Datasets:

mssongit

/

aiweb-dataset

like 0

전문분야 텍스트 ### 제목: 2008년도 “디지털콘텐츠(DC)대상” 시상식 개최 ### 본문: □ 문화체육관광부(장관 <NAME>)는 2008년 디지털콘텐츠 분야에서 두각을 나타낸 최우수작품을 선정하고, 12월 15일(월) 문화체육관광부 5층 독립예술영화관에서 "2008년 디지털콘텐츠 대상" 시상식을 개최했다. 대통령 상에 "<NAME> 디지털콘텐츠", 국무총리 상에 "웹 기반<NAME>상 편집기 플래온엠", "초감각 커플" 수상' '□"2008년 디지털콘텐츠 대상"은 2007년 4분기부터 2008년 3분기까지의 디지털콘텐츠 대상 수상작품 중 가장 우수한 작품을 시상하는 것으로, 이번 시상식에서 영예의 대통령 상에는 (주) 아사달의 "아사달 디지털콘텐츠", 국무총리 상에는 (주)엔 에이포의 "웹 기반<NAME>상 편집기 플래온엠", 그리고 (주) 크로스 필름과 (주) 옐로 엔터테인먼트가 공동제작한 "초감각 커플"이 각각 수상했다. □디자인 소스, 아이콘 및 설루션을 제작. 판매하는 (주) 아사달의 "아사달 디지털 콘텐츠"는 홈페이지 제작, 출판, PPT, 게임, 교육 등 다양한 콘텐츠 분야에서 사용자가 보다 쉽고 효과적으로 콘텐츠를 제작할 수 있도록 지원하는 온라인 정보 콘텐츠로 대통령 상을 수상했다. 특히 올해에는 50여 명의 디자이너와 개발자를 포함한 중국 법인을 설립하고 일본과 콘텐츠 공급계약을 체결하는 등 해외시장 개척에 박차를 가하고 있다. 이번 2008년 디지털콘텐츠 대상에서는 제품의 우수성, 기술력, 해외시장 진출 등에서 성공적인 사례를 선보였다는 평가를 받았으며, 향후 대만과 북미시장에도 동일한 서비스를 상용화할 예정이다.' 국무총리 상을 수상한 웹 기반<NAME>상 편집기 플래온엠은 웹 기반 서버사이드 기술과 웹 표준을 적용하여 사용자가 웹상에서 Active-X 등 별도의 프로그램을 설치하지 않고 바로 웹상에서 사용할 수 있는 웹 2.0 설루션이다. 이 작품은 휴대폰, PDA, IPTV 등 다양한 인터넷 디바이스와 연동이 가능하며, 사용자가 쉽게 멀티미디어 UCC를 제작할 수 있는 환경을 제공한다. 현재 SKT, KTF, G마켓 등 국내 통신사와 여러 업체에 설루션을 공급하여 7억여 원의 매출을 올렸으며, 향후에도 높은 수익성이 기대되고 있다.' 또한 국무총리 상을 수상한 (주) 크로스 필름, (주) 옐로 엔터테인먼트의 "초감각 커플"은 미스터리 HD 디지털 영화로, 실사영화에서 구현하기 힘든 판타지 부분에 애니메이션을 가미함으로써 영상 구현의 한계를 극복한 점이 돋보인다. o 특히, 저예산으로 제작되었으나 CJ CGV, CJ 미디어 등의 메이저 배급 및 마케팅팀이 결합되어 소자본 상업영화의 새로운 시장 실험 작품으로써 디지털 상영관 중심의 극장 개봉 후 관객들로부터 좋은 평가를 받고 있으며, 일본 All Rights 수출 계약 체결 등의 성과를 보이고 있다.' '□문화체육관광부는 국내 디지털콘텐츠 분야의 우수한 작품을 발굴, 홍보․마케팅과 국내외 시장 진출을 지원하기 위해 매 분기별 문화체육관광부 장관상을 수여하고 있으며, 수상업체들에게는 언론홍보 등의 마케팅 지원과 한국소프트웨어진흥원에서 주관하는 디지털콘텐츠 관련 사업 참여 시 가산점이 부과되며, 해외 전문교육 지원 등 다양한 특전이 주어진다.<|endoftext|>

전문분야 텍스트 ### 제목: 자전거로 전국 누비는 드림코리아 리포터단 모집 ### 본문: 자전거로 전국 누비는 드림코리아 리포터단 모집 o 문화체육관광부(장관 : <NAME>)는 자전거를 타고 전국을 누비며, 국민의 제안과 아이디어로 국가정책을 함께 만들어나가는 '위키' 방식 사이트「드림코리아」(www.dreamkorea.org)에 활발한 지식기부 활동을 해 줄 '드림코리아 자전거 리포터단'을 모집한다고 16일 밝혔다. o '드림코리아 자전거 리포터단'은 자전거를 타고 다닌 경험을 바탕으로 저탄소 녹색성장을 위한 다양한 아이디어를 제공하는 역할과 함께, 지역의 명소와 축제 등에 관한 내용을 취재하고<NAME>면서 정책을 제안하기도 하는 등 적극적인 참여자로서 활동할 예정이다. 시․도 단위로 운영될 리포터단은 드림코리아 사이트에서 상시 모집한다. 한편, 드림 코리아는 중요한 관련 행사가 있을 경우, 홈페이지에서 신청을 받아 소정의 심사를 거쳐 특별 리포터 팀을 구성, 운영할 계획이다. 환경올림픽'이라고 불리는 람사르총회는 자전거로 1차적으로 오는 28일부터 열리고, 특별 리포터 팀이 자전거를 타고 참여할 예정이다. 습지 보존에 대한 정보를 한눈에 파악할 수 있도록 코리아 사이트에 올려 공유할 수 있을 것으로 기대된다. o <NAME> 문화체육관광부 뉴미디어홍보과장은 "'자전거 리포터단'은 자전거를 타고 전국을 누비며 생생한 지역의 소식을 전하고, 자전거 이용자로서의 경험을 바탕으로 꼭 필요한 좋은 정책들을 제안하게 될 것"이라며 "친환경 교통수단인 자전거가 큰 관심을 받고 있는 상황에서 자전거 리포터단에 많은 관심이 모아질 것으로 기대한다"라고 밝혔다. 한편 문화체육관광부는 오는 19일 서울시청 앞 광장에서 자전거 여행가 <NAME> 씨 등이 참석한 가운데 드림코리아 자전거 리포터단 발대식을 개최할 예정이다.<|endoftext|>

전문분야 텍스트 ### 제목: “ 새 정부의 태권도 진흥 및 개혁방안 모색” ### 본문: 새 정부의 태권도 진흥 및 개혁 방안 모색" 문화체육관광부(장관 <NAME>)는 7월 25일(금) 14:00에 국립민속박물관 대강당에서 태권도 진흥 정책 토론회를 개최한다. 새 정부의 태권도 진흥 기본계획을 수립하기 위해 열리는 이번 토론회는 태권도 진흥 및 태권도공원 조성 등에 관한 법률에 의거해 태권도 진흥과 국기원 발전 방안을 주제로 한다. 정부에서 '08.6.22'부터 5개년 단위의 '태권도 진흥 기본계획'을 의무적으로 수립해야 한다. 이에 따라 문화체육관광부에서는 전문 연구 단체를 통해 연구용역을 진행해 왔고 그동안 도출된 연구 결과를 바탕으로 관련 전문가의 검증을 거치기 위해 토론회를 개최하게 되었다. 토론회에는 태권도학을 전공한 관련 전문가 등이 참석하여 태권도 종주국으로서의 위상 강화와 대외적 역할 확대, 태권도 올림픽 종목 유지를 위한 대책, 저변 확대, 문화산업과 관광산업 연계를 통한 발전 방안 등에 대해 집중적으로 논의될 예정이다. 또한 국기원을 비롯한 태권도계의 강도 높은 개혁과 발전방안도 제시될 예정이다. 금년 9월 4일 태권도의 날에 발표될 태권도 진흥 기본계획은 토론회를 통해 제시된 의견들을 반영하여 수립된다.<|endoftext|>

전문분야 텍스트 ### 제목: “ 도서관정보정책위원회 발족 ” ### 본문: " 도서관 정보정책 위원회 발족 " 정부는 도서관 정책의 주요 사항을 수립·심의·조정하기 위한 대통령 소속의 도서관 정보정책 위원회 위원장에 <NAME>(韓相完) 전 연세대학교 부총장을 위촉하고, 동 위원회 발족식을 6월 19일 오후 광화문 도렴빌딩에서 개최할 예정이다. 이번에 발족하는 도서관 정보정책 위원회는 지난 2006년 2월 27일 문화관광부 "공공도서관 정책 현황과 발전방안"에 대한 대통령 보고 시, 대통령께서 우리나라의 도서관 관련 정책을 여러 정부 부처에서 수행하는 관계로 조정·협의를 위한 튼실한 기구의 필요성을 강조하시고 도서관 정보정책 위원회의 소속을 대통령 소속 하에 두도록 지시한 바에 따른 것이다. 이후 관련 법제를 마련하기 위한 절차를 거쳐 금년 4월 시행된 도서관 법은 대통령 소속 도서관 정보정책 위원회 및 문화관광부 내 도서관 정보정책기획단 설립 등 정책 시스템의 전면 개편을 규정하고 있다. 지식 기반사회의 핵심 거점으로 도서관을 육성·지원하겠다는 참여 정부의 정책의지를 표방하며 발족한 동 위원회는 그동안 제기되었던 도서관 행정체계의 분산 문제를 해결할 수 있는 기반을 마련했다. 과거 '도서관 및 독서진흥 위원회' 등 여러 기구가 문화관광부 장관의 단순 자문 기구 역할에 국한되어 실질적인 운영이 되지 못한 한계가 있었으나 새로이 설립된 도서관 정보정책 위원회는 도서관 관련 정부부처의 장 및 민간 전문가를 위원으로 구성되어 범정부 차원의 정책 입안과 집행기구로서 필요한 법적 토대를 확보한 것이다. 「도서관 법」제12조에 의거 설치·운영되는 도서관 정보정책 위원회는 문화관광부, 교육인적자원부 등 13개 중앙행정기관의 장과 도서관에 관한 전문지식 및 경험이 풍부한 민간위원 등 26명으로 구성되었으며, 향후 도서관 정책은 동 위원회를 통하여 정부 각 부처에서 분산적으로 추진되는 도서관 정보정책을 국가 차원에서 협의·조정·평가 등을 통해 정책의 일관성과 종합성을 갖춤으로써 정책과 예산 집행의 효율성 제고를 기대하고 있다. 도서관 정보정책기획단은 또한 동 위원 회의 기능을 보좌하기 위해 문화관광부에 신설되었다. 단장을 포함한 3팀 25명으로 구성된 동 기획단은 문화부·교육부·행자부·정통부 등 여러 부처로 분산된 도서관 관련 정책을 통합·조정하게 된다. 정부에서는 도서관 정보정책 위원회 및 동 기획단의 발족으로 도서관 정책 관련 유관 법령 및 시책을 검토·조정하고 도서관 발전 종합 계획을 수립함으로써 관종을 통합하는 도서관 정책을 추진할 것이며, 특히 급속히 변화하고 있는 정보기술 환경에 도서관이 효과적으로 대응하도록 정보화 종합 계획을 수립·시행할 방침이다.<|endoftext|>

전문분야 텍스트 ### 제목: 2007「작은미술관」-여수공항 전시로 시작 ### 본문: 정부 과천 청사, 대전 한밭도서관, 국립어린이청소년도서관 등 8회 운영 국립현대미술관(관장: <NAME>)은 국민의 문화향수권 신장을 위해 전시장 밖 전시 조성 사업의 일환으로 운영 중인「작은 미술관」 Small Art Museum을 올해, 2월 23일 아름다운 한려수도 전남 여수공항을 시작으로 총 8회 진행한다. 금년도 첫 전시가 열리는 여수시는 인근 국가산업단지와 더불어 바다에 인접한 남도만의 아름다움을 간직한, 문화와 산업이 어우러진 고장으로, 작은 미술관은 여수시에 소재한 여수공항 대합실에서 열린다. 『현대미술과 한국미술』이라는 주제로 열리는 본 전시는 우리나라만이 지니고 있는 자연미와 그 속에 공존하며 살아가는 사람들의 현대적 미학을 보여주는 작품들로 구성된다. 한국화 17점, 서양화 15점, 문인화 2점, 판화 5점 및 조각 7점, 공예 및 사진 6점 등 한국미를 알리는 작품 50여 점이 전시된다. 이를 통해 남도의 아름다운 경치와 우리 작가들의 조형미를 동시에 감상할 수 있는 기회가 제공될 것으로 기대된다. 2012년 세계 해양엑스포 유치를 위해 적극적인 노력을 하고 있는 여수시의 관문 격인 여수공항에 작은 미술관을 조성함으로써 공항을 통해 입국하는 외국인 실사단과 내·외국인 관광객의 많은 관심과 호평을 받을 것으로 기대된다.<|endoftext|>

전문분야 텍스트 ### 제목: 국립국어원, 국민의 국어능력 실태 조사 실시 ### 본문: 문화관광부 국립국어원(원장 <NAME>)은 30년 만에 국민의 국어능력 실태 조사를 실시하는데, 이는 국민의 문맹률, 문해능력 조사이다. 한국어의 국제적 위상은 프랑스어, 이탈리아어와 비슷한 세계 10위권이고 외국에서 한국어를 배우려는 사람들이 하루가 다르게 증가하고 있다. 한국어가 2007년 9월 세계 지식 재산권 기구에 의해 영어, 스페인어, 아랍어에 이어 세계에서 아홉 번째로 국제 공개어로 채택됨으로써 명실상부한 국제어로 부상하게 되었다. 하지만 국내 상황은 외래어·외국어의 유입과 범람이 심해지면서 한국어에 대한 자긍심이 점차 약해지고 있으며, 외국어 교육이 강조되면서 외국어 학습의 기초인 모국어 능력의 중요성이 간과되고 있다. 또 우리 국민들의 국어능력은 매우 우려되는 수준으로 보고 있는데, 서울의 초등학교 36학년 학생 100명 중 3~4명이 한글을 해독하는 데 어려움을 겪고 있는 것으로 나타났다. 또한 다문화가정 자녀들의 대다수가 우리말과 글을 쓰는 데 어려움을 겪고 있는 것으로 알려져 이들의 국어능력 향상을 위한 다양한 정책이 절실한 실정이다. 이에 국립국어원은 국어기본법에 의거하여 국민의 국어능력에 대한 실태조사를 하려고 한다. 이는 객관적인 조사 결과를 바탕으로 위기에 처한 국민의 국어능력을 향상시키기 위한 실효성 있는 정책을 펴 나가기 위함이다. 이번 조사는 오는 2~3월의 예비조사와 5~6월의 본 조사로 나누어 진행되며, 문맹 여부와 문해능력의 정도를 측정할 것이다. 가정과 직장에서 일상생활을 영위하는 데 필요한 문서 해석 능력을 문해능력이라고 한다. 선진국의 경우 의무 교육 취학률이 거의 100%에 달하기 때문에 문맹 여부보다는 문해능력에 초점을 맞춘 언어능력 조사가 일반적이다. 이는 산업사회를 지나 고도의 지식정보화 사회로 진입하면서 나타나는 자연스러운 현상으로 문해력을 향상시킴으로써 국가 경쟁력을 높이고 이러한 조사 결과를 바탕으로 보다 다양한 정책을 펼 수 있기 때문이다. 예비조사를 통해 성인 500명, 초등학교 6학년 생 300명을 대상으로 질문지를 수정하고 보완하여 본 조사를 실시할 계획이다. 본조 사는 성인 4,500명과 초등학생 1,700명을 대상으로 오는 5월 실시하게 된다. 이번 국어능력 실태 조사가 이루어지면 1970년 통계청 조사 이래 30여 년 만에 처음으로 문맹률에 대한 객관적이고 과학적인 통계치가 나오게 된다. 이를 바탕으로 국립국어원은 비문해자를 대상으로 한 문해 교육, 국제결혼 이주여성과 그 자녀에 대한 대책 마련 등 국민 전반의 국어능력을 향상시키기 위한 다양한 정책을 수립·시행하고 제안할 계획이다. 또한 유네스코 등 관련 국제기구에도 정확한 문맹률 통계치를 제공하게 된다. 최근 구미 선진국에서는 다양한 문해능력에 대한 연구와 실태조사가 국가적 차원에서 이루어지고 있다. 이러한 추세에 맞추어 우리나라도 국민의 국어능력 향상을 위해 문해능력을 규명하고 국어능력 향상을 위한 대책을 시급히 세워야 한다. 한국어가 국가 발전의 원동력인 이 시대에 국민의 튼튼한 국어능력은 국가 경쟁력 강화를 위해서도 필요하다. 이런 현실 인식을 바탕으로 한 이번 국어능력 실태 조사가 이루어졌다. 한편 국립국어원은 앞으로 5년마다 국민의 국어능력 실태를 조사해 국어능력의 변화 추이를 분석하고 이에 따라 국민의 국어능력 향상을 위한 정책을 시행할 계획이다.<|endoftext|>

전문분야 텍스트 ### 제목: 게임위, ‘윈도우 비스타’내장 게임물에 첫 등급분류 신청 받아 ### 본문: 개인용 컴퓨터(PC) 운용체제(OS)의 내장 게임물도 앞으로는 등급 분류를 받아야 유통이 가능할 것으로 보인다. 2일 게임물 등급 위원회(약칭 '게임위', 위원장 <NAME>)에 따르면, 개인용 컴퓨터 운용체제로는 처음으로 미국 마이크로소프트(MS) 사의 '윈도 비스타' 내장 게임물의 등급 분류 신청이 최근 접수됐다. 이번 신청은 지난 2월 6일 게임위가 '윈도 비스타'에 포함된 여러 종류의 게임물에 대해 등급 분류 신청을 해 줄 것을 정식으로 요청한 데 따른 것이다. 게임위는 "윈도 비스타에 내장된 여러 종류의 게임물도 '게임산업진흥에 관한 법률'에 따라 등급 분류 대상이 되며, 등급을 받은 게임물은 등급 내용 정보를 표시해야 한다"라고 밝혔다. 이에 따라 개인용 컴퓨터 운용체제의 내장 게임물도 등급 분류를 받아야 유통이 가능해졌다. 이번에 신청한 '윈도 비스타'의 내장 게임물은 '체스', '카드놀이', '지뢰 찾기', '하트', '프리셀', '구슬 넣기', '스파이더 카드놀이', '스파이더 카드놀이', '스파이더 카드놀이', '마작' 등 9종이다. 앞으로 게임위는 개인용 컴퓨터 운용체제 외에 모바일폰, 휴대형 멀티미디어 플레이어(PMP), 디지털 셋톱박스 등의 내장 게임물에 대해서도 등급 분류 신청을 받아 등급을 부여할 방침이다. 또한 게임위는 내장 게임물에 대한 등급 분류를 통해 과몰입 등 여러 문제를 예방할 수 있을 것으로 기대했다. 한편, 게임위는 청소년 보호를 위해 '윈도 비스타'에 보호자 제어 기능(Parental Control)을 부여하는 방안을 MS 사와 협의 중인데, 상당한 진전이 이루어진 것으로 알려졌다.<|endoftext|>

전문분야 텍스트 ### 제목: 태권도, 대한민국을 대표하는 세계적 문화자산으로 육성” ### 본문: 문화체육관광부(장관 <NAME>는 태권도 진흥 및 태권도공원 조성 등에 관한 법률 시행('08.6.22)에 따른 태권도진흥 기본계획('09~'13)을 수립·발표하면서 "태권도, 대한민국을 대표하는 세계적 문화자산으로 육성" 하겠다고 밝혔다. 이번에 수립·발표된 태권도진흥 기본계획은 태권도 진흥을 위한 기본방향, 태권도의 세계화, 국기 태권도 정립을 위한 기반 강화, 저변 확대, 세계적 문화산업 및 관광브랜드화 등을 담고 있는 최초의 정부 차원의 태권도 전반을 포괄하는 종합 계획이자 법정계획이다. 관계 기관과 협의하여 2013년까지 3185억 원을 연차 투자할 계획이며, 사업비는 관계 기관과 협의해 확보할 예정이다. 비 <NAME>, 대한민국을 대표하는 세계적 문화자산 - 스포츠의 영역을 넘어 전통, 문화, 산업을 포괄하는 복합 문화자산으로 육성 - ❏ 4대 중점 추진전략 전략 1 : 태권도의 세계화 전략 2 : 국기 태권도 정립을 위한 기반 강화 전략 3 : 전 국민이 즐기는 생활 스포츠로 저변 확대 전략 4 : 세계적인 문화산업 및 관광 브랜드화 세계화 강화 태권도의 세계화 기반 강화 국기 태권도 정립을 위한 기반 강화 저변 확대 전 국민이 즐기는 생활스포츠 저변 확대 기반 강화 태권도 산업 촉진 세계적 문화산업 및 관광 브랜드화 대한민국을 대표하는 세계적 문화자산 스포츠의 영역을 넘어 전통, 문화, 산업까지 포괄하는 복합적 자산으로 육성 태권도는 우리 민족의 얼과 슬기를 담아 심신을 연마해 온 전통무예이자 세계 188개국 7천여만 명이 수련하고 있는 우리나라의 대표적인 문화브랜드로서 21세기 스포츠·문화·관광산업의 핵심 콘텐츠로 성장할 최상의 문화 동력이 될 것으로 평가되고 있다. 「태권도진흥 기본계획」은 이러한 국가 발전을 견인할 태권도를 위하여 정부가 향후 2009년부터 2013년까지 5년간 시행할 종합 마스터플랜(Master Plan)으로서 비전 및 이를 달성하기 위한 중점 추진과제(Action Plan)의 내용을 담고 있다. 태권도, 대한민국을 대표하는 세계적 문화자산이라는 비전을 세우고, 이를 달성하기 위한 4대 추진전략, 14개 중점 추진과제를 이번 종합 계획에서 제시하고 있다. 비전 달성을 위한 4대 추진전략 및 14개 중점 추진과제 I-1. 태권도의 세계화 I-1. 비전 달성을 위한 4대 추진전략 및 14개 추진과제 올림픽 코어(Core) 종목 유지를 위한 네트워크 구축 I-2. 글로벌 스포츠 지원 시스템 정비(IOC 기준 충족) I-3. 태권도의 전략적 해외 진출 II-1. 태권도의 인류문화사적 가치 및 정체성 규명 II-2. 태권도의 전략적 해외 진출 II-1. 국기 태권도 정립을 위한 기반 구축 II-2. 태권도 단체 간 역할 및 협력체계 구축 II-3. 승품단 심사 및 경기 제도 선진화 II-4. 전 국민이 즐기는 생활 스포츠로 저변 확대 III-1. 성인과 가족이 참여하는 생활밀착형 스포츠 보급 III-2. 태권도 사이버 월드 구축 III-1. 태권도 사이버 월드 구축 III-2. 학교 및 소외계층에 태권도 보급 확대 III-3. 태권도의 실용적 기능 개발 III-4. 태권도장 경영 활성화 지원 VI. 세계적인 문화 산업 및 관광브랜드화 VI-1. 태권도 한류 관광 거점시설 확충 VI-2. 세계인의 태권도 축제 및 문화상품 개발 Ⅵ-3. 태권도의 문화산업 원천 소재화 및 예술창작 지원 전략 1 (태권도의 세계화〕: 유도 등 경쟁 종목에 앞서는 글로벌 스포츠 IOC는 2013년 총회에서 기존 28개 올림픽 종목을 25개 코어(Core) 종목으로 축소할 예정이다. 정부는 태권도를 올림픽 코어 종목으로 유지함은 물론 유도 등 유사종목에 월등히 앞서는 세계적인 스포츠 종목으로 육성하기 위하여 IOC가 요구하는 글로벌 스탠더드 확보, WTF, 국기원 등 관련 단체의 글로벌 지원 시스템 구축 등의 방안을 마련하고, 태권도의 전략적 해외 진출을 확대하는 정책을 수립하였으며 이러한 정책들은 '<NAME> IOC 선수위원' 당선을 계기로 탄력을 받게 될 것으로 예상된다. ▶중점 추진과제 1 : 올림픽 Core 종목 유지를 위한 네트워크 구축 ⋅ IOC 스포츠⋅교육⋅문화포럼, 태권도의 날 등 계기 홍보 ⋅ WTF 연락사무소 전문 인력 배치 등 기능 확충(스위스 로잔) ⋅ 해외 한국 문화원의 태권도 보급 전진기지화(2013년까지 100억 원 투자) ⋅ 해외 태권도장 전통 인테리어 및 소재 개발 ▶ 중점 주진 과제 2 : 글로벌 스포츠 지원 시스템 정비 ⋅ WTF 개방성 확대(사무국의 국제화 추진) ⋅ 해외 단증 발급 시스템 개선 ⋅ 세계 태권도 아카데미(WTA) 설립(태권도 공원 내) ▶ 중점 추진과제 3 : 태권도의 전략적 해외 진출 확대 ⋅ 국가대표 태권도 시범단 창설⋅운영(2013년까지 50억 원 투자) ⋅ 국내 전문 인력의 해외 취업 지원(연간 10억 원) 및 해외 취업박람회 개최 ⋅ 개도국 태권도 용품 지원 및 사범 파견(연간 10억 원) 전략 2 : 국기 태권도 정립을 위한 선순환 시스템 구축 태권도는 우리나라의 전통무예이나 중국, 일본 등이 자국 기원설을 주장하는 등 인문학적 기반 취약에 따른 많은 문제점이 제기되고 있다. 한국의 전통무예인 태권도의 학문적 기반 강화를 위한 정책과 태권도 성립 후 약 40년이라는 짧은 기간에 세계적 스포츠로 급속하게 발전하는 과정에서 야기된 국내외 혼선 및 문제점을 개선할 수 있는 정책적 개선방안을 담고 있다. 국기원, 세계태권도연맹, 대한 태권도 협회, 태권도진흥재단의 역할을 경기부문, 무도 부문, 산업부 문의 3대 축으로 나누어 발전적 선순환 구조를 구축한다. 특히 국기원을 '세계 태권도 중앙도장'으로 취지를 살려 무도의 본산으로 육성하고 승품단 심사 등 경기 제도를 선진화한다. 중점 추진과제 1 : 태권도의 인류 문화사적 가치 및 정체성 규명 ⋅ 태권도학 정립을 위한 연구 지원 ⋅ 무술 관련 역사, 인문학 기반의 국제 학술 콘퍼런스 및 포럼 개최(연 1회) ⋅ 태권도 학회 설립 및 학술지 발간 ▶ 중점 추진과제 2 : 태권도 단체 간 역할 및 협력체계 구축 ⋅ 3대 기능 중심의 단체 간 역할 분담 (경기) : WTF, KTF, (무도 및 역사) : 국기원, (산업) : 태권도진흥재단 ⋅ 단체 간 상설 공동협의체 운영 ⋅ 국기원을 무도(武道)의 본산으로 육성(기능 강화, 법정법인화에 따른 공공성 강화) ▶ 중점 추진과제 3 : 승품⋅단 심사 및 경기 제도 선진화 ⋅ 단증 발급 온라인 시스템 도입 및 심사비 공시제 도입 ⋅ 국내⋅외 경기 규칙 심판 규정 통일로 판정 시비 개선 (심판 제도 개선 및 심판 교육 프로그램 표준화 지원) ⋅ 태권도 '사이버 월드' 구축 전략 3 : 전 국민이 참여하는 생활밀착형 스포츠로 저변 확대 태권도는 해외에서 대한민국=태권도라고 인식될 정도의 세계적 인지도를 보유하고 있음에도 정작 종주국인 우리나라에서는 수련인구 전체의 80 % 가 어린이일 정도로 중⋅장년층에서 외면받고 있다. 이러한 편중된 태권도 수련 현상을 극복하고 수련인구를 단기간에 23배로 늘리고 고립된 개인 위주의 가족관계를 극복하는 새로운 문화 트렌드로 육성한다. 학교 태권도를 정립하고, 소외계층에 대한 태권도 보급 등 태권도의 공공적 기능과 실용적 기능을 강화하며, 태권도장 경영 활성화를 지원하는 정책을 마련한다. 중점 추진과제 1 : 성인⋅가족이 참여하는 생활밀착형 스포츠 보급 ⋅ 가족 수련 프로그램 개발 및 캠페인 전개 ⋅ "Best 태권 가족 선발대회"개최 ⋅ 태권도 이 러닝(e-Learning) 프로그램 개발 ⋅ 전국 단위 생활체육 태권도 경연 대회 개최 ▶ 중점 추진과제 2 : 학교 소외계층 태권도 보급 확대 ⋅ 학교 체육 태권도 프로그램 개발 ⋅ 학교 순회 "태권도 교육 시범단" 운영 ⋅ 소외계층을 위한 "태권도 바우처"도입 ▶ 중점 추진과제 3 : 태권도의 실용적 기능 개발 ⋅ 태권도 명상수련, 심리치료, 예술치료 프로그램 개발 ⋅ 태권도 운동처방(클리닉) 시범사업 ▶ 중점 추진과제 4 : 태권도장 경영 활성화 지원 ⋅ 태권도장의 학교⋅사회교육 지원센터화 ⋅ 일선 태권도 경영개선 지원을 위한 도장 경영포럼 개최(지역별 연간 4회) ⋅ 우수 도장 경영자상 제정(태권도의 날 등과 연계) ⋅ 도장시설 개선 융자사업(스포츠산업 융자사업 등과 연계) 전략 4 : 제2, 제3의 로봇 태권 V 등 콘텐츠 산업 및 태권 한류 관광 촉진 태권도는 애니메이션 로봇 태권 V, 뮤지컬 JUMP 등 성공에서 알 수 있듯이 단순 스포츠를 넘어 대한민국을 상징하는 높은 브랜드 가치와 문화산업으로의 발전 잠재력을 가지고 있고, '종주국' 프리미엄을 통해 많은 해외 관광객을 유치할 수 있다는 장점을 가지고 있다. 이러한 연관 산업으로의 발전을 견인할 수 있는 콘텐츠와 세계적 문화이벤트 개발 등 관광 및 산업 발전방안을 제시한다. 이를 위해 수도권에 태권도 상설공연장을 건립하여 외국인을 위한 연간 상시 공연 상품화하고, 승품단 심사를 지역별 명품 의례 축제로 개발하고, 국제 프로태권도대회 창설을 검토한다. 태권도 소재의 만화. 애니메이션 등 킬러 콘텐츠와 공연예술 창작을 지원한다. 중점 추진과제 1 : 태권도 한류 관광 거점시설 확충 ⋅ 태권도 공원을 세계 태권도인의 성지로 조성(총 사업비 6,009억 원) ⋅ 수도권에 태권도 상설 공연장 건립 ▶ 중점 추진과제 2 : 세계인의 태권도 축제 및 관광상품 개발 ⋅"태권도의 날(9월 4일)", "세계 태권도 문화엑스포"를 태권도 분야 대표 축제로 개발 ⋅국제 프로태권도 대회(World Series) 창설 ⋅승품⋅단 심사를 지역별 명품 의례 축제로 개발(주말 전용 경기장 지정) ▶ 중점 추진과제 2 : 세계인의 태권도 축제 및 관광상품 개발 ⋅ 태권도 고증을 통한 "문화 원형 발굴사업" ⋅ 태권도 소재 킬러 콘텐츠 개발사업 ⋅ 태권도 응용예술 창작 활성화 사업(뮤지컬, 행위예술 등) 정부는 기본계획의 수립을 위하여 태권도 관련 단체, 학계 및 현장 전문가 그리고 토론회 등을 통해 의견을 수렴해 왔다. 앞으로 문화체육관광부는 태권도 종주국으로서의 위상을 높이고 세계인이 인정하는 스포츠로 자리매김할 수 있도록 태권도진흥 기본계획을 차질 없이 추진해 나갈 계획이다.<|endoftext|>

전문분야 텍스트 ### 제목: 이 달(4월)의 우수 신인음반 선정 ### 본문: 이 달(4월)의 우수 신인음반으로 뽑혔다. 4월의 우수 신인음반으로 문화관광부(장관 <NAME>)와 한국 문화콘텐츠진흥원(원장 <NAME>은 포코스(<NAME>)"의 Recall to One, s mind- (주) 제이에이치코오스 미디어 제작-을 선정했다. 3일 오전 11시 문화관광부 차관실에서 <NAME> 차관이 참석한 가운데 시상식이 열렸다. 1차 전문가 심사에서 "<NAME>(sei)", "<NAME>와 함께 최종 후보로 선정된 Recall to One, s mind는 4월 한 달간 케이블 TV 엠넷(m.net)과 음악전문 포털사이트인 엠넷닷컴 등 온 오프라인에서 홍보된다. 이후 실시된 2차 누리꾼 투표에서 총 53,343표 중 26,721표(50 % )의 지지를 얻어 4월의 우수 신인음반으로 선정됐다. <NAME>의 소속사 소장 중 (주) 제이에이치코오스 미디어 대표는 "이번 수상은 이제 막 가요계에 발을 들여놓은 신인가수에게는 든든한 버팀목과 같다"라며 "소수의 톱스타가 한국 가요계를 이끌어가는 현실에서 신인에게는 생각보다 많은 기회가 주어지지 않지만 이번 수상을 계기로 <NAME>가 활발하게 활동할 수 있도록 노력을 아끼지 않겠다"라고 말했다. 팝 발라드, 마이너 발라드 등 다양한 음악성을 지닌 신인가수 <NAME>는 서로 다른 장르의 음악생활을 하던 <NAME>, <NAME>, <NAME> 총 4명으로 이루어진 팀이다. 특히 그룹명은 4가지 각기 다른 우주라는 뜻을 담고 있는데 한국인은 3명, 일본인은 1명이다. 지난 3월 2일 발매된 데뷔 앨범 Recall to One, s mind는 4명의 하모니가 집약된 11곡과 각자의 색깔과 개성을 담아 부른 솔로곡 4곡으로 구성되어 있다. 플라이 투 더 스카이 등의 앨범에 참여했던 작곡가 <NAME>과<NAME>가 참여해 앨범의 완성도를 높였다. 한편 국내 음반시장에 새로운 활기를 불어넣기 위해 진행되고 있는 신인음반 발굴 및 홍보 지원 사업 '이 달의 우수 신인음반 선정 사업'은 누리집(www.mnet.com/hotpick)을 새롭게 열고, 엠넷(M.net)과 일간 스포츠를 비롯한 각종 유무선 매체를 통해 적극적으로 사업 홍보에 나서고 있다. ※문화관광부가 주관하는 이번 달의 우수 신인음반 선정 사업은 침체된 국내 음반시장을 활성화하고 음악산업의 창작 기반을 마련하는 데 그 목적이 있다. 문화관광부는 매월 우수한 신인음반을 선정하여 홍보 및 프로모션을 지원함으로써 신인 음악 콘텐츠의 양적 질적 향상을 돕고 있다. 지난 3월에는 신인가수 윤형렬의 윤형렬 1: (편안할:일) 집- <NAME> 제작- 이 우수 신인음반에 선정되어 언론이나 방송에서 큰 인기를 끌었다.<|endoftext|>

전문분야 텍스트 ### 제목: “문화부, P2P · 웹하드 총 31개 업체에 과태료 부과” ### 본문: "문화부, P2P · 웹하드 총 31개 업체에 과태료 부과" 문화관광부(장관 <NAME>)는 특수한 유형의 '온라인 서비스 제공자'(이하 "OSP")의 영화·음악 저작물에 대한 기술적 조치 4차 모니터링('07.12.5~12.8) 결과에 따라 총 31개 P2P·웹하드 업체에 210만 원에서 2,500만 원까지 과태료를 차등 부과했다. 이번 과태료는 작년 8월부터 11월까지 3차례 걸친 모니터링과 경고에도 불구하고 4차 모니터링에서 충분한 기술적 조치(미 차단율 5% 이하)를 취하지 않은 업체에 부과되었으며, 4차 모니터링 대상 38개 업체 중 31개 업체가 해당되었다.필터링율이 높은 5개 업체, 사이트가 폐쇄된 2개 업체 등 총 7개 업체가 과태료를 내지 않았지만, 최고액 2,500만 원을 부과 받은 곳은 2개 업체이다. 업체별 결과 별첨 참조(업체명 영문 머리글자 등 표기) 문화부는 이번 과태료 부과 전에 '07.12.14일 과태료 예정 금액 등을 통보하고 12일간('07.12.17~28) 의견 진술 기간을 두었다. 업체 의견 중 음원 DNA 기술 도입 등 자구 노력을 충분히 소명하였거나 영세 사업자(연 매출 4,800만 원 이하, 부가가치세법상 간이과세대상자 기준 인용) 임을 증명한 경우 이를 반영하여 과태료 예정 금액의 20~30%를 감경하였다. 이번에 과태료를 부과 받은 업체는 처분을 받은 날로부터 30일 이내에 이의 제기를 할 수 있으며, 이 경우 해당 사항은 법원에 통보되어 비송사건절차법에 따른 과태료 재판을 받게 된다. 이의 제기를 하지 않고 기한 내 과태료를 내지 않을 경우 국세 체납처분의 예에 따라 징수된다. 이번 4차 모니터링 결과 전체적으로 영화부문에서 지난 1·2·3차 모니터링에 비해 기술적 조치가 크게 향상된 것으로 나타났는데, 이는 지난 1·2차 모니터링과 비교했을 때이다. 음악의 경우도 상대적으로 양호한 상태를 유지했다. 영화(50편)의 경우 조사대상 전체 사이트에서 평균 32.5% (1차 67.6% 2차 59.2% 3차 44% 4차 44% )를 다운로드 가능하여 최초 1차 모니터링('07. 8월)에 비해 35% p 이상 나아졌다. 음악(100곡)의 경우 미차단율이 평균 11.2%로 3차(26.3%)에 비해 소폭(3% ) 개선되어 3차보다 계속해서 나아졌음을 알 수 있다. 이는 정부의 과태료 부과 조치에 민감하게 반응하는 P2P·웹하드 업계가 필터링율을 높이고 정부의 적극적인 불법 저작물 근절 의지가 어느 정도 성과를 내고 있는 것으로 보인다. 문화부는 앞으로 영화·음악뿐 아니라 게임·출판·방송 저작물까지 P2P·웹하드의 기술적 조치에 대한 모니터링을 확대한다는 계획이며, 포털에 대한 삭제 명령권 발동(저작권법 제133조) 등도 병행하여 추진해 온라인상의 불법 저작물 근절을 강화해 나간다는 방침이다.<|endoftext|>

전문분야 텍스트 ### 제목: 즐거운 성탄절과 연말연시는 대한민국 구석구석에서!! ### 본문: 문화관광부(장관 <NAME>)와 한국관광공사(사장 <NAME>)는 국내관광 활성화를 위하여 성탄절 및 연말연시에 가볼 만한 명소를 선정, 이들 명소를 주요 코스로 하는 국내여행상품을 국내여행사연합회와 공동개발하고, 추첨에 의해 명소 방문자에게 경품을 제공하는'구석구석 둘러보기 (Travel Rally Korea-season 1)'행사를 개최한다.오는 12월 15일부터 2008년 1월 14일까지 한 달간 진행되는 '구석구석 둘러보기 (Travel Rally Korea-season 1)'은 구석구석 둘러보기 (Travel Rally Korea-season 1)은 주문진 소돌바위, 안면도 안면암, 울산 대왕암, 울릉도 독도일출전망대 4개소의 일출 일몰 명소, 서천 마량진, 부안 내소사 숲길, 대전 장태산 자연 휴양림 3개소의 크리스마스 명소와 문경 온천, 산청 참숯굴, 당진 왜목마을 3개소 의 따뜻한 겨울이라는 3가지 테마로 나뉘어 총 10개 명소에서 진행된다.(그림 울산 대왕암)위의 명소를 방문하여 현장에 비치된 응모함에 접수하거나 현장 포토존을 배경으로 촬영한 사진을 이벤트 페이지(www.visitkorea.or.kr)에 등록하면 본 행사에 참여할 수 있다. 약 200명에게 3,000만 원 상당의 경품이 준비된 이번 이벤트에는 가장 많은 지역을 방문한 관광객에는 부상으로 150만 원 상당의 황금카드 등이 주어지게 되며, 최다지역 방문자 상위 100명에게도 행사 기념품 및 지방 토산품이 주어지게 된다. 1개 지역만을 방문해도 추첨권이 주어지며, 사진 및 수기공모 이벤트 등을 통해서도 국내 여행상품권 및 다양한 기념품들이 참가자들에게 주어질 계획이다.이와 더불어, 문화관광부와 한국관광공사는 국내여행사연합회와 손을 잡고 해외여행 수요를 국내로<NAME>기 위하여 성탄절과 연말연시에 『추천 가볼 만한 곳』을 중심으로 국내여행상품을 개발하였다. "남원 국악캐럴음악회와 임실 치즈 만들기"와 같은 성탄절 상품 9개와 "해남 땅끝마을 해돋이와 대흥사 기차여행"등의 신년상품 6개로 구성되어 있으며, 여행상품 참가후기를 올린 상품 구매자 50명에게는 한국관광공사에서 주최하는 "구석구석 국내여행"에 무료 초청(1인동반 가능)할 계획이다.문화관광부와 한국관광공사는 올해 연말연시 해외여행이 사상 최대로 12월 출국자가 작년대비 30 % 증가할 것으로 예상되는 가운데, 구석구석 둘러보기 (Travel Rally Korea-season 1) 이벤트와 성탄절 및 연말연시 국내여행상품 개발로 해외여행 수요를 국내로<NAME>고 국민들의 다양한 여행욕구를 충족시킬 수 있을 것으로 기대하고 있다.<|endoftext|>

전문분야 텍스트 ### 제목: 2008 한스타일 박람회 ### 본문: 2008 한스타일 박람회 - 이달 7월 31일(목)부터 8월 3일(일)까지 코엑스 태평양홀에서 개최 - 한글, 한식, 한복, 한옥, 한지, 한국음악 등 6개 분야 전통문화 대표 콘텐츠 참여 - 아시아청소년축전, 국악콘서트, 한글체험전 등 다채로운 공연과 체험 진행 박람회 개요 문화체육관광부(장관 <NAME>)는 농림수산식품부, 국토해양부, 전주시와 공동으로 2008년 7월 31일(목)부터 8월 3일(일)까지 코엑스 태평양홀에서 '2008 한스타일박람회'를 개최한다. '한스타일'은 우리 문화 원류로서 대표성과 상징성을 갖는 전통문화 중 산업화 가능성과 세계화 필요성이 높은 한글, 한식, 한복, 한옥, 한지, 한국음악 6개 부문을 선정하여 정책적 지원을 함으로써 부가가치와 국가 이미지를 높이는 사업이다. '2008 한스타일박람회'는 우리의 전통문화를 현대적 콘텐츠 산업으로 발전시킨 분야별 우수 기업이 참여하여 한스타일 산업의 현재의 미션과 미래의 비전을 제시하게 되며, 이번 박람회는 88개 업체 350부스(주제관 포함)가 참여한다.문화체육관광부는 이를 통해 전통문화콘텐츠 산업의 역량을 결집하고 우수 콘텐츠를 발굴, 확산하여 생활화, 산업화, 세계화에 계량할 수 있는 성과를 이루겠다는 전략을 갖고 있다. 또한 이번 박람회에는 비즈니스 프로그램에 집중하여 전통문화산업 종사자에게 실질적인 이익이 돌아갈 수 있도록 하겠다는 계획이다.각 분야별로 국내외 바이어와 업계 종사자를 초청해 1대1 미팅과 공개 프레젠테이션, 기업탐방 프로그램 등이 진행된다. 한스타일 대표 브랜드 참여는 한글부문에서는 대표적인 캘리그라피 업체인 '필묵'(영화 '복수는 나의 것', 서적 '봉순이언니' 제목글씨를 제작)이, 한식부문에서는 전주전통비빔밥 프랜차이즈인 '고궁F&B'가 담당한다. 한복은 생활한복 브랜드 '돌실나이'가 이미 참여 의사를 밝혔고, 한옥은 경주 한옥호텔 라궁을 시공한 '이연건축'이 함께한다. 한지에서는 우리나라 대표 한지제조사인 '천양제지'가 참여해 한지의 우수성과 다양한 활용 방법을 소개할 예정이다. 한국음악에서는 국내 최대 국악기제조사인 '난계국악기제작촌'에서 현대적 국악기 전시와 체험을 할 수 있다. 박람회를 즐기는 7가지 Tip 먼저 '2008 한스타일박람회' 엠블럼은 TV드라마 '대왕세종', '엄마가 뿔났다' 등을 쓴 캘리그라퍼 <NAME>님의 작품으로 세련되면서도 자유로운 느낌을 준다. '아시아청소년축전'은 아시아 22개국 청소년들이 모여 진행하는 프로그램으로 각 국의 문화를 박람회에 선보이게 된다.이는 박람회의 컨셉인 문화의 일방적 이식과 단편적 콘텐츠의 수출보다는 문화의 다양성과 교류의 쌍방향성을 실현한 기획이기도 하다. 이들은 물론 자국의 음식, 의상, 공연 문화를 소개함과 동시에 우리의 문화를 체험하는 기회를 갖는다. 한옥 테마관은 자체로도 명물이지만 제작과정이 기록될 만한 가치가 있다. 주춧돌부터 추녀, 용마루, 기와까지 실제 한옥을 건축하는 것은 무대세트처럼 외관만 한옥스럽게 짓는 것이 아니다. 현대식 공법을 적용해 단 3일 만에 135m2 넓이의 한옥 한 채를 짓는 것이 관건이다. 이를 위해 전국에서 실력 있는 12개 업체가 모여 협력하여 지은 <NAME>이 곧 뉴욕으로 날아간다. 한지로 꾸며진 UN <NAME> 사무총장의 관저 게스트룸. 당시 인테리어를 담당했던 전주 '지담'팀이 박람회장에 그 게스트룸을 그대로 재현한다. 한지등과 예술 벽지로 우리 한지 고유의 은은하고 우아한 분위기를 연출한다. 한식 부문에서는 독특한 소재가 눈길을 끈다. 한국전통음식연구소에서 중국인과 일본인의 입맛에 맞는 한식메뉴를 개발하여 선보이는 것이다. 보양식을 선호하는 중국인을 위해 궁중대하잣즙냉채와 장어잡채 등 20여 가지 메뉴를 선보이고 깔끔한 맛을 선호하는 일본인에게는 해물전골 등 20여 가지 메뉴를 준비했다. 우리 입맛과 어떻게 다른지 비교 시식해 보는 것이 관전 포인트. 한복 부문은 실용적인 아이템으로 짜여 있다. 한산모시테크놀로지가 개발한 신소재를 직접 만져볼 수 있는 코너. 한복 생활화를 위해 구김이 적고 물빨래가 가능한 신소재가 첫선을 보인다. 눈으로 확인할 수 없는 까닭에 손으로 직접 확인할 수 있게 만들었다. 국악콘서트도 열린다. 퓨전 해금주자 '<NAME>'과 '<NAME> 출신의 피리주자 '<NAME'가 무대에 오른다. 본명보다 '<NAME>'으로 더 유명한 엽기 판소리 '<NAME'도 국악의 대중화에 동참한다. 박람회 기간 동안 무대에 서는 팀은 어린이 국악연주단 'ATTI' 등 12개 팀이다.<|endoftext|>

전문분야 텍스트 ### 제목: Django 자습 ### 본문: Django 자습, 요약, 정리 출처 참고 서적 Django로 배우는 쉽고 빠른 웹 개발 - 파이썬 웹 프로그래밍 Django를 활용한 쉽고 빠른 웹 개발 - 파이썬 웹 프로그래밍 [실전 편] Tango With Django A beginner's Guide to Web Development With Python Django 1.9 Two Scoops of Django - Best Practices for Django 1.8 Mastering Django Core The Complete Guide to Django 1.8 LTS Django by Example Web Development with Django Cookbook, 2nd Django Design Pattern s and Best Practices Django Unleashed 소스코드 Test-Driven Development with Python Lightweight Django Using REST, WebSockets, and Backbone Learning Django Web Development 강좌 및 팁 사이트 장고 걸스 튜토리얼 날로 먹는 Django 웹 프레임워크 강좌 초보 멍키의 개발 공부로 그 Web Forefront - Beginning Django Simple is Better Than Complex Learning Django 1.10 DoKy's Blog Mastering Django Tango with Django Effective Django Matthew Daly's Blog - Django Blog 개발 강좌 경영 학도의 좌충우돌 프로그래밍-Django 참고 오픈소스 django-page-cms django-simple-blog django-blog-zinnia django-blogango kboard django-sitetree django-treenav 01. 프로젝트 및 앱의 구조와 설정 Django 프로젝트 및 앱의 디렉터리, 파일의 구조와 설정에 대한 이야기를 정리한다. 01) pyenv와 가상환경 파이썬 설치 유의사항 pyenv 개요 pyenv 설치 (우분투) pyenv 설치 및 파이썬 빌드 준비 파이썬 설치 pyenv로 설치한 파이썬 설치 디렉터리 파이썬 버전 선택 순서 여러 개의 파이썬 버전 선택 설치한 파이썬 삭제 pyenv 삭제 virtualenv 가상환경 준비 가상환경 생성 가상환경 선택 가상환경 삭제 요약: pyenv/virtualenv 실무적 시나리오 macOS에서 pyenv, pyenv-virtualenv 설치 결론 지침 헤딩 1 헤딩 2 헤딩 3 헤딩 4 헤딩 5 파이썬 설치 파이썬 다운로드 페이지에서 윈도의 경우 Windows x86-64 executable installer 파일을 받아 설치한다. 유의사항 설치 경로 문제 PATH 환경 변수 시스템 등록 문제 pyenv 개요 01-01. 프로그램 설치 페이지에서 virtualenv 가상환경을 간단히 소개하고 있다. pyenv의 기능은 github 홈페이지 README 문서에서 아래와 같이 소개하고 있다. 시스템 전역 파이썬 버전을 변경할 수 있다. 프로젝트별 파이썬 버전을 지정할 수 있다. 환경 변수로 파이썬 버전을 지정할 수 있다. 동시에 여러 버전의 파이썬을 찾을 수 있다. tox 유틸리티와 결합하여 빌드 호환성 체크에 유용하다. pyenv는 매우 편리한 도구이지만 윈도는 지원하지 않는다. pyenv는 파이썬 실행 파일을 다운로드하여 관리하는 것이 아니라 시스템에서 직접 빌드 하여 실행하기 때문에 윈도에서 파이썬 빌드 환경 구축은 완전히 다른 주제가 될 수 있다. pyenv 설치 (우분투) pyenv 설치 및 파이썬 빌드 준비 시스템에 curl 패키지가 설치되어 있는지 확인한다. curl은 원격 서버에서 여러 가지 프로토콜로 명령행에서 데이터를 주고받기 위한 도구이다. 현재 우분투 16.04 LTS 버전에는 기본적으로 curl이 설치되어 있지 않아 직접 설치해야 한다. $ sudo apt-get install curl 이제 curl 명령어로 pyenv를 아래의 명령어로 설치할 수 있다. $ curl -L https://raw.githubusercontent.com/pyenv/pyenv-installer/master/bin/pyenv-installer | bash 설치가 올바로 완료되면 ~/.pyenv 디렉터리가 만들어지고 홈 디렉터리 안에 ~/.bashrc 또는 ~/.bash_profile 파일 안에 다음 내용을 추가한다. export PATH="${HOME}/.pyenv/bin:$PATH" eval "$(pyenv init -)" eval "$(pyenv virtualenv-init -)" 이제 터미널을 재시작하면 PATH 환경 변수에 pyenv 도구의 명령어를 실행할 수 있도록 추가되고 pyenv와 pyenv-virtualenv를 구동한다. pyenv는 파이썬을 소스 코드를 다운로드해 직접 빌드 하여 설치하므로 컴파일러와 여러 가지 라이브러리를 설치해야 한다. sudo apt-get install build-essential libreadline-dev zlib1g-dev libbz2-dev libsqlite3-dev libssl-dev 파이썬 설치 pyenv에서 사용 가능한 파이썬 버전은 아래와 같이 확인할 수 있다. pyenv versions * system (set by /home/user/.pyenv/version) 우분투 16.04 LTS에서도 기본적으로 2.7.12 버전과 3.5.2 버전이 설치된다. 여기서는 시스템에 설치된 이 파이썬을 system 파이썬으로 분류한다. 아직까지 pyenv를 통해 파이썬을 빌드 설치하지 않았으므로 시스템 파이썬만 존재한다. pyenv를 통해 파이썬 빌드 설치는 pyenv install 명령어로 아래와 같이 명령할 수 있다. $ pyenv install 2.7.13 $ pyenv install 3.4.7 $ pyenv install 3.5.3 $ pyenv install 3.6.2 만약 파이썬 2.7, 3.4, 3.5, 3.6 버전으로 모든 호환성 검사를 하고 싶다면 위와 같이 각각의 최신 버전을 다운로드 설치할 수 있다. pyenv install 명령어로 설치할 수 있는 파이썬 버전 목록은 아래와 같이 조회할 수 있다. $ pyenv install -list Available versions: 2.1.3 2.2.3 2.3.7 2.4 2.4.1 2.4.2 2.4.3 ... 생략 ... 위와 같이 명령한 경우 pyenv versions 명령어로 설치된 파이썬의 버전을 확인할 수 있다: $ pyenv versions * system (set by /home/user/.pyenv/version) 2.7.13 3.4.7 3.5.3 3.6.2 여러 개의 파이썬 버전을 설치했지만 아직까지도 결국 시스템 파이썬이 기본적으로 사용된다. pyenv로 설치한 파이썬 설치 디렉터리 파이썬은 $(pyenv root)/versions 디렉터리에 설치된다. 일반적으로 홈 디렉터리 안에 ~/.pyenv/versions 디렉터리이다. 여러 개의 파이썬 버전을 설치할 수 있으며 $(pyenv root)/versions 디렉터리 안의 디렉터리 이름을 기준으로 pyenv에서 버전을 관리한다. 앞서 예시와 같이 pyenv로 파이썬 버전을 설치했다면 아래와 같은 디렉터리가 존재한다. $(pyenv root)/versions/2.7.13/ $(pyenv root)/versions/3.4.7/ $(pyenv root)/versions/3.5.3/ $(pyenv root)/versions/3.6.2/ 파이썬 버전 선택 순서 pyenv은 여러 개의 파이썬 버전을 설치할 수 있다. 그리고 pyenv가 파이썬 버전을 선택하는 순서를 올바르게 이해하고 정확히 사용하려는 파이썬 버전을 선택해야 한다. PYENV_VERSION 환경 변수의 값 pyenv shell 명령어로 현재 터미널 세션의 환경 변수를 설정한다. 터미널이 열린 상태에서 특정 파이썬 버전을 선택하여 명령할 때 유용하다. 만약 환경 변수 설정을 제거하려면 pyenv shell --unset으로 명령하거나 터미널을 종료하고 새로 연다. .python-version 파일의 값 pyenv local 명령어로 현재 디렉터리 및 하위 디렉터리에서 실행되는 파이썬 버전을 설정한다. pyenv local 명령어로. python-version 파일이 만들어지고 이 파일이 있는 디렉터리부터 재귀적으로 모든 하위 디렉터리에 적용된다. 따라서, 프로젝트 디렉터리 안에서 명시적으로 특정 파이썬 버전을 선택하고자 할 때 유용하다. 만약 디렉터리 설정을 제거하려면 pyenv local --unset으로 명령하거나 디렉터리 안에. python-version 파일을 삭제한다. $(pyenv root)/version 파일의 값 pyenv global 명령어로 시스템 전역의 파이썬 버전을 설정한다. $(pyenv root)/version 파일이 존재하지 않을 경우에는 "system" 디폴트 파이썬을 사용하는 것으로 간주한다. 많은 튜토리얼이 pyenv로 설치한 파이썬을 사용하기 위해 pyenv shell, pyenv local, pyenv global 명령어로 지정할 수 있다고 설명하고 각각의 차이를 설명하는 경우가 적다. 설정 우선순위 관계를 올바로 이해해야 사용할 때 혼동이 없다. 여러 개의 파이썬 버전 선택 tox 유틸리티로 호환성 검사할 때 매우 유용한 기능이다. pyenv를 통해 파이썬 2와 파이썬 3를 동시에 설치하여 빌드 검사를 할 수 있다. 앞서 우분투 16.04 LTS의 경우 시스템 패키지로 파이썬 버전 2.7.12, 3.5.2 버전이 설치되고 system 파이썬으로 분류된다고 언급했다. 그리고 pyenv install 명령어로 필요에 따라 여러 개의 파이썬을 설치했다. python 명령어로 실행되는 기본적으로 실행되는 system 파이썬은 아래와 같다: $ python -V Python 2.7.12 $ python3 -V Python 3.5.2 pyenv를 사용하여 개발 환경을 구축하기로 한 이상 system 버전은 사용하지 않도록 하겠다. 이제 시스템 안에서 여러 개의 파이썬 버전을 선택하기 위해 python global 명령어로 버전을 나열해 지정할 수 있다. $ pyenv global 3.6.2 3.5.3 3.4.7 2.7.13 이제 시스템에서 python, python3 명령어로 불러오는 버전을 확인해 보면 다음과 같이 모두 pyenv로 설치한 3.6.2 버전인 것을 알 수 있다. $ python -V Python 3.6.2 $ python3 -V Python 3.6.2 만약 3.5.3, 3.4.7, 2.7.13 같은 버전을 사용하고 싶다면 각각 python3.5, python3.4, python2.7 명령어로 호출할 수 있다. 아래 예시는 python2.7로 system 기본 버전 2.7.12가 아니라 2.7.13 버전이 실행되는 것을 확인할 수 있다. $ python2.7 Python 2.7.13 (default, Aug 20 2017, 15:43:40) [GCC 5.4.0 20160609] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> 파이썬 인터프리터 실행 파일의 위치를 확인하려면 아래의 명령어로 확인할 수 있다. $ pyenv which python3.6 /home/user/.pyenv/versions/3.6.2/bin/python3.6 만약에 아래와 같이 오류가 발생한다면 파이썬이 올바로 설치되지 않은 것이다. pyenv: python3.6: command not found The `python3.6' command exists in these Python versions: 3.6.2 또한 참고로 여러 버전의 파이썬을 지정하기 위해 python global 명령어가 아니라 python local 명령어로도 지정할 수 있다. 설치한 파이썬 삭제 pyenv install 명령어로 설치한 파이썬은 pyenv uninstall 명령어로 삭제할 수 있다. pyenv uninstall 3.6.2 pyenv 삭제 pyenv 설정이 꼬이고 설치된 여러 버전의 파이썬이 뭔가 문제를 일으킨다면 pyenv 자체를 삭제할 수 있다. pyenv의 삭제는 $(pyenv root) 경로의 디렉터리를 간단히 삭제하면 되는데 일반적으로는 ~/.pyenv 디렉터리이다. virtualenv 가상환경 준비 curl로 인스톨러를 내려받아 pyenv 설치한 경우에는 virtualenv가 같이 설치되기 때문에 따로 설치할 필요는 없다. 그리고 앞서 ~/.bashrc 또는 ~/.bash_profile 파일에 다음 줄을 추가했기 때문에 가상환경을 위한 준비가 이미 되어 있다. eval "$(pyenv virtualenv-init -)" 가상환경 생성 가상환경의 생성은 pyenv virtualenv 명령어로 생성한다. pyenv virtualenv venv 현재 파이썬의 환경으로 venv 이름의 가상환경을 만들고 아래와 같이 결과를 확인할 수 있다. $ pyenv versions system * 2.7.13 (set by /home/user/.pyenv/version) * 3.4.7 (set by /home/user/.pyenv/version) * 3.5.3 (set by /home/user/.pyenv/version) * 3.6.2 (set by /home/user/.pyenv/version) 3.6.2/envs/venv venv 시스템 기본 파이썬 버전이 3.6.2이기 때문에 해당 버전을 기준으로 가상환경이 만들어졌다. 명시적으로 파이썬 특정 버전을 지정해서 가상환경을 만들려면 다음과 같이 명령한다. $ pyenv virtualenv 3.5.3 venv 3.5.3 버전을 지정했고 그 결과는 아래와 같이 확인할 수 있다. $ pyenv versions system * 2.7.13 (set by /home/user/.pyenv/version) * 3.4.7 (set by /home/user/.pyenv/version) * 3.5.3 (set by /home/user/.pyenv/version) 3.5.3/envs/venv * 3.6.2 (set by /home/user/.pyenv/version) venv 가상환경 선택 가상환경을 선택하는 것은 결국 pyenv에서 어떤 버전의 파이썬을 선택할 것인가 하는 문제와 같다. 따라서 필요에 따라 pyenv shell, pyenv local, pyenv global 명령어 중 하나로 파이썬 버전을 선택한다. $ pyenv shell venv 위와 같이 특정 가상환경을 선택하고 python, python3 버전을 확인해 보면 다음과 같다. (venv) $ pyenv which python /home/user/.pyenv/versions/venv/bin/python (venv) $ python -V Python 3.5.3 (venv) $ pyenv which python3 /home/user/.pyenv/versions/venv/bin/python3 (venv) $ python3 -V Python 3.5.3 위와 같이 쉘에서 (venv) 가상환경으로 진입한 경우에는 pyenv로 설치한 3.4, 3.6 같은 다른 버전의 파이썬을 명령행에서 찾을 수 없다. $ pyenv which python3.4 pyenv: python3.4: command not found The `python3.4' command exists in these Python versions: 3.4.7 가상환경 삭제 가상환경의 삭제는 pyenv install로 설치한 파이썬을 삭제하는 pyenv uninstall 명령어와 같다. $ pyenv uninstall venv 요약: pyenv/virtualenv 실무적 시나리오 pyenv를 사용하는 가장 큰 이유 중 하나가 tox와 연동하여 여러 버전의 파이썬으로 빌드 테스트하는 것이다. tox를 설명하는 것이 아니라 개발 환경을 만들고 tox를 연동하기 위한 방법을 설명한다. pyenv 설치 $ apt-get install curl $ curl -L https://raw.githubusercontent.com/pyenv/pyenv-installer/master/bin/pyenv-installer | bash ~/.bashrc 또는 ~/.bash_profile 파일 생성 export PATH="${HOME}/.pyenv/bin:$PATH" eval "$(pyenv init -)" eval "$(pyenv virtualenv-init -)" 빌드 컴파일러 및 라이브러리 패키지 설치 $ sudo apt-get install build-essential libreadline-dev zlib1g-dev libbz2-dev libsqlite3-dev libssl-dev pyenv로 파이썬 다운로드 빌드 설치 $ pyenv install 2.7.13 $ pyenv install 3.4.7 $ pyenv install 3.5.3 $ pyenv install 3.6.2 가상환경 설치 (-p 옵션을 주지 않으면 가상환경으로 진입했을 때 다른 버전의 python을 찾을 수 없음) $ pyenv virtualenv -p python3.6 3.6.2 venv 여러 개의 파이썬 버전 선택(디폴트=venv 3.6.2 버전 가상환경) $ pyenv global venv 3.5.3 3.4.7 2.7.13 만약 여러 개의 파이썬 버전을 등록해두지 않으면 이후 tox 명령어 실행 시 파이썬 인터프리터를 찾지 못해 가상환경이 생성하지 않는 오류가 발생할 수 있다. 파이썬 버전 쉘로 지정 ((venv) 프롬프트가 활성화되지 않은 경우) $ pyenv shell venv tox 설치 및 실행 $ pip install tox $ tox macOS에서 pyenv, pyenv-virtualenv 설치 homebrew 설치 /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)" pyenv, pyenv-virtualenv 패키지 설치 $ brew update $ brew install pyenv $ brew install pyenv-virtualenv ~/.bash_profile 파일의 내용은 다음과 같다. eval "$(pyenv init -)" eval "$(pyenv virtualenv-init -)" 이하 가상환경 설치 내용은 위의 내용과 동일하다. 만약 아래와 같이 라이브러리를 찾지 못하는 에러가 발생할 경우 ERROR: The Python ssl extension was not compiled. Missing the OpenSSL lib? CFLAGS="-I$(brew --prefix openssl)/include" \ LDFLAGS="-L$(brew --prefix openssl)/lib" \ pyenv install -v 3.4.3 결론 지침 출처: 파이썬의 개발 “환경”(env) 도구들 파이썬 프로그래머가 아니지만, 파이썬 애플리케이션을 설치해서 이용합니다. 시스템에서 제공하는 패키지 관리자(APT나 홈 브루 등)를 통해 애플리케이션을 설치하세요. 파이썬 프로그래머가 아니지만, 파이썬 애플리케이션을 유난히 많이 이용합니다. pipsi를 이용해 파이썬 애플리케이션을 설치하는 것을 권합니다. 파이썬 프로그래머이고, 하나의 애플리케이션을 개발합니다. 파이썬 3.3 이상을 이용할 경우 pyvenv로 개발 환경을 만들어서 개발하세요. 그 이전의 파이썬 버전을 이용할 경우 virtualenv를 활용하세요. 파이썬 프로그래머이고, 여러 애플리케이션을 개발합니다. virtualenvwrapper를 활용하세요. 파이썬 프로그래머이고, 여러 애플리케이션을 다양한 파이썬 버전으로 개발합니다. pyenv-virtualenvwrapper를 활용하세요. 파이썬 프로그래머이고, 라이브러리를 개발합니다. pyenv와 tox를 활용하세요. 적어도 Django 개발자라면 3, 4, 5, 6 경우의 수 중 하나일 것이다. 그리고 재배포 가능한 Django 앱을 개발한다면 pyenv, tox를 반드시 사용해야 할 것이다. 헤딩 1 헤딩 2 헤딩 3 헤딩 4 헤딩 5 02) Django 설치 Django 설치 가상환경 준비 가상환경 생성 가상환경 활성화 (윈도) 가상환경 나오기 기존 가상환경 업데이트 PIP으로 Django 설치 Django 설치 설치 버전 확인 PyCharm 설치 Django를 비롯한 PyCharm IDE를 설치한다. Django 설치 가상환경 준비 파이썬 버전 3.4부터 virtualenv 패키지를 별도로 설치하지 않고 사용할 수 있다. 가상환경 생성 python -m venv my_env 가상환경 활성화 (윈도) venv\Scripts\activate.bat 가상환경 나오기 (venv) venv\Scripts\deactivate 기존 가상환경 업데이트 우분투 등에서 시스템 파이썬이 업그레이드되는 경우 예를 들어, 3.5 버전에서 3.6 버전으로 업그레이드되는 경우에 기존에 구 버전에 종속적인 가상환경을 업그레이드해줘야 한다. python3 -m venv --upgrade venv PIP으로 Django 설치 Django 설치 pip install Django==1.11.2 설치 버전 확인 import django print(django.VERSION) print(django.get_version()) django.VERSION (1, 11, 2, 'final', 0) 튜플로 반환 django.get_version() 1.11.2 문자열로 반환 PyCharm 설치 PyCharm Pro는 상용 프로그램이지만 커뮤니티 에디션을 무료로 이용할 수 있다. 커뮤니티 에디션은 Django를 직접적으로 지원하지 않지만 기본적인 개발에 사용 가능하다. PyCharm IDE는 자바로 개발된 프로그램으로 JRE가 설치되어 있어야 한다. 02) Django 프로젝트 및 앱 구조 Django 프로젝트 구조 기본 디렉터리 및 파일 구조 기본 디렉터리 및 파일 설명 명령어 정리 프로젝트 디렉터리 생성 파이썬 가상환경 생성 및 활성화 Django 설치 및 버전 확인 Django 프로젝트 저장소 생성 테스트 서버 구동 gitlab 주소에서 그대로 내려받기 여러 가지 문제 해결 django-admin.py 파일 실행이 올바로 안 되는 경우 Django 앱 구조 기본 디렉터리 및 파일 구조 공통 모듈 구조 쿠키 커터 쿠키 커터 설치 쿠키 커터로 Django 앱 뼈대 만들기 의견 및 요약 Django 프로젝트 구조 기본 디렉터리 및 파일 구조 최초 Django 프로젝트를 생성할 때 repo 디렉터리 안에서 아래와 같이 명령하면 conf 디렉터리가 만들어진다. django-admin.py startproject conf . 위 명령어로 실행했을 때 결과는 다음과 같다. 프로젝트_이름/ repo/ conf/ __init__.py settings.py urls.py wsgi.py manage.py venv/ PyCharm에서 프로젝트를 임포트 할 때는 repo 디렉터리를 임포트하고 이를 기준으로 저장소에 소스 커밋 한다. 기본 디렉터리 및 파일 설명 프로젝트 단위로 하위 디렉터리를 가진다. repo: Django 애플리케이션 소스 코드 디렉터리 = 저장소 커밋 관리 venv: 가상환경 디렉터리 mkdir 명령어로 repo 디렉터리를 생성 후 디렉터리 안에서 startproject 옵션으로 프로젝트를 만든다. 일반적으로 conf 이름 대신에 프로젝트 이름을 사용하지만 실제로는 프로젝트의 설정 파일이 들어가므로 conf 이름으로 사용한다. 타 프로젝트와 구별하기 위해 최상위 디렉터리 이름을 프로젝트 이름으로 한다. venv 디렉터리는 종속성 분리의 원칙에 따라 프로젝트의 독립적인 가상환경을 제공한다. 파이썬 3.4 버전부터는 별도의 virtualenv 패키지 설치하지 않고 가상환경 디렉터리를 만들 수 있다. 명령어 정리 상기 구조에 따른 구성을 위한 윈도 명령 프롬프트 명령어를 정리하면 다음과 같다. 프로젝트 디렉터리 생성 mkdir 프로젝트_이름 파이썬 가상환경 생성 및 활성화 python -m venv venv venv\Scripts\activate.bat Django 설치 및 버전 확인 pip으로 인터넷에서 다운로드해 설치한다. pip install Django 파이썬 인터프리터를 실행하고 Django 버전 확인을 통해 올바로 설치되었는지 확인한다. import django django.VERSION quit() Django 프로젝트 저장소 생성 mkdir repo cd repo django-admin.py startproject conf . 테스트 서버 구동 다음과 같이 Django 테스트 서버를 구동하고 브라우저로 http://127.0.0.1:8000/ 주소에 접속해 결과를 확인한다. python manage.py runserver gitlab 주소에서 그대로 내려받기 Django 프로젝트 생성 시 --template 옵션으로 그대로 프로젝트를 생성할 수도 있다. 프로젝트 이름의 최상위 디렉터리에서 아래와 같이 명령하면 repo 프로젝트/저장소 디렉터리가 생성된다. django-admin.py startproject --template https://gitlab.com/mairoo/django-quickstarter/repository/archive.zip repo 여러 가지 문제 해결 django-admin.py 파일 실행이 올바로 안 되는 경우 윈도에서. py 확장자에 연결 프로그램이 등록되어 있는 경우 django-admin.py 파일이 실행되지 않고 에디터 프로그램이 실행되거나 파이썬 가상환경 인터프리터가 아닌 시스템에 설치된 파이썬 인터프리터로 실행되는 경우가 있다. 이러한 문제 해결을 위해 venv\Scripts 디렉터리에 아래 배치 파일을 생성한다. django-admin.bat 파일 @echo off python "%VIRTUAL_ENV%\Scripts\django-admin.py" %* 위 배치 파일을 만들고 django-admin.py 대신에 django-admin.bat 명령어로 Django 프로젝트를 생성할 수 있다. django-admin.bat startproject conf . Django 앱 구조 기본 디렉터리 및 파일 구조 앱 디렉터리 안에 기본 생성 파일은 다음과 같다. bookmark/ __init__.py admin.py apps.py migrations/ models.py tests.py views.py Django 버전 1.9부터 애플리케이션의 설정 클래스를 정의하는 apps.py 파일이 추가되었다. 애플리케이션의 등록은 다음과 같이 할 수 있다. INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'bookmark.apps.BookmarkConfig', ] 단순히 bookmark 모듈 이름으로 등록할 수 있지만 bookmark.apps.BookmarkConfig 설정 클래스 이름으로 등록하는 것이 보다 정확한 방법이다. 공통 모듈 구조 Two Scoops of Django 책에서 소개하는 공통 모듈 구조이다. Django 개발자들끼리의 이름 규칙 약속이다. bookmark/ __init__.py admin.py apps.py migrations/ models.py tests.py views.py urls.py forms.py behaviors.py constants.py decorators.py db/ fields.py factories.py helpers.py managers.py signals.py viewmixins.py 추가로 넣을 수 있는 파일에 대한 설명은 다음과 같다. urls.py: 앱의 URL 패턴 선언 forms.py: 입력 폼 선언 behaviors.py: 모델 믹스인 위치에 대한 옵션 constants.py: 앱에 쓰이는 상수 선언 decorators.py: 데코레이터 db/: 여러 프로젝트에서 용되는 커스텀 모델이나 컴포넌트 fields.py: 폼 필드 factories.py: 테스트 데이터 팩토리 파일 helpers.py: 뷰와 모델 파일을 가볍게 하기 위해 유틸리티 함수 선언 managers.py: models.py가 너무 커질 경우 커스텀 모델 매니저가 위치 signals.py: 커스텀 시그널 viewmixins.py: 뷰 모듈과 패키지를 더 가볍게 하기 위해 뷰 믹스인을 이 모듈로 이전 쿠키 커터 쿠키 커터 프로젝트는 Django 프로젝트를 빨리 시작할 수 있도록 미리 만들어진 앱의 구조이다. 쿠키 커터 설치 pip install cookiecutter 쿠키 커터로 Django 앱 뼈대 만들기 cookiecutter https://github.com/pydanny/cookiecutter-django.git You've cloned /home/mairoo/.cookiecutters/cookiecutter-django before. Is it okay to delete and re-clone it? [yes]: yes Cloning into 'cookiecutter-django'... remote: Counting objects: 7833, done. remote: Compressing objects: 100% (42/42), done. remote: Total 7833 (delta 19), reused 0 (delta 0), pack-reused 7791 Receiving objects: 100% (7833/7833), 2.82 MiB | 991.00 KiB/s, done. Resolving deltas: 100% (5078/5078), done. Checking connectivity... done. project_name [Project Name]: project_slug [project_name]: author_name [Daniel Roy Greenfeld]: email [you@example.com]: description [A short description of the project.]: domain_name [example.com]: version [0.1.0]: timezone [UTC]: use_whitenoise [y]: use_celery [n]: y use_mailhog [n]: y use_sentry_for_error_reporting [y]: use_opbeat [n]: y use_pycharm [n]: y windows [n]: y use_python3 [y]: use_docker [y]: use_heroku [n]: y use_compressor [n]: y Select postgresql_version: 1 - 9.5 2 - 9.4 3 - 9.3 4 - 9.2 Choose from 1, 2, 3, 4 [1]: 1 Select js_task_runner: 1 - Gulp 2 - Grunt 3 - Webpack 4 - None Choose from 1, 2, 3, 4 [1]: 4 use_lets_encrypt [n]: y Select open_source_license: 1 - MIT 2 - BSD 3 - GPLv3 4 - Apache Software License 2.0 5 - Not open source Choose from 1, 2, 3, 4, 5 [1]: 1 You selected to use Let's Encrypt, please see the documentation for instructions on how to use this in production. You must generate a dhparams.pem file before running docker-compose in a production environment. 의견 및 요약 쿠키 커터의 상세 옵션을 모두 파악해서 이해하기 전까지는 실무적으로 그대로 가져다 쓰기엔 무리가 있다. 쿠키 커터 자체로 상당히 많은 의존성을 설치한다. (arrow, binaryornot, chardet, click, future, Jinaja2, jinja2-time, MarkupSafe, poyo, python-dateutil, six, whichcraft) 모든 옵션을 포함한 예제 프로젝트를 생성하고 그 내용을 참고하여 필요한 부분만 찾아서 프로젝트에 적용하면 좋은 지침이 된다. 03) Django 프로젝트 설정 설정 기본 데이터베이스 설정 템플릿 설정 지역 시각 및 다국어 설정 정적 파일 설정 미디어 파일 설정 애플리케이션 등록 설정 실무 settings 패키지로 구현 설정 데이터의 분류 주요 디렉터리 및 파일 설명 Django 기본 설정 옵션은 settings.py 모듈 파일 하나로 설정한다. 그러나 실무적으로는 패키지로 만들어 설정을 나눠서 관리한다. settings.py 기본 값을 살펴보고 패키지로 나누는 방법을 설명한다. 설정 기본 settings.py 파일의 내용은 크게 다음 부분으로 나눌 수 있다. 데이터베이스 설정 템플릿 설정 지역 시각 및 다국어 설정 애플리케이션의 등록 정적 파일 설정 미디어 파일 설정 데이터베이스 설정 DATABASES = { 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': os.path.join(BASE_DIR, 'db.sqlite3'), } } 프로젝트 기본 설정값은 위와 같이 sqlite를 사용하고 있으며 데이터베이스 연동 설정은 다음 링크의 내용을 참고한다. Django 데이터베이스 연동 설정 템플릿 설정 TEMPLATES = [ { 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'DIRS': [os.path.join(BASE_DIR, 'templates')], 'APP_DIRS': True, 'OPTIONS': { 'context_processors': [ 'django.template.context_processors.debug', 'django.template.context_processors.request', 'django.contrib.auth.context_processors.auth', 'django.contrib.messages.context_processors.messages', ], }, }, ] 프로젝트 기본 설정값은 위와 같으며 templates 디렉터리 이름을 변경하고자 할 경우 DIRS 변수를 수정한다. 'DIRS': [os.path.join(BASE_DIR, 'templates')], 지역 시각 및 다국어 설정 LANGUAGE_CODE = 'en-us' TIME_ZONE = 'UTC' USE_I18N = True USE_L10N = True USE_TZ = True 프로젝트 기본 설정값은 위와 같으며 아래와 같이 수정한다. LANGUAGE_CODE = 'ko-kr' TIME_ZONE = 'Asia/Seoul' USE_I18N = True USE_L10N = True USE_TZ = True 정적 파일 설정 STATIC_URL = '/static/' 프로젝트 기본 설정값은 위와 같으며 STATIC_URL 변수를 추가한다. STATIC_ROOT = os.path.join(BASE_DIR, 'static') STATICFILES_DIRS = [ os.path.join(BASE_DIR, 'static'), ] 미디어 파일 설정 프로젝트 기본 설정값은 없으며 파일 업로드 기능 구현을 위해 다음 설정을 추가한다. MEDIA_URL = '/media/' MEDIA_ROOT = os.path.join(BASE_DIR, 'media') runserver 테스트 서버 구동 시에 /media 경로를 올바로 찾지 못하는 문제가 발생한다. 따라서 URL 패턴 매칭을 해주는 다음 코드가 필요하다. from django.conf.urls.static import static urlpatterns = [ .... ] if settings.DEBUG: urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT) 애플리케이션 등록 bookmark 앱을 생성한 경우 해당 앱 디렉터리 안에 기본 생성 파일은 다음과 같다. bookmark/ migrations/ __init__.py admin.py apps.py models.py tests.py views.py Django 버전 1.9부터 애플리케이션의 설정 클래스를 정의하는 apps.py 파일이 추가되었다. 애플리케이션의 등록은 다음과 같이 할 수 있다. INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'bookmark.apps.BookmarkConfig', ] 단순히 bookmark 모듈 이름으로 등록할 수도 있지만 bookmark.apps.BookmarkConfig 설정 클래스 이름으로 등록하는 것이 보다 정확한 방법이다. 설정 실무 settings 패키지로 구현 Django 기본 설정 옵션은 settings.py 모듈 파일 하나로 설정한다. 그러나 실무적으로는 패키지로 만들어 설정을 나눠서 관리한다. 즉, settings.py 파일 하나가 아니라 settings 패키지(디렉터리)를 만들고 이 안에 여러 가지 모듈(파일)을 생성한다. 프로젝트_이름/ repo/ app1/ app2/ conf/ __init__.py settings/ base.py local.py production.py test.py urls.py wsgi.py manage.py README.md requirements.txt .gitignore venv/ run/ uwsgi.ini uwsgi.sock gunicorn.sock logs/ ssl/ 설정 데이터의 분류 settings 패키지(디렉터리) 안에는 base.py, local.py, production.py 등 여러 개의 모듈(파일)이 들어있다. 이 파일들의 용도와 구분은 다음과 같다. 환경마다 다른 공개적인 설정 local.py, test.py, production.py 등으로 파일을 나누고 저장소에서 관리한다. 모든 환경에서 동일한 공개적인 설정 base.py 파일을 만들고 이를 구체적인 local.py, test, py, production.py 등에서 임포트 한다. 환경마다 다른 비공개적인 설정 local.py, test.py, production.py 등으로 파일을 나누고 설정값은 환경 변수로 로드한다. 모든 환경에서 동일한 비공개적인 설정 base.py 파일을 만들고 설정값은 환경 변수에서 로드하며 구체적인 local.py, test.py, production.py 등에서 임포트 한다. 여기서 중요한 것은 공개적인 설정은 저장소에서 코드로 저장되어 관리되지만 비공개 설정은 저장소에 절대 커밋 되어서는 안 된다. 비공개 설정 정보 하는 방법은 환경 변수를 이용하는 방법이 가장 흔하며 시스템에 local.sh, production.sh와 같은 쉘 스크립트 파일을 작성하는 것이다. 주요 디렉터리 및 파일 설명 프로젝트 단위로 하위 디렉터리를 가진다. repo: Django 애플리케이션 소스 코드 디렉터리 = 저장소 커밋 관리 venv: 가상환경 디렉터리 run: 배포 후 소켓 파일 및 연동 설정 파일이 위치하는 디렉터리 logs: 로그 디렉터리 ssl: SSL 키 파일 디렉터리 mkdir 명령어로 repo 디렉터리를 생성 후 디렉터리 안에서 startproject 옵션으로 프로젝트를 만든다. 일반적으로 conf 이름 대신에 프로젝트 이름을 사용하지만 실제로는 프로젝트의 설정 파일이 들어가므로 conf 이름으로 사용한다. 타 프로젝트와 구별하기 위해 최상위 디렉터리 이름을 프로젝트 이름으로 한다. venv 디렉터리는 종속성 분리의 원칙에 따라 프로젝트의 독립적인 가상환경을 제공한다. 파이썬 3.4 버전부터는 별도의 virtualenv 패키지 설치하지 않고 가상환경 디렉터리를 만들 수 있다. run 디렉터리는 WSGI 서버가 동작할 때 소켓 파일을 생성하는 디렉터리이다. 보통은 그룹의 소유권을 www-data로 변경한다. 만약 개발 환경에서 manage.py로 테스트 서버를 구동한다면 불필요한 디렉터리이다. Two scoops of Django 책에서는 디렉터리의 종류를 아래와 같이 구분한다. 저장소 루트 Django 프로젝트 루트 : repo 설정 루트 : conf 해당 책에서는 최상위 디렉터리가 저장소 루트로 프로젝트 루트와 분리하는 것을 권장하지만 굳이 분리할 필요성을 아직은 느끼지 못했다. 04) 데이터베이스 연동 SQLite 데이터베이스 접속 설정 PostgreSQL 패키지 설치 데이터베이스 및 사용자 추가 데이터베이스 접속 설정 MySQL SQLite SQLite 파일 데이터베이스를 이용하기 위해서는 별도의 패키지 설치가 필요 없다. 데이터베이스 접속 설정 conf/settings.py 파일에서 데이터베이스 연결 설정을 아래와 같이 수정한다. SQLite는 파일 데이터베이스이므로 별도의 아이디/비밀번호 접속 정보가 없다. DATABASES = { 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': os.path.join(BASE_DIR, 'db.sqlite3'), } } PostgreSQL 패키지 설치 독립된 가상환경에서 psycopg2 파이썬 패키지를 설치한다. pip install psycopg2 데이터베이스 및 사용자 추가 데이터베이스와 사용자를 추가하기 위해 psql 콘솔을 아래와 같이 실행한다. sudo su - postgres psql psql (9.5.4) Type "help" for help. 아래와 같이 django_test 데이터베이스와 시스템 계정이 아닌 데이터베이스 사용자 django_user를 추가한다. CREATE DATABASE django_test; CREATE USER django_user WITH PASSWORD 'django_pass'; ALTER ROLE django_user SET client_encoding TO 'utf8'; ALTER ROLE django_user SET default_transaction_isolation TO 'read committed'; ALTER ROLE django_user SET timezone TO 'UTC'; GRANT ALL PRIVILEGES ON DATABASE django_test TO django_user; \q 데이터베이스와 사용자를 추가하고 권한까지 부여했으므로 psql 사용자에서 빠져나온다. exit 데이터베이스 접속 설정 conf/settings.py 파일에서 데이터베이스 연결 설정을 아래와 같이 수정한다. 데이터 접속 정보는 앞서 데이터베이스 생성할 때 입력한 데이터베이스 이름, 아이디, 비밀번호와 같다. DATABASES = { 'default': { 'ENGINE': 'django.db.backends.postgresql_psycopg2', 'NAME': 'django_test', 'USER': 'django_user', 'PASSWORD': 'django_pass', 'HOST': 'localhost', 'PORT': '', } } MySQL 02. 모델과 ORM 01) 모델의 선언 모델의 선언과 관리자 화면에 등록 모델의 선언 관리자 화면에 등록 주요 필드 필드 타입과 옵션 DateTimeField Meta 내부 클래스 옵션 verbose_name 옵션 verbose_name_plural 옵션 ordering 옵션 db_table 옵션 abstract 옵션 모델 코딩 가이드 필드 이름은 모두 소문자로 _(밑줄)로 띄어 쓴다. Meta 클래스는 필드 선언 밑에 한 줄 띄고 위치한다. 주요 메서드가 위치하는 순서 모델의 선언과 관리자 화면에 등록 모델의 선언 models.py 파일 예시 from django.db import models class Bookmark(models.Model): title = models.CharField(max_length=100, blank=True, null=True) url = models.URLField('url', unique=True) class Meta: verbose_name = '북마크' verbose_name_plural = '북마크 모음' ordering = ['title', ] def __str__(self): return self.title 관리자 화면에 등록 admin.py 파일 예시 from django.contrib import admin from bookmark.models import Bookmark class BookmarkAdmin(admin.ModelAdmin): list_display = ('title', 'url') admin.site.register(Bookmark, BookmarkAdmin) 주요 필드 필드 타입과 옵션 DateTimeField 기본값 = 생성 시 생성 시각 = 사용자 변경 가능 pub_date = models.DateTimeField('date published', default=datetime.datetime.now) 기본값 = 생성 시 생성 시각 = 사용자 변경 불가 (입력 필드 노출 안 함) pub_date = models.DateTimeField('date published', default=datetime.datetime.now, editable=False) 레코드 추가 시 자동 추가 = 사용자 변경 불가(입력 필드 노출 안 함) created = models.DateTimeField(auto_now_add=True) 레코드 변경 시 자동 추가 = 사용자 변경 불가(입력 필드 노출 안 함) updated = models.DateTimeField(auto_now=True) Meta 내부 클래스 옵션 verbose_name 옵션 사용자가 읽기 쉬운 모델 객체의 이름으로 관리자 화면 등에서 표시된다. 영어를 기준으로 단수형이다. verbose_name 옵션을 지정하지 않으면 CamelCase 클래스 이름을 기준으로 camel case 이와 같이 모두 소문자로 변경한다. verbose_name_plural 옵션 사용자가 읽기 쉬운 모델 객체의 이름으로 관리자 화면 등에서 표시되는 것은 동일하나 영어를 기준으로 복수형이다. 한국어에서는 굳이 단수와 복수를 구별해 사용하지 않으므로 verbose_name과 동일하게 쓸 수 있다. verbose_name_plural 옵션을 지정하지 않으면 verbose_name에 s를 붙인다. ordering 옵션 모델의 정렬 순서를 지정하며 여러 개를 지정할 경우 필드 이름을 리스트로 나열한다. 기본값은 오름차순으로 정렬하고 -를 붙이면 내림차순으로 정렬한다. 다음 예시는 pub_date 필드 기준 내림차순으로 정렬하고 다시 author 필드를 기준으로 오름차순 정렬한다. ordering = ['-pub_date', 'author'] db_table 옵션 abstract 옵션 모델 코딩 가이드 필드 이름은 모두 소문자로 _(밑줄)로 띄어 쓴다. 아래 예시처럼 데이터베이스 필드 이름 선언을 모두 소문자로 하고 _로 띄어 쓴다. class Person(models.Model): first_name = models.CharField(max_length=20) last_name = models.CharField(max_length=40) Meta 클래스는 필드 선언 밑에 한 줄 띄고 위치한다. 아래 예시처럼 데이터베이스 필드 이름 선언 아래 한 줄 띄고 Meta 클래스가 위치한다. class Person(models.Model): first_name = models.CharField(max_length=20) last_name = models.CharField(max_length=40) class Meta: verbose_name_plural = 'people' 주요 메서드가 위치하는 순서 모든 데이터베이스 필드 커스텀 매니저 속성 Meta 클래스 def __init__() 메서드 def __str__() 메서드 def save() 메서드 def get_absolute_url() 메서드 기타 커스텀 메서드 02) 모델의 관계 매핑 모델의 관계 매핑 일대다 관계 다대다 관계 일대일 관계 조인(join) select_related prefetch_related 모델의 관계 매핑 일대다 관계 다대다 관계 일대일 관계 조인(join) select_related 외래 키(foreign key) 참조 관계에서 관계된 필드의 값을 구하기 위해 관계별로 개별 쿼리를 실행하면 데이터베이스에 부담이 될 수 있다. 이러한 문제 해결을 위해 적절한 곳에 select_related() 메서드로 JOIN을 수행할 수 있다. 외래 키가 NOT NULL인 경우에는 INNER JOIN으로 만들고 NULL인 경우에는 LEFT OUTER JOIN으로 쿼리를 만든다. Message.objects \ .filter(board__slug=self.kwargs['slug']) \ .filter(status='published') \ .order_by('-created') 먼저 위와 같이 select_related() 메서드를 사용하지 않으면 템플릿에서 {% url 'board:message-detail' message.board.slug message.id %}, {{ message.author }} 사용할 때마다 아래의 개별 쿼리가 총 3회 수행된다. 문제는 게시물 목록이 20개라고 가정하면 한 페이지 렌더링에 3개 쿼리가 20번 총 60회 수행된다. SELECT "board_message"."id", "board_message"."board_id", "board_message"."title", "board_message"."author_id", "board_message"."content", FROM "board_message" WHERE ("board_message"."status" = 'published') ORDER BY "board_message"."created" DESC; SELECT "board_board"."id", "board_board"."title", "board_board"."slug", FROM "board_board" WHERE "board_board"."id" = 1; SELECT "auth_user"."id", "auth_user"."password", "auth_user"."last_login", "auth_user"."is_superuser", "auth_user"."user name", "auth_user"."first_name", "auth_user"."last_name", "auth_user"."email", "auth_user"."is_staff", "auth_user"."is_active", "auth_user"."date_joined" FROM "auth_user" WHERE "auth_user"."id" = 1; 여러 차례 개별 쿼리가 반복 수행하는 것을 JOIN을 통해 줄일 수 있다. Message.objects \ .select_related('author') \ .select_related('board') \ .filter(board__slug=self.kwargs['slug']) \ .filter(status='published') \ .order_by('-created') 위와 같이 객체 목록을 구하면 아래와 같이 조인한 쿼리문을 실행한다. SELECT "board_message"."id", "board_message"."board_id", "board_message"."title", "board_message"."author_id", "board_message"."content", "board_board"."id", "board_board"."title", "board_board"."slug", "auth_user"."id", "auth_user"."password", "auth_user"."last_login", "auth_user"."is_superuser", "auth_user"."user name", "auth_user"."first_name", "auth_user"."last_name", "auth_user"."email", "auth_user"."is_staff", "auth_user"."is_active", "auth_user"."date_joined" FROM "board_message" INNER JOIN "board_board" ON ("board_message"."board_id" = "board_board"."id") LEFT OUTER JOIN "auth_user" ON ("board_message"."author_id" = "auth_user"."id") WHERE ("board_board"."slug" = 'pic' AND "board_message"."status" = 'published') ORDER BY "board_message"."created" DESC; prefetch_related 03) 모델 매니저 모델 매니저 디폴트 모델 매니저 = objects 커스텀 모델 매니저 모델 매니저를 추가하는 방식 커스템 모델 매니저를 정의한다. 모델에 커스텀 매니저를 추가한다. 커스텀 모델 매니저의 메서드 호출 예시 모델 매니저를 메서드 체인로 지정하는 방식 커스템 모델 매니저를 정의한다. 모델의 기본 매니저를 커스텀 메서드로 변경한다. 커스텀 모델 매니저의 메서드 체인 호출 예시 정리 참고문헌 모델 매니저 디폴트 모델 매니저 = objects 모델 매니저는 데이터베이스 쿼리와 연동되는 인터페이스이다. 각 모델은 애플리케이션에서 최소 하나의 매니저를 가진다. 디폴트 모델 매니저의 이름은 objects이다. 커스텀 모델 매니저 커스텀 모델 매니저를 구현하는 방법은 크게 두 가지이다. 모델 매니저를 매번 추가해서 특정 모델 매니저 인스턴스를 이용하는 방식 디폴트 모델 매니저를 변경 후 메서드 체인으로 호출하는 방식 모델 매니저를 추가하는 방식 커스템 모델 매니저를 정의한다. blog/models.py 파일에 추가 class PublishedManager(models.Manager): def get_queryset(self): return super(PublishedManager, self).get_queryset().filter(status='published') 모델에 커스텀 매니저를 추가한다. blog/models.py 파일 수정 class Post(models.Model): objects = models.Manager() published = PublishedManager() STATUS_CHOICES = ( ('draft', 'Draft'), ('published', 'Published'), ) publish = models.DateTimeField(default=timezone.now) ... 생략 ... 커스텀 모델 매니저의 메서드 호출 예시 >>> from blog.models import Post >>> Post.objects.count() >>> Post.published.count() 모델 매니저를 메서드 체인로 지정하는 방식 커스템 모델 매니저를 정의한다. blog/models.py 파일에 추가 class PublishedManager(models.Manager): use_for_related_fields = True def published(self, **kwargs): return self.filter(status='published', **kwargs) use_for_related_fields = True 옵션은 기본 매니저로 이 매니저를 정의한 모델이 있을 때 이 모델을 가리키는 모든 관계 참조에서 모델 매니저를 사용할 수 있도록 한다. 모델의 기본 매니저를 커스텀 메서드로 변경한다. blog/models.py 파일 수정 class Post(models.Model): objects = PublishedManager() STATUS_CHOICES = ( ('draft', 'Draft'), ('published', 'Published'), ) publish = models.DateTimeField(default=timezone.now) ... 생략 ... 커스텀 모델 매니저의 메서드 체인 호출 예시 >>> from blog.models import Post >>> Post.objects.count() >>> Post.objects.published().count() 정리 Two Scoops of Django 책에서는 모델 매니저를 메서드로 지정하는 방식을 권장하는데 그이유는 다음과 같다. First, when using model inheritance, children of abstract base classes receive their parent’s model manager, and children of concrete base classes do not. 모델 상속을 이용할 때 추상(abstract) 클래스의 자식 클래스는 부모의 모델 매니저를 상속받지만 구상(concrete) 클래스의 자식 클래스는 그렇지 않다. Second, the first manager applied to a model class is the one that Django treats as the default. This is breaks significantly with the normal Python pattern, causing what can appear to be unpredictable results from QuerySets. 모델 클래스에서 선언하는 첫 번째 모델 매니저는 Django의 디폴트 매니저이다. 그리고 여러 개의 매니저를 나열하는 것은 일반적인 파이썬 패턴에 매우 어긋나는 것으로 QuerySets로부터 예상치 못한 결과를 얻을 수 있다. 참고문헌 How to use custom manager with related objects? 04) 모델 상속 05) 마이그레이션 파일 제거 마이그레이션 파일 제거 첫 번째 시나리오 두 번째 시나리오 현재 반영 안 된 마이그레이션이 없는지 확인한다. 프로젝트 앱 마이그레이션 히스토리 삭제 마이그레이션 파일 삭제 초기 마이그레이션 파일 생성 페이크 마이그레이션 마이그레이션 파일 제거 Django 마이그레이션 도구는 모델 관리에 훌륭한 도구이다 그러나 너무 많이 저장소에서 관리하는 것이 때로는 불필요한 문제나 부작용을 일으키기도 한다. 그래서 가끔은 마이그레이션 파일을 정리하는 것이 좋다. 첫 번째 시나리오 아직 전혀 배포되지 않은 개발 중인 프로젝트는 중간중간에 마이그레이션을 싹<NAME>는 것도 좋다. 마이그레이션 디렉터리 안에 모든 파일을 __init__.py 모듈 빼고 싹<NAME>다. 리눅스에서는 아래와 같은 명령어로 쉽게 지울 수 있다. find . -path "*/migrations/*.py" -not -name "__init__.py" -delete find . -path "*/migrations/*.pyc" -delete 데이터베이스를 제거한다. 기본 SQLite 엔진으로 개발 중이라면 db.sqlite3 파일을 삭제한다. 초기 마이그레이션 파일을 생성하고 데이터베이스 스키마를 생성한다. python manage.py makemigrations python manage.py migrate 두 번째 시나리오 마이그레이션 파일은 모두<NAME>지만 데이터베이스 데이터는 유지하고 싶은 경우이다. 현재 반영 안 된 마이그레이션이 없는지 확인한다. python manage.py makemigrations 위와 같이 명령하여 아래 메시지를 확인하면 추가로 반영할 마이그레이션이 없는 경우다. No changes detected 그러나 추가로 마이그레이션 파일이 만들어지면 이를 아래와 같이 명령하여 반영하도록 한다. python manage.py migrate 프로젝트 앱 마이그레이션 히스토리 삭제 python manage.py showmigrations 위와 같이 명령하면 프로젝트 안에 앱들의 마이그레이션 히스토리를 볼 수 있다. admin [X] 0001_initial [X] 0002_logentry_remove_auto_add auth [X] 0001_initial [X] 0002_alter_permission_name_max_length [X] 0003_alter_user_email_max_length [X] 0004_alter_user_user name_opts [X] 0005_alter_user_last_login_null [X] 0006_require_contenttypes_0002 [X] 0007_alter_validators_add_error_messages [X] 0008_alter_user_user name_max_length blog [X] 0001_initial [X] 0002_auto_20170610_1904 [X] 0003_auto_20170610_1906 [X] 0004_auto_20170610_2044 [X] 0005_auto_20170613_1152 [X] 0006_post_description contenttypes [X] 0001_initial [X] 0002_remove_content_type_name sessions [X] 0001_initial 위 예제에서는 blog 앱의 마이그레이션 파일을 아래와 같이 명령하여 초기화한다. python manage.py migrate --fake blog zero 위 명령어의 결과는 아래와 같다. Operations to perform: Unapply all migrations: blog Running migrations: Rendering model states... DONE Unapplying blog.0006_post_description... FAKED Unapplying blog.0005_auto_20170613_1152... FAKED Unapplying blog.0004_auto_20170610_2044... FAKED Unapplying blog.0003_auto_20170610_1906... FAKED Unapplying blog.0002_auto_20170610_1904... FAKED Unapplying blog.0001_initial... FAKED 다시 아래와 같이 마이그레이션 히스토리를 확인하기 위해 명령할 수 있다. python manage.py showmigrations 아래 결과에서 blog의 경우에는 마이그레이션 히스토리 앞에 [X] 표시가 사라진 것을 확인할 수 있다. admin [X] 0001_initial [X] 0002_logentry_remove_auto_add auth [X] 0001_initial [X] 0002_alter_permission_name_max_length [X] 0003_alter_user_email_max_length [X] 0004_alter_user_user name_opts [X] 0005_alter_user_last_login_null [X] 0006_require_contenttypes_0002 [X] 0007_alter_validators_add_error_messages [X] 0008_alter_user_user name_max_length blog [ ] 0001_initial [ ] 0002_auto_20170610_1904 [ ] 0003_auto_20170610_1906 [ ] 0004_auto_20170610_2044 [ ] 0005_auto_20170613_1152 [ ] 0006_post_description contenttypes [X] 0001_initial [X] 0002_remove_content_type_name sessions [X] 0001_initial 마이그레이션 파일 삭제 blog 앱의 마이그레이션 디렉터리 안에 __init__.py 파일을 빼고 모두 삭제한다. 그리고 다시 아래와 같이 마이그레이션 히스토리를 확인해 본다. python manage.py showmigrations 그러면 아래와 같이 blog 앱에는 마이그레이션이 없다는 결과를 확인할 수 있다. admin [X] 0001_initial [X] 0002_logentry_remove_auto_add auth [X] 0001_initial [X] 0002_alter_permission_name_max_length [X] 0003_alter_user_email_max_length [X] 0004_alter_user_user name_opts [X] 0005_alter_user_last_login_null [X] 0006_require_contenttypes_0002 [X] 0007_alter_validators_add_error_messages [X] 0008_alter_user_user name_max_length blog (no migrations) contenttypes [X] 0001_initial [X] 0002_remove_content_type_name sessions [X] 0001_initial 초기 마이그레이션 파일 생성 이제 초기 마이그레이션 파일을 만들기 위해 아래와 같이 명령한다. python manage.py makemigrations 최초 마이그레이션 파일 0001_initial.py이 생성된 것을 확인할 수 있다. Migrations for 'blog': blog\migrations\0001_initial.py - Create model Post 페이크 마이그레이션 데이터베이스 테이블이 이미 존재하기 때문에 초기 마이그레이션 파일을 적용할 수 없다. 따라서 마치 마이그레이션을 한 것처럼 아래와 같이 명령하여 페이크 마이그레이션한다. python manage.py migrate --fake-initial 결과는 다음과 같다. Operations to perform: Apply all migrations: admin, auth, blog, contenttypes, sessions Running migrations: Applying blog.0001_initial... FAKED 그리고 최종 마이그레이션 히스토리를 보면 아래와 같이 blog 앱에는 0001_initial 마이그레이션만 반영된 것으로 확인할 수 있다. python manage.py showmigrations admin [X] 0001_initial [X] 0002_logentry_remove_auto_add auth [X] 0001_initial [X] 0002_alter_permission_name_max_length [X] 0003_alter_user_email_max_length [X] 0004_alter_user_user name_opts [X] 0005_alter_user_last_login_null [X] 0006_require_contenttypes_0002 [X] 0007_alter_validators_add_error_messages [X] 0008_alter_user_user name_max_length blog [X] 0001_initial contenttypes [X] 0001_initial [X] 0002_remove_content_type_name sessions [X] 0001_initial 요약하면 아래와 같은 순서로 명령한다. python manage.py makemigrations python manage.py showmigrations python manage.py migrate --fake 프로젝트_앱 zero 마이그레이션 파일 삭제 python manage.py makemigrations python manage.py migrate --fake-initial 03. 뷰(컨트롤러) 01) URL 패턴 매핑 기본 문법 url 정의 클래스 형 뷰와 함수형 뷰 호출 파일 인클루드 추가사항 주요 실무 예제 PK - 정수 슬러그(slug) - 문자열 PK + 슬러그 조합 사용자 아이디(이메일 주소 포함) 연도별 월별 일별 URI 관련 규칙 문서(document) 집합(collection) 창고(store) 컨트롤러 Post 모델을 다루는 URL 규칙 예시 기타 유의사항 기본 문법 url 정의 urlpatterns = [ url(정규식, 뷰, kwargs=None, name=None, prefix=''), ] 정규식: URL을 정규식으로 표현 뷰: URL 매칭이 되면 불러올 뷰 (CBV 또는 FBV) kwargs: 정규식 인자에서 추출한 파라미터 외에 추가적인 인자를 파이썬 사전 타입의 키워드 인자로 뷰 함수에 전달 가능 name: URL 별로 별명을 두어 템플릿 파일에서 사용 prefix: 뷰 함수에 대한 접두사 문자열 2.0 버전부터는 path() 함수를 이용한다. 비교 정리 예정 클래스 형 뷰와 함수형 뷰 호출 뷰는 요청을 받아 응답을 반환해 주는 호출 가능한 객체이다. Django에서는 뷰를 함수 형태로 작성할 수도 있고 클래스 형태로 작성할 수도 있다. 클래스 형 뷰 호출 urlpatterns = [ url(r'^$', Home.as_view(), name='home'), ] 함수형 뷰 호출 urlpatterns = [ url(r'^$', views.home, name='home'), ] 파일 인클루드 urlpatterns = [ url(r'^polls/', include('polls.urls', namespace='polls')), ] 추가사항 1.8 버전 이후 patterns() 함수를 사용하지 않고 간단하게 urlpatterns 리스트를 정의한다. 주요 실무 예제 출처: List of Useful URL Patterns PK - 정수 정규식: (?P<pk>\d+) 예시 url(r'^questions/(?P<pk>\d+)/$', QuestionDV.as_view(), name='question_detail'), 슬러그(slug) - 문자열 정규식: (?P<slug>[-\w]+) 예시 url(r'^posts/(?P<slug>[-\w]+)/$', PostDV.as_view(), name='post_detail'), PK + 슬러그 조합 정규식: (?P<slug>[-\w]+)-(?P<pk>\d+) 예시 url(r'^blog/(?P<slug>[-\w]+)-(?P<pk>\d+)/$', PostDV.as_view(), name='blog_post'), 사용자 아이디(이메일 주소 포함) 정규식: (?P<month>[0-9]{2})/(?P<day>[0-9]{2}) 예시 url(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/(?P<day>[0-9]{2})/$', PostDAV.as_view(), name='post_day_archive'), URI 관련 규칙 RESTful API 이름 짓는 규칙을 참고하여 일관성 있는 이름을 지을 것을 권장한다. 문서(document) http://api.example.com/device-management/managed-devices/{device-id} http://api.example.com/user-management/users/{id} http://api.example.com/user-management/users/admin 위 예시에서 문서는 device-management, user-management 같은 단수형 명사이다. Django에서는 주로 앱 이름이 될 수 있다. 집합(collection) http://api.example.com/device-management/managed-devices http://api.example.com/user-management/users http://api.example.com/user-management/users/{id}/accounts 위 예시에서 집합은 managed-devices, users 같은 복수형 명사이다. accounts는 집합이 아니고 아래에서 설명하는 창고이다. 창고(store) http://api.example.com/cart-management/users/{id}/carts http://api.example.com/song-management/users/{id}/playlists 위 예시에서 창고는 carts 또는 playlists 같은 복수형 명사이다. 이는 여러 users 중 특정 {id} 값의 사용자의 장바구니, 재생목록을 뜻한다. 컨트롤러 http://api.example.com/cart-management/users/{id}/cart/checkout http://api.example.com/song-management/users/{id}/playlist/play 위 예시에서 checkout, play 같은 동사로 컬렉션/스토어의 한 인스턴스가 할 수 있는 동작(액션)을 뜻한다. Post 모델을 다루는 URL 규칙 예시 목록: /blog/posts/ 생성: /blog/new/ 보기: /blog/posts/1/ 수정: /blog/posts/1/edit/ 삭제: /blog/posts/1/delete/ 객체와 무관한 메서드: /blog/posts/view-name/ 객체와 관련 있는 메서드: /blog/posts/1/view-name/ 기타 유의사항 계층구조를 표현하기 위해 / (슬래시)를 사용한다. URI 끝에는 / (슬래시)를 붙이지 않는다. 가독성을 위해 _ (밑줄) 대신에 - (대시)를 일관적으로 사용한다. 모든 문자는 소문자로 통일한다. 02) 클래스 형 뷰 (CBV) 클래스 형 뷰 (CBV, Class-Based View) CBV의 장점 CBV 사용 가이드라인 제너릭 뷰와 상속 주요 제너릭 뷰 목록 기반 뷰(Base View) 제너릭 보기 뷰(Generic Display View) 제너릭 수정 뷰(Generic Edit View) 제너릭 날짜 뷰(Generic Date View) 제너릭 뷰 오버라이딩 속성 변수 오버라이딩 model queryset template_name context_object_name paginate_by date_field form_class success_url 메서드 오버라이딩 def get_queryset() def get_context_data(**kwargs) def form_valid(form) 모델을 지정하는 방법 3가지 예제 코드 믹스인 다중 상속 클래스 형 뷰 (CBV, Class-Based View) 클래스 형 뷰는 상속과 믹스인 기능을 이용하여 코드 재사용하고 뷰를 체계적으로 구성할 수 있다. CBV의 장점 GET, POST 등 HTTP 메서드에 따른 처리 코드를 작성할 때 if 함수 대신에 메서드 명으로 코드의 구조가 깔끔하다. 다중 상속 같은 객체지향 기법을 활용해 제너릭 뷰, 믹스인 클래스 등을 사용해 코드의 재사용과 개발 생산성을 높여준다. CBV 사용 가이드라인 뷰는 간단 명료해야 한다. 뷰 코드의 양은 적으면 적을수록 좋다. 뷰 안에서 같은 코드를 반복적으로 사용하지 않는다. 뷰는 프레젠테이션 로직에서 관리하고 비즈니스 로직은 모델에서 처리한다. 매우 특별한 경우에만 폼에서 처리한다. 403, 404, 500 에러 핸들링에는 CBV를 이용하지 않고 FBV를 이용한다. 믹스인은 간단명료해야 한다. 제너릭 뷰와 상속 제너릭 뷰의 4가지 분류 기반 뷰(Base View): 뷰 클래스를 생성하고 다른, 제너릭 뷰의 부모 클래스가 되는 기본 제너릭 뷰 제너릭 보기 뷰(Generic Display View): 객체의 목록 또는 하나의 객체 상세 정보를 보여주는 뷰 제너릭 수정 뷰(Generic Edit View): 폼을 통해 객체를 생성, 수정, 삭제하는 기능을 제공하는 뷰 제너릭 날짜 뷰(Generic Date View): 날짜 기반 객체의 연/월/일 페이지로 구분해 보여주는 뷰 주요 제너릭 뷰 목록 기반 뷰(Base View) View: 최상위 부모 제너릭 뷰 클래스 TemplateView: 주어진 템플릿으로 렌더링 RedirectView: 주어진 URL로 리다이렉트 제너릭 보기 뷰(Generic Display View) DetailView: 조건에 맞는 하나의 객체 출력 ListView: 조건에 맞는 객체 목록 출력 제너릭 수정 뷰(Generic Edit View) FormView: 폼이 주어지면 해당 폼을 출력 CreateView: 객체를 생성하는 폼 출력 UpdateView: 기존 객체를 수정하는 폼을 출력 DeleteView: 기존 객체를 삭제하는 폼을 출력 제너릭 날짜 뷰(Generic Date View) YearArchiveView: 주어진 연도에 해당하는 객체 출력 MonthArchiveView: 주어진 월에 해당하는 객체 출력 DayArchiveView: 주어진 날짜에 해당하는 객체 출력 TodayArchiveView: 오늘 날짜에 해당하는 객체 출력 DateDetailView: 주어진 연, 월, 일 PK(또는 슬러그)에 해당하는 객체 출력 제너릭 뷰 오버라이딩 속성 변수 오버라이딩 model 기본 뷰(View, Template, RedirectView) 3개를 제외하고 모든 제너릭 뷰에서 사용한다. queryset 기본 뷰(View, Template, RedirectView) 3개를 제외하고 모든 제너릭 뷰에서 사용한다. queryset을 사용하면 model 속성은 무시된다. template_name TemplateView를 포함한 모든 제너릭 뷰에서 사용한다. 템플릿 파일명을 문자열로 지정한다. context_object_name 뷰에서 템플릿 파일에 전달하는 컨텍스트 변수명을 지정한다. paginate_by ListView와 날짜 기반 뷰(예, YearArchiveView)에서 사용한다. 페이징 기능이 활성화된 경우 페이지당 출력 항목 수를 정수로 지정한다. date_field 날짜 기반 뷰(예, YearArchiveView)에서 사용한다. 이 필드의 타입은 DateField 또는 DateTimeField이다. form_class FormView, CreateView, UpdateView에서 폼을 만드는데 사용할 클래스를 지정한다. success_url FormView, CreateView, UpdateView, DeleteView에서 폼에 대한 처리가 성공한 후 리디이렉트할 URL 주소이다. 메서드 오버라이딩 def get_queryset() 기본 뷰(View, Template, RedirectView) 3개를 제외하고 모든 제너릭 뷰에서 사용한다. 디폴트는 queryset 속성을 반환한다. queryset 속성이 지정되지 않은 경우 모델 매니저 클래스의 all() 메서드를 호출해 QuerySet 객체를 생성해 반환한다. def get_context_data(**kwargs) 뷰에서 템플릿 파일에 넘겨주는 컨텍스트 데이터를 추가하거나 변경하는 목적으로 오버라이딩한다. def form_valid(form) 모델을 지정하는 방법 3가지 model 속성 변수 지정 queryset 속성 변수 지정 def get_queryset() 메서드 오버라이딩 예제 코드 from django.views.generic import ListView, DetailView from .models import Question class IndexView(ListView): template_name = 'cbvpolls/index.html' context_object_name = 'latest_question_list' def get_queryset(self): return Question.objects.order_by('-pub_date')[:5] class DetailView(DetailView): model = Question template_name = 'cbvpolls/detail.html' class ResultsView(DetailView): model = Question template_name = 'cbvpolls/results.html' 믹스인 다중 상속 03) 함수형 뷰 (FBV) 함수형 뷰 (FBV, Function-Based View) 예제 코드 함수형 뷰 (FBV, Function-Based View) 예제 코드 from django.shortcuts import render, get_object_or_404 from django.core.urlresolvers import reverse from .models import Question def index(request): latest_question_list = Question.objects.all().order_by('-pub_date')[:5] context = {'latest_question_list': latest_question_list} return render(request, 'polls/index.html', context) def detail(request, question_id): question = get_object_or_404(Question, pk=question_id) return render(request, 'polls/detail.html', {'question': question}) def results(request, question_id): question = get_object_or_404(Question, pk=question_id) return render(request, 'polls/results.html', {'question': question}) 04. 템플릿 01) 템플릿 변수 템플릿 변수 request 템플릿 변수 request GET 파라미터 미포함: {{ request.path }} - /board/free GET 파라미터 포함: {{ request.get_full_path }} /board/free?page=3&q=test 02) 템플릿 필터 기본 템플릿 필터 줄 바꿈 문자 자르기 문자열 연결 특수문자 이스케이프 HTML 태그 제거 대문자로 소문자로 커스텀 템플릿 필터 여러 가지 문제 해결 띄어쓰기 안 하기 기본 템플릿 필터 줄 바꿈 문자 자르기 문자열 연결 특수문자 이스케이프 HTML 태그 제거 대문자로 소문자로 커스텀 템플릿 필터 blog 이름의 앱 안에 커스텀 템플릿 필터를 구현하는 소스 파일의 구성은 다음과 같다. blog/ templatetags/ __init__.py blog_filters.py blog_tags.py 앱 디렉터리 안에 templatetags 이름의 패키지를 만들고 그 안에는 내용이 빈 파일 __init__.py 파일이 존재한다. 그리고 앱_ filters.py 파일 안에 커스텀 필터를 정의하고 앱_ tags 파일 안에 커스텀 태그를 정의한다. blog/templatetags/blog_filters.py 파일 예시는 다음과 같다. import bleach import markdown from django import template from django.template.defaultfilters import stringfilter from django.utils.safestring import mark_safe register = template.Library() @register.filter @stringfilter def markdownify(text): tags = ['h1', 'h2', 'h3', 'h4', 'h5', 'ol', 'ul', 'li', 'div', 'p', 'code', 'blockquote', 'pre', 'table', 'thead', 'tbody', 'tr', 'th', 'td', 'a', 'em', 'strong', 'hr', 'img'] attrs = { '*': ['class', 'id'], 'a': ['href', 'rel'], 'img': ['alt', 'src'], } return mark_safe( bleach.clean( markdown.markdown(text, output_format='html', extensions=['markdown.extensions.tables', 'markdown.extensions.fenced_code', 'markdown.extensions.codehilite', 'markdown.extensions.toc', ], ), tags=tags, attributes=attrs, strip=True)) 주어진 마크다운<NAME>의 문자열을 HTML<NAME>의 문자열로 바꾸는 커스텀 필터이다. 이는 템플릿에서 아래와 같이 사용할 수 있다. <div class="row"> <div class="col-md-12 post"> {% load blog_filters %} {{ post.content|markdownify }} </div> </div> 여러 가지 문제 해결 띄어쓰기 안 하기 |(bar)로 연결할 때는 띄어쓰기하지 않는다. 예를 들어, 아래와 같은 코드가 있을 때 url 태그의 아규먼트의 개수를 잘못 파악하는 에러가 발생할 수 있다. {% url 'blog:post_month_archive' date|date:'Y' date|date:'m' %} 03) 템플릿 태그 기본 템플릿 태그 URL 생성 간단한 커스텀 템플릿 태그 패키지 구성 커스텀 태그 구현 커스텀 태그 사용하기 복잡한 커스텀 템플릿 태그 구현 패키지 구성 커스텀 태그 구현 커스텀 태그 사용하기 재귀적 템플릿 태그 구현 패키지 구성 커스텀 태그 구현 커스텀 태그 사용하기 기본 템플릿 태그 URL 생성 템플릿 소스 코드에서 URL을 하드코딩하지 않도록 한다. {% url '네임스페이스:뷰_이름' 아규먼트1 아규먼트2 %} 간단한 커스텀 템플릿 태그 패키지 구성 blog 앱의 커스텀 템플릿 태그를 만든다고 가정하면 이름 규칙에 따라 아래와 같은 구조를 갖는다. blog/ templatetags/ __init__.py blog_tags.py templatetags 이름의 패키지를 만들고 빈 파일의 __init__.py 파일을 만든다. 그리고 앱_이름_ tags.py 모듈을 만든다. 커스텀 태그 구현 최근 게시물 n 개를 가져오는 커스텀 태그를 구현한다고 가정하면 아래와 같은 코드와 비슷하다. from django import template from .. models import Post register = template.Library() @register.simple_tag def recent_posts(count): posts = Post.objects.filter(status='published').order_by('-published')[:count] return posts 커스텀 태그 사용하기 템플릿에서 최신 글 5개를 가져오는 recent_posts 커스텀 템플릿 태그는 아래와 같이 사용할 수 있다. {% load blog_tags %} <ul> {% recent_posts 5 as posts %} {% for post in posts %} <li><a href="{{ post.get_absolute_url }}">{{ post.title|truncatechars:25 }}</a></li> {% endfor %} </ul> 복잡한 커스텀 템플릿 태그 구현 여기서 복잡하다는 것의 기준은 다음 2가지이다. 커스텀 템플릿 태그 호출할 때 파라미터를 전달한다. 커스텀 템플릿 태그에서 다른 html 페이지를 렌더링 하여 출력한다. 패키지 구성 mptt 라이브러리를 사용한 navbar 메뉴를 재귀적으로 호출하는 커스텀 템플릿 태그를 만든다고 가정한다. 이름 규칙에 따라 기본 커스텀 템플릿 태그와 비슷한 구조를 갖는다. navbar/ templates/ menu.html templatetags/ __init__.py navbar_tags.py templatetags 이름의 패키지를 만들고 빈 파일의 __init__.py 파일을 만든다. 그리고 앱_이름_ tags.py 모듈을 만드는 점은 같다. 차이점이 있다면 렌더링 할 html 파일을 templates 디렉터리 안에 넣어둔다. 그리고 커스텀 태그 함수의 데코레이터를 @register.simple_tag이 아니라 @register.tag로 사용한다. simple_tag로 지정할 경우 에러가 발생한다. 커스텀 태그 구현 {% navbar_menu '메뉴 이름' '렌더링. html' %} 위와 같은<NAME>으로 커스텀 태그를 호출하려고 한다. 따라서 '메뉴 이름'과 '렌더링. html' 아규먼트를 커스텀 태그 구현할 때 올바로 전달받아야 한다. from django import template from .. models import MenuItem register = template.Library() @register.tag def navbar_menu(parser, token): template_name = 'menu.html' # 입력받은 토큰을 분리한다. tokens = token.split_contents() num = len(tokens) if num not in [2, 3]: raise template.TemplateSyntaxError('%r tag requires two arguments.' % tokens[0]) tree_query_set = MenuItem.objects.filter(menu__title=tokens[1][1:-1]) if num == 3: template_name = tokens[2][1:-1] return Menu(tree_query_set, template_name) class Menu(template.Node): def __init__(self, tree_query_set, template_name): self.tree_query_set = tree_query_set self.template_name = template_name def render(self, context): t = context.template.engine.get_template(self.template_name) return t.render( template.Context({ 'tree_menu': self.tree_query_set }, autoescape=context.autoescape)) 커스텀 태그 함수의 시그니처를 (parser, token)으로 할 경우 token 변수는 태그 이름을 포함하여 전달받은 전체 변수가 된다. 이때, 입력받은 토큰을 split_contents 메서드로 분리하면 2개 또는 3개의 토큰이 된다. 렌더링 할 html 파일의 이름을 지정하지 않으면 디폴트 이름으로 menu.html으로 가정한다. 주의할 점은 token에 {% navbar _menu 'top_menu' %} 이와 같이 전달할 경우 두 번째 아규먼트 토큰의 문자열은 top_menu가 아니라 'top_menu' 따옴표가 감싸진 형태이다. MenuItem.objects.filter(menu__title=tokens[1][1:-1]) 이와 같이 필터로 검색 조건 문자열을 쓸 때는 앞뒤의 따옴표를 벗겨내는 코드 [1:-1] 코드를 써야 한다. 커스텀 태그 함수의 반환값은 반드시 template.Node 클래스를 상속하고 render() 메서드를 정의하고 있어야 한다. 렌더링 할 html 파일에 넘겨줄 컨텍스트 변수는 template.Context 클래스의 인스턴스로 넘겨준다. /templates/menu.html 파일 {% load i18n %} {% load mptt_tags %} <ul class="nav navbar-nav"> {% recursetree tree_menu %} {% if not node.is_leaf_node %} <li class="dropdown"> <a href="#" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false"> {{ node.title }} <span class="caret"></span> </a> <ul class="dropdown-menu"> {{ children }} </ul> </li> {% else %} <li> <a href="{{ node.path }}" target="{{ node.target }}">{% trans node.title %}</a> </li> {% endif %} {% endrecursetree %} </ul> 렌더링 하는 html 파일의 내용은 위와 같이 작성할 수 있으며 앞서 호출하는 쪽에서 tree_menu 컨텍스트 변수를 넘겨준 것에 유의한다. 또한 템플릿 파일의 위치는 기본값으로 시스템 전역 templates 디렉터리가 아니라 앱/templates 디렉터리에서 찾는다. 커스텀 태그 사용하기 앞서 만든 커스텀 템플릿 태그는 템플릿에서 아래와 같이 사용할 수 있다. {% load navbar_tags %} {% navbar_menu 'top_menu' 'menu.html' %} 재귀적 템플릿 태그 구현 패키지 구성 커스텀 태그 구현 from django import template from django.utils.safestring import mark_safe from mptt.utils import get_cached_trees from .. models import MenuItem register = template.Library() class NavbarNode(template.Node): def __init__(self, nodes, tree_query_set): self.nodes = nodes self.tree_query_set = tree_query_set self.request = template.Variable('request') def _render_menu_item(self, context, menu_item): request = self.request.resolve(context) nodes = [] context.push() for child in menu_item.get_children(): nodes.append(self._render_menu_item(context, child)) menu_item.active = False if menu_item.match == 'equals' and request.path == menu_item.url \ or menu_item.match == 'startswith' and request.path.startswith(menu_item.url): menu_item.active = True context['menu_item'] = menu_item context['children'] = mark_safe(''.join(nodes)) rendered = self.nodes.render(context) context.pop() return rendered def render(self, context): roots = get_cached_trees(self.tree_query_set) nodes = [self._render_menu_item(context, menu_item) for menu_item in roots] return ''.join(nodes) @register.tag def navbar(parser, token): # separates the arguments on spaces while keeping quoted strings together tokens = token.split_contents() if len(tokens) != 2: raise template.TemplateSyntaxError('%r tag requires a tree queryset.' % tokens[0]) nodes = parser.parse(('endnavbar',)) parser.delete_first_token() tree_query_set = MenuItem.objects \ .get(title=tokens[1][1:-1]) \ .get_descendants(include_self=False) return NavbarNode(nodes, tree_query_set) 커스텀 태그 사용하기 {% load navbar_tags %} {% navbar '홈' %} {% if not menu_item.is_leaf_node %} <li class="dropdown"> <a href="#" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false"> {{ menu_item.title }} <span class="caret"></span> </a> <ul class="dropdown-menu"> {{ children }} </ul> </li> {% else %} <li{% if menu_item.active %} class="active"{% endif %}> <a href="{{ menu_item.url }}">{{ menu_item.title }}</a> </li> {% endif %} {% endnavbar %} 04) 템플릿의 상속 기본 문법 템플릿 태그 기본 문법 템플릿 태그 05) 템플릿 실무 템플릿 구조 전역적 templates 디렉터리 vs. 앱별 templates 디렉터리 2단계 템플릿 구조 vs. 3단계 템플릿 구조 Jinja2 DTL과 Jinja2 Jinja2 설치 및 설정 템플릿 구조 전역적 templates 디렉터리 vs. 앱별 templates 디렉터리 Two Scoops of Django 책에서는 templates/ 디렉터리 안에 앱별로 디렉터리를 두고 일괄적으로 관리할 것을 추천한다. 물론 취향에 따라서 앱마다 templates/ 디렉터리를 둘 수도 있다. 2단계 템플릿 구조 vs. 3단계 템플릿 구조 2단계 템플릿 구조는 모든 템플릿은 하나의 base.html 파일을 상속한다. templates/ base.html dashboard.html # base.html 상속 profiles/ profiles_detail.html # base.html 상속 profiles_form.html # base.html 상속 3단계 템플릿 구조는 앱별로 base_<앱_이름>.html 파일이 있고 이는 base.html 파일을 상속한다. 각 앱 안의 템플릿은 모두 base_<앱_이름>.html 파일을 상속한다. base.html과 같은 디렉터리 안에 있는 모든 템플릿은 base.html 파일을 상속한다. templates/ base.html dashboard.html # base.html 상속 profiles/ base_profiles.html # base.html 상속 profiles_detail.html # base_profiles.html 상속 profiles_form.html # base_profiles.html 상속 3단계 템플릿 구조는 앱마다 레이아웃이 다른 경우에 적합하다. 예를 들어, 지방 뉴스 섹션, 단문 광고 섹션, 행사 섹션마다 다른 레이아웃을 제공할 수 있다. Jinja2 Django 1.8 버전부터 다중 템플릿 엔진을 지원한다. DTL과 Jinja2를 모두 기본 내장하고 있다. DTL과 Jinja2 DTL의 장점 Django의 공식 템플릿 엔진으로 별도의 설치와 설정이 필요 없다. DTL+Django 조합이 DTL+Jinja2 조합보다 더 많이 사용되어 검증되었다. 대부분의 서드파티 Django 패키지에서 DTL을 사용한다. 많은 양의 DTL 레거시 코드를 Jinja2로 바꾸는 것은 상당히 큰 작업이다. Jinja2의 장점 Django와 독립적으로 사용할 수 있다. DTL 문법보다 Jinja2 문법이 파이썬 문법에 더 가까워 직관적이다. Jinja2가 좀 더 명시적이고 명확하게 구성되어 있다. Jinja2가 좀 더 빠르다. 어느 것을 선택할 것인가. Django를 처음 배우는 개발자는 DTL을 이용한다. DTL로 작성된 레거시 프로젝트의 경우 특별히 성능 향상이 필요한 몇 페이지를 제외하고는 DTL을 이용한다. Django를 공부하고 둘을 비교해서 선택한다. Jinja2 설치 및 설정 Django는 다중 템플릿 엔진을 지원하지만 Jinja2 패키지가 함께 배포되지는 않는다. 따라서 먼저 Jinja2 패키지를 설치한다. pip install Jinja2 settings.py 파일을 수정한다. TEMPLATES = [ { 'BACKEND': 'django.template.backends.jinja2.Jinja2', 'DIRS': [os.path.join(BASE_DIR, 'templates')], 'APP_DIRS': True, 'OPTIONS': { # ... some options here ... }, }, ] 템플릿 백엔드 API를 django.template.backends.django.DjangoTemplates에서 django.template.backends.jinja2.Jinja2로 변경한다. templates 디렉터리에 Jinja2 템플릿 파일이 위치한다. 05) 페이지 네이션 페이지 네이션 Paginator 객체 Page 객체 예제 코드 클래스 형 뷰 템플릿 코드 믹스 인과 템플릿 인클루드 페이지 네이션 Paginator 객체 주요 속성 paginator.page_range: 전체 페이지 번호 xrange Page 객체 주요 속성 page_obj.number: 현재 페이지 번호 page.previous_page_number: 이전 페이지 번호 page.next_page_number: 다음 페이지 번호 예제 코드 페이지가 20개, 30개가 넘어가도 전체를 보여주므로 몇 개씩 끊어서 페이지를 보여주는 것을 별도로 처리할 필요가 있다. 클래스 형 뷰 클래스 형 뷰에 메서드를 추가한다. paginated_by = 10 # 한 페이지 목록에 표시 게시물 수 (단 한 줄로 페이지 네이션이 구현됨) def get_context_data(self, **kwargs): context = super(PostListView, self).get_context_data(**kwargs) block_size = 5 # 하단의 페이지 목록 수 start_index = int((context['page_obj'].number - 1) / self.block_size) * self.block_size end_index = min(start_index + self.block_size, len(context['paginator'].page_range)) context['page_range'] = context['paginator'].page_range[start_index:end_index] return context 템플릿 코드 템플릿 코드는 부트스트랩의 페이지 네이션 디자인을 활용하는 코드이다. <!-- Pagination --> <nav aria-label="Page navigation"> <ul class="pagination"> {% if page_obj.has_previous %} <li> <a href="?page={{ page_obj.previous_page_number }}" aria-label="Previous"> <span aria-hidden="true">«</span> </a> </li> {% else %} <li class="disabled"><span>«</span></li> {% endif %} {% for i in page_range %} {% if page_obj.number == i %} <li class="active"><span>{{ i }} <span class="sr-only">(current)</span></span></li> {% else %} <li><a href="?page={{ i }}">{{ i }}</a></li> {% endif %} {% endfor %} {% if page_obj.has_next %} <li> <a href="?page={{ page_obj.next_page_number }}" aria-label="Next"> <span aria-hidden="true">»</span> </a> </li> {% else %} <li class="disabled"><span>»</span></li> {% endif %} </ul> </nav> 믹스 인과 템플릿 인클루드 여러 개의 클래스 뷰마다 위와 같이 동일한 코드를 작성한다는 것은 귀찮은 일이다. 믹스인을 작성해놓고 해당 믹스인을 클래스 형 뷰 선언에 추가할 수 있다. PageableMixin 믹스인을 아래와 같이 정의한다. class PageableMixin(object): logger = logging.getLogger(__name__) paginate_by = 10 block_size = 10 def get_context_data(self, **kwargs): self.logger.debug('PageableMixin.get_context_data()') context = super(PageableMixin, self).get_context_data(**kwargs) start_index = int((context['page_obj'].number - 1) / self.block_size) * self.block_size end_index = min(start_index + self.block_size, len(context['paginator'].page_range)) context['page_range'] = context['paginator'].page_range[start_index:end_index] return context PageableMixin 믹스인을 사용하는 클래스 형 뷰 MessageListView를 아래와 같의 선언할 수 있다. class MessageListView(BoardContextMixin, PageableMixin, ListView): logger = logging.getLogger(__name__) context_object_name = 'messages' template_name = 'board/message_list.html' def __init__(self): self.logger.debug('MessageListView.__init__()') super(MessageListView, self).__init__() self.block_size = 10 # default value def get_queryset(self): self.logger.debug('MessageListView.get_queryset()') return Message.objects.published() \ .select_related('author') \ .select_related('board') \ .filter(board__slug=self.kwargs['slug']) \ .order_by('-date_created') def get_context_data(self, **kwargs): self.logger.debug('MessageListView.get_context_data()') context = super(MessageListView, self).get_context_data(**kwargs) context['board'] = self.board # already fetched by BoardContextMixin.dispatch() return context def get_paginate_by(self, queryset): self.logger.debug('MessageListView.get_paginate_by()') self.block_size = self.board.block_size return self.board.chunk_size PageableMixin의 멤버 변수 paginate_by와 block_size는 결국 MessageListView 클래스의 get_paginate_by() 메서드에 의해 섀도 된다. 그리고 위의 템플릿 코드를 페이지마다 쓰지 않고 별도의 파일로 _pagination.html 같이 분리하고 이를 인클루드 하는 코드로 재사용 가능하다. {% include '_pagination.html' with page_obj=page_obj page_range=page_range %} 위와 같이 _pagination.html 파일을 인클루드하기 위해 page_obj, page_range 변수를 전달해 줄 필요가 있다. 05. 폼 01) 폼 폼 처리 과정 3단계 일반 폼 모델 폼 모델 폼의 주요 메서드 호출 순서 폼 처리 과정 3단계 폼 처리 과정의 3단계는 다음과 같다. GET 메서드로 처음으로 폼을 출력한다. 빈 폼 또는 값을 채운(prepopulated) 폼이다. 유효하지 않은 값을 받은 경우 에러 메시지와 함께 폼을 다시 출력한다. 유효한 값을 받은 경우 데이터 처리하고 일반적으로 리다이렉트한다. Django의 폼은 크게 두 가지로 존재한다. 일반 폼 모델 폼 일반 폼 모델 폼 CreateView를 상속한 클래스에서 model 속성을 지정하면 자동으로 해당 ModelForm이 생성된다. class MessageCreateView(CreateView): model = Message fields = ['title', 'content', ] template_name = 'board/message_form.html' 유효성 검증을 추가하기 위해 커스텀 ModelForm 을 직접 지정하고 싶다면 model 속성 대신에 form_class 속성을 지정한다. class MessageCreateView(CreateView): form_class = MessageForm template_name = 'board/message_form.html' CreateView에서는 model 속성을 생략할 수 있지만 UpdateView에서는 model 속성까지 꼭 지정해 줘야 한다. class MessageUpdateView(UpdateView): model = Message form_class = MessageForm template_name = 'board/message_form.html' 만약 model 속성을 지정하지 않으면 아래와 같은 에러 메시지가 발생한다. django.core.exceptions.ImproperlyConfigured: MessageUpdateView is missing a QuerySet. Define MessageUpdateView.model, MessageUpdateView.queryset, or override MessageUpdateView.get_queryset(). 모델 폼의 주요 메서드 호출 순서 GET 메서드 요청 시 주요 메서드의 호출 순서이다. dispatch() get_context_data() get_initial() POST 메서드 요청 시 주요 메서드의 호출 순서이다. dispatch() get_initial() form_valid() get_success_url() 여기서 중요한 것은 get_context_data() 메서드가 POST 요청 시에는 호출되지 않는다. 반면에 form_valid() 메서드는 폼 데이터를 전송받지 못했으므로 역시 GET 요청 시에는 호출되지 않는다. GET, POST 요청에서 공통된 작업을 하고자 할 경우 get_initial() 메서드를 이용할 수 있다. 다만 이 메서드는 FormMixin의 메서드이기 때문에 FormMixin을 상속받지 않는 클래스 형 뷰에서는 작업이 처리되지 않는다. 앱 전체 뷰에서 공통으로 호출되길 원한다면 dispatch() 메서드를 오버라이딩해야 한다. 02) 폼 검증 03) 파일 업로드 이미지 업로드와 출력 파일 업로드와 다운로드 이미지 업로드와 출력 파일 업로드와 다운로드 04) 커스텀 위젯 커스텀 위젯 widgets.py 파일 templates/simplemde/simplemde.html 파일 커스텀 위젯 디폴트 TextArea 대신에 위지위그 에디터를 사용하고자 할 경우 커스텀 위젯을 작성할 수 있다. 여러 가지 WYSYWIG 에디터 django 모듈은 편리하게 설치 가능하지만 만약 에디터 변경을 위해 제거할 경우 데이터베이스 마이그레이션 문제가 발생하는 경우가 있다. 마이그레이션 파일에서 모델의 필드 타입을 변경했기 때문에 마이그레이션 파일에 앱의 의존성이 남기 때문이다. 이를 해결하기 위해서는 데이터베이스의 내용은 그대로 남겨두고 마이그레이션 파일을<NAME>는 것이다. 마이그레이션 파일 삭제하기 문서를 참고한다. 다음 예제는 SimpleMDE 에디터를 위한 커스텀 위젯을 만드는 예시이다. widgets.py 파일 from django.forms import widgets from django.template import loader from django.utils.safestring import mark_safe class SimpleMDEWidget(widgets.Textarea): # 템플릿 파일이 앱 안에 존재하도록 했다. 이는 별도의 앱으로 제작할 때 동작한다. template_name = 'simplemde/simplemde.html' # static/simplemde 디렉터리 안에 있는 CSS와 자바스크립트 파일을 불러온다. # simplemde.min.css와 simplemde.min.js 파일은 SimpleMDE에서 배포하는 파일이다. class Media: css = { 'all': ( 'simplemde/simplemde.min.css', 'simplemde/custom.css', ) } js = ( 'simplemde/simplemde.min.js', ) def __init__(self, attrs=None, wrapper_class='simplemde-box', options=''): # 템플릿을 출력할 때 wrapper_class와 options 변수를 넘겨주기 위해 가져온다. self.wrapper_class = wrapper_class self.options = options super(SimpleMDEWidget, self).__init__(attrs=attrs) def render(self, name, value, attrs=None, renderer=None): context = { 'widget': { 'name': name, 'value': value, 'wrapper_class': self.wrapper_class, 'options': self.options, } } # 템플릿을 렌더링 한다. template = loader.get_template(self.template_name).render(context) # 템플릿 파일의 문자열을 이스케이프하고 반환한다. return mark_safe(template) templates/simplemde/simplemde.html 파일 <div class="{{ widget.wrapper_class }}"> <textarea id="id-{{ widget.name }}" name="{{ widget.name }}">{% if widget.value %}{{ widget.value }}{% endif %}</textarea> <script> simplemde = new SimpleMDE({ element: document.getElementById("id-{{ widget.name }}"), {% autoescape off %}{{ widget.options }}{% endautoescape %} }); </script> </div> 위젯으로 렌더링 하는 템플릿 파일이다. {% autoescape off %}{{ widget.options }}{% endautoescape %} 구문이 필요한 이유는 위젯을 렌더링 할 때 mark_safe() 메서드를 통해 호출될 때 자바스크립트 옵션이 이스케이프 되는 걸 방지하기 위함이다. 06. 인증과 권한 01) Django 기본 인증 Django 제공 인증 기능 이름 규칙 기본 테이블 설계 구현 settings.py 파일 설정 URL 패턴 및 뷰 회원 가입 폼 뷰와 회원 가입 완료 출력 정의 템플릿 오버라이딩 로그인 로그아웃 비밀번호 변경 비밀번호 초기화 Django 제공 인증 기능 이름 규칙 django.contrib.auth.urls 모듈에는 인증 관련 URL 패턴과 이를 처리하는 뷰가 미리 정의되어 있다. urlpatterns = [ url(r'^login/$', views.LoginView.as_view(), name='login'), url(r'^logout/$', views.LogoutView.as_view(), name='logout'), url(r'^password_change/$', views.PasswordChangeView.as_view(), name='password_change'), url(r'^password_change/done/$', views.PasswordChangeDoneView.as_view(), name='password_change_done'), url(r'^password_reset/$', views.PasswordResetView.as_view(), name='password_reset'), url(r'^password_reset/done/$', views.PasswordResetDoneView.as_view(), name='password_reset_done'), url(r'^reset/(?P<uidb64>[0-9A-Za-z_\-]+)/(?P<token>[0-9A-Za-z]{1,13}-[0-9A-Za-z]{1,20})/$', views.PasswordResetConfirmView.as_view(), name='password_reset_confirm'), url(r'^reset/done/$', views.PasswordResetCompleteView.as_view(), name='password_reset_complete'), ] 위 정의를 이용하되 개발자는 실제로 템플릿을 만들어야 한다. URL 패턴 뷰 이름 템플릿 파일명 /accounts/login/ login() registration/login.html /accounts/logout/ logout() registration/logged_out.html (개발자 지정) logout_then_login() (개발자가 지정) /accounts/password_change/ password_change() registration/password_change_form.html /accounts/password_change/done/ password_change_done() registration/password_change_done.html /accounts/password_reset/ password_reset() registration/password_reset_form.html registration/password_reset_email.html registration/password_reset_subject.txt /accounts/password_reset/done/ password_reset_done() registration/password_reset_done.html /accounts/reset/ password_reset_confirm() registration/password_reset_confirm.html /accounts/reset/done/ password_reset_complete() registration/password_reset_complete.html 다음 항목은 개발자가 직접 개발해야 한다. URL 패턴 뷰 이름 템플릿 파일명 /accounts/register/ UserCreasteView(CreateView) registration/register.html /accounts/register/done UserCreateDoneTemplateView(TemplateView) registration/register_done.html 폼 클래스 로그인 화면 폼: AuthenticationForm 회원 가입 폼: UserCreationForm 비밀번호 변경 폼: PasswordChangeForm 기본 테이블 설계 구현 settings.py 파일 설정 settings.py에서 django.contrib.auth 앱은 기본적으로 설치되어 있고 인증 관련 기본 변수를 정의한다. INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', # 기본 설치됨 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', ] LOGIN_URL = '/accounts/login/' # 기본값 LOGOUT_URL = '/accounts/logout/' # 기본값 LOGIN_REDIRECT_URL = '/' # 반드시 정의할 것! URL 패턴 및 뷰 urlpatterns = [ url(r'^accounts/', include('django.contrib.auth.urls')), url(r'^accounts/register/$', UserCreateView.as_view(), name='register'), url(r'^accounts/register/done/$', UserCreateDoneTemplateView.as_view(), name='register_done'), ] django.contrib.auth.urls 모듈을 인클루드하여 Django가 기본 제공하는 것을 최대한 재사용한다. 그리고 UserCreateView 뷰와 UserCreateDoneTemplateView 뷰를 개발자가 직접 만든다. urls.py 모듈을 분리하여 namespace를 부여하고 별도의 앱 안에서 URL 패턴을 정의할 경우 올바로 동작하지 않는 경우가 있다. 회원 가입 폼 뷰와 회원 가입 완료 출력 정의 회원 가입 뷰 from django.contrib.auth.forms import UserCreationForm class UserCreateView(CreateView): template_name = 'registration/register.html' form_class = UserCreationForm success_url = reverse_lazy('common:register_done') # 네임스페이스 정확하게 회원 가입 완료 후 안내 페이지 출력 뷰 class UserCreateDoneTemplateView(TemplateView): template_name = 'registration/register_done.html' 템플릿 오버라이딩 로그인 로그아웃 비밀번호 변경 비밀번호 초기화 02) Django 기본 권한 관리 Django 기본 권한 관리 Django 기본 권한 관리 03) User 모델의 확장 기법 비교 목적 User 모델의 확장 여러 가지 기법 프락시 모델 사용하기 개요 구현 User 모델과 일대일 관계의 프로필 테이블 추가하기 개요 구현 AbstractUser 모델 상속한 사용자 정의 User 모델 사용하기 개요 구현 AbstractBaseUser 모델 상속한 사용자 정의 User 모델 사용하기 개요 구현 결론 또는 의견 참고문헌 목적 Django의 기본 User 모델이 제공하는 필드 외에 추가적인 사용자 정보, 프로필 등을 저장하고 싶은 경우 기본 User 모델의 비밀번호 알고리즘을 변경하고 싶은 경우 User 모델의 확장 여러 가지 기법 프락시 모델 사용하기 User 모델과 일대일 관계의 프로필 테이블 추가하기 AbstractUser 모델 상속한 사용자 정의 User 모델 사용하기 AbstractBaseUser 모델 상속한 사용자 정의 User 모델 사용하기 프락시 모델 사용하기 개요 프락시 모델이란 새 테이블을 추가하는 등의 데이터베이스 스키마 변경 없이 단순히 상속한 클래스이다. 정렬 순서 같은 기존 모델의 동작을 변경하거나 새로운 메서드를 추가하기 위해 사용한다. 데이터베이스에 부가적인 사용자 정보를 저장할 필요가 없을 때 사용하는 방법이다. 구현 프락시 모델 기법은 User 모델을 상속하지만 실제로 테이블엔 어떠한 변경도 없다. from django.contrib.auth.models import User from .managers import PersonManager class Person(User): objects = PersonManager() class Meta: proxy = True ordering = ('first_name', ) def do_something(self): ... 위 코드의 내용을 살펴보면 다음과 같다. User 모델을 상속한 Person 클래스를 정의한다. Meta 내부 클래스를 정의하면서 프락시 모델 클래스임을 선언하고 정렬 순서를 first_name 기준으로 변경한다. do_something 같은 메서드를 추가할 수 있다. User.objects.all()과 Person.objects.all() 코드는 스키마의 변경이 없으므로 같은 쿼리로 동작한다. User 모델과 일대일 관계의 프로필 테이블 추가하기 개요 기존 User 모델과 OneToOneField로 일대일 관계를 맺는 Django 모델을 추가해서 사용자에 관한 정보를 저장하는 것이다. Django의 인증 시스템을 그대로 활용하고 로그인, 권한 부여 등과 상관이 없는 사용자 정보 필드를 저장하고자 할 때 사용하는 기법이다. 구현 Profile 모델을 구현한다. from django.db import models from django.contrib.auth.models import User class Profile(models.Model): user = models.OneToOneField(User, on_delete=models.CASCADE) bio = models.TextField(max_length=500, blank=True) location = models.CharField(max_length=30, blank=True) birth_date = models.DateField(null=True, blank=True) AbstractUser 모델 상속한 사용자 정의 User 모델 사용하기 개요 AbstractUser 모델을 상속한 User 모델을 만들어 settings.py에 참조를 수정해야 한다. 이 기법의 사용 여부는 프로젝트 시작 전에 하는 것이 좋다. 추후에 settings.AUTH_USER_MODEL 변경 시 데이터베이스 스키마를 알맞게 재수정해야 하는데 사용자 모델 필드에 추가나 수정으로 끝나지 않고 완전히 새로운 사용자 객체를 생성하는 일이 된다. 이 기법은 기존 Django의 User 모델을 그대로 사용하므로 기본 로그인 인증 처리 부분은 Django의 것을 이용하면서 몇몇 사용자 정의 필드를 추가할 때 유용하다. 구현 AbstractBaseUser 모델 상속한 사용자 정의 User 모델 사용하기 개요 AbstractBaseUser 모델을 상속한 User 모델을 만들고 settings.py에 참조를 수정하는 것은 AbstractUser 모델을 상속하는 것과 같다. 따라서 마찬가지로 프로젝트 시작 전에 이 기법의 사용 여부를 결정하는 것이 바람직하다. 그런데 AbstractUser 모델을 상속하는 방법과 달리 로그인 아이디로 이메일 주소를 사용하도록 하거나 Django 로그인 절차가 아닌 인증 절차를 직접 구현하고자 할 때 사용할 수 있다. 구현 AbstractBaseUser의 상속 문서를 참고한다. 결론 또는 의견 Django의 기본 인증 시스템을 재사용 여부가 어떠한 기법을 사용할지 결정하는데 가장 중요하다. Django의 기본 인증 시스템을 재사용한다면 일대일 관계를 맺는 프로필 모델을 만들어서 관리한다. 인증 및 권한 관리를 직접 구현한다면 AbstractBaseUser 테이블을 상속해 모델을 만든다. 다시 말해서 만약에 Django로 신규 프로젝트를 시작한다면 일대일 관계를 맺는 프로필 모델을 사용하고 기존 시스템을 마이그레이션하는 경우에는 AbstractBaseUser 테이블을 상속해 모델을 만드는 것이 유리하다. 참고문헌 How to Extend Django User Model 04) 커스텀 User 모델 (AbstractBaseUser의 상속) AbstractBaseUser 클래스 상속의 장단점 구현 예시 account/models.py account/forms.py account/admin.py settings.py AbstractBaseUser 클래스 상속의 장단점 AbstractBaseUser 모델을 상속한 User 커스텀 모델을 만들면 로그인 아이디로 이메일 주소를 사용하거나 Django 로그인 절차가 아닌 다른 인증 절차를 직접 구현할 수 있다. 예를 들어, 기존에 운영 중이던 PHP 설루션의 회원 디비를 그대로 재사용하고자 한다면 AbstractBaseUser 모델을 상속한 User 커스텀 모델을 만들어야 한다. 단점은 운영 중에 시스템 사용자 모델을 변경하는 것이 매우 어렵다는 점이다. 따라서 이미 운영 중인 Django 기반 웹 사이트의 경우에는 그냥 기존 모델을 사용하자. 구현 예시 Django 공식 문서에서 Customizing authentication in Django - A full example 부분에 예제가 있다. 해당 예제에서 수정된 부분을 중심으로 설명한다. account/models.py 회원 관리를 위해 account 같이 원하는 이름으로 별도의 앱을 만든다. 공식 문서 예제와 다른 점은 다음과 같다. AbstractBaseUser 상속뿐만 아니라 PermissionsMixin을 다중 상속한다. Django의 기본 그룹, 허가권 관리 기능을 재사용한다. 생일(date_of_birth) 필드 대신에 닉네임(nickname) 필드를 추가한다. from django.contrib.auth.models import ( BaseUserManager, AbstractBaseUser, PermissionsMixin ) from django.db import models from django.utils import timezone from django.utils.translation import ugettext_lazy as _ class UserManager(BaseUserManager): def create_user(self, email, nickname, password=None): """ 주어진 이메일, 닉네임, 비밀번호 등 개인 정보로 User 인스턴스 생성 """ if not email: raise ValueError(_('Users must have an email address')) user = self.model( email=self.normalize_email(email), nickname=nickname, ) user.set_password(password) user.save(using=self._db) return user def create_superuser(self, email, nickname, last_name, first_name, password): """ 주어진 이메일, 닉네임, 비밀번호 등 개인 정보로 User 인스턴스 생성 단, 최상위 사용자이므로 권한을 부여한다. """ user = self.create_user( email=email, password=password, nickname=nickname, ) user.is_superuser = True user.save(using=self._db) return user class User(AbstractBaseUser, PermissionsMixin): email = models.EmailField( verbose_name=_('Email address'), max_length=255, unique=True, ) nickname = models.CharField( verbose_name=_('Nickname'), max_length=30, unique=True ) is_active = models.BooleanField( verbose_name=_('Is active'), default=True ) date_joined = models.DateTimeField( verbose_name=_('Date joined'), default=timezone.now ) # 이 필드는 레거시 시스템 호환을 위해 추가할 수도 있다. salt = models.CharField( verbose_name=_('Salt'), max_length=10, blank=True ) objects = UserManager() USER NAME_FIELD = 'email' REQUIRED_FIELDS = ['nickname', ] class Meta: verbose_name = _('user') verbose_name_plural = _('users') ordering = ('-date_joined',) def __str__(self): return self.nickname def get_full_name(self): return self.nickname def get_short_name(self): return self.nickname @property def is_staff(self): "Is the user a member of staff?" # Simplest possible answer: All superusers are staff return self.is_superuser get_full_name.short_description = _('Full name') account/forms.py from django import forms from django.contrib.auth.forms import ReadOnlyPasswordHashField from django.utils.translation import ugettext_lazy as _ from .models import User, UserManager class UserCreationForm(forms.ModelForm): # 사용자 생성 폼 email = forms.EmailField( label=_('Email'), required=True, widget=forms.EmailInput( attrs={ 'class': 'form-control', 'placeholder': _('Email address'), 'required': 'True', } ) ) nickname = forms.CharField( label=_('Nickname'), required=True, widget=forms.TextInput( attrs={ 'class': 'form-control', 'placeholder': _('Nickname'), 'required': 'True', } ) ) password1 = forms.CharField( label=_('Password'), widget=forms.PasswordInput( attrs={ 'class': 'form-control', 'placeholder': _('Password'), 'required': 'True', } ) ) password2 = forms.CharField( label=_('Password confirmation'), widget=forms.PasswordInput( attrs={ 'class': 'form-control', 'placeholder': _('Password confirmation'), 'required': 'True', } ) ) class Meta: model = User fields = ('email', 'nickname') def clean_password2(self): # 두 비밀번호 입력 일치 확인 password1 = self.cleaned_data.get("password1") password2 = self.cleaned_data.get("password2") if password1 and password2 and password1 != password2: raise forms.ValidationError("Passwords don't match") return password2 def save(self, commit=True): # Save the provided password in hashed format user = super(UserCreationForm, self).save(commit=False) user.email = UserManager.normalize_email(self.cleaned_data['email']) user.set_password(self.cleaned_data["password1"]) if commit: user.save() return user class UserChangeForm(forms.ModelForm): # 비밀번호 변경 폼 password = ReadOnlyPasswordHashField( label=_('Password') ) class Meta: model = User fields = ('email', 'password', 'last_name', 'first_name', 'is_active', 'is_superuser') def clean_password(self): # Regardless of what the user provides, return the initial value. # This is done here, rather than on the field, because the # field does not have access to the initial value return self.initial["password"] account/admin.py account 앱의 admin.py 파일을 아래와 같이 정의한다. from django.contrib import admin from django.contrib.auth.admin import UserAdmin as BaseUserAdmin from django.contrib.auth.models import Group from django.utils.translation import ugettext_lazy as _ from .forms import UserCreationForm, UserChangeForm from .models import User class UserAdmin(BaseUserAdmin): # The forms to add and change user instances form = UserChangeForm add_form = UserCreationForm # The fields to be used in displaying the User model. # These override the definitions on the base UserAdmin # that reference specific fields on auth.User. list_display = ('get_full_name', 'email', 'nickname', 'is_active', 'is_superuser', 'date_joined') list_display_links = ('get_full_name',) list_filter = ('is_superuser', 'is_active',) fieldsets = ( (None, {'fields': ('email', 'password')}), (_('Personal info'), {'fields': ('nickname', )}), (_('Permissions'), {'fields': ('is_active', 'is_superuser',)}), ) # add_fieldsets is not a standard ModelAdmin attribute. UserAdmin # overrides get_fieldsets to use this attribute when creating a user. add_fieldsets = ( (None, { 'classes': ('wide',), 'fields': ('email', 'nickname', 'password1', 'password2')} ), ) search_fields = ('email','nickname') ordering = ('-date_joined',) filter_horizontal = () # Now register the new UserAdmin... admin.site.register(User, UserAdmin) settings.py 시스템 사용자 모델을 디폴트에서 변경하기 위해 아래와 같이 설정을 변경한다. AUTH_USER_MODEL = 'account.User' 05) 비밀번호 암호화 알고리즘 변경 비밀번호 암호화 알고리즘 변경 구현 예시 로그인 처리 백엔드 구현 백엔드 등록 회원 가입 처리 User 모델에서 set_password 메서드 오버라이딩 비밀번호 변경 및 리셋 User 모델에서 check_password 메서드 오버라이딩 비밀번호 암호화 알고리즘 변경 기존 시스템의 비밀번호 암호화 알고리즘을 사용하고자 할 경우 인증 백엔드(Authentication Backend)의 authenticate() 메서드와 get_user() 메서드를 재정의한다. AbstractBaseUser의 상속 참고 그리고 User 모델의 set_password()와 check_password() 메서드를 재정의한다. 비밀번호 암호화 알고리즘 변경을 위해 다음 사항을 가정한다. AbstractBaseUser 클래스를 상속해 User 모델 재정의한다. User 모델에는 기존 비밀번호 암호화 알고리즘 호환을 위해 password, salt 필드 등이 올바른 값으로 존재한다고 가정한다. 구현 예시 PHP 오픈소스 쇼핑몰 Opencart의 기존 회원 DB를 Django에서 재사용하기 위해 구현하기 위해 예제를 작성하였다. 로그인 처리 백엔드 구현 account/backends.py 파일을 만들어 백엔드를 정의한다. 이 백엔드 안에 authenticate() 메서드가 로그인 처리를 담당한다. from hashlib import sha1 from .models import User class OpencartBackend: # Django 로그인 프러시 저가 호출하는 인증 메서드 def authenticate(self, user name=None, password=None): try: # 커스텀 User 모델에서 이메일 주소를 user name으로 사용한 경우 user = User.objects.get(email=User name) # Salted password SHA1 hashing 3 iterations # Opencart PHP 프로그램의 비밀번호 암호화 알고리즘 hashed = sha1( (user.salt + sha1( (user.salt + sha1( password.encode('utf8') ).hexdigest()).encode('utf8') ).hexdigest()).encode('utf8') ).hexdigest() if user.password == hashed: return user else: return None except User.DoesNotExist: return None # Required for your backend to work properly - unchanged in most scenarios def get_user(self, user_id): try: return User.objects.get(pk=user_id) except User.DoesNotExist: return None 위 예시 코드는 솔트값으로 SHA1 암호화 3회 돌리는 기존 시스템의 비밀번호 암호화 알고리즘을 구현했다. 기존 시스템의 암호화 방식은 시스템마다 다르므로 알맞게 직접 구현해야 한다. 백엔드 등록 settings.py 파일에 아래와 같이 백엔드를 등록한다. AUTHENTICATION_BACKENDS = ('account.backends.OpencartBackend',) 앱. 백엔드 모듈. 클래스 구조로 절대 경로를 적어준다. 기존 데이터베이스 이메일, 비밀번호, 솔트 값이 올바로 저장되어 있다는 가정하에 로그인이 잘 된다. 회원 가입 처리 User 모델에서 set_password 메서드 오버라이딩 회원 가입에서는 첫 비밀번호를 기존 암호화 알고리즘으로 저장할 수 있도록 User 모델을 다음과 같이 수정해야 한다. salt 필드를 추가한다. set_password() 메서드를 오버라이딩한다. import os from hashlib import sha1, md5 class User(AbstractBaseUser, PermissionsMixin): ... 생략 ... salt = models.CharField( verbose_name=_('Salt'), max_length=10, blank=True ) ... 생략 ... def set_password(self, raw_password): # Opencart의 salt 값은 9자리의 alphanumeric 문자열 salt = md5(os.urandom(128)).hexdigest()[:9] # Opencart PHP 프로그램의 비밀번호 암호화 알고리즘 hashed = sha1( (salt + sha1( (salt + sha1( raw_password.encode('utf8') ).hexdigest()).encode('utf8') ).hexdigest()).encode('utf8') ).hexdigest() self.salt = salt self.password = hashed ... 생략 ... 이제 새로운 사용자를 만들 때에도 기존 시스템의 비밀번호 암호화 알고리즘에 맞게 password와 salt 값을 저장한다. 비밀번호 변경 및 리셋 비밀번호 변경과 리셋에서는 새로운 비밀번호 저장을 위해 set_password() 메서드를 호출하지만 그전에 기존 비밀번호를 올바르게 입력했는지 확인하는 check_password() 메서드를 호출하므로 이를 기존 암호화 알고리즘으로 수정한다. User 모델에서 check_password 메서드 오버라이딩 User 모델의 check_password() 메서드를 기존 시스템의 비밀번호 암호화 알고리즘에 맞게 오버라이딩해야 한다. import os from hashlib import sha1, md5 class User(AbstractBaseUser, PermissionsMixin): ... 생략 ... def check_password(self, raw_password): try: user = User.objects.get(email=self.email) hashed = sha1( (user.salt + sha1( (user.salt + sha1( raw_password.encode('utf8') ).hexdigest()).encode('utf8') ).hexdigest()).encode('utf8') ).hexdigest() if user.password == hashed: return True else: return False except User.DoesNotExist: return False ... 생략 ... 06) 회원 가입 이메일 인증 처리 회원 가입 이메일 인증 처리 회원 가입 폼 인증 메일 발송 양식 이메일 인증 활성화 처리 뷰 이메일 인증 완료 템플릿 URL 패턴 등록 참고 UID 변환 토큰 생성 이메일 발송 처리 참고 사이트 회원 가입 이메일 인증 처리 회원 가입 폼 UserCreationForm을 상속한 웹 인터페이스에서 회원가입을 받기 위한 WebUserCreationForm 폼 클래스를 별도로 만든다. 그 이유는 같은 폼을 사용해서 관리자 페이지에서 사용자를 추가할 경우 이메일 발송을 위해 request 객체를 얻지 못하므로 에러가 발생하고 특히, 관리자가 직접 사용자 추가할 땐 어떤 목적이 있을 것이므로 굳이 이메일 인증 활성화가 불필요하다고 판단된다. Django 기본 폼에서 웹 인터페이스를 위한 폼을 분리하면 이용약관, 개인정보보호 방침 동의 폼 등을 추가할 수 있다. UserCreationForm 폼 클래스는 이미 email 필드를 갖고 있고 필수로 입력받도록 정의하고 있다. class UserCreationForm(forms.ModelForm): email = forms.EmailField( label=_('Email'), required=True, widget=forms.EmailInput( attrs={ 'class': 'form-control', 'placeholder': _('Email address'), 'required': 'True', } ) ) ... 생략 ... class Meta: model = User fields = ('email', 'last_name', 'first_name', 'nickname') UserCreationForm 폼 클래스를 상속하는 WebUserCreationForm 폼 클래스를 아래와 같이 작성한다. class WebUserCreationForm(UserCreationForm): terms = forms.BooleanField( label=_('Terms of service'), widget=forms.CheckboxInput( attrs={ 'required': 'True', } ), error_messages={ 'required': _('You must agree to the Terms of service to sign up'), } ) privacy = forms.BooleanField( label=_('Privacy policy'), widget=forms.CheckboxInput( attrs={ 'required': 'True', } ), error_messages={ 'required': _('You must agree to the Privacy policy to sign up'), } ) def __init__(self, *args, **kwargs): # important to "pop" added kwarg before call to parent's constructor self.request = kwargs.pop('request') super(UserCreationForm, self).__init__(*args, **kwargs) def save(self, commit=True): user = super(WebUserCreationForm, self).save(commit=False) if commit: user.is_active = False user.save() # Send user activation mail current_site = get_current_site(self.request) subject = (_('Welcome To %s! Confirm Your Email') % current_site.name) message = render_to_string('registration/user_activate_email.html', { 'user': user, 'domain': current_site.domain, 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'token': PasswordResetTokenGenerator().make_token(user), }) email = EmailMessage(subject, message, to=[user.email]) email.send() return user 토큰 생성을 위해 PasswordResetTokenGenerator Django 기본 라이브러리를 활용한다. 별도로 라이브러리를 제작할 필요가 없고 데이터베이스에 추가 필드가 필요하지 않다는 장점이 있다. 인증 메일 발송 양식 templates/registration/user_activate_email.html 파일 {% load i18n %}{% autoescape off %} {% blocktrans %} Please click on the link to confirm your registration, {% endblocktrans %} http://{{ domain }}{% url 'account:activate' uidb64=uid token=token %} {% endautoescape %} 이메일 인증 활성화 처리 뷰 account/views.py 파일 class UserActivateView(TemplateView): logger = logging.getLogger(__name__) template_name = 'registration/user_activate_complete.html' def get(self, request, *args, **kwargs): self.logger.debug('UserActivateView.get()') uid = force_text(urlsafe_base64_decode(self.kwargs['uidb64'])) token = self.kwargs['token'] self.logger.debug('uid: %s, token: %s' % (uid, token)) try: user = User.objects.get(pk=uid) except(TypeError, ValueError, OverflowError, User.DoesNotExist): self.logger.warning('User %s not found' % uid) user = None if user is not None and PasswordResetTokenGenerator().check_token(user, token): user.is_active = True user.save() self.logger.info('User %s(pk=%s) has been activated.' % (user, user.pk)) return super(UserActivateView, self).get(request, *args, **kwargs) 이메일 인증 완료 템플릿 {% extends "base.html" %} {% load i18n %} {% block title %}{{ title }}{% endblock %} {% block content %} <div class="container"> <div class="spacer_30"> </div> <div class="spacer_90 hidden-sm hidden-xs"> </div> <div class="row"> <div class="col-md-8 col-md-offset-2"> <div class="panel panel-default"> <div class="panel-body"> <p>{% trans "Your account has been activated. You may go ahead and log in now." %}</p> <p><a class="btn btn-success" href="{% url 'account:login' %}">{% trans 'Log in' %}</a></p> </div> </div> </div> </div> </div> {% endblock %} URL 패턴 등록 urlpatterns = [ ... 생략 ... url( r'^register/$', UserCreateView.as_view(), name='register' ), url( r'^register/done/$', UserCreateDoneTemplateView.as_view(), name='register-done' ), url( r'^activate/(?P<uidb64>[0-9A-Za-z_\-]+)/(?P<token>[0-9A-Za-z]{1,13}-[0-9A-Za-z]{1,20})/$', UserActivateView.as_view(), name='activate' ) ] 참고 UID 변환 사용자 PK 값을 UID로 변환한다. from django.utils.encoding import force_bytes from django.utils.http import urlsafe_base64_encode uid = urlsafe_base64_encode(force_bytes(user.pk)) UID에서 사용자 PK를 구한다. from django.utils.encoding import force_text from django.utils.http import urlsafe_base64_decode uid = force_text(urlsafe_base64_decode(self.kwargs['uidb64'])) 토큰 생성 비밀번호 토큰을 생성하기 위해 사용한다. from django.contrib.auth.tokens import PasswordResetTokenGenerator token = PasswordResetTokenGenerator().make_token(user) 토큰이 올바른지 검증하고 True/False 반환한다. PasswordResetTokenGenerator().check_token(user, token) 토근의 유효기간은 기본값이 3일이며 이를 바꾸는 것은 settings.py에서 변경한다. PASSWORD_RESET_TIMEOUT_DAYS = 1 단, 이 값을 바꾸면 결과적으로 비밀번호 리셋 요청 이메일의 토큰 유효기간도 1일로 줄어든다. 그런데 어느 쪽이든 굳이 이 토큰 값을 1일 이상 유지할 이유는 없어 보인다. 이메일 발송 처리 from django.contrib.sites.shortcuts import get_current_site from django.core.mail import EmailMessage from django.template.loader import render_to_string current_site = get_current_site(self.request) subject = (_('Welcome To %s! Confirm Your Email') % current_site.name) message = render_to_string('registration/user_activate_email.html', { 'user': user, 'domain': current_site.domain, 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'token': PasswordResetTokenGenerator().make_token(user), }) email = EmailMessage(subject, message, to=[user.email]) email.send() registration/user_activate_email.html 양식에 따라서 이메일을 발송한다. 단, settings.py 파일에서 이메일 백엔드를 설정해야 하며 테스트로 gmail을 사용한다면 아래와 비슷하게 설정할 수 있다. EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend' EMAIL_HOST = 'smtp.gmail.com' EMAIL_PORT = 587 EMAIL_HOST_USER = 'user name@gmail.com' EMAIL_HOST_PASSWORD = '앱 비밀번호' EMAIL_USE_TLS = True 참고 사이트 Django registration with confirmation email 07) 회원 가입 및 로그인 reCAPTCHA 입력 회원 가입할 때 로그인할 때 회원 가입 및 로그인할 때 불특정 다수 또는 봇으로부터 기계적인 시도로 공격을 당하는 경우가 있다. 이러한 피해를 최소화하기 위해 회원 가입 및 로그인할 때 reCAPTCHA를 도입할 수 있다. 구글 reCAPTCHA 페이지에서 키를 발급받고 사용하는 방법을 설명한다. 여기서는 회원 가입과 로그인하는 경우에 대하여 reCAPTCHA를 어떻게 적용할지 살펴본다. 회원 가입할 때 사용자 정의 WebUserCreationForm 폼 클래스에 clean() 메서드를 재정의한다. class WebUserCreationForm(UserCreationForm): ... 생략 ... def clean(self): # Google reCAPTCHA ''' reCAPTCHA 검증 시작 ''' recaptcha_response = self.request.POST.get('g-recaptcha-response') url = 'https://www.google.com/recaptcha/api/siteverify' values = { 'secret': settings.GOOGLE_RECAPTCHA_SECRET_KEY, 'response': recaptcha_response } data = urllib.parse.urlencode(values).encode() req = urllib.request.Request(url, data=data) response = urllib.request.urlopen(req) result = json.loads(response.read().decode()) ''' reCAPTCHA 검증 끝 ''' if not result['success']: raise forms.ValidationError(_('reCAPTCHA error occurred.')) return super(WebUserCreationForm, self).clean() 회원가입 템플릿 페이지는 아래와 같이 작성할 수 있다. <form action="." method="post" class="form-horizontal"> {% csrf_token %} {% if form.errors %} <div class="alert alert-danger" role="alert"> {% for error in form.errors.values %} {{ error|striptags }} {% endfor %} </div> {% endif %} <div class="form-group"> <label for="{{ form.email.id_for_label }}" class="col-sm-3 control-label">{{ form.email.label }}</label> <div class="col-sm-9"> {{ form.email }} {{ form.email.errors|striptags }} </div> </div> ... 생략 ... <div class="form-group"> <div class="col-sm-offset-3 col-sm-9"> <div class="checkbox"> <label> {{ form.terms }} {% trans 'I have read and agree to the Terms of service.' %} </label> </div> </div> </div> ... 생략 ... <div class="form-group"> <div class="col-sm-offset-3 col-sm-9"> <!-- Google reCAPTCHA --> <script src='https://www.google.com/recaptcha/api.js'></script> <div class="g-recaptcha" data-sitekey="공개 사이트 키값"></div> </div> </div> <div class="form-group"> <div class="col-sm-offset-3 col-sm-9"> <button type="submit" class="btn btn-default">{% trans 'Sign up' %}</button> </div> </div> </form> 로그인할 때 사용자 정의 UserLoginForm 폼 클래스에 clean() 메서드를 재정의한다. WebUserCreationForm 폼 클래스에 clean() 메서드와 다른 부분은 부모 생성자 호출 이름밖에 없다. class UserLoginForm(AuthenticationForm): ... 생략 ... def clean(self): # Google reCAPTCHA ''' reCAPTCHA 검증 시작 ''' recaptcha_response = self.request.POST.get('g-recaptcha-response') url = 'https://www.google.com/recaptcha/api/siteverify' values = { 'secret': settings.GOOGLE_RECAPTCHA_SECRET_KEY, 'response': recaptcha_response } data = urllib.parse.urlencode(values).encode() req = urllib.request.Request(url, data=data) response = urllib.request.urlopen(req) result = json.loads(response.read().decode()) ''' reCAPTCHA 검증 끝 ''' if not result['success']: raise forms.ValidationError(_('reCAPTCHA error occurred.')) return super(UserLoginForm, self).clean() 로그인 템플릿 페이지는 아래와 같이 작성할 수 있다. <form action="." method="post" accept-charset="UTF-8" role="form"> {% csrf_token %} {% if form.errors %} <div class="alert alert-danger" role="alert"> {% for error in form.errors.values %} {{ error|striptags }} {% endfor %} </div> {% endif %} <fieldset> <div class="form-group"> {{ form.user name }} {{ form.user name.errors }} </div> <div class="form-group"> {{ form.password }} {{ form.password.errors }} </div> <div class="form-group"> <!-- Google reCAPTCHA --> <script src='https://www.google.com/recaptcha/api.js'></script> <div class="g-recaptcha" data-sitekey="공개 사이트 키값"></div> </div> <div class="checkbox"> <label> <input name="remember" type="checkbox" value="Remember Me"> {% trans 'Remember me' %} </label> <a href="{% url 'account:password_reset' %}" class="pull-right">{% trans 'Forgot password' %}</a> </div> <input type="hidden" name="next" value="{{ next }}"/> <input class="btn btn-mg btn-success btn-block" type="submit" value="{% trans 'Sign in' %}"> </fieldset> </form> 08) 로그인 로깅 (시그널) 시그널 모델 작성 로그인 로그를 저장하는 시그널 리스너 작성 관리자 화면 보기 매번 로그인할 때 사용자의 기본적인 접속 정보를 로그 남겨두는 것은 향후 보안 시스템 관리상 유용하다. 시그널 시그널 리스너를 작성한다. account/signals.py 파일 import logging from django.contrib.auth.signals import user_logged_in, user_logged_out from django.dispatch import receiver @receiver(user_logged_in) def sig_user_logged_in(sender, user, request, **kwargs): logger = logging.getLogger(__name__) logger.debug("user logged in: %s at %s" % (user, request.META['REMOTE_ADDR'])) @receiver 데코레이터를 이용해 sig_user_logged_in() 함수 이름으로 user_logged_in 시그널을 처리하는 함수를 만든다. 참고로 django/contrib/auth/__init__.py 파일의 login(request, user, backend=None) 함수 맨 밑에 보면 로그인 작업을 완료한 후 시그널을 보내는 코드가 존재한다. python user_logged_in.send(sender=user.__class__, request=request, user=user) 로그인할 때마다 이미 위와 같이 시그널을 보내고 있으므로 이를 수신하는 함수를 정의하면 된다. 시그널 수신 함수를 정의하고 이를 Django 앱 설정을 통해 아래의 코드로 등록해야 한다. account/apps.py 파일 from django.apps import AppConfig from django.utils.translation import ugettext_lazy as _ class AccountConfig(AppConfig): name = 'account' verbose_name = _('Account') def ready(self): import account.signals 이제 로그인할 때 콘솔에서 로그인 로그가 올바로 찍히는지 확인한다. 모델 작성 from django.conf import settings from django.db import models from model_utils.models import TimeStampedModel class UserLoginLog(TimeStampedModel): user = models.ForeignKey( settings.AUTH_USER_MODEL, verbose_name=_('User'), related_name='login_logs', blank=True, null=True ) ip_address = models.GenericIPAddressField( verbose_name=_('IP Address') ) user_agent = models.CharField( verbose_name=_('HTTP User Agent'), max_length=300, ) class Meta: verbose_name = _('user login log') verbose_name_plural = _('user login logs') ordering = ('-created',) def __str__(self): return '%s %s' % (self.user, self.ip_address) 로그인 로그를 저장하는 시그널 리스너 작성 이제 실제로 UserLoginLog 인스턴스를 만들어 데이터베이스에 추가하는 코드를 시그널 처리 함수에서 작성한다. from ipware.ip import get_ip @receiver(user_logged_in) def sig_user_logged_in(sender, user, request, **kwargs): log = UserLoginLog() log.user = user log.ip_address = get_ip(request) log.user_agent = request.META['HTTP_USER_AGENT'] log.save() 사용자 아이피 주소를 얻기 위해 request.META['REMOTE_ADDR'] 코드가 아닌 django-ipware 라이브러리를 사용한다. 관리자 화면 보기 관리자 모델을 등록한다. account/admin.py 파일 class UserLoginLogAdmin(admin.ModelAdmin): list_display = ('user', 'ip_address', 'user_agent',) list_filter = ('ip_address',) date_hierarchy = 'created' admin.site.register(UserLoginLog, UserLoginLogAdmin) 07. 관리자 화면 01) 슈퍼 유저 생성 슈퍼유저 생성 슈퍼유저 생성 슈퍼유저 아이디와 이메일을 입력하고 비밀번호를 두 번 입력한다. >python manage.py createsuperuser User name (leave blank to use 'pinco'): admin Email address: test@example.com Password: Password (again): Superuser created successfully. 위 예시에서 슈퍼유저의 아이디는 편의상 admin으로 하였다. 02) 관리자 화면 개선 admin URL 구하기 인라인 폼셋에 추가/삭제 jQuery 이벤트 리스너 admin URL 구하기 AdminSite는 다음 URL 패턴을 제공한다. 페이지 1 URL 이름 파라미터 인덱스 admin:index 로그아웃 logout 비밀번호 변경 password_change 비밀번호 변경 완료 password_change_done 앱 인덱스 페이지 app_list app_lebel 객체 페이지로 리다이렉트 view_on_site content_type_id, object_id ModelAdmin은 다음 URL 패턴을 제공한다. 페이지 1 URL 이름 파라미터 목록 수정 앱_모델명_ changelist 추가 앱_모델명_ add 히스토리 앱_모델명_ history object_id 삭제 앱_모델명_ delete object_id 수정 앱_모델명_ change object_id 인라인 폼셋에 추가/삭제 jQuery 이벤트 리스너 Post 모델을 참조하는 Image 모델이 있다고 가정한다. Post 모델을 수정할 때 Image 모델을 동시에 추가, 삭제하기 위하여 인라인 폼셋을 사용할 수 있다. class ImageInline(admin.StackedInline): model = Image extra = 2 class PostAdmin(admin.ModelAdmin): ... inlines = [ImageInline] ... 이 폼셋에 데이터가 추가/삭제될 때마다 합계 등을 위한 jQuery 처리를 하고 싶다면 먼저 해당 관리자 템플릿 페이지를 오버라이딩해야 한다. blog 앱의 Post 모델 변경 페이지이므로 모델 변경을 위한 관리자 템플릿 페이지 오버라이딩은 templates/admin/blog/post/change_form.html 파일을 새로 만들어서 admin/change_form.html 파일을 상속 재정의한다. {% extends 'admin/change_form.html' %} {% load static %} {% block admin_change_form_document_ready %} {{ block.super }} <script type="text/javascript" src="{% static 'js/blog/post/formset_handlers.js' %}"></script> {% endblock %} 해당 페이지에서 {% static 'js/blog/post/formset_handlers.js' %} 자바스크립트를 로드하고 실제 js 파일 주소는 아마도 /js/blog/post/formset_handlers.js로 해석될 것이다. formset_handlers.js 파일의 내용의 뼈대는 다음과 같다. (function ($) { $(document).on('formset:added', function (event, $row, formsetName) { console.log('row added'); }); $(document).on('formset:removed', function (event, $row, formsetName) { console.log('row deleted') }); })(django.jQuery); 03) 관리자 페이지 셀렉트 박스 커스터마이징 외래 키 참조로 셀렉트 박스 내용 제한 종속 중첩된(cascading) 셀렉트 메뉴 외래 키 참조로 셀렉트 박스 내용 제한 "스포츠" 게시판에 "축구", "야구" 등을 분류하고 있고 "게임" 게시판에 "RPG", "FPS" 등으로 분류하고 있다고 할 때 일반적으로 게시물 모델에서 카테고리를 참조하면 기본적으로 "축구", "야구", "RPG", "FPS" 등 모든 카테고리가 나열된다. "스포츠" 게시판을 선택했을 때는 "축구", "야구" 등 종목만 목록에 보이도록 하는 것이 사용자 편의성과 데이터의 정합성을 위해 올바르다. 즉, 외래 키의 참조 필드 내용에 따라 선택적으로 셀렉트 박스 목록을 보여주고 싶다면 formfield_for_foreignkey() 메서드를 오버라이딩한다. def get_form(self, request, obj=None, **kwargs): request.current_object = obj return super(MessageAdmin, self).get_form(request, obj, **kwargs) def formfield_for_foreignkey(self, db_field, request, **kwargs): instance = request.current_object if db_field.name == 'category': kwargs['queryset'] = Category.objects.filter(board=instance.board) return super(MessageAdmin, self).formfield_for_foreignkey(db_field, request, **kwargs) 문제는 formfield_for_foreignkey 메서드에서 request.user 객체는 바로 접근할 수 있지만 참조하는 인스턴스에는 바로 접근할 수 없다. 특정 인스턴스를 넘겨받기 위해서는 get_form() 메서드를 오버라이딩하는 트릭을 써야 한다. get_form() 메서드를 오버라이딩해서 request 객체에 현재 인스턴스를 담아두고 formfield_for_foreignkey 필드에서 꺼내 쓰는<NAME>이다. 종속 중첩된(cascading) 셀렉트 메뉴 04) 관리자 페이지 입력 필드 커스텀 위젯 적용 관리자 페이지 입력 필드 커스텀 위젯 적용 필드 전체 위젯 적용 특정 필드에만 위젯 적용 forms.py admin.py 관리자 페이지 입력 필드 커스텀 위젯 적용 커스텀 필드를 만드는 요령은 커스텀 필드 만들기 문서를 참고한다. 필드 전체 위젯 적용 PostAdmin 같이 모델 어드민에 존재하는 TextField 모두 특정 위젯을 일괄 적용하고 싶은 경우이다. formfield_overrides 변수에 딕셔너리<NAME>으로 위젯을 지정한다. from django.db import models from django.contrib import admin from .widgets import SimpleMDEWidget from .models import Post class PostAdmin(admin.ModelAdmin): formfield_overrides = { models.TextField: {'widget': SimpleMDEWidget(wrapper_class='simplemde-box-admin', options=options)}, } PostAdmin 같이 모델 어드민에 여러 개의 TextField가 존재해도 일괄 적용되므로 편리하다. 특정 필드에만 위젯 적용 PostAdmin 같이 모델 어드민에 여러 개의 TextField가 존재하는 경우에 일괄 적용하는 것이 편리한 경우가 있고 content 필드에만 커스텀 위젯을 적용하고 description 필드에는 디폴트 TextArea를 사용하고자 하는 경우도 있다. forms.py from django import forms from django.conf import settings from .widgets import SimpleMDEWidget from .models import Post class PostAdminForm(forms.ModelForm): class Meta: model = Post exclude = [] options = getattr(settings, "SIMPLEMDE_OPTIONS", '') widgets = { 'content': SimpleMDEWidget(wrapper_class='simplemde-box-admin', options=options), } widget 변수 딕셔너리에 명시적으로 적용하고자 하는 필드 이름을 지정한다. exclude 또는 fields 속성으로 입력 가능 필드를 명시적으로 지정해야 한다. 그렇지 않으면 에러가 발생한다. admin.py 관리자에서 쓸 PostAdminForm 커스텀 폼으로 변경한다. 또한 관리자 화면에서 사용할 simplemde.css 스타일 시트를 불러온다. from django.contrib import admin from .forms import PostAdminForm class PostAdmin(admin.ModelAdmin): form = PostAdminForm class Media: css = { 'all': ('css/simplemde.css',) } 08. 보안 01) Django 보안 설정 Django 주요 보안 기능 Django 보안 설정 옵션 운영 환경에서 DEBUG 옵션 끄기 보안키 비공개 안전한 쿠키 이용하기 ALLOWED_HOSTS CSRF XSS SQL 인젝션 SSL 설정 Django 주요 보안 기능 XSS(cross-site scripting) CSRF(cross-site request forgery) SQL 인젝션 클릭재킹(clickjacking) Django 보안 설정 옵션 운영 환경에서 DEBUG 옵션 끄기 DEBUG = False 및 ALLOWED_HOSTS 설정 보안키 비공개 SECRET_KEY를 소스 저장소에 커밋 하지 않음 안전한 쿠키 이용하기 SESSION_COOKIE_SECURE = True CSRF_COOKIE_SECURE = True ALLOWED_HOSTS CSRF XSS SQL 인젝션 SSL 설정 09. 국제화 01) 다국어 지원 용어 정리 다국어 지원 절차 윈도 gettext/iconv 프로그램 설치 Django 전역 설정 미들웨어 설정 기본 언어 설정 번역 파일 만들기 소스 코드 번역 문구 처리 모델 템플릿 번역 메시지 파일 생성 메시지 파일 컴파일 문제 해결 번역 처리가 안 되는 것처럼 보이는 fuzzy 플래그 MacOS에서 gettext 설치 용어 정리 국제화(i18n, internationalization): 개발자가 지역화 지원을 위해 소프트웨어적으로 준비하는 것 지역화(l8n, localization): 번역가가 번역하고 지역<NAME>에 맞게 변환하는 것 로케일 이름: ko_KR은 대한민국 한국어이고 ko_KP는 북한 한국어 의미로 "언어_국가"<NAME>이다. 언어 코드: 브라우저가 HTTP 헤더 Accept-Language로 보내는 값으로 "언어-국가"<NAME>이며 ko-kr 같이 쓰는데 모두 소문자로 되어 있다. Django 설정 파일에서 쓰이는 값이다. .po 파일: 번역가가 직접 번역하는 메시지 파일이다. .mo 파일: Django가 인식할 수 있도록 개발자가. po 번역 메시지 파일을 컴파일해 만든 파일이다. 다국어 지원 절차 윈도 gettext/iconv 프로그램 설치 gettext 0.19.8.1 and iconv 1.14 - Binaries for Windows 링크에서 알맞은 버전을 설치한다. shared DLL 파일은 설치 용량이 작고 DLL 미포함 static 파일은 설치 용량이 크다. 비록 용량이 커도 깔끔한 설치, 삭제가 가능한 static 파일을 설치한다. Django 전역 설정 settings.py 파일의 내용을 수정 및 추가한다. 미들웨어 설정 settings.py 파일에서 아래와 같이 SessionMiddleware와 CommonMiddleware 사이에 LocaleMiddleware를 추가한다. MIDDLEWARE = [ 'django.middleware.security.SecurityMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.locale.LocaleMiddleware', 'django.middleware.common.CommonMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.clickjacking.XFrameOptionsMiddleware', ] 기본 언어 설정 settings.py 파일에서 다음 내용을 수정한다. LANGUAGE_CODE = 'ko-KR' settings.py 파일에서 상단에 다음과 같이 import 문을 추가한다. from django.utils.translation import ugettext_lazy as _ 프로젝트에서 지원할 다국어 언어 값을 설정한다. LANGUAGES = [ ('ko', _('Korean')), ('en', _('English')), ] 번역 파일이 들어있는 locale 디렉터리를 지정하고 실제로 디렉터리도 만들도록 한다. LOCALE_PATHS = ( os.path.join(BASE_DIR, 'locale'), ) 번역 파일 만들기 실제로 번역 파일을 만들고 컴파일하는 작업으로 실질적으로 가장 시간이 많이 소요되는 부분이다. 소스 코드 번역 문구 처리 모델 models.py 파일에서 예시이다. from django.utils.translation import ugettext_lazy as _ class Post(models.Model): STATUS_CHOICES = ( ('draft', _('Draft')), ('published', _('Published')), ) title = models.CharField(_('Title'), max_length=250) 템플릿 템플릿 파일에서 예시이다. <li><a href="{% url "blog:post_index" %}">{{ _('Blog') }}</a></li> 번역 메시지 파일 생성 원래는 아래 명령어로 전체 메시지 파일을 만들 수 있다. python manage.py makemessage -a 그러나 최초에는 잘 동작하지 않아서 아래와 같이 개별적으로 메시지 파일을 생성한다. python manage.py makemessages -l ko python manage.py makemessages -l en 메시지 파일 컴파일 생성한 번역 파일을 Django가 인식할 수 있도록 컴파일한다. python manage.py compilemessages 컴파일 후에는 Django 서버를 재기 동해야 메시지 번역 결과가 반영된다. 문제 해결 번역 처리가 안 되는 것처럼 보이는 fuzzy 플래그 .po 메시지 파일에 주석으로 #, fuzzy 표시가 있으면 해당 문자열은 번역되지 않는다. 따라서 번역 문자열 상단에 주석으로 #, fuzzy 표시가 있으면 해당 부분의 주석을 삭제한다. 주석이기 때문에 컴파일 결과에 영향을 미치지 않을 것 같지만 실제로는 번역되지 않아 원인을 찾는데 시간을 많이 소비할 수 있다. MacOS에서 gettext 설치 아래와 같이 gettext 프로그램이 설치되어 있지 않을 경우 이를 설치해야 한다. $ python manage.py makemessages CommandError: Can't find xgettext. Make sure you have GNU gettext tools 0.15 or newer installed. 아래와 같이 brew로 gettext를 설치한다. $ brew install gettext $ brew link gettext --force 단순히 설치만 하고 링크하지 않으면 명령행에서 실행할 수가 없다. 02) 지역 시각 10. 서드파티 패키지 라이브러리 01) 태그 패키지 선택 django-taggit 설치 django-taggit 앱 등록 커스텀 태그 모델 정의 태그 입력 규칙 주요 사항 정리 django-tagging 설치 django-tagging 앱 등록 모델에 Tag 필드 추가 태그 입력 규칙 패키지 선택 Django 태그 라이브러리 비교 사이트에서 보면 대표적으로 태그 라이브러리 패키지는 django-tagging과 django-taggit이 있다. django-tagging django-taggit django-tagging은 brosner가 개발하던 것은 2010년 이후 더 이상 개발, 유지 보수되지 않고 있고 Fantomas42가 현재 이어서 개발하고 있다. django-taggit 패키지는 Django 코어 개발자도 참여하고 있는 특징이 있다. 그런데 django-taggit의 경우 tag cloud 기능 등을 구현하기 위해서는 django-taggit-templatetags 별도의 패키지를 설치해야 한다. django-taggit 설치 pip install django-taggit pip install django-taggit-templatetags django-taggit 앱 등록 INSTALLED_APPS 변수에 'taggit', 추가해 django-taggit 패키지를 등록 설치한다. INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'taggit', 'blog.apps.BlogConfig', ] 커스텀 태그 슬러그를 만들 때 기본값은 unidecode 라이브러리를 이용하여 태그로 나를 입력하면 영문으로 변환한 na가 슬러그가 된다. 유니코드 문자열로 슬러그를 만들고 싶다면 직접 커스텀 태그를 만들어야 한다. 모델 정의 models.py 파일 from taggit.managers import TaggableManager from taggit.models import ( TagBase, TaggedItemBase ) class PostTag(TagBase): # NOTE: django-taggit does not allow unicode by default. slug = models.SlugField( verbose_name=_('slug'), unique=True, max_length=100, allow_unicode=True, ) class Meta: verbose_name = _("tag") verbose_name_plural = _("tags") def slugify(self, tag, i=None): return default_slugify(tag, allow_unicode=True) class TaggedPost(TaggedItemBase): content_object = models.ForeignKey( 'Post', on_delete=models.CASCADE, ) tag = models.ForeignKey( 'PostTag', related_name="%(app_label) s_%(class) s_items", on_delete=models.CASCADE, ) class Meta: verbose_name = _("tagged post") verbose_name_plural = _("tagged posts") class Post(models.Model): … 생략 … # 추가 tags = TaggableManager( verbose_name=_('tags'), help_text=_('A comma-separated list of tags.'), blank=True, through=TaggedPost, ) 태그 입력 규칙 태그 1, 태그 2, 태그 3 태그 4, 위와 같이 태그 입력할 경우 태그는 총 3개이고 저장 후 관리자 화면에서는 아래와 같이 확인된다. "태그 3 태그 4", 태그 1, 태그 2 정렬 순서는 변경될 수 있으며 띄어쓰기가 있는 경우 따옴표로 묶어 표시된다. 단, 끝에 ,(콤마)는 알아서 버려진다. 주요 사항 정리 두 라이브러리 모두 기존의 태그를 삭제하면 관계는 삭제되지만 태그 항목 자체가 삭제되진 않는다. django-tagging 설치 pip install django-tagging django-tagging 앱 등록 INSTALLED_APPS 변수에 'tagging.apps.TaggingConfig', 추가해 django-tagging 패키지를 등록 설치한다. INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'tagging.apps.TaggingConfig', 'blog.apps.BlogConfig', ] 모델에 Tag 필드 추가 class Post(models.Model): title = models.CharField('Title', max_length=50) slug = models.SlugField('Slug', unique=False, allow_unicode=True, help_text='dashed words for title alias') description = models.CharField('Description', max_length=100, blank=True, help_text='Simple description text') content = models.TextField('Content') published = models.DateTimeField('Date published', default=timezone.now) created = models.DateTimeField('Date created', auto_now_add=True) updated = models.DateTimeField('Date updated', auto_now=True) tag = TagField() # 추가 태그 입력 규칙 태그 입력 문자열 태그 결과 설명 apple ball cat [apple], [ball], [cat] 콤마가 없으면 띄어쓰기로 분리 apple, ball cat [apple], [ball cat] 콤마가 있으면 콤마로 분리하고 띄어쓰기 포함 하나의 태그로 간주 "apple, ball" cat dog [apple, ball], [cat], [dog] 모든 콤마를 따옴표로 감싸면 띄어쓰기로 분리 "apple, ball", cat dog [apple, ball], [cat dog] 따옴표로 안 감싼 콤마가 있으면 콤마로 분리 apple "ball cat" dog [apple], [ball cat], [dog] 콤마가 없으면 띄어쓰기로 분리 "apple" "ball dog [apple], [ball], [dog] 안 닫힌 따옴표는 무시 태그 1, 태그 2, 태그 3 태그 4, 위와 같이 태그 입력할 경우 태그는 총 3개이다. 태그 1 태그 2 태그 3 태그 4 관리자 화면에서는 맨 끝에 ,(콤마)를 붙여 입력할 경우 버려지지 않고 그대로 입력된다. 02) 댓글 패키지 선택 django-discuss 설치 설정 템플릿 django-comments-xtd 설치 설정 패키지 선택 예전에는 Django 안에 django-contrib-comments 패키지가 기본적으로 포함되어 배포되었다. 그러나 더 이상 Django 공식 팀에서 해당 패키지를 관리하지 않고 분리되어 관리된다. django-disqus django-comments-xtd django-disqus는 페이스북, 트위터, 구글 계정 등을 이용해 로그인해 댓글을 남길 수 있는 시스템이다. 사용법이 매우 쉬운 편이다. django-comments-xtd는 django-contrib-comments 패키지를 상속 확장해서 스레드(댓글에 댓글을 달 수 있는) 댓글 기능을 포함하여 여러 가지 편리한 기능을 담고 있다. django-discuss 설치 pip으로 아래와 같이 django-disqus 패키지를 설치한다. pip install django-disqus 설정 settings.py 파일에서 django-disqus와 django.contrib.sites 앱을 등록하고 SITE_ID 및 DISQUS_WEBSITE_SHORTNAME 변수를 선언한다. INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', # 추가 사항 'django.contrib.sites', 'disqus', ] # Disqus SITE_ID = 1 DISQUS_WEBSITE_SHORTNAME = 'your_website_shortname' DISQUS_WEBSITE_SHORTNAME 값은 disqus 사이트에 회원 가입해 할당받는다. 템플릿 상세 보기 뷰(DetailView) 하단에 댓글 템플릿 태그를 추가한다. <!-- Disqus Comments --> {% load disqus_tags %} {% disqus_show_comments %} django-comments-xtd 설치 pip으로 아래와 같이 django-comments-xtd 패키지를 설치한다. pip install django-comments-std 설정 settings.py 파일에서 앱을 등록하는데 이때 반드시 django_comments_xtd가 django_comments 보다 위에 있어야 한다. INSTALLED_APPS += [ 'django.contrib.sites', 'django_comments_xtd', 'django_comments', ] settings.py 파일에 다음 설정 변수를 등록한다. COMMENTS_APP = 'django_comments_xtd' COMMENTS_XTD_MAX_THREAD_LEVEL = 1 댓글 앱으로 사용하는 앱 이름을 지정하는데 이는 애초에 django-contrib-comment 앱에서 커스텀 모델을 지정할 때 쓰는 속성이다. URL 패턴을 아래와 같이 등록한다. urlpatterns = [ ... 생략 ... url(r'^comments/', include('django_comments_xtd.urls')), ... 생략 ... ] 로그인해 관리자 화면에서 사이트들에 기본 사이트에 도메인 정보를 example.com이 아니라 127.0.0.1:8000으로 변경한다. 물론 운영환경에서는 해당 사이트의 도메인을 입력한다. 03) 모델 유틸리티 django-model-utils 설치 필드 StatusField MonitorField 모델 모델 매니저 InheritanceManager 기타 유틸리티 Django의 모델 선언에 자주 쓰이는 믹스 인과 유틸리티를 제공한다. django-model-utils 설치 아래와 같이 PIP 명령어로 쉽게 설치할 수 있고 굳이 settings.py 파일을 수정하지 않아도 사용이 가능하다. pip install django-model-utils 필드 StatusField 레코드의 상태를 지정하는 필드이다. from model_utils.fields import StatusField from model_utils import Choices class Article(models.Model): STATUS_CHOICES = Choices('draft', 'published') # ... status = StatusField(choices_name='STATUS_CHOICES') StatusField는 db_index=True 설정이 기본값이 아니다. 상태 필드로 자주 필터링이 필요하다면 직접 인덱스를 지정할 필요가 있다. MonitorField 어떤 필드의 값이 변경되었을 때 변경 시각을 저장하는 필드이다. 아래와 같이 when 옵션을 주면 모니터링하는 필드가 특정 값일 때에만 업데이트하는 효과가 있다. from model_utils.fields import MonitorField, StatusField class Article(models.Model): STATUS = Choices('draft', 'published') status = StatusField() published_at = MonitorField(monitor='status', when=['published']) 모델 모델 매니저 InheritanceManager InheritanceManager(상속 매니저)는 상속과 다형성을 지원하는 매니저이다. 현재 Django 2.0에서는 _clone() 메서드의 이름이 _chain()으로 변경되어 이에 대한 패치가 되기 전까지 동작하지 않는다. Place 모델을 상속하는 Restaurant, Bar 모델을 정의하고 아래와 같이 쿼리를 실행할 경우 실제 Restaurant 또는 Bar의 인스턴스를 반환하는 것이 아니라 Place 인스턴스를 반환한다. nearby_places = Place.objects.filter(location='here') 이러한 문제 해결을 위해 Place 모델에 InheritanceManager를 붙여서 select_subclasses() 같은 메서드를 사용할 수 있다. from model_utils.managers import InheritanceManager class Place(models.Model): # ... objects = InheritanceManager() class Restaurant(Place): # ... class Bar(Place): # ... nearby_places = Place.objects.filter(location='here').select_subclasses() for place in nearby_places: # "place" will automatically be an instance of Place, Restaurant, or Bar 각 서브 클래스를 조인하기 위해 데이터베이스에 부가적 쿼리가 많이 실행되므로 조인 횟수를 줄이고 특정 하위 클래스만 필터링하기 위해 하위 클래스의 이름을 넘겨줄 수도 있다. nearby_places = Place.objects.select_subclasses("restaurant") # restaurants will be Restaurant instances, bars will still be Place instances nearby_places = Place.objects.select_subclasses("restaurant", "bar") # all Places will be converted to Restaurant and Bar instances. 하위 클래스의 이름을 넘겨주는 대신 그냥 하위 클래스 자체를 넘겨줄 수도 있다. nearby_places = Place.objects.select_subclasses(Restaurant) # restaurants will be Restaurant instances, bars will still be Place instances nearby_places = Place.objects.select_subclasses(Restaurant, Bar) # all Places will be converted to Restaurant and Bar instances. 별로 권장하고 싶지 않지만 이 둘을 섞어 쓸 수도 있다. nearby_places = Place.objects.select_subclasses(Restaurant, "bar") # all Places will be converted to Restaurant and Bar instances. InheritanceManager는 또한 get() 메서드 대신 get_subclass() 메서드로 하위 클래스를 불러올 수도 있다. place = Place.objects.get_subclass(id=some_id) # "place" will automatically be an instance of Place, Restaurant, or Bar select_subclasses() 또는 get_subclass() 메서드를 명시적으로 호출하지 않으면 InheritanceManager는 디폴트 매니저와 동일하게 동작한다. 따라서 기본 매니저 대신에 사용해도 충돌은 없다. 기타 유틸리티 04) 계층 트리 구조 django-mptt 장단점 패키지 설치 및 앱 등록 게시물과 카테고리 모델 관리자 등록 주요 쿼리 전체 쿼리셋 구하기 쿼리셋 조인하여 결과 얻기 breadcrumbs 구현 기타 예시 템플릿 recursetree django-treebeard 패키지 설치 및 앱 등록 카테고리 모델 관리자 등록 주요 쿼리 계층 트리 구조 구현을 위해 대표적으로 django-treebeard, django-mptt 두 라이브러리가 존재한다. 가장 많은 사용자를 갖고 있는 것은 django-mptt이고 근래에 django-cms나 wagtail 같은 CMS 설루션에서 사용하는 것은 django-treebeard이다. django-mptt 장단점 쿼리를 최소화하여 빠른 질의 결과를 구할 수 있는 것이 장점이다. 반면에 트리 구조를 계속 유지하기 위해 삽입과 삭제는 상대적으로 느린 게 단점이다. 따라서 초기에 한 번 트리를 구조화 해놓고 자주 변경 없이 그냥 질의만 하여 사용할 경우에는 매우 훌륭하고 매우 큰 트리 구조를 지속적으로 자주 변경해야 할 때는 적합하지 않을 수 있다. 패키지 설치 및 앱 등록 패키지는 아래와 같이 pip으로 설치한다. pip install django-mptt 설치한 앱은 settings.py 파일에 등록한다. INSTALLED_APPS += [ ... 설치한 앱 ..., 'mptt', ] 게시물과 카테고리 모델 from mptt.fields import TreeForeignKey from mptt.models import MPTTModel class Post(models.Model): title = models.CharField( verbose_name=_('title'), max_length=250 ) slug = models.SlugField( verbose_name=_('slug'), max_length=250, unique=False, allow_unicode=True ) category = TreeForeignKey( 'Category', verbose_name=_('category'), null=True, blank=True, db_index=True, on_delete=models.SET_NULL, ) ... 생략 ... class Category(MPTTModel): parent = TreeForeignKey( 'self', verbose_name=_('parent'), blank=True, null=True, related_name='children', db_index=True ) title = models.CharField( verbose_name=_('title'), max_length=128 ) slug = models.SlugField( verbose_name=_('slug'), max_length=250, unique=True, allow_unicode=True ) class Meta: ordering = ['tree_id', 'lft'] class MPTTMeta: order_insertion_by = ['title'] def __str__(self): return self.title order_insertion_by 필드 설정은 트리에 새 노드를 추가하거나 기존 노드의 부모를 변경할 때 순서를 정의하는 필드 이름의 리스트이다. 이 리스트의 기본값은 [] 빈 리스트이다. 데이터베이스에서 NOT NULL 필드이면 어느 필드나 지정할 수 있고 순서에 있어 가장 중요한 필드 이름을 가장 먼저 놓는다. 노드를 저장할 때 위치를 결정하기 위해 추가적인 데이터베이스 쿼리가 실행된다는 점에 유의한다. 이 옵션은 카테고리 트리처럼 항상 알파벳 순서로 정렬되어야 하는 거의 정적인(변경이 별로 없는) 구조를 유지할 때 유리하다. 관리자 등록 from mptt.admin import DraggableMPTTAdmin from .models import ( Post, Category ) class CategoryAdmin(DraggableMPTTAdmin): list_display = ( 'tree_actions', 'indented_title', 'title', 'slug', ) prepopulated_fields = {'slug': ('title',)} mptt_level_indent = 20 admin.site.register(Category, CategoryAdmin) 드래그 앤 드롭으로 트리 구조 위치를 조정할 수 있도록 DraggableMPTTAdmin 클래스를 상속해 어드민 클래스를 정의할 수 있다. 이때 인터넷 익스플로러의 경우 9 버전 이상에서 동작한다. 노드 수가 몇 백 개를 넘어가거나 깊이가 10단계 이상인 큰 트리는 잘 동작하지 않는다. 지연된 로딩을 지원하기 위한 패치가 필요한 실정이다. list_per_page는 기본값이 2000으로 대부분의 경우에는 페이징이 발생하지 않는다. 주요 쿼리 전체 쿼리셋 구하기 context['category_tree'] = Category.objects.all() 쿼리셋 조인하여 결과 얻기 Post.objects.published() \ .select_related('author') \ .select_related('category') \ .filter( category__in=Category.objects.filter( slug=self.kwargs['slug'] ).get_descendants(include_self=True) ) breadcrumbs 구현 자신의 노드를 포함해서 부모 노드 전체 구조를 구한다. MenuItem.objects.get(pk=11).get_ancestors(include_self=True) 기타 예시 Post.objects.filter(category__in=Category.objects.get(pk=2).get_descendants(include_self=True)) Post.objects.filter(category__in=Category.objects.get(title='Django').get_descendants(include_self=True)) MenuItem.objects.get(pk=1).get_leafnodes() MenuItem.objects.get(pk=3).get_ancestors() MenuItem.objects.get(pk=1).is_root_node() # 1, 2 루트 노드 템플릿 recursetree {% load mptt_tags %} {% recursetree category_tree %} {% if not node.is_leaf_node %} <li> <a href="{% url 'blog:post-category' node.slug %}">{% trans node.title %}</a> <ul> {{ children }} </ul> </li> {% else %} <li> <a href="{% url 'blog:post-category' node.slug %}">{% trans node.title %}</a> </li> {% endif %} {% endrecursetree %} django-treebeard 패키지 설치 및 앱 등록 패키지는 아래와 같이 pip으로 설치한다. pip install django-treebeard 설치한 앱은 settings.py 파일에 등록한다. INSTALLED_APPS += [ ... 설치한 앱 ..., 'treebeard', ] TreeAdmin 클래스를 이용하려면 treebeard의 템플릿 경로를 TEMPLATE_DIRS 경로에 추가하거나 TEMPLATE_CONTEXT_PROCESSORS 설정에 django.core.context_processors.request을 활성화해야 한다. 카테고리 모델 from django.db import models from treebeard.mp_tree import MP_Node class Category(MP_Node): name = models.CharField(max_length=30) #node_order_by = ['name'] def __str__(self): return self.name node_order_by 옵션은 리스트로 나열할 수 있으며 노출 시 정렬 순서를 무조건 따른다. 관리자 등록 from django.contrib import admin from treebeard.admin import TreeAdmin from treebeard.forms import movenodeform_factory from .models import Category class CategoryAdmin(TreeAdmin): form = movenodeform_factory(Category) admin.site.register(Category, CategoryAdmin) 주요 쿼리 05) 위지위그 에디터 패키지 선택 Summernote 설치 설정 사용하기 admin 페이지 설정 폼 만들기 출력 후기 SimpleMDE 후기 패키지 선택 Summernote SimpleMDE CKEditor TinyMCE Summernote 설치 pip 명령어로 설치한다. pip install django-summernote 설정 settings.py 파일에 django-summernote 앱 등록한다. INSTALLED_APPS += ('django_summernote', ) urls.py 파일에 django_summernote.urls을 등록한다. urlpatterns = [ ... url(r'^summernote/', include('django_summernote.urls')), ... ] 파일 업로드를 위한 MEDIA_URL 경로를 올바르게 설정한다. 에디터로 업로드한 첨부파일 관리를 위한 테이블을 생성하도록 마이그레이션한다. python manage.py migrate 사용하기 admin 페이지 설정 Post 모델에 TextField를 일괄적으로 Summernote로 작성할 수 있도록 처리하는 방법이다. from django.contrib import admin from django.utils import timezone from django_summernote.admin import SummernoteModelAdmin from .models import Post class PostAdmin(SummernoteModelAdmin): ... 생략 ... admin.site.register(Post, PostAdmin) 폼 만들기 출력 저장된 내용을 화면에 출력할 때는 safe 필터를 사용한다. {{ post.content|safe }} 후기 파일 업로드를 이미 구현해서 제공하기 때문에 편리하게 쓸 수 있지만 게시물별로 첨부파일 관리를 하려면 별도로 다시 구현해야 한다. SimpleMDE 후기 admin 관리자 화면에서 사용할 때 CSS가 가로가 전체를 차지하는 문제점이 있다. 06) RSS 피드 Django 공식 패키지에서 django.contrib.syndication.views.Feed 클래스를 제공하고 이를 상속하여 손쉽게 구현할 수 있다. Feed 클래스를 상속하여 아래와 같이 클래스와 메서드를 정의한다. class LatestPostFeed(Feed): title = _('Blog Feeds') link = '/feed' description = _('Blog Recent Posts') def items(self): return Post.objects.filter(status='published').order_by('-published')[:10] def item_title(self, item): return item.title def item_description(self, item): return item.description def item_link(self, item): return reverse('blog:post_detail', args=(item.pk, item.slug,)) Post 모델은 title, description 필드를 갖고 있으며 절대 URL 링크 값을 반환하는 link 메서드를 구현한다. urls.py 파일에서 URL 패턴을 다음과 같이 정의할 수 있다. urlpatterns = [ url(r'^feed/$', LatestPostFeed(), name='post_feed'), ] 07) 사이트 프레임워크 사이트 프레임워크 등록 settings.py 파일 수정 django_site 테이블 생성 사이트 도메인과 이름 변경 Django 공식 패키지에서 django.contrib.sites 프레임워크를 제공한다. 이를 이용하여 사이트 기본 정보를 설정하고 복수 사이트를 구현할 수 있다. 사이트 프레임워크 등록 settings.py 파일 수정 settings.py 파일에 django.contrib.sites 앱을 등록 설치한다. INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', # Additional Django apps 'django.contrib.sites', ] SITE_ID 정숫값은 django_site 데이터베이스 테이블에 있는 현재 사이트의 값이다. django_site 테이블에 여러 개의 사이트를 등록하고 그중 하나를 지정하는 역할을 한다. SITE_IDE = 1 django_site 테이블 생성 django_site 테이블을 생성하는데 makemigrations 필요 없이 바로 migrate 명령한다. python manage.py migrate 사이트 도메인과 이름 변경 사이트 도메인과 이름 기본값이 example.com이다. 이를 파이썬 콘솔에서 아래와 같이 변경할 수 있다. from django.contrib.sites.models import Site mysite = Site.objects.get_current() mysite.domain = 'my-site.com' mysite.name = 'My site powered by Django' mysite.save() 08) 인증 메일 가입 처리 django-registration 설치 및 준비 HMAC 활성화 방식 settings.py urls.py 템플릿 django-registration 본 패키지를 설치하는 가장 큰 이유는 이메일 인증 2단계 가입 처리를 지원하기 위함이다. 물론 1단계 가입도 지원하지만 이 경우는 굳이 이 패키지를 사용할 필요가 없다. 2단계 가입을 위해 HMAC 활성화 방식과 모델 기반 활성화 방식 2가지 방법이 있는데 HMAC 활성화 방식을 권장하므로 여기서는 HMAC 활성화 방식만 다룬다. 설치 및 준비 Django의 기본 인증 시스템인 django.contrib.auth이 INSTALLED_APPS 변수에 올바로 등록이 되어 있어야 한다. Django 설치 기본값이므로 크게 신경 쓸 필요는 없다. pip 패키지로 간단히 설치할 수 있다. pip install django-registration 패키지를 설치하고 INSTALLED_APPS 변수에 설치한 패키지 앱을 registration으로 등록하지 않는다. 그 이유는 앱에서 별도로 데이터베이스 모델을 추가하지 않기 때문이다. HMAC 활성화 방식 settings.py 회원 가입을 받고 회원 가입 이메일 인증을 만 하루 안에 완료하도록 설정한다. ACCOUNT_ACTIVATION_DAYS = 1 REGISTRATION_OPEN = True # 기본값 urls.py /accounts/register/, /accounts/login/ 같은 URL 패턴을 사용할 수 있도록 url 패턴을 추가한다. from django.conf.urls import include, url urlpatterns = [ ... 생략 ... url(r'^accounts/register/$', RegistrationView.as_view( form_class=WebUserCreationForm ), name='registration_register'), url(r'^accounts/', include('registration.backends.hmac.urls')), ... 생략 ... ] 따라서 아래와 같이 URL 패턴과 뷰가 매핑된다. /accounts/register/ [name='registration_register'] /accounts/activate/complete/ [name='registration_activation_complete'] /accounts/activate/(?P[-:\w]+)/ [name='registration_activate'] /accounts/register/ [name='registration_register'] /accounts/register/complete/ [name='registration_complete'] /accounts/register/closed/ [name='registration_disallowed'] /accounts/login/ [name='auth_login'] /accounts/logout/ [name='auth_logout'] /accounts/password/change/ [name='auth_password_change'] /accounts/password/change/done/ [name='auth_password_change_done'] /accounts/password/reset/ [name='auth_password_reset'] /accounts/password/reset/confirm/(?P[0-9A-Za-z_-]+)/(?P[0-9A-Za-z]{1,13}-[0-9A-Za-z]{1,20})/ [name='auth_password_reset_confirm'] /accounts/password/reset/complete/ [name='auth_password_reset_complete'] /accounts/password/reset/done/ [name='auth_password_reset_done'] 템플릿 django-registration 라이브러리를 위한 여러 가지 템플릿을 추가한다. registration/registration_form.html : 회원가입 폼 registration/registration_complete.html (TemplateView) : 회원가입 완료 메시지 registration/activate.html : 이메일 인증 실패 메시지 registration/activation_complete.html (TemplateView) : 이메일 인증 완료 메시지 registration/activation_email_subject.txt : 발송 이메일 제목 registration/activation_email.txt : 발송 이메일 본문 내용 registration/registration_closed.html (TemplateView) : 회원가입 불가 메시지 django.contrib.auth 기본값을 따르는 여러 가지 템플릿을 추가한다. login.html logout.html password_change_form.html password_change_done.html password_reset_form.html password_reset_email.html password_reset_subject.txt password_reset_done.html password_reset_confirm.html password_reset_complete.html 09) OAuth 라이브러리 종류 django-allauth 패키지 설치 및 준비 주요 설정값 계정 프로필 필드 추가 구현 일대일 관계 프로필 모델 정의 AbstractUser 클래스의 상속 SNS 설정 페이스북 social-auth-app-django 패키지 설치 및 준비 데이터베이스 마이그레이션 설정 settings.py urls.py SNS 설정 페이스북 라이브러리 종류 django-social-auth (deprecated) python-social-auth (deprecated) social-app-django (단, 패키 지명은 social-auth-app-django) django-allauth 즉, 크게 social-app-django와 django-allauth 두 패키지로 나눌 수 있다. 많은 차이가 있지만 쉽게 이야기하면 social-app-django는 django-registration과 결합하여 쓸 수 있고 all-in-one으로 쓸 수 있는 게 django-allauth이다. django-allauth의 장점은 거의 대부분의 소셜 로그인을 지원하고 회원가입시킬 수 있다. SNS 공급자(provider)가 제공하는 부정확한 정보(예: 인증받지 않은 이메일 주소 등)를 로그인 연동 과정에서 정확한 입력 요구할 수 있다. 특히, Django 시스템 기존 사용자의 경우에도 /accounts/social/connections/ 경로에서 소셜 로그인 계정 연동할 수 있다. 게다가 remember me 기능 또한 지원한다. django-allauth 패키지 설치 및 준비 pip install django-allauth settings.py 파일 INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', # <- 의존성 앱 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'django.contrib.sites', # <- 의존성 앱 'allauth', # <- 추가 'allauth.account', # <- 추가 'allauth.socialaccount', # <- 추가 # 'allauth.socialaccount.providers.facebook', # <- 필요한 소셜 로그인 추가 AUTHENTICATION_BACKENDS = ( 'django.contrib.auth.backends.ModelBackend', # <- 디폴트 모델 백엔드 'allauth.account.auth_backends.AuthenticationBackend', # <- 추가 ) SITE_ID = 1 # 사이트 아이디 기본값 urls.py 파일 urlpatterns = [ url(r'^admin/', admin.site.urls), url(r'^accounts/', include('allauth.urls')), # <- 추가 ] 주요 설정값 ACCOUNT_AUTHENTICATION_METHOD: 로그인인증 방법으로 user name, email, user name_email을 지정할 수 있다. email로 설정할 때는 ACCOUNT_EMAIL_REQUIRED = True 옵션을 같이 설정해야 한다. ACCOUNT_EMAIL_REQUIRED: 회원가입할 때 이메일 주소 입력 필수 여부이다. 디폴트 값은 False이므로 이메일 주소를 입력하지 않아도 가입된다. ACCOUNT_USER NAME_REQUIRED: 회원 가입할 때 user name 입력 필수 여부이다. 디폴트 값은 True이므로 반드시 ACCOUNT_AUTHENTICATION_METHOD를 통해 이메일로 로그인으로 설정하더라도 user name을 입력해야 가입된다. ACCOUNT_EMAIL_VERIFICATION: 이메일<NAME> 인증이 필요한 지이다. 'mandatory', 'optional', 'none' 값을 지정할 수 있으며 'mandatory'는 회원가입 후 이메일 주소를 인증하지 않으면 회원가입하더라도 로그인할 수 없다. 'optional'은 인증 이메일은 발송되지만 인증하지 않아도 로그인할 수 있고 'none'은 인증 메일을 보내지도 않고 로그인할 수 있다. ACCOUNT_LOGIN_ATTEMPTS_LIMIT: 지정된 횟수(기본값=5) 만큼 로그인 실패할 경우 ACCOUNT_LOGIN_ATTEMPTS_TIMEOUT 설정값으로 지정한 시간(단위=초) 만큼 로그인할 수 없다. allauth 로그인 뷰에서 적용되고 Django 기본 관리자 로그인 뷰에는 적용되지 않는다. ACCOUNT_LOGIN_ATTEMPTS_TIMEOUT: 로그인 실패 시 다시 로그인할 수 없는 시간(기본값=300초)이다. ACCOUNT_USER_MODEL_USER NAME_FIELD: 커스텀 사용자 모델을 사용하는 경우 아이디 필드의 이름이 user name이 아닌 다른 이름일 경우 지정한다. 만약 None으로 지정할 경우 allauth에서 user name과 관련된 모든 기능을 사용하지 않는다. 이 경우 ACCOUNT_USER NAME_REQUIRED 값 또한 반드시 False로 지정해야 한다. ACCOUNT_USER_MODEL_EMAIL_FIELD: 커스텀 사용자 모델을 사용하는 경우 이메일 필드의 이름이 기본값 email이 아닌 다른 이름일 경우 지정한다. 만약 None으로 지정할 경우 allauth에서 email과 관련된 모든 기능을 사용하지 않는다. 이 경우 ACCOUNT_EMAIL_REQUIRED 값 또한 반드시 False로 지정해야 한다. ACCOUNT_SIGNUP_FORM_CLASS: 회원가입 폼 클래스를 지정하고 해당 클래스는 def signup(self, request, user) 메서드를 반드시 구현해야 한다. SOCIALACCOUNT_AUTO_SIGNUP: 디폴트 값은 True이며 SNS 공급자에서 넘겨받은 정보를 가지고 바로 회원가입시킨다. 부가정보를 입력받기 위해 False로 설정할 수 있다. 예시 ACCOUNT_AUTHENTICATION_METHOD = 'email' ACCOUNT_EMAIL_REQUIRED = True ACCOUNT_EMAIL_VERIFICATION = 'mandatory' ACCOUNT_LOGIN_ATTEMPTS_LIMIT = 5 ACCOUNT_LOGIN_ATTEMPTS_TIMEOUT = 300 SOCIALACCOUNT_AUTO_SIGNUP = False ACCOUNT_SIGNUP_FORM_CLASS = accounts.forms.SignupForm 위와 같은 예시 설정은 회원가입할 때 이메일과 사용자 이름을 함께 입력받는다. 입력받은 이메일 주소는 반드시 인증해야 한다. 또한 소셜 로그인으로 회원가입이 자동으로 되지는 않고 필수 입력 필드를 반드시 입력 후 이메일 인증해야 가입이 완료된다. 계정 프로필 필드 추가 구현 계정 프로필을 위해 필드를 추가하는 방법은 크게 3가지가 있다. * AbstractBaseUser 클래스를 상속한 커스텀 모델 정의 * AbstractUser 클래스를 상속한 커스텀 모델 정의 * 일대일 관계로 프로필을 위한 테이블의 추가 자세한 설명은 User 모델의 확장 기법 비교 내용을 참고한다. AbstractBaseUser 클래스를 상속하는 가장 큰 이유 중에 하나가 로그인 아이디로 user name 대신에 email을 사용하기 위함인데 django-allauth 패키지를 사용할 경우에는 ACCOUNT_AUTHENTICATION_METHOD = 'email' 옵션으로 간단히 해결된다. 그러면 사용자 프로필 페이지를 위해 AbstractUser 클래스를 상속하는 방법과 일대일 관계로 프로필 테이블을 추가하는 방법이 있는데 프로필 페이지에는 데이터의 크기가 큰 정보들이 많으므로 회원 수가 증가하면 auth_user 테이블이 지나치게 커질 수가 있다. 따라서 결국 Django 공식 문서가 권장하는 방식인 일대일 테이블 추가가 가장 현실적인 대안이 될 수 있다고 생각한다. 일대일 관계 프로필 모델 정의 account 앱 이름은 allauth에서 사용하여 충돌하므로 member, user 같은 이름으로 앱을 생성한다. member 앱을 예시로 한다. settings.py 파일에서 member 앱을 등록한다. INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'django.contrib.sites', 'allauth', 'allauth.account', 'allauth.socialaccount', 'member.apps.MemberConfig', # <- 추가 ] ACCOUNT_SIGNUP_FORM_CLASS = 'member.forms.SignupForm' # <- 아래에서 기술할 회원가입 폼을 사용 member/models.py 파일 from django.conf import settings from django.db import models class Profile(models.Model): user = models.OneToOneField( settings.AUTH_USER_MODEL, # <- 특정 사용자 모델에 종속적이지 않다. on_delete=models.CASCADE ) phone = models.CharField( max_length=100 ) class Meta: db_table = 'account_profile' app_label = 'account' # <- account 앱 카테고리에서 관리되도록 한다. member/forms.py 파일 from django import forms from django.utils.translation import ugettext_lazy as _ from .models import Profile class SignupForm(forms.Form): first_name = forms.CharField(label=_('First name'), max_length=30, widget=forms.TextInput( attrs={'placeholder': _('First name'), })) last_name = forms.CharField(label=_('Last name'), max_length=30, widget=forms.TextInput( attrs={'placeholder': _('Last name'), })) phone = forms.CharField(label=_('Phone number'), max_length=30, widget=forms.TextInput( attrs={'placeholder': _('Phone number'), })) def signup(self, request, user): user.first_name = self.cleaned_data['first_name'] user.last_name = self.cleaned_data['last_name'] user.save() profile = Profile() profile.user = user profile.phone = self.cleaned_data['phone'] profile.save() User 모델에 first_name, last_name 필드가 존재하고 Profile 모델에 phone 필드가 존재한다. 별도로 각 인스턴스에서 알맞게 save() 메서드를 호출하여 저장한다. AbstractUser 클래스의 상속 일대일 테이블 추가가 가장 적합할 것 같지만 AbstractUser 클래스를 상속하는 방법도 살펴본다. users/models.py 파일 from django.contrib.auth.models import AbstractUser # AbstractUser는 이미 user name, email, password, first_name, last_name 같은 필드를 갖고 있음 class CustomUser(AbstractUser): phone = models.CharField( max_length=100 ) # 회원 가입 시 이메일 입력을 필수로 한다. REQUIRED_FIELDS = ["email"] settings.py 파일 AUTH_USER_MODEL = 'users.CustomUser' # 위에서 정의한 CustomUser 모델 클래스 지정 member/forms.py 파일 class SignupForm(forms.Form): # 일대일 관계 프로필 모델 예시와 동일 def signup(self, request, user): user.first_name = self.cleaned_data['first_name'] user.last_name = self.cleaned_data['last_name'] user.phone = self.cleaned_data['phone'] user.save() 모두 user 테이블에 속한 필드이므로 속성값 대입 후 저장한다. SNS 설정 페이스북 settings.py 파일 SOCIALACCOUNT_PROVIDERS = { 'facebook': { 'METHOD': 'oauth2', 'SCOPE': ['email', 'public_profile', ], # 'user_friends'는 요청 안 함 # 'AUTH_PARAMS': {'auth_type': 'reauthenticate'}, # 매번 비밀번호 묻지 않으려면 주석 처리 'INIT_PARAMS': {'cookie': True}, 'FIELDS': [ 'id', 'email', 'name', 'first_name', 'last_name', 'verified', 'locale', 'timezone', 'link', 'gender', 'updated_time', ], 'EXCHANGE_TOKEN': True, 'LOCALE_FUNC': lambda request: 'kr_KR', 'VERIFIED_EMAIL': False, 'VERSION': 'v2.4', }, } SOCIAL_AUTH_FACEBOOK_KEY = '앱 ID' SOCIAL_AUTH_FACEBOOK_SECRET = '앱 시크릿 코드' social-auth-app-django 패키지 설치 및 준비 pip install social-auth-app-django settings.py INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'social_django', # <-- django 기본 패키지 밑에 ] python manage.py migrate 데이터베이스 마이그레이션 필요한 테이블을 생성한다. manage.py migrate 설정 settings.py 미들웨어 클래스 등록한다. MIDDLEWARE_CLASSES = [ 'django.middleware.security.SecurityMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.common.CommonMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.auth.middleware.SessionAuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.clickjacking.XFrameOptionsMiddleware', 'social_django.middleware.SocialAuthExceptionMiddleware', # <-- 끝에 추가 ] 템플릿의 컨텍스트 프로세서 등록한다. TEMPLATES = [ { 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'DIRS': [os.path.join(BASE_DIR, 'templates')], 'APP_DIRS': True, 'OPTIONS': { 'context_processors': [ 'django.template.context_processors.debug', 'django.template.context_processors.request', 'django.contrib.auth.context_processors.auth', 'django.contrib.messages.context_processors.messages', 'social_django.context_processors.backends', # <-- 끝에 추가 'social_django.context_processors.login_redirect', # <-- 끝에 추가 ], 'debug': DEBUG, }, }, ] 인증 백엔드 등록한다. AUTHENTICATION_BACKENDS = ( 'social_core.backends.kakao.KakaoOAuth2', # <-- 카카오톡 'social_core.backends.line.LineOAuth2', # <-- 라인 'social_core.backends.google.GoogleOAuth2', # <-- 구글 'social_core.backends.facebook.FacebookOAuth2', # <-- 페이스북 'social_core.backends.twitter.TwitterOAuth', # <-- 트위터 'django.contrib.auth.backends.ModelBackend', # <-- Django 시스템 사용자로 로그인 ) urls.py URL 패턴을 등록한다. urlpatterns = [ ... 생략 ... url(r'^oauth/', include('social_django.urls', namespace='social')), # <-- ... 생략 ... ] SNS 설정 페이스북 사용자가 이메일 제공 동의해도 페이스북에서 이메일 주소를 반환하지 않는 경우 이메일 가입했으나 인증하지 않은 경우 전화번호로 가입해서 이메일이 없는 경우 10) 섬네일 이미지 패키지 선택 easy-thumbnails 설치 및 등록 모델 변경 템플릿 태그 주요 옵션 섬네일 이미지 전체 삭제 패키지 선택 Django 섬네일 이미지 라이브러리 비교 사이트에서 보면 대표적으로 섬네일 이미지 라이브러리 패키지는 easy-thumbnails, django-imagekit, sorl-thumbnail 등이 있다. image-thumbnails django-imagekit sorl-thumbnail easy-thumbnails 설치 및 등록 pip 패키지로 설치한다. pip install easy_thumbnails settings.py 파일에 앱을 등록한다. INSTALLED_APPS += [ 'easy_thumbnails', ] 모델 변경 기존 models.FileField 필드를 사용한 경우 easy_thumbnails.fields.ThumbnailerField 필드로 변경하고 models.ImageField 필드를 사용한 경우 easy_thumbnails.fields.ThumbnailerImageField 필드로 변경한다. 다음은 예시 선언이다. thumbnail = ThumbnailerImageField( verbose_name=_('Thumbnail'), upload_to='blog/thumbnails/%Y/%m', blank=True ) 템플릿 태그 다음은 템플릿 태그 사용 예시이다. {% if post.thumbnail %} {% load thumbnail %} {% thumbnail post.thumbnail 260x180 as im %} <img src="{{ im.url }}" width="{{ im.width }}" height="{{ im.height }}"> {% else %} <img src="http://placehold.it/260x180" alt="thumbnail"> {% endif %} 주요 옵션 섬네일 이미지 전체 삭제 class Post(Model): thumbnail = ThumbnailerImageField() 위와 같이 Post 모델이 존재하고 아래 thumbnail 이미지가 존재한다고 할 때 아래와 같이 섬네일을 삭제한다. for m in Post.objects.all(): m.image.delete_thumbnails() 11) 구글 reCAPTCHA 회원 가입 시 구글 reCAPTCHA 사이트 등록 비밀키 등록 reCAPTCHA 입력 페이지 입력 검증 서드 파티 라이브러리 데코레이터 참고 참고 사이트 회원 가입 시 구글 reCAPTCHA 봇에 의한 기계적인 회원 가입을 막기 위해 CAPTCHA 문자열 입력받을 수 있다. 이때 구글 reCAPTCHA 서비스 이용을 살펴본다. 사이트 등록 구글 reCAPTCHA 관리자 페이지에서 사이트를 등록하여 키를 발급받는다. 위 화면과 같이 내 컴퓨터에서 테스트 목적으로 로컬 호스트 IP 127.0.0.1을 도메인으로 등록한다. 그러면 공개키인 사이트 키(Site key)와 비밀키(Secret key)를 발급받는다. 사이트 키는 웹 페이지의 위젯으로 공개되는 값이지만 비밀키는 settings.py 파일에 비공개로 저장되는 값이다. 비밀키 등록 settings.py 파일에 아래와 같이 등록한다. GOOGLE_RECAPTCHA_SECRET_KEY = '6LdHtSgUAAAAAJM8ehkmf-.............' reCAPTCHA 입력 페이지 <form method="post"> {% csrf_token %} {{ form.as_p }} <script src='https://www.google.com/recaptcha/api.js'></script> <div class="g-recaptcha" data-sitekey="발급받은_고유_사이트_키값"></div> <button type="submit" class="btn btn-primary">Post</button> </form> 여기에서 중요한 코드는 자바스크립트 코드와 사이트 키값을 넘기는 div 태그 두 줄이다. 입력 검증 제너릭뷰 CreateView를 상속한 MessageCreateView 뷰 예시 코드이다. class MessageCreateView(BoardContextMixin, CreateView): logger = logging.getLogger(__name__) form_class = MessageForm template_name = 'board/message_form.html' def get_form_kwargs(self): # 'self.request' 객체를 폼에 전달하기 위해 오버라이딩 self.logger.debug('MessageListView.get_form_kwargs()') kwargs = super(MessageCreateView, self).get_form_kwargs() kwargs['request'] = self.request return kwargs get_form_kwargs() 메서드를 오버라이딩해야 하는데 폼 객체에 request 객체를 전달하도록 아규먼트를 저장해둔다. 모델 폼을 상속한 MessageForm 폼 클래스 예시이다. class MessageForm(forms.ModelForm): def __init__(self, *args, **kwargs): # important to "pop" added kwarg before call to parent's constructor self.request = kwargs.pop('request') super(MessageForm, self).__init__(*args, **kwargs) def clean(self): self.logger.debug('MessageForm.clean()') # Google reCAPTCHA recaptcha_response = self.request.POST.get('g-recaptcha-response') url = 'https://www.google.com/recaptcha/api/siteverify' values = { 'secret': settings.GOOGLE_RECAPTCHA_SECRET_KEY, 'response': recaptcha_response } data = urllib.parse.urlencode(values).encode() req = urllib.request.Request(url, data=data) response = urllib.request.urlopen(req) result = json.loads(response.read().decode()) if not result['success']: raise ValidationError(_('reCAPTCHA error occurred.')) return super(MessageForm, self).clean() 먼저 init() 생성자를 오버라이딩해서 뷰에서 저장해둔 request 객체를 꺼내온다. 나중에 검증을 위해 POST로 전달받은 g-recaptcha-response 값을 가져오기 위해서이다. 뷰의 form_valid() 메서드가 아닌 폼 클래스의 clean() 메서드에서 reCAPTCHA 입력<NAME> 검사를 한다. form_valid() 메서드는<NAME> 검사를 하는 메서드가 아니라 이미<NAME> 검사를 마친 값을 처리하는 메서드이기 때문이다. 서드 파티 라이브러리 requests 서드 파티 라이브러리를 사용하여 소스 코드의 양을 줄일 수 있다. recaptcha_response = self.request.POST.get('g-recaptcha-response') url = 'https://www.google.com/recaptcha/api/siteverify' values = { 'secret': settings.GOOGLE_RECAPTCHA_SECRET_KEY, 'response': recaptcha_response } data = urllib.parse.urlencode(values).encode() req = urllib.request.Request(url, data=data) response = urllib.request.urlopen(req) result = json.loads(response.read().decode()) 위와 같은 코드를 해당 라이브러리를 사용할 경우 아래와 같이 재작성할 수 있다. import requests recaptcha_response = request.POST.get('g-recaptcha-response') data = { 'secret': settings.GOOGLE_RECAPTCHA_SECRET_KEY, 'response': recaptcha_response } r = requests.post('https://www.google.com/recaptcha/api/siteverify', data=data) result = r.json() 캡슐화해서 코드의 양이 조금 줄기는 했지만 별도 라이브러리 없이 copy&paste로 작성해도 무방할 수준 같다. 데코레이터 참고 참고 사이트 How to Add reCAPTCHA to a Django Site 11. 테스트 01) 단위 테스트 12. WSGI 애플리케이션과 배포 WSGI 애플리케이션 서버 연동 예제이다. 여기서는 웹서버 nginx와 연동 가능한 WSGI 애플리케이션 서버로 uWSGI와 Gunicorn 두 가지를 살펴본다. 01) 배포 점검사항 배포 점검사항 manage.py check --deploy 명령 주요 배포 설정값 SECRET_KEY DEBUG ALLOWED_HOSTS 참고 자료 배포 점검사항 애플리케이션 배포 전에 여러 가지 사항을 점검해야 한다. manage.py check --deploy 명령 Django에서 기본적인 점검사항을 제안해 주는 명령어를 제공하고 있다. Django 기본값으로 설정된 settings.py 파일을 별다른 수정 없이 아래와 같이 명령하면 여러 가지 결과를 확인할 수 있다. > manage.py check --deploy ystem check identified some issues: WARNINGS: ?: (security.W004) You have not set a value for the SECURE_HSTS_SECONDS setting. If your entire site is served only over SSL, you may want to consider setting a value and enabling HTTP Strict Transport Security. Be sure to read the documentation first; enabling HSTS carelessly can cause serious, irreversible problems. ?: (security.W006) Your SECURE_CONTENT_TYPE_NOSNIFF setting is not set to True, so your pages will not be served with an 'x-content-type-options: nosniff' header. You should consider enabling this header to prevent the browser from identifying content types inc orrectly. ?: (security.W007) Your SECURE_BROWSER_XSS_FILTER setting is not set to True, so your pages will not be served with an 'x-xss-protection: 1; mode=block' header. You should consider enabling this header to activate the browser's XSS filtering and help prevent XS S attacks. ?: (security.W008) Your SECURE_SSL_REDIRECT setting is not set to True. Unless your site should be available over both SSL and non-SSL connections, you may want to either set this setting True or configure a load balancer or reverse-proxy server to redirect all connections to HTTPS. ?: (security.W012) SESSION_COOKIE_SECURE is not set to True. Using a secure-only session cookie makes it more difficult for network traffic sniffers to hijack user sessions. ?: (security.W016) You have 'django.middleware.csrf.CsrfViewMiddleware' in your MIDDLEWARE, but you have not set CSRF_COOKIE_SECURE to True. Using a secure-only CSRF cookie makes it more difficult for network traffic sniffers to steal the CSRF token. ?: (security.W018) You should not have DEBUG set to True in deployment. ?: (security.W019) You have 'django.middleware.clickjacking.XFrameOptionsMiddleware' in your MIDDLEWARE, but X_FRAME_OPTIONS is not set to 'DENY'. The default is 'SAMEORIGIN', but unless there is a good reason for your site to serve other parts of itself in a f rame, you should change it to 'DENY'. ?: (security.W020) ALLOWED_HOSTS must not be empty in deployment. System check identified 9 issues (0 silenced). 주요 배포 설정값 SECRET_KEY 보안상 절대 공개되면 안 되는 키값으로 실제 배포할 때는 settings.py 파일에 하드코딩하기보다는 환경 변수 또는 파일로 읽어드리는 방법을 권장한다. 소스코드와 비밀번호를 분리하는 것이다. 환경 변수를 읽어 설정하는 법 import os SECRET_KEY = os.environ['SECRET_KEY'] 파일을 읽어 설정하는 법 with open('/etc/secret_key.txt') as f: SECRET_KEY = f.read().strip() DEBUG 운영서버에서는 절대로 디버깅 모드를 사용하지 않는다. DEBUG = False ALLOWED_HOSTS 디버깅 모드에서 ALLOWED_HOSTS 변수가 빈 리스트일 경우 ['localhost', '127.0.0.1', '[::1]'] 의미가 된다. 즉, 로컬 호스트에서만 접속이 가능하다. 디버깅 모드를 끄면 일체 접속이 허용되지 않고 아래와 같이 명시적으로 지정한 호스트에만 접속할 수 있다. ALLOWED_HOSTS = ['example.com', 'www.example.com', 'localhost', ] 참고 자료 Deployment checklist 02) Nginx, uWSGI 배포 시스템 구성 예시 Django 가상환경 준비 패키지 설치 프로젝트/저장소 생성 STATIC_ROOT 디렉터리 지정 마이그레이션 admin 사용자 추가 static 데이터 모으기 테스트 서버 구동 및 접속 확인 uWSGI 구동 테스트 uWSGI 옵션 파일 서비스 등록 스크립트 생성 uWSGI 서비스 등록 uWSGI 서비스 구동 확인 nginx 사이트 설정 추가 사이트 추가 nginx 설정 문법 검사 및 재기동 방화벽 해제 한 서버에 여러 Django 애플리케이션 시스템 전역 uWSGI 설치 uWSGI 설정 Nginx 설정 참고문헌 시스템 구성 예시 우분투 16.04 Django nginx uWSGI 다음 설치 예제는 실제 물리 서버가 아닌 vultr.com의 가상 서버 인스턴스에서 진행하였다. 예제에서 시스템 계정 이름은 foo, 프로젝트 이름은 django_test로 가정한다. Django 가상환경 준비 아래와 같이 가상환경을 설치하고 활성화한다. cd ~ mkdir django_test cd django_test pyvenv venv source venv/bin/activate (venv) 패키지 설치 독립된 가상환경에서 Django를 비롯한 필요한 파이썬 패키지를 설치한다. pip install Django uwsgi 프로젝트/저장소 생성 mkdir repo run sudo chown foo:www-data run cd repo django-admin.py startproject conf . STATIC_ROOT 디렉터리 지정 conf/settings.py 파일의 끝에 다음 줄을 추가한다. STATIC_ROOT = os.path.join(BASE_DIR, 'static/') 마이그레이션 ./manage.py makemigrations ./manage.py migrate admin 사용자 추가 ./manage.py createsuperuser static 데이터 모으기 ./manage.py collectstatic 테스트 서버 구동 및 접속 확인 ./manage.py runserver 0.0.0.0:8000 http://서버_아이피:8000/ 주소로 접속하여 내용이 잘 출력되는지 확인한다. uWSGI 구동 테스트 uwsgi --http :8000 --home /home/foo/django_test/venv --chdir /home/foo/django_test/repo --module conf.wsgi ื주요 옵션의 내용은 다음과 같다. --http 포트 번호를 지정한다. --home virtualenv 가상환경 디렉터리를 지정한다. --chdir manage.py가 들어있는 Django 프로젝트 디렉터리를 지정한다. --module WSGI 모듈을 지정한다. 파이썬 WSGI HTTP 서버를 구동하여 마찬가지로 http://서버_아이피:8000/ 주소에 접속하여 내용이 잘 출력되는지 확인한다. uWSGI 서버가 올바로 동작하면 가상환경에서 이제 빠져나온다. deactivate uWSGI 옵션 파일 /home/foo/django_test/run/uwsgi.ini 파일 생성 [uwsgi] uid = foo base = /home/%(uid)/django_test home = %(base)/venv chdir = %(base)/repo module = conf.wsgi:application env = DJANGO_SETTINGS_MODULE=conf.settings master = true processes = 5 socket = %(base)/run/uwsgi.sock chown-socket = %(uid):www-data chmod-socket = 660 vacuum = true 단일 WSGI 서버만 구동할 것이라면 위와 같이 프로젝트 디렉터리에. ini 파일을 놓을 수 있다. 만약에 여러 개의 WSGI 서버를 구동하고 싶다면 /etc/uwsgi/sites와 같은 시스템 설정 디렉터리에 여러 개의. ini 파일을 둘 수 있다. 서비스 등록 스크립트 생성 /etc/systemd/system/uwsgi.service 파일을 아래와 같은 내용으로 생성한다. [Unit] Description=uWSGI Emperor service [Service] ExecStart=/home/foo/django_test/venv/bin/uwsgi \ --emperor /home/foo/django_test/run User=foo Group=www-data Restart=on-failure KillSignal=SIGQUIT Type=notify NotifyAccess=all StandardError=syslog [Install] WantedBy=multi-user.target --emperor 옵션으로 uwsgi.ini 파일이 들어있는 디렉터리를 지정한다. uWSGI 서비스 등록 sudo systemctl start uwsgi sudo systemctl enable uwsgi uWSGI 서비스 구동 확인 systemctl status uwsgi 만약 구동 실패 시 에러 로그는 /var/log/syslog에서 확인할 수 있다. nginx 사이트 설정 추가 /etc/nginx/sites-available/django_test 파일을 아래와 같은 내용으로 생성한다. upstream withthai-django { server unix:/home/foo/django_test/run/uwsgi.sock; } server { listen 80; server_name 128.199.192.157; location = /favicon.ico { access_log off; log_not_found off; } location /static/ { root /home/foo/django_test/repo; } location / { include /etc/nginx/uwsgi_params; uwsgi_pass django; } } 사이트 추가 sudo ln -s /etc/nginx/sites-available/django_test /etc/nginx/sites-enabled nginx 설정 문법 검사 및 재기동 sudo nginx -t sudo systemctl restart nginx 방화벽 해제 sudo ufw delete allow 8000 sudo ufw allow 'Nginx Full' 한 서버에 여러 Django 애플리케이션 시스템 전역 uWSGI 설치 sudo apt-get install python3-dev python3-pip python3-setuptools sudo -H pip3 install uwsgi uWSGI 설정 여러 애플리케이션의. ini 파일을 /etc/uwsgi/sites 디렉터리 한곳으로 모은다. [Unit] Description=uWSGI Emperor service [Service] ExecStart=/usr/local/bin/uwsgi --emperor /etc/uwsgi/sites Restart=on-failure KillSignal=SIGQUIT Type=notify NotifyAccess=all StandardError=syslog [Install] WantedBy=multi-user.target ExecStart 변수에서 --emperor /etc/uwsgi/sites 옵션을 두는 것이 핵심이다. 시스템 전역적으로 동작하므로 User, Group 변수 설정을 없앤다. 그리고 시스템 전역의 uWSGI를 이용하므로 가상환경의 uWSGI는 굳이 설치하지 않는다. Nginx 설정 upstream 정의 이름이 각 애플리케이션 서버마다 중복되지 않도록 주의한다. server_name에서 도메인 이름을 올바로 선언하고 정적 파일, 로그파일 등의 절대 경로를 정확히 지정한다. 참고문헌 How To Serve Django Applications with uWSGI and Nginx on Ubuntu 16.04 31장 장고 프로젝트 배포하기 - 31.1 작은 프로젝트를 위한 단일 서버의 경우 / Two Scoops of Django 03) Nginx, Gunicorn 배포 시스템 구성 예시 Django 가상환경 준비 패키지 설치 프로젝트/저장소 생성 STATIC_ROOT 디렉터리 지정 마이그레이션 admin 사용자 추가 static 데이터 모으기 테스트 서버 구동 및 접속 확인 Gunicorn 구동 테스트 서비스 등록 스크립트 생성 Gunicorn 서비스 등록 Gunicorn 서비스 구동 확인 nginx 사이트 설정 추가 사이트 추가 nginx 설정 문법 검사 및 재기동 방화벽 해제 참고문헌 시스템 구성 예시 우분투 16.04 Django nginx Gunicorn 다음 설치 예제는 실제 물리 서버가 아닌 vultr.com의 가상 서버 인스턴스에서 진행하였다. 예제에서 시스템 계정 이름은 foo, 프로젝트 이름은 django_test로 가정한다. Django 가상환경 준비 아래와 같이 가상환경을 설치하고 활성화한다. cd ~ mkdir django_test cd django_test pyvenv venv source venv/bin/activate (venv) 패키지 설치 독립된 가상환경에서 Django를 비롯한 필요한 파이썬 패키지를 설치한다. pip install Django gunicorn 프로젝트/저장소 생성 mkdir repo run sudo chown foo:www-data run cd repo django-admin.py startproject conf . STATIC_ROOT 디렉터리 지정 conf/settings.py 파일의 끝에 다음 줄을 추가한다. STATIC_ROOT = os.path.join(BASE_DIR, 'static/') 마이그레이션 ./manage.py makemigrations ./manage.py migrate admin 사용자 추가 ./manage.py createsuperuser static 데이터 모으기 ./manage.py collectstatic 테스트 서버 구동 및 접속 확인 ./manage.py runserver 0.0.0.0:8000 http://서버_아이피:8000/ 주소로 접속하여 내용이 잘 출력되는지 확인한다. Gunicorn 구동 테스트 gunicorn --bind 0.0.0.0:8000 conf.wsgi:application 파이썬 WSGI HTTP 서버 Gunicorn으로 구동하여 마찬가지로 http://서버_아이피:8000/ 주소에 접속하여 내용이 잘 출력되는지 확인한다. Gunicorn 서버가 올바로 동작하면 가상환경에서 이제 빠져나온다. deatviate 서비스 등록 스크립트 생성 /etc/systemd/system/gunicorn.service 파일을 아래와 같은 내용으로 생성한다. [Unit] Description=gunicorn daemon After=network.target [Service] User=foo Group=www-data WorkingDirectory=/home/foo/django_test/repo ExecStart=/home/foo/django_test/venv/bin/gunicorn \ --workers 3 \ --bind unix:/home/foo/django_test/run/gunicorn.sock \ conf.wsgi:application [Install] WantedBy=multi-user.target Gunicorn 서비스 등록 sudo systemctl start gunicorn sudo systemctl enable gunicorn Gunicorn 서비스 구동 확인 systemctl status gunicorn 만약 구동 실패 시 에러 로그는 /var/log/syslog에서 확인할 수 있다. nginx 사이트 설정 추가 /etc/nginx/sites-available/django_test 파일을 아래와 같은 내용으로 생성한다. server { listen 80; server_name 128.199.161.10; location = /favicon.ico { access_log off; log_not_found off; } location /static/ { root /home/foo/django_test/repo; } location / { include proxy_params; proxy_pass http://unix:/home/foo/django_test/run/gunicorn.sock; } } 사이트 추가 sudo ln -s /etc/nginx/sites-available/django_test /etc/nginx/sites-enabled nginx 설정 문법 검사 및 재기동 sudo nginx -t sudo systemctl restart nginx 방화벽 해제 sudo ufw delete allow 8000 sudo ufw allow 'Nginx Full' 참고문헌 How To Set Up Django with Postgres, Nginx, and Gunicorn on Ubuntu 16.04 31장 장고 프로젝트 배포하기 - 31.1 작은 프로젝트를 위한 단일 서버의 경우 / Two Scoops of Django 04) SSL 설치 SSL 설치 05) 이메일 서버 연동 예제 gmail 연동 예제 gmail 연동 대용량 이메일 발송이 아닌 비상업적인 용도로 개발 테스트에는 gmail 발송 정도면 충분하다. EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend' EMAIL_HOST = 'smtp.gmail.com' EMAIL_PORT = 587 EMAIL_HOST_USER = 'user name@gmail.com 또는 user name@example.com' EMAIL_HOST_PASSWORD = '앱 비밀번호' EMAIL_USE_TLS = True 여기서 주의할 점은 EMAIL_HOST_USER 이메일 주소는 gmail 계정을 올바르게 적어주되 EMAIL_HOST_PASSWORD 비밀번호는 일반적으로 웹에서 로그인하는 비밀번호가 아니다. 앱 비밀번호 관리 페이지에서 별도로 앱 비밀번호를 생성하여 이를 적어준다. 개발 및 테스트 용도로 이메일 발송할 때 아래 코드로 잘 동작하는지 확인할 수 있다. send_mail('Subject here', 'Here is the message.', 'user name@gmail.com', ['abc@example.com'], fail_silently=False) 피싱 사기를 방지하기 위해 보내는 이메일 주소를 user name@gmail.com 아닌 다른 이메일 주소로 지정하더라도 gmail에서 무조건 구글 계정으로 치환하여 보낸다. 06) 배포 자동화 Invoke는 파이썬 3 호환으로 Fabric 대신 사용 가능하다. 13. 성능 01) 로그와 프로파일링 로깅 settings.py 파일 로깅 Django에서 로그 레벨은 아래와 같이 나뉜다. DEBUG: 디버깅 목적으로 로우 레벨 시스템 정보 INFO: 일반적 시스템 정보 WARNING: 경미한 문제 발생을 알리는 정보 ERROR: 중요한 문제 발생을 알리는 정보 CRITICAL: 심각한 문제를 알리는 정보 settings.py 파일 LOGGING = { 'version': 1, 'disable_existing_loggers': False, 'handlers': { 'console': { 'level': 'DEBUG', 'class': 'logging.StreamHandler', } }, 'loggers': { 'django.db.backends': { 'handlers': ['console'], 'level': 'DEBUG', }, 'your_app': { 'handlers': ['console'], 'level': 'DEBUG', }, } } 02) 캐싱 캐시 백엔드 개발 환경 메모리 캐시 템플릿 부분 캐시 캐시 백엔드 개발 환경 메모리 캐시 CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache', 'LOCATION': 'unique-snowflake', 'TIMEOUT': 300, # 기본값 300초 = 5분 'OPTIONS': { 'MAX_ENTRIES': 300 # 기본값 = 300 } } } LocMemCache 메모리 캐시를 개발 환경에서 사용할 수 있다. 템플릿 부분 캐시 캐시 할 내용을 통째로 cache 태그로 감싼다. {% load cache %} {% cache 600 sidebar %} .. sidebar .. {% endcache %} 위와 같이 cache 태그로 감싸면 여러 번 요청이 들어와도 600초간 그 안의 내용을 가져오기 위해 데이터베이스에 질의하지 않는다. 14. 배포 가능한 재사용 앱 01) 파이썬 배포판 패키징 배포판 프로그램 기본 구조 파이썬 모듈/패키지 이름 규칙 예제 소스코드 sample 패키지의 hello() 함수 호출 사용 pip 명령어 설치 및 삭제 관리 배포판의 설치 sample 패키지의 hello() 함수 호출 패키지의 hello() 함수 호출 배포판 빌드 배포판의 삭제 Setuptools 모듈 setup() 함수 여러 가지 옵션 MANIFEST.in 파일 요약 참고 문서 들어가기 전에 이 문서에서는 아래와 같이 용어를 정의한다. 배포판: pip으로 설치 가능한 애플리케이션 패키지: 파이썬 모듈과 __init.py 파일이 이 들어있는 디렉터리 모듈: 파이썬. py 소스 파일 실제로는 배포판이라는 표현 대신에 패키지를 많이 사용하지만 이번 문서에서는 혼동을 피하고 명확히 구별하기 위함이다. 배포판 프로그램 기본 구조 최소한의 배포판 프로젝트 구조는 다음과 같다. packaging-tutorial/ sample/ __init__.py greeting.py setup.py 각 디렉터리 및 파일은 다음 의미를 갖는다. packaging-tutorial/: packaging-tutorial.git 같은 저장소 디렉터리이다. packaging-tutorial/sample/: 파이썬 예제 패키지를 위한 디렉터리이다. packaging-tutorial/sample/__init__.py: 디렉터리가 패키지임을 파이썬에게 알려주는 파일이다. packaging-tutorial/sample/greeting.py: sample 패키지에 속하는 greeting 모듈/파일이다. packaging-tutorial/setup.py: 파이썬 프로그램 패키지를 구성하는 가장 핵심적인 파일이다. 파이썬 모듈/패키지 이름 규칙 파이썬 모듈/패키지의 이름 규칙은 일반적으로 아래와 같다. 모두 소문자로 작성한다. pypi에서 유일해야 한다. 단어는 -(하이픈)이 아니라 _(밑줄)로 띄어 쓴다. 저장소 이름은 packaging-tutorial과 같이 하이픈을 사용할 수도 있다. 하지만 패키지의 이름은 sample과 같이 모두 소문자로 작성한다. 예제 소스코드 packaging-tutorial/sample/__init__.py 파일 아무런 내용이 없는 빈 파일이다. 파일 이름만 __init__.py로 맞춰준다. packaging-tutorial/sample/greeting.py 파일 def hello(): print('Hello world.') 단순히 'Hello world' 문자열만 출력하는 hello() 함수 하나만 정의되어 있다. packaging-tutorial/setup.py from setuptools import setup setup(name='packaging-tutorial', version='0.1', packages=['sample'], ) 패키지에 관한 여러 가지 부가 정보가 없이 패키지 빌드에 필요한 핵심 속성 파라미터로 전달하여 setup() 함수를 호출한다. name 속성: 배포판의 이름으로 재사용 가능한 배포판을 만들기 위해 PyPI에 등록된 외부 배포판 또는 내부 프로젝트의 배포판 이름과 중복되지 않는 이름을 짓는다. 대소문자를 구별하지 않고 유일한 이름을 짓는다. version 속성: 초기 버전으로 0.1로 지정하였다. packages 속성: 배포판에 포함시킬 패키지(디렉터리) 목록을 나열한다. 최상위 패키지뿐만 아니라 하위 패키지들까지 모두 나열해야 하는 것에 주의한다. 패키지 안의 모듈(파일)을 나열할 필요는 없다. sample 패키지의 hello() 함수 호출 사용 packaging-tutorial 디렉터리 안에서 파이썬 인터프리터를 실행하여 아래와 같이 명령하여 hello() 함수 호출을 확인할 수 있다. $ python Python 3.6.2 (default, Aug 20 2017, 17:24:58) [GCC 5.4.0 20160609] on linux Type "help", "copyright", "credits" or "license" for more information. >>> from sample.greeting import hello >>> hello() Hello world. >>> 만약 packaging-tutorial 디렉터리가 아닌 곳에서 실행할 경우에는 아래와 같이 모듈을 찾을 수 없다는 에러가 발생한다. >>> from sample.greeting import hello Traceback (most recent call last): File "<stdin>", line 1, in <module> ModuleNotFoundError: No module named 'sample' >>> pip 명령어 설치 및 삭제 관리 배포판의 설치 packaging-tutorial 디렉터리 안에서 pip install . 명령하여 배포판을 설치할 수 있다. $ pip install . Processing /home/m/Projects/packaging-tutorial Building wheels for collected packages: packaging-tutorial Running setup.py bdist_wheel for packaging-tutorial ... done Stored in directory: /home/m/.cache/pip/wheels/a2/76/a3/e04ee8b8f9f8511822ef4052878bcdf28ad30e7a0c223f02ec Successfully built packaging-tutorial Installing collected packages: packaging-tutorial Successfully installed packaging-tutorial-0.1 pip 배포판 설치 확인은 pip freeze 명령어로 할 수 있다. $ pip freeze packaging-tutorial==0.1 sample 패키지의 hello() 함수 호출 패키지의 hello() 함수 호출 앞서 배포판을 설치하기 전에는 packaging-tutorial 디렉터리 안에서만 파이썬 인터프리터를 실행하여 hello() 함수 호출을 확인할 수 있었다. 그러나 packaging-tutorial 패키지를 설치했기 대문에 해당 파이썬 환경에서는 어느 디렉터리에서 나 hello() 함수를 호출할 수 있다. 배포판 빌드 개발 환경에서는 배포판 소스코드에서 pip install . 명령으로 바로 배포판을 설치했지만 진정한 의미의 배포를 위해 python setup.py sdist 명령어로 배포판을 빌드 할 수 있다. $ python setup.py sdist running sdist running egg_info creating packaging_tutorial.egg-info writing packaging_tutorial.egg-info/PKG-INFO writing dependency_links to packaging_tutorial.egg-info/dependency_links.txt writing top-level names to packaging_tutorial.egg-info/top_level.txt writing manifest file 'packaging_tutorial.egg-info/SOURCES.txt' reading manifest file 'packaging_tutorial.egg-info/SOURCES.txt' writing manifest file 'packaging_tutorial.egg-info/SOURCES.txt' warning: sdist: standard file not found: should have one of README, README.rst, README.txt running check warning: check: missing required meta-data: url creating packaging-tutorial-0.1 creating packaging-tutorial-0.1/packaging_tutorial.egg-info creating packaging-tutorial-0.1/sample copying files to packaging-tutorial-0.1... copying setup.py -> packaging-tutorial-0.1 copying packaging_tutorial.egg-info/PKG-INFO -> packaging-tutorial-0.1/packaging_tutorial.egg-info copying packaging_tutorial.egg-info/SOURCES.txt -> packaging-tutorial-0.1/packaging_tutorial.egg-info copying packaging_tutorial.egg-info/dependency_links.txt -> packaging-tutorial-0.1/packaging_tutorial.egg-info copying packaging_tutorial.egg-info/top_level.txt -> packaging-tutorial-0.1/packaging_tutorial.egg-info copying sample/__init__.py -> packaging-tutorial-0.1/sample copying sample/greeting.py -> packaging-tutorial-0.1/sample Writing packaging-tutorial-0.1/setup.cfg creating dist Creating tar archive removing 'packaging-tutorial-0.1' (and everything under it) 이제 dist 디렉터리 안에 packaging-tutorial-0.1.tar.gz 파일이 생성된다. 소스 디렉터리 안에서 pip install.로 설치하는 것이 아니라 배포판 압축 파일을 지정하여 설치할 수도 있다. pip install dist/packaging-tutorial-0.1.tar.gz 배포판의 삭제 pip uninstall 명령어로 배포판을 삭제할 수 있다. $ pip uninstall packaging-tutorial Uninstalling packaging-tutorial-0.1: /home/m/.pyenv/versions/3.6.2/envs/venv/lib/python3.6/site-packages/packaging_tutorial-0.1.dist-info/DESCRIPTION.rst /home/m/.pyenv/versions/3.6.2/envs/venv/lib/python3.6/site-packages/packaging_tutorial-0.1.dist-info/INSTALLER /home/m/.pyenv/versions/3.6.2/envs/venv/lib/python3.6/site-packages/packaging_tutorial-0.1.dist-info/METADATA /home/m/.pyenv/versions/3.6.2/envs/venv/lib/python3.6/site-packages/packaging_tutorial-0.1.dist-info/RECORD /home/m/.pyenv/versions/3.6.2/envs/venv/lib/python3.6/site-packages/packaging_tutorial-0.1.dist-info/WHEEL /home/m/.pyenv/versions/3.6.2/envs/venv/lib/python3.6/site-packages/packaging_tutorial-0.1.dist-info/metadata.json /home/m/.pyenv/versions/3.6.2/envs/venv/lib/python3.6/site-packages/packaging_tutorial-0.1.dist-info/top_level.txt /home/m/.pyenv/versions/3.6.2/envs/venv/lib/python3.6/site-packages/sample/__init__.py /home/m/.pyenv/versions/3.6.2/envs/venv/lib/python3.6/site-packages/sample/__pycache__/__init__.cpython-36.pyc /home/m/.pyenv/versions/3.6.2/envs/venv/lib/python3.6/site-packages/sample/__pycache__/greeting.cpython-36.pyc /home/m/.pyenv/versions/3.6.2/envs/venv/lib/python3.6/site-packages/sample/greeting.py Proceed (y/n)? y Successfully uninstalled packaging-tutorial-0.1 Setuptools 모듈 setup() 함수 여러 가지 옵션 표준 라이브러리에 포함된 Distutils 모듈을 통해 setup.py 파일에 따라 배포판이 설치된다. 그러나 distutils.core 패키지의 setup() 함수를 쓸 수 있지만 많은 개발자가 setuptools 패키지의 setup() 함수를 사용하고 있다. 여기서는 setup() 함수에 넘길 수 있는 기본적인 파라미터 외에 다양한 파라미터를 살펴본다. packaging-tutorial/setup.py 파일 import os from setuptools import setup, find_packages with open(os.path.join(os.path.dirname(__file__), 'README.rst')) as readme: README = readme.read() setup(name='packaging-tutorial', version='0.1', packages=find_packages(exclude=['docs', 'tests']), description='Example package for packaging tutorial', long_description=README, url='https://www.example.com/', author='John Doe', author_email='test' '@' 'exmaple.com', license='MIT', classifiers=[ 'Development Status :: 3 - Alpha', 'Intended Audience :: Developers', 'Topic :: Software Development :: Build Tools', 'License :: OSI Approved :: MIT License', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.4', 'Programming Language :: Python :: 3.5', 'Programming Language :: Python :: 3.6', ], install_requires=[ 'foo', 'bar', ], scripts=['manage.py'], zip_safe=False, ) 다음 속성은 배포판 메타 정보로서 배포판 빌드 자체에 영향을 주는 속성은 아니다. description 속성: 배포판에 대한 설명 long_description 속성: 배포판에 대한 자세한 설명이다. 일반적으로 README.md 파일의 내용으로 보통은 예시 코드처럼 작성한다. 아래에서 다시 언급하지만 README.md 파일을 함께 배포할 수 있도록 MANIFEST.in 파일에 기술한다. 그렇지 않으면 실제 배포할 때 README.md 파일을 찾을 수 없어 에러가 발생한다. url 속성: 배포판 홈페이지 author 속성: 배포판 작성자 이름 author_email 속성: 배포판 작성자 이메일 주소, 메일 수집해 스팸 메일을 받을 수 있으므로 위와 같이 적당히 문자열 연결하여 이메일 주소를 만든다. license 속성: 배포판의 라이선스 classifiers 속성: PyPI 등록을 위해 배포판 분류 정보이다. 공식 문서에서 가능한 값의 목록을 참고한다. 다음 속성은 배포판 빌드에 영향을 주는 속성으로 정확히 지정해야 한다. packages 속성: setuptools를 쓰는 가장 중요한 이유 중에 하나가 바로 find_packages() 함수의 기능이다. 직접 설치할 패키지 목록을 나열한다면 하위 디렉터리의 패키지까지 나열해야 하는데 이를 재귀적으로 find_package() 함수가 처리해 준다. 이때 docs, tests 같이 포함되지 않아야 할 디렉터리가 있다면 명시적으로 exclude=['docs', 'tests'] 같은 파라미터를 넘겨줄 수도 있다. install_requires 속성: 배포판이 필요로 하는 패키지 목록 scripts 속성: 배포판에 포함될 파이썬 스크립트 파일 목록 (예를 들어, Django 프로젝트의 manage.py 파일을 같이 배포하고 싶은 경우) zip_safe 속성: zip 파일로 만들어서 실행해도 패키지가 정상적으로 동작하는지 MANIFEST.in 파일 파이썬 스크립트 외의 파일도 배포하는 경우가 있다. 어떤 파일/디렉터리를 함께 배포해야 할지 MANIFEST.in 파일에 기술한다. MANIFEST.in 파일 예시 include LICENSE include README.md recursive-include your_app/static * recursive-include your_app/templates * global-exclude conf/settings/secret.py 위 예시에서 include 지시어로 LICENSE, README.md 파일을 배포판에 포함한다. recursive-include 지시어로 your_app/static, your_app/templates 같은 특정 디렉터리의 내용을 재귀적으로 배포판에 전부 포함시키도록 한다. global-exclude 지시어로 비밀번호나 공개되지 않아야 할 데이터가 들어있는 소스 파일은 무조건 포함시키지 않는다. 요약 배포판 패키징을 위해 작성할 파일은 크게 다음과 같다. setup.py MANIFEST.py README.md 참고 문서 How To Package Your Python Code pypa/sampleproject 예시 프로젝트 02) Django 프로젝트 및 앱 패키징 Django 프로젝트 패키징 배포판 만들기 배포판 설치 배포판 실행 Django 앱 패키징 Django 프로젝트 패키징 배포판 만들기 Django 프로젝트를 패키징 하는 것은 생각처럼 유용한 일이진 않을 수 있다. 이유는 Django 프로젝트는 사이트마다 설정값 등이 다 제각각이어서 라이브러리로 만들어도 재사용이 어렵기 때문이다. 그러나 여기서는 학습 차원에서 Django 프로젝트를 직접 패키징 해본다. setup.py 파일 예시 import os from setuptools import setup, find_packages with open(os.path.join(os.path.dirname(__file__), 'README.md')) as readme: README = readme.read() setup(name='django-quickstarter', version='0.1', packages=find_packages(exclude=[ 'docs', ]), description='Django-based project boilerplate that follows best practices', long_description=README, url='https://www.example.com/', author='John Doe', author_email='test' '@' 'exmaple.com', license='MIT', classifiers=[ 'Development Status :: 3 - Alpha', 'Framework :: Django', 'Intended Audience :: Developers', 'Topic :: Software Development :: Build Tools', 'License :: OSI Approved :: MIT License', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.4', 'Programming Language :: Python :: 3.5', 'Programming Language :: Python :: 3.6', ], install_requires=[ 'Django', 'django-crispy-forms', ], setup_requires=[ ], scripts=[ 'manage.py', ], ) MANIFEST.in 파일 include LICENSE include README.md recursive-include requirements * recursive-include conf/static * recursive-include conf/templates * global-exclude conf/settings/secret.py 배포판 설치 pip install 명령어로 Django 프로젝트의 배포판을 설치할 수 있다. $ pip install django-quickstarter-0.1.tar.gz 배포판 실행 Django 프로젝트의 경우 settings.py 파일에는 비밀키 같은 비공개 데이터가 들어가 있기 때문에 이를 패키징 할 때 포함하기가 곤란하다. 그래서 직접 ~/.pyenv/versions/3.6.2/envs/venv-test/lib/python3.6/site-packages/conf/settings/secret.py 같은 비공개 데이터가 들어있는 파일을 수동으로 만들어줘야 한다. 또한 실행하더라도 설정값의 변경이 필요할 수 있다. 이럴 경우에는 직접 ~/.pyenv/versions/3.6.2/envs/venv-test/lib/python3.6/site-packages/conf/settings/production.py 같은 파일을 수정해야 한다. Django 앱 패키징 03) tox와 coverage tox pyenv tox.ini 파일 실행 travis coverage tox pyenv pyenv와 가상환경 문서를 참고한다. tox.ini 파일 tox-quickstart 명령어로 tox.ini 파일을 만들 수 있다. 공식 문서에서 소개하는 가장 간단한 tox.ini 파일은 다음과 같다: [tox] envlist = py27, py34, py35, py36 [testenv] commands = pytest deps = pytest [tox] 섹션의 envlist 변수는 테스트하려는 파이썬 버전을 나열한다. 위 예시에서는 2.7, 3.4, 3.5, 3.6 버전으로 테스트할 것이다. [testenv] 섹션의 commands 변수는 테스트를 실행하는 명령어의 예시는 다음과 같다. pytest python setup.py test nosetests package.module trial package.module [testenv] 섹션의 deps 변수로 테스트 실행을 위해 의존성 설치해야 하는 패키지를 나열할 수 있다. 위 예시에서는 pytest 실행하기로 했으므로 pytest 패키지를 임시 설치하여 테스트 진행한다. 실행 travis coverage 99. 부록 01) 파이썬 Django를 공부하기 위해 필요한 파이썬 기초 02) vultr 인스턴스 초기 설정 기본 준비 시스템 사용자 추가 루트 로그인 접속 금지 admin 그룹의 사용자만 su/sudo 명령어 사용 허가 설치 주요 패키지 설치 기본 준비 이는 vultr.com의 인스턴스 서버에서 설치하기 때문에 기본적인 시스템 사용자가 추가되어 있지 않다. 따라서 이 부분은 실제 시스템 사용자가 구성되어 있다면 생략 가능한 과정이다. 시스템 사용자 추가 foo 이름의 시스템 사용자를 추가한다. useradd -G admin -b /home -m -s /bin/bash foo passwd foo 루트 로그인 접속 금지 foo 사용자는 admin 그룹에 속하므로 sudo 명령어를 사용할 수 있다. 루트 접속은 금지한다. passwd -d -l root usermod -s /bin/false root admin 그룹의 사용자만 su/sudo 명령어 사용 허가 시스템 보안상 admin 그룹의 사용자만 su/sudo 명령어를 사용할 수 있도록 한다. dpkg-statoverride --update --add root admin 4750 /bin/su dpkg-statoverride --update --add root admin 4750 /usr/bin/sudo 설치 주요 패키지 설치 패키지를 업데이트한다. sudo apt-get update && sudo apt-get dist-upgrade 최소한 필요한 패키지 nginx와 python3-venv를 설치한다. sudo apt-get install python3-venv nginx 필요에 따라 apt-get install 명령어로 다음 패키지들을 추가로 설치할 수 있다. PostgreSQL 데이터베이스 관련 패키지 postgresql libpq-dev postgresql-contrib PostgreSQL, uWSGI, Gunicorn 등의 연동을 위한 빌드 관련 패키지 python3-dev build-essential 우분투 16.04 버전에서 파이썬을 실행하려면 명시적으로 python3 버전으로 명령해야 한다. 아래와 같이 파이썬 설치를 확인한다. python3 Python 3.5.2 (default, Jul 5 2016, 12:43:10) [GCC 5.4.0 20160609] on linux Type "help", "copyright", "credits" or "license" for more information. >>> 03) PyCharm 활용 Django 프로젝트 시작하기 PyCharm IDE 기본값 주요 활용 주요 단축키 여러 가지 문제 해결 runserver 실행 시 0xC0000005 종료 코드 Django 콘솔 창에서 라이브러리 로딩 실패 Django 프로젝트 시작하기 PyCharm IDE 기본값 실행 및 디버그 설정 프로젝트 구조 Django 콘솔 PyCharm Django 지원 주요 활용 주요 단축키 자동 완성: Ctrl+Space 파일 열기: Ctrl+Shift+N 경로에서 열기: Ctrl+Shift+F 빠른 검색: Shift 두 번 선언으로 이동: Ctrl+B 코드 포맷팅: Ctrl+Alt+L import 구문 정리: Ctrl+Alt+O 파일 닫기: Ctrl+F4 여러 가지 문제 해결 runserver 실행 시 0xC0000005 종료 코드 2017.1.3 이전 버전에서 아래와 같이 runserver 실행 시 0xC0000005 종료 코드로 테스트 서버가 실행되지 않는 현상이 있었다. "C:\Program Files (x86)\JetBrains\PyCharm 143.19\bin\runnerw.exe" C:\Python\Python35\python.exe C:/Users/mairoo/PycharmProjects/django35/manage.py runserver 8000 Process finished with exit code -1073741819 (0xC0000005) 해결 방법은 다음과 같다. 메뉴에서 Run > Edit Configurations 선택 후 환경 변수를 다음과 같이 등록한다. 이름(Name): =C: 값(Value): c:\" 출처: runnerw.exe sometimes finishes with exit code -1073741819 (0xC0000005) Django 콘솔 창에서 라이브러리 로딩 실패 개발 중에 프로젝트 이름, 프로젝트 디렉터리 이름 등을 변경하면 아래와 같은 에러가 발생하고 Django 콘솔이 올바로 동작하지 않는 경우가 있다. django.core.exceptions.ImproperlyConfigured: Requested setting LOGGING_CONFIG, but settings are not configured. You must either define the environment variable DJANGO_SETTINGS_MODULE or call settings.configure() before accessing settings. 에러 메시지에서 보는 것처럼 File > Settings 메뉴를 클릭해 설정 팝업이 뜨면 Build, Execution, Deployment > Console > Django Console 메뉴에서 DJANGO_SETTINGS_MODULE 환경 변수를 아래와 같이 알맞은 값으로 재설정한다. 04) 12 팩터 앱 (12 Factor App) 코드 베이스(Codebase) 의존성(Dependencies) 설정(Config) 백엔드 서비스(Backing Services) 빌드, 릴리스, 실행(Build, Release, Run) 프로세스(Processes) 포트 바인딩(Port Binding) 동시성(Concurrency) 폐기 가능(Disposability) 운영/개발 환경 일치(Dev/Prod Parity) 로그(Logs) 관리 프로세스(Admin Processes) 참고문헌 SaaS, PaaS 앱을 만들기 위한 방법론 코드 베이스(Codebase) 코드는 한곳에서 관리하고 Git 사용을 추천한다. 코드는 여러 대의 분산처리 운영서버나 여러 개발자의 컴퓨터로 배포, 실행될 수 있다. 의존성(Dependencies) 의존성 라이브러리는 requirements.txt 등에 명시적으로 선언한다. pip은 종속성 선언에 사용되고 virtualenv는 독립된 가상환경으로 시스템 사이에 종속성 분리를 위해 사용한다. curl, ImageMagick 같은 시스템 유틸리티에 의존하지 않는다. 모든 시스템에서 존재한다고 보장할 수 없으며 존재하더라도 100% 호환된다고 보장할 수 없다. 설정(Config) 애플리케이션의 설정은 운영, 개발 환경 등에 따라 달라질 수 있다. 데이터베이스를 비롯한 여러 서버의 접속 정보, 비밀번호 등 설정을 코드에 저장하지 않는다. 주요 설정은 환경 변수로 저장하거나 저장소에 커밋 되지 않는 파일에 저장한다. 백엔드 서비스(Backing Services) 코드는 로컬 서비스와 서드파티 서비스를 구별하지 않기 위해 URI로 접근한다. postgres://USER:PASSWORD@HOST:PORT/NAME mysql://USER:PASSWORD@HOST:PORT/NAME 빌드, 릴리스, 실행(Build, Release, Run) 빌드, 릴리스, 실행 단계를 엄격히 구분한다. 빌드는 소스를 컴파일하고 정적 파일을 구성해서 실행 가능한 번들로 변환시키는 것이다. 릴리스는 운영 또는 개발서버에 배포하는 것이다. 실행은 런타임 환경으로 프로그램이 동작하는 프로세스의 집합이다. 프로세스(Processes) 무상태 프로세스로 실행되는 여러 개의 프로세스 사이에 아무것도<NAME>지 않는다. 유지가 필요한 모든 데이터는 데이터베이스처럼 안정된 백엔드 서비스에 저장한다. 캐시 된 데이터를 무조건 신뢰해서는 안 된다. 사용자의 세션 데이터를 앱의 프로세스 메모리에 캐싱 한 후 같은 사용자가 이후에 동일한 프로세스로 요청할 거라고 가정해서는 안 된다. Sticky Session은 12 Factor에 위배된다. 포트 바인딩(Port Binding) 80 포트를 바인딩 하여 실제 웹 서비스를 제공한다. 동시성(Concurrency) 같은 일을 하는 프로세스를 수직적으로 추가할 수 있다. 다른 일을 하는 프로세스를 수평적으로 추가할 수 있다. 폐기 가능(Disposability) 프로세스는 빠르게 시작할 수 있어야 한다. 프로세스가 갑자기 죽더라도 서비스 장애가 발생해서는 안 된다. 운영/개발 환경 일치(Dev/Prod Parity) 개발 환경과 운영환경을 최대한 비슷하게 유지하여 쉽고 빠르게 재배포할 수 있도록 한다. 로그(Logs) stdout 표준 출력으로만 로그를 출력한다. 이는 loggack/slf4j를 사용하는 자바 개발자에게는 다소 납득하기 어려울 수 있다. 관리 프로세스(Admin Processes) 운영 중인 애플리케이션에 migrate 같은 관리 작업은 일회성으로 실행한다. 관리 코드는 동기화 문제를 피하기 위해 애플리케이션 코드와 함께 배포된다. 데이터베이스의 값을 직접 수정하지는 않는다. 참고문헌 The Twelve-Factor App 12-Factor Apps in Plain English https://dzone.com/articles/the-12-factor-app-a-java-developers-perspective 05) OWASP Top 10 보안 위험 Top 10 인젝션 인증 및 세션 관리 취약점 크로스 사이트 스크립팅(XSS) 취약한 직접 객체 참조 보안 설정 오류 민감 데이터 노출 기능 수준의 접근 통제 누락 크로스 사이트 요청 변조(CSRF) 알려진 취약점이 있는 컴포넌트 사용 검증되지 않은 리다이렉트 및 포워드 참고문헌 보안 위험 Top 10 인젝션 인증 및 세션 관리 취약점 크로스 사이트 스크립팅(XSS) 취약한 직접 객체 참조 보안 설정 오류 민감 데이터 노출 기능 수준의 접근 통제 누락 크로스 사이트 요청 변조(CSRF) 알려진 취약점이 있는 컴포넌트 사용 검증되지 않은 리다이렉트 및 포워드 참고문헌 가장 심각한 웹 애플리케이션 보안 위험 10 가지<|endoftext|>

전문분야 텍스트 ### 제목: 빅데이터 - 하둡, 하이브로 시작하기 ### 본문: 이 책은 하둡을 처음 시작하는 사람들을 대상으로 작성하였습니다. 하둡은 빅데이터 기술의 시작점입니다. 하둡이 맵리듀스와 HDFS 기술을 소개하면서 빅데이터를 적당한 가격으로 분석할 수 있게 되었습니다. 여기에 하둡이 오픈 소스가 되면서 하둡을 기반으로 하는 하둡 에코 시스템들이 다양하게 나타나면서 빅데이터 분석 기술이 폭발적으로 발전할 수 있게 되었습니다. 하이브는 SQL을 이용하여 맵리듀스를 실행할 수 있게 해주는 기술입니다. SQL을 이용하기 때문에 개발자가 아니어도 쉽게 데이터를 분석할 수 있습니다. 그리고 파일의 정보의 물리적인 구조를 테이블 형태의 논리적 구조로 설명할 수 있기 때문에 데이터 분석이 더욱 쉬워집니다. 이 책은 하둡 2.7 버전, 하이브 2.1 버전을 기준으로 작성되었습니다. 버전의 차이로 인해 다른 부분이나 틀린 부분은 알려주시면 수정하도록 하겠습니다. 감사합니다. mail to <EMAIL> 1-빅데이터 빅데이터가 무엇인지 알아보겠습니다. 빅데이터란? 빅데이터 처리단계 빅데이터 에코시스템 1-빅데이터란? 빅데이터는 큰 사이즈의 데이터로부터 유의미한 지표를 분석해 내는 것으로 정의할 수 있습니다. SNS, 로그, 문서 등 다양한 경로를 통해 수집한 여러 가지 형태의 많은 양의 데이터를 이용하여 의사결정에 도움을 주는 지표를 분석하여 제공하는 것입니다. 정의 데이터 규모에 초점을 맞춘 정의(맥킨지, 2011) 기존 DB 관리 도구의 수집, 저장, 관리, 분석 역량을 넘어서는 데이터 업무 수행 방식에 초점을 맞춘 정의(IDC, 2011) 다양한 종류의 대규모 데이터로부터 가치를 추출하고, 데이터의 빠른 수집, 발굴, 분석을 지원하도록 고안된 기술 및 아키텍처 출현 배경 최근에 빅데이터가 많은 관심을 받기 시작한 이유는 다음과 같습니다. 데이터양의 증가와 데이터 저장기술 발달 SNS 등장, 스마트 기기 보급으로 발생하는 데이터의 양이 증가 디지털 저장기술과 장치의 발달 경제적 타당성 증가 / 저장 장치의 가격 인하 1980년대 1G 10억 이상이던 메모리 가격이 2010년대 100원 미만으로 떨어짐 대용량의 데이터를 저장하여도 경제성이 있음 데이터 처리기술 발달 분산 병렬처리 기술의 발달로 합리적인 시간 안에 데이터 분석이 가능해짐 CPU 발전, 클라우드 컴퓨팅, 하둡 등 오픈소스 활성화로 스케일 아웃이 편리해짐 빅데이터 특징 - 3V 빅데이터의 특징은 3V로 정의할 수 있습니다. Volume - 크기 저장 장치 가격의 하락, 네트워크 속도의 향상으로 수 페타바이트의 데이터가 매일 생성 Variety - 다양성 정형, 반 정형, 비정형 형태의 다양한 데이터를 분석 Velocity - 속도 정보의 유통 속도가 굉장히 빠름. 데이터의 처리 속도가 빠름. 일, 주, 월단위 배치 처리와 초 단위 실시간 데이터 처리 빅데이터 특징 - 5V 3V에 아래의 두 가지를 추가해서 5V로 부르기도 합니다. Value - 가치 유의미한 가치를 가지는 지표 지표를 사용하는 사람의 의사 결정에 도움을 줄 수 있는 정보를 제공 Veracity - 정확성 빅데이터를 이용하여 뽑아낸 데이터의 신뢰성, 정확성이 높음 데이터가 많아질수록 더 정확한 분석이 가능 빅데이터 활용 빅데이터는 여러 가지 영역에서 활용되고 있습니다. 기업, 정부, 개인이 어떻게 빅데이터를 활용하는지 알아보겠습니다. 기업 빅데이터를 활용해 소비자의 행동을 분석하고 시장 변동을 예측하여 비즈니스 모델을 혁신하거나 신사업을 발굴합니다. 페이스북 마우스 커서의 움직임을 수집하여 사용자 이용 환경 개선과 광고 효과의 극대화에 활용 아마존 사용자의 개인 정보, 구매 내역 등을 활용하여 자동 도서 추천 구매내역, 장바구니 내역 등을 활용하여 물품의 구매를 예측하여 물류 예측 배송 서비스 정부 기상, 인구이동, 각종 통계 정보를 수집하여 사회 변화를 추정하거나, 환경 탐색, 주변국의 상황을 분석하여 장기적인 관점의 대응책을 분석합니다. 올빼미 버스 서울시와 KT가 협력하여 심야시간 유동인구를 분석하여 심야 시간 전용 버스의 배차 서비스 시작 개인 개인의 목적에 따라 활용합니다. 미국 대통령선거 버락 오바마 대통령이 빅데이터를 활용하여<NAME>자 개인에게 맞춤형 공약 정보 제공 1-데이터의 형태 수집 형태 데이터는 수집 형태에 따라 정형, 반 정형, 비정형으로 구분됩니다. 빅데이터는 정형 데이터보다는 비정형, 반 정형의 데이터가 더 많이 수집됩니다. 수집된 데이터를 다양한 도구를 이용하여 정형 형태로 변형하고 분석에 이용하는 경우가 많습니다. 정형 데이터베이스, CSV, 엑셀과 같이 칼럼 단위의 명확한 구분자와 형태가 존재하는 데이터 반 정형 XML, HTML, JSON 형태와 같이 여러 가지 형태가 있을 수 있지만, 메타데이터나 스키마가 존재하는 데이터 비정형 동영상, SNS 메시지, 사진, 오디오, 음성 데이터처럼 형태가 존재하지 않는 데이터 수집 시간 데이터는 수집과 처리하는 시간에 따라 배치 데이터, 실시간 데이터로 구분할 수 있습니다. 배치 시, 일, 주, 월 단위로 일정한 주기로 수집, 처리되는 데이터 실시간 실시간 검색어, 실시간 차트처럼 사용자의 입력과 동시에 처리되는 데이터 2-분석 형태 빅데이터 분석 형태로 구분할 수 있습니다. 대화형 분석 사용자가 입력한 쿼리에 바로 반응하여 결과를 반환하는 분석 방법 대화형 대시보드 배치 분석 저장된 데이터를 일정한 주기로 분석하는 방법 일/주/월간 보고서 실시간 분석 사용자의 여러 입력이 실시간으로 저장되고 분석하는 방법 결제/사기 경고 1분 측정 기계 학습 기계 학습 알고리즘을 이용해 예측 모델을 생성하는 방법 심리 분석, 예측 모델 2-빅데이터 처리단계 빅데이터는 다음의 5단계로 처리됩니다. 수집 데이터를 수집하는 단계 정형, 비정형, 반 정형 데이터 수집 정제 수집한 데이터를 적재하기 위해 필요 없는 데이터, 깨진 데이터를 정리하는 단계 반 정형, 비정형 데이터는 분석에 필요한 데이터 외에 필요 없는 부분을 제거하는 단계가 필요함 적재 정제된 데이터를 분석하기 위해 적재하는 단계 RDB, NoSQL 데이터베이스, Redshift, Druid 등의 도구에 적재 분석 적재한 데이터를 의미 있는 지표로 분석하는 단계 의사 결정권자나 이용자가 사용할 수 있는 데이터로 분석하는 단계 시각화 분석한 데이터를 도표로 보여주는 단계 데이터를 이해하기 쉬운 차트로 분석하는 단계 1-수집 빅데이터는 내부/외부의 여러 원천에서 데이터를 수집합니다. 따라서 다양한<NAME>의 데이터를 수집하게 됩니다. 내부/외부 데이터 내부 데이터 시스템 로그, DB 데이터 외부 데이터 동영상, 오디오 정보 웹 크롤링 데이터 SNS 데이터 수집 방식 기존 데이터 수집 HTTP 웹서비스, RDB, FTP, JMS, Text 새로운 방식의 데이터 수집 SNS의 여러 가지 데이터 Text, 이미지,<NAME>상 전화 음성, GPS IoT 디바이스 센서 공간 데이터 + 인구 데이터 데이터 수집 트랜잭션 데이터를 수집할 때 연동하는 데이터가 적다면 개별적으로 관리가 가능하지만 수백, 수천 개가 되면 트랜잭션 관리가 어려울 수 있습니다. 데이터의 유실, 데이터의 전송 여부 확인을 위한 트랜잭션 처리가 중요합니다. 데이터 수집 기술 Flume 플룸은 많은 양의 로그 데이터를 효율적으로 수집, 취합, 이동하기 위한 분산형 소프트웨어 Kafka 오픈 소스 메시지 브로커 프로젝트 Sqoop 관계형 데이터 베이스와 아파치 하둡 간의 대용량 데이터들을 효율적으로 변환하여 주는 명령 줄 인터페이스 애플리케이션 Nifi 소프트웨어 시스템 간 데이터 흐름을 자동화하도록 설계된 소프트웨어 프로젝트 Flink 오픈 소스 스트림 처리 프레임 워크 Splunk 기계가 생성한 빅 데이터를, 웹 스타일 인터페이스를 통해 검색, 모니터링, 분석하는 소프트웨어 Logstash 실시간 파이프라인 기능을 가진 오픈소스 데이터 수집 엔진 Fluentd 크로스 플랫폼 오픈 소스 데이터 수집 소프트웨어 프로젝트 2-정제 정제 단계는 데이터를 분석 가능한 형태로 정리하는 것입니다. 여러 경로에서 수집된 데이터가<NAME>이 다르기 때문에 분석 단계에 사용할 도구에 맞는 형태로 변환합니다. 데이터를 변환할 때 오류 데이터, 불필요한 데이터를 제거합니다. 정제한 데이터는 압축하여 데이터 사이즈를 줄여줍니다. 정제 단계 Identification 알려진 다양한 데이터 포맷이나 비정형 데이터에 할당된 기본 포맷을 식별 Filtration 수집된 정보에서 정확하지 않은 데이터는 제외 Validation 데이터<NAME>을 검증 Noise Reduction 오류 데이터를 제거 분석 불가능한 데이터는 제외 Transformation 데이터를 분석 가능한 형태로 변환 Compression 저장 장치 효율성을 위해 변환한 데이터를 압축 Integration 처리 완료한 데이터를 적재 3-적재 적재 단계는 대량의 데이터를 안전하게 보관하고 분석할 수 있는 환경으로 옮기는 것입니다. 분석에 사용할 도구에 따라 NoSQL, RDB, 클라우드 스토리지, HDFS 등 다양한 환경으로 데이터를 적재합니다. RDB에서 추출한 데이터나, CSV 형태로 제공되는 데이터는 별도의 정제 단계 없이 바로 적재할 수 있습니다. 4-분석 분석 단계는 적재된 데이터를 이용하여 의사 결정을 위한 데이터를 제공하기 위한 리포트를 생성하는 단계입니다. 대용량의 데이터를 빠르게 분석하기 위한 처리 엔진이 필요하고, 효율적으로 분석하기 위해서 파티셔닝, 인덱싱 등의 기술이 필요합니다. 실시간 분석, 배치 분석(일, 주, 월단위)을 이용해 리포트를 생성합니다. 5-시각화 최종적으로 시각화 단계입니다. 너무 많은 데이터는 정보 과잉으로 사용자가 확인하기에 부담이 될 수 있기 때문에 사용자가 빠르게 인식할 수 있는 형태의 시각화가 필요합니다. 3-빅데이터 에코시스템 빅데이터는 수집, 정제, 적재, 분석, 시각화의 여러 단계를 거칩니다. 이 단계를 거치는 동안 여러 가지 기술을 이용하여 처리되고, 이 기술들을 통틀어 빅데이터 에코 시스템(Bigdata Eco System)이라고 합니다. 수집 기술 플룸(Flume) 카프카(Kafka) NiFi Sqoop scribe Fluentd 작업 관리 기술 Airflow Azkaban Oozie 데이터 직렬화 Avro Thrift Protocol Buffers 저장 HDFS S3 NoSQL HBase 데이터 처리 MapReduce Spark Impala Presto Hive Hcatalog Pig 클러스터 관리 YARN Mesos 분산 서버 관리 Zookeeper 시각화 Zeppelin Hue 보안 Ranger 데이터 거버넌스 Atlas Amundsen 수집 기술 수집 기술은 빅데이터 분석을 위한 원천 데이터를 수집하는 기술입니다. 원천 데이터는 실시간 데이터 수집 기술, 배치 데이터 수집 기술이 있습니다. 원천 데이터의 종류에도 로그 데이터, DB 데이터, API 호출 데이터 등 여러 가지 종류가 있습니다. 플룸(Flume) 플룸은 클라우데라에서 개발한 서버 로그 수집 도구입니다. 각 서버에 에이전트가 설치되고, 에이전트로부터 데이터를 전달받는 컬렉터로 구성됩니다. Apache Flume(https://flume.apache.org/) 오픈소스 작명 센스: 아파치 플룸(Apache Flume)(바로 가기) 플룸 Wiki 바로 가기 카프카(Kafka) 카프카는 링크드 인에서 개발한 분산 메시징 시스템입니다. 대용량 실시간 로그 처리에 특화되어 있습니다. 발행(publish) - 구독(subscribe) 모델로 구성됩니다. Kafka([http://kafka.apache.org]) 카프카 소개 및 아키텍처 정리(바로 가기) Streaming Platform으로써의 Apache Kafka 바로 가기 카프카 Wiki 바로 가기 NiFi 미국 국가 안보국(NSA)에서 개발한 시스템 간 데이터 전달을 효율적으로 처리, 관리, 모니터링하기 위한 최적의 시스템입니다. Nifi(https://nifi.apache.org) 나이 파이 Wiki 바로 가기 NSA의 Dataflow 엔진 Apache NiFi 소개와 설치 바로 가기 Flume, Kafka, Nifi 바로 가기 Sqoop RDBMS와 HDFS 간 대용량 데이터 전송을 위한 설루션입니다. HDFS, RDBMS, DW, NoSQL 등 다양한 저장소에 대용량 데이터를 신속하게 전송할 수 있는 방법을 제공합니다. 상용 RDBMS도 지원하고, MySQL, PostgreSQL 오픈소스 RDBMS도 지원합니다. Sqoop(http://sqoop.apache.org/) 스쿱 Wiki 바로 가기 scribe 스크리브는 페이스북에서 제작한 로그 수집 시스템입니다. 메시지 큐에 쌓인 로그를 DB나 메시지 큐로 전달합니다. C++로 제작되어 속도가 빠르고, 페이스북의 대용량 데이터 처리에 사용되었을 정도로 안정성을 가지고 있습니다. 현재는 페이스북이 Calligraphus를 사용하여 2014년 이후 개선사항이 없습니다. Scribe(scribe github) Fluentd 트레저 데이터에서 개발한 로그 수집 시스템입니다. 주로 루비와 C로 작성되었습니다. 여러 형태의 로그를 전달받아서 원하는 저장소에 쌓을 수 있습니다. 비정형, 반 정형 데이터를 필터링, 버퍼링 하여 사용자가 지정하는 데이터베이스나 클라우드 저장소에 효율적으로 저장할 수 있습니다. 기본적인 구조는 Flume NG와 비슷합니다. Flume의 Source, Channel, Sink가 Input, Buffer, Output으로 대체되었습니다. 장점은 각 파트 별로 플러그인을 만들기 쉽습니다. Fluentd Fluentd github 작업 관리 기술 작업 관리 기술은 빅데이터를 분석하는 여러 가지 단계를 효율적으로 생성, 관리하고 모니터링할 수 있게 도와주는 기술입니다. Airflow 에어플로는 에어비앤비에서 개발한 데이터 흐름의 시각화, 스케쥴링, 모니터링이 가능한 워크플로 플랫폼입니다. 하이브, 프레스토, DBMS 엔진과 결합하여 사용할 수 있습니다. Airflow(http://nerds.airbnb.com/airflow) Apache Airflow - Workflow 관리 도구 바로 가기 데이터 워크플로 관리를 위한 Apache Airflow #1바로 가기 Azkaban 아즈카반은 링크드 인에서 개발한 워크플로 스케줄러, 시각화된 절차, 인증 및 권한 관리, 작업 모니터링 및 알람 등 다양한 기능을 가지는 워크플로 관리 도구입니다. Azkaban(https://azkaban.github.io) Azkaban - Hadoop Workflow Management System(Opensource by LinkedIn) 바로 가기 Oozie 우지는 하둡 작업을 관리하는 워크플로 및 코디네이터 시스템입니다. 자바 웹 애플리케이션 서버로 UI 제공하고, 맵리듀스, hive, pig 작업 같은 특화된 액션으로 구성된 XML 포맷의 워크플로우로 작업을 제어합니다. https://oozie.apache.org/ Oozie Wiki 바로 가기 Airflow vs Azkaban vs Oozie 바로 가기 데이터 직렬화 빅데이터 에코 시스템이 다양한 기술과 언어로 구현되기 때문에 각 언어 간에 내부 객체를 공유해야 하는 경우가 있습니다. 이를 효율적으로 처리하기 위해서 데이터 직렬화 기술을 이용합니다. Avro 에이브로(Avro)는 아파치의 하둡 프로젝트에서 개발된 원격 프러시저 호출(RPC) 및 데이터 직렬화 프레임워크입니다. 자료형과 프로토콜 정의를 위해 JSON을 사용하며 콤팩트 바이너리 포맷으로 데이터를 직렬화합니다. https://avro.apache.org/ Avro Wiki 바로 가기 Thrift 스 리프트는 페이스북에서 개발한 서로 다른 언어로 개발된 모듈의 통합을 지원하는 RPC 프레임워크입니다. 데이터 타입과 서비스 인터페이스를 선언하면, RPC 형태의 클라이언트와 서버 코드를 자동으로 생성해 줍니다. 자바, C++, C#, Perl, PHP, 파이썬, 델파이, Erlang, Go, Node.js 등과 같이 다양한 언어를 지원합니다. Thrift(http://thrift.apache.org) 스 리프트 Wiki 바로 가기 RPC - Apache Thrift 입문 1부 바로 가기 Protocol Buffers //polyline.proto syntax = "proto2"; message Point { required int32 x = 1; required int32 y = 2; optional string label = 3; } 프로토콜 버퍼(Protocol Buffers)는 구글에서 개발한 RPC 프레임워크입니다. 구조화된 데이터를 직렬화하는 방식을 제공합니다. C++, C#, Go, Java, Python, Object C, Javascript, Ruby 등 다양한 언어를 지원하며 특히 직렬화 속도가 빠르고 직렬화된 파일의 크기도 작아서 Apache Avro 파일 포맷과 함께 많이 사용됩니다. Protocol Buffers(https://developers.google.com/protocol-buffers/) 구글 프로토콜 버퍼(바로 가기) 저장 빅데이터는 대용량의 데이터를 저장하기 때문에 데이터의 저장의 안정성과 속도가 중요합니다. HDFS 외에도 아마존 AWS의 S3, MS Azure의 Data Lake, Blob Storage, Google의 Cloud Storage가 있습니다. HDFS 하둡 분산 파일 시스템(HDFS, Hadoop distributed file system)은 하둡 프레임워크를 위해 자바 언어로 작성된 분산 확장 파일 시스템입니다. HDFS는 범용 컴퓨터를 클러스터로 구성하여 대용량의 파일을 블록 단위로 분할하여 여러 서버에 복제하여 저장합니다. HDFS Wiki 바로 가기 S3 S3는 아마존에서 제공하는 인터넷용 저장소입니다. 아마존에서 자체적으로 제공하는 여러 가지 서비스에 잘 적용되는 저장소입니다. 아마존 S3(바로 가기) NoSQL HBase hbase(main):003:0> describe 'test' Table test is ENABLED test COLUMN FAMILIES DESCRIPTION {NAME => 'cf', VERSIONS => '1', EVICT_BLOCKS_ON_CLOSE => 'false', NEW_VERSION_BEHAVIOR => 'false', KEEP_DELETED_CELLS => 'FALSE', CACHE_DATA_ON_WRITE => 'false', DATA_BLOCK_ENCODING => 'NONE', TTL => 'FOREVER', MIN_VERSIONS => '0', REPLICATION_SCOPE => '0', BLOOMFILTER => 'ROW', CACHE_INDEX_ON_WRITE => 'f alse', IN_MEMORY => 'false', CACHE_BLOOMS_ON_WRITE => 'false', PREFETCH_BLOCKS_ON_OPEN => 'false', COMPRESSION => 'NONE', BLOCKCACHE => 'true', BLOCKSIZE => '65536'} 1 row(s) Took 0.9998 seconds HBase는 HDFS 기반의 칼럼 기반 NoSQL 데이터베이스입니다. 구글의 빅테이블(BigTable) 논문을 기반으로 개발됐습니다. 실시간 랜덤 조회 및 업데이트가 가능하며, 각 프로세스는 개인의 데이터를 비동기적으로 업데이트할 수 있습니다. HBase의 기본 동작 단위는 칼럼입니다. H 마스터가 H 리전을 관리하는 구조를 가지고 있습니다. 주키퍼가 H 마스터를 관리하여 SPOF를 회피합니다. HBase(http://hbase.apache.org) HBase Wiki 바로 가기 HBase의 이해 HBase An In-Depth Look at the HBase Architecture 데이터 처리 데이터 처리는 빅데이터를 분석하는 기술입니다. 하둡의 맵리듀스를 기반으로, 스파크, 하이브, HBase, 임팔라 등 여러 가지 기술이 있습니다. MapReduce 맵리듀스는 HDFS 상에서 동작하는 가장 기본적인 분석 기술입니다. 간단한 단위작업을 반복할 때 효율적인 맵리듀스 모델을 이용하여 데이터를 분석합니다. Spark 스파크(Spark)는 인 메모리 기반의 범용 데이터 처리 플랫폼입니다. 배치 처리, 머신러닝, SQL 질의 처리, 스트리밍 데이터 처리, 그래프 라이브러리 처리와 같은 다양한 작업을 수용할 수 있도록 설계되어 있습니다. 2009년 버클리 대학의 AMPLab에서 시작됐으며, 현재 가장 빠르게 성장하고 있는 오픈소스 프로젝트 중의 하나입니다. Spark(http://spark.apache.org) 스파크 Wiki 바로 가기 스파크 소개 및 실습 바로 가기 Impala 임팔라(Impala)는 클라우데라에서 개발한 하둡 기반의 분산 쿼리 엔진입니다. 맵리듀스를 사용하지 않고, C++로 개발한 인 메모리 엔진을 사용해 빠른 성능을 보여줍니다. 임팔라는 데이터 조회를 위한 인터페이스로 HiveQL을 사용하며, 수초 내에 SQL 질의 결과를 확인할 수 있습니다. 2015년 말 아파치 재단의 인큐베이션 프로젝트로 채택됐습니다. Impala(http://impala.io) 임팔라 Wiki 바로 가기 Hadoop에서의 실시간 SQL 질의: Impala 바로 가기 Presto 프레스토(Presto)는 페이스북이 개발한 대화형 질의를 처리하기 위한 분산 쿼리 엔진입니다. 메모리 기반으로 데이터를 처리하며, 다양한 데이터 저장소에 저장된 데이터를 SQL로 처리할 수 있습니다. 특정 질의 경우 하이브 대비 10배 정도 빠른 성능을 보여주며, 현재 오픈소스로 개발이 진행되고 있습니다. Presto(https://prestodb.io) 프레스토 소개 바로 가기 Hive hive> SELECT col1, col2 FROM t1 1 3 1 3 1 4 2 5 하이브(Hive)는 하둡 기반의 데이터웨어하우징용 설루션입니다. 페이스북에서 개발했으며, 오픈소스로 공개되며 주목받은 기술입니다. SQL과 매우 유사한 HiveQL이라는 쿼리 언어를 제공합니다. 그래서 자바를 모르는 데이터 분석가들도 쉽게 하둡 데이터를 분석할 수 있게 도와줍니다. HiveQL은 내부적으로 맵리듀스 잡으러 변환되어 실행됩니다. Hive(http://hive.apache.org) 하이브 Wiki 바로 가기 Hcatalog HCatalog는 Pig, MapReduce, Spark에서 Hive 메타 스토어 테이블에 액세스할 수 있는 도구입니다. 테이블을 생성하거나 기타 작업을 수행할 수 있는 REST 인터페이스 및 명령 줄 클라이언트를 제공합니다. HCatalog(https://cwiki.apache.org/confluence/display/Hive/HCatalog) Pig A = LOAD 'student' USING PigStorage() AS (name:chararray, age:int, gpa:float); B = FOREACH A GENERATE name; DUMP B; (John) (Mary) 피그(Pig)는 야후에서 개발됐으나 현재는 아파치 프로젝트에 속한 프로젝트로서, 복잡한 맵리듀스 프로그래밍을 대체할 피그 라틴(Pig Latin)이라는 자체 언어를 제공합니다. 맵리듀스 API를 매우 단순화한 형태이고 SQL과 유사한 형태로 설계됐습니다. SQL과 유사하기만 할 뿐, 기존 SQL 지식을 활용하기가 어려운 편입니다. 피그 Wiki 바로 가기 Pig(http://pig.apache.org) 클러스터 관리 빅데이터는 단일 시스템이보다는 보통 클러스터로 처리되기 때문에 자원의 효율적인 사용이 필요합니다. 클러스터의 관리를 위한 여러 가지 기술이 있습니다. YARN 얀(YARN)은 데이터 처리 작업을 실행하기 위한 클러스터 자원(CPU, 메모리, 디스크 등)과 스케쥴링을 위한 프레임워크입니다. 기존 하둡의 데이터 처리 프레임워크인 맵리듀스의 단점을 극복하기 위해서 시작된 프로젝트이며, 하둡 2.0부터 이용이 가능합니다. 맵리듀스, 하이브, 임팔라, 타조, 스파크 등 다양한 애플리케이션들은 얀에서 리소스를 할당받아서, 작업을 실행하게 됩니다. YARN(http://hadoop.apache.org) http://hadoop.apache.org/docs/stable/hadoop-yarn/hadoop-yarn-site/index.html Mesos 메소 스(Mesos)는 클라우드 인프라스트럭처 및 컴퓨팅 엔진의 다양한 자원(CPU, 메모리, 디스크)을 통합적으로 관리할 수 있도록 만든 자원 관리 프로젝트입니다. 메소스는 2009년 버클리 대학에서 Nexus라는 이름으로 시작된 프로젝트이며, 2011년 메소스라는 이름으로 변경됐으며, 현재는 아파치 탑 레벨 프로젝트로 진행 중이며, 페이스북, 에어비엔비, 트위터, 이베이 등 다양한 글로벌 기업들이 메소스로 클러스터 자원을 관리하고 있습니다. 메소스는 클러스터링 환경에서 동적으로 자원을 할당하고 격리해 주는 메커니즘을 제공하며, 이를 통해 분산 환경에서 작업 실행을 최적화시킬 수 있습니다. 1만 대 이상의 노드에도 대응이 가능하며, 웹 기반의 UI, 자바, C++, 파이썬 API를 제공합니다. 하둡, 스파크(Spark), 스톰(Storm), 일래스틱 서치(Elastic Search), 카산드라(Cassandra), 젠킨스(Jenkins) 등 다양한 애플리케이션을 메소스에서 실행할 수 있습니다. 메조스 Wiki 바로 가기 Apache Mesos 소개 바로 가기 Mesos(http://mesos.apache.org) 분산 서버 관리 클러스터에서 여러 가지 기술이 이용될 때 하나의 서버에서 모든 작업이 진행되면 이 서버가 단일 실패 지점(SPOF)가 됩니다. 이로 인한 리스크를 줄이기 위해 분산 서버 관리 기술을 이용합니다. Zookeeper 분산 환경에서 서버 간의 상호 조정이 필요한 다양한 서비스를 제공하는 시스템으로, 크게 다음과 같은 네 가지 역할을 수행합니다. 첫째, 하나의 서버에만 서비스가 집중되지 않게 서비스를 알맞게 분산해 동시에 처리하게 해줍니다. 둘째, 하나의 서버에서 처리한 결과를 다른 서버와도 동기화해서 데이터의 안정성을 보장합니다. 셋째, 운영(active) 서버에 문제가 발생해서 서비스를 제공할 수 없을 경우, 다른 대기 중인 서버를 운영 서버로 바꿔서 서비스가 중지 없이 제공되게 합니다. 넷째, 분산 환경을 구성하는 서버의 환경설정을 통합적으로 관리합니다. 예를 들면 HA(High Availability) 구성된 HDFS 네임노드의 Active 노드 선출, HBase 리 전 서버의 Active 서버 선출, Hiveserver2의 다중 선택 등을 지원합니다. Zookeeper(http://zookeeper.apache.org) 주키퍼 Wiki 바로 가기 시각화 Zeppelin Zeppelin은 한국의 NFLab이라는 회사에서 개발하여 Apache top level 프로젝트로 최근 승인받은 오픈소스 설루션으로, Notebook이라고 하는 웹 기반 Workspace에 Spark, Tajo, Hive, ElasticSearch 등 다양한 설루션의 API, Query 등을 실행하고 결과를 웹에 나타내는 설루션입니다. http://zeppelin.apache.org/ 아파치 제플린 소개 바로 가기 오픈소스 일기 2: Apache Zeppelin 이란 무엇인가? Hue 하둡 휴(Hue, Hadoop User Experience)는 하둡과 하둡 에코 시스템의 지원을 위한 웹 인터페이스를 제공하는 오픈 소스입니다. Hive 쿼리를 실행하는 인터페이스를 제공하고, 시각화를 위한 도구를 제공합니다. 잡의 스케줄링을 위한 인터페이스와 잡, HDFS, 등 하둡을 모니터링하기 위한 인터페이스도 제공합니다. https://github.com/cloudera/hue 보안 Ranger 레인저는 하둡 클러스터의 각 모듈에 대한 보안 정책을 관리할 수 있습니다. HDFS의 ACL, Hive 데이터베이스의 접근 권한 등의 보안 정책과 각 모듈에 대한 접근 기록(Audit)을 보관합니다. https://ranger.apache.org/ 데이터 거버넌스 데이터 거버넌스는 기업의 여기저기 산재한 데이터를 같은 저장소에 관리, 비정형 데이터를 규칙에 맞게 표준화하는 전사 차원의 빅데이터 관리 체계입니다. Atlas 아틀라스는 데이터 거버넌스로 조직이 보안/컴플라이언스 요구사항을 준수할 수 있도록 지원합니다. 데이터 자원에 대한 태깅, 다운스트림 데이터 셋에 대한 태그 전파, 메타 데이터 접근에 대한 보안등 다양한 기능을 가지고 있습니다. 메타데이터 변경 알림 기능을 제공하고, Hive, HBase, Kafka의 데이터가 변경되는 것을 알리는 기능을 제공합니다. Atlas Amundsen 아문센은 데이터 디스커버리 플랫폼입니다. 기업에 존재하는 데이터를 검색하고, 추천하는 기능을 가지고 있습니다. 검색, 추천, 미리 보기/칼럼 통계/소유자/주 사용자들이 잘 표현된 테이블 상세 페이지를 지원합니다. Amundsen 1-Flume 클라우데라에서 대량의 로그 데이터를 여러 소스에서 수집하여 저장하기 위한 목적으로 개발하여 오픈 소스로 공개한 데이터 수집 프레임워크입니다. 현재는 아파치 탑 레벨 오픈 소스로 Flume 1.1.0부터 구조가 변경되어 Flume-OG와 Flume-NG(New Generation)로 구분됩니다. 2020.04 현재 1.9.0 버전이 최신 버전입니다. 특징 여러 개의 플룸 에이전트를 연결하여 확장 가능 다양한 연결 모드를 지원하여 최종 목적지에 데이터를 전달할 때까지 유연한 구성이 가능 전달받은 데이터를 메모리, File, DB에 임시 저장하여 오류 발생 시 복구 가능하게 설정하여 신뢰성 있음 Flume 구조: OG vs NG OG는 master가 agent를 관리 데이터가 집중되면 master의 병목현상이 발생함 Flume OG Flume NG 용어 Event Flume에서 전달하는 데이터 단위 헤더와 보디로 구성 헤더: 설정값. 딕셔너리 형태 보디: 전달할 데이터 # 정보 예시 2019-07-18 05:19:41,401 (SinkRunner-PollingRunner-DefaultSinkProcessor) [INFO - org.apache.flume.sink.LoggerSink.process(LoggerSink.java:95)] Event: { headers:{file=/temp.file} body: 31 32 33 31 32 33 0D 123123. } Agent 에이전트는 소스, 채널, 싱크로 구성된 데이터 수집을 위한 JVM 프로세스 소스로 입력된 메시지를 채널에 저장하고, 저장된 메시지 묶음을 싱크로 전달 소스(Source) 웹 서버 같은 외부 소스에 의해 전달되는 이벤트를 수집 외부 소스는 Flume이 인식하는 형태로 이벤트를 전달 Avro, Thrift, File Http 소스 등이 있음 채널(Channel) 소스가 이벤트를 수신하면 채널에 임시 저장 채널은 싱크가 이벤트를 다른 목적지로 전달할 때까지 파일이나 메모리 등에 이벤트를 보관 메모리, File, Kafka, DB 채널 등이 있음 싱크(Sink) 채널에 저장된 이벤트를 외부 저장소, 다른 플룸 에이전트로 전달 소스와 싱크는 비동기적으로 진행 HDFS, Hive, Thrift, Avro 싱크가 있음 채널 실렉터(Channel Selector) 하나의 소스에 다수의 채널이 연결되었을 때 이벤트를 전달하는 기준으로 복제(replicating), 멀티플렉싱(multiplexing)이 있음 복제: 모든 채널에 동일한 이벤트를 전달. 기본 설정 멀티플렉싱: 헤더 정보를 이용해 분기 싱크 프로세서(Sink Processors) 채널에 연결된 싱크를 그룹으로 묶어서 사용 기본 설정은 한 개의 싱크를 사용하고, Failover 모드 시 우선순위가 높은 모드부터 사용하다가 오류가 발생하면 다음 순위의 싱크를 사용 인터셉터(Interceptor) 소스로 들어온 이벤트의 헤더를 수정하거나, 내용을 추가할 때 사용 시간 추가(TimeStamp Interceptor)나, 수집 서버(Host Interceptor) 정보를 추가할 때 사용 연결 모드 multi-agent flow 에이전트의 싱크와 소스를 연결하여, 다수의 에이전트를 링크드 리스트처럼 연결 Consolidation 하나의 에이전트가 여러 에이전트에서 수집한 데이터를 받아서 처리 Multiplexing the flow 하나의 에이전트에서 여러 개의 채널로 이벤트를 전달 실행 예제 netcat 소스, 메모리 채널, 로그 싱크를 이용하여 http로 전달된 로그를 출력하는 예제를 알아보겠습니다. flume 다운로드 및 압축 해제 # flume download wget http://apache.mirror.cdnetworks.com/flume/1.9.0/apache-flume-1.9.0-bin.tar.gz # 압축 해제 tar -zxvf apache-flume-1.9.0-bin.tar.gz configuration 파일 수정 # 설정 파일 수정 vi conf/example.conf # a1 에이전트 선언. 소스:r1, 싱크:k1, 채널:c1 a1.sources = r1 a1.sinks = k1 a1.channels = c1 # 소스 설정. 44444 포트에 netcat으로 읽음 a1.sources.r1.type = netcat a1.sources.r1.bind = localhost a1.sources.r1.port = 44444 # 싱크 설정. 로그를 남기는 타입. 디버그용 a1.sinks.k1.type = logger # 채널 설정. 메모리 타입 a1.channels.c1.type = memory a1.channels.c1.capacity = 1000 a1.channels.c1.transactionCapacity = 100 # 에이전트의 소스, 채널, 싱크를 연결 a1.sources.r1.channels = c1 a1.sinks.k1.channel = c1 실행 ./bin/flume-ng agent --conf conf --conf-file ./conf/example.conf --name a1 -Dflume.root.logger=INFO, console telnet localhost 44444 2-Kafka Kafka는 LinkedIn에서 개발한 분산 스트리밍 플랫폼입니다. 메시징, 메트릭 수집, 로그 수집, 스트림 처리 등 다양한 용도로 사용할 수 있습니다. 2020년 5월 기준 2.5.0 버전이 최신 버전입니다. 특징 빠르다: Fast 수 천 개의 데이터 소스로부터 초당 수백 메가 바이트의 데이터를 입력받아도 안정적으로 처리 가능 확장 가능: Scalable 메시지를 파티션으로 분리햐여 분산 저장, 처리할 수 있어 클러스터로 구성하여 확장 가능 안정적이다: Durable 클러스터에 파티션 복제하여 장애 내구성을 가짐 발행/구독(Pub/Sub) 모델 Kafka는 발행-구독(Pub/Sub) 모델을 기반으로 동작합니다. 발행-구독 모델은 발행자(Producer)가 메시지를 특정 수신자에게 직접 보내는 방식이 아니라 주제(topic)에 맞게 브로커에게 전달하면 구독자(Consumer)가 브로커에 요청해서 가져가는 방식입니다. 발행자는 메시지를 topic으로 카테고리화 구독자는 topic에 맞는 메시지를 브로커에게 요청 발행자와 구독자는 서로 알지 못함 카프카의 주요 구성 Topic, Partiton Producer, Consumer Broker, Zookeepr Consumer Group Replication Topic-Partition Topic 메시지는 topic으로 분류 topic은 발행자가 스트림을 발행하는 단위 스트림의 발행과 구독은 topic 단위로 처리 Partition 하나의 topic은 여러 개의 파티션으로 저장할 수 있음 1개의 토픽은 여러 개의 파티션으로 저장되고, 하나의 파티션은 여러 개의 로그로 기록 1:N = Topic:Partition, 1:N = Partition:Log 하나의 토픽을 여러 파티션으로 나누면 메시지 분산 처리로 처리량을 높일 수 있고, 분산 저장을 통해 오류가 발생할 때 데이터를 복구할 수 있음 파티션의 크기는 운영 중에 동적으로 줄일 수 없기 때문에 파티션 개수를 설정할 때 주의해야 함 파티션에서 메시지의 상대적인 위치를 오프셋(offset)이라 하고, 구독자는 현재까지 읽은 오프셋을 이용하여 데이터를 요청 파티션은 여러 개의 복제본으로 나누어서 저장됨 파티션 replica 설정에 따라 동일한 데이터를 복제하여 저장 데이터에 문제가 발생하면 복제된 데이터로 복구 파티션의 데이터 저장은 기본적으로 라운드 로빈 방식으로 동작 3개의 파티션이 있으면 P0, P1, P2에 순차적으로 저장 파티션 분배 알고리즘을 설정하여 키를 기준으로 파티션 분류도 가능 P0은 A 키, P1은 B 키만 저장 Producer, Consumer 발행자(Producer) 메시지를 생산하는 주체 메시지를 만들고 브로커(Broker)에게 토픽(Topic)으로 분류된 메시지를 전달 메시지는 배치 형태로 전달 발행자는 구독자의 존재를 알지 못함 구독자(Consumer) 소비자로 메시지를 소비하는 주체 발행자의 존재를 알지 못함 원하는 토픽을 구독하여 스스로 조절해가면서 소비할 수 있음 원하는 토픽의 각 파티션에 존재하는 오프셋의 위치를 기억하고 관리하여 데이터의 중복을 관리 오프셋 관리를 통해 발행자, 구독자에 장애가 발생해도 마지막으로 읽었던 위치에서부터 다시 구독 가능 fail-over에 대한 신뢰가 존재 구독자 그룹(Consumer Group) 구독자들의 묶음으로 하나의 파티션에 하나의 구독자 그룹이 존재함 파티션은 구독자 그룹의 구독자와 1:N 매칭 파티션 4 : 구독자 4 = 파티션과 구독자가 1:1로 매칭 파티션 4 : 구독자 5 = 구독자 1개는 대기. 파티션 5 : 구독자 4 = 구독자 1개는 2개의 파티션을 소비 파티션을 늘릴 때는, 구독자의 개수도 고려해야 함 기본 설정은 파티션과 구독자의 수를 동일하게 설정 메시지가 파티션에 쌓이는 속도와 구독자가 처리하는 속도를 비교하여 적절한 개수 설정이 필요함 구독자 그룹에서 하나의 구독자에 장애가 발생하면 다른 구독자가 장애가 발생한 구독자의 파티션 데이터도 함께 처리하여 장애를 극복함 브로커(Kafka Cluster) 클러스터로 구성된 메시지 큐라고 할 수 있음 메시지는 클러스터에 파티션 단위로 나누어 관리/복제됨 파일 시스템에 메시지를 저장하므로 유실이 없고 복구 가능 하드디스크의 순차적 읽기 기능을 이용하여 속도를 유지 구독자가 메시지를 가져가도 바로 삭제하지 않음 기본 설정은 7일간 저장하고 삭제 예제 # 카프카 다운로드 $ wget http://apache.mirror.cdnetworks.com/kafka/2.3.0/kafka_2.12-2.3.0.tgz # 압축 해제 $ tar -xf kafka_2.12-2.3.0.tgz # 1. 주키퍼 실행 $ bin/zookeeper-server-start.sh config/zookeeper.properties # 2. kafka 서버 실행: 브로커: Broker $ bin/kafka-server-start.sh config/server.properties # 3. Topic 생성 $ bin/kafka-topics.sh --create --bootstrap-server localhost:9092 --replication-factor 1 --partitions 1 --topic test # 3-1. Topic 확인 $ bin/kafka-topics.sh --list --bootstrap-server localhost:9092 test # 4. 메시지 전송: 프로듀서: Producer $ bin/kafka-console-producer.sh --broker-list localhost:9092 --topic test >abcd >efgh # 5. 메시지 확인: 컨슈머: Consumer $ bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic test --from-beginning abcd efgh 참고 KAFKA에 대해서 알아보자 카카오는 각 서버가 시스템 적으로 묶여 있어서 장애가 발생하면 동시에 다운되어 카프카를 이용하여 커플링을 줄여줌. 파티션은 8~20개로 설정 Kafka 기본 개념 잡기 Kafka를 이용한 메시징 시스템 구성하기 MSA 아키텍처 구성할 때 Kafka를 이용하여 메시징 시스템을 구성하는 방법 Kafka 운영자가 말하는 처음 접하는 Kafka 파티션 순서에 따른 메시지 순서: 파티션의 개수가 여러 개 일 때 메시지는 파티션의 여러 위치에 저장되어 구독자가 메시지를 가져올 때 메시지의 발생 순서와 구독자가 받은 메시지의 순서가 꼭 일치하지는 않음 Kafka 운영자가 말하는 Kafka Consumer Group 구독자 그룹(Consumer Group): 장애 복구성을 가질 수 있고, 분산 처리를 통해 빠른 메시지 처리가 가능함 카프카 설치 시 가장 중요한 설정 4가지 log.retention.hours=72: 브로커에 로그 유지 시간. 데이터가 많아지면 복제에 의해 많은 용량이 필요할 수 있음. 적절한 시간 설정이 필요함. delete.topic.enable=true: 디스크 용량 확보를 위해 토픽을 삭제할 수 있도록 설정해야 함. 이 옵션을 설정하지 않으면 바로 삭제되지 않고, 삭제 플래그에 체크만 됨 allow.auto.create.topics=false: 선언하지 않은 토픽으로 메시지가 들어올 때 토픽을 자동으로 생성하지 않도록 설정. log.dirs=/data: 메시지가 저장되는 실제 경로를 정확하게 설정해야 함 LINE에서 Kafka를 사용하는 방법 - 1편 분산 큐잉 시스템과 데이터 허브로 이용 하나의 클러스터에 데이터를 집중하여 데이터 허브 콘셉트로 아키텍처를 단순하게 유지할 수 있고, 운영의 효율성을 얻을 수 있음 대량의 데이터를 처리하면서 높은 신뢰성을 확보 요청 수를 제어. 안정성 확보를 위해 데이터의 양보다 요청 수(request quota)를 제어하는 것이 중요함 브로커의 스레드 시간을 제어하여 하나의 토픽으로 메시지가 몰려도 다른 작업에 영향이 가지 않게 함 3-Sqoop Sqoop은 관계형 데이터베이스와 하둡 HDFS 간에 데이터를 전송할 수 있도록 설계된 오픈소스 소프트웨어입니다. 2009년 발표되었고, 2012년에 Apache Top Level Project로 지정 Sqoop 1, Sqoop 2의 두 가지 버전이 존재함 Sqoop 1은 클라이언트 방식 CLI 명령어로 작업을 실행 Sqoop 2는 클라이언트 방식에 서버사이드 방식이 추가됨 Sqoop 서버가 존재하고, 사용자가 서버에 요청하여 작업을 실행하는 방식 HDFS와 RDB 간 데이터 전송 RDBMS > HDFS or HDFS > RDBMS 이동 가능 Hive, Pig, Hbase로 이동 가능 예제 Sqoop의 동작은 import와 export가 있습니다. import는 DB의 데이터를 HDFS로 옮기는 방식이고, export는 HDFS의 데이터를 DB로 옮기는 것입니다. import: DB to HDFS sqoop import \ --connect jdbc:mysql://loclhost:7777/db? zeroDateTimeBehavior=convertToNull \ --user name scott \ --password tiger \ --query 'select * from sample_table WHERE $CONDITIONS' \ --target-dir hdfs://localhost/user/hadoop/ export: HDFS to DB sqoop export --connect jdbc:mysql://loclhost:7777/db?zeroDateTimeBehavior=convertToNull \ --user name scott \ --password tiger \ --table sample_table \ --export-dir hdfs://localhost/user/hadoop/ \ --columns column1, column2, column3 참고 SqoopUserGuide 4-빅데이터 시스템 유명 IT 회사에서 빅데이터 시스템을 구성하는 방법을 알아보겠습니다. 참고 카카ᄋ데이터 파이프라인터파이프라인 NDC 2018 - 야생의 땅 듀랑고의 데이터 엔지니어링 이야기: 로그 시스템 구축 경험 공유 NDC 2018 - SparkAirflow로ck, Airflow 로 구현하는 탄력적이고 유연한 데이터 분산처리 자동화 인프라 구축 1-빅데이터 시스템:멜론 수집 데이터베이스 데이터 스쿱을 이용하여 수집 로그 데이터 플룸을 이용하여 한 시간마다 쉘 스크립트(scp)로 수집 허드슨을 이용하여 배치 데이터를 수집 분석 실시간 분석과 배치 분석을 제공 Hive를 이용하여 분석 결과 제공 데이터의 종류에 따라 MR, Mahout, Tajo, Spark도 이용 SQL 기반의 분석 플랫폼을 유지하기 위해 노력함 서비스 온라인 서비스와 통계 시스템 제공 MySQL과 HBase, ElasticSearch를 이용하여 제공 멜론 준 실시간 수집 Flume을 이용한 준 실시간 수집 참고 멜론 빅데이터 이야기 MelOn 빅데이터 플랫폼과 Tajo 이야기 2-빅데이터 시스템:네이버 - DataProc 데이터 로그(DataLog) 일래스틱 서치 기반 2017년에 구축한 로그 통합 관리 플랫폼 검색 서비스의 모든 로그를 한곳에 모아 효율적인 분석을 위한 환경을 제공 초당 22만 건 실시간 색인이 가능 데이터 스토어(DataStore) HBase 기반 데이터 카탈로그를 통해 보관된 데이터의 목록, 상세정보, 생산자와 소비자를 한눈에 알 수 있도록 제공 저장된 데이터의 효율적인 활용을 위해 SQL 기반의 처리 시스템을 구축 비슷한 형태의 요청이 많으므로 SQL 템플릿을 제공하여 처리할 수 있도록 지원(Hue) 빠른 처리를 위해 가공 테이블을 제공. 자주 사용되는 데이터를 미리 테이블로 분리하여 적재 하이브의 ORC, 파티션, 버켓팅을 적극 활용 데이터 프록(DataProc) 보관된 데이터를 개발자가 마음껏 분석할 수 있는 환경을 제공 개발자가 자유롭게 컴퓨팅 자원을 이용할 수 있는 환경을 제공 참고 [네이버 어벤저스] 국내 최대 빅데이터, 이렇게 다룹니다 네이버 로그를 지탱하는 힘 3-빅데이터 시스템:카카오 광고 시스템 카카오 광고 시스템은 하루 59TB의 데이터를 처리 카카오는 데이터를 다각도로 분석하기 위해서 키린(Kylin)을 이용 키린은 데이터를 큐브 형태로 가공하여 보관하고 있기 때문에 사용자의 쿼리에 빠른 속도로 결과를 제공 데이터 수집 기술 카프카, 로그스태쉬 스파크 스트리밍, 플링크 데이터 처리 하이브, 임팔라 저장 HDFS, 카산드라, HBase, 일래스틱 서치, 레디스 시각화 태블루, 제플린, 카프카, 키린 운영 에어플로, 그라파나, 키바나, 프로메테우스 참고 카카오 if 2019 - 광고 데이터 처리 시스템 소개 4-빅데이터 시스템:쿠팡 쿠팡은 RDB를 이용한 초기부터 2019년까지 4단계를 거쳐서 빅데이터 처리 시스템을 완성하였습니다. 페이즈 1 관계형 데이터베이스를 이용한 처리 페이즈 2 온프리미스 하둡, 하이브, MPP 시스템 데이터 생산과 수요의 증가 고객의 행동을 기반으로 하는 데이터 분석 데이터의 증가로 인한 병목 현상 발생 온 프레미스 환경에서는 스케일 아웃이 쉽지 않음 아키텍처 데이터 소스의 구분 ServerLog, ClientLog, DBMS, External Data 하둡, MPP 시스템(아마도 그린플럼) 페이즈 3 클라우드 인프라로 이동 고객의 행동 기반 로그도 수집 EDW를 스타 스키마 기반으로 구축 아키텍처 데이터 수집은 그대로, 저장은 클라우드 저장 공간 에어플로 스케줄러 도입 빅데이터 공간과 EDW 공간으로 분리 사용자를 위한 휴, 태블루, 제플린, CLI, 내부 도구 등을 제공 페이즈 4 빅데이터 플랫폼 클러스터 라이프 사이클 스케일링 정책 머신 이미지 사전 빌드 웹 로깅 플랫폼 카프카를 이용한 플랫폼 구축 데이터 웨어하우스 하이브, 휴, 프레스트, 제플린을 이용한 환경 제공 참고 쿠팡 데이터 플랫폼의 진화 5-빅데이터 시스템:LINE 광고 데이터 파이프라인 BigDB LINE의 광고 데이터 파이프라인 BigDB에 대해서 알아보겠습니다. (기준. 2017.07) BigDB란? BigDB는 LINE 광고의 빅데이터 처리 파이프라인 데이터 수집, 가공, 재가공, 조회 등의 기능 제공 실시간 분석 LINE 광고의 분석 형태는 사용자가 광고에 노출이 되었을 경우 해당 이벤트를 받아서 즉시 처리 배치 분석 이벤트를 받아서 1시간이나 1일, 등록한 시간마다 처리 유연한 데이터 제공 기능 BigDB는 분석을 위해 데이터를 제공 시계열 데이터와 정적인 데이터를 Join 하여 제공 특징 REST CLI(Command Line Interface) 기능을 제공 스트리밍 데이터와 정적인 데이터를 hiveContext Table로 생성하는 흐름을 제어 사용자 요청의 데이터<NAME>을 지정하여 데이터를 조회하는 기능 데이터 읽기, 쓰기를 위한 멀티세션을 지원 사용자 요청의 데이터를 Spark SQL 기반으로 실시간 데이터 Join 기능 제공 저장소를 크게 두 개로 구분 사용자 요청의 가공 데이터를 스케일에 맞는 저장소를 지정하여 가용성을 확보할 수 있는 구조를 제공 구조 설루션 구조 다양한 오픈소스를 활용 통합된 툴은 사용하지 않는 별도의 설루션을 포함하고, 이 설루션이 노드의 자원을 사용하는 문제가 있음 다양한 오픈소스를 활용하게 되면 의존성 문제가 발생할 수 있음 최대한 변경은 없게 하고, 설루션 간의 흐름에 대한 컨트롤 열할을 BigDB Core와 API로 개발 Message Proxy: akka.http를 사용하여 JSON 데이터를 수집하고, Kafka의 정해진 Topic에 produce 합니다. Kafka: 수집된 JSON 데이터를 7일간 보관하며, Partition은 스트리밍에서 사용하는 코어의 개수에 따라 변경됩니다. Streaming: Spark을 사용하며, 5초 주기로 Task를 수행하고 간단한 데이터의 변환 작업 후 스키마에서 지정한 Table에 Data Frame을 InsertInto로 추가하게 됩니다. Streaming이 두 개로 나누어져 있고, 왼쪽은 집계 데이터를 위한 Table, 오른쪽은 원본 데이터와 원본과의 Join 데이터를 위한 Table을 다루게 됩니다. HDFS: 수집된 JSON 데이터를 압축한 후 Parquet<NAME>으로 저장하게 됩니다. 왼쪽은 SSD 디스크를, 오른쪽은 SATA 디스크를 사용하고 있습니다. Federation 설정으로 각각의 HDFS는 Namespace 만으로 편리하게 접근할 수 있습니다. Spark: Zeppelin, Streaming, BigDB 각각 별도의 세션으로 동작을 하며, Hive Meta-Store를 사용하여 Table은 세션 간에 공유됩니다. Locality를 위해서 Table(실제 데이터 파일)이 존재하는 파트의 자원을 사용하게 됩니다. End Point: Web/Zeppelin/BigDB API 등에서 Spark의 자원과 Table을 사용하게 됩니다. 오른쪽에서는 주로 집계와 조회를 하고, 왼쪽에서는 조회와 스케줄링된 작업을 수행하는 용도로 사용됩니다. BigDB Core/API: akka.http를 사용하고 있습니다. 스키마의 생성과 관리, 쿼리 기반의 집계나 스케줄링된 작업의 수행을 관리합니다. terminus.js를 사용하여 REST CLI를 제공합니다. End Point에 결과를 전달하기 위해서 JSON 데이터를 CSV/TSV/JSON 형태로 변환합니다. 시스템 구조 디스크의 종류에 따라 두 개의 클러스터로 구분하여 사용 SSD의 경우는 읽기/쓰기가 빠르고 용량이 작은 경우에 사용 SATA의 경우는 읽기/쓰기가 SSD에 비해서 느리지만 용량이 큰 노드일 때 사용 SATA를 사용하는 데이터 노드의 경우는 물리적으로 12개의 디스크를 분산해서 사용함으로써 효율성을 확보 CPU의 경우는 동일하게 구성 Memory의 경우는 디스크의 공간을 고려한 Rack 구성으로 차이 나게 구성 두 개의 클러스터가 모두 수평 확장을 고려 SSD SSD를 사용하는 클러스터는 일반적으로 집계 후의 작은 사이즈를 장기간 보관하는 용도로 사용 SATA SATA를 사용하는 클러스터는 원본 데이터와 원본 데이터 수준으로 가공되는 큰 사이즈를 장기간 보관하는 용도로 사용 메모리 Memory의 경우는 Parquet를 사용하게 되면서 사용성이 적어지고 있고, 남는 Memory를 Elasticsearch에 일부 할당함으로써 검색이 필요한 데이터 처리에 활용 네트워크 조회 시 대상이 되는 데이터의 사이즈가 크고, 그에 따라서 셔플의 성능을 확보하기 위해 네트워크는 10GB를 사용하고 있습니다. 사용되는 설루션 모두 가능한 로컬 통신을 할 수 있도록 설정 Proxy: 비즈니스 로직을 최소화해서, 자원의 사용도 최소화하고 스케일의 확장을 쉽게 할 수 있도록 구성합니다. Kafka: Locality 확보를 위해서 Spark, HDFS와 같은 노드에 최소화해서 구성을 하고, 데이터의 버퍼 용도로 사용합니다. Spark & Spark Streaming: Kafka로부터 유실 없는 데이터 처리를 하고, PreferBroker 설정을 통해서 Locality를 확보합니다. Table 데이터 공유를 위해서 Streaming에서는 Data Frame을 InsertInto로 추가해서 사용합니다. Data Frame을 in-memory로 Cache 하는 것보다는, Parquet<NAME>을 사용하여 칼럼 별로 쿼리의 성능을 향상시킵니다. Memory는 Spark의 내부에서 사용하는 용도와 검색 용도로, 짧은 기간의 데이터를 저장하는 Elasticsearch에 할당하도록 노드에 구성할 수 있는 최대량을 증설해 둡니다. HDFS: SCR(Short-Circuit Local Reads) 설정을 활성화시켜서 로컬 통신의 효율을 고려합니다. Federation 설정을 통해서는 클러스터 간의 데이터 Path 공유를 편리하게 합니다. 두 개의 NameNode는 HA 구성을 함으로써 장애에 대응합니다. HDFS의 경우 SSD를 사용하는 파트와 SATA를 사용하는 파트로 두 개의 클러스터를 운영합니다. SSD의 경우 쓰기와 읽기의 성능이 우수하지만, 전체 용량은 한계가 있어서 집계 데이터를 쌓아서 활용하고, SATA의 경우 노드 별로 물리적으로 12개의 디스크를 no-mirror로 사용함으로써 쓰기와 읽기 면에서의 효율을 고려하였습니다. 전체 용량이 크기 때문에 향후 5년간의 데이터를 유지할 수 있도록 설계했습니다. 기능 소개 REST CLI (Command Line Interface) terminus.js를 사용하여, REST 방식으로 Command를 운용할 수 있도록 설정 Create Table[Schema] REST CLI를 통해 스키마를 생성하면, 스키마에서 지정된 Source 위치로부터 Data를 읽어서 생성한 Table에 스키마의<NAME>에 맞게 저장 스키마의 정보는 Zookeeper 내에 보관 Message Proxy와 Spark에서 스키마를 참조하여 Validation 및 형 변환 스키마에 지정된 Table의 파티션 정보를 활용 스트리밍의 짧은 간격으로 입력된 많은 파티션 정보는 매일 새벽 시간에 파티션을 merge 실제 테스트 시 80만 개 정도의 파티션이 생성되면 성능 문제가 발생 스트리밍이 5초 간격으로 파티션을 생성하기 때문에 매일 merge를 수행함으로써 이러한 이슈를 피할 수 있었음 Support [Multi] Session Table에 입력된 실시간 데이터는 서로 다른 Spark 클러스터에서 바로 사용할 수 있었음 입력된 데이터를 Zeppelin, JDBC, Web 등에서 서로 공유할 수 있음 InsertInto 동작에서는 스트리밍 시 파티션을 유일하게 생성하는 것으로, 다른 세션의 Spark에서 조회할 때 refresh table을 수행하지 않고도 입력된 실시간 데이터를 사용할 수 있었음 [Realtime] Data Join Data Join은 분석의 한 형태로 Online 분석의 경우, 실시간으로 여러 Table을 Join 하는 기능을 제공함으로써 학습 시 Join 하는 큰 비용을 줄일 수 있었음 실시간으로 증가하는 시계열 데이터와 정적으로 제공되는 메타 데이터 및 사용자 데이터를 대량으로 Join 하는 경우 데이터의 위치가 서로 다른 이유로 많은 비효율적인 이슈가 발생 이 경우 실시간으로 입력되는 데이터의 사이즈가 가장 작은 시점에 Join 하게 함으로써, Join 비용을 최소화할 수 있었음 Support Input/Output Spec ([ ] : Beta Phase) 지원하는 Output의 형태는 Table, Kafka, File, Elasticsearch와 Web에서 사용하기 위한 TSV, CSV, JSON 형태 기본적으로는 Kafka가 Input이 되며, 형태에 따라 Kafka 없이 HDFS에 바로 적재된 데이터를 사용 BigDB API를 이용해서 스키마를 생성할 때 Input/Output은 정의할 수 있음 Join의 경우는 스키마 생성 이후 BigDB API를 이용해서 스케줄러에 쿼리와 수행 간격을 등록할 수 있음 집계의 경우도 스케줄러에 쿼리와 수행 간격을 등록할 수 있음 쿼리 결과 데이터양에 따라 두 개의 HDFS 중에서 적절한 곳을 선택 Use Case 기간별 데이터 조회 및 분석 광고사업 부서나 기획 부서 등의 회사 내 사용자의 경우, 주로 기간별 데이터 조회를 통한 분석과 보고 업무를 수행 공통으로 사용하게 되는 집계 데이터는 별도로 Dashboard를 Web으로 구성하여 사용 Input: Kafka (Realtime Advertisement Impression & Click Log Data) Join Target: None Support Output: JSON (For Dashboard web page) 목적: 5초 주기의 실시간 광고 로그 메시지를 생성된 스키마에 따라 지정된 Table에 InsertInto로 추가하고 누적된 실시간 데이터를 등록한 집계 쿼리와 수행 간격에 따라 새로운 집계 Table을 생성하고 집계를 수행합니다. 성능: 5초마다 10,000건~100,000건의 스트리밍 데이터를 1초 이하로 저장할 수 있었고, 3개월 동안의 누적 데이터 조회는 수 초 이내로 수행할 수 있었습니다. Dashboard web 페이지에서는 BigDB API를 통해서 주기적으로 집계된 데이터를 JSON 형태로 받아서 사용합니다. 집계된 데이터이기 때문에 사이즈도 많이 줄어들고 기간에 따라 수 초에서 수십 초 사이로 web에 표시할 수 있었습니다. Dashboard는 간단하게 ad-hoc 쿼리를 사용하는 경우와 machine learning을 통한 결과 조회 등으로 구분하고 있습니다. ad-hoc 쿼리 광고사업 부서나 기획, 개발 부서 등의 회사 내 사용자의 경우, 업무적으로 발생하는 분석 작업을 위해 BigDB로 만들어진 Table에 ad-hoc 쿼리를 수행하여 조회 개발 부서 사용자의 경우는 좀 더 복잡한 비즈니스 로직을 처리하기 위해 ad-hoc 쿼리 및 UDF를 추가적으로 개발하여 사용 이를 위해서 주로 Zeppelin을 사용 Input: Kafka (Realtime Advertisement Impression & Click Log Data) Join Target: None Support Output: Table (For Zeppelin) 목적: 실시간으로 입력되는 데이터의 스키마를 생성하고 지정된 Table에 누적함으로써 Zeppelin을 활용하여 ad-hoc 쿼리를 할 수 있습니다. 또한 정해진 쿼리를 등록하고 집계 Table에 결과를 누적함으로써 집계에 대한 데이터의 ad-hoc 쿼리를 할 수 있습니다. 성능: 5초마다 10,000건~100,000건의 스트리밍 데이터를 1초 이하로 저장할 수 있었고, 집계 쿼리의 유형에 따라 수 초 이내로 수행할 수 있었습니다. 수행 시에는 자원을 점유하기 때문에 필요한 경우 실시간 Join을 통해서 가공 후 재처리를 하게 됩니다. 분석 및 예측을 위한 Online 데이터 Joiner 역할 (beta phase) 사용자에게 좀 더 유익한 광고를 전달하기 위해서, 실시간으로 이벤트를 수집하고 분석하여 온라인으로 분석된 광고를 제공하기 위한 많은 시도를 수행 대량의 데이터를 처리하기 위하여 발생하는 여러 가지의 데이터 정보를 BigDB를 사용하여 Table로 만들고 있으며, 분석 작업 시 시간이 많이 소요되는 Join 과정을 실시간으로 처리함으로써 분석에 대한 효율을 높이고 있음 Input: Kafka (Realtime Advertisement Impression & Click Log Data) Join Target: HDFS (Daily User Demo Data) Support Output: Kafka & Table 목적: 5초 주기의 실시간 광고 로그 메시지와 일별 집계된 사용자의 데모 정보를 실시간으로 Join 함으로써 분석 시 Join 비용을 줄이고, 온라인으로 광고에 대한 CTR(click-through rate)을 높이는 분석을 수행합니다. 성능: 5초마다 10,000건~100,000건의 스트리밍 데이터를 1초 이하의 시간 동안 저장할 수 있었고 해당 스트리밍 데이터와 7천만 건 데이터의 Join 시 2초~3초가 소요되었습니다. 일별 또는 시간별로 데이터를 Join 하는 경우 대량 데이터의 셔플 발생으로 인해 Join에 대한 비용이 증가 또한 batch 분석보다는 광고의 실시간 분석에 바로 사용함으로써 서비스의 질적 분석에 대한 성과를 확보하고자 노력하였음 사용자 입장에서는 좀 더 필요한 정보를 광고를 통해 제공받을 수 있다는 장점도 있음 참고 LINE 광고 데이터 파이프라인 BigDB 6-Hive에서 실시간으로 쇼핑 데이터를 조회할 수 있게 ETL 개선하기 LINE 쇼핑의 쇼핑 플랫폼 정보에 대해서 알아보겠습니다. 구조 Hive Kafka 실시간 데이터 전송 지원 HBase 데이터 저장 마치며 개선 작업으로 얻은 이점은 크게 두 가지입니다. 첫 번째는 대용량 데이터의 사용성이 증대된 것입니다. 그동안에는 여러 사용처에서 ETL이 완료될 시점을 공유 받아 후속 배치 작업을 실행하곤 했습니다. 이 때문에 간혹 Hadoop 지연이 발생하면 하루 전에 생성된 데이터를 사용해 버리는 문제가 발생했습니다. 하지만 일 주기, 시간 주기 또는 준 실시간 주기로 업데이트된 테이블을 뷰로 제공할 수 있게 되면서 문제가 사라졌습니다. Hadoop 지연이 발생하더라도 비교적 최근 데이터를 제공할 수 있게 됐고, 시간 제약이 사라지면서 사용처가 원하는 시간에 대용량 데이터를 다루는 마이크로 배치를 많이 사용할 수 있게 됐습니다. 예를 들어 이전에는 통계 데이터를 하루 단위로 밖에 만들 수 없었지만 이제는 시간 단위로 만들 수 있게 된 것입니다. 두 번째는 이벤트 드리븐 아키텍처의 운영 및 유지 보수 비용이 감소한 것입니다. 판매자가 상품 데이터를 잘못 올리거나 유입된 상품 데이터를 잘못 정제해 문제가 발생할 수 있습니다. 이런 경우 디버깅하며 원인을 찾아야 하는데 LINE 쇼핑의 경우 상품 정보 데이터가 많다 보니 쉽지 않았습니다. Kafka에 존재하는 많은 메시지를 확인하는 것 자체도 어려운데 보유 기한도 짧아 문제가 발생한 지 며칠이 지나면 원인을 찾을 수 없었기 때문입니다. 이 문제를 해결하기 위해 KSQL과 Elasticsearch를 도입해 활용하고 있었지만 비용 문제로 활용도를 더 높이기는 어려웠습니다. 하지만 이제 Hive에 실시간 데이터를 입력하고 업데이트할 수 있게 되면서 고민거리가 해결됐습니다. SQL 문법을 사용할 수 있는 HiveQL로 손쉽게 상품 데이터를 찾을 수 있고, 상대적으로 비용이 저렴한 HDFS를 사용하면서 보유 기한도 늘릴 수 있습니다. 참고 Hive에서 실시간으로 쇼핑 데이터를 조회할 수 있게 ETL 개선하기 Kafka와 MongoDB, Kubernetes로 유연하고 확장 가능한 LINE 쇼핑 플랫폼 구축하기 2-하둡(hadoop) 하둡(hadoop)에 대해서 알아봅시다. 하둡이란? HDFS MapReduce YARN 작업 지원 도구 1-하둡이란? 하둡은 2006년 야후의 더그 커팅이 '넛치'라는 검색엔진을 개발하는 과정에서 대용량의 비정형 데이터를 기존의 RDB 기술로는 처리가 힘들다는 것을 깨닫고, 새로운 기술을 찾는 중 구글에서 발표한 GFS와 MapReduce 관련 논문을 참고하여 개발하였습니다. 이후 아파치 재단의 오픈 소스로 공개되었습니다. 하둡은 하나의 성능 좋은 컴퓨터를 이용하여 데이터를 처리하는 대신, 적당한 성능의 범용 컴퓨터 여러 대를 클러스터 화하고, 큰 크기의 데이터를 클러스터에서 병렬로 동시에 처리하여 처리 속도를 높이는 것을 목적으로 하는 분산처리를 위한 오픈소스 프레임워크라고 할 수 있습니다. 2020. 06월 기준 최신 버전은 v3.2.1, v2.10입니다. 하둡의 구성 요소 하둡은 4개의 주요 모듈로 구성됩니다. Hadoop Common 하둡의 다른 모듈을 지원하기 위한 공통 컴포넌트 모듈 Hadoop HDFS 분산 저장을 처리하기 위한 모듈 여러 개의 서버를 하나의 서버처럼 묶어서 데이터를 저장 Hadoop YARN 병렬처리를 위한 클러스터 자원관리 및 스케줄링 담당 Hadoop Mapreduce 분산되어 저장된 데이터를 병렬 처리할 수 있게 해주는 분산 처리 모듈 Hadoop Ozone 하둡을 위한 오브젝트 저장소 하둡의 장단점 장점 오픈소스로 라이선스에 대한 비용 부담이 적음 시스템을 중단하지 않고, 장비의 추가가 용이(Scale Out) 일부 장비에 장애가 발생하더라도 전체 시스템 사용성에 영향이 적음(Fault tolerance) 저렴한 구축 비용과 비용 대비 빠른 데이터 처리 오프라인 배치 프로세싱에 최적화 단점 HDFS에 저장된 데이터를 변경 불가 실시간 데이터 분석같이 신속하게 처리해야 하는 작업에는 부적합 너무 많은 버전과 부실한 서포트 설정의 어려움 01-하둡 버전별 특징 하둡의 버전 1 별 특징을 알아보기 전에 각 버전의 특징에 대해서 알아보겠습니다. 하둡 v1에서 하둡의 기본 아키텍처를 정립하였습니다. 병렬처리(맵리듀스)는 잡트래커와 태스크 트래커가 담당하고, 분산 저장(HDFS)은 네임노드와 데이터노드가 담당하도록 구조를 설정하였습니다. 하지만 병렬처리의 클러스터의 자원관리와 애플리케이션의 라이프사이클 관리를 잡트래커가 모두 담당하여 병목현상이 발생하였습니다. 하둡 v2에서는 잡트래커의 병목현상을 개선하기 위하여 YARN 아키텍처를 도입하였습니다. 잡트래커의 기능을 분리하여 클러스터의 자원관리는 리소스 매니저와 노드 매니저, 애플리케이션의 라이프 사이클 관리는 애플리케이션 마스터와 컨테이너에게 담당하도록 하였습니다. 하둡 v3에서는 이레이져 코딩을 도입하여 HDFS의 데이터 저장 효율성을 증가시켰습니다. 또한, YARN 타임라인 서비스를 개선하고, 하둡 v1부터 사용된 쉘 스크립트를 재작성하여 안정성을 높였습니다. 맵리듀스 처리에 네이티브 프로그램을 도입하여 성능을 개선하였습니다. 하둡 v1 2011년에 정식 발표된 하둡 v1은 분산 저장, 병렬처리 프레임워크를 정의하였습니다. 분산 저장은 네임노드와 데이터노드가 처리합니다. 네임노드는 블록 정보를 가지고 있는 메타데이터를 관리하고, 데이터 노드를 관리하는 역할을 합니다. 데이터노드에서 데이터를 블록 단위로 나누어서 저장합니다. 블록 단위 데이터는 복제하여 데이터 유실에 대비합니다. 병렬처리는 잡트래커와 태스크 트래커가 처리합니다. 잡트래커가 전체 작업의 진행 상황을 관리하고, 자원 관리도 처리하였습니다. 이로 인해 최대 4000대의 노드를 등록할 수 있었습니다. 태스크 트래커는 실제 작업을 처리하였습니다. 병렬처리의 작업 단위는 슬롯(slot)입니다. 맵 슬롯, 리듀스 슬롯의 개수가 정해져 있고, 실행 시점에 역할이 정해지면 슬롯의 용도를 변경할 수 없기 때문에 맵 작업이 진행 중에는 리듀스 슬롯은 대기 상태로 있었습니다. 이로 인해 클러스터가 100% 활용되지 않을 때도 있었습니다. 하둡 v1 특징 분산 저장, 병렬처리 프레임워크를 정의 분산 저장(HDFS) 네임노드, 데이터 노드가 처리 병렬처리(MapReduce) 잡트래커, 테스트 트래커가 처리 클러스터 당 최대 4000개의 노드를 등록 작업 처리를 슬롯(slot) 단위로 처리 맵, 리듀스 슬롯을 구분하여 처리 하둡 v2 2012년 정식 발표된 하둡 v2는 잡트래커의 병목현상을 제거하기 위하여 YARN 아키텍처를 도입하였습니다. YARN 아키텍처는 잡트래커의 기능을 분리하여 자원관리는 리소스 매니저와 노드 매니저가 담당하고, 애플리케이션의 라이프 사이클 관리는 애플리케이션 마스터가 담당하고, 작업의 처리는 컨테이너가 담당합니다. 자원관리와 애플리케이션 관리의 분리를 통해 클러스터 당 최대 만개의 노드를 등록할 수 있습니다. YARN 아키텍처의 작업의 처리 단위는 컨테이너입니다. 작업에 제출되면 애플리케이션 마스터가 생성되고, 애플리케이션 마스터가 리소스 매니저에 자원을 요청하여 실제 작업을 담당하는 컨테이너를 할당받아 작업을 처리합니다. 컨테이너는 작업이 요청되면 생성되고, 작업이 완료되면 종료되기 때문에 클러스터를 효율적으로 사용할 수 있습니다. 또한 YARN 아키텍처에서는 MR로 구현된 작업이 아니어도 컨테이너를 할당받아서 동작할 수 있기 때문에 Spark, HBase, Storm 등 다양한 컴포넌트들을 실행할 수 있습니다. 하둡 v2 특징 YARN을 도입하여 병렬 처리 구조를 변경 클러스터 관리 리소스 매니저, 노드 매니저 작업 관리 애플리케이션 마스터, 컨테이너 MR 외 Spark, Hive, Pig 등 다른 분산 처리 모델도 수행 가능 클러스터 당 1만 개 이상의 노드 등록 가능 작업 처리를 컨테이너(container) 단위로 처리 하둡 v3 2017년 정식 발표된 하둡 v3는 이레이져 코딩, YARN 타임라인 서비스 v2 등이 도입되었습니다. 하둡 v2까지 HDFS에서 장애 복구를 위해 파일 복제를 이용했습니다. 기본 복제 단위가 3개여서, 파일 1개당 2개의 복제본을 가지게 됩니다. 이로 인해 1G 데이터 저장에 3G의 저장소를 사용하였습니다. 이레이져 코딩은 패리티 블록을 이용하여 1G 데이터 저장에 1.5G의 디스크를 사용하게 되고 저장소의 효율성이 증가합니다. 또한 YARN 타임라인 서버를 개선하고, 하둡 v1부터 사용하던 쉘 스크립트를 다시 작성하여 버그를 해결하였습니다. 네이티브 코드를 수정하여 셔플 단계의 처리 속도를 증가시키고, JAVA8을 지원하도록 수정하였습니다. 고가용성을 위하여 2개 이상의 네임노드를 지원하는 등 여러 가지 개선점이 추가되었습니다. 하둡 v3 특징 이레이져 코딩 도입 기존의 블록 복제(Replication)를 대체하는 방식으로 HDFS 사용량 감소 YARN 타임라인 서비스 v2 도입 기존 타임라인 서비스보다 많은 정보를 확인 가능 스크립트 재작성 및 이해하기 쉬운 형태로 수정 오래된 스크립트를 재작성하여 버그 수정 기본 포트 변경 NameNode 50470 → 9871 50070 → 9870 8020 → 9820 Secondary NameNode 50091 → 9869 50090 → 9868 DataNode ports: 50020 → 9867 50010 → 9866 50475 → 9865 50075 → 9864 JAVA8 지원 네이티브 코드 최적화 고가용성을 위해 2개 이상의 네임노드 지원 하나만 추가할 수 있었던 스탠바이 노드를 여러개 지원 가능 스탠바이 노드 Ozone 추가 오브젝트 저장소 추가 참고 NEW Hadoop3와 Erasure Coding(바로 가기) Hadooop Realease (바로 가기) 하둡은 현재(2020.05 기준) v3까지 공개되었습니다. ↩ 2-HDFS HDFS(Hadoop Distributed File System)는 범용 하드웨어에서 동작하고, 장애 복구성을 가지는 분산 파일 시스템을 목표로 합니다. HDFS는 실시간 처리보다는 배치처리를 위해 설계되었습니다. 따라서 빠른 데이터 응답시간이 필요한 작업에는 적합하지 않습니다. 또한 네임노드가 단일 실패 지점(SPOF)이 되기 때문에 네임노드 관리가 중요합니다. 특징 블록 단위 저장 HDFS는 데이터를 블록 단위로 나누어서 저장합니다. 블록 사이즈보다 작은 파일은 기존 파일의 사이즈로 저장하고, 블록 사이즈보다 큰 크기의 데이터파일은 블록 단위 나누어 저장하기 때문에 단일 디스크의 데이터보다 큰 파일도 저장할 수 있습니다. 블록 단위가 256MB 일 때 1G 파일은 4개의 블록으로 나누어 저장되고, 10MB 파일은 하나의 블록으로 저장됩니다. 블록 복제를 이용한 장애 복구 HDFS는 장애 복구를 위해서 각 블록을 복제하여 저장합니다. 블록의 기본 복제 단위는 3입니다. 하나의 블록은 3개의 블록으로 복제되고, 같은 랙(Rack)의 서버와 다른 랙(Rack)의 서버로 복제되어 저장됩니다. 블록에 문제가 생기면 복제한 다른 블록을 이용해서 데이터를 복구합니다. 1G 데이터를 저장할 때 데이터가 복제되어 3G의 저장 공간이 필요합니다. 읽기 중심 HDFS는 데이터를 한 번 쓰면 여러 번 읽는 것을 목적으로 합니다. 따라서 파일의 수정은 지원하지 않습니다. 파일의 수정을 제한하여 동작을 단순화하고 이를 통해 데이터를 읽을 때 속도를 높일 수 있습니다. 데이터 지역성 맵리듀스는 HDFS의 데이터 지역성을 이용해서 처리 속도를 증가시킵니다. 처리 알고리즘이 있는 곳에 데이터를 이동시키지 않고, 데이터가 있는 곳에서 알고리즘을 처리하여 네트워크를 통해 대용량 데이터를 이동시키는 비용을 줄일 수 있습니다. 01-구조(Architecture) HDFS는 마스터 슬레이브 구조로 하나의 네임노드와 여러 개의 데이터노드로 구성됩니다. 네임노드는 메타데이터를 가지고 있고, 데이터는 블록 단위로 나누어 데이터노드에 저장됩니다. 사용자는 네임노드를 이용해 데이터를 쓰고, 읽을 수 있습니다. 네임노드 메타데이터 관리 메타데이터 파일 종류 메타데이터 파일 저장 형태 메타데이터 데이터 노드 관리 데이터노드 블록 파일 저장 형태 데이터노드 상태 활성상태 운영 상태 네임노드 구동 과정 파일 읽기/쓰기 파일 읽기 파일 쓰기 참고 네임노드 네임노드의 주요 역할은 메타데이터 관리와 데이터노드의 관리입니다. 메타데이터 관리 메타데이터는 파일 이름, 파일 크기, 파일 생성 시간, 파일 접근 권한, 파일 소유자 및 그룹 소유자, 파일이 위치한 블록의 정보 등으로 구성됩니다. 각 데이터노드에서 전달하는 메타데이터를 받아서 전체 노드의 메타데이터 정보와 파일 정보를 묶어서 관리합니다. 메타데이터는 사용자가 설정한 위치(dfs.name.dir)에 보관됩니다. 네임노드가 실행될 때 파일을 읽어서 메모리에 보관합니다. 운영 중에 발생한 수정사항은 네임노드의 메모리에는 바로 적용되고, 데이터의 수정사항을 다음 구동시 적용을 위해서 주기적으로 Edist 파일로 저장합니다. 메타데이터 파일 종류 Fsimage 파일 네임스페이스와 블록 정보 Edits 파일 파일의 생성, 삭제에 대한 트랜잭션 로그 메모리에 저장하다가 주기적으로 생성 메타데이터 파일 저장 형태 사용자가 설정한 위치(dfs.name.dir)에 다음과 같은 파일의 형태로 저장됩니다. # 네임노드의 메타 데이터가 다음과 같은 형태로 생성됨 $ ls -alh /hadoop/hdfs/namenode/current total 1847556 -rw-r--r-- 1 hdfs hadoop 217 Sep 2 03:36 VERSION -rw-r--r-- 1 hdfs hadoop 1523554 Feb 21 14:30 edits_0000000003027897761-0000000003027906608 -rw-r--r-- 1 hdfs hadoop 1351557 Feb 21 14:32 edits_0000000003027906609-0000000003027914396 -rw-r--r-- 1 hdfs hadoop 1391038 Feb 21 14:34 edits_0000000003027914397-0000000003027922191 ... -rw-r--r-- 1 hdfs hadoop 836860 Feb 21 23:53 edits_0000000003029906692-0000000003029911098 -rw-r--r-- 1 hdfs hadoop 890807 Feb 21 23:55 edits_0000000003029911099-0000000003029915811 -rw-r--r-- 1 hdfs hadoop 1048576 Feb 21 23:56 edits_inprogress_0000000003029915812 -rw-r--r-- 1 hdfs hadoop 760128990 Feb 21 18:50 fsimage_0000000003028899087 -rw-r--r-- 1 hdfs hadoop 62 Feb 21 18:50 fsimage_0000000003028899087.md5 -rw-r--r-- 1 hdfs hadoop 762005689 Feb 21 23:50 fsimage_0000000003029901533 -rw-r--r-- 1 hdfs hadoop 62 Feb 21 23:50 fsimage_0000000003029901533.md5 -rw-r--r-- 1 hdfs hadoop 11 Feb 21 23:55 seen_txid 메타데이터 VERSION: 현재 실행 중인 HDFS의 ID, 타입 등 정보 edits_0000xxx-0000xxx: 트랜잭션 정보. edits_트랜잭션 시작번호-트랜잭션 종료 번호까지의 정보를 저장 eidts_inprogress_000xx: 최신 트랜잭션 정보. 압축되지 않은 정보 fsimage_000xxx: 000xxx까지 트랜잭션 정보가 처리된 fsimage fsimage_000xxx.md5: fsiamge의 해시값 seen_txid: 현재 트랜잭션 ID 데이터 노드 관리 네임노드는 데이터노드가 주기적으로 전달하는 하트비트(3초, dfs.heart beat.interval)와 블록 리포트(6시간, dfs.blockreport.intervalMsec)를 이용하여 데이터 노드의 동작 상태, 블록 상태를 관리합니다. 하트비트를 이용하여 데이터노드가 동작 중이라는 것을 네임노드가 알 수 있습니다. 하트비트가 도착하지 않으면 네임노드는 데이터노드가 동작하지 않는 것으로 간주하고, 더 이상 IO 가 발생하지 않도록 조치합니다. 블록 리포트를 이용하여 HDFS에 저장된 파일에 대한 최신 정보를 유지합니다. 블록 리포트에는 데이터노드에 저장된 블록 목록과 각 볼록이 로컬 디스크의 어디에 저장되어 있는지에 대한 정보를 가지고 있습니다. 데이터노드 데이터노드는 파일을 저장하는 역할을 합니다. 파일은 블록 단위로 저장됩니다. 데이터노드는 주기적으로 네임노드에 하트비트와 블록 리포트를 전달합니다. 하트비트는 데이터노드의 동작 여부를 판단하는데 이용됩니다. 네임노드는 하트비트가 전달되지 않는 데이터노드는 동작하지 않는 것으로 판단하여 더 이상 데이터를 저장하지 않도록 설정합니다. 블록 리포트로 블록의 변경사항을 체크하고, 네임노드의 메타데이터를 갱신합니다. 블록 파일 저장 형태 사용자가 설정한 위치(dfs.data.dir)에 다음과 같은 파일의 형태로 저장됩니다. 블록은 블록과 블록의 메타 정보로 저장됩니다. blk_12345 파일 블록 최대 크기가 블록 사이즈(dfs.blocksize) 크기로 생성 블록 복제 개수에 따라 동일한 이름의 블록이 여러 개의 노드에 생성됨 blk_12345_29082353.meta 블록의 메타 정보 ./hdfs/current/BP-11233441/current/finalized/subdir187/subdir191: total 676K drwxr-xr-x 2 hdfs hdfs 4.0K Sep 8 04:30. drwxr-xr-x 258 hdfs hdfs 8.0K Aug 31 22:21 .. -rw-r--r-- 1 hdfs hdfs 40K Aug 31 22:46 blk_12345 -rw-r--r-- 1 hdfs hdfs 327 Aug 31 22:46 blk_12345_29082353.meta -rw-r--r-- 1 hdfs hdfs 19K Aug 31 22:46 blk_12346 -rw-r--r-- 1 hdfs hdfs 155 Aug 31 22:46 blk_12346_29082375.meta -rw-r--r-- 1 hdfs hdfs 262K Aug 31 22:46 blk_12347 -rw-r--r-- 1 hdfs hdfs 2.1K Aug 31 22:46 blk_12347_29082433.meta 데이터노드 상태 데이터 노드의 상태를 나타내는 정보는 두 가지로 구분할 수 있습니다. 첫 번째 유형은 활성 상태입니다. 두 번째 유형은 서비스가 운영 중인지를 나타냅니다. 활성상태 활성 상태는 데이터노드가 Live 상태인지 Dead 상태인지를 나타냅니다. 데이터노드가 하트비트를 주기적으로 전달하여 살아 있는지 확인되면 Live 상태입니다. 데이터노드에 문제가 발생하여 지정한 시간 동안(dfs.namenode.stale.datanode.interval) 하트비트를 받지 못하면 네임노드는 데이터노드의 상태를 Stale 상태로 변경합니다. 이후 지정한 시간 동안 응답이 없으면 Dead 노드로 변경합니다. 운영 상태 운영 상태는 데이터노드의 업그레이드, 패치 같은 작업을 하기 위해 서비스를 잠시 멈추어야 할 경우 블록을 안전하게 보관하기 위해 설정합니다. 다음의 상태가 있습니다. NORMAL: 서비스 상태 DECOMMISSIONED: 서비스 중단 상태 DECOMMISSION_INPROGRESS: 서비스 중단 상태로 진행 중 IN_MAINTENANCE: 정비 상태 ENTERING_MAINTENANCE: 정비 상태로 진행 중 dfs.hosts 파일(DataNodeAdmin에 노드의 상태를 json 형태로 기술하여 운영 중에 서비스를 잠시 멈추고 정비를 한 후 다시 진행할 수 있습니다. 네임노드 구동 과정 네임노드는 다음의 순서로 구동됩니다. Fsimage와 Edits를 읽어서 작업을 처리하기 때문에 두 파일의 크기가 크면 구동 시작 시간이 오래 걸릴 수 있습니다. Fsimage를 읽어 메모리에 적재합니다. Edits 파일을 읽어와서 변경 내역을 반영 현재의 메모리 상태를 스냅샷으로 생성하여 Fsimage 파일 생성 데이터 노드로부터 블록 리포트를 수신하여 매핑 정보 생성 서비스 시작 파일 읽기/쓰기 HDFS의 파일에 접근하는 가장 간단한 방법은 HDFS 명령행 인터페이스를 이용하는 것입니다. 또한 Java, C API를 제공하여 이를 구현해서 접근하면 됩니다. 파일 읽기 네임노드에 파일이 보관된 블록 위치 요청 네임노드가 블록 위치 반환 각 데이터 노드에 파일 블록을 요청 노드의 블록이 깨져 있으면 네임노드에 이를 통지하고 다른 블록 확인 파일 쓰기 네임노드에 파일 정보를 전송하고, 파일의 블록을 써야 할 노드 목록 요청 네임노드가 파일을 저장할 목록 반환 데이터 노드에 파일 쓰기 요청 데이터 노드 간 복제가 진행 참고 하둡 데몬의 기동 과정과 메커니즘 이해 DataNode Admin 1. 블록 HDFS 파일은 지정한 크기의 블록으로 나누어지고, 각 블록은 독립적으로 저장됩니다. HDFS의 블록은 128MB와 같이 매우 큰 단위입니다. 블록이 큰 이유는 탐색 비용을 최소화할 수 있기 때문입니다. 블록이 크면 하드디스크에서 블록의 시작점을 탐색하는 데 걸리는 시간을 줄일 수 있고, 네트워크를 통해 데이터를 전송하는데 더 많은 시간을 할당할 수 있습니다. 따라서 여러 개의 블록으로 구성된 대용량 파일을 전송하는 시간은 디스크 IO 속도에 크게 영향을 받게 됩니다. 블록 크기 파일 분할 기본 블록 크기를 넘어서는 파일은 블록 크기로 분할하여 저장합니다. 블록 크기보다 작은 파일은 단일 블록으로 저장 실제 파일 크기의 블록이 됨 블록 단위로 나누어 저장하기 때문에 디스크 사이즈보다 더 큰 파일을 보관할 수 있음 블록 단위로 파일을 나누어 저장하기 때문에 700G * 2 = 1.4T 크기의 HDFS에 1T의 파일 저장 가능 블록 추상화의 이점 첫 번째는 파일 하나의 크기가 단일 디스크의 용량보다 더 커질 수 있습니다. 메일에 첨부파일을 전송할 때 한 번에 보낼 수 있는 용량이 제한되어 있을 때 분할 압축을 통해 전송 가능한 용량으로 나누어 보낼 수 있습니다. HDFS도 큰 파일을 블록 단위로 나누어서 단일 디스크의 용량보다 큰 파일을 저장할 수 있습니다. 두 번째는 파일 단위보다 블록 단위로 추상화를 하면 스토리지의 서브시스템을 단순하게 만들 수 있다는 것입니다. 파일 탐색 지점이나 메타정보를 저장할 때 사이즈가 고정되어 있으므로 구현이 좀 더 쉽습니다. 세 번째는 내 고장성을 제공하는데 필요한 복제(replication)을 구현할 때 매우 적합합니다. 블록 단위로 복제를 구현하기 때문에 데이터 복제에도 어려움 없이 처리할 수 있습니다. 같은 노드에 같은 블록이 존재하지 않도록 복제하여 노드가 고장일 경우 다른 노드의 블록으로 복구할 수 있습니다. 블록 지역성 맵리듀스를 이용한 분산 컴퓨팅은 블록의 지역성을 이용해 성능을 높입니다. 맵리듀스를 처리할 때 현재 노드에 저장되어 있는 블록을 이용하는 블록 지역성(Block Locality)을 통해 성능을 높일 수 있습니다. 네트워크를 이용한 데이터 전송 시간 감소 대용량 데이터 확인을 위한 디스크 탐색 시간 감소 적절한 단위의 블록 크기를 이용한 CPU 처리시간 증가 클라우드 저장 공간(eg. S3)을 이용하는 경우 HDFS를 이용하는 경우보다 속도가 느려집니다. 하지만 클라우드 저장 공간을 이용하는 경우 영구적인 데이터 보관 및 HDFS 관리비 절감에 따른 장점이 있습니다. 블록 작업 순서 블록 지역성을 위한 작업 우선순위는 다음과 같습니다. 같은 노드에 있는 데이터 같은 랙(Rack)의 노드에 있는 데이터 다른 랙의 노드에 있는 데이터 블록 스캐너 데이터 노드는 주기적으로 블록 스캐너를 실행하여 블록의 체크섬을 확인하고 오류가 발생하면 수정합니다. 블록 캐싱 데이터 노드에 저장된 데이터 중 자주 읽는 블록은 블록 캐시(block cache)라는 데이터 노드의 메모리에 명시적으로 캐싱 할 수 있습니다. 파일 단위로 캐싱 할 수도 있어서 조인에 사용되는 데이터들을 등록하여 읽기 성능을 높일 수 있습니다. $ hdfs cacheadmin Usage: bin/hdfs cacheadmin [COMMAND] [-addDirective -path <path> -pool <pool-name> [-force] [-replication <replication>] [-ttl <time-to-live>]] [-modifyDirective -id <id> [-path <path>] [-force] [-replication <replication>] [-pool <pool-name>] [-ttl <time-to-live>]] [-listDirectives [-stats] [-path <path>] [-pool <pool>] [-id <id>] [-removeDirective <id>] [-removeDirectives -path <path>] [-addPool <name> [-owner <owner>] [-group <group>] [-mode <mode>] [-limit <limit>] [-maxTtl <maxTtl>] [-modifyPool <name> [-owner <owner>] [-group <group>] [-mode <mode>] [-limit <limit>] [-maxTtl <maxTtl>]] [-removePool <name>] [-listPools [-stats] [<name>]] [-help <command-name>] # pool 등록 $ hdfs cacheadmin -addPool pool1 Successfully added cache pool pool1. # path 등록 $ hdfs cacheadmin -addDirective -path /user/hadoop/shs -pool pool1 Added cache directive 1 # 캐시 확인 hdfs cacheadmin -listDirectives Found 1 entry ID POOL REPL EXPIRY PATH 1 pool1 1 never /user/hadoop/shs 2. 세컨더리 네임노드 네임노드가 구동되고 나면 Edits 파일이 주기적으로 생성됩니다. 네임노드의 트랜잭션이 빈번하면 빠른 속도로 Edits 파일이 생성됩니다. 이는 네임노드의 디스크 부족 문제를 생성할 수도 있고, 네임노드가 재구동 되는 시간을 느려지게 할 수도 있습니다. 세컨더리 네임노드는 Fsimage와 Edits 파일을 주기적으로 머지 하여 최신 블록의 상태로 파일을 생성합니다. 파일을 머지 하면서 Edits 파일을 삭제하기 때문에 디스크 부족 문제도 해결할 수 있습니다. 02-HDFS Federation 네임노드는 파일 정보 메타데이터를 메모리에서 관리합니다. 파일이 많아지면 메모리 사용량이 늘어나게 되고, 메모리 관리가 문제가 됩니다. 이를 해결하기 위해 하둡 v2부터 HDFS 페더레이션을 지원합니다. HDFS 페더레이션은 디렉터리(네임스페이스) 단위로 네임노드를 등록하여 사용하는 것입니다. 예를 들어 user, hadoop, tmp 세 개의 디렉터리가 존재할 때, /user, /hadoop, /tmp 디렉터리 단위로 총 3개의 네임노드를 실행하여 파일을 관리하게 하는 것입니다. HDFS 페더레이션을 사용하면 파일, 디렉터리의 정보를 가지는 네임스페이스와 블록의 정보를 가지는 블록 풀을 각 네임노드가 독립적으로 관리합니다. 네임스페이스와 블록 풀을 네임스페이스 볼륨이라 하고 네임스페이스 볼륨은 독립적으로 관리되기 때문에 하나의 네임노드에 문제가 생겨도 다른 네임노드에 영향을 주지 않습니다. 참고 HDFS Federation 참고 HDFS Federation 설정 03-HDFS 고가용성 HDFS는 네임노드가 단일 실패 지점입니다. 네임노드에 문제가 발생하면 모든 작업이 중지되고, 파일을 읽거나 쓸 수 없게 됩니다. 하둡 v2에서 이 문제를 해결하기 위해서 HDFS 고가용성(High Availability)을 제공합니다. HDFS 고가용성은 이중화된 두 대의 서버인 액티브(active) 네임노드와 스탠바이(standby) 네임노드를 이용하여 지원합니다. 액티브 네임노드와 스탠바이 네임노드는 데이터 노드로부터 블록 리포트와 하트비트를 모두 받아서 동일한 메타데이터를 유지하고, 공유 스토리지를 이용하여 에디트 파일을 공유합니다. 액티브 네임노드는 네임노드의 역할을 수행하고, 스탠바이 네임노드는 액티브 네임노드와 동일한 메타데이터 정보를 유지하다가, 액티브 네임노드에 문제가 발생하면 스탠바이 네임노드가 액티브 네임노드로 동작하게 됩니다. 액티브 네임노드에 문제가 발생하는 것을 자동으로 확인하는 것이 어렵기 때문에 보통 주키퍼를 이용하여 장애 발생 시 자동으로 변경될 수 있도록 합니다. 스탠바이 네임노드는 세컨더리 네임노드의 역할을 동일하게 수행합니다. 따라서 HDFS를 고가용성 모드로 설정하였을 때는 세컨더리 네임노드를 실행하지 않아도 됩니다. 고가용성 모드에서 세컨더리 네임노드를 실행하면 오류가 발생합니다. QJM(Quorum Journal Manager) QJM은 HDFS 전용 구현체로, 고가용성 에디트 로그를 지원하기 위한 목적으로 설계되었고 HDFS의 권장 옵션입니다. QJM은 저널 노드 그룹에서 동작하며, 각 에디트 로그는 전체 저널 노드에 동시에 쓰입니다. 일반적으로 저널 노드는 세 개로 구성하며, 그중 하나가 손상되어도 문제가 없는 시스템입니다. 이러한 방식은 주키퍼의 작동 방식과 매우 유사하지만 QJM은 주키퍼를 사용하지 않고도 이런 기능을 구현했다는 점이 중요하다. 물론 HDFS 고가용성은 액티브 네임노드를 선출하기 위해 주키퍼를 이용합니다. 스탠바이 네임노드를 활성화시키는 전환 작업은 장애 복구 컨트롤러(failover controller)라는 새로운 객체로 관리됩니다. 다양한 방법으로 장애 복구 컨트롤러를 구현할 수 있지만, 기본 설정은 단 하나의 네임노드만 활성 상태에 있다는 것을 보장하기 위해 주키퍼를 이용합니다. NFS(Network File System) NFS를 이용하는 방법은 에디트 파일을 공유 스토리지를 이용하여<NAME>는 방법입니다. 공유 스토리지에 에디트 로그를<NAME>고 펜싱을 이용하여 하나의 네임노드만 에디트 로그를 기록하도록 합니다. 참고 HDFS High Availability With QJM HDFS High Availability With NFS 하둡 네임노드 이중화 시 fencing의 역할 04-HDFS 세이프 모드 HDFS의 세이프 모드(safemode)는 데이터 노드를 수정할 수 없는 상태입니다. 세이프 모드가 되면 데이터는 읽기 전용 상태가 되고, 데이터 추가와 수정이 불가능하며 데이터 복제도 일어나지 않습니다. 관리자가 서버 운영 정비를 위해 세이프 모드를 설정할 수도 있고, 네임노드에 문제가 생겨서 정상적인 동작을 할 수 없을 때 자동으로 세이프 모드로 전환됩니다. 세이프 모드에서 파일 수정은 다음과 같이 오류를 출력합니다. $ hadoop fs -put ./sample.txt /user/sample.txt put: Cannot create file/user/sample2.txt._COPYING_. Name node is in safe mode. 세이프 모드 커맨드 세이프 모드 상태의 확인, 진입, 해제 커맨드는 다음과 같습니다. # 세이프 모드 상태 확인 $ hdfs dfsadmin -safemode get Safe mode is OFF # 세이프 모드 진입 $ hdfs dfsadmin -safemode enter Safe mode is ON # 세이프 모드 해제 $ hdfs dfsadmin -safemode leave Safe mode is OFF 세이프 모드의 복구 HDFS 운영 중 네임노드 서버에 문제가 생겨서 세이프 모드에 진입하는 경우는 네임노드 자체의 문제와 데이터 노드의 문제일 경우가 많습니다. fsck 명령으로 HDFS의 무결성을 체크하고, hdfs dfsadmin -report 명령으로 각 데이터 노드의 상태를 확인하여 문제를 확인하고 해결한 후 세이프 모드를 해제하면 됩니다. 05-HDFS 데이터 블록 관리 HDFS 운영 중 데이터 노드에 문제가 생기면, 데이터 블록에 문제가 발생할 수 있습니다. 커럽트(CORRUPT) 상태와 복제 개수 부족(Under replicated) 상태입니다. 커럽트 블록 HDFS는 하트비트를 통해 데이터 블록에 문제가 생기는 것을 감지하고 자동으로 복구를 진행합니다. 다른 데이터 노드에 복제된 데이터를 가져와서 복구합니다. 하지만 모든 복제 블록에 문제가 생겨서 복구하지 못하게 되면 커럽트 상태가 됩니다. 커럽트 상태의 파일들은 삭제하고, 원본 파일을 다시 HDFS에 올려주어야 합니다. 커럽트 상태 확인 HDFS 커맨드의 fsck를 이용하여 상태를 체크할 수 있습니다. 커럽트 상태의 블록과 복제 개수가 부족한 블록의 정보를 확인할 수 있습니다. # 루트의 상태 체크 $ hdfs fsck / # /user/hadoop/ 디렉터리의 상태 체크 $ hdfs fsck /user/hadoop/ Status: HEALTHY Total size: 1378743129 B Total dirs: 612 Total files: 2039 Total symlinks: 0 Total blocks (validated): 2039 (avg. block size 676185 B) Minimally replicated blocks: 2039 (100.0 %) Over-replicated blocks: 0 (0.0 %) Under-replicated blocks: 2039 (100.0 %) Mis-replicated blocks: 0 (0.0 %) Default replication factor: 2 Average block replication: 1.0 Corrupt blocks: 0 Missing replicas: 4004 (66.258484 %) Number of data-nodes: 1 Number of racks: 1 FSCK ended at Thu Dec 06 05:31:42 UTC 2018 in 37 milliseconds The filesystem under path '/user/hadoop' is HEALTHY 상태를 확인하고, 커럽트 상태 이면 hdfs fsck -delete 명령을 이용하여 커럽트 상태의 블록을 삭제합니다. 커럽트 상태의 방지를 위해서 중요한 파일은 복제 개수를 늘려주면 좋습니다. hadoop fs -setrep 명령을 이용하여 처리합니다. The filesystem under path '/user/hadoop' is CORRUPT # 커럽트 상태의 파일 삭제 $ hdfs fsck -delete # /user/hadoop/의 복제 개수를 5로 조정 $ hadoop fs -setrep 5 /user/hadoop/ # /user/hadoop/ 하위의 모든 파일의 복제 개수를 조정 $ hadoop fs -setrep 5 -R /user/hadoop/ 복제 개수 부족 상태 복제개수 부족 상태는 파일에 지정된 복제 개수만큼 데이터 블록에 복제되지 않았을 때 발생합니다. 데이터 노드의 개수보다 복제 개수를 많이 지정했을 때 발생할 수 있습니다. fsck 명령으로 복제 개수가 부족한 파일을 확인할 수 있습니다. 복제개수가 부족한 파일은 복제 개수를 늘려주면 됩니다. hadoop fs -setrep 명령을 이용하여 처리합니다. # /user/hadoop/의 복제 개수를 5로 조정 $ hadoop fs -setrep 5 /user/hadoop/ # /user/hadoop/ 하위의 모든 파일의 복제 개수를 조정 $ hadoop fs -setrep 5 -R /user/hadoop/ 06-HDFS 휴지통 HDFS는 사용자의 실수에 의한 파일 삭제를 방지하기 위해서 휴지통 기능을 제공합니다. 휴지통 기능이 설정되면 HDFS에서 삭제한 파일은 바로 삭제되지 않고, 각 사용자의 홈 디렉터리 아래 휴지통 디렉토리(/user/유저명/.Trash)로 이동됩니다. 휴지통 아래의 파일은 복구할 수 있습니다. 휴지통 디렉터리는 지정한 간격으로 체크포인트가 생성되고, 유효 기간이 만료되면 체크포인트를 삭제합니다. 삭제되면 해당 블록을 해제하고, 사용자에게 반환합니다. 휴지통 설정 휴지통 관련 설정은 다음과 같습니다. 설정값 비고 fs.trash.interval 체크포인트를 삭제하는 시간 간격(분). 0이면 휴지통 기능을 끔. fs.trash.checkpoint.interval 체크포인트를 확인하는 간격(분). fs.trash.interval과 같거나 작아야 함. 체크 포인터가 실행될 때마다 체크포인트를 생성하고, 유효기간이 지난 체크포인트는 삭제. 휴지통 설정값 core-site.xml에 아래와 같이 설정합니다. <property> <name>fs.trash.interval</name> <value>1440</value> </property> <property> <name>fs.trash.checkpoint.interval</name> <value>120</value> </property> 휴지통 명령 # 휴지통을 비움. $ hadoop fs -expunge # 휴지통을 이용하지 않고 삭제 $ hadoop fs -rm -skipTrash /user/data/file 참고 HDFS 휴지통 설정: 바로 가기 07-HDFS 명령어 HDFS 커맨드는 사용자 커맨드, 운영자 커맨드, 디버그 커맨드로 구분됩니다. 각 모드마다 다양한 커맨드가 있지만 여기서는 사용 및 운영에 필수적인 몇 가지 커맨드만 확인하겠습니다. 전체 커맨드의 목록은 HDFS Commands Guide1을 참고하십시오. 사용자 커맨드 사용자 커맨드 목록 dfs 커맨드 dfs 커맨드 명령어 cat text ls mkdir cp mv get put rm setrep test touchz stat setfacl getfacl count fsck 커맨드 fsck 커맨드 명령어 사용법 운영자 커맨드 운영자 커맨드 목록 fsck 커맨드 명령어 dfsadmin 커맨드 사용법 전체 명령어 -report -safemode -triggerBlockReport fetchdt checknative 사용자 커맨드 사용자 커맨드는 hdfs, hadoop 쉘을 이용할 수 있습니다. 일부 커맨드는 hdfs 쉘을 이용해야 합니다. 둘 다 이용할 수 있는 경우 각 쉘의 결과는 동일하며, 사용법은 다음과 같습니다. # dfs 커맨드는 둘 다 동일한 결과를 출력 $ hdfs dfs -ls $ hadoop fs -ls # fsck 커맨드도 동일한 결과 출력 $ hdfs fsck / $ hadoop fsck / # fs.defaultFS 설정값 확인 $ hdfs getconf -confKey fs.defaultFS hdfs://127.0.0.1:8020 # 명령어를 인식하지 못함 $ hadoop getconf Error: Could not find or load main class getconf 사용자 커맨드 목록 커맨드 비고 classpath Hadoop jar 파일에 필요한 클래스 패스 출력 dfs 파일 시스템 쉘 명령어 fetchdt 네임노드의 델리게이션 토큰 확인 fsck 파일 시스템 상태 체크 getconf 설정된 Config 정보 확인 groups 사용자에 설정된 그룹 정보 확인 lsSnapshottableDir 스냅샷이 가능한 디렉터리 목록 확인 jmxget JMX 인포메이션 확인 oev Offline Edits Viewr, Edits 파일의 상태 확인 oiv Offline Image Viewr, 이미지 파일의 상태 확인(2.4 이상) oiv_legacy oiv 2.4 미만의 상태 확인 snapshotDiff HDFS 스냅샷의 상태 확인 version 버전 확인 이 명령어 중에서 필수적인 dfs와 fsck 커맨드에 대해서 확인해 보겠습니다. dfs 커맨드 dfs 커맨드는 파일시스템 쉘을 실행하는 명령어입니다. dfs는 hdfs dfs, hadoop fs, hadoop dfs 세 가지 형태로 실행이 가능합니다. 전체 명령어는 파일시스템쉘 가이드(바로 가기)를 확인하시면 됩니다. 명령어의 사용법은 다음과 같습니다. $ hdfs dfs -ls Found 17 items drwxr-xr-x - hadoop hadoop 0 2018-11-30 06:15 datas $ hadoop fs -ls Found 17 items drwxr-xr-x - hadoop hadoop 0 2018-11-30 06:15 datas dfs 커맨드 명령어 명령어 비고 cat 파일의 내용을 확인 text 텍스트<NAME>으로 파일을 읽음, 압축 파일도 텍스트<NAME>으로 확인 appendToFile 지정한 파일에 내용을 추가(append) checksum 파일의 체크 섬 확인 chgrp 파일의 그룹 변경 chmod 파일의 모드 변경 chown 파일의 소유권 변경 count 지정한 경로의 디렉터리 개수, 파일 개수, 파일 사이즈 확인 df 파일시스템의 용량 확인(복제본을 포함한 용량) du 지정한 경로의 용량 확인(단일 파일의 용량) dus 지정한 경로의 하위 폴더를 포함한 용량 확인 expunge 휴지통을 비움. 파일을 영구히 삭제. getfacl 디렉터리, 파일의 ACL(Access Control List) 확인 setfacl 디렉터리, 파일의 ACL(Access Control List) 설정 getfattr 디렉터리, 파일의 추가적인 속성 확인 setfattr 디렉터리, 파일의 추가적인 속성 설정 getmerge 주어진 경로의 파일들을 로컬의 파일로 머지 find 주어진 표현에 맞는 파일을 조회 ls 디렉터리의 파일 조회 lsr 디렉터리 하위의 파일을 포함하여 조회 mkdir 디렉터리 생성 copyFromLocal 로컬의 파일을 HDFS로 복사 copyToLocal HDFS의 파일을 로컬로 복사 cp 주어진 경로로 파일을 복사 moveFromLocal 로컬의 파일을 HDFS로 이동 moveToLocal HDFS의 파일을 로컬로 이동 mv 주어진 경로의 파일을 이동, 파일 이름 변경에도 이용 get copyToLocal 명령과 비슷 put copyFromLocal 명령과 비슷 createSnapshot 스냅샷 생성 deleteSnapshot 스냅샷 삭제 renameSnapshot 스냅샷 이름 변경 rm 파일 삭제 rmdir 디렉터리 삭제 rmr 주어진 경로의 하위 경로까지 삭제 setrep 레플리케이션 팩터 설정 stat 주어진 옵션에 따라 파일의 정보를 확인 tail 파일의 마지막 1kbyte를 출력 test 주어진 옵션에 따라 파일, 디렉터리의 존재 여부 확인 touchz 0byte 파일 생성 truncate 주어진 패턴에 따라 파일 삭제 usage 주어진 명령어 사용법 확인 help 명령어 사용법 확인 df는 복제개수를 포함한 전체의 용량을 표현하고, du 단일 파일 또는 경로의 용량입니다. 1M 파일의 용량을 du로 확인하면 1M으로 나오지만, df로 파일 시스템의 용량을 확인하면 복제개수가 3일 때 3M으로 표현됩니다. 이 중에서 주요 명령어의 사용법을 확인해 보겠습니다. cat 지정한 파일을 기본 입력으로 읽어서 출력합니다. $ hadoop fs -cat /user/file.txt text 지정한 파일을 텍스트<NAME>으로 읽습니다. gzip, snappy 등의<NAME>으로 압축된 파일을 자동으로 텍스트<NAME>으로 출력해 줍니다. $ hadoop fs -text /user/file.txt ls 주어진 경로의 파일 목록을 조회합니다. 주요 옵션: -h, -R,-u $ hadoop fs -ls /user/ # 사람이 읽을 수 있는 형태로 파일 사이즈를 메가, 기가로 변경하여 출력 $ hadoop fs -ls -h /user/ # 하위 폴더까지 조회 $ hadoop fs -ls -R /user/ # 액세스 시간을 조회. 기본 설정은 생성 시간. 마지막 접근 시간을 확인하여 파일 정리 가능 $ hadoop fs -ls -u /user/ mkdir 디렉터리를 생성합니다. 주요 옵션: -p $ hadoop fs -mkdir /user/folder # /user/folder1/folder2를 생성, 상위 폴더가 없으면 자동으로 생성 $ hadoop fs -mkdir -p /user/folder1/folder2 cp HDFS 상의 파일을 복사합니다. $ hadoop fs -cp /user/data1.txt /user/data2.txt mv HDFS 상의 파일을 이동합니다. 파일 이름을 변경할 때도 사용합니다. $ hadoop fs -mv /user/data1.txt /user/data2.txt get HDFS의 파일을 로컬에 복사할 때 사용합니다. 주요 옵션: -f $ hadoop fs -get /user/data1.txt ./ # 동일한 이름의 파일이 존재하면 덮어씀 $ hadoop fs -get -f /user/data1.txt ./ put 로컬의 파일을 HDFS에 복사할 때 사용합니다. 주요 옵션: -f $ hadoop fs -put ./data1.txt /user/ # 동일한 이름의 파일이 존재하면 덮어씀 $ hadoop fs -put -f ./data1.txt /user/ rm HDFS의 파일을 삭제할 때 사용합니다. 주요 옵션: -r, -spkipTrash $ hadoop fs -rm /user/data1.txt # 디렉터리를 포함하여 하위의 모든 파일을 삭제, 디렉터리 삭제 시 필요함 $ hadoop fs -rm -r /user/ # 쓰레기통을 사용하지 않고 파일 삭제 $ hadoop fs -skipTrash /user/ setrep 디렉터리, 파일의 레플리케이션 팩터를 수정합니다. 주요 옵션: -R # 디렉터리의 복제개수를 5로 설정 $ hadoop fs -setrep 5 /user/ # 하위의 모든 디렉터리, 파일의 복제개수를 5로 설정 $ hadoop fs -setrep 5 -R /user/ test 파일, 디렉터리의 존재 여부를 확인합니다. # -d: 경로가 디렉터리이면 0을 반환합니다. # -e: 경로가 있으면 0을 반환합니다. # -f: 경로가 파일이면 0을 반환합니다. # -s: 경로가 비어 있지 않으면 0을 반환합니다. # -w: 경로가 존재하고 쓰기 권한이 부여된 경우 0을 반환합니다. # -r: 경로가 존재하고 읽기 권한이 부여된 경우 0을 반환합니다. # -z: 파일 길이가 0이면 0을 반환합니다. # /user/test.txt 파일이 존재하면 0을 반환 $ hadoop fs -test -e /user/test.txt touchz 0byte 파일을 생성합니다. $ hadoop fs -touchz /user/test.txt stat 주어진 포맷에 따른 파일의 정보를 확인합니다. # 주요 포맷 # %y : 마지막 수정 시간 # %x : 마지막 접근 시간 # %n : 파일 이름 # %b : 파일 사이즈 (byte) $ hadoop fs -stat "%y %n" hdfs://127.0.0.1:8020/* setfacl 파일의 ACL을 설정합니다. ls 명령으로 확인할 수 있는 파일의 권한과 별도로 권한을 설정할 수 있습니다. # -m: 권한을 수정 # -b: 설정한 권한을 삭제 # user a에게 /user/file의 읽기(r), 쓰기(w) 권한을 줌 $ hadoop fs -setfacl -m user:a:rw- /user/file # /user/file에서 신규로 생성되는 파일, 디렉터리에 대하여 user a에게의 읽기(r), 쓰기(w) 권한을 줌 $ hadoop fs -setfacl -m default:user:a:rw- /user/file getfacl 파일의 ACL을 확인합니다. $ hadoop fs -getfacl /user/file # file: hdfs:///user/file # owner: c # group: g user::rw- user:a:rw- group::r-- mask::rw- other::--- count 지정한 경로의 디렉터리 개수, 파일 개수, 파일 사이즈 확인합니다. -q, -v 옵션과 함께 사용하여 더 많은 정보를 확인할 수 있습니다. # 디렉터리 개수 150 # 파일 개수 2000 # 디렉터리 용량 123456789 $ hadoop fs -count /user 150 2000 123456789 hdfs:///user # -h 사용자가 읽기 편하게 변환 # -q 디렉터리의 쿼터 정보 확인: QUOTA, REMAINING_QUOTA, SPACE_QUOTA, REMAINING_SPACE_QUOTA, DIR_COUNT, FILE_COUNT, CONTENT_SIZE, PATHNAME # -u 디렉터리의 쿼터 정보 확인: QUOTA, REMAINING_QUOTA, SPACE_QUOTA, REMAINING_SPACE_QUOTA, PATHNAME # -v는 -q, -u와 함께 사용하면 헤더를 함께 출력합니다. $ hadoop fs -count -q -v hdfs:///user/sample QUOTA REM_QUOTA SPACE_QUOTA REM_SPACE_QUOTA DIR_COUNT FILE_COUNT CONTENT_SIZE PATHNAME 8000000 471204 109951162777600 99303499783522 286862 7241934 3549220998026 hdfs:///user/sample fsck 커맨드 fsck 커맨드는 HDFS 파일시스템의 상태를 체크하는 명령어입니다. fsck 커맨드는 파일시스템에 블록 상태 확인, 파일의 복제 개수를 확인하여 결과를 알려줍니다. 일반적으로 네임노드가 자동으로 상태를 복구하기 위한 작업을 진행하기 때문에 fsck 커맨드가 오류를 확인해도 상태를 정정하지는 않습니다. fsck 커맨드 명령어 커맨드 비고 path 체크를 위한 경로 -list-corruptfileblocks 커럽트 상태의 블록을 출력 -delete 커럽트 파일 삭제 -move 커럽트 블록을 /lost+found 폴더로 이동 -files 체크한 파일 출력 -files -blocks 블록 리포트 출력 -files -blocks -locations 블록의 위치를 출력 -files -blocks -racks 블록의 랙 정보 출력 -files -blocks -replicaDetails 복제 개수 정보 출력 -files -blocks -upgradedomains 블록의 도메인을 갱신 -includeSnapshots 스냅샷을 포함해서 체크 -openforwrite 쓰기 작업을 위해 열린 파일 출력 -storagepolicies 블록의 저장 정책 출력 -maintenance 블록의 관리 정보 출력 -blockId 블록 ID 출력 사용법 fsck 커맨드는 우선 를 지정해야 합니다. 파일 시스템의 상태를 체크할 경로를 지정하고 필요한 명령어를 입력하면 됩니다. fsck 커맨드로 파일 시스템의 상태를 확인하고, -delete 커맨드로 오류가 난 파일을 삭제할 수 있습니다. $ hdfs fsck <path> [-list-corruptfileblocks [-move | -delete | -openforwrite] [-files [-blocks [-locations | -racks]]]] [-includeSnapshots] [-storagepolicies] [-blockId <blk_Id>] $ hdfs fsck / $ hdfs fsck /user/hadoop/ $ hdfs fsck /user -list-corruptfileblocks $ hdfs fsck /user -delete $ hdfs fsck /user -files $ hdfs fsck /user -files -blocks $ hdfs fsck / Status: HEALTHY Total size: 7683823089 B Total dirs: 3534 Total files: 14454 Total symlinks: 0 Total blocks (validated): 14334 (avg. block size 536055 B) Minimally replicated blocks: 14334 (100.0 %) Over-replicated blocks: 0 (0.0 %) Under-replicated blocks: 14334 (100.0 %) Mis-replicated blocks: 0 (0.0 %) Default replication factor: 2 Average block replication: 1.0 Corrupt blocks: 0 Missing replicas: 31288 (68.58095 %) Number of data-nodes: 1 Number of racks: 1 FSCK ended at Fri Dec 28 04:07:32 UTC 2018 in 172 milliseconds 운영자 커맨드 운영자 커맨드도 hdfs, hadoop 쉘을 이용할 수 있습니다. 일부 커맨드는 hdfs 쉘을 이용해야 합니다. 둘 다 이용할 수 있는 경우 각 쉘의 결과는 동일하며, 사용법은 다음과 같습니다. # 둘 다 balancer를 실행 $ hdfs balancer $ hadoop balancer 운영자 커맨드 목록 운영자 커맨드는 주로 실행, 설정 관련 명령어가 많습니다. 각 명령어의 주요 옵션은 Administration Commands2를 확인하면 됩니다. 커맨드 비고 namenode 네임노드 실행 datanode 데이터 노드 실행 secondarynamenode 세컨더리 네임노드 실행 balancer HDFS 밸렁싱 처리 cacheadmin 자주 읽는 데이터에 대한 캐시 처리 crypto 암호화 처리 dfsadmin HDFS 관리를 위한 Admin 유틸리티 명령 dfsrouter HDFS 연합 라우팅 실행 dfsrouteradmin 데이터 노드 라우팅 설정 haadmin HA 실행 명령어(QJM 또는 NFS) journalnode QJM을 이용한 HA, 저널노드용 명령어 mover 데이터 마이그레이션용 유틸리티 명령어 nfs3 NFS3 게이트웨이 명령어 portmap NFS3 게이트웨이 포트 맵 명령어 storagepolicies HDFS 저장 정책 설정 명령어 zkfc 주키퍼 FailOver 컨트롤러 실행 fsck 커맨드 명령어 HDFS의 상태를 체크합니다. 커럽트 파일, 언더 레플리케이트 상태의 파일을 확인합니다. # 루트 디렉터리부터 hdfs의 상태를 체크 $ hdfs fsck / dfsadmin 커맨드 dfsadmin 커맨드는 hdfs의 관리를 위한 정보를 설정 및 변경할 수 있습니다. 쿼터(Quota) 설정, 노드들의 리프레시, 노드들의 동작 및 정지등을 처리할 수 있습니다. 주요 명령어는 다음과 같습니다. 사용법 dfsadmin 커맨드가 가지고 있는 명령어는 다음과 같이 다양합니다. 주요 명령어의 사용 방법을 알아보겠습니다. 전체 명령어 $ hdfs dfsadmin Usage: hdfs dfsadmin Note: Administrative commands can only be run as the HDFS superuser. [-report [-live] [-dead] [-decommissioning]] [-safemode <enter | leave | get | wait>] [-saveNamespace] [-rollEdits] [-restoreFailedStorage true|false|check] [-refreshNodes] [-setQuota <quota> <dirname>...<dirname>] [-clrQuota <dirname>...<dirname>] [-setSpaceQuota <quota> [-storageType <storagetype>] <dirname>...<dirname>] [-clrSpaceQuota [-storageType <storagetype>] <dirname>...<dirname>] [-finalizeUpgrade] [-rollingUpgrade [<query|prepare|finalize>]] [-refreshServiceAcl] [-refreshUserToGroupsMappings] [-refreshSuperUserGroupsConfiguration] [-refreshCallQueue] [-refresh <host:ipc_port> <key> [arg1.. argn] [-reconfig <datanode|...> <host:ipc_port> <start|status>] [-printTopology] [-refreshNamenodes datanode_host:ipc_port] [-deleteBlockPool datanode_host:ipc_port blockpoolId [force]] [-setBalancerBandwidth <bandwidth in bytes per second>] [-fetchImage <local directory>] [-allowSnapshot <snapshotDir>] [-disallowSnapshot <snapshotDir>] [-shutdownDatanode <datanode_host:ipc_port> [upgrade]] [-getDatanodeInfo <datanode_host:ipc_port>] [-metasave filename] [-triggerBlockReport [-incremental] <datanode_host:ipc_port>] [-help [cmd]] -report HDFS의 각 노드들의 상태를 출력합니다. HDFS의 전체 사용량과 각 노드의 상태를 확인할 수 있습니다. Configured Capacity: 각 데이터 노드에서 HDFS에서 사용할 수 있게 할당된 용량 Present Capacity: HDFS에서 사용할 수 있는 용량 Configured Capacity에서 Non DFS Used 용량을 뺀 실제 데이터 저장에 이용할 수 있는 용량 DFS Remaining: HDFS에서 남은 용량 DFS Used: HDFS에 저장된 용량 Non DFS Used: 맵리듀스 임시 파일, 작업 로그 등 데이터 노드에 저장된 블록 데이터가 아닌 파일의 용량 Xceivers: 현재 작업 중인 블록의 개수 $ hdfs dfsadmin -report Configured Capacity: 165810782208 (154.42 GB) Present Capacity: 152727556096 (142.24 GB) DFS Remaining: 140297670656 (130.66 GB) DFS Used: 12429885440 (11.58 GB) DFS Used%: 8.14% Under replicated blocks: 18861 Blocks with corrupt replicas: 0 Missing blocks: 0 Missing blocks (with replication factor 1): 0 ------------------------------------------------- Live datanodes (1): Name: x.x.x.x:50010 (data_node) Hostname: data_node Decommission Status : Normal Configured Capacity: 165810782208 (154.42 GB) DFS Used: 12429885440 (11.58 GB) Non DFS Used: 13083226112 (12.18 GB) DFS Remaining: 140297670656 (130.66 GB) DFS Used%: 7.50% DFS Remaining%: 84.61% Configured Cache Capacity: 0 (0 B) Cache Used: 0 (0 B) Cache Remaining: 0 (0 B) Cache Used%: 100.00% Cache Remaining%: 0.00% Xceivers: 2 Last contact: Thu Apr 25 08:29:50 UTC 2019 -safemode 세이프 모드에 진입하고 빠져나올 수 있습니다. 옵션 비고 get 세이프 모드 상태를 확인 enter 세이프 모드 진입 leave 세이프 모드 복구 wait 세이프 모드이면 대기하다가, 세이프 모드가 끝나면 회복 $ hdfs dfsadmin -safemode get Safe mode is OFF $ hdfs dfsadmin -safemode enter Safe mode is ON $ hdfs dfsadmin -safemode get Safe mode is ON $ hdfs dfsadmin -safemode leave Safe mode is OFF $ hdfs dfsadmin -safemode wait Safe mode is OFF -triggerBlockReport 데이터노드에게 블록 리포트를 전달하도록 합니다. $ hdfs dfsadmin -triggerBlockReport datanode_host_name:datanode_ipc_port fetchdt HDFS에 접속하기 위한 델리게이션 토큰을 획득하기 위한 명령입니다. 커버 로스 인증이 설정된 HDFS 환경에서 커버 로스 인증을 획득한 후 토큰을 발급받아서 커버 로스 인증 없이 HDFS에 접근할 수 있습니다. # 토큰 파일로 발급 $ hdfs fetchdt token_file # 생성된 파일을 환경 변수로 설정 export HADOOP_TOKEN_FILE_LOCATION=[경로]/token_file # 데이터 조회 시 토큰 파일을 이용하게 됨 hadoop fs -ls hdfs:///user checknative 서버에 설치된 네이티브 압축 라이브러리 상태를 확인합니다. core-site.xml의 io.compression.codecs에 설정된 압축 라이브러리를 사용하기 위해서는 네이티브 라이브러리가 설치되어 있어야 하는데, 이 라이브러리 존재 여부를 확인할 때 사용합니다. $ hadoop checknative -a Native library checking: hadoop: true /opt/hadoop-2.10.0/lib/native/libhadoop.so.1.0.0 zlib: true /lib64/libz.so.1 snappy: true /lib64/libsnappy.so.1 zstd : true /lib64/libzstd.so.1 lz4: true revision:10301 bzip2: true /lib64/libbz2.so.1 openssl: false EVP_CIPHER_CTX_cleanup core-site.xml의 설정은 다음과 같습니다. <configuration> <property> <name>io.compression.codecs</name> <value>org.apache.hadoop.io.compress.GzipCodec, org.apache.hadoop.io.compress.DefaultCodec, org.apache.hadoop.io.compress.SnappyCodec</value> </property> </configuration> HDFSCommands 매뉴얼: 바로 가기 ↩ Administration Commands: 바로 가기 ↩ 08-WebHDFS REST API 사용법 HDFS는 REST API를 이용하여 파일을 조회하고, 생성, 수정, 삭제하는 기능을 제공합니다. 이 기능을 이용하여 원격지에서 HDFS의 내용에 접근하는 것이 가능합니다. 처리 가능한 명령어는 WebHDFS 공식 문서를 확인 바랍니다. 1 REST API 설정 REST API를 사용하기 위해서는 hdfs-site.xml에 다음의 설정이 되어 있어야 합니다. <property> <name>dfs.webhdfs.enabled</name> <value>true</value> </property> <property> <name>dfs.namenode.http-address</name> <value>0.0.0.0:50070</value> </property> 파일 리스트 확인 위에서 설정한 http 포트로 요청을 날리면 json<NAME>으로 결과를 반환합니다. curl 명령을 이용하여 요청을 처리하는 방법은 다음과 같습니다. # /user/hadoop/ 위치를 조회 $ curl -s http://127.0.0.1:50070/webhdfs/v1/user/hadoop/?op=LISTSTATUS https://hadoop.apache.org/docs/stable/hadoop-project-dist/hadoop-hdfs/WebHDFS.html ↩ 09-HDFS 암호화 HDFS는 민감정보의 보안을 위해 암호화 기능을 제공 1 합니다. 암호화를 적용하면 디스크에 저장되는 파일을 암호화하여 저장하고, HDFS의 디렉터리에 접근할 때 하둡 KMS를 이용하여 키 기반으로 전송 데이터의 암/복호화를 지원합니다. 사용 예제 HDFS 암호화를 이용하는 방법은 다음과 같습니다. # 암호화 키 생성 $ hadoop key create mykey # zone 디렉터리 생성하고 암호화 지역으로 설정, mykey를 이용하도록 설정 $ hadoop fs -mkdir /zone $ hdfs crypto -createZone -keyName mykey -path /zone # 키 확인 $ hadoop key list Listing keys for KeyProvider: org.apache.hadoop.crypto.key.kms.LoadBalancingKMSClientProvider mykey # 암호화 지역 확인 $ hdfs crypto -listZones /zone sample_key # As the normal user, put a file in, read it out $ hadoop fs -put helloWorld /zone $ hadoop fs -cat /zone/helloWorld # As the normal user, get encryption information from the file $ hdfs crypto -getFileEncryptionInfo -path /zone/helloWorld console output: {cipherSuite: {name: AES/CTR/NoPadding, algorithmBlockSize: 16}, cryptoProtocolVersion: CryptoProtocolVersion{description='Encryption zones', version=1, unknownValue=null}, edek: 2010d301afbd43b58f10737ce4e93b39, iv: ade2293db2bab1a2e337f91361304cb3, keyName: mykey, ezKeyVersionName: mykey@0} 하둡 KMS REST API 하둡 KMS2는 REST API 서버도 제공합니다. 9700 포트가 기본 포트입니다. curl http://$(hostname -f):9700/kms/v1/keys/names Transparent Encryption in HDFS ↩ Hadoop Key Management Server(KMS) ↩ 10-HDFS 사용량 제한 설정 HDFS 관리자는 디렉터리 별로 파일 개수와 파일 용량을 제한 1 할 수 있습니다. 각 설정은 개별 적으로 동작합니다. 하나만 설정하거나, 동시에 설정할 수 있습니다. 파일 개수 제한 디렉터리 별로 생성할 수 있는 파일 개수를 제한할 수 있습니다. 할당량을 초과하면 파일, 디렉터리를 생성할 수 없습니다. 파일 용량 제한 디렉터리 별로 용량을 제한할 수 있습니다. 파일 용량만 포함되고, 디렉터리는 용량에 포함되지 않습니다. 제한 설정 명령 파일 개수 제한, 파일 용량 제한은 hdfs dfsadmin 명령을 이용하여 설정할 수 있습니다. # 파일 개수 제한. 최대 Long.MAX_VALUE 만큼 제한 가능 hdfs dfsadmin -setQuota <N> <directory>...<directory> # 파일 개수 제한 초기화 hdfs dfsadmin -clrQuota <directory>...<directory> # 파일 용량 제한. 최대 Long.MAX_VALUE 만큼 제한 가능 hdfs dfsadmin -setSpaceQuota <N> <directory>...<directory> # 파일 용량 제한 초기화 hdfs dfsadmin -clrSpaceQuota <directory>...<directory> 제한 명령 확인 디렉터리 별로 설정된 제한은 hadoop fs -count 명령을 이용하여 확인할 수 있습니다. # quota 설정 확인 $ hadoop fs -count -q -v hdfs:///user/d1 QUOTA REM_QUOTA SPACE_QUOTA REM_SPACE_QUOTA DIR_COUNT FILE_COUNT CONTENT_SIZE PATHNAME 1000000 27300 10000000000 100000000 98337 1171599 12314 hdfs:///user/d1 # QUOTA, REMAINING_QUOTA, SPACE_QUOTA, REMAINING_SPACE_QUOTA, PATHNAME $ hadoop fs -count -u hdfs:///user/d1 1000000 273022 10000000000 80000 hdfs:///user/d1 # HDFS Quotas Guide ↩ 11-데이터 압축 데이터 압축 여부와 사용할 압축<NAME>은 성능에 큰 영향을 줄 수 있습니다. 데이터 압축을 고려해야 할 가장 중요한 두 가지 장소는 MapReduce 작업 및 HBase에 저장된 데이터 측면입니다. 대부분의 경우 원칙은 서로 비슷합니다. 데이터를 압축 및 압축 해제하는 데 필요한 처리 용량, 데이터를 읽고 쓰는 데 필요한 디스크 IO 및 네트워크를 통해 데이터를 보내는 데 필요한 네트워크 대역폭의 균형을 유지해야 합니다. 이러한 요소의 올바른 균형은 사용 패턴뿐만 아니라 클러스터 및 데이터의 특성에 따라 다릅니다. 데이터가 이미 압축된 경우 압축하지 않는 것이 좋습니다 (예 : JPEG<NAME>의 이미지). 실제로 결과 파일은 실제로 원본보다 클 수 있습니다. 압축 유형 GZIP 압축은 Snappy 또는 LZO보다 많은 CPU 리소스를 사용하지만 더 높은 압축률을 제공합니다. GZip은 종종 콜드 데이터에 적합하며 드물게 액세스 됩니다. Snappy 또는 LZO는 자주 액세스하는 핫 데이터에 더 적합합니다. BZip2는 압축 및 압축 해제 시 약간의 속도로 일부 유형의 파일에 대해 GZip보다 더 많은 압축을 생성할 수 있습니다. HBase는 BZip2 압축을 지원하지 않습니다. Snappy는 종종 LZO보다 성능이 우수합니다. 유의미한 차이가 있는지 확인하기 위해 테스트를 실행할 가치가 있습니다. MapReduce의 경우 압축 데이터를 분할할 수 있어야 하는 경우 BZip2, LZO 및 Snappy<NAME>은 분할 가능하지만 GZip은 분할할 수 없습니다. 분할<NAME> HBase 데이터와 관련이 없습니다. MapReduce의 경우 중간 데이터, 출력 또는 둘 다를 압축할 수 있습니다. MapReduce 작업에 제공 한 매개 변수를 적절히 조정하십시오. 다음 예제는 중간 데이터와 출력을 모두 압축합니다. MR2가 먼저 표시된 다음 MR1이 표시됩니다. hadoop jar hadoop-examples-.jar sort "-Dmapreduce.compress.map.output=true" "-Dmapreduce.map.output.compression.codec=org.apache.hadoop.io.compress.GzipCodec" "-Dmapreduce.output.compress=true" "-Dmapreduce.output.compression.codec=org.apache.hadoop.io.compress.GzipCodec" -outKey org.apache.hadoop.io.Text -outValue org.apache.hadoop.io.Text input output 참고 Choosing a Data Compression Format 12-RPC HDFS는 서버와 클라이언트 간 통신에 RPC를 이용합니다. RPC는 Remote Procedure Call은 원격지에 있는 노드의 함수를 실행하여 결과를 반환받을 수 있습니다. Hadoop RPC, IPC Protection Hadoop RPC를 이용한 서버/클라이언트 구현 13-이레이져 코딩(EC) HDFS의 이레이저 코딩에 대해서 알아보겠습니다. 목적 HDFS는 3x 복제(원본 1개, 복제본 2개, 총 3개의 파일 유지)를 이용해서 내 결함성을 제공합니다. 복제는 저장 공간, 네트워크 대역폭 등에서 200%의 오베 헤드를 가지는 것으로 계산됩니다. 상대적으로 낮은 액세스 활동이 있는 콜드 데이터 세트의 경우 추가 블록 복제본은 거의 액세스 되지 않지만 다른 복제본과 동일한 양의 리소스를 소비합니다. EC(Erasure Coding)를 이용해서 이런 문제를 해결할 수 있습니다. EC는 훨씬 적은 저장 공간을 사용하여 동일한 수준의 내 결함성을 제공합니다. 일반적인 EC 설정에서 스토리지 오버헤드는 50% 이하입니다. EC는 파일의 복제 개수는 항상 1이며 setrep 명령을 통해 변경할 수 없습니다. 배경 스토리지 시스템에서 EC의 주요 용도는 RAID 구성입니다. RAID는 스트라이핑을 통해 EC를 구현합니다. 스트라이핑은 논리적으로 순차적인 데이터 (예 : 파일)를 더 작은 단위 (예 : 비트, 바이트 또는 블록)로 나누고 연속된 장치를 다른 디스크에 저장합니다. 원본 데이터 셀의 각 스트라이프에 대해 특정 수의 패리티 셀 이 계산되고 저장됩니다. 이 과정을 인코딩이라고 합니다. 모든 스트라이핑 셀의 오류는 남아있는 데이터 및 패리티 셀을 기반으로 계산을 디코딩 하여 복구할 수 있습니다. EC를 HDFS와 통합하면 기존 복제 기반 HDFS 배포와 유사한 데이터 내구성을 제공하면서 스토리지 효율성을 향상시킬 수 있습니다. 예를 들어, 6 개의 블록이 있는 3x 복제 파일은 6 * 3 = 18 블록의 디스크 공간을 사용합니다. 그러나 EC (6 데이터, 3 패리티) 배포를 사용하면 9 블록의 디스크 공간 만 사용합니다. 구조 EC의 스트라이핑에는 몇 가지 중요한 이점이 있습니다. 첫째, 온라인 EC (EC<NAME>으로 즉시 데이터 쓰기)를 가능하게 하여 변환 단계를 피하고 즉시 저장 공간을 절약합니다. 온라인 EC는 또한 여러 디스크 스핀들을 병렬로 활용하여 순차 I/O 성능을 향상시킵니다. 이것은 하이 엔드 네트워킹이 있는 클러스터에서 특히 바람직합니다. 둘째, 작은 파일을 여러 DataNode에 자연스럽게 배포하고 여러 파일을 단일 코딩 그룹으로 묶을 필요가 없습니다. 이렇게 하면 삭제, 할당량 보고 및 연합 네임 스페이스 간 마이그레이션과 같은 파일 작업이 크게 단순화됩니다. 배포 이레이저 코딩은 CPU 및 네트워크 측면에서 클러스터에 추가 요구 사항을 부과합니다. 인코딩 및 디코딩 작업은 HDFS 클라이언트와 데이터 노드 모두에서 추가 CPU를 사용합니다. 이레이저 코딩에는 구성된 EC 스트라이프 너비만큼 클러스터에 최소한 많은 DataNode가 필요합니다. EC 정책 RS (6,3)의 경우 이는 최소 9 개의 DataNode를 의미합니다. 삭제 코드 파일은 랙 내 결함성을 위해 랙에 분산되어 있습니다. 이는 스트라이프 파일을 읽고 쓸 때 대부분의 작업이 랙 외부에 있음을 의미합니다. 따라서 네트워크 대역폭은 매우 중요합니다. 랙 내 결함성을 위해 충분한 수의 랙을 갖는 것도 중요합니다. 그래야 평균적으로 각 랙이 EC 패리티 블록 수보다 많은 수의 블록을 보유할 수 있습니다. 이를 계산하는 공식은 (데이터 블록 + 패리티 블록) / 패리티 블록이며 반올림됩니다. EC 정책 RS (6,3)의 경우 이는 최소 3 개의 랙 ((6 + 3) / 3 = 3으로 계산), 이상적으로는 계획된 중단과 계획되지 않은 중단을 처리하는 데 9개 이상을 의미합니다. 패리티 셀 수보다 랙이 적은 클러스터의 경우 HDFS는 랙 내 결함성을 유지할 수 없지만 노드 수준 내 결함성을 유지하기 위해 스트라이프 파일을 여러 노드에 분산하려고 시도합니다. 이러한 이유로 유사한 수의 DataNode를 사용하여 랙을 설정하는 것이 좋습니다. 정책 구성 기본적으로 dfs.namenode.ec.system.default.policy에 정의된 정책을 제외하고 모든 이레이저 코딩 정책은 비활성화됩니다. 클러스터 관리자는 클러스터 크기 및 원하는 내 결함성 속성을 기반으로 hdfs ec [-enablePolicy -policy ] 명령을 통해 정책을 활성화할 수 있습니다. 예를 들어 9 개의 랙이 있는 클러스터의 경우 RS-10-4-1024k 와 같은 정책은 랙 수준 내 결함성을 유지하지 않으며 RS-6-3-1024k 또는 RS-3-2-1024k 가 더 적합할 수 있습니다. 관리자가 노드 수준 내 결함성에만 관심 이 있는 경우 클러스터에 최소 14 개의 DataNode가 있는 한 RS-10-4-1024k는 적절합니다. 시스템 기본 EC 정책은 'dfs.namenode.ec.system.default.policy'구성을 통해 구성할 수 있습니다. 이 구성을 사용하면 '-setPolicy'명령에서 정책 이름이 전달되지 않을 때 기본 EC 정책이 사용됩니다. 기본적으로 'dfs.namenode.ec.system.default.policy'는 "RS-6-3-1024k"입니다. 데이터 노드에 대한 이레이져 코딩 백그라운드 복구 작업은 다음 구성 매개 변수를 통해 조정할 수도 있습니다. dfs.datanode.ec.reconstruction.stripedread.timeout.millis- 스트라이프 읽기 시간 초과. 기본값은 5000ms입니다. dfs.datanode.ec.reconstruction.stripedread.buffer.size- 판독기 서비스의 버퍼 크기. 기본값은 64KB입니다. dfs.datanode.ec.reconstruction.threads- 백그라운드 재구성 작업을 위해 데이터 노드에서 사용하는 스레드 수입니다. 기본값은 8 개 스레드입니다. dfs.datanode.ec.reconstruction.xmits.weight- 복제된 블록 복구와 비교하여 EC 백그라운드 복구 작업에서 사용하는 xmit의 상대적 가중치입니다. 기본값은 0.5입니다. EC 복구 작업에 대한 가중치 계산을 비활성화하려면 0으로 설정합니다. 즉, EC 작업에는 항상 1 개의 xmit이 있습니다. 삭제 코딩 복구 작업의 xmits는 읽기 스트림 수와 쓰기 스트림 수 사이의 최댓값으로 계산됩니다. 예를 들어 EC 복구 작업이 6 개 노드에서 읽고 2 개 노드에 써야 하는 경우 xmits는 max (6, 2) * 0.5 = 3입니다. 복제된 파일에 대한 복구 작업은 항상 1 xmit으로 계산됩니다. NameNode는 dfs.namenode.replication.max-streams에서 총 xmitsInProgress를 뺀 값을 사용합니다. 복제된 파일과 EC 파일의 xmit을 결합하는 DataNode에서 이 DataNode에 대한 복구 작업을 예약합니다. CLI 명령어 hdfs ec [generic options] [-setPolicy -path <path> [-policy <policyName>] [-replicate]] [-getPolicy -path <path>] [-unsetPolicy -path <path>] [-listPolicies] [-addPolicies -policyFile <file>] [-listCodecs] [-enablePolicy -policy <policyName>] [-disablePolicy -policy <policyName>] [-removePolicy -policy <policyName>] [-verifyClusterSetup -policy <policyName>...<policyName>] [-help [cmd ...]] setPolicy 정책을 설정합니다. getPolicy 이레이져 코딩 적책을 확인합니다. unsetPolicy 정책 설정을 해제합니다. listPolicies HDFS 경로에 등록된 모든 (활성화, 비활성화 및 제거된) 이레이져 코딩 정책을 출력합니다. addPolicies 이레이저 코딩 정책을 추가합니다. removePolicy 이레이저 코딩 정책을 제거합니다. listCodecs 이레이저 코딩 코덱 목록을 출력합니다. enablePolicy 이레이저 코딩 정책을 활성화합니다. disablePolicy 이레이저 코딩 정책을 비활성화합니다. verifyClusterSetup 클러스터 설정이 활성화된 모든 이레이져 코딩 정책을 지원할 수 있는지 확인합니다 CLI 예제 file.txt를 확인하면 데이터 블록을 어느 정도 사용하는지 확인할 수 있습니다. # 이레이져 코딩 설정 $ hdfs ec -setPolicy -path hdfs:///cold Set default erasure coding policy on hdfs:///cold # 복제 설정 $ hadoop fs -du -v hdfs:///rep SIZE DISK_SPACE_CONSUMED_WITH_ALL_REPLICAS FULL_PATH_NAME 2005986464 6017959392 hdfs:///rep/file.txt # 이레이져 코딩 정책 설정 $ hadoop fs -du -v hdfs:///ec SIZE DISK_SPACE_CONSUMED_WITH_ALL_REPLICAS FULL_PATH_NAME 2005986464 3009473696 hdfs:///ec/file.txt 참고 HDFSErasureCoding 14-Rack Awareness Hadoop 구성 요소는 랙을 인식합니다. 예를 들어 HDFS 블록 배치는 하나의 블록 복제본을 서로 다른 랙에 배치하는 내 결함성을 위해 랙 인식을 사용합니다. 이는 클러스터 내에서 네트워크 스위치 장애 또는 파티션이 발생한 경우 데이터 가용성을 제공합니다. 랙 인식(Rack Awareness) 구성 랙 인식을 설정하기 위해서는 core-site.xml에 다음 설정을 추가합니다. 설정된 스크립트(쉘 스크립트 or 파이썬 스크립트)는 노드가 어떤 랙인지를 반환합니다. <property> <name>net.topology.script.file.name</name> <value>/etc/hadoop/conf/topology.sh</value> </property> 설정된 스크립트를 네임노드, 리소스 매니저가 실행하여 노드의 랙을 결정합니다. # 실행 예제, 반환 결과가 랙이 됨 bash /etc/hadoop/conf/topology.sh 10.182.10.100 매핑 데이터 스크립트 매핑 데이터 스크립트는 topology.data 파일을 읽어서 랙을 결정합니다. #!/bin/bash # Supply appropriate rack prefix RACK_PREFIX="default" # To test, supply a hostname as script input if [ $# -gt 0 ]; then HADOOP_CONF=${HADOOP_CONF:-"/etc/hadoop/conf"} while [ $# -gt 0 ] ; do nodeArg=$1 exec< ${HADOOP_CONF}/topology.data result="" while read line ; do ar=( $line) if [ "${ar[0]}" = "$nodeArg" ] ; then result="${ar[1]}" fi done shift if [ -z "$result" ] ; then echo -n "/$RACK_PREFIX/rack" else echo -n "/$RACK_PREFIX/rack_$result" fi done else echo -n "/$RACK_PREFIX/rack" fi 10.182.0.1 rack-1 10.182.0.2 rack-2 파이썬 스크립트 다음 스크립트는 IP를 확인해서 3자리를 반환하여 랙을 결정합니다. 10.182.1.X, 10.182.2.X 와 같은<NAME>으로 랙이 구성됩니다. #!/usr/bin/python3 # this script makes assumptions about the physical environment. # 1) each rack is its own layer 3 network with a /24 subnet, which # could be typical where each rack has its own # switch with uplinks to a central core router. # +-----------+ # |core router| # +-----------+ # / \ # +-----------+ +-----------+ # |rack switch| |rack switch| # +-----------+ +-----------+ # | data node | | data node | # +-----------+ +-----------+ # | data node | | data node | # +-----------+ +-----------+ # 2) topology script gets list of IP's as input, calculates network address, and prints '/network_address/ip'. import netaddr import sys sys.argv.pop(0) # discard name of topology script from argv list as we just want IP addresses netmask = '255.255.255.0' # set netmask to what's being used in your environment. The example uses a /24 for ip in sys.argv: # loop over list of datanode IP's address = '{0}/{1}'.format(ip, netmask) # format address string so it looks like 'ip/netmask' to make netaddr work try: network_address = netaddr.IPNetwork(address).network # calculate and print network address print("/{0}".format(network_address)) except: print("/rack-unknown") # print catch-all value if unable to calculate network address bash 스크립트 다음 스크립트는 IP의 마지막을 랙으로 반환합니다. 10.182.0.1, 10.182.0.6 노드가 있으면 마지막 IP 정보를 이용하여 각각 1번 노드, 6번 노드로 설정합니다. #!/usr/bin/env bash # Here's a bash example to show just how simple these scripts can be # Assuming we have flat network with everything on a single switch, we can fake a rack topology. # This could occur in a lab environment where we have limited nodes, like 2-8 physical machines on a unmanaged switch. # This may also apply to multiple virtual machines running on the same physical hardware. # The number of machines isn't important, but that we are trying to fake a network topology when there isn't one. # +----------+ +--------+ # |jobtracker| |datanode| # +----------+ +--------+ # \ / # +--------+ +--------+ +--------+ # |datanode|--| switch |--|datanode| # +--------+ +--------+ +--------+ # / \ # +--------+ +--------+ # |datanode| |namenode| # +--------+ +--------+ # With this network topology, we are treating each host as a rack. This is being done by taking the last octet # in the datanode's IP and prepending it with the word '/rack-'. The advantage for doing this is so HDFS # can create its 'off-rack' block copy. # 1) 'echo $@' will echo all ARGV values to xargs. # 2) 'xargs' will enforce that we print a single argv value per line # 3) 'awk' will split fields on dots and append the last field to the string '/rack-'. If awk # fails to split on four dots, it will still print '/rack-' last field value echo $@ | xargs -n 1 | awk -F '.' '{print "/rack-"$NF}' 랙 인식 확인 랙을 구성하여 설정되면 인식된 랙을 명령어를 이용하여 확인할 수 있습니다. datanode 데이터 노드는 report 명령으로 확인할 수 있습니다. 다음과 같이 각 노드의 정보에 Rack 정보가 포함됩니다. $ hdfs dfsadmin -report Configured Capacity: xx Present Capacity: xx DFS Remaining: xx DFS Used: xx DFS Used%: 0.13% Under replicated blocks: 0 Blocks with corrupt replicas: 0 Missing blocks: 0 Missing blocks (with replication factor 1): 0 Pending deletion blocks: 902 ------------------------------------------------- Live datanodes (15): Name: 10.0.0.1:50010 (user-host.com) Hostname: user-host.com Rack: /rack/rack-1 nodemanager 노드 매니저는 개별 노드의 상태 정보에서 확인할 수 있습니다. 개별 노드의 상태 정보에서 확인할 수 있습니다. $ yarn node -status user-host.com:45454 Node Report : Node-Id : user-host.com:45454 Rack : /rack/rack-1 15-밸런서(balance) HDFS를 운영하면서 데이터 불균형이 발생하여 밸런싱을 실행해야 하는 경우가 있습니다. 주의할 점은 밸런서는 랙 인식(Rack Awareness) 설정이 되어 있지 않으면 동작하지 않습니다. 데이터 불균형이 발생하는 경우 데이터 노드를 추가하는 경우 하둡의 데이터 저장 공간이 부족하여 데이터노드를 추가하는 경우 다른 노드의 사용 공간은 70~80% 정도인데 신규 데이터 노드는 사용 공간이 0% 대량의 데이터를 삭제하는 경우 특정 데이터 노드에 블록이 많이 저장되어 데이터노드 간 저장 공간 차이가 20~30% 정도 발생하는 경우 대량의 데이터를 추가하는 경우 특정 데이터 노드에 데이터가 적은 경우 네임노드는 데이터 저장 공간이 작은 노드를 우선적으로 사용하는데 이 경우 특정 노드로 I/O가 집중 되게 됨 HDFS Balancer 밸런서는 다음과 같이 실행합니다. 상황에 따라 작업 시간이 굉장히 오래 걸릴 수도 있습니다. $ hdfs balancer -threshold 5 Time Stamp Iteration# Bytes Already Moved Bytes Left To Move Bytes Being Moved NameNode Nov 7, 2022 6:50:16 AM 0 4.23 GB 14.96 GB 10 GB hdfs://hdfs-namenode:8020 Nov 7, 2022 7:06:49 AM 1 9.96 GB 9.63 GB 10 GB hdfs://hdfs-namenode:8020 Nov 7, 2022 7:22:56 AM 2 15.53 GB 4.23 GB 8.77 GB hdfs://hdfs-namenode:8020 The cluster is balanced. Exiting... Nov 7, 2022 7:23:05 AM 3 15.53 GB 0 B 0 B hdfs://hdfs-namenode:8020 Nov 7, 2022 7:23:05 AM Balancing took 44.9548 minutes 대역폭 밸런서는 작업 간 많은 데이터 이동이 발생하기 때문에 대역폭을 지정하여 다른 작업에 영향이 가지 않도록 하는 것이 좋습니다. hdfs dfsadmin -setBalancerBandwidth 1073741824 threshold 각 노드 간 데이터 사용 비율 차이를 임곗값을 이용하여 지정합니다. hdfs balancer -threshold 3 추가 설정: hdfs-site.xml dfs.datanode.balance.max.concurrent.moves: 50 데이터노드가 데이터 이동에 사용할 스레드 개수 dfs.datanode.balance.bandwidthPerSec: 10MB 데이터 이동에 사용하는 대역폭 3-맵리듀스 맵리듀스는 간단한 단위작업을 반복하여 처리할 때 사용하는 프로그래밍 모델입니다. 간단한 단위작업을 처리하는 맵(Map) 작업과 맵 작업의 결과물을 모아서 집계하는 리듀스(Reduce) 단계로 구성됩니다. 하둡에서 분산처리를 담당하는 맵리듀스 작업은 맵과 리듀스로 나누어져 처리됩니다. 맵, 리듀스 작업은 병렬로 처리가 가능한 작업으로, 여러 컴퓨터에서 동시에 작업을 처리하여 속도를 높일 수 있습니다. 맵리듀스 작업 단위 하둡 v1의 작업 단위는 잡(job)이고, 하둡 v2의 작업 단위는 애플리케이션(application)입니다. YARN 아키텍처가 도입되면서 이름은 변경되었지만 동일하게 관리됩니다. 잡은 맵 태스크와 리듀스 태스크로 나누어집니다. 태스크는 어템프트(attempt) 단위로 실행됩니다. 하둡 잡이 생성되면 아이디가 job_xxx_xxx로 생성됩니다. 이 아이디로 잡의 상태, 로그를 확인할 수 있습니다. YARN에서는 application_xxx_xxx로 확인할 수 있습니다. 접두어는 다르지만 같은 작업입니다. 잡에서 생성되는 맵 태스크와 리듀스 태스크는 아이디가 attempt_xxx_xxx_m_000000_0으로 생성됩니다. 맵 태스크는 중간 아이디가 m으로 생성되고, 리듀스 태스크는 r로 생성됩니다. 잡아이디: job_1520227878653_30484 애플리케이션 아이디: application_1520227878653_30484 어템프트 아이디: attempt_1520227878653_30484_m_000000_0 맵리듀스 장애 극복(Failover) 맵리듀스는 실행 중 오류가 발생하면 설정 1 된 횟수만큼 자동으로 반복됩니다. 반복 후에도 오류가 발생하면 작업을 종료합니다. 다음은 작업을 실행하고 오류가 발생한 로그입니를 보면 잡(job_1520227878653_30484)이 생성되고 실행되는 중 오류가 발생하여 맵잡의 어템프트(attempt_1520227878653_30484_m_000000_0)가 반복되고 있습니다. 잡 아이디 마지막의 숫자가 증가하면서 반복 횟수를 알려줍니다. $ hadoop jar cctv.jar com.sec.cctv.CctvMain /user/cctv/ /user/cctv_output/ 18/10/19 08:22:42 WARN mapreduce.JobResourceUploader: Hadoop command-line option parsing not performed. Implement the Tool interface and execute your application with ToolRunner to remedy this. 18/10/19 08:22:42 INFO input.FileInputFormat: Total input paths to process : 1 18/10/19 08:22:42 INFO lzo.GPLNativeCodeLoader: Loaded native gpl library 18/10/19 08:22:42 INFO lzo.LzoCodec: Successfully loaded & initialized native-lzo library [hadoop-lzo rev 418fa8c602f2a4b153c1a89806305f 6b5a27a524] 18/10/19 08:22:42 INFO mapreduce.JobSubmitter: number of splits:1 18/10/19 08:22:42 INFO Configuration.deprecation: mapred.job.queue.name is deprecated. Instead, use mapreduce.job.queuename 18/10/19 08:22:42 INFO mapreduce.JobSubmitter: Submitting tokens for job: job_1520227878653_30484 18/10/19 08:22:43 INFO impl.YarnClientImpl: Submitted application application_1520227878653_30484 /application_1520227878653_30484/ 18/10/19 08:22:43 INFO mapreduce.Job: Running job: job_1520227878653_30484 18/10/19 08:22:48 INFO mapreduce.Job: Job job_1520227878653_30484 running in uber mode : false 18/10/19 08:22:48 INFO mapreduce.Job: map 0% reduce 0% 18/10/19 08:22:51 INFO mapreduce.Job: Task Id : attempt_1520227878653_30484_m_000000_0, Status : FAILED Error: java.io.IOException: Type mismatch in value from map: expected org.apache.hadoop.io.Text, received org.apache.hadoop.io.IntWritable at org.apache.hadoop.mapred.MapTask$MapOutputBuffer.collect(MapTask.java:1095) at org.apache.hadoop.mapred.MapTask$NewOutputCollector.write(MapTask.java:724) at org.apache.hadoop.mapreduce.task.TaskInputOutputContextImpl.write(TaskInputOutputContextImpl.java:89) at org.apache.hadoop.mapreduce.lib.map.WrappedMapper$Context.write(WrappedMapper.java:112) at com.sec.cctv.CctvMapper.map(CctvMapper.java:17) at com.sec.cctv.CctvMapper.map(CctvMapper.java:9) at org.apache.hadoop.mapreduce.Mapper.run(Mapper.java:146) at org.apache.hadoop.mapred.MapTask.runNewMapper(MapTask.java:796) at org.apache.hadoop.mapred.MapTask.run(MapTask.java:342) at org.apache.hadoop.mapred.YarnChild$2.run(YarnChild.java:164) at java.security.AccessController.doPrivileged(Native Method) at javax.security.auth.Subject.doAs(Subject.java:422) at org.apache.hadoop.security.UserGroupInformation.doAs(UserGroupInformation.java:1698) at org.apache.hadoop.mapred.YarnChild.main(YarnChild.java:158) 18/10/19 08:22:54 INFO mapreduce.Job: Task Id : attempt_1520227878653_30484_m_000000_1, Status : FAILED Error: java.io.IOException: Type mismatch in value from map: expected org.apache.hadoop.io.Text, received org.apache.hadoop.io.IntWritable at org.apache.hadoop.mapred.MapTask$MapOutputBuffer.collect(MapTask.java:1095) at org.apache.hadoop.mapred.MapTask$NewOutputCollector.write(MapTask.java:724) at org.apache.hadoop.mapreduce.task.TaskInputOutputContextImpl.write(TaskInputOutputContextImpl.java:89) at org.apache.hadoop.mapreduce.lib.map.WrappedMapper$Context.write(WrappedMapper.java:112) at com.sec.cctv.CctvMapper.map(CctvMapper.java:17) at com.sec.cctv.CctvMapper.map(CctvMapper.java:9) at org.apache.hadoop.mapreduce.Mapper.run(Mapper.java:146) at org.apache.hadoop.mapred.MapTask.runNewMapper(MapTask.java:796) at org.apache.hadoop.mapred.MapTask.run(MapTask.java:342) at org.apache.hadoop.mapred.YarnChild$2.run(YarnChild.java:164) at java.security.AccessController.doPrivileged(Native Method) at javax.security.auth.Subject.doAs(Subject.java:422) at org.apache.hadoop.security.UserGroupInformation.doAs(UserGroupInformation.java:1698) at org.apache.hadoop.mapred.YarnChild.main(YarnChild.java:158) 18/10/19 08:22:57 INFO mapreduce.Job: Task Id : attempt_1520227878653_30484_m_000000_2, Status : FAILED Error: java.io.IOException: Type mismatch in value from map: expected org.apache.hadoop.io.Text, received org.apache.hadoop.io.IntWritable at org.apache.hadoop.mapred.MapTask$MapOutputBuffer.collect(MapTask.java:1095) at org.apache.hadoop.mapred.MapTask$NewOutputCollector.write(MapTask.java:724) at org.apache.hadoop.mapreduce.task.TaskInputOutputContextImpl.write(TaskInputOutputContextImpl.java:89) at org.apache.hadoop.mapreduce.lib.map.WrappedMapper$Context.write(WrappedMapper.java:112) at com.sec.cctv.CctvMapper.map(CctvMapper.java:17) at com.sec.cctv.CctvMapper.map(CctvMapper.java:9) at org.apache.hadoop.mapreduce.Mapper.run(Mapper.java:146) at org.apache.hadoop.mapred.MapTask.runNewMapper(MapTask.java:796) at org.apache.hadoop.mapred.MapTask.run(MapTask.java:342) at org.apache.hadoop.mapred.YarnChild$2.run(YarnChild.java:164) at java.security.AccessController.doPrivileged(Native Method) at javax.security.auth.Subject.doAs(Subject.java:422) at org.apache.hadoop.security.UserGroupInformation.doAs(UserGroupInformation.java:1698) at org.apache.hadoop.mapred.YarnChild.main(YarnChild.java:158) 18/10/19 08:23:02 INFO mapreduce.Job: map 100% reduce 100% 18/10/19 08:23:02 INFO mapreduce.Job: Job job_1520227878653_30484 failed with state FAILED due to: Task failed task_1520227878653_30484_m_000000 Job failed as tasks failed. failedMaps:1 failedReduces:0 18/10/19 08:23:02 INFO mapreduce.Job: Counters: 13 Job Counters Failed map tasks=4 Killed reduce tasks=7 Launched map tasks=4 Other local map tasks=3 Data-local map tasks=1 Total time spent by all maps in occupied slots (ms)=327375 Total time spent by all reduces in occupied slots (ms)=0 Total time spent by all map tasks (ms)=7275 Total time spent by all reduce tasks (ms)=0 Total vcore-milliseconds taken by all map tasks=7275 Total vcore-milliseconds taken by all reduce tasks=0 Total megabyte-milliseconds taken by all map tasks=10476000 Total megabyte-milliseconds taken by all reduce tasks=0 맵 입력 분할 맵의 입력은 스플릿(InputSplit) 단위로 분할됩니다. 맵 작업은 큰 데이터를 하나의 노드에서 처리하지 않고, 분할하여 동시에 병렬 처리하여 작업 시간을 단축합니다. 스플릿이 작으면 작업 부하가 분산되어 성능을 높을 수 있습니다. 하지만 스플릿의 크기가 너무 작으면 맵 작업의 개수가 증가하고 맵 작업 생성을 위한 오버헤드가 증가하여 작업이 느려질 수 있습니다. 따라서 작업에 따라 적절한 개수의 맵 작업을 생성해야 합니다. 일반적으로 맵 작업의 적절한 스플릿 크기는 데이터 지역성의 이점을 얻을 수 있는 HDFS 블록의 기본 크기(128MB)입니다. 맵 작업 데이터 지역성 맵 작업은 HDFS에 입력 데이터가 있는 노드에서 실행할 때 가장 빠르게 동작합니다. 클러스터의 네트워크 대역을 사용하지 않고 처리할 수 있기 때문입니다. 데이터가 있는 노드에서 작업을 처리할 수 없다면 동일한 랙의 노드, 다른 랙의 노드 순서로 맵 작업이 실행 가능한 노드를 찾습니다. 맵 작업의 적절한 스플릿 크기가 HDFS 블록의 기본 크기인 이유는 단일 노드에 해당 블록이 모두 저장된다고 확신할 수 있는 입력 크기이기 때문입니다. 스플릿 크기가 블록의 기본 크기일 때 맵 작업이 로컬 디스크의 데이터만 이용하여, 다른 노드에서 데이터를 전송받아 처리할 때 보다 빠르게 작업을 처리할 수 있습니다. 맵 작업의 결과는 로컬 디스크에 임시 저장됩니다. 맵 작업의 결과는 리듀스 작업의 입력으로 쓰이는 임시 결과물이기 때문입니다. 리듀스 작업은 맵 작업의 결과를 입력으로 받기 때문에 지역성의 장점이 없습니다. 리듀스 작업의 결과는 HDFS에 저장됩니다. 리듀스 작업의 개수는 입력 크기와 상관없이 지정할 수 있습니다. 리듀스가 여러 개이면 리듀스의 개수만큼 파티션을 생성하고 맵의 결과를 각 파티션에 분배합니다. 파티션 별로 키가 존재하고 동일한 키는 같은 파티션에 전달됩니다. 맵리듀스 작업의 종류 맵리듀스는 리듀서 작업이 있는 경우와 없는 경우가 있습니다. 파일을 읽어서 바로 쓰는 작업의 경우 리듀서가 필요 없어서 매퍼만 있는 작업(Mapper Only)이 됩니다. 집계를 진행해야 해서 리듀서가 필요한 경우 정렬이 필요한 경우는 리듀서가 하나만 생성됩니다. 나머지의 경우 리듀서가 여러 개로 생성됩니다. 각 작업의 최종 매퍼, 리듀서의 수만큼 파일이 생성됩니다. 리듀서가 하나인 경우 모든 데이터의 정렬 작업 같은 경우입니다. 리듀서 하나로 모든 작업을 처리하기 때문에 시간이 오래 걸립니다. 리듀서가 여러 개인 경우 일반적인 집계 작업의 경우 리듀서가 여러 개 생성됩니다. 리듀서의 수만큼 파일이 생성됩니다. HDFS의 부하를 방지하기 위해서 추가적인 파일 머지 작업이 필요할 수 있습니다. 리듀서가 없는 경우(Mapper Only 작업) 원천 데이터를 읽어서 가공을 하고 바로 쓰는 경우입니다. 리듀서 작업이 없기 때문에 빠릅니다. 매퍼의 수만큼 파일이 생성되기 때문에 추가적인 파일 머지 작업이 필요할 수 있습니다. 맵 반복 설정(mapreduce.map.maxattempts), 리듀스 반복 설정(mapreduce.reduce.maxattempts). 기본적으로 3회 반복 설정되어 있음 ↩ 1-처리 단계 맵리듀스의 처리단계는 8단계로 크게 구분할 수 있습니다. 각 단계는 작업의 종류에 따라 생략될 수도 있습니다. 맵리듀스 처리 단계 입력 데이터를 입력하는 단계 텍스트, csv, gzip 형태의 데이터를 읽어서 맵으로 전달 맵(Map) 입력을 분할하여 키별로 데이터를 처리 컴바이너(Combiner) 네트워크를 타고 넘어가는 데이터를 줄이기 위하여 맵의 결과를 정리 로컬 리듀서라고도 함 컴바이너는 작업의 설정에 따라 없을 수도 있음 파티셔너(Partitoner) 맵의 출력 결과 키값을 해시 처리하여 어떤 리듀서로 넘길지를 결정 셔플(Shuffle) 각 리듀서로 데이터 이동 정렬(Sort) 리듀서로 전달된 데이터를 키값 기준으로 정렬 리듀서(Reduce) 리듀서로 데이터를 처리하고 결과를 저장 출력 리듀서의 결과를 정의된 형태로 저장 입력 입력 단계은 InputFormat 클래스를 이용합니다. InputFormat 입력 파일이 분할되는 방식(InputSplit)이나 읽어들이는 방식(RecordReader)을 정의하는 클래스입니다. InputFormat 추상 클래스를 상속하여 구현합니다. 하둡은 파일을 읽기 위한 FileInputFormat이나, 여러 개의 파일을 한 번에 읽을 수 있는 CombineFileInputFormat 등을 제공합니다. package org.apache.hadoop.mapreduce; @InterfaceAudience.Public @InterfaceStability.Stable public abstract class InputFormat<K, V> { /** * Logically split the set of input files for the job. */ public abstract List<InputSplit> getSplits(JobContext context ) throws IOException, InterruptedException; /** * Create a record reader for a given split. The framework will call */ public abstract RecordReader<K, V> createRecordReader(InputSplit split, TaskAttemptContext context ) throws IOException, InterruptedException; } InputSplit InputSplist은 맵의 입력으로 들어오는 데이터를 분할하는 방식을 제공합니다. 데이터의 위치와 읽어 들이는 길이를 정의합니다. package org.apache.hadoop.mapreduce; @InterfaceAudience.Public @InterfaceStability.Stable public abstract class InputSplit { /** * Get the size of the split, so that the input splits can be sorted by size. */ public abstract long getLength() throws IOException, InterruptedException; /** * Get the list of nodes by name where the data for the split would be local. * The locations do not need to be serialized. */ public abstract String[] getLocations() throws IOException, InterruptedException; /** * Gets info about which nodes the input split is stored on and how it is * stored at each location. */ @Evolving public SplitLocationInfo[] getLocationInfo() throws IOException { return null; } } RecordReader RecordReader는 실제 파일에 접근하여 데이터를 읽어 들입니다. 데이터를 읽어서 <키, 밸류> 형태로 반환합니다. package org.apache.hadoop.mapreduce; import java.io.Closeable; import java.io.IOException; import org.apache.hadoop.classification.InterfaceAudience; import org.apache.hadoop.classification.InterfaceStability; /** * The record reader breaks the data into key/value pairs for input to the */ @InterfaceAudience.Public @InterfaceStability.Stable public abstract class RecordReader<KEYIN, VALUEIN> implements Closeable { /** * Called once at initialization. */ public abstract void initialize(InputSplit split, TaskAttemptContext context ) throws IOException, InterruptedException; /** * Read the next key, value pair. */ public abstract boolean nextKeyValue() throws IOException, InterruptedException; /** * Get the current key */ public abstract KEYIN getCurrentKey() throws IOException, InterruptedException; /** * Get the current value. */ public abstract VALUEIN getCurrentValue() throws IOException, InterruptedException; /** * The current progress of the record reader through its data. */ public abstract float getProgress() throws IOException, InterruptedException; /** * Close the record reader. */ public abstract void close() throws IOException; } Mapper 매퍼는 사용자가 정의한 작업을 수행합니다. 사용자는 Mapper 클래스를 상속하고 map() 메서드를 구현하면 됩니다. run() 메서드를 보면 실제 매퍼 작업이 동작하는 방식을 알 수 있습니다. setup() 메서드로 매퍼를 초기화하고, RecordReader를 이용하여 데이터를 읽어서 map(키, 밸류) 함수를 호출합니다. 데이터를 모두 처리할 때까지 반복합니다. 마지막으로 cleanup() 메서드로 사용한 리소스의 반환 등을 처리합니다. package org.apache.hadoop.mapreduce; @InterfaceAudience.Public @InterfaceStability.Stable public class Mapper<KEYIN, VALUEIN, KEYOUT, VALUEOUT> { /** * The <code>Context</code> passed on to the {@link Mapper} implementations. */ public abstract class Context implements MapContext<KEYIN, VALUEIN, KEYOUT, VALUEOUT> { } /** * Called once at the beginning of the task. */ protected void setup(Context context) throws IOException, InterruptedException { // NOTHING } /** * Called once for each key/value pair in the input split. Most applications * should override this, but the default is the identity function. */ @SuppressWarnings("unchecked") protected void map(KEYIN key, VALUEIN value, Context context) throws IOException, InterruptedException { context.write((KEYOUT) key, (VALUEOUT) value); } /** * Called once at the end of the task. */ protected void cleanup(Context context) throws IOException, InterruptedException { // NOTHING } /** * Expert users can override this method for more complete control over the * execution of the Mapper. */ public void run(Context context) throws IOException, InterruptedException { setup(context); try { while (context.nextKeyValue()) { map(context.getCurrentKey(), context.getCurrentValue(), context); } } finally { cleanup(context); } } } Combiner 맵리듀스 프레임워크의 자원은 유한하기 때문에 맵 작업의 결과를 리듀스 작업의 입력으로 전달하기 전에 정리를 하면 데이터 전송에 필요한 자원을 줄일 수 있습니다. 이때 컴바이너 함수를 이용하여 처리할 수 있습니다. 하지만 컴바이너 작업에 사용할 수 있는 함수는 제약이 있습니다. 최댓값, 최솟값, 카운트 같은 함수는 가능하지만 평균 함수는 맵퍼 작업의 결과를 평균 내어, 리듀스 작업에 사용하면 최종 결과가 달라지기 때문에 사용할 수 없습니다. 리듀스 함수를 컴바이너 함수로 사용할 수도 있지만, 컴바이너 함수를 리듀스 함수를 완전히 대체할 수도 없습니다. 맵 단계에서 컴바이너 함수를 쓰더라도 리듀스 함수는 서로 다른 맵에서 오는 같은 키의 레코드를 여전히 처리해야 합니다. 컴바이너를 사용하면 매 퍼와 리듀서 사이의 셔플 단계에서 전송되는 데이터양을 줄일 수 있어서 작업의 속도를 향상시킬 수 있습니다. Partitioner & Shuffle 맵 작업이 종료되면 작업이 끝난 노드부터 리듀서로 데이터를 전달하는데 이를 셔플이라고 합니다. 리듀서로 데이터를 전달하기 위해서 맵의 결과 키를 리듀서로 분배하는 기준을 만드는 것을 파티션이라고 합니다. 기본적으로 사용되는 해시 파티션을 보면 키의 값을 이용하여 리듀서의 개수만큼 파티션을 생성합니다. 같은 파티션은 같은 리듀서로 전달됩니다. package org.apache.hadoop.mapreduce.lib.partition; @InterfaceAudience.Public @InterfaceStability.Stable public class HashPartitioner<K, V> extends Partitioner<K, V> { /** Use {@link Object#hashCode()} to partition. */ public int getPartition(K key, V value, int numReduceTasks) { return (key.hashCode() & Integer.MAX_VALUE) % numReduceTasks; } } 기본 파티셔너에서 Integer.MAX_VALUE 값을 이용하여 논리합(&) 연산을 하는 이유는 파티션의 번호가 양수여야 하기 때문입니다. 자바의 int형의 첫 번째 byte는 0이면 양수이기 때문에 해시 코드 연산을 통해서 음수가 나오면 논리합 연산을 통해 양수로 변경합니다. 따라서 사용자가 커스텀 파티셔너를 구현할 때 음수가 전달되지 않도록 잘 처리해 주어야 합니다. Sort 리듀스 작업 전에 전달받은 키를 이용하여 정렬을 수행합니다. 그리고 실제 리듀스 작업을 수행하기 위해 데이터를 List< Value > 형태로 만들기 위한 그룹핑 작업도 함께 수행합니다. 리듀서의 키와 다른 값을 함께 이용하는 복합키의 경우 다음과 같이 파티셔닝, 소트, 그룹핑 작업을 거치면서 복합키를 기준으로 정렬하게 됩니다. 데이터를 정렬할 때 파티션의 기준이 되는 주키(Primary Key) 외 다른 값을 기준으로 정렬할 수도 있습니다. 이를 세컨더리 소트(Secondary Sort)라고 합니다. Reduce 리듀서는 키별로 정렬된 데이터를 이용하여 리듀서 작업을 진행합니다. 리듀서는 사용자가 정의한 작업을 수행합니다. 사용자는 Reducer 클래스를 상속하고 reduce() 메서드를 구현하면 됩니다. run() 메서드를 보면 실제 매퍼 작업이 동작하는 방식을 알 수 있습니다. setup() 메서드로 리듀서를 초기화하고, 데이터를 읽어서 run(키, list(밸류)) 함수를 호출합니다. 데이터를 모두 처리할 때까지 반복합니다. 마지막으로 cleanup() 메서드로 사용한 리소스의 반환 등을 처리합니다 package org.apache.hadoop.mapreduce; @Checkpointable @InterfaceAudience.Public @InterfaceStability.Stable public class Reducer<KEYIN, VALUEIN, KEYOUT, VALUEOUT> { /** * The <code>Context</code> passed on to the {@link Reducer} implementations. */ public abstract class Context implements ReduceContext<KEYIN, VALUEIN, KEYOUT, VALUEOUT> { } /** * Called once at the start of the task. */ protected void setup(Context context ) throws IOException, InterruptedException { // NOTHING } /** * This method is called once for each key. Most applications will define * their reduce class by overriding this method. The default implementation * is an identity function. */ @SuppressWarnings("unchecked") protected void reduce(KEYIN key, Iterable<VALUEIN> values, Context context ) throws IOException, InterruptedException { for(VALUEIN value: values) { context.write((KEYOUT) key, (VALUEOUT) value); } } /** * Called once at the end of the task. */ protected void cleanup(Context context ) throws IOException, InterruptedException { // NOTHING } /** * Advanced application writers can use the * {@link #run(org.apache.hadoop.mapreduce.Reducer.Context)} method to * control how the reduce task works. */ public void run(Context context) throws IOException, InterruptedException { setup(context); try { while (context.nextKey()) { reduce(context.getCurrentKey(), context.getValues(), context); // If a back up store is used, reset it Iterator<VALUEIN> iter = context.getValues().iterator(); if(iter instanceof ReduceContext.ValueIterator) { ((ReduceContext.ValueIterator<VALUEIN>) iter).resetBackupStore(); } } } finally { cleanup(context); } } } 출력 출력 단계는 OutputFormat 단계를 이용합니다. OutputFormat 출력피일에 기록되는<NAME>을 설정합니다. Text<NAME>, Csv<NAME> 등을 설정하고 파일을 쓰는 방법을 설정합니다. import java.io.IOException; @InterfaceAudience.Public @InterfaceStability.Stable public abstract class OutputFormat<K, V> { public abstract RecordWriter<K, V> getRecordWriter(TaskAttemptContext context ) throws IOException, InterruptedException; public abstract void checkOutputSpecs(JobContext context ) throws IOException, InterruptedException; public abstract OutputCommitter getOutputCommitter(TaskAttemptContext context ) throws IOException, InterruptedException; } RecordWriter 실제 파일을 기록합니다. 참고 hadoop mapreduce tutorial github MapReduce source 1-워드 카운트 맵리듀스의 처리 단계를 워드 카운트 예제로 확인해 보겠습니다. 이 워드 카운트 예제는 하둡의 맵리듀스 튜토리얼의 워드 카운트 예제를 이용합니다. 워드 카운트는 입력된 파일의 문자 수를 세는 프로그램입니다. 워드 카운트의 작업 단계는 다음과 같습니다. 워드 카운트의 전체 소스코드는 다음과 같습니다. 다음 코드는 세 부분으로 나눌 수 있습니다. 매퍼를 구현한 TokenizerMapper, 리듀서를 구현한 IntSumReducer 잡을 설정하는 main() 함수입니다. import java.io.IOException; import java.util.StringTokenizer; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.Path; import org.apache.hadoop.io.IntWritable; import org.apache.hadoop.io.Text; import org.apache.hadoop.mapreduce.Job; import org.apache.hadoop.mapreduce.Mapper; import org.apache.hadoop.mapreduce.Reducer; import org.apache.hadoop.mapreduce.lib.input.FileInputFormat; import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat; public class WordCount { // 맵 public static class TokenizerMapper extends Mapper<Object, Text, Text, IntWritable> { private final static IntWritable one = new IntWritable(1); private Text word = new Text(); public void map(Object key, Text value, Context context) throws IOException, InterruptedException { // 입력된 한 라인(value)을 공백을 기준으로 분할하여 // context 객체를 이용하여 임시파일로 저장 StringTokenizer itr = new StringTokenizer(value.toString()); while (itr.hasMoreTokens()) { word.set(itr.nextToken()); context.write(word, one); } } } // 리듀스 public static class IntSumReducer extends Reducer<Text, IntWritable, Text, IntWritable> { private IntWritable result = new IntWritable(); // 키(문자) 별로 전달된 문자의 개수를 모두 더하여 출력 public void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException { int sum = 0; for (IntWritable val : values) { sum += val.get(); } result.set(sum); context.write(key, result); } } public static void main(String[] args) throws Exception { // Job 객체를 이용하여 하둡 작업을 실행 Configuration conf = new Configuration(); Job job = Job.getInstance(conf, "word count"); job.setJarByClass(WordCount.class); job.setMapperClass(TokenizerMapper.class); job.setCombinerClass(IntSumReducer.class); job.setReducerClass(IntSumReducer.class); job.setOutputKeyClass(Text.class); job.setOutputValueClass(IntWritable.class); FileInputFormat.addInputPath(job, new Path(args[0])); // 입력 파일 위치 FileOutputFormat.setOutputPath(job, new Path(args[1])); // 출력 파일 위치 System.exit(job.waitForCompletion(true) ? 0 : 1); } } 실행 하둡 맵리듀스의 실행은 jar 파일을 이용합니다. 워드 카운트 예제를 빌드 하여 jar 파일로 생성하고 실행합니다. 작업 준비 먼저 입력으로 사용할 파일을 생성하고 HDFS에 복사합니다. 입력 파일의<NAME>은 다음과 같습니다. $ cat word.txt Deer Bear River Car Car River Deer Car Bear # 작업 파일 복사 $ hadoop fs -put ./word.txt /user/word/input/ 실행 실행은 다음과 같이 hadoop jar 명령을 이용합니다. 작업 대상 jar 파일과 클래스 명을 명시하고 작업 파라미터인 입력 위치와 출력 위치를 전달합니다. $ hadoop jar Mapreduce.jar sdk.WordCount /user/word/input /user/word/output 작업 결과 작업 결과는 part 파일로 생성됩니다. _SUCCESS는 작업의 성공 여부를 알려주는 파일입니다. 맵리듀스 프레임워크에서 자체적으로 생성하는 파일입니다. # 실행 결과 확인 $ hadoop fs -ls /user/word/output/ Found 8 items -rw-r--r-- 2 hadoop hadoop 0 2019-02-21 05:39 /user/word/output/_SUCCESS -rw-r--r-- 2 hadoop hadoop 0 2019-02-21 05:39 /user/word/output/part-r-00000 -rw-r--r-- 2 hadoop hadoop 0 2019-02-21 05:39 /user/word/output/part-r-00001 -rw-r--r-- 2 hadoop hadoop 7 2019-02-21 05:39 /user/word/output/part-r-00002 -rw-r--r-- 2 hadoop hadoop 0 2019-02-21 05:39 /user/word/output/part-r-00003 -rw-r--r-- 2 hadoop hadoop 0 2019-02-21 05:39 /user/word/output/part-r-00004 -rw-r--r-- 2 hadoop hadoop 0 2019-02-21 05:39 /user/word/output/part-r-00005 -rw-r--r-- 2 hadoop hadoop 21 2019-02-21 05:39 /user/word/output/part-r-00006 # 파일 내용 확인 $ hadoop fs -cat /user/word/output/part* Deer 2 Bear 2 Car 3 River 2 워드 카운트 처리 단계 입력 워드 카운트는 파일로 데이터를 입력받습니다. 파일 위치를 파라미터로 전달하면 FileInputFormat을 이용해서 데이터를 읽습니다. FileInputFormat은 지정한 위치의 파일을 라인 단위로 읽어서 맵에 전달합니다. FileInputFormat.addInputPath(job, new Path(args[0])); 맵은 전달받은 <키, 밸류>에서 밸류 데이터를 공백 단위로 분할하여 문자 수를 세어줍니다. 맵에서 데이터를 정리하지 않습니다. 같은 문자가 있어도 합계를 내지 않고 하나씩 처리합니다. [입력, <버퍼 번호, 라인>] 1, Deer Bear River 16, Car Car River 30, Deer Car Bear [출력, <문자, 1>] Dear 1 Bear 1 River 1 Car 1 Car 1 River 1 Dear 1 Car 1 Bear 1 map 함수의 key로 들어오는 값이 버퍼 번호이고, value로 들어오는 값이 라인이 됩니다. 이 value를 공백을 기준으로 잘라서 문자 단위로 파일이 쓰게 됩니다. public void map(Object key, Text value, Context context) throws IOException, InterruptedException { // 입력된 한 라인(value)을 공백을 기준으로 분할하여 // context 객체를 이용하여 임시파일로 저장 StringTokenizer itr = new StringTokenizer(value.toString()); while (itr.hasMoreTokens()) { word.set(itr.nextToken()); context.write(word, one); } } 컴바이너(Combiner) 컴바이너는 잡에 설정합니다. 컴바이너는 설정해도 되고, 설정하지 않아도 동작에 영향을 주지 않습니다. job.setCombinerClass(IntSumReducer.class); 컴바이너를 설정하면 로컬에서 리듀서 작업을 처리합니다. 다음처럼 리듀서로 전달하는 결과가 줄어들기 때문에 네트워크 자원의 사용량을 줄일 수 있습니다. [입력, <문자, 1>] Dear 1 Bear 1 River 1 Car 1 Car 1 River 1 Dear 1 Car 1 Bear 1 [출력, <문자, List(1)>] Dear List(1, 1) Bear List(1, 1) Car List(1, 1, 1) River List(1, 1) 파티셔너, 셔플, 소트 워드 카운트 예제에서 파티셔너, 셔플, 소트 단계는 따로 설정하지 않습니다. 맵리듀스 프레임워크의 기본 단계를 이용하여 맵의 결과는 리듀스의 입력으로 전달됩니다. [맵의 결과] Dear 1 Bear 1 River 1 Car 1 Car 1 River 1 [리듀서의 입력] Dear List(1, 1) Bear List(1, 1) Car List(1, 1, 1) River List(1, 1) 리듀서(Reduce) 리듀서는 키별로 전달된 등장 횟수를 모두 더하여 전체 등장 회수를 생성합니다. [입력, <문자, List(1)>] Dear List(1, 1) Bear List(1, 1) Car List(1, 1, 1) River List(1, 1) [출력, <문자, 횟수>] Deer 2 Bear 2 Car 3 River 2 문자가 key로 들어오고, 등장 횟수가 Iterable 형태로 전달됩니다. 이 값들을 모두 더하여 결과를 출력합니다. public void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException { int sum = 0; for (IntWritable val : values) { sum += val.get(); } result.set(sum); context.write(key, result); } 출력 지정한 위치에 파일로 출력합니다. 출력 파일의 개수는 리듀서의 개수와 일치합니다. FileOutputFormat.setOutputPath(job, new Path(args[1])); 참고 hadoop mapreduce tutorial (바로 가기) 2-워드 카운트 2 - 카운터, 분산 캐시 워드 카운트 2 예제는 기존 워드 카운트 예제를 보강한 내용입니다. 추가한 내용은 다음과 같습니다. setup 함수를 이용하는 방법 카운터를 이용하는 방법 분산 캐시를 이용하는 방법 옵션 파서를 이용하는 방법 소스 코드 워드 카운트 2의 전체 소스는 다음과 같습니다. package sdk; import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.net.URI; import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Set; import java.util.StringTokenizer; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.Path; import org.apache.hadoop.io.IntWritable; import org.apache.hadoop.io.Text; import org.apache.hadoop.mapreduce.Job; import org.apache.hadoop.mapreduce.Mapper; import org.apache.hadoop.mapreduce.Reducer; import org.apache.hadoop.mapreduce.lib.input.FileInputFormat; import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat; import org.apache.hadoop.mapreduce.Counter; import org.apache.hadoop.util.GenericOptionsParser; import org.apache.hadoop.util.StringUtils; public class WordCount2 { public static class TokenizerMapper extends Mapper<Object, Text, Text, IntWritable> { // 문자의 개수를 세는 카운터 static enum CountersEnum { INPUT_WORDS } private final static IntWritable one = new IntWritable(1); private Text word = new Text(); private boolean caseSensitive; // 대소문자 구분 private Set<String> patternsToSkip = new HashSet<String>(); // 문자에서 제거할 기호 private Configuration conf; // 맵 작업의 설정 @Override public void setup(Context context) throws IOException, InterruptedException { conf = context.getConfiguration(); caseSensitive = conf.getBoolean("wordcount.case.sensitive", true); // 대소문자 구분 if (conf.getBoolean("wordcount.skip.patterns", false)) { // 스킵 패턴 파일을 분산 캐시에서 가져와서 patternsToSkip에 설정 URI[] patternsURIs = Job.getInstance(conf).getCacheFiles(); for (URI patternsURI : patternsURIs) { Path patternsPath = new Path(patternsURI.getPath()); String patternsFileName = patternsPath.getName().toString(); parseSkipFile(patternsFileName); } } } private void parseSkipFile(String fileName) { try (BufferedReader fis = new BufferedReader(new FileReader(fileName))) { String pattern = null; while ((pattern = fis.readLine()) != null) { patternsToSkip.add(pattern); } } catch (IOException ioe) { System.err.println("Caught exception while parsing the cached file '" + StringUtils.stringifyException(ioe)); } } @Override public void map(Object key, Text value, Context context) throws IOException, InterruptedException { String line = (caseSensitive) ? value.toString() : value.toString().toLowerCase(); // patternsToSkip과 일치하는 문자를 제거 for (String pattern : patternsToSkip) { line = line.replaceAll(pattern, ""); } StringTokenizer itr = new StringTokenizer(line); while (itr.hasMoreTokens()) { word.set(itr.nextToken()); context.write(word, one); // 카운터에 1을 더함 Counter counter = context.getCounter("User Custom Counter", CountersEnum.INPUT_WORDS.toString()); counter.increment(1); } } } public static class IntSumReducer extends Reducer<Text, IntWritable, Text, IntWritable> { private IntWritable result = new IntWritable(); public void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException { int sum = 0; for (IntWritable val : values) { sum += val.get(); } result.set(sum); context.write(key, result); } } public static void main(String[] args) throws Exception { Configuration conf = new Configuration(); // 옵션 파서를 이용해서 옵션의 개수가 2 또는 4개가 아니면 오류 메시지 출력 후 종료 // -D로 전달되는 옵션은 conf에 설정 GenericOptionsParser optionParser = new GenericOptionsParser(conf, args); String[] remainingArgs = optionParser.getRemainingArgs(); if (!(remainingArgs.length != 2 || remainingArgs.length != 4)) { System.err.println("Usage: wordcount <in> <out> [-skip skipPatternFile]"); System.exit(2); } // 맵리듀스 잡 설정 Job job = Job.getInstance(conf, "word count 2"); job.setJarByClass(WordCount2.class); job.setMapperClass(TokenizerMapper.class); job.setCombinerClass(IntSumReducer.class); job.setReducerClass(IntSumReducer.class); job.setOutputKeyClass(Text.class); job.setOutputValueClass(IntWritable.class); // 옵션으로 -skip으로 전달된 파일 경로를 분산 캐시에 추가하고, // wordcount.skip.patterns를 true로 설정 List<String> otherArgs = new ArrayList<String>(); for (int i = 0; i < remainingArgs.length; ++i) { if ("-skip".equals(remainingArgs[i])) { job.addCacheFile(new Path(remainingArgs[++i]).toUri()); job.getConfiguration().setBoolean("wordcount.skip.patterns", true); } else { otherArgs.add(remainingArgs[i]); // 파일 경로 } } FileInputFormat.addInputPath(job, new Path(otherArgs.get(0))); FileOutputFormat.setOutputPath(job, new Path(otherArgs.get(1))); System.exit(job.waitForCompletion(true) ? 0 : 1); } } setup 함수를 이용하는 방법 맵리듀스 프레임워크는 map, reduce 함수의 실행 전 setup 함수를 호출합니다. 작업에 필요한 설정값과 전처리를 여기서 처리합니다. 컨텍스트에서 설정값을 가져와서 설정에 이용하면 됩니다. @Override public void setup(Context context) throws IOException, InterruptedException { conf = context.getConfiguration(); caseSensitive = conf.getBoolean("wordcount.case.sensitive", ... } 카운터를 이용하는 방법 카운터(Counter)는 enum을 이용하여 카운터를 등록하고, 컨텍스트에서 카운터를 가져와서 사용하면 됩니다. 이렇게 사용한 카운터는 로그에서 확인할 수 있습니다. // 문자의 개수를 세는 카운터 static enum CountersEnum { INPUT_WORDS } // 카운터 이용 Counter counter = context.getCounter("User Custom Counter", CountersEnum.INPUT_WORDS.toString()); counter.increment(1); 카운터를 이용하면 맵리듀스 실행 로그에서 카운터 값을 확인할 수 있습니다. WRONG_MAP=0 WRONG_REDUCE=0 User Custom Counter INPUT_WORDS=9 File Input Format Counters Bytes Read=57 분산 캐시를 이용하는 방법 분산 캐시는 잡에 addCacheFile을 이용하여 등록합니다. 맵, 리듀스에서 이용할 때는 getCacheFiles를 이용합니다. // main() if ("-skip".equals(remainingArgs[i])) { job.addCacheFile(new Path(remainingArgs[++i]).toUri()); job.getConfiguration().setBoolean("wordcount.skip.patterns", true); } // setUp에서 이용하는 방법 URI[] patternsURIs = Job.getInstance(conf).getCacheFiles(); 옵션 파서를 이용하는 방법 옵션 파서를 이용하면 사용자가 개별적으로 설정을 추가하지 않아도, 설정값을 효율적으로 추가할 수 있습니다. 실행 시점에 사용자가 입력한 설정값의 접두어를 분석하여 conf에 설정해 줍니다. // 옵션 파서 GenericOptionsParser optionParser = new GenericOptionsParser(conf, args); // 실행 시 설정 추가 $ hadoop jar SdkMapreduce.jar sdk.WordCount2 -Dmapred.job.queue.name=queue_name /user/word/input2 /user/word/output2 워드 카운트 2 실행 준비 워드 카운트 2는 실행을 위해 원본 데이터를 준비합니다. 각 파일의 내용은 다음과 같고 HDFS에 복사합니다. 예제는 두 개의 파일로 되어 있지만 하나의 파일을 이용해도 상관없습니다. $ cat file1.txt Hello World, Bye World! $ cat file2.txt Hello Hadoop, Goodbye to hadoop. # 파일 복사 $ hadoop fs -put file*txt /user/word/input2/ 실행 워드 카운트 2를 실행하면 다음의 결과를 확인할 수 있습니다. $ hadoop jar SdkMapreduce.jar sdk.WordCount2 /user/word/input2 /user/word/output2 $ hadoop fs -ls /user/word/output2/ Found 8 items -rw-r--r-- 2 hadoop hadoop 0 2019-02-21 07:44 /user/word/output2/_SUCCESS -rw-r--r-- 2 hadoop hadoop 0 2019-02-21 07:44 /user/word/output2/part-r-00000 -rw-r--r-- 2 hadoop hadoop 15 2019-02-21 07:44 /user/word/output2/part-r-00001 -rw-r--r-- 2 hadoop hadoop 0 2019-02-21 07:44 /user/word/output2/part-r-00002 -rw-r--r-- 2 hadoop hadoop 0 2019-02-21 07:44 /user/word/output2/part-r-00003 -rw-r--r-- 2 hadoop hadoop 10 2019-02-21 07:44 /user/word/output2/part-r-00004 -rw-r--r-- 2 hadoop hadoop 17 2019-02-21 07:44 /user/word/output2/part-r-00005 -rw-r--r-- 2 hadoop hadoop 25 2019-02-21 07:44 /user/word/output2/part-r-00006 # 실행 결과 확인 $ hadoop fs -cat /user/word/output2/part* Bye 1 Goodbye 1 Hadoop, 1 World, 1 Hello 2 World! 1 hadoop. 1 to 1 대소문자 구분하지 않고 실행 wordcount.case.sensitive 옵션을 이용하면 대소문자를 구분하지 않고 실행하게 할 수 있습니다. 실행 결과 다음처럼 모두 소문자로 바꾸어 확인하는 것을 알 수 있습니다. $ hadoop jar SdkMapreduce.jar sdk.WordCount2 -Dwordcount.case.sensitive=false /user/word/input2 /user/word/output2 # 실행 결과 확인 $ hadoop fs -cat /user/word/output2/part* bye 1 world! 1 hadoop, 1 hello 2 world, 1 goodbye 1 hadoop. 1 to 1 기호는 제거하고 처리하도록 실행 기호를 제거하고 실행하기 위해서 패턴 파일을 먼저 HDFS에 올려야 합니다. 패턴 파일을 업로두 후 실행하면 다음의 결과를 확인할 수 있습니다. $ cat replace.txt \! \, \. # 패턴 파일 업로드 $ hadoop fs -put ./replace.txt /user/word/replace.txt # 패턴 파일 실행 $ hadoop jar SdkMapreduce.jar sdk.WordCount2 -Dmapred.job.queue.name=queue_name -Dwordcount.case.sensitive=false /user/word/input2 /user/word/output2 -skip /user/word/replace.txt # 실행 결과 확인 $ hadoop fs -cat /user/word/output2/part* world 2 bye 1 hadoop 2 hello 2 goodbye 1 to 1 참고 Hadoop MapReduce Example: WordCount v2.0 (바로 가기) 2-보조 도구 맵리듀스 작업을 처리하는 데 도움을 주는 유틸리티성 도구를 알아보겠습니다. 카운터 하둡은 맵리듀스 잡의 진행 상황을 확인할 수 있는 카운터(Counter)를 제공합니다. 잡은 기본적으로 맵리듀스의 작업 상황 입출력 상황을 확인할 수 있는 카운터를 제공합니다. 사용자가 카운터를 생성하여 사용할 수도 있습니다. 18/10/19 08:23:02 INFO mapreduce.Job: Counters: 13 Job Counters Failed map tasks=4 Killed reduce tasks=7 Launched map tasks=4 Other local map tasks=3 Data-local map tasks=1 Total time spent by all maps in occupied slots (ms)=327375 Total time spent by all reduces in occupied slots (ms)=0 Total time spent by all map tasks (ms)=7275 Total time spent by all reduce tasks (ms)=0 Total vcore-milliseconds taken by all map tasks=7275 Total vcore-milliseconds taken by all reduce tasks=0 Total megabyte-milliseconds taken by all map tasks=10476000 Total megabyte-milliseconds taken by all reduce tasks=0 분산 캐시(Distributed Cache) 맵리듀스 잡에서 공유되는 데이터를 이용해야 할 때 분산 캐시를 사용합니다. 맵리듀스 잡에서 데이터를 조인해야 할 경우 이용할 수 있습니다. // 드라이버에 등록 Job job = new Job(); ... job.addCacheFile(new Path(filename).toUri()); // 맵퍼에서 사용 Path[] localPaths = context.getLocalCacheFiles(); 3-메모리 설정 맵리듀스의 메모리 설정은 mapred-site.xml 파일을 수정하여 변경할 수 있습니다. 기본값은 mapred-default.xml를 참고하면 됩니다. Mapper 와 Reducer 메모리 설정 yarn.app.mapreduce.am.resource.mb 노드에서 애플리케이션 마스터를 실행할 때 할당하는 메모리 yarn.app.mapreduce.am.command-opts 애플리케이션 마스터의 히프 사이즈 mapreduce.map.memory.mb 맵 컨테이너를 생성할 때 설정하는 메모리 mapreduce.map.java.opts 맵 컨테이너를 생성할 때 설정하는 자바 옵션 Xmx 옵션을 이용하여 히프 사이즈를 설정 맵 컨테이너 메모리(mapreduce.map.momory.mb)의 80%로 설정 mapreduce.map.cpu.vcores 맵 컨테이너에서 사용 가능한 가상 코어 개수 기본값은 1 mapreduce.reduce.memory.mb 리듀스 컨테이너를 생성할 때 설정하는 메모리 맵 컨테이너 메모리(mapreduce.map.memory.mb)의 2배로 설정하는 것이 일반적 mapreduce.reduce.java.opts 리듀스 컨테이너를 생성할 때 설정하는 자바 옵션 Xmx 옵션을 이용하여 히프 사이즈를 설정 리듀스 컨테이너 메모리의 80%로 설정 mapreduce.reduce.cpu.vcores 리듀스 컨테이너의 코어 개수 mapred.child.java.opts 맵과 리듀스 태스크의 JVM 실행 옵션, Heap 사이즈 설정 mapreduce.map.java.opts, mapreduce.reduce.java.opts 설정이 이 설정을 오버라이드 하여 설정 기본 설정은 -Xmx200m <property> <name>yarn.app.mapreduce.am.resource.mb</name> <value>2880</value> </property> <property> <name>mapreduce.map.memory.mb</name> <value>1024</value> </property> <property> <name>mapreduce.map.java.opts</name> <value>-Xmx820m</value> </property> <property> <name>mapreduce.map.cpu.vcores</name> <value>1</value> </property> MR 엔진 메모리 설정 MR 엔진의 메모리 설정은 다음과 같습니다. MR 컨테이너의 map을 reduce로 바꾸면 리듀서의 메모리 설정입니다. TEZ 엔진 메모리 설정 TEZ 엔진의 메모리 설정은 다음과 같습니다. 매퍼 설정 매퍼 처리 중 발생하는 임시 데이터의 처리를 위한 설정은 다음과 같습니다. mapreduce.task.io.sort.mb 맵의 출력 데이터를 저장할 환형 버퍼의 메모리 크기 맵의 처리 결과를 설정한 메모리에 저장하고 있다가, io.sort.spill.percent 이상에 도달하면 임시 파일로 출력 split/sort 작업을 위한 예약 메모리 매 퍼가 소팅에 사용하는 버퍼 사이즈를 설정 디스크에 쓰는 횟수가 줄어듦 mapreduce.map.sort.spill.percent 맵의 출력 데이터를 저장하는 버퍼(mapreduce.task.io.sort.mb)가 설정한 비율에 도달하면 로컬 디스크에 임시 파일 출력 mapreduce.task.io.sort.factor 하나의 정렬된 출력 파일로 병합하기 위한 임시 파일의 개수 mapreduce.cluster.local.dir 임시 파일이 저장되는 위치 <property> <name>mapreduce.task.io.sort.mb</name> <value>200</value> </property> <property> <name>mapreduce.map.sort.spill.percent</name> <value>0.80</value> </property> <property> <name>mapreduce.task.io.sort.factor</name> <value>100</value> </property> <property> <name>mapreduce.cluster.local.dir</name> <value>${hadoop.tmp.dir}/mapred/temp</value> </property> 셔플 설정 셔플 단계의 설정은 맵에서 전달받은 임시 데이터를 복사하는 메모리와 데이터를 복사하는 스레드의 개수 등이 있습니다. mapreduce.reduce.shuffle.parallelcopies 셔플 단계에서 맵의 결과를 리듀서로 전달하는 스레드의 개수 mapreduce.reduce.memory.total.bytes 셔플 단계에서 전달된 맵의 데이터를 복사하는 메모리 버퍼의 크기 기본값은 1024MB mapreduce.reduce.shuffle.input.buffer.percent 메모리 버퍼 크기의 비율을 넘어서면 파일로 저장하는데 이 비율을 지정해 주는 설정값 mapreduce.reduce.memory.total.bytes * mapreduce.reduce.shuffle.input.buffer.percent의 사이즈를 넘어서면 파일로 저장 기본값은 0.7 mapreduce.reduce.shuffle.memory.limit.percent 메모리 버퍼의 크기에 비해 파일의 비율이 이 설정을 넘어서면 바로 디스크에 쓰임 mapreduce.reduce.memory.total.bytes * mapreduce.reduce.shuffle.memory.limit.percent 크기를 넘어서면 파일로 저장 기본값은 0.25 <property> <name>mapreduce.reduce.shuffle.parallelcopies</name> <value>20</value> </property> <property> <name>mapreduce.reduce.memory.total.bytes</name> <value>1024MB</value> </property> <property> <name>mapreduce.reduce.shuffle.input.buffer.percent</name> <value>0.7</value> </property> <property> <name>mapreduce.reduce.shuffle.memory.limit.percent/name> <value>0.25</value> </property> 매퍼, 리듀서 개수 설정 매 퍼와 리듀서의 개수를 원하는 대로 설정할 수 있습니다. mapreduce.job.maps 매퍼의 개수 설정 mapreduce.job.reduces 리듀서 개수 설정 입력 사이즈에 따라 매퍼의 개수를 설정하기 위해서 다음과 같이 설정하면 됩니다. mapreduce.input.fileinputformat.split.maxsize 매퍼에 입력 가능한 최대 사이즈 처리하려고 하는 총 size/mapreduce.input.fileinputformat.split.maxsize = 매퍼 개수 mapreduce.input.fileinputformat.split.minsize 매퍼에 입력 가능한 최소 사이즈 단계별 메모리 설정 매리 듀스 단계의 자세한 메모리 설정은 다음과 같습니다. 참고 자료 ### YARN (MR2 Included) 설정 가이드 hadoop 메모리 설정 YARN & MRv2 리소스 설정 Hadoop Yarn memory settings in HDInsight YARN 설정값 설정 정보 튜닝 정보 mapred-site.xml MapReduce Tutorial 4-성능 최적화 맵리듀스는 여러 단계를 거치기 때문에 특정 설정 하나로 성능을 높이기는 어렵습니다. 작업 속도가 느린 이유는 여러 가지가 있을 수 때문에 다양한 방식으로 수정해 보는 것이 좋습니다. 매퍼, 리듀서 수 설정 매퍼수와 리듀서수에 따라 작업의 속도가 빨라질 수 있습니다. 매퍼 하나에 많은 파일이 몰리거나, 메모리를 많이 사용하는 작업이어서 GC에 많은 시간이 걸려서 그럴 수 있습니다. 원천 데이터의 입력 사이즈에 따라 매퍼, 리듀서의 개수를 조절해 주는 것이 좋습니다. <property> <name>mapreduce.job.maps</name> <value>100</value> </property> <property> <name>mapreduce.job.reduces</name> <value>50</value> </property> 정렬 속성 튜닝(io.sort.* 튜닝) 맵 작업은 임시 결과 파일 개수를 줄이는 것으로 성능을 개선할 수 있다. 로컬 디스크에 저장된 파일이 줄어들수록 맵 출력 데이터의 병합, 네트워크 전송, 리듀서의 병합 작업 시간이 단축됩니다. 스필 되는 파일을 줄이려면 스필전 메모리 버퍼 크기인 io.sort.mb를 늘이면 됩니다. 메모리 버퍼가 커져서 로컬에 저장될 출력 데이터가 줄어들게 됩니다. <property> <name>mapreduce.task.io.sort.mb</name> <value>200</value> </property> <property> <name>mapreduce.map.sort.spill.percent</name> <value>0.80</value> </property> <property> <name>mapreduce.task.io.sort.factor</name> <value>100</value> </property> 컴바이너 클래스 적용 컴바이너를 적용하면 맵 작업의 결과 데이터가 리듀서로 전송되기 전에 컴바이너 작업을 진행하여, 데이터를 줄여서 네트워크 사용량을 줄이고 리듀서의 작업 속도를 향상시킬 수 있습니다. job.setMapperClass(TokenizerMapper.class); job.setCombinerClass(IntSumReducer.class); // 콤바이너 적용 job.setReducerClass(IntSumReducer.class); 맵 출력 데이터 압축 맵 출력 데이터를 압축하여 네트워크 트래픽을 줄여 주면 플레인 텍스트를 이용할 때보다 속도가 증가할 수 있습니다. <property> <name>mapreduce.map.output.compress</name> <value>true</value> </property> <property> <name>mapreduce.map.output.compress.codec</name> <value>org.apache.hadoop.io.compress.SnappyCodec</value> </property> 작은 파일 문제(small file problem) 수정 네임노드는 파일의 메타데이터와 블록을 관리하는 데 많은 메모리를 사용합니다. 작은 사이즈의 파일이 여러 개 존재하게 되면 이 파일들을 관리하는데 많은 메모리가 사용되고, 맵리듀스 작업 처리 중 많은 요청을 처리하기 되어 네임노드에 병목현상이 발생하게 되어 작업 속도가 느려지게 됩니다. 이를 방지하기 위해서 작은 사이즈의 파일을 하나의 파일로 합쳐서 HDFS 블록 사이즈 크기의 파일로 설정하는 것이 좋습니다. 주요 해결 방법은 작은 사이즈의 파일을 합쳐서 하나의 파일로 생성하는 것입니다. 이를 위해 하둡은 har 파일을 생성하는 방법을 제공합니다. 다른 방법은 작은 파일을 묶어서 하나의 압축 파일로 생성하는 방법입니다. hadoop archives har-files-hadoop-archive-files 5-예제 맵리듀스 예제는 공공데이터 포털의 전국 CCTV 표준 데이터를 이용하여 진행하도록 하겠습니다. 공공데이터 포털에서 CSV 형태의 데이터로 다운로드 1 하고, HDFS에 업로드합니다. # CSV 데이터 확인 $ hadoop fs -ls /user/cctv/ Found 1 items -rw-r--r-- 2 hadoop hadoop 30805141 2018-10-19 08:11 /user/cctv/data.csv 관리 기관명 기준으로 건수 확인 매퍼 리듀서 Job 실행 결과 관리 기관명(키) 기준으로 정렬하여 건수 확인 파티셔너 job 실행 결과 관리기관, 설치 목적 기준으로 정렬하여 건수 확인 매퍼 복합키 파티셔너 SortComparator GroupingComparator 리듀서 Job 실행 결과 관리 기관명 기준으로 건수 확인 매퍼 전국 CCTV 표준 데이터의 첫 번째 칼럼 데이터가 관리 기관명입니다. 맵리듀스에서 이 데이터를 분리하기 위해서는 라인 단위로 데이터를 읽어서, 탭(\t)을 이용하여 데이터를 분리하고 첫 번째 인덱스의 데이터를 선택하면 됩니다. package com.sec.cctv; import java.io.IOException; import org.apache.hadoop.io.IntWritable; import org.apache.hadoop.io.Text; import org.apache.hadoop.mapreduce.Mapper; public class CctvMapper extends Mapper<Object, Text, Text, IntWritable> { private final static IntWritable one = new IntWritable(1); private Text word = new Text(); @Override protected void map(Object key, Text value, Mapper<Object, Text, Text, IntWritable>.Context context) throws IOException, InterruptedException { // 관리 기관명 추출 String[] strs = value.toString().split("\t"); word.set(strs[0]); context.write(word, one); } } 리듀서 리듀서로는 매퍼에서 쓴 데이터가 리스트 형태로 전달됩니다. 이 데이터를 모두 더하여 주면 결과를 확인할 수 있습니다. package com.sec.cctv; import java.io.IOException; import org.apache.hadoop.io.IntWritable; import org.apache.hadoop.io.Text; import org.apache.hadoop.mapreduce.Reducer; public class CctvReducer extends Reducer<Text, IntWritable, Text, IntWritable> { private IntWritable result = new IntWritable(); @Override protected void reduce(Text key, Iterable<IntWritable> values, Reducer<Text, IntWritable, Text, IntWritable>.Context context) throws IOException, InterruptedException { int sum = 0; for(IntWritable value : values) sum += value.get(); result.set(sum); context.write(key, result); } } Job 잡 함수는 작업에 관련된 정보를 전달합니다. 매퍼, 리듀서, 컴바이너를 설정하고 출력 데이터의 타입을 설정합니다. FileInputFormat에 입력, 출력 경로를 지정합니다. package com.sec.cctv; import java.io.IOException; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.Path; import org.apache.hadoop.io.IntWritable; import org.apache.hadoop.io.Text; import org.apache.hadoop.mapreduce.Job; import org.apache.hadoop.mapreduce.lib.input.FileInputFormat; import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat; public class CctvMain { public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException { Configuration conf = new Configuration(); Job job = Job.getInstance(conf, "cctv"); job.setJarByClass(CctvMain.class); job.setMapperClass(CctvMapper.class); job.setCombinerClass(CctvReducer.class); job.setReducerClass(CctvReducer.class); job.setOutputKeyClass(Text.class); job.setOutputValueClass(IntWritable.class); FileInputFormat.addInputPath(job, new Path(args[0])); FileOutputFormat.setOutputPath(job, new Path(args[1])); System.exit(job.waitForCompletion(true) ? 0 : 1); } } 실행 결과 우선 위의 데이터를 컴파일하고 jar 파일로 묶어 줍니다. 그리고 실행 방법은 아래와 같습니다. 출력 결과는 덮어쓰지 않기 때문에 재작업을 위해서는 출력 위치를 지워야 합니다. # 실행 $ hadoop jar cctv.jar com.sec.cctv.CctvMain /user/cctv/ /user/cctv_output/ 처리 결과는 아래와 같습니다. 리듀서의 개수만큼의 결과 파일이 생성되고, 처리 결과의 성공 여부를 알리기 위한 _SUCCESS 폴더가 생성됩니다. 파일의 내용을 확인하면 데이터가 잘 출력된 것을 알 수 있습니다. # 결과 확인 $ hadoop fs -ls /user/cctv_output/ Found 8 items -rw-r--r-- 2 hadoop hadoop 0 2018-10-19 08:36 /user/cctv_output/_SUCCESS -rw-r--r-- 2 hadoop hadoop 2869 2018-10-19 08:36 /user/cctv_output/part-r-00000 -rw-r--r-- 2 hadoop hadoop 2965 2018-10-19 08:36 /user/cctv_output/part-r-00001 -rw-r--r-- 2 hadoop hadoop 2052 2018-10-19 08:36 /user/cctv_output/part-r-00002 -rw-r--r-- 2 hadoop hadoop 2418 2018-10-19 08:36 /user/cctv_output/part-r-00003 -rw-r--r-- 2 hadoop hadoop 2786 2018-10-19 08:36 /user/cctv_output/part-r-00004 -rw-r--r-- 2 hadoop hadoop 2902 2018-10-19 08:36 /user/cctv_output/part-r-00005 -rw-r--r-- 2 hadoop hadoop 2986 2018-10-19 08:36 /user/cctv_output/part-r-00006 # 파일의 내용 확인 $ hadoop fs -cat /user/cctv_output/part-r-00003 CCTV 통합관제센터 160 강원랜드 56 경기도 광명시 정보 통신과 342 경기도 시흥시청 1112 경기도 안양시 (교통정책과) 1041 경기도 양평군청 997 맵리듀스를 실행하면 다음과 같은 로그를 확인할 수 있습니다. 이 로그에 데이터 처리에 사용된 리소스 정보를 확인할 수 있습니다. 사용된 매퍼, 리듀서, 컴바이너의 수와 사용량 등을 확인할 수 있습니다. $ hadoop jar cctv.jar com.sec.cctv.CctvMain /user/cctv/ /user/cctv_output/ 18/10/19 09:11:39 INFO impl.TimelineClientImpl: Timeline service address: http://host_url:8188/ws/v1/timeline/ 18/10/19 09:11:40 INFO client.RMProxy: Connecting to ResourceManager at host_url/host_url:8032 18/10/19 09:11:40 WARN mapreduce.JobResourceUploader: Hadoop command-line option parsing not performed. Implement the Tool interface and execute your application with ToolRunner to remedy this. 18/10/19 09:11:40 INFO input.FileInputFormat: Total input paths to process : 1 18/10/19 09:11:40 INFO lzo.GPLNativeCodeLoader: Loaded native gpl library 18/10/19 09:11:40 INFO lzo.LzoCodec: Successfully loaded & initialized native-lzo library [hadoop-lzo rev 418fa8c602f2a4b153c1a89806305f 6b5a27a524] 18/10/19 09:11:40 INFO mapreduce.JobSubmitter: number of splits:1 18/10/19 09:11:40 INFO Configuration.deprecation: mapred.job.queue.name is deprecated. Instead, use mapreduce.job.queuename 18/10/19 09:11:40 INFO mapreduce.JobSubmitter: Submitting tokens for job: job_1520227878653_30488 18/10/19 09:11:40 INFO impl.YarnClientImpl: Submitted application application_1520227878653_30488 18/10/19 09:11:40 INFO mapreduce.Job: The url to track the job: http://host_url:20888/proxy/application_1520227878653_30488/ 18/10/19 09:11:40 INFO mapreduce.Job: Running job: job_1520227878653_30488 18/10/19 09:11:45 INFO mapreduce.Job: Job job_1520227878653_30488 running in uber mode : false 18/10/19 09:11:45 INFO mapreduce.Job: map 0% reduce 0% 18/10/19 09:11:50 INFO mapreduce.Job: map 100% reduce 0% 18/10/19 09:11:54 INFO mapreduce.Job: map 100% reduce 29% 18/10/19 09:11:55 INFO mapreduce.Job: map 100% reduce 43% 18/10/19 09:11:56 INFO mapreduce.Job: map 100% reduce 86% 18/10/19 09:11:57 INFO mapreduce.Job: map 100% reduce 100% 18/10/19 09:11:57 INFO mapreduce.Job: Job job_1520227878653_30488 completed successfully 18/10/19 09:11:57 INFO mapreduce.Job: Counters: 49 File System Counters FILE: Number of bytes read=12425 FILE: Number of bytes written=1043109 FILE: Number of read operations=0 FILE: Number of large read operations=0 FILE: Number of write operations=0 HDFS: Number of bytes read=30805288 HDFS: Number of bytes written=18978 HDFS: Number of read operations=24 HDFS: Number of large read operations=0 HDFS: Number of write operations=14 Job Counters Launched map tasks=1 Launched reduce tasks=7 Data-local map tasks=1 Total time spent by all maps in occupied slots (ms)=115650 Total time spent by all reduces in occupied slots (ms)=1541250 Total time spent by all map tasks (ms)=2570 Total time spent by all reduce tasks (ms)=17125 Total vcore-milliseconds taken by all map tasks=2570 Total vcore-milliseconds taken by all reduce tasks=17125 Total megabyte-milliseconds taken by all map tasks=3700800 Total megabyte-milliseconds taken by all reduce tasks=49320000 Map-Reduce Framework Map input records=139632 Map output records=139632 Map output bytes=4103862 Map output materialized bytes=12397 Input split bytes=147 Combine input records=139632 Combine output records=635 Reduce input groups=635 Reduce shuffle bytes=12397 Reduce input records=635 Reduce output records=635 Spilled Records=1270 Shuffled Maps =7 Failed Shuffles=0 Merged Map outputs=7 GC time elapsed (ms)=529 CPU time spent (ms)=9210 Physical memory (bytes) snapshot=2002321408 Virtual memory (bytes) snapshot=34572668928 Total committed heap usage (bytes)=1917845504 Shuffle Errors BAD_ID=0 CONNECTION=0 IO_ERROR=0 WRONG_LENGTH=0 WRONG_MAP=0 WRONG_REDUCE=0 File Input Format Counters Bytes Read=30805141 File Output Format Counters Bytes Written=18978 관리 기관명(키) 기준으로 정렬하여 건수 확인 다음 예제는 리듀서의 키를 기준으로 정렬하여 건수를 확인하는 방법입니다. 매퍼의 결과는 리듀서로 전달할 때 셔플 & 정렬 과정을 거치게 됩니다. 이때 키를 기준으로 정렬되어 리듀서에 전달됩니다. 이때 파티셔너가 키를 분류하는 기준이 되고, 기본 파티셔너는 해시 파티셔너 입니다. 관리 기관명 기준으로 정렬을 하여 데이터를 확인하기 위해서는 해시 파티셔너를 대체할 파티셔너를 구현해야 합니다. 그리고 정렬을 위해서는 모든 데이터를 같이 봐야 하기 때문에 리듀서의 개수를 하나로 해야 합니다. 리듀서 개수를 하나로 하지 않으면 파일별로 정렬된 데이터가 출력됩니다. 파티셔너 파티셔너는 다음과 같이 getPartition() 메서드를 구현하면 됩니다. 여기서는 키 첫 번째 문자가 파티션을 나누는 기준이 되도록 설정하였습니다. package com.sec.cctv; import org.apache.hadoop.io.IntWritable; import org.apache.hadoop.io.Text; import org.apache.hadoop.mapreduce.Partitioner; public class CctvPartitioner extends Partitioner<Text, IntWritable> { @Override public int getPartition(Text key, IntWritable value, int numPartitions) { return (key.toString().charAt(0)) % numPartitions; } } job 잡에서 리듀서의 개수를 1개로 설정하고, 파티셔너를 추가해 주면 됩니다. package com.sec.cctv; import java.io.IOException; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.Path; import org.apache.hadoop.io.IntWritable; import org.apache.hadoop.io.Text; import org.apache.hadoop.mapreduce.Job; import org.apache.hadoop.mapreduce.lib.input.FileInputFormat; import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat; public class CctvMain { public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException { Configuration conf = new Configuration(); Job job = Job.getInstance(conf, "cctv"); job.setJarByClass(CctvMain.class); job.setNumReduceTasks(1); job.setMapperClass(CctvMapper.class); job.setCombinerClass(CctvReducer.class); job.setPartitionerClass(CctvPartitioner.class); job.setReducerClass(CctvReducer.class); job.setOutputKeyClass(Text.class); job.setOutputValueClass(IntWritable.class); FileInputFormat.addInputPath(job, new Path(args[0])); FileOutputFormat.setOutputPath(job, new Path(args[1])); System.exit(job.waitForCompletion(true) ? 0 : 1); } } 실행 결과 파티션을 추가한 맵리듀스를 실행하면 결과를 다음과 같이 확인할 수 있습니다. # 실행 결과 $ hadoop fs -ls /user/cctv_output/ Found 2 items -rw-r--r-- 2 hadoop hadoop 0 2018-10-19 09:59 /user/cctv_output/_SUCCESS -rw-r--r-- 2 hadoop hadoop 18978 2018-10-19 09:59 /user/cctv_output/part-r-00000 # 파일 내용 $ hadoop fs -cat /user/cctv_output/part-r-00000 CCTV 통합관제센터 160 가오리 1 가평군청 9 강릉 시청 1 강북 공영주차장 4 강북구 2 강북문화 예술 회관 1 강북문화 정보도서관 1 강북웰빙스포츠센터 관리기관, 설치 목적 기준으로 정렬하여 건수 확인 이번에는 복합키를 이용하여 데이터를 정렬하는 방법을 확인해 보겠습니다. 관리기관과 설치 목적을 이용하여 관리기관별 설치 목적 건수와 모든 CCTV의 건수를 조회하도록 하겠습니다. 기존과 같이 관리기관을 키로 하면 설치 목적을 리듀서별로 전달할 수 없게 됩니다. 관리기관과 설치 목적을 연결하여 하나의 키(ex: 관리기관_설치 목적)로 이용하면, 서로 다른 리듀서로 보내질 수 있습니다. 이럴 때는 세컨더리 소트(Secondary Sort)를 이용하여 처리할 수 있습니다. 세컨더리 소트를 이용하기 위해서는 리듀서의 전체 입력을 정렬하는 기준이 되는 SortComparator와 리듀서의 reduce() 메서드로 데이터를 전달할 때 Iterable(values)를 만들기 위한 그룹핑 기준이 되는 GroupingComparator를 구현해야 합니다. 매퍼의 출력으로 <<관리기관, 목적>, 목적>과같이 출력합니다. 파티셔너는 복합키 중 관리기관을 기준으로 리듀서를 나누어줍니다. 리듀서는 복합키를 이용하여 관리기관, 목적 순으로 정렬을 수행합니다. 그리고 리듀서에 데이터를 넘기는 그룹핑 기준을 복합키의 관리기관을 이용하여 처리합니다. 리듀서는 입력으로 <<관리기관, 목적>, List<목적>>을 입력으로 받습니다. 여기서 목적의 유니크한 값과 리스트의 전체 개수를 세면 관리기관별 설치 목적의 건수와 모든 CCTV의 건수를 알 수 있게 됩니다. # 결과 출력 십 리 대밭축구장 1 4 # 다목적 1개의 용도로 4개의 CCTV를 가짐 합천군청 6 326 매퍼 매퍼에서는 관리기관과 설치 목적을 추출하고, 복합키(CctvComparePair)를 생성합니다. 매퍼의 밸류는 목적을 입력하고 결과를 출력합니다. package com.sec.cctv_2; import java.io.IOException; import org.apache.hadoop.io.Text; import org.apache.hadoop.mapreduce.Mapper; public class CctvMapper extends Mapper<Object, Text, CctvComparePair, Text> { private final static Text one = new Text(); @Override protected void map(Object key, Text value, Mapper<Object, Text, CctvComparePair, Text>.Context context) throws IOException, InterruptedException { String[] strs = value.toString().split("\t"); String admin = strs[0]; // 관리 기관명 추출 String purpose = strs[3]; // 설치 목적 추출 CctvComparePair pair = new CctvComparePair(admin, purpose); one.set(purpose); context.write(pair, one); } } 복합키 복합 키는 관리기관과 설치 목적을 같이 이용하기 위해서 생성하는 클래스입니다. 비교 연산과 쓰기(write)를 위해서 WritableComparable을 구현합니다. compareTo()를 구현하여 복합키 비교의 우선순위를 구해줍니다. package com.sec.cctv_2; import java.io.DataInput; import java.io.DataOutput; import java.io.IOException; import org.apache.hadoop.io.WritableComparable; /** * 정렬하고자 하는 세컨더리 키를 포함하는 복합 클래스 * @author User * */ public class CctvComparePair implements WritableComparable<CctvComparePair> { private String admin; private String purpose; public CctvComparePair() { } public CctvComparePair(String admin, String road) { super(); this.admin = admin; this.purpose = road; } @Override public void write(DataOutput out) throws IOException { out.writeUTF(admin); out.writeUTF(purpose); } @Override public void readFields(DataInput in) throws IOException { admin = in.readUTF(); purpose = in.readUTF(); } @Override public int compareTo(CctvComparePair key) { int result = admin.compareTo(key.admin); if (result == 0) { result = purpose.compareTo(key.purpose); } return result; } @Override public String toString() { return new StringBuffer().append(admin).append("\t").append(purpose).toString(); } public String getAdmin() { return admin; } public void setAdmin(String admin) { this.admin = admin; } public String getPurpose() { return purpose; } public void setPurpose(String road) { this.purpose = road; } } 파티셔너 파티셔너는 리듀서를 구분하는 기준이 되므로 관리기관을 기준으로 리듀서를 구분해 줍니다. package com.sec.cctv_2; import org.apache.hadoop.io.Text; import org.apache.hadoop.mapreduce.Partitioner; /** * 관리 기관을 기준으로 하는 커스텀 파티셔너 * * @author User * */ public class CctvPartitioner extends Partitioner<CctvComparePair, Text> { @Override public int getPartition(CctvComparePair key, Text value, int numPartitions) { return (key.getAdmin().charAt(0)) % numPartitions; } } SortComparator 리듀서의 전체 입력을 정렬하는 기준이 되는 SortComparator를 구현해 줍니다. 리듀서의 전체 입력은 관리기관, 설치 목적을 기준으로 정렬합니다. package com.sec.cctv_2; import org.apache.hadoop.io.WritableComparable; import org.apache.hadoop.io.WritableComparator; /** * 리듀서의 전체 입력을 정렬하는 기준이 되는 SortComparator * * @author User * */ public class CctvSortComparator extends WritableComparator { public CctvSortComparator() { super(CctvComparePair.class, true); } @Override public int compare(WritableComparable a, WritableComparable b) { CctvComparePair x = (CctvComparePair) a; CctvComparePair y = (CctvComparePair) b; return x.compareTo(y); } } GroupingComparator 리듀서에서 실제 작업을 진행하는 reduce(KEYIN key, Iterable values, Context context) 메서드에 values 데이터를 전달하기 위한 그룹핑을 처리하는 클래스를 구현합니다. 관리기관을 기준으로 그룹핑을 처리하여 전달하기 위해 관리 기관명으로 데이터를 비교합니다. 이제 reduce() 메서드에는 관리기관을 기준으로 정렬된 List<설치 목적> 값이 전달되게 됩니다. package com.sec.cctv_2; import org.apache.hadoop.io.WritableComparable; import org.apache.hadoop.io.WritableComparator; /** * reduce()의 values를 그룹핑하는 커스텀 그룹핑 Comparator * * @author User * */ public class CctvGroupingComparator extends WritableComparator { public CctvGroupingComparator() { super(CctvComparePair.class, true); } @Override public int compare(WritableComparable a, WritableComparable b) { CctvComparePair x = (CctvComparePair) a; CctvComparePair y = (CctvComparePair) b; return x.getAdmin().compareTo(y.getAdmin()); } } 리듀서 리듀서는 관리주체를 기준으로 정렬된 List<목적> 데이터를 입력으로 받습니다. 이를 이용하여 유니크한 목적의 개수(관리주체별 목적), 전체 목적의 개수(CCTV의 개수)를 세어서 출력하면 됩니다. package com.sec.cctv_2; import java.io.IOException; import org.apache.hadoop.io.Text; import org.apache.hadoop.mapreduce.Reducer; public class CctvReducer extends Reducer<CctvComparePair, Text, Text, Text> { private Text outputKey = new Text(); private Text outputValue = new Text(); @Override protected void reduce(CctvComparePair key, Iterable<Text> values, Reducer<CctvComparePair, Text, Text, Text>.Context context) throws IOException, InterruptedException { int uniq = 0; int sum = 0; String previous = ""; for (Text value : values) { String current = value.toString(); if (!previous.equals(current)) { uniq++; previous = current; } sum++; } outputKey.set(key.getAdmin()); outputValue.set(new StringBuffer().append(uniq).append("\t").append(sum).toString()); context.write(outputKey, outputValue); } } Job 잡에서는 파티션, 소트, 그룹핑을 위한 클래스를 설정하고, 이번에는 매퍼의 출력과 리듀서의 출력이 다르기 때문에 각각의 값을 설정해 주는 작업을 추가합니다. package com.sec.cctv_2; import java.io.IOException; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.Path; import org.apache.hadoop.io.Text; import org.apache.hadoop.mapreduce.Job; import org.apache.hadoop.mapreduce.lib.input.FileInputFormat; import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat; public class CctvMain { public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException { Configuration conf = new Configuration(); Job job = Job.getInstance(conf, "cctv"); job.setJarByClass(CctvMain.class); // 매퍼 리듀서 job.setMapperClass(CctvMapper.class); job.setReducerClass(CctvReducer.class); // 파티셔너, 소트, 그룹핑 job.setPartitionerClass(CctvPartitioner.class); job.setSortComparatorClass(CctvSortComparator.class); job.setGroupingComparatorClass(CctvGroupingComparator.class); // 맵의 출력 job.setMapOutputKeyClass(CctvComparePair.class); job.setMapOutputValueClass(Text.class); // 리듀서의 출력 job.setOutputKeyClass(Text.class); job.setOutputValueClass(Text.class); FileInputFormat.addInputPath(job, new Path(args[0])); FileOutputFormat.setOutputPath(job, new Path(args[1])); System.exit(job.waitForCompletion(true) ? 0 : 1); } } 실행 결과 작업의 실행 결과는 다음과 같이 확인할 수 있습니다. $ hadoop fs -ls /user/cctv_2_output/ Found 8 items -rw-r--r-- 2 hadoop hadoop 0 2018-10-23 07:15 /user/cctv_2_output/_SUCCESS -rw-r--r-- 2 hadoop hadoop 0 2018-10-23 07:15 /user/cctv_2_output/part-r-00000 -rw-r--r-- 2 hadoop hadoop 0 2018-10-23 07:15 /user/cctv_2_output/part-r-00001 -rw-r--r-- 2 hadoop hadoop 16402 2018-10-23 07:15 /user/cctv_2_output/part-r-00002 -rw-r--r-- 2 hadoop hadoop 850 2018-10-23 07:15 /user/cctv_2_output/part-r-00003 -rw-r--r-- 2 hadoop hadoop 481 2018-10-23 07:15 /user/cctv_2_output/part-r-00004 -rw-r--r-- 2 hadoop hadoop 45 2018-10-23 07:15 /user/cctv_2_output/part-r-00005 -rw-r--r-- 2 hadoop hadoop 2473 2018-10-23 07:15 /user/cctv_2_output/part-r-00006 $ hadoop fs -cat /user/cctv_2_output/part-r-00005 충청북도 단양군청 3 184 충청북도 보은군청 5 201 충청북도 영동군청 8 244 충청북도 옥천군청 3 278 CSV 데이터를 다운로드하면 euc-kr 인코딩이라서 하둡에서 한글이 깨질 수도 있습니다. 다운로드하시면 메모장 등을 이용하여 UTF-8 인코딩으로 변환하여 주십시오. ↩ 1-맵리듀스 기본 예제 하둡에서 기본적으로 제공하는 맵리듀스 예제를 알아보겠습니다. 다음 예제들을 이용하여 하둡의 설치 상태, 성능 테스트를 해볼 수 있습니다. pi pi 값을 계산합니다. export HADOOP_ROOT_LOGGER=INFO, console hadoop jar /opt/hadoop/share/hadoop/mapreduce/hadoop-mapreduce-examples-2.10.0.jar \ pi 32 10000000 4-YARN YARN(Yet Another Resource Negotiator)은 하둡 2에서 도입한 클러스터 리소스 관리 및 애플리케이션 라이프 사이클 관리를 위한 아키텍처입니다. 등장 배경 하둡 1에서는 잡트래커가 애플리케이션의 라이프 사이클 관리와 클러스터 리소스 관리를 모두 담당하여 병목 현상이 발생하였습니다. 잡트래커 한 대가 클러스터의 모든 노드를 관리해야 하고, 모든 애플리케이션의 관리하였기 때문에 잡트래커에 많은 메모리를 할당해야 했고, 최대 4000대의 노드까지 관리할 수 있었습니다. 잡트래커는 슬롯 단위로 리소스를 관리하여 시스템의 전체 자원을 효율적으로 사용할 수 없었습니다. 슬롯 단위 리소스 관리는 클러스터의 메모리, CPU 자원을 분할하여 슬롯 단위로 구분합니다. 100GB의 메모리를 가지는 클러스터를 1G로 구분하여 100개의 슬롯을 만들고, 60개의 맵 슬롯, 40개의 리듀서 슬롯으로 구분합니다. 슬롯은 각각의 역할에 맞게 동작할 수 있습니다. 따라서 맵 슬롯이 동작하는 동안 리듀서 슬롯은 대기하게 됩니다. 맵 슬롯에 더 많은 일을 하게 되더라도 리듀서 슬롯은 대기하게 됩니다. 잡 트래커의 애플리케이션은 맵리듀스 작업만 처리할 수 있어서 유연성이 부족하였습니다. 맵리듀스 API를 구현한 작업만 처리할 수 있었기 때문에 SQL 기반 작업의 처리나, 인 메모리 기반의 작업의 처리에 어려움이 있었습니다. 이런 단점을 극복하기 위하여 YARN 아키텍처가 도입되었습니다. YARN 구성 YARN은 잡트래커의 기능을 분리하여 자원 관리는 리소스 매니저와 노드 매니저, 애플리케이션 라이프 사이클 관리 기능은 애플리케이션 마스터와 컨테이너가 담당하도록 하였습니다. 자원관리 클러스터 자원 관리는 리소스 매니저(ResourceManager)와 노드 매니저(NodeManager)를 이용하여 처리합니다. 노드 매니저는 클러스터의 각 노드마다 실행됩니다. 현재 노드의 자원 상태를 관리하고, 리소스 매니저에 현재 자원 상태를 보고합니다. 리소스 매니저는 노드 매니저로부터 전달받은 정보를 이용하여 클러스터 전체의 자원을 관리합니다. 자원 사용 상태를 모니터링하고, 애플리케이션 마스터에서 자 자원을 요청하면 비어 있는 자원을 사용할 수 있도록 처리합니다. 자원을 분배하는 규칙을 설정하는 것이 스케줄러(Scheduler)입니다. 스케줄러에 설정된 규칙에 따라 자원을 효율적으로 분배합니다. 라이프사이클 관리 애플리케이션의 라이프 사이클 관리는 애플리케이션 마스터(Application Master)와 컨테이너(Container)를 이용하여 처리합니다. 클라이언트가 리소스 매니저에 애플리케이션을 제출하면, 리소스 매니저는 비어 있는 노드에서 애플리케이션 마스터를 실행합니다. 애플리케이션 마스터는 작업 실행을 위한 자원을 리소스 매니저에 요청하고, 자원을 할당받아서 각 노드에 컨테이너를 실행하고, 실제 작업을 진행합니다. 컨테이너는 실제 작업이 실행되는 단위입니다. 컨테이너에서 작업이 종료되면 결과를 애플리케이션 마스터에게 알리고 애플리케이션 마스터는 모든 작업이 종료되면 리소스 매니저에 알리고 자원을 해제합니다. 다양한 애플리케이션 YARN에서는 맵리듀스 API로 구현된 프로그램 외에도 다양한 애플리케이션을 실행할 수 있습니다. 맵리듀스, 피그, 스톰, 스파크 등 하둡 에코 시스템의 다양한 데이터 처리 기술을 이용할 수 있습니다. 최대 1만 개의 노드 관리 기능 분리를 통하여 1만 대 이상의 클러스터로 확장할 수 있도록 확장성을 제공하였습니다. 1-YARN-Scheduler 리소스 매니저는 클러스터 자원을 관리하고, 애플리케이션 마스터의 요청을 받아서 자원을 할당합니다. 자원 할당을 위한 정책을 스케줄러라고 합니다. 하둡에서 제공하는 기본 스케줄러는 다음과 같습니다. 피포(FIFO) 스케줄러 페어(Fair) 스케줄러 커패시티(Capacity) 스케줄러 스케줄러 설정 스케줄러는 yarn-site.xml 파일에 설정합니다. yarn.resourcemanager.scheduler.class에 다음의 클래스명을 적어주면 됩니다. 스케줄러 클래스명 FIFO 스케줄러 org.apache.hadoop.yarn.server.resourcemanager.scheduler.fifo.FifoScheduler Fair 스케줄러 org.apache.hadoop.yarn.server.resourcemanager.scheduler.fair.FairScheduler Capacity 스케줄러 org.apache.hadoop.yarn.server.resourcemanager.scheduler.capacity.CapacityScheduler 스케줄러 설정 방법은 다음과 같습니다. <property> <name>yarn.resourcemanager.scheduler.class</name> <value>org.apache.hadoop.yarn.server.resourcemanager.scheduler.capacity.CapacityScheduler</value> </property> FIFO Scheduler FIFO 스케줄러는 이름과 같이 먼저 들어온 작업이 먼저 처리됩니다. 작업의 제출 순서대로 처리되고, 먼저 들어온 작업이 종료될 때까지 다음 작업은 대기합니다. 이로 인해 자원을 효율적으로 사용할 수 없기 때문에 FIFO 스케줄러는 테스트 목적으로만 사용하는 것이 좋습니다. Fair Scheduler Fair 스케줄러는 제출된 작업이 동등하게 리소스를 점유합니다. 작업 큐에 작업이 제출되면 클러스터는 자원을 조절하여 작업에 균등하게 자원을 할당하여 줍니다. Capacity Scheduler 하둡 2의 기본 스케줄러입니다. 트리 형태로 큐를 선언하고 각 큐 별로 이용할 수 있는 자원의 용량을 정하여 주면 그 용량에 맞게 자원을 할당하여 줍니다. 참고 Fair scheduler 설정: 바로 가기 Capacity scheduler 설정: 바로 가기 1-커패시티 스케줄러(Capacity Scheduler) 스케줄러 설정값 capacity-scheduler.xml 주요 설정 사용자 큐 매핑(queue-mappings) 스케줄러 설정 큐의 계층 구조 capacity-scheduler.xml 설정 스케줄러 설정 확인 큐 설정 변경 스케줄러 설정 시 주의 사항 참고 하둡 2의 기본 스케줄러인 커패시티 스케줄러(Capacity Scheduler)에 대해서 알아보겠습니다. 커패시티 스케줄러는 트리 형태로 계층화된 큐를 선언하고, 큐별로 사용 가능한 용량을 할당하여 자원을 관리합니다. 예를 들어 100G의 메모리 용량을 가지는 클러스터에서 A, B 두 개의 큐에 각각 40%, 60%의 용량(capacity)를 설정하면 A 큐는 40G, B 큐는 60G의 메모리를 사용할 수 있습니다. 만약 클러스터의 자원에 여유가 있다면 설정을 이용하여 각 큐에 설정된 용량 이상의 자원을 이용하게 할 수도 있고, 운영 중에도 큐를 추가할 수 있는 유연성도 가지고 있습니다. 스케줄러 설정값 커패시티 스케줄러의 주요 설정값은 다음과 같습니다. 설정값 비고 yarn.scheduler.capacity.maximum-applications PRE, RUNNIG 상태로 설정될 수 있는 최대 애플리케이션의 개수 yarn.scheduler.capacity.maximum-am-resource-percent 애플리케이션 마스터(AM)에 할당 가능한 최대 비율. AM은 실제 작업이 돌지 않고 작업을 관리하는 역할을 하기 때문에 작업에 많은 컨테이너를 할당하기 위해 이 값을 적당히 조절해야 함 yarn.scheduler.capacity.root.queues root 큐에 등록하는 큐의 이름. root 큐는 하위에 동록할 큐를 위해 논리적으로만 존재 yarn.scheduler.capacity.root.[큐 이름].maximum-am-resource-percent 큐에서 AM이 사용할 수 있는 자원의 비율 yarn.scheduler.capacity.root.[큐 이름].capacity 큐의 용량 비율 yarn.scheduler.capacity.root.[큐 이름].user-limit-factor 큐에 설정된 용량 * limit-factor 만큼 다른 큐의 용량을 사용할 수 있음. 클러스터의 자원을 효율적으로 사용할 수 있음. maxmimum-capacity 이상으로는 이용할 수 없음. yarn.scheduler.capacity.root.[큐 이름].maximum-capacity 큐가 최대로 사용할 수 있는 용량 capacity-scheduler.xml 주요 설정 <configuration> <property> <name>yarn.scheduler.capacity.maximum-applications</name> <value>10000</value> </property> <property> <name>yarn.scheduler.capacity.maximum-am-resource-percent</name> <value>0.1</value> <description> 애플리케이션 마스터에 할당 가능한 최대 비율. </description> </property> <property> <name>yarn.scheduler.capacity.resource-calculator</name> <value>org.apache.hadoop.yarn.util.resource.DefaultResourceCalculator</value> </property> <property> <name>yarn.scheduler.capacity.root.queues</name> <value>prd, stg</value> <description> The queues at the this level (root is the root queue). </description> </property> <!-- capacity --> <property> <name>yarn.scheduler.capacity.root.prd.capacity</name> <value>80</value> </property> <property> <name>yarn.scheduler.capacity.root.stg.capacity</name> <value>20</value> </property> <!-- user-limit-factor --> <property> <name>yarn.scheduler.capacity.root.prd.user-limit-factor</name> <value>1</value> </property> <property> <name>yarn.scheduler.capacity.root.stg.user-limit-factor</user-limit-factor</name> <value>2</value> </property> <!-- maximum-capacity --> <property> <name>yarn.scheduler.capacity.root.prd.maximum-capacity</name> <value>100</value> </property> <property> <name>yarn.scheduler.capacity.root.stg.maximum-capacity</name> <value>30</value> </property> </configuration> 사용자 큐 매핑(queue-mappings) 사용자가 큐를 지정하지 않아도, 자동으로 사용자와 큐가 매핑 되게 할 수 있습니다. u:유저명:큐 유저와 큐를 매핑 g:그룹명:큐 그룹과 큐를 매핑 u:%user:%user 유저를 유저명 큐에 매핑 u:%user:%primary_group 유저를 유저의 프라이머리 그룹명 큐에 매핑 queue-mappings 설정에 정의된 순서에 따라 큐를 적용합니다. 큐가 생성되어 있지 않으면 오류가 발생하게 됩니다. <property> <name>yarn.scheduler.capacity.queue-mappings</name> <value>u:user1:queue1, g:group1:queue2, u:%user:%user, u:user2:%primary_group</value> <description> Here, <user1> is mapped to <queue1>, <group1> is mapped to <queue2>, maps users to queues with the same name as user, <user2> is mapped to queue name same as <primary group> respectively. The mappings will be evaluated from left to right, and the first valid mapping will be used. </description> </property> 스케줄러 설정 다음은 계층구조로 큐를 설정하는 예제입니다. 아래에서 사용하는 큐는 prod, dev, eng, science입니다. root 아래 prod, dev가 등록되고, dev 아래 eng, science 큐가 등록되어 있습니다. 큐의 계층 구조 root prod[capacity:40%, max:100%] dev[capacity:60%, max:75%] eng[capacity:50%] science[capacity:50%] capacity-scheduler.xml 설정 큐별 설정값을 지정할 때는 xml의 name에 큐의 계층 형태로 설정할 큐 이름을 지정해야 합니다. <?xml version="1.0"?> <configuration> <property> <name>yarn.scheduler.capacity.root.queues</name> <value>prod, dev</value> </property> <property> <name>yarn.scheduler.capacity.root.dev.queues</name> <value>eng, science</value> </property> <property> <name>yarn.scheduler.capacity.root.prod.capacity</name> <value>40</value> </property> <property> <name>yarn.scheduler.capacity.root.dev.capacity</name> <value>60</value> </property> <property> <name>yarn.scheduler.capacity.root.dev.maximum-capacity</name> <value>75</value> </property> <property> <name>yarn.scheduler.capacity.root.dev.eng.capacity</name> <value>50</value> </property> <property> <name>yarn.scheduler.capacity.root.dev.science.capacity</name> <value>50</value> </property> </configuration> 스케줄러 설정 확인 설정된 큐의 목록과 현재 사용 중인 용량을 확인하는 명령어는 다음과 같습니다. 위의 예제에 설정된 정보는 다음과 같이 출력됩니다. # Capacity: 설정된 용량 # MaximumCapacity: 최대 사용할 수 있는 용량, 기본값 100 # CurrentCapacity: 현재 사용 중인 용량 $ mapred queue -list ====================== Queue Name : prod Queue State : running Scheduling Info : Capacity: 20.0, MaximumCapacity: 100.0, CurrentCapacity: 0.0 ====================== Queue Name : dev Queue State : running Scheduling Info : Capacity: 60.0, MaximumCapacity: 75.0, CurrentCapacity: 0.0 ====================== Queue Name : eng Queue State : running Scheduling Info : Capacity: 50.0, MaximumCapacity: 100.0, CurrentCapacity: 0.0 ====================== Queue Name : science Queue State : running Scheduling Info : Capacity: 50.0, MaximumCapacity: 100.0, CurrentCapacity: 0.0 큐 설정 변경 운영 중 스케줄러의 설정을 변경할 때는 capacity-scheduler.xml 파일을 수정하고 다음 명령을 이용해서 설정을 변경하면 됩니다. capacity, user-limit-factor, maximum-capacity 수정, root의 신규 큐 추가는 가능하지만, 큐를 삭제할 때는 큐를 STOPPED 상태로 변경 후 처리 중인 작업이 없을 때 삭제 가능합니다. # capacity-scheduler.xml 을 설정을 통해 큐를 다시 설정 $ yarn rmadmin -refreshQueues 스케줄러 설정 시 주의 사항 커패시티 스케줄러를 설정할 때는 큐의 역할에 따라 용량을 잘 배분하고, 최대 사용 가능 용량(maximum-capacity)과 사용자 제한(user-limit-factor)을 이용하여 사용할 수 있는 자원의 용량을 제한해 주는 것이 중요합니다. 큐마다 사용할 수 있는 용량이 있지만 전체 클러스터에 여유가 있는 경우 기본 용량에 사용자 제한을 곱한 용량(capacity * user-limit-factor) 또는 이 값이 최대 사용 가능 용량을 넘어서는 경우 최대 사용 가능 용량만큼 할당됩니다. 큐의 용량 = min(capacity * user-limit-factor, maximum-capacity) 애플리케이션 마스터에 할당되는 용량 비율(yarn.scheduler.capacity.maximum-am-resource-percent)을 잘 조절해야 합니다. 제출된 작업이 많아지면서 애플리케이션 마스터가 많은 자원을 가져가면, 컨테이너를 생성할 자원이 부족해지기 때문입니다. 작업의 종류에 따라 적절한 비율을 찾는 것이 중요합니다. 참고 Capacity scheduler 설정: 바로 가기 2-페어 스케줄러(Fair Scheduler) 스케줄러 설정값 yarn-site.xml fair-scheduler.xml 참고 하둡의 페어 스케줄러(Fair Scheduler)에 대해서 알아보겠습니다. 페어 스케줄러는 제출된 작업이 동등하게 리소스를 점유할 수 있도록 지원합니다. 작업 큐에 작업이 제출되면 클러스터는 자원을 조절하여 모든 작업에 균등하게 자원을 할당하여 줍니다. 메모리와 CPU를 기반으로 자원을 설정할 수 있습니다. 페어 스케줄러는 트리 형태로 계층화된 큐를 선언하고, 큐별로 사용 가능한 용량을 할당하여 자원을 관리합니다. 예를 들어 100G의 메모리 용량을 가지는 클러스터에서 A, B 두 개의 큐에 각각 최저 자원(minResource) <10000 mb, 10vcores> 최대 자원(maxResource) <60000 mb, 30vcores>을 설정하고, 각 큐가 상황에 맞게 최대 60G까지의 메모리를 사용하게 설정할 수 있습니다. A 큐의 하위에 A_sub_1, A_sub_2와 같은 형태로 큐를 설정할 수도 있습니다. 스케줄러 설정값 페어 스케줄러는 yarn-site.xml에 스케줄러 관련 설정을 하고, fair-scheduler.xml에 큐 관련 설정을 저장합니다. 10초마다 설정 파일을 읽어서 큐 설정을 갱신합니다. 페어 스케줄러는 다음과 같이 설정합니다. <property> <name>yarn.resourcemanager.scheduler.class</name> <value>org.apache.hadoop.yarn.server.resourcemanager.scheduler.fair.FairScheduler</value> </property> yarn-site.xml 설정값 기본값 비고 yarn.scheduler.fair.allocation.file fair-scheduler.xml 설정 파일의 이름 yarn.scheduler.fair.user-as-default-queue true 큐이름을 지정하지 않았을 때 기본큐의 사용 여부 yarn.scheduler.fair.preemption false 우선순위 선점의 사용 여부 fair-scheduler.xml <?xml version="1.0"?> <allocations> <queue name="dev"> <minResources>10000 mb, 10vcores</minResources> <maxResources>60000 mb, 30vcores</maxResources> <maxRunningApps>50</maxRunningApps> <maxAMShare>1.0</maxAMShare> <weight>2.0</weight> <schedulingPolicy>fair</schedulingPolicy> </queue> <queue name="prd"> <minResources>10000 mb, 10vcores</minResources> <maxResources>60000 mb, 30vcores</maxResources> <maxRunningApps>100</maxRunningApps> <maxAMShare>0.1</maxAMShare> <weight>2.0</weight> <schedulingPolicy>fair</schedulingPolicy> <queue name="sub_prd"> <aclSubmitApps>charlie</aclSubmitApps> <minResources>5000 mb, 0vcores</minResources> </queue> </queue> <user name="sample_user"> <maxRunningApps>30</maxRunningApps> </user> <userMaxAppsDefault>5</userMaxAppsDefault> <queueMaxAMShareDefault>0.2</queueMaxAMShareDefault> <queuePlacementPolicy> <rule name="specified"/> <rule name="primaryGroup" create="false"/> <rule name="default" queue="dev"/> </queuePlacementPolicy> </allocations> 참고 Fair scheduler 설정: 바로 가기 2-YARN 메모리 설정 YARN의 메모리 설정은 yarn-site.xml 파일을 수정하여 변경할 수 있습니다. 노드 매니저의 메모리, CPU 개수와 컨테이너에 할당할 수 있는 최대, 최소 메모리 등을 설정할 수 있습니다. 기본값은 yarn-default.xml 을 참고(yarn-default.xml) 하면 됩니다. 리소스 매니저 설정 yarn.nodemanager.resource.memory-mb 클러스터의 각 노드에서 컨테이너 운영에 설정할 수 있는 메모리의 총량 노드의 OS를 운영할 메모리를 제외하고 설정 기본값은 장비에 설정된 메모리의 80% 정도를 설정 노드의 메모리가 32G인 경우 운영체제를 위한 4G를 제외하고 28G를 설정 yarn.nodemanager.resource.cpu-vcores 클러스터의 각 노드에서 컨테이너 운영에 설정할 수 있는 CPU의 개수 기본값은 장비에 설치된 CPU의 80% 정도를 설정 노드에 설치된 CPU가 40개일 경우 32를 설정 yarn.scheduler.maximum-allocation-mb 하나의 컨테이너에 할당할 수 있는 메모리의 최댓값 8G가 기본 값 yarn.scheduler.minimum-allocation-mb 하나의 컨테이너에 할당할 수 있는 메모리의 최솟값 1G가 기본값 yarn.nodemanager.vmem-pmem-ratio 실제 메모리 대비 가상 메모리 사용 비율 mapreduce.map.memory.mb * 설정값의 비율로 사용 가능 메모리를 1G로 설정하고, 이 값을 10으로 설정하면 가상 메모리를 10G 사용 yarn.nodemanager.vmem-check-enabled 가상 메모리에 대한 제한이 있는지 확인하여, true일 경우 메모리 사용량을 넘어서면 컨테이너를 종료 false로 설정하여 가상 메모리는 yarn.nodemanager.pmem-check-enabled 물리 메모리에 대한 제한이 있는지 확인하여, true일 경우 메모리 사용량을 넘어서면 컨테이너를 종료 yarn-site.xml 설정 예제 <property> <name>yarn.nodemanager.resource.memory-mb</name> <value>28672</value> </property> <property> <name>yarn.nodemanager.resource.cpu-vcores</name> <value>8</value> </property> <property> <name>yarn.scheduler.maximum-allocation-mb</name> <value>8192</value> </property> <property> <name>yarn.scheduler.minimum-allocation-mb</name> <value>1024</value> </property> <property> <name>yarn.nodemanager.vmem-pmem-ratio</name> <value>2.1</value> </property> <property> <name>yarn.nodemanager.pmem-check-enabled</name> <value>true</value> </property> <property> <name>yarn.nodemanager.vmem-check-enabled</name> <value>false</value> </property> 3-YARN 명령어 HDFS 커맨드는 사용자 커맨드, 운영자 커맨드로 구분됩니다. 각 모드마다 다양한 커맨드가 있지만 여기서는 사용 및 운영에 필수적인 몇 가지 커맨드만 확인하겠습니다. 전체 커맨드의 목록은 YARN Commands Guide1을 참고하십시오. 사용자 커맨드 사용자 커맨드 목록 application 커맨드 작업 목록 확인 작업 상태 확인 작업 종료 applicationattempt 커맨드 container 커맨드 logs 커맨드 운영자 커맨드 운영자 커맨드 목록 rmadmin 큐정보 갱신 사용자 커맨드 사용자 커맨드 목록은 다음과 같습니다. 이 중에서 주요 옵션인 application 과 logs에 대해서 알아보겠습니다. 사용자 커맨드 목록 명령어 설명 application 애플리케이션 정보 확인, 작업 종료 applicationattempt 애플리케이션 Attempt 정보 classpath 필요한 클래스 정보 container 컨테이너 정보 jar jar 파일 실행 logs 애플리케이션 로그 확인 node 노드 정보 queue 큐 정보 version 버전 정보 envvars 환경 변수 정보 application 커맨드 application 커맨드는 애플리케이션의 정보를 확인하고, 작업을 종료할 수 있습니다. 주요 커맨드는 다음과 같습니다. 작업 목록 확인 -list 옵션을 이용해서 현재 작업 중인 작업 목록을 확인할 수 있습니다. 작업 상태, 진행 상황, 작업큐, 트래킹 URL 정보를 확인할 수 있습니다. $ yarn application -list Total number of applications (application-types: [] and states: [SUBMITTED, ACCEPTED, RUNNING]):19 Application-Id Application-Name Application-Type User Queue State Final-State Progress Tracking-URL application_1536937158836_712399 OOZIE-launcher MAPREDUCE hadoop q1 RUNNING UNDEFINED 95% http://host:43902 application_1536937158836_712407 HIVE-ID TEZ hadoop q2 RUNNING UNDEFINED 67.77% http://host:33535/ui/ 작업 상태 확인 작업 목록에서 확인한 작업 ID(Application-Id)를 이용하여 현재 작업 상태를 확인할 수 있습니다. $ yarn application -status application_1234_1 Application Report : Application-Id : application_1234_1 Application-Name : HIVE-name Application-Type : MAPREDUCE User : hadoop Queue : prd Start-Time : 1560327373054 Finish-Time : 0 Progress : 95% State : RUNNING Final-State : UNDEFINED Tracking-URL : http://host:43902 RPC Port : 43360 AM Host : host Aggregate Resource Allocation : 2459450 MB-seconds, 960 vcore-seconds Diagnostics : 작업 종료 -kill 옵션을 이용해서 작업을 강제로 종료할 수 있습니다. 작업 목록에서 확인한 애플리케이션 아이디나 잡아이디를 이용하면 됩니다. $ yarn application -kill <application_id> applicationattempt 커맨드 애플리케이션의 현재 시도(attempt) 정보를 확인할 수 있습니다. 애플리케이션은 설정에 따라 오류가 발생하면 자동으로 재작업하기 때문에 관련된 정보를 확인할 수 있습니다. $ yarn applicationattempt -list application_1234_1 Total number of application attempts :1 ApplicationAttempt-Id State AM-Container-Id Tracking-URL appattempt_1234_1_000001 RUNNING container_1234_1_01_000001 http://host:20888/proxy/application_1234_1/ container 커맨드 현재 애플리케이션이 동작 중인 컨테이너의 정보를 확인할 수 있습니다. Attempt ID(ApplicationAttempt-Id)를 이용하여 정보를 확인합니다. $ yarn container -list appattempt_1234_1_000001 Total number of containers :94 Container-Id Start Time Finish Time State Host Node Http Address LOG-URL container_1234_1_01_138704 Wed Jun 12 08:40:17 +0000 2019 N/A RUNNING host-1:8041 http://host-1:8042 http://host-1:8042/node/containerlogs/container_1234_1_01_138704/hadoop container_1234_1_01_138638 Wed Jun 12 08:40:02 +0000 2019 N/A RUNNING host-2:8041 http://host-2:8042 http://host-2:8042/node/containerlogs/container_1234_1_01_138638/hadoop logs 커맨드 logs 커맨드는 작업이 종료된 잡의 로그를 확인하는 명령입니다. 작업 중인 잡의 로그는 히스토리 서버에 저장되기 전이라서 확인할 수 없습니다. 작업 중인 잡은 작업 목록에서 확인한 트래킹 URL에 접속해서 확인하면 됩니다. CLI 환경이라면 lynx 커맨드를 이용하면 되고, 웹으로 접속해서 확인할 수 있습니다. $ yarn logs -applicationId <application_id> 운영자 커맨드 운영자 커맨드 목록은 다음과 같습니다. 이 중에서 주요 옵션인 rmadmin에 대해서 알아보겠습니다. 운영자 커맨드 목록 명령어 설명 daemonlog 로그 레벨 설정 nodemanager 노드 매니저 실행 proxyserver 프락시 서버 실행 resourcemanager 리소스 매니저 실행 rmadmin 리소스 매니저 어드민 클라이언트 명령 schedulerconf 스케줄러 설정 업데이트 scmadmin 공유 캐시 매니저 어드민 클라이언트 명령 sharedcachemanager 공유 캐시 매니저 실행 timelineserver 타임라인 서버 실행 rmadmin rmadmin 옵션을 이용해서 리소스 매니저에 동록된 큐와 노드 정보를 갱신할 수 있습니다. 큐정보 갱신 커패시티 스케줄러 설정(capacity-scheduler.xml)을 다시 읽어서 정보를 갱신합니다. $ yarn rmadmin -refreshQueues YARN Commans (바로 가기) ↩ 4-YARN REST API 리소스 매니저는 REST API를 제공합니다. 이를 통해 클러스터의 상태 정보, 운영정보를 확인할 수 있습니다. 응답 형태는 JSON, XML 형태로 제공됩니다. 리소스 매니저 매뉴얼 1에서 전체 목록을 확인할 수 있습니다. 여기서는 파이썬을 이용해서 클러스터의 메트릭 정보를 확인해 보겠습니다. 클러스터 메트릭 정보 확인 클러스터 메트릭 정보를 확인하는 URI는 다음과 같습니다. 해당 URI를 GET 방식으로 호출하면 됩니다. 헤더에 { 'Content-Type': 'application/json' }로 정보를 설정하면 json<NAME>으로 값을 반환합니다. http://<rm http address:port>/ws/v1/cluster/metrics 메트릭 확인 REST API 예제 파이썬을 이용해서 RMA 메트릭을 호출합니다. #!/usr/bin/env python # -*- coding: utf-8 -*- import urllib, json, urllib2, datetime from urllib2 import HTTPError def request_get(request_url): return request(request_url, "GET", "", {'Content-Type': 'application/json'}) def request(request_url, request_type="GET", data="", header={}): opener = urllib2.build_opener(urllib2.HTTPHandler) request_get = urllib2.Request(request_url, data, header) request_get.get_method = lambda: request_type response = opener.open(request_get) response_info = response.info() response_body = response.read() json_obj = json.loads(response_body) print(json.dumps(json_obj, sort_keys=True, indent=4, separators=(',', ': '))) def main(): rma_url = "http://<RMA 주소>:<RMA 포트>/ws/v1/cluster/metrics" request_get(rma_url) if __name__ == '__main__': main() 결과는 다음과 같습니다. { "clusterMetrics": { "activeNodes": 2, "allocatedMB": 0, "allocatedVirtualCores": 0, "appsCompleted": 25000, "appsFailed": 1, "appsKilled": 1, "appsPending": 0, "appsRunning": 0, "appsSubmitted": 1, "availableMB": 1, "availableVirtualCores": 23, "containersAllocated": 0, "containersPending": 0, "containersReserved": 0, "decommissionedNodes": 0, "decommissioningNodes": 0, "lostNodes": 0, "rebootedNodes": 0, "reservedMB": 0, "reservedVirtualCores": 0, "totalMB": 25000, "totalNodes": 2, "totalVirtualCores": 23, "unhealthyNodes": 0 } } ResourceManager REST API's (바로 가기) ↩ 5-YARN Node Labels YARN은 2.6버전부터 노드 레이블(Node Label) 1 기능을 제공합니다. 노드 레이블은 서버를 특성에 맞게 구분하여 작업을 처리하게 하는 기능을 제공합니다. 예를 들어 어느 회사에서 클러스터를 Batch, Stream 큐로 구분하여 사용한다고 하겠습니다. 여기에 SSD를 설치한 서버와 GPU를 설치한 서버를 추가합니다. SSD를 설치한 서버는 IO가 많은 작업에 유리하고, GPU를 설치한 서버는 연산이 많은 작업에 유리할 것입니다. 기존의 방식대로 클러스터에 서버를 추가하면 리소스 매니저는 서버의 특성에 대한 구분 없이 여유가 있는 서버에서 작업을 진행할 것입니다. 이때 노드 레이블을 이용하여 각 서버에 유리한 작업을 등록할 수 있습니다. SSD를 설치한 서버는 SSD, GPU를 설치한 서버는 GPU 레이블로 설정하고 Batch 큐는 SSD 레이블, Stream 큐는 GPU 레이블을 이용하도록 설정하면 리소드 매니저는 Batch 큐에 들어온 작업을 처리할 때 SSD 레이블이 설정된 서버에서 작업하도록 합니다. 이를 통해 서버의 특성에 따라 작업을 구분할 수 있게 되고 작업 성능을 향상시킬 수 있습니다. 현재는 노드 파티션 기능을 제공하고 있으며, 노드 컨스트레인트2 기능은 현재 작업 중입니다. 특징 하나의 노드는 하나의 파티션을 가질 수 있음(One node can have only one node partition) 기본값은 DEFAULT 파티션(partition="") 클러스터는 여러 파티션(여러 노드)으로 구성할 수 있음 스케줄러에서 사용자가 각 파티션이 사용할 수 있는 리소스의 양을 설정해야 함 노드 레이블로 지정되지 않은 큐는 기본 파티션을 이용하게 됨 접근제어(ACL) 큐에서 설정된 노드만 작업에 이용할 수 있고, 이를 통해 각 노드에 대한 접근제어가 가능함 클러스터 사용량 제어 각 노드마다 사용할 수 있는 자원의 비율을 지정하여 사용량을 제어할 수 있음 파티션의 종류 Exclusive 파티션 클러스터의 자원에 여유가 있어도 지정한 파티션만 이용하여 작업을 처리 Non-Exclusive 파티션 클러스터에 여유가 있다면 DEFAULT 파티션으로 요청한 작업에 대해서 처리 가능 설정 노드 레이블 설정 리소스 매니저에서 노드 레이블을 지원하도록 하기 위해서 yarn-site.xml에 다음과 같이 설정합니다. <property> <name>yarn.node-labels.enabled</name> <value>true</value> </property> <property> <name>yarn.node-labels.fs-store.root-dir</name> <value>hdfs://namenode:port/path/to/store/node-labels/</value> </property> 노드 레이블 관련 명령어 yarn 명령어를 이용해 노드 레이블을 추가합니다. 클러스터의 레이블 정보 확인 # 클러스터의 레이블 정보 확인 $ yarn cluster --list-node-labels Node Labels: <GPU:exclusivity=false> 클러스터의 노드 레이블 추가 및 삭제 # 클러스터 노드 레이블 추가, exclusive 기본값은 true $ yarn rmadmin -addToClusterNodeLabels "label_1(exclusive=true),label_2(exclusive=false)" # 클러스터 노드 레이블 삭제 $ yarn rmadmin -removeFromClusterNodeLabels "label_1" 노드 레이블 추가 및 삭제 # 노드 레이블 추가 $ yarn rmadmin -replaceLabelsOnNode “node1[:port]=label1 node2=label2” 스케줄러 설정 스케줄러에 설정하는 값은 다음과 같습니다. 다음의 설정은 커패시티 스케줄러는 capacity-scheduler.xml에 설정하게 됩니다. 설정 비고 yarn.scheduler.capacity.<queue-path>.capacity DEFAULT 파티션에 속하는 노드에 액세스할 수 있는 큐의 백분율 설정. 각 부모의 직계 자녀에 대한 기본 용량의 합은 100 yarn.scheduler.capacity.<queue-path>.accessible-node-labels "hbase, storm"과 같이 관리자가 각 큐에서 레이블에 액세스할 수 있고 쉼표로 구분하여 레이블을 지정. 큐가 레이블 hbase 및 storm에 액세스할 수 있음을 의미함. 모든 큐는 레이블이 없는 노드에 액세스할 수 있으므로 사용자는 이를 지정하지 않아도 됨. 사용자가 이 필드를 지정하지 않으면 상위 필드에서 상속. yarn.scheduler.capacity.<queue-path>.accessible-node-labels.<label>.capacity <label> partition에 속하는 노드에 액세스할 수 있는 큐의 백분율을 설정. 각 부모 아래의 직계 자녀에 대한 <label> 용량의 합계는 100. 기본적으로 0. yarn.scheduler.capacity.<queue-path>.accessible-node-labels.<label>.maximum-capacity yarn.scheduler.capacity.<queue-path>.maximum-capacity와 유사하게 각 대기열의 레이블에 대한 최대 용량. 기본적으로 100. yarn.scheduler.capacity.<queue-path>.default-node-label-expression "hbase"와 같은 값. 즉, 응용 프로그램이 자원 요청에 노드 레이블을 지정하지 않고 큐에 제출 한 경우 "hbase"를 default-node-label-expression으로 사용. 예제 어느 회사에서 엔지니어 부서(engineering), 마케팅 부서(marketing), 영업부서(sales)가 하나의 클러스터를 1/3씩 나눠서 쓴다고 하겠습니다. yarn.scheduler.capacity.root.queues=engineering, marketing, sales yarn.scheduler.capacity.root.engineering.capacity=33 yarn.scheduler.capacity.root.marketing.capacity=34 yarn.scheduler.capacity.root.sales.capacity=33 엔지니어 부서와 마케팅 부서가 업무가 늘어나서 GPU를 가지고 있는 머신들을 추가하게 되었습니다. 이 머신들로 클러스터를 따로 구축하게 되면 운영비가 늘어나서 기존의 클러스터에 머신을 추가하면서 GPU 노드 레이블을 추가해서 적용합니다. 그리고 GPU 노드들은 엔지니어 부서와 마케팅 부서만 사용할 수 있도록 설정합니다. 엔지니어 부서와 마케팅 부서는 GPU 노드를 1/2씩 나눠서 사용할 수 있습니다. yarn.scheduler.capacity.root.engineering.accessible-node-labels=GPU yarn.scheduler.capacity.root.marketing.accessible-node-labels=GPU yarn.scheduler.capacity.root.engineering.accessible-node-labels.GPU.capacity=50 yarn.scheduler.capacity.root.marketing.accessible-node-labels.GPU.capacity=50 yarn.scheduler.capacity.root.engineering.default-node-label-expression=GPU https://hadoop.apache.org/docs/r2.7.3/hadoop-yarn/hadoop-yarn-site/NodeLabel.html ↩ Node Constraints. 하나의 노드에 여러 레이블을 지원. ↩ 6-YARN 고가용성 YARN은 리소스 매니저가 단일 실패 지점입니다. 리소스 매니저에 문제가 발생하면 클러스터의 자원관리, 작업 관리 기능을 사용할 수 없기 때문에 하둡 2.4 버전부터 HA 기능을 제공합니다. 리소스 매니저 HA 리소스 매니저 고가용성은 주키퍼와 액티브, 스탠바이 리소스 매니저를 이용하여 제공합니다. 각 리소스 매니저는 클러스터와 작업 상태 보관을 위한 메타 데이터를 저장하기 위한 저정소를 공유합니다. 주키퍼를 이용한 ZKRMStateStore와 파일 시스템을 이용한 FileSystemRMStateStore가 있습니다. 기본적으로 ZKRMStateStore를 추천합니다. 장애 극복 리소스 매니저에 장애가 발생하면 사용자가 수동으로 CLI 커맨드를 이용하여 액티브 리소스 매니저로 변경할 수 있습니다. 주키퍼를 이용하면 자동으로 리소스 매니저의 상태가 변경됩니다. # 리소스 매니저 상태 확인 $ yarn rmadmin -getServiceState rm1 active $ yarn rmadmin -getServiceState rm2 standby # 상태 변경 $ yarn rmadmin -transitionToStandby rm1 설정 고가용성 설정은 yarn.resourcemanager.ha.enabled 설정 여부로 사용됩니다. <property> <name>yarn.resourcemanager.ha.enabled</name> <value>true</value> </property> <property> <name>yarn.resourcemanager.cluster-id</name> <value>cluster1</value> </property> <property> <name>yarn.resourcemanager.ha.rm-ids</name> <value>rm1, rm2</value> </property> <property> <name>yarn.resourcemanager.hostname.rm1</name> <value>master1</value> </property> <property> <name>yarn.resourcemanager.hostname.rm2</name> <value>master2</value> </property> <property> <name>yarn.resourcemanager.webapp.address.rm1</name> <value>master1:8088</value> </property> <property> <name>yarn.resourcemanager.webapp.address.rm2</name> <value>master2:8088</value> </property> <property> <name>hadoop.zk.address</name> <value>zk1:2181, zk2:2181, zk3:2181</value> </property> 참고 ResourceManagerHA 7-타임라인 서비스 v.2 하둡 3 버전에서 YARN은 타임라인 서비스 v.2를 제공합니다. 특징 YARN 타임 라인 서비스 v.2는 v.1 및 v.1.5에 이은 타임 라인 서버의 다음 주요 버전입니다. V.2는 v.1의 두 가지 주요 과제를 해결하기 위해 만들어졌습니다. 확장성 V.1은 writer / reader 및 스토리지의 단일 인스턴스로 제한되며 소규모 클러스터 이상으로 확장되지 않습니다. V.2는 더 확장 가능한 분산 작성기 아키텍처와 확장 가능한 백엔드 저장소를 사용합니다. YARN Timeline Service v.2는 데이터 수집 (쓰기)과 데이터 제공 (읽기)을 분리합니다. 기본적으로 각 YARN 애플리케이션에 대해 하나의 수집 기인 분산 수집기를 사용합니다. 리더는 REST API를 통해 쿼리를 제공하는 전용 인스턴스입니다. YARN Timeline Service v.2는 Apache HBase가 읽기 및 쓰기에 대한 응답 시간을 유지하면서 큰 크기로 잘 확장되기 때문에 Apache HBase를 기본 백업 스토리지로 선택합니다. 유용성 향상 많은 경우 사용자는 작업의 진행 흐름(flow) 또는 YARN 응용 프로그램의 논리적 그룹 수준의 정보에 관심이 있습니다. 논리적 애플리케이션을 완료하기 위해 일련의 YARN 애플리케이션을 시작하는 것이 훨씬 더 일반적입니다. 타임 라인 서비스 v.2는 흐름 개념을 명시 적으로 지원합니다. 또한 흐름 수준에서 메트릭 집계를 지원합니다. 또한 구성 및 메트릭과 같은 정보는 가장 중요한 정보로 취급됩니다. 다음 다이어그램은 서로 다른 YARN 항목 모델링 흐름 간의 관계를 보여줍니다. 구조 YARN Timeline Service v.2는 수집기 (writer) 세트를 사용하여 백엔드 스토리지에 데이터를 씁니다. 수집기는 전용 응용 프로그램 마스터와 함께 배포되고 함께 배치됩니다. 리소스 관리자 타임 라인 수집기를 제외하고 해당 애플리케이션에 속하는 모든 데이터는 애플리케이션 수준 타임 라인 수집기로 전송됩니다. 특정 애플리케이션에 대해 애플리케이션 마스터는 함께 배치된 타임 라인 수집기 (이 릴리스의 NM 보조 서비스)에 애플리케이션 데이터를 쓸 수 있습니다. 또한 애플리케이션의 컨테이너를 실행 중인 다른 노드의 노드 관리자도 애플리케이션 마스터를 실행 중인 노드의 타임 라인 수집기에 데이터를 씁니다. 리소스 관리자는 자체 타임 라인 수집기도 유지합니다. 쓰기 볼륨을 합리적으로 유지하기 위해 YARN 일반 수명주기 이벤트 만 내 보냅니다. 타임 라인 리더는 타임 라인 수집 기와는 별도의 데몬이며 REST API를 통해 쿼리를 제공하는 데 전념합니다. 다음 다이어그램은 높은 수준의 설계를 보여줍니다. 설정 사전 작업 HBase 설정 타임 라인 서버 v.2는 저장소로 HBase를 이용하기 때문에 HBase를 구성해야 합니다. coprocessor 설정 coprocessor 사용을 위해서 jar 파일을 HDFS에 복사합니다. 타임라인 서버 스키마 생성 구성한 HBase에 타임라인 서비스를 위한 스키마를 생성합니다. 타임라인 서버 스키마 생성 export HADOOP_CLASSPATH=/opt/hadoop/share/hadoop/yarn/timelineservice/hadoop-yarn-server-timelineservice-hbase-client-3.2.1.jar:/opt/hbase/lib/*:/opt/hadoop/share/hadoop/yarn/timelineservice/hadoop-yarn-server-timelineservice-hbase-common-3.2.1.jar hadoop org.apache.hadoop.yarn.server.timelineservice.storage.TimelineSchemaCreator -create -skipExistingTable 참고 TimelineServiceV2 installing hadoop3 5-작업 지원 도구(Hadoop Common) 하둡에는 작업 지원 및 모니터링을 위한 몇 가지 기능을 제공합니다. 1-DistCp 하둡은 클러스터 내의 대규모 데이터 이동을 위한 DistCp(Distribute Copy) 기능을 제공합니다. 기본 파일 복사 명령인 hadoop fs -cp로는 파일을 하나씩 복사하지만 DistCp 기능을 이용하면, 맵리듀스를 이용하여 대규모의 파일을 병렬로 복사합니다. 맵리듀스를 이용하여 작업을 처리하기 때문에 클러스터의 리소스를 이용하게 되고 큐를 사용해야 한다면 큐 이름을 입력해야 합니다. 또한 대규모 병렬 처리 작업이기 때문에 네트워크 사용량을 잘 확인해야 합니다. 너무 많은 매퍼를 할당하면 네트워크 자원을 많이 사용하여 운영에 문제가 생길 수 있습니다. 운영 상황에서 DistCp 작업 시 네트워크 사용량을 꼭 확인하는 것이 좋고, 매퍼의 개수를 점진적으로 늘리는 것이 좋습니다. 또한 클러스터의 설정이 다르다면 복사 위치의 블록 사이즈, 복제개수를 확인해야 합니다. 주요 옵션 옵션 비고 -update 복사 시 파일 이름, 사이즈를 비교해서 복사 -overwrite 기존 복사 파일을 삭제하고 덮어씀 -f 복사 source 위치가 여러 개일 때 파일로 전달. -m 매퍼 개수 설정 -D 하둡 옵션 전달 사용법 디스트 카피 명령은 다음과 같이 사용합니다. 다른 옵션은 매뉴얼 1을 참고 바랍니다. # a 폴더를 b로 복사 $ hadoop distcp hdfs:///user/a hdfs:///user/b # a, b 폴더를 c로 복사 $ hadoop distcp hdfs:///user/a hdfs:///user/b hdfs:///user/c # -D 옵션을 이용하여 큐이름 설정 $ hadoop distcp -Dmapred.job.queue.name=queue hdfs:///user/a hdfs:///user/b # -D 옵션으로 메모리 사이즈 전달 $ hadoop distcp -Dmapreduce.map.memory.mb=2048 hdfs:///user/a hdfs:///user/b # 파일 이름, 사이즈를 비교하여 변경 내역 있는 파일만 이동 $ hadoop distcp -update hdfs:///user/a hdfs:///user/b hdfs:///user/c # 목적지의 파일을 덮어씀 $ hadoop distcp -overwrite hdfs:///user/a hdfs:///user/b hdfs:///user/c 매퍼 개수 설정 hadoop distcp \ -m 10 \ hdfs://source-nn/dir \ hdfs://target-nn/dir AWS S3 간 데이터 이동 AWS의 S3에서 distcp를 이용하여 데이터를 이동할 때는 옵션 값에 액세스키와 시크릿키를 전달합니다. hadoop distcp \ -Dfs.s3n.awsAccessKeyId=[source_액세스키1] \ -Dfs.s3n.awsSecretAccessKey=[source_시크릿키 1] \ -Dfs.s3.awsAccessKeyId=[target_액세스키2] \ -Dfs.s3.awsSecretAccessKey=[target_시크릿키 2] \ -Dmapred.job.queue.name=q2 \ s3n://[source_url] s3://[target_url] 일반 하둡과 커버 로스 하둡 간 데이터 이동 커버 로스 적용된 시큐어 하둡과 일반 하둡 간 데이터를 이동할 때는 시큐어 하둡에서 작업을 진행해야 합니다. 시큐어 하둡은 swebhdfs를 이용하고, 일반 하둡은 webhdfs를 이용합니다. hadoop distcp -D ipc.client.fallback-to-simple-auth-allowed=true \ webhdfs://source-nn:50070/dir \ swebhdfs://target-nn:50470/dir 커버 로스 하둡 간 데이터 이동 시큐어 하둡 간 데이터 이동 시에는 다음의 옵션을 추가해야 합니다. hadoop distcp -Dmapreduce.job.hdfs-servers.token-renewal.exclude=target-nn \ webhdfs://source-nn:50070/dir \ swebhdfs://target-nn:50470/dir 디스트 카피 매뉴얼(바로 가기) ↩ 2-하둡 아카이브 하둡 HDFS는 작은 사이즈의 파일이 많아지면 네임노드에서 이를 관리하는데 많은 어려움을 겪게 되는 문제가 발생합니다. 따라서 블록 사이즈 정도로 파일을 유지해 주는 것이 좋습니다. 이를 위해서 하둡은 파일을 묶어서 관리하고, 사용할 수 있는 하둡 아카이브(Hadoop Archive) 기능을 제공합니다. 하둡 아카이브로 묶은 파일은 har 스키마를 이용해서 접근합니다. 하둡 아카이브는 맵리듀스 작업을 이용해서 파일을 생성합니다. 생성된 아카이브는 ls 명령으로는 디렉터리처럼 보입니다. har 스키마를 이용해서 파일을 확인할 수 있습니다. 맵리듀스 작업의 입력으로 전달하면 하둡에서 데이터를 읽어서 처리합니다. 생성 하둡 아카이브 생성은 archive 커맨드를 이용합니다. 사용방법은 다음과 같습니다. # 사용 방법 hadoop archive -archiveName <NAME>.har -p <parent path> [-r <replication factor>]<src>* <dest> # 사용 예제(큐 이름 적용) $ hadoop archive -archiveName -Dmapred.job.queue.name=queue_name sample.har -p /user/data/ /user/ 19/01/14 01:57:52 INFO mapreduce.Job: Job job_1520227878653_38308 running in uber mode : false 19/01/14 01:57:52 INFO mapreduce.Job: map 0% reduce 0% 19/01/14 01:57:56 INFO mapreduce.Job: map 100% reduce 0% 19/01/14 01:58:01 INFO mapreduce.Job: map 100% reduce 100% 19/01/14 01:58:01 INFO mapreduce.Job: Job job_1520227878653_38308 completed successfully 19/01/14 01:58:01 INFO mapreduce.Job: Counters: 49 File System Counters FILE: Number of bytes read=126 # sample.har 확인 # ls 명령으로 보면 sample.har 디렉터리가 생성된 것을 알 수 있음 $ hadoop fs -ls /user/ Found 1 items drwxr-xr-x - hadoop hadoop 0 2019-01-14 01:57 /user/sample.har # sample.har 디렉터리 확인 $ hadoop fs -ls /user/sample.har/ Found 4 items -rw-r--r-- 2 hadoop hadoop 0 2019-01-14 01:57 /user/sample.har/_SUCCESS -rw-r--r-- 5 hadoop hadoop 117 2019-01-14 01:57 /user/sample.har/_index -rw-r--r-- 5 hadoop hadoop 23 2019-01-14 01:57 /user/sample.har/_masterindex -rw-r--r-- 2 hadoop hadoop 746 2019-01-14 01:57 /user/sample.har/part-0 # har 스키마를 이용한 데이터 확인 $ hadoop fs -ls har:///user/sample.har/ Found 1 items -rw-r--r-- 2 hadoop hadoop 746 2018-05-23 04:15 har:///user/sample.har/test.txt 해제 하둡 아카이브 파일의 압축을 해제할 때는 distcp를 이용합니다. #sample.har 압축 해제 $ hadoop distcp -Dmapred.job.queue.name=queue_name har:///user/sample.har/ /user/decompress/ # 압축 해제 확인 $ hadoop fs -ls /user/decompress/ Found 1 items -rw-r--r-- 2 hadoop hadoop 746 2019-01-14 04:04 /user/decompress/test.txt 참고 하둡 아카이브 매뉴얼(바로 가기) 6-오브젝트 저장소(Hadoop Ozone) 오존(Ozone)은 하둡을 위한 확장성(scalable) 있는 분산 객체 저장소(distributed object store)입니다. 2020년 3월 24일에 0.5.0-beta 버전이 발표되었습니다. 스파크, 하이브, YARN은 별도의 수정 없이 오존을 이용할 수 있습니다. 오존은 자바 라이브러리와 CLI 환경을 지원합니다. 자바 라이브러리는 RPC와 REST 프로토콜을 지원하고 있습니다. Ozone 구성요소 오존은 볼륨, 버킷, 키로 구성됩니다. 볼륨은 사용자 계정과 유사합니다. 관리자만 볼륨을 생성하거나 삭제할 수 있습니다. 버킷은 디렉터리와 유사합니다. 버킷은 여러 개의 키를 저장할 수 있지만, 다른 버킷은 저장할 수 없습니다. 키는 파일과 유사합니다. 버킷은 여러 개의 키를 저장할 수 있습니다. 볼륨 > 버킷 > 키 단위로 구성됩니다. 7-설정 하둡 관련 주요 설정은 ${HADOOP_HOME}/conf 아래 설정합니다. 주요 설정 파일은 다음과 같습니다. core-site.xml 공통으로 사용하는 주요 설정 hdfs-site.xml HDFS 관련 설정 mapred-site.xml 맵리듀스 작업 관련 설정 yarn-site.xml YARN 관련 설정 hadoop-env.sh 하둡을 이용하는데 필요한 환경 변수 설정 1-core-site.xml Hadoop 관련 주요 설정을 정리합니다. 기본 설정 설정 기본값 비고 fs.defaultFS file:/// 하둡이 기본적으로 접근할 파일 시스템을 설정. hdfs://{호스트명} 으로 설정해야 함 참고 core-site.default - 3.3.2 2-hdfs-site.xml HDFS 관련 주요 설정을 정리합니다. 네임 노드 설정 기본값 비고 dfs.namenode.name.dir file://${hadoop.tmp.dir}/dfs/name 네임노드의 에디트 로그를 저장할 위치를 지정 참고 hdfs-site.default - 2.10.2 3-yarn-site.xml YARN 관련 주요 설정을 정리합니다. 노드 매니저 설정 기본값 비고 yarn.nodemanager.local-dirs /hadoop/yarn/local 노드 매니저의 임시 파일 저장 위치. 큰 사이즈의 디스크가 좋음 타임라인/애플리케이션 히스토리 서버 설정 기본값 비고 yarn.timeline-service.generic-application-history.max-applications 10000 타임라인 서버가 보관할 최대 히스토리 개수 4-mapred-site.xml 맵리듀스 작업 관련 주요 설정을 정리합니다. 설정 기본값 비고 yarn.app.mapreduce.am.job.client.port-range 맵리듀스 작업의 AM이 바인딩 되는 포트 레인지 yarn.app.mapreduce.am.webapp.port-range 맵리듀스 작업의 AM이 실행하는 웹앱이 바인딩 되는 포트 레인지 5-보안 설정 암호화 설정 시 주의할 점은 암호화에 따른 오버헤드로 인해서 읽기, 쓰기 성능이 떨어질 수 있습니다. 암호화 설정 설정값 dfs.encrypt.data.transfer true dfs.encrypt.data.transfer.algorithm 3des dfs.data.transfer.protection privacyintegrity, authentication dfs.encrypt.data.transfer HDFS 데이터 전송 채널 및 클라이언트가 HDFS에 액세스할 수 있는 채널이 암호화되었는지를 나타냅니다. HDFS 데이터 전송 채널에는 DataNode 사이의 데이터 전송 채널과 클라이언트가 DataNode에 액세스하기 위한 DT(Data Transfer) 채널이 포함됩니다. true 값 은 채널이 암호화되었음을 나타냅니다. 채널은 기본적으로 암호화되지 않습니다. dfs.encrypt.data.transfer.algorithm HDFS 데이터 전송 채널 및 클라이언트가 HDFS에 액세스할 수 있는 채널이 암호화되었는지를 나타냅니다. 이 매개변수는 dfs.encrypt.data.transfer가 true로 설정된 경우에만 유효합니다. 기본값은 3des이며, 이는 3DES 알고리즘이 암호화에 사용됨을 나타냅니다. 값을 rc4로 설정할 수도 있습니다. 그러나 보안 위험을 방지하려면 매개변수를 이 값으로 설정하지 마십시오. dfs.data.transfer.protection Hadoop에 있는 각 모듈의 RPC 채널이 암호화되었는지를 나타냅니다. 채널에는 다음이 포함됩니다. 클라이언트가 HDFS에 액세스하기 위한 RPC 채널 HDFS의 모듈 간 RPC 채널(예: DataNode와 NameNode 간의 RPC 채널) 클라이언트가 YARN에 액세스하기 위한 RPC 채널 NodeManager와 ResourceManager 간의 RPC 채널 YARN 및 HDFS에 액세스하기 위한 Spark 용 RPC 채널 MapReduce가 YARN 및 HDFS에 액세스하기 위한 RPC 채널 HBase가 HDFS에 액세스하기 위한 RPC 채널 개인 정보 채널은 기본적으로 암호화되어 있음을 나타냅니다. 인증 채널이 암호화되지 않은 것을 나타냅니다. 3-하이브(hive) 하이브에 대해서 알아보겠습니다. 하이브 데이터베이스 테이블 함수 트랜잭션 성능 최적화 1-하이브란? 하이브는 하둡 에코시스템 중에서 데이터를 모델링하고 프로세싱 하는 경우 가장 많이 사용하는 데이터 웨어하우징용 설루션입니다. RDB의 데이터베이스, 테이블과 같은 형태로 HDFS에 저장된 데이터의 구조를 정의하는 방법을 제공하며, 이 데이터를 대상으로 SQL과 유사한 HiveQL 쿼리를 이용하여 데이터를 조회하는 방법을 제공합니다. Hive 구성요소 하이브는 다음의 구성요소를 가지고 있습니다. UI 사용자가 쿼리 및 기타 작업을 시스템에 제출하는 사용자 인터페이스 CLI, Beeline, JDBC 등 Driver 쿼리를 입력받고 작업을 처리 사용자 세션을 구현하고, JDBC/ODBC 인터페이스 API 제공 Compiler 메타 스토어를 참고하여 쿼리 구문을 분석하고 실행계획을 생성 Metastore 디비, 테이블, 파티션의 정보를 저장 Execution Engine 컴파일러에 의해 생성된 실행 계획을 실행 하이브 실행 순서 사용자가 제출한 SQL 문을 드라이버가 컴파일러에 요청하여 메타 스토어의 정보를 이용해 처리에 적합한 형태로 컴파일 컴파일된 SQL을 실행 엔진으로 실행 리소스 매니저가 클러스터의 자원을 적절히 활용하여 실행 실행 중 사용하는 원천 데이터는 HDFS 등의 저장 장치를 이용 실행 결과를 사용자에게 반환 1-하이브 버전별 특징 하이브는 SQL을 하둡에서 사용하기 위한 프로젝트로 시작되었습니다. 페이스북에서 자사의 데이터 분석을 위해 개발하여 아파치 오픈소스 프로젝트로 넘어왔습니다. 하이브의 각 버전별 특징에 대해서 알아보겠습니다. Hive 1.0 2012년 0.10 버전을 시작으로 점차 발전하여, 2015년 2월 1.0 버전이 발표되었습니다. 특징 SQL을 이용한 맵리듀스 처리 파일 데이터의 논리적 표현 빅데이터의 배치 처리를 목표 Hive 2.0 하이브 1.0을 개선하여 2016년 2월 2.0 버전이 발표되었습니다. LLAP의 등장과 기본 실행 엔진이 TEZ로 변경되어 성능이 향상되었습니다. 특징 LLAP(Live Long and Process) 구조 추가 Spark 지원 강화 CBO 강화 HPLSQL 추가 LLAP 작업을 실행한 데몬을 계속 유지하여, 핫 데이터를 캐슁하여 할 수 있어 빠른 속도로 데이터를 처리할 수 있습니다. LLAP는 작업을 도와주는 보조도구입니다. 실제 작업을 처리하는 MR, TEZ 같은 작업 엔진이 아닙니다. 또한 HDFS 같이 데이터를 영구히 저장하지 않습니다. 사용자가 작업 모드를 선택할 수 있으며, TEZ 엔진에서만 사용할 수 있습니다. 하이브 매뉴얼 LLAP [바로 가기] HPLSQL 오라클의 PL/SQL과 비슷한 Procedural SQL을 지원합니다. 재사용 가능한 스크립트 작성을 목표로 개발되었습니다. 아래와 같이 FOR를 이용한 루프문이나 커서 등을 이용할 수 있습니다. FOR i IN 1.. 10 LOOP DBMS_OUTPUT.PUT_LINE(i); END LOOP Hive 3.0 2018년 5월 3.0 버전이 발표되었습니다. 맵리듀스 엔진, 하이브 CLI를 제거하고 TEZ 엔진과 비 라인을 이용하여 작업을 처리하도록 수정되었습니다. 특징 롤을 이용한 작업 상태 관리(workload management) 트랜잭션 처리 강화 구체화 뷰(Materialized View) 추가 쿼리 결과를 캐슁하여 더 빠른 속도로 작업 가능 테이블 정보 관리 데이터베이스 추가 workload 관리 롤, 권한을 이용한 작업 상태 관리 기능이 추가되었습니다. SQL을 이용하여 워크 로드 관리를 위한 롤을 생성하고 이를 적용하여 작업의 부하에 따라 쿼리의 성능, 실행 여부를 제어할 수 있습니다. CREATE RESOURCE PLAN daytime; Materialized View 실제 데이터를 가지는 구체화 뷰(Materialized View) 기능이 추가되었습니다. 집계 데이터를 개별적으로 보관하여 쿼리 수행 시 빠른 속도로 데이터를 검색할 수 있습니다. CREATE MATERIALIZED VIEW mv1 AS SELECT empid, deptname, hire_date FROM emps JOIN depts ON (emps.deptno = depts.deptno) WHERE hire_date >= '2016-01-01'; 하이브 구체화 뷰 매뉴얼 (바로 가기) 테이블 정보 데이터베이스 추가 기존에는 하이브 메타 스토어에만 확인할 수 있던 정보를 데이터 베이스를 통해서 확인이 가능하게 되었습니다. 전체 테이블의 칼럼 정보, 통계정보 등을 확인할 수 있고 커넥터를 이용해서 사용자가 직접 접근하여 확인할 수도 있습니다. use information_schema; use sys; 참고 하이브 2, 하이브 3의 새 기능에 대한 상세한 참고 자료들입니다. 아래의 발표 자료들을 확인해 보시기 바랍니다. 하이브 2 하이브 2의 10가지 새 기능 (바로 가기) 하이브 2 - SQL, Speed, Scale (바로 가기) 하이브 3 하이브 3의 새 기능 (바로 가기) 하이브 3 - New Horizon(바로 가기) 하이브 3의 새 기능 소개 (바로 가기) 2-하이브 서비스 하이브는 편리한 작업을 위한 몇 가지 서비스를 제공합니다. 메타 스토어 메타 스토어 서비스는 HDFS 데이터 구조를 저장하는 실제 데이터베이스를 가지고 있습니다. 메타 스토어는 3가지 실행 모드가 있습니다. 테스트로 동작할 때는 임베이디드 모드를 사용하고, 실제 운영에서는 리모트 모드를 많이 사용합니다. 임베이디드(Embeded) 별도의 데이터 베이스를 구성하지 않고 더비 DB를 이용한 모드 한 번에 하나의 유저만 접근 가능 로컬(Local) 별도의 데이터베이스를 가지고 있지만, 하이브 드라이버와 같은 JVM에서 동작 리모트(Remode) 별도의 데이터베이스를 가지고, 별도의 JVM에서 단독으로 동작하는 모드 리모트로 동작하는 하이브 메타 스토어를 HCat 서버 1라고도 함 하이브 서버 2(hiveserver2) 하이브 서버 2는 다른 언어로 개발된 클라이언트와 연동 서비스를 제공합니다. 기존 하이브 서버 1을 개선하여 인증과 다중 사용자 동시성을 지원합니다. 쓰 리프트, JDBC, ODBC 연결을 사용하는 애플리케이션과 통신하여 하이브 연산을 수행하고 결과를 반환합니다. 비 라인(beeline) 일반적인 CLI처럼 내장형 모드로 작동하거나 JDBC로 하이브 서버 2 프로세스에 접근할 수 있는 하이브의 명령행 인터페이스입니다. CLI는 로컬 하이브 서비스에만 접근할 수 있지만 비 라인은 원격 하이브 서비스에 접속할 수 있습니다. HCatalog HCatalog는 Pig, MapReduce, Spark에서 하이브의 데이터 파일에 접근할 수 있도록 도와주는 추상 계층을 제공합니다. % spark-shell --jars /usr/lib/hive-hcatalog/share/hcatalog/hive-hcatalog-core-1.0.0-amzn-3.jar scala> val hiveContext = new org.apache.spark.sql.hive.HiveContext(sc); scala> val df = hiveContext.sql("SELECT * FROM impressions") scala> df.show() EMR-Hcatalog using WebHCat HCatalog의 기능을 REST API로 제공합니다. 기본적으로 50111 포트를 이용합니다. # WebHCat 버전 확인 curl -s 'http://localhost:50111/templeton/v1/version' # 명령 실행 curl -s -d execute="show tables" \ -d statusdir="pokes.output" \ 'http://localhost:50111/templeton/v1/hive? user.name=root' WebHCat Reference HCatalogInstallHCat-HCatalogServer ↩ 3-하이브 CLI 하이브 CLI(Command Line Interface)는 하이브 쿼리를 실행하는 가장 기본적인 도구입니다. 인터랙티브 쉘을 이용하여 사용자의 명령을 입력할 수 있습니다. 여기서는 쿼리 실행 방법, 유용한 옵션, 내부 명령어를 알아보겠습니다. 상세한 내용은 하이브 매뉴얼 1을 참고하면 됩니다. CLI 옵션 하이브 CLI의 주요 옵션은 다음과 같습니다. hiveconf는 옵션 값을 설정할 때 이용합니다. hivevar는 쿼리에 변수를 지정할 때 이용합니다. usage: hive -e <quoted-query-string> 커맨드 라인으로 실행할 쿼리 -f <filename> 쿼리가 작성된 파일을 이용하여 실행할 경우 --hiveconf <property=value> 하이브 설정값 입력 예) --hiveconf tez.queue.name=queue --hivevar <key=value> 쿼리에서 사용할 변수 입력 예) --hivevar targetDate=20180101 -- 옵션 지정 방법 $ hive --hiveconf tez.queue.name=queue --hivevar targetDate=20180101 쿼리 실행 하이브 쿼리 실행은 인터랙티브 쉘에서 입력하는 방법, 커맨드 라인 입력, 파일 입력 방법 세 가지가 있습니다. 인터랙티브 쉘 입력 하이브 CLI를 실행하고, 쉘을 이용하여 입력하는 방법입니다. -- hive 실행 후 쿼리 입력 $ hive hive> select 0; OK Time taken: 1.367 seconds, Fetched: 1 row(s) hive> select * from table; 커맨드 라인 입력 커맨드 라인 입력은 -e 옵션을 이용합니다. -- 커맨드 라인에서 바로 입력 $ hive -e "select * from table" -- 옵션을 이용하여 쿼리의 실행 엔진과, 변수를 설정 -- 커맨드 라인 입력에서 설정값 전달 $ hive -e 'SELECT * FROM table WHERE yymmdd=${hivevar:targetDate}' \ --hiveconf hie.execution.engine=tez \ --hiveconf tez.queue.name=queue_name \ --hivevar targetDate=20180101 파일 입력 파일 입력은 쿼리를 파일로 저장해 놓고 해당 파일을 지정하는 방식입니다. -f 옵션을 이용합니다. $ cat sample.hql SELECT * FROM table WHERE yymmdd=${hivevar:targetDate} -- 파일을 이용하여 쿼리 입력 $ hive -f sample.hql --hivevar targetDate=20180101 로깅 방법 하이브 CLI는 log4j를 이용하여 로깅합니다. 로깅 방법을 변경하고자 할 때는 log4j 설정 파일을 변경하거나 --hiveconf 옵션을 이용합니다. # 파일 로깅 -- 로깅 레벨, 파일 위치 변경 hive --hiveconf hive.log.file=hive_debug.log \ --hiveconf hive.log.dir=./ \ --hiveconf hive.root.logger=DEBUG, DRFA # 콘솔 출력 hive --hiveconf hive.root.logger=DEBUG, console CLI 내부 명령어 하이브 CLI의 주요 내부 명령어는 다음과 같습니다. 상세한 설명은 하이브 매뉴얼 2를 참고하면 됩니다. 커맨드 설명 exit 종료 reset 설정값 초기화 set <key>=<value> 설정값 입력 set 하이브의 설정값 출력 set -v 하둡, 하이브의 설정값 출력 add file <> 파일 추가 add files <> 여러 개의 파일 추가, 공백으로 경로 구분 add jar <> jar 파일 추가 add jars <> 여러 개의 jar 파일 추가, 공백으로 경로 구분 !<command> 쉘 커맨드 실행 dfs <dfs command> 하둡 dfs 커맨드 실행 jar 파일 추가는 사용자가 구현한 UDF, SerDe 등 자바 클래스 사용할 때 jar 파일의 위치를 지정합니다. 파일 추가는 스크립트나 UDF에서 내부적으로 사용하는 메타 파일 등을 추가할 때 사용합니다. -- 옵션 설정 hive> set mapred.reduce.tasks=32; -- 모든 옵션 값 확인 hive> set; -- CLI 상에서 설정한 옵션 초기화 hive> reset; -- 쉘커맨드 실행 hive> !ls -alh; -- dfs 커맨드 실행 hive> dfs -ls /user/; -- 파일 추가 hive> add file hdfs:///user/sample.txt; -- 여러 개의 파일 추가. 공백으로 구분 hive> add files hdfs:///user/sample1.txt hdfs:///user/sample2.txt; -- jar 파일 추가 hive> add jar hdfs:///user/sample.jar; 하이브 CLI 매뉴얼 바로 가기 ↩ 하이브 CLI 커맨드 바로 가기 ↩ 4-비 라인(beeline) 비 라인은 SQLLine1 기반의 하이브 서버 2(hiveserver2)에 접속하여 쿼리를 실행하기 위한 도구입니다. JDBC를 사용하여 하이브 서버 2에 접속합니다. 비 라인 접속 옵션은 하이브 매뉴얼 2를 참고하시면 됩니다. 비 라인 접속-하이브 서버 2 비 라인에서 하이브 서버 2에 접속하는 방법은 비 라인 CLI를 실행 후에 입력하는 방법과 비 라인 CLI를 실행하면서 옵션으로 입력하는 방법이 있습니다. 하이브 서버 2에 접속하면 프롬프트에 접속한 하이브 서버 2의 접속 정보가 표현됩니다. 하이브 서버 2의 접근 포트는 hive.server2.thrift.port에 설정된 정보를 이용하면 됩니다. # connect 명령을 이용한 접속 방법 $ beeline beeline> !connect jdbc:hive2://localhost:10000 scott tiger 0: jdbc:hive2://localhost:10000> # 커맨드 라인 옵션을 이용한 접속 방법 $ beeline -u jdbc:hive2://localhost:10000 -n scott -p tiger 0: jdbc:hive2://localhost:10000> 비 라인 접속-TLS/SSL 하이브 서버 2 SSL 적용된 하이브 서버 2에 접근할 때는 transportMode, httpPath, sslTrustStore, trustStorePassword를 설정해야 합니다. SSL 적용된 하이브 서버 2는 HTTP 모드로 접근해야 하고, Http 모드는 기본적으로 10001번 포트로 접근해야 하기 때문에 포트도 변경해 주어야 합니다. beeline> !connect jdbc:hive2://localhost:10001/default;transportMode=http;httpPath=/cliservice;ssl=true;sslTrustStore=/jks-file-path;trustStorePassword=jks-password 비 라인 접속-주키퍼 비 라인은 주키퍼에 의해서 HA 구성되어 있는 하이브 서버 2에 접속하여 비 라인 CLI를 실행할 수 있습니다. 주키퍼를 사용할 경우 접속 주소는 아래와 같이 표현됩니다. jdbc:hive2://[ZOOKEEPER_QUORUM]/;serviceDiscoveryMode=zooKeeper;zooKeeperNamespace=hiveserver2 # 호스트명, 주키퍼 네임스페이스에 주의해서 신청 $ beeline> !connect jdbc:hive2://host1:2181, host2:2181, host3:2181/;serviceDiscoveryMode=zooKeeper;zooKeeperNamespace=[hiveserver2_zooKeeper_namespace] [user_name] [pass_word] 비 라인 SQLLine 커맨드 비 라인에서는 느낌표를 이용하여 SQLLine 커맨드를 입력할 수 있습니다. SQLLine 커맨드의 상세한 내용은 매뉴얼을 참고하시면 됩니다. 0: jdbc:hive2://localhost:10000> !columns tbl; 0: jdbc:hive2://localhost:10000> !quit 0: jdbc:hive2://localhost:10000> !columns tbl; 비 라인 하이브 커맨드 비 라인에서 사용할 수 있는 주요 하이브 커맨드는 다음과 같습니다. CLI와 동일한 커맨드를 이용할 수 있습니다. 커맨드 설명 reset 설정값 초기화 set <key>=<value> 설정값 입력 set 하이브의 설정값 출력 set -v 하둡, 하이브의 설정값 출력 add file <> 파일 추가 add files <> 여러 개의 파일 추가, 공백으로 경로 구분 add jar <> jar 파일 추가 add jars <> 여러 개의 jar 파일 추가, 공백으로 경로 구분 dfs <dfs command> 하둡 dfs 커맨드 실행 0: jdbc:hive2://localhost:10000> set mapred.reduce.tasks=32; No rows affected (0.044 seconds) 0: jdbc:hive2://localhost:10000> reset; No rows affected (0.134 seconds) 0: jdbc:hive2://localhost:10000> dfs -ls /user/; +------------------------------------------------------------------------------+--+ | DFS Output | +------------------------------------------------------------------------------+--+ | drwxrwxrwx - hadoop hadoop 0 2018-12-04 07:14 /user/hadoop | +------------------------------------------------------------------------------+--+ 출력 포맷 비 라인은 출력 포맷을 설정할 수 있습니다. XML, CSV, TSV 형태로 설정할 수 있기 때문에 처리 결과를 이용하여 다른 작업을 해야 하는 경우에 편리하게 이용할 수 있습니다. # --outputformat=[table/vertical/csv/tsv/dsv/csv2/tsv2] $ beeline --outputformat=csv -f sample.hql SQLLine는 자바를 기반으로 하는 DB 접속 도구입니다. 바로 가기 ↩ 하이브 비 라인 실행 매뉴얼 ↩ 5-메타 스토어 하이브의 메타정보는 파일의 물리적인 위치와 데이터에 대한 논리적인 정보로 구분할 수 있습니다. 이 메타정보를 보관하고 사용자의 요청에 따라 관련 정보를 제공하는 곳이 하이브 메타 스토어입니다. 메타 스토어는 쓰 리프트 1 프로토콜을 이용하여 다른 서비스에 정보를 제공합니다. 메타 정보는 JDBC 드라이버를 이용하여 RDBMS에 저장됩니다. 메타 스토어 타입 메타 스토어는 실행 유형에 따라 3가지 타입이 있습니다. 각 타입은 다음과 같습니다. 메타 스토어를 실행하면 하이브에서 필요한 기본 데이터베이스, 테이블을 확인하고 자동으로 생성합니다. 임베이디드 메타 스토어 기본 설정의 하이브는 더비 DB를 사용하게 됩니다. 임베이디드 메타 스토어는 한 번에 한 명의 유저만 접근할 수 있습니다. 따라서 주로 테스트 목적으로만 이용하는 것을 추천합니다. hive-site.xml 설정 <property> <name>javax.jdo.option.ConnectionURL</name> <value>jdbc:derby:metastore_db;create=true </value> <description>JDBC connect string for a JDBC metastore </description> </property> 로컬 메타 스토어 로컬 메타 스토어는 하이브와 같은 JVM에서 동작합니다. 메타 데이터는 외부의 RDBMS에 저장합니다. 따라서 여러 사용자가 동시에 이용할 수 있습니다. hive-site.xml 설정 <property> <name>javax.jdo.option.ConnectionURL</name> <value>jdbc:mysql://[IP]:[port]/[데이터베이스 이름]</value> <description>user name to use against metastore database</description> </property> <property> <name>javax.jdo.option.ConnectionDriverName</name> <value>org.mariadb.jdbc.Driver</value> <description>user name to use against metastore database</description> </property> <property> <name>javax.jdo.option.ConnectionUserName</name> <value>[사용자명]</value> <description>user name to use against metastore database</description> </property> <property> <name>javax.jdo.option.ConnectionPassword</name> <value>[암호]</value> <description>password to use against metastore database</description> </property> 원격 메타 스토어 원격 메타 스토어는 메타 스토어가 별도의 JVM에서 동작합니다. 쓰 리프트 프로토콜을 이용하여 접속합니다. hive-site.xml 설정 <property> <name>hive.metastore.uris</name> <value>thrift://[메타 스토어 IP]:[메타 스토어 Port]</value> <description>JDBC connect string for a JDBC metastore</description> </property> 이기종 간 통신을 위한 프로토콜. Apache Thrift (바로 가기) ↩ 1-메타 데이터베이스 하이브의 테이블들에 대한 논리적인 정보는 데이터베이스에 저장됩니다. 메타 스토어 서비스는 이 데이터베이스 정보를 여러 클라이언트에게 제공합니다. 데이터베이스는 더비, MSSQL, MySQL, 오라클 등을 지원합니다. 이 데이터베이스에 하이브 서비스에 필요한 스키마 1을 미리 생성하고 서비스합니다. 하이브 클라이언트를 이용해서 확인하는 정보는 이 데이터베이스의 정보에 기반하고 있습니다. 따라서 하이브 테이블 관련하여 필요한 정보를 확인하고 싶을 때는 데이터베이스에 직접 접속하여 확인해도 됩니다. 주요 테이블 하이브 데이터베이스의 주요 테이블은 다음과 같습니다. 테이블명 설명 DBS 데이터베이스 정보 TBLS 테이블 정보 PARTITIONS 파티션 정보 메타 데이터 확인 SQL 쿼리를 이용하여 메타 데이터를 확인하는 방법은 다음과 같습니다. 메타 데이터 확인 다음과 같이 메타 데이터를 확인할 수 있습니다. -- DB 정보 SELECT * FROM DBS; -- 테이블 정보 SELECT * FROM TBLS; -- DB, 테이블 조인 SELECT * FROM TBLS t, DBS d WHERE t.DB_ID = d.DB_ID ORDER BY d.NAME; -- 테이블 이름에 sample 이 들어가는 테이블을 찾아서, 디 비명, 테이블명, 파티션명을 출력 SELECT d.NAME, t.TBL_NAME, p.PART_NAME FROM DBS d, TBLS t, PARTITIONS p WHERE d.DB_ID = t.DB_ID AND t.TBL_ID = p.TBL_ID AND t.TBL_NAME like '%sample%'; 전체 테이블 하이브 메타 스토어의 전체 테이블은 다음과 같습니다. +---------------------------+ | Tables_in_hive | +---------------------------+ | AUX_TABLE | | BUCKETING_COLS | | CDS | | COLUMNS_V2 | | COMPACTION_QUEUE | | COMPLETED_COMPACTIONS | | COMPLETED_TXN_COMPONENTS | | DATABASE_PARAMS | | DBS | | DB_PRIVS | | DELEGATION_TOKENS | | FUNCS | | FUNC_RU | | GLOBAL_PRIVS | | HIVE_LOCKS | | IDXS | | INDEX_PARAMS | | KEY_CONSTRAINTS | | MASTER_KEYS | | NEXT_COMPACTION_QUEUE_ID | | NEXT_LOCK_ID | | NEXT_TXN_ID | | NOTIFICATION_LOG | | NOTIFICATION_SEQUENCE | | NUCLEUS_TABLES | | PARTITIONS | | PARTITION_EVENTS | | PARTITION_KEYS | | PARTITION_KEY_VALS | | PARTITION_PARAMS | | PART_COL_PRIVS | | PART_COL_STATS | | PART_PRIVS | | ROLES | | ROLE_MAP | | SDS | | SD_PARAMS | | SEQUENCE_TABLE | | SERDES | | SERDE_PARAMS | | SKEWED_COL_NAMES | | SKEWED_COL_VALUE_LOC_MAP | | SKEWED_STRING_LIST | | SKEWED_STRING_LIST_VALUES | | SKEWED_VALUES | | SORT_COLS | | TABLE_PARAMS | | TAB_COL_STATS | | TBLS | | TBL_COL_PRIVS | | TBL_PRIVS | | TXNS | | TXN_COMPONENTS | | TYPES | | TYPE_FIELDS | | VERSION | | WRITE_SET | +---------------------------+ MySQL 생성 쿼리: GitHub 바로 가기 ↩ 2-메타 스토어 데이터베이스 설정 원격 하이브 메타 스토어를 이용하기 위해서는 MySQL, 오라클 같은 RDB에 하이브 메타 스토어 스키마를 설정해야 합니다. hive-site.xml에 RDB에 접속을 위한 정보를 입력하고, 커맨드를 입력하여 스키마를 생성할 수 있습니다. hive-site.xml 설정 하이브의 conf 아래 hive-site.xml에 다음과 같이 데이터 베이스 접속을 위한 정보를 입력합니다. <?xml version="1.0"?> <configuration> <property> <name>javax.jdo.option.ConnectionURL</name> <value>jdbc:mysql://database_ip:database_port/database_name</value> </property> <property> <name>javax.jdo.option.ConnectionDriverName</name> <value>org.mariadb.jdbc.Driver</value> </property> <property> <name>javax.jdo.option.ConnectionUserName</name> <value>user_name</value> </property> <property> <name>javax.jdo.option.ConnectionPassword</name> <value>password</value> </property> </configuration> 스키마 생성 스키마 생성 방법은 다음과 같습니다. dbType에 사용하는 데이터베이스를 입력하면 됩니다. mssql, mysql, oracle, postgres를 지원합니다. $ hive --service schemaTool -dbType mysql -initSchema 스키마 업그레이드 하이브 버전을 바꾸게 되면 하위 버전의 스키마를 상위 버전으로 업그레이드해야 하는 경우가 생깁니다. 이럴 때는 다음과 같이 사용합니다. $ hive --service schemaTool -dbType mysql -upgradeSchema 스키마 정보 확인 하이브 스키마의 정보를 확인하는 방법은 다음과 같습니다. $ hive --service schemaTool -dbType mysql -info Metastore connection URL: jdbc:mysql://database_ip:database_port/database_name Metastore Connection Driver : org.mariadb.jdbc.Driver Metastore connection User: user_name Hive distribution version: 2.3.0 Metastore schema version: 2.3.0 schemaTool completed 2-데이터베이스 하이브의 데이터베이스는 테이블의 이름을 구별하기 위한 네임 스페이스 역할을 합니다. 그리고 테이블의 데이터의 기본 저장 위치를 제공합니다. 데이터베이스를 생성할 때 로케이션을 지정하지 않으면 설정값 1을 기본 위치로 설정합니다. 데이터베이스의 로케이션은 테이블이 로케이션을 지정하지 않았을 때 기본 저장 위치 2가 됩니다. # 기본 위치 hive.metastore.warehouse.dir = hdfs:///user/hive/ # 데이터베이스의 기본 위치 hdfs:///user/hive/{데이터베이스 명}.db # 테이블의 기본 위치 hdfs:///user/hive/{데이터베이스 명}.db/{테이블명} 데이터 베이스 생성 데이터 베이스 생성은 다음과 같이 할 수 있습니다. 하이브 DDL 매뉴얼에 따르면 DATABASE와 SCHEMA는 동일합니다. 3 데이터 베이스를 생성할 때 저장 로케이션과 프로퍼티를 설정할 수 있습니다. IF NOT EXISTS 구문을 이용하여 같은 이름의 데이터 베이스가 있으면 생성하지 않도록 할 수 있습니다. CREATE (DATABASE|SCHEMA) [IF NOT EXISTS] database_name [COMMENT database_comment] [LOCATION hdfs_path] [WITH DBPROPERTIES (property_name=property_value, ...)]; 데이터 베이스 수정 ALTER를 이용하여 프로퍼티, 유저, 로케이션을 수정할 수 있습니다. 로케이션의 변경해도 하위 테이블의 데이터가 이동되는 것은 아닙니다. 테이블, 파티션의 로케이션에는 영향을 미치지 않습니다. 데이터베이스의 기본 로케이션만 변경됩니다. ALTER (DATABASE|SCHEMA) database_name SET DBPROPERTIES (property_name=property_value, ...); -- (Note: SCHEMA added in Hive 0.14.0) ALTER (DATABASE|SCHEMA) database_name SET OWNER [USER|ROLE] user_or_role; -- (Note: Hive 0.13.0 and later; SCHEMA added in Hive 0.14.0) ALTER (DATABASE|SCHEMA) database_name SET LOCATION hdfs_path; -- (Note: Hive 2.2.1, 2.4.0 and later) 데이터 베이스 삭제 DROP 을 이용하여 데이터베이스를 삭제할 수 있습니다. 기본적으로 RESTRICT 옵션을 이용하고 있습니다. IF EXISTS 구문을 이용하면 데이터 베이스가 존재할 때만 삭제할 수 있습니다. RESTRICT: 데이터 베이스에 테이블이 있으면 삭제 불가 CASCADE: 테이블이 있어도 삭제 가능 DROP (DATABASE|SCHEMA) [IF EXISTS] database_name [RESTRICT|CASCADE]; 예제 데이터 베이스 생성, 수정, 삭제하는 방법은 다음과 같습니다. -- 데이터 베이스 생성 CREATE DATABASE IF NOT EXISTS sample_database COMMENT "test database" LOCATION "/user/shs/sample_database/" WITH DBPROPERTIES ( 'key1' = 'value1', 'key2' = 'value2' ); -- 데이터베이스 정보 확인 hive> DESC DATABASE EXTENDED sample_database; OK sample_database test database hdfs:///user/shs/sample_database hadoop USER {key1=value1, key2=value2} -- 데이터베이스 정보 수정 ALTER DATABASE sample_database SET DBPROPERTIES ("key1"="value4"); hive> DESC DATABASE EXTENDED sample_database; OK sample_database test database hdfs:///user/shs/sample_database hadoop USER {key1=value4, key2=value2} -- 데이터베이스 드롭 -- 하위에 테이블이 존재하면 오류가 발생 hive> DROP DATABASE sample_database; FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. InvalidOperationException(message:Database sample_database is not empty. One or more tables exist.) -- CASCADE 옵션을 이용하여 삭제 hive> DROP DATABASE sample_database CASCADE; OK Time taken: 0.227 seconds 참고 하이브 DDL - 데이터베이스 hive.metastore.warehouse.dir ↩ {데이터베이스 로케이션}/{테이블명} ↩ 하이브 DDL의 정의 - The uses of SCHEMA and DATABASE are interchangeable – they mean the same thing. 바로 가기 ↩ 3-테이블 하이브에서 테이블은 HDFS 상에 저장된 파일과 디렉터리 구조에 대한 메타 정보라고 할 수 있습니다. 실제 저장된 파일의 구조에 대한 정보와 저장 위치, 입력 포맷, 출력 포맷, 파티션 정보, 프로퍼티에 대한 정보 등 다양한 정보를 가지고 있습니다. 테이블 생성 저장 위치 LOCATION 테이블 타입 MANAGED EXTERNAL TEMPORARY 파티션 PARTITIONED BY 버켓팅, 스큐 CLUSTERED BY SORTED BY INTO BUCKETS SKEWED BY 테이블 포맷(ROW FORMAT) DELIMITED 서데(SerDe) 저장 포맷(STORED AS) 테이블 수정 칼럼 수정 - CHANGE 칼럼 수정 - REPLACE 참고 테이블 생성 테이블 생성은 CREATE 명령을 이용하여 생성합니다. 상세한 옵션은 다음과 같습니다. -- 테이블 생성 쿼리 CREATE [TEMPORARY] [EXTERNAL] TABLE [IF NOT EXISTS] [db_name.] table_name -- (Note: TEMPORARY available in Hive 0.14.0 and later) [(col_name data_type [COMMENT col_comment], ... [constraint_specification])] [COMMENT table_comment] [PARTITIONED BY (col_name data_type [COMMENT col_comment], ...)] [CLUSTERED BY (col_name, col_name, ...) [SORTED BY (col_name [ASC|DESC], ...)] INTO num_buckets BUCKETS] [SKEWED BY (col_name, col_name, ...) -- (Note: Available in Hive 0.10.0 and later)] ON ((col_value, col_value, ...), (col_value, col_value, ...), ...) [STORED AS DIRECTORIES] [ [ROW FORMAT row_format] [STORED AS file_format] | STORED BY 'storage.handler.class.name' [WITH SERDEPROPERTIES (...)] -- (Note: Available in Hive 0.6.0 and later) ] [LOCATION hdfs_path] [TBLPROPERTIES (property_name=property_value, ...)] -- (Note: Available in Hive 0.6.0 and later) [AS select_statement]; -- (Note: Available in Hive 0.5.0 and later; not supported for external tables) -- LIKE를 이용하여 기 존재하는 테이블과 동일하게 테이블 생성 CREATE [TEMPORARY] [EXTERNAL] TABLE [IF NOT EXISTS] [db_name.] table_name LIKE existing_table_or_view_name [LOCATION hdfs_path]; -- 테이블의 데이터를 구분하는 기준 포맷 row_format : DELIMITED [FIELDS TERMINATED BY char [ESCAPED BY char]] [COLLECTION ITEMS TERMINATED BY char] [MAP KEYS TERMINATED BY char] [LINES TERMINATED BY char] [NULL DEFINED AS char] -- (Note: Available in Hive 0.13 and later) | SERDE serde_name [WITH SERDEPROPERTIES (property_name=property_value, property_name=property_value, ...)] -- 테이블의 데이터를 저장하는 파일의 타입 file_format: : SEQUENCEFILE | TEXTFILE -- (Default, depending on hive.default.fileformat configuration) | RCFILE -- (Note: Available in Hive 0.6.0 and later) | ORC -- (Note: Available in Hive 0.11.0 and later) | PARQUET -- (Note: Available in Hive 0.13.0 and later) | AVRO -- (Note: Available in Hive 0.14.0 and later) | INPUTFORMAT input_format_classname OUTPUTFORMAT output_format_classname -- 테이블의 제약조건 constraint_specification: : [, PRIMARY KEY (col_name, ...) DISABLE NOVALIDATE ] [, CONSTRAINT constraint_name FOREIGN KEY (col_name, ...) REFERENCES table_name(col_name, ...) DISABLE NOVALIDATE 저장 위치 LOCATION 테이블의 저장 위치는 테이블에 쓰는 데이터의 저장 위치입니다. 사용자가 입력하지 않으면 데이터베이스의 저장 위치 아래 테이블 이름의 폴더로 기본 생성됩니다. 테이블 타입 MANAGED 테이블 생성 시 옵션을 따로 주지 않으면 매니지드 테이블이 생성됩니다. 세션이 종료되어도 테이블의 데이터와 파일은 유지됩니다. 테이블을 DROP 하면 파일도 함께 삭제됩니다. EXTERNAL EXTERNAL 옵션은 매니지드 테이블과 파일 삭제 정책을 제외하고 동일합니다. 익스터널 테이블은 DROP 하면 파일은 그대로 유지됩니다. 사용자의 실수로 인한 파일 삭제를 방지하기 위해서 EXTERNAL 테이블로 관리하는 것이 좋습니다. TEMPORARY TEMPORARY 옵션은 현재 세션에서만 사용하는 테이블을 생성할 수 있습니다. 현재 세션이 종료되면 제거되기 때문에 임시 테이블 생성에 사용하면 좋습니다. 파티션 PARTITIONED BY 파티션은 폴더 구조로 데이터를 분할하여 저장합니다. PARTITIOND BY에 지정한 칼럼의 정뵤를 이용하여 폴더 단위로 데이터가 생성됩니다. 파티션 생성 시 정보의 제공 유무에 따라 다이내믹 파티션과 스태틱 파티션이 있습니다. 하이브는 폴더 단위로 데이터를 읽기 때문에 파티션이 없다면 테이블의 모든 데이터를 읽게 됩니다. 시간이 갈수록 데이터가 쌓이게 되면 점점 조회 시간이 길어집니다. 이를 방지하기 위하여 일자나 특정 조건을 이용하여 파티션을 지정하고, 조회 시에 파티션을 이용하여 데이터를 조회하면 조회 속도를 높일 수 있습니다. -- 일자를 기준으로 파티션 생성 CREATE TABLE tbl( col1 STRING ) PARTITIONED BY (yymmdd STRING); -- 데이터 저장 구조 hdfs://tbl/yymmddval=20180501/0000_0 hdfs://tbl/yymmddval=20180502/0000_0 hdfs://tbl/yymmddval=20180503/0000_0 -- 조회 SELECT yymmdd, count(1) FROM tbl WHERE yymmdd between '20180501' and '20180503' GROUP BY yymmdd 버켓팅, 스큐 CLUSTERED BY SORTED BY INTO BUCKETS 버켓팅은 CLUSTERED BY를 이용하여 설정합니다. 일반적으로 SORTED BY와 함께 사용합니다. 설정한 버킷의 개수(파일의 개수)에 지정한 칼럼의 데이터를 해시 처리하여 저장합니다. 버켓팅한 테이블은 조인 시에 SMB 조인으로 처리할 수 있게 되어 조인 시에 속도가 빨라집니다. -- col2를 기준으로 버켓팅 하여 20개의 파일에 저장 CREATE TABLE tbl( col1 STRING, col2 STRING ) CLUSTERED BY col2 SORTED BY col2 INTO 20 BUCKETS SKEWED BY 스큐는 값을 분리된 파일에 저장하여 특정한 값이 자주 등장할 때 속도를 높이는 방법입니다. -- col1의 col_value 값을 스큐로 저장 CREATE TABLE tbl ( col1 STRING, col2 STRING ) SKEWED BY (col1) on ('col_value'); 테이블 포맷(ROW FORMAT) 테이블 포맷(ROW FORMAT)은 데이터를 칼럼 단위로 구분하는 구분자(delimeter)와 데이터를 해석하는 방법을 지정하는 서데(SerDe)를 지정합니다. 사용자가 지정하지 않으면 기본 구분자와 서데를 사용합니다. DELIMITED 하이브는 구분자에 따라서 데이터를 분리하여 칼럼 단위로 보여줍니다. 하이브의 구분자를 설정하는 방법은 아래와 같습니다. 기본 구분자 칼럼 구분자: \001, 컬렉션 아이템 구분자: \002, 맵 아이템 구분자: \003 -- 하이브의 기본 구분자를 이용한 테이블 생성 -- 입력 데이터 $ cat sample.txt a, val1^val2^val3, key1:val1^key2:val2 -- ROW FORMAT을 이용한 테이블 생성 CREATE TABLE tbl ( col1 STRING, col2 ARRAY<STRING>, col3 MAP<STRING, STRING> ) ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' COLLECTION ITEMS TERMINATED BY '^' MAP KEYS TERMINATED BY ':'; -- 데이터 로드 LOAD DATA LOCAL INPATH './sample.txt' INTO TABLE tbl; -- 데이터 조회, 구분자에 따라 데이터가 구분됨 hive> select * from tbl; OK a ["val1","val2","val3"] {"key1":"val1","key2":"val2"} -- 지정 가능한 구분자 FIELDS TERMINATED BY '\t' -- 칼럼을 구분하는 기준 COLLECTION ITEMS TERMINATED BY ',' -- 리스트를 구분하는 기준 MAP KEYS TERMINATED BY '=' -- 맵 데이터의 키와 밸류를 구분하는 기준 LINES TERMINATED BY '\n' --로(row)를 구분하는 기준 ESCAPED BY '\\' -- 값을 입력하지 않음 NULL DEFINED AS 'null' -- null 값을 표현(0.13 버전에서 추가) 서데(SerDe) 서데는 데이터를 해석하는 방법을 지정합니다. 하이브에서 제공하는 서데는 기본서데, 정규식(RegExSerDe), JSON(JsonSerDe), CSV(OpenCSVSerde)가 존재합니다. 사용자가 개발하여 적용할 수도 있습니다. 각 서데의 상세한 사용법은 하이브 위키를 참고하면 됩니다. 각 서데의 사용법은 다음과 같습니다. -- RegEx 서 데 -- 127.0.0.1 - frank [10/Oct/2000:13:55:36 -0700] "GET /apache_pb.gif HTTP/1.0" 200 2326 CREATE TABLE apachelog ( host STRING, identity STRING, user STRING, time STRING, request STRING, status STRING, size STRING, referer STRING, agent STRING) ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.RegexSerDe' WITH SERDEPROPERTIES ( "input.regex" = "([^]*) ([^]*) ([^]*) (-|\\[^\\]*\\]) ([^ \"]*|\"[^\"]*\") (-|[0-9]*) (-|[0-9]*)(?: ([^ \"]*|\".*\") ([^ \"]*|\".*\"))?" ); -- JSON 서 데 CREATE TABLE my_table( a string, b bigint ) ROW FORMAT SERDE 'org.apache.hive.hcatalog.data.JsonSerDe' STORED AS TEXTFILE; -- CSV 서 데 CREATE TABLE my_table( a string, b string ) ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.OpenCSVSerde' WITH SERDEPROPERTIES ( "separatorChar" = "\t", "quoteChar" = "'", "escapeChar" = "\\" ) STORED AS TEXTFILE; 저장 포맷(STORED AS) STROED AS는 데이터를 저장하는 파일 포맷을 지정합니다. 저장 포맷은 TEXTFILE, SEQUENCEFILE, ORC, PARQUET 등이 존재합니다. 사용자가 개발하여 적용할 수도 있습니다. 상세한 내용은 하이브 위키를 확인하면 됩니다. -- 저장 포맷을 ORC로 설정하고, ORC 관련 설정 정보 전달 CREATE TABLE tbl ( col1 STRING ) STORED AS ORC TBLPROPERTIES ("orc.compress"="SNAPPY"); -- INPUTFORMAT, OUTPUTFORMAT을 따로 지정하는 것도 가능 CREATE TABLE tbl1 ( col1 STRING ) STORED AS INPUTFORMAT "com.hadoop.mapred.DeprecatedLzoTextInputFormat" OUTPUTFORMAT "org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat"; 테이블 수정 ALTER 명령을 이용하여 테이블 칼럼 정보를 수정할 수 있습니다. 다음 예제는 공식 문서에 공개된 예제인데 하이브 버전에 따라서 동작하지 않을 수도 있습니다. 테이블의 서데에 따라서도 변경되지 않을 수도 있습니다. 테이블 구조를 변경할 때는 EXTERNAL 테이블일 경우 테이블을 신규로 생성하는 것이 더 좋을 수 있습니다. 칼럼 수정 - CHANGE 다음은 칼럼의 타입을 변경하는 CHAGE 명령어 예제입니다. -- 테이블 생성 CREATE TABLE test_change (a int, b int, c int); -- a 칼럼을 a1으로 이름 수정 ALTER TABLE test_change CHANGE a a1 INT; -- a1을 a2로 변경하고, b 칼럼 뒤로 이동 ALTER TABLE test_change CHANGE a1 a2 STRING AFTER b; -- 테이블 구조가 변경됨: b int, a2 string, c int. -- c를 c1으로 바꾸고 첫밴째 위치로 이동 ALTER TABLE test_change CHANGE c c1 INT FIRST; -- 테이블 구조가 변경됨: c1 int, b int, a2 string. -- a2를 a3로 바꾸고 b 칼럼 뒤로 이동 ALTER TABLE test_change CHANGE a2 a3 INT COMMENT 'this is column a3' AFTER b; 칼럼 수정 - REPLACE 다음은 칼럼을 새로 생성하는 REPLACE 명령어 예제입니다. 이 명령어는 모든 칼럼을 삭제 후, 새로 생성합니다. -- tbl 테이블의 칼럼을 모두 삭제 후 x, y, z 칼럼으로 생성 ALTER TABLE tbl REPLACE COLUMNS (x INT COMMENT 'this is column x', y INT COMMENT 'this is column y', z INT COMMENT 'this is column z'); 참고 LanguageManual DDL Alter Table/Partition/Column 01-데이터 타입 하이브의 데이터 타입은 기본 원시 타입과 복합 타입을 지원합니다. 데이터 타입에 대한 상세한 설명은 하이브 위키를 참고하시면 됩니다. data_type : primitive_type | array_type | map_type | struct_type | union_type -- (Note: Available in Hive 0.7.0 and later) primitive_type : TINYINT | SMALLINT | INT | BIGINT | BOOLEAN | FLOAT | DOUBLE | DOUBLE PRECISION -- (Note: Available in Hive 2.2.0 and later) | STRING | BINARY -- (Note: Available in Hive 0.8.0 and later) | TIMESTAMP -- (Note: Available in Hive 0.8.0 and later) | DECIMAL -- (Note: Available in Hive 0.11.0 and later) | DECIMAL(precision, scale) -- (Note: Available in Hive 0.13.0 and later) | DATE -- (Note: Available in Hive 0.12.0 and later) | VARCHAR -- (Note: Available in Hive 0.12.0 and later) | CHAR -- (Note: Available in Hive 0.13.0 and later) array_type : ARRAY < data_type > map_type : MAP < primitive_type, data_type > struct_type : STRUCT < col_name : data_type [COMMENT col_comment], ...> union_type : UNIONTYPE < data_type, data_type, ... > -- (Note: Available in Hive 0.7.0 and later) CREATE TABLE tbl ( col1 INT, col2 STRING, col3 ARRAY<STRING>, col4 MAP<STRING, STRING>, col5 STRUCT<age:INT, name:STRING>, col6 UNIONTYPE<int, double, array<string>, struct<a:int, b:string>> ); 기본 타입 기본 타입은 INT, FLOAT, STRING, DATE 등 을 지원한다. 복합 타입 복합 타입은 array, map, struct, union을 지원한다. ARRAY 배열 타입이다. 인덱스로 접근이 가능하다. SELECT col3[0] FROM tbl; MAP 사전 타입이다. 키로 접근이 가능하다. SELECT col4['key1'] FROM tbl; STRUCT 자바의 클래스와 유사합니다. 주어진 칼럼의 정보에 필드명으로 접근하여 데이터를 반환합니다. SELECT col5.age FROM tbl; SELECT col5.name FROM tbl; UNIONTYPE 지정한 데이터 타입 중 하나를 저장합니다. 출력 시에 보이는 정보는 {데이터 타입 번호:데이터}와 같은 형태로 보입니다. CREATE TABLE union_test( foo UNIONTYPE<int, double, array<string>, struct<a:int, b:string>> ); -- 0: int -- 1: double -- 2: array<string> -- 3: struct<a:int, b:string> SELECT foo FROM union_test; {0:1} {1:2.0} {2:["three","four"]} {3:{"a":5, "b":"five"}} {2:["six","seven"]} {3:{"a":8, "b":"eight"}} {0:9} {1:10.0} 02-입력(Insert), 조회(Select) 입력과 조회는 하이브 테이블의 메타 정보를 이용하여 데이터를 읽고, 쓰는 작업입니다. 테이블의 메타 정보에 실제 파일의 로케이션과 데이터의 포맷이 저장되어 있습니다. 이 정보를 이용하여 파일을 읽고, 쓰게 됩니다. 입력(INSERT)은 INSERT 문으로 테이블에 데이터를 쓰는 방법과 테이블의 저장 위치, 테이블을 생성할 때 지정한 LOCATION에 파일을 복사하는 방법이 있습니다. 파티션 테이블은 파티션으로 나누어진 디렉터리를 구성하고 파일을 복사하면 됩니다. 조회(SELECT)는 테이블의 LOCATION의 위치에 있는 파일을 읽습니다. 하이브는 로케이션 아래의 모든 파일을 읽기 때문에 용량이 큰 파일을 저장한다면 파티션을 이용하여 데이터를 분산하여 주는 것이 좋습니다. 입력과 조회 방법은 파일을 읽어서 테이블에 쓰는 방법, 테이블의 데이터를 읽어서 다른 테이블에 쓰는 방법 마지막으로 테이블을 읽어서 지정한 디렉터리에 쓰는 방법이 있습니다. 파일 to 테이블 LOAD 명령으로 테이블에 쓰기 테이블의 LOCATION에 파일을 복사 테이블 파티션을 추가/수정하여 LOCATION을 파일 위치로 주는 법 MSCK 문으로 파티션 연결 테이블 to 테이블 INSERT 문 FROM INSERT 문 CREATE TABLE AS SELECT 문 INSERT, UPDATE, DELETE, MERGE 테이블 to 디렉터리 INSERT DIRECTORY 문 파일 to 테이블 파일을 읽어서 테이블의 LOCATION에 쓰는 방법입니다. LOAD 명령을 이용하는 방법, 테이블의 로케이션에 파일을 복사하는 방법 등이 있습니다. LOAD 명령으로 테이블에 쓰기 LOAD 명령으로 파일을 읽어서 테이블에 쓰면 테이블의 LOCATION에 데이터가 생성됩니다. HDFS와 로컬의 데이터를 테이블에 쓸 수 있고, 파티션 추가도 가능합니다. LOAD 명령의 기본 문법은 다음과 같습니다. LOCAL이 있으면 로컬의 데이터를 읽고, 없으면 HDFS의 파일을 읽습니다. OVERWRITE로 파일을 덮어쓸 수 있습니다. LOAD DATA [LOCAL] INPATH 'filepath' [OVERWRITE] INTO TABLE tablename [PARTITION (partcol1=val1, partcol2=val2 ...)] LOAD 명령을 이용한 예제는 다음과 같습니다. -- hdfs의 파일을 읽어서 tbl 테이블에 입력 LOAD DATA INPATH 'hdfs://127.0.0.1/user/data/sample.csv' INTO TABLE tbl; -- hdfs의 파일을 읽어서 tbl 테이블의 파티션 yymmdd='20180510'으로 입력 LOAD DATA INPATH '/user/data/sample.csv' INTO TABLE tbl PARTITION(yymmdd='20180510'); -- 로컬의 파일을 읽어서 tbl 테이블에 입력 LOAD DATA LOCAL INPATH './sample.csv' INTO TABLE tbl; -- test.txt 파일을 sample1 테이블에 로드하고 데이터 조회 LOAD DATA LOCAL INPATH './test.txt' INTO TABLE sample1; 테이블의 LOCATION에 파일을 복사 테이블의 메타정보에는 물리적인 파일의 위치를 위한 LOCATION이 존재합니다. 테이블을 조회할 때 해당 위치의 파일을 읽기 때문에 이 위치에 파일을 복사하면 데이터를 입력한 것과 동일한 역할을 합니다. 로컬 위치는 지정할 수는 없고, HDFS, S3 등 하둡에서 접근 가능한 파일 공유 파일 시스템을 이용해야 합니다. 테이블의 LOCATION 정보를 지정하는 방법은 CREATE 시에 지정할 수 있고, ALTER 문을 이용해서 처리할 수도 있습니다. -- 테이블을 생성하면서 LOCATION을 지정 CREATE TABLE employee ( id String, name String ) LOCATION 'hdfs://127.0.0.1/user/data/'; -- 테이블을 생성하고, 나중에 테이블의 위치를 ALTER 명령으로 지정 CREATE TABLE employee ( id String, name String); -- ALTER 명령으로 테이블의 로케이션 변경 ALTER TABLE employee SET LOCATION 'hdfs://127.0.0.1/user/data/'; 다음은 sample1 테이블을 LOCATION을 지정하지 않고 생성한 후 ALTER 문으로 로케이션을 지정하여 데이터를 조회하는 예제입니다. -- 테이블 생성 후 조회 시 데이터가 없음 hive> create table sample1(col1 string); hive> select * from sample1; OK Time taken: 0.8 seconds -- HDFS에 데이터가 존재 $ hadopo fs -ls hdfs://0.0.0.0:8020/user/data/ 2018-05-21 07:38:47 14 test.txt -- 로케이션을 설정 후 조회 시 데이터가 확인됨 hive> alter table sample 1set location 'hdfs://0.0.0.0:8020/user/data/'; hive> select * from sample1; OK b d g Time taken: 0.055 seconds, Fetched: 7 row(s) LOCATION을 지정하여 데이터를 조회할 때 서브 디렉터리 모두를 조회해야 한다면 옵션을 설정하여 조회하면 됩니다. -- 하위 폴더를 모두 검색할 수하는 옵션 set hive.supports.subdirectories=true; set mapred.input.dir.recursive=true; 테이블 파티션을 추가/수정하여 LOCATION을 파일 위치로 주는 법 파티션 테이블은 파티션 별로 LOCATION을 가지고 있습니다. 파티션의 LOCATION에 파일을 이동시키면 조회 시에 해당 데이터를 이용합니다. 신규 파티션을 생성할 때와 기존 파티션의 LOCATON을 수정하는 방법은 다음과 같습니다. -- 신규 파티션을 추가하면서 LOCATION을 지정 ALTER TABLE employee ADD PARTITION (yymmdd='20180510') LOCATION 'hdfs://127.0.0.1/user/'; -- 기존 파티션의 LOCATION을 수정 ALTER TABLE employee PARTITION (yymmdd='20180510') SET LOCATION 'hdfs://127.0.0.1/user/'; MSCK 문으로 파티션 연결 MSCK 문은 테이블을 신규 생성할 때 많이 사용합니다. 신규 테이블 LOCATON 정보에 기존 디렉터리의 정보를 매칭 시킬 때 MSCK 문을 이용하면 LOCATION 하위에 존재하는 디렉터리 정보를 이용하여 자동으로 파티션을 생성해 줍니다. 주로 테이블 정보가 삭제되어 테이블을 신규로 생성하고 파티션 정보를 새로 생성할 때나, 외부에서 대량의 데이터가 추가되어 파티션 정보를 신규로 생성하여야 할 때 유용하게 사용할 수 있습니다. -- hdfs에 아래와 같이 폴더가 존재 hdfs://127.0.0.1/user/employee/yymmdd=20180101/ hdfs://127.0.0.1/user/employee/yymmdd=20180101/ -- 테이블 생성 후 로케이션 지정 -- 로케이션을 폴더가 존재하고, 파티션이 생성되는 위치로 지정 CREATE TABLE employee ( name STRING, age STRING ) PARTITIONED BY (yymmdd STRING) LOCATION 'hdfs://127.0.0.1/user/employee'; -- 파티션 연결 MSCK REPAIR TABLE employee; 테이블 to 테이블 테이블의 정보를 읽어서 다른 테이블에 입력하는 방법입니다. INSERT 문 기본적인 데이터 입력 방식으로 테이블, 뷰의 데이터를 다른 테이블에 입력합니다. INSERT 문의 기본 문법은 다음과 같습니다. INSERT OVERWRITE TABLE tablename1 [PARTITION (partcol1=val1, partcol2=val2 ...) [IF NOT EXISTS]] select_statement1 FROM from_statement; INSERT INTO TABLE tablename1 [PARTITION (partcol1=val1, partcol2=val2 ...)] select_statement1 FROM from_statement; INSERT 문은 이용할 때는 다음과 같이 기본 테이블에 입력할 수도 있고, 파티션 테이블에 정보를 이용하여 입력할 수도 있습니다. -- source의 내용을 target 테이블에 입력 INSERT INTO TABLE target SELECT * FROM source; -- OVERWRITE가 붙으면 해당 위치의 내용을 삭제하고 덮어쓴다. INSERT OVERWRITE TABLE target PARTITION(col1 = 'a', col2) SELECT data1, date2 FROM source; FROM INSERT 문 FROM INSERT 문은 여러 테이블에 한 번에 입력할 때 사용합니다. FROM 절에 원천 데이터를 조회하여 뷰처럼 사용할 수 있습니다. FROM INSERT 문의 기본 문법은 다음과 같습니다. FROM page_view_stg pvs INSERT OVERWRITE TABLE page_view PARTITION(dt='2008-06-08', country) SELECT pvs.ip, pvs.country; 다음은 source1, source2 테이블을 읽어서 target1, target2 테이블에 입력하는 예제입니다. FROM ( SELECT * FROM source1 UNION SELECT * FROM source2 ) R INSERT INTO TABLE target1 SELECT R.name, R.age INSERT OVERWRITE TABLE target2 PARTITION(col1 = 'a', col2) SELECT R.name, R.age; CREATE TABLE AS SELECT 문 CTAS 문은 테이블을 생성하면서 데이터를 입력합니다. SELECT로 조회한 데이터를 CREATE 문으로 생성한 테이블에 입력합니다. CREATE 시에 기존에 테이블 생성할 때와 동일하게 부가 정보를 입력하여 생성할 수 있습니다. -- source_table을 target_table로 생성 CREATE TABLE target_table AS SELECT * FROM source_table; -- CREATE 문과 동일하게 생성하고 AS 문 다음에 SELECT 문 입력 CREATE TABLE new_key_value_store ROW FORMAT SERDE "org.apache.hadoop.hive.serde2.columnar.ColumnarSerDe" STORED AS RCFile AS SELECT (key % 1024) new_key, concat(key, value) key_value_pair FROM key_value_store SORT BY new_key, key_value_pair; INSERT, UPDATE, DELETE, MERGE 하이브 0.14부터는 INSERT, UPDATE, DELETE, MERGE 문을 지원합니다. 하이브 버전에 따라 실행되지 않을 수도 있습니다. UPDATE, DELETE는 트랜잭션 설정을 하여야만 사용할 수 있습니다. CREATE TABLE students (name VARCHAR(64), age INT, gpa DECIMAL(3, 2)) CLUSTERED BY (age) INTO 2 BUCKETS STORED AS ORC; -- INSERT INSERT INTO TABLE students VALUES ('fred flintstone', 35, 1.28), ('barney rubble', 32, 2.32); -- UPDATE UPDATE students SET age = 10 WHERE name = 'fred flintstone'; -- DELETE DELETE FROM students WHERE name = 'fred flintstone'; -- MERGE MERGE INTO <target table> AS T USING <source expression/table> AS S ON <boolean expression1> WHEN MATCHED [AND <boolean expression2>] THEN UPDATE SET <set clause list> WHEN MATCHED [AND <boolean expression3>] THEN DELETE WHEN NOT MATCHED [AND <boolean expression4>] THEN INSERT VALUES<value list> 테이블 to 디렉터리 테이블 데이터를 조회하여 디렉터리에 파일로 생성하는 방법입니다. INSERT DIRECTORY 문 테이블의 데이터를 읽어서 지정한 위치에 파일을 출력합니다. ROW FORMAT을 이용하여 데이터를 저장하는 방법을 설정할 수 있습니다. 기본 문법은 다음과 같습니다. INSERT OVERWRITE [LOCAL] DIRECTORY directory1 [ROW FORMAT row_format] [STORED AS file_format] (Note: Only available starting with Hive 0.11.0) SELECT ... FROM ... Hive extension (multiple inserts): FROM from_statement INSERT OVERWRITE [LOCAL] DIRECTORY directory1 select_statement1 [INSERT OVERWRITE [LOCAL] DIRECTORY directory2 select_statement2] ... row_format : DELIMITED [FIELDS TERMINATED BY char [ESCAPED BY char]] [COLLECTION ITEMS TERMINATED BY char] [MAP KEYS TERMINATED BY char] [LINES TERMINATED BY char] [NULL DEFINED AS char] (Note: Only available starting with Hive 0.13) 다음은 디렉터리에 파일을 쓰는 예제입니다. source 테이블의 정보를 읽어서 지정한 디렉터리에 저장할 수 있습니다. ROW FORMAT을 이용하여 원하는 형태로 변형하여 저장할 수도 있습니다. # /user/ 디렉터리에 source 테이블을 읽어서 저장 INSERT OVERWRITE DIRECTORY 'hdfs://1.0.0.1:8020/user/' SELECT * FROM source # /user/ 디렉터리에 source 테이블을 읽어서 칼럼 구분을 탭으로 저장 INSERT OVERWRITE DIRECTORY 'hdfs://1.0.0.1:8020/user/' ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t' SELECT * FROM source # /user/ 디렉터리에 source 테이블을 읽어서 칼럼 구분을 콤마으로 저장하면서 Gzip으로 압축 # 파일을 CSV 형태로 압축하여 저장 set hive.exec.compress.output=true; set mapred.output.compression.codec=org.apache.hadoop.io.compress.GzipCodec; INSERT OVERWRITE DIRECTORY 'hdfs://1.0.0.1:8020/user/' ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' SELECT * FROM source 1-복합 타입 입력 STRUCT와 UNIONTYPE 같은 복합 타입의 입력과 조회 방법에 대해서 알아보겠습니다. STRUCT 자바의 Value Object와 유사 칼럼명. 속성 형태로 데이터에 접근 UNIONTYPE 하나의 칼럼이 여러 가지 속성을 가질 수 있음 반환값으로 데이터 타입과 데이터 값을 반환 STRUCT 테이블 생성 및 조회 -- 테이블 생성 CREATE TABLE struct_tbl ( struct_col STRUCT<age:INT, name:STRING> ) ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t' COLLECTION ITEMS TERMINATED BY ',' MAP KEYS TERMINATED BY '=' -- 입력 데이터 예제. 콤마(,)로 구분 $ cat sample.tsv 1, A 2, B -- 데이터 적용 LOAD DATA LOCAL INPATH './sample.tsv' INTO TABLE struct_tbl; -- 데이터 조회 방법 hive> SELECT struct_col.age FROM struct_tbl; 2 hive> SELECT struct_col.name FROM struct_tbl; B STRUCT 데이터 생성 하이브에서 제공하는 기본 함수로 STRUCT를 생성하는 방법은 두 가지입니다. struct와 named_struct를 이용하는 방법입니다. -- struct는 이름 없는 데이터를 생성 hive> SELECT struct("a", "b"); OK {"col1":"a", "col2":"b"} -- named_struct는 칼럼 이름을 지정하고 데이터를 생성 hive> SELECT named_struct("a", 1, "b", 2); OK {"a":1, "b":2} STRUCT 데이터 입력 복합 타입에 데이터를 입력하는 방법은 해당 타입의 데이터를 생성하여 입력합니다. 기본 함수를 이용하여 해당 타입의 데이터를 생성하여 원하는 테이블에 데이터를 입력할 수 있습니다. -- named_struct를 이용하여 struct 데이터를 생성하여 struct_tbl에 입력 FROM ( SELECT named_struct("age", 10, "name", "aa") AS col1 ) R INSERT INTO TABLE struct_tbl SELECT R.col1 -- 데이터 입력 후 결과 조회 hive> SELECT * FROM struct_tbl; OK {"age":10, "name":"aa"} {"age":1, "name":"A"} {"age":2, "name":"B"} UNION 테이블 생성 및 조회 -- 테이블 생성 CREATE TABLE union_tbl ( union_col UNIONTYPE<int, double, array<string>, struct<a:int, b:string>> ) ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t' COLLECTION ITEMS TERMINATED BY ',' MAP KEYS TERMINATED BY '=' -- 콤마 구분자로 첫 번째는 데이터 타입, 두 번째는 값 $ cat union.tsv 0,1 1,2.0 2, a, b, c 3,1, A -- 데이터 적용 LOAD DATA LOCAL INPATH './union.tsv' INTO TABLE union_tbl; -- 데이터 조회 SELECT union_col FROM union_tbl; {0:1} {1:2.0} {2:["a, b, c"]} UNION 데이터 생성 하이브에서 제공하는 기본 함수로 UNION 데이터를 생성할 때는 create_union함수를 이용합니다. -- 첫 번째 0이 데이터의 인덱스 hive> SELECT create_union(0, 60, "a"); {0:60} -- 첫 번째 1이 데이터의 인덱스 hive> SELECT create_union(1, 60, "a"); {1:"a"} 03-파티션 파티션은 데이터를 디렉터리로 분리하여 저장합니다. 하이브 같은 파일 기반 테이블은 기본적으로 테이블의 모든 roww 정보를 읽기 때문에 데이터가 많아지면 속도가 느려집니다. 파티션 칼럼은 where 조건에서 칼럼처럼 이용할 수 있기 때문에 처음에 읽어 들이는 데이터를 줄여서 처리 속도를 향상시켜 줍니다. 테이블의 파티션을 생성하는 기본 문법은 다음과 같습니다. CREATE TABLE tbl( col1 STRING ) PARTITIONED BY (yymmdd STRING); 파티션 종류 파티션의 종류는 동적 파티션(dynamic)과 고정 파티션(static)이 있습니다. 고정 파티션은 테이블에 데이터를 입력하는 시점에 파티션 정보를 전달하기 때문에 입력되는 파티션을 알 수 있습니다. 동적 파티션은 칼럼의 정보를 이용하여 동적으로 파티션이 생성되기 때문에 쿼리 시점에는 파티션을 알 수 없습니다. 데이터를 입력할 때 고정 파티션, 동적 파티션을 단독으로 이용할 수도 있고, 고정과 동적 파티션을 혼합하여 사용할 수도 있습니다. 고정 파티션 고정 파티션을 이용한 데이터 입력은 INSERT 문에 파티션 정보를 고정된 값으로 전달하여 입력합니다. 다음은 yymmdd 파티션에 '20180510' 값을 직접적으로 전달하여 파티션을 생성하는 예제입니다. INSERT INTO TABLE tbl(yymmdd='20180510') SELECT name FROM temp; 위와 같이 데이터를 입력하면 다음과 같은 폴더 구조로 데이터를 생성합니다. hdfs://[tbl 테이블 로케이션]/yymmdd=20180510/ 동적 파티션 동적 파티션을 이용한 데이터 입력은 INSERT 문에 파티션 정보를 조회하는 칼럼을 전달하여 입력합니다. 다음은 yymmdd 파티션에 yymmdd 칼럼을 전달하여 파티션을 동적으로 생성하는 예제입니다. INSERT INTO TABLE tbl(yymmdd) SELECT name, yymmdd FROM temp; 위와 같이 데이터를 입력할 때 temp 테이블의 yymmdd 칼럼에 20180510, 20180511 두 개의 데이터가 있으면 다음과 같이 생성합니다. hdfs://[tbl 테이블 로케이션]/yymmdd=20180510/ hdfs://[tbl 테이블 로케이션]/yymmdd=20180511/ 하이브는 기본적으로 동적 파티션만 이용하는 것은 권장하지 않습니다. 동적 파티션만 이용하기 위해서는 hive.exec.dynamic.partition.mode 설정을 nonstrict로 변경해야 합니다. -- 동적 파티션만을 이용하여 데이터를 입력을 사용하기 위한 설정, 기본값은 strict로 동적 set hive.exec.dynamic.partition.mode=nonstrict; 동적 파티션을 사용하면 속도가 느려지기 때문에 동적 파티션의 생성 개수에 제힌이 있습니다. 기본 설정보다 많은 파티션을 생성할 때는 다음의 설정을 해주어야 합니다. -- 동적 파티션 개수 set hive.exec.max.dynamic.partitions=1000; -- 노드별 동적 파티션 생성 개수 set hive.exec.max.dynamic.partitions.pernode=100; 동적 파티션에 NULL 값이 들어가는 경우 하이브는 NULL 값을 기본 파티션 명을 이용해서 입력합니다. -- NULL 값의 기본 파티션 명 set hive.exec.default.partition.name=__HIVE_DEFAULT_PARTITION__; -- 아래와 같은 형태로 파티션이 생성 hdfs://temp/yymmdd=20180510/hh=00/ hdfs://temp/yymmdd=20180510/hh=__HIVE_DEFAULT_PARTITION__/ -- 해당 파티션을 조회할 때는 다음과 같이 사용 SELECT * FROM temp WHERE hh = '__HIVE_DEFAULT_PARTITION__'; 파티션 수정/삭제 파티션의 수정, 삭제는 ALTER 문을 이용합니다. 파티션 삭제 시 매니지드 테이블인 경우 파티션 위치의 데이터도 함께 삭제되므로 주의해야 합니다. -- 신규 파티션 추가 ALTER TABLE employee ADD PARTITION (yymmdd='20180510'); -- LOCATION을 지정해서 추가 ALTER TABLE employee ADD PARTITION (yymmdd='20180510') LOCATION 'hdfs://127.0.0.1/user/yymmdd=20180510'; -- 파티션이 없을 때 추가 ALTER TABLE employee ADD IF NOT EXISTS PARTITION (yymmdd='20180510'); -- 멀티 파티션 추가 ALTER TABLE employee ADD PARTITION (yymmdd='20180510') PARTITION (yymmdd='20180511'); -- 파티션 수정 ALTER TABLE employee PARTITION (yyyymmdd='20220101') RENAME TO PARTITION (yyyymmdd='20220102'); -- 파티션의 LOCATION 수정 ALTER TABLE employee PARTITION (yymmdd='20180510') SET LOCATION 'hdfs://127.0.0.1/user/'; -- 파티션 삭제 ALTER TABLE employee DROP PARTITION (yymmdd='20180510'); -- 파티션 범위 삭제, 비교연산자를 이용해 범위 삭제 가능 ALTER TABLE employee DROP PARTITION (yymmdd < '20180510'); ALTER TABLE employee DROP PARTITION (yymmdd >= '20180510'); 파티션 복구 테이블 삭제, 추가로 인하여 신규 테이블을 생성하고, 기존 데이터나 신규 데이터로 테이블의 파티션을 복구해야 하는 경우 MSCK 명령을 이용합니다. 많은 파티션을 한 번에 복구하게 되면 작업시간이 늘어나서 연결 시간 초과 등으로 오류가 발생할 수도 있습니다. 이 경우 hive.msck.repair.batch.size를 양수 값으로 설정하여 한 번에 처리할 파티션 개수를 설정해서 명령어를 여러 번 돌리는 것이 좋습니다. 파티션에 허용되지 않는 문자나 파티션 규칙에 맞지 않을 때 오류가 발생하는데, hive.msck.path.validation 옵션을 ignore로 설정하여 오류를 무시하고 진행하게 하면 됩니다. -- 0으로 설정하면 모든 파티션을 복구한다. set hive.msck.repair.batch.size=0; -- 파티션에 허용되지 않는 문자가 있으면 오류가 발생하는데, ignore로 설정하면 무시하고 넘어간다. set hive.msck.path.validation=ignore; -- 파티션 복구 MSCK REPAIR TABLE employee; 04-버켓팅 버켓팅은 지정된 칼럼의 값을 해시 처리하고 지정한 수의 파일로 나누어 저장합니다. 조인에 사용되는 키로 버킷 칼럼을 생성하면, 소트 머지 버킷(SMB) 조인으로 처리되어 수행 속도가 빨라집니다. 파티션은 데이터를 디렉터리로 나누어 저장하는 방식이고, 버켓팅은 데이터를 파일별로 나누어 저장합니다. 버켓팅 테이블을 생성하는 기본 문법은 다음과 같습니다. -- col2를 기준으로 버켓팅 하여 20개의 파일에 저장 CREATE TABLE tbl1( col1 STRING, col2 STRING ) CLUSTERED BY (col2) INTO 20 BUCKETS -- col2를 기준으로 버켓팅 하고, col1 기준으로 정렬하여 20개의 파일에 저장 CREATE TABLE tbl2( col1 STRING, col2 STRING ) CLUSTERED BY (col2) SORTED BY (col1) INTO 20 BUCKETS 예제 다음은 버켓팅 테이블 bucketed_table을 생성하고, source_table의 데이터를 입력합니다. -- 테이블 생성 CREATE TABLE buckted_table ( col1 STRING, col2 STRING ) CLUSTERED BY (col2) SORTED BY (col2) INTO 20 BUCKETS LOCATION '/user/bucketed_table/' -- 데이터 입력을 위한 소스 테이블 CREATE TABLE source_table ( col1 ARRAY<STRING> ) ROW FORMAT DELIMITED COLLECTION ITEMS TERMINATED BY '\t'; -- 소스 테이블의 데이터 입력 LOAD DATA LOCAL INPATH './cctv_utf8.csv' INTO TABLE source_table; -- 버켓팅 테이블에 데이터 입력 INSERT INTO TABLE buckted_table SELECT col1[0], col1[3] FROM source_table; bucketed_table에 데이터를 입력 후 조회하면 다음과 같이 지정한 개수의 버킷(파일. 20개)으로 데이터를 나누어 저장한 것을 확인할 수 있습니다. $ hadoop fs -ls /user/bucketed_table/ Found 20 items -rwxr-xr-x 2 hadoop hadoop 55246 2018-11-08 05:22 /user/bucketed_table/000000_0 -rwxr-xr-x 2 hadoop hadoop 101 2018-11-08 05:22 /user/bucketed_table/000001_0 -rwxr-xr-x 2 hadoop hadoop 2227 2018-11-08 05:22 /user/bucketed_table/000002_0 -rwxr-xr-x 2 hadoop hadoop 3171874 2018-11-08 05:22 /user/bucketed_table/000003_0 -rwxr-xr-x 2 hadoop hadoop 65 2018-11-08 05:22 /user/bucketed_table/000004_0 -rwxr-xr-x 2 hadoop hadoop 102704 2018-11-08 05:22 /user/bucketed_table/000005_0 -rwxr-xr-x 2 hadoop hadoop 0 2018-11-08 05:22 /user/bucketed_table/000006_0 -rwxr-xr-x 2 hadoop hadoop 636043 2018-11-08 05:22 /user/bucketed_table/000007_0 -rwxr-xr-x 2 hadoop hadoop 92 2018-11-08 05:22 /user/bucketed_table/000008_0 -rwxr-xr-x 2 hadoop hadoop 42 2018-11-08 05:22 /user/bucketed_table/000009_0 -rwxr-xr-x 2 hadoop hadoop 379097 2018-11-08 05:22 /user/bucketed_table/000010_0 -rwxr-xr-x 2 hadoop hadoop 148419 2018-11-08 05:22 /user/bucketed_table/000011_0 -rwxr-xr-x 2 hadoop hadoop 49212 2018-11-08 05:22 /user/bucketed_table/000012_0 -rwxr-xr-x 2 hadoop hadoop 1866 2018-11-08 05:22 /user/bucketed_table/000013_0 -rwxr-xr-x 2 hadoop hadoop 2082 2018-11-08 05:22 /user/bucketed_table/000014_0 -rwxr-xr-x 2 hadoop hadoop 123 2018-11-08 05:22 /user/bucketed_table/000015_0 -rwxr-xr-x 2 hadoop hadoop 1268 2018-11-08 05:22 /user/bucketed_table/000016_0 -rwxr-xr-x 2 hadoop hadoop 834307 2018-11-08 05:22 /user/bucketed_table/000017_0 -rwxr-xr-x 2 hadoop hadoop 3631 2018-11-08 05:22 /user/bucketed_table/000018_0 -rwxr-xr-x 2 hadoop hadoop 62 2018-11-08 05:22 /user/bucketed_table/000019_0 05-스큐 스큐는 칼럼에 특정 데이터가 주로 들어오는 경우 분리하여 저장하는 기능입니다. 스큐는 파티션과 유사하지만 용도를 다르게 사용합니다. 파티션은 주로 데이터를 크게 구분하는 용도로 사용합니다. 보통 일자별로 구분할 때 많이 사용합니다. 스큐는 칼럼의 데이터를 구분할 때 사용합니다. 스큐는 하나의 칼럼에 특정 데이터가 몰려서 생성될 때 사용합니다. 예를 들어 num 칼럼에 1~1000까지의 데이터가 들어오는데, 주로 1, 2로 데이터가 많이 들어온다고 가정하면 파티션은 1000개의 파티션을 생성합니다. 하지만 스큐는 1, 2 와 나머지 3개의 디렉터리나 파일로 구별하여 저장됩니다. 이는 네임노드의 관리 포인트가 줄어드는 효과가 있습니다. 파티션과 스큐를 사용했을 때 생성되는 데이터 구조는 다음과 같습니다. # 파티션은 데이터를 크게 구분할 때 사용 /year=2018/month=07/day=01 /year=2018/month=07/day=02 # 스큐는 칼럼의 데이터를 구분할 때 사용 /year=2018/month=07/day=01/code=1 /year=2018/month=07/day=01/code=2 /year=2018/month=07/day=01/code=HIVE_DEFAULT_LIST_BUCKETING_DIR_NAME/ 스큐의 기본 문법은 다음과 같습니다. CREATE TABLE tbl ( col1 STRING, col2 STRING ) SKEWED BY (col1) on ('value1', 'value2' ) [STORED as DIRECTORIES]; 예제 다음은 col2 칼럼에 1로 들어오는 데이터 많을 때 스큐 테이블을 생성하는 예제입니다. -- 스큐 테이블 생성 -- col2에 들어오는 값중 1로 들어오는 값만 스큐로 저장 CREATE TABLE skewed_table ( col1 STRING, col2 STRING ) SKEWED BY (col2) ON ('1') STORED AS DIRECTORIES LOCATION '/user/skewed_table/'; -- 소스 테이블의 데이터를 스큐 테이블에 입력 INSERT INTO TABLE skewed_table SELECT col1[0], col1[4] FROM source_table; 스큐 테이블에 값을 입력하면 다음 같이 개별 디렉터리에 값을 보관하게 됩니다. STORED AS DIRECTORIES 옵션을 주지 않으면 디렉터리 구분 없이 파일로 따로 저장합니다. $ hadoop fs -ls /user/skewed_table/ Found 2 items drwxr-xr-x - hadoop hadoop 0 2018-11-08 06:17 /user/skewed_table/HIVE_DEFAULT_LIST_BUCKETING_DIR_NAME drwxr-xr-x - hadoop hadoop 0 2018-11-08 06:17 /user/skewed_table/col2=1 $ hadoop fs -ls -R /user/skewed_table/ drwxr-xr-x - hadoop hadoop 0 2018-11-08 06:17 /user/skewed_table/HIVE_DEFAULT_LIST_BUCKETING_DIR_NAME -rw-r--r-- 2 hadoop hadoop 1490659 2018-11-08 06:17 /user/skewed_table/HIVE_DEFAULT_LIST_BUCKETING_DIR_NAME/000000_0 drwxr-xr-x - hadoop hadoop 0 2018-11-08 06:17 /user/skewed_table/col2=1 -rw-r--r-- 2 hadoop hadoop 2335328 2018-11-08 06:17 /user/skewed_table/col2=1/000000_0 06-정렬 하이브의 정렬은 order by, sort by, distribute by, cluster by 네 가지 종류가 있습니다. ORDER BY 모든 데이터를 정렬하여 하나의 파일로 생성합니다. 데이터가 클 경우 시간이 오래 걸리고, Out Of Memory 오류가 발생할 수 있습니다. 데이터가 작을 때 사용하는 것이 좋고, 데이터가 클 경우 limit 옵션을 이용하여 처리 개수를 제한하는 것이 좋습니다. -- 테이블 풀 스캔 같은 성능에 영향을 미치는 쿼리는 nonstrict 모드에서만 동작 set hive.mapred.mode=nonstrict; SELECT * FROM tbl ORDER BY number; -- strict 모드 일 때는 LIMIT 가 있어야만 처리 가능 set hive.mapred.mode=strict; SELECT * FROM tbl ORDER BY number LIMIT 100; SORT BY 리듀서 별로 입력된 데이터를 정렬하여 출력합니다. 리듀서 개수만큼 생성되는 파일의 결과가 정렬되어 출력됩니다. [1, 4, 3, 2, 5]의 데이터를 2개의 리듀서로 처리할 때 리듀서1에 (1, 4, 3) 이 전달되고 리듀서2에 (5, 2)가 전달되면, 2개의 리듀서가 2개의 파일을 생성하고 각각의 결과 파일이 (1, 3, 4)와 (2, 5)로 정렬되어 출력됩니다. SELECT * FROM tbl SORT BY number; DISTRIBUTE BY 매퍼의 결과를 리듀서로 전달할 때 같은 값을 가지는 row는 같은 리듀서로 전달됩니다. 리듀서로 전달할 때 정렬하여 전달하지는 않습니다. [1, 4, 1, 3, 2]의 데이터를 2개의 리듀서로 처리할 때 리듀서1에 (1, 2, 1)이 전달되고 리듀서2에 (4, 3)이 전달됩니다. 같은 값은 같은 리듀서로 전달되지만, 전달할 데이터를 정렬하지는 않습니다. SELECT * FROM tbl DISTRIBUTE BY number; CLUSTER BY sort by 와 DISTRIBUTE by를 동시에 수행합니다. 같은 값을 가지는 row는 같은 리듀서에 전달되고, 리듀서 처리 결과를 정렬하여 출력합니다. [1, 4, 1, 3, 2]의 데이터를 2개의 리듀서로 처리할 때 리듀서1에 (1, 2, 1)이 전달되고 리듀서2에 (4, 3)이 전달하고 리듀서1 (1, 1, 2), 리듀서2 (3, 4) 형태로 절렬되어 출력합니다. SELECT * FROM tbl CLUSTER BY age; 참고 Hive Wiki(바로 가기) 07-서데(SerDe) 서데(SerDe, Serializer/Deserialaizer)는 하이브가 데이터를 해석하는 방법을 제공합니다. 하이브는 서데와 파일 포맷을 이용하여 데이터를 읽고, 쓸 수 있습니다. 하이브는 파일을 읽을 때 파일 포맷(FileFormat)을 이용하고, 디시 리얼 라이저(Deserializer)를 이용하여 원천 데이터를 테이블 포맷에 맞는 로우 데이터로 변환합니다. 파일을 쓸 때는 로우 데이터를 시리얼라이저(Serializer)를 이용하여 키, 밸류 형태로 변경하고 파일 포맷을 이용하여 저장 위치에 씁니다. 서데는 doDeserialize(), doSerialize()를 구현하여 각각의 경우를 처리하게 됩니다. HDFS files --> InputFileFormat --> [key, value] --> Deserializer --> Row object Row object --> Serializer --> [key, value] --> OutputFileFormat --> HDFS files 하이브 기본 서 데 하이브에서 제공하는 기본 서데는 7가지(Avro, ORC, RegEx, Thrift, Parquet, CSV, JsonSerDe)가 있습니다. 각 서데는 STORED AS에 지정하는 파일의 포맷에 따라 자동으로 선택됩니다. Avro, ORC, Parquet 은 서데와 인풋, 아웃풋 포맷이 설정됩니다. 나머지는 기본 LazySimpleSerDe와 파일에 따른 인풋, 아웃풋 포맷이 설정 1 됩니다. 테이블에 설정되는 서데는 desc formatted 명령으로 확인이 가능합니다. # ORC 테이블 생성 CREATE TABLE orc_tbl ( col STRING ) STORED AS ORC; # ORC 테이블 확인 hive>desc formatted orc_tbl; # ORC 테이블의 서데, 인풋 아웃풋 포맷 # Storage Information SerDe Library: org.apache.hadoop.hive.ql.io.orc.OrcSerde InputFormat: org.apache.hadoop.hive.ql.io.orc.OrcInputFormat OutputFormat: org.apache.hadoop.hive.ql.io.orc.OrcOutputFormat # TXT 테이블 생성 CREATE TABLE txt_tbl ( col STRING ); # TXT 테이블 확인 hive>desc formatted txt_tbl; # TXT 테이블의 서데, 인풋 아웃풋 포맷 # Storage Information SerDe Library: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe InputFormat: org.apache.hadoop.mapred.TextInputFormat OutputFormat: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat 커스텀 서 데 기본적으로 제공하는 서데외에 사용자가 서데를 구현할 수 있습니다 2. 원천 데이터를 조작하여 테이블의 포맷에 맞는 데이터 형태로 변경해야 할 때 사용할 수 있습니다. 대부분의 경우 데이터를 읽을 때 포맷을 변환하는 경우가 많기 때문에 doDeserialize()를 구현하는 경우가 많습니다. 예제 다음은 LazySimpleSerDe를 상속하여 커스텀 서데를 구현한 예제입니다. 아래의 샘플 데이터처럼 값에 느낌표(!)가 들어가 있습니다. 데이터 입력 시에 이를 제거하기 위한 커스텀 서데 입니다. $ cat sample.txt david 23! cole 3! 5 anna ! 92 LazySimpleSerDe를 상속하고 doDeserialize()를 구현하였습니다. import org.apache.hadoop.hive.serde2.SerDeException; import org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe; import org.apache.hadoop.io.Text; import org.apache.hadoop.io.Writable; public class SampleSerDe extends LazySimpleSerDe { public SampleSerDe() throws SerDeException { super(); } @Override public Object doDeserialize(Writable field) throws SerDeException { // 느낌표는 제거 String temp = field.toString().replaceAll("!", ""); return super.doDeserialize(new Text(temp)); } } 사용방법 커스텀 서데를 사용하기 위해서는 우선 구현한 클래스를 jar 파일로 묶어서 ADD JAR 명령을 이용해 추가하고 테이블 생성 시에 설정값을 추가해 줍니다. 이후 데이터를 조회하면 느낌표가 없는 데이터를 확인할 수 있습니다. # 클래스가 들어 있는 jar 파일 추가 hive> ADD JAR ./hiveUDF.jar; # 테이블 생성 시에 서 데 정보 및 프로퍼티 정보 전달 hive> CREATE TABLE serde_tbl ( col1 STRING , col2 STRING ) ROW FORMAT SERDE 'com.sec.hive.serde.SampleSerDe' WITH SERDEPROPERTIES ( "field.delim" = "\t" ) # 샘플 데이터를 입력 hive> LOAD DATA LOCAL INPATH './sample.txt' INTO TABLE serde_tbl; # 데이터 조회 hive> select * from serde_tbl; OK david 23 cole 35 anna 92 네이티브 서데의 설정(바로 가기) ↩ 하이브 커스텀 서 데 구현 매뉴얼(바로 가기) ↩ 08-가상 칼럼 하이브에는 입력된 원천 데이터의 위치를 확인하기 위한 가상 칼럼(Virtual Column)이 존재합니다. 칼럼 설명 INPUT__FILE__NAME 매퍼의 입력으로 들어온 파일의 이름 BLOCK__OFFSET_INSIDE_FILE 파일에서 현재 데이터의 위치 가상 칼럼은 다음처럼 SELECT 문, WHER 조건에 사용할 수 있습니다. select INPUT__FILE__NAME, key, BLOCK__OFFSET__INSIDE__FILE from src; select key, count(INPUT__FILE__NAME) from src group by key order by key; select * from src where BLOCK__OFFSET__INSIDE__FILE > 12000 order by key; 09-쿼리 분석 하이브에서는 explain 명령을 이용하여 쿼리 실행 계획을 확인할 수 있습니다. 실행계획의 전체 매뉴얼은 하이브 매뉴얼 1에서 확인할 수 있습니다. EXPLAIN [EXTENDED|AST|DEPENDENCY|AUTHORIZATION|LOCKS|VECTORIZATION|ANALYZE] query hive> EXPLAIN select * from tbl; hive> EXPLAIN EXTENDED select * from tbl; 실행계획은 쿼리를 실행하는 스테이지 정보, 스테이지에서 처리되는 작업의 정보가 다음과 같이 출력됩니다. CBO를 이용하면 테이블의 통계정보를 이용하여 최적화됩니다. { "STAGE DEPENDENCIES": { "Stage-1": { "ROOT STAGE": "TRUE" }, "Stage-8": { "DEPENDENT STAGES": "Stage-1", "CONDITIONAL CHILD TASKS": "Stage-5, Stage-4, Stage-6" }, "Stage-5": {}, "Stage-2": { "DEPENDENT STAGES": "Stage-5, Stage-4, Stage-7" }, "Stage-0": { "DEPENDENT STAGES": "Stage-2" }, "Stage-3": { "DEPENDENT STAGES": "Stage-0" }, "Stage-4": {}, "Stage-6": {}, "Stage-7": { "DEPENDENT STAGES": "Stage-6" } } , "STAGE PLANS": { "Stage-1": { "Tez": { ... 옵션 EXTENDED 추가 정보 확인 AST Abstract Syntax Tree 정보 확인 DEPENDENCY 테이블 간 의존 정보 확인 AUTHORIZATION 테이블 조회 권한 정보 확인 LOCKS 테이블의 락 정보 확인 VECTORIZATION 벡터화 처리 정보 확인 ANALYZE 실제 참조하는 row 정보 확인 https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Explain ↩ 10-통계 정보 하이브는 테이블의 로우 수, 파일 개수, 사이즈 등의 통계정보를 이용하여 빠른 데이터처리를 지원합니다. 통계정보는 CBO를 이용한 실행계획 최적화, 단순 카운트 쿼리 등에 사용되어 처리 속도를 높여 줍니다. 테이블의 통계정보를 설정하는 옵션은 다음과 같습니다. 하이브는 기본적으로 통계정보를 수집하도록 되어 있어서 따로 설정하지 않아도 테이블의 메타정보에 통계정보를 수집합니다. 하지만 사용하는 버전, 제조사에 따라 설정이 다를 수 있기 때문에 확인하고 사용하는 것이 좋습니다. set hive.stats.autogather=true; set hive.stats.column.autogather=true; 통계정보 수집 DML을 이용하여 처리할 때는 통계정보를 자동으로 수집하지만 파일 시스템 상의 정보가 변경되지 않습니다. 이럴 때는 anayze 명령으로 통계정보를 수집하도록 설정해야 합니다. analyze 커맨드는 테이블 단위, 파티션 단위로 실행이 가능합니다. 통계정보 수집은 맵리듀스 작업입니다. 다른 작업에 영향을 미치지 않도록 주의해서 실행하는 것이 좋습니다. ANALYZE TABLE [db_name.] tablename [PARTITION(partcol1[=val1], partcol2[=val2], ...)] -- (Note: Fully support qualified table name since Hive 1.2.0, see HIVE-10007.) COMPUTE STATISTICS [FOR COLUMNS] -- (Note: Hive 0.10.0 and later.) [CACHE METADATA] -- (Note: Hive 2.1.0 and later.) [NOSCAN]; # tbl 테이블 통계정보 수집 hive> ANALYZE TABLE tbl COMPUTE STATISTICS; # tbl 테이블의 yymmdd가 '2018-01-01'인 파티션의 통계정보 수집 hive> ANALYZE TABLE tbl PARTITION(yymmdd='2018-01-01') COMPUTE STATISTICS; # 칼럼 통계정보 수집 hive> ANALYZE TABLE tbl PARTITION(yymmdd='2018-01-01') COMPUTE STATISTICS FOR COLUMNS; 통계정보는 desc extended|formatted 커맨드로 확인할 수 있습니다. 다음처럼 테이블 정보, 파티션 정보에 통계정보가 추가되어 보입니다. hive> desc formatted tbl partition(yymmddval='20180101'); OK # col_name data_type comment col1 string Partition Parameters: COLUMN_STATS_ACCURATE {\"BASIC_STATS\":\"true\"} numFiles 6 numRows 618048 rawDataSize 2230248184 totalSize 8546118 transient_lastDdlTime 1544059910 통계정보 활용 이렇게 수집한 통계정보를 활용하기 위해서는 설정을 이용하여 count 함수를 이용할 때 이 쿼리를 이용하도록 설정해야 합니다. 아래와 같이 설정 후 count를 실행하면 MR 작업을 하지 않고 통계정보를 이용하여 데이터를 바로 확인하는 것을 알 수 있습니다. set hive.compute.query.using.stats=true; -- 통계정보를 이용한 작업 hive> select count(*) from table; 통계정보 활용 시 주의할 점 통계정보는 INSERT 명령을 이용할 때 계산되어 메타데이터에 보관됩니다. 따라서 파티션 위치에 파일을 직접 복사한 경우에는 메타데이터가 갱신되지 않아서 정확한 값이 나오지 않을 수도 있습니다. 따라서 파일만 따로 복사한 경우에는 ANALYZE 명령을 이용하여 정보를 갱신하게 하는 것이 좋습니다. 참고 하이브 StatsDev 매뉴얼(바로 가기) 하이브 Statistics 설정 매뉴얼(바로 가기) 11-파일 머지 하이브의 작업 중 매퍼 단독 작업의 경우 파일이 많이 생성될 수 있습니다. 작은 사이즈의 파일이 많이 생성되면 HDFS에 부담이 될 수 있기 때문에 이때는 파일을 묶어주는 것이 좋습니다. 이때 이용하는 것이 머지 설정입니다. 파일 머지를 이용할 때 주의할 점은 너무 작은 사이즈의 파일이 많을 때 사용하면 작업시간이 길어질 수 있습니다. 예를 들어 1KB 사이즈의 파일 3000개를 256MB 사이즈로 묶는 머지 작업을 추가하면 시간이 오래 걸릴 수 있습니다. 사용할 때 주의해서 사용해야 합니다. -- 맵퍼 단독 작업일 때 머지 set hive.merge.mapfiles=true; -- 맵리듀스 작업일 때 머지 set hive.merge.mapredfiles=true; -- 테즈 작업일 때 머지 set hive.merge.tezfiles=true; -- 머지 작업의 대상이 되는 파일 사이즈(32MB 이하) set hive.merge.smallfiles.avgsize=32000000; -- 머지 파일을 묶을 때 기준(256MB) set hive.merge.size.per.task=256000000; 12-파일 압축 하이브를 이용하여 INSERT DIRECTORY, CTAS 문으로 파일을 생성할 때 원하는 타입의 형태로 파일을 압축할 수 있습니다. 압축 가능한 코덱은 io.compression.codecs에 설정되어 있어야 합니다. <property> <name>io.compression.codecs</name> <value>org.apache.hadoop.io.compress.GzipCodec, org.apache.hadoop.io.compress.DefaultCodec, org.apache.hadoop.io.compress.BZip2Codec, org.apache.hadoop.io.compress.SnappyCodec, com.hadoop.compression.lzo.LzoCodec, com.hadoop.compression.lzo.LzopCodec </value> </property> 작업 결과를 압축하기 위해서 작업 전에 처리 결과를 압축하겠다는 설정과 압축 코덱을 지정해야 합니다. Gzip으로 압축하는 방법은 다음과 같습니다. # 압축 여부 설정 set hive.exec.compress.output=true; # 압축 코덱 설정 set mapred.output.compression.codec=org.apache.hadoop.io.compress.GzipCodec; 압축 사용 INSERT DIRECTORY와 CTAS 문을 이용해서 처리 결과를 압축하는 방법을 알아보겠습니다. set hive.exec.compress.output=true; set mapred.output.compression.codec=org.apache.hadoop.io.compress.GzipCodec; # table을 읽어서 /user/tables/에 CSV 형태로 압축하여 저장 INSERT OVERWRITE DIRECTORY 'hdfs:///user/tables/' ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' SELECT * FROM table WHERE name = 'csv' # table을 읽어서 csvsample 테이블러 저장 CREATE TABLE csvsample ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' LOCATION '/user/csv/' AS SELECT * FROM table WHERE name = 'csv' 파일을 압축하여 저장한 결과는 다음과 같이. gz 파일로 생성됩니다. 생성되는 파일의 개수는 매퍼 only 잡은 매퍼의 개수이고 리듀서 작업은 리듀서의 개수로 생성됩니다. 파일 개수 조정이 필요하면 매 퍼와 리듀서의 개수를 저 절하 면 됩니다. $ hadoop fs -ls /user/csv/ -rwxr-xr-x 2 hadoop hadoop 72361505 2019-04-03 08:05 /user/csv/000000_0.gz -rwxr-xr-x 2 hadoop hadoop 74060122 2019-04-03 08:05 /user/csv/000001_0.gz -rwxr-xr-x 2 hadoop hadoop 60733841 2019-04-03 08:05 /user/csv/000002_0.gz 13-조인 타입 hive에서 테이블 간의 조인을 처리하는 방법은 셔플 조인, 맵 조인, 정렬-병합-버킷 조인 3가지가 있습니다. 각 조인의 호칭이 여러 개 존재하기 때문에 아래와 같이 정리하였습니다. 조인 명칭 셔플 조인(Shuffle Join) 머지 조인(Merge Join) 맵 조인(Map Join) 브로드캐스트 조인(Broadcast Join), 맵 사이드 조인(Mapside Join) 정렬-병합-조인(SMB Join. Sort-Merge-Bucket Join) - 셔플 조인 셔플 조인은 셔플(Shuffle) 단계에서 조인을 처리합니다. 두 개의 테이블을 조인할 때 각 테이블을 맵(Map) 단계에서 읽고, 파티션 키를 조인 키로 설정하여 셔플 단계에서 조인 키를 기준으로 리듀서로 데이터가 이동되고 테이블을 조인합니다. 어떤 형태의 데이터 크기와 구성에도 사용 가능 가장 자원을 많이 사용하고 느린 조인 방식 맵 조인 맵 조인은 두 개의 테이블을 조인할 때 하나의 테이블이 메모리에 로드 되어 처리됩니다. 따라서 하나의 테이블이 메모리에 올라갈 수 있을 정도로 작을 때 맵 조인을 적용할 수 있습니다. hive.auto.convert.join이 true 일 때 적용되고 hive.auto.convert.join.noconditionaltask.size이 메모리에 올릴 테이블의 기본 사이즈로 10MB으로 설정되어 있습니다. 셔플 조인에 비하여 빠른 속도로 처리할 수 있음 테이블이 메모리에 올라갈 수 있는 크기여야 함 -- 맵 조인 적용을 위한 설정. 기본 10MB로 설정 set hive.auto.convert.join=true; set hive.auto.convert.join.noconditionaltask.size=10000000; SMB 조인 SMB 조인은 조인 테이블이 버켓팅 되어 있을 때 사용할 수 있습니다. 버켓팅된 키의 정보를 이용하여 빠르게 조인을 처리할 수 있습니다. 어떤 크기의 테이블에서도 가장 빠른 속도로 조인을 처리할 수 있습니다. 테이블이 버켓팅이 되어 있어야 함 -- SMB 조인을 위한 설정 set hive.auto.convert.sortmerge.join=true; set hive.optimize.bucketmapjoin=true; set hive.optimize.bucketmapjoin.sortedmerge=true; 1-맵 조인 vs 셔플 조인 맵 조인과 셔플 조인의 차이를 확인해 보겠습니다. 다음의 table_a는 14.7G이고, table_b는 5KB입니다. 이 테이블을 조인할 때 각 조인에 따른 성능을 확인해 보면 셔플 조인일 때는 리듀서 단계가 추가되고 맵 조인에 비하여 2배의 시간이 더 걸리는 것을 확인할 수 있습니다. # table_a와 table_b를 조인하여 join_test 테이블 생성 # table_a: 14.7 GB # table_b: 5 KB CREATE TABLE join_test AS select a.deviceid, b.cnty_cd from db_a.table_a a, db_b.table_b b where a.date = '20191020' and a.code = b.code_cd 작업 시간 맵 조인 작업 시간은 75.14초, 셔플 조인 작업 시간은 130.73초입니다. # 맵 조인(Map Join) ---------------------------------------------------------------------------------------------- VERTICES MODE STATUS TOTAL COMPLETED RUNNING PENDING FAILED KILLED ---------------------------------------------------------------------------------------------- Map 1 .......... container SUCCEEDED 31 31 0 0 0 0 Map 2 .......... container SUCCEEDED 1 1 0 0 0 0 ---------------------------------------------------------------------------------------------- VERTICES: 02/02 [==========================>>] 100% ELAPSED TIME: 75.14 s ---------------------------------------------------------------------------------------------- # 셔플 조인(Shuffle Join, Merge Join) ---------------------------------------------------------------------------------------------- VERTICES MODE STATUS TOTAL COMPLETED RUNNING PENDING FAILED KILLED ---------------------------------------------------------------------------------------------- Map 1 .......... container SUCCEEDED 33 33 0 0 0 0 Map 3 .......... container SUCCEEDED 1 1 0 0 0 0 Reducer 2 ...... container SUCCEEDED 1009 1009 0 0 0 0 ---------------------------------------------------------------------------------------------- VERTICES: 03/03 [==========================>>] 100% ELAPSED TIME: 130.73 s ---------------------------------------------------------------------------------------------- 실행 계획 확인 맵 조인 hive (sample_db)> explain CREATE TABLE join_test > AS > select a.deviceid, b.cnty_cd > from db_a.table_a a, > db_b.table_b b > where a.date = '20191020' > and a.code = b.code_cd > ; OK Plan optimized by CBO. Vertex dependency in root stage Map 1 <- Map 2 (BROADCAST_EDGE) Stage-3 Stats-Aggr Operator Stage-4 Create Table Operator: name:sample_db.join_test Stage-2 Dependency Collection{} Stage-1 Map 1 File Output Operator [FS_10] table:{"name:":"sample_db.join_test"} Select Operator [SEL_9] (rows=290865947 width=2073) Output:["_col0","_col1"] Map Join Operator [MAPJOIN_15] (rows=290865947 width=2073) Conds:SEL_2._col1=RS_7.UDFToString(_col0)(Inner),HybridGraceHashJoin:true, Output:["_col0","_col4"] <-Map 2 [BROADCAST_EDGE] BROADCAST [RS_7] PartitionCols:UDFToString(_col0) Select Operator [SEL_5] (rows=513 width=10) Output:["_col0","_col1"] Filter Operator [FIL_14] (rows=513 width=10) predicate:code_cd is not null TableScan [TS_3] (rows=513 width=10) db_b@table_b, b, Tbl:COMPLETE, Col:NONE, Output:["code_cd","cnty_cd"] <-Select Operator [SEL_2] (rows=264423583 width=2073) Output:["_col0","_col1"] Filter Operator [FIL_13] (rows=264423583 width=2073) predicate:code is not null TableScan [TS_0] (rows=264423583 width=2073) db_a@table_a, a, Tbl:COMPLETE, Col:NONE, Output:["deviceid","code"] Stage-0 Move Operator Please refer to the previous Stage-1 Time taken: 0.143 seconds, Fetched: 39 row(s) 셔플 조인 hive (sample_db)> explain CREATE TABLE join_test > AS > select a.deviceid, b.cnty_cd > from db_a.table_a a, > db_b.table_b b > where a.date = '20191020' > and a.code = b.code_cd > ; OK Plan optimized by CBO. Vertex dependency in root stage Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 3 (SIMPLE_EDGE) Stage-3 Stats-Aggr Operator Stage-4 Create Table Operator: name:sample_db.join_test Stage-2 Dependency Collection{} Stage-1 Reducer 2 File Output Operator [FS_10] table:{"name:":"sample_db.join_test"} Select Operator [SEL_9] (rows=290865947 width=2073) Output:["_col0","_col1"] Merge Join Operator [MERGEJOIN_15] (rows=290865947 width=2073) Conds:RS_6._col1=RS_7.UDFToString(_col0)(Inner),Output:["_col0","_col4"] <-Map 1 [SIMPLE_EDGE] SHUFFLE [RS_6] PartitionCols:_col1 Select Operator [SEL_2] (rows=264423583 width=2073) Output:["_col0","_col1"] Filter Operator [FIL_13] (rows=264423583 width=2073) predicate:code is not null TableScan [TS_0] (rows=264423583 width=2073) db_a@table_a, a, Tbl:COMPLETE, Col:NONE, Output:["deviceid","code"] <-Map 3 [SIMPLE_EDGE] SHUFFLE [RS_7] PartitionCols:UDFToString(_col0) Select Operator [SEL_5] (rows=513 width=10) Output:["_col0","_col1"] Filter Operator [FIL_14] (rows=513 width=10) predicate:code_cd is not null TableScan [TS_3] (rows=513 width=10) db_b@table_b, b, Tbl:COMPLETE, Col:NONE, Output:["code_cd","cnty_cd"] Stage-0 Move Operator Please refer to the previous Stage-1 Time taken: 0.146 seconds, Fetched: 42 row(s) 실행계획 비교 두 쿼리의 실행계획을 비교해 보면 셔플 조인은 리듀서 단계가 추가되는 것을 확실하게 알 수 있습니다. 리듀서 단계가 추가되는 셔플 조인보다는 맵 조인을 이용하는 것이 성능상 유리합니다. 2-맵 조인 기준 맵 조인은 작은 크기의 테이블을 메모리에 적재하여 조인을 처리합니다. 이때 테이블 데이터의 크기는 자바 객체의 사이즈입니다. 실제 파일의 사이즈와 다릅니다. 예를 들어 다음의 테이블은 동일한 데이터를 보관하고 있는 테이블입니다. 65,454개의 데이터를 저장<NAME>만 다르게 하여 저장한 것입니다. 맵 조인에는 객체 사이즈를 이용하기 때문에 hive.auto.convert.join.noconditionaltask.size를 설정할 때 객체 사이즈 기준으로 설정해야 합니다. 기본 설정이 10MB 일 때 table_orc는 셔플 조인으로 처리되고, table_txt는 맵 조인으로 처리됩니다. table_orc를 맵 조인으로 처리하기 위해서는 hive.auto.convert.join.noconditionaltask.size=20000000으로 설정해야 합니다. ORC<NAME>은 데이터를 저장할 때 압축하여 저장하기 때문에 물리적인 파일의 크기가 원본에 비하여 줄어든 것을 확인할 수 있습니다. 객체 사이즈는 데이터의 타입과 자바 객체의 오버헤드 통계 정보 등을 추가한 사이즈입니다. 따라서 원본 사이즈보다 증가할 수 있습니다. 테이블<NAME> 파일 사이즈(totalSize) 객체 사이즈(rawDataSize) table_orc ORC 254,632(248 KB) 18,850,752(17.9 MB) table_txt TXT 2,639,622(2.5 MB) 2,574,168 (2.4 MB) table 정보 비교 table_txt hive (hseok1_seo)> desc formatted table_txt; OK # col_name data_type comment column_1 string column_2 string column_3 string # Detailed Table Information Table Parameters: numFiles 1 numRows 65454 rawDataSize 2574168 totalSize 2639622 # Storage Information SerDe Library: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe InputFormat: org.apache.hadoop.mapred.TextInputFormat OutputFormat: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat table_orc hive (hseok1_seo)> desc formatted table_orc; OK # col_name data_type comment column_1 string column_2 string column_3 string # Detailed Table Information Table Parameters: numFiles 1 numRows 65454 rawDataSize 18850752 totalSize 254632 # Storage Information SerDe Library: org.apache.hadoop.hive.ql.io.orc.OrcSerde InputFormat: org.apache.hadoop.hive.ql.io.orc.OrcInputFormat OutputFormat: org.apache.hadoop.hive.ql.io.orc.OrcOutputFormat 4-함수 하이브의 함수는 UDF1, UDAF2, UDTF3로 구분할 수 있습니다. 각 타입의 기본 함수는 하이브 매뉴얼을 확인하시기 바랍니다. 하이브에서 기본적으로 제공하는 함수 외에도 사용자가 생성한 함수를 등록하여 사용할 수도 있습니다. UDF UDAF UDTF UDTF 함수의 종류 UDTF 함수 예제 LATERAL VIEW json_tuple 예제 사용자 정의 함수 UDF UDF는 1개의 열(row)을 처리하여, 1개의 열을 반환하는 함수입니다. substr(), round() 등의 함수가 있습니다. -- 문자열의 두 번째 index부터 3개의 자를 반환 hive> select substr('ABCDEFG', 2, 3); OK BCD hive> select substr(col1, 2, 3) from tbl1; OK BCD UDAF UDAF는 N 개의 열을 이용하여, 1개의 열을 반환합니다. RDB의 윈도 함수라고 할 수 있습니다. count(), sum(), max() 등의 함수가 있습니다. SELECT count(1) FROM tbl1 GROUP BY col1 UDTF UDTF는 1개의 열을 입력받아서 N 개의 열을 반환합니다. 리스트, 맵 형태의 데이터를 테이블로 보여줄 때 사용할 수 있습니다. 단독으로 사용할 수도 있고, LATERAL VIEW와 함께 사용하면 원 테이블의 데이터와 조인한 형태로 값을 보여줄 수 있습니다. hive> select explode(array(1, 2, 3)); OK 2 UDTF 함수의 종류 explode, inline, posexplode array, map, struct<NAME>의 데이터를 테이블 형태로 반환 json_tuple json 문자열을 파싱 하여 반환 get_json_object() 와 비슷한데 속도가 빠름 xpath를 이용한 처리는 안됨 url_tuple url 문자를 파싱 HOST, PATH, QUERY, REF, PROTOCOL, AUTHORITY, FILE를 반환 stack 전달한 데이터를 여러 개의 행으로 반환 UDTF 함수 예제 UDTF 함수의 사용법은 다음과 같습니다. -- EMPLOYEE 테이블의 내용 확인 hive> desc employee; OK id string name string lists array<string> maps map<string, string> salary int hive> select * from employee; OK id-1 john ["a","b","c","d"] {"k1":"v1","k2":"v2"} 100 id-2 sam ["e","f","g","h"] {"k3":"v3","k4":"v4"} 300 id-3 tim ["i","j","k","l"] {"k5":"v5","k6":"v6"} 1000 id-4 paul ["z","c","v","b"] {"k7":"v7","k8":"v8"} 800 id-5 kill ["q","w","e","r"] {"k9":"v9","k0":"v0"} 600 -- 리스트를 explode() 함수를 이용하여 테이블 형태로 반환 hive> select explode(lists) as col1 > from employee; OK b d f h j l c b w r Time taken: 0.054 seconds, Fetched: 20 row(s) -- 맵을 explode() 함수를 이용하여 key, value 테이블 형태로 반환 hive> select explode(maps) as (key, value) > from employee; OK k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k0 v0 Time taken: 0.052 seconds, Fetched: 10 row(s) -- 리스트를 posexplode() 함수를 이용하여, 포지션 칼럼 형태로 반환 hive> select posexplode(lists) as (pos, col1) > from employee; OK 0 a 1 b 2 c 3 d 0 e 1 f 2 g 3 h 0 i 1 j 2 k 3 l 0 z 1 c 2 v 3 b 0 q 1 w 2 e 3 r Time taken: 0.059 seconds, Fetched: 20 row(s) -- inline, array, struct를 이용한 JSON 문자열의 테이블화 예제 hive> SELECT inline(array( struct(get_json_object(str, "$.key1")) > , struct(get_json_object(str, "$.key2")) )) > FROM ( SELECT '{ "key1": "a", "value1" : "1", "key2": "b", "value2" : "2" }' AS str) t > ; OK b Time taken: 0.031 seconds, Fetched: 2 row(s) LATERAL VIEW LATERAL VIEW는 UDTF 함수의 결과를 기존 테이블의 칼럼에 추가하여, 조인된 테이블처럼 보이게 됩니다. -- listTable 결과 확인 hive> select col_list from listTable; OK ["1","2","3"] ["4","5","6"] ["7","8","9"] -- LATERAL VIEW를 이용해 기존 테이블의 결과와 함께 출력 hive> SELECT col_list, item > FROM listTable LATERAL VIEW explode(col_list) t as item > ; OK ["1","2","3"] 1 ["1","2","3"] 2 ["1","2","3"] 3 ["4","5","6"] 4 ["4","5","6"] 5 ["4","5","6"] 6 ["7","8","9"] 7 ["7","8","9"] 8 ["7","8","9"] 9 Time taken: 0.142 seconds, Fetched: 9 row(s) -- explode() 함수의 결과 hive> SELECT explode(col_list) > FROM listTable; OK 2 4 6 8 Time taken: 0.05 seconds, Fetched: 9 row(s) json_tuple 예제 json_tuple은 LATERAL VIEW 와 함께 사용하여 json 데이터 테이블로 이용할 수 있습니다. SELECT j.service_id, j.component_id FROM json_table t LATERAL VIEW JSON_TUPLE(t.json_body, 'service_id', 'component_id') j AS service_id, component_id; 사용자 정의 함수 사용자 정의 함수는 기본 함수 외에 사용자가 함수를 생성할 수 있습니다. JAVA 함수를 생성하고, jar 파일로 묶어서 ADD JAR 명령으로 jar 파일을 추가하여 사용합니다. CREATE FUNCTION 명령으로 함수를 생성하여 SELECT 문에서 사용하면 됩니다. 상세한 개발 방법은 하이브 매뉴얼 4를 참고하시기 바랍니다. -- JAR 추가 및 함수 생성 ADD JAR hdfs:///user/hive/SampleUDF.jar; CREATE TEMPORARY FUNCTION time_stamp AS 'sdk.hive.TimeStampUDF'; -- 기존 함수와 같은 형태로 사용 SELECT time_stamp(col1) FROM sample; UDF 함수 매뉴얼(Built-in Funcs) (바로 가기) ↩ UDAF 함수 매뉴얼(Built-in Aggregate Functions) (바로 가기 ↩ UDTF 함수 매뉴얼(Built-in Table-Generating Functions) (바로 가기 ↩ 사용자 함수 개발 방법(바로 가기) ↩ 1-내장 함수(Built-In Function) 하이브에서 제공하는 여러 가지 내장 함수 중에서 유용한 함수 몇 가지에 대해서 알아보겠습니다. 함수의 전체 목록은 하이브 매뉴얼 1을 확인하면 됩니다. 목록, 확인 명령어 관계형 명령어 논리형 명령어 복합형 생성 명령어 기본 명령어 캐스팅 명령 컬렉션 명령 날짜 명령 조건 함수 문자열 함수 UDAF 목록, 확인 명령어 하이브에 등록된 함수, 테이블, 데이터베이스를 확인하는 명령어는 show와 desc 또는 describe가 있습니다. 함수 설명 show 함수, 테이블, 데이터베이스의 목록을 확인 desc 함수, 테이블, 데이터베이스의 설정값을 확인, extended, formatted 와 함께 사용하여 상세 설정을 확인 -- 목록 확인 show databases; show tables; show functions; -- 설명 확인 desc table tbl; desc extends tbl; desc formatted tbl; -- describe는 desc와 동일합니다. describe table tbl; 관계형 명령어 WHERE 조건에서 사용하는 관계형 명령어 중 between A and B는 일자별 파티션으로 구분된 테이블의 조회에서 유용하게 사용할 수 있습니다. 일자 파티션이 문자형(String)으로 선언되어 있어도 자동으로 캐스팅하여 비교해 줍니다. 함수 설명 A between B and C A의 값이 B 이상, C 이하이면 TRUE 반환 SELECT * FROM tbl WHERE yymmdd between '20180101' and '20180107'; 논리형 명령어 논리형 명령어 중에서 어떤 데이터가 존재하는지를 검증하는 IN은 서브 쿼리를 이용하여 데이터의 존재를 효율적으로 확인할 수 있습니다. -- col 칼럼의 값이 서브 쿼리의 데이터 안에 있으면 처리 SELECT * FROM tbl WHERE col IN (SELECT col FROM sub_tbl) -- col 칼럼의 값이 a, b, c 가 아니라면 처리 SELECT * FROM tbl WHERE col NOT IN ( 'a', 'b', 'c' ) 복합형 생성 명령어 하이브에서 제공하는 복합 타입(Map, Array, Struc)을 쿼리에서 직접 생성할 수도 있습니다. 함수 설명 map(key1, val1, ) 주어진 키와 값으로 맵을 생성 array(val1, val2) 주어진 값으로 배열을 생성 struct(val1, val2) 주어진 값으로 구조체를 생성 named_struct(col1, val1, col2, val2, ...) 주어진 값으로 이름있는 구조체를 생성 create_union(index, val1, val2) 주어진 값으로 Union 생성 -- 맵 생성 hive> select map('key1', 'value1', 'key2', 'value2'); OK {"key1":"value1","key2":"value2"} -- 배열 생성 hive> select array(1, 2, 3); OK [1,2,3] -- 구조체 생성 hive> select struct(1, "a"); OK {"col1":1, "col2":"a"} -- 이름 있는 구조체 생성 hive> SELECT named_struct("age", 10, "name", "aa") AS col1 OK {"age":10, "name":"aa"} -- 첫 번째 0이 데이터의 인덱스 hive> SELECT create_union(0, 60, "a"); {0:60} -- 첫 번째 1이 데이터의 인덱스 hive> SELECT create_union(1, 60, "a"); {1:"a"} 기본 명령어 하이브의 기본 명령어 중에서 유용한 명령어의 사용법은 다음과 같습니다. 전체 명령어는 하이브 매뉴얼을 참고하면 됩니다. 캐스팅 명령 주어진 값의 형을 변경해야 할 필요가 있을 때 cast를 이용합니다. 함수 설명 cast( expr as <type>) 주어진 값의 형을 변경 -- 문자열을 int형으로 변경 hive> select cast( "1" as int); OK 컬렉션 명령 컬렉션을 처리하는 명령어는 다음과 같습니다. 함수 설명 size(Map or Array) 맵과 배열의 값의 수를 반환 array_contains(Array, value) 배열에 값이 있는지 확인 sort_array(Array) 배열을 정렬 -- 사이즈 확인 hive> select size(map('key1', 'value1', 'key2', 'value2')); OK -- 값이 존재하는지 확인 hive> select array_contains(array(1, 2, 3), 2); OK true -- 배열을 정렬 hive> select sort_array(array(3, 1, 2)); OK [1,2,3] 날짜 명령 날짜 관련 함수는 날짜의 출력 포맷을 변경할 때 주로 사용합니다. 다음의 명령어를 이용하여 일자를 변경할 수 있습니다. 함수 설명 unix_timestamp(string date[, string format]) 주어진 값을 unixtime으로 변환 from_unixtime(bigint unixtime[, string format]) unixtime을 일자로 변환 -- 문자열 일자를 unix 타임으로 변환 hive> select unix_timestamp("2018-01-01 00:00:00", 'yyyy-MM-dd HH:mm:ss'); OK 1514764800 -- unix 타임을 지정한 타입의 문자열로 변환 hive> select from_unixtime(1514764800, 'yyyy-MM-dd HH:mm:ss'); OK 2018-01-01 00:00:00 조건 함수 조건 함수는 조건에 따라 값의 출력을 변경할 때 사용할 수 있습니다. 함수 설명 if(조건, 참, 거짓) 조건을 이용하여 맞는 값을 반환 isnull( a) null 값인지 체크 nvl(T value, T default_value) null이면 기본값 반환 COALESCE(T v1, T v2, ...) null 이 아닐 경우 순서대로 값을 반환 -- 조건문이 True 이면 참의 값, False 이면 거짓의 값 hive> select if(1=1, 'a','b'); OK -- 조건이 null이면 true 반환 hive> select isnull(null); OK true -- 입력값이 null이면 기본값 반환 hive> select nvl(null, 'a'); OK -- 입력값이 null이 아니면 입력값 반환 hive> select nvl('b', 'a'); OK -- 순서대로 null 이 아닌 최초의 값을 반환 hive> select coalesce(null,'a','b'); OK hive> select coalesce(1, 'a','b'); OK hive> select coalesce(null, null,'b'); OK 문자열 함수 문자열을 조작하는 함수는 종류가 다양합니다. 그중에서 자주 사용되는 함수는 다음과 같습니다. 다음은 문자열을 병합하는 함수입니다. 함수 설명 concat(string binary A, string concat_ws(string SEP, string A, string B...) SEP를 이용하여 문자열 병합 concat_ws(string SEP, array<string>) SEP를 이용하여 문자열 병합 -- 문자열 병합 hive> select concat('A','B'); OK AB -- SEP를 기준으로 문자열을 병합 hive> select concat_ws(',','a','b'); OK a, b -- SEP를 기준으로 배열의 문자열을 병합 hive> select concat_ws(',',array('a','b','c')); OK a, b, c 다음은 문자열을 조작하는 함수입니다. 함수 설명 substr(string A, int start) 문자열을 자름 substring(string A, int start) 문자열을 자름 trim(string A) 문자열 앞, 뒤의 공백을 제거 replace(string A, string old, string new) A 안의 old 문자열을 new로 변경 -- start 지점부터 끝까지 문자를 반환 hive> select substr('123456789',3); OK 3456789 -- start 지점부터 지정한 개수의 문자를 반환 hive> select substr('123456789',3,2); OK 34 -- 문자열 양쪽의 공백을 제거 hive> select trim(' 123 '); OK 123 -- 문자열에 존재하는 old 문자를 new 문자로 변환 hive> select replace('123123123','2','a'); OK 1a31a31a3 다음은 문자열을 맵, 배열로 변환하는 함수입니다. 함수 설명 str_to_map(text[, delimiter1, delimiter2]) String을 구분자를 이용하여 키, 값으로 구분하여 맵으로 변환 split(string str, string pat) 문자열을 구분하여 배열로 반환 -- 문자열을 맵으로 변환 hive> select str_to_map('a:1, b:2, c:3', ',' ,':'); OK {"a":"1","b":"2","c":"3"} -- 문자열을 배열로 변환 hive> select split('a, b, c',','); OK ["a","b","c"] UDAF 함수 설명 collect_set(col) 중복 제거된 배열을 반환 collect_list(col) 칼럼 값의 배열을 반환 hive> select col1, col2 from tbl; 1 a 1 a 2 a 2 b hive> select col1, collect_list(col2) from tbl group by col1; 1 ['a', 'a'] 2 ['a', 'b'] hive> select col1, collect_set(col2) from tbl group by col1; 1 ['a'] 2 ['a', 'b'] 하이브 내장 함수 매뉴얼 (바로 가기) ↩ 2-사용자 정의 함수 사용자 정의 함수는 하이브에서 제공하는 기본 함수 구현을 상속하여 Java로 구현합니다. UDF, UDAF, UDTF를 각각 구현할 수 있습니다. 파이썬 스크립트를 이용하여 UDTF 함수를 구현할 수도 있습니다. 1-UDF 구현 UDF를 구현하는 방법은 두 가지가 있습니다. UDF(org.apache.hadoop.hive.ql.exec.UDF) 상속 evaluate() 함수 구현 GenericUDF(org.apache.hadoop.hive.ql.udf.generic.GenericUDF) 상속 initialize(), evaluate(), getDisplayString() 함수를 구현 UDF를 상속하면 실제 데이터가 처리되는 부분만 구현하면 됩니다. 간단한 함수를 구현할 때 사용하면 좋습니다. GenericUDF는 복합 타입의 데이터를 입력받아서 처리할 때 사용합니다. GenericUDF를 상속하면 데이터의 검증 부분과 실제 처리 부분을 구현해야 합니다. UDF보다는 복잡하지만 상세한 구현을 할 수 있고, 입력 데이터의 검증을 처리할 수 있습니다. UDF 구현 아래의 UDF는 evalute() 함수를 메서드 오버 로딩을 이용하여 구현하였습니다. 문자형은 대문자로 반환하고, int형 숫자가 들어오면 숫자에 1을 더하여 반환합니다. 맵 형은 키가 있는지 검사해서 키가 있으면 값을 반환하고, 없으면 None 문자를 반환합니다. import java.util.Map; import org.apache.hadoop.hive.ql.exec.UDF; import org.apache.hadoop.io.Text; public class SampleUDF extends UDF { public Text evaluate(Text text) { // 입력받은 문자를 대문자로 반환 return new Text(text.toString().toUpperCase()); } public int evaluate(int number) { // 입력받은 숫자에 1을 더하여 반환 return number + 1; } public String evaluate(Map<String, String> map, String key) { // 입력받은 키의 밸류가 있으면 반환하고, 없으면 None를 반환 return map.containsKey(key) ? map.get(key) : "None"; } } 사용방법 -- UDF가 포함된 jar 추가 ADD JAR hdfs:///user/hiveUDF.jar; CREATE FUNCTION func AS 'com.sec.hive.udf.GeneralUDF'; // int형은 +1 hive> select func(1); OK Time taken: 0.816 seconds, Fetched: 1 row(s) -- 문자형은 대문자 반환 hive> select func('small'); OK SMALL Time taken: 0.032 seconds, Fetched: 1 row(s) -- 일치하는 값이 없으면 오류 hive> select func(array(1, 2, 3)); FAILED: SemanticException [Error 10014]: Line 1:7 Wrong arguments '3': No matching method for class com.sec.hive.udf.GeneralUDF with (array<int>). Possible choices: _FUNC_(int) _FUNC_(map<string, string>, string) _FUNC_(string) GenericUDF를 구현 다음 UDF는 문자열이 들어 있는 리스트를 입력받아서 문자 길이의 총합을 세는 UDF입니다. initialize(), evalute(), getDisplayString() 함수를 구현하였습니다. import java.util.List; import org.apache.hadoop.hive.ql.exec.Description; import org.apache.hadoop.hive.ql.exec.UDFArgumentException; import org.apache.hadoop.hive.ql.exec.UDFArgumentLengthException; import org.apache.hadoop.hive.ql.metadata.HiveException; import org.apache.hadoop.hive.ql.udf.generic.GenericUDF; import org.apache.hadoop.hive.serde2.lazy.LazyString; import org.apache.hadoop.hive.serde2.objectinspector.ListObjectInspector; import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory; import org.apache.hadoop.hive.serde2.objectinspector.primitive.StringObjectInspector; import org.apache.hadoop.io.IntWritable; @Description(name = "sumListStringLength", value = "_FUNC_(value) - Returns value that sum list string length.", extended = "Example:\n > SELECT _FUNC_(Array<String>) FROM table LIMIT 1;") public class ListGenericUDF extends GenericUDF { ListObjectInspector listOi; @Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { // initialize 함수에서는 // 입력받은 파라미터에 대한 검증 // 반환하는 파라미터에 대한 검증 // 함수에 입력받는 파라미터 개수 확인 if (arguments.length != 1) throw new UDFArgumentLengthException("function argument need 1."); // 파라미터의 타입 확인 ObjectInspector inspector = arguments[0]; if (!(inspector instanceof ListObjectInspector)) throw new UDFArgumentException("function argument need List"); listOi = (ListObjectInspector) inspector; // 입력받는 리스트 내 엘리먼트의 객체 타입 확인 if (!(listOi.getListElementObjectInspector() instanceof StringObjectInspector)) throw new UDFArgumentException("array argument need "); // 반환은 문자열의 수이므로 int 객체 반환 return PrimitiveObjectInspectorFactory.writableIntObjectInspector; } @SuppressWarnings("unchecked") @Override public Object evaluate(DeferredObject[] arguments) throws HiveException { // arguments의 객체를 형 변환 List<LazyString> list = (List<LazyString>) listOi.getList(arguments[0].get()); if (list == null) return null; int sum = 0; for (LazyString str : list) { sum += str.getWritableObject().getLength(); } return new IntWritable(sum); } @Override public String getDisplayString(String[] children) { StringBuffer buffer = new StringBuffer(); buffer.append("sumListStringLength(Array<String>), "); for (String child : children) buffer.append(child).append(","); return buffer.toString(); } } 사용방법 ADD JAR hdfs:///user/hiveUDF.jar; CREATE FUNCTION listFunc AS 'com.sec.hive.udf.ListGenericUDF'; hive> select * from listTable; OK ["1","2","3"] ["4","5","6"] ["7","8","9"] ["abcdefg","alskdjfalskd","alksdfjalskdfj"] ["aslkdfjalskdf","asldkjfalskd","asldkfja"] ["asldkfjalskd","asdlkfjalskdjflaksd","asldkjfalsdkjflkasd","alsdkjfalkdjf"] -- col_list를 입력받아서 문자열의 길이를 더하여 반환 hive> select listFunc(col_list) > from listTable; OK 3 33 33 63 Time taken: 0.307 seconds, Fetched: 6 row(s) 2-UDAF 구현 UDAF는 AbstractGenericUDAFResolver를 상속하여 구현합니다. Resolver를 상속하여 파라미터 타입 체크를 처리하고 데이터 처리를 구현한 Evaluator 클래스를 반환합니다. Resolver 클래스: 파라미터 타입 체크 오퍼레이터 구현 실제 처리 프로세스 구현체(GenericUDAFEvaluator)를 반환 Evaluator 클래스: init(), merge(), terminatePartial() 등의 실제 처리 구현 getNewAggregationBuffer() - 집계에 사용할 AggregationBuffer 반환 reset - aggregation 이 재사용될 때의 처리 init - 입력받는 아규먼트와 반환값의 타입을 지정 iterate - 매 퍼가 동작하는 동안 반복하는 작업 terminatePartial - 부분적으로 집계 작업을 종류 할 때 작업 merge - 집계 작업의 결과를 머지 할 때 terminate - 작업이 종료될 때 실제 데이터의 처리는 다음과 같습니다. init() 함수로 초기화 후 iterate() 함수로 데이터를 처리합니다. 매퍼의 마지막에 terminatePartial() 함수로 중간 결과를 반환하고, 리듀서에서 다시 merge()를 통해 각 매퍼의 결과를 머지 합니다. 그리고 tereminate()를 통해 결과를 반환합니다. 구현 아래는 Sum 함수를 구현한 예제입니다. import org.apache.hadoop.hive.ql.exec.UDFArgumentTypeException; import org.apache.hadoop.hive.ql.metadata.HiveException; import org.apache.hadoop.hive.ql.parse.SemanticException; import org.apache.hadoop.hive.ql.udf.generic.AbstractGenericUDAFResolver; import org.apache.hadoop.hive.ql.udf.generic.GenericUDAFEvaluator; import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector; import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector.PrimitiveCategory; import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory; import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorUtils; import org.apache.hadoop.hive.serde2.typeinfo.PrimitiveTypeInfo; import org.apache.hadoop.hive.serde2.typeinfo.TypeInfo; /** * String, int를 입력받아서 합계를 반환 * * @author User * */ public class SumInt extends AbstractGenericUDAFResolver { @Override public GenericUDAFEvaluator getEvaluator(TypeInfo[] info) throws SemanticException { // 파라미터는 하나만 받음 if (info.length != 1) { throw new UDFArgumentTypeException(info.length - 1, "Exactly one argument is expected."); } // 파라미터의 카테고리가 프리미티브 타입이 아니면 예외 처리 if (info[0].getCategory() != ObjectInspector.Category.PRIMITIVE) { throw new UDFArgumentTypeException(0, "Only primitive type arguments are accepted but " + info[0].getTypeName() + " was passed as parameter 1."); } // 전달된 파라미터의 타입이 스트링이면 SumStringEvaluator, 아니면 SumIntEvaluator 처리 PrimitiveCategory category = ((PrimitiveTypeInfo) info[0]).getPrimitiveCategory(); if (category == PrimitiveCategory.STRING || category == PrimitiveCategory.INT) { return new SumEvalutor(); } else { throw new UDFArgumentTypeException(0, "Only string, int type arguments are accepted but " + info[0].getTypeName() + " was passed as parameter 1."); } } @SuppressWarnings("deprecation") public static class SumEvalutor extends GenericUDAFEvaluator { protected PrimitiveObjectInspector inputOI; @Override public ObjectInspector init(Mode m, ObjectInspector[] parameters) throws HiveException { super.init(m, parameters); inputOI = (PrimitiveObjectInspector) parameters[0]; return PrimitiveObjectInspectorFactory.javaIntObjectInspector; } static class SumAggregationBuffer implements AggregationBuffer { int sum; } @Override public AggregationBuffer getNewAggregationBuffer() throws HiveException { SumAggregationBuffer sum = new SumAggregationBuffer(); sum.sum = 0; return sum; } @Override public void reset(AggregationBuffer agg) throws HiveException { ((SumAggregationBuffer) agg).sum = 0; } @Override public void iterate(AggregationBuffer agg, Object[] parameters) throws HiveException { ((SumAggregationBuffer) agg).sum += getInt(parameters[0]); } @Override public Object terminatePartial(AggregationBuffer agg) throws HiveException { return ((SumAggregationBuffer) agg).sum; } @Override public void merge(AggregationBuffer agg, Object partial) throws HiveException { ((SumAggregationBuffer) agg).sum += getInt(partial); } @Override public Object terminate(AggregationBuffer agg) throws HiveException { return ((SumAggregationBuffer) agg).sum; } public int getInt(Object strObject) { return PrimitiveObjectInspectorUtils.getInt(strObject, inputOI); } } } 사용방법 -- UDF가 포함된 jar 추가 ADD JAR hdfs:///user/hiveUDF.jar; CREATE FUNCTION sumInt AS 'com.sec.hive.udf.SumInt'; -- 데이터 확인 hive> select * from intTable; OK 2 4 6 8 10 -- 처리 결과 확인 select sumInt(col) from intTable; Query ID = hadoop_20181113081733_822f2f53-139c-419b-bb67-fb9e572994a4 Total jobs = 1 Launching Job 1 out of 1 OK 55 Time taken: 14.06 seconds, Fetched: 1 row(s) 참고 hive RANK 함수 구현 3-UDTF 구현 UDTF는 GenericUDTF를 상속하여 구현합니다. initialize() 입력 파라미터의 검증과 칼럼 이름을 반환 process() 실제 데이터 처리를 반환 forward() 함수에 데이터를 넘김 close() 자원의 반환을 처리 구현 다음은 딜리 미터를 입력받아 문자열을 분할하고 테이블 데이터를 반환하는 UDTF 예제입니다. import java.util.ArrayList; import org.apache.hadoop.hive.ql.exec.Description; import org.apache.hadoop.hive.ql.exec.UDFArgumentException; import org.apache.hadoop.hive.ql.metadata.HiveException; import org.apache.hadoop.hive.ql.udf.generic.GenericUDTF; import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorFactory; import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector; import org.apache.hadoop.hive.serde2.objectinspector.StructObjectInspector; import org.apache.hadoop.io.Text; @Description(name = "string_parse", value = "_FUNC_(delimiter, string) - ") public class StringParseUDTF extends GenericUDTF { private transient final Object[] forwardListObj = new Object[1]; protected PrimitiveObjectInspector inputOI1; protected PrimitiveObjectInspector inputOI2; @Override public StructObjectInspector initialize(ObjectInspector[] argOIs) throws UDFArgumentException { inputOI1 = (PrimitiveObjectInspector) argOIs[1]; inputOI2 = (PrimitiveObjectInspector) argOIs[1]; ArrayList<String> fieldNames = new ArrayList<String>(); ArrayList<ObjectInspector> fieldOIs = new ArrayList<ObjectInspector>(); fieldNames.add("col"); fieldOIs.add(inputOI1); fieldOIs.add(inputOI2); return ObjectInspectorFactory.getStandardStructObjectInspector(fieldNames, fieldOIs); } @Override public void process(Object[] o) throws HiveException { String delim = (String) inputOI1.getPrimitiveJavaObject(o[0]); String datas = (String) inputOI2.getPrimitiveJavaObject(o[1]); for(String str: datas.split(delim)) { forwardListObj[0] = new Text(str); forward(forwardListObj); } } @Override public void close() throws HiveException { } } 사용방법 -- UDF가 포함된 JAR 추가 및 함수 생성 ADD JAR hdfs:///user/hiveUDF.jar; CREATE TEMPORARY FUNCTION parseStr AS 'com.sec.hive.udf.StringParseUDTF'; hive> SELECT parseStr(",", "1,2,3"); OK 2 hive> SELECT parseStr("-", "a-b-c"); OK b 참고 hive explode() 함수 구현 하이브 UDTF 구현 위키 4-TRANSFORM 구현 TRANSFORM 함수는 입력 데이터가 정형 데이터가 아닐 때 파이썬 스크립트를 이용하여 입력 데이터를 정형 구조로 변경할 때 사용합니다. 사용자가 구현한 파이썬 스크립트와 TRANSFORM 함수를 이용하여 비정형 데이터를 처리하는 예제를 알아보겠습니다. 예를 들어 아래의<NAME>으로 <입력>되는 로그를 <출력>처럼 처리하고 싶을 때 사용할 수 있습니다. <입력> DATA1 Column1-1 Column1-2 DATA2 Column2-1 Column2-2 <출력> DATA1 Column1-1 Column1-2 DATA2 Column2-1 Column2-2 구현 입력을 출력의 구조적인 형태로 변경하는 파이썬 스크립트를 아래처럼 구현할 수 있습니다. #!/usr/bin/python # -*- coding: utf-8 -*- import re, json, sys, time def readFile(): with sys.stdin as lines: str_list = [] for line in lines: # DATA 시작하면 출력 if line.startswith("DATA") and len(str_list) != 0: print "\t".join(str_list) del str_list[:] str_list.append(line.strip()) else: str_list.append(line.strip()) # 마지막 데이터 출력 print "\t".join(str_list) if __name__ == "__main__": readFile() 사용방법 -- 테이블 생성 CREATE EXTERNAL TABLE sample_temp ( rawLine STRING ) LOCATION "/user/data/txt/"; -- trsnsform(입력 칼럼명) using 파일 위치 as (출력 칼럼) -- 이런 형태로 입력하면 아래와 같은 결과를 확인할 수 있다. SELECT TRANSFORM(rawLine) USING "hdfs:///user/custom_mapred.py" AS (type, dt1, dt2) FROM sample_temp; Total MapReduce CPU Time Spent: 1 seconds 710 msec OK DATA1 Column1-1 Column1-2 DATA2 Column2-1 Column2-2 참고 Hive - LanguageManual Transform 3-Macro 하이브는 매크로 기능을 제공합니다. 자주 사용하는 값이나 복합 함수를 매크로로 설정하여 편리하게 호출할 수 있습니다. 생성 기본 문법은 아래와 같습니다. 칼럼 이름을 표현식에 사용할 수 있습니다. 기본 빌트인 함수를 이용하여 매크로를 생성할 수도 있습니다. 매크로는 현재 세션에만 유지됩니다. CREATE TEMPORARY MACRO macro_name([col_name col_type, ...]) expression; 매크로를 생성하는 방법은 아래와 같습니다. CREATE TEMPORARY MACRO fixed_number() 42; CREATE TEMPORARY MACRO string_len_plus_two(x string) length(x) + 2; CREATE TEMPORARY MACRO simple_add (x int, y int) x + y; CREATE TEMPORARY MACRO mfunc(a string, b string, c string) CONCAT(CONCAT_WS("/", a, b, c), "/"); hive> select fixed_number(); OK 42 hive> select string_len_plus_two("AB"); OK hive> select simple_add(10, 5); OK 15 hive> select mfunc('a', 'b', 'c'); OK a/b/c/ 삭제 매크로 이름을 입력하여 삭제합니다. DROP TEMPORARY MACRO [IF EXISTS] macro_name; 5-관리 하이브 데이터베이스, 테이블, 함수 등을 관리하기 위한 desc, show 명령을 알아보겠습니다. 1-DESCRIBE DESC는 메타 스토어에 정의된 데이터베이스, 테이블의 이름, 속성, 설정 정보 등을 확인할 때 사용합니다. DESC를 이용하여 확인할 수 있는 목록은 다음과 같습니다. Database Table/View/Materialized View/Column Display Column Statistics Partition Describe Database DESCRIBE DATABASE는 데이터베이스 이름, 주석(설정된 경우) 및 파일 시스템의 루트 위치를 보여줍니다. SCHEMAS와 DATABASES는 동일한 의미로 바꾸어 사용할 수 있습니다. EXTENDED는 데이터베이스 속성도 표시합니다. FORMATTED는 포맷에 맞게 출력합니다. DESCRIBE DATABASE [EXTENDED|FORMATTED] db_name; DESCRIBE SCHEMA [EXTENDED|FORMATTED] db_name; -- (Note: Hive 1.1.0 and later) Describe Table/View/Materialized View/Column DESCRIBE [EXTENDED|FORMATTED] table_name; Describe Partition DESCRIBE [EXTENDED|FORMATTED] table_name[.column_name] PARTITION partition_spec; hive> DESCRIBE formatted part_table partition (d='abc'); OK # col_name data_type comment i int # Partition Information # col_name data_type comment d string # Detailed Partition Information Partition Value: [abc] Database: default Table: part_table CreateTime: Wed Mar 30 16:57:14 PDT 2016 LastAccessTime: UNKNOWN Protect Mode: None Location: file:/tmp/warehouse/part_table/d=abc Partition Parameters: COLUMN_STATS_ACCURATE true numFiles 1 numRows 1 rawDataSize 1 totalSize 2 transient_lastDdlTime 1459382234 # Storage Information SerDe Library: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe InputFormat: org.apache.hadoop.mapred.TextInputFormat OutputFormat: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat Compressed: No Num Buckets: -1 Bucket Columns: [] Sort Columns: [] Storage Desc Params: serialization.format 1 Time taken: 0.334 seconds, Fetched: 35 row(s) 2-SHOW SHOW는 메타 스토어에 정의된 데이터베이스, 테이블, 뷰, 테이블 파티션 등의 목록을 확인할 때 사용합니다. LIKE를 이용하면 정규식의 와일드카드(*)를 이용하여 여러 개의 목록을 한 번에 조회할 수 있습니다. SHOW를 이용하여 확인할 수 있는 목록은 다음과 같습니다. Databases Tables/Views/Materialized Views/Partitions/Indexes Tables Views Materialized Views Partitions Table/Partition Extended Table Properties Create Table Indexes Columns Functions Locks Conf Transactions Compactions Show Databases SHOW DATABASES 또는 SHOW SCHEMAS는 메타 스토어에 정의된 모든 데이터베이스를 나열합니다. SCHEMAS와 DATABASES는 동일한 의미로 바꾸어 사용할 수 있습니다. LIKE 절을 사용하면 정규식을 사용하여 데이터베이스 목록을 필터링할 수 있습니다. 정규식의 와일드카드(*)를 이용하여 여러 개의 목록을 한 번에 조회할 수 있습니다. 예를 들어 'employee', 'emp', 'emp|*ees'는 모두 'employees'라는 데이터베이스와 일치합니다. SHOW (DATABASES|SCHEMAS) [LIKE 'identifier_with_wildcards']; Show Tables/Views/Materialized Views/Partitions/Indexes SHOW Tables/Views/Materialized Views/Partitions/Indexes는 현재 데이터베이스(또는 IN 절을 사용하여 명시적으로 명명된)의 모든 기본 테이블과 뷰를 선택적 정규식과 일치하는 이름으로 나열합니다. Show Tables -- Show Tables SHOW TABLES [IN database_name] ['identifier_with_wildcards']; Show Views -- Show Views SHOW VIEWS [IN/FROM database_name] [LIKE 'pattern_with_wildcards']; SHOW VIEWS; -- show all views in the current database SHOW VIEWS 'test_*'; -- show all views that start with "test_" SHOW VIEWS '*view2'; -- show all views that end in "view2" SHOW VIEWS LIKE 'test_view1|test_view2'; -- show views named either "test_view1" or "test_view2" SHOW VIEWS FROM test1; -- show views from database test1 SHOW VIEWS IN test1; -- show views from database test1 (FROM and IN are same) SHOW VIEWS IN test1 "test_*"; -- show views from database test2 that start with "test_" Show Materialized Views -- Show Materialized Views SHOW MATERIALIZED VIEWS [IN/FROM database_name] [LIKE 'pattern_with_wildcards’]; Show Partitions -- Show Partitions SHOW PARTITIONS table_name; SHOW PARTITIONS [db_name.] table_name [PARTITION(partition_spec)]; -- (Note: Hive 0.13.0 and later) SHOW PARTITIONS table_name PARTITION(ds='2010-03-03'); -- (Note: Hive 0.6 and later) SHOW PARTITIONS table_name PARTITION(hr='12'); -- (Note: Hive 0.6 and later) SHOW PARTITIONS table_name PARTITION(ds='2010-03-03', hr='12'); -- (Note: Hive 0.6 and later) Show Table/Partition Extended -- Show Table/Partition Extended SHOW TABLE EXTENDED [IN|FROM database_name] LIKE 'identifier_with_wildcards' [PARTITION(partition_spec)]; Show Table Properties -- Show Table Properties SHOW TBLPROPERTIES tblname; SHOW TBLPROPERTIES tblname("foo"); Show Create Database SHOW CREATE DATABASE은 데이터베이스 생성 명령어를 확인할 수 있습니다. -- Show Create Table SHOW CREATE DATABASE db_name; hive> SHOW CREATE DATABASE db_name; OK CREATE DATABASE `db_name` LOCATION 'hdfs://127.0.0.1:8020/hdfs' Show Create Table SHOW CREATE TABLE은 테이블 생성 명령어를 확인할 수 있습니다. -- Show Create Table SHOW CREATE TABLE ([db_name.] table_name|view_name); Show Indexes -- Show Indexes SHOW [FORMATTED] (INDEX|INDEXES) ON table_with_index [(FROM|IN) db_name]; Show Columns -- Show Columns SHOW COLUMNS (FROM|IN) table_name [(FROM|IN) db_name]; -- SHOW COLUMNS CREATE DATABASE test_db; USE test_db; CREATE TABLE foo(col1 INT, col2 INT, col3 INT, cola INT, colb INT, colc INT, a INT, b INT, c INT); -- SHOW COLUMNS basic syntax SHOW COLUMNS FROM foo; -- show all column in foo SHOW COLUMNS FROM foo "*"; -- show all column in foo SHOW COLUMNS IN foo "col*"; -- show columns in foo starting with "col" OUTPUT col1, col2, col3, cola, colb, colc SHOW COLUMNS FROM foo '*c'; -- show columns in foo ending with "c" OUTPUT c, colc SHOW COLUMNS FROM foo LIKE "col1|cola"; -- show columns in foo either col1 or cola OUTPUT col1, cola SHOW COLUMNS FROM foo FROM test_db LIKE 'col*'; -- show columns in foo starting with "col" OUTPUT col1, col2, col3, cola, colb, colc SHOW COLUMNS IN foo IN test_db LIKE 'col*'; -- show columns in foo starting with "col" (FROM/IN same) OUTPUT col1, col2, col3, cola, colb, colc -- Non existing column pattern resulting in no match SHOW COLUMNS IN foo "nomatch*"; SHOW COLUMNS IN foo "col+"; -- + wildcard not supported SHOW COLUMNS IN foo "nomatch"; Show Functions SHOW FUNCTIONS는 LIKE로 지정된 경우 정규식으로 필터링 된 모든 사용자 정의 및 내장 함수를 나열합니다. SHOW FUNCTIONS [LIKE "<pattern>"]; Show Locks SHOW LOCKS는 테이블 또는 파티션의 잠금을 표시합니다. 잠금에 대한 정보는 Hive Concurrency Model을 참조하십시오. SHOW LOCKS <table_name>; SHOW LOCKS <table_name> EXTENDED; SHOW LOCKS <table_name> PARTITION (<partition_spec>); SHOW LOCKS <table_name> PARTITION (<partition_spec>) EXTENDED; SHOW LOCKS (DATABASE|SCHEMA) database_name; -- (Note: Hive 0.13.0 and later; SCHEMA added in Hive 0.14.0) Show Transactions 트랜잭션 표시는 Hive 트랜잭션을 사용할 때 관리자가 사용하기 위한 것입니다. 다음 정보를 포함하여 시스템에서 현재 열려 있고 중단된 모든 트랜잭션 목록을 리턴합니다. + transaction ID + transaction state + user who started the transaction + machine where the transaction was started + timestamp when the transaction was started (as of Hive 2.2.0) + timestamp for last heart beat (as of Hive 2.2.0 ) SHOW TRANSACTIONS; Show Compactions SHOW COMPACTIONS는 다음 정보를 포함하여 Hive 트랜잭션이 사용될 때 현재 압축되거나 압축될 예정인 모든 테이블 및 파티션의 목록을 리턴합니다. SHOW COMPACTIONS; 6-트랜잭션 하이브는 0.13버전부터 트랜잭션을 지원합니다. 파일 수정이 없는 HDFS의 특성상 모든 기능이 완벽하게 지원되지 않고 다음의 기능만을 지원하고, 기본(default) 트랜잭션 설정은 off로 되어 있습니다. 상세한 내용은 Hive Wiki의 하이브 트랜잭션을 참고 바랍니다. BEGIN, COMMIT, ROLLBACK은 아직 지원하지 않음, 현재는 auto-commit만 지원 ORC 파일 포맷, 버켓팅 설정이 된 매니지드 테이블에서만 지원 Non-ACID 세션에서는 ACID 테이블에 접근 불가 트랜잭션의 처리 순서 HDFS는 파일의 변경/수정을 지원하지 않습니다. 따라서 HDFS에서 트랜잭션을 지원하기 위해서 데이터를 베이스(base) 파일에 기록하고, 트랜잭션(생성/수정/삭제)이 발생할 때마다 델타(delta) 파일에 내용을 기록합니다. 그리고 파일을 읽을 때 베이스 파일에 델타 파일의 내용을 적용하여 수정된 내용을 반환합니다. 테이블이나 파티션은 베이스 파일의 집합으로 저장 insert, update, delete에 대해서는 델타 파일로 저장 읽는 시점에 베이스 파일과, 델 터 파일을 합쳐서 수정된 내용을 반환 파일시스템에 저장된 파일을 확인하면 다음과 같은 형태입니다. base_xxx 파일과 delta_xxx 파일이 함께 존재합니다. hive> dfs -ls -R /user/hive/warehouse/t; drwxr-xr-x - ekoifman staff 0 2016-06-09 17:03 /user/hive/warehouse/t/base_0000022 -rw-r--r-- 1 ekoifman staff 602 2016-06-09 17:03 /user/hive/warehouse/t/base_0000022/bucket_00000 drwxr-xr-x - ekoifman staff 0 2016-06-09 17:06 /user/hive/warehouse/t/delta_0000023_0000023_0000 -rw-r--r-- 1 ekoifman staff 611 2016-06-09 17:06 /user/hive/warehouse/t/delta_0000023_0000023_0000/bucket_00000 drwxr-xr-x - ekoifman staff 0 2016-06-09 17:07 /user/hive/warehouse/t/delta_0000024_0000024_0000 -rw-r--r-- 1 ekoifman staff 610 2016-06-09 17:07 /user/hive/warehouse/t/delta_0000024_0000024_0000/bucket_00000 컴팩션 컴팩션은 델타 파일(delta_xxx)을 정리하는 작업입니다. 트랜잭션이 많아지면 델타 파일의 개수가 늘어나고 파일의 사이즈가 커지면서 네임노드의 관리 포인트가 늘어나게 됩니다. 이 부하를 줄이기 위해서 백그라운드 서비스로 컴팩션이 수행됩니다. 델타 파일이 많아지면, 마이너 컴팩션이 발생하여 델타 파일을 하나로 합치고, 델타 파일이 점점 커지면 메이저 컴팩션이 발생하여 베이스 파일의 내용을 수정하게 됩니다. 컴팩션은 트랜잭션이 발생할 때 처리되지 않고, 주기적으로 수행되는 컴팩션 스케줄에 따라 맵리듀스 잡으러 실행됩니다. 마이너 컴팩션(minor compaction) 델타 파일을 모아서 버켓당 하나의 델타 파일로 다시 생성 메이저 컴팩션(major compaction) 베이스 파일과 델타 파일을 새로운 베이스 파일로 생성 베이스 파일과 디렉터리 구조 파티션이 적용되지 않은 t라는 테이블을 생성하였을 때 HDFS를 확인하면 구조가 다음과 같습니다. base_ 파일이 기본 파일이고, delta_ 파일이 델타 파일입니다. 실제 데이터를 읽을 때 하이브는 base_ 파일의 내용에 delta_ 파일의 내용을 합쳐서 수정사항을 반영하여 반환하게 됩니다. hive> dfs -ls -R /user/hive/warehouse/t; drwxr-xr-x - ekoifman staff 0 2016-06-09 17:03 /user/hive/warehouse/t/base_0000022 -rw-r--r-- 1 ekoifman staff 602 2016-06-09 17:03 /user/hive/warehouse/t/base_0000022/bucket_00000 drwxr-xr-x - ekoifman staff 0 2016-06-09 17:06 /user/hive/warehouse/t/delta_0000023_0000023_0000 -rw-r--r-- 1 ekoifman staff 611 2016-06-09 17:06 /user/hive/warehouse/t/delta_0000023_0000023_0000/bucket_00000 drwxr-xr-x - ekoifman staff 0 2016-06-09 17:07 /user/hive/warehouse/t/delta_0000024_0000024_0000 -rw-r--r-- 1 ekoifman staff 610 2016-06-09 17:07 /user/hive/warehouse/t/delta_0000024_0000024_0000/bucket_00000 트랜잭션, 컴팩션 설정 트랜잭션은 hive.txn.manager과 hive.support.concurrency를 설정해야 합니다. set hive.support.concurrency=true; set hive.txn.manager=org.apache.hadoop.hive.ql.lockmgr.DbTxnManager; 컴팩션은 hive.compactor.initiator.on를 설정해야 합니다. set hive.compactor.initiator.on=true; set hive.compactor.worker.threads=3; ConfigurationProperties-TransactionsandCompactor 트랜잭션 테이블 생성 트랜잭션 테이블은 버켓팅을 설정해야 하고, 테이블 저장 타입을 ORC로 설정해야 합니다. 그리고 테이블 프로퍼티에 "transactional"="true"를 설정하면 됩니다. CREATE TABLE table_name ( id int, name string ) CLUSTERED BY (id) INTO 2 BUCKETS STORED AS ORC TBLPROPERTIES ("transactional"="true", "compactor.mapreduce.map.memory.mb"="2048", -- specify compaction map job properties "compactorthreshold.hive.compactor.delta.num.threshold"="4", -- trigger minor compaction if there are more than 4 delta directories "compactorthreshold.hive.compactor.delta.pct.threshold"="0.5" -- trigger major compaction if the ratio of size of delta files to -- size of base files is greater than 50% ); 테이블 컴팩션 설정 테이블 컴팩션 설정 방법은 다음과 같습니다. ALTER TABLE table_name COMPACT 'minor' WITH OVERWRITE TBLPROPERTIES ("compactor.mapreduce.map.memory.mb"="3072"); -- specify compaction map job properties ALTER TABLE table_name COMPACT 'major' WITH OVERWRITE TBLPROPERTIES ("tblprops.orc.compress.size"="8192"); -- change any other Hive table properties 트랜잭션 확인 트랜잭션 처리 상황은 다음의 명령으로 확인합니다. hive> show transactions; OK Transaction ID Transaction State Started Time Last Heart beat Time User Hostname 96 OPEN 1584422197000 1584422197000 hadoop home 1-락(Lock) 트랜잭션과 락은 동시성을 지원하는 장치입니다. 트랜잭션은 작업의 논리적인 단위입니다. 락은 트랜잭션을 처리할 때 테이블, 파티션에 접근을 제어하는 용도로 사용합니다. 락의 종류: 공유 잠금, 배타적 잠금 락은 Shared(S), Exclusive(X)가 있습니다. 데이터베이스에서 락은 공유 잠금(S)과 배타적 잠금(X)이 있습니다. 공유 잠금은 읽기 잠금(Read Lock)이라고도 불립니다. 다른 트랜잭션에서 데이터를 읽으려고 할 때 다른 공유 잠금은 허용되지만, 배타적 잠금은 허용되지 않습니다. 배타적 잠금은 쓰기 잠금(Write Lock)이라고도 불립니다. 데이터를 변경(INSERT, UPDATE, DELETE) 하려고 할 때 다른 트랜잭션에서 데이터를 읽거나 변경하지 못하게 배타적 잠금을 설정합니다. 배타적 잠금이 걸리면 공유 잠금, 배타적 잠금을 설정할 수 없습니다. 락의 획득 락은 논파티션 테이블과 파티션 테이블에서 따로 동작합니다. 논파티션 테이블은 직관적으로 동작합니다. 테이블을 읽을 때는 S 잠금을 획득하고, 다른 작업에서는 X 잠금을 획득합니다. 파티션 테이블은 읽을 때 테이블에 S 잠금, 파티션에 S 잠금을 획득합니다. 다른 작업에서는 테이블에 S 잠금, 파티션에 X 잠금을 획득합니다. 락을 획득하는 방법은 다음과 같습니다. Hive Command Locks Acquired select .. T1 partition P1 S on T1, T1.P1 insert into T2(partition P2) select .. T1 partition P1 S on T2, T1, T1.P1 and X on T2.P2 insert into T2(partition P.Q) select .. T1 partition P1 S on T2, T2.P, T1, T1.P1 and X on T2.P.Q alter table T1 rename T2 X on T1 alter table T1 add cols X on T1 alter table T1 replace cols X on T1 alter table T1 change cols X on T1 alter table T1 concatenate X on T1 alter table T1 add partition P1 S on T1, X on T1.P1 alter table T1 drop partition P1 S on T1, X on T1.P1 alter table T1 touch partition P1 S on T1, X on T1.P1 alter table T1 set serdeproperties S on T1 alter table T1 set serializer S on T1 alter table T1 set file format S on T1 alter table T1 set tblproperties X on T1 alter table T1 partition P1 concatenate X on T1.P1 drop table T1 X on T1 락 확인 락을 확인하는 명령어입니다. SHOW LOCKS <TABLE_NAME>; SHOW LOCKS <TABLE_NAME> EXTENDED; SHOW LOCKS <TABLE_NAME> PARTITION (<PARTITION_DESC>); SHOW LOCKS <TABLE_NAME> PARTITION (<PARTITION_DESC>) EXTENDED; 하이브에서 락은 아래와 같이 확인합니다. hive (default)> show locks; OK Lock ID Database Table Partition State Blocked By Type Transaction ID Last Heart beat Acquired At UseHostname Agent Info 406.1 default table_name NULL ACQUIRED SHARED_READ 96 0 1584422197000 hadoop home hadoop_20200317051637_e6f8965b-eb5d-4281-b60a-8dc7f499c7d5 Time taken: 0.014 seconds, Fetched: 2 row(s) 참고 Hive-Locking 7-성능 최적화 작업 엔진 선택: TEZ 엔진 사용 파일 저장 포맷: ORC 파일 사용 데이터 처리 방식: 벡터화(Vectorization) 사용 데이터 저장 효율화: 파티셔닝, 버켓팅 사용 통계정보 이용: 하이브 stat 사용 옵티마이저 이용: CBO YARN: 작업 큐 설정 하이브의 성능을 최적화하기 위한 설정에 대해서 알아보겠습니다. 작업 엔진 선택: TEZ 엔진 사용 맵리듀스(MR) 엔진은 연산의 중간 파일을 로컬 디스크에 쓰면서 진행하여 이로 인한 잦은 IO 처리로 작업이 느려집니다. 테즈(TEZ) 엔진은 작업 처리 결과를 메모리에 저장하여 맵리듀스보다 빠른 속도로 작업을 처리할 수 있습니다. set hive.execution.engine=tez; 파일 저장 포맷: ORC 파일 사용 테이블의 데이터 저장에 ORC 파일을 사용하여 처리 속도를 높일 수 있습니다. ORC 파일 포맷은 데이터를 칼럼 단위로 저장하기 때문에 검색 속도가 빠르고, 압축률이 높습니다. CREATE TABLE table1 ( ) STORED AS ORC; 데이터 처리 방식: 벡터화(Vectorization) 사용 벡터화 처리는 한 번에 1행을 처리하지 않고, 한 번에 1024행을 처리하여 속도를 높이는 기술입니다. ORC 파일 포맷에서만 사용 가능합니다. 필터링, 조인, 집합 연산에서 40~50% 정도의 성능 향상을 기대할 수 있습니다. set hive.vectorized.execution.enabled=true; 데이터 저장 효율화: 파티셔닝, 버켓팅 사용 하이브는 디렉터리 단위로 데이터를 처리하기 때문에 검색에 사용되는 데이터를 줄이기 위한 방안으로 파티셔닝, 버켓팅 기능을 이용하면 좋습니다. 파티셔닝은 데이터를 폴더 단위로 구분하여 저장하고, 버켓팅은 지정한 개수의 파일에 칼럼의 해시값을 기준으로 데이터를 저장합니다. 이를 이용하여 한 번에 읽을 데이터의 크기를 줄일 수 있습니다. CREATE TABLE table1 ( ) PARTITIONED BY(part_col STRING); 통계정보 이용: 하이브 stat 사용 하이브는 테이블, 파티션의 정보를 메타 스토어에 저장하고 조회나 count, sum 같은 집계 함수를 처리할 때 이 정보를 이용할 수 있습니다. 맵리듀스 연산 없이 바로 작업할 수 있기 때문에 작업의 속도가 빨라집니다. set hive.stats.autogather=true; 옵티마이저 이용: CBO 하이브는 카탈리스트 옵티마이저를 이용하여 효율적으로 작업을 처리할 수 있습니다. explain을 이용하여 작업 분석 상태를 확인할 수 있습니다. set hive.cbo.enable=true; hive> explain select A from ta, tb where ta.id = tb.id; YARN: 작업 큐 설정 YARN의 스케줄러 설정을 통해 작업의 효율성을 높일 수 있습니다. 작업의 성격에 따라 큐를 여러 개 만들어서 스케줄러의 사용 설정을 적용하면 좋습니다. 하나의 큐에 모든 작업을 넣지 않고, batch, adhoc 같은 형태로 큐를 만들어서 큐의 최대 사용량 설정을 통해 적절하게 작업을 분산하여 주는 것이 좋습니다. 1-TEZ 테즈(TEZ)는 YARN 기반의 비동기 사이클 그래프 프레임워크입니다. 하이브에서 맵리듀스 대신 실행 엔진으로 사용할 수 있습니다. 맵리듀스는 맵 단계에서 데이터를 읽어서 처리하고, 리듀스 단계에서 처리 결과를 저장합니다. 하나의 작업이 여러 단계의 맵, 리듀스를 거치게 되면 중간 작업 결과를 HDFS에 쓰고, 다시 맵 단계에서 파일을 읽어서 처리하게 됩니다. 작업 중간 임시 데이터도 디스크에 쓰게 되어 IO 작업으로 인한 오버헤드가 많았습니다. 테즈는 맵 단계 처리 결과를 메모리에 저장하고, 이를 리듀스 단계로 바로 전달합니다. 리듀스 작업의 결과를 맵 단계를 거치지 않고 리듀스 단계로 전달하여 IO 오버헤드를 줄여서 속도를 높일 수 있습니다. 맵리듀스 vs 테즈 AWS EMR을 이용한 테스트에서 동일한 작업에서 맵리듀스는 약 50초, 테즈는 30초로 40% 정도 성능이 향상된 것을 확인할 수 있습니다. 맵리듀스 작업: 49.699초 Starting Job = job_1464200677872_0002, Tracking URL = http://ec2-host:20888/proxy/application_1464200677872_0002/ Kill Command = /usr/lib/hadoop/bin/hadoop job -kill job_1464200677872_0002 Hadoop job information for Stage-1: number of mappers: 1; number of reducers: 1 2016-05-27 04:53:11,258 Stage-1 map = 0%, reduce = 0% 2016-05-27 04:53:25,820 Stage-1 map = 13%, reduce = 0%, Cumulative CPU 10.45 sec 2016-05-27 04:53:32,034 Stage-1 map = 33%, reduce = 0%, Cumulative CPU 16.06 sec 2016-05-27 04:53:35,139 Stage-1 map = 40%, reduce = 0%, Cumulative CPU 18.9 sec 2016-05-27 04:53:37,211 Stage-1 map = 53%, reduce = 0%, Cumulative CPU 21.6 sec 2016-05-27 04:53:41,371 Stage-1 map = 100%, reduce = 0%, Cumulative CPU 25.08 sec 2016-05-27 04:53:49,675 Stage-1 map = 100%, reduce = 100%, Cumulative CPU 29.93 sec MapReduce Total cumulative CPU time: 29 seconds 930 msec Ended Job = job_1464200677872_0002 Moving data to: s3://myBucket/mr-test/os_requests MapReduce Jobs Launched: Stage-Stage-1: Map: 1 Reduce: 1 Cumulative CPU: 29.93 sec HDFS Read: 599 HDFS Write: 0 SUCCESS Total MapReduce CPU Time Spent: 29 seconds 930 msec OK Time taken: 49.699 seconds 테즈 작업: 30.711초 Time taken: 0.517 seconds Query ID = hadoop_20160527050505_dcdc075f-8338-4041-adc3-d2ffe69dfcdd Total jobs = 1 Launching Job 1 out of 1 Status: Running (Executing on YARN cluster with App id application_1464200677872_0003) -------------------------------------------------------------------------------- VERTICES STATUS TOTAL COMPLETED RUNNING PENDING FAILED KILLED -------------------------------------------------------------------------------- Map 1 .......... SUCCEEDED 1 1 0 0 0 0 Reducer 2 ...... SUCCEEDED 1 1 0 0 0 0 -------------------------------------------------------------------------------- VERTICES: 02/02 [==========================>>] 100% ELAPSED TIME: 27.61 s -------------------------------------------------------------------------------- Moving data to: s3://myBucket/tez-test/os_requests OK Time taken: 30.711 seconds 실행 엔진 설정 하이브에서 테즈 엔진을 사용하는 방법은 다음과 같습니다. -- 테즈 엔진 설정 set hive.execution.engine=tez; set tez.queue.name=tez_queue_name; -- 맵리듀스 엔진 설정 set hive.execution.engine=mr; set mapred.job.queue.name=mr_queue_name; 1-TEZ 작업 최적화 TEZ로 작업을 진행할 때 성능을 최적화할 수 있는 방법입니다. Tez 로그 성공/실패 확인 Tez의 로그는 아래와 같이 표시됩니다. 성공, 실패 확인을 통해 작업의 효율적인 처리 여부를 확인할 수 있습니다. A(+B, -C)/D A는 성공한 작업의 수 B는 실행 중인 작업의 수 C는 실패 한 작업의 수 D는 전제 착업의 수 Map 1: 0(+1)/1 Map 4: 1/1 Reducer 2: 0/1 Reducer 3: 0/1 애플리케이션 마스터의 메모리 설정 애플리케이션 마스터는 쿼리를 분석하는 역할을 합니다. 쿼리를 분석하기 위해 쿼리에 사용되는 테이블의 정보를 활용합니다. 메타 스토어에 저장된 통계정보와 ORC 같은 파일의 풋터에 저장되어 있는 통계정보를 이용하기 때문에 쿼리에 사용되는 파일의 개수가 많다면 큰 메모리를 이용하게 됩니다. set tez.am.resource.memory.mb=2048; set tez.am.launch.cmd-opts=-Xmx1800m; 컨테이너 메모리 설정 컨테이너는 맵리듀스 작업을 실행합니다. 데이터 입력 사이즈에 맞게 적당한 크기의 메모리를 지정해야 합니다. 컨테이너의 메모리가 크면 생성되는 컨테이너의 개수가 작아지고, 메모리가 작으면 컨테이너의 개수가 많아집니다. 각 컨테이너의 히프 사이즈에 따라 GC 발생 여부가 결정되고, 이로 인한 작업의 지연이 발생할 수도 있습니다. set hive.tez.container.size=2048; set hive.tez.java.opts=-Xmx1800m; 스플릿 사이즈 - 리듀서 개수 애플리케이션 마스터는 쿼리를 분석하여 매 퍼와 리듀서의 개수를 계산합니다. 아래의 경우 매퍼 1은 44개의 컨테이너를 필요로 하고, 리듀서2와 3은 12개의 컨테이너를 필요로 합니다. 이는 그룹핑 사이즈 정보를 이용하여 입력 파일의 사이즈와 파일 개수를 기반으로 애플리케이션 마스터가 계산하여 설정됩니다. -- 매퍼, 리듀서 개수 Map 1: 44/44 Map 4: 1/1 Reducer 2: 0(+12)/12 Reducer 3: 12/12 -- 매퍼 개수 설정 tez.grouping.max-size tez.grouping.min-size -- 리듀서 개수 설정 hive.exec.reducers.bytes.per.reducer GC 확인 작업에 사용된 리소스 정보를 확인하기 위해서는 마지막에 보고서를 출력하면 됩니다. hive.tez.exec.print.summary 옵션을 이용하여 이 데이터를 처리합니다. 맵 조인 맵 조인을 이용하기 위해서는 테이블의 사이즈가 지정한 메모리의 사이즈보다 작아야 합니다. set hive.auto.convert.join.noconditionaltask.size=10000000; 파티션 입력 데이터의 입력으로 파티션을 생성할 때 많은 작업이 하나의 파티션에 데이터를 삽입하면 작업이 오래 걸릴 수 있습니다. 이럴 때는 hive.optimize.sort.dynamic.partition 옵션을 고려할 수 있습니다. 적은 수의 파티션에는 작업이 오래 걸릴 수 있기 때문에 10개 이상의 파티션일 때 true를 사용하는 것이 좋습니다. 하이브 통계 정보 하이브 CBO는 통계정보를 이용하여 빠른 결과를 반환할 수 있습니다. 통계정보는 하이브 메타 스토어 DB에 저장되고, 이 정보를 이용하여 윈도 함수 이용 시 빠른 계산 결과를 확인할 수 있습니다. 참고 Tez Internals #1 – Number of Map Tasks Understanding Considerations to Move Existing MapReduce Jobs in Hive to Tez 2-그룹핑 설정 최적화 파일 개수와 사이즈에 따른 그룹핑 사이즈 설정과 처리 속도 차이 하이브를 이용해서 데이터를 처리할 때 파일의 개수와 사이즈가 중요합니다. 동일한 쿼리에서도 설정에 따라 속도 차이가 많이 날 수 있습니다. SELECT A, count(*) FROM tbl GROUP BY A ORDER BY A; 칼럼 A로 파티셔닝 파티션당 60 여개의 ORC 파일 파일당 10~20KB 이 상황에서 TEZ 엔진 기본 설정으로 쿼리를 실행하면 2148초가 걸립니다. 파일의 사이즈가 작아서 매 퍼가 작게 생성되지만, ORC 파일의 특성상 하나의 파일에 많은 데이터가 들어가게 되고, 이 데이터를 모두 처리하는데 많은 메모리가 소모되기 때문입니다. 이런 경우 TEZ 엔진의 그룹핑 사이즈를 조절하여 매퍼의 개수를 늘려서, 하나의 매 퍼가 처리하는 데이터를 줄이면 속도가 빨라지는 것을 확인할 수 있습니다. 설정 변경을 통해 다음과 같이 시간이 변경되는 것을 확인할 수 있었습니다. 설정 크기 매퍼개수 시간 tez.grouping.max-size 1G 3 2148.009 tez.grouping.max-size 25600 8671 139.95 tez.grouping.max-size 256000 1231 51.30 TEZ 설정 변경 set tez.grouping.max-size=256000; set tez.grouping.min-size=128000; 2-ORC ORC(Optimized Row Columnar)는 칼럼 기반의 파일 저장 방식으로, Hadoop, Hive, Pig, Spark 등에 적용 가능합니다. 데이터베이스의 데이터를 읽을 때 보통 칼럼 단위의 데이터를 이용하는 경우가 많습니다. ORC는 칼럼 단위로 데이터를 저장하기 때문에 칼럼의 데이터를 찾는 것이 빠르고, 압축효율이 좋습니다. ORC 설정 하이브에서는 다음과 같이 STORED AS를 ORC로 선언하고, TBLPROPERTIES에 설정 정보를 입력합니다. CREATE TABLE table1 ( col1 string, col2 string ) STORED AS ORC TBLPROPERTIES ( "orc.compress"="ZLIB", "orc.compress.size"="262144", "orc.create.index"="true", "orc.stripe.size"="268435456", "orc.row.index.stride"="3000", "orc.bloom.filter.columns"="col1, col2" ); ORC 설정값 orc.compress 기본값: ZLIB 압축방식 설정 (one of NONE, ZLIB, SNAPPY) orc.compress.size 기본값: 262,144 압축을 처리할 청크 사이즈 설정(256 * 1024 = 262,144) orc.create.index 기본값: true 인덱스 사용 여부 orc.row.index.stride 기본값: 10,000 설정 row 이상일 때 인덱스 생성 (must be >= 1000) orc.stripe.size 기본값: 67,108,864 스트라이프를 생성할 사이즈 (64 * 1024 *1024 = 67,108,864)), 설정 사이즈마다 하나씩 생성 orc.bloom.filter.columns 기본값: "" 블룸 필터 1을 생성할 칼럼 정보, 콤마(,)로 구분하여 입력 orc.bloom.filter.fpp 기본값: 0.05 블룸 필터의 오판 확률(fpp=false positive portability) 설정 (must >0.0 and <1.0) 원소가 집합에 속하는지를 검사하는데 사용하는 확률적 자료 구조입니다. 블룸 필터에 의해 어떤 원소가 집합에 속한다고 판단된 경우 실제로는 원소가 집합에 속하지 않는 긍정 오류가 발생하는 것이 가능하지만, 반대로 원소가 집합에 속하지 않는 것으로 판단되었는데 실제로는 원소가 집합에 속하는 부정 오류는 절대로 발생하지 않는다는 특성이 있습니다. ↩ 3-CBO 하이브 0.14 버전부터 사용자의 쿼리를 최적화하는 CBO를 지원합니다. CBO가 적용되면 사용자의 쿼리를 분석해서 쿼리를 최적화합니다. 예를 들어 테이블 A, B,의 조인을 처리할 때 조인 데이터를 비교하여 셔플 단계의 데이터를 줄일 수 있는 방향으로 쿼리를 수정하여 줍니다. 다음과 같은 쿼리에서 t1, t2를 모두 읽어서 조인하지 않고, t2를 읽을 때 먼저 필터링을 처리한 뒤 조인하는 방향으로 쿼리를 최적화하여 줍니다. t2의 데이터가 많을 경우 네트워크를 통해 이동하는 데이터가 줄어들어서 처리 비용이 감소합니다. SELECT sum(v) FROM ( SELECT t1.id, t1.value AS v FROM t1 JOIN t2 WHERE t1.id = t2.id AND t2.id > 50000) inner ) outer CBO 옵션 CBO를 적용하기 위해서는 다음의 옵션을 설정해야 합니다. 기본적으로 true 상태입니다. -- CBO 적용 set hive.cbo.enable=true; -- 새로 생성되는 테이블과 INSERT 처리를 할 때 자동으로 통계정보 수집 set hive.stats.autogather=true; set hive.stats.fetch.column.stats=true; set hive.stats.fetch.partition.stats=true; 통계정보를 자동으로 수집하지 않으면 ANALYZE 명령을 이용해서 수동으로 정보를 수집해야 합니다. 통계정보 수집도 맵리듀스 작업이기 때문에 데이터가 많으면 시간이 오래 걸릴 수 있습니다. ANALYZE TABLE sample_table PARTITION(yymmdd='20180201') COMPUTE STATISTICS for columns; ANALYZE TABLE sample_table PARTITION(yymmdd='20180201') COMPUTE STATISTICS; explain 쿼리 확인 explain 명령으로 CBO 적용 여부를 확인할 수 있습니다. CBO가 작용되면 다음과 같이 "Plan optimized by CBO."라는 메시지가 출력됩니다. hive> explain INSERT OVERWRITE DIRECTORY 'hdfs:///user/data/location' > select name, count(1) > from sample_table > where yymmdd=20180201 > group by name > > ; OK Plan optimized by CBO. CBO 적용 불가 CBO가 적용 불가능한 상황이 몇 가지 있습니다. CBO 적용이 불가능한 경우 로그에 불가능한 원인을 다음과 같이 출력합니다. 따라서 "Plan not optimized by CBO." 메시지가 출력되면 하이브 로그를 확인하여 적용 불가 원인을 확인하고 수정하면 됩니다. 2019-04-05T08:08:12,490 INFO [main([])]: parse.BaseSemanticAnalyzer (:()) - Not invoking CBO because the statement has sort by 적용 불가 상황 CBO 적용이 불가능한 몇 가지 상황은 다음과 같습니다. 트랜스폼(transform)은 사용 불가 인라인 Lateral View Join만 가능 UNIQUE 조인은 불가 서브 쿼리 사용 불가 Having 절에 select의 alias 가 들어있으면 사용 불가 Sort By 사용 불가 참고 Cost-based optimization in Hive 바로 가기 HIVE 0.14 Cost Based Optimizer (CBO) Technical Overview 바로 가기 4-압축 하둡, 하이브를 이용하여 작업을 처리할 때 저장 장치를 효율적으로 이용하기 위해서 데이터 파일을 압축할 때 사용하는 압축 알고리즘인 gzip, snappy에 대해서 알아보겠습니다. gzip gzip은 GNU zip의 약자이며 유닉스에서 사용되는 압축 방식의 한 종류입니다. DEFLATE 알고리즘을 이용하고, 압축률이 높지만 CPU 사용률이 높습니다. snappy snappy는 구글에서 개발한 압축 알고리즘입니다. 적당한 수준의 압축률에 빠른 압축/해제 속도를 제공합니다. gzip vs snappy 압축 알고리즘 비교 하이브에서 두 개의 압축 알고리즘을 이용하여 테스트해 보았습니다. 100MB의 원본 파일을 이용하여 테스트한 결과 다음과 같습니다. gzip을 이용할 때 압축파일은 4MB가 되었고, snappy를 이용하면 10MB가 되었습니다. 압축할 때 CPU는 snappy가 30~40%, gzip이 50~60% 정도의 사용률을 보였습니다. 압축 용량 원본 104857627 100 gzip 4851875 4 snappy 10968637 10 하이브 적용 하이브는 압축파일의 타입에 따라 자동으로 리더를 선택하기 때문에 두 개의 파일이 한곳에 있어도 문제없이 처리됩니다. 같은 환경에서 gzip의 용량이 더 작기 때문에 매퍼의 개수가 작게 생성됩니다. 원본이 100G 일 때 gzip은 4G, snappy는 10G가 됩니다. 테즈 엔진을 이용할 때 매 퍼가 Gzip은 4개, snappy는 10개가 생성됩니다. 기본 설정에서 매퍼당 생성되는 데이터가 많기 때문에 gzip의 처리 속도가 더 늦습니다. 같은 설정으로 snappy로 1,994초 걸리는 작업이 gzip에서는 2,687초가 걸렸습니다. 또한 전체 클러스터의 사용률도 상당한 차이가 발생하였습니다. gzip을 이용할 때는 tez.grouping.max-size를 조절하여 적당한 크기의 데이터를 처리할 수 있도록 수정하는 것이 좋습니다. 참고 고속 압축 알고리즘 비교 테스트: LZO/Snappy/SynLZ/LZ4/QuickLZ/Zlib What is Google Snappy? High-speed data compression and decompression 8-설정 하이브의 여러 가지 유용한 설정에 대해서 알아보겠습니다. 기본 설정값 실행 엔진, 큐 설정 MR 설정 TEZ 설정 TEZ 엔진 실행 결과 출력 매퍼 설정 데이터 사이즈에 따른 매퍼 개수 설정 매퍼 개수 고정 리듀서 설정 압축 설정 파일 머지 설정 임시 파일 위치 설정 다이내믹 파티션 설정 MSCK 처리 설정 하위 디렉터리 조회 설정 쿼리 오류 무시 설정 프롬프트에 데이터베이스 명 표시 조회 결과 출력 시에 칼럼 이름 출력 쿼리 조회 모드 설정 맵 조인 설정 컨테이너 예열(prewarm) 기본 설정값 하이브 쿼리 실행을 위한 기본 설정값입니다. 실행 엔진 선택, 메모리 설정, 매퍼 리듀서 개수 선택을 위한 설정입니다. -- 하이브 실행 엔진 설정 set hive.execution.engine=tez; set tez.queue.name=q2; -- TEZ AM 메모리 설정 set tez.am.resource.memory.mb=2048; set tez.am.java.opts=-Xmx1600m; -- TEZ 컨테이너 메모리 설정 set hive.tez.container.size=2048; set hive.tez.java.opts=-Xmx1600m; -- 테즈 엔진의 매퍼 개수 설정. 일부 환경에서 설정이 제대로 되지 않는 경우 맵리듀스 설정도 같이 해야 함 -- 매퍼는 256MB에 하나씩 생성 set mapreduce.input.fileinputformat.split.maxsize=256000000; set mapreduce.input.fileinputformat.split.minsize=128000000; set tez.grouping.max-size=256000000; set tez.grouping.min-size=128000000; -- 테즈 엔진의 리듀서 개수 설정 -- 128MB에 하나씩 생성 set mapred.reduce.tasks=-1; set hive.exec.reducers.bytes.per.reducer=128000000; -- 리듀서 10개 고정 set mapred.reduce.tasks=10; -- 다이내믹 파티션 설정 set hive.exec.dynamic.partition.mode=nonstrict; 실행 엔진, 큐 설정 하이브는 버전에 따라 mr, tez, spark 실행엔진을 지원합니다. 각 엔진에 따라 YARN 큐 설정은 다음과 같습니다. -- 실행 엔진 설정 set hive.execution.engine=mr; set hive.execution.engine=tez; set hive.execution.engine=spark; -- 실행 엔진별 커패시티 스케줄러의 큐 이름 설정 set mapred.job.queue.name=queueName; set tez.queue.name=queueName; set spark.job.queue.name=queueName; MR 설정 MR 엔진의 애플리케이션 마스터, 매퍼, 리듀서 메모리 설정은 다음과 같습니다. -- 맵리듀스 애플리케이션 마스터의 메모리 설정 set yarn.app.mapreduce.am.resource.mb=2048; set yarn.app.mapreduce.am.command-opts=-Xmx1600m; -- 매퍼의 메모리 설정 set mapreduce.map.memory.mb=2048; set mapreduce.map.java.opts=-Xmx1600m; -- 리듀서의 메모리 설정 set mapreduce.reduce.memory.mb=2048; set mapreduce.reduce.java.opts=-Xmx1600m; TEZ 설정 TEZ 엔진의 애플리케이션 마스터, 컨테이너 메모리 설정은 다음과 같습니다. -- TEZ 잡을 실행하는 애플리케이션 마스터의 메모리 설정은 다음과 같다. set tez.am.resource.memory.mb=2048; set tez.am.java.opts=-Xmx1600m; -- TEZ 엔진을 처리하는 컨테이너의 메모리 설정은 다음과 같다. set hive.tez.container.size=2048; set hive.tez.java.opts=-Xmx1600m; // container의 80% -- 출력 결과를 소팅해야 할 때 사용하는 메모리 set tez.runtime.io.sort.mb=800; // container의 40% TEZ 엔진 실행 결과 출력 TEZ 엔진으로 작업을 처리한 후 결과에 대한 리포트를 출력하기 위한 설정값입니다. MR, Spark 엔진에서는 동작하지 않습니다. set hive.tez.exec.print.summary=true; 매퍼 설정 매 퍼와 리듀서의 개수는 실행 시간에 직접적인 영향을 주게 됩니다. 따라서 입력되는 데이터의 사이즈에 따라 개수를 조절해 주면 성능을 빠르게 할 수 있습니다. 데이터 사이즈에 따른 매퍼 개수 설정 매퍼는 입력 데이터의 사이즈가 1GB 일 때 최대 매퍼 사이즈가 256MB 이면 매퍼는 4개 생성되어 작업을 처리합니다. 일부 tez 작업에서 MR 설정을 같이 입력해야 매퍼 개수가 늘어나는 경우가 있습니다. 데이터 사이즈에 따라 매퍼 개수가 늘어나지 않으면 MR 엔진, TEZ 엔진 설정을 같이 입력해 보십시오. 매퍼 개수는 원본 파일의 크기에 영향을 받습니다. 예를 들어 1MB 크기의 파일이 4개 있는 경우 그룹핑 사이즈를 줄여도 매 퍼가 4개가 생성될 수 있습니다. 자세한 사항은 애플리케이션 마스터의 로그에서 grouper.TezSplitGrouper 정보를 확인하는 것이 좋습니다. -- MR 엔진의 매퍼당 최대 처리 사이즈 set mapreduce.input.fileinputformat.split.maxsize=268435456; set mapreduce.input.fileinputformat.split.minsize=134217728; -- TEZ 엔진의 매퍼당 최대 처리 사이즈 set tez.grouping.max-size=268435456; set tez.grouping.min-size=134217728; 매퍼 개수 고정 매퍼 only 잡에서 최종 생성되는 파일의 개수를 설정하거나 리소스의 효율적인 사용을 이유로 매퍼의 개수를 고정해야 할 때는 다음의 설정을 이용합니다. -- MR 엔진의 매퍼 개수 설정 set mapreduce.job.maps=1; -- TEZ 엔진의 매퍼 개수 설정 set tez.grouping.split-count=1; 리듀서 설정 리듀서는 입력 사이즈가 1GB 일 때 최대 처리 사이즈가 256MB 이면 리듀서 4개를 이용하여 데이터를 처리합니다. 최대 리듀서 사용 개수나 리듀서 사용 개수를 이용하여 리듀서의 개수를 지정할 수 있습니다. 리듀서 개수 설정 순서는 다음과 같습니다. 리듀서별 최대 처리 사이즈 > 최대 리듀서 사용 개수 > 리듀서 사용 개수 -- 리듀서 사용 개수 지정 set mapreduce.job.reduces=100; -- 최대 리듀서 사용 개수 set hive.exec.reducers.max=100; -- 리듀서별 최대 처리 사이즈 set hive.exec.reducers.bytes.per.reducer=268435456; 압축 설정 하이브 처리 결과를 압축하는 설정을 이용해 네트워크 통신량과 저장 용량의 이점을 가질 수 있습니다. -- 하이브 처리 결과를 압축할 것인지 설정 set hive.exec.compress.output=true; set hive.exec.compress.intermediate=true; set mapreduce.output.fileoutputformat.compress.codec=org.apache.hadoop.io.compress.SnappyCodec; 파일 머지 설정 HDFS는 작은 사이즈의 파일이 많으면 성능에 좋지 않습니다. 하이브는 처리 결과를 머지 하는 기능을 제공합니다. avgsize 이하의 파일을 모아서 task 사이즈의 파일로 머지 하여 줍니다. 작은 사이즈의 파일을 많이 생성하는 경우 머지를 사용하면 머지 작업에 시간이 매우 많이 걸릴 수 있습니다. 따라서 사용에 주의하시기 바랍니다. set hive.merge.mapfiles=true; // 매퍼 only 결과 머지 set hive.merge.mapredfiles=true; // 맵리듀스 결과 머지 set hive.merge.tezfiles=true; // tez 결과 머지 set hive.merge.size.per.task=256000000; set hive.merge.smallfiles.avgsize=32000000; 임시 파일 위치 설정 하이브 실행 중 발생하는 임시 파일의 위치 설정은 다음과 같습니다. set hive.exec.scratchdir=/tmp; set hive.exec.local.scratchdir=/tmp; set hive.exec.stagingdir=/tmp/hive-staging; 다이내믹 파티션 설정 하이브의 다이내믹 파티션 설정은 다음과 같습니다. set hive.exec.dynamic.partition=true; -- 다이내믹 파티션 사용 여부 설정 set hive.exec.dynamic.partition.mode=nonstrict; -- 스태틱 파티션과의 혼합 사용 여부 set hive.exec.max.dynamic.partitions.pernode=500; -- 노드별 다이내믹 파티션 개수 설정 set hive.exec.max.dynamic.partitions=10000; -- 전체 다이내믹 파티션 개수 설정 MSCK 처리 설정 MSCK 처리를 위한 데이터가 많을 경우 배치 사이즈를 조정해서 한 번에 처리할 데이터의 양을 줄여서 하이브의 부하를 줄여주는 것이 좋습니다. -- 0으로 설정하면 모든 파티션을 복구한다. 설정한 값만큼 처리 set hive.msck.repair.batch.size=0; -- 파티션에 허용되지 않는 문자가 있으면 오류가 발생하는데, ignore로 설정하면 무시하고 넘어간다. set hive.msck.path.validation=ignore; 하위 디렉터리 조회 설정 테이블 LOCATION의 데이터와 하위에 위치한 모든 데이터를 조회해야 한다면 다음을 설정합니다. set hive.supports.subdirectories=true; set mapred.input.dir.recursive=true; 쿼리 오류 무시 설정 하이브는 hql 파일을 이용하여 쿼리를 수행하는 중 오류가 발생하면 쿼리 수행을 종료하고, cli 도 동작을 종료하게 됩니다. 이때 오류가 발생해도 무시하고 다음 쿼리를 수행하게 하는 옵션은 다음과 같습니다. set hive.cli.errors.ignore=true; 프롬프트에 데이터베이스 명 표시 하이브 프롬프트에 현재 사용 중인 데이터베이스 명을 표시하게 하면 사용자 오류에 의한 실수를 사전에 방지할 수 있습니다. set hive.cli.print.current.db=true 조회 결과 출력 시에 칼럼 이름 출력 데이터 조회 결과를 출력할 때 칼럼 이름을 함께 출력하는 옵션은 다음과 같습니다. set hive.cli.print.header=true; 쿼리 조회 모드 설정 쿼리의 성능을 위해 테이블 풀 스캔(Full scan)을 제한하는 하거나, msck repair 처리 시 경우에 따라 nonstrict 모드에서만 동작할 경우가 있습니다. 이때는 다음의 옵션을 이용합니다. set hive.mapred.mode=strict | nonstrict; strict 모드에서는 파티션 처리된 테이블을 조회할 때 나, group by, order by를 처리할 때 where 조건이 없으면 처리할 수 없습니다. hive (default)> select * from tbl_table_hdfs; FAILED: SemanticException Queries against partitioned tables without a partition filter are disabled for safety reasons. If you know what you are doing, please set hive.strict.checks.large.query to false and that hive.mapred.mode is not set to 'strict' to proceed. Note that if you may get errors or incorrect results if you make a mistake while using some of the unsafe features. No partition predicate for Alias "tbl_user" Table "tbl_user" 맵 조인 설정 맵 조인을 이용하면 테이블의 조인 처리가 빨라집니다. 기본적으로 10MB로 설정됩니다. 메모리에 올라가는 데이터 기준 사이즈이므로, 파일의 사이즈와는 다릅니다. desc formatted로 테이블 정보를 확인하여 확인할 수 있는 테이블 파라미터의 rawDataSize 기준으로 설정해야 합니다. set hive.auto.convert.join=true; set hive.auto.convert.join.noconditionaltask.size=10000000; 컨테이너 예열(prewarm) 하둡 2에서는 컨테이너를 미리 실행하여 작업을 빠르게 처리할 수 있습니다. 컨테이너 개수가 많이 생기는 작업의 경우 컨테이너를 미리 생성하여 작업을 빠르게 진행할 수 있습니다. set hive.prewarm.enabled=true; set hive.prewarm.numcontainers=10; 1-하이브 서버 2 하이브 서버 2 관련 설정을 정리합니다. 세션 설정 하이브 서버 2 세션 관련 설정입니다. 세션을 유지하는 시간과 종료하는 시간을 설정할 수 있습니다. <property> <name>hive.server2.idle.operation.timeout</name> <value>1h</value> </property> <property> <name>hive.server2.idle.session.timeout</name> <value>3h</value> </property> <property> <name>hive.server2.session.check.interval</name> <value>3600000</value> </property> 4-하둡 클러스터 운영 하둡 클러스터를 운영하면서 알아두면 좋은 팁에 대해서 알아보겠습니다. 하둡 클러스터의 기본 포트(Port) 1-하둡 클러스터 기본 포트(Port) 하둡 클러스터의 기본 포트에 대해서 알아보겠습니다. 타입 서버 포트 종류 사용법 설명 hdfs hdfs 8020 RPC hadoop fs -ls hdfs://$(hostname -f):8020/ 네임노드 호출 hdfs webhdfs 50070 http curl -s http://$(hostname -f):50070/webhdfs/v1/?op=GETFILESTATUS jq hdfs|webhdfs-proxy|14000|curl -s "http:///Misplaced & Misplaced & (hostname -f):8088 yarn|timelineserver|8188|curl -s http:// ( o t a e f ) 8188 w / 1 t m l n y r | a n p o y s r e | 20888 M p e u e h s o y e v r 19888 c r − h t : / (hostname -f):19888/ws/v1/history/info hive|metastore|9083|thrift:// ( o t a e f ) 9083 i e h v − e v r | 10000 j b : i e : / o a h s : 10000 i e h v − e v r w b I 10002 l n h t : / (hostname -f):10002 spark|spark-history-server|18080|curl http:// ( o t a e f ) 18080 a i v / p l c t o s p r | i y s r e | 8998 l n h t : / o a h s : 8998 m | a o p k s 9700 c r h t : / (hostname -f):9700/kms/v1/keys/names 2-하둡 클러스터 운영 하둡 클러스터를 운영하면서 주의해야 할 사항에 대해서 알아보겠습니다. 네임노드 네임노드는 힙메모리에 HDFS에 존재하는 모든 파일의 메타정보를 저장하고 있습니다. 네임노드 JVM의 히프 메모리 사이즈 1에 따라 전체 파일, 블록의 개수가 제한됩니다. 파일, 블록이 많이 생성되어 메모리의 한계치에 도달하면 JVM의 힙메모리를 늘려야 합니다. 하지만 메모리 설정을 변경하려면 네임노드를 재기 동해야 하고, 네임노드는 재기동 할 때 블록 정보를 재구축하기 위해 fsimage, edits 파일을 읽어서 블록 정보를 재구축합니다. 또한 데이터노드로부터 블록 정보를 받아서 결과를 연동합니다. 이 과정에서 파일 개수가 많을수록 네임노드를 다시 가동하는데 걸리는 시간이 길어지고, 이 시간 동안 클러스터의 운영이 중단됩니다. 파일 개수를 줄이는 방법 Hadoop Archive 이용 하둡은 har 기능을 제공하여 여러 개의 파일을 하나로 묶을 수 있습니다. 사용하지 않는 파일 정리 파일의 접근시간을 이용하여 접근 시간이 오래된 파일을 정리합니다. ls 명령어의 -u 옵션을 이용하여 접근 시간(access time)을 확인할 수 있습니다. 이 방법은 파일이 많으면 네임노드에 부하를 줄 수 있습니다. hadoop fs -ls -u /user/ oiv(offline fsimage viewer)를 이용하여 접근 시간을 확인할 수 있습니다. 네임노드의 현재 상태를 파일로 저장한 내용을 분석하여 접근시간을 확인합니다. hdfs oiv HDFS 연합(Federation) 이용 HDFS 연합 기능은 디렉터리 별로 여러 개의 네임노드를 생성하는 방법입니다. hdfs:///user, hdfs:///datas, hdfs:///temps 같은 3개의 디렉터리를 각각의 네임노드로 서비스합니다. 각 디렉터리 간에는 cp, mv를 할 수 없습니다. distcp를 이용하여 파일을 옮겨야 합니다. 하이브 머지(merge) 기능 이용 하이브는 최종 작업 파일의 사이즈를 확인하여, 지정한 기준 이하의 파일을 하나의 파일로 묶을 수 있습니다. Map, Reduce 작업 이후 Merge 작업이 추가적으로 생성되어 결과 파일을 머지 합니다. 클러스터 장애 대응 네임노드 장애 HDFS는 네임노드가 SPOF로 네임노드에 장애가 발생하면 클러스터가 중단됩니다. 이를 회 파하기 위해서 주키퍼를 이용해 HDFS를 HA 구성으로 설정하는 것이 좋습니다. 사례 1: 데이터노드를 한 번에 재시작하여 네임노드에 장애가 발생함 데이터 노드를 한 번에 재시작하여 네임노드에 데이터노드의 블록 리포팅과 블록 리포팅을 처리하면서 남기는 INFO 로그, 주키퍼의 네임노드 헬스모니터링 RPC 포트와 블록 리포팅 포트가 동일하여 응답시간이 초과되면서 네임노드에 장애가 발생하였습니다. HDFS의 로그를 TRACE로 변경하고, 주키퍼의 RPC 포트를 변경하였습니다. 노드 매니저 장애 사례 1: 리소스 매니저 이전으로 정보가 제대로 반영되지 않아서 장애 발생 HA 구성된 리소스 매니저 중 하나를 변경할 때 노드 매니저가 중단된 리소스 매니저의 정보를 계속 캐슁하여 노드 매니저에 장애가 발생하였습니다. 액티브 리소스 매니저와 스탠바이 리소스 매니저를 순서대로 변경하여 작업의 안정성을 확보하는 것이 좋습니다. 모든 작업은 스테이지에서 테스트 후 운영에 적용하는 것이 좋습니다. 리소스 매니저 장애 사례 1: 주키퍼가 응답하지 않아서 장애가 발생 리소스 매니저가 작업의 정보를 주키퍼에 보관할 때 주키퍼에 너무 많은 데이터가 보관되어 주키퍼가 응답을 하지 않으면서 리소스 매니저에 장애가 발생하였습니다. 완료된 애플리케이션 정보는 저장하지 않고, 주키퍼의 버퍼 설정을 변경하였습니다. 클러스터의 노드 OS 업그레이드 클러스터를 구성하는 노드의 OS 업그레이드는 다음을 고려하여 진행하는 것이 좋습니다. YARN 컨테이너 실행 환경 컨테이너가 실행되는 OS 환경 변수 설지에 유의하여야 합니다. OS 별로 /usr/bin/과 같은 실행 명령어의 위치가 다르기 때문입니다. 하둡 작업 리소스 하둡으로 실행되는 작업은 어떤 OS에서 실행될지 정확하게 알 수 없습니다. OS 버전에 맞는 작업 리소스가 적용될 수 있도록 설정해야 합니다. OS에 의존하는 작업 OS에 설치된 기본 명령어의 버전에 따라 작업 결과가 달라질 수 있습니다. 각 버전에서 작업 결과를 확인해야 합니다. 문제의 가능성이 있는 작업은 사전에 여러 방면으로 테스트를 해보고, YARN 컨테이너의 작업 환경을 통일하는 것이 좋습니다. 클러스터에 장애가 발생하지 않도록 클러스터에서 장비를 안전하게 제거 후 업그레이드를 진행하는 것이 좋습니다. 참고 네이버 - 멀티테넌트 하둡 클러스터 운영 경험기 1만 블록당 1G의 메모리가 사용됩니다. ↩ 1-Line의 클러스터 장애 대응 Line에서 하둡 클러스터를 운영하면서 발생한 장애 상황을 정리한 것입니다. 데이터 엔지니어링 관련 소프트웨어 장애 대응 사례에서 상세한 내용을 확인할 수 있습니다. Apache Hadoop YARN 리소스 매니저 failover 발생 문제와 해결 방안 현상 하둡 클러스터에서 동작하는 애플리케이션의 수가 늘어나면서 리소스 매니저가 주키퍼의 응답에 정상적으로 동작하지 못하여 HA 구성된 리소스 매니저의 Failover 현상이 발생함 Failover가 발생하여 액티브 노드가 스탠바이 노드로 변경 액티브 리소스 매니저가 하트비트를 주키퍼로 전송하지 못해서 오류가 발생 원인 액티브 리소스 매니저의 JVM을 확인 Failover 발생 시 JVM이<NAME> 기록이 없어 GC는 아님 CPU 사용률 등 평소와 큰 차이가 없음 따라서 원인은 리소스 매니저 내부에 있는 것으로 추정 각종 로그 분석 및 JMX metric 모니터링을 통해 Failover 발생 직전 JVM의 스레드 개수가 평소 1,000개에서 15,000개까지 증가한 것을 확인 소스코드 분석 결과 애플리케이션 운영, 컨테이너 정지 시 발생하는 정보 처리를 위한 스레드로 확인 조치 상황 컨테이너 정지 시 발생하는 정보를 처리하지 않도록 hadoop.registry.rm.enabled 설정을 false로 변경 현재 사용 중인 EMR에도 해당 설정은 false임. Apache Hadoop HDFS NameNode failover 발생 문제와 해결 방안 현상 HA 구성된 HDFS 네임노드에 특정 시간대에 Failover 발생 네임노드 헬스 체크가 타임아웃되어 발생 원인 .Trash 하위 데이터를<NAME>는 과정에서 특정 디렉터리를 삭제하면서 write lock이 장시간(36초) 유지됨 그 후에도 블록을 삭제하면서 GC가 1~7초간 발생 네임노드 RPC Client Port 큐를 확인하면 write lock으로 처리되지 않은 큐가 대량(3,500)으로 발생 주키퍼의 헬스 체크 요청 포트와 RPC 클라이언트 포트가 동일하여 장시간 대기가 발생하여 네임노드 Failover 발생 해결 방안 .Trash 디렉터리 하위 파일의 삭제 간격 단축 삭제 간격을 줄여서 많은 데이터가 휴지통에 쌓이기 전에 처리 주키퍼의 헬스 요청 포트 변경 응답 포트를 분리하여 요청에 대응 Apache Zeppelin Notebook 스케줄러 작동 이상 문제와 해결 방안 현상 제플린의 스케 줄리 실행되지 않는 현상 재시작하면 해결됨 원인 로그에서 원인을 확인하지 못해서 JVM 프로세스의 스레드 덤프 확인 Quartz Scheduler Worker 스레드가 모두 sleeping 상태인 것을 확인 버그로 인한 처리 해결 방안 제플린 소스코드를 수정하여 처리 Apache Zeppelin deadlock 발생 문제와 해결 방안 현상 갑자기 제플린이 응답하지 않는 현상이 여러 번 발생 원인 로그에서 원인을 확인하지 못해서 제플린의 JVM 프로세스 스레드 덤프를 확인 데드락이 발생한 것을 확인 해결 방안 소스코드의 수정이 필요하여 OSS에 알림 원인이 발생하는 순서를 사용하지 않는 것을 권고 Apache Spark SQL 성능 이슈와 해결 방안 현상 쿼리 실행이 완료되지 않는 현상이 발생함 파티션을 지정하여도 쿼리가 실행되지 않음 드라이버 프로세스의 CPU 사용률이 100%가 되어 쿼리 실행이 완료되지 않음 확인해 보니 대상 테이블의 조회에 사용되는 파티션 개수가 4,368,000개 원인 JVM의 드라이버 스레드를 확인 특정 스레드가 메모리를 대량으로 사용 쿼리를 분석하고 최적화하는 스레드 쿼리가 실제 파일을 이용하지 않고 파티션의 메타 데이터만을 이용하여 데이터를 산출하도록 최적화 진행 spark.sql.optimizer.metadataOnly=true 일 때 최적화 진행 해결 방안 쿼리의 검색 대상 파티션 수가 많아서 파티션 정보를 수집하는 부하가 높아지면서 GC가 빈번하게 발생함 파티션 수가 많은 테이블을 처리할 때는 spark.sql.optimizer.metadataOnly=false로 설정 2-네이버의 클러스터 장애 대응 네이버에서 발표한 자료를 통해 하둡 클러스터를 운영하면서 주의해야 할 사항에 대해서 알아보겠습니다. 네임노드 네임노드는 힙메모리에 HDFS에 존재하는 모든 파일의 메타정보를 저장하고 있습니다. 네임노드 JVM의 히프 메모리 사이즈(만 블록당 1G의 메모리가 사용)에 따라 전체 파일, 블록의 개수가 제한됩니다. 파일, 블록이 많이 생성되어 메모리의 한계치에 도달하면 JVM의 힙메모리를 늘려야 합니다. 하지만 메모리 설정을 변경하려면 네임노드를 재기 동해야 하고, 네임노드는 재기동 할 때 블록 정보를 재구축하기 위해 fsimage, edits 파일을 읽어서 블록 정보를 재구축합니다. 또한 데이터노드로부터 블록 정보를 받아서 결과를 연동합니다. 이 과정에서 파일 개수가 많을수록 재기동에 걸리는 시간이 길어지고, 이 시간 동안 클러스터의 운영이 중단됩니다. 파일 개수를 줄이는 방법 Hadoop Archive 이용 하둡은 har 기능을 제공하여 여러 개의 파일을 하나로 묶을 수 있습니다. 사용하지 않는 파일 정리 파일의 접근시간을 이용하여 접근 시간이 오래된 파일을 정리합니다. ls 명령어의 -u 옵션을 이용하여 접근 시간(access time)을 확인할 수 있습니다. 이 방법은 파일이 많으면 네임노드에 부하를 줄 수 있습니다. hadoop fs -ls -u /user/ oiv(offline fsimage viewer)를 이용하여 접근 시간을 확인할 수 있습니다. 네임노드의 현재 상태를 파일로 저장한 내용을 분석하여 접근시간을 확인합니다. hdfs oiv HDFS 연합(Federation) 이용 HDFS 연합 기능은 디렉터리 별로 여러 개의 네임노드를 생성하는 방법입니다. hdfs:///user, hdfs:///datas, hdfs:///temps 같은 3개의 디렉터리를 각각의 네임노드로 서비스합니다. 각 디렉터리 간에는 cp, mv를 할 수 없습니다. distcp를 이용하여 파일을 옮겨야 합니다. 하이브 머지(merge) 기능 이용 하이브는 최종 작업 파일의 사이즈를 확인하여, 지정한 기준 이하의 파일을 하나의 파일로 묶을 수 있습니다. Map, Reduce 작업 이후 Merge 작업이 추가적으로 생성되어 결과 파일을 머지 합니다. 클러스터 장애 대응 네임노드 장애 HDFS는 네임노드가 SPOF로 네임노드에 장애가 발생하면 클러스터가 중단됩니다. 이를 회피하기 위해서 주키퍼를 이용해 HDFS를 HA 구성으로 설정하는 것이 좋습니다. 사례 1: 데이터노드를 한 번에 재시작하여 네임노드에 장애가 발생함 데이터 노드를 한 번에 재시작하여 네임노드에 데이터노드의 블록 리포팅과 블록 리포팅을 처리하면서 남기는 INFO 로그, 주키퍼의 네임노드 헬스모니터링 RPC 포트와 블록 리포팅 포트가 동일하여 응답시간이 초과되면서 네임노드에 장애가 발생하였습니다. HDFS의 로그를 TRACE로 변경하고, 주키퍼의 RPC 포트를 변경하였습니다. 노드 매니저 장애 사례 1: 리소스 매니저 이전으로 정보가 제대로 반영되지 않아서 장애 발생 HA 구성된 리소스 매니저 중 하나를 변경할 때 노드 매니저가 중단된 리소스 매니저의 정보를 계속 캐슁하여 노드 매니저에 장애가 발생하였습니다. 액티브 리소스 매니저와 스탠바이 리소스 매니저를 순서대로 변경하여 작업의 안정성을 확보하는 것이 좋습니다. 모든 작업은 스테이지에서 테스트 후 운영에 적용하는 것이 좋습니다. 리소스 매니저 장애 사례 1: 주키퍼가 응답하지 않아서 장애가 발생 리소스 매니저가 작업의 정보를 주키퍼에 보관할 때 주키퍼에 너무 많은 데이터가 보관되어 주키퍼가 응답을 하지 않으면서 리소스 매니저에 장애가 발생하였습니다. 완료된 애플리케이션 정보는 저장하지 않고, 주키퍼의 버퍼 설정을 변경하였습니다. 클러스터의 노드 OS 업그레이드 클러스터를 구성하는 노드의 OS 업그레이드는 다음을 고려하여 진행하는 것이 좋습니다. YARN 컨테이너 실행 환경 컨테이너가 실행되는 OS 환경 변수 설정에 유의하여야 합니다. OS 별로 /usr/bin/과 같은 실행 명령어의 위치가 다르기 때문입니다. 하둡 작업 리소스 하둡으로 실행되는 작업은 어떤 OS에서 실행될지 정확하게 알 수 없습니다. OS 버전에 맞는 작업 리소스가 적용될 수 있도록 설정해야 합니다. OS에 의존하는 작업 OS에 설치된 기본 명령어의 버전에 따라 작업 결과가 달라질 수 있습니다. 각 버전에서 작업 결과를 확인해야 합니다. 문제의 가능성이 있는 작업은 사전에 여러 방면으로 테스트를 해보고, YARN 컨테이너의 작업 환경을 통일하는 것이 좋습니다. 클러스터에 장애가 발생하지 않도록 클러스터에서 장비를 안전하게 제거 후 업그레이드를 진행하는 것이 좋습니다. 참고 네이버 - 멀티테넌트 하둡 클러스터 운영 경험기 3-네임노드 히프 메모리 관리/용량 계산법 HDFS는 네임노드의 히프 메모리 관리가 중요합니다. 보통 백만 블록당 1GB의 메모리를 설정하는 것을 추천합니다. 블록의 개수, 블록의 기본 크기, 파일의 개수에 따라 네임노드의 히프 메모리 사용량이 달라질 수 있기 때문에 상황을 고려해서 적절하게 설정해야 합니다. 파일 사이즈에 따른 히프 메모리 기본 블록 크기가 128MB, 복제 개수는 1일 때 네임노드의 히프 메모리 용량에 대해서 알아보겠습니다. 아래의 경우와 같이 적절한 파일의 개수를 설정하는 것이 중요합니다. 1024MB 파일 1개 파일 inode: 1 개 블록 개수: 1024 / 128 = 8개 9개의 객체 * 150 byte = 1,350 byte 128MB 파일 8개 파일 inode: 8개 블록 개수: 128 / 128 = 1 * 8 = 8개 16개의 객체 * 150 byte = 2,400 byte 1MB 파일 1024개 파일 inode: 1024개 블록 개수: 1 /128 = 1 * 1024 = 1024개 2048개의 객체 * 150 byte = 307,200 byte 복제 개수에 따른 히프 메모리 다음은 복제 개수에 따른 히프 메모리 사이즈의 차이에 대한 설명입니다. 블록 사이즈: 128MB, 복제개수 1 호스트 200개, 블록: 128MB, 복제개수: 1 호스트당 24TB 200 * 24 TB = 4800 TB 복제개수 1이므로 블록당 128MB 필요함 4800TB / 128MB = 36,000,000 백만(1,000,000)블록당 1G 36G의 히프 사이즈가 필요함 블록 사이즈: 128MB, 복제개수 3 호스트 200개, 블록: 128MB, 복제개수: 3 호스트당 24TB 200 * 24 TB = 4800 TB 복제개수 3이므로 블록당 384MB 필요함 4800TB / 384MB = 12,000,000 백만(1,000,000)블록당 1G 12G의 히프 사이즈가 필요함 4-디스크 사이즈 데이터 노드는 디스크를 많이 사용할 것이라고 생각해서 많은 디스크를 설정합니다. 하지만 노드 매니저의 디스크도 애플리케이션에 따라 많은 용량을 사용하기 때문에 적절한 용량을 설정해야 합니다. 스파크 스트리밍 작업에서 발생하는 로그 정보도 일정 기간 쌓이게 되면 무시할 수 없는 수준입니다. 사용자가 로그에 어떤 정보를 출력한다고 하면 더욱 많은 용량이 쌓이게 됩니다. 맵리듀스나 스파크 작업에서 셔플 단계에서 발생하는 데이터도 상당합니다. 셔플을 위한 데이터가 메모리 용량을 넘어서 임시로 디스크에 쌓이게 되면 디스크 부족을 유발할 수 있기 때문에 적절한 용량을 설정해야 합니다. 운영하면서 각 상황에서 단일 애플리케이션의 로그만 60G, 단일 작업의 셔플 데이터만 50G가 쌓인 경우가 있었습니다. 애플리케이션 설계에서 이런 부분을 고려하면 좋겠지만 모든 상황에서 그렇데 될 수 없기 때문에 노드 매니저의 디스크도 적당한 크기로 선택해야 합니다. 5-메모리 사이즈 데이터노드, 노드 매니저가 기본적으로 사용하는 메모리 사이즈도 잘 생각해야 합니다. 처음에는 메모리 사용량이 많지 않지만 운영 일자가 길어지고, 데이터가 많아질수록 메모리 사용량도 점점 증가하게 됩니다. 노드 매니저에 할 당할 수 있는 기본 메모리를 설정할 때 데이터 노드와 같은 노드에 동작하고 있다면 데이터 노드와 노드 매니저 OS 가 기본적으로 사용하는 메모리를 생각하고 메모리를 할당해야 합니다. 데이터노드: 15~20G 노드 매니저: 10~15G OS: 메모리 4G 여기에 추가 여유분 메모리를 생각해서 노드 매니저의 메모리를 할당해야 합니다. <property> <name>yarn.nodemanager.resource.memory-mb</name> <value>102400</value> </property> 3-하둡 작업 애플리케이션 운영 하둡 작업 시간이 오래 걸릴 때 확인해야 할 사항을 알아보겠습니다. 클러스터 작업 제출 여부 확인 클러스터에 작업이 제출되고 AM이 할당되고, AM이 작업을 분석하여 맵리듀스 작업이 시작되는지 확인해야 합니다. YARN에 작업이 제출되어도 AM이 실행되지 않고, ACCEPTED 상태로 대기할 수 있습니다. 두 가지 원인이 있을 수 있습니다. 클러스터에 여유가 없을 때 스케줄러의 설정에 의해 AM이 할당되지 않을 때 클러스터에 여유가 없을 때 클러스터가 100% 활용되고 있어서 다른 작업을 처리할 수 없을 때입니다. 이 경우는 클러스터를 증설하지 않으면 작업 속도를 높이기 힙듭니다. 클러스터를 증설할 수 없다면 맵리듀스 작업을 효율화해야 합니다. 스케줄러의 설정에 의해 AM이 할당되지 않을 때 스케줄러는 클러스터를 효율적으로 사용하기 위해서 AM을 할당할 수 있는 비율을 제한하고 있습니다. AM이 사용할 수 있는 자원을 제한하여 실제 맵리듀스를 처리하는 컨테이너를 많이 생성하도록 하는 것입니다. 이 경우 AM을 할당할 수 있는 비율을 늘려서 자원을 활용할 수 있게 해도 되고, 기존 큐와 다른 설정을 가지는 큐를 생성하여 기존 설정에 영향이 없도록 할 수 있습니다. 작업 시간 확인 맵리듀스 작업이 RUNNING 상태에서 오래 걸리는 경우에는 다양한 원인이 있을 수 있습니다. 클러스터를 100% 활용하지 못할 때 원천 데이터 사이즈가 너무 클 때 맵퍼, 리듀서 개수가 적절하지 못할 때 컨테이너 메모리가 부족할 때 정규식 함수 처리에 오래 걸릴 때 많은 파일 수로 발생하는 문제 네트워크 사용량이 많을 때 하나의 노드에 작업이 몰릴 경우 클러스터를 100% 활용하지 못할 때 클러스터를 100% 활용하지 못하는 경우는 스케줄러 설정을 따르는 경우입니다. 커패시티 스케줄러는 maximum-capacity 설정을 통해 큐가 사용할 수 자원의 상한선을 가지고 있습니다. 이 설정을 확인하여 적절한 값으로 변경해야 합니다. 원천 데이터 사이즈가 너무 클 때 작업의 대상이 되는 원천 데이터 사이즈가 너무 큰 경우 작업이 오래 걸릴 수 있습니다. 실제 작업의 입력 파일 크기와 개수가 큰 경우에는 작업 시간을 줄일 수 없습니다. 하이브 작업은 디렉터리 단위로 데이터를 입력받기 때문에 작업 조건을 제한하여 원천 사이즈를 줄여 주는 것이 좋습니다. 하이브의 파티셔닝, 버켓팅을 적절히 활용하여 일 단위, 큰 카테고리 단위로 파일을 나누어 준다면 작업 조건에 따라 입력하는 파일 사이즈와 개수를 줄일 수 있습니다. 맵퍼, 리듀서 개수가 적절하지 못할 때 입력 데이터의 크기에 비해 매퍼의 개수가 작거나, 리듀서로 입력되는 데이터 크기에 비해 리듀서의 개수가 작을 때 작업시간이 오래 걸릴 수 있습니다. 하이브 tez는 1G당 1개의 매퍼를 생성합니다. 데이터의 압축률 맵퍼에서 처리되는 함수의 종류에 따라 512MB나 256MB로 줄여주면 성능이 빨라질 수 있습니다. 하이브의 UDTF 함수에 의해 입력 데이터보다 많은 수의 출력 데이터가 생성되는 경우에도 맵퍼의 개수를 늘려주면 작업시간이 빨라집니다. 컨테이너 메모리가 부족할 때 맵퍼, 리듀서에서 실행되는 작업이 메모리를 많이 사용하는 경우 과도한 GC가 발생하여 작업 시간이 오래 걸릴 수 있습니다. 하이브에서 UDAF, UDTF 함수를 사용할 때 내부에서 많은 메모리를 사용하게 되고, 메모리 버퍼를 넘어서는 데이터가 발생하여 이를 로컬에 임시파일로 쓰고, 메모리를 정리하는 과정을 거치면서 작업시간이 느려질 수 있습니다. 이때는 JVM 옵션을 수정하여 힙메모리를 늘려주면 작업시간이 빨라집니다. 정규식 함수 처리에 오래 걸릴 때 정규식은 편리하지만 특정 조건에서 정규식의 연산이 많아져서 시간이 오래 걸릴 수 있습니다. 처리 시간을 보장하는 정규식 라이브러리를 이용하거나, 정규식 대상이 되는 문자열의 길이를 제한하는 방법 등으로 정규식을 튜닝하여 문제를 해결할 수 있습니다. 많은 파일 수로 발생하는 문제 맵리듀스, 셔플 단계에서 발생하는 임시 파일이 많아지면 잦은 I/O로 인하여 작업이 느려질 수 있습니다. 이 경우 임시 파일을 압축하거나, 메모리에 저장하는 방법을 이용하는 것이 좋습니다. 임시 파일이 많아지면 잦은 I/O가 발생하여 작업이 느려집니다. 임시 파일이 많아져서 노드의 i-node가 부족해지는 경우도 있습니다. 마스터 노드의 경우 각종 서비스에서 발생하는 로그, 라이브러리 등 많은 파일이 있기 때문에 각 작업용 디스크를 분리해 주는 것도 좋습니다. 네트워크 사용량이 많을 때 맵리듀스와 HDFS는 작업 라이브러리 복사, HDFS 블록 복사, 내부 메시지 처리 등 네트워크 통신이 끊임없이 처리됩니다. 또한 S3, NAS 같은 외부 저장소에 저장된 대용량 데이터를 복사할 때도 네트워크를 이용합니다. 따라서 네트워크 대역폭이 작을 때는 데이터 이동 시간이 오래 걸릴 수 있습니다. 적절한 네트워크 대역폭을 구성하는 것이 중요합니다. 하나의 노드에 작업이 몰릴 경우 스케줄러의 노드 레이블 구성으로 인하여 특정 노드로 작업이 몰리는 경우 작업 시간이 느려질 수 있습니다. 하나의 노드에 작업이 집중되면 과부하가 발생하여 통신 포트가 마비될 수도 있습니다. 작업을 적절히 분배할 수 있도록 설정해야 합니다. 작업 튜닝 맵리듀스, 하이브 작업은 다음과 같은 방법을 통해 성능을 높일 수 있습니다. 맵리듀스 매퍼, 리듀서 수 설정 정렬 속성 튜닝 컴파이너 클래스 적용 맵 출력 데이터 압축 small file 문제 수정 하이브 작업 엔진 선택: TEZ 엔진 사용 파일 저장 포맷: ORC 파일 사용 데이터 처리 방식: 벡터화(Vectorization) 사용 데이터 저장 효율화: 파티셔닝, 버켓팅 사용 통계정보 이용: 하이브 stat 사용 옵티마이저 이용: CBO YARN: 작업 큐 설정 1-하이브 성능 최적화-ETL 성능 향상 팁-NC soft NC 소프트에서 공개한 Hive와 RDBMS의 ETL 팁을 정리했습니다. ETL 성능 향상을 위한 몇 가지 팁들 HiveQL 측면에서 성능 향상하기 조건절 내의 UDF 제거 where 조건절에 UDF를 사용하면 하이브 옵티마이저는 정보를 이용할 수 없어서 파티션 가지치기(Partiton Pruning)이 발생하지 않습니다. 따라서 많은 양의 데이터를 읽어야 하기 때문에 성능에 나쁜 영향을 주게 됩니다. DISTINCT COUNT 연산 피하기 COUNT(DISTINCT column) 함수를 이용하면 하나의 리듀서에서 정보를 처리하기 때문에 작업이 느려질 수 있습니다. GROUP BY 함수를 이용한 방법으로 처리하는 것이 좋습니다. JOIN 사용 시 고려할 점 하이브 옵티마이저는 가장 마지막의 테이블이 가장 크다고 가정합니다. 가장 큰 데이터의 테이블을 마지막에 놓거나 /*+STREAMTABLE(a)*/ 옵션을 이용하면 좋습니다. 아웃 조인 시 조인 수행 후 WHERE 조건을 처리하기 때문에 중첩 SELECT 문을 이용해 먼저 데이터를 필터링 후 조인을 진행하도록 처리하는 것이 좋습니다. SELECT 사용 시 고려 사항 *를 이용해 모든 데이터를 가져오지 않고, 필요한 칼럼 데이터만 가져오는 것이 좋습니다. RDBMS 쿼리 측면에서 성능 향상하기 불필요한 인덱스 줄이기 인덱스는 DDL 문의 성능에 안 좋은 영향을 주고, Nested Loops Join을 이용하게 될 수 있기 때문에 적절한 수의 인덱스를 선언하는 것이 좋습니다. WHERE 조건에서 함수 피하기 함수를 이용하면 정확한 카디날리티를 얻을 수 없기 때문에 옵티마이저가 안 좋은 선택을 하게 할 수 있습니다. OR 조건 피하기 OR 조건은 최적화되지 않은 실행계획을 만들 수도 있습니다. OR 조건은 UNION 문을 대체하면 더 빠를 수도 있습니다. ETL 작업 측면에서 성능 향상하기 2-HDFS의 Heterogeneous Storage 적용기 - Pinpoint 비용 효율화 네이버에서 공개한 HDFS를 이종 저장 공간을 이용하여 성능을 높이는 방법을 정리하였습니다. # HDFS의 Heterogeneous Storage 적용기 - Pinpoint 비용 효율화 이종 저장 공간(Heterogeneous Storage) 적용 스토리지 유형 지정 스토리지 정책 지정 데이터 이동 적용 효과 비용 효율성 향상 데이터 처리 속도 향상 데이터 티어링 개발 비용과 운영의 최소화 9-참고 설정 자료 HDFS NameNode HA 구성 Hadoop3 Installing hadoop3 - 하둡 3 설정 국내 자료 라인 - 데이터 엔지니어링 관련 소프트웨어 장애 대응 사례 해외 자료 Shifting to Hive Part II: Best Practices and Optimizations 하이브 최적화 방안<|endoftext|>

전문분야 텍스트 ### 제목: WikibooksHaskell ### 본문: 소개 이 책은 wikibooks의 하스 켈 책을 번역한 것입니다. 원문의 라이선스를 따라 이 책의 라이선스도 CCL BY-SA(저작자 표시, 동일 조건 변경 허락, 상업적 이용 제한 없음)입니다. 1차 번역을 완료했습니다. 페이지 번호를 붙일 때 원문이 아예 누락된 것들은 건너뛰어 붙였습니다. Beginner's Track은 대부분 내용이 완성되어 있습니다. Advanced Track은 저도 제대로 이해하지 못하고 옮긴 내용이 많아서 참고만 하고 원문을 읽는 것을 추천드립니다. 다만 원문도 미완성인 경우가 많습니다. Haskell in Practice은 난해한 내용은 없지만 원문이 미완성이거나 낡은 정보인 경우가 많습니다. 진행 상황 초급반 - 34/34 완료 하스 켈 기초 - 9/9 완료 하스 켈 초급 - 9/9 완료 하스 켈 중급 - 7/7 완료 모나드 - 9/9 완료 고급반 - 28/38 완료 하스 켈 고급 - 11/16 완료 (5개는 원문 없음) 타입과의 유희 - 6/7 완료 (1개는 원문 없음) 여러 이론들 - 4/6 완료 (2개는 원문 없음) 하스 켈 성능 - 7/9 완료 (2개는 원문 없음) 하스 켈 실전 - 16/17 완료 라이브러리 레퍼런스 - 7/7 완료 일반 작업 - 5/5 완료 특수 작업 - 4/5 완료 (1개는 원문 없음) 기타 하스 켈 자료 Real World Haskell 온라인 책 하스켈위키 타입 백과(HaskellWiki Typeclassopedia) 하스켈을 배울 때 알았더라면 좋았을 것들(What I Wish I Knew When Learning Haskell) Parallel and Concurrent Programming in Haskell 1 초급반 여기서는 하스켈의 기초와 자주 쓰이는 라이브러리들을 소개합니다. 초급반을 마치고 나면 간단한 하스 켈 프로그램을 작성할 수 있게 될 것입니다. 대부분의 장은 실전 연습을 위한 연습문제와 해답을 포함합니다. 목차 하스 켈 기초 환경 갖추기(Getting set up) 변수와 함수(Variables and functions) 진위 값(Truth values) 타입의 기초(Type basics) 리스트와 튜플(Lists and tuples) 타입의 기초 2(Type basics II) 다음 과정(Next steps) 어휘 쌓기(Building vocabulary) 간단한 입출력(Simple input and output) 하스 켈 초급 재귀(Recursion) 리스트 보충 설명(More about lists) 리스트 처리(List processing) 타입 선언(Type declarations) 패턴 매칭(Pattern matching) 제어 구조(Control structures) 함수 보충 설명(More on functions) 고차 함수(Higher order functions) GHCi 효율적으로 사용하기(Using GHCi effectively) 하스 켈 중급 모듈(Modules) 독립 실행 프로그램(Standalone programs) 들여 쓰기(Indentation) 데이터 타입 보충 설명(More on datatypes) 다른 자료구조들(Other data structures) 클래스와 타입(Classes and types) Functor 클래스(The Functor class) 모나드 서장: IO, 이른바 적용성 펑 터 모나드 이해하기 Maybe - List do 표기 IO - State Alternative와 MonadPlus 모나드 변환기 1 하스 켈 기초 하스 켈 기초 환경 갖추기(Getting set up) 변수와 함수(Variables and functions) 진위 값(Truth values) 타입의 기초(Type basics) 리스트와 튜플(Lists and tuples) 타입의 기초 2(Type basics II) 다음 과정(Next steps) 어휘 쌓기(Building vocabulary) 간단한 입출력(Simple input and output) 1 환경 갖추기 원문: https://en.wikibooks.org/wiki/Haskell/Getting_set_up 원문에서는 Haskell Platform 설치를 추천하지만 실 사용자들 사이에는 이에 반하는 의견이 많이 나오고 있습니다. 참고: https://mail.haskell.org/pipermail/haskell-community/2015-September/000014.html Haskell Platform은 2022년에 폐기되고 GHCup으로 대체되었습니다. 이 장에서는 하스 켈로 코딩을 시작하기 위해 필요한 프로그램을 설치하는 방법을 설명한다. 하스 켈 설치하기 하스켈은 프로그래밍 언어, 즉 컴퓨터가 어떻게 행동하라고 사람이 의사를 표현할 수 있는 언어다. 요리법을 작성하는 것과 비슷하다. 우리는 요리법을 작성하고 컴퓨터는 그것을 시행한다. 하스 켈 프로그램을 사용하려면 하스 켈 컴파일러라는 특별한 프로그램이 필요하다. 컴파일러는 하스 켈로 작성된 코드를 받아 기계어로 변환한다. 기계어는 컴퓨터가 이해하는 보다 원시적인 언어다. 요리법에 다시 비유해 보면 우리는 요리법(하스 켈 프로그램)을 작성하고 요리사(컴파일러 프로그램)는 재료들을 모아서 먹을 수 있는 요리(실행 가능한 파일)로 만들어낸다. 물론 완성된 요리로부터 그 요리법을 쉽게 얻어낼 수는 없다(그리고 하스 켈 프로그램 코드를 컴파일하여 실행 가능한 파일로 만들어낸 뒤에는 그 코드를 다시 얻어낼 수 없다). 하스 켈 공부를 시작하려면 하스 켈 플랫폼을 내려받고 설치해야 한다. 이 플랫폼에는 "Glasgow Haskell Compiler" 즉 GHC, 그리고 우리에게 필요한 그 외 모든 것이 포함되어 있다. 다운로드 및 설치 없이 하스켈의 기본을 테스트해 보고 싶다면 Haskell.org 홈페이지에서 간단한 인터프리터를 제공한다. 이 위키 책의 설명은 완전한 GHC를 설치했다고 가정하지만 기초적인 것들은 웹사이트 버전에서도 작동한다. 잠깐 UNIX 유저에게: 소스를 직접 컴파일하는 것을 선호한다면 GHC에 대해서는 별로 좋은 생각이 아니다. 특히 GHC를 처음 설치하는 거라면 더욱 그렇다. GHC 자체가 대부분 하스 켈로 작성되었기 때문에 소스로부터 GHC를 직접 부트스트랩 하는 것은 아주 어렵다. 게다가 빌드 과정이 상당히 오래 걸리고 디스크 공간을 많이 소비한다. 그래도 정말로 GHC를 소스로부터 빌드 하고 싶다면 GHC 홈페이지의 Building and Porting GHC를 볼 것. 요약하자면, 소스로부터 컴파일하는 대신 그냥 하스 켈 플랫폼을 내려받는 것을 강력히 추천한다. 걸음마 떼기 하스 켈 플랫폼을 설치했으면 GHCi라는('i'는 '반응형 interactive'을 뜻함) 프로그램으로 첫 번째 하스 켈 코드를 작성해 보자. 다음 중 여러분의 운영체제에 맞는 절차를 따르면 된다. 윈도우즈: Start - Run을 누르고 'cmd'를 입력한 후 엔터를 누른다. ghci를 입력하고 엔터를 한 번 더 누른다. 맥 OS: "Applications/Utilities" 폴더의 "Terminal" 애플리케이션을 연다. 나타나는 창에 ghci를 입력하고 엔터 키를 누른다. 리눅스: 터미널을 열고 ghci 프로그램을 실행한다. 그러면 이런 것이 출력될 것이다. GHCi, version 8.10.7: http://www.haskell.org/ghc/ :? for help Prelude> 첫 번째 줄은 GHCi 버전이고 GHCi에서 도움말을 얻는 방법을 알려준다. Prelude> 부분은 프롬프트(prompt)라고 한다. 여기에 명령을 입력하면 GHCi는 그에 반응해 결과를 내놓는다. 이 프롬프트는 지금 로드된 모듈이 Prelude라는 것도 표시한다. Prelude는 대부분의 내장 함수에 대해 접근할 수 있게 해준다. 이제 간단한 산수를 해보자. Prelude> 2 + 2 Prelude> 5 + 4 * 3 17 Prelude> 2 ^ 5 32 이 연산자들은 대부분의 다른 언어에 있는 연산자들과 같다. +는 더하기, *는 곱하기, ^는<NAME>(즉 b )다. 두 번째 예시에서 하스켈이 표준 연산 순서(예를 들면 더하기보다 곱하기 먼저)를 따른다는 것을 볼 수 있다. 이제 하스켈을 계산기로 쓰는 방법을 알게 되었다. 사실 하스켈은 기본적으로 계산기다. 다만 숫자뿐 아니라 문자, 리스트, 함수, 트리, 심지어 다른 프로그램까지 처리하는 매우 강력한 계산기다(이 용어들이 익숙하지 않아도 걱정할 필요 없다). GHCi를 떠나려면 :quit 또는 :q를 입력한다. Prelude> :quit Leaving GHCi. GHCi는 강력한 개발 환경이다. 진도를 나아감에 따라 소스 코드가 들어있는 파일을 GHCi로 불러오고 파일들의 각 부분을 평가(evaluate) 하는 방법을 배울 것이다. 지금까지 잘 따라왔다면(그렇지 않다면 talk page를 통해 이 위키 책을 개선하는 것을 도와주세요!), 다음 장을 읽을 준비가 된 것이다. 다음 장에서는 함수를 포함해 하스켈의 몇 가지 기본 개념을 소개한다. 2 변수와 함수 원문: http://en.wikibooks.org/wiki/Haskell/Variables_and_functions 변수(variable) 하스 켈 소스 파일 주석(comment) 명령형 언어의 변수 함수(function) 평가(evaluation) 다중 매개변수 함수 합성에 관해서 지역 정의(local definition) where 절 스코프(scope) 요약 이 장의 모든 예제는 하스 켈 소스 파일에 입력하고 그 파일을 GHC로 불러와서 평가할 수 있다. 어떤 예제든 "Prelude>" 프롬프트는 소스에 포함하는 게 아니다. 이 프롬프트는 GHCi 같은 환경에 해당 코드를 입력할 수 있다는 뜻이다. 그 외의 경우에는 코드를 파일에 넣고 그 파일을 실행해야 한다. 변수(variable) 앞선 장에서 GHCi를 계산기로 활용했다. 물론 이런 것은 짧은 계산에나 쓸모가 있다. 더 긴 계산을 하거나 하스 켈 프로그램을 작성하려면 중간 결과들을 보관해야 한다. 중간 결과에 이름을 할당하면 그 결과를 보관할 수 있다. 이런 이름을 변수라고 부른다. 프로그램을 실행하면 각 변수는 그 변수가 가리키는 값으로 치환된다. 다음 계산을 보자. Prelude> 3.141592653 * 5^2 78.539816325 이 값은 반지름 5인 원의 대략적인 넓이로서 = r이라는 공식에 따른 것이다. π≒3.141592653의 자릿수들을 입력하는 것은 성가시고 처음 몇 자리를 기억하는 것조차 귀찮은 일이다. 프로그래밍은 무의미한 반복과 암기를 기계에 위임한다. 지금 같은 경우 하스켈은 이미 π를 수십 자리까지 보관하는 pi라는 변수를 포함한다. pi를 쓰면 코드가 더 깔끔할 뿐 아니라 정밀도도 높다. Prelude> pi 3.141592653589793 Prelude> pi * 5^2 78.53981633974483 변수 pi와 그 값 3.141592653589793는 계산에서 서로 바꿔 쓸 수 있다. 하스 켈 소스 파일 두고두고 쓸 코드를 작성했으면 확장자가. hs인 하스 켈 소스 파일에 그 코드를 저장한다. 기본적으로. hs 파일은 평문(plain text)이다. 코딩에 적합한 텍스트 에디터를 이용해 이 파일들을 작업하면 된다. (텍스트 에디터에 대한 위키피디아 글을 읽어보자) 괜찮은 소스 코드 에디터들은 읽고 이해하기 쉽도록 코드를 색칠하는 구문 하이라이팅(syntax highlighting)을 제공한다. 하스 켈 프로그래머 사이에선 Vim과 Emacs가 인기 있다. 깔끔하게 정리하기 위해 컴퓨터에 디렉터리(즉 폴더)를 하나 만들고, 앞으로 이 책에서 연습문제를 풀며 만들 하스 켈 파일들을 여기에 저장하자. 디렉터리 이름은 HaskellWikibook 정도면 될 것이다. 이 디렉터리에 Varfun.hs라는 파일을 만들고 다음 코드를 입력한다. r = 5.0 이 코드는 변수 r을 값 5.0으로서 정의한다. 잠깐: 줄의 시작 부분에 공백이 없는지 확인하자. 하스켈은 공백에 민감하다. 그다음 터미널에서 HaskellWikibook 디렉터리로 이동하여 GHCi를 열고 :load 명령으로 Varfun.hs 파일을 불러온다. Prelude> :load Varfun.hs [1 of 1] Compiling Main ( Varfun.hs, interpreted) Ok, modules loaded: Main. :load는 :l로 축약할 수 있다. (:l Vafun.hs처럼) GHCi가 Could not find module 'Varfun.hs' 같은 오류를 내뱉는다면 GHCi를 다른 디렉터리에서 실행했거나 파일을 다른 디렉터리에 저장한 것이다. GHCi 안에서 :cd 명령을 써서 디렉터리를 변경할 수 있다. (예: :cd HaskellWikibook) 파일을 불러왔으면 GHCi의 프롬프트가 "Prelude"에서 "*Main"으로 변한다. 이제 새로 정의한 변수 r을 계산에 활용할 수 있다. *Main> r 5.0 *Main> pi * r^2 78.53981633974483 잘 알려진 공식 = r 을 사용해서 반지름 5.0인 원의 넓이를 계산했다. 이것이 작동하는 이유는 우리가 Varfun.hs 파일에 r을 정의했고 pi는 표준 하스 켈 라이브러리에 있기 때문이다. 넓이 공식에 대한 변수 이름을 정의해서 이 공식에 접근하기 더 쉽게 만들어보자. 소스 파일의 내용을 이렇게 변경한다. r = 5.0 area = pi * r ^ 2 파일을 저장한다. 파일을 로드했던 GHCi를 아직 실행 중이라면 :reload (짧게는 :r) 명령을 입력한다. *Main> :reload Compiling Main ( Varfun.hs, interpreted) Ok, modules loaded: Main. *Main> 이제 r과 area라는 두 변수를 쓸 수 있게 되었다. *Main> area 78.53981633974483 *Main> area / r 15.707963267948966 잠깐 let 키워드(특별한 뜻이 있는 단어)로 GHCi 프롬프트에서 소스 파일 없이 바로 변수를 정의할 수 있다. Prelude> let area = pi * 5 ^ 2 편리할 때도 있지만 GHCi에서 이런 식으로 변수를 할당하는 것은 복잡한 작업에는 실용적이지 않다. 보통은 소스 파일을 사용한다. 주석(comment) 소스 파일은 작동하는 코드 외에도 주석을 포함할 수 있다. 하스켈에는 주석이 두 종류 있다. 하나는 --으로 시작하고 그 줄이 끝날 때까지 이어진다. x = 5 -- x is 5. y = 6 -- y is 6. -- z = 7 -- z is not defined. 여기서 x와 y는 실제 하스 켈 코드에 정의되지만 z는 그렇지 않다. 두 번째 종류의 주석은 {- ... -}로 감싸는 것이며 여러 줄로 확장할 수 있다. answer = 2 * {- block comment, crossing lines and... -} 3 {- inline comment. -} * 7 주석은 프로그램 일부를 설명하거나 문맥상 어떤 기록을 남기기 위해 사용한다. 주석이 너무 많으면 프로그램을 읽는 것이 오히려 힘들어지기 때문에 남용을 주의해야 한다. 또한 코드를 변경하면 그에 대응하는 주석도 신중히 수정해야 한다. 낡은 주석은 큰 혼동을 일으킬 수 있다. 명령형 언어의 변수 명령형(imperative) 프로그래밍에 익숙한 독자는 하스켈의 변수가 C 같은 언어의 변수와 상당히 다르다는 것을 눈치챘을 것이다. 여러분이 프로그래밍 경험이 없다면 이 절을 건너뛰어도 되지만, 사람들이 하스켈을 다른 프로그래밍 언어와 비교하는 많은 경우(예를 들면 대부분의 하스 켈 교재)에서 일반적인 상황을 이해하는 데 도움이 될 것이다. 명령형 프로그래밍은 변수를 컴퓨터 메모리 안의 변경 가능 장소로 취급한다. 이 접근법은 컴퓨터의 기본적인 동작 원리와 연결된다. 명령형 프로그램은 컴퓨터가 할 일을 명시한다. 고수준 명령형 언어들은 직접적인 컴퓨터 어셈블리 코드와 꽤 멀어졌지만 단계별로 생각하는 방식은 동일하다. 이와 달리 함수형 프로그래밍은 고수준 수학적 도구를 통해 사고하는 방법을 제공하며, 변수들이 서로 어떻게 연결되는지를 정의하고 이것을 컴퓨터가 처리할 수 있는 단계별 명령으로 번역하는 일은 컴파일러에게 맡긴다. 예시를 하나 보자. 다음 코드는 하스켈에서 작동하지 않는다. r = 5 r = 2 명령형 프로그래머는 이것을 처음에는 r = 5로 설정하고 그다음 r = 2로 변경한다고 읽을 것이다. 하스켈에서 위 코드는 "r의 중복 선언"이라는 오류를 뱉는다. 주어진 스코프 안에서 한 하스 켈 변수는 한 번만 정의할 수 있고 변경 불가능하다. 하스켈의 변수는 거의 변수가 아닌 것처럼 보이지만 사실은 수학의 변수 같은 것이다. 수학 교실에서 우리는 한 문제 안의 어떤 변수가 그 값을 바꾸는 것은 본 적이 없다. 정확히 말하면 하스 켈 변수는 불변 immutable이다. 하스 켈 변수는 우리가 프로그램에 입력하는 데이터에 의해서만 변한다. r을 한 코드에서 두 방법으로 정의할 수는 없지만 파일을 변경해서 변수의 값을 바꿀 수는 있다. 위 코드를 다음과 같이 변경해 보자. r = 2.0 area = pi * r ^ 2 물론 여기에는 문제가 없다. r이 정의된 곳에서 r을 수정하면 코드의 나머지 부분에서 r을 이용하는 모든 값이 자동으로 갱신된다. 현실의 하스 켈 프로그램에서는 일부 변수들을 코드에 명시하지 않는다. 그 값은 프로그램이 외부 파일, 데이터베이스, 사용자 입력으로부터 데이터를 얻을 때 정의된다. 하지만 지금은 변수를 내부에 정의하는 방식을<NAME>다. 외부 데이터와의 상호작용은 나중에 다룰 것이다. 다음은 명령형 언어와의 주된 차이점을 보여주는 또 다른 예시다. r = r + 1 이 하스 켈 코드는 "변수 r을 증가시키는" (즉 메모리 내 값을 갱신하는) 것이 아니라 r의 재귀적 정의다. (즉 r을 이용해 r을 정의) 재귀는 나중에 자세히 설명한다. 여기서 만약 r을 다른 값으로 앞서 정의했다면 r = r + 1은 오류 메시지를 뱉었을 것이다. r = r + 1은 수학적으로 말하자면 5 = 5 + 1 같은 것인데, 분명히 잘못된 것이다. 변수들의 값이 프로그램 내에서 변하지 않기 때문에 어떤 순서로도 정의할 수 있다. 예를 들어 다음 코드들은 정확히 같은 일을 한다. y = x * 2 x = 3 x = 3 y = x * 2 하스켈에는 "x를 y보다 먼저 선언한다"라는 개념이 없다. 물론 y를 사용하려면 여전히 x의 값이 필요하지만 이는 특정 숫자 값이 필요하기 전에는 중요하지 않은 일이다. 함수(function) 새 원의 넓이를 구할 때마다 프로그램을 변경하는 것은 지루하고 한 번에 원 한 개만 계산한다는 한계가 있다. 코드를 복사해서 두 번째 원을 위한 새 변수 r2와 area2를 만들면 원 2개를 계산할 수 있다. 1 r = 5 area = pi * r ^ 2 r2 = 3 area2 = pi * r2 ^ 2 물론 이런 생각 없는 반복을 없애려면 넓이을 계산하는 함수는 하나만 있고 이 함수를 서로 다른 반지름에 적용해야 한다. 함수는 인자(argument) 값(또는 매개변수(parameter))을 취해서 결괏값을 돌려준다. (그 본질은 수학의 함수와 같다) 하스켈에서 함수를 정의하는 것은 변수를 정의하는 것과 비슷하지만 좌변에 함수 인자를 놓는다는 점이 다르다. 예를 들면 다음은 r이라는 인자에 의존하는 함수 area를 정의한다. area r = pi * r ^ 2 문법을 자세히 보면 함수 이름(여기서는 area)이 가장 먼저 나오고 그다음 공백 한 칸과 인자(여기서는 r)가 나온다. = 기호 다음의 함수 정의는 그 인자를 이미 정의된 다른 용어들과 함께 이용하는 하나의 공식이다. 이제 인자에 서로 다른 값들을 넣어서 이 함수를 호출할 수 있다. 이 코드를 파일에 저장하고 GHCi로 파일을 불러와서 다음을 시도해 보자. *Main> area 5 78.53981633974483 *Main> area 3 28.274333882308138 *Main> area 17 907.9202768874502 함수에 서로 다른 반지름을 넣어서 호출하면 어떤 원의 넓이든 계산할 수 있다. 우리의 함수는 수학적으로는 다음과 같이 정의된다. = r 수학에서는 A(5) = 78.54 또는 A(3) = 28.27처럼 매개변수를 괄호로 감싼다. 하스 켈 코드는 괄호가 있어도 작동하지만 이 책에서는 관례에 따라 생략한다. 하스켈은 어디서든 함수를 사용하며 우리는 가능하다면 여분의 기호를 줄이고자 한다. 반드시 함께 평가해야 하는 표현식(값을 돌려주는 임의의 코드)들의 경우에는 여전히 괄호를 사용한다. 다음 표현식들이 어떻게 서로 다르게 해석되는지 눈여겨보자. 5 * 3 + 2 -- 15 + 2 = 17 (곱셈을 덧셈보다 먼저) 5 * (3 + 2) -- 5 * 5 = 25 (괄호 덕분에) area 5 * 3 -- (area 5) * 3 area (5 * 3) -- area 15 하스 켈 함수들은 +나 * 같은 모든 연산자보다 우선순위를 부여받는 것에 유의하라. 이는 수학에서 곱셈이 덧셈보다 먼저 되는 것과 같은 방식이다. 평가(evaluation) GHCi에 표현식을 입력하면 정확히 무슨 일이 일어나는 걸까? 엔터 키를 누르면 GHCi는 우리가 제공한 표현식을 평가한다. 이 말은 각각의 함수를 그 정의로 치환하고 단일 값이 남을 때까지 결과를 계산한다는 뜻이다. 예를 들어 area 5의 평가는 다음과 같이 진행된다. area 5 => { replace the left-hand side area r = ... by the right-hand side ... = pi * r^2 } pi * 5^2 => { replace pi by its numerical value } 3.141592653589793 * 5^2 => { apply exponentiation (^) } 3.141592653589793 * 25 => { apply multiplication (*) } 78.53981633974483 여기서 볼 수 있듯이 함수를 적용(apply) 하거나 호출(call) 한다는 것은 함수 정의의 좌변을 우변으로 치환한다는 뜻이다. GHCi를 사용할 때는 함수의 결과가 화면에 나타난다. 여기 함수가 몇 개 더 있다. double x = 2 * x quadruple x = double (double x) square x = x * x half x = x / 2 연습문제 GHCi가 quadruple 5를 어떻게 평가하는지 설명하라. 인자를 반으로 나누고 12를 빼는 함수를 작성하라. 다중 매개변수 함수는 인자를 하나보다 많이 가질 수 있다. 예를 들어 이 함수는 직사각형의 길이와 너비를 받아 그 넓이를 계산한다. areaRect l w = l * w *Main> areaRect 5 10 50 이 예제는 삼각형의 넓이 ( = h) 를 계산한다. areaTriangle b h = (b * h) / 2 *Main> areaTriangle 3 9 13.5 여기서 볼 수 있듯이 인수들은 공백으로 구분된다. 이것이 표현식을 묶기 위해 괄호를 쓰기도 해야 하는 이유다. 예를 들어 x를 네 제곱하려면 단순히 이렇게 쓸 수는 없다. quadruple x = double double x -- error 이러면 double이라는 함수를 두 인자 double과 x에 적용하게 된다. 함수도 다른 함수의 인자가 될 수 있다는 것에 유의하라. (그 이유는 나중에 볼 것이다) 지금은 이 예제가 작동하도록 하기 위해 인자를 괄호로 둘러싸야 한다. quadruple x = double (double x) 인자는 항상 주어진 순서대로 전달된다. 예를 들어 subtract x y = x - y *Main> subtract 10 5 *Main> subtract 5 10 -5 여기서 subtract 10 5는 10 - 5로 평가되지만 subtract 5 10은 5 - 10으로 평가되는데 그 순서가 바뀌었기 때문이다. 연습문제 상자의 부피를 계산하는 함수를 작성하라. 기자(Giza)에 있는 유명한 피라미드를 이루는 돌은 대략 몇 개일까? 힌트: 피라미드의 부피와 각각의 블록의 부피에 대한 추정치가 필요하다. 함수 합성에 관해서 물론 우리가 앞서 정의한 함수들을 활용해 새로운 함수를 정의할 수도 있다. 이는 덧셈 (+) 또는 곱셈 (*) 같은 미리 정의된 함수들을(하스켈에서는 연산자가 함수로서 정의된다) 활용할 수 있는 것과 같은 원리다. 예를 들어 정사각형의 넓이를 계산하기 위해 우리는 직사각형의 넓이를 계산하는 함수를 재활용할 수 있다. areaRect l w = l * w areaSquare s = areaRect s s *Main> areaSquare 5 25 어쨌든 정사각형은 단지 두 변의 길이가 같은 직사각형일 뿐이다. 연습문제 원통의 부피를 계산하는 함수를 작성한다. 원통의 부피는 원 모양인 바닥의 넓이(이 장에서 이미 작성한 함수이니 재활용할 것) 곱하기 높이다. 지역 정의(local definition) where 절 함수를 정의할 때 그 함수에 한정된 중간 결과를 정의하고 싶을 때가 있다. 예를 들어 삼각형의 변 a, b, c로 그 삼각형의 넓이를 구하는 헤론의 공식을 고려해 보자. heron a b c = sqrt (s * (s - a) * (s - b) * (s - c)) where s = (a + b + c) / 2 변수 s는 삼각형의 둘레의 절반인데 제곱근 함수 sqrt의 인자로 s를 네 번 쓰는 것은 지루한 일이다. 단순히 정의를 순서대로 쓰는 것은 먹히지 않는다. heron a b c = sqrt (s * (s - a) * (s - b) * (s - c)) s = (a + b + c) / 2 -- a, b, and c are not defined here 변수 a, b, c 가는 heron 함수의 우변에서만 이용할 수 있지만 여기서 s의 정의는 heron의 우변의 일부가 아니다. s를 우변의 일부로 만들려면 where 키워드를 사용해야 한다. where와 지역 정의를 공백 4개로 들였음으로써 이어지는 정의들과 구별한 것에 주목하라. 다음은 지역 정의와 최상위 정의를 섞어 쓰는 또 다른 예시다. areaTriangleTrig a b c = c * height / 2 -- use trigonometry where cosa = (b ^ 2 + c ^ 2 - a ^ 2) / (2 * b * c) sina = sqrt (1 - cosa ^ 2) height = b * sina areaTriangleHeron a b c = result -- use Heron's formula where result = sqrt (s * (s - a) * (s - b) * (s - c)) s = (a + b + c) / 2 스코프(scope) 앞선 예제를 자세히 들여다보면 변수 이름 a, b, c를 두 넓이 함수에 한 번씩, 총 두 번씩 사용했다. 이게 어떻게 가능한 걸까? 다음 GHCi 시퀀스를 살펴보자. Prelude> let r = 0 Prelude> let area r = pi * r ^ 2 Prelude> area 5 78.53981633974483 앞의 let r = 0 정의 때문에 넓이가 0을 반환했다면 불편하고 놀라운 일이었을 것이다. 그런 일이 일어나지 않은 이유는 두 번째로 r을 정의할 때는 또 다른 r에 대해 말하고 있기 때문이다. 헷갈릴 수 있지만 얼마나 많은 사람이 존이라는 이름을 가지는지 생각해 보자. 존이 한 명만 있는 문맥에서 우리는 아무 혼란 없이 "존"에 대해 말할 수 있다. 프로그래밍에도 문맥과 비슷한 스코프라는 개념이 있다. 스코프의 기술적인 면면을 당장은 설명하지 않을 것이다. 지금은 여러분이 함수를 호출할 때 전달한 것이 바로 매개변수의 값이고 함수 정의에서 변수를 어떻게 부르는지와 무관하다는 것만 알아두자. 그렇긴 하지만 변수에 적절한 고유 이름을 붙이면 독자가 코드를 읽기 쉬워진다. 요약 변수는 값을 저장한다. 값은 임의의 하스 켈 표현식이다. 변수는 스코프 내에서 변하지 않는다. 함수는 재사용 가능한 코드 작성을 돕는다. 함수는 하나보다 많은 인자를 취할 수 있다. 그리고 소스 파일 안에서 코드가 아닌 텍스트인 주석도 배웠다. 이 예제에서 볼 수 있듯이, 변수의 이름에 문자뿐 아니라 숫자도 들어갈 수 있다. 하스 켈 변수는 반드시 소문자로 시작해야 하지만 그다음에는 문자, 숫자, 밑줄(_), 따옴표(') 무엇이든 가능하다. ↩ 3 진위 값 원문: http://en.wikibooks.org/wiki/Haskell/Truth_values 동등 비교와 기타 비교들 불리언 값 타입 입문 중위 연산자(infix operator) 불리언 연산 가드(guard) where와 가드 동등 비교와 기타 비교들 바로 앞 장에서 다음 코드처럼 등호를 사용하여 변수와 함수를 정의했었다. r = 5 이는 프로그램을 평가하면 (이 정의의 스코프 안에서) r을 모두 5로 치환한다는 뜻이다. 비슷하게, 다음 코드를 평가하면 f x = x + 3 f 다음에 숫자(f의 인자)가 붙는 모든 자리가 그 숫자에 3을 더한 것으로 치환된다. 그런데 수학에서 등호는 역시 중요하지만 미묘하게 다른 방식으로도 쓰인다. 그 예로 다음의 간단한 문제를 보자. 예: 다음 등식을 푸시오. x + 3 = 5 여기서 우리의 관심사는 값 5를 x + 3으로 표현하거나 x + 3을 5로 표현하는 것이 아니다. 우리는 등식 x + 3 = 5를<NAME>(proposition)로서 보고, 어떤 숫자 x에 3를 더하면 5가 나온다고 읽는다. 이 등식을 푼다는 것은 이<NAME>를 참으로 만드는 x 값을 (만약 있다면) 찾아낸다는 뜻이다. 이 예에서는 초등 대수를 이용해 x = 2라 판단 내릴 수 있다. (즉 2는 이 등식을 참으로 만드는 숫자이며 2 + 3 = 5이다.) 값들이 동일한지 비교하는 일은 프로그래밍에서도 유용하다. 하스켈에서 그런 검사는 단순히 등식처럼 보인다. 등호는 이미 정의를 위해 쓰고 있기 때문에 하스켈은 그 대신 이중 등호 ==를 사용한다. 위의<NAME>를 GHCi에 입력해 보자. Prelude> 2 + 3 == 5 True GHCi는 "True"를 반환하는데, 2 + 3이 5와 같기 때문이다. 참이 아닌 등식을 쓰면 어떻게 될까? Prelude> 7 + 3 == 5 False 논리<NAME>하다. 다음으로는 우리가 만든 함수를 이런 검사에 활용해 보자. 이 과목을 시작할 때 언급한 함수 f를 가지고 실험해 보자. Prelude> let f x = x + 3 Prelude> f 2 == 5 True 예상한 대로다. f 2는 2 + 3으로 평가되기 때문이다. 두 숫자 값 중 무엇이 큰지 비교할 수도 있다. 하스켈은 <(미만), >(초과), <=(이하), >=(이상) 등 많은 검사를 제공한다. 이 검사들은 ==(동일)과 같은 방식으로 작동한다. 예를 들면 <를 이전 과목의 area 함수와 함께 써서 특정 반지름의 원이 어떤 값보다 작은지 확인할 수 있다. Prelude> let area r = pi * r ^ 2 Prelude> area 5 < 50 False 불리언 값 GHCi가 이런 산술<NAME>를 참인지 거짓인지 결정할 때 실제로 무슨 일이 일어나는 걸까? 조금 다른 이야기지만 연관이 있는 다음 문제를 생각해 보자. GHCi에 산술 표현식을 입력하면 그 표현식은 평가되고, 결과 산 술값이 화면에 표시된다. Prelude> 2 + 2 이 산술 표현식을 항등 비교로 대체하면 비슷한 일이 벌어진다. Prelude> 2 == 2 True "4"는 일종의 셈, 수량 같은 것을 나타낸다. "True"는<NAME>의 참을 의미하는 값(value)이다. 이런 값을 진위 값(true value) 또는 불리언 값(boolean value) 1이라 부른다. 자연스럽게 불리언 값은 오직 True와 False만 존재한다. 타입 입문 True와 False는 단순히 비유가 아니라 실제 값이다. 불리언 값은 하스켈에서 숫자 값과 같은 신분을 가지고 비슷한 방식으로 조작할 수 있다. 다음은 간단한 예시다. Prelude> True == True True Prelude> True == False False True는 True와 같고 True는 False와 같지 않다. 이제 빨리 가보자. 그러면 2는 True와 같을까? Prelude> 2 == True <interactive>:1:0: No instance for (Num Bool) arising from the literal ‘2’ at <interactive>:1:0 Possible fix: add an instance declaration for (Num Bool) In the first argument of ‘(==)’, namely ‘2’ In the expression: 2 == True In an equation for ‘it’: it = 2 == True 땡! 이 질문은 애초에 성립하지 않는다. 숫자를 숫자가 아닌 것과 비교하거나 불리언 값을 불리언이 아닌 값과 비교하는 것은 불가능하다. 하스켈은 이 개념을 받아들이고, 위의 못생긴 오류 메시지는 이에 대해 불평하고 있다. 복잡한 부분을 건너뛰면 이 메시지는 ==의 좌변에 숫자(Num)가 있고, 그래서 우변에 숫자를 기대한다고 말한다. 하지만 불리언 값(Bool)은 숫자가 아니므로 항등 검사가 실패한다. 즉 값은 타입(type)을 가지며, 타입은 우리가 값을 가지고 무엇을 할 수 있고 무엇을 할 수 없는지, 그 한계를 정의한다. True와 False는 Bool 타입의 값이다. 2는 조금 복잡한데, 숫자 타입이 여러 개 있기 때문에 이에 관한 설명은 나중으로 미루겠다. 타입은 매우 강력한 도구다. 값들이 말이 되는 규칙 하에서 행동하도록 제한하여, 올바르게 작동하는 프로그램의 작성을 쉽게 만든다. 타입은 하스켈에서 아주 중요하기 때문에 타입에 대해서 앞으로 자주 논하게 될 것이다. 중위 연산자(infix operator) 2 == 2 같은 항등 검사는 2 + 2처럼 단지 표현식이며 거의 같은 방식으로 값으로 평가된다. 표현식이라는 것은 앞선 예제의 오류 메시지에서도 말하고 있다. In the expression: 2 == True 우리가 프롬프트에 2 == 2를 입력하고 GHCi가 True로 "대답"할 때, GHCi는 단지 표현식을 평가하고 있는 것이다. 사실 ==는 그 자체가 인자 두 개를 받는 함수다. (두 인자가 각각 항등 검사의 좌변과 우변에 위치하는) 하지만 그 문법은 다소 인상적이다. 하스켈은 2-인자 함수를, 인자들 사이에 위치하는 중위 연산자로서 사용하는 것을 허용한다. 함수 이름에 알파벳이나 숫자가 들어가지 않을 경우 이런 중위 표기는 흔한 용법이다. 이런 함수를 "표준" 방식으로 (함수 이름이 인자들보다 앞에 오는, 전위 연산자로서) 사용하려면 함수 이름을 괄호로 감싸야 한다. 즉 다음 표현식들은 완벽히 동등하다. Prelude> 4 + 9 == 13 True Prelude> (==) (4 + 9) 13 True 여기서 (==)가 앞 과목의 areaRec와 비슷하게 작동하는 것을 볼 수 있다. 이런 개념은 다른 관계 연산자들(<, >, <=, >=)과 산술 연산자들(+, * 등)에도 적용된다. 이것들은 모두 인자를 두 개 취하는 함수이며 보통은 중위 연산자로 작성된다. 일반화하면 하스켈에서 실체가 있는 것들은 값 또는 함수라고 말할 수 있다. 불리언 연산 하스켈은 진위 값을 논리<NAME>로서 조작하기 위한 기본 함수를 3개 제공한다. (&&)은 and 연산(논리곱)을 수행한다. 두 불 리언 값이 주어질 때, 둘 다 True인 경우 True로 평가되고 그 외의 경우 False로 평가된다. Prelude> (3 < 8) && (False == False) True Prelude> (&&) (6 <= 5) (1 == 1) False (||)은 or 연산(논리합)을 수행한다. 두 불 리언 값이 주어질 때, 둘 중 하나라도 True인 경우 True로, 그 외의 경우 False로 평가된다. Prelude> (2 + 2 == 5) || (2 > 0) True Prelude> (||) (18 == 17) (9 >= 11) False not은 불리언 값의 반전(negation)을 수행한다. 즉 True는 False로, False는 True로 변환한다. Prelude> not (5 * 2 == 10) False 하스 켈 라이브러리에는 같지 않음(not equal to)을 위한 관계 연산자 함수 (/=)가 이미 들어있지만, 우리가 쉽게 직접 구현할 수 있다. x /= y = not (x == y) 중위 표기는 연산자를 정의할 때도 가능하다. ASCII 기호들(키보드에서 가장 흔히 쓰이는 기호들)을 사용해서 완전히 새로운 연산자를 만들 수도 있다. 가드(guard) 하스 켈 프로그램은 불리언 연산자를 종종 간편하고 축약된 구문으로 사용한다. 동일한 로직을 다른 식으로 작성하는 것을 편의 문법(syntactic sugar)이라고 부르는데, 사람이 보기에 코드가 더 이쁘기 때문이다. 그런 문법 중 가드를 먼저 알아보자. 가드는 불리언 값에 기반해 단순하지만 강력한 함수들을 작성할 수 있게 만든다. 절댓값 함수를 구현해 보자. 실수의 절댓값은 그 수에서 기호를 제거한 것이다. 따라서 음수 면(0보다 작으면) 그 기호를 반전시키고 음수가 아니면 그대로 둔다. 그 정의를 다음과 같이 적을 수 있다. x = { , if ≥ − , if < 여기서 |x|를 계산하기 위해 쓰이는 실제 표현식은 x에 관해 세운<NAME>들의 집합에 따라 달라진다. 만약 x ≥ 0이 참이면 첫 번째 표현식을 사용한다. 그러나 x < 0인 경우에는 두 번째 표현식을 대신 사용한다. 우리에겐 이 결정 과정을 표현할 수단이 필요하다. 가드를 사용하면 다음과 같이 구현할 수 있다. 2 예제: 절댓값 함수. absolute x | x < 0 = -x | otherwise = x 확실히 위의 코드는 이에 대응하는 수학적 정의만큼이나 가독성 있다. 이 정의를 하나씩 해부해 보자. 일반적인 함수 정의처럼 시작한다. 함수 이름 absolute를 적고, 이 함수가 단일 매개변수 x를 취한다고 알린다. =와 정의의 우변을 적는 대신 줄 바꿈을 하고, 두 대체문을 별개의 줄에 놓았다. 3 이 대체문들이 가드다. 공백은 단순히 미적인 이유로 넣은 것이 아니며 코드가 올바르게 파싱 되려면 필수다. 각각의 가드는 파이프 문자인 |으로 시작한다. 파이프 뒤에는 불리언 값으로 평가될 표현식(불리언 조건식 또는 술어식(predicate)이라고도 부름)을 놓고, 그 뒤에는 정의의 나머지 부분이 온다. 함수는 술어식이 True로 평가되는 줄의 등호와 그 우변만을 사용한다. otherwise 분기는 선행하는 술어식들 중 True로 평가되는 게 없을 때 사용된다. 이 경우 x가 0보다 작지 않다면 x는 0과 같거나 그보다 커야만 한다. 따라서 마지막 술어식은 x >= 0으로 쓸 수도 있었지만, otherwise도 잘 작동한다. 잠깐 otherwise의 이면에 문법상의 마법은 없다. otherwise는 하스켈의 다른 기본 변수, 함수들과 함께 정의되어 있으며 단순히 otherwise = True 이다. 이 정의는 otherwise를 전방 수비 가드로 만든다. 가드 술어식의 평가는 순차적이기 때문에 다른 술어식들 중 하나도 True로 평가되지 않을 때만 otherwise에 도달하게 된다. (그러니 otherwise를 마지막 가드로 세웠는지 항상 확인하자!) 일반적으로는 항상 otherwise를 두는 것이 좋다. 어떤 입력에 대해 아무 술어 식도 참이 아니면 못생긴 런타임 오류가 발생하기 때문이다. 잠깐 첫 번째 가드에서 | x < 0 = -x x를 반전하기 위해 마이너스 기호를 사용했다. 기호 반전을 이렇게 표현하는 것은 일종의 특수 사례다. -는 인자를 하나 받아서 0 - x로 평가하는 함수가 아니며 축약 문법일 뿐이다. 이런 축약은 편리하지만 가끔 (-)를 실제로 함수로서 사용하는 것(뺄셈 연산자)과 충돌해서 성가심의 원인이 될 수 있다. (괄호로 묶지 않고 음수 네 개를 가지고 뺄셈을 세 번 해보자) 그러므로 음수를 가지고 absolute를 테스트해 보려면 이렇게 호출해야 한다. Prelude> absolute (-10) 10 where와 가드 where 절은 특히 가드와 함께 쓸 때 편리하다. 2차 방정식 x + x c 0 의 (실수인) 해의 개수를 구하는 함수를 살펴보자. numOfSolutions a b c | disc > 0 = 2 | disc == 0 = 1 | otherwise = 0 where disc = b^2 - 4*a*c where 정의는 모든 가드의 스코프 내에 있으므로 disc의 표현식을 여러 번 작성하지 않아도 된다. 이 용어는 수학자이자 철학자인 조지 부울(George Boole)에 대한 헌정이다. ↩ 이 함수는 이미 하스켈이 abs라는 이름으로 제공하므로 실전에서는 직접 구현하지 않아도 된다. ↩ 여러 줄을 합쳐서 한 줄에 전부 작성할 수도 있었지만 그러면 읽기가 더 힘들었을 것이다. ↩ 4 타입의 기초 원문: http://en.wikibooks.org/wiki/Haskell/Type_basics 서문 왜 타입이 유용한가 반응형 커맨드 :type 활용하기 문자와 문자열 함수형 타입 예제: not 예제: chr와 ord 인자가 둘 이상인 함수 실전 예제: openWindow 코드 안의 타입 시그너처 타입 추론 타입과 가독성 타입은 오류를<NAME>다 노트 프로그래밍에서 타입은 비슷한 값들을 범주로 묶는다. 하스켈의 타입 체계는 코드 상에서의 실수를 줄여주는 강력한 수단이다. 서문 프로그래밍은 여러 종류의 개체(entity)를 다루는 일이다. 두 수를 더하는 경우를 생각해 보자. 2 + 3 2와 3은 무엇인가? 물론 숫자다. 가운데의 더하기 기호는 무엇인가? 분명 숫자는 아니다. 이것은 숫자 두 개를 가지고 할 수 있는 연산, 즉 덧셈을 뜻한다. 여러분의 이름을 물어보고 "Hello" 메시지로 답하는 프로그램을 생각해 보자. 여러분의 이름도, Hello라는 단어도 숫자는 아니다. 그럼 이것들은 무엇일까? 우리는 모든 단어와 문장을 통틀어 텍스트라고 부를 수도 있다. 프로그래밍에서는 String(문자열)이라는 다소 이색적인 낱말을 사용하는데, 이는 "문자들의 나열"의 줄임말이다. 하스켈에는 모든 타입 이름이 대문자로 시작해야 한다는 규칙이 있다. 앞으로 이 관습을 고수할 것이다. 데이터베이스는 타입이라는 개념을 명확히 보여준다. 우리의 데이터베이스에 사람들의 연락처에 관한 상세 정보를 보관하는 테이블이 있다고 치자. 일종의 개인 전화번호부인 셈이다. 그 내용물은 이런 식이다. 성 이름 전화번호 주소 Sherlock Holmes 743756 221B Baker Street London Bob Jones 655523 99 Long Road Street Villestown 각 항목(entry)의 필드들은 값을 포함한다. Sherlock은 값이고, 99 Long Road Street Villestown도, 655523도 값이다. 이 예제의 값들을 타입의 관점에서 분류해 보자. "성"과 "이름"은 텍스트를 포함하고, 따라서 이 값들의 타입은 String이라 말할 수 있다. 언뜻 보면 주소를 문자열로 분류하고 싶겠지만, 단순해 보이는 주소의 이면에는 상당히 복잡한 의미가 들어있다. 주소를 어떻게 해석할지에 대해서는 다양한 관습이 있다. 가령 주소 텍스트가 숫자로 시작하면 그 숫자는 그 집의 번지일 수 있다. 숫자가 아니면 분명 그 집의 이름일 것이다. 아, "PO Box"로 시작하는 경우는 제외해야 한다. 단순히 우편함 주소이며 사람이 어디 사는지 전혀 알려주지 않는다. 주소의 각 부분은 저마다 의미를 가진다. 원칙적으로는 주소를 String 값이라고 말할 수 있지만, 그러면 주소의 중요한 특징들을 포착하지 못한다. 우리가 무언가를 String 값이라고 하면, 그것이 문자의 나열이라고 말하는 것일 뿐이다. 무언가를 하나의 특화된 타입으로 구분하면 더 많은 의미를 가지게 된다. 만약 무언가가 Address 값이라는 것을 안다면, 그 데이터 조각에 관해 더 많은 것을 즉시 알아낼 수 있다. 가령, 주소에 의미를 부여하는 "관습"을 활용해 그 데이터를 해석할 수 있는 것이다. 이런 방침을 전화번호에도 적용할 수 있다. TelephoneNumber라는 타입을 만들 수도 있는 것이다. 어떤 숫자의 나열을 받았는데 그것의 타입이 TelephoneNumber라면, 우리는 이것이 단순한 Number 값일 때보다 더 많은 정보를 알 수 있다. 예를 들어 처음 자릿수들을 통해 지역 부호나 국가 부호 같은 것을 알아낼 수 있는 것이다. 전화번호를 그저 Number로 간주하지 않는 또 다른 이유는 이걸 가지고 산수를 하는 것이 말이 안 되기 때문이다. TelephoneNumber에 100을 곱하는 것의 의미와 그 기대되는 결과가 무엇일까? 그런 번호로는 누구에게도 전화를 걸 수 없다. 또한 전화번호의 각 자릿수는 모두 중요하다. 반올림으로 자릿수 일부를 날리거나 시작 부분의 0을 생략하는 것은 용납할 수 없다. 왜 타입이 유용한가 개체들을 서술하고 분류하는 것이 프로그래밍에 어떻게 도움이 되는 걸까? 타입을 정의하면 그것을 가지고 무엇이 가능하고 무엇이 불가능한지를 기술할 수 있다. 이러면 거대한 프로그램을 관리하고 오류를 피하는 것이 훨씬 쉬워진다. 반응형 커맨드 :type 활용하기 GHCi를 이용해 타입이 어떻게 작동하는지 살펴보자. 모든 표현식의 타입은 :type (짧게는 :t)이라는 커맨드로 확인할 수 있다. 이전 과목의 불리언 값들에 시험해 보자. 예: GHCi에서 불리언 값의 타입 확인하기 Prelude> :type True True :: Bool Prelude> :type False False :: Bool Prelude> :t (3 < 5) (3 < 5) :: Bool :: 기호는 "... 이다음의 타입을 가진다"라고 읽으면 되며 타입 시그너처(type signature)를 뜻한다. :type은 하스켈에서 진위 값들의 타입이 Bool 임을 드러낸다. 불리언 값들은 단순히 값 비교를 위한 것이 아니라는 것에 주의하자. Bool은 예/아니요 답의 의미를 포착하며, 따라서 그런 종류의 모든 정보를 표현할 수 있다. 예를 들면 스프레드시트에 어떤 이름이 있는지, 사용자가 on/off 옵션을 토글 했는지가 그런 정보다. 문자와 문자열 뭔가 새로운 것에 :t를 써보자. 리터럴 문자는 따옴표로 감싸서 입력할 수 있다. 예를 들어 다음은 단일 문자 H이다. 예: GHCi에서 리터럴 문자에 :type 명령 사용하기 Prelude> :t 'H' 'H' :: Char 즉 리터럴 문자 값은 Char("character"의 줄임말) 타입을 가진다. 하지만 따옴표는 단독 문자에만 가능하다. 더 긴 텍스트, 즉 문자의 나열을 입력하려면 쌍따옴표를 사용한다. 예: GHCi에서 리터럴 문자열에 :t 명령 사용하기 Prelude> :t "Hello World" "Hello World" :: [Char] 왜 Char가 다시 나오는 걸까? 차이점은 각괄호(square bracket)에 있다. [Char]는 여러 개의 문자가 줄줄이 이어져서 리스트를 형성하는 것을 뜻한다. 하스켈은 모든 문자열을 문자들의 리스트로 취급한다. 리스트는 하스켈에서 중요한 개념이며 조만간 자세히 다룰 것이다. 연습문제 리터럴 값 "H"(쌍따옴표에 주의)에 :type을 사용해 보자. 무슨 일이 벌어지는가? 그 이유는? 리터럴 값 'Hello World'(그냥 따옴표에 주의)에 :type을 사용해 보자. 무슨 일이 벌어지는가? 그 이유는? 우연히도 하스켈에는 사람 언어의 동의어('big'과 'large'처럼 뜻이 같은 낱말들)와 썩 비슷하게 작동하는, 타입 동의어라는 것이 있다. 하스켈에서 타입 동의어는 타입을 위한 또 다른 이름이다. 가령 String은 [Char]의 동의어로 정의되어 있기 때문에 이 둘은 서로를 자유롭게 대체할 수 있다. 따라서 다음은 완벽히 타당하며 "Hello World" :: String 대부분의 경우 훨씬 가독성이 좋다. 이제부터는 대부분의 텍스트 값을 [Char] 대신 String이라 칭할 것이다. 함수형 타입 지금까지는 값(문자열, 불리언, 문자 등)이 어떻게 타입을 가지고 이런 타입이 어떻게 값을 분류하고 설명하는지를 알아봤다. 이제 하스켈의 타입 체계를 진정으로 강력하게 만드는 커다란 전환점을 맞이하자. 함수 역시 타입을 가진다. 1 그 예제를 몇 개 살펴보겠다. 예제: not not을 이용하면 불리언 값을 반전시킬 수 있다(True는 False로, False는 True로). 이 함수의 타입을 밝혀내려면 두 가지를 고려해야 한다. 바로 not이 입력으로 취하는 값의 타입과 반환하는 값의 타입이다. 이 예제에선 상황이 간단하다. not은 (반전시킬) Bool 값을 취해 (반전된) Bool 값을 반환한다. 이것을 표기하면 예: not의 타입 시그너쳐 not :: Bool -> Bool "not은 Bool 타입의 무언가로부터 Bool 타입의 무언가로 가는 함수다"라고 읽을 수 있다. 이 함수에 :t를 쓰면 예상한 대로 나온다. Prelude> :t not not :: Bool -> Bool 함수의 타입은 그 함수의 인자의 타입과 돌려주는 값의 타입으로 기술된다. 예제: chr와 ord 텍스트는 컴퓨터에서 골칫거리다. 가장 저 수준에서 컴퓨터는 오직 1과 0 밖에 모른다. 컴퓨터는 이진 체계에서 작동한다. 이진수로 작업하는 것은 전혀 편하지 않기 때문에 사람들은 컴퓨터가 텍스트를 보관할 수단을 만들어냈다. 모든 문자는 일단 숫자로 변환되고, 이 숫자는 이진수로 변환되어 저장된다. 이것이 텍스트 한 조각(문자들의 열)이 이진수로 부호화되는 절차다. 우리는 대개 문자를 수학적 표상으로 부호화하는 것에만 신경 쓰는데, 컴퓨터가 보통은 이진수로의 변환을 알아서 처리하기 때문이다. 문자를 숫자로 변환하는 가장 쉬운 방법은 모든 가능한 문자들을 적고 번호를 매기는 것이다. 예를 들어 'a'는 1, 'b'는 2 순으로 대응시킬 수 있다. ASCII 표준이 바로 이런 것이다. ASCII는 널리 쓰이는 128개 문자에 순서대로 번호를 매긴다. 물론 엉덩이 깔고 앉아 커다란 참조표에서 부호화를 할 때마다 문자를 일일이 찾는 것은 따분할 것이다. 그런 일을 대신해주는 chr('char'라 발음)와 ord라는 함수가 있다. 2 예: chr와 ord의 시그너쳐 chr :: Int -> Char ord :: Char -> Int Char가 무엇을 뜻하는지는 알고 있다. 위 시그너쳐에서 Int는 처음 보는 타입으로, 정수의 크기를 나타내고, 여러 타입의 수 중 하나다. 3 chr의 타입 시그너쳐는 Int 타입의 인자 즉 정수를 취해서 Char 타입의 결괏값으로 평가한다는 것을 알려준다. ord는 그 반대다. Char 타입의 값을 취해서 Int 타입의 값을 반환한다. 타입 시그너쳐로부터 얻은 정보로 어떤 함수가 문자를 숫자 부호로 부호화하고(ord) 어떤 함수가 그것을 다시 문자로 복호화 하는지가(chr) 분명히 보인다. 좀 더 확실히 하기 위해 여기 chr과 ord를 호출하는 몇 가지 예가 있다. 두 함수는 기본적으로 이용할 수 없다. 그래서 GHCi에서 이것들을 시험해 보기 전에 :module Data.Char(또는 :m Data.Char)로 이것들이 정의된 Data.Char 모듈을 불러와야 한다. 예: chr과 ord에 대한 함수 호출 Prelude> :m Data.Char Prelude Data.Char> chr 97 'a' Prelude Data.Char> chr 98 'b' Prelude Data.Char> ord 'c' 99 인자가 둘 이상인 함수 지금까지 사용한 타입 시그너쳐는 인자가 하나인 함수에는 충분했지만, 이런 함수의 타입은 어떨까? 예: 인자가 하나보다 많은 함수 xor p q = (p || q) && not (p && q) (xor은 배타적 or 함수로, 두 인자 중 하나만 True인 경우 True로 평가된다. 그 외의 경우 False로 평가된다) 인자가 여럿인 함수의 타입을 짜는 일반적인 절차는 모든 인자의 타입을 한 줄에 순서대로 쓰고(이 경우 p 다음 q) 이것들을 ->로 연결하는 것이다. 최종적으로 그 줄의 끝에 결괏값의 타입을 적고 바로 전에 최종 ->를 놓는다. 4 이 예제에서는 인자들의 타입을 써 내려간다. 이 경우 (||)와 (&&)의 사용에서 p와 q가 Bool 타입이어야 한다는 것이 정해진다. Bool Bool ^^ p is a Bool ^^ q is a Bool as well 그 사이에 ->를 채운다. Bool -> Bool 결괏값 타입과 마지막 ->를 추가한다. 여기선 기본적인 불리언 연산을 하므로 그 결과도 Bool이다. Bool -> Bool -> Bool ^^ We're returning a Bool ^^ This is the extra -> that got added in 최종 시그너쳐는 다음과 같다. 예: xor의 시그너쳐 xor :: Bool -> Bool -> Bool 실전 예제: openWindow 하스 켈 실전에서 배우겠지만, GUI(그래픽 사용자 인터페이스 Graphical User Interface)는 하스 켈 라이브러리들 중 인기 있는 부류의 하나다. GUI는 컴퓨터 사용자들에게 익숙한 메뉴, 버튼, 애플리케이션 창, 마우스 움직이기 등 시각적인 것들을 다루는 함수들을 제공한다. 그런 라이브러리들 중 하나에 openWindow라는 함수가 있는데, 이 함수를 이용해 애플리케이션에서 새 윈도를 열 수 있다. 예를 들어 여러분이 문서 편집기를 만들고 있는데 사용자가 'Options' 버튼을 누르면, 여러분은 변경 가능한 모든 옵션을 포함하는 새 윈도를 열어야 한다. 이 함수의 타입 시그너처를 들여다보자. 5 예제: openWindow openWindow :: WindowTitle -> WindowSize -> Window 아직 모르는 타입들이지만 아주 단순하다. WindowTitle, WindowSize, Window 세 타입 모두 openWindow를 제공하는 GUI 라이브러리에서 정의하는 것들이다. 두 화살표는 처음의 두 타입이 매개변수들의 타입이고 마지막 타입은 결과의 타입임을 뜻한다. WindowTitle은 윈도의 제목(보통은 윈도 맨 위의 타이틀 바에 표시됨)을 뜻하고 WindowSize는 윈도가 얼마나 큰지를 기술한다. 그러고 나서 openWindow는 실제 윈도를 나타내는 Window 타입의 값을 반환한다. 어떤 함수를 본 적이 없거나 실제로 어떻게 작동하는지 모르더라도 타입 시그너처를 보면 그 함수가 무슨 용도인지 대략 알 수 있다. 새로운 함수를 볼 때마다 :t으로 확인해 보는 습관을 들여보자. 하스켈의 표준 라이브러리 함수들을 배우고 하스켈의 함수에 대한 유용한 직관을 기를 수 있다. 연습문제 다음 함수들의 타입은 무엇인가? 숫자가 관여하는 함수들의 경우 그 숫자가 Int라고 가정해도 된다. negate 함수는 Int를 받아서 부호를 반전하여 반환한다. 예를 들면 negate 4 = -4이고 negate (-2) = 2이다. (||) 함수는 'or'이라고 부르며 Bool 값 두 개를 취해서 둘 중 하나라도 True인 경우 True를, 그 외의 경우 False를 반환한다. monthLength 함수는 윤년인 경우 True, 아니면 False인 Bool 값과 몇 번째 달인지를 나타내는 Int 값을 취한다. 그리고 그 달의 요일 수를 나타내는 Int 값을 반환한다. f x y = not x && y g x = (2*x - 1)^2 코드 안의 타입 시그너처 지금까지 타입의 이면에 있는 기본적인 이론과 그 이론이 하스켈에 어떻게 적용되는지를 알아봤다. 이제 소스 파일 안에서 함수에 타입 시그너처를 붙이는 방법을 알아보자. 다음은 앞서 예제로 들었던 xor 함수다. 예제: 시그너처를 붙인 함수 xor :: Bool -> Bool -> Bool xor p q = (p || q) && not (p && q) 우리가 할 일은 이게 전부다. 최대한 명료하게 하기 위해 시그너처는 대응하는 함수 정의 바로 앞에 놓는다. 이렇게 추가한 시그너처는 두 가지 역할을 맡는다. 그 함수의 타입을 코드를 읽는 사람에게도, 컴파일러 및 인터프리터에도 명확히 알린다. 타입 추론 타입 시그너처가 인터프리터(또는 컴파일러)에게 함수의 타입을 알려준다면 지금까지는 타입 시그너처를 쓰지 않고 어떻게 하스 켈 코드를 작성해왔던 걸까? 우리가 함수나 변수의 타입을 하스켈에게 알려주지 않으면 하스켈은 타입 추론이라는 절차를 통해 그 타입을 알아낸다. 컴파일러는 알고 있는 것들의 타입으로 시작해서 값의 나머지 부분의 타입을 알아낸다. 다음은 흔한 예시다. 예제: 간단한 타입 추론 -- 이 함수의 타입 시그너처는 의도적으로 생략됨 isL c = c == 'l' isL은 인자 c를 취해 c == 'l'을 평가한 결과를 반환한다. 타입 시그너처가 없으면 c의 타입과 결괏값의 타입이 명시되지 않는다. 하지만 표현식 c == 'l'에서 컴파일러는 'l'이 Char 값이란 걸 알아낸다. c와 'l'이 (==)에서 항등 비교되고 (==)의 두 인자는 타입이 같아야 하기 때문에 6, c는 반드시 Char 값이어야 한다는 결론이 나온다. 마지막으로, isL c는 (==)의 결과값이기 때문에 Bool이어야 한다. 그러므로 이 함수의 시그너처는 다음과 같다. 예제: 타입을 첨부한 isL isL :: Char -> Bool isL c = c == 'l' 타입 시그너처를 빼먹으면 하스 켈 컴파일러는 이런 과정을 통해 그 타입을 찾는다. isL에 시그너처를 붙이거나 붙이지 않고서 :t를 써서 검증해 볼 수 있다. 타입 시그너처가 추론이 되는 것이라면 왜 작성해야 할까? 어떤 경우에는 컴파일러가 타입을 추론하기에 정보가 부족해서 시그너처가 필수적이다. 타입 시그너처를 이용해 함수나 값의 최종 타입을 제한하는 경우도 있다. 지금은 그런 경우를 고려할 필요가 없지만, 타입 시그너처를 명시할 이유는 그 외에도 여러 가지가 있다. 문서화: 타입 시그너처는 코드를 읽기 쉽게 만든다. 대부분의 함수는 그 이름과 타입만 보면 무슨 일을 하는지 충분히 추측할 수 있다. 물론 코드에 적절히 주석을 다는 것도 중요하지만, 타입을 확실히 하는 것도 많은 도움이 된다. 디버깅: 함수에 타입을 달아놓고 함수 몸체 안에서 변수의 타입을 바꾸면, 컴파일러가 컴파일 도중에 여러분의 함수가 잘못되었음을 알려줄 것이다. 타입 시그너처가 없으면 오류 있는 프로그램이 컴파일되고, 컴파일러가 잘못된 타입들을 할당할 수도 있다. 프로그램을 실행하기 전에는 이런 실수를 했다는 걸 알아내지 못할 것이다. 타입과 가독성 보다 현실적인 예제를 통해 시그너처가 문서화에 어떻게 도움이 되는지 알아보자. 아래의 코드는 작은 모듈으로서 (모듈은 라이브러리를 마련하는 일반적인 수단이다), GHC에 포함된 라이브러리들은 이런 식으로 코드를 조직화한다. 잠깐 여기 있는 함수들이 실제로 어떻게 작동하는지 이해하려 골머리를 앓지 말자. 우리가 아직 다루지 않은 기능이 많이 나오기 때문이다. 지금은 그냥 읽고 즐기면 된다. 예제: 타입 시그너처를 포함한 모듈 module StringManip where import Data.Char uppercase, lowercase :: String -> String uppercase = map toUpper lowercase = map toLower capitalize :: String -> String capitalize x = let capWord [] = [] capWord (x:xs) = toUpper x : xs in unwords (map capWord (words x)) 이 작은 라이브러리는 문자열 조작 함수를 3개 제공한다. uppercase는 문자열을 대문자로, lowercase는 소문자로, capitalize는 모든 낱말의 첫 글자를 대문자로 변환한다. 각 함수는 String 값을 인자로 취해 다른 String으로 평가한다. 우리는 이 함수들이 어떻게 작동하는지 몰라도 타입 시그너처를 들여다보고 인자들과 반환값의 타입을 바로 알 수 있다. 여기에 적절한 함수 이름도 곁들이면 함수들을 어떻게 쓸지 충분히 알아낼 수 있다. 함수들의 타입이 같으면 시그너처를 한 번만 쓸 수도 있다는 것에 주목하자. 위에서 uppercase와 lowercase처럼 함수들의 이름을 쉼표로 구분하면 된다. 타입은 오류를<NAME>다 타입 있는 언어에서 타입은 오류 방지의 핵심이다. 표현식들을 여기저기 전달할 때는 여기서 한 것처럼 타입이 일치하는지 확인해야 한다. 일치하지 않으면 컴파일할 때 타입 오류를 받게 된다. 여러분의 프로그램은 타입 검사를 통과하지 못할 것이다. 이러면 프로그램에서 버그를 줄이는 데 도움이 된다. 아주 간단한 예를 하나 들어보면, 예제: 타입 검사가 없는 프로그램 "hello" + " world" -- type error 프로그램에 이런 줄이 있으면 컴파일에 실패하는데, 두 문자열을 더할 수는 없기 때문이다. 프로그래머는 이와 비슷하게 생긴 결합 연산자(concatenation operator)를 의도했을 것이다. 이 연산자는 두 문자열을 하나로 합친다. 예제: 오류 수정한 프로그램 "hello" ++ " world" -- "hello world" 이런 오타는 쉽게 나오며, 하스켈은 컴파일할 때 이런 오류를 잡아낸다. 프로그램을 실행하고 버그가 등장할 때까지 기다릴 필요가 없는 것이다. 프로그램을 수정하다 보면 타입들도 변경하게 된다. 그런 변경이 의도되지 않았거나 예상치 못한 결과라면 컴파일할 때 바로 드러나게 된다. 하스 켈 프로그래머들은 타입 오류를 모두 고치고 프로그램을 컴파일하면 대체로 "그냥 잘 돌아간다"라고 말하고는 한다. 그 동작은 의도와 일치하지 않을 수도 있지만 프로그램이 터지지는 않는다. 하스켈은 다른 언어보다 런타임 오류(프로그램이 컴파일할 때가 아니라 실행하고 있을 때 잘못되는 상황)가 훨씬 희귀하다. 노트 더 심오한 사실은 함수가 다른 것들처럼 값이라는 것이다. ↩ chr과 ord가 하는 일은 정확히는 이게 아니지만 우리의 의도에는 잘 들어맞는 설명이므로 충분하다. ↩ 사실 Int는 정수를 위한 유일한 타입이 아니다! Int의 친척들은 곧 만날 것이다. ↩ 이런 방법론이 지금은 시시해 보이지만 사실 여기에는 아주 심오한 이유가 있다. 이에 관해서는 고차 함수 장에서 다룰 것이다. ↩ 의도에 맞춰 간소화한 것이지만 그 본질은 같다. ↩ 진위 값 장에서 논의했듯이 (==)의 타입 시그너처가 이를 진술한다. 궁금하면 직접 확인해 볼 수 있지만, 여기 쓰인 표기에 대한 완벽한 설명은 조금 기다려야 한다. ↩ 5 리스트와 튜플 원문: http://en.wikibooks.org/wiki/Haskell/Lists_and_tuples 리스트 리스트 구축하기 문자열은 리스트일 뿐이다 리스트 내의 리스트 튜플 다수에 관한 다른 표기법 튜플 내의 튜플 (그리고 다른 조합들) 값 획득하기 보류된 질문들 다형성 타입 예제: fst와 snd 요약 하스켈에는 여러 개의 값을 관리하기 위한 근본적인 구조체가 두 개 있는데 바로 리스트와 튜플이다. 둘 다 여러 값을 하나의 합성 값으로 묶음으로써 작동한다. 리스트 GHCi에서 리스트를 몇 개 만들어보자. Prelude> let numbers = [1,2,3,4] Prelude> let truths = [True, False, False] Prelude> let strings = ["here", "are", "some", "strings"] 각괄호는 리스트의 범위를 제한하고, 개개의 원소들은 쉼표로 구분된다. 여기서 중요한 제약은 리스트 내의 모든 원소는 타입이 같아야 한다는 것이다. 타입이 혼재된 원소들의 리스트를 정의하려고 하면 전형적인 타입 오류가 발생한다. Prelude> let mixed = [True, "bonjour"] <interactive>:1:19: Couldn't match `Bool' against `[Char]' Expected type: Bool Inferred type: [Char] In the list element: "bonjour" In the definition of `mixed': mixed = [True, "bonjour"] 리스트 구축하기 각괄호와 쉼표를 이용해서 리스트 전체를 한 번에 기입하는 방법 외에 "cons"라고 부르는 (:) 연산자를 사용해서 한 조각씩 쌓아 올릴 수도 있다. 이렇게 리스트를 구축하는 공정을 컨싱(consing)이라 부르기도 한다. 이 용어는 "to cons"("constructor"의 mnemonic)라는 동사를 발명한 LISP 프로그래머들에게서 유래한 것으로서 원소를 리스트 앞에 붙이는 특정 작업을 지칭한다. 예: 리스트에 무언가를 컨싱하기 Prelude> let numbers = [1,2,3,4] Prelude> numbers [1,2,3,4] Prelude> 0:numbers [0,1,2,3,4] 무언가를 리스트에 컨싱(something:someList)하면 우리는 또 다른 리스트를 돌려받는 것이다. 따라서 원하는 만큼 컨싱을 계속할 수 있다. cons 연산자는 오른쪽에서 왼쪽으로 평가된다. cons를 생각하는 보다 일반적인 또 다른 방법은 첫 번째 값을 왼쪽에, 전체 표현식을 오른쪽에 취한다고 보는 것이다. 예: 리스트에 많은 것을 컨싱하기 Prelude> 1:0:numbers [1,0,1,2,3,4] Prelude> 2:1:0:numbers [2,1,0,1,2,3,4] Prelude> 5:4:3:2:1:0:numbers [5,4,3,2,1,0,1,2,3,4] 사실 하스켈은 모든 원소를 빈 리스트 []에 컨싱하는 방식으로 모든 리스트를 구축한다. 쉼표와 괄호 표기는 편의 문법일 뿐이다. 그러므로 [1,2,3,4,5]와 1:2:3:4:5:[]는 완전히 동치다. 그런데 리스트 생성에는 잠재적인 함정이 있어서 조심해야 한다. True:False:[]와 같은 것은 더할 나위 없이 훌륭한 하스 켈 코드지만 True:False는 아니다. 예: 으악! Prelude> True:False <interactive>:1:5: Couldn't match `[Bool]' against `Bool' Expected type: [Bool] Inferred type: Bool In the second argument of `(:)', namely `False' In the definition of `it': it = True : False True:False는 익숙한 타입 오류 메시지를 배출한다. cons 연산자 (:)는 (진짜로 하나의 함수일 뿐이다) 두 번째 인자로 리스트를 기대했는데 우리는 리스트에 무언가를 매달 줄만 아는 것에게 Bool을 줘버렸다. 1 그러니 cons를 쓸 때는 다음을 기억하자. 리스트의 원소들은 타입이 같아야 한다. 무언가를 리스트에 cons 할 수만 있다. 다른 식으로는 안 된다(리스트를 무언가에 cons 할 수 없음). 따라서 가장 오른쪽 항목은 리스트여야 하며 왼쪽의 항목들은 리스트가 아니라 독립 원소여야 한다. 연습문제 3:[True, False]는 작동할까? 되는 이유, 혹은 안 되는 이유는 무엇일까? 리스트를 취해 (시작 부분에) 8을 cons 하는 함수 cons8을 작성해 보자. 다음의 리스트들을 가지고 검정해 보자. cons8 [] cons8 [1,2,3] cons8 [True, False] let foo = cons8 [1,2,3] cons8 foo 위 함수를 수정하여 8이 리스트의 끝에 오도록 해보자. (힌트: 이전 장의 연결 연산자 ++를 떠올려보자) 인자 두 개, 리스트와 어떤 것을 취해서 그 어떤 것을 리스트에 cons 하는 함수를 작성해 보자. 이렇게 시작해 볼 수 있다. let myCons list thing = 문자열은 리스트일 뿐이다 타입의 기초 과목에서 짧게 언급했듯이 하스켈의 문자열은 문자들의 리스트일 뿐이다. 이는 String 타입의 값을 여타 리스트처럼 조작할 수 있다는 뜻이다. 가령 문자열을 쌍따옴표로 감싼 문자들의 순열로 쭉 입력하는 대신, Char 값들을 (:)로 연결하고 빈 리스트로 마무리 짓거나 쉼표-각괄호 표기를 쓸 수 있다. Prelude>"hey" == ['h','e','y'] True Prelude>"hey" == 'h':'e':'y':[] True 쌍따옴표 문자열은 좀 더 편리한 구문일 뿐이다. 리스트 내의 리스트 리스트는 무엇이든 포함할 수 있다. 그것들이 모두 같은 타입이기만 한다면. 리스트도 그런 것 중 하나이기 때문에 리스트는 다른 리스트를 포함할 수 있다! 인터프리터에서 이것을 시도해 보자. 예: 리스트는 리스트를 포함할 수 있다 Prelude> let listOfLists = [[1,2],[3,4],[5,6]] Prelude> listOfLists [[1,2],[3,4],[5,6]] 리스트의 리스트는 가끔 상당히 혼란스러운데, 어떤 것들의 리스트는 그 어떤 것들 자체와는 같은 타입이 아니기 때문이다. 가령 Int 타입은 [Int] 타입과 다르다. 몇 가지 연습문제를 가지고 이것들이 내포하는 의미를 정리해 보자. 연습문제 이것들 중 어떤 것이 올바른 하스켈이고 어떤 것이 올바르지 않을까? cons 표기로 재작성해 보자. [1,2,3, []] [1, [2,3],4] [[1,2,3],[]] 이것들 중 어떤 것이 올바른 하스켈이고 어떤 것이 올바르지 않을까? 쉼표와 괄호 표기로 재작성해 보자. []:[[1,2,3],[4,5,6]] []:[] []:[]:[] [1]:[]:[] ["hi"]:[1]:[] 하스켈에서 리스트의 리스트의 리스트를 가지는 것이 가능할까? 그 이유는? 다음 리스트는 하스켈에서 왜 올바르지 않을까? [[1,2],3, [4,5]] 리스트의 리스트는 복잡하고 구조화된 데이터(2차원 행렬이라던가)를 표현할 수 있는 유용한 방법이다. 또한 하스켈의 타입 체계가 빛을 발하는 장소이기도 하다. 사람 프로그래머들은 (이 위키 책의 공동 저자들 포함) 리스트의 리스트를 다룰 때마다 항상 혼란에 빠지곤 하며, 타입에 제약을 걸면 잠재적인 문제를 헤치고 나아가는 데 도움이 된다. 튜플 다수에 관한 다른 표기법 튜플은 여러 값을 한 값에 담는 또 다른 방법이다. 튜플과 리스트에는 두 가지 중대한 차이가 있다. 튜플은 고정된 개수의 원소들을 가진다(변경 불가능 immutable). 튜플에 cons 할 수는 없다. 따라서 몇 개의 값이 저장될지 미리 아는 경우에는 튜플을 쓰는 것이 타당하다. 가령 한 점의 2D 좌표를 보관하기 위한 타입을 원한다면 점마다 값이 몇 개 필요한지 알고 있으므로(2개. x 좌표와 y좌표) 튜플이 합리적이다. 튜플의 원소들은 같은 타입일 필요가 없다. 가령 전화번호부 애플리케이션에서 세 개의 값 이름, 전화번호, 주소를 사람별로 묶어서 처리하는 경우가 있다. 그럴 때는 세 값의 타입이 같지 않아 리스트는 별 도움이 안 될 것이다. 하지만 튜플은 도움이 된다. 튜플은 괄호 안에 원소들을 쉼표로 구분해서 생성한다. 튜플의 견본을 몇 개 보자. 예: 튜플 견본들 (True, 1) ("Hello world", False) (4, 5, "Six", True, 'b') 첫 번째 튜플은 두 원소를 담는다. 첫 번째는 True고 두 번째는 1이다. 두 번째 튜플도 두 원소를 가진다. 첫 번째는 "Hello world"고 두 번째는 False다. 세 번째 튜플은 다섯 개의 원소로 이루어져 있다. 첫 번째는 4(숫자), 두 번째는 5(다시 숫자), 세 번째는 "Six"(문자열), 네 번째는 True(불리언 값), 다섯 번째는 'b'(문자)다. 명명법을 빠르게 소개하자면, 크기 n인 튜플을 n-튜플이라 표기한다. 2-튜플(원소가 2개인 튜플)은 짝(pair), 3-튜플은 세 짝(triple)이라 한다. 그보다 크기가 큰 튜플들은 사실 흔하지 않지만 굳이 명명 체계를 확장하자면 네 짝(quadruple), 다섯 짝(quintuple) 등이 되겠다. 연습문제 첫 번째 원소는 4, 두 번째 원소는 "hello", 세 번째 원소는 True인 3-튜플을 작성해 보자. 다음 중 올바른 튜플들은 무엇일까? (4, 4) (4, "hello") (True, "Blah", "foo") 리스트는 새로운 원소를 리스트에 컨싱하여 구축할 수 있다. 숫자의 리스트에 숫자를 cons 하면 숫자의 리스트를 돌려받는다. 튜플을 이런 식으로 구축하는 방법이 없다는 것은 명백하다. 그 이유는 무엇일까? 논의를 위해 그런 함수가 있다고 가정하자. 무언가를 튜플에 "컨싱"하면 무엇을 얻게 될까? 튜플은 함수로부터 하나보다 많은 값을 반환받고 싶을 때도 편리하다. 많은 언어에서는 둘 이상을 한꺼번에 반환하려면 그 함수에서만 쓰는 자료 구조로 감싸야 한다. 하스켈에선 아주 편리한 대안으로 그 값들을 튜플로 반환한다. 튜플 내의 튜플 (그리고 다른 조합들) 리스트 내의 리스트를 보관하는 것과 같은 추론을 튜플에 적용할 수 있다. 튜플도 형체가 있으므로 튜플 내에 튜플을 저장할 수 있다(얼마든지 복잡하게 중첩할 수 있음). 비슷하게 튜플의 리스트, 리스트의 튜플, 같은 선상의 온갖 조합이 가능하다. 예: 튜플과 리스트 중첩시키기 ((2,3), True) ((2,3), [2,3]) [(1,2), (3,4), (5,6)] 튜플의 타입은 그 크기뿐 아니라, 리스트와 마찬가지로 그 튜플이 포함하고 있는 객체들의 타입도 고려해서 정의된다. 가령 튜플 ("Hello",32)와 (47, "world")는 그 근간이 다르다. 하나는 (String, Int) 타입이고 다른 건 (Int, String) 타입이다. 여기에는 튜플의 리스트 구축에 관해 함의하는 바가 있다. [("a",1),("b",9),("c",9)] 같은 리스트는 만들 수 있지만 하스켈은 [("a",1),(2, "b"),(9, "c")] 같은 리스트를 가질 수 없다. 연습문제 다음 중 올바른 하스 켈 코드들은 무엇일까? 그 이유는? 1:(2,3) (2,4):(2,3) (2,4):[] [(2,4),(5,5),('a','b')] ([2,4],[2,2]) 값 획득하기 리스트와 튜플이 쓸모가 있으려면 그 안에 포함된 값들에 접근할 수단이 필요하다. 점의 2D 좌표를 나타내는 짝(2-튜플)부터 시작하자. 체스판의 특정 사각형을 표현하려 한다고 상상해 보자. 모든 rank(가로줄)에 1에서 8까지 이름표를 붙이고 file(세로줄)에도 비슷하게 할 수 있다. 그러면 짝 (2, 5)는 rank 2와 file 5에 있는 사각형을 나타낸다. rank가 주어지면 그 rank의 모든 조각을 찾는 함수를 정의한다고 할 때, 한 가지 방법은 모든 조각의 좌표를 훑어보고 rank 부분이 우리에게 요구된 그 행인지 보는 것이다. 한 조각의 (x, y) 좌표짝을 얻은 후에는 이 함수는 x(rank 좌표)를 추출해야 한다. 그런 목적으로 fst, snd 함수가 있다. 이것들은 짝의 첫 번째와 두 번째 원소를 획득한다. 2 몇 가지 예시를 보자. 예: fst와 snd 사용하기 Prelude> fst (2, 5) Prelude> fst (True, "boo") True Prelude> snd (5, "Hello") "Hello" 이 함수들은 정의에 따라 짝에 대해서만 작동한다.3 리스트의 경우에는 head 및 tail이 fst 및 snd와 대략적으로 비슷하다. 이 함수들은 (:)로 연결된 리스트를 분해한다. head는 리스트의 첫 번째 원소로 평가되고, tail은 리스트의 나머지를 돌려준다. 예: head와 tail 사용하기 Prelude> 2:[7,5,0] [2,7,5,0] Prelude> head [2,7,5,0] Prelude> tail [2,7,5,0] [7,5,0] 노트 불행히도 head와 tail에는 심각한 문제점이 있다. 이것들 중 하나라도 빈 리스트에 적용하면... Prelude> head [] *** Exception: Prelude.head: empty list ...터지고 만다. 빈 리스트는 첫 번째 원소도, 다른 원소도 가지지 않기 때문이다. GHCi 바깥에서 빈 리스트에 대해 head나 tail을 실행했다면 프로그램이 고장 났을 것이다. 당분간 head와 tail을 다룰 텐데, 실제 코드에서 그런 기능 고장이 일어날 위험은 피하고 싶다. 나중에는 더 나은 선택지를 배울 것이다. "뭐가 문제야? 빈 리스트를 전달하지 않거나 호출하기 전에 리스트가 비어있는지 어떻게든 확인하면 head와 tail은 잘 작동할 텐데."라는 의문이 들 수도 있겠지만 이런 방식은 위험하다. 프로그램이 점점 더 커지고 복잡해지면 우리가 head나 tail에 빈 리스트를 전달하게 될 수도 있는 장소가 급격히 많아지고, 우리가 실수할 수도 있는 장소도 그만큼 많아진다. 경험상 함수가 경고 없이 실패하는 것은 피해야 한다. 이 책을 진행함에 따라 그런 위험을 피할 더 나은 방법들을 배우게 될 것이다. 보류된 질문들 여기서 소개한 네 함수는 이 절을 시작할 때 말한 문제를 완벽히 풀기에는 충분하지 않은 것 같다. fst와 snd가 짝의 경우에는 만족스러운 해결책을 제공하지만 세 개 이상의 원소가 있는 튜플은 어떻게 할까? 그리고 리스트의 경우 첫 번째 원소를 나머지와 분리하는 것보다 나은 방법은 없을까? 지금은 이 질문들을 보류할 것이다. 대신 필수적인 기반을 다진 후에 리스트 조작에 관한 이후의 장들에서 이 주제로 돌아올 것이다. 지금은 리스트의 head와 tail을 분리하면 우리가 원하는 무엇이든 할 수 있다는 것을 알아두자. 연습문제 fst와 snd를 결합해 튜플 (("Hello", 4), True)에서 4를 추출해 보자. 표준 체스 표기법은 여기서 우리가 사용한 것과 조금 다르다. 표준에서는 행을 1에서 8로, 열을 a에서 h로 센다. 그리고 관례상 열을 먼저 말한다. 특정 위치에 ('a', 4)처럼 문자 하나와 숫자 하나로 이름표를 붙일 수 있을까? 이것과 리스트의 중요한 차이점은 무엇일까? 리스트의 head와 tail을 튜플의 첫 번째 및 두 번째 원소로서 반환하는 함수를 작성해 보자. 리스트의 다섯 번째 원소를 반환하는 함수를 head와 tail을 이용해 작성해 보자. 이것에 무엇이 성가시고 어떤 단점이 있는지 비평해 보자. 다형성 타입 리스트의 타입은 그 원소들의 타입에 의존하며 원소의 타입에 각괄호를 감싸서 표기한다. Prelude> :t [True, False] [True, False] :: [Bool] Prelude> :t ["hey", "my"] ["hey", "my"] :: [[Char]] 그러므로 Bool의 리스트는 [Char] (즉 문자열)의 리스트나 Int의 리스트와는 다른 타입이다. 함수는 함수의 타입에 명시한 타입의 인자만 받아들이기 때문에 실전에서 복잡한 문제가 생기곤 한다. head의 경우를 생각해 보자. [Int], [Bool], [String]은 모두 다른 타입이므로 headInt :: [Int] -> Int, headBool :: [Bool] -> Bool, headString :: [String] -> String 등 모든 경우에 별도의 함수가 필요할 것처럼 보인다. 그런데 이러면 너무 성가시고 무분별하다. 무엇보다 리스트는 그것이 포함하는 값들의 타입에 무관하게 동일한 방식으로 조립된다. 우리는 리스트의 첫 번째 원소를 얻어내는 절차도 모든 경우에 동일하기를 바란다. 다행히도 모든 리스트에 대해 작동하는 head라는 단 하나의 함수가 존재한다. Prelude> head [True, False] True Prelude> head ["hey", "my"] "hey" 이게 어떻게 가능할까? 평소대로 head의 타입을 확인해 보면 좋은 힌트가 보인다. -- 예제: 우리의 첫 번째 다형 타입 Prelude> :t head head :: [a] -> a 각괄호 안의 a는 타입이 아니다. 타입 이름은 항상 대문자로 시작한다는 것을 기억하자. 이것은 타입 변수다. 하스켈은 타입 변수의 자리에 아무 타입이나 들어가는 것을 허용한다. 타입 이론(수학의 한 갈래)에서는 이것을 다형성 polymorphism이라 부른다. 단일 타입만을 가지는 함수나 변수는 단일 형 monomorphic이라 하고, 하나보다 많은 타입을 허용하기 위해 타입 변수를 사용하는 것들은 다형성 polymorphic이라 한다. 예를 들어 head의 타입이 뜻하는 바는 임의 타입(a)의 값들의 리스트([a])를 취해서 같은 타입의 값을 반환한다는 것이다. 하나의 타입 시그너쳐 내에서, 한 타입 변수의 모든 경우는 같은 타입이어야 함을 명심하자. 예를 들어, f :: a -> a 는 f가 임의 타입의 인자를 취해 인자와 같은 타입의 무언가를 반환한다는 뜻이고, 반면에 f :: a -> b 는 f가 임의 타입의 인자를 취해 임의 타입의 결과를 돌려주는데 그 타입이 a 자리에 들어갈 타입과 같을 수도 같지 않을 수도 있다는 뜻이다. 서로 다른 타입 변수들은 그 타입들이 반드시 서로 다르다고 명시하지 않는다. 단지 다를 수도 있다고 말할 뿐이다. 예제: fst와 snd 앞서 봤듯이 fst와 snd를 사용하면 짝의 일부를 추출할 수 있다. 지금쯤은 함수를 볼 때마다 "이것의 타입이 뭘까?" 하고 궁금해하는 습관이 생겼을 것이다. fst와 snd의 경우를 살펴보자. 두 함수는 인자로 짝을 하나 취해서 이 짝의 한 원소를 반환한다. 무엇보다 짝의 타입은 리스트처럼 그 원소들의 타입에 의존하므로 이 함수들도 다형성이어야 한다. 그리고 튜플은 일반적으로 그 내부 타입들이 동종일 필요가 없다는 걸 명심하자. 따라서 이렇게 적으면 fst :: (a, a) -> a fst가 짝의 첫 번째와 두 번째 원소가 같은 타입일 때만 작동하게 된다. 따라서 올바른 타입은 예제: fst와 snd의 타입 fst :: (a, b) -> a snd :: (a, b) -> b fst와 snd의 타입 시그너쳐 말고는 아무것도 몰랐다고 해도 이것들이 각각 짝의 첫 번째와 두 번째 원소를 반환한다고 추측할 수 있다. 일리가 있지만 다른 함수들도 이와 같은 타입 시그너쳐를 가질 수도 있다. 시그너쳐가 말해주는 것은 짝의 첫 번째 및 두 번째 부분과 타입이 같은 무언가를 반환해야 한다는 것뿐이다. 연습문제 다음 함수들에 타입 시그너쳐를 부여해 보자. 이전 절의 세 번째 연습문제의 해답("... 리스트의 머리와 꼬리를 튜플의 첫 번째와 두 번째 원소로 반환하는 함수") 이전 절의 네 번째 연습문제의 해답("... 리스트의 다섯 번째 원소를 반환하는 함수") h x y z = chr (x - 2) (이전 장에서 논한 chr을 기억하자) 요약 이 장에서 리스트와 튜플이라는 두 새로운 개념을 소개했다. 둘 사이의 중요한 유사점과 차이점을 종합해 보자. 리스트는 각괄호와 쉼표로 정의된다: [1, 2, 3] 리스트는 그 원소들의 타입이 같은 한 무엇이든 담을 수 있다. 리스트는 또한 cons 연산자 (:)를 이용해 구축할 수 있다. 다만 무언가를 리스트에 cons 하는 것만 가능하다. 튜플은 괄호와 쉼표로 정의된다: ("Bob", 32) 튜플은 서로 다른 타입의 무엇이든 담을 수 있다. 튜플의 길이는 그 튜플의 타입에 반영되어 있다. 즉 길이가 다른 두 튜플은 타입이 다르다. 리스트와 튜플은 어떤 식으로든 결합될 수 있다. 리스트의 리스트, 리스트의 튜플... 하지만 그 조합이 타당하려면 그것들의 기준을 만족해야만 한다. 이쯤에서 타입의 가치에 대해 의문이 들 수도 있다. 타입은 처음에는 성가시게 느껴지지만 사실은 아주 유용하다. 여러분이 하스 켈로 프로그래밍을 하다가 무언가 터지면, 차라리 "타입 오류"였으면 하게 될 것이다. ↩ 좀 더 기술적으로 말하자면, "... 원소들을 투영하는 투영체..." 이다. 수학적으로는, 한 구조에서 데이터를 가져오는 함수를 투영(projection)이라고 한다. ↩ 사실 임의 크기의 튜플에서 첫 번째 값을 추출하는 함수를 설계하는 방법이 있다. 하지만 생각만큼 간단치 않은 일이고, 표준 라이브러리의 fst와 snd는 그런 식으로 작동하지 않는다. ↩ 6 타입의 기초 2 원문: http://en.wikibooks.org/wiki/Haskell/Type_basics_II Num 클래스 숫자 타입들 다형성 추측 단일형 문제 숫자 너머의 클래스 노트 이번 장에서는 숫자 타입들이 하스켈에서 어떻게 처리되는지 보여주고 타입 시스템의 몇 가지 중요한 특성을 소개한다. 계속하기에 앞서 잠시 숨을 고르고 이런 질문을 생각해 보자. (+) 함수의 타입은 무엇일까?1 Num 클래스 수학에는 함께 더할 수 있는 수의 종류에 몇 가지 제약이 있다. 예를 들면 2 + 3(두 자연수), (-7) + 5.12(음의 정수와 실수), 1/7 + π(유리수와 무리수)... 등이 있다. 이것들은 모두 타당하다. 사실 모든 임의의 두 실수는 덧셈이 가능하다. 그런 일반성을 가장 단순하게 포착하려면 하스켈에는 일반화된 Number 타입이 필요하고, 그런 (+)의 시그너처는 단순히 (+) :: Number -> Number -> Number 이어야 한다. 하지만 이런 설계는 컴퓨터가 산수를 하는 방식에 잘 들어맞지 않는다. 컴퓨터는 정수를 메모리 내 일련의 이진수로 다룰 수 있지만 실수에는 이 접근법이 먹히지 않는다.2 그러므로 실수를 다루려면 부동소수점이라는 더 복잡한 인코딩이 필요하다. 부동소수점은 일반적으로 실수를 다루는 합리적인 수단이지만 불편한 점도 있어서 (특히 정밀도의 소실) 정수에는 더 간단한 인코딩을 사용할 가치가 있다. 즉 우리는 숫자를 저장하는 방법을 최소한 두 가지 가진다. 하나는 정수, 하나는 일반적인 실수를 위한 것이다. 각 접근법은 서로 다른 하스 켈 타입에 대응한다. 더욱이 컴퓨터는 (+) 같은 연산을 동일 포맷의 숫자들에 대해서만 수행할 수 있다. 범우주적 Number 타입은 고사하고 정수와 실수를 섞는 (+)도 쓸 수 없는 것처럼 보인다. 그런데 하스켈은 적어도 정수들 또는 실수들 사이에는 동일한 (+) 함수를 사용할 수 있다. GHCi에서 직접 확인해 보자. Prelude> 3 + 4 Prelude> 4.34 + 3.12 7.46 리스트와 튜플을 논할 때, 함수가 다형성이면 서로 다른 타입의 인자들을 받아들일 수 있는 걸 봤었다. 이런 사실을 고려해 보면 (+)의 타입 시그너처로 이런 게 가능할 것 같다. (+) :: a -> a -> a (+)는 a라는 동일 타입(정수일 수도 부동소수점 수일 수도 있는)의 두 인수를 취해 a 타입의 결과로 평가할 것이다. 하지만 이 해결책에는 문제가 있다. 앞서 봤듯이 타입 변수 a는 모든 타입을 나타낼 수 있다. (+)의 타입 시그너쳐가 이것이라면 두 Bool도, 두 Char도 더할 수 있다는 건데 그다지 말이 되지 않는 것 같다. 대신 (+)의 실제 시그너쳐는 한 언어 특성을 활용하는데, 이 특성은 a가 숫자 타입인 한 어느 타입이든 될 수 있다고 의미상 제한을 거는 것을 가능케 한다. (+) :: (Num a) => a -> a -> a Num은 타입 클래스로, 숫자로 간주되는 모든 타입을 아우르는, 타입들의 모임이다. 3 시그너쳐의 (Num a) => 부분은 a를 숫자형으로, 좀 더 정확하게는, Num의 인스턴스들로 제한한다. 숫자 타입들 그러면 시그너쳐에서 a가 나타내는 Num의 인스턴스라는 건 실제로는 무슨 숫자 타입일까? 가장 중요한 숫자 타입은 Int, Integer, Double이다. Int는 대부분 언어의 그 정수 타입에 대응한다. 컴퓨터의 프로세서에 따라 고정된 최댓값과 최솟값을 가진다. (32비트 기계에서는 -2147483648에서 2147483647까지) Integer도 정수를 위해 쓰이지만 Int와 달리 효율성을 조금 희생해서 임의 크기의 값을 지원한다. Double은 배정밀도 부동소수점 타입으로, 대다수의 경우 실수를 위한 좋은 선택이다. (Float이라고 Double의 단정 밀도 친구가 있는데 정밀도의 추가 손실 때문에 대개는 Double에 밀린다) 이들 타입은 하스켈에서 기본적으로 사용할 수 있고 일상 작업에서 쓰게 될 것들이다. 다형성 추측 아직 설명하지 않은 게 하나 더 있다. 시작부에서 언급한 덧셈 예시를 시도해 봤다면 이런 것이 완벽히 타당하단 걸 알고 있을 것이다. Prelude> (-7) + 5.12 -1.88 여기서는 서로 다른 타입의 두 숫자를 더하는 것 같다. 정수와 정수가 아닌 것... (+)의 타입 때문에 불가능하지 않았었나? 이 물음에 답하려면 우리가 입력한 숫자들이 실제로는 무슨 타입인지 봐야 한다. Prelude> :t (-7) (-7) :: (Num a) => a 이것 보게, (-7)은 Int도 Integer도 아니다! 대신 이것은 다형성 상수로서, 필요한 어느 숫자 타입으로든 "변할 수" 있다. 그 이유는 다른 숫자를 살펴보면 명확해진다. Prelude> :t 5.12 5.12 :: (Fractional t) => t 5.12도 다형성 상수인데 Num보다 제한적인 Fractional 클래스에 속하는 것이다. 모든 Fractional은 Num이지만 모든 Num이 Fractional인 것은 아니다(가령 Int와 Integer는 Fractional이 아니다) 하스 켈 프로그램은 (-7) + 5.12를 평가할 때, 이 숫자들의 실제 타입을 결정해야 한다. 그 방법은 클래스 명세를 고려하여 타입 추론을 수행하는 것이다. (-7)은 어떤 Num도 될 수 있지만, 5.12에는 추가적인 제한이 있어서, 5.12의 타입이 (-7)이 무엇이 될지를 결정할 것이다. 둘의 타입이 어때야 하는지에 대한 다른 단서가 없기 때문에 5.12는 기본적인 Fractional 타입인 Double로 간주될 것이다. 따라서 (-7)도 Double이 되고 덧셈을 진행하는 것이 가능하여 Double을 반환받게 된다.4 이 과정을 더 와닿게 하는 빠른 검사가 있다. 소스 파일에서 이렇게 정의한다. x = 2 그리고 이 파일을 GHCi로 불러와 x의 타입을 확인한다. 그다음 파일에 변수 y를 추가한다. x = 2 y = x + 3 파일을 다시 불러와서 x와 y의 타입을 확인한다. 마지막으로 y를 수정하고 x = 2 y = x + 3.1 두 변수의 타입에 무슨 일이 일어나는지 보라. 단일형 문제 숫자 타입과 클래스의 정교함은 복잡함으로 이어지기도 한다. 가령, 흔한 나누기 연산자인 (/)를 보자. 그 타입 시그너쳐는 다음과 같다. (/) :: (Fractional a) => a -> a -> a a를 분수형으로 제한하는 것은 필수사항인데 두 정수의 나눗셈 결과는 대개 정수가 아니기 때문이다. 그래도 여전히 이렇게 작성할 수 있다. Prelude> 4 / 3 1.3333333333333333 리터럴 4와 3은 다형성 상수고 (/)의 요구에 따라 Double 타입으로 간주되기 때문이다. 하지만, 한 숫자를 리스트의 길이로 나누는 것을 가정해 보자. 5 당연히 length 함수를 사용해야 할 것이다. Prelude> 4 / length [1,2,3] 그런데... 이런... <interactive>:1:0: No instance for (Fractional Int) arising from a use of `/' at <interactive>:1:0-17 Possible fix: add an instance declaration for (Fractional Int) In the expression: 4 / length [1, 2, 3] In the definition of `it': it = 4 / length [1, 2, 3] 평소와 마찬가지로 이 문제는 length의 타입 시그너쳐를 보면 이해할 수 있다. length :: [a] -> Int length의 결과는 다형성 상수가 아니라 Int이다. 그리고 Int는 Fractional이 아니기 때문에 (/)의 시그너쳐에 들어맞지 않는다. 이 문제에서 탈출하는 수단을 제공하는 편리한 함수가 있다. 글을 계속 읽기 전에 이름과 시그너쳐만으로 이 함수가 하는 일을 추측해 보자. fromIntegral :: (Integral a, Num b) => a -> b fromIntegral은 Integral 타입(Int나 Integer 등)의 무언가를 인자로 취해서 다형성 상수로 만든다. length와 결합하면 리스트의 길이를 (/)의 시그너쳐에 맞출 수 있다. Prelude> 4 / fromIntegral (length [1,2,3]) 1.3333333333333333 처음에는 이 표현식이 과도하게 복잡해 보이겠지만, 이런 방법이 숫자를 조작할 때 표현식을 더 철저하게 만든다. 인자가 Int인 함수를 정의하면 그 인자는 절대 알아서 Integer나 Double로 변환되지 않는다. 여러분이 fromIntegral 같은 함수로 프로그램에게 그 일을 명확히 지시해야 한다. 이런 절제된 타입 체계의 결과로 하스켈에는 숫자를 다루는 놀랍도록 다양한 클래스와 함수들이 있다. 숫자 너머의 클래스 타입 클래스의 용도는 산술을 넘어 많은 것이 있다. 가령 (==)의 타입 시그너쳐는 다음과 같다. (==) :: (Eq a) => a -> a -> Bool (+)나 (/)처럼 (==)도 다형성 함수다. (==)는 같은 타입의 두 값을 비교해 Bool 값을 반환하는데, 이 두 값은 반드시 Eq 클래스에 속해야 한다. Eq는 항등 비교가 가능한 값들의 타입들의 클래스이며 모든 기본적인 비함수형 타입들이 여기에 포함된다. 6 타입 클래스는 타입 체계에 많은 강력함을 보태는 아주 범용적인 언어 특성이다. 이 책의 뒷부분에서 이 주제로 돌아와 타입 클래스를 우리 입맛대로 쓰는 방법을 볼 것이다. 노트 "타입의 기초"에서 우리가 한 권고를 따랐다면 :t로 시험해 봐서 이 기묘한 답을 이미 봤을 것이다. 그랬다면, 글에서 이어지는 분석을 이 시그너쳐의 의미를 이해하는 길로 여기기를. ↩ 그 이유는 두 실수 사이에 무한히 많은 실수가 있기 때문이다. 그리고 우리가 무슨 짓을 해도 이 무한함을 메모리에 그대로 표현할 수가 없다. ↩ 아주 느슨한 정의지만 타입 클래스를 더 자세히 논할 준비가 될 때까지는 충분하다. ↩ 노련한 프로그래머들에게 : 이것은 C(그리고 다른 많은 언어들)로 작성된 프로그램에서 암묵적 캐스팅(정수 리터럴이 조용히 double으로 변환됨)을 다루는 것과 같은 효과처럼 보일 것이다. 차이점은 C에서는 그 변환이 여러분의 등 뒤에서 벌어지지만 하스켈에서는 변수나 리터럴이 다형성 상수일 때만 그런 변환이 일어난다는 것이다. 그 차이는 반례를 보면 곧 분명해질 것이다. ↩ 있을 법한 시나리오 - 리스트 내 값들의 평균을 구하는 것을 생각해 보자. ↩ 두 함수의 항등 비교는 아주 다루기 힘든 것으로 간주된다. ↩ 7 다음 과정 원문: http://en.wikibooks.org/wiki/Haskell/Next_steps if / then / else 패턴 매칭의 도입 튜플 패턴과 리스트 패턴 let 바인딩 노트 이 장에서는 패턴 매칭이라는 하스켈의 핵심 특성과 if 표현식 및 let 바인딩이라는 새로운 문법을 소개한다. if / then / else 하스 켈 문법은 if... then... (else...) 형태의 흔한 조건 표현식을 지원한다. 가령 인자가 0보다 작으면 (-1)을 반환하는 함수를 생각해 보자. 인자가 0이면 0을, 인자가 0보다 크면 1을 반환한다. 그런 일을 하는 signum이라는 함수가 이미 정의되어 있지만, 설명을 위해 직접 정의해 보자. 예제: signum 함수 mySignum x = if x < 0 then -1 else if x > 0 then 1 else 0 다음과 같이 실험해 볼 수 있다. *Main> mySignum 5 *Main> mySignum 0 *Main> mySignum (5-10) -1 *Main> mySignum (-1) -1 마지막의 "-1"을 감싼 괄호는 필수사항이다. 빼먹으면 시스템은 여러분이 mySignum에서 1을 빼려 한다고 생각할 것이고, 이건 타입 불량이다. if/then/else 구조에서는 맨 처음에 조건식(이 경우 x < 0)이 평가된다. 그 결과가 True 이면 구조 전체가 then 표현식으로 평가된다. 아니면(조건이 False 이면) else 표현식으로 평가된다. 모든 것이 직관적이다. 하지만 명령형 언어로 프로그래밍을 해봤다면 하스켈에선 항상 then과 else 모두를 요구한다는 점이 놀라울 수도 있겠다. 이는 if 구조가 두 경우 모두 어떤 값을 결과로 내야 하기 때문이다. 좀 더 정확히는, 두 경우 모두 같은 타입의 값을 결과로 내야 한다. 위와 같은 if / then / else 함수 정의는 이전 과목에서 소개한 가드 문법으로 쉽게 재작성할 수 있다. 예제: if에서 가드로 mySignum x | x < 0 = -1 | x > 0 = 1 | otherwise = 0 비슷하게, 진위 값 장의 절댓값 함수를 if/then/else로 만들 수 있다. 예제: guard에서 if로 abs x = if x < 0 then -x else x 왜 가드를 놔두고 if를 쓰는가? 뒤의 예제에서도, 여러분이 프로그래밍을 할 때도 보게 되겠지만, 조건부를 다루는 각각의 방식은 상황에 따라 가독성이 더 좋거나 편리하다. 대부분의 경우에는 두 방식 모두 잘 작동한다. 패턴 매칭의 도입 경주자들이 각 경주에서의 순위에 따라 점수를 받는 경쟁에서 통계치를 추적하는 프로그램을 작성하는 것을 생각해 보자. 점수 규칙은 이렇다. 승자는 10점 2등은 6점 3등은 4점 4등은 3점 5등은 2점 6등은 2점 나머지는 0점 순위(1등은 정수 1로 나타내는 등 1)를 받아서 획득한 점수를 반환하는 함수는 쉽게 작성할 수 있다. 한 가지 해결책은 if/then/else를 쓰는 것이다. 예제: if/then/else로 점수 세기 pts :: Int -> Int pts x = if x == 1 then 10 else if x == 2 then 6 else if x == 3 then 4 else if x == 4 then 3 else if x == 5 then 2 else if x == 6 then 1 else 0 윽. 분명 if/then/else 대신 가드를 썼으면 이렇게 흉물스럽진 않았을 것이다. 하지만 모든 항등 검사를 쓰고 (또 읽는) 것도 지루한 일이다. 더 나은 방법이 있다. 예제: 조각 함수 정의를 이용해 점수 세기 pts :: Int -> Int pts 1 = 10 pts 2 = 6 pts 3 = 4 pts 4 = 3 pts 5 = 2 pts 6 = 1 pts _ = 0 훨씬 낫다. 그런데 pts를 이런 식으로 정의하면 (임의로 조각 정의라고 부르자) 분명 코드를 읽는 사람은 이 함수가 무엇을 하는지 명확히 알 수 있지만, 그 문법은 우리가 지금까지 본 하스켈이라기엔 기이하다. 왜 pts에 등식이 7개나 있을까? 좌변의 숫자들은 뭐고, x는 어디로 간 걸까? 하스켈의 이런 특성은 패턴 매칭이라고 한다. pts를 호출하면 그 인자는 각 등식의 좌변에 있는 숫자, 즉 패턴이라는 것과 비교(매칭) 된다. 이러한 비교는 등식들을 작성한 순서대로 행해진다. 그래서 인자는 첫 번째 등식의 1과 비교된다. 인자가 1이면 맞는 걸 찾은 것이고 첫 번째 등식이 사용된다. 따라서 pts 1은 10으로 평가된다. 아니면 같은 절차를 따라 다른 등식들이 시도된다. 그런데 마지막은 사뭇 다르다. _는 특수 패턴으로, 종종 "와일드카드"라 부르는데, "아무거나"라고 읽을 수 있다. _는 모든 것과 일치한다. 그래서 인자가 앞선 패턴들 중 어느 것에도 일치하지 않으면 pts는 0을 반환한다. 인자를 나타낼 x 같은 변수가 없는 이유는, 정의를 작성할 때 그런 게 필요하지 않기 때문이다. 여기서는 모든 가능한 반환값이 상수다. 변수는 정의의 우변과의 관계를 표현하기 위해 사용하는 것이므로 우리의 pts 함수에서는 x가 필요 없다. 그렇지만 변수를 활용하면 pts를 보다 간결하게 만들 수 있다. 경주자들에게 주어지는 점수는 3등에서 6등까지는 균일하게 1점씩 감소한다. 여기에 착안해서 방정식 7개 중 3개를 제거할 수 있다. 예제: 혼합 스타일 pts :: Int -> Int pts 1 = 10 pts 2 = 6 pts x | x <= 6 = 7 - x | otherwise = 0 즉 정의의 두 가지 스타일을 섞을 수 있다. 사실은 등식의 좌변에 pts x라고 쓸 때도 패턴 매칭을 이용하고 있는 것이다! 패턴으로서의 x는(그리고 다른 변수 이름들은) _처럼 모든 것과 일치한다. 유일한 차이점은 우변에서도 그 이름을 쓸 수 있다는 것이다(이 경우 7 - x를 작성하기 위해 필요하다). 연습문제 pts의 두 번째 버전에서 세 번째 버전으로 옮겨갈 때 속임수를 약간 썼다. 이 둘은 정확히 같은 일을 하는 것은 아니다. 그 차이를 알아보겠는가? 정수 외에도 패턴 매칭은 여러 타입의 값과 작동한다. 한 가지 유용한 예는 불리언이다. 가령 진위 값에서 만났던 논리합 연산자 (||)는 다음과 같이 정의할 수 있다. 예제: (||) (||) :: Bool -> Bool -> Bool False || False = False _ || _ = True 또는 예제: 다른 방식의 (||) (||) :: Bool -> Bool -> Bool True || _ = True False || y = y 한 번에 두 개 이상의 인자들을 비교하면, 모든 인자가 일치할 때만 등식이 사용된다. 패턴 매칭을 쓸 때 잘못될 수 있는 것들을 몇 개 논의하며 이 절을 마무리하자. 모든 것에 일치하는 패턴(pts 예제의 마지막 패턴 같은 것)을 더 구체적인 패턴의 앞에 놓으면 후자는 무시된다. 그런 경우 GHC(i)는 "패턴 매칭이 중복됨 Pattern match(es) are overlapped"이라 경고할 것이다. 일치하는 패턴이 하나도 없으면 오류가 발생한다. 통상 패턴들이 모든 경우를 다루도록 하는 게 좋은 생각인데, otherwise 가드가 필수는 아니지만 강력히 권장되는 것과 같다. 마지막으로, (&&) 2를 여러 방식으로 재정의하며 놀 수 있는데, 이것은 작동하지 않는 버전이다. (&&) :: Bool -> Bool -> Bool x && x = x -- oops! _ && _ = False 이 프로그램은 인자들이 같은지 검사하지 않는데 둘 다에 같은 이름을 썼기 때문이다. 매칭에 관한 한, 첫 번째 줄에 _ && _라 쓴 거나 마찬가지다. 그리고 더 안 좋아진다. 두 인자에 같은 이름을 부여했기 때문에 GHC(i)는 "x의 정의들이 상충함(Conflicting definitions for 'x')"이라며 이 함수를 거절할 것이다. 튜플 패턴과 리스트 패턴 위의 예제들은 패턴 매칭이 더 우아한 코드 작성에 도움을 준다는 것은 보여주지만, 패턴 매칭이 왜 중요한지는 설명하지 않는다. 그럼 fst의 정의를 작성하는 문제를 생각해 보자. 이 함수는 짝의 첫 번째 원소를 추출한다. 지금 시점에서 이는 불가능한 일처럼 보이는데, 짝의 첫 번째 값에 접근하는 유일한 방법은 fst 자체를 이용하는 것이기 때문이다. 그런데 다음 함수는 fst와 같은 일을 한다. (GHCi에서 확인해 보자) 예제: fst의 정의 fst' :: (a, b) -> a fst' (x, _) = x 마법이다! 등식의 좌변에서 정규 변수를 쓰는 대신 인자를 2-짝의 패턴으로 기입했다. 즉 변수와 _ 패턴으로 채워진 (,) 인 것이다. 그러면 이 변수는 튜플의 첫 번째 성분과 자동으로 연관되고 등식의 우변에서 이용할 수 있게 된다. snd의 정의도 물론 비슷하다. 위에서 설명한 기교는 리스트에서도 할 수 있다. 다음은 head와 tail의 실제 정의다. 예제: head, tail, 그리고 패턴 head :: [a] -> a head (x:_) = x head [] = error "Prelude.head: empty list" tail :: [a] -> [a] tail (_:xs) = xs tail [] = error "Prelude.tail: empty list" 이전 예제와 근본적으로 다른 점은 (,)를 cons 연산자 (:)의 패턴으로 대체한 것뿐이다. 이 함수들도 빈 리스트 []의 패턴을 활용하는 등식을 포함한다. 하지만 빈 리스트는 머리나 꼬리가 없기 때문에 error로 오류 메시지를 출력하는 것 말고는 할 수 있는 일이 없다. 요약하자면, 패턴 매칭의 진정한 힘은 이것을 이용하여 복잡한 값의 일부에 접근할 수 있다는 것이다. 특히 리스트에 대한 패턴 매칭은 재귀와 그 이후의 장에서 광범위하게 쓰일 것이다. 나중에 이 마법 같은 특성의 외견 뒤편에서 무슨 일이 일어나는지 탐구할 것이다. let 바인딩 let 바인딩을 짧게 소개하며 이번 장을 마무리하겠다. (let은 지역 선언을 위한 where 절의 대체문이다) 예를 들어 x + x c 꼴의 다항식의 해를 구하는 문제를 보자. (즉 이차 방정식의 답. 중학교 수학 시간을 떠올려보자) 그 답은 이렇다. = b b − a 2 x의 두 값을 계산하는 다음 함수를 작성할 수 있다. roots a b c = ((-b + sqrt(b*b - 4*a*c)) / (2*a), (-b - sqrt(b*b - 4*a*c)) / (2*a)) 하지만 sqrt(b*b - 4*a*c) 항을 두 번 쓰는 것은 성가시기 때문에, 대신 where 또는 밑에서 설명할 let 선언을 이용하여 지역 바인딩을 할 수 있다. roots a b c = let sdisc = sqrt (b*b - 4*a*c) in ((-b + sdisc) / (2*a), (-b - sdisc) / (2*a)) let 키워드를 선언 앞에 놓고, in을 이용해 함수의 "주" 몸체로 돌아온다는 신호를 보낸다. 하나의 let... in 블록 내에 여러 선언을 놓을 수 있다. 이것들이 같은 양만큼 들여쓰기 되었는지 확실히 해야 한다. 그렇지 않으면 문법 오류가 발생한다. roots a b c = let sdisc = sqrt (b*b - 4*a*c) twice_a = 2*a in ((-b + sdisc) / twice_a, (-b - sdisc) / twice_a) 경고: 하스켈에선 들여 쓰기가 문법상 중요하기 때문에, 여러분이 탭을 쓰고 있는지 스페이스를 쓰고 있는지 주의해야 한다. 최선책은 탭을 두 개나 네 개의 스페이스로 대체하도록 텍스트 에디터를 구성하는 것이다. 탭을 스페이스와 구분해서 쓸 것이라면 적어도 탭이 항상 같은 길이를 가지도록 해야 한다. 잠깐 들여쓰기 장에서 들여쓰기 규칙의 모든 것을 다룬다. 노트 여기서는 함수에 말이 안 되는 값(가령 (-4))을 전달할 때 무슨 일이 일어날지 별로 신경 쓰지 않는다. 하지만 보통은 나중에 깜짝 놀라지 않기 위해 그런 "이상한" 경우를 고려하는 게 좋다. ↩ GHCi에서 이를 실험해 보려면, 이름 충돌을 피하기 위해 여러분의 함수를 뭔가 다른 것, 가령 (&!&)으로 명명해 보자. ↩ 8 어휘 쌓기 원문: http://en.wikibooks.org/wiki/Haskell/Building_vocabulary 함수 합성 어휘 사전의 필요성 Prelude와 라이브러리들 one exhibit 어휘 사전 얻기 이 책에서 외부 자료들 노트 이번 장은 앞뒤의 장과는 다소 다를 것이다. 주된 목표가 새 특성을 소개하는 것이 아니라 하스켈을 공부하는(그리고 활용하는!) 것에 대한 조언을 주기 위한 막간 정도로 생각하라. 여기서 우리는 함수들의 어휘 사전(vocabulary)을 얻는 것의 중요함과, 이에 관해 이 책이나 기타 자료에서 어떻게 도움을 주는지 논할 것이다. 하지만 그에 앞서 함수 합성의 요점을 빠르게 짚어보자. 함수 합성 함수 합성은 정말 간단한 개념이다. 어떤 값에 한 함수를 적용하고, 그 결과를 또 다른 함수에 적용하는 것을 뜻한다. 다음의 정말 간단한 두 함수를 보자. 예: 간단한 함수들 f x = x + 3 square x = x^2 이것들을 무엇을 먼저 적용하느냐에 따라 두 가지 방법으로 합성할 수 있다. Prelude> square (f 1) 16 Prelude> square (f 2) 25 Prelude> f (square 1) Prelude> f (square 2) 안쪽의 함수를 둘러싼 괄호는 필수다. 이러지 않으면 인터프리터는 여러분이 square f나 f square의 값을 구하려 한다고 생각할 것이다. 둘 다 아무 의미도 없다. 두 함수의 합성은 그 자체로 하나의 함수가 된다. 숫자에 f 다음 square를, 혹은 그 반대로 적용하는 것이 프로그램에서 흔하고, 또 의미 있고, 하여간 중요한 연산이라면 자연스레 다음 단계는 이런 것을 정의하는 것이다. 예: 합성된 함수들 squareOfF x = square (f x) fOfSquare x = f (square x) 합성 함수를 작성하는 다른 훌륭한 방법이 있다. 함수 합성 연산자인 (.)를 쓰는 것으로, 두 함수 사이에 공백을 넣는 것만큼이나 간단하다. 예: (.)로 합성한 함수 squareOfF x = (square . f) x fOfSquare x = (f . square) x 이렇게 해도 함수들은 오른쪽에서 왼쪽으로 적용되기 때문에 g(f(x)) == (g . f) x 임을 명심하라. 1 어휘 사전의 필요성 함수 합성은 간단한 함수들을 기초 벽돌 삼아 복잡한 함수를 정의할 수 있게 해준다. 하스켈의 핵심 자질 중 하나는 기반 함수를 내가 작성했든 다른 사람이 작성했든, 합성 함수를 작성하는 것이 정말 간단하다는 것으로 2, 간단하고 우아하고 풍부한 코드 작성에 도움이 된다. 함수 합성을 하려면 합성할 함수들이 있어야 한다. 우리가 직접 짠 코드야 어떻게 쓰는 건지 알고 있지만, GHC의 설치판에는 다양한 일반적인 작업을 위한 함수들을 제공하는 막대한 종합 라이브러리들(즉 패키지로 묶인 코드)이 딸려온다. 그래서 능률적인 하스 켈 프로그래밍을 하려면 반드시 기초 라이브러리들에 익숙해져야 한다. 최소한, 필요할 때 라이브러리 내의 관련 함수들을 찾을 줄은 알아야 한다. 이 문제를 다른 관점에서 볼 수 있다. 우리는 이미 하스 켈 문법의 상당한 부분을 겪었다. 그리고 재귀 장을 끝낸 후에는 원하는 어떤 리스트 조작이든 할 수 있게 될 것이다. 하지만 지금 시점에서 완전한 프로그램을 작성하는 건 끔찍하게 비효율적인데, 지금까진 주로 표준 라이브러리의 많은 부분을 재작성하는 것으로 끝났기 때문이다. 잘 알려진 자명한 프로그램은 라이브러리로 처리하고 우리의 뇌세포는 진짜로 관심 있는 문제를 푸는 데 활용하는 것이 훨씬 낫다. 또한 라이브러리가 제공하는 기능들은 우리만의 알고리즘을 개발하는 데도 도움이 된다. 3 Prelude와 라이브러리들 다음은 하스 켈 라이브러리들에 관한 기본적인 사항이다. 무엇보다도 Prelude는 모든 하스 켈 프로그램에 기본적으로 적재되는 핵심 라이브러리다. 기본 타입들과 더불어 어디에나 쓰이고 극히 유용한 함수들을 제공한다. Prelude 자체 그리고 Prelude의 함수들을 이 입문성 과목 전체에 걸쳐 계속 참고할 것이다. Prelude의 너머에는 광범위한 도구를 제공하는 핵심 라이브러리들이 있다. 이것들이 GHC와 함께 기본적으로 제공되기는 하지만 Prelude처럼 자동으로 불러와지는 것은 아니다. 대신 이것들은 모듈로서 이용 가능한데, 반드시 여러분의 프로그램에 들여와야 한다. 나중에 모듈이 어떻게 작동하는가에 관한 세부 사항을 설명할 것이다. 지금은 소스 파일 윗부분에 필요한 모듈을 들여오는 줄이 필요하다는 것만 알아둘 것. 예를 들어 permutation 함수는 Data.List 모듈에 들어있는데 이 모듈을 들여오려면 여러분의. hs 파일의 꼭대기에 import Data.List라는 줄을 추가한다. 다음은 완전한 소스 파일의 생김새다. 예: 소스 파일에 모듈 들여오기 import Data.List testPermutations = permutations "Prelude" GHCi로 빠르게 시험해 보려면 명령줄에서 :m +Data.List를 입력해 그 모듈을 불러온다. Prelude> :m +Data.List Prelude Data.List> :t permutations permutations :: [a] -> [[a]] one exhibit 계속하기 전에 Prelude의 기본 함수들에 익숙해지면 무슨 도움이 되는지 그 예시를 하나 보자(약간 작위적이다. 동의한다.) 4. 공백으로 구분된 낱말들로 이루어진 문자열을 취해 낱말들의 순서를 뒤집은 문자열을 반환하는 함수가 필요하다고 치자. 즉 "Mary had a little lamb"는 "lamb little a had Mary"이 된다. 이제 우리가 지금까지 배운 하스켈과 재귀 장을 배우며 얻을 수 있는 약간의 통찰력을 한껏 활용해 이 문제를 풀 수 있다. 이것이 그 답이다. 너무 오래 쳐다보지 말라! 예: There be dragons monsterRevWords :: String -> String monsterRevWords input = rejoinUnreversed (divideReversed input) where divideReversed s = go1 [] s where go1 divided [] = divided go1 [] (c:cs) | testSpace c = go1 [] cs | otherwise = go1 [[]] (c:cs) go1 (w:ws) [c] | testSpace c = (w:ws) | otherwise = ((c:w):ws) go1 (w:ws) (c:c':cs) | testSpace c = if testSpace c' then go1 (w:ws) (c':cs) else go1 ([c']:w:ws) cs | otherwise = if testSpace c' then go1 ((c:w):ws) (c':cs) else go1 ((c:w):ws) (c':cs) testSpace c = c == ' ' rejoinUnreversed [] = [] rejoinUnreversed [w] = reverseList w rejoinUnreversed strings = go2 (' ' : reverseList newFirstWord) (otherWords) where (newFirstWord : otherWords) = reverseList strings go2 rejoined ([]:[]) = rejoined go2 rejoined ([]:(w':ws')) = go2 (rejoined) ((' ':w'):ws') go2 rejoined ((c:cs):ws) = go2 (c:rejoined) (cs:ws) reverseList [] = [] reverseList w = go3 [] w where go3 rev [] = rev go3 rev (c:cs) = go3 (c:rev) cs 이것에는 문제가 너무 많다. 그중 세 개만 보자. 우리가 monsterRevWords는 기대되는 동작을 수행한다고 동작하면, 여러분은 이 함수를 온갖 종류의 가능한 입력에 일일이 시험해 보거나 이걸 이해하려 시도하다 끔찍한 두통이 올 것이다.(그러지 말기를...) 게다가 함수를 이렇게 못나게 작성했는데 나중에 버그를 고쳐야 하거나 조금 수정해야 한다면 5, 시간을 겁나게 투자할 각오를 해야 한다. 마지막으로, 알아보기 쉬운 잠재적인 문제가 적어도 하나 있다. 정의를 한 번 더 훑어보면 중간 언저리에 문자가 공백인지 아닌지 검사하는 testSpace라는 도우미 함수가 있다. 하지만 이 검사는 오직 일반적인 공백 문자(즉 ' ')만을 포함하고 다른 공백 문자들(탭, 줄바꿈 등)은 포함하지 않는다. 6 위의 쓰레기 대신 다음의 Prelude 함수들을 활용해서 훨씬 잘할 수 있다. words 함수. 문자열을 공백으로 구분된 낱말들로 믿을 만하게 쪼개서 문자열들의 리스트를 반환한다. reverse 함수. 리스트를 뒤집는다(우연히도 위의 reverseList가 하는 일이다). unwords 함수. words의 반대되는 일을 한다. 그러면 함수 합성은 우리의 문제를 순식간에 해결한다. 예: 하스켈식 revWords revWords :: String -> String revWords input = (unwords . reverse . words) input 짧고, 단순하고, 가독성 있고, Prelude는 믿을 만하기 때문에 버그 걱정이 없다. 7 그러니 프로그램을 작성하다 monsterRevWords 같은 게 보이기 시작한다면 여러분의 도구상자, 즉 라이브러리를 들여다볼 것. 어휘 사전 얻기 위의 엄중한 경고 이후 우리가 앞으로 표준 라이브러리를 깊게 파고들 거라고 기대할지도 모르겠다. 하지만 우리는 그 길로 가지 않는다. 적어도 이 책의 초반부에서는. 초급반은 하스 켈 언어 기초의 대부분을 읽기 쉽고 사리에 맞게 압축하여 다루는 것이 목적인데, 라이브러리를 순서대로 체계적으로 다루자면 그걸 희생해야 한다. 어느 경우든 코스를 계속하며 라이브러리를 점차 손에 쥐게 될 터이니 여기서 멈추고 스스로 라이브러리를 공부하러 갈 필요는 없다. 라이브러리를 배울 때 활용할 수 있는 자료들을 몇 개 제안해 본다. 이 책에서 하스 켈 초급에 발을 들이고 나면 Prelude 함수들의 정의와 동등한 것을 작성하는 여러 연습문제를 만날 것이다. (주로 리스트 처리에 관한 것들) 이 연습문제들을 풀 때마다 여러분의 레퍼토리에 함수를 하나쯤은 보탤 수 있다. 지금부터 예제에서든 그냥 지나가듯 언급하든 더 많은 라이브러리 함수를 소개할 것이다. 그때마다 함수를 여러모로 실험해 보라. 타입의 기초에서 언급한, 타입에 관한 습관적인 호기심을 함수 자체로까지 넓힐 것. 처음의 몇 장은 서로 상당히 얽혀있지만, 책의 뒷부분들은 보다 독립적이고, 특히 3부인 하스 켈 실전이 그렇다. 거기서 계층적 라이브러리에 대한 장을 찾을 수 있는데, 하스 켈 초급을 떼고 나면 대부분의 내용을 이해할 수 있다. 초급반의 끝자락에 다다르면 논의할 개념들(특히 모나드)을 따라가면 자연스레 핵심 라이브러리의 중요한 부분들을 탐구하게 될 것이다. 외부 자료들 무엇보다도 문서가 있다. 지금 당장 유용하기엔 확실히 너무 무미건조하지만 곧 그 가치가 드러날 것이다. 온라인에서 Prelude 명세서와 GHC에 딸려오는 라이브러리에 관한 문서를 읽을 수 있다. 안내 기능도 출중하고 한 번 클릭만으로 소스 코드를 볼 수 있다. Hoogle은 기막힌 문서 검색 수단이다. Hoogle은 핵심 라이브러리를 다루는 하스 켈 검색 엔진이다. 함수 이름이나 타입 선언 등 모든 것을 검색할 수 있다. GHC에 포함된 라이브러리 너머에는 거대한 라이브러리 생태계가 있고 Hackage를 통해 얻을 수 있고 cabal 이란 도구로 설치할 수 있다. Hackage 사이트에는 거기서 얻을 수 있는 라이브러리들에 관한 문서도 있다. 초급반에서는 핵심 라이브러리 바깥을 모험하지 않지만 여러분이 자신만의 프로젝트를 시작하고 나면 Hackage에 이끌리게 될 것이다. 다른 하스 켈 검색 엔진으로 Hayoo! 가 있다. 이것은 Hackage의 전부를 다룬다. 적절한 때마다 다른 학습 자료들을 소개할 것이다. 특히 중급반과 고급 주제에서. 노트 (.)는 같은 식으로 작동하는 수학 연산자 ο를 본뜬 것이다. (g ο f)(x) = g(f(x))이다. ↩ 이런 간편함은 우리가 언급한 문법 덕분만은 아니며, 주로 나중에 깊게 설명하고 논할 특성들, 특히 고차 함수 덕분이다. ↩ 한 가지 간단한 예시는 곧 나올 리스트 처리에 관한 장들에서 다룰 map, filter, fold 같은 것이다. 또 다른 예시로 여러 모나드가 있는데 나중에 심도 있게 공부할 것이다. ↩ 이 예제는 HaskellWiki의 Simple Unix Tools에 영감을 받은 것이다. ↩ 공동 저자들의 노트: "나중에? 난 이걸 30분 전에 썼는데 이게 어떻게 작동하는지 벌써 가물가물해..." ↩ 문자가 공백인지 검사하는 신뢰할 만한 방법은 Data.Char 모듈의 isSpace 함수를 쓰는 것이다. ↩ 의심이 든다면 Prelude에든 Data.List에든 다른 함수가 많은데 이것들로 monsterRevWords를 보다 정상적으로 만들 수 있다. 이름만 읊자면 (++), concat, groupBy, intersperse 등이 있다. 하지만 이 경우엔 한 줄짜리 코드에 비할 바가 없는 것들이라 필요 없다. ↩ 9 간단한 입출력 원문: http://en.wikibooks.org/wiki/Haskell/Simple_input_and_output 현실로 돌아오다 do를 통한 액션 연계 왼쪽 화살표에 대한 설명 <-는 마지막 액션을 제외하고 어떤 액션에도 쓸 수 있다 액션 제어하기 액션 해부하기(Actions under the microscope) 액션의 타입을 염두에 둔다 표현식 타입도 따져본다 더 읽을거리 현실로 돌아오다 우리는 프로그램이 내부에서만 값을 계산하는 것을 넘어 세계와 상호작용하길 원한다. 어느 언어든 입문자를 위한 가장 흔한 프로그램은 화면에 "hello world" 인사말을 출력하는 것이다. 하스 켈 버전은 다음과 같다. Prelude> putStrLn "Hello, World!" putStrLn은 표준 Prelude 함수다. 이름의 putStr 부분이 암시하듯이 이 함수는 String 값을 인자로 취해 그걸 화면에 표시한다. putStr이라는 함수 자체도 따로 있지만, 보통은 "Ln"을 붙여서 줄바꿈도 출력하도록 만든다. 이러면 다음에 출력할 것은 새로운 줄에서 시작하게 된다. 이제 이런 생각이 들 것이다. "putStrLn 함수의 타입이 뭘까?" 이 함수는 String을 취해서... 뭘 돌려주냐면... 어? 뭐라고 해야 하지? 이 함수는 다른 함수에서 활용할 수 있는 무언가를 돌려주지 않는다. 대신 그 결과로 인해 컴퓨터가 화면을 변경하도록 만든다. 달리 말하자면 이 함수는 프로그램 바깥에 있는 세상에서 무언가를 수행한다. 이것의 타입을 뭐라고 해야 할까? GHCi가 뭐라고 하는지 보자. Prelude> :t putStrLn putStrLn :: String -> IO () "IO"는 "입력(input)과 출력(output)"을 뜻한다. 타입에 IO가 들어가면 프로그램 외부 세상과의 상호작용이 수반된다. 앞으로 이런 IO 값들을 액션이라고 부르겠다. IO 타입의 다른 부분, 이 경우 ()는, 액션의 결괏값의 타입이다. 즉 액션이 (프로그램 바깥에서 하는 일이 아니라) 프로그램에 돌려주는 무언가의 타입이다. ()는 ("유닛"이라 함) 타입은 오직 하나의 값을 가지는데 그 값도 ()라 부른다. (사실상 원소가 없는 튜플이다) putStrLn은 세상에 출력을 보내지만 프로그램에는 아무것도 돌려주지 않기 때문에, ()는 단순히 자리를 채우는 용도로 쓰인다. IO ()는 "()를 반환하는 액션"이라고 볼 수 있다. 다음은 IO를 사용하는 예시들이다. 화면에 문자열을 출력한다 키보드에서 문자열을 읽어온다 파일에 데이터를 쓴다 파일에서 데이터를 읽어온다 IO를 실제로 작동하게 만드는 건 무엇일까? putStrLn에서 화면 속 픽셀로 가기까지 그 이면에서는 많은 일이 일어난다. 하지만 프로그램을 작성하기 위해 그 디테일을 이해할 필요는 없다. 완전한 하스 켈 프로그램은 사실 하나의 거대한 IO 액션이다. 컴파일된 프로그램에서 이 액션의 이름은 main이고 그 타입은 IO ()이다. 이런 관점에서 보면 하스 켈 프로그램을 작성한다는 것은 액션들과 함수들을 결합하여 총체적인 액션 main을 형성하는 것이다. 그리고 프로그램을 켜면 main이 실행된다. 컴파일러는 어떻게 실행할지를 컴퓨터에게 지시한다. 연습문제 타입의 기초 장에서 openWindow 함수의 타입은 간소화된 것이라고 했었다. 그 실제 타입이 어때야 한다고 생각하는가? do를 통한 액션 연계 do 표기는 액션들을 묶는 편리한 수단을 제공한다. (do는 하스켈에서 유용한 작업을 하려면 필수다.) 다음 프로그램을 살펴보자. 예시: 이름이 뭐예요? main = do putStrLn "Please enter your name: " name <- getLine putStrLn ("Hello, " ++ name ++ ", how are you?") 잠깐 do 표기는 지금까지 봐온 하스 켈 코드와 아주 달라 보이지만, 실은 여러 함수에 대한 편의 문법일 뿐이며 그중에서도 가장 중요한 것은 (>>=) 연산자다. 이 함수들이 어떻게 작동하는지 설명하고 그다음 do 표기를 소개할 수도 있지만, 충분한 설명을 하려면 그에 앞서 다룰 주제가 많이 있다. 지금 do로 건너뛴 것은 실용적인 지름길로서, IO를 포함한 완전한 프로그램을 당장 작성할 수 있게 만든다. do가 어떻게 작동하는지는 나중에 모나드 이해하기장에서 알아볼 것이다. do가 어떻게 작동하는지 보기 전에 getLine을 살펴보자. getLine은 바깥세상, 이 경우 터미널로 나가서 String을 하나 가져온다. 그 타입은 무엇일까? Prelude> :t getLine getLine :: IO String getLine이 IO 액션이고, 실행되면 String을 하나 반환한다고 한다. 그럼 입력은? 함수는 인자를 취해 결과를 반환하는 걸 반영하는 a -> b 식의 타입을 가지는데 getLine은 인자를 취하지 않는다. getLine은 터미널의 무엇이든 그걸 입력으로 취한다. 하지만 바깥세상의 그 줄은 하스 켈 프로그램 안으로 가져오기 전에는 무언가 타입 있고 결정된 값이 아니다. 프로그램은 실행되기 전에는 바깥 세계의 상태를 모르기 때문에 IO 액션의 정확한 결과를 예측할 수 없다. 이런 IO 액션들과 프로그램의 다른 측면들의 관계를 관리하기 위해 액션들은 반드시 코드에서 미리 정의된, 예측 가능한 순서대로 실행되어야 한다. IO를 수행하지 않는 일반적인 함수들의 경우는 그 결과가 올바른 장소에 도달하기만 한다면 정확한 실행 순서가 그렇게 큰 문제가 아니다. 이름 묻기 프로그램에서 우리는 액션 3개를 연계하고 있다. 인사말을 출력하는 putStrLn, 그다음 getLine, 그리고 또 다른 putStrLn이다. getLine에서 사용한 <- 표기는 액션의 결괏값을 가리키기 위해 변수 이름을 할당하는 수단이다. 이 변수는 다른 곳에서 활용할 수 있다(이 경우 최종 메시지 출력을 준비하기 위해). 마지막 액션은 putStrLn의 결과이므로 전체 프로그램의 타입은 IO ()이다. 연습문제 사용자에게 직각삼각형의 밑변과 높이를 요청해서 그 넓이를 계산해 화면에 출력하는 프로그램을 작성한다. 상호작용은 이런 식이어야 한다. The base? 3.3 The height? 5.4 The area of that triangle is 8.91 힌트: read 함수를 사용해서 "3.3" 같은 사용자 문자열을 숫자 3.3으로 변환하고 show 함수로 숫자를 문자열로 반환할 수 있다. 왼쪽 화살표에 대한 설명 getLine 같은 액션은 거의 항상 값을 얻는 용도로 쓰이지만 우리가 반드시 그 값을 포착해야 하는 것은 아니다. 예를 들어 이렇게 쓰는 것도 가능하다. 예: getLine 직접 실행하기 main = do putStrLn "Please enter your name: " getLine putStrLn ("Hello, how are you?") 이 경우 입력을 전혀 활용하지 않지만 유저에게 이름을 입력할 수는 있게 만든다. <-를 생략하면 액션은 발생하지만 그 데이터는 어디에도 저장되지 않고 이 프로그램에서 접근할 수도 없다. <-는 마지막 액션을 제외하고 어떤 액션에도 쓸 수 있다 어떤 액션들로부터 값을 얻어오는 것이 가능한지에 관한 제약은 거의 없다. 다음 예제에서는 각 액션의 결과를 변수에 넣는다. (마지막은 제외하고... 나중에 알아보자) 예: 모든 결과를 변수에 넣기 main = do x <- putStrLn "Please enter your name: " name <- getLine putStrLn ("Hello, " ++ name ++ ", how are you?") 변수 x는 액션으로부터 값을 얻어오지만 이 경우에는 별 쓸모가 없다. 이 액션은 단위 값 ()를 반환하기 때문이다. 즉 기술적으로는 어떤 액션에서도 값을 뽑아올 수 있지만 항상 그럴 가치가 있는 건 아니다. 왜 마지막 액션에서는 값을 얻을 수 없을까? 그렇게 하면 어떤 일이 일어나는지 보자. 예: 마지막 액션에서 값 얻어오기 main = do x <- putStrLn "Please enter your name: " name <- getLine y <- putStrLn ("Hello, " ++ name ++ ", how are you?") 윽! 오류다! HaskellWikibook.hs:5:2: The last statement in a 'do' construct must be an expression 이걸 이해하려면 지금보다 하스켈을 깊게 이해해야 한다. 대략 말하자면 <-를 써서 액션으로부터 값을 얻을 때, 하스켈은 다른 액션이 뒤에 올 것이라고 기대한다. 그래서 가장 마지막 액션은 <-를 가질 수 없다. 액션 제어하기 if/then/else 같은 일반적인 하스 켈 요소를 do 표기 내에서 사용할 수 있지만 주의사항이 조금 있다. 예를 들면 다음과 같은 간단한 "숫자 알아맞히기" 프로그램에서, doGuessing num = do putStrLn "Enter your guess:" guess <- getLine if (read guess) < num then do putStrLn "Too low!" doGuessing num else if (read guess) > num then do putStrLn "Too high!" doGuessing num else putStrLn "You Win!" if/then/else는 조건식, "then" 분기, "else" 분기 이렇게 인자를 세 개 받는다. 조건식의 타입은 Bool이어야 하고, 두 분기는 타입만 같으면 어느 타입이든 가능하다. if/then/else 전체의 타입은 두 분기의 타입이다. 가장 바깥의 비교에서는 (read guess) < num이 조건식이다. 확실히 올바른 타입이다. 이번엔 "then" 분기를 보자. do putStrLn "Too low!" doGuessing num 여기선 두 액션 putStrLn과 doGuessing을 연계한다. 첫 액션의 타입은 IO ()이므로 괜찮다. 두 번째도 IO () 타입으로 괜찮다. 전체 계산의 결과 타입은 바로 마지막 계산의 타입이다. 따라서 "then" 분기의 타입도 IO ()이다. 비슷한 맥락에서 "else" 분기의 타입도 IO ()다. 따라서 if/then/else 전체의 타입도 IO ()이다. 바로 우리가 원한 것이다. 잠깐: "난 이미 do 블록을 시작했으니 또 다른 do는 필요 없겠지."라고 생각하고 있다면 조심하자. 이렇게 코딩할 수는 없다. do if (read guess) < num then putStrLn "Too low!" doGuessing num else ... 여기선 do를 반복하지 않았기 때문에 컴파일러는 putStrLn과 doGuessing 호출이 연계되어야 함을 알지 못하고, putStrLn을 인자 세 개를 가지고 호출하려 한다고 생각할 것이다. 그 인자들이란 바로 문자열, doGuessing 함수, 정수 num이다. 따라서 이 프로그램을 거부한다. 연습문제 사용자에게 이름을 묻는 프로그램을 작성한다. 그 이름이 Simon, John, Phil 중 하나라면 '나는 하스켈이 훌륭한 프로그래밍 언어라고 생각해'라고 사용자에게 말한다. 이름이 Koen 이면 '하스켈을 디버깅하는 것은 재밌어'라고 말한다. (Koen Classen은 하스 켈 디버깅을 작업하는 사람 중 하나다) 그 외의 경우 당신이 누구인지 모르겠다고 말한다. (문법상 이 프로그램을 작성하는 여러 방법이 있는데, 최소한 if / then / else를 쓰는 버전은 작성하자) 액션 해부하기(Actions under the microscope) 지금은 액션이 쉬워 보일 수 있지만 사실 액션은 하스 켈 입문자들의 흔한 진입장벽이다. 액션을 다루다 문제가 생기면 밑에 제시한 사례들 중 하나와 일치하는지 확인해 보자. 지금은 이 절을 건너뛰고 실제로 문제를 겪었을 때 돌아오는 것을 추천한다. 액션의 타입을 염두에 둔다 이름을 얻어 다시 출력하는 프로그램을 간단하게 만들고 싶은 유혹이 들 수도 있겠다. 다음은 성공적이지 않은 시도다. 예시: 왜 안 되지? main = do putStrLn "What is your name? " putStrLn ("Hello " ++ getLine) 이건 무슨 오류일까? HaskellWikiBook.hs:3:26: Couldn't match expected type `[Char]' against inferred type `IO String' 위의 예제를 가장 간단한 형태로 만들어보자. 이 프로그램이 컴파일될까? 예시: 이것도 안 된다 main = do putStrLn getLine 필요치 않은 "What is your name"과 정중한 "Hello"만 빼면 거의 같은 프로그램이다. 이것을 이해하는 한 가지 방법은 타입을 따져보는 것이다. 대조해 보자. putStrLn :: String -> IO () getLine :: IO String 타입의 기초에서 배운 사고방식을 그대로 활용하면 왜 틀렸는지를 알 수 있다. putStrLn은 입력으로서 String을 기대한다. 우리가 가지고 있는 것은 String이 아니라 미묘하게 비슷한 IO String다. IO String은 실행되면 String을 돌려주는 액션을 나타낸다. putStrLn이 원하는 String을 얻으려면, 액션을 실행한 다음 왼쪽 화살표 <-를 이용해야 한다. 예: 이제 된다 main = do name <- getLine putStrLn name 앞서의 복잡한 예제로 돌아가면 main = do putStrLn "What is your name? " name <- getLine putStrLn ("Hello " ++ name) 표현식 타입도 따져본다 우리는 액션을 호출하지 않는 상황에선 그 액션을 활용할 수 없다는 중요한 발상을 얻었다. 그 반대로, 액션이 예상되는 상황에서 액션이 아닌 것을 이용할 수는 없다. 사용자를 환영하려 하는데 이번에는 만나려니 무척 들떠서 이름을 크게 외치려고 한다. 예시: 흥미롭지만 틀렸다. 왜? import Data.Char (toUpper) main = do name <- getLine loudName <- makeLoud name putStrLn ("Hello " ++ loudName ++ "!") putStrLn ("Oh boy! Am I excited to meet you, " ++ loudName) -- Don't worry too much about this function; it just capitalises a String makeLoud :: String -> String makeLoud s = map toUpper s 이렇게 틀렸다... Couldn't match expected type `IO' against inferred type `[]' Expected type: IO t Inferred type: String In a 'do' expression: loudName <- makeLoud name 위에서 봤던 문제와 비슷하다. IO 타입이 예상되는 무언가와 그런 걸 내놓지 않는 무언가 사이에 불일치가 있다. 이번에는 왼쪽 화살표 <-의 쓰임새가 문제다. makeLoud name의 값을 얻으려고 하는데, <-의 재료는 아니다. 기본적으로 앞의 절에서 본 불일치와 같은 것인데 이번에는 정규 String을 IO String으로 쓰려고 했다는 것이 다르다. 분명히 이 둘은 다른 것이다. 후자는 실행될 액션이고 전자는 자기 일에나 신경 쓰는 표현식이다. 단순히 loudName = makeLoud name이라고 쓸 수는 없는데 do는 액션들을 연계하고 loudName = makeLoud name은 액션이 아니기 때문이다. 그럼 이 골칫덩어리를 어떻게 해결해야 할까? 여러 선택지가 있다. makeLoud를 액션으로 전환시켜 IO String을 반환하도록 만들 수 있다. 하지만 아무 이유 없이 액션이 세상으로 나가게 만들고 싶지는 않다. 우리의 프로그램 내에서는 모든 것이 어떻게 돌아가는지 믿을 만하게 검증할 수 있다. 액션이 바깥세상과 연관되면 우리의 결괏값은 덜 예측적이게 된다. IO makeLoud를 어떻게든 만들 수 있지만 이건 길을 잘못 들어선 것이다. 또 다른 문제를 생각해 보자. makeLoud를, IO가 아닌 다른 함수에서 쓰려고 한다면? IO 액션이 정말로 필요한 때를 제외하고는 어울리고 싶지 않다. 대문자 이름을 액션으로 만들기 위해 return이라는 특수 코드를 이용해 loudName <- return (makeLoud name)이라 쓸 수 있다. makeLoud 함수 자체는 훌륭하게 놔두고 IO로부터 자유로운 동시에 IO와 호환된다는 점에서 좀 낫다. 그래도 좀 투박한데, 맥빠지게 뭔가를 반환만 하고서 그다음으로 넘어가는 액션이 수행되는 꼴이기 때문이다. 이 얼마나 흥미진진한가! (잠깐: return의 적절한 사용법은 나중에 배울 것이다) 아니면 let 바인딩을 쓸 수도 있다... 사실 하스켈에는 액션 안에서의 let 바인딩을 위한 특별 편의 문법이 있다. 이런 것이다. 예: do 블록 내에서의 let 바인딩 main = do name <- getLine let loudName = makeLoud name putStrLn ("Hello " ++ loudName ++ "!") putStrLn ("Oh boy! Am I excited to meet you, " ++ loudName) 주의를 기울이면 위의 let 바인딩에는 in이 빠졌다는 걸 알아챌 수 있다. do 블록 내의 let 바인딩은 in 키워드가 필요하지 않다. 물론 in을 쓸 수도 있지만 지저분한 여분의 do 블록을 넣어야 한다. 도움이 될는지 몰라도 다음의 두 코드는 동등하다. 편함 불편함 do name <- getLine let loudName = makeLoud name putStrLn ("Hello " ++ loudName ++ "!") putStrLn ( "Oh boy! Am I excited to meet you, " ++ loudName) do name <- getLine let loudName = makeLoud name in do putStrLn ("Hello " ++ loudName ++ "!") putStrLn ( "Oh boy! Am I excited to meet you, " ++ loudName) 연습문제 let 바인딩의 불편한 버전에선 왜 여분의 do 키워드가 필요할까? 항상 여분의 do가 필요한 걸까? (추가 점수) 수상하게도 in 없는 let은 우리가 책의 초반부에서 인터프리터를 다룰 때 썼던 바로 그것이다. 왜 인터프리터에선 in 키워드를 생략해도 괜찮은데 소스 파일에선 in을 넣어야 하는 걸까? 더 읽을거리 이제 더 화려한 입출력을 다루기 위한 기반을 갖추었다. 다음은 이 책의 주 과목들과 병행해서 볼 만한 IO 관련 주제들이다. 과목들을 차례대로 진행해서 타입에 관해 더 배우고 최종적으로 모나드에 도달한다. 또는, GUI 장에서 그래픽 사용자 인터페이스를 제작하는 것을 배우기 시작할 수 있다. IO 관련 기능들을 더 알아보기 위해 System.IO 라이브러리 공부를 시작할 수 있다. 2 하스 켈 초급 하스 켈 초급 재귀(Recursion) 리스트 보충 설명(More about lists) 리스트 처리(List processing) 타입 선언(Type declarations) 패턴 매칭(Pattern matching) 제어 구조(Control structures) 함수 보충 설명(More on functions) 고차 함수(Higher order functions) GHCi 효율적으로 사용하기(Using GHCi effectively) 1 재귀 원문: http://en.wikibooks.org/wiki/Haskell/Recursion 수치 재귀 계승 함수 루프, 재귀, 매개변수 누적 다른 재귀 함수들 리스트 기반 재귀 재귀에 너무 들뜨지 말자... 재귀 함수는 하스켈에서 중추적인 역할을 수행하고 컴퓨터 과학과 수학 전반에 걸쳐 범용적으로 사용된다. 재귀는 기본적으로 반복의 한 형태인데 우리는 함수가 재귀적이라는 것의 의미와 그 동작을 분리해서 이해할 수 있다. 재귀 함수의 의미는 자기 자신을 호출할 수 있는 함수를 뜻한다. 그리고 동작 면에서 재귀 함수는 if/else/then 표현식 또는 패턴 매칭 같은 특정 조건을 만족할 때만 자기 자신을 호출하는데, 여기에는 재귀를 종료하는 기본 가정(base case)이 적어도 하나 있고 함수가 자기 자신을 호출하도록 하여 루프를 만드는 재귀 가정(recursive case)이 포함된다. 종료 조건이 없으면 재귀 함수는 영원히 루프를 돌아서 무한 회귀를 일으킨다. 수치 재귀 계승 함수 수학, 특히 조합론에는 계승(factorial)이라는 함수가 있다.1 이 함수는 음이 아닌 정수 하나를 인자로 취해 "n" 이하의 모든 양의 정수를 찾아 곱한다. 예를 들어 6의 계승(6!으로 표기)은 1 × 2 × 3 × 4 × 5 × 6 = 720이다. 이것을 하스켈에서 재귀 스타일로 정의할 수 있다. 인접한 두 수의 계승을 살펴보자. 예: 연속된 수들의 계승 Factorial of 6 = 6 × 5 × 4 × 3 × 2 × 1 Factorial of 5 = 5 × 4 × 3 × 2 × 1 숫자들을 어떻게 정렬했는지에 주목하자. 여기서 6! 이 5!를 포함하는 것을 볼 수 있다. 사실 6! 은 단지 6 × 5!이다. 계속해 보자. 예: 연속된 수들의 계승 Factorial of 4 = 4 × 3 × 2 × 1 Factorial of 3 = 3 × 2 × 1 Factorial of 2 = 2 × 1 Factorial of 1 = 1 어떤 수의 계승은 바로 그 수와 그 수보다 하나 작은 수의 계승을 곱한 것이다. 예외가 하나 있다. 0의 계승은 0에 -1의 계승을 곱한 것이 아니다(계승은 양수만을 위한 것이다). 사실 0의 계승은 1이다(그렇게 정한 것이다. 그냥 그렇다고 치자. 2) 따라서 0은 이 재귀의 기본 가정이다. 0에 다다르면 재귀 없이 답이 1이라고 바로 답한다. 계승 함수의 정의를 다음과 같이 요약할 수 있다. 0의 계승은 1이다. 다른 임의의 수의 계승은 그 수에 하나 적은 수의 계승을 곱한 것이다. 이것을 그대로 하스 켈로 번역할 수 있다. 예: 계승 함수 factorial 0 = 1 factorial n = n * factorial (n-1) 이 코드는 factorial이라는 새로운 함수를 정의한다. 첫 번째 줄은 0의 계승이 1이고, 두 번째 줄은 다른 임의의 수 n의 계승이 n 곱하기 n-1의 계승과 같다고 선언한다. n-1을 감싼 괄호에 주목하라. 괄호가 없었으면 (factorial n) - 1로 해석되었을 것이다. 함수 적용(함수를 어떤 값에 적용하는 것)은 그룹핑이 명시되지 않으면 최우선 순위를 차지함을 기억하자. (이를 두고 함수 적용이 다른 무엇보다 긴밀하게 묶인다고 한다) 잠깐 위의 factorial 함수는 썩 잘 정의된 것이지만, 조그만 함수이기 때문에 GHCi에선 한 줄로 작성하는 게 용이하다. 그러려면 중괄호(즉 {와 })와 세미콜론을 추가한다. let { factorial 0 = 1 ; factorial n = n * factorial (n - 1) } 하스켈은 사실 줄바꿈과 다른 공백들을 위의 구분 문자와 그룹핑 문자의 대용으로 쓴다. 하스 켈 프로그래머들은 대체로 줄바꿈과 적절한 들여 쓰기의 말쑥함을 선호하지만 세미콜론 같은 표시물을 선호한다면 이것도 괜찮다. let 문의 중괄호를 떼어내면 함수의 마지막 정의만 사용되어, 종료되는 기본 가정을 잃고 무한 재귀를 하게 된다는 것에 주의하라. 위의 예제는 숫자 n의 계승과 약간 작은 수 n-1의 계승 간의 아주 간단한 관계를 보여준다. 함수 호출을 하나의 위임으로 생각하라. 재귀 함수에 대한 명령은 부차적인 작업을 위임한다. 위임받는 함수는 위임하는 함수와 똑같은 명령을 사용한다. 변하는 것은 데이터뿐이다. 재귀 함수에 관해 정말로 헷갈리는 것은 각각의 함수 호출이 같은 매개변수 이름을 사용하기 때문에 많은 위임을 추적하기가 쉽지 않다는 것이다. factorial 3을 실행하면 무슨 일이 일어나는지 보자. 3은 0이 아니기 때문에 2의 계승을 계산한다 2는 0이 아니기 때문에 1의 계승을 계산한다 1은 0이 아니기 때문에 0의 계승을 계산한다 0은 0이므로 1을 반환한다 1의 계승 계산을 완성하기 위해 현재 수 1에 0의 계승인 1을 곱하여 1(1×1)을 얻는다. 2의 계승 계산을 완성하기 위해 현재 수 2에 1의 계승인 1을 곱하여 2(2×1×1)을 얻는다. 3의 계승 계산을 완성하기 위해 현재 수 3에 2의 계승인 2를 곱하여 6(3×2×1×1)을 얻는다. (1을 두 번 곱하는 것으로 끝나는 것에 주목하라. 0의 기본 가정은 1이기 때문이다. 1을 곱하면 아무 영향도 없기 때문에 괜찮다. 원한다면 factorial이 1에서 멈추게 설계할 수도 있지만 이것이 관습이고, 0의 계승을 정의하는 게 유용할 때도 있다.) 먼저 재귀 호출의 결과가 계산되고 그다음 곱셈으로 결합되는 방법을 볼 수 있다. 물론 재귀 함수를 읽거나 구성할 때 재귀를 이렇게 "풀어헤칠" 필요는 거의 없다. 그 동작은 컴파일러가 구현해야 하는 것이고, 프로그래머들은 추상적인 수준에서 일할 수 있다. factorial의 재귀적 정의에서 하나 더 눈여겨볼 점은 두 선언의 순서(factorial 0의 선언 다음 factorial n의 선언)이 중요하다는 것이다. 하스켈은 위에서부터 시작하여 제일 처음 일치하는 함수 정의를 쓰겠다고 결정한다. 일반적인 경우(factorial n)를 '기본 가정'(factorial 0)의 앞에 놓으면 이 일반적인 n은 전달되는 모든 것(0 포함)에 일치할 것이다. 그럼 컴파일러는 factorial 0이 0 * factorial (-1)과 같다고 결론짓고 음의 무한으로 치닫는다(분명 우리가 바라는 바는 아니다). 따라서 복수 개의 함수 정의는 항상 구체적인 것에서 가장 일반적인 것 순으로 나열한다. 연습문제 계승 함수를 하스 켈 소스 파일로 작성하고 GHCi로 불러와보자. factorial 5나 factorial 1000을 시도해 보자. factorial (-1)은 어떤가? 왜 그런 일이 일어날까? 수 n의 겹계승은 1(또는 2)에서 n까지의 모든 2 차이 나는 수의 곱이다. 가령 8의 겹계승은 8 × 6 × 4 × 2 = 384, 7의 겹계승은 7 × 5 × 3 × 1 = 105이다. 하스 켈로 doublefactorial 함수를 정의해 보자. 루프, 재귀, 매개변수 누적 명령형 언어는 하스 켈 프로그램이 재귀를 사용하는 것과 같은 문맥에서 루프를 사용한다. 예를 들어 C 같은 전형적인 명령형 언어에서 재귀 함수를 작성하는 자연스러운 방법은 for 루프를 사용하는 것이다. 예: 명령형 언어에서의 계승 함수 int factorial(int n) { int res = 1; for ( ; n > 1; n--) res *= n; return res; } 이 for 루프는 res에 n을 반복하여 곱한다. 각 반복 후에는 n에서 1을 뺀다(바로 n--이하는 일이다). 반복은 n이 1보다 크지 않으면 멈춘다. 이런 함수를 하스 켈로 곧이곧대로 번역하는 것은 불가능한데, 변수 res와 n의 값을 바꾸는 것(파괴적 갱신)이 허용되지 않기 때문이다. 하지만 루프는 항상 동등한 형태의 재귀로 번역할 수 있다. 갱신해야 하는 루프 변수를 재귀 함수의 인자로 만드는 것이다. 예를 들어 이것은 위의 루프를 하스켈식 재귀로 "번역"한 것이다. 예: 재귀로 루프 모사하기 factorial n = go n 1 where go n res | n > 1 = go (n - 1) (res * n) | otherwise = res go는 실제로 계승 계산을 수행하는 보조 함수다. go는 여분의 인자 res를 취하는데 res는 최종 결과를 쌓아 올리기 위한 누적 매개변수로 쓰였다. 잠깐 여러분에게 익숙한 언어를 생각해서 재귀가 일으키는 퍼포먼스 문제를 걱정할지도 모르겠다. 하지만 하스켈이나 여타 함수형 언어의 컴파일러들은 재귀를 위한 많은 최적화를 포함하는데, 재귀가 얼마나 흔히 필요한지를 생각해 보면 놀랄 일은 아니다. 또한 하스켈은 게으르다. 즉 계산이 수행되는 것은 오직 그 결과를 다른 계산이 요구할 때뿐이다. 이는 일부 퍼포먼스 문제를 회피하는 데 도움이 된다. 이와 관련한 문제들과 그 문제들이 수반하는 중요한 세부 요소들은 뒤에서 더 논할 것이다. 다른 재귀 함수들 조만간 드러나겠지만 factorial 함수에 뭔가 특별한 것은 없다. 많은 수치적 함수들은 재귀적으로 자연스럽게 정의된다. 가령 곱셈을 생각해 보자. 곱셈을 처음 배웠을 때(그때가 기억나는가? :)) '반복 덧셈'이라는 과정을 거쳤을 것이다. 즉 5 × 4는 숫자 5의 복사본 네 개를 합한 것과 같다. 물론 5의 복사본 4개를 더하는 것은 복사본 3개에 5를 하나 더하는 것과 같다. 즉 5 × 4 = 5 × 3 + 5이다. 여기서 자연스레 곱셈의 재귀 정의가 나온다. 예: 재귀적으로 정의된 곱셈 mult n 0 = 0 -- 아무개 곱하기 0은 영이다 mult n 1 = n -- 아무개 곱하기 1은 그대로다 mult n m = (mult n (m - 1)) + n -- 재귀: 하나 적은 것과 곱하고 여분의 복사본을 하나 더한다 잠깐 물러서서 보면 수치 재귀가 일반적인 재귀 패턴에 얼마나 잘 들어맞는지 볼 수 있다. 수치 재귀의 기본 가정은 통상 그 답이 즉각 나오는 하나 이상의 구체적인 수(주로 0이나 1)로 구성된다. 재귀 가정은 더 작은 인수로 함수를 재귀 호출한 결과를 어떤 방식으로 사용하여 최종적인 답을 도출해서 결과를 계산한다. 이때 쓰이는 '더 작은 인수'는 주로 현재 인수보다 하나 작은 것으로, '수직선을 걸어 내려가는' 재귀를 이끌어낸다(위의 factorial이나 mult처럼). 하지만 이런 원시적인 패턴만 가능한 건 아니다. 다른 방식으로도 이런 더 작은 인수를 만들 수 있다. 연습문제 factorial 3을 가지고 한 것과 비슷하게 곱셈 5 × 4를 전개하라. power x y가 x의 y 승인 재귀 함수 power를 정의하라. plusOne x = x + 1이란 함수가 주어졌다. 다른 (+)를 쓰지 않고 addition x y가 x와 y를 더하는 재귀 함수 addition을 정의하라. (어려움) 인자의 정수 로그(밑이 2)를 계산하는 함수 log2를 정의하라. 즉 log2는 인자 이하의 가장 큰 2의 거듭제곱의<NAME>를 계산한다. 예를 들어 log2 16 = 4, log2 11 = 3, log2 1 = 0이다. (작은 힌트: 이 연습문제들 바로 전 단락의 마지막 문장을 읽을 것.) 리스트 기반 재귀 하스켈의 많은 함수가 재귀적인데, 특히 리스트 관련 함수들이 그렇다.4 리스트의 길이를 알아내는 length 함수를 살펴보자. 예: length의 재귀적 정의 length :: [a] -> Int length [] = 0 length (x:xs) = 1 + length xs 노트 위 정의를 소스 파일로부터 불러오면 실제로 사용하려고 할 때 GHCi가 "모호한 출처(ambiguous occurrence)"에 대해 불평할 것이다. Prelude가 이미 length를 제공하기 때문이다. 이럴 때는 우리가 정의하려는 함수의 이름을 다른 것, 가령 length'나 myLength로 바꾸면 된다. 이 알고리즘이 어떻게 작동하는지 확실히 하기 위해 한국어로 풀어보자. length의 타입 시그너쳐는 임의 타입의 리스트를 취해 Int를 만들어낸다고 알린다. 다음 줄은 빈 리스트의 길이가 0이라 선언한다. 그리고 자연스레 이것이 기본 가정이 된다. 마지막 줄이 재귀 가정이다. 리스트가 비어있지 않으면 첫 번째 원소(여기선 x)와 리스트의 나머지(여기선 xs, 즉 x의 복수형. 원소가 더 없으면 단순히 빈 리스트)로 쪼갠다. 이 리스트의 길이는 1(x를 고려) 더하기 xs의 길이다(다음 과정의 tail과 마찬가지로 xs는 인자인 리스트가 (:) 패턴에 일치할 때 갖춰진다). 이번에는 두 리스트를 잇는 연결 함수 (++)를 살펴보자. 예: 재귀적 (++) Prelude> [1,2,3] ++ [4,5,6] [1,2,3,4,5,6] Prelude> "Hello " ++ "world" -- String은 Char들의 리스트다 "Hello world" (++) :: [a] -> [a] -> [a] [] ++ ys = ys (x:xs) ++ ys = x : xs ++ ys length보단 조금 복잡하지만 쪼개고 나면 그다지 어렵지 않다. (++)의 타입은 (++)가 같은 타입의 두 리스트를 취해 같은 타입의 또 다른 리스트를 생산한다는 것을 알린다. 기본 가정은 빈 리스트를 리스트 ys와 연결하는 것이 ys 자체와 같다고 선언한다. 마지막으로 재귀 가정은 첫 번째 인자를 x(머리)와 xs(꼬리)로 쪼개서, xs와 ys를 연결하고 그 앞에 머리인 x를 붙이라고 선언한다. 여기 패턴이 보인다. 리스트 기반 함수에서는 기본 가정이 통상 빈 리스트를 수반하고, 재귀 가정은 리스트의 꼬리를 함수에 다시 넘겨 리스트가 점차 작아지게 만든다. 연습문제 다음의 리스트 기반 함수들을 재귀적으로 정의하라. 각각 기본 가정이 어떨지를 생각한 다음에 재귀 가정은 어떨지를 생각해 볼 것. (여기의 모든 함수는 Prelude에 이미 있으므로 GHCi에서 여러분의 정의를 시험할 때는 이름을 다르게 해야 한다) replicate :: Int -> a -> [a]는 카운트와 한 원소를 취해 그 원소를 그만큼 반복한 리스트를 반환한다. 예를 들어 replicate 3 'a' = "aaa"다. (힌트: 카운트가 0일 때 무언가의 복제가 무엇이어야 하는지 생각해 보라. 카운트 0이 여러분의 '기본 가정'이다.) (!!) :: [a] -> Int -> a는 주어진 '인덱스'의 원소를 반환한다. 첫 번째 원소는 인덱스 0에, 두 번째는 1에 있는 식이다. Note that with this function, you're recursing both numerically and down a list.5 (살짝 어려움) zip :: [a] -> [b] -> [(a, b)]는 두 리스트를 취해 'zip'하여, 첫 번째 짝은 두 리스트의 처음 원소들이고, 그렇게 계속된다. 가령 zip [1,2,3] "abc" = [(1, 'a'), (2, 'b'), (3, 'c')]이다. 두 리스트의 길이가 다르면 하나라도 다 떨어지는 시점에서 멈출 수 있다. 가령 zip [1,2] "abc" = [(1, 'a'), (2, 'b')]이다. factorial의 루프식 대체 버전처럼 보조 함수와 누적 매개변수를 이용하여 length를 정의하라. 재귀는 리스트와 수에 관한 거의 모든 함수를 정의하는데 쓰인다. 나중에 리스트 기반 알고리즘이 필요할 때 빈 리스트의 경우와 비어있지 않은 리스트의 경우로 시작해서 혹시 알고리즘이 재귀적인지 살펴보라. 재귀에 너무 들뜨지 말자... 하스켈에서 재귀의 범용성에도 불구하고 우리가 명시적으로 재귀하는 함수를 작성할 일은 드물다. 대신 표준 라이브러리 함수들은 다양한 방식으로 우리 대신 재귀를 수행한다. 예를 들어 factorial은 이런 식으로 더 간단히 구현할 수 있다. 예: 표준 라이브러리 함수로 계승 구현하기 factorial n = product [1.. n] 부정행위 같지 않은가? :) 대부분의 노련한 하스 켈 프로그래머들은 factorial을 작성할 때 명시적인 재귀 대신 이렇게 할 것이다. 물론 product 함수는 그 이면에서 모종의 리스트 재귀를 수행하지만, 6 이런 식으로 factorial을 작성하면 프로그래머인 우리는 그런 재귀를 신경 쓸 필요가 없다. 수학에서 n! 이 일반적으로 음이 아닌 정수 n의 계승을 뜻하지만 이 문법은 하스켈에서 불가능하기 때문에 여기선 사용하지 않는다. ↩ 사실 0의 계승을 1로 정의한 건 임의로 한 게 아니다. 그 이유는 0의 계승이 공 곱셈(empty product)을 나타내기 때문이다. ↩ 흥미롭게도 구식 과학 계산기는 1000의 계승 같은 걸 다룰 수 없는데 자릿수가 너무 커서 메모리가 부족하기 때문이다! ↩ 우연의 일치가 아니다. 수정 가능한 변수가 없을 때 재귀는 제어 구조를 구현할 유일한 수단이다. 여기에 익숙해지기 전에는 어떤 한계처럼 보일 수도 있겠다. ↩ 부수적으로 (!!)는 리스트와 튜플/값 획득하기의 네 번째 연습문제의 그 문제에 합리적인 해답을 제공한다. ↩ 사실 product는 foldl이라는 함수를 이용하고 foldl이 실제로 재귀를 수행한다. ↩ 2 리스트 보충 설명 원문: https://en.wikibooks.org/wiki/Haskell/Lists_II 리스트 재구축하기 일반화하기 더 일반화하기 커링 map 함수 팁과 트릭 이중점 표기(Dot Dot Notation) 무한 리스트 head와 tail에 관한 노트 앞서 하스켈은 cons 연산자 (:)와 빈 리스트 []를 통해 리스트를 구축한다는 것을 배웠다. 재귀와 패턴 매칭을 조합해서 리스트의 원소들을 하나씩 처리하는 방법도 봤다. 이번 장과 다음 장에서는 리스트 처리를 위한 더 심도 있는 기법들을 살펴보고 몇 가지 새로운 표기들을 알아볼 것이다. 여기서는 무한 리스트, 리스트 조건 제시식(list comprehension), 고차 함수 같은 하스 켈 기능들을 맛볼 것이다. 잠깐 이번 장 전체에 걸쳐 우리는 리스트 원소들을 더하고, 빼고, 곱하는 함수들을 읽고 또 작성할 것이다. 간결함을 위해 리스트 원소들이 Integer 타입이라 가정하겠다. 그런데 타입의 기초 2에서 했던 논의를 떠올려보면 Num 타입 클래스에 속하는 타입은 여러 개 있었다. 함수들을 다형성으로 만들어 리스트 원소들이 Num 클래스의 임의의 타입을 가질 수 있도록 만들려면, 그런 함수들의 타입 시그너처가 무엇이어야 하는지를 일종의 연습 문제 삼아 생각해 볼 수 있다. 함수의 시그너처를 확인하려면 그것들을 명시하지 않고 생략하고, GHCi로 그 함수를 불러와서 :t를 사용해 타입 추론이 이끄는 길을 따라가자. 리스트 재구축하기 다음 함수는 정수 리스트의 모든 원솔르 두 배로 만든다. doubleList :: [Integer] -> [Integer] doubleList [] = [] doubleList (n:ns) = (2 * n) : doubleList ns 기본 가정은 빈 리스트로 평가되는 빈 리스트다. 재귀 가정에서 doubleList는 (:)를 이용하여 새로운 리스트를 구축한다. 이 새로운 리스트의 첫 번째 원소는 인자의 머리의 두 배이며, 결과의 나머지는 doubleList를 인자의 꼬리에 재귀적으로 호출하여 얻어진다. 꼬리가 빈 리스트라면 기본 가정이 실행되고 재귀는 멈춘다. 1 다음의 예시 표현식이 어떻게 평가되는지 연구해 보자. doubleList [1,2,3,4] 대수학 교과서처럼 인자를 함수 정의로 치환해가면 길게 늘어뜨릴 수 있다. doubleList 1:[2,3,4] = (1*2) : doubleList (2 : [3,4]) = (1*2) : (2*2) : doubleList (3 : [4]) = (1*2) : (2*2) : (3*2) : doubleList (4 : []) = (1*2) : (2*2) : (3*2) : (4*2) : doubleList [] = (1*2) : (2*2) : (3*2) : (4*2) : [] = 2 : 4 : 6 : 8 : [] = [2, 4, 6, 8] 모든 원소를 두 배로 만들어 원본 리스트를 재구축했다. 이 기나긴 평가 연습에서 우리가 곱셈을 평가하기로 고른 시점은 결과에 영향을 끼치지 않는다. 평가는 doubleList의 각각의 재귀 호출 직후에 할 수도 있었다.2 하스켈은 이런 평가 순서의 유연함을 몇 가지 중요한 방식으로 활용한다. 순수 함수형 프로그래밍 언어로서, 컴파일러는 무언가를 언제 실제로 평가할지를 대부분 결정한다. 지연 평가 언어로서, 하스켈은 최종 값이 필요할 때까지 평가를 미룬다(가끔은 영영 필요하지 않기도 하다).3 프로그래머의 관점에서 평가 순서를 신경 쓸 일은 드물다. 4 일반화하기 리스트의 각 원소를 세 배로 만들기 위해 doubleList와 같은 전략을 취할 수 있다. tripleList :: [Integer] -> [Integer] tripleList [] = [] tripleList (n:ns) = (3 * n) : tripleList ns 그런데 서로 다른 모든 승수(4, 8, 17 등)마다 새로운 리스트 곱셈 함수를 작성하고 싶지는 않다. 그러니 임의의 수를 곱할 수 있는 범용적인 함수를 만들어보자. 이 새로운 함수는 인자를 두 개 받는다. 하나는 피승수고 하나는 곱셈을 할 Integer 리스트다. multiplyList :: Integer -> [Integer] -> [Integer] multiplyList _ [] = [] multiplyList m (n:ns) = (m*n) : multiplyList m ns 이 예제는 _를 "신경 안 씀"(don't care) 패턴으로써 사용한다. 기본 가정에는 피승수가 쓰이지 않기 때문에 어떤 이름(m, n, ns 등)을 부여하는 대신 무시한다. mutiplyList가 예상대로 작동하는지 확인해 볼 수 있다. Prelude> multiplyList 17 [1,2,3,4] [17,34,51,68] 연습문제 다음 함수들을 작성하고 확인해 본다. 타입 시그너처를 잊지 말자. takeInt는 리스트의 처음 n 개 항목을 반환한다. 즉 takeInt 4 [11,21,31,41,51,61]는 [11,21,31,41]을 반환한다. dropInt는 리스트의 처음 n 개 항목을 버리고 나머지를 반환한다. 즉 dropInt 3 [11,21,31,41,51]은 [41,51]을 반환한다. sumInt는 리스트 내 항목들의 합을 반환한다. scanSum은 리스트 내 항목들을 더해 중간 합들을 담은 리스트를 반환한다. 즉 scanSum [2,3,4,5]은 [2,5,9,14]을 반환한다. diffs는 인접 항목들의 차이의 리스트를 반환한다. 즉 diffs [3,5,6,8]은 [2,1,2]을 반환한다. (힌트: 두 리스트를 취해 대응하는 항목들의 차를 계산하는 보조 함수를 작성한다. 또 다른 방법은 인자가 적어도 둘인 리스트는 (x:y:ys) 패턴에 일치한다는 사실을 활용하는 것이다. 처음의 세 함수는 Prelude에 take, drop, sum 이란 이름으로 들어있다. 더 일반화하기 이번 장을 원소들에 2를 곱하는 제한된 함수로 시작했다. 각 승수마다 새 함수를 하드코딩하지 않아도 된다는 것을 깨닫고 multiplyList를 만들어 임의의 Integer를 사용할 수 있게 되었다. 이제 덧셈 같은 다른 연산자를 사용하거나 각 원소의 제곱을 계산하고 싶다면 어떻게 해야 할까? 하스켈의 한 핵심 기능을 활용하면 더 일반화할 수 있다. 하지만 그 해결책이 꽤 놀라울 수도 있기에 빙 둘러 가는 접근법을 택할 것이다. multiplyList의 타입 시그너쳐를 살펴보자. multiplyList :: Integer -> [Integer] -> [Integer] 가장 먼저 알아야 할 점은 타입 시그너쳐의 -> 화살표가 우결합(right-associative)이라는 것이다. 즉 시그너쳐를 다음과 같이 읽을 수 있다. multiplyList :: Integer -> ( [Integer] -> [Integer] ) 이걸 어떻게 이해해야 할까? multiplyList가 Integer 인자 하나를 취해 또 다른 함수로 평가하는데, 그 함수는 Integer의 리스트를 취해 또 다른 Integer 리스트를 반환한다고 한다. 앞서의 doubleList 함수를 multiplyList를 이용해 재정의해 보자. doubleList :: [Integer] -> [Integer] doubleList xs = multiplyList 2 xs 이렇게 작성하면 xs를 깔끔히 소거할 수 있다. doubleList = multiplyList 2 인자 변수가 없는 이런 식의 정의를 "인자 생략"(point-free) 방식이라고 부른다. 이 표현식은 완벽히 형태를 갖춘 것이다. 따라서 multiplyList의 두 번째 인자(doubleList의 유일한 인자와 같은 그것)는 엄밀히는 불필요하다. multiplyList에 인자를 하나만 적용해도 평가가 실패하지 않으며, 단지 최종 [Integer] 값으로 종결하는 대신 [Integer] -> [Integer] 타입의 좀 더 구체적인 함수를 우리에게 돌려준다. 위의 기교는 하스켈의 함수가 다른 값들처럼 행동한다는 것을 시사한다. 다른 함수를 반환하는 함수, 인자를 명시하지 않고 독립 개체로서 존재하는 함수라. 함수가 마치 일반적인 상수인 것만 같다. 함수 자체를 인자로 쓸 수도 있을까? 이것이 multiplyList에 관한 우리의 딜레마의 열쇠다. 우리에겐 곱셈뿐 아니라 임의의 적절한 함수를 취해 리스트의 원소들에 적용하는 그런 함수가 필요하다. applyToIntegers :: (Integer -> Integer) -> [Integer] -> [Integer] applyToIntegers _ [] = [] applyToIntegers f (n:ns) = (f n) : applyToIntegers f ns applyToIntegers를 가지고 임의의 Integer -> Integer 함수를 취해 그 함수를 Integer의 리스트의 원소들에 적용할 수 있다. 물론 이 일반화된 함수를 가지고 multiplyList를 재정의할 수도 있다. 특히 applyToIntegers의 첫 번째 원소로 (*) 함수를 쓸 수 있다. multiplyList :: Integer -> [Integer] -> [Integer] multiplyList m = applyToIntegers ((*) m) 여기서는 (*) 함수에 인자를 하나만 넘겨서 다른 인자를 받을 준비가 된 새로운 함수를 생성한다. (이 경우 그 인자는 주어진 리스트 안의 수들로부터 전달된다) 커링 이 모든 추상화가 헷갈린다면 구체적인 예시를 보자. 하스켈에서 5 * 7을 할 때, (*) 함수는 두 인자를 한꺼번에 취하는 것이 아니다. 사실은 먼저 5를 취해서 5*라는 새로운 함수를 돌려준다. 그리고 이 새로운 함수는 하나의 인자를 취해 5에 곱한다. 즉 우리는 5* 함수에 7을 전달해서 그것이 최종 평가된 수(35)를 반환하는 것이다. 즉 하스켈의 모든 함수는 사실 인자를 하나만 취한다. 하지만 우리는 최종 결과에 도달하기 위해 얼마나 많은 중간 함수들이 생성될지 알고 있으므로 우리는 함수가 마치 여러 인자를 받는 것처럼 취급할 수 있다. 우리가 통상 말하는 함수의 인자 개수는 사실 첫 번째 인자와 함수가 아닌 최종 결괏값 사이의 일인자 함수의 개수다. 복잡한 함수에 인자들을 공급할 때 중간 함수들을 생성하는 이 과정을 커링currying이라 부른다(하스 켈 프로그래밍 언어와 동명이기도 한 하스 켈 카레(Haskell Curry)의 이름을 딴 것이다). map 함수 applyToIntegers의 타입이 (Integer -> Integer) -> [Integer] -> [Integer]이긴 하지만 이 알고리즘에는 정수에 한정되는 그런 게 없다. 따라서 타입 시그너쳐만 바꿔서 applyToChars, applyToStrings, applyToLists 같은 것을 정의할 수 있다. 하지만 이건 정말 낭비다. 각 타입마다 다른 함수를 정의하려고 여기까지 기어올라온 것이 아니다! 게다가 시그너쳐를 가령 (Integer -> String) -> [Integer] -> [String]으로 바꿔서, 함수가 Integer -> String 타입의 함수를 취해 Integer 리스트의 각각의 원소에 적용될 [Integer] -> [String] 타입의 함수를 반환하는 것도 아무 문제가 없다. 그리하여 일반화의 끝판은 applyToIntegers의 완전히 다형성인 버전으로 시그너쳐가 (a -> b) -> [a] -> [b]인 함수를 만드는 것이다. 그런 함수가 Prelude에 이미 있다. map이라는 함수로서 다음과 같이 정의된다. map :: (a -> b) -> [a] -> [b] map _ [] = [] map f (x:xs) = (f x) : map f xs map을 이용하면 별 노력을 들이지 않고 함수들을 구현할 수 있다. multiplyList :: Integer -> [Integer] -> [Integer] multiplyList m = map ((*) m) ...그리고... heads :: [[a]] -> [a] heads = map head Prelude> heads [[1,2,3,4],[4,3,2,1],[5,10,15]] [1,4,5] map은 한 함수를 리스트의 각 원소에 적용하는 이상적인 범용 해법이다. 기존의 doubleList 문제는 map의 아주 구체적인 한 버전일 뿐이었다. map처럼 다른 함수를 인자로 취하는 함수를 고차 함수라 부르고, 이것은 아주 유용하다. 특히 다음 장에서 리스트 처리에 쓰이는 다른 중요한 고차 함수들을 몇 개 만날 것이다. 연습문제 map을 이용하여, Int의 리스트 xs가 주어졌을 때 다음을 반환하라. xs의 원소들을 각기 반전한 리스트 xs의 각 원소에 대한 인수들을 포함하는, Int의 리스트의 리스트 xss. 인수들을 구하기 위해 다음 함수를 사용할 수 있다. divisors p = [ f | f <- [1.. p], pmodf == 0 ] xss의 원소별 반전 연속 길이 부호화(Run Length Encoding; RLE)의 인코더와 디코더를 구현하라. RLE의 발상은 간단하다. 어떤 입력이 주어지면 "aaaabbaaa" 각 문자가 연속되는 길이를 취해 압축한다. (4, 'a'), (2, 'b'), (3, 'a') concat 함수와 group 함수가 도움이 될 수 있다. group을 사용하려면 Data.List 모듈을 불러와야 한다. ghci 프롬프트에서 :m Data.List을 치거나 하스 켈 소스 코드 파일에 import Data.List을 추가해서 이 모듈에 접근할 수 있다. encode 함수와 decode 함수의 타입은 무엇인가? 튜플의 리스트(가령 [(4, 'a'), (6, 'b')])를 어떻게 문자열(가령 "4a6b")으로 변환할 것인가? (보너스) 원래 문자열에 숫자인 문자가 금지되어 있다고 가정하자. 그 문자열을 어떻게 튜플의 리스트로 다시 파싱 할 것인가? 팁과 트릭 리스트 처리를 더 배우기 전에 하스켈의 리스트에 대해 유용한 몇 가지 잡다한 점을 관찰해 보자. 이중점 표기(Dot Dot Notation) 하스켈에는 균일하게 떨어진 정수들의 정렬된 목록을 작성하는 편리한 단축법이 있다. 그 예로, 코드 결과 ---- ------ [1.. 10] [1,2,3,4,5,6,7,8,9,10] [2,4.. 10] [2,4,6,8,10] [5,4.. 1] [5,4,3,2,1] [1,3.. 10] [1,3,5,7,9] 문자에도 같은 표기를 쓸 수 있고 심지어 부동소수점 수도 가능하다. 반올림 오차 때문에 좋은 생각은 아니지만. 이것을 시도해 보라. [0,0.1 .. 1] 잠깐 .. 표기는 오직 연속된 원소들의 차이가 일정할 때만 작동한다. 이렇게는 쓸 수 없다... [0,1,1,2,3,5,8.. 100] 이래놓고 피보나치수열의 나머지를 돌려받는 마법을 기대할 순 없다. 5 무한 리스트 하스 켈 리스트에 관해 가장 뇌가 꼬이는 점은 무한할 수 있다는 것이다. 예를 들어 다음은 1로 시작하는 정수들의 무한 리스트를 생성한다. [1..] (GHCi에서 이걸 시도한다면, Ctrl-c로 평가를 멈출 수 있음을 기억하라.) 재귀 함수로도 같은 효과를 낼 수 있다. intsFrom n = n : intsFrom (n+1) -- 기본 가정이 없다! positiveInts = intsFrom 1 이것이 가능한 이유는 하스켈이 지연 평가를 하기 때문이다. 하스켈은 어느 시점에든 필요한 것 이상으로 평가하지 않는다. 대부분의 경우 무한 리스트를 평범한 리스트처럼 다룰 수 있다. 프로그램은 평가가 리스트의 모든 값을 요구하는 경우에만 무한 루프에 빠진다. 리스트 전체를 정렬하거나 출력하는 작업이 그 예다. 하지만 이것은 "evens"을 무한 리스트 [2,4,6,8...]으로 정의한다. 여러분은 "evens"를 다른 함수들에 전달할 수 있고, 최종 결과에 대해 리스트의 일부만 평가해도 되면 잘 작동한다. 무한 리스트는 하스켈에서 상당히 쓸모 있다. 가끔은 유한 리스트를 만드느니 무한 리스트를 정의하고 처음의 몇 항목을 취하는 것이 더 편할 때가 있다. 두 리스트를 동시에 처리하는 함수는 대개 짧은 것에 맞춰 멈추기 때문에 두 번째 리스트를 무한으로 만들면 첫 번째의 길이를 구할 필요가 없다. 무한 리스트는 상호작용형 프로그램의 최상위에서 전통적인 무한 루프의 간편한 대체재가 되기도 한다. head와 tail에 관한 노트 리스트를 쪼개기 위해 (:) 패턴과 head/tail 중 하나를 선택해야 할 때는 대개 패턴 매칭이 선호할 만하다. head와 tail의 단순함과 간명함은 유혹스럽지만 이것들이 빈 리스트에 대해 실패한다는 점을 까먹기는 너무 쉽고 런타임 크래시는 전혀 좋은 일이 아니. Prelude 함수 null :: [a] -> Bool이 패턴 매칭 없이 빈 리스트를 확인하는 건전한 수단을 제공하지만(null은 빈 리스트에 대해 True를, 그 외의 경우 False를 반환한다), 빈 리스트에 대한 패턴 매칭은 그에 대응되는 if-then-else 표현식보다 더 깔끔하고 깨끗한 경향이 있다. 연습문제 이 장의 첫 번째 연습문제 모음에 대한 여러분의 해답과 관련하여, scanSum (takeInt 10 [1..])과 takeInt 10 (scanSum [1..])에 차이가 있을까? 리스트에 적용하면 마지막 원소와 그 원소를 뺀 나머지를 반환하는 함수를 작성해 보자. 이 기능은 Prelude가 last와 init 함수로 제공하는 것이다. head와 tail처럼 빈 리스트를 받으면 폭발한다. 기본 가정을 빼먹으면 재귀가 빈 리스트에 다다랐을 때 (x:xs) 패턴 매칭이 실패하고 우리는 오류를 받게 된다. ↩ 계산 중 오류이거나 끝나지 않는 것이 없기만 한다면. 이 경우엔 문제가 되지 않는다. ↩ 컴파일러는 효율을 높일 수 있다면 자유로이 이것들을 즉시 평가할 수 있다. ↩ 한 가지 예외는 무한 리스트인 경우로(!) 곧 다룰 것이다. ↩ http://en.wikipedia.org/wiki/Fibonacci_number ↩ 3 리스트 처리 원문: http://en.wikibooks.org/wiki/Haskell/List_processing 접기(fold) foldr foldl foldr1과 foldl1 접기와 지연성 scan 걸러내기(filter) 리스트 조건 제시식(list comprehension) 접기(fold) 접기는 map처럼 함수와 리스트를 취하는 고차 함수다. 하지만 함수를 원소마다 적용하는 것이 아니라 이 함수를 이용해서 리스트 원소들을 단일 결괏값으로 합성한다. 몇 가지 구체적인 예시를 보며 시작하자. sum 같은 함수는 다음과 같이 구현할 수 있다. 예: sum sum :: [Integer] -> Integer sum [] = 0 sum (x:xs) = x + sum xs 또는 product. 예: product product :: [Integer] -> Integer product [] = 1 product (x:xs) = x * product xs 또는 concat. 리스트의 리스트를 취해 하나로 연결한다. 예: concat concat :: [[a]] -> [a] concat [] = [] concat (x:xs) = x ++ concat xs 이 예시들에는 모두 어떤 공통된 재귀 패턴이 있다. 이 패턴은 접기라는 것으로, 아마 리스트를 하나의 값으로 "꼬깃꼬깃 접는다"거나 함수가 리스트의 원소들 "사이에서 감싸진다"라는 발상에서 나온 것 같다. 표준 Prelude에는 네 개의 fold 함수 foldr, foldl, foldr1, foldl1이 정의되어 있다. foldr 우결합성인 foldr은 리스트를 오른쪽에서 왼쪽으로 접는다. 진행함에 따라 foldr은 주어진 함수를 사용해 각 원소를 누산 기라는 계속되는 값과 결합한다. foldr을 호출할 때 누산기의 초깃값이 인자로 설정된다. foldr :: (a -> b -> b) -> b -> [a] -> b foldr f acc [] = acc foldr f acc (x:xs) = f x (foldr f acc xs) 첫 번째 인자는 인자가 두 개인 함수고, 두 번째 인자는 누산기의 "영" 값, 세 번째는 접어버릴 리스트다. sum에서 f는 (+), acc는 0이고 concat에서 f는 (++), acc는 []다. 앞의 예제들처럼 접기에 전달되는 함수의 두 인자는 대개 같은 타입이지만 꼭 그래야 하는 것은 아니다. foldr f acc xs가 하는 일은 xs 리스트의 각각의 cons (:)을 함수 f로 대체하고 마지막의 빈 리스트는 acc로 대체하는 것이다. a : b : c : [] 는 이렇게 된다. f a (f b (f c acc)) 괄호들이 리스트의 끝에서 어떻게 중첩되는지에 주목하라. 리스트 자료 구조를 트리로 묘사하면 우아한 시각화를 만들 수 있다. : f / \ / \ a : foldr f acc a f / \ -------------> / \ b : b f / \ / \ c [] c acc 여기서 foldr (:) []이 리스트를 완전히 그대로 반환한다는 걸 볼 수 있다. 아무 영향이 없는 이런 유의 함수를 항등 함수라 한다. 여러 경우에서 항등 함수를 찾아보는 습관을 길러야 하며 이에 관해서는 모 노이드를 배울 때 더 논할 것이다. foldl 좌 결합성 foldl은 리스트를 반대 방향으로 처리해서, 좌측의 첫 번째 원소부터 시작한다. foldl :: (a -> b -> a) -> a -> [b] -> a foldl f acc [] = acc foldl f acc (x:xs) = foldl f (f acc x) xs 결과 표현식의 괄호들은 리스트의 왼쪽 끝에 쌓인다. 위의 리스트는 foldl f acc에 의해 변환된 후 다음과 같이 된다. f (f (f acc a) b) c 이에 대응하는 트리는 다음과 같다. : f / \ / \ a : foldl f acc f c / \ -------------> / \ b : f b / \ / \ c [] acc a 모든 접기가 왼쪽 원소와 오른쪽 원소 둘 다를 포함하기 때문에 초급자들은 그 이름이 혼란스러울 수 있다. foldr은 오른쪽에서 왼쪽으로 접기의 줄임말, foldl은 왼쪽에서 오른쪽으로 접기의 줄임말로 생각할 수 있다. 이 이름들은 접기가 시작하는 지점을 지칭한다. 잠깐 기술적 측면의 기록: foldl은 꼬리 재귀다. 즉 자신을 호출하여 즉시 재귀한다. 그러면 컴파일러는 재귀를 간단한 루프로 최적화할 수 있고, 이는 수행능력 측면에서 좋은 것이다. 하지만 하스켈은 게으른 언어고 f에 대한 호출은 기본적으로 평가되지 않은 채 남겨지기 때문에, 리스트의 전체를 포함하는, 미평가된 표현식을 메모리에 얹어놓게 된다. 메모리 부족을 피하기 위해 각 단계마다 f를 즉각 평가하도록 강제하는 foldl'이라는 적극적인 접기가 있다. 함수 이름 끝의 따옴표는 "틱"이라고 발음하고 함수는 "폴드-엘-틱"이다. 틱은 하스 켈 식별자로 올바른 문자다. foldl'은 Data.List 라이브러리 모듈에서 찾을 수 있다(소스 파일의 시작 부분에 import Data.List을 추가하여 들여올 수 있다). 경험상 foldr은 무한할 수 있는 리스트 혹은 접기가 자료 구조 구축 수단일 때 쓰고, foldl'은 리스트가 유한하고 단일 값으로 접힐 때 쓰는 게 좋다. 리스트가 너무 길지 않으면 작동은 하겠지만, foldl(틱 없는)을 쓸 좋은 이유는 전혀 없다. foldr1과 foldl1 앞서 언급했듯이 foldr의 타입 선언은 리스트 원소들과 결과가 다른 타입을 가지는 것을 가능케 한다. 가령 read는 문자열을 취해 모종의 타입으로 변환하는 함수다(타입 체계는 그게 어떤 타입인지 알아낼 만큼 충분히 똑똑하다). 다음 경우에는 문자열을 부동소수점 수로 변환한다. 예: 리스트 원소들과 결괏값은 다른 타입을 가질 수 있다 addStr :: String -> Float -> Float addStr str x = read str + x sumStr :: [String] -> Float sumStr = foldr addStr 0.0 foldr의 타입에서 타입 변수 a와 b를 Float과 String으로 치환하면 이 타입이 올바르단 것을 볼 수 있다. foldr1("폴드-알-원")이란 변종도 있는데 리스트의 마지막 원소를 명시적으로 취하여 영값을 없앤다. foldr1 :: (a -> a -> a) -> [a] -> a foldr1 f [x] = x foldr1 f (x:xs) = f x (foldr1 f xs) foldr1 _ [] = error "Prelude.foldr1: empty list" 그리고 foldl1도 있다. foldl1 :: (a -> a -> a) -> [a] -> a foldl1 f (x:xs) = foldl f x xs foldl1 _ [] = error "Prelude.foldl1: empty list" 잠깐: foldl처럼, Data.List 라이브러리에는 foldl1의 적극적인 버전 foldl1'이 포함되어 있다. foldl1과 foldr1에선 모든 타입이 같아야 하고 빈 리스트는 오류다. 이 변종들은 초기 누산 값으로 마땅한 후보가 없고 리스트가 비어있을 일이 없다고 확신할 때 유용하다. 의심의 여지가 있다면 foldr과 foldl'을 고수하라. 접기와 지연성 우결합성 접기가 하스켈에서 좌 결합성 접기보다 자연스러운 이유는 오른쪽 접기는 무한 리스트에 대해 기능할 수 있기 때문이다. 무한 리스트를 반환하는 접기는 무한한 결과 전체에 접근할 필요가 없는 더 큰 문맥에서 이용하기에 완벽하다. 그런 경우 foldr은 필요한 만큼 얼마든지 나아갈 수 있고 컴파일러는 나머지는 처리하지 않을 것이다. 하지만 왼쪽 접기는 입력 리스트의 끝에 다다를 때까지 자기 자신을 재귀적으로 호출해야 한다(재귀 호출이 f의 인자에서는 이루어지지 않기 때문). 말할 필요도 없이 foldl의 입력 리스트가 무한하면 그 끝은 다다를 수 없다. 간단한 예시로 정수의 리스트를 취해 숫자 n을 n 번 복제한 리스트를 생산하는 함수 echoes를 고려해 보자. 이 메아리 함수를 제작하기 위해 Prelude 함수 replicate을 쓸 것이다. replicate n x는 모든 원소가 x인 길이 n의 리스트다. echoes는 foldr로 꽤 간단히 작성할 수 있다. echoes = foldr (\ x xs -> (replicate x x) ++ xs) [] 잠깐: 이 정의는 \ x xs -> 구문 덕에 꽤 간결하다. 람다(λ)처럼 생긴 \는 이름 없는 함수이며, 우리는 이 함수를 다른 데서는 쓰지 않을 것이다. 그래서 식 안에 일회용 함수를 내장한 것이다. x와 xs는 람다의 인자고, 정의의 우변은 -> 뒤에 온다. 또는, 역시 간편한 foldl을 쓸 수 있다. echoes = foldl (\xs x -> xs ++ (replicate x x)) [] 하지만 foldr 버전만이 [1..] 같은 무한 리스트에 대해 작동한다. 시도해 보라! (GHCi에서 시도하는 거라면 Ctrl-c로 평가를 멈출 수 있다. 모니터에 눈을 붙이고 빨리하지 않으면 메모리가 순식간에 바닥나 시스템이 멈출 것이다.) 알아챘을지 모르겠지만 마지막 예제는 map 자체도 접기로 구현할 수 있다는 것이다. map f = foldr (\x xs -> f x : xs) [] 접기는 익숙해지는 데 별로 시간이 안 걸리지만 함수형 프로그래밍에서 근본적인 패턴이며 결국 아주 자연스러워질 것이다. 리스트를 순회하고 그 구성요소들로부터 결과를 구축하려면 언제든지 접기를 활용할 수 있다. 연습문제 다음 함수들을(앞의 sum, product, concat처럼) 재귀적으로 정의한 다음 접기로 바꿔보라. and :: [Bool] -> Bool. Bool의 리스트의 전체가 True 면 True를, 그 외의 경우 False를 반환한다. or :: [Bool] -> Bool. Bool의 리스트에서 하나라도 True 면 True를, 그 외의 경우 False를 반환한다. foldl1과 foldr1을 사용하여 다음 함수들을 정의하라. maximum :: Ord a => [a] -> a. 리스트의 최대 원소를 반환한다(힌트: max :: Ord a => a -> a -> a는 두 값 중 작지 않은 값을 반환한다). minimum :: Ord a => [a] -> a. 리스트의 최소 원소를 반환한다(힌트: min :: Ord a => a -> a -> a은 두 값 중 크지 않은 값을 반환한다). 접기로(어떤 버전?) reverse :: [a] -> [a]를 정의하라. 원소들의 순서를 뒤집은 리스트를 반환한다. 이것들은 이미 Prelude 함수이기 때문에 필요하면 언제든 손에 가까이 있다. (여러분의 해답을 GHCi에서 시험하려면 약간 다른 이름을 써야 한다는 뜻이기도 하다) scan "scan"은 map과 접기의 경합 같은 것이다. 리스트를 접으면 단일 결과로 누적되는 반면 한 함수를 통해 각각의 원소를 사상하면 누적되지 않는다. scan은 둘 다 한다. 접기처럼 값을 누적하지만 결괏값을 반환하는 대신 모든 중간의 값을 담은 리스트를 반환한다. 표준 Prelude에는 네 개의 scan 함수가 포함되어 있다. scanl :: (a -> b -> a) -> a -> [b] -> [a] 이것은 리스트를 왼쪽부터 누적하고, 두 번째 인자는 결과 리스트의 첫 번째 항목이 된다. 즉 scanl (+) 0 [1,2,3] = [0,1,3,6]이다. scanl1 :: (a -> a -> a) -> [a] -> [a] scanl과 같지만 리스트의 첫 번째 항목을 영 번 매개변수로 쓴다. 입력 항목과 출력 항목이 같은 타입이면 대개 이걸 사용한다. 타입 시그너쳐의 차이에 유의할 것. scanl1 (+) [1,2,3] = [1,3,6]이다. scanr :: (a -> b -> b) -> b -> [a] -> [b] scanr1 :: (a -> a -> a) -> [a] -> [a] 두 함수는 scanl과 scanl1의 정확히 반대다. 총계를 오른쪽부터 누적한다. 즉 scanr (+) 0 [1,2,3] = [6,5,3,0] scanr1 (+) [1,2,3] = [6,5,3] 연습문제 여러분 고유의 scanr을 먼저 재귀로, 그다음 foldr으로 정의하라. 다음 함수들을 정의하라. factList :: Integer -> [Integer]. 1에서 인자까지의 계승들의 목록을 반환한다. 예를 들어 factList 4 = [1,2,6,24]이다. 추가 예정 걸러내기(filter) 필터링은 리스트에 대해 수행되는 아주 흔한 연산으로, 처음 리스트에서 특정 조건을 만족하는 원소들로만 구성된 새로운 리스트를 반환하는 작업을 뜻한다. 그 간단한 예가 정수의 리스트를 취해 짝수만 담는 리스트를 만드는 것이다. retainEven :: [Int] -> [Int] retainEven [] = [] retainEven (n:ns) = -- mod n 2는 정수 n을 2로 나눈 나머지를 계산한다. 즉 짝수일 때는 0이다. if ((mod n 2) == 0) then n : (retainEven ns) else retainEven ns 이걸로 잘 작동하지만 다소 장황한 해결책이다. 필터 함수를 작성하는 보다 간결하고 일반적인 방법이 있으면 좋을 것 같다. Prelude가 filter란 걸 이미 제공하고 타입 시그너쳐는 다음과 같다. filter :: (a -> Bool) -> [a] -> [a] 즉 (a -> Bool) 함수는 조건에 대해 원소를 시험하고, 그다음 걸러낼 리스트가 있고, 걸러낸 리스트를 반환한다. filter로 retainEven를 작성하려면 이런 식으로 조건을 (a -> Bool) 타입의 보조 함수로 나타내야 한다. isEven :: Int -> Bool isEven n = ((mod n 2) == 0) 그러면 retainEven는 단순히 retainEven ns = filter isEven ns xs 대신 ns를 썼는데 이것들이 숫자일 뿐 다른 것이 아님을 안다는 걸 합리적으로 나타내기 때문이다. 하지만 그런 건 무시하고 더 간결한 인자 생략식 정의를 사용할 수 있다. retainEven = filter isEven 우리가 앞서 map과 접기에 대해 예시를 들어 설명한 것과 마찬가지다. 이것들도 filter처럼 다른 함수를 인자로 취한다. 그리고 이것들을 인자 생략식으로 쓰면 이러한 "함수의 함수" 관점이 돋보인다. 리스트 조건 제시식(list comprehension) 리스트 조건 제시식은 리스트 처리를 위한 강력하고, 간결하고, 표현력 풍부한 문법적 도구다. 여러 가지 중에서도 리스트 조건 제시식은 필터링을 위한 편의 문법이다. Prelude의 filter를 쓰는 대신 retainEven을 이렇게도 작성할 수 있다. retainEven es = [ n | n <- es, isEven n ] 이 압축된 문법은 처음 보면 약간 겁이 나겠지만 쪼개보면 단순하다. 이걸 해석하는 한 가지 방법은, (중간부터 시작) 리스트 es를 취해 각각의 원소를 값 n으로서 뽑는다("<-"). (쉼표 뒤) 뽑아낸 n마다 불리언 조건식 isEven n을 검사한다. (수직 막대 앞) 오직 불리언 조건이 만족될 때만 n을 새로 생성될 리스트에 추가한다(전체 표현식을 둘러싼 각괄호에 유의). 그러므로 es가 [1,2,3,4]와 같다면 [2,4]를 돌려받는다. 1과 3이 뽑히지 않는 건 (isEven n) == False이기 때문이다. 리스트 조건 제시식은 쉽게 확장할 수 있다는 것이 강점이다. 첫 번째로, 검사를 원하는 만큼(아예 안 할 수도) 있다. 복수 조건을 작성하려면 표현식의 목록을 쉼표로 구분한다(물론 불리언들로 평가되어야 한다). 간단한 예로 retainEven을 100보다 큰 수만 얻도록 수정하려면, retainLargeEvens :: [Int] -> [Int] retainLargeEvens es = [ n | n <- es, isEven n, n > 100 ] 게다가 리스트를 생성할 때 추가할 원소로 n만 써야 하는 것도 아니다. 수직 막대 앞에 어떤 표현 식도 놓을 수 있다 물론 리스트의 타입과 호환되는 한에서). 가령 모든 짝수에서 1을 빼고 싶다면, evensMinusOne es = [ n - 1 | n <- es, isEven n ] 결과적으로 리스트 조건 제시식이란 문법은 map과 filter의 기능을 통합한다. 이제야 간결해졌다(그리고 여전히 가독성 있다!). 더 마음에 드는 점은 리스트 조건 제시식의 왼쪽 화살표 표기를 패턴 매칭과 결합할 수 있다는 것이다. 예를 들어 (Int, Int) 튜플의 리스트에 대해, 두 번째 원소가 짝수인 튜플들의 첫 번째 원소로 리스트를 구축한다고 치자. 리스트 조건 제시식을 쓰면 다음과 같이 작성할 수 있다. firstForEvenSeconds :: [(Int, Int)] -> [Int] firstForEvenSeconds ps = [ fst p | p <- ps, isEven (snd p) ] -- 여기서 p는 짝이다. 패턴으로 더 가독성 좋게 만들 수 있다. firstForEvenSeconds ps = [ x | (x, y) <- ps, isEven y ] 다른 경우들과 마찬가지로 | 앞에 어떤 표현 식도 쓸 수 있다. 이 첫 번째 원소들의 2배수의 리스트를 원한다면, doubleOfFirstForEvenSeconds :: [(Int, Int)] -> [Int] doubleOfFirstForEvenSeconds ps = [ 2 * x | (x, y) <- ps, isEven y ] 스페이스를 빼면 함수 코드가 함수 이름보다 짧다! 그리고 더한 기교도 있다. allPairs :: [(Int, Int)] allPairs = [ (x, y) | x <- [1.. 4], y <- [5.. 8] ] 이 조건 제시식은 두 개의 리스트에서 원소들을 뽑는다. 첫 번째 원소는 [1.. 4]에서, 두 번째는 [5.. 8]에서 뽑아 모든 가능한 (x, y) 짝을 생성한다. 최종 짝 리스트는 첫 번째 리스트의 첫 번째 원소(여기선 1)를 가지고 생성한 것들 다음 첫 번째 리스트의 두 번째 원소를 가지고 생성한 것들이 오는 식이다. 이 예에서 완전한 리스트는 다음과 같다. (명료함을 위해 줄바꿈을 넣었다) Prelude> [(x, y)|x<-[1.. 4],y<-[5.. 8]] [(1,5),(1,6),(1,7),(1,8), (2,5),(2,6),(2,7),(2,8), (3,5),(3,6),(3,7),(3,8), (4,5),(4,6),(4,7),(4,8)] 최종 리스트에 포함될 조합들을 제한하는 조건도 쉽게 넣을 수 있다. somePairs = [ (x, y) | x <- [1.. 4], y <- [5.. 8], x + y > 8 ] 이 리스트는 원소들의 합이 8보다 큰 짝만을 포함한다. 처음은 (1, 8)이고 다음은 (2, 7) 이 오는 식이다. 연습문제 함수 returnDivisible :: Int -> [Int] -> [Int]을 작성한다. 이 함수는 정수 리스트를 걸러내서, 첫 번째 인자로 나눌 수 있는 수들만 통과시킨다. 정수 x와 n에 대해 (mod x n) == 0이면 x는 n으로 나눌 수 있다. (짝수 검사는 이것의 특수한 경우다) 함수 choosingTails :: [[Int]] -> [[Int]]를 리스트 조건 제시식으로 작성한다. 빈 리스트는 적절한 가드(필터)를 사용해 걸러내고 head가 5보다 큰 리스트들의 tail들만 반환해야 한다. choosingTails [[7,6,3],[],[6,4,2],[9,4,3],[5,5,5]] -- [[6,3],[4,2],[4,3]] 가드들의 순서가 상관이 있을까? 앞선 연습문제들에서 작성한 함수들을 이용해서 알아낼 수 있다. 이 절에서 봤듯이 리스트 조건 제시식은 근본적으로 filter와 map의 편의 문법이다. 이제 반대로 생각해서 리스트 조건 제시식 문법을 이용해 filter와 map의 대체 버전을 정의해 보자. 리스트 조건 제시식 대신 filter와 map을 사용해서 doubleOfFirstForEvenSeconds을 재작성해 보자. 4 타입 선언 원문: http://en.wikibooks.org/wiki/Haskell/Type_declarations 다른 챕터들을 봤지만 newtype에 관한 설명이 없어서 HaskellWiki에서 newtype 페이지를 따로 번역했습니다. http://codeonwort.tistory.com/279 data와 생성자 함수 타입 분해하기 타입 동의어를 만들기 위한 type 언어에서 기본적으로 제공하는 타입들만 써야 하는 것은 아니다. 우리만의 타입을 정의하면 많은 이점이 있다. 해결하려는 문제의 관점에서 코드를 작성할 수 있어서 프로그램을 설계하고 작성하고 이해하는 것을 쉽게 만든다. 관련된 데이터 조각들에 대해, 단순히 리스트나 튜플에 값을 넣거나 가져올 때보다 편리하고 의미를 부여할 수 있게 된다. 여러분만의 맞춤형 타입에 패턴 매칭과 타입 체계를 한껏 활용할 수 있다. 하스켈에는 새로운 타입을 선언하는 세 개의 기본적인 방법이 있다. data 선언. 새로운 데이터 타입을 정의한다. type 선언. 타입 동의어를 위한 것이다. newtype 선언. 위의 둘을 섞은 것이다. 이번 장에서는 data와 type을 다룬다. newtype은 나중에 설명할 것이다. data와 생성자 함수 data는 이미 있는 데이터 타입들을 기초 벽돌 삼아 새로운 타입들을 정의하는 데 쓰인다. 다음은 간단한 기념일 목록을 위한 자료 구조다. data Anniversary = Birthday String Int Int Int -- name, year, month, day | Wedding String String Int Int Int -- spouse name 1, spouse name 2, year, month, day 새로운 데이터 타입인 Anniversary를 선언하는데, Birthday도 Wedding도 될 수 있다. Birthday는 문자열 하나와 정수 세 개를 포함하고 Wedding은 문자열 두 개와 정수 세 개를 포함한다. 이 둘의 정의는 수직 막대로 구분된다. 주석은 코드를 읽는 이에게 새로운 타입들의 의도된 용법을 설명한다. 이 선언을 통해 우리는 Anniversary에 대한 두 개의 생성자 함수를 얻게 되었다. 적절하게도 그 이름은 Birthday와 Wedding이다. 이 함수들은 새로운 Anniversary를 생성하는 수단을 제공한다. data 선언으로 정의된 타입들을 대수적 데이터 타입(algebraic data type)이라 부르기도 한다. 이에 관해서는 나중에 다룰 것이다. 하스켈에서 으레 그러듯이 첫 번째 문자의 대소문자 여부는 중요하다. 타입 이름과 생성자 함수는 반드시 대문자로 시작해야 한다. 이런 문법상 세부사항 외에도 생성자 함수는 우리가 지금까지 만난 "전통적인" 함수와 상당히 비슷하게 작동한다. 사실 GHCi에서 :t를 통해 Birthday의 타입을 질의하면 다음을 얻게 된다. *Main> :t Birthday Birthday :: String -> Int -> Int -> Int -> Anniversary Birthday는 String 하나와 Int 세 개를 인자로 취해 Anniversary로 평가하는 함수일 뿐이다. 이 기념일은 우리가 Birthday 생성자에 명시한 네 인자를 포함할 것이다. 생성자 호출은 여타 함수 호출과 별반 다르지 않다. 예를 들어 1968년 7월 3일에 태어난 John Smith 씨를 생각해 보자. johnSmith :: Anniversary johnSmith = Birthday "John Smith" 1968 7 3 이 남자는 1987년 3월 4일에 Jane Smith와 결혼했다. smithWedding :: Anniversary smithWedding = Wedding "John Smith" "Jane Smith" 1987 3 4 두 기념일을 한 리스트에 넣을 수도 있다. anniversariesOfJohnSmith :: [Anniversary] anniversariesOfJohnSmith = [johnSmith, smithWedding] 또는 리스트를 구축할 때 생성자들을 바로 호출할 수도 있다(결과 코드가 좀 너저분하지만). anniversariesOfJohnSmith = [Birthday "John Smith" 1968 7 3, Wedding "John Smith" "Jane Smith" 1987 3 4] 타입 분해하기 우리의 새로운 데이터 타입을 사용하려면 그 내용물에 접근할 방법이 있어야 한다. 예를 들어 위에 정의한 기념일의 아주 기본적인 작업은 String으로 포함된 이름과 날짜를 추출하는 것이다. 따라서 showAnniversary 함수가 필요하다(코드를 명료하게 하기 위해 showDate란 보조 함수를 사용했지만 당분간은 무시하자). showDate :: Int -> Int -> Int -> String showDate y m d = show y ++ "-" ++ show m ++ "-" ++ show d showAnniversary :: Anniversary -> String showAnniversary (Birthday name year month day) = name ++ " born " ++ showDate year month day showAnniversary (Wedding name1 name2 year month day) = name1 ++ " married " ++ name2 ++ " on " ++ showDate year month day 이 예제는 우리의 데이터 타입에 내장된 값들을 어떻게 분해할 수 있는지를 보여준다. showAnniversary는 Anniversary 타입의 단일 인자를 취한다. 하지만 정의의 좌변에서 인자의 이름만 적는 대신 생성자 함수들 중 하나를 기입하고 그 생성자의 각 인자에 이름을 부여했다(Anniversary의 내용물과 대응한다). "이름을 부여하는" 것의 공식적인 서술은 변수를 바인딩 한다이다. "바인딩"은 변수를 각각의 값에 할당해서 함수 정의의 우변에서 그 값들을 참조할 수 있게 한다는 의미에서 쓰이는 것이다. "Birthday" 기념일과 "Wedding" 기념일 모두를 처리하기 위해 생성자마다 하나씩 두 개의 함수를 제공해야 한다. showAnniversary가 호출될 때, 그 인자가 Birthday 기념일이라면 첫 번째 정의가 사용되어 변수 name, month, date, year가 내용물들에 바인딩 된다. 인자가 Wedding 기념일이면 두 번째 정의가 사용되어 같은 식으로 변수들이 바인딩 된다. 생성자의 타입에 따라 함수의 여러 버전을 사용하는 이런 과정은 case 문이나 조각 함수 정의를 사용할 때 일어나는 일과 상당히 닮았다. 생성자 이름과 바인딩 변수를 감싸는 괄호는 필수라는 것에 주의하자. 그렇게 하지 않으면 컴파일러나 인터프리터는 이것들을 단일 인자로 취급하지 않는다. 또한 괄호 내의 표현식이 생성자 함수에 대한 호출처럼 생겼어도, 사실은 그렇지 않다는 것도 확실히 해두는 것이 중요하다. 연습문제 잠깐: 이 연습문제의 해답이 이번 장이 끝나갈 즈음 나오기 때문에 그전에 풀어보는 것을 추천한다. 위의 함수 정의를 다시 읽어보자. 그러고 나서 도우미 함수 showDate를 자세히 보자. 이것이 "코드의 명료함을 위해" 있다고 말헀지만 쓰이는 방식이 조금 이상하다. 우리는 세 개의 별개의 Int 인자를 전달해야 하지만 이 인자들을 항상 단일 날짜의 일부로서 서로 연결되어 있다. Anniversary의 연월일을 다른 순서로 전달하거나 월을 두 번 넘기고 일은 생략하는 그런 일은 사리에 맞지 않다. 이 장에서 봐온 것들을 활용하여 이런 조잡함을 없앨 수 있을까? 각각 년, 월, 일에 대응하는 세 개의 Int로 구성된 Date 타입을 선언하자. 그리고 showDate를 다시 작성해서 이 새로운 Date 데이터 타입을 사용하도록 만들어보자. 그러려면 showAnniversary와 Anniversary를 어떻게 바꿔야 할까? 타입 동의어를 만들기 위한 type 이 과목의 도입부에서 언급했듯이 맞춤형 타입을 쓰는 이유 중 하나는 코드의 명료함이다. 그런 뜻에서 Anniversary 타입 내의 String들이 이름으로 쓰이면서도 일반 String처럼 조작할 수 있음을 확실히 하면 좋을 것도 같다. 이를 type 선언이라 한다. type Name = String 위의 코드는 Name이 이제 String의 동의어라고 선언한다. String을 취하는 모든 함수는 이제 Name도 취할 것이다(그 반대로 Name을 취하는 함수도 모든 String을 받아들일 것이다). type 선언의 우변은 더 복잡한 타입일 수 있다. 가령 String 자체는 표준 라이브러리에 이렇게 정의되어 있다. type String = [Char] 우리가 써왔던 기념일 목록으로도 비슷한 것을 할 수 있다. type AnniversaryBook = [Anniversary] 타입 동의어는 대체로 편의를 위한 것이다. 타입 동의어는 타입의 역할을 명확하게 만들고 복잡한 리스트나 튜플 타입 같은 것들을 위한 별칭을 제공한다. 타입 동의어를 어떻게 만들지는 순전히 개인의 취향 문제다. 동의어를 남발하면 코드를 혼란스럽게 만들 수도 있다(Int나 String 같은 흔한 타입에 여러 가지 이름을 쓰는 장문의 프로그램을 생각해 보자). 타입 동의어와 앞의 절에서 제안한 연습문제(*)를 통합하여 이렇게 작성할 수 있다. (() 스포일러를 안 보고 그 연습문제를 시도할 마지막 기회다.*) type Name = String data Anniversary = Birthday Name Date | Wedding Name Name Date data Date = Date Int Int Int -- Year, Month, Day johnSmith :: Anniversary johnSmith = Birthday "John Smith" (Date 1968 7 3) smithWedding :: Anniversary smithWedding = Wedding "John Smith" "Jane Smith" (Date 1987 3 4) type AnniversaryBook = [Anniversary] anniversariesOfJohnSmith :: AnniversaryBook anniversariesOfJohnSmith = [johnSmith, smithWedding] showDate :: Date -> String showDate (Date y m d) = show y ++ "-" ++ show m ++ "-" ++ show d showAnniversary :: Anniversary -> String showAnniversary (Birthday name date) = name ++ " born " ++ showDate date showAnniversary (Wedding name1 name2 date) = name1 ++ " married " ++ name2 ++ " on " ++ showDate date 이런 간단한 예제에서도 Int, String, 관련된 리스트만 써서 동일한 작업을 했을 때보다 단순함과 명료함이 드러난다. Date 타입은 역시 그 이름이 Date인 생성자 함수를 가진다는 것에 주목하자. 여기에는 아무 문제가 없으며 생성자가 하나뿐일 때 생성자의 이름과 타입의 이름을 동일하게 만드는 것은 좋은 습관이다. 이는 함수의 역할을 명확하게 만드는 간단한 길이다. 잠깐 지금까지의 기초적인 예시들을 보고 나면 생성자 함수를 사용하는 방식이, 특히 여러분이 타 언어의 비슷한 특성에 익숙하다면, 거추장스럽게 보일 수도 있다. 생성자를 더 편하게 다루기 위한 문법적 요소들이 있으며 이에 관해서는 나중에 생성자와 데이터 타입이란 주제로 돌아올 때 더 자세히 다룰 것이다. 5 패턴 매칭 원문: https://en.wikibooks.org/wiki/Haskell/Pattern_matching 패턴 매칭 분석하기 생성자와의 연관성 리스트에 대해 작동하는 이유 튜플 생성자 리터럴 값과의 일치 문법 트릭 as 패턴 레코드의 도입 패턴 매칭을 쓸 수 있는 곳 등식 let 표현식과 where 절 람다 추상화 리스트 조건 제시식(list comprehension) do 블록 노트 앞선 과목들에서 패턴 매칭을 소개하고 자주 언급했다. 이제 하스켈에 어느 정도 익숙해졌으니 더 정확하고 깊은 안목을 기를 때가 되었다. 다음의 압축된 문장으로 운을 떼고 이번 장에서 전반적으로 풀어헤칠 것이다. 패턴 매칭은 값을 패턴에 일치시키려 시도하고, 필요하다면 성공적으로 일치한 곳에 변수를 바인딩 한다. 패턴 매칭 분석하기 패턴 매칭은 사실상 어디에나 있다. 예를 들어 다음의 map 정의를 보자. map _ [] = [] map f (x:xs) = f x : map f xs 여기에는 등식마다 2개씩 총 4개의 서로 다른 패턴이 들어있다. f는 모든 것에 일치하는 패턴으로서, 변수 f를 그 자리에서 일치하는 무엇에든 바인딩 한다. (x:xs)는 비어있지 않은 리스트에 일치하는 패턴으로서, 변수 x에 바인딩 되는 무언가와 xs에 바인딩 되는 다른 무언가가 (:) 함수에 의해 연결된다. []는 빈 리스트에 일치하는 패턴이다. 아무 변수도 바인딩 하지 않는다. _는 모든 것에 일치하는 패턴이지만 아무것도 바인딩 하지 않는다. (와일드카드, "신경 쓰지 않음" 패턴) (x:xs) 패턴에서 x와 xs는 리스트의 일부분에 일치시키기 위한 하위 패턴들로 볼 수 있다. 이 패턴들은 f와 마찬가지로 아무것에나 일치한다. 일치가 성공해서 x의 타입이 a라면 xs의 타입은 [a]라는 것은 명백하다. 마지막으로, xs는 빈 리스트에도 일치하며 따라서 원소가 하나인 리스트라도 (x:xs)에 일치한다. 지금까지 분석한 것을 보면 패턴 매칭이 다음 수단들을 제공한다고 볼 수 있다. 값을 인식한다. 예를 들어 map이 호출되고 두 번째 인수가 []에 일치하면 map의 두 번째 등식이 아니라 첫 번째 등식이 사용된다. 인식된 값에 변수를 바인딩 한다. 위 경우에는 두 번째 등식이 사용될 경우 변수 f, x, xs에는 map의 인수로서 전달된 값들이 할당되고, 따라서 =의 우변에서 이 변수들을 통해 그 값들을 이용할 수 있다. _와 []가 보여주듯이 바인딩은 패턴 매칭의 필수 요소가 아니며 변수 이름을 패턴으로서 쓸 때의 부수 효과일 뿐이다. 값을 분해한다. (x:xs) 패턴이 두 변수를 각각, 일치하는 인수(비어있지 않은 리스트)의 머리와 꼬리에 바인딩 하는 것이 그 예시다. 생성자와의 연관성 위에서 면밀히 분석하긴 했지만, (:) 연산자의 결과를 되돌린 것 마냥 리스트를 분해한 것이 마치 마법처럼 보일 수도 있다. 주의: 이런 작업을 모든 연산자에 대해 할 수 있는 것은 아니다. 예를 들어 (++)를 이용해서 리스트의 처음 세 원소를 잘라내는 함수를 정의해 보자. dropThree ([x, y, z] ++ xs) = xs 하지만 이런 것은 작동하지 않는다. (++) 함수는 패턴으로 허용되지 않는다. 사실 리스트에 작용하는 대부분의 함수는 패턴 매칭에 허용되지 않는다. 그럼 어떤 함수들이 허용되는 걸까? 한 마디로 말하면 생성자(constructor), 즉 대수 자료형(algebraic data type)의 값을 구축하는 데 쓰이는 함수들만이 가능하다. 임시로 만든 다음 예시를 보자. data Foo = Bar | Baz Int 여기서 Bar와 Baz는 Foo 타입의 생성자다. 이것들을 사용해 Foo 값을 패턴 매칭하고, Baz에 의해 생성된 Foo에 포함된 Int 값에 변수를 바인딩 할 수 있다. f :: Foo -> Int f Bar = 1 f (Baz x) = x - 1 이는 타입 선언 과목의 showAnniversary, showDate와 상당히 유사하다. data Date = Date Int Int Int -- Year, Month, Day showDate :: Date -> String showDate (Date y m d) = show y ++ "-" ++ show m ++ "-" ++ show d showDate 정의의 좌변의 (Date y m d) 패턴은 Date 생성자로 만들어진 Date 값과 일치하고 변수 y, m, d를 Date 값의 내용에 바인딩 한다. 리스트에 대해 작동하는 이유 패턴 매칭에 관한 한, 리스트는 data를 통해 정의된 다른 대수 자료형들과 다를 바가 없다. 리스트는 다음의 data 선언에 의해 정의된 것처럼 작동한다(이 구문은 실제로는 올바르지 않다. 리스트는 이런 식으로 정의하기에는 하스켈에 너무 깊숙이 뿌리를 내렸다). data [a] = [] | a : [a] 빈 리스트의 경우 []와 (:) 함수는 리스트 자료형의 생성자이며 따라서 이것들에 패턴을 일치시킬 수 있다. []는 인수를 취하지 않으므로 패턴 매칭에서 []에는 변수가 바인딩 될 수 없다. (:)는 리스트의 머리와 꼬리라는 두 인수를 취해, 패턴이 인식될 경우 변수들을 이 둘에 바인딩 한다. Prelude> :t [] [] :: [a] Prelude> :t (:) (:) :: a -> [a] -> [a] 게다가 [x, y, z]는 x:y:z:[]의 편의 구문일 뿐이기 때문에 dropThree 같은 것은 패턴 매칭만으로 가능하다. dropThree :: [a] -> [a] dropThree (_:_:_:xs) = xs dropThree _ = [] 첫 번째 패턴은 원소가 3개 이상인 어느 리스트에나 일치한다. 뭐든지 잡는 두 번째 패턴은 합리적인 기본값 1을 제공하여, 리스트가 주 패턴에 일치하지 않을 때 패턴 매칭 실패로 런타임 충돌이 일어나는 것을<NAME>다. 잠깐 dropThree 함수를 패턴 매칭만으로 작성할 수 있다고 해서 꼭 그래야 한다는 말은 아니다! 이 해결책은 간단하지만 이런 것을 코딩하는 것은 여전히 시간 낭비다. 그저 Prelude를 이용해 drop 3 xs로 대체할 수 있다. 재귀 함수 때 한 말을 그대로 해보면, 그렇다고 패턴 매칭에도 너무 들뜨지 말자... 튜플 생성자 튜플의 경우도 비슷한 논의가 적용된다. 패턴 매칭을 통해 튜플의 구성 성분들에 접근할 수 있다. fstPlusSnd :: (Num a) => (a, a) -> a fstPlusSnd (x, y) = x + y norm3D :: (Floating a) => (a, a, a) -> a norm3D (x, y, z) = sqrt (x^2 + y^2 + z^2) 이 또한 튜플 생성자가 있어서 가능하다. 짝(pair)의 생성자는 쉼표 연산자 (,)이다. 더 큰 튜플의 경우 (,,), (,,,) 등을 쓴다. 이 연산자들은 표준 방식으로는 중위 연산자로 쓸 수 없다. 5, 3은 (5, 3)을 작성하는 올바른 방법이 아니다. 하지만 이 연산자들은 모두 전치 연산자로 쓰일 수 있다. Prelude> (,) 5 3 (5,3) Prelude> (,,,) "George" "John" "Paul" "Ringo" ("George","John","Paul","Ringo") 리터럴 값과의 일치 앞서 논의했듯이 다음과 같은 조각 함수 정의도 패턴 매칭을 수행한다. f :: Int -> Int f 0 = 1 f 1 = 5 f 2 = 2 f _ = -1 여기서는 f의 인수를 Int 리터럴인 0, 1, 2, 마지막으로 _와 일치시킨다. 일반적으로 숫자 및 문자 리터럴은 그 자체로 2 패턴 매칭에 쓰일 수 있고 생성자 패턴과 함께 쓰일 수도 있다. 다음 함수는 g :: [Int] -> Bool g (0:[]) = False g (0:xs) = True g _ = False 리스트 [0]에 대해 False로, 첫 번째 원소가 0이고 꼬리가 빈 리스트가 아닌 리스트에 대해 True로, 다른 모든 경우 False로 평가된다. 또한 [1,2,3]처럼 리터럴이 있는 리스트나 "abc"(['a','b','c']와 동일)도 패턴 매칭에 쓸 수 있다. 이런 형태는 (:) 생성자의 편의 구문일 뿐이다. 위의 내용은 리터럴 값에만 해당한다. 이런 것은 작동하지 않는다. k = 1 --again, this won't work as expected h :: Int -> Bool h k = True h _ = False 연습문제 위의 결함 있는 함수 h를 GHCi에서 1인 인수와 1이 아닌 인수로 시험해 보자. 그러고 나서 뭐가 잘못되었는지 설명해 보자. 이번 절에서 리터럴 값을 이용한 패턴 매칭을 다루면서 불리언 값 True와 False는 전혀 언급하지 않았는데, 이 둘도 패턴 매칭이 가능하다. 다음 장에서 설명할 것인데, 왜 이 둘을 빠뜨렸는지 추측해 보자. (힌트: 불리언 값을 작성하는 별개의 방법이 있을까?) 문법 트릭 as 패턴 가끔 패턴과 값을 일치시킬 때, 일치되는 값 전체에 이름을 이름을 바인딩 하는 게 유용할 수도 있다. 이를 위한 것이 as 패턴이다. var@pattern 꼴이며, pattern에 매칭되는 전체 값에 이름 var를 바인딩 한다. 다음은 map의 변형이다. contrivedMap :: ([a] -> a -> b) -> [a] -> [b] contrivedMap f [] = [] contrivedMap f list@(x:xs) = f list x : contrivedMap f xs contrivedMap은 매개 함수 f에 x뿐 아니라 분리되지 않은 리스트도 재귀 호출의 인수로 전달한다. as 패턴을 쓰지 않으면 head를 쓰거나 원래의 list를 불필요하게 재구축, 즉 우변에서 x:xs를 평가해야 했을 것이다. contrivedMap :: ([a] -> a -> b) -> [a] -> [b] contrivedMap f [] = [] contrivedMap f (x:xs) = f (x:xs) x : contrivedMap f xs 연습문제 List Processing의 연습문제 scanr을 as 패턴을 써서 구현하라. 레코드의 도입 원소가 많은 생성자를 위해 레코드는 다음과 같은 구문을 통해 자료형의 값들에 이름 짓는 방법을 제공한다. data Foo2 = Bar2 | Baz2 {bazNumber::Int, bazName::String} 레코드를 쓰면 관심 있는 변수만 매칭, 바인딩 할 수 있어서 코드가 보다 깔끔해진다. h :: Foo2 -> Int h Baz2 {bazName=name} = length name h Bar2 {} = 0 data 선언에서 레코드를 쓰지 않더라도, {} 패턴으로 원소들의 데이터 타입에 상관없이 생성자를 매칭할` 수 있다. data Foo = Bar | Baz Int g :: Foo -> Bool g Bar {} = True g Baz {} = False 생성자 Bar와 Baz의 원소들의 개수나 타입을 바꾸더라도 함수 g는 수정할 필요가 없다. 데이터 타입 보충 설명 장의 기명 필드 절에서 레코드를 더 자세히 다룰 때 레코드 구문의 추가적인 이점을 볼 것이다. 패턴 매칭을 쓸 수 있는 곳 짧게 말하면 변수를 바인딩 하는 모든 곳에 패턴 매칭을 사용할 수 있다. 전례를 한 번 훑어보자. 다음 장에서 몇 가지를 더 소개할 것이다. 등식 가장 명확한 용례는 함수 정의식의 좌변으로, 지금까지의 예제의 주제였다. map _ [] = [] map f (x:xs) = f x : map f xs 두 등식 모두 좌변에서 패턴 매칭을 한다. 두 번째 식에서는 변수 바인딩도 수행한다. let 표현식과 where 절 let과 where는 로컬 변수를 바인딩 하는 수단이다. 여기서도 패턴 매칭을 사용할 수 있다. y = let (x:_) = map (*2) [1,2,3] in x + 5 이는 다음과 동등하다. y = x + 5 where (x:_) = map (*2) [1,2,3] x는 map ((*) 2) [1,2,3]의 첫 번째 원소에 바인딩 된다. y는 따라서 2 + 5 = 7로 변환된다. 람다 추상화 람타 추상화에 패턴 매칭을 직접 사용할 수 있다. swap = \(x, y) -> (y, x) 하지만 이 구문은 단 하나의 패턴만 허용한다. (인자가 여럿인 람다 추상화의 경우 인자 당 한 패턴) 리스트 조건 제시식(list comprehension) 리스트 조건 제시식에서 | 뒤에 패턴 매칭을 쓸 수 있다. 이는 굉장히 유용하며 조건 제시식의 표현력을 풍부하게 만들어준다. 그 작동법을 다소 복잡한 예시를 통해 살펴보자. Prelude는 다음 생성자를 가지는 Maybe 타입을 제공한다. data Maybe a = Nothing | Just a Maybe는 대개 성공 여부를 모르는 작업의 결괏값을 저장하는 데 쓰인다. 작업이 성공하면 Just 생성자가 사용되어 결괏값이 전달된다. 그렇지 않으면 Nothing이 사용된다. 3 보조 함수 catMaybes (Data.Maybe 라이브러리 모듈에 있음)는 Maybe의 리스트("Just"와 "Nothing" Maybe를 모두 포함)를 취해 Nothing은 걸러내고 Just x에서 Just 래퍼를 걷어내 그 안의 값을 얻는다. 리스트 해석을 이용하면 매우 직관적으로 작성할 수 있다. catMaybes :: [Maybe a] -> [a] catMaybes ms = [ x | Just x <- ms ] 이 작업에 리스트 조건 제시식을 쓸 때의 또 다른 장점은 패턴 매칭이 실패하면(즉 Nothing을 만나면) ms의 다음 원소로 이동한다는 것이다. 또 다른 함수를 정의하여 우리가 관심 없는 생성자를 명시적으로 처리할 필요가 없다. 4 do 블록 간단한 입출력 장에서 사용했던 do 블록에서도 왼쪽 화살표 바인딩의 좌변에 패턴 매칭을 사용할 수 있다. putFirstChar = do (c:_) <- getLine putStrLn [c] do 블록 내의 let 바인딩은 패턴 매칭에 관한 한 진짜 let 표현식이나 마찬가지다. 노트 이 특정한 작업에는 합리적인데, 그 이유는 dropThree를 가령 원소가 2개인 리스트에 적용했을 때 []를 반환할 것이라 예상하는 게 자연스럽기 때문이다. 다른 문제에서는 첫 번째 매칭이 실패했다고 임의의 리스트를 반환하는 게 말이 안 될 수도 있다. 나중에 그런 경우를 처리하는 간단한 방법을 알아볼 것이다. ↩ 예상했겠지만 이런 유의 리터럴과의 매칭은 생성자에 기반하지 않는다. 이런 경우 그 이면에서는 등식 비교를 수행한다. ↩ 그런 연산의 대표적인 예시는 사전(dictionary)에서 값을 찾는 것이다. 그 구현은 단순히 키, 값의 짝을 나타내는 튜플의 리스트 [(a, b)]일 수도 있고 더 복잡할 수도 있다. 어느 경우든 임의의 키로 값에 접근하려 할 때 그 키와 연관된 값을 찾으리라는 보장은 없다. ↩ 이게 패턴 매칭 실패로 고장 나지 않고 작동하는 이유는 리스트 조건 제시식의 본 모습과 관련 있다. 리스트 조건 제시식은 사실 리스트 모나드의 래퍼다. 이게 무슨 뜻인지는 모나드를 논할 때 설명할 것이다. ↩ 6 제어 구조 원문: https://en.wikibooks.org/wiki/Haskell/Control_structures if와 guard 재조명 if 표현식 끼워 넣기 case 표현식 액션 제어 재조명 return에 관한 노트 하스켈은 여러 값 중 하나를 선택하는 방법을 몇 가지 제공한다. 하스 켈 기초 장에서 그중 일부를 살펴봤다. 이 절에서는 지금까지 봤던 것들을 좀 더 상세히 논의하고 새로운 제어 구조를 소개한다. if와 guard 재조명 이미 봤던 것이지만, 다음은 if 표현식의 구문이다. if <condition> then <true-value> else <false-value> <condition>은 불리언으로 평가되는 표현식이다. <condition>이 True 이면 <true-value>가 반환되고 아니면 <false-value>가 반환된다. 하스켈에서 if는 값으로 변환되는 표현식이지, 명령형 언어들과 달리 실행되는 명령문 statement이 아니다. 1 그래서 하스켈에서는 else가 필수다. if가 표현식이기 때문에 조건이 참이냐 거짓이냐에 따라 결과를 내야 하며 else는 이를 보장한다. 또한 <true-value>와 <false-value>는 같은 타입으로 평가되어야 하고 그 타입이 if 표현식 전체의 타입이 된다. if 표현식을 여러 줄에 쪼개어 쓸 경우 else의 들여 쓰기는 대개 if가 아니라 then에 맞춰진다. 흔히 이런 스타일을 쓴다. describeLetter :: Char -> String describeLetter c = if c >= 'a' && c <= 'z' then "Lower case" else if c >= 'A' && c <= 'Z' then "Upper case" else "Not an ASCII letter" guard와 최상위 if 표현식은 대개 서로 바꿔 쓸 수 있다. 위의 예제는 guard를 이용하면 조금 깔끔해진다. describeLetter :: Char -> String describeLetter c | c >= 'a' && c <= 'z' = "Lower case" | c >= 'A' && c <= 'Z' = "Upper case" | otherwise = "Not an ASCII letter" otherwise는 단지 True의 별칭임을 기억하자. 마지막 guard는 모든 경우를 포착해 if 표현식 끝의 else와 같은 역할을 수행한다. 가드는 순서대로 평가된다. 다음과 같은 구성을 고려해 보자. f (pattern1) | predicate1 = w | predicate2 = x f (pattern2) | predicate3 = y | predicate4 = z f의 인수는 pattern1과 패턴 매칭된다. 성공하면 첫 번째 가드로 진행한다. predicate1이 True로 평가되면 w가 반환되고 아니면 predicate2가 평가된다. predicate2가 참이면 x가 반환된다. 이번에도 아니면 다음 경우로 넘어가 인수를 pattern2와 일치시키려 시도한다. 그리고 guard에 대해 predicate3와 predicate4를 가지고 같은 절차를 반복한다. 물론 어느 패턴, 어느 술어식에도 패턴이 맞지 않으면 런타임 에러가 발생할 것이다. 어느 제어 구조를 택하든 모든 경우가 처리되도록 하는 것이 중요하다. if 표현식 끼워 넣기 if가 표현식이라는 점에서 나오는 결론은 하스 켈 표현식이 들어가는 어디든 if가 들어갈 수 있다는 것으로, 이런 코드가 가능하다. g x y = (if x == 0 then 1 else sin x / x) * y 줄바꿈 없이 if 표현식을 써서 간결함을 극대화했다. if와 달리 guard 블록은 표현식이 아니어서, 이런 식으로 사용하려면 let이나 where 정의가 최선이다. 물론 복잡한 한 줄 if 표현식은 읽기 힘들 것이며 그런 경우 let과 where가 괜찮은 대안이다. case 표현식 아직 case 표현식이라는 제어 구조를 언급하지 않았는데, case와 조각 함수 정의의 관계는 if 표현식과 guard의 관계와 유사하다. 다음의 간단한 조각 정의를 보자. f 0 = 18 f 1 = 15 f 2 = 12 f x = 12 - x 이것은 다음의 예제와 동등하며, 사실 아래 코드의 편의 구문이다. f x = case x of 0 -> 18 1 -> 15 2 -> 12 _ -> 12 - x 둘 중 어느 정의를 선택하든 f를 호출하면 같은 과정이 발생한다. 인수 x는 모든 패턴에 순서대로 매칭된다. 첫 번째 매칭에선 = 기호(조각 버전) 또는 화살표(case 버전)의 우변에 있는 표현식이 평가된다. 이 case 표현식에서 패턴에 x를 적을 필요가 없다는 것에 주목하라. 만능 패턴 _이 같은 효과를 갖는다. 2 case를 사용할 땐 들여 쓰기가 중요하다. 각 분기는 of 키워드를 포함하는 줄의 시작점보다 오른쪽으로 들여 써야 하며 모든 분기의 들여 쓰기가 같아야 한다. 설명을 위해 case 표현식의 올바른 양식 두 개를 첨부한다. f x = case x of 0 -> 18 1 -> 15 2 -> 12 _ -> 12 - x f x = case x of 0 -> 18 1 -> 15 2 -> 12 _ -> 12 - x case 분기의 좌변은 패턴일 뿐이므로 조각 함수 정의의 경우와 마찬가지로 바인딩에 쓰일 수 있다. describeString :: String -> String describeString str = case str of (x:xs) -> "The first character of the string is: " ++ [x] ++ "; and " ++ "there are " ++ show (length xs) ++ " more characters in it." [] -> "This is an empty string." 이 함수는 str의 일부 속성을 사람이 읽을 수 있는 문자열로 서술한다. 이 경우는 리스트의 머리와 꼬리에 변수를 바인딩 할 때 case 구문이 편리하지만, if 문도 쓸 수 있다. (빈 문자열의 경우 null str 조건을 이용) 마지막으로 if 표현식처럼 case 표현 식도 다른 표현식이 들어가는 어디든 끼워 넣을 수 있다. (조각 정의는 그럴 수 없다) data Colour = Black | White | RGB Int Int Int describeBlackOrWhite :: Colour -> String describeBlackOrWhite c = "This colour is" ++ case c of Black -> " black" White -> " white" RGB 0 0 0 -> " black" RGB 255 255 255 -> " white" _ -> "... uh... something else" ++ ", yeah?" 위의 case 블록은 어느 문자열에도 들어맞는다. describeBlackOrWhite를 이런 식으로 작성하면 let/where가 필요하지 않다. (정의는 좀 읽기 어려워지지만) 연습문제 case 문으로 fakeIf 함수를 구현하여 if 표현식을 대체해 보자. 액션 제어 재조명 이번 장의 마지막으로서 간단한 입출력 장의 논의를 되짚어보며 제어 구조에 관한 추가 사항을 몇 개 소개하겠다. 액션 제어 절에서 다음 함수를 통해 do 블록 내에서 if 표현식을 이용한 액션의 조건부 실행을 설명한 바 있다. doGuessing num = do putStrLn "Enter your guess:" guess <- getLine if (read guess) < num then do putStrLn "Too low!" doGuessing num else if (read guess) > num then do putStrLn "Too high!" doGuessing num else do putStrLn "You Win!" case 표현식으로 동일한 함수를 작성할 수 있다. 그러려면 일단 Prelude 함수 compare를 도입해야 한다. 이 함수는 같은 타입인 두 값을 취해 Ordering 타입의 값을 반환하며 그 값은 GT, LT, EQ 중 하나로 첫 번째가 두 번째보다 큰지, 작은지, 같은지를 나타낸다. doGuessing num = do putStrLn "Enter your guess:" guess <- getLine case compare (read guess) num of LT -> do putStrLn "Too low!" doGuessing num GT -> do putStrLn "Too high!" doGuessing num EQ -> putStrLn "You Win!" -> 뒤의 do는 LT, GT에만 필요하다. 두 경우에만 액션을 계속하기 때문이다. return에 관한 노트 이제 혼란의 여지를 없애려고 한다. 통상 C 같은 명령형 언어에서는 doGuessing을 이런 식으로 구현할 것이다(C를 모른다면 세부적인 건 제쳐두고 if-else 연쇄만 따라갈 것). void doGuessing(int num) { printf("Enter your guess:"); int guess = atoi(readLine()); if (guess == num) { printf("You win!\n"); return (); } // we won't get here if guess == num if (guess < num) { printf("Too low!\n"); doGuessing(num); } else { printf("Too high!\n"); doGuessing(num); } } 이 doGuessing은 먼저 같은 경우를 검사한다. 이때는 doGuessing을 새로 호출하지 않는다. 그리고 if에 else가 따라붙지 않는다. 추측이 맞았다면 return 문으로 함수를 종료하여 다른 경우들은 건너뛴다. 하스 켈로 돌아가서, do 블록 내의 액션 연쇄는 마치 명령형 코드처럼 보이고, 실제로 Prelude에는 return이 있다. 그럼 case 문이 if 문과는 달리 모든 경우를 다루도록 강제하기 않는 걸 아는 누군가가 위의 C 코드를 그대로 옮겨보려 하지 않았을까? (궁금하면 직접 실행해 보라...) doGuessing num = do putStrLn "Enter your guess:" guess <- getLine case compare (read guess) num of EQ -> do putStrLn "You win!" return () -- we don't expect to get here if guess == num if (read guess < num) then do print "Too low!"; doGuessing num else do print "Too high!"; doGuessing num ...그런데 생각대로 되지 않는다! 맞게 추측한 경우 이 함수는 "You win!"을 출력하고, return()에서 종료되지 않는다. 대신 if 표현식으로 이어가서 guess가 num보다 작은지 검사한다. 물론 그렇지 않기 때문에 else 분기로 넘어가 "Too high!"를 출력하고 재추측을 요청한다. 오 측을 하는 것보다 나을 것이 없다. 이제 case 문을 평가하여 compare의 결과로 LT나 GT를 얻으려 할 것이고, 어느 경우든 일치하는 패턴이 없어 프로그램은 결국 예외를 만들며 즉시 실패할 것이다. (불완전한 case 자체만으로 의심을 불러일으키기 충분하다) 여기서의 문제는 return이 C나 자바의 이름이 같은 그 명령문과 전혀 같은 것이 아니라는 점이다. 당분간은 return이 하나의 함수라고 치자. 4 return()은 아무것도 하지 않는 액션으로 평가된다. return은 제어 흐름에 아무 영향도 미치지 않는다. 맞게 추측한 경우 case 문은 IO 타입의 액션인 return()을 평가하며 실행은 정상적으로 진행된다. 결론은 액션과 do 블록이 명령형 코드처럼 보이지만 하스켈의 고유 문법을 따라야 한다는 것이다. 연습문제 1. 간단한 입출력/액션 제어의 "Haskell greeting" 예제를 case 문으로 재작성하라. 2. 다음 프로그램은 무엇을 출력하는가? 그 이유는? main = do x <- getX putStrLn x getX = do return "My Shangri-La" return "beneath" return "the summer moon" return "I will" return "return" return "again" C나 자바로 프로그래밍을 해봤다면, 하스켈의 if/then/else가 삼 항 연산자 ?:와 동등 다하는 것을 알아챘을 것이다. ↩ 왜 이런지를 보려면 패턴 매칭 절의 매칭, 바인딩에 관한 논의를 살펴볼 것. ↩ 따라서 숫자<NAME>에 대한 일치 비교만으로 제한되는 명령형 언어의 switch/case 문보다 하스켈의 case 문이 보다 다재다능하다. ↩ 보충 설명: 보다 정확히 설명하자면, return은 값을 취해, 그 값을 평가되는 시점에 가서 원래 값을 돌려주는 액션으로 만든다고 볼 수 있다. 이 예시의 do 블록들 중 하나에 return "strawberry"를 넣으면 IO String 타입을 가질 것이며 이는 getLine과 같은 타입이다. 말이 안 되는 것 같아도 걱정하지 말라. 나중에 본격적으로 모나드를 논의할 때 return이 진짜로 하는 일을 깨닫게 될 것이다. ↩ 7 함수 보충 설명 원문: https://en.wikibooks.org/wiki/Haskell/More_on_functions let과 where 재조명 익명 함수 - 람다(lambda) 연산자 섹션 section 연습문제 함수 사용을 쉽게 만들어주는 훌륭한 기능들이 있다. let과 where 재조명 이전의 여러 장에서 논의한 바와 같이 let과 where는 로컬 함수 정의에 유용하다. addStr :: Float -> String -> Float addStr x str = x + read str sumStr :: [String] -> Float sumStr = foldl addStr 0.0 addStr을 다른 데서 쓸 일이 절대 없다면? 로컬 바인딩을 이용해서 sumStr을 재작성할 수 있다. sumStr = let addStr x str = x + read str in foldl addStr 0.0 where 절을 쓰는 방법도 있다. sumStr = foldl addStr 0.0 where addStr x str = x + read str 그럼 바인딩이 정의의 나머지의 앞에 오느냐 뒤에 오느냐의 취향 차이일 뿐일까? let과 where에는 중요한 차이가 있다. let ... in 구조는 if/then/else처럼 표현식이다. 반대로 where 절은 가드와 같아서 표현식이 아니다. 따라서 let 바인딩은 복잡한 표현식 내부에서도 쓸 수 있다. f x = if x > 0 then (let lsq = (log x) ^ 2 in tan lsq) * sin x else 0 바깥 괄호 안의 표현식은 그 자체로 종결되며 x의 로그를 제곱한 것의 탄젠트로 평가된다. lsq의 스코프는 괄호 밖으로 확장되지 않는다. then 분기를 다음과 같이 바꾸는 것은 then (let lsq = (log x) ^ 2 in tan lsq) * (sin x + lsq) let 주변의 괄호를 벗겨내지 않는 한 작동하지 않는다. where 절이 완벽한 표현식이 아니지만 case 표현식에 포함될 수 있다. describeColour c = "This colour " ++ case c of Black -> "is black" White -> "is white" RGB red green blue -> " has an average of the components of " ++ show av where av = (red + green + blue) `div` 3 ++ ", yeah?" 이 예제처럼 where 절을 들여 쓰면 RGB red green blue인 경우에만 av 변수가 존재하도록 스코프를 설정한다. case 분기들과 같은 수준으로 들여 쓰면 av를 모든 분기에서 사용할 수 있다. 다음은 가드를 이용한 예시다. doStuff :: Int -> String doStuff x | x < 3 = report "less than three" | otherwise = report "normal" where report y = "the input is " ++ y 가드마다 등호 기호가 하나씩 있어서, 모든 가드의 스코프에 let 표현식이 들어가도록 할 방법이 where 절과 달리 없다. 이 경우는 where가 편리하다. 익명 함수 - 람다(lambda) addStr 같이 다른 함수 정의 안에서만 존재하고 다신 쓰지 않을 함수에 굳이 이름을 붙여야 할까? 대신 람다 함수라고도 불리는 익명의 함수를 이용해 sumStr을 정의할 수 있다. sumStr = foldl (\ x str -> x + read str) 0.0 괄호 안의 표현식이 람다 함수다. 백슬래시()는 그리스 문자 람다(λ)와 가장 비슷한 ASCII 문자로서 쓰인 것이다. 이 람다 함수는 두 인수 x와 str을 취해 "x + read str"로 평가한다. 이 sumStr은 let 바인딩에서 addStr을 쓴 기존의 sumStr과 정확히 같은 것이다. 람다는 map, fold 부류의 함수에서 한 번 쓰고 말 함수를 작성할 때, 특히 그 함수가 간단할 때 편리하다. (복잡한 표현식을 람다로 쓰면 가독성을 해칠 수 있다) 람다 표현식 안에서는 정식 함수 정의처럼 인자에 변수가 바인딩 된다. 따라서 여기서도 패턴 매칭을 쓸 수 있다. 명확한 예가 tail을 람다로 재정의하는 것이다. tail' = (\ (_:xs) -> xs) 주의: 하스켈에서 람다는 특수 문자이기 때문에 \는 그 자체로 함수로 취급되고 다음에 오는 공백 아닌 무슨 문자든 그것이 첫 번째 인자의 변수가 된다. 그래도 람다와 인수 사이에 일반 함수 구문처럼 공백을 두는 게 좋은 형태다. (특히 람다의 인수가 둘 이상일 때) 연산자 하스켈에서 인수를 두 개 취하고 이름이 전적으로 알파벳이나 숫자가 아닌 문자로만 이루어진 모든 함수는 연산자로 간주된다. 가장 흔한 예가 덧셈(+)이나 뺄셈(-) 같은 산술 연산자다. 다른 함수와 달리 연산자는 보통 중위(infix)로 쓰여, 두 인수 사이에 들어간다. 모든 연산자는 괄호로 감싸면 다른 함수처럼 전치(prefix)로 쓸 수 있다. -- 이것들은 동일하다: 2 + 4 (+) 2 4 다른 함수와 같은 방식으로 새로운 연산자를 정의할 수 있다. 이름에 알파벳이나 숫자를 넣지만 마라. 다음은 Data.List의 차집합 정의다. (\\) :: (Eq a) => [a] -> [a] -> [a] xs \\ ys = foldl (\zs y -> delete y zs) xs ys 위 예제에서 보듯이 연산자는 중위로도 정의할 수 있다. 전치로 작성한 같은 정의도 작동한다. (\\) xs ys = foldl (\zs y -> delete y zs) xs ys 연산자의 타입 선언은 중위 버전이 없으며 괄호로 감싸야 한다. 섹션 section 섹션은 연산자와 함께 사용할 수 있는 훌륭한 편의 구문이다. 괄호 안에 인수 하나와 함께 들어있는 연산자는... (2+) 4 (+4) 2 ...그 자체로 새로운 함수다. 예를 들어 (2+)의 타입은 (Num a) => a -> a이다. 섹션을 map (+2) [1.. 4] == [3.. 6] 이렇게 다른 함수에 넘길 수도 있다. 다른 예로는 리스트 보충 설명에서 작성한 multiplyList 함수에 장식을 달 수 있다. multiplyList :: Integer -> [Integer] -> [Integer] multiplyList m = map (m*) "일반적인" 전치 함수를 연산자로서 쓰고 싶다면 역 따옴표(backtick)으로 감싸면 된다. 1 `elem` [1.. 4] 이런 것을 보고 함수를 중위로 만든다고 하며 가독성 때문에 이렇게 하곤 한다. 1 'elem' [1.. 4]는 elem 1 [1.. 4] 보다 읽기 쉽다. 함수를 중위로 정의할 수도 있다. elem :: (Eq a) => a -> [a] -> Bool x `elem` xs = any (==x) xs 이번에도 타입 시그너쳐는 전치<NAME>임에 주의하라. 섹션도 중위 함수와 함께 쓸 수 있다. (1 `elem`) [1.. 4] (`elem` [1.. 4]) 1 물론 이항 함수 즉 인수가 두 개인 것만 중위로 만들 수 있다. 연습문제 람다는 불필요하게 별개의 함수를 정의하는 것을 피하는 훌륭한 수단이다. 다음의 let 또는 where 바인딩을 람다로 바꿔보라. map f xs where f x = x * 2 + 3 let f x y = read x + y in foldr f 1 xs 섹션은 단지 람다 연산의 편의 구문이다. 즉 (+2)는 \x -> x + 2 와 동등하다. 다음 섹션의 람다 대응은 무엇인가? 그 타입은 어떻게 되는가? (4+) (1 elem) (notElem "abc") 8 고차 함수 원문: https://en.wikibooks.org/wiki/Haskell/Higher-order_functions 정렬 알고리즘 Ord 클래스 비교 방법 선택하기 고차 함수와 타입 함수 조작 인수 뒤집기 합성 composition 응용 uncurry와 curry id와 const 연습문제 노트 함수형 프로그래밍의 핵심에는 함수가 다른 값들과 다를 바 없다는 발상이 자리 잡고 있다. 함수형의 강력함은 함수 자체를 정규 값처럼 다루는 것에 있다. 즉 함수를 다른 함수에 전달하고 함수로부터 함수를 반환받는다. 함수는 하스켈의 도처에 존재한다. 그런 예로는 이미 map과 fold 같은 것을 봤다. 리스트 보충 설명에서 map을 논의할 때 고차 함수의 흔한 예를 봤다. 이제 함수를 조작하는 코드의 일반적인 작성법을 탐험하려 한다. 정렬 알고리즘 구체적인 예시로 리스트 정렬 작업을 살펴보려 한다. 퀵 정렬은 유명한 재귀 정렬 알고리즘이다. 퀵 정렬의 정렬 전략을 리스트에 적용하려면 먼저 한 원소를 선택하고 리스트의 나머지를 (A) 선택된 원소의 앞에 올 원소들, (B) 선택된 원소와 같은 원소들, (C) 뒤에 올 원소들로 분리한다. 그러고 나서 정렬되지 않은 리스트 (A)와 (C)에 같은 알고리즘을 적용한다. 충분히 재귀 정렬을 하고 나면 모든 것을 다시 연결해 최종적으로 정렬된 리스트를 얻는다. 이 전략을 하스 켈로 구현하는 방법은 아주 간단하다. -- Type signature: any list with elements in the Ord class can be sorted. quickSort :: (Ord a) => [a] -> [a] -- Base case: -- If the list is empty, there is nothing to do. quickSort [] = [] -- The recursive case: -- We pick the first element as our "pivot", the rest is to be sorted. -- Note how the pivot itself ends up included the middle part. quickSort (x : xs) = (quickSort less) ++ (x : equal) ++ (quickSort more) where less = filter (< x) xs equal = filter (== x) xs more = filter (> x) xs 우리의 quickSort는 다소 어설프다. 더 효율적인 구현에서는 각각의 재귀 단계에서 filter를 통한 세 개의 패스를 쓰지 않으며 정렬된 리스트를 구축하기 위해 (++)를 쓰지 않는다. 게다가 우리의 구현과 달리 원래 퀵 정렬 알고리즘은 유동성 mutability을 이용해 제자리에서 정렬을 수행한다. 1 지금은 정확한 구현보다 정렬 함수의 사용 패턴에 관심이 있기 때문에 이런 것을 신경 쓰지 않겠다. Ord 클래스 하스켈의 대부분의 기본 데이터 타입은 Ord 클래스의 멤버다. Eq가 일치 검사를 위한 것이듯이 Ord는 순서 검사를 위한 것이다. Ord 클래스는 어떤 순서가 해당 타입에 자연스러운지를 정의한다. Ord는 다음 타입을 가지는 compare 함수를 제공한다. compare :: (Ord a) => a -> a -> Ordering compare는 두 값을 취해 둘을 비교하고 Ordering 값을 반환한다. 그 값은 첫 번째 값이 두 번째 값보다 작을 경우 LT, 같을 경우 EQ, 클 경우 GT이다. Ord 타입에서 (<), Eq의 (==), (>)는 compare의 단축키로서, 세 가능성을 검사하고 기입한 순서가 그 타입의 Ord 명세에 따라 참인지를 나타내는 Bool 값을 반환한다고 볼 수 있다. quickSort의 정의에서 filter에 사용한 각각의 검사는 compare의 가능한 결과들 하나하나에 대응하고, 따라서 less를 less = filter (\y -> y compare x == LT) xs처럼 작성할 수도 있다. 비교 방법 선택하기 quickSort를 가지고 원소가 Ord 클래스인 리스트를 정렬하기란 쉬운 일이다. String의 리스트를 정렬하려면 quickSort를 그 리스트에 적용하기만 하면 된다. 이제 단어가 몇 개 있는 가상의 사전을 사용하겠다. (수천 단어를 담은 사전에도 잘 작동할 것이다) dictionary = ["I", "have", "a", "thing", "for", "Linux"] quickSort dictionary는 다음을 반환한다. ["I", "Linux", "a", "for", "have", "thing"] 정렬에서 대소문자가 기본으로 고려되는 걸 볼 수 있다. 하스 켈 String은 유니코드 문자의 리스트다. 유니코드는(그리고 대부분의 문자 인코딩은) 대문자의 문자 코드를 소문자의 문자 코드보다 낮게 명시한다. 따라서 "z"는 "a"보다 작다. 진짜 사전식 정렬을 하려면 대소문자를 고려하는 quickSort가 필요하다. 위의 compare 논의에서 힌트를 얻을 수 있다. quickSort의 재귀 분기 부분을 이렇게 재작성할 수 있다. quickSort compare (x : xs) = (quickSort compare less) ++ (x : equal) ++ (quickSort compare more) where less = filter (\y -> y `compare` x == LT) xs equal = filter (\y -> y `compare` x == EQ) xs more = filter (\y -> y `compare` x == GT) xs 처음의 quickSort보다 덜 깔끔하지만 원소의 순서 매김이 전적으로 compare 함수에 달려있음을 명확히 보여준다. 그러니까 우리는 compare를 입맛에 맞는 (Ord a) => a -> a -> Ordering 함수로 교체만 하면 된다. 새로운 quickSort'는 비교 함수 그리고 정렬할 리스트를 취하는 고차 함수다. quickSort' :: (Ord a) => (a -> a -> Ordering) -> [a] -> [a] -- No matter how we compare two things the base case doesn't change, -- so we use the _ "wildcard" to ignore the comparison function. quickSort' _ [] = [] -- c is our comparison function quickSort' c (x : xs) = (quickSort' c less) ++ (x : equal) ++ (quickSort' c more) where less = filter (\y -> y `c` x == LT) xs equal = filter (\y -> y `c` x == EQ) xs more = filter (\y -> y `c` x == GT) xs 이 quickSort' 함수를 여러 가지 용도로 쓸 수 있다. 내림차순으로 정렬하려면 reverse (quickSort dictionary)로 기존의 정렬된 목록을 뒤집어도 되지만, 애초에 정렬을 내림차순으로 하려면, 통상의 Ordering을 뒤집어 반환하는 비교 함수를 quickSort'에 건네면 된다. -- the usual ordering uses the compare function from the Ord class usual = compare -- the descending ordering, note we flip the order of the arguments to compare descending x y = compare y x -- the case-insensitive version is left as an exercise! insensitive = ... -- How can we do case-insensitive comparisons without making a big list of all possible cases? 잠깐 Data.List는 리스트 정렬을 위한 sort 함수를 제공한다. 이 함수는 퀵 정렬을 쓰지 않는다. 대신 병합 정렬이라는 알고리즘의 효율적인 구현을 사용한다. Data.List에는 우리의 quickSort'처럼 맞춤형 비교 함수를 취하는 sortBy 역시 들어있다. 연습문제 quickSort' insensitive dictionary가 ["a", "for", "have", "I", "Linux", "thing"]를 반환하도록 insensitive 함수를 작성하라. 고차 함수와 타입 최종 결과 가는 도중 거쳐가는 중간 함수들을 생성하는, 커링currying이라는 개념은 앞서 리스트 보충 설명 장에서 처음 소개했다. 지금이 커링의 작동 방식을 되짚을 좋은 시기다. quickSort'의 타입은 (a -> a -> Ordering) -> [a] -> [a]이다. 대체로 고차 함수의 타입은 그 사용법에 대한 지침을 주곤 한다. 위의 타입 시그너쳐를 해석하는 직관적인 방식은 다음과 같다. "quickSort'는 첫 번째 인자로 두 a의 순서를 매기는 함수를 취하고, 두 번째 인자는 a들의 리스트다. 마지막으로 a들의 새로운 리스트를 반환한다." 이 정도면 순서 매김 함수를 리스트 정렬에 쓴다는 걸 추측하는 데 충분하다. a -> a -> Ordering 을 감싸는 괄호가 필수라는 것에 유의하라. 이는 a -> a -> Ordering 이 하나의 함수로써 단독 인자를 형성함을 명시한다. 괄호가 없으면 a -> a -> Ordering -> [a] -> [a] 가 되어 인자가 두 개가 아닌 네 개가 되며(이 중 어느 것도 함수가 아니다) 원하는 대로 작동하지 않을 것이다. -> 연산자는 오른쪽으로 결합(right-associative) 되기 때문에 quickSort'의 시그너쳐를 올바르게 묶으면 사실 a -> (a -> (Ordering -> ([a] -> [a]))) 이 된다. 완벽히 말이 된다. 조정 가능한 비교 함수 인자가 없던 원래의 quickSort의 타입은 [a] -> [a]였다. quickSort는 리스트를 취하여 정렬한다. quickSort'는 quickSort 꼴의 함수를 생성하는 함수다! (a -> a -> Ordering) 부분에 compare를 꽃아 넣으면 원래 quickSort 함수를 돌려받는다. 인자로 다른 비교 함수를 사용하면 quickSort 함수의 변형을 생성하는 것이다. 물론 비교 함수뿐 아니라 실제로 정렬할 리스트도 인자로 넘기면 최종 결과는 quickSort 꼴의 새로운 함수가 아니다. 대신 계속하여 그 리스트를 새 함수로 전달하고 최종 결과로 정렬된 리스트를 돌려받는다. 연습문제 (도전) 다음 연습문제는 고차 함수, 재귀, 입출력을 하나로 묶은 것이다. 명령형 언어에서 for 루프라고 알려진 것을 우리 손으로 만들고자 한다. 다음 함수를 구현하라. for :: a -> (a -> Bool) -> (a -> a) -> (a -> IO ()) -> IO () for i p f job = -- ??? 이 함수의 용법은 이런 식이다. for 1 (<10) (+1) print 1에서 9까지의 숫자를 화면에 출력한다. for에 요구되는 동작은 다음과 같다. for는 초깃값 i에서 시작해 job i를 실행한다. 그리고 f를 이용해 이 값을 수정하고 수정된 f 값이 조건 p를 만족하는지 검사한다. 만족하지 않으면 중단한다. 아니면 for 루프는 i의 자리에 수정된 f i를 넣고 for 루프는 계속된다. 1. 하스 켈로 for 루프를 구현하라. 2. 위 단락에서는 for 루프를 명령형 식으로 설명했다. 함수형의 관점에서 여러분의 구현을 서술하라. 그 외에도 시도해 볼 만한 도전 문제가 여러 개 있다. 1. "1에서 10까지의 리스트를 출력하라" 같은 작업을 생각해 보라. print라는 함수가 주어졌고 숫자의 리스트에 print를 적용하려 할 때, map을 쓰는 게 자연스러울 것 같은데 정말 그럴까? 2. 함수 sequenceIO :: [IO a] -> IO [a]를 구현하라. 액션의 리스트에 대해 이 함수는 각 액션을 순서대로 실행하고 그것들의 결과를 리스트로 돌려받는다. 3. 함수 mapIO :: (a -> IO b) -> [a] -> IO [b]를 구현하라. 이 함수는 a -> IO b 타입의 함수와 [a] 타입의 리스트를 인자로 받아 그 액션을 리스트의 각 항목에 대해 실행한 다음, 결과들을 돌려받는다. 함수 조작 유용하게 널리 쓰이는 범용 고차 함수들을 몇 개 논의하며 이번 장을 마무리 짓겠다. 이것들에 익숙해지면 하스 켈 코드를 작성하고 읽는 기술이 눈에 띄게 향상될 것이다. 인수 뒤집기 filp은 편리하고 작은 Prelude 함수다. 인자가 두 개인 함수를 취해 같은 함수인데 두 인자가 뒤바뀐 변형을 반환한다. flip :: (a -> b -> c) -> b -> a -> c flip 사용법: Prelude> (flip (/)) 3 1 0.3333333333333333 Prelude> (flip map) [1,2,3] (*2) [2,4,6] quickSort 예제의 비교 함수 descending의 인자 생략 버전을 flip을 이용해 작성할 수도 있다. descending = flip compare flip이 특히 유용한 때는 서로 타입이 다른 인자가 2개인 함수를 다른 함수에 전달하는데 그 고차 함수의 시그너쳐를 고려할 때 두 인자의 순서가 잘못된 경우다. 합성 composition 합성 연산자 (.)는 또 다른 고차 함수다. (.)의 시그너쳐는 다음과 같다. (.) :: (b -> c) -> (a -> b) -> a -> c (.)는 두 함수를 인자로 받아 두 번째 인자와 첫 번째 인자 순으로 적용하는 함수를 반환한다. 합성과 고차 함수로 강력한 기교를 부릴 수 있다. 조그만 예로 Data.List 모듈에 정의된 inits 함수를 보자. 문서를 보면 "인자의 모든 절면 initial segment을 짧은 것이 앞에 오는 순으로 반환한다"라고 쓰여있다. Prelude Data.List> inits [1,2,3] [[],[1],[1,2],[1,2,3]] inits는 Prelude의 고차 함수 flip, scanl, (.), map을 이용해 한 줄만으로 구현할 수 있다. (극적 효과를 위해 인자 생략 식으로 작성) myInits :: [a] -> [[a]] myInits = map reverse . scanl (flip (:)) [] 이렇게 꽉 눌러 담은 정의는 처음에는 벅찰 수 있으니 각 함수가 하는 일을 떠올리고 타입 시그너쳐를 안내인 삼아 한 꺼풀씩 찬찬히 뜯어보자. myInits의 정의는 매우 간결하며 괄호를 거의 쓰지 않아 깔끔하다. 기나긴 (.) 연쇄로 합성을 너무 많이 하다 보면 자연스레 코드가 혼란스러워지기 마련이다. 하지만 적절히 배치하면 이러한 인자 생략<NAME>이 빛을 발한다. 게다가 이 구현은 상당히 "고수준"이다. 패턴 매칭이나 재귀 같은 세부 사항을 명시적으로 처리하지 않는다. 우리가 배치한 함수들 즉 고차 함수들과 인자로서 전달된 함수들이 그런 연계 작업을 처리한다. 응용 ($)는 의문의 고차 연산자다. 타입은 이렇다. ($) :: (a -> b) -> a -> b 함수를 첫 번째 인자로 받는데 하는 일이라곤 그 함수를 두 번째 인자에 적용하는 것이다. 그러니까, (head $ "abc") == (head "abc")이다. 뭐 이런 쓸모없는 연산자가 다 있을까? 하지만 이 함수에는 두 가지 흥미로운 점이 있다. 먼저 ($)는 우선순위가 높은 정상적인 함수 적용과 달리 우선순위가 아주 낮다. 2 결과적으로 $로 우선순위를 깨서 중첩된 괄호에서 오는 혼란을 피할 수 있게 된다. 괄호를 추가하지 않고 myInits의 인자 명시 버전을 작성할 수도 있다. myInits :: [a] -> [[a]] myInits xs = map reverse . scanl (flip (:)) [] $ xs 한 가지 더, ($)는 함수를 적용하는 함수고 함수는 값이기 때문에 이런 흥미로운 표현식을 작성할 수 있다. map ($ 2) [(2*), (4*), (8*)] 그렇다. 함수의 리스트다. 그리고 완벽히 타당하다. uncurry와 curry 이름이 암시하듯이 uncurry는 커링을 취소하는 함수다. 즉 인수가 둘인 함수를, 하나의 쌍만을 인자로 갖는 함수로 변환한다. uncurry :: (a -> b -> c) -> (a, b) -> c Prelude> let addPair = uncurry (+) Prelude> addPair (2, 3) uncurry의 흥미로운 용법은 ($)와의 조합으로 쌍의 첫 번째 원소를 두 번째 원소에 적용하는 것이다. Prelude> uncurry ($) (reverse, "stressed") "desserts" uncurry의 반대인 curry도 있다. curry :: ((a, b) -> c) -> a -> b -> c Prelude> curry addPair 2 3 -- addPair as in the earlier example. 대부분의 하스 켈 함수는 이미 커링이 되어 있어서 uncurry와 달리 curry는 거의 쓰이지 않는다. id와 const 마지막으로 그 자체로는 고차 함수가 아니지만 고차 함수의 인자로 자주 쓰이는 함수 두 개를 언급해야겠다. 항등 함수 id는 인수를 그대로 돌려주는 a -> a 타입의 함수다. Prelude> id "Hello" "Hello" id와 비슷한 개념으로 const는 이렇게 작동하는 a -> b -> a 함수다. Prelude> const "Hello" "world" "Hello" const는 두 인수를 취해 첫 번째 인수만 반환하고 두 번째 인수는 버린다. 인수가 하나인 a -> (b -> a) 함수로 보면 이 함수는 상수 함수를 반환하고 이 상수 함수는 무슨 인수를 받든 같은 값을 반환한다. id와 const는 처음에는 아무 쓸모도 없어 보일 것이다. 하지만 고차 함수를 다룰 때면 아무것도 안 하거나 항상 같은 값을 반환하는 의사 dummy 함수를 넘겨야 할 때가 있다. id와 const는 그런 때에 편리한 의사 함수다. 연습문제 curry, uncurry, const의 구현을 작성하라. 다음 함수들이 어떤 일을 하는지 직접 실행하지 않고 설명하라. uncurry const curry fst curry swap (여기서 swap :: (a, b) -> (b, a)는 쌍의 두 원소를 맞바꾼다. swap은 Data.Tuple에 있다) (고난도) foldr로 foldl을 구현하라. 힌트: 일단 리스트 처리의 foldr과 foldl을 복습하라. 두 가지 해법이 있는데 하나는 쉽지만 밋밋하고 다른 하나는 무척 흥미롭다. 그 흥미로운 것의 경우 리스트 안의 모든 함수를 어떻게 합정 할지 신중히 생각하는 것이 핵심이다. 노트 "진정한" 제자리 퀵 정렬을 하스켈에서 할 수 있다. 하지만 초급 자반에서 논의하지 않는 보다 고급스러운 도구가 필요하다. ↩ 상기하는 의미로 말하자면, 여기서 우선순위란 수학에서 *가 +보다 우선순위가 높다(즉 먼저 평가된다)는 말과 같은 맥락이다. ↩ 9 GHCi 효율적으로 사용하기 원문: https://en.wikibooks.org/wiki/Haskell/Using_GHCi_effectively 사용자 인터페이스 탭 완성 ": commands" GHCi에서 함수의 시간 측정 여러 줄 입력 GHCi는 여러 수단을 통해 보다 효율적인 작업을 보조한다. 여기서는 GHCi를 사용할 때 도움 되는 몇 가지 실전 지식을 논의한다. 사용자 인터페이스 탭 완성 다른 많은 터미널 프로그램처럼 GHCi에서도 시작 문자를 몇 개 입력하고 탭 키를 눌러 그 문자들로 시작하는 모든 가능한 항목들의 목록을 볼 수 있다. 가능한 문자열이 하나만 있을 때 탭을 누르면 그 문자열을 자동으로 완성한다. 예를 들어 fol<탭>을 누르면 "d"가 추가된다. ("fold" 말고는 "fol"로 시작하는 항목이 없기 때문이다) 다시 탭을 누르면 Prelude에 포함된 네 함수(foldl, foldl1, foldr, foldr1)가 나열된다. 다른 모듈들을 임포트 해놓다면 더 많은 항목이 나타날 수도 있다. 프로그램이 들어있는 파일을 GHCi로 불러올 때도 탭 완성이 작동한다. 예를 들어 :l fi<탭>을 입력하면 현재 디렉터리(GHCi를 실행했을 때 있던 위치)에서 "fi"로 시작하는 모든 파일이 뜬다. 모듈을 들여올 때도 마찬가지다. :m +Da<탭>을 입력하면 설치된 패키지 중 "Da"로 시작하는 모든 모듈이 나타난다. ": commands" GHCi 명령줄에서 인터프리터를 위한 커맨드들은 ":" (콜론) 문자로 시작한다. :help 또는 :h -- 사용 가능한 모든 커맨드를 출력한다 :load 또는 :l -- 파일을 GHCi로 불러온다(커맨드에 파일 이름을 반드시 포함할 것) :reload 또는 :r -- 가장 최근에 불러온 파일을 다시 불러온다(그 파일을 변경했을 때 유용) :type 또는 :t -- 커맨드에 포함된 표현식의 타입을 출력한다 :module 또는 :m -- 해당 모듈을 불러온다(커맨드에 모듈 이름을 포함할 것). 모듈 이름 앞에 -를 붙여서 불러온 걸 취소할 수도 있다 :browse -- 해당 모듈의 모든 함수의 타입 시그너쳐를 표시한다 여기서도 탭 완성으로 커맨드의 목록을 볼 수 있다. 가능한 모든 커맨드를 보려면 :<탭> 을 입력하라. GHCi에서 함수의 시간 측정 GHCi는 함수 실행이 얼마나 오래 걸리는지 측정하는 기본적인 수단을 제공하며, 이것은 한 함수의 어떤 버전이 가장 빠른지 찾을 때 유용하다. (예를 들면 어떤 동일한 결과를 얻는 방법이 여러 가지일 때) ghci 명령줄에 :set +s를 입력한다. 확인하려는 함수들을 실행한다. GHCi가 함수의 결과를 출력한 뒤에 그 함수의 실행 시간이 표시된다. 여러 줄 입력 여러 줄에 걸쳐 함수를 정의하거나, ghci 안에서 별개의 파일을 작성해 불러오지 않고 do 블록을 입력하려면 쉬운 방법이 있다. 새로운 줄을 :{로 시작한다. 코드를 작성한다. 줄 바꿈이 필요할 때마다 엔터를 친다. 여러 줄 입력이 끝났으면 :}를 입력한다. 예시 *Main> :{ *Main| let askname = do *Main| putStrLn "What is your name?" *Main| name <- getLine *Main| putStrLn $ "Hello " ++ name *Main| :} *Main> :set +m 커맨드(여러 줄 입력 허용)를 써도 된다. 이때는 빈 줄에서 블록이 끝난다. 추가로, ghci 명령줄에서 줄 바꿈은 ;로 할 수 있다. *Main> let askname1 = do ; putStrLn "what is your name?" ; name <- getLine ; putStrLn $ "Hello " ++ name 3 하스 켈 중급 하스 켈 중급 모듈(Modules) 독립 실행 프로그램(Standalone programs) 들여 쓰기(Indentation) 데이터 타입 보충 설명(More on datatypes) 다른 자료구조들(Other data structures) 클래스와 타입(Classes and types) Functor 클래스(The Functor class) 1 모듈 원문: https://en.wikibooks.org/wiki/Haskell/Modules 모듈 들여오기(Importing) 한정 들여오기(Qualified imports) 정의 은닉 재작명 들여오기 재작명과 한정 들여오기를 섞어 쓰기 내보내기(Exporting) 노트 모듈은 하스 켈 코드를 조직화하는 주된 수단이다. 모듈은 import 문을 써서 라이브러리 함수를 스코프 내로 들여올 때 언뜻 봤었다. 모듈을 알고 나면 라이브러리를 더 잘 활용할 수 있게 될 뿐만 아니라 우리가 스스로 프로그램의 구조를 빚고 GHCi와 독립적으로 실행되는 독립 실행 프로그램을 제작할 때 도움이 된다. (우연히도 바로 다음 장의 주제가 독립 실행 프로그램이다) 모듈 하스 켈 모듈 1은 서로 연관된 기능들을 하나의 패키지로 모으고 이름이 같은 별개의 함수들을 관리하는 유용한 수단이다. 모듈 정의는 하스 켈 파일의 맨 처음에 온다. 기본적인 모듈 정의는 다음과 같다. module YourModule where 다음 사항을 주의해야 한다. 모듈 이름은 대문자로 시작한다. 각각의 파일은 모듈을 하나만 포함한다. 파일의 이름은 모듈 이름에 파일 확장자. hs를 더한 것이다. 모듈 이름에 포함된 점 '.'은 디렉터리에 대응한다. 2 즉 YourModule 모듈은 YourModule.hs 파일에 들어가고 Foo.Bar 모듈은 Foo/Bar.hs 또는 Foo\Bar.hs 파일에 들어간다. 모듈 이름은 대문자로 시작해야 하기 때문에 파일 이름도 대문자로 시작해야 한다. 들여오기(Importing) 한 모듈은 다른 모듈의 함수를 들여올 수 있다. 즉 모듈 선언과 나머지 코드의 사이에 import 선언을 포함할 수 있다. import Data.Char (toLower, toUpper) -- import only the functions toLower and toUpper from Data.Char import Data.List -- import everything exported from Data.List import MyModule -- import everything exported from MyModule 들여온 데이터 타입들을 기술할 때는 이름 뒤에 들여온 생성자들의 목록을 괄호로 감싼다. import Data.Tree (Tree(Node)) -- import only the Tree data type and its Node constructor from Data.Tree 서로 중복되는 정의를 포함한 모듈들을 들여올 때는 어떻게 해야 할까? 아니면 모듈을 불러왔는데 여러분만의 함수를 재정의하고 싶다면? 이런 경우를 처리하는 방법은 세 가지가 있다. 바로 한정 들여오기, 정의 은닉, 재작명 들여오기다. 한정 들여오기(Qualified imports) MyModule과 MyOtherModule 둘 다 remove_e라는 정의를 포함한다고 가정하자. 이 함수는 문자열에서 모든 e를<NAME>다. 그런데 MyModule은 소문자 e만<NAME>지만 MyOtherModule은 대소문자 e를 모두<NAME>다. 이 경우 다음 코드는 애매한 구석이 있다. import MyModule import MyOtherModule -- someFunction puts a c in front of the text, and removes all e's from the rest someFunction :: String -> String someFunction text = 'c' : remove_e text 무슨 remove_e를 가리키는 건지 확실하지 않다! 이런 경우를 피하려면 qualified 키워드를 사용한다. import qualified MyModule import qualified MyOtherModule someFunction text = 'c' : MyModule.remove_e text -- Will work, removes lower case e's someOtherFunction text = 'c' : MyOtherModule.remove_e text -- Will work, removes all e's someIllegalFunction text = 'c' : remove_e text -- Won't work as there is no remove_e defined 후자의 코드 조각에서 이름이 remove_e인 함수는 전혀 이용할 수 없다. 한정 들여오기를 하면 모든 들여온 값은 모듈 이름을 앞에 포함한다. 정상적인 들여오기를 해도 모듈 이름을 앞에 붙일 수 있다. ("qualified" 키워드를 넣지 않아도 MyModule.remove_e는 작동한다) 잠깐 MyModule.remove_e 같은 한정 이름과 함수 합성 연산자 (.)에 관해 애매한 점이 있다. reverse.MyModule.remove_e라고 쓰면 하스 켈 컴파일러는 혼란스러워할 것이다. 한 가지 멋진 해결책이 있다. 함수 합성에는 항상 띄어쓰기를 사용하라. 예를 들어, reverse . remove_e 또는 Just . remove_e 또는 심지어 Just . MyModule.remove_e도 가능하다. 정의 은닉 이번에는 MyModule과 MyOtherModule을 들여오지만 소문자만 지울 일은 없고 모든 e를<NAME>기를 원한다고 가정하자. 모든 remove_e 호출에 MyOtherModule을 붙이는 건 무척이나 지루할 것이다. 그냥 MyModule에서 remove_e를 제외할 수는 없을까? import MyModule hiding (remove_e) import MyOtherModule someFunction text = 'c' : remove_e text 이 코드는 import 줄의 hiding 단어 덕분에 잘 작동한다. "hiding" 키워드 뒤에 오는 것은 들여오지 않는다. 쉼표로 구분하고 괄호로 감싸서 여러 항목을 은닉할 수 있다. import MyModule hiding (remove_e, remove_f) 재작명 들여오기 덮어쓰기를 위한 기법은 아니지만, qualified 플래그와 함께 자주 쓰이곤 한다. import qualified MyModuleWithAVeryLongModuleName someFunction text = 'c' : MyModuleWithAVeryLongModuleName.remove_e text 특히 qualified를 쓸 때면 이런 것이 매우 성가시다. as 키워드로 이 상황을 타개할 수 있다. import qualified MyModuleWithAVeryLongModuleName as Shorty someFunction text = 'c' : Shorty.remove_e text 들여온 함수에 MyModuleWithAVeryLongModuleName 대신 Shorty를 붙일 수 있다. 이러한 재작명은 qualified가 있든 없든 가능하다. 충돌하는 항목이 없는 한 여러 모듈을 들여와 같은 이름으로 재작명할 수 있다. import MyModule as My import MyCompletelyDifferentModule as My 이 경우 MyModule과 MyCompletelyDifferentModule 모두 My로 대신할 수 있다. 재작명과 한정 들여오기를 섞어 쓰기 가끔은 같은 모듈에 import 지시문을 두 번 쓰는 것이 편할 때가 있다. 전형적인 경우는 다음과 같다. import qualified Data.Set as Set import Data.Set (Set, empty, insert) 이렇게 하면 Data.Set 모듈의 모든 것에 "Set"이라는 별칭으로 접근할 수 있고 몇 가지 함수(empty, insert, constructor)는 "Set"을 안 붙여도 접근할 수 있다. 내보내기(Exporting) 이 글의 서두의 예제에서 "MyModule이 내보낸 모든 것을 들여온다"라는 말을 썼다. 3 여기서 질문. 어떤 함수를 내보내고 어떤 함수를 내부에 놔둘지 어떻게 결정할 것인가? 그 방법은 이렇다. module MyModule (remove_e, add_two) where add_one blah = blah + 1 remove_e text = filter (/= 'e') text add_two blah = add_one . add_one $ blah 여기서 remove_e와 add_two만 내보내기의 대상이다. add_two는 add_one을 이용할 수 있지만 MyModule을 들여오는 모듈에 있는 함수에서는 add_one이 내보내기의 대상이 아니라 직접 이용할 수 없다. 데이터 타입 내보내기는 들여오기와 비슷하다. 타입을 쓰고 생성자 목록을 괄호로 감싼다. module MyModule2 (Tree(Branch, Leaf)) where data Tree a = Branch {left, right :: Tree a} | Leaf a 이 경우 모듈 선언을 "MyModule2 (Tree(..))"로 다시 써서 모든 생성자를 내보내도록 선언할 수 있다. 내보내기 목록을 유지하면 이름 공간 오염을 줄이고 다른 경우엔 불가능한 컴파일 타임 최적화를 할 수 있다. 노트 모듈 체계에 관한 보다 자세한 사항은 하스 켈 보고서를 보자. ↩ Haskell2010 이전에 하스켈의 최신 표준이었던 Haskell98에서는 모듈 시스템이 상당히 보수적(?) 이었다. 하지만 요즘은 계층적 모듈 시스템을 수용하여 마침표를 통해 이름 공간들을 분리한다. ↩ 모듈은 다른 데서 들여온 함수를 내보낼 수도 있다. 상호 재귀적으로 의존하는 모듈도 가능하지만 특수한 조치를 해야 한다. ↩ 2 독립 실행 프로그램 원문: https://en.wikibooks.org/wiki/Haskell/Standalone_programs 간단한 하스 켈 애플리케이션, 즉 독립 실행 소프트웨어를 만들어보자. Main 모듈 기본적인 요구사항으로 Main 모듈이 있어야 하고 이 모듈은 IO() 타입의 main 이란 진입점을 가져야 한다. -- thingamie.hs module Main where main = putStrLn "Bonjour, world!" 이것을 GHCi로 불러오는 방법은 이미 알고 있다. 다음은 이 파일을 컴파일하고 독립적으로 실행하는 방법이다. $ ghc --make -o bonjourWorld thingamie.hs $ ./bonjourWorld Bonjour, world! 보라! 이로써 하스 켈로 만든 독립 실행 애플리케이션을 하나 만들었다. 다른 모듈 대부분의 프로그램은 점점 복잡해지며 여러 파일로 쪼개진다. 여기 모듈 두 개를 사용하는 간단한 애플리케이션이 있다. -- Hello.hs module Hello where hello = "Bonjour, world!" -- thingamie.hs module Main where import Hello main = putStrLn hello 이 새로운 프로그램을 전과 같은 방법으로 컴파일할 수 있다. --make 플래그는 컴파일하려는 파일들의 의존성을 GHC가 자동으로 감지하도록 한다. thingamie.hs가 Hello 모듈을 들여오기 때문에, GHC는 현 디렉터리에서 Hello를 구현하는 하스 켈 파일을 찾을 것이다. Hello가 다른 모듈에 의존한다면 GHC는 그 의존성도 알아서 감지한다. $ ghc --make -o bonjourWorld thingamie.hs $ ./bonjourWorld Bonjour, world! Main 모듈이 포함된 파일인 thingamie.hs의 이름이 모듈 이름과 일치하지 않는다는 것을 알아챘는가? 모듈 장에서 한 말과 다른데 어떻게 된 걸까? 모듈 이름과 파일 이름을 맞추는 것은 GHC가 파일들을 자동으로 찾을 수 있도록 하기 위한 것이다. 이 작업은 항상 Main에서 시작하고 GHC에서 명렁줄에 입력하는 것은 Main이 든 파일이기 때문에 이 파일은 관습을 따를 필요가 없다. 다른 위치에서(파일과 디렉터리의 중첩 구조를 포함해서) 소스 파일을 검색하려면, -i 플래그로 의존성 검색의 시작점을 추가할 수 있다. 이 플래그는 쉼표로 구분된 디렉터리 이름을 인수로 받는다. 다소 인위적인 다음 프로그램에서는 src/ 디렉터리에 세 파일이 전부 저장되어 있다. 디렉터리 구조는 다음과 같다. HaskellProgram/ src/ Main.hs GUI/ Interface.hs Functions/ Mathematics.hs Main 모듈은 모듈 이름과 유사한 경로를 검색해 의존 관계를 들여온다. 말인즉 import GUI.Interface는 GUI/Interface를 검색한다(알맞은 파일 확장자를 덧붙여서). 이 프로그램을 HaskellProgram 디렉터리에서 컴파일하려면 GHC를 이렇게 실행하라. $ ghc --make -isrc -o sillyprog Main.hs 3 들여쓰기 원문: https://en.wikibooks.org/wiki/Haskell/Indentation 들여 쓰기의 황금률 들여 쓰기를 대체하는 특별한 문자들 레이아웃 실전 첫 번째 요소까지 들여 쓰기 하라 do 안의 if 노트 하스켈은 들여 쓰기를 통해 코드의 장황함을 덜어낸다. 실제 용법은 조금 복잡하지만 근본적인 레이아웃 규칙은 몇 개 밖에 없다.1 들여 쓰기의 황금률 어떤 표현식의 일부인 코드는 그 표현식의 시작 부분보다 더 들여 써야 한다. 그 표현식이 그 줄에서 가장 왼쪽에 있는 요소가 아닐지라도 그렇게 해야 한다. 가장 쉬운 예가 'let' 바인딩 그룹이다. 변수를 바인딩 하는 등식은 'let' 표현식의 일부이며 따라서 그 바인딩 그룹의 시작인 'let' 키워드보다 더 들여 써야 한다. 별개의 줄에서 표현식을 시작할 때는 띄어쓰기를 한 번만 더 하면 된다. 물론 더 많이 띄어 쓰는 것도 가능하고 그게 더 깔끔할 것이다. let x = a y = b 첫 번째 절을 'let' 옆에 두고 나머지를 줄 맞춰 들여 쓸 수도 있다. 틀림 틀림 맞음 let x = a y = b let x = a y = b let x = a y = b 입문자들은 이것 때문에 혼란에 빠지고는 한다. 모든 그룹 표현식은 정확히 열을 맞춰야 한다. 첫 번째 줄에서 하스켈은 표현식의 좌측에 있는 모든 것을 공백이 아니어도 들여 쓰기로 센다. 몇 가지 예를 더 들어보겠다. do foo bar baz do foo bar baz where x = a y = b case x of p -> foo p' -> baz 'case'의 경우 딸려오는 첫 번째 표현식을 'case' 키워드와 같은 선에 놓는 코드는 올바르긴 하지만 흔하지는 않다. 그래서 부수적인 표현식들은 'case' 절보다 딱 한 번 더 들여쓰기 되고는 한다. 화살표들을 정렬한 것은 순전히 심미적인 것이며 다른 레이아웃으로 판단되지 않는다. 오직 들여 쓰기, 즉 가장 왼쪽 끝에서 시작하는 공백만이 레이아웃 해석을 다르게 만든다. 표현식이 왼쪽 끝에서 시작하지 않으면 상황이 복잡해진다. 이럴 때는 그저 표현식의 시작 부분을 포함하는 줄보다만 많이 들여 쓰는 것이 상책이다. myFunction firstArgument secondArgument = do -- the 'do' doesn't start at the left-hand edge foo -- so indent these commands more than the beginning of the line containing the 'do'. bar baz 다음과 같은 대안들도 가능하다. myFunction firstArgument secondArgument = do foo bar baz myFunction firstArgument secondArgument = do foo bar baz myFunction firstArgument secondArgument = do foo bar baz 들여 쓰기를 대체하는 특별한 문자들 사실 그룹화와 분리에 C 같은 "일차원" 언어처럼 세미콜론과 중괄호를 쓴다면 들여 쓰기는 선택 사항일 뿐이다. 의미 있는 들여 쓰기가 코드를 더 보기 좋게 만든다는 것이 하스 켈 프로그래머들의 여론이지만, 한 양식에서 다른 양식으로 바꾸는 방법을 알면 들여쓰기 규칙을 이해하는 데 도움이 된다. 전체적인 레이아웃 과정은 세 개의 변환 규칙과, 거의 마주칠 일이 없는 네 번째 규칙으로 정리할 수 있다. 레이아웃 키워드(let, where, of, do) 중 하나를 만나면 바로 뒤에 여는 중괄호를 삽입한다. 같은 수준으로 들여 쓴 것은 세미콜론을 삽입한다. 적게 들여 쓴 것에 닫는 중괄호를 삽입한다. 목록에서 예상하지 못한 것이 있으면 세미콜론 대신 닫는 괄호를 삽입한다. 예를 들어, 이 정의는 foo :: Double -> Double foo x = let s = sin x c = cos x in 2 * s * c 들여쓰기 규칙을 무시하고 이렇게 작성할 수 있다. foo :: Double -> Double; foo x = let { s = sin x; c = cos x; } in 2 * s * c GHCi에서 한 줄짜리 코드를 작성할 때는 괄호와 세미콜론을 명시하는 방법이 편리하다. Prelude> let foo :: Double -> Double; foo x = let { s = sin x; c = cos x } in 2 * s * c 연습문제 제어 구조 장의 이 코드를 괄호와 세미콜론을 사용해 재작성하라. doGuessing num = do putStrLn "Enter your guess:" guess <- getLine case compare (read guess) num of LT -> do putStrLn "Too low!" doGuessing num GT -> do putStrLn "Too high!" doGuessing num EQ -> putStrLn "You Win!" 레이아웃 실전 틀림 틀림 맞음 맞음 do first thing second thing third thing do first thing second thing third thing do first thing second thing third thing do first thing second thing third thing 첫 번째 요소까지 들여 쓰기 하라 위에서 설명한 "들여 쓰기의 황금률"에 따라, do 블록 내의 중괄호는 do 자체가 아니라 바로 다음에 오는 것에 의존한다. 예를 들어 이 기묘한 코드는 하등의 문제가 없다. do first thing second thing third thing 결과적으로 if와 do를 이런 식으로 조합할 수 있다. 틀림 맞음 맞음 if foo then do first thing second thing third thing else do something else if foo then do first thing second thing third thing else do something else if foo then do first thing second thing third thing else do something else 이 모든 것은 do에 관한 것이 아니라 do 안에서 같은 수준에 있는 항목들을 정렬하는 것에 관한 것이다. 따라서 다음의 모든 코드는 인정된다. main = do first thing second thing 또는 main = do first thing second thing 또는 main = do first thing second thing do 안의 if 이 조합은 많은 하스 켈 프로그래머를 헷갈리게 한다. 다음 코드는 왜 작동하지 않을까? 멋지지만 틀림 멋지지도 않고 틀림 -- why is this bad? do first thing if condition then foo else bar third thing -- still bad, just explicitly so do { first thing ; if condition ; then foo ; else bar ; third thing } 하스 켈 컴파일러는 if 표현식 작성이 끝나지 않았다고 생각하기 때문에 새 구문을 시작하는 건지 혼란스러워한다. 컴파일러는 if condition; 같이 적힌 것을 보지만 이 코드는 완성이 안 되어 있다. 이것을 고치려면 if 블록의 하단부를 들여 써서 then과 else가 if 문의 일부가 되도록 해야 한다. 멋지고 맞음 멋지진 않지만 맞음 -- whew, fixed it! do first thing if condition then foo else bar third thing -- the fixed version without sugar do { first thing ; if condition then foo else bar ; third thing } 이제 do 블록은 if 문 전체를 한 항목으로 본다. if-then-else 문이 do 블록 안에 있지 않을 때는 이런 들여 쓰기가 기술적으로 불필요하지만 해가 되지는 않으니 if-then-else를 항상 이런 식으로 들여 쓰는 것은 좋은 습관이다. 연습문제 do 안의 if 문제는 많은 하스 켈 사용자를 혼란스럽게 했고 급기야 한 프로그래머가 Haskell prime initiative에 제안하기를, if then else 사이에 추가적으로 세미콜론을 넣자고 했다. 이게 도움이 될까? 들여쓰기 관련 문제는 do가 왜 모나 딕 연산자 (>>=)의 편의 구문인지 살펴볼 때 연계하여 설명할 것이다. 노트 The Haskell Report (lexemes)의 2.7절을 볼 것. ↩ 4 데이터 타입 보충 설명 원문: https://en.wikibooks.org/wiki/Haskell/More_on_datatypes 열거형 기명 필드 Named Field(레코드 구문) 편의 구문일 뿐 매개화 타입 Parameterized Type 둘 이상의 매개변수 종 오류 kind error 열거형 열거형은 data 선언의 특수 경우로서 어느 생성자 함수도 인자를 갖지 않는 데이터 타입이다. data Month = January | February | March | April | May | June | July | August | September | October | November | December 인자를 갖는 생성자들과 갖지 않는 생성자들을 섞을 수 있지만 그 결과물은 열거형이라 부르지 않는다. 다음 예에서는 마지막 생성자가 인자 세 개를 취하기 때문에 열거형이 아니다. data Colour = Black | Red | Green | Blue | Cyan | Yellow | Magenta | White | RGB Int Int Int 클래스와 파생형 derivation을 논의할 때 추가로 보겠지만 열거형인 것과 아닌 것을 구분하는 데는 실용적인 면의 이유가 있다. 우연히도 Bool 데이터 타입은 열거형이다. data Bool = False | True deriving (Eq, Ord, Enum, Read, Show, Bounded) 기명 필드 Named Field(레코드 구문) 환경설정을 담아두는 데이터 타입을 생각해 보자. 여러분이 이 타입으로부터 멤버를 추출할 때는 기껏해야 한두 개 설정에만 관심이 있을 것이다. 게다가, 많은 설정이 타입이 같다면 "잠깐, 이 원소가 네 번째였나 다섯 번째였나..." 헷갈리고는 한다. 이런 것을 명확하게 하는 한 가지 방법은 접근자accessor 함수를 작성하는 것이다. 터미널 프로그램을 위한 다음의 환경설정 타입을 보자. data Configuration = Configuration String -- user name String -- local host String -- remote host Bool -- is guest? Bool -- is super user? String -- current directory String -- home directory Integer -- time connected deriving (Eq, Show) 그러면 이런 접근자 함수를 작성할 수 있다. getUserName (Configuration un _ _ _ _ _ _ _) = un getLocalHost (Configuration _ lh _ _ _ _ _ _) = lh getRemoteHost (Configuration _ _ rh _ _ _ _ _) = rh getIsGuest (Configuration _ _ _ ig _ _ _ _) = ig -- and so on... 단일 원소를 갱신하는 함수를 작성할 수도 있다. 물론 나중에 환경설정에 항목을 추가하거나 제거한다며 이 모든 함수는 이제 인자의 수가 달라지게 된다. 이는 매우 짜증 나는 일이고 버그가 슬그머니 들어오기 쉬운 장소다. 다행히도 해결책이 있다. 데이터 타입 선언에서 필드에 이름을 부여하는 것이다. data Configuration = Configuration { user name :: String, localhost :: String, remotehost :: String, isguest :: Bool, issuperuser :: Bool, currentdir :: String, homedir :: String, timeconnected :: Integer } 그러면 다음의 접근자 함수들이 자동으로 생성된다. user name :: Configuration -> String localhost :: Configuration -> String -- etc. 또한 편리한 갱신 수단도 제공된다. 다음은 Configuration에 대해 작동하는, "현재 작업 중인 디렉터리"와 "디렉터리 변경" 함수의 짧은 예시다. changeDir :: Configuration -> String -> Configuration changeDir cfg newDir = if directoryExists newDir -- make sure the directory exists then cfg{currentdir = newDir} -- change our current directory else error "directory does not exist" postWorkingDir :: Configuration -> String postWorkingDir cfg = currentdir cfg -- retrieve our current directory 그러니까, 일반적으로 데이터 타입 y의 필드 x를 z로 갱신하려면 y{x=z}라고 쓴다. 둘 이상을 바꿀 수도 있다. 각각을 쉼표로 구분하여, y{x=z, a=b, c=d}처럼 쓴다. 잠깐 객체 지향 언어에 익숙한 독자라면 이 모든 걸 "접근자 함수 accessor function"와 "갱신 메서드 update method"에 관한 이야기로 생각하여, y{x=z}는 setter 메서드로서 이미 존재하는 y의 x 값을 변경한다고 생각할지도 모르겠다. 아니다. 하스 켈 변수는 수정 불가능하다 하지 않았던가. conf2 = changeDir conf1 "/opt/foo/bar" 같은 코드에서 conf2는 conf1과 같지만 currentdir만은 "/opt/foo/bar"로 다른 Configuration으로 정의되고, conf1은 그대로 남아있는다. 편의 구문일 뿐 물론 예전에 한 것처럼 Configuration에 대한 패턴 매칭을 할 수도 있다. 기명 필드는 편의 구문일 뿐이다. 여전히 이런 식으로 쓸 수 있다. getUserName (Configuration un _ _ _ _ _ _ _) = un 하지만 이럴 필요는 전혀 없다. 마지막으로, 기명 필드에도 패턴 매칭이 가능하다. getHostData (Configuration {localhost=lh, remotehost=rh}) = (lh, rh) 여기서 변수 lh는 Configuration의 localhost 필드에, rh는 remotehost 필드에 매칭된다. 두 매칭은 물론 성공할 것이다. 또한 데이터 타입에서 그랬듯이 변수 이름 대신 값을 넣어서 더 제한된 매칭을 할 수도 있다. GHC를 쓰고 있다면 NamedFieldPuns 언어 확장을 이용해 이런 형태로 사용하는 것이 가능하다. getHostData (Configuration {localhost, remotehost}) = (localhost, remotehost) 표준 형태와 섞어 쓸 수도 있다. getHostData (Configuration {localhost, remotehost=rh}) = (localhost, rh) 이 언어 확장을 사용하려면 인터프리터에 :set -XNamedFieldPuns 명령을 입력하거나 소스 파일 앞머리에 {-# LANGUAGE NamedFieldPuns #-} 프라그마fragma를 넣거나 컴파일러에 -XNamedFieldPuns라는 명령 줄 플래그를 전달하라. Configuration의 값들은 첫 번째 정의처럼 예전 방식으로 생성할 수도 있고 두 번째 정의처럼 기명 필드의 타입 안에 생성할 수도 있다. initCFG = Configuration "nobody" "nowhere" "nowhere" False False "/" "/" 0 initCFG' = Configuration { user name="nobody", localhost="nowhere", remotehost="nowhere", isguest=False, issuperuser=False, currentdir="/", homedir="/", timeconnected=0 } 첫 번째가 훨씬 짧지만 두 번째가 훨씬 깔끔하다. 경고: 두 번째 방식에서는 필드를 생략하는 코드여도 컴파일이 된다. cfgFoo = Configuration { user name = "Foo" } cfgBar = Configuraton { localhost = "Bar", remotehost = "Baz" } cfgUndef = Configuration {} 기입하지 않은 필드를 평가하려고 하면 런타임 오류가 발생할 것이다! 매개화 타입 Parameterized Type 매개화 타입은 다른 언어의 "제너릭generic"이나 "템플릿 template"과 유사한 개념이다. 매개화 타입은 하나 이상의 타입 매개변수를 취한다. 예를 들어 표준 Prelude 타입인 Maybe는 다음과 같이 정의된다. data Maybe a = Nothing | Just a Maybe는 타입 매개변수 a를 취한다. Maybe를 이용해 다음과 같이 선언할 수 있다. lookupBirthday :: [Anniversary] -> String -> Maybe Anniversary lookupBirthday 함수는 생일 레코드의 리스트와 문자열 하나를 취해 Maybe Anniversary를 반환한다. 이 타입은 일반적으로 문자열로 주어진 이름이 생일 리스트에서 발견되면 대응하는 레코드의 Just 값이고, 아니면 Nothing이라고 해석할 수 있다. Maybe는 하스켈에서 실패를 나타내는 가장 간결하고 흔한 수단이다. 함수의 인자로 쓰일 때도 있는데 그 인자를 선택사항으로 만들기 위함이다. 즉 생략하려는 인자에 Nothing을 전달하려는 의도가 있다. type과 newtype 선언을 정확히 같은 방법으로 매개화할 수 있다. 또한 매개 타입들을 여러 방법으로 결합하여 새로운 타입을 생성할 수 있다. 둘 이상의 매개변수 타입 매개변수는 하나보다 많을 수 있다. Either 타입이 그러한 예시다. data Either a b = Left a | Right b 예를 들어, 다음 예제에서 pairOff :: Int -> Either String Int pairOff people | people < 0 = Left "Can't pair off negative number of people." | people > 30 = Left "Too many people for this activity." | even people = Right (people `div` 2) | otherwise = Left "Can't pair off an odd number of people." groupPeople :: Int -> String groupPeople people = case pairOff people of Right groups -> "We have " ++ show groups ++ " group(s)." Left problem -> "Problem! " ++ problem pairOff는 여러분의 동호회 activity에서 특정 수의 사람들을 짝지을 때 얼마나 많은 그룹이 생길지를 나타낸다. 또한 사람이 너무 많거나 누군가 나가게 될 것도 알려준다. 따라서 pairOff는 그룹의 수를 나타내는 int 또는 모임을 만들 수 없는 이유를 설명하는 String을 반환한다. 종 오류 kind error 하스 켈 매개 타입의 유연함은 타입 오류 같아 보이는 타입 선언 오류를 일으킬 수도 있다. 단지 그것들은 프로그램 실행 중이 아니라 타입 선언 시점에 일어난다. 이런 "타입의 타입" 오류를 "종" 오류라 한다. 여러분은 종을 가지고 프로그래밍을 하지 않는다. 컴파일러가 스스로 추론한다. 하지만 매개화 타입이 잘못되었다면 컴파일러가 종 오류를 보고할 것이다. 5 다른 자료구조들 원문: https://en.wikibooks.org/wiki/Haskell/Other_data_structures 트리 트리로서의 리스트 map과 fold map fold 다른 데이터 타입들 범용 map 일반화된 fold 재귀적 데이터 타입에 대한 fold 멋져 보이는 말 노트 이 장에서는 우리가 지금까지 배운 기법들을 어떻게 이용하여 더 복잡한 데이터 타입들을 만들 수 있는지를 여러 예제를 통해 알아볼 것이다. 특히 같은 타입의 값을 포함하는 재귀 자료 구조의 예시를 볼 것이다. 재귀 자료 구조는 많은 프로그래밍 기법에서 생명수와 같으며, 라이브러리에 있는 것을 쓴다거나 하면 그런 것을 새로 정의할 필요가 없지만 그 실체가 어떻고 조작은 어떤 식으로 되는지 알고 있는 것이 중요하다. 그리고 이번 장에서 구현하는 예제들을 잘 따라가면 하스 켈 능력이 싹트는 데 좋은 연습이 될 것이다. 잠깐 하스 켈 라이브러리 생태계에는 풍부한 자료 구조가 있어서(재귀적인 것도 있고 아닌 것도 있다) 광범위한 실용적 요구를 만족한다. 리스트 외에도 맵, 집합, 유한 순열 finite sequence, 배열 등 많은 자료구조가 있다. 하스 켈 실전반의 Data Structure primer가 핵심 자료 구조들을 배우는 데는 좋은 출발점이다. 중급자 과목이 몇 개 안 남았는데 다 끝내면 한 번 훑어보는 것을 권장한다. 트리 재귀 자료 구조 중 가장 중요한 유형은 트리다. 트리에는 여러 종류가 있는데 그중 간단한 것을 예시로 골랐다. 그 정의는 다음과 같다. data Tree a = Leaf a | Branch (Tree a) (Tree a) 트리가 매개화된 것을 볼 수 있다. 즉 Int의 트리, String의 트리, Maybe Int의 트리, (Int, String) 짝의 트리 등이 모두 가능하다. 이 데이터 타입의 특별한 점은 Tree가 정의 그 자체에 나타난다는 것이다. Tree는 a 타입의 값을 포함하는 리프(말단)이거나 Tree a 타입의 또 다른 트리 두 개를 달고 있는 브랜치(분기)다. 트리로서의 리스트 리스트 보충 설명과 리스트 처리에서 본 것처럼 리스트를 두 경우로 나눌 수 있다. 하나는 빈 리스트([]로 표기)인 경우고 다른 하나는 특정 타입의 원소 하나에 또 다른 리스트를 더한 경우((x:xs)로 표기)다. 즉 리스트 데이터 타입의 정의는 이런 식이다. -- 의사 하스켈. 실제로는 작동하지 않는다 (리스트는 특별한 문법을 가지기 때문) data [a] = [] | (a:[a]) 다음은 실제로 가능하면서 위와 동등한 정의다. data List a = Nil | Cons a (List a) 트리처럼 리스트도 재귀적이다. 리스트의 생성자 함수는 []와 (:)다. 이 둘은 각각 Tree 정의의 Leaf와 Branch에 해당한다. 이것이 내포하는 바는 빈 리스트와 (x:xs)에 대해 패턴 매칭을 했듯이 Leaf와 Branch도 패턴 매칭에 사용할 수 있다는 것이다. map과 fold 우리는 리스트를 위한 map과 fold를 이미 알고 있다. 그러면 Tree 타입을 위한 map과 fold를 작성해 보자. 요약하자면 data Tree a = Leaf a | Branch (Tree a) (Tree a) deriving (Show) data [a] = [] | (:) a [a] -- (:) a [a]는 (a:[a])를 중위가 아니라 전위 표기한 것과 같다 노트 Deriving은 클래스와 타입에서 설명할 것이다. 지금은 하스켈(그리고 인터프리터)에게 Tree 인스턴스를 표시하는 방법을 말해주는 수단이라고 생각하자. map 리스트를 위한 map 정의를 살펴보자. map :: (a -> b) -> [a] -> [b] map _ [] = [] map f (x:xs) = f x : map f xs treeMap을 작성한다면 그 타입은 무엇이어야 할까? 함수의 타입이 무엇이어야 하는지에 대해 생각이 있으면 그 함수를 정의하기가 쉬워진다. 우리는 treeMap이 임의 타입의 Tree에 대해 작동하여, 그 트리의 각 원소에 함수를 적용하고 동일 타입의 또 다른 Tree를 반환하길 원한다. treeMap :: (a -> b) -> Tree a -> Tree b 이것은 리스트 예제의 경우와 비슷하다. 이제 Tree에 대해 말해보자면, 각각의 Leaf는 값을 한 개만 포함하므로 우리가 할 일은 주어진 함수를 그 값에 적용해 수정된 값을 담은 새 Leaf를 반환하는 것이 전부다. treeMap :: (a -> b) -> Tree a -> Tree b treeMap f (Leaf x) = Leaf (f x) 빈 리스트에 map을 적용한 경우와 많이 유사하다. 이제 Branch를 처리해야 하는데, Branch는 두 하위 트리를 포함한다. 이것들로 뭘 해야 할까? 리스트 map은 리스트의 꼬리에 대해 스스로를 호출했으니 두 하위 트리에도 그렇게 해보자. treeMap의 완전한 정의는 다음과 같다. treeMap :: (a -> b) -> Tree a -> Tree b treeMap f (Leaf x) = Leaf (f x) treeMap f (Branch left right) = Branch (treeMap f left) (treeMap f right) treeMap f 자체가 Tree a -> Tree b 타입의 함수라는 점에 착안하여 조금 더 읽기 쉽게 만들 수 있다. treeMap :: (a -> b) -> Tree a -> Tree b treeMap f = g where g (Leaf x) = Leaf (f x) g (Branch left right) = Branch (g left) (g right) 이 정의가 바로 와닿지 않는다면 다시 읽어보자. 이런 식의 패턴 매칭이 처음에는 이상하게 보여도 데이터 타입을 활용하는 필수적인 방식이다. 패턴 매칭은 생성자 함수에 대해 수행된다는 것을 기억하자. 준비가 되었다면 Tree에 대한 fold로 넘어가자. fold 이번에도 리스트의 foldr 정의를 다시 한번 보자. foldr :: (a -> b -> b) -> b -> [a] -> b foldr f acc [] = acc foldr f acc (x:xs) = f x (foldr f acc xs) 리스트의 생성자는 두 개라는 걸 떠올려보자. (:) :: a -> [a] -> [a] -- 원소 하나를 받아서 리스트의 나머지 부분과 결합한다 [] :: [a] -- 빈 리스트는 인자를 받지 않는다 그러므로 foldr은 두 생성자에 대응하는 두 인자를 취한다. f :: a -> b -> b -- 함수는 인자를 두 개 받아서 이것들에 대해 작동하고 단일 결과를 반환한다 acc :: b -- 누적기는 빈 리스트의 경우 무슨 일이 일어날지를 정의한다 잠시 명확하게 하고 넘어가자. 최초에 foldr이 빈 리스트를 받았다면 기본 누적기(accumulator)가 반환된다. 빈 리스트가 아니면 첫 번째 원소가 리스트의 tail을 접은 결과와 (f를 통해) 결합되므로 fold는 빈 리스트를 받을 때까지 계속된다. 우리는 리스트를 위한 foldr처럼 treeFold가 어떤 타입의 트리를 다른 타입의 값으로 변환하길 원한다. 따라서 [a] -> b가 있던 자리에는 Tree a -> b가 온다. 변환은 어떻게 작성해야 할까? 먼저 리스트가 생성자를 두 개 가지는 것처럼 Tree a가 생성자를 두 개 가지는 것에 주목하자. Branch :: Tree a -> Tree a -> Tree a Leaf :: a -> Tree a 따라서 treeFold 역시 두 생성자에 대응하는 두 인수를 취한다. fbranch :: b -> b -> b fleaf :: a -> b 이 모든 걸 한 데 모으면 다음의 타입 정의를 얻는다. treeFold :: (b -> b -> b) -> (a -> b) -> Tree a -> b 첫 번째 인자는 (b -> b -> b) 타입을 가지며, 하위 트리들을 결합해 단일 결과를 도출하는 함수다. a -> b 타입의 두 번째 인자는 leaf 들에 대해 수행할 작업을 기술하는 함수다. (리스트에서 빈 리스트가 그런 것처럼 leaf는 재귀의 끝이다) 그리고 Tree a 타입의 세 번째 인자는 fold 하려는 전체 트리다. treeMap과 마찬가지로 지역 변수 g를 도입하여 인자 fbranch와 fleaf의 반복을 피하겠다. treeFold :: (b -> b -> b) -> (a -> b) -> Tree a -> b treeFold fbranch fleaf = g where -- definition of g goes here fleaf 인자는 Leaf인 하위 트리에 대해 수행할 작업이다. g (Leaf x) = fleaf x fbranch 인자는 두 하위 트리를 "folding"한 결과를 결합하는 방법을 알려준다. g (Branch left right) = fbranch (g left) (g right) 전체 정의는 다음과 같이 된다. treeFold :: (b -> b -> b) -> (a -> b) -> Tree a -> b treeFold fbranch fleaf = g where g (Leaf x) = fleaf x g (Branch left right) = fbranch (g left) (g right) 이것들이 어떻게 작동하는지 보기 위해 Tree 데이터 정의와 treeMap, treeFold 함수를 하스 켈 파일 하나에 붙여 넣고 다음의 예제 Tree와 fold 용 함수들을 넣어보자. tree1 :: Tree Integer tree1 = Branch (Branch (Branch (Leaf 1) (Branch (Leaf 2) (Leaf 3))) (Branch (Leaf 4) (Branch (Leaf 5) (Leaf 6)))) (Branch (Branch (Leaf 7) (Leaf 8)) (Leaf 9)) doubleTree = treeMap (*2) -- doubles each value in tree sumTree = treeFold (+) id -- sum of the leaf values in tree fringeTree = treeFold (++) (: []) -- list of the leaves of tree 이 파일을 GHCi로 불러와 실행해 보자. doubleTree tree1 sumTree tree1 fringeTree tree1 다른 데이터 타입들 map과 fold 함수는 어떤 종류의 데이터 타입에 대해서도 정의될 수 있다. 리스트와 트리에 적용했던 전략을 일반화하기 위해 이번 마지막 절에서는 다음의 상당히 이상하고 인위적인 데이터 타입에 대한 map과 fold를 구현할 것이다. data Weird a b = First a | Second b | Third [(a, b)] | Fourth (Weird a b) 유익한 연습이 될 수 있으니 더 읽기에 앞서 직접 코딩해 보기를 추천한다. 범용 map Weird 타입을 다룰 때 중요한 첫 번째 차이점은 이것이 타입 매개변수를 두 개 취한다는 점이다. 그렇기 때문에 map 함수는 인자를 두 개 취해 하나는 a 타입의 원소에 적용하고 다른 하나는 b 타입의 원소에 적용해야 한다. 이를 고려하면 weirdMap의 타입 시그너쳐를 작성할 수 있다. weirdMap :: (a -> c) -> (b -> d) -> Weird a b -> Weird c d 다음 단계는 weirdMap을 정의하는 것이다. 여기서 핵심은 map이 데이터 타입의 구조를 보존한다는 것으로, 함수는 원래의 Weird와 같은 생성자를 쓰는 Weird로 평가되어야 한다. 그래서 하나의 정의가 각각의 생성자를 처리하고 이들 생성자는 패턴으로서 사용된다. 전과 같이 weirdMap의 인자 목록을 몇 번이고 반복하는 것을 피하기 위해 where 절을 쓰겠다. 이 함수는 대충 이렇게 생겼다. weirdMap :: (a -> c) -> (b -> d) -> Weird a b -> Weird c d weirdMap fa fb = g where g (First x) = --More to follow g (Second y) = --More to follow g (Third z) = --More to follow g (Fourth w) = --More to follow 처음 두 경우는 Weird 안에 a 또는 b 타입의 단일 원소만 있어서 꽤 직관적이다. weirdMap :: (a -> c) -> (b -> d) -> Weird a b -> Weird c d weirdMap fa fb = g where g (First x) = First (fa x) g (Second y) = Second (fb y) g (Third z) = --More to follow g (Fourth w) = --More to follow Thrid는 원소 자체가 자료 구조(튜플)인 리스트를 포함해서 조금 복잡하다. 여기서는 중첩된 자료 구조를 누벼야 한다. fa와 fb를 a와 b 타입의 모든 원소에 적용하면 결국 (map이 반드시 구조를 보존해야 하므로) 튜플의 리스트 [(c, d)]가 만들어지며 이 리스트는 생성자와 함께 사용될 것이다. 가장 간단한 접근법은 Weird 내부의 리스트를 쪼개서 패턴대로 처리하는 것이다. g (Third []) = Third [] g (Third ((x, y):zs)) = Third ( (fa x, fb y) : ( (\(Third z) -> z) (g (Third zs)) ) ) 이렇게 작성하니 리스트에 대한 전형적인 재귀 함수처럼 보인다. 이 함수를 대상의 첫 번째 원소에 적용하여 새로운 리스트의 머리 (fa x, fb y)를 얻는 것으로 시작한다. 하지만 이걸 어디에 컨싱해야 할까? g가 Weird 인자를 요구하기 때문에 리스트 꼬리를 이용해 Weird를 만들고 재귀 호출을 해야 한다. 하지만 g는 리스트가 아니라 Weird를 줄 것이기 때문에 수정된 리스트를 얻어야 한다. 이것이 바로 람다 함수의 역할이다. 마지막으로, 빈 리스트가 기본 분기로 정의되어 있다. 이 모든 일을 끝내고 나니 함수가 꽤나 지저분해졌다. g의 모든 재귀 호출은 zs를 Weird로 감쌀 것을 요구한다. 그런데 우리가 정말 하고 싶었던 것은 (fa x, fb y)와 수정된 xs를 이용해 리스트를 구축하는 것이었다. 이 해법의 문제는 g가 리스트 머리에는 패턴 매칭 덕에 직접 작동하지만 타입 시그너쳐 때문에 리스트 꼬리에는 직접 호출할 수 없다는 것이다. 그래서 리스트를 패턴 매칭으로 분해하지 않고 fa와 fb를 적용하는 것이 더 나을 수도 있다(적어도 g가 직접적으로 연관되는 한). 그런데 리스트를 원소별로 직접 수정하는 방법이 있었다... g (Third z) = Third ( map (\(x, y) -> (fa x, fb y) ) z) ...이 훌륭한 옛날 map 함수는 리스트 z 내의 모든 튜플을 람다 함수를 이용해 수정한다. 사실 이 정의의 첫 번째 버전은 그럴싸해 보이던(하지만 잘못된) Weird 패킹과 언 패킹을 빼면 리스트 map의 응용처럼 보인다. 이번에는 정규 리스트에 바로 작동하는 map에 z를 분해하는 패턴을 맡겨서 패킹과 언 패킹을 제거했다. g 내부의 map 정의를 전개해서 그 차이를 보다 확실하게 보는 게 유용할 수도 있다. 마지막으로, 리스트 조건 제시식 구문을 사용하는 깔끔한 대안이 있다. g (Third z) = Third [ (fa x, fb y) | (x, y) <- z ] Third 함수를 추가했으니 Fourth 정의만 남았다. weirdMap :: (a -> c) -> (b -> d) -> Weird a b -> Weird c d weirdMap fa fb = g where g (First x) = First (fa x) g (Second y) = Second (fb y) g (Third z) = Third ( map (\(x, y) -> (fa x, fb y) ) z) g (Fourth w) = --More to follow 여기서는 g를 재귀적으로 적용하기만 하면 된다. weirdMap :: (a -> c) -> (b -> d) -> Weird a b -> Weird c d weirdMap fa fb = g where g (First x) = First (fa x) g (Second y) = Second (fb y) g (Third z) = Third ( map (\(x, y) -> (fa x, fb y) ) z) g (Fourth w) = Fourth (g w) 일반화된 fold map은 각 유형에 함수 하나씩을 인자로 기입하여 정의할 수 있었지만 fold는 그걸로 충분하지 않다. fold에서는 모든 생성자 함수를 위한 하나의 함수가 필요하다. 리스트의 경우 생성자는 []와 (:)다. foldr 함수의 acc 인자는 (:) 생성자에 대응한다. Weird 데이터 타입은 생성자가 네 개이기 때문에 각각의 생성자에 명시된 데이터 타입의 내부 구조를 처리하는 네 개의 함수가 필요하다. 다음으로 Weird a b 타입의 인자가 있는데 우리는 이 인자가 foldr 함수를 통해 다른 임의의 타입으로 평가되길 원한다. 또한 우리가 weirdFold에 전달할 네 함수는 같은 타입으로 평가되어야 한다. 그러면 타입 시그너쳐와 정의를 얼추 그릴 수 있다. weirdFold :: (something1 -> c) -> (something2 -> c) -> (something3 -> c) -> (something4 -> c) -> Weird a b -> c weirdFold f1 f2 f3 f4 = g where g (First x) = --Something of type c here g (Second y) = --Something of type c here g (Third z) = --Something of type c here g (Fourth w) = --Something of type c here 이제 something1, something2, something3, something4가 어떤 타입이어야 하는지를 밝혀내야 한다. 이 함수들이 인자로 취하는 원소들은 생성자 타입 시그너쳐에 명시된 타입을 가지기 때문에, 생성자를 분석하면 도움이 될 것이다. 이번에도 처음 두 함수의 타입과 정의는 쉽다. 세 번째도 그다지 어렵진 않은데 (a, b)의 리스트를 folding 할 때 튜플은 단순한 타입이나 다를 바 없기 때문이다. (map 예제와 달리 그 내부 구조는 지금은 고려 대상이 아니다) 하지만 네 번째 생성자는 재귀적이기 때문에 조심해야 하나. weirdMap의 경우처럼 g 함수는 재귀적으로 호출해야 한다. 그러면 최종 정의가 나온다. weirdFold :: (a -> c) -> (b -> c) -> ([(a, b)] -> c) -> (c -> c) -> Weird a b -> c weirdFold f1 f2 f3 f4 = g where g (First x) = f1 x g (Second y) = f2 y g (Third z) = f3 z g (Fourth w) = f4 (g w) 노트 weirdFold에서 아주 복잡한 표현식을 예상했는데 해답이 곧바로 나와서 놀랐다면, 우리를 혼란스럽게 하는 리스트의 특별한 각괄호 구문을 쓰지 않고 일반적인 foldr을 이런 식으로 써서 한 번 보자. -- List a is [a], Cons is (:) and Nil is [] data List a = Cons a (List a) | Nil listFoldr :: (a -> b -> b) -> (b) -> List a -> b listFoldr fCons fNil = g where g (Cons x xs) = fCons x (g xs) g Nil = fNil 이제 병렬성이 더 잘 보인다. 아직도 복잡한 부분을 보면 Cons (즉 (:))가 인자를 두 개 취하고 따라서 fCons도 인자를 두 개 취한다. 또한 Cons의 구조가 재귀적이어서 g에 대한 재귀 호출을 요구하고 fNil은 사실은 함수가 아니기 때문에 인수를 취하지 않는다. 재귀적 데이터 타입에 대한 fold fold에 한해서 Weird는 다루기에 꽤 좋은 데이터 타입이었다. 재귀적 생성자는 하나뿐이고 다른 구조에 중첩되지도 않는다. 여기에 진짜로 복잡한 다섯 번째 생성자를 추가한다면 어떻게 될까? Fifth [Weird a b] a (Weird a a, Maybe (Weird a b)) 이런 질문은 있을 법하면서도 교활하기도 하다. 일반적으로 다음 규칙들이 적용된다. fold에 전달되는 함수는 대응하는 생성자 함수와 같은 개수의 인자를 가진다. 그런 함수의 인자들의 타입은 생성자의 인수들의 타입과 일치해야 한다. 생성자가 재귀적일 때(즉 자신의 타입과 같은 인자를 취할 때)는 예외다. 생성자가 재귀적이면, 그 생성자의 재귀적 인자는 fold를 통해 평가될 타입의 인자와 일치한다. 1 생성자가 재귀적이면, 재귀적 생성자 인자들에 완전한 fold 함수를 (재귀적으로) 적용해야 한다. 어떤 재귀적 원소가 다른 자료 구조 내부에 있다면, 그 자료 구조에 알맞은 map 함수를 사용해 fold 함수를 적용해야 한다. 따라서 f5의 타입은 f5 :: [c] -> a -> (Weird a a, Maybe c) -> c 그리고 Fifth의 타입은 Fifth :: [Weird a b] -> a -> (Weird a a, Maybe (Weird a b)) -> Weird a b Fifth 생성자에 대한 g의 정의는 다음과 같다. g (Fifth list x (waa, mc)) = f5 (map g list) x (waa, maybeMap g mc) where maybeMap f Nothing = Nothing maybeMap f (Just w) = Just (f w) 그런데 Weird a a 부분에서는 이상한 일이 전혀 일어나지 않는다. g는 호출되지 않는데 어떻게 된 걸까? 이건 재귀이지 않은가? 사실 아니다. Weird a a와 Weird a b는 다른 타입이기 때문에 진짜 재귀가 아니다. 예를 들어 f2가 'b' 타입을 예상하는 자리에 'a' 타입을 놓고 작업할 거라는 보장은 없다. 어떤 경우에는 그럴 수도 있지만 항상 그런 것은 아니다. maybeMap의 정의도 보자. 다음 이유로 인해 이것 역시 map 함수다. 구조를 보존한다. 타입만이 변한다. 멋져 보이는 말 여기서 정의한 fold는 반(反) 사상(= catamorphism)의 한 예다. 반사상은 자료 구조를 단일 값으로 눌러 접어버리는 일반적인 수단이다. 반사상과 그에 관련된 재귀 개념에 대한 심오한 이론이 있지만 여기서는 그 이론을 파고들지 않는다. 우리의 주 목표는 탄탄한 예제를 통해 하스켈에서 자료 구조 조작의 메커니즘을 연습하는 것이기 때문이다. 노트 folding을 위해 사용되는 함수가 또 다른 fold의 결과를 인자로 받는 이런 종류의 재귀는 리스트나 트리 같은 자료 구조의 fold에게 "누적되는" 기능을 부여한다. ↩ 6 클래스와 타입 원문: https://en.wikibooks.org/wiki/Haskell/Classes_and_types 클래스와 인스턴스 파생(deriving) 클래스 상속 표준 클래스 타입 한정 다른 사용법 구체적인 예제 조언 한 마디 노트 타입의 기초 2에서 타입 클래스를 숫자형에 활용되는 메커니즘으로서 간단히 소개했었다. 하지만 앞서 언급했듯이 클래스에는 다른 쓰임새가 많이 있다. 간략히 말하면 타입 클래스의 핵심은 특정 타입의 값들에 대해 특정 작업들이 가능함을 보장하는 것이다. 예를 들어 어떤 타입이 Fractional 클래스에 속한다는 것(전문 용어를 사용하자면, 인스턴스화한다는 것)을 알고 있다면, 우리는 그 값을 가지고 나누기를 실제로 수행할 수 있음을 보장받는다. 클래스와 인스턴스 지금까지는 이미 존재하는 타입 클래스가 시그너처에 어떻게 나타나는지를 봐왔다. (==) :: (Eq a) => a -> a -> Bool 관점을 바꿔볼 시간이다. 먼저 Prelude의 Eq 클래스의 정의를 가져와보겠다. class Eq a where (==), (/=) :: a -> a -> Bool -- Minimal complete definition: -- (==) or (/=) x /= y = not (x == y) x == y = not (x /= y) 이 정의는 a 타입이 Eq 클래스의 인스턴스가 되려면, 함수 (==)와 (/=) (클래스 메서드들)을 지원해야 하고 이들의 타입은 a -> a -> Bool 이어야 한다고 선언한다. 추가적으로, 이 클래스는 (==)와 (/=)의 기본 정의를 제공하는데, 이것들은 서로를 이용해 정의된다. 그 결과 Eq의 한 타입에 두 함수를 모두 정의할 필요가 없게 된다. 하나만 있으면 다른 것은 자동으로 생성된다. 한 클래스를 정의하면, 이미 존재하는 타입들을 이 클래스의 인스턴스로 만들 수 있다. 다음 예시에서는 인스턴스 선언을 통해서 한 대수 데이터 타입을 Eq의 인스턴스로 만들었다. data Foo = Foo {x :: Integer, str :: String} instance Eq Foo where (Foo x1 str1) == (Foo x2 str2) = (x1 == x2) && (str1 == str2) 이제 Foo 값에 (==)와 (/=)를 흔히 쓰는 방식으로 적용할 수 있다. *Main> Foo 3 "orange" == Foo 6 "apple" False *Main> Foo 3 "orange" /= Foo 6 "apple" True 중요한 사항을 몇 개 짚어보자. Eq 클래스는 표준 Prelude에 정의되어 있다. 이 코드는 Foo 타입을 정의하고 Eq의 인스턴스로 선언한다. 세 개의 정의(클래스, 데이터 타입, 인스턴스)는 완전히 별개이며 이것들을 어떻게 묶는가에 관한 규칙은 없다. 이것은 양방향으로 작동한다. Bar라는 새로운 클래스를 만들어 Integer 타입을 이 클래스의 인스턴스로 선언할 수도 있다. 클래스는 타입이 아니라 타입의 범주(category)다. 그리고 클래스의 인스턴스는 값이 아니라 타입이다.2 Foo를 위한 (==) 정의는 Foo의 필드(즉 Integer와 String)의 값 역시 Eq의 구성원이라는 사실에 기반한다. 사실 하스켈의 거의 모든 타입은 Eq의 구성원이다. (가장 주목할 만한 예외는 함수다.) type 키워드를 이용해 정의한 타입 동의어(type synonym)는 클래스의 인스턴스로 만들 수 없다. 파생(deriving) 값 사이의 항등 비교는 흔한 일이기 때문에 여러분이 실제로 작성할 프로그램에서는 대부분의 자료형이 Eq의 구성원이어야 한다. 많은 자료형이 Ord나 Show 같은 다른 Prelude 클래스의 구성원이다. 모든 새로운 타입에 비슷한 코드를 찍어내는 것을 피하기 위해 하스켈은 deriving 키워드를 통해 "뻔한" 인스턴스 정의를 편리하게 선언하는 수단을 지원한다. Foo는 이렇게 작성할 수 있다. data Foo = Foo {x :: Integer, str :: String} deriving (Eq, Ord, Show) 이러면 Foo는 Eq의 인스턴스가 되어 우리가 방금 작성했던 ==의 정의와 완전히 같은 것을 자동으로 생성하며, 또한 Foo는 적절한 방식으로 Ord와 Show의 인스턴스가 된다. deriving는 일부 내장 클래스들에 한정해서만 사용할 수 있다. 아주 간략히 서술하자면 다음과 같은 것들이 있다. Eq 항등 검사 연산자 ==와 /= Ord 비교 연산자 < <= > >= 그리고 min, max, 마지막으로 compare Enum 열거형 전용. [Blue .. Green] 같은 리스트 문법을 사용할 수 있다. Bounded 열거형을 위한 것이지만 생성자가 하나인 타입에도 쓸 수 있다. minBound와 maxBound를 그 타입이 취할 수 있는 하한 값과 상한 값으로서 제공한다. Show show 함수를 정의한다. 이 함수는 값을 문자열료 변환한다. 기타 관련된 함수들도 정의한다. Read read 함수와 기타 관련 함수들을 정의한다. read는 문자열을 그 타입의 값으로 변환한다. 관련 함수들이 파생되는 정확한 규칙은 language report에 있다. 하지만 대체로 "올바른 구현"을 할 거라고 보장할 수 있다. 이때 데이터 타입 내의 원소 타입도 파생하려는 클래스의 인스턴스여야 한다. 미리 정의된 몇 클래스에 대한 특별한 "마법" 함수들을 제공한다는 것은 하스켈의 "내장된 것이라고 특별하지 않다"라는 일반적인 원칙을 위배한다. 하지만 손 고생을 많이 덜어주기도 하고 인스턴스 파생은 우리가 뭔가를 잘못 작성하는 것을 막아준다. (예: x == y와 y == x가 같지 않은 Eq의 인스턴스는 완전히 잘못된 것이다) 3 클래스 상속 클래스는 다른 클래스를 상속할 수 있다. 다음은 Prelude의 Ord 정의의 핵심부다. class (Eq a) => Ord a where compare :: a -> a -> Ordering (<), (<=), (>=), (>) :: a -> a -> Bool max, min :: a -> a -> a 실제 정의는 이것보다 길고 대부분의 함수의 기본 정의를 포함한다. 여기서 핵심은 Ord가 Eq를 상속한다는 것이다. 첫 번째 줄의 => 표기가 바로 상속을 의미하며 이는 클래스가 타입 시그너처에 나타나는 방식을 반영한다. 여기서 뜻하는 바는 Ord의 인스턴스가 될 타입은 Eq의 인스턴스가 되어야 하며 따라서 == 연산과 /= 연산을 구현해야 한다는 것이다. 4 클래스는 여러 클래스를 상속할 수 있다. =>에 앞서 부모가 될 클래스들을 괄호로 감싸면 된다. Prelude의 또 다른 일부를 인용해 보자. class (Num a, Ord a) => Real a where -- | the rational equivalent of its real argument with full precision toRational :: a -> Rational 표준 클래스 Haskell Report에서 가져온 이 다이어그램은 표준 Prelude의 클래스들과 타입들 간의 관계를 보여준다. 굵은 이름은 클래스이고 보통 글자는 각 클래스의 인스턴스인 타입을 나타낸다. (->)는 함수를, []는 리스트를 나타낸다. 클래스들을 연결하는 화살표는 상속 관계를 나타내며 화살촉이 있는 쪽이 상속하는 클래스다. 기본 타입 클래스들의 계층도 타입 한정 책에서 클래스가 맨 처음 등장한 예제로 돌아가 보자. (+) :: (Num a) => a -> a -> a (Num a) =>는 타입 한정(type constraint)으로서, a 타입을 Num 클래스의 인스턴스로 제한한다. 사실 (+)는 (*), (-)와 더불어 Num의 메서드이다. 단 (/)는 아니다. 타입 시그너처에 이렇게 여러 개의 제약을 추가할 수 있다. foo :: (Num a, Show a, Show b) => a -> a -> b -> String foo x y t = show x ++ " plus " ++ show y ++ " is " ++ show (x+y) ++ ". " ++ show t 여기서 인수 x와 y는 같은 타입이어야 하며 그 타입은 Num과 Show의 인스턴스여야 한다. 더욱이 마지막 인수인 t는 (아마 a와 다를) 어떤 타입인데, Show의 인스턴스여야 한다. 이 예시에서는 그 제약이 정의에 이용한 함수들(이 경우 (+)와 show)로부터 새로 정의되는 함수로 어떻게 확산되는 지도 볼 수 있다. 다른 사용법 타입 제한은 타입 시그너처뿐 아니라 다른 상황에도 도입할 수 있다. instance 선언 (보통 매개화 타입과 함께 쓰인다) class 선언 (클래스를 정의하는 타입 변수 외에 어떤 타입 변수에도 일반적인 방식으로 메서드 시그너처에 제약을 걸 수 있다 5) data 선언 6. 이때는 생성자 시그너처에 대한 제약으로 작용한다. 잠깐 data 선언에서의 타입 한정은 보기보단 그다지 유용하지 않다. data (Num a) => Foo a = F1 a | F2 a String Foo는 생성자가 두 개인 타입이다. 둘 다 a 타입의 인자를 취하는데 이 인자는 반드시 Num이어야 한다. 하지만 (Num a) =>라는 제한은 F1과 F2 생성자에만 영향을 주며 Foo를 수반하는 다른 함수에서는 그렇지 않다. 따라서 다음 예시에서 fooSquared :: (Num a) => Foo a -> Foo a fooSquared (F1 x) = F1 (x * x) fooSquared (F2 x s) = F2 (x * x) s 생성자는 a가 Num 클래스의 타입이라고 보장하지만 fooSquared의 시그너처에서 그 한정을 복제할 수밖에 없다. 7 구체적인 예제 타입, 클래스, 한정(constraint)의 상호작용을 더 잘 보기 위해 아주 간단하지만 다소 인위적인 예제를 보자. 우리는 Located 클래스, Located를 상속하는 Movable 클래스, Movable 한정이 붙으며 부모 클래스인 Located의 메서드들을 이용해 구현되는 함수를 정의할 것이다. -- Location, in two dimensions. class Located a where getLocation :: a -> (Int, Int) class (Located a) => Movable a where setLocation :: (Int, Int) -> a -> a -- An example type, with accompanying instances. data NamedPoint = NamedPoint { pointName :: String , pointX :: Int , pointY :: Int } deriving (Show) instance Located NamedPoint where getLocation p = (pointX p, pointY p) instance Movable NamedPoint where setLocation (x, y) p = p { pointX = x, pointY = y } -- Moves a value of a Movable type by the specified displacement. -- This works for any movable, including NamedPoint. move :: (Movable a) => (Int, Int) -> a -> a move (dx, dy) p = setLocation (x + dx, y + dy) p where (x, y) = getLocation p 조언 한 마디 위의 Movable 예제를 너무 깊게 들여다보지는 말자. 이것은 클래스와 관련된 언어 특징을 설명하기 위한 용도일 뿐이다. setLocation 같이, 생각하기에 따라 일반화할 수 있는 모든 개별 기능에 저마다 타입 클래스가 필요하지는 않다. 특히 모든 Located 인스턴스가 움직일 수 있어야 한다면 Movable은 불필요하다. 그리고 인스턴스가 하나만 필요하면 타입 클래스를 쓸 이유가 전혀 없다! 클래스는 그 클래스를 인스턴스화하는 여러 타입이 있고(또는 다른 사람들이 추가적인 인스턴스를 작성할 거라고 예상될 때) 사용자가 타입들 사이의 차이를 알거나 신경 쓰길 원하지 않을 때 가장 훌륭하게 쓰이는 법이다. Show가 바로 그러한 예시다. Show는 수많은 타입이 구현하는 범용 기능이며 show를 호출하기 전 알아야 할 사전 지식은 없다. 다음 장에서는 라이브러리에 들어 있는 많은 중요한 타입 클래스들을 파헤칠 것이다. 이 클래스들은 여러 기능이 한 클래스에 어우러지는 좋은 예시다. 노트 객체 지향 언어의 나라에서 온 프로그래머들에게: 하스켈의 클래스는 여러분이 생각하는 그런 것이 아니다. 클래스라는 용어에 헷갈리지 말자. 타입 클래스의 일부 사용법은 추상 클래스나 자바 인터페이스와 비슷하긴 하지만, 근본적인 차이가 있으며 앞으로 명확하게 알게 될 것이다. ↩ 이것이 대부분의 객체 지향 언어와의 주된 차이점이다. 객체 지향 언어에서는 클래스 자체가 타입이다. ↩ 이 마법을 다른 클래스에 적용하는 방법이 있다. GHC 확장은 다른 흔히 쓰는 클래스에도 deriving을 허용하며 이때 그 인스턴스를 작성하는 올바른 방법은 단 하나인데 GHC 제너릭이 작동하는 방식은 커스텀 클래스의 인스턴스를 자동 생성하는 것을 가능케 한다. ↩ Prelude 명세서에서 완전한 정의를 확인해 보면 그 이유가 명확해진다. 기본 구현은 비교될 값들에 (==)를 적용한다. ↩ 클래스를 정의하는 타입의 제한은 클래스 상속을 통해 지정되어야 한다. ↩ newtype 선언도 마찬가지다. 단 type은 아니다. ↩ 궁금한 독자들을 위한 부연 설명: 이 문제는 고급반의 "타입과의 유희" 장에서 논하는 고급 기능들이 처리하는 문제들과 연관 있다. ↩ 7 Functor 클래스 원문: http://en.wikibooks.org/wiki/Haskell/The_Functor_class 동기 Functor의 도입 functor의 법칙 무엇을 얻었는가? 이번 장에서는 Functor라는 중요한 타입 클래스를 소개한다. 동기 다른 자료구조들에서 어떤 그룹화된 값의 모든 원소에 적용되는 연산을 봤었다. 그 대표적인 예시가 리스트에 대해 작동하는 map이다. 또 다른 예로 우리가 만들었던 Tree 데이터 타입이 있다. data Tree a = Leaf a | Branch (Tree a) (Tree a) deriving (Show) 다음은 Tree를 위해 작성했던 map 함수다. treeMap :: (a -> b) -> Tree a -> Tree b treeMap f (Leaf x) = Leaf (f x) treeMap f (Branch left right) = Branch (treeMap f left) (treeMap f right) 앞서 논의한 바와 같이 어떤 자료구조에든 map<NAME>의 함수를 생각하여 정의할 수 있다. 리스트 보충 설명에서 map을 처음 소개할 때, 리스트 원소에 대한 아주 구체적인 함수에서 시작하여 일반화를 거쳐 map을 모든 종류의 리스트에 들어맞는 함수와 결합했었다. 이제 더 일반화하여, 리스트용 map, 트리용 map 등을 만드는 대신 매핑 가능한 모든 종류의 타입에 대한 범용 map을 두는 것이 어떨까? Functor의 도입 Functor는 매핑 가능한 타입을 위한 Prelude 클래스로서, fmap이라는 하나의 메서드를 가지며 다음과 같이 정의된다. class Functor f where fmap :: (a -> b) -> f a -> f b 타입 변수 f의 용법이 처음에는 낯설 수도 있겠다. f는 매개화된 데이터 타입이다. fmap의 시그너처에서 f는 a를 하나의 타입 매개변수로 취하고 b를 다른 것으로 취한다. Functor의 예시를 하나 보자. f를 Maybe로 치환하면 fmap의 시그너쳐는 다음과 같이 된다. fmap :: (a -> b) -> Maybe a -> Maybe b 이는 다음의 자연스러운 정의와 들어맞는다. instance Functor Maybe where fmap f Nothing = Nothing fmap f (Just x) = Just (f x) (우연히도 이 정의는 Prelude에 들어있다. 그러니 "다른 자료구조들" 장에 있는 그 예제에 대한 maybeMap을 구현할 필요는 없다) 리스트에 대한 Functor 인스턴스는 간단하고 이것 역시 Prelude에 들어있다. instance Functor [] where fmap = map 그리고 fmap의 시그너쳐에서 f를 []로 치환하면 친숙한 map을 볼 수 있다. 즉 fmap은 임의의 매개화 데이터 타입에 대해 map을 일반화한 것이다. 1 자연스레 우리가 만든 데이터 타입에도 Functor 인스턴스를 제공할 수 있다. 특히 treeMap을 Functor의 인스턴스로 바로 대체할 수 있다. instance Functor Tree where fmap f (Leaf x) = Leaf (f x) fmap f (Branch left right) = Branch (fmap f left) (fmap f right) 다음은 위의 인스턴스를 실제로 쓰는 fmap 데모다. Tree의 data와 instance 선언만 불러오면 된다. 나머지는 이미 Prelude에 들어있다. *Main> fmap (2*) [1,2,3,4] [2,4,6,8] *Main> fmap (2*) (Just 1) Just 2 *Main> fmap (fmap (2*)) [Just 1, Just 2, Just 3, Nothing] [Just 2, Just 4, Just 6, Nothing] *Main> fmap (2*) (Branch (Branch (Leaf 1) (Leaf 2)) (Branch (Leaf 3) (Leaf 4))) Branch (Branch (Leaf 2) (Leaf 4)) (Branch (Leaf 6) (Leaf 8)) 잠깐 여기서 언급한 []와 Maybe 예시 밖에도 많은 편리한 Functor 인스턴스들이 제공된다. 완전한 목록은 Control.Monad 모듈에 대한 GHC의 문서에서 볼 수 있다. functor의 법칙 Functor의 새 인스턴스를 정의할 때는 두 개의 functor 법칙을 만족해야 한다. 이 법칙들에 불가사의한 점은 없다. 이 법칙들의 역할은 fmap이 정상적으로 작동하여 매핑 작업을 실제로 수행하도록 보장하는 것이다. 2 첫 번째 법칙은 다음과 같다. fmap id == id id는 항등 함수로서 인자를 그대로 반환한다. 제1법칙은 functor로 id를 매핑하면 반드시 그 functor를 그대로 반환해야 함을 뜻한다. 제2법칙은 다음과 같다. fmap (f . g) == fmap f. fmap g 이 법칙은 합성 함수를 매핑하든 먼저 하나를 매핑하고 다음 것을 매핑하든 무관해야 함을 뜻한다. (적용 순서는 둘 다 같다고 가정) 무엇을 얻었는가? 이쯤에서 Functor 클래스에 의한 추가적인 일반화 계층으로 인해 무슨 이점을 얻을 수 있는지 자문할 수 있다. 여기에는 두 가지 중요한 이득이 있다. fmap 메서드 덕분에 우리는 서로 이름이 다른 매핑 메서드들(maybeMap, treeMap, weirdMap 등)을 일일이 기억하고 읽고 쓰지 않아도 된다. 그 결과 코드는 더 깔끔하고 이해하기 쉬워진다. fmap이 사용된 곳을 보자마자 우리는 무슨 일이 벌어지는지 감을 잡을 수 있다.3 타입 클래스 체계를 이용하면 [], Maybe, Tree, 그 외에 어떤 펑터에도 작동하는 fmap 기반 알고리즘을 작성할 수 있다. 다름 아닌 핵심 라이브러리의 많은 유용한 클래스가 Functor를 상속한다. 타입 클래스를 통해 온갖 종류의 문제에 대한 일반적인 해법을 만들 수 있다. 하스켈을 어떤 용도로 사용하느냐에 따라 새 클래스를 정의할 필요가 없을 수도 있지만 타입 클래스는 항상 쓰게 될 것이다. 하스켈의 대부분의 강력한 특징과 정교한 기능은 타입 클래스에 의존한다. 지금부터 클래스는 우리의 공부에서 빠질 수 없는 존재일 것이다. 자료구조가 가장 직관적인 예시다. 하지만 자료구조라고 볼 수 없는 펑터도 있다. 흔히들 펑터를 컨테이너에 비유하곤 한다. 하지만 모든 비유가 그렇듯이 대략적으로 들어맞을 뿐이다. ↩ 펑터의 법칙, 더불어 펑터라는 개념은 범주론이라는 수학의 한 갈래에 기반하는데 지금은 신경 쓸 사항이 아니다. 고급반에서 관련 주제들을 볼 기회가 있을 것이다. ↩ 이는 리스트에 대한 명시적인 재귀 알고리즘을 고차 함수에 기반한 구현으로 대체할 때 얻어지는 명료함과 비슷하다. ↩ 4 모나드 모나드 서장: IO, 이른바 적용성 펑 터 모나드 이해하기 Maybe - List do 표기 IO - State Alternative와 MonadPlus 모나드 변환기 1 서장: IO, 적용성(applicative) 펑 터 원문: https://en.wikibooks.org/wiki/Haskell/Prologue:_IO,_an_applicative_functor functorial의 적절한 번역? (https://math.stackexchange.com/questions/2009361/what-does-it-mean-to-be-functorial-in-something) 1막 : Applicative 펑 터 내에서의 적용(application) 2막 : IO 참조 투명성(Referential transparency) 안개 걷어내기 이제 시작일 뿐 노트 펑터의 도입은 이 책의 분수령이다. 이 도입부에서 다음 장들을 위한 무대를 준비하며 그 이유가 점차 드러날 것이다. 여기서 다루는 코드 예제들은 아주 간단하지만, 새롭고 중요한 개념들을 다루는데 활용된다. 이 개념들은 책을 진행하면서 다시 방문하고 더 깊게 다루게 될 것이다. 그러니 이번 장을 신중하게 연구하여 각 단계에 내포된 뜻에 대해 생각해 보고 코드 샘플을 GHCi에서 확인해 보는 것을 추천한다. 1막 : Applicative 첫 번째 예제에서는 Text.Read 모듈이 제공하는 readMaybe 함수를 활용할 것이다. GHCi> :m +Text.Read GHCi> :t readMaybe readMaybe :: Read a => String -> Maybe a readMaybe는 문자열을 하스 켈 값으로 변환하는 간단한 수단을 제공한다. 제공된 문자열이 a 타입의 값으로 해석되기 적합한 포맷을 가지면 readMaybe는 변환된 값을 Just로 감싸서 반환한다. 그렇지 않으면 결과는 Nothing이다. GHCi> readMaybe "3" :: Maybe Integer Just 3 GHCi> readMaybe "foo" :: Maybe Integer Nothing GHCi> readMaybe "3.5" :: Maybe Integer Nothing GHCi> readMaybe "3.5" :: Maybe Double Just 3.5 노트 readMaybe를 사용하려면 우리가 어떤 타입을 읽으려고 하는지를 명시해야 한다. 대부분의 경우 이는 타입 추론과 우리 코드 내의 시그너처를 조합해 처리된다. 하지만 가끔은 알맞은 시그너처를 작성하는 대신 type annotation을 붙이는 게 더 편리한 경우가 있다. 예를 들어 위의 예제에서 readMaybe "3" :: Maybe Integer의 :: Maybe Integer는 readMaybe "3"의 타입이 Maybe Integer 임을 뜻한다. readMaybe를 사용하면 다음 작업들을 하는 간단한 프로그램을 간단한 입출력 장의 스타일로 작성할 수 있다. 사용자가 커맨드 라인을 통해 제공한 문자열을 받는다. 숫자로서 읽기를 시도한다. (Double 타입을 이용) 읽기가 성공하면 그 숫자의 두 배를 출력하고, 아니면 설명문을 출력하고 다시 시작한다. 노트 계속하기 전에 프로그램을 직접 작성해 보는 것을 추천한다. readMaybe 외에도 getLine, putStrLn, show 등 유용한 것들을 발견하게 될 것이다. 콘솔을 통해 읽고 출력하는 법을 복기해야 한다면 간단한 입출력 장을 보자. 다음은 가능한 구현 중 하나다. import Text.Read interactiveDoubling = do putStrLn "Choose a number:" s <- getLine let mx = readMaybe s :: Maybe Double case mx of Just x -> putStrLn ("The double of your number is " ++ show (2*x)) Nothing -> do putStrLn "This is not a valid number. Retrying..." interactiveDoubling GHCi> interactiveDoubling Choose a number: foo This is not a valid number. Retrying... Choose a number: The double of your number is 6.0 잘 되고 간단하다. 이 해법을 변형하자면 Maybe가 Functor 임을 활용해 case 문에서 mx를 해체하기 전에 그 값을 두 배로 만들 수 있다. interactiveDoubling = do putStrLn "Choose a number:" s <- getLine let mx = readMaybe s :: Maybe Double case fmap (2*) mx of Just d -> putStrLn ("The double of your number is " ++ show d) Nothing -> do putStrLn "This is not a valid number. Retrying..." interactiveDoubling 이번에는 그렇게 해도 실질적인 이득이 없었지만, 이런 게 가능하다는 것을 염두에 두 자. 펑 터 내에서의 적용(application) 좀 더 복잡한 것을 해보자. readMaybe로 숫자 두 개를 읽고 그 합을 출력한다. (역시 계속하기 전에 직접 작성해 보는 것을 제안한다) 다음은 가능한 해법 중 하나다. interactiveSumming = do putStrLn "Choose two numbers:" sx <- getLine sy <- getLine let mx = readMaybe sx :: Maybe Double my = readMaybe sy case mx of Just x -> case my of Just y -> putStrLn ("The sum of your numbers is " ++ show (x+y)) Nothing -> retry Nothing -> retry where retry = do putStrLn "Invalid number. Retrying..." interactiveSumming GHCi> interactiveSumming Choose two numbers: foo Invalid number. Retrying... Choose two numbers: foo Invalid number. Retrying... Choose two numbers: 4 The sum of your numbers is 7.0 interactiveSumming은 제대로 작동하지만 작성하기 성가시다. 특히 중첩된 case 문들은 아름답지 않고 코드를 읽는 것을 조금 어렵게 만든다. interactiveDoubling의 두 번째 버전에서 fmap으로 했던 것처럼, 숫자들을 해체하기 전에 더할 수단이 있었다면 case를 하나만 쓸 수 있었을 것이다. -- Wishful thinking... case somehowSumMaybes mx my of Just z -> putStrLn ("The sum of your numbers is " ++ show z) Nothing -> do putStrLn "Invalid number. Retrying..." interactiveSumming 그런데 somehowSumMaybes 자리에 무얼 넣어야 할까? 가령 fmap으로는 충분하지 않다. 한편 fmap (+)는 Maybe로 감싼 값에 (+)를 적용하는 경우에만 작동한다. GHCi> :t (+) 3 (+) 3 :: Num a => a -> a GHCi> :t fmap (+) (Just 3) fmap (+) (Just 3) :: Num a => Maybe (a -> a) 우리는 Maybe로 감싼 함수를 두 번째 값에 적용하는 방법을 모른다. 여기에는 다음과 같은 시그너처를 가지는 함수가 필요하다. (<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b 위 함수를 이런 식으로 쓸 수 있을 것이다. GHCi> fmap (+) (Just 3) <*> Just 4 Just 7 그런데 위의 GHCi 프롬프트는 상상이 아니다. (<*>)는 실존하고 GHCi에서 실험해 보면 실제로 작동한다! fmap의 중위 동의어인 (<$>)도 사용하면 위의 표현식은 상당히 깔끔하게 보인다. GHCi> (+) <$> Just 3 <*> Just 4 Just 7 실제 타입 (<*>)은 우리가 방금 작성한 것보다 더 일반적이다. 확인해 보면... GHCi> :t (<*>) (<*>) :: Applicative f => f (a -> b) -> f a -> f b Applicative라는 새로운 타입 클래스가 등장한다. Applicative는 적용성 펑 터(applicative functor)들의 타입 클래스다. 소개를 하자면 적용성 펑터는 펑터의 일종으로서 함수들을 펑 터 내에 적용하는 것을 지원하고, 그럼으로써 부분 적용(및 다인자 함수)의 원활한 사용을 돕는다. Applicative의 모든 인스턴스는 Functor이며, Maybe 외에도 많은 범용 Functor가 Applicative이다. 다음은 Maybe를 위한 Applicative 인스턴스다. instance Applicative Maybe where pure = Just (Just f) <*> (Just x) = Just (f x) _ <*> _ = Nothing 사실 (<*>)의 정의는 상당히 간단하다. 두 값 모두 Nothing이 아니면 함수 f를 x에 적용하고 그 결과를 Just로 감싼다. 그 외의 경우 Nothing을 반환한다. 이 로직이 interactiveSumming에서 중첩 case 문이 하는 일과 정확히 동등하다는 것에 주목하자. 위의 인스턴스에는 (<*>) 외에도 pure라는 메서드가 있는 것에 주목하자. GHCi> :t pure pure :: Applicative f => a -> f a pure는 값을 받아서 기본적이고 자명한 방식으로 펑터에 집어넣는다. Maybe의 경우 그 자명한 방식은 값을 Just로 감싸는 것이다. 자명하지 않은 방식으로는 그 값을 버리고 Nothing을 반환하는 경우가 있다. pure를 이용하면 위의 3 더하기 4 예제를 다시 작성할 수 있다. GHCi> (+) <$> pure 3 <*> pure 4 :: Num a => Maybe a Just 7 혹은 이런 것도 가능하다. GHCi> pure (+) <*> pure 3 <*> pure 4 :: Num a => Maybe a Just 7 Functor 클래스가 합리적인 인스턴스들이 어떻게 행동해야 하는지를 기술하는 법칙들을 가지는 것처럼 Applicative에도 그런 법칙들이 있다. 이 법칙들은 특히 pure를 통해 값들을 펑터에 넣는 "자명한" 방식이 무엇인지를 기술하는 데 중점을 둔다. 이번 장에서 이미 많은 주제가 나왔기 때문에 그 법칙들을 지금 논의하지는 않는다. 하지만 그리 멀지 않은 시점에 이 중요한 주제로 다시 돌아올 것이다. 노트 궁금하다면 적용성 펑 터 장의 "적용성 펑 터 법칙" 섹션을 먼저 읽고 와도 된다. "ZipList" 섹션이 지금까지 배운 것들만 활용하는 일반적인 적용성 펑 터 예제들을 제공하므로 이것도 봐두면 좋다. 정리하자면 다음은 (<*>)를 통해 개선한 interactiveSumming이다. interactiveSumming = do putStrLn "Choose two numbers:" sx <- getLine sy <- getLine let mx = readMaybe sx :: Maybe Double my = readMaybe sy case (+) <$> mx <*> my of Just z -> putStrLn ("The sum of your numbers is " ++ show z) Nothing -> do putStrLn "Invalid number. Retrying..." interactiveSumming 2막 : IO 지금까지의 예제에서는 getLine 같은 I/O 액션들을 당연하다고 여겼다. 이제 몇 장 앞에서 처음 떠오른 질문을 재고할 시간이다. getLine의 타입은 무엇일까? 간단한 입출력 장에서 봤듯이 그 답은 다음과 같다. GHCi> :t getLine getLine :: IO String 지금까지 배운 바에 미루어보면 IO는 타입 변수를 하나 가지는 타입 생성자이며, getLine의 경우 그 타입 변수는 String으로서 인스턴스화된다. 하지만 문제의 근원에 다다르지는 못했다. IO String의 참뜻은 무엇이고 평범한 String과 무엇이 다른 걸까? 참조 투명성(Referential transparency) 하스켈의 핵심 기능은 우리가 작성할 수 있는 모든 표현식은 참조 투명(referentially transparent) 하다는 것이다. 이는 프로그램의 동작을 변경하지 않으면서 어떤 표현식이든 그것의 값으로 대체할 수 있음을 뜻한다. 예를 들어 다음의 아주 단순한 프로그램을 보자. addExclamation :: String -> String addExclamation s = s ++ "!" main = putStrLn (addExclamation "Hello") 그 동작은 그다지 놀랍지 않다. GHCi> main Hello! addExclamation s = s ++ "!"이 주어졌을 때 우리는 main이 addExclamation를 언급하지 않도록 재작성할 수 있다. addExclamation 정의의 우변에서 s를 "Hello"로 대체하고 addExclamation "Hello"를 그 결과 표현식으로 대체한다. 앞서 말했듯 프로그램의 동작은 변하지 않는다. GHCi> let main = putStrLn ("Hello" ++ "!") GHCi> main Hello! 참조 투명성은 이런 종류의 치환이 작동한다는 것을 보장한다. 이런 보장은 모든 하스 켈 프로그램으로 확장되어, 프로그램을 이해하고 그 동작을 예측하는 것을 쉽게 만든다. 이제 getLine의 타입이 String이라고 가정하자. 이 경우 getLine을 addExclamation의 인자로 쓸 수 있을 것이다. -- Not actual code. main = putStrLn (addExclamation getLine) 하지만 여기에는 새로운 의문이 생긴다. 만약 getLine이 String이라면 어떤 String 인가? 여기에는 만족스러운 답이 없다. "Hello", "Goodby", 혹은 사용자가 터미널에 입력한 무엇이든 될 수 있다. 무엇보다 getLine을 임의의 String으로 교체하면 프로그램이 망가지는데, 사용자가 터미널에 문자열을 더 이상 입력할 수 없기 때문이다. 그러므로 getLine이 String 타입을 가지는 것은 참조 투명성을 깨트린다. 다른 I/O 액션들도 모두 마찬가지다. 그 결과는 불투명하며, 미리 아는 것이 불가능하다. 프로그램의 외부에 있는 요인에 의존하기 때문이다. 안개 걷어내기 getLine이 보여주듯이 I/O 액션에는 근본적인 비결정성이 관여한다. 참조 투명성을 유지하려면 이러한 비결정성을 고려해야 한다. 하스켈에서 이는 IO 타입 생성자를 통해 이뤄진다. getLine이 IO String이라는 것의 뜻은 이것이 실제 String이라는 것이 아니고, 프로그램이 실행될 때에서야 실체화할 String을 위한 자리표이자 그 String이 전달될 것이라는 약속이다. (getLine의 경우 터미널을 통해 받아서) 따라서 우리가 IO String을 조작할 때, 우리는 이 미지의 String이 도착하면 무엇을 하게 될지에 대한 계획을 세우는 것이다. 그렇게 하는 방법은 여러 개인데, 이 절에서는 두 가지를 알아볼 것이다. 세 번째 방법은 몇 장 뒤에서 알아볼 것이다. 실제로 거기에 없는 값을 다룬다는 발상은 처음에는 이상하게 보인다. 그런데 우리는 이미 태연하게 그런 것을 논의한 적이 있다. mx가 Maybe Double 일 때, fmap (2*) mx는 값이 거기에 있다면 그 값을 두 배로 만드는데, 이 fmap은 그 값이 실제로 존재하는지와 무관하게 작동한다. 1 Maybe a와 IO a는 a 타입의 값에 도달하기 위해 서로 다른 이유로 간접적인 층을 하나 더한다. 따라서 Maybe처럼 IO도 Functor라는 게 새삼스러운 일은 아니며, fmap은 이 간접적인 층을 통과하는 가장 기초적인 수단이다. 우선 IO가 Functor라는 사실을 이용해서 앞절의 interactiveSumming에서 let 정의를 더 간단하게 만들 수 있다. interactiveSumming :: IO () interactiveSumming = do putStrLn "Choose two numbers:" mx <- readMaybe <$> getLine -- equivalently: fmap readMaybe getLine my <- readMaybe <$> getLine case (+) <$> mx <*> my :: Maybe Double of Just z -> putStrLn ("The sum of your numbers is " ++ show z) Nothing -> do putStrLn "Invalid number. Retrying..." interactiveSumming readMaybe <$> getLine은 "일단 getLine이 문자열을 전달하면 그게 무엇이든 readMaybe를 적용하라"로 읽을 수 있다. 참조 투명성은 깨지지 않는다. readMaybe <$> getLine 이면의 값은 getLine의 값만큼이나 불투명하고 그 타입(이 경우 IO (Maybe Double))은 이것을 어떤 결정된 값(가령 Just 3)으로 교체하는 것을<NAME>다. 그렇게 하면 참조 투명성을 위반하기 때문이다. IO는 Functor이면서 Applicative이기도 하므로 I/O 액션에 의해 전달된 값을 조작하는 두 번째 수단을 제공한다. 이것은 interactiveSumming와 비슷한 방식으로 interactiveConcatenating 액션을 통해 설명할 것이다. 첫 번째 버전은 다음과 같다. (<*>)를 이용해서 어떻게 단순하게 만들 수 있을까? interactiveConcatenating :: IO () interactiveConcatenating = do putStrLn "Choose two strings:" sx <- getLine sy <- getLine putStrLn "Let's concatenate them:" putStrLn (sx ++ sy) 다음은 (<*>)를 활용한 버전이다. interactiveConcatenating :: IO () interactiveConcatenating = do putStrLn "Choose two strings:" sz <- (++) <$> getLine <*> getLine putStrLn "Let's concatenate them:" putStrLn sz (++) <$> getLine <*> getLine은 두 I/O 액션(두 getLine)으로부터 만들어진 I/O 액션이다. 이 액션이 실행되면 그 두 I/O 액션이 실행되고 이것들이 전달하는 문자열들이 연결된다. 여기서 주목할 것은 (<*>)이 연결하는 액션들 간에 실행 순서가 일관된다는 것이다. 실행 순서는 I/O를 다룰 때 중요하다. 그런 예시는 끝도 없지만 이런 질문으로 시작해 보자. 위 에제에서 두 번째 getLine을 (take 3 <$> getLine)으로 교체한다면 터미널에 입력한 문자열들 중 어떤 것이 세 글자로 잘릴까? (<*>)는 액션들의 순서를 존중하므로 그 액션들을 나열하는 수단도 제공한다. 특히 나열만 하면 되고 첫 번째 액션의 결과에 관심이 없다면 \_ y -> y를 통해 그 결과를 파기할 수 있다. GHCi> (\_ y -> y) <$> putStrLn "First!" <*> putStrLn "Second!" First! Second! 이 사용 패턴은 워낙 흔해서 특별히 이를 위한 (*>) 연산자가 있다. u *> v = (\_ y -> y) <$> u <*> v GHCi> :t (*>) (*>) :: Applicative f => f a -> f b -> f b GHCi> putStrLn "First!" *> putStrLn "Second!" First! Second! interactiveConcatenating 예제에도 쉽게 적용할 수 있다. interactiveConcatenating :: IO () interactiveConcatenating = do putStrLn "Choose two strings:" sz <- (++) <$> getLine <*> getLine putStrLn "Let's concatenate them:" *> putStrLn sz 더 나아가 이렇게 할 수도 있다. interactiveConcatenating :: IO () interactiveConcatenating = do sz <- putStrLn "Choose two strings:" *> ((++) <$> getLine <*> getLine) putStrLn "Let's concatenate them:" *> putStrLn sz 각 (*>)는 do 블록에서 액션들이 순서대로 실행되도록 하는 마법의 줄바꿈 들 중 하나를 대체한다는 것을 숙지하자. 사실 교체된 줄바꿈 들은 (*>)의 편의 문법일 뿐이다. 앞서 말하기를 펑터는 그 안의 값에 접근하기 위한 간접층을 하나 늘린다고 하였다. 이러한 관찰을 뒤집어보면 간접층은 문맥(context)에 의해 유발되고, 그 문맥 안에서 값이 발견되는 것이다. IO의 경우 간접은 프로그램이 실행될 때에만 값이 결정된다는 것이고, 문맥은 이 값을 생산하기 위해 사용된 일련의 명령들로 구성된다. (getLine의 경우 그 명령은 "터미널에서 텍스트 한 줄을 빼오는 것"이다) 이런 관점에서 (<*>)는 두 functorial 값을 취해서 그 안의 값들뿐 아니라 문맥들 자체도 합성하게 된다. IO의 경우 문맥의 합성은 한 I/O 액션의 명령들을 다른 액션의 명령들에 덧붙여서 액션들을 연결하는 것을 뜻한다. 이제 시작일 뿐 이번 장은 다소 정신이 없었다. 핵심을 요약해 보자. Applicative는 적용성 펑터를 위한 Functor의 서브 클래스로서, 펑터를 떠나지 않고 함수 적용을 할 수 있게 해주는 펑터다. Applicative의 (<*>) 메서드는 다중 인자를 위한 fmap 일반화로서 사용할 수 있다. IO a는 a 타입의 실재하는 값이 아니라 프로그램이 실행될 때 실현될 a 값의 자리표이자 이 값이 어떤 수단을 통해 전달될 것이라는 약속이다. 이로써 I/O 액션을 다룰 때도 참조 투명성을 만족하게 된다. IO는 펑 터이고 특히 Applicative의 인스턴스로서, I/O 액션에 의해 생산된 값을 그 비결정성에도 불구하고 조작할 수 있는 수단을 제공한다. functorial 값은 어떤 문맥 안의 값들로 이루어졌다고 볼 수 있다. (<$>) 연산자(즉 fmap)는 그 문맥을 통과해서 기저의 값을 수정한다. (<*>) 연산자는 두 functorial 값의 문맥들과 기저 값들을 합성한다. IO의 경우 (<*>)와 (*>)는 I/O 액션들을 연결함으로써 문맥들을 합성한다. do 블록의 역할은 단지 (*>)의 편의 문법을 제공하는 것이 많은 부분을<NAME>다. 마지막으로, do 블록에는 아직 큰 수수께끼가 숨어있다. 왼쪽 화살표는 무엇을 할까? 이런 do 블록은... sx <- getLine 마치 IO 문맥 하에서 getLine이 생성한 값을 추출하는 것처럼 보인다. 참조 투명성에 관한 논의 덕에 우리는 이제 그것이 환상이라는 것을 알고 있다. 그러면 그 이면에서는 무슨 일이 일어나는 걸까? 나중에 알게 될 테니 지금은 자유롭게 고민해 보자. 노트 두 상황의 주요 차이점은 Maybe의 경우 비결정성인 것처럼 보일 뿐이며, mx 뒤에 실제 Double이 오게 될지 미리 알 수 있다는 것이다. 더 정확히 말하자면, mx의 값이 I/O에 의존하지 않아야만 가능하다. ↩ 2 모나드 이해하기 원문 : http://en.wikibooks.org/wiki/Haskell/Understanding_monads 정의 동기: Maybe 타입 클래스 Monad와 Applicative 계산이라는 개념 Notions of Computation 모나드의 법칙 중립 원 neutral element으로서의 return bind의 결합법칙 모나 딕 합성 모나드와 범주론 liftM과 그 친구들 하스켈에서 모나드는 매우 유용하지만 처음에는 그 개념이 꽤 어렵다. 모나드는 수많은 응용이 있기 때문에 사람들은 모나드를 특정 관점에서만 설명하는 경향이 있는데, 그러면 여러분이 모나드를 완벽히 이해하는 데 혼란을 줄 수도 있다. 역사적으로 보면 모나드는 하스켈에서 입출력을 수행하기 위해 도입되었다. 미리 정의된 실행 순서는 파일 읽고 쓰기 같은 작업에 중대한 사항이고 모나 딕 연산은 내재된 inherent 순서를 따른다. 전에 간단한 입출력에서 do 표기를 이용한 연쇄와 IO를 논의한 바 있다. 사실 do는 모나드의 편의 구문일 뿐이다. 모나드는 입출력에 한정되지 않는다. 모나드는 예외, 상태, 비결정성 non-determinism, 연속성 continuation, 코루틴, 그 외에 수많은 것을 지원한다. 사실 모나드의 다재다능함 덕에 이 중 어느 것도 하스 켈 언어의 일부로 내장될 필요가 없었다. 이것들은 대신 표준 라이브러리에 정의되어 있다. 정의 모나드는 세 가지에 의해 정의된다. 타입 생성자 M return 함수 1 "bind"라 부르는 (>>=) 연산자 위의 함수와 연산자는 Monad 타입 클래스의 메서드이며 다음의 타입을 가진다. return :: a -> M a (>>=) :: M a -> ( a -> M b) -> M b 그리고 나중에 설명할 세 개의 법칙을 따라야 한다. 구체적인 예시로 Maybe 모나드를 보자. 타입 생성자는 M = Maybe이고 return과 (>>=)는 이렇게 정의된다. return :: a -> Maybe a return x = Just x (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b m >>= g = case m of Nothing -> Nothing Just x -> g x Maybe는 모나드고 return은 하나의 값을 Just로 감싸서 반환한다. (>>=)는 m :: Maybe a 값과 g :: a -> Maybe b 함수를 취한다. m이 Nothing 이면 하는 일 없이 결과도 Nothing이다. 반대로 Just x의 경우 Just로 감싼 x에 g가 적용되고 Maybe b를 결과로 내놓는다. 그 결과는 g가 x에 하는 일에 따라 Nothing 일 수도 있다. 종합하면, m에 포함된 값이 있으면 이 값에 g를 적용하고 그 결과가 Maybe 모나드에 다시 들어가 반환된다. return과 (>>=)가 어떻게 작동하는지 이해하는 첫걸음은 어떤 값과 인수가 모나딕인지 아닌지 추적하는 것이다. 다른 많은 경우와 마찬가지로 타입 시그너쳐가 그 과정의 안내자가 될 것이다. 동기: Maybe (>>=)와 Maybe 모나드의 유용함을 다음 예제에서 살펴보자. 두 함수를 제공하는 가계도 데이터베이스를 가정한다. father :: Person -> Maybe Person mother :: Person -> Maybe Person 이 함수들은 누군가의 아버지나 어머니의 이름을 검색한다. 데이터베이스에 그런 정보가 없을 때 Maybe 덕에 프로그램을 고장 내는 대신 Nothing 값을 반환할 수 있다. 이 함수들을 결합하여 할아버지들을 찾아보자. 다음 함수는 외할아버지를 검색한다. maternalGrandfather :: Person -> Maybe Person maternalGrandfather p = case mother p of Nothing -> Nothing Just mom -> father mom 다음 함수는 데이터베이스에 친할아버지와 외할아버지가 모두 있는지 검사한다. bothGrandfathers :: Person -> Maybe (Person, Person) bothGrandfathers p = case father p of Nothing -> Nothing Just dad -> case father dad of Nothing -> Nothing Just gf1 -> -- found first grandfather case mother p of Nothing -> Nothing Just mom -> case father mom of Nothing -> Nothing Just gf2 -> -- found second grandfather Just (gf1, gf2) 너무 길고 복잡하다! 각각의 질의는 Nothing을 반환하면서 실패할 수 있고 그럴 경우 전체 함수도 실패해야 한다. 분명히 Nothing을 쓰고 또 쓰는 것보다 나은 방법이 있을 것이다. 모나드가 바로 그 방법이다. 예컨대 외할아버지에 접근하는 함수는 (>>=) 연산자와 정확히 동일한 구조를 가지므로 이렇게 다시 쓸 수 있다. maternalGrandfather p = mother p >>= father 람다 표현식과 return의 도움을 받아 두 할아버지를 찾는 함수도 다시 작성할 수 있다. bothGrandfathers p = father p >>= (\dad -> father dad >>= (\gf1 -> mother p >>= -- this line works as "\_ -> mother p", but naming gf1 allows later return (\mom -> father mom >>= (\gf2 -> return (gf1, gf2) )))) 중첩된 람다 표현식이 혼란스러울지도 모르겠다. 여기서 눈여겨볼 점은 (>>=) 덕에 모든 Nothing을 나열하는 부분을 없애서 코드의 관심 있는 부분에만 집중할 수 있다는 것이다. 좀 더 정확히 하자면, father p의 결과는 모나 딕 값이다. 그 값은 p의 아버지가 데이터베이스에 있느냐 없느냐에 따라 Just dad 또는 Nothing이다. father 함수가 모나드 딕 값이 아닌 정규 값을 취하기 때문에 (>>=)는 모나딕이 아닌 값인 p의 dad를 father에게 인자로 전달한다. 그리고 father dad의 결과는 다시 모나 딕 값이고, 이 과정은 계속된다. 즉 (>>=)는 모나드를 떠나지 않고도 함수에 모나딕이 아닌 값을 전달할 수 있도록 한다. Maybe 모나드의 모나 딕 관점은 그 값을 구할 수 있을지에 대한 불확실성이다. 타입 클래스 하스켈에서는 Monad 타입 클래스를 이용해 모나드를 구현한다. Monad는 Control.Monad 모듈의 일부이며 Prelude에 포함되어 있다. 이 클래스는 다음 메서드들을 가진다. class Monad m where return :: a -> m a (>>=) :: m a -> (a -> m b) -> m b (>>) :: m a -> m b -> m b fail :: String -> m a return과 bind 외에도 (>>)와 fail이라는 함수가 있다. 이 둘도 기본 구현을 가지기 때문에 인스턴스를 작성할 때 굳이 정의하지 않아도 된다. (>>) 연산자는 "then"이라 읽으며 그저 편의를 위한 것으로 대개 이렇게 구현된다. m >> n = m >>= \_ -> n (>>)는 두 모나 딕 액션을 연결하는데 두 번째 액션이 첫 번째 액션의 결과를 이용하지 않는다. IO 같은 모나드에서는 흔한 일이다. printSomethingTwice :: String -> IO () printSomethingTwice str = putStrLn str >> putStrLn str fail 함수는 do 표기 내에서의 패턴 매칭 실패를 처리한다. 기술적으로 어쩔 수 없이 필요할 뿐 모나드와는 아무 상관이 없다. fail을 코드에서 직접 호출하는 것은 권장하지 않는다. Monad와 Applicative Applicative가 Monad의 슈퍼클래스이며 이에 따른 주목할 만한 결과들이 있다는 걸 짚고 넘어가야겠다. 2 먼저 모든 Monad는 Functor 이자 Applicative이고, 따라서 모나드에도 fmap, pure, (<*>)을 사용할 수 있다. 두 번째로 사실 Monad 인스턴스를 작성하려면 Functor와 Applicative 인스턴스도 작성해야 한다. 그렇게 하는 방법은 이 장의 뒤에서 논의한다. 세 번째로 서문을 읽어봤다면 return과 (>>)의 타입과 역할이 친숙할 것이다... (*>) :: Applicative f => f a -> f b -> f b (>>) :: Monad m => m a -> m b -> m b pure :: Applicative f => a -> f a return :: Monad m => a -> m a (*>)와 (>>)의 유일한 차이점은 제약이 Applicative에서 Monad로 바뀌었다는 것이다. 사실 두 메서드 간의 차이는 이것뿐이다. Monad를 처리할 때는 언제든 (*>)와 (>>)를 서로 교체할 수 있다. pure와 return도 마찬가지다. 사실 Applicative 인스턴스에 pure의 별도 정의가 있다면 return을 구현할 필요도 없는데, return의 기본 구현은 return = pure이기 때문이다. 계산이라는 개념 Notions of Computation Maybe를 사용할 때, 틀에 박힌 코드를 없애는 데 (>>=)와 return이 아주 편리하다는 걸 봤었다. 하지만 이걸로는 모나드가 왜 그토록 중요한지 납득하기에는 충분하지 않다. 두 할아버지를 찾는 함수를, do 표기에 괄호와 세미콜론을 붙여 다시 작성하면서 모나드 공부를 계속하겠다. 다른 프로그래밍 언어 경험이 있으면 그 언어가 연상될 수도 있겠다. bothGrandfathers p = do { dad <- father p; gf1 <- father dad; mom <- mother p; gf2 <- father mom; return (gf1, gf2); } 이 코드가 명령형 언어의 코드처럼 보이는 이유는 정말 그렇기 때문이다. 사실 이 명령형 언어는 예외를 지원한다. father와 mother는 결과를 도출하는 데 실패할 수도 있는 함수다. 즉 예외를 일으킬 수 있다. 그리고 그런 일이 발생하면 do 블록 전체가 실패한다. 즉 예외를 일으키며 종료한다. 달리 말하자면 표현식 father p는 Maybe Person 타입이며 해석되기로는 명령형 언어에서 Person을 결괏값으로 반환하는 하나의 명령문처럼 해석된다. 이 말은 모든 모나드에 대해 성립한다. M a 타입의 값은 명령형 언어에서 a 타입의 값을 결과로 반환하는 명령문으로 해석된다. 그리고 이 언어의 의미 semantic는 모나드 M에 의해 결정된다. 3 이런 해석에 따르면 bind 연산자 (>>=)는 세미콜론의 함수 버전일 뿐이다. let 표현식을 함수 적용처럼 작성할 수 있듯이 let x = foo in x + 3는 다음에 대응된다 (\x -> x + 3) foo 할당과 세미콜론은 bind 연산자로 재작성할 수 있다. x <- foo; return (x + 3)는 다음에 대응된다 foo >>= (\x -> return (x + 3)) return 함수는 값 a를 M a로 전이시킨다. M a는 모나드 M에 대응하는 명령형 언어의 명령문과 같다. 명령형 언어의 여러 의미(semantic)는 각기 다른 모나드에 대응한다. 다음 표는 모든 하스 켈 프로그래머가 반드시 알아야 하는 고전적인 사항을 선별한 표다. 모나드에 깔린 발상이 아직도 명확하지 않다면, 뒤에 이어지는 장들의 예제를 공부하면서 좋은 도구상자도 얻고 여러 모나드 뒤에 숨은 공통된 추상화를 이해하는 데 도움을 받을 수 있을 것이다. 모나드 명령형 언어에서의 의미 semantic 위키 책 과목 Maybe 예외(익명) 모나드 이해하기/Maybe Error 예외(오류 내용이 있음) 모나드 이해하기/Error State 전역 상태 global state 모나드 이해하기/State IO 입출력 모나드 이해하기/IO [](리스트) 비결정성 모나드 이해하기/List Reader 환경설정 Environment 모나드 이해하기/Reader Writer 로 거 Logger 모나드 이해하기/Writer 더욱이, 서로 다른 이들 의미 semantic는 꼭 따로 써야 하는 것이 아니다. 몇몇 장에서 보겠지만 모나드 변환기 monad transformer를 사용해서 모나드들을 합성하고, 일치시키거나 여러 모나드의 semantic을 단일 모나드로 합성하는 것이 가능하다. 모나드의 법칙 하스켈에서 Monad 타입 클래스의 모든 인스턴스는(그리고 (>>=)와 return의 모든 구현은) 다음의 세 법칙을 만족해야 한다. m >>= return = m -- 우단 위원의 법칙(right unit) return x >>= f = f x -- 좌 단위원의 법칙(left unit) (m >>= f) >>= g = m >>= (\x -> f x >>= g) -- 결합법칙(associativity) 중립 원 neutral element으로서의 return return의 동작은 좌 단위원(left unit)의 법칙과 우단 위원(right unit)의 법칙에 의해 기술된다. 이 법칙들은 return이 아무 계산도 하지 않음을 뜻한다. return은 그저 값을 보관한다. 예를 들어 다음 코드는 maternalGrandfather p = do mom <- mother p gf <- father mom return gf 우단 위원의 법칙에 의해 다음과 정확히 같다. maternalGrandfather p = do mom <- mother p father mom bind의 결합법칙 결합법칙은 세미콜론이 그러듯이 bind 연산자 (>>=)가 계산의 순서만 신경 쓸 뿐 그 중첩 구조는 고려하지 않음을 보장한다. 예를 들어 bothGrandfathers를 이렇게 작성할 수도 있다. do를 쓰지 않은 이전 버전과 비교해 보라. bothGrandfathers p = (father p >>= father) >>= (\gf1 -> (mother p >>= father) >>= (\gf2 -> return (gf1, gf2) )) then 연산자의 결합 법칙은 특수한 경우다. (m >> n) >> o = m >> (n >> o) 모나 딕 합성 bind의 결합 법칙을 이렇게 재구성하면 그 의미를 포착하기가 더 쉽다. (f >=> g) >=> h = f >=> (g >=> h) 여기서 (>=>)는 모나 딕 합성 연산자로서 함수 합성 연산자 (.)와 아주 유사하지만 그 인자는 반대로다. (>=>)는 다음과 같이 정의된다. (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c f >=> g = \x -> f x >>= g (>=>)을 뒤집은 (<=<)도 있다. 이걸 쓸 때는 합성 순서가 (.)와 일치하며, 따라서 (f <=< g)에서는 g가 먼저 온다. 4 모나드와 범주론 모나드는 범주론이라는 수학의 한 갈래에서 유래했다. 다행히도 하스켈에서 모나드를 이해하고 활용하기 위해 범주론을 이해할 필요는 전혀 없다. 범주론의 모나드 정의는 사실 표현법이 조금 다르다. 이 표현법을 하스 켈 식으로 다듬으면 동등하지만 또 다른 모나드 정의를 얻는다. 이로부터 Monad 클래스에 대한 또 다른 통찰을 얻을 수 있다. 5 지금까지는 (>>=)와 return을 통해 모나드를 정의했다. 또 다른 정의에서는 모나드를 두 결합기를 가지는 functor로 취급한다. fmap :: (a -> b) -> M a -> M b -- functor return :: a -> M a join :: M (M a) -> M a Functor 클래스에 관한 장에서 논의했듯이 펑터를 컨테이너에 비유할 수 있다. 이에 따르면 functor M은 일종의 컨테이너로서 M a는 a 타입의 값을 "보관" 하고, 대응하는 매핑 함수 fmap은 그 내부의 값에 함수들을 적용할 수 있도록 한다. 이렇게 해석하면 위 함수들은 다음과 같이 작동한다. fmap은 주어진 함수를 컨테이너 내부의 모든 원소에 적용한다 return은 원소를 컨테이너로 감싼다 join은 컨테이너의 컨테이너를 취해 단일 컨테이너로 평탄화한다. 이 함수들을 이용해 bind 연산자를 다음과 같이 정의할 수 있다. m >>= g = join (fmap g m) 비슷하게 (>>=)와 return을 이용해 fmap과 join을 정의할 수 있다. fmap f x = x >>= (return . f) join x = x >>= id liftM과 그 친구들 앞서 모든 Monad는 Applicative이고 따라서 Functor라는 것을 짚고 넘어갔었다. 그 결과 return과 (>>)는 각각 pure와 (*>)의 모나드 전용 버전이 되었다. 그런데 여기서 끝이 아니다. Control.Monad는 liftM을 정의하는데 그 타입 시그너쳐가 왠지 익숙하다. liftM :: (Monad m) => (a1 -> r) -> m a1 -> m r 의심했던 대로 liftM은 우리가 바로 앞 절에서 한 것처럼 (>>=)와 return을 통해 구현한 fmap 일뿐이다. 따라서 liftM과 fmap은 서로 바꿔 쓸 수 있다. ap는 Control.Monad에 있는 또 다른 함수로서 묘한 타입을 가진다. ap :: Monad m => m (a -> b) -> m a -> m b 다른 경우와 비슷하게 ap는 (<*>)의 모나드 전용 버전이다. Control.Monad를 비롯해 기본 라이브러리 모듈에는 Monad에 특화된 버전의 Applicative 함수들이 곳곳에 있다. 이런 함수들이 존재하는 데는 역사적인 이유가 있다. 하스켈에 Monad와 Applicative가 도입되는 사이에는 몇 년의 간격이 있었고 Applicative가 Monad의 슈퍼클래스가 되기까지는 더 오랜 시간이 걸렸기에 특화된 버전을 사용하는 것은 선택사항이 되었다. 이제 와서는 모나드 전용 버전을 사용할 이유가 거의 없어져서, 다른 사람들의 코드를 보면 return과 (>>)만 보일 것이다. 이것들의 용법은 하스켈에서 20년이 넘도록 Applicative가 Monad의 슈퍼클래스가 아니었던 덕에 잘 자리 잡게 되었다. 노트 Applicative가 Monad의 슈퍼클래스이므로 Monad를 구현하는 가장 명료한 방법은 Functor 인스턴스를 작성하고 클래스 계층도를 따라 내려가는 것이다. instance Functor Foo where fmap = -- etc. instance Applicative Foo where pure = -- etc. (<*>) = -- etc. instance Monad Foo where (>>=) = -- etc. 앞으로 이어질 챕터들에서 여러분은 Monad의 인스턴스들을 작성하고 사용해 보거나, 이 책의 예제들을 실행해 보거나, 여러분이 생각하는 다른 실험을 해볼 것이다. 하지만 위에서 보여준 방식으로 인스턴스를 작성하려면 pure와 (<*>)를 구현해야 하는데, 이 책의 이 시점에서는 Applicative 법칙들을 아직 다루지 않았기 때문에 이는 쉬운 일이 아니다. (적용성 펑 터 장에 가서야 다룬다) 다행히 돌아가는 길이 있다. (>>=)와 return을 구현하여 그 자체로 충분한 Monad 인스턴스를 만들고 나면 liftM, ap, return을 사용해 다른 인스턴스들을 채워 넣을 수 있다. instance Monad Foo where return = -- etc. (>>=) = -- etc. instance Applicative Foo where pure = return (<*>) = ap instance Functor Foo where fmap = liftM 모나드에 대한 이 일련의 챕터들에 나오는 예제와 연습문제에서는 Applicative 인스턴스를 작성할 것을 요구하지 않는다. 따라서 Applicative를 자세히 논의하기 전까지는 이 우회책을 쓸 수 있다. 이 return 함수는 C나 자바 같은 명령형 언어의 return 키워드와 아무 관련이 없다. 둘을 헷갈리지 말 것. ↩ 이 중요한 상하관계는 역사적 우연 덕에 최근에 와서야 (2015년 초기 GHC 7.10 버전) 구현되었다. 이보다 오래된 GHC 버전을 쓰고 있다면 이런 클래스 제약이 존재하지 않으므로 우리가 앞으로 고려할 실용적 관점들 중 일부는 해당사항이 없을 것이다. ↩ "의미 semantic"라 함은 언어가 여러분에게 말하기를 허락한 것이다. Maybe의 의미는 우리가 실패를 표현하는 것을 허락하여, 명령문이 결과를 내는 데 실패하면 뒤에 따라오는 명령문은 건너뛰게 만든다. ↩ 물론 정규 함수 합성에 쓰이는 함수들은 모나 딕 함수가 아닌 반면, 모나 딕 합성은 모나 딕 함수만을 취한다. ↩ 고급반의 범주론에서 이론적인 측면을 다룰 것이다. ↩ 1 Maybe 원문: http://en.wikibooks.org/wiki/Haskell/Understanding_monads/Maybe 안전한 함수 참조표 공개된 모나드 Maybe와 안전성 Maybe를 예제로 삼아 모나드를 소개했었다. Maybe 모나드는 값을 반환하지 않음으로써 "잘못될 수 있는" 계산(computation)을 표현한다. 참고를 위해 여기 앞의 장에서 봤던 Maybe 용 return과 (>>=)의 정의가 있다.1 return :: a -> Maybe a return x = Just x (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b (>>=) m g = case m of Nothing -> Nothing Just x -> g x 안전한 함수 Maybe 데이터 타입은 다양한 인자 때문에 실패할 수 있는 함수들을 감싸는 안전한 래퍼 wrapper를 만드는 수단을 제공한다. 예를 들어 head와 tail은 비어있지 않은 리스트에만 작동한다. 또 다른 전형적인 예는 이 절에서 볼 것인데, sqrt나 log 같은 수학 함수다. 실수의 범위에서 고려할 때, 이들 함수는 음이 아닌 인자에 대해서만 정의된다. > log 1000 6.907755278982137 > log -1000 ''ERROR'' -- runtime error 이런 문제를 피하는 방법으로, log의 "안전한" 구현은 다음과 같다. safeLog :: (Floating a, Ord a) => a -> Maybe a safeLog x | x >= 0 = Just (log x) | otherwise = Nothing > safeLog 1000 Just 6.907755278982137 > safeLog -1000 Nothing 나누기, 제곱근, 역삼각함수같이 정의역이 제한된 모든 함수에 대해 비슷한 "안전한 함수"들을 작성할 수 있다. safeDiv, safeSqrt, safeArcSin 등 safeLog와 타입이 같지만 그 정의는 각각의 정의역 제한에 따라 다르다. 이 모나 딕 함수들을 결합하고자 한다면 가장 깔끔한 접근법은, 이전 장의 거의 끝부분에서 짧게 언급했던 모나 딕 합성과 인자 생략 스타일이다. safeLogSqrt = safeLog <=< safeSqrt 이렇게 작성하고 보니 safeLogSqrt는 안전하지 않고 모나딕이 아닌 버전과 비슷하다. unsafeLogSqrt = log . sqrt 참조표 참조표는 키와 값을 연관 짓는다. 값을 검색하려면 그 값의 키를 알아내어 참조표를 이용해 검색한다. 예를 들어 전화번호에 대응하는 키가 연락처인 참조표가 들어있는 전화번호부 애플리케이션을 상상해 보자. 하스켈에서 참조표를 구현하는 기초적인 방법은 짝의 리스트 [(a, b)]를 사용하는 것이다. a는 키의 타입이고 b는 값의 타입이다. 2 전화번호부 참조표는 이런 식이다. phonebook :: [(String, String)] phonebook = [ ("Bob", "01788 665242"), ("Fred", "01624 556442"), ("Alice", "01889 985333"), ("Jane", "01732 187565") ] 참조표를 가지고 하는 가장 흔한 일이 값을 찾는 것이다. 전화번호부에서 "Bob", "Fred", "Alice", "Jane"을 찾으려 할 때는 아무 문제가 없다. 하지만 "Zoe"를 찾아본다면? Zoe는 전화번호부에 없기 때문에 검색은 실패한다. 그러므로 표에서 값을 찾는 하스 켈 함수는 Maybe 계산이다. 이 함수는 Prelude에 들어있다. lookup :: Eq a => a -- 키 -> [(a, b)] -- 사용할 참조표 -> Maybe b -- 검색 결과 lookup의 결과를 몇 개 보자. Prelude> lookup "Bob" phonebook Just "01788 665242" Prelude> lookup "Jane" phonebook Just "01732 187565" Prelude> lookup "Zoe" phonebook Nothing 이제 모나 딕 인터페이스의 모든 능력을 이끌어내 이것을 확장해 보자. 지금 정부를 위해 일하고 있고 관계자들의 전화번호를 가지고 있는데, 거대한 정부 규모의 참조표에서 이 전화번호들을 찾아 관계자들의 자동차 등록번호를 알아내려 한다고 치자. 이것 역시 또 다른 Maybe-계산이다. 하지만 우리가 찾는 사람이 전화번호부에 없으면 정부 데이터베이스에서 그들의 등록번호를 찾을 수 없을 것이다. 우리에게 필요한 것은 첫 번째 계산의 결과를 취해 두 번째 검색에 넣는데, 오직 첫 번째 검색에서 값을 성공적으로 얻었을 때만 그렇게 하는 함수다. 물론 두 검색 중 하나라도 Nothing을 돌려주면 최종 결과는 Nothing이어야 한다. getRegistrationNumber :: String -- 이름 -> Maybe String -- 등록번호 getRegistrationNumber name = lookup name phonebook >>= (\number -> lookup number governmentDatabase) 정부 데이터베이스를 검색해서 얻은 이 결과를 이어서 세 번째 검색에 사용하려 한다면(관계자들의 자동차세에 부채가 있는지 확인하려고 등록번호를 검색한다던가 하는 이유로), getRegistrationNumber 함수를 확장할 수 있다. getTaxOwed :: String -- 이름 -> Maybe Double -- 지불할 세금의 양 getTaxOwed name = lookup name phonebook >>= (\number -> lookup number governmentDatabase) >>= (\registration -> lookup registration taxDatabase) 또는 do 블록을 쓰면 getTaxOwed name = do number <- lookup name phonebook registration <- lookup number governmentDatabase lookup registration taxDatabase 여기서 멈춰 서고, 어디에서든 Nothing을 받게 될 때 어떤 일이 일어날지 생각해 보자. 그 정의에 따라, >>=의 첫 인자가 Nothing 이면 >>=는 무슨 함수를 받든 Nothing을 반환한다. 따라서 큰 계산의 어느 단계에서든 Nothing이 있으면 다른 함수야 어떻든 간에 전체가 Nothing으로 끝난다. 첫 번째 Nothing을 만난 뒤의 모든 >>=는 그 Nothing을 서로에게 전달만 하며 다른 인자는 무시한다. 기술적으로 말하자면 Maybe 모나드의 구조는 실패를 확산시킨다. 공개된 모나드 Maybe 모나드의 또 다른 특징은 "공개되어 있다"라는 것이다. 우리는 Just 값의 내용을 들여다보고 패턴 매칭을 통해 연관된 값을 추출할 수 있다. zeroAsDefault :: Maybe Int -> Int zeroAsDefault mx = case mx of Nothing -> 0 Just x -> x Nothing을 기본값으로 치환하는 이런 사용법은 Data.Maybe의 fromMaybe 함수에서 볼 수 있다. zeroAsDefault :: Maybe Int -> Int zeroAsDefault mx = fromMaybe 0 mx Prelude 함수 maybe는 추출한 값을 수정하는 함수를 전달해 이 일을 보다 일반화된 방법으로 할 수 있다. displayResult :: Maybe Int -> String displayResult mx = maybe "There was no result" (("The result was " ++) . show) mx 이런 게 가능하다는 것이 Maybe의 경우에는 타당하다. 실패를 만회하는 것이 가능해지기 때문이다. 모든 모나드가 이런 식으로 공개된 것은 아니다. 때로 모나드는 불필요한 세부사항을 감추도록 설계된다. return과 (>>=)만으로는 모나 딕 연산으로부터 내부의 값을 추출할 수 없다. 그리고 "출구 없는" 모나드, 즉 값을 추출하는 것이 불가능한 모나드도 말이 안 되는 것은 아니다. 그 대표적인 예가 IO 모나드다. Maybe와 안전성 Maybe가 제공하는, 런타임 오류를 일으키지 않고 실패를 처리하는 우아한 수단을 통해 어떻게 코드를 더 안전하게 만드는지 봤다. 그럼 모든 곳에 Maybe를 사용해야 할까? 글쎄다. 함수를 작성할 때, 여러분은 프로그램이 정상적인 작업 3을 하는 도중 그 함수가 결과를 내는 데 실패할 수도 있다고 표현할 수 있다. 그 이유가 여러분이 사용하는 함수가 실패할 수도 있어서 든(위 예제처럼), 또는 인자나 중간 결괏값이 말이 안 된다는 걸 알고 있어서 든(인자가 10 미만일 때만 의미 있는 계산이라던가), 그런 경우에는 실패를 잡기 위해 꼭 Maybe를 사용하라. 임의의 기본값을 반환하거나 오류를 던지는 것보다는 훨씬 낫다. 하지만 이유 없이 결괏값의 타입에 Maybe를 붙여봐야 코드를 어지르고 위험하게 만들 뿐이다. 불필요한 Maybe가 있는 함수의 타입 시그너쳐는 코드의 사용자에게 실패할 일도 없는데 그럴 수도 있다고 말하는 셈이다. 물론 그 반대인 실패할 수도 있는데 실패하지 않는다고 거짓말하는 것보다는 낫지만, 우리는 어떤 경우에든 바람직한 코드를 원하지 않는가. 게다가 Maybe를 쓰면 실패를 확산하도록 강요받고(fmap 또는 모나 딕 코드를 통해), 결국 실패하는 경우를 패턴 매칭, maybe 함수, Data.Maybe의 fromMaybe를 통해 처리해야 한다. 함수가 실패할 일이 없다면 실패에 대한 코딩은 상황을 복잡하게 만들 뿐이다. Data.Maybe의 실제 인스턴스는 조금 다르게 정의되어 있지만 이것과 완벽히 동치다. ↩ 하스 켈 실전에서 map에 대한 과목을 확인해 보면 조금 다르고 더 유용할 수도 있는 구현이 있다. ↩ "정상적인 작업"이라 함은 실세계에서 통제 불가능한 상황에 의해 발생하는 실패를 제외한 것이다. 메모리 부족이나 개가 프린터 케이블을 물어뜯는 것이 그런 경우다. ↩ 2 List 원문: http://en.wikibooks.org/wiki/Haskell/Understanding_monads/List 모나드로서 인스턴스화된 리스트 토끼의 침공 보드 게임 예제 리스트 조건 제시식(List comprehensions) 리스트는 하스켈의 근본을 이루는 일부다. 그리고 우리는 여기까지 오면서 리스트를 광범위하게 사용했다. 중요한 통찰은 리스트 타입 역시 모나드라는 것이다! 모나드로서의 리스트는 임의 개수의 결과를 반환하는 비결정적 연산을 모델링 한다. Maybe가 값을 반환하지 않거나 하나의 값만을 반환하는 계산을 표현하는 방법에는 확실한 병렬성이 있었는데, 리스트의 경우에는 0개, 1개, 더 많은 값을 반환할 수 있다. 값의 개수는 리스트의 길이에 반영된다. 모나드로서 인스턴스화된 리스트 리스트를 위한 return 함수는 단순히 값을 리스트 안에 삽입한다. return x = [x] 달리 말하자면, return은 원소 하나 즉 인자를 포함하는 리스트를 만든다. 리스트 return의 타입은 return :: a -> [a] 또는 동치인 것으로 return :: a -> [] a다. 후자처럼 작성하면 return의 시그너쳐에서 제너릭 타입 생성자(모나드 이해하기에서 M이라고 한 것)를 리스트 타입 생성자 [](빈 리스트와 별개의 것이지만 헷갈리기 쉽다)로 대체했다는 것이 명확해진다. 바인딩 연산자는 썩 자명하지 않다. 리스트의 경우에 타입이 어떻게 되는지부터 살펴보자. [a] -> (a -> [b]) -> [b] 예상했던 대로다. 리스트에서 값을 빼내 한 함수에 전달하고 새로운 리스트를 반환한다. 실제로 일어나는 일은 이렇다. 먼저 주어진 리스트에 주어진 함수를 매핑해 [[b]] 타입인 리스트의 리스트를 얻는다. (물론 여러분이 매핑에 쓰는 많은 함수는 리스트를 반환하지 않지만, 위의 타입 시그너쳐에서 보듯이 리스트에 대한 모나 딕 바인딩은 리스트를 반환하는 함수에 대해서만 작동한다) 일반적인 리스트를 얻으려면 리스트의 리스트 안의 원소들을 연결해 [b] 타입의 최종 결과를 얻는다. 따라서 (>>=)의 리스트 버전을 작성할 수 있다. xs >>= f = concat (map f xs) bind 연산자는 여러 종류의 모나드가 각기 어떤 일을 하는지 이해하기 위한 핵심이고, bind 연산자의 정의를 통해 그 모나드의 사용법을 추론할 수 있다. 리스트 모나드가 비결정성을 나타낸다고 말하는 이유는, 서로 다른 함수들을 리스트에 매핑하면 임의 개수의 서로 다른 결과들을 반환하기 때문이다. 토끼의 침공 우리에게 익숙한 리스트 처리 함수들을 모나 딕 코드와 통합하는 것은 쉬운 일이다. 이런 예시를 생각해 보자. 토끼는 새끼를 밸 때마다 평균 여섯 마리의 자식을 낳는데 그중 반절은 암컷이다. 우리는 엄마 토끼 한 마리로 시작할 때 이어지는 각 세대에서의 암컷의 개수를 모델링 할 수 있다. 즉 토끼들이 성장하고 각자 새끼를 밴 후의 새로운 새끼의 수를 말한다. Prelude> let generation = replicate 3 Prelude> ["bunny"] >>= generation ["bunny","bunny","bunny"] Prelude> ["bunny"] >>= generation >>= generation ["bunny","bunny","bunny","bunny","bunny","bunny","bunny","bunny","bunny"] 이 어처구니없는 예제에서는 모든 원소가 동일하지만 같은 논리로 방사성 붕괴나 화학 반응, 그리고 단일체에서 시작해 일련의 원소들을 생산하는 어떤 현상도 모델링 할 수 있다. 보드 게임 예제 턴 기반 게임을 모델링하고 있고 게임이 진행될 수 있는 모든 가능한 경우를 찾으려 한다. 우리에겐 현재 보드 상태가 주어졌을 때, 다음 턴에서의 선택지들을 담은 리스트를 계산하는 함수가 필요하다. nextConfigs :: Board -> [Board] nextConfigs bd = undefined -- 자잘한 것은 중요치 않다 두 턴이 지난 뒤의 모든 가능성을 찾아내려면, 보드 상태의 새로운 리스트에 들어있는 각 원소에 함수를 한 번씩 더 적용한다. nextConfigs는 보드 상태를 취해서 새로운 가능 상태들의 리스트를 반환한다. 따라서 모나 딕 바인딩을 사용하여 리스트의 각 원소에 함수를 매핑할 수 있다. nextConfigs bd >>= nextConfigs 같은 방법으로 결과를 다시 함수에 넘겨 다음 턴의 가능성들을 생성할 수 있다. 게임 규칙에 따라서는 가능한 다음 턴이 없는 보드 상태에 다다를 수 있다. 그런 경우 이 함수는 빈 리스트를 반환할 것이다. 1 부수적인 언급을 하자면 모나드 이해하기의 할아버지 예제에서 했던 것처럼 여러 턴을 do 블록으로 변환할 수 있다. threeTurns :: Board -> [Board] threeTurns bd = do bd1 <- nextConfigs bd -- bd1은 1턴 후의 보드 구성을 참조한다 bd2 <- nextConfigs bd1 nextConfigs bd2 위의 코드가 마법처럼 보인다면 do 표기는 (>>=) 연산의 편의 문법이라는 것을 명심하라. <-의 오른쪽에는 리스트로 평가될 함수가 인자와 함께 위치한다. 왼쪽의 변수는 리스트 원소들을 나타낸다. 이 <- 할당 줄 이후에는 그 할당된 변수를 어떤 함수 인자로 쓰는 코드가 올 수 있다. 그 함수는 <-가 있는 줄의 함수에서 건너온 리스트 내의 원소들 각각에 대해 실행된다. 이런 원소별 처리는 (>>=) 정의의 map에 해당한다. 그 결과인 리스트의 리스트(각각의 리스트는 원래 리스트의 각각의 원소에 대응)는 단일 리스트로 평탄화된다. ((>>=) 정의의 concat) 리스트 조건 제시식(List comprehensions) 리스트 모나드는 리스트 조건 제시식과 놀랍도록 비슷하게 작동한다. 방금 threeTurns를 작성할 때 쓴 do 블록을 조금 수정해서 return으로 끝내보자. threeTurns bd = do bd1 <- nextConfigs bd bd2 <- nextConfigs bd1 bd3 <- nextConfigs bd2 return bd3 이것은 다음의 리스트 조건 제시식을 정확히 반영한다. threeTurns bd = [ bd3 | bd1 <- nextConfigs bd, bd2 <- nextConfigs bd1, bd3 <- nextConfigs bd2 ] (리스트 조건 제시식에서, 한 리스트에서 뽑은 원소들로 그다음 원소들을 정의하는 것은 전혀 문제 될 게 없다) 둘이 비슷한 것은 우연의 일치가 아니다. 리스트 조건 제시식은 concatMap을 이용해 정의되며 concatMap f xs = concat (map f xs))이다. 이것 역시 리스트 모나드 바인딩이다! 리스트 모나드의 본질을 정리하자면, 리스트 모나드를 위한 바인딩은 결합과 매핑의 조합이며 합성 함수인 concatMap은 리스트에 대한 >>=와 같다. (문법상 순서만 다르다) 리스트 모나드와 리스트 조건 제시식의 대응 관계를 완벽히 하려면 리스트 조건 제시식이 수행하는 걸러내기를 재현할 수단이 필요하다. 어떻게 그럴 수 있는지는 가산적 모나드 장에서 설명할 것이다. 선택 사항, 고급 연습문제: 유한 개의 가능성을 가진 게임의 모든 가능한 결과를 찾기 위한 재귀 바인딩을 연구해 보라. 더 나아가서 빈 리스트에 도달했을 때도 그전의 최종적인 가능한 보드 상태들을 유지하는 방법을 고려해 보라. ↩ 3 do 표기 원문: http://en.wikibooks.org/wiki/Haskell/do_Notation then 연산자 번역하기 bind 연산자 번역하기 fail 메서드 예제: 사용자 반응형 프로그램 값 반환하기 편의 문법일 뿐 노트 간단한 입출력 장에서 모나드 문법의 대안으로 do 블록을 사용하는 것을 처음 소개했었다. 그때는 입출력 연산들을 연이어 하기 위해 do를 사용했지만 모나드는 소개하지 않았었다. 이제 IO가 또 하나의 모나드라는 것을 확인해 보자. 다음 예제들은 전부 IO가 관련되기 때문에 앞에서 그랬듯이 계산 computation과 모나 딕 값을 액션이라 칭하겠다. 물론 do는 어느 모나드에도 작동한다. do가 작동하는 방식에 대해 IO라고 특별할 것은 없다. then 연산자 번역하기 (>>) 즉 then 연산자는 do 표기에서도 일반 문법에서도 거의 동일하게 작동한다. 다음과 같은 액션의 연쇄를 고려해 보자. putStr "Hello" >> putStr " " >> putStr "world!" >> putStr "\n" do 표기를 이용해 다시 작성할 수 있다. do putStr "Hello" putStr " " putStr "world!" putStr "\n" 이 일련의 명령은 마치 명령형 언어의 것처럼 보인다. 하스켈에서는 액션들이 같은 모나드 안에 있는 한 연쇄하는 것이 가능하다. IO 모나드의 문맥에서 우리는 파일에 쓰기, 네트워크 연결 열기, 사용자에게 입력 요청하기 등의 액션을 수행한다. 이것은 do 표기를 편의 문법을 쓰지 않은 하스 켈 코드로 한 단계식 번역한 것이다. do action1 action2 action3 이다음은 action1 >> do action2 action3 그렇게 do 블록이 빌 때까지 계속된다. bind 연산자 번역하기 (>>=)는 do 표기로 옮기기가 조금 어렵다. (>>=)는 하나의 값, 즉 액션 또는 함수의 결과를 일련의 바인딩의 아래쪽으로 전달한다. do 표기는 전달된 값에 <-를 이용해 변수 이름을 할당한다. do x1 <- action1 x2 <- action2 action3 x1 x2 x1과 x2는 action1과 action2의 결과값이다. 만약 action1이 IO Integer라면 x1은 Integer에 바인딩 된다. x1과 x2에 저장된 값들은 action3에 인수로 전달되고, action3는 세 번째 액션을 반환한다. 이 do 블록은 다음의 실제 하스 켈 코드와 많은 부분에서 동등하다. action1 >>= \ x1 -> action2 >>= \ x2 -> action3 x1 x2 (>>=)의 두 번째 인자는 함수로서, 첫 번째 인자로 전달된 액션의 결과를 가지고 무엇을 할지를 기술한다. 람다의 연쇄는 그 결과들을 아래쪽으로 전달한다. 괄호를 추가로 쓰지 않아도 람다가 표현식의 끝까지 확장된다는 것을 숙지할 것. action3를 호출하는 시점에도 x1은 스코프 내에 있다. 줄바꿈과 들여 쓰기를 이용해서 람다 연쇄를 좀 더 읽기 좋게 만들 수 있다. action1 >>= \ x1 -> action2 >>= \ x2 -> action3 x1 x2 이 코드에서는 각각의 람다 함수의 스코프를 명확하게 볼 수 있다. do 표기처럼 보이게 묶어볼 수도 있다. action1 >>= \ x1 -> action2 >>= \ x2 -> action3 x1 x2 이런 표현법의 차이는 어떤 게 보기 좋으냐의 문제일 뿐이다. 1 fail 메서드 앞서 람다를 사용한 코드가 do 블록과 "거의 동등하다"라고 말한 바 있다. 이는 정확한 번역이 아닌데 do 표기에서는 패턴 매칭 실패에 대한 특별한 처리를 하기 때문이다. <-나 ->의 왼쪽에 위치한 x1과 x2는 패턴 매칭의 대상이다. 그래서 action1이 Maybe Integer를 반환한다면 do 블록을 이렇게 작성할 수 있다. do Just x1 <- action1 x2 <- action2 action3 x1 x2 그리고 x1은 Integer 값이 된다. 그런데 action1이 Nothing을 반환한다면? 보통은 프로그램이 non-exhaustive patterns(일치하는 패턴 없음) 오류를 일으키며 고장 날 것이다. 이 오류는 빈 리스트에 대해 head를 호출할 때 일어나는 그런 오류다. 하지만 do 표기에서는 관련된 모나드의 fail 메서드가 실패를 처리한다. 위의 do 블록은 다음과 같이 번역된다. action1 >>= f where f (Just x1) = do x2 <- action2 action3 x1 x2 f _ = fail "..." -- 컴파일러가 생성한 메시지 fail이 실제로 하는 일은 모나드 인스턴스마다 다르다. 보통은 패턴 매칭 오류를 다시 던지지만 나름대로 실패를 처리하는 모나드도 있다. 가령 Maybe의 fail은 fail _ = Nothing이고, 비슷하게 리스트 모나드의 경우 fail _ = []이다. 2 fail 메서드는 do 표기의 장치 arfifact다. 여러분이 사용하는 모나드를 위해 fail이 뭔가 합리적인 대처를 해줄 거라 확신할 수 있으면, fail을 직접 호출하는 대신 자동으로 수행되는 패턴 매칭 실패 처리를 믿어야 한다. 예제: 사용자 반응형 프로그램 잠깐 우리는 사용자와 상호작용하기 위해 putStr과 getLine을 번갈아 쓸 것이다. 출력에 예상치 못한 결과를 피하기 위해 System.IO를 들여올 때 출력 버퍼링 output buffering을 꺼야 한다. 그러려면 코드의 첫 줄에 hSetBuffering stdout NoBuffering을 입력하라. 다른 방식으로 하려면 사용자와 상호작용할 때마다(즉 getLine을 쓸 때마다) 그에 앞서 hFlush stdout으로 출력 버퍼를 명시적으로 씻어낼 flush 수 있다. ghci에서 이 코드를 시험하고 있다면 그런 문제가 일어나지 않는다. 사용자에게 성과 이름을 질문하는 다음의 간단한 프로그램을 살펴보자. nameDo :: IO () nameDo = do putStr "What is your first name? " first <- getLine putStr "And your last name? " last <- getLine let full = first ++ " " ++ last putStrLn ("Pleased to meet you, " ++ full ++ "!") 이를 실제 모나 딕 코드로 변환할 수 있다. nameLambda :: IO () nameLambda = putStr "What is your first name? " >> getLine >>= \ first -> putStr "And your last name? " >> getLine >>= \ last -> let full = first ++ " " ++ last in putStrLn ("Pleased to meet you, " ++ full ++ "!") 이처럼 단지 여러 액션을 연쇄하려는 경우, do 표기의 명령형 스타일이 자연스럽고 편하게 느껴진다. 한편 bind와 람다를 명시한 모나 딕 코드는 처음엔 별로지만 자꾸 접하다 보니 괜찮다. 첫 번째 예제에서 do 블록 안에 let 문이 있는 것에 주목하라. 이 let 다음에 오는 줄이, 편의 문법을 쓰지 않은 두 번째 버전에서는 in에 따라붙어, 정규 let 표현식이 된다. 값 반환하기 do 표기의 마지막 명령문은 do 블록의 최종 결과다. 앞의 예제에서 결괏값의 타입은 IO (), 즉 IO 모나드 상에서 비어있는 값이었다. 이 예제를 수정해서, 획득한 이름을 나타내는 IO String을 반환하도록 해보자. 우리가 해야 하는 것은 return을 추가하는 것뿐이다. nameReturn :: IO String nameReturn = do putStr "What is your first name? " first <- getLine putStr "And your last name? " last <- getLine let full = first ++ " " ++ last putStrLn ("Pleased to meet you, " ++ full ++ "!") return full 이 예제는 IO 모나드 내의 문자열로 표현되는 성명을 "반환"할 것이고, 이다음부터는 이 이름을 활용할 수 있다. greetAndSeeYou :: IO () greetAndSeeYou = do name <- nameReturn putStrLn ("See you, " ++ name ++ "!") nameReturn이 실행되면 반환된 결괏값(nameReturn 함수 안에선 "full"이었던 것)이 greetAndSeeYou 함수 안의 "name" 변수에 할당될 것이다. nameReturn에서 인사말 부분은 화면에 출력되는데 이 역시 계산 과정의 일부이기 때문이다. 그러면 "see you" 메시지가 추가로 출력될 것이고 마지막으로 반환되는 값은 IO ()다. C 같은 명령형 언어를 알고 있다면 하스켈의 return이 C의 return과 일치한다고 생각할지도 모르겠다. 예제를 조금 변형하면 그런 생각이 사라질 것이다. nameReturnAndCarryOn = do putStr "What is your first name? " first <- getLine putStr "And your last name? " last <- getLine let full = first++" "++last putStrLn ("Pleased to meet you, "++full++"!") return full putStrLn "I am not finished yet!" 마지막 줄의 문자열은 출력되는데, return은 흐름을 끝내는 명령문이 아니기 때문이다. (C나 다른 언어에서는 그랬을 것이다) 그리고 nameReturnAndCarryOn의 타입은 IO ()다. 함수를 호출한 후에는 return full에 의해 생성된 IO String이 흔적도 없이 사라진다. 편의 문법일 뿐 문법상의 편의인 do 표기는 근본적으로 새로운 개념을 아무것도 도입하지 않지만, 그 명료함과 멋 때문에 애용된다. 하지만 do는 단일 액션에는 절대 쓰이지 않는다. 하스켈식 "Hello World"는 단지 main = putStrLn "Hello world!" 이며 다음과 같은 코드는 전혀 불필요하다. fooRedundant = do x <- bar return x 모나드의 법칙 덕에 이렇게 간단히 작성할 수 있고, 이렇게 해야 한다. foo = bar 함수 합성과 관련해 미묘하지만 중요한 점이 있다. 이미 알고 있듯이 바로 앞 절의 greetAndSeeYou 액션은 이렇게 고칠 수 있다. greetAndSeeYou :: IO () greetAndSeeYou = nameReturn >>= \ name -> putStrLn ("See you, " ++ name ++ "!") 람다가 좀 보기 힘들다면 어딘가에 printSeeYou 함수가 정의되어 있다고 가정하자. printSeeYou :: String -> IO () printSeeYou name = putStrLn ("See you, " ++ name ++ "!") 그러면 함수 정의에 람다도 do도 없어서 깨끗해진다. greetAndSeeYou :: IO () greetAndSeeYou = nameReturn >>= printSeeYou 혹은, 모나딕이 아닌 seeYou 함수가 있으면 seeYou :: String -> String seeYou name = "See you, " ++ name ++ "!" 이렇게 작성할 수 있다. -- Reminder: liftM f m == m >>= return . f == fmap f m greetAndSeeYou :: IO () greetAndSeeYou = liftM seeYou nameReturn >>= putStrLn 이 마지막 예시를 liftM과 함께 기억해 둘 것. 모나 딕 코드에서 비 모나 딕 함수를 사용하는 것으로 곧 돌아올 텐데, liftM이 함께할 것이다. 노트 1. ↑사실 이 경우에는 들여 쓰기가 필요하지 않다. 다음도 올바른 코드다. action1 >>= \ x1 -> action2 >>= \ x2 -> action3 x1 x2 물론 원한다면 들여 쓰기를 더 할 수도 있다. 다음은 갈 데까지 간 예시다. action1 >>= \ x1 -> action2 >>= \ x2 -> action3 x1 x2 확실히 너무했지만, 더 나빠질 수도 있다. action1 >>= \ x1 -> action2 >>= \ x2 -> action3 x1 x2 올바른 하스 켈 코드지만 도저히 읽을 수가 없다. 그러니 제발 이런 식으로 쓰지 않기를. 일관되고 의미 있게 코드를 작성할 것. 2. ↑"패턴 매칭" 장에서 지적했듯이, 이것이 리스트 조건 제시식에서의 패턴 매칭 실패가 조용히 무시되는 이유다. 4 IO 원문: http://en.wikibooks.org/wiki/Haskell/Understanding_monads/IO 입출력과 순수성 함수와 입출력 액션 결합하기 do 표기 재검토 프로그램의 일부로서의 우주 순수와 비순수 함수형과 명령형 입출력 라이브러리 모나 딕 제어 구조 노트 하스켈은 느긋한 함수형 언어다. 하지만 현실에서는 입출력 연산의 결과를 순수 함수로 표현할 수 없다. 게다가 대부분의 경우 입출력은 느긋하게 수행할 수 없다. 느긋한 computation은 값이 실제로 필요할 때가 되어서야 실행되기 때문에 두서없이 느긋한 입출력은 현실의 실행 순서 결과를 예측 불가능하게 만든다. 하스켈은 이런 문제에 IO 모나드로 대처한다. 입출력과 순수성 하스 켈 함수는 순수한 함수다. 같은 인자를 받으면 같은 결과를 반환한다. 순수 함수는 믿을 수 있고 예측 가능하다. 디버깅과 검증을 쉽게 만든다. 인자 외에는 함수의 결과에 영향을 주는 것이 없다고 확신할 수 있기 때문에 테스트 케이스를 갖추는 것도 쉽다. 프로그램 안에 완전히 포함된 하스 켈 컴파일러는 컴파일된 코드를 최적화하기 위해 함수들을 총체적으로 평가할 수 있다. 그럼 네트워크 연결 열기, 파일 작성하기, 외부에서 입력 읽어오기 등 계산된 결과를 반환하는 것 이상의 일을 하는 액션들을 어떻게 관리해야 할까? 그 핵심은 다음과 같다. 이런 액션은 함수가 아니다. IO 모나드는 액션을 하스 켈 값으로 표현하여, 순수 함수를 통해 그 값을 조작하기 위한 수단이다. 함수와 입출력 액션 결합하기 함수와 입출력을 결합하여 완전한 프로그램을 만들어보자. 사용자에게 문자열 입력을 요청한다. 그 문자열을 읽어들인다. liftM을 사용해, 문자열 전체를 대문자로 만드는 shout 함수를 적용한다. 결과 문자열을 출력한다. module Main where import Data.Char (toUpper) import Control.Monad main = putStrLn "Write your string: " >> liftM shout getLine >>= putStrLn shout = map toUpper 완전한 프로그램을 작성했지만 타입 정의는 하나도 포함시키지 않았다. 어느 부분이 함수고 어느 부분이 IO 액션이고 어디가 값인 걸까? ghci로 이 프로그램을 불러와서 타입을 확인해 보자. main :: IO () putStrLn :: String -> IO () "Write your string: " :: [Char] (>>) :: Monad m => m a -> m b -> m b liftM :: Monad m => (a1 -> r) -> m a1 -> m r shout :: [Char] -> [Char] getLine :: IO String (>>=) :: Monad m => m a -> (a -> m b) -> m b 많은 정보가 출력되었다. 전부 봤던 것이지만 다시 검토해 보자. main은 IO ()다. 함수가 아니다. 함수는 a -> b 식의 타입을 가진다. 우리의 프로그램 자체는 IO 액션이다. putStrLn은 함수다. 하지만 그 결과는 IO 액션이다. "Write your string: " 텍스트는 String 값이다. (String은 [Char]의 동의어일 뿐이다) 이 텍스트는 putStrLn의 인자로 쓰였고 putStrLn의 결과인 IO 액션에 통합되었다. 따라서 putStrLn은 함수이지만 IO 액션으로 평가된다. IO 타입의 () 부분은 이어지는 함수나 액션에 아무것도 전달할 수 없음을 지시한다. 마지막이 핵심이다. 우리는 때로 IO 액션이 뭔가를 "반환한다"라고 말하고는 한다. 하지만 이걸 곧이곧대로 받아들이면 혼란을 일으킬 수 있다. 함수가 결과를 반환한다고 말할 때는 그 뜻이 명확하다. 하지만 IO 액션은 함수가 아니다. getLine을 보자. getLine은 값을 하나 제공하는 IO 액션이다. getLine은 String 값을 반환하는 함수가 아닌데, getLine이 함수가 아니기 때문이다. 오히려 getLine은 IO 액션이며, 평가되는 시점에 한 String 값을 만들어낸다. 이 값은 이어지는 fmap, liftM, (>>=) 같은 함수들에 전달될 수 있다. getLine을 사용해 String 값을 획득할 때, 그 값은 모나 딕 값이며 그 이유는 값이 IO functor 안에 들어있기 때문이다. 이 값은 평범한(모나 딕이 아니고 functorial이 아닌) 값을 취하는 함수에 직접 전달할 수 없다. liftM은 모나 딕 값을 전달하고 반환하는 사이에 비 모나 딕 함수를 취하는 일을 한다. 이미 봤듯이 (>>=)는 비 모나 딕 함수를 취하는 함수에 모나 딕 값을 전달해 모나 딕 값을 돌려받는 일을 한다. liftM은 주어진 함수에서 비 모나 딕 결과를 취해 단지 (>>=)를 위해 모나 딕 값을 반환하고 그 안의 비 모나 딕 값을 다음 함수에 넘기는데 이런 것이 불필요하게 보일 수도 있다. 하지만 바로 이런 연쇄가 믿을 수 있는 순서를 만들어 순수 함수와 IO 액션을 통합할 때 모나드를 결정적인 요소로 만든다. do 표기 재검토 연쇄에 주목하면, do 표기는 IO 모나드와 특히 어울린다. 다음 프로그램은 putStrLn "Write your string: " >> liftM shout getLine >>= putStrLn 다음과 같이 고칠 수 있다. do putStrLn "Write your string: " string <- getLine putStrLn (shout string) 프로그램의 일부로서의 우주 IO 모나드를 보는 한 가지 관점은, IO a가 하나의 계산 computation이며 입출력을 통해 세계의 상태를 바꾸면서 a 타입의 값을 제공한다고 보는 것이다. 당연히 우리가 말 그대로 세계의 상태를 어찌할 수는 없다. IO functor는 추상적이기 때문에 세계는 여러분으로부터 감추어져 있다. (즉 IO를 파헤쳐 그 안의 값을 들여다볼 수 없다. Maybe와는 다른 상황이다.) 이렇게 보면 IO는 곧 살펴볼 State 모나드와 닮은 구석이 있다. 하지만 State의 경우에는 변경될 상태가 일반적인 하스 켈 값으로 만들어져 있어서 순수 함수를 통해 직접 조작할 수 있다. 우주를 IO를 통해 하스 켈 값에 의해 영향을 받고 또 영향을 주는 객체로 바라보는 이런 발상은 단지 비유이며 최대한 느슨하게 해석했을 뿐이다. 더 현실적인 사실은 IO가 아주 기본적인 수준의 작업을 하스 켈 언어로 들여왔다는 것이다. 1 하스켈은 하나의 추상이고, 하스 켈 프로그램은 실제로 실행되려면 기계 코드로 컴파일되어야 한다. IO의 실제 작동은 아주 저 수준의 추상에서 일어나고, 하스 켈 언어 그 자체의 정의에 밀접히 연관되어 있다.2 순수와 비순수 다음 코드를 보자. speakTo :: (String -> String) -> IO String speakTo fSentence = liftM fSentence getLine -- 용례. sayHello :: IO String sayHello = speakTo (\name -> "Hello, " ++ name ++ "!") 입출력 액션을 위한 별도의 타입이 없는 대부분의 타 프로그래밍 언어에서 speakTo의 타입은 이럴 것이다. speakTo :: (String -> String) -> String 하지만 이런 타입의 speakTo는 절대 함수가 될 수 없다! 함수는 같은 인수를 받으면 같은 결과를 생산한다. 하지만 speakTo가 돌려주는 String은 터미널 프롬프트에서 입력한 무언가에 따라 달라진다. 하스켈에서는 이런 문제를 IO String을 반환하여 해결한다. IO String 자체는 String이 아니지만, 입출력을 동반하는 명령(이 경우에는 터미널에서 입력을 한 줄 받는 입출력)을 수행함에 따라 어떤 String이 전달될 것이라는 약속이다. speakTo가 평가될 때마다 String 값은 달라질 수 있지만 입출력 명령은 항상 동일하다. 하스켈이 순수 함수형 언어라고 말할 때는 대부분의 타 언어와 달리 모든 함수가 진짜로 함수라는 것을 뜻한다. 정확히 하자면 하스 켈 표현식은 항상 참조 투명성(referential transparency)을 가진다. 즉 speakTo 같은 표현식을 그것의 값, 이 경우 \fSentence -> liftM fSentence getLine으로 치환해도 절대 프로그램의 작동을 변경하지 않는다. 반면에 getLine이 돌려주는 String 값은 불투명하다. 그 값은 명시되지 않고 프로그램이 미리 발견할 수 없다. speakTo의 타입이 위에서 언급한 그 문제 있는 타입이라면 sayHello는 String 값일 것이다. 하지만 sayHello를 어떤 특정 문자열로 치환하면 프로그램을 망가뜨린다. 하스켈이 순수 함수형 언어지만 IO 액션은 비순수하다고 말할 수 있는 이유는 IO 액션이 외부에 끼치는 영향이, (하스 켈 내부에 완전히 포함되는 정규 효과와 반대로) 부수 효과이기 때문이다. 순수성이라는 개념이 없는 프로그래밍 언어들에서는 다양한 연산에 관련된 수많은 위치에서 부수 효과가 발생한다. 반면 순수 함수형 언어는 비순수 값을 포함한 표현식조차 참조 투명성을 보장한다. 이것이 뜻하는 바는 비순수를 표현하고 추론하고 처리하는 것이 순수 함수형 방식으로 가능하다는 것이다. functor나 모나드 같은 순수 함수형 장치를 통해서 말이다. IO 액션은 비순수하지만 그 액션을 조작하는 모든 하스 켈 함수는 순수하다. 함수형의 순수함을 입출력 타입과 결합하면 하스 켈 프로그래머에게 여러모로 이익이 된다. 참조 투명성이 보장되기에 컴파일러 최적화의 여지가 많아진다. 타입만으로는 IO 값들을 분간할 수 없어서 어디가 부수 효과나 불투명한 값인지 한눈에 파악할 수 있다. IO 자체가 또 다른 functor 일뿐이기 때문에 예측 가능한 영역을 최대로 유지하고 순수 함수와 연 게되는 추론을 쉽게 만든다. 함수형과 명령형 모나드를 도입할 때 모나 딕 표현식을 명령형 언어의 명령문으로 해석할 수 있다고 말한 바 있다. 이런 해석은 IO의 경우 바로 와닿는데, IO 액션 관련 코드는 흡사 전형적인 명령형 언어처럼 보이기 때문이다. 하지만 우리가 단지 해석에 대해 이야기하고 있다는 걸 명확히 하자. 모나드나 do 표기법이 하스켈을 명령형 언어로 바꾼다는 말은 아니다. 핵심은 모나 딕 코드를 명령형 구문으로 보고 그렇게 이해할 수 있다는 것이다. 그 의미 semantic는 명령형이지만 모나드와 (>>=)의 구현은 여전히 순수 함수형이다. 짧은 예시로 이 구별을 명확히 하자. int x; scanf("%d", &x); printf("%d\n", x); 전형적인 명령형 언어인 C의 코드다. 변수 x를 선언하고, 그 값을 scanf를 이용해 사용자로부터 입력받고, printf로 그 값을 출력한다. IO do 블록 안에서 같은 일을 하는 하스 켈 코드를 퍽 비슷하게 작성할 수 있다. x <- readLn print x 의미상으로는 두 코드는 거의 동등하다. 3 하지만 C 코드에서 명령문들은 프로그램이 수행하는 명령어 instruction 들과 직접적으로 대응한다. 반면 하스 켈 코드는 편의 문법을 떼어내고 나면 readLn >>= \x -> print x 명령문이 없다. 오직 적용되는 함수들만이 있다. 프로그램의 실행 순서는 데이터 의존성을 따라 간접적으로 지시된다. 모나 딕 계산을 (>>=)로 연쇄할 때는 앞서의 결과에 함수를 적용하여 나중의 결과를 얻는다. 놀라워라. print x를 평가하면 문자열이 터미널에 출력된다. 모나드를 사용할 때 하스켈은 함수형 프로그래밍의 이점을 살리면서 명령형의 의미 semantic로 코드를 작성할 수 있도록 한다. 입출력 라이브러리 지금까지는 putStrLn과 getLine 그리고 이것들을 조금 변형한 원시적인 입출력만을 사용했다. 하지만 표준 라이브러리는 IO를 수반하는 많은 함수와 액션을 제공한다. 그중 파일 읽고 쓰기를 위한 기본적인 기능처럼 가장 중요한 것들을 하스 켈 실전의 IO 장에 포함시켰다. 모나 딕 제어 구조 모나드가 액션의 순차적 실행을 일반적인 방식으로 표현하는 것을 가능케 한다면, 루프 같은 흔한 반복 패턴도 구현할 수 있을까? 이 절에서는 바로 그런 것을 가능케 하는 표준 라이브러리의 여러 함수를 보여줄 것이다. 여기서 제시하는 예제들은 IO에 대한 것이지만 이와 관련된 발상은 모든 모나드에 적용됨을 명심하라. 모나 딕 값에 마법의 무언가는 없다. 모나 딕 값도 하스켈의 다른 값들처럼 조작할 수 있다. 이런 사실에 기초해 사용자 입력을 다섯 줄 받는 함수를 이렇게 작성한다면 어떨까? fiveGetLines = replicate 5 getLine 하지만 이 코드는 작동하지 않는다. GHCi에서 시도해 보라! 문제는 replicate가 액션의 리스트를 생산하지만 우리가 원하는 것은 리스트를 반환하는 하나의 액션(즉 [IO String]이 아닌 IO [String])이라는 것이다. 우리에겐 액션의 리스트를 방문하여 그 액션들을 실행하고 결과값들을 단일 리스트로 결합하는 fold가 필요하다. 우연히도 그런 일을 하는 sequence라는 Prelude 함수가 있다. sequence :: (Monad m) => [m a] -> m [a] 우리가 원하는 것은 다음과 같이 할 수 있다. fiveGetLines = sequence $ replicate 5 getLine replicate와 sequence는 매력적인 조합을 형성한다. 그래서 Control.Monad는 액션을 임의 횟수 반복하는 replicateM 이란 함수를 제공한다. Control.Monad는 모나 딕 zip, fold 등 비슷한 개념의 많은 편의 함수를 제공한다. fiveGetLinesAlt = replicateM 5 getLine 특히 중요한 조합은 map과 sequence다. 이 둘을 합하면 값의 리스트로부터 액션들을 만들고, 순차적으로 실행하고, 그 결과들을 수집할 수 있다. Prelude 함수 mapM은 이 패턴을 포착한 것이다. mapM :: (Monad m) => (a -> m b) -> [a] -> m [b] 위 함수들의 이름 뒤에 _를 붙인 sequence_, mapM_, replicateM_ 같은 변종들이 있다. 이것들은 최종 결과를 버리기 때문에 액션을 수행하는 것에만 관심 있을 때 적합하다. _이 없는 것과 비교해 보면 (>>)와 (>>=)의 차이와 비슷하다. 가령 mapM_의 타입은 다음과 같다. mapM_ :: (Monad m) => (a -> m b) -> [a] -> m () 마지막으로 Control.Monad는 forM과 forM_도 제공한다. 이것들은 mapM과 mapM_을 뒤집은 것이다. forM_은 명령형 언어의 for-each 루프를 하스켈에 자연스러운 방식으로 만든 것이다. 타입 시그너쳐에 그 점이 명확히 드러난다. forM_ :: (Monad m) => [a] -> (a -> m b) -> m () 연습문제 방금 소개한 모나 딕 함수들을 사용해서 임의의 값의 리스트를 출력하는 함수를 작성하라. 리스트 모나드 장의 토끼의 침공 예제를 임의 수의 세대로 일반화하라. Maybe 모나드에 대한 sequence의 동작을 예상하라. 노트 기술적 용어는 "원시형 primitive"으로, "원시 연산 primitive operation"의 그 원시다. ↩ 물론 모든 고수준 프로그래밍 언어에 대해 같은 말을 할 수 있다. 우연히도 하스켈의 IO 작업은 C 라이브러리를 호출하는 외부 기능 인터페이스(Foreign Function Interface; FFI)를 통해 실제로 확장 가능하다. C에서는 인라인 어셈블리 코드를 쓸 수 있기 때문에 하스켈은 컴퓨터가 할 수 있는 모든 것에 간접적으로 관여할 수 있는 셈이다. 이때도 하스 켈 함수는 그런 외부 작업을 IO functor 내의 값들로서 간접 조작한다. ↩ 한 가지 차이점은 C에서는 x가 수정 가능한 변수이며 따라서 한 구문에서 x를 선언하고 다음 구문에서 그 값을 설정할 수 있다는 것이다. 하스켈은 그런 변경을 절대 허용하지 않는다. C 코드를 더 유사하게 모방하려면 IORef를 사용할 수 있다. IORef는 파괴적 갱신 destructive update이 가능한 값을 포함하는 방 cell이다. 당연히 IORef는 IO 모나드 내에서만 사용할 수 있다. ↩ 5 State 원문: http://en.wikibooks.org/wiki/Haskell/Understanding_monads/State 의사 난수 하스켈에서의 구현 예제: 주사위 굴리기 IO 모나드 제거하기 IO 없는 주사위 State의 도입 newtype 상태 모나드 인스턴스화하기 State 설정하고 접근하기 값과 상태에 접근하기 주사위와 상태 여러 종류의 의사 난수 값들 노트 다른 언어로 프로그래밍을 한 적이 있다면 "상태를 유지하는" 함수를 작성해 봤을 것이다. 이 개념을 접해 본 적이 없는 사람을 위해 설명하자면, 상태는 함수의 인자는 아니지만 어떤 계산을 수행할 때 필요한 하나 이상의 변수를 칭한다. C++ 같은 객체 지향 언어는 상태 변수를 객체 안에서 멤버 변수의 형태로 광범위하게 사용한다. C 같은 절차적 언어에서는 상태를 유지하기 위해 현재 스코프의 바깥에 선언된 변수를 사용한다. 하지만 하스켈에서는 이런 기법을 그대로 적용할 수가 없다. 상태에는 변경 가능한 변수가 필요한데 이는 하스켈의 함수 순수성과 상충한다. 매개변수를 함수에서 함수로 전달하거나 여러 종류의 패턴 매칭을 이용해 상태를 유지할 수도 있지만, 더 일반적이거나 편리한 해법을 찾는 것이 알맞을 때도 있다. 그럼 State 모나드가 어떻게 도움이 되는지, 흔한 예시인 의사 난수 생성을 통해 살펴보자. 의사 난수 진짜 난수를 생성하는 것은 매우 복잡한 과제다. 컴퓨터 프로그래밍에서는 대개 의사 난수를<NAME>다. "의사 pseudo"라 불리는 이유는 진짜 무작위가 아니기 때문이다. 초기 상태(흔히 씨값seed라고 부름)에서 시작하여 의사 난수는 무작위인 것처럼 보이는 일련의 수를 생성한다. 의사 난수가 요청될 때마다 전역 상태가 갱신된다. 1 일련의 의사 난수는 초기 씨값과 알고리즘을 알고 있으면 재현 가능하다. 하스켈에서의 구현 대부분의 프로그래밍 언어에서 의사 난수를 생성하는 것은 쉬운 일이다. 보통은 C나 C++의 rand()처럼 의사 난수를 제공하는 함수 또는 구현에 따라 진짜 무작위인 함수가 있기 마련이다. 하스켈도 System.Random 모듈에 비슷한 것이 있다. > :m System.Random > :t randomIO randomIO :: Random a => IO a > randomIO -1557093684 이 함수는 하스켈의 외부에 있고 IO를 통해 상호작용할 수 있는, 변경 가능한 상태를 참조하며, 따라서 randomIO를 통해 얻은 값은 매번 달라진다. 예제: 주사위 굴리기 기회라는 개념이 필요한 게임을 하나 코딩하고 있다고 치자. 현실에선 대개 주사위를 쓴다. 그럼 하스 켈로 주사위를 던지는 함수를 만들어보자. 의사 난수의 범위를 명시하기 위해 randomR 함수를 사용하겠다. 주사위의 경우는 randomR(1, 6)이다. 굴릴 때마다 새로운 값을 얻는 것을 보장하기 위해 randomR의 IO 버전을 사용할 것이다. import Control.Monad import System.Random rollDiceIO :: IO (Int, Int) rollDiceIO = liftM2 (,) (randomRIO (1,6)) (randomRIO (1,6)) 이 함수는 주사위를 두 개 굴린다. 여기서 liftM2는 비 모나 딕 이인자 함수 (,)를 모나드에서 작동시키기 위해 사용되었다. (,)는 튜플 생성자의 비전치 버전이다. 주사위 두 개는 IO 내의 튜플로 반환된다. 연습문제 굴릴 주사위의 개수를 나타내는 정수를 받아 1에서 6 사이의 의사 정수들의 리스트를 반환하는 함수 rollNDiceIO :: Int -> IO [Int]를 작성하라. IO 모나드 제거하기 randomIO의 단점은 IO 모나드를 써서 무슨 일이 벌어질지 알 수 없는 프로그램 외부에 상태를 저장해야 한다는 것이다. IO는 외부 세계와 상호작용할 타당한 이유가 있을 때만 사용하는 것이 좋다. IO 모나드의 대안으로 로컬 생성기가 있다. System.Random 모듈에 있는 random과 mkStdGen 함수로 생성한 튜플에는 의사 난수 그리고 다음에 함수를 호출할 때 쓸 새로운 생성기가 함께 들어있다. > :m System.Random > let generator = mkStdGen 0 -- "0" is our seed > generator 1 1 > random generator :: (Int, StdGen) (2092838931,1601120196 1655838864) IO 모나드는 피했지만 새로운 문제가 생겼다. 무엇보다도 생성기로 난수를 생성한다면, 이 명백한 정의는 > let randInt = fst . random $ generator :: Int > randInt 2092838931 이것은 항상 2092838931이라는 동일한 값을 반환한다. 항상 같은 생성기를 사용하기 때문이다. 이를 해결하려면 random을 새로 호출할 때는 튜플의 두 번째 멤버 즉 새로운 생성기를 취해 전달해야 한다. > let (randInt, generator') = random generator :: (Int, StdGen) > randInt -- Same value 2092838931 > random generator' :: (Int, StdGen) -- Using new generator' returned from “random generator” (-2143208520,439883729 1872071452) 물론 이것은 난잡하고 지루하다. 새로 호출할 때마다 새 함수를 계속 만들어야 하고 생성기를 신중히 전달하느라 야단법석을 떨어야 해서 골치가 아프다. IO 없는 주사위 앞의 주사위를 다른 방법으로 던질 수 있다. > randomR (1,6) (mkStdGen 0) (6, 40014 40692) 이 튜플은 주사위 하나를 던진 결과와 새 생성기를 포함한다. 주사위 두 개 굴리기는 간단하게 구현할 수 있다. clumsyRollDice :: (Int, Int) clumsyRollDice = (n, m) where (n, g) = randomR (1,6) (mkStdGen 0) (m, _) = randomR (1,6) g 연습문제 생성기가 주어지면 첫 번째 원소가 난수고 두 번째가 최근 생성기인 튜플을 반환하는 함수 rollDice :: StdGen -> ((Int, Int), StdGen)를 구현하라. clumsyRollDice의 구현은 한 방에 작동하지만, 한 where 절에서 다른 절로 생성기 g를 우리 손으로 전달해야 한다. 이 접근법은 의사 난수를 다량으로 생성할 때 정말로 성가실 것이다. 또한 오류에 취약하다. 오류에 취약한 중간 생성기를 where 절의 잘못된 줄에 전달해버린다면? 우리에게 정말로 필요한 것은 튜플의 두 번째 멤버 즉 새로운 생성기를 자동으로 추출해 random을 새로 호출할 때 전달하는 방법이다. 이곳에서 State 모나드가 등장한다. State의 도입 잠깐 이 장에서는 transformers 패키지의 Control.Monad.Trans.State 모듈이 제공하는 상태 모나드를 사용할 것이다. 실전에서 하스 켈 코드를 읽다 보면 mtl 패키지와 밀접한 관련이 있는 Control.Monad.State 모듈을 보게 될 것이다. 두 모듈의 차이점은 지금은 고려할 바가 아니다. 여기서 논의하는 모든 것은 mtl 변종에도 해당하는 것이다. 하스켈의 State 타입은 상태를 취해 결괏값과 그 결괏값이 추출된 후의 새로운 상태를 포함하는 튜플을 생성한다. 지금은 그 정의가 다음과 동등하다고 생각하자. 2 newtype State s a = State { runState :: s -> (a, s) } 여기서 s는 상태의 타입, a는 생산된 결괏값의 타입이다. 위의 타입이 State 타입이라고 확언할 수는 없는 것이, 그 안의 감싸진 값이 상태 자체가 아니라 상태 처리기이기 때문이다. newtype 위의 데이터 타입을 일반적인 data 키워드가 아니라 newtype 키워드로 정의한 것에 주목하라. newtype은 생성자가 하나고 필드도 하나인 타입에만 쓸 수 있다. newtype은 자명한 단일 필드의 래핑 와 언래핑이 컴파일러에 의해 제거됨을 보장한다. 이 때문에 State 같은 단순한 래퍼는 newtype으로 정의되곤 한다. 그럼 type으로 별칭을 정의해도 충분하지 않을까? type은 새로운 데이터 타입에 대한 인스턴스 정의를 허용하지 않기 때문에 그럴 수 없다. 상태 모나드 인스턴스화하기 지금까지 본 모나드들과 달리 State는 두 타입 매개변수를 가진다. Monad를 정의하기 위해 State를 두 번째 매개변수와 결합해야 한다. instance Monad (State s) where 이에 따라 State String, State Int, State SomeLargeDataStructure 등 수많은 State 모나드가 존재하게 된다. return 함수는 다음과 같이 구현된다. return :: a -> State s a return x = state ( \ st -> (x, st) ) 풀어쓰면, return에 전달한 값은 State 생성자에 감싸진 함수를 생산한다. 이 함수는 상태 값을 취해, 그대로 결괏값과 함께 튜플의 두 번째 멤버로 반환한다. 바인딩은 조금 복잡하다. (>>=) :: State s a -> (a -> State s b) -> State s b processor >>= processorGenerator = state $ \ st -> let (x, st') = runState processor st in runState (processorGenerator x) st' (>>=)는 상태 처리기와 한 함수를 취하는데 이 함수는 첫 번째 처리기의 결과를 이용해 다른 처리기를 생성할 수 있다. 두 처리기를 결합하면 초기 상태를 취해 두 번째 결과와 상태를 생성하는 함수를 얻게 된다. 다음의 도식은 이를 도식화하여 보여주는데, 조금 다르지만 ">>=" (bind) 함수의 동등한 형태다. wpA와 wpAB는 pA와 pAB의 래핑 버전이다. bind가 주어진 상태 처리기 pA와 생성기 f로부터 새로운 상태 처리기 pAB를 만드는 것에 관한 도식적 표현. s1, s2, s3는 실제 상태다. v2와 v3는 값이다. pA, pB, pAB는 상태 처리기다. 이 도식에서는 State 래퍼 내의 함수 래핑과 언래핑을 생략했다. -- pAB = s1 --> pA --> (v2, s2) --> pB --> (v3, s3) wpA >>= f = wpAB where wpAB = state $ \s1 -> let pA = runState wpA (v2, s2) = pA s1 pB = runState $ f v2 (v3, s3) = pB s2 in (v3, s3) State 설정하고 접근하기 모나드 인스턴스화는 다양한 상태 처리기의 조작을 가능케 하지만 이 시점에서 의문이 들 것이다. 최초의 상태는 정확히 어디서 오는 걸까? State s는 두 함수를 제공하는 MonadState 클래스의 인스턴스이기도 하다. put newState = state $ \_ -> ((), newState) 상태가 주어지면 이 함수는 상태 처리기를 생성한다. 처리기의 입력은 무시되고 그 결괏값은 우리가 제공한 상태를 담는 튜플이다. 결과는 신경 쓰지 않기 때문에(무엇보다 우리는 입력을 무시했다), 튜플의 첫 번째 원소는 "null"이 된다. 3 put의 반대되는 작업은 상태를 읽어들이는 것이다. 이는 get에 의해 이뤄진다. get = state $ \st -> (st, st) 그 결과 나오는 상태 처리기는 생성된 튜플의 양 위치에 입력 st를 결과로도 상태로도 넣어, 다른 처리기에 바인딩 될 수 있도록 만든다. 값과 상태에 접근하기 State의 정의로부터 runState가 접근 자이며 그 역할은 State a b 값에 적용하여 상태 처리 함수를 얻기 위함임을 알 수 있다. 이 함수는 초기 상태가 주어지면 추출된 값과 새로운 상태를 반환한다. 유사한 함수로 evalState와 execState가 있다. State a b와 초기 상태가 주어지면 evalState 함수는 추출된 값만을 반환하고 execState는 새로운 상태만을 반환한다. evalState :: State s a -> s -> a evalState processor st = fst ( runState processor st) execState :: State s a -> s -> s execState processor st = snd ( runState processor st) 주사위와 상태 주사위 던지기 예제에 State 모나드를 사용해 보자. "State"와 "상태 처리기"의 혼동을 막기 위해 타입 동의어를 사용하겠다. import Control.Monad.Trans.State import System.Random type GeneratorState = State StdGen 따라서, GenerateState는 본질적으로 StdGen -> (Int, StdGen) 함수이며 생성자 상태의 처리기다. 생성기 상태 자체는 mkStdGen 함수에 의해 만들어진다. GenerateState는 어떤 타입의 값을 추출하려는지는 명시하지 않으며 오직 상태의 타입만을 기술하는 것에 주목하라. 이제 StdGen 생성기가 주어지면 1에서 6 사이의 숫자를 내놓는 함수를 만들 수 있다. rollDie :: GeneratorState Int rollDie = do generator <- get let (value, newGenerator) = randomR (1,6) generator put newGenerator return value 한 단계씩 짚어보자. 첫 번째로 <-와 get을 이용해 의사 난수 생성기를 준비한다. get 은 상태를 이용해 모나 딕 값('m a' 안의 'a')을 덮어쓰고, 생성기를 그 상태에 바인딩 한다. (의심스러우면 get과 >>=의 정의를 떠올려보라) 그다음 randomR 함수로 1에서 6 사이의 정수를 만들어내는데 이때 준비해놓은 생성기를 사용한다. 또한 randomR이 반환한 새 생성기를 우아하게 보관한다. 이제 put 함수를 사용하여 상태를 newGenerator가 되도록 설정하면, 다음에는 다른 의사 난수 생성기를 호출할 수 있다. 마지막으로 return을 이용해 그 결과를 GeneratorState 모나드로 집어넣는다. 마침내 모나 딕 주사위를 쓸 수 있게 되었다. > evalState rollDie (mkStdGen 0) fst $ randomR (1,6) 만으로 할 수 있는 일을 하려고 왜 모나드를 끌어들여 이런 복잡한 틀을 만들었을까? 다음의 함수를 보자. rollDice :: GeneratorState (Int, Int) rollDice = liftM2 (,) rollDie rollDie 두 의사 난수의 튜플을 만들어내는 함수를 장만했다. 두 난수가 대체로 서로 다른 것에 주목하라. > evalState rollDice (mkStdGen 666) (6,1) 그 이면에서는 모나드들이 서로에게 상태를 넘기고 있다. 전에는 상태를 직접 전달해야 해서 randomR(1, 6)을 쓰는 것이 상당히 지저분했다. 이제 모나드가 그 일을 대신해준다. 전이 함수의 사용법을 알면 의사 난수의 복잡한 조합(튜플, 리스트, 그 외 뭐든 간에)을 생성하기가 순식간에 쉬워진다. 연습문제 rollNDiceIO에서 했던 것과 비슷하게, 정수가 주어지면 1에서 6사이의 정수인 의사 난수를 그 정수만큼 포함하는 리스트를 반환하는 함수 rollNDice :: Int -> GeneratorState [Int]를 구현하라. 여러 종류의 의사 난수 값들 지금까지는 Int 타입의 의사 난 수들만을 고려했다. 하지만 GeneratorState 모나드를 정의할 때 이미 본 것처럼, 이 모나드는 반환되는 값의 타입에 대해서는 아무것도 명시하지 않는다. 사실 암묵적인 가정이 하나 있다. random 호출로는 Int 비슷한 타입의 값들만 생성할 수 있다. Random 클래스는 Int, Char, Integer, Bool, Double, Float 등을 생성하는 함수들의 기본적인 구현을 포함하기 때문에 이 중 어떤 것이든 바로 생성할 수 있다. GeneratorState는 이것이 생성하는 의사 난수 값의 타입을 고려하면 "불가지론 agnostic"이기 때문에, 명시되지 않은 타입의 의사 난수 값을 제공하는 비슷한 "불가지론" 함수를 작성할 수 있다. (그 타입이 Random의 인스턴스인 한) getRandom :: Random a => GeneratorState a getRandom = do generator <- get let (value, newGenerator) = random generator put newGenerator return value rollDie와 비교해 보면 이 함수는 시그너쳐에서 Int 타입을 명시하지 않으며 randomR 대신 random을 사용한다. 아니면 똑같은 것인 getRandom을 Random의 모든 인스턴스에 사용할 수 있다. > evalState getRandom (mkStdGen 0) :: Bool True > evalState getRandom (mkStdGen 0) :: Char '\64685' > evalState getRandom (mkStdGen 0) :: Double 0.9872770354820595 > evalState getRandom (mkStdGen 0) :: Integer 2092838931 게다가 이 모든 것을 한 번에 부리기도 퍽 쉬워진다. allTypes :: GeneratorState (Int, Float, Char, Integer, Double, Bool, Int) allTypes = liftM (,,,,,,) getRandom `ap` getRandom `ap` getRandom `ap` getRandom `ap` getRandom `ap` getRandom `ap` getRandom 여기서 Control.Monad에 정의된 ap 함수를 사용할 수밖에 없는데, liftM7 같은 것은 없기 때문이다. (표준 라이브러리에는 liftM5까지만 있다) 여기서 볼 수 있듯이 ap는 다중 계산을, (리프트 된) n 원 소 튜플 생성자(이 경우 7항목인 (,,,,,,))의 적용으로 변환한다. ap를 좀 더 이해하기 위해 그 시그너쳐를 살펴보자. ap :: (Monad m) => m (a -> b) -> m a -> m b 하스켈에서 a란 타입은 값뿐 아니라 함수도 될 수 있음을 떠올릴 것. 그리고 다음과 비교해 보면 >:type liftM (,,,,,,) getRandom liftM (,,,,,) getRandom :: (Random a1) => State StdGen (b -> c -> d -> e -> f -> (a1, b, c, d, e, f)) 모나드 m은 분명히 State StdGen(우리가 GeneratorState라고 "별칭을 붙인")이지만 ap의 첫 번째 인자는 함수 b -> c -> d -> e -> f -> (a1, b, c, d, e, f)이다. ap를 적용하고 또 적용하면(여기서는 6번), 마침내 b가 또 다른 함수가 아니라 실제 값(여기서는 7원소 튜플)이 되는 시점에 다다른다. 종합하면, ap는 모나드 내의 함수를 모나 딕 값에 적용한다. (모나드 안에 있지 않은 함수를 모나 딕 값에 적용하는 liftM과 비교해 보라) 구현을 이해한답시고 정말 많이도 했다. allTypes 함수는 Random의 모든 기본 인스턴스에 대한 의사 난수 값들을 제공한다. 생성기가 동일하지 않다는 것을 입증하기 위해 끝에 Int를 또 넣었는데, 두 Int는 서로 다를 것이다. ↩ 우리의 접근법의 미묘한 문제는 transformers 패키지가 State 타입을 다소 다르게 구현한다는 것이다. 그 차이는 State를 사용하거나 이해하는 데 영향을 주지는 않는다. 하지만 이로 인해 Control.Monad.Trans.State는 State 생성자를 내보내지 않는다. 대신 같은 일을 하는 state 함수가 있다. 구현이 왜 위에서 제시한 명백한 것이 아닌지에 관해서는 몇 과목을 넘긴 후 다시 논의할 것이다. state :: (s -> (a, s)) -> State s a ↩ () 타입의 기술적 용어는 단위 unit이다. ↩ 3 Alternative와 MonadPlus 원문: http://en.wikibooks.org/wiki/Haskell/MonadPlus 정의 예제: 병렬 파싱 MonadPlus Alternative와 MonadPlus 법칙 유용한 함수들 asum guard 연습문제 모 노이드와의 관계 기타 법칙들 지금까지 알아본 바에 따르면 Maybe 모나드와 리스트 모나드는 결과가 여러 개인 계산(computation)을 표현할 수 있다. 계산이 어떤 이유로든 실패할 수 있다는 걸 나타내고 싶을 때는 Maybe를 사용한다(결과가 0개 또는 1개). 많은 결과를 가지는 계산에는 리스트를 사용한다(결과가 0개에서 임의의 많은 수). 두 경우에 모두 유용한 연산이 있는데, 복수의 계산에 의해 생긴 모든 가능한 결과를 하나로 합치는 것이다. 예를 들면 리스트의 경우에는 모든 가능한 결과들의 리스트들을 연결하는(concatenate) 것이 가능하다. 정의 노트: Alternative 클래스와 그 메서드들은 Control.Applicative 모듈에서 볼 수 있다. Alternative 클래스는 Applicative의 서브 클래스다. Applicative의 인스턴스는 최소한 다음의 두 메서드를 정의해야 한다. class Applicative f => Alternative f where empty :: f a (<|>) :: f a -> f a -> f a empty는 결과가 0개인 applicative computation이고 (<|>)는 두 computation을 결합하는 이항 함수다. 다음은 Maybe와 리스트를 위한 인스턴스 정의다. instance Alternative Maybe where empty = Nothing -- Note that this could have been written more compactly. Nothing <|> Nothing = Nothing -- 0 results + 0 results = 0 results Just x <|> Nothing = Just x -- 1 result + 0 results = 1 result Nothing <|> Just x = Just x -- 0 results + 1 result = 1 result Just x <|> Just y = Just x -- 1 result + 1 result = 1 result: -- Maybe can only hold up to one result, -- so we discard the second one. instance Alternative [] where empty = [] (<|>) = (++) -- length xs + length ys = length (xs ++ ys) 예제: 병렬 파싱 전통적인 입력 파싱에서는 입력을 한 글자씩 소비하는 함수가 사용된다. 즉 파싱 함수는 입력 문자열의 머리 부분에서 특정 조건을 만족하는 글자들을 떼어낸다("소비한다"). 예를 들면 대문자 하나를 소비하는 함수를 작성해 볼 수 있다. 문자열 앞부분의 글자들이 주어진 조건을 만족하지 않으면 그 파서는 실패한다. 아래의 예제에서는 입력에서 숫자 하나를 소비하고 파싱 된 해당 숫자를 반환한다. 실패 가능성은 Maybe를 통해 표현된다. digit i (c:_) | i > 9 || i < 0 = Nothing | otherwise = if [c] == show i then Just i else Nothing 가드는 우리가 검사하려는 Int가 한 자릿수임을 보장한다. 한자리가 맞으면 문자열의 첫 글자가 우리가 확인하려는 그 숫자와 일치하는지 검사한다. 검사를 통과하면 그 숫자를 Just로 감싸서 반환한다. 실패하면 Nothing을 반환한다. (<|>)는 두 파서를 병렬로 실행하는 데 사용할 수 있다. 즉 첫 번째 파서가 성공하면 그것의 결과를 사용하고, 아니면 두 번째 파서의 결과를 사용한다. 둘 다 실패하면 이 합성 파서는 Nothing을 반환한다. digit를 (<|>)와 함께 사용하면 이진수 문자열을 파싱 할 수 있다. binChar :: String -> Maybe Int binChar s = digit 0 s <|> digit 1 s 파서 라이브러리들은 Alternative를 이런 식으로 사용한다. Text.ParserCombinators.ReadP의 (+++)와 Text.ParserCombinators.Parsec.Prim의 (<|>)가 그런 예시다. 이런 사용 패턴은 선택(choice)이라는 관점에서 서술할 수 있다. binChar에 넣으면 성공적으로 파싱 될 문자열의 경우 두 가지 선택이 있다. 그 문자열은 '0' 또는 '1'으로 시작한다. MonadPlus MonadPlus 클래스는 Alternative와 밀접한 연관이 있다. class Monad m => MonadPlus m where mzero :: m a mplus :: m a -> m a -> m a 그 정의는 메서드 이름들이 다르고 Applicative 제약이 Monad로 바뀐 것만 빼면 Alternative와 같다. Alternative와 MonadPlus의 인스턴스들을 모두 가지는 타입의 경우 mzero와 mplus는 각각 empty 및 (<|>)와 동치여야 한다. 그러면 왜 MonadPlus 같은 클래스가 굳이 필요한지 의문이 들 수 있다. 그 이유의 일부는 역사적이다. 하스켈에 Applicative가 도입되기 오래전부터 Monad가 존재했던 것처럼 MonadPlus는 Alternative보다 훨씬 오래되었다. 그 외에도 MonadPlus 메서드들이 Monad와 어떻게 상호작용할지에 관한 추가적인 기대값들이 있는데 그것이 Alternative에는 적용되지 않아서, 무언가가 MonadPlus라고 명시하는 것은 그것이 Alternative면서 Monad라고 명시하는 것보다 더 강한 주장이다. 이 문제는 다음 절에서 좀 더 알아본다. Alternative와 MonadPlus 법칙 대부분의 범용 클래스들처럼 Alternative와 MonadPlus는 지켜야 하는 법칙들이 있다. 하지만 그 법칙들의 완전한 집합이 어떻게 생겼는지에 관한 보편적 동의는 없다. Alternative에서 가장 흔하게 채택되고 또한 직관을 얻는데 가장 중요한 법칙은, empty와 (<|>)가 모 노이드를 형성한다는 것이다. -- empty is a neutral element empty <|> u = u u <|> empty = u -- (<|>) is associative u <|> (v <|> w) = (u <|> v) <|> w "모 노이드를 형성" 하는 것에 특별한 것은 없다. 항등원(nuetral element)과 결합(associative)은 정수 덧셈이 결합법칙을 만족하고 그 항등원이 0이라고 말하는 것과 다를 바가 없다. 사실 MonadPlus의 메서드들 이름이 mzero와 mplus인 것은 이런 유사성 때문이다. MonadPlus의 경우에는 최소한 모 노이드 법칙들이 필수적이며 위의 법칙들에 정확히 대응한다. mzero `mplus` m = m m `mplus` mzero = m m `mplus` (n `mplus` o) = (m `mplus` n) `mplus` o 그리고 추가적인 법칙 2개가 있다. Control.Monad 문서에서 인용: mzero >>= f = mzero -- left zero m >> mzero = mzero -- right zero mzero를 실패한 계산(computation)으로 해석하면 이 법칙들은 monadic computation 연쇄 안에서 한 번의 실패가 연쇄 전체의 실패로 이어짐을 뜻한다. Alternative와 MonadPlus에 추가로 제안된 법칙들은 이 장의 끝에서 살펴본다. 유용한 함수들 베이스 라이브러리에는 Alternative에 관련하여 (<|>)와 empty 외에도 유용한 범용 함수가 2개 있다. asum Alternative를 다룰 때는 alternative 값들의 리스트, 가령 [Maybe a]나 [[a]]를 받아서 (<|>)로 결합하는 일이 흔하다. Data.Foldable의 asum 함수가 그런 일을 한다. asum :: (Alternative f, Foldable t) => t (f a) -> f a asum = foldr (<|>) empty 어떻게 보면 asum은 리스트의 concat 연산을 일반화한다. 리스트의 경우 둘은 완벽히 동치다. Maybe의 경우 asum은 리스트의 첫 번째 Just x를 찾고 하나도 없으면 Nothing을 반환한다. Data.Foldable과 Control.Monad에 둘 다 들어있는 msum은 MonadPlus에 특화된 asum이다. msum :: (MonadPlus m, Foldable t) => t (m a) -> m a guard 리스트 모나드를 논할 때 가드와 리스트 조건 제시식이 얼마나 비슷한지 언급했지만, 리스트 조건 제시식 필터링을 가드에서 어떻게 처리할지는 논의하지 않았다. Control.Monad의 guard 함수가 바로 그런 일을 해준다. 모든 피타고라스 세 쌍(즉 직각삼각형의 변들의 길이를 나타내는 세 쌍의 정수들)을 구하는 다음의 조건 제시식을 살펴보자. 먼저 브루트 포스 접근법을 보자. 필터링을 위해 불리언 조건식, 이른바 피타고라스 정리를 사용한다. pythags = [ (x, y, z) | z <- [1..], x <- [1.. z], y <- [x.. z], x^2 + y^2 == z^2 ] 위의 조건 제시식을 리스트 모나드 do 블록으로 번역하면: pythags = do z <- [1..] x <- [1.. z] y <- [x.. z] guard (x^2 + y^2 == z^2) return (x, y, z) guard 함수는 모든 Alternative에 대해 이렇게 정의할 수 있다. guard :: Alternative m => Bool -> m () guard True = pure () guard _ = empty guard는 술어가 False 이면 do 블록을 empty로 환원한다. left zero 법칙에 따르면 mzero >>= f = mzero -- Or, equivalently: empty >>= f = empty >>= 연산자의 좌변의 empty는 다시 empty를 생산한다. do 블록은 (>>=)로 연결된 표현식들로 분해되기 때문에 어느 시점에든 empty가 있으면 do 블록 전체를 empty로 만든다. pythags 안에서 guard가 하는 일을 자세히 살펴보자. 먼저 이것은 리스트 모나드에 대해 정의된 guard다. -- guard :: Bool -> [()] guard True = [()] guard _ = [] guard는 기본적으로 길을 막는다. pythags에서 우리는 x^2 + y^2 + z^2가 False인 모든 길(즉 x, y, z의 조합)을 막으려 한다. 위의 do 블록을 전개해서 어떻게 작동하는지 살펴보자. pythags = [1..] >>= \z -> [1.. z] >>= \x -> [x.. z] >>= \y -> guard (x^2 + y^2 == z^2) >>= \_ -> return (x, y, z) >>=와 return을 리스트 모나드에 대한 그것들의 정의로 치환하면 (그리고 가독성을 위해 let 바인딩을 곁들이면) 다음을 얻는다. pythags = let ret x y z = [(x, y, z)] gd z x y = concatMap (\_ -> ret x y z) (guard $ x^2 + y^2 == z^2) doY z x = concatMap (gd z x) [x.. z] doX z = concatMap (doY z) [1.. z] doZ = concatMap (doX) [1..] in doZ guard는 그 인자가 False 면 빈 리스트를 반환한다는 것을 기억하자. 빈 리스트를 가로질러 매핑을 수행하면 어떤 함수를 전달하던 빈 리스트가 나온다. 따라서 gd 안에서 guard를 호출하여 빈 리스트가 나왔으면 gd 자체도 빈 리스트를 생산한다. 이 경우 \_ -> ret x y z는 호출되지 않는다. 이게 왜 중요한지를 이해하기 위해 리스트 조건 제시식을 트리라고 생각해 보자. 우리의 피타고라스 세 쌍 알고리즘의 경우 루트에서 시작해 모든 z에 대한 브랜치가 있어야 하고, 이런 브랜치마다 모든 x에 대한 하위 브랜치가 있어야 하며, 다시 이런 브랜치마다 모든 y에 대한 하위 브랜치가 있어야 한다. 따라서 그 트리는 이런 모양이다. start |_________________________... | | | z 1 2 3 | |____ |____________ | | | | | | x 1 1 2 1 2 3 | |_ | |___ |_ | | | | | | | | | | | y 1 1 2 2 1 2 3 2 3 3 각 z, x, y 조합은 트리를 경유하는 한 경로를 나타낸다. 모든 함수를 적용하고 나면 바닥부터 시작해서 브랜치들의 결과를 결합한다. 술어가 성립하지 않는 모든 경로는 빈 리스트로 평가되므로 이러한 결합에 영향을 주지 않는다. 연습문제 1 Alternative 모 노이드 법칙들을 Maybe와 리스트에 대해 증명해 보자. 2 병렬 파싱 예제를 보강해서 다음과 같은 방식으로 임의 문자를 처리하게 만들 수 있다. -- | Consume a given character in the input, and return -- the character we just consumed, paired with rest of -- the string. We use a do-block so that if the -- pattern match fails at any point, 'fail' of the -- Maybe monad (i.e. Nothing) is returned. char :: Char -> String -> Maybe (Char, String) char c s = do c' : s' <- return s guard (c == c') return (c, s') 그러면 임의의 올바른 16진수 문자(0-9 또는 a-f)를 파싱 하는 hexChar 함수를 작성할 수 있다. 이 함수를 작성해 보자. (힌트: map digit [0.. 9] :: [String -> Maybe Int]) 3 guard와 Applicative 결합기 들(pure, (<*>), (*>) 등)을 사용하여 Maybe 모나드 장에서 나온 safeLog를 구현해 보자. Monad 결합기 들(return, (>>=), (>>)은 사용하지 않는다. 모 노이드와의 관계 위에서 Alternative 법칙들을 논하면서 모 노이드의 수학적 개념을 넌지시 언급했다. 사실 하스켈에는 Monoid 클래스가 이미 있다. (Data.Monoid에 정의됨) 모 노이드에 대해서는 이후의 장에서 세세히 살펴보겠지만, 지금은 Monoid의 최소한의 정의가 두 메서드를 구현하는 것을 알면 충분하다. 바로 항등원(즉 0)과 결합법칙이 성립하는 이항 연산(즉 'plus')이다. class Monoid m where mempty :: m mappend :: m -> m -> m 예를 들면 리스트는 간단한 모 노이드를 형성한다. instance Monoid [a] where mempty = [] mappend = (++) 낯설지 않다. Alternative 및 MonadPlus와 수상할 정도로 닮았지만 중요한 차이점이 있다. 인스턴스 선언에서 [] 대신 [a]을 사용한 것에 주목하자. 모노이드는 무언가의 "래퍼"이거나 매개변수 다형성을 가질 필요가 없다. 예를 들어 정수는 0을 항등원으로 덧셈 하에서 모 노이드를 형성한다. Alternative가 별개의 타입 클래스인 이유는, 고유의 성질을 가지는 특정 유형의 모 노이드를 포착(capture) 하기 때문이다. 예를 들면 이항 연산 (<|>) :: Alternative f => f a -> f a -> f a은 Appilcative 문맥과 본질적으로 연결되어 있다. (?) 기타 법칙들 노트 이 절은 보너스다. 이런 법칙들이 있다는 것을 알아두면 좋지만 이것 때문에 잠을 설칠 필요는 없다. 지금까지 언급한 일반적으로 가정되는 법칙들 외에도 특정 관점에서는 말이 되지만, 현존하는 모든 Alternative와 MonadPlus에 대해 성립하지는 않는 법칙들이 있다. 특히 현재의 MonadPlus는 추가적인 법칙들을 가질 수도 있는 가상의 클래스들의 교집합이라 볼 수 있다. Alternative에는 다음의 두 추가 법칙이 흔히 제안된다. 이것들은 Maybe와 리스트에는 성립하지만 코어 라이브러리 안에 반례가 존재한다. 또한 Alternative가 MonadPlus 기도할 때, 앞서 언급한 mzero 법칙은 다음 법칙들의 결과물이 아니다. (f <|> g) <*> a = (f <*> a) <|> (g <*> a) -- right distributivity (of <*>) empty <*> a = empty -- right absorption (for <*>) MonadPlus의 경우 left distribution 법칙이 흔히 제안되지만 이는 리스트에는 성립하는 반면 Maybe에는 성립하지 않는다. (m `mplus` n) >>= k = (m >>= k) `mplus` (n >>= k) -- left distribution 한 면 left catch 법칙은 Maybe에는 성립하지만 리스트에는 성립하지 않는다. return x `mplus` m = return x -- left catch 일반적으로는 모든 MonadPlus 인스턴스에 대해 left distribution 또는 left catch 중 하나만 성립할 거라고 가정된다. 둘 다는 안 될까? 그렇다고 가정해 보자. 그러면 모든 x, y :: m a에 대해 x `mplus` y = -- monad identity (return x >>= id) `mplus` (return y >>= id) = -- left distribution (return x `mplus` return y) >>= id = -- left catch return x >>= id = -- monad identity 이러면 가장 자명한 MonadPlus 구현 외에는 모두 소거된다. 더 나쁜 것은 임의의 x에 대해 mzero `mplus` x = mzero가 된다는 것이다. 모 노이드 항등 법칙 mzero `mplus` x = x을 추가해 보면 그 모나드는 값을 하나만 가지고 따라서 자명한 모나드인 Data.Proxy.Proxy와 동형이 된다. 마지막으로 모 노이드 법칙들에 대해서도 견해의 차이가 있다는 것을 짚고 넘어가겠다. 이 법칙들에 반하는 사례로서 특정 비결정론적 모나드들은 대개 MonadPlus를 이용해 표현되고 이 경우 핵심 법칙들은 left zero와 left distribution이지만, 이런 경우에서 모 노이드 법칙들은 지키기 어려워서 완화하거나 완전히 버려야 한다. 다음은 호기심이 많은 독자들을 위한 추가 읽을거리다. The Haskell Wiki on MonadPlus (이 논쟁은 Alternative가 생기기도 전부터 오래 이어져온 것임을 상기하자.) 스택 오버플로의 Distinction between typeclasses MonadPlus, Alternative, and Monoid? 와 Confused by the meaning of the 'Alternative' type class and its relationship to other type classes (GHC 7.x/8.x의 관련 라이브러리들의 문서화에 반영된 현재 상태에 대한 상세한 개요. 2010 하스 켈 리포트는 이 문제에 관해 정확히 규정하지 않는다.) From monoids to near-semirings: the essence of MonadPlus and Alternative by Rivas, Jaskelioff and Schrijvers (모 노이드 법칙을 넘어 Alternative를 위한 right distribution과 right absorption, MonadPlus를 위한 left zero와 left distribution을 포함하는 formulation) Wren Romano on MonadPlus and seminearrings (MonadPlus right zero 법칙이 너무 강하다는 주장.) Oleg Kiselyov on the MonadPlus laws 비결정론적 모나드의 경우 모 노이드 법칙을 반대하는 주장.) 스택 오버플로 Must mplus always be associative? (MonadPlus의 모 노이드 법칙들의 효용성에 관한 논의.) 4 모나드 변환기 원문: http://en.wikibooks.org/wiki/Haskell/Monad_transformers 패스프레이즈 검증 간단한 모나드 변환기: MaybeT 간략화된 패스프레이즈 검증 변환기 과잉 타입 곡예 전이(lifting) lift 구현하기 변환기 구현하기 State 변환기 감사의 말 노트 지금까지 IO 액션, Maybe, 리스트, 상태를 처리하는데 모나드가 어떻게 도움이 되는지 알아봤다. 모나드가 이토록 범용적인 도구들을 활용하는 일반적인 방법이라면 여러 모나드의 기능을 한 번에 사용하는 것도 되지 않을까. 예를 들어 입출력과 Maybe 예외 처리를 모두 사용할 수 있는 함수라던가? IO (Maybe a) 같은 타입을 써도 가능하지만 그러면 IO do 블록 안에서 패턴 매칭으로 값을 추출해야 하는데, Maybe 모나드는 그럴 일 없이 작동하도록 되어 있다. 모나드 변환기(monad transformer)는 두 모나드의 행동을<NAME>는 단일 모나드를 만드는 특별한 타입이다. 패스프레이즈 검증 전 세계 IT 직원들의 현실적인 문제를 하나 고려해 보자. 사용자들이 강력한 '장문의 비밀번호(passphrase)'를 생성하도록 하는 것이다. 한 가지 접근법은 사용자가 성가신 요구사항들(대문자, 숫자, 알파벳이나 숫자가 아닌 문자를 적어도 하나씩 포함)을 만족하는 최소한의 길이를 입력하게 강제하는 것이다. 이 하스 켈 함수는 사용자로부터 패스프레이즈를 받는다. getPassphrase :: IO (Maybe String) getPassphrase = do s <- getLine if isValid s then return $ Just s else return Nothing -- The validation test could be anything we want it to be. isValid :: String -> Bool isValid s = length s >= 8 && any isAlpha s && any isNumber s && any isPunctuation s getPassphrase는 IO 액션인데, 사용자로부터 입력을 받아야 하기 때문이다. 그리고 패스워드가 isValid를 통과하지 못할 경우 Nothing을 반환하기 위해 Maybe도 사용한다. 하지만 우리는 여기서 Maybe를 모나드로서 쓰고 있지 않다. do 블록은 IO 모나드 내에 있고 우리는 Maybe 값을 return할 뿐이다. 모나드 변환기는 getPassphrase 작성을 쉽게 만들 뿐 아니라 모든 코드 조각을 간단하게 만든다. 일단 패스프레이즈 수집 프로그램을 계속해 보자. askPassphrase :: IO () askPassphrase = do putStrLn "Insert your new passphrase:" maybe_value <- getPassphrase case maybe_value of Just value -> do putStrLn "Storing in database..." -- do stuff Nothing -> putStrLn "Passphrase invalid." 이 코드는 maybe_value 변수를 한 줄만으로 생성하고 그다음 패스프레이즈를 검증한다. 모나드 변환기를 쓰면 패스프레이즈를 한 방에 추출할 수 있다. 패턴 매칭도 isJust 같은 관료도 필요 없다. 이 간단한 예제에서는 그 이점이 사소해 보일 수 있지만, 진가는 복잡한 상황에서 드러난다. 간단한 모나드 변환기: MaybeT getPassphrase와 관련된 모든 코드를 간단히 만들기 위해, 우리는 IO 모나드에 Maybe 모나드의 일부 특성을 부여하는 모나드 변환기를 정의하고 MaybeT라 부를 것이다. 이는 모나드 변환기에 이름을 붙일 때, 특성을 제공하는 모나드의 이름에 "T"를 붙여 만드는 관습을 따른 것이다. MaybeT는 m (Maybe a)의 래퍼다. m은 임의의 모나드이며 이 예제에서는 IO다. newtype MaybeT m a = MaybeT { runMaybeT :: m (Maybe a) } 이 데이터 타입 정의는 m에 대해 매개화된 타입 생성자 MaybeT를 명시한다. 역시 이름이 MaybeT인 생성자를 가지고, 그 기저의 표현에 접근할 수 있는 편의성 접근자 함수 runMaybeT도 있다. 모나드 변환기의 요체는 모나드를 모나드로 변환한다는 것이다. 따라서 MaybeT m을 Monad 클래스의 인스턴스로 만들어야 한다. instance Monad m => Monad (MaybeT m) where return = MaybeT . return . Just -- The signature of (>>=), specialized to MaybeT m: -- (>>=) :: MaybeT m a -> (a -> MaybeT m b) -> MaybeT m b x >>= f = MaybeT $ do maybe_value <- runMaybeT x case maybe_value of Nothing -> return Nothing Just value -> runMaybeT $ f value return 함수는 return = MaybeT . return . return라고 작성할 수도 있다. (가독성이 조금 안 좋지만) do 블록의 첫 줄부터 보자. runMaybeT 접근 자는 x를 m (Maybe a) 계산으로 해체한다. 여기서 do 블록 전체가 m 안에 있는 것을 볼 수 있다. 역시 첫 번째 줄에서 <-는 해체된 계산으로부터 Maybe a 값을 추출한다. case 문은 maybe_value를 테스트한다. Nothing의 경우 Nothing을 m으로 반환한다. Just의 경우 Just로부터 온 value에 f를 적용한다. f의 결과 타입은 MaybeT m b이므로 결과를 m 모나드에 다시 넣으려면 별도의 runMaybeT가 필요하다. 마지막으로 do 블록은 그 자체로 m (Maybe b) 타입이다. 그러므로 MaybeT 생성자로 감싼다. 조금 복잡하지만 방대한 래핑과 언래핑을 제외하면 MaybeT의 bind 구현은 Maybe의 익숙한 bind 연산자 구현과 동일하게 작동한다. -- (>>=) for the Maybe monad maybe_value >>= f = case maybe_value of Nothing -> Nothing Just value -> f value do 안에 접근자인 runMaybeT가 있는데 그럼 왜 do 블록 전에 MaybeT 생성자를 쓰는 걸까? do 블록은 MaybeT m이 아니라 m 모나드 내에 있어야만 한다. (이 시점에서는 MaybeT m의 bind 연산자가 정의되지 않음) 늘 그랬듯이 Monad의 슈퍼클래스인 Applicative와 Functor를 위한 인스턴스들도 제공해야 한다. instance Monad m => Applicative (MaybeT m) where pure = return (<*>) = ap instance Monad m => Functor (MaybeT m) where fmap = liftM 이 외에도 MaybeT m을 몇 가지 클래스들의 인스턴스로 만들어두는 것이 편리하다. instance Monad m => Alternative (MaybeT m) where empty = MaybeT $ return Nothing x <|> y = MaybeT $ do maybe_value <- runMaybeT x case maybe_value of Nothing -> runMaybeT y Just _ -> return maybe_value instance Monad m => MonadPlus (MaybeT m) where mzero = empty mplus = (<|>) instance MonadTrans MaybeT where lift = MaybeT . (liftM Just) MonadTrans는 lift 함수를 구현하므로 우리는 m 모나드로부터 함수를 취해서 MaybeT m 모나드로 데려온 다음 do 블록 안에서 사용할 수 있다. Alternative와 MonadPlus의 경우, Maybe가 이 클래스들의 인스턴스이므로 MaybeT m도 인스턴스화하는 것이 합리적이다. 간략화된 패스프레이즈 검증 위의 패스프레이즈 검증 예제는 MaybeT 모나드 변환기를 이용해 간소화할 수 있다. getPassphrase :: MaybeT IO String getPassphrase = do s <- lift getLine guard (isValid s) -- Alternative provides guard. return s askPassphrase :: MaybeT IO () askPassphrase = do lift $ putStrLn "Insert your new passphrase:" value <- getPassphrase lift $ putStrLn "Storing in database..." 코드가 더 간단해졌다. 특히 사용자 함수 askPassphrase가 그렇다. 가장 중요한 것은 결과가 Nothing 인지 Just 인지 우리가 직접 확인할 필요가 없다는 점이다. bind 연산자가 그 일을 대신해준다. MaybeT IO 모나드 안으로 getLine 함수와 putStrLn 함수를 들여오기 위해 lift를 어떻게 사용했는지에 주목하자. 또한 MaybeT IO가 Alternative의 인스턴스이기 때문에 패스프레이즈의 타당성 검사를 guard 문으로 처리할 수 있다. guard는 나쁜 패스프레이즈의 경우 empty(즉 IO Nothing)을 반환할 것이다. 부수적으로, MonadPlus의 도움을 받으면 사용자에게 올바른 패스프레이즈를 무한정 요구하는 것도 아주 쉬워진다. askPassphrase :: MaybeT IO () askPassphrase = do lift $ putStrLn "Insert your new passphrase:" value <- msum $ repeat getPassphrase lift $ putStrLn "Storing in database..." 변환기 과잉 transformers 패키지는 흔히 쓰이는 모나드들을 위한 변환기들이 있는 모듈들을 제공한다. (예를 들어 MaybeT는 Control.Monad.Trans.Maybe에서 찾을 수 있다) 이 변환기들은 비변환기 버전들에 대응해 일관되게 정의되어 있다. 즉 그 구현이 다른 모나드를 엮기 위한 부수적인 감싸기와 풀어헤치기를 빼면 대동소이하다. 이제부터 변환기가 그 기반으로 삼는 비변환기 모나드(예: MaybeT의 Maybe)를 전구 모나드(precursor monad)라 칭하고 변환기가 적용되는 다른 모나드(예: MaybeT IO의 IO)를 기반 모나드(base monad)라 칭하겠다. 예시를 임의로 하나 뽑자면, ReaderT Env IO String은 Env 타입(전구 모나드인 Reader의 semantics)의 어떤 환경으로부터 값을 읽어오고, 어떤 IO를 수행한 다음, String 타입의 값을 받아오는 작업을 수반하는 계산(computation)이다. 이 변환기의 bind 연산자와 return이 전구 모나드의 semantic을 반영하기 때문에 ReaderT Env IO String 타입의 do 블록은 바깥에서 보면 Reader 모나드의 do 블록처럼 보일 것이다. 단 lift를 사용하면 IO 액션을 끼워 넣기가 아주 쉬워진다는 점이 다르다. 타입 곡예 MaybeT의 타입 생성자는 기반 모나드의 Maybe 값에 대한 wrapper라는 것을 봤었다. 대응하는 접근자 runMaybeT는 m (Maybe a) 타입의 값을 돌려준다. 즉 이 값은 기반 모나드 안에서 반환된, 전구 모나드의 값이다. 이와 비슷하게 리스트 및 Either에 기반한 ListT 및 ExceptT 변환기의 경우를 보면, runListT :: ListT m a -> m [a] 그리고 runExceptT :: ExceptT e m a -> m (Either e a) 하지만 모든 변환기가 이런 식으로 전구 모나드와 연계되는 것은 아니다. 위에서 예로 든 전구 모나드들과 달리 Writer, Reader, State, Cont 모나드는 다중 생성자를 가지지도 않고 다중 인자를 가지는 생성자도 없다. 그래서 이것들은 변환기 버전의 run... T와 비슷한 단순한 unwrapper로 작동하는 run... 함수를 가진다. 아래의 표는 각각의 경우 run... 와 run... T 함수의 결과 타입을 보여준다. 각각 기반 모나드와 변환된 모나드에 의해 감싸진 타입으로 생각할 수 있다. 1 전구 모나드 변환기 기존 타입 (전구 모나드에 의해 "감싸지는") 합성 타입 (변환기에 의해 "감싸진") Writer WriterT (a, w) m (a, w) Reader ReaderT r -> a r -> m a State StateT s -> (a, s) s -> m (a, s) Cont ContT (a -> r) -> r (a -> m r) -> m r 결합된 타입에서는 전구 모나드 타입 생성자가 빠진 것에 주목하자. Maybe나 리스트 류처럼 흥미로운 생성자가 없으면 변환된 모나드를 풀어헤친 후에는 전구 모나드의 타입을 유지할 필요가 없다. 뒤의 세 경우는 함수 타입들이 wrapping 된 것도 눈여겨보자. 예를 들어 StateT는 s -> (a, s) 꼴의 상태 변환 함수들을 s -> m (a, s) 꼴의 상태 변환 함수들로 탈바꿈시킨다. 감싸진 함수의 최종 타입만이 기반 모나드 안으로 들어간다. ReaderT도 비슷하다. ContT는 상황이 다른데, Cont(continuation 모나드)의 semantic 때문이다. 감싸진 함수와 그것의 함수 인자의 최종 타입들은 같아야 하며, 따라서 변환기는 둘 다 기반 모나드에 넣는다. 일반적으로 모나드의 변환 버전을 만드는 마법의 공식은 없다. 각 변환기의 형태는 비 변환기 타입의 문맥에서 어떤 것이 말이 되는지에 따라 달라진다. 전이(lifting) 이제 lift 함수를 자세히 살펴볼 것이다. lift는 일상에서 모나드 변환기를 이용할 때 매우 중요하다. 가장 먼저 확실히 할 것은 "lift"라는 이름 그 자체다. 우리는 비슷한 이름의 liftM이라는 함수를 이미 알고 있다. 모나드 이해하기에서 봤듯이 liftM은 fmap의 모나드 특화 버전이다. liftM :: Monad m => (a -> b) -> m a -> m b liftM은 모나드 m 내부의 값에 함수 (a -> b)를 적용한다. 이것을 인자가 하나인 함수로 볼 수도 있다. liftM :: Monad m => (a -> b) -> (m a -> m b) liftM은 평범한 함수를 m 안에서 작동하는 함수로 변환한다. 여기서 "전이"는 무언가를 다른 무언가로 바꾸는 것을 지칭한다. 이 경우는 함수를 모나드로 바꿨다. liftM은 do 블록이나 다른 기교 없이 평범한 함수를 모나 딕 값에 적용할 수 있게 해준다. bind notation do notation liftM monadicValue >>= \x -> return (f x) do x <- monadicValue return (f x) liftM f monadicValue lift 함수는 모나드 변환기를 다룰 때 비슷한 역할을 한다. 기반 모나드 계산을 합성 모나드로 데려온다 bring (좀 더 일반적인 단어를 쓰자면, 격상시킨다 promote). 그럼으로써 기반 모나드 계산들을 합성 모나드 내의 더 큰 계산의 일부로서 쉽게 삽입할 수 있도록 한다. lift는 Control.Monad.Trans.Class에 있는 MonadTrans 클래스의 하나뿐인 메서드다. 모든 모나드 변환기는 MonadTrans의 인스턴스이므로 이 모두에 lift를 사용할 수 있다. class MonadTrans t where lift :: (Monad m) => m a -> t m a IO 연산에 특화된 lift의 변종인 liftIO라는 것도 있다. 이는 Control.Monad.IO.Class에 있는 MonadIO 클래스의 하나뿐인 메서드다. class (Monad m) => MonadIO m where liftIO :: IO a -> m a liftIO는 여러 변환기가 단일 합성 모나드로 쌓여있을 때 편리하다. 그런 경우 IO는 항상 가장 안쪽의 모나드이므로 IO 값들을 가장 바깥으로 빼내려면 전이를 한 번보다 많이 해야 한다. liftIO는 함수를 작성할 때 어느 깊이에서든 IO 값을 가져올 수 있도록 정의되어 있다. lift 구현하기 lift 구현은 대개 직관적이다. MaybeT 변환기를 보자. instance MonadTrans MaybeT where lift m = MaybeT (liftM Just m) 기반 모나드의 모나 딕 값으로 시작한다. liftM을 이용해(fmap을 써도 된다) 전구 모나드를 통과(Just 생성자를 거쳐) 하여 m a에서 m (Maybe a)에 도달한다. 마지막으로 MaybeT 생성자로 감싼다. 여기서 liftM은 기반 모나드 안에서 작동하며, 이는 이전에 본 (>>=)의 구현에서 do 블록을 MaybeT로 감싼 것이 기반 모나드 안에 있던 것과 비슷한 상황이다. 연습문제 liftM은 범용적으로 정의될 수 있는데 lift 함수는 왜 모나드마다 따로 정의해야 할까? Identity는 Data.Functor.Identity에 정의된 자명한 펑터다. newtype Identity a = Identity { runIdentity :: a } 그리고 다음과 같은 Monad 인스턴스를 가진다. instance Monad Identity where return a = Identity a m >>= k = k (runIdentity m) 모나드 변환기 IdentityT를 구현해 보자. Identity와 비슷하지만 a 대신 m a 타입의 값들을 래핑 한다. 최소한 이것의 Monad 및 MonadTrans 인스턴스들은 작성해 보자. 변환기 구현하기 State 변환기 이번에는 추가적인 예제로서 StateT의 구현을 자세히 살펴볼 것이다. 계속하기 전에 State 모나드에 관한 절을 다시 읽어보면 좋다. State 모나드가 newtype State s a = State { runState :: (s -> (a, s)) }라는 정의에 기반한다고 볼 수 있는 것처럼, StateT 변환기는 다음 정의에 기반한다. newtype StateT s m a = StateT { runStateT :: (s -> m (a, s)) } StateT s m은 다음의 Monad 인스턴스를 가진다. 여기서는 전구 모나드인 State를 곁에 표기했다. State StateT newtype State s a = State { runState :: (s -> (a, s)) } instance Monad (State s) where return a = State $ \s -> (a, s) (State x) >>= f = State $ \s -> let (v, s') = x s in runState (f v) s' newtype StateT s m a = StateT { runStateT :: (s -> m (a, s)) } instance (Monad m) => Monad (StateT s m) where return a = StateT $ \s -> return (a, s) (StateT x) >>= f = StateT $ \s -> do (v,s') <- x s -- get new value and state runStateT (f v) s' -- pass them to f 우리의 return 정의는 기반 모나드의 return 함수를 이용한다. (>>=)는 do 블록을 사용하여 기반 모나드 내에서 계산을 수행한다. 노트 부수적으로, State 모나드에 관한 장에서 State 생성자 대신 state 함수가 있었던 이유를 마침내 설명할 수 있게 되었다. transformers와 mtl 패키지에서 State s는 StateT s Identity의 타입 동의어로서 구현되며, 여기서 Identity는 앞절의 연습문제에서 소개한 더미 모나드다. 최종 모나드는 우리가 지금까지 써온, newtype을 이용한 정의와 동등하다. 합성된 StateT s m 모나드들을 상태 모나드로써 사용한다면 분명 get 명령과 put 명령이 필요해질 것이다. 여기서는 mtl 패키지 스타일의 정의들을 보여주겠다. mtl은 모나드 변환기들 자체 외에도, 일반적인 모나드들의 기초 연산들을 위한 타입 클래스들을 제공한다. 예를 들어 Control.Monad.State의 MonadState 클래스는 get과 put 메서드를 가진다. instance (Monad m) => MonadState s (StateT s m) where get = StateT $ \s -> return (s, s) put s = StateT $ \_ -> return ((),s) MonadState s m => MonadState s (MaybeT m)처럼 다른 변환기들로 감싼 상태 모나드들을 위한 MonadState 인스턴스들도 있다. 이것들은 get과 put을 명시적으로 전이할 필요성을 없애서 우리를 좀 더 편하게 만들어준다. 합성된 모나드들을 위한 MonadState 인스턴스가 그러한 전이를 대신 처리해 주기 때문이다. 기반 모나드에서 사용할 수도 있는 인스턴스들을 합성 모나드로 전이하면 유용할 수도 있다. 예를 들어 StateT가 MonadPlus의 인스턴스와 함께 사용되는 모든 합성 모나드는 MonadPlus의 인스턴스로 만들 수 있다. instance (MonadPlus m) => MonadPlus (StateT s m) where mzero = StateT $ \_ -> mzero (StateT x1) `mplus` (StateT x2) = StateT $ \s -> (x1 s) `mplus` (x2 s) mzero와 mplus의 구현은 자명하다. 즉 실제 작업을 기반 모나드의 인스턴스에게 위임한다. 모나드 변환기는 lift를 사용하려면 반드시 MonadTrans를 가져야 한다는 것을 잊지 말자. instance MonadTrans (StateT s) where lift c = StateT $ \s -> c >>= (\x -> return (x, s)) lift 함수는 상태 변환 함수 StateT를 생성한다. 이 함수는 기반 모나드 내에서의 계산을, 결괏값을 입력 상태로 포장하는 함수에 바인딩 한다. 가령 StateT를 List 모나드에 적용한다면, 리스트를 반환하는 함수(즉 List 모나드 내에서의 계산)는 State s [] 안으로 전이할 수 있고 거기서 StateT (s -> [(a, s)])을 반환하는 함수가 된다. 즉 전이된 계산은 그것의 입력 상태로부터 여러 개의 (값, 상태) 짝을 생산한다. 이것은 StateT 내의 계산(computation)을 "나눠서", 전이된 함수가 반환하는 리스트 안의 각각의 값에 대해 계산의 다른 분기들을 생성한다. StateT를 다른 모나드에 적용하면 lift 함수의 의미가 달라질 것이다. 연습문제 get과 put을 이용해 state :: MonadState s m => (s -> (a, s)) -> m a를 구현해 보자. MaybeT (State s)와 StateT s Maybe는 동등할까? (힌트: 각 경우에 run... T unwrapper가 무엇을 생산하는지 비교해 보는 방법이 있다.) 감사의 말 이 과목에선 All About Monads의 저자 Jeff Newbern의 허락을 받아 많은 인용문을 사용했다. 노트 wrapping 해석은 2.0.0.0 이전의 mtl 패키지에 대해서만 올바르다. ↩ 2 고급반 여기서는 여러 가지 자료구조, 타입 이론 등 더 폭넓은 함수형 프로그래밍 개념을 소개합니다. 그리고 동시성 같은 보다 실용적인 주제도 다룹니다. 목차 하스 켈 고급 모 노이드 적용성 펑 터 Foldable Traversable 애로 튜토리얼 애로 이해하기 Continuation passing style (CPS) 지퍼 렌즈 Comonads Value recursion (MonadFix) Effectful streaming 가변 객체 동시성 Template Haskell Type Families 타입과의 유희 다형성 기초 Existentially qualified types 타입 클래스 고급 팬텀 타입 일반화된 대수적 데이터 타입 (GADT) 데이터 타입 대수 타입 생성자 & 종(kind) 여러 이론들 표기 의미론(Denotational semantics) Equational reasoning Program derivation 범주론 Curry-Howard 동형 fix와 재귀 하스 켈 성능 입문 성능 예시들 그래프 소거 지연성 Time and space profiling Strictness 알고리즘 복잡도 자료구조 Parallelism 1 하스 켈 고급 하스 켈 고급 모 노이드 적용성 펑 터 Foldable Traversable 애로 튜토리얼 애로 이해하기 Continuation passing style (CPS) 지퍼 렌즈 Comonads - 원문 없음 Value recursion (MonadFix) - 원문 없음 Effectful streaming - 원문 없음 가변 객체 동시성 - 원문이 대충 작성됨. "Parallel and Concurrent Programming in Haskell" 책을 추천합니다. Template Haskell - 원문 없음 Type Families - 원문 없음 01 모 노이드 원문: http://en.wikibooks.org/wiki/Haskell/Monoids 소개 예제 함수 일반화하기 하스 켈 정의와 법칙 예시 동형사상(Homomorphism) 더 읽을거리 노트 앞에서 모 노이드와 Monoid 타입 클래스를 지나가듯 언급했었다(특히 MonadPlus를 논할 때). 여기서는 이것들을 자세하게 살펴보고 어떤 점이 유용한지 살펴본다. 소개 모 노이드(m, mappend, mempty)는 m 타입으로서, 두 원소를 합성하는 결합성 연산 mappend :: m -> m -> m(하스켈에선 (<>)라고도 부름) 그리고 mappend의 중립 원인 영원 mempty :: m을 가진다. 이것들을 보다 공식적으로 정의하기 전에 실전에서의 모 노이드를 보자. 예제 맛보기로 다음의 흔한 패턴을 보자. > (5 + 6) + 10 == 5 + (6 + 10) True > (5 * 6) * 10 == 5 * (6 * 10) True > ("Hello" ++ " ") ++ "world!" == "Hello" ++ (" " ++ "world!") True 이 성질은 결합성(associativity)이라는 것으로, 위의 특정 값들에만 성립하는 것이 아니라 덧셈 하 모든 정수에, 곱셈 하 모든 정수에, 결합 하 모든 리스트에 성립한다. 이것은 또 다른 종류의 패턴이다. > 255 + 0 == 255 && 0 + 255 == 255 True > 255 * 1 == 255 && 1 * 255 == 255 True > [1,2,3] ++ [] == [1,2,3] && [] ++ [1,2,3] == [1,2,3] True 여기서 0은 정수를 더할 때의 항등원, 1은 곱할 때의 항등원, []는 두 리스트를 이어붙일 때의 항등원이다. 따라서, 정수는 덧셈 하에 모 노이드를 형성하며 0이 단위원이다. (Integer, (+), 0) 정수는 곱셈 하에 모 노이드를 형성하며 1이 단위원이다. (Integer, (*), 1) 리스트는 결합 하에 모 노이드를 형성한다. ([a], (++), []) 정수가 두 개별 연산 하에 모 노이드를 형성하기 때문에 두 개의 새로운 데이터 타입을 만든다. Sum은 덧셈, Product는 곱셈을 위한 것이다. > import Data.Monoid > Sum 5 <> Sum 6 <> Sum 10 Sum {getSum = 21} > mconcat [Sum 5, Sum 6, Sum 10] Sum {getSum = 21} > getSum $ mconcat $ map Sum [5, 6, 10] 21 > getProduct $ mconcat $ map Product [5, 6, 10] 300 > mconcat ["5", "6", "10"] "5610" 이게 어디가 유용하단 걸까? 함수 일반화하기 세 리스트를 연결하는 다음 함수를 보자. threeConcat :: [a] -> [a] -> [a] -> [a] threeConcat a b c = a ++ b ++ c 이 함수가 임의의 모 노이드에 대해 작동하도록 일반화할 수 있다. threeConcat' :: Monoid m => m -> m -> m -> m threeConcat' a b c = a <> b <> c -- > threeConcat' "Hello" " " "world!" -- "Hello world!" -- > threeConcat' (Sum 5) (Sum 6) (Sum 10) -- Sum {getSum = 21} Data.Foldable의 fold :: (Foldable t, Monoid m) => t m -> m 같은 타 함수들은 모 노이드의 성질을 이용하여 모 노이드를 포함하는 임의의 접기 가능한 구조를 단일 모노이드성 값으로 환원한다. > fold ["Hello", " ", "world!"] "Hello world!" > fold (Just (Sum 10)) Sum {getSum = 10} > fold Nothing :: Sum Integer Sum {getSum = 0} 이런 식이라면, 우리만의 모노이드성 데이터 타입을 포함하는 컨테이너(트리 같은)를 만들었을 때 fold 같은 이미 정의된 함수들을 즉시 활용할 수 있게 된다. 연습문제 Integer에 대해, 덧셈 대신 곱셈을 합성 연산으로 쓰는 제2의 Monoid 인스턴스가 있을 수 있다. 그 인스턴스를 구현하라. 1 mempty와 mappend를 mconcat을 이용해서 정의하는 게 가능하다. 그 정의를 작성하라. 여러분의 정의가 위의 법칙들을 자동으로 만족하는지 확인해 보라. 하스 켈 정의와 법칙 Data.Monoid의 Monoid 타입 클래스는 이 일반화 개념을 포착한 것이다. class Monoid a where mempty :: a mappend :: a -> a -> a mconcat :: [a] -> a mconcat = foldr mappend mempty 세 번째 메서드인 mconcat은 기본 구현인 mconcat = foldr (++) []가 제공되는데 리스트의 concat과 동등한 것이다. 리스트에 대한 인스턴스는 다음과 같이 정의된다. instance Monoid [a] where mempty = [] mappend = (++) 모 노이드를 덧붙임(appending)을 지원하는 타입으로 생각하는 게 적당하다. (Monoid 정의가 극도로 포괄적이고 자료구조에 한정된 게 아니라서 시적 허용이 필요하지만. 그래서 "덧붙임"은 어떤 경우에는 비유적인 뜻이 된다) 예를 들어 정수는 덧셈을 "덧붙임"으로서, 0을 영원으로서 가지는 모 노이드를 형성한다. -- | Monoid under addition. newtype Sum a = Sum { getSum :: a } -- | Monoid under multiplication. newtype Product a = Product { getProduct :: a } instance Num a => Monoid (Sum a) where mempty = Sum 0 Sum x `mappend` Sum y = Sum (x + y) instance Num a => Monoid (Product a) where mempty = Product 1 Product x `mappend` Product y = Product (x * y) Monoid의 모든 인스턴스가 따라야 하는 법칙은 앞서 언급한 중립원과 결합 성질에 대응한다. mempty <> x = x x <> mempty = x x <> (y <> z) = (x <> y) <> z Monoid 클래스는 Data.Monoid에 많은 공용 타입들에 대한 인스턴스와 함께 정의되어 있다. 예시 이렇게 이름도 어려운데 모노이드는 평이하고 지루해 보인다. 그런 인상에 잘못 이끌리지 않기를. 모노이드는 여러 흥미로운 응용법이 있다. Writer 모나드 Write w a 타입의 계산(computation)은 w 타입의 누적되는 출력을 생산하는 동시에 a 타입의 값을 반환한다. w는 Monoid의 인스턴스이고 Writer 모나드의 bind 연산자는 출력을 누적하기 위해 mappend를 사용한다. w를 일종의 기록을 위해 쓰는 리스트 타입으로 볼 수 있다. 하지만 Monoid 클래스의 일반성 덕분에 어떤 모 노이드 인스턴스도 사용할 수 있어서 많은 가능성이 열린다. Foldable 클래스 Data.Foldable에서 찾을 수 있는 Foldable은 리스트 접기 함수를(그리고 Data.List와 관련된 많은 것을) 타 자료구조들로 일반화하는 간편한 수단을 제공한다. 2 Data.Foldable의 구현은 모 노이드를 활용하여 자료구조 내의 원소들로부터 모노이드성 값을 생성하고, 그러고 나면 mappend로 쉽게 합성할 수 있다. Fodable은 Traversable 클래스(Data.Traversable에 들어있음)의 정의에서 또 다른 역할을 수행한다. Traversable은 Control.Monad의 sequence를 일반화한다. 핑거 트리 자료구조에 대한 연산에서 자료구조의 구현으로 자리를 옮겨보면, 모노이드는 효율적이고 다재다능한 핑거 트리를 구현하는 데 쓸 수 있다. 그 구현은 모노이드성 값을 트리 노드의 태그로 활용한다. 그리고 수반되는 Monoid 인스턴스만 교체하면 여러 자료구조(시퀀스, 우선순위 큐, 검색 트리 등)를 얻을 수 있다. 3 옵션과 환경설정 완전히 다른 문맥에서, 모노이드는 응용 프로그램의 옵션과 환경설정을 다루는 편리한 수단이다. 두 가지 예는 하스켈의 패키징 시스템인 Cabal("패키지 데이터베이스는 모 노이드다. 설정 파일은 모 노이드다. 명령 줄 플래그와 명렁줄 플래그의 집합은 모 노이드다. 하스 켈 빌드 정보는 모 노이드다."[1]) 그리고 하스 켈로 구현한 타일링 윈도 매니저인 XMonad("xmonad configuration hook은 모노이드성이다."[2])이다. 동형사상(Homomorphism) 두 모 노이드 a와 b 사이의 함수 f :: a -> b가 그 모 노이드 구조를 보존한다면, 이 함수를 동형사상이라고 부른다. 그러니까, f mempty = mempty f (x `mappend` y) = f x `mappend` f y 가령 length는 ([],++)와 (Int,+) 사이에서 동형사상이다. length [] = 0 length (xs ++ ys) = length x + length y 모 노이드와 동형사상의 "실전에서 나타나는" 흥미로운 예시를 Google Protocol Buffers API 문서에서 Chris Kuklewicz가 발견했다. 이 글의 인용문에 기초해, (파이썬의) 다음 성질을 보자. MyMessage message; message.ParseFromString(str1 + str2); 이는 다음과 동등한데 MyMessage message, message2; message.ParseFromString(str1); message2.ParseFromString(str2); message.MergeFrom(message2); ParseFromString이 동형사상임을 뜻한다. 하스켈과 모노이드로 번역해 보면, 다음 등식들이 성립한다. parse :: String -> Message -- these are just equations, not actual code. parse [] = mempty parse (xs ++ ys) = parse xs `merge` parse ys 파싱은 실패할 수도 있기 때문에 완벽히 성립하진 않지만, 대략 그렇다는 것이다. 더 읽을거리 모 노이드에 대한 Dan Pipone (Sigfpe)의 블로그 글 그리고 결합법칙의 본성에 관한 견해 모 노이드 관련 링크들 핑거 트리에 관한 추가 견해: FingerTrees. Cabal에서의 Monoid 사용에 관한 추가 견해: [3], [4]. 노트 Data.Monoid에 대한 문서를 확인해 보면 Num 타입에 대해 두 인스턴스 모두 정의되어 있는 걸 볼 수 있다. 둘 다 newtype 래퍼가 있지만. ↩ 이런 식의 접기는 다른 자료구조들에서 논의한 그 접기와 다르다는 것에 유의하라. ↩ Ralf Hinze와 Ross PattersonRalf의 논문에 기초한 이 블로그 글은 모 노이드가 핑거 트리에서 어떻게 쓰이는가에 관해 간결하고도 알기 쉬운 설명을 담고 있다. ↩ 02 적용성 펑 터 원문: http://en.wikibooks.org/wiki/Haskell/Applicative_Functors 펑 터 작용성 펑 터 인스턴스 적용성 펑 터 사용하기 모나드와 적용성 펑 터 ZipLists 참고 자료 적용성 펑 터(applicative functor)는 추가적인 성질을 가진 펑터다. 가장 중요한 것은 펑 터 내부의 함수를 적용하는 게 가능하다는 것이다(그래서 이름이 이렇다). 펑 터 펑터들(즉 Functor 타입 클래스의 인스턴스들)은 "사상(map) 할 수 있는" 구조체다. 다음은 Functor의 클래스 정의다. class Functor f where fmap :: (a -> b) -> f a -> f b 가장 잘 알려진 펑터는 리스트로, fmap이 map에 상응한다. 또 다른 예는 Maybe이다. instance Functor Maybe where fmap f (Just x) = Just (f x) fmap _ Nothing = Nothing 통상적으로 모든 트리 비슷한 구조체에 대해 Functor의 인스턴스를 작성할 수 있다. 연습문제 다음 타입들에 대해 Functor의 인스턴스를 정의하라. 장미 나무 타입의 Tree. 다음과 같이 정의된다. data Tree a = Node a [Tree a] 고정된 e에 대한 Either e. 함수 타입 ((->) t). 이 경우 f a는 (t -> a)가 될 것이다. 작용성 펑 터 class (Functor f) => Applicative f where pure :: a -> f a (<*>) :: f (a -> b) -> f a -> f b pure 함수는 임의 값을 펑 터 내부로 전이시킨다. (<*>)는 펑 터 내부의 함수를 펑터의 값에 대한 함수로 변경한다. 이 펑터는 몇 가지 법칙을 만족해야 한다. pure id <*> v = v -- 항등 법칙(Identity) pure (.) <*> u <*> v <*> w = u <*> (v <*> w) -- 결합법칙(Composition) pure f <*> pure x = pure (f x) -- 동형사상(Homomorphism) u <*> pure y = pure ($ y) <*> u -- 교환법칙(Interchange) 그리고 Functor 인스턴스는 다음 법칙을 만족해야 한다. fmap f x = pure f <*> x -- Fmap 인스턴스 Maybe의 Functor 인스턴스를 본 적이 있으니 이번에는 Maybe를 Applicative로 만들어보자. pure의 정의는 쉽다. Just이다. (<*>)의 정의는 이렇다. 두 인자 중 하나라도 Nothing 이면 결과는 Nothing이다. 그 외의 경우 두 Just 값으로부터 함수와 그 인자를 뽑아내 인자에 그 함수가 적용된 Just를 반환한다. instance Applicative Maybe where pure = Just (Just f) <*> (Just x) = Just (f x) _ <*> _ = Nothing 연습문제 Applicative의 법칙이 이 Maybe에 대한 인스턴스에 성립함을 보여라. 다음에 대한 Applicative 인스턴스를 작성하라. 고정된 e에 대한 Either e 고정된 t에 대한 ((->) t) 적용성 펑 터 사용하기 당장은 (<*>)를 어디에 쓸지 명확하지 않으니 여러분이 겪었을 수도 있는 몇 가지 예시를 살펴보자. 다음 함수를 가정하자. f :: Int -> Int -> Int f x y = 2 * x + y 그런데 Int들 대신 Maybe Int 타입에 이 함수를 적용하고 싶다. 전에 이 문제를 봤기 때문에 fmap2라는 함수를 작성하기로 결정한다. fmap2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c fmap2 f (Just x) (Just y) = Just (f x y) fmap2 _ _ _ = Nothing 잠깐은 행복하지만 이러면 인자가 많아진다. 어떻게 일반화할까? (<*>)가 필요하다, fmap f를 작성하면 어떤 일이 벌어지는지 보자. f :: (a -> b -> c) fmap :: Functor f => (d -> e) -> f d -> f e fmap f :: Functor f => f a -> f (b -> c) -- Identify d with a, and e with (b -> c) 이제 (<*>)의 용법이 명확하다. f (b -> c)가 있으면 (f b -> f c)를 얻을 수 있다. 이에 더해 fmap2 f a b = f `fmap` a <*> b fmap3 f a b c = f `fmap` a <*> b <*> c fmap4 f a b c d = f `fmap` a <*> b <*> c <*> d 이를 더 깔쌈하게 만들기 위해 Control.Applicative 라이브러리는 (<$>)를 fmap의 동의어로 정의한다. 결과적으로 코드는 읽기 더 깔끔하고 적용, 재사용하기가 쉬워진다. fmap2 f a b = f <$> a <*> b fmap3 f a b c = f <$> a <*> b <*> c fmap4 f a b c d = f <$> a <*> b <*> c <*> d 다른 개수의 인자들을 수용하는 또 다른 고차 함수들을 정의해야 할 때면 Applicative의 적당한 인스턴스를 정의해서 여러분의 삶을 편하게 만들 수 있다는 걸 떠올려라. 물론 Control.Applicative)는 위의 함수들을 편의를 위해 liftA와 liftA3라는 이름으로 제공한다. 모나드와 적용성 펑 터 pure의 타입이 어딘가 익숙하다. 이것의 타입 클래스 제한을 이것으로부터 Applicative f => a -> f a 다음과 같이 바꾸면 Monad m => a -> m a return과 정확히 같은 타입을 가진다. 사실은 Monad의 모든 인스턴스는 Applicative의 인스턴스로 만들 수 있다. 다음은 활용할 수 있는 정의들이다. pure = return (<*>) = ap 여기서 ap는 다음과 같이 정의된다. ap f a = do f' <- f a' <- a return (f' a') Control.Monad에도 정의되어 있다. 연습문제 Maybe의 Applicative 인스턴스를 위의 변환을 통해 얻을 수 있음을 확인하라. ZipLists Applicative가 삶을 편하게 만들어 준다는 발상으로 돌아오자. 아마 가장 잘 알려진 예가 Data.List의 zipWIthN 함수들일 것이다. 적용성 펑터가 유용할 만한 종류의 패턴을 보인다. 기술적인 이유 때문에 []의 Applicative 인스턴스는 정의할 수 없다. 이미 정의되어 있기 때문이다. 이 인스턴스는 완전히 다른 작업을 한다. fs <*> xs는 fs의 모든 함수를 취해 xs의 모든 값에 적용한다. 이를 처리하기 위해 래퍼를 만든다. newtype ZipList a = ZipList [a] instance Functor ZipList where fmap f (ZipList xs) = ZipList (map f xs) 이것을 예상된 행동을 하는 Applicative의 인스턴스로 만들려면 먼저 (<*>)의 정의를 봐야 한다. 우리가 하려는 것으로부터 상당히 직관적으로 따라나오기 때문이다. (<*>) 연산자는 함수의 리스트와 값의 리스트를 취해서 함수들과 값들을 짝지어 적용해야 한다. 마치 zipWith ($)처럼 들린다. ZipList 래퍼만 추가하면 된다. instance Applicative ZipList where (ZipList fs) <*> (ZipList xs) = ZipList $ zipWith ($) fs xs pure = undefined 이제 pure만 정의하면 된다. 이렇게 정의하면 pure x = ZipList [x] 항등 법칙 pure id <*> v = v을 만족하지 않는다. v가 하나보다 많은 원소를 포함하고 zipWith는 두 입력 중 크기가 작은 것의 리스트만을 반환하기 때문이다. v가 얼마나 많은 원소를 가질지 모르기 때문에 가장 안전한 방법은 pure가 무한 원소의 리스트를 반환하도록 만드는 것이다. 이제 우리의 인스턴스 선언이 완성되었다. instance Applicative ZipList where (ZipList fs) <*> (ZipList xs) = ZipList (zipWith ($) fs xs) pure x = ZipList (repeat x) 참고 자료 Control.Applicative 03 Foldable 원문: https://en.wikibooks.org/wiki/Haskell/Foldable foldr 해부 Foldable 클래스 리스트 같은 folding Foldable에 대한 추가 사실들 노트 Foldable 타입 클래스는 리스트 접기(foldr 류)와 그로부터 파생된 연산들을 임의 자료구조에 대해 일반화한 것이다. Foldable은 매우 유용하며 또한 모 노이드가 좋은 추상화의 공식화를 어떻게 돕는지 보여주는 훌륭한 예시다. foldr 해부 foldr은 어지간히 복잡한 함수다. 첫 번째 함수 화살표의 양쪽에는 이항 함수가 있으며 각각의 타입들은 두 변수를 사용한다. foldr :: (a -> b -> b) -> b -> [a] -> b foldr을 일반화하려면 좀 더 다루기 쉽거나, 최소한 간단한 성분들로 분해할 수 있는 것이 있으면 좀 더 편리할 것 같다. 그 성분들은 어떤 모습일까? 대강 설명하자면 리스트 접기는 리스트 요소들을 훑어서 이항 함수를 통해 합성한다. 우리는 온전히 값의 짝을 합성하는 것에 관한 타입 클래스를 하나 알고 있다. 바로 Monoid다. 다음의 fold r z에서 a `f` (b `f` (c `f` z)) -- foldr f z [a, b, c] f = (<>) 그리고 (z = mempty)으로 바꾸면 a <> (b <> (c <> mempty)) -- foldr (<>) mempty [a, b, c] mconcat = foldr mappend mempty을 얻는다. foldr보다 간단하며 구체적이다. 합성 함수와 초기 누적값을 명시할 필요도 없다. mappend(즉 (<>))와 mempty를 썼기 때문이다. mconcat :: Monoid m => [m] -> m mconcat은 모든 원소를 합성한다는 foldr의 개념을 잘 포착하며 foldr의 몇 가지 용법을 포함한다. GHCi> mconcat ["Tree", "fingers"] -- concat "Treefingers" 훌륭하다. 하지만 우리는 Monoid 인스턴스만 접는 것으로 끝내고 싶지 않다. 원소들을 어떤 Monoid 타입으로 바꾸는 함수가 있다면, mconcat을 사용해 임의 타입의 원소들의 리스트를 접을 수 있음을 깨닫는다면 이 상황을 타개할 수 있다. foldMap :: Monoid m => (a -> m) -> [a] -> m foldMap g = mconcat . fmap g 이러면 상황이 좀 더 흥미로워진다. GHCi> foldMap Sum [1.. 10] Sum {getSum = 55} 지금까진 좋다. 하지만 여전히 임의의 합성 함수를 이용해 접는 것은 불가능하다. 그런데 foldr 시그너처에 맞는 모든 이항 함수는 값을 Monoid 타입으로 변환하는 데 쓸 수 있다! 비결은 foldr에 전달되는 합성 함수를 단항 함수로서 보는 것이다. foldr :: (a -> (b -> b)) -> b -> [a] -> b 그리고 b -> b 꼴 함수가 합성 하에서 (.)는 mappend, id는 mempty로서 모 노이드를 형성한다는 사실을 이용한다. 1 대응하는 Monoid 인스턴스는 Data.Monoid의 Endo 래퍼를 통해 얻을 수 있다.2 newtype Endo b = Endo { appEndo :: b -> b } instance Monoid Endo where mempty = Endo id Endo g `mappend` Endo f = Endo (g . f) 이제 다음을 정의할 수 있다. foldComposing :: (a -> (b -> b)) -> [a] -> Endo b foldComposing f = foldMap (Endo . f) 이 함수는 b -> b 함수를 각 원소에 적용해 전부 합성한다. Endo (f a) <> (Endo (f b) <> (Endo (f c) <> (Endo id))) -- foldComposing f [a, b, c] Endo (f a. (f b. (f c. id))) -- (<>) and (.) are associative, so we don't actually need the parentheses. -- As an example, here is a step-by-step evaluation: foldComposing (+) [1, 2, 3] foldMap (Endo . (+)) [1, 2, 3] mconcat (fmap (Endo . (+)) [1, 2, 3]) mconcat (fmap Endo [(+1), (+2), (+3)]) mconcat [Endo (+1), Endo (+2), Endo (+3)] Endo ((+1) . (+2) . (+3)) Endo (+6) 이 함수를 임의의 b 값에 적용하면... foldr :: (a -> (b -> b)) -> b -> [a] -> b foldr f z xs = appEndo (foldComposing f xs) z foldr을 다시 얻게 된다. 즉 foldMap으로 foldr을 정의할 수 있다는 것이다. foldMap이 더 간단하고 따라서 이해하기 더 쉽기 때문에 foldMap은, foldr을 임의의 자료 구조로 일반화하는 Foldable 클래스의 핵심이다. 연습문제 리스트에 대한 foldMap의 두 가지 구현을 작성하라. 하나는 foldr을 이용하여, 하나는 명시적인 재귀만을 사용하라. Foldable 클래스 어떤 자료구조에 대한 Foldable을 구현하려면 foldMap 또는 foldr 중 하나만 구현하면 된다. 하지만 Foldable에는 다른 메서드가 많이 있다. -- 메서드 시그너처만 있는 요약된 정의 class Foldable t where foldMap :: Monoid m => (a -> m) -> t a -> m foldr :: (a -> b -> b) -> b -> t a -> b -- 모두 기본 구현이 있다 fold :: Monoid m => t m -> m -- 일반화된 mconcat foldr' :: (a -> b -> b) -> b -> t a -> b foldl :: (b -> a -> b) -> b -> t a -> b foldl' :: (b -> a -> b) -> b -> t a -> b foldr1 :: (a -> a -> a) -> t a -> a foldl1 :: (a -> a -> a) -> t a -> a toList :: t a -> [a] null :: t a -> Bool length :: t a -> Int elem :: Eq a => a -> t a -> Bool maximum :: Ord a => t a -> a minimum :: Ord a => t a -> a sum :: Num a => t a -> a product :: Num a => t a -> a 부가 메서드들은 필요하면 더 효율적인 구현을 작성할 수 있도록 되어있다. 어쨌든 foldMap 또는 foldr만 작성하면 위에 나열된 유용한 함수들을 모두 공짜로 얻을 수 있다. 심지어 Data.Foldable은 모든 Foldable에 대해 일반화된 mapM_, traverse_ 등의 함수들을 제공한다. 다음은 Foldable에 대한 짧은 데모로서 Data.Map을 이용한 것이다.3 GHCi> import qualified Data.Map as M GHCi> let testMap = M.fromList $ zip [0..] ["Yesterday","I","woke","up","sucking","a","lemon"] GHCi> length testMap GHCi> sum . fmap length $ testMap 29 GHCi> elem "lemon" testMap True GHCi> foldr1 (\x y -> x ++ (' ' : y)) testMap -- Be careful: foldr1 is partial! "Yesterday I woke up sucking a lemon" GHCi> import Data.Foldable GHCi> traverse_ putStrLn testMap Yesterday woke up sucking lemon 유용한 일반화를 넘어서 Foldable과 foldMap은 fold에 대해 더 선언적으로 생각하는 방법을 제안한다. 가령 sum을 리스트(트리나 그 외 어떤 자료구조건)를 훑으며 원소들을 (+)로 누적하는 함수로 보는 대신, sum이 각각의 원소의 값을 질의하고 질의의 결과들을 Sum 모 노이드를 이용해 요약한다고 볼 수 있다. 사소한 차이로 보이겠지만 모 노이드 관점은 fold가 수반된 문제에서 우리가 어떤 종류의 결과를 얻으려는가와 fold 되는 자료구조의 세부사항을 분리하여 상황을 명료하게 만든다. 연습문제 모 노이드 파헤치기 놀이! 규칙은 다음과 같다. 각 함수에 대해 mempty, mappend, 그리고 필요하다면 fold나 foldMap으로 구현될, 값들을 준비하는 함수의 조합을 제안하라. newtype 인스턴스로 골치를 앓을 필요는 없다. (여러분의 해답을 foldMap으로 시험해 볼 생각이 아니라면) 예를 들어 "mempty는 0이고 mappend는 (+)이다"라는 sum에 대한 답으로 완벽히 수용된다. 필요하다면 함수들을 부분 적용하고 공급된 인자들을 해답에 사용할 수 있다. 모든 질문에 id와 (.)으로 답하지 말 것 - 꼼수는 안 된다! 힌트: Data.Monoid의 Monoid 인스턴스들을 볼 것. a. product :: (Foldable t, Num a) => t a -> a b. concat :: Foldable t => t [a] -> [a] c. concatMap :: Foldable t => (a -> [b]) -> t a -> [b] d. all :: Foldable t => (a -> Bool) -> t a -> Bool e. elem :: Eq a => a -> t a -> Bool f. length :: t a -> Int g. traverse_ :: (Foldable t, Applicative f) => ‌(a -> f b) -> t a -> f () h. mapM_ :: (Foldable t, Monad m) => ‌(a -> m b) -> t a -> m () i. safeMaximum :: Ord a => t a -> Maybe a (like maximum, but handling emptiness.) j. find :: Foldable t => (a -> Bool) -> t a -> Maybe a k. composeL :: Foldable t => (b -> a -> b) -> t a -> b -> b (foldl과 동일) 리스트 같은 folding Foldable에는 toList :: Foldable t => t a -> [a]이 들어있다. 즉 어떤 Foldable 자료 구조든 리스트로 변환할 수 있다. 게다가 그 리스트를 접으면 원래 구조를 직접 접는 것과 같은 결과가 나온다. foldMap을 이용한 toList 구현은 아마 이럴 것이다. 4 toList = foldMap (\x -> [x]) toList는 리스트가 하스 켈 타입에 대한 자유 모노이더라는 사실을 반영한다. 여기서 "자유"는 어떤 값이든 정보를 추가하거나 없애지 않고 모노이드로 변환할 수 있음을 뜻한다. 5 (우리는 a 타입의 값을 원소가 하나인 [a] 리스트로 변환하고 (\x->[x])와 head로 손실 없이 되돌릴 수 있다) 이와 관련된 중요한 특성은 toList에 의해 명백해진다. 리스트의 경우 toList = id이기 때문에 다음과 같은 함수를 정의하면 -- Given a list xs :: [a] xsAsFoldMap :: Monoid m => (a -> m) -> m xsAsFoldMap = \f -> foldMap f xs xsAsFoldMap에 (x -> [x])를 넘겨 항상 기존 리스트 xs를 복구하는 것이 가능하다. 이런 식이면 리스트는 그것의 오른쪽 접기와 동치가 된다. 즉 Foldable 연산을 통한 접기는 데이터가 리스트보다 복잡하면 어쩔 수 없이 손실 연산이 된다. 달리 보면 Foldable이 제공하는 리스트류의 접기는 다른 자료구조들에서 본 것과 같은 접기(공식 용어는 catamorphism)보다 덜 일반적이고, 기존 구조를 재구축하는 것이 가능해진다. 연습문제 다른 자료구조들에서 사용한 트리 타입에 대해 data Tree a = Leaf a | Branch (Tree a) (Tree a) a. Tree에 대한 Foldable 인스턴스를 작성해 보자. b. treeDepth :: Tree a -> Int를 구현해 보자. 루트에서 가장 먼 잎까지 도달하는 데 필요한 가지의 개수를 반환한다. Foldable 또는 다른 자료구조들에서 정의한 treeFold를 사용해 보자. 두 방법이 모두 가능할까? Foldable에 대한 추가 사실들 Foldable은 원칙에 입각이고 범용적이어서, 그 자체로는 목적이 없는 하스 켈 클래스들 사이에서 조금 이례적이다. 가장 비슷한 것은 다음과 같은 성질로, 엄밀히 말하면 법칙이 아니다(어떤 인스턴스에 대해서도 성립하기 때문에). 어떤 모 노이드 동형사상 g에 대해 foldMap (g . f) = g. foldMap f foldMap (g . f)를 g. foldMap f로 바꾸면 g를 자료구조 내의 모든 가능한 원소에 대해서가 아니라 접기의 결과에만 적용하기 때문에 이익이다. Foldable 구조가 Functor이기도 하다면, 다음도 자동으로 성립한다. foldMap f = fold . fmap f ...그리고 펑 터 제2 법칙과 위의 성질을 적용하면 다음을 얻는다. foldMap g. fmap f = foldMap (g . f) = g. foldMap f foldMap 같은 메서드가 있다는 것이 어떤 Foldable 타입이든 Functor 인스턴스를 가져야 함을 암시하기는 하지만, Functor가 Foldable의 상위 클래스인 것은 아니다. 따라서 어떤 Foldable 인스턴스가 어떤 이유에서건 Functor가 아닐 수도 있다. 가장 흔한 예가 Data.Set의 sets다. 이들 집합의 원소 타입은 Ord의 인스턴스여야 하고, 따라서 이것들의 map 함수는 fmap으로 쓰일 수 없다. fmap은 부수적인 클래스 제한이 없기 때문이다. 하지만 여전히 Data.Set.Set은 유용한 Foldable 인스턴스다. GHCi> import qualified Data.Set as S GHCi> let testSet = S.fromList [1,3,2,5,5,0] GHCi> testSet fromList [0,1,2,3,5] GHCi> import Data.Foldable GHCi> toList testSet [0,1,2,3,5] GHCi> foldMap show testSet "01235" 연습문제 a. 짝에 대한 모 노이드 인스턴스를 작성해 보자. (Monoid a, Monoid b) => Monoid (a, b) b. fst와 snd가 모 노이드 동형사상임을 증명해 보자. c. foldMap의 모 노이드 동형사상 속성을 이용하여 다음을 증명해 보자. foldMap f &&& foldMap g = foldMap (f &&& g) 여기서 f &&& g = \x -> (f x, g x) 이 연습문제는 Edward Kmett이 제안한 것이다. 노트 이 기법은 고차 함수 끝부분에서 foldl에 관한 연습문제를 풀어봤다면 익숙할 것이다. ↩ "Endo"는 "내부 사상 endomorphism"의 줄임말로, 한 타입에서 다른 타입으로 사상하는 함수를 일컫는 은어다. ↩ Data.Map과 다른 유용한 자료 구조 구현에 대한 정보는 data structures primer를 보자. ↩ Data.Foldable은 수행능력 때문에 기본 구현이 이와 다르다. ↩ 리스트가 자유 모 노이드를 형성한다고 말할 때는 비종결(non-termination)에 관해 주의할 점이 하나 있다. Dan Doel이 쓴 Free Monoids in Haskell를 읽어보자. (이 글의 논의는 꽤 전문적이므로 지금 막 Foldable을 알게 되었다면 그리 재밌지 않을 수 있다.) ↩ 소스(하스 켈 카페) 1 ↩ 04 Traversable 원문: https://en.wikibooks.org/wiki/Haskell/Traversable 순회를 위한 Functor들 Traversable의 여러 해석 Traversable 법칙들 fmap과 foldMap 되살리기 Prelude에는 자료 구조를 조작하기 위한 타입 클래스가 5개 있는데, Functor, Applicative, Monad, Foldable는 이미 알아봤다. 마지막은 Traversable이다.1 순회(traverse)는 걸어 지나간다는 뜻이고, Traversable은 바로 이 일을 일반화한다. 자료 구조를 걸어 지나가서, 멈출 때마다 그 결과를 수집한다. 순회를 위한 Functor들 순회가 걸어 지나가기를 의미한다면 우리는 이미 순회를 하고 있던 셈이다. 리스트에 대한 Functor와 Foldable 인스턴스를 보자. instance Functor [] where fmap _ [] = [] fmap f (x:xs) = f x : fmap f xs instance Foldable [] where foldMap _ [] = mempty foldMap f (x:xs) = f x <> foldMap f xs fmap f는 리스트를 걸어 지나가 각 원소에 f를 적용하고 그 결과를 모아 리스트를 재구축한다. 비슷하게 foldMap f는 리스트를 걸어 지나가 f를 각 원소에 적용하고 그 결과를 모아 mappend로 결합한다. 하지만 Functor와 Foldable만으로는 모든 유용한 순회 방법을 표현할 수 없다. 음수를 검사해서 Maybe로 인코딩하는 다음 함수를 보자. deleteIfNegative :: (Num a, Ord a) => a -> Maybe a deleteIfNegative x = if x < 0 then Nothing else Just x 이 deleteIfNegative을 다음 함수를 구현하는 데 쓰려고 한다. rejectWithNegatives :: (Num a, Ord a) => [a] -> Maybe [a] 이 함수는 음수가 하나도 없으면 원래 리스트를 Just로 감싸서 반환하고, 아니면 Nothing을 반환한다. Foldable이나 Functor는 도움이 되지 않는다. Foldable을 사용하면 기존 리스트의 구조를, 우리가 접기를 위해 선택한 Monoid의 구조로 대체하게 되는데, 이것을 원래 리스트나 Nothing으로 변환할 방법이 없다. 2 Functor의 경우 fmap으로 될 것 같지만... GHCi> let testList = [-5,3,2, -1,0] GHCi> fmap deleteIfNegative testList [Nothing, Just 3, Just 2, Nothing, Just 0] 이러면 Maybe들의 리스트를 하나의 Maybe 리스트로 변환해야 한다. 잘 보면 접기처럼 보인다. 하지만 우리는 값들을 결합하고 리스트를 파괴하는 것이 아니라, 값들의 Maybe 문맥들을 결합해 그 결합 문맥 안에서 리스트 구조를 재생성해야 한다. 다행히도 Functor 문맥을 결합하는 것에 대한 타입 클래스가 있다. 바로 Applicative다. 3 Applicative는 우리에게 필요한 클래스인 Traversable를 이끌어낸다. instance Traversable [] where -- sequenceA :: Applicative f => [f a] -> f [a] sequenceA [] = pure [] sequenceA (u:us) = (:) <$> u <*> sequenceA us -- 또는 다음과 동치: instance Traversable [] where sequenceA us = foldr (\u v -> (:) <$> u <*> v) (pure []) us Traversable과 Applicative 문맥의 관계는 Foldable과 Monoid 값의 관계와 비슷하다. 이런 관점에서 sequenceA는 fold와 유사하다. sequenceA는 한 구조 내에서 문맥의 적용 합산(applicative summary)을 생성하고, 그 구조를 새로운 문맥에서 재구축한다. 우리가 찾던 그 함수다. GHCi> let rejectWithNegatives = sequenceA . fmap deleteIfNegative GHCi> :t rejectWithNegatives rejectWithNegatives :: (Num a, Ord a, Traversable t) => t a -> Maybe (t a) GHCi> rejectWithNegatives testList Nothing GHCi> rejectWithNegatives [0.. 10] Just [0,1,2,3,4,5,6,7,8,9,10] 다음은 Traversable의 메서드 들이다. class (Functor t, Foldable t) => Traversable t where traverse :: Applicative f => (a -> f b) -> t a -> f (t b) sequenceA :: Applicative f => t (f a) -> f (t a) -- These methods have default definitions. -- They are merely specialised versions of the other two. mapM :: Monad m => (a -> m b) -> t a -> m (t b) sequence :: Monad m => t (m a) -> m (t a) sequenceA가 fold와 비슷하다면 traverse는 foldMap과 비슷하다. 이 둘은 서로를 이용해 정의할 수 있으므로 Traversable의 최소한의 구현은 둘 중 하나만으로 충분하다. traverse f = sequenceA . fmap f sequenceA = traverse id Traversable의 리스트 인스턴스를 traverse를 이용해 다시 작성해 보면 Functor와 Foldable의 유사성이 더 명백해진다. instance Traversable [] where traverse _ [] = pure [] traverse f (x:xs) = (:) <$> f x <*> traverse f xs -- 또는 다음과 동치: instance Traversable [] where traverse f xs = foldr (\x v -> (:) <$> f x <*> v) (pure []) xs 보통은 Traversable을 구현할 때 traverse를 작성하는 것이 더 좋은데, traverse의 기본 정의는 자료구조를 두 번 걸어가기 때문이다. (한 번은 fmap을 위해, 한 번은 sequenceA를 위해) traverse를 이용해 rejectWithNegatives를 깔끔하게 정의할 수 있다. rejectWithNegatives :: (Num a, Ord a, Traversable t) => t a -> Maybe (t a) rejectWithNegatives = traverse deleteIfNegative 연습문제 다른 자료구조들의 Tree에 대한 Traversable 인스턴스를 작성하라. Tree의 정의는 다음과 같다. data Tree a = Leaf a | Branch (Tree a) (Tree a) Traversable의 여러 해석 우리가 직접 선택한 적용성 펑터를 이용하여 Traversable 구조체들을 순회할 수 있다. traverse의 타입은 이렇다. traverse :: (Applicative f, Traversable t) => (a -> f b) -> t a -> f (t b) 여타 클래스에서 봤던 사상 함수들의 타입과 닮았다. fmap은 함수 인자를 이용해 원래 구조에 펑 터 문맥을 삽입하고, (>>=)는 구조 자체를 수정하지만, traverse는 그 구조의 위에 새로운 문맥층을 더한다. 달리 말하자면 traverse는 영향 있는 순회, 즉 종합적인 결과(문맥의 새로운 바깥 레이어)를 산출하는 순회를 가능케 한다. 새로운 레이어의 기저에 있는 구조를 완전히 복구 가능하다면, 그 구조는 원래 구조와 일치할 것이다(물론 값들은 바뀔 수 있다). 다음은 중첩 리스트의 예시다. GHCi> traverse (\x -> [0.. x]) [0.. 3] [[0,0,0,0],[0,0,0,1],[0,0,0,2],[0,0,0,3],[0,0,1,0],[0,0,1,1] ,[0,0,1,2],[0,0,1,3],[0,0,2,0],[0,0,2,1],[0,0,2,2],[0,0,2,3] ,[0,1,0,0],[0,1,0,1],[0,1,0,2],[0,1,0,3],[0,1,1,0],[0,1,1,1] ,[0,1,1,2],[0,1,1,3],[0,1,2,0],[0,1,2,1],[0,1,2,2],[0,1,2,3] ] 안쪽의 리스트들은 원래 리스트의 구조를 유지하여, 모두 원소를 네 개씩 가진다. 바깥 리스트는 새로운 레이어로, 각각의 원소가 0과 원래 값 사이에 있는 것을 허용하여 비결정성을 도입한다. sequenceA가 어떻게 문맥을 분배하는지에 초점을 맞추어 Traversable을 이해할 수도 있다. GHCi> sequenceA [[1,2,3,4],[5,6,7]] [[1,5],[1,6],[1,7],[2,5],[2,6],[2,7] ,[3,5],[3,6],[3,7],[4,5],[4,6],[4,7] ] 이 예제에서 sequenceA가 이전의 바깥 구조를 새로운 구조 내부에 분배한다고 볼 수 있다. 새로운 안쪽 리스트들은 이전의 바깥 리스트처럼 2개 원소를 가진다. 새로운 바깥 구조는 원소가 12개인 리스트로, 원소가 4개인 리스트와 3개인 리스트를 (<*>)로 결합할 때 예상되는 그대로다. 분배라는 관점의 흥미로운 측면 하나는 왜 어떤 펑터들은 Traversable의 인스턴스를 가질 수 없는가를 이해하는 데 도움이 된다는 것이다. (하나의 IO 액션이나 함수를 어떻게 분배하겠는가?) 연습문제 적용성 펑 터 장을 숙지하면 다음 연습문제들을 풀 때 도움이 될 것이다. 행렬을 중첩 리스트로 표현하는 것을 생각해 보자. 안쪽 리스트들이 행이 된다. Traversable을 사용하여 다음을 구현해 보자. transpose :: [[a]] -> [[a]] 이 함수는 행렬을 전치한다. (즉 행과 열을 맞바꾼다) 이 연습문제에서 행들의 길이가 모두 다른 "가짜 행렬"은 고려하지 않는다. 2. traverse mappend가 하는 일을 설명하라. 3. 적용성 펑 터 집중 조명 시간이다. mapAccumL :: Traversable t =>‌ (a -> b -> (a, c)) -> a -> t b -> (a, t c) 이 타입에서 무언가가 떠오르는가? 적절한 Applicative를 사용하여 이것을 Traversable로 구현해 보자. 첨언하자면 다음은 Data.Traversable 문서의 mapAccumL 설명이다. mapAcuumL 함수는 fmap과 foldl을 결합한 것처럼 작동한다. 함수를 자료구조의 각 원소에 적용하고 누적 인자를 왼쪽에서 오른쪽으로 넘겨 최종 누적값을 새로운 자료구조와 함께 반환한다. Traversable 법칙들 합리적인 Traversable 인스턴스는 일련의 법칙을 만족한다. 다음은 그중 두 가지다. traverse Identity = Identity -- 항등 법칙 traverse (Compose . fmap g. f) = Compose . fmap (traverse g) . traverse f -- 결합법칙 그리고 다음 법칙이 딸려 나온다. -- If t is an applicative homomorphism, then t. traverse f = traverse (t . f) -- naturality 이 법칙들이 썩 자명하지는 않으니 자세히 살펴보자. 마지막 법칙부터 보면 적용성 동형사상(applicative homomorphism)은 Applicative 연산들을 보존하는 함수다. -- Given a choice of f and g, and for any a, t :: (Applicative f, Applicative g) => f a -> g a t (pure x) = pure x t (x <*> y) = t x <*> t y 이 정의가 전에 본 모 노이드 동형사상과 비슷하기도 하거니와 naturality 법칙이 Foldable에 대한 장에서 봤던 foldMap과 모 노이드 동형사상에 대한 성질을 정확히 반영하는 것에 주목하자. 항등 법칙은 Identity라는 더미 펑터를 수반한다. newtype Identity a = Identity { runIdentity :: a } instance Functor Identity where fmap f (Identity x) = Identity (f x) instance Applicative Identity where pure x = Identity x Identity f <*> Identity x = Identity (f x) 이 법칙이 말하는 바는, Identity 생성자를 통한 순회가 하는 일이라고는 그 구조를 Identity로 감싸는 것뿐이라는 것이다. 실상 아무것도 하지 않는 셈이다. (runIdentity로 원래 구조를 자명하게 복구할 수 있기 때문) Identity 생성자는 따라서 항등 순회고, 사실 매우 합리적이다. 결합 법칙은 Compose 펑터를 이용해 서술된다. newtype Compose f g a = Compose { getCompose :: f (g a) } instance (Functor f, Functor g) => Functor (Compose f g) where fmap f (Compose x) = Compose (fmap (fmap f) x) instance (Applicative f, Applicative g) => Applicative (Compose f g) where pure x = Compose (pure (pure x)) Compose f <*> Compose x = Compose ((<*>) <$> f <*> x) Compose는 펑터들의 합성을 수행한다. 두 Functor를 합성하면 하나의 Functor가 되고, 두 Applicative를 합성하면 하나의 Applicative가 된다 4. 그 인스턴스들은 자명한 것들로, 펑 터 레이어를 내려가며 메서드들을 이어준다. 결합법칙은 우리가 두 순회를 별개로 하던지(항등식의 우변), 자료구조를 한 번만 순회하기 위해 합성하던지(좌변) 상관없음을 나타낸다. 이는 펑 터 제2 법칙과 비슷하다. fmap이 필요한 이유는 두 번째 순회가(또는 좌변에서는 순회의 두 번째 부분) 첫 번째 부분에 의해 추가된 구조의 계층 밑에서 일어나기 때문이다. Compose는 합성된 순회가 올바른 계층에 적용되기 위해 필요하다. Identity와 Compose는 각각 Data.Functor.Identity와 Data.Functor.Compose에서 찾을 수 있다. 이 법칙들을 sequenceA를 이용해 공식화할 수 있다. sequenceA . fmap Identity = Identity -- identity sequenceA . fmap Compose = Compose . fmap sequenceA . sequenceA -- composition -- For any applicative homomorphism t: t. sequenceA = sequenceA . fmap t -- naturality 당장 와닿지는 않지만 5, 순회의 몇 가지 유익한 특징이 이 법칙들로부터 나온다. 순회는 원소들을 건너뛰지 않는다. 순회는 각 원소를 한 번만 방문한다. traverse pure = pure 순회는 기존 구조를 수정할 수 없다(기존 구조는 보존되거나 완전히 파괴된다). fmap과 foldMap 되살리기 아직 Traversable의 Functor와 Foldable 클래스 제약을 정당화하지 않았다. 이유는 아주 간단하다. Traversable 인스턴스가 위의 법칙들을 만족하는 한 fmap과 foldMap을 구현하는 것은 traverse로 충분하다. fmap의 경우 우리가 할 일은 순회를 임의의 함수로 만들기 위해 Identity를 쓰는 것뿐이다. fmap f = runIdentity . traverse (Identity . f) foldMap을 살리려면 세 번째 유틸리티 펑 터인 Const(Control.Applicative에 포함)를 도입해야 한다. newtype Const a b = Const { getConst :: a } instance Functor (Const a) where fmap _ (Const x) = Const x Const는 상수 펑터다. Const a b 타입의 값은 b 값을 포함하지 않는다. 대신 fmap의 영향을 받지 않는 a 값을 보관한다. 우리의 현 목적에서는 진짜로 흥미로운 인스턴스는 Applicative의 것이다. instance Monoid a => Applicative (Const a) where pure _ = Const mempty Const x <*> Const y = Const (x `mappend` y) (<*>)는 각 문맥의 값을 mappend로 합성한다 6. 이를 이용해 순회를 임의의 Monoid m => a -> m 함수로 만들어 foldMap에 전달할 수 있다. 위의 인스턴스 덕에 순회는 접기가 된다. foldMap f = getConst . traverse (Const . f) traverse로부터 겉으로는 완전히 달라 보이는 두 함수를 복구해냈고, 우리가 한 일이라고는 서로 다른 펑 터 두 개를 골랐을 뿐이다. 추상화 펑터는 이렇게 강력하다 7. 엄밀히 말하면 GHC Prelude의 다섯 클래스라고 해야 한다. Haskell Report에 따르면 Applicative, Foldable, Traversable은 Prelude에 공식적으로 포함되지 않는다. 하지만 시간문제일 뿐이다. ↩ Data.Monoid의 Monoid a => Monoid (Maybe a) 인스턴스를 이용하는 건 어떨까? 하지만 실제로 해보면 원하는 결과를 얻을 수 없다. ↩ Applicative의 모 노이드 표현을 보면 명확해진다. ↩ 하지만 두 모나드의 합성이 꼭 모나드는 아님을 기억하라. ↩ 기술적인 세부사항은 Data.Traversable 문서에 인용된 논문들을 확인할 것. ↩ 이는 Applicative가 문맥들을 어떻게 모노이드적으로 합성하는지를 훌륭히 설명한다. 문맥 내의 값들을 제거하면 applicative 법칙들의 모 노이드 표현은 모 노이드 법칙들과 정확히 일치한다. ↩ 이에 관해 최고이자 실용적인 예시는 lens 라이브러리로, 실로 펑터에 바치는 헌정이다. ↩ 05 애로 튜토리얼 원문: http://en.wikibooks.org/wiki/Haskell/Arrow_tutorial 스테판의 애로 튜토리얼 Circuit의 타입 정의 Circuit<NAME> 애로 proc 표기 행맨: 낱말 맞추기 행맨: 메인 프로그램 고급 주제 애로 명령을 함수와 합성하기 재귀적 바인딩 ArrowApply 노트 이 장은 애로에 대한 실전 튜토리얼이고, 다음 장인 애로 이해하기는 보다 개념적인 소개다. 둘 중 무엇을 먼저 읽어도 무방하다. 스테판의 애로 튜토리얼 이 튜토리얼에서는 직접 애로를 제작하고, 애로 proc과 do 표기의 사용법을 보여주고, ArrowChoice가 어떻게 작동하는지 보여준다. 간단한 행맨 게임으로 마무리한다. 먼저 언어 프라그 마를 이용해 컴파일러에서 애로 do 표기를 활성화한다. {-# LANGUAGE Arrows #-} 그리고 import 문도 좀 있다. module Main where import Control.Arrow import Control.Monad import qualified Control.Category as Cat import Data.List import Data.Maybe import System.Random 모든 하스 켈 함수는 애로로서 작동할 수 있는데, 함수 타입 생성자 (->)에 대한 Arrow 인스턴스가 있기 때문이다. 이 튜토리얼에서는 보다 흥미로운, 상태를 유지할 수 있는 (평범한 하스 켈 함수 애로는 할 수 없는) 애로를 제작할 것이다. 애로로 입출력을 포함해 온갖 효과를 만들어낼 수 있지만 여기선 간단한 예제 몇 개만 살펴본다. 우리의 애로를 회로(circuit)로 시각화할 수 있다는 의미에서 Circuit이라 부르겠다. 1 Circuit의 타입 정의 평범한 하스 켈 함수는 a -> b 타입의 애로로 취급할 수 있다. 우리의 Circuit 애로는 두 개의 두드러지는 특징을 가진다. 첫째, Arrow 인스턴스를 깔끔히 정의하기 위해 Circuit을 newtype 선언으로 감싼다. 둘째, 회로가 내부 상태를 유지하려면 우리의 애로는 자신의 대체물을 일반적인 출력값 b와 함께 반환해야 한다. newtype Circuit a b = Circuit { unCircuit :: a -> (Circuit a b, b) } Circuit을 애로로 만들려면 Category와 Arrow의 인스턴스로 만들어야 한다. 다음의 정의 전체에 걸쳐, 각 Circuit은 항상 그것이 반환하는, 자신의 새 버전으로 치환된다. instance Cat.Category Circuit where id = Circuit $ \a -> (Cat.id, a) (.) = dot where (Circuit cir2) `dot` (Circuit cir1) = Circuit $ \a -> let (cir1', b) = cir1 a (cir2', c) = cir2 b in (cir2' `dot` cir1', c) Cat.id 함수는 상태를 유지하지 않으면서 자신을 자신의 복제로 치환한다. (.) 함수의 용도는 두 애로를 오른쪽에서 왼쪽으로 연쇄하는 것이다. (>>>)와 (<<<)는 (.)에 기반한다. (.)는 Circuit 인자들을 실행하여 반환된 두 대체물의 dot으로 스스로를 치환한다. instance Arrow Circuit where arr f = Circuit $ \a -> (arr f, f a) first (Circuit cir) = Circuit $ \(b, d) -> let (cir', c) = cir b in (first cir', (c, d)) arr은 평범한 하스 켈 함수를 애로로 전이(lift) 시킨다. id와 마찬가지로 arr이 돌려주는 대체물은 자기 자신인데 평범한 하스 켈 함수는 상태를 유지할 수 없기 때문이다. 이제 회로를 실행할 함수가 필요하다. runCircuit :: Circuit a b -> [a] -> [b] runCircuit _ [] = [] runCircuit cir (x:xs) = let (cir',x') = unCircuit cir x in x' : runCircuit cir' xs 나 같은 mapAccumL 팬이라면 이렇게도 쓸 수 있다. runCircuit :: Circuit a b -> [a] -> [b] runCircuit cir inputs = snd $ mapAccumL (\cir x -> unCircuit cir x) cir inputs 또는, 에타 소거(eta-reduction)를 하고 나면 이렇게 간단해진다. runCircuit :: Circuit a b -> [a] -> [b] runCircuit cir inputs = snd $ mapAccumL unCircuit cir inputs Circuit<NAME> 이후 작업의 기반이 될 일반화된 누적기를 정의해 보자. accum'은 accum보다 덜 범용적인 버전이다. -- | 공급된 함수에 의해 결정되는 값을 출력하는 누적기 -- | Accumulator that outputs a value determined by the supplied function. accum :: acc -> (a -> acc -> (b, acc)) -> Circuit a b accum acc f = Circuit $ \input -> let (output, acc') = input `f` acc in (accum acc' f, output) -- | 누적기 값을 출력하는 누적기 -- | Accumulator that outputs the accumulator value. accum' :: b -> (a -> b -> b) -> Circuit a b accum' acc f = accum acc (\a b -> let b' = a `f` b in (b', b')) 다음은 입력으로서 전달된 모든 수의 중간 총합들을 저장하는, 유용하고 구체적인 누적기다. total :: Num a => Circuit a a total = accum' 0 (+) 이 회로를 다음과 같이 실행할 수 있다. *Main> runCircuit total [1,0,1,0,0,2] [1,1,2,2,2,4] *Main> 애로 proc 표기 다음은 평균(statistical mean) 함수다. mean1 :: Fractional a => Circuit a a mean1 = (total &&& (const 1 ^>> total)) >>> arr (uncurry (/)) 이 함수는 두 누적기 셀(cell)을 유지하는데, 하나는 합, 하나는 원소의 개수를 위한 것이다. 입력을 팬아웃(fanout) 연산자인 &&&로 분리하고 두 번째 입력 스트림에 앞서 입력 값들을 제거하고 1로 대체한다. const 1 ^>> total은 arr (const 1) >>> total의 단축 표현이다. 첫 번째 스트림은 입력의 합이다. 두 번째 스트림은 각 입력에 대응하는 1의 합(즉 입력의 개수)이다. 그리고 두 스트림을 (/) 연산자로 결합한다. 다음은 같은 함수를 애로 do 표기를 써서 작성한 것이다. mean2 :: Fractional a => Circuit a a mean2 = proc value -> do t <- total -< value n <- total -< 1 returnA -< t / n do 표기는 애로 간의 같은 관계를 서술하지만 그 방법이 완전히 다르다. 와이어링을 명시하는 대신 여러분은 변수 바인딩과 순수 하스 켈 표현식을 사용하여 애로들을 연결하고, 컴파일러가 arr, >>>, &&& 등을 대신 처리한다. 애로 proc 표기 안의 let 문은 모나 딕 do 표기 안의 let처럼 순수한 let이다. proc은 애로 표기를 도입하는 키워드로서 애로 입력을 패턴(여기선 'value')에 바인딩 한다. do 블록 내의 애로 구문은 다음 중 하나의 양식을 갖는다. 변수 바인딩 패턴 <- 애로 -< 애로 입력을 제공하는 순수 표현식 애로 -< 애로 입력을 제공하는 순수 표현식 모나드의 경우와 비슷하게, do 키워드의 용도는 변수 바인딩 패턴을 <-와 함께 사용함으로써 여러 줄을 결합하는 것이다. 모나드와 마찬가지로 마지막 줄은 변수 바인딩 패턴이 허용되지 않고 마지막 줄의 결괏값은 애로의 결과값이다. returnA는 total처럼 하나의 애로 일 뿐이다(사실 returnA는 arr id로 정의된 항등 애로다). 역시 모나드와 비슷하게, 마지막이 아닌 줄에도 변수 바인딩이 없을 수 있고, 그러면 결괏값을 무시하고 그 효과만을 얻게 된다. Circuit에서는 그런 일을 할 이유가 없지만(결괏값을 통해서가 아니고선 어떤 상태도 탈출할 수 없기 때문), 많은 애로는 그렇게 한다. 이 예제에서는 'proc' 표기가 코드를 훨씬 읽기 좋게 만든다. 한 번 실험해 보자. *Main> runCircuit mean1 [0,10,7,8] [0.0,5.0,5.666666666666667,6.25] *Main> runCircuit mean2 [0,10,7,8] [0.0,5.0,5.666666666666667,6.25] *Main> 행맨: 낱말 맞추기 이제 행맨 게임이다. 사전에서 낱말을 하나 골라보자. generator :: Random a => (a, a) -> StdGen -> Circuit () a generator range rng = accum rng $ \() rng -> randomR range rng dictionary = ["dog", "cat", "bird"] pickWord :: StdGen -> Circuit () String pickWord rng = proc () -> do idx <- generator (0, length dictionary-1) rng -< () returnA -< dictionary !! idx generator에서는 누산 기능을 사용해 난수 생성기를 보관한다. 생성자 애로가 인자를 취하는 하스 켈 함수에 의해 생성된다는 것만 빼면, pickWord는 딱히 새로운 개념을 도입하지 않는다. 다음은 출력 결과다. *Main> rng <- getStdGen *Main> runCircuit (pickWord rng) [(), (), ()] ["dog","bird","dog"] *Main> 당분간 이 조그만 애로를 쓴다. 이 애로는 처음에만 True를 반환하고 그 이후엔 쭉 False를 반환한다. oneShot :: Circuit () Bool oneShot = accum True $ \_ acc -> (acc, False) *Main> runCircuit oneShot [(), (), (), (), ()] [True, False, False, False, False] 이 게임의 메인 애로는 반복하여 실행될 것이고, 우리는 첫 번째 반복 때만 낱말을 골라두고 게임 내내 기억하려고 한다. 그 출력을 연이은 루프에서 덮어쓰기보단 pickWord를 실제로 단 한 번만 실행하려 한다(실제 구현에선 매우 느릴 것이기 때문). 하지만, 현 상태에서는 Circuit 내의 데이터 흐름은 반드시 구성요소 애로들의 모든 경로를 거쳐야 한다. 데이터 흐름이 한 패스만 거치고 다른 패스는 거치지 않게 하려면 우리의 애로를 ArrowChoice의 인스턴스로 만들어야 한다. 다음은 최소한의 정의다. instance ArrowChoice Circuit where left orig@(Circuit cir) = Circuit $ \ebd -> case ebd of Left b -> let (cir', c) = cir b in (left cir', Left c) Right d -> (left orig, Right d) getWord :: StdGen -> Circuit () String getWord rng = proc () -> do -- If this is the first game loop, run pickWord. mPicked becomes Just <word>. -- On subsequent loops, mPicked is Nothing. first Time <- oneShot -< () mPicked <- if first Time then do picked <- pickWord rng -< () returnA -< Just picked else returnA -< Nothing -- An accumulator that retains the last 'Just' value. mWord <- accum' Nothing mplus -< mPicked returnA -< fromJust mWord ArrowChoice가 정의되었기 때문에 컴파일러는 이제 <- 뒤에 if를 놓아서, 어떤 애로를 실행할지 선택하는 것을 허용한다(pickWord를 실행하거나 건너뛰거나). 이것이 일반적인 하스 켈 if가 아님에 유의할 것. 컴파일러는 이것을 ArrowChoice를 이용하여 구현한다. 같은 방식으로 case도 구현한다. 중요한 것은 proc 인자를 포함해 어떤 로컬 이름 바인딩도 <-와 -< 사이의 스코프에 있지 않다(if와 case의 조건부는 예외)는 걸 이해하는 것이다. 이런 것은 틀린 것이다. {- proc rng -> do idx <- generator (0, length dictionary-1) rng -< () -- 잘못됨 returnA -< dictionary !! idx -} 실행할 애로(여기선 generator (0, length dictionary -1) rng)가 proc 문 외부에 존재하는 스코프 내에서 평가된다. 이 스코프에선 rng가 존재하지 않는다. 생각해 보면 맞는 것이, 애로는 시작 부분(proc의 바깥)에서만 생성되기 때문이다. 애로를 실행할 때마다 생성된다면 어떻게 상태를 유지하겠는가? getWord를 실험해 보자. *Main> rng <- getStdGen *Main> runCircuit (getWord rng) [(), (), (), (), (), ()] ["dog","dog","dog","dog","dog","dog"] *Main> 행맨: 메인 프로그램 이것이 행맨 게임이다. hangman :: StdGen -> Circuit String [String] hangman rng = proc userInput -> do word <- getWord rng -< () let letter = listToMaybe userInput guessed <- updateGuess -< (word, letter) hung <- updateHung -< (word, letter) let hangman = "HangMan: ["++replicate hung '#'++replicate (5-hung) ' '++"]" returnA -< if word == guessed then [guessed, "You won!"] else if hung >= 5 then [guessed, hangman, "You died!"] else [guessed, hangman] where updateGuess :: Circuit (String, Maybe Char) String updateGuess = accum' (repeat '_') $ \(word, letter) guess -> case letter of Just l -> map (\(w, g) -> if w == l then w else g) (zip word guess) Nothing -> take (length word) guess updateHung :: Circuit (String, Maybe Char) Int updateHung = proc (word, letter) -> do total -< case letter of Just l -> if l `elem` word then 0 else 1 Nothing -> 0 main = do rng <- getStdGen interact (unlines . -- Concatenate lines out output ("Welcome to Arrow Hangman":) . -- Prepend a greeting to the output concat . runCircuit (hangman rng) . -- Process the input lazily ("":) . -- Act as if the user pressed ENTER once at the start lines) -- Split input into lines 그리고 다음은 실행 예시다. 최상의 결과를 위해 게임을 컴파일하고 GHCi보단 터미널에서 실행할 것. Welcome to Arrow Hangman ___ HangMan: [ ] ___ HangMan: [# ] __g HangMan: [# ] d_g HangMan: [# ] dog You won! 고급 주제 이 절에서는 애로 표기의 모든 것을 다룬다. 애로 명령을 함수와 합성하기 mean2를 이렇게 구현했었다. mean2 :: Fractional a => Circuit a a mean2 = proc value -> do t <- total -< value n <- total -< 1 returnA -< t / n GHC는 애로 구문을 그 애로에 작용하는 함수와 합성하기 위한 banana 괄호 문법을 정의한다. (Ross Paterson의 논문 2에서는 form 키워드를 사용했지만, GHC는 banana 괄호를 채택했다) 딱히 이유는 없지만 mean을 이렇게 작성할 수도 있다. mean3 :: Fractional a => Circuit a a mean3 = proc value -> do (t, n) <- (| (&&&) (total -< value) (total -< 1) |) returnA -< t / n (| ... |) 내의 첫 번째 항목은 임의 개수의 애로를 취해 한 애로를 반환하는 함수다. 여기선 중위 표기를 쓸 수 없다. 그다음 proc 구문의 형태로 인자들이 온다. 여러분이 원한다면 이 구문들에 do나 <-로 바인딩을 포함할 수 있다. 각 인자는 애로로 번역된 후 (&&&) 함수에 인자로 전달된다. banana 괄호는 사실 필요 없다. 컴파일러는 여러분이 이렇게 작성해도 무슨 뜻인지 알만큼 똑똑하다. (여기선 중위 표기가 허용된다는 것에 주목하라) mean4 :: Fractional a => Circuit a a mean4 = proc value -> do (t, n) <- (total -< value) &&& (total -< 1) returnA -< t / n 그럼 banana 괄호는 왜 필요할까? 위의 평이한 문법이 모호한 상황을 위해서다. 그 이유는 proc 명령의 애로 부분이 평범한 하스 켈 표현식이 아니기 때문이다. proc 구문 안에 명시된 애로들에는 다음이 성립함을 명심하라. 로컬 변수 바인딩이 허용되는 곳은 -< 뒤의 입력 표현식, if와 case의 조건식뿐이다. 애로 자체는 proc 바깥의 스코프에서 해석된다. if와 case는 평이한 하스켈이 아니다. 이것들은 ArrowChoice를 이용하여 구현된다. 애로를 결합하기 위한 함수들도 일반적인 하스켈이 아니다. 이것들은 banana 표기를 위한 단축 표현이다. 재귀적 바인딩 mean 예제를 또 우려먹자면, 다음은 재귀 바인딩을 이용해 구현하는 또 다른 방법이다. 이것이 작동하려면 그 입력을 한 단계 지연시키는 애로가 필요하다. delay :: a -> Circuit a a delay last = Circuit $ \this -> (delay this, last) 이것이 delay가 하는 일이다. *Main> runCircuit (delay 0) [5,6,7] [0,5,6] *Main> 이것은 mean의 재귀 버전이다. mean5 :: Fractional a => Circuit a a mean5 = proc value -> do rec (lastTot, lastN) <- delay (0,0) -< (tot, n) let (tot, n) = (lastTot + value, lastN + 1) let mean = tot / n returnA -< mean rec 블록은 다음 사항을 빼고는 do 블록과 닮았다. 마지막 줄이 변수 바인딩일 수 있고 통상 그렇게 쓴다. let이 든 <-에 의한 do 블록 바인딩이든 무관하다. rec 블록은 반환값이 없다. var <- rec ... 은 올바르지 않고 rec은 do 블록의 마지막 요소일 수 없다. 변수의 사용이 사이클을 형성할 것으로 기대된다(그렇지 않으면 rec을 쓰는 의미가 없다). rec의 machinery는 ArrowLoop 클래스의 루프 함수에 의해 처리되고, Circuit에 대해서는 이렇게 정의된다. instance ArrowLoop Circuit where loop (Circuit cir) = Circuit $ \b -> let (cir', (c, d)) = cir (b, d) in (loop cir', c) 그 이면에서는 이렇게 작동한다. rec에 정의되어 있으면서 rec 내에서 전방 참조되는 변수들은 loop의 두 번째 튜플 원소를 통해 전달되며 루프를 돈다. 그 결과 변수 바인딩과 그에 대한 참조는 어떤 순서로도 가능하다(하지만 애로 구문들의 순서는 효과 면에서 중요하다). rec에 정의되어 있으면서 rec 외부에서 참조되는 변수들은 loop의 첫 번째 튜플 원소로 반환된다. loop는 (그에 따라 rec은) 그저 변수를 바인딩 한다는 걸 이해하는 게 중요하다. 이것은 값을 보관했다 다음 실행 때 다시 전달하지 않는다. 그건 delay의 몫이다. 변수 참조에 의해 형성되는 사이클은 모종의 딜레이 애로나 지연 평가에 의해 분해되어야 한다. 그렇지 않으면 코드는 여러분이 평범한 하스켈에서 let a = a + 1이라고 쓸 때와 마찬가지로 무한 루프의 구천을 떠돌 것이다. ArrowApply 앞서 언급했듯이 애로 구문의 애로 부분(-< 앞부분)은 proc 내에서 바인딩 된 변수를 포함할 수 없다. 이 제한을 없애주는 -<<라는 연산자가 있다. 이걸 쓰려면 애로가 ArrowApply 타입 클래스를 구현해야 한다. 노트 애로를 회로로 보는 것은 어느 정도 Yampa라는 functional reactive programming 라이브러리에서 따온 것이다. ↩ 애로 proc 표기에 관한 Ross Paterson의 논문 ↩ 06 애로 이해하기 원문 : http://en.wikibooks.org/wiki/Haskell/Understanding_arrows 공장과 컨베이어 벨트 비유 세상이 로봇으로 가득해 arr (>>>) first second *** &&& 함수는 애로다 애로 표기 Maybe 필터 애로의 활용 스트림 처리(stream processing) 누수 방지(avoiding leaks) 그럼 뭐가 더 좋은가? 정적 파서와 동적 파서 애로 결합기 (로봇) 그래서 애로가 주는 것은? 모나드도 애로가 될 수 있다 애로 실전 더 보기 감사의 말 노트 우리는 하스 켈 애로 페이지에서 자료를 가져오는 것을 허락받았다. 자세한 사항은 talk page를 볼 것. 공장과 컨베이어 벨트 비유 이 튜토리얼에서는 공장 비유를 통해, 흐름 처리기라는 관점에서 애로를 소개한다. 손에 기름때를 묻혀보자. 여러분은 공장주고 작업 기계 한 다발을 소유하고 있다. 이 작업 기계는 함수에 대한 은유다. 기계는 모종의 입력을 받아 모종의 출력을 생산한다. 여러분의 목적은 작업 기계들을 결합하여 더 풍부하고 복잡한 작업을 수행할 수 있게 만드는 것이다. 모나드는 이 기계들을 파이프라인으로 결합할 수 있도록 한다. 애로는 이것들을 보다 흥미로운 방식으로 결합할 수 있도록 한다. 모나드 공장에서는 기계의 출력을 컨테이너로 감싸는 접근법을 취한다. 애로 공장은 확연히 다른 방법을 택한다. 출력을 컨테이너로 감싸는 게 아니라 기계 자체를 감싼다. 좀 더 구체적으로는, 애로 공장에서는 각각의 기계에 입력과 출력을 위한 한 쌍의 컨베이어 벨트를 장착한다. 즉 b -> c 타입의 함수가 있을 때, 우리는 그 기계에 b와 c 컨베이어 벨트를 붙여서 이 함수와 동등한 애로 a를 만들어낸다. 그 애로는 a b c 타입이고, b에서 c로 가는 애로 a라 읽는다. 세상이 로봇으로 가득해 앞서 언급하기를 기계들을 서로 결합하는 방법은 모나드보다 애로가 많다고 했다. 모나드의 로봇은 두 개지만 애로 타입 클래스의 로봇은 6개다. arr 가장 간단한 로봇은 arr으로 그 타입 시그너처는 arr :: (b -> c) -> a b c이다. 달리 말하자면 arr 로봇은 b -> c 타입의 작업 기계를 취해서 컨베이어 벨트를 붙임으로써 b에서 c로 가는 애로 a를 만들어낸다. (>>>) 다음 로봇은 아마 가장 중요한 (>>>)이다. 이것은 기본적으로 모나드 bind 로봇 (>>=)와 동등한 애로다. bind의 애로 버전인 (>>>)는 두 애로를 한 시퀀스 안에 놓는다. 즉 첫 번째 애로의 출력 컨베이어 벨트를 두 번째 애로의 입력 컨베이어 벨트에 연결한다. 이로써 우리는 새로운 애로를 얻는다. 하지만 하나 생각해 볼 것은, 우리의 애로가 취할 입력과 출력의 타입이 무엇이냐는 것이다. 우리가 첫 번째 애로와 두 번째 애로에서 각각 출력 컨베이어 벨트와 입력 컨베이어 벨트를 연결하고 있기 때문에, 두 번째 애로는 첫 번째 애로가 출력하는 것과 같은 종류의 입력을 취해야 한다. 첫 번째 애로의 타입이 a b c라면, 두 번째 애로의 타입은 a c d 여야 한다. 다음은 위와 같은 도식이지만 타입과 관련된 사항이 잘 보이도록 컨베이어 벨트에 물건을 놓았다. 연습문제 합성된 애로의 타입은 무엇인가? first 지금의 애로는 모나드와 같은 일만을 할 수 있다. 지금부터 흥미롭다! 애로 타입 클래스는 애로가 입력의 짝에 작용하는 것을 가능케하는 함수를 제공한다. 나중에 보겠지만 이를 통해 병렬 계산을 아주 간결한 방법으로 표현할 수 있다. 그 함수들 중 첫 번째가 first다. 이 튜토리얼을 휙휙 넘기고 있다면 적어도 이 절에서는 서행하는 게 좋을 것 같다. first 로봇은 애로를 진정으로 유용하게 만드는 것들 중 하나이기 때문이다. 애로 f가 주어지면 first 로봇은 컨베이어 벨트들과 여분의 기계를 붙여 새로운, 더 복잡한 애로를 형성한다. 입력 애로와 닿은 기계는 입력 짝을 구성요소들로 분해했다가 다시 한 데 모은다. 이 뒤에 깔린 발상은 모든 짝의 첫 번째 부분이 f에 공급되고 두 번째 부분은 빈 컨베이어 벨트에 전달된다는 것이다. 모든 것을 다시 한 데 모으면 공급한 것과 같은 짝들을 얻는데, 모든 짝의 첫 번째 부분이 f로부터 나온 동등한 출력으로 치환되어 있다. 이제 이것의 타입을 자문해 보자. 입력 튜플들의 타입이 (b, d)이고 입력 애로의 타입이 a b c(즉 b에서 c로 가는 애로)라 하자. 출력의 타입은? 애로가 모든 b를 c로 변환하니 모든 것을 다시 합치고 나면 출력의 타입은 반드시 (c, d) 여야 한다. 연습문제 first 로봇의 타입은 무엇인가? second first 로봇이 이해가 된다면 second 로봇은 식은 죽 먹기다. first와 같은 일을 하는데, 애로 f에 공급되는 것이 모든 입력 짝의 첫 번째가 아니라 두 번째 부분이다. second 로봇의 정말 흥미로운 점은 앞서의 로봇들로부터 유도할 수 있다는 것이다! 엄밀히 말하면 여러분에게 필요한 애로 로봇은 arr, (>>>), first뿐이다. 나머지는 자유다. 연습문제 튜플의 두 원소를 맞바꾸는 함수를 작성하라. 이 보조 함수를 arr, (>>>), first 로봇과 결합하여 second 로봇을 구현하라. *** 애로의 강점 중 하나는 병렬 계산을 표현할 수 있다는 것이다. 여기에는 (***) 로봇이 적격이다. 두 애로 f와 g가 주어졌을 때 (***)는 이들을 합성해 새로운 애로로 만드는데 이때 앞의 두 로봇에서 본 것과 같은 받침 기계를 사용한다. 개념상 first, second 로봇과 별반 다르지 않다. 전과 마찬가지로 새 애로는 입력의 짝을 취한다. 그 짝을 쪼개 각각의 컨ㅂ이어 벨트에 보낸다. 여기서 유일한 차이점은 애로 하나, 빈 컨베이어 벨트 하나가 아니라 별개의 두 애로가 있다는 것이다. 안 될 게 뭐가 있겠는가? 연습문제 (***) 로봇의 타입은 무엇인가? (>>>), first, second 로봇을 가지고 (***) 로봇을 구현하라. &&& Arrow 클래스의 마지막 로봇은 (***) 로봇과 아주 비슷하다. 결과 애로가 짝이 아니라 단일 입력을 취하는 것만 빼면. 하지만 기계의 나머지 부분은 똑같다. 입력이 하나뿐이라면 어떻게 애로 두 개로 일을 한다는 걸까? 간단하다. 입력을 복사해서 그 복사본을 각 기계에 공급한다. 연습문제 입력을 짝으로 복제하는 간단한 함수를 작성하라. 이 복제 함수와 arr, (>>>), *** 로봇을 이용해서 &&& 로봇을 구현하라. 비슷하게, 다음 함수를 &&& 없이 재작성하라. addA f g = f &&& g >>> arr (\(y, z) -> y + z) 함수는 애로다 애로 로봇 6개를 모두 보여줬으니, 이제 Arrow 클래스를 간단히 구현하며 보다 확실히 이해하자. 모나드 세계와 마찬가지로 애로도 종류가 다양하다. 여러분이 생각할 수 있는 가장 간단한 애로는? 함수다. 구체적으로는, 함수의 타입 생성자 (->)는 Arrow의 인스턴스다. instance Arrow (->) where arr f = f f >>> g = g. f first f = \(x, y) -> (f x, y) 자세히 살펴보자. arr - 함수를 애로로 변환하는 것은 자명하다. 사실 함수 자체가 이미 애로다. (>>>) - 첫 번째 함수의 출력을 두 번째 함수의 입력으로 공급하려고 한다. 함수 합성이 제격이다. first - 조금 복잡하다. 함수 f가 주어지면, 입력의 짝 (x, y)를 취해 f를 x에 대해 실행하고 y는 그대로 놔두는 함수를 반환한다. 엄밀히는 이것이 애로를 완성하기 위한 전부지만, 애로 타입 클래스는 나머지 세 로봇을 여러분이 직접 구현하는 것도 허용하므로 한 번 해보자. first f = \(x, y) -> (f x, y) -- 비교용 second f = \(x, y) -> ( x, f y) -- first와 비슷 f *** g = \(x, y) -> (f x, g y) -- takes two arrows, and not just one f &&& g = \x -> (f x, g x) -- feed the same input into both functions 끝! 이 이상 간단할 수 없다. 이것이 함수의 애로로서의 공식 인스턴스는 아니다. 진짜를 원한다면 하스 켈 라이브러리를 들여다볼 것. 애로 표기 앞의 Arrow 튜토리얼에서 proc과 -< 표기를 소개했다. 이것들이 그 모든 애로 로봇과 어떻게 섞이는 걸까? 슬프게도 모나드 do 표기보단 덜 직관적이지만, 한 번 살펴보자. proc (애로 추상화)는 일종의 람다다. 함수 대신 애로를 구축한다. -< (애로 적용)은 표현식의 값을 애로에 공급한다. addA :: Arrow a => a b Int -> a b Int -> a b Int addA f g = proc x -> do y <- f -< x z <- g -< x returnA -< y + z addA :: Arrow a => a b Int -> a b Int -> a b Int addA f g = arr (\ x -> (x, x)) >>> first f >>> arr (\ (y, x) -> (x, y)) >>> first g >>> arr (\ (z, y) -> y + z) addA :: Arrow a => a b Int -> a b Int -> a b Int addA f g = f &&& g >>> arr (\ (y, z) -> y + z) ※ 원문에서 이 절은 미완성입니다. Maybe 필터 모든 모나드는 애로로 변환할 수 있다. ※ 원문에서 이 절은 미완성입니다. 애로의 활용 이쯤이면 애로의 기제를 충분히 파악했을 테니 애로가 어디에 유용하느냐는 중요한 질문을 해보자. 스트림 처리(stream processing) ※ 원문에서 이 절은 미완성입니다. 누수 방지(avoiding leaks) 애로는 원래 Swierstra와 Duponcheel의 효율적 파서 설계에서 나온 것이다. 1 그 설계의 장점을 설명하기 위해 모나드 파서가 정확히 어떻게 작동하는지 보자. 단일 낱말을 파싱 할 때는 다닥다닥 붙은 모나드 파서가 만들어지곤 한다. Parsec을 예로 들면, 파서 문자열 "word"는 이렇게 볼 수도 있다. word = do char 'w' >> char 'o' >> char 'r' >> char 'd' return "word" 각 문자를 순서대로 시도하고, 만약 입력이 "worg"라면 처음 세 파서는 성공하지만 마지막 파서는 실패하여 전체 문자열 "word" 파서가 실패한다. 두 선택지 중 하나를 파싱 하려면 각각에 대해 새 파서를 만들고 순서대로 시도한다. 첫 번째 파서가 실패하면 같은 입력을 가지고 다음 것을 시도한다. ab = do char 'a' <|> char 'b' <|> char 'c' "c"를 성공적으로 파싱 하려면 a와 b를 둘 다 시도해 봐야 한다. one = do char 'o' >> char 'n' >> char 'e' return "one" two = do char 't' >> char 'w' >> char 'o' return "two" three = do char 't' >> char 'h' >> char 'r' >> char 'e' >> char 'e' return "three" nums = do one <|> two <|> three 이렇게 파서 세 개가 있으면 마지막 파서가 실패하기 전에는 문자열 "four"가 이 파서에 실패하는지 알 수가 없다. 파서들 중 하나가 입력의 상당 부분을 잡아먹지만 실패한다면 마지막 파서가 실패할 때까지 파서의 연쇄를 이어가야 한다. 뒷부분의 파서들이 받을 수도 있는 모든 입력은 반드시 메모리에 남아있어야 한다. 그래서 여러분이 낙관한 것보다 훨씬 많은 공간을 사용하게 되는데 이것을 주로 공간 누수(space leak)이라 부른다. 모나드 파서의 일반적인 패턴은 한 선택지가 실패하면 다른 선택지는 성공한다는 것이다. 그럼 뭐가 더 좋은가? Swierstra & Duponcheel (1996)은 똑똑한 파서라면 맨 처음 문자를 보는 즉시 실패할 수 있다는 것에 주목했다. 가령 위의 nums 파서에서 첫 번째 문자 파서들의 선택은 "one"에 대해 'o', "two"와 "three"에 대해 't'로 제한된다. 이 똑똑한 파서는 또한 입력을 즉시 가비지 콜렉팅할 수 있는데 앞을 내다봐서 다른 파서들이 그 입력을 취할 수 있는지를 보고 그럴 수 없으면 입력을 버리기 때문이다. 이 새로운 파서는 모나드 파서와 많이 유사하지만 주된 차이점은 정적인 정보를 내보낸다는 것이다. 무엇을 파싱 할 수 있는지도 알려준다. 그런데 큰 문제가 있다. 이것은 모나드 인터페이스와 어울리지 않는다. 모나드는 (a -> m b)인데 함수에만 기반한다. 정적 정보를 붙일 방법이 없다. 여러분에겐 단 한 개의 선택지만이 있다. 어떤 입력을 투척하고, 통과하는지 실패하는지 지켜본다. 함수형 프로그래밍 커뮤니티에서는 오랫동안 모나드 인터페이스를 범용적인 도구로 내세웠지만 그 인터페이스에 어울리지 않는, 그러면서도 특별히 유용한 코드가 있다는 걸 알아낸 것은 일종의 좌절이었다. 여기서 애로가 등장한다. John Hughes의 Generalising monads to arrows은 새롭고 보다 유연한 도구로서 애로 추상화를 제안했다. 정적 파서와 동적 파서 Swierstra & Duponcheel의 파서를 애로의 관점에서 낱낱이 파헤쳐 보자. 이 파서는 두 구성요소를 가진다. 입력이 파싱을 시도할 가치가 있는지 알려주는 빠르고 정적인 파서와 실제로 파싱을 하는 느리고 동적인 파서다. data Parser s a b = P (StaticParser s) (DynamicParser s a b) data StaticParser s = SP Bool [s] newtype DynamicParser s a b = DP ((a,[s]) -> (b,[s])) 정적 파서는 빈 입력을 받아들일지를 알려주는 플래그, 가능한 시작 문자들의 리스트로 이루어진다. 예를 들어 단일 문자에 대한 정적 파서는 다음과 같을 것이다. spCharA :: Char -> StaticParser Char spCharA c = SP False [c] 이 파서는 빈 문자열을 수용하지 않고(False), 가능한 시작 문자들의 리스트에는 오직 'c'만 들어있다. 이 절의 나머지 부분은 검증이 필요합니다. 동적 파서는 조금 더 복잡하다. 우리에게 보이는 것은 (a, [s])에서 (b, [s])로 가는 함수다. 두 파서의 연계라는 관점에서 생각하는 것이 효율적이다. 각 파서는 이전 파서(a)의 결과를 입력 스트림의 나머지 조각들([s])과 함께 섭취한다. a로 무언가를 해서 자신의 결과 b를 만들어내고, 문자여 르이 일부를 취해 그것을 반환한다. 실제 예시로 동적 파서 (Int, String) -> (Int, String)을 생각해 보자. Int는 지금까지 파싱 된 문자의 개수를 나타낸다. 아래의 표는 우리가 이들 중 몇 개를 연계하고 문자열 "cake"에 적용하면 무슨 일이 일어나는지를 보여준다. result remaining before 0 cake after first parser 1 ake after second parser 2 ke after third parser 3 e 요점은 동적 파서가 투잡을 뛴다는 것이다. 이전 파서의 출력에 무언가를 하고(형식적으로는 a -> b), 입력 문자열의 일부를 취한다. ([s] -> [s]) 따라서 그 타입은 DP ((a, [s]) -> (b, [s]))이다. 이제 단일 문자에 대한 동적 파서를 보자. 첫 번째 작업은 자명하다. 이전 파서의 출력을 무시한다. 그리고 막 파싱 한 문자를 반환한다. 다음에는 스트림에서 문자 하나를 뽑아온다. dpCharA :: Char -> DynamicParser Char Char Char dpCharA c = DP (\(_,x:xs) -> (x, xs)) 여기서 질문을 몇 개 해볼 수 있다. 가령 이전 파서의 출력을 그냥 무시할 거라면 그걸 받는 목적이 무엇인가? 지금 할 수 있는 최선의 답변은 "잠깐 기다려봐"이다. 여러분이 모나드에 익숙하다면 bind 연산자 (>>=)를 생각해 보라. bind는 그 자체로도 아주 유용하지만 가끔 두 모나드 계산을 연계할 때 우리는 익명 bind인 (>>)을 사용해서 첫 번째 계산의 출력을 무시하기도 한다. 여기서도 같은 상황이다. 흥미로운 능력의 일부를 손아귀에 쥐고 있지만 당장은 쓰지 않는 것이다. 그럼 다음 질문은 동적 파서에서, 방금 스트림에서 떼어낸 문자가 파싱 할 문자와 일치하는지 확인해야 하느냐는 것이다. x == c를 검사해야 하나? 아니다. 사실 이것이 핵심이다. 이 작업은 정적 파서가 이미 검사했기 때문에 필요 없다. 어쨌든 이것들을 한 데 모으면, 이것이 단일 문자에 대한 S+D 스타일 파서다. charA :: Char -> Parser Char Char Char charA c = P (SP False [c]) (DP (\(_,x:xs) -> (x, xs))) 애로 결합기 (로봇) 지금까지 독립된 노선을 걷는 두 개의 사고를 살펴봤다. 한편으로는 애로 기제(위의 결합기/로봇)를 살펴봤는데, 무엇을 위한 것인지는 정확히 모른다. 한편으로는 Arrow 클래스를 사용하여 일종의 파서를 소개했다. 그 목적은 공간 누수를 피하는 것이고 그러기 위해 빠른 정적 파서와 느린 동적 파서를 분리했다. 하지만 이것이 그 모든 애로 기제와 어떻게 연관되는지는 아직 이해하지 못했다. 이 절에서는 우리의 지식에 있는 틈을 메꿔 두 노선을 하나로 합치려고 한다. 우리는 Parser s를 위한 Arrow 클래스를 구현하고, 그럼으로써 무엇이 애로를 유용하게 만드는지 짧은 경험을 주려고 한다. instance Arrow (Parser s) where 우리가 할 수 있는 가장 간단한 것들 중 하나는 임의의 함수를 파싱 애로로 변환하는 것이다. "parse"라는 용어를 느슨한 의미로 쓰겠다. 결과 애로는 오직 빈 문자열만을 받아들인다(이것의 시작 문자들의 집합은 []이다). 유일한 업무는 이전 파싱 애로의 출력을 취해 무언가를 하는 것이다. 그 외의 경우 아무 입력도 취하지 않는다. arr f = P (SP True []) (DP (\(b, s) -> (f b, s))) first 결합기는 보다 직관적이다. 앞의 컨베이어 벨트를 떠올리자. 우리는 입력의 짝 (b, d)을 수용하는 새로운 파서를 만들려고 한다. 입력의 첫 번째 부분은 b로서, 우리가 실제로 파싱 하려는 것이다. 두 번째 부분은 완전히 그대로 넘어간다. first (P sp (DP p)) = (P sp (DP (\((b, d),s) -> let (c, s') = p (b, s) in ((c, d),s')))) 한편 (>>>)의 구현은 생각을 좀 해봐야 한다. 두 파서를 취해서 각각의 정적 파서와 동적 파서를 통합하는 합성 파서를 반환해야 한다. (P (SP empty1 start1) (DP p1)) >>> (P (SP empty2 start2) (DP p2)) = P (SP (empty1 && empty2) (if not empty1 then start1 else start1 `union` start2)) (DP (p2.p1)) 동적 파서들을 합성하는 것은 쉽다. 함수 합성을 하면 된다. 정적 파서들을 합치는 것은 조금 생각해야 한다. 무엇보다도 두 파서 모두 빈 문자열을 수용하면 합성된 파서도 그렇게 밖에 할 수 없다. 그럼 시작 기호는? 음, 파서들은 순차적일 테니 합성 파서의 시작 기호는 start이겠지? 이보게, 인생은 녹록하지 않다. 파서들이 빈 문자열을 수용할 수도 있기 때문이다. 첫 번째 파서가 빈 입력을 수용하는 가능성을 고려하려면 두 파서의 시작 기호들을 전부 수용해야 한다. 연습문제 위의 charA 파서를 보자. charA 'o' >>> charA 'n' >>> charA 'e'의 결과는? 그 합성 파서를 간략화한 버전을 작성하라. 그 파서가 빈 문자열을 수용하는가? 시작 기호는? 이것의 동적 파서는 무엇인가? 그래서 애로가 주는 것은? 우리의 Arrow 타입을 다시 보고 정적 파서 부분을 가리면 함수에 대한 애로 인스턴스와 많이 닮아 있다. arr f = \(b, s) -> (f b, s) first p = \((b, d), s) -> let (c, s') = p (b, s) in ((c, d), s')) p1 >>> p2 = p2. p1 여기엔 뜬금없이 변수 s가 등장하는데, 정의를 다소 낯설게 만들지만 컨베이어 벨트와 계산 기계의 윤곽을 어렴풋이 볼 수 있다. 사실 이것은 거의 State 모나드에 대한 애로의 인스턴스와 닮아 있다. (let f :: b -> c, p :: b -> State s c and . actually be <=<. 좋다. 그런데 이건 고전적인 모나드 스타일의 bind로도 할 수 있던 것이고 first는 쉽게 패턴 매칭을 할 수 있는 기이한 보조 함수가 되었을 것이다. 하지만 다시 생각해 보자. 우리의 Parser 타입은 단순한 동적 파서가 아니다. 정적 파서도 들어있다. arr f = SP True [] first sp = sp (SP empty1 start1) >>> (SP empty2 start2) = (SP (empty1 && empty2) (if not empty1 then start1 else start1 `union` start2)) 이건 절대로 함수가 아니다. 그저 데이터 타입 몇 개를 이리저리 밀어낼 뿐이다. 하지만 애로 비유 역시 잘 들어맞고, 우리는 이걸 애로라는 이름으로 포장한다. 그리고 두 타입을 합성할 때, 우리는 1:2의 이익을 얻는다. 정적 파서 자료구조는 동적 파서를 따라다닌다. Arrow 인터페이스 덕에 우리는 두 파서를 한 단위로서 투명하고 동시적으로 합성 및 조작할 수 있다. 그리고 이 단위를 전통적인 균일 함수처럼 운영할 수 있게 된다. 모나드도 애로가 될 수 있다 애로의 진정한 유연함은 모나드가 아닌 것들에서 나온다. 그 외의 경우에는 그저 지저분한 문법일 뿐이다. -- Philippa Cowderoy 모든 모나드는 애로로 만들 수 있다는 것이 밝혀졌다. 다음은 원래의 애로 논문에서 따온 주요 문구다. Just as we think of a monadic type m a as representing a 'computation delivering an a '; so we think of an arrow type a b c, (that is, the application of the parameterised type a to the two parameters b and c) as representing 'a computation with input of type b delivering a c'; arrows make the dependence on input explicit. (우리가 모나드 타입 m이 'a를 배달하는 계산'을 나타낸다고 생각하는 것처럼 애로 타입 a b c (즉 매개화 타입 a를 두 매개변수 b와 c에 적용하는 것)이 'a c를 배달하는 b 타입의 입력이 있는 계산'을 나타낸다고 생각하자는 것이다. 애로는 입력에 관한 의존성을 명시적인 것으로 만든다.) 애로를 보는 한 가지 관점은 영어가 여러분에게 동사를 명사화하는 걸 허용한다는 것이다. 예를 들어 "I had a chat with them" 대 "I chatted with them"처럼. 애로가 바로 이런 것으로, a에서 b로 가는 함수를 하나의 값으로 변환한다. 이 값은 a에서 b로 가는 일급 변환이다. 애로 실전 애로는 상대적으로 새로운 추상화지만, 이미 하스 켈 세계에서 많은 용례가 발견되었다. Hughes의 애로 스타일 파서는 그의 2000년 논문에서 처음 소개되어는 데 쓸만한 구현은 2005년 5월에나 나왔다. Einar Karttumen은 표준 하스 켈 파서 합성기 라이브러리인 Parsec의 기능들에 근접한 PArrows라는 구현을 작성했다. 그래픽 인터페이스를 구축하기 위한 Fudgets 라이브러리 수정 요망 하스 켈 XML 툴킷(HXT)은 애로를 이용해 XML을 처리한다. 하스 켈 위키에 Gentle Introduction to HXT라는 페이지가 있다. Netwire - 게임 개발을 위한 FRP 라이브러리. 적용성 애로뿐 아니라 애로 인터페이스도 있다. 더 보기 모나드를 애로로 일반화하기 - John Hughes https://www.haskell.org/arrows/biblio.html 감사의 말 이 과목은 원래 The Monad.Reader 4를 위해 작성된, Shae Erisson의 An Introduction to Arrows의 내용을 빌려 썼다. 노트 Swierstra, Duponcheel. Deterministic, error correcting parser combinators ↩ 06 애로 이해하기 (개정) (작업 중) 원문 : http://en.wikibooks.org/wiki/Haskell/Understanding_arrows 내용이 너무 많이 바뀌어서 처음부터 새로 번역하는 중입니다. Arrow 포켓 가이드 애로는 함수와 많이 닮았다 Applicative와 Monad 사이에 있는 Arrow Arrow는 멀티태스크가 가능하다 ArrowChoice는 단정적(resolute) 일 수 있다 ArrowApply는 그저 따분하다 애로 합성 자는 예기치 못한 곳에서 나온다 애로 사용하기 릭 방지 더 나은 방법은? 스태틱 파서와 다이내믹 파서 애로 합성자 도입하기 그래서 애로는 어디에 좋은가? 실전에서의 애로 더 읽을거리 우리는 하스 켈 애로 페이지에서 자료를 가져오는 것을 허락받았다. 자세한 사항은 talk page를 볼 것. 모나드와 비슷하게 애로는 어떤 문맥 내에서 일어나는 계산을 표현한다. 하지만 애로는 모나드보다 더 일반화된 추상화이며, Monad 클래스보다 더 풍부한 문맥을 표현할 수 있다. 둘의 근본적인 차이는 다음과 같이 요악할 수 있다. 모나 딕 타입 m a가 'a를 전달하는 계산'을 표현한다고 생각할 수 있는 것처럼, 애로 타입 a b c (즉 매개화된 타입 a를 두 매개변수 b와 c에 적용하는 것)은 'b 타입의 입력을 받아 c를 전달하는 계산'을 표현한다고 생각할 수 있다. 애로는 입력에 대한 의존을 명확하게 만든다. - John Hughes, Generalising Monads to Arrows[^1] 이번 장은 크게 2부로 나뉜다. 1부에서는 애로 계산이 우리에게 익숙한 펑 터 클래스들로 표현된 계산과 어떻게 다른지 살펴보고, 애로와 관련된 핵심 타입 클래스들을 소개한다. 2부에서는 John Hughes가 애로를 소개한 논문에서 사용했던 파서 예제를 공부한다. Arrow 포켓 가이드 애로는 함수와 많이 닮았다 애로를 이해하는 첫걸음은 애로가 함수와 얼마나 비슷한지 깨닫는 것이다. (->)와 마찬가지로 Arrow 인스턴스의 타입 생성자의 종(kind)은 * -> * -> *이다. 즉 타입 인자를 두 개 받는데, 이는 Monad는 인자를 하나만 받는 것과 다른 점이다. 특히 Arrow는 상위 클래스로 Category를 가진다. Category는 아주 대강 설명하자면 함수처럼 합성될 수 있는 것들을 위한 클래스다. class Category y where id :: y a a -- identity for composition. (.) :: y b c -> y a b -> y a c -- associative composition. (함수가 Category의 인스턴스라는 건 말할 필요도 없다. 사실 함수는 Arrow이기도 하다.) 이런 유사성의 결론은, Arrow 연산자로 가득한 표현식을 볼 때 인자 생략식(point-free)을 생각해야 한다는 것이다. (total &&& (const 1 ^>> total)) >>> arr (uncurry (/)) 그렇지 않으면 값을 적용할 곳을 찾다가 금방 길을 잃는다. 어쨌든 올바른 방식으로 봐도 길을 잃기 쉬운 건 마찬가지다. 이것이 proc 표기가 있는 이유다. proc은 변수 이름과 공백을 추가하고 어떤 연산자는 숨겨서 Arrow 코드를 읽기 쉽게 만든다. 계속하기 전에 Control.Category는 (<<<) = (.)와 (>>>) = flip (.)도 정의한다는 것을 짚고 넘어가야겠다. 이것들은 애로를 왼쪽에서 오른쪽으로 결합할 때 매우 흔하게 쓰인다. Applicative와 Monad 사이에 있는 Arrow 바로 앞에서 경고했지만, 사실 애로를 적용성 펑터와 모나드에 비교해 볼 수 있다. 여기서 트릭은 펑터를 좀 더 애로처럼 보이게 만들고 그 반대는 막는 것이다. 그러니까 Arrow y => y a b를 Applicative f => f a 또는 Monad m => m a와 비교하면 안 되고, 다음과 비교해야 한다. static morphism의 타입인 Applicative f => f (a -> b) 즉 (<*>)의 좌변의 값 Kleisli morphism의 타입인 Monad m => a -> m b 즉 (>>=) 우변의 함수 2 사상(morphism)은 Category 인스턴스를 가질 수 있는 것이다. 사실 static morphism과 Kleisli morphism 둘 모두에 대한 Category의 인스턴스를 작성할 수가 있다. 이렇게 적당하게 비틀면 적절히 비교하는 데는 충분하다. 이 논의에서 Functor, Applicative, Monad를 비교했던 sliding scale of power discussion가 떠오른다면 여러분이 주의를 기울이고 있다는 뜻이다. 지금 정확히 같은 길을 밟고 있기 때문이다. 그때는 사상의 타입이 어떻게 결과(effect)의 생성 가능 유무를 제한하는지에 주목했다. 모나 딕 바인드는 Kleisli 사상에 주어진 a 값에 의존하는 계산의 결과에 거의 임의적인 변경을 유발하는 반면, static 사상 내 functorial wrapper와 함수 애로 사이의 격리는 applicative computation 내의 결과가 펑 터 내의 어느 값에도 의존하지 않음을 뜻한다.3 Monadic binds can induce near-arbitrary changes to the effects of a computation depending on the a values given to the Kleisli morphism, while the isolation between the functorial wrapper and the function arrow in static morphisms mean the effects in an applicative computation do not depend at all on the values within the functor 이거 먼 소리여 애로가 이런 관점과 연관이 적은 것은 Arrow y => y a b 안에서 문맥 y와 함수 애로 사이에 가능성의 범위를 명확히 결정하는 관계가 없다는 것이다. static morphism과 Kleisli morphism 모두 Arrow로 만들 수 있고 반대로 Arrow의 인스턴스를 Applicative 인스턴스만큼 제한되거나 Monad 인스턴스처럼 강력하게 만들 수 있다. 4 더 흥미로운 것은 Arrow에 세 번째 선택지가 있다는 것인데, 한 컨텍스트 안에 applicative 같은 static effect와 모나드 같은 dynamic effect를 동시에 가지면서도 서로 분리할 수 있다. 애로는 effect들이 결합되는 방식을 세밀하게 조정할 수 있다. 이것이 이번 장 마지막에서 살펴볼 고전적인 예제인 애로 기반 파서의 요지다. Arrow는 멀티태스크가 가능하다 다음은 Arrow 메서드 들이다. class Category y => Arrow y where -- Minimal implementation: arr and first arr :: (a -> b) -> y a b -- converts function to arrow first :: y a b -> y (a, c) (b, c) -- maps over first component second :: y a b -> y (c, a) (c, b) -- maps over second component (***) :: y a c -> y b d -> y (a, b) (c, d) -- first and second combined (&&&) :: y a b -> y a c -> y a (b, c) -- (***) on a duplicated value 이 메서드들을 이용하면 일렬로 연결된 것처럼 보이는 애로들에 대해 매 단계마다 여러 계산을 수행할 수 있다. 개별 계산에 쓰인 값들을 (중첩되었을 수 있는) 짝 안의 짝들의 원소로 저장하고, 짝을 다루는 함수를 이용해 필요할 때마다 각각의 값에 접근하는 것이다. 이러면 나중을 위해 중간 값들을 저장하거나 인자가 여러 개인 함수를 쓰는 등의 일을 편하게 할 수 있다. 5 시각화를 하면 애로 계산의 데이터 흐름을 이해하는 데 도움이 될 것 같다. 다음은 (>>>)를 비롯 6개의 Arrow 메서드들을 묘사한 것이다. arr는 함수를 애로로 변환하여 다른 애로와 합성할 수 있게 만든다. 모든 애로가 이런 식으로 만들어지는 것은 아니다, (>>>)는 두 애로를 합성한다. 첫 번째 애로의 결과가 두 번째 애로에 공급된다. first는 두 입력을 나란히 취한다. 첫 번째 입력은 애로를 통해 수정되는 반면 두 번째 입력은 변경되지 않는다. second는 반대로 두 번째 입력만 수정한다. (***)는 두 입력을 각각 다른 애로를 통해 수정한다. (&&&)는 한 입력을 취해 복제하고 각각 다른 애로를 통해 수정한다. 애로 튜토리얼의 mean 애로의 데이터 흐름. 직사각형은 애로, 둥근 사각형은 arr를 통해 만들어진 애로, 원은 기타 데이터 흐름 분할/병합 지점이다. 다른 합성자들은 생략했다. 위 그림은 다음 코드에 대응한다. (total &&& (const 1 ^>> total)) >>> arr (uncurry (/)) Control.Arrow는 returnA = arr id를 아무 일도 하지 않는 애로로 정의한다. 애로 법칙 중 하나는 returnA가 반드시 Category 인스턴스의 id와 동치여야 한다고 정의한다. 6 ArrowChoice는 단정적(resolute) 일 수 있다 Arrow가 멀티태스킹을 가능하게 만든다면 ArrowChoice는 어떤 작업을 수행할지를 결정한다. class Arrow y => ArrowChoice y where -- Minimal implementation: left left :: y a b -> y (Either a c) (Either b c) -- maps over left choice right :: y a b -> y (Either c a) (Either c b) -- maps over right choice (+++) :: y a c -> y b d -> y (Either a b) (Either c d) -- left and right combined (|||) :: y a c -> y b c -> y (Either a b) c -- (+++), then merge results Either는 값에 태그를 매기는 수단을 제공하여, 애로들이 값에 붙은 Left 또는 Right 태그에 따라 그 값을 다르게 처리할 수 있도록 한다. Either를 수반하는 메서드들은 Arrow가 제공하는 쌍을 수반하는 메서드들과 매우 유사한 것에 주목할 것. 애로 튜토리얼의 getWord 예제의 데이터 흐름 일부. 파란색은 Left 태그를, 붉은색은 Right를 나타낸다. proc 표기의 if 부분이 True를 left로, False를 right로 보내는 것에 주목할 것. 상응하는 코드는 다음과 같다. proc () -> do first Time <- oneShot -< () mPicked <- if first Time then do picked <- pickWord rng -< () returnA -< Just picked else returnA -< Nothing accum' Nothing mplus -< mPicked ArrowApply는 그저 따분하다 이름에서 알 수 있듯 ArrowApply는 애로 계산 도중 애로를 값에 직접 적용할 수 있게 만든다. 일반적인 Arrow는 이런 것을 허용하지 않는다. ArrowApply들은 끊임없이 합성할 수 있다. 일종의 run-arrow 함수를 사용해 애로로부터 평범한 함수를 얻어낸 후 마지막에만 적용이 발생한다. class Arrow y => ArrowApply y where app :: y (y a b, a) b -- applies first component to second (예를 들어 함수를 위한 app은 uncurry ($) = \(f, x) -> f x이다.) 하지만 app에는 뼈아픈 대가가 있다. 애로 계산 안에서 애로를 값으로서 구축하고 적용을 통해 제거한다는 것은 계산 내 값들이 문맥에 영향을 주는 것을 허용한다는 뜻이다. 이것은 마치 모나 딕 바인드가 하는 일처럼 들린다. 사실 ArrowApply가 하는 일은 ArrowApply 법칙만 지킨다면 Monad와 완전히 동등하다. 최종 결론은 ArrowApply 애로는 부분 정적 문맥처럼 Monad는 불가능하지만 Arrow는 허용하는 흥미로운 가능성을 전혀 실현할 수 없다는 것이다. 애로의 진정한 유연함은 모나드에는 없는 것들로부터 나오는 것이며, 그게 없으면 단지 지저분한 문법일 뿐이다. - Philippa Cowderoy 애로 합성 자는 예기치 못한 곳에서 나온다 함수는 애로의 자명한 예시이며 따라서 Control.Arrow의 모든 함수는 함수들에도 사용할 수 있다. 애로와 아무 상관 없는 코드에서 애로 합성자가 쓰이는 것은 흔한 일이다. 다음은 평범한 함수들에 대해 애로 합성자가 무슨 일을 하는지를 요약한 것이다. 같은 방식으로 사용될 수 있는 다른 모듈의 합성자들도 옆에 표시했다. (다른 이름을 선호하거나 단순 작업에는 단순한 모듈을 선호하는 경우) TODO: 표 Data.Bifunctor 모듈의 Bifunctor 클래스는 쌍과 Either를 인스턴스로 가진다. Bifunctor는 Functor와 유사하지만 함수를 매핑하는 방법이 두 가지이며 각각 first 메서드와 second 메서드에 대응한다. 7 연습문제 second, (***), (&&&)의 구현을 작성하라. second의 구현에는 (>>>), arr, first (그리고 기타 평범한 함수들)을 사용할 것. 그 후에는 다른 합성자들을 사용할 수 있다. left를 이용해 right의 구현을 작성하라. liftY2 :: Arrow y =>(a -> b -> c) -> y r a -> y r b -> y r c을 구현하라. 애로 사용하기 릭 방지 애로는 Swierstra와 Duponcheel의 효율적인 파서 설계에서 유래된 것이다 8. 이 설계가 왜 좋은지 논의하기에 앞서 모나 딕 파서가 어떻게 작동하는지 빠르게 살펴보자. 다음은 모나 딕 파서 타입을 거의 뼈대만 묘사한 것이다. newtype Parser s a = Parser { runParser :: [s] -> Maybe (a, [s]) } Parser는 입력 스트림(여기서는 [s] 타입의 리스트)을 취해 입력에서 찾은 것에 따라 결과([a] 타입의)와 스트림(보통은 입력 스트림에서 파서가 소비한 입력 일부를 제외한 것), 또는 Nothing을 반환한다. 파서가 성공했는지 실패했는지를 말하려면 파서가 결과를 생산했는지를 본다. Parsec9의 ParsecT 같은 실전의 파서 타입은 여러 기능을 제공하기 위해 (특히 실패할 경우 에러 메시지) 훨씬 복잡하지만 이 단순한 Parser도 우리 목적에는 충분하다. 예를 들어 이 파서는 문자열 내 단일 문자를 위한 것이다. char :: Char -> Parser Char Char char c = Parser $ \input -> case input of [] -> Nothing x : xs -> if x == c then Just (c, xs) else Nothing 입력 문자열의 첫 문자가 c라면 char c는 성공하여 첫 문자를 소비하고 c를 결과로 반환한다. 그 외의 경우에는 실패한다. GHCi> runParser (char 'H') "Hello" Just ('H',"ello") GHCi> runParser (char 'G') "Hello" Nothing Parser 타입을 다시 보면 이것은 Maybe에 대한 State [s]이다. 따라서 Parser를 Applicative, Monad, Alternative 등의 인스턴스로 만들 수 있다. (직접 시도해 봐도 좋다.) 따라서 간단한 파서로부터 복잡한 파서를 구축하기 위해 매우 다양한 합성자를 활용할 수 있다. 파서들은 순차적으로 실행될 수도 있고... isHel :: Parser Char () isHel = char 'H' *> char 'e' *> char 'l' *> pure () 그 결과를 합성할 수도 있으며... string :: String -> Parser Char String string = traverse char ... or be tried as alternatives to each other: solfege :: Parser Char String solfege = string "Do" <|> string "Re" <|> string "Mi" 마지막 예시에서 Swierstra와 Duponcheel가 제안하려던 문제가 무엇인지 짐작할 수 있다. solfege를 문자열 "Fa"에 대해 실행할 때, 파서가 세 제안을 모두 실패한 후에야 그 파서가 실패할 것임을 알 수 있다. 복잡한 파서에서 제안 중 하나가 입력 스트림을 상당 부분 소비한 후에야 실패한다면 이후의 일련의 파서들도 그런 식으로 실행해야 한다. 이후 파서들이 소비할 가능성이 있는 입력은 메모리에 유지되어야 한다. 그러면 공간 사용량이 단순 예상보다 훨씬 많아져서 space leak이라 부르는 상황에 처할 수 있다. 더 나은 방법은? Swierstra와 Duponcheel(1996)은 파싱 작업 같은 걸 처리할 때 똑똑한 파서는 첫 문자를 보자마자 즉시 실패할 수 있음을 알아차렸다. 예를 들어 위의 solfege 파서의 경우 첫 번째 문자로 가능한 것은 "Do", "Re", "Mi"에 대해 각각 D, R, M으로 제한된다. 이 똑똑한 파서는 입력의 가비지 컬렉션을 더 일찍 수행할 수도 있는데, 다른 파서들이 입력을 소비할 수 있을지 미리 알아보고 소비될 수 없는 입력은 버릴 수 있기 때문이다. 이 새로운 파서는 모나 딕 파서와 비슷하지만 정적 정보를 산출한다는 주요 차이점이 있다. 모나드와 비슷하지만 무엇을 파싱 할 수 있는지를 말할 수 있는 것이다. 그런데 큰 문제가 하나 있다. 이런 건 Monad 인터페이스에 맞지 않는다. 모나 딕 합성은 오로지 (a -> m b) 함수와 함수들에 의해 작동한다. 정적 정보를 붙일 방법은 없다. 선택지는 오로지 하나다. 어떤 입력을 던지고 통과하는지 실패하는지 보는 것이다. 이 화제를 처음 꺼냈을 때로 돌아가서, 모나 딕 인터페이스는 함수형 프로그래밍 커뮤니티에서 완벽한 만능 도구로 홍보되고 있었기에 이 인터페이스에 맞지 않으면서 특별히 유용한 코드가 있다는 것은 일종의 난관이었다. 여기서 애로가 등장한다. John Hughes의 Generalising monads to arrows는 새롭고 더 유연한 도구로서 애로 추상화를 제안한다. 스태틱 파서와 다이내믹 파서 Swierstra와 Duponcheel의 파서를 Hughes가 제시한 애로의 관점에서 자세히 살펴보자. 이 파서는 두 구성요소를 가진다. 하나는 입력을 파싱 할 가치가 있는지 알려주는 빠른 스태틱 파서고 다른 하나는 실제 파싱을 수행하는 느린 다이내믹 파서다. import Control.Arrow import qualified Control.Category as Cat import Data.List (union) data Parser s a b = P (StaticParser s) (DynamicParser s a b) data StaticParser s = SP Bool [s] newtype DynamicParser s a b = DP ((a, [s]) -> (b, [s])) 스태틱 파서는 파서가 빈 입력을 허용하는지를 나타내는 플래그와 가능한 시작 문자들의 리스트로 이루어진다. 예를 들어 한 문자를 위한 파서는 이런 식이다. spCharA :: Char -> StaticParser Char spCharA c = SP False [c] 이 파서는 빈 문자열을 허용하지 않으며(False) 가능한 시작 문자의 리스트는 c로만 구성된다. 다이내믹 파서는 좀 더 해부해야 한다. 이것은 (a, [s])에서 (b, [s])로 가는 함수다. 두 파서를 연결하는 것으로 생각하는 게 쉽다. 각 파서는 이전 파서의 결과(a)와 입력 스트림의 나머지 부분([s])을 소비해서 a에 뭔가를 한 후 자신의 결과 b를 만들고 문자열 일부를 소비한 후 그걸 반환한다. 이런 동작의 예시로 다이내믹 파서 (Int, String) -> (Int, String)를 생각해 보자. 여기서 Int는 파싱 한 문자 개수를 나타낸다. 아래의 표는 그런 파서 몇 개를 연결하고 문자열 "cake"에 대해 실행하면 무슨 일이 일어나는지를 보여준다. result remaining before 0 cake after first parser 1 ake after second parser 2 ke after third parser 3 e 요점은 다이내믹 파서가 두 가지 일을 한다는 것이다. 이전 파서의 출력에 무언가를 하고(a -> b), 입력 스트링의 일부를 소비하며([s] -> [s]), 따라서 그 타입은 DP ((a,[s]) -> (b,[s]))이다. 이제 단일 문자에 대한 다이내믹 파서의 경우 (타입 (Char, String) -> (Char, String)) 첫 번째 작업은 자명하다. 이전 파서의 출력을 무시하고 우리가 파싱 한 문자를 반환하고 스트림에서 문자를 하나 소모한다. dpCharA :: Char -> DynamicParser Char a Char dpCharA c = DP (\(_,_:xs) -> (c, xs)) 여기서 몇 가지 의문이 들 것이다. 가령 이전 파서의 출력을 무시할 거라면 애초에 왜 받는 걸까? 다이내믹 파서는 스트림에서 가져온 문자가 파싱 할 문자와 일치하는지 x == c로 검사해야 하지 않을까? 두 번째 질문에 대한 답은 '아니오'다. 사실 이것이 요지의 일부다. 그런 작업이 불필요한 것은 스태틱 파서가 이미 그 일을 수행했을 것이기 때문이다. 여기서는 문자 하나만 검사하기 때문에 상황이 간단했다. 문자 몇 개를 연속으로 처리하는 파서를 작성한다면 두 번째 및 그 이후의 문자들을 확인하는 다이내믹 파서가 필요했을 것이다. 그리고 문자 파서들 몇 개를 연결해서 출력 문자열을 구성하길 원한다면 이전 파서의 출력이 필요했을 것이다. 두 파서를 한데 모을 시간이다. 다음은 단일 문자를 위한 S+D 스타일 파서다. charA :: Char -> Parser Char a Char charA c = P (SP False [c]) (DP (\(_,_:xs) -> (c, xs))) 이 파서를 실제로 사용하려면 runParser 함수를 사용해서 입력에 정적 검사를 실행하고 동적 파서를 적용해야 한다. -- The Eq constraint on s is needed so that we can use elem. runParser :: Eq s => Parser s a b -> a -> [s] -> Maybe (b, [s]) runParser (P (SP emp _) (DP p)) a [] | emp = Just (p (a, [])) | otherwise = Nothing runParser (P (SP _ start) (DP p)) a input@(x:_) | x `elem` start = Just (p (a, input)) | otherwise = Nothing runParser가 [s] -> Maybe (b, [s]) 타입의 함수를 내놓는 것에 주목하자. 이것은 우리가 앞서 설명한 모나 딕 파서와 본질적으로 같은 것이다. 이제 charA를 char처럼 쓸 수 있게 되었다. (주요한 차이점은 더미 인자로 ()를 넘긴다는 것이다) charA는 a 타입의 초깃값을 실제로는 활용하지 않기 때문에 이것은 말이 된다. 다른 파서들은 그렇지 않을 것이다. GHCi> runParser (charA 'D') () "Do" Just ('D',"o") GHCi> runParser (charA 'D') () "Re" Nothing 애로 합성자 도입하기 준비는 충분히 했으니 Parser s에 대한 Arrow 클래스를 구현해 보자. 그러고 나면 애로의 유용함을 느끼게 될 것이다. instance Eq s => Arrow (Parser s) where arr는 임의 함수를 파싱 애로로 변환해야 한다. 이 경우 아주 느슨한 의미로 "파싱"을 활용한다. 결과 애로는 오로지 빈 문자열만을 받는다. (첫 문자들의 집합이 []) 이것의 유일한 역할은 이전 파싱 애로의 출력을 받아서 그걸로 뭔가를 하는 것이다. 즉 입력을 전혀 소비하지 않는다. arr f = P (SP True []) (DP (\(b, s) -> (f b, s))) first 결합기도 꽤 직관적이다. 어떤 파서가 주어질 때 우리가 원하는 것은 입력의 쌍 (b, d)를 받아들이는 새로운 파서다. 우리가 실제로 파싱 하려는 것은 입력 b의 첫 번째 구성요소다. 두 번째 성분은 건드리지 않고 그대로 넘긴다. first (P sp (DP p)) = P sp (DP (\((b, d),s) -> let (c, s') = p (b, s) in ((c, d),s'))) Category 인스턴스도 제공해야 한다. id = arr id가 성립해야 하므로 id는 자명하다. instance Eq s => Cat.Category (Parser s) where id = P (SP True []) (DP (\(b, s) -> (b, s))) -- Or simply: id = P (SP True []) (DP id) 반면 (.)의 구현은 생각을 조금 해야 한다. 파서를 두 개 받아서 두 인자의 정적 및 동적 파서를 모두 통합하는 합성 파서를 반환해야 한다. -- The Eq s constraint is needed for using union here. (P (SP empty1 start1) (DP p2)) . (P (SP empty2 start2) (DP p1)) = P (SP (empty1 && empty2) (if not empty1 then start1 else start1 `union` start2)) (DP (p2.p1)) 동적 파서들의 합성은 꽤나 쉽다. 단순히 함수 합성을 하면 된다. 정적 파서들의 합성은 생각을 조금 해야 한다. 먼저 두 파서가 빈 문자열만을 받아들인다면 합성 파서도 빈 문자열만 받아들일 수 있다. 합리적이다. 이제 시작 기호에 관해 생각해 보자. Combining the dynamic parsers is easy enough; we just do function composition. Putting the static parsers together requires a little bit of thought. First of all, the combined parser can only accept the empty string if both parsers do. Fair enough, now how about the starting symbols? Well, the parsers are supposed to be in a sequence, so the starting symbols of the second parser shouldn't really matter. If life were simple, the starting symbols of the combined parser would only be start1. Alas, life is not simple, because parsers could very well accept the empty input. If the first parser accepts the empty input, then we have to account for this possibility by accepting the starting symbols from both the first and the second parsers 그래서 애로는 어디에 좋은가? Parser 타입에서 스태틱 파서 부분을 빼면 마치 함수를 위한 애로 인스턴스처럼 보인다. arr f = \(b, s) -> (f b, s) first p = \((b, d), s) -> let (c, s') = p (b, s) in ((c, d), s')) id = id p2. p1 = p2. p1 변수 s가 정의를 조금 묘하게 만들지만 대체로 first 함수와 비슷해 보인다. 사실 이것은 State 모나드/Kleisli morphism을 위한 애로 인스턴스에 가깝다. (f :: b -> c, :: b -> State s c로 두면 (.)는 (<=<) = flip (>=>)가 된다) TODO... That's fine, but we could have easily done that with bind in classic monadic style, with first becoming just an odd helper function that could be easily written with a bit of pattern matching. But remember, our Parser type is not just the dynamic parser − it also contains the static parser. arr f = SP True [] first sp = sp (SP empty1 start1) >>> (SP empty2 start2) = (SP (empty1 && empty2) (if not empty1 then start1 else start1 `union` start2)) This is not at all a function, it's just pushing around some data types, and it cannot be expressed in a monadic way. But the Arrow interface can deal with just as well. And when we combine the two types, we get a two-for-one deal: the static parser data structure goes along for the ride along with the dynamic parser. The Arrow interface lets us transparently compose and manipulate the two parsers, static and dynamic, as a unit, which we can then run as a traditional, unified function. 실전에서의 애로 애로를 사용하는 라이브러리의 예시들 SQL 생성을 위한 라이브러리 Opaleye (라이브러리 문서) Haskell XML Toolbox (프로젝트 페이지와 라이브러리 문서)는 애로를 사용해 XML을 처리한다. Haskell Wiki에 Gentle Introduction to HXT라는 위키 페이지가 있다. Netwire (라이브러리 문서)는 함수형 반응형 프로그래밍 (FRP) 을 위한 라이브러리다. FRP는 이벤트와 시간에 따라 변하는 값을 처리하기 위한 함수형 패러다임으로서 용례로는 유저 인터페이스, 시뮬레이션, 게임이 있다. Netwire는 애로 인터페이스 외에 applicative 인터페이스도 포함한다. Yampa (Haskell Wiki 페이지 라이브러리 문서)는 또 다른 애로 기반 FRP 라이브러리이며 Netwire의 전신이다. Hughes의 애로 스타일 파서는 그의 2000년 논문에서 처음 소개되었지만 가용한 구현은 2005년 5월에 Einar Karttunen이 PArrows를 릴리스하며 등장했다. 더 읽을거리 Bibilography on arrows (haskell.org) 애로를 소개한 논문. 출판사에서 무료로 열람할 수 있다. ↩ 이 두 개념은 각각 static arrow와 Kleisli arrow로 알려져 있다. "애로"라는 단어를 미묘하게 다른 두 가지 뜻으로 쓰면 이 글이 매우 혼란스러워지기 때문에 우리는 이 또 다른 뜻의 동의어인 "사상(morphism)"을 채택했다. ↩ 이것들이 static이라 불리는 이유다. 결과는 일련의 계산에 의해 확정된다. 생성된 값들은 결과에 영향을 주지 못한다. ↩ 자세한 것은 Idioms are oblivious, arrows are meticulous, monads are promiscuous, by Sam Lindley, Philip Wadler and Jeremy Yallop를 볼 것. ↩ 중첩된 튜플들을 처리하는 게 얼마나 혼란스러운지를 생각해 보면 "편하게"라는 조금 과장된 말이다. ↩ Arrow 및 우리가 여기서 논의하는 다른 애로 클래스들은 저마다 법칙을 가진다. 여기서 그 법칙들을 짚고 넘어가지는 않을 것이지만 Control.Arrow 문서에서 볼 수 있다. ↩ Data.Bifunctor는 7.10 버전에서 와서야 코어 GHC 라이브러리에 추가되었으므로 여러분이 예전 버전을 쓰고 있다면 설치되어 있지 않을 수도 있다. 그 경우 bifunctors 패키지를 설치하면 되며, 여기에는 바이펑터와 관련된 다른 모듈들도 들어있다. ↩ Swierstra, Duponcheel. Deterministic, error correcting parser combinators. ↩ Parsec은 유명하고 강력한 파싱 라이브러리다. 자세한 것은 Hackage의 parsec 문서를 볼 것. ↩ 07 Continuation Passing Style 원문: http://en.wikibooks.org/wiki/Haskell/Continuation_passing_style continuation 이란? 어떤 용도인가? continuation 전달하기 피타고라스 thrice Cont 모나드 callCC k의 사용 시점 결정하기 내막 예제: 복잡한 제어 구조 예제: 예외(exception) 예제: 코루틴 예제: 패턴 매칭 구현하기 노트 Continuation Passing Style (줄여서 CPS)는 함수가 값을 반환하지 않는 프로그래밍 스타일이다. CPS는 대신 continuation 을 이용해 제어권을 넘긴다. continuation은 다음에 무엇이 일어날지를 기술한다. 이번 장에서는 CPS가 하스켈에서 어떤 역할을 하고, 특히 모나드로 CPS를 표현하는 방법을 알아본다. continuation 이란? 혼란을 피하기 위해 앞에서 봤던 예제를 재차 살펴보겠다. ($) 연산자를 소개했을 때 > map ($ 2) [(2*), (4*), (8*)] [4,8,16] 위 표현식은 map (*2) [2, 4, 8]보다 조금 기묘하지만 이상할 건 없다. ($) 섹션은 코드를 거꾸로 보이게 만들어, 마치 값을 함수에 적용하는 것처럼 만든다. 이 별거 아닌 뒤집기가 continuation passing style의 핵심이다. CPS의 관점에서 ($ 2)는 유예 계산(suspended computation)이다. 이 함수의 타입은 일반화 타입 (a -> r) -> r으로서, 다른 함수를 인자로 받아 최종 결과를 도출한다. 인자 a -> r이 바로 continuation이다. 이것은 계산이 어떻게 결과로 이어지는지를 기술한다. 이 예제에서 리스트 내의 함수들은 map에 의해 continuation으로서 공급되고, 세 개의 개별 결과를 생산한다. 유예 계산은 대체로 평이한 값과 맞바꿀 수 있음에 주목할 것. flip ($) 1은 임의의 값을 유예 계산으로 변환하고, 이것의 continuation으로 id을 전달하면 원래 값을 돌려받는다. 어떤 용도인가? continuation은 그저 하스 켈 초보자를 놀래는 무대 마술이 아니다. CPS로 프로그램의 제어 흐름을 명시적으로 조작하고 크게 수정할 수 있다. 가령 어떤 프러시저(절차)에서 조기에 빠져나오는 것을 continuation으로 구현할 수 있다. 예외와 실패도 continuation으로 처리할 수 있다. 성공에 대한 continuation, 실패에 대한 continuation을 전달하고 알맞은 continuation을 실행하면 된다. 또 다른 가능성은 계산을 "유예" 하고 다른 때에 되돌아온다거나 단순한 형태의 동시성을 구현하는 것이다. (주목할 만한 것으로, 하스켈의 구현체 중 하나인 Hugs는 continuation을 사용해 협력적 cooperative 동시성을 구현한다) 하스켈에서는 continuation들을 비슷한 방식으로 이용하여 모나드 안에서 흥미로운 데이터 흐름을 구현할 수 있다. 그런 경우 대개는 대안이 있는데, 특히 지연성과 조화를 이룰 때 그러하다. 어떤 경우는 CPS가 특정 생성-패턴 매칭 시퀀스들(즉 함수가 반환하는 복잡한 구조체를 호출자 측에서 결국 분해할 예정인)을 소거하여 수행능력을 향상시키기도 한다. 충분히 똑똑한 컴파일러라면 그런 소거를 할 수 있어야 하지만. continuation 전달하기 continuation을 활용하는 기초적인 방법은 함수가 평범한 값 대신 유예 계산을 반환하도록 수정하는 것이다. 간단한 예제 두 개로 그 방법을 설명하겠다. 피타고라스 예: 간단한 모듈, continuation 미사용 -- We assume some primitives add and square for the example: add :: Int -> Int -> Int add x y = x + y square :: Int -> Int square x = x * x pythagoras :: Int -> Int -> Int pythagoras x y = add (square x) (square y) 유예 계산을 반환하도록 수정한 pythagoras는 이렇게 생겼다. 예: 간단한 모듈. continuation 사용함. -- We assume CPS versions of the add and square primitives, -- (note: the actual definitions of add_cps and square_cps are not -- in CPS form, they just have the correct type) add_cps :: Int -> Int -> ((Int -> r) -> r) add_cps x y = \k -> k (add x y) square_cps :: Int -> ((Int -> r) -> r) square_cps x = \k -> k (square x) pythagoras_cps :: Int -> Int -> ((Int -> r) -> r) pythagoras_cps x y = \k -> square_cps x $ \x_squared -> square_cps y $ \y_squared -> add_cps x_squared y_squared $ k pythagoras 예제는 이렇게 작동한다. x를 제곱하고 그 결과를 (\x_squared -> ...) continuation 안으로 던진다 y를 제곱하고 그 결과를 (\y_squared -> ...) continuation 안으로 던진다 x_squared와 y_squared를 더하고 그 결과를 최상위/프로그램 continuation인 k로 던진다 print를 프로그램 continuation으로서 전달하여 GHCi에서 이것을 시험해 볼 수 있다. *Main> pythagoras_cps 3 4 print 25 (Int -> r) -> r의 부가적인 괄호들을 떼고 pythagoras_cps의 타입을 원래 pythagoras의 타입과 비교하면 continuation이 사실은 여분의 인자로 추가된 것을 볼 수 있다. "continuation passing style"이라는 이름이 왜 붙었는지 알 것 같다. 역자 주: pythagoras_cps 3 4 print의 치환 과정 pyth_cps 3 4 print = square_cps x $ \x2 -> square_cps y $ \y2 -> add_cps x2 y2 print = square_cps x (\x2 -> square_cps y (\y2 -> add_cps x2 y2 print)) = square_cps x (\x2 -> square_cps y (\y2 -> print (add x2 y2)) = (\x2 -> square_cps y (\y2 -> print (add x2 y2)) (square x) = ((\x2 -> (\y2 -> print (add x2 y2)) (square y)) (square x) = (\y2 -> print (add (square x) y2)) (square y) = print (add (square x) (square y)) thrice 예: 간단한 고차 함수. continuation 미사용. thrice :: (a -> a) -> a -> a thrice f x = f (f (f x)) *Main> thrice tail "foobar" "bar" thrice 같은 고차 함수는 CPS로 변환하고 나면 인자도 CPS 형태로 받는다. 따라서 f :: a -> a는 f_cps :: a -> ((a -> r) -> r)이 되고 최종 타입은 thrice_cps :: (a -> ((a -> r) -> r)) -> a -> ((a -> r) -> r)이 된다. 정의의 나머지 부분은 타입에서 자연스럽게 나온다. f를 CPS 버전으로 치환해 continuation을 손수 전달한다. 예: 간단한 고차 함수. continuation 사용함. thrice_cps :: (a -> ((a -> r) -> r)) -> a -> ((a -> r) -> r) thrice_cps f_cps x = \k -> f_cps x $ \fx -> f_cps fx $ \ffx -> f_cps ffx $ k Cont 모나드 continuation-passing 함수를 장만했으면 다음 단계로 이들을 합성하는 영리한 방법, 특히 위처럼 중첩 람다를 길게 연쇄할 필요가 없는 방법이 필요하다. CPS 함수를 suspended computation에 적용하는 컴비네이터가 좋은 출발점인 것 같다. 다음과 같은 타입이 가능하다. chainCPS :: ((a -> r) -> r) -> (a -> ((b -> r) -> r)) -> ((b -> r) -> r) (계속 읽기 전에 이걸 구현해 보고 싶은가? 힌트: 결과가 b -> r continuation을 취하는 함수임을 기술하는 것으로 시작하라. 그다음은 타입이 여러분을 이끌 것이다.) 그리고 이것이 그 구현이다. chainCPS s f = \k -> s $ \x -> f x $ k 기존의 suspended computation s를, 새로운 유예 계산(f에 의해 생성됨)을 생성하는 continuation에 공급하고, 여기에 최종 계산 k를 넘긴다. 놀랄 것도 없이 이는 앞선 예제의 중첩 람다 패턴을 고스란히 따른다. chainCPS의 타입이 익숙하지 않은가? (a -> r) -> r을 (Monad m) => m a로, (b -> r) -> r을 (Monad m) => m b로 치환하면 (>>=) 시그너처를 얻는다. 더욱이 우리의 오랜 친구 flip ($)은 마치 return 같은 역할을 하여, 유예 계산을 하나의 값으로 만든다. 맙소사, 모나드다! 이제 필요한 것은 3 유예 계산을 감싸며 통상의 래퍼와 언래퍼가 있는 Cont r a 타입뿐이다. cont :: ((a -> r) -> r) -> Cont r a runCont :: Cont r a -> (a -> r) -> r Cont에 대한 모나드 인스턴스는 우리의 표현법에서 바로 도출되며, 유일한 차이점은 래핑과 언래핑 전략이다. instance Monad (Cont r) where return x = cont ($ x) s >>= f = cont $ \c -> runCont s $ \x -> runCont (f x) c 결론은 이 모나드 인스턴스가 continuation passing(그리고 람다 연쇄)를 암묵적으로 만든다는 것이다. 모나 딕 바인드는 CPS 함수를 유예 계산에 적용하고, runCont는 최종 continuation을 제공하는 데 사용된다. 간단한 예로 피타고라스 예제는 다음과 같이 된다. 예: Cont 모나드를 이용한 pythagoras -- Using the Cont monad from the transformers package. import Control.Monad.Trans.Cont add_cont :: Int -> Int -> Cont r Int add_cont x y = return (add x y) square_cont :: Int -> Cont r Int square_cont x = return (square x) pythagoras_cont :: Int -> Int -> Cont r Int pythagoras_cont x y = do x_squared <- square_cont x y_squared <- square_cont y add_cont x_squared y_squared callCC 자연스레 유도되는 모나드를 보는 것은 언제든지 기분 좋지만, 이 시점에서 실망의 여지가 남을 수도 있다. CPS의 약속 중 하나는 continuation을 통한 정밀한 제어 흐름 조작이다. 그런데 우리는 함수를 CPS로 변환하고 곧바로 continuation을 모나드 뒤에 숨겨버렸다. 이것을 바로잡기 위해 continuation의 명시적 제어를 (원할 때만) 되돌려주는 callCC 함수를 소개한다. callCC 함수는 아주 특이한 함수인데, 예제로 소개하는 것이 최고다. 자명한 예제로 시작해 보자. 예: callCC를 이용한 square -- Without callCC square :: Int -> Cont r Int square n = return (n ^ 2) -- With callCC squareCCC :: Int -> Cont r Int squareCCC n = callCC $ \k -> k (n ^ 2) callCC에 전달되는 인자는 함수로서 그 결과는 (일반화된 Cont r a 타입의) 유예 계산이며 앞으로 "callCC 계산"이라 칭할 것이다. 원칙적으로 callCC 계산은 callCC 표현식 전체가 평가되는 결과다. 주의할 것은, callCC를 특별하게 만드는 점이기도 한데, 인자에 대한 인자인 k다. k는 사출 장치 같은 함수다. 어디서든 k를 호출하면 k에 전달된 값이 유예 계산 내에 형성되고 그러면 callCC 호출 시점에서 제어 흐름 내에 삽입된다. 이것은 무조건 일어난다. 특히 callCC 계산에서 k 호출 다음에 무엇이 오든 즉시 제거된다. 다른 관점에서 보면 k는 callCC 다음의 계산의 나머지를 포착한다. k를 호출하면 그 시점에 값을 계산 내에 던진다("callCC"의 뜻은 "현재 continuation으로 호출함(call with current continuation)"이다) 이 간단한 예제에서는 그 결과가 평이한 return이지만 callCC는 수많은 가능성을 열어주며 이제 이를 탐험하려 한다. k의 사용 시점 결정하기 callCC는 우리에게 continuation 내에 무엇을 던질지, 그것이 언제 끝날지를 결정하는 권한을 준다. 다음 예제는 이 힘의 활용법을 보여주는 출발점이다. 예: 그럴듯한 첫 번째 callCC 함수 foo :: Int -> Cont r String foo x = callCC $ \k -> do let y = x ^ 2 + 3 when (y > 20) $ k "over twenty" return (show $ y - 4) foo는 입력을 제공하고 3을 더하는 약간 병적인 함수다. 이 계산의 결과가 20보다 크면 callCC 계산을 즉시 종료하고(이 경우 전체 함수를 종료), foo에 전달될 continuation 내에 문자열 "over twenty"를 던진다. 아니면 이전의 계산에서 4를 빼고, show를 적용하고, continuation 내에 던진다. 주목할 것은 k가 명령형 언어에서 함수를 즉시 종료하는 return 명령문처럼 쓰였다는 것이다. 그럼에도 여전히 하스켈이고, k는 평범한 일급 함수이므로 when 같은 다른 함수에 전달하거나 Reader에 저장하는 게 가능하다. 자연스레 callCC 호출을 do 블록 안에 넣을 수 있다. 예: do 블록을 사반한 더 발전된 `callCC` 예제 bar :: Char -> String -> Cont r Int bar c s = do msg <- callCC $ \k -> do let s0 = c : s when (s0 == "hello") $ k "They say hello." let s1 = show s0 return ("They appear to be saying " ++ s1) return (length msg) 값을 가지고 k를 호출할 때 callCC 호출 전체가 그 값을 취한다. 그 결과 k는 다른 언어의 goto 명령처럼 된다. 이 예제에서 k를 호출하면 callCC를 처음 호출한 msg <- callCC $ ... 줄로 실행 흐름을 옮겨버린다. callCC에 대한 인자(내부 do 블록)는 더 이상 실행되지 않는다. 따라서 다음 예제는 쓸모없는 줄을 포함하는 셈이다. 예: 함수 빠져나오기, 쓸모없는 줄 있음. quux :: Cont r Int quux = callCC $ \k -> do let n = 5 k n return 25 quux는 25가 아니라 5를 반환한다. return 25 줄에 다다르기 전에 quux를 종료하기 때문이다. 내막 지금까지 CPS라는 트렌드를 정성껏 분해했다. 함수를 소개할 때면 그 타입부터 보여주곤 했는데 이번엔 그렇게 하지 않았다. 이유는 단순하다. 이 타입은 상당히 복잡해서 이 함수가 무얼 하고 어떻게 작동하는지에 대한 통찰을 바로 주지 않는다. 하지만 이제 callCC를 분석해 볼 만하다. 숨을 깊게 들이쉬고... callCC :: ((a -> Cont r b) -> Cont r a) -> Cont r a 우리가 callCC에 대해 알고 있는 것에 기초해 위문장을 이해할 수 있다. 최종 결과 타입과 인자의 결과 타입은 Cont r a으로 같아야 한다. k를 호출하지 않아도 그에 대응하는 결괏값이 같은 타입이어야 하기 때문이다. 그럼 k의 타입은? 앞서 언급했듯 k의 인자는 유예 계산 내에 형성되고 이 계산은 callCC 호출 시점에 삽입된다. 따라서 후자가 Cont r a 타입이라면 k의 인자는 a 타입이어야만 한다. 흥미롭게도 k의 결과 타입은 같은 Cont r 안에만 있으면 상관없다. 달리 말하자면 b는 임의의 타입을 뜻한다. a 인자로 이루어진 유예 계산이 callCC에 따라오는 continuation을 받을 것이고, 따라서 k의 결과가 취할 continuation은 무관하기 때문이다. 잠깐 k의 결과 타입이 무작위라는 것은 '쓸모없는 줄' 예제를 조금 수정한 다음 코드가 왜 타입 오류를 일으키는지를 설명한다. quux :: Cont r Int quux = callCC $ \k -> do let n = 5 when True $ k n k 25 k의 결과 타입은 Cont r a 형태이면 무엇이든 될 수 있다. 하지만 when은 그 결과를 Cont r ()으로 제한하기 때문에 마지막의 k 25는 quux의 결과 타입과 일치하지 않는다. 해결책은 간단하다. 끝의 k를 평범한 return으로 교체하라. callCC의 구현과 함께 이 절을 마무리하겠다. 여기서 k를 알아보겠는가? callCC f = cont $ \h -> runCont (f (\a -> cont $ \_ -> h a)) h 썩 명쾌하지 않은 코드다. 그런데 놀라운 것은 Cont에 대한 callCC, return, (>>=)의 구현을 그 타입 시그너쳐로부터 자동으로 도출할 수 있다는 것이다. Lennart Augustsson의 프로그램 Djinn[1]이 그런 일을 해준다. Djinn의 이론적 배경에 관해서는 Phil Gossett의 구글 tech talk를 보라. [2] 그리고 Pan Piponi의 이 글[3]은 continuous passing style을 파생하는 데 Djinn을 사용한다. 예제: 복잡한 제어 구조 이제 제어 흐름 조작에 관한 좀 더 현실적인 예시를 보자. 밑에 제시된 예시는 원래 All about monads 튜토리얼의 "The continuation monad" 절에서 가져온 것으로, 허가를 받고 사용했다. 예: 복잡한 제어 구조를 위해 Cont 사용하기 {- We use the continuation monad to perform "escapes" from code blocks. This function implements a complicated control structure to process numbers: Input (n) Output List Shown ========= ====== ========== 0-9 n none 10-199 number of digits in (n/2) digits of (n/2) 200-19999 n digits of (n/2) 20000-1999999 (n/2) backwards none >= 2000000 sum of digits of (n/2) digits of (n/2) -} fun :: Int -> String fun n = (`runCont` id) $ do str <- callCC $ \exit1 -> do -- define "exit1" when (n < 10) (exit1 (show n)) let ns = map digitToInt (show (n `div` 2)) n' <- callCC $ \exit2 -> do -- define "exit2" when ((length ns) < 3) (exit2 (length ns)) when ((length ns) < 5) (exit2 n) when ((length ns) < 7) $ do let ns' = map intToDigit (reverse ns) exit1 (dropWhile (=='0') ns') --escape 2 levels return $ sum ns return $ "(ns = " ++ (show ns) ++ ") " ++ (show n') return $ "Answer: " ++ str fun은 정수 n을 취하는 함수다. 그 구현은 Cont와 callCC를 사용해 제어 구조를 구축하는데 주석에 적힌 대로 n이 속하는 범위에 따라 다른 일을 한다. 코드를 해부해 보자. 맨 위의 (runCont id)는 우리가 Cont 블록을 실행하는데 최종 continuation이 id 임을 뜻한다(달리 말하자면 유예 계산으로부터 값을 변경하지 않고 추출한다). fun의 결과 타입이 Cont를 언급하지 않기 때문에 필수다. 따라오는 callCC do 블록의 결과에 str을 바인딩 한다. n이 10보다 작으면 곧장 종료하고 n을 보여준다. 아니면 계속한다. n `div` 2의 자릿수들을 담는 리스트 ns를 구축한다. n'(Int 값)은 따라오는 callCC do 블록의 결과에 바인딩 한다. length ns < 3이면, 즉 n `div` 2의 자릿수가 3보다 작으면 그 결괏값을 가지고 이 안쪽 do 블록을 빠져나온다. n `div` 2의 자릿수가 5보다 작으면 원래 n을 반환하며 안쪽 do 블록을 빠져나온다. n `div` 2의 자릿수가 7보다 작으면 안쪽과 바깥쪽 do 블록을 둘 다 빠져나오는데 n `div` 2의 자릿수들을 순서를 뒤집어 반환한다. 그 외의 경우 n `div` 2의 자릿수들의 합을 반환하며 내부 do 블록을 종료한다. 문자열 "(ns = X) Y"을 반환하며 이 do 블록을 반환한다. 여기서 X는 ns 즉 n `div` 2의 자릿수들이고 Y는 안쪽 do 블록의 결과인 n'이다. 마지막으로 함수 전체를 종료한다. 그 결과는 문자열 "Answer: Z"인데 여기서 Z는 callCC do 블록으로부터 얻은 문자열이다. 예제: 예외(exception) continuation으로 예외를 모델링 할 수 있다. 그러려면 continuation 두 개를 유지해야 한다. 하나는 예외가 발생할 경우 그 핸들러로 우리를 데려가고 다른 하나는 성공한 경우 후처리 코드로 데려간다. 다음 함수는 두 수를 취해 정수 나눗셈을 하는데, 분모가 0인 경우 실패한다. 예: 예외를 던지는 div divExcpt :: Int -> Int -> (String -> Cont r Int) -> Cont r Int divExcpt x y handler = callCC $ \ok -> do err <- callCC $ \notOk -> do when (y == 0) $ notOk "Denominator 0" ok $ x `div` y handler err {- For example, runCont (divExcpt 10 2 error) id --> 5 runCont (divExcpt 10 0 error) id --> *** Exception: Denominator 0 -} 어떻게 작동하는 걸까? 여기선 callCC를 중첩하여 두 번 호출한다. 첫 번째는 아무 문제가 없을 경우 쓰일 continuation에 이름을 붙이고, 두 번째는 예외를 던지고 싶을 때 쓰일 continuation에 이름을 붙인다. 분모가 0이 아니면 x `div` y는 ok continuation에 던져지고 따라서 실행 흐름은 divExcept의 최상위로 바로 빠져나간다. 하지만 분모가 0이면 notOK continuation에 오류 메시지를 던지고 이 continuation은 내부 do 블록을 빠져나오게 만든다. 이 문자열은 err에 할당되고 handler에 전달된다. 예외를 처리하는 보다 범용적인 접근법을 다음 함수에서 볼 수 있다. 계산을 첫 번째 매개변수로(정확히는 오류를 던지는 함수를 취하고 계산을 반환하는 함수다), 오류 처리기를 두 번째 매개변수로 취한다. 이 예는 일반화된 MonadCont 클래스 4를 활용한다. 이 클래스는 Cont와 이에 대응하는 ContT 변환기를 기본으로 포함하고 이것들을 인스턴스화하는 다른 continuation 모나드들도 포함한다. 예: continuation을 사용한 일반화된 try import Control.Monad.Cont tryCont :: MonadCont m => ((err -> m a) -> m a) -> (err -> m a) -> m a tryCont c h = callCC $ \ok -> do err <- callCC $ \notOk -> do x <- c notOk ok x h err 그리고 다음은 try를 실제로 활용한 것이다. 예: try의 활용 data SqrtException = LessThanZero deriving (Show, Eq) sqrtIO :: (SqrtException -> ContT r IO ()) -> ContT r IO () sqrtIO throw = do ln <- lift (putStr "Enter a number to sqrt: " >> readLn) when (ln < 0) (throw LessThanZero) lift $ print (sqrt ln) main = runContT (tryCont sqrtIO (lift . print)) return 이 예제에서 오류를 던진다는 것은 에워싸는 callCC를 빠져나오는 것을 의미한다. sqrtIO 내의 throw는 tryCont의 내부 callCC를 빠져나온다. 예제: 코루틴 이 절에서는 CoroutineT 모나드를 제작한다. 이 모나드는 새로운 유예 코루틴을 enqueue 하는 fork와 현 스레드를 유예하는 yield를 제공한다. {-# LANGUAGE GeneralizedNewtypeDeriving #-} -- We use GeneralizedNewtypeDeriving to avoid boilerplate. As of GHC 7.8, it is safe. import Control.Applicative import Control.Monad.Cont import Control.Monad.State -- The CoroutineT monad is just ContT stacked with a StateT containing the suspended coroutines. newtype CoroutineT r m a = CoroutineT {runCoroutineT' :: ContT r (StateT [CoroutineT r m ()] m) a} deriving (Functor, Applicative, Monad, MonadCont, MonadIO) -- Used to manipulate the coroutine queue. getCCs :: Monad m => CoroutineT r m [CoroutineT r m ()] getCCs = CoroutineT $ lift get putCCs :: Monad m => [CoroutineT r m ()] -> CoroutineT r m () putCCs = CoroutineT . lift . put -- Pop and push coroutines to the queue. dequeue :: Monad m => CoroutineT r m () dequeue = do current_ccs <- getCCs case current_ccs of [] -> return () (p:ps) -> do putCCs ps p queue :: Monad m => CoroutineT r m () -> CoroutineT r m () queue p = do ccs <- getCCs putCCs (ccs++[p]) -- The interface. yield :: Monad m => CoroutineT r m () yield = callCC $ \k -> do queue (k ()) dequeue fork :: Monad m => CoroutineT r m () -> CoroutineT r m () fork p = callCC $ \k -> do queue (k ()) p dequeue -- Exhaust passes control to suspended coroutines repeatedly until there isn't any left. exhaust :: Monad m => CoroutineT r m () exhaust = do exhausted <- null <$> getCCs if not exhausted then yield >> exhaust else return () -- Runs the coroutines in the base monad. runCoroutineT :: Monad m => CoroutineT r m r -> m r runCoroutineT = flip evalStateT [] . flip runContT return . runCoroutineT' . (<* exhaust) 다음은 활용 예시다. printOne n = do liftIO (print n) yield example = runCoroutineT $ do fork $ replicateM_ 3 (printOne 3) fork $ replicateM_ 4 (printOne 4) replicateM_ 2 (printOne 2) 출력: 4 2 3 4 예제: 패턴 매칭 구현하기 CPS 함수의 흥미로운 용법으로 패턴 매칭을 직접 구현하는 것이 있다. 예제를 통해 그 방법을 설명하겠다. 예제: 내장된 매칭 check :: Bool -> String check b = case b of True -> "It's True" False -> "It's False" CPS를 배웠으니 이 코드를 다음과 같이 리팩토링할 수 있다. type BoolCPS r = r -> r -> r true :: BoolCPS r true x _ = x false :: BoolCPS r false _ x = x check :: BoolCPS String -> String check b = b "It's True" "It's False" *Main> check true "It's True" *Main> check false "It's False" 여기서 일어나는 일을 보면 True와 False를 평범한 값 대신 함수로 표현했는데, 이 함수들은 전달받은 인자들 중 첫 번째 또는 두 번째를 선택한다. true와 false가 서로 다르게 행동하기 때문에 우리는 패턴 매칭과 동일한 효과를 달성할 수 있다. 더욱이 True, False와 true, false는 \b -> b True False와 \b -> if b then true else false를 통해 서로 변환될 수 있다. 조금 더 복잡한 예제를 통해 이것이 CPS와 어떻게 연관되는지 알아보자. 예제: 더 복잡한 패턴 매칭과 그것의 CPS 버전 data Foobar = Zero | One Int | Two Int Int type FoobarCPS r = r -> (Int -> r) -> (Int -> Int -> r) -> r zero :: FoobarCPS r zero x _ _ = x one :: Int -> FoobarCPS r one x _ f _ = f x two :: Int -> Int -> FoobarCPS r two x y _ _ f = f x y fun :: Foobar -> Int fun x = case x of Zero -> 0 One a -> a + 1 Two a b -> a + b + 2 funCPS :: FoobarCPS Int -> Int funCPS x = x 0 (+1) (\a b -> a + b + 2) *Main> fun Zero *Main> fun $ One 3 *Main> fun $ Two 3 4 *Main> funCPS zero *Main> funCPS $ one 3 *Main> funCPS $ two 3 4 앞선 예제와 비슷하게 함수를 이용해 값을 표현한다. 이 함수-값들은 전달받은 continuation들 중 대응하는 (즉 매칭되는) 것을 골라서 전자에 보관되어 있던 값들을 후자에 전달한다. 흥미로운 점은 이 과정에 비교가 관여하지 않는다는 것이다. 알고 있듯이 패턴 매칭은 Eq의 인스턴스가 아닌 타입들에도 작동한다. 함수-값들은 패턴들이 무엇인지 "알고" 올바른 continuation을 자동으로 선택한다. 이걸 가령 pattern_match :: [(pattern, result)] -> value -> result 같은 함수를 통해 외부에서 수행한다면 매칭하는지 보기 위해 패턴들과 값들을 조사하고 비교해야 했을 것이고, 따라서 Eq 인스턴스가 필요했을 것이다. 노트 즉 \x -> ($ x)으로, 완전히 풀어쓰면 \x -> \k -> k x이다. ↩ attoparsec은 퍼포먼스를 위해 CPS를 활용한 예시다. ↩ 모나드 법칙이 성립한다는 것은 독자에게 연습 문제로 남긴다. ↩ Control.Monad.Cont 모듈은 mtl 패키지에 들어있다. ↩ 08 지퍼 원문: http://en.wikibooks.org/wiki/Haskell/Zippers 테세우스와 지퍼 미궁(The Labyrinth) 아라드네의 지퍼(Zipper) 데이터 타입의 미분 기계적 미분 미분을 통한 지퍼 고정점의 미분 함수를 함수에 대해 미분하기 지퍼 vs 문맥 결론 노트 테세우스와 지퍼 미궁(The Labyrinth) "테세우스. 문제가 생겼어." Ancient Geeks 주식회사의 최고마케팅경영자 호머가 말했다. 테세우스는 미노타우로스 피겨™를 선반에 올려놓고 고개를 끄덕였다. "요즘 애들은 고대 신화에 관심이 없어. 스파이더맨이나 스폰지 밥 같은 최신 영웅을 좋아하지." 영웅이라, 테세우스는 크레타 1에서 자신이 얼마나 영웅적이었는지 잘 알고 있다. 하지만 "요즘 영웅들"은 사실적으로 보이려는 시도조차 하지 않는다. 성공 요인이 뭘까? 어쨌든, 상품이 안 팔리는 문제를 해결하지 않으면 주주들이 Ancient Geeks 주식회사를 위해 스틱스 강에 길을 터놓을 지도 모른다. "알았다! 테세우스. 생각이 있어. 너와 미노타우로스 이야기를 컴퓨터 게임으로 구현하는 거야! 어때?" 호머 말이 맞다. 책도 있고, (차트를 석권한) 서사시도 있고, 영화 3부작에, 셀 수 없는 테세우스 & 미노타우루스™ 기믹이 있는데 컴퓨터 게임만 없다. "완벽해. 자, 테세우스. 그걸 이제 네가 구현해야 함ㅋ" 참된 영웅 테세우스는 회사의 기사회생을 위한 제품을 구현할 언어로 하스켈을 선택했다. 물론 미노 타우루스의 미궁을 탐험하는 게 게임의 하이라이트다. 테세우스는 고민에 빠졌다. "2차원 미궁이 있는데 통로들이 여러 방향으로 갈라지지. 물론 세세한 길이와 각도로 추상화할 수 있어. 나가는 길을 찾으려면 그 경로가 어떻게 갈라지는 지만 알면 돼. 미궁을 트리로 모델링 하는 게 쉬울 거야. 이러면 한 갈림길의 두 분기는 더 깊이 들어감에 따라 서로 합쳐지지 않고 플레이어는 빙글빙글 돌 수 없지. 하지만 길을 잃을 가능성이 충분해. 그리고 플레이어가 충분히 인내심이 있으면 왼손 짚기로 미궁 전체를 탐험할 수 있어." data Node a = DeadEnd a | Passage a (Node a) | Fork a (Node a) (Node a) 예시 미궁과 그 트리 표현 테세우스는 미궁의 노드들이 a 타입의 여분의 매개변수를 보관하도록 만들었다. 이 변수는 나중에 노드의 위치, 주변의 조명, 바닥에 놓인 게임 아이템 목록, 근처에서 어슬렁거리는 몬스터 목록 같은 게임 관련 정보를 담을 것이다. 이제 도우미 함수 두 개를 생각해 보자. get :: Node a -> a put :: a -> Node a -> Node a 이것들은 Node a의 모든 생성자의 첫 번째 인자에 저장된 a 타입의 값을 획득하고 변경한다. 연습문제 get과 put을 구현하라. get의 경우 get (Passage x _) = x이다. 구체적인 예시로, 위 그림의 미궁을 Node (Int, Int) 타입의 값을 이용해 작성하라. 여분의 매개변수 (Int, Int)는 노드의 직교 좌표를 담는다. "그런데 미궁에서 플레이어의 현 위치를 어떻게 표현하지? 플레이어는 왼쪽이나 오른쪽 분기를 선택해서 더 깊숙이 들어갈 수 있어. 이렇게..." turnRight :: Node a -> Maybe (Node a) turnRight (Fork _ l r) = Just r turnRight _ = Nothing "하지만 미궁의 현 최상위를 하위 미궁으로 치환하면 되돌아올 수가 없어." 테세우스는 고심했다. "아, 아라드네의 실타래로 되돌아오기 방법을 응용할 수 있어. 플레이어의 위치를 실타래를 풀어헤친 분기들의 목록으로 나타내면 미궁은 그대로 남아있지." data Branch = KeepStraightOn | TurnLeft | TurnRight type Thread = [Branch] 아라드네의 실로 표현한 플레이어 위치 "가령 [TurnRight, KeepStraightOn] 실뭉치는 플레이어가 입구에서 오른쪽 갈림길로 가고 Passage 하나를 직진해서 지금 위치에 도달했다는 뜻이야. 이 실뭉치를 가지고 미궁을 더 깊숙이 들어가거나 되돌아올 수가 있지. 예를 들어 turnRight 함수는 실뭉치에 TurnRight을 덧붙이는 거야." turnRight :: Thread -> Thread turnRight t = t ++ [TurnRight] "여분의 자료, 즉 게임 관련 아이템 같은 것에 접근하려면 실뭉치를 따라가면 되고." retrieve :: Thread -> Node a -> a retrieve [] n = get n retrieve (KeepStraightOn:bs) (Passage _ n) = retrieve bs n retrieve (TurnLeft :bs) (Fork _ l r) = retrieve bs l retrieve (TurnRight :bs) (Fork _ l r) = retrieve bs r 연습문제 a -> a 타입의 함수를 플레이어 위치에 있는 여분의 데이터에 적용하는 update 함수를 작성하라. 이 해결책에 대한 테세우스의 만족은 그리 오래가지 않았다. "그런데 경로를 늘리거나 되돌아가려면 리스트의 마지막 원소를 변경해야 하는데. 리스트를 반대로 저장하면 플레이어 위치의 미궁 데이터를 접근할 때 실뭉치를 계속 따라가야 하고. 둘 다 실뭉치의 길이에 비례하는 시간이 걸리는데, 미궁이 크면 너무 오래 걸릴 거야. 다른 방법 없나?" 아라드네의 지퍼(Zipper) 테세우스는 노련한 전사지만 프로그래밍 기술은 많이 훈련하지 않아서 만족스러운 해답을 찾을 수 없었다. 별 소득 없이 고심하던 테세우스는 옛사랑 아라드네에 게 조언을 구하기로 결심했다. 어쨌든 실뭉치를 고안한 것도 아라드 네지 않은가. "아라드네 상담소입니다. 무엇을 도와드릴까요?" 테세우스는 그 목소리를 즉시 알아봤다. "아라드네. 안녕. 나야. 테세우스." 불편한 정적이 대화를 끊었다. 테세우스는 아라드네를 낙소스 섬에 버렸던 자신을 똑똑히 기억하고 있었고 아라드네가 자신의 전화를 반기지 않을 것도 알고 있었다. 하지만 어쩌겠는가. Ancient Geeks 주식회사가 하데스에게 가는 길목에 서 있고 다른 방법이 없는 것을. "어... 자기... 잘 지내?" 아라드네가 차갑게 대꾸했다. "테세우스 씨. 자기라 부르던 때는 한참 오래전이지. 뭘 원해?" "아, 그게, 프로그래밍 문제가 좀 생겨서. 나 테세우스와 미노타우로스™라는 컴퓨터 게임을 만들고 있는데." "당신의 '영웅성'을 빛내기 위한 또 다른 장식품인가? 그거 때문에 차고 넘치는 사람들 중에 나를 보고 도와달라고? 아라드네가 야유했다. "아라드네. 제발. 이렇게 빌게. 우리 주식회사가 파산할 지경이란 말이야. 이 게임이 마지막 희망이야!" 잠깐의 정적이 흐르고 아라드네는 결정을 내렸다. "좋아, 도와주지. 대신 주식의 상당 부분을 떼줘야겠어. 30퍼센트." 테세우스의 안색이 창백해졌다. 하지만 달리 방법이 있겠는가? 이미 상황은 충분히 절망적이었고 테세우스는 아라드네의 공동 지분을 10퍼센트로 협상했다. 테세우스가 고심하던 미궁 표현법을 아라드네에 게 말하자 즉시 조언을 받았다. "지퍼 면 되겠군." "뭐? 이거랑 내 바지 지퍼랑 무슨 상관이..." "아니. 지퍼는 Gérard Huet2가 제안한 자료구조야." "아?" "좀 더 자세히는, 리스트나 이진 트리 같은 트리 류의 자료구조에서 내부의 한 하위 트리를 단번에 짚어 상수 시간 내에 갱신 및 검색을 할 수 있는 순수 함수형 수단이지. 3 네 경우에는 플레이어의 위치에 신경을 쓰는 거고." "고속 갱신이야 하고 싶지. 그런데 코딩을 어떻게 하지?" "기다려봐. 코딩으로 문제를 해결할 수는 없어. 생각해야 풀 수 있지. 순수 함수형 자료구조에서 우리가 상수 시간 내에 갱신할 수 있는 것은 최상위 노드뿐이야. 45 그러니까 최상위에 집중해야 해. 지금으로선 네 미궁의 최상위 노드가 항상 입구인데, 미궁을 하위 미궁으로 치환하는 네 발상은 플레이어의 위치를 최상위 노드로 놓게 되지." "문제는 어떻게 돌아가느냐야. 플레이어가 선택하지 않은 하위 미궁은 싹 소실되니까." "내 실뭉치를 활용해." 아라드네는 어리둥절한 테세우스가 이미 시도해 봤다고 불평할 틈을 주지 않고 빠르게 이어갔다. "소실된 하위 미궁들을 실뭉치에 붙여서 실제로는 소실되지 않게 하는 게 핵심이야. 실뭉치와 현 하위 미궁이 서로를 보충해 전체 미궁을 이루게 하는 거지. '현' 하위 미궁은 플레이어가 서 있는 곳을 뜻해. 지퍼는 단순히 실뭉치와 현 하위 미궁으로 구성되지." type Zipper a = (Thread a, Node a) 지퍼는 아라드네의 실뭉치와 플레이어가 서 있는 하위 미궁의 최상위로 구성된 짝이다. 주 실뭉치는 적색으로 표시되었고 하위 미궁들이 붙어있다. 이 짝을 가지고 미궁 전체를 재구축할 수 있다. 테세우스는 아무 말이 없었다. "실뭉치를 현 하위 미궁이 놓인 컨텍스트로 볼 수도 있지. 이제 Thread a를 정의할 방법을 찾아보자고. Thread는 이제 하위 미궁들을 보관해야 하기 때문에 여분의 매개변수 a를 취해야 해. 실뭉치는 여전히 갈림길의 리스트지만 갈림길 자체는 좀 달라지지." data Branch a = KeepStraightOn a | TurnLeft a (Node a) | TurnRight a (Node a) type Thread a = [Branch a] "가장 중요한 건 TurnLeft와 TurnRight에 하위 미궁이 붙는다는 거야. 플레이어가 오른쪽으로 가면 실뭉치에 TurnRight을 더하고 이 TurnRight에는 선택하지 않은 왼쪽 갈림길을 붙여서 소실되지 않게 하는 거지." 테세우스가 끼어들었다. "잠깐만. 그걸 어떻게 turnRight라는 함수로 구현할 수 있지? 그리고 TurnRight의 a 타입 첫 번째 인자는? 아, 잠깐. 소실될 갈림길만 붙이는 게 아니라 Fork라는 추가 자료도 붙이는 거구나. 아니면 이것도 소실되니까. 그럼 새 갈림길을 생성할 수 있어." branchRight (Fork x l r) = TurnRight x l "이제 어떻게든 이걸 가지고 기존 실뭉치를 확장해야 하는데..." "실뭉치에 관한 두 번째 사항은 거꾸로 저장된다는 거야. 실뭉치를 확장하려면 리스트의 맨 앞에 새 갈림길을 놓는 거야. 되돌아가려면 최상위 원소를 삭제하고." "아하. 그러면 내가 전에 했던 것과 달리 확장과 후퇴에 상수 시간만 걸리는군. 그럼 turnRight의 최종 버전은..." turnRight :: Zipper a -> Maybe (Zipper a) turnRight (t, Fork x l r) = Just (TurnRight x l : t, r) turnRight _ = Nothing 입구에서 오른쪽 하위 트리 선택. 당연히 처음에는 실뭉치가 비어있다. 실뭉치는 역방향으로 간다는 것을 명심하라. 즉 최상위 조각이 가장 최근의 것이다. "별로 어렵지 않은데. 통로를 직진하는 keepStraightOn은 갈림길 고르기보다 쉽지. 여분의 데이터만 유지하면 되니까." keepStraightOn :: Zipper a -> Maybe (Zipper a) keepStraightOn (t, Passage x n) = Just (KeepStraightOn x : t, n) keepStraightOn _ = Nothing 이번에는 통로를 직진한다. 연습문제 turnLeft 함수를 작성하라. 테세우스는 만족하고 계속했다. "물론 후퇴가 흥미로운 부분이지. 어디 보자..." back :: Zipper a -> Maybe (Zipper a) back ([] , _) = Nothing back (KeepStraightOn x : t, n) = Just (t, Passage x n) back (TurnLeft x r : t, l) = Just (t, Fork x l r) back (TurnRight x l : t, r) = Just (t, Fork x l r) "실뭉치가 비어있으면 미궁의 입구에 있는 거고 후퇴할 수 없지. 다른 경우엔 실뭉치를 감아올리고. 그리고 실뭉치의 부착물 덕에 우리가 지나왔던 하위 미궁을 재구축할 수 있어." 아라드네가 첨언했다. "좌변에 바운딩된 변수 x, l, r이 우변에도 딱 한 번씩만 나타나는 걸 봐. 따라서 지퍼를 올리거나 내릴 때 실뭉치와 현 하위 미궁 사이에서만 데이터를 재배치하는 거지." 연습문제 이제 지퍼를 돌아다닐 수 있으니 플레이어 위치의 추가 데이터에 작용하는 get, put, update 함수를 코딩해 보자. 지퍼는 Node a라는 특정 사례에 국한되지 않는다. 트리 류의 모든 자료구조에 대해 지퍼를 구축할 수 있다. 이진 트리의 지퍼를 구축해 보라. data Tree a = Leaf a | Bin (Tree a) (Tree a) 실뭉치가 취할 수 있는 가능한 분기 즉 Branch a에서 시작할 것. 트리를 탐색할 때 실뭉치에 붙일 것은 무엇인가? 단순한 리스트도 지퍼를 가질 수 있다. data List a = Empty | Cons a (List a) 어떻게 생겼을까? 테세우스의 미궁에 기반해 완벽한 게임을 작성하라. 아하! 테세우스가 갈망하던, 그리고 Ancient Geeks 주식회사에 필요한 바로 그 해답이다! 아라드네 상담소에 조금 팔리긴 했지만. 그런데 질문이 하나 남아있다. "왜 지퍼라고 부르는 거지?" "뭐, '아라드네의 진주 목걸이'라고 부를 수도 있었는데 실뭉치는 지퍼의 열린 부분, 하위 미궁은 닫힌 부분과 닮았기 때문이야. 자료구조 내를 이리저리 돌아다니는 건 지퍼를 올렸다 내렸다 하는 것과 비슷하고." "'아라드네의 진주 목걸이'라. 테세우스는 분명히 업신여기는 투였다. "네 실뭉치가 크레타에서 도움이 되었던 것처럼." "실뭉치가 네 발상인 양 말이지." 아라드네가 대꾸했다. "아. 난 실뭉치 필요 없어." 사실 테세우스는 게임을 프로그래밍하는데 실뭉치가 필요했지만 부정했다. 놀랍게도 아라드네가 수긍했다. "사실 실뭉치는 필요하지 않아. 또 다른 관점은 트리를 손가락으로 말 그대로 집어서 공중으로 들어 올리는 거야. 최상위에 초점을 맞추고 트리의 모든 다른 분기는 아래로 늘어지지. 그 결과 나온 트리에 알맞은 대수적 자료형만 할당해. 지퍼처럼." 목표를 손가락으로 집어 공중으로 들어 올리면 매달린 분기들이 여러분의 손가락이 최상위인 새로운 트리를 형성하여, 알맞은 대수적 자료형에 의해 구조화될 것이다. "아." 테세우스에겐 아라드네의 실뭉치가 필요 없었지만 아라드네가 그걸 말해줘야 했다는 건가? 너무하는군. "고마워. 아라드네. 안녕." 아라드네는 히죽거렸다. 어쨌든 전화기로 보이는 건 아니니까. 연습문제 리스트를 취해서 중간의 한 원소를 손가락으로 집어 리스트를 공중으로 들어 올려라. 결과 트리의 타입은 어떻게 되는가? 반년 후, 테세우스가 한 진열장 앞에 멈춰 선다. 단추를 여며, 외투 속으로 들어가려는 차가운 빗줄기를 막으며. 유리창에 글자들이 깜빡인다. "스파이더맨: lost in the web" -실뭉치의 미궁에서 여러분의 길을 찾으세요- 위대한 컴퓨터 게임. Ancient Geeks 주식회사 제작 테세우스는 아라드네에 게 전화를 걸어 회사의 일부를 팔았던 그날을 저주했다. 아라드네의 남편 디오니소스가 운영하는 WineOS 주식회사. 그 회사에 달갑지 않게 공개매수된 것이 아라드네의 계획이었을까? 테세우스는 빗방울들이 유리창을 미끄러지는 것을 물끄러미 쳐다보았다. 생산 라인이 변경되고 나면 아무도 Theseus and the Minotaur ™ 상품을 생산하지 않을 것이다. 테세우스는 한숨을 내쉬었다. 영웅으로서 그의 시대는 끝났다. 이제는 슈퍼 영웅의 시대다. 데이터 타입의 미분 앞 절에서는 지퍼를 소개했는데, 지퍼는 트리 류의 자료구조인 Node a를 손가락(finger)을 통해 조작하여 여러 하위 트리에 초점을 맞출 수 있게 하는 수단이다. 우리가 Node a라는 특정 자료구조에 대한 지퍼를 구축하긴 했지만, 다른 트리 구조들로 쉽게 확장할 수 있다. 연습문제 삼진 트리로 시작하자. data Tree a = Leaf a | Node (Tree a) (Tree a) (Tree a) 그리고 이에 맞는 Thread a와 Zipper a를 도출하라. 기계적 미분 그런데 어떤 정형적인 자료형에 대해서도 지퍼를 도출하는 완전히 기계적인 방법이 있다. 놀랍게도, 도출한다(derive)는 말 그대로, 지퍼는 자료형을 미분해서 얻을 수 있는데, Conor McBride6가 처음 발견하였다. 이어지는 절에서는 이 경이로운 수학적 보배를 설명할 것이다. derive는 '파생하다', '도출하다'라는 뜻도 있지만 수학에서는 주로 '미분하다'라는 뜻으로 쓰인다. 구조적 생성을 위해서는 타입을 계산해야 한다. 타입의 구조적 계산은 [Generic Programming] 장에서 별도로 설명하며 여기의 내용에 크게 의존할 것이다. 몇 가지 예제를 통해 지퍼들에 어떤 공통점이 있고 미분할 때 어떤 의미를 지니는지 보자. 이진 트리의 타입은 다음 재귀식의 고정점이다. Tree2 1 Tree2 Tree2 트리를 걸어 내려갈 때 우리는 매번 왼쪽이나 오른쪽 하위 트리를 선택하고, 선택하지 않은 하위 트리를 아라드네의 실에 연결한다. 따라서 실의 가지(branch)의 타입은 다음과 같다. Branch2 Tree2 Tree2 2 Tree2 비슷하게, 삼진 트리의 실은 Tree3 1 Tree3 Tree3 Tree3 다음 타입의 가지를 가지는데 Branch3 3 Tree3 Tree3 매 단계마다 세 하위 트리 중 하나를 선택하고 나머지 두 하위 트리를 보관해야 하기 때문이다. 도함수 d x = × 그리고 d x = × 2 와 비슷하지 않은가? 이 미스터리의 핵심은 자료 구조의 원홀(one-hole) 문맥이라는 개념이다. 트리 Tree처럼, 타입 X에 대해 매개화된 자료구조를 상상해 보라. 이제 이 자료구조에서 X 타입의 아이템 하나를 제거하여 그 빈 위치에 어떻게 표식을 남긴다면, 표식 있는 구멍을 포함하는 구조를 얻게 된다. 그 결과물을 "원홀 문맥"이라 부르고 X 타입의 아이템을 그 구멍에 다시 넣으면 완벽히 채워진 Tree를 되돌려 받는다. 이 구멍은 특수 위치, 초점 역할을 한다. 다음 그림을 보라. 트리 Tree에서 X 타입의 값을 하나 제거하면 그 위치에 구멍이 남는다 X를 원홀 문맥에 집어넣는 작업의 더 추상화된 묘사 우리가 관심 있는 것은 원홀 문맥에 넣을 타입이다. 즉 이것을 하스 켈로 어떻게 표현할 것인가? 문제는 그 초점을 효율적으로 표시하는 방법이다. 곧 보겠지만 자료구조에 대한 귀납법을 통해 원홀 문맥의 표현법을 찾으면 자동으로 효율적인 자료형을 얻게 된다.7 그러니, 작용자 와 인자 타입 를 가지는 자료구조 X 가 있을 때,의 구조로부터 원홀 문맥의 타입 F X 를 계산해 보자. F 라는 표기에서 이미 드러나듯이 합, 곱, 합성의 원홀 문맥을 구축하는 규칙은 라이프니츠의 미분 규칙과 정확히 같다. 원홀 문맥 설명 ( C n t) X = 0 = C n t X 에는 가 없기 때문에 그 원홀 문맥의 타입은 empty이다. ( I) X = 1 = d에서의 위치는 하나뿐이다.를 하나 제거하면 그 결과에는 더 이상 이 없다. 그리고를 제거할 수 있는 위치가 오직 하나이기 때문에, d의 원홀 문맥은 하나다. 따라서 그 원홀 문맥의 타입은 싱글턴 타입이다. ( + ) ∂ + G + 타입의 원소는 그 타입이 또는이기 때문에 원홀 문맥은 F 또는 G 이다. ( × ) F ∂ + F G  쌍의 원홀 문맥에서 그 구멍은 첫 번째 또는 두 번째 구성요소에 있다. ( ∘ ) ( F G ) ∂  연쇄 법칙. The hole in a composition arises by making a hole in the enclosing structure and fitting the enclosed structure in. 물론 구멍을 채우는 plug 함수의 타입은 ( F X ) X F X 이다. 지금까지 구문은 펑터의 미분, 즉 인자가 하나인 함수에 관한 표기였다. 그런데 손으로 쓰는 데 편한 표기법인 X 도 있고 이것이 계산에도 좀 더 적합하다. 아래 첨자는 우리가 그 변수에 대해 미분하겠다는 뜻이다. 일반적으로 다음과 같다. ( F ) = ∂ ( X ) 다음은 하나의 예시다. ( d I) = ∂ ( × ) = 1 X + X 1 ≅ 2 X X 는 인자 생략, 은 인자 표기 방식일 뿐 차이는 없다. 연습문제 몇 가지 법칙들을 인자 생략식으로 재작성하라. 예를 들어 곱의 법칙의 좌변은 X ( X G X ) . . 가 된다. 원홀 문맥에 익숙해지기 위해 곱 n := × ×. × 을<NAME>적으로 미분하고 그 결과가 원홀 문맥에 상응하는지 확인하라. 원홀 문맥은 타입의 값을 다시 넣을 수 없다면 쓸모가 없다. 위의 다섯 개 법칙에 대응하는 plug 함수를 작성하라. 두 변수의 연쇄 법칙을 공식화하고 그것이 원홀 문맥을 생성함을 증명하라. 바이펑터 X를 짝 ( , ) 내의 일반 펑터로 볼 것. 바이펑터의 편미분에 대한 인자 생략식 표기가 필요할 수도 있다. 미분을 통한 지퍼 위의 법칙들로 재귀 자료형 F := μ. X 에 대한 지퍼를 생성할 수 있다. 여기서 F는 다형 펑 터(polynomial functor)다. 지퍼는 특정 하위 트리 즉 F 타입의 큰 트리 안에 있는 같은 타입의 하위 구조에 대한 초점이다. 앞에서와 마찬가지로 지퍼는 우리가 초점을 맞추길 원하는 하위 트리, 그 하위 트리가 속하는 문맥인 스레드로 표현할 수 있다. i p r = μ × o t x F 이제 이 문맥은 일련의 단계이며 각 단계에서 μ 안에 있는 특정 하위 트리 F 를 선택한다. 선택하지 않은 하위 트리들은 원홀 문맥 F ( F ) 에 의해 수집된다. 이 문맥의 구멍은 우리가 입장하지 않은 하위 트리를 삭제함으로써 생긴다. 지금까지 한 것을 종합하면 o t x F = L s ( F ( F ) ) 또는 다음과 동치다. o t x F = 1 + ∂ ( F ) C n e t 구체적으로 계산이 어떻게 진행되는지를 설명하기 위해 우리의 미궁 자료형에 대한 지퍼를 체계적으로 구축해 보자. data Node a = DeadEnd a | Passage a (Node a) | Fork a (Node a) (Node a) 이 재귀 타입은 다음 펑터의 o e A = A A X A X X 고정점 o e = μ. o e A이다. 달리 말하자면 다음과 같다. o e ≅ o e A ( o e) A A N d A A N d A 미분하면 X ( o e A) A 2 A X 그리고 다음을 얻는다. N d F ( o e) A 2 A N d A 그러므로 문맥은 o t x N d F L s ( N d F ( o e) ) L s ( + × × 다음과 비교해 보면 data Branch a = KeepStraightOn a | TurnLeft a (Node a) | TurnRight a (Node a) type Thread a = [Branch a] 이 둘은 정확히 같다! 연습문제 삼진 트리에 대한 지퍼를 미분을 통해 구축하라. 리스트에 대한 지퍼를 구축하라. 앞의 연습문제를 고려한 수사적인 질문: 리스트와 스택은 무엇이 다른가? 고정점의 미분 합과 곱 말고도 자료형에 대해 할 이야기는 더 있다. 고정점 연산자는 딱히 미적분에서 대응하는 것이 없다. 그래서 위의 표에는 고정점 F X = μ. X Y 의 미분 법칙이 빠져있다. X ( F X ) ? 이 공식은 두 변수의 연쇄 법칙을 수반하기 때문에 연습문제로 남기겠다. 대신 구체적인 타입인 o e에 대해 계산해 보자. A ( o e A ) ∂ ( + × o e + × o e × o e) 1 N d A N d A N d A + A ( o e) ( + × × o e) 물론 A ( o e) 를 더 이상 전개하는 것은 쓸모가 없지만 이것을 고정점으로 보고 다음을 도출할 수 있다. A ( o e) = μ. A + S A X 요약하면 A 1 N d A N d A N d A 그리고 A A 2 A N d A 이다. 이 재귀 타입은 리스트인데 원소 타입이 A 이고 빈 리스트만 A 타입의 기본 가정으로 바꾼 것과 같다. 하지만 그 리스트가 유한하다면 기본 가정을 1로 두고 A 를 리스트에서 빼낼 수 있다. A ( o e) T A ( X 1 S A X ) = T A L s ( A ) 마지막 문단에서 도출한 지퍼와 비교해 보면 리스트 타입은 우리의 문맥이고 i t ( A ) C n e t o e 다음에 의해 × A N d A 결국 다음을 얻게 된다. i p r o e ≅ A ( o e) A 그러므로 o e를에 대해 미분하면의 지퍼를 얻게 된다! 연습문제 2변수 연쇄 법칙을 이용하여 고정점의 미분 규칙을 공식화하라. inductive( ) 고정점과 coinductive( ) 고정점이 있다는 것을 아는가? coinductive 고정점에 대한 법칙은 어떻게 되는가? 함수를 함수에 대해 미분하기 원홀 문맥의 타입을 찾을 때는 f ( ) x 를 계산한다. f ( ) g ( ) 같은 표현 식도 가능하다. 예를 들어 x d 2 2 2 로서, 4-짝의 two-hole 문맥이다. 그 미분은 = 2 라 할 때 x d 2 = d 2 u = 2 = 2 2 와 같이 한다. 지퍼 vs 문맥 그런데 일반적으로 지퍼와 one-hole 문맥은 다른 것을 가리킨다. 지퍼는 임의의 하위 트리에 대한 초점인 반면 one-hole 문맥은 타입 생성자의 인자에 대한 것이다. 예를 들어 다음 자료형에서 data Tree a = Leaf a | Bin (Tree a) (Tree a) 고정점은 다음과 같다. r e A = μ. + × 지퍼는 최상위가 Bin이나 Leaf인 하위 트리에 초점을 맞출 수 있지만 r e의 one-hole 문맥은 Leaf들에만 초점을 맞출 수 있는데 Leaf들에서만 타입이 있기 때문이다. o e의 도함수는 지퍼인데 모든 하위 트리의 최상위는 에 의해 장식되기 때문이다. 연습문제 놀랍게도 A ( r e A ) A T e A 의 지퍼는 같은 타입이다. 그 계산은 어렵지 않지만 왜 그렇게 되는지 이유를 아는가? F 의 지퍼 구축은 보조 변수를 도입해 X Y F X Y 에 대해 미분하고 =로 치환하면 된다. 이것이 왜 알맞은가? 그 지퍼가 one-hole 문맥과 다른 타입 A 를 찾아라. 결론 미적분의 법칙들이 어떻게 이산적인 세계에 나타나는지 질문하며 이 절을 마치겠다. 지금은 아무도 모른다. 최소한 선형(linear)의 이산적 표기는 "오직 하나"임은 알려져 있다. 타입의 항목을 one-hole 문맥의 구멍에 넣는 함수의 중요한 특징은 그 항목이 오직 한 번 사용된다는 것, 즉 선형이라는 것이다. 이 삽입 매핑의 타입을 다음과 같이 볼 수 있다. X X ( ⊸ F X ) 여기서 ⊸는 선형 함수로서, 선형 논리에서 그렇듯이 그 인자를 복제하거나 무시하지 않는다. 어떤 의미에서 one-hole 문맥은 함수 공간 ⊸ X 의 표현, 즉 → X 의 선형 근사로 볼 수 있다. 노트 이언 스튜어트. The true story of how Tehseus found his way out of the labyrinth. Scientific American, 1991년 2월, 137쪽. ↩ Gérard Huet. The Zipper. Journal of Functional Programming, 7 (5), Sept 1997, pp. 549--554. PDF ↩ Gérard Huet이 말하는 지퍼는 전체 하위 트리를 교체하는 것이, 연관된 추가 데이터가 없어도 허용됨에 주목하라. 우리의 미궁의 경우에는 무관한 일이다. 데이터 타입의 미분 절에서 다시 다루겠다. ↩ 물론 최상위에서 상수 단계만큼 밑의 임의 노드도 상수 시간 안에 접근 가능하다. ↩ 노드의 데이터를 갱신하는 것과 달리, 전체 자료구조를 변경하는 것은 최상위 노드 외의 노드들이 영향을 받더라도 amortized 상수 시간 안에 가능함에 주목하라. 한 예로 이진수 표현에서 증가 연산을 보자. 가령 111... 11을 증가시키려면 모든 자릿수를 건드려서 1000.. 00을 만들어야 한다. 그 증가함수는 그럼에도 amortized 상수 시간 안에 실행된다. (최악의 경우에는 상수 시간이 아니다) ↩ Conor Mc Bride. The Derivative of a Regular Type is its Type of One-Hole Contexts. 온라인 이용 가능. PDF ↩ 이 현상은 이미 generic tries에서 나타난다. ↩ 09 렌즈 원문: https://en.wikibooks.org/wiki/Haskell/Lenses_and_functional_references 렌즈 맛보기 렌즈를 향한 여정 순회 세터(setter) 접기 Getter 마지막 렌즈 합성(composition) 연산자 만능칼 State 조작 Iso Prism 법칙 다형성 갱신 아무런 조건 없이 더 읽을거리 이 장은 함수형 참조에 대한 것이다. "참조"라 함은, 함수형 참조가 값의 일부를 가리키며, 그 일부에 접근하고 수정할 수 있음을 뜻한다. "함수형"이라 함은 함수형 참조가 동작하는 방식이 함수에서 기대되는 유연함과 합성 가능성(composability)을 제공함을 뜻한다. 우리가 배울 것은 lens 라이브러리가 구현하는 함수형 참조다. lens는 함수형 참조 중에서도 특히 유명한 렌즈에서 따온 이름이다. 개념 자체도 매우 흥미롭지만, 렌즈와 다른 함수형 참조들은 편리하고 놀랍도록 흔한 관용구들을 가능케 하며 많은 유용한 라이브러리에서 쓰이고 있다. 렌즈 맛보기 가벼운 몸풀기로 렌즈의 가장 간단한 사용법을 보여주겠다. 렌즈는 평범한 하스 켈 레코드 구문을 훌륭하게 대체한다. 이 절에는 설명이 별로 없는데, 빠진 것은 뒤에서 보충하겠다. 2D 드로잉 라이브러리에서 흔히 나올 법한 다음의 타입들을 살펴보자. -- 평면 상의 점. data Point = Point { positionX :: Double , positionY :: Double } deriving (Show) -- 한 점에서 다른 점으로 가는 선분. data Segment = Segment { segmentStart :: Point , segmentEnd :: Point } deriving (Show) -- 점과 선분을 만들기 위한 보조 함수들. makePoint :: (Double, Double) -> Point makePoint (x, y) = Point x y makeSegment :: (Double, Double) -> (Double, Double) -> Segment makeSegment start end = Segment (makePoint start) (makePoint end) 레코드 구문은 필드에 접근하는 함수를 제공한다. 위 함수들을 이용하면 선분을 정의하는 점의 좌표를 쉽게 얻을 수 있다. GHCi> let testSeg = makeSegment (0, 1) (2, 4) GHCi> positionY . segmentEnd $ testSeg GHCi> 4.0 하지만 갱신은 조금 그렇다. GHCi> testSeg { segmentEnd = makePoint (2, 3) } Segment {segmentStart = Point {positionX = 0.0, positionY = 1.0} , segmentEnd = Point {positionX = 2.0, positionY = 3.0}} 그리고 중첩된 필드에 도달하기가 썩 깔끔하지 않다. 종점의 y 좌표의 값을 두 배로 하려면 이렇게 해야 한다. GHCi> :set +m -- Enabling multi-line input in GHCi. GHCi> let end = segmentEnd testSeg GHCi| in testSeg { segmentEnd = end { positionY = 2 * positionY end } } Segment {segmentStart = Point {positionX = 0.0, positionY = 1.0} , segmentEnd = Point {positionX = 2.0, positionY = 8.0}} 렌즈를 쓰면 이런 번잡함을 피할 수 있다. 다시 해보자. -- 이번 장의 몇 예제는 GHC 확장 기능이 필요하다. -- TemplateHaskell은 makeLenses를 위해 필요하다. RankNTypes은 -- 나중에 나올 타입 시그너처들에 필요하다. {-# LANGUAGE TemplateHaskell, RankNTypes #-} import Control.Lens data Point = Point { _positionX :: Double , _positionY :: Double } deriving (Show) makeLenses ''Point data Segment = Segment { _segmentStart :: Point , _segmentEnd :: Point } deriving (Show) makeLenses ''Segment makePoint :: (Double, Double) -> Point makePoint (x, y) = Point x y makeSegment :: (Double, Double) -> (Double, Double) -> Segment makeSegment start end = Segment (makePoint start) (makePoint end) 여기서 바뀐 것은 makeLenses을 쓴 것뿐이다. 이러면 Point와 Segment의 필드들에 대한 렌즈가 자동으로 생성된다. (밑줄은 makeLenses의 작명 관례 때문에 필요하다) 뒤에서 보겠지만 렌즈 정의를 손수 작성하는 것은 전혀 어렵지 않다. 하지만 렌즈를 만들 필드가 많다면 지루한 작업이 될 것이기 때문에 자동으로 생성할 수 있다면 편리할 것이다. makeLenses 덕에 필드마다 렌즈가 생겼다. 렌즈의 이름은 필드의 이름에서 밑줄을 뺀 것이다. GHCi> :info positionY positionY :: Lens' Point Double -- Defined at WikibookLenses.hs:9:1 GHCi> :info segmentEnd segmentEnd :: Lens' Segment Point -- Defined at WikibookLenses.hs:15:1 positionY :: Lens' Point Double이라는 타입은 positionY가 Point 내의 Double에 대한 참조임을 뜻한다. 이런 참조 방식을 다루려면 lens 라이브러리가 제공하는 합성자를 사용해야 한다. view가 그중 하나인데, 레코드 접근자처럼 렌즈가 가리키는 값을 얻어온다. GHCi> let testSeg = makeSegment (0, 1) (2, 4) GHCi> view segmentEnd testSeg Point {_positionX = 2.0, _positionY = 4.0} set은 가리키는 값을 덮어쓴다. GHCi> set segmentEnd (makePoint (2, 3)) testSeg Segment {_segmentStart = Point {_positionX = 0.0, _positionY = 1.0} , _segmentEnd = Point {_positionX = 2.0, _positionY = 3.0}} 렌즈의 굉장한 점 중 하나는 합성하기 쉽다는 것이다. GHCi> view (segmentEnd . positionY) testSeg GHCi> 4.0 segmentEnd . positionY 같은 합성 렌즈를 작성할 때 순서는 큰 것에서 작은 것 순이다. 이 경우 선분의 한 점에 대한 렌즈가 그 점의 좌표에 대한 렌즈보다 앞에 온다. 레코드 접근자가 어떻게 작동하는지 생각해 보면 조금 놀라울 수도 있겠지만(앞에서 나온 렌즈 없는 예제와 비교해 보라) 여기서 사용한 (.)는 우리가 익히 알고 있는 그 함수 합성 연산자다. 렌즈의 합성을 통해 중첩된 레코드 갱신의 수렁을 빠져나올 수 있다. 다음은 좌표를 두 배로 키우는 예제를 수정한 것으로, 렌즈가 가리키는 값에 over를 통해 함수를 적용한다. GHCi> over (segmentEnd . positionY) (2 *) testSeg Segment {_segmentStart = Point {_positionX = 0.0, _positionY = 1.0} , _segmentEnd = Point {_positionX = 2.0, _positionY = 8.0}} 이런 예제들이 처음에는 마술처럼 보일지도 모르겠다. 렌즈 하나로 어떻게 값을 얻고, 설정하고, 수정할 수 있을까? 어떻게 렌즈를 (.)로 합성하는 게 가능할까? makeLenses 없이 렌즈를 작성하는 게 정말 쉬울까? 렌즈가 어떻게 만들어졌는지 알아보고 이 질문들에 대답해 보자. 렌즈를 향한 여정 렌즈를 이해하는 방법은 많다. 우리는 개념적 맹신을 피하는 구불구불하고 조심스러운 길을 걸을 것이다. 이 길에서 몇 가지 다른 함수형 참조들을 소개할 것이다. lens의 용법에 따라 이제부터 "optics"라는 단어로 다양한 함수형 참조를 통칭하겠다. 뒤에서 보겠지만 lens의 optics는 서로 엮여 계층도를 형성한다. 이제부터 이 계층도를 탐험할 것이다. 순회 시작은 렌즈가 아니다. 대신 상당히 연관이 많은 순회부터 시작한다. Traversable 장에서 traverse가 어떻게 구조를 걸어 지나가며 전체적인 결과를 산출하는가를 논의했었다. traverse :: (Applicative f, Traversable t) => (a -> f b) -> t a -> f (t b) traverse를 쓸 때는 결과를 내기 위해 어떤 Applicative든 이용할 수 있다. 특히 Identity를 적용성 펑터로 선택하면 traverse로부터 fmap이 얻어지는 것을 본 적이 있다. Monoid m => Applicative (Const m)을 쓰면 foldMap과 Const m에 대해서도 같은 일이 일어난다. fmap f = runIdentity . traverse (Identity . f) foldMap f = getConst . traverse (Const . f) lens는 이 아이디어를 드넓게 활용한다. traverse 같은 것을 이용해 Traversable 구조 내부의 값을 조작하는 것은 전체의 일부를 대상으로 삼는 한 예시다. 하지만 traverse는 유연하긴 하지만 제한된 목표만을 처리할 수 있다. 그 예로, Traversable 펑터가 아닌 구조를 걸어 지나가고 싶다고 하자. 그렇다면 Point 타입에 대한 다음 함수는 지극히 타당하다. pointCoordinates :: Applicative f => (Double -> f Double) -> Point -> f Point pointCoordinates g (Point x y) = Point <$> g x <*> g y pointCoordinates는 Point에 대한 순회다. traverse의 일반적인 구현과 비슷하게 보이고 거의 같은 방식으로 사용할 수 있다. 다음은 Traversable 장의 rejectWithNegatives 예제를 고친 것이다. GHCi> let deleteIfNegative x = if x < 0 then Nothing else Just x GHCi> pointCoordinates deleteIfNegative (makePoint (1, 2)) Just (Point {_positionX = 1.0, _positionY = 2.0}) GHCi> pointCoordinates deleteIfNegative (makePoint (-1, 2)) Nothing pointCoordinates가 전형적으로 보여주는 이러한 일반화된 순회 표기는 lens의 핵심 타입들 중 하나인 Traversal에서 찾을 수 있다. type Traversal s t a b = forall f. Applicative f => (a -> f b) -> s -> f t 노트 type 선언 우변의 forall f.는 f 자리에 어떤 Appplicative든 사용할 수 있음을 뜻한다. 이러면 좌변에 f를 언급하거나 Traversal을 사용할 때 특정 f를 택할 필요가 없다. Traversal을 이용하면 pointCoordinates의 타입을 이렇게 표현할 수 있다. Traversal Point Point Double Double Traversal s t a b에서 각 타입 변수가 어떻게 되는지 자세히 살펴보자. s는 Point가 된다. pointCoordinates는 Point에 대한 순회다. t는 Point가 된다. pointCoordinates는 Point를 산출한다. (어떤 Applicative 문맥 안에서) a는 Double이 된다. pointCoordinates는 Point 내의 Double 값을 목표로 한다. (점의 X, Y 좌표) b는 Double이 된다. 목표 Double 값은 Double 값이 된다. (원래 값과 다를 수 있는) pointCoordinates의 경우 s는 t와 같고 a는 b와 같다. pointCoordinates는 순회한 구조나 그 안의 대상의 타입을 변경하지 않는다. 하지만 반드시 그럴 필요는 없다. 그 예가 traverse로, 다음과 같이 타입을 표현할 수 있다. Traversable t => Traversal (t a) (t b) a b traverse는 Traversable 구조 내의 목푯값의 타입을 변경할 수 있고, 더 나아가, 그 구조의 타입 자체를 변경할 수 있다. Control.Lens.Traversal 모듈은 Data.Traversable 함수들의 일반화 그리고 다양한 순회 관련 도구들을 포함한다. 연습문제 Segment를 정의하는 점들의 모든 좌표를 데이터 선언에 표현된 순서대로 순회하는 extremityCoordinates를 작성하라. (힌트: pointCoordinates 순회를 이용하라) 세터(setter) 다음 계획은 Traversable, Functor, Foldable 사이의 연결을 일반화하는 것이다. Functor부터 시작하자. traverse로부터 fmap을 복구하기 위해 Identity를 적용성 펑터로 선택했었다. 그럼으로써 부수 효과 없이 목푯값을 수정할 수 있었다. 비슷한 결과를 얻으려면 Traversal의 정의를 선택하고... forall f. Applicative f => (a -> f b) -> s -> f t ... f를 Identity로 한정한다. (a -> Identity b) -> s -> Identity t lens의 용법에서는 이것이 Setter를 얻는 방법이다. 기술적인 이유로 Control.Lens.Setter의 Setter 정의는 이것과 조금 다르다. type Setter s t a b = forall f. Settable f => (a -> f b) -> s -> f t 하지만 문서를 들여다보면 Settable 펑터가 Identity 또는 이와 상당히 비슷한 것을 볼 수 있다. 그러니 별로 신경 쓸 차이는 아니다. Traversal에서 f를 어떤 것으로 제한하면 타입은 사실 더 일반화된다. Traversal이 모든 Applicative 펑터와 작동하기 때문에 Identity와 작동하는 것도 가능하다. 따라서 모든 Traversal은 Setter이며 Setter로서 쓰일 수 있다. 하지만 그 역은 아니다. 모든 세터가 순회는 아니다. over는 세터를 위한 기본적인 합성 자다. fmap처럼 작동하는데, 구조의 어떤 부분이 대상인지 명시하기 위해 세터를 첫 번째 인자로 넘긴다는 점이 다르다. GHCi> over pointCoordinates negate (makePoint (1, 2)) Point {_positionX = -1.0, _positionY = -2.0} 사실은 mapped라는 Setter로 fmap을 복구할 수 있다. GHCi> over mapped negate [1.. 4] [-1, -2, -3, -4] GHCi> over mapped negate (Just 3) Just (-3) set은 또 다른 중요한 합성자로서, 모든 목푯값을 상수로 대체한다. set setter x = over setter (const x),는 (x <$) = fmap (const x) 와 비슷하게 작동한다. GHCi> set pointCoordinates 7 (makePoint (1, 2)) Point {_positionX = 7.0, _positionY = 7.0} 연습문제 over를 이용해 다음을 구현하라. scaleSegment :: Double -> Segment -> Segment scaleSegment n이 선분의 모든 좌표에 n을 곱하도록 한다. (힌트: 이전 연습문제의 답을 활용할 것) mapped를 구현하라. 이 연습문제에서는 Settable 펑터를 Identity로 한정해도 된다. (힌트: Data.Functor.Identity가 필요할 것이다) 접기 순회로서의 fmap 기법을 일반화했으니 순회로서의 foldMap을 일반화할 차례다. 이것을 forall f. Applicative f => (a -> f b) -> s -> f t Const를 이용하여 다음과 같이 바꾼다. forall r. Monoid r => (a -> Const r a) -> s -> Const r s Const의 두 번째 인자는 무관하기 때문에 b를 a로, t를 s로 바꾼다. Setter와 Identity에서 봤듯이 Conrol.Lens.Fold는 Monoid r => Const r보다 조금 일반화된 것을 사용한다. type Fold s a = forall f. (Contravariant f, Applicative f) => (a -> f a) -> s -> f s 노트 Contravariant는 contravariant functor를 위한 타입 클래스다. Contravariant의 핵심 메서드는 contramap이다. contramap :: Contravariant f => (a -> b) -> f b -> f a 생긴 것은 fmap과 비슷하지만, 뭐라 해야 할까, 이것은 함수 애로를 사상 주변에서 회전시킨다. (turns the function arrow around on mapping.) 함수 인자에 대해 매개화된 타입은 Contravariant의 전형적인 예다. 예를 들어 Data.Functor.Contravariant는 Predicate 타입을 정의하는데, a 타입의 값에 대한 불리언 테스트를 위한 것이다. newtype Predicate a = Predicate { getPredicate :: a -> Bool } GHCi> :m +Data.Functor.Contravariant GHCi> let largerThanFour = Predicate (> 4) GHCi> getPredicate largerThanFour 6 True Predicate은 Contravariant이므로 contrmap으로 Predicate을 수정하여, 테스트 전에 값을 조정할 수가 있다. GHCi> getPredicate (contramap length largerThanFour) "orange" True Contravariant의 법칙들은 Functor의 법칙들과 비슷하다. contramap id = id contramap (g . f) = contramap f. contramap g Monoid r => Const r은 Contravariant이면서 Applicative이다. 펑 터 법칙과 반변 법칙 덕에 Contravariant이면서 Functor인 것은 마치 Const r처럼 공펑터(vacuous functor)가 되어, fmap과 contramap이 아무것도 하지 않는다. 추가적인 Applicative 제약은 Monoid r과 대응한다. 이로부터 대상으로부터 만들어진 Const 류 문맥과 결합하여 접기를 수행하는 것이 가능해진다. 모든 Traversal은 Fold로서 사용될 수 있는데, Traversal은 어떤 Applicative와도 작동해야 하기 때문이다. 여기에는 Contravariant인 것도 포함한다. Traversal과 Setter에서 본 상황과 정확히 일치한다. Control.Lens.Fold는 Data.Foldable에 있는 모든 것에 대해 유사품을 제공한다. 이 모듈에서 자주 쓰이는 두 합성자가 있는데 Fold 대상들의 리스트를 생성하는 toListOf와, GHCi> -- Using the solution to the exercise in the traversals subsection. GHCi> toListOf extremityCoordinates (makeSegment (0, 1) (2, 3)) [0.0,1.0,2.0,3.0] Data.Monoid의 First 모 노이드를 이용하여 Fold의 첫 대상을 추출하는 preview이다. GHCi> preview traverse [1.. 10] Just 1 Getter 지금까지는 순회에 이용할 수 있는 펑터들을 제한하여 Traversal으로부터 더 일반화된 optics(Setter와 Fold)로 옮겨갔는데, 그 반대 방향도 가능하다. 즉 펑터가 다뤄야 하는 범위를 넓혀서 더 구체적인 optics를 얻을 수 있다. 예를 들어 Fold의 경우... type Fold s a = forall f. (Contravariant f, Applicative f) => (a -> f a) -> s -> f s Applicative 제한을 Functor로 완화하면 Getter를 얻는다. type Getter s a = forall f. (Contravariant f, Functor f) => (a -> f a) -> s -> f s f는 여전히 Contravariant이 자 Functor이어야 하기 때문에, Const 같은 공펑터(vacuous functor)로 남는다. 하지만 Applicative 제약 없이는 복수 대상으로부터의 결과를 합성할 수 없다. 결국 Getter는 항상 한 대상을 가진다. 대상을 얼마든지, 0개도 가질 수 있는 Fold(또는 Setter나 Traversal)과 대비되는 점이다. f를 Const r로 한정하면 Getter의 본질을 드러낼 수 있다. someGetter :: (a -> Const r a) -> s -> Const r s Const r whatever 값과 r 값은 서로 무손실 변환이므로 위의 타입은 다음과 동치다. someGetter'' :: s -> a someGetter'' x = someGetter' id x someGetter' k x = k (someGetter'' x) 따라서 Getter s a가 함수 s -> a와 동치라고 결론을 내릴 수 있다. 이 관점에서는 대상을 오직 하나만 취해 정확히 하나의 결과를 내놓는 것이 자연스럽다. Control.Lens.Getter의 두 기본적인 합성자가 임의 함수의 Getter를 만드는 to와 Getter를 임의 함수로 되돌리는 view라는 건 놀랍지 않은 일이다. GHCi> -- The same as fst (4, 1) GHCi> view (to fst) (4, 1) 노트 Getter가 Fold보다 덜 일반적이라고 했지만, view는 사실 Getter뿐 아니라 Fold, Traversal에도 작동한다. GHCi> :m +Data.Monoid GHCi> view traverse (fmap Sum [1.. 10]) Sum {getSum = 55} GHCi> -- both traverses the components of a pair. GHCi> view both ([1,2],[3,4,5]) [1,2,3,4,5] 이것이 가능한 이유는 lens의 타입 명세에 있는 묘한 구석 때문이다. view의 첫 인자는 정확히는 Getter가 아니라 Getting이다. type Getting r s a = (a -> Const r a) -> s -> Const r s view :: MonadReader s m => Getting a s a -> m a Getting은 펑 터 인자를 Const r로 한정하며, 이는 Getter를 위한 명백한 선택이다. 하지만 이에 대해 Applicative 인스턴스가 있는지는(즉, r이 Monoid 인지는) 물음표로 남겨둔다. view를 예로 들면 a가 Monoid인 한, Getting a s a는 Fold로 쓸 수 있고, Fold는 접기 대상이 모 노이드 면 view에 쓸 수 있다. Control.Lens.Getter와 Control.Lens.Fold의 많은 합성 자는 Getter나 Fold가 아니라 Getting을 이용하여 정의된다. Getting을 쓰는 것의 이점은 그 결과 나오는 타입 명세를 보면 수행되는 fold에 대해 더 많은 정보를 알 수 있다는 것이다. 예를 들어 Control.Lens.Fold의 hasn't를 살펴보면, hasn't :: Getting All s a -> s -> Bool 이것은 비어있음에 대한 일반화된 검사다. GHCi> hasn't traverse [1.. 4] False GHCi> hasn't traverse Nothing True Fold s a -> s -> Bool도 hasn't의 명세로서 문제가 없다. 하지만 실제 명세의 Getting All은 많은 것을 말해주는데, 특히 hasn't가 하는 일을 뚜렷이 보여준다. hasn't는 s 안의 모든 a 대상을 All 모노이드로(더 정확히는, All False로) 변환한다. 그리고 그것들을 접어서 나온 결과 All로부터 Bool을 추출한다. 마지막 렌즈 Traversal로 되돌아가 보자. type Traversal s t a b = forall f. Applicative f => (a -> f b) -> s -> f t Fold에서 Getter로 옮겨갈 때 했듯이 Applicative 제약을 Functor로 완화하면 type Lens s t a b = forall f. Functor f => (a -> f b) -> s -> f t 최종적으로 Lens 타입을 얻는다. Traversal에서 Lens로 옮겨갈 때 무엇이 바뀌는가? 앞서 봤듯이 Applicative 제약을 완화하면 복수 대상을 순회할 수가 없다. Traversal과 달리 Lens는 항상 단일 대상에 초점을 맞춘다. 그런데 이런 제약에 좋은 점도 있는 법이다. Lens에서는 정확히 한 대상을 찾을 것을 보장한다. 반면 Traversal에서는 대상이 여러 개이거나 아예 없을 수도 있다. Applicative 제약의 부재와 대상의 유일함은 렌즈들의 또 다른 핵심을 드러낸다. 렌즈는 getter로 쓸 수 있다. Contravariant 더하기 Functor는 단순 Functor보다 구체적인 제약이고, 따라서 Getter는 Lens보다 일반적이다. 또한 모든 Lens는 Traversal이며 따라서 Setter이다. 결론은 렌즈가 getter로도, setter로도 쓰일 수 있다는 것이다. 이것이 렌즈로 레코드 레이블을 대체할 수 있는 이유다. 노트 마무리하기 전에, 모든 Lens는 Getter로 쓸 수 있다는 주장은 조금 성급해 보인다. 두 타입을 나란히 놓으면 type Lens s t a b = forall f. Functor f => (a -> f b) -> s -> f t type Getter s a = forall f. (Contravariant f, Functor f) => (a -> f a) -> s -> f s Lens s t a b에서 Getter s a로 옮길 때 s는 t와, a는 b와 같아진다. 모든 렌즈에서 이것이 가능하다고 어떻게 확신할 수 있는가? Traversal과 Fold의 관계에서도 비슷한 문제가 있다. 지금은 그 대답을 미뤄두고, optic 법칙에 대한 절에서 돌아올 것이다. 다음은 튜플의 첫 성분을 가리키는 _1을 사용하여 렌즈의 유연함을 설명하는 짧은 예제다. GHCi> _1 (\x -> [0.. x]) (4, 1) -- Traversal [(0,1),(1,1),(2,1),(3,1),(4,1)] GHCi> set _1 7 (4, 1) -- Setter (7,1) GHCi> over _1 length ("orange", 1) -- Setter, changing the types (6,1) GHCi> toListOf _1 (4, 1) -- Fold [4] GHCi> view _1 (4, 1) -- Getter 연습문제 Point와 Segment의 필드들에 대한 렌즈, 즉 makeLenses로 생성했던 것들을 구현하라. (힌트: 타입을 따라갈 것. 타입 명세를 쓰고 나면 fmap과 레코드 레이블 말고 쓸 것이 별로 없다.) getter 함수 s -> a와 setter 함수 s -> b -> t를 취해 Lens s t a b를 생성하는 lens 함수를 구현하라. (힌트: 여러분의 구현이 이전 연습문제 해답에서 반복되는 부분을 최소화할 수 있을 것이다) 합성(composition) 지금까지 본 optic들은 다음과 같은 모양이었다. (a -> f b) -> (s -> f t) 여기서 f는 일종의 Functor이다. s는 optic이 작동하는 전체 구조의 타입이다. t는 optic을 통해 되는 무언가의 전체 타입이다. a는 부분들 즉 optic이 가리키는 s 내의 대상들의 타입이다. b는 그 부분들이 optic을 통해 되는 무언가의 타입이다. 이 optic들의 핵심적인 공통점은 모두 함수라는 것이다. 구체적으로는, 부분 (a -> f b)에 작용하는 함수를 전체인 (s -> f t)에 작용하는 함수로 변환하는 매핑 함수다. 함수이기 때문에 일반적인 방법으로 합성이 가능하다. 맨 처음의 렌즈 합성 예제를 다시 보자. GHCi> let testSeg = makeSegment (0, 1) (2, 4) GHCi> view (segmentEnd . positionY) testSeg GHCi> 4.0 optic은 넘겨받은 함수를 수정하여 인자로 만듦으로써 더 큰 구조에 작용하도록 한다. (.)이 함수를 오른쪽에서 왼쪽으로 합성하기에 코드를 왼쪽에서 오른쪽으로 읽을 때 (.)로 합성된 optic의 구성요소들은 점차 원래 구조의 작은 부분들을 가리키게 된다. lens 타입 유사형에 사용되는 관습은 이러한 큰 것에서 작은 것 순서와 일치하여, s와 t가 a와 b보다 먼저 온다. 아래의 표는 segmentEnd . positionY를 예시로, optic이 하는 일을 어떻게 매핑(작은 것에서 큰 것) 또는 포커싱(큰 것에서 작은 것)으로 보는지 설명한다. 렌즈 segmentEnd positionY segmentEnd . positionY 풀어쓴 타입 Functor f => (Point -> f Point) -> (Segment -> f Segment) Functor f => (Double -> f Double) -> (Point -> f Point) Functor f => (Double -> f Double) -> (Segment -> f Segment) "매핑" 해석 Point의 함수에서 Segment의 함수로 Double의 함수에서 Point의 함수로 Double의 함수에서 Segment의 함수로 Lens로 표현한 타입 Lens Segment Segment Point Point Lens Point Point Double Double Lens Segment Segment Double Double Lens'로 표현한 타입 Lens' Segment Point Lens' Point Double Lens' Segment Double "포커싱" 해석 Segment 내의 Point를 가리킨다 Point 내의 Double을 가리킨다 Segment 내의 Double을 가리킨다 노트 Lens' 유사형은 그저 타입을 바꾸지 않는 렌즈의 줄임말이다. (즉 s가 t와, a가 b와 같은 렌즈다) type Lens' s a = Lens s s a a 비슷하게 Traversal'과 Setter'도 있다. Lens와 Traversal 같은 synonym들 뒤에 있는 타입들 간의 유일한 차이는 f의 자리에 어떤 펑터가 올 수 있는가 뿐이다. 그 결과 서로 종이 다른 여러 optic들을, 모두가 들어맞는 타입만 있다면 자유로이 섞을 수 있다. 다음은 몇 가지 예시다. GHCi> -- A Traversal on a Lens is a Traversal. GHCi> (_2. traverse) (\x -> [-x, x]) ("foo", [1,2]) [("foo",[-1, -2]),("foo",[-1,2]),("foo",[1, -2]),("foo",[1,2])] GHCi> -- A Getter on a Lens is a Getter. GHCi> view (positionX . to negate) (makePoint (2,4)) -2.0 GHCi> -- A Getter on a Traversal is a Fold. GHCi> toListOf (both . to negate) (2, -3) [-2,3] GHCi> -- A Getter on a Setter does not exist (there is no unifying optic). GHCi> set (mapped . to length) 3 ["orange", "apple"] <interactive>:49:15: No instance for (Contravariant Identity) arising from a use of ‘to’ In the second argument of ‘(.)’, namely ‘to length’ In the first argument of ‘set’, namely ‘(mapped . to length)’ In the expression: set (mapped . to length) 3 ["orange", "apple"] 연산자 몇 가지 렌즈 합성자에는 중위 연산자 동의어 또는 최소한 거의 동등한 연산자가 있다. 다음은 우리가 살펴본 몇 합성자와 그에 대응하는 연산자들이다. 전위 중위 view _1 (1,2) (1,2) ^. _1 set _1 7 (1,2) (_1 .~ 7) (1,2) over _1 (2 *) (1,2) (_1 %~ (2 *)) (1,2) toListOf traverse [1.. 4] [1.. 4] ^.. traverse preview traverse [] [] ^? traverse 값을 추출하는 렌즈 연산자들(가령 (^.), (^..), (^?))은 대응하는 전위 연산자에 대해 인자가 뒤집혀있어서, 결과를 추출할 구조체를 첫 번째 인자로 받는다. 이러면 코드 가독성이 좋아지는데, optic이 가리키는 구조 전체를 optic이 가리키는 부분보다 먼저 작성하게 되고, 이는 합성 optic이 큰 것에서 작은 것 순으로 작성되는 것을 반영하기 때문이다. (&) 연산자는 단순히 flip ($)로 정의되며, 이것 덕에 수정 연산자(가령 (.~)나 (%~))를 쓸 때도 구조를 먼저 작성할 수 있다. (&)는 수정할 필드가 많을 때 특히 편하다. sextupleTest = (0,1,0,1,0,1) & _1 .~ 7 & _2 %~ (5 *) & _3 .~ (-1) & _4 .~ "orange" & _5 %~ (2 +) & _6 %~ (3 *) GHCi> sextupleTest (7,5, -1, "orange",2,3) 만능칼 이만큼 했으면 렌즈가 불가사의한 마술이 아니라는 것을 보여주기에 충분한 것 같다. 하지만 이것은 빙산의 일각이다. lens는 풍부한 도구를 제공하고 다채로운 개념을 구현하는 거대한 라이브러리다. 곤란한 점은 여러분이 코어 라이브러리에 있는 무엇을 생각하든 lens 어딘가에 그것에 작용하는 합성자가 있다는 것이다. lens의 모든 구석을 설명하는 책을 쓰려면 지금 읽는 이 책만큼 길어야 할 것이다. 안타깝지만 여기서 그런 공을 들일 수는 없다. 우리가 할 수 있는 건 여러분이 실전에서 언젠가 만날 lens의 범용 도구 몇 가지를 짧게 소개하는 것뿐이다. State 조작 lens 모듈에는 상태 펑터를 위한 합성자들이 있다. 예를 들어: Control.Lens.Getter의 use는 Control.Monad.State의 gets와 비슷한데, 평범한 함수 대신 getter를 취한다. Control.Lens.Setter includes suggestive-looking operators that modify parts of a state targeted a setter (e.g. .= is analogous to set, %= to over and (+= x) to over (+x)). Control.Lens.Zoom는 zoom이라는 아주 편리한 합성자를 제공한다. zoom은 순회(또는 렌즈)를 사용하여 상태의 일부로 확대해 들어간다. 그러기 위해 zoom 은 상태 있는 계산을 더 큰 상태와 작동하는 계산으로 전이하는데, 여기서 원래 상태는 그 큰 상태의 일부가 된다. 이런 합성자들을 쓰면 그 의도를 잘 드러내는 코드를 작성할 수 있다. 그런 코드는 상태의 깊은 부분을 투명하게 조작한다. import Control.Monad.State stateExample :: State Segment () stateExample = do segmentStart .= makePoint (0,0) zoom segmentEnd $ do positionX += 1 positionY *= 2 pointCoordinates %= negate GHCi> execState stateExample (makeSegment (1,2) (5,3)) Segment {_segmentStart = Point {_positionX = 0.0, _positionY = 0.0} , _segmentEnd = Point {_positionX = -6.0, _positionY = -6.0}} Iso 일련의 Point와 Segment 예제에서 makePoint 함수를 (Double, Double) 짝으로부터 Point를 만들어내는 편리한 방법으로써 사용했었다. makePoint :: (Double, Double) -> Point makePoint (x, y) = Point x y 그 결과 나오는 Point의 X, Y 좌표는 원래 짝의 두 구성요소에 정확히 대응한다. 그렇다면 unmakePoint 함수를 정의해서... unmakePoint :: Point -> (Double, Double) unmakePoint (Point x y) = (x, y) makePoint와 unmakePoint가 서로 역이 되도록 할 수 있다. 즉 이것들은 서로를 상쇄한다. unmakePoint . makePoint = id makePoint . unmakePoint = id 무슨 말인고 하니, makePoint와 unmakePoint는 짝을 점으로, 점을 짝으로 무손실 변환하는 방법을 제공한다. 전문 용어를 쓰자면 makePoint와 unmakePoint는 동형을 형성한다. unmakePoint는 Lens' Point (Double, Double)로 만들 수 있다. 그 대칭으로 makePoint는 Lens' (Double, Double) Point로 만들 수 있다. 두 렌즈는 한 쌍의 역이다. 역이 있는 렌즈들은 고유의 Iso 동의 타입을 가지고, Control.Lens.Iso에 보조 도구들이 정의되어 있다. iso 함수를 통해 한 쌍의 역으로부터 Iso를 만들 수 있다. iso :: (s -> a) -> (b -> t) -> Iso s t a b pointPair :: Iso' Point (Double, Double) pointPair = iso unmakePoint makePoint Iso는 Lense이므로 익숙한 렌즈 합성자들도 잘 작동한다. GHCi> import Data.Tuple (swap) GHCi> let testPoint = makePoint (2,3) GHCi> view pointPair testPoint -- Equivalent to unmakePoint (2.0,3.0) GHCi> view (pointPair . _2) testPoint 3.0 GHCi> over pointPair swap testPoint Point {_positionX = 3.0, _positionY = 2.0} 그리고 Iso는 from을 이용하여 반전될 수 있다. GHCi> :info from pointPair from :: AnIso s t a b -> Iso b a t s -- Defined in ‘Control.Lens.Iso’ pointPair :: Iso' Point (Double, Double) -- Defined at WikibookLenses.hs:77:1 GHCi> view (from pointPair) (2,3) -- Equivalent to makePoint Point {_positionX = 2.0, _positionY = 3.0} GHCi> view (from pointPair . positionY) (2,3) 3.0 under는 또 다른 흥미로운 합성 자다. under는 이름에서 보이듯이 over와 비슷한데, from에서 얻을 수 있는 반전된 Iso를 사용한다는 점이 다르다. Data.Char의 chr와 ord를 직접 사용하지 않고 enum 동형사상을 통해 Char의 Int 표현을 다루면서 이를 설명하겠다. GHCi> :info enum enum :: Enum a => Iso' Int a -- Defined in ‘Control.Lens.Iso’ GHCi> under enum (+7) 'a' 'h' newtype과 기타 단일 생성자 타입들은 동형을 만든다. Control.Lens.Wrapped는 이 사실을 활용하여 Iso 기반 도구들을 제공하는데, 그 예로 newtype들을 언래핑하기 위해 레코드 레이블 이름을 기억할 필요를 없앤다. GHCi> let testConst = Const "foo" GHCi> -- getConst testConst GHCi> op Const testConst "foo" GHCi> let testIdent = Identity "bar" GHCi> -- runIdentity testIdent GHCi> op Identity testIdent "bar" 그리고 인스턴스 선택을 위한 newtype 래핑을 좀 더 깔끔하게 만든다. GHCi> :m +Data.Monoid GHCi> -- getSum (foldMap Sum [1.. 10]) GHCi> ala Sum foldMap [1.. 10] 55 GHCi> -- getProduct (foldMap Product [1.. 10]) GHCi> ala Product foldMap [1.. 10] 3628800 Prism Iso를 통해 optic들의 계층도에서 Lens보다 밑의 단계에 처음으로 진입했다. 모든 Iso는 Lens 지만 모든 Lens가 Iso는 아니다. Traversal을 되돌아보면 optic이 가리키는 대상이 점차 흐려지는 것을 관찰할 수 있다. Iso는 정확히 한 대상을 가지고 역이 있는 optic이다. Lens도 정확히 한 대상을 가지지만 역이 없다. Traversable은 복수 대상을 가지고 역이 없다. 여기까지 오며 우리는 먼저 가역성을 버리고 그다음 대상의 유일성을 버렸다. 다른 길을 취해서 가역성보다 유일성을 먼저 버리면 동형과 순회 사이에서 두 번째 종류의 optic인 프리즘을 발견할 수 있다. Prism은 가역 optic이지만 대상이 반드시 하나는 아니다. 그런데 가역성과 복수 대상은 양립할 수 없기 때문에 더 명확히 하자면, Prism은 대상이 없거나 정확히 하나만 있다. 실패 가능성이 있는 단일 대상을 가리킨다고 하니 패턴 매칭같이 들리는데, 프리즘은 바로 그 개념을 포착할 수 있다. 튜플과 레코드가 렌즈의 자연스러운 용례를 제공하듯이 Maybe, Either, 기타 복수 생성자를 가지는 타입들이 프리즘에 대해 같은 역할을 한다. 모든 Prism은 Traversal이므로 순회를 위한 모든 합성자, setter, fold는 프리즘에도 작동한다. GHCi> set _Just 5 (Just "orange") Just 5 GHCi> set _Just 5 Nothing Nothing GHCi> over _Right (2 *) (Right 5) Right 10 GHCi> over _Right (2 *) (Left 5) Left 5 GHCi> toListOf _Left (Left 5) [5] 하지만 Prism은 Getter가 아니다. 대상이 없을 수도 있다. 그런 이유로 대상을 얻기 위해 view 대신 preview를 사용한다. GHCi> preview _Right (Right 5) Just 5 GHCi> preview _Right (Left 5) Nothing Prism의 역을 얻으려면 Control.Lens.Review의 re와 review를 쓴다. re는 from과 유사하지만 단순히 Getter를 제공한다. review는 반전된 프리즘을 취하는 view와 동등하다. GHCi> view (re _Right) 3 Right 3 GHCi> review _Right 3 Right 3 렌즈가 단지 레코드 필드에 접근하기 위한 것이 아니듯이, 프리즘은 생성자 매칭만을 위한 것이 아니다. 예를 들어 Control.Lens.Prism에 정의된 only는 동치 검사를 Prism으로 감싼다. GHCi> :info only only :: Eq a => a -> Prism' a () -- Defined in ‘Control.Lens.Prism’ GHCi> preview (only 4) (2 + 2) Just () GHCi> preview (only 5) (2 + 2) Nothing prism과 prism' 함수를 이용해 우리만의 프리즘을 만들 수 있다. 다음은 Data.List의 stripPrefix를 사용한 예제다. GHCi> :info prism prism :: (b -> t) -> (s -> Either t a) -> Prism s t a b -- Defined in ‘Control.Lens.Prism’ GHCi> :info prism' prism' :: (b -> s) -> (s -> Maybe a) -> Prism s s a b -- Defined in ‘Control.Lens.Prism’ GHCi> import Data.List (stripPrefix) GHCi> :t stripPrefix stripPrefix :: Eq a => [a] -> [a] -> Maybe [a] prefixed :: Eq a => [a] -> Prism' [a] [a] prefixed prefix = prism' (prefix ++) (stripPrefix prefix) GHCi> preview (prefixed "tele") "telescope" Just "scope" GHCi> preview (prefixed "tele") "orange" Nothing GHCi> review (prefixed "tele") "graph" "telegraph" prefixed는 lens 라이브러리의 Data.List.Lens 모듈에서 찾을 수 있다. 연습문제 1. Control.Lens.Prism에는 다음의 타입(간략화됨)을 가지는 outside 함수가 정의되어 있다. outside :: Prism s t a b -> Lens (t -> r) (s -> r) (b -> r) (a -> r) a. outside가 하는 일을 구현을 언급하지 않고 설명하라. (힌트: 문서에는 outside를 통해 "Prism을 일종의 일등급 패턴으로 쓸 수 있다"라고 쓰여있다. 여러분의 답은 이것을 확장하여 어떻게 그런 방식으로 쓸 수 있는지를 설명해야 한다.) b. outside를 사용해 Prelude의 maybe와 either를 구현하라. maybe :: b -> (a -> b) -> Maybe a -> b either :: (a -> c) -> (b -> c) -> Either a b -> c 법칙 정상적인 optic이라면 어떻게 행동해야 한다고 기술하는 법칙들이 있다. 지금까지 다룬 optic 들에 적용되는 법칙들을 알아보자. 계층도의 꼭대기부터 보면 Foldable 클래스와 마찬가지로 Fold의 법칙은 없다. 모든 함수는 Getter로 만들 수 있기 때문에 Getter의 법칙도 없다. Setter의 법칙은 있다. over는 fmap의 일반화이기 때문에 펑 터 법칙의 대상이다. over s id = id over s g. over s f = over s (g . f) set s x = over s (const x)이기 때문에 펑 터 제2법칙은: set s y. set s x = set s y 즉 두 번의 세팅은 한 번의 세팅과 같다. Traversal 법칙도 비슷하게 Traversable 법칙의 일반화다. t pure = pure fmap (t g) . t f = getCompose . t (Compose . fmap g. f) Traversable 장의 결론은 이런 것이었다. 모든 대상을 정확히 한 번씩 순회 방문한 다음, 둘러싸는 구조를 보존하거나 완전히 파괴해야 한다. 모든 Lens는 Traversal이 자 Setter이며 따라서 위의 법칙들은 렌즈들에도 적용된다. 게다가 모든 Lens는 Getter이다. 렌즈가 getter 이자 setter이기 때문에 설정 대상과 획득 대상이 같아야 한다. 이 공통 요구사항은 다음 법칙으로 표현된다. view l (set l x) = x set l (view l z) z = z 위에서 본 setter의 "이중 설정" 법칙과 함께 이 법칙들을 대개 렌즈 법칙이라 부른다. 비슷한 법칙들이 Prism에도 있는데, view 대신 preview를, set 대신 review를 쓴다. preview p (review p x) = Just x review p <$> preview p z = Just z Iso는 렌즈이라 프리즘이어서 위의 모든 법칙이 성립한다. 그런데 동형성 preview i = Just . view i(즉 preview는 절대 실패하지 않는다)에 따라 프리즘 법칙은 간략하게 만들 수 있다. view i (review i x) = x review i (view i z) = z 다형성 갱신 Setter s t a b나 Lens s t a b 같은 optic 타입들에는 독립된 타입 변수 네 개가 있다. 하지만 다양한 optic 법칙들을 고려해 보면 모든 s, t, a, b의 조합이 말이 되는 건 아니다. 가령 setter의 "이중 설정" 법칙을 보자. set s y. set s x = set s y "두 번의 설정은 한 번의 설정과 같다"가 말이 되려면 같은 setter로 두 번 설정하는 것이 가능해야 한다. 이 법칙이 성립하려면 t를 어떻게든 한정 지어서 s와 같게 만들어야 한다. (그러지 않으면 매번 set할 때마다 전체 타입이 바뀌어 타입이 맞지 않게 된다) 위와 같은 법칙들에 수반되는 타입 제한으로부터 모범적인 Setter, Traversal, Prism, Lens의 네 타입 매개변수가 서로 완전히 독립이 아니라는 것을 알 수 있다. 이 독립성을 자세히 살펴보지는 않고, 그 결론은 몇 가지 짚고 넘어가겠다. 첫 번째로 a와 b는 같은 옷감에서 잘라낸 것이라 어떤 optic이 타입을 바꾸더라도 a와 b를 동일하게 만들 방법이 있어야 한다. s와 t에 대해서도 같다. 두 번째로, a와 b가 같다면 s와 t도 같아야만 한다. 실전에서 이 제한사항들이 뜻하는 바는, 타입을 바꿀 수 있는 유효한 optic은 s와 t가 a와 b에 대해 매개화되기 마련이라는 것이다. 이런 식으로 타입을 바꾸는 갱신을 다형성 갱신(polymorphic update)이라고 칭한다. 설명을 위해 lens에서 예제 몇 개를 가져왔다. -- To avoid distracting details, -- we specialised the types of argument and _1. mapped :: Functor f => Setter (f a) (f b) a b contramapped :: Contravariant f => Setter (f b) (f a) a b argument :: Setter (b -> r) (a -> r) a b traverse :: Traversable t => Traversal (t a) (t b) a b both :: Bitraversable r => Traversal (r a a) (r b b) a b _1 :: Lens (a, c) (b, c) a b _Just :: Prism (Maybe a) (Maybe b) a b 이제 Lens 타입을 소개할 때 남겨둔 질문으로 돌아간다. Lens와 Traversal은 타입 변경을 허용하고 Getter와 Fold는 허용하지 않는다면, 모든 Lens가 타입 변경을 허용하는 Traversal이고 Getter와 Fold는 그렇지 않다고 말하기는 성급한 것 아닌가? 그런데 타입 변수들의 독립성은 법칙을 만족하는 Lens라면 Getter로 쓰일 수 있고, 법칙을 만족하는 Traversal은 Fold로 쓰일 수 있음을 뜻한다. 따라서 법칙을 만족하는 렌즈와 순회는 타입을 바꾸지 않는 방식으로 항상 사용할 수 있다. 아무런 조건 없이 앞서 봤듯이 lens 같은 함수나 makeLenses 같은 자동 생성 도구를 이용해서 optic을 정의할 수 있다. 엄밀히 말하면 이것들은 단지 편리한 도우미다. Lens나 Traversal 등이 그저 동의 타입이기 때문에 그 정의는 optic을 작성할 때 필요 없다. 가령 Lens s t a b 대신 언제나 Functor f => (a -> f b) -> (s -> f t)라고 쓸 수 있다. 즉 lens를 전혀 쓰지 않고도 lens와 호환되는 optic을 정의할 수 있다는 말이다. 모든 Lens, Traversal, Setter, Getting은 base 패키지 외의 어느 것에도 의존하지 않고 정의할 수 있다. 더 읽을거리 앞서 언급하기를 lens만으로도 책 한 권은 나온다고 했었다. 여기에 가장 근접한 것은 Artyom Kazak의 블로그에 있는 "lens over tea" 연재물이다. 이 연재에서는 lens에서 함수형 참조의 구현을 탐험하고 그 속의 개념을 여기서 한 것보다 심도 있게 다룬다. 강력 추천한다. lens의 깃헙 위키에 유용한 정보가 있다. 물론 lens의 API 문서도 볼 가치가 있다. lens는 거대하고 복잡한 라이브러리다. 그 구현을 공부하고 싶지만 좀 더 간단한 것을 원한다면 microlens나 lens-simple 같이 lens와 호환되는 소형 라이브러리들이 좋은 출발점이다. optic 기반 라이브러리들을 배우고 또한 활용하는 것은 함수형 참조가 어떻게 쓰이는지 익히는 좋은 방법이다. 몇 가지 예를 들면 diagrams는 lens를 폭넓게 활용하여 그래픽스 요소의 속성을 다루는 라이브러리다. wreq는 lens 기반 인터페이스를 갖춘 웹 클라이언트 라이브러리다. xml-lens는 XML을 수정하기 위한 optic을 제공한다. formattable은 날짜, 시간, 숫자 포매팅을 위한 라이브러리다. Formattable.NumFormat은 lens 패키지에 의존하지 않고 lens 호환 렌즈들을 제공하는 모듈의 예시다. 10 가변 객체 원문: https://en.wikibooks.org/wiki/Haskell/Mutable_objects IORef 동시성의 함정 ST 모나드 가변 자료구조 더 읽을거리 노트 함수 순수성은 하스켈의 핵심이다. 하스 켈 생태계에서는 가변 상태를 되도록 피할 것을 권장한다. State 모나드 덕에 상태를 편리하면서 순수 함수적인 방법으로 추적할 수 있거니와, containers나 unordered-containers 패키지의 효율적인 불변 자료구조 덕에 하스 켈 프로그래머에게 불변성이 문제가 되는 일은 적기 때문이다. 하지만 그저 가변 상태가 더 나을 때도 있다. 예를 들면, 하스 켈 코드에서 다른 언어로 작성된, 가변 상태를 가정하는 라이브러리를 사용할 때. 이벤트-콜백 GUI 툴킷이 대표적이다. 하스 켈로 명령형 가변 변수를 제공하는 언어를 구현할 때 변수를 파괴적으로 갱신해야 하는 알고리즘을 구현할 때 계산 능력을 한 방울까지 쥐어짜내야 하는 거대한 데이터 처리 범용 프로그래밍 언어는 이런 작업들을 잘 처리해야 한다. 하스켈도 마찬가지다. 가변 객체를 만드는 것뿐 아니라, 가변성을 통제 하에 두어, 불변성이 기본인 환경을 평화롭게 유지할 수도 있다. IORef 가장 간단한 예부터 시작하자. 유저 인터페이스를 위한 일반적인 코드는 이벤트와 콜백 모델을 이용한다. 이벤트는 버튼이나 키보드를 누르는 그런 것이고, 콜백은 그 이벤트에 응답하여 호출되는 코드 조각이다. 클라이언트 코드(즉, 그런 라이브러리를 사용하는 여러분의 코드)는 인터페이스 요소, 관련 이벤트, 대응하는 콜백을 서로 연결해야 한다. 다음은 콜백을 등록하는 가상의 함수다. register :: (Element -> Event) -> Element -> IO () -> IO () IO () 인자는 콜백이고 register의 결과는 연결을 구성하는 IO 액션이다. register click button1 (print "Hello")을 실행하면 button1을 클릭할 때마다 콘솔에 "Hello"가 출력될 것이다. IO가 만연하고 의미 있는 반환값도 없는 register와 위의 설명을 보니 영락없이 명령형이라는 느낌이 든다. 그 이유는 가상의 GUI 라이브러리가 하스켈과 완전히 다른 명령형 언어로 작성되었기 때문이다. 훌륭한 사람들이 이 라이브러리를 하스켈에서 사용할 수 있게 인터페이스를 작성했지만, 이 인터페이스는 매우 얇은 것이어서 원래 라이브러리의 스타일이 우리 코드에 드러난다 1. register를 이용해 콘솔에 출력하거나 대화 상자를 띄우는 등의 IO 액션을 수행하는 것은 충분히 쉽다. 하지만 버튼을 누를 때마다 어떤 카운터를 1씩 증가시키려면 어떻게 해야 할까? register의 타입에는 콜백에 정보를 넘기거나 콜백으로부터 정보를 받을 방법이 드러나지 않는다(반환 타입이 ()이다). State는 도움이 되지 않는다. 콜백에 초기 상태를 넘길 방법이 있더라도 그 안에서 State 계산을 한 다음은? 계산 결과를 가지고 무엇을 할 것인가? 카운터의 다음 상태를 버튼을 또 누를 때 콜백에 넘겨야 하는데, 그게 언제 일어날지도 모르고 어쨌건 그 값을 유지하고 있을 방법도 없다. 많은 언어에서 이 문제의 확실한 해결책은 콜백 바깥에 가변 변수를 생성하고 콜백에서 이 변수를 참조하는 것이다. 그러면 콜백 코드에서 이 변수의 값을 원하는 대로 변경할 수 있다. 걱정할 필요 없다. 하스켈도 그런 것을 허용하기 때문이다. 사실 가변 변수 타입은 여러 개 있으며 가장 간단한 것은 IORef다. IORef는 가변 값을 담는 아주 단순한 상자다. 이렇게 생성한다. GHCi> import Data.IORef GHCi> :t newIORef newIORef :: a -> IO (IORef a) GHCi> box <- newIORef (4 :: Int) newIORef는 값을 하나 취해서 그 값으로 초기화된 IORef를 돌려준다. 이제 readIORef로 그 안의 값을 얻을 수 있다. GHCi> :t readIORef readIORef :: IORef a -> IO a GHCi> readIORef box >>= print 그리고 modifyIORef와 writeIORef로 값을 변경할 수 있다. GHCi> modifyIORef box (2*) GHCi> readIORef box >>= print GHCi> writeIORef box 0 GHCi> readIORef box >>= print 버튼 클릭 사이에 유지되는 정도라면, IORef 면 카운터를 구현하기에 충분하다. setupGUI :: IORef Int -> IO () setupGUI counter = do -- However much other GUI preparation code we need. register click button1 (modifyIORef counter (+1)) main :: IO () main = do -- etc. counter <- newIORef (0 :: Int) setupGUI counter -- Then just use the counter value wherever necessary. IORef를 합당한 이유 없이 마구잡이로 쓰는 것에 아무 의미도 없음을 주의하라. 가변 상태에 대한 근본적인 고려는 차치하고, 명시적인 read/write/modify 호출은 전혀 편리하지 않다. IORef를 다루기 위한 부수적인 IO는 말할 필요도 없다(우리의 가상 예제에서는 큰 문제가 되지 않는데, GUI 코드가 어쨌든 IO 내부에 있어야 하고, 프로그램의 핵심을 이루는 순수 함수들과 격리할 것이기 때문이다). 하지만 피할 수 없는 상황이라면 IORef가 여러분을 위해 준비되어 있다. 동시성의 함정 서문에서 말하지 않은 중요한 가변 변수 사용처가 있다. 바로 동시성이다. 즉 컴퓨터가 여러 계산을 동시에 수행하는 상황이다. 동시성 시나리오는 시시한 것(백그라운드 작업의 진행도를 표시하는 진행 막대)에서 극히 복잡한 것(수천 개 요청을 동시에 처리하는 서버단 소프트웨어)을 아우른다. 원칙적으로 동시 계산 사이의 실행 순서는 아무 보장도 없기 때문에 이들 사이의 의사소통에는 가변 변수가 필요하다. 하지만 여기서 복잡해진다. 가변 상태를 활용하는 코드를 이해하고 예측하는 문제는 예측 불가능한 순간의 독립적인 계산이 있을 때 심각해진다. 예를 들어 계산 A에는 계산 B의 결과가 필요한데, 예상보다 일찍 그 결과를 요청해서 가짜 결과를 얻을 수도 있다. 올바른 동시성 코드를 작성하는 것은 어려울 수 있고, 적절한 조치가 없으면 미묘한 버그가 쉽게 침투한다. Data.IORef에서 동시성 코드에 대한 안전장치를 제공하는 함수는 atomicallyModifyIORef와 atomicallyWriteIORef뿐이다. 이것들은 계산들 간에 유일한 공유 자원이 단 하나의 IORef 밖에 없는 아주 단순한 상황에서나 도움이 된다. 하스 켈 동시성 코드는 동시성을 위해 맞춤 제작된 보다 정교한 도구들을 활용해야 한다. MVar(가변 변수. 한 계산에 필요한 동안은 다른 계산에서 사용하지 못하도록 만들 수 있다. Control.Concurrent.MVar를 볼 것)라던가 stm 패키지의 Control.Concurrent.STM(소프트웨어 트랜잭션 메모리의 구현. 모든 공유 변수의 가용성을 명시적으로 관리하는 복잡함을 덜어주면서 안전한 동시성 코드를 작성할 수 있게 돕는 동시성 모델)이 바로 그런 것들이다 2. ST 모나드 위의 IORef 예제에서 가변성은 외부의 요인 때문에 강제되었다. 하지만 서문의 두 시나리오(가변성과 극심한 계산량이 필요한 알고리즘들)의 경우 가변 상태는 내부 요인 때문에 필요하다. 즉 최종 결과에는 반영되지 않는다. 가령 리스트 정렬에는 가변성이 근본적으로 필요하지 않으며 따라서 리스트를 정렬하고 새 리스트를 반환하는 함수는 원칙적으로 순수 함수다. 정렬 알고리즘 자체가 원소 간 위치를 바꾸기 위해 파괴적 갱신을 사용하더라도 말이다. 그런 경우 가변성은 구현 세부사항일 뿐이다. 표준 라이브러리에는 순수 함수를 유지하면서 이런 상황을 처리하는 훌륭한 도구가 있다. 바로 Control.Monad.ST의 ST 모나드다. data ST s a ST s a는 State s a와 비슷하게 보이는데, 실제로도 그렇다. ST 계산은 결과를 내놓기 위해 내부 상태를 사용하는데 그 상태가 변경 가능하다. 이를 위해 Data.STRef는 STRef를 제공한다. STRef s a는 IORef a와 같지만 IO가 아니라 ST s 모나드 내부에 있다는 점이 다르다. ST를 State나 IO와 구별짓는 주된 차이점이 있다. Control.Monad.ST에는 runST 함수가 있다. runST :: (forall s. ST s a) -> a 타입 명세가 충격적이다. ST가 가변성을 수반한다면 어떻게 모나드에서 단순히 값을 뽑아올 수 있는가? 해답은 forall s.에 있다. 인자의 타입에 forall s. 가 들어가면 타입 검사기에게 이렇게 말하는 것이다. "s는 무엇이든 될 수 있다. 이에 대해 어떤 가정도 하지 말 것." 하지만 아무런 가정도 할 수 없다면 s는 무엇에도 매칭될 수 없다는 뜻이다. 심지어 runST를 다른 곳에서 실행할 때의 s와도 매칭할 수 없다 3. GHCi> import Control.Monad.ST GHCi> import Data.STRef GHCi> -- Attempt to keep an STRef around to pass to pure code: GHCi> let ref = runST $ newSTRef (4 :: Int) <interactive>:125:19: Couldn't match type ‘a’ with ‘STRef s Int’ because type variable ‘s’ would escape its scope This (rigid, skolem) type variable is bound by a type expected by the context: ST s a at <interactive>:125:11-37 Expected type: ST s a Actual type: ST s (STRef s Int) Relevant bindings include ref :: a (bound at <interactive>:125:5) In the second argument of ‘($)’, namely ‘newSTRef (4 :: Int)’ In the expression: runST $ newSTRef (4 :: Int) GHCi> -- The error message is quite clear: GHCi> -- "because type variable ‘s’ would escape its scope" GHCi> -- Attempt to feed an STRef from one ST computation to another: GHCi> let x = runST $ readSTRef =<< runST (newSTRef (4 :: Int)) <interactive>:129:38: Couldn't match type ‘STRef s1 Int’ with ‘ST s (STRef s a)’ Expected type: ST s1 (ST s (STRef s a)) Actual type: ST s1 (STRef s1 Int) Relevant bindings include x :: a (bound at <interactive>:129:5) In the first argument of ‘runST’, namely ‘(newSTRef (4 :: Int))’ In the second argument of ‘(=<<)’, namely ‘runST (newSTRef (4 :: Int))’ GHCi> -- The 's' from each computation are necessarily not the same. 이 타입 기교의 결과로서 각 ST 계산 내부에 내부 상태와 가변성이 격리되어, 프로그램의 다른 모든 부분에서 runST를 순수 함수로 보게 된다. ST의 쉬운 예로 다음은 리스트 합의 명령형 버전이다[4]. import Control.Monad.ST import Data.STRef import Data.Foldable sumST :: Num a => [a] -> a sumST xs = runST $ do n <- newSTRef 0 for_ xs $ \x -> modifySTRef n (+x) readSTRef n 어느 모로 보나 sumST는 익숙한 sum 만큼 순수한 함수다. 누산기 n을 파괴적 갱신하는 것은 구현 세부사항일 뿐이고, n에 대한 정보가 최종 결과 외에 누출될 길은 없다. 이 단순한 예에서는 ST s a의 타입 변수 s가 계산 내의 특정한 것에 대응하지 않는다는 점이 확실히 드러난다. s는 인공적인 표식일 뿐이다. 주목할 만한 또 다른 세부사항은 for_는 리스트를 오른쪽부터 접지만 합은 왼쪽부터 수행된다는 것으로, 변경이 왼쪽에서 오른쪽으로 나열된 형태의 applicative effect로서 수행되기 때문이다. 가변 자료구조 가변 자료구조는 필요성이 입증된 사례에 대한 라이브러리들에서 찾을 수 있다. 예를 들어 가변 배열(불변 배열 포함)은 GHC에 동봉된 vector 패키지나 array 패키지에서 찾을 수 있다 5. hashtables 패키지에서는 가변 해시 테이블을 찾을 수 있다. 모두 ST 버전과 IO 버전을 제공한다. 더 읽을거리 Writing Yourself a Scheme in 48 Hours의 7장은 언어에서 가변 변수를 구현하기 위해 IORef를 활용하는 흥미로운 예시다. Lennart Augustsson의 블로그는 진짜 퀵소트(즉 리스트를 정렬하기 위해 파괴적 갱신을 하는 원본 알고리즘)를 하스켈에서 구현하는 방법을 보여준다. 그의 구현은 가변성을 다루기 위해 사용된 결합기 덕에 상당히 흥미로운데, 하스켈을 C처럼 보이게 만든다. 작동 원리를 알려면 링크한 글 앞의 두 글을 확인할 것. 노트 다른 언어에서 라이브러리 간 인터페이스를 칭하는 기술적 용어는 바인딩이다. 바인딩은 얇아서 원래 라이브러리의 구조를 환하게 드러낼 수도 있고 추상화 계층을 더해서 보다 하스켈스럽게 만들 수도 있다. 하스켈에서 바인딩을 만드는 기본적인 도구는 FFI(foreign function interface)로, 하스 켈 실전에서 다룰 것이다. ↩ 이 책의 뒷부분에서 그 특징들 중 일부를 소개할 것이다. ↩ 이는 존재적 existential 타입의 예시다. "existential"은 우리가 아는 것이라고는 이것이 존재한다는 것뿐임을 뜻한다. ↩ 하스켈위키의 ST에 관한 페이지에서 가져옴. ↩ 배열에 관한 일반적인 설명은 자료구조 입문을 볼 것. ↩ 11 동시성 원문: https://en.wikibooks.org/wiki/Haskell/Concurrency 동시성 언제 동시성이 필요한가? 예제 소프트웨어 트랜잭션 메모리 동시성 하스켈에서 동시성은 대부분 하스 켈 스레드에 의해 이뤄진다. 하스 켈 스레드는 런타임에 구현되는 유저 스페이스 스레드다. 하스 켈 스레드는 OS 스레드보다 시간 및 공간 측면에서 훨씬 효율적이다. 세마포어 같은 전통적인 동기화 프리미티브 외에도 하스켈은 공유 메모리에 대한 동시 접근을 크게 단순화하는 소프트웨어 트랜잭션 메모리를 제공한다. 동시성을 위한 모듈로 Control.Concurrent.*와 Control.Monad.STM이 있다. 언제 동시성이 필요한가? 아마 언제 필요한지 보다는 언제 필요하지 않은 지가 더 중요할 것이다. 하스켈의 동시성은 멀티프로세서 코어들을 활용하기 위한 것이 아니다. 그런 것에는 "병렬화"가 필요하다. 동시성은 단일 코어가 그 관심사를 여러 가지, 보통은 IO로 분산해야 할 때 사용된다. 예를 들어 간단한 "정적" 웹서버(즉 이미지 같은 정적 콘텐츠만 제공하는)를 생각해 보자. 이상적으로는 그런 웹서버는 프로세싱 리소스를 적게 먹어야 한다. 대신 데이터를 최대한 빠르게 전송할 수 있어야 한다. 병목은 분명 더 많은 하드웨어를 쏟아부을 수 있는 I/O 일 것이다. 따라서 여러 커넥션에 대해 단일 프로세서 코어를 효율적으로 활용해야 한다. 그러한 웹서버의 C 버전이라면 각 커넥션과 리스닝 소켓에 대해 select()를 중심으로 거대한 루프를 사용했을 것이다. 각 오픈 커넥션은 그 커넥션의 상태를 기술하는 자료구조를 가졌을 것이다. (즉 HTTP 헤더를 받아 파싱하고 파일을 보내는) 그런 거대 루프는 직접 코딩하기에는 어렵고 오류에 취약하다. 하지만 하스 켈 동시성을 활용하면 리스닝 소켓에만 집중하는 보다 작은 루프를 작성할 수 있다. 이 루프에서는 수락된 커넥션마다 새로운 "스레드"를 스폰 한다. 그러면 이 새로운 "스레드"를 IO 모나드 안에서 HTTP 헤더를 받고, 파싱하고, 파일을 보내도록 작성할 수 있다. 내부적으로 하스 켈 컴파일러는 스레드의 스폰을 "스레드"의 상태를 기술하는 작은 구조체의 할당으로 변환한다. 이 구조체는 C에서 정의했을 법한 자료구조와 유사하다. 그러고는 여러 스레드를 하나의 거대 루프로 변환할 것이다. 따라서 여러분이 각 스레드가 독립적인 것처럼 작성해도 내부적으로 컴파일러는 그걸 select()를 중심으로 하는 하나의 거대 루프 또는 여러분의 시스템에 최선인 무언가로 변환할 것이다. 예제 예제: 파일의 병렬 다운로드 downloadFile :: URL -> IO () downloadFile = undefined downloadFiles :: [URL] -> IO () downloadFiles = mapM_ (forkIO . downloadFile) 소프트웨어 트랜잭션 메모리 소프트웨어 트랜잭션 메모리(STM)는 데이터베이스 트랜잭션과 비슷한 메모리 상에서의 트랜잭션을 위한 메커니즘이다. STM은 멀티쓰레딩 환경에서 프로그래밍을 할 때 공유 리소스에 대한 접근을 크게 간소화한다. STM을 사용하면 더 이상 잠금(locking)에 의존하지 않아도 된다. STM을 사용하려면 Control.Concurrent.STM을 임포트 해야 한다. STM 모나드 내부로 들어가려면 atomically 함수를 사용한다. STM은 커뮤니케이션을 위해 사용할 수 있는 여러 프리미티브(TVar, TMVar, TChan, TArray)를 제공한다. 2 타입과의 유희 타입과의 유희 다형성 기초 Existentially qualified types 타입 클래스 고급 팬텀 타입 일반화된 대수적 데이터 타입 (GADT) 데이터 타입 대수 원문이 없음 타입 생성자 & 종(kind) 1 다형성 기초 원문: https://en.wikibooks.org/wiki/Haskell/Polymorphism TODO 원문도 미완성 상태입니다. (2021-09-30 마지막 확인) 매개변수 다형성 forall a Higher rank types runST 예측 불가능성 System F 예제 다형성의 다른 형태 노트 매개변수 다형성 forall a 여러분은 아마 다형 함수가 여러 다른 타입에 대해 작동하는 함수라는 것을 알고 있을 것이다. 한 예시로 length :: [a] -> Int 는 문자열 String = [Char]이든 숫자들의 리스트 [Int]이든 어떤 리스트의 길이도 계산할 수 있다. 타입 변수 a는 length가 어떤 타입이든 받아들임을 뜻한다. 다른 다형 함수의 예는 fst :: (a, b) -> a snd :: (a, b) -> b map :: (a -> b) -> [a] -> [b] 타입 변수는 항상 소문자로 시작하는 반면 Int나 String 같은 구체적인 타입은 항상 대문자로 시작한다. 둘은 이렇게 구분한다. a가 임의의 타입이 될 수 있음을 나타내는 더 명시적인 방법이 있다. length :: forall a. [a] -> Int 달리 말하면, "모든 타입 a에 대해 length 함수는 a 타입인 원소들의 리스트를 취해서 정수를 반환한다." 이전의 타입 명세는 forall1을 쓰는 새로운 명세의 축약 표현으로 생각하라. 즉 컴파일러는 빠뜨린 forall을 내부에서 끼워 넣을 것이다. 다른 예로 fst의 타입 명세는 다음을 줄인 것이다. fst :: forall a. forall b. (a, b) -> a 또는 다음과 동치다. fst :: forall a b. (a, b) -> a 비슷하게 map의 타입은 사실 다음과 같다. map :: forall a b. (a -> b) -> [a] -> [b] 무언가를 모든 타입에 적용한다거나 모든 것에 대해 성립한다는 발상을 universal quantification이라고 한다. 수리논리에서 ∀2 기호(A를 뒤집은 것. "forall"으로 읽는다)가 흔히 그런 의미로 쓰이고 universal quantifier라고 불린다. Higher rank types 명시적인 forall을 쓰면 다형 인자를 취하는 함수를 작성할 수 있게 된다. 예를 들어 foo :: (forall a. a -> a) -> (Char, Bool) foo f = (f 'c', f True) 여기서 f는 다형 함수고 모든 것에 적용할 수 있다. 특히 f는 문자 c와 이진 값 True 둘 다에 적용할 수 있다. Haskell98에서는 foo 같은 함수를 작성할 수 없는데, 타입 검사기가 f는 Char 타입 또는 Bool 타입의 값에만 적용될 수 있다고 불평하고 따라서 이 정의를 거부할 것이기 때문이다. 그나마 가장 유사하게 타입을 써보자면, bar :: (a -> a) -> (Char, Bool) 이는 다음과 같다. bar :: forall a. ((a -> a) -> (Char, Bool)) 하지만 이것은 foo와 매우 다르다. 가장 바깥의 forall은 f가 bar에게 알려지지 않은 어떤 타입 a에 대해 a -> a 형태인 한, bar가 어떤 인자 f와도 작동함을 약속한다. foo와 비교해 보면 a -> a 형태임을 약속하는 주체가 인자 f이고, 그 약속을 활용하는 것은 a = Char와 a = Bool을 선택하는 foo다. 명명법에 의하면 bar 같은 단순 다형 함수는 랭크-1 타입이라 부르고 foo의 타입은 랭크-2 타입으로 분류된다. 일반적으로 랭크-n 타입은 랭크-(n-1) 인자가 최소 한 개 있지만 랭크가 더 높은 인자는 없는 함수다. 고랭크 타입의 이론적<NAME> System F으로서 2차 람다 대수라고도 알려져 있다. 이에 관해서는 forall의 의미, foo나 bar에서 forall의 위치가 가지는 뜻을 더 잘 이해하기 위해 System F 절에서 자세히 알아볼 것이다. Haskell98은 Hindley-Milner 타입 체계에 기반한다. 이 체계는 System F의 하위로 forall과 랭크-2 이상의 타입을 지원하지 않는다. 언어 확장 RankNTypes3을 활성화해야 System F의 전부를 활용할 수 있다. 하지만 Haskell98이 고랭크 타입을 지원하지 않는 이유가 있는 법이다. 완전한 System F를 위한 타입 추론은 결정 불가능하고 프로그래머가 모든 타입 명세를 작성해야 한다. 그래서 초기 하스켈은 단순한 다형 함수만을 제공하는 Hindley-Milner 타입 체계를 채택했고, 그 대신 완벽한 타입 추론을 제공했다. 최근 연구의 발달로 타입 명세를 작성하는 부담이 줄어 요즘 하스 켈 컴파일러에서는 랭크-n 타입을 실용적으로 쓸 수 있다. runST 하스 켈 실전 프로그래머라면 ST 모나드로 랭크-2 타입을 처음 접했을 것이다. ST 모나드는 IO 모나드와 비슷하게 가변 참조를 제공한다. newSTRef :: a -> ST s (STRef s a) readSTRef :: STRef s a -> ST s a writeSTRef :: STRef s a -> a -> ST s () 그리고 가변 배열도 지원한다. 타입 변수 s는 조작할 상태를 나타낸다. 하지만 IO와 달리 이 상태 있는 계산은 순수 코드에서 사용할 수 있다. 특히 다음 함수는 runST :: (forall s. ST s a) -> a 초기 상태를 설정하고, 계산을 실행하고, 상태를 제거한 다음 결과를 반환한다. 보듯이 랭크-2 타입이다. 왜? 요점은 가변 참조가 한 runST에 국한되어야 한다는 것이다. 예를 들어 v = runST (newSTRef "abc") foo = runST (readSTRef v) 이것은 잘못되었는데 가변 참조를 한 runST의 문맥에서 생성하고 두 번째 runST에서 재사용했기 때문이다. 달리 말하자면 (forall s. ST s a) -> a에서 최종 타입인 a는 v의 경우 STRef s String이 아닐 수도 있다. 그런데 랭크-2 타입이 그것을 보장한다! 인자가 s에 대해 다 형이어야 하기 때문에 모든 상태 s에 대해 같은 타입인 a를 반환해야 한다. 최종 a는 상태와 무관할 수 있다. 따라서 위의 코드는 타입 오류를 품고 있고 컴파일러가 거부할 것이다. ST 모나드에 대한 더 자세한 설명은 원논문 Lazy functional state threads에서 볼 수 있다.4 예측 불가능성 예측 가능 = 타입 변수가 단일 타입으로 인스턴스화됨. 예측 불가능 = 다형 타입. 예: length [id :: forall a. a -> a] 또는 Just (id :: forall a. a -> a). 고랭크에서 미묘하게 다름. 다형 타입들의 일반성에 의한 관계, 즉 isInstanceOf. 하스 켈 카페: RankNTypes 토막 설명 System F Section goal = 암묵적 타입 매개변수 전달이 뇌에 줄 타격을 방지하기 위한 람다 대수 기초 System F = 이 모든 ∀의 근간이 되는 것 명시적 타입 응용. map Int (+1) [1,2,3] 같은 거. ∀는 함수 애로 ->와 유사. 타입에 따른 용어. 타입 인자에는 대문자 Λ, 값 인자에는 소문자 λ. 예제 독자가 ∀가 들어간 자료 구조를 사용할지 말지 스스로 판단할 수 있도록 하기. Church numerals, Encoding of arbitrary recursive types (positivity conditions): &forall x. (F x -> x) -> x Continuations, Pattern-matching: maybe, either and foldr 다형성의 다른 형태 Section goal = OOP의 다형성과 비교. 타입 클래스와의 어울림. ad-hoc polymorphism = 타입 s에 따라 다른 동작 => 하스 켈 타입 클래스 parametric polymorphism = 실제 쓰이는 타입과 무관 => ∀ subtyping 노트 키워드 forall은 하스 켈 98 표준이 아니다. 언어 확장 ScopedTypeVariables, Rank2Types, RankNTypes 등이 컴파일러에서 forall을 활성화한다. 미래의 하스 켈 표준은 이 중 하나를 포함할 것이다. ↩ UnicodeSyntax 확장은 하스 켈 소스 코드에서 forall 키워드 대신 ∀ 기호를 쓸 수 있도록 한다. ↩ 또는 랭크-2 타입만 원한다면 Rank2Types를 활성화할 것. ↩ John Launchbury; Simon Peyton Jones (1994-??-??). Lazy functional state threads. ACM Press". pp. 24-35. ↩ 2 Existentially qualified types 원문: https://en.wikibooks.org/wiki/Haskell/Existentially_quantified_types forall 키워드 예: 혼종 리스트 존재적이라는 용어에 대한 설명 예: runST 원시형으로서의 한정 더 읽을거리 Existential type, 짧게는 existential는 타입들의 모음을 하나의 타입으로 찌부러뜨리는 방법이다. existential은 GHC의 타입 체계 확장이다. 하스 켈 98에는 포함되지 않고 existential을 사용하는 코드를 컴파일하려면 커맨드 라인 인자로 -XExistentialQuantification을 추가하거나 소스 코드 윗부분에 {-# LANGUAGE ExistentialQuantification #-}을 넣어야 한다. forall 키워드 forall 키워드는 타입 변수를 스코프에 명시적으로 표현하는 데 사용된다. 다음과 같은 것을 수백 번도 더 봤을 것이다. 예: 다형 함수 map :: (a -> b) -> [a] -> [b] 여기서 a와 b는 무엇인가? 뭐, 타입 변수 아니겠나. 컴파일러는 이것들이 소문자로 시작하는 것을 보고 어느 타입이든 채워지도록 허용한다. 이를 다르게 보는 방법은 이 변수들이 universally quantified라고 보는 것이다.<NAME> 논리를 배웠다면 '모든 ...에 대해' ( ) 또는 `... 가 존재한다' ( ) 같은 한정자를 봤을 것이다. 이것들은 그다음에 오는 것들을 '한정'한다. ( )는 다음에 오는 것이 오직 하나의 x에 대해서만 참임을 뜻한다. ( ) 은 다음에 오는 것이 생각할 수 있는 모든 x에 대해 참임을 뜻한다. ( x x ≥ )이나 ( x x = 27 ) 이 그 예다. forall 키워드는 비슷한 방식으로 타입을 한정한다. map의 타입은 다음과 같이 고쳐 쓸 수 있다. 예: 타입 변수의 존재 한정 map :: forall a b. (a -> b) -> [a] -> [b] 말인즉슨 우리가 생각할 수 있는 모든 a와 b에 대해 map의 타입은 (a -> b) -> [a] -> [b]이다. a = Int, b = String을 선택한다면 map의 타입은 (Int -> String) -> [Int] -> [String]이 된다. map의 일반적인 타입을 더 구체적인 타입으로 인스턴스화한 것이다. 그런데 하스켈에서 소문자 타입은 알고 있듯이 암묵적인 forall 키워드로 시작한다. 따라서 map의 두 타입 선언은 동치며 아래의 선언도 마찬가지다. 예: 동치인 두 타입 선언 id :: a -> a id :: forall a. a -> a 정말 흥미로운 점은 forall을 어디 둘지를 하스켈에 알려서 이 기본 동작을 덮어쓸 수 있다는 것이다. 그 예가 존재 한정 타입 또는 존재적 타입, 간단히는 existential이라는 것이다. 잠깐, forall은 보편 한정자 아니었던가? 여기서 어떻게 존재적 타입을 얻는단 말인가? 그것은 나중에 알아볼 것이다. 그전에 존재적 타입의 강력함을 실제로 느껴보자. 예: 혼종 리스트 하스켈의 타입 클래스 체계에 깔린 전제는 공통 속성을<NAME>는 모든 타입을 그룹으로 묶는 것이다. 그러니까 여러분이 어떤 클래스 C를 인스턴스화하는 타입을 안다면 그 타입에 대해 무언가를 아는 것이다. 예를 들어 Int는 Eq를 인스턴스화하기에 우리는 Int의 원소들을 항등 비교할 수 있음을 안다. 값들의 모임이 있는데 이것들의 타입이 다 같은지는 모르지만, 모두 어떤 클래스를 인스턴스화하는 것은 안다고 가정하자. 즉 모든 값이 특정 성질을 가진다. 이 값들을 모두 한 리스트에 집어넣으면 유용할 것 같다. 일반적으로는 그럴 수 없는데 리스트는 타입에 대해 혼종 homogeneous이기 때문이다. 리스트는 단일 타입만을 담을 수 있다. 하지만 존재적 타입은 '타입 은닉자hider 또는 타입 상자'를 정의하여 이 제한을 완화한다. 예: 혼종 리스트의 구축 data ShowBox = forall s. Show s => SB s heteroList :: [ShowBox] heteroList = [SB (), SB 5, SB True] 이 데이터 타입 정의의 의미를 자세히 설명하지는 않겠지만 그 뜻은 확 와닿을 것으로 믿는다. 중요한 점은 세 다른 타입의 값에 대해 같은 생성자를 호출했고, 이것들을 한 리스트에 넣어서, 최종 타입들이 같다는 것이다. 근본적인 원리는 forall 키워드로 인해 생성자의 타입이 SB :: forall s. Show s => s -> ShowBox가 되었다는 점이다. 이제 heteroList를 전달하는 함수를 작성하고자 한다면, SB 내부의 값에 not 같은 함수를 적용할 수는 없다. 그 값의 타입이 Bool이 아닐 수도 있기 때문이다. 하지만 우리가 이 리스트의 원소들에 대해 아는 것이 있다. 이것들은 Show를 통해 문자열로 변환할 수 있다. 사실 우리가 아는 것이라곤 이것뿐이다. 예: 혼종 리스트의 활용 instance Show ShowBox where show (SB s) = show s -- 아래 문단을 볼 것 f :: [ShowBox] -> IO () f xs = mapM_ print xs main = f heteroList 한 번 살펴보자. ShowBox에 대한 show의 정의(주석 달린 줄)에서 우리는 s의 타입을 모른다. 하지만 앞서 말했듯 이 타입이 Show의 인스턴스라는 것은 SB 생성자의 제한에서 알 수 있다. 따라서 s에 함수 show를 사용하는 것은 함수 정의 우변에서 보듯이 정당하다. f에 대해서는, print의 타입을 떠올려보라. 예: 연관된 함수들의 타입 print :: Show s => s -> IO () -- print x = putStrLn (show x) mapM_ :: (a -> m b) -> [a] -> m () mapM_ print :: Show s => [s] -> IO () ShowBox를 Show의 인스턴스로 선언했기 때문에 리스트 내의 값들을 출력할 수 있다. 존재적이라는 용어에 대한 설명 앞에서 던졌던 질문으로 돌아가자. forall이 보편 한정자라면 왜 이것들을 존재적 타입이라 부르는가? forall으로 존재적 타입을 얻을 수 있기 때문에 하스켈에는 중복만 될 exists 키워드가 없다. 무엇보다도 forall은 '모든 ...에 대해'를 뜻한다. 타입을 그 타입의 값들의 집합으로 생각해 보면 Bool은 집합 {True, False, ⊥}이고(바텀 즉 ⊥은 모든 타입의 멤버다), Integer는 모든 정수와 바텀의 집합이고, String은 가능한 모든 문자열과 바텀의 집합이고... 이런 식이다. 가령 forall a. a는 모든 타입의 교집합으로, {⊥} 즉 오직 한 원소(바텀) 만 가지는 타입(집합)이다. Bool의 원소들 중 예를 들면 String에 나타나는 것은 무엇인가? 바텀만이 모든 타입에 공통인 값이다. 추가 예시: [forall a. a]는 모든 원소의 타입이 forall a. a인 리스트, 즉 바텀들의 리스트의 타입이다. [forall a. Show a => a]는 모든 원소의 타입이 forall a. Show a => a인 리스트다. Show 클래스라는 제약은 여러분이 교집합을 구하려는 집합들을 제한한다. (여기서는 오직 Show의 인스턴스들의 교집합) 하지만 여전히 ⊥가 모든 타입에 공통된 유일한 값이기 때문에 이것 역시 바텀들의 리스트다. [forall a. Num a => a]는 각 원소가 Num을 인스턴스화하는 모든 타입 중 하나의 멤버인 리스트다. forall a. Num a => a 타입인 숫자 리터럴과 바텀을 포함한다. forall a. [a] 원소들이 어떤 하나의 타입 a를 가지는 리스트. a는 피호출자에서 어떤 타입이든 지정 가능하다. (따라서 이것도 바텀들의 리스트다) 타입들 간의 교집합은 어떤 식으로든 대부분 결국 바텀들의 조합일 뿐이다. 타입들이 공통으로 가지는 값이 많지 않기 때문이다. 앞절에서 '타입 은닉자'를 이용해 혼종 리스트를 만들어낸 것을 떠올려보자. 이상적으로는 혼종 리스트의 타입이 [exists a. a] 즉 모든 원소의 타입이 exists a. a인 리스트여야 한다. 이 exists 키워드는 (하스켈에는 없다) 타입들의 합집합으로서 [exists a. a]는 모든 원소가 임의 타입을 가질 수 있는 리스트다. 그런데 데이터 타입을 이용하면 위와 거의 동일한 것을 얻을 수 있다. 그런 것을 하나 선언해 보자. 예제: 존재적 타입 data T = forall a. MkT a 이는 다음을 의미한다. 예제: 존재적 생성자의 타입 MkT :: forall a. a -> T 즉 MkT에 아무 값이나 넘기고 그것을 T로 변환할 수 있다. 이제 MkT 값을 분해하려 하면 어떤 일이 일어나는가? 예제: 존재적 타입에 대한 패턴 매칭 foo (MkT x) = ... -- x의 타입? 방금 말했듯이 x는 어떤 타입도 될 수 있다. 즉 임의 타입의 멤버이며 그 타입은 x :: exists a. a이다. 달리 말하자면 T의 선언은 다음과 동일하다. 예제: 위 존재적 타입과 동치 (의사 하스켈) data T = MkT (exists a. a) 갑자기 존재적 타입을 얻게 되었다. 이제 혼종 리스트를 만들 수 있다. 예제: 혼종 리스트의 생성 heteroList = [MkT 5, MkT (), MkT True, MkT map] 물론 heteroList에 패턴 매칭할 때 그 원소들에 대해서는 아무 일도 할 수가 없는데 1, 우리가 아는 것이라고는 단지 이것들이 어떤 타입을 가진다는 것뿐이기 때문이다. 하지만 클래스 제약을 도입한다면 예제: 클래스 제약이 있는 존재적 타입 data T' = forall a. Show a => MkT' a 이는 다음과 동치다. 예제: '진짜' 존재적 타입으로 번역한 데이터 타입 data T' = MkT' (exists a. Show a => a) 이번에도 클래스 제약은 합집합을 구하려는 타입들을 제한하여, 우리는 MkT' 안의 값들이 Show를 인스턴스화하는 어떤 타입을 가진다는 것을 안다. 여기 내포된 바는, exists a. Show a => a 타입의 값에 Show를 적용할 수 있다는 것이다. 이것이 실제로 어떤 타입인지는 중요하지 않다. 예제: 위 혼종 리스트의 활용 heteroList' = [MkT' 5, MkT' (), MkT' True, MkT' "Sartre"] main = mapM_ (\(MkT' x) -> print x) heteroList' {- prints: () True "Sartre" -} 요약하면, 보편 한정자와 데이터 타입이 결합하여 존재적 타입을 만들어낸다. forall을 수반하는 타입의 가장 흥미로운 응용들은 이러한 결합을 활용하고, 우리는 그런 타입을 '존재적'이라 부른다. 존재적 타입을 원하면 그 타입을 데이터 타입 생성자로 감싸야 한다. [exists a. a]처럼, 그 타입은 밖에서는 존재할 수 없다. 예: runST 아마 지금까지 ST 모나드라는 것을 본 적이 없을 것이다. ST는 State 모나드의 더 강력한 버전이다. ST의 구조는 훨씬 복잡하고 고급 주제들을 수반한다. ST는 원래 하스켈에 IO를 제공하기 위해 작성되었다. 모나드 이해하기 장에서 언급했듯 IO는 실제 세계에 관한 모든 정보라는 환경이 있는 State 모나드다. 사실 GHC 내에서는 ST가 쓰이는데 그 환경은 RealWorld라는 타입이다. runState를 사용해 State 모나드를 벗겨낼 수 있다. ST에서는 비슷한 것으로 runST가 있는데, 그 타입이 사뭇 특이하다. 예제: runST 함수 runST :: forall a. (forall s. ST s a) -> a 이것은 사실 랭크-2 다형성이라는 더 복잡한 언어 특성으로서 지금은 깊게 파고들지 않을 것이다. 초기 상태를 위한 매개변수가 없다는 점이 중요하다. 또한 ST는 상태를 표기하는 방식이 State와 다르다. State가 현 상태를 get 하고 put 하는 것을 허용하는 반면, ST는 참조에 대한 인터페이스를 제공한다. 여러분은 STRef 타입의 참조를 생성하기 위해 newSTRef :: a -> ST s (STRef s a)에 초깃값을 제공하고, 조작을 위해 readSTRef :: STRef s a -> ST s a와 writeSTRef :: STRef s a -> a -> ST s ()를 사용한다. 그래서 ST 계산의 내부 환경은 어떤 특정 값이 아니라 참조에서 값으로 가는 매핑이다. runST에 초기 상태를 제공할 필요가 없는 것은, 초기 상태가 참조를 포함하지 않는 빈 매핑이기 때문이다. 그런데 그렇게 단순한 일이 아니다. 한 ST 계산 안에서 참조를 만들면, 그것을 다른 ST 계산 안에서 쓰는 것을 어떻게 막을까? 이런 일이 일어나면 안 되는 이유는 (스레드 안정성을 위해) 어떤 ST 계산이든 초기 내부 환경이 특정 참조를 포함한다고 가정해서는 안 되기 때문이다. 보다 구체적으로는, 다음 코드는 올바르지 않아야 한다. 예제: 좋지 않은 ST 코드 let v = runST (newSTRef True) in runST (readSTRef v) 무엇이 이런 일을 막는가? runST의 타입이 랭크-2 다형성인 것의 영향으로 타입 변수 s의 범위는 첫 번째 매개변수 내부로 한정된다. 그러니까, 타입 변수 s가 첫 번째 매개변수 안에 나타나면 두 번째 매개변수 안에서도 나타날 수는 없다. 일이 정확히 어떻게 돌아가는지 살펴보자. 다음과 같은 코드에서 예: 좋지 않은 ST 코드의 일부 ... runST (newSTRef True) ... 컴파일러는 타입들을 끼워 맞추려고 노력한다. 예: 컴파일러의 타입 검사 단계 newSTRef True :: forall s. ST s (STRef s Bool) runST :: forall a. (forall s. ST s a) -> a 합치면 forall a. (forall s. ST s (STRef s Bool)) -> STRef s Bool 첫 번째 괄호 안의 forall의 요점은 s의 이름을 바꿀 수 있다는 것이다. 즉 이렇게 쓸 수 있다. 예: 타입 불일치 합치면 forall a. (forall s'. ST s' (STRef s' Bool)) -> STRef s Bool 말이 된다. 수학에서 x x 5 ∀. > 와 같다. 변수에 다른 이름을 붙일 뿐이다. 하지만 위 코드에는 문제가 있다. forall이 runST의 반환 타입까지 덮지 않기 때문에 반환 타입에서는 s의 이름이 바뀌지 않는다. 그런데 타입이 일치하지 않는다! 첫 매개변수 내의 ST 계산 결과의 타입은 runST의 결과 타입과 일치해야 하는데, 이제는 그렇지 않다. 존재자의 핵심은 컴파일러가 첫 번째 매개변수 내의 상태의 타입을 일반화하여, 결과 타입이 이것에 의존할 수 없도록 하는 것이다. 의존성 문제를 영리하게 비껴나가 runST의 매 호출마다 칸막이를 쳐 고유의 작은 히프를 만들고, 참조들은 호출 사이에서 공유될 수 없다. 원시형으로서의 한정 보편 한정은 이전에 정의되지 않은 데이터 타입을 정의할 때 유용하다. 하스켈에 쌍(pair)이 내장되지 않았다고 가정해 보자. 한정으로 쌍을 정의할 수 있다. {-# LANGUAGE ExistentialQuantification, RankNTypes #-} newtype Pair a b = Pair (forall c. (a -> b -> c) -> c) makePair :: a -> b -> Pair a b makePair a b = Pair $ \f -> f a b GHCi에서는 λ> :bro newtype Pair a b = Pair {runPair :: forall c. (a -> b -> c) -> c} makePair :: a -> b -> Pair a b λ> let pair = makePair "a" 'b' λ> :t pair pair :: Pair [Char] Char λ> runPair pair (\x y -> x) "a" λ> runPair pair (\x y -> y) 'b' 더 읽을거리 GHC의 사용자 지침에 existential에 대한 유용한 정보가 있다. Simon Peyton-Jones와 John Launchbury의 Lazy Functional State Threads는 ST의 아이디어를 설명하는 논문이다. 사실 타입이 forall a. a -> R인 함수들에는 적용할 수 있다. R은 임의 타입이다. 이 함수들은 어떤 타입의 값도 매개변수로 받아들인다. 예로 id, const k, seq 등이 있다. 그래서, 엄밀히 말하면 원소들을 WHNF으로 환원하는 것 외에는 어떤 유용한 일을 할 수가 없다. ↩ 3 고급 타입 클래스 원문: https://en.wikibooks.org/wiki/Haskell/Advanced_type_classes 복수 매개변수 타입 클래스 함수형 의존성 예제 행렬과 벡터 타입 클래스는 지루한 내용 같지만 연구 결과 몇 가지 발전과 일반화를 이루어, 매우 강력한 도구가 되었다. 복수 매개변수 타입 클래스 복수 매개변수 타입 클래스는 단일 매개변수 타입 클래스의 일반화로서 여러 하스 켈 구현에서 지원한다. 다양한 구체적 데이터 타입에 쓸 수 있고 두 가지 연산을 지원하는 'Collection' 타입 클래스를 만들려 한다고 가정하자. 그 연산은 원소를 추가하는 'insert'와 소속을 검사하는 'member'이다. 처음 시도는 다음과 같다. 예: (잘못된) Collection 타입 클래스 class Collection c where insert :: c -> e -> c member :: c -> e -> Bool -- 리스트를 Collection의 인스턴스로 만든다 instance Collection [a] where insert xs x = x : xs member = flip elem 하지만 이것은 컴파일되지 않는다. 문제는 Collection 연산들의 e 타입 변수가 근본이 없다는 것이다. Collection의 인스턴스의 타입에는 e가 실제로 무엇인지 말해주는 요소가 전혀 없다. 따라서 우리는 이 메서드들의 구현을 절대로 정의할 수 없다. 복수 매개변수 타입 클래스는 e를 클래스의 타입으로 집어넣어 이 문제를 해결한다. 다음 예시는 실제로 컴파일해서 사용할 수 있다. 예: (올바른) Collection 타입 클래스 {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} class Eq e => Collection c e where insert :: c -> e -> c member :: c -> e -> Bool instance Eq a => Collection [a] a where insert = flip (:) member = flip elem 함수형 의존성 위 예제에서 문제가 되는 것은 컴파일러가 모르는 여분의 정보를 우리만 가지고 있다는 것이다. 이는 잘못된 모호함과 과하게 일반화된 함수 시그너처로 이어질 수 있다. 이 경우에는 컬렉션의 타입이 원소들의 타입을 항상 결정함을 직관적으로 알아볼 수 있다. 즉 c가 [a] 면 e는 a다. c가 Hashmap a 면 e는 a다. (역은 참이 아니다. 서로 다른 컬렉션 타입들이 같은 타입의 원소를 담을 수 있기 때문에, 원소 타입이 가령 Int라는 것을 알아도 컬렉션 타입은 알 수 없다) 컴파일러에게 이 정보를 알려주려면 함수형 의존성을 추가하여, 클래스 선언을 다음과 같이 바꾼다. 예: 함수형 의존성 class Eq e => Collection c e | c -> e where ... 함수형 의존성은 타입 클래스 매개변수에 가할 수 있는 제약이다. 여기서 추가된 | c -> e는 'c가 e를 유일한 것으로 확정한다'라고 읽는다. 즉 c가 주어지면 e는 단 하나만 있다는 뜻이다. 한 클래스 안에서 여러 함수형 의존성이 있을 수 있다. 위의 예에서 c -> e, e -> c도 가능하다. 복수 매개변수 클래스에서 매개변수가 두 개보다 많을 수도 있다. 예제 행렬과 벡터 간단한 선형 대수를 수행하기 위해 코드를 작성하려고 한다. 예: Vector와 Matrix 데이터 타입 data Vector = Vector Int Int deriving (Eq, Show) data Matrix = Matrix Vector Vector deriving (Eq, Show) 이것들이 최대한 숫자처럼 행동하게 만들고 싶다. 시작은 하스켈의 Num 클래스를 오버 로딩하는 것이다. 예: Vector와 Matrix의 인스턴스 선언 instance Num Vector where Vector a1 b1 + Vector a2 b2 = Vector (a1+a2) (b1+b2) Vector a1 b1 - Vector a2 b2 = Vector (a1-a2) (b1-b2) {- ... and so on ... -} instance Num Matrix where Matrix a1 b1 + Matrix a2 b2 = Matrix (a1+a2) (b1+b2) Matrix a1 b1 - Matrix a2 b2 = Matrix (a1-a2) (b1-b2) {- ... and so on ... -} 두 값을 곱하려고 할 때 문제가 발생한다. 다른 타입들을 오버로드 하는 곱셈 함수가 필요하다. 예: 우리에게 필요한 것 (*) :: Matrix -> Matrix -> Matrix (*) :: Matrix -> Vector -> Vector (*) :: Matrix -> Int -> Matrix (*) :: Int -> Matrix -> Matrix {- ... and so on ... -} 이것들을 모두 허용하는 타입 클래스를 어떻게 기술할 것인가? 다음과 같이 시도해 볼 수 있다. 예: 비효율적인 시도 (너무 일반화됨) class Mult a b c where (*) :: a -> b -> c instance Mult Matrix Matrix Matrix where {- ... -} instance Mult Matrix Vector Vector where {- ... -} 하지만 우리가 원하던 바가 아니다. 이와 같은 단순한 표현 식도 중간 표현식에 타입 선언을 명시하지 않으면 타입이 모호해진다. 예: 모호함으로 인해 더 지저분해진 코드 m1, m2, m3 :: Matrix (m1 * m2) * m3 -- type error; type of (m1*m2) is ambiguous (m1 * m2) :: Matrix * m3 -- this is ok 누군가 나중에 와서는 또 다른 인스턴스를 추가할지도 모르는 일이다. 예: 엉터리 Mult 인스턴스 instance Mult Matrix Matrix (Maybe Char) where {- whatever -} 문제는 c가 자유 타입 변수일 필요가 없다는 것이다. 곱하는 것들의 타입을 알면 결과 타입을 이 정보만으로 결정할 수 있어야 한다. 함수형 의존성으로 이를 표현할 수 있다. 예: Mult의 올바른 정의 class Mult a b c | a b -> c where (*) :: a -> b -> c c가 a와 b로부터 유일하게 결정된다고 하스켈에게 알린다. 4 팬텀 타입 원문: https://en.wikibooks.org/wiki/Haskell/Phantom_types 팬텀 타입은 하스켈의 타입 시스템보다 강력한 타입 시스템을 가진 언어를 끼워 넣는 방법이다. 팬텀 타입 평범한 타입 data T = TI Int | TS String plus :: T -> T -> T concat :: T -> T -> T 팬텀 타입 버전 data T a = TI Int | TS String 변한 것은 없다. 인자 a를 새로 넣었을 뿐이다. 그런데 마법이 일어났다! plus :: T Int -> T Int -> T Int concat :: T String -> T String -> T String 이제 더 강한 제약을 가할 수 있다. 타입 안전성을 늘리고 싶지만 런타임 오버헤드는 원하지 않을 때 팬텀 타입이 유용하다. -- Peano numbers at the type level. data Zero = Zero data Succ a = Succ a -- Example: 3 can be modeled as the type -- Succ (Succ (Succ Zero))) type D2 = Succ (Succ Zero) type D3 = Succ (Succ (Succ Zero)) data Vector n a = Vector [a] deriving (Eq, Show) vector2d :: Vector D2 Int vector2d = Vector [1,2] vector3d :: Vector D3 Int vector3d = Vector [1,2,3] -- vector2d == vector3d raises a type error -- at compile-time: -- Couldn't match expected type `Zero' -- with actual type `Succ Zero' -- Expected type: Vector D2 Int -- Actual type: Vector D3 Int -- In the second argument of `(==)', namely `vector3d' -- In the expression: vector2d == vector3d -- while vector2d == Vector [1,2,3] works 5 GADT 원문: https://en.wikibooks.org/wiki/Haskell/GADT 서론 GADT의 이해 산술식 언어 확장하기 팬텀 타입 GADT 요약 문법 새로운 가능성들 예제 안전한 리스트 간단한 표현식 평가자 논의사항 팬텀 타입 존재적 타입 서론 일반화된 대수적 자료형(Generalized algebraic datatype; GADT)는 익숙한 대수적 자료형을 일반화한 것이다. GADT는 생성자의 타입을 명시적으로 쓸 수 있게 한다. 이 장에서는 이것이 왜 유용하고, 어떻게 선언하는지 배울 것이다. 시작은 GADT에 대한 훌륭한 기반이 되는, 간단한 산술식을 위한 내장된 도메인 한정 언어(EDSL)를 설계하는 예제다. 그다음 GADT의 문법을 간단히 설명하고, 또 다른 예제로서 head []가 타입 검사를 실패하기 때문에 *** Exception: Prelude.head: empty list 같은 런타임 오류가 발생하지 않는, 안전한 리스트 타입을 구축할 것이다. GADT의 이해 GADT란 무엇이고 어디에 유용한가? GADT는 주로 도메인 한정 언어를 구현하는 데 쓰이므로 이 절에서는 그에 맞는 예제를 소개할 것이다. 산술식 다음과 같은 데이터 타입이 있을 때, 산술식을 위한 조그만 언어를 생각해 보자. data Expr = I Int -- integer constants | Add Expr Expr -- add two expressions | Mul Expr Expr -- multiply two expressions 이 데이터 타입은 추상적인 구문 트리에 대응한다. (5+1)*7 같은 항은 (I 5AddI 1) MulI 7 :: Expr로 표현할 수 있다. 추상 구문 트리가 있으니 무언가 해보자. 컴파일한다거나 최적화한다거나. 초보자를 위해 표현식을 취해 그것이 나타내는 정수를 계산하는 평가 함수를 작성해 보자. 그 정의는 직관적이다. eval :: Expr -> Int eval (I n) = n eval (Add e1 e2) = eval e1 + eval e2 eval (Mul e1 e2) = eval e1 * eval e2 언어 확장하기 이제 이 언어를 정수 이외의 다른 타입들로 확장하는 것을 상상해 보자. 예를 들어 항등 비교를 나타내려면 진위 값이 필요하다. Expr 타입을 조정하자. data Expr = I Int | B Bool -- boolean constants | Add Expr Expr | Mul Expr Expr | Eq Expr Expr -- equality test 5+1 == 7은 (I 5AddI 1) EqI 7로 나타낼 수 있다. 표현식 평가 함수로 돌아가면, 표현식이 이제 정수 또는 진위 값을 나타낼 수 있기 때문에 반환 타입에 그것을 반영해야 한다. eval :: Expr -> Either Int Bool 처음의 두 경우는 직관적이다. eval (I n) = Left n eval (B b) = Right b 이다음이 문제다. eval (Add e1 e2) = eval e1 + eval e2 -- ??? 이것은 타입 검사를 통과하지 못한다. 더하기 함수 +는 두 정수 인자를 기대하지만 eval e1의 타입은 Either Int Bool이기 때문에 Int를 추출해야 한다. 게다가 e1이 진위 값을 나타내기라도 한다면? 다음은 타당한 표현식이다. B True `Add` I 5 :: Expr 하지만 말이 안 된다. 진위 값과 정수를 더할 순 없다. 평가는 정수 또는 진위 값을 반환할 수도 있지만 표현식이 말이 안 되어 실패할 수도 있다. 이것마저 반환 타입에 반영하면 eval :: Expr -> Maybe (Either Int Bool) 이 함수는 잘 작성할 수 있지만 여전히 만족스럽지 못하다. 우리는 하스켈의 타입 시스템이 올바르지 않은 표현식을 알아서 걸러내길 원한다. 추상 구문 트리를 분해하면서까지 우리가 타입을 검사해야 하는가? 연습문제 그럼에도 위의 eval 함수를 구현하는 것은 교육적일 수 있다. 한 번 해보라. 출발점: data Expr = I Int | B Bool -- boolean constants | Add Expr Expr | Mul Expr Expr | Eq Expr Expr -- equality test eval :: Expr -> Maybe (Either Int Bool) -- Your implementation here. 팬텀 타입 소위 팬텀 타입이라는 것이 우리 목표를 향한 첫걸음이다. Expr에 타입 변수 a를 덧붙인다. data Expr a = I Int | B Bool | Add (Expr a) (Expr a) | Mul (Expr a) (Expr a) | Eq (Expr a) (Expr a) 표현식 Expr a는 a 값을 전혀 포함하지 않는다. 그래서 a를 팬텀 타입이라 한다. a는 잉여 변수일 뿐이다. a를 한 무더기 포함하는 리스트 [a] 같은 것과 비교해 보라. 핵심은 a를 이용해 표현식의 타입을 추적하는 것이다. 다음의 생성자를 유저로부터 숨기고 Add :: Expr a -> Expr a -> Expr a 더 제한된 타입의 스마트 생성자를 제공할 것이다. add :: Expr Int -> Expr Int -> Expr Int add = Add 구현은 같지만 타입은 달라졌다. 다른 생성자들에도 같은 작업을 한다. i :: Int -> Expr Int i = I b :: Bool -> Expr Bool b = B 앞서 문제가 되었던 표현식은 b True `add` i 5 더 이상 타입 검사를 실패하지 않는다! 무엇보다 첫 번째 인자의 타입은 Expr Bool인데 add는 Expr Int를 기대한다. 팬텀 타입 a는 의도된 표현식 타입을 나타낸다. 스마트 생성자만 공개하면 사용자는 타입이 올바르지 않은 표현식을 만들 수가 없다. 아직 평가 함수를 구현해야 한다. 새로운 표식 a을 더하여 이런 타입을 기대해 볼 수 있다. eval :: Expr a -> a 그리고 첫 번째 경우를 이렇게 구현한다. eval (I n) = n 아, 애석하지만 안된다. 생성자 I가 a = Int를 뜻한다는 걸 컴파일러는 알 수가 없다. 물론 우리 언어를 쓰는 사람들이 만든 표현식에는 스마트 생성자만 쓰였다. 하지만 내부적으로 이런 표현식은 I 5 :: Expr String 역시 타당하다. a는 Int나 Bool 일 필요가 없다. 무엇이든 될 수 있다. 우리에겐 생성자의 반환 타입을 제한할 수단이 필요하다. 일반화된 자료형이 바로 그런 일을 한다. GADT 생성자의 타입을 제한하는 명백한 표기법은 그 타입을 작성하는 것이다. GADT가 그렇게 정의된다. data Expr a where I :: Int -> Expr Int B :: Bool -> Expr Bool Add :: Expr Int -> Expr Int -> Expr Int Mul :: Expr Int -> Expr Int -> Expr Int Eq :: Expr Int -> Expr Int -> Expr Bool 즉 모든 생성자의 타입 시그너처를 단순히 나열한다. 특히 스마트 생성자에서 한 것처럼, 마커 타입 a가 필요에 따라 Int나 Bool로 특화된다. 그리고 GADT의 굉장한 점은 이제 타입 마커를 활용해 평가 함수를 구현할 수 있다는 것이다. eval :: Expr a -> a eval (I n) = n eval (B b) = b eval (Add e1 e2) = eval e1 + eval e2 eval (Mul e1 e2) = eval e1 * eval e2 eval (Eq e1 e2) = eval e1 == eval e2 특히 첫 번째 경우에 eval (I n) = n 생성자 I를 만나면 컴파일러는 이제 a = Int이고 n :: Int를 반환하는 것이 타당하다고 추론할 수 있다. 다른 경우들도 비슷하다. 요약하면 GADT는 생성자의 반환 타입을 제한하고 따라서 하스켈의 타입 시스템을 도메인 한정 언어에 활용할 수 있게 해준다. 따라서 더 풍부한 언어를 구현하면서 그 구현은 더 간단해진다. 요약 문법 다음은 GADT 선언에 관한 문법을 짧게 요약한 것이다. 먼저 평범한 대수적 자료형들을 보자. List, Maybe는 익숙하고, 간단한 트리 타입인 RoseTree이 있다. Maybe List RoseTree data Maybe a = Nothing | Just a data List a = Nil | Cons a (List a) data RoseTree a = RoseTree a [RoseTree a] 위의 선언에서 생성자들은 패턴 매칭을 통해 값을 분해하는 데 쓸 수도 있고, 값을 생성하기 위해 함수로써 사용할 수도 있음을 기억할 것. (Nothing과 Nil은 "인자가 없는" 함수다) 후자의 경우, 그 타입을 질의할 수 있다. Maybe List RoseTree > :t Nothing Nothing :: Maybe a > :t Just Just :: a -> Maybe a > :t Nil Nil :: List a > :t Cons Cons :: a -> List a -> List a > :t RoseTree RoseTree :: a -> [RoseTree a] -> RoseTree a Maybe, List, RoseTree의 생성자에 관한 각각의 타입 정보는 우리가 데이터 타입을 선언할 때 컴파일러에 제공한 정보와 동등하다. 그러면 단순히 모든 생성자의 타입을 열거하여 데이터 타입을 선언하는 것을 생각해 볼 법 하다. 이것이 바로 GADT 구문이 하는 일이다. Maybe List RoseTree data Maybe a where Nothing :: Maybe a Just :: a -> Maybe a data List a where Nil :: List a Cons :: a -> List a -> List a data RoseTree a where RoseTree :: a -> [RoseTree a] -> RoseTree a 이 문법은 언어 옵션 {-#LANGUAGE GADTs #-}으로 활성화한다. 타입 선언 문법과 상당히 닮아있기 때문에 친숙할 것이다. 이미 생성자를 함수로 생각하길 좋아한다면 기억하기도 쉬울 것이다. 각 생성자가 타입 시그너쳐에 의해 정의될 뿐이다. 새로운 가능성들 GHCi에 Nothing과 Just의 타입을 질의했을 때 Maybe a와 a -> Maybe a를 돌려주었던 것에 주목하자. 이 경우 그 생성자와 연관된 함수의 최종 출력 타입은 우리가 애초에 정의했던 그 타입, Maybe a, List a, 또는 RoseTree a이다. 일반화하면 표준 하스켈에서 Foo a의 생성자 함수의 최종 반환 타입은 Foo a이다. 새 구문이 기존 구문과 엄밀히 동등하다면, 올바른 타입 선언을 위해 그 사용에 제한을 두어야 한다. 그래서 GADT가 주는 이점은 무엇인가? 정확히 어떤 종류의 Foo를 반환할지를 제어하는 능력이다. GADT를 통하면 Foo a의 생성자가 반드시 Foo a를 반환할 의무가 없다. 생성자는 임의의 Foo blah를 반환할 수 있다. 예를 들어 아래의 코드에서 GadtedFoo 생성자는 GatedFoo x 타입에 대한 생성자임에도 GadtedFoo Int을 반환한다. 예제: GADT는 더 많은 제어권을 준다 data FooInGadtClothing a where MkFooInGadtClothing :: a -> FooInGadtClothing a --which is no different from: data Haskell98Foo a = MkHaskell98Foo a , --by contrast, consider: data TrueGadtFoo a where MkTrueGadtFoo :: a -> TrueGadtFoo Int --This has no Haskell 98 equivalent. 하지만 일반화는 여기까지다. 여러분이 선언하는 데이터 타입이 Foo라면 생성자 함수는 반드시 어떤 Foo를 반환해야 한다. 다른 타입을 반환할 수는 없다. 예제: 시도해 보라. 안된다 data Bar where BarNone :: Bar -- 된다 data Foo where MkFoo :: Bar Int -- 타입 검사를 실패한다 예제 안전한 리스트 선행지식: 이 절에서는 여러분이 함수형 언어에서 List가 어떻게 표현되는지 안다고 가정한다 노트: 이 절의 예제들은 EmptyDataDecls와 KindSignatures 확장을 추가로 활성화해야 한다 GADT 문법이 주는 추가적인 제어권을 살짝 맛봤다. 유일하게 새로웠던 점은 어떤 자료구조를 반환할지를 제어할 수 있다는 것이다. 이걸 어디 활용할 수 있을까? 평범한 하스 켈 리스트를 생각해 보자. head []를 실행하면 무슨 일이 일어나는가? 하스켈이 폭발한다. 원소가 적어도 하나는 있는 리스트만 받아들이는, 절대 터지지 않는 마법의 head를 바란 적이 있는가? 시작하기에 앞서 새로운 타입인 SafeList x y를 정의하자. 평범한 하스 켈 리스트 [x]와 비슷하지만 타입에 약간의 추가 정보를 가미했다. 이 추가 정보(타입 변수 y)는 리스트가 비어있는지를 나타낸다. 빈 리스트는 SafeList x Empty로, 비어있지 않은 리스트는 SafeList x NotEmpty로 표현된다. -- we have to define these types data Empty data NonEmpty -- the idea is that you can have either -- SafeList a Empty -- or SafeList a NonEmpty data SafeList a b where -- to be implemented 이 여분의 정보 덕에 비어있지 않은 리스트에 대해서만 safeHead를 정의할 수 있다! 빈 리스트에 대해 safeHead를 호출하면 타입 검사가 실패한다. safeHead :: SafeList a NonEmpty -> a 이제 safeHead를 어떻게 구현할 것인가? GADT가 답이다. 핵심은 GADT 특성을 활용해 Nil 생성자에 대해서는 SafeList a Empty, Cons 생성자에 대해서는 SafeList a NonEmpty 이렇게 두 종류의 리스트를 반환하는 것이다. data SafeList a b where Nil :: SafeList a Empty Cons :: a -> SafeList a b -> SafeList a NonEmpty 이는 GADT가 아니면 불가능하다. GADT 없이는 모든 생성자가 같은 타입의 리스트를 반환해야 하기 때문이다. 이제 서로 다른 생성자를 가지고 서로 다른 타입의 리스트를 반환할 수 있다. 어쨌든 SafeHead의 실제 정의까지 전부 모아보자. 예제: GADT를 이용한 안전한 리스트 {-#LANGUAGE GADTs, EmptyDataDecls #-} -- (the EmptyDataDecls pragma must also appear at the very top of the module, -- in order to allow the Empty and NonEmpty datatype declarations.) data Empty data NonEmpty data SafeList a b where Nil :: SafeList a Empty Cons:: a -> SafeList a b -> SafeList a NonEmpty safeHead :: SafeList a NonEmpty -> a safeHead (Cons x _) = x 이 코드를 파일로 복사해 ghci -fglasgow-exts로 로드하라. safeHead를 비어있지 않은 리스트와 빈 리스트에 대해 호출할 때의 차이점에 주목할 것. 예시: safeHead는... 안전하다 Prelude Main> safeHead (Cons "hi" Nil) "hi" Prelude Main> safeHead Nil <interactive>:1:9: Couldn't match `NonEmpty' against `Empty' Expected type: SafeList a NonEmpty Inferred type: SafeList a Empty In the first argument of `safeHead', namely `Nil' In the definition of `it': it = safeHead Nil 이런 불평은 좋은 것이다. 이제 컴파일할 때 safeHead를 알맞은 리스트에 대해 호출한다는 것을 확인할 수 있다. 그런데 여기에는 위험도 잠재해 있다. 다음 함수는 무슨 타입일까? 예제: Trouble with GADTs silly False = Nil silly True = Cons () Nil 이 예제를 GHCi에서 불러오려 하면 다음 오류가 발생한다. Example: Trouble with GADTs - the complaint Couldn't match `Empty' against `NonEmpty' Expected type: SafeList () Empty Inferred type: SafeList () NonEmpty In the application `Cons () Nil' In the definition of `silly': silly True = Cons () Nil silly 정의의 두 분기에서 리스트들의 타입이 달라서 타입 오류가 발생한다. GADT에 의한 부가적인 제약 때문에 한 함수가 빈 리스트와 비어있지 않은 리스트 둘 다 생성하는 것이 불가능하다. 정말로 silly를 정의하고 싶다면 Cons의 타입을 완화하여 안전한 리스트와 안전하지 않은 리스트 둘 다 구축할 수 있도록 해야 한다. 예제: 다른 접근법 {-#LANGUAGE GADTs, EmptyDataDecls, KindSignatures #-} -- here we add the KindSignatures pragma, -- which makes the GADT declaration a bit more elegant. -- Note the subtle yet revealing change in the phantom type names. data NotSafe data Safe data MarkedList :: * -> * -> * where Nil :: MarkedList t NotSafe Cons :: a -> MarkedList a b -> MarkedList a c safeHead :: MarkedList a Safe -> a safeHead (Cons x _) = x -- This function will never produce anything that can be consumed by safeHead, -- no matter that the resulting list is not necessarily empty. silly :: Bool -> MarkedList () NotSafe silly False = Nil silly True = Cons () Nil 여기에는 대가가 따른다. Cons에 대한 제약을 완화한 결과 우리는 Cons가 빈 리스트를 생산할 수 없다는 정보를 버려버렸다. 안전 리스트의 첫판에 기반하여, SafeList a Empty 인자를 취하는 함수를 정의하고 Cons가 생산하는 무엇이던 받아들이지 않도록 할 수도 있었다. MarkedList a NotSafe에는 이것이 성립하지 않는다. 틀림없이, 이 타입은 덜 제한적이기 때문에 덜 유용하다. 이 예제에서는 빈 리스트로 할 만한 것이 없기 때문에 사소한 문제로 보이지만 일반적으로는 심사숙고할 가치가 있다. 연습문제 safeTail 함수를 구현할 수 있겠는가? 여기서 소개한 두 버전이나 다른 변형들도 좋은 시작점이다. 간단한 표현식 평가자 Insert the example used in Wobbly Types paper... I thought that was quite pedagogical This is already covered in the first part of the tutorial. * 논의사항 팬텀 타입 팬텀 타입을 볼 것. 존재적 타입 존재 한정 타입(Existentially quantified types)을 좋아하는가? 이것이 GADT에 포함되는 개념임에 주목할 것. GHC 매뉴얼이 말하듯이 다음의 두 타입 선언은 같다. data TE a = forall b. MkTE b (b->a) data TG a where { MkTG :: b -> (b->a) -> TG a } GADT를 이용한 혼종 리스트는 이런 식이다. data TE2 = forall b. Show b => MkTE2 [b] data TG2 where MkTG2 :: Show b => [b] -> TG2 6 타입 생성자 & 종(kind) 원문: https://en.wikibooks.org/wiki/Haskell/Kinds C++ 사용자를 위한 종(kind) *는 함수를 포함하여 임의의 구체적인 타입이다. 다음은 모두 * 종(kind)을 가진다. type MyType = Int type MyFuncType = Int -> Int myFunc :: Int -> Int typedef int MyType; typedef int (*MyFuncType)(int); int MyFunc(int a); * -> *는 타입 인자를 한 개 취하는 템플릿이다. 타입에서 타입으로 가는 함수와 비슷하다. 어떤 타입을 하나 넣으면 그 결과는 어떤 타입이다. 다음의 MyData의 두 용법은 혼란스러울 수 있다. (둘의 이름을 다르게 할 수도 있지만) 첫 번째는 타입 생성자, 두 번째는 데이터 생성자다. 각각 C++의 클래스 템플릿과 생성자에 대응한다. 문맥이 모호함을 해결한다. 하스켈이 타입을 기대하는 곳(예: 타입 시그너처)에서 MyData는 타입 생성자다. 값을 기대하는 곳에서 MyData는 데이터 생성자다. data MyData t -- type constructor with kind * -> * = MyData t -- data constructor with type a -> MyData a *Main> :k MyData MyData :: * -> * *Main> :t MyData MyData :: a -> MyData a template <typename t> class MyData { t member; }; * -> * -> *는 타입 인자 두 개를 취하는 템플릿이다. data MyData t1 t2 = MyData t1 t2 template <typename t1, typename t2> class MyData { t1 member1; t2 member2; MyData(t1 m1, t2 m2) : member1(m1), member2(m2) { } }; (* -> *) -> *는 (* -> *) 종의 템플릿 인자 하나를 취하는 템플릿이다. data MyData tmpl = MyData (tmpl Int) template <template <typename t> class tmpl> class MyData { tmpl<int> member1; MyData(tmpl<int> m) : member1(m) { } }; 3여러 이론들 여러 이론들 표기 의미론(Denotational semantics) Equational reasoning 원문 없음 Program derivation 원문 없음 범주론 Curry-Howard 동형 fix와 재귀 1 표기 의미론 (검토 중) 원문: https://en.wikibooks.org/wiki/Haskell/Denotational_semantics 원문에서 Interpretation as Powersets 섹션의 내용이 올바른지에 대한 논쟁이 있습니다. 서문 표기 의미론은 무엇이고 어디에 쓰이는가? 의미 역으로 무엇을 선택할 것인가? 바텀과 부분 함수 ⊥ 바텀 부분 함수와 의미론적 근사 순서 Partial Functions and the Semantic Approximation Order 단조성(Monotonicity) 고정점 반복으로서의 재귀 정의 (Recursive Definitions as Fixed Point Iterations) 계승(factorial) 함수의 근사 수렴성 바텀은 비종결을 내포한다 Bottom includes Non-Termination 최소 고정점으로서의 해석 엄격 의미론과 비 엄격 의미론 엄격한 함수 비 엄격 및 엄격한 언어 다인자 함수 대수적 자료형 생성자 패턴 매칭 재귀적 자료형과 무한 리스트 하스 켈 한정: strictness annotation과 newtype 다른 주제들 abstract interpretation과 엄격함 분석 멱집합으로서의 해석 naive set은 재귀적 자료형에 적합하지 않다 외부 링크 서문 이 장에서는 하스 켈 프로그램의 의미를 공식화(formalize) 하는 방법인 표기 의미론(denotational semantics)을 설명한다. "프로그램 square x = x*x의 의미는 어떤 수를 그 제곱으로 사상하는 수학의 제곱 함수와 같은 뜻이다"라는 공식적 기술은 트집 잡기처럼 보일 수도 있다. 하지만 영원히 반복되는 f x = f (x+1) 같은 프로그램의 의미는 어떨까? 앞으로 이 질문에 대해 Scott과 Strachey가 처음 취한 접근법을 예로 들고, 일반적인, 특히 재귀 정의된 함수형 프로그램의 올바름을 추론하는 기반을 닦을 것이다. 물론 하스 켈 프로그램을 이해하는 데 필요한 주제들에 집중할 것이다. 1 이 장의 또 다른 목표는 엄밀함(strict)과 지연(lazy) 즉 함수가 자신의 인자들을 평가해야 하는지에 대한 개념을 설명하는 것이다. 이것은 하스 켈 프로그램의 평가 순서를 예측하기 위한 기본이므로 프로그래머의 주된 관심사다. 흥미롭게도 이 개념들은 표기 의미론만으로 간결하게 공식화할 수 있고 실행 모델은 고려할 필요가 없다. 이것들은 그래프 소거에서 유용하게 쓰일 것이지만, 어쨌든 이 장의 목적은 독자가 표기적 정의와 ⊥(바텀) 같은 개념에 익숙해지도록 하는 것이다. 엄밀함에만 관심 있는 독자는 Bottom and Partial Functions 절을 훑어보고 Strict and Non-Strict Semantics로 빠르게 넘어가도 좋다. 표기 의미론은 무엇이고 어디에 쓰이는가? 하스 켈 프로그램은 무엇을 의미하는가? 이 질문에는 하스켈의 표기 의미론으로 답할 수 있다. 일반적으로 한 프로그래밍 언어의 표기 의미론은 각 프로그램을 수학적 개체(표기)로 사상한다. 이 수학적 개체는 그 프로그램의 의미를 나타낸다. 예를 들어 하스 켈 프로그램 10, 9+1, 2*5, sum [1.. 4]는 정수 10으로 표현할 수 있다. 이 프로그램들은 모두 정수 10을 나타낸다고 말할 수 있다. 이런 수학적 개체들의 모음을 의미 역(semantic domain)이라 부른다. 프로그램 코드에서 의미 역으로 가는 사상은 보통 프로그램 코드를 쌍곽괄호("옥스포드 괄호")로 감싸서 표현한다. 예를 들면 이런 것이다. [ [ ∗ = 10 ] ] 표기는 구성적(compositional)이다. 즉 1+9 같은 프로그램의 의미는 구성 성분들의 의미에만 의존한다. [ [ + ] ] [ [ ] ] [ [ ] ] 타입에도 같은 표기를 사용한다. [ [ n e e ] ] Z 하지만 간단함을 위해 앞으로는 표현식을 의미론 개체와 암묵적으로 동일시하고, 이런 표기는 명확함이 필요할 때만 사용하겠다. 하스 켈 같은 순수 함수형 언어의 핵심은 "1+9는 10을 의미한다" 같은 수학적 해석이 함수에 그대로 적용된다는 것이다. Integer -> Integer 타입인 프로그램의 본질적 의미는 정수 간의 수학적 함수 ( → )이다. 나중에 보겠지만 이 표현식은 비종결(non-termination)을 포함하도록 정제해야 한다. 어쨌든 명령형 언어는 상황이 더 나쁘다. 이 타입을 가진 프러시저는 기계의 상태를 의도하지 않은 방식으로 변경할 수 있는 무언가를 의미한다. 명령형 언어는 기계의 실행 방식을 서술하는 명령 의미론(operational semantics)과 긴밀히 연관된다. 명령형 프로그램의 표기 의미론을 정의하고 그런 프로그램에 대해 추론하는 것이 가능하지만 그 의미는 명령형(operational) 성질을 띄기 마련이고 그러면 함수형 언어의 표기 의미론에 비해 확장을 해야 한다.2 반면 순수 함수형 언어의 의미는 기본으로 실행 방식과 완전히 무관하다. Haskell98 표준은 하스켈의 엄밀하지 않은 표기 의미론만을 명시하여, 어떻게 구현할지는 자유로 남겨두었다. 결론은, 표기 의미론은 우리가 수학적으로 원하는 대로 프로그램이 작동한다는 것을<NAME>적으로 증명할 수 있게 한다는 것이다. 아이러니하게도 하스켈에서 어떤 프로그램 성질을 증명하기 위해 등식 추론(equational reasoning)을 활용할 수 있는데, 이 방법은 프로그램을 동등한 다른 프로그램으로 변환하며 기저의 수학적 개체들은 거의 들여다보지 않는다. 하지만 표기 의미론은 무한 리스트 같은 비종결 프로그램에 대해 추론해야 할 때마다 등장한다. 물론 표기 의미론은 프로그램이 무엇인지만 서술하기 때문에 프로그램이 얼마나 오래 걸리는지 또는 메모리를 얼마나 먹는지는 답하지 못한다. 이것은 컴퓨터가 표현식의<NAME>을 어떻게 계산할지를 지시하는 평가 전략(evaluation strategy)에 의해 좌우된다. 반면 그 구현은 의미론을 반영해야 하고, 의미론은 하스 켈 프로그램이 기계 상에서 어떻게 평가되어야 하는지를 어느 정도 결정한다. 이에 대해서는 Strict and Non-Strict Semantics에서 자세히 다룰 것이다. 의미 역으로 무엇을 선택할 것인가? 이제 모든 하스 켈 프로그램에 부여할 수 있는 적합한 수학적 개체를 찾아보자. 10, 2*5, sum [1.. 4]의 경우 이들 표현식은 모두 정수 10을 의미한다. 일반화하면 Integer 타입의 모든 값 x는 집합 ( )의 원소를 의미한다. Bool 타입의 값도 비슷하다. f :: Integer -> Integer 같은 함수에 대해 "함수"의 수학적 정의를 (인자, 값) 짝들의 집합 즉 그래프로 볼 수 있다. 하지만 함수를 그 함수의 그래프로 해석하는 것은 너무 성급하다. 재귀적 정의에 잘 맞지 않기 때문이다. 다음의 정의를 보자. shaves :: Integer -> Integer -> Bool 1 `shaves` 1 = True 2 `shaves` 2 = False 0 `shaves` x = not (x `shaves` x) _ `shaves` _ = False 0, 1, 2를 긴 수염이 난 남성으로 간주하고 누가 누구를 면도할까 질문해 보자. 사람 1은 스스로를 면도하고, 세 번째 식 0 `shaves` 2 == True 때문에 사람 2는 이발사 0이 면도해 준다. 일반화하면 세 번째 줄의 뜻은 스스로 면도하지 않는 사람들은 이발사 0이 면도해 준다는 것이다. 그러면 이발사 0은? 0 `shaves` 0이 참일까 거짓일까? 참이라면 세 번째 등식은 그것이 거짓이라 말한다. 거짓이라면 이 등식은 그것이 참이라 말한다. 우리는 0 `shaves` 0에 단순히 True나 Fales를 부여할 수 없다. 이 함수에 대한 해석으로 사용할 그래프는 빈 부분을 가져야 한다. 우리의 의미론 개체는 부분 함수, 즉 특정 인자에 대해 정의되지 않는 함수를 포용해야 한다. 이 유명한 예시는 집합 이론의 근본을 건드리는 심각한 문제로 떠올랐다. 이는 비단 정적(impredicative) 정의의 한 예시다. 비단 정적 정의는 그 자신을 사용하여 순환 논리를 만들어낸다. 하지만 재귀적 정의에서는 이런 순환이 무슨 문제가 되는 것이 아니고 하나의 특성일 뿐이다. 바텀과 부분 함수 ⊥ 바텀 부분 함수를 정의하기 위해 특별한 값 ⊥를 도입하겠다. 이것의 이름은 바텀(bottom)이고 타자할 때는 대개 _|_로 쓴다. ⊥는 아예 "정의되지 않은" 값 또는 함수다. Integer나 () 같은 모든 기본적인 자료형은 ⊥를 일반적인 원소로서 포함한다. 따라서 Integer 타입으로 가능한 값은 다음과 같다. , , 1 − , 2 − , 3 − , 값들의 집합에 ⊥를 추가하는 것을 lifting이라고도 부른다. ⊥ 처럼 아래 첨자로 표기하기도 한다. 이것이 수학적 집합 "lifted integers"의 올바른 표기지만, 우리는 "Integer 타입의 값들"에 대해 말하는 것을 선호한다. ⊥ 는 "진짜" 정수들을 의미하지만 하스켈에서 "정수들"은 Integer이기 때문이다. 다른 예시로 원소가 오직 하나인 () 타입은 사실 원소가 두 개다. , ( ) 당장은 Integer를 이용한 프로그래밍을 고수하겠다. 임의의 대수적 자료형은 Algebraic Data Types 절에서 다룬다. ⊥를 어떻게 포함하느냐에 대해 엄밀한 언어와 엄밀하지 않은 언어의 방식이 갈리기 때문이다. 하스켈에서 표현식 undefined은 ⊥를 의미한다. undefined 덕에 실제 하스 켈 프로그램의 의미론적 성질을 검증할 수 있다. undefined의 다형 타입은 forall a. a로서 undefined :: Integer, undefined :: (), undefined :: Integer -> Integer 등으로 특화할 수 있다. 하스 켈 Prelude에 undefined는 이렇게 정의되어 있다. undefined = error "Prelude.undefined" 첨언하자면 Curry-Howard 동형에 따라 다형 타입 forall a. a의 모든 값은 반드시 ⊥를 표기(denote) 해야 한다. 부분 함수와 의미론적 근사 순서 Partial Functions and the Semantic Approximation Order 이제 ⊥(바텀 타입)을 이용해 부분 함수를 표기할 수 있다. ( ) { if is − if is ⊥ else 여기서 f(n)은 n=0과 n=1에 대해서는 잘 정의된 값을 제공하지만 다른 모든 n에 대해서는 ⊥을 내뱉는다. ⊥ 타입은 보편적(universal)인데, ⊥ 타입의 값은 없기 때문이다. 함수 ⊥ :: Integer -> Integer는 다음과 같이 주어진다. ⊥(n) = ⊥ for all n 우변의 ⊥는 Integer 타입의 값을 의미한다. 공식화하면, 부분 함수, 가령 Integer -> Integer 타입의 함수는 lifted integers ⊥ { , , 1 ±, 3 … } 에서 lifted integers로 가는 사상이다. 하지만 이걸로는 충분하지 않다. ⊥의 특별한 역할을 반영하지 않기 때문이다. 예를 들어 다음의 정의는 ( ) { if is ⊥ else 직관적이지 않고 실제로도 틀렸다. 왜 g(⊥)는 정의된 값을 돌려주는데 g(1)은 정의되지 않는가? 모든 부분 함수 g는 더 잘 정의된 인자에 대해 더 잘 정의된 답을 돌려줘야 한다. 공식화하면 모든 구체적인 수는 ⊥보다 더 잘 정의되었다고 할 수 있다. ⊏, ⊥ 2 , 여기서 ⊏는 b가 a보다 더 잘 정의되었다는 뜻이다. 비슷하게 ⊑는 b가 a보다 더 잘 정의되었거나 정의된 정도(definedness)가 같다는 뜻이다.를 semantic approximation order라고도 부르는데 정의된 값을 덜 정의된 값으로 근사하여 "더 잘 정의됨"을 "더 잘 근사 됨"으로 해석할 수 있기 때문이다. 물론 ⊥는 자료형의 최소 원소가 되도록 설계되었기 때문에 모든 x에 대해 ⊏ 이 성립한다. (x가 ⊥ 자체인 경우는 제외) x ⊥ ⊏ 어떤 수도 다른 수보다 더 잘 정의되지 않았기 때문에 수학적 관계 은 임의의 두 수에 대해 성립하지 않는다. ⊏는 성립하지 않는다. ⊏ 와 ⊏ 모두 성립하지 않는다. 이는 임의의 두 수를 비교할 수 있는 일반적인 순서 술어식 와 대조된다. 이것을 기억하는 방법은 이렇다. "1과 2는 담고 있는 정보의 내용은 다르지만 정보의 질은 같다." 또 다른 기호를 쓰는 이유기도 하다. ⊑ 와 ⊑ 모두 성립하지 않는다. ⊑는 성립한다.를 부분 순서, Integer 타입의 값들을 부분 순서 집합(partially ordered set ; poset)이라고도 한다. 부분 순서는 세 법칙을 만족한다. Reflexivity. 모든 것은 자신과 같은 정도로 정의된다. ⊑ f r l x Transitivity. ⊑이고 ⊑ 이면 ⊑이다. Antisymmetry. ⊑이고 ⊑ 이면 x = y 이어야 한다. 연습문제 정수들은 순서에 대해 poset을 형성하는가? Integer 타입의 값들에 대한 순서를 다음 그래프로 묘사할 수 있다. 두 노드 간 연결은 위의 것이 아래의 것보다 더 잘 정의되었음을 뜻한다. ⊥를 제외하면 레벨이 하나뿐이므로 Integer는 평역(flat domain)이라고 말할 수 있다. 위 그림은 ⊥의 이름도 설명한다. ⊥를 바텀이라고 하는 이유는 항상 맨 밑에 있기 때문이다. 단조성(Monotonicity) 부분 함수에 대한 우리의 직관을 이제 다음과 같이 공식화할 수 있다. 모든 부분 함수 f는 부분 순서 집합 간의 단조 사상이다. 더 잘 정의된 인자는 더 잘 정의된 값을 내놓는다. ⊑ ⇒ ( ) f ( ) 특히 h(⊥) = 1을 만족하는 함수 h는 상수다. 모든 n에 대해 h(n) = 1이다. 여기서 ⊑ 같은 것이 성립하지 않는 것에 주의할 것. 하스켈식으로 말하자면 단조성의 의미는 ⊥를 조건으로 사용할 수 없다는 것이다. 우리는 ⊥ 즉 undefined에 대해 패턴 매칭할 수 없다. 만약 가능했다면 위의 g를 하스 켈 프로그램으로 표현할 수 있었을 것이다. 후에 보겠지만 ⊥은 비종결 프로그램도 의미하며, 하스켈에서 ⊥를 관찰할 수 없는 것은 종료 문제(halting problem)와 연관된다. 더 잘 정의됨이라는 개념을 부분 함수로 확장하여, 모든 가능한 인자에 대해 다음을 만족할 경우 한 함수가 다른 함수보다 더 잘 정의되었다고 말할 수 있다. ⊑ if x f ( ) g ( ) 이에 따라 부분 함수들은 undefined 함수 ⊥(x) = ⊥를 최소 원소로 하는 poset을 형성한다. 고정점 반복으로서의 재귀 정의 (Recursive Definitions as Fixed Point Iterations) 계승(factorial) 함수의 근사 부분 함수를 서술할 수단이 생겼으니 이제 재귀 정의를 해석할 수 있다. 유명한 예시인 계승 함수 f(n) = n!를 살펴보자. 계승의 재귀 정의는 다음과 같다. ( ) if == then else ⋅ ( − ) 이 재귀 정의를 그대로 집합 형태로 해석하면 문제가 생길 수 있다는 것을 봤지만, 우리는 f(n)을 계산하려면 우변을 반복적으로 계산해야 함을 직관적으로 안다. 이 반복은 다음과 같이 공식화할 수 있다. 일련의 함수 k 들을 계산하는데, 각 k 는 우변을 이전의 k 에 적용한 것이다. 즉 1 ( ) { if is ⊥ else , f ( ) { if is 1 if is ⊥ else , f ( ) { if is 1 if is 2 if is ⊥ else 다음은 확실하다. = 0 f ⊑ 2 … 따라서 이 수열이 계승 함수로 수렴한다고 기대할 수 있다. 위의 반복은 고정점 반복(fixed point iteration)이라는 잘 알려진 체계를 따른다. 0 g ( 0 ) g ( ( 0 ) ) g ( ( ( 0 ) ) ) … 위의 경우 0 은 함수고 g는 functional, 즉 함수 간의 사상이다. 0 ⊥ and ( ) n if == then else ∗ ( − ) 0 ⊥ 에서 시작하면 이 반복은 계승 함수에 대해 점차 잘 정의되는 근사를 돌려준다. ⊑ ( ) g ( ( ) ) g ( ( ( ) ) ) … (이 수열이 증가한다는 것에 대한 증명: 첫 번째 부등식 ⊑ ( ) ⊥ 이 다른 모든 것보다 덜 정의되었음에서 기인한다. 두 번째 부등식은 첫 부등식의 양변에 단조인 g를 적용해서 얻는다. 이후의 부등식들도 같은 방식으로 얻는다.) 이 반복 체계를 하스 켈로 표현해 보자. functional은 평범한 고차 함수다. g :: (Integer -> Integer) -> (Integer -> Integer) g x = \n -> if n == 0 then 1 else n * x (n-1) x0 :: Integer -> Integer x0 = undefined (f0:f1:f2:f3:f4:fs) = iterate g x0 이제 f0, f1, ... 을 평가하여 undefined를 반환하는지 아닌지 볼 수 있다. > f3 0 1 > f3 1 1 > f3 2 2 > f3 5 *** Exception: Prelude.undefined > map f3 [0..] [1,1,2, *** Exception: Prelude.undefined > map f4 [0..] [1,1,2,6, *** Exception: Prelude.undefined > map f1 [0..] [1, *** Exception: Prelude.undefined 물론 정말 f4가 모든 인자에 대해 정의되지 않는지 이런 식으로는 확인할 수는 없다. 수렴성 수학자에게는 이 일련의 근사가 수렴하는지를 대답하는 문제가 아직 남아있다. 이와 관련해 poset이 directed complete partial order (dcpo) 일 필요충분조건은 체인이라고도 불리는, 모든 단조수열 0 x ⊑ 이 최소 상계(supremum)를 가지는 것이다. To the mathematician, the question whether this sequence of approximations converges is still to be answered. For that, we say that a poset is a directed complete partial order (dcpo) iff every monotone sequence {\displaystyle x_{0}\sqsubseteq x_{1}\sqsubseteq \dots } x_{0}\sqsubseteq x_{1}\sqsubseteq \dots (also called chain) has a least upper bound (supremum) $ \sup {{\sqsubseteq }}{x{0}\sqsubseteq x_{1}\sqsubseteq \dots }=x. $ 의미론 근사 순서(semantic approximation order)의 경우 계승 함수를 근사하는 함수들의 단조수열은 유계를 가진다고 확신할 수 있다. 우리의 표기 의미론에서(이 글에서)는 최소 원소 ⊥를 포함하는 dcpo만을 볼 것이다. 이런 것들을 complete partial order(cpo)라고 한다. If that's the case for the semantic approximation order, we clearly can be sure that monotone sequence of functions approximating the factorial function indeed has a limit. For our denotational semantics, we will only meet dcpos which have a least element {\displaystyle \bot } \bot which are called complete partial orders (cpo). Integer들은 확실히 (d) cpo를 형성하는데, 원소가 적어도 하나인 단조수열은 다음을 형성하기 때문이다. The Integers clearly form a (d) cpo, because the monotone sequences consisting of more than one element must be of the form ⊑ ⊑ ⊥ n n ⋯ n 여기서 n은 일반적인 숫자다. 즉 n 자체가 이미 최소 상계다. where {\displaystyle n} n is an ordinary number. Thus, {\displaystyle n} n is already the least upper bound. Integer -> Integer 함수들의 경우 이 주장은 거짓인데 단조수열이 무한히 길 수 있기 때문이다. 하지만 Integer가 (d) cpo이기 때문에 우리는 모든 점 n에 대해 최소 상계가 있다는 것을 안다. For functions Integer -> Integer, this argument fails because monotone sequences may be of infinite length. But because Integer is a (d) cpo, we know that for every point {\displaystyle n} n, there is a least upper bound $ \sup {{\sqsubseteq }}{\bot =f{0}(n)\sqsubseteq f_{1}(n)\sqsubseteq f_{2}(n)\sqsubseteq \dots }=:f(n) $ 의미 근사 순서가 점별로 정의되기 때문에 함수 f는 우리가 찾던 supremum이다. As the semantic approximation order is defined point-wise, the function {\displaystyle f} f is the supremum we looked for. 지금까지가 계승 함수의 비단 정적 정의를 더 잘 정의하기 위한 여정이었다. 여전히 f(n)이 실제로 모든 n에 대해 잘 정의된 값을 돌려줌을 보여줘야 하지만 이는 어렵지 않고 그 형태가 글러먹은 정의보다는 낫다. These have been the last touches for our aim to transform the impredicative definition of the factorial function into a well defined construction. Of course, it remains to be shown that {\displaystyle f(n)} f(n) actually yields a defined value for every {\displaystyle n} n, but this is not hard and far more reasonable than a completely ill-formed definition. 바텀은 비종결을 내포한다 Bottom includes Non-Termination 재귀적 정의에 관해 새롭게 얻은 통찰을 비종결 예시에 적용해 보자. It is instructive to try our newly gained insight into recursive definitions on an example that does not terminate: ( ) f ( + ) 근사 수열은 다음과 같이 The approximating sequence reads 0 ⊥ f = , ⊥로만 이뤄진다. 그 극값의 결과는 분명히 ⊥이다. 연산의 관점에서 이 프로그램을 실행하는 기계는 기약 없이 반복될 것이다. 따라서 우리는 ⊥가 비종결 함수나 값을 의미한다고 본다. 그러므로 이 종료 문제에 대해, 하스켈에선 ⊥에 대한 패턴 매칭이 불가능하다. and consists only of {\displaystyle \bot } \bot . Clearly, the resulting limit is {\displaystyle \bot } \bot again. From an operational point of view, a machine executing this program will loop indefinitely. We thus see that {\displaystyle \bot } \bot may also denote a non-terminating function or value. Hence, given the halting problem, pattern matching on {\displaystyle \bot } \bot in Haskell is impossible. 최소 고정점으로서의 해석 앞에서 근사 수열을 널리 알려진 "고정점 반복(fixed point iteration)" shceme의 예시라고 했다. 물론 계승 함수 f의 정의는 functional g의 고정점을 기술한 것으로 볼 수도 있다. Earlier, we called the approximating sequence an example of the well known "fixed point iteration" scheme. And of course, the definition of the factorial function {\displaystyle f} f can also be thought as the specification of a fixed point of the functional {\displaystyle g} g: = ( ) n if == then else ⋅ ( − ) 하지만 고정점은 여러 개일 수 있다. 위 명세를 만족하는 다른 f가 있다. However, there might be multiple fixed points. For instance, there are several {\displaystyle f} f which fulfill the specification = ↦ if == then else ( + ) 이 프로그램을 실행하면 f(1)이나 f(2)에서 루프를 무한히 돌기 때문에 f(1)의 값에 대해서 어떤 유의미한 정보를 산출하지 못한다. 이는 최소 정의(least defined) 고정점을 의미론 개체로 선택하는 고전적인 방법이다. 따라서 다음은 Of course, when executing such a program, the machine will loop forever on {\displaystyle f(1)} f(1) or {\displaystyle f(2)} f(2) and thus not produce any valuable information about the value of {\displaystyle f(1)} f(1). This corresponds to choosing the least defined fixed point as semantic object {\displaystyle f} f and this is indeed a canonical choice. Thus, we say that = ( ) g의 최소 고정점 f를 정의한다고 말한다. 최소(least)는 우리의 의미론 근사 정렬(semantic approximation order) 과 연관된다. 가 연속("chain continuous"라고도 부른다)이어야 한다는 조건을 추가하면 우리의 iterative construction에 의해 최소 고정점의 존재가 보장된다. 이는 단순히 가 단조수열의 suprema를 준수함을 뜻한다. $ \sup {{\sqsubseteq }}{g(x{0})\sqsubseteq g(x_{1})\sqsubseteq \dots }=g\left(\sup {{\sqsubseteq }}{x{0}\sqsubseteq x_{1}\sqsubseteq \dots }\right) $ 그러면 다음에 의해 $ f=\sup {{\sqsubseteq }}{x{0}\sqsubseteq g(x_{0})\sqsubseteq g(g(x_{0}))\sqsubseteq \dots } $ 이것을 주장할 수 있다. $ {\begin{array}{lcl}g(f)&=&g\left(\sup {{\sqsubseteq }}{x{0}\sqsubseteq g(x_{0})\sqsubseteq g(g(x_{0}))\sqsubseteq \dots }\right)\&=&\sup {{\sqsubseteq }}{g(x{0})\sqsubseteq g(g(x_{0}))\sqsubseteq \dots }\&=&\sup {{\sqsubseteq }}{x{0}\sqsubseteq g(x_{0})\sqsubseteq g(g(x_{0}))\sqsubseteq \dots }\&=&f\end{array}} $ 그리고 iteration limit는의 고정점이기도 하다. 고정점 반복이 최소 고정점을 내놓는다는 것을 확인해 봐도 좋다. 연습문제 0 ⊥ 에서 고정점 반복을 시작해 얻은 고정점이 최소 고정점, 즉 다른 모든 고정점보다 작다는 것을 증명하라. (힌트: 은 우리의 cpo의 최소 원소고는 단조다) 그건 그렇고 우리가 작성한 하스 켈 함수가 연속인지는 어떻게 알아낼까? 단조성처럼 이것도 프로그래밍 언어에 의해 강제되어야 한다. 이런 성질들은 마음먹기에 따라 강제할 수도 깰 수도 있어서 이 질문은 조금 헛되게 느껴진다. 하지만 직관적으로 보자면 단조성은에 패턴 매칭을 허용하지 않음으로써 보장할 수 있다. 연속성의 경우를 보면, 임의 타입 a에 대해 모든 함수 a -> Integer는 자동으로 연속이다. Integer들의 단조수열의 길이는 유한하기 때문이다. a 타입의 값들의 무한 연쇄는 Integer들의 유한 연쇄에 사상되고 suprema를 준수해서(?) 단조성으로 귀결된다. 그러므로 특수 경우 Integer -> Integer의 모든 함수는 연속이어야 한다. g :: (Integer -> Integer) -> (Integer -> Integer) 같은 functional의 경우 연속성은 커링에 의해 성립되는데, 타입이 :: ((Integer -> Integer), Integer) -> Integer와 동형이고 a=((Integer -> Integer), Integer)를 취할 수 있기 때문이다. -> 먼 말임??? 하스켈에서 계승 함수의 fixed interpretation은 다음 코드로 나타낼 수 있다. factorial = fix g 여기에는 고정점 컴비네이터의 도움이 필요하다. fix :: (a -> a) -> a fix는 다음과 같이 정의할 수 있다. fix f = let x = f x in x 머리가 좀 꼬인다. factorial을 전개한 결과는 우리가 애초에 하스켈에서 factorial 함수를 정의한 것과 다르지 않다. 물론 우리가 이 절에서 쌓아 올린 모든 것은 실제 하스 켈 프로그램을 실행할 때 전혀 등장하지 않는다. 이것은 하스 켈 프로그램의 수학적 해석을 확고한 기반 위에 세우기 위한 수단일 뿐이다. 그래도 undefined의 도움을 받아 하스켈에서 이 의미론들을 탐험할 수 있다는 것은 멋진 일이다. 엄격 의미론과 비 엄격 의미론 하스 켈 프로그램의 표기 의미론을 자세히 설명한 후에 semantic object에 대한 수학적 함수 표기 ( ) 를 버리고 그와 동등한 하스 켈 표기인 f n을 사용할 것이다. 엄격한 함수 인자가 하나인 함수 f가 엄격하다고 부를 필요충분조건은 f ⊥ = ⊥ 다음은 엄격한 함수의 예시다. id x = x succ x = x + 1 power2 0 = 1 power2 n = 2 * power2 (n-1) 그리고 여기에 예상을 벗어나는 것은 없다. 하지만 이 함수들이 왜 엄격하다는 걸까? 정말로 엄격한지 증명하는 것은 좋은 연습이다. id의 경우 정의로부터 알 수 있다. succ의 경우 ⊥ + 1가 ⊥인지 아닌지를 고려해야 한다. ⊥가 아니라면 ⊥ + 1 = 2 또는 좀 더 일반적으로 어떤 구체적인 숫자 k에 대해 ⊥ + 1 = k가 성립할 것이다. 모든 함수는 단조임이 기억나는가? 예를 들어 다음이 성립한다. 2 = ⊥ + 1 ⊑ 4 + 1 = 5 그 이유는 ⊥ ⊑ 4이기 때문이다. 하지만 2 ⊑ 5, 2 = 5, 2 ⊒ 5 모두 k가 2일 수 없으므로 참이 아니다. 일반화하면 다음과 같은 모순을 얻는다. k = ⊥ + 1 ⊑ k + 1 = k + 1. 따라서 유일하게 가능한 선택지는 succ ⊥ = ⊥ + 1 = ⊥ 그러므로 succ은 엄격하다. 연습문제 power2가 엄격하다고 가정하자. power2 n이 n 이라는 "명백한" 사실에 근거해 증명할 수도 있지만 가급적이면 후자를 고정점 반복을 이용해 증명하라. 비 엄격 및 엄격한 언어 비 엄격 함수를 찾다 보면 Integer -> Integer 타입의 비 엄격 함수의 프로토타입은 오직 하나만 존재한다. one x = 1 변종으로 모든 구체적인 숫자 k에 대해 constk x = k이 있다. 왜 이것들이 유일한 경우일까? one n은 one ⊥보다 덜 정의될 수 없다는 것을 기억하라. Integer는 평역(flat domain)이기 때문에 이 둘은 같아야만 한다. 왜 one이 비 엄격할까? 그 이유를 보기 위해 하스 켈 인터프리터를 써보자. > one (undefined :: Integer) ⊥이 아니다. one은 인자를 완전히 무시하기 때문에 이것은 합리적이다. ⊥를 "비종결"이라는 동작 의미론적 개념으로 해석할 때 one의 비 엄격함이 의미하는 바는 그 인자를 강제로 평가하지 않는 것이고, 그러므로 인자 ⊥를 평가할 때 무한 루프를 피하는 것이라고 주장할 수도 있다. 하지만 모든 함수는 그 결과를 계산하기에 앞서 인자를 평가해야 하므로 one ⊥ 역시 ⊥여야 한다고 주장할 수도 있다. 즉 그 인자를 평가하는 프로그램이 종료하지 않는다면 one도 종료하지 않아야 한다는 것이다. 3 사실 함수형 프로그래밍 언어를 위해 여러분은 이 설계 또는 다른 설계를 자유롭게 선택할 수 있다. 누군가는 함수가 엄격한지 비 엄격한지에 따라 언어가 엄격하다 또는 비 엄격하다고 말한다. 하스켈은 비 엄격함을 선택한다. 대조적으로 ML과 Lisp는 엄격함 의미론을 선택한다. 다인자 함수 엄격함이라는 개념은 변수가 여러 개인 함수로 확장된다. 예를 들어 인자가 2개인 함수 f가 두 번째 인자에 관해 엄격할 필요충분조건은 모든 x에 대해 다음이 성립하는 것이다. f x ⊥ = ⊥ 하지만 인자가 여러 개일 때는 엄격함 유무가 다른 인자의 값에 달려있는 경우가 더 흔하다. 조건식이 그런 예시다. cond b x y = if b then x else y 이 함수가 y에 관해 엄격한지는 b가 True 인지 False 인지에 따라 달라진다. cond True x ⊥ = x cond False x ⊥ = ⊥ x의 경우도 비슷하다. 보아하니 x와 y가 둘 다 ⊥면 cond는 확실히 ⊥이지만, 둘 중 하나라도 정의된다면 cond가 반드시 ⊥이지는 않다. 이런 동작을 joint strictness라고 부른다. cond는 then과 else 분기 중 하나만 평가하는 것이 중요한 if-then-else 구문처럼 작동한다. if null xs then 'a' else head xs if n == 0 then 1 else 5 / n 조건을 만족할 경우 else 부분은 ⊥이다. 그러므로 비 엄격 언어에서는 if-then-else 같은 원시 제어문을 cond 같은 함수로 감쌀 수 있다. 이런 방식으로 우리만의 제어 연산자를 정의할 수 있다. 엄격한 언어에서는 cond를 호출할 때 두 분기를 모두 평가해야 하므로 cond의 쓸모가 없어진다. 여기서 비 엄격함이 엄격함보다 코드 재사용에 관해 더 유연하다는 일반화된 관찰을 맛볼 수 있다. 이 주제에 대해서는 지연성 4를 볼 것. 대수적 자료형 Intege 간의 부분 함수들의 경우를 다루며 동기를 얻었으니 표기 의미론의 범위를 임의의 하스 켈 대수적 자료형으로 확대해 보자. TODO : 무슨 말이여 잠시 명명법을 짚고 넘어가자면 특정 타입에 대한 semantic object들의 모음을 domain이라고 부른다. 이 용어는 특정한 정의라기보단 일반화된 이름이며 우리는 이 domain이 cpos(complete partial orders), 즉 값들의 집합과 fixed point iteration을 위한 조건들을 만족하도록 더 잘 정의된 more defined 관계를 합한 것이라고 본다. 보통은 cpos에 추가 조건들을 달아서 정의역 안의 값들이 컴퓨터 상에서 유한한 수단으로 표현될 수 있도록 하고 셀 수 없는 무한 집합들을 신경 쓰지 않아도 되도록 한다. 하지만 여기서 일반적인 domain theoretic 정리들을 증명하지는 않을 것이므로 그러한 조건들이 생성에 의해 성립하게 될 것이다. (?) A word about nomenclature: the collection of semantic objects for a particular type is usually called a domain. This term is more a generic name than a particular definition and we decide that our domains are cpos (complete partial orders), that is sets of values together with a relation more defined that obeys some conditions to allow fixed point iteration. Usually, one adds additional conditions to the cpos that ensure that the values of our domains can be represented in some finite way on a computer and thereby avoiding to ponder the twisted ways of uncountable infinite sets. But as we are not going to prove general domain theoretic theorems, the conditions will just happen to hold by construction. 생성자 다음 타입들을 예로 들어보자. data Bool = True | False data Maybe a = Just a | Nothing 여기서 True, False, Nothing은 인자 없는(nullary) 생성자인 반면 Just는 단항 생성자다. Bool의 inhabitant들은 다음 도메인을 형성한다. ⊥는 값의 집합 True와 False에 최소 원소로서 추가되는 것을 기억할 것. Bool 타입은 lift 되었다고 한다. 5 poset 도식에서 층이 하나뿐인 도메인을 flat domain이라 부른다. 우리는 Integer가 flat domain이라는 것도 알고 있다. 다만 ⊥ 위의 층에 무한히 많은 원소가 있을 뿐이다. Maybe Bool의 inhabitant로는 다음 원소들이 있다. ⊥, Nothing, Just ⊥, Just True, Just False 일반적인 규칙은 모든 가능한 값을 단항(이항, 삼 항, ...) 생성자들에 넣으면서 ⊥를 잊지 않는 것이다. 부분 순서를 생각해 보면 생성자가 다른 함수들처럼 단조여야 한다는 조건을 떠올릴 수 있다. 따라서 부분 순서는 다음과 같다. 그런데 신중해야 하는 것이 있다. 왜 Just ⊥ = ⊥가 아닐까? "Just undefined"는 "undefined"만큼이나 정의되지 않는데 말이다. 그 답은 언어가 엄격한지 비 엄격한지에 달려있다. 엄격한 언어에서는 모든 생성자가 기본으로 엄격하므로 Just ⊥ = ⊥이다. 그리고 위 도식은 이렇게 환원된다. 그 결과 엄격한 언어의 모든 도메인은 flat 하다. 하지만 하스 켈 같은 비 엄격 언어에서는 생성자가 기본으로 비 엄격이고 Just ⊥는 ⊥와 다른 새로운 원소인데, 이 값들에 대해 다르게 반응하는 함수를 작성할 수 있기 때문이다. f (Just _) = 4 f Nothing = 7 f가 Just 생성자의 내용물을 무시하기 때문에 f (Just ⊥)는 4이지만 f ⊥는 ⊥이다. (직관적으로 생각하면 f가 ⊥를 받았을 때 Just 분기를 탈지 Nothing 브랜치를 탈지 결정할 수 없기 때문에 ⊥를 반환한다고 볼 수 있다.) 패턴 매칭 엄격한 함수 절에서 몇 함수의 엄격함을 증명하기 위해 여러 입력에 대한 결과를 조사하고 단조성을 강요했다. 하지만 대수적 자료형의 경우 현실적으로 엄격함의 원인은 단 하나인데 바로 패턴 매칭, 즉 case 표현식이다. 일반적으로는 데이터 타입의 생성자에 대한 패턴 매칭이 그 함수를 엄격하도록 강제한다. 즉 생성자에 대해 ⊥를 매칭하면 항상 ⊥가 나온다. 예시를 통해 살펴보자. const1 _ = 1 const1' True = 1 const1' False = 1 const1은 비 엄격하지만 const1'은 엄격하다. 결과가 인자에 의존하지 않아도 인자가 True 인지 False 인지 판단하기 때문이다. 함수 인자에 대한 패턴 매칭은 다음 case 표현식과 동등하다. const1' x = case x of True -> 1 False -> 1 이 case 표현 식도 x에 대해 엄격함을 강제한다. case 표현식에 대한 인자가 ⊥를 표기한다면 case 전체가 ⊥를 표기한다. 하지만 case 표현식의 인자는 좀 더 복잡할 수 있고 foo k table = case lookup ("Foo." ++ k) table of Nothing -> ... Just x -> ... 이것이 foo의 엄격함에 대해 의미하는 바를 추적하기는 어렵다. 등식 스타일의 다중 패턴 매칭의 예시로 논리 or이 있다. or True _ = True or _ True = True or _ _ = False 이 등식들은 위에서 아래로 매칭된다. or 매칭들 중 첫 번째 등식은 첫 인자를 True에 매칭하므로 or은 첫 번째 인자에 대해 엄격하다. 같은 등식에서 or True x가 x에 비엄격한 것도 알 수 있다. 첫 번째 인자가 False 이면 두 번째 인자는 True에 매칭되므로 or false x는 x에 대해 엄격하다. 와일드카드는 보통은 비 엄격함을 암시하지만 생성자에 대한 패턴 매칭에서는 그 위치에 따라 비 엄격함 여부가 달라진다. 연습문제 논리 and에 대해 동일한 논의를 해보자. "배타적 논리합"(xor)의 한 인자를 알면 다른 인자에 대해 비엄격할 수 있을까? 물결 기호 ~가 붙는 거부할 수 없는 패턴 irrefutable pattern이라는 또 다른 형태의 패턴 매칭이 존재한다. f ~(Just x) = 1 f Nothing = 2 거부할 수 없는 패턴은 (그 이름대로) 항상 성공하므로 f ⊥ = 1이다. 하지만 f의 정의를 이렇게 변경하면, f ~(Just x) = x + 1 f Nothing = 2 -- this line may as well be left away 다음을 얻는다. f ⊥ = ⊥ + 1 = ⊥ f (Just 1) = 1 + 1 = 2 인자가 패턴에 일치하면 x는 대응하는 값에 바인딩 된다. 그렇지 않으면 x 같은 모든 변수는 ⊥에 묶인다. 기본적으로 let과 where 바인딩 역시 비 엄격하다. foo key map = let Just x = lookup key map in ... 위 코드는 다음과 동등하다. foo key map = case (lookup key map) of ~(Just x) -> ... 연습문제 하스 켈 언어 정의는 패턴 매칭의 의미론을 자세히 설명하며 여러분이라면 이제 이해할 수 있다. 한번 읽어보자. Boolean 인자 2개를 가지는 or 함수의 다음 성질을 생각해 보자. or ⊥ ⊥ = ⊥ or True ⊥ = True or ⊥ True = True or False y = y or x False = x 이 함수는 joint strictness의 또 다른 예시다. 두 인자가 ⊥일 때만(최소한 인자들을 True 또는 ⊥로 한정하는 경우) 그 결과도 ⊥이다. 이런 함수를 하스 켈로 구현할 수 있을까? 재귀적 자료형과 무한 리스트 재귀 자료구조는 기본적인 경우와 크게 다르지 않다. 유닛 값들의 리스트를 생각해 보자. data List = [] | () : List 단순한 타입처럼 보이지만 ⊥를 여기저기 끼워 넣는 방법은 놀라울 만큼 많고 따라서 이에 대응하는 그래프도 복잡하다. 다음 그림은 이 그래프의 바텀을 보여준다. 생략 부호는 그래프가 이 방향으로 계속 이어진다는 뜻이다. 원소 뒤의 빨간 원은 여기가 연쇄의 끝임을 나타낸다. 원소는 normal form이다. 그런데 이제는 무한히 긴 연쇄도 있다. ⊥⊑ ( ) :⊥⊑ ( ) ( ) :⊥⊑. 여기에는 수렴성 절에서 지적했듯이 모든 단조수열이 최소 상계를 가져야 한다는 점에서 문제가 있다. 이것은 무한 리스트를 허용해야만 가능하다. 무한 리스트(스트림이라고도 한다)는 사실 아주 유용하고 그 용례는 지연성 장에서 자세히 다룬다. 여기서는 그것의 표기 의미론이 무엇이고 이에 대해 추론하는 방법을 보여준다. 앞으로의 논의는 리스트에 한정되지만 트리 같은 임의의 재귀 자료구조로 쉽게 일반화할 수 있다. 앞으로는 표준 리스트 타입으로 돌아간다. data [a] = [] | a : [a] 이는 하스켈에서 무한 리스트를 실제로 프로그래밍하는 것과 문법적 차이를 메꾸기 위해서이다. 연습문제 [Bool]에 상응하는 non-flat domain을 그린다. [Integer]의 경우 그 모양이 어떻게 바뀔까? 무한 리스트의 계산은 예제로 보여주는 것이 최선이다. 그러려면 무한 리스트가 하나 필요하다. ones :: [Integer] ones = 1 : ones 이 재귀 정의에 고정점 반복을 적용하면 ones가 다음의 상한(supremum)임이 드러난다. ⊑ 1 :⊥ ⊑ : :⊥ ⊑ : : :⊥ ⊑. , 이것은 1의 무한 리스트다. take 2 ones가 무엇이 되어야 하는지 이해해 보자. take의 정의에 따르면 take 0 _ = [] take n (x:xs) = x : take (n-1) xs take n [] = [] ones의 근사 수열의 원소들에 take를 적용할 수 있다. take 2 ⊥ ==> ⊥ take 2 (1:⊥) ==> 1 : take 1 ⊥ ==> 1 : ⊥ take 2 (1:1:⊥) ==> 1 : take 1 (1:⊥) ==> 1 : 1 : take 0 ⊥ ==> 1 : 1 : [] take 2 (1:1:1:⊥) 등은 take 2 (1:1:⊥) = 1:1:[] 와 같을 수밖에 없는데, 그 이유는 1:1:[]이 완전히 정의되기 때문이다. 입력 리스트의 시퀀스와 출력 리스트의 결과 시퀀스 양쪽에 상한을 취하면 다음 결론이 나온다. take 2 ones = 1:1:[] 그러므로 ones의 처음 두 인자를 취하면 예상한 바 그대로 행동한다. 위 예제를 일반화하자면 무한 리스트에 대한 추론은 진짜 무한 리스트의 근사 시퀀스의 상한을 취하는 작업을 수반한다. 아직 확실히 하지 않았는데, 해법은 연쇄 전체 그 자체인 무한 리스트를 규명하고 우리의 domain에 새로운 원소로서 추가하는 것이다. 무한 리스트가 바로 자신의 근사 시퀀스다. 물론 ones 같은 무한 리스트는 압축해서 표현할 수 있다. ones = 1 : 1 : 1 : 1 : ... 그 뜻은 그저 다음과 같다. ones = (⊥ ⊑ 1:⊥ ⊑ 1:1:⊥ ⊑ ...) 연습문제 물론 ones보다 흥미로운 무한 리스트들이 존재한다. 다음을 하스켈의 재귀 정의로 작성할 수 있는가? 자연수들 nats = 1:2:3:4:... 사이클 cycle123 = 1:2:3: 1:2:3 : ... 프렐류드 함수 repeat와 iterate를 활용해 1번 연습문제를 풀어본다. 이 글의 예제를 활용해 표현식 drop 3 nats이 표기하는 값을 구한다. 엄격한 환경을 가정한다. 즉 [Integer]의 domain은 flat 하다. 그 domain은 어떻게 생겼는가? 무한 리스트나 ones가 표기하는 값은 어떠한가? 컴퓨터는 무한 리스트를 어떻게 계산할 수 있을까? 무한한 시간이 걸리지 않을까? 맞는 말이다. 하지만 무한 리스트의 유한한 일부만 고려하면 유한한 시간 안에 끝낼 수 있다. 따라서 무한 리스트는 잠재적으로 무한한 리스트라고 봐야 한다. 일반적으로 중간 결과는 무한 리스트의 형태를 취하는 반면 최종 값은 유한하다. 프로그램의 correctness를 추론할 때 중간 과정의 자료구조를 정말로 무한하다고 취급할 수 있는 것은 표기 의미론이 주는 이점 중 하나다. 연습문제 무한 리스트를 중간 결과로서 사용하는 것을 체험하기 위해 다음을 증명하라. take 3 (map (+1) nats) = take 3 (tail nats) map (+1) nats에 해당하는 무한 순열을 계산하는 것으로 시작하라. 2. 물론 최종 결과에 무한한 시간이 걸리는 예시도 있다. filter (< 5) nats이 표기하는 바는 무엇인가? 3. 때로는 위 연습문제의 takeWhile을 filter로 대체할 수 있다. 왜 어떤 경우에만 가능하고, 교체할 경우 어떤 일이 일어나는가? 마지막으로 짚고 넘어가자면 함수의 재귀 정의와 비슷한 방법으로 fixed point iteration을 통해 재귀적 domain을 구축할 수 있다. 무한 연쇄 문제는 직접 해결해야 한다.<NAME>적 구축에 관해서는 외부 링크의 문헌을 참고할 것. 하스 켈 한정: strictness annotation과 newtype 하스켈은 strictness annotation을 통해 데이터 타입 생성자의 기본 비 엄격 행동을 변경하는 수단을 제공한다. 다음과 같은 데이터 선언에서 data Maybe' a = Just' !a | Nothing' 생성자 인자 앞의 느낌표!는 그 인자에 대해 엄격해야 함을 명시한다. 따라서 여기서는 Just' ⊥ = ⊥이다. 적극성 장에서 더 많은 정보를 볼 수 있다. 다음과 같이 데이터 타입을 개명하고 싶을 수도 있다. data Couldbe a = Couldbe (Maybe a) 하지만 Couldbe a는 ⊥와 Couldbe ⊥를 모두 포함한다. newtype 정의의 도움을 받으면 newtype Couldbe a = Couldbe (Maybe a) Couldbe a가 구문적으로는 Maybe a와 동등하지만 타입 검사 시에는 다르게 취급하도록 만들 수 있다. 특히 Couldbe 생성자는 엄격하다. 그렇지만 이 정의는 다음 정의와 미묘하게 다르다. data Couldbe' a = Couldbe' !(Maybe a) 그 이유를 설명하려면 다음 함수들을 살펴봐야 한다. f (Couldbe m) = 42 f' (Couldbe' m) = 42 여기서 f' ⊥는 Couldbe' 생성자에 대한 패턴 매칭을 실패하게 만드는데, f' ⊥ = ⊥이기 때문이다. 하지만 newtype의 경우 Couldbe에 대한 매칭은 절대 실패하지 않으며 우리는 f ⊥ = 42를 얻는다. ⊥에 대한 패턴 매칭은 실패하지만 Constructor ⊥에 대한 매칭은 성공한다는 점에서, 이러한 차이를 다음처럼 서술할 수 있다. 엄격함의 경우 Couldbe' ⊥는 ⊥의 동의어다. newtype의 경우 ⊥는 Couldbe ⊥의 동의어다. newtype은 재귀 타입을 정의하는데도 사용할 수 있다. 다음 예제는 리스트 타입 [a]를 다른 식으로 정의한다. newtype List a = In (Maybe (a, List a)) 이번에도 요점은 생성자 In 가 ⊥에 의한 추가적인 lift를 도입하지 않는다는 것이다. 다음은 newtype과 비 엄격 및 엄격한 data 선언들의 차이를 설명하는 예제들이다. Prelude> data D = D Int Prelude> data SD = SD! Int Prelude> newtype NT = NT Int Prelude> (\(D _) -> 42) (D undefined) 42 Prelude> (\(SD _) -> 42) (SD undefined) *** Exception: Prelude.undefined [...] Prelude> (\(NT _) -> 42) (NT undefined) 42 Prelude> (\(D _) -> 42) undefined *** Exception: Prelude.undefined [...] Prelude> (\(SD _) -> 42) undefined *** Exception: Prelude.undefined [...] Prelude> (\(NT _) -> 42) undefined 42 다른 주제들 abstract interpretation과 엄격함 분석 지연 평가는 고정적인 계산 오버헤드를 유발하기 때문에 하스 켈 컴파일러는 비 엄격함을 내재할 필요가 전혀 없는 경우를 발견해서 그런 경우 오버헤드를 없애길 원할 수도 있다. 그런 의미에서 컴파일러는 우리가 엄격한 함수 절에서 함수의 엄격함을 입증한 것과 같은 방식으로 엄격함 분석을 수행한다. 물론 우리의 cond 예제처럼 인자의 정확한 값에 기반한 엄격함 유추는 범위 밖이다. (이런 건 일반적으로 결정 불가능하다) 하지만 컴파일러는 대략적인 엄격함 정보를 얻으려 노력하며 power2처럼 많은 경우 잘 작동한다. abstract interpretation은 엄격함을 추론하기 위한 어마어마한 아이디어다. TODO: 원문 미완성 엄격함 분석에 관해서는 하스 켈 위키의 엄격함 분석에 관한 연구 논문들을 볼 것. 멱집합으로서의 해석 TODO: 원문 내용이 올바른지에 대한 논쟁이 있습니다. naive set은 재귀적 자료형에 적합하지 않다 What to choose as Semantic Domain? 절에서 단순한 집합을 타입의 표기로 사용하는 것은 부분 함수와 잘 맞지 않는다고 논했다. 재귀적 자료형을 고려하면 John C. Reynolds가 그의 논문 Polymorphism is not set-theoretic7에서 보인 것처럼 상황은 더 나빠진다. Reynolds는 다음의 재귀적 타입을 고려했다. newtype U = In ((U -> Bool) -> Bool) Bool을 집합 {True, False}, 함수 타입 A -> B를 A에서 B로 가는 함수들의 집합으로 해석할 때, 타입 U은 집합을 표기하지 못한다. 그 이유는 (A -> Bool)은 A의 하위 집합들의 집합 (즉 멱집합)인데 Cantor의 자연수보다 실수가 더 많다는 논의와 비슷한 대각선 논법에 의해 이 집합의 cardinality는 항상 A의 cardinality보다 크기 때문이다. 그러므로 (U -> Bool) -> Bool은 U보다 큰 cardinality를 가지고 U와 동형(isomorphic)일 리가 없다. 그러므로 집합 U는 존재하지 않아야 하는데 이는 모순이다. 우리의 부분 함수 세계에서 이 논법은 실패한다. U의 원소는 일련의 정의역으로부터 취한 일련의 approximation에 의해 주어진다. ⊥, (⊥ -> Bool) -> Bool, (((⊥ -> Bool) -> Bool) -> Bool) -> Bool 등등 여기서 ⊥는 단일 inhabitant ⊥를 가지는 정의역을 표기한다. 이 글을 쓰고 있는 나는 이것이 뜻하는 바가 무엇인지 모른다. 생성자는 U를 위해 완벽히 잘 정의된 객체를 돌려준다. 그 타입인 (U -> Bool) -> Bool은 shifted approximating sequence들로 구성되는데, U와 동형임을 뜻한다. 마지막 노트로서 Reynold는 이차 다형 람다 대수를 통해 U의 동치를 구축한다. 모든 항은 normal form을 가진다. 즉 primitive recursion 연산자 fix :: (a -> a) -> a를 도입하지 않으면 total function들만이 존재하게 된다. 그러므로 부분 함수와 ⊥는 필요 없고, naïve set theoretic semantics는 실패한다. 우리는 모든 수학적 함수가 계산 가능하지는 않다는 사실만 짐작할 뿐이다. 특히 계산 가능한 함수들의 집합 Nat -> Bool는 Nat보다 큰 cardinality를 가져서는 안 된다. 외부 링크 표기 의미론에 관한 온라인 책들 Schmidt, David A. (1986). Denotational Semantics. A Methodology for Language Development. Allyn and Bacon. 사실 하스켈의 표기 의미론은 어디에도 완벽하게 적혀있지 않다. 그런 작업은 새로운 직관을 가져다주지 못하는 지루한 작업일 뿐이므로 전통적으로 내려오는 상식적인 의미론을 받아들이자. ↩ 모나드는 명령형 프로그램에 표기 의미론을 부여하는 가장 성공적인 방법 중 하나다. Haskell/Advanced monads도 읽어볼 것. (옮긴이: Advanced monads 페이지 원문에도 쓰여있듯이 대부분 내용은 모나드 이해하기 페이지에 통합되었습니다.) ↩ 함수 인자의 이른 평가로서의 엄격함은 그래프 소거장에서 자세히 설명한다. ↩ 지연성이라는 용어는 비 엄격 언어들에서 흔한 구현 기법이 지연 평가라고 불리는 것에 기인한다. ↩ lifted라는 용어는 뜻이 조금 많다. Unboxed Types도 읽어볼 것. (옮긴이: 원문 링크가 깨짐) ↩ S. Peyton Jones, A. Reid, T. Hoare, S. Marlow, and F. Henderson. A semantics for imprecise exceptions. In Programming Languages Design and Implementation. ACM press, May 1999. ↩ John C. Reynolds. Polymorphism is not set-theoretic. INRIA Rapports de Recherche No. 296. May 1984. ↩ 4 범주론 원문: https://en.wikibooks.org/wiki/Haskell/Category_theory source object와 target object의 마땅한 번역 용어를 찾지 못해 그대로 표기했습니다. 보통은 mapping을 사상이라고 번역하는데 이 페이지에서는 morphism과 mapping을 구분해서 쓰고 있기 때문에 일단 여기 한정으로 morphism을 사상, mapping을 그냥 매핑이라고 번역했습니다. 다른 페이지들에서는 다 mapping을 사상이라고 번역한 것에 유의해 주세요. 범주(category) 입문 범주 법칙 Hask: 하스켈의 범주 펑 터 Hask에 대한 펑 터 범 주론적 개념들을 하스 켈로 번역하기 모나드 예제: 멱집합 펑터는 모나드다 모나드 법칙과 그 중요성 첫 번째 법칙 두 번째 법칙 세 번째 법칙과 네 번째 법칙 do 블록에 대한 응용 요약 이 글에서는 범주론이 무엇이고 하스켈에 어떻게 적용되는지 간단히 살펴본다. 이를 위해 수학적 정의마다 하스 켈 코드가 같이 나올 것이다. 정말 엄밀하지는 않지만 우리의 목적은 독자들이 범주론의 개념들을 직관적으로 느끼고 그것이 어떻게 하스켈에 연관되는지 보여주는 것이다. 범주(category) 입문 세 개체 A, B, C, 세 동형 사상 d, d, d, 두 사상 : →, : → 을 가지는 간단한 범주. 세 번째 요소(사상들을 합성하는 방법에 대한 명세)는 표시하지 않았다. 본질적으로 범주는 그저 모음이다. 범주는 세 구성요소(component)를 가진다. 개체(object)들의 모음. 사상(morphism)들의 모음. 한 사상은 두 개체(source object와 target object)를 연결한다. (사상을 애로(arrow)라고 부르기도 하지만 하스켈에서 애로는 다른 의미를 가지기 때문에, 애로라는 용어는 쓰지 않을 것이다) f가 source object로 A, target object로 B를 가지는 사상이면 : →로 표기한다. 사상들의 합성(composition)이라는 개념. 두 사상 : → 와 : → 을 합성하면 사상 ∘ : →를 얻는다. 많은 것이 범주를 형성한다. 예를 들어 Set은 모든 집합의 범주로서 사상은 일반적인 함수, 합성은 일반적인 함수 합성이 된다. (범주의 이름은 굵게 표시하곤 한다) Grp은 모든 군(group)의 범주다. 그런 군에서 사상은 군 연산을 보존하는 함수다(군 동형사상). 즉 연산 *를 가지는 군 G와 연산 ·를 가지는 군 H에 대해 다음을 만족하는 함수 : →는 Grp의 사상이다. ( ∗ ) f ( ) f ( ) 사상이 항상 함수인 것은 아니다. 예를 들어 부분 순서 ( , ) 가 정의하는 범주에서는 P의 원소들이 개체가 되고, 두 개체 A와 B 사이에 사상이 있을 필요충분조건은 ≤이다. 더욱이 동일한 source object, target object에 대해 사상이 여러 개일 수 있다. Set을 예로 들면 sin과 cos 둘 다 source object가 (실수 집합)이고 target object는 [ 1 1 ] 인 함수지만, 분명히 같은 사상은 아니다! 범주 법칙 범주가 만족해야 하는 세 가지 법칙이 있다. 첫 번째는 가장 간단한 것으로 사상의 합성에 결합법칙이 성립해야 한다는 것이다. 기호로 표현하면 ∘ ( ∘ ) ( ∘ ) h 수학에서 대개 그렇듯이 하스켈에서는 사상이 오른쪽에서 왼쪽으로 적용된다. 따라서 ∘에서는 g가 먼저 적용되고 그다음 f가 적용된다. 두 번째 법칙은 범주가 합성 연산에 대해 닫혀있다는 것이다. 만약 : → 와 : → 가 있다면 그 범주 안에 사상 : → 가 반드시 존재해고, = ∘ 여야 한다. 이게 어떤 식으로 작동하는지는 다음의 범주에서 볼 수 있다. f와 g 둘 다 사상이므로 둘을 합성해 그 범주에 속하는 또 다른 사상을 얻을 수 있어야 한다. 그래서 사상 ∘는 무엇인가? 유일한 후보는 d이다. 비슷하게 ∘ = d이다. 마지막으로, 범주 C 안의 모든 개체 A에 대해 동형 사상 d : → 이 있어야 한다. 이것은 다른 사상과 합성할 때 항등원이 된다. 정확히 말하면 모든 사상 : →에 대해 다음이 성립해야 한다. ∘ d = d ∘ = Hask: 하스켈의 범주 이 글에서는 Hask 범주를 자주 보게 된다. Hask는 하스 켈 타입을 개체로, 하스 켈 함수를 사상으로, (.)을 합성으로 취급한다. 타입 A와 B에 대한 함수 f :: A -> B는 Hask 안에서 사상이다. 첫 번째와 두 번째 법칙은 쉽게 확인할 수 있다. (.)는 연관 법칙이 성립하는 함수고 모든 f와 g에 대해 f. g가 또 다른 함수임은 자명하다. Hask에서 동형 사상은 id이다. 그리고 다음도 자명하다. id. f = f. id = f 1 그런데 이것이 위 법칙을 정확히 옮긴 것은 아니다. 여기에는 첨자가 빠져있다. 하스켈의 함수 id는 다형성이어서 정의역과 치역으로 다양한 타입을 허용하여, 범주론의 용어로 말하면 다양한 source object와 target object를 가질 수 있다. 하지만 범주론에서 사상의 정의는 단 형성(monomorphic)이다. 각 사상은 구체적인 한 source object와 한 target object를 가진다. (전문가를 위한 노트: 여기서 monomorphic이라는 단어는 범주론의 그 의미로 쓴 것이 아니다) 하스켈의 다형 함수는 그 타입을 구체화하여 (단형 타입으로 인스턴스화하여) 단형성으로 만들 수 있다. 따라서 타입 A에 대해 Hask의 동형 사상은 (id :: A -> A)라고 말하는 게 좀 더 정확하겠다. 이를 염두에 두고 위 법칙을 아래와 같이 다시 쓸 수 있다. (id :: B -> B) . f = f. (id :: A -> A) = f 하지만 뜻하는 바가 명확하다면 단순함을 위해 이런 구분을 무시할 것이다. 연습문제 앞에서 언급했듯이 임의의 부분 순서 ( , ) 는 P의 원소들을 개체로, 원소 a, b 사이의 사상이 ≤ 인 범주다. 위 법칙들 중 어느 것이의 이행성(transitivity)을 보장하는가? (어려움) 위 예제에 아래 그림과 같이 또 다른 사상을 추가하면 범주가 아니게 된다. 그 이유는? 힌트: 합성 연산의 결합 법칙을 생각해 보라. 펑 터 개체들과 그 개체들을 연결하는 사상을 가지는 범주를 알게 되었으니 다음 화제는 범주들을 연결하는 펑터다. 펑터의 본질은 범주 사이의 변환이다. 범주 C와 D에 대해 펑 터 : →는 다음을 만족한다. C 안의 개체 A를 D 안의 F(A)에 매핑한다. C 안의 사상 : →를 D 안의 ( ) F ( ) F ( ) 에 매핑한다. 펑터의 전형적인 예시는 잊기 쉬운 펑 터인 Grp → Set이다. 이 펑터는 군을 그 기저의 집합에 매핑하고, 군 사상을 함수로 매핑하는데 이 함수는 하는 일은 같지만 군 대신 집합에 대해 정의된다. 또 다른 예로 멱집합 펑 터 Set -> Set은 집합을 그들의 멱집합으로 매핑하고, 함수 : →를 함수 ( ) P ( ) 로 매핑한다. 이때 입력은 ⊆이고 ( ) 를 반환한다. ( ) 는 f 하에서 U의 상(image)으로서 ( ) { ( ) u U } 로 정의된다. 임의의 범주 C에 대해 항등 펑 터 C C C 를 정의할 수 있는데, 이것은 단순히 개체를 자신으로, 사상을 자신으로 매핑하는 일을 한다. 나중에 모나드 법칙 절에서 이것이 어디에 유용한지 볼 것이다. 펑터에도 몇 가지 공리가 있다. 첫 번째로 개체 A에 대한 항등 사상 d에 대해 ( d) F ( ) 에 대한 항등 사상이어야 한다. 즉 ( d) i F ( ) 두 번째로 펑터는 사상 합성에 대해 분배법칙이 성립해야 한다. 즉 ( ∘ ) F ( ) F ( ) 연습문제 아래 다이어그램에 대해 위 펑 터 법칙들을 확인하라. 두 범주 C와 D 사이의 펑터. 개체 A와 B는 D 내의 같은 개체로 매핑되므로 g는 source object와 target object가 동일한 사상이 된다. (하지만 꼭 항등인 것은 아니다) d 와 d는 동일한 사상이다. 개체 간 매핑을 나타내는 화살표는 옅은 초록색 점선으로 표시했다. 사상 간 매핑은 옅은 파란색 점선으로 표시했다. Hask에 대한 펑 터 여러분이 하스켈에서 봤을 Functor 타입 클래스는 펑터의 범 주론적 표기와 일치한다. 펑터에는 두 부분이 있음을 기억할 것: 펑터는 한 범주의 개체를 다른 범주의 개체로, 한 범주의 사상을 다른 범주의 사상으로 매핑한다. 하스켈의 펑터는 Hask의 func에 해당하는데, func는 그 펑터의 타입들에 대해 정의된 Hask 하위 범주다. 에를 들어 리스트 펑터는 Hask에서 나온 Lst로서 Lst는 리스트 타입들, 즉 타입 T에 대한 [T]만을 포함하는 범주다. Lst 내의 사상은 리스트 타입들에 대해, 타입 T, U에 대한 [T] -> [U]로 정의된다. 이것이 하스켈의 Functor 타입 클래스와 어떻게 일치한다는 걸까? Functor의 정의를 떠올려보자. class Functor (f :: * -> *) where fmap :: (a -> b) -> f a -> f b 다음은 Functor의 한 인스턴스다. instance Functor Maybe where fmap f (Just x) = Just (f x) fmap _ Nothing = Nothing 핵심은 이거다. 타입 생성자 Maybe는 임의 타입 T를 새로운 타입 Maybe T로 데려간다. 또한 Maybe 타입들에 한정된 fmap은 함수 a -> b를 함수 Maybe a -> Maybe b로 데려간다. 바로 이거다! 방금 두 가지를 정의했는데 하나는 Hask 안의 개체를 다른 범주의 개체로 데려가고 다른 하나는 Hask 안의 사상을 다른 범주의 사상으로 데려간다. 따라서 Maybe는 펑터다. 하스 켈 펑터에 대한 유용한 직관이 있는데, 펑터는 매핑 가능한 타입을 나타낸다. 그 타입은 리스트, Maybe, 또는 트리 같은 더 복잡한 구조체일 수도 있다. 무언가 매핑을 하는 함수는 fmap을 이용하여 작성할 수 있고, 그다음 임의의 펑 터 구조체를 이 함수에 전달한다. 가령 여러분은 Data.List.Map, Data.Map.map, Data.Array.IArray.amap 등을 모두 처리하는 일반화된 함수를 작성할 수도 있다. 펑 터 공리는 어떠한가? 다형 함수 id는 임의의 A에 대해 d 역할을 한다. 따라서 첫 번째 법칙이 성립한다. fmap id = id 위의 직관을 염두에 두면 이 문장이 뜻하는 바는 "구조체의 각 원소에 대해 아무것도 하지 않는 매핑은 전반적으로 아무것도 하지 않는 것과 동치"라는 것이다. 두 번째로 사상 합성은 단순히 (.)이다. 따라서 fmap (f . g) = fmap f. fmap g 이 두 번째 법칙은 실전에서 매우 유용하다. 펑터를 리스트나 그 비슷한 컨테이너로 보면 우변은 2단계 알고리즘이다. 구조체 전체에 대해 g를 수행해 매핑하고 그다음 f를 수행해 다시 매핑한다. 펑 터 공리는 우리가 이것을 f. g를 수행하는 1단계 알고리즘으로 변환할 수 있음을 보장한다. 이런 절차를 퓨전(fusion)이라고 한다. 연습문제 Maybe 펑터와 리스트 펑터에 대해 위 법칙들을 확인하라. 범 주론적 개념들을 하스 켈로 번역하기 펑터는 범주론이 하스 켈로 어떻게 번역되는지를 잘 보여주는 예시다. 핵심은 다음과 같다. 우리는 Hask와 그 하위 범주에서 작업한다. 개체는 타입이다. 사상은 함수다. 타입을 취해 다른 타입을 반환하는 것들은 타입 생성자다. 함수를 취해 다른 함수를 반환하는 것들은 고차 함수다. 타입 클래스와 그것이 제공하는 다형성은 범주론에서 이런저런 것들이 많은 개체에 대해 한 번에 정의된다는 사실을 포착하는 훌륭한 수단이다. 모나드 모나드는 분명 하스켈에서 매우 중요한 개념이고, 사실 범주론에서 유래한 것이다. 모나드는 특수한 펑터로서 한 범주를 동일한 범주로 데려가며 추가적인 구조체를 지원한다. 그럼 정의를 보자. 모나드는 펑 터 : →이며 C 안의 모든 개체 X에 대해 두 사상을 2 가진다. n t M X M ( ) o n M M ( ( ) ) M ( ) 논의하려는 모나드가 명확하다면 윗첨자 M을 떼어내고 단순히 어떤 X에 대한 n t 와 o n라고 하겠다. 주어진 모나드의 모든 개체에 대해 존재해야 하는 두 사상 unit과 join. 이것이 어떻게 하스 켈 타입 클래스 Monad로 번역되는지 보자. class Functor m => Monad m where return :: a -> m a (>>=) :: m a -> (a -> m b) -> m b Functor m이라는 클래스 제약은 우리가 이미 펑 터 구조, 즉 개체와 사상의 매핑을 가지고 있음을 보장한다. return은 임의 X에 대해 n t 와 비슷하며 다항적이다. 그런데 문제가 하나 있다. return의 타입이 unit의 타입과 상당히 비슷해 보이지만 다른 함수 (>>=)는, 주로 바인드 bind라고 부르는데, join과 하나도 닮지 않았다. 그렇지만 또 다른 모나드 함수 join :: Monad m => m (m a) -> m a는 상당히 비슷해 보인다. 사실 join과 (>>=)는 서로를 토대로 만들어질 수 있다. join :: Monad m => m (m a) -> m a join x = x >>= id (>>=) :: Monad m => m a -> (a -> m b) -> m b x >>= f = join (fmap f x) 따라서 모나드의 return, fmap, join을 명시하는 것은 return과 (>>=)을 명시하는 것과 동등하다. 범주론에서 모나드를 정의하는 일반적인 방법은 unit과 join이지만 하스 켈 프로그래머들은 return과 (>>=)를 선호한다. 3 대개 범주론의 방법이 더 타당하다. 어떤 구조 M이 있고 임의 개체 X를 M(X)로 데려가는 자연스러운 방법이 있다면, 그뿐만 아니라 M(M(X))를 M(X)로 데려가는 방법도 있다면, 확실히 모나드가 있는 것이다. 다음 예제에서 이것을 본다. 예제: 멱집합 펑터는 모나드다 위에서 서술한 멱집합 펑 터 : e → e 은 모나드를 형성한다. 임의 집합 S에 대해 n t ( ) { } 은 원소를 단위집합으로 매핑한다. 각각의 단위집합은 S의 자명한 하위 집합이므로 n t는 S의 멱집합의 원소를 반환하는 것이다. 그리고 o n를 다음과 같이 정의할 수 있다. 입력 ∈ ( ( ) ) 을 받는다. 이 입력은 S의 멱집합의 멱집합의 멤버다. 따라서 S의 모든 하위 집합의 집합의 모든 하위 집합의 집합의 멤버다. 따라서 S의 하위 집합들의 집합이다. 이제 이 하위 집합들의 합집합을 반환하여 S의 또 다른 하위 집합을 제공한다. 기호로 표현하면 o n ( ) ⋃ 따라서 P는 모나드다. 4 사실 P는 리스트 모나드와 거의 동등하다. 집합 대신 리스트라는 것만 빼면 거의 같다. 비교해 보자. 집합에 대한 멱집합 펑 터 함수 타입 정의 집합 S와 사상 : →에 대해 ( ) P ( ) P ( ) ( ( ) ) ( ) { ( ) a S } n t : → ( ) n t ( ) { } o n : ( ( ) ) P ( ) o n ( ) ⋃ 하스켈의 List 모나드 함수 타입 정의 타입 T 와 함수 f :: A -> B에 대해 fmap f :: [A] -> [B] fmap f xs = [ f a | a <- xs ] return :: T -> [T] return x = [x] join :: [[T]] -> [T] join xs = concat xs 모나드 법칙과 그 중요성 펑터가 펑 터이기 위해 만족해야 하는 공리가 있었듯이 모나드도 모나드의 공리가 있다. 먼저 그 공리들을 나열하고, 하스 켈로 번역하고, 왜 중요한지 살펴보겠다. 다음은 모나드 : → 와, , ∈에 대한 사상 : →이다. o n M ( o n ) j i ∘ o n o n M ( n t ) j i ∘ n t i u i ∘ = ( ) u i j i ∘ ( ( ) ) M ( ) j i 위의 하스 켈 번역판들이 이제는 척 보면 알 정도가 되었을 것이다. join . fmap join = join . join join . fmap return = join . return = id return . f = fmap f. return join . fmap (fmap f) = fmap f. join (fmap은 사상에 대해 작동하는 펑터의 일부임을 기억하자.) 이 법칙들이 처음에는 난해할 수 있다. 법칙들이 무엇을 뜻하고 모나드가 왜 이것들을 만족해야 하는지 알아보는 탐험을 시작하자. 첫 번째 법칙 join . fmap join = join . join 이 법칙을 이해하기 위해 리스트를 예시로 들겠다. 첫 번째 법칙에는 두 함수 join . fmap join (좌변)과 join . join (우변)이 있다. 이 함수들의 타입은 무엇일까? join의 타입이 [[a]] -> [a] (지금은 리스트에 대해 말하는 중이다) 임을 떠올려보면 두 함수의 타입은 똑같이 [[[a]]] -> [a]이다. (두 타입이 같다는 사실은 편리하다. 무엇보다 우리는 이 둘이 완전히 같은 함수라는 것을 보이려는 중이다!) 그래서 우리에겐 리스트의 리스트의 리스트가 있다. 좌변은 이 3중첩 리스트에 fmap join을 수행하고 그 결과에 join을 수행한다. fmap은 리스트에선 단순히 map이므로 우리는 가장 바깥의 리스트 안에 있는 각각의 리스트의 리스트들에 매핑을 수행하고 하나의 리스트로 연결하는 것이다. 결국 리스트의 리스트를 얻고, 여기에 join을 수행한다. 요약하면 우리는 가장 바깥 레벨에 '들어가서' 두 번째 층과 세 번째 층을 합치고 이 새로운 레벨을 최상위 레벨과 합친다. 우변은 어떠한가? 먼저 리스트의 리스트의 리스트에 join을 수행한다. 층이 3개고, 보통은 2중첩 리스트에 join을 적용하지만, 이 상황에서도 작동을 한다. [[[a]]]는 b = [a]에 대해 [[b]]이기 때문이다. 어떤 의미에서 3중첩 리스트는 2중첩 리스트인데 마지막 층이 '평평한' 것이 아니라 또 다른 리스트인 것이다. 우리의 리스트의 리스트(의 리스트)를 join에 적용하면 바깥의 두 층이 한 층으로 펴진다. 두 번째 층이 평평하지 않고 세 번째 층을 포함하기 때문에 여전히 우리에게 있는 것은 리스트의 리스트고, 또 다른 join이 이것을 편다. 요약하면 좌변은 안쪽의 두 레이어를 새로운 레이어로 편 다음 이것을 가장 바깥의 리스트와 함께 편다. 우변은 바깥의 두 레이어를 편 다음 가장 안쪽의 레이어를 편다. 이 두 연산은 동치여야 한다. 일종의 join을 위한 연관 법칙인 셈이다. Maybe도 다음을 만족하는 모나드다. return :: a -> Maybe a return x = Just x join :: Maybe (Maybe a) -> Maybe a join Nothing = Nothing join (Just Nothing) = Nothing join (Just (Just x)) = Just x 3중첩 Maybe(Nothing, Just Nothing, Just (Just Nothing), Just (Just (Just x))) 등)에 대해, 첫 번째 법칙에 따르면 안쪽 두 층을 먼저 합치고 가장 바깥 층을 합치는 것은 바깥 두 층을 먼저 합치고 가장 안쪽 층을 합치는 것과 동일하다. 연습문제 리스트와 Maybe 모나드가 이 법칙을 만족한다는 것을 몇 가지 예제를 이용해 검증하고 레이어 합치기가 어떻게 작동하는지 보자. 두 번째 법칙 join . fmap return = join . return = id 이번에도 리스트 예시로 시작한다. 두 번째 법칙이 언급하는 두 함수는 [a] -> [a]이다. 좌변은 리스트에 사상하는 함수를 표현하는데, 각 원소 x를 싱글턴 리스트 [x]로 변환하여 최종적으로 싱글턴 리스트들의 리스트가 만들어진다. 이 2중 리스트를 join을 이용해 단일 리스트로 짓누른다. 반면 우변은 전체 리스트 [x, y, z, ...]를 취해 리스트들의 싱글턴 리스트 [[x, y, z, ...]]로 변환하고 다시 두 층을 한 층으로 짓누른다. 이 법칙은 한 마디로 요약하기 애매하지만, 그 근간은 모나 딕 값에 return을 적용하고 join 하면 그 결과는 return을 최상위 층의 밖에서 하든 안에서 하든 동일하다는 뜻이다. 연습문제 Maybe 모나드에 대해 두 번째 법칙을 증명해 보자. 세 번째 법칙과 네 번째 법칙 return . f = fmap f. return join . fmap (fmap f) = fmap f. join 이 두 법칙은 우리가 모나드의 행동에 기대하는 바를 좀 더 스스로 드러낸다. 이것들이 참임을 보이는 가장 쉬운 방법은 확장형을 사용해 식을 펼치는 것이다. \x -> return (f x) = \x -> fmap f (return x) \x -> join (fmap (fmap f) x) = \x -> fmap f (join x) 연습문제 우리가 첫 번째, 두 번째 법칙을 설명한 것과 비슷한 방식으로 이 법칙들이 무엇을 뜻하는지 탐구하고 모든 모나드에 대해 참임을 보이자. do 블록에 대한 응용 모나드가 반드시 만족해야 하는 법칙들을 알아보긴 했는데 뭐가 중요하다는 걸까? 그 답은 do 블록을 고려하면 명확해진다. do 블록은 (>>=)를 포함하는 문(statement)들의 조합을 위한 편의 문법일 뿐이라는 것을 상기하자. do { x } --> x do { let { y = v }; x } --> let y = v in do { x } do { v <- y; x } --> y >>= \v -> do { x } do { y; x } --> y >>= \_ -> do { x } 일반적으로 return과 (>>=)을 이용해 서술되는 모나드 법칙이라는 것들을, 위의 법칙들을 통해 증명할 수도 있다. (몇 개는 증명이 조금 빡세니 그냥 넘어가도 된다) return x >>= f = f x. 증명: return x >>= f = join (fmap f (return x)) -- By the definition of (>>=) = join (return (f x)) -- By law 3 = (join . return) (f x) = id (f x) -- By law 2 = f x m >>= return = m. 증명: m >>= return = join (fmap return m) -- By the definition of (>>=) = (join . fmap return) m = id m -- By law 2 = m (m >>= f) >>= g = m >>= (\x -> f x >>= g). 증명: (fmap f. fmap g = fmap (f . g) 임을 숙지) (m >>= f) >>= g = (join (fmap f m)) >>= g -- By the definition of (>>=) = join (fmap g (join (fmap f m))) -- By the definition of (>>=) = (join . fmap g) (join (fmap f m)) = (join . fmap g. join) (fmap f m) = (join . join . fmap (fmap g)) (fmap f m) -- By law 4 = (join . join . fmap (fmap g) . fmap f) m = (join . join . fmap (fmap g. f)) m -- By the distributive law of functors = (join . join . fmap (\x -> fmap g (f x))) m = (join . fmap join . fmap (\x -> fmap g (f x))) m -- By law 1 = (join . fmap (join . (\x -> fmap g (f x)))) m -- By the distributive law of functors = (join . fmap (\x -> join (fmap g (f x)))) m = (join . fmap (\x -> f x >>= g)) m -- By the definition of (>>=) = join (fmap (\x -> f x >>= g) m) = m >>= (\x -> f x >>= g) -- By the definition of (>>=) return과 (>>=)를 이용한 새 모나드 법칙들을 do 블록 표기로 번역할 수 있다. 인자 생략식 do 블록 return x >>= f = f x do { v <- return x; f v } = do { f x } m >>= return = m do { v <- m; return v } = do { m } (m >>= f) >>= g = m >>= (\x -> f x >>= g) do { y <- do { x <- m; f x }; g y } = do { x <- m; y <- f x; g y } 모나드 법칙들은 이제 do 블록이 어떻게 작동해야 하는지에 대한 상식선의 서술이다. 이 법칙들 중 하나라도 깨지면 사용자들은 혼란스러워할 것이다. do 블록 안에서 상황을 예상대로 조작할 수 없기 때문이다. 모나드 법칙들은 사용성 지침인 셈이다. 연습 문제 사실 우리가 제공한 두 버전의 법칙들은 -- Categorical: join . fmap join = join . join join . fmap return = join . return = id return . f = fmap f. return join . fmap (fmap f) = fmap f. join -- Functional: m >>= return = m return m >>= f = f m (m >>= f) >>= g = m >>= (\x -> f x >>= g) 완전히 동치다. 우리는 범주론의 법칙들로부터 함수형 법칙들을 복구할 수 있음을 보였다. 그 반대를 해볼 것. 함수형 법칙들에서 시작해 범주론 법칙들이 성립함을 보여라. 다음 정의들을 기억하면 도움이 될 것이다. join m = m >>= id fmap f m = m >>= return . f 이 연습문제를 제안한 것에 대해 Yitzchak Gale에게 감사한다. 요약 기나긴 여정을 걸어오며 범주란 무엇이고 하스켈에 어떻게 적용되는지 살펴봤다. 범주론의 기본 개념인 펑터와 모나드처럼 좀 더 고급 개념도 소개하고, 이것들이 하스켈의 관용구에 얼마나 중요한지 살펴봤다. 자연 변환(natural transformation)처럼 범주론의 기본이지만 우리의 목적에는 부합하지 않는 것들은 다루지 않았는데, 그 대신 하스켈을 구성하는 범 주론적 기반을 직관적으로 느껴보는 시간을 가졌다. 사실 여기에는 미묘한 점이 있다. (.)는 지연 함수기 때문에 f가 undefined 면 id. f = \_ -> ⊥가 된다. 이게 항상 ⊥와 동치일 것 같지만, 엄격함 강제 함수 seq를 이용해 구분할 수 있다. 즉 마지막 범주론 법칙이 깨진 것이다. 새롭게 엄격한 합성 함수 f .! g = ((.) $! f) $! g를 정의해 Hask를 완벽한 범주로 만들 수도 있지만 일반적인 (.)를 계속 쓰고, 이 같아야 할 것들 사이의 차이는 seq가 많은 언어 성질을 깨뜨리는 탓으로 돌리겠다. ↩ 숙련된 범주론자들은 우리가 여기서 상황을 좀 단순화한다는 것을 눈치챘을 것이다. unit과 join을 자연 변환(natural transformation)으로서 도입하는 대신 사상이라고 취급하고, naturality는 표준 모나드 법칙들(법칙 3과 4)과 함께 추가적인 공리로 내세웠다. 이유는 단순함이다. 우리는 범주론 전체를 가르치려는 것이 아니라 하스켈의 구조의 범 주론적 배경을 설명하려는 것뿐이다. 그리고 이 사상들에 하스켈식 이름을 붙인 것도 와는 그다지 많은 것을 말해주지 않기 때문이다. ↩ 이것은 아마 하스 켈 프로그래머들이 보는 모나드는, 일반적인 특성을<NAME>는 computation들을 나열하는 수단이기 때문이다. 범주론에서는 여러 구조들의 컨테이너라는 관점을 강조한다. join은 컨테이너와 자연스럽게 연결된다. (컨테이너의 두 층을 하나로 합침) 하지만 (>>=)는 자연스러운 나열 연산이다. (무언가를 하고 그 결과를 다른 것에 공급) ↩ 이 법칙들이 성립함을 증명할 수 있다면. 다음 절에서 알아볼 것이다. ↩ 5 Curry-Howard 동형 원문: https://en.wikibooks.org/wiki/Haskell/ThE_Curry%E2% 80% 93Howard_isomorphism 서문 형식논리학 벼락치기 명제(proposition)는 타입이다 ⊥의 문제점 논리 연산들과 그것들의 동치 논리곱(conjunction)과 논리합(disjunction) 거짓성(falsity) 부정(negation) 공리 논리학(axiomatic logic)과 조합 대수(combinatory calculus) 공리 논리학 Combinator calculus 예시 증명들 직관 논리학(intuitionistic logic) 대 고전논리학 Curry-Howard 동형(isomorphism)은 수학의 언뜻 연관 없어 보이는 두 분야인 타입 이론(type theory)과 구조 논리학(structural logic)을 연결하는 매력적인 관계다. 서문 Curry-Howard 동형(앞으로 CH로 축약)은 어떤 수학적 정리를 증명하려면 그 이론의 본질을 반영하는 타입을 구축하고 그 타입을 가지는 값을 찾기만 하면 된다고 주장한다. 처음 보면 이것은 굉장히 이상해 보인다. 타입과 정리가 무슨 상관이란 말인가? 앞으로 보겠지만 이 둘은 밀접하게 연관되어 있다. 시작하기 전에 잠깐, 여기 입문 단락들에서는 error나 undefined처럼 표기 의미론이 ⊥인 표현식들의 존재를 무시한다. 이것들의 역할은 중대하지만 나중에 따로 다룰 것이다. 그리고 unsafeCoerce#처럼 타입 시스템을 우회하는 함수들도 무시한다. 하스켈의 고차 함수를 이용하면 놀랍도록 복잡한 타입을 만들 수 있다. 그러면 임의의 타입이 주어졌을 때 어떤 조건 하에서 그 타입을 가지는 값이 존재할까? (그런 타입은 점유되었다고 inhabited 칭한다) 언뜻 보면 '항상' 존재할 것 같지만 몇 가지 예시 하에서 바로 무너진다. 예를 들어 타입이 a -> b인 함수는 없는데, a 타입의 무언가를 완전히 별개의 b 타입의 무언가로 변환하는 방법은 없기 때문이다. (타입 a와 b가 무엇인지 미리 알고 있지 않는 한. ord :: Char -> Int 같은 단형 함수가 그런 경우다.) 놀랍게도 타입이 수리논리학의 어떤 정리에 대응할 때만 그 타입은 점유된다는 사실은 이미 밝혀졌다. 이런 대응 관계의 본질은 무엇일까? a -> b 같은 타입이 논리학 문맥에서 어떤 의미를 가질까? 형식논리학 벼락치기 형식논리학과 타입 이론의 관계를 탐험하기 전에 먼저<NAME>논리학에 대한 배경지식을 조금 알아야 한다. 여기서 하는 것은 아주 간략한 소개다. 더 기반을 다지려면 이 주제에 대한 입문 교재를 읽어볼 것을 추천한다. 일상 언어에서 우리는 '만약... 그렇다면...' 같은 문장을 자주 사용한다. 예를 들면 '만약 오늘 날씨가 맑으면 도시까지 걸어가야지.' 같은 게 있다. 수학에서도 이런 종류의 문장이 등장한다. '만약 x가 양수라면 (실수) 제곱근을 가진다' 같은 것이 그렇다.<NAME> 논리는 영어 뜻을 근사하는 문장을 계산 가능 불리언 논리로 표현하는 수단이다. A → B ('A가 B를 함의한다'라고 읽음)은 A가 참이면 항상 B도 참이라는 뜻이다. 예를 들어 위의 문장은 'x가 양수 → x는 실수 제곱근을 가짐'이라고 다시 쓸 수 있다. 이것이 뜻하는 바는 그 수의 양수성(positivity)이 우리가 원하는 종류의 근이 존재함을 함의한다는 것이다. 앞으로 문장 전체를 지칭하기 위해 문자를 자주 쓸 것이다. 예를 들어 W가 '날씨가 좋다'라는 문장이고 T가 '도시까지 걸어간다'라는 문장이면 W → T라고 쓸 수 있다. P → Q에 대한 이 정의는 결함이 있다. Q가 항상 참인 문장이면 조건이 무엇이든('태양은 뜨겁다'처럼) 상관이 없으며 그러면 P가 무엇인지도 상관이 없다. 심지어 P가 거짓인 문장이어도 Q는 여전히 참이며 따라서 P → Q는 틀릴 일이 없다. P가 거짓이고 Q가 참이면 P → Q는 참으로 정의된다. 따라서 →는 실제로는 원인-결과 관계를 나타내지 않는다. '하늘이 분홍색이다 → 태양은 뜨겁다' 같은 것도 참으로 정의된다. 불리언 논리 외에도 이런 "문제점"1을 고치려 시도하는 다른 논리 대수들이 있으며 하스켈에서는 그 모든 것을 구현할 수 있다. 논리곱(conjunction)과 논리합(disjunction) 역시 일상 언어와 수학 양쪽에서 흔하게 등장한다. 전자는 '그리고'를 수반하는 문장을 표현하고 후자는 '또는'을 수반하는 문장을 표현한다. '나는 이 잡지의 재고가 있고 내게 돈이 충분하다면 이 잡지를 구매할 것이다'라는 문장을 ( ∧ ) B 으로 표현할 수 있는데, 여기서 M = '나는 돈이 충분하다', S = '잡지의 재고가 있다', B = '나는 이 잡지를 구매할 것이다'이다. 여러분은 기호를 단순히 '그리고'라고 읽을 수 있다. 비슷하게 기호는 '또는'이라고 읽을 수 있다. 따라서 '나는 출근하기 위해 걷거나 기차를 타거나 둘 다 할 것이다'라는 문장은 ∨으로 표현할 수 있는데 여기서 W = '나는 걸어서 출근한다', T = '나는 기차를 타고 출근한다'이다. 이런 기호들과 앞으로 나올 기호들을 활용하면 임의의 복잡한 기호열을 만들어낼 수 있다. 이런 기호열은 두 종류로 나뉜다. 하나는 참인 문장을 나타내며 정리 theorem라고도 한다. 거짓 문장을 나타내는 것들은 비정리nontheorem라고 부른다. 기호열이 정리인지 비정리인지는 문자들이 무엇을 뜻하는지에 따라 달라진다는 것에 주의하라. 예를 들어 P가 '지금은 낮이다'라는 문장을, Q는 '지금은 밤이다'라는 문장을 나타낸다면(낮과 밤의 중간지대는 무시하자) ∨는 정리다. 하지만 P가 '나무는 파랗다'이고 Q는 '모든 새는 날 수 있다'라면 비정리다. 기호열이 정리인지 아닌지 모를 때는<NAME> proposition라고도 부른다. 논리학의 주제에는 더욱 미묘한 것들이 많다. (가령 우리가 '네가 저녁을 먹는다면 디저트를 받을 것이다'라고 말하는 것은 사실은 '오직 저녁을 먹는 경우에만 디저트를 받을 것이다'를 뜻하는 것이다.) 이런 주제에 흥미가 동한다면 이 주제를 폭넓게 다루는 교재가 많이 있다. 명제(proposition)는 타입이다 그래서 기호논리학에서는 타입 a -> b이 무엇을 뜻하는 걸까? 편리하게도 그 뜻은 단순히 a → b이다. 물론 이것은 a와 b가 기호논리학에서 해석 가능한 타입일 때만 말이 된다. 이것이 CH의 본질이다. 앞서 언급했듯이 a → b가 정리일 필요충분조건은 a -> b가 점유 타입(inhabited type)이라는 것이다. 하스켈의 가장 단순한 함수 중 하나인 const를 통해 알아보자. const의 타입은 a -> b -> a이다. 논리학에서는 a → b → a가 된다. 이것은 정리임이 분명한데, 타입 a -> b -> a은 const라는 값에 의해 점유되기 때문이다. a → b를 표현하는 또 다른 방법이 있다. 'a가 참이라고 가정한다면 b는 반드시 참이어야 한다'. 즉 a → b → a는 a가 참이라고 가정하고 더 나아가 b가 참이라고 가정한다면 a라고 결론 내릴 수 있음을 뜻한다. 이것은 물론 정리다. 우리는 a를 가정했으므로 우리의 가정 하에서 a는 참이다. ⊥의 문제점 앞서 타입은 점유되는 경우에만 정리에 대응한다고 언급했다. 그런데 하스켈에서 모든 타입은 값 undefined에 의해 점유된다. 더 나아가 모든 forall a. a 타입에 대해 ⊥의 표기 의미론을 가지는 값은 문제가 된다. 타입 이론에서 ⊥는 논리 내의 비일관성 inconsistency에 대응한다. 하스 켈 타입을 이용하면 어떤 정리든 증명할 수 있는데, 모든 타입은 점유되기 때문이다. 그러므로 하스켈의 타입 시스템은 사실은 비일관적 논리 체계에 대응한다. 하지만 하스 켈 타입 시스템의 한정된 하위 집합만 다루면, 특히 다 형(polymorphic type)을 금지하면 일관된 논리 체계를 얻게 되며 그 안에서 멋진 일들을 할 수 있다. 앞으로는 그런 타입 시스템을 다루고 있다고 가정한다. 이제 CH의 기본을 알게 되었으니 타입과<NAME>의 관계를 좀 더 풀어헤칠 수 있다. 논리 연산들과 그것들의 동치 기호 논리의 정수는 일련의<NAME>들, 가령 P와 Q, 이것들을 Q → P 또는 ∨ P Q 처럼 합성하는 방법들이다.<NAME>들의 합성은<NAME>에 대한 연산으로 볼 수 있다. CH에 따르면<NAME>는 타입에 대응하므로 이런<NAME> 합성자들에 대한 CH 대응은 타입 연산들, 좀 더 일반적으로 타입 생성자라고 알려진 것들이다. 그 예시는 이미 봤었다. 논리에서의 함의 연산자 →는 타입 생성자 (->)에 대응한다. 이번 절에서는 다른<NAME> 합성자들과 그것들의 대응을 살펴본다. 논리곱(conjunction)과 논리합(disjunction) ∧ A B 가 정리(theorem)이려면 A와 B는 반드시 정리여야 한다. 따라서 ∧ A B 의 증명은 A와 B를 모두 증명하는 것에 달렸다.<NAME> A를 증명하려면 A 타입의 값을 발견해야 한다. 여기서 A와 A는 CH 대응이다. 이 경우 두 하위 값(sub-value)을 포함하는 값을 발견해야 한다. 하나는 그 타입이 A에 대응하고 다른 하나의 타입은 B에 대응한다. 이건 마치 쌍(pair)을 말하는 것 같다. 다름이 아니라 기호열 ∧ A B 를 (a, b)로 표현할 것이다. 여기서 a는 A에 b는 B에 대응한다. 논리합은 논리곱의 정반대다. ∨ A B 가 정리가 되려면 A 또는 B가 정리여야 한다. 이번에는 A 타입의 값 또는 B 타입의 값을 포함하는 값을 탐색한다. 이는 Either다. Either A B는<NAME> ∨ A B 에 대응하는 타입이다. 거짓성(falsity) 논리 체계에 거짓문(false statement)을 도입하면 유용한 경우가 많다. 정의에 따르면 거짓문은 증명할 수 없는 문장이다. 따라서 우리가 찾는 것은 점유될 수 없는 타입이다. 기본 라이브러리에는 그런 타입이 존재하지 않지만 (정확히 하나의 값을 가지는 () 타입과 혼동하지 말자) 그런 타입을 직접 정의할 수 있다. (Haskell2010을 지원하지 않는 이전 버전의 GHC에서는 -XEmptyDataDecls 플래그를 켜야 한다) data Void 생성자를 생략하는 것은 Void가 점유되지 않는 타입임을 뜻한다. Void 타입은 우리의 논리에서 비정리에 대응한다. 여기에는 몇 가지 따름 정리(corollary)가 있다. 모든 타입 A에 대해 (Void, A)와 (A, Void)는 점유되지 않는 타입이며 이는 F가 비정리면 ∧ F A A F ∧ 가 비정리라는 사실에 대응한다. 모든 타입 A에 대해 Either Void A와 Either A Void는 본질적으로 A와 동일하다.2 이는 비정리 F에 대해 ∨ F A A F ∨ 가 정리일 필요충분조건은 A가 정리라는 사실에 대응한다. 비정리에 대응하는 모든 타입은 Void로 대체할 수 있다. 비정리 타입은 점유되지 않아야 하며 따라서 그런 것을 Void로 대체해도 아무것도 바뀌지 않기 때문이다. Void는 모든 비정리 타입과 동치다. 3 첫 번째 절에서 언급했듯이 Q가 참이면 함의 P → Q는 P의 진위에 무관하게 참이다. 따라서 우리는 Void -> a 타입의 항을 찾을 수 있어야만 한다. 그런 것이 존재하기는 하지만 설명하기가 복잡하다. 그 답은 공함수(empty function) 다. 함수 f :: A -> B는 첫 번째 원소가 A의 원소(정의역)이고 두 번째 원소가 f의 출력 즉 B의 원소(공역)인 쌍들의 (아마 무한일) 집합으로서 정의할 수 있다. 예를 들어 자연수에 대한 연속함수(successor function)는 {(0,1), (1,2), (2,3), ...}으로 표현된다. (완전하고 잘 정의된) 함수가 되려면 A 타입의 각 항 a에 대해 (a, f a)가 정확히 하나만 있어야 한다. 공함수 empty가 이런 식으로 공집합으로 표현된다고 치자. 하지만 정의역의 각 원소에 대해 하나의 쌍이 있어야 하고, 우리의 표현법에는 아무 쌍도 없기 때문에 정의역 타입도 비어있어야 한다. 즉 Void 여야 한다. 치역의 타입은 어떨까? empty는 아무것도 출력하지 않으므로 치역 타입에 대해서는 아무런 제약도 없다. 그러므로 치역의 타입은 아무 타입이나 가능하다고 가정해도 합당하고 empty :: forall a. Void -> a라고 말할 수 있다. 불행히도 이런 함수는 하스 켈로 작성할 수 없다. 이상적으로는 이런 것을 원하지만, empty :: Void -> a 잠깐, 하스켈에서 이것은 올바르지 않다. 다음이 그나마 가장 비슷한 것이다. empty :: Void -> a empty _ = undefined 아니면 이런 것도 있다. empty :: Void -> a empty = empty 또 다른 합리적인 방법은 이렇게 쓰는 것이다. (EmptyCase 확장을 쓰면 GHC에서 올바르다) empty x = case x of { } 이 case 문은 완벽히 well-formed인데, x의 모든 가능한 값을 처리하기 때문이다. 이 함수의 우변은 절대 도달할 수 없기 때문에 (아무것도 전달하지 않기 때문에) 이것은 완벽히 안전하다. 이 모든 것의 결론은 P가 거짓이면 P → Q가 참인 것과 마찬가지로 Void -> a 가 점유된 타입이라는 것이다. 부정(negation) 논리의 ¬ 연산은 정리와 비정리를 서로 변환한다. A가 정리면 ¬ A는 비정리다. A가 비정리면 ¬ A는 정리다. 이것을 하스 켈로 어떻게 표현할까? 그 답은 교묘하다. 다음과 같은 타입 동의어를 정의한다. type Not a = a -> Void 타입 A에 대해 Not A는 단지 A -> void이다. 이게 어떻게 작동하는 걸까? A가 정리-타입이면 A -> Void는 점유되지 않아야 한다. 그런 함수가 값을 반환할 방법은 없다. 리턴 타입인 Void는 값을 가지지 않기 때문이다! (그런 함수는 A의 모든 inhabitant에 대해 값을 제공해야 한다) 반면 A가 비정리면 앞절에서 연구했듯이 A는 Void로 대체할 수 있다. 그러면 함수 id :: Void -> Void는 Not A의 inhabitant이므로 Not A는 요구대로 정리가 된다. (이 함수는 아무 값도 제공할 필요가 없는데, 정의역에 inhabitant가 하나도 없기 때문이다. 그럼에도 이것은 함수가 맞다) 공리 논리학(axiomatic logic)과 조합 대수(combinatory calculus) 지금까지는 하스켈의 타입 시스템의 아주 기초적인 특징들만을 활용했다. 사실 우리가 지금까지 언급한 논리의 대부분 특징은 아주 기초적인 '프로그래밍 언어'인 combinator calculus를 통해서도 알아볼 수 있다. CH가 수학의 이 두 영역을 얼마나 밀접하게 엮는지 완전히 이해하려면 우리의<NAME>논리에 대한 논의와 프로그래밍 언어에 대한 논의를 공리화(axiomatise) 해야 한다. 공리 논리학 → 연산이 어떻게 행동해야 하는지에 대한 공리 두 개로 시작한다. (지금부터 →가 우결합 함수라고 가정한다. 즉 A → B → C는 A → (B → C)를 의미한다. A → B → A (A → B → C) → (A → B) → A → C 첫 번째 공리는 두<NAME> A와 B가 주어질 때 A와 B 모두 참이라고 가정하면 A는 참이라는 것이다. 두 번째 공리는 B가 C를 함의한다는 것을 A가 함의하면 (달리 말하면 A와 B가 참일 때 항상 C가 참이라면) A 자체는 B를 함의하므로, A가 참임을 알면 C가 참이라고 결론을 내리기에 충분하다. 복잡하게 들리지만 조금 생각해 보면 상식적이다. 여러 색깔의 상자 모음이 있는데 그중에는 바퀴가 달린 것도 있고 뚜껑이 달린 것도 있다고 상상해 보자. 바퀴가 달린 빨간 상자라면 뚜껑도 있는데, 모든 빨간 상자는 바퀴가 달려있다. 상자를 하나 고른다. A = '이 상자는 빨간색이다', B = '이 상자는 바퀴가 달렸다', C = '이 상자는 뚜껑이 달렸다'라고 하면 두 번째 법칙은 이렇게 된다. A → B → C (바퀴가 달린 모든 빨간 상자는 뚜껑도 달렸다)와 A → B(모든 빨간 상자는 바퀴가 달렸다)가 성립하므로, A(상자가 빨갛다) 면 C(상자에 뚜껑이 달렸다)도 반드시 참이다. 여기에 더해 긍정 논법(modus ponens)이라는 추론 법칙을 허용한다. 만약 A → B 이면, 그리고 A라면, 그러므로 B이다. 이 법칙은 기존 정리를 가지고 새 정리를 만드는 것을 가능케 한다. 이것의 의미는 꽤나 명백하고 본질적으로 → 가 무슨 뜻인가에 관한 정의다. 이 작은 기반이 우리의 논의 대부분을 표현하기에 충분하면서도 간단한 논리 체계를 생성한다. 다음은 우리의 논리 체계에서 법칙 A → A를 증명하는 예시다. 우리는 정리의 두 공리를 알고 있다. A → B → A (A → B → C) → (A → B) → A → C 두 번째 공리의 좌변은 첫 번째 공리와 비슷해 보인다. 두 번째 공리는 A → B → C 임을 알고 있다면 (A → B) → A → C라고 결론 내릴 수 있음을 보장한다. 여기서 C를 A와 동일한<NAME>로 두면, '만약 A → B → A 이면 (A → B) → A → A이다'가 된다. 그런데 A → B → A는 이미 알고 있듯이 첫 번째 공리다. 그러므로 (A → B) → A → A는 정리다. 또 다른<NAME> C에 대해 B를<NAME> C → A으로 설정하면 '만약 A → C → A 이면 A → A이다'가 된다. 이번에도 A → C → A (역시 첫 번째 공리)임은 알고 있으므로 A → A 가 성립하고 우리가 원하던 대로 된다. 위 예시는 간단한 공리들 그리고 기존 정리로부터 새 정리를 만들어내는 간단한 수단이 주어지면 더 복잡한 정리들을 유도할 수 있음을 시사한다. 거기까지 가기에는 시간이 많이 걸릴 것이다. 여기서는 A → A 가 정리라는 명백한 문장을 증명하는데도 몇 줄에 걸친 추론이 필요했다. 하지만 결국에는 목적을 이뤘다. 이런<NAME> 화가 매력적인 이유는 우리가 매우 간단한 체계를 정의했고 그래서 그 체계가 어떻게 작동하는지 연구하기도 아주 쉽기 때문이다. Combinator calculus 람다 대수는 매우 간단한 기저로부터 간단한 프로그래밍 언어를 정의하는 수단이다. 링크된 문서를 읽지 않았다면 최소한 untyped 대수를 소개하는 절은 읽는 것을 추천한다. Here's a refresher in case you're feeling dusty. 람다 항은 다음 셋 중 하나다. 값 v 람다 추상 x t x t , 여기서 t는 또 다른 람다 항 적용 ( 1 2 ) ( 1 2 ) , 여기서 1 t는 람다 항 베타-소거(beta-reduction)라는 소거 법칙도 하나 있다. ( ( x t) 2 ) t [ := 2 ] 1 [ := 2 ] , 여기서 1 [ := 2 ] 1 [ := 2 ] 는 x의 모든 free occurrence를 가지는 1 t으로 대체됨을 뜻한다. (??) 람다 대수 문서에서 언급하듯이 식별자의 free occurence라는 개념을 이해하는 것이 난관이다. (바로 어떤 프로그래밍 언어의 유래인) 미국 수학자 Haskell Curry는 그런 난관 때문에 combinator 대수를 발명했다. 기초적인 combinator 대수의 변종이 많지만 여기서는 가장 간단한 것 중 하나를 살펴본다. combinator라 부르는 것이 2개 있다. K는 값 두 개를 취해서 첫 번째 값을 반환한다. 람다 대수에서는 = x . x 이다. S는 이항 함수, 단항 함수, 값 하나를 취해서 그 값과 그 값을 단항 함수에 적용한 값 이렇게 두 값을 이항 함수에 적용한다. 람다 대수에서는 = x z x ( z ) 이다. 첫 번째 함수는 const다. 두 번째는 더 복잡한데 ((->) e) 모나드에서의 모나 딕 함수 ap이다. (즉 Reader다) 이 두 combinator가 람다 대수 전체를 위한 완전한 기저를 형성한다. 모든 람다 대수 프로그램은 이 두 함수를 이용해 작성할 수 있다. 예시 증명들 원문 없음 직관 논리학(intuitionistic logic) 대 고전논리학 지금까지 우리가 증명한 모든 결과는 직관 논리학의 정리들이다. 고전논리학의 기초 정리 Not Not A -> A를 증명하려 하면 어떤 일이 일어나는지 보자. 이것은 ((A -> Void) -> Void) -> A으로 번역된다. 따라서 우리는 A -> Void) -> Void 타입의 함수가 주어질 때 A 타입의 함수가 필요하다. 타입 A -> Void가 점유되지 않았다면, 즉 타입 A가 점유되지 않았다면 (A -> Void) -> Void 타입의 함수가 존재한다. 그러므로 임의의 점유된 타입을 취해서 그 타입의 원소를 반환하는 함수가 필요하다. 컴퓨터에서는 간단한 일이다. 그 타입의 "가장 간단한" 또는 "첫 번째" inhabitant를 찾으면 된다. 표준 람다 대수 또는 combinator 기법에는 그런 수단이 없다. 그래서 이 두 기법으로는 이런 결과를 증명할 수 없고 그 기저의 논리는 고전적이 아니라 직관적이다. 대신 오류가 발생하면 throw를 호출해서 computation을 catch로 전달하는 고전적인 오류 처리 함수를 살펴보자. throw 함수는 원래 함수의 모든 반환값을 취소하므로 A -> Void 타입을 가진다. 여기서 A는 그 인자의 타입이다. catch 함수는 throw 함수를 인자로 취하고 throw가 발동하면(즉 Void를 반환하면) throw 함수의 인자를 반환한다. 따라서 catch의 타입은 ((A -> Void) -> Void) -> A이다. 이에 대한 또 다른 관점은 우리가 논리 연산자 → 가 자연어의 "만약... 그렇다면" 구조에 대한 우리의 직관을 포착하도록 정의하려 시도하고 있다는 것이다. 우리는 가령 자연수 x에 대해 "x는 짝수" → "x+1은 홀수"가 참 같은 문장을 원한다. 즉 그 함의는 x를 아무 자연수, 가령 5로 치환해도 성립해야 한다. 하지만 "5는 짝수"와 "6은 홀수"는 둘 다 거짓이므로 False → False는 참이어야 한다. 비슷하게 모든 자연수 x > 3에 대해 "x가 소수" → "x+1은 소수가 아니다" 같은 문장을 고려하면 False → True로 참이어야 한다. 당연하지만 True → True는 참이어야 하고 True → False는 거짓이어야 한다. 따라서 x → y는 x가 참이고 y가 거짓인 경우를 제외하면 성립한다. ↩ 엄밀히는 Either Void A 타입과 A 타입은 동형(isomorphic)이다. Void 타입의 값을 가질 수는 없으니 Either Void A 타입의 모든 값은 Right가 붙는 값이어야 하고 따라서 변환 과정에서 Right 생성자를 제거하게 된다. ↩ 역시 엄밀하게 말하면 Void는 비정리인 모든 타입과 동형이다. ↩ 이 논의는 Dan Piponi. "Adventures in Classical Land". The Monad Reader (6)에서 가져온 것이다. ↩ 6 Fix와 재귀 원문: https://en.wikibooks.org/wiki/Haskell/Fix_and_recursion fix 소개 fix와 고정점 재귀 형식 람다 대수 데이터 타입으로서의 fix fix 함수를 처음 보면 기이하고 쓸데없는 것으로 보인다. 하지만 fix의 존재에는 이론적인 근거가 있다. (형식) 람다 대수에 fix를<NAME>으로서 도입하면 재귀 함수를 정의할 수 있게 된다. fix 소개 fix는 다음과 같이 단순하게 정의된다. fix :: (a -> a) -> a fix f = let {x = f x} in x 조금... 마술 같지 않은가? fix f는 f를 무한히 중첩 적용해서 x = f x = f (f x) = f (f (f ( ... )))가 되지 않는가? 이것은 지연 평가에 의해 해결된다. f를 무한히 적용하는 것을 회피할 필요충분조건은 f가 게으른 함수라는 것이다. 예시를 보자. 예제: fix 예시들 Prelude> :m Control.Monad.Fix Prelude Control.Monad.Fix> fix (2+) -- Example 1 *** Exception: stack overflow Prelude Control.Monad.Fix> fix (const "hello") -- Example 2 "hello" Prelude Control.Monad.Fix> fix (1:) -- Example 3 [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, ... 먼저 Control.Monad.Fix 모듈을 들여와서 fix를 스코프 안으로 가져온다. (Data.Function 모듈도 fix를 내보낸다) 그다음 세 가지 예시를 시도한다. 첫 번째 예시에서 실제로 무슨 일이 일어나는지 살펴보자. -- fix f = let {x = f x} in x fix (2+) = let {x = 2 + x} in x = let {x = 2 + x} in 2 + x = let {x = 2 + x} in 2 + (2 + x) = let {x = 2 + x} in 2 + (2 + (2 + x)) = let {x = 2 + x} in 2 + (2 + (2 + (2 + x))) = ... 첫 번째 예시는 적극적 함수인 (+)를 사용한다. (+)는 먼저 x의 값을 요구한다... x의 값을 계산하기 위해 말이다. 따라서 이 계산은 절대 멈추지 않는다. 두 번째 예시를 보자. fix (const "hello") = let {x = const "hello" x} in x = "hello" 여기서는 상황이 사뭇 다르다. fix를 한번 전개하면 평가가 끝나는데, const는 두 번째 인자를 무시하기 때문이다. 마지막 예시의 평가는 조금 다르지만 비슷한 방식으로 전개할 수 있다. fix (1:) = let {x = 1 : x} in x = let {x = 1 : x} in 1 : x 여기서 1 : x는 이미 WNHF이므로((:)는 게으른 데이터 생성자) 전개가 멈춘다. 이는 순환 구조를 형성한다. 소비자 함수가 이 리스트의 새 원소를 요청할 때마다 x의 정의를 찾아보게 되는데 그것은 이미 1 : x임이 알려져 있다. 그러므로 이 리스트의 원소들을 하나씩 요청하면 끝없이 매번 1을 반환한다. 따라서 take 10 (fix (1:))는 1을 10개 가지는 리스트를 생성하지만 GHCi에 fix (1:)을 입력해서 모든 원소를 출력하려 하면 끝없는 1의 수열이 출력된다. 이 경우 실제로는 show (fix (1:)) = "[" ++ intercalate "," (map show (fix (1:))) ++ "]"의 평가를 일으키고 map show (fix (1:))는 절대 종료하지 않지만 그 출력을 점진적으로 만들어내어 한 번에 하나씩 "1"을 산출한다. "[" ++ intercalate "," (map show (fix (1:))) ++ "]" = "[" ++ intercalate "," (map show (let {x = 1 : x} in x)) ++ "]" = "[" ++ intercalate "," (map show (let {x = 1 : x} in 1 : x)) ++ "]" = "[" ++ "1" ++ "," ++ intercalate "," (map show (let {x = 1 : x} in x)) ++ "]" = "[1, " ++ intercalate "," (map show (let {x = 1 : x} in 1 : x)) ++ "]" = "[1, " ++ "1" ++ "," ++ intercalate "," (map show (let {x = 1 : x} in x)) ++ "]" = "[1,1, " ++ intercalate "," (map show (let {x = 1 : x} in 1 : x)) ++ "]" = "[1,1, " ++ "1" ++ "," ++ intercalate "," (map show (let {x = 1 : x} in x)) ++ "]" = "[1,1,1, " ++ intercalate "," (map show (let {x = 1 : x} in 1 : x)) ++ "]" = ... 여기서는 지연 평가가 작동하고 있다. 출력하는 함수는 출력을 시작하기 전에 입력 문자열 전체를 소비하지 않아도 된다. 출력을 시작할 수 있는 만큼만 소비하면 된다. 마지막으로 다음은 숫자의 제곱근을 반복적으로 근사하는 것이다. -- fix f = let {x = f x} in x fix (\next guess tol val -> if abs(guess^2-val) < tol then guess else next ((guess + val / guess) / 2.0) tol val) 2.0 0.0001 25.0 = (let {next = (\next guess tol val -> if abs(guess^2-val) < tol then guess else next ((guess + val / guess) / 2.0) tol val) next} in next) 2.0 0.0001 25.0 = let {next guess tol val = if abs(guess^2-val) < tol then guess else next ((guess + val / guess) / 2.0) tol val} in next 2.0 0.0001 25.0 = 5.000000000016778 연습문제 다음 표현식들은 수렴한다면 무엇에 수렴하는가? fix ("hello"++) fix (\x -> cycle (1:x)) fix reverse fix id fix (\x -> take 2 $ cycle (1:x)) fix와 고정점 함수 f의 고정점은 f a == a인 값 a이다. 예를 들어 0은 함수 ( * 3)의 고정점인데 0 * 3 == 0이기 때문이다. fix의 이름은 여기서 유래한다. fix는 함수의 최소 정의 고정점(least-defined fixed point)을 발견한다. ("최소 정의"의 뜻은 곧 알아볼 것이다) 앞서 언급한 수렴하는 두 예시의 경우 이를 쉽게 알아볼 수 있다. const "hello" "hello" = "hello" (1:) [1,1, ..] = [1,1, ...] 그리고 2+x == x인 숫자 x 같은 것은 없기 때문에 fix (2+)는 발산한다고 말할 수 있다. 연습문제 위 연습문제에서 fix f가 수렴한다고 판단한 각 함수 f에 대해 fix f가 고정점을 찾는다는 것을 검증하라. 사실 fix가 고정점을 찾는다는 것은 fix의 정의를 보면 명백하다. 우리가 할 일은 fix의 등식을 다르게 쓰는 것뿐이다. f (fix f) = fix f 이는 다름 아닌 고정점의 정의다. 따라서 fix가 항상 고정점을 찾아야 할 것처럼 보인다. 그런데 가끔은 fix가 그러는 것을 실패하는데, 발산하는 경우가 있기 때문이다. 표기 의미론을 조금 도입하면 이 성질을 고칠 수 있다. 모든 하스 켈 타입은 bottom이라 부르고 ⊥로 표기하는 특별한 값을 포함한다. 즉 Int 타입은 1, 2, 3 같은 값뿐만 아니라 ⊥도 포함한다. 발산하는 계산은 ⊥의 값으로 표기된다. 즉 fix (2+) = ⊥이다. 특별한 값인 undefined도 ⊥에 의해 표기된다. 이제 fix가 어떻게 (2+) 같은 함수의 고정점을 찾는지 이해할 수 있다. 예시: (2+)의 고정점 Prelude> (2+) undefined *** Exception: Prelude.undefined (2+)에 undefined(즉 ⊥)을 넣으면 undefined를 돌려받는다. 따라서 ⊥는 (2+)의 고정점이다. (2+)의 경우에는 ⊥가 유일한 고정점이다. 그런데 fix f가 발산해도 여러 고정점을 가지는 그런 함수 f들이 있다. fix (*3)은 발산하지만 앞서 봤듯이 0은 이 함수의 고정점이다. 여기서 "최소 정의"가 등장한다. 하스켈에서 타입들은 definedness라는 부분 순서를 가진다. 어떤 타입이든 ⊥는 최소 정의 값이다. (그래서 "bottom"이라 부르는 것이다) Int 같은 단순한 타입의 경우 부분 순서를 가지는 유일한 쌍들은 ⊥ ≤ 1, ⊥ ≤ 2 등이다. bottom이 아닌 임의의 Int 값 m, n에 대해 m ≤ n를 만족하는 경우는 없다. 비슷한 논지가 Bool이나 () 같은 기타 단순 타입들에도 적용된다. 리스트나 Maybe처럼 "계층적인" 값들은 상황이 더 복잡하며 이에 관해서는 표기 의미론에서 다룬다. ⊥가 모든 타입의 최소 정의 값이고 fix는 최소 정의 고정점을 발견하므로 f ⊥ = ⊥라면 fix f = ⊥이고 그 역도 참이다. 표기 의미론 페이지를 읽었다면 이것이 엄격한 함수를 위한 기준임을 알아챘을 것이다. fix f가 발산할 필요충분조건은 f가 엄격하다는 것이다. 재귀 이미 fix에 관한 예제들을 본 적이 있다면 아마 fix와 재귀에 관한 예제였을 것이다. 다음은 고전적인 예제다. 예시: fix를 이용한 재귀 표현 Prelude> let fact n = if n == 0 then 1 else n * fact (n-1) in fact 5 120 Prelude> fix (\rec n -> if n == 0 then 1 else n * rec (n-1)) 5 120 여기서는 fix를 사용해 팩토리얼 함수를 "표현"했다. fact의 두 번째 정의는 (fix를 언어<NAME> 취급하면) 재귀를 전혀 포함하지 않는 것에 주목하라.<NAME> 람다 대수 같은 언어에서는 이것이 재귀가 아니며 fix를 도입해 이런 식으로 재귀 함수를 작성할 수 있다. 다음은 추가적인 예제들이다. 예시: 추가적인 fix 예제들 Prelude> fix (\rec f l -> if null l then [] else f (head l) : rec f (tail l)) (+1) [1.. 3] [2,3,4] Prelude> map (fix (\rec n -> if n == 1 || n == 2 then 1 else rec (n-1) + rec (n-2))) [1.. 10] [1,1,2,3,5,8,13,21,34,55] 이것이 어떻게 동작하는 걸까? fact 함수를 표기의 관점에서 접근해 보자. 간결함을 위해 이렇게 정의한다. fact' rec n = if n == 0 then 1 else n * rec (n-1) 이것은 익명 함수에 이름을 부여한 것을 빼면 첫 번째 예제의 함수와 같다. 이제 fix fact' 5를 계산할 수 있게 되었다. fix는 fact'의 고정점 즉 f == fact' f인 함수 f를 찾을 것이다. 이게 무슨 뜻인지 전개해 보자. f = fact' f = \n -> if n == 0 then 1 else n * f (n-1) 여기서 한 것은 fact'의 정의에서 rec을 f로 치환한 것뿐이다. 그런데 이것은 바로 팩토리얼 함수의 재귀적 정의처럼 보인다. fix는 fact' 그 자체를 첫 번째 인자로 공급해서 고차 함수로부터 재귀 함수를 만들어낸다. 명령형 관점에서 접근해 볼 수도 있다. fix fact'의 정의를 실제로 전개해 보자. fix fact' = fact' (fix fact') = (\rec n -> if n == 0 then 1 else n * rec (n-1)) (fix fact') = \n -> if n == 0 then 1 else n * fix fact' (n-1) = \n -> if n == 0 then 1 else n * fact' (fix fact') (n-1) = \n -> if n == 0 then 1 else n * (\rec n' -> if n' == 0 then 1 else n' * rec (n'-1)) (fix fact') (n-1) = \n -> if n == 0 then 1 else n * (if n-1 == 0 then 1 else (n-1) * fix fact' (n-2)) = \n -> if n == 0 then 1 else n * (if n-1 == 0 then 1 else (n-1) * (if n-2 == 0 then 1 else (n-2) * fix fact' (n-3))) = ... fix를 사용했기 때문에 fact'의 정의를 "풀어헤칠" 수 있다. else 절을 마주칠 때마다 평가 규칙 fix fact' = fact' (fix fact')을 통해 fact'의 또 다른 사본을 만들어내면 재귀 사슬에서 그다음 호출로서 기능한다. 결국 then 절에 도달해서 이 연쇄의 끝에 도달한다. 연습문제 다른 두 예시를 이런 식으로 전개하라. 피보나치 예시는 종이가 많이 필요할 것이다. filter와 foldr의 비재귀적 버전을 작성하라. 형식 람다 대수 이번 절에서는 앞선 절에서 몇 차례 언급했던 사항인, fix가<NAME> 람다 대수에서 어떻게 재귀를 표현하는지를 자세히 알아본다. 여러분이<NAME> 람다 대수를 알고 있다고 가정하겠다. 람다 대수에는 let 절도 최상위 바인딩도 없다. 모든 프로그램은 람다 추상화, 적용, 리터럴의 단순 트리다. 이제 fact 함수를 작성해 보자. 자연수를 위한 Nat이라는 타입을 가정하면 이렇게 시작할 수 있다. λ n:Nat. if iszero n then 1 else n * <blank> (n-1) 문제는 <blank>를 어떻게 채울 것인가다. 우리의 함수에는 이름이 없으므로 재귀 호출할 수가 없다. 항에 이름을 묶는 유일한 방법은 람다 추상화를 사용하는 것이다. 한번 해보자. (λ f:Nat → Nat. λ n:Nat. if iszero n then 1 else n * f (n-1)) (λ m:Nat. if iszero m then 1 else m * <blank> (m-1)) 이렇게 전개된다. λ n:Nat. if iszero n then 1 else n * (if iszero n-1 then 1 else (n-1) * <blank> (n-2)) 여전히 <blank>가 남아있다. 한 계층을 더 추가해 보자. (λ f:Nat → Nat. λ n:Nat. if iszero n then 1 else n * f (n-1) ((λ g:Nat → Nat. λ m:Nat. if iszero m then 1 else m * g (m-1)) (λ p:Nat. if iszero p then 1 else p * <blank> (p-1)))) -> λ n:Nat. if iszero n then 1 else n * (if iszero n-1 then 1 else (n-1) * (if iszero n-2 then 1 else (n-2) * <blank> (n-3))) 이름을 몇 계층을 추가해도 이 <blank>를 영원히 제거할 수 없는 것이 명백하다. fix를 사용하지 않는 한 절대 불가능하다. fix는 개체를 제공하며, 우리는 이 개체를 통해 재귀를 한 층 풀어헤치고도 기존에 있던 것을 유지할 수 있다. fix (λ f:Nat → Nat. λ n:Nat. if iszero n then 1 else n * f (n-1)) 이것은<NAME> 람다 대수에 fix를 추가해서 얻은 완벽한 팩토리얼 함수다. fix는<NAME> 람다 대수의 문맥을 벗어나면 좀 더 흥미로운 주제다. 언어에 fix를 도입하면 모든 타입은 점유되는데(inhabited), 구체적인 타입 T에 대해 다음 표현식이 타입 T를 가지기 때문이다. fix (λ x:T. x) 하스켈에서 이것은 fix id이며 표기 의미론적으로 ⊥이다. 따라서 fix를<NAME> 람다 대수에 도입하면 "모든 well-typed term은 값으로 환원된다"라는 성질을 잃게 된다. 데이터 타입으로서의 fix 하스켈에서 fix 데이터 타입을 만드는 것도 가능하다. fix를 정의하는 방법은 세 가지가 있다. newtype Fix f = Fix (f (Fix f)) 또는 RankNTypes 확장을 이용한다. newtype Mu f = Mu (forall a. (f a -> a) -> a) data Nu f = forall a. Nu a (a -> f a) Mu와 Nu는 fold, unfold, refold를 일반화하는 데 유용하다. fold :: (f a -> a) -> Mu f -> a fold g (Mu f) = f g unfold :: (a -> f a) -> a -> Nu f unfold f x = Nu x f refold :: (a -> f a) -> (g a -> a) -> Mu f -> Nu g refold f g = unfold g. fold f Mu와 Nu는 Fix의 제한된 버전이다. Mu는 귀납적 비무한 자료(inductive noninfinite data)를 만드는데 사용되고 Nu는 공귀납적 무한 자료(coinductive infinite data)를 만드는데 사용된다. newtype Stream a = Stream (Nu ((,) a)) -- exists b. (b, b -> (a, b)) newtype Void a = Void (Mu ((,) a)) -- forall b. ((a, b) -> b) -> b fix point 함수와 달리 fix point 타입은 bottom으로 향하지 않는다. 다음 코드에서 Bot은 완벽하게 정의된다. Bot은 유닛 타입 ()와 동치다. newtype Id a = Id a newtype Bot = Bot (Fix Id) -- equals newtype Bot=Bot Bot -- There is only one allowable term. Bot $ Bot $ Bot $ Bot .., Fix 데이터 타입이 모든 종류의 재귀를 표현할 수는 없다. 이런 일반적이지 않은 데이터 타입의 경우 data Node a = Two a a | Three a a a data FingerTree a = U a | Up (FingerTree (Node a)) 이것을 Fix를 이용해 구현하기는 쉽지 않다. 4 하스 켈 성능 하스 켈 성능 입문 성능 예시들 그래프 소거 지연성 Time and space profiling Strictness (원문 미완성) 알고리즘 복잡도 (원문 미완성) 자료구조 (원문 없음) Parallelism (원문 없음) 1 입문 원문: http://en.wikibooks.org/wiki/Haskell/Performance_introduction 실행 모형 지연 평가 입문 예제: 접기(fold) 시간 공간 저 수준 오버헤드 알고리즘과 자료구조 알고리즘 자료구조 병렬성Parallelism 실행 모형 지연 평가 입문 프로그래밍은 작동하는 프로그램을 작성하는 것만이 아니라 컴퓨터에서 적은 메모리와 실행 시간을 요구하는 프로그램에 관한 것이기도 하다. 시간과 메모리 사용을 명령형 언어나 LISP, ML 같은 적극적인(strict) 함수형 언어에서는 비교적 직관적으로 예측할 수 있지만 하스켈에서는 상황이 다르다. 하스켈에서 표현식은 필요에 따라 평가된다. 예를 들어 다음 표현식은 head (map (2 *) [1.. 10]) 다음과 같이 평가된다. ⇒ head (map (2 *) (1 : [2 .. 10])) ([1 .. 10]) ⇒ head (2 * 1 : map (2 *) [2 .. 10]) (map) ⇒ 2 * 1 (head) ⇒ 2 (*) head 함수는 오직 리스트의 첫 번째 원소만 요구하고 그 결과 나머지 부분인 (map (2 *) [2.. 10])는 결코 평가되지 않는다. 이 전략은 필요한 만큼만 수행한다 해서 지연 평가라고 부른다. [graph reduction] 장에서 상술하겠다. 지연 평가가 하스켈을 구현할 때 흔히 채택되는 기법이긴 하지만 언어 표준은 하스켈이 특정 실행 모형에 국한되지 않으며 적극적이지 않은 표기상 의미론을 가져야 한다고 못 박을 뿐이다. 일인자 함수 f가 적극적이라는 것은, 이 함수의 인자를 평가할 때 무한 루프를 돌게 될 경우 함수가 종료하지 않거나 오류를 일으키지 않고, 그 외의 경우에는 함수가 정의되지 않는다는 뜻이다. 무한 루프의 "결과"를 ⊥로 표기한다면 적극성의 정의는 이렇다. 함수 f에 대해 f ⊥ = ⊥이면 f는 적극적이다. 예를 들어 영원히 루프를 도는 수에 1을 더하는 것도 영원히 루프를 돌기 때문에 ⊥ + 1 = ⊥이고 덧셈 함수 (+1)은 적극적이다. head 함수도 적극적인데 리스트의 첫 번째 원소는 리스트 자체가 정의되지 않으면 접근할 수 없기 때문이다. 하지만 첫 원소는 잘 정의되어 있으면서 리스트의 나머지는 안 되어있을 수도 있다. 그런 경우 다음과 같이 되고 head (x : ⊥) = x 이 등식이 뜻하는 바는 head가 나머지 리스트를 평가하지 않으며 그렇게 할 경우 역시 루프를 돌게 된다는 것이다. 이러한 순수히 대수적인 적극성 성질이 실행 시간과 메모리를 추론하는 데 큰 도움이 된다. LISP나 ML 같은 적극적 언어에서는 항상 head (x : ⊥) = x인 반면 하스켈은 "비적극적"이어서 위의 성질을 갖는 head나 가장 간단하게는 (const 1) ⊥ = 1 같은 비적극적 함수를 작성할 수 있다. Prelude에 정의된 상수 undefined의 도움으로 이 적극성이라는 것을 대화식으로 탐구해 볼 수도 있다. > head (1 : undefined) > head undefined *** Exception: Prelude.undefined 적극성과 ⊥는 이어지는 장들에서도 계속 쓰일 것이다. [graph reduction]에서는 보다 입문 격의 예제들을 제시하고 [denotational semantic]에서는 denotational 관점을 자세히 살펴본다. 예제: 접기(fold) 지연 평가를 맛보는 최선의 길은 예제를 공부하는 것이다. 그래서 foldr과 그 변종들의 모범적인 용례들을 몇 개 살펴볼 것이다. 프로그램의 시간 복잡도와 공간 복잡도를 연구하는 데 필요한 기초 지식은 [알고리즘 복잡도] 장에서 개괄한다. 시간 어떤 숫자가 소수인지 아닌지 확인하는 다음의 isPrime 함수를 보자. isPrime n = not $ any (`divides` n) [2.. n-1] d `divides` n = n `mod` d == 0 any p = or. map p or = foldr (||) False 하스 켈 Prelude의 보조 함수 any는 리스트에 어떤 성질 p를 만족하는 원소가 적어도 하나 존재하는지 검사한다. isPrime의 경우 그 성질은 "n의 약수"다. isPrime이 표현식을 평가하는 데 걸리는 시간의 양은 물론 축소 단계의 개수를 통해 측정된다. n이 소수라면 위의 알고리즘은 2에서 n-1까지의 숫자 리스트 전체를 검사하고 따라서 O(n) 축소라는 최악의 실행 시간이 걸린다. 하지만 n이 소수가 아니라면 모든 수에 걸쳐 루프를 돌지 않고 약수를 하나 찾자마자 멈춰서 n이 합성수라고 보고할 수 있다. 지연 평가의 즐거움은 이 동작이 이미 논리합 ||에 내장되어 있다는 것이다! isPrime 42 ⇒ not $ any (`divides` 42) [2.. 41] ⇒ not ( or (map (`divides` 42) [2.. 41] ) ) ⇒ not ( or ((42 `mod` 2 == 0) : map (`divides` 42) [3.. 41]) ) ⇒ not ( (42 `mod` 2 == 0) || or (map (`divides` 42) [3.. 41]) ) ⇒ not ( True || or (map (`divides` 42) [3.. 41]) ) ⇒ not True ⇒ False 이 함수는 42가 짝수란 걸 보자마자 False를 반환하고 ||는 첫 번째 인자가 True로 결론나면 두 번째 인자는 쳐다보지도 않는다. 즉 다음의 적극성을 얻게 된다. True || ⊥ = True 물론 위의 알고리즘은 손수 루프로 구현할 수도 있다. 하지만 지연 평가의 핵심은 우리가 표준 foldr을 활용하여 투명한 방식으로 알고리즘을 공식화하고도 여전히 조기 탈출이 가능하다는 것이다. 달리 보면 지연 평가는 고속 알고리즘을 모듈화 방식으로 공식화하는 것에 대한 것이다. 그 극적인 예가 무한 자료 구조를 사용하여 효율적으로 생성 & 가지치기 알고리즘을 모듈화하는 것이다. 이 외에도 지연 평가와 관련된 영리한 기법들을 [지연성] 장에서 자세히 다룰 것이다. 실행 시간을 분석한답시고 시시콜콜한 그래프 축소를 수행하는 것은 현실적이지도, 필요치도 않다. 비적 극성이나 지연 평가가 정열적인 평가보다 항상 적은 단계를 거친다는 사실처럼 지름길이 가능하다. 이것들은 [그래프 축소] 장에서 소개한다. 공간 실행 시간이 축소 단계 개수에 의해 모형화된다면 메모리 사용량은 평가 중 표현식의 크기에 의해 모형화된다. 불행히도, ??? 자세한 것은 [그래프 축소]에서. 일단 예상치 못한 공간 문제의 모범적인 사례를 소개하겠다. Unfortunately, it's harder to predict and deviating from the normal course lazy evaluation by more strictness can ameliorate it. More details in Graph reduction. Here, we will present the prototypical example for unexpected space behavior. 막대한 개수의 정수를 무식하게 더하면 > foldr (+) 0 [1.. 1000000] *** Exception: stack overflow 스택 오버플로가 발생한다. 뭐지? 그 평가 과정은 다음과 같다. foldr (+) 0 [1.. 1000000] ⇒ 1+(foldr (+) 0 [2.. 1000000]) ⇒ 1+(2+(foldr (+) 0 [3.. 1000000])) ⇒ 1+(2+(3+(foldr (+) 0 [4.. 1000000])) 이렇게 계속된다. 표현식이 점점 커지며 더 많은 메모리가 필요하다. 이 경우 foldr의 재귀 호출 후 보류된 덧셈들을 수행하기 위해 스택에 메모리가 할당된다. 어느 시점에는 필요한 메모리가 최대 가용한 스택 크기를 초과해 "스택 오버플로" 오류를 일으킨다. 그게 스택이든 히프이든 명심할 것은 표현식의 크기가 사용되는 메모리에 상응하고 일반적으로 foldr (+) 0 [1.. n]의 평가에 O(n) 메모리가 필요하다는 것이다. 그런데 +가 결합성이라는 것에 착안해 지금까지의 숫자들의 합을 누적해서 이 일을 O(1) 공간에서 수행하는 것이 가능하다. (어떤 독자들은 함수를 꼬리 재귀하게 만든다는 말임을 눈치챘을 것이다) foldl이 바로 그런 일을 한다. foldl (+) 0 [1.. n] ⇒ foldl (+) (0+1) [2.. n] ⇒ foldl (+) ((0+1)+2) [3.. n] ⇒ foldl (+) (((0+1)+2)+3) [4.. n] 하지만 더 끔찍하게도 누적 하비 더 이상 축소되지 않는다! 이 표현식은 리스트의 끝에 다다를 때까지 히프 안에서 자라날 것이다. ⇒ ... ⇒ foldl (+) ((((0+1)+2)+3)+...) [] ⇒ ((((0+1)+2)+3)+...) 그리고 이 평가되지 않은 거대한 합의 축소 역시 스택 오버플로로 실패할 것이다. (즉 단지 누적 매개변수를 도입한다고 함수가 꼬리 재귀를 하지는 않는다) 문제는 이 평가되지 않은 합이 단일 정수에게는 과도하게 큰 표현이고 적극적으로 평가하는 것이 더 저렴하다는 것이다. foldl'이 바로 그런 일을 한다. foldl' f z [] = z foldl' f z (x:xs) = z `seq` foldl' f (f z x) xs 여기서 a `seq` b를 평가하면 a는 b의 축소에 앞서 weak head normal form으로 축소된다. 합은 이제 상수 공간 내에서 진행된다. foldl' (+) 0 [1.. n] ⇒ foldl' (+) (0+1) [2.. n] ⇒ foldl' (+) (1+2) [3.. n] ⇒ foldl' (+) (3+3) [4.. n] ⇒ foldl' (+) (6+4) [5.. n] ⇒ ... 보다 자세한 사항과 추가 예시들은 [그래프 축소] 장을 볼 것. 저 수준 오버헤드 적극적 평가와 비교해서 지연 평가는 상당한 오버헤드를 유발하는데, 정수나 문자조차도 ⊥일 수 있기에 포인터로서 저장되어야 하기 때문이다. 1바이트 문자들의 배열은 같은 길이의 String = [Char]보다 몇 배는 압축적이다. 적극성 표기, unboxed 타입, 자동 적극성 분석으로 이 오버헤드를 줄일 수 있다. 그런 저 수준 세부사항에 대해서는 하스 켈 위키가 적격이다.[1] 위키 책에서는 현재로썬 이것들을 다루지 않는다. 알고리즘과 자료구조 알고리즘 이 위키 책이 알고리즘에 관한 포괄적인 책은 아니지만 효율적 프로그램 작성을 위한 함수형 프로그래밍만의 기법들은 많다. [알고리즘 복잡도] 장에서는 빅-O 표기를 개괄하고 실제 사례를 몇 개 제시한다. [지연성] 장에서는 지연 평가를 활용하여 효율적인 알고리즘을 모듈화 방식으로 작성하는 것에 초점을 맞춘다. program derivation과 equational reasoning의 공통 관심사는 다음과 같은 등식들을 응용 및 증명하여 명세로부터 효율적인 프로그램을 도출하는 것이다. map f. reverse = reverse . map f filter p. map f = map f. filter (p . f) 이 과제는 다이내믹 프로그래밍의 순수 대수적 접근법으로 부상하는데, 나중에 적절한 이름으로 소개될 것이다. This quest has given rise to a gemstone, namely a purely algebraic approach to dynamic programming which will be introduced in some chapter with a good name. fusion 또는 deforestration으로 알려진 또 다른 등식 기법은 함수 합성에서 중간 자료구조를 제거하는 것이 목표다. 가령 다음 코드의 좌변에 있는 합성은 map f. map g = map (f . g) 중간 리스트를 구축 및 파괴하지만 우변은 한 리스트에 걸친 단일 패스다. 여기서 일반적인 주제는 생성자-파괴자 짝을 이렇게 접합하는 것이다. case (Just y) of { Just x -> f x; Nothing -> ...; } = f y 이에 관해서는 다음에 알맞은 명칭으로 상세히 다룰 것이다. 자료구조 올바른 자료구조를 선택하는 것이 성공의 열쇠다. 리스트는 흔하고 놀랍도록 길어질 수 있지만 고속 접근 및 갱신이 가능한 고전적인 자료구조라기보단 루프의 구체화된 한 형태다. 많은 언어가 이런 유의 특정 자료 구조를 특별 지원하는데 C는 배열(array), 펄은 해시 테이블, LISP는 리스트가 있다. 하스켈은 선천적으로 어떤 종류의 트리도 장려한다. 하지만 매개화 다형성(parametric polymorphism)과 타입 클래스 덕에 균형 이진 트리 등 어떤 추상 타입도 사용 및 재사용이 쉽다! [자료구조] 장에서 일반적인 문제들을 위한 자연스러운 자료구조를 선택하는 것을 자세히 다룬다. 하스켈은 순수 함수형이기 때문에 자료구조들이 영구적인 공통부분을 공유한다. 즉 자료구조의 구판(old version)도 이런 식으로 이용할 수 있다. foo set = (newset, set) where newset = insert "bar" set 반면 명령형 언어의 단점은 단명한다는 것인데, 즉 자료가 그 자리에서 갱신되어 구판은 덮어씐다. 가령 배열은 단명한다. 그래서 하스켈에서 배열을 쓰려면 변경 불가능해야 하거나 모나드가 필요한 것이다. 다행히 큐나 히프 같은 단명 구조에 대응하는 영구 구조들이 있고 [자료구조] 장에서 그런 쪽의 원칙, 가령 amortization 같은 몇 가지 설계 원칙들을 상냥하게 소개할 것이다. 병렬성Parallelism 병렬화의 목적은 한 알고리즘을 여러 코어 또는 컴퓨터 상에서 실행하여 보다 빠르게 결과를 얻는 것이다. 하스켈은 그 자체의 순수성 덕에 실행 순서를 강제하지 않기 때문에 병렬 알고리즘을 공식화하는 데 잘 들어맞는다. 하스켈에서의 병렬화는 아직 연구 주제이자 실험 대상이다. Control.Parallel.Strategies에 실행 순서를 제어하는 결합기 들 이 있지만 조각조각 흩어져있다. 덜 야망적이지만 보다 실용적인 대안인 Data Parallel Haskell에 대한 연구도 진행 중이다. [병렬화] 장은 아직 작성하지 않았지만 하스켈에서의 병렬 알고리즘과 현시점에서의 가능성을 소개할 계획이다. 2 성능 예시들 원문: https://en.wikibooks.org/wiki/Haskell/Performance_examples 옮긴이: 원문이 미완성인 문서입니다. 목표: 실제 예시를 들며 최적화를 단계 별로 설명한다. 타이트 루프 하스켈을 C 만큼 빠르게 만들기: 엄격함, 지연성, 재귀의 활용 CSV 파싱 haskell-cafe: 또 다른 초짜의 수행능력 질문 type CSV = [[String]] main = do args <- getArgs file <- readFile (head args) writeFile (head args ++ "2") (processFile (args !! 1) file) processFile s = writeCSV . doInteraction s. readCSV doInteraction line csv = insertLine (show line) (length csv - 1) csv writeCSV = (\x -> x ++ "\n") . concat . intersperse "\n" . (map (concat . intersperse "," . (map show))) insertLine line pos csv = (take pos csv) ++ [readCSVLine line] ++ drop pos csv readCSVLine = read . (\x -> "["++x++"]") readCSV = map readCSVLine . lines 메일링 리스트에 cvs 파싱에 대한 다른 스레드가 있던 거 같은데 못 찾겠다. 공간 누수 jkff가 로그 파일을 분석하는 코드에 관해 물어봤다. 기본적으로 히스토그램을 만드는 코드다. foldl' (\m (x, y) -> insertWith' x (\[y] ys -> y:ys) [y] m) M.empty [(ByteString.copy foo, ByteString.copy bar) | (foo, bar) <- map (match regex) lines] 입력은 1GB 로그였고 프로그램은 ByteString.copy 때문에 가용 메모리를 터뜨렸다. 평가가 강제되지 않아 파일 전체가 메모리에 올라갔기 때문이다. 3 그래프 소거 원문: https://en.wikibooks.org/wiki/Haskell/Graph_reduction TODO reduction = 소거 or 환원 원문이 미완성입니다. 서문 지연 평가로 표현식 평가하기 소거 소거 전략 정리 (CUrch Roser II) 그래프 소거 (소거 + 공유) 패턴 매칭 고차 함수 Weak Head Normal Form Weak Head Normal Form strict 함수와 non-strict 함수 공간 제어 공유와 CSE 꼬리 재귀 시간 추론 지연 평가 < 적극적 평가 인자 버리기 영속성 & 감가상각 그래프 소거의 구현 레퍼런스 서문 프로그래밍은 단순히 표기 의미론(denotational semantics)에 의해 도출된 올바른 프로그램을 작성하는 일이 아니다. 프로그래밍은 적은 메모리를 쓰는 빠른 프로그램을 작성하는 일이기도 하다. 그러려면 프로그램이 기계에서 어떻게 실행되는지를 알아야 하는데, 그 기계는 주로 동작 의미론(operational semantics) 적으로 기술된다. 이 장에서는 하스 켈 프로그램이 실제 컴퓨터에서 어떻게 실행되는지를 설명하며 이는 시간 및 공간의 사용을 분석하는 토대가 된다. 하스 켈 표준은 특정한 동작 의미론을 포함하지 않는다. 하스 켈 구현체는 어떤 의미론이든 자유롭게 고를 수 있다. 하지만 아직까지 모든 하스 켈 구현은 지연 평가의 실행 모형을 따른다. 이제부터 지연 평가를 면밀히 살펴보고 이 실행 모형으로 하스 켈 프로그램의 시간 및 공간 복잡도에 대한 추론을 설명할 것이다. 지연 평가로 표현식 평가하기 소거 함수형 프로그램 실행하기, 즉 표현식 평가하기는 모든 함수 적용이 전개될 때까지 함수 정의들을 반복적으로 적용하는 것을 뜻한다. 다음 정의들과 함께 표현식 pythagoras 3 4를 살펴보자. square x = x * x pythagoras x y = square x + square y 다음은 가능한 소거 절차 중 하나다. pythagoras 3 4 ⇒ square 3 + square 4 (pythagoras) ⇒ (3*3) + square 4 (square) ⇒ 9 + square 4 (*) ⇒ 9 + (4*4) (square) ⇒ 9 + 16 (*) ⇒ 25 모든 소거는 하위 표현식을 동등한 다른 표현식으로 치환한다. 그런 하위 표현식을 소거 가능 표현식(reducible expression), 짧게는 redex라고 부른다. 치환에는 square 같은 함수 정의나 (+) 같은 내장 함수를 이용한다. redex 없는 표현식을<NAME>(normal form)이라고 부른다. 물론 실행은<NAME>에 다다르면 멈추고 이것이 계산의 결과가 된다. 당연히 소거를 적게 할수록 프로그램은 더 빠르게 실행된다. 실제 하드웨어에서의 구현은 아주 다르기 때문에 각 소거 단계에 걸리는 시간이 같다고 기대할 수는 없다. 하지만 점근적인 복잡도 측면에서 소거 개수는 정확한 측정치다. 소거 전략 가능한 소거 절차는 다양하고 소거 개수는 수행되는 소거 순서에 따라 다르다. 표현식 fst (square 3, square 4)를 예로 들자. 함수 정의를 적용하기 전에 모든 함수 인자를 평가하는 방법이 있다. fst (square 3, square 4) ⇒ fst (3*3, square 4) (square) ⇒ fst ( 9 , square 4) (*) ⇒ fst ( 9 , 4*4) (square) ⇒ fst ( 9 , 16 ) (*) ⇒ 9 (fst) ``` 이 전략은 **최내 우선 소거(innermost reduction)**라 부르며 **최내 redex(innermost redex)**은 내부에 다른 하위 표현식을 redex로 가지지 않는 redex이다. 다른 가능성으로 모든 함수 정의를 적용하고 인자만 평가하는 방법이 있다. ``` fst (square 3, square 4) ⇒ square 3 (fst) ⇒ 3*3 (square) ⇒ 9 (*) ``` 이를 **최 외 소거(outermost reduction)**라 부르며 항상 다른 redex 안에 있지 않은 **outermost redex**를 소거한다. 여기서는 최외 소거가 최내 소거보다 단계 수가 적다. `fst` 함수는 짝의 두 번째 성분이 필요하지 않아서 `square 4`의 소거가 필요 없기 때문이다. #### 종료 다음과 같은 표현식에서는 ``` loop = 1 + loop ``` 어떤 소거 절차도 종료하지 않고 프로그램 실행은 끝나지 않는 루프에 빠진다. 이런 표현식은<NAME>이 없다. 그런데 어떤 소거 절차는 종료하고 어떤 건 그렇지 않은 표현식들도 있다. fst (42, loop) ⇒ 42 (fst) fst (42, loop) ⇒ fst (42,1+loop) (loop) ⇒ fst (42,1+(1+loop)) (loop) ⇒ ... ``` 첫 번째 소거 절차는 최외 소거다. 두 번째는 최내 소거인데 fst가 무시할 텐데도 쓸데없이 loop를 평가하려고 한다. 오직 필요할 때만 함수 인자를 평가하는 능력이 종료를 따질 때는 최외 소거를 최적으로 만든다. 정리 (CUrch Roser II) 종료하는 소거가 적어도 하나 있으면 최외 소거 역시 종료한다. 그래프 소거 (소거 + 공유) 인자를 버리는 능력에도 불구하고 최외 소거가 항상 최내 소거보다 소거 단계가 적은 것은 아니다. square (1+2) ⇒ (1+2)*(1+2) (square) ⇒ (1+2)*3 (+) ⇒ 3*3 (+) ⇒ 9 (*) 여기서 인자 (1+2)가 중복되며 두 번 소거된다. 하지만 똑같은 인자이기 때문에 해답은 소거 (1+2) ⇒ 3를 모든 같은 인자에서<NAME>는 것이다. 표현식을 그래프로 나타내면 가능하다. 다음은 __________ | | ↓ ◊ * ◊ (1+2) 표현식 (1+2)*(1+2)를 나타낸다. square (1+2)의 최외 그래프 소거는 다음과 같이 진행된다. square (1+2) ⇒ __________ (square) | | ↓ ◊ * ◊ (1+2) ⇒ __________ (+) | | ↓ ◊ * ◊ 3 ⇒ 9 (*) 그리고 이 작업은 공유된다. 즉 최외 그래프 소거는 모든 인자를 최대 한 번만 소거한다. 그래서 최외 소거는 항상 최내 소거보다 소거 단계가 적으며, 이는 소모 시간 추론에서 증명한다. 표현식 공유는 let과 where에서도 존재한다. 가령 변의 길이 a, b, c를 가지고 삼각형의 넓이를 계산하는 헤론의 공식을 보자. area a b c = let s = (a+b+c)/2 in sqrt (s*(s-a)*(s-b)*(s-c)) 정삼각형에 적용하면 다음과 같이 소거된다. area 1 1 1 ⇒ _____________________ (area) | | | | ↓ sqrt (◊*(◊-a)*(◊-b)*(◊-c)) ((1+1+1)/2) ⇒ _____________________ (+),(+),(/) | | | | ↓ sqrt (◊*(◊-a)*(◊-b)*(◊-c)) 1.5 ⇒ ... ⇒ 0.433012702 결과는 4 이다. 달리 말하면 let 바인딩은 그래프의 노드에 이름을 부여하는 것이다. 사실 graphical notation을 완전히 생략하고 let 만으로 공유를 지정해 그래프 구조를 표현할 수 있다. 1 하스켈의 모든 구현은 어느 형태로든 최외 그래프 소거에 기반하기 때문에 시간과 공간 할당의 점근적 복잡도를 추론하기 좋은 모형을 제공한다.<NAME>에 다다르기 위한 소거 단계 개수는 실행 시간에, 그래프 내 항들의 크기는 메모리 사용량에 대응한다. 연습문제 문제 1. square (square 3)을 최내/최외 그래프 소거를 이용해<NAME>으로 소거하라. 문제 2. 다음의 고속<NAME> 알고리즘은 x의 n 승을 계산한다. power x 0 = 1 power x n = x' * x' * (if n `mod` 2 == 0 then 1 else x) where x' = power x (n `div` 2) power 2 5를 최내/최외 그래프 소거를 이용해 소거하라. 소거를 몇 번 해야 하는가? 일반적인 power 2 n의 점근적 복잡도는 무엇인가? "graphless" 최외 소거를 사용하면 알고리즘이 어떻게 되는가? 패턴 매칭 지금까지는 패턴 매칭과 데이터 생성자가 있을 때 최외 그래프 소거가 어떻게 되는지 설명하지 않았다. 이 부분을 설명하면서 하스 켈 같은 non-strict 함수형 언어를 구현할 때 흔히 토대가 되는 소거 전략의 대부분을 짚고 넘어갈 수 있다. 이를 call-by-need 또는 지연 평가(lazy evaluation)라고 부르는데, 함수 인자의 소거를 최후의 끝까지 "게으르게" 미루기 때문이다. 세부 사항은 다음 챕터들에서 다루겠다. 패턴 매칭이 specification을 어떻게 요구하는지 보기 위해 불리언 논리합을 살펴보자. or True y = True or False y = y 그리고 표현식 or (1==1) loop loop = not loop는 종료하지 않는다. 다음 소거 절차는 or (1==1) loop ⇒ or (1==1) (not loop) (loop) ⇒ or (1==1) (not (not loop)) (loop) ⇒ ... 최외 redex만을 소거하고 따라서 최외 소거다. 하지만 or (1==1) loop ⇒ or True loop (or) ⇒ True 이 더 말이 된다. 물론 우리는 or의 정의를 적용하고 어떤 식을 선택할지 결정하기 위해 인자들을 소거하고 싶을 뿐이다. 이 의도는 하스켈의 패턴 매칭 규칙에 의해 포착된다. 좌변은 위에서 아래로 매칭된다. 좌변을 매칭할 때 인자들은 왼쪽에서 오른쪽으로 매칭된다. 인자들의 매칭 여부 결정에 필요한 만큼만 인자들을 평가한다. 따라서 우리의 or (1==1) loop의 경우 첫 번째 인자를 True나 False로 소거한 다음, 변수 y 패턴에 매칭하기 위해 두 번째 인자를 평가하고, 일치하는 함수 정의를 전개한다. 변수에 대한 매칭은 항상 성공하기 때문에 두 번째 인자는 소거되지 않는다. 이 동작을 수행하는 것은 위 절차의 두 번째 단계다. 이런 것들을 염두에 두면 대부분의 하스 켈 표현식을 평가할 수 있다. 다음은 테스트를 위한 몇 가지 연습문제다. 연습문제 다음 표현식들을 지연 평가하여 normal form으로 소거하라. Prelude의 표준 함수 정의들을 사용할 것. length [42,42+1,42-1] head (map (2*) [1,2,3]) head $ [1,2,3] ++ (let loop = tail loop in loop) zip [1.. 3] (iterate (+1) 0) head $ concatMap (\x -> [x, x+1]) [1,2,3] take (42-6*7) $ map square [2718.. 3146] 고차 함수 고차 함수와 커링의 소거가 남았다. 다음 정의들에서 id x = x a = id (+1) 41 twice f = f. f b = twice (+1) (13*3) id와 twice 둘 다 인자가 하나다. 해답은 여러 인자를 한 인자의 연이은 적용으로 보는 것이다. 이것을 커링currying이라고 부른다. a = (id (+1)) 41 b = (twice (+1)) (13*3) 임의의 함수 적용 expression1 expression2를 소거하기 위해 call-by-need는 먼저 expression1이 함수가 되고 이 함수를 expression2를 이용해 unfold 할 수 있을 때까지 소거한다. 소거 절차는 다음과 같다. ⇒ (id (+1)) 41 (a) ⇒ (+1) 41 (id) ⇒ 42 (+) ⇒ (twice (+1)) (13*3) (b) ⇒ ((+1).(+1) ) (13*3) (twice) ⇒ (+1) ((+1) (13*3)) (.) ⇒ (+1) ((+1) 39) (*) ⇒ (+1) 40 (+) ⇒ 41 (+) 설명이 조금 모호한데, 다음 절에서 명확하게 설명할 것이다. 패턴 매칭은 시간이 오래 걸리는 계산을 위한 것이고 고차 함수는 단지 알고리즘의 본질을 붙잡기 위한 것으로 보일 수도 있지만, 함수는 자료구조로서도 유용하다. 그 예 중 하나로 O(1) 시간에 결합할 수 있는 difference list ([a] -> [a])가 있다. 또 다른 예로 fold를 이용한 스트림 표현이 있다. 사실 모든 함수형 언어의 뿌리인 순수 람다 대수에서, 모든 자료구조는 함수로 표현된다. Weak Head Normal Form 지연 평가가 소거 절차를 어떻게 선택하는지 정확히 공식화하려면 등식에 의한 함수 정의를 버리고 표현식 위주의 접근법을 취하는 것이 최선이다. f (x:xs) = ... 같은 함수 정의를 f = expression 형태로 바꾸자는 말이다. 이 일을 case expression과 lambda abstraction이라는 두 기본형으로 할 수 있다. case 표현식의 기본형은 최외 생성자의 분해만 허용한다. 예를 들어 리스트의 기본 case 표현식은 다음과 같은 꼴이다. case expression of [] -> ... x:xs -> ... lambda abstraction은 인자가 하나인 함수이므로 다음의 두 정의는 동등하다. f x = expression f = \x -> expression 다음은 zip의 정의다. zip :: [a] -> [a] -> [(a, a)] zip [] ys = [] zip xs [] = [] zip (x:xs') (y:ys') = (x, y):zip xs' ys' 그리고 이것은 case 표현식과 람다 abstraction으로 번역한 것이다. zip = \xs -> \ys -> case xs of [] -> [] x:xs' -> case ys of [] -> [] y:ys' -> (x, y):zip xs' ys' 모든 정의를 이러한 기본형들로 번역하면 모든 redex는 다음 중 한 형태가 된다. 함수 적용 ((\variable->expression1) expression2) case 표현식 case expression of { ... } Weak Head Normal Form 표현식이 WHNF 일 필요충분조건은 다음 중 하나를 만족하는 것이다. True, Just (square 42), (:) 1 같은 (아마 인자에 적용될) 생성자 (+) 2, sqrt처럼 인자를 완전히 전달하지 않은 내장 함수 적용 람다 abstraction \x -> expression strict 함수와 non-strict 함수 non-strict 함수는 인자가 필요 없다. non-termination의 다른 형태들을 구분하지 않는다면 strict 함수는 인자가 WHNF 여야 한다. (예를 들어 f x = loop는 인자가 필요 없다) 공간 제어 여기서 "공간(space)"은 그래프 순회로 더 잘 표현할 수 있다. 그래프 자료구조나 induced dependency 그래프라고 생각하라. 예를 들어 Fibonacci(N)은 N = 0 또는 N = 1일 경우 아무것에도 의존하지 않고 그 외에는 Fibonacci(N-1)과 Fibonacci(N-2)에 의존한다. Fibonacci(N-1)이 Fibonacci(N-2)에 의존하므로 이 induced graph는 트리가 아니다. 따라서 구현 기법과 자료구조 순회 방법이 대응한다. 대응하는 구현 기법 자료구조 순회 메모이제이션 DFS (중간 결과를 모두 메모리에 유지) 병렬 평가 BFS (중간 결과를 모두 메모리에 유지) 공유 DAC 순회 ("frontier"만 메모리에 유지) 일반적인 재귀 트리 순회 (스택 채우기) 꼬리 재귀 리스트 순회 / 그리디 서치 (상수 공간) 다음의 고전적인 피보나치는 fibo 0 = 1 fibo 1 = 1 fibo n = fibo (n-1) + fibo (n-2) DAC 그래프에 적용된 트리 순회로서 가장 안 좋다. 최적화된 버전은 fibo n = let f a b m = if m = 0 then a if m = 1 then b f b (a+b) (m-1) in f 1 1 n ``` DAG 순회를 사용한다. 운 좋게도 frontier 크기가 상수이며 따라서 꼬리 재귀 알고리즘이 된다. 이번에는 공간을 먹어치우는 fold 예제를 보자. ``` foldl (+) 0 [1.. 10] ``` 다음은 교묘한 공간 누수 예제다. ``` (\xs -> head xs + last xs) [1.. n] (\xs -> last xs + head xs) [1.. n] 첫 번째 것은 O(1) 공간에서 실행되지만 두 번째 것은 O(n)에서 실행된다. 공유와 CSE 노트: 시간에 관한 절과 중복됨. 별도의 메모이제이션 절 필요? 어떻게 공유할 것인가 foo x y = -- s is not shared foo x = \y -> s + y where s = expensive x -- s is shared "lambda-lifting", "full laziness". 컴파일러가 full laziness 면안 된다. 공간과 시간 사이의 절충에 대한 고전적이고 중요한 예제 sublists [] = [[]] sublists (x:xs) = sublists xs ++ map (x:) (sublists xs) sublists' (x:xs) = let ys = sublists' xs in ys ++ map (x:) ys 컴파일러가 common subexpression elimination을 최적화로서 수행하면 안 되는 이유 (GHC는 하고 있나?) 꼬리 재귀 NOTE: 공간 절에 두는 게 맞는가? 스택 공간에 관한 거니까 맞는 듯. 하스켈의 꼬리 재귀는 좀 다른 것 같다. 시간 추론 지연 평가 < 적극적 평가 실행 시간을 추론할 때 그래프 소거를 손수 해보고 어림짐작하는 것은 대부분 통하지 않는다. 사실 지연 평가에 의한 평가 순서는 사람이 예측하기 어려워서, 인자를 함수에 전달하기 전에 normal form으로 소거하는 적극적 평가 단계를 추적하는 게 더 쉽다. 지연 평가는 항상 적극적 평가보다 소거 단계가 적기 때문에 함수가 적극적으로 평가된다고 가정하여 소거 횟수의 상한을 쉽게 얻을 수 있다. 예시: or = foldr (||) False isPrime n = not $ or $ map (\k -> n `mod` k == 0) [2.. n-1] => 적극적 평가는 항상 n 단계. 지연 평가는 이보다 많지 않다. 인자 버리기 인자를 normal form으로 평가하는 함수의 시간 바운드는 정해져 있다. 함수가 그 인자를 필요로 한다는 성질은 표기 의미론으로 간결하게 포착할 수 있다. f ⊥ = ⊥ 단 WKNF 형태의 인자에 한정된다. 동작 의미론적으로는 비종결 -> 비종결이다. (이것은 근사일 뿐인데 f anything = ⊥ 이 그 인자를 "필요"로 하지 않기 때문이다) 비 엄격 함수는 자신의 인자를 필요로 하지 않으며 time bound가 명확하지 않다. 하지만 함수가 엄격한지 아닌지에 대한 정보만으로도 분석에 유용하게 쓰일 수 있다. isPrime n = not $ or $ (n `mod` 2 == 0) : (n `mod` 3 == 0) : ... or True ⊥ = True를 아는 것만으로 충분하다. 다른 예시들: foldr (:) [] 대 foldl (flip (:)) []에서 ⊥의 사용 head . mergesort를 ⊥만으로 해석할 수 있을까? 이 예시는 너무 복잡하며 지연성에서 다루는 게 적절하다. 영속성 & 감가상각 NOTE: this section is better left to a data structures chapter because the subsections above cover most of the cases a programmer not focussing on data structures / amortization will encounter. Persistence = no updates in place, older versions are still there. Amortisation = distribute unequal running times across a sequence of operations. Both don't go well together in a strict setting. Lazy evaluation can reconcile them. Debit invariants. Example: incrementing numbers in binary representation. 그래프 소거의 구현 Small talk about G-machines and such. Main definition: closure = thunk = code/data pair on the heap. What do they do? Consider {\displaystyle (\lambda x.\lambda y.x+y) 2} (\lambda x.\lambda y.x+y) 2. This is a function that returns a function, namely {\displaystyle \lambda y.2+y} \lambda y.2+y in this case. But when you want to compile code, it's prohibitive to actually perform the substitution in memory and replace all occurrences of {\displaystyle x} x by 2. So, you return a closure that consists of the function code {\displaystyle \lambda y.x+y} \lambda y.x+y and an environment {\displaystyle {x=2}} {x=2} that assigns values to the free variables appearing in there. GHC (?, most Haskell implementations?) avoid free variables completely and use supercombinators. In other words, they're supplied as extra-parameters and the observation that lambda-expressions with too few parameters don't need to be reduced since their WHNF is not very different. Note that these terms are technical terms for implementation stuff, lazy evaluation happily lives without them. Don't use them in any of the sections above. 레퍼런스 Bird, Richard (1998). Introduction to Functional Programming using Haskell. Prentice Hall. ISBN 0-13-484346-0. Peyton-Jones, Simon (1987). The Implementation of Functional Programming Languages. Prentice Hall. John Maraist, Martin Odersky, and Philip Wadler (May 1998). "The call-by-need lambda calculus". Journal of Functional Programming 8 (3): 257-317. ↩ 4 Laziness https://en.wikibooks.org/wiki/Haskell/Laziness 서문 비 엄격성(nonstrictness) 대 지연성 썽크와 weak head normal form 지연 함수와 엄격 함수 블랙박스 엄격성 분석 비 엄격 의미론의 문맥에서 사물에 대한 표기적 관점 게으른 패턴 매칭 언제 지연 패턴을 사용해야 하는가? 비 엄격 의미론의 장점 시간 페널티 없는 주의 분산(Separation of concerns without time penalty) 개선된 코드 재사용 무한 자료구조 흔한 비 엄격 관용구 Tying the knot Memoization, Sharing and Dynamic Programming 지연성에 대한 결론 노트 레퍼런스 고생하면 결국 보상받지만 게으름은 지금 변상해야 한다! - Steven Wright 서문 이제 여러분은 하스켈이 지연 평가를 활용한다는 것을 알고 있다. 어떤 것도 필요하기 전에는 평가되지 않는다. 하지만 "필요하기 전"이 정확히 무슨 뜻인가? 이번 장에서는 지연 평가가 어떻게 작동하는지 (그 안에 어떤 흑마술이 있는지), 이것이 함수형 프로그래밍에서 뜻하는 바가 무엇인지, 어떻게 해야 최대한 활용할지 알아본다. 먼저 지연 평가를 하는 이유와 지연 평가가 내포하는 바를 고려해 보자. 언뜻 보면 지연 평가가 프로그램을 더 효율적으로 만든다고 볼 수 있다. 어쨌든 아무것도 안 하는 것보다 효율적일 수는 없지 않나? 사실은 지연성이 오버헤드를 만들어서 프로그래머가 코드를 더 엄격하게 만들 수 있는 부분을 방해하기도 한다. 지연의 진짜 이점은 올바른 것을 충분히 효율적으로 만드는 데 있다. 지연 평가는 엄격한 환경에서 할 수 있는 것보다 단순하고 우아한 코드를 작성할 수 있게 한다. 비 엄격성(nonstrictness) 대 지연성 지연성과 비 엄격성은 미묘하게 다르다. 비 엄격 의미론은 여러분이 믿을 수 있는 하스 켈 프로그램의 어떤 성질을 지칭한다. 어떤 것도 필요하기 전에는 평가되지 않는다. 지연 평가는 다음 절에서 설명할 썽크thunk라는 수단을 통해 비 엄격성을 구현하는 방법이다. 하지만 이 두 개념은 워낙 밀접하게 연관되어 있어서 함께 설명하는 게 좋다. 썽크를 알면 비 엄격성을 이해하는 데 도움이 되고 비 엄격성의 의미론은 애초에 왜 지연 평가를 사용하는지를 설명한다. 그래서 이 개념들을 동시에 소개하며 혼용을 피하지 않을 것이다. (용어는 올바르게 구분하겠지만) 썽크와 weak head normal form 하스켈에서 프로그램이 어떻게 실행되는지 알려면 두 원칙을 이해해야 한다. 첫 번째는 비 엄격성의 성질이다. 평가는 최소한으로 하고 최대한 지연한다. 두 번째, 하스켈의 값들은 고도로 층을 이루어 값을 '평가하는' 것은 여러 층 중 하나를 평가한다는 뜻이다. 쌍을 이용하는 몇 가지 예제를 살펴보자. let (x, y) = (length [1.. 5], reverse "olleh") in ... in 부분에서 x와 y를 사용한다고 가정하자. 그렇지 않으면 애초에 이 let 바인딩을 평가할 필요가 없다. 우변이 undefined 일 수도 있는데, in 부분이 x 또는 y를 언급하지 않으면 그런 경우에도 작동했을 것이다. 이 가정은 이 절의 모든 예제에 적용된다. 우리는 x에 대해 무엇을 아는가? 계산해 보면 x는 반드시 5이고 y는 "hello"임을 알 수 있다. 하지만 첫 번째 원칙을 기억하자. 필요하기 전에는 length와 reverse의 호출을 평가하지 않는다. 따라서 x와 y가 썽크라고 말할 수 있는데, 즉 이것들은 평가하는 방법을 알려주는 설명서가 동봉된 평가되지 않은 값 들이다. 예를 들어 x의 설명서는 'length [1.. 5]를 평가하시오'이다. 그런데 우리는 좌변에서 일종의 패턴 매칭을 하고 있다. 그걸 제거하면 어떻게 될까? let z = (length [1.. 5], reverse "olleh") in ... 우리에게는 z가 쌍이라는 것이 명백하지만 컴파일러가 보기에 우리는 '=' 기호 우변의 값을 분해하려는 노력을 전혀 하지 않는다. 따라서 컴파일러는 그게 무엇이든 전혀 신경 쓰지 않는다. 컴파일러는 z 자체를 썽크로 만든다. 나중에 우리가 z를 사용하려 한다면 두 구성요소 중 하나 또는 둘 다 필요하게 될 테고, 따라서 z를 평가해야 한다. 하지만 지금 당장은 z가 썽크여도 된다. 앞서 하스켈의 값은 층을 이룬다고 했는데 z에 대해 패턴 매칭을 하면 볼 수 있다. let z = (length [1.. 5], reverse "olleh") (n, s) = z in ... 첫 번째 줄이 실행된 후 z는 단순히 썽크다. z가 어떤 종류의 값인지는 모르는데, 아직 알아보라는 요청이 없기 때문이다. 하지만 두 번째 줄에서는 쌍 패턴을 통해 z에 대해 패턴 매칭을 한다. 컴파일러는 'z에 패턴이 매칭하는지 확인해야겠는데, 그러려면 z가 쌍인지 확실히 해야 해'라고 생각한다. 하지만 조심하자. 우리는 아직 구성요소 부분(length와 reverse 호출)에 대해서는 아무것도 하지 않았다. 따라서 이것들은 평가하지 않은 채 놔둘 수 있다. 달리 말하자면 방금까지 썽크였던 z는 (썽크, 썽크) 같은 걸로 평가된 것이고, n과 s는 썽크인데 평가되고 나면 원래 z의 구성요소 부분들로 변할 것이다. 좀 더 복잡한 패턴 매칭을 해보자. let z = (length [1.. 5], reverse "olleh") (n, s) = z 'h':ss = s in ... z의 두 번째 성분에 대한 패턴 매칭은 평가를 유발한다. 컴파일러는 'h':ss 패턴이 쌍의 두 번째 성분에 매칭하는지 확인하고자 하고, 따라서 s의 최상위 층을 평가해서 cons 셀 s = *thunk* : *thunk* 인지 확인한다. (s가 빈 리스트였다면 이 시점에서 패턴 매칭 실패 오류를 만났을 것이다.) 방금 밝혀낸 첫 번째 썽크를 평가해 'h':ss = 'h' : *thunk* 인지 확인한다. 리스트의 나머지는 평가되지 않은 채 유지되고 ss는 썽크가 되며, 평가된다면 이 리스트의 나머지 부분이 될 것이다. 값 (4, [1, 2])를 차례대로 평가하는 과정. 첫 단계에서는 전혀 평가되지 않는다. 연이은 형태들은 WHNF 형태이며 마지막은 normal form 형태다. 거의 모든 하스 켈 값은 '부분 평가'될 수 있다. 또한 평가할 수 있는 최소 단위에 대한 개념도 있다. 예를 들어 쌍의 썽크를 최소한만 평가하면 두 구성요소를 평가하지 않은 쌍 생성자 (*thunk*, *thunk*) 가 나온다. 리스트를 최소한 평가하면 cons cell *thunk* : *thunk* 또는 빈 리스트 []가 나온다. 빈 리스트의 경우에는 그 값을 더 이상 평가할 수 없으며 normal form 형태라고 칭한다. 그 사이의 단계에서 값의 일부라도 평가한 상태면 weak head normal form (WHNF) 형태라고 부른다. ('head normal form'이라는 것도 있으나 하스켈에서는 사용하지 않는다) WNHF 형태의 무언가를 완전히 평가하면 normal form으로 환원된다. 어느 시점에 z를 사용자에게 출력해야 한다면 z를 완전히 평가해서 length와 reverse도 호출하여 normal form인 (5, "hello")로 만들어야 한다. 값을 조금이라도 평가하는 행위를 두고 그 값을 강제한다(force)고 부르기도 한다. 어떤 값들은 그 결과가 오직 하나다. 예를 들어 정수를 부분 평가할 수는 없다. 정수는 썽크이거나 normal form이다. 엄격한 구성요소(data MaybeS a = NothingS | JustS ! a처럼 느낌표가 붙은 것)를 가지는 생성자의 경우, 이런 구성요소는 상위 단계를 평가하는 순간 그 자신도 평가된다. JustS *thunk* 같은 것은 불가능하다. 이 단계에 도달하면 JustS의 구성요소에 대한 엄격함 표기 때문에 그 구성요소의 평가도 강제된다. 이번 절에서는 지연성의 기본을 알아봤다. 어떤 것도 필요하기 전에는 평가되지 않는다. (사실 하스 켈 값이 평가되는 유일한 장소는 패턴 매칭과 특정 원시 IO 함수들 내부뿐이다) 이 원칙은 값을 평가할 때도 적용된다. 값을 평가할 때는 결과를 계산하는 데 필요한 작업만 수행한다. 지연 함수와 엄격 함수 함수는 '인자에 관해서' 게으르거나 엄격할 수 있다. 대부분의 함수는 인자를 가지고 무언가를 해야 하며 따라서 인자들을 여러 수준으로 평가하게 된다. 예를 들어 length는 전달받은 인자의 cons cell들만 평가하면 되며 cons cell들의 내용물은 평가하지 않는다. length *thunk*는 length (*thunk* : *thunk* : *thunk* : []) 같은 형태로 평가된 다음 3으로 평가될 것이다. (length . show) 같은 함수는 그 인자들을 완전히 평가해야 한다. length $ show *thunk*의 경우 그 썽크를 normal form으로 평가하는 것 외에는 다른 방법이 없다. 어떤 함수는 다른 함수보다 그 인자들을 더 깊이 평가한다. 인자가 하나인 두 함수 f와 g에 대해, f x가 g x보다 x를 더 깊은 수준까지 평가한다면 f는 g보다 엄격하다. 가끔은 WNHF만을 고려하여 어떤 함수가 그 인자를 최소한 WNHF로 평가한다면 엄격하다고 부르고 아무 평가도 하지 않는 함수는 게으르다고 부른다. 인자가 여러 개인 함수의 경우 어떤 인자에 대해서는 엄격하고 다른 인자에 대해서는 게으르다고 말할 수 있다. 다음과 같은 함수에서, f x y = length $ show x y는 평가할 필요가 전혀 없지만 x는 normal form으로 완전히 평가해야 한다. 따라서 f는 첫 번째 인자에 대해서는 엄격하고 두 번째 인자에 대해서는 게으르다. 연습문제 f x y = show x에서 왜 x를 완전히 평가해야 하는가? 다음 중 어떤 함수가 더 엄격한가? f x = length [head x] g x = length (tail x) fold에 관한 기존 논의에서 foldl의 메모리 문제를 해결하기 위해 적극 평가되는 foldl'을 사용하는 것에 관해 논의한 적이 있다. 본질을 보면 foldr (:) []와 foldl (flip (:)) []는 그 인자들을 같은 수준의 엄격함으로 평가하지만 foldr은 값들을 바로 처리하기 시작할 수 있는 반면 foldl은 cons cell들을 끝까지 평가한 다음에야 결과물을 만들어내기 시작한다. 따라서 엄격함이 가치 있는 경우가 있다. 블랙박스 엄격성 분석 인자가 하나인 함수 f를 상상해 보자. f의 소스 코드는 볼 수 없지만 f가 엄격한지 아닌지 알고 싶다면 어떻게 해야 할까? 아마 가장 쉬운 방법은 표준 프렐류드 값인 undefined를 써보는 것이다. undefined를 조금이라도 평가할 것을 강제하면 프로그램이 멈추고 오류를 출력한다. 따라서 다음은 모두 오류를 출력한다. let (x, y) = undefined in x length undefined head undefined JustS undefined -- 앞선 절에서 정의했던 MaybeS 따라서 엄격한 함수에 undefined를 전달하면 오류를 출력할 것이다. 게으른 함수에 undefined를 전달하면 오류를 출력하지 않고 정상적으로 진행할 수 있을 것이다. 예를 들어 다음 중 어느 것도 오류를 만들지 않는다. let (x, y) = (4, undefined) in x length [undefined, undefined, undefined] head (4 : undefined) Just undefined 즉 f가 엄격한 함수일 필요충분조건은 f undefined가 오류를 출력하고 프로그램을 종료시킨다는 것이다. 비 엄격 의미론의 문맥에서 지금까지 설명한 것은 id 같은 함수를 고려하면 말이 안 되기 시작한다. id는 엄격한가? 아마 "아니, id는 인자를 평가하지 않으므로 게으르다" 같은 반응이 나올 것이다. 그런데 앞의 블랙박스 엄격성 분석을 id에 적용해 보자. 분명히 id undefined는 오류를 출력하고 프로그램을 중단시킨다. 그러면 id는 엄격하다고 해야 하지 않을까? 이런 혼란은 하스켈의 비 엄격 의미론이 이런 문제 전체를 더 애매하게 만들기 때문이다. 비 엄격성에 따르면 어느 것도 필요하기 전에는 평가되지 않는다. 다음 코드에서 length undefined는 평가될까? [4, 10, length undefined, 12] 이 코드를 GHCi에 쳐보면 엄격해 보인다. 여러분은 오류를 받게 된다. 하지만 우리의 질문에는 함정이 있다. 이 값을 가지고 무언가를 하지 않는 한, 이 값이 평가되는지를 논의하는 것은 말이 되지 않는다. GHCi에 head [1, 2, 3]을 입력할 때 이 값을 평가할 이유는 GHCi가 그 결과를 출력해야 하기 때문이다. [4, 10, length undefined, 12]를 입력하면 GHCi는 그 리스트를 출력해야 하므로 normal form으로 평가해야 한다. 일반적인 하스 켈 프로그램에서는 main에서 IO를 수행하지 않는 한 아무것도 평가되지 않는다. 따라서 어떤 것이 평가되는지 안되는지 말하는 것은 이것이 전달되는 상위 수준을 쳐다보지 않으면 의미가 없다. 여기서 얻을 수 있는 교훈은 GHCi를 맹신하지 말라는 것이다. GHCi의 모든 것은 IO를 거치기 때문이다. 그러면 언제 "f x가 x를 강제한다"라고 말할 수 있을까? 이 말이 정말로 의미하는 바는 "f x를 강제할 때 x는 그 결과가 강제되는가"이다. 이제 id로 주의를 돌려보자. id x를 normal form으로 강제하면 x는 normal form이 강제되므로 id는 엄격하다고 결론 내릴 수 있다. id 자체는 인자를 평가하지 않고 호출자에게 그 인자를 전달한다. 다음 코드는 그런 상황을 보여준다. -- We evaluate the right-hand of the let-binding to WHNF by pattern-matching -- against it. let (x, y) = undefined in x -- Error, because we force undefined. let (x, y) = id undefined in x -- Error, because we force undefined. id는 평가의 강제를 "중단" 하지 않는다. 게으른 함수인 const (3, 4)와 비교해 보면, let (x, y) = undefined in x -- Error, because we force undefined. let (x, y) = const (3, 4) undefined -- No error, because const (3, 4) is lazy. 사물에 대한 표기적 관점 여러분이 표기 의미론(denotational semantics)에 익숙하다면 (해당 챕터를 읽어보셨나요?) 함수의 엄격함을 아주 간단명료하게 요약할 수 있다. f ⊥ = ⊥ ⇔ f is strict 위와 같은 가정 하에서, undefined, error "any string", throw 등을 포함해 타입이 forall a. a인 모든 것은 표기 ⊥를 가진다고 할 수 있다. 게으른 패턴 매칭 하스 켈 소스에서 다음과 같은 패턴 매칭을 본 적이 있는가? -- From Control.Arrow (***) f g ~(x, y) = (f x, g y) 위의 패턴 매칭에서 물결 기호(~)는 어떤 의미일까? ~는 게으른 패턴 즉 거부할 수 없는 패턴 irrefutable pattern을 형성한다. 보통은 생성자를 패턴 매칭의 일부로 사용하면 그 생성자에 전달되는 모든 인자를 평가해서 패턴이 일치하는지 확인해야 한다. 예를 들면 위와 같은 함수에서 세 번째 인자는 여러분이 함수를 호출해서 값이 패턴에 일치하는지 확인할 때 평가된다. (첫 번째와 두 번째 인자는 평가되지 않는 것에 주의할 것. 패턴 f와 g는 아무것에나 매칭되기 때문이다. 튜플의 구성요소들은 평가되지 않고 최상위 수준만 평가되는 점도 눈여겨볼 것. let f (Just x) = 1 in f (Just undefined)를 확인해 보라.) 패턴에 물결 기호를 붙이면 그 구성요소 일부가 실제로 사용될 때까지 값의 평가가 지연된다. 하지만 그러면 값이 패턴과 일치하지 않을 수도 있는 위험이 생긴다. 여러분은 컴파일러에게 '날 믿어. 문제없을 거야'라고 말하는 셈이다. (패턴이 일치하지 않으면 런타임 오류가 발생한다) 그 차이점을 확인해 보자. Prelude> let f (x, y) = 1 Prelude> f undefined *** Exception: Prelude.undefined Prelude> let f ~(x, y) = 1 Prelude> f undefined 첫 번째 예제에서는 값이 튜플 패턴에 일치해야 하기 때문에 평가된다. 여러분은 undefined를 평가하고 undefined를 얻으며 진행이 중단된다. 다음 예제에서는 인자가 필요하기 전에는 평가하지 않는데, 그럴 일이 절대 없기 때문에 undefined를 넘겨도 상관이 없다. 화제를 돌려 (***)로 돌아가 보면, Prelude> (const 1 *** const 2) undefined (1,2) 거부할 수 있는 패턴이었다면 이 예제는 실패했을 것이다. 언제 지연 패턴을 사용해야 하는가? 튜플처럼 해당 타입을 위한 생성자가 하나일 때만 지연 패턴을 사용해야 한다. 복수 개의 등식은 거부할 수 없는 패턴과 잘 맞지 않는다. head에 거부할 수 없는 패턴을 넣어보면 알 수 있다. head' :: [a] -> a head' ~[] = undefined head' ~(x:xs) = x 분명히 패턴들 중 하나에는 일치하게 되는데, 인자의 최상위 수준도 필요하지 않으면 평가할 필요가 없다. 따라서 그 인자가 빈 리스트인지 cons 셀 인지도 모른다. 첫 번째 등식에 거부할 수 없는 패턴을 사용했기 때문에 여기에 일치하고, head는 항상 undefined를 반환한다. 연습문제 왜 head'의 등식들의 순서를 바꿔도 문제가 해결되지 않을까? 첫 번째 등식에 일반적인 거부할 수 있는 패턴을 사용해도 head'는 여전히 head와 다르게 동작할까? 다르다면, 왜 그럴까? 비 엄격 의미론의 장점 애초에 왜 하스켈을 비 엄격 언어로 만들어야 하고, 그러면 어떤 이득이 있을까? 시간 페널티 없는 주의 분산(Separation of concerns without time penalty) 지연 평가는 코딩할 때 "보는 그대로를 얻는다" 식의 사고를 장려한다. 예를 들어 긴 리스트의 가장 작은 숫자 세 개를 찾는 걸 생각해 보자. 하스켈에서 그 방법은 극히 자연스럽다. take 3 (sort xs). 하지만 이 코드를 엄격 언어로 단순 번역하는 건 아주 나쁜 발상이다. 그러면 리스트 전체를 정렬하고 처음 세 원소를 잘라내게 된다. 하지만 지연 평가의 경우 세 번째 원소까지만 리스트를 정렬해 내면 거기서 중단하므로 이런 자연스러운 정의가 효율적이게 된다. (정렬의 구현에 따라) 다른 예시를 들어보면 Data.List의 isInfixOf 함수는 문자열이 다른 문자열의 일부인지 확인한다. isInfixOf는 쉽게 정의할 수 있다. isInfixOf :: Eq a => [a] -> [a] -> Bool isInfixOf x y = any (isPrefixOf x) (tails y) 엄격 언어에서 이렇게 하는 건 자살행위다. 리스트의 모든 tail들을 계산하는 건 아주 오래 걸리기 때문이다. 하지만 여기서는 각 tail이 x를 전치사로 포함하는지 확인하기에 충분한 만큼만 평가하며 그러한 tail을 찾으면 바로 중단하고 True를 반환한다. 이 외에도 많은 예시가 있으므로 1 시간 페널티를 걱정하지 않으며 자연스럽게 보이는 코드를 작성할 수 있다. 하지만 컴퓨터 과학이 으레 그렇듯이 (삶도 마찬가지다) 트레이드오프(특히 공간-시간 트레이드오프)가 있는 법이다. 2+2 같은 자잘한 계산에 단순한 Int 대신 썽크를 사용하는 건 낭비다. 더 많은 예시를 보려면 엄격성에 관한 페이지를 볼 것. 개선된 코드 재사용 코드 재사용은 자주 요구되는 사항이다. Data.List의 isInfixOf를 이번엔 더 자세히 살펴보자. 완전한 정의는 다음과 같다. -- From the Prelude or = foldr (||) False any p = or. map p -- From Data.List isPrefixOf [] _ = True isPrefixOf _ [] = False isPrefixOf (x:xs) (y:ys) = x == y && isPrefixOf xs ys tails [] = [[]] tails xss@(_:xs) = xss : tails xs -- Our function isInfixOf :: Eq a => [a] -> [a] -> Bool isInfixOf x y = any (isPrefixOf x) (tails y) any, isPrefixOf, tails는 Data.List 라이브러리에서 가져온 함수다. isInfixOf는 첫 번째 인자 x가 두 번째 인자 y의 부분 수열인지를 확인한다. String 즉 [Char]에 적용될 경우에는 x가 y의 부분 문자열인지 검사한다. 엄격한 방식으로 해석하면 isInfixOf는 y의 모든 tail의 리스트를 생성하고 그중 하나라도 x를 전치사로 가지는지 검사한다. 엄격한 언어에서 이 함수를 이런 식으로 (이미 작성된 any, isPrefixOf, tails를 이용해) 작성하는 건 어리석다. 필요 이상으로 느릴 것이기 때문이다. 여러분은 결국 또다시 직접적으로 재귀를 하거나 명령형 언어라면 중첩된 루프를 쓰게 될 것이다. isPrefixOf는 활용할 여지가 있겠지만 tails를 쓰지는 않을 것이다. any를 써서 조기 종료할 수는 있겠지만 foldr을 쓰고 싶지는 않을 것이니 더 번거로운 일이 될 것이다. 게으른 언어에서는 모든 축약이 알아서 된다. 여러분은 해답을 찾았을 때를 위해 foldr을 손수 작성하거나 tail 들에서 일어나는 재귀를 조기 종료하기 위해 그 재귀를 직접 구현하지 않아도 된다. 표준 라이브러리 코드를 더 잘 재사용할 수 있는 것이다. 지연성은 단순한 속도 관련 상수 요인이 아니다. 지연성은 코드를 합리적으로 작성하는 데 큰 영향을 준다. 사실 무한 자료구조를 정의하고는 필요한 만큼만 사용하는 방식이 어떤 부분이 필요한지 결정한 다음 자료구조를 구축하는 로직을 만드는 것보다 일반적이다. 코드 모듈성 또한 향상되는데, 지연성은 코드를 더 잘게 쪼개어 각 조각이 데이터 생성, 필터링, 기타 조작 등 단순한 작업을 나타낼 수 있도록 하기 때문이다. Why Functional Programming Matters는 지연성이 중요한 예시들에 초점을 맞추고, 지연 평가를 기본으로 삼아야 한다고 강하게 주장한다. 무한 자료구조 (원문 미완성) 예제: fibs = 1:1:zipWith (+) fibs (tail fibs) "rock-scissors-paper" example from Bird&Wadler prune . generate Infinite data structures usually tie a knot, too, but the Sci-Fi-Explanation of that is better left to the next section. One could move the next section before this one but I think that infinite data structures are simpler than tying general knots 흔한 비 엄격 관용구 Tying the knot (원문 미완성) 더 실용적인 예시? repMin Sci-Fi-Explanation: "You can borrow things from the future as long as you don't try to change them". Advanced: the "Blueprint"-technique. Examples: the one from the haskellwiki, the one from the mailing list. 언뜻 보면 순수 함수형 언어는 순환 자료구조를 다루기에 문제가 있어 보인다. 이런 자료형을 생각해 보자. data Foo a = Foo {value :: a, next :: Foo a} 두 개체 x와 y를 생성해서 x와 y가 서로에 대한 참조를 포함하게 만들고 싶을 경우, 전통적인 언어에서는 그 방법이 단순하다. 두 개체를 생성하고 각각의 필드가 서로를 가리키게 만들면 된다. -- Not Haskell code x := new Foo; y := new Foo; x.value := 1; x.next := y; y.value := 2 y.next := x; 하스켈에선 이런 것이 허용되지 않는다. 대신 지연 평가에 의존한다. circularFoo :: Foo Int circularFoo = x where x = Foo 1 y y = Foo 2 x 이것은 Foo 생성자가 함수이며 대부분의 함수처럼 지연 평가된다는 사실에 의거한다. 필드들은 필요한 때만 평가된다. 무대 뒤에서 어떤 일이 벌어지는지 이해해 보자. 지연 값이 생성되면 (예를 들어 Foo 호출에 의해) 컴파일러는 함수 호출과 인자를 포함하는 썽크라는 내부 자료구조를 구축한다. 함수의 값이 필요해지면 그 함수를 호출한다. 그러면 썽크 자료구조가 반환값으로 교체된다. 따라서 그 값을 참조하는 어떤 것이든 함수를 호출할 필요 없이 그 값을 곧바로 얻는다. (하스 켈 언어 표준은 썽크를 전혀 언급하지 않는다는 것을 주의하라. 썽크는 구현을 위한 수단이다. 수학적 관점에서 이것은 상호 재귀의 간단한 예시다.) 즉 circularFoo를 호출한 결과인 x는 사실 썽크다. 인자들 중 하나는 y를 나타내는 두 번째 썽크에 대한 참조다. 이것은 다시 x를 나타내는 썽크를 가리킨다. next x라는 값을 사용한다면 x 썽크의 평가가 강제되어 y 썽크에 대한 참조를 반환한다. next $ next x라는 값을 사용하면 두 썽크의 평가를 강제하게 된다. 그러면 이제 두 썽크가 실제 Foo 구조체로 교체되어 서로를 가리키게 된다. 바로 우리가 원했던 결과다. 이런 기교는 주로 생성자 함수들에 활용되지만 생성자에 국한되는 이야기는 아니다. 이런 것도 가능하며, x = f y y = g x 논리는 동일하다. Memoization, Sharing and Dynamic Programming Dynamic programming with immutable arrays. DP with other finite maps, Hinze's paper "Trouble shared is Trouble halved". Let-floating \x-> let z = foo x in \y -> ... . 지연성에 대한 결론 지연성은... 성능을 크게 향상할 수 있다. 성능을 해치는 경우도 있다. 코드를 간결하게 만든다. 어려운 문제를 다룰 수 있게 만든다. 데이터 생성과 처리를 구분해서 고려할 수 있게 한다. 노트 레퍼런스 Laziness on the Haskell wiki Lazy evaluation tutorial on the Haskell wiki 일반적으로 prune . generate 같은 표현식에서 generate가 어떤 리스트를 생성하고 prune이 그걸 잘라내는 경우 비 엄격 언어에서는 훨씬 효율적으로 작동한다. ↩ 5 시간 및 공간 프로파일링 원문: https://en.wikibooks.org/wiki/Haskell/Time_and_space_profiling 어느 언어든 프로파일링은 퍼포먼스 최적화의 중요한 첫걸음이다. 프로파일링 없이는 경험이 많은 프로그래머라도 나쁜 퍼포먼스의 원인이 무엇인지 올바르게 이해하기 어렵다. 하스켈에서 지연에 의한 공간 누수는 문제의<NAME>인이다. 즉 프로파일링 사용법을 익히는 것이 중요하다. 지금으로선 이 주제에 대한 외부 자료들에 대한 링크만 있다. 참고 자료 http://book.realworldhaskell.org/read/profiling-and-optimization.html https://www.haskell.org/ghc/docs/latest/html/users_guide/profiling.html http://www.haskell.org/haskellwiki/How_to_profile_a_Haskell_program 6 적극성 원문: https://en.wikibooks.org/wiki/Haskell/Strictness 적극 평가와 지연 평가의 차이 지연이 왜 문제인가 적극성 표기(annotation) seq 참고 자료 적극 평가와 지연 평가의 차이 적극 평가(strict evaluation, or eager evaluation)는 표현식이 변수에 바인딩 되자마자 평가하는 전략이다. 예를 들어 x = 3 * 7을 읽으면 3 * 7이 즉시 계산되어 x에 21이 바인딩 된다. 반대로 지연 평가에서는 값이 필요할 때만 계산된다. x = 3 * 7의 경우 3 * 7은 가령 x의 값을 출력하기 위해서 등의 이유로 필요해지기 전에는 평가되지 않는다. 지연이 왜 문제인가 지연 평가에는 대개 썽크라는 객체가 관여한다. 썽크는 일종의 자리 표시용으로서 데이터 그 자체가 아니라 그 데이터를 계산하는 방법을 기술한다. 어떤 개체는 그것을 계산하기 위한 썽크로 대체할 수 있다. 해당 객체가 복사될 때 그것이 썽크인지 아닌지는 상관없고 그대로 복사된다. (대부분의 구현에서는 데이터에 대한 포인터가 생성된다) 그 개체가 평가될 때는 먼저 썽크인지를 확인한다. 썽크라면 실행되고 아니라면 실제 데이터가 반환된다. 썽크라는 마술 덕에 지연성을 구현할 수 있는 것이다. 일반적인 구현에서 썽크는 단지 (대개 정적인) 코드 조각에 대한 포인터와 그 코드가 실행될 데이터에 대한 또 다른 포인터를 모아놓은 것이다. 썽크에 의해 계산되는 개체가 코드에 대한 포인터와 연관 데이터보다 크다면 썽크가 메모리 사용면에서 이득이다. 하지만 썽크에 의해 계산되는 개체가 그 썽크보다 작으면 썽크는 메모리만 더 많이 쓰게 된다. 예를 들어 표현식 iterate (+ 1) 0에 의해 생성된 무한 리스트를 생각해 보자. 이 리스트의 길이는 무한하지만 그 코드는 단지 더하기 연산이고 두 데이터 조각 1과 0은 정수일뿐이다. 이 경우 이 리스트를 나타내는 썽크는 메모리를 무한히 사용할 실제 리스트보다 훨씬 적은 메모리를 사용한다. 하지만 표현식 4 * 13 + 2이 생성하는 숫자를 생각해 보자. 이 숫자의 값은 54지만 썽크 형태로는 곱셈, 덧셈, 숫자 세 개가 필요하다. 이런 경우 썽크는 메모리 면에서 좋지 않다. 두 번째 경우 메모리를 너무 많이 소비해서 전체 히프를 소비하고 가비지 컬렉터를 실행하게 만든다. 이러면 프로그램 실행이 심각하게 느려질 수 있다. 바로 이것이 지연성이 문제가 되는 주 이유다. 또한 결괏값이 사용될 것이라면 절약할 계산은 없고 대신 썽크를 구축하는 오버헤드만 지불해야 한다. 하지만 이 오버헤드는 대부분의 경우 프로그래머가 신경 쓸 것이 아니다. 이보다 더 큰 개선을 얻을 수 있는 다른 중요한 요인들은 많다. GHC 같은 하스 켈 컴파일러는 '정적 분석'을 통해 이런 오버헤드를 제거할 수 있다. 적극성 표기(annotation) 원문 미완성 seq 원문 미완성 참고 자료 하스 켈 위키의 strictness 7 알고리즘 복잡도 원문: https://en.wikibooks.org/wiki/Haskell/Algorithm_complexity 복잡도 이론(Complexity Theory)은 프로그램 실행이 입력의 크기에 따라 얼마나 걸릴지에 관한 연구다. 복잡도 이론에 대한 좋은 입문서는 많고 모든 훌륭한 알고리즘 서적이 그 기초를 설명한다. 여기서는 최소한의 논의만 한다. 핵심은 프로그램이 더 많은 데이터에 얼마나 잘 대응하는가이다. 아주 적은 양의 데이터에는 빠르게 실행되지만 많은 양의 데이터에 대해서는 느린 프로그램은 그다지 유용하지 않다. (물론 적은 데이터만 다뤄야 하는 경우가 아닐 때만.) 리스트의 원소들의 합을 반환하는 다음의 하스 켈 함수를 보자. sum [] = 0 sum (x:xs) = x + sum xs 이 함수가 완료되려면 얼마나 걸릴까? 이는 매우 어려운 질문이다. 여기에는 프로세서 속도, 메모리 양, 덧셈이 수행되는 방식, 리스트의 길이, 컴퓨터에서 다른 프로그램이 몇 개나 돌아가는지 등 온갖 것이 관여한다. 고려할 것이 너무 많으므로 우리에겐 더 간단한 모델이 필요하다. 우리가 사용하는 모델은 일종의 "machine step"이다. 질문은 "이 프로그램이 완료되려면 machine step이 몇 번 필요한가?"이다. 이 경우에는 그 답이 오직 입력 리스트의 길이에 달려있다. 입력 리스트의 길이가 0이면 함수는 0, 1, 2 또는 아주 적은 수의 machine step만 밟을 것이다. 이는 machine step을 어떻게 세는지에 달렸다. (패턴 매칭에 한 단계, 값 0을 반환하는데 한 단계 등) 리스트의 길이가 1이면 어떨까? 얼마나 걸리든 간에 길이 0일 때의 단계 수와 (유일한) 첫 번째 원소를 처리하는 단계 수를 더한 만큼 걸릴 것이다. 입력 리스트의 길이가 n 일 때 빈 리스트에 걸리는 단계 수를 y라 하고 각 원소마다 덧셈 및 재귀 호출을 처리하는데 걸리는 단계 수를 x라 하자. 덧셈을 n 번 해야 하므로 이 함수에 걸리는 총 시간은 nx + y이다. 여기서 x와 y는 상수 값들인데, n에 무관하고 우리가 machine step을 어떻게 정의하는가에 달려있기 때문에 중요하게 여기지 않는다. 따라서 이 sum 함수의 복잡도는 O(n) ("order n"이라 읽는다)이다. 무언가 O(n)이라고 말하는 것은 어떤 상수 인자 x, y에 대해 이 함수가 완료하는데 machine step이 nx + y 필요하다는 뜻이다. 다음의 리스트 정렬 알고리즘을 보자. (흔히 "삽입 정렬"이라 부른다) sort [] = [] sort [x] = [x] sort (x:xs) = insert (sort xs) where insert [] = [x] insert (y:ys) | x <= y = x : y : ys | otherwise = y : insert ys 이 알고리즘은 이렇게 작동한다. 빈 리스트나 원소가 하나인 리스트는 이미 정렬되어 있으므로 그대로 반환한다. 그 외의 경우 리스트는 x:xs 꼴이다. 이 경우 xs를 정렬하고 x를 적절한 위치에 넣어야 한다. insert 함수가 바로 그 일을 한다. insert는 이제는 정렬된 tail을 순회하여 x를 알맞은 곳에 삽입한다. 이 함수가 얼마나 걸릴지 분석해 보자. 길이 n인 리스트를 정렬하는데 f(n) 단계가 걸린다고 가정하자. 원소가 n 개인 리스트를 정렬하려면 먼저 그 리스트의 tail을 정렬해야 하고 f(n-1) 시간이 걸린다. 이제 이 새로운 리스트에 x를 삽입해야 한다. x가 끝에 추가된다면 O(n-1) = O(n) 단계가 걸릴 것이다. 전부 합치면 O(n) 만큼의 작업을 O(n) 번만큼 반복해야 하고 이는 이 정렬 알고리즘의 총 복잡도가 ( 2 ) 라는 뜻이다. 이 제곱은 상수가 아니므로 버릴 수 없다. 이게 무슨 뜻일까? 아주 긴 리스트에 대해 sum 함수 자체는 그리 오래 걸리지 않지만 sort 함수는 시간이 제법 걸린다. 물론 ( 2 ) 보다 느리게 실행되는 알고리즘들도 있고 ( ) 보다 빠르게 실행되는 것들도 있다. (또한 ( 2 ) 알고리즘의 한 단계를 실행하는 것이 더 적게 걸린다면, 실제로는 ( ) 알고리즘보다 빠를 수도 있다. 리스트와 배열에 대한 랜덤 액세스 함수들을 생각해 보자. 최악의 경우 길이 n인 리스트의 임의 원소에 접근하는 시간은 O(n)이다. (마지막 원소에 접근하는 것을 생각하면 된다) 하지만 배열의 경우 어떤 원소든 즉시 접근할 수 있으며 이것을 두고 상수 시간 또는 O(1)이 걸린다고들 말한다. 기본적으로 모든 알고리즘은 최대한 이만큼만 빨라질 수 있다. 복잡도 이론에는 훨씬 많은 것들이 있지만 이 튜토리얼의 논의들을 이해하는 데는 이 정도면 충분할 것이다. O(1)은 O(n)보다 빠르고 O(n)은 ( 2 ) 보다 빠르다는 것만 기억하자. 최적화 원문 없음 3 하스 켈 실전 표준 라이브러리의 이해, 그래픽 인터페이스 구축, 데이터베이스 작업 등 일상적인 주제. 초급반에서 바로 여기로 넘어와도 된다. 라이브러리 레퍼런스 소개 Maybe - IO - Random 자료구조 기초 배열 - 맵 일반적인 작업 디버깅 테스팅 소프트웨어 패키징 (Cabal) Foreign Function Interface(FFI) 활용하기 제네릭 프로그래밍: 정형화된 코드는 그만 특수 작업 그래픽 유저 인터페이스 (GUI) 데이터베이스 XML 다루기 수학식의 파싱 기본적인 타입 검사기 작성 1 라이브러리 레퍼런스 라이브러리 레퍼런스 소개 Maybe - IO - Random 자료구조 기초 배열 - 맵 1 소개 원문: https://en.wikibooks.org/wiki/Haskell/Libraries 하스켈의 풍부한 라이브러리는 계속 커지고 있다. 라이브러리들은 몇 가지 그룹으로 나뉜다. ("the Prelude"로 칭해지는) 표준 Prelude는 하스 켈 2010 표준에 정의되어 있고 여러분이 작성하는 모든 모듈에 자동으로 임포트 된다. 표준 Prelude는 문자열, 리스트, 숫자 같은 표준 타입과 이들에 대한 산술, map, foldr 등 기본적인 함수들을 정의한다. 표준 라이브러리도 언어 표준에 정의되어 있다. 하지만 사용하려면 임포트 해야 한다. 이 라이브러리들의 명세는 하스 켈 2010 표준에서 볼 수 있다. 1998년부터 표준 라이브러리는 꾸준히 늘어나 base 라이브러리라는 사실상 표준이 되었다. Hugs와 GHC 모두 동일한 base 라이브러리를 사용할 수 있다. 컴파일러에 따라 추가적인 라이브러리가 딸려올 수 있다. 특히 GHC는 containers, text, bytestring 같은 널리 쓰이는 유용한 라이브러리들을 포함한다. 1 이외에 많은 라이브러리들을 Hackage에서 가져와 cabal 유틸리티로 설치할 수 있다. 하스 켈 98 표준이 정해졌을 때 모듈에는 1차원적인 이름 공간이 부여되었다. 이것이 그다지 적절하지 않아서, 모듈 이름에 점(.)을 허용하는 계층적 이름 공간이 추가되었다. 역호환성을 위해 표준 라이브러리들은 여전히 이전의 비계층적 이름으로 접근 가능하다. 따라서 List와 Data.List 모듈은 동일한 표준 리스트 라이브러리를 가리킨다. 라이브러리를 여러분의 프로그램으로 임포트 하는 자세한 방법은 Modules 장을 참조하라. 하스 켈 소프트웨어를 패키징 하기 위한 Cabal 시스템에 대해서는 Haskell/Packaging을 참조하라. Haddock 문서 라이브러리 레퍼런스 문서는 대개 Haddock 도구를 이용해 생성한다. GHC에 동봉된 라이브러리들 역시 이런 식으로 문서화된다. 문서를 온라인으로 볼 수 있고 GHC를 설치했다면 로컬 복사본이 있을 것이다. Haddock은 하이퍼링크 문서를 생성하므로 모든 함수, 타입, 클래스 이름은 누르면 그 정의로 이동한다. 너무 많은 라이브러리에 질릴 수도 있기 때문에 이 튜토리얼에서는 중요한 것들만 짚고 넘어가겠다. Haddock은 인스턴스를 통해 타입과 클래스를 상호 참조한다. 예를 들어 Data.Maybe 라이브러리에서 Maybe 데이터 타입은 Ord의 인스턴스로서 나열된다. Ord a => Ord (Maybe a) Ord의 인스턴스인 Foo 타입을 선언하면 Maybe Foo 타입 역시 자동으로 Ord의 인스턴스가 된다. 문서에서 단어 Ord를 누르면 Ord 클래스의 정의로 이동하여 아주 긴 인스턴스 목록을 볼 것이다. Maybe의 인스턴스 역시 이 목록에 포함된다. 패키지는 라이브러리 배포 단위다. 편리한 배포와 설치를 위해 모듈들을 묶은 것이다. ↩ 1 Maybe 원문: https://en.wikibooks.org/wiki/Haskell/Libraries/Maybe 정의 라이브러리 함수 질의 isJust isNothing 빠져나오기 maybe fromMaybe 리스트와 Maybe listToMaybe maybeToList 리스트 조작 어떤 실패는 무시하고 계속하기 catMaybes mapMaybe 실패에서 멈추기 sequence Maybe 데이터는 실패할 수 있는 함수에서 쓰인다. 완전한 설명은 Maybe 모나드장에 있다. 정의 표준 Prelude는 Maybe 타입을 다음과 같이 정의한다. data Maybe a = Nothing | Just a 타입 a는 다 형이므로 복잡한 타입 혹은 심지어 (IO () 타입 같은) 다른 모나드를 포함할 수도 있다. 라이브러리 함수 Data.Maybe 모듈은 표준 라이브러리의 일부로서, Maybe 값을 다루기 위한 함수들을 포함한다. 질의 Maybe 값에 대한 정보를 주는 자명한 함수 두 개가 있다. isJust isJust는 인자가 Just _ 형태면 True를 반환한다. isJust :: Maybe a -> Bool isJust (Just _) = True isJust Nothing = False isNothing isNothing은 인자가 Nothing 이면 True를 반환한다. isNothing :: Maybe a -> Bool isNothing (Just _) = False isNothing Nothing = True 빠져나오기 Maybe 값을 Maybe가 아닌 값으로 변환하는 함수가 여럿 있다. maybe maybe는 Just 내부의 값에 함수를 적용한다. 하지만 Nothing이 주어지면 기본 값을 반환한다. maybe :: b -> (a -> b) -> Maybe a -> b maybe _ f (Just x) = f x maybe z _ Nothing = z fromMaybe Just에 아무 함수도 적용하지 않고 maybe를 쓰길 원한다면 id 함수를 인자로 maybe를 호출하면 된다. Data.Maybe에는 이미 그런 fromMaybe가 들어있다. fromMaybe :: a -> Maybe a -> a fromMaybe z = maybe z id 인자 생략식(point-free style)을 쓴 것을 주목하라. maybe z id는 Maybe 값을 취하는 함수로 평가된다. 리스트와 Maybe 리스트와 Maybe 사이의 많은 유사점은 리스트 모나드장에서 다룬 바 있다. 리스트와 Maybe를 서로 변환하는 함수들이 있다. listToMaybe 실패한 계산은 리스트의 경우 []를, Maybe의 경우 Nothing을 반환한다. listToMaybe는 리스트 모나드를 Maybe 모나드로 변환한다. Maybe는 값을 하나만 가질 수 있으므로 listToMaybe는 리스트의 첫 번째 해만 취한다. listToMaybe :: [a] -> Maybe a listToMaybe [] = Nothing listToMaybe (x:_) = Just x maybeToList listToMaybe의 반대는 당연히 maybeToList이다. maybeToList :: Maybe a -> [a] maybeToList Nothing = [] maybeToList (Just x) = [x] 리스트 조작 평범한 Prelude 리스트 조작 함수들과 비슷하지만 Maybe 값에 특화된 함수들이 있다. 어떤 실패는 무시하고 계속하기 한 부분이 실패했다고 모든 계산이 실패하지는 않는 OR 함수가 필요할 수 있다. catMaybes catMaybes는 Maybe 값들의 리스트를 취해 Just _ 형태의 모든 값을 추출하고 Just 생성자를 떼어낸다. 그 일은 리스트 조건 제시식이 한다. (패턴 매칭 장에서 봤던 것처럼) catMaybes :: [Maybe a] -> [a] catMaybes ms = [ x | Just x <- ms ] mapMaybe mapMaybe는 함수를 리스트에 적용하고 그 결과를 수집한다. 여러분이 이미 알고 있는 함수들의 합성으로 이해할 수 있다. mapMaybe :: (a -> Maybe b) -> [a] -> [b] mapMaybe f xs = catMaybes (map f xs) 사실 Data.Maybe에 들어있는 실제 정의는 리스트를 순회하는데 이게 더 효율적이다. mapMaybe :: (a -> Maybe b) -> [a] -> [b] mapMaybe _ [] = [] mapMaybe f (x:xs) = case f x of Just y -> y : mapMaybe f xs Nothing -> mapMaybe f xs 실패에서 멈추기 OR 대신 모두 성공했을 때만 값을 수집할 필요가 있다면 sequence sequence :: [Maybe a] -> Maybe [a] sequence [] = Just [] sequence (Nothing:xs) = Nothing sequence (Just x:xs) = case sequence xs of Just xs' -> Just (x:xs') _ -> Nothing 2 IO 원문: https://en.wikibooks.org/wiki/Haskell/Libraries/IO IO 라이브러리 Bracket 파일 읽기 프로그램 IO 라이브러리 여기서는 System.IO 모듈의 가장 흔하게 쓰이는 요소들을 살펴본다. data IOMode = ReadMode | WriteMode | AppendMode | ReadWriteMode openFile :: FilePath -> IOMode -> IO Handle hClose :: Handle -> IO () hIsEOF :: Handle -> IO Bool hGetChar :: Handle -> IO Char hGetLine :: Handle -> IO String hGetContents :: Handle -> IO String getChar :: IO Char getLine :: IO String getContents :: IO String hPutChar :: Handle -> Char -> IO () hPutStr :: Handle -> String -> IO () hPutStrLn :: Handle -> String -> IO () putChar :: Char -> IO () putStr :: String -> IO () putStrLn :: String -> IO () readFile :: FilePath -> IO String writeFile :: FilePath -> String -> IO () 노트 FilePath는 String의 타입 동의어다. 예를 들어 readFile 함수는 String(읽을 파일)을 받아서 액션을 반환하는데 이 액션을 실행하면 그 파일의 내용물을 내뱉는다. 타입 동의어에 관해서는 타입 선언 챕터를 볼 것. 대부분의 IO 함수는 보기만 해도 알 수 있다. openFile과 hClose는 각각 파일을 열고 닫는다. IOMode 인자는 파일을 여는 방식을 결정한다. hIsEOF는 파일의 끝을 검사한다. hGetChar와 hGetLine은 각각 파일에서 문자 하나 또는 한 줄을 통째로 읽는다. hGetContents는 파일 전체를 읽는다. 파생된 버전인 getChar, getLine, getContents는 표준 입력으로부터 읽는다. hPutChar는 파일에 문자를 출력한다. hPutStr은 문자열을 출력한다. hPutStrLn은 끝에 개행 문자를 붙인 문자열을 출력한다. h가 없는 파생 버전들은 표준 출력에 대해 작동한다. readFile과 writeFile 함수는 파일을 열 필요 없이 파일 전체를 읽거나 쓴다. Bracket bracket 함수는 Control.Exception 모듈에 들어있다. bracket은 액션을 안전하게 수행하는 걸 보조한다. bracket :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c 파일을 열어 문자를 기록하고 그 파일을 닫는 함수를 생각해 보자. 그런 함수를 작성할 때는 도중에 오류가 발생해도 파일이 성공적으로 닫히는 것을 보장해야 한다. bracket 함수는 이런 일을 쉽게 만든다. bracket은 세 인자를 받는다. 첫 번째는 처음에 수행할 액션, 두 번째는 오류가 있든 없든 마지막에 수행할 액션, 세 번째는 중간에 수행되며 오류를 일으킬 수도 있는 액션이다. 우리의 문자를 기록하는 함수는 이렇게 작성할 수 있다. writeChar :: FilePath -> Char -> IO () writeChar fp c = bracket (openFile fp WriteMode) hClose (\h -> hPutChar h c) 이 함수는 파일을 열어 문자를 기록하고 그 파일을 닫는다. 그런데 문자 기록을 실패해도 여전히 hClose가 실행되며 예외는 나중에 다시 발생한다. 이렇게 하면 예외를 잡아서 모든 핸들을 닫는 것을 걱정하지 않아도 된다. 파일 읽기 프로그램 사용자가 파일을 읽고 쓸 수 있게 하는 간단한 프로그램을 작성해 볼 수 있다. 사용법은 형편없고 모든 오류를 잡아내지도 않는다. (존재하지 않는 파일을 읽는 등) 그래도 IO를 활용하는 방법을 설명하기에는 꽤나 괜찮은 예시다. 다음 코드를 "FileRead.hs"에 입력하고 컴파일 및 실행해 보자. import System.IO import Control.Exception main = doLoop doLoop = do putStrLn "Enter a command rFN wFN or q to quit:" command <- getLine case command of 'q':_ -> return () 'r':filename -> do putStrLn ("Reading " ++ filename) doRead filename doLoop 'w':filename -> do putStrLn ("Writing " ++ filename) doWrite filename doLoop _ -> doLoop doRead filename = bracket (openFile filename ReadMode) hClose (\h -> do contents <- hGetContents h putStrLn "The first 100 chars:" putStrLn (take 100 contents)) doWrite filename = do putStrLn "Enter text to go into the file:" contents <- getLine bracket (openFile filename WriteMode) hClose (\h -> hPutStrLn h contents) 이 프로그램은 무슨 일을 할까? 먼저 사용법을 짧게 알리고 커맨드를 읽는다. 그다음 커맨드에 대해 case 분기를 수행해서 첫 번째 문자가 'q'인지 확인한다. 맞는다면 유닛 타입의 값을 반환한다. 노트 return 함수는 a 타입의 값을 취해 IO a 타입의 액션을 반환한다. 따라서 return ()의 타입은 IO ()이다. 커맨드의 첫 번째 문자가 'q'가 아니면 이 프로그램은 그 문자가 'r'이고 변수 filename에 바인딩 될 문자열이 이어서 들어오는지 검사한다. 그런 경우 파일을 읽고 있다고 알리고 읽기를 수행한 다음 doLoop를 다시 실행한다. w에 대한 검사도 거의 동일하다. 그 외의 경우 만능 문자인 _에 일치하고 doLoop를 반복한다. doRead 함수는 bracket 함수를 사용해 파일 읽기에 문제가 없음을 보장한다. doRead는 파일을 ReadMode 모드로 열어서 그 내용물을 읽고 처음 100개 문자를 출력한다. (take 함수는 정수 n과 리스트를 취해서 그 리스트의 첫 n 개 원소를 반환한다) doWrite 함수는 텍스트를 요구하고 키보드로부터 그 텍스트를 읽어 지정된 파일에 그 텍스트를 기록한다. 노트 doRead와 doWrite는 readFile과 writeFile을 사용해 더 간단하게 만들 수 있지만 더 복잡한 함수를 활용하는 방법을 보여주기 위해 풀어썼다. 이 프로그램은 큰 문제가 하나 있다. 존재하지 않는 파일을 읽거나 *\bs^#_@ 같이 이상한 파일 이름을 지정하면 프로그램이 죽는다. doRead와 doWrite에 들어있는 bracket 호출이 그런 일을 방지해야 할 것처럼 보이지만 그렇지 않다. bracket은 몸체에서 발생하는 예외만 잡으며 구동 함수와 마무리 함수(openFile과 hClose)에서 발생하는 예외는 잡지 않는다. 완전히 안전하게 만들려면 openFile이 일으키는 예외를 잡을 수단이 필요하다. 연습문제 위 프로그램을 변형해 사용자가 파일 읽기, 파일 쓰기, 종료 중 무엇을 원하는지를 먼저 물어보도록 만들 것. 사용자가 "quit"으로 응답하면 프로그램이 종료되어야 한다. "read"로 응답하면 프로그램은 파일 이름을 요청하고 그 파일을 화면에 출력하라. (파일이 존재하지 않으면 프로그램이 크래시가 날 것이다) "write"로 응답하면 파일 이름을 요청한 다음 그 파일에 기록할 텍스트를 "."가 나오기 전까지 받는다. 단 "." 자체도 파일에 기록해야 한다. 예를 들어 이 프로그램을 실행하면 다음과 같은 결과가 나와야 한다. Do you want to [read] a file, [write] a file, or [quit]? read Enter a file name to read: foo ...contents of foo... Do you want to [read] a file, [write] a file, or [quit]? write Enter a file name to write: foo Enter text (dot on a line by itself to end): this is some text for foo Do you want to [read] a file, [write] a file, or [quit]? read Enter a file name to read: foo this is some text for foo Do you want to [read] a file, [write] a file, or [quit]? blech I don't understand the command blech. Do you want to [read] a file, [write] a file, or [quit]? quit Goodbye! 3 Random 원문: https://en.wikibooks.org/wiki/Haskell/Libraries/Random Random의 예시들 표준 난수 생성기 QuickCheck를 활용해 무작위 데이터 생성하기 Random의 예시들 난수는 많은 쓰임새를 가진다. 예시: 임의의 정수 10개 import System.Random main = do gen <- newStdGen let ns = randoms gen :: [Int] print $ take 10 ns IO 액션 newStdGen은 의사 난수 생성기 상태를 나타내는 StdGen를 생성한다. 이 StdGen은 의사 난수를 생성해야 하는 함수들에 전달될 수 있다. (시스템에 의존적인 방식으로 자동 초기화되는 전역 난수 생성기도 존재한다. 이 생성기는 IO 모나드 내에서 유지되며 getStdGen을 통해 접근할 수 있다. 그런데 이건 라이브러리가 깔끔하지 못한 면이 있는데, newStdGen만 있으면 충분하기 때문이다.) 혹은 mkStdGen을 활용할 수도 있다. 예시: mkStdGen을 이용한 무작위 float 10개 import System.Random randomList :: (Random a) => Int -> [a] randomList seed = randoms (mkStdGen seed) main :: IO () main = do print $ take 10 (randomList 42 :: [Float]) 이 스크립트를 실행하면 다음과 비슷한 결과가 나온다. [0.110407025,0.8453985,0.3077821,0.78138804,0.5242582,0.5196911,0.20084688,0.4794773,0.3240164, 6.1566383e-2] 예시: 리스트를 헤집어놓기 (완벽하지 않음) import Data.List ( sortBy) import Data.Ord ( comparing) import System.Random ( Random, RandomGen, randoms, newStdGen) main :: IO () main = do gen <- newStdGen interact $ unlines . unsort gen . lines unsort :: (RandomGen g) => g -> [x] -> [x] unsort g es = map snd . sortBy (comparing fst) $ zip rs es where rs = randoms g :: [Integer] randoms는 난수 생성만을 위한 것이 아니다. 예를 들어 random('s'가 없음)을 이용해 난수 하나와 새로운 StdGen을 생성하고 그 StdGen을 이용해 다음 StdGen을 생성할 수 있다. 또한 randomR과 randomRs는 범위를 지정하는 인자를 받는다. 계속 읽으면 더 많은 영감을 받을 수 있다. 표준 난수 생성기 하스 켈 표준 난수 함수 및 타입은 System.Random 모듈에 정의되어 있다. 무작위의 정의는 그 자신을 더 일반화하기 위해 클래스들을 이용하기 때문에 이해하기가 다소 난해하다. 표준에 따르면: ---------------- The RandomGen class ------------------------ class RandomGen g where genRange :: g -> (Int, Int) next :: g -> (Int, g) split :: g -> (g, g) ---------------- A standard instance of RandomGen ----------- data StdGen = ... -- Abstract 여기서는 표준 난수 생성기 "객체"인 StdGen을 도입한다. 이것은 RandomGen 클래스의 인스턴스이며 이 클래스는 System.Random 라이브러리와 함께 사용할 의사 난수 생성기 라이브러리가 구현해야 하는 연산들을 기술한다. r :: StdGen에 대해 다음을 주장할 수 있다. (x, r2) = next r 이러면 무작위 Int인 x와 새로운 StdGen인 r2를 얻는다. next 함수는 RandomGen 클래스에 정의되어 있으며 StdGen 타입의 무언가에 next를 적용할 수 있는데, 아래에서 볼 수 있듯 StdGen은 RandomGen 클래스의 인스턴스기 때문이다. 표준에 따르면: instance RandomGen StdGen where ... instance Read StdGen where ... instance Show StdGen where ... 이는 StdGen과 문자열을 서로 변환할 수 있다는 뜻이기도 하다. (... 부분은 하스 켈 구문이 아니라 표준은 이 인스턴스들의 구현을 정의하지 않는다는 뜻이다.) 표준에 따르면: mkStdGen :: Int -> StdGen 씨값 Int을 mkStdGen 함수에 넣으면 생성기를 얻는다. 함수형 언어로서 하스켈은 next를 통해 새로운 난수 생성기를 반환한다. 변수를 변경할 수 있는 언어들에서 의사 난수 생성기 루틴은 생성기의 상태를 바꾸는 숨겨진 사이드 이펙트를 가진다. 하스켈은 그렇게 하지 않는다. 하스켈에서 의사 난수 세 개를 생성하려면 이런 식으로 해야 한다. let (x1, r2) = next r (x2, r3) = next r2 (x3, r4) = next r3 무작위 값 x1, x2, x3은 그 자체로 무작위 정수다. (0, 999) 같은 구간으로 한정하려면 그걸 고려하여 제작된 라이브러리 루틴이 있어야 하며, 그런 루틴이 실제로 있다. 표준에 따르면: ---------------- The Random class --------------------------- class Random a where randomR :: RandomGen g => (a, a) -> g -> (a, g) random :: RandomGen g => g -> (a, g) randomRs :: RandomGen g => (a, a) -> g -> [a] randoms :: RandomGen g => g -> [a] randomRIO :: (a, a) -> IO a randomIO :: IO a StdGen은 RandomGen 타입의 유일한 인스턴스임을 기억하라. (여러분이 직접 난수 생성기를 만들지 않는 한) 따라서 위의 타입들 중 g를 StdGen 으로 치환해 볼 수 있다. randomR :: (a, a) -> StdGen -> (a, StdGen) random :: StdGen -> (a, StdGen) randomRs :: (a, a) -> StdGen -> [a] randoms :: StdGen -> [a] 하지만 이 모든 것은 Random이라는 또 다른 클래스 선언 내부에 있다는 것을 기억하자. 즉 Random의 모든 인스턴스는 이 함수들을 사용할 수 있다. 표준에서 Random의 인스턴스인 것들은 다음과 같다. instance Random Integer where ... instance Random Float where ... instance Random Double where ... instance Random Bool where ... instance Random Char where ... 즉 위의 모든 타입에 대해 난수의 구간을 정할 수 있다. 다음과 같이 무작위 정수를 얻을 수도 있고 (x1, r2) = randomR (0,999) r 무작위 대문자를 얻을 수도 있으며 (c2, r3) = randomR ('A', 'Z') r2 심지어 무작위 비트를 얻을 수도 있다. (b3, r4) = randomR (False, True) r3 지금까지는 좋다. 하지만 프로그램 전체에 걸쳐 난수 상태를 연결하는 것은 고통스럽고 오류에 취약하며 프로그램의 훌륭하고 깔끔한 함수형 성질을 파괴하는 경향이 있다. RandomGen 클래스의 split 함수는 이런 문제를 어느 정도는 해결한다. split은 생성기를 하나 받아서 생성기 두 개를 돌려준다. 다음과 같은 경우, (r1, r2) = split r x = foo r1 여기서는 r1을 foo 함수에 전달해 모종의 작업을 하고 그 결과 x를 반환한다. 이제 다음에 올 의사 난수 생성기에는 r2를 쓰면 된다. split이 없었다면 이렇게 써야 했을 것이다. (x, r2) = foo r1 가끔은 이것조차 귀찮을 때가 있다. 이를 해결하는 빠르면서도 지저분한 방법은 모든 것을 IO 모나드 안에 집어넣는 것이다. 그리고 다른 언어들처럼 표준 전역 난수 생성기를 얻게 된다. 표준에 따르면: ---------------- The global random generator ---------------- newStdGen :: IO StdGen setStdGen :: StdGen -> IO () getStdGen :: IO StdGen getStdRandom :: (StdGen -> (a, StdGen)) -> IO a 이제 이렇게 작성할 수 있다. foo :: IO Int foo = do r1 <- getStdGen let (x, r2) = randomR (0,999) r1 setStdGen r2 return x 전역 생성기를 획득하고, 사용하고, 갱신한다. (그러지 않으면 모든 난수가 똑같을 것이다) 하지만 매번 전역 생성기를 획득해 갱신하는 것은 고통스럽기 때문에 보통은 getStdRandom을 사용한다. 이것의 인자는 함수다. 그 함수의 타입을 random과 randomR의 타입에 대조해 보면 잘 들어맞는다. 이런 식으로 IO 모나드 안에서 무작위 정수를 얻을 수 있다. x <- getStdRandom $ randomR (1,999) randomR (1,999)의 타입은 StdGen -> (Int, StdGen)이므로 getStdRandom의 인자로서 꼭 들어맞는다. QuickCheck를 활용해 무작위 데이터 생성하기 IO 모나드만을 통해서 난수를 생성할 수 있다는 건 고통이다. 코드 깊숙한 곳의 어떤 함수에 난수가 필요해졌고 여러분은 이제 프로그램 절반을 순수 함수가 아니라 IO 액션으로 재작성하거나 그보다 위에 있는 모든 함수를 거쳐 StdGen 인자를 전달해야 한다. 좀 더 순수한 방식은 없을까? State 모나드 챕터를 떠올려보면 이런 패턴은 let (x1, r2) = next r (x2, r3) = next r2 (x3, r4) = next r3 do 표기로도 할 수 있었다. do -- Not real Haskell x1 <- random x2 <- random x3 <- random 물론 IO 모나드 안이라면 이렇게 할 수 있지만, 난 수들이 난수 계산에 특화된 자기만의 작은 모나드를 가질 수 있다면 더 좋다. 다행히도 그런 모나드가 존재한다. 그 모나드는 Test.QuickCheck 모듈에 있으며 Gen이라고 한다. Gen이 Test.QuickCheck에 들어있는 것에는 역사적인 이유가 있다. Gen은 여기서 발명되었다. QuickCheck의 목적은 임의의 유닛 테스트를 생성해 여러분의 코드의 여러 성질을 검증하는 것이다. (여담이지만 QuickCheck는 놀랍도록 잘 작동하며 대부분의 하스 켈 개발자는 테스팅을 위해 QuickCheck를 사용한다.) 세부사항은 HaskellWiki의 [Introduction to QuickCheck](https://wiki.haskell.org/Introduction_to_QuickCheck2)를 볼 것. 여기서는 Gen 모나드를 이용한 무작위 데이터 생성에 집중하겠다. QuickCheck 모듈을 사용하려면 QuickCheck 패키지를 설치해야 한다. 설치하고 나면 소스 파일에 이것만 추가하면 된다. import Test.QuickCheck Gen 모나드는 난수 계산에 대한 모나드라고 생각하면 된다. Gen은 난수를 생성할 뿐만 아니라 간단한 값들로부터 복잡한 값을 구축하는 함수들을 제공한다. 그러면 0과 999 사이의 임의 정수 3개를 반환하는 루틴으로 시작해 보자. randomTriple :: Gen (Integer, Integer, Integer) randomTriple = do x1 <- choose (0,999) x2 <- choose (0,999) x3 <- choose (0,999) return (x1, x2, x3) choose는 QuickCheck의 함수들 중 하나로서 randomR에 대응한다. choose :: Random a => (a, a) -> Gen a 즉 Random의 인스턴스인 어떤 타입 a에 대해 choose는 구간을 생성기로 사상한다. Gen 액션을 얻었으니 이걸 실행해야 한다. unGen 액션은 그 액션을 실행하고 무작위 결과를 반환한다. unGen :: Gen a -> StdGen -> Int -> a 세 인자는 다음과 같다. 생성기 액션 난수 생성기 결과의 "크기". 위 예시에서는 이걸 활용하지 않았지만 여러분이 리스트처럼 요소의 개수가 변하는 자료구조를 구축하고 있다면 이 인자는 그 예상되는 크기를 생성기에 전달한다. 이에 대한 예시는 나중에 알아보겠다. 예를 들면 이것은 임의의 숫자 세 개를 생성한다. let triple = unGen randomTriple (mkStdGen 1) 1 하지만 이 숫자들은 항상 동일한데, 똑같은 씨값을 사용했기 때문이다. 서로 다른 숫자들을 원한다면 각각 다른 StdGen 인자를 사용해야 한다. 대부분의 프로그래밍 언어에서는 의사 난수 생성기를 이용해 두 액션 중 하나를 취한다. -- Not Haskell code r := random (0,1) if r == 1 then foo else bar QuickCheck는 같은 일을 하지만 좀 더 선언형인 수단을 제공한다. foo와 bar가 같은 타입을 반환하는 생성기라면 이렇게 할 수 있다. oneof [foo, bar] 이것은 foo 또는 bar 중 하나를 반반 확률로 반환한다. 확률을 다르게 하고 싶다면 이렇게 할 수 있다. frequency [ (30, foo), (70, bar) ] oneof는 Gen 액션들의 리스트를 받아서 이 중 하나를 무작위로 선택한다. frequency는 비슷한 일을 하지만 각 항목을 선택할 확률은 그에 연관된 가중치에 의해 결정된다. oneof :: [Gen a] -> Gen a frequency :: [(Int, Gen a)] -> Gen a 2 자료구조 기초 원문: https://en.wikibooks.org/wiki/Haskell/Libraries/Data_structures_primer 트레이드오프 조회: Data.Map 계열 Map의 변형들 Data.Sequence를 통해 양 끝에서 조회하기 배열을 통한 raw 성능 text, bytestring, 그리고 String의 문제점 이번 장에서는 라이브러리에 있는 몇 가지 자료구조를 소개한다. 모든 하스 켈 사용자가 배워야 하는 일반적이고 특히 유용한 예시들에 집중할 것이다. 트레이드오프 이번 장에서는 리스트의 단점을 계속 강조하지만 리스트를 그만 써야 한다는 뜻은 아니다. 리스트가 하스켈의 기본 자료구조인 데는 이유가 있다. 리스트는 단순하다는 것을 넘어 게으르고 순수한 함수형 환경에서 높은 동력비(power-to-weight ratio)를 가진다. 지연성은 리스트를 스트림으로써 사용함으로써 필요에 따라 생성되는 원소들을 순차 처리할 수 있도록 한다. 이러한 처리는 map, filter, foldr, takeWhile, zipWith 같은 함수들이 흔한 반복적 제어 구조를 효율적으로 대체할 수 있도록 한다. 리스트는 단순한 데이터 저장과 획득보다는 스트리밍 및 반복의 제어 같은 패턴에 더 잘 맞는다. 물론 다른 자료구조로 교체하는 것에는 트레이드오프가 수반된다. 모든 자료구조에는 나름의 장점과 단점이 있으며 올바른 선택은 당면해 있는 문제에 따라 달라진다. 조회: Data.Map 계열 흔한 문제인 자료구조에 대한 조회를 첫 번째로 생각해 보자. 연관된 키와 값의 모음이 주어졌을 때 어떤 키에 대응하는 값이 있다면 그 값을 획득하고자 한다. 이 연관 관계를 단순히 쌍의 리스트 [(k, v)]로 저장할 수도 있다. 아니나 다를까 프렐류드에는 lookup :: Eq k => k -> [(k, v)] -> Maybe v가 있지만 리스트에서 값을 탐색하려면 리스트의 모든 쌍을 훑어보며 우리가 찾던 키에 도달하거나 리스트의 끝에 도달할 때까지 키에 대한 항등 검사를 해야 한다. 평범한 연관 리스트에서 조회는 O(n) 연산으로서 예상되는 작업 수행 횟수가 리스트의 길이에 비례하여 증가한다. 연관 관계가 많으면 이것이 문제가 될 수 있다는 건 알기 쉽다. 더 알맞은 자료구조로 갈아타면 조회를 더 잘할 수 있다. containers 패키지의 Data.Map에 있는 Map 타입은 범용적으로 쓰기에 좋은 선택이다. Data.Map은 프렐류드 함수들과 이름 충돌을 피하기 위해 보통은 한정되어 임포트 된다. GHCi> import qualified Data.Map as M GHCi> :t M.empty M.empty :: M.Map k a Map에서 키와 값은 (균형 잡힌 이진) 트리 안에 배열된다. 이 트리 형태에서 키 탐색은 단순히 트리의 특정 브랜치를 따라 내려가는 일이지만 전적으로 배후에서 벌어지는 일이다. 라이브러리 내 다른 자료구조들과 마찬가지로 Map은 인터페이스를 거치는 추상 타입으로서 사용되며 그 뒤의 트리 구현은 언급되지 않는다. 특히 생성자가 익스포트되지 않는데, 새 Map을 생성하려면 empty 맵에 연관 관계를 삽입하거나 유틸리티 함수 fromList를 이용해야 한다. GHCi> let foo = M.fromList [(1, "Robert"), (5, "Ian"), (6, "Bruce")] GHCi> :t foo foo :: M.Map Integer [Char] Data.Map 인터페이스는 O(log n) 탐색을 보장한다. GHCi> :t M.lookup M.lookup :: Ord k => k -> M.Map k a -> Maybe a GHCi> M.lookup 5 foo Just "Ian" GHCi> M.lookup 7 foo Nothing 그 외에도 합집합, 교집합, 원소 삭제 등 유용한 명렁들을 지원한다. Functor 같은 중요한 타입 클래스들에 대한 인스턴스도 지원된다. GHCi> M.size $ M.union foo $ M.fromList [(11, "Andrew"), (17, "Mike")] GHCi> fmap reverse foo fromList [(1, "treboR"),(5, "naI"),(6, "ecurB")] Map의 변형들 맵이나 맵과 유사한 자료구조를 지원하는 다른 모듈이 여러 개 있다. containers의 Data.IntMap은 Int 키에 한정된 더 효율적인 맵 구현을 제공한다. 역시 containers에 있는 Data.Set은 집합 구현을 제공한다. 집합은 관심 있는 연산이 어떤 값이 컬렉션에 들어있는지 알아보는 것일 뿐, 주어진 키를 통해 값을 획득할 필요가 없을 때 적합하다. 키만 신경 쓰면 된다는 점에서 집합은 맵과 유사하며 성능과 구현에 관한 많은 사항이 둘 다 똑같이 적용된다. unordered-containers 패키지는 해시 맵 및 집합을 제공한다. 이것들은 키를 Int 타입으로 한정하지 않으면서도 성능 향상을 이루는데(가령 조회는 거의 상수 시간이다) 그 대신 인터페이스가 더 제한되고 container의 트리 기반 맵과 달리 순서를 보장하지 않는다. Data.Sequence를 통해 양 끝에서 조회하기 리스트의 특성은 비대칭이라는 것이다. 리스트의 헤드에서 (:)를 통해 구축 및 분해를 한다는 점에서 연산은 헤드에서 실행하는 게 테일에서 실행하는 것보다 효율적이다. 예를 들어 (:)를 통해 원소를 앞에 추가하는 것은 상수 시간이 걸리지만 xs x -> xs ++ [x]를 통해 끝에 원소 하나를 추가하는 것은 xs의 길이에 비례하는 시간이 걸린다. 이는 덧붙여서 리스트를 구축하려면 원소 개수의 제곱에 비례하는 시간이 걸린다는 뜻이다. 아주 좋지 않다. 중간 또는 끝에서 많은 연산을 해야 한다면 시퀀스는 리스트와 비슷하면서도 훌륭한 대안이다. 시퀀스는 Data.Sequence 모듈에 들어으며 이 모듈 역시 containers의 일부다. 시퀀스와 리스트는 그다지 비슷하지 않지만 친숙한 리스트 함수들이 Data.Sequence에도 많이 등장한다. 리스트는 게으르고 무한할 수 있는 반면 시퀀스는 유한하고 엄격하다. 시퀀스를 유용하게 만드는 트레이드오프는 리스트에 비해 약간의 오버헤드 비용을 치르면 리스트에서 문제 있던 많은 연산이 더 나아진다는 것이다. 특히 앞과 뒤에 추가하는 것 모두 상수 시간이 걸리며, 길이를 구하는 것도 상수 시간, 연결과 임의 접근은 로그 시간이 걸린다. 이 모든 것은 순수 함수형 인터페이스를 통해 이뤄진다. GHCi> import qualified Data.Sequence as S GHCi> import Data.Sequence((<|), (|>), (><), ViewL(..), ViewR(..)) GHCi> let foo = S.fromList [1, 3, 5, 2, 9] GHCi> :t foo foo :: S.Seq Integer (<|)는 prepend, (|>)는 append, (><)는 concatenate를 수행한다. GHCi> 0 <| foo fromList [0,1,3,5,2,9] GHCi> foo |> 18 fromList [1,3,5,2,9,18] GHCi> foo >< foo fromList [1,3,5,2,9,1,3,5,2,9] 양 끝단에 대해 패턴 매칭을 할 수도 있다. 그러려면 viewl 또는 viewr을 써서 원하는 뷰를 얻은 다음 EmptyL 및 (:<)를 이용하거나 EmptyR 및 (:>)를 이용하여 매칭한다. GHCi> S.viewl foo 1 :< fromList [3,5,2,9] GHCi> S.viewr foo fromList [1,3,5,2] :> 9 GHCi> let xs :> x = S.viewr foo GHCi> xs fromList [1,3,5,2] GHCi> x 배열을 통한 raw 성능 거대 규모의 데이터를 다룰 때는 성능 요구사항이 상당히 빡세질 수 있다. 대용량 데이터를 빠르게 처리해야 하는 경우 지연성과 스트리밍은 고려 대상조차 아니다. 하스켈은 C에서 볼 수 있는 진짜 배열을 지원한다. 배열은 메모리에서 연속적이며(compact) 임의 접근을 상수 시간에 해내고 기타 많은 연산을 굉장히 빠르게 처리한다. (주된 예외는 불변 배열의 연결처럼 배열의 복사가 필요한 경우) 그 대신 배열과 우리가 평소에 다루는 순수 함수형 자료구조가 작동하는 방식의 근본적인 차이에서 나오는 불편함을 감수해야 한다. 이용할 수 있는 배열 라이브러리는 여러 개가 있는데, 각 라이브러리는 그 사용법이 평범한 하스 켈 자료구조와 그다지 다르지 않은 배열부터 C 스타일의 가변 원시 값 배열까지 다양한 종류의 배열을 제공한다. 여기서는 가장 유명한 배열 라이브러리 3개를 소개하겠다. vector는 배열에 입문하거나 다른 라이브러리들이 제공하는 특화된 요구사항이 필요 없을 때 기본으로 선택하기 좋다. vector는 containers 같은 다른 자료구조 라이브러리들에서 볼 수 있는 인터페이스와 유사한 인터페이스를 가지는 1차원 배열을 제공한다. array의 인터페이스는 좀 더 위압감이 든다. 기능은 다차원 배열과 커스텀 인덱싱을 지원한다. 중요한 점은 array가 언어 표준의 일부이며 GHC에 포함되었다는 것이다. 이는 추가적인 의존성을 달가워하지 않는 라이브러리 작성자들에게 유용하다. 별개의 장에 있는 표준 배열의 개요를 통해 배열과 관련된 용어에 입문할 수 있다. repa는 최신 다차원 병렬화 가능 배열을 제공하는 정교한 라이브러리다. 이미지 처리 같은 작업에 적합하다. text, bytestring, 그리고 String의 문제점 base 라이브러리들을 훑어보면 하스 켈 프로그램에서 데이터의 입출력에 String이 선호되는 수단이라는 인상을 받는다. 하지만 String에는 그런 역할을 맡기에는 좋지 않은 몇 가지 문제가 있다. 가장 명백한 문제는 성능이다. String은 Char의 리스트일 뿐이며 적당히 큰 규모의 텍스트나 바이너리 데이터를 처리하는 애플리케이션에서조차 링크드 리스트의 범용성이 주는 이점보다는 특별화된 구현으로 얻을 수 있는 효율성의 손실이 훨씬 크다. 바이너리 데이터의 경우 Char 기반 표현이 의미를 잃는데, 우리는 말 그대로 날 것의 바이트를 다루고 있기 때문이다. 마지막으로 하스 켈 Char는 유니코드 문자인데 base 라이브러리들에는 다른 인코딩이나 국제화에 대한 지원이 다소 부족하다. String의 이런 단점들은 text와 bytestring 라이브러리로 해결할 수 있다. 이 둘은 사실상 표준이다. 막대한 양의 데이터 입출력을 다루는 현대적인 라이브러리들은 거의 대부분 이 둘을 사용한다. 둘의 쓰임새는 확연히 나뉜다. text는 유니코드 텍스트의 효율적인 처리를 위한 것이다. 인코딩 간 변환을 지원하며 유니코드 서비스를 위한 종합 라이브러리인 text-icu와 함께 쓰인다. bytestring은 모든 형태의 바이너리 데이터의 효율적인 처리를 위한 것이다. 네트워크 패킷, raw 이미지 데이터, 직렬화(binary와 cereal 같은 라이브러리를 통해) 등이 있다. Text, ByteString 라이브러리의 핵심 타입들은 각각 Char와 Word8 (즉 raw byte)의 특화된 단형성 컨테이너로서 구현된다. 내부 구현은 배열에 기반하며 매우 압축적이다. 두 라이브러리의 인터페이스는 꽤나 직관적이다. 주의해야 할 점은 둘 다 엄격한 타입과 게으른 타입 변종이 있다는 것이다. 엄격한 버전은 거대 볼륨들 몇 개를 처리하는데 알맞고 게으른 버전은 덩어리 단위로 처리되는, 따라서 메모리 소모 걱정 없이 단일 데이터의 많은 조각의 스트리밍 및 처리에 적합하다. String의 대체재들을 다룰 때 알아두면 좋은 편리한 기능이 있는데, OverloadedStrings GHC 확장은 문자열 리터럴을 Text 또는 ByteString으로 알아서 타입에 맞춰 변환해 준다. 이 기능은 특히 Text에 유용하다. 1 배열 원문: https://en.wikibooks.org/wiki/Haskell/Libraries/Arrays 원문은 GHC 6.x 시절 작성되었습니다. 본문 시점에 최신 릴리스는 2021-02-04 배포된 GHC 9.0.1입니다. 더 이상 맞지 않는 설명이나 깨진 링크가 있어서 확인 가능한 부분들은 적절히 수정하고 역주를 달아놓았으니 참고해 주세요. 요약표 불변 배열 가변 IO 배열 ST 모나드 내의 가변 배열 freeze와 thaw DiffArray Unboxed arrays StorableArray The Haskell Array Preprocessor (STPP) ArrayRef 라이브러리 unsafe operations and running over array elements GHC에 한정된 화제들 평행 배열 (GHC.PArr 모듈) Welcome to the machine Array#, MutableArray#, ByteArray#, MutableByteArray#, pinned and moveable byte arrays Mutable arrays and GC 하스 켈 98은 배열 생성자 타입을 하나만 지원하며 그 이름은 Array이다. 이것은 불변 boxed 배열인데 "불변"은 이 배열이 다른 순수 함수형 자료구조들처럼 생성 시간에 그 내용이 고정된다는 뜻이다. 이 배열은 수정할 수 없으며 질의만 가능하다. "수정" 연산은 있지만 원래 배열을 수정하는 것이 아니라 새로운 배열을 반환한다. 그래서 Array는 순수 함수형 코드에서 리스트와 함께 사용할 수 있다. "boxed"는 배열 원소가 일반적인 하스 켈 (게으른) 값이며 필요에 따라 평가되고 심지어 bottom (undefined) 값일 수도 있다는 뜻이다. 이런 배열의 사용법은 https://www.haskell.org/tutorial/arrays.html에서 배울 수 있으며 이 페이지를 계속 읽기 전에 읽어볼 것을 추천한다. 요즘은 주요 하스 켈 컴파일러인 GHC와 Hugs가 Hierarchical Libraries와 함께 배포되며 이 라이브러리들은 하스 켈 98의 배열과 하 휘 호환되지만 기능이 더 많으며 새로 구현한 배열을 포함한다. 일단 이 라이브러리들이 9가지 배열 생성자를 지원한다는 것을 알아두자. † (Array, UArray, IOArray, IOUArray, STArray, STUArray, DiffArray, DiffUArray, StorableArray) 하스 켈 입문자에게 이 배열 라이브러리들은 혼돈의 근원이다. 그런데 사실은 아주 간단하다. 각각 두 인터페이스 중 하나를 제공하며 한 인터페이스는 여러분도 이미 알고 있는 것이다. † 역주: GHC 9.0.1 기준 DiffArray와 DiffUArray는 표준 라이브러리가 아니다. 요약표 Immutable instance IArray a e IO monad instance MArray a e IO ST monad instance MArray a e ST 표준 Array DiffArray IOArray STArray Unboxed UArray DiffUArray IOUArray StorableArray STUArray 불변 배열 새로운 배열 라이브러리가 제공하는 첫 번째 인터페이스는 타입 클래스 IArray에 의해 정의된다. ("불변 배열"이라는 뜻이며 Data.Array.IArray 모듈에 정의되어 있다) IArray는 하스 켈 98의 Array와 동일한 연산들을 정의한다. 다음은 IArray를 사용해 (37,64)를 출력하는 간단한 예시다. import Data.Array buildPair :: (Int, Int) buildPair = let arr = listArray (1,10) (repeat 37) :: Array Int Int arr' = arr // [(1, 64)] in (arr ! 1, arr' ! 1) main = print buildPair 여기서 큰 차이점은 IArray가 이제 타입 클래스이며 이 인터페이스를 구현하는 배열 타입 생성자가 Array, UArray, DiffArray, DiffUArray 이렇게 4개 있다는 것이다. 나중에 이것들의 차이점과 예전 배열 대신 쓰기 좋은 상황을 설명할 것이다. 그리고 Array 타입 생성자를 새 배열 타입들과 함께 사용하려면 Data.Array가 아니라 Data.Array.IArray 모듈을 임포트 해야 하는 것에 주의하라. 가변 IO 배열 두 번째 인터페이스는 타입 클래스 MArray에 의해 정의된다. ("가변 배열"을 뜻하며 Data.Array.MArray 모듈에 정의되어 있다) MArray는 그 자리에서 배열 원소를 갱신하기 위한 명령들을 포함한다. 가변 배열은 IORef와 매우 유사하지만 값을 여러 개 포함한다는 점이 다르다. 가변 배열의 타입 생성자로는 IOArray와 IOUArray가 있으며 (Data.Array.IO) 이 배열들의 생성, 갱신, 질의 명령은 모두 IO 모나드에 속한다. import Data.Array.IO main = do arr <- newArray (1,10) 37 :: IO (IOArray Int Int) a <- readArray arr 1 writeArray arr 1 64 b <- readArray arr 1 print (a, b) 이 프로그램은 원소 10개의 초깃값이 모두 37인 배열을 생성한다. 그리고 배열의 첫 원소를 읽는다. 그다음 배열의 첫 원소를 수정하고 다시 읽는다. 두 번째 줄의 타입 선언은 프로그램이 arr의 구체적인 타입을 결정하기에 충분한 문맥을 제공하지 않기 때문에 필수적이다. ST 모나드 내의 가변 배열 IORef의 더 일반화된 버전인 STRef가 있는 것처럼 IOArray도 더 일반화된 버전인 STArray가 있다. (비슷하게 IOUArray에 대한 STUArray가 있으며 둘 다 Data.Array.ST에 있다) 이 배열 타입들은 ST 모나드 내에서 가변 배열을 다룰 수 있게 한다. import Control.Monad.ST import Data.Array.ST buildPair = do arr <- newArray (1,10) 37 :: ST s (STArray s Int Int) a <- readArray arr 1 writeArray arr 1 64 b <- readArray arr 1 return (a, b) main = print $ runST buildPair 믿기지 않겠지만 이제 여러분은 모든 배열 타입의 사용법을 알게 되었다. 속도 문제에 관심 있는 게 아니라면 그저 적절한 곳에 Array, IOArray, STArray를 사용하라. 이다음 주제들은 대부분 전적으로 프로그램을 더 빠르게 실행하기 위해 적절한 배열 타입을 선택하는 것에 관한 내용이다. freeze와 thaw 하스켈은 freeze와 thaw 함수를 통해 불변 배열과 가변 배열 사이의 변환을 허용한다. freeze :: (Ix i, MArray a e m, IArray b e) => a i e -> m (b i e) thaw :: (Ix i, IArray a e, MArray b e m) => a i e -> m (b i e) 예를 들어 다음 코드는 Array를 STArray로 변환하고, 그 STArray를 갱신하고, 다시 Array로 변환한다. import Data.Array import Control.Monad.ST import Data.Array.ST buildPair :: (Int, Int) buildPair = let arr = listArray (1,10) (repeat 37) :: Array Int Int arr' = modifyAsST arr in (arr ! 1, arr' ! 1) modifyAsST :: Array Int Int -> Array Int Int modifyAsST arr = runST $ do starr <- thaw arr compute starr newarr <- freeze starr return newarr compute :: STArray s Int Int -> ST s () compute arr = do writeArray arr 1 64 main = print buildPair freeze와 thaw는 배열 전체를 복사한다. freeze와 thaw 전후로 같은 메모리 위치를 사용하면서 일종의 접근 제한도 하고 싶다면 unsafe operations and running over array elements 절을 볼 것. DiffArray 앞서 말했듯이 불변 배열(IArray)에 대한 갱신은 그 배열의 새 복사본을 만들어서 매우 비효율적이지만 순수 함수 내에서 사용할 수 있는 순수 연산이다. 반면에 가변 배열(MArray)에 대한 갱신은 효율적이지만 모나드 코드 안에서만 수행할 수 있다. DiffArray(Data.Array.Diff에 정의됨)는 이 둘의 장점만을 취한다. DiffArray는 IArray 인터페이스를 지원하면서 순수 함수형으로 사용할 수 있지만 내부적으로는 MArray의 효율적인 갱신을 활용한다. † † 역주: GHC 9.0.1 기준 DiffArray는 더 이상 표준 라이브러리가 아니다. 하스 켈 위키에 따르면 DiffArray는 이론상 성능을 보장하지 않으며 MArray보다 10~100배 느리다. 이 트릭이 어떻게 작동하는 걸까? DiffArray는 순수 외부 인터페이스를 가지지만 IOArray에 대한 참조로서 표현된다. diff 배열에 // 연산자를 적용하면 그 내용물은 제자리에서 갱신된다. 이전 배열은 드러나는 행동을 바꾸지 않으면서 자신의 표현을 조용히 변경한다. 즉 새로운 현 배열에 대한 링크와 이전 내용물을 얻기 위해 적용할 차이를 보관한다. 따라서 diff 배열을 싱글 스레드 스타일로 사용한다면, 즉 //를 적용한 후 이전 버전은 더 이상 사용하지 않는다면 a! i는 O(1) 시간이 걸리고 a // d는 O(n) 시간이 걸린다. 이전 버전의 원소에 접근하는 시간은 점점 느려진다. 현재 배열이 아닌 것을 갱신하면 새로운 물리적 복사본이 만들어진다. 그 결과 나오는 배열은 이전 배열들과 연결이 끊어진다. 따라서 현재 버전임을 보장할 수 있는 배열을 얻을 수 있고 "항등 갱신"인 old // []를 수행해서 빠르게 원소에 접근할 수 있다. 이 라이브러리는 두 "differential" 배열 생성자를 제공한다. DiffArray는 IOArray에서 유래하고 DiffUArray는 IOUArray에 기반한다. 정말 그래야 한다면 IO 모나드 안에서 임의 MArray 타입으로부터 새로운 "differential" 배열 타입을 구축할 수 있다. 자세한 것은 모듈 문서화를 볼 것. DiffArray의 사용법은 Array와 크게 다르지 않다. 유일한 차이점은 메모리 소비량과 속도다. import Data.Array.Diff main = do let arr = listArray (1,1000) [1.. 1000] :: DiffArray Int Int a = arr ! 1 arr2 = arr // [(1,37)] b = arr2! 1 print (a, b) seq를 사용해서 배열 갱신 전에 배열 원소들의 평가를 강제할 수 있다. import Data.Array.Diff main = do let arr = listArray (1,1000) [1.. 1000] :: DiffArray Int Int a = arr ! 1 b = arr ! 2 arr2 = a `seq` b `seq` (arr // [(1,37),(2,64)]) c = arr2! 1 print (a, b, c) Unboxed arrays 대부분의 지연 평가 구현체에서 값은 런타임에 그 값에 대한 포인터 또는 그 값을 계산하는 코드에 대한 포인터로서 표현된다. 이런 여분의 indirection과 런타임에 필요한 추가 태그들을 모아서 박스라고 부른다. 기본적인 "boxed" 배열은 이런 박스들로 구성되며 각각의 박스는 그 값을 따로 계산한다. 이로써 배열의 원소를 다른 원소를 이용해 정의하거나 필요한 특정 원소들만 계산하는 등 많은 묘기를 부릴 수 있다. 하지만 큰 배열에서 박스는 많은 오버헤드를 유발하며 배열 전체가 항상 필요한 경우 낭비일 수 있다. Unboxed 배열(Data.Array.Unboxed에 정의됨)은 C의 배열에 더 가깝다. Unboxed 배열은 추가 indirection 없이 평범한 값을 보관하므로 가령 Int32 타입의 값 1024개의 배열은 메모리를 4 kb만 사용한다. 게다가 이런 배열에 대한 인덱싱은 훨씬 빠르다. 물론 unboxed 배열도 단점이 있다. 먼저 unboxed 배열은 Int, Word, Char, Bool, Ptr, Double 등 고정 크기를 가지는 평범한 값으로만 구성할 수 있다. (UArray 클래스 정의에 나열되어 있음) 열거형을 포함해 간단한 타입에 대한 unboxed 배열은 여러분이 직접 구현할 수도 있다. 하지만 Integer, String, 기타 가변 크기를 가지는 타입들은 unboxed 배열의 원소가 될 수 없다. 두 번째로 추가 indirection이 없는 unboxed 배열을 평가할 때는 모든 원소를 평가해야 한다. 따라서 지연 평가의 이점을 잃는다. 배열의 원소 하나만 읽기 위한 인덱싱도 배열 전체의 구축을 유발한다. 결국 배열 전체가 필요하다면 그다지 손실은 아니다. 하지만 배열의 한 원소를 통해 다른 원소를 재귀 정의할 수 없게 되며 특정 값들만 필요할 경우 비용이 너무 커질 수 있다. 그렇지만 unboxed 배열은 매우 유용한 최적화 수단이며 최대한 활용할 것을 추천한다. 이 라이브러리의 모든 주 배열 타입에는 대응하는 unboxed 버전이 있다. Array - UArray (module Data.Array.Unboxed) IOArray - IOUArray (module Data.Array.IO) STArray - STUArray (module Data.Array.ST) DiffArray - DiffUArray (module Data.Array.Diff) 그래서 프로그램에 있는 boxed 배열을 unboxed 배열로 바꾸는 작업은 매우 간단하다. 타입 시그너쳐에 'U'만 붙이면 끝이다. 물론 Array를 UArray로 변경하면 임포트 목록에 Data.Array.Unboxed를 추가해야 한다. StorableArray storable 배열(Data.Array.Storable)은 그 내용물을 C 히프 내의 연속된 메모리 블록에 저장하는 IO-mutable 배열이다. 원소들은 Storable 클래스에 의해 저장된다. (?) 배열 내용물에 대한 포인터를 얻어서 C와 같은 방식으로 원소들을 수정할 수 있다. storable 배열은 (특히 동일한 MArray 인터페이스를 구현하는 점에서) IOUArray와 비슷하지만 더 느리다. 장점은 FFI를 통해 C와 호환 가능하다는 것이다. stroable 배열의 메모리 주소는 고정이기 때문에 C 루틴에 그대로 전달할 수 있다. 배열 내용물에 대한 포인터는 withStorableArray를 통해 획득한다. 아이디어는 ForeignPtr과 비슷하다(내부적으로도 사용한다). 이 포인터는 withStorableArray에 인자로서 전달한 함수가 반환하는 IO 액션의 실행 도중에만 사용해야 한다. {-# OPTIONS_GHC -fglasgow-exts #-} import Data.Array.Storable import Foreign.Ptr import Foreign.C.Types main = do arr <- newArray (1,10) 37 :: IO (StorableArray Int Int) a <- readArray arr 1 withStorableArray arr (\ptr -> memset ptr 0 40) b <- readArray arr 1 print (a, b) foreign import ccall unsafe "string.h" memset :: Ptr a -> CInt -> CSize -> IO () 이 포인터를 이후에도 사용하려면 포인터를 마지막으로 사용한 후 touchStorableArray를 호출해서 이 배열이 일찍 해제되지 않게 만들어야 한다. 추가 코멘트: GHC 6.6은 StorableArray에 대한 접근을 다른 unboxed 배열만큼 빠르게 만들어야 한다. StorableArray와 UArray의 유일한 차이점은 UArray는 GHC 히프의 재배치 가능한 영역에 있고 StorableArray는 재배치 불가 영역에 있으며 주소가 고정되어서 이 주소를 C 루틴에 전달하고 C 데이터구조 안에 그 주소를 저장할 수 있다는 것뿐이다. GHC 6.6은 unsafeForeignPtrToStorableArray 연산을 추가하여 임의의 Ptr을 StorableArray의 주소로 사용할 수 있도록 하며 특히 C 루틴이 반환한 배열을 다룰 수 있도록 한다. 다음은 이 연산을 사용하는 예시다. import Data.Array.Storable import Foreign.Marshal.Alloc import Foreign.Marshal.Array import Foreign.ForeignPtr main = do ptr <- mallocArray 10 fptr <- newForeignPtr_ ptr arr <- unsafeForeignPtrToStorableArray (1,10) fptr :: IO (StorableArray Int Int) writeArray arr 1 64 a <- readArray arr 1 print a free ptr 이 예시는 Int 10개를 위한 메모리를 할당하고(C 함수가 반환한 배열을 흉내) 반환받은 Ptr Int를 ForeignPtr Int로 변환한 다음 ForeignPtr Int를 다시 StorableArray Int Int로 변환한다. 그리고 배열의 첫 번째 원소를 쓰고 읽는다. 마지막으로 배열이 사용한 메모리를 free로 해제해서 C 루틴의 해제를 흉내 낸다. newForeignPtr_ ptr를 newForeignPtr finalizerFree ptr로 교체하면 할당된 블록을 자동 해제할 수 있다. 이러면 다른 하스 켈 객체들처럼 배열을 마지막으로 사용한 이후 메모리가 자동 해제된다. The Haskell Array Preprocessor (STPP) 하스켈에서 가변 배열(IO, ST 버전)은 사용하기에 그다지 편하지 않다. 그런데 편의 문법을 추가하고 그런 배열의 사용법을 명령형 언어와 유사하게 만들어주는 도구가 있다. 이 도구는 Hal Daume III이 작성했고 http://hal3.name/STPP/STPP.tar.gz에서 받을 수 있다. 이 도구를 사용하면 복잡한 표현식 안에서 arr[|i|]로 배열 원소에 접근할 수 있고 전처리기가 그런 구문을 자동으로 알맞은 readArray와 writeArray 호출로 변환한다. 다차원 배열도 arr[|i|][|j|] 형태로 지원된다. 자세한 것은 http://hal3.name/STPP/를 볼 것. ArrayRef 라이브러리 ArrayRef 라이브러리는 다음 확장 기능을 포함하여 배열 라이브러리를 재구현한다. 동적 (크기 변경 가능) 배열 다형 unboxed 배열 그리고 편의 문법을 추가해 배열 사용법을 간소화한다. STPP처럼 우아하지는 않지만 전처리기 없이 하스 켈 언어만으로 구현된 것이다. unsafe operations and running over array elements 앞서 언급했듯 동일 타입의 가변 배열과 불변 배열 사이를 변환하는 명령이 있는데 바로 freeze(가변 -> 불변)와 thaw(불변 -> 가변)이다. 이것들은 배열 전체를 복사한다. 가변 배열이 수정되지 않거나 불변 배열이 변환 후에는 사용되지 않는다는 확신이 있다면 unsafeFreeze/unsafeThaw를 대신 사용할 수 있다. 이 명령들은 입력 배열과 결과 배열의 메모리 표현이 같으면(즉 타입과 boxing 여부가 같으면) 배열을 제자리에서 변환한다. "unsafe*" 명령은 메모리를 수정한다는 것에 주의하라. 그런 명령은 배열 변경 가능 여부에 대한 배열 헤더 플래그를 설정 또는 해제한다. 따라서 이런 명령은 배열에 대한 멀티 스레드 접근(스레드 또는 코루틴)과 함께 쓸 수 없다. unboxed 배열을 다른 원소 타입으로 변환하는 castIOUArray와 castSTUArray도 있다. 이 명령들은 메모리 내 실제 타입 표현에 의존하므로 그 결과에 대해 아무 보장도 하지 않는다. 특히 이 명령들은 임의의 unboxed 값을 일련의 바이트로 또는 그 반대 방향으로 변환한다. AltBinary 라이브러리는 부동소수점 값을 직렬화하기 위해 이것들을 사용한다. 이 명령들은 원소 크기의 변화에 따라 배열의 바운드를 재계산하지 않는 것에 주의하라. 그 일은 여러분이 sizeOf 명령을 통해 직접 해야 한다. 배열의 인덱스는 어떤 타입도 될 수 있지만 내부적으로 바운드 검사 이후 모든 인덱스는 평범한 Int 값(위치)로 변환되며 로우 레벨 명령인 unsafeAt, unsafeRead, unsafeWrite 중 하나가 사용된다. 이 명령들을 직접 상 요해서 바운드 검사를 건너뛰거나 프로그램을 빠르게 만들 수 있다. 이 명령들은 배열 전체에 접근할 때 특히 유용하다. -- | Returns a list of all the elements of an array, in the same order -- as their indices. elems arr = [ unsafeAt arr i | i <- [0 .. rangeSize (bounds arr)-1] ] 이런 루프 안의 "unsafe*" 명령들은 실제로는 안전한데 i가 항상 존재하는 배열 원소들의 위치기 때문이다. GHC에 한정된 화제들 평행 배열 (GHC.PArr 모듈) 앞서 언급했듯이 배열 라이브러리는 두 배열 변종을 지원한다. 바로 지연 boxed 배열과 엄격한 unboxed 배열이다. 평행 배열은 그 경계에 있는 것, 엄격한 boxed 불변 배열을 구현한다. 어떤 데이터 타입이던 배열 원소로 사용할 수 있는 유연함을 갖추면서 배열의 생성과 접근을 빠르게 만든다. 배열 생성은 모든 배열 원소를 채우는 단일 명령형 루프로서 구현되며 배열 원소에 대한 접근은 "box"를 검사할 필요가 없다. 배열 원소의 계산이 복잡하고 대부분의 배열 원소를 사용하지 않는 경우에는 평행 배열이 비효율적임이 명백하다. 실전에서의 또 다른 단점은 평행 배열이 IArray 인터페이스를 지원하지 않아서 Array와 평행 배열 생성자 둘 다 지원하는 일반화된 알고리즘을 작성할 수 없다는 것이다. 많은 GHC 확장과 마찬가지로 이 확장은 Manuel M. T. Chakravarty와 Gabriele Keller의 논문 An Approach to Fast Arrays in Haskell에 기술되어 있다. GHC.PArr 모듈의 소스를 살펴볼 수도 있다. 주석이 많이 달려있다. GHC 6.4.1의 사용자 매뉴얼에는 문서화되어있지 않지만, 평행 배열을 위한 특수 문법은 "ghc -fparr" 또는 "ghci -fparr"를 통해 활성화할 수 있다. Welcome to the machine Array#, MutableArray#, ByteArray#, MutableByteArray#, pinned and moveable byte arrays GHC 히프는 두 종류의 개체들을 보관한다. 한 종류는 그저 바이트 시퀀스들이고 다른 종류는 타 개체들에 대한 포인터("박스")를 포함하는 것들이다. 이러한 분리를 통해 가비지 컬렉션을 수행할 때 레퍼런스 연쇄를 찾고, 히프가 사용하는 메모리가 압축되어 개체들이 새 위치로 옮겨질 때 그 포인터들을 갱신할 수 있다. GHC의 내부(raw) 타입인 Array#는 객체 포인터들(박스들)의 시퀀스를 나타낸다. ST 모나드에는 히프에 특정 크기의 배열을 할당하는 로우 레벨 명령이 있으며 그 타입은 (Int -> ST s Array#)이다. Array# 타입은 boxed 불변 배열을 나타내는 Array 타입의 내부에서 사용된다. MutableArray#는 가변 boxed 배열(IOArray/STArray)을 위한 또 다른 타입이다. 가변 배열을 위한 별도의 타입이 필요한 이유는 2단계 가비지 컬렉션 메커니즘 때문이다. Array#와 MutableArray#의 내부 표현은 헤더의 몇 플래그를 제외하고는 동일하기 때문에 제자리에서 MutableArray#와 Array#를 상호 변환할 수 있다. (이것이 unsafeFreeze와 usnafeThaw가 하는 일이다) unboxed 배열은 ByteArray# 타입에 의해 표현된다. 이것은 C 배열처럼 히프의 평볌한 메모리 영역이다. 특정 크기의 ByteArray#를 생성하는 원시 연산이 두 개 있다. 하나는 일반 히프에 메모리를 할당하며 이 바이트 배열은 가비지 컬렉션이 일어날 때마다 다른 곳으로 이동할 수 있다. 그래서 ByteArray#는 C 프러시 저가 사용할 수 있는 평범한 메모리 포인터로 변환할 수 없다. (그럼에도 현재 ByteArray# 포인터를 "unsafe foreign" 프러시저에 전달할 수는 있다. 그 프러시 저가 이 포인터를 다른 곳에 저장하려 하지 않는다면.) Mutable arrays and GC GHC는 고속 2단계 GC를 구현한다. 256 kb가 할당될 때마다 마이너 GC가 일어나고 "살아있는" 데이터를 탐색할 때 이 영역(최신 스택 프레임도)만 스캔한다. 이 방침은 일반적인 하스 켈 데이터가 불변이며 따라서 마이너 GC 이전에 생성된 자료구조는 이 GC 이후 생성된 자료구조를 가리킬 수 없다는 점을 활용한다. (불변 데이터는 "backward" 레퍼런스만 포함하기 때문) 하지만 이런 단순함은 언어에 가변 boxed 레퍼런스(IORef/STRef)와 배열(IOArray/STArray)를 도입하면 성립하지 않는다. 마이너 GC를 포함해 각 GC마다 가변 자료구조의 각 원소를 스캔해야 하는데, 마지막 GC 이후 그 원소가 갱신되어 이전 GC 이후 할당된 데이터를 가리킬 수도 있기 때문이다. 가변 boxed 배열/레퍼런스에 많은 데이터를 보관하는 프로그램의 경우 의미 있는 계산 시간보다 GC 시간이 길어질 수 있다. 아이러니하게도 GHC 자체가 그러한 프로그램이다. 이에 대한 해법은 "+RTS -A10m" 같은 커맨드 라인 옵션을 추가해서 마이너 GC 덩어리의 크기를 256 kb에서 10 mb로 늘리는 것이다. 즉 마이너 GC를 40배 덜 빈번하게 일어나도록 만든다. 이런 변경의 영향은 "+RTS -sstderr" 옵션을 사용해서 볼 수 있다. "%GC time"이 극적으로 줄었을 것이다. 실행 파일에 이 옵션을 포함해서 매 실행마다 자동으로 사용하도록 하는 방법이 있다. 프로젝트에 다음 줄을 포함하는 C 소스 파일을 추가하면 된다. char *ghc_rts_opts = "-A10m"; 물론 필요에 따라 이 값을 늘릴 수도 줄일 수도 있다. "-A" 값을 늘리는 비용은 공짜가 아니다. 메모리 사용은 당연히 증가하며 (의미 있는 코드의) 실행 시간도 증가한다. "-A"의 기본값은 현대 CPU 캐시 사이즈에 근접하도록 맞춰져있어 대부분의 메모리 참조가 캐시 안에 들어가도록 한다. GC를 하기 전에 10 mb의 메모리를 할당하면 그런 데이터 지역성은 더 이상 성립하지 않는다. 따라서 "-A"를 늘리면 프로그램 속도가 빨라질 수도 느려질 수도 있다. 프로그램을 "일반적인" 파라미터들과 함께 실행하면서 이 설정에 64 kb에서 16 mb 사이의 다양한 값을 시도해 보고 여러분의 프로그램과 cpu에 최적의 설정을 선택할 것. GC 시간의 증가를 피하는 다른 방법이 있다. unboxed 또는 불변 배열을 쓰는 것이다. 불변 배열은 가변 배열로서 생성되고 "freeze"되기 때문에 생성할 때는 GC가 그 내용물을 스캔한다는 것에 주의하라. 다행히도 GHC 6.6은 이 문제를 고친다. GHC 6.6은 마지막 GC 이후 어떤 레퍼런스/배열이 갱신되었는지 기억하고 그것들만 스캔한다. 매우 큰 배열을 사용할 때는 그런 문제를 여전히 겪게 될 것이다. 추가 정보: 가비지 컬렉터를 제어하기 위한 RTS 옵션들 Simon Marlow의 문제 설명과 이 분야에서 GHC 6.6의 개선사항에 대한 보고서 GHC 가비지 컬렉터에 대한 노트 GHC 가비지 컬렉터에 대한 논문들 이 페이지의 일부는 하스 켈 위키의 Modern array libraries에서 Simple Permissive 라이선스 하에 가져온 것이다. 이 페이지를 수정하고자 하며 그 변경사항이 이 위키에도 도움이 될 것 같다면 여기 대신 원본 페이지를 수정하는 것을 고려하라. 하스 켈 위키의 변경사항은 여기에 반영될 수 있지만 그 반대는 일어나지 않기 때문이다. 또는 여러분의 기여 사항을 Simple Permissive 라이선스 하에 이중 라이선싱 할 수도 있다. 2 맵 원문: https://en.wikibooks.org/wiki/Haskell/Libraries/Maps 동기 왜 그냥 [(a, b)]를 쓰지 않는가? 라이브러리 함수 예시 Data.Map 모듈이 제공하는 Map 데이터 타입은 특정 키에 부착된 값을 보관한다. 다른 언어에서는 룩업 테이블, 사전(dictionary), 연관 배열(associative array) 등으로 부르기도 한다. 동기 값 또는 값의 리스트를 특정 키에 연관 짓는 자료구조가 유용한 경우가 많다. 이런 자료구조를 실생활에서 따와서 사전이라고 부르고는 한다. 실제 사전은 정의(값)을 각 단어(키)에 연관 짓는다. 이 사전은 단어에서 정의로 가는 맵이다. 파일시스템 드라이버는 파일 이름에서 파일 정보로 가는 맵을 보관할 것이고, 전화번호부 애플리케이션은 연락명에서 전화번호로 가는 맵을 보관할 것이다. 맵은 매우 다재다능하고 유용한 데이터 타입이다. 왜 그냥 [(a, b)]를 쓰지 않는가? 다른 장에서 쌍의 리스트(또는 '룩업 테이블')를 lookup :: a -> [(a, b)] -> Maybe b 함수와 함께 일종의 맵처럼 사용하는 것을 봤을 것이다. 그러면 왜 항상 룩업 테이블을 쓰지 않을까? 그 이유는 다음과 같다. 맵을 사용하면 룩업 테이블을 쓰는 것보다 유용한 함수들을 많이 사용할 수 있다. 맵은 룩업 테이블보다 효율적으로 구현된다. 특히 조회 속도에 관해서는. 1 라이브러리 함수 Data.Map 모듈은 Map을 다루기 위한 함수들을 제공한다. 그런 함수로는 합집합과 교집합 등 집합 연산 비슷한 것들이 있다. 완전한 목록은 코어 라이브러리 문서 2에서 볼 수 있다. 예시 다음 예시는 비밀번호 데이터베이스를 구현한다. 사용자는 신뢰된다고 가정하므로 인증이 필요 없고 비밀번호 조회와 변경 권한을 가진다. {- A quick note for the over-eager refactorers out there: This is (somewhat) intentionally ugly. It doesn't use the State monad to hold the DB because it hasn't been introduced yet. Perhaps we could use this as an example of How Monads Improve Things? -} module PassDB where import qualified Data.Map as M import System.Exit type User Name = String type Password = String type PassDB = M.Map User Name Password -- PassBD is a map from usernames to passwords -- | Ask the user for a user name and new password, and return the new PassDB changePass :: PassDB -> IO PassDB changePass db = do putStrLn "Enter a user name and new password to change." putStr "User name: " un <- getLine putStrLn "New password: " pw <- getLine if un `M.member` db -- if un is one of the keys of the map then return $ M.insert un pw db -- then update the value with the new password else do putStrLn $ "Can't find user name '" ++ un ++ "' in the database." return db -- | Ask the user for a user name, whose password will be displayed. viewPass :: PassDB -> IO () viewPass db = do putStrLn "Enter a user name, whose password will be displayed." putStr "User name: " un <- getLine putStrLn $ case M.lookup un db of Nothing -> "Can't find user name '" ++ un ++ "' in the database." Just pw -> pw -- | The main loop for interacting with the user. mainLoop :: PassDB -> IO PassDB mainLoop db = do putStr "Command [cvq]: " c <- getChar putStr "\n" -- See what they want us to do. If they chose a command other than 'q', then -- recurse (i.e. ask the user for the next command). We use the Maybe datatype -- to indicate whether to recurse or not: 'Just db' means do recurse, and in -- running the command, the old datbase changed to db. 'Nothing' means don't -- recurse. db' <- case c of 'c' -> fmap Just $ changePass db 'v' -> do viewPass db; return (Just db) 'q' -> return Nothing _ -> do putStrLn $ "Not a recognised command, '" ++ [c] ++ "'." return (Just db) maybe (return db) mainLoop db' -- | Parse the file we've just read in, by converting it to a list of lines, -- then folding down this list, starting with an empty map and adding the -- user name and password for each line at each stage. parseMap :: String -> PassDB parseMap = foldr parseLine M.empty . lines where parseLine ln map = let [un, pw] = words ln in M.insert un pw map -- | Convert our database to the format we store in the file by first converting -- it to a list of pairs, then mapping over this list to put a space between -- the user name and password showMap :: PassDB -> String showMap = unlines . map (\(un, pw) -> un ++ " " ++ pw) . M.toAscList main :: IO () main = do putStrLn $ "Welcome to PassDB. Enter a command: (c) hange a password, " ++ "(v) iew a password or (q) uit." dbFile <- readFile "passdb" db' <- mainLoop (parseMap dbFile) writeFile "passdb" (showMap db') Data.Map의 경우 그 구현은 size balanced binary tree에 기반한다. ↩ http://hackage.haskell.org/package/containers-0.6.0.1/docs/Data-Map.html ↩ 2 일반적인 작업 일반적인 작업 디버깅 테스팅 소프트웨어 패키징 (Cabal) Foreign Function Interface(FFI) 활용하기 제네릭 프로그래밍: 정형화된 코드는 그만 1 디버깅 원문: https://en.wikibooks.org/wiki/Haskell/Debugging Debug.Trace를 이용한 디버그 출력 추가 조언 유용한 관용구 GHCi를 이용한 점진적 개발 Hat을 이용한 디버깅 일반적인 팁 Debug.Trace를 이용한 디버그 출력 디버그 출력은 프로그램을 디버깅하는 흔한 수단이다. 명령형 언어에서는 코드 군데군데 프린트문을 끼워 넣어 표준 출력 또는 로그 파일에 출력하여 디버그 정보(예를 들면 특정 변수의 값이나 사람이 읽을 수 있는 메시지)를 추적할 수 있다. 하지만 하스켈에서는 IO 모나드를 통하지 않으면 어떤 정보도 출력할 수 없다. 그렇다고 단지 디버깅을 위해 IO 모나드를 도입하고 싶지는 않을 것이다. 이 문제를 해결하기 위해 표준 라이브러리는 Debug.Trace를 제공한다. 이 모듈은 trace라는 함수를 익스포트하는데, trace는 프로그램 어디에서든 디버그 출력문을 붙일 수 있는 편리한 수단이다. 예를 들어 이 프로그램은 fib에 전달한 0이나 1이 아닌 모든 인자를 출력한다. module Main where import Debug.Trace fib :: Int -> Int fib 0 = 0 fib 1 = 1 fib n = trace ("n: " ++ show n) $ fib (n - 1) + fib (n - 2) main = putStrLn $ "fib 4: " ++ show (fib 4) 다음은 출력 결과다. n: 4 n: 3 n: 2 n: 2 fib 4: 3 trace로 프로그램의 실행 순서를 추적할 수도 있다. 즉 어떤 함수가 먼저 호출되고 그다음은 무엇이 호출되는지 알아낼 수 있다. 그러려면 관심 있는 함수들에 추적 표를 달아놓는다. module Main where import Debug.Trace factorial :: Int -> Int factorial n | n == 0 = trace ("branch 1") 1 | otherwise = trace ("branch 2") $ n * (factorial $ n - 1) main = do putStrLn $ "factorial 6: " ++ show (factorial 6) 이 프로그램을 실행하면 꼬리표들이 실행되는 순서대로 디버그 문자열을 출력한다. 그 출력은 빠트린 구문 같은 것에 의해 발생하는 오류의 위치를 찾는데 유용할 수 있다. 추가 조언 앞서 언급했듯 trace는 IO 모나드 밖에서 사용할 수 있다. 그리고 그 타입 시그너쳐를 보면 trace :: String -> a -> a 이것이 순수 함수임을 볼 수 있다. 하지만 분명히 trace는 메시지를 출력하며 IO 작업을 한다. 이게 무슨 일일까? 사실 trace는 IO와 순수 하스켈의 격리를 회피하기 위해 지저분한 기교를 부린다. 이는 trace의 문서에도 명시되어 있다. trace 함수는 오직 디버깅 또는 실행의 모니터링을 위해서만 사용해야 한다. 이 함수는 참조 투명성이 없다. 그 타입은 순수 함수를 나타내지만 추적 메시지를 출력하는 사이드 이펙트를 가진다. trace를 사용할 때 흔한 실수는 디버그 출력을 기존 함수에 끼워 넣다가 trace가 출력하는 메시지 안에 값 평가를 포함하는 것이다. 예를 들어 이렇게 하면 안 된다. let foo = trace ("foo = " ++ show foo) $ bar in baz 이는 무한 재귀를 일으킨다. trace 메시지가 bar 표현식보다 먼저 평가되는데 그러면 foo와 bar의 평가를 유발하고 다시 trace 메시지의 평가를 유발하는 게 되풀이되기 때문이다. 여기서는 show foo 대신 show bar를 써야 한다. let foo = trace ("foo = " ++ show bar) $ bar in baz 유용한 관용구 show를 포함하는 헬퍼 함수가 편리한 경우가 있다. traceThis :: (Show a) => a -> a traceThis x = trace (show x) x 비슷한 결에서 Debug.Trace는 traceShow 함수를 정의하는데, 이것은 첫 번째 인자를 "출력" 하고 두 번째 인자를 평가한다. traceShow :: (Show a) => a -> b -> b traceShow = trace . show 마지막으로 debug 함수도 유용할 수 있다. debug = flip trace debug를 이용하면 이런 코드를 작성할 수 있다. main = (1 + 2) `debug` "adding" 이렇게 하면 디버깅 구문의 주석 처리가 쉬워진다. GHCi를 이용한 점진적 개발 원문 없음 Hat을 이용한 디버깅 원문 없음 일반적인 팁 원문 없음 2 테스팅 원문: https://en.wikibooks.org/wiki/Haskell/Testing Quickcheck 순수성을 유지하기 QuickCheck를 이용한 테스팅 take5의 테스팅 또 다른 속성 커버리지 QuickCheck에 대한 추가 정보 HUnit Quickcheck 다음 함수를 살펴보자. getList = find 5 where find 0 = return [] find n = do ch <- getChar if ch `elem` ['a'..'e'] then do tl <- find (n-1) return (ch : tl) else find n 하스켈에서 이 함수를 효과적으로 테스트하는 방법은 무엇일까? 리팩토링과 QuickCheck를 활용해 보자. 순수성을 유지하기 getList 함수를 테스트하기 어려운 이유는 getChar가 IO를 수행해서 상황을 검증할 내부적인 수단이 없기 때문이다. do 블록 안의 다른 구문들이 모두 IO로 감싸져있다. 이 함수를 풀어헤쳐서 최소한 QuickCheck를 통해 참조 투명성이라도 테스트해 보자. 달갑지 않은 로우 레벨 IO 처리를 모두 피하기 위해 게으른 IO의 이점을 활용할 수 있다. 첫 단계는 함수의 IO 부분을 얇은 "스킨" 레이어로 분리하는 것이다. -- A thin monadic skin layer getList :: IO [Char] getList = fmap take5 getContents -- The actual worker take5 :: [Char] -> [Char] take5 = take 5. filter (`elem` ['a'..'e']) QuickCheck를 이용한 테스팅 이제 우리 알고리즘의 핵심부인 take5 함수를 별도 테스트할 수 있다. QuickCheck를 활용해 보자. 먼저 Char 타입의 Arbitrary 인스턴스가 필요하다. 이 인스턴스는 테스트에 쓸 임의 Char의 생성을 담당한다. 단순함을 위해 그 범위를 적절한 문자들로 한정하자. import Data.Char import Test.QuickCheck instance Arbitrary Char where arbitrary = choose ('\32', '\128') coarbitrary c = variant (ord c `rem` 4) GHCi를 켜고 일반적인 속성 몇 개를 실험해 보자. (하스 켈 REPL에서 QuickCheck 테스팅 프레임워크를 바로 이용할 수 있다.) 쉬운 것부터 해보면, [Char]는 그 자신과 동일하다. *A> quickCheck ((\s -> s == s) :: [Char] -> Bool) OK, passed 100 tests. 방금 무슨 일이 일어난 걸까? QuickCheck는 무작위 [Char] 값을 100개 생성하고 우리가 지정한 속성을 적용하여 모든 경우에 대해 결과가 True 임을 확인했다. QuickCheck가 테스트 집합을 생성해 준 것이다. 이제 더 흥미로운 속성을 시도해 보자. 두 번의 반전은 원본을 반환한다. *A> quickCheck ((\s -> (reverse.reverse) s == s) :: [Char] -> Bool) OK, passed 100 tests. 훌륭하다. take5의 테스팅 QuickCheck를 이용한 테스팅의 첫 단계는 함수의 모든 입력에 대해 참인 속성을 준비하는 것이다. 즉 불변식을 찾아야 한다. 간단한 불변식으로 s l n t ( a e s ) 5 같은 것이 있다. 이걸 QuickCheck 속성으로 작성해 보자. \s -> length (take5 s) == 5 이제 QuickCheck에서 실행해 볼 수 있다. *A> quickCheck (\s -> length (take5 s) == 5) Falsifiable, after 0 tests: "" 이런, QuickCheck가 문제점을 잡아냈다. 입력 문자열의 길이가 5보다 작으면 필터링 결과 문자열의 길이도 5 이상일 수 없다. 속성을 조금 널찍하게 만들어보자. s l n t ( a e s ) 5 즉 take5는 길이가 최대 5인 문자열을 반환한다. 실험해 보자. *A> quickCheck (\s -> length (take5 s) <= 5) OK, passed 100 tests. 훌륭하다. 또 다른 속성 올바른 문자들이 반환되는지도 확인해 볼 수 있다. 즉 반환되는 모든 문자는 집합 ['a', 'b', 'c', 'd', 'e']의 구성원이다. 이렇게 기술할 수 있다. s e ( ∈ a e s ) ( ∈, , , , ) 그리고 QuickCheck에서는 *A> quickCheck (\s -> all (`elem` ['a'..'e']) (take5 s)) OK, passed 100 tests. 멋지다. 이제 함수가 반환하는 문자열이 너무 길거나 잘못된 문자를 포함하지 않는다고 확신할 수 있다. 커버리지 [Char]를 테스트할 때 QuickCheck의 기본 구성의 문제점은 테스트 100개가 우리의 상황에는 충분하지 않다는 것이다. 사실 우리가 제공한 Arbitrary 인스턴스에 대해 QuickCheck는 길이가 5보다 큰 String 객체를 절대로 생성하지 않는다. 직접 확인해 볼 수도 있다. *A> quickCheck (\s -> length (take5 s) < 5) OK, passed 100 tests. 우리에게 정말로 필요한 것은 더 긴 문자열이지만 QuickCheck는 여러 Char들을 생성하는 데 시간을 낭비한다. 이에 대한 해결책은 QuickCheck의 기본 구성을 바꿔서 더 깊게 테스트하도록 만드는 것이다. deepCheck p = check (defaultConfig { configMaxTest = 10000}) p 이러면 시스템이 이상 무라고 결론내기 전에 테스트 케이스를 10000개 찾도록 만든다. 더 긴 문자열을 생성하는지 확인해 보자. *A> deepCheck (\s -> length (take5 s) < 5) Falsifiable, after 125 tests: ";:iD^*NNi~Y\\RegMob\DEL@krsx/=dcf7kub|EQi\DELD*" QuickCheck가 생성하는 테스트 데이터는 verboseCheck 훅을 이용해서 확인할 수 있다. 다음은 정수 리스트에 대해 실험해 본 것이다. *A> verboseCheck (\s -> length s < 5) 0: [] 1: [0] 2: [] 3: [] 4: [] 5: [1,2,1,1] 6: [2] 7: [-2,4, -4,0,0] Falsifiable, after 7 tests: [-2,4, -4,0,0] QuickCheck에 대한 추가 정보 http://haskell.org/haskellwiki/Introduction_to_QuickCheck http://haskell.org/haskellwiki/QuickCheck_as_a_test_set_generator HUnit 가끔은 일반적인 규칙을 정의하기보다는 테스트의 예시를 제공하는 게 쉬울 때가 있다. HUnit은 그런 일을 도와주는 유닛 테스팅 프레임워크를 제공한다. QuickCheck에 일반적인 규칙을 넘겨서 그런 예시를 만들어낼 수도 있지만 그런 경우에는 HUnit을 쓰면 할 일이 더 적을 것이다. TODO: HUnit 테스트 예시, 짧은 소개 HUnit의 세부사항은 그 사용자 가이드에서 볼 수 있다. 3 소프트웨어 패키징 (Cabal) (검토 중) 원문: https://en.wikibooks.org/wiki/Haskell/Packaging TODO 실제로 따라 해보고 되는지 확인 깨진 링크 처리 추천 도구 버전 관리 (Revision control) 빌드 시스템 문서화 테스팅 간단한 프로젝트의 구조 디렉터리 생성 하스 켈 소스 작성 darcs에 넣기 빌드 시스템 추가 프로젝트 빌드 하기 실행 haddock 문서 빌드 하기 자동화된 테스트 추가: QuickCheck darcs에서 test suite 실행 안정 버전 태그 하기, tarball 만들기, 판매하기! 고급 Darcs 기능: lazy get 배포 darcs를 이용한 tarball Cabal을 이용한 tarball 요약 라이브러리 계층적 소스 코드 Cabal 파일 더 복잡한 빌드 시스템 내부 모듈 자동화 cabal init mkcabal 라이선스 배포 호스팅 예제 노트 새 하스 켈 프로젝트 또는 프로그램을 제작하기 위한 최선의 실천 지침. 추천 도구 거의 모든 하스 켈 프로젝트는 다음 도구들을 활용한다. 각자 나름의 쓸모가 있지만 함께 사용하면 모든 이의 생산성이 증가하고 여러분이 패치를 받을 가능성도 높아진다. 버전 관리 (Revision control) 특별한 이유가 없으면 darcs를 사용하라. 아니면 git도 있다. git을 싫어한다면 darcs를 살펴볼 것. darcs는 하스 켈로 작성되었고 많은 하스 켈 개발자가 사용하고 있다. 입문용으로는 위키 북 darcs 이해하기를 볼 것. 빌드 시스템 Cabal을 사용하라. 적어도 Cabal User's Guide의 2절 첫 부분은 읽어야 한다. 문서화 라이브러리에는 Haddock을 사용하라. 최신 버전을 쓸 것을 추천한다. (2010년 12월 기준으로 2.8 이상) 테스팅 순수 코드는 QuickCheck 또는 SmallCheck로, 비순수 코드는 HUnit로 테스트할 수 있다. 간단한 프로젝트의 구조 최소한의 하스 켈 프로젝트인 HNop에서 새 하스 켈 프로젝트의 기본 구조를 따올 수 있다. HNop은 빈 프로젝트 "haq"를 포함 다음 파일들로 구성된다. 옮긴이: HNop 원본 링크가 깨져서 hackage 링크로 대체하였지만 완전히 같은 프로젝트는 아닙니다. Haq.hs -- 메인 하스 켈 소스 파일 haq.cabal -- cabal 빌드 구성 Setup.hs -- 빌드 스크립트 _darcs 또는. git -- 버전 관리 README -- 정보 LICENSE -- 라이선스 물론 여기에 하위 디렉터리나 여러 모듈을 추가할 수 있다. 다음은 하스 켈 프로그램 "haq"를 제작하기 위해 darcs와 cabal을 사용하는 최소한의 하스 켈 프로젝트를 만들고, 빌드하고, 설치하고, 배포하는 절차다. 커맨드 도구 'cabal init'는 이 모든 것을 자동으로 해주지만 먼저 이 절차를 이해해야 한다. 이제 간단한 하스 켈 실행 프로그램을 위한 기반 구조를 구축한다. 라이브러리에 대한 조언은 그다음에 나온다. 디렉터리 생성 어딘가에 소스 디렉터리를 생성한다. $ mkdir haq $ cd haq 하스 켈 소스 작성 프로그램을 작성한다. $ cat > Haq.hs -- -- Copyright (c) 2006 Don Stewart - http://www.cse.unsw.edu.au/~dons -- GPL version 2 or later (see http://www.gnu.org/copyleft/gpl.html) -- import System.Environment -- 'main' runs the main program main :: IO () main = getArgs >>= print . haqify . head haqify s = "Haq! " ++ s darcs에 넣기 소스를 버전 관리에 넣는다. $ darcs init $ darcs add Haq.hs $ darcs record addfile ./Haq.hs Shall I record this change? (1/?) [ynWsfqadjkc], or ? for help: y hunk ./Haq.hs 1 +-- +-- Copyright (c) 2006 Don Stewart - http://www.cse.unsw.edu.au/~dons +-- GPL version 2 or later (see http://www.gnu.org/copyleft/gpl.html) +-- +import System.Environment +-- | 'main' runs the main program +main :: IO () +main = getArgs >>= print . haqify . head +haqify s = "Haq! " ++ s Shall I record this change? (2/?) [ynWsfqadjkc], or ? for help: y What is the patch name? Import haq source Do you want to add a long comment? [yn] n Finished recording patch 'Import haq source' 이제 darcs가 작동하고 있다. $ ls Haq.hs _darcs git의 경우는 다음과 같이 사용한다. $ git config --global user.name "John Doe" $ git config --global user.email johndoe@example.com $ git init $ git add * $ git commit -m 'Import haq source' $ ls -A .git Haq.hs 빌드 시스템 추가 프로젝트를 어떻게 빌드 할지 서술하는. cabal 파일을 생성한다. $ cat > haq.cabal Name: haq Version: 0.0 Synopsis: Super cool mega lambdas Description: My super cool, indeed, even mega lambdas will demonstrate a basic project. You will marvel. License: GPL License-file: LICENSE Author: Don Stewart Maintainer: Don Stewart <dons@cse.unsw.edu.au> Build-Depends: base Executable: haq Main-is: Haq.hs 여러분의 패키지가 (array 등) 다른 패키지를 사용한다면 Build-Dependes: 필드에 추가해야 한다. 실제로 빌드를 수행할 Setup.lhs를 추가한다. $ cat > Setup.lhs #! /usr/bin/env runhaskell > import Distribution.Simple > main = defaultMain cabal은 포맷만 올바르면 Setup.hs도 Setup.lhs도 허용한다. 하지만 항상 #! /usr/bin/env runhaskell 라인을 포함하는 것이 좋다. 이 라인은 shebang 관례를 따르기 때문에 runhaskell을 직접 호출하는 대신 유닉스 셸에서 Setup.hs를 바로 실행할 수 있다. (물론 Setup 파일이 실행 가능한 상태일 때만) 변경 사항을 기록한다. $ darcs add haq.cabal Setup.lhs $ darcs record --all What is the patch name? Add a build system Do you want to add a long comment? [yn] n Finished recording patch 'Add a build system' git에서는: $ git add haq.cabal Setup.lhs $ git commit -m 'Add a build system' 프로젝트 빌드 하기 이제 빌드 한다. $ runhaskell Setup.lhs configure --prefix=$HOME --user $ runhaskell Setup.lhs build $ runhaskell Setup.lhs install 실행 이제 프로젝트를 실행할 수 있다. $ haq me "Haq! me" 설치 단계를 생략하고 그 자리에서 실행할 수도 있다. $ dist/build/haq/haq you "Haq! you" haddock 문서 빌드 하기 dist/doc/*에 API 문서를 생성한다. $ runhaskell Setup.lhs haddock dist/doc/에 파일들을 생성한다. $ w3m -dump dist/doc/html/haq/Main.html haq Contents Index Main Synopsis main :: IO () Documentation main :: IO () main runs the main program Produced by Haddock version 0.7 아무 출력도 없는가? haddock이 정말 설치되었는지 확인하라. haddock은 별도의 프로그램이며 cabal처럼 하스 켈 컴파일러에 딸려오는 것이 아니다. 자동화된 테스트 추가: QuickCheck QuickCheck를 사용해서 Haq.hs의 코드의 일부 property를 확인한다. 테스트 모듈 Tests.hs를 만들고 QuickCheck 뼈대를 추가한다. $ cat > Tests.hs import Char import List import Test.QuickCheck import Text.Printf main = mapM_ (\(s, a) -> printf "%-25s: " s >> a) tests instance Arbitrary Char where arbitrary = choose ('\0', '\128') coarbitrary c = variant (ord c `rem` 4) 간단한 property를 작성한다. $ cat >> Tests.hs -- reversing twice a finite list, is the same as identity prop_reversereverse s = (reverse . reverse) s == id s where _ = s :: [Int] -- and add this to the tests list tests = [("reverse.reverse/id", test prop_reversereverse)] 이 테스트를 실행하고 QuickCheck가 테스트 데이터를 생성하도록 한다. $ runhaskell Tests.hs reverse.reverse/id : OK, passed 100 tests. 'haqify' 함수의 테스트를 추가하자. -- Dropping the "Haq! " string is the same as identity prop_haq s = drop (length "Haq! ") (haqify s) == id s where haqify s = "Haq! " ++ s tests = [("reverse.reverse/id", test prop_reversereverse) ,("drop.haq/id", test prop_haq)] 테스트해 본다. $ runhaskell Tests.hs reverse.reverse/id : OK, passed 100 tests. drop.haq/id : OK, passed 100 tests. darcs에서 test suite 실행 darcs가 모든 커밋에 대해 test suite를 실행하도록 설정할 수 있다. $ darcs setpref test "runhaskell Tests.hs" Changing value of test from '' to 'runhaskell Tests.hs' 이러면 모든 QuickCheck를 실행할 것이다. 여러분의 테스트가 요구한다면 다른 것들도 빌드 됨을 보장해야 할 것이다. (예: darcs setpref test "alex Tokens.x;happy Grammar.y;runhaskell Tests.hs") 새 패치를 커밋 해보자. $ darcs add Tests.hs $ darcs record --all What is the patch name? Add testsuite Do you want to add a long comment? [yn] n Running test... reverse.reverse/id : OK, passed 100 tests. drop.haq/id : OK, passed 100 tests. Test ran successfully. Looks like a good patch. Finished recording patch 'Add testsuite' 훌륭하다. 이제 패치는 커밋 전에 테스트 suite을 통과해야 한다. 안정 버전 태그 하기, tarball 만들기, 판매하기! 안정 버전을 태그 한다. $ darcs tag What is the version name? 0.0 Finished tagging patch 'TAG 0.0' 고급 Darcs 기능: lazy get 여러분의 저장소에 패치가 쌓여감에 따라 새로운 사용자들은 최초 darcs get에 걸리는 시간에 점점 짜증이 날 것이다. (yi나 GHC 같은 프로젝트는 패치가 수천 개다) Darcs가 충분히 빠르긴 하지만 패치 수천 개를 일일이 다운로드하는 것은 시간이 좀 걸린다. 더 효율적인 방법은 없을까? Darcs는 darcs get에 --lazy 옵션을 제공한다. 이 옵션은 저장소의 최신 버전만을 다운로드하도록 한다. 패치는 나중에 필요할 때 다운로드된다. 배포 여러분의 하스 켈 프로그램을 배포할 때 대략 세 가지 옵션이 있다. Darcs 저장소를 통해 배포 tarball을 통해 배포 Darcs tarball Cabal tarball Darcs 저장소를 쓸 경우 public 이면 그걸로 끝이다. 하지만 여러분이 쓰는 서버에 Darcs가 없거나 컴퓨터가 사람들이 darcs pull을 쓸 수 있도록 설정되지 않았을 수도 있다. 그런 경우 소스를 tarball로 배포해야 한다. darcs를 이용한 tarball darcs는 압축된 tarball을 만드는 명령어를 제공한다. 이 tarball은 darcs가 관리하는 모든 파일의 복사본을 담는다. (_darcs에 있는 것들은 포함되지 않는다. 리비전 히스토리 없이 소스 파일만 들어간다) $ darcs dist -d haq-0.0 Created dist as haq-0.0.tar.gz 이걸로 끝이다! Cabal을 이용한 tarball 우리 코드가 cabal에 기반하기 때문에 Cabal으로 직접 tarball을 생성할 수 있다. $ runhaskell Setup.lhs sdist Building source dist for haq-0.0... Source tarball created: dist/haq-0.0.tar.gz 이 방법은 Darcs로 생성한 tarball에 비해 장점도 있고 단점도 있다. 주된 장점은 Cabal이 우리의 저장소를 검사하고 tarball이 HackageDB와 cabal-install이 요구하는 구조를 가지는지 확인한다는 것이다. 하지만 단점도 있다. Cabal은 프로젝트 빌드에 필요한 파일들만 패키지로 만든다. 저장소의 다른 파일들이 언젠가 필요한 시점이 와도, 그 파일들은 포함되지 않는다. 1 기타 파일들을 포함하려면 (위 예제의 Test.hs 같은) cabal 파일에 이런 줄을 추가해야 한다. extra-source-files: Tests.hs AUTHORS나 README 같은 파일이 있다면 역시 포함할 수 있다. data-files: AUTHORS, README 요약 다음 파일들이 생성되었다. $ ls Haq.hs Tests.hs dist haq.cabal Setup.lhs _darcs haq-0.0.tar.gz 라이브러리 하스 켈 라이브러리를 제작하는 절차도 거의 같다. 가상의 "ltree" 라이브러리를 통해 차이점을 보자. 계층적 소스 코드 소스는 모듈 레이아웃 가이드를 따르는 경로에 있어야 한다. Data.LTree 모듈에 대해서는 다음과 같은 디렉터리 구조를 만든다. $ mkdir Data $ cat > Data/LTree.hs module Data.LTree where Data.LTree 모듈은 Data/LTree.hs에 있게 된다. Cabal 파일 라이브러리를 위한 Cabal 파일들은 공개 모듈들을 나열하며 실행 파일 부분은 없다. $ cat ltree.cabal Name: ltree Version: 0.1 Description: Lambda tree implementation License: BSD3 License-file: LICENSE Author: Don Stewart Maintainer: dons@cse.unsw.edu.au Build-Depends: base Exposed-modules: Data.LTree 이 라이브러리는 다음과 같이 빌드 한다. $ runhaskell Setup.lhs configure --prefix=$HOME --user $ runhaskell Setup.lhs build Preprocessing library ltree-0.1... Building ltree-0.1... [1 of 1] Compiling Data.LTree ( Data/LTree.hs, dist/build/Data/LTree.o) /usr/bin/ar: creating dist/build/libHSltree-0.1.a 라이브러리가 오브젝트 아카이브로서 생성되었다. *nix 시스템에서는 configure 단계에 --user 플래그를 붙여야 할 것이다. 이는 설치 도중 로컬 패키지 데이터베이스를 업데이트하길 원한다는 뜻이다. 이제 설치한다. $ runhaskell Setup.lhs install Installing: /home/dons/lib/ltree-0.1/ghc-6.6 & /home/dons/bin ltree-0.1... Registering ltree-0.1... Reading package info from ".installed-pkg-config" ... done. Saving old package config file... done. Writing new package config file... done. 이걸로 끝이다. 이제 라이브러리를 ghci에서 쓴다던가 하는 것이 가능하다. $ ghci -package ltree Prelude> :m + Data.LTree Prelude Data.LTree> 새로운 라이브러리가 스코프 안에 있으며 사용할 준비가 되었다. 더 복잡한 빌드 시스템 큰 프로젝트에서는 서브디렉터리들에 소스 트리들을 나눠 담는 것이 유용하다. 새 디렉터리, 가령 "src" 같은 것을 만들고 여기에 소스 트리를 넣으면 된다. Cabal이 이 코드를 검색하도록 하려면 Cabal 파일에 다음 줄을 추가한다. hs-source-dirs: src Cabal은 이 외에도 configure 스크립트를 실행하는 등 여러 기능을 설정할 수 있다. Cabal 문서에서 더 많은 정보를 볼 수 있다. 내부 모듈 여러분의 라이브러리가 노출되지 않는 내부 모듈을 사용한다면 other-modules 필드에 나열하는 것을 잊지 말 것. other-modules: My.Own.Module 그렇지 않으면 (GHC 6.8.3 기준) 라이브러리가 에러 없이 빌드 되지만 실제로는 애플리케이션에서 쓸 수 없다. 빌드 때 링커 에러가 나기 때문이다. 자동화 cabal init 하스켈의 패키지 관리 도구인 cabal-install은 개발자들이 간단한 cabal 프로젝트를 만드는 것을 돕는 커맨드 라인 도구를 제공한다. 실행하고 모든 질문에 대답만 하면 된다. 각각 기본값도 주어진다. $ cabal init Package name [default "test"]? Package version [default "0.1"]? Please choose a license: ... mkcabal mkcabal은 cabal init 이전에 있던 도구로서 역시 새 cabal 프로젝트 생성을 자동화한다. darcs get http://code.haskell.org/~dons/code/mkcabal 이 도구는 윈도우즈에서는 작동하지 않는다. 윈도우즈 버전 GHC는 이 도구에 필요한 readline 패키지를 포함하지 않는다. 사용법은 다음과 같다. $ mkcabal Project name: haq What license ["GPL","LGPL","BSD3","BSD4","PublicDomain","AllRightsReserved"] ["BSD3"]: What kind of project [Executable, Library] [Executable]: Is this your name? - "Don Stewart " [Y/n]: Is this your email address? - "<dons@cse.unsw.edu.au>" [Y/n]: Created Setup.lhs and haq.cabal $ ls Haq.hs LICENSE Setup.lhs _darcs dist haq.cabal 'haq' 프로젝트를 위한 스텁 Cabal 파일들을 채워 넣는다. 완전히 새로운 프로젝트 트리를 생성하려면 $ mkcabal --init-project Project name: haq What license ["GPL","LGPL","BSD3","BSD4","PublicDomain","AllRightsReserved"] ["BSD3"]: What kind of project [Executable, Library] [Executable]: Is this your name? - "Don Stewart " [Y/n]: Is this your email address? - "<dons@cse.unsw.edu.au>" [Y/n]: Created new project directory: haq $ cd haq $ ls Haq.hs LICENSE README Setup.lhs haq.cabal 라이선스 base 라이브러리 패키지의 코드는 BSD 라이선스 또는 보다 자유롭고 개방된 것이어야 한다. 그 외에는 모두 당신, 저작자에게 달려있다. 라이선스를 선택하라. 여러분이 사용하는 하스 켈 패키지와 C 라이브러리의 라이선스를 확인하라. 이것들이 여러분의 선택을 제한할 수 있다. 연관된 프로젝트들과 최대한 비슷한 라이선스를 사용하라. 하스 켈 커뮤니티는 대략 두<NAME>으로 나뉜다. 한쪽은 모든 것을 BSD 또는 퍼블릭 도메인으로 배포하고 다른 쪽은 GPL/LGPL 파다. (대략 자유 소프트웨어 커뮤니티의 카피레프트/논 카피레프트 분단을 반영한다고 보면 된다) 어떤 하스 켈러들은 특히 LGPL을 피할 것을 추천하는데, cross-module optimization 문제 때문이다. 많은 라이선스 질문들이 그렇듯이 이 조언도 논란의 여지가 있다. 몇 하스 켈 프로젝트는 (wxHaskell, HaXml 등) LGPL을 쓰는데, cross-module optimization 문제를 피하기 위해 추가적인 허용 조항이 있다. 배포 여러분의 코드를 안정적이고 태깅 된 tarball로 배포해야 한다. 배포할 때 단순히 darcs에 기대지 말 것. darcs dist는 darcs 저장소로부터 직접 tarball을 생성한다. 예를 들어 $ cd fps $ ls Data LICENSE README Setup.hs TODO _darcs cbits dist fps.cabal tests $ darcs dist -d fps-0.8 Created dist as fps-0.8.tar.gz 이러면 이제 그냥 fps-0.8.tar.gz를 게시할 수 있다. post-hook을 걸어서 darcs가 '일별 스냅샷'을 만들도록 할 수도 있다. 다음을 _darcs/prefs/defaults에 넣는다. apply posthook darcs dist apply run-posthook 조언: 각 릴리스를 darcs tag로 태깅 할 것. $ darcs tag 0.8 Finished tagging patch 'TAG 0.8' 이러면 사람들이 darcs get --lazy --tag 0.8을 이용해 전체 히스토리가 아니라 이 태그 된 버전만 얻을 수 있다. 호스팅 공개 또는 비공개 Darcs 저장소를 http://patch-tag.com/에 무료로 호스트 할 수 있다. 또는 단순히 Darcs 저장소가 웹 페이지에서 보이게 만들 수도 있다. http://code.haskell.org/의 Haskell Community Server에 호스트 하는 방법도 있다. http://community.haskell.org/admin/를 통해 계정을 요청할 수 있다. https://github.com/에서 Git 호스팅을 할 수도 있다. 예제 새 하스 켈 라이브러리를 지금까지의 절차에 따라 작성하고, 패키징하고, 배포하는 완전한 예제(링크 깨짐) At least part of this page was imported from the Haskell wiki article How to write a Haskell program, in accordance to its Simple Permissive License. If you wish to modify this page and if your changes will also be useful on that wiki, you might consider modifying that source page instead of this one, as changes from that page may propagate here, but not the other way around. Alternately, you can explicitly dual license your contributions under the Simple Permissive License. Note also that the original tutorial contains extra information about announcing your software and joining the Haskell community, which may be of interest to you. 노트 이는 사실 좋은 것이다. tarball에는 포함되지 않는 정밀 test suite을 만든다던가 하는 것이 가능해지기 때문에 사용자가 신경 쓸 필요가 없다. 우리의 코드에 숨은 가정과 생략을 밝힐 수도 있다. 여러분의 코드는 우연히 생성한 파일이 있을 때만 빌드와 실행이 가능했을 수도 있다. ↩ 4 FFI 원문: https://en.wikibooks.org/wiki/Haskell/FFI 하스켈에서 C 호출하기 마샬링 (타입 변환) 순수 C 함수 호출하기 비순수 C 함수 C 포인터 다루기 C 구조체 다루기 Storable 클래스의 인스턴스 만들기 C 함수 들여오기 Bessel 함수 구현 예제 고급 주제 이용 가능한 C 함수와 구조체 import와 inclusion 열거형 Haskell Function Target 하스 켈 함수를 C 알고리즘에 전달하기 미지의 구조체 다루기 완성된 함수 스스로 해제하는 포인터 C에서 하스 켈 호출하기 하스 켈 소스 C 소스 하스켈을 쓰는 건 좋다. 그런데 다른 언어, 특히 C로 작성된 라이브러리는 아주 많다. 이런 라이브러리들을 사용하려면, 그리고 C 코드가 하스 켈 함수를 이용하려면 FFI(Foreign Function Interface)가 필요하다. 하스켈에서 C 호출하기 마샬링 (타입 변환) C 함수를 호출하려면 하스 켈 타입을 알맞은 C 타입으로 변환해야 한다. Foreign.C.Types 모듈에 C 타입들이 있다. 다음 표에 몇 가지 예시가 있다. 하스 켈 Foreign.C.Types C Double CDouble double Char CUChar unsigned char Int CLong long int 하스 켈 타입을 C 타입으로 변환하는 작업을 마샬링이라고 한다. (반대 작업은 언마샬링이라고 한다) 기본 타입들은 직관적이다. 부동소수점 타입은 realToFrac을 쓰고 (Double과 CDouble 모두 Real과 Fractional 클래스의 인스턴스), 정수는 fromIntegral을 쓰는 식이다. 6.12.x 이전의 GHC를 쓰고 있다면 CLDouble 타입이 long double이 아니라 CDouble의 동의어임을 주의하라. 그냥 절대 사용하지 말 것. C 컴파일러가 long double을 double의 동의어로 생각하지 않는 이상 조용히 타입 오류를 낼 것이다. 6.12.x 이래로 CLDouble은 제거되었고, 알맞은 구현을 기다리고 있다. 순수 C 함수 호출하기 C로 구현된 순수 함수는 하스켈에서 큰 문제를 일으키지 않는다. C 표준 라이브러리의 sin 함수가 좋은 예시다. {-# LANGUAGE ForeignFunctionInterface #-} import Foreign import Foreign.C.Types foreign import ccall unsafe "math.h sin" c_sin :: CDouble -> CDouble 첫 줄에 FFI를 위한 GHC 확장을 명시한다. 그다음 Foreign과 Foreign.C.Types 모듈을 들여온다. 후자는 C의 배정밀도 부동소수점을 나타내는 CDouble에 대한 정보를 포함한다. 다음에는 외부 함수를 들여온다고 명시한다. "안전 수준"은 키워드 safe (기본값) 또는 unsafe다. 일반적으로 unsafe가 더 효율적이고 safe는 하스 켈 함수를 호출할 수 있는 C 코드에만 필요하다. 매우 특이한 경우이기 때문에 대부분은 unsafe 키워드를 써도 안전하다. 마지막으로 헤더와 함수 이름을 명시한다. 하스 켈 함수 이름으로 c_sin을 썼지만 무엇이든 가능하다. 함수 명세는 올 바라야 한다. GHC는 함수가 실제로 CDouble을 받는지, 뭘 반환하는지 확인하기 위해 C 헤더를 검사하지 않으며, 명세가 틀리면 예측할 수 없는 결과를 만든다. 이제 CDouble을 사용하는 함수의 래퍼를 만들어서 평범한 하스 켈 함수처럼 보이게 만들 수 있다. haskellSin :: Double -> Double haskellSin = realToFrac . c_sin . realToFrac C의 sin는 double을 받아 double을 반환하는 순수 함수이기 때문에 들여오기 간단하다. C의 복잡한 라이브러리에 만연한, 비순수 함수와 포인터의 경우 상황이 복잡해진다. 비순수 C 함수 rand는 의사 난수를 생성하는 고전적인 비순수 C 함수다. 여러분이 어떤 C 루틴이 출력하는 의사 난수열을 정확히 재현하고 싶기 때문에 하스켈의 System.Random.randomIO를 원치 않는다고 가정하자. 그러면 rand를 이전의 sin처럼 들여올 수 있다. {-# LANGUAGE ForeignFunctionInterface #-} import Foreign import Foreign.C.Types foreign import ccall unsafe "stdlib.h rand" c_rand :: CUInt -- Oops! 이 아무 생각 없는 구현을 GHCI에서 시도해 보면 c_rand가 항상 같은 값을 반환한다. > c_rand 1714636915 > c_rand 1714636915 실은 GHC에게 이게 순수 함수라고 했기 때문에, GHC는 한 순수 함수의 결과를 두 번 계산할 이유가 없다. GHC가 어떤 오류나 경고 메시지도 띄우지 않은 것에 주목하라. GHC에게 이 함수가 비순수임을 알리려면 IO 모나드를 써야 한다. {-# LANGUAGE ForeignFunctionInterface #-} import Foreign import Foreign.C.Types foreign import ccall unsafe "stdlib.h rand" c_rand :: IO CUInt foreign import ccall "stdlib.h srand" c_srand :: CUInt -> IO () C 의사 난수 생성기의 시드(seed)를 설정하기 위해 srand 함수도 들여왔다. > c_rand 1957747793 > c_rand 424238335 > c_srand 0 > c_rand 1804289383 > c_srand 0 > c_rand 1804289383 C 포인터 다루기 유용한 C 함수들은 대개 여러 인자를 받아 복잡한 계산을 하고 제어 코드를 반환한다. 즉 C 라이브러리들의 패러다임은 할당된 메모리에 대한 포인터들을 "타깃"으로 지정해 여기에 결과를 기록하고, 함수 자체는 정수를 반환하는 것이다(계산이 성공했으면 0, 아니면 특정 문제를 나타내는 숫자). 함수가 어떤 구조체에 대한 포인터를 반환하는 경우도 있다. 이 구조체는 아마 구현에 정의되어 있어 우리는 접근 불가능할 것이다. 교육적인 예시로 과학 계산용 자유 라이브러리인 GNU Scientific Library의 gsl_frexp 함수를 보자. 명세가 다음과 같은 간단한 C 함수다. double gsl_frexp (double x, int * e) 이 함수는 double x를 취해 다음과 같이 정규화된 분수 f와 정수<NAME> e를 반환한다. = × e ∈, 0.5 f 1 이 C 함수를 다음과 같이 하스켈에 이어준다. {-# LANGUAGE ForeignFunctionInterface #-} import Foreign import Foreign.Ptr import Foreign.C.Types foreign import ccall unsafe "gsl/gsl_math.h gsl_frexp" gsl_frexp :: CDouble -> Ptr CInt -> IO CDouble Ptr이 새롭게 등장했다. Ptr은 Storable 클래스의 어느 인스턴스와도 쓸 수 있다. 모든 C 타입 그리고 몇몇 하스 켈 타입이 가능한 대상이다. gsl_frexp의 결과가 IO 모나드 안에 있는 것에 주목하라. 포인터를 입출력으로 쓸 때는 이런 일이 흔하다. 단순히 CDouble를 쓰면 어떻게 되는지 곧 볼 것이다. frexp 함수는 다음과 같이 순수 하스 켈 코드로 구현된다. frexp :: Double -> (Double, Int) frexp x = unsafePerformIO $ alloca $ \expptr -> do f <- gsl_frexp (realToFrac x) expptr e <- peek expptr return (realToFrac f, fromIntegral e) 옮긴이: unsafePerformIO를 쓰려면 System.IO.Unsafe를 임포트 해야 합니다. 메모리 관리 세부사항은 치워놓고, 이 함수는 순수 함수다. 명세가 f와 e를 IO 모나드 밖으로 꺼내서 튜플로 반환하는 이유다. 하지만 f는 모나드 내부에 있다. f를 IO 모나드에서 꺼내려면 unsafePerformIO 함수를 사용한다. 함수가 순수하다는 걸 알 때만 사용해야 하며, 그러면 GHC가 알맞게 최적화할 수 있다. 포인터를 할당하려면 alloca 함수를 사용한다. 이 함수는 메모리를 해제할 책임도 진다. alloca는 인자로 Ptr a -> IO b 타입의 함수를 취하고 IO b를 반환한다. 실전에서는 다음 람다 함수와 같은 패턴을 따른다. ... alloca $ \pointer -> do c_function argument pointer result <- peek pointer return result 포인터가 여러 개 필요하면 이 패턴을 중첩할 수 있다. ... alloca $ \firstPointer -> alloca $ \secondPointer -> do c_function argument firstPointer secondPointer first <- peek firstPointer second <- peek secondPointer return (first, second) frexp 함수로 돌아가자. alloca의 인자인 람다 함수가 평가되자마자 peek로 포인터를 읽는다. C 함수 gsl_frexp가 IO 모나드 안의 값을 반환해야 하는 이유가 여기서 드러난다. GHC가 f를 언제 계산할지 결정할 수 있으면, GHC는 필요하기 전까지 f를 계산하지 않을 것이다. return이 f를 사용하는 마지막 줄이 바로 그때이며, 이때는 할당되었지만 아직 초기화되지 않아 임의 값을 가지는 메모리 주소에서 e를 읽은 후이다. 짧게 말하면 우리가 계산 순서를 결정하길 원하기 때문에 gsl_frexp가 모나 딕 값을 반환하게 하는 것이다. 어떤 함수가 출력을 저장하는 대신 입력을 제공해야 한다면 함수를 평가하기 전에 poke 함수로 포인터에 값을 설정한다. ... alloca $ \inputPointer -> alloca $ \outputPointer -> do poke inputPointer value c_function argument inputPointer outputPointer result <- peek outputPointer return result 마지막 줄에서는 C 타입으로부터 변환된 결과를 튜플에 넣고 반환한다. 이 함수를 테스트하려면 GHC를 GSL에 연결해야 한다. GHCi에서 다음을 실행한다. $ ghci frexp.hs -lgsl (대부분의 시스템에는 GSL이 미리 설치되어 있지 않다. 개발 패키지에서 내려받아 설치해야 할 것이다.) 옮긴이: 우분투는 libgsl-dev 패키지를 설치하면 됩니다. C 구조체 다루기 많은 C 함수가 struct의 형태 또는 구조체에 대한 포인터를 반환한다. 구조체를 직접 반환하는 경우는 드물고 대개 포인터를 반환한다. 반환값은 대부분 오류가 있었는지를 나타내는 int이다. 또 다른 GSL 함수인 gsl_sf_bessel_Jn_e를 살펴보자. 이 함수는 차수 n에 대해 regular cylindrical Bessel 함수를 계산해 그 결과를 gsl_sf_result 구조체에 대한 포인터로 반환한다. 이 구조체는 두 double을 포함하는데 하나는 계산 결과고 하나는 오차다. 함수가 반환하는 정수 에러 코드는 gsl_strerror를 이용해 C 문자열로 변환할 수 있다. 따라서 우리가 추구하는 하스 켈 함수의 명세는 다음과 같다. BesselJn :: Int -> Double -> Either String (Double, Double) 첫 번째 인자는 cylindrical Bessel 함수의 차수, 두 번째 인자는 함수의 인자, 반환값은 에러 메시지 또는 결과와 오차한계의 튜플이다. Storable 클래스의 인스턴스 만들기 gsl_sf_result 구조체에 대한 포인터를 할당하고 읽으려면 Storable 클래스의 인스턴스를 만들어야 한다. 그런 일에는 hsc2hs 프로그램이 적격이다. 먼저 Bessel.hsc 파일을 만들고 하스 켈 문법과 C 매크로를 섞어 쓴다. 나중에 다음 명령을 통해 하스 켈 코드로 확장한다. $ hsc2hs Bessel.hsc 그다음 Bessel.hs를 GHC로 로드한다. 다음은 Bessel.hsc의 처음 모습이다. {-# LANGUAGE ForeignFunctionInterface #-} module Bessel (besselJn) where import Foreign import Foreign.Ptr import Foreign.C.String import Foreign.C.Types #include <gsl/gsl_sf_result.h> data GslSfResult = GslSfResult { gsl_value :: CDouble, gsl_error :: CDouble } instance Storable GslSfResult where sizeOf _ = (#size gsl_sf_result) alignment _ = alignment (undefined :: CDouble) peek ptr = do value <- (#peek gsl_sf_result, val) ptr error <- (#peek gsl_sf_result, err) ptr return GslSfResult { gsl_value = value, gsl_error = error } poke ptr (GslSfResult value error) = do (#poke gsl_sf_result, val) ptr value (#poke gsl_sf_result, err) ptr error hsc2hs에게 gsl_sf_result에 대한 정보를 찾을 위치를 알리기 위해 #include 지시문을 사용한다. 그리고 GSL의 자료구조를 반영하는, CDouble 2개를 가지는 하스 켈 자료구조를 정의한다. 이것을 Storable의 인스턴스로 만들 것이다. 사실 이 예제에는 sizeOf, alignment, peek만 필요하지만 완벽함을 위해 poke도 추가하였다. sizeOf는 확실히 할당 절차에 필요하고, #size 매크로를 통해 hsc2hs에 의해 계산된다. alignment는 자료구조 alignment의 바이트 크기다. 일반적으로 자료구조 내 원소들의 alignment 중 가장 큰 것인데, 이 경우 모두 CDouble이므로 이것의 alignment를 쓴다. alignment의 인자의 값은 중요하지 않다. 중요한 것은 인자의 타입이다. peek는 do 블록과 #peek 매크로를 사용해 구현한다. val과 err는 GSL 소스 코드의 구조체 필드들의 이름이다. poke는 #poke 매크로로 구현한다. C 함수 들여오기 foreign import ccall unsafe "gsl/gsl_bessel.h gsl_sf_bessel_Jn_e" c_besselJn :: CInt -> CDouble -> Ptr GslSfResult -> IO CInt foreign import ccall unsafe "gsl/gsl_errno.h gsl_set_error_handler_off" c_deactivate_gsl_error_handler :: IO () foreign import ccall unsafe "gsl/gsl_errno.h gsl_strerror" c_error_string :: CInt -> IO CString GSL 라이브러리로부터 몇 가지 함수를 들여온다. 먼저 실제 계산을 하는 Bessel 함수, 그다음 gsl_set_error_handler_off 함수를 들여온다. 기본 GSL 에러 핸들러는 하스켈에서 호출해도 프로그램을 죽이기 때문에 우리가 직접 에러를 처리한다. 마지막으로 에러 코드를 사람이 읽을 수 있는 C 문자열로 번역하는 GSL 인터프리터를 들여온다. Bessel 함수 구현 마지막으로 n 차 GSL cylindrical Bessel 함수의 하스 켈 버전을 구현한다. besselJn :: Int -> Double -> Either String (Double, Double) besselJn n x = unsafePerformIO $ alloca $ \gslSfPtr -> do c_deactivate_gsl_error_handler status <- c_besselJn (fromIntegral n) (realToFrac x) gslSfPtr if status == 0 then do GslSfResult val err <- peek gslSfPtr return $ Right (realToFrac val, realToFrac err) else do error <- c_error_string status error_message <- peekCString error return $ Left ("GSL error: "++error_message) 이번에도 unsafePerformIO를 사용한다. 내부 구현은 그렇지 않을지라도 순수 함수로 취급되기 때문이다. GSL 결과 자료구조에 대한 포인터를 할당한 후 GSL 에러 핸들러를 비활성화해서, 무언가 잘못되었을 때 크래시가 나는 것을 막는다. 마지막으로 GSL 함수를 호출한다. 이 시점에서 함수가 반환하는 status가 0이면 결과를 unmarshal 하고 튜플로 반환한다. 그렇지 않으면 GSL 에러-문자열 함수를 호출하고 에러를 Left 결과로 전달한다. 예제 Bessel.hsc 함수 작성을 마쳤으니 하스 켈로 변환하고 로드한다. $ hsc2hs Bessel.hsc $ ghci Bessel.hs -lgsl 이제 Bessel 함수를 호출할 수 있다. > besselJn 0 10 Right (-0.2459357644513483, 1.8116861737200453e-16) > besselJn 1 0 Right (0.0,0.0) > besselJn 1000 2 Left "GSL error: underflow" 고급 주제 이 절에서는 FFI의 보다 복잡한 기능을 활용하는 고급 예제를 다룬다. GSL의 좀 더 복잡한 함수를 하스 켈로 임포트 할 것이며, 이 함수는 주어진 두 점 사이에서 adaptive Gauss-Kronrod 알고리즘을 이용해 함수의 적분을 계산한다. 이 GSL 함수의 이름은 gsl_integration_qag이다. 이번 예제는 함수 포인터, 하스 켈 함수를 C 루틴으로 익스포트하는 방법, 열거형, 알려지지 않은 구조체에 대한 포인터를 다루는 방법을 설명한다. 이용 가능한 C 함수와 구조체 GSL이 주어진 함수를 qag으로 적분하려면 세 함수가 필요하다. gsl_integration_workspace * gsl_integration_workspace_alloc (size_t n); void gsl_integration_workspace_free (gsl_integration_workspace * w); int gsl_integration_qag (const gsl_function * f, double a, double b, double epsabs, double epsrel, size_t limit, int key, gsl_integration_workspace * workspace, double * result, double * abserr); 처음 두 함수는 우리가 모르는 "작업장" 구조체의 할당과 해제를 담당한다. 우리는 포인터만 넘길 뿐이다. 실제 일은 마지막 함수가 하는데, 이 함수는 작업장에 대한 포인터를 요구한다. GSL은 이 함수들을 제공하기 위한 C 구조체를 명시한다. struct gsl_function { double (* function) (double x, void * params); void * params; }; void 포인터인 이유는 λ 함수를 C에서 정의할 수 없어서다. 매개변수들은 미지의 타입을 가진 매개변수와 함께 전달된다. 하스켈에서는 params가 필요 없기 때문에 앞으로 쭉 무시하겠다. import와 inclusion qag.hsc 파일은 이렇게 시작한다. {-# LANGUAGE ForeignFunctionInterface, EmptyDataDecls #-} module Qag ( qag, gauss15, gauss21, gauss31, gauss41, gauss51, gauss61 ) where import Foreign import Foreign.Ptr import Foreign.C.Types import Foreign.C.String #include <gsl/gsl_math.h> #include <gsl/gsl_integration.h> foreign import ccall unsafe "gsl/gsl_errno.h gsl_strerror" c_error_string :: CInt -> IO CString foreign import ccall unsafe "gsl/gsl_errno.h gsl_set_error_handler_off" c_deactivate_gsl_error_handler :: IO () 여기서 선언한 EmptyDataDecls pragma는 나중에 Workspace 데이터 타입에 사용할 것이다. 이 파일은 바깥세상에 보여서는 안 될 함수를 많이 포함할 것이기 때문에 모듈로 선언하고 최종 함수인 qag와 gauss 플래그들만 내보낸다. 그리고 GSL의 관련 있는 C 헤더들을 포함시킨다. 에러 메시지 처리와 에러 핸들러의 비활성화를 위해 C 함수들을 들여오는 것은 앞에서 설명했다. 열거형 gsl_integration_qag의 인자들 중 하나인 key는 1에서 6까지의 값을 가지는 정수로서 적분 규칙을 지시한다. GSL은 각각의 값마다 매크로를 정의하지만 하스켈에서는 타입을 하나 정의하는 것이 더 자연스럽다. 이 타입을 IntegrationRule이라고 하자. IntegrationRule의 값들을 hsc2hs가 자동으로 생성하도록 enum 매크로를 사용한다. newtype IntegrationRule = IntegrationRule { rule :: CInt } #{enum IntegrationRule, IntegrationRule, gauss15 = GSL_INTEG_GAUSS15, gauss21 = GSL_INTEG_GAUSS21, gauss31 = GSL_INTEG_GAUSS31, gauss41 = GSL_INTEG_GAUSS41, gauss51 = GSL_INTEG_GAUSS51, gauss61 = GSL_INTEG_GAUSS61 } hsc2hs는 매크로를 위한 헤더들을 검색하고 알맞은 값을 할당한다. enum 지시문은 각 enum 값마다 알맞은 타입 명세가 붙은 함수를 정의한다. 위 예제는 아래와 같은 식으로 번역된다. (C 매크로는 해당하는 값으로 치환된다) newtype IntegrationRule = IntegrationRule { rule :: CInt } gauss15 :: IntegrationRule gauss15 = IntegrationRule GSL_INTEG_GAUSS15 gauss21 :: IntegrationRule gauss21 = IntegrationRule GSL_INTEG_GAUSS21 ... 이 변수들은 수정될 수 없고 본질적으로 상수 플래그다. 모듈 선언에서 IntegrationRule의 생성자는 빼고 gauss 플래그들만 내보내기 때문에 사용자가 잘못된 값을 만드는 것 자체가 불가능하다. 걱정거리가 하나 줄어든 셈이다! Haskell Function Target 이제 우리가 원하는 함수의 명세를 작성할 수 있다. qag :: IntegrationRule -- Algorithm type -> Int -- Step limit -> Double -- Absolute tolerance -> Double -- Relative tolerance -> (Double -> Double) -- Function to integrate -> Double -- Integration interval start -> Double -- Integration interval end -> Either String (Double, Double) -- Result and (absolute) error estimate 인자들의 순서가 C 버전과 다른 것에 주목하라. 사실 C에는 부분 적용(partial application)이 없기 때문에 하스켈에서는 순서 배치가 다른 것이다. 이전 예제와 마찬가지로 에러를 Either String (Double, Double) 결괏값으로 나타낸다. 하스 켈 함수를 C 알고리즘에 전달하기 type CFunction = CDouble -> Ptr () -> CDouble data GslFunction = GslFunction (FunPtr CFunction) (Ptr ()) instance Storable GslFunction where sizeOf _ = (#size gsl_function) alignment _ = alignment (undefined :: Ptr ()) peek ptr = do function <- (#peek gsl_function, function) ptr return $ GslFunction function nullPtr poke ptr (GslFunction fun nullPtr) = do (#poke gsl_function, function) ptr fun makeCfunction :: (Double -> Double) -> (CDouble -> Ptr () -> CDouble) makeCfunction f = \x voidpointer -> realToFrac $ f (realToFrac x) foreign import ccall "wrapper" makeFunPtr :: CFunction -> IO (FunPtr CFunction) 가독성을 위해 축약 타입 CFunction을 정의한다. void 포인터는 Ptr ()으로 바뀌었는데, 사용하지 않을 것이기 때문이다. 다음은 gsl_function 구조체 차례다. 놀랄 만한 것은 없다. void 포인터는 peek에서도 poke에서도 null이라고 가정하고, 읽기도 쓰기도 하지 않는다. 하스 켈 Double -> Double 함수를 C 알고리즘에서 쓸 수 있게 만들려면 두 단계를 거친다. 첫 번째, makeCfunction 안에서 λ 함수를 이용해 인자들을 재구성한다. 그다음 makeFunPtr에서 함수를 재정렬된 인자들과 함께 받아서, poke에 전달할 수 있는 함수 포인터를 만들어낸다. 이로써 GslFunction 자료구조를 구축할 수 있게 된다. 미지의 구조체 다루기 data Workspace foreign import ccall unsafe "gsl/gsl_integration.h gsl_integration_workspace_alloc" c_qag_alloc :: CSize -> IO (Ptr Workspace) foreign import ccall unsafe "gsl/gsl_integration.h gsl_integration_workspace_free" c_qag_free :: Ptr Workspace -> IO () foreign import ccall safe "gsl/gsl_integration.h gsl_integration_qag" c_qag :: Ptr GslFunction -- Allocated GSL function structure -> CDouble -- Start interval -> CDouble -- End interval -> CDouble -- Absolute tolerance -> CDouble -- Relative tolerance -> CSize -- Maximum number of subintervals -> CInt -- Type of Gauss-Kronrod rule -> Ptr Workspace -- GSL integration workspace -> Ptr CDouble -- Result -> Ptr CDouble -- Computation error -> IO CInt -- Exit code EmptyDataDecls pragma를 들여오는 이유는 다음과 같다. 우리는 Workspace 자료구조를 생성자 없이 선언했다. 이는 Workspace가 항상 포인터로서 다루어지고 절대 인스턴스화되지 않게 하기 위한 방편이었다. 그렇지 않으면 우리는 보통 할당, 해제 루틴을 들여온다. 이제 모든 조각(GslFunction과 Workspace)을 갖추었으니 적분 함수를 들여올 수 있다. 완성된 함수 이제 GSL의 QAG 알고리즘과 동일한 기능을 하는 함수를 구현할 수 있다. qag gauss steps abstol reltol f a b = unsafePerformIO $ do c_deactivate_gsl_error_handler workspacePtr <- c_qag_alloc (fromIntegral steps) if workspacePtr == nullPtr then return $ Left "GSL could not allocate workspace" else do fPtr <- makeFunPtr $ makeCfunction f alloca $ \gsl_f -> do poke gsl_f (GslFunction fPtr nullPtr) alloca $ \resultPtr -> do alloca $ \errorPtr -> do status <- c_qag gsl_f (realToFrac a) (realToFrac b) (realToFrac abstol) (realToFrac reltol) (fromIntegral steps) (rule gauss) workspacePtr resultPtr errorPtr c_qag_free workspacePtr freeHaskellFunPtr fPtr if status /= 0 then do c_errormsg <- c_error_string status errormsg <- peekCString c_errormsg return $ Left errormsg else do c_result <- peek resultPtr c_error <- peek errorPtr let result = realToFrac c_result let error = realToFrac c_error return $ Right (result, error) 무엇보다 먼저 GSL 오류 처리자를 비활성화한다. 오류를 보고하는 대신 프로그램을 죽이기 때문이다. 그다음 작업장을 할당한다. 반환된 포인터가 null이면 보고해야 하는 (보통은 크기가 너무 크다는) 오류가 있었다는 뜻이다. 작업장을 잘 할당했으면 주어진 함수를 함수 포인터로 변환하고 GslFunction 구조체를 할당한다. 여기에 함수 포인터를 넣는다. 메인 루틴 호출 전에 마지막 준비로 결괏값과 그 오차 범위를 위한 메모리를 할당한다. 호출 후에는 일종의 정리 정돈을 하고 작업장과 함수 포인터에 할당한 메모리를 해제해야 한다. ForeignPtr을 이용해 정리 정돈을 건너뛸 수도 있지만, 제대로 작동하게 만드는 데 필요한 작업은 클린업 한 줄을 기억하는 노고 이상의 가치가 있는 것이다. 그다음 반환 값을 확인하고 결과를 반환한다. Bessel 함수에서 했던 것과 같다. 스스로 해제하는 포인터 앞의 예제에서 GSL 적분에 필요한 작업장(우리는 모르는 자료구조)의 해제를 C 할당 해제 함수를 직접 호출해서 처리했다. 하스 켈로 들여오려고 하는 여러 적분 루틴이 같은 작업장을 사용한다면 어떻게 할까? 같은 할당/해제 코드를 매번 복제하면 누군가 해제를 깜빡했을 때 메모리 누수가 일어난다. 여기에 더 이상 필요 없으면 스스로 메모리를 해제하는 일종의 "스마트 포인터"를 도입할 수 있다. 이것을 ForeignPtr이라고 부른다. (Foreign.Ptr과 헷갈리지 말 것. 사실 이것의 한정 이름(qualified name)은 Foreign.ForeignPtr이다) 해제를 처리하는 함수는 finalizer라고 부른다. 이 절에서는 GSL 작업장을 할당하고 ForeignPtr로 적절히 꾸미는 간단한 모듈을 작성하여, 사용자들이 할당 해제를 걱정할 필요를 없앨 것이다. 이 모듈은 GSLWorkspace.hs 파일에 다음과 같이 작성된다. {-# LANGUAGE ForeignFunctionInterface, EmptyDataDecls #-} module GSLWorkSpace (Workspace, createWorkspace) where import Foreign.C.Types import Foreign.Ptr import Foreign.ForeignPtr data Workspace foreign import ccall unsafe "gsl/gsl_integration.h gsl_integration_workspace_alloc" c_ws_alloc :: CSize -> IO (Ptr Workspace) foreign import ccall unsafe "gsl/gsl_integration.h &gsl_integration_workspace_free" c_ws_free :: FunPtr( Ptr Workspace -> IO () ) createWorkspace :: CSize -> IO (Maybe (ForeignPtr Workspace) ) createWorkspace size = do ptr <- c_ws_alloc size if ptr /= nullPtr then do foreignPtr <- newForeignPtr c_ws_free ptr return $ Just foreignPtr else return Nothing 첫 번째로 앞 절과 마찬가지로 빈 자료 구조 Workspace를 선언한다. gsl_integration_workspace_alloc과 gsl_integration_workspace_free 함수는 다른 파일에서 더 이상 필요하지 않다. 할당 해제 함수는 앰퍼샌드(&)와 함께 호출하는 것에 주의. finalizer로 지정하려면 함수 자체가 아니라 함수에 대한 포인터가 필요하기 때문이다. 작업장 생성 함수는 IO (Maybe) 값을 반환한다. 할당이 실패하고 null 포인터가 반환될 가능성이 여전히 있기 때문이다. GSL은 null 포인터에 대해 할당 해제 함수를 호출할 때 무슨 일이 일어날지 명시하지 않는다. 그러니 안전을 위해 이 경우 finalizer를 지정하지 않고 IO Nothing을 반환한다. 사용자 코드는 반환 값이 Just 인지를 확인해야 한다. 할당 함수가 반환한 포인터가 null이 아니면 할당 해제 함수를 가지고 외부 포인터를 제작하여 Maybe에 넣고, 그것을 다시 IO 모나드에 넣는다. 이게 끝이다. 이제 이 외부 포인터를 쓸 수 있다. 이 함수는 컴파일된 목적 코드를 요구한다. GHCi에서 이 모듈을 로드할 때 다음과 같이 지시해야 한다. $ ghci GSLWorkspace.hs -fobject-code 또는 GHCi 안에서 :set -fobject-code :load GSLWorkspace.hs qag.hsc 파일이 새로운 모듈을 사용하도록 고쳐야 한다. 바뀐 부분은 다음과 같다. {-# LANGUAGE ForeignFunctionInterface #-} -- [...] import GSLWorkSpace import Data.Maybe(isNothing, fromJust) -- [...] qag gauss steps abstol reltol f a b = unsafePerformIO $ do c_deactivate_gsl_error_handler ws <- createWorkspace (fromIntegral steps) if isNothing ws then return $ Left "GSL could not allocate workspace" else do withForeignPtr (fromJust ws) $ \workspacePtr -> do -- [...] 확실히 EmptyDataDecls 확장은 더 이상 필요 없다. 대신 GSLWorkSpace 모듈 그리고 Data.Maybe에서 유용한 함수 몇 개를 들여온다. 작업장 할당과 해제 함수의 외부 선언도 제거한다. 가장 중요한 차이점은 메인 함수에 있다. 작업장 ws를 할당하고, Just 여부를 확인하고, 모든 것이 정상이면 withForeignPtr 함수를 써서 작업장 포인터를 추출한다. 다른 것은 모두 동일하다. C에서 하스 켈 호출하기 지연 평가처럼 C로 구현하기는 지리멸렬한 것들을 하스 켈로 처리하기 위해, C에서 하스켈을 호출하는 것이 편리할 때도 있다. 고전적인 하스 켈 예제인 피보나치 수를 생각해 보자. 우아하고 하스켈스러운 한 줄 함수로 구현된다. fibonacci = 0 : 1 : zipWith (+) fibonacci (tail fibonacci) 우리가 할 일은 하스켈의 피보나치 수를 계산 능력을 C로 내보내는 것이다. 하스켈에선 보통 유계 없는 Integer 타입을 사용한다. C에는 이에 대응하는 타입이 없어서 Integer를 내보낼 수 없다. 더 넓은 범위의 출력을 제공하기 위해 C 함수가 정수 타입의 범위를 넘어서는 결과를 만들어야 할 때 부동소수점 근사치를 제공하기로 한다. 결과가 부동소수점 범위마저 넘어서면 계산은 실패한다. 결과의 상태(C 정수나 부동소수점으로 표현 가능한지, 아예 불가능한지)는 함수가 반환하는 상태 정수로 나타낸다. 따라서 이 함수의 명세는 다음과 같다. int fib( int index, unsigned long long* result, double* approx) 하스 켈 소스 fibonacci.hs 파일의 하스 켈 소스 코드는 다음과 같다. {-# LANGUAGE ForeignFunctionInterface #-} module Fibonacci where import Foreign import Foreign.C.Types fibonacci :: (Integral a) => [a] fibonacci = 0 : 1 : zipWith (+) fibonacci (tail fibonacci) foreign export ccall fibonacci_c :: CInt -> Ptr CULLong -> Ptr CDouble -> IO CInt fibonacci_c :: CInt -> Ptr CULLong -> Ptr CDouble -> IO CInt fibonacci_c n intPtr dblPtr | badInt && badDouble = return 2 | badInt = do poke dblPtr dbl_result return 1 | otherwise = do poke intPtr (fromIntegral result) poke dblPtr dbl_result return 0 where result = fibonacci !! (fromIntegral n) dbl_result = realToFrac result badInt = result > toInteger (maxBound :: CULLong) badDouble = isInfinite dbl_result 내보낼 때 함수들을 모듈로 감싸야 한다. (이것은 어쨌든 좋은 습관이다) 피보나치 무한 리스트는 이미 봤으니 내보내는 함수에 집중하자. 이 함수는 인자 하나, unsigned long long과 double에 대한 포인터를 취하고 상태 값을 IO 모나드로 감싸 반환한다. (포인터에 값을 쓰는 것은 부수효과이기 때문) 함수는 input guard로 구현되고 맨 밑에의 where 절에서 정의된다. 성공적인 계산은 0을 반환하고 부분적인 성공은 1을 반환한다. 이 경우 부동소수점 값을 근삿값으로 쓸 수 있다. 완전히 실패하면 2를 반환한다. 이 함수는 alloca를 호출하지 않는다. 포인터들이 이미 호출자 C 함수에서 할당되었다고 가정하기 때문이다. 이 하스 켈 코드를 GHC로 컴파일할 수 있다. ghc -c fibonacci.hs C 소스 fibonacci.hs를 컴파일하면 몇 가지 파일이 생성된다. 그중 fibonacci_stub.h가 있는데, fib.c에서 포함시킨다. #include <stdio.h> #include <stdlib.h> #include "fibonacci_stub.h" int main(int argc, char *argv[]) { if (argc < 2) { printf("Usage: %s <number>\n", argv[0]); return 2; } hs_init(&argc, &argv); const int arg = atoi(argv[1]); unsigned long long res; double approx; const int status = fibonacci_c(arg, &res, &approx); hs_exit(); switch (status) { case 0: printf("F_%d: %llu\n", arg, res); break; case 1: printf("Error: result is out of bounds\n"); printf("Floating-point approximation: %e\n", approx); break; case 2: printf("Error: result is out of bounds\n"); printf("Floating-point approximation is infinite\n"); break; default: printf("Unknown error: %d\n", status); } return status; } 주목할 것은 하스 켈 환경을 hs_init에 메인 함수의 명령 줄 인자를 전달하며 초기화하는 부분이다. 그리고 일이 끝나면 hs_exit()로 하스켈을 종료한다. 나머지는 할당과 오류 처리를 위한 통상적인 C 코드다. 이 C 코드는 C 컴파일러가 아니라 GHC로 컴파일해야 한다. ghc -no-hs-main fib.c fibonacci.o -o fib 이제 이 알고리즘을 테스트해 볼 수 있다. ./fib 42 F_42: 267914296 $ ./fib 666 Error: result is out of bounds Floating-point approximation: 6.859357e+138 $ ./fib 1492 Error: result is out of bounds Floating-point approximation is infinite ./fib -1 fib: Prelude.(!!): negative index 5 제네릭 프로그래밍: 정형화된 코드는 그만 원문: https://en.wikibooks.org/wiki/Haskell/SYB TODO 원문이 미완성 1에서 설명하는 "Scrap your boilerplate" 접근법은 여러분의 자료구조를 소위 "제네릭" 함수가 순회할 수 있게 만드는 방법이다. 제네릭 함수라 함은 생성 또는 변경되는 특정 데이터 생성자들에 대해 추상화하면서 특정 타입에 대한 예외사항을 추가할 수 있다. 원문이 이해가 안 됨... The "Scrap your boilerplate" approach, "described" in [1], is a way to allow your data structures to be traversed by so-called "generic" functions: that is, functions that abstract over the specific data constructors being created or modified, while allowing for the addition of cases for specific types. 예를 들면 코드의 모든 구조체를 직렬화 하고 싶지만 Data.Data.Data 클래스의 모든 인스턴스(-XDeriveDataTypeable로 파생시킬 수 있음)에 대해 작동하는 단 하나의 직렬화 함수만 작성하고 싶을 수 있다. 직렬화 예시 목표는 모든 데이터를 다음<NAME>으로 변환하는 것이다. data Tag = Con String | Val String 하스 켈 AST들의 비교 haskell-src-exts 패키지는 하스켈을 꽤나 복잡한 구문 트리로 파싱 한다. 거의 동일한 두 소스 파일이 동등한지 확인한다고 치자. 출발점: import System.Environment import Language.Haskell.Exts main = do -- parse the filenames given by the first two command line arguments, -- proper error handling is left as an exercise [ParseOk moduleA, ParseOk moduleB] <- mapM parseFile . take 2 =<< getArgs putStrLn $ if moduleA == moduleB then "Your modules are equal" else "Your modules differ" 테스트를 조금 해보면 이름만 다르고 나머지는 동일한 두 파일은 같지(==) 않다. 하지만 사실을 정정하면 많은 보일러 플레이트에 의존하지 않아도 제네릭 프로그래밍을 활용할 수 있다. From a bit of testing, it will be apparent that identical files with different names will not be equal to (==). However, to correct the fact, without resorting to lots of boilerplate, we can use generic programming: TODO describe using Data.Generics.Twins.gzip*? to write a function to find where there are differences? Or use it to write a variant of geq that ignores the specific cases that are unimportant (the SrcLoc elements) (i.e. syb doesn't allow generic extension... contrast it with other libraries?). Or just explain this hack (which worked well enough) to run before (==), or geq:: everyWhere (mkT $ \ _ -> SrcLoc "" 0 0) :: Data a => a -> a Or can we develop this into writing something better than sim_mira (for hs code), found here: http://dickgrune.com/Programs/similarity_tester/ 3 특수 작업 특수 작업 그래픽 유저 인터페이스 (GUI) 데이터베이스 XML 다루기 수학식의 파싱 기초적인 타입 검사기의 작성 원문 없음 1 GUI (검토 중) 원문: https://en.wikibooks.org/wiki/Haskell/GUI TODO 원문이 미완성 wxHaskell의 설치 및 실행 Debian과 Ubuntu를 위한 지름길 Hello World 컨트롤 텍스트 레이블 버튼 레이아웃 속성 속성 설정 및 수정 속성을 찾는 방법 이벤트 하스켈에는 그래픽 인터페이스를 프로그래밍하기 위한 툴킷이 적어도 4개가 있다. wxHaskell - Windows, OS X 및 GNU/Linux Gtk+ 등을 지원하는 크로스 플랫폼 wxWidgets 툴킷의 하스 켈 인터페이스 Gtk2Hs - GTK+ 라이브러리의 하스 켈 인터페이스 hoc (문서화는 sourceforge에) - MacOS X의 Cocoa 라이브러리에 접근할 수 있게 해주는 하스 켈 to Objective-C 바인딩 qtHaskell - Qt Widget 라이브러리를 위한 하스 켈 바인딩 wxHaskell의 설치 및 실행 wxHaskell을 설치하려면 GNU/Linux, Mac, Windows 중 맞는 버전의 지침을 볼 것. 아니면 wxHaskell 다운로드 페이지가 제공하는 설치 지침을 따라가면 된다. wxHaskell을 GHC에 등록하지 않으면 실행되지 않는 것을 기억하라. (Cabal이 자동으로 등록한다) wxHaskell 코드를 이용하는 source.hs를 컴파일하려면 커맨드 라인을 열어 다음을 입력한다. ghc -package wx source.hs -o bin GHCi의 경우도 코드는 비슷하다. ghci -package wx 이러면 GHCi 인터페이스 안에서 파일들을 로드할 수 있다. 전부 잘 작동하는지 테스트하려면 $wxHaskellDir/samples/wx로 가서 ($wxHaskellDir는 여러분이 wxHaskell을 설치한 디렉터리다) HelloWorld.hs를 로드하거나 컴파일해 보면 된다. 타이틀은 "Hello World!", File과 About을 포함하는 메뉴 바, 밑에는 "Welcome to wxHaskell"이라 써진 상태 창을 포함하는 창을 하나 띄울 것이다. 작동하지 않으면 $wxHaskellDir/lib의 내용물을 ghc 설치 디렉터리로 복사해 볼 것. Debian과 Ubuntu를 위한 지름길 여러분의 운영체제가 데비안 또는 우분투라면 터미널에서 다음 명령을 실행하면 된다. sudo apt-get install g++ sudo apt-get install libglu-dev sudo apt-get install libwxgtk2.8-dev Hello World 다음은 기본적인 "Hello World" 하스 켈 프로그램이다. module Main where main :: IO () main = putStr "Hello World!" 이 프로그램은 문제없이 컴파일되지만 여기서 GUI가 작동하게 만들려면 어떻게 해야 할까? 첫 번째로 할 일은 wxHaskell 라이브러리의 Graphics.UI.WX를 임포트 하는 것이다. Graphics.UI.WXCore에 좀 더 많은 것이 있지만 지금은 필요하지 않다. GUI를 시작하려면 start gui를 사용한다. 이 경우 gui는 인터페이스를 구축하기 위해 사용할 함수 이름이다. 이 함수는 IO 타입을 가져야 한다. module Main where import Graphics.UI.WX main :: IO () main = start gui gui :: IO () gui = do --GUI stuff 프레임을 만들려면 타입이 [Prop (Frame ())] -> IO (Frame ())인 frame 함수를 사용한다. frame은 "프레임 요소들"의 리스트를 받아서 이에 대응하는 프레임을 반환한다. 나중에 자세히 살펴보겠지만 요소(property)는 대개 속성(attribute)과 값(value)의 조합이다. 여기서 우리가 관심 있는 것은 타이틀이다. 타이틀은 text 속성 안에 있고 그 타입은 (Textual w) => Attr w String이다. 이것이 String 속성이라는 게 가장 중요하다. 다음 코드를 보자. gui :: IO (Frame ()) gui = do frame [text := "Hello World!"] (:=) 연산자는 속성과 값을 받아 요소로 결합한다. frame이 IO (Frame ())을 반환하는 것에 주목하라. start 함수의 타입은 IO a -> IO ()이다. gui의 타입을 IO (Frame ())로 바꿀 수도 있지만 단순히 return ()을 추가하는 게 더 나을 것이다. 이제 타이틀이 "Hello World!"인 프레임으로 구성된 GUI를 가지게 되었다. 완전한 코드는 다음과 같다. module Main where import Graphics.UI.WX main :: IO () main = start gui gui :: IO () gui = do frame [text := "Hello World!"] return () 결과물은 이 스크린숏처럼 보일 것이다. (리눅스나 MacOS X에서는 조금 다르게 보일 것이다.) 컨트롤 여기서부터는 wxHaskell 문서를 같이 열어두는 것이 좋다. 이 문서는 $wxHaskellDir/doc/index.html에서도 볼 수 있다. 텍스트 레이블 단순한 프레임은 별일을 하지 않는다. 이 절에서는 더 많은 요소를 추가할 것이다. 간단하게 레이블부터 시작하자. wxHaskell에는 label이 있지만 이것은 레이아웃에 관한 것이다. 레이아웃은 다음 절에서나 다룬다. 지금 찾는 것은 staticText로서 Graphics.UI.WX.Controls에 들어있다. staticText 함수는 Window 및 일련의 요소를 인자로 취한다. 우리에게 윈도가 있나? 있다. Graphics.UI.WX.Frame을 보면 Frame이 그저 특별한 종류의 윈도에 대한 타입 동의어인 것을 볼 수 있다. gui 코드를 조금 바꿔서 이렇게 만들겠다. gui :: IO () gui = do f <- frame [text := "Hello World!"] staticText f [text := "Hello StaticText!"] return () staticText 객체도 text 속성을 가진다. 한번 시도해 보자. Hello StaticText! (winXP) 버튼 상호작용을 추가해 보자. 이번에는 버튼이다. 버튼의 기능은 이벤트에 대한 절에서 추가할 것이지만 지금도 버튼을 누르면 눈에 보이는 무언가가 일어날 것이다. button은 staticText처럼 컨트롤의 일종이다. Graphics.UI.WX.Controls에 들어있다. 이번에도 윈도와 요소들의 목록이 필요하다. 프레임을 다시 사용하겠다. 버튼도 text 속성을 가진다. gui :: IO () gui = do f <- frame [text := "Hello World!"] staticText f [text := "Hello StaticText!"] button f [text := "Hello Button!"] return () 버튼과 StaticText의 겹침 (winXP) GHCi로 로드해 보면 (또는 GHC로 컴파일해 보면) 이게 뭐람? 레이블이 버튼을 덮고 있다. 고쳐보자. 레이아웃 레이블과 버튼이 겹치는 이유는 우리가 프레임에 레이아웃을 지정하지 않았기 때문이다. 레이아웃을 만드는데 사용하는 함수들은 Graphics.UI.WXCore.Layout의 문서에서 찾을 수 있다. 레이아웃을 사용하기 위해 Graphics.UI.WXCore를 임포트 할 필요는 없다. 문서에는 widget 함수를 이용해서 위젯 클래스의 멤버를 레이아웃으로 변환할 수 있다고 쓰여있다. 마침 윈도는 위젯 클래스의 멤버다. 그런데 잠깐, 우리에겐 윈도가 프레임밖에 없지 않나? 아니다. Graphics.UI.WX.Controls에서 Control이라고 적혀있는 것을 하나 눌러보라. Graphics.UI.WXCore.WxcClassTypes로 이동할 텐데, 여기서 컨트롤이 윈도의 특화된 타입에 대한 타입 동의어라는 걸 알 수 있다. 코드는 조금 바꿔야 한다. gui :: IO () gui = do f <- frame [text := "Hello World!"] st <- staticText f [text := "Hello StaticText!"] b <- button f [text := "Hello Button!"] return () 이제 widget st와 widget b를 이용해서 staticText와 button의 레이아웃을 만들 수 있다. layout은 프레임의 속성이므로 거기서 설정한다. gui :: IO () gui = do f <- frame [text := "Hello World!"] st <- staticText f [text := "Hello StaticText!"] b <- button f [text := "Hello Button!"] set f [layout := widget st] return () 레이아웃을 지정한 StaticText (winXP) set 함수는 나중에 속성에 관한 절에서 다룰 것이다. 이 코드를 실행해 보자. 뭐가 잘못됐는지 이번에는 staticText만 보이고 button은 보이지 않는다. 이 둘을 묶을 방법이 필요한데, 이를 위해 레이아웃 합성자를 사용할 것이다. row와 column이 적절해 보인다. 이 함수들은 정수와 레이아웃 목록을 취한다. button과 staticText의 레이아웃들의 목록은 쉽게 만들 수 있다. 정수는 리스트 원소 간 간격을 지정한다. 한번 해보자. gui :: IO () gui = do f <- frame [text := "Hello World!"] st <- staticText f [text := "Hello StaticText!"] b <- button f [text := "Hello Button!"] set f [layout := row 0 [widget st, widget b] ] return () 행 레이아웃 (winXP) 정숫값을 조정하거나 row를 column으로 바꿔보자. 원소들의 순서도 바꿔봐서 어떻게 작동하는 건지 감을 잡아보자. 리스트에 widget b를 몇 번 더 넣어보면 무슨 일이 일어날까? 여기 여러분의 상상력에 불을 지피기 위한 연습문제들이 있다. 문서를 활용하자. 연습문제 체크박스 컨트롤을 추가한다. 아무 작동도 하지 않아도 된다. 행 레이아웃을 사용할 때는 staticText와 button 다음에 보이거나 열 레이아웃의 경우 그 밑에 보이기만 하면 된다. 체크박스도 text 속성을 가진다. row와 column은 레이아웃들의 리스트를 취해서 레이아웃을 하나 생성한다. 이 사실을 활용해 체크박스가 staticText와 button의 왼쪽에 나타나며 staticText와 button은 한 열이 되도록 하라. 라디오박스 컨트롤이 어떻게 작동하는지 알아낼 수 있겠는가? 이전 연습문제의 레이아웃을 기반으로 checkbox, staticText, button의 밑에 옵션이 두 개(또는 그 이상)인 라디오박스를 추가하라. 문서를 볼 것! boxed 합성자를 사용해서 네 컨트롤을 감싸는 보더와 staticText, button을 감싸는 또 다른 보더를 생성하라. (노트: boxed 합성 자는 MacOS X에서는 작동하지 않을 수도 있다. 위젯의 상호작용이 불가능할 수 있다. 이는 wsHaskell의 버그로 보인다.) 이 연습문제들을 완료한 결과는 다음과 같다. 연습문제들의 해답 속성 이제 이런 의문이 들 것이다. "set 함수는 어디서 튀어나온 걸까?" 그리고 "text가 무언가의 속성인지 어떻게 알아낼 것인가?" 둘 다 그 해답은 wxHaskell의 속성 시스템에 있다. 속성 설정 및 수정 wxHaskell 프로그램에서 위젯의 속성들을 설정하는 방법은 두 가지다. 생성할 때: f <- frame [ text := "Hello World!" ] set 함수 이용: set f [ layout := widget st ] set 함수는 두 인자를 취한다. 하나는 w 타입의 무언가이고 다른 하나는 w의 속성들이다. wxHaskell에서 이 인자들은 위젯과 그 위젯의 속성들이다. alignment나 textEntry처럼 생성할 때만 설정할 수 있는 속성들이 있지만 다른 것들은 대부분 프로그램의 어떤 IO 함수에서든 그 속성에 대한 참조(set f [stuff]의 f)만 있다면 설정이 가능하다. 속성은 설정뿐 아니라 획득도 가능하다. 획득은 get 함수로 한다. gui :: IO () gui = do f <- frame [ text := "Hello World!" ] st <- staticText f [] ftext <- get f text set st [ text := ftext] set f [ text := ftext ++ " And hello again!" ] get의 타입 시그너쳐는 w -> Attr w a -> IO a이다. text는 String 속성이므로 우리는 IO String을 얻어서 ftext에 바인드 할 수 있다. 마지막 줄은 프레임의 텍스트를 수정한다. wxHaskell에서는 파괴적 갱신이 가능하다. set과 (:=)을 사용하면 언제든지 속성을 덮어쓸 수 있다. 따라서 modify 함수를 이렇게 작성할 수 있다. modify :: w -> Attr w a -> (a -> a) -> IO () modify w attr f = do val <- get w attr set w [ attr := f val ] modify는 먼저 값을 얻어 함수를 적용한 후 다시 설정한다. 분명히 우리가 이런 생각을 처음으로 한 것은 아니다. (:~)라는 연산자를 보자. (:~)는 속성과 함수를 취하기 때문에 set 안에서 사용할 수 있다. 그 결과는 원본 값이 함수에 의해 수정된 한 요소다. 따라서 이렇게 작성할 수 있다. gui :: IO () gui = do f <- frame [ text := "Hello World!" ] st <- staticText f [] ftext <- get f text set st [ text := ftext ] set f [ text :~ ++ " And hello again!" ] 람다 표기를 통해 익명 함수를 사용하기 좋은 상황이다. 요소를 설정 또는 수정하는 데 사용할 수 있는 연산자가 두 개 더 있다. (::=)와 (::~)이다. 이것들은 (:=), (:~)와 거의 같지만 w -> orig 타입의 함수를 받는 점이 다르다. w는 위젯 타입이고 orig는 원래의 "값" 타입이다. ((:=)의 경우 a이고 (:~)의 경우 a -> a) 아직은 IO 타입이 아닌 속성들만 봤고 이 함수들에 필요한 위젯들은 대개 IO 블록 안에서만 유용하기 때문에 이것들은 지금 사용하지 않을 것이다. 속성을 찾는 방법 두 번째 질문의 차례다. text가 모든 컨트롤의 속성이라는 것을 어떻게 판단할까? 문서를 본다. 버튼이 무슨 속성들을 가지는지 보자. Graphics.UI.WX.Controls 이 링크를 누르면 "Button"이 나온다. Button이 Control의 한 종류에 대한 타입 동의어라는 것과 버튼을 생성하는 데 사용할 수 있는 함수들의 목록을 볼 수 있다. 함수마다 "인스턴스" 목록이 있다. 일반적인 button 함수의 경우 Commanding -- Textual, Literate, Dimensions, Colored, Visible, Child, Able, Tipped, Identity, Styled, Reactive, Paint를 볼 수 있는데 이는 버튼이 이 클래스들의 인스턴스임을 뜻한다. 클래스와 타입 장을 읽어볼 것. 이는 이 버튼에서 사용할 수 있는 클래스 특화 함수들이 있다는 뜻이다. 예를 들어 Textual은 text 함수와 appendText 함수를 추가한다. 어떤 위젯이 Textual 클래스의 인스턴스 면 그 위젯이 text 속성을 가진다는 뜻이다. StaticText에는 인스턴스 목록이 없지만 StaticText는 여전히 Control이며, Control은 Window의 특정 유형에 대한 타입 동의어다. Textual 클래스를 보면 Window가 Textual의 인스턴스라고 쓰여있다. 문서에 오류가 조금 있다. 프레임의 속성들은 Graphics.UI.WX.Frame에 있다. 이번에도 문서에 오류가 있는데, Frame이 HasImage를 인스턴스화한다고 쓰여있다. wxHaskell의 구 버전에서는 맞는 말이지만 지금은 HasImage가 Pictured로 바뀌었다. 이외에도 Form, Textual, Dimensions, Colored, Able 등이 있다. Textual과 Form은 이미 봤다. Form의 인스턴스는 모두 layout 속성을 가진다. Dimensions는 clientSize 속성을 포함해 여러 가지를 추가한다. 이 속성의 타입은 Size로서 sz를 통해 만들 수 있다. layout 속성은 크기도 변경할 수 있다는 것에 주목할 것. clientSize를 사용하려면 layout 이후에 설정해야 한다. Colored는 color와 bgcolor 속성을 추가한다. Able은 enabled라는 불리언 속성을 추가한다. 이것은 특정 폼 요소를 활성화 또는 비활성화하는데 사용되며, 비활성화된 요소는 대개 회색으로 표시된다. 이 밖에도 많은 속성이 있으니 클래스마다 문서를 읽어볼 것. 이벤트 특별히 주목할 만한 클래스가 몇 개 있다. 바로 Reactive 클래스와 Commanding 클래스다. 이 클래스들의 문서를 보면 속성(Attr w a 꼴)이 아니라 이벤트를 추가한다. Commanding 클래스는 command 이벤트를 추가한다. 이벤트 처리를 설명하기 위해 버튼을 이용하겠다. 다음은 button과 staticText가 있는 간단한 GUI다. gui :: IO () gui = do f <- frame [ text := "Event Handling" ] st <- staticText f [ text := "You haven\'t clicked the button yet." ] b <- button f [ text := "Click me!" ] set f [ layout := column 25 [ widget st, widget b ] ] 이전 상태 (winXP) button을 누르면 staticText를 변경하고자 한다. on 함수가 필요하다. b <- button f [ text := "Click me!" , on command := --stuff ] on의 타입은 Event w a -> Attr w a이다. command의 타입은 Event w (IO ())이므로 IO 함수가 필요하다. 이 함수는 이벤트 핸들러라고 부른다. gui :: IO () gui = do f <- frame [ text := "Event Handling" ] st <- staticText f [ text := "You haven\'t clicked the button yet." ] b <- button f [ text := "Click me!" , on command := set st [ text := "You have clicked the button!" ] ] set f [ layout := column 25 [ widget st, widget b ] ] 이벤트 필터에 대한 내용 추가 요망 2 데이터베이스 (검토 중) 원문: https://en.wikibooks.org/wiki/Haskell/Database TODO 원문이 미완성 서문 설치 PostgreSQL 또는 SQLite 네이티브 MySQL ODBC/MySQL 일반적인 워크플로 연결과 연결 해제 쿼리 실행 SQL 문의 실행 Select Insert Update Delete 트랜잭션 프러시저 호출 서문 HDBC는 하스켈에서 가장 인기 있는 데이터베이스 모듈이다. HDBC는 하스 켈 프로그램과 SQL 관계형 데이터베이스 사이의 추상 계층을 제공한다. 이로써 데이터베이스 코드를 하스 켈로 한 번만 작성하면 많은 백엔드 SQL 데이터베이스와 함께 작동하게 만들 수 있다. HDBC는 Perl의 DBI 인터페이스에 어느 정도 기반하지만 파이썬의 DB-API v2, 자바의 JDBC, 하스켈의 HSQL에도 영향을 받았다. Perl에서 DBI가 DBD를 요구하는 것처럼 HDBC가 작동하려면 기저의 드라이버 모듈이 필요하다. HDBC 백엔드 드라이버로는 PostgreSQL, SQLite, ODBC(윈도우즈와 유닉스/리눅스/맥 용)이 있다. MySQL은 가장 인기 있는 오픈소스 데이터베이스로서 드라이버가 HDBC-mysql (네이티브), HDBC-odbc (ODBC) 이렇게 2개 존재한다. MySQL 사용자는 리눅스를 포함해 MySQL을 지원하는 모든 플랫폼에서 ODBC 드라이버를 사용할 수 있다. ODBC를 사용할 때의 이점은 SQL 문의 문법이 여러 데이터베이스 엔진들의 차이점에 구애받지 않는다는 것이다. 따라서 데이터베이스를 갈아탈 때 애플리케이션 이식이 쉽다. 이는 다른 상업용 데이터베이스(오라클이나 DB2 같은)의 경우에도 ODBC를 선호할 근거가 된다. 설치 PostgreSQL 또는 SQLite 자세한 정보는 HDBC FAQ를 볼 것. 네이티브 MySQL 네이티브 ODBC-mysql 라이브러리의 경우 먼저 C MySQL 클라이언트 라이브러리가 필요하다. 런타임 오류를 방지하기 위해 데이터베이스 접근을 래핑 해야 할 수도 있다. ODBC/MySQL ODBC를 통해 MySQL이 HDBC와 작동하게 만들려면 절차가 많다. 특히 루트 권한이 없는 경우는 더욱 그렇다. 플랫폼이 ODBC 라이브러리를 제공하지 않는다면(대부분 그럴 것이다) Unix-ODBC를 설치한다. 자세한 정보는 여기를 볼 것. MySQL-ODBC Connector를 설치한다. 자세한 정보는 여기에. Database.HDBC 모듈을 설치한다. Database.HDBC.ODBC 모듈을 설치한다. mysql 드라이버를 odbcinst.ini 파일($ODBC_HOME/etc/에 있음)에 추가하고 데이터 소스는 $HOME/.odbc.ini에 추가한다. 테스트 프로그램을 제작한다. ODBC 드라이버는 기본적으로 공유 라이브러리를 이용해 설치되기 때문에 다음 환경 변수가 필요하다. export LD_LIBRARY_PATH=$ODBC_HOME/lib 환경 변수를 추가하는 게 싫다면 스태틱 라이브러리 옵션을 활성화하고 ODBC를 컴파일해야 한다. 그다음에는 데이터베이스에 연결해서 모든 테이블의 이름을 출력하는 간단한 테스트 프로그램을 작성해 본다. 런타임 오류를 방지하기 위해 데이터베이스 접근을 래핑 해야 할 수도 있다. module Main where import Database.HDBC.ODBC import Database.HDBC main = do c <- connectODBC "DSN=PSPDSN" xs <- getTables c putStr $ "tables "++(foldr jn "." xs)++"\n" where jn a b = a++" "++b 일반적인 워크플로 연결과 연결 해제 모든 데이터베이스 작업의 첫걸음은 목표 데이터베이스에 연결하는 것이다. 이는 드라이버에 특화된 connect API를 통해 이루어지며 그 타입은 다음과 같다. String -> IO Connection connect API는 connect 문자열을 받아서 IO 모나드 안의 Connection을 반환한다. 대부분의 프로그램은 스코프를 벗어나거나 프로그램이 종료하면 데이터베이스 연결을 가비지 컬렉션 하지만 명시적으로 연결을 해제하는 것은 좋은 습관이다. conn->Disconnect 쿼리 실행 쿼리를 실행하는 것은 대개 다음과 같은 절차를 따른다. 구문을 준비한다 bind 변수들과 함께 구문을 실행한다 결과 집합(있다면)을 fetch 한다 구문을 종료한다 HDBC는 bind 변수와 결과 집합을 위한 수단으로 [ SqlValue ]와 [ Maybe String ]을 지원한다. [ SqlValue ] 대신 [ Maybe String ]을 사용할 때는 s로 시작하는 함수들을 사용해야 한다. [ SqlValue ]는 애플리케이션에서 타입 안정성이 아주 중요한 경우 강한 타입의 데이터를 위해 사용할 수 있다. 그렇지 않으면 [ Maybe String ]이 많은 데이터베이스 쿼리를 다룰 때 좀 더 편하다. [ Maybe String ]을 사용할 때는 데이터베이스 드라이버가 자동으로 데이터 변환을 수행할 것이다. 여기에는 퍼포먼스 비용이 있다는 것에 주의하라. 가끔은 쿼리가 간단한 경우 여러 단계를 하나로 합치는 간소화된 API가 있다. 예를 들어 Run과 sRun은 "준비 및 실행"의 래퍼다. quickQuery는 "준비, 실행, 모든 열 fetch"의 래퍼다. SQL 문의 실행 Select 원문 없음 Insert 원문 없음 Update 원문 없음 Delete 원문 없음 트랜잭션 데이터베이스 트랜잭션은 commit과 rollback으로 제어한다. 하지만 어떤 데이터베이스들은(mysql 같은) 트랜잭션을 지원하지 않는 것에 주의하라. 따라서 모든 쿼리는 그 자체로 원자적 트랜잭션 내에 있다. HDBC는 쿼리 그룹에 대한 트랜잭션을 자동화하기 위한 withTransaction을 제공한다. 프러시저 호출 원문 없음 3 XML 원문: https://en.wikibooks.org/wiki/Haskell/XML XML 파싱을 위한 라이브러리들 XML 생성을 위한 라이브러리 다른 선택지들 HXT에 익숙해지기 XML 작업을 위한 하스 켈 라이브러리가 몇 개 있으며 HTML을 위한 라이브러리도 있다. 웹에 특화된 작업의 경우 Haskell/Web programming 장을 볼 것. XML 파싱을 위한 라이브러리들 Haskell XML Toolbox는 XML 파싱을 위한 도구 모음으로써 다른 도구들보다 일반화된 접근법을 목표로 한다. HaXml은 하스켈을 이용해 XML 문서의 파싱, 필터링, 변환, 생성하기 위한 유틸리티 모음이다. HXML은 무검증, 게으른, 공간 효율적인 파서로서 HaXml의 단순 대체재로 사용할 수 있다. xml-conduit은 XML의 파싱과 렌더링을 제공한다. 튜토리얼은 1을 볼 것. XML 생성을 위한 라이브러리 HSXML은 XML 문서를 정적 타입 안전 s-expression으로 표현한다. 다른 선택지들 tagsoup은 구조화되지 않은 HTML을 파싱 하기 위한 라이브러리다. 즉 데이터의<NAME>이나 well-formed 유무를 가정하지 않는다. HXT에 익숙해지기 여기서는 예시를 위해 Haskell XML Toolbox를 사용하겠다. 먼저 GHC, GHCi를 설치해야 하고 지침에 따라 HXT도 다운로드 및 설치해야 한다. 모두 갖췄으면 HXT를 다룰 준비가 된 것이다. XML 파서를 스코프 안으로 가져오고 간단한 XML 포맷 문자열을 파싱 해보자. Prelude> :m + Text.XML.HXT.Parser.XmlParsec Prelude Text.XML.HXT.Parser.XmlParsec> xread "<foo>abc<bar/>def</foo>" [NTree (XTag (QN {namePrefix = "", localPart = "foo", namespaceUri = ""}) []) [NTree (XText "abc") [],NTree (XTag (QN {namePrefix = "", localPart = "bar", namespaceUri = ""}) []) [],NTree (XText "def") []]] HXT가 XML 문서를 트리의 리스트로 표현하는 것을 볼 수 있다. 노드는 서브 트리의 리스트를 포함하는 XTag 또는 문자열을 포함하는 XText로 구성된다. GHCi를 사용하면 더 자세하게 살펴볼 수 있다. Prelude> :m + Data.Tree.NTree.TypeDefs Prelude Text.XML.HXT.Parser.XmlParsec Text.XML.HXT.DOM> :i NTree data NTree a = NTree a (NTrees a) -- Defined in Data.Tree.NTree.TypeDefs Prelude Text.XML.HXT.Parser.XmlParsec Text.XML.HXT.DOM> :i NTrees type NTrees a = [NTree a] -- Defined in Data.Tree.NTree.TypeDefs NTree는 범용 트리 구조로서 각 노드가 리스트에 자식들을 보관한다. 좀 더 둘러보면 XML 문서가 다음과 같이 정의되는 XNode 타입에 대한 트리라는 것을 알 수 있다. data XNode = XText String | XCharRef Int | XEntityRef String | XCmt String | XCdata String | XPi QName XmlTrees | XTag QName XmlTrees | XDTD DTDElem Attributes | XAttr QName | XError Int String 우리 예제로 돌아오면 HXT가 입력을 성공적으로 파싱 했지만 사람이 읽기에 더 명료한 표현을 원할 수도 있다. 다행히도 DOM 모듈이 그런 걸 제공한다. xread는 트리의 리스트를 반환하지만 포매팅 함수는 단일 트리에 대해 작동하는 것에 주목할 것. Prelude Text.XML.HXT.Parser.XmlParsec> :m + Text.XML.HXT.DOM.FormatXmlTree Prelude Text.XML.HXT.Parser.XmlParsec Text.XML.HXT.DOM> putStrLn $ formatXmlTree $ head $ xread "<foo>abc<bar/>def</foo>" ---XTag "foo" | +---XText "abc" | +---XTag "bar" | +---XText "def" 이 표현법은 그 구조를 명시적으로 만들며 입력 문자열과의 관계를 더 잘 보여준다. 우리의 XML 문서에 속성(attribute)을 추가해서 더 확장해 보자. (따옴표에 이스케이프 시퀀스를 붙이는 것에 주의) Prelude Text.XML.HXT.Parser.XmlParsec> xread "<foo a1=\"my\" b2=\"oh\">abc<bar/>def</foo>" [NTree (XTag (QN {namePrefix = "", localPart = "foo", namespaceUri = ""}) [NTree (XAttr (QN {namePrefix = "", localPart = "a1", namespaceUri = ""})) [NTree (XText "my") []],NTree (XAttr (QN {namePrefix = "", localPart = "b2", namespaceUri = ""})) [NTree (XText "oh") []]]) [NTree (XText "abc") [],NTree (XTag (QN {namePrefix = "", localPart = "bar", namespaceUri = ""}) []) [],NTree (XText "def") []]] 속성은 NTree 노드로서 보관되며 그 내용물은 XAttr 타입이고 물론 자식은 없다. 위에서 한 것처럼 이 표현을 보기 좋게 출력해 보자. 다음은 XPath를 이용해 데이터를 추출하는 단순한 예시다. Prelude> :set prompt "> " > :m + Text.XML.HXT.Parser.XmlParsec Text.XML.HXT.XPath.XPathEval > let xml = "<foo><a>A</a><c>C</c></foo>" > let xmltree = head $ xread xml > let result = getXPath "//a" xmltree > result > [NTree (XTag (QN {namePrefix = "", localPart = "a", namespaceUri = ""}) []) [NTree (XText "A") []]] > :t result > result :: NTrees XNode 4 수학식의 파싱 (검토 중) 원문: https://en.wikibooks.org/wiki/Haskell/ParseExps TODO 예제 코드가 이상하다. 글 도중에 연산자들이 바뀐다. 원문이 이상한 문장 몇 개 몸풀기 Adaptation Structure Emerges 공백과 applicative 표기 모듈화하기 이번 장에서는 "3*sin x + y" 같은 텍스트를 Plus (Times (Number 3) (Apply "sin" (Variable "x"))) (Variable "y") 같은 추상 구문 표현으로 바꾸는 방법을 논한다. Text.Parser.Combinators.ReadP를 사용할 것이므로 레퍼런스를 같이 열어두자. 몸풀기 import Text.ParserCombinators.ReadP 몸풀기의 일환으로 좀 더 쉬운 문제부터 시작한다. 기호가 문자 o, 연산자 &, 괄호만 있는 언어가 있다. 트리들의 데이터 타입을 정의한다. data Tree = Branch Tree Tree | Leaf deriving Show 리프들의 파서는 ReadP 라이브러리를 이용해 정의된다. leaf = do char 'o' return Leaf & 연산자로 구성되는 브랜치들의 파서를 정의하려면 연관 법칙을 선택해야 한다. 즉 o&o&o가 (o&o)&o 또는 o&(o&o) 중 무엇과 같아야 할까? 여기서는 후자를 고르겠다. 일단 괄호는 잊고 첫 번째 "마일스톤" 이후에 넣기로 한다. branch = do a <- leaf char '&' b <- tree return (Branch a b) tree = leaf +++ branch 몇 가지 입력에 제대로 반응하는지 테스트해 본다. *Main> readP_to_S tree "o" [(Leaf,"")] *Main> readP_to_S tree "o&o" [(Leaf,"&o"),(Branch Leaf Leaf,"")] *Main> readP_to_S tree "o&o&o" [(Leaf,"&o&o"),(Branch Leaf Leaf,"&o"),(Branch Leaf (Branch Leaf Leaf),"")] 잘 되니 다음에는 괄호를 지원해 보자. 괄호는 나중에 재사용할 수 있도록 범용적으로 정의된다. brackets p = do char '(' r <- p char ')' return r 이제 브랜치 파서와 트리 파서가 괄호를 지원하도록 갱신할 수 있다. branch = do a <- leaf +++ brackets tree char '&' b <- tree return (Branch a b) tree = leaf +++ branch +++ brackets tree 테스트해 보면 잘 작동하는 것 같다. *Main> readP_to_S tree "((o&((o&o)))&o&((o&o)&o)&o)" [(Branch (Branch Leaf (Branch Leaf Leaf)) (Branch Leaf (Branch (Branch (Branch Leaf Leaf) Leaf) Leaf)),"")] Adaptation 이쯤이 adaptation을 위한 좋은 출발점이다. 최종 목표를 향한 첫 수정사항은 꽤 쉬운 작업인데 리프들을 o에서 임의의 문자열로 변경하는 것이다. 그러려면 데이터 타입을 Leaf에서 Leaf String으로 바꾸고 leaf 함수를 수정해야 한다. TODO: adaptation을 무슨 의미로 쓴 건지... data Tree = Branch Tree Tree | Leaf String deriving Show leaf = do s <- many1 (choice (map char ['a'..'z'])) return (Leaf s) 다음 adaptation으로 &보다 약하게 결합되는 연산자인 |를 도입한다. 즉 foo&bar|baz는 (foo&bar)|baz로 파싱 되어야 한다. 먼저 구문을 나타내는 데이터 타입을 갱신한다. data Operator = And | Or deriving Show data Tree = Branch Operator Tree Tree | Leaf String deriving Show branch 함수를 복제해서 andBranch와 orBranch를 만들고 left choice operator인 <++를 이용해 우선순위를 부여한다. andBranch = do a <- leaf +++ brackets tree char '&' b <- tree return (Branch And a b) orBranch = do a <- leaf +++ brackets tree char '|' b <- tree return (Branch Or a b) tree = leaf +++ (orBranch <++ andBranch) +++ brackets tree 그런데 이렇게 수정하면 잘 작동하지 않는다. a&b&c&d|e&f&g&h|i&j&k|l&m&n&o|p&q&r|s 같은 표현식을 X|Y|Z|W|P|Q라는 트리인데(이 트리는 이미 파싱 할 수 있다) 단지 리프들이 좀 더 복잡한 형태(역시 어떻게 파싱 할지 이미 알고 있다)라고 생각해 보면, 잘 작동하는 파서를 만들 수 있다. andBranch = do a <- leaf +++ brackets tree char '&' b <- andTree return (Branch And a b) andTree = leaf +++ brackets tree +++ andBranch orBranch = do a <- andTree +++ brackets tree char '|' b <- orTree return (Branch Or a b) orTree = andTree +++ brackets tree +++ orBranch tree = orTree 이 접근법은 잘 작동하지만 *Main> readP_to_S tree "(foo&bar|baz)" [(Leaf "","(foo&bar|baz)"),(Branch Or (Branch And (Leaf "foo") (Leaf "bar")) (Leaf "baz"),""),(Branch Or (Branch And (Leaf "foo") (Leaf "bar")) (Leaf "baz"),"")] *Main> readP_to_S tree "(foo|bar&baz)" [(Leaf "","(foo|bar&baz)"),(Branch Or (Leaf "foo") (Branch And (Leaf "bar") (Leaf "baz")),""),(Branch Or (Leaf "foo") (Branch And (Leaf "bar") (Leaf "baz")),"")] 파싱을 모호하게 한다. 효율성 측면에서 바람직하지 않고 우리가 무언가 부자연스러운 일을 했음을 암시한다. andTree와 orTree 함수 둘 다 안에 brackets tree가 있는데, orTree는 andTree를 포함하기 때문에 여기서 모호함이 발생한다. 이 문제를 해결하려면 그저 backets tree를 orTree에서 제거하면 된다. orTree = andTree +++ orBranch Structure Emerges 지금까지의 소일거리로 사실은 최종 프로그램 구조가 상당 부분 명료해졌다. 작성했던 것을 돌아보면 새로운 연산자를 추가해서 확장하는 것이 꽤나 쉬웠다. (독자를 위한 연습문제: 아직 이 작업이 명료하지 않다면 알아내볼 것) 잠시 고민하면 이 패턴을 완성해서 임의의 연산자들의 리스트에 대해 추상화할 수 있다. operators = [(Or,'|'),(And,'&')] 또는 data Operator = Add | Mul | Exp deriving Show operators = [(Add,'+'),(Mul,'*'),(Exp,'^')] 옮긴이: 지금까지는 &, |를 쓰다가 갑자기 +, *로 바뀐 것에 주의하세요 파서는 이것으로부터 계산되고 중첩을 통해(이전에 직접 했던 것처럼) 파싱이 모호함 없이 일어나야 한다. 능숙한 하스 켈 프로그래머라면 이미 다음 코드를 머릿속에 떠올렸을 것이다. tree = foldr (\(op, name) p -> let this = p +++ do a <- p +++ brackets tree char name b <- this return (Branch op a b) in this) (leaf +++ brackets tree) operators 그리고 테스트해 볼 수 있다. *Main> readP_to_S tree "(x^e*y+w^e*z^e)" [(Leaf "","(x^e*y+w^e*z^e)"),(Branch Add (Branch Mul (Branch Exp (Leaf "x") (Leaf "e")) (Leaf "y")) (Branch Mul (Branch Exp (Leaf "w") (Leaf "e")) (Branch Exp (Leaf "z") (Leaf "e"))),"")] 이쯤이 쉬어가기 좋은 지점이다. 처음의 그 파서는 이제 다음과 같은 스크립트가 되었다. import Text.ParserCombinators.ReadP brackets p = do char '(' r <- p char ')' return r data Operator = Add | Mul | Exp deriving Show operators = [(Add,'+'),(Mul,'*'),(Exp,'^')] data Tree = Branch Operator Tree Tree | Leaf String deriving Show leaf = do s <- many1 (choice (map char ['a'..'z'])) return (Leaf s) tree = foldr (\(op, name) p -> let this = p +++ do a <- p +++ brackets tree char name b <- this return (Branch op a b) in this) (leaf +++ brackets tree) operators 공백과 applicative 표기 functional/applicative 표기와 공백 무시는 둘 다 동일 문자(공백 문자)에 의존하기 때문에 어떤 것을 먼저 구현할지, 혹은 무엇을 먼저 구현하던 상고나 없을지를 고민해 보자. f x라는 표현식을 고려하면 applicative 표현에 앞서 공백을 파싱 하는 방법을 찾아야 한다. 함수 application을 처리하고 나면 단순 병치(juxtaposition)에 (의도한 대로) 대응해야 하기 때문이다. 지금의 파서가 공백을 무시하게 만드는 데는 기술적인 어려움이 있다. skipWhitespace 파서를 만든다고 치고 공백이 발생할 수 있는 모든 곳에 이걸 끼워 넣으면 파서에 모호함이 범람할 것이다. 따라서 특정한 주요 지점들에서만 공백을 무시해야 한다. 예를 들면 공백은 항상 토큰을 읽기 전에 무시되는 규약을 선택할 수 있다. 그러면 파서는 " a + b * c "를 "[ a][ +][ b][ *][ c][ ]"처럼 자를 것이다. 어떤 규약을 선택할지는 우리 마음대로지만 공백을 앞서 무시하는 것이 좀 더 영리해 보인다. 불편함 없이 " a"를 처리하기 때문이다. 다음과 같이 정의한다. skipWhitespace = do many (choice (map char [' ','\n'])) return () 그리고 앞서 작성했던 모든 파싱을 수정하여 새 규약을 따르도록 한다. brackets p = do skipWhitespace char '(' r <- p skipWhitespace char ')' return r leaf = do skipWhitespace s <- many1 (choice (map char ['a'..'z'])) return (Leaf s) tree = foldr (\(op, name) p -> let this = p +++ do a <- p +++ brackets tree skipWhitespace char name b <- this return (Branch op a b) in this) (leaf +++ brackets tree) operators applicative를 깔끔하게 지원하려면 구문도 그걸 허용하도록 만들어야 한다. data Tree = Apply Tree Tree | Branch Operator Tree Tree | Leaf String deriving Show 이 구문 트리는 "(x + y) foo" 같은 문장을 허용하지만 "(f . g) x"처럼 하스켈에선 흔한 구문은 허용하지 않는다. 어떤 것이 의미 있고 어떤 것이 아닌지는 타입 검사기가 결정할 문제다. 이런 관심의 분리는 우리의 문제(파싱)를 단순하고 통일되게<NAME>다. This syntax tree will allow for sentences such as "(x + y) foo", while this not correct other sentences like "(f . g) x" are commonplace in haskell 이게 먼 소리임? 우리의 파서의 본질은 leaf와 tree라는 두 함수다. (skipWhitespace와 brackets는 "라이브러리" 또는 헬퍼 함수들로 취급) tree 함수는 소비할 수 있는 모든 오퍼레이터를 소비하고 그것들에 리프들을 최대한 붙인다. leaf 함수는 연산자들 포함하지 않는 모든 것을 읽는다고 볼 수 있다. 이런 관점에서 프로그램을 볼 때 applicative 표기를 지원하려면 리프를 함수 적용의 연쇄를 파싱 하는 무언가로 교체해야 한다는 게 명백해진다. 따라서 다음과 같은 시도를 할 수 있다. leaf = chainl1 (do skipWhitespace s <- many1 (choice (map char ['a'..'z'])) return (Leaf s)) (return Apply) 앞서 언급한 "흔한" 합성 구문을 지원하도록 확장하는 것은 쉽다. leaf = chainl1 (brackets tree +++ do skipWhitespace s <- many1 (choice (map char ['a'..'z'])) return (Leaf s)) (return Apply) 이걸로 문제를 완벽히 해결했다. 원래 목표를 달성해서 원하는 연산자들을 (순서대로) 기술하고 Tree를 일종의 수학식으로 변환하는 순회 함수를 작성하기만 하면 된다. 알려지지 않은 함수가 사용되면 오류를 발생시킨다던가 하고. 모듈화하기 앞서 작성한 알고리즘은 다른 상황에서 쓰기에도 충분하게 범용적이다. 한 가지 목적을 위한 것이어도 더 큰 프로그램에서 사용할 계획이라면 내부와 외부(인터페이스)를 분리하는 것은 필수다. module Parser ( Tree(..), parseExpression ) where import Data.Maybe import Text.ParserCombinators.ReadP skipWhitespace = do many (choice (map char [' ','\n'])) return () brackets p = do skipWhitespace char '(' r <- p skipWhitespace char ')' return r data Tree op = Apply (Tree op) (Tree op) | Branch op (Tree op) (Tree op) | Leaf String deriving Show parseExpression operators = listToMaybe . map fst . filter (null .snd) . readP_to_S tree where leaf = chainl1 (brackets tree +++ do skipWhitespace s <- many1 (choice (map char ['a'..'z'])) return (Leaf s)) (return Apply) tree = foldr (\(op, name) p -> let this = p +++ do a <- p +++ brackets tree skipWhitespace char name b <- this return (Branch op a b) in this) (leaf +++ brackets tree) operators<|endoftext|>

전문분야 텍스트 ### 제목: SAS로 하는 기초 데이터 전처리, 핸들링(Data handling) ### 본문: SAS를 활용한 데이터 전처리를 다루는 책입니다. SAS를 이용해서 통계분석을 다루는 책은 많이 있지만, SAS 문법을 활용한 데이터 전처리(핸들링)나 SQL 프러시저(PROC SQL)를 활용한 데이터 전처리를 다룬 책은 찾기가 어렵습니다. SAS 사용 시 거의 활용하지 않는 구문을 제외하고 활용도가 높고 자주 사용되는 함수, 문법을 설명합니다. 최대한 원리를 상세하게 설명했습니다. 디테일한 부분에서 헷갈리는 부분이 없도록 간단한 문장으로 자세하게 설명합니다. 다른 책들과의 차별성을 얘기하자면 이 책은 대부분 문법 설명에서 동일한 예제를 사용합니다(SASHELP 라이브러리의 CLASS 테이블). 그 이유는 코딩을 할 때 테이블의 파악하고 머릿속으로 그림을 그리는 게 중요한데 동일한 예제로 연습을 할 경우 그 과정을 빠르게 할 수 있기 때문입니다. 코딩 이해도 빠를 것입니다. CLASS 테이블은 SAS 설치 시 기본으로 설치되는 테이블입니다. 행의 수가 20개 정도라서 한눈에 파악하기 쉬우며 다양한 예시를 들어 보이기에도 적합합니다. 초보자들이 어렵지 않게 원하는 데이터를 전처리 할 수 있게 만들었습니다. 피드백은 언제든 환영합니다. 1.SAS의 기초 SAS 데이터를 다루는 데 가장 기초적인 개념은 ‘테이블’ 과 ‘라이브러리’입니다. SAS뿐만 아니라 R을 이용하여 데이터 분석을 할 때도 ‘테이블’과 ‘라이브러리’ 개념을 활용합니다. 1-1. 테이블과 라이브러리 테이블: 엑셀과 같이 행과 열로 데이터가 정리된 파일명 라이브러리: 테이블이 속한 폴더명 간단하게 이야기해서 ‘테이블’=‘파일명’, ‘라이브러리’=‘폴더명’으로 볼 수 있습니다. 예를 들어 sashelp.class로 되어있다면 sashelp 라이브러리의 class 테이블을 의미합니다. 우리가 익숙하게 접하는 윈도에서 활용하는 파일과 폴더를 생각하면 간단합니다. 윈도와 거의 유사한 개념입니다. 데이터 분석 세계에서는 테이블과 라이브러리라는 용어를 사용합니다. 데이터를 분석을 시작하기에 앞서 가장 기초적인 부분은 테이블 생성과 라이브러리 생성이라고 볼 수 있습니다. 파일(테이블)이 있어야 분석할 대상이 있고, 이 파일을 저장할 폴더(라이브러리) 가 있어야 하기 때문입니다. 우리가 윈도를 사용할 때. doc, .hwp 파일을 생성하는 것처럼 테이블을 생성하고, 이 테이블을 저장할 라이브러리를 생성하는 방법을 배우겠습니다. tip 라이브러리를 특별하게 설정하지 않는다면 기본 라이브러리로 ‘WORK’라이브러리가 설정됩니다. tip SAS 프로그램은 명령어를 읽어들일 때 위에서부터 읽습니다. 그리고 왼쪽에서부터 읽습니다. 우리가 책을 읽듯이 순서대로 명령어를 읽어들인다고 생각하시면 됩니다. 코딩을 하실 때 중요한 요소입니다. 먼저 수행하길 바라는 명령어를 위쪽에 배치하시면 됩니다. 명령어 알아보기 명령어 * data xxx: 테이블을 생성하는 명령어입니다. xxx라는 이름의 테이블을 만듭니다. * set yyy: 테이블을 불러오는 명령어입니다. yyy라는 이름을 테이블을 불러옵니다. * run: SAS 코딩의 끝을 알려주는 명령어입니다. 이 명령어가 들어가야 SAS가 전체 코딩이 끝난 것을 인식하고 명령어들을 시행합니다. * ‘;’ : 각 명령어 문장의 끝을 알려주는 명령어입니다. ‘run’이 전체 코딩이 끝난 것을 알려준다면 ‘;’은 문장 코딩이 끝난 것을 알려줍니다. 간단하게 비유하자면 ‘run’은 문단의 끝, ‘;’은 문장의 끝을 알려주는 명령어라고 볼 수 있습니다. * ‘ ’(스페이스 공간): SAS는 각 명령어를 구분할 때 ‘ ’(공백:스페이스)으로 구분합니다. 명령어 간 구분을 할 때 스페이스가 여러 개여도 관계없습니다. * /* */: 주석입니다. 주석은 코드의 앞뒤에 붙어서 해당 코드를 설명하는 역할을 합니다. 실제 코드 실행에는 전혀 영향을 미치지 않습니다. 아래 예제에서 주석이 붙은 채로 실행을 해도 문제가 없습니다. 예제 DATA TEST; /*테이블 TEST를 생성함(DATA)*/ SET SASHELP.CLASS; /*라이브러리 sashelp의 class라는 테이블에서 데이터를 불러옴*/ RUN; /*모든 명령어를 종료*/ 이름 성별 나이 키(단위: 인치) 몸무게(단위: 파운드) 알프레드 남 14 69 112.5 앨리스여 13 56.5 84 바바라여 13 65.3 98 캐럴여 14 62.8 102.5 헨리 남 14 63.5 102.5 제임스 남 12 57.3 83 제인여 12 59.8 84.5 자넷여 15 62.5 112.5 제프리 남 13 62.5 84 존 남 12 59 99.5 조이스여 11 51.3 50.5 주디여 14 64.3 90 루이스여 12 56.3 77 메리여 15 66.5 112 필립 남 16 72 150 로버트 남 12 64.8 128 로날드 남 15 67 133 토마스 남 11 57.5 85 윌리엄 남 15 66.5 112 라이브러리 명령어는 ‘라이브러리명.테이블명’ 으로 실행합니다. 예를 들어 우리가 익숙한 윈도에서 C:\SASHELP\CLASS.TXT 파일을 불러오는 것을 SAS에서 하자면 ‘SASHELP.CLASS’ 가 됩니다. SAS는 ‘.TXT' 나 '.HWP’ 같은 확장자명이 없고 행과 열로 이뤄진 엑셀처럼 단일한 형태로 이뤄져 있기 때문에 확장자명을 쓰지 않습니다. tip 예제에서 생성된 테이블 TEST 앞에 라이브러리가 없습니다. 만약 이처럼 테이블 앞에 라이브러리명을 지정하지 않을 경우 SAS는 자동으로 WORK 라이브러리에 테이블 TEST를 저장합니다. 1-2. 라이브러리 생성 법 이제 라이브러리를 생성해 보겠습니다. 라이브러리는 윈도 화면에서 폴더명과 동일한 역할을 합니다. 파일(테이블)을 불러오기 위해 폴더(라이브러리)에 들어가는 것을 생각하면 간단합니다. 라이브러리 생성을 위한 명령어는 다음과 같습니다. 명령어 LIBNAME XXX YYY: 라이브러리명 XXX의 위치를 YYY로 지정하는 명령어입니다. 예제 LIBNAME SASTEST “C:\SAS\BASE”; /*라이브러리명 ‘SASTEST’를 생성하는데 그 위치는 “C:\SAS\BASE”로 함*/ tip 만약 SAS 엔터프라이즈를 사용하신다면 YYY의 위치에 네트워크 상의 폴더명을 입력하시면 됩니다(예: \PGM\SASTEST) 2. PROC 사용법 이제 구체적인 테이블 활용법에 대해서 설명해 보겠습니다. 행과 열로 이뤄진 엑셀과 같은 파일이 테이블이라고 이전 장에서 설명을 했습니다. PROC 명령어는 테이블을 이리저리 조합하고 다루는 명령어입니다. PROC은 PROCEDURE(절차)를 줄인 말입니다. ‘PROC’ 뒤에 사용할 SAS 기능명을 붙여서 사용합니다. 예를 들어 ‘PROC PRINT’, ‘PROC SQL’처럼 ‘PROC XXX’ 와 같은 방식으로 코딩을 합니다. ‘PROC PRINT’라고 명령어를 쓴다면 이는, ‘SAS의 PRINT 기능을 사용하겠다.’라는 의미입니다. 앞으로 자주 쓰이는 간단한 PROC의 기능을 쉬운 예제로 알아보겠습니다. 자주 활용되면서 간단한 PROC 명령어는 아래와 같습니다. PROC SORT PROC PRINT PROC CONTENTS PROC FREQ 2-1. PROC SORT(순서대로 정렬하기) 테이블 데이터를 순서대로 정렬합니다. 명령어 PROC SORT: SORT 프러시저를 시행합니다. DATA=XXX: XXX라는 데이터를 불러옵니다. OUT=YYY: 결괏값을 YYY라는 테이블로 만듭니다. BY ZZZ: 변수 ZZZ를 정렬합니다. DESCENDING: 내림차순으로 정렬합니다. 예제 PROC SORT DATA=SASHELP.CLASS OUT=TEST; /*SORT PROCEDURE를 사용하여(PROC SORT) SASHELP 라이브러리(SASHELP.)의 CLASS 테이블을 불러오고(DATA=) 정렬한 결괏값은 WORK 라이브러리의 ‘TEST’테이블로 저장함.*/ BY AGE; /*AGE를 오름차순으로 정렬함(BY로 인함)*/ RUN; /*모든 명령어를 종료*/ 이름 성별 나이 키(단위: 인치) 몸무게(단위: 파운드) 조이스여 11 51.3 50.5 토마스 남 11 57.5 85 제임스 남 12 57.3 83 제인여 12 59.8 84.5 존 남 12 59 99.5 루이스여 12 56.3 77 로버트 남 12 64.8 128 앨리스여 13 56.5 84 바바라여 13 65.3 98 제프리 남 13 62.5 84 알프레드 남 14 69 112.5 캐럴여 14 62.8 102.5 헨리 남 14 63.5 102.5 주디여 14 64.3 90 자넷여 15 62.5 112.5 메리여 15 66.5 112 로날드 남 15 67 133 윌리엄 남 15 66.5 112 필립 남 16 72 150 만약 ‘OUT=TEST’ 명령어를 쓰지 않는다면 ‘DATA=SASHELP.CLASS’에서 정렬을 시행하고 그대로 CLASS 테이블에 저장합니다(단, SAS 엔터프라이즈에서는 SASHELP 테이블은 특수 권한이 있어야 수정할 수 있습니다. SASHELP 테이블은 SAS 명령어를 연습하기 좋은 데이터가 많으므로 수정하지 않는 것을 권장합니다.) PROC SORT를 이용하여 정렬할 때, 변수 XXX가 숫자 변수이면 작은 수부터 차례대로 오름차순으로 정렬됩니다. 문자 변수이면 ASCII 코드에 표시된 값에 따라 오름차순으로 정렬됩니다. 한글이면 가나다순으로, 영어면 알파벳순으로 정렬됩니다. 한글과 영어가 섞여있다면 영어가 먼저 나오고 다음으로 한글이 나옵니다. 오름차순과 내림차순 BY 이후 변수 AGE 앞에 DESCENDING 명령어를 넣는다면 내림차순으로 정렬합니다. BY 이후 변수 AGE 앞에 ASCENDING 명령어를 넣으면 오름차순으로 정렬됩니다. ASCENDING 명령어는 기본 옵션으로 설정돼 있어서 입력하지 않아도 무방합니다. BY와 AGE 사이에 명령어를 입력하지 않을 경우 변수 AGE는 자동적으로 오름차순으로 설정됩니다. PROC SORT DATA=TEST;/*SORT PROCEDURE를 사용하여(PROC SORT) WORK 라이브러리(SASHELP.)의 CLASS 테이블을 불러옴(DATA=).*/ BY DESCENDING AGE;/*AGE를 내림차순으로 정렬함(BY, DESCENDING)*/ RUN;/*모든 명령어를 종료*/ 이름 성별 나이 키(단위: 인치) 몸무게(단위: 파운드) 필립 남 16 72 150 자넷여 15 62.5 112.5 메리여 15 66.5 112 로날드 남 15 67 133 윌리엄 남 15 66.5 112 알프레드 남 14 69 112.5 캐럴여 14 62.8 102.5 헨리 남 14 63.5 102.5 주디여 14 64.3 90 앨리스여 13 56.5 84 바바라여 13 65.3 98 제프리 남 13 62.5 84 제임스 남 12 57.3 83 제인여 12 59.8 84.5 존 남 12 59 99.5 루이스여 12 56.3 77 로버트 남 12 64.8 128 조이스여 11 51.3 50.5 토마스 남 11 57.5 85 2-2. PROC PRINT(테이블 보여주기) 테이블 데이터를 보여줍니다. 명령어 PROC PRINT: PRINT 프러시저를 시행합니다. DATA=XXX: XXX라는 데이터를 불러옵니다. VAR XXX: 지정된 변수 XXX를 불러옵니다. ID XXX: 지정된 변수를 기준값으로 활용합니다. 기준값이란, 해당 행의 대푯값으로 활용하겠다는 의미입니다. BY XXX: 지정된 변수를 그룹으로 만듭니다. tip 단, BY 명령어를 활용할 때는 BY가 오름차순으로 정렬돼 있어야 합니다. PROC SORT를 활용할 수 있습니다.) 예제 PROC PRINT DATA=SASHELP.CLASS;/*PRINT PROCEDURE를 사용하여(PROC PRINT) SASHELP 라이브러리(SASHELP.)의 CLASS 테이블을 불러옴(DATA=)*/ RUN;/*명령어를 종료*/ | OBS|Name|Sex|Age|Height|Weight| | -------- | -------- | --------| -------- | --------| 1|알프레드|남|14|69.0|112.5 2|앨리스|여|13|56.5|84.0 3|바바라|여|13|65.3|98.0 4|캐럴|여|14|62.8|102.5 5|헨리|남|14|63.5|102.5 6|제임스|남|12|57.3|83.0 7|제인|여|12|59.8|84.5 8|자넷|여|15|62.5|112.5 9|제프리|남|13|62.5|84.0 10|존|남|12|59.0|99.5 11|조이스|여|11|51.3|50.5 12|주디|여|14|64.3|90.0 13|루이스|여|12|56.3|77.0 14|메리|여|15|66.5|112.0 15|필립|남|16|72.0|150.0 16|로버트|남|12|64.8|128.0 17|로날드|남|15|67.0|133.0 18|토마스|남|11|57.5|85.0 19|윌리엄|남|15|66.5|112.0 예제 2 PROC PRINT DATA=SASHELP.CLASS; /*PRINT PROCEDURE를 사용하여(PROC PRINT) SASHELP 라이브러리(SASHELP.)의 CLASS 테이블을 불러옴(DATA=).*/ VAR AGE NAME;/*변수(AGE, NAME)를 불러옴(VAR)*/ RUN;/*명령어를 종료*/ OBS Age Name 1 14 알프레드 2 13 앨리스 3 13 바바라 4 14 캐럴 5 14 헨리 6 12 제임스 7 12 제인 8 15 자넷 9 13 제프리 10 12 존 11 11 조이스 12 14 주디 13 12 루이스 14 15 메리 15 16 필립 16 12 로버트 17 15 로날드 18 11 토마스 19 15 윌리엄 예제 3 PROC PRINT DATA=TEST;/*PRINT PROCEDURE를 사용하여(PROC PRINT) SASHELP 라이브러리(SASHELP.)의 CLASS 테이블을 불러옴(DATA=).*/ VAR AGE NAME;/*변수(AGE, NAME)를 불러옴(VAR)*/ ID AGE;/*변수(AGE)를 기준값으로 사용함*/ BY AGE;/*변수(AGE)를 그룹으로 만듦(※BY 구문이 적용되는 변수는 오름차순 정렬돼 있어야 함)*/ RUN;/*명령어를 종료*/ tip 예제 3을 하기 전에 아래 구문을 시행하세요. PROC PRINT에서 그룹을 설정하는 BY 구분은 오름차순 순서대로 정렬돼 있어야 합니다. 그렇지 않을 경우 에러가 발생합니다. PROC SORT DATA=SASHELP.CLASS OUT=TEST; BY AGE; RUN; 2-3. PROC CONTENTS(테이블 속성 보기) SAS 테이블과 라이브러리에 대한 정보를 제공합니다. 변수가 몇 개인지 관측지가 몇 개인지 어떤 폴더에 테이블이 저장돼 있는지 등 테이블과 라이브러리의 속성 정보를 제공합니다. 윈도에서 파일이나 폴더의 속성을 조회하는 것과 비슷한 역할을 합니다. 명령어 PROC CONTENTS: CONTENTS 프러시저를 시행합니다. DATA=XXX: 탐색할 테이블이나 라이브러리를 지정합니다. RUN: 예제 PROC CONTENTS DATA=SASHELP.CLASS;/*라이브러리 SASHELP의 테이블 CLASS의 속성정보를 불러옴(CONTENTS)*/ RUN;/*SAS 명령어 종료*/ - - - - 데이터 셋 이름 SASHELP.CLASS 관측치 19 멤버 유형 DATA 변수 5 엔진 V9 인덱스 0 생성일 2015.05.28 14:08:14 관측치 길이 40 마지막 수정일 2015.05.28 14:08:14 삭제된 관측치 0 보호 압축 여부 아니요 데이터 셋 유형 정렬 아니요 레이블 학생 데이터 데이터 표현 HP_UX_64, RS_6000_AIX_64, SOLARIS_64, HP_IA64 인코딩 euc-kr Korean (EUC) - - 엔진/호스트 관련 정보 데이터 셋 페이지 크기 65536 데이터 셋 페이지 번호 1 첫 번째 데이터 페이지 1 페이지 당 최대 관측 치수 1632 첫 번째 데이터 페이지의 관측 치수 19 데이터 셋 수리의 번호 0 파일 이름 /sashelp/class.sas7bdat 생성된 릴리스 6.1204S4 생성된 호스트 AIX Inode 번호 2341333 액세스 권한 rw-r--r-- 소유자 이름 sas 파일 크기 128KB 파일 크기(바이트) 131072 변수 유형 길이 레이블 3 Age 숫자 8 4 Height 숫자 8 1 Name 문자 12 2 Sex 문자 4 5 Weight 숫자 8 tip SAS 작업을 하면서 CONTENTS 명령어를 통해 주로 확인하는 속성을 다음과 같습니다. 1. 데이터 셋 이름: 테이블 이름과 라이브러리명을 확인합니다. 2. 생성일: 테이블 생성 일자를 확인합니다. 3. 관측치: 관측 값이 몇 개의 행으로 이뤄져 있는지 확인합니다. 4. 변수: 변수가 몇 개가 있는지 확인합니다. 5. 파일 이름: 테이블이 저장된 폴더 주소와 실제 파일 이름을 확인합니다. 6. 인덱스: 인덱스가 몇 개 설정돼 있는지 확인합니다(인덱스 내용에 대해서는 뒤에 배우겠습니다). 7. 정렬: 테이블이 특정 변수를 기준으로 정렬돼 있는지를 ‘예/아니요’로 확인합니다. 8. 파일 크기: 테이블의 용량을 확인합니다. 라이브러리 전체의 속성 다음으로 라이브러리 전체의 속성 정보를 확인하는 명령어를 배워보겠습니다. 명령어 DATA=XXX._ALL_: 라이브러리 XXX와 라이브러리 내부에 있는 테이블 전체에 대한 속성정보를 조회합니다(_ALL_). 대상 라이브러리명 뒤에 붙여서 사용합니다. 예제 PROC CONTENTS DATA=WORK._ALL_;/*라이브러리 XXX(XXX._ALL_)에 대한 속성정보와 라이브러리 내부에 있는 테이블 전체(XXX._ALL_)에 대한 속성정보를 불러옴(CONTENTS).*/ RUN;/*SAS 명령어 종료*/ - - Directory 라이브러리 참조 WORK 엔진 V9 물리적 경로 C:\ 파일 이름 C:\ Inode 번호 19868 액세스 권한 rwx------ 소유자 이름 sas 파일 크기 8KB 파일 크기(바이트) 8192 # 이름 멤버 유형 파일 크기 마지막 수정일 1 REGSTRY ITEMSTOR 32KB 2020.07.24 09:46:49 2 SASGOPT CATALOG 12KB 2020.07.24 09:46:54 3 SASMAC1 CATALOG 100KB 2020.07.24 09:46:52 4 TEST DATA 192KB 2020.07.24 10:00:33 5 _PRODSAVAIL DATA 192KB 2020.07.24 09:46:50 위의 표가 출력됩니다. 2-4. PROC FREQ(빈도 조회) 테이블 내 데이터의 빈도를 조회합니다. 명령어 PROC FREQ: FREQ 프러시저를 시행합니다. DATA=XXX: XXX라는 데이터를 불러옵니다. TABLE YYY ZZZ: 변수 YYY와 ZZZ를 조회합니다. tip 보통 SAS에서는 변수명을 쓸 때 ‘VAR(VARIANCE를 지칭하는 명령어)’를 사용하지만 FREQ에서는 TABLE이라는 명령어를 사용합니다. 이 이유는 잠시 후에 알아보겠습니다. 예제 PROC FREQ DATA=SASHELP.CLASS; /*FREQ PROCEDURE를 사용하여(PROC FREQ) SASHELP 라이브러리의 CLASS 테이블을 불러옴(DATA=SASHELP.CLASS).*/ TABLE AGE NAME;/*변수 AGE와 NAME을 조회함*/ RUN;/*모든 명령어를 종료*/ Age(나이) 빈도 백분율 누적 빈도 누적 백분율 11 2 10.53 2 10.53 12 5 26.32 7 36.84 13 3 15.79 10 52.63 14 4 21.05 14 73.68 15 4 21.05 18 94.74 16 1 5.26 19 100.00 Height(키(단위: 인치) 빈도 백분율 누적 빈도 누적 백분율 51.3 1 5.26 1 5.26 56.3 1 5.26 2 10.53 56.5 1 5.26 3 15.79 57.3 1 5.26 4 21.05 57.5 1 5.26 5 26.32 59 1 5.26 6 31.58 59.8 1 5.26 7 36.84 62.5 2 10.53 9 47.37 62.8 1 5.26 10 52.63 63.5 1 5.26 11 57.89 64.3 1 5.26 12 63.16 64.8 1 5.26 13 68.42 65.3 1 5.26 14 73.68 66.5 2 10.53 16 84.21 67 1 5.26 17 89.47 69 1 5.26 18 94.74 72 1 5.26 19 100.00 결과로 변수 AGE와 NAME의 빈도·백분율·누적 빈도·누적 백분율을 확인할 수 있습니다. 변수 개수와 이름을 바꿔가며 조회할 수 있습니다. 추가 명령어 TABLE AGE * NAME: AGE와 NAME의 2차원 표를 조회합니다. 예제 PROC FREQ DATA=SASHELP.CLASS;/*FREQ PROCEDURE를 사용하여(PROC FREQ) SASHELP 라이브러리의 CLASS 테이블을 불러옴(DATA=SASHELP.CLASS).*/ TABLE AGE*HEIGHT;/*변수 AGE와 NAME의 2차원 표를 조회함*/ RUN;/*모든 명령어를 종료*/ 화면에 결괏값을 다 담을 수 없어 결과는 생략합니다. 실제 시행을 해보시기 바랍니다. FREQ PROCEDURE가 변수를 뜻하는 VAR 명령어를 사용하지 않고 TABLE 명령어를 사용하는 이유를 확인할 수 있습니다. TABLE은 행과 열로 이뤄진 표를 의미합니다. TABLE 변수 1변수 2 형태의 명령어를 쓰면 변수 1변수 2로 이루어진 교차 표를 생성합니다. 예제에서는 연령별 이름을 빈도·백분율·행 백분율·칼럼 백분율을 조회할 수 있습니다(변수 1 * 변수 2 * 변수 3으로 명령어를 쓸 경우, 변수 1에 따른 변수 2 * 변수 3의 교차 표를 보여줍니다. 예를 들어 TABLE AGE * NAME * WEIGHT로 명령어를 쓴다면 AGE 별 NAME * WEIGHT 교차 표를 보여줍니다). 3. 데이터 생성 법 SAS에서 직접 데이터 테이블을 생성할 수 있습니다. SAS는 대용량 데이터를 주로 다루기 때문에 수작업으로 테이블을 생성할 일은 그다지 많지 않습니다. 기업에서나 학교에서 SAS를 활용할 때는 주어진 데이터를 활용할 때가 많습니다. 병원에서는 의료 데이터를, 노동 연구소에서는 소득 데이터를 활용하는 식입니다. 그렇다고 데이터 생성 법을 몰라도 되는 것은 아닙니다. 데이터 생성은 SAS 분석의 기초입니다. 그리고 변수 속성처럼 이후 분석 과정에서 중요한 부분의 기초 지식을 습득할 수 있습니다. 이 과정에서는 기초적인 테이블 생성 방법을 배우고 테이블의 속성에 대해서 공부하겠습니다. 3-1. 직접 테이블 생성 법 데이터는 크게 숫자 변수와 문자 변수로 나뉩니다. SAS는 숫자와 문자를 분명하게 구분합니다. 예를 들어 ‘+ , - , * , / ’ 같은 사칙연산은 숫자 변수에만 적용이 되고 문자 변수에는 적용이 되지 않습니다. 사칙연산이 문자 변수에 적용이 되면 오류로 SAS 명령어가 바로 종료됩니다. 그렇다면 숫자 변수와 문자 변수에 유의하여 데이터를 생성해 보겠습니다. 명령어 DATA XXX: 테이블 XXX를 생성함 INPUT YYY $ ZZZ: 문자 변수 YYY와 숫자 변수 ZZZ를 생성함(숫자 변수는 변수명만 입력하면 되고 문자 변수는 변수명 뒤에 한 칸을 띄우고 $를 붙임) CARDS; XX 1: XX와 1을 각각의 변수에 입력함(CARDS는 DATALINES로 바꿀 수 있습니다.) RUN: SAS 명령어 종료 예제 DATA TEST;/*데이터 TEST를 생성함(DATA)*/ INPUT NAME $ AGE SEX $;/*문자 변수 NAME과 SEX, 숫자 변수 AGE를 생성함(INPUT)*/ CARDS;/*변수별 데이터를 입력함(CARDS)*/ OK 1 남 YOU 2 녀;/*변수별로 들어갈 데이터 입력*/ RUN;/*SAS 명령어 종료*/ NAME AGE SEX OK 1 남 YOU 2 녀 INPUT 명령어 이후 변수 NAME 뒤에 문자를 붙임으로써 이 문자 변수라는 걸 나타냅니다 뒤에 있는 자 붙 으 써 A E 문 변 라 걸 타 네. E 뒤 있 문자도 동일한 역할을 합니다. AGE는 숫자 변수로 입력됩니다. 만약 숫자 변수로 설정돼 있는데 ‘가나다’처럼 문자 변수가 입력될 경우 해당 데이터는 ‘.’으로 표시가 됩니다. 공백(통계학적으로 NULL 값, 결 측 치라고 합니다)으로 인식합니다. CARDS 명령어는 테이블 내부에 데이터를 입력하는 명령어입니다. CARDS 명령어만 쓴 다음(‘;’ 사용) ‘OK 1 남’을 변수명 순서에 맞춰 입력해 줍니다. INPUT에 쓴 변수명 순서가 1) NAME 2) AGE 3) SEX이므로 OK(NAME의 데이터)-1(AGE의 데이터)-남(SEX)을 차례대로 입력합니다. 모든 데이터 입력을 마치면 ‘;’를 입력해 데이터 입력을 종료합니다. 문자 변수 길이 설정 문자 변수에 긴 데이터를 입력해야 할 때가 있습니다. 예를 들어 ‘호날두 파이팅’ 같이 긴 글자를 입력하는 상황을 가정해 보겠습니다. 위의 예제 1.에서 한 행을 추가해 보겠습니다. 예제 DATA TEST;/*데이터 TEST를 생성함(DATA)*/ INPUT NAME $ AGE SEX $;/*문자 변수 NAME과 SEX, 숫자 변수 AGE를 생성함(INPUT)*/ CARDS;/*변수별 데이터를 입력함(CARDS)*/ OK 1 남 YOU 2 녀 호날두 파이팅 3 남 ;/*변수별로 들어갈 데이터 입력*/ RUN;/*SAS 명령어 종료*/ NAME AGE SEX OK 1 남 YOU 2 녀 호날두화 3 남 이렇게 입력을 할 경우에 결괏값에 ‘호날두 파이팅’이 ‘호날두화’까지만 나오는 것을 확인할 수 있습니다. 그 이유는 SAS는 기본적으로 문자 변수를 8글자(영어 기준)까지 읽어들이도록 설정돼 있기 때문입니다. 한글은 4글자까지 가능합니다. 알파벳 2글자가 한글 1글자와 같다고 생각하시면 됩니다. 따라서 ‘호날두 파이팅’이 6글자이므로 ‘호날두화’를 넘어서는 2글자는 제외하고 읽어들입니다. 이를 해결하기 위해서는 문자 변수를 읽어들이는 길이를 바꿔줘야 합니다. 전문용어로 ‘포맷을 변경한다’라고 합니다. 변수의 문자·숫자 여부와 길이 등 속성을 포맷이라고 합니다. 포맷을 변경하는 방법은 크게 두 가지가 있습니다. 1) 문자 변수 길이 변경 문자 변수가 읽어들일 수 있는 최대 글자 수를 변경합니다. 여기서 글자 수는 영어 알파벳 기준입니다. 변경 방법은 아래와 같습니다. 명령어 INPUT NAME: $12. AGE SEX $;: 변수 NAME의 포맷을 알파벳 10글자까지 받아들일 수 있도록 변경합니다. 예제 DATA TEST;/*데이터 TEST를 생성함(DATA)*/ INPUT NAME: $12. AGE SEX $;/*문자 변수 NAME의 포맷을 최대 12글자(알파벳 기준)까지 받아들일 수 있도록 변경합니다(NAME: $12.) */ CARDS;/*변수별 데이터를 입력함(CARDS)*/ OK 1 남 YOU 2 녀 호날두 파이팅 3 남 ;/*변수별로 들어갈 데이터 입력*/ RUN;/*SAS 명령어 종료*/ NAME AGE SEX OK 1 남 YOU 2 녀 호날두 파이팅 3 남 최대 길이를 늘릴 대상인 변수 NAME 뒤쪽에 (: $12.)이라는 명령어를 덧붙입니다. 이 명령어로 NAME이 받아들일 수 있는 최대 문자 변수를 12글자(알파벳 기준)까지 늘리게 됩니다. 다른 문자 변수에도 똑같이 적용할 수 있습니다. 2) 입력 대상 데이터 위치 설정 문자 변수를 읽어들이는 위치를 설정합니다. 입력된 데이터가 위치별로 일정하게 정렬돼 있을 때 사용하면 유용한 명령어입니다. 예를 들어 1번째 칸부터 12번째 칸까지 변수 NAME의 데이터로, 14번째 칸은 변수 AGE의 데이터로, 16번째 칸부터 17번째 칸까지는 변수 SEX의 데이터로 설정하는 식입니다. 명령어 INPUT NAME $ 1-12 AGE 14 SEX $ 16-17;: 1번째 칸부터 12번째 칸까지는 문자 변수 NAME의 데이터로, 14번째 칸은 변수 AGE의 데이터로, 16번째 칸부터 17번째 칸까지는 변수 SEX의 데이터로 설정합니다. 예제 DATA TEST;/*데이터 TEST를 생성함(DATA)*/ INPUT NAME $1-12 AGE 14 SEX $ 16-17;/*1~12번째 칸의 데이터를 문자 변수 NAME의 데이터로(NAME $1-12), 14번째 칸은 숫자 변수 AGE의 데이터로(AGE 14), 16~17번째 칸은 문자 변수 SEX의 데이터로(SEX $ 16-17) 설정함*/ CARDS;/*변수별 데이터를 입력함(CARDS)*/ OK 1 남 YOU 2 녀 호날두 파이팅 3 남 ;/*변수별로 들어갈 데이터 입력*/ RUN;/*SAS 명령어 종료*/ NAME AGE SEX OK 1 남 YOU 2 녀 호날두 파이팅 3 남 위 방법은 데이터가 일정한 위치에 정렬돼 있을 때 사용할 수 있습니다. 만약 데이터가 일정하게 위치에 맞게 정렬돼 있지 않을 경우 올바른 테이블을 생성할 수 없습니다. tip 한글 데이터의 경우 SAS 프로그램에서 최소 2개 위치를 차지합니다. 한글 한 글자는 영어 두 글자와 동일한 위치 공간을 차지합니다. 따라서 한글 한 글자를 변수 SEX에 입력하기 위해서는 적어도 2개 칸을 설정해 줘야 합니다. 숫자 변수의 경우 한 자당 한 개의 위치를 차지하기 때문에 변수 AGE를 설정할 때처럼(INPUT AGE 14) 하나의 칸만 설정해 줘도 무방합니다. 3-2. 외부 데이터를 불러와서 테이블 생성하기 보통학교나 기업체에서 데이터를 분석할 때는. TXT 파일이나. XLSX, .CSV 파일로 원시데이터(가공하지 않은 초창기 데이터)가 제공되는 경우가 많습니다. SAS에서 분석할 데이터가 대용량이라면 수작업으로 작업하는 건 거의 불가능하죠. 시간이 많이 걸려서 효율적이지 않습니다. 그래서 분석 대상 원시데이터는 대체로 위와 같은 파일 형태로 제공됩니다. 이 파일을 성공적으로 SAS에 탑재해야 분석 작업을 진행할 수 있습니다. 그렇다면 위와 같은 파일 형태를 어떻게 SAS에서 작업할 수 있는 파일로 변환할 수 있는지 알아보겠습니다. 명령어 INFILE ‘C:\SAS_TEST\TEST.TXT’;: ‘C:\SAS_TEST\TEST.TXT’ 파일을 불러오는 명령어입니다(INFILE) INPUT YYY $ ZZZ: 문자 변수 YYY와 숫자 변수 ZZZ를 생성함 DLM=‘X’: 데이터의 구분자는 ‘,’로 구성돼 있음을 입력 (숫자 변수는 변수명만 입력하면 되고 문자 변수는 변수명 뒤에 한 칸을 띄우고 $를 붙임) 예제 TEST.TXT 파일 내용 OK, 1, 남 YOU, 2, 녀 호날두 파이팅, 3, 남 DATA TEST;/*데이터 TEST를 생성함(DATA)*/ INFILE 'C:/SAS_TEST/TEST.TXT' DLM=‘,’;/*'C:/SAS_TEST/TEST.TXT' 위치에 있는 파일을 읽어오고(INFILE) 파일의 구분자는 ‘,’로 이뤄져 있다는 것을 규정(DLM=’,‘)*/ INPUT NAME: $12. AGE SEX $;/*문자 변수 NAME(알파벳 12글자 길이로 지정)과 SEX, 숫자 변수 AGE를 생성함(INPUT)*/ RUN;/*SAS 명령어 종료*/ NAME AGE SEX OK 1 남 YOU 2 녀 호날두 파이팅 3 남 기본적인 데이터 불러오는 명령어입니다. INFILE 명령어를 사용하여 불러올 데이터를 지정합니다. 원시데이터. TXT가 변수별로 공백(띄어쓰기)으로 구분돼 있는 것으로 가정했습니다. INFILE로 불어올 수 있는 확장자로는. TXT, .XLSX, .CSV 등 여러 가지 확장자가 있습니다. 대체로 위 3가지를 많이 사용합니다. DLM=‘,’는 데이터의 구분자가 어떻게 구성돼 있는지를 입력하는 명령어입니다. SAS는 기본값으로 ‘ ’처럼 빈칸을 데이터 간 구분자로 인식합니다. 그렇지만 우리가 데이터를 불러올 때 꼭 빈칸으로만 데이터가 구분돼 있다는 법은 없습니다. ‘,’, ‘-’와 같은 기호로 데이터 간 구분이 이뤄져 있을 수도 있습니다. 이런 경우에 DLM=‘,’를 입력하게 되면 SAS는 데이터 간 구분자가 ‘,’라고 인식합니다. 그래서 ‘,’가 나오기 전까지 띄어쓰기를 포함한 모든 값을 변수에 입력합니다. INFILE 이후에는 INPUT 명령어를 통해 변수를 지정해 줘야 합니다. INFILE은 데이터를 불러오는 기능만 있지 변수명을 만들고 이에 따라 데이터를 입력하는 기능은 없기 때문입니다. INFILE 명령어는 CARDS와 유사한 역할을 하는 명령어로 보셔도 됩니다. CARDS 명령어를 이용해 직접 손으로 입력하기에 곤란한 방대한 데이터를 INFILE 명령어를 이용해 간단하게 불러오는 것과 동일하기 때문입니다. 3-3. 테이블을 불러와서 새 테이블 생성하기 앞에서 외부 데이터를 가져와 테이블(SAS 데이터)로 만드는 작업을 했다면 이제는 만들어진 테이블을 가공하는 과정을 학습하겠습니다. 원시데이터를 테이블로 만드는 건 한 번의 과정이면 충분합니다. 그러나 만들어진 테이블을 가공하는 건 분석 과정에서 여러 번 반복하게 될 과정입니다. 그리고 가장 중요한 과정이기도 합니다. 테이블을 변환하고 생성하는 것은 통계 분석을 진행하기 전 필수 과정입니다. 테이블을 통계 분석 목적과 방법에 알맞게 가공해야 제대로 된 통계 분석이 가능하기 때문입니다. 그렇다면 지금부터 테이블을 가공하는 방법을 학습해 보겠습니다. SET을 사용하여 테이블을 생성하기 가장 앞에서 학습한 내용이지만 다시 한번 배워보겠습니다. SET 명령어를 사용해 테이블을 불러오고 이를 기반으로 새로운 테이블을 생성합니다. 명령어 DATA XXX: 새로운 테이블 XXX를 생성합니다 SET YYY: 기존 테이블 YYY를 불러옵니다. 예제 DATA TEST;/*테이블 TEST를 생성합니다.*/ SET SASHELP.CLASS;/*테이블 SASHELP.CLASS를 불러옵니다.*/ RUN;/*SAS 명령어를 종료합니다.*/ NAME SEX AGE HEIGHT WEIGHT 알프레드 남 14 69 112.5 앨리스여 13 56.5 84 바바라여 13 65.3 98 캐럴여 14 62.8 102.5 헨리 남 14 63.5 102.5 제임스 남 12 57.3 83 제인여 12 59.8 84.5 자넷여 15 62.5 112.5 제프리 남 13 62.5 84 존 남 12 59 99.5 조이스여 11 51.3 50.5 주디여 14 64.3 90 루이스여 12 56.3 77 메리여 15 66.5 112 필립 남 16 72 150 로버트 남 12 64.8 128 로날드 남 15 67 133 토마스 남 11 57.5 85 윌리엄 남 15 66.5 112 라이브러리 SASHELP의 테이블 CLASS를 불러오는 명령어입니다. 테이블 CLASS를 그대로 TEST로 옮기는 명령어입니다. tip TEST 앞에는 라이브러리 명이 없으므로 임시 라이브러리인 WORK에 배정됩니다. 4. 포맷(FORMAT)의 개념 SAS나 다른 데이터 관리 시스템에서 중요한 것은 칼럼(변수)의 데이터 유형입니다. 데이터는 크게 2개의 유형으로 나뉩니다. 숫자 데이터와 문자 데이터입니다. 데이터를 이렇게 나누는 이유는 여러 가지가 있겠는데요, 가장 큰 이유는 컴퓨터의 한계 때문입니다. 정확한 원리는 아니지만, 사례를 들어 포맷의 존재 이유를 이해하기 쉽게 설명해 드리겠습니다. 흔히들 디지털이라는 것에 대해서 들어보셨을 겁니다. 디지털의 특징은 세상의 모든 것을 0과 1로 표현을 하죠. 컴퓨터는 디지털로 이뤄져 있습니다. 세상의 모든 것을 0과 1로 변환을 해서 표현합니다. 우리가 컴퓨터로 보는 글자, 사진들을 근원으로까지 파헤쳐 가면 모두 0과 1로 구성되어 있습니다. 여기서 문제가 발생합니다. 컴퓨터가 0과 1을 숫자로 파악할 것인지, 아니면 문자로 파악할 것인지 스스로는 판단을 할 수 없기 때문입니다. 예를 들어서 컴퓨터가 문자 ‘안녕하세요’를 표현할 때 10110이라는 디지털 언어를 사용한다고 합시다. 이때 우리가 진짜 숫자 10110을 표현하고 싶어서 10110을 입력했다면 컴퓨터는 내부에서 10110을 구분할 방법이 없습니다. 이것을 문자로 표현을 할지, 숫자로 표현을 할지 모른다는 의미입니다. 그래서 우리는 칼럼(변수)을 입력할 때 문자인지 숫자인지 컴퓨터에 알려줍니다. 이것이 바로 포맷이라는 겁니다. 칼럼이 문자인지 숫자인지를 정의를 내려서 10110을 처리할 경우, 컴퓨터가 이를 어떻게 처리해야 하는지 미리 정해놓는 거죠. 포맷은 앞으로 배울 데이터 관리의 기초이자 중요한 부분입니다. 세부적으로 보면 포맷은 매우 다양한 형태가 있습니다. 지금부터 중요하고 자주 사용하는 포맷들을 배워보겠습니다. 4-1. 숫자 포맷 포맷은 크게 문자와 숫자로 나뉩니다. 문자와 숫자로 나뉜 다음에도 다양하게 세분화됩니다. 아래의 표로 이를 보여드리겠습니다. 아래의 표가 포맷의 전부는 아닙니다. 포맷의 종류는 더 다양하게 존재하지만, 우리가 평소에 SAS를 사용할 때는 앞으로 배울 포맷 정도만 숙지하셔도 충분할 것입니다. 숫자 포맷 포맷 명령어 포맷 설명 포맷 예시 입력값 포맷 출력값 숫자. 자릿수만큼 정수 숫자 값을 표시 5. 324.5678 325 숫자. 숫자 앞자리 숫자만큼 전체 길이를 표현하고, 뒷자리 숫자만큼 소수로 표현(만약 입력값 길이가 앞자리 숫자를 초과할 경우 소수점 이하 길이가 축소될 수 있음) 6.2 324.5678 324.57 BEST 숫자. ‘.’을 포함하여 숫자 자릿수만큼 수를 표현(최상의 숫자 표기법으로 알려져 있음) BEST5. 324.5678 324.6 COMMA 숫자. 숫자 3자리 숫자 값마다 ‘,’를 표시 COMMA5. 3245.678 3,246 PERCENT 숫자. 숫자 주어진 숫자를 %로 표현합니다(단, 앞자리 숫자는 전체 길이, 뒷자리 숫자는 소수 부분을 나타내는데 앞자리는 3보다 커야 합니다. ‘%’가 3의 위치만큼 차지합니다.) PERCENT8.2 0.3245678 32.46% Z 숫자. 숫자 앞자리 수만큼 전체 숫자 값을 표현하고 빈 길이만큼 0을 표시합니다. Z7.2 324.5678 0324.57 예제 TEST 테이블 생성 DATA TEST; INPUT NAME $ AGE; CARDS; 라이올라 324.5678 RUN; PROC PRINT DATA=TEST; VAR AGE; FORMAT AGE 5.; /*1번 사례*/ FORMAT AGE 6.2; /*2번 사례*/ FORMAT AGE BEST5.; /*3번 사례*/ FORMAT AGE COMMA5.; /*4번 사례*/ FORMAT AGE PERCENT8.2; /*5번 사례*/ FORMAT AGE Z7.2; /*6번 사례*/ RUN; 숫자 포맷에서 주의해야 할 점은 SAS는 포맷의 길이를 측정할 때 ‘.’도 길이에 포함한다는 것입니다. 예를 들어 324.56이라는 숫자를 포맷의 개념으로 볼 때 전체 길이는 ‘3’,‘2’,‘4’,‘.’,‘5’,‘6’까지 6개로 인식이 됩니다. 따라서 전체 길이를 설정할 때 ‘.’을 고려해서 설정하도록 합니다. 또 포맷 설정 시에는 ‘.’을 기준으로 앞자리 수와 뒷자리 수의 개념이 있습니다. 앞자리 수는 전체 데이터의 길이를 의미합니다. 뒷자리 수는 소수점 이하의 길이를 의미합니다. 만약 앞자리 수(전체 길이)가 짧아 뒷자리 수(소수점 이하 길이)를 온전하게 표현할 수 없다면 뒷자리 수가 일부 누락되기도 합니다. tip 주의: 포맷을 설정할 때 ‘.’을 입력해 주시는 건 대단히 중요합니다. ‘5.’, ‘BEST4.’, ‘Z7.2’처럼 앞자리 수(전체 길이)의 다음에 ‘.’이 없으면 SAS는 이를 포맷 명령어로 받아들이지 못합니다. 그러므로 포맷을 설정할 때는 반드시 ‘.’을 입력해 주세요. 4-2. 문자 포맷 문자 포맷 포맷 명령어 포맷 설명 포맷 예시 입력값 포맷 출력값 $숫자. 자릿수만큼 문자를 표시 $6. 라이올라 라이올 예제 TEST 테이블 생성 DATA TEST; INPUT NAME $ AGE; CARDS; 라이올라 324.5678 RUN; PROC PRINT DATA=TEST; VAR NAME; FORMAT NAME $6.; /*1번 사례*/ RUN; 문자 포맷은 표시를 이용하여 숫자 포맷과 구분합니다 시 이 하 숫 포과 분 네. 4., $5.처럼 표현을 할 수 있습니다. 이때 4,5와 같은 숫자는 단순하게 문자 수를 의미하는 게 아닙니다. 길이를 의미하는데 1BYTE로 해석을 하시면 됩니다. 영어는 1BYTE에 한 자가, 한국어는 2BYTE에 한 글자가 들어가게 됩니다. 이 길이를 넘어서는 문자부터는 표현이 되지 않습니다. tip 주의: 포맷을 설정할 때 ‘.’을 입력해 주시는 건 대단히 중요합니다. ‘ 6. , 7.’처럼 포맷<NAME>의 마지막에 ‘.’을 찍어주세요. 이는 모든 포맷에 동일한 사항입니다. 4-3. 날짜 포맷 날짜 포맷 포맷 명령어 포맷 설명 포맷 예시 입력값 포맷 출력값 DATE 숫자. 숫자 값을 날짜 값으로 변경(일월 년) DATE9. 3 4JAN1960 YYMMDD 숫자. 숫자 값을 날짜 값으로 변경(연도-월-일) YYMMDD10. 3 1960-01-04 WEEKDATE. 숫자 값을 날짜 값으로 변경(요일, 월일, 연도) WEEKDATE. 3 Monday, January 4, 1960 WORDDATE. 숫자 값을 날짜 값으로 변경(월일, 연도) WORDDATE 3 January 4, 1960 NLDATE 숫자. 숫자 값을 날짜 값으로 변경(연도 월 일) NLDATE20. 3 1960년 01월 04일 YYMMN 숫자. 숫자 값을 날짜 값으로 변경(연도 월) YYMMN6. 3 196001 MONYY 숫자. 숫자 값을 날짜 값으로 변경(월 연도) MONYY7. 3 JAN1960 YEAR 숫자. 숫자 값을 날짜 값으로 변경(연도) YEAR4. 3 1960 DATETIME 숫자. 숫자 숫자 값을 날짜, 시간 값으로 변경(일월 년:시:분:초) DATETIME20. 3 01JAN1960:00:00:03 TIME 숫자. 숫자 숫자 값을 날짜, 시간 값으로 변경(시:분:초) TIME8. 3333 0:55:03 HHMM 숫자. 숫자 숫자 값을 날짜, 시간 값으로 변경(시:분) HHMM5. 3333 0:56 HOUR 숫자. 숫자 숫자 값을 날짜, 시간 값으로 변경(시각) HOUR5. 3333 1 예제 TEST 테이블 생성 DATA TEST; INPUT NAME $ NUMBER; CARDS; 날짜 3 RUN; PROC PRINT DATA=TEST; VAR NUMBER; FORMAT NUMBER DATE10.; /*1번 사례*/ FORMAT NUMBER YYMMDD10.; /*2번 사례*/ FORMAT NUMBER WEEKDATE.; /*3번 사례*/ FORMAT NUMBER WORDDATE.; /*4번 사례*/ FORMAT NUMBER NLDATE20.; /*5번 사례*/ FORMAT NUMBER YYMMN6.; /*6번 사례*/ FORMAT NUMBER MONYY7.; /*7번 사례*/ FORMAT NUMBER YEAR4.; /*8번 사례*/ FORMAT NUMBER DATETIME20. ; /*9번 사례*/ FORMAT NUMBER TIME8. ; /*10번 사례*/ FORMAT NUMBER HHMM5. ; /*11번 사례*/ FORMAT NUMBER HOUR5. ; /*12번 사례*/ RUN; SAS에서 날짜 포맷은 기존의 숫자, 문자 포맷과는 조금 다릅니다. 개념부터 설명하자면 SAS에서는 1960년 1월 1일을 숫자 0으로 표시합니다. 1은 1960년 1월 2일, 2는 1960년 1월 3일인 식입니다. 그래서 1,2,3 같은 숫자가 숫자 포맷인지 날짜 포맷인지를 설정하는 것은 중요한 작업입니다. 위의 예제 3은 숫자를 날짜 포맷으로 변경하는 방법입니다. 테이블 TEST에 칼럼 NUMBER에 3이라는 숫자가 있을 경우 SAS는 이를 1960년 1월 4일로 인식합니다. 그리고 이를 표현하는 방법은 다양합니다. 예를 들어 YYMMDD10.<NAME>의 포맷을 사용할 경우 ‘1960-01-04’와 같이 표현이 됩니다. 각 문자들의 총 길이 10입니다. 그래서 뒤쪽의 숫자를 늘이기도, 줄이기도 할 수 있습니다. 각 포맷의 마지막 부분에 숫자는 그 포맷의 길이를 의미하기 때문입니다. 다만 날짜 포맷은 정해진 길이가 있는 경우가 많아서 원하는 대로 길이를 유동적으로 설정하기는 어려운 편입니다. 예를 들어 YYMMDD8.으로 포맷을 설정할 경우 결괏값은 ‘60-01-04’로 나오게 됩니다. 이처럼 마지막 부분 숫자를 통해 원하는 형태의 날짜 값을 얻을 수 있습니다. 다만 YYMMDD12.처럼 포맷의 한계를 벗어나는 길이를 입력할 경우 에러가 발생하게 됩니다. 날짜 값을 숫자로 바꾸는 방법은 이후에 있을 과정에서 알아가겠습니다. tip 주의: 포맷을 설정할 때 ‘.’을 입력해 주시는 건 대단히 중요합니다. ‘.’이 마지막에 입력이 돼 있어야 SAS는 이를 날짜 포맷으로 인식합니다. 포맷을 입력할 때는 ‘.’을 잊지 마세요. 5. 데이터 전처리를 위한 SAS 명령어 지금부터 본격적으로 SAS를 활용한 데이터 전처리를 배워보겠습니다. 데이터는 무조건 엑셀과 같이 행렬로 이뤄져 있습니다. 여기서는 열을 '칼럼' 또는 변수라고 부르도록 하겠습니다. 다양한 전처리 방법을 알아보도록 하겠습니다. 5-1. KEEP과 DROP 간단하게 말해서 테이블에서 유지할 칼럼은 KEEP, 버릴 칼럼은 DROP으로 설정합니다. 테이블에서 선택하고자 하는 칼럼이 있거나 제외하고자 하는 칼럼이 있을 때 사용하면 유용합니다. 아래 3개의 예제는 비슷하지만 다릅니다. 모두 비교해 보겠습니다. 명령어 DATA XXX: 새로운 테이블 XXX를 생성합니다 SET YYY: 기존 테이블 YYY를 불러옵니다. KEEP ZZZ: 칼럼 ZZZ를 테이블에서 유지합니다. DROP PPP: 칼럼 PPP를 테이블에서 버립니다. 예제 1 DATA TEST;/*테이블 TEST를 생성합니다.*/ SET SASHELP.CLASS(KEEP=NAME AGE);/*테이블 SASHELP.CLASS를 불러오되 칼럼 AGE와 NAME만을 유지합니다.*/ RUN;/*SAS 명령어를 종료합니다.*/ NAME AGE 알프레드 14 앨리스 13 바바라 13 캐럴 14 헨리 14 제임스 12 제인 12 자넷 15 제프리 13 존 12 조이스 11 주디 14 루이스 12 메리 15 필립 16 로버트 12 로날드 15 토마스 11 윌리엄 15 SET 명령어 다음에 KEEP 명령어를 사용했으므로 SASHELP.CLASS 테이블에서 칼럼를 가져올 때 NAME과 AGE만 불러옵니다. 예제 2 DATA TEST;/*테이블 TEST를 생성합니다.*/ SET SASHELP.CLASS(DROP=NAME AGE);/*테이블 SASHELP.CLASS를 불러오되 칼럼 AGE와 NAME을 버립니다.*/ RUN;/*SAS 명령어를 종료합니다.*/ SEX WEIGHT HEIGHT 남 69 112.5 여 56.5 84 여 65.3 98 여 62.8 102.5 남 63.5 102.5 남 57.3 83 여 59.8 84.5 여 62.5 112.5 남 62.5 84 남 59 99.5 여 51.3 50.5 여 64.3 90 여 56.3 77 여 66.5 112 남 72 150 남 64.8 128 남 67 133 남 57.5 85 남 66.5 112 SET 명령어 다음에 DROP 명령어를 사용함으로써 SASHELP.CLASS 테이블에서 칼럼 NAME과 AGE를 제외하고 나머지 칼럼들을 가져오게 됩니다. 예제 3 DATA TEST(KEEP=NAME AGE);/*테이블 TEST를 생성하되 칼럼 NAME과 AGE만 유지합니다.*/ SET SASHELP.CLASS;/*테이블 SASHELP.CLASS를 불러옵니다.*/ RUN;/*SAS 명령어를 종료합니다.*/ NAME AGE 알프레드 14 앨리스 13 바바라 13 캐럴 14 헨리 14 제임스 12 제인 12 자넷 15 제프리 13 존 12 조이스 11 주디 14 루이스 12 메리 15 필립 16 로버트 12 로날드 15 토마스 11 윌리엄 15 DATA 명령어 다음에 KEEP 명령어를 사용함으로써 SASHELP.CLASS 테이블에서 모든 칼럼를 가져온 다음, 테이블 TEST를 생성시킬 때 칼럼 NAME과 AGE만 유지합니다. tip KEEP과 DROP 명령어로 원하는 칼럼만을 유지하거나, 원하지 않는 칼럼을 버릴 수 있습니다. KEEP과 DROP은 SET 명령어나 DATA 명령어 모두에 쓸 수 있습니다. 다만 KEEP 명령어를 SET 단계에서 쓰는 것과 DATA 단계에서 쓰는 것은 엄연히 다릅니다. 만약 SET 단계까지는 칼럼 WEIGHT, NAME, AGE가 필요하고 이후 결괏값을 보여주는 과정에서 NAME과 AGE만 필요하다면 SET 단계에서 KEEP 명령어로 WEIGHT, NAME, AGE를 지정해 주고 DATA 단계에서 KEEP 명령어로 NAME, AGE만 지정해 주면 됩니다. 하지만 처음부터 SET에서 칼럼 NAME과 AGE만 필요하다면 SET 단계에서 KEEP 명령어로 칼럼 NAME, AGE만 지정해 주면 됩니다. 지금은 중요하지 않아 보이지만 이 위치는 추후 테이블 생성 과정에 따라 중요한 의미를 지닐 때가 있습니다. 5-2. 수식을 활용한 계산 SAS에서 직접 데이터를 변환시킬 수 있습니다. +,-,÷, × 와 같은 사칙연산을 시행할 수 있습니다. SAS는 명령어를 위에서부터 읽고, 같은 줄이라면 왼쪽에서부터 읽습니다. 이 같은 점을 확인할 수 있는 연습도 함께 해보겠습니다. 명령어 YYY=XXX+N;: 칼럼 YYY를 숫자 칼럼 XXX에 숫자 N을 더한 변수로 정의합니다. YYY+N;: 숫자 칼럼 YYY에 숫자 N을 더합니다. 예제 1 DATA TEST;/*테이블 TEST를 생성합니다.*/ SET SASHELP.CLASS;/*테이블 SASHELP.CLASS를 불러옵니다.*/ AGE2=AGE+1;/*칼럼 AGE2를 생성합니다. 칼럼 AGE2는 칼럼 AGE에 1을 더한 값입니다.*/ RUN;/*SAS 명령어를 종료합니다.*/ Name Sex Age Height Weight AGE2 알프레드 남 14 69 112.5 15 앨리스여 13 56.5 84 14 바바라여 13 65.3 98 14 캐럴여 14 62.8 102.5 15 헨리 남 14 63.5 102.5 15 제임스 남 12 57.3 83 13 제인여 12 59.8 84.5 13 자넷여 15 62.5 112.5 16 제프리 남 13 62.5 84 14 존 남 12 59 99.5 13 조이스여 11 51.3 50.5 12 주디여 14 64.3 90 15 루이스여 12 56.3 77 13 메리여 15 66.5 112 16 필립 남 16 72 150 17 로버트 남 12 64.8 128 13 로날드 남 15 67 133 16 토마스 남 11 57.5 85 12 윌리엄 남 15 66.5 112 16 SASHELP.CLASS에서 데이터를 불러오고 다음으로 칼럼 AGE2를 생성합니다. 칼럼 AGE2는 기존에 있던 칼럼 AGE의 값에 1씩을 더한 것이 됩니다. 예제 2 DATA TEST;/*테이블 TEST를 생성합니다.*/ SET SASHELP.CLASS;/*테이블 SASHELP.CLASS를 불러옵니다.*/ AGE+1;/*칼럼 AGE에 1을 더한 값을 저장합니다.*/ AGE2=AGE+1;/*칼럼 AGE2를 생성합니다. 칼럼 AGE2는 칼럼 AGE에 1을 더한 값입니다.*/ RUN;/*SAS 명령어를 종료합니다.*/ Name Sex Age Height Weight AGE2 알프레드 남 15 69 112.5 15 앨리스여 14 56.5 84 14 바바라여 14 65.3 98 14 캐럴여 15 62.8 102.5 15 헨리 남 15 63.5 102.5 15 제임스 남 13 57.3 83 13 제인여 13 59.8 84.5 13 자넷여 16 62.5 112.5 16 제프리 남 14 62.5 84 14 존 남 13 59 99.5 13 조이스여 12 51.3 50.5 12 주디여 15 64.3 90 15 루이스여 13 56.3 77 13 메리여 16 66.5 112 16 필립 남 17 72 150 17 로버트 남 13 64.8 128 13 로날드 남 16 67 133 16 토마스 남 12 57.5 85 12 윌리엄 남 16 66.5 112 16 변수 AGE2를 생성한 다음 칼럼 AGE를 수정합니다. AGE+1로써 칼럼 AGE에 1씩을 더한 값을 출력합니다. 5-3. 단순 IF 구문 IF를 활용한 구문을 학습합니다. IF란 ‘만약~라면’이라는 의미인데 SAS에서는 이를 조건부 문장으로 활용합니다. 데이터를 편집하는 하나의 기준을 제시하는 것입니다. 예를 들어 IF AGE=12라는 명령어를 입력한다면 이는 ‘AGE가 12인 행들을 선택한다.’라는 의미입니다. 만약 칼럼이 숫자 칼럼이라면 1,2,3 등 숫자를 그대로 입력하고, 문자 칼럼이라면 ‘필립’,‘루이스’처럼 ‘ ’안에 셀의 데이터를 적어줍니다. 예시를 통해 활용법을 알아보겠습니다. 명령어 IF XXX=N;: 숫자 칼럼 XXX가 N인 행들만 선택합니다. IF YYY=‘ZZ’;: 문자 칼럼 YYY가 ZZ인 행들만 선택합니다. IF PPP^=N;: 숫자 칼럼 PPP가 N이 아닌 행들만 선택합니다(^=). IF XXX=N AND YYY=‘ZZ’;: 칼럼 XXX가 N이고 칼럼 YYY가 ZZ인 행을 선택합니다(AND, OR). IF XXX IN (N1, N2);: 칼럼 XXX가 N1이거나 N2인 행을 선택합니다(IN, NOT IN). 예제 1 DATA TEST;/*테이블 TEST를 생성합니다.*/ SET SASHELP.CLASS;/*테이블 SASHELP.CLASS를 불러옵니다.*/ IF AGE=12;/*칼럼 AGE가 12인 행들만 선택합니다. */ RUN;/*SAS 명령어를 종료합니다.*/ Name Sex Age Height Weight 제임스 남 12 57.3 83 제인여 12 59.8 84.5 존 남 12 59 99.5 루이스여 12 56.3 77 로버트 남 12 64.8 128 예제. 1에서는 IF 문으로 칼럼 AGE=12를 지정합니다. 이 결괏값으로 AGE 값이 12인 행들이 선택되어 출력됩니다. 예제 2 DATA TEST;/*테이블 TEST를 생성합니다.*/ SET SASHELP.CLASS;/*테이블 SASHELP.CLASS를 불러옵니다.*/ IF NAME='필립';/*칼럼 NAME이 '필립'인 행들만 선택합니다.*/ RUN;/*SAS 명령어를 종료합니다.*/ Name Sex Age Height Weight 필립 남 16 72 150 예제. 2에서는 IF 문으로 칼럼 NAME=‘필립’을 지정했습니다. 그 결과 칼럼 NAME이 ‘필립’인 행이 출력됐습니다. 예제 3 DATA TEST;/*테이블 TEST를 생성합니다.*/ SET SASHELP.CLASS;/*테이블 SASHELP.CLASS를 불러옵니다.*/ IF AGE^=12;/*칼럼 AGE가 12가 아닌 행들만 선택합니다.*/ RUN;/*SAS 명령어를 종료합니다.*/ Name Sex Age Height Weight 알프레드 남 14 69 112.5 앨리스여 13 56.5 84 바바라여 13 65.3 98 캐럴여 14 62.8 102.5 헨리 남 14 63.5 102.5 자넷여 15 62.5 112.5 제프리 남 13 62.5 84 조이스여 11 51.3 50.5 주디여 14 64.3 90 메리여 15 66.5 112 필립 남 16 72 150 로날드 남 15 67 133 토마스 남 11 57.5 85 윌리엄 남 15 66.5 112 예제 3.에서는 칼럼 AGE의 값이 12가 아닌 행들만 선택했습니다. SAS에서는 ‘같지 않다’라는 의미로 ‘^=(NOT EQAUL)’을 사용합니다. 어느 명령어에서든 ‘^=’을 붙이면 ‘같지 않다’라는 의미로 사용됩니다. 예제 4 DATA TEST;/*테이블 TEST를 생성합니다.*/ SET SASHELP.CLASS;/*테이블 SASHELP.CLASS를 불러옵니다.*/ IF AGE=12 AND NAME='존';/*칼럼 AGE가 12이고 칼럼 NAME이 ‘존’인 행을 선택합니다.*/ RUN;/*SAS 명령어를 종료합니다.*/ Name Sex Age Height Weight 존 남 12 59 99.5 예제 4.에서는 AND 명령어를 사용했습니다. ‘(1) AND (2)’ 구조는 ‘(1)이면서 (2)인 값들을 선택’ 하는 것입니다. 수학에서 교집합의 개념입니다. 따라서 예제 4에서는 칼럼 AGE의 값이 12이면서 칼럼 NAME의 값이 ‘존’인 행만 선택하게 됩니다. 예제 5 DATA TEST;/*테이블 TEST를 생성합니다.*/ SET SASHELP.CLASS;/*테이블 SASHELP.CLASS를 불러옵니다.*/ IF AGE=12 OR AGE=13;/*변수 AGE가 12이거나 13인 행을 선택합니다.*/ RUN;/*SAS 명령어를 종료합니다.*/ Name Sex Age Height Weight 앨리스여 13 56.5 84 바바라여 13 65.3 98 제임스 남 12 57.3 83 제인여 12 59.8 84.5 제프리 남 13 62.5 84 존 남 12 59 99.5 루이스여 12 56.3 77 로버트 남 12 64.8 128 예제 5.는 명령어 OR을 사용했습니다. ‘(1) OR (2)’ 구조는 ‘(1)이거나 (2)인 값들을 선택’ 하는 것입니다. 명령어 ‘AND’가 교집합의 개념이라면 OR은 합집합의 개념입니다. 따라서 칼럼 AGE가 12이거나 13인 행을 선택하게 됩니다. 예제 6 DATA TEST;/*테이블 TEST를 생성합니다.*/ SET SASHELP.CLASS;/*테이블 SASHELP.CLASS를 불러옵니다.*/ IF AGE IN (12,13);/*칼럼 AGE가 12이거나 13인 행을 선택합니다.*/ RUN;/*SAS 명령어를 종료합니다.*/ Name Sex Age Height Weight 앨리스여 13 56.5 84 바바라여 13 65.3 98 제임스 남 12 57.3 83 제인여 12 59.8 84.5 제프리 남 13 62.5 84 존 남 12 59 99.5 루이스여 12 56.3 77 로버트 남 12 64.8 128 예제 6.에서는 명령어 IN을 사용했습니다. IN은 예제 5에서 배운 OR의 개념과 동일합니다. 칼럼 AGE에서 12와 13인 행을 선택하는 것입니다. 그래서 예제 5와 예제 6의 결괏값은 동일합니다. OR로 할 때보다 명령어 길이를 줄일 수 있어서 자주 사용되는 명령어입니다. 숫자 칼럼이 아니라 문자 칼럼이라면 ‘문자’ 식으로 코딩하시면 됩니다. 만약 예제 6의 결과와는 반대로 칼럼 AGE가 12와 13이 아닌 행을 선택하려면 ‘NOT IN’으로 명령어를 수정하면 됩니다. tip SAS 프로그램에서는 숫자 칼럼 내부 데이터를 선택할 때는 숫자를 그대로 쓰고, 문자 칼럼 내부 데이터를 선택할 때는 ‘ ’를 붙입니다. 그러지 않을 경우 에러가 발생하니 주의하세요. 5-4. IF 구문을 활용한 칼럼 변환 IF 문에서 한 발자국 더 나아가서 IF를 활용한 칼럼 변환에 대해서 학습하겠습니다. IF 문은 조건부 명령어인데 THEN과 함께 사용하면 유용하게 쓰입니다. IF~THEN~로 이루어져 있습니다. 특정 조건(IF 문)을 주고 그 조건에 부합하는 행에 따라 변화(THEN)를 주는 거죠. 테이블을 가공할 때 특정 상황에서 칼럼을 변환할 때 이용하면 좋습니다. 명령어 IF XXX=N THEN YYY+2;: 칼럼 XXX가 N 이면 칼럼 YYY에 2를 더한 값을 출력합니다. IF XXX=N THEN DELETE;: 칼럼 XXX가 N 이면 해당 행을 삭제합니다. IF XXX=N THEN NEW=‘새로운 칼럼’;: 칼럼 XXX가 N 이명 칼럼 NEW를 생성하고 ‘새로운 칼럼’이라는 값이 나오도록 만듭니다. IF XXX=N THEN NEW=YYY+2; ELSE NEW=ZZZ+3;: 칼럼 XXX가 N 이면 칼럼 YYY에 2를 더한 값을 출력하고 XXX가 N이 아닌 나머지 경우 ZZZ에 3을 더한 값을 출력합니다. 예제 1 DATA TEST;/*테이블 TEST를 생성합니다.*/ SET SASHELP.CLASS;/*테이블 SASHELP.CLASS를 불러옵니다*/ IF AGE=12 THEN HEIGHT+300;/*칼럼 AGE가 12이면 칼럼 HEIGHT 값에 300을 더합니다.*/ RUN;/*SAS 명령어를 종료합니다.*/ Name Sex Age Height Weight 알프레드 남 14 69 112.5 앨리스여 13 56.5 84 바바라여 13 65.3 98 캐럴여 14 62.8 102.5 헨리 남 14 63.5 102.5 제임스 남 12 357.3 83 제인여 12 359.8 84.5 자넷여 15 62.5 112.5 제프리 남 13 62.5 84 존 남 12 359 99.5 조이스여 11 51.3 50.5 주디여 14 64.3 90 루이스여 12 356.3 77 메리여 15 66.5 112 필립 남 16 72 150 로버트 남 12 364.8 128 로날드 남 15 67 133 토마스 남 11 57.5 85 윌리엄 남 15 66.5 112 예제 1은 IF와 THEN으로 이루어져 있습니다. 칼럼 AGE가 12인 행이 있다면 칼럼 HEIGHT에 각각 300씩을 더하라는 명령어입니다. 칼럼 HEIGHT 모든 값에 300을 더하는 게 아니라 칼럼 AGE가 12인 행에만 300씩을 더합니다. 예제 2 DATA TEST;/*테이블 TEST를 생성합니다.*/ SET SASHELP.CLASS;/*테이블 SASHELP.CLASS를 불러옵니다.*/ IF AGE=12 THEN DELETE;/*칼럼 AGE가 12이면 해당 행을 삭제합니다.*/ RUN;/*SAS 명령어를 종료합니다.*/ Name Sex Age Height Weight 알프레드 남 14 69 112.5 앨리스여 13 56.5 84 바바라여 13 65.3 98 캐럴여 14 62.8 102.5 헨리 남 14 63.5 102.5 자넷여 15 62.5 112.5 제프리 남 13 62.5 84 조이스여 11 51.3 50.5 주디여 14 64.3 90 메리여 15 66.5 112 필립 남 16 72 150 로날드 남 15 67 133 토마스 남 11 57.5 85 윌리엄 남 15 66.5 112 예제 2도 동일한 방식입니다. 여기서는 칼럼 AGE가 12일 경우 해당 행을 삭제(DELETE) 하도록 명령을 합니다. 그래서 출력값을 보면 칼럼 AGE가 12인 값을 찾을 수 없습니다. 예제 3 DATA TEST;/*테이블 TEST를 생성합니다.*/ SET SASHELP.CLASS;/*테이블 SASHELP.CLASS를 불러옵니다.*/ IF AGE=12 THEN NEW='새로운 칼럼';/*칼럼 AGE가 12이면 새로운 칼럼 NEW에 ‘새로운 칼럼’이라는 값을 줍니다.*/ RUN;/*SAS 명령어를 종료합니다.*/ Name Sex Age Height Weight NEW 알프레드 남 14 69 112.5 앨리스여 13 56.5 84 바바라여 13 65.3 98 캐럴여 14 62.8 102.5 헨리 남 14 63.5 102.5 제임스 남 12 57.3 83 새로운 칼럼 제인여 12 59.8 84.5 새로운 칼럼 자넷여 15 62.5 112.5 제프리 남 13 62.5 84 존 남 12 59 99.5 새로운 칼럼 조이스여 11 51.3 50.5 주디여 14 64.3 90 루이스여 12 56.3 77 새로운 칼럼 메리여 15 66.5 112 필립 남 16 72 150 로버트 남 12 64.8 128 새로운 칼럼 로날드 남 15 67 133 토마스 남 11 57.5 85 윌리엄 남 15 66.5 112 예제 3은 새로운 칼럼을 생성하는 명령어입니다. 칼럼 AGE가 12일 경우 새로운 칼럼 NEW를 생성하고 거기에 ‘새로운 칼럼’이라는 값을 입력하는 명령어입니다. 여기서도 예제 1과 유사하게 칼럼 NEW 전체에 ‘새로운 칼럼’ 값을 입력하는 게 아니라 칼럼 AGE가 12인 행에만 ‘새로운 칼럼’값을 입력합니다. 만약 칼럼 NEW 전체에 ‘새로운 칼럼’이라는 값을 입력하고 싶으시다면 IF 문을 사용할 필요 없이 ‘NEW=‘새로운 칼럼’’라는 명령어를 입력해 주시면 됩니다. 예제 4 DATA TEST; SET SASHELP.CLASS; IF AGE=12 THEN NEW='새로운 칼럼'; ELSE IF AGE=13 THEN NEW='새로운 칼럼 2'; ELSE NEW='새 칼럼'; RUN; Name Sex Age Height Weight NEW 알프레드 남 14 69 112.5 새 변수 앨리스여 13 56.5 84 새로운 칼럼 2 바바라여 13 65.3 98 새로운 칼럼 2 캐럴여 14 62.8 102.5 새 칼럼 헨리 남 14 63.5 102.5 새 칼럼 제임스 남 12 57.3 83 새로운 칼럼 제인여 12 59.8 84.5 새로운 칼럼 자넷여 15 62.5 112.5 새 칼럼 제프리 남 13 62.5 84 새로운 칼럼 2 존 남 12 59 99.5 새로운 칼럼 조이스여 11 51.3 50.5 새 칼럼 주디여 14 64.3 90 새 칼럼 루이스여 12 56.3 77 새로운 칼럼 메리여 15 66.5 112 새 칼럼 필립 남 16 72 150 새 칼럼 로버트 남 12 64.8 128 새로운 칼럼 로날드 남 15 67 133 새 칼럼 토마스 남 11 57.5 85 새 칼럼 윌리엄 남 15 66.5 112 새 칼럼 예제 4처럼 IF AGE=12 THEN NEW=‘새로운 칼럼’ 명령어가 종료된 다음 ELSE 명령어에 의해 AGE=13 THEN NEW=‘새로운 칼럼 2’가 입력됐습니다. 마지막 ELSE 명령어에는 조건문이 없습니다. 그래서 이외의 값들에 대해서 NEW=‘새칼럼’를 입력하는 명령어가 실행됩니다. 이 경우에는 AGE가 12,13이 아닌 11,14,15,16인 행에 NEW=‘새 칼럼’라는 데이터가 입력됩니다. 그 결과는 위의 표와 같습니다. ELSE 명령어는 IF 명령어를 마친 다음에 세트처럼 사용할 수 있는 명령어입니다. IF 명령어를 추가하거나, IF 명령어 이외의 값에 대해 데이터를 새로 생성하거나 변경하고 싶을 경우 사용하면 됩니다. tip IF 문 명령어를 종료한 후 ELSE 문을 통해 추가 명령어를 입력할 수 있습니다. IF~THEN~명령어를 마친 다음, ELSE 명령어를 입력하면 IF 명령어 조건을 추가할 수 있습니다. 그리고 ELSE 명령어 다음 아무런 조건을 입력하지 않은 채 결괏값만을 입력할 수도 있습니다. 그러면 위의 IF 명령어가 입력된 값 이외의 나머지에 대해서 ELSE 명령어에 적힌 내용을 실행합니다. 6. 테이블 결합 다음부터는 테이블의 연결에 대해서 배워보겠습니다. 테이블끼리 연결할 일은 상당히 자주 일어나는 일입니다. 데이터를 연결하는 건 크게 두 가지가 있습니다. 아래로 이어서 붙이는 방식과 옆으로 이어서 붙이는 방식이 있죠. 예를 들어 테이블 A의 아래쪽에 테이블 B를 잇는다든지(행을 추가), 테이블 A의 옆에 테이블 C를 이어야 하는 일(열을 추가)이 생깁니다. 적절한 예시를 통해서 테이블을 어떻게 연결하는지 배워보겠습니다. 6-1. 테이블 아래로 붙이기(SET) 테이블을 아래에 붙이기 전에, 우선 예시를 들어볼 테이블을 만들겠습니다. 우리가 결합할 테이블은 A와 B, 두 개입니다. 하나는 라이브러리 SASHELP의 테이블 CLASS이고 이를 테이블 A라고 칩시다. 하나는 아래에 만든 테이블 ‘CLASS2’로 하고 이를 테이블 B라고 여기겠습니다. 대상 테이블 생성 테이블 B 생성 DATA CLASS2; INPUT NAME $ SEX $ AGE HEIGHT WEIGHT; CARDS; 최철기 남 12 150 50 주양 여 11 130 40 RUN; NAME SEX AGE HEIGHT WEIGHT 최철기 남 12 150 50 주양 여 11 130 40 명령어 SET XXX YYY;: 테이블 XXX와 YYY를 연속하여 불러와서 하나의 테이블로 만듭니다. 예제 DATA TEST;/*테이블 TEST를 생성합니다.*/ SET SASHELP.CLASS CLASS2;/*테이블 CLASS와 CLASS를 연속으로 불러옵니다.*/ RUN;/*SAS 명령어를 종료합니다.*/ Name Sex Age Height Weight 알프레드 남 14 69 112.5 앨리스여 13 56.5 84 바바라여 13 65.3 98 캐럴여 14 62.8 102.5 헨리 남 14 63.5 102.5 제임스 남 12 57.3 83 제인여 12 59.8 84.5 자넷여 15 62.5 112.5 제프리 남 13 62.5 84 존 남 12 59 99.5 조이스여 11 51.3 50.5 주디여 14 64.3 90 루이스여 12 56.3 77 메리여 15 66.5 112 필립 남 16 72 150 로버트 남 12 64.8 128 로날드 남 15 67 133 토마스 남 11 57.5 85 윌리엄 남 15 66.5 112 최철기 남 12 150 50 주양 여 11 130 40 SET 문을 사용하면 사실상 여러 개의 테이블을 아래로 이어 붙일 수 있습니다. SET은 하나의 테이블만 불러오는 명령어가 아니라 불러올 테이블을 모두 지정하는 명령어임을 알 수 있습니다. 예제에서 보듯이 테이블 SASHELP.CLASS 다음으로 테이블 CLASS2가 이어져 붙어있음을 확인할 수 있습니다. 6-1-A. 칼럼명이 일치하지 않는 경우 데이터를 붙일 때 반드시 테이블 A와 테이블 B의 칼럼(열)이 같지는 않습니다. 테이블 A에 있는 칼럼이 테이블 B에는 없을 수도 있고, 그 반대일 수도 있습니다. 이번에는 테이블을 아래로 붙일 때 생길 수 있는 누락 데이터 건을 살펴보겠습니다. 테이블 A에 없는 열이 테이블 B에 있거나, 테이블 B에 일부 데이터가 누락됐을 경우입니다. 테이블 A를 SASHELP.CLASS로 하고, 새로운 테이블 B를 아래와 같이 생성하겠습니다. 테이블 B 생성 DATA CLASS2; INPUT NAME $ AGE HEIGHT WEIGHT ADDR $; CARDS; 최철기 12 150 50 남대문 주양 11 130 40 서초 RUN; NAME AGE HEIGHT WEIGHT ADDR 최철기 12 150 50 남대문 주양 11 130 40 서초 테이블 A와 테이블 B는 비슷하지만 칼럼이 조금 다릅니다. 테이블 A의 칼럼이 NAME, SEX, AGE, HEIGHT, WEIGHT이고 테이블 B의 칼럼은 NAME, AGE, HEIGHT, WEIGHT, ADDR입니다. 테이블 A에 없는 칼럼은 ADDR이고 각 칼럼의 위치도 한 칸씩 변경됐습니다. 이렇게 2개의 테이블이 서로 다른 형태일 때 테이블 이어붙이기가 어떻게 진행되는지 알아보겠습니다. 명령어 DATA TEST; SET SASHELP.CLASS CLASS2 RUN; Name Sex Age Height Weight ADDR 알프레드 남 14 69 112.5. 앨리스여 13 56.5 84. 바바라여 13 65.3 98. 캐럴여 14 62.8 102.5. 헨리 남 14 63.5 102.5. 제임스 남 12 57.3 83. 제인여 12 59.8 84.5. 자넷여 15 62.5 112.5. 제프리 남 13 62.5 84. 존 남 12 59 99.5. 조이스여 11 51.3 50.5. 주디여 14 64.3 90. 루이스여 12 56.3 77. 메리여 15 66.5 112. 필립 남 16 72 150. 로버트 남 12 64.8 128. 로날드 남 15 67 133. 토마스 남 11 57.5 85. 윌리엄 남 15 66.5 112. 최철기. 12 150 50 남대문 주양. 11 130 40 서초 두 테이블의 칼럼이 다른 상황입니다. 이럴 경우 각 테이블에 있는 칼럼들을 모두 불러옵니다. 그러고서 칼럼명이 동일한 테이블은 정상적으로 테이블 A와 B를 이어서 붙입니다. 동일하지 않은 나머지 칼럼은 각각 테이블 A와 테이블 B의 데이터만을 넣어서 전체 테이블을 완성합니다. 그 결과 테이블 A에 존재하지 않지만 테이블 B에는 있는 ADDR 칼럼이 생겼고, 거기엔 19개 행이 빈칸으로 구성돼 있습니다. 그리고 테이블 B에는 있지만 테이블 A에는 없는 SEX 칼럼이 있고 2개 행이 빈칸으로 구성돼 있습니다. tip SET 명령어는 두 테이블의 모든 칼럼을 합칩니다. 그리고 속한 데이터들을 모두 불러옵니다. 만약 데이터가 없다면, 없는 대로 빈칸으로 출력합니다. 6-1-B. 칼럼의 길이가 다른 경우 모든 테이블이 동일한 길이로 구성돼 있는 건 아닙니다. 칼럼 이름이 똑같아도 칼럼의 길이가 다를 수 있습니다. 이번에는 칼럼명은 똑같지만, 길이가 다른 경우 어떤 결과가 나오는지를 알아보겠습니다. 예를 들어 우선 테이블 A는 라이브러리 SASHELP의 테이블 CLASS를 사용하겠습니다. CLASS 테이블의 속성을 앞에서 배운 PROC CONTENTS 명령어를 통해서 알아보겠습니다. PROC CONTENTS DATA=SASHELP.CLASS; RUN; # 변수 유형 길이 레이블 3 Age 숫자 8 나이 4 Height 숫자 8 키(단위: 인치) 1 Name 문자 12 이름 2 Sex 문자 4 성별 5 Weight 숫자 8 몸무게(단위: 파운드) PROC CONTENTS 명령어를 시행하면 위와 같은 결과를 확인할 수 있습니다. 우선 AGE는 숫자형 변수이면서 길이는 최대 8까지 지정돼 있습니다. HEIGHT는 숫자형 변수이면서 길이는 최대 8, NAME은 문자형 변수이면서 길이는 최대 12까지 지정이 돼 있습니다. 여기서 길이 1은 알파벳 하나로 생각하시면 됩니다. 따라서 변수 NAME에 한글은 6글자까지 입력이 가능합니다. 두 테이블의 동일 이름 칼럼 간 데이터 길이가 다른 경우 두 테이블을 아래로 이어 붙일 때 동일한 이름의 칼럼 간 길이의 차이가 있는 경우를 생각해 보겠습니다. 우리는 테이블 A(SASHELP.CLASS)와 테이블 B(CLASS2)에 있는 칼럼 NAME을 기준으로 공부를 해보겠습니다. 테이블 B는 아래와 같은 테이블로 정의하겠습니다. 테이블 B 생성 DATA CLASS2; INPUT NAME: $14. SEX $ AGE HEIGHT WEIGHT; CARDS; 드레이 먼드 그린 1 17 207 90 드마트라커즌스 2 21 210 100 RUN; 테이블 CLASS2를 생성했습니다. CLASS2의 변수 속성은 아래와 같습니다. 칼럼 NAME을 보십시오. 테이블 A(SASHELP.CLASS)와 테이블 B(CLASS2)에서의 칼럼 NAME은 칼럼명이 동일합니다. 그래서 SAS는 SET 명령어에서 테이블 A와 B의 칼럼 NAME을 이어서 붙이게 됩니다. 그 결과는 아래와 같습니다. NAME SEX AGE HEIGHT WEIGHT 드레이 먼드 그린 1 17 207 90 드마트라커즌스 2 21 210 100 tip 새로운 테이블을 생성할 경우 특별한 명령어가 없는 이상 길이는 8로 설정이 됩니다. 다음으로 CLASS2의 속성을 PROC CONTENTS 명령어를 통해 확인해 보겠습니다. PROC CONTENTS DATA=CLASS2; RUN; # 변수 유형 길이 # 변수 유형 길이 3 AGE 숫자 8 4 HEIGHT 숫자 8 1 NAME 문자 14 2 SEX 문자 8 5 WEIGHT 숫자 8 이제 그럼 두 테이블을 SET 명령어를 통해 이어보겠습니다. 명령어 SET XXX YYY;: 테이블 XXX와 YYY를 연속하여 불러와서 하나의 테이블로 만듭니다. 예제 DATA TEST; SET SASHELP.CLASS CLASS2 RUN; Name Sex Age Height Weight 알프레드 남 14 69 112.5 앨리스여 13 56.5 84 바바라여 13 65.3 98 캐럴여 14 62.8 102.5 헨리 남 14 63.5 102.5 제임스 남 12 57.3 83 제인여 12 59.8 84.5 자넷여 15 62.5 112.5 제프리 남 13 62.5 84 존 남 12 59 99.5 조이스여 11 51.3 50.5 주디여 14 64.3 90 루이스여 12 56.3 77 메리여 15 66.5 112 필립 남 16 72 150 로버트 남 12 64.8 128 로날드 남 15 67 133 토마스 남 11 57.5 85 윌리엄 남 15 66.5 112 드레이 먼드 그 1 17 207 90 드마트라커즌 2 21 210 100 NAME 칼럼의 가장 아래쪽을 보겠습니다. 테이블 B에서는 원래 ‘드레이 먼드 그린’과 ‘드마트라커즌스’이 입력돼 있었지만 최종 테이블에는 마지막 한 글자가 잘려서 입력됐습니다. 그 이유는 테이블 A에 있습니다. 처음에 나온 테이블 A(SASHELP.CLASS)에서 칼럼 NAME의 길이가 12로 지정이 돼 있기 때문이죠. SET 명령어로 두 개 이상의 테이블을 이어붙일 때 기준이 되는 것은 첫 번째로 지정된 테이블입니다. 앞에서 설명했듯이 SAS는 명령어를 위에서부터 읽고 왼쪽에서부터 읽습니다. 이 같은 기준에 따라 SET 명령어에서 가장 위에 있는 테이블을 먼저 읽어 들이게 되죠. 이에 따라 통합된 테이블의 칼럼 NAME은 길이가 12인 상태로 생성이 됩니다. 이 상황에서 두 번째로 나오는 테이블 B(CLASS2)의 칼럼 NAME의 길이가 14라면, 테이블 B의 뒤쪽 길이가 2만큼 잘리게 되는 것이죠. 그렇기에 칼럼들의 행을 이어줄 때는 길이를 유심히 살피셔야 합니다. 해결책 1) 길이가 긴 테이블을 SET 명령어에서 앞쪽에 나오도록 합니다. 여기서는 칼럼의 길이가 긴 테이블 B를 A보다 앞에 나오도록 하면 됩니다. 그럴 경우 길이가 긴 테이블 B가 기준이 되므로 칼럼 NAME에서 잘리는 데이터가 없게 됩니다. DATA TEST; SET CLASS2 SASHELP.CLASS RUN; 2) 테이블을 생성할 때 테이블 A의 길이를 테이블 B에 맞춰서 변경하는 것입니다. 테이블 A의 길이를 테이블 B에 맞춰서 확장해 주면 됩니다. 길이는 데이터가 잘리지 않을 만큼 확장해 주시면 됩니다.(하지만 라이브러리 SASHELP 내부의 데이터는 수정되지 않으니 이 방법을 쓰지는 못합니다.) 3) 이미 만들어진 테이블의 길이를 변경해 주는 것입니다. 이 방법은 이후 과정에서 학습하도록 하겠습니다. 6-1-C. 칼럼의 속성이 다른 경우(전자책 내용) 죄송합니다. 해당 자료는 위키독스 웹 사이트에서는 비공개 처리되어 구현 코드와 코드에 대한 상세한 설명은 아래 링크의 유료 E-book을 구매하시면 확인할 수 있습니다. (링크) SAS로 하는 기초 데이터 전처리, 핸들링(Data handling) 전자책 구매 6-2. 테이블 옆으로 붙이기(MERGE) 테이블을 다루면서 테이블끼리 조합을 해야 하는 경우는 상당히 많은 편입니다. 현대 데이터베이스 관리는 주로 테이블과 테이블 간의 결합으로 이뤄진다고 말할 만큼 상이한 여러 가지 테이블을 이어 붙이는 작업은 중요합니다. 이번에는 테이블을 옆으로 이어붙이는 작업을 해보겠습니다. 기준이 될 테이블 A는 SASHELP.CLASS로 하고, 옆으로 붙일 대상 테이블 B를 생성해 보겠습니다. 대상 테이블 생성 테이블 B 생성 DATA CLASS3; INPUT LAST_NAME $ ADDR $ LINE; CARDS; 존 서울 5 마커스 부산 6 RUN; LAST_NAME ADDR LINE 존 서울 5 조던 부산 6 위와 같은 데이터를 테이블 B라고 지칭하겠습니다. 테이블 A(SASHELP.CLASS)와 테이블 B(CLASS3)을 옆으로 결합하는 방법을 알아보겠습니다. 명령어 MERGE XXX YYY;: XXX와 YYY를 옆으로 결합합니다. 예제 DATA TEST; MERGE SASHELP.CLASS CLASS3 RUN; Name Sex Age Height Weight LAST_NAME ADDR LINE 알프레드 남 14 69 112.5 존 서울 5 앨리스여 13 56.5 84 조던 부산 6 바바라여 13 65.3 98. . . 캐럴여 14 62.8 102.5. . . 헨리 남 14 63.5 102.5. . . 제임스 남 12 57.3 83. . . 제인여 12 59.8 84.5. . . 자넷여 15 62.5 112.5. . . 제프리 남 13 62.5 84. . . 존 남 12 59 99.5. . . 조이스여 11 51.3 50.5. . . 주디여 14 64.3 90. . . 루이스여 12 56.3 77 . . . 메리여 15 66.5 112. . . 필립 남 16 72 150. . . 로버트 남 12 64.8 128. . . 로날드 남 15 67 133. . . 토마스 남 11 57.5 85. . . 윌리엄 남 15 66.5 112. . . 예제의 결과는 위와 같습니다. 우선 테이블 A의 데이터가 모두 나오고 그 오른쪽으로 테이블 B의 결괏값이 붙게 됩니다. 추가 명령어가 없을 경우 테이블 B의 결괏값은 위에서부터 보이게 됩니다. 6-2-A. 특정 값을 기준으로 결합하는 경우(전자책 내용) 죄송합니다. 해당 자료는 위키독스 웹 사이트에서는 비공개 처리되어 구현 코드와 코드에 대한 상세한 설명은 아래 링크의 유료 E-book을 구매하시면 확인할 수 있습니다. (링크) SAS로 하는 기초 데이터 전처리, 핸들링(Data handling) 전자책 구매 7. DO 명령어 DO 명령어를 활용하여 여러 가지 명령어를 한 번에 시행되도록 할 수 있습니다. 7-1. 기본 DO 명령어 가장 단순한 형태의 DO 명령어에 대해서 알아보겠습니다. 명령어 IF AGE=12 THEN DO; NEW=‘열둘’; NEW2=‘열두 살’; END;: 변수 AGE가 12일 경우 DO 이하에 있는 명령어를 시행합니다. 그 명령어는 변수 NEW를 생성하고 데이터 값으로 ‘열둘’을 입력하고 변수 NEW2를 생성하고 데이터 값으로 ‘열두 살’을 입력합니다. END를 씀으로써 DO 명령어를 종료합니다. 예제 DATA TEST; SET SASHELP.CLASS; IF AGE=12 THEN DO; NEW='열둘'; NEW2='열두 살'; END; RUN; Name Sex Age Height Weight NEW NEW2 알프레드 남 14 69 112.5. . 앨리스여 13 56.5 84. . 바바라여 13 65.3 98. . 캐럴여 14 62.8 102.5. . 헨리 남 14 63.5 102.5. . 제임스 남 12 57.3 83열둘 열두 살 제인여 12 59.8 84.5열둘 열두 살 자넷여 15 62.5 112.5. . 제프리 남 13 62.5 84. . 존 남 12 59 99.5열둘 열두 살 조이스여 11 51.3 50.5. . 주디여 14 64.3 90. . 루이스여 12 56.3 77열둘 열두 살 메리여 15 66.5 112. . 필립 남 16 72 150. . 로버트 남 12 64.8 128열둘 열두 살 로날드 남 15 67 133. . 토마스 남 11 57.5 85. . 윌리엄 남 15 66.5 112. . 위의 결과에서 확인할 수 있듯이 DO 명령어를 통해 한 번에 두 개의 문장을 시행했습니다. 그래서 IF 명령어의 결과로 칼럼 NEW와 NEW2가 생성되었고 해당 데이터가 IF 조건에 맞는 행에만 입력되었습니다. 만약 DO 명령어를 쓰지 않을 경우 IF THEN 이후 하나의 명령어만 IF 명령어를 받아서 시행합니다. 아래에서는 DO 명령어를 쓰지 않은 사례를 통해 설명해 보겠습니다. 예제 2(DO 명령어를 쓰지 않은 경우) DATA TEST; SET SASHELP.CLASS; IF AGE=12 THEN NEW='열둘'; NEW2='열두 살'; RUN; Name Sex Age Height Weight NEW NEW2 알프레드 남 14 69 112.5. 열두 살 앨리스여 13 56.5 84. 열두 살 바바라여 13 65.3 98. 열두 살 캐럴여 14 62.8 102.5. 열두 살 헨리 남 14 63.5 102.5. 열두 살 제임스 남 12 57.3 83열둘 열두 살 제인여 12 59.8 84.5열둘 열두 살 자넷여 15 62.5 112.5. 열두 살 제프리 남 13 62.5 84. 열두 살 존 남 12 59 99.5열둘 열두 살 조이스여 11 51.3 50.5. 열두 살 주디여 14 64.3 90. 열두 살 루이스여 12 56.3 77열둘 열두 살 메리여 15 66.5 112. 열두 살 필립 남 16 72 150. 열두 살 로버트 남 12 64.8 128열둘 열두 살 로날드 남 15 67 133. 열두 살 토마스 남 11 57.5 85. 열두 살 윌리엄 남 15 66.5 112. 열두 살 DO 명령어를 쓰지 않았을 경우 IF THEN 명령어를 받는 문장은 단 하나입니다. 따라서 칼럼 NEW만 IF 명령어를 받아서 시행되었습니다. SAS는 칼럼 NEW2는 IF 명령어와는 별개로 인식하여 따로 하나의 칼럼을 만들고 해당 데이터를 모두 ‘열두 살’로 입력합니다. 원하던 사례와는 조금 다른 결괏값이 나오게 됩니다. 이 사례처럼 DO 명령어를 통해 IF 명령어 등에서 한 번에 여러 명령어를 수행하게 만들 수 있습니다. 7-2. 반복 DO 명령어 (전자책 내용) 죄송합니다. 해당 자료는 위키독스 웹 사이트에서는 비공개 처리되어 구현 코드와 코드에 대한 상세한 설명은 아래 링크의 유료 E-book을 구매하시면 확인할 수 있습니다. (링크) SAS로 하는 기초 데이터 전처리, 핸들링(Data handling) 전자책 구매 7-3. DO UNTIL / WHILE 명령어 (전자책 내용) 죄송합니다. 해당 자료는 위키독스 웹 사이트에서는 비공개 처리되어 구현 코드와 코드에 대한 상세한 설명은 아래 링크의 유료 E-book을 구매하시면 확인할 수 있습니다. (링크) SAS로 하는 기초 데이터 전처리, 핸들링(Data handling) 전자책 구매 8. SAS로 하는 SQL 명령어 SQL의 역사 이제부터는 PROC SQL에 대해서 배워보겠습니다. SQL은 사실 SAS와는 다른 컴퓨터 언어입니다. SAS와는 다르게 SQL은 미국의 IBM 사에서 70년대에 개발했습니다. SQL은 약자인데요, 풀네임은 ‘Structured English Query Language’입니다. ‘영어 체계의 질의 언어’ 정도로 해석할 수 있습니다. 영어로 컴퓨터에 질의(질문)를 던진다는 의미인데요, 이는 우리가 컴퓨터로 ‘이러이러한 데이터를 찾아주세요’라고 질의를 하면 컴퓨터가 이에 알맞은 답변을 한다는 식으로 생각하시면 됩니다. IBM 사에서 SQL을 개발한 이유는 당시 관계형 데이터베이스가 발전 초기 단계였는데, 이를 관리하기 위한 언어 체계가 필요했습니다. 그래서 새로운 컴퓨터 언어를 개발했는데요, 그것이 바로 SQL입니다. SQL의 유용성 SQL은 대단히 유용한 언어입니다. 현재 데이터베이스를 다루는 언어 중에 가장 대중적인 것이 SQL입니다. SQL은 SAS에서만 쓸 수 있는 게 아니라 다른 프로그램에서도 활용할 수 있습니다. 데이터를 다루는 기업에서는 SAS 프로그램 대신(또는 별도로) ORACLE이나 MY-SQL 같은 프로그램을 쓰는 경우가 있습니다. 이럴 때 ORACLE이나 MY-SQL을 구동하는 언어가 SQL입니다. SQL은 1986년 ANSI 표준화가 이뤄졌습니다. 그래서 사용하는 프로그램이 달라도 SQL 언어 체계는 대부분 동일합니다(정확히 100% 동일하지는 않습니다). SQL 언어를 알면 다른 프로그램을 운용하는 데 도움이 되는 만큼, 제대로 알아두면 일석이조의 효과를 얻을 수 있습니다. SQL이 대중적으로 활용되어서 SAS도 SQL을 사용할 수 있도록 프러시저(PROC XXX와 같은 형태)를 개발했습니다. 실제로 SAS를 활용하다 보면 SQL 프러시저를 사용해 데이터를 만들 때가 많습니다. 그렇다면 이제부터 유용한 SQL의 기초부터 배워보겠습니다. SAS 기존 문법과 SQL 문법의 차이점 SQL은 기존의 SAS 문법과는 체계가 다릅니다. 기존의 SAS 명령어와 SQL 명령어가 다른 점은 크게 두 가지가 있습니다. 1) SAS에서는 명령어를 읽을 때 ‘위에서부터 읽고, 왼쪽에서부터 읽는다.’ 고 설명했습니다. 그러나 SQL은 왼쪽에서부터 읽는 건 동일하지만, 반드시 위에서부터 읽는 건 아닙니다. 아래에 있는 것을 먼저 읽을 때가 있습니다. SQL은 명령어에 따라 컴퓨터가 읽어들이는 순서가 다릅니다. 2) 그리고 각 명령어 문장의 끝에 ‘;’를 넣지 않습니다. SAS는 각 개별 명령어의 끝에 ‘;’를 붙여야 했습니다. 그러나 SQL은 모든 명령어가 끝났을 때만 ‘;’를 붙이면 됩니다. 8-01. SQL로 표 만들기 SQL의 가장 기본적인 문법을 알아보겠습니다. 명령어 PROC SQL;: 프러시저 SQL을 불러옵니다. SELECT XXX: 칼럼 XXX를 선택합니다. FROM YYY: 테이블 YYY로부터 불러옵니다. ;: 모든 명령어를 종료합니다. QUIT;: SQL을 종료합니다. 예제 PROC SQL; SELECT NAME, AGE, HEIGHT FROM SASHELP.CLASS QUIT; 이름 나이 키(단위: 인치) 알프레드 14 69 앨리스 13 56.5 바바라 13 65.3 캐럴 14 62.8 헨리 14 63.5 제임스 12 57.3 제인 12 59.8 자넷 15 62.5 제프리 13 62.5 존 12 59 조이스 11 51.3 주디 14 64.3 루이스 12 56.3 메리 15 66.5 필립 16 72 로버트 12 64.8 로날드 15 67 토마스 11 57.5 윌리엄 15 66.5 SQL 명령어를 통해 위의 표를 만들었습니다. 우선 PROC SQL을 통해 프러시저 SQL을 사용한다는 명령어를 입력합니다. 다음으로 어떤 칼럼을 사용할지 SELECT를 통해 선택합니다. 여기에서는 SELECT를 통해 칼럼 NAME, AGE, HEIGHT를 사용했습니다. 그리고 마지막으로 FROM 명령어를 통해 라이브러리 SASHELP의 테이블 CLASS를 불러옵니다. 이전의 SAS 문법에서는 우선 SET 명령어를 통해 어떤 테이블에서 데이터를 불러올 것인지를 선택하게 됩니다. 그러나 SQL은 테이블을 불러오는 FROM 명령어가 뒤쪽에 있습니다. SQL은 영어 문법과 유사합니다. 보통 영어 문장에서 FROM 같은 전치사로 이뤄진 단어는 문장의 뒤쪽에 위치합니다. SQL도 유사하게 FROM이 뒤쪽에 있습니다. 사용하는 단어들도 실제 사용하는 영어와 유사한 부분이 많습니다. FROM(~로부터)이라든지 SELECT(선택하다) 같은 경우에서 볼 수 있듯 실제 문장으로 대화를 하듯이 명령어가 구성돼 있습니다. 이를 참고한다면 SQL 문장을 더 쉽게 이해하실 수 있을 겁니다. tip 만약 테이블에 있는 전체 칼럼을 모두 가져오고 싶다면 * 표시를 해주면 됩니다. 예제 1.처럼 SASHELP.CLASS에 있는 모든 칼럼을 가져오고 싶다면 “SELECT * ”로 표현을 해주시면 됩니다. PROC SQL; SELECT * FROM SASHELP.CLASS QUIT; 이와 같이 실행을 해주시면 SASHELP.CLASS의 모든 칼럼들이 선택되어 표에 보이게 됩니다. 8-02. SQL로 테이블 만들기 8-1의 과정은 단순한 표를 만드는 거였습니다. 사용자에게 보이는 기능만 있는 표입니다. 이번에는 8-1의 예제 표를 테이블로 만드는 작업을 해보겠습니다. 예제에서 한 줄만 추가를 해주면 됩니다. 명령어 CREATE TABLE XXX AS: 테이블 XXX를 만들고 세부 내용은 AS 이하를 따릅니다. 예제 PROC SQL; CREATE TABLE TEST AS SELECT NAME, AGE, HEIGHT FROM SASHELP.CLASS QUIT; Name Age Height 알프레드 14 69 앨리스 13 56.5 바바라 13 65.3 캐럴 14 62.8 헨리 14 63.5 제임스 12 57.3 제인 12 59.8 자넷 15 62.5 제프리 13 62.5 존 12 59 조이스 11 51.3 주디 14 64.3 루이스 12 56.3 메리 15 66.5 필립 16 72 로버트 12 64.8 로날드 15 67 토마스 11 57.5 윌리엄 15 66.5 8-1의 예제에 나와 있는 표와 똑같습니다. 다만 이 결과표는 테이블로 생성이 됐습니다. 8-1의 예제와 지금의 예제의 차이점은 CREATE TABLE XXX AS 문장입니다. 이 문장이 있어서 테이블 XXX가 만들어집니다. 그리고 AS 이하의 칼럼 값들을 SELECT 하여 불러오고 FROM으로 대상 테이블을 지정합니다. 이 방법이 테이블을 만드는 SQL 기본 문법입니다. 이 방법을 SAS 문법으로 재현해 보면 아래와 같습니다. tip 현 챕터의 명령어를 SAS 문법으로 재현해 보면 아래와 같습니다. DATA TEST(KEEP=NAME AGE HEIGHT); SET SASHELP.CLASS; RUN; 직접 재현해 보시면 위의 예제와 같은 결괏값을 얻을 수 있습니다. 8-03. SQL로 사칙연산하기 SQL을 활용해서 여러 가지 수식을 사용할 수 있습니다. 사칙연산을 활용하여 숫자를 계산할 수 있고 여러 가지 조합을 활용해 새로운 칼럼을 생성할 수 있습니다. 그러면 지금부터 SQL을 다양하게 활용하는 법을 알아보겠습니다. 1) SQL에서 사칙연산 사용하기 간단하게 사칙연산의 활용부터 배워보겠습니다. SQL에서도 사칙연산을 사용할 수 있습니다. 수식 기호를 사용해 주시면 됩니다. 사칙연산은 숫자 칼럼들끼리만 가능합니다. 문자 칼럼을 쓸 경우 에러가 발생합니다. 명령어 SELECT XXX+YYY: 칼럼 XXX와 칼럼 YYY를 더합니다. (+,-,*,/를 사용한 사칙연산 가능) 예제 1 PROC SQL; CREATE TABLE TEST AS SELECT NAME, SEX, AGE, AGE+HEIGHT FROM SASHELP.CLASS QUIT; Name Sex Age Height _ TEMA001 알프레드 남 14 69 83 앨리스여 13 56.5 69.5 바바라여 13 65.3 78.3 캐럴여 14 62.8 76.8 헨리 남 14 63.5 77.5 제임스 남 12 57.3 69.3 제인여 12 59.8 71.8 자넷여 15 62.5 77.5 제프리 남 13 62.5 75.5 존 남 12 59 71 조이스여 11 51.3 62.3 주디여 14 64.3 78.3 루이스여 12 56.3 68.3 메리여 15 66.5 81.5 필립 남 16 72 88 로버트 남 12 64.8 76.8 로날드 남 15 67 82 토마스 남 11 57.5 68.5 윌리엄 남 15 66.5 81.5 결과를 보시면 칼럼 NAME, SEX, AGE, HEIGHT가 선택되어 출력되었고 ‘_TEMA001’라는 칼럼이 생긴 것을 확인할 수 있습니다. 이 칼럼‘_TEMA001’은 칼럼 AGE와 칼럼 HEIGHT를 합한 값임을 확인할 수 있습니다. ‘AGE+HEIGHT’ 명령어에 의해 두 숫자 칼럼을 합한 값이 출력되었습니다. 이런 식으로 사칙연산을 수행할 수 있습니다. 2) SQL에서 사칙연산과 평균, 분산, 간단한 숫자 세기 방법 등 활용하기 기본적인 사칙연산을 넘어, SAS에서 제공하는 수식 활용법을 알아보겠습니다. SAS에서는 분석을 위해 다양한 수식 활용법을 제공합니다. 알아두면 유용한 계산식을 소개하겠습니다. 명령어 SELECT SUM(XXX), SUM(XXX, YYY), MEAN(XXX), MIDIAN(XXX), MIN(XXX), MAX(XXX), VAR(XXX), STD(XXX), COUNT(XXX), COUNT(XXX, YY) :SUM(XXX)는 칼럼 XXX의 값을 모두 더하는 것입니다. SUM(XXX, YYY)는 칼럼 XXX와 YYY의 값을 모두 더하는 것입니다. MEAN(XXX)는 칼럼 XXX의 평균값을 구합니다. MIDIAN(XXX)는 칼럼 XXX의 중앙값을 구합니다. MIN(XXX)는 칼럼 XXX에서 가장 작은 값을 구합니다. MAX(XXX)는 칼럼 XXX에서 가장 큰 값을 구합니다. VAR(XXX)는 칼럼 XXX의 분산을 구합니다. STD(XXX)는 칼럼 XXX의 표준편차를 구합니다. 예제 2 PROC SQL; CREATE TABLE TEST AS SELECT NAME, SEX, AGE, HEIGHT, SUM(AGE), SUM(HEIGHT, WEIGHT), MEAN(AGE), MEDIAN(AGE), MIN(AGE), MAX(AGE), VAR(AGE), STD(AGE) FROM SASHELP.CLASS QUIT; Name Sex Age Height _ TEMG001 _ TEMA008 _ TEMG002 _ TEMG003 _ TEMG004 _ TEMG005 _ TEMG006 _ TEMG007 알프레드 남 14 69 253 181.5 13.31579 13 11 16 2.22807 1.492672 앨리스여 13 56.5 253 140.5 13.31579 13 11 16 2.22807 1.492672 바바라여 13 65.3 253 163.3 13.31579 13 11 16 2.22807 1.492672 캐럴여 14 62.8 253 165.3 13.31579 13 11 16 2.22807 1.492672 헨리 남 14 63.5 253 166 13.31579 13 11 16 2.22807 1.492672 제임스 남 12 57.3 253 140.3 13.31579 13 11 16 2.22807 1.492672 제인여 12 59.8 253 144.3 13.31579 13 11 16 2.22807 1.492672 자넷여 15 62.5 253 175 13.31579 13 11 16 2.22807 1.492672 제프리 남 13 62.5 253 146.5 13.31579 13 11 16 2.22807 1.492672 존 남 12 59 253 158.5 13.31579 13 11 16 2.22807 1.492672 조이스여 11 51.3 253 101.8 13.31579 13 11 16 2.22807 1.492672 주디여 14 64.3 253 154.3 13.31579 13 11 16 2.22807 1.492672 루이스여 12 56.3 253 133.3 13.31579 13 11 16 2.22807 1.492672 메리여 15 66.5 253 178.5 13.31579 13 11 16 2.22807 1.492672 필립 남 16 72 253 222 13.31579 13 11 16 2.22807 1.492672 로버트 남 12 64.8 253 192.8 13.31579 13 11 16 2.22807 1.492672 로날드 남 15 67 253 200 13.31579 13 11 16 2.22807 1.492672 토마스 남 11 57.5 253 142.5 13.31579 13 11 16 2.22807 1.492672 윌리엄 남 15 66.5 253 178.5 13.31579 13 11 16 2.22807 1.492672 SAS에서 활용할 수 있는 사칙연산과 통계량이 결과로 나왔습니다. SELECT 이후 입력한 칼럼 순서대로 결과가 나옵니다. 우선 SUM(AGE)에 의해서 모든 행의 AGE 값이 합해졌습니다. 알프레드, 앨리스... 윌리엄까지 AGE의 모든 값을 더했습니다. 원래 테이블 모습은 그대로 유지하면서 오른쪽에 TEMG001칼럼이 추가됐습니다. 모든 행의 칼럼 AGE를 더했기에 모든 칼럼의 값은 똑같습니다. 다음으로 SUM(HEIGHT, WEIGHT)을 보겠습니다. 칼럼 TEMA008이 생성됐습니다. 각 행에서 칼럼 HEIGHT와 칼럼 WEIGHT를 더합니다. 그래서 각각의 행이 값이 다릅니다. 다만 특이점이 우리는 분명 SELECT 명령어에서 칼럼 WEIGHT를 선택하지 않았다는 점입니다. 여기서 SQL 명령어의 특징을 볼 수 있습니다. 우리가 SELECT로 칼럼 WEIGHT을 표현하지 않더라도, FROM 테이블에 칼럼 WEIGHT가 있을 경우, SQL은 이를 인식하고 계산합니다. SELECT 명령어는 칼럼을 표현할지 말지를 결정하는 역할만을 하는 셈입니다. 다음으로 나오는 명령어들 모두 각 칼럼들의 모든 행을 계산한 값입니다. 평균, 중앙값, 최솟값, 최댓값, 분산, 표준편차 등의 값을 결과로 나타냅니다. 8-04. SQL로 새 칼럼 이름 부여하기(AS) 앞의 예제에서 새로운 칼럼이 생성되었지만 칼럼의 이름이 ‘TEMA001’ 등으로 부여된 것을 확인할 수 있습니다. 이는 임시 이름으로 나중에 새 칼럼을 활용할 때 불편할 수 있습니다. 따라서 AS를 활용해 칼럼에 새로운 이름을 부여하는 것이 가능합니다. 꼭 새로운 칼럼에 이름을 부여하는 것뿐만이 아니라 기존 칼럼의 이름을 바꿀 때도 활용이 가능합니다. 명령어 SELECT XXX AS YYY, ZZZ+PPP AS BBB: 칼럼 XXX의 이름을 YYY로 바꾸고, 칼럼 ZZZ와 PPP를 더한 값의 칼럼 이름을 BBB로 합니다. 예제 PROC SQL; CREATE TABLE TEST AS SELECT NAME, SEX AS MALE_FEMALE, AGE+HEIGHT AS SUM FROM SASHELP.CLASS QUIT; Name MALE_FEMALE SUM 알프레드 남 83 앨리스여 69.5 바바라여 78.3 캐럴여 76.8 헨리 남 77.5 제임스 남 69.3 제인여 71.8 자넷여 77.5 제프리 남 75.5 존 남 71 조이스여 62.3 주디여 78.3 루이스여 68.3 메리여 81.5 필립 남 88 로버트 남 76.8 로날드 남 82 토마스 남 68.5 윌리엄 남 81.5 AS는 영어 단어 ‘~로서’라는 의미를 가지고 있습니다. 이 AS는 기존 칼럼의 이름을 새롭게 부여하거나 변경하는 역할을 합니다. 예제 2의 ‘AS MALE_FEMALE’, ‘AS SUM’은 해당 칼럼의 이름을 AS 이하로 변경하겠다는 의미입니다. SQL을 사용할 때 자주 이용되는 명령어이니 기억해두면 편리합니다. 8-05. SQL 명령어들 SQL에서는 여러 가지 명령어를 사용할 수 있습니다. 빈도가 높게 사용되는 명령어들을 알아보겠습니다. 명령어 명령어 속성 예시 COMPRESS 특정 문자를 제거합니다. COMPRESS(칼럼,‘문자’) COMPRESS 공백을 제거합니다. COMPRESS(칼럼) TRIM 뒤의 공백을 제거합니다. TRIM(칼럼) TRANSLATE 특정 문자를 다른 문자로 대체합니다 TRANSLATE(칼럼,‘문자 1’,‘문자 2’) TRANWRD 특정 문자를 다른 문자로 대체합니다. TRANSWRD(칼럼,‘문자 1’,‘문자 2’) LOWCASE 문자를 소문자로 변경합니다 LOWCASE(칼럼) UPCASE 문자를 대문자로 변경합니다 UPCASE(칼럼) SUBSTR 특정 위치의 문자를 추출합니다. SUBSTR(칼럼, 숫자 1, 숫자 2) SCAN 특정 문자를 기준으로 했을 때 특정 순서의 문자를 추출합니다 SCAN((칼럼, 순서,‘특정 문자’) CATX 문자들 사이에 원하는 구분 기호를 삽입합니다 CATX(‘특정 문자’, 칼럼 1, 칼럼 2, ..., 칼럼 n) FIND 특정 문자의 위치를 찾습니다. FIND(칼럼,‘특정 문자’, 순서) LEFT 왼쪽으로 정렬합니다 LEFT(칼럼) RIGHT 오른쪽으로 정렬합니다 RIGHT(칼럼) PUT 숫자 칼럼을 문자칼럼로 변경합니다. PUT(칼럼, 문자 포맷) INPUT 문자 칼럼을 숫자칼럼로 변경합니다. INPUT(칼럼, 숫자 포맷) 예제 PROC SQL; CREATE TABLE TEST AS SELECT NAME, AGE, COMPRESS(NAME,'스') AS COMPRESS, TRANSLATE(NAME,'AA','스') AS TRANS ,TRANWRD(NAME,'스','AAAA') AS TRANSWRD, SUBSTR(NAME, 1,2) AS SUBSTR, CATX('-',NAME, SEX) AS CATX ,FIND(NAME,'스') AS FIND, PUT(AGE, 5.) AS PUT, COMPRESS(PUT(AGE, 5.)) AS COM_PUT FROM SASHELP.CLASS QUIT; NAME AGE COMPRESS TRANS TRANSWRD SUBSTR CATX FIND PUT COM_PUT 알프레드 14 알프레드 알프레드 알프레드 알 알프레드-남 0 14 14 앨리스 13 앨리 앨리 AA 앨리 AAAA 앨 앨리스-여 5 13 13 바바라 13 바바라 바바라 바바라 바 바바라-여 0 13 13 캐럴 14 캐럴 캐럴 캐럴 캐 캐럴-여 0 14 14 헨리 14 헨리 헨리 헨리 헨 헨리-남 0 14 14 제임스 12 제임 제임AA 제임AAAA 제 제임스-남 5 12 12 제인 12 제인 제인 제인 제 제인-여 0 12 12 자넷 15 자넷 자넷 자넷 자 자넷-여 0 15 15 제프리 13 제프리 제프리 제프리 제 제프리-남 0 13 13 존 12 존 존 존 존 존-남 0 12 12 조이스 11 조이 조이 AA 조이 AAAA 조 조이스-여 5 11 11 주디 14 주디 주디 주디 주 주디-여 0 14 14 루이스 12 루이 루이 AA 루이 AAAA 루 루이스-여 5 12 12 메리 15 메리 메리 메리 메 메리-여 0 15 15 필립 16 필립 필립 필립 필 필립-남 0 16 16 로버트 12 로버트 로버트 로버트로 로버트-남 0 12 12 로날드 15 로날드 로날드 로날드로 로날드-남 0 15 15 토마스 11 토마 토마 AA 토마 AAAA 토 토마스-남 5 11 11 윌리엄 15 윌리엄 윌리엄 윌리엄 윌 윌리엄-남 0 15 15 SASHELP.CLASS 테이블에서 칼럼 NAME과 AGE를 이용해서 여러 가지 특수 명령어를 사용했습니다. 1) 우선 칼럼 COMPRESS를 보겠습니다. COMPRESS(NAME,‘스’)에 따라 칼럼 NAME에서 ‘스’를 제외하고 됩니다. 결과에 따라 제임스, 조이스, 루이스, 토마스에서 ‘스’가 제외된 결괏값이 나왔습니다. 2) 다음으로 칼럼 TRANS를 보겠습니다. TRANSLATE(NAME,‘AA’,‘스’)에 따라 칼럼 NAME의 ‘스’가 ‘AA’로 변경되었습니다. 3) 다음은 칼럼 TRAN0WRD를 보겠습니다. TRANWRD(NAME,‘스’,‘AAAA’)에 따라 칼럼 NAME의 ‘스’가 ‘AAAA’로 변경되었습니다. 4) TRANSLATE와 TRANWRD 명령어는 얼핏 보면 동일한 역할을 수행합니다. 공통점은 대상 단어의 길이는 제한이 없다는 점입니다. ‘스’를 쓰든 ‘임스’, ‘제임스’를 쓰든 대상이 되는 단어의 길이는 자유롭게 설정할 수 있습니다. 그러나 둘 사이는 차이점이 있습니다. TRANSLATE는 문자를 변경합니다. 따라서 한글로는 1글자(1글자=2BYTE), 영어로는 2자(1자=1BYTE)를 바꿀 수 있습니다. 2BYTE 만큼 바꿀 수 있습니다. 반면에 TRANWRD 명령어는 단어를 변경합니다. 1글자 이상 되는 단어를 변경할 수 있습니다. 그래서 ‘AAAA’처럼 4자짜리로 변경할 수 있습니다. 5) 명령어 SUBSTR은 칼럼에서 위치를 정해서 데이터를 추출하는 명령어입니다. 예를 들어 SUBSTR(NAME, 1,2) 일 경우 칼럼 NAME에서 문자의 첫 번째부터 두 번째를 추출하라는 의미입니다. 다만 여기서 ‘1,2’ 와 같은 위치정보는 BYTE 개념입니다. 따라서 알파벳을 기준으로 한다고 생각하시면 됩니다. 앞에서 배웠듯이 알파벳은 1BYTE에 한 자지만, 한글은 2BYTE에 한 글자입니다. 그러므로 한글 데이터 일 경우 첫 번째 한 글자를 뽑고 싶다면 SUBSTR(NAME, 1,2)를, 첫 번째부터 두 번째 글자를 뽑고 싶다면 SUBSTR(NAME, 1,4)를 사용하시면 됩니다. 6) CATX 명령어는 여러 칼럼을 통합하는 명령어입니다. CATX(‘-’,NAME, SEX)는 칼럼 NAME과 SEX 사이에 ‘-’를 넣어서 두 칼럼을 하나의 칼럼으로 합치는 명령어입니다. 칼럼의 개수는 2개 이상 가능합니다. 7) FIND 명령어는 칼럼 내에서 특정한 문자의 위치를 찾는 명령어입니다. FIND(NAME,‘스’)는 칼럼 NAME에서 ‘스’라는 문자가 몇 번째 위치에 있는지를 찾는 명령어입니다. 만약 칼럼 NAME에서 ‘제임스’라는 데이터가 있다면 FIND 명령어의 결괏값은 5가 됩니다. 한글은 한 글자가 2개의 위치를 차지하기 때문에 ‘스’가 나오는 처음 나오는 위치는 5가 됩니다. 8) PUT 명령어는 숫자 칼럼을 문자 칼럼으로 변경하는 명령어입니다. PUT(AGE, 5.)의 경우 칼럼 AGE를 포맷 길이가 5인 문자 칼럼으로 변경하라는 의미입니다. SAS에서는 포맷의 개념을 사용할 때는 ‘.’을 붙여야 합니다. 예를 들어 ‘5.’처럼 포맷 길이(유형) 뒤에 반드시 ‘.’을 붙여줘야 합니다. 그래야 SAS는 명령어가 포맷을 뜻함을 알게 됩니다. 그리고 포맷 길이는 본래 칼럼 데이터 길이보다 길어야 합니다. 만약 PUT(AGE, 1.)으로 원래의 AGE 내부 데이터의 길이인 2보다 작게 입력을 할 경우 오류가 발생하게 됩니다. PUT 명령어는 대상 칼럼이 숫자 칼럼인 경우에만 사용 가능합니다. 9) INPUT 명령어는 문자 칼럼을 숫자 칼럼으로 변경하는 명령어입니다. INPUT(칼럼, N.)의 경우 대상 칼럼을 포맷 길이가 N인 숫자 같은 방식으로 명령어가 사용됩니다. 소수점 이하 숫자가 있을 경우 ‘5.2’처럼 5자리 포맷이되 소수점 아래 2글자까지 표현을 하라는 의미로 사용할 수 있습니다. 8-06. SQL로 특정 데이터 추출하기(WHERE) SQL로 데이터를 추출할 때 특정한 조건을 주는 경우가 있습니다. 이는 데이터를 다루는 데 매우 자주 사용되는 방법입니다. ‘나이가 20살인 사람을 뽑기’, ‘이름이 존인 사람을 뽑기’처럼 특정한 조건을 줄 수 있죠. 지금부터는 SQL을 활용하여 특정 조건의 데이터를 추출하는 방법을 알아보겠습니다. 명령어 WHERE XXX=YY: 칼럼 XXX가 YY인 데이터를 불러옵니다. 예제 1 PROC SQL; CREATE TABLE TEST AS SELECT NAME, AGE, HEIGHT FROM SASHELP.CLASS WHERE AGE=12 QUIT; Name Age Height 제임스 12 57.3 제인 12 59.8 존 12 59 루이스 12 56.3 로버트 12 64.8 예제 1에 따라 나온 결괏값에는 칼럼 AGE=12인 값들만 출력되었습니다. 칼럼 명도 바꿀 수 있고 ‘=’이외에 다른 부등호를 사용할 수 있습니다. 예를 들어 ‘WHERE 59<=HEIGHT<=61’을 입력할 경우 HEIGHT가 59~61사이에 있는 데이터가 출력됩니다. AND와 OR WHERE 명령어에서 ‘AND’와 ‘OR’를 사용할 수 있습니다. 1) AND는 ‘그리고’라는 의미입니다. 우리가 중학교 때 학습한 집단 간 벤다이어그램에서 교집합에 해당하는 부분입니다. 모든 조건에 부합하는 데이터만 출력이 됩니다. 2) OR는 ‘또는’이라는 의미입니다. 벤다이어그램에서 합집합에 해당하는 부분입니다. 여러 개의 명령어가 OR와 함께 있다면, 각각의 조건에 하나라도 부합하는 데이터는 모두 출력이 됩니다. 명령어 WHERE XXX=YY AND ZZZ=AA: 칼럼 XXX가 YY이고 칼럼 ZZZ가 AA인 데이터를 불러옵니다. 예제 2 PROC SQL; CREATE TABLE TEST AS SELECT NAME, AGE, HEIGHT FROM SASHELP.CLASS WHERE AGE=12 AND 59<=HEIGHT<=61 QUIT; Name Age Height 제인 12 59.8 존 12 59 칼럼 AGE가 12이고 HEIGHT가 59~61 사이인 데이터가 출력되는 것을 확인할 수 있습니다. AND를 OR로 바꿔서도 실행해 보시기 바랍니다. 예제 4. 와는 다른 결괏값이 출력되는 것을 확인할 수 있습니다. tip AND와 OR를 이용하면 WHERE 명령어를 2개 이상 사용할 수 있습니다. 예를 들어 ‘AGE=12’ 이면서 ‘59<=HEIGHT<=61’인 두 개의 조건을 동시에 적용하고 싶을 경우 ‘WHERE AGE=12 AND 59<=HEIGHT<=61’이라고 명령어를 입력하면 됩니다(모든 수식이 가능합니다. =(EQ), ^=(NE, 같지 않다), >(GT), <(LT), >=(GE), <=(LE) 등의 식을 사용할 수 있습니다. 괄호 안의 영어를 쓰셔도 동일한 결과를 얻을 수 있습니다.). 그러면 칼럼 AGE와 HEIGHT에서 조건에 맞는 데이터만 출력이 됩니다. 데이터가 특정 문자인 경우 칼럼이 문자일 때는 데이터에 ‘ ’을 씌우고 숫자일 때는 씌우지 않습니다. SAS는 문자 칼럼과 숫자 칼럼을 구분합니다. 그래서 문자 칼럼일 경우에는 데이터에 ‘ ’를 씌워서 구분을 해줘야 합니다. 예를 들어 칼럼 NAME에서 존을 출력하고 싶다면 ‘WHERE NAME=‘존’’으로 입력을 해야 합니다. 만약 문자 칼럼에 ‘ ’을 붙이지 않는다면 SAS는 이를 숫자로 받아들이고 오류 결괏값을 나타냅니다. 명령어 WHERE XXX='존': 칼럼 XXX가 '존'인 데이터를 불러옵니다. 예제 3 PROC SQL; CREATE TABLE TEST AS SELECT NAME, AGE, HEIGHT FROM SASHELP.CLASS WHERE NAME='존' QUIT; Name Age Height 존 12 59 칼럼 NAME이 '존'인 데이터만 추출됐음을 확인할 수 있습니다. tip WHERE 조건 이외의 경우에도 문자 칼럼인 경우 ' '을 씌우고 숫자 칼럼인 경우 씌우지 않습니다. 문자 칼럼임에도 ' '를 씌우지 않으면 에러가 발생합니다. 예를 들어 WHERE NAME=존으로 입력할 경우 SAS는 존을 칼럼으로 인식합니다. 칼럼 존은 테이블에 없으므로 에러가 발생합니다. 8-07. SQL로 데이터 정렬하기(ORDER BY) 때때로 데이터를 보기 좋게 순서대로 정렬을 해야 할 때가 있습니다. 또 일부 SAS 명령어는 데이터가 정렬이 돼 있어야 실행이 되기도 합니다. 지금부터 SQL은 어떻게 데이터를 정렬하는지 알아보겠습니다. 명령어 ORDER BY XXX: 칼럼 XXX의 오름차순으로 데이터를 정렬합니다. 예제 PROC SQL; CREATE TABLE TEST AS SELECT * FROM SASHELP.CLASS ORDER BY AGE QUIT; Name Sex Age Height Weight 토마스 남 11 57.5 85 조이스여 11 51.3 50.5 제임스 남 12 57.3 83 루이스여 12 56.3 77 존 남 12 59 99.5 제인여 12 59.8 84.5 로버트 남 12 64.8 128 바바라여 13 65.3 98 제프리 남 13 62.5 84 앨리스여 13 56.5 84 알프레드 남 14 69 112.5 주디여 14 64.3 90 헨리 남 14 63.5 102.5 캐럴여 14 62.8 102.5 메리여 15 66.5 112 윌리엄 남 15 66.5 112 자넷여 15 62.5 112.5 로날드 남 15 67 133 필립 남 16 72 150 데이터가 칼럼 AGE의 오름차순으로 정렬된 것을 확인할 수 있습니다. ORDER BY 구문을 통해서 정렬을 할 때 칼럼 AGE만 바뀌는 게 아니라 전체 칼럼이 모두 함께 이동합니다. 칼럼 AGE가 11인 ‘토마스, 남, 11, 57.5, 85’ 행이 가장 위로 이동합니다. 엑셀 정렬과 비슷합니다. 엑셀에서 필터를 걸고 정렬을 할 때, 전체 데이터가 정렬 기준을 따라 이동하는 것도 동일합니다. tip 만약 ORDER BY로 정렬을 하고 싶을 때 내림차순으로 정렬을 하고 싶으시다면 칼럼 뒤에 ‘DESC’를 붙이면 됩니다. 예를 들어 AGE의 내림차순으로 정렬을 하려면 ‘ORDER BY AGE DESC’로 적으시면 됩니다. 그러면 칼럼 AGE 값이 가장 큰 행이 위에서부터 나타나게 됩니다. PROC SQL; CREATE TABLE TEST AS SELECT * FROM SASHELP.CLASS ORDER BY AGE DESC QUIT; 여러 개 칼럼을 동시에 정렬하기 여러 가지 칼럼을 동시에 정렬하려면 대상 칼럼을 모두 적어주시면 됩니다. 다만 칼럼 사이에 ‘,’를 붙여주시면 됩니다. SAS 명령어에서는 칼럼들 사이를 ‘ ’(공백)으로 구분했다면, SQL 명령어에서는 ‘,’로 구분한다는 점을 기억하시면 됩니다. SELECT 명령어에서 칼럼을 ‘,’로 구분하는 걸 확인하셨을 겁니다. SQL에서는 칼럼들을 나열할 때 ‘,’를 두어 구분합니다. 칼럼 AGE와 HEIGHT 순으로 정렬하는 명령어는 아래와 같습니다. 명령어 ORDER BY AGE, HEIGHT: 칼럼 AGE를 정렬하고, AGE 별로 칼럼 HEIGHT를 정렬합니다 예제 2 PROC SQL; CREATE TABLE TEST AS SELECT * FROM SASHELP.CLASS ORDER BY AGE, HEIGHT QUIT; Name Sex Age Height Weight 조이스여 11 51.3 50.5 토마스 남 11 57.5 85 루이스여 12 56.3 77 제임스 남 12 57.3 83 존 남 12 59 99.5 제인여 12 59.8 84.5 로버트 남 12 64.8 128 앨리스여 13 56.5 84 제프리 남 13 62.5 84 바바라여 13 65.3 98 캐럴여 14 62.8 102.5 헨리 남 14 63.5 102.5 주디여 14 64.3 90 알프레드 남 14 69 112.5 자넷여 15 62.5 112.5 메리여 15 66.5 112 윌리엄 남 15 66.5 112 로날드 남 15 67 133 필립 남 16 72 150 ORDER BY 뒤에 오는 칼럼의 순서대로 우선순위를 부여받아 데이터가 정렬됩니다. 예제 2에서는 앞에 있는 칼럼 AGE의 순서대로 우선 정렬을 한 다음, 그에 속해 있는 칼럼 HEIGHT가 정렬이 됩니다. 칼럼 AGE가 정렬이 된 다음, 칼럼 AGE=11에 속해있는 칼럼 HEIGHT가 순서대로 정렬이 되는 식입니다. 특정 칼럼 AGE 값에 속한 칼럼 HEIGHT끼리 다시 재정렬을 한다고 보시면 됩니다. 8-08. SQL로 조건문 만들기(CASE WHEN) 특정 조건을 만족하면 새로운 값을 만들어내는 칼럼을 생성하는 방법을 알아보겠습니다. 예를 들어 칼럼 AGE가 12일 경우 ‘열두 살’을, 13일 경우 ‘열세 살’이 나오도록 새로운 칼럼을 만들고 싶을 때가 있습니다. 이처럼 특정 조건을 주고 이에 따른 결괏값을 생성하는 방법을 알아보겠습니다. 명령어 CASE WHEN XXX=YY THEN ZZ END AS PPP: 칼럼 XXX가 YY 일 때, ZZ 값을 갖는 칼럼 PPP를 생성합니다. 예제 1 PROC SQL; CREATE TABLE TEST AS SELECT *, CASE WHEN AGE=12 THEN '열두 살' WHEN AGE=13 THEN '열세 살' END AS NEW_AGE FROM SASHELP.CLASS QUIT; Name Sex Age Height Weight NEW_AGE 알프레드 남 14 69 112.5. 앨리스여 13 56.5 84 열세 살 바바라여 13 65.3 98 열세 살 캐럴여 14 62.8 102.5. 헨리 남 14 63.5 102.5. 제임스 남 12 57.3 83열두 살 제인여 12 59.8 84.5열두 살 자넷여 15 62.5 112.5. 제프리 남 13 62.5 84 열세 살 존 남 12 59 99.5열두 살 조이스여 11 51.3 50.5. 주디여 14 64.3 90. 루이스여 12 56.3 77열두 살 메리여 15 66.5 112. 필립 남 16 72 150. 로버트 남 12 64.8 128열두 살 로날드 남 15 67 133. 토마스 남 11 57.5 85. 윌리엄 남 15 66.5 112. 칼럼 AGE 값과 칼럼 NEW_AGE를 비교해 보면 동일함을 확인할 수 있습니다. WHEN 이후로 조건과 결괏값을 넣어주시면 됩니다. WHEN 사용자의 임의대로 추가할 수 있습니다. 사칙연산 값이나 부등호를 이용하여 조건에 맞는 결괏값을 만들어낼 수도 있습니다. 사실 ‘CASE WHEN’명령어는 앞서 배운 SAS 명령어의 ‘IF~THEN’ 명령어와 기능은 거의 동일합니다. 예제 1의 명령어와 동일한 SAS 명령어는 아래와 같습니다. DATA TEST; SET SASHELP.CLASS; IF AGE=12 THEN NEW_AGE='열두 살'; ELSE IF AGE=13 THEN NEW_AGE='열세 살'; RUN; ELSE 명령어 SQL의 ‘CASE WHEN’ 명령어에서 ELSE 명령어를 쓸 수 있습니다. WHEN 명령어로 지정한 값 이외 다른 모든 값을 지정할 때 사용합니다. 예를 들어 칼럼 AGE=12 이외의 값일 경우 ‘나머지’라는 값을 출력하는 경우를 생각해 보겠습니다. 예제 2 PROC SQL; CREATE TABLE TEST AS SELECT *, CASE WHEN AGE=12 THEN '열두 살' ELSE '나머지' END AS NEW_AGE FROM SASHELP.CLASS QUIT; Name Sex Age Height Weight NEW_AGE 알프레드 남 14 69 112.5 나머지 앨리스여 13 56.5 84 나머지 바바라여 13 65.3 98 나머지 캐럴여 14 62.8 102.5 나머지 헨리 남 14 63.5 102.5 나머지 제임스 남 12 57.3 83열두 살 제인여 12 59.8 84.5열두 살 자넷여 15 62.5 112.5 나머지 제프리 남 13 62.5 84 나머지 존 남 12 59 99.5열두 살 조이스여 11 51.3 50.5 나머지 주디여 14 64.3 90 나머지 루이스여 12 56.3 77열두 살 메리여 15 66.5 112 나머지 필립 남 16 72 150 나머지 로버트 남 12 64.8 128열두 살 로날드 남 15 67 133 나머지 토마스 남 11 57.5 85 나머지 윌리엄 남 15 66.5 112 나머지 ELSE로 인해서 AGE=12 이외의 행의 칼럼 NEW_AGE에는 모두 '나머지'라는 값이 입력됩니다. 8-09. SQL로 그룹별로 연산하기(GROUP BY) GROUP BY 명령어는 SAS뿐만 아니라 ORACLE에서도 대단히 자주 사용되는 명령어입니다. GROUP BY는 특정 값들을 그룹으로 묶고 해당 그룹 안에서의 사칙연산 같은 명령어를 수행하는 명령어입니다. 만약 GROUP BY로 나이 데이터를 3개 그룹으로 나눈 다음 덧셈(+) 명령어를 입력한다면, 각 그룹 안에서만 덧셈 명령어를 수행하게 됩니다. 명령어 GROUP BY XXX: 칼럼 XXX를 기준으로 나눠서 연산을 수행합니다 예제 PROC SQL; CREATE TABLE TEST AS SELECT *, SUM(AGE) AS SUM_AGE FROM SASHELP.CLASS GROUP BY SEX QUIT; Name Sex Age Height Weight SUM_AGE 제임스 남 12 57.3 83 134 존 남 12 59 99.5 134 필립 남 16 72 150 134 로날드 남 15 67 133 134 토마스 남 11 57.5 85 134 제프리 남 13 62.5 84 134 헨리 남 14 63.5 102.5 134 윌리엄 남 15 66.5 112 134 알프레드 남 14 69 112.5 134 로버트 남 12 64.8 128 134 제인 여 12 59.8 84.5 119 메리여 15 66.5 112 119 바바라여 13 65.3 98 119 루이스여 12 56.3 77 119 주디여 14 64.3 90 119 조이스여 11 51.3 50.5 119 앨리스여 13 56.5 84 119 캐럴여 14 62.8 102.5 119 자넷여 15 62.5 112.5 119 GROUP BY 명령어는 특정 칼럼 값을 기준으로 데이터를 나눠서 연산하는 작업을 수행합니다. 예를 들어 예제와 같이 GROUP BY SEX를 입력한다면 SEX의 ‘남’, ‘여’ 데이터를 구분하여 각각 연산 작업을 실시합니다. 칼럼 SEX의 데이터는 ‘남’과 ‘여’ 두 종류뿐이기 때문에 칼럼 AGE를 두 기준으로 나눈 다음 연산을 수행합니다. 따라서 SUM(AGE)는 칼럼 SEX의 ‘남’, ‘여’ 각각 따로 연산을 수행하였습니다. 그 결과 칼럼 SEX가 ‘남’인 경우 SUM(AGE) 값은 134, 칼럼 SEX가 ‘여’인 경우 SUM(AGE) 값은 119로 나왔습니다. 만약 칼럼 SEX의 값이 ‘남’, ‘여’, ‘아이’로 구성돼 있었다면, 세 가지 기준으로 각각 연산을 수행했을 것입니다. tip SUM(AGE) 명령어는 AGE의 모든 값을 합하라는 명령어입니다. 8-10. SQL로 그룹별 특정 데이터 추출하기(HAVING) (전자책 내용) 죄송합니다. 해당 자료는 위키독스 웹 사이트에서는 비공개 처리되어 구현 코드와 코드에 대한 상세한 설명은 아래 링크의 유료 E-book을 구매하시면 확인할 수 있습니다. (링크) SAS로 하는 기초 데이터 전처리, 핸들링(Data handling) 전자책 구매 8-11. SQL 명령어 순서 (전자책 내용) 죄송합니다. 해당 자료는 위키독스 웹 사이트에서는 비공개 처리되어 구현 코드와 코드에 대한 상세한 설명은 아래 링크의 유료 E-book을 구매하시면 확인할 수 있습니다. (링크) SAS로 하는 기초 데이터 전처리, 핸들링(Data handling) 전자책 구매 8-12. SQL로 테이블에 없는 칼럼 생성 후 연산(CALCULATED) (전자책 내용) 죄송합니다. 해당 자료는 위키독스 웹 사이트에서는 비공개 처리되어 구현 코드와 코드에 대한 상세한 설명은 아래 링크의 유료 E-book을 구매하시면 확인할 수 있습니다. (링크) SAS로 하는 기초 데이터 전처리, 핸들링(Data handling) 전자책 구매 8-13. SQL로 날짜 명령어 수행하기 (전자책 내용) 죄송합니다. 해당 자료는 위키독스 웹 사이트에서는 비공개 처리되어 구현 코드와 코드에 대한 상세한 설명은 아래 링크의 유료 E-book을 구매하시면 확인할 수 있습니다. (링크) SAS로 하는 기초 데이터 전처리, 핸들링(Data handling) 전자책 구매 8-번외. SQL로 데이터 직접 입력하기 SQL로 테이블을 직접 생성하고, 데이터를 직접 입력하는 경우를 배워보겠습니다. SQL은 주로 완성된 테이블을 이용하여 조합하는 경우가 많기 때문에 데이터를 직접 입력할 일은 자주 일어나지 않습니다. 1) SQL로 테이블 생성하기 SQL로 테이블을 직접 만들 수 있습니다. 우선 빈 테이블부터 만들어보겠습니다. 명령어 PROC SQL;: 프러시저 SQL을 시행합니다. CREATE TABLE XXX: 테이블 XXX를 생성합니다. (YYY CHAR(6)): 문자 변수이면서 길이가 6인 칼럼 YYY를 만듭니다. ;: 전체 SQL 명령어를 종료합니다. QUIT;: 프러시저 SQL을 종료합니다. 예제 1 PROC SQL; CREATE TABLE TEST (NAME CHAR(12) ,AGE NUM ,HEIGHT NUM ,WEIGHT NUM ,ADDR CHAR) QUIT; NAME AGE HEIGHT WEIGHT ADDR 예제를 통해서 데이터가 없는 빈 테이블이 생성됐습니다. 문자 칼럼 NAME, ADDR과 숫자 칼럼 AGE, HEIGHT, WEIGHT가 만들어졌습니다. 만약 CHAR 뒤에 괄호를 만들지 않는다면 기본 길이로 칼럼이 생성됩니다. 길이는 8BYTE입니다. 문자 칼럼은 4글자만 입력이 됩니다. 따라서 칼럼 NAME은 12BYTE로 한글 6글자 영어 12개 알파벳, 칼럼 ADDR은 8BYTE로 한글 4글자 영어 12개 알파벳까지 입력이 됩니다. 숫자 칼럼도 ‘( )’를 만들지 않는다면 기본값으로 생성이 됩니다. 숫자 칼럼 또한 기본 길이는 8BYTE입니다. 다만 문자 칼럼과는 다르게 309자까지 입력이 가능합니다. 충분히 긴 길이이므로 기본값으로 생성하셔도 무방합니다. 2) SQL로 데이터 입력하기 SQL로 만들어진 빈 테이블에 값을 넣어야 할 때가 있습니다. 그럴 때 사용되는 방법은 크게 두 가지입니다. 하나는 데이터를 직접 입력하는 방법이고, 다른 하나는 불러오는 방법입니다. 우선 데이터를 직접 입력하는 방법을 배워보겠습니다. 위에서 만들어진 테이블 TEST를 활용하여 실습해 보겠습니다. 직접 데이터를 입력하기 명령어(1) INSERT INTO TEST SET XXX=‘YYY’, ZZZ=111: 테이블 TEST의 칼럼 XXX에 문자 값 YYY를 입력하고 칼럼 ZZZ에 숫자 값 111을 입력합니다. 예제 2 PROC SQL; INSERT INTO TEST SET NAME='호날두', AGE=27, HEIGHT=6, WEIGHT=70 SET NAME='메시', AGE=26, HEIGHT=5, WEIGHT=65, ADDR='바르셀로나' QUIT; NAME AGE HEIGHT WEIGHT ADDR 호날두 27 6 70. 메시 26 5 65 바르셀로 INSERT INTO로 대상 테이블을 정합니다. INSERT INTO는 영어로 ‘~에 삽입하다’라는 의미입니다. 이 명령어로 테이블 TEST에 데이터를 삽입할 것임을 명령합니다. 다음으로 SET 명령어를 살펴보겠습니다. 앞선 SAS 명령어에서 SET은 테이블을 불러오는 역할을 했습니다. 그러나 SQL에서는 이와는 조금 다릅니다. 여기서 SET 명령어는 칼럼을 지목하는 역할을 합니다. SET 명령어 다음에 칼럼과 데이터를 나열하여 테이블에 데이터를 입력하게 됩니다. SET 명령어는 한 행에만 유효합니다. 만약 2개의 행에 데이터를 입력하려면 SET 명령어를 두 번 사용해야 합니다. 예제 3.에서는 2개의 행을 입력하기 때문에 SET 명령어가 두 번 입력됐습니다. 그리고 테이블에 존재하지만 SET 명령어에 나타나지 않은 칼럼은 무시하고 입력하지 않습니다. 직접 데이터를 입력하기 명령어(2) SET 명령어와는 다른 VALUE 명령어를 배워보겠습니다. SET 명령어는 매 행마다 입력할 칼럼명을 지정해야만 했습니다. 하지만 VALUE 명령어는 칼럼명을 입력하지 않아도 됩니다. 칼럼의 순서대로 입력할 데이터를 넣어주시면 됩니다. 위의 예제 1에 이어서 진행을 해보겠습니다. INSERT INTO TEST VALUE(‘XXX’,11,22,33, ‘YYY’: 테이블 TEST의 칼럼에 데이터 ‘XXX’,11,22,33, ‘YYY’를 차례대로 입력합니다. 예제 3 PROC SQL; INSERT INTO TEST VALUES ('벤제마', 30, 6, 72, '런던') VALUES ('그리즈만',25, 5, 67, '마드리드') QUIT; NAME AGE HEIGHT WEIGHT ADDR 호날두 27 6 70. 메시 26 5 65 바르셀로 벤제마 30 6 72 런던 그리즈만 25 5 67 마드리드 예제 3의 테이블에서 새로운 행을 추가했습니다. 예제 3처럼 SET 명령어를 활용하지 않고 VALUE 명령어를 이용하여 행을 추가했습니다. VAULE 명령어도 SET 명령어와 마찬가지로 한 행씩 추가를 해야 합니다. 다만 SET 명령어와 달리 칼럼을 지정하지 않는 게 특징입니다. 칼럼을 지정하지 않으므로, 칼럼의 개수와 똑같은 수의 데이터를 입력해 줘야 합니다. SET 명령어에서는 칼럼을 지정해서 데이터를 입력하기 때문에 누락 값이 있어도 입력이 가능했습니다. 그러나 VALUE 명령어는 데이터를 입력할 칼럼을 지정하지 않으므로, 칼럼 수만큼 데이터가 없을 경우 에러가 발생하게 됩니다. 이를 유의하여 데이터를 입력하시기 바랍니다. tip PROC SQL; INSERT INTO TEST VALUES ('포그바', 21, 7, 78) QUIT; → 테이블 TEST의 칼럼은 5개인데 VALUE 안의 데이터가 4개이므로 에러가 발생합니다. 직접 데이터를 입력하기 명령어(3) VALUE 명령어를 활용한 데이터 입력을 하나 더 살펴보겠습니다. 위에서 VALUE 명령어를 만들었지만 데이터에 누락 값이 있을 경우 에러가 난다고 설명한 바가 있습니다. 그렇지만 애초에 누락 값이 있은 경우가 있습니다. 그럴 경우 SET 명령어를 쓰면 되지만 매번 칼럼 이름을 적어야 하는 등 불편할 수 있습니다. 이럴 경우 누락 값이 있더라도 VALUE 명령어를 사용하여 입력하는 방법을 알아보겠습니다. INSERT INTO TEST (XXX, YYY, ZZZ) VALUE(‘AAA’,‘BBB’,111);: 테이블 TEST의 XXX, YYY, ZZZ 칼럼에 데이터 ‘AAA’,‘BBB’,111 데이터를 차례대로 입력합니다. 예제 4 PROC SQL; INSERT INTO TEST (NAME, AGE, ADDR) VALUES ('므키타리안', 29, '북런던') QUIT; NAME AGE HEIGHT WEIGHT ADDR 호날두 27 6 70. 메시 26 5 65 바르셀로 벤제마 30 6 72 런던 그리즈만 25 5 67 마드리드 므키타리안 29. . 북런던 INSERT INTO TEST 아래쪽에 괄호로 (NAME, AGE, ADDR)이 지정되었습니다. 3개의 칼럼에만 데이터를 입력하겠다는 의미입니다. 그래서 VALUE 명령어에는 3개의 데이터만 입력하면 됩니다. 칼럼 NAME, AGE, ADDR을 대상으로 한 데이터만 있으면 됩니다. 칼럼 순서와 데이터 입력 순서는 같아야 합니다. 나머지는 누락 값으로, 빈칸으로 표현이 됩니다. 9. SAS MACRO(매크로) 명령어 매크로(Macro)는 한마디로 자동화 프로그램을 의미합니다. 복잡한 코드 단어를 간단한 방법으로 수정할 수 있으며 반복되는 작업도 간단하게 만들 수 있습니다. 매크로는 문자 변수나 숫자 변수로 생성이 됩니다. 변수 속성을 바꾸고 싶으시다면, 매크로 변수 생성 이후, 값을 변환하는 과정을 거쳐야 합니다. 매크로는 SAS에서 크게 두 가지 용도로 사용됩니다. 첫 번째가 특정 텍스트를 손쉽게 변경할 때입니다. 이를 사용자 정의 매크로 칼럼이라고 합니다. 두 번째로는 반복 작업을 시행할 때입니다. 이는 SAS 코드 반복 생성이라고 합니다. 매크로는 복잡한 작업을 손쉬운 방법으로 구현할 수 있습니다. 사용자 편의성을 높이는 프로그램입니다. 그리고 매크로를 사용하면 코드 문장의 길이를 줄일 수 있어서 SAS 속도를 높일 수도 있습니다. 그러면 우선 사용자 정의 매크로 칼럼 사용법부터 알아보겠습니다. 9-1. SAS MACRO 직접 입력 명령어(LET) LET 명령어 가장 간단한 방법은 LET 명령어를 사용하는 것입니다. LET 명령어는 사용자가 직접 매크로를 생성하는 것입니다. 그렇다면 매크로 생성 방법과 매크로 사용방법을 예제를 통해 알아보도록 하겠습니다. 명령어 %LET XXX=YYY; :매크로 XXX가 YYY로 출력되는 매크로를 생성합니다 &XXX. : 매크로 XXX를 출력합니다. %PUT &=XXX. : 매크로 XXX의 출력값을 로그 창을 통해 확인합니다. 예제 %LET NAME=존; %PUT &=NAME; %PUT &NAME.; ----로그기록 시작---- %LET NAME=존; %PUT &=NAME; NAME=존 %PUT &NAME.; 존 ----로그기록 끝---- 우선 %LET(매크로 생성 방법)과 &(트리거)과 %PUT(결괏값 출력) 활용방법부터 보겠습니다. 1) 매크로를 생성할 때는 %LET 명령어를 통해 만듭니다. 반드시 ‘%’를 붙여야 SAS는 이를 매크로 칼럼 생성으로 인식합니다. ‘%’는 표로 이뤄진 결괏값을 출력하는 게 아니라 SAS에 명령어를 인식시키거나 로그기록에만 출력을 할 때 사용하는 명령어입니다. ‘%’가 들어가는 명령어는 표로 이뤄진 결괏값을 출력하지 않는다는 점을 기억하면 됩니다. %LET을 통해 매크로를 생성할 수 있습니다. %LET NAME=존의 경우 매크로 변수 NAME을 입력할 경우 ‘존’이라는 데이터를 출력하라는 의미입니다. 2) '&'명령어를 통해 %LET 명령어로 생성된 매크로 변숫값을 불러올 수 있습니다. 이를 매크로 트리거(방아쇠라는 의미)라고 합니다. 모든 매크로는 ‘&’을 통해 불러옵니다. 따라서 &NAME. 을 입력할 경우 SAS는 이를 매크로 칼럼 NAME을 불러오라는 명령어로 인식합니다. 그래서 ‘존’이라는 값이 출력됩니다. 3) %PUT 명령어의 경우 표로 이뤄진 결괏값을 출력하는 게 아니라 로그 기록에 결괏값을 출력하는 명령어입니다. %PUT 명령어를 통해 매크로 칼럼과 결괏값을 로그 창에서 확인할 수 있습니다. %PUT &=NAME. 은 매크로 칼럼 NAME의 결괏값을 출력하라는 명령어입니다. 그리고 %PUT &NAME. 은 매크로 칼럼 NAME의 결괏값만을 출력하게 됩니다. &=NAME. 은 매크로 칼럼과 결괏값을 동시에 출력하고 &NAME. 은 결괏값만을 출력하게 됩니다. tip 매크로 칼럼을 불러올 때 마지막을 ‘.’을 찍어주는 게 좋습니다. ‘.’은 매크로 칼럼이 끝나는 지점을 의미합니다. 예를 들어 ‘존 스탁턴’이라는 결괏값을 출력하고 싶을 때, ‘&NAME 스탁턴’으로 불러올 경우 에러가 발생합니다. 왜냐하면 SAS에서는 NAME 스탁턴 전체를 매크로 변수로 보게 되기 때문입니다. 이를 방지하기 위해서는 매크로 칼럼 마지막에 ‘.’을 붙여서 매크로 칼럼이 끝남을 알려줘야 합니다. ‘&NAME. 스탁턴’으로 매크로 칼럼을 불러온다면 에러 없이 결괏값을 출력할 수 있을 것입니다. SAS가 매크로 칼럼 NAME과 ‘스탁턴’이라는 값을 따로 인식해서 불러오기 때문입니다. 해당 결괏값은 로그기록에서 확인할 수 있습니다. LET 명령어를 사용한 SAS SQL 명령어 예제 %LET NAME='존'; PROC SQL; CREATE TABLE TEST AS SELECT NAME, SEX, AGE FROM SASHELP.CLASS WHERE NAME=&NAME. QUIT; Name Sex Age 존 남 12 매크로를 SQL에 적용을 했습니다. 우선 %LET 명령어로 매크로 칼럼 NAME을 생성합니다. 이 매크로는 결괏값으로 ‘존’을 생성합니다. 다음으로 SQL 문장을 생성하고 WHERE 명령어를 통해서 칼럼 NAME=‘존’인 행만 불러오게 됩니다. ‘ ’을 붙이는 이유는 SAS에서 문자 칼럼은 ‘ ’을 붙여야 하기 때문입니다. 이를 붙이지 않을 경우 SAS는 이를 문자 변숫값이 아닌, 칼럼으로 인식을 합니다. 칼럼 존은 존재하지 않기 때문에 에러가 발생합니다. tip SQL 문장에서 WHERE NAME=‘&NAME.’으로 입력을 하면 되지 않을까, 생각하실 수도 있습니다. 하지만 ‘ ’안에 매크로 트리거(&)가 있다면 SAS는 이를 매크로 트리거로 인식하지 않고 단순한 텍스트&로 인식을 합니다. 그래서 매크로가 작동하지 않습니다. 따라서 처음 매크로를 생성할 때 ‘ ’를 붙여서 생성하는 게 가장 좋은 방법입니다. 9-2. SAS MACRO 연동 입력 명령어(CALL SYMPUT) %LET 명령어가 직접 명령어를 하나하나 입력해야 하는 명령어입니다. 반면 CALL SYMPUT은 주로 테이블을 활용해서 자동으로 매크로 변수를 생성할 때 사용하는 명령어입니다. 물론 테이블을 활용하지 않고 직접 입력해서 만드는 방법도 있습니다. 그러면 우선 간단한 CALL SYMPUT 명령어 사용방법부터 알아보겠습니다. 1) 직접 입력 명령어 CALL SYMPUT(‘XXX’,‘YYY’): 매크로 변수 XXX를 직접 입력하여 생성합니다. 매크로 변수 XXX의 값은 YYY로 설정합니다. 예제 1 DATA _NULL_; /*빈 데이터를 생성합니다(테이블을 만들지 않습니다)*/ CALL SYMPUT('VALUE','나이'); /*매크로 변수 'VALUE'을 만들고 이 값을 나이로 저장합니다*/ RUN; /*SAS 명령어를 종료합니다*/ %PUT &=VALUE; /*매크로 변수 VALUE의 값을 확인합니다*/ %PUT VALUE=&VALUE. /*매크로 변수 VALUE의 값을 확인합니다. 위의 명령어와 동일합니다*/ ----로그기록---- %PUT &=VALUE; /매크로 변수 VALUE의 값을 확인합니다/ VALUE=나이 %PUT VALUE=&VALUE. VALUE=나이 ----로그기록---- CALL SYMPUT 명령어는 DATA 명령어를 통해 생성할 수 있습니다. 이를 위해서는 우선 DATA 명령어를 입력해 줘야 합니다. 그리고 DATA 명령어가 끝나면 CALL SYMPUT(‘매크로 변수명’,‘값’)을 입력합니다. SYMPUT 안에서 첫 번째 입력한 값은 매크로 변수명이 되고 두 번째 입력한 값은 매크로의 결괏값이 됩니다. 예제에서 보신 거와 같이 SYMPUT(‘VALUE’,‘나이’)라고 명령어를 입력할 경우, VALUE는 매크로 변수명이, 나이는 그 매크로의 결괏값이 됩니다. 직접 입력할 경우, SYMPUT 내부의 매크로 변수명과 값에는 반드시 ‘ ’를 씌워줘야 합니다. 예를 들어 CALL SYMPUT(VALUE, 나이);처럼 ‘ ’를 입력하지 않을 경우, SAS는 VALUE와 나이를 칼럼으로 인식합니다. 그렇기 때문에 여기서는 오류가 발생하게 됩니다(칼럼으로 인식하여야 하는 경우는 다음 챕터에서 배워보겠습니다). tip _NULL_이란, DATA 명령어에서 테이블을 생성하지 않는 명령어입니다. SAS 명령어를 수행하다 보면 굳이 테이블을 생성하지 않아도 되는 경우가 있습니다. SYMPUT 명령어를 생성하는 경우, SAS는 단독 문장만으로 명령어를 수행할 수 없으므로 DATA 명령어를 필수적으로 함께 입력해야 합니다. 하지만 매크로 변수는 굳이 테이블로 생성해서 만들 필요가 없습니다. 따라서 테이블은 생성하지 않되 매크로만 생성하기 위해서 DATA 명령어 단계에서 _NULL_을 적어줍니다. 그러면 SAS는 DATA 명령어 이후의 명령어만 수행하고 테이블을 생성하지 않습니다. 2) 연동 입력 명령어 CALL SYMPUT(XXX, YYY): 매크로 변수 XXX를 생성합니다. 다른 테이블에서 연동한 결괏값을 매크로로 생성합니다. 매크로 변수 XXX는 칼럼 XXX의 각 값으로 설정됩니다. 결괏값은 칼럼 XXX의 각 값과 동일한 행에 있는 칼럼 YYY의 값으로 설정합니다. 단번에 이해하기 어려우시다면 예제를 통해서 알아보겠습니다. 예제 2 DATA _NULL_; /*빈 데이터를 생성합니다(테이블을 만들지 않습니다)*/ SET SASHELP.CLASS; /*테이블 SASHELP.CLASS을 대상으로 설정합니다.*/ CALL SYMPUT(NAME, AGE); /*매크로 변수 대상 칼럼은 NAME입니다. 칼럼 NAME의 각 값이 매크로 변수가 됩니다. 그리고 매크로 변수와 같은 행의 칼럼 AGE 값을 매크로 결괏값으로 저장합니다*/ RUN; /*SAS 명령어를 종료합니다*/ %PUT &=알프레드; /*매크로 변수 알프레드의 결괏값을 확인합니다*/ %PUT &=존; /*매크로 변수 존의 결괏값을 확인합니다*/ -----로 그 결괏값 %PUT &=알프레드; 알프레드= 14 %PUT &=존; 존= 12 -----로 그 결괏값 우선 SASHELP.CLASS 테이블을 확인해 보겠습니다. NAME SEX AGE HEIGHT WEIGHT 알프레드 남 14 69 112.5 앨리스여 13 56.5 84 바바라여 13 65.3 98 캐럴여 14 62.8 102.5 헨리 남 14 63.5 102.5 제임스 남 12 57.3 83 제인여 12 59.8 84.5 자넷여 15 62.5 112.5 제프리 남 13 62.5 84 존 남 12 59 99.5 조이스여 11 51.3 50.5 주디여 14 64.3 90 루이스여 12 56.3 77 메리여 15 66.5 112 필립 남 16 72 150 로버트 남 12 64.8 128 로날드 남 15 67 133 토마스 남 11 57.5 85 윌리엄 남 15 66.5 112 CALL SYMPUT 명령어(CALL SYMPUT(NAME, AGE)를 통해 칼럼 NAME의 각 값이 매크로 변수로 생성됩니다. 생성된 매크로 변수에 매칭되는 칼럼 AGE의 값이 그 결괏값이 됩니다. 예를 들어보겠습니다. 칼럼 NAME의 가장 위에 있는 알프레드가 매크로 변수로 생성이 됩니다. 그리고 알프레드의 칼럼 AGE에 있는 값인 14가 매크로 결괏값이 됩니다. 따라서 “&알프레드.”라고 명령어를 입력할 경우 14라는 값이 나옵니다. 다음으로 칼럼 NAME에 있는 앨리스가 매크로 변수로 생성이 되고 “&앨리스.”의 결괏값은 13이 됩니다. 칼럼 NAME에 있는 각 변수가 모두 매크로 변수로 생성이 되는 것입니다. 따라서 CALL SYMPUT 명령어를 통해 매크로 변수는 19개가 생성됩니다. tip 매크로 변수를 활용하는 방법에 대해서 알아보겠습니다. 데이터를 추출할 때 매크로 변수를 활용할 수 있습니다. 예를 들어서 칼럼 NAME의 존과 같은 AGE(나이)를 가진 행만을 추출하고 싶을 때, 매크로 변수를 사용할 수 있습니다. PROC SQL; CREATE TABLE SSS AS SELECT * FROM SASHELP.CLASS WHERE AGE=&존. QUIT; 위의 코드에서 WHERE AGE=&존. 은 WHERE AGE=12와 동일한 결과를 도출합니다. WHERE AGE=&존.에서 이름만 바꿔주면 이름에 따른 나이를 기반으로 한 테이블을 생성할 수 있습니다. 9-3. SAS MACRO 연동 입력 명령어(PROC SQL의 INTO) (전자책 내용) 죄송합니다. 해당 자료는 위키독스 웹 사이트에서는 비공개 처리되어 구현 코드와 코드에 대한 상세한 설명은 아래 링크의 유료 E-book을 구매하시면 확인할 수 있습니다. (링크) SAS로 하는 기초 데이터 전처리, 핸들링(Data handling) 전자책 구매 9-4. SAS MACRO 활용한 문장의 매크로화(%MACRO) 지금까지는 단순하게 하나의 매크로 변수를 만드는 과정을 배웠습니다. 지금부터는 하나의 매크로 변수를 넘어서 전체 명령문을 매크로화하는 방법을 배워보겠습니다. 전체 명령문을 매크로화 시키면 전체 명령문을 반복해서 입력하지 않아도 됩니다. 하나의 문장으로 대체가 가능합니다. 그러면 코드가 짧아지고 연산 속도도 빨라집니다. 그러면 지금부터 전체 명령어를 매크로화 시키는 방법과 그 활용법을 알아보겠습니다. tip 하나의 단어를 매크로화할 경우 이를 매크로 변수라고 하겠습니다. 전체 문장을 매크로화할 경우 이를 매크로라고 하겠습니다. MACRO 생성 명령어 1 %MACRO XXX;: 매크로 XXX를 생성합니다. 아래 전체 명령어를 매크로화 시킵니다. --DATA 또는 SQL 명령어 입력-- %MEND;: 매크로 XXX 생성을 종료합니다. %XXX;: 매크로 XXX를 시행합니다. 예제 1 %MACRO TEST; /*매크로 TEST를 생성합니다*/ PROC SQL; CREATE TABLE TEST_1 AS SELECT * FROM SASHELP.CLASS QUIT; /*매크로 TEST의 명령어를 입력합니다*/ %MEND; /*매크로 TEST 생성을 종료합니다*/ %TEST; /*매크로 TEST를 시행합니다*/ Name Sex Age Height Weight 알프레드 남 14 69 112.5 앨리스여 13 56.5 84 바바라여 13 65.3 98 캐럴여 14 62.8 102.5 헨리 남 14 63.5 102.5 제임스 남 12 57.3 83 제인여 12 59.8 84.5 자넷여 15 62.5 112.5 제프리 남 13 62.5 84 존 남 12 59 99.5 조이스여 11 51.3 50.5 주디여 14 64.3 90 루이스여 12 56.3 77 메리여 15 66.5 112 필립 남 16 72 150 로버트 남 12 64.8 128 로날드 남 15 67 133 토마스 남 11 57.5 85 윌리엄 남 15 66.5 112 간단한 매크로 TEST를 생성해 봤습니다. %MACRO TEST;의 아래 줄부터 명령어 예제에 적힌 대로 입력을 했습니다. 그러면 %MEND가 나오는 부분까지 매크로 명령어로 인식을 합니다. %MACRO TEST; 이후부터 %MEND;까지가 생성되는 매크로 명령어입니다. 그리고 이 매크로를 시행하는 건 %TEST입니다. SAS에 %TEST;를 입력하면 매크로 TEST를 찾아서 시행을 하게 됩니다. PROC SQL;부터 QUIT;까지의 명령어를 한 줄의 명령어(%TEST)에 담은 셈입니다. MACRO 안에 들어가 있는 명령어의 길이는 아무리 길어도 관계가 없습니다. 긴 문장의 명령어를 반복해서 시행할 때 요긴하게 사용할 수 있습니다. tip 여기서 보시면 매크로 명령어를 생성할 때는 ‘%’가 들어감을 알 수 있습니다. 매크로는 %를 통해서 생성되고, 매크로를 불러올 때도 %를 사용합니다(매크로 변수는 &으로 불러옵니다). 매크로는 %와 밀접한 연관이 있음을 참고하세요. 매크로 생성 명령어 2 이번에는 특정 조건을 준 매크로 명령어 생성을 알아보겠습니다. 단순 매크로 생성보다 조건을 준 명령어를 생성할 때가 많습니다. 전체 매크로 문장에서 특정 조건만 바꿔가면서 전체 명령어를 시행하는 것입니다. 사용방법을 알아보겠습니다. %MACRO XXX(YYY);: 매크로 XXX를 생성합니다. 아래 전체 명령어를 매크로화 시킵니다. 매크로 변수 YYY를 함께 생성합니다. ex) WHERE AAA=&YYY. %MEND;: 매크로 XXX 생성을 종료합니다. %XXX(111);: 매크로 XXX 시행합니다. 그리고 매크로 변수 YYY의 값은 111로 지정합니다. 예제 2 %MACRO TEST2(CUT); /*매크로 TEST2를 생성합니다. 그리고 CUT이라는 매크로 변수도 함께 생성합니다*/ PROC SQL; CREATE TABLE TEST_2 AS SELECT * FROM SASHELP.CLASS WHERE AGE=&CUT. /*칼럼 AGE의 값이 &CUT.의 값과 동일한 행만 추출합니다*/ QUIT; /*매크로 TEST2의 명령어를 입력합니다*/ %MEND; /*매크로 TEST2 생성을 종료합니다*/ %TEST2(13); /*매크로 TEST2를 시행합니다. 매크로 변수 CUT의 결괏값은 13으로 설정합니다*/ Name Sex Age Height Weight 앨리스여 13 56.5 84 바바라여 13 65.3 98 제프리 남 13 62.5 84 앞선 매크로와 다른 점이 있다면 MACRO TEST2(CUT); 부분입니다. CUT은 매크로 변수입니다. CUT을 활용해서 매크로 명령어 내부에 조건을 줄 수 있습니다. 예제 2처럼 WHERE AGE=&CUT. 부분에서 매크로 변수 CUT을 입력하면, %TEST2(13);으로 매크로를 시행할 때 SAS는 CUT을 %LET CUT=13과 동일하게 인식합니다. 그래서 WHERE AGE=13으로 인식하게 되고 칼럼 AGE가 13인 행만 결과로 추출합니다. 이 방식은 복잡한 매크로 명령어에서 특정 부분만 바꿀 때 유용하게 사용될 수 있습니다. 명령어를 바꿔야 할 때 내부 명령어를 일일이 손볼 필요 없이 매크로 시행 단계에서만 CUT 값을 수정해 주면 됩니다. CUT 값을 바꿔가면서 시행해 보면 그 효과를 더 체감하실 수 있습니다. 매크로 생성 명령어 3 이번에는 두 개의 특정 조건을 준 매크로 명령어 생성을 배워보겠습니다. 위에서는 하나의 조건을 준 매크로 명령어를 생성했다면, 이제는 두 개의 조건을 갖는 매크로 생성 법을 알아보겠습니다. %MACRO XXX(YYY, ZZZ);: 매크로 XXX를 생성합니다. 아래 전체 명령어를 매크로화 시킵니다. 매크로 변수 YYY와 ZZZ를 함께 생성합니다. ex) WHERE AAA=&YYY. AND BBB=&ZZZ. %MEND;: 매크로 XXX 생성을 종료합니다. %XXX(111,222);: 매크로 XXX를 시행합니다. 그리고 매크로 변수 YYY의 값은 111로 지정하고 ZZZ의 값은 222로 지정합니다. 예제 3 %MACRO TEST3(CUT, CUT2); /*매크로 TEST3를 생성합니다. 그리고 CUT과 CUT2라는 매크로 변수도 함께 생성합니다*/ PROC SQL; CREATE TABLE TEST_3 AS SELECT * FROM SASHELP.CLASS WHERE AGE=&CUT. /*칼럼 AGE의 값이 &CUT. 과 동일한 행을 추출합니다*/ AND SEX=&CUT2./*칼럼 AGE의 값이 &CUT2. 과 동일한 행만 추출합니다*/ QUIT; /*매크로 TEST3의 명령어를 입력합니다*/ %MEND; /*매크로 TEST3 생성을 종료합니다*/ %TEST3(13, '여'); /*매크로 TEST3를 시행합니다*/ Name Sex Age Height Weight 앨리스여 13 56.5 84 바바라여 13 65.3 98 이번에는 두 개의 조건이 붙은 매크로 명령어를 알아보겠습니다. 앞선 예제 2가 하나의 조건이 있는 매크로 명령어라면, 예제 3은 두 개의 조건이 있는 매크로 명령어입니다. 원리는 앞선 예제 2의 방식과 동일합니다. 우선 매크로 변수 CUT과 CUT2를 %MACRO TEST3(CUT, CUT2);를 통해 만듭니다. 그리고 내부 명령어에 WHERE AGE=&CUT. AND SEX=&CUT2.로 입력을 해둡니다. 마지막으로 이를 시행할 때 %TEST3(13, ‘여’);로 입력을 함으로써 %LET CUT=13; %LET CUT2=‘여’ 와 동일한 명령어를 입력한 셈이 됩니다. 매크로를 시행하면 SAS는 이 부분을 자동으로 입력하게 됩니다. 그러므로 매크로 %TEST3(13, ‘여’)는 AGE가 13이고 SEX가 ‘여’인 행만 추출을 하게 됩니다. tip %MACRO XXX(AAA, BBB,.....,ZZZ); 등의 방식으로 조건을 주는 매크로 변수는 필요한 만큼 생성할 수 있습니다. 9-5. SAS MACRO 활용한 매크로의 자동화(%DO) (전자책 내용) 죄송합니다. 해당 자료는 위키독스 웹 사이트에서는 비공개 처리되어 구현 코드와 코드에 대한 상세한 설명은 아래 링크의 유료 E-book을 구매하시면 확인할 수 있습니다. (링크) SAS로 하는 기초 데이터 전처리, 핸들링(Data handling) 전자책 구매<|endoftext|>

전문분야 텍스트 ### 제목: 공학자를 위한 Python ### 본문: 파이썬 관련 정리 문서. 아래는 참고 서적 점프 투 파이썬 파이썬으로 배우는 알고리즘 트레이딩 (4쇄) Python Data Science Handbook 1. 환경설정 Python은 공식 사이트인 python.org에서 내려받아 설치할 수 있다. 공식배포본을 사용하면 추가로 여러 패키지(라이브러리를 의미)를 별도로 인스톨해야 한다. 보통은 필수 패키지를 포함하고 있는 Anaconda 배포본을 주로 사용하는데, 최근 Anaconda 배포본이 개인에게는 무료이지만 일정 규모 이상의 회사에서 사용할 때는 유료화되었다. 따라서 여기에서는 공식배포본으로 작업한다. Python은 버전 번호 2.x와 3.x의 두 가지 버전으로 제공한다. 이를 각각 Python 2, Python 3로 부르는데 일부 언어 표준이 변경된 부분이 있어 소스가 호환되지 않을 수 있다. 여기에서는 Python 3를 사용한다. Anaconda 배포본이라 하 더하고 모든 패키지를 포함하지 않기 때문에 사용자가 필요한 추가 패키지는 찾아서 인스톨해야 한다. 에디팅, 디버깅, 실행 등을 편리하게 지원하는 통합개발 환경(IDE)의 선택이 매우 중요하다. 이는 취향 문제이나 가장 많이 사용하는 통합개발 환경은 Spyder, PyCharm, Visual Studio, VS Code 등이 있다. 1.1 Python 설치와 구동 1.1.1 설치 Python은 www.python.org에서 관리하며 표준 배포본을 제공하고 있다. 실제 Python 사용 시 필요한 다양한 패키지(라이브러리를 의미)를 일일이 인스톨하는 것이 쉽지 않다. 그렇기 때문에 대부분 필수 패키지와 개발 환경을 포함하고 있는 Anaconda 배포본이 많이 사용되고 있다. 하지만 최근 Anaconda가 회사에서 사용 시 라이선스 조건이 상용으로 변경됨에 따라 여기에서는 표준배포본을 기준으로 기술하였다. Python 표준 배포본 안정화가 되지 않을 수 있기 때문에 가장 최신 버전은 사용하지 않는 것이 좋다. 즉, 최신 버전의 바로 이전 버전을 설치한다 현재(2023.19.11)는 Python 3.12가 최신이다. 따라서 3.11버전 중 마지막으로 바이너리 릴리스를 고른다. 64비트를 고려하면 python-3.11.6-amd64.exe를 다운로드해 설치한다. 실행한 후 첫 화면에서 Customize installation 선택한 후 두 번째 화면 Next 마지막 화면에서 모두 check on(이 경우 모든 user 사용 가능하고, 디폴트 설치 위치는 C:\Program Files\Python311, 환경 변수 PATH 등록 등의 특징을 갖는다) 이전 버전 제거 시 환경 변수 PATH가 자동으로 삭제되지 않는다. 이 경우 직접 조정해 주어야 한다. 주의 모든 user 사용 가능에 ON 한 경우 디폴트 설치 위치는 C:\Program Files\Python311이나 관리자 권한으로 pip로 패키지를 설치해야 그 하위의 scripts, site-packages에 설치된다. 권리자 권한이 아닌 경우에는 추가 설치하는 패키지는 c:/users/사용자 아이디/appdata/roaming/python/python311하위에 설치되됨(그 하위에 scripts, site-packages 등).<NAME> scripts가 PATH에 잡히지 않으며, 삭제 시 수동 삭제가 필요함 필수 패키지 설치 커맨트프람프트를 관리자 권한으로 실행한다. > pip install wheel > pip install numpy > pip install scipy > pip install matplotlib > pip install pandas > pip install spyder > pip install jupyter 참고 pip freeze > requirements.txt 담에 깔 때 다음으로 인스톨 pip install wheel pip install -r requirements.txt 추가 Python 패키지 Anaconda에는 대부분 많이 사용하는 패지지가 포함되어 있다. 이외의 패키지를 깔기 위해서는 가능한 pip나 conda 등의 패키지 관리자를 지원하는 것을 찾는 것이 좋다. 원래 python은 setup.py를 통해 패키지 인스톨이 가능하지만 순수 파이썬 파일 이외에 DLL 등을 포함할 경우 인스톨이 쉽지 않다. 이를 이를 보완하기 위해 출현한 것이 Python 표준의 pip이다. conda는 Anaconda에서 사용하는 pip 정도로 이해하면 된다. 이 문서에서는 Anaconda 배포본에 미리 포함되지 않은 다양한 패키지의 인스톨이 필요하다. Anaconda 명령창(Anaconda Prompt)을 관리자 권한으로 연 후 다음과 같이 pip로 인스톨한다. conda 대신 pip를 사용하는 이유는 Tensorflow와 같이 일부 패키지에서는 공식적으로 pip만 지원하기 때문이다 > pip install opencv-contrib-python > pip install h5py > pip install vtk > pip install pygame > pip install graphviz > pip install pydot > pip install theano > pip install tensorflow > pip install keras opencv-contrib-python은 OpenCV와 OpenCV contrib 모듈을 포함한 패키지이다. vtk는 과학기술 시각화용 패키지이다. pygame은 비디오 게임을 작성하는데 필요한 모듈이다. graphviz와 pydot은 다이어그램을 그리기 위한 파이썬 패키지이지만 실제 실행파일을 포함하고 있지 않다. 정상작동을 위해서는 www.grpahviz.org에서 설치 파일(현 버전은 graphviz-2.38.msi)을 다운로드 후 graphviz를 설치하고 환경 변수를 설정해야 한다. 자세한 사항은 Keras_Install_on_Windows을 참고한다. theano, tensorflow, keras는 Machine Learning 패키지이다. 업그레이드 시에서는 다음과 같이 --upgrade 옵션을 사용하여 다음과 같이 인스톨한다. > pip install --upgrade opencv-contrib-python 1.1.2 기본 구동 법 Python은 라인 단위로 구동되는 스크립트 언어이다. 즉, Python을 구동하려면 인터프리터(python.exe)가 필요하다. 실행하는 방식은 다음과 같은 두 가지이다. (1) 인터프리터(python.exe)에서 한 줄씩 직접 타이팅하여 실행 cmd에서 Python 인터프리터(python.exe)를 구동한 후 한 줄씩 구동할 수 있다. (2) 텍스트 에디터에서 소스 작성 후 인터프리터(python.exe)로 실행 먼저 스크립트(.py)를 작성한 후 python HelloPython.py와 같이 실행할 수도 있다. # HelloPython.py a = 1 b = 2 c = a+b print('Hello Python!!! You know %d+%d=%d?'%(a, b, c)) 실행은 콘솔 창에서 다음과 같다. C:\> python HelloPython.py Hello Python!!! You know 1+2=3? Python을 콘솔 창에서 별도의 에디터로 스크립트를 편집하고, 이를 콘솔에서 실행하는 것은 작업효율지 낮다. 이를 편리하게 해주는 것이 통합개발 환경이다. 통합개발 환경으로는 Visual Studio, PyCharm, Spyder 등이 주로 사용된다. 참고. 원하는 위치에 CMD 창 띄우기 Windows에서 명령 프롬프트(CMD) 창을 띄우면 사용자의 바탕화면 위치로 창이 뜬다. 이후 필요한 위치를 찾아가는 것은 cd 명령을 활용해서 타이핑해야 한다. 보다 좋은 방법은 탐색기를 원하는 위치에 두고 그 위치에 CMD 창을 띄우는 것이다. 1.2 통합개발 환경 Python을 위한 다양한 IDE(Integrated Development Environment, 통합개발 환경)가 존재한다. 어떤 IDE를 선택할지는 개인의 취향과 IDE의 장단점에 따라 다르다. Jupyter 통합개발 환경이라기 보다 웹에서 Python 코드 작성 및 Markdown 문서 작성이 가능한 웹 애플리케이션 웹상에서 Python 코드를 작성하고 그 결과를 바로 확인 가능함. Anaconda 배포본에 포함되어 있음 Spyder Anaconda 배포본 사용 시 제공되는 IDE로 과학기술 계산용으로 특화 Crossplaform이며 무료 간단하게 사용할 수 있는 IDE Visual Studio PTVS Visual Studio에 PTVS라는 확장을 인스톨하면 Python 용 IDE로 사용 가능. Windows 용이며, 개인 개발자는 무료이며 그 외는 상용 최고의 Windows 용 IDE PyCharm 가장 많은 사용자가 있는 Python IDE Crossplaform이며 무료 및 유료 버전 있음. 다양한 확장기능을 설치할 수 있음 가장 많은 사람의 선택을 받는 IDE Visual Studio Code Visual Studio Code에 Python 확장을 인스톨하면 Python 용 IDE로 사용 가능. Crossplatform이며 무료 다양한 확장 기능을 설치할 수 있음 최근 사용자 층이 늘어나고 있는 IDE 1.2.1 Jupyter Jupyter는 IPython 쉘을 이용해서 Python 코드가 포함된 동적 문서를 작성하는 웹 애플리케이션이다. 인스톨은 pip install jupyter로 가능하다. 시작 버턴에서 Jupyter Notebook을 실행하면 디폴트로 사용자 바탕화면이 홈 디렉터리(startup folder)가 되므로 아래 그림과 같이 실행하는 것이 좋다. 실행 이후에는 기존 노트를 편집하거나 새로운 노트를 생성하고 편집할 수 있다. Jupyter notebook은 ipynb라는 확장자를 가지고 있다. 스타일 변경 C:\Users\user_id\.jupyter 폴더에 custom이라는 자식 폴더(C:\Users\user_id\.jupyter\custom)를 만들고 custom.css과 custom.js를 통해 커스터마이징을 할 수 있다. 스타일을 변경할 때는 custom.css를 사용한다. 다음은 전형적인 예(참조:<NAME>네 집)이다. #notebook-container { line-height:1.8em } .rendered_html pre, .rendered_html code, pre, .CodeMirror, .prompt { font-family: Consolas, "Andale Mono WT","Andale Mono","Lucida Console","Lucida Sans Typewriter","DejaVu Sans Mono","Bitstream Vera Sans Mono","Liberation Mono","Nimbus Mono L",Monaco,"Courier New",Courier, monospace;; } .rendered_html pre,.rendered_html code { background-color: #f5f5f5; margin: 1em 0em } .rendered_html pre { padding: 8.5px; border: 1px solid #ccc; border-radius: 2px; } .rendered_html p > code, .rendered_html ul li code { border: solid 1px #e1 e4e5; color: #E74C3C; padding: 0 5px; overflow-x: auto; } .rendered_html blockquote{ margin: 1em 0em } blockquote { background-color: #fcf2f2; border-color: #dFb5b4; border-left: 5px solid #dfb5b4; padding: 0.5em; } 1.2.2 Spyder Spyder는 Anaconda 배포본에 포함되어 있는 IDE이다. 에디터와 콘솔을 지원하기 때문에 위의 작업을 편하기 수행할 수 있다. 또한, 프로젝트, 디버깅, 헬프, 변수 보기(variable explorere) 등 다양한 편의 기능을 제공한다. Spyder는 대화형창(콘솔)으로 표준 Python 콘솔을 확장한 IPython 콘솔을 사용한다. 편집기에서 편집하다가 스크립트를 전체 수행하거나 일부 영역을 선택한 후 그 부분만 수행할 수 있다. Spyder는 디폴트로 한 개의 인스턴스만 수행할 수 있다. Multiple instance 실행 방법 : Prefereance > Application > Advanced settins에서 Use a single instance를 off 현재 디렉터리를 spyder 프로젝트로 열기 > spyder -p . 1.2.3 Visual Studio Code Visual Studio Code는 Microsoft에서 제공하는 가벼운 에디터이자 개발 환경이다. 설치 후 python extension 등 필요한 extension을 인스톨하여 그 기능을 확장하는 형태로 사용한다. 사전 준비 사항 Anaconda를 설치하고, 아래와 같이 PATH를 설정되어 있어야 한다. PATH=C:\ProgramData\Anaconda3;C:\ProgramData\Anaconda3\Scripts;%PATH% 위 설치 경로는 Anaconda 인스톨 시 옵션에 따라 상이할 수 있으며 미리 등록되어 있을 수도 있다. VSCode 용 extension 원활한 Python 개발을 위해서는 다음의 extension을 설치해야 한다. Python : Microsoft 제공. Python 사용을 위해 필요 Jupyter : Jupyter 사용을 위해 필요 Material Icon Theme : 파일 아이콘을 멋이 세게 보여줌. 문서는 Markdown을 활용하는 것이 편리한데 관련된 extension은 다음과 같다. Markdown+Math : Markdown 문서 미리 보기에서 수식 출력을 위해 필요 vscode-pandoc : pandoc으로 markdown을 그릴 때. 보통 MS word로 export 가 가능함. markdonwlint : markdown linting (옵션) Markdown Shorcuts : 마크다운 문 번에 대한 shortcut 제공 (옵션) Markdown Preview Enhanced : 내장된 Markdown preview 보다 우수(옵션) 마크다운 수식을 latex 입력 방식으로 직접 하는 것은 현실적으로 쉽지 않다. 좋은 방법은 MS Word에서 작성하고 이를 복사하는 것이다. 이를 가능하게 하는 MS Word plugin으로 writage라는 것이 있다. writage : MS word를 위한 플러그인 Visual Studio Code를 이용한 Python 개발 현재 디렉터리를 code 프로젝트로 열기 > spyder . 실행하는 세 가지 방법 Run Run with debug Run in interactive window [ 마우스 오른쪽 클릭으로 ipython 실행] 1.3 환경 변수 PATH 환경 변수 PATH는 프로그램 실행 시의 경로는 탐색하는 데 사용된다. 예를 들어 Windows에서 prog.exe라는 프로그램이 실행되면 다음과 같은 순서로 프로그램을 찾아 기동하게 된다. 현재 작업 디렉터리(Current Working Directory, CWD) Windows 디렉터리 PATH에 설정된 디렉터리 (1) Windows 시스템에서 PATH 관리 시스템 속성 다이얼로그에서 고급 탭에서 환경 변수를 선택하면 현재 설정된 PATH를 조회하고 변경할 수 있다. (2) 명령행(cmd)에서 PATH 관리 명령행(cmd)에서 set path로 조회하거나 설정할 수 있다. PATH 확인 > set path Path=C:\ProgramData\Anaconda3;C:\ProgramData\Anaconda3\Scripts;C:\Program Files (x86)\Graphviz2.38\bin;... PATH 추가 > set path=d:\myProg;%PATH% 위에서 %PATH%는 기존 설정된 PATH를 의미한다. 이 방법은 현재 실행된 명령창에 대해서만 유효하다. (3) Python에서 PATH 관리 Python의 os 모듈로 PATH를 관리할 수 있다. 여기를 참고하도록 한다. 이 방법은 현재 실행되는 Python 프로세스에서만 유효한다. 2. Python 기본 특징과 철학 Python은 Guido von Rossum이 1991년 발표한 인터프리터 방식의 고급 프로그래밍 언어이다. 그 특징은 다음과 같다. 인터프리터 방식의 언어(interpreted language) : C/C++은 컴파일을 통해 실행파일을 만들어 내지만 Python은 인터프리터에서 라인 단위로 실행된다. 다양한 프로그래밍 기법 지원(multi-paradigm programming language) : 객체지향, 절차 지향 등등 다양한 프로그래밍 기법을 지원하다. 즉 쓰기 나름이다. 동적 타이핑(dynamic typing) : 실행할 때 자료형을 검사하며, 포인터 연산 없다(자동 가비지 컬렉션). 풍부한 라이브러리 한글 위키피디아에 소개된 Python의 핵심 철학은 다음과 같다. "아름다운 게 추한 것보다 낫다." (Beautiful is better than ugly) "명시적인 것이 암시적인 것보다 낫다." (Explicit is better than implicit) "단순함이 복잡함보다 낫다." (Simple is better than complex) "복잡함이 난해한 것보다 낫다." (Complex is better than complicated) "가독성은 중요하다." (Readability counts) 결국 Python은 쉽게 알기 쉬운 코드를 작성하도록 고안되었다. IPython Python 표준 쉘은 python.exe를 구동시키면 된다. IPython은 ipython.org에서 배포하는 쉘로서, 대화형 작업을 위해 표준쉘을 확장한 것이다. 보통 통합개발 환경에서 사용되는 대화형 쉘은 표준쉘 보다는 IPython을 사용한다. 실행하면 프롬프트에서 >>> 대신 [1] 등과 같이 라인 번호가 프롬프트 된다. CPython, JPython, ... Python을 실제 실행하는 인터프리터로는 C로 구현된 CPython, 자바 가상머신용 JPython, 닷넷 플래폼용 IronPython 등등이 있다. 보통은 CPython이 주로 사용된다. C/C++와의 구문 비교 최신의 다른 언어가 그렇듯 Python은 C/C++의 영향을 많이 받았으며, 키워드나 구문 등이 매우 유사하다. 다음은 몇몇 차이점을 나열한 것이다. 대소문자를 구분한다( C/C++과 동일) 각 라인에서 # 이후의 문자열을 무시한다(C/C++에서는 /* ... */ 또는 //를 이용) 한 라인에 한 개 구문을 쓸 때는 라인 브레이크(;) 가 필요 없으나(있어도 무방), 두 개 이상의 구문인 경우 ;로 구분한다(C/C++은 항상 ;가 필요) 한 개 구문이 길어 다음 라인까지 연결할 경우 경우 \를 사용한다(C/C++와 동일) 문자열 리터럴(string literal)을 '...``, "...", '''...''', """...""" 등 네 가지 방법으로 정의할 수 있다(C/C++은 "..." 만 가능) 들여 쓰기(indentation)을 통해 블록을 구성한다(C/C++에서는 {...}를 이용) if, while 문에 사용되는 조건문에 괄호((...))가 필요 없다(있어도 무관)(C/C++은 반드시 있어야 함) 위에서 C/C++ 사용자에게 가장 어색하고, 오류를 유발하는 것이 들여 쓰기를 통한 블록 구성이다. 어떤 구문이 :로 끝나면 그 하위 수준의 블록은 동일한 들여 쓰기가 되면 된다. if 조건문: a = a b = c 위에서 if 문은 :로 끝나기 때문에 블록 구조가 이어져야 한다. 블록 구조는 같은 개수의 공백문자(스페이스나 탭)로 들여 쓰기를 하면 된다. 보통 2개의 스페이스나 4개의 스페이스가 주로 사용된다. 탭 문자를 잘 사용되지 않는데 그 이유는 탭과 스페이스가 섞여 있을 경우 눈으로 보기에는 같아 보이지만 에러가 발생하기 때문이다. 다음 예는 www.python.org에 소개된 Python으로 피보나치수열을 계산하는 코드와 C/C++에서 동일한 코드를 보여주고 있다. Python이 보다 간결하고 읽기 쉬운 코드 작성이 가능함을 알 수 있다. Python을 통한 피보나치수열 계산 def fib(n): a, b = 0, 1 while a < n: a = b b = a+b print("%s ! = %d"%(n, a)) fib(1000) C/C++에서 피보나치수열 계산 void fib(int n) { int a = 0, b = 1; while(a<n) { a = b; b = a+b; } printf("%d ! = %d ",n, a) } int main() { fib(1000); return 0; } 2.1 자료형 Python은 불린(bool), 정수(int), 실수(float), 복소수(complex) 등의 기본 자료형, 리스트(list), 튜플(tuple), 딕셔너리(dict), 집합(set) 등의 컨테이너 자료형, 유네 코드 문자열(str) 및 ANSI 문자열(bytes) 등의 문자열 등의 다양한 자료형을 제공한다. 다음은 간단한 자료형 정의 방법과 type(x)를 통해 자료형을 확인한 결과 예시이다. bool은 True, False만을 저장하는 불린 형이다. == 등과 같은 조건 문의 결과이다. >>> isCheck = True # True or False >>> type(isCheck) <class 'bool'> int, float, complex는 수치자료형이다. 사칙연산이 가능하다. >>> a = 12 >>> type(a) <class 'int'> >>> f = 12.3 >>> type(f) <class 'float'> >>> c = 1+2*1j >> type(c) <class 'complex'> Python에서 제공하는 컨테이너로는 list, tuple, dict, set 등이 있다. 이중 list와 tuple은 순차 컨테이너(또는 sequence)이고, dict와 set은 연관 컨테이너이다. list는 C++ STL의 vector나 list와 동등하다. Python에는 배열이 없는데 list가 그 역할을 대신한다. C++ STL의 vector나 list와 다른 점은 저장하는 요소의 자료형이 동일한 자료형일 필요가 없다는 점이다. >>> x = [1, 'ones', 1.2] >>> type(x) <class 'list'> >>> x[0] >>> x[1] 'ones' tuple은 읽기 전용 list이다. >>> y = (1,2, 'one') >>> y[0] >>> y[2] 'one' >>> type(y) <class 'tuple'> dict는 C++ STL의 map과 동등하다. 즉, <Key, Value>의 쌍으로 구성된 자료형이다. C++ STL의 map과 다른 점은 Key나 Value의 자료형이 동일 자료형일 필요가 없다는 것이다. >>> dic = {'name':'pey', 'phone':'0119993323', 'birth': '1118'} >>> dic['name'] >>> dic = {1:'pey',1.2:'good', 'test':5} set은 각각 C++ STL의 set과 같은 기능을 한다. 즉, 순서 없이 저장하는 컨테이너이다. 이 또한 C++ STL의 set과 달리 동일한 자료형일 필요가 없다. >>> myset = {1,2,3} >>> myset {1, 2, 3} >>> type(myset) <class 'set'> C에서는 1개 문자를 표시하는 char 을 기본 타입으로 제공하고, char의 배열로 문자열을 다룬다. 하지만 Python에서는 이러한 방식 대신 문자가 아닌 문자열을 1개의 객체로 취급한다. 한문자를 2바이트 크기로 표시하는 유니코드 문자열은 str이고(그냥 문자열이라고 한다), 1바이트의 문자열인 ANSI 문자열은 bytes이다. str과 bytes는 고정 폭, 고정 길이의 특수한 순차 컨테이너(시퀀스)라고 할 수 있으며, 한번 생성하면 변경이 불가능(읽기 전용) 하다. >>> word = 'Hello' >>> word 'Hello' >>> type(word) <class 'str'> >>> bword = b'Hello' >>> bword b'Hello' >>> type(bword) <class 'bytes'> 2.1.1 수치 자료형 수치자료형으로는 int, float, complex가 있다. int와 float는 지정 시 소수점의 유무에 따라 결정된다. 사칙연산에서는 가장 큰 데이터 타입으로 결정되는 데 주의할 점은 int와 int의 연산 역시 항상 float라는 점이다. >>> x = 10 >>> type(x) <class 'int'> >>> y = 10. >>> type(y) <class 'float'> >>> 10/2 # int/int but result always float 5.0 일반적인 사칙연산 이외에<NAME> 계산은 **을 사용한다. 또는 pow(x, r)을 사용할 수 있다. >>> 2.1**2 4.41 >>> pow(2.1,2) 4.41 complex은 미리 정의된 1j로 복소 단위를 이용하거나 complex(re, im)을 통해 정의할 수 있다. >>> x = 1-2*1j >>> y = complex(2,3) >>> x+y (3+1j) 실수부와 허수부는 c.real, c.imag로 조회할 수 있고, c.conjugate()는 공액 복소수를 계산한다. >>> x = complex(2,3) >>> x.real 2.0 >>> x.imag 3.0 >>> x.conjugate() (2-3j) 연산자 다음은 연산자를 정리한 것이다. x+y, x-y, x*y, x/y : 사칙 연산 -x, +x : 단항 연산 pow(x, y), x**y :<NAME> 연산 x//y, x%y, divmode(x, y) : 몫, 나머지, (몫, 나머지) abs(x), int(x), float(x), complex(re, im), c.conjugate(), Integer type에 대한 bitwise operation x|y, x^y, x&y, x << n, x >> n, ~x 위 연산은 논리 연산자 and, or, not과 구분되어야 한다. x and y, x or y, not x 2.1.2 불린 자료형 bool 은 미리 정의된 상수 True, False만을 가질 수 있다. >>> a = 1 >>> b = 2 >>> is_same = (a == b) >>> is_same False 2.1.3 순차 컨테이너 (1) 리스트 생성 list는 다른 언어의 배열처럼 사용하는 자료형이다. list라고 명명한 이유는 구성요소의 타입이 같을 필요가 없기 때문이다. 생성은 [] 기호로 둘러싸면 된다. >>> x = [1,2,3] >>> y = ['Hello', 'World', 2] >>> z = [1,2, [3,5]] >>> q = [] # null list. same to q=list() 위에서 'Hello'는 문자열(str) 객체이다. 여기에 보다 자세히 설명되어 있다. 인덱싱과 슬라이싱 list, tuple, str은 x[i] 등과 같은<NAME>으로 인덱싱을 할 수 있다. 이때 인덱스 i는 0부터 시작한다(0-based index). 특수하게 x[-1]은 마지막 요소이다. x[i:j] 기호호 범위를 지정할 수 있으며, i부터 j-1의 리스트를 추출해 준다. >>> x = [0,1,2,3,4,5] >>> x[1] >>> x[1] = 10 >>> x [0,10,2,3,4,5] >>> x[-1] >>> x[1:3] [10,2] >>> x[1:6] [10, 2, 3, 4, 5] >>> x[3:-1] # same to x[3:5] [3, 4] 연산 list는 + 연산으로 두 리스트를 연결(concatenation) 할 수 있고, * 연산으로 반복해서 만들어 내다. >>> x=[1,2,3] >>> y = [4,5,6] >>> x+y [1, 2, 3, 4, 5, 6] >>> x*2 [1, 2, 3, 1, 2, 3] >>> x*y # ERROR 요소 추가와 삭제 x.append(v)는 list x의 끝에 v를 추가한다. x.insert(i, v)는 i 위치에 v를 추가한다. 요소를 삭제하는 것은 x[i] = [], x[i:j]=[] 등과 같이 null list를 대입하거나, del x[i], del x[i:j] 등을 사용할 수 있다. >>> x = [] >>> x.append(1) >>> x.append(2) >>> x.append(3) >>> x.insert(1,10) >>> x [1, 10, 2, 3] >>> x[1:3] = [] # del x[1:3] >>> x [1, 3] 튜플 생성 tuple는 읽기 전용 리스트이다. 생성은 () 기호로 둘러싸면 되며, 한번 생성하면 바꿀 수 없다. >>> x = (1,2,3) >>> y = ('Hello', 'World', 2) >>> z = (1,2, [3,5]) 인덱싱과 슬라이싱 인덱싱 및 슬라이싱 방법은 list와 동일하다. 다만 읽기 전용이므로 요솟값을 변경하고자 하면 오류가 발생한다. >>> x = (0,1,2,3,4,5) >>> x[1] >>> x[1] = 10 # ERROR >>> x [0,1,2,3,4,5] >>> x[-1] >>> x(1:3) (1,2) >>> x(1:6) (1, 2, 3, 4, 5) >>> x[3:-1] # same to x[3:5] (3, 4) 연산 list처럼 + 연산으로 연결(concatenation) 할 수 있고, * 연산으로 반복해서 만들어 내다. >>> x=(1,2,3) >>> y = (4,5,6) >>> x+y (1, 2, 3, 4, 5, 6) >>> x*2 (1, 2, 3, 1, 2, 3) >>> x*y # ERROR 리스트와의 형 변환 tuple과 list는 단지 쓸 수 있느냐의 차이점만 있다. 이 둘의 변환을 tuple(x) 또는 list(x) 등을 통해 가능하다. >>> x = (1,2,3) >>> y = list(x) >>> y.append(4) >>> z = tuple(y) 언 패킹(unpacking) tuple은 언 패킹을 통해 각 요소를 쉽게 분해할 수 있다. list 역시 식의 오른쪽 값(R-value)로 사용하면 tuple과 동일하므로 같은 방식의 적용이 가능하다. >>> a, b = (1,2) # a=1, b=2 >>> x,*y, z = (1,2,3,4,5) # x=1, y=(2,3,4), z=5 위에서 *y와 같이 사용하는 것은 starred expression이라고 한다. str에도 unpacking의 적용이 가능하다. >>> a, b, c, d = 'john' # a='j', b='o', c='h', d='n' >>> actor = 'James Dean' >>> x,*y, z = actor >>> x 'J' >>> y ['a', 'm', 'e', 's', ' ', 'D', 'e', 'a'] >>> z 'n' 2.1.4 연관 컨테이너 딕셔너리 생성 집합 2.1.5 문자열 문자 1개을 2바이트로 표현하는 유니코드 문자열은 str에, 문자 1개를 1바이트로 표현하는 ANSI 문자열은 bytes라는 클래스를 사용한다. Python에서는 표준 문자열은 유니코드 문자열이다. 즉, 문자열이라고 하면 str을 의미하며, bytes는 길이가 고정된 1 byte 배열로 이해하기도 한다. 문자열을 정의하는 4가지 방법 문자열(str)은 작은따옴표나 큰따옴표로 둘러싸면 되는데 다음과 같은 4가지 방법으로 정의한다. >>> movie = 'World War Z' >>> movie = "World War Z" >>> movie = '''World War Z''' >>> movie = """World War Z""" 만약 문자열 내에 ‘ 또는 “ 가 있을 다른 종률의 따옴표로 둘러싸면 된다. >>> sentense = "It's fine" >>> sentense = '"I like the word "good"' 따옴표 세개인 것은 multiline으로 문자열을 정의할 때 주로 사용된다. >>> sentense = """Jane is good. Paul is bad""" 물론 C/C++처럼 이스케이프 코드로 정의할 수도 있다. >>> sentense = 'It\'s fine' raw 리터럴 경로명은 지정할 때는 이스케이프 코드가 오히려 불편하다. D:\Prog와 D:\newProg라는 두 폴더를 생각해 보기로 한다. >>> dir1 = "D:\Prog" >>> dir2 = "D:\newProg" >>> print(dir1) D:\Prog >>> print(dir2) D: ewProg 위에서 \를 사용하는 것이 경우에 따라 다르게 해석되는 것을 알 수 있다. 이를 방지하기 위해서는 \\를 사용하거나 r을 문자열 앞에 두는 방법이 있다. 이때 r은 raw string literal을 의미한다. 즉 \를 이스케이프 코드로 인식하지 않는다. new_dir1 = r"D:\newProg" new_dir2 = "D:\\newDir" 참고로 Python은 운영 체계와 무관하게 \와 / 모두 디렉터리 구분자로 인식한다. 따라서 /로 구분하여 경로를 쓰는 것도 좋은 방법이다. bytes bytes를 생성하는 것은 b를 앞에 붙이는 것을 제외하며 str과 동일하다. 출력해도 str과 구분하기 위해 b가 표시된다. >>> movie = b'World War Z' >>> print(movie) b'World War Z' 이스케이프 코드 역시 str과 동일하게 작동하며, 'r`를 쓰면 이스케이프 코드를 무시하는 raw literal이 된다. >>> sentense = b'It\'s fine' >>> dir = br"d:\nprog" >>> print(dir) b'd:\nprog' 이어지는 설명에서 str과 bytes의 사용상에 차이점은 없다. bytes는 텍스트 파일을 저장할 때 encoding된 상태를 표현하기 위해 주로 사용된다. 연산 문자열에는 +와 *연산자를 적용할 수 있으며, [] 연산자로 로 인덱싱과 슬라이싱이가능하다. 또한 문자열 조작 함수가 존재한다. + 연산은 concatenation이다. >>> head = "Python" >>> tail = " is fun!" >>> head + tail 'Python is fun!' * 연산은 반복이다. 다음은 흔히 사용하는 응용 예이다. # script.py print("=" * 50) print("My Program") print("=" * 50) > python script.py ================================================== My Program ================================================== 인덱싱과 슬라이싱 [] 연산자로 인덱싱이 가능하다. 이때 인덱스는 0부터 시작하고 –는 제일 뒤쪽에서의 인덱스로 처리한다. 즉, -1은 제일 뒤, -2는 뒤에서 두 번째 요소를 가리킨다. :기호로 범위를 지정할 수도 있다. >>> s = 'Python uses zero-based index' >>> s[0] 'P' >>> s[1] 'y' >>> s[-1] 'x' >>> s[-2] 'e' >>> s[7:11] 'uses' >>> s[7:-1] 'uses zero-based inde' >>> s[7:] 'uses zero-based index' 주의할 점은 인덱싱이나 슬라이싱 된 부분을 L-value로 사용하여 값을 넣을 수 없다는 점이다. >>> s[1] = 'T' # Error >>> s[1:3] = 'As' # Error 포맷팅(% 연산자를 이용하는 방법 - C 스타일) 문자열의 포맷팅는 % 기호를 사용하고, C언어의 printf() 함수의 %s, %f, %d 등의 포맷팅 지시자를 사용한다. >>> "I have %d apples" % 3 'I have 3 apples' 만약 여러 개를 포맷팅할 때는 () 기호 롤 튜플로 만들어 주면 된다. >>> 'X = %d, y = %f\n' %(1.2,3.1) 'X = 1, y = 3.100000\n' 보통 문자열 포맷팅은 print() 문을 사용할 때 같이 사용한다. print('X = %d, y = %f\n' %(1.2,3.1)) 포맷팅(str.format() 함수를 이용하는 방법 - Pythonic 스타일) 보다 파이썬스러운 방법은 str.format() 함수를 이용하는 방법이다. 필요한 위치에 {}를 삽입한다. >>> 'x = {}, y = {}\n'.format(1.2,3.1) 'x = 1.2, y = 3.1\n' {}에 0부터 시작하는 번호를 기입하거나, 변수를 지정하여 사용할 수도 있다. >>> 'y = {0}, y = {1}\n'.format(1.2,3.1) 'y = 1.2, y = 3.1\n' >>> 'x = {1}, y = {0}\n'.format(1.2,3.1) 'x = 3.1, y = 1.2\n' >>> 'x = {x}, y = {y} '.format(x=1.2, y=3.1) 'x = 1.2, y = 3.1\n' 포 매칭하는 것은 {:format} 형태를 사용한다. >>> 'x = {x:0.2f}, y = {y} '.format(x=1.212, y=3.1) 'x = 1.21, y = 3.1\n' 위에서 0.2f는 실수형 데이터의 소수점 둘째 자리까지 출력하라는 의미이다. 다른 데이터 타입이나 정렬, 자릿수 등과 관련해서는 레퍼런스 매뉴얼을 참조토록 한다. 문자열 조작 문자열 조작 함수로는 count(), find(), rfind(), index(), rindex(), replace(), join(), split(), lstrip(), rstrip(), strip(), upper(), lower() 등이 있다. 이들 함수는 모두 일반 함수가 아닌 문자열의 메쏘드이다. count(s)는 주어진 문자열의 개수를, find(s)는 최초 찾은 문자열의 위치를 리턴한다. rfind(s)는 뒤에서부터 찾는다. index(s), rindex(s)는 find(s)와 rfind(s)와 동일하지만 찾지 못할 때는 ValueError를 이르킨다. >>> names = 'John Elis Python Elis Mike' >>> names.count('Elis') >>> names.find('Elis') >>> names.rfind('Elis') 17**** count(s), find(s), rfind(s), index(s), rindex(s) 등의 함수는 시작과 끝단의 범위를 지정할 수도 있다. >>> names.find('Elis',10) 17 >>> names.find('Elis',10,24) 17 replace(old, new)는 찾아바꾸기를 수행한다. >>> names = 'John Elis Python Elis Mike' >>> names.replace('Elis','Jane') 'John Jane Python Jane Mike' replace(old, new, count)로 바꾸기 회수 count를 지정할 수 있다. >>> names = 'John Elis Python Elis Mike' >>> names.replace('Elis','Jane',1) 'John Jane Python Elis Mike' split()는 white space로 문자열을 분리하여 string list로 변경한다. split(sep)를 사용하면 sep로 구분하여 분리한다. >>> name = 'John Python Elis Mike' >>> name.split() ['John', 'Python', 'Elis', 'Mike'] >>> name = 'John\tPython\n Elis Mike' >>> name.split() ['John', 'Python', 'Elis', 'Mike'] 위의 예처럼 split()으로 사용할 때 공백문자는 ' ', '\t', '\n', '\r' 중 하나이면 된다. 반면에 split(sep)으로 호출할 때는 주어진 sep과 일치하는 것으로만 분리 가능하다. >>> name = 'John Python, Elis, Mike' >>> name.split(',') ['John Python', ' Elis', ' Mike'] join(iterable)은 인자로 주어진 iteration이 가능한 객체(문자열, 리스트, 튜플 등)를 자신으로 이어서 새로운 문자열을 만들어 준다. >>> a = ['Mike','John'] >>> '-'.join(a) 'Mike-John' >>> b = 'Mike' >>> '-'.join(b) 'M-i-k-e' iterable이라는 것은 인덱스를 통한 연산이 가능하는 의미이다. 위에서 문자열로 이루어진 리스트, 또는 문자열 그 자체를 이어줌을 알 수 있다. 다음은,로 구분되는 숫자 데이터를 읽은 전형적이 코드이다. 이외에 주로 사용하는 함수로는 왼쪽 공백을 제거해 주는 lstrip(), 오른쪽 공백을 제거하는 rstrip(), 양쪽 공백을 제 거 나는 strip(), 대문자 또는 소문자로 변경해 주는 upper(), lower() 등이 있다. >>> line = ' This is test ' >>> line.rstrip() ' This is test' >>> s = "What's this?" >>> s.upper() "WHAT'S THIS?" >>> s.lower() "what's this?" 2.1.6 형 변환과 타입 검사 형 변환 자료형들은 자신들의 이름인 bool, int, float, str, list, tuple, bytes를 사용하여 형 변환이 가능하다. >>> bool('True') True >>> bool('True') True >>> bool(1) True >>> bool(0) False >>> bool(-1) True >>> str(12) '12' >>> float('12.3') 12.3 타입 검사 type(x)를 사용하면 형을 리턴해 준다. 이를 검토하면 타입을 알 수 있다. x = 1.0 if type(x) is int: print('type(x) is integer') a = [1,2,3] if type(a) is list: print('list') import numpy as np z = np.array([1,2,3]) if z is np.ndarray: print('numpy.ndarray') 2.1.7 mutable vs immutable mutable과 immutable 파이선은 모든 것이 객체(object)인데, 그 속성이 mutable(값이 변한다) 과 immutable로 구분된다. Immutable : 숫자(number), 문자열(string), 튜플(tuple) Mutable : 리스트(list), 딕셔너리(dictionary), NumPy의 배열(ndarray) 즉, 숫자, 문자열, 튜플은 값을 변경하지 못하고, 리스트와 딕셔너리는 변경할 수 있다는 뜻이다. >>> x = 1 >>> y = x >>> y += 3 >>> x >>> y 위에서 두 번째 라인까지는 1이라는 동일한 객체를 x와 y가 가리키고 있다. 세 번째에서 y의 값을 변경하는 순간 y는 4를, x는 1을 가리키게 된다. C/C++ 같은 언어 관점에서 보면 y=x가 실행하는 순간 값을 복사하는 것으로 이해할 수 있다. 조금 다른 점은 y=x가 호출되는 시점에는 동일한 객체를 가리키다가 immutable 타입인 y를 변경했을 때 변경된다는 점이다. id(obj)를 이용하면 보다 자세하게 이해할 수 있다. >>> x = 1 >>> y = x >>> id(1) 140706521527120 >>> id(x) 140706521527120 >>> id(y) 140706521527120 >>> y += 3 >>> id(y) 140706521527216 id(obj)는 객체의 유일한 숫자를 리턴하는데 포인터로 이해해도 무방하다. 다음은 다른 immutable 타입인 문자열(string)과 튜플( tuple)의 예이다. >>> x = 'abcd' >>> y = x >>> y += 'e' >>> x abcd >>> y abcde >>> x = (1,2,3) >>> y = x >>> y += (4, ) >>> x (1,2,3) >>> y (1,2,3,4) Mutable 타입은 쓰기가 가능한 컨테이너로 이해할 수 있다. 앞서에서 튜플(tuple)은 읽기만 가능한 컨 터이너이기 때문에 immutable이다. 다음은 리스트에 적용한 예이다. >>> x = [1,2,3] >>> y = x >>> y += [4, ] >>> x [1,2,3,4] >>> y [1,2,3,4] 위에서 두 번째 줄까지 실행하면 x, y는 모두 [1,2,3]을 가리키게 된다. 이후 y를 변경하면 x 역시도 변경되게 된다. 즉, C/C++ 관점에서 보면 포인터 연산 또는 레프 런스 변수로 선언한 것과 유사함을 알 수 있다. 쓰기가 가능한 컨테이너는 mutable이므로 shallow copy 가 되는 것으로 이해할 수도 있다. 복사 Python에서 immutable 자료형(숫자, 문자열, 튜플)은 직접 값이 변경되는 deep copy로 이해할 수 있다. 반면에 mutable 자료형(즉, 쓰기가 가능한 컨테이너)는 shallow copy(내부적으로 포인터만 복사)를 적용된다. >>> a = [1,2,3] >>> b = a # b와 a는 같은 값을 가리킴(shallow copy) >>> b is a True >>> b[1] = 10 # a = b = [10,11] >>> a = [5, 11] # a = [5,11] 이도록 새로 지정함, b와 연결이 끊어짐. >>> b is a False 실제 값까지 복사(deep copy) 하기 위해서는 object.copy()를 사용해야 한다. >>> a = [1,2,3] >>> b = a.copy() >>> b is a False >>> b == a True 위에서 is 와 ==를 통한 결괏값이 다른 것을 알 수 있다. is는 내부적으로 유지하는 포인터 값을 비교하고, ==는 list를 구성하는 성분을 비교한다. 2.2 제어문 C/C++ 프로그래밍 언어처럼 Python에도 if, for, while 등의 제어 구문을 제공하며, break, continue의 키워드도 동일하게 사용된다. 2.2.1 조건문 if 문 if a>0: print(a) else: print(a) if x < 0: print('negative') elif x < 10: print('0<=x<10') else: print('x>=10') switch 문 Python에는 switch/case 문이 없다. if 문으로 작성해야 한다. 조건문 if, for, while 문에서는 조건문이 포함되게 된다. 조건문은 비교연산자와 논리연산자의 조합으로 구성된다. 비교연산자 x < y, x > y, x == y, x is y, x != y, x >= y, x<=y 등이 있으며, C/C++에서 사용하는 것과 동일하다. 유일하게 다른 것은 is 연산자이다. ==가 값이 같은 것을 검토하지만 is는 레퍼런스가 같은 지를 비교한다. 예를 들어 numpy 배열의 경우 그 배열이 존재 여부를 검토할 때는 is를, 내부의 값을 검토할 때는 ==를 사용한다. import numpy as np a = np.array([1,2,3]) b = a == 1 --> [True False False] if a is None: print('None array') 논리연산자 x or y, x and y, not x 등이 있다. 2.2.2 반복문 for 문 range()를 사용할 때 for i in range(10): print(i) 리스트 멤버 접근 xdata = [0.1, 4, 3] for x in xdata: print(x) 인덱스와 리스트 멤버 동시 접근 : enumerate(list) 사용 items = [9,5,4,10] for idx, val in enumerate(items): print(idx, val) while 문 while True: key = input() if key == 'x': break print(key) list comprehesion size = 10 arr = [i * 2 for i in range(size)] 2.2.3 예외 처리 예외 처리 2.3 함수와 클래스 함수와 클래스 어떤 반복적인 작업은 보통 함수로 만들어 재사용하는 것이 일반적이다. Python에서는 def func(...): 형태로 함수를 정의한다. 간단한 프로그램일 경우 함수만으로 효율적으로 프로그램을 작성할 수 있으며 이를 절차 지향 프로그래밍(procedure-oriented programming)이라고 한다. 하지만 프로그램의 덩치가 커지고 복잡 해지만 객체지향프로그래밍(object-oriented programming)이 필요해지게 된다. 객체지향프로그래밍을 위해서는 객체를 만들어 내는 틀인 클래스(class)를 정의할 방법이 필요하다. Python에서는 class라는 키워드로 클래스를 정의할 수 있다. Python 내장 함수 Python 자체에서 직접 제공하는 함수를 내장함수(built-in function)이라고 하는데 문서를 확인하며 다음과 같다. 위 함수를 제외한 함수를 외장 함수라 부른다. 2.3.1 함수 Python에서 함수는 def function(…): 형태로 정의한다. def add(a, b): return a+b def printSomething(a, b, c): print(a, b, c) def printLogo(): print('logo text ...') c=add(a, b) printSomething(1,2,3) printLogo() 위에서 add(a, b)는 리턴 값이 있는 함수이고, printSomething()과 printLogo()는 없다. printLogo()처럼 인자가 없을 수도 있다. 함수의 리턴 값 여러 값을 리턴할 때는 튜플로 리턴한다. 값을 받을 때는 한 개의 변수로 받을 수도 있고 unpack 기능을 이용해 리턴 값으로 튜플을 모아도 된다. def computeProps(n, p, q): ... return (a, b, c) r = computeProps(...) (a, b, c) = computeProps(...) # unpack 이용 a, b, c = computeProps(...) # 위와 동일 Immutable과 Mutable 타입의 인자 Immutable 자료형( 숫자, 문자열 등 기본 자료형과 쓰기가 불가능한 컨테이너인 tuple)은 함수 내에서 값을 변경하더라고 호출 측에서 값이 변경되지 않는다. 즉, call by value로 인자가 전달된다. def foo(a, b): a = 100 b = 200 a = 1 b = 2 foo(a, b) print(a, b) # 1,2 출력 위 코드에서 함수 내부에서 인자의 값을 변경하더라고 a, b 값은 변경되지 않는다. Mutable 자료형(쓰기가 가능한 컨테이너인 list, dictionary, ndarray 등)이 함수의 인자로 전달되는 경우 함수안에서 값이 변경될 수 있다는 점에 주의해야 한다. C/C++ 관점에서 보면 call by reference로 인자를 전달하는 것이다. def foo(x): x.append(100) x = [1,2,3] foo(x) print(x) # [1,2,3,100] 위에서 인자로 넘겨진 x는 mutable 자료형인 리스트이므로, 함수 내에서 변경하는 경우 함수 호출 이후에도 값이 바뀌게 된다. 인자로 mutable 자료형을 전달했을 때는 함수 내에서 값이 바뀌는지를 주의해야 하지만, 다른 한편으로는 리턴 값이 아닌 인자로 값을 받아오도록 설계하는 데 사용할 수도 있다. 다음은 f(x, y) = x^2 + y^2라는 수학 함수에 대해 함숫값과 그래디 언트를 받아오도록 한다면 다음과 같다. import numpy as np def myfunc(x, grad): f = x[0]*x[0] + x[1]*x[1] grad[0] = 2*x[0] grad[1] = 2*x[1] return f x = np.array([0.5,0.1]) grad = np.zeros(2) f = myfunc(x, grad) print(f) # 0.26 print(grad) # array([1.,0.2]) 디폴트 인자의 지정 디폴트 인자의 지정 역시 간단하게 할 수 있다. def computeIgIcr(n, b, h, Ast, dt, Asc, dc, opt='exact'): … Ig = computeIg(n, b, h, h, Ast, dt, Asc, dt) 또는 Ig = computeIg(n, b, h, h, Ast, dt, Asc, dt,’appr’) *arg와 **kwargs 인자의 개수가 정해지지 않을 때 사용하는 것이 *arg와 **kwargs이다. def add(*args): r = 0 for v in args: r = v+i return r >>> r = add(1,2,3) >>> print(r) *args에서 *는 여러 개의 인자를 튜플로 묶어 args 변수로 함수로 전달하게 된다. 위에서 arg=(1,2,3) 형태로 전달되게 된다. 일반 인자와도 같이 사용할 수 있는데 항상 뒤에 와야 한다. def foo(x,*args) 형태이고, foo(1,2,3,4,5)로 호출했다면 x=1, args=(2,3,4,5)로 전달하는 식이다. 비슷한 것으로 **kwargs가 있다. 이는 keyword arguments로 이해할 수 있는데 keyword1=value1, keyword2=value2, ... 형태를 dictionary로 만들어 준다. def myfunc(**kwargs): print(kwargs) for key, value in kwargs.items(): print(key,'=',value) >>> myfunc(a=1, b=2, c=3) {'a': 1, 'b': 2, 'c': 3} a = 1 b = 2 c = 3 *args와 **kwargs는 일반 인자와 함께 사용될 수 있으며, 순서는 항상 다음과 같다. def some_func(fargs,*args,**kwargs): pass 변수의 범위(scope) 함수 내에 사용하는 변수는 local scope를 갖는다. 함수 내 함수 Python은 C/C++과 달리 함수 내에서 함수를 정의해서 사용할 수 있다. 함수 내 함수는 자신을 둘러싼 함수의 변수를 마치 전역변수처럼 사용할 수 있기 때문에 사용하기에 따라 매우 편리하게 사용 가능하다. def outside(): outsideList = [1, 2] def nested(): outsideList.append(3) nested() print outsideList 2.3.2 클래스 Python의 클래스는 class 키워드를 이용해 선언할 수 있다. 다음은 가장 간단하게 정의한 예이다. 다음과 같은<NAME>을 지닌다. class Simple: pass 위와 같이 정의한 후 객체를 생성한 후 멤버 변수를 추가할 수도 있다. >>> a = Simple() >>> a.name = 'Jane' >>> a.phone = '123-456-7890' 다음은 보다 일반적인 사용법을 예시한 것이다. class Account: numOfAccount = 0 def __init__(self, name): self.name = name; self.balances = 0 Account.numOfAccount += 1 def withdraw(self, value): self.balances -= value return self.balances def deposit(self, value): self.balances += value return self.balances def __del__(self): Account.numOfAccount -= 0 >>> a1 = Account('John') >>> a1.deposit(10) 10 >>> a1.withdraw(2) >>> print(a1.balances) >>> a2 = Account('Jane') >>> print('no of Account : ',Account.numOfAccount) Account 클래스는 클래스 단위로 정의한 변수(클래스 변수, C++의 static variable과 동일)인 numOfAccount, 인스턴스 변수(C++의 멤버 변수) name, balances, 생성자 __init__(), 소멸자 __del__(), 일반 메쏘드 withdraw(), deposit() 등을 정의하고 있다. self는 C++ 클래스 정의 시 생략되는 this 포인터와 같은 역할을 한다. 또한 Python에서는 기본적으로 멤버와 메쏘드가 public 속성을 지닌다. 만약 private으로 하고 싶을 때는 두 개의 밑줄 __로 시작하도록 이름을 정의하면 된다. 메쏘드에 self 인자가 없는 경우는 C++의 static member와 동일하다. 이 함수에서는 클래스 멤버 변수를 조작하거나 단순히 namespace를 사용하는 함수처럼 사용해야 한다. class Account: numOfAccount = 0 ... def makeZero(number): Account.numOfAccount = number Python의 클래스에서도 상속(inheritance)과 가상 함수 등을 지원한다. 다음은 간단한 예이다. class Element: def __init__(self, id): self.id = id self.nodeIds = [] def computeStiffness(self): print('Element::computeStiffness') def printElement(self): print('id : %d'%self.id) class Q4Element(Element): def __init__(self, id, nodeIds): super().__init__(id) # or Element.__init__(self, id) self.nodeIds = nodeIds def computeStiffness(self): print('Q4Element::computeStiffness') >>> e = Q4Element(1, [1,2,3]) >>> e.printElement() id : 1 >>> e.computeStiffness() Q4Element::computeStiffness 위에서 부모 클래스의 생성자인 __init__()를 호출하는 방법을 두 가지이다. super().__init__(id) 등과 같이 self를 사용하는 방법과 Element.__init__(self, id)와 같이 클래스 이름을 사용하고 메쏘드에 self를 사용하는 방법이 있다. 이러한 방법을 일반 메쏘드에서도 성립한다. 또한 이름이 같은 메쏘드가 가상 함수가 된다. 2.3.3 정적 함수를 이용한 다중 생성 Python 클래스는 keyword 입력을 허용하기 때문에 다중 생성자를 쓰기 쉽지 않다. 이를 위해서는 variable 입력을 받든지, 정적 함수를 이용하는 방법을 사용할 수 있다. 방법 1 class A: def __init__(self, *arg,**karg): ... arg와 karg를 분석 정적 함수 class Rectangle def __init__(self): self.a = None self.b = None def fromWithHeight(a, b): r = A() r.a = a r.b = b return r def fromArea(a, area): r = Rectangle() r.a = a r.b = area/a return r 2.5 모듈과 패키지 프로그램을 작성하게 되면 거의 대부분 외부 라이브러리의 활용이 필요하며, 프로그램의 규모가 커짐에 따라 자신이 직접 작성한 부분도 몇몇 부분으로 소스를 나누어 작성해야 한다. Python에서 여기에 대응하는 개념이 모듈(module)과 패키지(package)이다. 모듈(module)은 재사용할 목적으로 작성된 Python 소스 파일을 의미하며, import 문으로 로딩하여 사용한다. 예를 들어 os 모듈은 os.py라는 파일로 작성되어 있으며 사용 시에서는 import os 등으로 로딩한다. 다음은 사용 예이다. >>> import os >>> os.getcwd() 'D:\\DevProg\\Python\\samples' >>> os.chdir(r'D:\DevProg\Python') abs(), complex(), int() , list(), ord() 등의 내장함수(built-in function)를 제외한 모든 함수, 클래스 들은 항상 모듈에 포함된다. math 등의 일부 내장 모듈(built-in module)은 Python 언어 자체에 포함되어 있지만 나머지 모듈/패키지는 별도 파일 형태로 존재한다. 다음은 내장 모듈을 확인 코드이다. >>> import sys >>> sys.builtin_module_names ('_ast', '_bisect', '_blake2', '_codecs', '_codecs_cn', '_codecs_hk', '_codecs_iso2022', '_codecs_jp', '_codecs_kr', '_codecs_tw', '_collections', '_csv', '_datetime', '_findvs', '_functools', '_heapq', '_imp', '_io', '_json', '_locale', '_lsprof', '_md5', '_multibytecodec', '_opcode', '_operator', '_pickle', '_random', '_sha1', '_sha256', '_sha3', '_sha512', '_signal', '_sre', '_stat', '_string', '_struct', '_symtable', '_thread', '_tracemalloc', '_warnings', '_weakref', '_winapi', 'array', 'atexit', 'audioop', 'binascii', 'builtins', 'cmath', 'errno', 'faulthandler', 'gc', 'itertools', 'marshal', 'math', 'mmap', 'msvcrt', 'nt', 'parser', 'sys', 'time', 'winreg', 'xxsubtype', 'zipimport', 'zlib') 패키지(package)는 모듈을 디렉터리 구조로 묽어놓은 것을 의미한다. 예를 들어 os 모듈은 os.py라는 파일로 존재하지만 대표적 수치 패키지인 NumPy는 numpy라는 폴더 내에서 여러 모듈이 존재한다. 표준 라이브러리는 Python 인스톨 시 제공되는 내장함수, 내장모듈, 외장 모듈 등을 의미한다. 예를 들어 다음과 같다. abs() : 내장 함수 os.getcwd() : 외장 함수. 모듈 os에 정의된 외장 함수 math 모듈 : 내장 모듈 os 모듈 : 외장 모듈이나 표준 모듈. C:\ProgramData\Anaconda3\Lib\os.py로 제공 NumPy 패키지 : 외장 패키지이고 사용자가 직접 인스톨해야 함. C:\ProgramData\Anaconda3\Lib\site-packages\numpy에 여러 모듈이 디렉터리를 이루고 있음. 2.5.1 모듈 모듈 작성과 사용 모듈(module)은 단순히 재사용을 염두에 두고 작성한 Python 소스파일을 의미한다. 예를 들어 다음과 같이 mysolve.py라는 파일에 Newton 법과 bisection 법으로 방정식의 해를 구하는 함수를 작성했다고 가정하기로 한다. mysolver.py tol = 1E-10 maxiter = 50 def solve_by_newton(func, der, x0): """ solve equation by newton method """ x = x0 for i in range(maxiter): f, df = func(x), der(x) if abs(f) < tol: return x x = x-f/df return None def solve_by_bisection(func, lb, ub): """ solve equation by bisection method """ for i in range(maxiter): x = (lb+ub)/2. if func(x) == 0 or (ub-lb)/2 < tol: return x elif func(lb)*func(x) < 0: ub = x else: lb = x return None mysolver.py가 있는 폴더에서 python을 실행했다면 다음과 같이 모듈을 사용할 수 있다. import mysolver def func(x): return x*x-2*x-4 def der(x): return 2*x-2 # f(x), f'(x) xNewton = mysolver.solve_by_newton(func, der, 10) xBisection = mysolver.solve_by_bisection(func, 0,10) print('tol = ',mysolver.tol) print('x = ',xNewton, ', ', xBisection) 모듈을 사용하는 것은 확장자. py를 뺀 파일 이름으로 import module 형태로 로딩하여 사용하면 된다. 코드에서 확인할 수 있듯이 모듈 내의 함수, 변수, 클래스 등은 module.xxx 등과 같은 형태로 사용한다. 이때 module은 namespace 역학을 한다. 여러 가지 import 문의 변형이 가능하다. 다음은 다양한 변형을 나열한 것이다. from mysolver import * # mysolve 모듈의 모든 것을 임포트 xNewton = solve_by_newton(func, der, 10) from mysolver import solve_by_newton, tol # mysolve 모듈에서 solve_by_newton과 tol만 임포트 xNewton = solve_by_newton(func, der, 10) print(tol) import mysolver as solver # 모듈의 이름을 solver로 변경하여 사용할 때 xNewton = solver.solve_by_newton(func, der, 10) from mysolver import solve_by_newton as solve # 모듈의 일부 함수를 임포트 하면서 이름을 변경할 때 xNewton = solve(func, der, 10) 모듈 찾기 경로 Python에서 import 문으로 주어진 모듈은 다음의 순서로 찾는다. 현재 작업 디렉터리(current working directory) Python 인스톨 디렉터리와 그 하위의 lib/site-packages 디렉터리 (Python 인터 리프터마다 조금씩 다름) 환경 변수 PYTHONPATH에 지정된 디렉터리 이 모듈을 찾는 위치는 sys 모듈에서 sys.path를 통해 접근할 수 있다. >>> import sys >>> sys.path ['', 'C:\\ProgramData\\Anaconda3\\Scripts', 'C:\\ProgramData\\Anaconda3\\python36.zip', 'C:\\ProgramData\\Anaconda3\\DLLs', 'C:\\ProgramData\\Anaconda3\\lib', 'C:\\ProgramData\\Anaconda3', 'C:\\ProgramData\\Anaconda3\\lib\\site-packages', 'C:\\ProgramData\\Anaconda3\\lib\\site-packages\\Babel-2.5.0-py3.6.egg', 'C:\\ProgramData\\Anaconda3\\lib\\site-packages\\win32', 'C:\\ProgramData\\Anaconda3\\lib\\site-packages\\win32\\lib', 'C:\\ProgramData\\Anaconda3\\lib\\site-packages\\Pythonwin', 'C:\\ProgramData\\Anaconda3\\lib\\site-packages\\IPython\\extensions', 'C:\\Users\\jrcho\\.ipython'] 위에서 첫 번째 모듈 찾기 경로로 ''인 점에 주목하자. 이 위치는 python의 working directory를 의미한다. 즉, python을 실행한 경로이다. 만약 import os, os.chdir(somefolder) 등으로 working directry를 변경할 때 os.getcwd()로 조회되는 디렉터리다. 이 때문에 앞서 예제에서 mpsolver.py를 import mysolver로 구동할 수 있었던 것이다. 여러 모듈로 나누어 프로젝트를 만들 때(1) 몇몇 모듈(파일)로 분리하여 하나의 프로젝트를 수행하는 경우가 일반적이다. D:\Prog\MyProg - myprog.py - myutil.py - geom - show_geom.py - construct.py 위와 같은 예에서 myprog.py가 main 함수 역할을 하고, myutil.py나 geom/show_geo.py 등이 사용되는 모듈이라고 생각기로 한다. myprog.py를 실행할 때 현 디렉터리가 working directory이므로 다음과 같이 모듈을 임포트 하면 된다. import myutil from geom import construct .... 여러 모듈로 나누어 프로젝트를 만들 때(2) 두 번째는 메인 모듈을 하위 디렉터리에 두는 경우이다. 이 경우네는 sys.path에 추가하는 방법이 주로 사용된다. D:\Prog\MyProg - main_module/myprog.py, myutil.py - geom/ show_geom.py, construct.py 위와 같은 예에서 myprog.py가 main 함수 역할을 하고, myutil.py나 geom/show_geo.py 등이 사용되는 모듈이라고 생각기로 한다. myprog.py를 실행할 때 현 디렉터리가 working directory이므로 다음과 같이 모듈을 임포트 하면 된다. import sys sys.path.append('../geom) import myutil from geom import construct .... 위에서 sys.path에서 상대 경로를 사용했다는 점에 주목한다. 자신만의 라이브러리화된 모듈/패키지 작성한 모듈/패키지를 사용하는 컴퓨터 단위에서 공용으로 사용하려면 모듈의 위치를 PYTHONPATH나 sys.path에 등록해야 한다. 다음과 같이 D:\Prog\Lib 내에 자신만의 모듈이나 패키지가 존재한다고 가정하기로 한다. D:\Prog\Lib - myutils.py - mygraphics.py - geom - __init__.py - show_geom.py - construct.py 이제 모듈의 위치를 PYTHONPATH나 sys.path에 등록해서 사용한다. (1) 환경 변수 PYTHONPATH에 추가하는 방법 : 항상 추가된다. import myutils as utils area = utils.compute_area([0,0,1,0,2,1) (2) sys.path에 추가하는 방법 : 현재 Python 프로세스에서만 유효하다. import sys sys.path.append(r'D:\Prog\Lib') import myutils as utils area = utils.compute_area([0,0,1,0,2,1) 여기에서 sys.path에 절대 경로를 사용했다는 점에 주목한다. 2.5.2 패키지 패키지(package)는 디렉터리 형태로 관련 모듈을 모아둔 것으로 이해할 수 있다. 보다 전문적으로 이야기하면 점(.)으로 모듈 이름을 활용할 수 있도록 구조화하는 방법을 의미한다. 다음은 Python 공식 튜토리얼에 소개된 설명을 정리한 것이다. 사운드 관련 패키지를 만든다고 가정하기로 한다. 이 경우 다음과 같은 파일 구조로 라이브러리를 구성한다. sound/ Top-level package __init__.py Initialize the sound package formats/ Subpackage for file format conversions __init__.py wavread.py wavwrite.py auread.py auwrite.py ... effects/ Subpackage for sound effects __init__.py echo.py surround.py reverse.py ... filters/ Subpackage for filters __init__.py equalizer.py vocoder.py karaoke.py ... 이 라이브러리를 사용하는 것은 점(.)이 있는 모듈명 import 할 수 있다. 예를 들어 echo.py에 echofilter(...)라는 함수를 사용하려면 다음과 같다. import sound.effects.echo sound.effects.echo.echofilter(input, output, delay=0.7, atten=4) from sound.effects import echo echo.echofilter(input, output, delay=0.7, atten=4) from sound.effects.echo import echofilter echofilter(input, output, delay=0.7, atten=4) from sound.effects.echo import * echofilter(input, output, delay=0.7, atten=4) 경우에 따라서 부 패키지(sub-package) 자체를 임포트 할 수도 있다. 즉, 원칙적으로 from module import * 형태 대신 from package import * 등과 같이 사용하려면 __init__.py에 __all__ 속성에 모듈명을 리스트 형태로 나열해야만 한다. sound/effects/init.py __all__ = ["echo", "surround", "reverse"] 이제 다음과 같이 from package import *형태로 사용이 가능하다. from sound.effects import * echo.echofilter(input, output, delay=0.7, atten=4) 2.6 파일 입출력 Python의 파일 입출력은 C/C++의 stdio.h에 정의된 방식과 유사하다. 다음은 텍스트 파일을 읽어 strlist라는 str의 list에 저장한 후 출력한 예이다. f = open('mytext.txt','rt') # f = open('mytext.txt') 와 동일 strlist = f.readlines() f.close() print(strlist) f = open(file, mode='r',encoding=None,...)으로 파일 객체를 만들고 이후 파일 객체를 대상으로 멤버 함수를 호출하는 방식으로 파일을 다룬다. mode는 C의 fopen()처럼 읽기/쓰기/추가(각각 'r', 'w', 'a'), 텍스트 파일/이진 파일(각각 't','b') 등과 같이 파일 오픈 모드를 문자열로 지정한다. 디폴트는 읽기('r')와 텍스트 파일('t')이다. 텍스트 파일로 파일을 열면 파일에 입출력은 유니코드 문자열인 str 객체를 통해 수행하게 된다. 이때 텍스트 인코딩(encoding)과 디코딩(decoding)이 발생하게 된다. 이진 파일로 파일을 열면 파일에 입출력은 bytes 객체를 통해 수행하게 된다. bytes 객체는 단순히 1 바이트 단위의 배열(또는 ASCII 문자열)로, 파일에 저장되어 있는 데이터를 바이트 단위로 변환 없이 입출력한다는 것을 의미한다. encoding은 텍스트 파일로 파일을 열 때만 의미가 있으며, 디폴트인 None은 시스템의 디폴트 인코딩(Windows의 경우 cp949)을 사용한다는 것을 의미한다. 파일 입출력 관련 주요 함수 이진 파일은 io.BufferedReader 또는 io.BufferedWriter라는 클래스가 생성되며, 텍스트 파일은 io.TextIOWrapper라는 클래스 객체가 생성되는 데 모두 io.IOBase라는 클래스에서 상속받고 있다. 파일을 다룰 때 복잡한 클래스 상속에 대한 지식은 필요 없으며, 단지 File Object에 에서 사용되는 주요한 함수을 기억하면 된다. f = open(file, mode='r',encoding=None,...) : 파일 열기 f.name : 파일 이름 f.mode : 파일 열기 모드 조회 f.encoding : 현재 사용되고 있는 인코딩(텍스트 파일에서만 유효) f.close() : 닫기. 강제로 사용이 끝나 파일을 닫는다. 이를 호출하지 않아도 파일 객체가 파괴될 때 파일을 닫는다. f.flush() : 버퍼 즉시 비우기 f.closed : 파일이 닫혔는지를 True, False로 리턴 f.readable(), f.writable() : 읽거나 쓸 수 있는지 True, False로 리턴 f.seek(offset, whence=SEEK_SET), f.tell() : 파일 포인터 위치 설정. 기준 위치 whence에 SEEK_SET(0), SEEK_CUR(1),SEEK_END(2) 지정 가능. offset이 음수이면 기준 위치로부터 역방향으로 위치 지정 f.tell() : 파일 포인터 위치 조회 f.read([size]),f.readline([size]), f.readlines([sizehint]): 읽기 함수. f.write(str), f.writelines(sequenc) : 쓰기 함수 with 구문의 사용 사용이 끝난 파일 객체는 f.close()로 닫고 재사용 가능하다. 다른 방법은 with 구문을 이용하여 구문 내에서만 유효한 파일 객체를 사용하는 것이다. with open('test.txt') as f: strlist = f.readlines() process strlist... 위에서 f.close()로 명시적으로 파일을 닫지 않아도 with 블록이 끝날 때 파일 자동으로 닫히게 된다. 예외 처리 주어진 파일명의 파일 존재하지 않거나 인코딩 오류가 발생하는 등과 같은 여러 예외가 발생할 수 있다. 이들 오류는 모두 IOError로 처리할 수 있다. 다음은 예외 처리를 포함한 간단한 코드 형태를 나타낸 것이다. try: f = open(filename,"rb") try: data = f.read() finally: f.close() except IOError: print("IOError occured") 2.6.1 텍스트 파일 텍스트 파일 인코딩 텍스트 파일은 항상 2바이트로 문자를 표시하는 배열, 즉 유니코드 문자열인 str로 파일을 읽고 쓰게 된다. 문제는 실제 파일은 바이트 단위를 저장한다는 점이다. 예를 들어 다음과 같은 두 개의 문자열이 존재한다고 가정해 보자 eng = 'Hello' kor = '안녕하세요' 위에서 eng와 kor은 모두 5개의 문자로 구성된 유니코드 문자열이므로 메모리 상에서는 한 문자당 2바이트의 메모리가 필요하므로 10바이트를 사용한다(실제로는 str 객체의 정보가 포함되어 있으므로 더 많은 메모리 소요). 파일로 출력할 때는 어떤 방식으로 인코딩해야 할지 결정해야 한다. 주로 사용하는 인코딩 방식은 'CP949'와 UTF-8가 있다. 'CP949' : Windows의 디폴트 인코딩 방식, 영문에는 아스키코드에 따라 1바이트로, 한글에는 2바이트를 사용해서 인코딩. 'EUC-KR'를 다시 확장한 인코딩 방식이며, 에디터에 따라 'ANSI', 'EUC-KR' 등으로도 표기됨. 'UTF-8' : 유니코드 인코딩 방식의 하나. Python 3에서. py 소스 파일에 대한 디폴트 인코딩 방식. 영문에는 아스키코드에 따라 1바이트로, 한글은 초성, 중성, 종성을 각각 1바이트로 저장(정확히는 ANSI 문자 셋을 제외하면 2~4바이트로 표현). 다른 유니코드 방식인 'UTF-16'에 비해 영문이 많을 경우 파일 용량을 줄일 수 있으며, 'ANSI'와의 하위호환성이 보장되기 때문에 가장 많이 사용됨. 다음 앞서의 eng와 kor를 텍스트 파일로 출력했을 때 인코딩 방식에 따른 파일 용량이다. 인코딩 방식 encoding ='CP949' encoding ='UTF-8' 비고 eng = 'Hello' 저장 시 5 바이트 5바이트 저장된 파일을 완전히 동일 kor = '안녕하세요' 저장 시 10 바이트 15바이트 만약 영문만을 저장했다면 두 인코딩 방식은 ASCII 코드를 이용해 파일에 쓰기 때문에 완전히 동일하다. 한글이 포함된 경우 인코딩 방식에 따라 저장하는 방식이 완전히 다르다. 이를 다시 이야기하면 영문만 있는 텍스트 파일은 위 두 개의 인코딩 방식 중 아무 방식으로 지정해도 읽을 수 있지만, 한글이 포함된 텍스트 문서는 인코딩 방식을 알아야만 정확하게 읽어 올 수 있다는 의미가 되기도 한다. 이때 파일에 바이트 단위로 인코딩 방식에 따라 쓰는 작업은 encoding, 그 반대로 인코딩된 바이트 배열을 유니코드 문자열로 바꾸는 것을 decoding이라고 한다. 참고 여기에서는 유니코드의 인코딩으로 UTF-8만 다루었지만 유니코드 인코딩 방식에는 'UTF-8', 'UTF-8 with BOM', 'UTF-16', 'UTF-16 with BOM' 등 다양한 방식이 있다. BOM(Byte Order Mark)은 파일 맨 앞에 몇 개의 바이트를 예약하여 표기하는 것을 의미한다. 자세한 사항은 세모 노트-문자열 인코딩의 모든 것!를 참조하길 바란다. 인코딩 확인법 이미 존재하는 텍스트 파일의 인코딩은 notepad++ 등의 에디터에서 가능하고, 변환 역시 가능하다. 가능하면 UTF-8을 사용하는 것이 좋다. 대부분의 에디터에서 최초 저장하는 텍스트 파일은 UTF-8을 사용한다. 만약 이미 존재하는 파일이고 인코딩 방식을 에디터가 인식했다면 그 인코딩 방식으로 변경된 사항을 저장한다. 문제는 Visual Studio인데 다음과 같은 방식이 적용된다. 새로 생성한 파일(처음으로 저장하는 파일)인 경우 CP949를 사용한다. 이미 존재하는 파일은 자동으로 인코딩을 감지하고 그 인코딩으로 저장한다. 따라서 Visual Studio로 Python 코드에 한글을 쓸 때는 주의해야 한다. 텍스트 파일 읽기 텍스트 파일은 rt 모드로 열어서 작업을 수행한다. 문서에 한글이 포함되어 있다면 문서의 인코딩 방식을 미리 알고 있어야 한다(보통 사용하는 'CP949' 와 'UTF-8'에서 영문은 구분할 필요가 없으나 한글이 포함되면 미리 알아야 함) 보통 텍스트 파일은 read(), readline(), readlines(), write() 등의 메쏘드로 읽고 쓰기를 수행한다. f.read()로 전체 파일을 읽어오기 f = open('SomeWord.txt','rt',encoding='utf-8') # Open file with 'UTF-8' 인코딩 text = f.read() f.close() lines = f.split('\n') # 라인 단위로 분해 f.readline()으로 라인 단위 작업 f = open('SomeWord.txt','rt',encoding='utf-8') # Open file with 'UTF-8' 인코딩 while True: line = f.readline() # read line-by-line using f.readline() if not line: break processing line .... f.close() # Close file f.readlines()으로 모든 라인을 일괄 읽어와 작업 f = open('SomeWord.txt','rt',encoding='utf-8') # Open file with 'UTF-8' 인코딩 lines = f.readlines() # read all lines f.close() # Close file ... processing lines 텍스트 출력 f = open('SomeWordOutput.txt','wt',encoding='UTF-8') for line in lines: f.write(line) # Use f.write(line) instead of f.writeline(line) f.close() # Close file CSV 파일 다루기 CSV 파일인 경우 Python 빌트인 패키지인 csv 패키지를 사용하면 편리하다. filename = './text.csv'; f = open(filename,'rt') reader = csv.reader(f, delimiter=',') next(reader) # 헤더 라인 skip … 필요한 경우 사용한다. for line in reader: print(line) f.close() 위에서 line은 line = [‘first’, ‘second’,’third’] 등과 같이 문자열로 분리해서 읽히게 된다. 만약 숫자만을 포함한 CSV 파일이라면 다음과 같이 float()를 통해 변환하면 된다. filename = './text.csv'; f = open(filename,'rt') reader = csv.reader(f, delimiter=',') next(reader) # 헤더 라인 skip … 필요한 경우 사용한다. for line in reader: for word in line: print(float(word)) f.close() 숫자를 이루어진 텍스트 파일 숫자만 있는 경우(엄밀하게 그럴 필요는 없지만), numpy 이용하는 것이 편리하다. 예를 들어 숫자로 이루어진 테이블<NAME>의 파일을 쉽게 읽으려면 NumPy의 loadtxt()나 savetxt()를 사용하면 편리하다. 아래는 공백문자로 구분된 테이블 형태의 숫자 파일을 읽어들이고 저장한다. import numpy as np data = np.loadtxt('ttt.txt') np.savetxt('ttt.out',data,"# test") 만약 header가 있는 경우 skiprows 인자를 지정할 수 있고, 디폴트로 공백문자인 구분자를 변경하려면 delimiter 인자를 지정한다. 예를 들어 첫 번째 줄을 무시하고, 콤머로 구분된 파일을 읽을 때는 다음과 같다. data = np.loadtxt(fname, skiprows=1, delimiter=',')) 이외에도 주석 처리, 구분자 변경 등 다양한 사양은 3장 NumPy 편 참조 비정형 데이터 파일 읽기 앞서에서 소개한 load_txt(), load_csv() 등의 함수를 숫자 데이터가 행렬 형태여야 한다. 다음과 같이 정확하게 행렬 행태가 아닌 경우에는 직접 파일을 읽어야 한다. PEER NGA STRONG MOTION DATABASE RECORD Loma Prieta, 10/18/1989, Gilroy - Gavilan Coll., UP ACCELERATION TIME SERIES IN UNITS OF G .1922907E-02 .1922299E-02 .1921739E-02 .1921233E-02 .1920794E-02 .1920399E-02 .1920027E-02 .1919639E-02 .1919272E-02 .1919053E-02 .1919245E-02 .1919835E-02 .1920353E-02 .1920558E-02 .1920871E-02 .1921351E-02 .1920903E-02 .1918933E-02 .1916462E-02 .1914326E-02 .1911934E-02 .1910234E-02 .1909185E-02 .1908185E-02 .1914254E-02 .1930378E-02 .1941617E-02 .1933759E-02 .1920388E-02 .1923397E-02 .1926134E-02 .1898869E-02 .1869943E-02 .1879737E-02 .1935748E-02 .2021556E-02 .2070567E-02 .2060695E-02 .2056042E-02 .2081995E-02 .2062717E-02 .1988024E-02 def loadData(file, skiprow=0): f = open(file,'rt',encoding='utf-8') lines = f.readlines() f.close() data = [] for i in range(skiprow, len(lines)): temp = lines[i].split() for t in temp: data.append(float(t)) return data 2.6.2 바이너리 파일 이진 파일로 파일을 열면 텍스트 파일처럼 인코딩 작업이나 줄바꿈 문자에 대한 변환이 없이 항상 1바이트 크기의 배열인 bytes 객체로 읽고 쓰기를 수행한다. 다음은 이진 파일로 열어 파일을 복사한 예이다. 파일 복사 f = open('ABBA.mp3','rb') data = f.read() # bytes f.close() f = open('ABBA-copy.mp3','wb') f.write(data) f.close() MP3 파일 곡명 확인 다음은 Working with File Objects에 소개된 코드를 발췌한 것으로 mp3 파일에서 곡명을 확인한 예이다. mp3 파일은 파일 마지막의 128 바이트에 곡명, 장르 등등 여러 정보를 저장한다(포맷 정보는 한글 위키피디아 참조). >>> f = open('ABBA.mp3','rb') >>> f.seek(-128,2) # 끝에서 128 바이트로 위치 이동 >>> tagdata = f.read(128) >>> title = tagdata[3:33].decode() >>> title 'I Do I Do I Do I Do I Do ' >>> f.close() 위에서 bytes.decode()를 이용해 유니코드 문자열인 str로 변환하고 있다. 문자열 읽고 쓰기 문자열을 읽고 쓰는 것은 텍스트 파일로 파일을 열고 읽고 쓰면 편리하다. 만약 이진 파일로 파일을 열어 다룬 때는 str.encode(encoding='utf-8')과 bytes.decode(encoding='utf-8')을 적절히 활용해야 한다. 다음은 문자열을 이진 파일에 읽고 쓴 예이다. # writing str to binary file mytext = '이 일은 쉬운 일이 아닙니다.' f = open('mydata.bin','wb') f.write(mytext.encode()) f.close() # reading str from binary file f = open('mydata.bin','rb') bdata = f.read() mytext = bdata.decode() f.close() 수치 데이터 읽고 쓰기 int, float 같은 수치데이터는 struct 모듈에서 제공하는 struct.pack(fmt, v1, v2,...)으로 bytes로 변환할 수 있으며(이를 packing이라고 함), 반대로 (v1, v2,...) = struct.unpack(fmt)로 수치데이터로 변환 가능하다(이를 unpacking이라고 함). 이때 v1, v2 등이 수치데이터이고, fmt는 포맷 문자열이다. 예를 들어 fmt가 "idd"이면 int, float, float 순서로 packing이나 unpacking을 한다는 의미이다. import struct # packing numerical data into bytes data = struct.pack("idd",1,10.3, -11.3) # int, float, float # unpacking bytes to numerical data (i, x, y) = struct.unpack("idd",data) # i=1, x = 10.3, y=-11.3 파일에 읽고 쓰는 예는 다음과 같다. import struct # writing data age = 27 # int height = 175.2 # float weight = 71.3 # float data = struct.pack('idd',age, height, weight) f = open('mydata.bin','wb') f.write(data) f.close() # reading data f = open('mydata.bin','rb') data = f.read() (age, height, weight) = struct.unpack('idd',data) 문자열과 수치데이터를 동시에 읽고 쓰기 문자열은 str.encode(), bytes.decode() 함수를 활용하고, 수치데이터는 data=struct.pack(fmt, v1, v2,...)와 (v1, v2,...)=struct.unpack(fmt, data)를 적절히 활용한다. 이때 문자열의 길이를 직접 계산해야 한다는 점에 주의한다. import struct # writing data name = '홍길동' # str age = 27 # int height = 175.2 # float weight = 71.3 # float name_bytes = name.encode() name_data = struct.pack('i',len(name_bytes)) + name_bytes numeric_data = struct.pack('idd',age, height, weight) data = name_data+numeric_data f = open('mydata.bin','wb') f.write(data) f.close() # reading data f = open('mydata.bin','rb') data = f.read() strlen, = struct.unpack('i',data[0:4]) name = data[4:(4+strlen)].decode() (age, height, weight) = struct.unpack('idd',data[4+strlen:]) 참고 이진 파일에 대한 입출력은 상당히 복잡하다. 보다 자세한 사항은 Working binary data python을 참고한다. 2.7 실행 환경 관리 Python은 다양한 방법으로 실행 가능하다. 2.7.1 os와 glob 모듈 이용하기 Python의 기본 모듈 중 os 모듈은 운영 체계와 관련된 각종 기능을 제공한다. 디렉터리 및 리스팅 import os os.listdir() os.listdir('c:') os.mkdir('NewDir') os.rmdir('NewDir') os.unlink('ttt.txt') os.rename('from.txt','to.txt') import glob files = glob.glob('*.*') 파일, 폴더 여부 확인 import os os.path.isdir(r'D:\DevProg\Python\test.txt') os.path.isfile(r'D:\DevProg\Python\test.txt') 작업 디렉터리 working directory를 조회하는 것은 os.getcwd(), 변경하는 것은 os.chdir(dir)을 사용한다. >>> import os >>> os.getcwd() >>> os.chdir(r'D:\DaelimCS\Report\Analysis\Now') 환경 변수 PATH 관리 PATH 확인 >>> import os >>> os.environ['PATH'] 'C:\\ProgramData\\Anaconda3\\Library\\bin;C:\\ProgramData\\Anaconda3;C:\\ProgramData\\Anaconda3\\Scripts;C:\\Program Files (x86)\\Graphviz2.38\\bin;... PATH 추가 >>> import os >>> env = os.environ >>> newpath = r'D:\DevProg\HFC3.0\resource\Distrib-x64-2017-08-21;'+env['PATH'] >>> env['PATH'] = newpath 이 방법은 현재 실행된 명령창에 대해서만 유효하다. 외부 프로그램 실행 os.system('notepad') os.system('notepad') 2.7.2 스크립트 실행 제어 파이썬 스크립트 실행하기 Python 스크립트 내에서 다른 스크립트를 실행하는 것은 Python 2에서 execfile('script.py') 형태로 다른 스크립트를 실행하였다. Python 3에서는 더 이상 지원하지 않는다. 대신 파일을 읽은 다음 exec(commandLines)와 같이 라인 단위로 실행하는 명령어를 이용하면 된다. f = open('myRCPile.py') exec(f.read()) f.close() 스크립트 실행을 중단하기 스크립트 실행을 중단하는 것은 sys.exit(msg)를 사용하거나 raise SystemExit(msg)를 사용한다. import sys ... if something == None: sys.exit('something is wrong') ... ... if something == None: raise SystemExit('something is wrong') ... 디버깅 용도로 특정 라인까지만 실행하고자 할 때 사용하면 유용하다. 2.7.3 외부 프로그램 실행 subprocess를 이용한 외부 프로그램 실행 외부 프로그램의 실행은 os 모듈을 사용할 수도 있느나 보다 전문적으로는 subprocess 모듈을 사용한다. import subprocess subprocess.run('notepad') 위 코드에서 subprocess.run(,...)는 실행하고 끝날 때까지 기다린다(wait). run()은 Python 3.5부터 도입되었으며 예전에는 다음과 같이 Popen 객체를 생성하고 wait()를 호출하여 사용하였다. import subprocess subprocess.Popen('notepad').wait() 다음은 일반적인 사용방법이다. import os import subprocess env = os.environ newpath = r'D:\Earthquake\myStudy\OpenSees3.3.0\bin;'+env['PATH'] env['PATH'] = newpath r = subprocess.run('Opensees.exe push1.tcl',shell=True, capture_output=True, text=True) # CompletedProcess returned print(r.args) print(r.returncode) print(r.stderr) print(r.stdout) os 모듈을 통해 외부 실행파일을 위한 PATH를 지정하였다. 다음과 같이 env=... 인자로 지정하는 것도 동등하다. mport os import subprocess env = os.environ newpath = r'D:\Earthquake\myStudy\OpenSees3.3.0\bin;'+env['PATH'] r = subprocess.run('Opensees.exe push1.tcl',shell=True, capture_output=True, text=True, env={'PATH':newPATH}) ... 외부 실행파일에 전달한 명령행 인자가 있는 경우 자신을 포함해서 인자를 리스트로 주어야 한다.(위에서는 ['Opensees.exe', 'push1.tcl']). 명령행에 입력하는 것처럼 문자열로 처리하려면 shell=True 옵션을 쓴다. capture_output=True은 표준 입출력을 받아오고 text=True는 텍스트로 받아오라는 의미이다. subprocess.run()을 실행하면 CompletedProcess 객체가 리턴된다. 이 객체를 통해 args, 리턴 값, 표준 입출력 등을 얻을 수 있다. 외부 프로그램 병렬 실행 concurrent.futures.ProcessPoolExecutor를 이용하여 subprocess.run을 실행하면 외부 프로그램을 비동기적으로 병렬 실행할 수 있다. 반드시 __main__ 모듈 내에서 실행되어야 함을 주의한다. import subprocess import concurrent.futures import time import os def main_single_run(): env = os.environ newpath = r'D:\Earthquake\myStudy\OpenSees3.3.0\bin;'+env['PATH'] env['PATH'] = newpath r = subprocess.run('Opensees.exe push1.tcl',shell=True, capture_output=True, text=True) # CompletedProcess returned print(r.args) print(r.returncode) print(r.stderr) print(r.stdout) def main_serial_run(): env = os.environ newpath = r'D:\Earthquake\myStudy\OpenSees3.3.0\bin;'+env['PATH'] env['PATH'] = newpath start = time.time() runs = ['Opensees.exe push1.tcl', 'Opensees.exe push2.tcl', 'Opensees.exe push3.tcl', 'Opensees.exe push4.tcl', 'Opensees.exe push5.tcl', 'Opensees.exe push6.tcl', 'Opensees.exe push7.tcl', 'Opensees.exe push8.tcl'] for i, single_run in enumerate(runs): r = subprocess.run(single_run, shell=True, capture_output=True, text=True) if r.returncode != 0: print('--Error at ' + p.result().args) end = time.time() print("Serial 처리 수행 시각", end-start, 's') def main_parallel_run(): env = os.environ newpath = r'D:\Earthquake\myStudy\OpenSees3.3.0\bin;'+env['PATH'] env['PATH'] = newpath start = time.time() executor = concurrent.futures.ProcessPoolExecutor(max_workers=10) runs = ['Opensees.exe push1.tcl', 'Opensees.exe push2.tcl', 'Opensees.exe push3.tcl', 'Opensees.exe push4.tcl', 'Opensees.exe push5.tcl', 'Opensees.exe push6.tcl', 'Opensees.exe push7.tcl', 'Opensees.exe push8.tcl'] procs = [] for i, single_run in enumerate(runs): procs.append(executor.submit(subprocess.run, single_run , shell=True, capture_output=True, text=True)) # 모든 프로세스 실행이 끝날 때까지 기다린다. # concurrent.futures.wait(procs) # 모든 프로세스 실행이 끝날 때까지 기다리고, 종료된 순서대로 p를 리턴한다. # p.result()가 CompletedProcess 객체이므로 여러 가지를 조회할 수 있다. for p in concurrent.futures.as_completed(procs): print(p.result().args + '... compoleted') if p.result().returncode != 0: print('--Error at ' + p.result().args) end = time.time() print("병렬처리 수행 시각", end-start, 's') if __name__ == '__main__': print('-------single run---') main_single_run(); print('-------serial run---') main_serial_run() print('-------parallel run---') main_parallel_run() 참고 : 점프 투 파이썬 - 리브러리 예제 편 - 12-03 concurent.futures 2.7.4 시간 다루기 Python에서 시간을 다루는 모듈은 time, datetime , locale, calendar 등이 있다. 이중 가장 기본이 되는 모듈이 time이다. 다음은 time 모듈의 가장 기본 함수 2개를 설명한 것이다. sec=time.time() : 현재의 시각을 실수로 리턴. 엄밀하게는 에포크(epoch, 시간의 기준점, 1970년 1월 1일 0시 0분 0초)로부터 현재까지 경과된 시각이며, 초 단위이다. 실수로 리턴하는 하는 초 이하를 나타내기 위해서이다. time.sleep(t) : 주어진 t 초 동안 멈춘다. time.time() 호출로 리턴된 수는 epoch로부터의 시간이므로 사람이 이해하기 힘들다. 이를 변환하는 함수로 time.gmtime(t)과 time.localtime(t)를 제공한다. 전자는 UTC(예전에 그리니치 표준시로 불렸던)와 지역 시간으로 변경하는데, time.struct_time 클래스로 리턴해 준다. >>> import time >>> t = time.time() >>> t 1554030353.9675264 >>> time_utc = time.gmtime(t) >>> time_utc time.struct_time(tm_year=2019, tm_mon=3, tm_mday=31, tm_hour=11, tm_min=6, tm_sec=21, tm_wday=6, tm_yday=90, tm_isdst=0) >>> time_local = time.localtime(t) >>> time_local time.struct_time(tm_year=2019, tm_mon=3, tm_mday=31, tm_hour=20, tm_min=6, tm_sec=43, tm_wday=6, tm_yday=90, tm_isdst=0) 만약 time.gmtime() 또는 time.localtime()와 같이 인자가 None 이면, 현재 시간을 리턴한다. struct_time의 멤버는.` 연산을 통해 액세스 할 수 있다. >>> time_local.tm_year 2019 struct_time 클래스를 문자열로 변환하는 함수를 time.asctime(time)이다. >>> time.asctime(time_utc) 'Sun Mar 31 11:06:21 2019' >>> time.asctime(time_local) 'Sun Mar 31 20:06:43 2019' time.ctime([secs])는 asctime(localtime(secs))를 호출하는 것과 같다. secs가 None 이면 현재를 의미한다. >>> time.ctime() 'Sun Mar 31 20:23:44 2019' >>> time.ctime(2400.) 'Thu Jan 1 09:40:00 1970' 단일 실수인 시각은 struct_time으로 변환하는 함수가 time.localtime(sec)와 time.gmtime(sec)인데 그 반대의 함수가 존재한다. time.mktime(t)은 time.localtime(sec)의 역함수이고, calendar 모듈의 calendar.timegm(t)는 time.gmtime(sec)의 역함수이다. 문자열로 표시된 시간 처리 실험을 수행하여 센서에서 측정된 데이터는 문자열 형태의 시간 값이 동시에 저장되게 된다. 이를 struct_time으로 변환하려면 time.strptime(str, format)를 이용한다. 이후 sec으로 변환하는 등의 다양한 작업이 가능하다. >>> import time >>> str_time = '2016-04-25 13:03:17' >>> t_in_time = time.strptime(str_time,'%Y-%m-%d %H:%M:%S') >>> t_in_time time.struct_time(tm_year=2016, tm_mon=4, tm_mday=25, tm_hour=13, tm_min=3, tm_sec=17, tm_wday=0, tm_yday=116, tm_isdst=-1) >>> t_in_secs = time.mktime(t_in_time) >>> t_in_secs 1461556997.0 다음이 위 코드를 응용하여 여러 시간을 처리한 예이다. import time str_times = ['2016-04-25 13:03:17', '2016-04-25 13:03:18', '2016-04-25 13:03:19'] t_floats = [] for str_time in str_times: date = time.strptime(str_time,'%Y-%m-%d %H:%M:%S') t_floats.append(time.mktime(date)) 작업에 소요되는 시간을 측정할 때 앞서에서 소개한 time.time()은 시계에서 측정되는 시간 정도로 이해할 수 있다. 이를 어떤 작업에 걸리 시간을 정밀하게 측정하는 데 사용하기는 힘들다. 이를 위해서는 time.perf_counter() 또는 time.process_time() 을 사용한다(예전에는 time.clock()를 사용했는데 depreciated 되었다.) 다음을 참고하도록 한다. 5. SciPy : Timing 2.7.5 난수 Python에서는 random 모듈로 난수 생성을 할 수 있다(정확히는 pseudo-random number). 난수 발생 random.random()은 [0,1) 사이의 실수로 난수를 구하며, random.ranint(a, b)는 [a, b] 사이의 정수로 난수를 구한다. >>> import random >>> random.random() 0.0705821259174515 >>> random.random() 0.9647091416741986 >>> random.randint(0,10) >>> random.randint(0,10) random.randint(a, b)와 비슷한 합수로 random.randrange(a, b)가 있다. 이 함수는 [a, b) 사이이 정수를 난수로 발생시킨다. random.uniform(a, b)는 random.random()을 이용해 구현한 함수로 [a, b] 사이에 실수형 난수를 발생시킨다( a+(b-a)*random.random()으로 계산). 끝 값 b는 라운딩에 의해 포함될 수도 아닐 수도 있다. random.random()과 random.uniform(a, b)은 uniform distribution에 따르는 난수발생이며, 이외에도 random.triagular(low, high, mode), random.betavariate(alpha, beta), random.expovariate(lambd) 등 다양한 분포에 따른 난수 생성이 가능하다. 편의 함수 random 모듈을 이용한 편의 함수로 random.choice(seq), shuffle(seq) random.sample(seq, k) 등이 있다. 모두 list나 tuple 등 시퀀스를 대상으로 임의로 선택하거나, 뒤 석거나(in-place 연산에 주의), 샘플링(k는 샘플링할 시퀀스의 크기) 한다. >>> actors = ['James', 'Jane', 'Bruce'] >>> random.choice(actors) 'Jane' >>> random.shuffle(actors) >>> actors ['Jane', 'James', 'Bruce'] >>> random.sample(actors, 2) ['James', 'Bruce'] 특히 random.shuffle(seq)는 리턴 값이 없고, 입력 시퀀스를 직접 바꾸는 in-place 연산임에 주의한다. 시드 경우에 따라서(보통 디버깅 등을 위해 ) 동일한 순서로 난수를 발생시켜야 할 경우가 있다. 난수 발생을 위해서는 적절한 시드(seed)를 난수발생기에 주어야 한다. 만약 시드가 같다면 동일한 난수를 발생시키게 된다. random.seed(a=None)을 통해 시드를 설정할 수 있다. 다음은 시드를 100, 50 등으로 변경하며 난수를 발생시킨 예이다. 시드가 100으로 같으면 동일한 값이 난수로 발생됨을 알 수 있다(random.random()은 현재의 시드에 근거에 다음 난수를 발생시키는 함수) >>> import random >>> random.seed(100) >>> random.random() 0.1456692551041303 >>> random.random() 0.45492700451402135 >>> random.seed(50) >>> random.random() 0.4975365687586023 >>> random.random() 0.2661737230725406 >>> random.seed(100) >>> random.random() 0.1456692551041303 >>> random.random() 0.45492700451402135 C/C++에서는 시드를 항상 줘야 했는데... C/C++에서는 다음과 같이 항상 시드를 먼저 설정하고 이후에 난수를 발생시키는 방식으로 사용한다. #include <cstdlib> #include <iostream> #include <ctime> int main() { std::srand(std::time(0)); //use current time as seed for random generator int random_variable = std::rand(); std::cout << "Random value on [0 " << RAND_MAX << "]: " << random_variable << '\n'; } 만약 C/C++ 코드에서 srand(seed)를 통해 시드를 주지 않으며 항상 rand()는 srand(1)인 것처럼 계산하게 된다. 따라서 이를 방지하기 위해 일반적으로 위 코드처럼 현재의 시간을 구해 시드를 주게 된다. Python의 random 모듈에서는 random.seed(a=None)로 시드를 설정할 수 있다. 이때 인자 없이 호출하면(a=None), 현재의 시간이 시드로 설정된다. 또한 random 모듈은 임포트 될 때 그 시간으로 시드가 설정되게 된다. 따라서 C/C++에서와 같이 특별한 경우가 아니라면 random.seed()를 별도로 호출할 필요가 없다. 3. NumPy NumPy는 과학 컴퓨팅을 위한 기본 패키지이다. 다차원 배열 객체, 이로부터 유도한 마스크 된 배열 및 행렬 등과 같은 객체, 논리, 배열 형태 조작, 정렬, 선택, I/O를 비롯한 배열에 대한 빠른 작업을 위한 다양한 루틴을 제공한다. 이외에도 이산 푸리에 변환, 기본 선형 대수학, 기본 통계 연산, 무작위 시뮬레이션 등등 다양한 기능을 가지고 있다. 3.1 ndarray 개념과 생성 NumPy와 패키지의 핵심은 ndarray 객체이다. ndarray는 fixed-size homogeneous multidimensional array 정도로 이해할 수 있으며, 기본적으로 vectorization과 broadcasting을 지원한다. Python에서 제공하는 list, tuple 등의 시퀀스 자료형은 서로 다른 데이터 타입을 저장할 수 있고(heterogeneous sequence), 크기가 자동으로 커질 수 있다. 반면에 ndarray는 성능 향상을 위해 같은 데이터 타입만을 요소로 가질 수 있고, 크기 역시 고정되어 있다. 만약 크기를 변경하면 새로 메모리에 할당되고 이전 값은 삭제된다. ndarray는 list나 tuple 같은 시퀀스 자료형으로부터 생성한다. >>> import numpy as np >>> x = np.array((0.1,0.2,0.3)) # np.array([0.1,0.2,0.3])도 가능 >>> x array([0.1, 0.2, 0.3]) >>> x.shape (3, ) >>> x.dtype dtype('float64') >>> y = np.array(((1,2,3),(4,5,6))) # [(1,2,3),(4,5,6)],[[1,2,3],[4,5,6]] 등도 가능 >>> y array([[1, 2, 3], [4, 5, 6]]) >>> y.dtype dtype('int32') >>> y.shape (2, 3) x는 float64를 요소 타입으로 갖는 크기 3의 1차원 배열이다. y는 int32를 요소 타입으로 하는 (2,3) 크기의 2차원 배열이다. 요소 타입을 dtype 멤버에서 확인할 수 있으며, 차원은 shape에서 확인할 수 있다. 1차원 배열의 shape은 (m,) 형태이고, 2차원 배열은 (m, n) 형태이다. 3차원은 (p, q, r) 등과 같다. 생성 시 입력된 값을 통해 dtype을 추정하는데, 강제로 지정하는 것은 다음과 같다. z = np.array([1,2,3],dtype='float64') ndarray의 중요 속성을 정리하면 다음과 같다. shape : 배열의 형태 dtype : 요소의 데이터 타입, int32, float32 등등 ndim : 차원수. x.ndim = 1, y.ndim=2 등이며 len(x.shape) 와 동일 size : 요소의 개수. shape의 모든 값의 곱. x.size = 3, y.size=6 등 itemsize : 요소 데이터 타입의 크기(byte 단위), x.itemsize=8 등 data : 실제 데이터. 직접 사용자가 접근할 필요는 없음 초기화 관련 편의 함수 초기화와 관련된 몇몇 편의 함수를 제공한다. zeros(..)는 모두 0으로, ones(...)는 모든 성분을 1로, empty(...)는 값을 초기화하지 않고(메모리 상태에 따라 다른 값이 들어감) 생성한다. 인자로 생성할 배열의 차원을 list나 tuple로 지정한다. dtype은 디폴트가 float64이고, 변경을 원하면 지정해야 한다. >>> Y = np.zeros((3,3)) >>> Y array([[ 0., 0., 0.], [ 0., 0., 0.], [ 0., 0., 0.]]) >>> Y = np.ones((3,3),dtype='int32') >>> Z = np.empty((3,3)) 미리 크기를 지정하지 않고 순차적으로 만들어야 할 경우가 있다. 이때는 크기 0인 배열을 생성하고 append()를 수행하면 된다. import numpy as np A = np.array([]) for i in range(3): A = np.append(A,[1,2,3]) >>> A array([ 1., 2., 3., 1., 2., 3., 1., 2., 3.]) 단순한 시퀀스는 range() 함수의 실수 버전인 arange(from, to, step)이나 linspace(from, to, npoints)를 사용하면 편리하다. 또한 단위행렬을 위한 eye(n) 함수를 제공한다. >>> np.arange(1,2,0.1) array([ 1. , 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9]) >>> np.arange(10) # start, step 생략 가능. 정수로 생성 array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> np.arange(10.) # start, step 생략 가능. 실수로 생성 array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.]) >>> np.linspace(0.,20.,11) array([ 0., 2., 4., ..., 16., 18., 20.]) >>> np.eye(3) array([[ 1., 0., 0.], [ 0., 1., 0.], [ 0., 0., 1.]]) shape과 dtype 변경 ndarray는 고정된 크기를 유지하면서 shape을 변경할 수 있다. 예를 들어 크기 9의 1차원 배열을 3*3 2차원 배열로 바꿀 수 있다. 이때 사용하는 함수는 reshape()인데 함수 또는 메쏘드 형태로 제공한다. >>> X = np.arange(0,9,1.) >>> X array([ 0., 1., 2., 3., 4., 5., 6., 7., 8.]) >>> Y = np.reshape(X,(3,3)) # 또는 Y=X.reshape((3,3)) >>> Y array([[ 0., 1., 2.], [ 3., 4., 5.], [ 6., 7., 8.]]) 만약 자기 자신을 대상을 변경하면 shape 속성을 강제로 변경하면 된다. >>> X.shape = (3,3) >>> X array([[ 0., 1., 2.], [ 3., 4., 5.], [ 6., 7., 8.]]) astype() 메쏘드를 사용하면 배열에서 dtype을 바꿀 수 있다. >>> a = np.arange(3); >>> a.astype(int) # a.astype('int34') 와 동일 >>> a.astype('int34') >>> a.astype('int64') >>> a.astype(float) # a.astype('float64') >>> a.astype('float32') >>> a.astype('float64') 인자로는 문자열로 정확한 형과 크기를 지정하거나 int, float 등과 같이 대표 상수가 들어갈 수 있다. 위 예에서 32 bit 정수와 64bit 실수형이 디폴트임을 확인할 수 있다. 3.2 인덱싱과 합치기 인덱싱 ndarray에서 인덱싱하는 것은 A[2], A[2,3] 등과 같은 [] 연산자를 사용한다. A[1:3,1:2] 등과 같이 :를 이용한 범위 지정을 통해 부분 배열을 얻어낼 수 있다. A[-1] 등과 같이 음의 정수를 사용하면 뒤에서부터 인덱싱 된다. >>> a = np.array([1.2, -1.3,2.2,5.3,3.7]) >>> a array([ 1.2, -1.3, 2.2, 5.3, 3.7]) >>> a[0] 1.2 >>> a[0:3] array([ 1.2, -1.3, 2.2]) >>> a[-1] 3.7000000000000002 >>> a[-2] 5.2999999999999998 >>> a[0:-1] array([ 1.2, -1.3, 2.2, 5.3]) 인덱스 배열 정수로 이루어진 index array를 [] 기호에 넣어 인덱스로 활용할 수 있다. >>> a = np.array([1.2, -1.3,2.2,5.3,3.7]) >>> idx = [0,3] >>> a[idx] array([ 1.2, 5.3]) 불린 배열 True와 False로 구성된 boolean array 역시 인덱스 배열처럼 사용 가능하다. 아래 코드에서 x > 2와 같이 ndarray에 조건식을 부과하면 boolean array가 계산된다. 이 boolean array를 인덱스로 사용할 수 있다. >>> x = np.array([1.2, -1.3, 0., 2.2, 0., 5.3, 3.7]) >>> x > 2 array([False, False, False, True, False, True, True]) >>> idx = x>2 >>> idx array([False, False, False, True, False, True, True]) >>> x[idx] array([2.2, 5.3, 3.7]) 위 예제에서의 성질을 이용하면 어떤 조건을 만족하는 부분 배열을 쉽게 얻을 수 있다. >>> x = np.array([1.2, -1.3, 0., 2.2, 0., 5.3, 3.7]) >>> x[x > 2] array([2.2, 5.3, 3.7]) np.nonzero(x)는 배열 x의 원소가 0이 아닌 인덱스를 배열 형태로 리턴해주는 합수이다. >>> x = np.array([1.2, -1.3, 0., 2.2, 0., 5.3, 3.7]) >>> np.nonzero(x) array([0, 1, 3, 5, 6], dtype=int64),) np.nonzero(x)에서 x가 불린 배열인 경우 True인 인덱스를 배열로 리턴해주기 때문에 다음과 같은 연산이 가능하다. >>> x = np.array([1.2, -1.3, 0., 2.2, 0., 5.3, 3.7]) >>> np.nonzero(x>2) (array([3, 5, 6], dtype=int64),) np.where(x>2)도 사용 가능하지만 np.nonzero(x>2)와 동일하다. 합치기 concatenate((A, B,...),axis=0), hstack((A, B,...)), vstack((A, B,...))를 통해 배열을 합칠 수 있다. >>> a = np.array([[1, 2], [3, 4]]) >>> b = np.array([[5, 6]]) >>> np.concatenate((a, b), axis=0) array([[1, 2], [3, 4], [5, 6]]) >>> np.concatenate((a, b.T), axis=1) array([[1, 2, 5], [3, 4, 6]]) concatenate((A, B,...),axis=0)는 axis 방향으로 합치라는 의미이다(axis=0은 row, aixs=2는 column 방향 등) 위에서 b가 (1,2) 2-d 배열이다. 만약 b가 (2, )의 1-d 배열이면 에러가 발생한다. 만약 2차원 행렬을 대상으로 한다면 hstack((A, B,...))과 vstack((A, B,...)) 이보다 편리하다. 이 들 함수는 (n,) 형태의 1D 배열을 (1, n) 배열로 취급한다. np.append(obj, val)을 사용해도 된다. >>> a = np.array([1,2,3]) >>> b = np.array([4,5,6]) >>> np.vstack((a, b)) array([[1, 2, 3], [4, 5, 6]]) >>> np.hstack((a, b)) array([1, 2, 3, 4, 5, 6]) >>> c = np.append(a, b) array([1, 2, 3, 4, 5, 6]) 3.3 연산 요소 단위 연산 ndarray 객체에 대한 연산은 기본적으로 elementwise로 진행된다. >>> a = np.array([1,2,3,4]) >>> b = np.array([4,5,6,7]) >>> a+b array([ 5, 7, 9, 11]) >>> a*b array([ 4, 10, 18, 28]) >>> a**2 array([ 1, 4, 9, 16]) >>> a+2 # 상수 2는 같은 크기의 배열로 인식 array([3, 4, 5, 6]) >>> 10*np.sin(a) # NumPy의 universal 함수 sin() 적용 array([ 8.41470985, 9.09297427, 1.41120008, -7.56802495]) >>> a<3 array([ True, True, False, False], dtype=bool) >>> a *= b # a = a*b와 동일 >>> a array([ 4, 10, 18, 28]) 위와 같이 배열의 개별 요소가 아닌 배열에 대해 연산을 적용하는 것을 vectorization이라 하며 크기가 다를 경우에도 작동하도록 한 것(예를 들어 a=a+3)을 broadcasting이라고 한다. 배열의 요소를 인덱싱하는 것은 [] 기호를 사용할 수 있으며 :를 이용해 범위를 지정하는 것이 가능하다. >>> A[1,2] >>> A[1:3, :] # 또는 A[1:3, ] Universal 함수 NumPy에서는 sin(), cos() 다양한 수학 함수를 제공한다. 스칼라 값을 입력으로 하는 math 패키지와 달리 배열에 대해 elementwise로 적용된다. >>> x = np.arange(0.,2*np.pi, 0.1) >>> y = np.sin(x) >>> y array([ 0. , 0.09983342, 0.19866933, ..., -0.2794155 , -0.1821625 , -0.0830894 ]) 행렬 연산 행렬 연산 중 +, - 연산 및 스칼라와 행렬의 곱셈은 일반 수학식과 동일하게 처리할 수 있다. 이는 행렬 요소에 대해 element-wise 연산을 수행하기 때문이다. D = A-2*B+C 행렬의 곱셈은 dot(), matmul(), @ 연산자 등으로 수행한다. 추천 방법은 @을 사용하는 것이다. # -*- coding: utf-8 -*- """ Created on Wed Aug 7 10:58:34 2019 @author: 조정래 """ import numpy as np A = np.arange(9).reshape(3,3) # (3,3) B = np.arange(11,11+9).reshape(3,3) # (3,3) x = np.arange(3) # (3, ) y = np.arange(3).reshape(3,1) # (3,1) z = np.arange(3).reshape(1,3) # (1,3) # C = A*B ... same results C1 = np.dot(A, B) C2 = np.matmul(A, B) C3 = A@B # A*x ... 2d*1d ... same results Ax1 = np.dot(A, x) # array([ 5, 14, 23]) Ax2 = np.matmul(A, x) Ax3 = A@x # A*y ... 2d*(2d, but 1d vector) ... same results Ay1 = np.dot(A, x) # array([[ 5],[14],[23]]) Ay2 = np.matmul(A, x) Ay3 = A@y # A*z ... 2d*(2d, but 1d vector) ... all dimension error Az1 = np.dot(A, z) # array([[ 5],[14],[23]]) Az2 = np.matmul(A, z) Az3 = A@z # left make (row vector), right make (column vector) xy = x@y # array([5]) 가독성 측면에서 @을 사용하는 것이 좋다. 다음 규칙을 기억하도록 한다. @의 좌측에 오는 1차원 배열은 row vector로 취급( (3, )인 경우 (1,3)으로 취급) @의 좌측에 오는 1차원 배열은 column vector로 취급( (3, )인 경우 (3,1)으로 취급) 전치 행렬은 A.T와 같은 속성을 이용하거나 transpose() 함수를 사용한다. >>> A.T array([[0, 3, 6], [1, 4, 7], [2, 5, 8]]) >>> np.transpose(A) array([[0, 3, 6], [1, 4, 7], [2, 5, 8]]) 주요 선형대수함수로는 linalg.eig(A), linalg.norm(x), linalg.cond(x), linalg.det(a), linalg.solve(A, b), linalg.inv(a) 등이 있다. >>> A = np.array([[1,2, -1],[3,7,0],[0,4, -1]]) >>> [D, V] = np.linalg.eig(A) # D는 eigenvalues, V는 vector >>> D array([ 7.69041576, 1. , -1.69041576]) >>> V array([[-0.20463281, 0.66666667, 0.44197763], [-0.88917212, -0.33333333, -0.15257416], [-0.40926563, -0.66666667, 0.88395526]]) 정렬과 탐색 배열에서 찾는 것은 최솟값 또는 최댓값은 np.amin(x), np.amax(x)를 이용하면 된다. 만약 최솟값 또는 최댓값이 있는 위치를 구하려면 np.argmin(x), np.argmax(x)를 사용한다. 정렬은 np.sort(x)를, 정렬했을 때의 인덱스를 구하려면 np.argsort(x)를 사용하면 된다. import numpy as np >>> x = np.array([9.1,8.2,2.3,3,3,7.6,5.2]) >>> np.amin(x) 2.2999999999999998 >>> np.argmin(x) >>> np.sort(x) array([ 2.3, 3. , 3. , 5.2, 7.6, 8.2, 9.1]) >>> np.argsort(x) array([2, 3, 4, 6, 5, 1, 0], dtype=int64) 만약 두 번째로 큰 값의 위치를 구한다면 다음과 같다. >>> imax2 = np.argsort(x)[-2] 이진 탐색 이미 정렬되어 있는 배열을 대상으로 탐색할 때는 이진 탐색(binary search)를 사용하면 계산 효율을 대폭 높일 수 있다. Numpy는 np.searchsorted(array, value, side='left')를 통해 이진 탐색을 수행할 수 있다. side 인자로는 'left'와 'right'가 가능하다. side='left'는 array[i-1] < value <= array[i]이고, side='right'는 array[i-1] <= value < array[i]이다. 영역을 벗어나는 경우도 있기 때문에 다음 그림을 참조하는 것이 이해하기 쉽다. import numpy as np x = np.array([0.,13.,26.,30.]) print(x) print(-1, ':',np.searchsorted(x,-1.),',',np.searchsorted(x,-1.,side='right')) print( 0, ':',np.searchsorted(x, 0.),',',np.searchsorted(x, 0.,side='right')) print( 5, ':',np.searchsorted(x, 5.),',',np.searchsorted(x, 5.,side='right')) print(13, ':',np.searchsorted(x, 13.),',',np.searchsorted(x, 13.,side='right')) print(15, ':',np.searchsorted(x,15.),',',np.searchsorted(x, 15.,side='right')) print(30, ':',np.searchsorted(x, 30.),',',np.searchsorted(x, 30.,side='right')) print(35, ':',np.searchsorted(x, 35.),',',np.searchsorted(x, 35.,side='right')) 결괏값은 다음과 같다. [ 0. 13. 26. 30.] -1 : 0 , 0 0 : 0 , 1 5 : 1 , 1 13 : 1 , 2 15 : 2 , 2 30 : 3 , 4 35 : 4 , 4 np.searchsorted(a, v, side='left')는 C++ STL의 lower_bound(), np.searchsorted(a, v, side='right')는 upper_bound()와 거동이 동일하다. #include <vector> #include <algorithm> template<typename T> size_t searchsorted_left(std::vector<T> x, const T val) { return std::lower_bound(x.begin(), x.end(), val) - x.begin(); } template<typename T> size_t searchsorted_right(std::vector<T> x, const T val) { return std::upper_bound(x.begin(), x.end(), val) - x.begin(); } int main() { std::vector<double> xx = { 0, 13, 26, 30 }; //, 34, 47, 60}; std::cout << "value : lowerbound, upperbound\n"; std::cout << "-1.: " << searchsorted_left(xx, -1.) << " " << searchsorted_right(xx, -1.) << "\n"; std::cout << " 0.: " << searchsorted_left(xx, 0.) << " " << searchsorted_right(xx, 0.) << "\n"; std::cout << " 5.: " << searchsorted_left(xx, 5.) << " " << searchsorted_right(xx, 5.) << "\n"; std::cout << "13.: " << searchsorted_left(xx, 13.) << " " << searchsorted_right(xx, 13.) << "\n"; std::cout << "15.: " << searchsorted_left(xx, 15.) << " " << searchsorted_right(xx, 15.) << "\n"; std::cout << "30.: " << searchsorted_left(xx, 30.) << " " << searchsorted_right(xx, 30.) << "\n"; std::cout << "35.: " << searchsorted_left(xx, 35.) << " " << searchsorted_right(xx, 35.) << "\n"; return 1; } 다음 코드는 이미 정렬되어 있는 배열을 대상으로 추가하는 코드이다. a = np.array([1,1,2,4,7,7,11,13,13,13,15,20,25,26,27,30,45,70]) b = np.array([5,7,9,45]) ii = np.searchsorted(a, b) a = np.insert(a, ii, b) 3.4 브로드캐스팅 브로드캐스팅 NumPy에서 차원이 맞지 않은 객체끼리 연산되도록 하는 것을 broadcasting이라 한다. 대표적인 예가 다음과 같이 2차원 배열에 스칼라나 1차원 배열을 연산하는 것이다. 다음과 같이 (3,3)의 2차원 배열 A, (3, )인 1차원 배열 x, (1,3)과 (3,1)인 2차원 배열 y, z가 있다고 가정하기로 한다. >>> import numpy as np >>> A = np.arange(9.).reshape(3,3) # 2d array : (3,3) >>> x = np.array([1.,0,0]) # 1d array : (3, ) >>> y = x.reshape(1,3) # 2d array : (1,3) >>> z = x.reshape(3,1) # 2d array : (3,1) >>> A array([[ 0., 1., 2.], [ 3., 4., 5.], [ 6., 7., 8.]]) >>> x array([ 1., 0., 0.]) >>> y array([[ 1., 0., 0.]]) >>> z array([[ 1.], [ 0.], [ 0.]]) 2차원 배열과 스칼라의 연산은 다음과 같다. 내부적으로 스칼라 1의 차원을 (3,3)으로 확장하고 그 성분의 값은 스칼라 값을 그대로 쓴다. >>> A+1 # (3,3) + scalar ==> (3,3) + scalar*I array([[ 1., 2., 3.], [ 4., 5., 6.], [ 7., 8., 9.]]) 2차원 배열과 1차원 배열의 연산에서는 1차원 배열 (3, )을 2차원 배열 (3,3)으로 확장하게 된다. # (3,3) + (3, ) ==> (3,3) # x = [1,0,0] --> expand with (3,3) 1 0 0 # 1 0 0 # 1 0 0 >>> A+x array([[ 1., 1., 2.], [ 4., 4., 5.], [ 7., 7., 8.]]) 차원이 (1,3)인 배열을 적용할 때는 위와 통일하다. # (3,3) + (1,3) ==> (3,3) # y = [[1,0,0]] --> expand with (3,3) 1 0 0 # 1 0 0 # 1 0 0 >>> A+y array([[ 1., 1., 2.], [ 4., 4., 5.], [ 7., 7., 8.]]) 차원이 (3,1)일 경우에는 다음과 같이 확장된다. # (3,3) + (3,1) # z = 1 --> expand with (3,3) 1 1 1 # 0 0 0 0 # 0 0 0 0 >>> A+z array([[ 1., 2., 3.], [ 3., 4., 5.], [ 6., 7., 8.]]) 마지막으로 (1,3)와 (3,1) 배열이 연산 결과는 다음과 같이 (3,3) 배열이 된다. # (1,3) + (3,1) --> each dimensions are expanded # y = [1,0,0] --> (3,3) 1 0 0 z = 1 1 1 1 # 1 0 0 0 0 0 0 # 1 0 0 0 0 0 0 >>> y+z array([[ 2., 1., 1.], [ 1., 0., 0.], [ 1., 0., 0.]]) 행렬 연산 함수 호출 시 주의사항 matmul(A, b), dot(A, B), solve(A, b) 등의 함수로 선형대수를 수행할 때 배열의 차원과 관련해서 주의해야 할 점이 있다. 다음과 같은 배열을 선언하였다고 가정하기로 한다. >>> A = np.arange(9.).reshape(3,3) # (3,3) 2d array >>> x = np.array([2,0,1]) # (3, ) 1d array >>> y = x.reshape(1,3) # (1,3) 2d array >>> z = x.reshape(3,1) # (3,1) 2d array >>> A array([[ 0., 1., 2.], [ 3., 4., 5.], [ 6., 7., 8.]]) >>> x array([2, 0, 1]) >>> y array([[2, 0, 1]]) >>> z array([[2], [0], [1]]) Ay 연산이나 Az 연산은 예상한 대로 오류를 출력하거나 정상적이로 결과가 출력된다. >>> np.matmul(A, y) # (3,3)*(1,3) -> Dimension Error >>> np.matmul(A, z) # (3,3)*(3,1) -> (3,1) array([[ 2.], [ 11.], [ 20.]]) 문제는 Ax와 같이 2차원 배열과 1차원 배열에 연산을 적용할 때이다. >>> np.matmul(A, x) # (3,3)*(3, ) -> (3, ) array([ 2., 11., 20.]) 위 결과에서 Ax와 같은 연산은 x를 (3,1) 배열로 취급한 연산 결과와 동일하지만 출력될 때는 다시 (3, ) 행태로 변환해 줌을 알 수 있다. 이는 앞서의 broadcasting과 비교할 때 상당히 혼돈될 수 있으므로 주의해야 한다. 3.5 복사 Python에서 list 등의 컨테이너는 shallow copy가 된다. 마찬가지로 NumPy의 ndarray와 대입 연산자 =를 사용하면 shallow copy가 되며, 실제 복사(deep copy) 하려면 object.copy()를 사용해야 한다. >>> import numpy as np >>> a = [1,2,3] >>> x = np.array(a) >>> y = x # shallow copy >>> y[0]=10 >>> a [1, 2, 3] >>> x array([10, 2, 3]) >>> y array([10, 2, 3]) >>> y is x True >>> z = x.copy() # deep copy >>> z is x False 위에서 x와 y를 같은 데이터를 가리키고 있기 때문에 y를 변경하면 x까지 변경하게 된다. a는 값이 변경되지 않는데 그 이유는 x를 생성할 때 그 값에 복사가 이루어지기 때문이다. 부분 행렬 역시 shallow copy 되는 점에 주의해야 한다(list의 슬라이싱은 deep copy됨!!!) >>> import numpy as np >>> x = np.array([1,2,3]) >>> y = x[0:2] >>> y[0] = 10 >>> y array([10, 2]) >>> x array([10, 2, 3]) 3.6 데이터 읽고 쓰기 텍스트 파일로 읽고 쓰기 np.loadtxt()와 np.savetxt()를 사용하면 텍스트 파일로 읽고 쓸 수 있다. 빌트인 패키지인 csv와 비교할 때 헤더를 읽지 못하지만 콤마뿐만 아니라 공백으로 분리된 구조화된 데이터를 읽고 쓸 때 편리하다. 다음은 중요 인자만 포함된 두 함수의 원형이다. 두 함수는 디폴트로 스페이스를 구분자로 사용한다. 만약 콤마를 사용하려면 delimiter=','로 지정해야 한다. np.loadtxt()가 skiprows(처음 몇 개의 열을 무시할 건지)와 comment 문자를 지정하는 부분만 추가되어 있다고 생각하면 된다. np.savetxt(fname, X, delimiter=' ', ...) X= np.loadtxt(fname, delimiter=' ', skiprows=0, comments='#', ...) 다음은 2차원 배열에 대한 간단한 코드 예이다. import numpy as np x = np.arange(9).reshape(3,3) np.savetxt('3by3.txt',x) y = np.loadtxt('3by3.txt') 저장된 파일인 3by3.txt은 다음과 같다. 0.000000000000000000e+00 1.000000000000000000e+00 2.000000000000000000e+00 3.000000000000000000e+00 4.000000000000000000e+00 5.000000000000000000e+00 6.000000000000000000e+00 7.000000000000000000e+00 8.000000000000000000e+00 사용 시 주의할 점은 1차원 배열(즉, 벡터)은 n*1 형태로 저장된다는 점과 파일에서 n*1이나 1*n은 모두 1차원 벡터로 읽힌다는 점이다. import numpy as np x1 = np.array([1.1,2.2,3.1]) np.savetxt('x1.txt', x1) x2 = np.array([1.1,2.2,3.1]).reshape(1,3) np.savetxt('x2.txt', x2) x3 = np.array([1.1,2.2,3.1]).reshape(3,1) np.savetxt('x3.txt', x3) y1 = np.loadtxt('x1.txt') # array([1.1, 2.2, 3.1]) y2 = np.loadtxt('x1.txt') # array([1.1, 2.2, 3.1]) y3 = np.loadtxt('x1.txt') # array([1.1, 2.2, 3.1]) x1.txt 1.100000000000000089e+00 2.200000000000000178e+00 3.100000000000000089e+00 x2.txt 1.100000000000000089e+00 2.200000000000000178e+00 3.100000000000000089e+00 x3.txt 1.100000000000000089e+00 2.200000000000000178e+00 3.100000000000000089e+00 ndarray 파일 저장과 복원 ndarray.tofile()과 np.fromfile()로 Matlab에서 행렬 데이터를 저장하고 로드하는 것과 같은 효과를 낼 수 있다. ... A에 대한 작업 A.tofile(‘backup’) # 저장 ... Anew = np.fromfile(‘backup’) # 저장했던 값을 A_new로 loading Binary 파일 NumPy에서 지원하는 바이너리 파일을. npy, .npz라고 한다. .npy는 1개의 ndarray를, .npz는 여러 개의 ndarray를 저장하는 데 사용된다. save(file, arr,...): arr을. npy 포맷으로 file에 씀 savez(file,*args,**kwds): args와 kwgs에 주어진 여러 배열을. npz 포뱃으로 file에 씀. **kwds로 저장할 때 주어진 키워드가 사용되고, args로 저장하는 경우 arr_0, arr_1, 등을 키워드를 사용한 것과 같음. savez_compresseds(file,*args,*kwds): savez(...) 와 동일하나 데이터를 압축함 load(file,...) : 위 세 함수로 저장된 데이터를 읽음 다음은 가속도 센서 데이터를 측정 간격과 계측 스테이션 번호와 함께 저장한 예이다. >>> import numpy as np >>> acc = np.random.random(1024) # 1024 points in [0,1.0) >>> dt = 60.0 >>> station = 3 >>> np.savez('acceleration.npz',acc=acc, dt=dt, station=station) >>> data = np.load('acceleration.npz') >>> data["acc"] array([0.74681048, 0.33561388, 0.0677092 , ..., 0.67783846, 0.01131057, 0.62417015]) >>> data["dt"] array(60.) >>> data["station"] array(3) 3.7 타입과 structured array 데이터 타입 NumPy 배열을 생성할 때는 다음과 같이 dtype을 지정할 수 있다. 만약 지정하지 않으면 정수형은 np.int32, 실수형은 np.float64가 지정된다. >>> x = np.array([1,2,3],dtype=np.int16) >>> xf = np.array([1,2,3],dtype=np.float64) 파이썬에서 리스트 등의 컨테이너를 제외한 기본 자료형은 bool, int, float, str 등이다. 이들은 C/C++와 같은 일반 언어와 달리 모두 객체이기 때문에 단순히 몇 바이트의 크기를<NAME>다 등으로 이야기할 수 없다. 파이썬에서는 정수(int)에 대한 값의 크기 제한 없이, 가능한 메모리 한도까지 확장된다. >>> x = 10000000000000000000000000000000000000000000 >>> x = x + 1 >>> print (x) 10000000000000000000000000000000000000000000 반면에 NumPy에서는 수치로 이루어진 배열인 ndarray를 다루기 때 그 구성요소의 크기가 C/C++처럼 고정되어야 한다. 이러한 이유로 NumPy는 np.int32, np.float64 등과 같은 타입 객체야 np.dtype('int32') 등과 같이 문자열을 인자로 하는 np.dtype 객체를 사용한다. 아래 예에서 np.int32와 np.dtype('int32')가 서로 동일함을 알 수 있다. >>> np.int32 numpy.int32 >>> np.dtype('int32') dtype('int32') >>> np.dtype('int32') == np.int32 True 주의할 점은 np.int는 NumPy의 정수형이 아닌 Python 정수라는 점이다. 따라서 np.int32도 np.int64도 아니다. >>> np.int # 그냥 Python int임 int >>> np.int == np.int32 False >>> np.int == np.int64 False 다음은 주로 사용되는 정의된 NumPy 객체이다. 불린 형 : np.bool_ 정수형 : np.int8, np.int16, np.int32, np.int64 실수형 : np.float32, np.float64 복소수 : np.complex64, np.complex128 np.dtype('str')을 사용하면 바이트 오더(bite order)를 포함한 보다 다양한 타입을 지정할 수 있다. 다음은 예이다. np.dtype('int32') : 32비트 LE 정수, np.int32와 동일 np.dtype('i4') : 4바이트 LE 정수, np.int32와 동일 np.dtype('f8') : 8바이트 LE 실수, np.float64와 동일 np.dtype('>f8') : 8바이트 BE 실수 정수형의 경우 i{byte}, int{bit}, <i{byte}, >i{byte} 형태를 쓸 수 있다. 이때 <는 LE(리틀 엔디안)으미하며 디폴트이다. 마찬가지로 실수형의 경우 f{byte}, float{bit}, <f{byte}, >f{byte} 형태를 쓸 수 있다. 리틀 vs 빅 엔디언 컴퓨터는 데이터를 메모리나 디스크에 저장할 때 바이트 단위로 나누어 저장한다. 저장하는 데이터는 대게 4바이트나 8바이트로 구성되므로, 연속되는 바이트를 어떤 순서로 저장해하는데 이를 바이트 저장 순서(byte order)라고 한다. 여기에는 두 가지가 있다. 빅 엔디언(big endian) : 높은 바이트부터 낮은 바이트로 저장. 예를 들어 0x12345678인 경우 0x12, 0x34, 0x56, 0x78 순서로 저장 리틀 엔디안(little endian) : 낮은 바이트부터 낮은 바이트로 저장. 예를 들어 0x12345678인 경우 0x78, 0x56, , 0x34, 0x12 순서로 저장 인텔 계열 CPU(인텔이나 AMD)는 리틀 엔디안을 사용한다. 다만 네트워크를 통해 데이터를 전송할 때는 빅엔디안을 사용한다. Python은 플랫폼을 따른다. 즉 little endian이다. 다음으로 확인할 수 있다. >>> import sys >>> sys.byteorder little 컴파운드 타입과 structured array NumPy는 C의 구조체(structure)로 이우러진 배열에 해당하는 structured array를 지원한다. 다음과 같이 C에서 구조체의 배열을 사용하는 경우를 생각해 보기로 한다. struct info { char name[10]; int age; float height; }; struct info data[3]; strcpy(data[0].name, "Alice"); data[0].age = 19; data[1].height = 171.; ... 위에 대응하는 작업을 NumPy에서 지원하는 데 이를 structured array라고 한다. Structured array의 개별 구성 요소는 여러 타입을 모은 compound type이라고 하며 (name, type)의 쌍으로 구성한다. >>> import numpy as np >>> dtype = [('name','S10'),('age','<i4'),('height','<f4')] >>> x = np.array([('Alice',19,173.),('Bob',20, '181.')],dtype=dtype) >>> x array([(b'Alice', 19, 173.), (b'Bob', 20, 181.)], dtype=[('name', 'S10'), ('age', '<i4'), ('height', '<f4')]) >>> x['name'] array([b'Alice', b'Bob'], dtype='|S10') >>> x['age'] array([19, 20]) >>> x['height'] array([173., 181.], dtype=float32) >>> x[0] (b'Alice', 19, 173.) 위 코드에서 dtype인 자로 (name, type)의 쌍이 사용된 것을 알 수 있다. name은 인덱싱에 사용되며, type은 np.dtype(str)에서 사용된 str과 동일하게 사용할 수 있다. 주의할 점은 NumPy에서 사용하는 배열의 각 구성요소는 그 크기가 미리 정해져야 하므로 문자열은 S10 등과 같이 그 크기가 미리 정해진다는 것이다(S10은 10바이트 크기의 문자열을 의미). dtype을 정의하는 부분에서 type은 다음과 같은 문자열도 작동한다. dtype = [('name','S10'),('age','int32'),('weight','float64')] # 위 예와 동일 아래의 코드는 여러 개의 리스트로 있는 자료는 structured array로 표현한 예이다. import numpy as np name = ['Alice', 'Bob', 'Doug'] age = [25, 45, 37] height = [173.,181.,165.] dtype = [('name','S10'),('age','<i4'),('height','<f4')] x = np.zeros(3, dtype=dtype) x['name'] = name x['age'] = age x['height'] = height 3.8 기타 nan, inf 활용법 NumPy에서는 nan (not a number)와 inf (infinite)을 별도의 상수로 정의하고 있다. nan을 이용하면 데이터를 처리하는 데 편리할 수 있다. 그림을 그릴 때 nan이 있으면 그 포인트는 그리지 않게 된다. x = [1,2,3,4] y1 = [4, 7,, 8, 9] y2 = [2,3,1, np.nan] plt.plot(x, y1) plt.plot(x, y2) inf는 비교 시 초깃값으로 활용하면 편리하다. maximum = -np.inf for x in data: if x > maximum: maximum = x 4. Matplotlib Matplotlib은 python에서 그래프를 그릴 때 사용하는 패키지이다. Numpy와 더불어 없어서는 안 될 패키지라고 할 수 있다. 4.1 기본 사용법 간단한 2차원 플롯 matplotlib은 2차원 그래픽 패키지이다. Matlab과 같이 커맨드 방식(matplotlib에서는 Pyplot API라고 한다)으로 그래프를 그릴 수 있으며, 커맨드 함수의 이름도 유사도 록 설계되어 있다. 다음은 간단한 예이다. # example 1 import matplotlib.pyplot as plt import numpy as np x = np.linspace(0,1,50) y1 = np.cos(4*np.pi*x) y2 = np.cos(4*np.pi*x)*np.exp(-2*x) plt.plot(x, y1) plt.plot(x, y2) plt.show() plt.plot(x, y)로 이차원 선 그래프를 그릴 수 있다. plt.show()는 화면에 표시하는 기능을 하는데 Jupyter나 IPython을 사용할 때는 자동으로 표시되기 때문에 호출할 필요가 없다. 꾸미기 다음은 보다 보기 좋게 꾸민 것이다. # example 2 import matplotlib.pyplot as plt import numpy as np x = np.linspace(0,1,50) y1 = np.cos(4*np.pi*x) y2 = np.cos(4*np.pi*x)*np.exp(-2*x) plt.plot(x, y1,'r-*', label=r'$sin(4 \pi x)$',lw=1) plt.plot(x, y2,'b--o', label=r'$ e^{-2x} sin(4\pi x) $',lw=1) plt.title(r'$sin(4 \pi x)$ vs. $ e^{-2x} sin(4\pi x)$') plt.xlabel('x') plt.ylabel('y') plt.text(0.5, -1.0, r'This is sample') plt.axis([0,1, -1.5,1.5]) plt.grid(True) plt.legend(loc='upper left') plt.tight_layout() plt.show() plt.plot(x, y,'r-*',label='sin',lw=1)에서 'r-*'은 문자열은 색상, 선타입, 마커 등의 속성을 나타낸다. 'r-*'는 red, solid line, * 마커를 의미한다. label은 레전드에 표시될 내용이고, lw는 line width이다. plt.title(title), plt.xlabel(xlabel), plt.ylabel(ylabel)은 제목, X와 Y 축 제목을 나타낸다. plt.text(x, y, text)로 (x, y) 위치에 text를 출력한다 plt.axis([xmin, xmax, ymin, ymax])는 축의 범위를 지정한다. plt.xlim([xmin, xmax]), plt.ylim([ymin, ymax])을 사용할 수도 있다. plt.grid(True)는 격자를 그리고, plt.legend()는 레전드를 표시한다. plt.tight_layout()은 여백을 조정하는 역할을 한다. latex 수식을 title(), xlabel(), ylabel(), text() 등에 지정할 수 있다. 다만 r’text’ 등과 같은 r을 앞에 기입하여 raw 문자열이어야 한다. Example 1 Example 2 텍스트를 출력하는 plt.text(x, y, text, ...)는 추가 인자를 통해 보다 세밀하게 조정할 수 있다. 두 번째는 text의 정렬 속성을 center, center로, 좌표계는 0~1 사이의 relative coordinate를 사용한 것이다. plt.text(20,30, "test') # 일반 plt.text(0.2,0.3, horizontalalignment='center',verticalalignment='center',transform=plt.gca().transAxes) # transform=ax.transAxes 주로 사용하는 선과 마커 다음은 선의 색상 및 스타일, 마커 등의 옵션이다. Subplot Subplot은 Matlab처럼 plt.subplot(nrow, ncol, inum)을 호출하는 것으로 그릴 수 있다. import matplotlib.pyplot as plt import numpy as np x = np.linspace(0,1,50) y1 = np.cos(4*np.pi*x) y2 = np.cos(4*np.pi*x)*np.exp(-2*x) plt.subplot(2,1,1) plt.plot(x, y1,'r-*',lw=1) plt.grid(True) plt.ylabel(r'$sin(4 \pi x)$') plt.axis([0,1, -1.5,1.5]) plt.subplot(2,1,2) plt.plot(x, y2,'b--o',lw=1) plt.grid(True) plt.xlabel('x') plt.ylabel(r'$ e^{-2x} sin(4\pi x) $') plt.axis([0,1, -1.5,1.5]) plt.tight_layout() plt.show() 주요 함수 요약 커맨드 방식의 함수인 Pyplot API 중 주로 사용하는 함수를 정리하면 다음과 같다. plot() subplot() title() xlabel() ylabel() axis() xlim() ylim() tight_layout() grid() legend() show() figure() text() subplots() xscale(...) : xscale("log")이면 로그 스케일 minorticks_on(), minorticks_off() grid(True, which='both') yscale(...) : 한글 설정 import matplotlib.pyplot as plt # plt.rc('font', family='NanumGothicOTF') # For MacOS plt.rc('font', family='NanumGothic') # For Windows ... 4.2 IPython Python 인터프리터에서 인터랙티브하게 사용하려면 python 콘솔보다는 ipython 콘솔을 사용하는 것이 좋다. ipython의 %matplotlib이라는 magic command 와 matplotlib.pyplot.ion(), matplotlib.pyplot.ioff()를 통해 제어한다. 다음의 두 가지를 고려할 수 있다. 그래프가 콘솔 내에 출력하도록 할 경우 [1] %matplotlib inline ... plt.plot() 같은 명령이 있을 때마다 콘솔 내에 출력 plt.show()를 호출하지 않아도 됨 그래프가 별도창에 출력하면서, 인터랙티브하게 사용하고자 할 경우 [1] %matplotlib qt5 [2] matplotlib.pyplot.ion() ... plt.plot() 등을 호출하면 바로 그래프가 업데이트 plt.show()를 호출할 필요가 없음 그래프가 별도창에 출력하면서, 인터랙티브하지 않게 사용하고자 할 경우 [1] %matplotlib qt5 [2] matplotlib.pyplot.ioff() ... plt.plot() 등을 호출 후 plt.show()를 호출해야 그래프가 없데이트 Python IDE마다 디폴트로 설정되어 있는 값이 조금씩 다르다. 4.3 Matplotlib의 이해 Matplotlib의 구동 방식 Matplotlib은 두 가지 방식의 API를 제공하고 있다. Pyplot API : 이전절에 소개한 Matlab과 같이 커맨드 방식. matplotlib.pyplot 모듈에 함수로 정의되어 있음. 객체지향 API : matplotlib이 구현된 객체지향 라이브러리를 직접 활용하는 방식. Pyplot API는 결국 객체지향 API로 편의 함수를 구현한 것에 불과하며, 세밀한 제어를 위해서는 객체지향 API를 사용해야 한다. matplotlib 객체지향 API에는 FigureCanvas, Renderer, Artist라는 세 가지 객체로 구성되어 있다. FigureCanvas: 그림을 그릴 영역을 나타내는 객체 Renderer: 캔버스(FigureCanvas)에 그리는 도구 객체 Artist : Renderer가 FigureCanvas에 어떻게 그릴 것인가를 나타내는 객체 FigureCanvas와 Renderer는 wxPython, PostScript 등과 같은 사용자 이터 페이스 툴킷과 연계되는 낮은 수준의 제어를 담당하며, Artist는 figure, text, line, patch 등을 표시하는 높은 수준을 담당하게 된다(patch는 rectange, spline, path 등을 모두 이르는 용어). 따라서 matplotlib 사용자 입장에서는 Artist 객체를 다루는데 집중하면 된다. Artist는 primitives와 containers라는 두 가지 유형으로 구분할 수 있다. Primitives: Line2D, Rectangle, Text, AxesImage, Patch 등과 같이 캔버스에 그려지는 표준 그래픽 객체 Containers: Axis, Axes, Figure 등과 같이 이들 primitives가 위치하게 될 대상 커맨드 방식이 아닌 객체지향 방식으로 그림을 그리는 표준적인 방법은 Figure 객체를 생성하고, 이를 이용해 하나 이상의 Axes 객체를 만들고, Axes 객체의 헬퍼 함수로 primitives를 만들어 내는 것이다. 다음 코드는 동일한 기능을 수행하는 것을 비교한 것이다. Method 1 : Pyplot API(커맨드 방식)를 이용하는 방식 import matplotlib.pyplot as plt import numpy as np x = np.linspace(0,1,50) y1 = np.cos(4*np.pi*x) y2 = np.cos(4*np.pi*x)*np.exp(-2*x) plt.plot(x, y1,'r-*',lw=1) plt.plot(x, y2,'b--',lw=1) Method 2 :객체지향 API를 이용하는 방식 것이다. import matplotlib.pyplot as plt import numpy as np x = np.linspace(0,1,50) y1 = np.cos(4*np.pi*x) y2 = np.cos(4*np.pi*x)*np.exp(-2*x) fig = plt.figure() # 직접 Figure 객체를 생성 ax = fig.subplots() # 직접 axes를 생성 ax.plot(x, y1,'r-*',lw=1) # 생성된 axes에 대한 plot() 멤버 직접 호출 ax.plot(x, y2,'b--',lw=1) Method 3 :이 둘을 조합하여 Figure와 Axes를 plt.subpolots()라는 편의 함수를 사용한 것이다. import matplotlib.pyplot as plt import numpy as np x = np.linspace(0,1,50) y1 = np.cos(4*np.pi*x) y2 = np.cos(4*np.pi*x)*np.exp(-2*x) fig, ax = plt.subplots() # plt.subplots() 편의 함수는 Figure 객체를 생성하고 Figure.subplots()를 호출하여 리턴 ax.plot(x, y1,'r-*',lw=1) ax.plot(x, y2,'b--',lw=1) 사실 plt.plot(x, y, …) Pyplot 함수는 Line2D라는 Axes에 포함되는 primitive를 현재의 Axes를 대상으로 만들어 주는 함수이다. 만약 Figure, Axes 객체가 없다면 이를 만들어 준다. 따라서 (2)와 같은 방식이 matplotlib의 내부의 구동 상황을 잘 표현한다고 할 수 있다. 마지막 예인 (3)에서 plt.subplots()는 Figure 객체와 Axes 객체를 동시에 리턴한다. 또한 plt.subplots(2,1) 등과 같이 호출한 면 2*1 subplot에 대응하는 Figure 객체와 Axes 객체의 리스트를 리턴하여 주기 때문에 편리하다. 많은 쓰는 함수로 gca()가 있는 현재의 Axes 객체를 구해준다. Axes와 Axis Artist 객체에서 Figure, Axes, Axis의 개념이 중심한데 다음은 이를 나타낸 것이다. Axes와 Axis를 구분하는 것이 중요하다. Subplot을 그리는 방식 다음 코드는 subplot을 그린 예이다. 왼쪽의 기존 방식과 비교할 때 subplots()로 Figure 객체와 Axes 객체 리스트를 만들고, Axes 객체를 대상으로 plot(), grid(), set_xlabel() 등의 메쏘드를 호출하였다. 메쏘드 이름에서 일부 차이 나는 것을 제외하면 두 방식이 매우 유사함을 알 수 있다. Method 1 : subplot()을 이용하는 방법 import matplotlib.pyplot as plt import numpy as np x = np.linspace(0,1,50) y1 = np.cos(4*np.pi*x) y2 = np.cos(4*np.pi*x)*np.exp(-2*x) plt.subplot(2,1,1) plt.plot(x, y1,'r-*',lw=1) plt.grid(True) plt.ylabel(r'$sin(4 \pi x)$') plt.axis([0,1, -1.5,1.5]) plt.subplot(2,1,2) plt.plot(x, y2,'b--o',lw=1) plt.grid(True) plt.xlabel('x') plt.ylabel(r'$ e^{-2x} sin(4\pi x) $') plt.axis([0,1, -1.5,1.5]) plt.tight_layout() plt.show() Method 2 :객체지향 API를 이용하는 방식 것이다. import matplotlib.pyplot as plt import numpy as np x = np.linspace(0,1,50) y1 = np.cos(4*np.pi*x) y2 = np.cos(4*np.pi*x)*np.exp(-2*x) fig = plt.figure() ax = fig.add_subplot(2,1,1) ax.plot(x, y1,'r-*',lw=1) ax.grid(True) ax.set_ylabel(r'$sin(4 \pi x)$') ax.axis([0,1, -1.5,1.5]) ax = fig.add_subplot(2,1,2) ax.plot(x, y2,'b--o',lw=1) ax.grid(True) ax.set_xlabel('x') ax.set_ylabel(r'$ e^{-2x} sin(4\pi x) $') ax.axis([0,1, -1.5,1.5]) fig.tight_layout() plt.show() Method 3 : subplots()를 이용하는 방법 import matplotlib.pyplot as plt import numpy as np x = np.linspace(0,1,50) y1 = np.cos(4*np.pi*x) y2 = np.cos(4*np.pi*x)*np.exp(-2*x) fig, ax = plt.subplots(2,1) ax[0].plot(x, y1,'r-*',lw=1) ax[0].grid(True) ax[0].set_ylabel(r'$sin(4 \pi x)$') ax[0].axis([0,1, -1.5,1.5]) ax[1].plot(x, y2,'b--o',lw=1) ax[1].grid(True) ax[1].set_xlabel('x') ax[1].set_ylabel(r'$ e^{-2x} sin(4\pi x) $') ax[1].axis([0,1, -1.5,1.5]) plt.tight_layout() plt.show() 4.4 코드 조각 getp()를 이용한 정보 알아내기 gca(), gcf()와 axis() Figure 크기와 Face color 그림 저장하기 종횡비와 축 없애기 두 개의 Y 축 다양한 도형 그리기 Subplot 위치 및 크기 커스터마이징 대수축과 보조틱 plt.grid(True, which="both") getp()를 이용한 정보 알아내기 matplotlib 객체에 대한 정보는 plt.getp() 함수로 구할 수 있다. >>> plt.getp(fig) agg_filter = None alpha = None animated = False axes = [<matplotlib.axes._subplots.AxesSubplot object at ... children = [<matplotlib.patches.Rectangle object at 0x0000013... clip_box = None clip_on = True ... gca(), gcf()와 axis() gca()로 현재의 Axes를, gcf()로 현재의 Figure 객체를 구할 수 있다. 경우에 따라서 유용하게 사용된다. 이 두 함수는 만약 현재의 Axes나 Figure가 없을 경우 새로 생성한다. import matplotlib.pyplot as plt plt.gca().plot([1,2,3]) # 이전 그림이 없으면 생성 plt.gca().plot([7,8,9]) # 현재 그림에 그림 axis()는 축과 관련된 편의 함수이다. axis() : 축의 [xmin, xmax, ymin, ymax]를 리턴한다. axis([xmin, xmax, ymin, ymax]) : 축의 범위를 지정한다. axis(‘off’) : 축과 라벨을 없앤다. axis(‘equal’) axis(‘scaled’) axis(‘tight’) axis(‘image’) axis(‘auto’) axis(‘normal’) axis(‘square’) Figure 크기와 Face color Figure의 크기를 조정하거나 face color를 조정하는 것은 다음과 같다. 방법 1 : figure()로 생성할 때 인자로 조정하는 방법 plt.figure(figsize=(10,5),facecolor=’yellow’) 방법 2: 이미 생성되는 있는 figure를 대상으로 멤버 함수를 호출하는 방법 # already constructed …. # for example : fig, ax = plt.subplots() # or fig = plt.gcf() fig.set_size_inches(10,5) fig.patch.set_facecolor('white') 참고로 사용하는 환경에 따라 figure의 face color가 gray로 설정되는 경우가 있기 때문에 강재로 white로 지정하는 것이 보기 좋다. 그림 저장하기 그림을 저장하기 위해서는 figure()로 그림 객체를 만든 후 savefig() 함수를 사용하면 된다. >>> f = plt.figure(); … # plt.plot(...) # ... >>> f.savefig('AAA.png') fig, ax = plt.subplots(2,2) fig.set_size_inches(14,8) fig.set_facecolor('white') 종횡비와 축 없애기 Matplotlib을 일종의 캔버스로 사용하여 그림을 그릴 때는 가로세로 축, 프레임 등이 없어야 한다. import matplotlib.pyplot as plt import numpy as np t = np.arange(0.0, 1.0 + 0.01, 0.01) s = np.cos(2*2*np.pi*t) plt.plot(t, s, '-', lw=2) # aspect ratio plt.axes().set_aspect('equal', 'datalim') # axis 없애기 plt.axes().get_xaxis().set_visible(False) plt.axes().get_yaxis().set_visible(False) # frame선 없애기 plt.axes().set_frame_on(False) plt.tight_layout() 아래의 세 라인 대신 plt.axes().axis('off') 을 사용해도 된다. 만약 축 라벨만 없애고 싶다면 set_ticklabels([])를 적용한다. import numpy as np import matplotlib.pyplot as plt theta = np.linspace(22,65,100) h = theta*np.pi/180 # in radian f2bzV = 1/( np.sin(h)* np.cos(h))/2 av = np.sin(h)/np.cos(h) f = plt.figure() plt.subplot(2,1,1) plt.plot(theta, f2bzV) plt.axis([22,65,0,2]) plt.ylabel(r'normalized $f_2$ for given $V$') plt.gca().xaxis.set_ticklabels([]) plt.grid() plt.subplot(2,1,2) plt.plot(theta, 1/f2bzV) # av) plt.axis([22,65,0,2]) plt.ylabel(r'normalized $V$ for given $f_2$') plt.xlabel(r'$\theta$') plt.grid() plt.tight_layout() plt.savefig('compare.png') 두 개의 Y 축 두 개의 Y 축을 갖는 그래프는 Axes 객체를 x축을<NAME>도록 겹치면 된다. 이때 사용되는 메쏘드가 Axes.twinx()이다. import matplotlib.pyplot as plt import numpy as np fig, ax1 = plt.subplots() t = np.arange(0.01, 10.0, 0.01) s1 = np.exp(t) ax1.plot(t, s1, 'b-') ax1.set_xlabel('time (s)') # Make the y-axis label, ticks and tick labels match the line color. ax1.set_ylabel('exp', color='b') ax1.tick_params('y', colors='b') ax2 = ax1.twinx() s2 = np.sin(2 * np.pi * t) ax2.plot(t, s2, 'r.') ax2.set_ylabel('sin', color='r') ax2.tick_params('y', colors='r') fig.tight_layout() plt.show() 아래래는 pyplot API를 활용한 코드로 동일한 일을 한다. import matplotlib.pyplot as plt import numpy as np t = np.arange(0.01, 10.0, 0.01) s1 = np.exp(t) plt.plot(t, s1, 'b-') plt.xlabel('time (s)') # Make the y-axis label, ticks and tick labels match the line color. plt.xlabel('exp', color='b') plt.gca().tick_params('y', colors='b') plt.gca().twinx() s2 = np.sin(2 * np.pi * t) plt.plot(t, s2, 'r.') plt.ylabel('sin', color='r') plt.gca().tick_params('y', colors='r') plt.tight_layout() plt.show() 다양한 도형 그리기 plot() 명령은 내부적으로 Line2D 객체를 생성하여 Axes 객체에 추가하게 된다. 비슷하게 다양한 도형 객체를 생성하여 Axes 객체에 추가하는 것으로 도형을 그릴 수 있다. 도형은 Patch import matplotlib.pyplot as plt import matplotlib.patches as patches from matplotlib.path import Path # circle circle = patches.Circle((0,0),radius=1.,color = '.75') plt.gca().add_patch(circle) #rectangle rect = patches.Rectangle((2.5, -.5), 2., 1., color = '.75') plt.gca().add_patch(rect) # Ellipse ellipse = patches.Ellipse((0, -2.), 2., 1., angle = 45., color ='.75') plt.gca().add_patch(ellipse) # Path verts = [ (3., -2), # left, bottom (3., -1.), # left, top (4., -1.), # right, top (4., -2), # right, bottom (3., -2.), # ignored ] codes = [Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY, ] path = Path(verts, codes) patch = patches.PathPatch(path, color='.75') # facecolor='orange', lw=2, plt.gca().add_patch(patch) plt.gca().set_xlim(-2,2) plt.gca().set_ylim(-2,2) plt.axis('scaled') plt.grid(True) plt.show() Subplot 위치 및 크기 커스터마이징 gridspec을 통해 가능하다. 대수축과 보조틱 ... plt.plot(r1.Tp, r1.Sap,'ro', r1.Tv, r1.Sav,'r') plt.plot(r2.Tp, r2.Sap,'bo', r2.Tv, r2.Sav,'b--') plt.grid(True, which="both") ... plt.xlabel('Period') plt.xlim([0.01,10]) plt.xscale("log") plt.ylabel('Spectral acceleration [g]') plt.minorticks_on() plt.grid(True, which='both') plt.show() 4.5 3차원 그래픽 Matplotlib은 mpl_tookits라는 모듈로 3차원 그래프를 그릴 수 있다. 커맨드 방식인 Pyplot API는 없고, 항상 객체지향 API를 사용해야 한다. Axes3D 객체를 생성 후 3차원 그래프를 그리는 멤버 함수를 호출하는 방식이다. 다음은 주로 사용하는 3차원 그래프에 대한 일반적인 코드 골격이다. import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D fig = plt.figure() ax = fig.add_subplot(111, projection='3d') # or ax = fig.gca(projection='3d') # line/scatter plot : x, y, z는 1차원 배열 ax.plot(x, y, z,...) ax.scatter(x, y, z,...) # surface, wireframe plot : X, Y, Z는 2차원 배열 ax.plot_surface(X, Y, Z,...) ax.plot_wireframe(X, Y, Z,...) # bar3d plot : x, y, z는 1차원 배열 ax.bar3d(x, y, width,depth, z,...) from mpl_toolkits.mplot3d import Axes3D는 명시적으로 사용하지 않지만 반드시 임포트 선언해야 한다. fig.add_subplot(111, projection='3d')에서 Axes3D 객체를 만든다. ax = fig.gca(projection='3d')를 사용해도 된다. Axes3D 객체의 여러 그리기 멤버 함수에서 사용되는 x, y, z 배열의 차원에 주의해야 한다. 4.4.1 Line and scatter plot 다음 line plot과 scatter plot의 예이다. import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D import numpy as np # line plot fig = plt.figure() ax = fig.add_subplot(111, projection='3d') # ax = fig.gca(projection='3d') theta = np.linspace(-4*np.pi, 4*np.pi, 100) z = np.linspace(-2,2,100) r = z**2+1 x = r*np.sin(theta) y = r*np.cos(theta) ax.plot(x, y, z, label='parametric curve') ax.scatter(x, y, z) ax.legend() ax.set_xlabel('X') ax.set_ylabel('Y') ax.set_zlabel('Z') fig.tight_layout() plt.show() 4.4.2 Surface plot 다음은 surface plot과 wireframe plot의 예이다. import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D import numpy as np fig = plt.figure() ax = fig.gca(projection='3d') X=np.arange(-5,5,0.25) Y=np.arange(-5,5,0.25) X, Y = np.meshgrid(X, Y) R = np.sqrt(X**2+Y**2) Z = np.sin(R) surf = ax.plot_surface(X, Y, Z, cmap='coolwarm',linewidth=0, antialiased=False) wire = ax.plot_wireframe(X, Y, Z, color='r',linewidth=0.1) fig.colorbar(surf,shrink=0.5, aspect=5) fig.tight_layout() plt.show() 4.4.3 bar3d plot 다음은 bar3d plot의 예이다. import numpy as np import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D # setup the figure and axes fig = plt.figure(figsize=(8, 3)) ax1 = fig.add_subplot(121, projection='3d') ax2 = fig.add_subplot(122, projection='3d') # fake data _x = np.arange(4) _y = np.arange(5) _xx, _yy = np.meshgrid(_x, _y) x, y = _xx.ravel(), _yy.ravel() top = x + y bottom = np.zeros_like(top) width = depth = 1 ax1.bar3d(x, y, bottom, width, depth, top, shade=True) ax1.set_title('Shaded') ax2.bar3d(x, y, bottom, width, depth, top, shade=False) ax2.set_title('Not Shaded') plt.show() 5. NumPy + SciPy 활용 SciPy란? SciPy('사이파이'라고 읽음)는 과학기술 계산을 위한 Python 라이브러리이다. NumPy, Matplotlib, pandas, SymPy와 연계되어 있다(특히 NumPy와). 가능한 알고리즘과 관련 부패 키지는 다음과 같다. Clustering package (scipy.cluster) Constants (scipy.constants) Discrete Fourier transforms (scipy.fftpack) Integration and ODEs (scipy.integrate) Interpolation (scipy.interpolate) Input and output (scipy.io) Linear algebra (scipy.linalg) Miscellaneous routines (scipy.misc) Multi-dimensional image processing (scipy.ndimage) Orthogonal distance regression (scipy.odr) Optimization and root finding (scipy.optimize) Signal processing (scipy.signal) Sparse matrices (scipy.sparse) Sparse linear algebra (scipy.sparse.linalg) Compressed Sparse Graph Routines (scipy.sparse.csgraph) Spatial algorithms and data structures (scipy.spatial) Special functions (scipy.special) Statistical functions (scipy.stats) Statistical functions for masked arrays (scipy.stats.mstats) Low-level callback functions 설치 Anaconda 사용자는 별도의 인스톨 없이 바로 사용할 수 있다. NumPy와의 관계와 설정 확인 SciPy는 NumPy 상위에서 구동되는 라이브러리 정도로 이해해도 무방하다. SciPy는 기본적으로 NumPy의 ndarray를 기본 자료형으로 사용한다. 일부 패키지는 중복되지만(예, 선형대수 - numpy.linalg vs. scipy.linalg, 이산푸리에변환 - numpy.fft vs. scipy.fftpack) SciPy가 보다 풍부한 기능을 제공한다. NumPy, SciPy 등은 수치계산을 위한 패키지이므로 성능이 중요하다. 특히 BLAS와 LAPACK 등 기본 수치 라이브러리로 어떤 것을 사용했는가가 중요하다. 최근 Intel MKL을 도입하였다. numpy.show_config()와 scipy.show_config()를 통해 확인할 수 있다. >>> import numpy >>> numpy.show_config() mkl_info: libraries = ['mkl_rt'] library_dirs = ['C:/ProgramData/Anaconda3\\Library\\lib'] define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)] include_dirs = ['C:\\Program Files (x86)\\IntelSWTools\\compilers_and_libraries_2016.4.246\\windows\\mkl', ...] blas_mkl_info: <위와 동일> blas_opt_info: <위와 동일> lapack_mkl_info: <위와 동일> lapack_opt_info: <위와 동일> >>> import scipy >>> scipy.show_config() openblas_lapack_info: NOT AVAILABLE lapack_mkl_info: libraries = ['mkl_rt'] library_dirs = ['C:/ProgramData/Anaconda3\\Library\\lib'] define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)] include_dirs = ['C:\\Program Files (x86)\\IntelSWTools\\compilers_and_libraries_2016.4.246\\windows\\mkl', ...] lapack_opt_info: <위와 동일> blas_mkl_info: <위와 동일> blas_opt_info: <위와 동일> >>> Timing 과학기술 계산 연산은 계산 속도가 중요한 척도이다. 어떤 작업이 수행된 시간을 측정하는 것은 CPU time과 wall time으로 보통 구분한다. CPU time : 작업을 수행한 프로세서의 시간을 합산한 시간. time.process_time()에서 리턴된 값의 차이로 계산 wall time : 작업을 수행한 시간. time.perf_counter()이나 time.time()에서 리턴되는 값의 차이. time_perf_counter()가 보다 정확한 값을 제시 예를 들어 A라는 작업을 2개 프로세서(코어)에서 동시에 쉬지지않고 작업했는 데 2초가 걸렸다면, CPU time은 4초, wall time은 2초이다. 작업을 수행하는 개별 프로세서는 중간에 쉴 때가 존재하므로 단순히 (wall time) * (프로세서 수)로 CPU time이 계산되지는 않는다. import numpy as np import scipy.linalg import linalg A = np.random.random(size=(10000,10000)) cpuTime = time.process_time() # CPU time wallTime1 = time.perf_counter() # wall time wallTime2 = time.time() # wall time linalg.norm(A) cpuTime = time.process_time()-cpuTime # CPU time wallTime1 = time.perf_counter()-wallTime1 # wall time wallTime2 = time.time()-wallTime2 # wall time print('cpuTime : ', cpuTime) print('wallTime1 : ',wallTime1) print('wallTime2 : ',wallTime2) 주요 참고 사이트 SciPy Tutorial Python Scientific Lecture Notes 5.1 선형대수 np.linalg와 scipy.linalg에서 선형대수를 수행할 수 있다. scipy.linalg가 np.linalg와 비교할 때 일부 기능이 중복되나 보다 풍부한 기능을 제공한다. 행렬의 곱셈 import numpy as np import scipy.linalg as linalg A = np.array([[1,2, -1], [2,7,4], [0,4, -1]]) b = np.array([1,0,1.2]) # matrix-vector multiplication y1 = np.matmul(A, b) y2 = np.dot(A, b) y3 = A.dot(b) # matrix-matrix multiplication B = np.array([[1,2,3,4], [-1,2,3,1], [3, -2,5,9]]) C1 = np.matmul(A, B) C2 = np.dot(A, B) C3 = A.dot(B) determinant, solve, inverse # determinant det = linalg.det(A) # solve x = linalg.solve(A, b) r = A.dot(x) - b # check 0 vector # inverse Ainv = linalg.inv(A) # vector norm norm1 = linalg.norm(x, 1) # L1 norm == sum(np.abs(x)) norm2 = linalg.norm(x) # L2 norm == np.sqrt(sum(x*x)) # normp = linalg.norm(x, p) # p norm normMax = linalg.norm(x, np.inf) # max norm == np.max(abs(x)) # matrix norm LLS(Linear Least Square) # least-square import numpy as np from scipy import linalg import matplotlib.pyplot as plt c1, c2 = 5.0, 2.0 x = np.linspace(0.1,1,100) y = c1*np.exp(-x) + c2*x z = y + 0.05 * np.max(y) * np.random.randn(len(y)) A = np.vstack((np.exp(-x),x)).T c, resid, rank, sigma = linalg.lstsq(A, z) x2 = np.linspace(0.1,1,100) y2 = c[0]*np.exp(-x2) + c[1]*x2 plt.plot(x, z,'x', x2, y2) plt.axis([0,1.1,3.0,5.5]) plt.xlabel('$x$') plt.title('Data fitting with linalg.lstsq') plt.show() 고유치 문제 # eigen D, V = linalg.eigh(A) # for real sym or complex hermitian D, V = linalg.eig(A) 기타 pseudo-inverse generalized inverse svd lu decompositon cholesky QR schur matrix functions special matrix 5.2 희소 행렬 공학에서 발생하는 많은 문제들이 꽉 찬 행렬(dense matrix)가 아닌 대부분 0의 값을 갖는 희소 행렬(sparse matrix)이다. 계산의 효율을 위해서 희소 행렬은 곱셈, 역행렬 등등 행렬 연산을 수행할 때 별도의 알고리즘이 적용되어야 한다. scipy.sparse에서는 희소 행렬의 생성, 연산 등을 위한 함수, 객체를 제공하며, 선형대수는 scipy.sparse.linalg에서 제공한다. 5.3 최적화 들어가기 전에 여기에서 설명할 일부 함수는 scipy 1.2.1부터 지원되는 함수가 있다. 따라서 다음과 같이 버전 확인을 하도록 한다. > python >>> import scipy >>> scipy.__version__ '1.2.1' 만약 버전이 낮다면 scipy를 업그레이드한다. 관리자로 cmd를 실행한 후 다음을 실행한다. # 주의: 관리자로 cmd 실행 > pip install scipy --upgrade 개요 여러 공학 문제는 최적화(optimization) 문제로 귀결된다. scipy.optimize 패키지는 다음과 같은 최적화 문제를 풀 수 있다. Local optimization: 비구속 및 구속 조건하의 multivariate scalar function의 최소화 문제, 'minimize' Global optimizaiton : bashinhopping, differential_evolution Least-squares minimization과 curve fitting : least_squares, curve_fit Scalar univariate function의 최소화 또는 해 찾기 : minimizer_scalar, root_scalar Multivariate equation system의 해 찾기 : root Linear Programming : linprog 스칼라 함수의 해 찾기 Univariate scalar function f(x)=0 (x는 스칼라, 함숫값도 스칼라)의 해를 찾는 문제는 scipy.optimize.root_scalar(...)를 이용한다. optimize.root_scalar(f, args=(), method=None, bracket=None, fprime=None, fprime2=None, x0=None, x1=None, xtol=None, rtol=None, maxiter=None, options=None) 위에서 f는 사용자가 제공해야 하는 함수인데, def f(x,...) 형태로 첫 번째 인자가 x이고, 나머지 보조인자가 있을 수 있으며, args는 그 보조인자를 튜플로 넘겨준다. method는 bisect, brentq, newton 등과 같이 사용할 알고리즘을 기입한다. 해가 존재하는 범위를 아는 경우(bracketing method)와 그렇지 않은 경우(non-bracketing method)로 구분할 수 있다. Bracketing method는 Brent's method를 non-bracketing method로는 newton method를 사용하면 된다. Brent's method를 사용할 때는 해를 찾아야 하는 범위를 bracket 인자로 주어야 하며 해가 존재하는 경우 항상 해를 찾을 수 있다. from scipy import optimize def func(x): return x**3-1 sol = optimize.root_scalar(func, bracket=[0, 3], method='brentq') if sol.converged == True: print('Solution = ', sol) Newton method는 초깃값을 x0 인자로 fprime 인자로는 미분 함수를 제공해야 한다. fprime의 보조인자는 f 인자에 사용된 함수의 보조인자와 동일해야 한다. from scipy import optimize def func(x): return x**3-1 def derivative(x): return 3*x**2 sol = optimize.root_scalar(func, x0=1.5, method='newton',fprime=derivative) if sol.converged == True: print('Solution = ', sol) Inner function으로 최적화 대상 함수를 정의하기 최적화 루틴은 대부분 사용자가 함수를 작성하여 최적화 루틴에 인자로 제공해야 한다. 보통은 이 함수는 다양한 정보를 가지고 있어야 한다. 따라서 그 정보를 인자로 넘겨주어야 하므로, 인터페이스가 복잡할 여지가 있다. 따라서 경우에 따라서 inner function으로 대상 함수를 작성하는 것이 간결할 수 있다. 클래스 멤버 함수는 첫 번째 인자가 self이다. 따라서 클래스의 어떤 멤버 함수 내에서 최적화를 수행하고자 할 때는 정적 멤버 함수를 다시 정의해 주어야 한다. 다른 방법은 inner function을 사용하는 것이다. Local optimization 최적화 문제는 다음과 같은 형태이다. min ( ) subject to g ( ) 0 i 1 … m j ( ) 0 j 1 … p ( ) 는 최소화의 대상이 되는 스칼라 함수로 목적함수라고 불린다.는 벡터이다. i ( ) h ( ) 는 구속 조건이다. 구속 조건이 없는 경우는 비구속 최적화(unconstrained optimization), 존재하는 경우는 구속 최적화(constrained optimization) 문제라고 한다. scipy.optimize에서는 다양한 최적화 알고리즘을 제공하고 있는데 minimize(fun, x0,method=method,...) 함수로 일원화해서 풀도록 권장하고 있다. 이 함수은 OptimizeResult라는 객체에 결과를 담아 리턴한다. scipy.optimize.minimize(fun, x0, args=(), method=None, jac=None, hess=None, hessp=None, bounds=None, constraints=(), tol=None, callback=None, options=None)` fun, x0 : 목적함수와 초기값(initial guess) method : 사용할 알고리즘(솔버)를 나타내는 문자열. Nelder-Mead, Powell, CG, BFGS, trust-ncg 등등 jac, hess, hessp : 목적함수의 자코비언, 헤시 안, 헤시 안과 임의 벡터의 곱. 사용하는 알고리즘에 따라 필요할 수도, 필요하지 않을 수도 있음 bounds, constraints : 구속 최적화 문제에서의 구속조건을 부과하는 데 사용 tol:: 반복 계산 시 사용되는 종료를 위한 허용치(tolerance for termination) options : dict 형태로 주어지는 알고리즘별 옵션. maxiter와 disp는 공통이고 show_options(solver='minimize',method-'nelder-mead') 등과 같이 알고리즘별 옵션 조회 가능 maxiter : 정수로 최대 반복회수 disp : 수렴 정보를 출력할지 여부(True 또는 False) 최적화 알고리즘에 따라 비구속, 구속 조건에 적용할 수 있는 범주가 다르며, 경우에 따라서 자코비안, 헤시 안 등이 필요할 수 있다. 다음은 그 특징을 정리한 것이다. 비구속 최적화(unconstrained minimization) method jac hess, hessp bounds constraints Nelder-Mead X X X X Powell X X CG O X BFGS O X Newton-CG O O L-BFGS-B O X O TNC O X O COBYLA X X X O SLSQP O X O O dogleg O O trust-ncg O O trust-exact O O trust-krylov O O 비구속 최적화 예를 들어 `BFGS import numpy as np from scipy.optimize import minimize def rosen(x): """The Rosenbrock function""" return sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0) def rosen_der(x): xm = x[1:-1] xm_m1 = x[:-2] xm_p1 = x[2:] der = np.zeros_like(x) der[1:-1] = 200*(xm-xm_m1**2) - 400*(xm_p1 - xm**2)*xm - 2*(1-xm) der[0] = -400*x[0]*(x[1]-x[0]**2) - 2*(1-x[0]) der[-1] = 200*(x[-1]-x[-2]**2) return der def rosen_hess(x): x = np.asarray(x) H = np.diag(-400*x[:-1],1) - np.diag(400*x[:-1],-1) diagonal = np.zeros_like(x) diagonal[0] = 1200*x[0]**2-400*x[1]+2 diagonal[-1] = 200 diagonal[1:-1] = 202 + 1200*x[1:-1]**2 - 400*x[2:] H = H + np.diag(diagonal) return H def rosen_hess_p(x, p): x = np.asarray(x) Hp = np.zeros_like(x) Hp[0] = (1200*x[0]**2 - 400*x[1] + 2)*p[0] - 400*x[0]*p[1] Hp[1:-1] = -400*x[:-2]*p[:-2]+(202+1200*x[1:-1]**2-400*x[2:])*p[1:-1] \ -400*x[1:-1]*p[2:] Hp[-1] = -400*x[-2]*p[-2] + 200*p[-1] return Hp x0 = np.array([1.3,0.7,0.8,1.9,1.2]) #x0 = np.zeros([-1,2,3,1,5]) res = minimize(rosen, x0,method='nelder-mead', options={'xtol':1e-8, 'disp':True}) print('nelder-mead:',res.x) res = minimize(rosen, x0, method='BFGS', jac=rosen_der, options={'disp': True}) print('BFGS:',res.x) res = minimize(rosen, x0, method='Newton-CG', jac=rosen_der, hess=rosen_hess, options={'xtol': 1e-8, 'disp': True}) print('Newton-CG with Hessian:',res.x) res = minimize(rosen, x0, method='Newton-CG', jac=rosen_der, hessp=rosen_hess_p, options={'xtol': 1e-8, 'disp': True}) print('Newton-CG with Hessian product:',res.x) res = minimize(rosen, x0, method='trust-ncg', jac=rosen_der, hess=rosen_hess, options={'gtol': 1e-8, 'disp': True}) print('trust-ncg with Hessian:',res.x) res = minimize(rosen, x0, method='trust-ncg', jac=rosen_der, hessp=rosen_hess_p, options={'gtol': 1e-8, 'disp': True}) print('trust-ncg with Hessian product:',res.x) res = minimize(rosen, x0, method='trust-krylov', jac=rosen_der, hess=rosen_hess, options={'gtol': 1e-8, 'disp': True}) res = minimize(rosen, x0, method='trust-krylov', jac=rosen_der, hessp=rosen_hess_p, options={'gtol': 1e-8, 'disp': True}) import scipy.optimize as optimize optimize.show_options(solver='minimize',method='nelder-mead') 5.4 이산 푸리에변환 NumPy에서는 numpy.fft에서 Matlab과 거의 동일한<NAME>으로 DFT를 지원한다. 주로 사용하는 함수는 fft(x), ifft(x), fftfreq(n), fftshift(x) 등이다. 또한 matplotlib의 stem(x)를 stem plot을 그리는 데 많이 사용한다. FFT의 정의는 Matlab과 동일하다. 다만 인덱스가 0부터라는 점에 주의해야 한다. 3.6.1 FFT의 정의와 실수 신호 FFT의 정의 다음은 m X이고 데이터 개수가 N 일 때 FFT와 IFFT의 정의이다. FFT n ∑ = N 1 m exp ( j π n) where = , , , − Inverse FFT m 1 ∑ = N 1 n exp ( 2 m N ) where = , , , − 실수 신호의 FFT 실수 신호의 FFT는 항상 신호의 1/2 점을 기준으로 공액 관계를 이룬다. import numpy as np import matplotlib.pyplot as plt plt.ion() x = np.array([1.0,0.8,0.1,0.2,0.5,0.1,0,0.2]) # even number # x = np.array([1.0,0.8,0.1,0.2,0.5,0.1,0.2]) # odd number xf = np.fft.fft(x) plt.subplot(3,1,1) plt.stem(x); plt.ylabel('x') plt.title('Even number real signal') # plt.title('Odd number real signal') plt.subplot(3,1,2) plt.stem(np.abs(xf)); plt.ylabel('abs(X)') plt.subplot(3,1,3) plt.stem(np.angle(xf)); plt.ylabel('angle(X)') plt.tight_layout() Even number real signal Odd number real signal 3.6.2 Fourier transform 근사와 신호분석 Fourier transform의 정의와 DFT 근사 Fourier transform은 학자에 따라 다양하게 정의된다. ( ) X ( ) 쌍에 대해 보통 사용하는 정의는 다음과 같다. Forward Fourier Transform ( ) 1 π − ∞ ( ) exp ( j t ) ω Inverse Fourier Transform ( ) ∫ ∞ x ( ) exp ( j t ) t 위 정의를 사용할 때 DFT를 이용해 근사적으로 계산하는 것은 다음과 같다. Forward Fourier Transform : X = fft(x)*dt Inverse Fourier Transform : x = ifft(X)/dt 여기에서 dt는 샘플링 시간 간격 등이다. DFT를 이용한 신호분석 다음은 60 Hz 와 120 Hz의 사인 곡선이 중첩된 신호 ( ) 0.7 sin ( 120 t ) sin ( 240 t ) N ( = , = ) 를 따르는 노이즈가 포함된 신호에 대해 주파수 분석을 한 예이다. 샘플링 주파수는 100 Hz이고 1500개의 데이터가 있다고 가정하기로 한다. import numpy as np import matplotlib.pyplot as plt fmax = 1000 # sampling frequency 1000 Hz dt = 1/fs # sampling period N = 1500 # length of signal t = np.arange(0, N)*dt # time = [0, dt, ..., (N-1)*dt] s = 0.7*np.sin(2*np.pi*60*t) + np.sin(2*np.pi*120*t) x = s+2*np.random.randn(N) # random number Normal distn, N(0,2)... N(0,2*2) plt.subplot(2,1,1) plt.plot(t[0:51],s[0:51],label='s') plt.plot(t[0:51],x[0:51],label='x') plt.legend() plt.xlabel('time'); plt.ylabel('x(t)'); plt.grid() # Fourier spectrum df = fmax/N # df = 1/N = fmax/N f = np.arange(0, N)*df # frq = [0, df, ..., (N-1)*df] xf = np.fft.fft(x)*dt plt.subplot(2,1,2) plt.plot(f[0:int(N/2+1)],np.abs(xf[0:int(N/2+1)])) plt.xlabel('frequency(Hz)'); plt.ylabel('abs(xf)'); plt.grid() plt.tight_layout() 주파수 분석 결과 60 Hz 및 120 Hz에서 피크를 보임을 알 수 있다. 3.6.3 주파수 해석 예 선형계의 경우 동적 해석은 주파수 영역에서 해석이 가능하다. 다음은 스프링, 댐퍼, 질량으로 구성된 단 자유 도계에 대한 주파수 해석 코드이다. 질량 1, 고유주기 2 sec, 감쇠비 0.1 인 시스템에 대해 Half-sine 함수가 외부 하중으로 주어질 경우 1024개의 데이터, 총 시간 40 sec 에 대한 해석을 수행한 것이다. import numpy as np import matplotlib.pyplot as plt # Signal properties N=1024; T=40; dt =T/N t = np.arange(0, N*dt, dt) # [0, dt, ..., (N-1)*dt] # System properties Tn = 2.; xi = 0.1; wn = 2*np.pi/Tn m = 1 c = 2*m*wn*xi k = wn*wn # Excitation force p0 = 1; td = 2; p = np.zeros(N) p[t<td] = np.sin(np.pi*t[t<td]/td) # Frequency response df = 1/T f = np.arange(0, N*df, df) #[0, df,...,(N-1)*df] w = 2*np.pi*f pf = np.fft.fft(p)*dt H = 1/(-w*w*m+c*m*1j+k) uf = pf*H for i in range(0, int(N/2)): uf[N-i-1] = np.conjugate(uf[i+1]) ut = np.real(np.fft.ifft(uf)/dt) plt.subplot(2,2,1) plt.plot(t, p) plt.title('Excitation p(t)'); plt.xlabel('time[sec]') plt.grid() plt.subplot(2,2,2) plt.plot(f[0:int(N/2+1)],abs(pf[0:int(N/2+1)])) plt.title(r'Excitation p($\omega$)'); plt.xlabel('frq [Hz]') plt.grid() plt.subplot(2,2,3) plt.plot(t, ut) plt.title('Response u(t)'); plt.xlabel('time[sec]') plt.grid() plt.subplot(2,2,4) plt.plot(f[0:int(N/2+1)],np.abs(uf[0:int(N/2+1)])) plt.title(r'Reponse u($\omega$)'); plt.xlabel('frq [Hz]') plt.grid() plt.tight_layout() 6. 유용한 패키지와 함수 같은 라인 출력하기 print()는 기본적으로 실행될 때마다 줄을 바꾸게 된다. 같은 줄에 쓰려면 '\r'을 적용하고, 플러싱을 하면 된다. 저 수준의 stdout.write()를 사용하면 다음과 같다. from sys import stdout from time import sleep for i in range(10): stdout.write('\r%d' % i) stdout.flush() sleep(1) stdout.write('\n') print() 문을 사용할 때는 다음과 같다. from time import sleep for i in range(10): print(' %d'%i, end='',flush=True) sleep(1) print('\n') 위 코드는 cmd에서 사용거나 spyder에서는 정상작동하나, Visual Studio 2017에서는 줄바꿈을 하게 된다(버그로 보임) 다음은 keras에서 사용하고 있는 실제 코드이다. import sys import time for i in range(10): s = '{:03d} / 100'.format(i) sys.stdout.write(s) time.sleep(1) sys.stdout.write('\b' * len(s)) sys.stdout.write('\r') Findpeak 데이터 분석 시 첨두 값을 구해야 할 경우가 많다. 여기를 참조하면 Python에서 사용된 다양한 방법을 제시하고 있다. 여기에서는 peakdectect라는 matlab을 흉내 낸 코드가 가장 효율적이라고 제시한다. import numpy as np import matplotlib.pyplot as plt from peakdetect import * from scipy import signal x = np.arange(0, 10*np.pi, 0.05) y = np.sin(x)+0.5*np.cos(2*x) #ipeak = signal.find_peaks_cwt(y, np.arange(1,2)) #ipeak, x[ipeak], y[ipeak] #([32], array([ 1.6]), array([ 0.9995736])) ipeaks = peakdetect(y, lookahead=1) ipeaksmax = ipeaks[0]; ipeaksmin = ipeaks[1]; ipeakmax = [ipeaksmax[i][0] for i in range(len(ipeaksmax)) ] ipeakmin = [ipeaksmin[i][0] for i in range(len(ipeaksmin)) ] plt.plot(x, y, x[ipeakmax],y[ipeakmax],'o',x[ipeakmin],y[ipeakmin],'*') 6.1 Excel 파일 다루기(OpenPyXL) Python에서 Excel을 다루는 방법은 크게 COM을 이용하는 방법과 COM 무관한 독립 패키지를 이용하는 방법이 있다. 독립 패키지로는 xlwt, xlsxwriter, openpyxl이 있으며, OpenPyXL이 가장 많이 사용되고 있다. Anaconda 배포본에 포함되어 있으므로 별도의 인스톨 없이 사용 가능하다. 별도 인스톨은 다음과 같다. > pip install openpyxl OpenPyXL은 xlsx 파일을 메모리에 로딩한 후 읽거나 수정 따위의 작업을 수행한 하다. 이후 저장하는 방식으로 작업을 수행한다. 원본 파일을 변경하는 것이 아니라 메모리에 상주하는 파일을 새로운 이름으로 저장하는 방식임에 주의해야 한다. 다음은 기존 파일에서 읽어서 작업 후 다시 저장하는 샘플이다. # Tips : ascii to int, and back # >>> ord('a') # 97 # >>> chr(97) # 'a' from openpyxl import Workbook from openpyxl import load_workbook import numpy as np filename = 'SW-Top.xlsx' sheetName = 'S' startCol = 'F' # .... startCol = 'F' # .... F G H I J K # .... Sxx Syy, Szz Sxy Syz Szx outputFileName = filename[0:filename.rfind('.')] + '-new.xlsx' ns = ord('F')-ord('A') wb = load_workbook(filename) # load to memory # wb.get_sheet_names() ws = wb[sheetName] # selet sheet max_row = ws.max_row ws[chr(ord('F')+6)+str(1)] = 'P1' ws[chr(ord('F')+7)+str(1)] = 'P2' ws[chr(ord('F')+8)+str(1)] = 'P3(Zero)' for i in range(2, max_row+1): Sxx = ws[chr(ord('F')+0)+str(i)].value Syy = ws[chr(ord('F')+1)+str(i)].value Szz = ws[chr(ord('F')+2)+str(i)].value Sxy = ws[chr(ord('F')+3)+str(i)].value Syz = ws[chr(ord('F')+4)+str(i)].value Szx = ws[chr(ord('F')+5)+str(i)].value S = np.array([ [Sxx, Sxy, Szx], [Sxy, Syy, Syz], [Szx, Syz, Szz]]) (P, V) = np.linalg.eig(S) # allway (-neg, +pos, 0) ws[chr(ord('F')+6)+str(i)] = P[1] ws[chr(ord('F')+7)+str(i)] = P[0] ws[chr(ord('F')+8)+str(i)] = P[2] wb.save(outputFileName) Workbook에서 worksheet를 iteration 하는 것은 workbook.worksheets 멤버를 사용하면 된다. from openpyxl import Workbook from openpyxl import load_workbook import numpy as np filename = '단어장-2013.10.xlsx' wb = load_workbook(filename) for ws in wb.worksheets: print(ws.title) ws = wb.worksheets[0] # first worksheet ... ws = wb.active # active worksheet ... Excel 데이터를 clipboard를 복사한 후 사용하기 import numpy as np import pandas as pd df= pd.read_clipboard() # If you have selected the headers # df = pd.read_clipboard(header=None) # If you haven't selected the headers df[‘Tag1’] # Pandas Series로 들어오는 데 numpy 1d arry와 동일 x = df[‘Tag1’].as_matrix() # 강재로 numpy로 바꿀 경우 x = np.array(df['Tag1']) 이면 (n,) 형태의 1차원 배열 x = df['Tag1']).as_matrxi() 이면 (1, n) 형태의 2차원 배열 6.2 심벌릭 매스(SymPy) SymPy 패키지는 Matlab의 Symbolic Math Toolbox처럼 Symbolic math를 지원한다. Anaconda 배포본에 포함되어 있으므로 별도의 인스톨이 필요 없다. 다만 수식을 보기 좋게 보기 위해서는 TeX를 설치할 필요가 있다. MikTeX 인스톨 basic-miktex-2.9.6236-x64.exe 주의할 점은 init_printing()을 호출해야 한다. 이 함수는 수식을 출력할 가장 좋은 backend를 검색하여 구동하게 한다. 만약 TeX가 인스톨 되어 있다면 이를 사용하고, 없다면 matplotlib을 사용한다. Matplotlib은 행렬을 보기 좋게 출력 못하기 때문에 MikTeX 등 TeX를 인스톨하는 것이 좋다. 6.3 음성합성 Python으로 TTS(Text-to-Speech, 또는 음성합성, Speech Synthesis)는 다양한 방법으로 할 수 있다. 여기에서는 인터넷이 연결된 상태에서 자연스러운 합성 음성을 제공하는 다음의 무료 서비스를 소개한다. 다음 google TTS 서비스와 네이버 TTS를 이용하는 방법을 간략하게 정리한다. Google Text to Speech API : Google에서 제공하는 TTS 서비스. gTTS라는 모듈을 인스톨해야 함 Clova Speech Synthesis API : 네이버에서 제공하는 TTS 서비스 Google Text to Speech API Python에서 사용하려면 gTTS을 인스톨해야 한다. > pip install gTTS 다음은 간단한 사용 예이다. from gtts import gTTS text ="Hi, everybody. Playing with Python is fun!!!" tts = gTTS(text=text, lang='en') tts.save("helloEN.mp3") gTTS 객체를 생성하고, save(mp3file)로 저장하면 mp3 파일이 합성된다. gTTS 객체 생성 시 text 인자에는 변환할 문자열, lang에는 언어를 지정한다. 'en'은 영어, 'ko'는 한국어 등이다. from gtts import gTTS text ="안녕하세요, 여러분. 파이썬으로 노는 것은 재미있습니다!!!" tts = gTTS(text=text, lang='ko') tts.save("helloKO.mp3") 'en'으로 지정했을 때 한글이 text에 포함되어 있으면 이를 무시하지만, 'ko'일 때 text 내의 영문은 무시되지 않고 음성합성을 수행한다(아주 이상함) 영어는 여자<NAME>, 한글은 남자<NAME>이다(변경 불가능) 생성된 음성 파일을 "모노, 24000 Hz"이다. 영어, 한글을 섞거나 문자열을 이어서 mp3에 쓰고 싶다면 다음과 같다. from gtts import gTTS tts_en = gTTS(text=text, lang='en') tts_kr = gTTS(text='안녕하세요',lang='ko') f = open(tempFileName,'wb') tts_en.write_to_fp(f) # 영어로 네 번 말하고 tts_en.write_to_fp(f) tts_en.write_to_fp(f) tts_en.write_to_fp(f) tts_kr.write_to_fp(f) # 한글로 한번 말하기 f.close() Clova Speech Synthesis API (네이버 TTS) 네이버 개발자 사이트에서 오픈 API 이용 신청을 해야 하며, 하루에 사용할 수 있는 용량은 "10,000글자/일"이다. 자세한 사용법은 여기를 참조하면 된다. 여기에서는 개략적으로, 오류를 줄일 수 있는 방향으로 설명한다. import os import sys import urllib.request client_id = "YOUR_CLIENT_ID" client_secret = "YOUR_CLIENT_SECRET" encText = urllib.parse.quote("반갑습니다 네이버") data = "speaker=mijin&speed=0&text=" + encText url = "https://openapi.naver.com/v1/voice/tts.bin" request = urllib.request.Request(url) request.add_header("X-Naver-Client-Id",client_id) request.add_header("X-Naver-Client-Secret",client_secret) response = urllib.request.urlopen(request, data=data.encode('utf-8')) rescode = response.getcode() if(rescode==200): print("TTS mp3 저장") response_body = response.read() with open('1111.mp3', 'wb') as f: f.write(response_body) else: print("Error Code:" + rescode) "YOUR_CLIENT_ID"와 "YOUR_CLIENT_SECRET"은 네이버 OpenAPI 신청 시 주어지는 값으로 대체해햐 한다. Python 소스 파일이 반드시 UTF-8로 인코딩되어야 한다(한글이 있기 때문. 사용하는 에디터에 따라 ANSI(에디터에 따라 EUC-KR, CP949 등으로 표시)를 디폴트로 사용하는 경우도 있기 때문에 주의한다. 코드에서 data = "speaker=mijin&speed=0&text=" + encText가 음성으로 변환할 데이터에 대한 정보를 정의하는 부분이다. speaker에서<NAME>를 지정한다. 한국 남녀 : jinho, mijin 영어 남녀 : matt, clara 일본어 남녀 : shinji, yuri 중국어 남녀 : liangliang, meimei 스페인어 남녀 : jose, carmen 한국<NAME>(jinho, mijin)은 영문을 읽을 수 있지만(발음 안 좋음), 영어<NAME>(matt, clara)는 한글을 입력하면 오류가 발생하거나 한글 부분을 읽지 못한다. speed에서 -5~5 사이의 정수로 음성 재생속도를 지정한다. -5이면 0.5배 빠른, 5이면 0.5배 느린, 0이면 정상 속도이다. text로 음성 합성할 문자열을 지정한다. 원 문자열이 반드시 UTF-8로 인코딩되어 있어야 하며, 이를 다시 URL encoding으로 변환한 값을 전송해야 한다. 이 때문에 Python 소스는 반드시 UTF-8로 저장해야 한다. 한 번에 최대 5000자의 텍스트를 합성할 수 있다. text 필드에 쉼표(,)를 넣으면 고금 쉬었다가 말하고, .\n을 입력하면 구분된 문장으로 합성 결과를 보내준다. (예, '그는 방으로 들어가고, 그녀는 집 밖으로 나갔다. 이유는 알 수 없었다.') 한글과 영문 여부 검토 문자열에 한글과 영어가 섞여 있는지 검토할 필요가 있다. import re pkor = re.compile('[ㄱ-ㅎ|ㅏ-ㅣ|가-힣]') peng = re.compile('[a-z|A-Z]') text = "Hello world 한글 인가" text = "Hello world" text = "한글" text = "123-12" mkor = pkor.search(text) meng = peng.search(text) if mkor and meng: print("KOR + ENG") elif mkor and not meng: print("KOR only") elif not mkor and meng: print("ENG only") else: print("no KOR or ENG") 6.4 mp3 파일 플레이 Python은 wav 파일에 대한 지원은 표준배포본 차원에서 제공하고 있다. 하지만 주로 사용하는 mp3 파일에 대한 지원을 위해서는 외부 패키지의 설치 및 사용법 확인이 필요하다. 오디오 패키지에 대한 다양한 정보는 다음에서 구할 수 있다. Audio in Python Python Audio Material 위의 문서만으로는 MP3 파일 플레이가 가능한지 등에 대한 정보가 잘 나와 있지 않다. 다음은 직접 테스트해 본 몇몇 결과이다. PyAudio : 가장 많이 쓰이나 mp3 파일을 지원하지 않는다. pyglet : AvBin을 추가로 인스톨하면 mp3 파일을 지원한다. 단점으로는 ipython 쉘 내에서는 실행이 안 된다는 점이다. playsound : 한번 play 한 파일을 삭제할 수 없다(계속 파일을 잡고 있음) Pygame : 비디오 게임용 라이브러리이나, 제한적으로 MP3 파일을 지원한다. libVLC :<NAME>상 플레이어 VLC의 라이브러이다. VLC를 인스톨 후, 파이썬 바인딩인 vlc-python을 pip로 인스톨하면 사용 가능하다. VLC 인스톨 시 Python의 32비트 및 64비트에 일치하도록 VLC를 인스톨해야 한다. QtMultimedia : Qt에서 제공하는 멀티미디어 라이브러리 사용. PyQt5나 PySide2 등을 통해 사용할 수 있다. pyglet pyglet 패키지를 인스톨(콘솔 창에서 > pip install pyglet) 하고, AvBin을 직접 인스톨해야 한다(AvBin은 mp3 파일 지원을 위해) 사용법은 다음과 같다. import pyglet song = pyglet.media.load('thesong.ogg') song.play() pyglet.app.run() 콘솔 창에서 > python testPyglet.py와 같이 실행할 때는 위와 같이 하면 된다. Python 인터프리터 내에서 실행할 때는 마지막 pyglet.app.run()을 실행하면 안 된다. 단점은 IPython 인터프리터 내에서는 실행이 되지 않는다는 점이다. Pygame Pygame 패키지를 pip로 인스톨(콘솔 창에서 > pip install pygame) 하면 사용 준비가 끝난다. 다음은 간단한 예이다. import pygame music_file = "1.mp3" # mp3 or mid file freq = 16000 # sampling rate, 44100(CD), 16000(Naver TTS), 24000(google TTS) bitsize = -16 # signed 16 bit. support 8, -8,16, -16 channels = 1 # 1 is mono, 2 is stereo buffer = 2048 # number of samples (experiment to get right sound) # default : pygame.mixer.init(frequency=22050, size=-16, channels=2, buffer=4096) pygame.mixer.init(freq, bitsize, channels, buffer) pygame.mixer.music.load(music_file) pygame.mixer.music.play() clock = pygame.time.Clock() while pygame.mixer.music.get_busy(): clock.tick(30) pygame.mixer.quit() pygame.mixer.init(freq, bitsize, channels, buffer)에서 초기화하는데 디폴트로 호출하면 사운드의 속도가 비정상일 수 있다. 이때 중요한 것은 sampling rate를 올바르게 설정하는 것인데, Pygame은 mp3 정보 얻을 수 있는 방법이 없고, Audicity나 VLC 등을 통해 사용하려는 mp3 파일의 정보를 확인해야 한다. 보통 CD에서 직접 뽑은 mp3는 44100이고, Clova Speech Synthesis API (네이버 TTS)의 음성합성는 16000, Google Text to Speech API는 24000 등이다. pygame.mixer.music.play() 호출 후 while 루프가 없다면 콘솔에서는 mp3 파일이 플레이되지 않는다(기다리지 않고 프로그램을 종료하기 때문). 하지만 Python interpreter로 실행할 때는 없어도 무관하다. pygame.mixer.quit()를 호출해야 mp3 파일을 삭제하는 등과 같은 파일 접근이 가능하다(호출 전에는 파일을 mixer에서 계속 사용하는 중) 위 예는 가장 단순한 예이며, Pygame은 멈추기( pygame.mixer.music.stop() ), 볼륨 설정(예 pygame.mixer.music.set_volume(0.8)), 페이드아웃(예 pygame.mixer.music.fadeout(1000)) 등 다양한 함수를 제공한다. 자세한 설명은 Pygame 문서를 참조한다. libVLC 설치 방법은 먼저 VLC를 깔고 python-vlc를 인스톨하는 것으로 사용할 수 있다. 문제는 64비트 Python 사용 시 VLC 역시 64 비트를 인스톨해야 하는데 현재 버전인 3.0.0의 64비트 VLC 인스톨러가 문제가 있다는 점이다. 32비트 Python 이면 공식 사이트인 www.videolan.org에서 VLC 32비트 3.0.0를 다운로드해 설치한다. 64비트 Python 이면 nightlies.videolan.org에 접속하여 아직 릴리스되지 않은 64비트 VLC 4.0.0을 다운로드해 설치한다. VLC 설치 위치(C:\Program Files\VideoLAN\VLC)를 환경 변수 PATH에 추가한다. python-vlc 패키지를 인스톨(콘솔 창에서 > pip install pyton-vlc) 한다. 간단한 사용법은 다음과 같다 import vlc import time instance = vlc.Instance() #Create a MediaPlayer with the default instance player = instance.media_player_new() #Load the media file media = instance.media_new('test.mp3') #Add the media to the player player.set_media(media) #Play for 10 seconds then exit player.play() time.sleep(10) 마지막에 time.sleep(10)은 player.play() 되는 동시에 호출되어야 한다. 따라서 Python 인터프리터에서 실행할 때 >>> player.play(); time.sleep(10) 등과 같이 한 라인에서 실행하도록 한다. 보다 상세한 사용법은 Playing audio in Python with libVLC와 libVLC 위키를 참조한다. 오디오 편집 프로그램 mp3를 다룰 때 경우에 따라서 오디오 편집 프로그램이 필요하다. 다음은 무료 오디오 편집 프로그램이다. Audicity 6.5 PySide2 이 책의 자매 책인 공학자를 위한 PySide2 참조 6.6 Markdown+MathJax+Pandoc 수식이 포함된 공학 문서를 작성하는 좋은 방법은 Markdown+MathJax를 이용하는 것이다. 이때 작성된 문서는 Visual Studio Code 따위에서 Preview를 통해 포맷팅된 결과를 볼 수 있으며, Pandoc을 사용하면 docx나 html 등의 문서로 변환할 수 있다. Markdown : html 등으로 변환하는 것을 목표로 제시된 간단한 텍스트 문서 포맷 MathJax : html에서 latex 수식을 표시하는 js 라이브러리 Pandoc : 다양한 문서 포맷 변환 유틸러티. 예를 들어 Markdown 문서를 워드(docx), 웹(html) 등으로 변환할 수 있다. 참고로 wikidocs 사이트 역시 Markdown + Mathjax 조합으로 마크다운 문서 내에 Latex 수식을 쓰고 이를 화면에 나타낸다. HTML 문서에 MathJax 사용하기 https://www.mathjax.org/ HTML에서 latex 수식을 표시하게 해주는 js 라이브러리앋. 최신 버전은 Version 3에서는 3.2.2, Version 2에서는 2.7.9이다. MathJax를 사용하려면 다음과 같이 HTML 문서의 header에 포함 시면 된다. 버전 2 <head> ... <script async src="https://cdn.jsdelivr.net/npm/MathJax@2/MathJax.js? config=TeX-AMS-MML_CHTML"></script> 또는 <script src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/MathJax.js?config=TeX-MML-AM_CHTML" type="text/javascript"></script> ... </head> ... 버전 3 <head> ... <script src="https://polyfill.io/v3/polyfill.min.js? features=es6"></script> <script id="MathJax-script" async src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script> 또는 <script src="https://polyfill.io/v3/polyfill.min.js?features=es6"></script> <script id="MathJax-script" async src="https://cdn.jsdelivr.net/npm/mathjax@3.2.2/es5/tex-mml-chtml.js"></script> ... </head> ... MathJax 2.7.5부터는 MathJax.js 대신 latest.js 을 쓸 것을 추천하는데, 이 경우 2.x.x 대의 최신 버전으로 자동 변환해 준다. 버전 3도 비슷하게 mathjax@3는 최신 버전, mathjax@3.2.2는 지정한 버전을 의미한다. MathJax를 다운로드하여 off-line에서도 구동시킬 수 있다. 이때는 latest.js를 쓰면 안 된다. https://github.com/mathjax/MathJax에서 Version 2 또는 Version 3 최신 버전을 다운로드하고 압축 해제한 후 다음과 같이 사용한다. (MathJax-2.7.9.zip, MathJax-3.2.2.zip) 버전 2 <head> ... <script src="file:///D:/MathJax-2.7.9/MathJax.js? config=TeX-MML-AM_CHTML" type="text/javascript"></script> ... </head> ... 버전 3 <head> ... <script src="https://polyfill.io/v3/polyfill.min.js?features=es6"></script> <script src="file:///D:/MathJax-3.2.2/es5/tex-mml-chtml.js"></script> ... </head> ... 참고로 인터넷이 1번 연결되면 브라우저 캐시가 작동한다. 따라서 완전히 인터넷이 작동하지 않는 특수 조건에서만 off-line MathJax를 사용한다. Pandoc 기초 Pandoc은 문서 변환 유틸러티 프로그램이다. 자세한 사항은 다음을 참고한다. Pandoc, Markdown, KaTeX, Visual Studio Code로 똑똑하게 논문 쓰기 Anaconda를 인스톨하면 C:\ProgramData\Anaconda3\Scripts\pandoc.exe 등과 같이 하위 디렉토린 Scripts에 설치된다. PATH가 자동으로 잡히기 때문에 도스 창에서 직접 실행할 수 있다. https://pandoc.org/에서 다운로드할 수 있으며 현버전은 3.1.6.1이다(pandoc-3.1.6.1-windows-x86_64.zip). 다운로드 후 압축 해제하면 된다. 압축을 해제하면 pandoc.exe라는 단독 실행파일이 생성되며 이 파일만 있으면 실행이 가능하다(다른 dll 등 필요조건이 없음) 참고로 윈도 인스톨러 windows 인스톨러(pandoc-3.1.6.1-windows-x86_64.msi를 제공한다. Path를 설정된다는 점 이외에는 압축 본과 차이가 압서다. 기본 사용법 > pandoc -s -o fft.docx fft.md 위에서 -s 옵션은 standalone 실행(이 옵션이 없으면 타이핑으로 문서를 받음)을 의미하며 -o는 변환하여 저장할 문서 이름, 마지막에 대상 문서를 기입한다. 다음은 Python 스크립트로 실행한 것이다. import os os.system('pandoc -s fft.md -o fft.docx') 만약 pandoc을 별도로 설치할 경우 Pandoc 사이트에서 최신 버전을 인스톨할 수 있다. 윈도우즈용은 C:\Program Files\Pandoc에 설치된다. Markdown 문서 작성 시 \rm 대신 항상 \textrm을 사용하라 : \rm 은 obsolute이다. 따라서 Pandoc에서 파싱 할 때(특히, md -> docx로 변환할 때) 안되는 경우가 있다. Markdown to Docx Docx 문서를 포매팅하는 것은 레퍼런스를 작성한 후 한다. pandoc -s -o design1.docx design1.md --reference-docx=my-reference.docx Markdown to HTML MathJax 2를 온라인에서 사용하는 방법 ./pandoc-3.1.6.1/pandoc.exe -s -o design.html design.md --metadata pagetitle="Design" --css=pandoc.css --mathjax=https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.9/MathJax.js?config=TeX-MML-AM_CHTML MathJax 2를 Offline에서 사용하게 하는 경우 ./pandoc-3.1.6.1/pandoc.exe -s -o design.html design.md --metadata pagetitle="Design" --css=pandoc.css --mathjax=file:///D:/DevProg/HFC4.0/EXAMPLE/DigitalTwin/web/MathJax-2.7.9/MathJax.js?config=TeX-MML-AM_CHTML MathJax 3를 온라인으로 ./pandoc-3.1.6.1/pandoc.exe -s -o design.html design.md --metadata pagetitle="Design" --css=pandoc.css --mathjax=https://cdn.jsdelivr.net/npm/mathjax@3.2.2/es5/tex-mml-chtml.js MathJax 3를 오프라인으로 ./pandoc-3.1.6.1/pandoc.exe -s -o design.html design.md --metadata pagetitle="Design" --css=pandoc.css --mathjax=file:///D:/DevProg/HFC4.0/EXAMPLE/DigitalTwin/web/MathJax-3.2.2/es5/tex-mml-chtml.js 수식을 처리하기 위해 --mathjax 옵션에 MathJax의 CDN을 지정하거나 offline의 위치를 지정한다. --metadata는 HTML5 문서에서 꼭 필요한 pagetitle 또는 title 제공을 위해(없으면 경고 메시지 발생) --css는 css 서식 파일을 지정한다. 주의 : mathjax와 css에 로컬 파일을 지정할 때 공백 문자가 있는 경우 경로명을 ""로 묶어주어야 한다 추천 css (pandoc.css) /* * I add this to html files generated with pandoc. */ html { font-size: 100%; overflow-y: scroll; -webkit-text-size-adjust: 100%; -ms-text-size-adjust: 100%; } body { color: #444; font-family: Georgia, Palatino, 'Palatino Linotype', Times, 'Times New Roman', serif; font-size: 12px; line-height: 1.7; padding: 1em; margin: auto; max-width: 42em; background: #fefefe; } a { color: #0645ad; text-decoration: none; } a:visited { color: #0b0080; } a:hover { color: #06e; } a:active { color: #faa700; } a:focus { outline: thin dotted; } *::-moz-selection { background: rgba(255, 255, 0, 0.3); color: #000; } *::selection { background: rgba(255, 255, 0, 0.3); color: #000; } a::-moz-selection { background: rgba(255, 255, 0, 0.3); color: #0645ad; } a::selection { background: rgba(255, 255, 0, 0.3); color: #0645ad; } p { margin: 1em 0; } img { max-width: 100%; } h1, h2, h3, h4, h5, h6 { color: #111; line-height: 125%; margin-top: 2em; font-weight: normal; } h4, h5, h6 { font-weight: bold; } h1 { font-size: 2.5em; } h2 { font-size: 2em; } h3 { font-size: 1.5em; } h4 { font-size: 1.2em; } h5 { font-size: 1em; } h6 { font-size: 0.9em; } blockquote { color: #666666; margin: 0; padding-left: 3em; border-left: 0.5em #EEE solid; } hr { display: block; height: 2px; border: 0; border-top: 1px solid #aaa; border-bottom: 1px solid #eee; margin: 1em 0; padding: 0; } pre, code, kbd, samp { color: #000; font-family: Consolas, monospace, serif; font-size: 0.98em; background-color:#f8f8f8 } pre { white-space: pre; white-space: pre-wrap; word-wrap: break-word; } b, strong { font-weight: bold; } dfn { font-style: italic; } ins { background: #ff9; color: #000; text-decoration: none; } mark { background: #ff0; color: #000; font-style: italic; font-weight: bold; } sub, sup { font-size: 75%; line-height: 0; position: relative; vertical-align: baseline; } sup { top: -0.5em; } sub { bottom: -0.25em; } ul, ol { margin: 1em 0; padding: 0 0 0 2em; } li p:last-child { margin-bottom: 0; } ul ul, ol ol { margin: .3em 0; } dl { margin-bottom: 1em; } dt { font-weight: bold; margin-bottom: .8em; } dd { margin: 0 0 .8em 2em; } dd:last-child { margin-bottom: 0; } img { border: 0; -ms-interpolation-mode: bicubic; vertical-align: middle; } figure { display: block; text-align: center; margin: 1em 0; } figure img { border: none; margin: 0 auto; } figcaption { font-size: 0.8em; font-style: italic; margin: 0 0 .8em; } table { margin-bottom: 2em; border-bottom: 1px solid #ddd; border-right: 1px solid #ddd; border-spacing: 0; border-collapse: collapse; } table th { padding: .2em 1em; background-color: #eee; border-top: 1px solid #ddd; border-left: 1px solid #ddd; } table td { padding: .2em 1em; border-top: 1px solid #ddd; border-left: 1px solid #ddd; vertical-align: top; } .author { font-size: 1.2em; text-align: center; } @media only screen and (min-width: 480px) { body { font-size: 14px; } } @media only screen and (min-width: 768px) { body { font-size: 16px; } } @media print { * { background: transparent ! important; color: black ! important; filter: none ! important; -ms-filter: none ! important; } body { font-size: 12pt; max-width: 100%; } a, a:visited { text-decoration: underline; } hr { height: 1px; border: 0; border-bottom: 1px solid black; } a[href]:after { content: " (" attr(href) ")"; } abbr[title]:after { content: " (" attr(title) ")"; } .ir a:after, a[href^="javascript:"]:after, a[href^="#"]:after { content: ""; } pre, blockquote { border: 1px solid #999; padding-right: 1em; page-break-inside: avoid; } tr, img { page-break-inside: avoid; } img { max-width: 100% !important; } @page :left { margin: 15mm 20mm 15mm 10mm; } @page :right { margin: 15mm 10mm 15mm 20mm; } p, h2, h3 { orphans: 3; widows: 3; } h2, h3 { page-break-after: avoid; } } 샘플 md #### 설계 조건 * 두께 $h = [h] ~\textrm{mm}$ * 폭 $b = [b] ~\textrm{mm}$ * 콘크리트 * 콘크리트 기준 압축강도 $f_{ck} = [fck] ~\textrm{MPa}$ * 콘크리트 평균 압축강도 [fcm] * 콘크리트 단위질량 $m_c = 2,300 ~ \textrm{kg/m}^3$, * 콘크리트 탄성계수 $E_c=0.077m_c ^{1.5} \sqrt[3]{f_{cm}} = [Ec] ~ \textrm{MPa}$ * 콘크리트 평균인 장강도 $f_{ctm} = 0.3f_{cm} ^{2/3} = [fctm]~\textrm{MPa}$ * 콘크리트 기준인 장강도 $f_{ctk} = 0.70f_{ctm} = [fctk] ~\textrm{MPa}$ * 콘크리트 관련 상수 [KDS 24 14 21 3.1.2.5] * 상승곡선 부 형상<NAME> $n = \textrm{min}(1.2+1.5( \frac{100-f_{ck}}{60})^4,2.0) = [n]$ * 최대 응력 도달 시 변형률 $\epsilon_{co} = \textrm{max}(0.002+\frac{f_{ck}-40}{100,000},0.002) = [eco]$ * 극한 변형률 $\epsilon_{cu} = \textrm{min} (0.0033-\frac{f_{ck}-40}{100,000},0.0033) = [ecu]$ * p-r 단면 해석 계수 * 압축 합력 크기 계수 $\alpha = 1-\frac{1}{n+1} \frac{\epsilon_{co}}{\epsilon_{cu}} = [alpha]$ * 작용점 위치 계수 $\beta = 1 - \frac{1}{\alpha} (0.5- \frac{1}{(1+n)(2+n)} (\frac{\epsilon_{co}}{\epsilon_{cu}})^2 ) = [beta]$ * 철근 * 항복강도 $f_y = [fy] ~\textrm{MPa}$ * 철근 탄성계수 $E_s = [Es] ~\textrm{MPa}$ * 주철근 D[dbNomial]@[spacing], 피복 $c=[cover] ~\textrm{mm}$ 선택 * 주철근 직경 $d_b = [db] ~\textrm{mm}$ * 주철근 면적 $A_s = [Ask] \times [b]/[spacing] = [As] ~\textrm{mm}^2$ * 깊이 $d = [h] - [cover] + [db]/2 = [d] ~\textrm{mm}$ * 주철근비 $\rho = A_s / bd = [rho]$ * 휭철근 : D[dbTNomial]@[spacingT] 선택 * 횡철근 면적 $A_{st} = [AskT] \times [b]/[spacingT] = [AsT] ~\textrm{mm}^2$ * 전단 철근 : D[dbSNomial]-[legShear]@[spacingS] 선택 * 단위폭당 다리 수 : [legShear] * 전단 철근 면적 $A_{v} = [AskS] \times [legShear] = [Av] ~\textrm{mm}^2$ * 노출 등급 : [exposureClass] * 하중 * 극한한계상태 $M_u^{ULS} = [MuULS] ~\textrm{kN-m}~~ V_u^{ULS} = [VuULS] ~\textrm{kN}$ * 극단 한계 상태 $M_u^{ELS} = [MuELS] ~\textrm{kN-m}~~ V_u^{ELS} = [VuELS] ~\textrm{kN}$ * 사용 한계 상태 $Ms = [Ms] ~\textrm{kN-m}$ * 한계균열폭 $w_{lim} = [wlim] ~\textrm{mm}$ 6.7 MkDocs MkDocs는 마크다운(.md)로부터 정적 사이트를 생성할 수 있는 툴이다. 보통 프로젝트 설명서를 웹으로 구축할 때 많이 사용된다. MkDocs : MkDocs 설명서 MkDocs 튜토리얼 : 한글 MkDocs 설명서 MkDocs GitHub : MkDocs의 소스 및 위키 MkDocs Wiki : MkDocs 위키. 테마/확장/플러그인 등을 제공 Material for MkDocs : Material 테마 제공 PyMdown : Material 테마에서 제공하는 확장(extension) 관련 통합 패키지. 테마와 무관하게 사용 가능 ReadTheDocs-Dropdown : ReadTheDocs 테마를 수정한 드롭 다운 형태의 테마 https://math.meta.stackexchange.com/questions/5020/mathjax-basic-tutorial-and-quick-reference 설치 설치 ( PYTHON 실행 경로가 환경변수 PATH로 설정되어 있어야 하며, 관리자 권한으로 실행) > pip install mkdocs # mkdocs --version로 확인할 때 현 버전은 1.1.2 > pip install pymdown-extensions > pip install mkdocs-material > pip install mkdocs-rtd-dropdown mkdocs는 MkDocs를, pymdown-extensions는 PyMdown을, mkdocs-material은 material 테마, mkdocs-rtd-dropdown는 rtd-dropdown 테마를 설치한다. 주요 명령 > mkdocs new myProject # myProject라는 프로젝트 생성 > cd myProject > mkdocs serve # 로컬 서버 띄우기 -> 브라우저에서 `http://localhost:8000/` 또는`http://127.0.0.1:8000/`로 확인 가능 > mkdocs build # html 문서 만들기 mkdocs new <projectName>으로 새로운 프로젝트를 생성하는데 그 하부에 다음과 같다. <projectName> + docs - index.md - mkdocs.yml 마크다운 파일은 docs 폴더 아래(이 안에서 폴더 구조여도 된다) 넣고 mkdocs.yml을 통해 설정을 수행하면 된다. 다음은 간단한 docs의 구조와 mkdocs.yml 예이다. docs - index.md - about.md + chapter1 - 1-1.md - 1-2.md site_name: My Docs nav: - Home: index.md - About: about.md - chapter1: - 1-1 : chaper1/1-1.md - 1-2 : chaper1/1-2.md theme : material use_directory_urls: false pages 아래에 계층구조로 지정하면 된다. pages가 없어도 docs 디렉터리의 계층구조에 따라 자동으로 만들어 주나, 문서의 #(없으면 파일명)이 제목으로 설정된다. 따라서 pages를 사용하여 별도의 목차를 구성하는 것이다. 파일 명에 공백 등이 있는 경우 따옴표로 묶어 준다 - 1-1 : 'chaper1/1-1.md' theme은 테마를 지정하는데 지정하지 않을 경우 mkdocs 테마가 지정된다. mkdocs, readthedocs 테마를 제외한 테마는 MkDocs Wiki에서 구할 수 있다. 다음의 세 테마가 쓸만하다. readthedocs : MkDocs에서 추가로 제공하는 readthedocs 사이트를 흉내 낸 테마. 인스톨 불필요. 멀티 레벨 내비게이션 시 인덴테이션이 맞지 않는 문제점이 있다. rtd-dropdown : readthedocs의 내비게이션을 드롭 다운 형태로 변경한 테마. material : material 테마. 최근에 많이 세련됐다. 추천 use_directory_urls: false은 html 문서를 직접적으로 생성하도록 지정한다. 수식 설정 PyMdown을 설치한 후 mkdocs.yml에 다음을 추가한다. markdown_extensions: - pymdownx.arithmatex - pymdownx.betterem: smart_enable: all - pymdownx.caret - pymdownx.critic - pymdownx.details - pymdownx.emoji: emoji_generator:!! python/name:pymdownx.emoji.to_svg - pymdownx.inlinehilite - pymdownx.magiclink - pymdownx.mark - pymdownx.smartsymbols - pymdownx.superfences - pymdownx.tasklist: custom_checkbox: true - pymdownx.tilde extra_javascript: - 'https://cdnjs.cloudflare.com/ajax/libs/MathJax/2.7.5/MathJax.js? config=TeX-MML-AM_CHTML' 이제 마크다운 문서에서 $...$이나 $$...$$으로 Latex 수식을 적용할 수 있다. MathJax의 CDN 서버는 버전에 따라 조금씩 바뀐다(위의 2.7.5는 2020.1.14기준이며, mathJax 홈페이지에서 확인할 수 있다) Markdown 수식에서 \rm 대신 \textrm을 쓰도록 한다(Markdown 문서를 Pandoc으로 변환할 때 경우 따라 발생하는 오류 유발 방지) 7. HDF5 (파이썬) 소개 hdf5(Hierarchical Data Format version 5)는 대용량 데이터를 저장하기 위한 파일 포맷이다. 특징은 다음으로 요약할 수 있다. Easy sharing Cross platform Fast IO Big Data Heterogeneous data 쉽게 말해서 일종의 고성능 DB라고 이해할 수 있으며, 주로 과학기술 데이터의 포맷으로 적당하다. BSD 스타일의 라이선스를 채택하기 때문에 수정, 배포, 상용 프로그램 사용 등에 자유롭다. 파이썬 바인딩 h5py h5py와 PyTables 두 가지 파이썬 바인딩이 있다. 여기에서는 h5py를 사용한다. Anaconda의 경우 h5py가 미리 설치되어 있으므로 별도의 추가 인스톨이 필요 없다. 사용할 버전은 2.10.0이므로 업그레이드가 필요할 수 있다. 설치 시(필요한 경우) > pip install h5py 설치 시(업그레이드의 경우) > pip install h5py --upgrade 버전 확인 >>> import h5py >>> h5py.__version__ '2.10.0' 관련 사이트 https://www.hdfgroup.org/ : HDF5 https://www.h5py.org/ : HDF5의 파이썬 바인딩인 h5py 패키지 https://www.pytables.org/ : HDF5의 파이썬 바인딩인 PyTables 패키지 https://www.nexusformat.org/ : h5py를 이용한 데이터 포맷 예시 7.1 HDF5의 특징 HDF5의 특징 HDF5를 이해하는 가장 중요한 개념은 그룹(Group), 데이터 셋(Dataset), 속성(attribute)이다. 디렉터리 구조와 비슷한데, 그룹=디렉터리, 데이터 셋=파일로 이해하면 쉽다. 속성은 일종의 메타데이터로 그룹이나 데이터 셋을 부연 설명하는 것을 의미한다. HDF5 파일을 생성하면 먼저 /라는 루트 그룹이 생성되고 그 하위에 트리 구조로 다른 그룹을 생성할 수 있다. 그룹 하위에 다른 그룹이 있을 수도 있고, 데이터 셋이 존재할 수도 있다. 즉 완전히 운영 체계의 디렉터리-파일 구조와 일치한다. 또 다른 특징은 속성인데 속성은 데이터 셋이나 그룹을 설명하는 데 사용하는 데 이를 사용자가 정의하게 된다. 정리하면 HDF5는 Hierarchical Data Format이며 self-describing이 되는 고성능 데이터 포맷 또는 DB 정도로 이해할 수 있다. 운영 체계와 무관하게 사용할 수 있으며, 대용량 데이터를 빠르게 읽고 쓸 수 있다. 간단한 예 import numpy as np import matplotlib.pyplot as plt import h5py ######################### # write # station 15 temperature15 = np.random.random(1024) wind15 = np.random.random(2048) # station 20 temperature20 = np.random.random(1024) wind20 = np.random.random(2048) f = h5py.File('weather.hdf5','w') # 'a' f.attrs['descr'] = 'Temperature and wind data at HK mall' f['/15/temperature'] = temperature15 f['/15/temperature'].attrs['dt'] = 10.0 f['/15/temperature'].attrs['start_time'] = 1375204299 f['/15/wind'] = wind15 f['/15/wind'].attrs['dt'] = 5.0 f['/20/temperature'] = temperature20 f['/20/temperature'].attrs['dt'] = 10.0 f['/20/temperature'].attrs['start_time'] = 1375204299 f['/20/wind'] = wind20 f['/20/wind'].attrs['dt'] = 5.0 f.close() ######################### # read f = h5py.File('weather.hdf5','r') temp = f['15/temperature'][:] dt = f['15/temperature'].attrs['dt'] f.close() npoint = len(temp) t = np.arange(0.,npoint*dt, dt) plt.plot(t, temp) plt.tight_layout() plt.show() 생성된 HDF5 파일은 HDFView에서 편리하게 확인할 수 있다. 7.2 파일과 그룹 파일 hdf 파일 h5py.File(name, mode=None, ...) 형태로 객체를 생성하여 파일을 열게 된다. f = h5py.File('test.h5','w') ... f.close() 모드에는 다음과 같은 5가지가 있다. r Readonly, file must exist r+ Read/write, file must exist w Create file, truncate if exists w- or x Create file, fail if exists a Read/write if exists, create otherwise (default) 그룹(group) 그룹은 컨테이너 역할을 한다. HDF5 파일에는 항상 루트 그룹 / 이 존재하며, 파일 객체는 루트 그룹으로 취급할 수 있다. 그룹에 하위 그룹을 만드는 것은 group.create_group(name, ...)로 생성한다. 이때 name은 /로 시작하면 절대 경로가, 그렇지 않으며 상대 경로가 사용된다. import numpy as np import h5py fdata = np.arange(10.) f = h5py.File('group.h5','w') f.create_group('1') f.create_group('/2/1') f['/2'].create_group('2') f['/2'].create_group('/3/4/1') # f.create_group('/3/4/1') f['/2'].create_group('3/4/1') f['/4/data'] = fdata # f.create_dataset('/4/data',data=fdata) f.close() 위에서 순차적으로 그룹을 만들지 않더라도 은연중에 그룹이 생성됨을 알 수 있다. 또한 group.create_dataset(name, data=data)로 데이터 셋을 생성할 때 마찬가지이다. 위에서 생성한 파일의 구조는 다음과 같이 h5ls나 h5dump 유틸러티로 확인해 볼 수 있다. 또는 HDFView를 통해 시각적으로 확인할 수 있다. 그룹의 중요 멤버는 [key], name, attrs 등이다. >>> f = h5py.File('group.h5','r') >>> f['/1'] <HDF5 group "/1" (0 members)> >>> f['/1'].name Out[94]: '/1' 순회가 필요하면 keys(), items(), values() 을 사용한다. for k in f.keys(): print(f[k].name) for k, v in f.items(): print(k, v.name) for v in f.values(): print(v.name) 결괏값 keys() /1 /2 /3 /4 items() 1 /1 2 /2 3 /3 4 /4 values() /1 /2 /3 /4 7.3 데이터 셋 - 기초 기본 사항 데이터 셋은 동일한 데이터 타입을 갖는 수치로 이루어진 배열(1차던, 2차던, 고차던)을 저장한다. numpy의 ndarray에 이름을 붙여 저장한다고 생각할 수 있다. 생성은 그룹의 멤버 함수인 create_dataset(...)로 생성할 수 있다. dataset = group.create_dataset(name, shape=None, dtype=None, data=None,...) 이미 만들어진 데이터 셋의 중요 속성은 name, shape, dtype이다. ndarray로 데이터를 지정할 때는 shape과 dtype을 지정할 필요 없다. import numpy as np import h5py fdata = np.arange(5.) f = h5py.File('dataset.h5','w') data1 = f.create_dataset('data1',data=fdata) # same to f['data'] = fdata print(data1.name) # /data1 print(data1.shape) # (5, ) print(data1.dtype) #[ 0. 500. 2. 3. 4.] ... 데이터 셋을 액세스하는 것은 ndarray와 동일하게 []를 이용한다(예전에서는 dataset.value로 직접 내부의 ndarray를 접근하였으나 depreciated 됨)로 가능하다. 아래와 같이 변경하면 바로 값이 변경된다. data1[1] = 500 data1[2:5] = -1.4 print(data1[:]) 저장할 공간만 미리 정해 놓고 나중에 값을 대입하는 것은 다음과 같다. flush()를 사용하여 바로 쓰도록 해야 한다(호출하지 않으면 파일 닫힐 때 불림) d = f.create_dataset('data2',shape=(5, ),dtype='float') d[:] = fdata f.flush() 위에서 dtype을 직접 지정할 때는 numpy의 다양한 데이터 타입이 가능하다( dtype = numpy.float32, dtype = np.dtype('int') 등등). NumPy 배열을 데이터로 지정하면서 dtype을 지정하면 형 변환이 이루어지며 복사되게 된다. f.create_data('data',data=fdata, dtype=np.dtype('float32')) 위에서 fdata의 dtype은 float64 (64비트 실수)인데, 데이터 셋의 dtype을 float32로 지정했기 때문에 32 비트 크기의 배열로 저장된다. 크기가 변경 가능한 데이터 셋 데이터 셋에 저장되는 배열은 dataset.resize(tuple)로 변경할 수 있다. 하지만 생성 시 디폴트는 크기가 변경 불가능하다. data = f.create_dataset('dset',(2,2),dtype='int') print(data.shape) # (2,2) print(data.maxshape) # (2,2) d.resize((2,10)) # error ... 크기가 변경 가능하게 하려면 maxshape 인자를 데이터 셋을 생성할 때 지정해야 한다. import numpy as np import h5py data = np.array([[1,2],[3,4]]) f = h5py.File('datasetresize.h5','w') d = f.create_dataset('dset',(2,2),dtype='int',maxshape=(2, None)) print(d.shape) # (2,2) print(d.maxshape) # (2, None) d[:] = data print(d[:]) d.resize((2,10)) print(d[:]) f.close() 위 코드는 처음 데이터 셋을 생성할 때 (2,2)로 생성하고, maxshape 인자에서 None 지정된 축으로 크기가 변경할 수 있다는 의미이다. 즉, (2, any) 형태로 변경할 수 있다. 7.4 데이터 셋 - 고급 기본 사항 dataset을 생성할 때 dtype 인자가 주어지지 않는 경우 주어진 numpy array의 dtype으로 설정되게 된다. 만약 보다 다양한 데이터 타입을 사용하고자 하면 dtype을 인자로 주어야 한다. 정수 : np.dtype("i") , np.dtype("i8"), np.dtype("int"), np.dtype("<i8"), ... 실수 : np.dtype("f"), np.dtype("float64"), ... 고정길이 문자열 : np.dtype('S10') 가변 길이 문자열 : h5py.string_dtype(encoding='utf-8') 가변길이 데이터 : h5py.vlen_dtype(np.dtype('int32')), ... 컴파운드(C의 구조체, np의 structured array) : dtype = [('name','S10'),('age','<i4'),('height','<f4')] 가변길이 데이터를 포함한 컴파운드 : vdtype = h5py.vlen_dtype(np.dtype("float64")); dtype=[("no", np.dtype("int")), ("nodes",vdtype)] 이외에도 열거형 등 다양한 타입을 지원한다. 가변 길이 문자열 NumPy의 데이터 타입을 모두 지원하기 때문에 NumPy 배열을 dataset으로 저장하는 데는 문제가 없다. 하지만 NumPy의 데이터 타입이 아닌 경우 특수한 처리가 필요하다. 대표적 예가 문자열이다. 문자열은 string_dtype(encoding=encoding)으로 특수 타입을 만들어 사용한다(주의 예전 버전은 special_dtype(vlen=str)을 사용하였음) import numpy as np import h5py data = np.array([1,2,3]) tags = ['James','Cook','Linda'] f = h5py.File('datasetstr.h5','w') f['data'] = data # f.create_dataset('data',data=data) sdtype = h5py.string_dtype(encoding='utf-8') # (3, ) array of string dset = f.create_dataset('strdata',(3, ),dtype=sdtype) dset[0] = 'James' dset[1] = 'Cook' dset[2] = 'Michael' # only one string : (1, ) string f.create_dataset('strdata2',data='This is special type',dtype=sdtype) f.close() f = h5py.File('datasetstr.h5','r') A = f['strdata'][0] B = f['strdata2'][()] # zero-dimension case 'CAUTION' f.close() 가변길이 데이터(vlen data) NumPy 배열은 각 요소의 크기가 일정한 것이 특징이다. h5py는 배열 요소의 크기가 가변인 데이터를 지원한다(h5py 버전 2.10.0부터 지원) import h5py import numpy as np f = h5py.File('vlen.h5','w') dtype = h5py.vlen_dtype(np.dtype('int32')) dataset = f.create_dataset('vlen_int',(3, ),dtype=dtype) dataset[0] = [1,2,3] dataset[1] = [1,2,3,4,5] f.close() 가변길이 데이터를 타입으로 지정할 경우 열의 수가 1인 dataset만 가능하다. 따라서 정수, 실수 등이 혼합되어 있는 경우는 뒤에 설명할 vlen 데이터를 포함한 compound로 처리해야 한다. 컴파운드 C의 구조체를 성분으로 갖는 배열은 NumPy에서 structured array이다. HDF5 역시 이를 지원하다. import numpy as np import h5py name = ['Alice', 'Bob', 'Doug'] age = [25, 45, 37] height = [173.,181.,165.] dtype = [('name','S10'),('age','<i4'),('height','<f4')] data = np.zeros(3, dtype=dtype) data['name'] = name data['age'] = age data['height'] = height f = h5py.File('compound.h5','w') f['data'] = data # d = f.create_dataset('data',dtype=dtype) # d[:] = data f.close() 가변길이 데이터를 가지는 컴파운드 컴파운드를 구성할 때 가변길이 데이터를 구성요소로 지정하면 다양한<NAME>으로 저장할 수 있다. import h5py import numpy as np # np.dtype("<i8") == np.dtype('int64') vlen_dtype = h5py.vlen_dtype(np.dtype("float64")) f = h5py.File('compound-vlen.h5', "w") dset = f.create_dataset( "elem_nodes", shape=(5, ), maxshape=(None,), chunks=True, compression="gzip", dtype=[("no", np.dtype("int")), ("nodes", vlen_dtype)], # dtype=[("no", np.dtype("<i8")), ("nodes", np.dtype("<i8"))], # dtype=dt ) dset[0] = (1, np.array([1, 2], dtype=np.dtype("float64")) ) dset[1] = ( 2, np.array([2, 3, 4])) dset[2] = ( 3, np.array([2, 3, 4], dtype="float64")) f.close() 데이터 타입 추가사항 h5dump로 출력된 결과를 보면 H5T_STD_I32LE라는 표현이 있다. 이는 HDF5의 C에서 사용하는 타입명인데 정수형, 32비트, 리틀엔디언을 의미한다. 미리 정의되어 있는 타입은 HDF5 Predefined Datatypes을 참조하면 된다. 일부만 소개하면 다음과 같다. IEEE floating point datatypes H5T_IEEE_F32BE H5T_IEEE_F32LE H5T_IEEE_F64BE H5T_IEEE_F64LE 정수 H5T_STD_I8BE H5T_STD_I8LE ... H5T_STD_I64BE H5T_STD_I64LE h5py의 저 수준 API에서는 C에서 정의하는 데이터 타입을 정의하고 있다. 따라서 다음 f.create_dataset("fdata",data=fdata) # 디폴트인 64비트 LE 사용 f.create_dataset("fdata",data=fdata, dtype=h5py.h5t.IEEE_F64LE) # 64비트 LE 사용 f.create_dataset("fdata",data=fdata, dtype=h5py.h5t.IEEE_F64BE) # 64비트 BE 사용 f.create_dataset("idata",data=idata) # 디폴트인 32비트 LE 사용 f.create_dataset("idata",data=idata, dtype=h5py.h5t.STD_I32LE) # 32비트 LE f.create_dataset("idata",data=idata, dtype=h5py.h5t.STD_I32BE) # 32비트 BE 7.5 속성 기본 HDF5의 가장 큰 장점 중 하나가 그룹이나 데이터 셋을 부연 설명하는 사용자 정의 메타 데이터를 속성으로 지정할 수 있다느 점이다. 속성(attribute)는 그룹이나 데이터 셋 객체의 attrs 멤버로 액세스할 수 있으며 dictionary 타입처럼 사용할 수 있다. import numpy as np import h5py sensor = np.random.random(100) f = h5py.File('attr.h5','w') f['sensor'] = sensor f['sensor'].attrs['dt'] = 5. f['sensor'].attrs['time'] = '2019.12.3' f.close() #--------------------------- f = h5py.File('attr.h5','r') sensor_data = f['sensor'] sensor_attrs = sensor_data.attrs dt = sensor_attrs['dt'] print('dt = ',dt) print('---attrs.keys()') for key in sensor_attrs.keys(): print(key, ':', sensor_attrs[key]) print('---attrs.values()') for value in sensor_attrs.values(): print(value) print('---attrs.items()') for key, value in sensor_attrs.items(): print(key,':', value) 출력 dt = 5.0 ---attrs.keys() dt : 5.0 time : 2019.12.3 ---attrs.values() 5.0 2019.12.3 ---attrs.items() dt : 5.0 time : 2019.12.3 7.6 링크 HDF5는 hard link와 soft link(=symbolic link)를 지원한다. 이는 UNIX에서 파일의 쇼트커트로 제안되었으며, symbolic link는 Windows에서도 지원한다. UNIX에서의 구분은 다음으로 이해할 수 있다. 예를 들어서 a.txt라는 파일이 있다고 가정한다. 이 파일을 가리키는 hard link를 만들었다면, hard link를 삭제하거나 원 파일을 삭제하더도 실제 파일이 삭제되지는 않는다. 내부적으로 reference counter를 유지하며 이가 0이 될 때 실제로 삭제하게 된다(파일을 생성되지 마자 그 자체가 hard link, 즉 reference counter 가 1이다). 즉, smart pointer와 유사한 개념이다. Soft link는 단순히 경로만 저장한다. a.txt를 삭제하면 실제로 그 파일이 삭제되며, 연결된 soft link는 의미 없게 된다(dangling). HDF5는 그룹과 데이터 셋을 대상으로 hard link, soft link를 사용할 수 있다. 다음은 단순히 그룹에 대한 hard link를 생성하고 h5dump로 관찰한 결과이다. import numpy as np import h5py f = h5py.File('link1.h5','w') g1 = f.create_group('g1') f['g2'] = g1 f.close() >h5dump link1.h5 HDF5 "link1.h5" { GROUP "/" { GROUP "g1" { } GROUP "g2" { HARDLINK "/g1" } } } 다음은 단순히 데이터 셋에 대한 hard link를 생성하고 h5dump로 관찰한 결과이다. import numpy as np import h5py f = h5py.File('link2.h5','w') d1 = f.create_dataset('d1',shape=(2,2),dtype=np.int32) g1 = f.create_group('g1') f['g2'] = g1 g1['d2'] = d1 f.close() >h5dump link2.h5 HDF5 "link2.h5" { GROUP "/" { DATASET "d1" { DATATYPE H5T_STD_I32LE DATASPACE SIMPLE { ( 2, 2 ) / ( 2, 2 ) } DATA { (0,0): 0, 0, (1,0): 0, 0 } } GROUP "g1" { DATASET "d2" { HARDLINK "/d1" } } GROUP "g2" { HARDLINK "/g1" } } } 7.7 실제 예제 유한 요소 결과 데이터 저장 import numpy as np import h5py inp = ''' *Title test *Node 1, 0, 0, 1 2, 2, 1, 0 *Element, TYPE=Element 1,2,1 *Step 0.1 ''' nodes = [ [1,3,1,0,0], [2,3,0,21], [3,1,2,1,3], [4,5,1,2,3,1,4]] elms = [ [1, 0,0, 10,0], [2, 10,0,12,1], [3, 1,2,3, -4,2,1]] f = h5py.File('fem.h5','w') sdtype = h5py.string_dtype(encoding='utf-8') vdtype = h5py.vlen_dtype(np.dtype('float64')) #inpGroup = f.create_group('/inp') #inpGroup.create_dataset('inp',data=inp, dtype=sdtype) # only one string : (1, ) string f.attrs['inp'] = inp step1 = f.create_group('/Step1') # /2/1 step1.attrs['TargetElement'] = 'Elset1, Elset2, Elset3' step1.attrs['TargetLoad'] = 'LC1, LC2' step1.attrs['TargetConstraint'] = 'C1, C2' step1.attrs['FieldOutputs'] = 'D, SF' dofs = np.zeros((len(nodes),2),dtype='int') for i, n in enumerate(nodes): dofs[i, 0] = n[0] dofs[i, 1] = n[1] step1.attrs['dofs'] = dofs frame1 = step1.create_group('frame1') frame1.attrs['time'] = 0.1 disp = frame1.create_dataset('D',shape=(4, ),dtype=[("iD",np.dtype('int')),("data",vdtype)]) for i, n in enumerate(nodes): disp[i] = (n[0],np.array(n[2:])) sf = frame1.create_dataset('SF',shape=(3, ),dtype=[("id",np.dtype('int')),("data",vdtype)]) for i, e in enumerate(elms): sf[i] = (e[0],np.array(e[1:])) f.close() f = h5py.File('fem.h5','r') inputStream = f.attrs['inp'] print(inputStream) f.close() 8. Embedding Python in C++ program Extending과 Embedding Python과 C/C++를 연동하는 방법으로는 (1) Python에서 C/C++를 사용하기(extending), (2) C/C++에서 Python 사용하기(embedding) 가 있으며, 이때 다음의 두 가지로 이를 구현할 있다. Python에서 제공하는 API를 사용하는 방법 pybind11, PythonQt, Boost.Python 등 패키지를 이용해 보다 쉽게 사용하는 방법 구글링을 통해 살펴보면 최근에는 pybind11을 많을 쓰는 것을 알 수 있다. pybind11을 쓰기 위해서는 C++ 11을 지원해야 한다. pybind11 참고 사이트 https://github.com/pybind/pybind11 https://pybind11.readthedocs.io/en/stable/ Visual Studio에서 설명된 pybind11 pybind11 설치 > pip install pybind11 설치한 후 다음을 통해 설치된 헤더 파일 경로를 확인할 수 있다. >python -m pybind11 --includes -IC:\Python\Python38\Include -IC:\Python\Python38\lib\site-packages\pybind11\include 위에서 -I를 뺀 경로가 C++ 코드 컴파일 시 필요한 인클루드 경로이다. Visual Studio 2019에서 빈 프로젝트를 만든다. 프로젝트 속성 설정 추가 포함 디렉터리 : C:\Python\Python38\Include;C:\Python\Python38\lib\site-packages\pybind11\include 추가 라이브러리 디렉터리 : C:\Python\Python38\libs 추가 종속성 : python38.lib 참고 : ``` 8.1 기본 Python Embedding 기본 방법 준비 CMake를 이용한 간단한 embedding 프로그램을 만들어 본다. 아래와 같이 준비한다. HelloEmbed/main.cpp CMakeLIsts.txt #define PY_SSIZE_T_CLEAN #include <Python.h> int main(int argc, char *argv[]) { wchar_t *program = Py_DecodeLocale(argv[0], NULL); if (program == NULL) { fprintf(stderr, "Fatal error: cannot decode argv[0]\n"); exit(1); } Py_SetProgramName(program); /* optional but recommended */ Py_Initialize(); PyRun_SimpleString("from time import time, ctime " "print('Today is', ctime(time()))\n"); if (Py_FinalizeEx() < 0) { exit(120); } PyMem_RawFree(program); return 0; } cmake_minimum_required(VERSION 3.12) project(HelloEmbed) # set(Python_ROOT "/path/to/python") # Set the path to the desired Python installation # Find the Python package find_package(Python REQUIRED COMPONENTS Development) set(SOURCES main.cpp ) add_executable(HelloEmbed ${SOURCES}) target_include_directories(HelloEmbed PRIVATE ${Python_INCLUDE_DIRS}) target_li 외부 CMake 실행 아래와 같이 HelloEmbed> mkdir build HelloEmbed> cd build HelloEmbed/build> cmake .. 이제 build 디렉터리 내에 *.sln 파일을 열어서 컴파일한다. Visual Studio CMake Integration 적용 HelloEmbed를 폴더 열기로 열고 CMake 설정하고, 컴파일한다. 기타 사항 Debug 버전으로 컴파일하기 위해서는 Python 인스톨 시 디버그 라이브러리를 인스톨해야 한다. numpy 등과 같은 외부 패키지를 사용할 때는 debug 버전이 안된다. 8.2 배포 Embedable package란 파이썬 공식 사이트(www.python.org)에서는 windows 플랫폼을 대상으로 full installer 이외에 embeddable package를 제공한다. 파이썬 3.5부터 도입된 것이데 파이썬을 구동시키는 최소한의 것들을 한 개의 zip 파일로 묶어 제공하는 배포본이다. 직접 최종사용자가 접근해서 사용하기보다는 파이썬을 다른 프로그램의 일부로 사용하는 경우를 위해서 제공되는 것이다. python-3.11.6-amd64.exe : 윈도우즈 64비트 용 full installer python-3.11.6-embed-amd64.zip : 윈도우즈 64비트 용 embedable package Embeddable package의 압축을 풀게 되면, 다음과 같이 python3x.dll, python.exe 등과 감께 zip 파일에. pyc를 담고 있다. 정규 파이썬에서 패키지가 저장되는 Lib 대신 이들 정보가 python310.zip에 압축되어 있다. 배포할 때는 이 패키지를 sub-directory에 넣어 배포하도록 한다. 테스트해보기 Embeddable Package의 압축을 푼 후 그 폴더에서 embed_python_folder> python >>> import numpy --> numpyd아 없으므로 error >>> exit() --> 에러 >>> import sys >>> sys.exit() --> 이제 제대로 빠져나옴 embed_python_folder> 아래를 실행하면 디폴트 모듈 경로가 일반 python과 다름을 알 수 있는데 working directory가 자동으로 경로에 포함되지 않는다는 점이다. >>> import sys >>> sys.path ['E:\\TestPython\\embed\\python311.zip', 'E:\\TestPython\\embed'] Embeded python에는 압축 해제된 경로에 있는 python3x._pth 파일에 경로 정보를 읽어오게 된다. python311.zip # Uncomment to run site.main() automatically #import site 만약 python3x._pth 없다면 컴퓨터에 인스톨 된 python처럼 경로를 읽게 된다(이 경우 버전이 맞지 않으면 큰 문제가 발생함). 다시 말하면 python3x._pth이 존재하는 한 working directory를 모듈 찾기 경로에 넣을 수는 없다. 추가 패키지 인스톨 정규 배포 본과 달리 pip가 없으몰 pip부터 깔아야 한다. pip 사이트(https://pip.pypa.io/en/stable/installation/ )에서 get-pip.py 다운로드 후 아래를 실행 embedded_python> python get-pip.py 위를 실행하면 Lib, Scripts 폴더가 추가로 생긴다. python3x._pth에서 Lib\site-packages를 추가한다. python311.zip # Uncomment to run site.main() automatically #import site Lib\site-packages 주의 > pip ... 등과 같이 사용하면 시스템에 깔린 python과 연결된 pip가 실행되므로 반드시 > python -m pip ... 등으로 실행 필요 패키지 인스톨 다은은 numpy, scipy, matplotlib, pandas, openpyxl, h5py을 사용할 수 있도록 패키지를 설치한 예이다. embed> python -m pip install numpy embed> python -m pip install scipy embed> python -m pip install matplotlib embed> python -m pip install pandas embed> python -m pip install openpyxl embed> python -m pip install h5py embed> python -m pip install PyQt5 다음은 테스트이다. embed> python >>> import numpy as np >>> import matplotlib.pyplot as plt >>> x = np.arnge(0,10,0.1) >>> y = np.sin(y) >>> plt.plot(x, y) >>> plt.show() >>> matplotlib 백엔드 수정 matplotlib 을 사용할 필요가 있는 경우 이를 상업적으로 배포하려면 backend로 사용하는 PyQt5를 TkInter로 변경해야 한다. numpy, scipy, matplotlib. pandas, openpyxl, h5py의 설치는 이전과 동일하다. embed> python -m pip install numpy embed> python -m pip install scipy embed> python -m pip install matplotlib embed> python -m pip install pandas embed> python -m pip install openpyxl embed> python -m pip install h5py TkInter는 embeddable package에 포함되지 않고, pip로 인스 톨리 불가능하다. 방법은 embeddable package와 동일한 full installation에서 직접 파일을 복사하여 해결한다. FullInstall/tcl --> Embeddable/tcl [폴더] FullInstall/Lib/tkinter --> Embeddable/tkinter [폴더] FullInstall/DLLs/tcl86t.dll --> Embeddalbe/tcl86t.dll [파일] FullInstall/DLLs/tk86t.dll --> Embeddalbe/tk86t.dll [파일] FullInstall/DLLs/_tkinter.pyd --> Embeddalbe/_tkinter.pyd [파일] 다음은 tkinter 테스트 코드이다. import tkinter root = tkinter.Tk() root.title("TEST") root.mainloop() 다음으로 다음과 같이 Matplotlib 백엔드를 변경해 준다. embed/Lib/site-packages/matplotlib/mpl-data/matplotlibrc ... #backend: TkAgg ... bokeh bokeh만 인스톨하면, numpy, pandas는 깔림. > python -m pip install bokeh<|endoftext|>

전문분야 텍스트 ### 제목: 실용 파이썬 프로그래밍: 프로그래밍 유경험자를 위한 강좌 ### 본문: <NAME>의 《 Practical Python Programming 》을 번역한 책입니다. 궁금한 점은 댓글을 남겨 주시고, 챗봇에게도 물어보세요. 파이썬 알려주는 봇 2(GPT-3.5 Turbo) 머리말 이 책은 데이비드 M. 비즐리(David Beazley)의 《 Practical Python Programming 》을 번역한 것으로, 다른 프로그래밍 언어를 접해보신 분이 파이썬을 빠르게 익힐 수 있게 구성돼 있습니다. 용어 선택에 도움 주신 분들께 감사드립니다('리스트 컴프리 헨 션', '제너레이터'). 환영한다! 내가 파이썬(Python)을 거의 25년 전에 처음 배웠을 때, 온갖 지저분한 프로젝트의 생산성을 높일 수 있다는 것에 충격을 받았다. 그로부터 십 년이 흐른 뒤에는 다른 사람들에게 그러한 재미를 가르치게 됐다. 2007년부터 지금까지 400개가 넘는 그룹에 이 코스를 가르쳤다. 트레이더, 시스템 관리자, 천문학자, 팅커러, 심지어 화성에 로버를 착륙시키는 데 참여한 수백 명의 로켓 과학자가 이 코스를 들었다. 이제 이 코스에 크리에이티브 커먼즈 라이선스를 적용하게 되어 기쁘다. 함께 즐기자! 깃허브 페이지 | 깃허브 저장소. --David Beazley (https://dabeaz.com), @dabeaz 이것은 무엇인가? 이 자료는 기업 트레이닝과 전문적인 개발을 위한, 강사가 이끄는 파이썬 교육 코스의 핵심이다. 2007년부터 지속적으로 개발했으며 실제 교재로 사용하며 검증을 거쳤다. 이 코스를 가르치는 데 보통 사나흘이 걸리며 시간으로는 25~35시간의 강도 높은 교육이 필요하다. 또한, 약 130 가지 코딩 실습을 완료해야 한다. 대상 독자 이 코스의 수강생은 전문적인 과학자, 기술자, 프로그래머로 최소 한 가지 이상의 프로그래밍 언어에 경험이 있어야 한다. 파이썬에 대한 사전 지식은 필요하지 않지만, 일반적인 프로그래밍 주제에 대한 지식이 있다고 가정한다. 참가자 대부분에게 이 코스는 도전적일 것이다. 파이썬 프로그래밍에 어느 정도 경험이 있다 하더라도 그렇다. 학습 목표 이 코스의 목표는 파이썬 프로그래밍의 기초를 다루는 것이며 스크립트 작성, 데이터 처리, 프로그램 조직화에 중점을 둔다. 이 코스를 마칠 무렵에는 유용한 파이썬 프로그램을 스스로 작성하거나 동료가 작성한 파이썬 코드를 이해하고 수정할 수 있게 된다. 요구사항 이 코스를 마치기 위해 기본적인 파이썬 3.6 이상의 버전만 있으면 된다. 이 코스는… 이 코스는 초보자에게 컴퓨터 프로그래밍을 가르치는 것이 아니다. 학습자가 다른 프로그래밍 언어나 파이썬 자체에 경험이 있을 것으로 가정한다. 또한, 이 코스는 웹 개발을 다루지 않는다. 웹 개발은 전혀 다른 종류의 서커스다. 그렇지만, 이 서커스를 고집하더라도 흥미로운 활동을 볼 수 있다. 다만 동물이 나오지 않을 뿐이다. 이 코스는 백만 줄짜리 파이썬 애플리케이션을 작성하거나 유지하는 소프트웨어 기술자를 위한 것이 아니다. 나는 그런 프로그램을 작성하지도 않으며, 파이썬을 사용하는 기업 대부분은 그런 식으로 하지 않는다. 어서 지워라! 커뮤니티 논의 이 코스에 대해 의논하고 싶은가? Gitter에서 대화에 참여하라. 개별적인 응답을 약속할 수 없지만, 다른 사람들이 도와줄지 모른다. 감사의 말 Llorenç Muntaner는 이 코스의 내용을 애플 키노트에서 이 온라인 문서로 변환하는 데 중요한 역할을 했다. 지난 12년 동안 다음과 같은 여러 강사들이 이 코스를 한 번 이상 발표했다(알파벳순). Ned Batchelder, Juan Pablo Claude, Mark Fenner, Michael Foord, Matt Harrison, Raymond Hettinger, Daniel Klein, Travis Oliphant, James Powell, Michael Selik, Hugo Shi, Ian Stokes-Rees, Yarko Tymciurak, Bryan Van de ven, Peter Wang, Mark Wiebe. 이 코스에 참가한 수천 명의 수강생에게, 의견과 논의를 통해 성공적인 코스를 만드는 데 많은 도움을 준 것에 대해 감사한다. 질문과 답변 질문: 비디오가 있나? 없다. 이 코스는 당신이 직접 파이썬 코드를 작성하는 것이지, 다른 사람이 하는 것을 구경하는 것이 아니다. 질문: 코스의 라이선스는? Practical Python Programming은 크리에이티브 커먼즈 저작자 표시-동일 조건 변경 허락 4.0 국제(Attribution ShareAlike 4.0 International) 라이선스가 적용된다. 질문: 이 자료를 가지고 파이썬 코스를 가르쳐도 되나? 그렇다. 단, 저작자를 표시해야 한다. 질문: 2차 저작물을 만들어도 되나? 그렇다. 단, 같은 라이선스를 적용하고 저작자 표시를 해야 한다. 질문: 다른 나라말로 번역해도 되나? 그렇다. 그렇게 해주면 정말 좋을 것이다. 완료하면 링크를 보내 달라. 질문: 이 코스의 라이브 방송을 하거나 영상을 만들어도 되나? 좋다! 그 과정에서 파이썬을 많이 배울 수 있다. 질문: 왜 특정 주제를 다루지 않는가? 사나흘 만에 다루기에는 분량이 너무 많다. 여기서 다루지 않았다면, 이미 시도해 봤지만 사람들이 머리가 터져버렸거나 이 코스에서 다룰 만한 시간이 부족해서 그런 것이다. 또한, 이것은 교육 코스이지 파이썬 레퍼런스 매뉴얼이 아니다. 질문: 풀(pull) 요청을 받나? 이슈 트래커를 통한 버그 리포트는 환영한다. 특별한 경우 외에 풀 요청은 수락하지 않는다. 이슈를 먼저 등록해 달라. 실습 준비 Practical Python Programming 코스에 온 것을 환영한다! 이 페이지는 코스 환경 구성과 준비물에 대한 중요 정보를 담고 있다. 소요 시간 이 코스는 강사가 3~4일 동안 가르치는 것으로 설계했다. 이 코스를 완전히 마치는 데 최소 25~35 시간을 들일 것으로 계획해야 한다. 참가자 대부분에 있어, 해답 코드(아래를 참조)를 보지 않고 연습 문제를 푸는 것이 만만치 않았다. 준비 및 파이썬 설치 기본적인 Python 3.6 또는 상위 버전만 있으면 된다. 운영 체제, 편집기, IDE, 기타 파이썬 관련 도구는 필요하지 않다. 서드 파티에 의존하지 않는다. 따라서, 파일에서 데이터를 읽는 데 필요한 스크립트와 간단한 프로그램을 작성하는 법이 이 코스에 포함된다. 그러므로 파일을 다루기 쉬운 환경을 준비해야 한다. 편집기에서 파이썬 프로그램을 작성하고 셸/터미널에서 프로그램을 실행할 수 있어야 한다. 주피터 노트북(Jupyter Notebook)과 같이 좀 더 상호작용적인 환경을 사용하기를 원할 수도 있지만, 권장하지 않는다! 주피터 노트북 같은 것은 실험에 매우 유용하지만, 이 코스에서 가르치는 개념 중 많은 부분이 프로그램의 조직화(organization)와 관련된다. 여러 파일에 걸쳐 함수, 모듈, 임포트 문을 사용하며 프로그램 리 팩터링 작업을 하게 된다. 내 경험상, 주피터 노트북 등에서는 그런 작업을 재현하기 어렵다. 저장소를 복제하기(Forking/Cloning) 이 코스를 수강할 준비로, 깃허브 https://github.com/dabeaz-course/practical-python 저장소를 포크 할 것을 권장한다. 그런 다음, 다음 명령으로 로컬 머신에 클론 한다. bash % git clone https://github.com/yourname/practical-python bash % cd practical-python bash % 모든 작업을 practical-python/ 디렉터리에서 수행하라. 포크 한 저장소에 스스로 작성한 코드를 커밋 하면, 코드를 한곳에 모아둘 수 있고, 코스를 마쳤을 때 멋진 기록으로 남을 것이다. 포크 하는 것이 내키지 않거나 깃허브 계정이 없다면, 다음 명령으로 이 코스의 디렉터리를 여러분의 머신에 클론 해도 된다. bash % git clone https://github.com/dabeaz-course/practical-python bash % cd practical-python bash % 단, 이 경우는 여러분이 작성한 코드를 로컬 머신 외에는 커밋 할 수 없다. 디렉터리 구조 모든 코딩 작업은 Work/ 디렉터리에서 수행하라. 이 디렉터리에는 Data/ 디렉터리가 있다. Data/ 디렉터리에는 이 코스에서 사용하는 여러 가지 데이터 파일과 스크립트가 있다. Data/에 있는 파일을 빈번하게 사용하게 된다. 코스의 연습 문제는 Work/ 디렉터리에 프로그램이 있다고 가정한다. 학습 순서 교재는 섹션 1부터 차례대로 완료해야 한다. 연습 문제는 이전 섹션의 코드를 기반으로 한다. 기존 코드를 조금씩 리 팩터링 하는 연습이 많다. 해답 코드 연습 문제의 완전한 해답 코드가 Solutions/ 디렉터리에 있다. 힌트가 필요할 때는 자유롭게 살펴보라. 그러나 최대의 학습효과를 위해서는 스스로 코드를 작성하려고 노력하라. 1. 파이썬 소개 첫 섹션의 목표는 파이썬 기초를 소개하는 것이다. 작은 프로그램을 편집하고, 실행하고, 디버그 하는 법을 배운다. 끝으로, CSV 데이터 파일을 읽어 간단한 계산을 하는 짧은 스크립트를 작성한다. 1.1 파이썬 소개 1.2첫 번째 프로그램 1.3 숫자 1.4 문자열(string) 1.5 리스트(list) 1.6 파일 1.7 함수 1.1 파이썬 파이썬은 무엇인가? 파이썬은 인터프리터 방식의 고수준 프로그래밍 언어다. 파이썬은 펄(Perl), 티클(Tcl), 루비(Ruby) 같은 "스크립팅 언어"로 분류된다. 파이썬의 구문은 C 프로그래밍의 요소에 어느 정도 영향을 받았다. 파이썬은 1990년 무렵 Guido van Rossum이 창시했으며 영국의 코미디 그룹 Monty Python에서 이름을 땄다. 파이썬을 어디서 구할 수 있나? Python.org에서 파이썬을 구할 수 있다. 이 코스를 수강하는 데는 기본 설치로 충분하다. 파이썬 3.6 또는 그 이상의 버전을 설치할 것을 권장한다. 강의 노트와 연습 문제 해답은 파이썬 3.6을 사용했다. 파이썬을 왜 만들었나? 파이썬의 창시자 가라사대, Amoeba [운영 체제] 프로젝트에 사용할 고수준 언어가 필요하다고 생각한 것이 파이썬을 처음 만들게 된 동기다. 시스템 관리 유틸리티를 C로 작성하는 것은 시간이 너무 많이 걸린다는 것을 깨달았다. 더구나 본 셸(Bourne shell)로 작업하는 것도 몇 가지 난점이 있었다. ... 그래서 C와 셸의 중간쯤 되는 언어를 만들기로 했다. Guido van Rossum 내 컴퓨터의 어디에 파이썬이 있나? 실행하는 환경에 따라 다르지만, 파이썬은 일반적으로 터미널 또는 명령 셸에서 실행되는 프로그램으로서 설치된다. 터미널에서 python을 실행하면 다음과 같이 작동한다. bash $ python Python 3.8.1 (default, Feb 20 2020, 09:29:22) [Clang 10.0.0 (clang-1000.10.44.4)] on darwin Type "help", "copyright", "credits" or "license" for more information. >>> print("hello world") hello world >>> 셸이나 터미널을 처음 사용한다면 일단 멈추고, 그에 대한 간단한 자습서를 본 다음에 돌아오기 바란다. 셸이 아닌 환경에서 파이썬 코딩을 할 수 있는 것이 많이 있지만, 터미널에서 파이썬을 실행, 디버그, 상호작용할 수 있어야 더 나은 파이썬 프로그래머가 될 수 있다. 이것이 파이썬의 기본 환경이기 때문이다. 셸이나 터미널에서 파이썬을 사용할 줄 알면 다른 환경에서도 사용할 수 있다. 연습 문제 연습 문제 1.1: 파이썬을 계산기로 사용하기 컴퓨터에서 파이썬을 실행해 다음 문제를 풀어보자. 행운아 래리는 구글 주식을 주당 235.14 달러에 75주 샀다. 오늘 구글 주가는 711.25 달러다. 파이썬의 상호작용 모드를 계산기처럼 사용해, 래리가 주식을 모두 팔면 얼마를 벌 수 있는지 계산해 보자. >>> (711.25 - 235.14) * 75 35708.25 >>> 전문가의 팁: 마지막 계산 결과를 사용하려면 밑줄(_) 변수를 사용한다. 예를 들어, 사악한 주식 중개인이 20%를 수수료로 가져가는 경우 래리는 얼마의 수익을 얻는가? >>> _ * 0.80 28566.600000000002 >>> 연습 문제 1.2: 도움말 help() 명령을 사용해 abs() 함수에 대한 도움말을 출력해 보자. 그런 다음 help()를 사용해 round() 함수의 도움말도 출력하자. 그냥 아무 값 없이 help()라고 입력하면 상호작용적인 도움말이 나타난다. 한 가지 주의할 점으로, 파이썬의 for, if, while 같은 기본 문장에 대해 help()를 사용할 때 help(for)와 같이 입력하면 구문 오류가 발생한다. 그 대신 따옴표를 써서 help("for")를 실행해 보라. 그렇게 해도 도움말을 볼 수 없으면 인터넷에서 검색하라. 심화: http://docs.python.org에서 abs() 함수의 문서를 찾아보라(힌트: 빌트인 함수 관련 라이브러리 레퍼런스에 있다). 연습 문제 1.3: 잘라 붙이기 이 코스는 전통적인 웹 페이지로 구성했으며, 상호작용적인 파이썬 코드 예제를 직접 손으로 타이핑해 볼 것을 권장한다. 파이썬을 처음으로 배운다면 이와 같이 "천천히" 학습하는 것을 권장한다. 속도를 늦추고 직접 입력하면서 언어를 음미하고, 무엇을 하고 있는지 스스로 생각할 시간을 갖는 것이 좋다. 예제 코드를 "복사해서 붙여넣기"해야 한다면, >>> 프롬프트 뒤부터 선택하되 공백 행이나 다음 번 >>> 프롬프트(두 가지 중 먼저 나오는 것)를 넘어가지 않게 한다. 브라우저에서 "복사"를 선택하고, 파이썬 창으로 가서 "붙여넣기"를 선택해 파이썬 셸에 복사한다. 붙여 넣은 후에 "엔터" 키를 눌러야 실행된다. 이 세션에서 파이썬 구문을 복사해서 붙여 넣어 실행해 보라. >>> 12 + 20 32 >>> (3 + 4 + 5 + 6) 18 >>> for i in range(5): print(i) 1 3 >>> 경고: 기본 파이썬 셸에 파이썬 명령(>>> 이후의 문장)을 동시에 여러 개 붙여 넣는 것은 불가능하다. 각 명령을 한 번에 하나씩 붙여 넣어라. 이 방법으로 해봤으니, 앞으로 이 수업에서는 코드를 복사해서 붙여 넣지 말고 천천히 타이핑해야 함을 명심하자. 연습 문제 1.4: 버스가 언제 오려나? 좀 더 수준 높은 것을 시도해 보자. 시카고의 한 버스 정류장(Clark & Balmoral)에서 북쪽으로 가는 CTA 22번 버스를 기다리는 사람들이 얼마나 더 기다려야 하는지 알아보자. >>> import urllib.request >>> u = urllib.request.urlopen('http://ctabustracker.com/bustime/map/getStopPredictions.jsp?stop=14791&route=22') >>> from xml.etree.ElementTree import parse >>> doc = parse(u) >>> for pt in doc.findall('.//pt'): print(pt.text) 6 MIN 18 MIN 28 MIN >>> 그렇다. 방금 단 6줄의 코드로 웹페이지 하나를 다운로드해 XML 문서를 파싱하고 유용한 정보를 추출했다. 이 데이터는 실제 웹사이트 http://ctabustracker.com/bustime/home.jsp에 제공된다. 다시 시도해 예상 시간이 바뀌는지 지켜보라. 참고: 이 서비스는 30분 내에 오는 버스의 도착 시간만 제공한다. 만약 당신이 다른 시간대에 살고 있어 시카고가 밤늦은 시간이라면 버스가 다니지 않아 출력이 없을 수도 있다. 위의 링크를 확인하라. 첫 번째 문장인 import urllib.request가 실패했다면, 아마 파이썬 2를 사용해서 그럴 것이다. 이 강좌는 파이썬 3.6 이후 버전을 사용한다. 필요하다면 https://www.python.org에서 다운로드하라. HTTP 프락시 서버가 필요한 작업 환경이라면 이 연습 문제를 풀기 위해 HTTP_PROXY 환경 변수를 설정해야 할 수도 있다. 예: >>> import os >>> os.environ['HTTP_PROXY'] = 'http://yourproxy.server.com' >>> 잘 안되더라도 걱정할 필요는 없다. 이 코스의 나머지 부분은 XML 파싱을 다루지 않는다. 1.2첫 번째 프로그램 이 섹션에서는 처음으로 파이썬 프로그램을 작성해 인터프리터로 실행하고, 기본적인 디버깅을 해본다. 파이썬 실행하기 파이썬 프로그램은 항상 인터프리터에서 실행된다. 인터프리터는 "콘솔 기반" 애플리케이션으로, 명령 셸에서 실행된다. python3 Python 3.6.1 (v3.6.1:69c0db5050, Mar 21 2017, 01:21:04) [GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin Type "help", "copyright", "credits" or "license" for more information. >>> 전문 프로그래머는 이런 방식으로 인터프리터를 사용하는 데 전혀 어려움이 없겠지만, 초보자에게는 그리 친화적이지 않다. 다른 인터페이스를 통해 파이썬을 사용할 수 있는 환경도 있다. 그것도 좋지만, 파이썬 터미널을 실행하는 법을 배워두면 쓸모가 있다. 상호작용 모드 파이썬을 시작할 때 상호작용(interactive) 모드를 선택해 실험할 수 있다. 문장을 타이핑해서 즉시 실행해 볼 수 있다. 편집/컴파일/실행/디버그 사이클이 존재하지 않는다. >>> print('hello world') hello world >>> 37*42 1554 >>> for i in range(5): ... print(i) ... 1 3 >>> 이것을 읽기-평가-프린트-루프(read-eval-print-loop, REPL)라 한다. REPL은 디버그와 탐색에 매우 유용하다. 잠깐! 파이썬을 상호작용 모드로 사용하는 법을 모르겠으면 진도를 나가지 말고 사용법부터 익혀라. IDE를 사용한다면 메뉴 옵션이나 다른 창에 숨겨져 있을 것이다. 이 코스는 학습자가 인터프리터와 상호작용할 수 있을 것으로 가정한다. REPL을 좀 더 살펴보자. >>>은 문장을 새로 시작하는 인터프리터 프롬프트다. ...은 문장을 이어가는 인터프리터 프롬프트다. 타이핑을 마치려면 공백 행을 입력한다. 그러면 입력한 것이 실행된다. ... 프롬프트는 환경에 따라 보일 수도 있고 그렇지 않을 수도 있다. 이 코스는 코드 예제를 쉽게 복사/붙여넣기 할 수 있게 이것을 공백으로 처리한다. 밑줄(_)은 최종 결과를 저장한다. >>> 37 * 42 1554 >>> _ * 2 3108 >>> _ + 50 3158 >>> 단, 상호작용 모드에서만 이렇게 작동한다. 프로그램에 _를 사용하면 안 된다. 프로그램 작성하기 프로그램은. py 파일에 저장한다. # hello.py print('hello world') 선호하는 텍스트 편집기를 사용해 이러한 파일을 만들 수 있다. 프로그램 실행하기 프로그램을 작성했으면, 터미널에서 python 명령을 함께 사용해 실행한다. 예를 들어, 유닉스(Unix) 명령행에서는 다음과 같이 실행한다. bash % python hello.py hello world bash % 윈도(Windows) 셸에서는 다음과 같이 실행한다. C:\SomeFolder>hello.py hello world C:\SomeFolder>c:\python36\python hello.py hello world 참고: 윈도에서는 파이썬 인터프리터의 전체 경로를 지정해야 할 수도 있다(예: c:\python36\python). 그렇지만, 파이썬을 일반적인 방식으로 설치했다면 hello.py와 같이 프로그램 이름만 타이핑해도 실행할 수 있을 것이다. 예제 프로그램 다음 문제를 풀어 보자. 어느 날 아침, 당신은 시카고의 시어스 타워(Sears tower) 근처를 거닐다가 보도에 1 달러 지폐를 한 장 올려뒀다. 그 후 매일 외출할 때마다 그 위에 지폐를 얹어 탑을 쌓으며, 높이는 매일 두 배로 불어난다. 돈으로 쌓은 탑의 높이가 시어스 타워의 높이와 같아지려면 시간이 얼마나 걸릴까? 풀이: # sears.py bill_thickness = 0.11 * 0.001 # 지폐의 두께(0.11 mm)를 미터로 환산 sears_height = 442 # 높이(미터) num_bills = 1 day = 1 while num_bills * bill_thickness < sears_height: print(day, num_bills, num_bills * bill_thickness) day = day + 1 num_bills = num_bills * 2 print('Number of days', day) print('Number of bills', num_bills) print('Final height', num_bills * bill_thickness) 실행하면 다음과 같이 출력된다. bash % python3 sears.py 1 1 0.00011 2 2 0.00022 3 4 0.00044 4 8 0.00088 5 16 0.00176 6 32 0.00352 ... 21 1048576 115.34336 22 2097152 230.68672 Number of days 23 Number of bills 4194304 Final height 461.37344 이 프로그램에서 파이썬의 핵심 개념을 배울 수 있다. 문장(Statement) 파이썬 프로그램은 일련의 문장으로 이뤄진다. a = 3 + 4 b = a * 2 print(b) 각 문장은 개행(newline)으로 끝난다. 파일의 끝에 도달할 때까지 한 문장씩 실행된다. 부연 설명 주석은 실행되지 않는 텍스트다. a = 3 + 4 # 이것이 주석이다 b = a * 2 print(b) 주석은 #으로 표시하며, 해당 행의 끝까지다. 변수(Variable) 변수는 값(value)의 이름(name)이다. a에서 z까지(소문자 및 대문자)를 사용할 수 있다. 밑줄(_) 문자도 사용할 수 있다. 숫자도 변수 명의 일부로 사용할 수 있지만, 변수 명의 첫 글자에는 숫자를 사용할 수 없다. height = 442 # 가능 _height = 442 # 가능 height2 = 442 # 가능 2height = 442 # 불가 타입(Type) 변숫값의 타입을 선언할 필요가 없다. 변수와 관련된 타입은 변수명이 아니라 오른쪽에 무엇이 오느냐에 따라 결정된다. height = 442 # 정수 height = 442.0 # 부동소수점 height = 'Really tall' # 문자열 파이썬은 동적으로 타입이 결정(dynamically typed) 된다. 프로그램이 실행됨에 따라 변수 "타입"이 무엇인지에 대한 인식이 달라질 수 있다. 타입은 현재 할당된 값이 무엇인지에 달렸다. 대소문자 구분 파이썬은 대문자와 소문자를 구별한다. 대문자와 소문자를 다른 글자로 간주한다. 다음 세 변수는 모두 서로 다르다. name = 'Jake' Name = 'Elwood' NAME = 'Guido' 언어의 키워드는 모두 소문자다. while x < 0: # OK WHILE x < 0: # 오류 루핑(Looping) while 문은 루프(loop)를 실행한다. while num_bills * bill_thickness < sears_height: print(day, num_bills, num_bills * bill_thickness) day = day + 1 num_bills = num_bills * 2 print('Number of days', day) while 아래에 들여 쓴 문장은 while 뒤에 오는 표현식이 true인 한 계속 실행된다. 들여 쓰기(Indentation) 들여 쓰기는 함께 있는 문장들의 그룹을 나타낸다. 다음 코드에서, while num_bills * bill_thickness < sears_height: print(day, num_bills, num_bills * bill_thickness) day = day + 1 num_bills = num_bills * 2 print('Number of days', day) 다음 문장들은 들여 쓰기가 같으므로 함께 묶여 반복적으로 수행된다. print(day, num_bills, num_bills * bill_thickness) day = day + 1 num_bills = num_bills * 2 그렇지만 마지막 행의 print() 문은 들여쓰기 하지 않았으므로 루프에 속하지 않는다. 빈 행은 가독성을 위한 것으로, 실행에는 영향을 주지 않는다. 들여쓰기 모범 사례(best practice) 탭(tab) 대신 공백(space)을 사용한다. 수준 당 4개의 공백을 사용한다. 파이썬 구문을 인식하는 편집기를 사용한다. 파이썬은 같은 블록 내의 들여 쓰기에 대해서만 일관적인 들여 쓰기를 요구한다. 예를 들어, 다음 코드는 오류를 일으킨다. while num_bills * bill_thickness < sears_height: print(day, num_bills, num_bills * bill_thickness) day = day + 1 # 오류 num_bills = num_bills * 2 조건(Conditional) if 문은 조건부 실행에 사용한다. if a > b: print('Computer says no') else: print('Computer says yes') 조건이 여러 개 있을 때는 elif를 사용해 추가로 검사할 수 있다. if a > b: print('Computer says no') elif a == b: print('Computer says yes') else: print('Computer says maybe') 프린팅(Printing) print 함수는 전달한 값을 가지고 단 일행의 텍스트를 생성한다. print('Hello world!') # 텍스트 'Hello world!'를 프린트 변수를 사용해 프린트할 수 있다. 변수명이 아니라 변숫값이 텍스트로 프린트된다. x = 100 print(x) # 텍스트 '100'을 프린트 복수의 값을 print에 전달하면 공백으로 구분되어 프린트된다. name = 'Jake' print('My name is', name) # 'My name is Jake'를 프린트 print()는 항상 끝에 개행을 넣는다. print('Hello') print('My name is', 'Jake') 위 코드는 다음과 같이 프린트한다. Hello My name is Jake 개행 문자를 프린트하고 싶지 않으면 다음과 같이 한다. print('Hello', end=' ') print('My name is', 'Jake') 위의 코드는 다음과 같이 프린트한다. Hello My name is Jake 사용자 입력 사용자가 타이핑한 입력의 행을 읽으려면 input() 함수를 사용한다. name = input('Enter your name:') print('Your name is', name) input은 사용자에게 프롬프트를 프린트하고 사용자의 응답을 반환한다. 이것은 작은 프로그램, 연습 문제, 간단한 디버깅 등에 적합하다. 실제 프로그램에서는 그리 많이 사용하지 않는다. pass 문 때로는 빈 코드 블록을 지정하고 싶을 때가 있다. 이때 사용할 수 있는 키워드가 pass다. if a > b: pass else: print('Computer says false') 이것을 "no-op" 문이라고도 한다. 아무 일도 하지 않는다. 나중에 문장을 작성할지도 모르는 자리를 표시하는 역할이다. 연습 문제 파이썬 파일을 작성해 실행하는 연습 문제를 풀어보자. 지금부터 모든 연습 문제는 practical-python/Work/ 디렉터리에 파일을 편집하는 것으로 가정한다. 적절한 위치를 찾는 것을 돕기 위해, 적당한 파일명으로 빈 파일을 만들어두었다. Work/bounce.py 파일을 찾아보라. 연습 문제 1.5: 얌체공 고무공을 100미터 높이에서 떨어뜨린다. 이 공은 땅에 닿을 때마다 원래 높이의 3/5만큼 튀어 오른다. 공이 열 번 튈 동안, 그때마다 높이를 나타내는 테이블을 프린팅 하는 프로그램 bounce.py를 작성하라. 프로그램은 다음과 같은 테이블을 만들어야 한다. 1 60.0 2 36.0 3 21.599999999999998 4 12.959999999999999 5 7.775999999999999 6 4.6655999999999995 7 2.7993599999999996 8 1.6796159999999998 9 1.0077695999999998 10 0.6046617599999998 참고: round() 함수를 사용해 출력을 정돈할 수 있다. 소수점 아래 네 자리까지 출력해 보라. 1 60.0 2 36.0 3 21.6 4 12.96 5 7.776 6 4.6656 7 2.7994 8 1.6796 9 1.0078 10 0.6047 연습 문제 1.6: 디버깅 다음 코드는 시어스 타워 문제에서 가져왔다. 이 코드에는 버그가 있다. # sears.py bill_thickness = 0.11 * 0.001 # 미터(0.11 mm) sears_height = 442 # 높이(미터) num_bills = 1 day = 1 while num_bills * bill_thickness < sears_height: print(day, num_bills, num_bills * bill_thickness) day = days + 1 num_bills = num_bills * 2 print('Number of days', day) print('Number of bills', num_bills) print('Final height', num_bills * bill_thickness) 위의 코드를 복사해 sears.py라는 이름의 새 프로그램에 붙여 넣어라. 코드를 실행하면 다음과 같은 오류 메시지가 뜨며 프로그램이 충돌한다(crash). Traceback (most recent call last): File "sears.py", line 10, in <module> day = days + 1 NameError: name 'days' is not defined 오류 메시지를 읽는 것은 파이썬 코드에서 중요한 부분이다. 프로그램이 충돌한다면 트레이스 백(traceback) 메시지에서 마지막 행을 읽으면 프로그램이 충돌한 진짜 이유를 알 수 있다. 그 위에는 소스 코드의 일부가 있으며 파일명과 행 번호가 있다. 코드의 몇 번째 행에 오류가 있는가? 무엇이 잘못되었는가? 오류를 수정하라 프로그램을 성공적으로 실행하라 1.3 숫자 이 섹션은 수학 계산을 논의한다. 숫자 타입 파이썬에는 네 가지 숫자 타입이 있다. 불린 정수 부동소수점 복소수(허수) 불린(bool) 불린 값은 True와 False 중 하나다. a = True b = False 수학 계산에서는 각각 1과 0으로 평가한다. c = 4 + True # 5 d = False if d == 0: print('d is False') 그렇지만, 코드를 이런 식으로 작성하지 말자. 이상하니까. 정수(int) 임의의 크기에 밑수(base)가 있는 부호 있는(signed) 값이다. a = 37 b = -299392993727716627377128481812241231 c = 0x7fa8 # 16진수 d = 0o253 # 8진수 e = 0b10001111 # 2진수 일반적인 연산: x + y 덧셈 x - y 뺄셈 x * y 곱셈 x / y 나눗셈(부동소수점수를 생성) x // y Floor 나눗셈(정수를 생성) x % y 모듈로(나머지) x ** y 제곱 x << n 왼쪽으로 비트 시프트(shift) x >> n 오른쪽으로 비트 시프트 x & y AND 비트 연산 x | y OR 비트 연산 x ^ y XOR 비트 연산 ~x NOT 비트 연산 abs(x) 절댓값 부동소수점(float) 십진수 또는<NAME> 표기법을 사용해 부동소수점수를 지정한다. a = 37.45 b = 4e5 # 4 x 10**5 또는 400,000 c = -1.345e-10 부동소수점은 네이티브 CPU 표현 IEEE 754를 사용해 배정밀도(double precision)로 나타낸다. C 프로그래밍 언어의 double 타입과 같다. 정밀도는 17 자리 -308에서 308까지 부동소수점수를 십진수로 나타낼 경우 부정확함에 유의하라. >>> a = 2.1 + 4.2 >>> a == 6.3 False >>> a 6.300000000000001 >>> 이것은 파이썬 이슈가 아니라, CPU의 부동소수점 하드웨어 때문이다. 일반적인 연산: x + y 덧셈 x - y 뺄셈 x * y 곱셈 x / y 나눗셈 x // y Floor 나눗셈 x % y 모듈로 x ** y 제곱 abs(x) 절댓값 비트 연산을 제외하면, 이 연산들은 정수 연산과 같다. 추가적인 수학 함수가 math 모듈에 있다. import math a = math.sqrt(x) b = math.sin(x) c = math.cos(x) d = math.tan(x) e = math.log(x) 비교 숫자에 대해 다음과 같은 비교/관계 연산을 할 수 있다. x < y 작음 x <= y 작거나 같음 x > y 큼 x >= y 크거나 같음 x == y 같음 x != y 같지 않음 다음을 사용해 복잡한 불린 표현식을 만들 수 있다. and, or, not 예: if b >= a and b <= c: print('b is between a and c') if not (b < a or b > c): print('b is still between a and c') 숫자 변환하기 타입명을 사용해 숫자를 변환할 수 있다. a = int(x) # x를 int로 변환 b = float(x) # x를 float로 변환 한번 해보자. >>> a = 3.14159 >>> int(a) >>> b = '3.14159' # 숫자를 포함하는 문자열을 가지고도 가능 >>> float(b) 3.14159 >>> 연습 문제 참고: 연습 문제는 practical-python/Work 디렉터리에서 작업하는 것으로 가정한다. mortgage.py 파일을 찾아보라. 연습 문제 1.7: 데이브의 주택 담보 대출 데이브는 500,000 달러의 30년 고정 이율 주택 담보 대출(mortgage)을 받기로 결정했다. 이율은 5%이고 매달 납부할 금액은 2684.11 달러다. 다음은 대출 기간 동안 지불할 총액을 계산하는 프로그램이다. # mortgage.py principal = 500000.0 rate = 0.05 payment = 2684.11 total_paid = 0.0 while principal > 0: principal = principal * (1+rate/12) - payment total_paid = total_paid + payment print('Total paid', total_paid) 이 프로그램을 입력해 실행하라. 답이 966,279.6로 나와야 한다. 연습 문제 1.8: 추가 납입 데이브가 처음 12개월 동안 매달 1000 달러를 추가로 납입한다면 어떻게 될까? 이 추가 납입금 계산을 포함하도록 프로그램을 수정해 총 납입금액과 소요 월수를 프린트해 보자. 프로그램을 실행했을 때 총 납입금이 929,965.62, 소요 월수는 342로 나와야 한다. 연습 문제 1.9: 추가 납입금 계산기 추가 납입금을 일반적으로 다룰 수 있게 프로그램을 수정하자. 사용자가 다음 변수를 설정할 수 있게 한다. extra_payment_start_month = 61 extra_payment_end_month = 108 extra_payment = 1000 프로그램이 이 변숫값을 읽고 총 납입액을 계산하게 해 보자. 데이브가 대출 시작 5년 후부터 4년간 매달 1000 달러를 추가로 지불할 경우 총 납입액은 얼마인가? 연습 문제 1.10: 테이블 만들기 월수, 현재까지의 납부액, 남은 원금을 나타내는 테이블을 프린트하게 프로그램을 수정해 보라. 다음과 같이 출력한다. 1 2684.11 499399.22 2 5368.22 498795.94 3 8052.33 498190.15 4 10736.44 497581.83 5 13420.55 496970.98 ... 308 874705.88 3478.83 309 877389.99 809.21 310 880074.1 -1871.53 Total paid 880074.1 Months 310 연습 문제 1.11: 보너스 마지막 달에 초과 납부하는 금액이 생기지 않게 프로그램을 수정해 보라. 연습 문제 1.12: 미스터리 int()와 float()를 사용해 숫자를 변환할 수 있다. 예: >>> int("123") 123 >>> float("1.23") 1.23 >>> 그렇다면, 왜 다음과 같이 작동하는지 설명할 수 있는가? >>> bool("False") True >>> 1.4 문자열 이 섹션은 텍스트를 가지고 작업하는 법을 소개한다. 리터럴 텍스트(Literal Text) 표현 프로그램에서 문자열 리터럴은 따옴표를 사용한다. # 작은따옴표 a = 'Yeah but no but yeah but...' # 큰따옴표 b = "computer says no" # 따옴표 세 개 c = ''' Look into my eyes, look into my eyes, the eyes, the eyes, the eyes, not around the eyes, don't look around the eyes, look into my eyes, you're under. ''' 일반적으로 문자열은 한 줄을 넘어가지 않는다. 따옴표 세 개를 사용하면 모든 포매팅을 포함해 여러 행에 걸친 텍스트가 문자열이 된다. 작은따옴표(')와 큰따옴표(") 사이에 차이는 없다. 하지만, 문자열의 시작과 끝에 같은 종류의 따옴표를 사용해야 한다. 문자열 이스케이프 코드(escape code) 이스케이프 코드는 제어 문자나 키보드에서 타이핑하기 힘든 문자를 나타내는 데 사용한다. 이스케이프 코드의 예: '\n' 라인피드(Line feed) '\r' 캐리지 리턴(Carriage return) '\t' 탭(Tab) '\'' 작은따옴표(Literal single quote) '\"' 큰따옴표(Literal double quote) '\\' 백슬래시(Literal backslash) 문자열 표현 문자열의 각 문자는 내부적으로 유니코드(Unicode) 코드 포인트(code-point)로 저장된다. 다음과 같이 이스케이프 시퀀스(escape sequence)를 사용해 정확한 코드 포인트를 지정할 수 있다. a = '\xf1' # a = 'ñ' b = '\u2200' # b = '∀' c = '\U0001D122' # 낮은 음자리표 d = '\N{FOR ALL}' # d = '∀' 사용 가능한 전체 캐릭터 코드는 유니코드 문자 데이터베이스(Unicode Character Database)를 참조한다. 문자열 인덱싱(String Indexing) 문자열은 문자에 액세스함에 있어서 배열(array)과 비슷하게 작동한다. 0부터 시작하는 정수 인덱스(index)를 사용한다. 음수 인덱스는 문자열의 끝에서부터 상대적 위치를 가리킨다. a = 'Hello world' b = a[0] # 'H' c = a[4] # 'o' d = a[-1] # 'd'(문자열의 끝) 또한 콜론(:)으로 인덱스 범위를 지정함으로써 슬라이싱(부분 문자열을 선택) 할 수 있다. d = a[:5] # 'Hello' e = a[6:] # 'world' f = a[3:8] # 'lo wo' g = a[-5:] # 'world' 끝 인덱스에 있는 문자는 (인덱싱 결과에) 포함되지 않는다. 생략된 인덱스는 문자열의 시작 또는 끝으로 간주한다. 문자열 연산 이어붙이기(concatenation), 길이(length), 멤버십(membership), 복제(replication). # 이어붙이기(+) a = 'Hello' + 'World' # 'HelloWorld' b = 'Say ' + a # 'Say HelloWorld' # 길이(len) s = 'Hello' len(s) # 5 # 멤버십 테스트(`in`, `not in`) t = 'e' in s # True f = 'x' in s # False g = 'hi' not in s # True # 복제(s * n) rep = s * 5 # 'HelloHelloHelloHelloHello' 문자열 메서드 문자열에는 문자열 데이터에 대해 다양한 연산을 수행하는 메서드가 있다. 예: 맨 앞이나 맨 뒤의 화이트 스페이스 제거. s = ' Hello ' t = s.strip() # 'Hello' 예: 대소문자 변환 s = 'Hello' l = s.lower() # 'hello' u = s.upper() # 'HELLO' 예: 텍스트 교체. s = 'Hello world' t = s.replace('Hello' , 'Hallo') # 'Hallo world' 기타 문자열 메서드 문자열에는 텍스트 데이터를 테스트하고 조작하는 다양한 메서드가 있다. 그중 일부를 소개한다. s.endswith(suffix) # 문자열이 suffix로 끝나는지 확인 s.find(t) # s에서 t가 처음 나타나는 곳 s.index(t) # s에서 t가 처음 나타나는 곳 s.isalpha() # 문자가 영문자인지 s.isdigit() # 문자가 숫자인지 s.islower() # 문자가 소문자인지 s.isupper() # 문자가 대문자인지 s.join(slist) # s를 구분자(delimiter)로 삼아 문자열의 리스트를 붙이기(join) s.lower() # 소문자로 변환 s.replace(old, new) # 텍스트 교체 s.rfind(t) # 문자열의 끝에서부터 t를 검색 s.rindex(t) # 문자열의 끝에서부터 t를 검색 s.split([구분자]) # 문자열을 분할해 부분 문자열의 리스트를 만듦 s.startswith(prefix) # 문자열이 prefix로 시작하는지 확인 s.strip() # 앞뒤의 공백을 제거 s.upper() # 대문자로 변환 문자열의 변경 가능성(Mutability) 문자열은 변경 불가능(immutable), 즉 읽기 전용이다. 한 번 생성하면 값이 바뀌지 않는다. >>> s = 'Hello World' >>> s[1] = 'a' Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'str' object does not support item assignment >>> 문자열 데이터를 조작하는 모든 연산과 메서드는 항상 새로운 문자열을 생성한다. 문자열 변환 다른 타입의 값을 문자열로 변환하려면 str()을 사용한다. 그 결과로 print() 문이 생성하는 것과 같은 텍스트가 반환된다. >>> x = 42 >>> str(x) '42' >>> 바이트 열(Byte String) 8비트 바이트가 끈(string)처럼 이어진 것으로 일반적으로 저 수준 입출력(I/O)에 사용되며, 다음과 같이 쓴다. data = b'Hello World\r\n' 첫 번째 따옴표 바로 앞에 소문자 b를 붙이면, 텍스트 열(text string)이 아닌 바이트 열로 지정된다. 일반적인 문자열 연산은 대부분 작동한다. len(data) # 13 data[0:5] # b'Hello' data.replace(b'Hello', b'Cruel') # b'Cruel World\r\n' 인덱싱은 좀 다르게 작동하는데, 바이트 값을 정수로 반환하기 때문이다. data[0] # 72 ('H'의 ASCII 코드) 텍스트 열과의 변환. text = data.decode('utf-8') # 바이트 열 -> 텍스트 열 data = text.encode('utf-8') # 텍스트 열 -> 바이트 열 'utf-8' 인자(argument)는 문자 인코딩을 지정한다. 'ascii'와 'latin1'도 일반적으로 사용하는 값이다. 원시 문자열(Raw String) 원시 문자열은 백슬래시를 해석하지 않는 문자열 리터럴이다. 소문자 "r"을 앞에 붙여 원시 문자열임을 나타낸다. >>> rs = r'c:\newdata\test' # 원시(백슬래시를 해석하지 않음) >>> rs 'c:\\newdata\\test' 문자열은 입력한 그대로의 리터럴 텍스트다. 백슬래시가 특별히 중요할 때 이것을 사용하면 편리하다. 예: 파일명, 정규 표현식(regular expression) 등 f 문자열(f-String) 포매팅된 표현식 대체가 있는 문자열이다. >>> name = 'IBM' >>> shares = 100 >>> price = 91.1 >>> a = f'{name:>10s} {shares:10d} {price:10.2f}' >>> a ' IBM 100 91.10' >>> b = f'Cost = ${shares*price:0.2f}' >>> b 'Cost = $9110.00' >>> 참고: f 문자열은 파이썬 3.6 이상에서 지원한다. 포맷 코드의 의미는 나중에 다룬다. 연습 문제 이 연습 문제에서는 파이썬의 문자열 타입에 대한 연산을 실험한다. 파이썬의 상호작용적인 프롬프트에서 쉽게 결과를 확인할 수 있다. 중요: 인터프리터와 상호작용할 때, >>>는 파이썬이 새로운 문장 입력을 요구하는 인터프리터 프롬프트다. 이 연습 문제의 몇몇 문장은 여러 행에 걸쳐 작성되므로, 그것들을 실행하려면 '엔터(return)'를 몇 번 눌러야 한다. 그러니까 예제를 실습할 때 >>>를 입력하지 않는다. 주식 티커 심벌을 포함하는 문자열을 정의하는 것부터 해 보자. >>> symbols = 'AAPL, IBM, MSFT, YHOO, SCO' >>> 연습 문제 1.13: 개별 문자와 부분 문자열을 추출하기 문자열은 문자의 배열이다. 문자를 몇 개 추출해 보자. >>> symbols[0] >>> symbols[1] >>> symbols[2] >>> symbols[-1] # 마지막 문자 >>> symbols[-2] # 음수 인덱스는 문자열 끝에서부터 센다 >>> 파이썬에서 문자열은 읽기 전용이다. 이것을 확인하기 위해 symbols의 첫 글자를 소문자 'a'로 바꿔보자. >>> symbols[0] = 'a' Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'str' object does not support item assignment >>> 연습 문제 1.14: 문자열 이어붙이기 문자열 데이터가 읽기 전용이기는 하지만, 새로 생성한 문자열에 변수를 재할당할 수 있다. 다음과 같이 symbols의 끝에 새로운 심벌 "GOOG"를 이어붙여 보라. >>> symbols = symbols + 'GOOG' >>> symbols 'AAPL, IBM, MSFT, YHOO, SCOGOOG' >>> 아차! 이걸 원한 것이 아니다. symbols 변수에 'AAPL, IBM, MSFT, YHOO, SCO, GOOG'가 들어가게 수정해 보자. >>> symbols = ? >>> symbols 'AAPL, IBM, MSFT, YHOO, SCO, GOOG' >>> 문자열의 시작에 'HPQ'를 추가해 보자. >>> symbols = ? >>> symbols 'HPQ, AAPL, IBM, MSFT, YHOO, SCO, GOOG' >>> 문자열이 읽기 전용이라고 했는데, 이 예에서는 원래의 문자열을 수정해 규칙을 위반하는 것처럼 보일 수도 있다. 그런 것이 아니다. 문자열에 대한 연산은 완전히 새로운 문자열을 매번 생성한다. 변수명 심벌(symbol)이 재할당되면, 그것은 새로 생성된 문자열을 가리킨다. 사용하지 않는 문자열은 삭제된다. 연습 문제 1.15: 멤버십 테스팅(부분 문자열 테스팅) in 연산자를 사용해 부분 문자열을 확인해 보자. 상호작용적인 프롬프트에서 다음 연산을 해 보라. >>> 'IBM' in symbols >>> 'AA' in symbols True >>> 'CAT' in symbols >>> 'AA'를 확인할 때 왜 True가 반환될까? 연습 문제 1.16: 문자열 메서드 파이썬 프롬프트에서 문자열 메서드를 시험 삼아 사용해 보자. >>> symbols.lower() >>> symbols >>> 문자열은 항상 읽기 전용임을 명심하자. 연산 결과를 저장하고 싶으면 변수에 넣어라. >>> lowersyms = symbols.lower() >>> 몇 가지 연산을 더 해 보자. >>> symbols.find('MSFT') >>> symbols[13:17] >>> symbols = symbols.replace('SCO','DOA') >>> symbols >>> name = ' IBM \n' >>> name = name.strip() # 둘러싸는 공백을 제거 >>> name >>> 연습 문제 1.17: f 문자열(f-strings) 변숫값을 포함하는 문자열을 생성하고 싶을 때가 있다. 그럴 때 f 문자열을 사용한다. 예: >>> name = 'IBM' >>> shares = 100 >>> price = 91.1 >>> f'{shares} shares of {name} at ${price:0.2f}' '100 shares of IBM at $91.10' >>> 연습 문제 1.10의 mortgage.py 프로그램을 수정해, f 문자열을 사용해 출력을 생성하게 해 보자. 출력을 보기 좋게 정렬해 보라. 연습 문제 1.18: 정규 표현식(Regular Expressions) 기본 문자열 연산은 고급 패턴 매칭을 지원하지 않지만, 파이썬의 re 모듈을 가지고 정규 표현식을 사용할 수 있다. 정규 표현식은 그 자체로 큰 주제이지만 여기서는 간단한 예를 들겠다. >>> text = 'Today is 3/27/2018. Tomorrow is 3/28/2018.' >>> # 날짜가 있는 곳을 모두 찾음 >>> import re >>> re.findall(r'\d+/\d+/\d+', text) ['3/27/2018', '3/28/2018'] >>> # 날짜가 있는 곳을 모두 찾아 text로 교체 >>> re.sub(r'(\d+)/(\d+)/(\d+)', r'\3-\1-\2', text) 'Today is 2018-3-27. Tomorrow is 2018-3-28.' >>> re 모듈에 대한 자세한 정보는 공식 문서 https://docs.python.org/library/re.html을 참조하라. 부연 설명 인터프리터를 가지고 실험을 하다 보면, 다른 객체(object)가 지원하는 연산에 대해 더 알고 싶을 것이다. 가령, 문자열에 어떤 연산이 있는지 어떻게 찾을 수 있을까? 파이썬 환경에 따라, 탭 자동완성을 통해 리스트를 볼 수 있을 수도 있다. 다음과 같이 해 보라. >>> s = 'hello world' >>> s.<tab key> >>> 탭을 눌렀을 때 반응이 없다면, 빌트인 dir() 함수를 사용한다. 예: >>> s = 'hello' >>> dir(s) ['__add__', '__class__', '__contains__', ..., 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill'] >>> dir()은 (.) 이후에 나타날 수 있는 전체 연산의 리스트를 생성한다. 특정 연산에 대한 자세한 내용을 알고 싶으면 help() 명령을 사용하라. >>> help(s.upper) Help on built-in function upper: upper(...) S.upper() -> string Return a copy of the string S converted to uppercase. >>> 1.5 리스트 이 섹션은 파이썬에서 값의 순서가 유지되는 컬렉션(ordered collection)을 나타내는 기본 타입인 리스트를 소개한다. 리스트 생성 대괄호를 사용해 리스트 리터럴을 정의한다. names = [ 'Elwood', 'Jake', 'Curtis' ] nums = [ 39, 38, 42, 65, 111] 다른 방법으로 리스트를 정의할 수도 있다. 예를 들어, split() 메서드를 가지고 문자열을 분할해 리스트를 만들 수 있다. >>> line = 'GOOG, 100,490.10' >>> row = line.split(',') >>> row ['GOOG', '100', '490.10'] >>> 리스트 연산 어떤 타입이든 리스트 항목(item)이 될 수 있다. append()를 사용해 새 항목을 추가한다. names.append('Murphy') # 마지막에 추가 names.insert(2, 'Aretha') # 중간에 삽입 리스트를 이어붙이려면 +를 사용한다. s = [1, 2, 3] t = ['a', 'b'] s + t # [1, 2, 3, 'a', 'b'] 리스트의 인덱스에는 정수를 사용한다. 인덱스는 0부터 시작한다. names = [ 'Elwood', 'Jake', 'Curtis' ] names[0] # 'Elwood' names[1] # 'Jake' names[2] # 'Curtis' 음수 인덱스는 뒤에서부터 센다. names[-1] # 'Curtis' 리스트의 항목을 변경할 수 있다. names[1] = 'Joliet Jake' names # [ 'Elwood', 'Joliet Jake', 'Curtis' ] 리스트의 길이. names = ['Elwood','Jake','Curtis'] len(names) # 3 멤버십 테스트(in, not in). 'Elwood' in names # True 'Britney' not in names # True 복제(s * n). s = [1, 2, 3] s * 3 # [1, 2, 3, 1, 2, 3, 1, 2, 3] 리스트 이터레이션(Iteration)과 검색 for를 사용해 리스트 내용을 훑는다. for name in names: # name을 사용 # 예: print(name) ... 다른 프로그래밍 언어의 foreach 문과 비슷하다. 무엇의 위치를 재빨리 찾으려면 index()를 사용한다. names = ['Elwood','Jake','Curtis'] names.index('Curtis') # 2 원소(element)가 한 번 이상 나타나면, index()는 해당 원소가 처음 나타난 인덱스를 반환한다. 원소를 찾지 못하면 ValueError 예외를 일으킨다. 리스트 제거 특정 값 또는 인덱스를 갖는 항목을 제거할 수 있다. # 값을 사용 names.remove('Curtis') # 인덱스를 사용 del names[1] 항목을 제거하더라도 빈자리가 생기지는 않는다. 다음 항목이 따라붙는다. 원소가 한 번 이상 나타나는 경우, remove()는 첫 번째 나타난 것만 제거한다. 리스트 정렬 리스트를 "제자리에서(in-place)" 정렬할 수 있다. s = [10, 1, 7, 3] s.sort() # [1, 3, 7, 10] # 역순 s = [10, 1, 7, 3] s.sort(reverse=True) # [10, 7, 3, 1] # 순서가 유지되는 자료형에 동일하게 적용된다 s = ['foo', 'bar', 'spam'] s.sort() # ['bar', 'foo', 'spam'] 새 리스트를 만들고 싶으면 sorted()를 사용한다. t = sorted(s) # s는 바뀌지 않으며, t는 정렬된 값을 가짐 리스트와 수학 주의: 리스트는 수학 연산을 위해 설계한 것이 아니다. >>> nums = [1, 2, 3, 4, 5] >>> nums * 2 [1, 2, 3, 4, 5, 1, 2, 3, 4, 5] >>> nums + [10, 11, 12, 13, 14] [1, 2, 3, 4, 5, 10, 11, 12, 13, 14] 특히 리스트는 매트랩(MATLAB), 옥타브(Octave), R 등의 벡터나 행렬을 나타내지 않는다. 그런 용도로 사용할 수 있는 패키지가 따로 있다.(예: numpy) 연습 문제 이 연습 문제에서는 파이썬의 리스트 자료형을 실험한다. 지난 섹션에서 주식 심벌을 포함하는 문자열을 다뤘다. >>> symbols = 'HPQ, AAPL, IBM, MSFT, YHOO, DOA, GOOG' 문자열의 split() 연산을 사용해 이름의 리스트를 만든다. >>> symlist = symbols.split(',') 연습 문제 1.19: 리스트 원소를 추출해 재할당 조회를 해 보자. >>> symlist[0] 'HPQ' >>> symlist[1] 'AAPL' >>> symlist[-1] 'GOOG' >>> symlist[-2] 'DOA' >>> 값을 재할당해 보자. >>> symlist[2] = 'AIG' >>> symlist ['HPQ', 'AAPL', 'AIG', 'MSFT', 'YHOO', 'DOA', 'GOOG'] >>> 슬라이스를 해 보자. >>> symlist[0:3] ['HPQ', 'AAPL', 'AIG'] >>> symlist[-2:] ['DOA', 'GOOG'] >>> 빈 리스트를 생성하고 항목을 추가해 보자. >>> mysyms = [] >>> mysyms.append('GOOG') >>> mysyms ['GOOG'] 리스트의 일부를 다른 리스트에 재할당할 수 있다. 예: >>> symlist[-2:] = mysyms >>> symlist ['HPQ', 'AAPL', 'AIG', 'MSFT', 'YHOO', 'GOOG'] >>> 이렇게 하면 왼쪽의 리스트(symlist)는 오른쪽 리스트(mysyms)에 맞춰 크기가 변한다. 위의 예에서, symlist의 마지막 두 개 항목이 mysyms의 한 개 항목으로 교체된다. 연습 문제 1.20: 리스트 항목을 루핑 for 루프는 리스트 같은 시퀀스의 데이터를 루핑 한다. 다음 루프를 타이핑하고 무슨 일이 일어나는지 지켜보라. >>> for s in symlist: print('s =', s) # 출력을 살펴보라 연습 문제 1.21: 멤버십 테스트 in이나 not in 연산자를 사용해, 심벌 리스트에 'AIG','AA', 'CAT'가 있는지 확인하라. >>> # 'AIG'가 `symlist`에 있는가?(in) True >>> # 'AA'가 `symlist`에 있는가?(in) False >>> # 'CAT'가 `symlist` 없는가?(not in) True >>> 연습 문제 1.22: 항목을 추가, 삽입, 삭제 append() 메서드를 사용해 심벌 'RHT'를 symlist의 끝에 추가하라. >>> # 'RHT'를 추가 >>> symlist ['HPQ', 'AAPL', 'AIG', 'MSFT', 'YHOO', 'GOOG', 'RHT'] >>> insert() 메서드를 사용해 심벌 'AA'를 리스트의 두 번째 항목으로 삽입하라. >>> # 'AA'를 리스트의 두 번째 항목으로 >>> symlist ['HPQ', 'AA', 'AAPL', 'AIG', 'MSFT', 'YHOO', 'GOOG', 'RHT'] >>> remove() 메서드를 사용해 'MSFT'를 리스트에서 삭제하라. >>> # 'MSFT'를 삭제 >>> symlist ['HPQ', 'AA', 'AAPL', 'AIG', 'YHOO', 'GOOG', 'RHT'] >>> 리스트 끝에 'YHOO'를 한 개 더 추가하라. 참고: 리스트에는 중복된 값이 들어가도 전혀 문제가 없다. >>> # 'YHOO'를 추가 >>> symlist ['HPQ', 'AA', 'AAPL', 'AIG', 'YHOO', 'GOOG', 'RHT', 'YHOO'] >>> 리스트에서 'YHOO'의 위치를 빨리 찾으려면 index() 메서드를 사용한다. >>> # 'YHOO'의 첫 번째 인덱스 찾기 >>> symlist[4] 'YHOO' >>> 리스트에 'YHOO'가 몇 번 나오는지 센다. >>> symlist.count('YHOO') >>> 첫 번째 나타나는 'YHOO'를 삭제한다. >>> # 첫 번째 나오는 'YHOO'를 삭제 >>> symlist ['HPQ', 'AA', 'AAPL', 'AIG', 'GOOG', 'RHT', 'YHOO'] >>> 모든 항목을 찾거나, 모든 항목을<NAME>는 메서드는 없다. 그렇지만 그렇게 할 수 있는 우아한 방법을 섹션 2에서 알아본다. 연습 문제 1.23: 정렬(Sorting) 리스트를 정렬하고 싶은가? sort() 메서드를 사용하라. 한번 사용해 보자. >>> symlist.sort() >>> symlist ['AA', 'AAPL', 'AIG', 'GOOG', 'HPQ', 'RHT', 'YHOO'] >>> 역순으로 정렬하고 싶다면? 다음과 같이 해 보라. >>> symlist.sort(reverse=True) >>> symlist ['YHOO', 'RHT', 'HPQ', 'GOOG', 'AIG', 'AAPL', 'AA'] >>> 참고: 리스트를 정렬하면 내용이 '제자리에서(in-place)' 수정된다. 그 말은 리스트의 항목은 이리저리 옮겨지지만 새로운 리스트를 생성하지는 않는다는 뜻이다. 연습 문제 1.24: 모두 합치기 문자열의 리스트를 가지고 항목들을 합쳐서(join) 한 개의 문자열을 만들고 싶은가? 다음과 같이 문자열의 join() 메서드를 사용하라(참고: 처음 보면 좀 웃기다). >>> a = ','.join(symlist) >>> a 'YHOO, RHT, HPQ, GOOG, AIG, AAPL, AA' >>> b = ':'.join(symlist) >>> b 'YHOO:RHT:HPQ:GOOG:AIG:AAPL:AA' >>> c = ''.join(symlist) >>> c 'YHOORHTHPQGOOGAIGAAPLAA' >>> 연습 문제 1.25: 온갖 것들의 리스트 리스트는 어떤 종류의 객체든 담을 수 있고, 다른 리스트를 담을 수도 있다(예: 중첩된 리스트). 다음과 같이 시도해 보라. >>> nums = [101, 102, 103] >>> items = ['spam', symlist, nums] >>> items ['spam', ['YHOO', 'RHT', 'HPQ', 'GOOG', 'AIG', 'AAPL', 'AA'], [101, 102, 103]] 출력을 잘 들여다보라. items는 세 개의 원소를 가진 리스트다. 첫 번째 원소는 문자열이지만, 나머지 두 개의 원소는 리스트다. 여러 가지 인덱싱 연산자를 사용해 중첩된 리스트의 항목에 액세스할 수 있다. >>> items[0] 'spam' >>> items[0][0] 's' >>> items[1] ['YHOO', 'RHT', 'HPQ', 'GOOG', 'AIG', 'AAPL', 'AA'] >>> items[1][1] 'RHT' >>> items[1][1][2] 'T' >>> items[2] [101, 102, 103] >>> items[2][1] 102 >>> 매우 복잡한 리스트 구조를 만드는 것이 기술적으로는 가능하지만, 단순하게 만드는 것이 좋다. 리스트의 항목은 모두 같은 종류의 값으로 구성하는 것이 일반적이다. 예를 들어, 숫자만으로 리스트를 구성하거나, 텍스트 문자열만으로 리스트를 구성한다. 같은 리스트에 여러 종류의 데이터를 섞다 보면 머리가 터질 수 있으니 될 수 있으면 피하자. 1.6 파일 관리 대부분의 프로그램은 외부로부터 입력을 읽어야 한다. 이 섹션은 파일 액세스를 논의한다. 파일 입력과 출력 파일을 연다. f = open('foo.txt', 'rt') # 읽기를 위해 열기(텍스트) g = open('bar.txt', 'wt') # 쓰기를 위해 열기(텍스트) 모든 데이터를 읽는다. data = f.read() # 'maxbytes' 바이트까지만 읽음 data = f.read([maxbytes]) 텍스트를 기록한다. g.write('some text') 마쳤으면 파일을 닫는다. f.close() g.close() 파일을 열었으면 제대로 닫아야 하는데, 이 단계를 잊어버리기 쉽다. 따라서, 다음과 같이 with 문을 사용하면 좋다. with open(filename, 'rt') as file: # `file` 파일을 사용 ... # 명시적으로 닫지 않아도 된다 ...문장 이렇게 하면 들여 쓴 코드 블록에서 벗어날 때 파일이 자동으로 닫힌다. 파일 데이터를 읽는 일반적인 방법 파일 전체를 한 번에 읽어 문자열로 처리한다. with open('foo.txt', 'rt') as file: data = file.read() # `data`는 `foo.txt`의 텍스트 전체로 된 문자열이다 파일을 한 행씩 읽어 내려가기. with open(filename, 'rt') as file: for line in file: # 행을 처리 파일에 쓰는 일반적인 방법 문자열 데이터를 기록한다. with open('outfile', 'wt') as out: out.write('Hello World\n') ... print 함수의 출력을 재지정(redirect) 한다. with open('outfile', 'wt') as out: print('Hello World', file=out) ... 연습 문제 이 연습 문제에서는 Data/portfolio.csv 파일을 사용한다. 이 파일은 주식의 포트폴리오에 대한 정보를 담은 행들의 리스트를 담고 있다. practical-python/Work/ 디렉터리에서 작업하는 것으로 가정한다. 확실하지 않으면 파이썬의 현재 작업 디렉터리(current working directory)를 확인해 보자. >>> import os >>> os.getcwd() '/Users/beazley/Desktop/practical-python/Work' # 출력은 환경에 따라 다르다 >>> 연습 문제 1.26: 파일 기초 먼저, 전체 파일을 한 번에 읽어 큰 문자열을 만들어 보자. >>> with open('Data/portfolio.csv', 'rt') as f: data = f.read() >>> data 'name, shares, price "AA",100,32.20 "IBM",50,91.10 "CAT",150,83.44 "MSFT",200,51.23 "GE",95,40.37 "MSFT",50,65.10\n"IBM",100,70.44\n' >>> print(data) name, shares, price "AA",100,32.20 "IBM",50,91.10 "CAT",150,83.44 "MSFT",200,51.23 "GE",95,40.37 "MSFT",50,65.10 "IBM",100,70.44 >>> 위의 예에서 파이썬에 두 가지 출력 모드가 있음에 유의한다. 첫 번째 모드에서는 프롬프트에 data를 타이핑하면 따옴표와 이스케이프 코드가 포함된 원시 문자열이 나타난다. print(data)를 타이핑하면 실제 포매팅된 문자열 출력이 나타난다. 파일을 한 번에 읽는 것이 간단하기는 하지만 때에 따라서는 좋은 방법이 아닐 수도 있다. 특히 파일이 아주 크거나, 한 번에 처리하고 싶은 데이터가 포함된 경우가 그렇다. 파일을 행 단위로 읽으려면 다음과 같이 for 루프를 사용한다. >>> with open('Data/portfolio.csv', 'rt') as f: for line in f: print(line, end='') name, shares, price "AA",100,32.20 "IBM",50,91.10 ... >>> 코드를 위와 같이 사용하면, 행을 차례로 읽다가 파일의 끝에 도달하면 루프가 종료된다. 특정한 상황에서, 텍스트의 단 일행을 읽거나 건너뛸 수 있다(예: 첫 행의 칼럼 헤더를 건너뛰고 싶을 것이다). >>> f = open('Data/portfolio.csv', 'rt') >>> headers = next(f) >>> headers 'name, shares, price ' >>> for line in f: print(line, end='') "AA",100,32.20 "IBM",50,91.10 ... >>> f.close() >>> next()는 파일에서 다음 번 행을 반환한다. 이것을 반복적으로 호출함으로써 행을 연속적으로 얻을 수 있다. 그렇지만, 알다시피 for 루프에서 데이터를 얻을 때 next()를 이미 사용한다. 따라서, 단 일행을 명시적으로 건너뛰거나 읽을 때 외에는 직접적으로 호출하지 않는다. 파일의 행을 읽었으면 문자열을 분할하는 것과 같은 처리를 할 수 있다. 예: >>> f = open('Data/portfolio.csv', 'rt') >>> headers = next(f).split(',') >>> headers ['name', 'shares', 'price\n'] >>> for line in f: row = line.split(',') print(row) ['"AA"', '100', '32.20\n'] ['"IBM"', '50', '91.10\n'] ... >>> f.close() 참고: 이 예에서는 with 문을 사용하지 않았으므로 f.close()를 명시적으로 호출했다. 연습 문제 1.27: 데이터 파일 읽기 파일을 읽는 방법을 알았으니 간단한 계산을 수행하는 프로그램을 작성하자. portfolio.csv의 각 칼럼은 보유 종목의 이름, 주식 수, 매수 가격에 해당한다. 이 파일을 열어 전체 행을 읽은 뒤, 포트폴리오의 전체 주식을 매수하는 데 드는 비용을 계산하는 pcost.py 프로그램을 작성한다. 힌트: 문자열을 정수로 변환하려면 int(s)를 사용한다. 문자열을 부동소수점으로 변환하려면 float(s)를 사용한다. 다음과 같이 출력하는 프로그램을 작성하라. Total cost 44671.15 연습 문제 1.28: 다른 종류의 "파일" 일반 텍스트 파일이 아닌, gzip 압축된 데이터 파일을 읽고 싶으면 어떻게 해야 할까? 빌트인 open() 함수는 여기서 도움이 되지 않지만, 파이썬에는 gzip 압축된 파일을 읽을 수 있는 gzip 라이브러리 모듈이 있다. 한번 해 보자. >>> import gzip >>> with gzip.open('Data/portfolio.csv.gz', 'rt') as f: for line in f: print(line, end='') ... 출력을 살펴보라 ... >>> 참고: 파일 모드를 'rt'로 지정하는 것이 중요하다. 이것을 잊으면 일반 텍스트 열이 아닌 바이트 열을 얻게 된다. 부연 설명: 판다스를 사용하면 되지 않나? 데이터 과학자라면 CSV 파일을 읽는 함수를 제공하는 판다스(Pandas, https://pandas.pydata.org) 같은 라이브러리를 사용하면 된다고 지적할 것이다. 맞는 말씀이다. 잘 작동한다. 하지만, 이 코스는 판다스를 배우는 코스가 아니다. 파일을 읽는 것은 CSV 파일이라는 국소적인 문제에 비해 좀 더 일반적인 문제다. 여기서 CSV 파일을 다루는 주된 이유는 그것이 잘 알려진<NAME>이고 직접 다루기 쉬운 편이므로, 그것을 처리하는 과정을 통해 파이썬의 기능을 소개하기 위함이다. 그러니, 판다스는 일터로 돌아가면 마음껏 써라. 이 코스에서는 표준 파이썬 기능만 사용한다. 1.7 함수 프로그램이 커질수록 조직화가 필요해진다. 이 섹션은 함수와 라이브러리 모듈을 간략히 소개한다. 예외를 가지고 오류 처리를 하는 법도 소개한다. 커스텀 함수 재사용하고자 하는 코드를 위해 함수를 사용하라. 함수 정의는 다음과 같다. def sumcount(n): ''' 정수 1부터 n까지의 합을 반환 ''' total = 0 while n > 0: total += n n -= 1 return total 다음과 같이 함수를 호출한다. a = sumcount(100) 함수는 작업을 수행하고 결과를 반환하는 문장으로 이뤄진다. 함수가 값을 반환하려면 return 키워드를 사용해 명시해야 한다. 라이브러리 함수 파이썬에는 큰 규모의 표준 라이브러리(standard library)가 있다. import를 사용해 라이브러리 모듈에 액세스한다. 예: import math x = math.sqrt(10) import urllib.request u = urllib.request.urlopen('http://www.python.org/') data = u.read() 라이브러리와 모듈에 대한 자세한 내용은 나중에 다룬다. 오류와 예외 함수는 오류를 예외로서 보고한다. 예외가 발생하면 함수의 실행이 중단되며 이를 처리하지 않으면 프로그램 전체가 중단될 수 있다. 파이썬 REPL에서 다음을 시도해 보라. >>> int('N/A') Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: invalid literal for int() with base 10: 'N/A' >>> 실패를 일으킨 다른 함수 호출을 보여주는 트레이스 백과 함께, 무슨 일이 일어났으며 어디서 오류가 발생했는지 설명하는 메시지가 나타난다. 이 정보는 디버깅에 도움이 된다. 예외를 붙잡아 처리하기 예외를 붙잡아 처리할 수 있다. 그렇게 하려면 try - except 문을 사용한다. for line in f: fields = line.split() try: shares = int(fields[1]) except ValueError: print("Couldn't parse", line) ... ValueError라는 이름이 당신이 붙잡으려는 오류의 종류와 일치해야 한다. 어떤 종류의 오류가 발생할 수 있는지, 연산을 수행하기 전에 미리 정확하게 알기 어려울 때도 있다. 프로그램이 예상치 못하게 충돌한 이후에 예외 처리가 추가되곤 한다(예: "아차, 그 오류를 붙잡는 걸 깜빡했네. 처리하는 코드를 넣어야겠어!"). 예외를 일으키기 예외를 일으키려면 raise 문을 사용한다. raise RuntimeError('What a kerfuffle') 이렇게 하면 예외 트레이스 백과 함께 프로그램이 중단된다. try-except 블록으로 붙잡지 않았다면 말이다. % python3 foo.py Traceback (most recent call last): File "foo.py", line 21, in <module> raise RuntimeError("What a kerfuffle") RuntimeError: What a kerfuffle 연습 문제 연습 문제 1.29: 함수를 정의하기 다음과 같은 단순한 함수를 정의해 보자. >>> def greeting(name): 'Issues a greeting' print('Hello', name) >>> greeting('Guido') Hello Guido >>> greeting('Paula') Hello Paula >>> 함수의 첫 문장이 문자열이면 그것을 문서로 사용한다. help(greeting) 명령을 타이핑해 문서가 표시되는지 확인해 보라. 연습 문제 1.30: 스크립트를 함수로 탈바꿈 연습 문제 1.27의 pcost.py 프로그램 코드를 가져다가 portfolio_cost(filename) 함수를 만들어 보라. 이 함수는 파일명을 입력으로 받아 포트폴리오 데이터를 읽고, 포트폴리오의 총비용을 부동소수점으로 반환한다. 함수를 사용하려면 프로그램을 다음과 같이 수정하자. def portfolio_cost(filename): ... # 여기에 코드를 작성 ... cost = portfolio_cost('Data/portfolio.csv') print('Total cost:', cost) 프로그램을 실행하면 이전과 똑같은 출력이 나타나야 한다. 프로그램을 실행한 후, 다음과 같이 타이핑해 함수를 상호작용적으로 호출할 수 있다. bash $ python3 -i pcost.py 이렇게 하면 상호작용 모드에서 함수를 호출할 수 있다. >>> portfolio_cost('Data/portfolio.csv') 44671.15 >>> 코드를 상호작용적으로 실험할 수 있어 테스트와 디버깅하기 좋다. 연습 문제 1.31: 오류 처리 필드가 누락된 파일을 가지고 함수를 실행하면 무슨 일이 일어나는가? >>> portfolio_cost('Data/missing.csv') Traceback (most recent call last): File "<stdin>", line 1, in <module> File "pcost.py", line 11, in portfolio_cost nshares = int(fields[1]) ValueError: invalid literal for int() with base 10: '' >>> 이 시점에 결정해야 한다. 입력 파일에서 잘못된 행을 제거하거나, 잘못된 행을 처리하도록 코드를 수정하는 것이다. 오류를 잡아서 경고 메시지를 프린트하고, 파일의 끝까지 계속 처리하게 pcost.py 프로그램을 수정해 보자. 연습 문제 1.32: 라이브러리 함수 사용하기 파이썬에는 유용한 함수의 방대한 표준 라이브러리가 있다. 여기서는 csv 모듈을 사용하면 좋다. CSV 데이터 파일을 다룰 일이 있을 때 사용해라. 다음과 같이 사용한다. >>> import csv >>> f = open('Data/portfolio.csv') >>> rows = csv.reader(f) >>> headers = next(rows) >>> headers ['name', 'shares', 'price'] >>> for row in rows: print(row) ['AA', '100', '32.20'] ['IBM', '50', '91.10'] ['CAT', '150', '83.44'] ['MSFT', '200', '51.23'] ['GE', '95', '40.37'] ['MSFT', '50', '65.10'] ['IBM', '100', '70.44'] >>> f.close() >>> csv 모듈은 따옴표라든지, 콤마를 사용한 분할 등 저 수준의 여러 가지 세부사항을 처리해 준다. 위 출력의 첫 번째 칼럼에서 큰따옴표가 제거된 것을 볼 수 있다. csv 모듈을 사용해 파싱을 하도록 pcost.py 프로그램을 수정한 다음, 이전의 예제를 실행해 보라. 연습 문제 1.33: 명령행에서 읽기 pcost.py 프로그램은 입력 파일명을 하드코딩했다. # pcost.py def portfolio_cost(filename): ... # 여기에 코드를 작성 ... cost = portfolio_cost('Data/portfolio.csv') print('Total cost:', cost) 배우고 테스트할 때는 괜찮지만 실제 프로그램에서는 그렇게 하면 안 된다. 스크립트의 인자로 파일명을 전달하라. 다음과 같이 프로그램을 바꿔라. # pcost.py import sys def portfolio_cost(filename): ... # 여기에 코드를 작성 ... if len(sys.argv) == 2: filename = sys.argv[1] else: filename = 'Data/portfolio.csv' cost = portfolio_cost(filename) print('Total cost:', cost) 명령행에서 전달받은 인자가 있는 경우 sys.argv 리스트에 들어 있다. 따라서, 이 프로그램은 다음과 같이 터미널에서 실행해야 한다. 예(유닉스 bash에서 실행): bash % python3 pcost.py Data/portfolio.csv Total cost: 44671.15 bash % 2. 데이터로 작업하기 유용한 프로그램을 작성하려면 데이터를 다룰 수 있어야 한다. 이 섹션은 파이썬의 핵심 데이터 구조인 튜플, 리스트, 세트, 딕셔너리를 소개하고 데이터를 다루는 일반적인 방법을 논의한다. 이 섹션의 마지막 부분은 파이썬의 기본 객체 모델을 더 깊이 다룬다. 2.1 자료형과 자료 구조 2.2 컨테이너 2.3 출력 포매팅 2.4 시퀀스 2.5 collections 모듈 2.6 리스트 컴프리 헨 션(list comprehension) 2.7 객체 모델 2.1 자료형과 자료 구조 이 섹션에서는 튜플과 딕셔너리 자료형을 소개한다. 기본 자료형 파이썬에는 몇 가지 기본 자료형이 있다. 정수 부동소수점수 문자열(텍스트) 이런 것들을 도입에서 배웠다. None 타입 email_address = None None은 주로 선택적인 값이나 누락 값(missing value)을 표시하는 데 사용된다. 조건문에서는 False로 평가한다. if email_address: send_email(email_address, msg) 자료형 실제 프로그램에서는 더 복잡한 자료형을 사용한다. 주식 보유에 대한 정보의 예를 살펴보자. 구글(GOOG) 주식을 490.10 달러에 100주 보유 이 "객체"는 세 부분으로 구성된다. 종목명 또는 심벌(문자열 "GOOG") 주식 수(정수 100) 가격(부동소수점수 490.10) 튜플(Tuple) 튜플은 함께 묶인 값의 컬렉션이다. 예: s = ('GOOG', 100, 490.1) 다음과 같이 ()를 생략하기도 한다. s = 'GOOG', 100, 490.1 특수한 사례(0-튜플, 1-튜플). t = () # 빈 튜플 w = ('GOOG', ) # 항목이 한 개 있는 튜플 튜플은 주로 단순한 레코드 또는 자료 구조를 표현하는 데 사용한다. 일반적으로 여러 부분으로 된 단일 객체다. 좋은 비유: 튜플은 데이터베이스 테이블의 단 일행과 비슷하다. 튜플의 항목은 순서가 있다(배열과 비슷함). s = ('GOOG', 100, 490.1) name = s[0] # 'GOOG' shares = s[1] # 100 price = s[2] # 490.1 그러나, 내용을 수정할 수 없다. >>> s[1] = 75 TypeError: object does not support item assignment 현재 튜플을 가지고 새로운 튜플을 만들 수는 있다. s = (s[0], 75, s[2]) 튜플로 묶기(packing) 튜플은 서로 관련된 항목들을 단일 엔티티(entity)로 묶는 역할을 한다. s = ('GOOG', 100, 490.1) 튜플을 단일 객체로서 프로그램의 다른 부분으로 쉽게 전달할 수 있다. 튜플을 풀기(unpacking) 튜플을 전달받은 후에는 풀어서 각각의 변수를 사용할 수 있다. name, shares, price = s print('Cost', shares * price) 왼쪽의 변수 개수가 튜플 구조와 일치해야 한다. name, shares = s # 오류 Traceback (most recent call last): ... ValueError: too many values to unpack 튜플 vs. 리스트 튜플은 읽기 전용 리스트처럼 보인다. 그러나, 튜플의 주된 용도는 여러 부분으로 구성된 단일 항목으로서 사용하는 것이다. 리스트는 고유한 항목들의 컬렉션으로 사용되며, 이때 모든 항목이 같은 타입인 경우가 많다. record = ('GOOG', 100, 490.1) # 포트폴리오의 한 레코드를 나타내는 튜플 symbols = [ 'GOOG', 'AAPL', 'IBM' ] # 세 가지 주식 심벌을 나타내는 리스트 딕셔너리(Dictionary) 딕셔너리는 키(key)를 값(value)에 대응(mapping) 시킨다. 해시 테이블(hash table) 또는 연관 배열(associative array)이라고도 부른다. 키는 값에 접근하는 인덱스 역할을 한다. s = { 'name': 'GOOG', 'shares': 100, 'price': 490.1 } 공통적인 연산 딕셔너리에서 값을 얻으려면 키 이름을 사용한다. >>> print(s['name'], s['shares']) GOOG 100 >>> s['price'] 490.10 >>> 값을 추가하거나 수정할 때 키 이름을 사용한다. >>> s['shares'] = 75 >>> s['date'] = '6/6/2007' >>> 값을 삭제하려면 del 문을 사용한다. >>> del s['date'] >>> 딕셔너리를 사용하는 이유 딕셔너리는 서로 다른 값이 많이 있고 그 값들을 수정 또는 조작해야 할 때 유용하다. 딕셔너리를 사용하면 코드의 가독성이 높아진다. s['price'] # vs s[2] 연습 문제 지난 몇 개의 연습 문제에서, 데이터파일 Data/portfolio.csv를 읽는 프로그램을 작성했다. csv 모듈을 사용하면 파일을 행 단위로 쉽게 읽을 수 있다. >>> import csv >>> f = open('Data/portfolio.csv') >>> rows = csv.reader(f) >>> next(rows) ['name', 'shares', 'price'] >>> row = next(rows) >>> row ['AA', '100', '32.20'] >>> 파일을 읽는 것은 쉽지만, 데이터를 읽은 다음에는 그것을 가지고 더 많은 일을 하고 싶을 때가 있다. 예를 들어, 읽은 데이터를 저장하고 계산을 수행하고 싶을 것이다. 하지만, 원시 "행(row)" 데이터만으로는 작업하기에 충분하지 않다. 예를 들어, 간단한 수학 계산도 할 수 없다. >>> row = ['AA', '100', '32.20'] >>> cost = row[1] * row[2] Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: can't multiply sequence by non-int of type 'str' >>> 원시 데이터를 좀 더 유용한 객체로 바꿔야 나중에 작업에 사용할 수 있다. 튜플이나 딕셔너리를 사용하면 된다. 연습 문제 2.1: 튜플 상호작용적인 프롬프트에서, 다음과 같이 위의 행을 나타내는 튜플을 생성하되, 숫자 칼럼은 적절한 숫자로 변환한다. >>> t = (row[0], int(row[1]), float(row[2])) >>> t ('AA', 100, 32.2) >>> 이것을 사용해, 주식 수와 가격을 곱한 총비용을 계산할 수 있다. >>> cost = t[1] * t[2] >>> cost 3220.0000000000005 >>> 파이썬에서 수학 계산이 틀린가? 답이 왜 3220.0000000000005라고 나올까? 이것은 컴퓨터의 부동소수점 하드웨어로 계산한 결과다. 십진수(decimal)를 십진법(Base-10)이 아니라 이진법(Base-2)으로 표현하기 때문에 이런 결과가 나왔다. 간단한 계산이라 할지라도, 십진수와 관련된 계산에는 작은 오류가 발생한다. 처음 본다면 놀라울 수 있겠지만, 이것은 정상적인 작동이다. 부동소수점 십진수를 사용하는 모든 프로그래밍 언어에서 발생하는 일이지만, 프린팅 과정에서 종종 숨겨진다. 예: >>> print(f'{cost:0.2f}') 3220.00 >>> 튜플은 읽기 전용이다. 확인해 보고 싶으면 주식 수를 75로 바꿔보라. >>> t[1] = 75 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'tuple' object does not support item assignment >>> 튜플의 내용을 바꿀 수는 없지만, 항상 완전히 새로운 튜플을 생성해 기존 것을 대신할 수 있다. >>> t = (t[0], 75, t[2]) >>> t ('AA', 75, 32.2) >>> 기존 변수명을 재할당할 때마다 기존 값은 버려진다. 위의 할당문이 튜플을 수정하는 것처럼 보일 수 있지만, 실제로는 새로운 튜플을 생성하고 기존 것을 버렸다. 튜플은 패킹을 하고 변수로 언 패킹하는 데 종종 사용된다. 다음과 같이 해 보자. >>> name, shares, price = t >>> name 'AA' >>> shares 75 >>> price 32.2 >>> 위 변수들을 튜플로 패킹하자. >>> t = (name, 2*shares, price) >>> t ('AA', 150, 32.2) >>> 연습 문제 2.2: 자료 구조로서의 딕셔너리 튜플 대신 딕셔너리를 생성할 수 있다. >>> d = { 'name' : row[0], 'shares' : int(row[1]), 'price' : float(row[2]) } >>> d {'name': 'AA', 'shares': 100, 'price': 32.2 } >>> 총비용을 계산하자. >>> cost = d['shares'] * d['price'] >>> cost 3220.0000000000005 >>> 위의 튜플에 대해서 했던 것과 같은 계산을 했다. 주식 수를 75로 변경한다. >>> d['shares'] = 75 >>> d {'name': 'AA', 'shares': 75, 'price': 32.2 } >>> 튜플과 달리, 딕셔너리는 자유롭게 수정할 수 있다. 어 트리뷰트를 추가하자. >>> d['date'] = (6, 11, 2007) >>> d['account'] = 12345 >>> d {'name': 'AA', 'shares': 75, 'price':32.2, 'date': (6, 11, 2007), 'account': 12345} >>> 연습 문제 2.3: 추가적인 딕셔너리 연산 딕셔너리를 리스트로 변환하면 전체 키를 얻는다. >>> list(d) ['name', 'shares', 'price', 'date', 'account'] >>> 마찬가지로, 딕셔너리에 대해 for 문을 사용해 이터레이션을 해도 키를 얻는다, >>> for k in d: print('k =', k) k = name k = shares k = price k = date k = account >>> 다음 코드는 키와 값을 동시에 조회한다. >>> for k in d: print(k, '=', d[k]) name = AA shares = 75 price = 32.2 date = (6, 11, 2007) account = 12345 >>> keys() 메서드를 사용해도 전체 키를 얻을 수 있다. >>> keys = d.keys() >>> keys dict_keys(['name', 'shares', 'price', 'date', 'account']) >>> keys()는 특수한 dict_keys 객체를 반환한다는 점에서 독특하다. 이것은 원래 딕셔너리에 대한 오버레이로, 딕셔너리가 변경되더라도 항상 현재 키를 얻게 해준다. 다음과 같이 해 보자. >>> del d['account'] >>> keys dict_keys(['name', 'shares', 'price', 'date']) >>> d.keys()를 다시 호출하지 않았음에도 'account'가 keys에서 사라진 것에 유의하라. 키와 값을 함께 다루는 더욱 우아한 방법은 items() 메서드를 사용하는 것이다. 이 메서드를 사용해 (키, 값) 튜플을 얻을 수 있다. >>> items = d.items() >>> items dict_items([('name', 'AA'), ('shares', 75), ('price', 32.2), ('date', (6, 11, 2007))]) >>> for k, v in d.items(): print(k, '=', v) name = AA shares = 75 price = 32.2 date = (6, 11, 2007) >>> items 같은 튜플이 있으면 dict() 함수를 사용해 딕셔너리를 생성할 수 있다. 한번 해 보자. >>> items dict_items([('name', 'AA'), ('shares', 75), ('price', 32.2), ('date', (6, 11, 2007))]) >>> d = dict(items) >>> d {'name': 'AA', 'shares': 75, 'price':32.2, 'date': (6, 11, 2007)} >>> 2.2 컨테이너 이 섹션은 리스트, 딕셔너리, 세트를 논의한다. 개요 프로그램에서 많은 수의 객체를 다뤄야 할 때가 있다. 주식 포트폴리오 주식 가격 테이블 세 가지 선택사항이 있다. 리스트(list): 순서가 유지되는(ordered) 데이터. 딕셔너리(dict): 순서가 없는(unordered) 데이터. 세트(set): 고유한 항목의 집합이며 순서가 없음. 컨테이너로서의 리스트 데이터의 순서가 중요할 때는 리스트를 사용하라. 리스트는 어떤 유형의 객체든 담을 수 있음을 명심하라. 예: 튜플의 리스트. portfolio = [ ('GOOG', 100, 490.1), ('IBM', 50, 91.3), ('CAT', 150, 83.44) ] portfolio[0] # ('GOOG', 100, 490.1) portfolio[2] # ('CAT', 150, 83.44) 리스트 생성(construction) 다음은 리스트에 항목을 하나하나 채워 넣는 예이다. records = [] # 빈 리스트로 초기화 # .append()를 사용해 항목을 추가 records.append(('GOOG', 100, 490.10)) records.append(('IBM', 50, 91.3)) ... 다음은 파일에서 레코드를 읽어 리스트에 채우는 예이다. records = [] # 빈 리스트로 초기화 with open('Data/portfolio.csv', 'rt') as f: next(f) # 헤더를 건너뜀 for line in f: row = line.split(',') records.append((row[0], int(row[1]), float(row[2]))) 컨테이너로서의 딕셔너리 딕셔너리는 빠른 임의 조회(키 이름을 사용)에 유용하다. 예: 주식 가격의 딕셔너리. prices = { 'GOOG': 513.25, 'CAT': 87.22, 'IBM': 93.37, 'MSFT': 44.12 } 간단히 조회해 보자. >>> prices['IBM'] 93.37 >>> prices['GOOG'] 513.25 >>> 딕셔너리 생성 다음은 딕셔너리에 항목을 하나하나 채우는 예이다. prices = {} # 빈 딕셔너리로 초기화 # 새 항목을 삽입 prices['GOOG'] = 513.25 prices['CAT'] = 87.22 prices['IBM'] = 93.37 다음은 파일 내용으로부터 딕셔너리를 채우는 예이다. prices = {} # 빈 딕셔너리로 초기화 with open('Data/prices.csv', 'rt') as f: for line in f: row = line.split(',') prices[row[0]] = float(row[1]) 참고: Data/prices.csv 파일을 가지고 이것을 시도하면 잘 되다가 마지막에 공백 행이 있어 충돌한다. 문제가 생기지 않게 코드를 수정해야 한다(연습 문제 2.6을 참조). 딕셔너리 조회 키가 존재하는지 테스트할 수 있다. if key in d: # YES else: # NO 존재하지 않는 값을 찾으려 할 경우 기본값을 제공할 수 있다. name = d.get(key, default) 예: >>> prices.get('IBM', 0.0) 93.37 >>> prices.get('SCOX', 0.0) 0.0 >>> 복합 키(composite keys) 파이썬에서는 어떤 타입의 값이든 딕셔너리의 키로 사용할 수 있다. 딕셔너리 키는 반드시 변경 불가능한 타입이어야 한다. 튜플의 예: holidays = { (1, 1) : 'New Years', (3, 14) : 'Pi day', (9, 13) : "Programmer's day", } 액세스: >>> holidays[3, 14] 'Pi day' >>> 리스트, 세트, 다른 딕셔너리는 변경 가능(mutable) 하므로 딕셔너리의 키로 사용할 수 없다. 세트 세트는 고유 항목의 모음이며 순서를 유지하지 않는다. tech_stocks = { 'IBM','AAPL','MSFT' } # 대체 구문 tech_stocks = set(['IBM', 'AAPL', 'MSFT']) 세트는 멤버십 테스트에 유용하다. >>> tech_stocks set(['AAPL', 'IBM', 'MSFT']) >>> 'IBM' in tech_stocks True >>> 'FB' in tech_stocks False >>> 세트는 중복 제거에도 유용하다. names = ['IBM', 'AAPL', 'GOOG', 'IBM', 'GOOG', 'YHOO'] unique = set(names) # unique = set(['IBM', 'AAPL','GOOG','YHOO']) 그 외의 집합(set) 연산: names.add('CAT') # 항목을 추가 names.remove('YHOO') # 항목을 제거 s1 | s2 # 합집합 s1 & s2 # 교집합 s1 - s2 # 차집합 연습 문제 이 연습 문제에서는 이 코스에서 계속 사용할 주된 프로그램 중 하나를 만들기 시작한다. Work/report.py 파일을 가지고 작업하라. 연습 문제 2.4: 튜플의 리스트 Data/portfolio.csv 파일에는 포트폴리오에 편입된 주식 목록이 있다. 연습 문제 1.30에서, 우리는 이 파일을 읽고 간단한 계산을 수행하는 portfolio_cost(filename) 함수를 작성했다. 코드가 다음과 같을 것이다. # pcost.py import csv def portfolio_cost(filename): '''포트폴리오 파일의 총비용(주식 수*가격)을 계산''' total_cost = 0.0 with open(filename, 'rt') as f: rows = csv.reader(f) headers = next(rows) for row in rows: nshares = int(row[1]) price = float(row[2]) total_cost += nshares * price return total_cost 이 코드를 참고해, 새로운 report.py 파일을 생성하라. 그 파일에서, 주어진 포트폴리오 파일을 열고 내용을 읽어 튜플의 리스트를 생성하는 read_portfolio(filename) 함수를 정의한다. 이를 위해, 위의 코드를 약간 수정해야 한다. 먼저, total_cost = 0를 정의하는 대신, 변수를 만들어 빈 리스트로 초기화한다. 예: portfolio = [] 다음으로, 총비용을 계산하는 대신, 이전 연습 문제에서 했던 것과 똑같은 방법으로 각 행을 튜플로 바꿔서 리스트에 추가한다. 예: for row in rows: holding = (row[0], int(row[1]), float(row[2])) portfolio.append(holding) 끝으로, 결과 portfolio 리스트를 반환한다. 작성한 함수를 상호작용적으로 실험해 보라(그렇게 하려면 인터프리터에서 report.py부터 실행해야 한다). 힌트: 파일을 터미널에서 실행할 때는 -i를 사용한다. >>> portfolio = read_portfolio('Data/portfolio.csv') >>> portfolio [('AA', 100, 32.2), ('IBM', 50, 91.1), ('CAT', 150, 83.44), ('MSFT', 200, 51.23), ('GE', 95, 40.37), ('MSFT', 50, 65.1), ('IBM', 100, 70.44)] >>> >>> portfolio[0] ('AA', 100, 32.2) >>> portfolio[1] ('IBM', 50, 91.1) >>> portfolio[1][1] 50 >>> total = 0.0 >>> for s in portfolio: total += s[1] * s[2] >>> print(total) 44671.15 >>> 방금 생성한 튜플의 리스트는 2차원 배열과 매우 비슷하다. 예를 들어, portfolio[row][column]와 같이 조회해 특정 row와 column에 액세스할 수 있다(row와 column은 정수). 따라서, 다음과 같은 구문을 사용해 마지막 for 루프를 재작성할 수도 있다. >>> total = 0.0 >>> for name, shares, price in portfolio: total += shares*price >>> print(total) 44671.15 >>> 연습 문제 2.5: 딕셔너리의 리스트 연습 문제 2.4에서 작성한 함수를 수정해, 포트폴리오에 있는 주식을 튜플 대신 딕셔너리로 나타내게 해 보자. 이 딕셔너리에서 입력 파일의 칼럼들을 나타내기 위해, 각각 "name", "shares", "price"라는 필드명을 사용한다. 이 함수를 연습 문제 2.4에서 했던 것과 같은 방식으로 실험해 보라. >>> portfolio = read_portfolio('Data/portfolio.csv') >>> portfolio [{'name': 'AA', 'shares': 100, 'price': 32.2}, {'name': 'IBM', 'shares': 50, 'price': 91.1}, {'name': 'CAT', 'shares': 150, 'price': 83.44}, {'name': 'MSFT', 'shares': 200, 'price': 51.23}, {'name': 'GE', 'shares': 95, 'price': 40.37}, {'name': 'MSFT', 'shares': 50, 'price': 65.1}, {'name': 'IBM', 'shares': 100, 'price': 70.44}] >>> portfolio[0] {'name': 'AA', 'shares': 100, 'price': 32.2} >>> portfolio[1] {'name': 'IBM', 'shares': 50, 'price': 91.1} >>> portfolio[1]['shares'] 50 >>> total = 0.0 >>> for s in portfolio: total += s['shares']*s['price'] >>> print(total) 44671.15 >>> 여기서 각 항목의 필드에 접근할 때는 숫자로 된 칼럼 번호 대신 키 이름을 사용한 것을 볼 수 있다. 나중에 코드를 읽기 수월하므로 이 방법을 선호한다. 큰 딕셔너리와 리스트를 조회하는 것은 지저분해질 수 있다. 디버깅을 위해 출력을 정돈하려면 pprint 함수를 사용하는 것을 고려하라. >>> from pprint import pprint >>> pprint(portfolio) [{'name': 'AA', 'price': 32.2, 'shares': 100}, {'name': 'IBM', 'price': 91.1, 'shares': 50}, {'name': 'CAT', 'price': 83.44, 'shares': 150}, {'name': 'MSFT', 'price': 51.23, 'shares': 200}, {'name': 'GE', 'price': 40.37, 'shares': 95}, {'name': 'MSFT', 'price': 65.1, 'shares': 50}, {'name': 'IBM', 'price': 70.44, 'shares': 100}] >>> 연습 문제 2.6: 컨테이너로서의 딕셔너리 딕셔너리는 항목을 정수 이외의 인덱스를 사용해 조회하고자 할 때 유용하다. 파이썬 셸에서 딕셔너리를 가지고 놀아보자. >>> prices = { } >>> prices['IBM'] = 92.45 >>> prices['MSFT'] = 45.12 >>> prices ... 결과를 살펴 보라 ... >>> prices['IBM'] 92.45 >>> prices['AAPL'] ... 결과를 살펴 보라 ... >>> 'AAPL' in prices False >>> Data/prices.csv 파일은 여러 행에 걸쳐 주식 가격을 담고 있다. 파일 내용은 다음과 같다. "AA",9.22 "AXP",24.85 "BA",44.85 "BAC",11.27 "C",3.72 ... 이와 같은 가격 정보를 읽어 딕셔너리를 생성하는 read_prices(filename) 함수를 작성하라. 딕셔너리 키는 종목명으로, 값은 주식 가격으로 한다. 위에서 했던 것처럼 빈 딕셔너리를 먼저 만들고 나서 값을 삽입하라. 이번에는 파일에서 값을 읽는다는 점이 다르다. 이 자료 구조를 사용하면 종목명을 재빨리 조회할 수 있다. 몇 가지 팁이 있다. 먼저, 앞에서 한 것처럼 csv 모듈을 사용하라. 바퀴를 재발명할 필요는 없다. >>> import csv >>> f = open('Data/prices.csv', 'r') >>> rows = csv.reader(f) >>> for row in rows: print(row) ['AA', '9.22'] ['AXP', '24.85'] ... [] >>> 또 다른 복잡성은 Data/prices.csv 파일에 공백 행이 있을 수 있다는 점이다. 위에서 데이터의 마지막 행은 빈 리스트다. 즉, 그 행에는 아무 데이터도 표시하지 않았다. 그것 때문에 프로그램이 예외를 내며 죽어버릴 가능성이 있다. try와 except 문을 사용해 예외를 처리하자. 생각할 거리: 예외 처리 대신 if 문을 사용해 나쁜 데이터를 차단하는 것이 나을까? read_prices() 함수를 작성했으면, 제대로 작동하는지 테스트해 보라. >>> prices = read_prices('Data/prices.csv') >>> prices['IBM'] 106.28 >>> prices['MSFT'] 20.89 >>> 연습 문제 2.7: 은퇴해도 되는지 알아보기 지금까지 배운 것을 모두 활용해 report.py 프로그램을 만들어 보자. 연습 문제 2.5의 주식 목록과 연습 문제 2.6의 가격 딕셔너리를 받아서 포트폴리오의 현재 가치와 손익을 계산한다. 2.3 포매팅 데이터를 가지고 작업할 때 구조화된 출력(테이블 등)을 생성하고자 할 때가 있다. 예: Name Shares Price ---------- ---------- ----------- AA 100 32.20 IBM 50 91.10 CAT 150 83.44 MSFT 200 51.23 GE 95 40.37 MSFT 50 65.10 IBM 100 70.44 문자열 포매팅 파이썬 3.6 이상에서는 문자열 포매팅에 f 문자열(f-string)을 사용할 수 있다. >>> name = 'IBM' >>> shares = 100 >>> price = 91.1 >>> f'{name:>10s} {shares:>10d} {price:>10.2f}' ' IBM 100 91.10' >>> {표현식:포맷} 부분이 대체된다. 이것을 다음과 같이 print 문과 함께 사용한다. print(f'{name:>10s} {shares:>10d} {price:>10.2f}') 포맷 코드 포맷 코드({} 내의 : 이후)는 C의 printf()와 비슷하다. 일반적인 코드는 다음과 같다. d 십진 정수 b 이진 정수 x 16진 정수 f 부동소수점수 [-] m.dddddd e 부동소수점수 [-] m.dddddde+-xx g E 표기를 선택적으로 사용하는 부동소수점 s 문자열 c 문자(정수로부터) 필드 폭과 정밀도를 조정하는 공통 수정자. 이것은 부분적인 목록이다. :>10d 정수를 10자리 필드에 오른쪽 정렬 :<10d 정수를 10자리 필드에 왼쪽 정렬 :^10d 정수를 10자리 필드에 가운데 정렬 :0.2f 부동소수점수를 두 자리 정밀도로 나타냄 딕셔너리 포매팅 format_map() 메서드를 사용해 값들의 딕셔너리에 문자열 포매팅을 적용할 수 있다. >>> s = { 'name': 'IBM', 'shares': 100, 'price': 91.1 } >>> '{name:>10s} {shares:10d} {price:10.2f}'.format_map(s) ' IBM 100 91.10' >>> 그것은 f 문자열과 같은 코드를 사용하되, 제공된 딕셔너리로부터 값을 취한다. format() 메서드 format() 메서드는 인자 또는 키워드 인자에 대한 포매팅을 적용할 수 있다. >>> '{name:>10s} {shares:10d} {price:10.2f}'.format(name='IBM', shares=100, price=91.1) ' IBM 100 91.10' >>> '{:10s} {:10d} {:10.2f}'.format('IBM', 100, 91.1) ' IBM 100 91.10' >>> 솔직히, format()은 다소 장황하다. 나는 f 문자열을 선호한다. C 스타일 포매팅 포매팅 연산자 %를 사용할 수도 있다. >>> 'The value is %d' % 3 'The value is 3' >>> '% 5d %-5d % 10d' % (3,4,5) ' 3 4 5' >>> '% 0.2f' % (3.1415926, ) '3.14' 이때 오른쪽에는 단일 항목 또는 튜플이 있어야 한다. 포맷 코드는 C의 printf()와 유사하다. 참고: 이것은 바이트 문자열에 대해서만 사용 가능한 포매팅이다. >>> b'%s has %n messages' % (b'Dave', 37) b'Dave has 37 messages' >>> 연습 문제 연습 문제 2.8: 숫자를 포맷하는 법 숫자를 프린팅 할 때의 공통적인 문제는 십진수의 자릿수를 지정하는 것이다. 이것을 해결하는 한 가지 방법은 f 문자열을 사용하는 것이다. 다음 예를 시도해 보자. >>> value = 42863.1 >>> print(value) 42863.1 >>> print(f'{value:0.4f}') 42863.1000 >>> print(f'{value:>16.2f}') 42863.10 >>> print(f'{value:<16.2f}') 42863.10 >>> print(f'{value:*>16, .2f}') *******42,863.10 >>> f 문자열에서 사용하는 포매팅 코드에 대한 완전한 문서는 여기서 찾을 수 있다. 문자열의 % 연산자를 사용해 포매팅을 수행할 수도 있다. >>> print('% 0.4f' % value) 42863.1000 >>> print('% 16.2f' % value) 42863.10 >>> % 과 함께 사용되는 여러 가지 코드에 대한 문서를 여기서 찾을 수 있다. 문자열 포매팅을 print와 함께 사용하는 것이 일반적이기는 하지만, 반드시 그렇게 해야 하는 것은 아니다. 포매팅한 문자열을 저장할 수도 있다. 다음과 같이 변수에 할당하면 된다. >>> f = '% 0.4f' % value >>> f '42863.1000' >>> 연습 문제 2.9: 데이터 수집하기 연습 문제 2.7에서 주식 포트폴리오의 손익을 계산하는 report.py라는 프로그램을 작성했다. 이 연습 문제에서는 그 프로그램을 수정해 다음과 같은 테이블을 생성한다. Name Shares Price Change ---------- ---------- ---------- ---------- AA 100 9.22 -22.98 IBM 50 106.28 15.18 CAT 150 35.46 -47.98 MSFT 200 20.89 -30.34 GE 95 13.48 -26.89 MSFT 50 20.89 -44.21 IBM 100 106.28 35.84 이 보고서에서 "Price"는 주식의 현재 가격이며 "Change"는 처음 매수한 가격과의 차이를 나타낸다. 위와 같은 보고서를 생성하려면, 우선 테이블에 있는 데이터를 모두 수집해야 한다. 종목 리스트와 가격 딕셔너리를 입력으로 취해서 위의 테이블과 같은 행을 포함하는 튜플의 리스트를 반환하는 make_report() 함수를 작성하자. 이 함수를 report.py 파일에 추가한다. 상호작용하면 다음과 같이 작동해야 한다. >>> portfolio = read_portfolio('Data/portfolio.csv') >>> prices = read_prices('Data/prices.csv') >>> report = make_report(portfolio, prices) >>> for r in report: print(r) ('AA', 100, 9.22, -22.980000000000004) ('IBM', 50, 106.28, 15.180000000000007) ('CAT', 150, 35.46, -47.98) ('MSFT', 200, 20.89, -30.339999999999996) ('GE', 95, 13.48, -26.889999999999997) ... >>> 연습 문제 2.10: 포매팅된 테이블을 프린팅 하기 연습 문제 2.9의 for 루프에서 print 문을 수정해 튜플을 포매팅한다. >>> for r in report: print('% 10s % 10d % 10.2f % 10.2f' % r) AA 100 9.22 -22.98 IBM 50 106.28 15.18 CAT 150 35.46 -47.98 MSFT 200 20.89 -30.34 ... >>> 값을 확장해 f 문자열을 사용할 수도 있다. 예: >>> for name, shares, price, change in report: print(f'{name:>10s} {shares:>10d} {price:>10.2f} {change:>10.2f}') AA 100 9.22 -22.98 IBM 50 106.28 15.18 CAT 150 35.46 -47.98 MSFT 200 20.89 -30.34 ... >>> 위문장을 report.py 프로그램에 추가하자. make_report() 함수의 출력을 사용해 보기 좋게 포매팅된 테이블을 프린트하게 프로그램을 작성하라. 연습 문제 2.11: 헤더 추가하기 다음과 같이 헤더의 튜플이 있다고 하자. headers = ('Name', 'Shares', 'Price', 'Change') 위와 같은 헤더의 튜플을 가지고 문자열을 생성하는 코드를 프로그램에 추가하라. 헤더 폭은 10자리, 헤더 이름은 오른쪽 정렬하고, 각 필드는 공백 한 개로 구분한다. ' Name Shares Price Change' 헤더를 가지고, 다음과 같이 헤더와 데이터를 구분하는 문자열을 생성하는 코드를 작성하라. 이 문자열은 각 필드명 아래에 "-" 문자를 여러 개 사용한 것이다. 예: '---------- ---------- ---------- -----------' 완료된 프로그램은 이 연습의 처음에 보인 것과 같은 테이블을 생성해야 한다. Name Shares Price Change ---------- ---------- ---------- ---------- AA 100 9.22 -22.98 IBM 50 106.28 15.18 CAT 150 35.46 -47.98 MSFT 200 20.89 -30.34 GE 95 13.48 -26.89 MSFT 50 20.89 -44.21 IBM 100 106.28 35.84 연습 문제 2.12: 포매팅 도전 가격에 통화 기호($)를 포함해 다음과 같이 출력하게 수정해 보라. Name Shares Price Change ---------- ---------- ---------- ---------- AA 100 $9.22 -22.98 IBM 50 $106.28 15.18 CAT 150 $35.46 -47.98 MSFT 200 $20.89 -30.34 GE 95 $13.48 -26.89 MSFT 50 $20.89 -44.21 IBM 100 $106.28 35.84 2.4 시퀀스 시퀀스 자료형 파이썬에는 세 가지 시퀀스(sequence) 자료형이 있다. 문자열: 'Hello'. 문자열(string)은 문자(character)들의 시퀀스다. 리스트: [1, 4, 5]. 튜플: ('GOOG', 100, 490.1). 모든 시퀀스는 순서가 유지되고, 정수로 인덱싱하며, 길이가 있다. a = 'Hello' # 문자열 b = [1, 4, 5] # 리스트 c = ('GOOG', 100, 490.1) # 튜플 # 인덱싱된 순서 a[0] # 'H' b[-1] # 5 c[1] # 100 # 시퀀스의 길이 len(a) # 5 len(b) # 3 len(c) # 3 시퀀스를 복제할 수 있다(s * n). >>> a = 'Hello' >>> a * 3 'HelloHelloHello' >>> b = [1, 2, 3] >>> b * 2 [1, 2, 3, 1, 2, 3] >>> 같은 타입의 시퀀스끼리 이어붙일 수 있다(s + t). >>> a = (1, 2, 3) >>> b = (4, 5) >>> a + b (1, 2, 3, 4, 5) >>> >>> c = [1, 5] >>> a + c Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: can only concatenate tuple (not "list") to tuple 슬라이싱(Slicing) 시퀀스의 일부(subsequence)를 취하는 것을 슬라이싱이라 한다. s[start:end] 구문을 사용한다. start와 end는 얻고자 하는 서브 시퀀스의 인덱스다. a = [0,1,2,3,4,5,6,7,8] a[2:5] # [2,3,4] a[-5:] # [4,5,6,7,8] a[:3] # [0,1,2] start와 end 인덱스는 반드시 정수여야 한다. 슬라이스는 end 값을 포함하지 않는다. 수학에서 한쪽만 열린 구간(interval)과 비슷하다. 인덱스를 생략하면 리스트의 시작이나 끝을 기본값으로 사용한다. 슬라이스 재할당(re-assignment) 리스트에서 슬라이스를 다시 할당하거나 삭제할 수 있다. # 재할당 a = [0,1,2,3,4,5,6,7,8] a[2:4] = [10,11,12] # [0,1,10,11,12,4,5,6,7,8] 참고: 재할당된 슬라이스는 길이가 똑같을 필요가 없다. # 삭제 a = [0,1,2,3,4,5,6,7,8] del a[2:4] # [0,1,4,5,6,7,8] 시퀀스 축소(Reduction) 시퀀스를 단일 값으로 줄이는 몇 가지 함수가 있다. >>> s = [1, 2, 3, 4] >>> sum(s) 10 >>> min(s) >>> max(s) >>> t = ['Hello', 'World'] >>> max(t) 'World' >>> 시퀀스에 대한 이터레이션 for 루프는 시퀀스의 원소에 대해 이터레이션을 수행한다. >>> s = [1, 4, 9, 16] >>> for i in s: ... print(i) ... 4 16 >>> 각 이터레이션에서 새 항목을 얻어 작업한다. 이러한 새 값이 이터레이션 변수에 할당된다. 이 예에서 이터레이션 변수는 x다. for x in s: # `x`는 이터레이션 변수 ...문장 각 이터레이션에서, 이터레이션 변수에 있는 이전 값을 덮어쓴다. 루프가 끝난 후 변수는 최종 값을 갖는다. break 문 break 문을 사용해 루프에서 일찍 빠져나갈 수 있다. for name in namelist: if name == 'Jake': break ... ... 문장 문장의 실행을 break 하면 루프에서 빠져나가서 다음 문장을 수행한다. break 문은 가장 안쪽 루프에만 적용된다. 만약 이 루프가 다른 루프 안에 있다면, 바깥쪽 루프는 빠져나지 않는다. continue 문 한 원소를 건너뛰고 다음으로 가려면 continue 문을 사용한다. for line in lines: if line == '\n': # 공백 행을 건너뜀 continue # 나머지 문장들 ... 현재 항목에 관심이 없거나 처리 과정에서 무시해야 할 때 유용하다. 정수에 대해 루핑 카운트를 하고 싶으면 range()를 써라. for i in range(100): # i = 0,1, ...,99 구문은 range([start,] end [,step])이다. for i in range(100): # i = 0,1, ...,99 for j in range(10,20): # j = 10,11, ..., 19 for k in range(10,50,2): # k = 10,12, ...,48 # step이 1이 아니라 2일 때 어떤 식으로 카운트하는지 눈여겨 보라. end 값은 포함하지 않는다. 이는 슬라이스의 작동과 같다. start는 선택적이고, 기본값이 0이다. step도 선택적이며, 기본값이 1이다. range()는 필요에 따라 값을 계산한다. 실제로 많은 숫자를 저장하지는 않는다. enumerate() 함수 enumerate 함수는 이터레이션에 카운터 값을 추가한다. names = ['Elwood', 'Jake', 'Curtis'] for i, name in enumerate(names): # i = 0, name = 'Elwood'를 가지고 루프 # i = 1, name = 'Jake' # i = 2, name = 'Curtis' 일반적 형태는 enumerate(시퀀스 [, start = 0])이다. start는 선택적이다. enumerate()를 사용하는 좋은 예는 파일을 읽으면서 행 번호를 추적하는 것이다. with open(filename) as f: for lineno, line in enumerate(f, start=1): ... enumerate는 다음 코드를 축약하는 셈이다. i = 0 for x in s: 문장 i += 1 enumerate를 사용하면 타이핑을 적게 할 수 있고 속도도 약간 더 빠르다. for와 튜플 여러 개의 이터레이션 변수(iteration variable)를 사용해 루핑을 할 수 있다. points = [ (1, 4),(10, 40),(23, 14),(5, 6),(7, 8) ] for x, y in points: # x = 1, y = 4를 가지고 루핑 # x = 10, y = 40 # x = 23, y = 14 # ... 여러 개의 변수를 사용할 때, 각 튜플은 이터레이션 변수의 세트로 언팩(unpacked) 된다. 변수의 개수는 각 튜플의 항목 수와 일치해야 한다. zip() 함수 zip 함수는 여러 시퀀스를 결합해 이터 레이터(iterator)를 만든다. columns = ['name', 'shares', 'price'] values = ['GOOG', 100, 490.1 ] pairs = zip(columns, values) # ('name','GOOG'), ('shares',100), ('price',490.1) 결과를 얻으려면 반드시 이터레이션을 해야 한다. 앞서 본 것처럼 여러 개의 변수를 사용해 튜플을 언팩 할 수 있다. for column, value in pairs: ... zip의 일반적인 용도는 딕셔너리를 생성하기 위한 키/값 쌍을 생성하는 것이다. d = dict(zip(columns, values)) 연습 문제 연습 문제 2.13: 카운팅 기본적인 카운팅을 해 보자. >>> for n in range(10): # 0 ... 9를 카운트 print(n, end=' ') 0 1 2 3 4 5 6 7 8 9 >>> for n in range(10,0, -1): # 10 ... 1을 카운트 print(n, end=' ') 10 9 8 7 6 5 4 3 2 1 >>> for n in range(0,10,2): # 0, 2, ... 8을 카운트 print(n, end=' ') 0 2 4 6 8 >>> 연습 문제 2.14: 더 많은 시퀀스 연산 시퀀스 축소 연산을 상호작용적으로 실험해 보자. >>> data = [4, 9, 1, 25, 16, 100, 49] >>> min(data) >>> max(data) 100 >>> sum(data) 204 >>> 데이터에 대해 루핑을 해 보자. >>> for x in data: print(x) 9 ... >>> for n, x in enumerate(data): print(n, x) 0 4 1 9 2 1 ... >>> 파이썬 초보자들은 for 문, len(), range()를 사용해 C 프로그램처럼 보이는 끔찍한 코드를 작성하곤 한다. >>> for n in range(len(data)): print(data[n]) 9 ... >>> 이러지 마라! 가독성도 떨어지는 데다 메모리를 비효율적으로 사용하며 실행 속도도 느려진다. 평범한 for 루프를 써서 데이터를 이터 레이트 하라. 인덱스를 써야 할 합당한 이유가 있을 때는 enumerate()를 사용하라. 연습 문제 2.15: 실용적인 enumerate() 예제 주식 포트폴리오 데이터가 있는 Data/missing.csv의 일부 행에는 데이터가 누락되어 있다. enumerate()를 사용해 pcost.py 프로그램이 잘못된 입력을 만나면 행 번호와 경고 메시지를 프린트하게 해 보라. >>> cost = portfolio_cost('Data/missing.csv') Row 4: Couldn't convert: ['MSFT', '', '51.23'] Row 7: Couldn't convert: ['IBM', '', '70.44'] >>> 이렇게 하려면 코드를 몇 군데 수정해야 한다. ... for rowno, row in enumerate(rows, start=1): try: ... except ValueError: print(f'Row {rowno}: Bad row: {row}') 연습 문제 2.16: zip() 함수 사용하기 Data/portfolio.csv 파일의 첫 행에는 칼럼 헤더가 있다. 이전 코드에서는 그 부분을 버렸다. >>> f = open('Data/portfolio.csv') >>> rows = csv.reader(f) >>> headers = next(rows) >>> headers ['name', 'shares', 'price'] >>> 헤더를 잘 활용할 수 있다면 좋지 않을까? zip() 함수를 이용해 보자. 먼저, 파일 헤더를 데이터 행과 짝을 짓는다. >>> row = next(rows) >>> row ['AA', '100', '32.20'] >>> list(zip(headers, row)) [ ('name', 'AA'), ('shares', '100'), ('price', '32.20') ] >>> zip()이 어떻게 칼럼 헤더와 칼럼 값의 짝을 만드는지 눈여겨 보라. 그 결과를 리스트로 바꾸기 위해 list()를 사용했으므로 확인할 수 있다. zip()으로 이터 레이터를 생성하여 for 루프에서 소비하는 것이 보통이다. 이러한 짝짓기는 딕셔너리를 만들어내는 중간 단계다. 이번에는 이렇게 해 보자. >>> record = dict(zip(headers, row)) >>> record {'price': '32.20', 'name': 'AA', 'shares': '100'} >>> 이러한 변환 방식은 데이터 파일을 많이 처리할 때 매우 유용한 트릭이다. 예를 들어, pcost.py 프로그램이 다양한 입력을 처리하게 하되, 종목명, 주식 수, 가격이 나타나는 실제 칼럼 번호를 참고하고 싶다고 하자. pcost.py의 portfolio_cost() 함수를 다음과 같이 수정한다. # pcost.py def portfolio_cost(filename): ... for rowno, row in enumerate(rows, start=1): record = dict(zip(headers, row)) try: nshares = int(record['shares']) price = float(record['price']) total_cost += nshares * price # 위의 int()와 float() 변환 시 발생하는 오류를 처리 except ValueError: print(f'Row {rowno}: Bad row: {row}') ... 이제 완전히 다른 데이터 파일을 함수에 적용해 보자. Data/portfoliodate.csv는 다음과 같다. name, date, time, shares, price "AA","6/11/2007","9:50am",100,32.20 "IBM","5/13/2007","4:20pm",50,91.10 "CAT","9/23/2006","1:30pm",150,83.44 "MSFT","5/17/2007","10:30am",200,51.23 "GE","2/1/2006","10:45am",95,40.37 "MSFT","10/31/2006","12:05pm",50,65.10 "IBM","7/9/2006","3:15pm",100,70.44 >>> portfolio_cost('Data/portfoliodate.csv') 44671.15 >>> 데이터 파일이 앞에서 사용한 것과 완전히 달라지더라도 프로그램이 여전히 작동할 것이다. 멋지지 않은가! 코드를 많이 바꾸지 않았지만 그 효과는 상당하다. 새로운 버전의 portfolio_cost() 함수에서는 고정된 파일<NAME>을 하드코딩하는 대신, 어느 CSV 파일이 들어오더라도 원하는 값을 골라낼 수 있게 됐다. 필요한 칼럼이 파일에 있기만 하면 코드는 잘 작동한다. 섹션 2.3에서 작성한 report.py 프로그램에, 칼럼 헤더를 선택하는 기술을 적용해 보자. Data/portfoliodate.csv 파일에 대해 report.py 프로그램을 실행해, 이전과 같은 답을 만들어내는지 확인해 보라. 연습 문제 2.17: 딕셔너리 뒤집기 딕셔너리는 키를 값에 매 팽한다. 다음은 주식 가격 딕셔너리의 예다. >>> prices = { 'GOOG' : 490.1, 'AA' : 23.45, 'IBM' : 91.1, 'MSFT' : 34.23 } >>> items() 메서드를 사용하면 (키, 값) 쌍을 얻는다. >>> prices.items() dict_items([('GOOG', 490.1), ('AA', 23.45), ('IBM', 91.1), ('MSFT', 34.23)]) >>> 그런데, 만약 (값, 키)의 쌍이 필요하다면 어떻게 해야 할까? 힌트: zip()을 사용한다. >>> pricelist = list(zip(prices.values(),prices.keys())) >>> pricelist [(490.1, 'GOOG'), (23.45, 'AA'), (91.1, 'IBM'), (34.23, 'MSFT')] >>> 이렇게 해야 할 이유가 있을까? 딕셔너리 데이터에 대해 특정한 데이터 처리를 할 수 있다는 점을 한 가지 이유로 들 수 있다. >>> min(pricelist) (23.45, 'AA') >>> max(pricelist) (490.1, 'GOOG') >>> sorted(pricelist) [(23.45, 'AA'), (34.23, 'MSFT'), (91.1, 'IBM'), (490.1, 'GOOG')] >>> 또한 이것은 튜플의 중요 기능을 보여준다. 튜플을 비교하면, 첫 번째 항목부터 원소 하나하나를 비교하게 된다. 이는 문자열의 문자 하나하나를 비교하는 것과 비슷하다. zip()은 이와 같이 서로 다른 자리의 데이터를 가지고 짝을 지어야 하는 상황에 종종 사용된다. 예를 들어, 명명된 값의 딕셔너리를 만들기 위해, 칼럼명과 칼럼 값의 쌍을 만들 수 있다. 참고로, zip()으로 1:1 쌍만 만들 수 있는 것이 아니다. 여러 개의 입력 리스트를 가지고도 그런 일을 할 수 있다. >>> a = [1, 2, 3, 4] >>> b = ['w', 'x', 'y', 'z'] >>> c = [0.2, 0.4, 0.6, 0.8] >>> list(zip(a, b, c)) [(1, 'w', 0.2), (2, 'x', 0.4), (3, 'y', 0.6), (4, 'z', 0.8))] >>> 또한, zip()은 가장 짧은 입력 시퀀스의 마지막 원소에서 멈춘다. >>> a = [1, 2, 3, 4, 5, 6] >>> b = ['x', 'y', 'z'] >>> list(zip(a, b)) [(1, 'x'), (2, 'y'), (3, 'z')] >>> 2.5 collections 모듈 collections 모듈에는 데이터 처리를 위한 유용한 객체가 많이 있다. 그중 몇 가지를 간략히 소개한다. 예: 카운트하기 보유한 주식이 다음과 같을 때, 종목별로 합산해 나타내고 싶다고 하자. portfolio = [ ('GOOG', 100, 490.1), ('IBM', 50, 91.1), ('CAT', 150, 83.44), ('IBM', 100, 45.23), ('GOOG', 75, 572.45), ('AA', 50, 23.15) ] 위 리스트에 IBM과 GOOG가 두 개씩 있다. 종목별로 합산해 보자. Counter 해법: Counter를 사용한다. from collections import Counter total_shares = Counter() for name, shares, price in portfolio: total_shares[name] += shares total_shares['IBM'] # 150 예: 일대다(One-Many) 매핑 문제: 하나의 키를 여러 개의 값에 매핑하려고 한다. portfolio = [ ('GOOG', 100, 490.1), ('IBM', 50, 91.1), ('CAT', 150, 83.44), ('IBM', 100, 45.23), ('GOOG', 75, 572.45), ('AA', 50, 23.15) ] 앞의 예와 같이, IBM을 키로 삼으면 두 개의 튜플이 있다. 해법: defaultdict를 사용한다. from collections import defaultdict holdings = defaultdict(list) for name, shares, price in portfolio: holdings[name].append((shares, price)) holdings['IBM'] # [ (50, 91.1), (100, 45.23) ] defaultdict을 사용하면 키에 액세스할 때마다 기본값을 얻는다. 예: 이력을 유지하기 문제: 마지막 N 개의 이력(history)을 유지하고 싶다. 해법: deque를 사용한다. from collections import deque history = deque(maxlen=N) with open(filename) as f: for line in f: history.append(line) ... 연습 문제 collections 모듈은 가장 유용한 라이브러리 모듈 중 하나로, 표와 인덱싱 같은 데이터를 다룰 때 특히 유용하다. 연습 문제를 통해 간단히 살펴보자. report.py 프로그램을 상호작용 모드로 실행해 주식 포트폴리오를 적재하자. bash % python3 -i report.py 연습 문제 2.18: Counter로 표 형태의 데이터 다루기 각 종목의 총 주식 수를 나타내는 표를 만들고 싶다고 하자. Counter 객체를 사용해 쉽게 할 수 있다. 한번 해 보자. >>> portfolio = read_portfolio('Data/portfolio.csv') >>> from collections import Counter >>> holdings = Counter() >>> for s in portfolio: holdings[s['name']] += s['shares'] >>> holdings Counter({'MSFT': 250, 'IBM': 150, 'CAT': 150, 'AA': 100, 'GE': 95}) >>> portfolio의 MSFT와 IBM을 어떻게 한곳에 모았는지 주의 깊게 관찰하라. Counter를 사전처럼 사용해, 각각의 값을 조회할 수 있다. >>> holdings['IBM'] 150 >>> holdings['MSFT'] 250 >>> 순위를 매기고 싶으면 다음과 같이 한다. >>> # 가장 많이 보유한 종목 3가지 >>> holdings.most_common(3) [('MSFT', 250), ('IBM', 150), ('CAT', 150)] >>> 다른 포트폴리오를 가지고 새로운 Counter를 만들어보자. >>> portfolio2 = read_portfolio('Data/portfolio2.csv') >>> holdings2 = Counter() >>> for s in portfolio2: holdings2[s['name']] += s['shares'] >>> holdings2 Counter({'HPQ': 250, 'GE': 125, 'AA': 50, 'MSFT': 25}) >>> 모든 보유 종목을 간단한 연산 하나로 결합해 보자. >>> holdings Counter({'MSFT': 250, 'IBM': 150, 'CAT': 150, 'AA': 100, 'GE': 95}) >>> holdings2 Counter({'HPQ': 250, 'GE': 125, 'AA': 50, 'MSFT': 25}) >>> combined = holdings + holdings2 >>> combined Counter({'MSFT': 275, 'HPQ': 250, 'GE': 220, 'AA': 150, 'IBM': 150, 'CAT': 150}) >>> Counter의 능력을 아주 조금만 맛보았다. 표 형태의 값을 다룰 일이 있을 때, 이것을 사용할지 고려해 보라. 부연 설명: collections 모듈 collections 모듈은 파이썬에서 가장 유용한 라이브러리 모듈 중 하나다. 사실 그것을 좀 더 설명할 수도 있었지만, 지금은 주의가 분산될 수 있어 그렇게 하지 않았다. 나중에 한가할 때 collections에 대해 읽어보라. 2.6 리스트 컴프리 헨 션 리스트의 항목을 처리하는 것은 일반적인 작업이다. 이 섹션은 강력한 도구인 리스트 컴프리 헨 션(list comprehension)을 소개한다. 새 리스트 생성하기 리스트 컴프리헨션은 시퀀스의 각 원소에 연산을 적용함으로써 새로운 리스트를 생성한다. >>> a = [1, 2, 3, 4, 5] >>> b = [2*x for x in a ] >>> b [2, 4, 6, 8, 10] >>> 다른 예: >>> names = ['Elwood', 'Jake'] >>> a = [name.lower() for name in names] >>> a ['elwood', 'jake'] >>> 일반적인 구문: [ <표현식> for <변수명> in <시퀀스> ]. 필터링 리스트 컴프리헨션을 통해 원소를 거를 수 있다. >>> a = [1, -5, 4, 2, -2, 10] >>> b = [2*x for x in a if x > 0 ] >>> b [2, 8, 4, 20] >>> 용례 리스트 컴프리헨션은 엄청나게 유용하다. 예를 들어, 특정 딕셔너리 필드의 값을 수집할 수 있다. stocknames = [s['name'] for s in stocks] 시퀀스에 데이터베이스 질의와 비슷한 것을 수행할 수 있다. a = [s for s in stocks if s['price'] > 100 and s['shares'] > 50 ] 리스트 컴프리헨션과 시퀀스 축소를 조합할 수도 있다. cost = sum([s['shares']*s['price'] for s in stocks]) 일반적인 구문 [ <표현식> for <변수명> in <시퀀스> if <조건>] 이것이 의미하는 바는 다음과 같다. result = [] for 변수명 in 시퀀스: if 조건: result.append(표현식) 리스트 컴프리헨션의 유래 리스트 컴프리헨션은 수학(조건제시법)에서 유래했다. 파이썬: a = [ x * x for x in s if x > 0 ] 수학: 이 기능은 몇몇 언어에 구현돼 있다. 코더 대부분은 수학 시간에 배운 것까지 떠올리지는 않을 것이다. 그러므로, 리스트를 쉽게 만들어주는 쿨한 구문으로 받아들여도 좋다. 연습 문제 report.py 프로그램을 실행해 상호작용 모드에서 주식 포트폴리오를 적재한다. bash % python3 -i report.py 이제, 파이썬 상호작용 프롬프트에서 다음과 같은 문장을 타이핑한다. 이 연산들은 포트폴리오 데이터에 대해 데이터 축소(reduction), 변환(transform), 질의를 다양하게 수행한다. 연습 문제 2.19: 리스트 컴프리 헨 션 리스트 컴프리 헨 션 구문에 익숙해지도록 연습해 보자. >>> nums = [1,2,3,4] >>> squares = [ x * x for x in nums ] >>> squares [1, 4, 9, 16] >>> twice = [ 2 * x for x in nums if x > 2 ] >>> twice [6, 8] >>> 리스트 컴프리헨션을 통해 새로운 리스트를 생성하는 동시에 데이터를 변환 및 필터링했다. 연습 문제 2.20: 시퀀스 축소 단 하나의 파이썬 문장을 사용해 포트폴리오의 총비용을 계산하자. >>> portfolio = read_portfolio('Data/portfolio.csv') >>> cost = sum([ s['shares'] * s['price'] for s in portfolio ]) >>> cost 44671.15 >>> 딘 일 문장으로 포트폴리오의 현재 가격도 계산해 보자. >>> value = sum([ s['shares'] * prices[s['name']] for s in portfolio ]) >>> value 28686.1 >>> 위의 두 연산은 모두 맵 축소(map-reduction)의 예다. 리스트 컴프리헨션은 리스트에 걸친 연산에 대해 매핑한다. >>> [ s['shares'] * s['price'] for s in portfolio ] [3220.0000000000005, 4555.0, 12516.0, 10246.0, 3835.1499999999996, 3254.9999999999995, 7044.0] >>> sum() 함수는 결과에 대해 축소를 수행한다. >>> sum(_) 44671.15 >>> 이 지식을 가지고, 당신은 빅데이터 스타트업 회사를 시작할 준비가 되었다. 연습 문제 2.21: 데이터 질의 다양한 데이터 질의의 예를 따라 해 보자. 먼저, 포트폴리오에서 100주 이상 보유한 종목의 리스트를 뽑아보자. >>> more100 = [ s for s in portfolio if s['shares'] > 100 ] >>> more100 [{'price': 83.44, 'name': 'CAT', 'shares': 150}, {'price': 51.23, 'name': 'MSFT', 'shares': 200}] >>> 다음은 보유한 MSFT와 IBM 주식 전체 리스트다. >>> msftibm = [ s for s in portfolio if s['name'] in {'MSFT','IBM'} ] >>> msftibm [{'price': 91.1, 'name': 'IBM', 'shares': 50}, {'price': 51.23, 'name': 'MSFT', 'shares': 200}, {'price': 65.1, 'name': 'MSFT', 'shares': 50}, {'price': 70.44, 'name': 'IBM', 'shares': 100}] >>> 다음은 보유 종목 중 가격이 10,000달러가 넘는 것의 리스트다. >>> cost10k = [ s for s in portfolio if s['shares'] * s['price'] > 10000 ] >>> cost10k [{'price': 83.44, 'name': 'CAT', 'shares': 150}, {'price': 51.23, 'name': 'MSFT', 'shares': 200}] >>> 연습 문제 2.22: 데이터 추출 portfolio에서 얻은 name과 shares를 가지고 튜플의 리스트 (name, shares)를 만들자. >>> name_shares =[ (s['name'], s['shares']) for s in portfolio ] >>> name_shares [('AA', 100), ('IBM', 50), ('CAT', 150), ('MSFT', 200), ('GE', 95), ('MSFT', 50), ('IBM', 100)] >>> 대괄호([,])를 중괄호({, })로 바꾸면 세트 컴프리헨션이 된다. 그 결과는 고유한 값들의 세트가 된다. 예를 들어, 다음은 portfolio에서 고유한 종목 명의 세트를 구한다. >>> names = { s['name'] for s in portfolio } >>> names { 'AA', 'GE', 'IBM', 'MSFT', 'CAT' } >>> key:value 쌍을 지정하면 딕셔너리를 만들 수 있다. 다음은 종목명을 보유 주식 수와 매핑하는 딕셔너리를 만드는 예다. >>> holdings = { name: 0 for name in names } >>> holdings {'AA': 0, 'GE': 0, 'IBM': 0, 'MSFT': 0, 'CAT': 0} >>> 이 기능을 딕셔너리 컴프리 헨 션(dictionary comprehension)이라 한다. 테이블로 나타내자. >>> for s in portfolio: holdings[s['name']] += s['shares'] >>> holdings { 'AA': 100, 'GE': 95, 'IBM': 150, 'MSFT':250, 'CAT': 150 } >>> prices 딕셔너리의 항목 중 포트폴리오에 포함된 종목만 추려보자. >>> portfolio_prices = { name: prices[name] for name in names } >>> portfolio_prices {'AA': 9.22, 'GE': 13.48, 'IBM': 106.28, 'MSFT': 20.89, 'CAT': 35.46} >>> 연습 문제 2.23: CSV 파일에서 데이터 추출하기 리스트, 세트, 딕셔너리를 다양하게 조합해 데이터 처리에 활용할 수 있다. CSV 파일에서 선택된 칼럼을 추출하는 예를 살펴보자. 먼저, CSV 파일에서 헤더 정보가 있는 행을 읽는다. >>> import csv >>> f = open('Data/portfoliodate.csv') >>> rows = csv.reader(f) >>> headers = next(rows) >>> headers ['name', 'date', 'time', 'shares', 'price'] >>> 다음으로, 실제 데이터 칼럼을 나열하는 변수명을 정의한다. >>> select = ['name', 'shares', 'price'] >>> 이제, 입력 CSV 파일에서 칼럼의 인덱스를 찾는다. >>> indices = [ headers.index(colname) for colname in select ] >>> indices [0, 3, 4] >>> 끝으로, 데이터의 행을 읽어 딕셔너리 컴프리헨션을 사용해 딕셔너리를 만든다. >>> row = next(rows) >>> record = { colname: row[index] for colname, index in zip(select, indices) } # 딕셔너리 컴프리 헨 션 >>> record {'price': '32.20', 'name': 'AA', 'shares': '100'} >>> 무슨 일이 일어났는지 이해했으면, 파일의 나머지 부분도 읽어보자. >>> portfolio = [ { colname: row[index] for colname, index in zip(select, indices) } for row in rows ] >>> portfolio [{'price': '91.10', 'name': 'IBM', 'shares': '50'}, {'price': '83.44', 'name': 'CAT', 'shares': '150'}, {'price': '51.23', 'name': 'MSFT', 'shares': '200'}, {'price': '40.37', 'name': 'GE', 'shares': '95'}, {'price': '65.10', 'name': 'MSFT', 'shares': '50'}, {'price': '70.44', 'name': 'IBM', 'shares': '100'}] >>> 세상에, read_portfolio() 함수를 한 문장으로 줄였다. 부연 설명 리스트 컴프리헨션은 파이썬에서 데이터를 변환, 필터링, 수집하는 데 일반적으로 사용된다. 그 구문이 복잡하므로, 가능하면 리스트 컴프리헨션을 단순하게 유지하라. 여러 단계의 코드로 나눠 구현해도 괜찮다. 예를 들어, 마지막 예제를 당신의 순진한 동료에게 불쑥 내밀어도 괜찮을지 잘 모르겠다. 어쨌든, 데이터를 빠르게 조작하는 법을 알아두면 매우 유용하다. 데이터 가져오기, 내보내기, 추출 등 일회성 문제를 해결해야 하는 상황이 많다. 리스트 컴프리헨션을 숙달하면 해결책을 고안하는 데 걸리는 시간을 상당히 줄일 수 있다. collections 모듈도 잊지 말자. 2.7 객체 이 섹션은 파이썬의 내부 객체 모델을 자세히 소개하고 메모리 관리, 복사, 타입 검사를 논의한다. 할당(Assignment) 파이썬의 많은 연산자는 값의 할당(assigning) 혹은 저장(storing)과 관련이 있다. a = value # 변수에 할당 s[n] = value # 리스트에 할당 s.append(value) # 리스트에 추가 d['key'] = value # 딕셔너리에 추가 주의: 할당 연산은 할당될 값의 사본을 절대 만들지 않는다. 모든 할당은 레퍼런스 복사(혹은 포인터 복사) 일뿐이다. 할당의 예 다음 코드를 생각해 보자. a = [1,2,3] b = a c = [a, b] 메모리 연산의 그림을 그려 보자. 이 예에는 단 한 개의 리스트 객체 [1,2,3]이 있지만, 그것을 가리키는 레퍼런스(reference)는 4개가 있다. 이것이 의미하는 바는 값을 수정하면 모든 레퍼런스에 영향을 미친다는 것이다. >>> a.append(999) >>> a [1,2,3,999] >>> b [1,2,3,999] >>> c [[1,2,3,999], [1,2,3,999]] >>> 원래의 리스트를 변경하자 모든 리스트가 바뀌어 버렸다(으악!). 사본을 만들지 않았기 때문이다. 모든 것이 같은 리스트를 가리키고 있었던 것이다. 값을 재할당 값을 재할당한다고 해서, 이전 값에서 사용한 메모리를 덮어쓰는 것이 절대 아니다. a = [1,2,3] b = a a = [4,5,6] print(a) # [4, 5, 6] print(b) # [1, 2, 3] 원래 값이 있음 기억해 줘: 변수는 이름일 뿐, 메모리 위치가 아니다. 위험성 이 공유 방식을 이해하지 못하면 자기 발등을 찍는 일이 생길 수 있다. 일반적인 시나리오. 어떤 데이터가 프라이빗(private) 사본이라고 생각해서 수정했다가 프로그램의 다른 부분에서 사용하는 데이터를 오염시키는 사고가 일어날 수 있다. 설명: 이것이 기본 자료형(int, float, string)이 변경 불가능(읽기 전용)인 한 가지 이유다. id와 레퍼런스 is 연산자를 사용해 두 값이 정확히 같은 객체인지 검사할 수 있다. >>> a = [1,2,3] >>> b = a >>> a is b True >>> is는 객체의 id(정수)를 비교한다. id는 id()를 사용해 얻을 수 있다. >>> id(a) 3588944 >>> id(b) 3588944 >>> 참고: 객체 검사에는 늘 ==를 사용하는 게 좋다. is는 종종 예상치 못한 작동을 한다. >>> a = [1,2,3] >>> b = a >>> c = [1,2,3] >>> a is b True >>> a is c False >>> a == c True >>> 얕은 복사(shallow copy) 리스트와 딕셔너리에는 복사를 위한 메서드가 있다. >>> a = [2,3, [100,101],4] >>> b = list(a) # 사본을 만듦 >>> a is b False 리스트가 새로 만들어지긴 했지만 리스트 항목은 공유된다. >>> a[2].append(102) >>> b[2] [100,101,102] >>> >>> a[2] is b[2] True >>> 예를 들어, 내부 리스트 [100, 101, 102]이 공유된다. 이것을 얕은 복사라 한다. 그림을 보자. 깊은 복사(deep copy) 객체와 그 안에 있는 모든 객체의 사본이 필요할 때가 종종 있다. 이를 위해 copy 모듈을 사용할 수 있다. >>> a = [2,3, [100,101],4] >>> import copy >>> b = copy.deepcopy(a) >>> a[2].append(102) >>> b[2] [100,101] >>> a[2] is b[2] False >>> 이름, 값, 타입 변수명은 타입을 갖지 않는다. 그저 이름일 뿐이다. 하지만, 값에는 타입이 있다. >>> a = 42 >>> b = 'Hello World' >>> type(a) <type 'int'> >>> type(b) <type 'str'> type()을 실행하면 값의 타입을 알려준다. 타입명은 함수로 사용되어 해당 타입의 값을 생성하거나, 다른 타입의 값을 해당 타입으로 변환한다. 타입 검사(Type Checking) 어떤 객체가 특정 타입이 맞는지 확인하는 방법이다. if isinstance(a, list): print('a is a list') 가능한 여러 타입 중 하나에 대해 확인한다. if isinstance(a, (list, tuple)): print('a is a list or tuple') *주의: 타입 겁사를 지나치게 사용하지 말 것. 과도한 코드 복잡성을 초래할 수 있다. 다른 사람이 당신의 코드를 사용할 때 저지를 수 있는 일반적인 실수를 방지할 수 있을 때만 사용하라. * 모든 것이 객체다 숫자, 문자열, 리스트, 함수, 예외, 클래스, 인스턴스(instance) 등 모든 것은 객체다. 모든 객체에 대해 이름을 붙이고, 데이터로 전달하고, 컨테이너에 넣는 등의 일을 아무 제약 없이 할 수 있다. 특별 대우를 받는 객체는 없다. '모든 객체가 일급'이라고도 표현한다. 간단한 예를 보자. >>> import math >>> items = [abs, math, ValueError ] >>> items [<built-in function abs>, <module 'math' (builtin)>, <type 'exceptions.ValueError'>] >>> items[0](-45) 45 >>> items[1].sqrt(2) 1.4142135623730951 >>> try: x = int('not a number') except items[2]: print('Failed!') Failed! >>> 여기서 items는 함수, 모듈, 예외를 포함하는 리스트다. 원래 이름 대신에 리스트의 항목을 바로 사용할 수 있다. items[0](-45) # abs items[1].sqrt(2) # math except items[2]: # ValueError 강력함에는 책임이 따른다. 할 수 있다고 해서 함부로 사용하지는 말자. 연습 문제 연습 문제를 통해 일급 객체의 강력함을 느껴보자. 연습 문제 2.24: 일급 데이터 Data/portfolio.csv 파일에서, 다음과 같이 칼럼으로 조직화된 데이터를 읽는다. name, shares, price "AA",100,32.20 "IBM",50,91.10 ... 이전 코드에서, 우리는 파일을 읽는 데 csv 모듈을 사용했지만, 여전히 수작업으로 형 변환을 수행해야 했다. 예: for row in rows: name = row[0] shares = int(row[1]) price = float(row[2]) 약간의 리스트 기본 연산을 사용해 이러한 유형의 변환을 좀 더 영리하게 수행할 수 있다. 각 칼럼을 적절한 타입으로 변환하는 함수의 이름을 담는 파이썬 리스트를 만들자. >>> types = [str, int, float] >>> 이런 리스트를 만드는 것조차 가능한 이유는 파이썬에서는 모든 것이 일급(first-class)이기 때문이다. 함수의 리스트를 만들고 싶다면 얼마든지 그렇게 할 수 있다. 방금 생성한 리스트의 항목은 값 x를 주어진 타입으로 변환하는 함수들이다(예: str(x), int(x), float(x)). 이제, 위 파일에서 데이터의 행을 읽는다. >>> import csv >>> f = open('Data/portfolio.csv') >>> rows = csv.reader(f) >>> headers = next(rows) >>> row = next(rows) >>> row ['AA', '100', '32.20'] >>> 이 값들은 타입이 잘못되어 계산에 부적합하다. 예: >>> row[1] * row[2] Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: can't multiply sequence by non-int of type 'str' >>> 하지만, 데이터를 types에 지정한 타입과 짝지을 수 있다. 예: >>> types[1] <type 'int'> >>> row[1] '100' >>> 값 하나를 변환해 보자. >>> types[1](row[1]) # int(row[1])와 같음 100 >>> 다른 값도 변환해 보자. >>> types[2](row[2]) # float(row[2])와 같음 32.2 >>> 변환한 값을 가지고 계산해 보자. >>> types[1](row[1])*types[2](row[2]) 3220.0000000000005 >>> zip으로 칼럼 타입과 필드를 묶은 결과는 다음과 같다. >>> r = list(zip(types, row)) >>> r [(<type 'str'>, 'AA'), (<type 'int'>, '100'), (<type 'float'>,'32.20')] >>> 타입 변환과 값이 짝 지어진 것을 볼 수 있다. 예를 들어, int는 값 '100'과 짝을 이룬다. 리스트에 zip을 사용하면 모든 값을 하나하나 변환할 수 있어 유용하다. 다음과 같이 해 보라. >>> converted = [] >>> for func, val in zip(types, row): converted.append(func(val)) ... >>> converted ['AA', 100, 32.2] >>> converted[1] * converted[2] 3220.0000000000005 >>> 위 코드에서 어떤 일이 일어나는지 이해해야 한다. 루프에서, func 변수는 타입 변환 함수들(예: str, int 등) 중 하나이며, val 변수는 'AA', '100'과 같은 값들 중 하나다. 표현식 func(val) 은 값을 변환한다(타입 캐스트와 비슷하다). 위의 코드를 단일 리스트 컴프리헨션으로 압축할 수 있다. >>> converted = [func(val) for func, val in zip(types, row)] >>> converted ['AA', 100, 32.2] >>> 연습 문제 2.25: 딕셔너리 만들기 키 이름과 값의 시퀀스를 갖고 있을 때 dict() 함수를 가지고 딕셔너리를 쉽게 만들 수 있는 것을 기억하는가? 칼럼 헤더로부터 딕셔너리를 만들자. >>> headers ['name', 'shares', 'price'] >>> converted ['AA', 100, 32.2] >>> dict(zip(headers, converted)) {'price': 32.2, 'name': 'AA', 'shares': 100} >>> 물론, 리스트 컴프리헨션에 능통하다면, 딕셔너리 컴프리헨션을 사용해 전 과정을 한 번에 끝낼 수 있다. >>> { name: func(val) for name, func, val in zip(headers, types, row) } {'price': 32.2, 'name': 'AA', 'shares': 100} >>> 연습 문제 2.26: 큰 그림 이 연습 문제의 기법을 사용해, 칼럼 위주의 데이터 파일의 필드를 파이썬 딕셔너리로 쉽게 변환하는 문장을 작성할 수 있다. 설명을 위해, 다음과 같은 데이터 파일에서 데이터를 읽는다고 가정하자. >>> f = open('Data/dowstocks.csv') >>> rows = csv.reader(f) >>> headers = next(rows) >>> row = next(rows) >>> headers ['name', 'price', 'date', 'time', 'change', 'open', 'high', 'low', 'volume'] >>> row ['AA', '39.48', '6/11/2007', '9:36am', '-0.18', '39.67', '39.69', '39.45', '181800'] >>> 비슷한 트릭을 사용해 필드를 변환하자. >>> types = [str, float, str, str, float, float, float, float, int] >>> converted = [func(val) for func, val in zip(types, row)] >>> record = dict(zip(headers, converted)) >>> record {'volume': 181800, 'name': 'AA', 'price': 39.48, 'high': 39.69, 'low': 39.45, 'time': '9:36am', 'date': '6/11/2007', 'open': 39.67, 'change': -0.18} >>> record['name'] 'AA' >>> record['price'] 39.48 >>> 보너스: date를 (6, 11, 2007)과 같은 튜플로 파싱 하려면 이 예제를 어떻게 수정해야 할까? 이 연습 문제에서 한 것을 곰곰 생각해 보라. 이 개념을 나중에 다시 살펴본다. 3. 프로그램 조직화 지금까지 파이썬 기초를 배웠으며 짧은 스크립트를 작성했다. 하지만 더 큰 프로그램을 작성하려면 조직화할 필요가 있다. 이 섹션은 함수를 작성하고 오류를 처리하는 방법을 자세히 다루며 모듈을 소개한다. 끝에 가서는 여러 파일에 걸쳐 함수로 분할된 프로그램을 작성할 수 있다. 스크립트를 작성하는 데 유용한 코드 템플릿도 제공한다. 3.1 함수와 스크립트 작성 3.2 함수에 대한 자세한 내용 3.3 예외 처리 3.4 모듈 3.5 메인 모듈 3.6 유용성을 위한 설계 논의 3.1 스크립팅 파이썬 스크립트를 작성하는 방법을 자세히 살펴보자. 스크립트(Script)란? 스크립트는 여러 문장을 실행한 다음 멈추는 프로그램이다. # program.py 문장 1 문장 2 문장 3 ... 위의 프로그램은 스크립트에 가깝다고 할 수 있다. 문제점 유용한 스크립트를 작성해 사용하다 보면 기능이 점차 늘어난다. 관련된 다른 문제에도 적용하고 싶을 수 있다. 시간이 흐름에 따라, 스크립트는 점점 더 중요한 애플리케이션이 되어 버릴 수도 있다. 이제 주의를 기울이지 않으면 큰 문제가 일어날 수 있다. 그러므로 체계를 세워야 한다. 정의하기 나중에 재사용하려면 이름을 붙여둬야 한다. def square(x): return x*x a = 42 b = a + 2 # `a`가 정의돼 있어야 함 z = square(b) # `square`와 `b`가 정의돼 있어야 함 순서가 중요하다. 변수와 함수의 정의를 항상 위쪽에 둬야 한다. 함수 정의하기 단일 작업에 관련된 코드를 한곳에 모아두는 것이 현명하다. 함수 사용하기. def read_prices(filename): prices = {} with open(filename) as f: f_csv = csv.reader(f) for row in f_csv: prices[row[0]] = float(row[1]) return prices 함수는 반복적인 연산을 단순화하기도 한다. oldprices = read_prices('oldprices.csv') newprices = read_prices('newprices.csv') 함수란 무엇인가? 함수는 문장의 시퀀스에 이름을 붙인 것이다. def funcname(args): 문장 문장 ... return 결과 함수 내에 모든 파이썬 문장을 사용할 수 있다. def foo(): import math print(math.sqrt(2)) help(math) 파이썬에는 특수한 문장이 없다(그러므로 기억하기 쉽다). 함수 정의 함수는 어떠한 순서로든 정의할 수 있다. def foo(x): bar(x) def bar(x): 문장 # 또는 def bar(x): 문장 def foo(x): bar(x) 함수는 반드시 프로그램 실행 중 사용(호출) 하기 전에 정의되어 있어야 한다. foo(3) # foo가 정의돼 있어야 한다 함수는 상향식(bottom-up)으로 작성하는 것이 일반적이다. 상향식 함수는 빌딩 블록과 같이 다뤄진다. 작고 단순한 블록부터 먼저 만든다. # myprogram.py def foo(x): ... def bar(x): ... foo(x) # 위에 정의됨 ... def spam(x): ... bar(x) # 아래에 정의됨 ... spam(42) # 함수를 사용하는 코드가 끝에 나타남 나중에 나오는 함수는 앞에 나온 함수를 바탕으로 한다. 다시 말하지만, 이것은 스타일일 뿐이다. 위 프로그램에서 중요한 것은 spam(42) 호출을 마지막에 해야 한다는 것뿐이다. 함수 설계 함수는 블랙박스(black box)로 간주하는 것이 이상적이다. 전달된 입력만 가지고 연산을 하며 글로벌 변수의 사용이나 신비한 부작용을 배제해야 한다. 모듈화(Modularity)와 예측 가능성(Predictability)을 목표로 하라. 문서 문자열(Doc Strings) 문서를 doc-string 형태로 코드에 포함하는 것이 좋다. doc-strings은 함수 이름 바로 뒤에 직접 쓴 문자열이다. help(), IDE 및 기타 도구에서 인식한다. def read_prices(filename): ''' CSV 파일에서 이름과 가격 데이터를 읽음 ''' prices = {} with open(filename) as f: f_csv = csv.reader(f) for row in f_csv: prices[row[0]] = float(row[1]) return prices 문서 문자열을 작성할 때는 함수가 무슨 일을 하는지를 짧은 문장으로 작성하는 것이 좋다. 추가 정보가 필요할 때는 짧은 사용 예제와 함게 인자에 대한 자세한 설명을 넣어라. 타입 애너 테이션(Type Annotations) 함수 정의에 선택적인 타입 힌트(type hint)를 추가할 수 있다. def read_prices(filename: str) -> dict: ''' CSV 파일에서 이름과 가격 데이터를 읽음 ''' prices = {} with open(filename) as f: f_csv = csv.reader(f) for row in f_csv: prices[row[0]] = float(row[1]) return prices 힌트는 실제로 연산을 하지는 않는다. 순전히<NAME>이다. 하지만, IDE, 코드 검사기, 기타 도구에서 사용된다. 연습 문제 섹션 2에서 주식 포트폴리오의 성과를 나타내는 보고서를 프린트하는 report.py 프로그램을 작성했다. 이 프로그램에는 몇 가지 함수가 있다. 예: # report.py import csv def read_portfolio(filename): ''' 주식 포트폴리오 파일을 읽어 딕셔너리의 리스트를 생성. name, shares, price를 키로 사용. ''' portfolio = [] with open(filename) as f: rows = csv.reader(f) headers = next(rows) for row in rows: record = dict(zip(headers, row)) stock = { 'name' : record['name'], 'shares' : int(record['shares']), 'price' : float(record['price']) } portfolio.append(stock) return portfolio ... 하지만, 스크립트로 된 일련의 계산을 수행하는 프로그램 부분도 있다. 이 코드는 프로그램의 끝부분 근처에 있다. 예: ... # 보고서를 출력 headers = ('Name', 'Shares', 'Price', 'Change') print('% 10s % 10s % 10s % 10s' % headers) print(('-' * 10 + ' ') * len(headers)) for row in report: print('% 10s % 10d % 10.2f % 10.2f' % row) ... 이 연습 문제에서, 이 프로그램의 함수 사용 부분을 좀 더 강력하게 조직화한다. 연습 문제 3.1: 프로그램을 함수의 컬렉션으로 구조화 계산과 출력을 포함한 모든 주요 연산을 함수의 컬렉션에 의해 수행하도록 report.py 프로그램을 수정하자. 특히, 보고서를 출력하는 print_report(report) 함수를 작성한다. 프로그램의 마지막 부분을 수정해 일련의 함수만 남기고 계산 코드를 없애자. 연습 문제 3.2: 프로그램 실행을 위한 최상위 함수를 작성 프로그램의 마지막 부분을 가지고 단일 함수 portfolio_report(portfolio_filename, prices_filename)로 패키징 하라. 그 함수에서 다음과 같이 호출해, 이전과 똑같은 보고서를 생성하자. portfolio_report('Data/portfolio.csv', 'Data/prices.csv') 이 최종 버전에는 일련의 함수 정의와 함께, 맨 마지막에 portfolio_report() 함수 호출만 유일하게 남긴다(이 함수가 이 프로그램과 관련된 모든 단계를 실행). 프로그램을 단일 함수로 바꾸면 입력이 바뀌더라도 쉽게 실행할 수 있다. 예를 들어, 상호작용 모드에서 프로그램을 실행한 후 다음과 같은 문장을 실행해 보라. >>> portfolio_report('Data/portfolio2.csv', 'Data/prices.csv') ... 출력을 보라 ... >>> files = ['Data/portfolio.csv', 'Data/portfolio2.csv'] >>> for name in files: print(f'{name:-^43s}') portfolio_report(name, 'prices.csv') print() ... 출력을 보라 ... >>> 부연 설명 파이썬을 사용해 문장을 순서대로 나열한 비구 조적인 스크립팅 코드를 아주 쉽게 작성할 수 있다. 큰 그림에서, 가능하다면 함수를 활용하는 것이 좋다. 언젠가는 스크립트가 커져서 진작 조직화해두지 않은 것을 아쉬워하게 된다. 또한, 파이썬은 함수를 사용하면 더 빨리 실행된다. 3.2 함수의 작동 앞에서 이미 함수를 소개했지만, 실제로 어떻게 작동하는지 좀 더 깊이 알아보자. 이 섹션의 목적은 약간의 갭을 메우고 호출 관례, 스코핑 규칙 같은 문제를 논의하는 것이다. 함수 호출하기 이 함수를 생각해 보자. def read_prices(filename, debug): ... 위치 인자를 사용해 함수를 호출할 수 있다. prices = read_prices('prices.csv', True) 키워드 인자를 가지고 함수를 호출할 수도 있다. prices = read_prices(filename='prices.csv', debug=True) 기본 인자 인자를 선택 사항으로 하고 싶을 때가 있다. 그런 경우에는 함수 정의에 기본값을 정해두라. def read_prices(filename, debug=False): ... 기본값이 할당되면 인자는 함수 호출 시 선택사항이 된다. d = read_prices('prices.csv') e = read_prices('prices.dat', True) 참고: 기본값이 있는 인자는 반드시 인자 리스트의 끝에 두어야 한다(선택적이지 않은 인자가 모두 앞쪽에 와야 한다). 선택적 인자를 키워드 인자로 하면 좋다. 두 가지 호출 방식을 비교, 대조해 보자. parse_data(data, False, True) # ????? parse_data(data, ignore_errors=True) parse_data(data, debug=True) parse_data(data, debug=True, ignore_errors=True) 키워드 인자를 사용하는 것이 대체로 가독성이 높다. 플래그 역할을 하는 인자라든지, 선택적 기능과 관련된 경우 특히 그렇다. 설계 모범 사례 함수 인자에는 항상 짧고 의미 있는 이름을 붙인다. 함수를 키워드 호출 스타일로 사용하고 싶을 수도 있다. d = read_prices('prices.csv', debug=True) 파이썬 개발 도구는 도움말 기능과 문서에서 이름을 표시한다. 값을 반환 return 문을 값을 반환한다. def square(x): return x * x 반환값이 주어지지 않거나 return 문이 없으면 None을 반환한다. def bar(x): 문장 return a = bar(4) # a = None # 또는 def foo(x): statements # `return`이 없음 b = foo(4) # b = None 여러 개의 반환값 함수는 단 하나의 값만 반환할 수 있다. 하지만, 튜플에 여러 값을 담아 반환할 수 있다. def divide(a, b): q = a // b # 몫 r = a % b # 나머지 return q, r # 튜플을 반환 용례: x, y = divide(37,5) # x = 7, y = 2 x = divide(37, 5) # x = (7, 2) 변수 스코프 프로그램은 변수에 값을 할당한다. x = value # 글로벌 변수 def foo(): y = value # 로컬 변수 변수 할당은 함수 정의의 안팎에서 일어난다. 바깥에서 정의된 변수는 '글로벌'이다. 함수 내의 변수는 '로컬'이다. 로컬 변수 함수 내에 할당된 변수는 프라이빗이다. def read_portfolio(filename): portfolio = [] for line in open(filename): fields = line.split(',') s = (fields[0], int(fields[1]), float(fields[2])) portfolio.append(s) return portfolio 이 예에서, filename, portfolio, line, fields, s는 로컬 변수다. 이 변수들은 함수 호출 이후에 보존되지 않으므로 이것들에 액세스할 수 없다. >>> stocks = read_portfolio('portfolio.csv') >>> fields Traceback (most recent call last): File "<stdin>", line 1, in ? NameError: name 'fields' is not defined >>> 로컬은 다른 곳의 변수와 충돌할 일이 없다. 글로벌 변수 함수는 같은 파일에 정의된 글로벌들의 값에 자유롭게 액세스할 수 있다. name = 'Dave' def greeting(): print('Hello', name) # 글로벌 변수 `name`을 사용 단, 함수는 글로벌을 수정할 수 없다. name = 'Dave' def spam(): name = 'Guido' spam() print(name) # 'Dave'를 프린트 기억해 줘: 함수 내의 모든 할당은 로컬이다. 글로벌을 수정하기 글로벌 변수를 수정해야만 한다면 다음과 같은 방법으로 선언한다. name = 'Dave' def spam(): global name name = 'Guido' # 위 글로벌 name을 변경 글로벌을 사용하기 전에 선언이 먼저 나타나야 하며, 관련된 변수는 반드시 함수와 같은 파일에 있어야 한다. 글로벌을 사용하는 법을 알아보기는 했지만, 별로 좋은 것은 아니다. global을 아예 사용하지 않는 것이 상책이다. 함수가 외부의 상태를 변경할 필요가 있다면, 차라리 클래스를 사용해라(나중에 다룬다). 인자 전달 함수를 호출할 때, 인자 변수는 전달된 값을 참조하는 이름이다. 이 변수들은 사본이 아니다(섹션 2.7을 참조). 변경 가능한 자료형(예: list, dict)을 전달하면 제자리에서 수정될 수 있다. def foo(items): items.append(42) # 입력 객체를 수정 a = [1, 2, 3] foo(a) print(a) # [1, 2, 3, 42] 핵심: 함수는 입력 인자의 사본을 받지 않는다. 재할당 vs 수정 변수를 수정하는 것과 변수명을 재할당하는 것의 미묘한 차이를 이해해야 한다. def foo(items): items.append(42) # 입력 객체를 수정 a = [1, 2, 3] foo(a) print(a) # [1, 2, 3, 42] # VS def bar(items): items = [4,5,6] # 다른 객체를 가리키도록 로컬 `items` 변수를 변경 b = [1, 2, 3] bar(b) print(b) # [1, 2, 3] 기억해 줘: 변수 할당은 메모리를 절대 덮어쓰지 않는다. 이름은 새 값에 바운드된다. 연습 문제 이 연습 문제들은 이 코스에서 가장 강력하고 어려운 부분을 구현한다. 지금까지의 연습 문제를 통해 익힌 여러 개념을 한곳에 모은다. 최종적인 해답은 25줄가량의 코드에 불과하지만, 시간을 들여 각 부분을 이해하도록 노력하라. report.py 프로그램에서 중요한 부분은 CSV 파일을 읽는 것이다. 예를 들어 read_portfolio() 함수는 포트폴리오 데이터의 행을 포함한 파일을 읽으며, read_prices() 함수는 가격 데이터의 행을 포함한 파일을 읽는다. 두 함수 모두 저 수준의 "fiddly" 비트가 있고 기능이 서로 비슷한다. 예를 들어, 파일을 열고 csv 모듈을 사용해 감싸서 값을 새로운 타입으로 변환한다. 파일 파싱을 실제로 많이 한다면 이런 것들을 깔끔하게 정리해 좀 더 일반적으로 사용할 수 있게 하는 것이 좋다. 이것이 우리 목표다. Work/fileparse.py 파일을 열어 이 연습을 시작하자. 이 파일을 가지고 작업한다. 연습 문제 3.3: CSV 파일 읽기 먼저 CSV 파일을 읽어 딕셔너리의 리스트에 넣는 문제부터 해결하자. fileparse.py 파일에 다음과 같은 함수를 정의한다. # fileparse.py import csv def parse_csv(filename): ''' CSV 파일을 파싱 해 레코드의 목록을 생성 ''' with open(filename) as f: rows = csv.reader(f) # 헤더를 읽음 headers = next(rows) records = [] for row in rows: if not row: # 데이터가 없는 행을 건너뜀 continue record = dict(zip(headers, row)) records.append(record) return records 이 함수는 CSV 파일을 읽어 딕셔너리의 리스트를 생성하되, 파일을 열고 csv 모듈을 가지고 감싸고, 공백 행을 건너뛰는 등의 세부사항을 숨긴다. 한번 사용해 보자. 힌트: python3 -i fileparse.py. >>> portfolio = parse_csv('Data/portfolio.csv') >>> portfolio [{'price': '32.20', 'name': 'AA', 'shares': '100'}, {'price': '91.10', 'name': 'IBM', 'shares': '50'}, {'price': '83.44', 'name': 'CAT', 'shares': '150'}, {'price': '51.23', 'name': 'MSFT', 'shares': '200'}, {'price': '40.37', 'name': 'GE', 'shares': '95'}, {'price': '65.10', 'name': 'MSFT', 'shares': '50'}, {'price': '70.44', 'name': 'IBM', 'shares': '100'}] >>> 이 함수는 좋긴 하지만, 모든 것을 문자열로 표현하기 때문에 계산에 사용할 수 없다는 아쉬움이 있다. 이 점을 곧 수정하겠지만, 일단은 계속 만들어 나가자. 연습 문제 3.4: 칼럼 선택기 구축하기 CSV 파일의 모든 데이터가 아니라 일부에만 관심이 있는 때가 많을 것이다. 다음과 같이, 가져올 칼럼을 사용자가 선택할 수 있게 parse_csv() 함수를 수정해 보자. >>> # 전체 데이터를 읽기 >>> portfolio = parse_csv('Data/portfolio.csv') >>> portfolio [{'price': '32.20', 'name': 'AA', 'shares': '100'}, {'price': '91.10', 'name': 'IBM', 'shares': '50'}, {'price': '83.44', 'name': 'CAT', 'shares': '150'}, {'price': '51.23', 'name': 'MSFT', 'shares': '200'}, {'price': '40.37', 'name': 'GE', 'shares': '95'}, {'price': '65.10', 'name': 'MSFT', 'shares': '50'}, {'price': '70.44', 'name': 'IBM', 'shares': '100'}] >>> # 일부 데이터만 읽기 >>> shares_held = parse_csv('Data/portfolio.csv', select=['name','shares']) >>> shares_held [{'name': 'AA', 'shares': '100'}, {'name': 'IBM', 'shares': '50'}, {'name': 'CAT', 'shares': '150'}, {'name': 'MSFT', 'shares': '200'}, {'name': 'GE', 'shares': '95'}, {'name': 'MSFT', 'shares': '50'}, {'name': 'IBM', 'shares': '100'}] >>> 칼럼 선택기의 예가 연습 문제 2.23에 있다. 그렇지만, 여기 한 가지 방법이 있다. # fileparse.py import csv def parse_csv(filename, select=None): ''' CSV 파일을 파싱 해 레코드의 목록을 생성 ''' with open(filename) as f: rows = csv.reader(f) # 헤더를 읽음 headers = next(rows) # 칼럼 선택기가 주어지면, 지정한 칼럼의 인덱스를 찾는다. # 또한 결과 딕셔너리에 사용할 헤더의 집합을 좁힌다 if select: indices = [headers.index(colname) for colname in select] headers = select else: indices = [] records = [] for row in rows: if not row: # 데이터가 없는 행을 건너뜀 continue # 특정 칼럼이 선택되었으면 필터링 if indices: row = [ row[index] for index in indices ] # 딕셔너리를 만듦 record = dict(zip(headers, row)) records.append(record) return records 이 부분에 몇 가지 트릭이 있다. 칼럼 선택을 행 인덱스에 매핑하는 부분이 가장 중요할 것이다. 예를 들어, 입력 파일에 다음과 같은 헤더가 있다고 하자. >>> headers = ['name', 'date', 'time', 'shares', 'price'] >>> 선택한 칼럼은 다음과 같다고 하자. >>> select = ['name', 'shares'] >>> 적절한 선택을 위해, 선택한 칼럼명을 파일의 칼럼 인덱스에 매핑해야 한다. 이 단계에서 그 일을 한다. >>> indices = [headers.index(colname) for colname in select ] >>> indices [0, 3] >>> 달리 말해, "name"은 칼럼 0이고 "shares"는 칼럼 3이다. 파일에서 데이터 행을 읽을 때, 인덱스를 사용해 원하는 칼럼만 얻을 수 있다. >>> row = ['AA', '6/11/2007', '9:50am', '100', '32.20' ] >>> row = [ row[index] for index in indices ] >>> row ['AA', '100'] >>> 연습 문제 3.5: 형 변환 수행하기 반환된 데이터에 형 변환을 적용할지 선택할 수 있게 parse_csv() 함수를 수정해 보자. 예: >>> portfolio = parse_csv('Data/portfolio.csv', types=[str, int, float]) >>> portfolio [{'price': 32.2, 'name': 'AA', 'shares': 100}, {'price': 91.1, 'name': 'IBM', 'shares': 50}, {'price': 83.44, 'name': 'CAT', 'shares': 150}, {'price': 51.23, 'name': 'MSFT', 'shares': 200}, {'price': 40.37, 'name': 'GE', 'shares': 95}, {'price': 65.1, 'name': 'MSFT', 'shares': 50}, {'price': 70.44, 'name': 'IBM', 'shares': 100}] >>> shares_held = parse_csv('Data/portfolio.csv', select=['name', 'shares'], types=[str, int]) >>> shares_held [{'name': 'AA', 'shares': 100}, {'name': 'IBM', 'shares': 50}, {'name': 'CAT', 'shares': 150}, {'name': 'MSFT', 'shares': 200}, {'name': 'GE', 'shares': 95}, {'name': 'MSFT', 'shares': 50}, {'name': 'IBM', 'shares': 100}] >>> 이것을 연습 문제 2.24에서 이미 탐구했다. 다음 코드를 당신의 코드에 포함시키자. ... if types: row = [func(val) for func, val in zip(types, row) ] ... 연습 문제 3.6: 헤더를 다루기 CSV 파일에 헤더 정보가 없는 경우도 있다 예를 들어, prices.csv는 다음과 같이 되어 있다. "AA",9.22 "AXP",24.85 "BA",44.85 "BAC",11.27 ... 튜플의 리스트를 생성함으로써 이런 파일을 다룰 수 있게 parse_csv() 함수를 수정해 보자. 예: >>> prices = parse_csv('Data/prices.csv', types=[str, float], has_headers=False) >>> prices [('AA', 9.22), ('AXP', 24.85), ('BA', 44.85), ('BAC', 11.27), ('C', 3.72), ('CAT', 35.46), ('CVX', 66.67), ('DD', 28.47), ('DIS', 24.22), ('GE', 13.48), ('GM', 0.75), ('HD', 23.16), ('HPQ', 34.35), ('IBM', 106.28), ('INTC', 15.72), ('JNJ', 55.16), ('JPM', 36.9), ('KFT', 26.11), ('KO', 49.16), ('MCD', 58.99), ('MMM', 57.1), ('MRK', 27.58), ('MSFT', 20.89), ('PFE', 15.19), ('PG', 51.94), ('T', 24.79), ('UTX', 52.61), ('VZ', 29.26), ('WMT', 49.74), ('XOM', 69.35)] >>> 이렇게 변경하려면 데이터의 첫행이 헤더 파일로 인식되지 않게 코드를 수정해야 한다. 또한, 칼럼명을 키로 삼아 딕셔너리를 생성하지 않게 수정해야 한다. 연습 문제 3.7: 다른 칼럼 구분자(delimitier)를 사용하기 콤마를 구분자로 사용하는 것이 일반적이지만, 탭이나 공백을 칼럼 구분자로 사용하는 경우도 있다. 그 예로, Data/portfolio.dat은 다음과 같다. name shares price "AA" 100 32.20 "IBM" 50 91.10 "CAT" 150 83.44 "MSFT" 200 51.23 "GE" 95 40.37 "MSFT" 50 65.10 "IBM" 100 70.44 csv.reader() 함수는 구분자를 변경하는 기능이 있다. rows = csv.reader(f, delimiter=' ') 구분자를 변경할 수 있게 parse_csv() 함수를 수정해 보자. 예: >>> portfolio = parse_csv('Data/portfolio.dat', types=[str, int, float], delimiter=' ') >>> portfolio [{'price': '32.20', 'name': 'AA', 'shares': '100'}, {'price': '91.10', 'name': 'IBM', 'shares': '50'}, {'price': '83.44', 'name': 'CAT', 'shares': '150'}, {'price': '51.23', 'name': 'MSFT', 'shares': '200'}, {'price': '40.37', 'name': 'GE', 'shares': '95'}, {'price': '65.10', 'name': 'MSFT', 'shares': '50'}, {'price': '70.44', 'name': 'IBM', 'shares': '100'}] >>> 부연 설명 여기까지 잘 수행했다면 정말 유용한 라이브러리 함수를 만든 셈이다. 이것을 가지고 임의의 CSV 파일에서 원하는 칼럼을 선택해 형 변환을 해보라. 파일의 내부 작동이나 csv 모듈 사용에 크게 신경 쓸 필요가 없다. 3.3 오류 검사 예외를 이미 다뤘지만, 이 섹션에서 오류 검사와 예외 처리에 대해 좀 더 알아보자. 프로그램은 어떻게 실패하는가 파이썬은 인자 타입이나 값에 대한 검사나 검증을 수행하지 않는다. 어떤 데이터든 함수에 기술한 것과 호환되기만 하면 함수가 작동한다. def add(x, y): return x + y add(3, 4) # 7 add('Hello', 'World') # 'HelloWorld' add('3', '4') # '34' 함수에 오류가 있으면 실행 시간에 예외로서 나타난다. def add(x, y): return x + y >>> add(3, '4') Traceback (most recent call last): ... TypeError: unsupported operand type(s) for +: 'int' and 'str' >>> 코드를 검증하기 위해 테스팅을 매우 중요시한다(나중에 다룬다). 예외 예외는 오류에 대한 신호로 사용된다. 예외를 일으키고 싶으면 raise 문을 사용하라. if name not in authorized: raise RuntimeError(f'{name} not authorized') 예외를 붙잡으려면 try-except를 사용한다. try: authenticate(user name) except RuntimeError as e: print(e) 예외 처리 예외는 처음 일치하는 except까지 전파된다. def grok(): ... raise RuntimeError('Whoa!') # 여기서 예외가 발생 def spam(): grok() # 호출하면 예외가 발생 def bar(): try: spam() except RuntimeError as e: # 예외를 여기서 잡음 ... def foo(): try: bar() except RuntimeError as e: # 예외는 여기 도달하지 않음 ... foo() 예외를 처리하려면 except 블록에 문장을 넣는다. 예외를 처리하는 데 사용하고 싶은 문장을 무엇이든 넣을 수 있다. def grok(): ... raise RuntimeError('Whoa!') def bar(): try: grok() except RuntimeError as e: # 예외를 여기서 잡음 statements # 이 문장을 사용 문장 ... bar() 처리한 다음, try-except 이후 첫 번째 문장으로 실행을 재개한다. def grok(): ... raise RuntimeError('Whoa!') def bar(): try: grok() except RuntimeError as e: # 예외를 여기서 잡음 문장 문장 ... 문장 # 예외를 여기서 재개 문장 # 여기서 계속 ... bar() 빌트인 예외 스무 가지가 넘는 빌트인 예외가 있다. 예외 이름은 무엇이 잘못됐는지 지시한다(예: 잘못된 값을 제공하면 ValueError가 일어난다). 이 목록에 있는 것 외에도 더 있다. 더 알고 싶으면 문서를 참조하라. ArithmeticError AssertionError EnvironmentError EOFError ImportError IndexError KeyboardInterrupt KeyError MemoryError NameError ReferenceError RuntimeError SyntaxError SystemError TypeError ValueError 예외 값 예외에는 관련 값이 있다. 무엇이 잘못됐는지 구체적으로 알려주는 정보가 포함된다. raise RuntimeError('Invalid user name') 이 값은 예외 인스턴스의 일부이며 except에 제공된 변수에 배치된다. try: ... except RuntimeError as e: # 발생한 예외를 `e`로 가리킨다 ... e는 예외 타입의 인스턴스다. 하지만, 이것을 프린트하면 문자열처럼 보인다. except RuntimeError as e: print('Failed : Reason', e) 여러 오류를 잡기 except 블록을 여러 개 사용해서 서로 다른 종류의 예외를 붙잡을 수 있다. try: ... except LookupError as e: ... except RuntimeError as e: ... except IOError as e: ... except KeyboardInterrupt as e: ... 또는, 처리하는 명령문이 동일하다면 그룹화할 수 있다. try: ... except (IOError, LookupError, RuntimeError) as e: ... 모든 오류를 붙잡기 예외를 붙잡으려면 다음과 같이 Exception을 사용한다. try: ... except Exception: # 위험! 아래를 참조 print('An error occurred') 일반적으로, 코드를 이런 식으로 작성하는 것은 좋은 생각이 아니다. 실패 이유를 알 수 없기 때문이다. 오류를 붙잡는 잘못된 방식 예외를 바람직하지 않은 방식으로 사용하는 예를 살펴보자. try: go_do_something() except Exception: print('Computer says no') 이렇게 하면 발생할 수 있는 모든 오류를 붙잡아 버리므로, 전혀 예상치 못한 이유로 문제가 생기는 경우(예: 파이썬 모듈을 설치하지 않았을 때 등) 디버깅이 불가능하다. 더 나은 방법 모든 오류를 다 붙잡고 싶으면 다음과 같이 접근하는 것이 좋다. try: go_do_something() except Exception as e: print('Computer says no. Reason :', e) 이렇게 하면 실패한 이유를 구체적으로 보고한다. 발생할 수 있는 모든 오류를 붙잡도록 코드를 작성할 때는 이와 같이 오류를 보고하는 메커니즘을 갖춰두는 것이 좋다. 더 좋은 방법은 오류의 범위를 좁히는 것이다. 실제로 처리할 수 있는 오류만 잡아라. 처리할 수 없는 오류는 다른 코드에서 처리하게 내버려 두라. 예외를 다시 일으키기 붙잡은 오류를 전파하려면 raise를 사용한다. try: go_do_something() except Exception as e: print('Computer says no. Reason :', e) raise 이렇게 하면 행동을 취하고(예: 로깅) 호출자에게 오류를 전달할 수 있다. 예외 모범 사례 예외를 붙잡지 않는다. 일찍 큰 소리를 내며 실패한다. 중요한 문제라면 다른 사람이 신경 써 줄 것이다. 그렇게 해 줄 다른 사람이 없을 때만 예외를 붙잡아라. 회복해서 진행이 가능한 오류만 붙잡으라는 뜻이다. finally 문 예외가 발생했는지의 여부와 관계없이 실행해야 할 코드를 지정한다. lock = Lock() ... lock.acquire() try: ... finally: lock.release() # 이것은 항상 실행된다! 예외 발생 여부와 관계없이. 리소스를 안전하게 관리하기 위해 사용한다(잠금, 파일 등). with 문 요즘은 코드에서 try-finally를 with 문으로 대신하곤 한다. lock = Lock() with lock: # 잠금을 획득 ... # 잠금 해제 좀 더 친숙한 예를 보자. with open(filename) as f: # 파일을 사용 ... # 파일을 닫음 with는 리소스 사용 콘텍스트(context)을 정의한다. 예외가 콘텍스트에서 벗어나면 리소스는 해제된다. with 문은 해당 구문을 지원하도록 특별히 프로그래밍된 객체에 대해서만 작동한다. 연습 문제 연습 문제 3.8: 예외 일으키기 지난 섹션에서 작성한 parse_csv() 함수는 사용자 정의 칼럼을 선택할 수 있게 해주지만, 입력 데이터 파일에 칼럼 헤더가 있어야만 올바로 작동한다. select와 has_headers=False 인자가 함께 전달되는 경우 예외를 일으키게 코드를 수정해 보라. 예: >>> parse_csv('Data/prices.csv', select=['name','price'], has_headers=False) Traceback (most recent call last): File "<stdin>", line 1, in <module> File "fileparse.py", line 9, in parse_csv raise RuntimeError("select argument requires column headers") RuntimeError: select argument requires column headers >>> 이 검사 외에, 함수에서 또 다른 종류의 입력값 검사를 수행해야 하는 것은 아닌지 궁금할 것이다. 예를 들어, 파일명이 문자열인지, 타입이 리스트인지, 아니면 다른 것인지 확인해야 할까? 일반적인 규칙으로, 그러한 테스트를 건너뛰고, 잘못된 입력이 들어오면 프로그램이 실패하게 내버려 두는 것이 최선일 때가 많다. 트레이스 백 메시지가 문제를 지목하여 디버깅을 도와줄 것이다. 위에서 확인을 추가한 이유는 프로그램이 무의미하게 실행되는 것을 피하기 위해서다(예: 칼럼 헤더를 필요로 하는 기능을 사용함에도 불구하고, 그와 동시에 아무 헤더도 없다고 지정하는 것). 이는 호출하는 코드에 프로그래밍 오류가 있음을 가리킨다. "발생해서는 안 되는" 케이스를 검사하는 것은 좋은 생각이다. 연습 문제 3.9: 예외를 붙잡기 앞에서 작성한 parse_csv() 함수는 파일의 전체 내용을 처리하는 데 사용된다. 하지만, 실제 세계에서는 입력 파일이 손상되거나, 값이 누락되거나, 오류 데이터가 섞여 있을 수 있다. 다음과 같이 실험해 보자. >>> portfolio = parse_csv('Data/missing.csv', types=[str, int, float]) Traceback (most recent call last): File "<stdin>", line 1, in <module> File "fileparse.py", line 36, in parse_csv row = [func(val) for func, val in zip(types, row)] ValueError: invalid literal for int() with base 10: '' >>> 레코드 생성 도중 발생한 모든 ValueError 예외를 붙잡아, 변환이 불가능한 행에 대해 경고 메시지를 프린트하도록 parse_csv() 함수를 수정하라. 메시지에 행 번호와 실패 이유를 나타내는 정보를 포함한다. 함수를 테스트하기 위해, 위의 Data/missing.csv 파일을 읽는다. 예: >>> portfolio = parse_csv('Data/missing.csv', types=[str, int, float]) Row 4: Couldn't convert ['MSFT', '', '51.23'] Row 4: Reason invalid literal for int() with base 10: '' Row 7: Couldn't convert ['IBM', '', '70.44'] Row 7: Reason invalid literal for int() with base 10: '' >>> >>> portfolio [{'price': 32.2, 'name': 'AA', 'shares': 100}, {'price': 91.1, 'name': 'IBM', 'shares': 50}, {'price': 83.44, 'name': 'CAT', 'shares': 150}, {'price': 40.37, 'name': 'GE', 'shares': 95}, {'price': 65.1, 'name': 'MSFT', 'shares': 50}] >>> 연습 문제 3.10: 오류 억제 사용자가 명시적으로 원하는 경우 오류 메시지를 발생시키지 않게 parse_csv() 함수를 수정하라. 예: >>> portfolio = parse_csv('Data/missing.csv', types=[str, int, float], silence_errors=True) >>> portfolio [{'price': 32.2, 'name': 'AA', 'shares': 100}, {'price': 91.1, 'name': 'IBM', 'shares': 50}, {'price': 83.44, 'name': 'CAT', 'shares': 150}, {'price': 40.37, 'name': 'GE', 'shares': 95}, {'price': 65.1, 'name': 'MSFT', 'shares': 50}] >>> 대부분의 프로그램에서 오류 처리는 가장 어려운 부분이다. 일반적인 규칙은 오류를 조용히 무시해 버리지 말라는 것이다. 그렇게 하는 것보다는, 문제를 보고하되 사용자가 원할 때에 한 해 오류 메시지를 숨기는 것이 낫다. 3.4 모듈 이 섹션은 모듈의 개념을 소개하고 여러 파일에 걸쳐 함수를 다룬다. 모듈과 임포트 모든 파이썬 소스 파일은 모듈이다. # foo.py def grok(a): ... def spam(b): ... import 문은 모듈을 적재(load) 하고 실행(execute) 한다. # program.py import foo a = foo.grok(2) b = foo.spam('Hello') ... 네임스페이스 모듈은 이름이 있는 변수들의 컬렉션이며, 네임스페이스(namespace)라고 부르기도 한다. 이름은 모두 글로벌 변수이며 함수는 소스 파일에 정의된다. 임포트 한 뒤, 모듈명은 프리픽스(prefix)로 사용된다. 네임스페이스라고 부르는 것은 그 때문이다. import foo a = foo.grok(2) b = foo.spam('Hello') ... 모듈명은 파일명과 직접 연관된다(foo -> foo.py). 글로벌 정의 글로벌(global) 스코프에 정의된 모든 것은 모듈 네임스페이스에 존재한다. 같은 변수 x를 정의하는 두 모듈을 생각해 보자. # foo.py x = 42 def grok(a): ... # bar.py x = 37 def spam(a): ... 두 경우 x 정의는 서로 다른 변수를 참조한다. 하나는 foo.x이고, 다른 하나는 bar.x다. 서로 다른 모듈이 같은 이름을 사용할 수 있으며, 이때 이름은 서로 충돌하지 않는다. 모듈은 독립적이다(isolated). 환경으로서의 모듈 모듈은 내부에 정의된 모든 코드를 감싸는 환경을 형성한다. # foo.py x = 42 def grok(a): print(x) 글로벌 변수들은 항상 감싸는 모듈(같은 파일)에 바인딩 된다. 각 소스 파일은 개별적인 소우주다. 모듈 실행 모듈이 임포트 될 때, 파일의 끝에 도달할 때까지 모듈의 모든 문장이 차례대로 실행된다. 모듈 네임스페이스의 내용은 모두 글로벌 이름이며 실행 과정의 끝에 정의된다. 글로벌 스코프에서 작업(프린팅, 파일 생성 등)을 수행하는 스크립팅 문장이 있다면, 임포트 할 때 수행되는 것을 볼 수 있을 것이다. import as 문 모듈을 임포트 하면서 그 이름을 바꿔 사용할 수 있다. import math as m def rectangular(r, theta): x = r * m.cos(theta) y = r * m.sin(theta) return x, y 그냥 임포트 할 때와 똑같이 작동한다. 한 파일 내에서 모듈 이름을 바꿔 부를 뿐이다. from 모듈 import 다음과 같이 모듈에서 심벌을 선택해 로컬에서 사용할 수 있다. from math import sin, cos def rectangular(r, theta): x = r * cos(theta) y = r * sin(theta) return x, y 이렇게 하면 모듈 프리픽스 없이도 모듈의 일부를 사용할 수 있다. 자주 사용하는 이름을 가져올 때 유용한 방식이다. 임포트에 대한 설명 임포트를 어떤 방식으로 사용하든, 모듈이 작동하는 방식은 달라지지 않는다. import math # vs import math as m # vs from math import cos, sin ... 특히, import는 항상 파일 전체를 실행시키며 모듈은 환경과 여전히 분리된다. import 모듈 as 문은 로컬의 이름만 바꾼다. from math import cos, sin 문은 여전히 math 모듈 전체를 적재한다. 이것을 수행하면 모듈에 있는 cos와 sin이 로컬 스페이스에 복사될 뿐이다. 모듈 적재 각 모듈은 단 한 번만 적재 및 실행된다. 참고: 임포트를 여러 번 하더라도 이전에 적재한 모듈의 레퍼런스를 반환한다. sys.modules은 적재된 모듈 전체의 딕셔너리다. >>> import sys >>> sys.modules.keys() ['copy_reg', '__main__', 'site', '__builtin__', 'encodings', 'encodings.encodings', 'posixpath', ...] >>> 주의: 만약 모듈의 소스 코드를 변경한 후에 import 문을 수행하면 혼동이 생긴다. 모듈을 임포트 하면 sys.modules에 캐시 되므로, 임포트를 여러 번 수행하면 이전에 적재된 모듈이 반환되며, 모듈을 수정하더라도 반영되지 않는다. 수정한 모듈을 적재하는 가장 안전한 방법은 파이썬을 종료하고 다시 시작하는 것이다. 모듈 위치 파이썬은 모듈을 찾을 때 경로 리스트(sys.path)를 참고한다. >>> import sys >>> sys.path [ '', '/usr/local/lib/python36/python36.zip', '/usr/local/lib/python36', ... ] 현재 작업 디렉터리가 가장 먼저 온다. 모듈 검색 경로 언급한 바와 같이, sys.path에는 검색 경로가 있다. 필요한 경우 수작업으로 변경할 수 있다. import sys sys.path.append('/project/foo/pyfiles') 환경 변수를 통해 경로를 추가할 수도 있다. % env PYTHONPATH=/project/foo/pyfiles python3 Python 3.6.0 (default, Feb 3 2017, 05:53:21) [GCC 4.2.1 Compatible Apple LLVM 8.0.0 (clang-800.0.38)] >>> import sys >>> sys.path ['','/project/foo/pyfiles', ...] 일반적으로, 모듈 검색 경로를 수작업으로 조정할 필요는 없다. 하지만, 일반적이지 않은 위치에 있다든지 현재 작업 디렉터리에서 액세스할 준비가 되지 않은 파이썬 코드를 임포트 할 일이 생기곤 한다. 연습 문제 이 연습 문제는 모듈과 관련 있기 때문에, 파이썬을 적절한 환경에서 실행하는 것이 매우 중요하다. 프로그래머들이 겪는 모듈과 관련된 문제는 대부분 현재 작업 디렉터리 또는 파이썬 경로 설정과 관련된다. 이 코스에서는 작성하는 모든 코드가 Work/ 디렉터리에 있는 것으로 가정한다. 최선의 결과를 얻으려면, 인터프리터도 그 디렉터리에서 실행하라. 그렇게 하지 않으려면 sys.path에 practical-python/Work를 추가해야 한다. 연습 문제 3.11: 모듈 임포트 섹션 3에서 우리는 CSV 데이터 파일의 내용을 파싱 하는 범용 함수 parse_csv()를 작성했다. 이제 그 함수를 다른 프로그램에서 사용하는 법을 알아보자. 먼저, 새로운 셸 창을 시작한다. 파일이 있는 폴더로 이동한다. 그 파일들을 임포트 할 것이다. 파이썬 상호작용 모드를 시작한다. bash % python3 Python 3.6.1 (v3.6.1:69c0db5050, Mar 21 2017, 01:21:04) [GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin Type "help", "copyright", "credits" or "license" for more information. >>> 이전에 작성한 프로그램을 임포트 해보자. 이전과 똑같이 출력이 표시된다. 모듈을 임포트 하면 코드가 실행된다. >>> import bounce ... 출력을 보라 ... >>> import mortgage ... 출력을 보라 ... >>> import report ... 출력을 보라 ... >>> 위와 같이 작동하지 않는다면 파이썬을 잘못된 디렉터리에서 실행하고 있을 가능성이 높다. 이제 fileparse 모듈을 임포트하고 도움말을 표시해 보자. >>> import fileparse >>> help(fileparse) ... 출력을 보라 ... >>> dir(fileparse) ... 출력을 보라 ... >>> 이 모듈을 사용해 데이터를 읽는다. >>> portfolio = fileparse.parse_csv('Data/portfolio.csv',select=['name','shares','price'], types=[str, int, float]) >>> portfolio ... 출력을 보라 ... >>> pricelist = fileparse.parse_csv('Data/prices.csv',types=[str, float], has_headers=False) >>> pricelist ... 출력을 보라 ... >>> prices = dict(pricelist) >>> prices ... 출력을 보라 ... >>> prices['IBM'] 106.11 >>> 모듈 이름을 포함하지 않도록 함수를 임포트 해 보자. >>> from fileparse import parse_csv >>> portfolio = parse_csv('Data/portfolio.csv', select=['name','shares','price'], types=[str, int, float]) >>> portfolio ... 출력을 보라 ... >>> 연습 문제 3.12: 라이브러리 모듈 사용하기 섹션 2에서 다음과 같은 주식 보고서를 생성하는 report.py 프로그램을 작성했다. Name Shares Price Change ---------- ---------- ---------- ---------- AA 100 9.22 -22.98 IBM 50 106.28 15.18 CAT 150 35.46 -47.98 MSFT 200 20.89 -30.34 GE 95 13.48 -26.89 MSFT 50 20.89 -44.21 IBM 100 106.28 35.84 모든 입력 파일의 처리에 fileparse 모듈에 있는 함수를 사용하도록 프로그램을 수정하라. 이 작업 위해 fileparse를 모듈로서 임포트하고 read_portfolio() 와 read_prices() 함수에서 parse_csv() 함수를 사용하게 수정한다. 이 연습 문제의 처음에 예로 든 상호작용적인 예제를 참고하라. 수정 후에도 이전과 똑같이 출력되어야 한다. 연습 문제 3.14: 라이브러리 임포트를 더 많이 사용하기 섹션 1에서, 포트폴리오를 읽어 비용을 계산하는 pcost.py 프로그램을 작성했다. >>> import pcost >>> pcost.portfolio_cost('Data/portfolio.csv') 44671.15 >>> report.read_portfolio() 함수를 사용하게 pcost.py 파일을 수정하라. 부연 설명 이 연습 문제를 맞히면 세 개의 프로그램을 갖게 된다. fileparse.py에는 범용 parse_csv() 함수가 있다. report.py는 훌륭한 보고서를 생성하며, read_portfolio()와 read_prices() 함수도 갖는다. 끝으로, pcost.py는 포트폴리오 비용을 계산하며, report.py를 위해 작성된 read_portfolio() 함수를 사용한다. 3.5 메인 모듈 이 섹션은 메인 프로그램 혹은 메인 모듈의 개념을 소개한다. 메인 함수 여러 프로그래밍 언어에는 메인(main) 함수 또는 메서드 개념이 있다. // c / c++ int main(int argc, char *argv[]) { ... } // 자바 class myprog { public static void main(String args[]) { ... } } 이것은 애플리케이션을 시작할 때 처음 실행하는 함수다. 파이썬 메인 모듈 파이썬에는 메인 함수나 메서드가 없다. 그 대신 메인 모듈이 있다. 처음 실행하는 소스 파일이 메인 모듈이다. bash % python3 prog.py ... 인터프리터에 무엇을 전달하든, 그것이 메인 모듈이 된다. 이름이 무엇이든 상관없다. __main__ 확인 모듈이 메인 스크립트로 작동하는지 알아보는 관례적인 방법이다. # prog.py ... if __name__ == '__main__': # 메인 프로그램으로서 실행 ... 문장 ... 위 if 문에 속한 문장이 메인 프로그램이 된다. 메인 프로그램 vs. 라이브러리 임포트 모든 파이썬 파일은 메인으로 실행하거나 라이브러리로서 임포트 된다. bash % python3 prog.py # 메인으로서 실행 import prog # 라이브러리 임포트 되어 실행 두 경우 모두 __name__은 모듈의 이름이다. 그러나 메인으로서 실행할 때만 __main__이 된다. 라이브러리 임포트로서 실행할 때는 메인 프로그램으로서 실행하는 문장을 실행하고 싶지 않을 수 있다. 그러므로 어떤 쓰임새인지를 if로 검사하는 것이다. if __name__ == '__main__': # 임포트 될 때는 실행하지 않는다 ... 프로그램 템플릿 다음은 파이썬 프로그램을 작성하는 공통적인 프로그램 템플릿이다. # prog.py # Import 문(라이브러리) import modules # 함수 def spam(): ... def blah(): ... # 메인 함수 def main(): ... if __name__ == '__main__': main() 명령행 도구 파이썬은 종종 명령행 도구로 사용된다. bash % python3 report.py portfolio.csv prices.csv 그 말은 스크립트를 셸 또는 터미널에서 실행한다는 뜻이다.<NAME>도는 자동화, 백그라운드 작업 등이다. 명령행 인자 명령행은 텍스트 열의 리스트다. bash % python3 report.py portfolio.csv prices.csv 이러한 텍스트 열의 리스트를 sys.argv에서 찾을 수 있다. # 위 bash 명령에서 sys.argv # ['report.py, 'portfolio.csv', 'prices.csv'] 인자를 처리하는 간단한 예를 살펴보자. import sys if len(sys.argv) != 3: raise SystemExit(f'Usage: {sys.argv[0]} ' 'portfile pricefile') portfile = sys.argv[1] pricefile = sys.argv[2] ... 표준 입출력 표준 입출력(stdio)은 일반 파일과 똑같이 작동하는 파일이다. sys.stdout sys.stderr sys.stdin print는 기본적으로 sys.stdout로 지정(direct) 된다. 입력은 sys.stdin으로부터 읽는다. 트레이스 백(Traceback)과 오류(error)는 sys.stderr로 지정된다. stdio는 터미널, 파일, 파이프 등에 연결될 수 있다. bash % python3 prog.py > results.txt # 또는 bash % cmd1 | python3 prog.py | cmd2 환경 변수(Environment Variable) 환경 변수는 셸에서 설정된다. bash % setenv NAME dave bash % setenv RSH ssh bash % python3 prog.py os.environ은 이러한 값을 담는 딕셔너리다. import os name = os.environ['NAME'] # 'dave' 변경은 프로그램이 나중에 실행시키는 서브 프로세스에 반영된다. 프로그램 종료(Program Exit) 프로그램 종료는 예외를 통해 처리된다. raise SystemExit raise SystemExit(exitcode) raise SystemExit('Informative message') 대안. import sys sys.exit(exitcode) 0이 아닌 종료 코드(exit code)는 오류를 나타낸다. #! 행 유닉스에서 #! 행은 스크립트를 파이썬으로서 실행할 수 있다. 다음과 같이 스크립트 파일 첫행에 추가한다. #!/usr/bin/env python3 # prog.py ... 실행 권한이 필요하다. bash % chmod +x prog.py # Then you can execute bash % prog.py ... 출력 ... 참고: 윈도의 Python Launcher도 언어 버전을 확인하기 위해 #! 행을 찾는다. 스크립트 템플릿 끝으로, 명령행 스크립트로서 실행되는 파이썬 프로그램을 위한 공통적인 코드 터미널이 있다. #!/usr/bin/env python3 # prog.py # Import statements (libraries) import modules # Functions def spam(): ... def blah(): ... # 메인 함수 def main(argv): # 명령행 인자, 환경 변수 등을 파싱. ... if __name__ == '__main__': import sys main(sys.argv) 연습 문제 연습 문제 3.15: main() 함수 report.py 파일에 명령행 옵션의 리스트를 받아 이전과 같은 출력을 생성하는 main() 함수를 추가하자. 그것을 다음과 같이 상호작용적으로 실행할 수 있어야 한다. >>> import report >>> report.main(['report.py', 'Data/portfolio.csv', 'Data/prices.csv']) Name Shares Price Change ---------- ---------- ---------- ---------- AA 100 9.22 -22.98 IBM 50 106.28 15.18 CAT 150 35.46 -47.98 MSFT 200 20.89 -30.34 GE 95 13.48 -26.89 MSFT 50 20.89 -44.21 IBM 100 106.28 35.84 >>> 비슷한 main() 함수를 갖도록 pcost.py 파일을 수정하자. >>> import pcost >>> pcost.main(['pcost.py', 'Data/portfolio.csv']) Total cost: 44671.15 >>> 연습 문제 3.16: 스크립트 만들기 report.py와 pcost.py 프로그램을 수정해 명령행에서 스크립트로서 실행할 수 있게 해 보자. bash $ python3 report.py Data/portfolio.csv Data/prices.csv Name Shares Price Change ---------- ---------- ---------- ---------- AA 100 9.22 -22.98 IBM 50 106.28 15.18 CAT 150 35.46 -47.98 MSFT 200 20.89 -30.34 GE 95 13.48 -26.89 MSFT 50 20.89 -44.21 IBM 100 106.28 35.84 bash $ python3 pcost.py Data/portfolio.csv Total cost: 44671.15 3.6 설계에 관한 논의 이 섹션에서는 앞에서 결정한 설계를 재검토한다. 파일명 vs 이터러블 같은 출력을 반환하는 다음 두 프로그램을 비교해 보자. # 파일명을 제공 def read_data(filename): records = [] with open(filename) as f: for line in f: ... records.append(r) return records d = read_data('file.csv') # 행을 제공 def read_data(lines): records = [] for line in lines: ... records.append(r) return records with open('file.csv') as f: d = read_data(f) 어느 함수를 선호하는가? 이유는? 이 함수 중 어느 것이 더 유연한가? 심오한 아이디어: "덕 타이핑" 컴퓨터 프로그래밍에서 덕 타이핑(Duck Typing)이란, 어떤 객체를 특정 목적으로 사용할 수 있는지 판단하는 것과 관련된 개념이다. 덕 테스트(duck test)의 예를 들어 설명한다. 만약 어떤 것이 오리처럼 생겼고, 오리처럼 헤엄치고, 오리처럼 꽥꽥거린다면, 그것은 아마도 오리일 것이다. 위 read_data()의 두 번째 버전에서, 함수는 이터러블 객체를 예상한다. 파일의 행에 국한되지 않는다. def read_data(lines): records = [] for line in lines: ... records.append(r) return records 이는 우리가 다른 lines를 가지고 사용할 수 있음을 의미한다. # CSV 파일 lines = open('data.csv') data = read_data(lines) # ZIP 압축된 파일 lines = gzip.open('data.csv.gz','rt') data = read_data(lines) # 표준 입력 lines = sys.stdin data = read_data(lines) # 문자열의 리스트 lines = ['ACME, 50,91.1','IBM, 75,123.45', ... ] data = read_data(lines) 이 설계는 상당히 유연하다. 질문: 이러한 유연성을 환영해야 할까, 아니면 꺼려야 할까? 라이브러리 설계 모범 사례 유연한 코드 라이브러리는 더 나은 서비스를 제공할 수 있다. 옵션을 제한하지 말자. 유연성이 높을수록 더 강력해진다. 연습 문제 연습 문제 3.17: 파일명에서 파일 비슷한 객체로 앞에서 parse_csv() 함수가 있는 fileparse.py 파일을 작성했다. 이 함수는 다음과 같이 작동한다. >>> import fileparse >>> portfolio = fileparse.parse_csv('Data/portfolio.csv', types=[str, int, float]) >>> 이 함수는 파일명이 전달될 것으로 예상한다. 이 코드의 유연성을 좀 더 높이면 좋을 것이다. 파일과 유사하거나 이터러블한 객체를 다룰 수 있게 함수를 수정해 보라. 예: >>> import fileparse >>> import gzip >>> with gzip.open('Data/portfolio.csv.gz', 'rt') as file: ... port = fileparse.parse_csv(file, types=[str, int, float]) ... >>> lines = ['name, shares, price', 'AA, 100,34.23', 'IBM, 50,91.1', 'HPE, 75,45.1'] >>> port = fileparse.parse_csv(lines, types=[str, int, float]) >>> 새로운 코드에 예전처럼 파일명을 전달하면 무슨 일이 일어나는가? >>> port = fileparse.parse_csv('Data/portfolio.csv', types=[str, int, float]) >>> port ... 출력을 살펴보라(미쳤다) ... >>> 그렇다. 조심해야 한다. 이런 일이 생기지 않게 안전장치를 둘 수는 없을까? 연습 문제 3.18: 기존 함수를 수정하기 parse_csv()의 수정된 버전과 작동할 수 있게, report.py 파일의 read_portfolio()와 read_prices() 함수를 수정해 보라. 코드를 조금만 고쳐야 한다. 수정한 후에는 report.py와 pcost.py 프로그램이 이전과 같은 방식으로 작동해야 한다. 4. 클래스와 객체 지금까지 우리가 작성한 프로그램은 파이썬 빌트인 자료형만 사용했다. 이 섹션에서는 클래스와 객체 개념을 도입한다. 새로운 객체를 만들 수 있는 class 문을 배운다. 상속 개념도 소개하며, 확장 가능한 프로그램을 구축하는 데 공통적으로 사용하는 도구를 다룬다. 끝으로, 특수한 메서드, 동적 어트리뷰트 찾기, 새로운 예외 정의 등 클래스와 관련한 기능을 살펴본다. 4.1 클래스 4.2 상속 4.3 특수 메서드 4.4 새로운 예외 정의하기 4.1 클래스 이 섹션은 class 문을 소개하고 새로운 객체를 생성하는 아이디어를 제시한다. 객체 지향(Object Oriented, OO) 프로그래밍 코드를 객체의 모음으로써 조직화하는 프로그래밍 기법이다. 객체는 다음으로 구성된다. 데이터(Data). 어 트리뷰트(Attribute) 행위(Behavior). 메서드(method) - 객체에 적용되는 함수. 이 코스에서 이미 객체지향을 사용했다. 예를 들어 리스트를 조작할 때, >>> nums = [1, 2, 3] >>> nums.append(4) # 메서드 >>> nums.insert(1,10) # 메서드 >>> nums [1, 10, 2, 3, 4] # 데이터 >>> nums는 리스트의 인스턴스다. 메서드(append()와 insert())는 인스턴스(nums)에 붙어 있다. class 문 class 문을 사용해 새로운 객체를 정의한다. class Player: def __init__(self, x, y): self.x = x self.y = y self.health = 100 def move(self, dx, dy): self.x += dx self.y += dy def damage(self, pts): self.health -= pts 간단히 말해서 클래스는 인스턴스라 부르는 것에 대한 여러 연산을 수행하는 함수의 집합체다. 인스턴스 인스턴스는 프로그램에서 다루는 실제 객체다. 클래스를 함수로서 호출하여 생성한다. >>> a = Player(2, 3) >>> b = Player(10, 20) >>> a와 b는 Player의 인스턴스다. 강조: class 문은 정의(definition) 일뿐이다(그 자체로는 아무 일도 하지 않는다). 함수 정의와 마찬가지다. 인스턴스 데이터 인스턴스에는 자체 로컬 데이터가 있다. >>> a.x >>> b.x 10 이 데이터는 __init__()에 의해 초기화된다. class Player: def __init__(self, x, y): # `self`에 저장된 값은 인스턴스 데이터다 self.x = x self.y = y self.health = 100 어 트리뷰트의 개수나 유형에는 제한이 없다. 인스턴스 메서드 인스턴스 메서드는 객체의 인스턴스에 적용되는 함수다. class Player: ... # `move`는 메서드다 def move(self, dx, dy): self.x += dx self.y += dy 객체 그 자체가 항상 첫 번째 인자로 전달된다. >>> a.move(1, 2) # `a`를 `self`와 매치 # `1`을 `dx`와 매치 # `2`를 `dy`와 매치 def move(self, dx, dy): 관례적으로 인스턴스를 self라고 한다. 그러나 실제로 어떤 이름을 쓰는지는 중요하지 않다. 객체는 항상 첫 번째 인자로 전달된다. 이 인자를 self라고 부르는 것은 파이썬 프로그래밍 스타일일 뿐이다. 클래스 스코핑 클래스는 이름의 스코프를 정의하지 않는다. class Player: ... def move(self, dx, dy): self.x += dx self.y += dy def left(self, amt): move(-amt, 0) # NO. 글로벌 `move` 함수를 호출 self.move(-amt, 0) # YES. 위에 정의한 `move` 메서드를 호출. 인스턴스에 대한 연산을 하고 싶으면, 항상 명시적으로 참조한다(예: self). 연습 문제 지금부터 나오는 연습 문제는 이전 섹션에서 작성한 코드를 변경한다. 연습 문제 3.18의 코드가 올바로 작동하는 것을 가지고 시작해야 한다. 그렇지 못할 경우, Solutions/3_18 디렉터리의 해답 코드를 가지고 실습하라. 복사해서 써도 된다. 연습 문제 4.1: 데이터 구조로서의 객체 섹션 2와 3에서, 튜플과 딕셔너리로서 표현되는 데이터를 가지고 작업했다. 예를 들어, 보유 주식을 다음과 같이 튜플로 표현했다. s = ('GOOG',100,490.10) 또는 다음과 같이 딕셔너리를 사용했다. s = { 'name' : 'GOOG', 'shares' : 100, 'price' : 490.10 } 그러한 데이터를 조작하는 함수를 작성할 수도 있다. 예: def cost(s): return s['shares'] * s['price'] 그렇지만 프로그램이 커져감에 따라 조직화를 더 잘 하고 싶어질 것이다. 따라서 클래스를 정의함으로써 데이터를 표현하는 접근을 취할 수 있다. stock.py라는 파일을 만들어 보유 주식 한 종목을 표현하는 Stock 클래스를 정의하자. Stock 인스턴스에는 name, shares, price 어 트리뷰트가 있다. 예: >>> import stock >>> a = stock.Stock('GOOG',100,490.10) >>> a.name 'GOOG' >>> a.shares 100 >>> a.price 490.1 >>> Stock 객체를 몇 개 더 생성해 조작해 보자. 예: >>> b = stock.Stock('AAPL', 50, 122.34) >>> c = stock.Stock('IBM', 75, 91.75) >>> b.shares * b.price 6117.0 >>> c.shares * c.price 6881.25 >>> stocks = [a, b, c] >>> stocks [<stock.Stock object at 0x37d0b0>, <stock.Stock object at 0x37d110>, <stock.Stock object at 0x37d050>] >>> for s in stocks: print(f'{s.name:>10s} {s.shares:>10d} {s.price:>10.2f}') ... 출력을 보라 ... >>> 여기서 강조하고 싶은 것은 Stock 클래스가 객체의 인스턴스를 생성하는 팩토리처럼 작동한다는 점이다. 기본적으로, 그것을 함수로서 호출해 새로운 객체를 생성할 수 있다. 또한, 각 객체는<NAME>다는 점이 중요하다. 객체가 갖는 데이터는 다른 객체가 생성될 때 갖게 되는 데이터와 별개다. 클래스에 의해 정의된 객체는, 구문은 좀 다르지만 딕셔너리와도 비슷하다. 예를 들어, s['name']과 s['price'] 대신, s.name과 s.price라고 작성한다. 연습 문제 4.2: 메서드를 추가하기 클래스에서는 객체에 함수를 붙일 수 있는데, 이를 메서드라 한다. 메서드는 객체 내에 저장된 데이터를 조작하는 함수다. Stock 객체에 cost()와 sell() 메서드를 추가하자. 다음과 같이 작동한다. >>> import stock >>> s = stock.Stock('GOOG', 100, 490.10) >>> s.cost() 49010.0 >>> s.shares 100 >>> s.sell(25) >>> s.shares 75 >>> s.cost() 36757.5 >>> 연습 문제 4.3: 인스턴스의 리스트를 생성하기 딕셔너리의 리스트로부터 Stock 인스턴스의 리스트를 만들어 보자. 그런 다음 총비용을 계산한다. >>> import fileparse >>> with open('Data/portfolio.csv') as lines: ... portdicts = fileparse.parse_csv(lines, select=['name','shares','price'], types=[str, int, float]) ... >>> portfolio = [ stock.Stock(d['name'], d['shares'], d['price']) for d in portdicts] >>> portfolio [<stock.Stock object at 0x10c9e2128>, <stock.Stock object at 0x10c9e2048>, <stock.Stock object at 0x10c9e2080>, <stock.Stock object at 0x10c9e25f8>, <stock.Stock object at 0x10c9e2630>, <stock.Stock object at 0x10ca6f748>, <stock.Stock object at 0x10ca6f7b8>] >>> sum([s.cost() for s in portfolio]) 44671.15 >>> 연습 문제 4.4: 클래스를 사용하기 포트폴리오를 읽어 연습 문제 4.3에 보인 것과 같은 Stock 인스턴스의 리스트를 만들도록 report.py 프로그램의 read_portfolio() 함수를 수정하라. 완료하면, 딕셔너리 대신 Stock 인스턴스를 사용하게 report.py와 pcost.py의 코드를 모두 수정한다. 힌트: 코드를 너무 많이 수정하면 안 된다. 딕셔너리 액세스 s['shares']를 s.shares로 바꾸는 것과 같이 소소한 변경을 한다. 이전과 같은 방법으로 함수를 실행할 수 있어야 한다. >>> import pcost >>> pcost.portfolio_cost('Data/portfolio.csv') 44671.15 >>> import report >>> report.portfolio_report('Data/portfolio.csv', 'Data/prices.csv') Name Shares Price Change ---------- ---------- ---------- ---------- AA 100 9.22 -22.98 IBM 50 106.28 15.18 CAT 150 35.46 -47.98 MSFT 200 20.89 -30.34 GE 95 13.48 -26.89 MSFT 50 20.89 -44.21 IBM 100 106.28 35.84 >>> 4.2 상속 상속은 확장성 있는 프로그램을 작성하는 일반적인 도구다. 이 섹션에서 그 개념을 알아보자. 도입 상속은 기존 객체를 특수화하는 데 사용된다. class Parent: ... class Child(Parent): ... 위의 Child 클래스와 같은 것을 파생 클래스(derived class) 또는 하위 클래스(subclass)라 한다. 위의 Parent 클래스는 기본 클래스(base class) 또는 상위 클래스(superclass)라 한다. class Child(Parent):에서 클래스명 뒤의 ()에 Parent를 지정했다. 확장(Extending) 상속을 통해 기존 클래스를 취하여 다음과 같은 일을 할 수 있다. 새로운 메서드를 추가 기존 메서드 일부를 재정의(redefine) 인스턴스에 새로운 어 트리뷰트를 추가 그리하여 기존 코드를 확장하게 된다. 이 클래스에서 시작한다고 하자. class Stock: def __init__(self, name, shares, price): self.name = name self.shares = shares self.price = price def cost(self): return self.shares * self.price def sell(self, nshares): self.shares -= nshares 상속을 통해 이것의 어느 부분이든 변경할 수 있다. 새 메서드를 추가 class MyStock(Stock): def panic(self): self.sell(self.shares) 용례: >>> s = MyStock('GOOG', 100, 490.1) >>> s.sell(25) >>> s.shares 75 >>> s.panic() >>> s.shares >>> 기존 메서드를 재정의 class MyStock(Stock): def cost(self): return 1.25 * self.shares * self.price 용례: >>> s = MyStock('GOOG', 100, 490.1) >>> s.cost() 61262.5 >>> 새 메서드는 기존 것을 대체한다. 다른 메서드는 영향을 받지 않는다. 굉장하다. 오버라이딩(Overriding) 때로는 클래스가 기존 메서드를 확장하되, 원래 구현을 재정의에 포함하고 싶을 수 있다. 이를 위해 super()를 사용한다. class Stock: ... def cost(self): return self.shares * self.price ... class MyStock(Stock): def cost(self): # `super`에 대한 호출을 확인 actual_cost = super().cost() return 1.25 * actual_cost 이전 버전을 호출하기 위해 super()를 사용한다. 주의: 파이썬 2는 이것보다 구문이 복잡하다. actual_cost = super(MyStock, self).cost() __init__와 상속 __init__를 재정의하려면 부모를 초기화해야 한다. class Stock: def __init__(self, name, shares, price): self.name = name self.shares = shares self.price = price class MyStock(Stock): def __init__(self, name, shares, price, factor): # `super`와 `__init__`에 대한 호출을 확인 super().__init__(name, shares, price) self.factor = factor def cost(self): return self.factor * super().cost() super에 __init__() 메서드를 호출해야 한다. 이것이 앞에서 본 것과 같이 이전 버전을 호출하는 방법이다. 상속을 사용하기 상속은 관련 객체를 조직화하는 데 사용되곤 한다. class Shape: ... class Circle(Shape): ... class Rectangle(Shape): ... 논리적 계층 구조나 분류법을 생각해 보라. 그렇지만 좀 더 일반적이고도 실용적인 용도는 재사용 가능 혹은 확장 가능한 코드를 만드는 것이다. 예를 들어, 프레임워크에 정의된 기본 클래스를 당신이 커스터마이즈 할 수 있다. class CustomHandler(TCPHandler): def handle_request(self): ... # 커스텀 처리 기본 클래스는 일반 목적 코드를 포함한다. 당신의 클래스는 기본 클래스를 상속해 특수한 부분을 커스터마이즈 한다. "is a" 관계 상속은 타입 간의 관계를 설정한다. class Shape: ... class Circle(Shape): ... 객체 인스턴스를 확인하라. >>> c = Circle(4.0) >>> isinstance(c, Shape) True >>> 중요: 부모 클래스의 인스턴스를 다루는 코드는 자식 클래스의 인스턴스에 대해서도 작동하는 것이 이상적이다. object 기본 클래스 만약 클래스에 부모가 없으면 object를 기본으로 삼을 수 있다. class Shape(object): ... 파이썬에서 object는 모든 객체의 부모다. *참고: 기술적으로 이것이 필요하지는 않지만, 파이썬 2에서 필요했기 때문에 남겨둔 경우가 많다. object를 생략하더라도 암시적으로 상속한다. 다중 상속 여러 클래스로부터 상속하도록 클래스에 정의할 수 있다. class Mother: ... class Father: ... class Child(Mother, Father): ... Child 클래스는 Mother와 Father의 특징을 모두 상속받는다. 다중 상속은 세부적으로 들어가면 골치가 아파진다. 정확히 이해하기 전에는 사용하지 마라. 다음 섹션에서 추가 정보를 제공하겠지만, 이 코스에서 다중 상속을 사용할 일은 없다. 연습 문제 상속의 주 용도는 다양한 방법으로 확장 또는 커스터마이즈 된 코드를 작성하는 것에 있다(특히 라이브러리나 프레임워크에서). 설명을 위해 report.py 프로그램의 print_report() 함수를 생각해 보자. 그것은 다음과 같이 보일 것이다. def print_report(reportdata): ''' (name, shares, price, change) 튜플의 리스트로부터 보기 좋게 포매팅한 테이블을 프린팅. ''' headers = ('Name','Shares','Price','Change') print('% 10s % 10s % 10s % 10s' % headers) print(('-'*10 + ' ')*len(headers)) for row in reportdata: print('% 10s % 10d % 10.2f % 10.2f' % row) report 프로그램을 실행하면 다음과 같이 출력한다. >>> import report >>> report.portfolio_report('Data/portfolio.csv', 'Data/prices.csv') Name Shares Price Change ---------- ---------- ---------- ---------- AA 100 9.22 -22.98 IBM 50 106.28 15.18 CAT 150 35.46 -47.98 MSFT 200 20.89 -30.34 GE 95 13.48 -26.89 MSFT 50 20.89 -44.21 IBM 100 106.28 35.84 연습 문제 4.5: 확장성 문제 print_report() 함수가 일반 텍스트, HTML, CSV, XML 같이 다양한 출력 포맷을 지원하게 수정하고 싶다고 하자. 그렇게 하려고 모든 일을 처리하는 아주 큰 함수를 작성하려고 시도할 수 있다. 하지만 그렇게 했다가는 유지 보수를 하기 힘들 만큼 지저분해질 수 있다. 이때가 상속을 사용하기에 아주 좋은 기회다. 시작하려면 테이블을 생성하는 단계에 집중하자. 테이블의 첫 행에는 헤더가 있다. 그 후, 테이블 데이터 행들이 나타난다. 다음 단계를 따라 자체 클래스에 집어넣자. 다음과 같은 클래스를 정의하는 tableformat.py 파일을 작성한다. # tableformat.py class TableFormatter: def headings(self, headers): ''' 테이블 헤딩을 반환. ''' raise NotImplementedError() def row(self, rowdata): ''' 테이블 데이터의 단 일행을 반환. ''' raise NotImplementedError() 이 클래스는 아무 일도 하지 않지만, 곧 정의할 추가 클래스의 설계 사양과 역할을 한다. 이러한 클래스를 "추상 기본 클래스(abstract base class)"라고 부른다. 입력으로 받은 TableFormatter 객체의 메서드를 호출해 출력을 생성하도록 print_report() 함수를 수정하자. 예를 들면 다음과 같다. # report.py ... def print_report(reportdata, formatter): ''' (name, shares, price, change) 튜플의 리스트로부터 보기 좋게 포매팅한 테이블을 프린팅. ''' formatter.headings(['Name','Shares','Price','Change']) for name, shares, price, change in reportdata: rowdata = [ name, str(shares), f'{price:0.2f}', f'{change:0.2f}' ] formatter.row(rowdata) print_report()에 인자를 추가했으므로, portfolio_report() 함수도 수정해야 한다. TableFormatter를 생성하게 변경한다. # report.py import tableformat ... def portfolio_report(portfoliofile, pricefile): ''' 주어진 포트폴리오와 가격 데이터 파일을 가지고 주식 보고서를 작성. ''' # 데이터 파일 읽기 portfolio = read_portfolio(portfoliofile) prices = read_prices(pricefile) # 보고서 데이터 생성 report = make_report_data(portfolio, prices) # 프린트 formatter = tableformat.TableFormatter() print_report(report, formatter) 새 코드를 실행하자. >>> ================================ RESTART ================================ >>> import report >>> report.portfolio_report('Data/portfolio.csv', 'Data/prices.csv') ... 충돌 ... 곧바로 NotImplementedError 예외를 내며 충돌한다. 썩 즐겁지는 않지만, 이것은 예상했던 바다. 다음 부분으로 이어 가자. 연습 문제 4.6: 상속을 통해 다른 출력을 생성하기 (a) 부분에서 정의한 TableFormatter 클래스는 상속을 통해 확장할 의도를 가지고 정의했다. 사실, 그것이 아이디어의 전부다. 다음과 같이 TextTableFormatter 클래스를 정의한다. # tableformat.py ... class TextTableFormatter(TableFormatter): ''' 테이블을 일반 텍스트 포맷으로 출력 ''' def headings(self, headers): for h in headers: print(f'{h:>10s}', end=' ') print() print(('-'*10 + ' ')*len(headers)) def row(self, rowdata): for d in rowdata: print(f'{d:>10s}', end=' ') print() portfolio_report() 함수를 다음과 같이 수정하고 사용해 보자. # report.py ... def portfolio_report(portfoliofile, pricefile): ''' 주어진 포트폴리오와 가격 데이터 파일을 가지고 주식 보고서를 작성. ''' # 데이터 파일 읽기 portfolio = read_portfolio(portfoliofile) prices = read_prices(pricefile) # 보고서 데이터 생성 report = make_report_data(portfolio, prices) # 프린트 formatter = tableformat.TextTableFormatter() print_report(report, formatter) 이전과 같은 출력을 생성해야 한다. >>> ================================ RESTART ================================ >>> import report >>> report.portfolio_report('Data/portfolio.csv', 'Data/prices.csv') Name Shares Price Change ---------- ---------- ---------- ---------- AA 100 9.22 -22.98 IBM 50 106.28 15.18 CAT 150 35.46 -47.98 MSFT 200 20.89 -30.34 GE 95 13.48 -26.89 MSFT 50 20.89 -44.21 IBM 100 106.28 35.84 >>> 하지만, 출력을 다른 것으로 바꾸자. 출력을 CSV 포맷으로 출력하는 새로운 클래스 CSVTableFormatter를 정의한다. # tableformat.py ... class CSVTableFormatter(TableFormatter): ''' 포트폴리오 데이터를 CSV 포맷으로 출력. ''' def headings(self, headers): print(','.join(headers)) def row(self, rowdata): print(','.join(rowdata)) 메인 프로그램을 다음과 같이 수정한다. def portfolio_report(portfoliofile, pricefile): ''' 주어진 포트폴리오와 가격 데이터 파일을 가지고 주식 보고서를 작성. ''' # 데이터 파일 읽기 portfolio = read_portfolio(portfoliofile) prices = read_prices(pricefile) # 보고서 데이터 생성 report = make_report_data(portfolio, prices) # 프린트 formatter = tableformat.CSVTableFormatter() print_report(report, formatter) 이제 다음과 같은 CSV 출력을 볼 수 있을 것이다. >>> ================================ RESTART ================================ >>> import report >>> report.portfolio_report('Data/portfolio.csv', 'Data/prices.csv') Name, Shares, Price, Change AA, 100,9.22, -22.98 IBM, 50,106.28,15.18 CAT, 150,35.46, -47.98 MSFT, 200,20.89, -30.34 GE, 95,13.48, -26.89 MSFT, 50,20.89, -44.21 IBM, 100,106.28,35.84 마찬가지로, 다음과 같은 출력을 생성하는 HTMLTableFormatter 클래스를 정의한다. <tr><th>Name</th><th>Shares</th><th>Price</th><th>Change</th></tr> <tr><td>AA</td><td>100</td><td>9.22</td><td>-22.98</td></tr> <tr><td>IBM</td><td>50</td><td>106.28</td><td>15.18</td></tr> <tr><td>CAT</td><td>150</td><td>35.46</td><td>-47.98</td></tr> <tr><td>MSFT</td><td>200</td><td>20.89</td><td>-30.34</td></tr> <tr><td>GE</td><td>95</td><td>13.48</td><td>-26.89</td></tr> <tr><td>MSFT</td><td>50</td><td>20.89</td><td>-44.21</td></tr> <tr><td>IBM</td><td>100</td><td>106.28</td><td>35.84</td></tr> CSVTableFormatter 객체 대신 HTMLTableFormatter 객체를 생성하게 메인 프로그램을 수정해 코드를 테스트하자. 연습 문제 4.7: 다형성 객체 지향 프로그래밍의 주된 특징은 기존 코드를 변경할 필요 없이 객체를 프로그램에 끼워 넣을 수 있다는 것이다. 예를 들어, TableFormatter 객체를 사용할 것으로 예상되는 프로그램을 작성했다고 하면, 어떤 종류의 TableFormatter를 주는지에 관계없이 작동할 것이다. 이러한 행위를 '다형성(polymorphism)'이라 한다. 한 가지 잠재적인 문제는 사용자가 원하는 포매터를 선택하게 하는 방법을 알아내는 것이다. TextTableFormatter 같은 클래스명을 직접 사용하게 하는 것은 종종 성가시다. 따라서 단순한 접근을 고려할 수 있다. 다음과 같이 코드에 if 문을 포함할 수 있을 것이다. def portfolio_report(portfoliofile, pricefile, fmt='txt'): ''' 주어진 포트폴리오와 가격 데이터 파일을 가지고 주식 보고서를 작성. ''' # 데이터 파일 읽기 portfolio = read_portfolio(portfoliofile) prices = read_prices(pricefile) # 보고서 데이터 생성 report = make_report_data(portfolio, prices) # 프린트 if fmt == 'txt': formatter = tableformat.TextTableFormatter() elif fmt == 'csv': formatter = tableformat.CSVTableFormatter() elif fmt == 'html': formatter = tableformat.HTMLTableFormatter() else: raise RuntimeError(f'Unknown format {fmt}') print_report(report, formatter) 이 코드에서, 사용자는 'txt'나 'csv' 같이 단순화된 이름을 지정함으로써 포맷을 선택한다. 하지만, portfolio_report() 함수에 커다란 if 문을 넣는 것이 최선인가? 그 코드를 다른 범용 함수로 옮기는 것이 나을 것이다. 'txt', 'csv', 'html' 같은 출력 이름에 따라 사용자가 포매터를 생성하는 create_formatter(name) 함수를 tableformat.py 파일에 추가한다. portfolio_report()를 다음과 같이 수정하자. def portfolio_report(portfoliofile, pricefile, fmt='txt'): ''' 주어진 포트폴리오와 가격 데이터 파일을 가지고 주식 보고서를 작성. ''' # 데이터 파일 읽기 portfolio = read_portfolio(portfoliofile) prices = read_prices(pricefile) # 보고서 데이터 생성 report = make_report_data(portfolio, prices) # 프린트 formatter = tableformat.create_formatter(fmt) print_report(report, formatter) 여러 포맷으로 함수를 호출해 함수가 제대로 작동하는지 확인해 보자. 연습 문제 4.8: 모두 합치기 portfolio_report() 함수가 출력 포맷을 지정하는 선택적 인자를 받게 report.py 프로그램을 수정하라. 예: >>> report.portfolio_report('Data/portfolio.csv', 'Data/prices.csv', 'txt') Name Shares Price Change ---------- ---------- ---------- ---------- AA 100 9.22 -22.98 IBM 50 106.28 15.18 CAT 150 35.46 -47.98 MSFT 200 20.89 -30.34 GE 95 13.48 -26.89 MSFT 50 20.89 -44.21 IBM 100 106.28 35.84 >>> 명령행에서 포맷을 지정하게 메인 프로그램을 수정한다. bash $ python3 report.py Data/portfolio.csv Data/prices.csv csv Name, Shares, Price, Change AA, 100,9.22, -22.98 IBM, 50,106.28,15.18 CAT, 150,35.46, -47.98 MSFT, 200,20.89, -30.34 GE, 95,13.48, -26.89 MSFT, 50,20.89, -44.21 IBM, 100,106.28,35.84 bash $ 논의 라이브러리와 프레임워크에서 확장성 있는 코드를 작성하는 것은 상속의 주된 용도다. 예를 들어, 프레임워크는 기본 클래스를 제공하고 당신은 그것을 상속해 객체를 정의한다. 그런 다음 기능을 구현하는 다양한 메서드를 채운다. 또 한 가지 심오한 개념은 '추상화를 직접 작성'하는 것이다. 우리는 이 연습 문제에서 테이블을 포매팅하는 클래스를 직접 정의했다. 코드를 들여다보고 '포매팅 라이브러리라든지 다른 사람이 이미 만들어놓은 것을 사용해야겠다'라고 생각할지 모르겠다. 하지만 직접 만든 클래스와 라이브러리를 둘 다 사용해야 한다. 스스로 클래스를 만들면 커플링이 줄어들고 더 유연해진다. 당신의 애플리케이션이 당신의 클래스의 프로그래밍 인터페이스를 사용하는 한, 내부 구현을 원하는 대로 변경할 수 있다. 완전한 맞춤 코드를 작성할 수 있다. 다른 사람이 만든 서드 파티 패키지를 사용할 수 있다. 사용하던 서드 파티 패키지보다 더 좋은 것을 찾게 되면 다른 것으로 바꿀 수 있다. 패키지를 교체하는 것이 별문제가 되지 않을 것이다. 인터페이스를 유지하는 한 애플리케이션 코드가 전혀 깨지지 않을 것이기 때문이다. 그것은 강력한 아이디어이며, 이와 같은 상속을 고려해야 하는 이유다. 객체 지향 프로그램 설계는 매우 어려울 수 있다. 더 알고 싶으면 디자인 패턴을 다루는 책을 살펴보기 바란다(이 연습 문제에서 일어난 일을 이해하면 객체를 실용적으로 다루는 데 상당한 도움이 된다). 4.3 특수한 메서드 특수한 메서드를 사용함으로써, 파이썬의 행위를 여러 면에서 커스터마이즈 할 수 있다. 이러한 특수 메서드를 “마법(magic)” 메서드라고도 부른다. 이 섹션에서 그 개념을 알아보자. 동적 어트리뷰트 액세스와 바운드 메서드도 논의한다. 도입 클래스에 특수 메서드를 정의할 수 있다. 파이썬 인터프리터는 이러한 메서드들을 특별하게 다룬다. 항상 앞에 __가 붙는다. (예: __init__) class Stock(object): def __init__(self): ... def __repr__(self): ... 특수 메서드는 많이 있지만, 그중 몇 가지만 예를 들어 보자. 문자열 변환을 위한 특수 메서드 객체에는 두 가지 문자열 표현이 있다. >>> from datetime import date >>> d = date(2012, 12, 21) >>> print(d) 2012-12-21 >>> d datetime.date(2012, 12, 21) >>> str() 함수를 사용해 멋지게 프린트할 수 있는 출력을 생성한다. >>> str(d) '2012-12-21' >>> repr() 함수는 개발자를 위한 상세한 표현에 사용된다. >>> repr(d) 'datetime.date(2012, 12, 21)' >>> 이러한 str()과 repr() 함수는 특수한 메서드를 사용해, 클래스로부터 문자열을 생성한다. class Date(object): def __init__(self, year, month, day): self.year = year self.month = month self.day = day # Used with `str()` def __str__(self): return f'{self.year}-{self.month}-{self.day}' # `repr()`과 함께 사용 def __repr__(self): return f'Date({self.year},{self.month},{self.day})' 참고: __repr__()이 반환하는 문자열을 eval()에 전달하면 객체를 다시 만들 수 있도록 하는 것이 관례다. 그렇게 하는 것이 불가능하다면, 그 대신 읽기 쉬운 표현을 사용한다. 수학을 위한 특수 메서드 다음과 같은 메서드가 수학 연산에 사용된다. a + b a.__add__(b) a - b a.__sub__(b) a * b a.__mul__(b) a / b a.__truediv__(b) a // b a.__floordiv__(b) a % b a.__mod__(b) a << b a.__lshift__(b) a >> b a.__rshift__(b) a & b a.__and__(b) a | b a.__or__(b) a ^ b a.__xor__(b) a ** b a.__pow__(b) -a a.__neg__() ~a a.__invert__() abs(a) a.__abs__() 항목 접근을 위한 특수 메서드 컨테이너를 구현하는 데 다음과 같은 메서드를 사용한다. len(x) x.__len__() x[a] x.__getitem__(a) x[a] = v x.__setitem__(a, v) del x[a] x.__delitem__(a) 이것들을 다음과 같이 클래스에서 사용할 수 있다. class Sequence: def __len__(self): ... def __getitem__(self, a): ... def __setitem__(self, a, v): ... def __delitem__(self, a): ... 메서드 호출 메서드 호출은 두 단계 과정으로 이뤄진다. 메서드가 있는지 확인(lookup): . 연산자 메서드 호출: () 연산자 >>> s = Stock('GOOG',100,490.10) >>> c = s.cost # 메서드 확인 >>> c <bound method Stock.cost of <Stock object at 0x590d0>> >>> c() # 메서드 호출 49010.0 >>> 바운드 메서드 함수 호출 연산자 ()에 의해 호출되지 않은 메서드를 바운드 메서드(bound method)라 한다. 바운드 메서드는 그것이 어느 인스턴스에서 왔는지를 반환한다. >>> s = Stock('GOOG', 100, 490.10) >>> s <Stock object at 0x590d0> >>> c = s.cost >>> c <bound method Stock.cost of <Stock object at 0x590d0>> >>> c() 49010.0 >>> 바운드 메서드는 부주의하고 명백하지 않은 오류의 원인이 되곤 한다. 예: >>> s = Stock('GOOG', 100, 490.10) >>> print('Cost : % 0.2f' % s.cost) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: float argument required >>> 또는 디버깅하기 힘든 잘못된 행동을 한다. f = open(filename, 'w') ... f.close # 아차, 아무 일도 하지 않았다. `f`는 여전히 열려 있다. 두 경우 모두 괄호를 붙이는 것을 잊었기 때문에 오류가 발생했다. 예: s.cost() 또는 f.close(). 어트리뷰트 액세스 어 트리뷰트에 액세스, 조작, 관리하는 또 다른 방법이 있다. getattr(obj, 'name') # obj.name과 같음 setattr(obj, 'name', value) # obj.name = value와 같음 delattr(obj, 'name') # del obj.name과 같음 hasattr(obj, 'name') # 어 트리뷰트가 존재하는지 테스트 예: if hasattr(obj, 'x'): x = getattr(obj, 'x'): else: x = None 참고: getattr()에도 유용한 기본값 arg가 있다. x = getattr(obj, 'x', None) 연습 문제 연습 문제 4.9: 객체를 프린팅 하기 위한 더 나은 출력 stock.py에 정의한 Stock 객체를 수정해 __repr__() 메서드가 더 유용한 출력을 생성하게 해 보자. 예: >>> goog = Stock('GOOG', 100, 490.1) >>> goog Stock('GOOG', 100, 490.1) >>> 이러한 변경을 한 후에 주식 포트폴리오를 읽고 결과 리스트를 볼 때 무슨 일이 일어나는지 확인하라. 예: >>> import report >>> portfolio = report.read_portfolio('Data/portfolio.csv') >>> portfolio ... see what the output is ... >>> 연습 문제 4.10: getattr()을 사용하는 예 getattr()은 어 트리뷰트를 읽는 대체 메커니즘이다. 이것을 사용해 극도로 유연한 코드를 작성할 수 있다. 다음 예제부터 시도하자. >>> import stock >>> s = stock.Stock('GOOG', 100, 490.1) >>> columns = ['name', 'shares'] >>> for colname in columns: print(colname, '=', getattr(s, colname)) name = GOOG shares = 100 >>> 출력 데이터가 columns 변수에 나열된 어트리뷰트 이름에 의해 완전히 결정되는 것을 주의 깊게 관찰하라. 이 아이디어를 tableformat.py 파일의 일반화된 함수 print_table()에 적용한다. 이 함수는 임의의 객체의 리스트의 사용자 정의 어 트리뷰트를 보여주는 테이블을 프린트한다. 이전의 print_report() 함수와 마찬가지로, print_table()은 출력 포맷을 지정하는 TableFormatter 인스턴스를 받는다. 다음과 같이 실행한다. >>> import report >>> portfolio = report.read_portfolio('Data/portfolio.csv') >>> from tableformat import create_formatter, print_table >>> formatter = create_formatter('txt') >>> print_table(portfolio, ['name','shares'], formatter) name shares ---------- ---------- AA 100 IBM 50 CAT 150 MSFT 200 GE 95 MSFT 50 IBM 100 >>> print_table(portfolio, ['name','shares','price'], formatter) name shares price ---------- ---------- ---------- AA 100 32.2 IBM 50 91.1 CAT 150 83.44 MSFT 200 51.23 GE 95 40.37 MSFT 50 65.1 IBM 100 70.44 >>> 4.4 예외 정의하기 사용자 정의 예외는 클래스에 의해 정의된다. class NetworkError(Exception): pass 예외는 항상 Exception으로부터 상속한다. 보통 그것들은 빈 클래스다. 몸체에 pass를 사용한다. 예외 계층을 직접 만들 수 있다. class AuthenticationError(NetworkError): pass class ProtocolError(NetworkError): pass 연습 문제 연습 문제 4.11: 커스텀 예외 정의하기 라이브러리에 자체적인 예외를 정의하는 것이 좋다. 공통적인 프로그래밍 오류로 인해 발생하는 파이썬 예외와 라이브러리 내부적으로 발생해 특정한 사용상의 문제를 가리키는 예외를 구분하기 쉬워진다. 지난 연습 문제의 create_formatter() 함수를 수정해, 사용자가 잘못된 포맷 이름을 제공했을 때 커스텀 FormatError 예외를 일으키게 해 보자. 예: >>> from tableformat import create_formatter >>> formatter = create_formatter('xls') Traceback (most recent call last): File "<stdin>", line 1, in <module> File "tableformat.py", line 71, in create_formatter raise FormatError('Unknown table format %s' % name) FormatError: Unknown table format xls >>> 5. 파이썬 객체의 내부 작동 이 섹션은 파이썬 객체의 내부 작동을 다룬다. 다른 프로그래밍 언어를 다뤄본 프로그래머라면 파이썬의 클래스 개념이 부족하다는 것을 발견하곤 한다. 예를 들어, 접근 제어(예: private, protected)가 없고, self 인자도 이상해 보이고, 객체 관련 작업은 "무엇이든 자유롭게" 할 수 있는 것처럼 느껴진다. 그것이 사실일 수도 있지만, 일반적인 프로그래밍 방식에서부터 객체 내부의 더 나은 캡슐화까지 어떻게 작동하는지 알게 될 것이다. 내부를 상세히 알지 못한다고 해서 생산성이 떨어지는 것은 아니다. 그렇지만, 파이썬 코더 대부분은 클래스가 작동하는 기본 원리를 이해한다. 그러므로 우리도 한번 알아보자. 5.1 딕셔너리 톺아보기(객체 구현) 5.2 캡슐화 기법 5.1 딕셔너리 톺아보기 파이썬 객체 시스템은 딕셔너리와 관련된 구현에 많은 부분 기반을 둔다. 이 섹션에서 그에 대해 논의한다. 딕셔너리 딕셔너리가 이름 붙은 값들의 컬렉션이라는 것을 상기하자. stock = { 'name' : 'GOOG', 'shares' : 100, 'price' : 490.1 } 딕셔너리는 주로 단순한 자료 구조를 위해 사용된다. 하지만, 인터프리터에서 중요하게 사용되며 파이썬에서 가장 중요한 자료형이다. 딕셔너리와 모듈 모듈에서, 딕셔너리는 모든 글로벌 변수와 함수를 보유한다. # foo.py x = 42 def bar(): ... def spam(): ... foo.__dict__나 globals()를 조사해 보면 딕셔너리가 보일 것이다. { 'x' : 42, 'bar' : <function bar>, 'spam' : <function spam> } 딕셔너리와 객체 사용자 정의 객체도 인스턴스 데이터와 클래스를 위해 딕셔너리를 사용한다. 사실, 객체 시스템 대부분이 딕셔너리 위에 세워진 추가적인 계층이라 할 수 있다. 인스턴스 데이터 __dict__는 딕셔너리다. >>> s = Stock('GOOG', 100, 490.1) >>> s.__dict__ {'name' : 'GOOG', 'shares' : 100, 'price': 490.1 } self에 할당할 때 이 딕셔너리와 인스턴스를 채운다. class Stock: def __init__(self, name, shares, price): self.name = name self.shares = shares self.price = price 인스턴스 데이터 self.__dict__는 다음과 같이 보인다. { 'name': 'GOOG', 'shares': 100, 'price': 490.1 } 인스턴스마다 자체적인 프라이빗 딕셔너리가 생긴다. s = Stock('GOOG', 100, 490.1) # {'name' : 'GOOG','shares' : 100, 'price': 490.1 } t = Stock('AAPL', 50, 123.45) # {'name' : 'AAPL','shares' : 50, 'price': 123.45 } 어떤 클래스의 인스턴스를 100개 만들었다고 하면, 데이터를 담는 딕셔너리 100개가 있는 셈이다. 클래스 멤버 메서드를 보유하는 독립적인 딕셔너리가 있다. class Stock: def __init__(self, name, shares, price): self.name = name self.shares = shares self.price = price def cost(self): return self.shares * self.price def sell(self, nshares): self.shares -= nshares 이 딕셔너리는 Stock.__dict__에 있다. { 'cost': <function>, 'sell': <function>, '__init__': <function> } 인스턴스와 클래스 인스턴스와 클래스는 서로 연결돼 있다. __class__ 어 트리뷰트는 클래스를 다시 참조한다. >>> s = Stock('GOOG', 100, 490.1) >>> s.__dict__ { 'name': 'GOOG', 'shares': 100, 'price': 490.1 } >>> s.__class__ <class '__main__.Stock'> >>> 인스턴스 딕셔너리는 각 인스턴스에 대해 고유한 데이터를 갖는다. 클래스 딕셔너리는 전체 인스턴스에서<NAME>는 데이터를 갖는다. 어트리뷰트 액세스 객체로 작업할 때는. 연산자를 사용해 데이터와 메서드에 액세스한다. x = obj.name # 얻기 obj.name = value # 설정 del obj.name # 삭제 이 연산자는 딕셔너리에 직접 연결된다. 인스턴스 수정 객체를 수정하는 연산은 딕셔너리를 갱신한다. >>> s = Stock('GOOG', 100, 490.1) >>> s.__dict__ { 'name':'GOOG', 'shares': 100, 'price': 490.1 } >>> s.shares = 50 # 설정 >>> s.date = '6/7/2007' # 설정 >>> s.__dict__ { 'name': 'GOOG', 'shares': 50, 'price': 490.1, 'date': '6/7/2007' } >>> del s.shares # 삭제 >>> s.__dict__ { 'name': 'GOOG', 'price': 490.1, 'date': '6/7/2007' } >>> 어 트리뷰트를 읽기 인스턴스에서 어 트리뷰트를 읽는다고 하자. x = obj.name 어 트리뷰트는 두 곳에 존재할 수 있다. 로컬 인스턴스 딕셔너리. 클래스 딕셔너리. 두 딕셔너리를 모두 확인한다. 먼저 로컬 __dict__를 확인한다. 거기서 찾을 수 없으면 __class__를 통해 클래스의 __dict__에서 찾는다. >>> s = Stock(...) >>> s.name 'GOOG' >>> s.cost() 49010.0 >>> 이러한 조회 방식으로 인해 class의 멤버가 모든 인스턴스에서 공유된다. 상속이 이뤄지는 원리 클래스는 다른 클래스로부터 상속할 수 있다. class A(B, C): ... 기본 클래스는 각 클래스의 튜플에 저장된다. >>> A.__bases__ (<class '__main__.B'>, <class '__main__.C'>) >>> 이것은 부모 클래스에 대한 링크를 제공한다. 상속과 어트리뷰트 읽기 논리적으로, 어 트리뷰트를 찾는 과정은 다음과 같다. 먼저, 로컬 __dict__를 확인한다. 찾지 못하면, 클래스의 __dict__를 확인한다. 클래스에서 찾지 못하면, __bases__를 통해 기본 클래스들에서 확인한다. 그런데 여기에는 미묘한 구석이 있다. 단일 상속과 어트리뷰트 읽기 여러 계층에 걸쳐 상속이 이뤄지는 경우, 어 트리뷰트를 찾기 위해 상속 트리를 차례대로 순회한다. class A: pass class B(A): pass class C(A): pass class D(B): pass class E(D): pass 단일 상속에서는 최상위 클래스로 가는 경로가 하나밖에 없다. 첫 번째 일치하는 것에서 멈춘다. 메서드 찾기 순서(MRO) 파이썬은 상속 사슬을 미리 계산해 클래스의 MRO 어 트리뷰트에 저장한다. 그것을 직접 볼 수 있다. >>> E.__mro__ (<class '__main__.E'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.A'>, <type 'object'>) >>> 이 사슬을 메서드 찾기 순서(Method Resolution Order)라 한다. 어 트리뷰트를 찾기 위해 파이썬은 MRO를 순회한다. 첫 번째 일치하는 것이 선택된다. 다중 상속의 MRO 다중 상속에서는 최상위에 이르는 단일 경로가 없다. 예를 살펴보자. class A: pass class B: pass class C(A, B): pass class D(B): pass class E(C, D): pass 어 트리뷰트에 액세스할 때 무슨 일이 일어나는가? e = E() e.attr 어트리뷰트 검색 과정이 수행되는데, 그 순서는 어떻게 이뤄지는가? 그것이 문제다. 파이선에서는 클래스 순서를 정할 때 협동 다중 상속(cooperative multiple inheritance)이라는 규칙을 따른다. 항상 자식을 부모보다 먼저 확인한다. 부모가 둘 이상인 경우 항상 리스트 된 순서대로 확인한다. 계층의 모든 클래스를 이 규칙에 따라 정렬함으로써 MRO를 계산한다. >>> E.__mro__ ( <class 'E'>, <class 'C'>, <class 'A'>, <class 'D'>, <class 'B'>, <class 'object'>) >>> 이때 사용하는 알고리듬은 ‘C3 선형화(Linearization)’라는 것으로, 세부적인 내용은 중요하지 않다. 집에 불이 났을 때 자식을 먼저 대피시킨 다음 부모가 대피하는 것처럼, 클래스 계층이 같은 순서 규칙을 따른다는 점만 기억하면 된다. 이상한 코드 재사용(다중 상속이 관련됨) 다음 두 예제를 보자. class Dog: def noise(self): return 'Bark' def chase(self): return 'Chasing!' class LoudDog(Dog): def noise(self): # LoudBike와의 코드 공통성(아래) return super().noise().upper() 위 예제의 객체들은 아래 예제의 객체들과 아무 관련이 없다. class Bike: def noise(self): return 'On Your Left' def pedal(self): return 'Pedaling!' class LoudBike(Bike): def noise(self): # LoudDog 과의 코드 공통성(위) return super().noise().upper() 그런데 LoudDog.noise()와 LoudBike.noise() 구현에는 공통적인 코드가 있다. 사실 코드가 똑같다. 소프트웨어 기술자라면 이런 코드에 끌리기 마련이다. 믹스인 패턴 믹스인(Mixin) 패턴은 코드 일부를 갖는 클래스다. class Loud: def noise(self): return super().noise().upper() 이 클래스는 동떨어져 사용할 수 없다. 이것은 상속을 통해 다른 클래스들을 뒤섞는다. class LoudDog(Loud, Dog): pass class LoudBike(Loud, Bike): pass noise 메서드를 한 번만 구현해, 서로 관계없는 두 클래스에 재사용했다. 파이썬에서 다중 상속을 사용하는 주 용도가 이런 것이다. super()를 사용하는 이유 메서드를 오버라이딩할 때는 항상 super()를 사용하라. class Loud: def noise(self): return super().noise().upper() super()는 MRO의 다음 클래스에 위임한다. 까다로운 부분은 당신이 그것을 알 수 없다는 점이다. 특히 다중 상속이 일어날 때는 그것이 무엇인지 알 수가 없다. 주의 사항 다중 상속은 강력한 도구다. 힘에는 책임이 따른다는 점을 명심하라. 프레임워크/라이브러리에서 컴포넌트의 구성과 관련된 고급 기능을 위해 그것을 종종 사용한다. 이제, 방금 본 것을 잊어라. 연습 문제 섹션 4에서, 보유 주식을 나타내는 Stock 클래스를 정의했다. 이 연습 문제에서는 그 클래스를 재사용한다. 인터프리터를 다시 시작해 인스턴스를 몇 개 만들자. >>> ================================ RESTART ================================ >>> from stock import Stock >>> goog = Stock('GOOG',100,490.10) >>> ibm = Stock('IBM',50, 91.23) >>> 연습 문제 5.1: 인스턴스 표현 상호작용적인 셸에서, 당신이 생성성 두 인스턴스의 내부 딕셔너리를 조사해 보라. >>> goog.__dict__ ... 출력을 보라 ... >>> ibm.__dict__ ... 출력을 보라 ... >>> 연습 문제 5.2: 인스턴스 데이터 수정 위 인스턴스들 중 하나에 새 어 트리뷰트를 설정해 보라. >>> goog.date = '6/11/2007' >>> goog.__dict__ ... 출력을 보라 ... >>> ibm.__dict__ ... 출력을 보라 ... >>> 위의 출력에서 goog 인스턴스는 date 속성을 갖는 반면 ibm 인스턴스는 그렇지 않은 것을 볼 수 있다. 파이썬은 속성에 아무 제한을 두지 않는다는 것에 유의하자. 예를 들어, 인스턴스의 어 트리뷰트는 __init__() 메서드에서 셋업 한 것에 국한되지 않는다. 어 트리뷰트를 설정하는 대신, __dict__ 객체에 새 값을 직접 넣어라. >>> goog.__dict__['time'] = '9:45am' >>> goog.time '9:45am' >>> 여기서 인스턴스는 딕셔너리 위의 계층에 불과하다는 것을 알 수 있다. 참고: 보통은 이런 식으로 딕셔너리를 직접 조작하지 않는다. 항상 (.) 구문을 사용해 코드를 작성하자. 연습 문제 5.3: 클래스의 역할 클래스 정의를 만드는 정의는 해당 클래스의 모든 인스턴스에 의해 공유된다. 모든 인스턴스가 관련 클래스에 대한 링크를 갖는다. >>> goog.__class__ ... 출력을 살펴보라 ... >>> ibm.__class__ ... 출력을 살펴보라 ... >>> 인스턴스에 대해 메서드를 호출해 보자. >>> goog.cost() 49010.0 >>> ibm.cost() 4561.5 >>> 'cost'라는 이름은 goog.__dict__나 ibm.__dict__에 정의돼 있지 않다. 클래스 딕셔너리에서 제공한 것이다. 다음과 같이 해 보라. >>> Stock.__dict__['cost'] ... 출력을 살펴보라 ... >>> 딕셔너리를 통해 cost() 메서드를 직접 호출해 보자. >>> Stock.__dict__['cost'](goog) 49010.0 >>> Stock.__dict__['cost'](ibm) 4561.5 >>> 클래스 정의에 정의된 함수를 호출한 것이다. self 인자가 인스턴스를 어떻게 얻는지도 유의하자. Stock 클래스에 새로운 어 트리뷰트를 추가해 보자. >>> Stock.foo = 42 >>> 새로 추가한 어 트리뷰트가 이제 모든 인스턴스에 나타난다. >>> goog.foo 42 >>> ibm.foo 42 >>> 그렇지만, 이는 인스턴스 딕셔너리에 속한 것은 아니다. >>> goog.__dict__ ... 출력을 살펴보면 'foo' 어 트리뷰트가 없다 ... >>> 인스턴스에서 foo 어 트리뷰트에 액세스할 수 있는 이유는, 파이썬에서는 인스턴스 자체에서 뭔가를 찾을 수 없으면 항상 클래스 딕셔너리를 확인하기 때문이다. 참고: 연습 문제의 이 부분은 클래스 변수라고 알려진 것을 묘사한다. 예를 들어, 다음과 같은 클래스가 있다고 하자. class Foo(object): a = 13 # 클래스 변수 def __init__(self, b): self.b = b # 인스턴스 변수 이 클래스에서 변수 a는 클래스 자체의 몸체에 할당된 '클래스 변수'다. 생성되는 모든 인스턴스가 이것을 공유한다. 예: >>> f = Foo(10) >>> g = Foo(20) >>> f.a # 클래스 변수를 조사(두 인스턴스에 대해 같음) 13 >>> g.a 13 >>> f.b # 인스턴스 변수를 조사(다름) 10 >>> g.b 20 >>> Foo.a = 42 # 클래스 변수의 값을 변경 >>> f.a 42 >>> g.a 42 >>> 연습 문제 5.4: 바운드 메서드 파이썬에서 메서드를 호출하는 것은 실제로는 두 단계로 이뤄지며 바운드 메서드라는 것이 관여한다. 예: >>> s = goog.sell >>> s <bound method Stock.sell of Stock('GOOG', 100, 490.1)> >>> s(25) >>> goog.shares 75 >>> 바운드 메서드는 메서드를 호출하는 데 필요한 것을 모두 포함한다. 예를 들어, 메서드를 구현하는 함수의 레코드를<NAME>다. >>> s.__func__ <function sell at 0x10049af50> >>> Stock 딕셔너리에서 이것과 같은 값을 찾을 수 있다. >>> Stock.__dict__['sell'] <function sell at 0x10049af50> >>> 바운드 메서드는 인스턴스, 즉 self 인자도 기록한다. >>> s.__self__ Stock('GOOG',75,490.1) >>> ()를 사용해 함수를 호출할 때 모든 것이 합쳐진다. 예를 들어, s(25)를 호출하는 것은 실제로는 다음과 같은 일을 한다. >>> s.__func__(s.__self__, 25) # s(25)와 같음 >>> goog.shares 50 >>> 연습 문제 5.5: 상속 Stock으로부터 상속받는 새 클래스를 생성한다. >>> class NewStock(Stock): def yow(self): print('Yow!') >>> n = NewStock('ACME', 50, 123.45) >>> n.cost() 6172.50 >>> n.yow() Yow! >>> 상속은 어 트리뷰트를 위한 검색 프로세스를 확장함으로써 구현된다. __bases__ 어 트리뷰트는 직계 부모의 튜플을 갖는다. >>> NewStock.__bases__ (<class 'stock.Stock'>,) >>> __mro__ 어 트리뷰트는 전체 부모의 튜플을 가지며, 그 순서에 따라 어 트리뷰트를 검색한다. >>> NewStock.__mro__ (<class '__main__.NewStock'>, <class 'stock.Stock'>, <class 'object'>) >>> 위의 n 인스턴스의 cost() 메서드를 찾는 방법은 다음과 같다. >>> for cls in n.__class__.__mro__: if 'cost' in cls.__dict__: break >>> cls <class '__main__.Stock'> >>> cls.__dict__['cost'] <function cost at 0x101aed598> >>> 5.2 클래스와 캡슐화 클래스를 작성할 때는 내부적인 세부사항을 캡슐화하는 것이 일반적이다. 이 섹션에서는 프라이빗 변수와 프로퍼티(property)를 포함해, 파이썬 프로그래밍의 몇 가지 관례를 소개한다. 퍼블릭 vs 프라이빗 클래스의 주역할 은 객체의 데이터와 내부 구현 세부사항을 캡슐화하는 것이다. 그러나, 외부 세계가 객체를 조작하는 데 사용할 퍼블릭(public) 인터페이스도 클래스에 정의해야 한다. 구현 세부사항과 퍼블릭 인터페이스를 구분하는 것이 중요하다. 문제점 파이썬에서는 클래스와 객체의 거의 모든 것이 오픈되어 있다. 객체의 내부를 쉽게 조사할 수 있고, 원하는 대로 바꿀 수 있다. 액세스 제어에 대한 강력한 개념은 없다(예: 프라이빗 클래스 멤버). 이는 내부 구현을 격리하고자 할 때 이슈가 된다. 파이썬의 캡슐화(Encapsulation) 파이썬은 의도된 사용법을 지시하는 프로그래밍 관례를 따른다. 이러한 관례는 명명(naming)에 기반을 둔다. 언어에서 규칙을 강요하기보다는 프로그래머가 자발적으로 준수하는 것이 일반적이다. 프라이빗 어트리뷰트 이름이 _로 시작하는 어 트리뷰트는 프라이빗(private)으로 간주한다. class Person(object): def __init__(self, name): self._name = 0 앞에서 언급한 것과 같이, 이것은 프로그래밍 스타일일 뿐이다. 여전히 그것에 액세스하고 변경할 수 있다. >>> p = Person('Guido') >>> p._name 'Guido' >>> p._name = 'Dave' >>> _로 시작하는 이름은, 그것이 변수든 함수든 모듈명이 든, 모두 내부 구현으로 간주하는 것이 일반적인 규칙이다. 그런 이름을 직접 사용하고 있다면 뭔가 잘못하고 있는 것이다. 고수준 기능을 찾아라. 단순 어트리뷰트 다음 클래스를 생각해 보자. class Stock: def __init__(self, name, shares, price): self.name = name self.shares = shares self.price = price 놀랍게도, 어떤 값에든지 어 트리뷰트를 설정할 수 있다. >>> s = Stock('IBM', 50, 91.1) >>> s.shares = 100 >>> s.shares = "hundred" >>> s.shares = [1, 0, 0] >>> 이것을 보고 뭔가 추가적인 검사가 필요하다는 생각이 들었을지 모른다. s.shares = '50' # 문자열인 경우 TypeError를 일으키고 싶다 이것을 어떻게 할 수 있을까? 관리(Managed) 어트리뷰트 접근자(accessor) 메서드를 도입하는 방법이 있긴 하다. class Stock: def __init__(self, name, shares, price): self.name = name self.set_shares(shares) self.price = price # "get" 연산을 계층화하는 기능 def get_shares(self): return self._shares # "set" 연산을 계층화하는 기능 def set_shares(self, value): if not isinstance(value, int): raise TypeError('Expected an int') self._shares = value 이것 때문에 기존 코드가 깨지는 것이 너무 나쁘다. s.shares = 50이 s.set_shares(50)이 된다. 프로퍼티 더 나은 방법이 있다. class Stock: def __init__(self, name, shares, price): self.name = name self.shares = shares self.price = price @property def shares(self): return self._shares @shares.setter def shares(self, value): if not isinstance(value, int): raise TypeError('Expected int') self._shares = value 이제 평범한 프로퍼티 액세스는 @property와 @shares.setter 하에서 getter와 setter 메서드를 트리거 한다. >>> s = Stock('IBM', 50, 91.1) >>> s.shares # @property를 트리거 50 >>> s.shares = 75 # @shares.setter를 트리거 >>> 이 패턴을 적용하면 소스 코드를 바꿀 필요가 없다. 새로운 setter도 클래스 내에 할당되면 내부 __init__() 메서드를 포함해 호출된다. class Stock: def __init__(self, name, shares, price): ... # 이 할당은 아래 setter를 호출한다 self.shares = shares ... ... @shares.setter def shares(self, value): if not isinstance(value, int): raise TypeError('Expected int') self._shares = value 프로퍼티와 프라이빗 이름이 혼동되곤 한다. 프로퍼티는 프라이빗 이름을 _shares 같이 내부적으로 사용하지만, 클래스의 나머지(프로퍼티가 아닌 것)는 shares와 같은 이름을 계속 사용할 수 있다. 프로퍼티는 또한 계산된 데이터 어 트리뷰트에 유용하다. class Stock: def __init__(self, name, shares, price): self.name = name self.shares = shares self.price = price @property def cost(self): return self.shares * self.price ... 이것은 추가적인 괄호를 버릴 수 있게 해주어, 그것이 실제로 메서드임을 숨긴다. >>> s = Stock('GOOG', 100, 490.1) >>> s.shares # 인스턴스 변수 100 >>> s.cost # 계산된 변수 49010.0 >>> 통일된 액세스 마지막 예제는 객체에 좀 더 통일된 인터페이스를 넣는 방법을 보여준다. 이것을 하지 않는다면 객체는 사용하기 혼동될 수 있다. >>> s = Stock('GOOG', 100, 490.1) >>> a = s.cost() # 메서드 49010.0 >>> b = s.shares # 데이터 어트리뷰트 100 >>> 왜 cost에는 ()가 붙어야 하고 share는 그렇지 않은가? 프로퍼티는 이것을 고칠 수 있다. 데코레이터(Decorator) 구문 @ 구문을 "데커레이션(decoration)"이라고 부른다. 데커레이션은 바로 뒤따라오는 함수 정의에 적용되는 수정자를 지정한다. ... @property def cost(self): return self.shares * self.price 자세한 사항은 7장에서 다룬다. __slots__ 어트리뷰트 어트리뷰트 이름의 집합을 제한할 수 있다. class Stock: __slots__ = ('name','_shares','price') def __init__(self, name, shares, price): self.name = name ... 그 외의 어 트리뷰트에 대해서는 오류가 일어난다. >>> s.price = 385.15 >>> s.prices = 410.2 Traceback (most recent call last): File "<stdin>", line 1, in ? AttributeError: 'Stock' object has no attribute 'prices' 이는 오류를 방지하고 객체 사용을 제한하지만, 실제로는 성능을 위해 사용되며 파이썬이 메모리를 더 효율적으로 사용하게 해준다. 캡슐화에 대한 최종 의견 프라이빗 어 트리뷰트, 프로퍼티, 슬롯 등을 사용하지 마라. 이런 것들은 특수한 목적이 있으며, 다른 파이썬 코드를 읽다 보면 눈에 띌 수 있다. 하지만 일상적인 코딩에는 거의 필요 없다. 연습 문제 연습 문제 5.6: 단순 프로퍼티 프로퍼티는 '계산된 어 트리뷰트'를 객체에 추가하는 유용한 방법이다. stock.py에서 Stock 객체를 생성했다. 그 객체는 데이터의 종류에 따라 추출 방법이 일관적이지 않다. >>> from stock import Stock >>> s = Stock('GOOG', 100, 490.1) >>> s.shares 100 >>> s.price 490.1 >>> s.cost() 49010.0 >>> 특히, cost는 메서드이므로 ()를 붙여야 한다. 만약 cost()를 프로퍼티로 바꿀 수 있다면 괄호를 제거할 수 있다. 다음과 같은 방법으로 cost 계산이 이뤄지게 Stock 클래스를 수정해 보라. >>> ================================ RESTART ================================ >>> from stock import Stock >>> s = Stock('GOOG', 100, 490.1) >>> s.cost 49010.0 >>> cost가 프로퍼티로 정의되었으므로, s.cost()를 호출하면 작동하지 않을 것이다. >>> s.cost() ... 실패 ... >>> 이렇게 수정하면 앞의 pcost.py 프로그램이 깨진다. 문제가 생기지 않게 cost() 메서드의 ()를 제거하라. 연습 문제 5.7: 프로퍼티와 Setter 값이 프라이빗 어 트리뷰트에 저장되고, 프로퍼티 함수의 쌍을 사용해 항상 정숫값이 설정됨을 보증하게 shares 어 트리뷰트를 수정한다. 예상되는 행위의 예는 다음과 같다. >>> ================================ RESTART ================================ >>> from stock import Stock >>> s = Stock('GOOG',100,490.10) >>> s.shares = 50 >>> s.shares = 'a lot' Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: expected an integer >>> 연습 문제 5.8: 슬롯 추가하기 Stock 클래스를 수정해 __slots__ 어 트리뷰트를 추가한다. 그런 다음, 새로운 어 트리뷰트를 추가할 수 없음을 확인한다. >>> ================================ RESTART ================================ >>> from stock import Stock >>> s = Stock('GOOG', 100, 490.10) >>> s.name 'GOOG' >>> s.blah = 42 ... 어떤 일이 일어나는지 보라 ... >>> __slots__를 사용하면 파이썬은 객체의 내부 표현을 더 효율적으로 사용한다. s의 딕셔너리를 조사하려고 하면 무슨 일이 일어날까? >>> s.__dict__ ... 어떤 일이 일어나는지 보라 ... >>> 데이터 구조로 사용되는 클래스의 최적화로 __slots__를 일반적으로 사용한다. 슬롯을 사용하면 프로그램이 메모리를 훨씬 적게 사용하고 더 빨리 실행된다. 하지만 그 외의 클래스에서는 __slots__를 사용하지 않는 것이 좋다. 6. 제너레이터 이터레이션(for 루프)은 파이썬의 가장 일반적인 프로그래밍 패턴이다. 프로그램에서 리스트를 다루고, 파일을 읽고, 데이터베이스에 질의하는 등의 여러 가지 일에 이터레이션이 자주 사용된다. 파이썬의 가장 큰 장점 중 하나가 바로 "제너레이터 함수"라는 형태로 이터레이션을 커스터마이즈하고 새롭게 정의할 수 있는 능력이다. 이 섹션은 이 주제를 다룬다. 끝으로, 실시간 스트리밍 데이터를 흥미로운 방식으로 처리하는 프로그램을 작성한다. 6.1 이터레이션 프로토콜 6.2 제너레이터를 사용해 이터레이션을 커스터마이즈 하기 6.3 생산자/소비자 문제와 흐름 6.4 제너레이터 표현식 6.1 이터레이션 프로토콜 이 섹션은 이터레이션이 어떻게 작동하는지 살펴본다. 너도나도 이터레이션 온갖 객체들이 이터레이션을 지원한다. a = 'hello' for c in a: # a의 문자를 루핑 ... b = { 'name': 'Dave', 'password':'foo'} for k in b: # 딕셔너리 키를 루핑 ... c = [1,2,3,4] for i in c: # 리스트/튜플의 항목을 루핑 ... f = open('foo.txt') for x in f: # 파일의 행을 루핑 ... 이터레이션: 프로토콜 for 문을 생각해 보자. for x in obj: # 문장 내부적으로 어떻게 작동하는가? _iter = obj.__iter__() # 이터 레이터 객체를 얻음 while True: try: x = _iter.__next__() # 다음 항목을 얻음 except StopIteration: # 남은 항목이 없음 break # 문장 ... for 문에서 작동하는 모든 객체는 이러한 저 수준 이터레이션 프로토콜을 구현한 것이다. 예제: 리스트에 대해 수작업으로 이터레이션. >>> x = [1,2,3] >>> it = x.__iter__() >>> it <listiterator object at 0x590b0> >>> it.__next__() >>> it.__next__() >>> it.__next__() >>> it.__next__() Traceback (most recent call last): File "<stdin>", line 1, in? StopIteration >>> 이터레이션 지원하기 이터레이션의 유용성을 이해한다면 스스로 작성한 객체도 이터레이션을 지원하게 하고 싶을 것이다. 예를 들어, 다음과 같이 커스텀 컨테이너를 만들 수 있다. class Portfolio: def __init__(self): self.holdings = [] def __iter__(self): return self.holdings.__iter__() ... port = Portfolio() for s in port: ... 연습 문제 연습 문제 6.1: 이터레이션 뜯어보기 다음 리스트를 생성한다. a = [1,9,4,25,16] 이 리스트에 대해 수작업으로 이터레이션을 수행하라. __iter__()를 호출해 이터 레이터를 얻은 다음, __next__() 메서드를 호출해 다음 번 원소를 얻는다. >>> i = a.__iter__() >>> i <listiterator object at 0x64c10> >>> i.__next__() >>> i.__next__() >>> i.__next__() >>> i.__next__() 25 >>> i.__next__() 16 >>> i.__next__() Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration >>> 빌트인 함수 next()를 사용하면 이터 레이터의 __next__() 메서드를 간편하게 호출할 수 있다. 파일을 가지고도 같은 일을 해 보자. >>> f = open('Data/portfolio.csv') >>> f.__iter__() # 참고: 이것은 파일 자체를 반환함 <_io.TextIOWrapper name='Data/portfolio.csv' mode='r' encoding='UTF-8'> >>> next(f) 'name, shares, price ' >>> next(f) '"AA",100,32.20\n' >>> next(f) '"IBM",50,91.10\n' >>> 파일의 끝에 도달할 때까지 next(f)를 계속 호출하라. 무슨 일이 일어나는지 관찰하라. 연습 문제 6.2: 이터레이션을 지원하기 당신이 직접 만든 객체가 이터레이션을 지원하게 하고 싶을 때가 있다. 기존 리스트나 다른 이터러블을 감싸는 객체를 만들었을 때가 특히 그렇다. 새 파일 portfolio.py에 다음 클래스를 정의하자. # portfolio.py class Portfolio: def __init__(self, holdings): self._holdings = holdings @property def total_cost(self): return sum([s.cost for s in self._holdings]) def tabulate_shares(self): from collections import Counter total_shares = Counter() for s in self._holdings: total_shares[s.name] += s.shares return total_shares 이 클래스는 리스트 주위에 계층을 덧씌우되, total_cost 프로퍼티와 같은 추가 메서드를 갖는다. report.py의 read_portfolio() 함수를 수정해 다음과 같은 Portfolio 인스턴스를 생성하게 하자. # report.py ... import fileparse from stock import Stock from portfolio import Portfolio def read_portfolio(filename): ''' 주식 포트폴리오 파일을 읽어 딕셔너리의 리스트를 생성. name, shares, price를 키로 사용. ''' with open(filename) as file: portdicts = fileparse.parse_csv(file, select=['name','shares','price'], types=[str, int, float]) portfolio = [ Stock(d['name'], d['shares'], d['price']) for d in portdicts ] return Portfolio(portfolio) ... report.py 프로그램을 실행해 보라. Portfolio 인스턴스가 이터러블하지 않다는 사실로 인해 요란하게 실패하는 모습을 보게 된다. >>> import report >>> report.portfolio_report('Data/portfolio.csv', 'Data/prices.csv') ... 충돌한다 ... Portfolio 클래스가 이터레이션을 지원하게 수정해서 문제를 해결해 보자. class Portfolio: def __init__(self, holdings): self._holdings = holdings def __iter__(self): return self._holdings.__iter__() @property def total_cost(self): return sum([s.shares*s.price for s in self._holdings]) def tabulate_shares(self): from collections import Counter total_shares = Counter() for s in self._holdings: total_shares[s.name] += s.shares return total_shares 이렇게 수정하고 나면 report.py 프로그램이 다시 잘 작동할 것이다. pcost.py 프로그램이 새로운 Portfolio 객체를 사용하게 수정하자. 이렇게 말이다. # pcost.py import report def portfolio_cost(filename): ''' 포트폴리오 파일의 총비용(주식 수 * 가격)을 계산 ''' portfolio = report.read_portfolio(filename) return portfolio.total_cost ... 잘 작동하는지 시험해 보자. >>> import pcost >>> pcost.portfolio_cost('Data/portfolio.csv') 44671.15 >>> 연습 문제 6.3: 더 적절한 컨테이너 만들기 컨테이너 클래스를 만들다 보면 이터레이션 외에도 넣고 싶은 기능이 더 있을 것이다. Portfolio 클래스를 다음과 같이 수정해 특수 메서드를 추가해 보자. class Portfolio: def __init__(self, holdings): self._holdings = holdings def __iter__(self): return self._holdings.__iter__() def __len__(self): return len(self._holdings) def __getitem__(self, index): return self._holdings[index] def __contains__(self, name): return any([s.name == name for s in self._holdings]) @property def total_cost(self): return sum([s.shares*s.price for s in self._holdings]) def tabulate_shares(self): from collections import Counter total_shares = Counter() for s in self._holdings: total_shares[s.name] += s.shares return total_shares 새 클래스를 가지고 실험을 해 보자. >>> import report >>> portfolio = report.read_portfolio('Data/portfolio.csv') >>> len(portfolio) >>> portfolio[0] Stock('AA', 100, 32.2) >>> portfolio[1] Stock('IBM', 50, 91.1) >>> portfolio[0:3] [Stock('AA', 100, 32.2), Stock('IBM', 50, 91.1), Stock('CAT', 150, 83.44)] >>> 'IBM' in portfolio True >>> 'AAPL' in portfolio False >>> 이와 관련해 중요한 점을 관찰할 수 있다. 코드가 파이썬에서 공통적으로 사용되는 어휘를 말한다면 '파이썬 다운(Pythonic)' 것으로 간주된다. 컨테이너 객체를 파이썬답게 만들려면 이터레이션, 인덱싱, containment, 기타 연산자를 지원하는 것이 중요하다. 6.2 이터레이션을 커스터마이징 이 섹션은 제너레이터 함수를 사용해 이터레이션을 커스터마이즈 하는 법을 살펴본다. 문제 커스텀 이터레이션 패턴을 만들고 싶다고 하자. 예(카운트다운): >>> for x in countdown(10): ... print(x, end=' ') ... 10 9 8 7 6 5 4 3 2 1 >>> 이것을 쉽게 할 수 있는 방법이 있다. 제너레이터 제너레이터는 이터레이션을 정의하는 함수다. def countdown(n): while n > 0: yield n n -= 1 예: >>> for x in countdown(10): ... print(x, end=' ') ... 10 9 8 7 6 5 4 3 2 1 >>> yield 문을 사용하는 함수는 제너레이터다. 제너레이터는 일반적인 함수와 다르게 작동한다. 제너레이터 함수를 호출하면 제너레이터 객체가 생성된다. 함수가 즉시 실행되는 것은 아니다. def countdown(n): # print 문을 추가했다 print('Counting down from', n) while n > 0: yield n n -= 1 >>> x = countdown(10) # print 문이 없다! >>> x # x는 generator 객체다 <generator object at 0x58490> >>> 이 함수는 __next__() 호출에 의해서만 실행된다. >>> x = countdown(10) >>> x <generator object at 0x58490> >>> x.__next__() Counting down from 10 10 >>> yield는 값을 생산하고, 함수 실행을 일시<NAME>다. 다음번 __next__() 호출 시 함수가 재개된다. >>> x.__next__() >>> x.__next__() 제너레이터가 마지막으로 반환할 때, 이터레이션은 오류를 일으킨다. >>> x.__next__() >>> x.__next__() Traceback (most recent call last): File "<stdin>", line 1, in? StopIteration >>> 관찰: 제너레이터 함수는 리스트, 튜플, 딕셔너리, 파일 등에 사용하는 for 문과 똑같은 저 수준 프로토콜을 구현한다. 연습 문제 연습 문제 6.4: 단순한 제너레이터 이터레이션을 커스터마이즈 하고 싶을 때에는 제너레이터 함수를 떠올려라. 작성하기 쉽다---원하는 이터레이션 로직을 함수로 구현하고, yield 문으로 값을 내보내면 된다. 예를 들어, 다음 제너레이터는 파일에서 특정 부분 문자열이 일치하는 행을 검색한다. >>> def filematch(filename, substr): with open(filename, 'r') as f: for line in f: if substr in line: yield line >>> for line in open('Data/portfolio.csv'): print(line, end='') name, shares, price "AA",100,32.20 "IBM",50,91.10 "CAT",150,83.44 "MSFT",200,51.23 "GE",95,40.37 "MSFT",50,65.10 "IBM",100,70.44 >>> for line in filematch('Data/portfolio.csv', 'IBM'): print(line, end='') "IBM",50,91.10 "IBM",100,70.44 >>> 함수에서 커스터마이즈 한 부분을 숨기고 for 루프에 먹이는 데 사용할 수 있다는 점에서 꽤 흥미롭다. 좀 더 특이한 사례를 살펴보자. 연습 문제 6.5: 스트리밍 데이터 소스를 모니터링 제너레이터는 로그 파일이라든지 주식 시장 피드와 같은 실시간 데이터 소스를 모니터링하는 흥미로운 방법이다. 이 개념을 탐색해 보자. 시작하려면 다음 지침을 주의 깊게 따르기 바란다. Data/stocksim.py는 주식 시장 데이터를 시뮬레이션하는 프로그램이다. 이 프로그램은 출력으로서, Data/stocklog.csv 파일에 실시간 데이터를 지속적으로 기록한다. 별도의 명령 창에서 Data/ 디렉터리로 가서 이 프로그램을 실행한다. bash % python3 stocksim.py 윈도에서는 탐색기에서 stocksim.py를 더블클릭하면 실행된다. 이제 이 프로그램은 잊어버리자(실행되게 내버려 둔다). 다른 창에서, 시뮬레이터에 의해 Data/stocklog.csv 파일이 기록되는 것을 살펴보자. 몇 초마다 새로운 텍스트 행이 파일에 추가되는 것을 볼 수 있을 것이다. 다시 말하지만, 이 프로그램은 몇 시간이고 실행되게 내버려 둔다(걱정할 필요는 없다). 프로그램이 실행되면, 파일을 열고 파일의 끝에 새로운 출력이 있는지 감시(watch) 하는 작은 프로그램을 작성하자. follow.py 파일에 다음과 같이 코드를 작성한다. # follow.py import os import time f = open('Data/stocklog.csv') f.seek(0, os.SEEK_END) # 파일 포인터를 파일의 끝으로부터 0 바이트로 이동 while True: line = f.readline() if line == '': time.sleep(0.1) # 짧게 쉬었다가 재시도 continue fields = line.split(',') name = fields[0].strip('"') price = float(fields[1]) change = float(fields[4]) if change < 0: print(f'{name:>10s} {price:>10.2f} {change:>10.2f}') 프로그램을 실행하면 실시간 주식 티커를 볼 수 있다. 이 코드는 유닉스의 tail -f 명령처럼 로그 파일을 감시한다. 참고: 파일에서 행을 읽는 일반적인 방법이 아니라는 점에서, 이 예의 readline() 메서드의 사용은 그리 일반적이지 않다(보통은 for 루프를 사용한다). 그렇지만 이 경우 파일의 끝에 새로운 데이터가 추가되는지 반복적으로 확인한다(readline()은 새 데이터 또는 빈 문자열을 반환한다). 연습 문제 6.6: 제너레이터를 사용해 데이터를 생산 연습 문제 6.5의 코드를 보면, 코드의 첫 부분은 데이터의 행들을 생산하고, while 루프의 끝 문장은 데이터를 소비한다. 제너레이터 함수의 주요 기능은 모든 데이터 생산 코드를 재사용 가능한 함수로 이전하는 것이다. 제너레이터 함수 follow(filename) 이 파일 읽기를 수행하도록 연습 문제 6.5의 코드를 수정하자. 다음 코드가 작동하게 하라. >>> for line in follow('Data/stocklog.csv'): print(line, end='') ... 출력 행이 여기 만들어져야 한다 ... 주식 티커 코드를 다음과 같이 수정하자. if __name__ == '__main__': for line in follow('Data/stocklog.csv'): fields = line.split(',') name = fields[0].strip('"') price = float(fields[1]) change = float(fields[4]) if change < 0: print(f'{name:>10s} {price:>10.2f} {change:>10.2f}') 연습 문제 6.7: 포트폴리오 감시하기 주식 데이터의 스트림을 감시해, 포트폴리오에 있는 주식의 정보만 티커를 프린트하도록 follow.py 프로그램을 수정하자. 예: if __name__ == '__main__': import report portfolio = report.read_portfolio('Data/portfolio.csv') for line in follow('Data/stocklog.csv'): fields = line.split(',') name = fields[0].strip('"') price = float(fields[1]) change = float(fields[4]) if name in portfolio: print(f'{name:>10s} {price:>10.2f} {change:>10.2f}') 참고: 이 작업을 위해, Portfolio 클래스는 반드시 in 연산자를 지원해야 한다. 연습 문제 6.3을 참고해서 __contains__() 연산자를 구현하자. 논의 매우 강력한 것을 만들었다. 흥미로운 이터레이션 패턴(파일의 마지막 행을 읽기)을 그것의 작은 함수에 옮겼다. 이제 follow() 함수는 완전히 일반적인 유틸리티가 되었으며, 다른 프로그램에서도 사용할 수 있게 됐다. 예를 들어, 서버 로그, 디버깅 로그, 기타 그와 비슷한 데이터 소스를 감시할 수 있다. 훌륭하다. 6.3 생산자, 소비자, 파이프라인 제너레이터는 생산자/소비자 문제와 데이터 흐름 파이프라인 같은 다양한 문제를 푸는 데 유용한 도구다. 이 섹션은 그에 대해 논의한다. 생산자-소비자 문제 제너레이터는 생산자-소비자(producer-consumer) 문제와 밀접한 연관이 있다. # 생산자 def follow(f): ... while True: ... yield line # 아래 `line`에 값을 생산 ... # 소비자 for line in follow(f): # 위에서 `yield`한 값을 소비 ... yield가 생산한 값을 for 문에서 소비한다. 제너레이터 파이프라인 제너레이터의 이러한 측면을 사용해 처리 파이프라인(Unix 파이프 같은 것)을 설정할 수 있다. 생산자 → 처리 → 처리 → 소비자 처리 파이프는 초기 데이터 생산자, 중간 처리 단계, 최종 소비자로 이뤄진다. 생산자 → 처리 → 처리 → 소비자 def producer(): ... yield item ... 생산자는 일반적으로 제너레이터다. 다른 시퀀스의 리스트가 될 수도 있다. yield는 파이프라인에 데이터를 공급한다. 생산자 → 처리 → 처리 → 소비자 def consumer(s): for item in s: ... 소비자는 for 루프다. 항목을 얻어 무언가를 한다. 생산자 → 처리 → 처리 → 소비자 def processing(s): for item in s: ... yield newitem ... 중간 처리 단계에서는 항목의 소비와 생산이 동시에 이뤄진다. 그것들은 데이터 스트림을 수정할 수도 있다. 그것들은 필터링(항목을 버림)을 할 수도 있다. 생산자 → 처리 → 처리 → 소비자 def producer(): ... yield item # yield 한 item을 `processing`이 받음 ... def processing(s): for item in s: # `producer`로부터 온 것 ... yield newitem # newitem을 yield ... def consumer(s): for item in s: # `processing`으로부터 온 것 ... 파이프라인을 설정하는 코드 a = producer() b = processing(a) c = consumer(b) 데이터가 서로 다른 함수들을 통해 점진적으로 흐른다는 것을 알 수 있다. 연습 문제 이 연습 문제를 위해 stocksim.py 프로그램을 백그라운드에서 계속 실행해야 한다. 이전 연습 문제에서 작성한 follow() 함수를 사용한다. 연습 문제 6.8: 단순한 파이프라인 구성 파이프라인 개념의 실제 구현을 살펴보자. 다음 함수를 작성하라. >>> def filematch(lines, substr): for line in lines: if substr in line: yield line >>> 이 함수는 지난 연습 문제의 첫 번째 제너레이터 예제와 거의 같지만, 파일을 열지 않고 인자로 받은 행들의 시퀀스에 대해서만 연산을 한다. 다음을 시도해 보자. >>> lines = follow('Data/stocklog.csv') >>> ibm = filematch(lines, 'IBM') >>> for line in ibm: print(line) ... 출력을 기다린다 ... 출력이 나타나는 데 시간이 걸릴 수도 있지만, 결국 IBM의 데이터를 포함하는 행이 나타난다. 연습 문제 6.9: 좀 더 복잡한 파이프라인 구성 파이프라인의 아이디어를 발전시켜서 더 많은 작업을 수행해 보자. >>> from follow import follow >>> import csv >>> lines = follow('Data/stocklog.csv') >>> rows = csv.reader(lines) >>> for row in rows: print(row) ['BA', '98.35', '6/11/2007', '09:41.07', '0.16', '98.25', '98.35', '98.31', '158148'] ['AA', '39.63', '6/11/2007', '09:41.07', '-0.03', '39.67', '39.63', '39.31', '270224'] ['XOM', '82.45', '6/11/2007', '09:41.07', '-0.23', '82.68', '82.64', '82.41', '748062'] ['PG', '62.95', '6/11/2007', '09:41.08', '-0.12', '62.80', '62.97', '62.61', '454327'] ... 흥미롭다. follow() 함수의 출력이 csv.reader() 함수로 전달되어 행이 분할된 것을 볼 수 있다. 연습 문제 6.10: 더 큰 파이프라인 컴포넌트 파이프라인을 더 키워보자. 별도의 파일 ticker.py에 CSV 파일을 읽는 함수를 생성한다. # ticker.py from follow import follow import csv def parse_stock_data(lines): rows = csv.reader(lines) return rows if __name__ == '__main__': lines = follow('Data/stocklog.csv') rows = parse_stock_data(lines) for row in rows: print(row) 특정 칼럼을 선택하는 함수를 새로 작성한다. # ticker.py ... def select_columns(rows, indices): for row in rows: yield [row[index] for index in indices] ... def parse_stock_data(lines): rows = csv.reader(lines) rows = select_columns(rows, [0, 1, 4]) return rows 프로그램을 다시 실행하자. 선택한 칼럼만 출력된다. ['BA', '98.35', '0.16'] ['AA', '39.63', '-0.03'] ['XOM', '82.45','-0.23'] ['PG', '62.95', '-0.12'] ... 자료형을 변환해 딕셔너리를 만드는 제너레이터 함수를 작성하자. 예: # ticker.py ... def convert_types(rows, types): for row in rows: yield [func(val) for func, val in zip(types, row)] def make_dicts(rows, headers): for row in rows: yield dict(zip(headers, row)) ... def parse_stock_data(lines): rows = csv.reader(lines) rows = select_columns(rows, [0, 1, 4]) rows = convert_types(rows, [str, float, float]) rows = make_dicts(rows, ['name', 'price', 'change']) return rows ... 프로그램을 다시 실행하자. 다음과 같이 딕셔너리를 스트리밍 하게 됐다. { 'name':'BA', 'price':98.35, 'change':0.16 } { 'name':'AA', 'price':39.63, 'change':-0.03 } { 'name':'XOM', 'price':82.45, 'change': -0.23 } { 'name':'PG', 'price':62.95, 'change':-0.12 } ... 연습 문제 6.11: 데이터를 필터링하기 데이터를 필터링하는 함수를 작성하자. 예: # ticker.py ... def filter_symbols(rows, names): for row in rows: if row['name'] in names: yield row 이것을 사용해 포트폴리오에 있는 주식만 나오게 해보자. import report portfolio = report.read_portfolio('Data/portfolio.csv') rows = parse_stock_data(follow('Data/stocklog.csv')) rows = filter_symbols(rows, portfolio) for row in rows: print(row) 연습 문제 6.12: 모두 합치기 주어진 포트폴리오, 로그 파일, 표<NAME>대로 실시간 주식 티커를 생성하는 ticker(portfile, logfile, fmt) 함수를 ticker.py 프로그램에 작성한다. 예: >>> from ticker import ticker >>> ticker('Data/portfolio.csv', 'Data/stocklog.csv', 'txt') Name Price Change ---------- ---------- ---------- GE 37.14 -0.18 MSFT 29.96 -0.09 CAT 78.03 -0.49 AA 39.34 -0.32 ... >>> ticker('Data/portfolio.csv', 'Data/stocklog.csv', 'csv') Name, Price, Change IBM, 102.79, -0.28 CAT, 78.04, -0.48 AA, 39.35, -0.31 CAT, 78.05, -0.47 ... 논의 배운 것: 다양한 제너레이터 함수를 생성할 수 있으며 그것들을 함께 엮어서 데이터 흐름 파이프라인 처리를 수행할 수 있다. 또한, 파이프라인의 단계들을 패키징 하는 함수를 작성해 단일 함수로 호출할 수 있다(예: parse_stock_data() 함수). 6.4 제너레이터 심화 이 섹션은 제너레이터 표현식과 itertools 모듈 같은 몇 가지 추가적인 제너레이터 관련 주제를 소개한다. 제너레이터 표현식 리스트 컴프리헨션의 제너레이터 버전. >>> a = [1,2,3,4] >>> b = (2*x for x in a) >>> b <generator object at 0x58760> >>> for i in b: ... print(i, end=' ') ... 2 4 6 8 >>> 리스트 컴프리헨션과의 차이점. 리스트를 생성하지 않는다. 유일한 용도는 이터레이션이다. 소비되고 나면 재사용할 수 없다. 일반적인 구문. (<표현식> for i in s if <조건>) 함수 인자로도 사용할 수 있다. sum(x*x for x in a) 모든 이터러블에 적용할 수 있다. >>> a = [1,2,3,4] >>> b = (x*x for x in a) >>> c = (-x for x in b) >>> for i in c: ... print(i, end=' ') ... -1 -4 -9 -16 >>> 제너레이터 표현식의<NAME>도는 시퀀스에서 계산을 수행하되 결과를 단 한 번만 사용하는 코드를 위한 것이다. 예를 들어, 파일에서 모든 주석을 제거한다. f = open('somefile.txt') lines = (line for line in f if not line.startswith('#')) for line in lines: ... f.close() 제너레이터를 사용하면 코드가 더 빨리 작동하며 메모리를 적게 사용한다. 스트림에 필터를 적용한 것과 같다. 제너레이터를 사용하는 이유 많은 프로그램은 이터레이션으로 깔끔하게 표현된다. 항목들의 컬렉션을 루핑 하며 몇 가지 연산(검색, 교체, 수정 등)을 수행한다. 파이프라인을 처리하는 것은 더 넓은 범위의 데이터 처리 문제가 적용된다. 메모리를 더 효율적으로 사용한다. 필요할 때만 값을 생산한다. 거대한 리스트를 생성하는 것과 대비된다. 스트리밍 데이터를 다룰 수 있다 제너레이터는 코드 재사용을 촉진한다 코드에서 이터레이션과 이터레이션 사용을 분리한다. 흥미로운 이터레이션 함수의 도구 모음을 만들고 믹스 앤 매치할 수 있다. itertools 모듈 itertools는 이터 레이터/제너레이터를 돕도록 설계된 다양한 함수가 있는 라이브러리 모듈이다. itertools.chain(s1, s2) itertools.count(n) itertools.cycle(s) itertools.dropwhile(predicate, s) itertools.groupby(s) itertools.ifilter(predicate, s) itertools.imap(function, s1, ... sN) itertools.repeat(s, n) itertools.tee(s, ncopies) itertools.izip(s1, ... , sN) 모든 함수는 데이터를 반복적으로 처리한다. 다양한 이터레이션 패턴을 구현한다. 자세한 정보는 2008년 파이콘의 시스템 프로그래머를 위한 제너레이터 트릭 튜토리얼을 참조하라. 연습 문제 지난 연습 문제에서, 로그 파일에 행을 기록하고 행들의 시퀀스로 파싱 하는 코드를 작성했다. 이번 문제는 지난 문제와 이어진다. Data/stocksim.py가 계속 실행되는지 확인하자. 연습 문제 6.13: 제너레이터 표현식 제너레이터 표현식은 리스트 컴프리헨션의 제너레이터 버전이다. 예: >>> nums = [1, 2, 3, 4, 5] >>> squares = (x*x for x in nums) >>> squares <generator object <genexpr> at 0x109207e60> >>> for n in squares: ... print(n) ... 4 16 25 제너레이터 표현식은 리스트 컴프리헨션과 달리 단 한 번만 사용 가능하다. 따라서, 다른 for 루프를 시도하면 아무것도 얻지 못할 것이다. >>> for n in squares: ... print(n) ... >>> 연습 문제 6.14: 제너레이터 표현식을 함수 인자로 사용 제너레이터 표현식을 함수 인자로 사용하기도 한다. 처음에는 좀 이상해 보이겠지만, 다음과 같이 해 보라. >>> nums = [1,2,3,4,5] >>> sum([x*x for x in nums]) # 리스트 컴프리 헨 션 55 >>> sum(x*x for x in nums) # 제너레이터 표현식 55 >>> 큰 리스트를 조작하는 경우, 제너레이터를 사용하는 버전이 메모리를 훨씬 적게 사용한다. portfolio.py 파일에서 리스트 컴프리헨션을 사용하는 계산을 수행했다. 그것들을 제너레이터 표현식으로 바꿔보라. 연습 문제 6.15: 코드 단순화하기 제너레이터 표현식은 작은 제너레이터 함수를 대체할 수 있어 유용하다. 예를 들어, 다음과 같은 함수가 있다. def filter_symbols(rows, names): for row in rows: if row['name'] in names: yield row 다음과 같이 작성할 수 있다. rows = (row for row in rows if row['name'] in names) 제너레이터 표현식을 사용하도록 ticker.py 프로그램을 수정하자. 7. 고급 주제 이 섹션에서는 고급 주제 가운데 일상적인 코딩에서 접할 수 있는 것을 살펴본다. 이러한 주제는 대부분 이전의 섹션에서 다룰 수도 있었지만, 설명이 너무 복잡해지는 것을 피하기 위해 미뤄둔 것이다. 이 섹션은 이러한 개념의 극히 기본적인 소개로서 다룬다는 점을 강조해야겠다. 자세한 내용은 자료를 찾아보라. 7.1 가변 인자 함수 7.2 익명 함수와 람다 7.3 함수를 반환하기(클로저) 7.4 함수 데코레이터 7.5 정적 및 클래스 메서드 7.1 가변 인자 이 섹션은 *args와 **kwargs 같은 함수 인자를 다룬다. 위치 가변 인자(*args) 임의의 개수의 인자를 받는 함수를 가리켜 가변 인자를 사용한다고 표현한다. 예: def f(x, *args): ... 함수 호출. f(1,2,3,4,5) 추가적인 인자를 튜플로 전달한다. def f(x, *args): # x -> 1 # args -> (2,3,4,5) 키워드 가변 인자(**kwargs) 함수는 임의의 개수의 키워드 인자도 받을 수 있다. 예: def f(x, y, **kwargs): ... 함수 호출. f(2, 3, flag=True, mode='fast', header='debug') 추가적인 키워드를 딕셔너리로 전달한다. def f(x, y, **kwargs): # x -> 2 # y -> 3 # kwargs -> { 'flag': True, 'mode': 'fast', 'header': 'debug' } 두 가지를 혼합 함수는 임의의 개수의 가변 인자와 키워드 없는(non-keyword) 인자들을 받을 수 있다. def f(*args, **kwargs): ... 함수 호출. f(2, 3, flag=True, mode='fast', header='debug') 인자들은 위치 및 키워드 요소로 분할된다. def f(*args, **kwargs): # args = (2, 3) # kwargs -> { 'flag': True, 'mode': 'fast', 'header': 'debug' } ... 이 함수는 위치 또는 키워드 인자들의 어떠한 조합이라도 받을 수 있다. 래퍼(wrapper)를 작성하거나 인자를 다른 함수에 전달하고자 할 때 사용하곤 한다. 튜플과 딕셔너리를 전달하기 튜플을 가변 인자로 확장할 수 있다. numbers = (2,3,4) f(1, *numbers) # f(1,2,3,4)와 같음 마찬가지로 딕셔너리를 키워드 인자로 확장할 수 있다. options = { 'color' : 'red', 'delimiter' : ',', 'width' : 400 } f(data, **options) # f(data, color='red', delimiter=',', width=400)와 같음 연습 문제 연습 문제 7.1: 가변 인자의 간단한 예 다음 함수를 정의해 보자. >>> def avg(x,*more): return float(x+sum(more))/(1+len(more)) >>> avg(10,11) 10.5 >>> avg(3,4,5) 4.0 >>> avg(1,2,3,4,5,6) 3.5 >>> *more 매개변수(parameter)가 추가적인 인자를 어떻게 수집하는지 살펴보라. 연습 문제 7.2: 튜플과 딕셔너리를 인자로 전달 데이터 파일을 읽어 다음과 같은 튜플을 얻었다고 하자. >>> data = ('GOOG', 100, 490.1) >>> 이 데이터로부터 Stock 객체를 생성하고자 한다. 그런데 data를 직접 전달하면 작동하지 않는다. >>> from stock import Stock >>> s = Stock(data) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: __init__() takes exactly 4 arguments (2 given) >>> 그 대신 *data를 사용하면 간단히 해결할 수 있다. 다음과 같이 해 보라. >>> s = Stock(*data) >>> s Stock('GOOG', 100, 490.1) >>> 딕셔너리를 사용할 때는 **을 붙인다. 예: >>> data = { 'name': 'GOOG', 'shares': 100, 'price': 490.1 } >>> s = Stock(**data) Stock('GOOG', 100, 490.1) >>> 연습 문제 7.3: 인스턴스의 리스트를 생성 report.py 프로그램에서 다음과 같은 코드를 사용해 인스턴스의 리스트를 생성했다. def read_portfolio(filename): ''' 주식 포트폴리오 파일을 읽어 딕셔너리의 리스트를 생성. name, shares, price를 키로 사용. ''' with open(filename) as lines: portdicts = fileparse.parse_csv(lines, select=['name','shares','price'], types=[str, int, float]) portfolio = [ Stock(d['name'], d['shares'], d['price']) for d in portdicts ] return Portfolio(portfolio) Stock(**d)를 사용해 코드를 단순화할 수 있다. 그렇게 바꿔보라. 연습 문제 7.4: 인자 통과 fileparse.parse_csv() 함수에는 파일 구분자를 바꾸거나 오류를 보고하는 옵션이 있다. 위의 read_portfolio() 함수에 그런 기능이 있으면 좋을 것이다. 다음과 같이 바꿔보자. def read_portfolio(filename, **opts): ''' 주식 포트폴리오 파일을 읽어 딕셔너리의 리스트를 생성. name, shares, price를 키로 사용. ''' with open(filename) as lines: portdicts = fileparse.parse_csv(lines, select=['name','shares','price'], types=[str, int, float], **opts) portfolio = [ Stock(**d) for d in portdicts ] return Portfolio(portfolio) 변경을 했으면, 오류가 있는 파일을 읽어보자. >>> import report >>> port = report.read_portfolio('Data/missing.csv') Row 4: Couldn't convert ['MSFT', '', '51.23'] Row 4: Reason invalid literal for int() with base 10: '' Row 7: Couldn't convert ['IBM', '', '70.44'] Row 7: Reason invalid literal for int() with base 10: '' >>> 오류 메시지가 나오지 않게 해 보자. >>> import report >>> port = report.read_portfolio('Data/missing.csv', silence_errors=True) >>> 7.2 익명 함수와 람다 리스트 정렬 되돌아보기 리스트를 제자리에서(in-place) 정렬할 수 있다. sort 메서드를 사용한다. s = [10,1,7,3] s.sort() # s = [1,3,7,10] 역순으로 정렬할 수 있다. s = [10,1,7,3] s.sort(reverse=True) # s = [10,7,3,1] 간단해 보인다. 그런데, 딕셔너리를 정렬하려면 어떻게 해야 할까? [{'name': 'AA', 'price': 32.2, 'shares': 100}, {'name': 'IBM', 'price': 91.1, 'shares': 50}, {'name': 'CAT', 'price': 83.44, 'shares': 150}, {'name': 'MSFT', 'price': 51.23, 'shares': 200}, {'name': 'GE', 'price': 40.37, 'shares': 95}, {'name': 'MSFT', 'price': 65.1, 'shares': 50}, {'name': 'IBM', 'price': 70.44, 'shares': 100}] 어떤 기준으로? 키(key) 함수를 사용해 정렬 기준을 안내할 수 있다. 키 함수는 딕셔너리를 받아서 정렬 기준값을 반환한다. def stock_name(s): return s['name'] portfolio.sort(key=stock_name) 결과는 다음과 같다. # 딕셔너리가 `name` 키를 기준으로 정렬됨 [ {'name': 'AA', 'price': 32.2, 'shares': 100}, {'name': 'CAT', 'price': 83.44, 'shares': 150}, {'name': 'GE', 'price': 40.37, 'shares': 95}, {'name': 'IBM', 'price': 91.1, 'shares': 50}, {'name': 'IBM', 'price': 70.44, 'shares': 100}, {'name': 'MSFT', 'price': 51.23, 'shares': 200}, {'name': 'MSFT', 'price': 65.1, 'shares': 50} ] 콜백 함수(Callback Function) 앞의 예에서 키 함수는 콜백 함수의 일종이다. sort() 메서드는 당신이 제공한 함수를 콜백 한다. 콜백 함수는 짧은 한 줄짜리 함수로 작성해 단 하나의 오퍼레이션만을 위해 사용하는 경우가 많다. 프로그래머는 종종 이러한 추가적인 처리를 위한 지름길을 요구한다. 람다(Lambda): 익명 함수 함수를 작성하는 대신 람다를 사용하자. 앞의 정렬 예제를 가지고 해 본다. portfolio.sort(key=lambda s: s['name']) 람다는 단일 표현식을 평가하는 이름 없는 함수를 생성한다. 위 코드는 함수로 만들었을 때보다 훨씬 짧다. def stock_name(s): return s['name'] portfolio.sort(key=stock_name) # 람다와 비교 portfolio.sort(key=lambda s: s['name']) 람다 사용하기 람다는 매우 제한적이다. 단일 표현식만 허용한다. if, while 같은 문장은 허용하지 않는다. sort()의 예와 같이 함수와 함께 사용하는 것이 일반적인 용도다. 연습 문제 주식 포트폴리오 데이터를 읽어 리스트로 변환하자. >>> import report >>> portfolio = list(report.read_portfolio('Data/portfolio.csv')) >>> for s in portfolio: print(s) Stock('AA', 100, 32.2) Stock('IBM', 50, 91.1) Stock('CAT', 150, 83.44) Stock('MSFT', 200, 51.23) Stock('GE', 95, 40.37) Stock('MSFT', 50, 65.1) Stock('IBM', 100, 70.44) >>> 연습 문제 7.5: 필드 정렬하기 포트폴리오 데이터를 종목명을 기준으로 알파벳순으로 정렬해 보자. >>> def stock_name(s): return s.name >>> portfolio.sort(key=stock_name) >>> for s in portfolio: print(s) ... 결과를 확인하라 ... >>> 위의 stock_name() 함수는 portfolio 리스트의 단일 항목에서 종목명을 추출한다. sort()는 이 함수의 결과를 비교해 정렬한다. 연습 문제 7.6: 람다를 가지고 필드 정렬하기 lambda 표현식을 사용해 주식 수를 기준으로 포트폴리오를 정렬해 보자. >>> portfolio.sort(key=lambda s: s.shares) >>> for s in portfolio: print(s) ... 결과를 확인하라 ... >>> 주식 가격을 기준으로 포트폴리오를 정렬해 보자. >>> portfolio.sort(key=lambda s: s.price) >>> for s in portfolio: print(s) ... 결과를 확인하라 ... >>> 참고: lambda는 별도의 함수를 따로 정의할 필요 없이 sort()를 호출할 때 특수한 처리 함수를 정의할 수 있어 유용하다. 7.3 함수를 반환하기 이 섹션은 함수를 사용해 다른 함수를 생성하는 아이디어를 소개한다. 도입 다음 함수를 생각해 보자. def add(x, y): def do_add(): print('Adding', x, y) return x + y return do_add add() 함수는 또 다른 함수인 do_add를 반환한다. >>> a = add(3,4) >>> a <function do_add at 0x6a670> >>> a() Adding 3 4 로컬 변수 외부 함수가 정의한 변수를 내부 함수가 어떻게 참조하는지 관찰하자. def add(x, y): def do_add(): # `x`와 `y`는 `add(x, y)`에 정의 print('Adding', x, y) return x + y return do_add 좀 더 관찰해 보면 이 변수들이 add()가 완료된 후에도 살아 있는 것을 볼 수 있다. >>> a = add(3,4) >>> a <function do_add at 0x6a670> >>> a() Adding 3 4 # 이 변수들은 어디서 왔을까? 클로저 내부 함수를 결과로 반환할 때, 그 내부 함수를 클로저(closure)라고 부른다. def add(x, y): # `do_add`는 클로저다 def do_add(): print('Adding', x, y) return x + y return do_add 필수 기능: 클로저는 나중에 함수가 올바로 작동하는 데 필요한 모든 변수의 값을<NAME>다. 클로저를 함수와 그 함수가 의존하는 변숫값을 저장하는 환경이 합쳐진 것으로 생각할 수 있다. 클로저 사용하기 클로저는 파이썬의 중요 기능이다. 그런데 그 용법은 미묘한 데가 있다. 공통적인 응용은 다음과 같다. 콜백 함수에 사용. 지연된 평가. 데코레이터 함수(뒤에서 설명한다). 지연된 평가(Delayed Evaluation) 다음과 같은 함수를 생각해 보자. def after(seconds, func): time.sleep(seconds) func() 용례: def greeting(): print('Hello Guido') after(30, greeting) after는 제공된 함수를 실행한다... 나중에. 클로저는 추가적인 정보를 보유한다. def add(x, y): def do_add(): print(f'Adding {x} + {y} -> {x+y}') return do_add def after(seconds, func): time.sleep(seconds) func() after(30, add(2, 3)) # `do_add`는 레퍼런스 x -> 2와 y -> 3를 가짐 코드 반복 과도한 코드 반복을 피하는 기법으로서 클로저를 사용할 수도 있다. 코드를 작성하는 함수를 작성할 수 있다. 연습 문제 연습 문제 7.7: 반복을 피하기 위해 클로저 사용하기 클로저는 반복적인 코드를 생성하는 기능이 뛰어나다. 연습 문제 5.7에서 타입을 검사하는 프로퍼티를 정의한 코드를 작성했다. class Stock: def __init__(self, name, shares, price): self.name = name self.shares = shares self.price = price ... @property def shares(self): return self._shares @shares.setter def shares(self, value): if not isinstance(value, int): raise TypeError('Expected int') self._shares = value ... 코드를 일일이 타이핑하는 대신, 클로저를 사용해 자동으로 생성할 수 있다. typedproperty.py 파일을 만들어 다음 코드를 넣자. # typedproperty.py def typedproperty(name, expected_type): private_name = '_' + name @property def prop(self): return getattr(self, private_name) @prop.setter def prop(self, value): if not isinstance(value, expected_type): raise TypeError(f'Expected {expected_type}') setattr(self, private_name, value) return prop 이제 다음과 같은 클래스를 정의해 보자. from typedproperty import typedproperty class Stock: name = typedproperty('name', str) shares = typedproperty('shares', int) price = typedproperty('price', float) def __init__(self, name, shares, price): self.name = name self.shares = shares self.price = price 인스턴스를 생성해 타입 검사가 잘 되는지 확인해 보자. >>> s = Stock('IBM', 50, 91.1) >>> s.name 'IBM' >>> s.shares = '100' ... TypeError가 발생한다 ... >>> 연습 문제 7.8: 함수 호출을 단순화 히기 위의 예에서 typedproperty('shares', int)와 같이 타이핑하여 호출하기가 귀찮았을 것이다. 반복적으로 하려면 더 불편하다. typedproperty.py 파일에 다음과 같은 정의를 추가하자. String = lambda name: typedproperty(name, str) Integer = lambda name: typedproperty(name, int) Float = lambda name: typedproperty(name, float) 이제 이 함수들을 사용하도록 Stock 클래스를 재작성한다. class Stock: name = String('name') shares = Integer('shares') price = Float('price') def __init__(self, name, shares, price): self.name = name self.shares = shares self.price = price 아, 좀 더 낫다. 이와 같이 클로저와 lambda를 사용해 코드를 단순화하고 거슬리는 반복을 제거할 수 있다. 이렇게 하는 쪽이 좋을 때가 많다. 연습 문제 7.9: 실전에 응용 stock.py의 Stock 클래스를 재작성해, 타입 있는 프로퍼티를 사용하게 하라. 7.4 함수 데코레이터 이 섹션은 데코레이터의 개념을 소개한다. 이것은 고급 주제이므로 이 코스에서는 겉핥기로 다룬다. 로깅 예제 다음 함수를 생각해 보자. def add(x, y): return x + y 이 함수에 로깅을 추가해 보자. def add(x, y): print('Calling add') return x + y 이제 두 번째 함수에도 로깅을 추가한다. def sub(x, y): print('Calling sub') return x - y 관찰 관찰: 코드가 반복된다. 같은 코드를 복사해서 프로그램을 작성하는 것은 성가신 일이다. 작성하기도 번거롭고 유지 보수도 힘들다. 특히 작동을 변경하고 싶을 때 문제가 된다(예: 로깅 작동을 바꾸기). 로깅을 만드는 코드 함수에 로깅을 추가해 주는 함수를 만들 수 있을 것이다. 래퍼(wrapper) 말이다. def logged(func): def wrapper(*args, **kwargs): print('Calling', func.__name__) return func(*args, **kwargs) return wrapper 이제 사용해 보자. def add(x, y): return x + y logged_add = logged(add) logged가 반환한 함수를 호출할 때 무슨 일이 일어나는가? logged_add(3, 4) # 로깅 메시지가 나타난다 이 예는 래퍼 함수(wrapper function)를 생성하는 과정을 보여준다. 래퍼는 다른 함수를 감싸는 함수다. 약간의 처리를 추가하지만, 그 외에는 원래 함수와 똑같이 작동한다. >>> logged_add(3, 4) Calling add # 부가적인 출력이 래퍼에 의해 추가됨 >>> 참고: logged() 함수는 래퍼를 생성해, 그것을 결과로 반환한다. 데코레이터 파이썬에서는 함수 주변에 래퍼를 두는 일이 매우 흔하다. 그래서 아예 전용 구문이 있다. def add(x, y): return x + y add = logged(add) # 특수한 구문 @logged def add(x, y): return x + y 이러한 특수 구문은 앞에서 했던 것과 똑같은 일을 한다. 데코레이터는 새로운 구문이다. 이를 가리켜 함수를 데코 레이트 한다고(decorate) 한다. 부연 설명 여기서는 간단히 시연했지만, 데코레이터와 관련해 미묘한 세부사항이 많다. 클래스에서 데코레이터를 사용하는 경우를 예로 들 수 있다. 또는 함수에 데코레이터를 여러 개 붙이는 경우를 생각해 볼 수 있다. 그렇기는 해도, 앞의 예는 데코레이터를 어떻게 사용하는지 잘 나타낸다. 광범위한 함수 정의에 반복적으로 나타나는 코드에 대응하는 것이 일반적인 용도다. 데코레이터를 이용하면 그러한 코드를 한곳에 모아둘 수 있다. 연습 문제 연습 문제 7.10: 타이밍을 위해 데코레이터 사용하기 어떤 함수를 정의하면, 그 이름과 모듈이 __name__과 __module__ 어 트리뷰트에 저장된다. 예: >>> def add(x, y): return x+y >>> add.__name__ 'add' >>> add.__module__ '__main__' >>> timethis.py 파일에서, 함수를 수행하는 데 얼마나 걸리는지 프린트하는 추가적인 논리 계층으로 감싸는 데코레이터 함수 timethis(func)를 작성하자. 이를 위해 다음과 같은 타이밍 호출로 함수를 감싼다. start = time.time() r = func(*args,**kwargs) end = time.time() print('%s.%s: %f' % (func.__module__, func.__name__, end-start)) 데코레이터가 다음과 같이 작동하게 하라. >>> from timethis import timethis >>> @timethis def countdown(n): while n > 0: n -= 1 >>> countdown(10000000) __main__.countdown : 0.076562 >>> 논의: 이 @timethis 데코레이터는 어느 함수 정의의 앞에든지 올 수 있다. 따라서, 데코레이터를 성능 튜닝을 위한 진단 도구로 사용할 수 있다. 7.5 데코 레이트 된 메서드 이 섹션은 메서드 정의와 함께 사용할 수 있는 빌트인 데코레이터 몇 가지를 논의한다. 미리 정의된 데코레이터 클래스 정의에 특수한 메서드 유형을 지정하는 데 사용할 수 있는 데코레이터가 미리 정의돼있다 class Foo: def bar(self, a): ... @staticmethod def spam(a): ... @classmethod def grok(cls, a): ... @property def name(self): ... 하나씩 살펴보자. 정적 메서드 @staticmethod는 정적(static) 클래스 메서드(C++/Java에서 유래)를 정의하는 데 사용한다. 정적 메서드는 클래스에 속한 함수이지만 인스턴스에 대해 연산을 하지 않는다. class Foo(object): @staticmethod def bar(x): print('x =', x) >>> Foo.bar(2) x=2 >>> 클래스를 위한 내부 지원 코드를 구현하는 데 정적 메서드를 종종 사용한다. 생성한 인스턴스를 관리하는 코드를 예로 들 수 있다(메모리 관리, 시스템 자원, 지속성, 잠금 등). 특정 설계 패턴에서도 사용한다(여기서는 다루지 않는다). 클래스 메서드 @classmethod는 클래스 메서드를 정의하는 데 사용한다. 클래스 메서드는 인스턴스 대신 class 객체를 첫 번째 매개변수로 받는다. class Foo: def bar(self): print(self) @classmethod def spam(cls): print(cls) >>> f = Foo() >>> f.bar() <__main__.Foo object at 0x971690> # 인스턴스 `f` >>> Foo.spam() <class '__main__.Foo'> # `Foo` 클래스 >>> 생성자(constructor)의 대안으로 클래스 메서드를 종종 사용한다. class Date: def __init__(self, year, month, day): self.year = year self.month = month self.day = day @classmethod def today(cls): # 클래스가 어떻게 인자로 전달되는지 보라 tm = time.localtime() # 새 인스턴스를 생성하는 데 사용됨 return cls(tm.tm_year, tm.tm_mon, tm.tm_mday) d = Date.today() 클래스 메서드는 상속과 같이 까다로운 문제를 해결한다. class Date: ... @classmethod def today(cls): # 올바른 클래스를 얻음(예: `NewDate`) tm = time.localtime() return cls(tm.tm_year, tm.tm_mon, tm.tm_mday) class NewDate(Date): ... d = NewDate.today() 연습 문제 연습 문제 7.11: 클래스 메서드 실습 report.py와 portfolio.py 파일에서 Portfolio 객체의 생성이 다소 애매하다. 예를 들어, report.py 프로그램에는 다음과 같은 코드가 있다. def read_portfolio(filename, **opts): ''' 주식 포트폴리오 파일을 읽어 딕셔너리의 리스트를 생성. name, shares, price를 키로 사용. ''' with open(filename) as lines: portdicts = fileparse.parse_csv(lines, select=['name','shares','price'], types=[str, int, float], **opts) portfolio = [ Stock(**d) for d in portdicts ] return Portfolio(portfolio) 그리고 portfolio.py 파일은 Portfolio()를 정의하는데, 초기화가 약간 이상하다. class Portfolio: def __init__(self, holdings): self.holdings = holdings ... 솔직히 코드가 여기저기 흩어져 있어 책임 관계가 헷갈린다. Portfolio 클래스에 Stock 인스턴스의 리스트를 둘 것이라면, 클래스를 좀 더 명확하게 바꾸는 것이 좋겠다. 이렇게 말이다. # portfolio.py import stock class Portfolio: def __init__(self): self.holdings = [] def append(self, holding): if not isinstance(holding, stock.Stock): raise TypeError('Expected a Stock instance') self.holdings.append(holding) ... CSV 파일에서 포트폴리오를 읽고 싶다면, 그것을 위한 클래스 메서드를 만들어야 할 것이다. # portfolio.py import fileparse import stock class Portfolio: def __init__(self): self.holdings = [] def append(self, holding): if not isinstance(holding, stock.Stock): raise TypeError('Expected a Stock instance') self.holdings.append(holding) @classmethod def from_csv(cls, lines, **opts): self = cls() portdicts = fileparse.parse_csv(lines, select=['name','shares','price'], types=[str, int, float], **opts) for d in portdicts: self.append(stock.Stock(**d)) return self 이 새로운 포트폴리오 클래스를 사용하기 위해, 이제 다음과 같은 코드를 작성할 수 있다. >>> from portfolio import Portfolio >>> with open('Data/portfolio.csv') as lines: ... port = Portfolio.from_csv(lines) ... >>> Portfolio 클래스에 이러한 변경을 반영하고 클래스 메서드를 사용하게 report.py 코드를 수정하라. 8. 테스팅과 디버깅 이 절은 테스팅, 로깅, 디버깅과 관련한 새로운 기초 주제를 소개한다. 8.1 테스팅 8.2 로깅, 오류 처리 및 진단 8.3 디버깅 8.1 테스팅 디버깅보다 테스팅 파이썬은 동적 특성으로 인해 애플리케이션 대부분에 있어 테스팅이 매우 중요하다. 컴파일러로는 버그를 찾을 수 없다. 버그를 찾는 유일한 방법은 코드를 실행해 모든 기능을 점검하는 것이다. assert 문 assert 문은 프로그램의 내부 점검이다. 표현식이 참이 아니면 AssertionError 예외가 발생한다. assert 문의 구문은 다음과 같다. assert <표현식> [, '진단 메시지'] 예: assert isinstance(10, int), 'Expected int' 사용자 입력(예: 웹 양식 같은 것을 통해 입력한 데이터)을 검사하는 데 assert를 사용하면 안 된다. 내부적인 점검과 불변 조건(항상 참인 조건)을 검사하는 것이 목적이다. 계약 프로그래밍(Contract Programming) assert를 아낌없이 활용하는 소프트웨어 설계 접근법으로, 계약에 의한 설계(Design By Contract)라고도 한다. 소프트웨어 설계자가 소프트웨어 구성요소의 정확한 인터페이스 사양을 정의해야 한다고 규정한다. 예를 들어, 함수의 모든 입력에 assert를 넣을 수 있다. def add(x, y): assert isinstance(x, int), 'Expected int' assert isinstance(y, int), 'Expected int' return x + y 입력값 검사는 적절한 인자를 사용하지 않은 호출자를 즉시 잡아낸다. >>> add(2, 3) >>> add('2', '3') Traceback (most recent call last): ... AssertionError: Expected int >>> 인라인 테스트 assert를 가지고 단순한 테스트를 할 수도 있다. def add(x, y): return x + y assert add(2,2) == 4 이런 식으로 테스트 코드를 같은 모듈에 포함한다. 장점: 코드가 명백히 망가진 경우 임포트 시도 자체가 실패한다. 테스트를 제대로 하려면 이 방식만으로는 부족하다. 이것은 심각한 오류를 찾아내는 기본 점검(smoke test)에 불과하다. 이 함수는 모든 예제에서 작동하는가? 그렇지 않다면 뭔가 잘못된 것이 분명하다. unittest 모듈 다음과 같은 코드가 있다고 하자. # simple.py def add(x, y): return x + y 이제 이것을 테스트한다고 하자. 다음과 같이 테스트 파일을 따로 생성한다. # test_simple.py import simple import unittest 그런 다음, 테스트 클래스를 정의한다. # test_simple.py import simple import unittest # unittest.TestCase로부터 상속함에 유의 class TestAdd(unittest.TestCase): ... 테스트 클래스는 반드시 unittest.TestCase로부터 상속해야 한다. 테스트 클래스에 테스트 메서드를 정의한다. # test_simple.py import simple import unittest # unittest.TestCase로부터 상속함에 유의 class TestAdd(unittest.TestCase): def test_simple(self): # 단순한 정수 인자를 가지고 테스트 r = simple.add(2, 2) self.assertEqual(r, 5) def test_str(self): # 문자열을 가지고 테스트 r = simple.add('hello', 'world') self.assertEqual(r, 'helloworld') *중요: 메서드 이름이 test로 시작해야 한다. unittest 사용하기 unittest 모듈에 몇 가지 검사 함수가 기본으로 들어있다. 그것들은 각기 다른 일을 한다. # 표현이 참인지 검사 self.assertTrue(표현) # x == y를 검사 self.assertEqual(x, y) # x != y를 검사 self.assertNotEqual(x, y) # x와 y가 비슷한지 검사 self.assertAlmostEqual(x, y, 자릿수) # callable(인자 1, 인자 2, ...)이 예외를 일으키는지 검사 self.assertRaises(예외, callable, 인자 1, 인자 2, ...) 이것이 다가 아니다. 모듈에 다른 검사가 더 있다. unittest 실행하기 테스트를 실행하기 위해 코드를 스크립트로 바꾸자. # test_simple.py ... if __name__ == '__main__': unittest.main() 그다음에 파이썬으로 테스트 파일을 실행한다. bash % python3 test_simple.py F. ======================================================== FAIL: test_simple (__main__.TestAdd) -------------------------------------------------------- Traceback (most recent call last): File "testsimple.py", line 8, in test_simple self.assertEqual(r, 5) AssertionError: 4 != 5 -------------------------------------------------------- Ran 2 tests in 0.000s FAILED (failures=1) 부연 설명 효과적인 테스팅은 예술에 가까우며, 대규모 애플리케이션에서는 꽤 복잡해질 수 있다. unittest 모듈은 테스트 실행과 결과 수집 등 테스팅의 여러 측면에 유용한 옵션이 아주 많다. 자세한 사항은 문서를 참조하라. 서드 파티 테스트 도구 unittest 모듈은 파이썬에 빌트인 되어 있으므로 어디서나 사용할 수 있다는 장점이 있다. 그렇지만, 너무 장황하다고 생각하는 프로그래머가 많다. unittest 대신 pytest도 많이 사용된다. pytest를 사용하면 테스팅 파일이 다음과 같이 단순해진다. # test_simple.py import simple def test_simple(): assert simple.add(2,2) == 4 def test_str(): assert simple.add('hello','world') == 'helloworld' 테스트를 실행하려면 명령행에서 python -m pytest와 같이 타이핑하면 된다. 모든 테스트를 찾아서 실행해 준다. pytest 예제가 많이 있지만 여기서는 다루지 않는다. 사용하기 쉬우므로 한번 시도해 보라. 연습 문제 이 연습 문제에서는 파이썬 unittest 모듈의 기본 작동 원리를 탐구한다. 앞의 연습 문제에서 Stock 클래스가 있는 stock.py를 작성했다. 이 연습 문제는 타입 있는 프로퍼티와 관련된 연습 문제 7.9를 풀었다고 가정한다. 만약 어떤 이유로든 작동하지 않는다면 Solutions/7_9의 해답 코드를 복사해서 사용해도 된다. 연습 문제 8.1: 유닛 테스트 작성하기 Stock 클래스에 대한 단위 테스트를 test_stock.py 파일에 따로 작성한다. 인스턴스 생성을 검사하는 코드는 다음과 같다. # test_stock.py import unittest import stock class TestStock(unittest.TestCase): def test_create(self): s = stock.Stock('GOOG', 100, 490.1) self.assertEqual(s.name, 'GOOG') self.assertEqual(s.shares, 100) self.assertEqual(s.price, 490.1) if __name__ == '__main__': unittest.main() 단위 테스트를 실행하자. 다음과 같이 출력된다. ---------------------------------------------------------------------- Ran 1 tests in 0.000s OK 이것이 잘 작동하면, 다음 사항을 점검하는 단위 테스트를 추가로 작성한다. s.cost 프로퍼티가 올바른 값 (49010.0)을 반환하는지 확인한다. s.sell() 메서드가 올바로 작동하는지 확인한다. s.shares 값이 감소해야 한다. s.shares 어 트리뷰트에 정수가 아닌 값이 설정되지 않음을 확인한다. 끝으로, 예외가 일어나는지 확인해야 한다. 다음과 같은 코드를 가지고 하면 쉽다. class TestStock(unittest.TestCase): ... def test_bad_shares(self): s = stock.Stock('GOOG', 100, 490.1) with self.assertRaises(TypeError): s.shares = '100' 8.2 로깅 이 섹션에서는 logging 모듈을 간단히 소개한다. logging 모듈 logging 모듈은 진단 정보를 기록하기 위한 표준 라이브러리 모듈이다. 정교한 기능이 많은, 매우 큰 모듈이기도 하다. 유용한 몇 가지 예를 살펴보자. 예외 되돌아보기 연습 문제에서 다음과 같은 parse() 함수를 작성했다. # fileparse.py def parse(f, types=None, names=None, delimiter=None): records = [] for line in f: line = line.strip() if not line: continue try: records.append(split(line, types, names, delimiter)) except ValueError as e: print("Couldn't parse :", line) print("Reason :", e) return records try-except 문에 집중하자. except 블록에서 무슨 일을 해야 할까? 경고 메시지를 출력해야 하나? try: records.append(split(line, types, names, delimiter)) except ValueError as e: print("Couldn't parse :", line) print("Reason :", e) 아니면 조용히 무시해야 하나? try: records.append(split(line, types, names, delimiter)) except ValueError as e: pass 두 가지 행위를 모두 원할 수 있으므로(사용자가 선택) 어느 해결책도 만족스럽지 않을 것이다. logging 모듈 사용하기 logging 모듈을 사용해 해결할 수 있다. # fileparse.py import logging log = logging.getLogger(__name__) def parse(f, types=None, names=None, delimiter=None): ... try: records.append(split(line, types, names, delimiter)) except ValueError as e: log.warning("Couldn't parse : %s", line) log.debug("Reason : %s", e) 경고 메시지 또는 특수한 Logger 객체를 발행하도록 코드를 수정한다. logging.getLogger(__name__)으로 생성한 것이다. 로깅 기초 로 거 객체를 생성한다. log = logging.getLogger(name) # name은 문자열이다 로그 메시지를 발행한다. log.critical(message [, args]) log.error(message [, args]) log.warning(message [, args]) log.info(message [, args]) log.debug(message [, args]) 각 메시지는 심각도(severity) 수준이 각기 다르다. 이것들은 모두 포매팅된 로그 메시지를 생성한다. 메시지를 생성하기 위해 args를 % 연산자와 함께 사용한다. logmsg = message % args # 로그에 기록됨 로깅 설정 로깅 작동을 각각 설정할 수 있다. # main.py ... if __name__ == '__main__': import logging logging.basicConfig( filename = 'app.log', # Log output file level = logging.INFO, # Output level ) 일반적으로, 프로그램이 시작할 때 한 번만 설정한다. 설정은 logging을 호출하는 코드와 분리된다. 부연 설명 로깅은 설정할 수 있는 폭이 넓다. 출력 파일, 수준, 메시지 포맷 등 모든 것을 설정할 수 있다. 그렇지만, logging을 사용하는 코드는 그런 것에 신경 쓰지 않아도 된다. 연습 문제 연습 문제 8.2: 모듈에 logging 추가하기 fileparse.py에는 잘못된 입력에 의해 발생하는 예외와 관련해 몇 가지 오류 처리가 있다. 다음과 같다. # fileparse.py import csv def parse_csv(lines, select=None, types=None, has_headers=True, delimiter=',', silence_errors=False): ''' CSV 파일을 파싱 및 형 변환하여 레코드의 리스트를 생성. ''' if select and not has_headers: raise RuntimeError('select requires column headers') rows = csv.reader(lines, delimiter=delimiter) # 파일 헤더가 있으면 읽음 headers = next(rows) if has_headers else [] # 특정 칼럼을 선택한 경우, 필터링을 위한 인덱스를 만들고 출력 칼럼을 설정 if select: indices = [ headers.index(colname) for colname in select ] headers = select records = [] for rowno, row in enumerate(rows, 1): if not row: # 데이터가 없는 행을 건너뜀 continue # 특정 칼럼 인덱스가 선택되었으면 그것을 고름 if select: row = [ row[index] for index in indices] # 행에 형 변환을 적용 if types: try: row = [func(val) for func, val in zip(types, row)] except ValueError as e: if not silence_errors: print(f"Row {rowno}: Couldn't convert {row}") print(f"Row {rowno}: Reason {e}") continue # 튜플의 딕셔너리를 만듦 if headers: record = dict(zip(headers, row)) else: record = tuple(row) records.append(record) return records 진단 메시지를 발행하는 print 문에 유의하라. 이 print를 logging 오퍼레이션으로 교체하는 것은 간단한 편이다. 코드를 다음과 같이 바꾸자. # fileparse.py import csv import logging log = logging.getLogger(__name__) def parse_csv(lines, select=None, types=None, has_headers=True, delimiter=',', silence_errors=False): ''' CSV 파일을 파싱 및 형 변환하여 레코드의 리스트를 생성. ''' if select and not has_headers: raise RuntimeError('select requires column headers') rows = csv.reader(lines, delimiter=delimiter) # 파일 헤더가 있으면 읽음 headers = next(rows) if has_headers else [] # 특정 칼럼을 선택한 경우, 필터링을 위한 인덱스를 만들고 출력 칼럼을 설정 if select: indices = [ headers.index(colname) for colname in select ] headers = select records = [] for rowno, row in enumerate(rows, 1): if not row: # 데이터가 없는 행을 건너뜀 continue # 특정 칼럼 인덱스가 선택되었으면 그것을 고름 if select: row = [ row[index] for index in indices] # 행에 형 변환을 적용 if types: try: row = [func(val) for func, val in zip(types, row)] except ValueError as e: if not silence_errors: log.warning("Row %d: Couldn't convert %s", rowno, row) log.debug("Row %d: Reason %s", rowno, e) continue # 튜플의 딕셔너리를 만듦 if headers: record = dict(zip(headers, row)) else: record = tuple(row) records.append(record) return records 이렇게 변경했으므로, 잘못된 데이터를 입력해 보자. >>> import report >>> a = report.read_portfolio('Data/missing.csv') Row 4: Bad row: ['MSFT', '', '51.23'] Row 7: Bad row: ['IBM', '', '70.44'] >>> 기본값으로는 경고(WARNING) 수준 이상의 로깅 메시지만 출력된다. 출력은 단순한 print 문처럼 보인다. 그렇지만 logging 모듈을 설정하는 경우 로깅 수준, 모듈 등의 추가적인 정보가 제공된다. 다음과 같이 타이핑하여 확인해 보자. >>> import logging >>> logging.basicConfig() >>> a = report.read_portfolio('Data/missing.csv') WARNING:fileparse:Row 4: Bad row: ['MSFT', '', '51.23'] WARNING:fileparse:Row 7: Bad row: ['IBM', '', '70.44'] >>> log.debug()의 출력은 나타나지 않는다. 디버그(DEBUG) 메시지도 나타나도록 수준을 변경해 보자. >>> logging.getLogger('fileparse').level = logging.DEBUG >>> a = report.read_portfolio('Data/missing.csv') WARNING:fileparse:Row 4: Bad row: ['MSFT', '', '51.23'] DEBUG:fileparse:Row 4: Reason: invalid literal for int() with base 10: '' WARNING:fileparse:Row 7: Bad row: ['IBM', '', '70.44'] DEBUG:fileparse:Row 7: Reason: invalid literal for int() with base 10: '' >>> 심각(CRITICAL) 메시지만 나타나게 해 보자. >>> logging.getLogger('fileparse').level=logging.CRITICAL >>> a = report.read_portfolio('Data/missing.csv') >>> 연습 문제 8.3: 프로그램에 로깅을 추가하기 애플리케이션에 로깅을 추가하려면 메인 모듈에서 로깅 모듈을 초기화하는 메커니즘이 필요하다. 다음과 같은 셋업 코드를 포함하는 방식으로 할 수 있다. # 이 파일은 logging 모듈의 기본 구성을 설정한다. # 이 설정을 변경함으로써 로깅 출력을 원하는 대로 조정할 수 있다. import logging logging.basicConfig( filename = 'app.log', # 로그 파일의 이름(생략하면 stderr을 사용) filemode = 'w', # 파일 모드('a': 추가) # 로깅 수준(DEBUG, INFO, WARNING, ERROR, CRITICAL) level = logging.WARNING, ) 당신의 프로그램의 시작 단계에 이것을 두어야 한다. 예를 들어, report.py 프로그램의 어디에 두어야 할까? 8.3 디버깅 프로그램이 충돌했다... bash % python3 blah.py Traceback (most recent call last): File "blah.py", line 13, in ? foo() File "blah.py", line 10, in foo bar() File "blah.py", line 7, in bar spam() File "blah.py", 4, in spam line x.append(3) AttributeError: 'int' object has no attribute 'append' 어떡하지?! 트레이스 백 읽기 마지막 행이 문제를 일으킨 주범이다. bash % python3 blah.py Traceback (most recent call last): File "blah.py", line 13, in ? foo() File "blah.py", line 10, in foo bar() File "blah.py", line 7, in bar spam() File "blah.py", 4, in spam line x.append(3) # 충돌 원인 AttributeError: 'int' object has no attribute 'append' 그렇지만 읽고 이해하기가 쉽지만은 않다. 전문가의 조언: 트레이스 백 전체를 구글에 붙여 넣어 검색하라. REPL 사용하기 -i 옵션을 사용해 스크립트를 사용할 때 파이썬이 살아있도록 한다. bash % python3 -i blah.py Traceback (most recent call last): File "blah.py", line 13, in ? foo() File "blah.py", line 10, in foo bar() File "blah.py", line 7, in bar spam() File "blah.py", 4, in spam line x.append(3) AttributeError: 'int' object has no attribute 'append' >>> 이것은 인터프리터 상태를<NAME>다. 충돌 이후에 여기저기 찔러볼 수 있다. 변숫값과 기타 상태를 확인한다. 프린트를 사용한 디버깅 print() 디버깅은 꽤 일반적이다. 조언: repr()을 사용하라. def spam(x): print('DEBUG:', repr(x)) ... repr() 은 값의 정확한 표현(representation)을 나타낸다. 출력을 예쁘게 프린트하는 것과는 다르다. >>> from decimal import Decimal >>> x = Decimal('3.4') # `repr` 없이 >>> print(x) 3.4 # `repr` 사용 >>> print(repr(x)) Decimal('3.4') >>> 파이썬 디버거 이 프로그램에서 디버거를 수작업으로 실행할 수 있다. def some_function(): ... breakpoint() # 디버거 진입(파이썬 3.7 이상) ... 이것은 breakpoint() 호출에서 디버거를 시작한다. 이전 버전에서는 방법이 약간 다르다. 다른 디버깅 안내서에서 다음과 같이 설명하는 것을 볼 수 있을 것이다. import pdb ... pdb.set_trace() # `breakpoint()` 대신 이것을 사용하라 ... 디버거에서 실행하기 전체 프로그램을 디버거에서 실행할 수도 있다. bash % python3 -m pdb someprogram.py 이렇게 하면 첫 번째 문장 이전에 디버거에 자동으로 진입한다. 중단점(breakpoint)을 설정하고 구성을 바꿔볼 수 있다. 일반적인 디버거 명령: (Pdb) help # 도움말 (Pdb) w(here) # 스택 트레이스(stack trace)를 프린트 (Pdb) d(own) # 한 스택 수준 아래로 이동 (Pdb) u(p) # 한 스택 수준 위로 이동 (Pdb) b(reak) loc # 중단점 설정 (Pdb) s(tep) # 한 인스트럭션(instruction)을 실행 (Pdb) c(ontinue) # 계속 실행 (Pdb) l(ist) # 소스 코드 보기 (Pdb) a(rgs) # 현재 함수의 인자를 프린트 (Pdb) !statement # 문장(statement)을 실행 중단점 위치는 다음 중 하나다. (Pdb) b 45 # 현재 파일의 45행 (Pdb) b file.py:34 # file.py의 34행 (Pdb) b foo # 현재 파일의 foo() 함수 (Pdb) b module.foo # module의 foo() 연습 문제 연습 문제 8.4: 버그? 무슨 버그? 작동한다. 출시해라! 9. 패키지 이 과정의 마지막 섹션은 코드를 패키지 구조로 조직화하는 방법에 대한 몇 가지 세부 사항을 알아본다. 서드 파티 패키지를 설치하는 방법과 여러분이 작성한 코드를 다른 사람들을 위해 제공하는 방법도 논의한다. 패키징은 계속 진화하며, 파이썬 개발에 있어 너무 복잡한 주제다. 특정 도구에 초점을 맞추기보다는, 코드를 제공하거나 의존성을 관리함에 있어 어떤 도구를 사용하더라도 적용할 수 있는 일반적인 코드 조직화 원칙에 집중한다. 9.1 패키지 9.2 서드 파티 모듈 9.3 코드를 다른 사람에게 주기 9.1 패키지 더 큰 프로그램을 작성한다면, 독립적인 파일의 거대한 모음을 최상위 수준에서 조직화하는 것은 바람직하지 않다. 이 섹션은 패키지의 개념을 소개한다. 모듈(Module) 모든 파이썬 소스 파일은 모듈이다. # foo.py def grok(a): ... def spam(b): ... import 문은 모듈을 적재하고 실행한다. # program.py import foo a = foo.grok(2) b = foo.spam('Hello') ... 패키지 vs 모듈 더 큰 코드 모음에서는 모듈을 패키지로 조직화하는 것이 일반적이다. # 이것을 pcost.py report.py fileparse.py # 이렇게 porty/ __init__.py pcost.py report.py fileparse.py 적당한 이름을 골라 최상위 디렉터리를 만들어라. 위의 예에서는 porty로 정했다(이름을 잘 고르는 것이 가장 중요한 첫걸음이다). __init__.py 파일을 디렉터리에 추가한다. 디렉터리가 비어 있을 것이다. 소스 파일을 디렉터리에 넣어라. 패키지 사용하기 패키지는 임포트를 위한 네임스페이스 역할을 한다. 즉, 여러 수준의 임포트가 존재한다. import porty.report port = porty.report.read_portfolio('port.csv') import 문에는 여러 변형이 있다. from porty import report port = report.read_portfolio('portfolio.csv') from porty.report import read_portfolio port = read_portfolio('portfolio.csv') 두 가지 문제점 이러한 접근은 두 가지 문제가 있다. 같은 패키지에서 여러 파일을 임포트 하면 문제가 생긴다. 패키지에 있는 메인 스크립트가 깨진다. 따라서 모든 것이 깨진다. 그렇지만 그 외에는 작동한다. 문제: 임포트 같은 패키지에서 파일들을 임포트 하려면 임포트에 패키지 이름을 포함해야 한다. 구조를 기억하자. porty/ __init__.py pcost.py report.py fileparse.py 수정한 임포트 예. # report.py from porty import fileparse def read_portfolio(filename): return fileparse.parse_csv(...) 모든 임포트는 상대가 아닌 절대 임포트다. # report.py import fileparse # 깨진다. fileparse을 찾지 못한다. ... 상대 임포트 패키지 이름을 직접 사용하는 대신, 현재 패키지를.로 가리킬 수 있다. # report.py from . import fileparse def read_portfolio(filename): return fileparse.parse_csv(...) 구문: from . import modname 이렇게 하면 패키지 이름을 바꾸기 쉽다. 문제점: 메인 스크립트 패키지 서브 모듈을 메인 스크립트로서 실행하면 깨진다. bash $ python porty/pcost.py # 깨짐 ... 이유: 파이썬을 단일 파일에서 실행하는데, 파이썬은 나머지 패키지 구조를 올바로 볼 수 없기 때문이다(sys.path가 잘못됨). 모든 임포트가 깨진다. 이것을 해결하려면 프로그램을 실행할 때 -m 옵션을 사용한다. bash $ python -m porty.pcost # 작동함 ... __init__.py 파일 이 파일의 주목적은 여러 모듈을 한데 모으는 것이다. 예: 함수들을 결속시키기 # porty/__init__.py from .pcost import portfolio_cost from .report import portfolio_report 이렇게 하면 임포트 할 때 이름이 최상위 수준에 나타난다. from porty import portfolio_cost portfolio_cost('portfolio.csv') 다중 수준 임포트를 사용하는 대신. from porty import pcost pcost.portfolio_cost('portfolio.csv') 스크립트를 위한 설루션 이제 패키지에서 스크립트를 실행하려면 -m package.module을 사용해야 한다. bash % python3 -m porty.pcost portfolio.csv 또 다른 방법도 있다. 새로운 최상위 수준 스크립트를 작성하는 것이다. #!/usr/bin/env python3 # pcost.py import porty.pcost import sys porty.pcost.main(sys.argv) 이 스크립트는 패키지 바깥에 있다. 예를 들어, 디렉터리 구조를 보자. pcost.py # 최상위 수준 스크립트 porty/ # 패키지 디렉터리 __init__.py pcost.py ... 애플리케이션 구조 코드와 파일의 구조화는 애플리케이션 유지 보수성의 핵심이다. 파이썬에서 모든 문제에 맞는 단 한 가지 방식이 있지는 않다. 그렇지만 다음과 같은 구조는 여러 가지 문제에 적합하다. porty-app/ README.txt script.py # SCRIPT porty/ # 라이브러리 코드 __init__.py pcost.py report.py fileparse.py 최상위 수준의 porty-app은 문서, 최상위 수준 스크립트, 예제 등 모든 것을 담는다. 재차 말하지만, 최상위 수준 스크립트는 코드 패키지 외부에 두어야 한다. 한 단계 높이자. #!/usr/bin/env python3 # porty-app/script.py import sys import porty porty.report.main(sys.argv) 연습 문제 이제 디렉터리에는 프로그램 여러 개가 있다. pcost.py # 포트폴리오 비용 계산 report.py # 보고서 작성 ticker.py # 실시간 주식 시세 생성 그 외의 기능을 지원하는 모듈도 여러 개 있다. stock.py # Stock 클래스 portfolio.py # Portfolio 클래스 fileparse.py # CSV 파싱 tableformat.py # 표 작성 follow.py # 로그 파일 추적 typedproperty.py # 타입 있는 클래스 프로퍼티 연습 문제에서는 코드를 정리해 공통 패키지에 넣는다. 연습 문제 9.1: 단순한 패키지 만들기 porty/라는 디렉터리를 만들고 위의 파이썬 파일들을 모두 집어넣어라. 그 디렉터리에 빈 __init__.py 파일도 만들어라. 디렉터리에 다음과 같이 파일이 있어야 한다. porty/ __init__.py fileparse.py follow.py pcost.py portfolio.py report.py stock.py tableformat.py ticker.py typedproperty.py 디렉터리에 있는 __pycache__는 삭제한다. 앞서 프리 컴파일한 파이썬 모듈이 들어 있다.<NAME>고 새로 시작하자. 패키지 모듈을 임포트 해보자. >>> import porty.report >>> import porty.pcost >>> import porty.ticker 임포트에 실패한다면 해당 파일의 모듈 임포트에 패키지 상대 임포트를 포함하게 수정한다. 예를 들어, import fileparse는 다음과 같이 바꾼다. # report.py from . import fileparse ... from fileparse import parse_csv 같은 문장이 보이면, 다음과 같이 변경한다. # report.py from .fileparse import parse_csv ... 연습 문제 9.2: 애플리케이션 디렉터리 만들기 코드를 모두 '패키지'에 넣기만 한다고 애플리케이션이 되는 것은 아니다. 지원 파일, 문서, 스크립트, 그 외의 것들이 필요하다. 이러한 파일들은 위에서 만든 porty/ 디렉터리의 바깥에 있어야 한다. porty-app이라는 디렉터리를 새로 만들자. 연습 문제 9.1에서 생성한 porty 디렉터리를 그 디렉터리로 옮긴다. Data/portfolio.csv와 Data/prices.csv 테스트 파일을 이 디렉터리로 복사한다. 당신에 대한 정보를 담은 README.txt 파일도 추가로 작성한다. 이제 코드가 다음과 같이 되어 있을 것이다. porty-app/ portfolio.csv prices.csv README.txt porty/ __init__.py fileparse.py follow.py pcost.py portfolio.py report.py stock.py tableformat.py ticker.py typedproperty.py 코드를 실행하려면 최상위 porty-app/ 디렉터리에서 작업해야 한다. 터미널에서 다음과 같이 실행한다. shell % cd porty-app shell % python3 >>> import porty.report >>> 앞에서 만든 스크립트들을 메인 프로그램으로서 실행해 보자. shell % cd porty-app shell % python3 -m porty.report portfolio.csv prices.csv txt Name Shares Price Change ---------- ---------- ---------- ---------- AA 100 9.22 -22.98 IBM 50 106.28 15.18 CAT 150 35.46 -47.98 MSFT 200 20.89 -30.34 GE 95 13.48 -26.89 MSFT 50 20.89 -44.21 IBM 100 106.28 35.84 shell % 연습 문제 9.3: 최상위 스크립트 python -m 명령을 사용하는 것은 좀 이상할 때가 있다. 패키지의 특성을 다루는 최상위 수준 스크립트를 작성하는 것이 좋다. 위의 보고서를 생성하는 print-report.py 스크립트를 작성한다. #!/usr/bin/env python3 # print-report.py import sys from porty.report import main main(sys.argv) 이 스크립트를 최상위 수준의 porty-app/ 디렉터리에 넣는다. 해당 위치에서 실행해야 한다. shell % cd porty-app shell % python3 print-report.py portfolio.csv prices.csv txt Name Shares Price Change ---------- ---------- ---------- ---------- AA 100 9.22 -22.98 IBM 50 106.28 15.18 CAT 150 35.46 -47.98 MSFT 200 20.89 -30.34 GE 95 13.48 -26.89 MSFT 50 20.89 -44.21 IBM 100 106.28 35.84 shell % 최종 코드는 다음과 같은 구조가 된다. porty-app/ portfolio.csv prices.csv print-report.py README.txt porty/ __init__.py fileparse.py follow.py pcost.py portfolio.py report.py stock.py tableformat.py ticker.py typedproperty.py 9.2 서드 파티 모듈 파이썬에는 빌트인 모듈의 방대한 라이브러리가 있다(전자제품에 배터리를 끼워 파는 것에 비유해 batteries included라고 표현한다). 게다가 서드 파티 모듈도 아주 많다. 파이썬 패키지 인덱스(PyPi: Python Package Index)를 둘러보라. 아니면 특정 주제를 구글에서 검색해도 된다. 서드 파티 의존성을 어떻게 다룰 것인지가 파이썬에서 끊임없이 진화하는 주제다. 이 섹션에서는 기본 원리를 소개하는 선에서 다룬다. 모듈 검색 경로 sys.path는 모든 디렉터리의 목록을 포함하는 디렉터리로, import 문에서 이것을 확인하다. 한번 살펴보자. >>> import sys >>> sys.path ... 결과를 살펴보라 ... >>> 만약 어떤 것을 임포트 하려고 했는데 그것을 이 디렉터리 중 어디에서도 찾을 수 없으면 ImportError 예외가 발생한다. 표준 라이브러리 모듈 파이썬의 표준 라이브러리에 속한 모듈은 보통 /usr/local/lib/python3.6과 같은 곳에 있다. 간단한 테스트를 통해 확인해 볼 수 있다. >>> import re >>> re <module 're' from '/usr/local/lib/python3.6/re.py'> >>> REPL에서 모듈을 찾아보기만 해도 디버깅에 도움이 되는 정보를 얻을 수 있다. 이것은 파일의 위치를 보여준다. 서드 파티 모듈 서드 파티 모듈은 일반적으로 전용 site-packages 디렉터리에 있다. 앞에서 한 것과 같은 방법으로 찾아볼 수 있다. >>> import numpy <module 'numpy' from '/usr/local/lib/python3.6/site-packages/numpy/__init__.py'> >>> import와 관련해 예상대로 작동하지 않는 이유를 찾으려고 할 때, 모듈을 들여다보는 것은 좋은 디버깅 방법이다. 모듈 설치하기 서드 파티 모듈을 설치하는 가장 일반적인 방법은 pip를 사용하는 것이다. 예: bash % python3 -m pip install packagename 이 명령은 패키지를 다운로드해 site-packages 디렉터리에 설치한다. 문제점 당신이 직접 제어하지 않는 파이썬을 사용 중일 수 있다. 회사 승인 설치 OS에 포함된 파이썬 버전을 사용하고 있는 경우. 당신은 컴퓨터에 글로벌 패키지를 설치할 권한이 없을 수 있다. 다른 의존성이 있을 수 있다. 가상 환경(Virtual Environment) 패키지 설치 이슈의 일반적인 해법은 자신을 위한 "가상 환경"을 생성하는 것이다. 여기에 '왕도'는 없으며, 여러 가지 도구와 기법이 경쟁한다. 하지만, 표준 파이썬 설치를 사용한다면 다음의 방법을 시도할 수 있다. bash % python -m venv mypython bash % 잠시 기다리면 mypython이라는 디렉터리가 새로 만들어진다. 이것을 당신만의 작은 파이썬 설치본이라고 생각할 수 있다. 그 디렉터리 안에서 bin/ 디렉터리(유닉스) 또는 Scripts/ 디렉터리(윈도)를 찾을 수 있다. 거기 있는 activate 스크립트를 실행하면, 해당 파이썬 버전이 '활성화(activate)'되어, 셸의 디폴트 python 명령이 된다. 예: bash % source mypython/bin/activate (mypython) bash % 이곳에 파이썬 패키지를 설치할 수 있다. 예: (mypython) bash % python -m pip install pandas ... 여러 패키지를 실험하고 사용해 보고 싶을 때 가상 환경을 사용하면 좋다. 한편, 개발하는 애플리케이션에 특정 패키지 의존성이 필요한 경우는 약간 다른 문제가 있다. 애플리케이션에서 서드 파티 의존성을 다루기 만약 당신이 작성한 애플리케이션이 특정 서드 파티에 의존성이 있으면, 당신의 코드와 의존성을 포함하는 환경을 생성하고 보존하는 데 어려움이 있다. 안타깝게도, 파이썬에서 이 영역은 매우 혼란스럽고 빈번한 변화가 있다. 지금도 계속 진화하고 있다. 정보를 제공하더라도 금세 구식이 되어버리므로, 파이썬 패키징 사용자 안내서(Python Packaging User Guide)를 참조하기를 권한다. 연습 문제 연습 문제 9.4 : 가상 환경에 설치 가상 환경을 만들어, 위에서 설명한 판다스 설치 과정을 재현해 보라. 9.3 배포 여러분이 작성한 코드를 동료라든지 다른 누군가에게 주고 싶을 수도 있다. 그렇게 하는 가장 기본적인 방법을 알아보자. 자세한 정보는 파이썬 패키징 사용자 안내서(Python Packaging User Guide)를 참조하라. setup.py 파일 생성 프로젝트 디렉터리 최상위에 setup.py 파일을 추가한다. # setup.py import setuptools setuptools.setup( name="porty", version="0.0.1", author="Your Name", author_email="you@example.com", description="Practical Python Code", packages=setuptools.find_packages(), ) MANIFEST.in 생성 프로젝트와 연관된 추가 파일이 있다면 MANIFEST.in 파일에 지정한다. 예: # MANIFEST.in include *.csv MANIFEST.in 파일을 setup.py와 같은 디렉터리에 둔다. 소스 배포판 생성 코드 배포판을 생성하려면 setup.py 파일을 사용한다. 예: bash % python setup.py sdist 이것은 dist/ 디렉터리에. tar.gz 또는. zip 파일을 생성한다. 그 파일을 다른 사람에게 줄 수 있다. 당신의 코드를 설치 당신이 작성한 파이썬 코드를 다른 사람들이 pip를 사용해 설치하게 할 수 있다. 이전 단계에서 생성한 파일을 제공하면 된다. 예: bash % python -m pip install porty-0.0.1.tar.gz 부연 설명 위에서 설명한 단계는 다른 사람에게 줄 수 있는 파이썬 코드의 패키지를 생성하는 최소한의 기초만 다뤘다. 현실에서는 서드 파티 의존성, 외부 코드(예: C/C++) 포함 여부 등으로 인해 훨씬 복잡하다. 그런 일들을 다루는 것은 이 코스의 범위를 벗어난다. 우리는 아주 작은 첫걸음만 디뎠다. 연습 문제 연습 문제 9.5: 패키지 만들기 연습 문제 9.3에서 만든 porty-app/ 코드를 가지고 이 섹션에서 설명한 단계를 실습해 보라. setup.py 파일과 MANIFEST.in 파일을 최상위 디렉터리에 추가하라. python setup.py sdist를 실행해 소스 배포 파일을 생성하라. 끝으로, 당신이 만든 패키지를 파이썬 가상 환경에 설치해 보라. 끝! 이 과정을 모두 마쳤다. 시간과 노력을 기울인 것에 감사한다. 앞으로의 파이썬 해킹이 더욱 재미있고 생산적이 되기를 바란다! 언제든 의견을 고맙게 받겠다. 나를 https://dabeaz.com이나 트위터 @dabeaz에서 찾을 수 있다. - David Beazley. A. Practical Python Programming - 강의 노트 저자: David Beazley 개요 이 문서는 나의 “Practical Python” 코스의 내용을 가르침에 있어 학습목표, 대상자, 주의점을 포함해 일반적인 참고 사항과 조언을 제공한다. 이 지침은 기업 트레이닝 환경의 전형적인 3일 교육 코스에서 사람들을 가르치는 사람들을 위한 것이다. 자신만의 코스를 만들어 가르치고자 하는 경우에도 이 문서가 도움이 될 것이다. 대상자 및 일반적인 접근 이 코스는 프로그래밍 경험이 있는 사람들을 위한 “파이썬 입문” 코스로 기획했다. “프로그래밍 첫걸음” 코스를 듣는 사람들을 가르치도록 설계한 것이 아니다. 필자의 경험상, 파이썬 코스를 들으러 오는 일반적인 수강생은 높은 수준의 소프트웨어 기술자 혹은 프로그래머가 아닌 경우가 많다. 기술자, 과학자, 웹 프로그래머, 경험이 적은 개발자가 뒤섞여 있을 가능성이 높다. 수강생의<NAME> 매우 다양하다. C, C++, 자바를 다뤄본 학생이 있을 수도 있고, PHP와 HTML을 알 수도 있고, MATLAB 같은 도구를 다뤄봤을 수도 있다. 선수 조건을 명확히 하려 노력했음에도 불구하고 전통적인 “프로그래밍” 경험이 전혀 없는 수강생이 있을 수도 있다. 이를 염두에 두고, 이 코스는 데이터를 조작하는 일반적인 문제(특히 주식 시장의 데이터)를 통해 파이썬을 가르친다. 이 영역을 선택한 이유는 단순하면서도 수강생의 배경에 관계없이 누구나 알기 때문이다. 예를 들어, 프로그래밍 기술이 부족한 학생도 스프레드시트(예: Excel)를 사용하는 것과 같이 일반적인 것은 알 것이다. 그러므로, 수강생이 헤매고 있을 때 “튜플은 스프레드시트의 데이터 열 같은 것”이라든지 “리스트 컴프리 헨 션(list comprehension)은 스프레드시트 칼럼에 연산을 적용한 결과를 다른 칼럼에 넣는 것”이라고 설명할 수 있다. 핵심 개념은 난해한 “컴퓨터 과학” 문제에 얽매이지 않고(예: “피보나치수열을 계산해 봅시다”) 실세계에 발붙이는 것이다. 이 문제 영역은 다른 프로그래밍 주제를 소개할 때도 효과적이다. 예를 들어, 과학자/공학자는 데이터 분석이나 플로팅에 관심이 있을 것이다. 따라서, 그들에게는 matplotlib을 사용해 플롯을 작성하는 법을 보여줘라. 웹 프로그래머는 주식 시장 데이터를 웹페이지에 표시하는 법을 알고 싶을 것이다. 그러면 템플릿 엔진을 설명하면 된다. 시스템 관리자는 로그 파일을 다루는 법을 알고 싶을 것이다. 그러면 실세계의 주식 데이터 로그 파일을 가지고 수업을 하라. 소프트웨어 기술자는 설계에 관심이 있을 것이다. 그렇다면 주식 데이터를 객체에 캡슐화하는 방법이라든지 프로그램의 확장성을 높이는 법을 설명하라(예: 이 프로그램의 출력을 열 가지 테이블 포맷으로 표현하는 법). 아이디어를 내 보라. 발표 지침 발표 슬라이드(노트)는 이야기 구조로 되어 있으며 수강생이 연습을 할 때 참고할 수 있게 제공한다. 모든 슬라이드의 모든 항목을 다루려 애쓸 필요 없다. 수강생이 읽을 수 있으며 코딩하다가 다시 볼 시간이 있을 것으로 가정한다. 나는 슬라이드를 빠르게 훑으면서 상호작용적인 짧은 예를 보여주는 편이다. 시연을 하면서 슬라이드를 통째로 건너 뛰기도 한다. 모든 슬라이드를 다루지 않아도 된다. 몇 가지만 골라 인터프리터에서 직접 시연하라. 규칙: 특별히 까다롭지 않은 한, 슬라이드 당 1분을 넘기지 마라. 솔직히 말해서, 슬라이드 대부분은 넘기고 필요하다고 생각되는 것만 라이브 데모 위주로 강의를 해도 된다 나는 종종 그렇게 한다. 코스 연습 문제 이 코스에는 약 130 개의 연습 문제가 있다. If you do every single exercise and give students time to think and code, it will likely take them about 10-12 hours. In practice, you will probably find that students require more time on certain exercises. I have some notes about this below. You should repeatedly emphasize to students that solution code is available and that it is okay to look at it and copy it--especially due to time requirements. Prior to teaching the course, I would strongly advise that you go through and work every single course exercise so that there are no surprises. During course delivery, I usually work every single exercise from scratch, without looking at the solution, on my computer while the students also work. For this, I strongly advise you to have a printed copy of the exercises on hand that you can look at without having to pull it up on the computer screen (which is being projected). Near the end of the exercise time period, I will start discussing my solution code, emphasizes different bits on the screen and talking about them. If there are any potential problems with the solution (including design considerations), I’ll also talk about it. Emphasize to students that they may want to look at/copy solution code before going forward. Section 1: Introduction The major goal of this section is to get people started with the environment. This includes using the interactive shell and editing/run short programs. By the end of the section, students should be able to write short scripts that read data files and perform small calculations. They will know about numbers, strings, lists, and files. There will also be some exposure to functions, exceptions, and modules, but a lot of details will be missing. The first part of this course is often the longest because students are new to the tools and may have various problems getting things to work. It is absolutely critical that you go around the room and make sure that everyone can edit, run, and debug simple programs. Make sure Python is installed correctly. Make sure they have the course exercises downloaded. Make sure the internet works. Fix anything else that comes up. Timing: I aim to finish section 1 around lunch on the first day. Section 2 : Working with Data This section is probably the most important in the course. It covers the basics of data representation and manipulation including tuples, lists, dicts, and sets. Section 2.2 the most important. Give students as much time as they need to get exercises working within reason. Depending on audience, the exercises might last 45 minutes. In the middle of this exercise, I will often move forward to Section 2.3 (formatted printing) and give students more time to keep working. Together, Sections 2.2/2.3 might take an hour or more. Section 2.4 has people explore the use of enumerate(), and zip(). I consider these functions essential so don’t skimp on it. Section 2.5 introduces the collections module. There is a LOT that could be said about collections, but it won't be fully appreciated by students at this time. Approach this more from the standpoint of "here's this cool module you should look at later. Here are a few cool examples." Section 2.6 introduces list comprehensions which are an important feature for processing list data. Emphasize to students that list comprehensions are very similar to things like SQL database queries. At the end of this exercise, I often do an interactive demo involving something more advanced. Maybe do a list comprehension and plot some data with matplotlib. Also an opportunity to introduce Jupyter if you're so inclined. Section 2.7 is the most sophisticated exercise. 그것은 파이썬의 일급(first-class) 데이터 사용과 관련이 있으며, 원하는 모든 종류의 객체를 리스트 같은 자료 구조에 담을 수 있다는 사실과 관련이 있다. The exercises are related to parsing columns of data in CSV files and concepts are later reused in Section 3.2. Timing: Ideally, you want to be done with section 2 on the first day. However, it is common to finish with section 2.5 or 2.6. So, don't panic if you feel that you're a bit behind. 3. 프로그램 조직화 The main goal of this section is to introduce more details about functions and to encourage students to use them. The section builds from functions into modules and script writing. Section 3.1 is about going from simple “scripting” to functions. 수강생이 조직화되지 않은 “스크립트”를 작성하지 않게 하라. 코드는 함수를 사용해 모듈화해야 한다. 조직화된 코드는 이해하기 쉽고, 나중에 변경하기도 쉬우며, 실행 속도도 좀 더 빠르다. 함수는 좋다. 섹션 3.2의 연습 문제는 전체 코스에서 가장 고급일 것이다. 수강생은 칼럼 기반의 데이터를 파싱 하는 범용 유틸리티 함수를 작성한다. 리스트 컴프리헨션과 함수의 리스트를 많이 사용한다(예: 함수를 일급 객체로서 사용). 사람들에게 코드의 각 단계가 어떻게 작동하는지 상세하게 안내할 필요가 있을 것이다. The payoff is huge however---you can show people a short general purpose function that does something amazingly powerful and which would be virtually impossible to write in C, C++, or Java without having a LOT of very complicated code. There are a lot of possible design/discussion avenues for this code. Use your imagination. Section 3.3 adds error handling to the function created in Section 3.2 This is a good time to talk about exception handling generally. Definitely talk about the dangers of catching all exceptions. This might be a good time to talk about the “Errors should never pass silently” item on the “Zen of Python.” *Note: Before Exercise 3.4, make sure students get fully working versions of report.py, pcost.py, and fileparse.py. Copy from Solutions folder if needed * Section 3.4 Introduces module imports. The file written in Section 3.2-3.3 is used to simplify code in Section 3.1. Be aware that you may need to help students fix issues with IDLE, sys.path, and other assorted settings related to import. Section 3.5 talks about __main__ and script writing. There's a bit about command line arguments. You might be inclined to discuss a module like argparse. However, be warned that doing so opens up a quagmire. It's usually better to just mention it and move on. Section 3.6 opens up a discussion about design more generally in Python. Is it better to write code that's more flexible vs code that's hardwired to only work with filenames? This is the first place where you make a code change and have to refactor existing code. Going forward from here, most of the exercises make small changes to code that's already been written. 4. 클래스와 객체 This section is about very basic object oriented programming. In general, it is not safe to assume that people have much background in OO. So, before starting this, I usually generally describe the OO “style” and how it's data and methods bundled together. Do some examples with strings and lists to illustrate that they are “objects” and that the methods (invoked via .) do things with the object. Emphasize how the methods are attached to the object itself. For example, you do items.append(x), you don’t call a separate function append(items, x). Section 4.1 introduces the class statement and shows people how to make a basic object. Really, this just introduces classes as another way to define a simple data structure--relating back to using tuples and dicts for this purpose in section 2. Section 4.2 is about inheritance and how you use to create extensible programs. This set of exercises is probably the most significant in terms of OO programming and OO design. Give students a lot of time to work on it (30-45 minutes). Depending on interest, you can spend a LOT of time discussing aspects of OO. For example, different design patterns, inheritance hierarchies, abstract base classes, etc. Section 4.3 does a few experiments with special methods. I wouldn't spend too much time fooling around with this. Special methods come up a bit later in Exercise 6.1 and elsewhere. Timing: This is usually the end of the 2nd day. 5. Inside Objects This section takes students behind the scenes of the object system and how it’s built using dictionaries, how instances and classes are tied together, and how inheritance works. However, most important part of this section is probably the material about encapsulation (private attributes, properties, slots, etc.) Section 5.1 just peels back the covers and has students observe and play with the underlying dicts of instances and classes. Section 5.2 is about hiding attributes behind get/set functions and using properties. I usually emphasize that these techniques are commonly used in libraries and frameworks--especially in situations where more control over what a user is allowed to do is desired. An astute Python master will notice that I do not talk about advanced topics such as descriptors, or attribute access methods (__getattr__, __setattr__) at all. I have found, through experience, that this is just too much mental overload for students taking the intro course. Everyone’s head is already on the verge of exploding at this point and if you go talk about how something like descriptors work, you’ll lose them for the rest of the day, if not the rest of the course. Save it for an "Advanced Python" course. If you're looking at the clock thinking "There's no way I'm going to finish this course", you can skip section 5 entirely. 6. 제너레이터 The main purpose of this section is to introduce generators as a way to define custom iteration and to use them for various problems related to data handling. The course exercises have students analyze streaming data in the form of stock updates being written to a log file. There are two big ideas to emphasize. First, generators can be used to write code based on incremental processing. This can be very useful for things like streaming data or huge datasets that are too large to fit into memory all at once. The second idea is that you can chain generators/iterators together to create processing pipelines (kind of like Unix pipes). Again, this can be a really powerful way to process and think about streams, large datasets, etc. Some omissions: Although the iteration protocol is described, the notes don’t go into detail about creating iterable objects (i.e., classes with __iter__() and next()). In practice, I’ve found that it’s not necessary to do this so often (generators are often better/easier). So, in the interest of time, I’ve made a conscious decision to omit it. Also not included are extended generators (coroutines) or uses of generators for concurrency (tasklets, etc.). That’s better covered in advanced courses. 7. 고급 주제 Basically this section is an assortment of more advanced topics that could have been covered earlier, but weren’t for various reasons related to course flow and content of the course exercises. If you must know, I used to present this material earlier in the course, but found that students were already overloaded with enough information. Coming back to it later seems to work better---especially since by this point, everyone is much more familiar with working in Python and starting to get the hang of it. Topics include variadic function arguments (args, *kwargs), lambda, closures, and decorators. Discussion of decorators is only a tiny hint of what’s possible with metaprogramming. Feel free to say more about what’s possible, but I’d probably stay out of metaclasses! Lately, I have been demoing "numba" as an example of a more interesting decorator. If you're pressed for time, most of section 7 can be skipped or heavily compressed (you could skip exercises for instance). 8. Testing and Debugging The main purpose of this section is just to introduce various tools and techniques related to testing, debugging, and software development. Show everyone the unittest module. Introduce the logging module. Discuss assertions and the idea of “contracts.” Show people the debugger and profiler. Most of this is self-explanatory. 9. 패키지(Package) At this point, students have written an assortment of files (pcost.py, report.py, fileparse.py, tableformat.py, stock.py, portfolio.py, follow.py, etc.). Two main goals in this section. First, put all of the code into a Python package structure. This is only a gentle introduction to that, but they'll move the files into a directory and everything will break. They'll need to fix their import statements (package relative imports) and maybe fiddle with an __init__.py file. Second goal, write a simple setup.py file that they can use to package up the code and give it away to someone. That's it. End of the course. B. 라이선스 creative commons Attribution-ShareAlike 4.0 International Creative Commons Corporation (“Creative Commons”) is not a law firm and does not provide legal services or legal advice. Distribution of Creative Commons public licenses does not create a lawyer-client or other relationship. Creative Commons makes its licenses and related information available on an “as-is” basis. Creative Commons gives no warranties regarding its licenses, any material licensed under their terms and conditions, or any related information. Creative Commons disclaims all liability for damages resulting from their use to the fullest extent possible. Using Creative Commons Public Licenses Creative Commons public licenses provide a standard set of terms and conditions that creators and other rights holders may use to share original works of authorship and other material subject to copyright and certain other rights specified in the public license below. The following considerations are for informational purposes only, are not exhaustive, and do not form part of our licenses. Considerations for licensors: Our public licenses are intended for use by those authorized to give the public permission to use material in ways otherwise restricted by copyright and certain other rights. Our licenses are irrevocable. Licensors should read and understand the terms and conditions of the license they choose before applying it. Licensors should also secure all rights necessary before applying our licenses so that the public can reuse the material as expected. Licensors should clearly mark any material not subject to the license. This includes other CC-licensed material, or material used under an exception or limitation to copyright. More considerations for licensors. Considerations for the public: By using one of our public licenses, a licensor grants the public permission to use the licensed material under specified terms and conditions. If the licensor’s permission is not necessary for any reason – for example, because of any applicable exception or limitation to copyright – then that use is not regulated by the license. Our licenses grant only permissions under copyright and certain other rights that a licensor has authority to grant. Use of the licensed material may still be restricted for other reasons, including because others have copyright or other rights in the material. A licensor may make special requests, such as asking that all changes be marked or described. Although not required by our licenses, you are encouraged to respect those requests where reasonable. More considerations for the public. Creative Commons Attribution-ShareAlike 4.0 International Public License By exercising the Licensed Rights (defined below), You accept and agree to be bound by the terms and conditions of this Creative Commons Attribution-ShareAlike 4.0 International Public License ("Public License"). To the extent this Public License may be interpreted as a contract, You are granted the Licensed Rights in consideration of Your acceptance of these terms and conditions, and the Licensor grants You such rights in consideration of benefits the Licensor receives from making the Licensed Material available under these terms and conditions. Section 1 – Definitions. a. Adapted Material means material subject to Copyright and Similar Rights that is derived from or based upon the Licensed Material and in which the Licensed Material is translated, altered, arranged, transformed, or otherwise modified in a manner requiring permission under the Copyright and Similar Rights held by the Licensor. For purposes of this Public License, where the Licensed Material is a musical work, performance, or sound recording, Adapted Material is always produced where the Licensed Material is synched in timed relation with a moving image. b. Adapter's License means the license You apply to Your Copyright and Similar Rights in Your contributions to Adapted Material in accordance with the terms and conditions of this Public License. c. BY-SA Compatible License means a license listed at creativecommons.org/compatiblelicenses, approved by Creative Commons as essentially the equivalent of this Public License. d. Copyright and Similar Rights means copyright and/or similar rights closely related to copyright including, without limitation, performance, broadcast, sound recording, and Sui Generis Database Rights, without regard to how the rights are labeled or categorized. For purposes of this Public License, the rights specified in Section 2(b)(1)-(2) are not Copyright and Similar Rights. e. Effective Technological Measures means those measures that, in the absence of proper authority, may not be circumvented under laws fulfilling obligations under Article 11 of the WIPO Copyright Treaty adopted on December 20, 1996, and/or similar international agreements. f. Exceptions and Limitations means fair use, fair dealing, and/or any other exception or limitation to Copyright and Similar Rights that applies to Your use of the Licensed Material. g. License Elements means the license attributes listed in the name of a Creative Commons Public License. The License Elements of this Public License are Attribution and ShareAlike. h. Licensed Material means the artistic or literary work, database, or other material to which the Licensor applied this Public License. i. Licensed Rights means the rights granted to You subject to the terms and conditions of this Public License, which are limited to all Copyright and Similar Rights that apply to Your use of the Licensed Material and that the Licensor has authority to license. j. Licensor means the individual(s) or entity(ies) granting rights under this Public License. k. Share means to provide material to the public by any means or process that requires permission under the Licensed Rights, such as reproduction, public display, public performance, distribution, dissemination, communication, or importation, and to make material available to the public including in ways that members of the public may access the material from a place and at a time individually chosen by them. l. Sui Generis Database Rights means rights other than copyright resulting from Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, as amended and/or succeeded, as well as other essentially equivalent rights anywhere in the world. m. You means the individual or entity exercising the Licensed Rights under this Public License. Your has a corresponding meaning. Section 2 – Scope. a. License grant. 1. Subject to the terms and conditions of this Public License, the Licensor hereby grants You a worldwide, royalty-free, non-sublicensable, non-exclusive, irrevocable license to exercise the Licensed Rights in the Licensed Material to: A. reproduce and Share the Licensed Material, in whole or in part; and B. produce, reproduce, and Share Adapted Material. 2. __Exceptions and Limitations.__ For the avoidance of doubt, where Exceptions and Limitations apply to Your use, this Public License does not apply, and You do not need to comply with its terms and conditions. 3. __Term.__ The term of this Public License is specified in Section 6(a). 4. __Media and formats; technical modifications allowed.__ The Licensor authorizes You to exercise the Licensed Rights in all media and formats whether now known or hereafter created, and to make technical modifications necessary to do so. The Licensor waives and/or agrees not to assert any right or authority to forbid You from making technical modifications necessary to exercise the Licensed Rights, including technical modifications necessary to circumvent Effective Technological Measures. For purposes of this Public License, simply making modifications authorized by this Section 2(a)(4) never produces Adapted Material. 5. __Downstream recipients.__ A. __Offer from the Licensor – Licensed Material.__ Every recipient of the Licensed Material automatically receives an offer from the Licensor to exercise the Licensed Rights under the terms and conditions of this Public License. B. __Additional offer from the Licensor – Adapted Material. Every recipient of Adapted Material from You automatically receives an offer from the Licensor to exercise the Licensed Rights in the Adapted Material under the conditions of the Adapter’s License You apply. C. __No downstream restrictions.__ You may not offer or impose any additional or different terms or conditions on, or apply any Effective Technological Measures to, the Licensed Material if doing so restricts exercise of the Licensed Rights by any recipient of the Licensed Material. 6. __No endorsement.__ Nothing in this Public License constitutes or may be construed as permission to assert or imply that You are, or that Your use of the Licensed Material is, connected with, or sponsored, endorsed, or granted official status by, the Licensor or others designated to receive attribution as provided in Section 3(a)(1)(A)(i). b. Other rights. 1. Moral rights, such as the right of integrity, are not licensed under this Public License, nor are publicity, privacy, and/or other similar personality rights; however, to the extent possible, the Licensor waives and/or agrees not to assert any such rights held by the Licensor to the limited extent necessary to allow You to exercise the Licensed Rights, but not otherwise. 2. Patent and trademark rights are not licensed under this Public License. 3. To the extent possible, the Licensor waives any right to collect royalties from You for the exercise of the Licensed Rights, whether directly or through a collecting society under any voluntary or waivable statutory or compulsory licensing scheme. In all other cases the Licensor expressly reserves any right to collect such royalties. Section 3 – License Conditions. Your exercise of the Licensed Rights is expressly made subject to the following conditions. a. Attribution. 1. If You Share the Licensed Material (including in modified form), You must: A. retain the following if it is supplied by the Licensor with the Licensed Material: i. identification of the creator(s) of the Licensed Material and any others designated to receive attribution, in any reasonable manner requested by the Licensor (including by pseudonym if designated); ii. a copyright notice; iii. a notice that refers to this Public License; iv. a notice that refers to the disclaimer of warranties; v. a URI or hyperlink to the Licensed Material to the extent reasonably practicable; B. indicate if You modified the Licensed Material and retain an indication of any previous modifications; and C. indicate the Licensed Material is licensed under this Public License, and include the text of, or the URI or hyperlink to, this Public License. 2. You may satisfy the conditions in Section 3(a)(1) in any reasonable manner based on the medium, means, and context in which You Share the Licensed Material. For example, it may be reasonable to satisfy the conditions by providing a URI or hyperlink to a resource that includes the required information. 3. If requested by the Licensor, You must remove any of the information required by Section 3(a)(1)(A) to the extent reasonably practicable. b. ShareAlike. In addition to the conditions in Section 3(a), if You Share Adapted Material You produce, the following conditions also apply. The Adapter’s License You apply must be a Creative Commons license with the same License Elements, this version or later, or a BY-SA Compatible License. You must include the text of, or the URI or hyperlink to, the Adapter's License You apply. You may satisfy this condition in any reasonable manner based on the medium, means, and context in which You Share Adapted Material. You may not offer or impose any additional or different terms or conditions on, or apply any Effective Technological Measures to, Adapted Material that restrict exercise of the rights granted under the Adapter's License You apply. Section 4 – Sui Generis Database Rights. Where the Licensed Rights include Sui Generis Database Rights that apply to Your use of the Licensed Material: a. for the avoidance of doubt, Section 2(a)(1) grants You the right to extract, reuse, reproduce, and Share all or a substantial portion of the contents of the database; b. if You include all or a substantial portion of the database contents in a database in which You have Sui Generis Database Rights, then the database in which You have Sui Generis Database Rights (but not its individual contents) is Adapted Material, including for purposes of Section 3(b); and c. You must comply with the conditions in Section 3(a) if You Share all or a substantial portion of the contents of the database. For the avoidance of doubt, this Section 4 supplements and does not replace Your obligations under this Public License where the Licensed Rights include other Copyright and Similar Rights. Section 5 – Disclaimer of Warranties and Limitation of Liability. a. Unless otherwise separately undertaken by the Licensor, to the extent possible, the Licensor offers the Licensed Material as-is and as-available, and makes no representations or warranties of any kind concerning the Licensed Material, whether express, implied, statutory, or other. This includes, without limitation, warranties of title, merchantability, fitness for a particular purpose, non-infringement, absence of latent or other defects, accuracy, or the presence or absence of errors, whether or not known or discoverable. Where disclaimers of warranties are not allowed in full or in part, this disclaimer may not apply to You. b. To the extent possible, in no event will the Licensor be liable to You on any legal theory (including, without limitation, negligence) or otherwise for any direct, special, indirect, incidental, consequential, punitive, exemplary, or other losses, costs, expenses, or damages arising out of this Public License or use of the Licensed Material, even if the Licensor has been advised of the possibility of such losses, costs, expenses, or damages. Where a limitation of liability is not allowed in full or in part, this limitation may not apply to You. c. The disclaimer of warranties and limitation of liability provided above shall be interpreted in a manner that, to the extent possible, most closely approximates an absolute disclaimer and waiver of all liability. Section 6 – Term and Termination. a. This Public License applies for the term of the Copyright and Similar Rights licensed here. However, if You fail to comply with this Public License, then Your rights under this Public License terminate automatically. b. Where Your right to use the Licensed Material has terminated under Section 6(a), it reinstates: 1. automatically as of the date the violation is cured, provided it is cured within 30 days of Your discovery of the violation; or 2. upon express reinstatement by the Licensor. For the avoidance of doubt, this Section 6(b) does not affect any right the Licensor may have to seek remedies for Your violations of this Public License. c. For the avoidance of doubt, the Licensor may also offer the Licensed Material under separate terms or conditions or stop distributing the Licensed Material at any time; however, doing so will not terminate this Public License. d. Sections 1, 5, 6, 7, and 8 survive termination of this Public License. Section 7 – Other Terms and Conditions. a. The Licensor shall not be bound by any additional or different terms or conditions communicated by You unless expressly agreed. b. Any arrangements, understandings, or agreements regarding the Licensed Material not stated herein are separate from and independent of the terms and conditions of this Public License.t stated herein are separate from and independent of the terms and conditions of this Public License. Section 8 – Interpretation. a. For the avoidance of doubt, this Public License does not, and shall not be interpreted to, reduce, limit, restrict, or impose conditions on any use of the Licensed Material that could lawfully be made without permission under this Public License. b. To the extent possible, if any provision of this Public License is deemed unenforceable, it shall be automatically reformed to the minimum extent necessary to make it enforceable. If the provision cannot be reformed, it shall be severed from this Public License without affecting the enforceability of the remaining terms and conditions. c. No term or condition of this Public License will be waived and no failure to comply consented to unless expressly agreed to by the Licensor. d. Nothing in this Public License constitutes or may be interpreted as a limitation upon, or waiver of, any privileges and immunities that apply to the Licensor or You, including from the legal processes of any jurisdiction or authority. Creative Commons is not a party to its public licenses. Notwithstanding, Creative Commons may elect to apply one of its public licenses to material it publishes and in those instances will be considered the “Licensor.” Except for the limited purpose of indicating that material is shared under a Creative Commons public license or as otherwise permitted by the Creative Commons policies published at [creativecommons.org/policies](http://creativecommons.org/policies), Creative Commons does not authorize the use of the trademark “Creative Commons” or any other trademark or logo of Creative Commons without its prior written consent including, without limitation, in connection with any unauthorized modifications to any of its public licenses or any other arrangements, understandings, or agreements concerning use of licensed material. For the avoidance of doubt, this paragraph does not form part of the public licenses. Creative Commons may be contacted at creativecommons.org<|endoftext|>

전문분야 텍스트 ### 제목: 🤗Transformers (신경망 언어모델 라이브러리) 강좌 ### 본문: 현재 전 세계적으로 가장 많이 활용되고 있는 신경망 언어 모델(Neural Language Models) 기반 딥러닝 라이브러리인 Hugging Face 사의 Transformers 라이브러리 활용법을 상세히 기술하고 있는 Transformers Course를 한국어로 번역한 자료를 공유합니다. 내용 자체가 워낙 알기 쉽게 기술되어 있고, Jupyter Notebook이나 Google Colaboratory를 사용하여 본인이 직접 실습을 진행하면서 공부할 수 있기 때문에 별도의 추가 설명이 많이 필요하지는 않았으나, 그래도 일부 내용 중에서 역자가 생각하기에 이해가 쉽지 않거나 복잡할 수도 있는 부분은 부가 설명을 추가했습니다. 부디 딥러닝 기반 언어 처리 및 대규모 신경망 언어 모델 공부에 도움이 되셨으면 좋겠습니다. 강좌 활용 방법 본 강좌를 시작하기 전에 몇 가지 알려드릴 내용이 있습니다. 본 강좌는 대부분의 내용이 직접 실습을 해가면서 공부할 수 있도록 구성되었습니다. 따라서, 가급적이면 Jupyter Notebook이나 Colaboratory를 활용하여 실습을 하시면서 공부하시길 권장합니다. 저 역시도 강좌 내의 모든 코드들을 실행하여 그 결과를 확인하면서 번역을 진행했습니다. 가끔씩 노트북이나 PC 등과 같은 일반적인 컴퓨터 사양에서 실행되지 않거나 시간이 오래 걸리는 예제들이 있습니다. 따라서 가용한 GPU 서버가 있다면 그 서버에서 실습하시길 바라며, 가용 서버가 없다면 Google Colaboratory 활용을 추천합니다. 본 강좌는 TensorFlow 및 PyTorch를 선택적으로 활용할 수 있습니다만, 이 번역판은 PyTorch를 활용했습니다. 강좌 내에 나오는 모든 이미지들은 직접 가져오지 않고 Transformers Course 사이트의 URL을 링크만 했습니다. 그러나 도표는 직접 마크다운(Markdown)으로 만들었습니다. 질문 사항이 있으시면 언제든지 댓글을 통해서 알려주시면 성심을 다해서 답변드리도록 하겠습니다. 내용 전개 과정에서 아이콘이 많이 등장하는 것을 알 수 있습니다. Hugging Face 아이콘인는 주로 제공하는 라이브러리 명칭 앞에 위치하고 있습니다. 전체 강좌 내용 본 강좌는 다음과 같은 내용으로 구성되어 있습니다. 각 장의 해당 섹션의 링크로 들어가시면 됩니다. 0장. 본 강좌를 공부하기 위해 기본적으로 준비해야 할 사항들 (Setup) 1장. 트랜스포머 모델 (Transformer models) 2장. Transformers 라이브러리 활용법 (Using Transformers) 3장. 사전학습 모델에 대한 미세조정 (Fine-tuning a pretrained model) 4장. 모델 및 토크 나이저 공유 (Sharing models and tokenizers) 5장. Datasets 라이브러리 (The Datasets library) 6장. Tokenizers 라이브러리 (The Tokenizers library) 7장. 주요 NLP 태스크 (Main NLP Tasks) 8장. 도움 요청 방법 (How to ask for help) 향후 보완 사항 현재 Hugging Face 강좌 사이트에는 0장부터 8장까지만 공개되어 있습니다. 9장부터 12장은 현재 해당 저자들이 내용 작성 중이라고 합니다. 조만간 공개될 예정이니 공개되면 다시 번역하여 추가하겠습니다. 강좌 과정 중에 보이는 유튜브<NAME>상은 일단 제외했습니다. 추후 요구가 있으면 추가하도록 하겠습니다. 0장(Chapter 0)의 내용이 많이 부실하다고 생각합니다. 원본 강좌의 내용을 그대로 반영했으나 아무래도 다양한 설정 방식을 포괄적으로 설명하지는 못하고 있는 것 같습니다. 이 부분에 대해서 향후 보완하겠습니다. 원본 강좌에는 각 장이 끝나면 퀴즈를 풀게 하고 있습니다만 이 부분도 제외를 하였습니다. 4장과 8장은 현재 작성 과정에 있습니다. 다른 내용에 비해서 상대적으로 중요도가 낮고 부가적인 설명들이라 향후에 지속적으로 업데이트할 예정입니다. 0장. 환경설정 (SETUP) Hugging Face 강좌에 오신 것을 환영합니다! 여기에서는 작업 환경을 설정하는 과정을 안내합니다. 본 과정을 이제 막 시작하는 경우에는 먼저 1장을 살펴본 다음 돌아와서 코드를 직접 사용해 볼 수 있도록 시스템 환경을 설정하는 것이 좋습니다. 이 강좌에서 사용할 모든 라이브러리는 Python 패키지로 제공되므로 여기에서는 Python 환경을 설정하고 필요한 특정 라이브러리를 설치하는 방법을 보여줍니다. 먼저 Colab 노트북 또는 Python 가상 환경을 사용하여 작업 환경을 설정하는 두 가지 방법을 다룹니다. 두 가지 방법들 중에서 여러분이 좋아하는 방법을 선택하시면 됩니다. 초보자의 경우 Colab 노트북을 사용하여 시작하는 것이 좋습니다. Windows 시스템에서의 환경 설정은 다루지 않습니다. Windows에서 본 강좌를 보고 계신다면 브라우저를 통한 Colab 노트북을 사용하는 것을 추천드립니다. Linux 배포판이나 macOS를 사용하는 경우 여기에 설명된 두 가지 방법 중 하나를 사용할 수 있습니다. 대부분의 강좌는 Hugging Face 계정이 있어야 편하게 공부할 수 있습니다. 따라서, 지금 바로 계정을 만드는 것이 좋습니다: 계정 생성 구글의 Colab 노트북 사용하기 Colab 노트북을 사용한다면 가장 간단하게 설정을 마칠 수 있습니다. 브라우저에서 노트북을 부팅하고 바로 코딩을 시작할 수 있습니다. Colab에 익숙하지 않은 경우 소개(Introduction)를 한번 공부하고 시작하는 것이 좋습니다. Colab을 사용하면 GPU 또는 TPU와 같은 일부 가속 하드웨어를 사용할 수 있으며 소규모 워크 로드(workload)에는 돈이 들지 않습니다. Colab에 어느 정도 익숙해지면 새 노트북을 만들고 설정 작업을 시작하세요: 가장 먼저 해야 할 설정 작업은 이 강좌에서 사용할 라이브러리들을 설치하는 것입니다. Python 용 패키지 관리자인 pip를 설치에 사용할 것입니다. 노트북에서는 시스템 명령 앞에! 문자를 입력하여 Transformers 라이브러리를 다음과 같이 설치할 수 있습니다: !pip install transformers Python 런타임(Python runtime) 내에서 패키지를 임포트(import) 하여 패키지가 올바르게 설치되었는지 확인할 수 있습니다: import transformers 이 과정에서 Transformers의 매우 가벼운 버전을 설치합니다. 특히 PyTorch 또는 TensorFlow와 같은 특정 기계 학습 프레임워크가 함께 설치되지는 않기 때문에 이는 별도로 설치해야 합니다. 또한, Transformers 라이브러리의 다양한 기능을 사용할 것이기 때문에, 상상할 수 있는 거의 모든 활용 사례(use cases)에 필요한 모든 종속성(dependency)을 포함한 개발자 버전(development version)을 설치하는 것이 좋습니다: !pip install transformers[sentencepiece] 시간이 조금 걸릴 수 있습니다. 문제없이 완료되었다면 본 강좌의 나머지 부분을 공부할 준비가 된 것입니다. Python 가상 환경 이용하기 Python 가상 환경(Python virtual environment)을 사용하려는 경우, 첫 번째 단계는 시스템에 Python을 설치하는 것입니다. 이 작업을 시작하려면 이 가이드를 따르는 것이 좋습니다. Python이 설치되면 터미널에서 Python 명령을 실행할 수 있어야 합니다. 다음 단계로 진행하기 전에 올바르게 설치되었는지 확인하기 위해 python --version 명령을 실행해 봅시다. 이제 시스템에서 가용한 Python 버전이 출력되어야 합니다. 터미널에서 python --version과 같은 Python 명령을 실행할 때 이를 실행하는 프로그램을 시스템의 "main" Python으로 생각해야 합니다. 이러한 "main" 설치(installation)를 어떠한 추가 패키지 없이 원래대로 유지하고, 본인이 작업하는 각 응용 프로그램에 맞는 별도의 환경을 추가적으로 만드는 것이 좋습니다. 이렇게 하면 해당 환경에는 각 응용 프로그램에 고유한 종속성과 부가 패키지들이 존재하며, 다른 응용 프로그램과의 잠재적인 호환성 문제에 대해 걱정할 필요가 없습니다. Python에서는 이를 가상 환경(virtual environment)으로 실현할 수 있습니다. 가상 환경은 응용 프로그램이 필요로 하는 각종 패키지들이 포함된 특정 버전의 파이썬이 설치되어 있는 완전한 디렉터리라고 볼 수 있습니다. 이러한 가상 환경을 만드는 것은 다양한 도구를 사용하여 수행할 수 있지만 우리는 venv라고 하는 공식 Python 패키지를 사용할 것입니다. 먼저 대상 응용 프로그램을 저장할 디렉터리를 만듭니다. 예를 들어, 홈 디렉터리의 루트에 transformers-course라는 새 디렉터리를 만들어 보세요: mkdir ~/transformers-course cd ~/transformers-course 이 디렉터리 내에서 Python venv 모듈을 사용하여 가상 환경을 만듭니다: python -m vent .env 이제 비어있는 폴더에. env라는 디렉터리가 있어야 합니다: ls -a activate 및 deactivate 스크립트를 사용하여 가상 환경에 들어가거나 나올 수 있습니다. # 가상 환경을 활성화 source .env/bin/activate # 가상 환경을 비활성화 source .env/bin/deactivate which python 명령을 실행하여 환경이 활성화되었는지 확인할 수 있습니다. 가상 환경을 가리키는 경우 성공적으로 활성화한 것입니다! which python /home//transformers-course/.env/bin/python Dependencies 설치 Google Colab 인스턴스 사용에 대한 이전 섹션에서와 같이 이제 강좌를 진행하는데 필요한 패키지를 설치해야 합니다. 다시 말하지만, pip 패키지 관리자를 사용하여 Transformers의 개발자 버전을 설치할 수 있습니다: pip install "transformers[sentencepiece]" 이제 모든 설정이 완료되었으며 본격적으로 공부할 준비가 되었습니다! 1장. 트랜스포머 (Transformer) 모델 Welcome to the Course! 본 강좌는 Hugging Face 생태계(ecosystem)를 구성하는 Transformers, Datasets, Tokenizers, Accelerate 라이브러리들과 Hugging Face Hub을 활용한 자연어 처리(NLP)에 대해 알려줍니다. 완전히 무료이며 광고가 없습니다. 어떤 내용을 포함하고 있나? 이 강좌에 대한 간략한 개요는 다음과 같습니다: 1장에서 4장까지는 Transformers 라이브러리의 주요 개념을 소개합니다. 이 과정이 끝나면 Transformer 모델의 작동 방식에 익숙해지고, Hugging Face Hub에 공개된 모델들을 사용하는 방법이나 데이터 셋을 이용해서 모델을 미세 조정(fin-tune) 하고 그 결과를 Hub에<NAME>는 방법을 알게 될 것입니다! 5장에서 8장까지는 Datasets와 Tokenizers의 기초를 다지고 이를 바탕으로 잘 알려져 있는 주요 NLP 태스크(task) 들에 대한 내용을 공부합니다. 이 부분이 끝나면 가장 일반적이고 그래서 자주 접할 수 있는 NLP 문제들을 스스로 해결할 수 있습니다. 9장에서 12장까지는 메모리 효율화(memory efficiency) 및 길이가 긴 시퀀스(long sequences) 문제 등과 같은 특별한 아키텍처를 보여주고, 보다 더 특화된 사용 사례(use cases)를 위해 사용자 정의 개체(custom objects)를 작성하는 방법을 가르쳐 줍니다. 이 파트가 끝나면 복잡한 NLP 문제를 해결할 수 있는 준비를 갖추게 되고, Transformers에 중요한 기여를 할 수도 있습니다. 이 강좌를 잘 활용하기 위해서는: Python을 잘 알고 다룰 수 있어야 합니다. fast.ai의 Practical Deep Learning for Coders 또는 DeepLearning.AI에서 만든 강좌 프로그램 등과 같은 입문 딥러닝 강좌를 공부한 후에 수강하는 것이 좋습니다. PyTorch 또는 TensorFlow에 대한 사전 지식을 필요로 하지는 않지만 둘 중 하나에 익숙하면 분명 도움이 됩니다. 이 과정을 마친 후에는 알아야 할 가치가 있는 나이브 베이즈(naive Bayes) 및 LSTM과 같은 기존 NLP 모델들을 광범위하게 다루고 있는 DeepLearning.AI의 Natural Language Processing Specialization을 추가적으로 살펴보기를 추천합니다! 저자 소개 Matthew Carrigan 은 Hugging Face의 기계 학습 엔지니어입니다. 아일랜드 더블린에 거주하며 이전에는 Parse.ly에서 ML 엔지니어로 근무했고 그전에는 Trinity College Dublin에서 박사후 연구원으로 근무했습니다. 그는 우리가 기존 아키텍처를 확장하여 범용 인공 지능(AGI, Artificial General Intelligence)에 도달할 것이라고 믿지는 않지만, Robot Immortality에 대한 강한 희망을 가지고 있습니다. Lysandre Debut는 Hugging Face의 기계 학습 엔지니어이며 초기 개발 단계부터 Transformers 라이브러리를 개발해 왔습니다. 그의 목표는 매우 간단한 API로 도구를 개발하여 모든 사람이 NLP에 쉽게 접근할 수 있도록 하는 것입니다. Sylvain Gugger는 Hugging Face의 연구원(Research Engineer)이 자 Transformers 라이브러리의 핵심 관리자 중 한 명입니다. 이전에 그는 fast.ai에서 연구 과학자(Research Scientist)로 근무했으며, Jeremy Howard와 함께 Deep Learning for Coders with fastai and PyTorch를 공동 저술했습니다. Merve Noyan 은 Hugging Face의 디벨로퍼 에드보케이트(developer advocate)로서 각종 도구들을 개발하고 각 도구들에 대한 다양한 콘텐츠들을 구축하여 기계 학습 기술이 모든 사람들에게 공평하게 활용될 수 있도록 노력하고 있습니다. Lucile Saulnier는 Hugging Face의 기계 학습 엔지니어로 오픈 소스 도구를 개발하고 있습니다. 그녀는 또한 collaborative training 및 BigScience와 같은 자연어 처리 분야의 많은 연구 프로젝트에 적극적으로 참여하고 있습니다. Lewis Tunstall 은 Hugging Face의 기계 학습 엔지니어로 오픈 소스 도구를 개발하고 더 많은 커뮤니티에서 이를 쉽게 접근할 수 있도록 하는데 집중하고 있습니다. 그는 또한 곧 출시될 O'Reilly의 Transformers에 대한 도서의 공동 저자이기도 합니다. Leandro von Werra는 Hugging Face의 오픈 소스 팀의 기계 학습 엔지니어이자 곧 출시될 O'Reilly의 Transformers에 대한 도서의 공동 저자이기도 합니다. 그는 기계학습 기반의 NLP 프로젝트를 제품으로 실현시키는 수년간의 업계 경험을 보유하고 있습니다. 이 장(Chapter 1)에서는 다음의 내용을 배웁니다: pipeline() 함수를 사용하여 텍스트 생성 및 분류와 같은 NLP 작업을 해결하는 방법 Transformer 아키텍처 인코더(encoder), 디코더(decoder) 및 인코더-디코더(encoder-decoder) 아키텍처의 구분 및 각 아키텍처의 활용 방안 1. 자연어 처리 (Natural Language Processing) 트랜스포머 모델에 대해서 본격적으로 공부하기 전에, 자연어 처리(Natural Language Processing)가 무엇이고, 왜 우리가 이 기술에 대해서 관심을 가져야 하는지 알아봅시다. NLP가 무엇인가요? NLP는 인간의 언어(human language)와 관련된 모든 것을 이해하는 데 중점을 둔 언어학(linguistics) 및 기계 학습(machine learning)의 한 분야입니다. NLP 작업은 단일 단어를 개별적으로 이해하는 것은 물론 해당 단어의 컨텍스트, 즉 주변 문맥도 함께 이해할 수 있도록 하는 것을 목표로 합니다. 다음은 일반적인 NLP 태스크 종류와 그 예시들을 보여주고 있습니다. 전체 문장을 분류하기(Classifying whole sentences): 리뷰(review)의 감정(sentiment)을 식별하고, 이메일이 스팸인지 감지하고, 문장이 문법적으로 올바른지 또는 두 문장이 논리적으로 관련되어 있는지를 판단합니다. 단일 문장에서 각 단어를 분류하기(Classifying each word in a sentence): 문장의 문법적 구성요소(명사, 동사, 형용사) 또는 명명된 개체(개체명, e.g., 사람, 위치, 조직) 식별 텍스트 콘텐츠 생성하기(Generating text content): 자동 생성된 텍스트로 프롬프트 완성(completing a prompt), 마스킹 된 단어(masked words)로 텍스트의 공백 채우기 텍스트에서 정답 추출하기(Extracting an answer from a text): 질문(question)과 맥락(context)이 주어지면, 맥락에서 제공된 정보를 기반으로 질문에 대한 답변을 추출 입력 텍스트에서 새로운 문장을 생성하기(Generating a new sentence from an input text): 텍스트를 다른 언어로 번역(translation), 텍스트 요약(summarization) NLP는 문어적 텍스트(written text) 처리에 국한되지 않습니다. NLP는 오디오 샘플의 스크립트(transcript) 또는 이미지 설명(image caption) 생성과 같은 음성 인식(speech recognition) 및 컴퓨터 비전(computer vision) 등의 복잡한 문제도 또한 해결합니다. NLP는 왜 어려운가요? 컴퓨터는 인간과 같은 방식으로 정보를 처리하지 않습니다. 예를 들어, 우리가 “배고프다(I am hungry)”라는 문장을 읽으면, 인간은 그 의미를 쉽게 이해할 수 있습니다. 마찬가지로, "나는 배고프다(I am hungry)"와 "나는 슬프다(I am sad)"와 같은 두 문장이 주어지면 우리는 두 문장이 얼마나 유사한지를 쉽게 결정할 수 있습니다. 기계 학습(Machine Learning, ML) 모델의 경우 이러한 일을 수행하기가 더 어렵습니다. 모델이 이 작업을 수행하기 위해서는, 텍스트가 모델이 학습할 수 있는 방식으로 처리되어야 합니다. 그리고 언어가 복잡하기 때문에 인간은 이 처리가 어떻게 이루어져야 하는지에 대해 신중하게 생각해야 합니다. 지금까지 텍스트를 표현하는 방법(how to represent text)에 대한 많은 연구가 진행되었으며, 다음 섹션에서 몇 가지 방법을 살펴보겠습니다. 2. Transformers가 할 수 있는 일들 이 섹션에서는 트랜스포머 모델이 무엇을 할 수 있는지 살펴보고, Transformers 라이브러리의 첫 번째 도구인 pipeline() 함수를 사용해 볼 것입니다. Transformers는 어디에든 존재합니다! 트랜스포머 모델은 이전 섹션에서 언급한 모든 종류의 NLP 작업을 해결하는 데 사용됩니다. 다음은 Hugging Face 및 트랜스포머 모델을 사용하는 몇몇 회사 및 조직들을 보여주고 있습니다. 이들은 자신들이 만든 모델들을<NAME>여 커뮤니티에 다시 기여합니다 Transformers 라이브러리는 공유된 모델을 만들고 사용할 수 있는 다양한 기능들을 제공합니다. Model Hub에는 누구나 다운로드하여 사용할 수 있는 수천 개의 사전 학습된 모델(pretrained models)들이 포함되어 있습니다. 또한 자신의 모델을 허브에 업로드할 수도 있습니다! ⚠ The Hugging Face Hub는 트랜스포머 모델에만 국한하지 않습니다. 누구나 원하는 모든 종류의 모델이나 데이터 셋(datasets)을 공유할 수 있습니다! 사용 가능한 모든 기능을 활용하려면 huggingface.co 계정을 만드세요! 트랜스포머 모델이 내부적으로 어떻게 작동하는지 알아보기 전에 몇 가지 흥미로운 NLP 문제를 해결하는 데 사용할 수 있는 몇 가지 예를 살펴보겠습니다. 파이프라인(pipeline) 활용하기 Transformers 라이브러리의 가장 기본적인 객체는 pipeline() 함수입니다. 이 함수는 특정 모델과 동작에 필요한 전처리 및 후처리 단계를 연결하여 텍스트를 직접 입력하고 이해하기 쉬운 답변을 얻을 수 있습니다. from transformers import pipeline classifier = pipeline("sentiment-analysis") classifier("I've been waiting for a HuggingFace course my whole life.") 여러 개의 문장을 동시에 입력으로 전달할 수도 있습니다! classifier(["I've been waiting for a HuggingFace course my whole life.", "I hate this so much!"]) 기본적으로 이 파이프라인은 영어 문장에 대한 감정 분석(sentiment analysis)을 위해 미세 조정된(fine-tuned) 사전 훈련 모델(pretrained model)을 선택합니다. 위 코드에서 classifier 객체를 생성할 때 해당 모델이 다운로드되고 캐시 됩니다. 생성된 classifier 객체를 다시 실행하면 캐시 된 모델이 대신 사용되며 모델을 다시 다운로드할 필요가 없습니다. 파이프라인에 텍스트가 입력되면 3가지 주요 단계가 내부적으로 실행됩니다. 텍스트는 모델이 이해할 수 있는<NAME>으로 전처리됩니다(preprocessing). 전처리 완료된 입력 텍스트는 모델에 전달됩니다. 모델이 예측한 결과는 후처리되어(postprocessing) 우리가 이해할 수 있는 형태로 변환됩니다. 현재 활용 가능한 몇 가지 파이프라인들은 다음과 같습니다: feature-extraction (텍스트에 대한 벡터 표현 제공) fill-mask ner (named entity recognition, 개체명 인식) question-answering sentiment-analysis summarization text-generation translation zero-shot-classification 이 중 몇 가지를 살펴보겠습니다! Zero-shot 분류 우선, 레이블이 지정되지 않은 텍스트를 분류해야 하는 더 어려운 작업부터 시작하겠습니다. 텍스트에 주석(annotation)을 추가하는 것은 일반적으로 시간이 많이 걸리고 분야 전문 지식(domain expertise)이 필요하기 때문에 이 작업은 실제 프로젝트에서 매우 흔한 시나리오입니다. 이 활용 사례의 경우, zero-shot-classification 파이프라인은 매우 유용합니다. 그 이유는 해당 분류에 사용할 레이블을 직접 마음대로 지정할 수 있으므로 사전 훈련된 모델의 레이블 집합에 의존할 필요가 없기 때문입니다. 이미 우리는 해당 모델이 두 레이블(긍정, 부정)을 사용하여 문장을 긍정 또는 부정으로 분류하는 방법을 이미 보았습니다. 그러나 이 모델을 이용해서 우리가 원하는 또 다른 레이블 집합을 사용하여 텍스트를 분류할 수도 있습니다. from transformers import pipeline classifier = pipeline("zero-shot-classification") classifier( "This is a course about the Transformers library", candidate_labels=["education", "politics", "business"], ) 위와 같이 완전히 다른 새로운 레이블 집합으로 문장 분류를 수행할 때도 새로운 데이터를 이용해서 모델을 미세 조정(fine-tuning) 할 필요가 없기 때문에 zero-shot 분류라고 합니다. 위 예시에서 보는 바와 같이 원하는 레이블 목록에 대한 확률 점수를 직접 반환할 수도 있습니다! 텍스트 생성 이제 파이프라인을 사용하여 텍스트를 생성하는 방법을 살펴보겠습니다. 여기서 주요 아이디어는 입력으로 특정 프롬프트(prompt)를 제공하면 모델이 나머지 텍스트를 생성하여 프롬프트를 자동 완성한다는 것입니다. 이것은 전화기에서 볼 수 있는 텍스트 예측 기능(predictive text feature)과 유사합니다. 텍스트 생성은 랜덤하게 수행되므로 여러분의 출력이 아래 결과와 다르게 나오는 것은 정상입니다. from transformers import pipeline generator = pipeline("text-generation") generator("In this course, we will teach you how to") 위의 generator 객체에 num_return_sequences 인자(argument)를 지정하여 생성되는 시퀀스의 개수를 정할 수 있고, max_length 인자로는 출력 텍스트의 총 길이를 제어할 수 있습니다. 파이프라인에서 허브의 모든 모델을 사용할 수 있다! 이전 예제에서는 현재 작업에 대한 기본적인 모델(default model)을 사용했지만 허브에서 여러분이 원하는 모델을 선택하여 특정 작업(예: 텍스트 생성)에 대한 파이프라인에서 사용할 수도 있습니다. 모델 허브(Model Hub)로 이동하여 왼쪽에 있는 특정 태그를 클릭하면 관련 작업을 지원하는 모델만 표시됩니다. 그 결과는 이 페이지에서 볼 수 있습니다. 자 이제 distilgpt2 모델을 사용해 봅시다! 파이프라인에서 이 모델을 로드하는 방법은 다음과 같습니다. from transformers import pipeline generator = pipeline("text-generation", model="distilgpt2") # distilgpt2 모델을 로드한다. generator( "In this course, we will teach you how to", max_length=30, num_return_sequences=2, ) 언어 태그(language tags)를 클릭하여 그 언어에 특화된 모델을 세부적으로 검색하고 선택함으로써 원하는 언어로 표현된 텍스트를 생성할 수 있는 모델을 사용할 수 있습니다. Model Hub에는 다중 언어를 지원하는 다국어 모델(multilingual models)에 대한 체크포인트도 포함되어 있습니다. 특정 모델을 클릭하여 선택하면 온라인에서 직접 테스트할 수 있는 위젯(widget)이 표시됩니다. 이렇게 하면 다운로드하기 전에 그 모델의 기능을 빠르게 테스트할 수 있습니다. 추론 API 모든 모델은 Hugging Face 웹사이트에서 제공되는 Inference API를 사용하여 브라우저를 통해 직접 테스트할 수 있습니다. 이 페이지에서 직접 임의의 텍스트를 입력하고 모델이 해당 텍스트를 처리하는 것을 살펴보면서 모델들을 테스트해 볼 수 있습니다. 위젯을 구동하는 Inference API는 유료 제품으로도 제공되므로 실무적으로도 편리하게 사용 가능합니다. 자세한 내용은 가격 책정 페이지를 참조하세요. Mask filling 다음으로 시도할 파이프라인은 fill-mask입니다. 이 작업은 주어진 텍스트의 공백을 채우는 것입니다. from transformers import pipeline unmasker = pipeline("fill-mask") unmasker("This course will teach you all about <mask> models.", top_k=2) top_k 인자(argument)는 출력할 공백 채우기 종류의 개수를 지정합니다. 여기서 모델은 마스크 토큰(mask token)이라고 부르는 특수한 <mask> 단어를 채웁니다. 마스크 채우기(mask-filling) 모델에 따라 서로 다른 마스크 토큰을 요구할 수 있으므로 다른 모델을 탐색할 때 항상 해당 마스크 토큰을 확인하는 것이 좋습니다. 이를 확인하는 한 가지 방법은 위젯에 사용된 마스크 토큰을 살펴보는 것입니다. 개체명 인식(Named entity recognition) 개체명 인식(NER, Named Entity Recognition)은 입력 텍스트에서 어느 부분이 사람, 위치 또는 조직과 같은 개체명에 해당하는지 식별하는 작업입니다. 예를 살펴보겠습니다. from transformers import pipeline ner = pipeline("ner", grouped_entities=True) ner("My name is Sylvain and I work at Hugging Face in Brooklyn.") 여기서 모델은 "Sylvain"이 사람(PER)이고 "Hugging Face"가 조직(ORG)이며 "Brooklyn"이 위치(LOC) 임을 올바르게 식별했습니다. 파이프라인 생성 함수에서 grouped_entities=True 옵션을 전달하여 파이프라인이 동일한 엔티티에 해당하는 문장의 부분(토큰 혹은 단어)들을 그룹화하도록 지시합니다. 여기서 모델은 "Hugging"과 "Face"를 단일 조직(ORG)으로 올바르게 그룹화했지만 이름 자체는 여러 단어로 구성됩니다. 사실, 다음 장에서 보게 되겠지만, 전처리 과정에서 심지어 일부 단어를 더 작은 부분으로 나눌 수도 있습니다. 예를 들어 Sylvain은 S, ##yl, ##va 및 ##in의 네 부분으로 나뉩니다. 후처리 단계에서 파이프라인은 해당 조각을 성공적으로 재그룹화했고, 그 결과로 "Sylvain"이 단일 단어로 출력되고 있습니다. 질의응답(Question Answering) question-answering 파이프라인은 주어진 컨텍스트(context) 정보를 사용하여 입력 질문에 응답을 제공합니다. from transformers import pipeline question_answerer = pipeline("question-answering") question_answerer( question="Where do I work?", context="My name is Sylvain and I work at Hugging Face in Brooklyn", ) 이 파이프라인은 제공된 컨텍스트에서 정보를 추출하여 작동합니다. 응답을 새롭게 생성하지는 않습니다. 자동 요약(Summarization) 요약(summarization)은 텍스트에 존재하는 모든(또는 대부분의) 중요한 내용을 유지하면서 해당 텍스트를 더 짧은 텍스트로 줄이는 작업입니다. 예를 살펴보겠습니다. from transformers import pipeline summarizer = pipeline("summarization") summarizer( """ America has changed dramatically during recent years. Not only has the number of graduates in traditional engineering disciplines such as mechanical, civil, electrical, chemical, and aeronautical engineering declined, but in most of the premier American universities engineering curricula now concentrate on and encourage largely the study of engineering science. As a result, there are declining offerings in engineering subjects dealing with infrastructure, the environment, and related issues, and greater concentration on high technology subjects, largely supporting increasingly complex scientific developments. While the latter is important, it should not be at the expense of more traditional engineering. Rapidly developing economies such as China and India, as well as other industrial countries in Europe and Asia, continue to encourage and advance the teaching of engineering. Both China and India, respectively, graduate six and eight times as many traditional engineers as does the United States. Other industrial countries at minimum maintain their output, while America suffers an increasingly serious decline in the number of engineering graduates and a lack of well-educated engineers. """ ) 텍스트 생성과 마찬가지로 옵션으로 결과에 대해 max_length 또는 min_length 지정이 가능합니다. 기계 번역(Translation) 번역(Translation)의 경우 작업(task) 이름에 언어 쌍(예: "translation_en_to_fr")을 지정하면 시스템에서 기본적으로 제공하는 모델(default model)을 사용할 수 있지만 가장 쉬운 방법은 Model Hub에서 사용하려는 모델을 선택하는 것입니다. 아래 예시에서 프랑스어에서 영어로 번역을 시도해 보겠습니다. from transformers import pipeline translator = pipeline("translation", model="Helsinki-NLP/opus-mt-fr-en") translator("Ce cours est produit par Hugging Face.") 텍스트 생성 및 요약과 마찬가지로 옵션으로 결과에 대해 max_length 또는 min_length 지정이 가능합니다. 지금까지 살펴본 파이프라인은 대부분 데모용입니다. 특정 작업(specific tasks)을 위해 프로그래밍되었으며 변형된 작업이나 더 복잡한 작업은 수행할 수 없습니다. 다음 섹션에서는 pipeline() 함수 내부에 어떠한 기능 및 동작들이 존재하고 그것들을 어떻게 변경할 수 있는지에 대해서 알아보겠습니다. 3. Transformers는 어떻게 동작하는가? 이 섹션에서는 Transformer 모델의 아키텍처를 개략적으로 살펴보겠습니다. Transformer의 짧은 역사 다음은 Transformer 모델의 (짧은) 역사에서 참조할 수 있는 몇 가지 주요 모델들입니다. Transformer 아키텍처는 2017년 6월에 소개되었습니다. 원래 이 아키텍처 연구의 초점은 기계번역(machine translation)이었습니다. 최초 모델이 소개된 후 다음과 같은 몇 가지 강력하고 우수한 모델들이 추가적으로 도입되었습니다. 2018년 6월: GPT, 최초의 사전 학습된(pretrained) Transformer 모델. 다양한 NLP 작업에 대한 미세 조정에 사용되었고 그 당시 많은 태스크에서 최고 성능을 달성 2018년 10월: BERT, 또 다른 대규모 사전 학습된 모델. 이 모델은 특히 고 수준의 문장 요약을 제공하도록 설계되었습니다(다음 장에서 더 자세히 설명합니다!) 2019년 2월: GPT-2, 윤리적인 문제로 인해 즉시 공개되지 않은, 기존 GPT보다 규모가 더 크고 성능이 향상된 GPT 버전 2019년 10월: DistillBERT, 속도가 60% 더 빠르고 메모리 소비는 40% 줄였지만 여전히 BERT 성능의 97%를 유지하는 증류된(distilled) BERT 버전 2019년 10월: BART 및 T5, 원래 Transformer 모델과 동일한 아키텍처를 사용하는 두 개의 대규모 사전 학습 모델(순수 Transformer 아키텍처를 사용한 최초의 사전 학습 모델) 2020년 5월: GPT-3, 미세 조정 없이도 다양한 작업을 훌륭하게 수행할 수 있는 GPT-2의 더 큰 버전으로 제로 샷 학습(zero-shot learning)이라고 함 그 외에도 다양한 사전 학습 모델이 존재하며, 이 목록은 단지 몇 가지 다른 종류의 Transformer 모델을 강조하여 설명하기 위한 것입니다. 사전 학습 모델은 대체로 다음 세 가지 범주로 그룹화할 수 있습니다: GPT-like 모델(auto-regressive Transformer 모델) BERT-like 모델(auto-encoding Transformer 모델) BART/T5-like 모델(__sequence-to_sequence __Transformer 모델) 나중에 각각의 그룹별로 좀 더 상세하게 알아볼 것입니다. Transformers는 언어 모델입니다. 위에서 언급한 모든 Transformer 모델(GPT, BERT, BART, T5 등)은 언어 모델(language model)로 학습되었습니다. 이는 그 모델들이 자가 지도(self-supervised) 학습 방식으로 많은 양의 원시 텍스트에 대해 학습되었음을 의미합니다. 자가 지도 학습(self-supervised learning)은 목적 함수(objectives)가 모델의 입력에서 자동으로 계산되는 학습 유형입니다. 즉, 사람이 데이터에 레이블을 지정할 필요가 없습니다! 이러한 유형의 모델은 학습된 언어에 대한 통계적인 이해를 가능하게 하지만 실제 태스크에는 그다지 유용하지 않습니다. 이런 이유 때문에 일반적으로 사전 학습된 모델은 전이 학습(transfer learning)이라는 프로세스를 거치게 됩니다. 이 프로세스 동안 모델은 주어진 작업에 대해 감독(supervised) 방식 즉, 사람이 주석으로 추가한 레이블을 사용함으로써 미세 조정(fine-tuning) 됩니다. 예를 들어, n 개의 이전 단어를 읽은 문장에서 다음 단어를 예측한다고 합시다. 여기서 출력할 예측값은 과거 및 현재 입력값에 의존하지만 미래 입력값에는 의존하지 않기 때문에 우리는 이것을 causal language modeling이라고 합니다. 또 다른 예는 모델이 문장에서 마스크 된 단어(masked word)를 예측하는 masked language modeling입니다. Transformers는 규모가 큰 모델입니다. 몇 가지 예외 모델(예: DistilBERT)을 제외하고, 더 나은 성능을 달성하기 위한 일반적인 전략은 모델의 크기와 사전 훈련된 데이터의 양을 늘리는 것입니다. 불행히도 사전 학습 모델(pretrained model), 특히 큰 모델을 학습하려면 많은 양의 데이터가 필요합니다. 이는 시간과 컴퓨팅 리소스 면에서 고비용을 초래합니다. 심지어 이러한 대규모 모델 학습은 다음 그래프에서 볼 수 있듯이 환경적인 문제(environmental impact)를 야기하기도 합니다. 위 그래프의 맨 아래에서 사전 학습의 환경적 영향을 줄이기 위해 의식적으로 노력하고 있는 한 연구팀에 의해서 진행되는 프로젝트에서 대규모의 사전 학습을 실행할 때 배출되는 이산화탄소의 양을 보여주고 있습니다. 최적의 하이퍼 파라미터(hyperparameter)를 얻기 위해 많은 학습 시도를 실행해야 하는 경우 탄소 발자국(carbon footprint)은 훨씬 더 높을 것입니다. 모든 연구 팀, 학생 조직 또는 회사가 자신들의 모델을 직접 처음부터 사전 학습한다고 생각해 보십시오. 이는 광범위하고 불필요한 글로벌 비용으로 이어질 것입니다! 이것이 언어 모델을 공유해야만 하는 가장 중요한 이유입니다. 학습된 가중치(weights)를<NAME>고 이미 학습된 가중치를 기반으로 미세 조정(fine-tuning) 하여 모델을 만들면 커뮤니티의 전체 컴퓨팅 비용과 탄소 발자국(carbon footprint)을 줄일 수 있습니다. 전이 학습(Transfer Learning) 사전 학습(Pretraining)은 모델을 처음부터 학습하는 작업입니다. 모델의 가중치(weight)는 무작위로 초기화되고, 사전 지식(prior knowledge)이 없이 학습이 시작됩니다. 이 사전 학습(pretraining)은 일반적으로 매우 많은 양의 데이터가 필요합니다. 따라서 매우 큰 규모의 데이터 코퍼스(corpus)가 필요하며 학습에는 최대 몇 주가 소요될 수 있습니다. 반면에, 미세 조정(fine-tuning)은 모델이 사전 학습된 후에 수행되는 학습입니다. 미세 조정(fine-tuning)을 수행하려면 먼저 사전 학습된 언어 모델(pretrained language model)을 확보한 다음, 특정 태스크에 맞는 데이터 셋(dataset)을 사용하여 추가 학습을 수행합니다. 잠깐만요! 최종 태스크(task)를 위해 처음부터 직접 학습하지 않는 이유는 무엇일까요? 몇 가지 이유가 있습니다. 사전 학습된 모델(pretrained model)은 미세 조정(fine-tuning)에 사용할 데이터 셋과 유사한 데이터를 바탕으로 이미 학습되었습니다. 따라서, 미세 조정(fine-tuning) 과정에서, 사전 학습 과정에서 얻은 지식을 활용할 수 있습니다. (예를 들어, NLP 문제의 경우 사전 학습된 모델은 원하는 태스크에 사용하는 언어에 대한 일종의 통계적 이해를 갖게 됩니다.) 사전 학습된 모델은 이미 많은 데이터에 대해 학습되었기 때문에 미세 조정 과정에서 훨씬 적은 데이터 셋을 이용하더라도 좋은 결과를 얻을 수 있습니다. 같은 이유로, 좋은 결과를 얻는 데 필요한 시간과 자원은 훨씬 적을 수 있습니다. 예를 들어, 영어로 사전 학습된 모델을 가지고, arXiv 말뭉치에서 미세 조정(fine-tuning) 하여 과학/연구(science/research) 분야 데이터에 특화된 모델을 만들 수 있습니다. 미세 조정(fine-tuning)에는 제한된 양의 데이터만 필요합니다. 사전 학습된 모델이 획득한 지식은 "전이(transferred)"되므로 전이 학습(transfer learning)이라는 용어를 사용합니다. 따라서 모델을 미세 조정(fine-tuning) 하면 시간(time), 데이터(data), 재정(financial) 및 환경(environmental) 비용이 절감됩니다. 또한 학습 과정이 전체 사전 훈련(pretraining)보다 제약이 적기 때문에, 보다 쉽고 빠르게 다양한 미세 조정 작업을 반복할 수 있습니다. 또한, 만일 본인이 원하는 최종 태스크에 필요한 데이터가 충분치 않을 경우, 미세 조정(fine-tuning) 과정에서 처음부터 학습하는 방법보다 더 나은 결과를 얻을 수 있습니다. 따라서 항상 사전 학습된 모델을 활용하고 이를 미세 조정하려고 노력해야 합니다. 일반적인 아키텍처 여기서는 Transformer 모델의 일반적인 아키텍처를 살펴보겠습니다. 일부 개념을 이해하지 못하더라도 걱정하지 마십시오. 나중에 각 구성 요소를 자세히 다루는 섹션(section)이 있습니다. 개요 (Introduction) 모델은 주로 두 개의 블록으로 구성됩니다. 인코더(Encoder) (왼쪽): 인코더는 입력에 대한 표현(representation) 혹은 자질(feature)을 도출합니다. 이는 모델이 입력으로부터 이해를 얻도록(acquire understanding from the input), 다시 말해서, 최종 목적 태스크를 위해서 입력에 대한 표현 형태가 최적화되었음을 의미합니다. 디코더(Decoder) (오른쪽): 디코더는 인코더가 구성한 표현(representation) 혹은 자질(feature)을 다른 입력과 함께 사용하여 대상 시퀀스를 생성합니다. 이는 모델이 출력 생성(generating outputs)에 최적화되어 있음을 의미합니다. 이들 각각의 블록은 작업의 종류에 따라 개별적으로 사용할 수도 있습니다. 인코더 전용 모델(Encoder-only models): 문장 분류(sentence classification) 및 개체명 인식(named-entity recognition)과 같이 입력에 대한 분석 및 이해(understanding)가 필요한 태스크에 적합합니다. 디코더 전용 모델(Decoder-only models): 텍스트 생성(text generation) 등과 같은 생성 태스크(generative tasks)에 좋습니다. 인코더-디코더 모델(Encoder-Decoder models) 혹은 시퀀스-투-시퀀스 모델(sequence-to-sequence model): 번역(translation)이나 요약(summarization)과 같이 입력이 수반되는 생성 태스크(generative tasks)에 적합합니다. 이러한 아키텍처는 이후 섹션에서 개별적으로 자세히 살펴보겠습니다. 어텐션 계층 (Attention layers) Transformer 모델의 가장 중요한 특징은 어텐션 레이어(attention layers)라는 특수 레이어로 구축된다는 것입니다. 사실, Transformer 아키텍처를 소개하는 논문의 제목이 "Attention Is All You Need"였습니다! 이 강좌의 뒷부분에서 어텐션 레이어(attention layer)에 대한 상세한 내용을 살펴볼 것입니다. 그러나 현재는 이 레이어가 각 단어의 표현을 처리할 때, 문장의 특정 단어들에 특별한 주의를 기울이고 나머지는 거의 무시하도록 모델에 지시할 것이라는 점만 알면 됩니다. 이것을 상황에 맞게 설명하기 위해서, 영어로 된 텍스트를 프랑스어로 번역하는 작업을 고려해 봅시다. "You like this course"라는 입력이 주어지면 번역 모델은 "like"라는 단어에 대한 적절한 번역을 얻기 위해 인접 단어 "You"에도 주의를 기울여야 합니다. 왜냐하면 프랑스어에서 동사 "like"는 주어(subject)에 따라 다르게 활용되기 때문입니다. 그러나 문장의 나머지 부분("this course")은 해당 단어("like")의 번역에 그다지 유용하지 않습니다. 같은 맥락에서, "this"를 번역할 때, 모델은 "course"라는 단어에도 주의를 기울여야 합니다. "this"는 연결된 명사가 남성(masculine)인지 여성(feminine)인지에 따라 다르게 번역되기 때문입니다. 위와 마찬가지로, 문장의 다른 단어들("You", "like")은 "this"의 번역에 중요하지 않습니다. 더 복잡한 문장이나 더 복잡한 문법 규칙의 경우, 모델은 개별 단어를 적절하게 번역하기 위해 문장에서 해당 단어와 멀리 떨어진 단어에도 특별한 주의를 기울여야 합니다. 동일한 개념이 자연어와 관련된 모든 태스크에 적용될 수 있습니다. 단어 자체가 고유한 의미를 가지고 있지만 그 의미는 주변 문맥, 즉 컨텍스트(context)에 의해 크게 영향을 받으며, 컨텍스트는 처리 중인 단어 앞이나 뒤에 존재하는 다른 단어들을 포함할 수 있습니다. 어텐션 레이어(attention layer)가 무엇인지 이해했으므로 이제 Transformer 아키텍처를 자세히 살펴보겠습니다. 오리지널 아키텍처 Transformer 아키텍처는 원래 번역용으로 설계되었습니다. 학습이 진행되는 동안 인코더(encoder)는 특정 언어로 표기된 입력(문장)을 수신하고 디코더(decoder)는 원하는 대상 언어로 표기된 동일한 의미의 문장을 수신합니다. 인코더에서 어텐션 레이어(attention layer)는 문장의 모든 단어에 주의(attention)를 기울여야 합니다. 왜냐하면, 우리가 방금 보았듯이 현재 단어에 대한 번역 결과는 문장에서 해당 단어의 앞부분과 뒷부분의 내용에 따라 달라질 수 있기 때문입니다. 그러나 디코더는 순차적으로 작동하며 이미 번역된 문장의 단어들에만, 즉 현재 생성되고 있는 단어 앞의 단어들에만 주의(attention)를 기울일 수 있습니다. 예를 들어, 번역 대상(target sentence)의 처음 세 단어를 예측한 경우, 디코더에 이를 입력한 다음 인코더의 모든 입력(원본 문장의 모든 단어들)을 사용하여 네 번째 단어를 예측하려고 시도합니다. 학습 도중 속도를 높이기 위해, 디코더(decoder)는 전체 대상 문장(target sentences)을 입력으로 받지만, 이 중에서 미래 단어(현재 디코딩 대상 단어의 이후에 나타나는 단어들)를 사용하는 것은 허용되지 않습니다. 두 번째 위치에 나타나는 단어를 예측하려고 할 때, 두 번째 위치의 정답 단어를 바로 접근할 수 있다면 학습이 제대로 진행되지 않을 것입니다. 예를 들어, 네 번째 단어를 예측하려고 할 때 어텐션 계층은 첫 번째에서 세 번째까지의 단어들에만 주의를 집중할 수 있습니다. 원래 Transformer 아키텍처는 왼쪽에 인코더가 있고 오른쪽에 디코더가 있는 형태로 다음 그림과 같습니다: 디코더(decoder) 블록의 첫 번째 어텐션 계층(attention layer)은 디코더(decoder)에 대한 모든 (과거) 입력에 주의를 집중하지만, 두 번째 어텐션 계층은 인코더의 출력을 입력으로 받아서 사용하고 있음을 알 수 있습니다. 따라서 현재 단어를 가장 잘 예측하기 위해 전체 입력 문장(input/source sentence)에 액세스할 수 있습니다. 이것은 대상 언어(target language)가 원본 언어(source language)와 비교하여 상당히 다른 단어 순서(words in different orders)로 문장을 표현하는 문법 규칙(grammatical rule)을 가지거나, 원본 문장(input/source sentence)의 뒷부분에 나타난 컨텍스트(context)가 현재 단어에 대한 최상의 번역을 결정하는 데 도움이 될 수 있는 경우 매우 유용합니다. 어텐션 마스크(Attention mask)는 인코더/디코더에서 모델이 특정 단어에 주의를 집중하는 것을 방지하는 데 사용할 수 있습니다. 예를 들어, 문장을 일괄 처리(batching) 할 때 모든 입력을 동일한 길이로 만들기 위해서 사용되는 특수 패딩 단어(padding word)에 적용할 수 있습니다. 아키텍처(architectures) vs. 체크포인트(checkpoints) 이 강좌에서 향후 Transformer 모델에 대해 공부하면서 아키텍처(architecture) 와 체크포인트(checkpoint), 그리고 모델(model)이라는 용어를 자주 접하게 될 것입니다. 이 용어들은 각각 서로 다른 다른 의미를 가집니다. 아키텍처(Architectures): 이 용어는 모델의 뼈대(skeleton)를 의미합니다. 모델 내에서 발생하는 각 레이어(layer)와 오퍼레이션(operation, 연산) 등을 정의합니다. 체크포인트(Checkpoints): 해당 아키텍처에서 로드될 가중치 값들을 나타냅니다. 모델(Model): 이것은 "아키텍처(architecture)" 또는 "체크포인트(checkpoint)"보다는 덜 명확한 포괄적인 용어(umbrella term)입니다. 두 가지 모두를 의미할 수도 있습니다. 본 강좌에서는 표기의 명확성이 필요할 경우 모델이라는 용어보다는 아키텍처(architecture) 또는 체크포인트(checkpoint)를 주로 사용할 것입니다. 예를 들어, BERT는 아키텍처(architecture)이고 BERT의 첫 번째 릴리스를 위해 Google 팀에서 학습한 가중치 세트(set of weights)인 bert-base-cased는 체크포인트(checkpoint)입니다. 하지만, "BERT 모델(BERT model)"과 "bert-base-cased"도 모델이라고 말할 수도 있습니다. 4. 인코더 모델 (Encoder Models) 인코더 모델(encoder models)은 Transformers 모델의 인코더 모듈만 사용합니다. 각 단계에서 어텐션 계층(attention layer)은 초기/원본 입력 문장(initial sentence)의 모든 단어에 액세스할 수 있습니다. 이러한 모델은 종종 "양방향(bi-directional)" 주의 집중(attention)을 수행하는 것이 특징이며, auto-encoding model이라고 부르기도 합니다. 이러한 모델의 사전 학습(pretraining) 과정에서 일반적으로 주어진 초기 문장을 다양한 방법을 사용하여 손상시키고(예: 임의의 단어를 masking 하여), 손상시킨 문장을 다시 원래 문장으로 복원하는 과정을 통해서 모델 학습이 진행됩니다. 인코더 모델(encoder models)은 문장 분류(sentence classification), 개체명 인식(named-entity recognition), 혹은 더 일반적으로 단어 분류(word classification) 및 추출형 질의응답(extractive question answering) 등과 같이 전체 문장에 대한 이해가 필요한 작업(task)에 가장 적합합니다. 대표적으로 다음과 같은 모델이 있습니다: ALBERT BERT DistilBERT ELECTRA RoBERTa 5. 디코더 모델 (Decoder Models) 디코더 모델(decoder models)은 Transformer 모델의 디코더 모듈만 사용합니다. 각 단계에서 주어진 단어에 대해 어텐션 레이어(attention layer)는 문장에서 현재 처리 단어 앞쪽에 위치한 단어들에만 액세스할 수 있습니다. 이러한 모델을 일반적으로 자동 회귀 모델(auto-regressive models)이라고 합니다. 디코더 모델(decoder models)의 사전 학습(pretraining)은 일반적으로 문장의 다음 단어 예측을 수행함으로써 이루어집니다. 이러한 모델은 텍스트 생성(text generation)과 관련된 작업(task)에 가장 적합합니다. 대표적인 모델로는 다음과 같습니다: CTRL GPT GPT-2 Transformer XL 6. 인코더-디코더 모델 (Sequence-to-sequence models) 인코더-디코더 모델(sequence-to-sequence 모델이라고도 함)은 Transformer 아키텍처의 두 부분, 즉 인코더(encoder)와 디코더(decoder) 모두를 사용합니다. 각 단계에서 어텐션 계층(attention layer)은 초기/원본 입력 문장(initial sentence)의 모든 단어에 액세스할 수 있는 반면, 디코더의 어텐션 레이어(attention layer)는 문장에서 현재 처리 단어 앞쪽에 위치한 단어들에만 액세스할 수 있습니다. 이러한 모델의 사전 학습(pretraining)은 인코더 또는 디코더 모델의 목적 함수(objectives)를 사용하여 수행될 수 있지만 일반적으로 약간 더 복잡한 처리 과정이 수반됩니다. 예를 들어, T5는 임의의 텍스트 일부분(text span, 여러 단어를 포함할 수 있음)을 하나의 마스크 특수 단어(mask special word)로 대체하여 사전 학습되며, 학습 목표(objective)는 이 마스크 단어가 대체할 텍스트를 예측하는 것입니다. Sequence-to-sequence 모델은 요약(summarization), 번역(translation) 또는 생성형 질의응답(generative question answering) 등과 같이 주어진 입력에 따라 새로운 문장을 생성하는 작업(task)에 가장 적합합니다. 대표적으로 다음과 같은 모델이 있습니다: BART mBART Marian T5 7. 편견과 한계 (Bias and Limitations) 만일 사전 학습된 모델이나 미세 조정된 모델을 상용 시스템에서 사용하려는 경우, 제약 사항(limitations)이 존재한다는 것을 유의해야 합니다. 그중에서 가장 크게 이슈가 될 수 있는 사실은 대용량 데이터에 대해서 사전 학습을 수행하기 위해, 인터넷에 존재하는 좋은 데이터는 물론 최악의 데이터들도 무조건 수집하여 활용한다는 것입니다. 이에 대한 빠른 설명을 위해 BERT 모델을 활용한 fill-mask 파이프라인의 예를 다시 살펴보겠습니다. from transformers import pipeline unmasker = pipeline("fill-mask", model="bert-base-uncased") result = unmasker("This man works as a [MASK].") print([r["token_str"] for r in result]) result = unmasker("This woman works as a [MASK].") print([r["token_str"] for r in result]) 위 두 문장에서 누락된 단어를 채우라는 요청을 받았을 때 모델은 성별과 상관없는(gender-free) 대답(waiter/waitress)은 오직 하나만 제공합니다. 나머지는 일반적으로 특정 성별과 밀접한 관련이 있는 직업들입니다. 그리고 매춘부(prostitute)는 모델이 "여성" 및 "직업"과 연관되는 상위 5개 단어에 속해 있습니다. 이러한 현상은 BERT가 인터넷 전체에서 데이터를 수집하여 학습된 것이 아니라, 오히려 중립적인 데이터 즉, English Wikipedia 와 BookCorpus를 사용하여 학습된 드문 Transformer 모델 중 하나임에도 불구하고 발생합니다. 8. 1장 요약 (Summary) 이 장에서는 Transformers의 고수준(high-level) pipeline() 함수를 사용하여 다양한 NLP 작업을 수행하는 방법을 살펴보았습니다. 또한 허브에서 모델을 검색하고 사용하는 방법과 Inference API를 사용하여 브라우저에서 직접 모델을 테스트하는 방법을 알아봤습니다. 우리는 또한 Transformer 모델이 고수준(high-level)에서 어떻게 작동하는지 논의하고 전이 학습(transfer learning)과 미세 조정(fine-tuning)의 중요성에 대해 이야기했습니다. 가장 중요한 핵심은 대상 작업의 종류에 따라 전체 아키텍처(full architecture)를 사용하거나 인코더(encoder) 또는 디코더(decoder)만 사용할 수 있다는 것입니다. 다음 표는 이를 요약한 것입니다. 모델 예시 태스크(Tasks) 인코더(Encoder) ALBERT, BERT, DistilBERT, ELECTRA, RoBERTa 문장 분류(sentence classification), 개체 명인식(named-entity recognition), 추출형 질의응답(extractive question answering) 디코더(Decoder) CTRL, GPT, GPT-2, Transformer-XL 텍스트 생성(Text generation) 인코더-디코더(Encoder-Decoder) BART, T5, Marian, mBART 요약(summarization), 번역(translation), 생성형 질의응답(generative question answering) 2장. Transformers 라이브러리 사용하기 1장에서 보았듯이 Transformer 모델은 일반적으로 규모가 매우 큽니다. 수백만에서 수천억 개의 매개변수가 포함된 모델을 학습하고 배포하는 일은 매우 복잡한 작업입니다. 게다가 새로운 모델이 거의 매일 출시되고 각각 고유한 구현 방식이 있기 때문에, 이 모든 모델들을 시험해 보는 것 또한 쉬운 일이 아닙니다. Transformers 라이브러리는 이러한 문제를 해결하기 위해 만들어졌습니다. 이 라이브러리의 목표는 모든 Transformer 모델들을 적재하고, 학습하고, 저장할 수 있는 단일 API를 제공하는 것입니다. Transformers 라이브러리의 특징은 다음과 같습니다. 사용 용이성(Ease of use): 최신 NLP 모델을 기반으로 추론 작업을 수행하기 위해서, 해당 모델을 다운로드, 적재 및 사용하는데 단 두 줄의 코드만 작성하면 됩니다. 유연성(Flexibility): 기본적으로 모든 모델은 PyTorch의 nn.Module 또는 TensorFlow의 tf.keras.Model 클래스로 표현되며 각 기계 학습(ML) 프레임워크(framework, e.g., PyTorch, Tensorflow) 내에서의 다른 모델들과 동일하게 취급됩니다. 단순성(Simplicity): 라이브러리 전체에서 추상화(abstraction)가 거의 이루어지지 않습니다. "All in one file"은 Transformers 라이브러리의 핵심 개념입니다. 다시 말해서, 모델의 순전파(forward pass)가 단일 파일에 완전히 정의되어 해당 코드 자체를 쉽게 이해하고 해킹할 수 있습니다. 이 마지막 특징은 Transformers 라이브러리가 다른 기계학습 라이브러리와 구별되는 차별성입니다. 모든 모델은 파일 간에 공유되는 모듈에 기반하여 구현되지 않습니다. 대신 각 모델에는 자체 레이어가 있습니다. 모델을 더 접근하기 쉽고 이해하기 쉽게 만드는 것 외에도, 다른 모델에 영향을 주지 않고 특정 모델에서 쉽게 실험을 진행할 수 있습니다. 이번 장에서는 1장에서 소개한 pipeline() 함수를 대체하기 위해, 직접 모델(model)과 토크 나이저(tokenizer)를 함께 사용하는 종단 간(end-to-end) 예제를 가지고 이번 장을 시작합니다. 다음으로 모델 API에 대해 설명합니다. 모델 클래스 및 설정(configuration) 클래스를 자세히 살펴보고, 모델을 로드하는 방법과 모델이 예측(prediction)을 출력하기 위해 수치적 입력(numerical input)을 처리하는 방법을 알아보겠습니다. 그런 다음, pipeline() 함수의 또 다른 주요 구성 요소인 토크 나이저(tokenizer) API를 살펴보겠습니다. 토크 나이저는 신경망 모델의 입력으로 사용하기 위해서 텍스트 입력을 수치 데이터(numerical data)로 변환하고, 필요시 변환된 수치 데이터를 다시 텍스트로 변환하는 기능을 수행할 수 있습니다. 어떻게 보면, 전체 프로세스의 처음과 마지막을 담당한다고 할 수 있겠습니다. 마지막으로, 배치(batch) 형태로 여러 문장들을 모델로 한꺼번에 입력하는 방법을 알아보고, 상위 수준의 tokenizer() 함수를 자세히 살펴봄으로써 이번 장을 마무리합니다. ⚠ Model Hub 및 Transformers에서 제공되는 모든 기능을 활용하려면 계정을 만드는 것이 좋습니다. 1. Pipeline 내부 실행 과정 본 한글 강좌는 기본적으로 PyTorch를 사용한다고 가정합니다. 이제 완전한 예제로 시작합니다. 우선, 1장에서 다음 코드를 실행했을 때 내부적으로 무슨 일이 일어났는지 살펴보겠습니다. from transformers import pipeline classifier = pipeline("sentiment-analysis") classifier( [ "I've been waiting for a HuggingFace course my whole life.", "I hate this so much!", ] ) 1장에서 보았듯이 이 파이프라인은 전처리(preprocessing), 모델로 입력 전달 및 후처리(postprocessing)의 3단계를 한 번에 실행합니다. 이들 각각에 대해 빠르게 살펴보겠습니다. 토크 나이저를 이용한 전처리 다른 신경망(neural networks)과 마찬가지로 Transformer 모델은 원시 텍스트를 직접 처리할 수 없으므로 파이프라인의 첫 번째 단계는 텍스트 입력을 모델이 이해할 수 있는 숫자로 변환하는 것입니다. 이를 위해, 다음 기능들을 수행하는 토크 나이저(tokenizer)를 사용합니다: 입력을 토큰(token)이라고 부르는 단어(word), 하위 단어(subword) 또는 기호(symbol)(예: 구두점)로 분할 각 토큰(token)을 정수(integer)로 매핑(mapping) 모델에 유용할 수 있는 부가적인 입력(additional inputs)을 추가 이 모든 전처리(preprocessing)는 모델이 사전 학습(pretraining) 될 때와 정확히 동일한 방식으로 수행되어야 하므로 먼저 Model Hub에서 해당 정보를 다운로드해야 합니다. 이를 위해 AutoTokenizer 클래스와 from_pretrained() 메서드를 사용합니다. 모델의 체크포인트(checkpoint) 이름을 사용하여 모델의 토크 나이저(tokenizer)와 연결된 데이터를 자동으로 가져와 캐시 합니다. 따라서, 아래 코드를 처음 실행할 때만 해당 정보가 다운로드됩니다. sentiment-analysis 파이프라인의 디폴트 체크포인트(default checkpoint)는 distilbert-base-uncased-finetuned-sst-2-english(이 모델에 대한 model card는 여기에서 확인 가능합니다)이므로 다음을 실행합니다. from transformers import AutoTokenizer checkpoint = "distilbert-base-uncased-finetuned-sst-2-english" tokenizer = AutoTokenizer.from_pretrained(checkpoint) 일단 위와 같이 토크 나이저(tokenizer)를 생성하면, 아래의 코드에서 보는 것처럼, 이 토크 나이저에 문장을 입력하여 모델에 바로 전달할 수 있는 파이썬 딕셔너리(dictionary) 정보를 구할 수 있습니다! 이후 해야 할 일은 input IDs 리스트를 텐서(tensors)로 변환하는 것뿐입니다. 여러분들은 PyTorch, TensorFlow 또는 Flax 등, 이들 중 어떤 ML 프레임워크가 백엔드(backend)로 사용되는지 걱정할 필요가 없이 Transformers를 마음대로 사용할 수 있습니다. 그러나 Transformer 모델은 텐서(tensor) 입력만 받습니다. 만일 여러분이 텐서(tensor)에 대해 처음 접한다면, NumPy 배열(array)을 생각하면 됩니다. NumPy 배열은 스칼라(0D), 벡터(1D), 행렬(2D) 혹은 더 많은 차원을 가질 수 있습니다. 이것은 사실상 텐서입니다. 다른 기계학습 프레임워크의 텐서도 비슷하게 동작하며, 일반적으로 NumPy 배열만큼 간단하게 생성(instantiate) 할 수 있습니다. 토크 나이저가 반환하는 텐서의 유형(PyTorch, TensorFlow 또는 일반 NumPy)을 지정하려면 return_tensors 인수(argument)를 사용하면 됩니다. raw_inputs = [ "I've been waiting for a HuggingFace course my whole life.", "I hate this so much!", ] inputs = tokenizer(raw_inputs, padding=True, truncation=True, return_tensors="pt") print(inputs) 아직 패딩(padding)과 truncation에 대해 신경 쓰지 마세요. 나중에 설명하겠습니다. 여기서 기억해야 할 주요 사항은 단일 문장 또는 다중 문장 리스트를 토크 나이저 함수로 전달할 수 있을 뿐만 아니라 출력 텐서 유형을 지정할 수 있다는 것입니다. 텐서 유형이 지정되지 않으면 결과로 이중 리스트(list of list)가 표시됩니다. PyTorch 텐서 유형의 결과는 위와 같습니다. 위 결과에서 보듯이, 출력은 두 개의 키(key) 즉, input_ids 및 attention_mask를 가지는 파이썬 딕셔너리입니다. input_ids에는 각 문장에 있는 토큰의 고유 식별자로 구성된 두 행의 정수(각 문장에 하나씩)가 값(value)으로 들어가 있습니다. 이 장의 뒷부분에서 attention_mask 가 무엇인지 설명합니다. 모델 살펴보기 토크 나이저와 동일한 방식으로 사전 학습된 모델(pretrained model)을 다운로드할 수 있습니다. Transformers는 위의 AutoTokenizer 클래스와 마찬가지로, from_pretrained() 메서드가 포함된 AutoModel 클래스를 제공합니다. from transformers import AutoModel checkpoint = "distilbert-base-uncased-finetuned-sst-2-english" model = AutoModel.from_pretrained(checkpoint) 위 코드 스니펫(code snippet)에서는 이전에 파이프라인에서 사용한 것과 동일한 체크포인트를 다운로드하고(실제로 이미 캐시 되어 있어야 함) 모델을 인스턴스화(instantiate) 했습니다. 해당 아키텍처에는 기본 Transformer 모듈만 포함되어 있습니다. 따라서, 입력이 주어지면 자질(feature)이라고도 불리는 hidden states를 출력합니다. 각 모델 입력에 대해 Transformer 모델에 의해서 수행된 해당 입력의 문맥적 이해(contextual understanding) 결과를 나타내는 고차원 벡터(high-dimensional vector)를 가져옵니다. 이 부분이 이해가 가지 않더라도 걱정하지 마세요. 나중에 모두 설명하겠습니다. 이러한 hidden states는 그 자체로도 유용할 수 있지만 일반적으로 head라고 알려진 모델의 다른 부분에 대한 입력으로 들어갑니다. 1장에서, 동일한 아키텍처로 서로 다른 태스크(task)를 수행할 수 있었지만 이러한 각 태스크(task)에는 서로 다른 헤드(head)가 연결되어 있습니다. 고차원 벡터? Transformer 모듈의 벡터 출력은 일반적으로 규모가 큽니다. 일반적으로 세 가지 차원이 있습니다: 배치 크기(Batch size): 한 번에 처리되는 시퀀스(sequence)의 개수(위의 예제에서는 2개). 시퀀스 길이(Sequence length): 시퀀스 숫자 표현의 길이(이 예에서는 16). 은닉 크기(Hidden size): 각 모델 입력의 벡터 차원. 위에서 마지막 값 때문에 "고차원(high-dimensional)" 벡터라고 나타냅니다. Hidden size는 매우 클 수 있습니다(768은 작은 모델에 일반적이고 큰 모델에서는 3072 이상일 수도 있음). 사전 처리한 입력을 모델에 넘기면 다음과 같은 내용을 볼 수 있습니다. outputs = model(**inputs) print(outputs.last_hidden_state.shape) Transformers 모델의 출력은 namedtuple 또는 딕셔너리(dictionary)처럼 동작합니다. 요소에 접근하기 위해서 속성 또는 키(outputs["last_hidden_state"])를 사용할 수 있습니다. 또한, 찾고 있는 항목이 어디에 있는지 정확히 알고 있는 경우 인덱스(outputs[0])로도 액세스할 수 있습니다. 모델 헤드(model heads): 숫자 이해하기 모델 헤드(model head)는 hidden states의 고차원 벡터(high-dimensional vector)를 입력으로 받아 다른 차원에 투영(project) 합니다. 일반적으로 헤드(head)는 하나 또는 몇 개의 선형 레이어(linear layers)로 구성됩니다. Transformer 모델의 출력은 처리할 모델 헤드(model head)로 직접 전달됩니다. 위 그림에서 모델은 임베딩 레이어(embeddings layer)와 후속 레이어(subsequent layers)로 표현됩니다. 임베딩 레이어(embeddings layer)는 토큰화된 입력(tokenized input)의 각 입력 ID를 해당 토큰을 나타내는 벡터(embeddings vector)로 변환합니다. 그 이후의 후속 레이어는 주의 메커니즘(attention mechanism)을 사용하여 이들 임베딩 벡터(embeddings vector)를 조작하여 문장의 최종 표현(final representation)을 생성합니다. Transformers에는 다양한 아키텍처가 있으며 각 아키텍처는 특화된 작업을 처리하도록 설계되었습니다. 다음은 일부 아키텍처를 보여주고 있습니다: *Model (hidden states를 리턴) *ForCausalLM *ForMaskedLM *ForMultipleChoice *ForQuestionAnswering *ForSequenceClassification *ForTokenClassification and others 이 섹션에서의 예시에서는 시퀀스 분류 헤드(sequence classification head)가 포함되어 있는 모델이 필요합니다(문장을 긍정 또는 부정으로 분류하기 위해서). 따라서 실제로 AutoModel 클래스를 사용하지 않고 대신 AutoModelForSequenceClassification를 사용합니다: from transformers import AutoModelForSequenceClassification checkpoint = "distilbert-base-uncased-finetuned-sst-2-english" model = AutoModelForSequenceClassification.from_pretrained(checkpoint) outputs = model(**inputs) 이제 출력의 모양(shape)을 보면 차원이 훨씬 낮아집니다. 모델 헤드(model head)는 고차원 벡터를 입력으로 사용하고 두 개의 값(레이블당 하나씩)을 포함하는 벡터를 출력합니다. print(outputs.logits.shape) 두 개의 문장과 두 개의 레이블만 있기 때문에, 모델에서 얻은 결과의 모양(shape)은 2 x 2입니다. 출력 후처리하기 모델에서 출력으로 얻은 값은 반드시 그 자체로 의미가 있는 것은 아닙니다. 다음을 한번 보시지요. print(outputs.logits) 우리 모델은 첫 번째 문장에 대해 [-1.5607, 1.6123], 두 번째 문장에 대해 [4.1692, -3.3464]를 예측했습니다. 이는 확률이 아니라 모델의 마지막 계층에서 출력된 정규화되지 않은 원시 점수인 logits입니다. 이들 값을 확률로 변환하려면 SoftMax 계층을 통과해야 합니다. 모든 Transformers 모델은 이 logits 값을 출력합니다. 그 이유는 일반적으로 학습을 위한 손실 함수(loss function)는 최종 활성화 함수(activation function, e.g., SoftMax)와 실제 손실 함수(actual loss function, e.g., cross entropy)를 모두 사용하여 구현되기 때문입니다. import torch predictions = torch.nn.functional.softmax(outputs.logits, dim=-1) print(predictions) 이제 모델이 첫 번째 문장에 대해 [0.0402, 0.9598], 두 번째 문장에 대해 [0.9995, 0.0005]를 예측했음을 알 수 있습니다. 이들은 우리가 이해할 수 있는 확률 점수입니다. 각 위치에 해당하는 레이블을 가져오기 위해, model.config의 id2label 속성값을 확인합니다. 더 자세한 내용은 다음 섹션에서 다룹니다. model.config.id2label 이제 모델이 아래 내용을 예측했다는 결론을 내릴 수 있습니다: 첫 번째 문장 : NEGATIVE: 0.0402, POSITIVE: 0.9598 두 번째 문장 : NEGATIVE: 0.9995, POSITIVE: 0.0005 지금까지 파이프라인(pipeline)의 내부에서 실행되는 3단계인 토크 나이저를 사용한 전처리(preprocessing), 모델을 통한 입력 전달(passing the inputs through the model) 및 후처리(postprocessing)를 성공적으로 실행해 봤습니다. ✏ Try it out! 본인이 가지고 있는 텍스트를 두 개(또는 그 이상) 선택하고 sentiment analysis 파이프라인을 통해 실행해 봅시다. 그런 다음 여기에서 설명한 대로 직접 실행해 보고, 동일한 결과를 얻는지 확인해 보세요! 2. 모델 (Models) 이 섹션에서는 모델을 생성하고 사용하는 방법을 자세히 살펴보겠습니다. 이를 위해, 우리는 지정된 체크포인트(checkpoint)를 바탕으로 모델을 인스턴스화할 때 편리한 AutoModel 클래스를 사용할 것입니다. AutoModel 클래스와 이와 관련된 모든 항목들은 실제로 라이브러리에서 사용할 수 있는 다양한 모델에 대한 단순한 래퍼(wrapper)입니다. 당신이 선택한 체크포인트(checkpoint)에 적합한 모델 아키텍처(model architecture)를 자동으로 추측한 다음 이 아키텍처로 모델을 인스턴스화할 수 있으므로 영리한 래퍼(wrapper)라고 볼 수 있겠지요. 그러나 사용하려는 모델의 유형을 알고 있다면 해당 아키텍처를 직접 정의하는 클래스를 사용할 수도 있습니다. 이것이 BERT 모델과 함께 어떻게 작동하는지 살펴보겠습니다. 트랜스포머 모델 생성하기 BERT 모델을 초기화하기 위해 가장 먼저 해야 할 일은 설정(configuration) 객체를 로드하는 것입니다: from transformers import BertConfig, BertModel # config(설정)을 만듭니다. config = BertConfig() # 해당 config에서 모델을 생성합니다. model = BertModel(config) 이 설정(configuration) 객체에는 모델을 빌드 하는데 필요한 많은 속성이 포함되어 있습니다: print(config) BertConfig { "attention_probs_dropout_prob": 0.1, "classifier_dropout": null, "hidden_act": "gelu", "hidden_dropout_prob": 0.1, "hidden_size": 768, "initializer_range": 0.02, "intermediate_size": 3072, "layer_norm_eps": 1e-12, "max_position_embeddings": 512, "model_type": "bert", "num_attention_heads": 12, "num_hidden_layers": 12, "pad_token_id": 0, "position_embedding_type": "absolute", "transformers_version": "4.12.5", "type_vocab_size": 2, "use_cache": true, "vocab_size": 30522 } 아직 이 모든 속성들이 담당하는 일들을 살펴보지는 않았지만, 그중 일부는 이미 알 수도 있을 겁니다. hidden_size 속성은 hidden_states 벡터의 크기를 정의하고 num_hidden_layers는 Transformer 모델의 계층(layers) 수를 정의합니다. 다른 로딩 메서드들(loading methods) 기본 설정(configuration)에서 모델을 생성하면 해당 모델을 임의의 값으로 초기화합니다. from transformers import BertConfig, BertModel config = BertConfig() model = BertModel(config) # 모델은 무작위로 초기화됩니다. 이 상태에서 모델을 바로 사용할 수도 있겠지만 해당 출력은 그야말로 횡설수설입니다. 따라서 먼저 학습을 해야 합니다. 우리가 수행해야 할 작업(task)을 위해서 모델을 처음부터(from scratch) 학습할 수도 있지만, 1장에서 보았듯이 이를 위해서는 오랜 실행 시간과 많은 데이터가 필요하며 게다가 환경에 미치는 영향은 무시할 수 없습니다. 불필요하고 중복되는 노력을 피하기 위해서는 이미 학습된 모델을<NAME>고 재사용할 수 있어야 합니다. 이미 사전 학습된 Transformer 모델을 로드하는 것은 간단합니다. from_pretrained() 메서드를 사용하여 이 작업을 수행할 수 있습니다: from transformers import BertModel model = BertModel.from_pretrained("bert-base-cased") Some weights of the model checkpoint at bert-base-cased were not used when initializing BertModel: ['cls.predictions.bias', 'cls.seq_relationship.weight', 'cls.predictions.decoder.weight', 'cls.predictions.transform.dense.bias', 'cls.predictions.transform.LayerNorm.bias', 'cls.seq_relationship.bias', 'cls.predictions.transform.LayerNorm.weight', 'cls.predictions.transform.dense.weight'] - This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model). - This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model). 앞서 보았듯이, BertModel을 동일한 기능을 수행하는 AutoModel 클래스로 대체할 수 있습니다. 이렇게 하면 체크포인트(checkpoint)에 구애받지 않는 코드를 구현할 수 있으므로 지금부터 이 클래스를 사용합니다. 이 코드가 특정 체크포인트에서 작동한다면 다른 체크포인트에서도 원활하게 작동해야 합니다. 이는 심지어 모델의 아키텍처(architecture)가 다르더라도, 변경할 체크포인트가 현재 체크포인트와 유사한 작업(task), 예를 들어, 감성 분석 태스크(sentiment analysis task)로 학습되었다면 변경이 가능해야 합니다. 위의 코드 샘플에서는 BertConfig를 사용하지 않고 대신 bert-base-cased 식별자를 통해 사전 학습된 모델(pretrained model)을 로드했습니다. 이것은 BERT 개발자가 직접 학습한 모델 체크포인트(model checkpoint)입니다. 모델 카드(model card)에서 자세한 내용을 찾을 수 있습니다. 이제 해당 모델은 체크포인트의 모든 가중치로 초기화됩니다. 학습된 작업(task)에 대한 추론(inference)에 직접 사용할 수 있으며, 새로운 작업(task)에 대해 미세 조정할(fine-tune) 수도 있습니다. 처음부터 신규로 학습하지 않고 사전 훈련된 가중치로 학습하면 좋은 결과를 빠르게 얻을 수 있습니다. 자동으로 가중치가 다운로드되고 캐시 되어(따라서 from_pretrained() 메서드를 다시 호출해도 가중치가 다시 다운로드되지 않습니다) 캐시 폴더에 저장됩니다. 기본 캐시 폴더 위치는 ~/.cache/huggingface/transformers입니다. HF_HOME 환경 변수를 설정하여 캐시 폴더를 변경할 수 있습니다. 모델을 로드하는 데 사용되는 식별자(checkpoint 명칭)는 BERT 아키텍처(BERT architecture)와 호환되는 모든 Model Hub 내의 식별자들을 사용할 수 있습니다. 사용 가능한 BERT 체크포인트(checkpoint)의 전체 목록은 여기에서 찾을 수 있습니다. 저장 메서드(Saving methods) 모델을 저장하는 것은 모델을 로드하는 것만큼 쉽습니다 — from_pretrained() 메서드와 유사한 save_pretrained() 메서드를 사용합니다: model.save_pretrained("saving_folder") ls saving_folder config.json pytorch_model.bin config.json 파일 내용을 보면 모델 아키텍처(model architecture)를 구축하는 데 필요한 다양한 속성들을 볼 수 있습니다. 이 파일에는 또한 몇몇 메타데이터(metadata), 즉 해당 체크포인트(checkpoint)를 구축한 출처, 체크포인트(checkpoint)를 마지막으로 저장할 때 사용하고 있던 Transformers 버전 등과 같은 정보가 저장되어 있다. pytorch_model.bin 파일은 state dictionary라고 부릅니다. 여기에는 모델의 모든 가중치가 저장되어 있습니다. 이 두 파일은 함께 사용됩니다. 설정 객체(configuration objects)는 모델의 아키텍처(model architecture)를 파악하는데 필요한 반면, 모델 가중치는 모델의 매개변수(parameters)입니다. 트랜스포머 모델을 활용한 추론(inference) 이제 모델을 로드하고 저장하는 방법을 알았으므로 모델을 사용하여 몇 가지 예측을 해보겠습니다. Transformer 모델은 토크 나이저가 생성하는 숫자만 처리할 수 있습니다. 그러나 토크 나이저에 대해 논의하기 전에 모델이 허용하는 입력을 살펴보겠습니다. 두 개의 시퀀스가 있다고 가정해 보겠습니다: sequences = ["Hello!", "Cool.", "Nice!"] 토크 나이저는 이를 일반적으로 input IDs라고 하는 어휘 인덱스로 변환합니다. 이제 각 시퀀스는 숫자의 리스트(list)입니다! 결과 출력은 다음과 같습니다: encoded_sequences = [ [101, 7592, 999, 102], [101, 4658, 1012, 102], [101, 3835, 999, 102], ] 이는 인코딩된 시퀀스의 리스트입니다. 파이썬 이중 리스트(list of list)입니다. 텐서(tensor)는 직사각형(rectangular) 모양(shape)만 허용합니다(행렬을 생각해 보면 쉽게 이해가 될 것입니다). encoded_sequences는 이미 "배열(array)" 형태의 직사각형(rectangular) 모양이므로 텐서로 변환하는 것은 쉽습니다. import torch model_inputs = torch.tensor(encoded_sequences) 모델의 입력으로 텐서 활용 모델과 함께 텐서를 사용하는 것은 매우 간단합니다. 입력을 매개변수로 지정하여 모델을 호출하기만 하면 됩니다. output = model(model_inputs) 모델은 다양한 추가적인 매개변수를 입력받을 수 있지만 여기서는 input IDs만 있으면 됩니다. 다른 매개변수가 어떤 것인지, 언제 필요한지에 대해서는 나중에 설명하겠지만 먼저 Transformer 모델이 이해할 수 있는 입력(inputs)을 구성할 수 있는 토크 나이저(tokenizer)를 자세히 살펴볼 필요가 있습니다. 3. 토크 나이저 (Tokenizer) 토크 나이저는 NLP 파이프라인의 핵심 구성 요소 중 하나입니다. 토크 나이저는 단지 1가지 목적을 가지고 있습니다. 즉, 입력된 텍스트를 모델에서 처리할 수 있는 데이터로 변환하는 것입니다. 모델은 숫자만 처리할 수 있으므로, 토크 나이저는 텍스트 입력을 숫자 데이터로 변환해야 합니다. 이 섹션에서는 토큰화 파이프라인(tokenization pipeline)에서 정확히 어떤 일이 발생하는지 살펴보겠습니다. NLP 작업에서 일반적으로 처리되는 데이터는 원시 텍스트(raw text)입니다. 다음은 원시 텍스트의 예시입니다: Jim Henson was a puppeteer 그러나 모델은 숫자만 처리할 수 있으므로 원시 텍스트를 숫자로 변환하는 방법을 찾아야 합니다. 이것이 토크 나이저가 하는 일이며, 이를 위해서 다양한 방법이 존재합니다. 토크 나이저의 목표는 가장 의미 있는 표현(meaningful representation), 즉 모델에 가장 적합하면서 최대한 간결한 표현을 찾는 것입니다. 토큰 분리 알고리즘의 몇 가지 예를 살펴보고 토큰화에 대해 가질 수 있는 몇 가지 질문에 답해 보겠습니다. 단어 기반 토큰화 (Word-based Tokenization) 가장 먼저 생각할 수 있는 토큰화(tokenization) 형태는 단어 기반 (word-based)입니다. 일반적으로 몇 가지 규칙만 가지고도 설정 및 사용이 매우 쉽고, 종종 괜찮은 결과를 얻을 수 있습니다. 예를 들어, 아래 그림에서의 토큰화 과정은 원시 텍스트를 단어로 나누고 각각에 대한 숫자 표현을 찾는 것입니다: 텍스트를 분할하는 방법에는 여러 가지가 있습니다. 예를 들어, Python의 split() 함수를 적용하여 공백을 기준으로 텍스트를 단어로 토큰화할 수 있습니다. tokenized_text = "Jim Henson was a puppeteer".split() print(tokenized_text) ['Jim', 'Henson', 'was', 'a', 'puppeteer'] 구두점에 대한 추가 규칙이 있는 단어 기반 토크 나이저(word-based tokenization)의 변형도 있습니다. 이러한 토크 나이저를 사용하여 말뭉치에 존재하는 독립적인 토큰들의 총합으로 구성되는 꽤 큰 규모의 vocabulary들을 얻을 수 있습니다. 각 단어에는 0에서부터 시작하여 어휘집(vocabulary) 크기(개수) 사이의 ID(식별자)가 할당됩니다. 모델은 이러한 ID를 사용하여 각 단어를 식별합니다. 단어 기반 토크 나이저로 특정 언어를 완전히 커버하려면, 해당 언어의 모든 단어에 대한 식별자가 필요하고, 이는 엄청난 양의 토큰을 생성합니다. 예를 들어, 영어에는 500,000개 이상의 단어가 있으므로 개별 단어에 대한 input ID(입력 식별자)로의 매핑을 구성하기 위해서 그만큼의 식별자들을 감당해야 합니다. 게다가, "dog"와 같은 단어는 "dogs"와 같은 단어와 다르게 표현되며, 모델은 처음에는 "dog"와 "dogs"가 유사한 단어들인지 파악하기 어렵습니다. 따라서, 두 단어를 관련이 없는 것으로 인식합니다. 이는 "run"과 "running"과 같은 다른 유사한 단어들도 마찬가지입니다. 마지막으로, 어휘집(vocabulary)에 없는 단어를 표현하기 위해 사용자 정의 토큰이 필요합니다. 이는 "unknown" 토큰으로 알려져 있으며, 종종 "[UNK]" 또는 ""로 표시됩니다. 토크 나이저가 이러한 "unknown" 토큰을 많이 생성한다는 것은 토크 나이저가 해당 단어의 합당한 표현(sensible representation)을 찾을 수 없고, 그 과정에서 정보를 잃어버린다는 뜻이므로 나쁜 징조입니다. 어휘집(vocabulary)을 만들 때, 토크 나이저가 이러한 "unknown" 토큰들을 최대한 적게 출력하게끔 하는 것이 목표가 되어야 합니다. "Unknown" 토큰의 양을 줄이는 한 가지 방법은 문자 기반 (character-based) 토크 나이저를 사용하여 한 단계 더 깊이 들어가는 것입니다. 문자 기반 토큰화 (Character-based Tokenization) 문자 기반 토크 나이저는 텍스트를 단어(words)가 아닌 문자(characters)로 나눕니다. 이러한 방법은 두 가지 장점이 있습니다: 어휘집(vocabulary)의 크기가 매우 작습니다. 모든 단어들이 문자를 가지고 만들어질 수 있기 때문에, out-of-vocabulary (OOV, unknown) 토큰이 훨씬 적습니다. 그러나 여기에서도 공백과 구두점에 관한 몇 가지 의문이 발생합니다: 이 방식 역시 완벽하지 않습니다. 분리된 토큰 표현 자체가 단어가 아닌 문자 기반이므로 직관적으로 볼 때 각 토큰의 의미 파악이 어렵습니다. 그러나 이 또한 언어에 따라 다릅니다. 예를 들어, 중국어에서 각 문자(한자)는 라틴(Latin) 언어의 문자보다 더 많은 정보를 전달합니다. 고려해야 할 또 다른 사항은 모델에서 처리할 매우 많은 양의 토큰이 발생하게 된다는 것입니다. 단어 기반 토크 나이저를 사용하면 각 단어는 하나의 단일 토큰이지만, 문자로 변환하면 10개 이상의 토큰으로 쉽게 변환될 수 있습니다. 위 두 가지 방식의 장점을 최대한 활용하기 위해 이를 결합한 세 번째 기법인 subword tokenization(하위 단어 토큰화)를 사용할 수 있습니다. 하위 단어 토큰화 (Subword Tokenization) 하위 단어 토큰화(subword tokenization) 알고리즘은 빈번하게 사용하는 단어(frequently used words)는 더 작은 하위 단어(subword)로 분할하지 않고, 희귀 단어(rare words)를 의미 있는 하위 단어(meaningful subwords)로 분할해야 한다는 원칙에 기반합니다. 예를 들어, "annoyingly"는 희귀 단어로 간주될 수 있으며, "annoying"와 "ly"로 분해될 수 있습니다. 이들은 둘 다 독립적인 하위 단어(standalone subwords)로 더 자주 출현할 가능성이 높으며 동시에 "annoyingly"의 의미는 "annoying"와 "ly"의 합성 의미(composite meaning)로 유지됩니다. 다음은 하위 단어 토큰화(subword tokenization) 알고리즘이 "Let's do tokenization!" 시퀀스를 토큰화하는 방법을 보여주는 예입니다: 위 그림에서의 하위 단어들(subwords)은 충분한 양의 의미 정보(semantic meaning)을 제공하고 있습니다. 예를 들어, 위의 예에서 "tokenization"는 "token"과 "iztion"으로 분리되었습니다. 두 개의 토큰은 각각이 의미 정보(semantic meaning)을 가지면서도 공간 효율적(space-efficient)입니다. 즉, 길이가 긴 한 단어를 표현하기 위해서 단 두 개의 토큰만 필요합니다. 이를 통해 우리는 규모가 작은, 다시 말해서, 구성 어휘가 많지 않은 어휘집(vocabulary)으로도 충분히 많은 수의 토큰들을 표현할 수 있고, "unknown" 토큰이 거의 없습니다. 이 방식은 하위 단어(subwords)를 연결하여 길이가 긴 복잡한 단어를 임의로 만들 수 있는 터키어(Turkish)와 같은 교착 언어(agglutinative languages)에서 특히 유용합니다. 세부 기법들 짐작은 했겠지만, 이 하위 단어 토큰화와 관련된 더 많은 기법들이 있습니다. 몇 가지 예를 들면 다음과 같습니다: Byte-level BPE (GPT-2에 사용됨) WordPiece (BERT에 사용됨) SentencePiece, Unigram (몇몇 다국어 모델에 사용됨) 이제 토크 나이저가 작동하는 방식에 대한 충분한 지식을 가지고 있다고 가정하고 본격적으로 API를 공부해 봅시다. 토크 나이저 로딩 및 저장 토크 나이저를 로드하고 저장하는 것은 모델의 경우처럼 간단합니다. 실제로, 모델을 로드하고 저장할 때와 같이, from_pretrained() 및 save_pretrained() 메서드(method)를 그대로 사용합니다. 이들 메서드(method)들은 토크 나이저(모델의 아키텍처와 약간 비슷함)와 어휘집(vocabulary, 모델의 가중치(weights)와 비슷함)에서 사용하는 알고리즘을 로드하거나 저장합니다. BERT와 동일한 체크포인트(checkpoint)로 학습된 BERT 토크 나이저를 로드하는 것은 BertTokenizer 클래스를 사용한다는 점을 제외하고는 모델을 로드하는 것과 동일한 방식으로 수행됩니다. from transformers import BertTokenizer tokenizer = BertTokenizer.from_pretrained("bert-base-cased") AutoModel 클래스와 유사하게 AutoTokenizer 클래스는 라이브러리에서 체크포인트 이름에 해당하는 토크 나이저 클래스를 가져옵니다. 라이브러리 내의 다른 모든 체크포인트와 함께 직접 사용할 수 있습니다. from transformers import AutoTokenizer tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") 이제 위에서처럼 동일하게 토크 나이저를 사용할 수 있습니다. tokenizer("Using a Transformer network is simple") {'input_ids': [101, 7993, 170, 13809, 23763, 2443, 1110, 3014, 102], 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0], 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1]} 토크 나이저를 저장하는 것은 모델을 저장하는 것과 동일합니다. tokenizer.save_pretrained("saving_folder") ('saving_folder/tokenizer_config.json', 'saving_folder/special_tokens_map.json', 'saving_folder/vocab.txt', 'saving_folder/added_tokens.json', 'saving_folder/tokenizer.json') 위 토크 나이저 출력 결과 중에서 token_type_ids에 대해서는 3장에서 더 이야기하고, attention_mask 키에 대해서는 잠시 후에 설명하겠습니다. 먼저 input_ids 가 어떻게 생성되는지 살펴봅시다. 이를 위해서는 토크 나이저의 중간 메서드(intermediate methods)를 살펴봐야 합니다. 인코딩 (Encoding) 텍스트를 숫자로 변환하는(translating text to numbers) 과정을 인코딩(encoding)이라고 합니다. 인코딩(encoding)은 토큰화와 입력 식별자(input IDs)로의 변환이라는 2단계 프로세스로 수행됩니다. 우리가 보았듯이, 첫 번째 단계는 텍스트를 토큰(tokens)이라고 부르는 단어(또는 단어의 일부, 구두점 기호 등)로 분리하는 것입니다. 다양한 토큰화 방법들이 존재하고 각 모델들이 사전학습될 때 사용한 토큰화 방법이 다양하기 때문에, 본인이 사용하고자 하는 모델의 이름을 이용하여 토크 나이저도 인스턴스화(instantiate) 해야 합니다. 그래야 해당 모델에서 사용한 토크 나이저를 동일하게 사용할 수 있습니다. 두 번째 단계는 토큰화 결과인 토큰들을 숫자로 변환하여 텐서(tensor)를 만들고 이를 모델에 입력할 수 있도록 하는 것입니다. 이를 위해 토크 나이저는 from_pretrained() 메서드로 인스턴스화할 때 다운로드되는 파일 중의 하나로 vocabulary를 포함하고 있습니다. 여기서도, 모델이 사전학습될 때 사용한 것과 동일한 어휘집(vocabulary)을 사용해야 합니다. 위 두 단계를 개별적으로 살펴보겠습니다. 토큰화 파이프라인(tokenization pipeline) 전체 과정에서 내부적으로 호출되는 몇 가지 메서드들을 실행하여 중간 단계의 결과물들을 출력해 보겠습니다. 그러나 실제로는 입력에 대해서 토크 나이저를 한 번에 호출하는 것이 일반적입니다. 토큰화 작업 토큰화 프로세스는 토크 나이저의 tokenize() 메서드에 의해 수행됩니다. from transformers import AutoTokenizer tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") sequence = "Using a Transformer network is simple" tokens = tokenizer.tokenize(sequence) print(tokens) ['Using', 'a', 'Trans', '##former', 'network', 'is', 'simple'] 이 메서드의 출력은 문자열 또는 토큰들의 리스트입니다. 위에서 보듯이 여기서 실행한 토크 나이저는 하위 단어 토크 나이저(subword tokenization)입니다. 해당 어휘집(vocabulary)에 존재하는 토큰들을 얻을 수 있을 때까지 단어를 분할합니다. Transformer는 Trans 와 ##former라는 두 개의 토큰으로 나뉩니다. 이들 토큰들은 모두 어휘집(vocabulary)에 존재하는 토큰들입니다. 토큰을 입력 식별자로 변환 (From tokens to input IDs) 이후 각 토큰들의 입력 식별자(input IDs)로의 변환은 convert_tokens_to_ids() 메서드에 의해 처리됩니다. ids = tokenizer.convert_tokens_to_ids(tokens) print(ids) [7993, 170, 13809, 23763, 2443, 1110, 3014] 위 출력은 일단 적절한 프레임워크 텐서(framework tensor)로 변환되면, 이 장의 앞부분에서 본 것처럼, 모델에 대한 입력으로 사용할 수 있습니다. 디코딩 (Decoding) 디코딩(decoding)은 반대 방향으로 진행됩니다. 변환된 입력 식별자(input IDs)를 이용해서 어휘집(vocabulary)에서 해당 문자열을 찾습니다. 이것은 다음과 같이 decode() 메서드를 사용하여 수행할 수 있습니다. decoded_string = tokenizer.decode([7993, 170, 13809, 23763, 2443, 1110, 3014]) print(decoded_string) Using a Transformer network is simple decode() 메서드는 인덱스를 다시 토큰으로 변환할 뿐만 아니라 하위 단어(subword)로 분할된 토큰을 병합하여, 읽을 수 있는 원본 문장을 도출합니다. 이 동작은 새로운 텍스트를 생성하는 모델, 다시 말해서, 프롬프트(prompt)에서의 텍스트 생성, 번역(translation), 요약(summarization) 등과 같은 시퀀스-투-시퀀스(sequence-to-sequence) 문제 등을 다룰 때 매우 유용합니다. 지금까지, 토크 나이저가 수행하는 세부적인 작업들 즉, 토큰화(tokenization), 식별자(ID)로 변환(conversion to IDs), 식별자(ID)를 문자열로 다시 변환(converting IDs back to string) 작업들을 파악했습니다. 그러나 이는 단지 빙산의 일각일 뿐입니다. 다음 섹션에서는 위 방법들의 한계를 알아보고 이를 극복하는 방법을 살펴보겠습니다. 4. 다중 시퀀스 처리 이전 섹션에서 우리는 가장 간단한 활용 사례를 살펴보았습니다. 즉, 길이가 짧은 단일 시퀀스에 대한 추론을 수행하는 것입니다. 그러나 몇 가지 의문점이 벌써 머릿속에 남습니다: 다중 시퀀스(multiple sequences)를 어떻게 처리할까? 각각이 길이가 다른 여러 개의 시퀀스를 어떻게 처리할까? 모델이 잘 동작할 수 있게 하기 위해서 어휘집(vocabulary)의 인덱스들만 입력하면 될까? 길이가 엄청나게 긴 시퀀스에 대해서는 잘 처리할 수 있을까? 위 질문들이 어떤 문제를 일으키고 이를 Transformers API를 사용하여 해결할 수 있는지 알아봅시다. 모델(model)은 입력의 배치(batch) 형태를 요구한다. 이전 섹션에서 시퀀스가 숫자 리스트로 변환되는 방법을 보았습니다. 이 숫자 리스트를 텐서(tensor)로 변환하고 모델에 입력해 보겠습니다: import torch from transformers import AutoTokenizer, AutoModelForSequenceClassification checkpoint = "distilbert-base-uncased-finetuned-sst-2-english" tokenizer = AutoTokenizer.from_pretrained(checkpoint) model = AutoModelForSequenceClassification.from_pretrained(checkpoint) sequence = "I've been waiting for a HuggingFace course my whole life." tokens = tokenizer.tokenize(sequence) ids = tokenizer.convert_tokens_to_ids(tokens) input_ids = torch.tensor(ids) # This line will fail model(input_ids) --------------------------------------------------------------------------- IndexError Traceback (most recent call last) /tmp/ipykernel_9651/1126667217.py in <module> 12 input_ids = torch.tensor(ids) 13 # This line will fail ---> 14 model(input_ids) ~/anaconda3/lib/python3.8/site-packages/torch/nn/modules/module.py in _call_impl(self, *input, **kwargs) 1100 if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks 1101 or _global_forward_hooks or _global_forward_pre_hooks): -> 1102 return forward_call(*input, **kwargs) 1103 # Do not call functions when jit is used 1104 full_backward_hooks, non_full_backward_hooks = [], [] ~/anaconda3/lib/python3.8/site-packages/transformers/models/distilbert/modeling_distilbert.py in forward(self, input_ids, attention_mask, head_mask, inputs_embeds, labels, output_attentions, output_hidden_states, return_dict) 727 return_dict = return_dict if return_dict is not None else self.config.use_return_dict 728 --> 729 distilbert_output = self.distilbert( 730 input_ids=input_ids, 731 attention_mask=attention_mask, ~/anaconda3/lib/python3.8/site-packages/torch/nn/modules/module.py in _call_impl(self, *input, **kwargs) 1100 if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks 1101 or _global_forward_hooks or _global_forward_pre_hooks): -> 1102 return forward_call(*input, **kwargs) 1103 # Do not call functions when jit is used 1104 full_backward_hooks, non_full_backward_hooks = [], [] ~/anaconda3/lib/python3.8/site-packages/transformers/models/distilbert/modeling_distilbert.py in forward(self, input_ids, attention_mask, head_mask, inputs_embeds, output_attentions, output_hidden_states, return_dict) 548 549 if inputs_embeds is None: --> 550 inputs_embeds = self.embeddings(input_ids) # (bs, seq_length, dim) 551 return self.transformer( 552 x=inputs_embeds, ~/anaconda3/lib/python3.8/site-packages/torch/nn/modules/module.py in _call_impl(self, *input, **kwargs) 1100 if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks 1101 or _global_forward_hooks or _global_forward_pre_hooks): -> 1102 return forward_call(*input, **kwargs) 1103 # Do not call functions when jit is used 1104 full_backward_hooks, non_full_backward_hooks = [], [] ~/anaconda3/lib/python3.8/site-packages/transformers/models/distilbert/modeling_distilbert.py in forward(self, input_ids) 117 embeddings) 118 """ --> 119 seq_length = input_ids.size(1) 120 121 # Setting the position-ids to the registered buffer in constructor, it helps IndexError: Dimension out of range (expected to be in range of [-1, 0], but got 1) 이런! 뭐가 문제일까요? 위 코드에서 우리는 섹션 2에서의 파이프라인 단계를 그대로 따랐습니다. 위 문제는 우리가 모델에 하나의 단일 시퀀스를 입력해서 발생하는 문제입니다. Transformers 모델은 기본적으로 다중 문장(시퀀스)을 한 번에 입력하기를 기대한다는 것입니다. 여기에서 우리는 시퀀스에 토크 나이저를 적용할 때 실제 내부적으로 수행하는 모든 작업을 시도했습니다. 하지만 아래 코드를 자세히 보면 입력 식별자(input IDs) 리스트를 텐서로 변환하는 동시에 차원(dimension) 하나가 그 위에 추가되는 것을 알 수 있습니다: tokenized_inputs = tokenizer(sequence, return_tensors="pt") print(tokenized_inputs["input_ids"]) tensor([[ 101, 1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172, 2607, 2026, 2878, 2166, 1012, 102]]) 오류가 발생한 코드에서 input_ids에 새로운 차원을 하나 추가해 보겠습니다: import torch from transformers import AutoTokenizer, AutoModelForSequenceClassification checkpoint = "distilbert-base-uncased-finetuned-sst-2-english" tokenizer = AutoTokenizer.from_pretrained(checkpoint) model = AutoModelForSequenceClassification.from_pretrained(checkpoint) sequence = "I've been waiting for a HuggingFace course my whole life." tokens = tokenizer.tokenize(sequence) ids = tokenizer.convert_tokens_to_ids(tokens) input_ids = torch.tensor([ids]) print("Input IDs:", input_ids) output = model(input_ids) print("Logits:", output.logits) Input IDs: tensor([[ 1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172, 2607, 2026, 2878, 2166, 1012]]) Logits: tensor([[-2.7276, 2.8789]], grad_fn=<AddmmBackward0>) 위 코드에서는 입력 식별자(input IDs)와 그 결과 로짓(logit) 값을 출력하고 있습니다. Batching 이란 모델을 통해 한 번에 여러 문장을 입력하는 동작입니다. 문장이 하나만 있는 경우 아래와 같이 단일 시퀀스로 배치(batch)를 빌드 할 수 있습니다. batch_ids = [ids, ids] 이것은 동일한 두 시퀀스로 구성된 배치(batch)입니다! 배치(batch) 처리를 통해서 모델이 여러 문장을 동시에 입력받을 수 있도록 할 수 있습니다. 다중 시퀀스를 사용하는 것은 단일 시퀀스로 배치(batch)를 구성하는 것만큼 간단합니다. 하지만 두 번째 문제가 있습니다. 두 개(또는 그 이상) 문장을 함께 배치(batch) 처리하려고 할 때 각 문장의 길이가 다를 수 있습니다. 이전에 텐서(tensor)를 사용해 본 적이 있다면 항상 그 형태가 직사각형 모양이어야 한다는 것을 알고 있을 것입니다. 따라서 이럴 경우에는 입력 식별자(input IDs) 리스트를 텐서로 직접 변환할 수 없습니다. 이 문제를 해결하기 위해 일반적으로 입력을 채웁니다(padding). 입력을 패딩(padding) 하기 다음 리스트의 리스트(혹은 이중 리스트)는 텐서로 변환할 수 없습니다. batched_ids = [ [200, 200, 200], [200, 200], ] 이 문제를 해결하기 위해 패딩(padding) 을 사용하여 텐서를 직사각형 모양으로 만듭니다. 패딩(padding)은 길이가 더 짧은 문장에 패딩 토큰(padding token)이라는 특수 단어를 추가하여 모든 문장이 동일한 길이를 갖도록 합니다. 예를 들어, 10개의 단어로 구성된 10개의 문장과 20개의 단어가 있는 1개의 문장이 있는 경우, 패딩(padding)을 사용하면 모든 문장에 20개의 단어가 포함됩니다. 위의 batched_ids를 패딩(padding) 처리하면 결과 텐서는 다음과 같습니다: padding_id = 100 batched_ids = [ [200, 200, 200], [200, 200, padding_id], ] 패딩 토큰(padding token)의 식별자(ID)는 tokenizer.pad_token_id에 지정되어 있습니다. 이를 활용하여 두 개의 시퀀스를 한번은 개별적으로 또 한 번은 배치(batch) 형태로 모델에 입력해 보겠습니다: model = AutoModelForSequenceClassification.from_pretrained(checkpoint) sequence1_ids = [[200, 200, 200]] sequence2_ids = [[200, 200]] batched_ids = [ [200, 200, 200], [200, 200, tokenizer.pad_token_id], ] print(model(torch.tensor(sequence1_ids)).logits) print(model(torch.tensor(sequence2_ids)).logits) print(model(torch.tensor(batched_ids)).logits) tensor([[ 1.5694, -1.3895]], grad_fn=<AddmmBackward0>) tensor([[ 0.5803, -0.4125]], grad_fn=<AddmmBackward0>) tensor([[ 1.5694, -1.3895], [ 1.3374, -1.2163]], grad_fn=<AddmmBackward0>) 배치 처리된 예측 결과의 로짓(logits)에 문제가 있습니다. 두 번째 행은 두 번째 문장의 로짓(logits)과 같아야 하지만 완전히 다른 값을 갖습니다! 이는 트랜스포머(Transformer) 모델의 핵심적인 특징이 각 토큰을 컨 텍스트화(contextualize) 하는 어텐션 레이어(attention layers)를 가지고 있다는 사실이기 때문입니다. 어텐션 레이어(attention layers)는 시퀀스의 모든 토큰에 주의 집중(paying attention)을 하기 때문에 패딩 토큰도 역시 고려합니다. 모델에 길이가 다른 개별 문장들을 입력할 때나 동일한 문장으로 구성된 패딩이 적용된 배치(batch)를 입력할 때 동일한 결과를 얻기 위해서는 해당 어텐션 레이어(attention layers)가 패딩 토큰을 무시하도록 지시해야 합니다. 이는 어텐션 마스크(attention mask)를 사용하여 처리할 수 있습니다. 어텐션 마스크 (attention masks) 어텐션 마스크(attention mask)는 0과 1로 채워진 입력 식별자(input IDs) 텐서(tensor)와 형태가 정확하게 동일한 텐서(tensor)입니다. 1은 해당 토큰에 주의를 기울여야 함을 나타내고 0은 해당 토큰을 무시해야 함을 나타냅니다. 즉, 모델의 어텐션 레이어(attention layers)에서 무시해야 합니다. 어텐션 마스크(attention mask)로 이전 예제를 완성해 보겠습니다: batch_ids = [ [200, 200, 200], [200, 200, tokenizer.pad_token_id], ] attention_mask = [ [1, 1, 1], [1, 1, 0], ] outputs = model(torch.tensor(batch_ids), attention_mask=torch.tensor(attention_mask)) print(outputs.logits) tensor([[ 1.5694, -1.3895], [ 0.5803, -0.4125]], grad_fn=<AddmmBackward0>) 이제 배치(batch)의 두 번째 문장에 대해 동일한 로짓(logits) 값을 얻을 수 있습니다. 두 번째 시퀀스의 마지막 값이 패딩 식별자(padding ID)이고 이에 해당하는 어텐션 마스크(attention mask)의 값이 0인 점을 주의하세요. 길이가 더 긴 시퀀스들 트랜스포머(Transformer) 모델을 사용할 때, 모델에 입력할 수 있는 시퀀스의 길이에 제한이 있습니다. 대부분의 모델은 최대 512개 또는 1024개의 토큰 시퀀스를 처리하며, 그보다 더 긴 시퀀스를 처리하라는 요청을 받으면 오류를 발생시킵니다. 이 문제에 대한 두 가지 설루션이 있습니다. 길이가 더 긴 시퀀스를 지원하는 모델을 사용하십시오. 시퀀스를 절단합니다(truncation). 모델 별로 지원되는 시퀀스 길이가 다르며 일부 모델은 매우 긴 시퀀스 처리에 특화되어 있습니다. Longformer가 하나의 예이고 다른 하나는 LED입니다. 매우 긴 시퀀스를 필요로 하는 태스크를 수행하는 경우 해당 모델을 살펴보는 것이 좋습니다. 그렇지 않으면, max_sequence_length 매개변수를 지정하여 시퀀스를 절단하는 것이 좋습니다. max_sequence_length = 512 sequence = sequence[:max_sequence_length] 5. 2장 요약 (Summary) 지난 몇 섹션에서 우리는 대부분의 작업을 직접 세부적으로 수행하기 위해 최선을 다했습니다. 우리는 토크 나이저의 작동 방식과 토큰화(tokenization), 입력 식별자(input IDs)로의 변환, 패딩(padding), 절단(truncation) 및 어텐션 마스크(attention mask) 등을 살펴보았습니다. 그러나 섹션 2에서 보았듯이 Transformers API를 사용하면 여기에서 자세히 다룰 예정인 고수준 함수들(high-level functions)로 이 모든 것을 처리할 수 있습니다. 문장에 대해서 직접 토크 나이저를 호출하면 모델에 전달될 준비가 된 최종 입력 형태를 만들 수 있습니다: from transformers import AutoTokenizer checkpoint = "distilbert-base-uncased-finetuned-sst-2-english" tokenizer = AutoTokenizer.from_pretrained(checkpoint) sequence = "I've been waiting for a HuggingFace course my whole life." model_inputs = tokenizer(sequence) 여기에서 model_inputs 변수는 모델이 제대로 동작하는데 필요한 모든 정보들을 포함하고 있습니다. DistilBERT의 경우, model_inputs에는 입력 식별자(input IDs)와 어텐션 마스크(attention mask)가 포함됩니다. 모델에 따라서 tokenizer 객체는 모델에 필요한 입력 정보들을 알아서 제공해 줍니다. 아래의 몇 가지 예에서 볼 수 있듯이 tokenizer 메서드는 매우 강력합니다. 우선 단일 시퀀스를 토큰화할 수 있습니다: sequence = "I've been waiting for a HuggingFace course my whole life." model_inputs = tokenizer(sequence) 또한 변경 사항 없이 한 번에 여러 시퀀스를 처리합니다: sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"] model_inputs = tokenizer(sequences) 그리고 다양한 모드에 따라 패딩(padding) 처리를 할 수 있습니다: # 해당 시퀀스를 리스트 내의 최대 시퀀스 길이까지 패딩(padding) 합니다. model_inputs = tokenizer(sequences, padding="longest") # 시퀀스를 모델 최대 길이(model max length)까지 패딩(padding) 합니다. # (512 for BERT or DistilBERT) model_inputs = tokenizer(sequences, padding="max_length") # 지정된 최대 길이까지 시퀀스를 패딩(padding) 합니다. model_inputs = tokenizer(sequences, padding="max_length", max_length=8) 시퀀스를 자를 수도 있습니다: sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"] # 모델 최대 길이(model max length)보다 긴 시퀀스를 자릅니다. # (512 for BERT or DistilBERT) model_inputs = tokenizer(sequences, truncation=True) # 지정된 최대 길이보다 긴 시퀀스를 자릅니다. model_inputs = tokenizer(sequences, max_length=8, truncation=True) 특수 토큰들 (Special tokens) 토크 나이저가 반환한 입력 식별자(input IDs)를 살펴보면 이전과 약간 다르다는 것을 알 수 있습니다: sequence = "I've been waiting for a HuggingFace course my whole life." model_inputs = tokenizer(sequence) print(model_inputs["input_ids"]) tokens = tokenizer.tokenize(sequence) ids = tokenizer.convert_tokens_to_ids(tokens) print(ids) [101, 1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172, 2607, 2026, 2878, 2166, 1012, 102] [1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172, 2607, 2026, 2878, 2166, 1012] 새로운 토큰 식별자가 처음과 마지막에 하나씩 추가되었습니다. 위의 두 가지 식별자 시퀀스를 디코딩(decoding) 하여 이것이 무엇을 나타내는 것인지 알아보겠습니다: print(tokenizer.decode(model_inputs["input_ids"])) print(tokenizer.decode(ids)) [CLS] i've been waiting for a huggingface course my whole life. [SEP] i've been waiting for a huggingface course my whole life. 토크 나이저는 시작 부분에 특수 단어 [CLS]를 추가하고 끝에 특수 단어 [SEP]를 추가했습니다. 이는 모델이 해당 특수 토큰들로 사전 학습(pre-training) 되었기 때문에 추론에 대해 동일한 결과를 얻으려면 이를 추가해야 합니다. 일부 모델은 이들 특수 토큰들이나 다른 특별한 단어들을 추가하지 않는 경우도 있습니다. 또 어떤 모델은 시작 부분에만 이러한 특수 단어를 추가하거나 혹은 끝부분에만 추가할 수도 있습니다. 어쨌든 토크 나이저는 입력이 예상되는 토큰들을 이미 알고 있으며 이를 처리할 것입니다. 마무리: 토크 나이저에서 모델로... 이제 토크 나이저 객체가 텍스트를 처리할 때 실행되는 모든 개별 단계들을 살펴보았으므로, 주요 API로 다중 시퀀스(패딩, padding!), 매우 긴 시퀀스(절단, truncation!), 여러 유형의 텐서를 처리하는 방법 등을 마지막으로 한 번 보겠습니다. import torch from transformers import AutoTokenizer, AutoModelForSequenceClassification checkpoint = "distilbert-base-uncased-finetuned-sst-2-english" tokenizer = AutoTokenizer.from_pretrained(checkpoint) model = AutoModelForSequenceClassification.from_pretrained(checkpoint) sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"] tokens = tokenizer(sequences, padding=True, truncation=True, return_tensors="pt") output = model(**tokens) print(output) SequenceClassifierOutput(loss=None, logits=tensor([[-1.5607, 1.6123], [-3.6183, 3.9137]], grad_fn=<AddmmBackward0>), hidden_states=None, attentions=None) 3장. 사전학습 모델에 대한 미세조정 2장에서는 토크 나이저와 사전 학습된 모델을 사용하여 예측을 수행하는 방법을 살펴보았습니다. 그런데 여러분들이 가지고 있는 고유의 데이터 셋(dataset)을 가지고 기존의 사전 학습된 모델을 미세 조정(fine-tune) 하려면 어떻게 해야 할까요? 이 장의 내용이 바로 그 부분입니다! 여기서는, 허브(Hub)에서 대규모 데이터 셋을 가지고 오는 방법에 대해서 배웁니다. 고급 Trainer API를 사용하여 모델을 미세 조정(fine-tune) 하는 방법을 공부합니다. 사용자 지정 학습 루프(custom training loop)을 사용하는 방법을 알아봅니다. Accelerate 라이브러리를 활용하여 분산 환경에서 사용자 지정 학습 루프(custom training loop)을 쉽게 실행하는 방법을 공부합니다. 미세 조정된 체크포인트(checkpoint)를 Hugging Face Hub에 업로드하려면 huggingface.co 계정이 필요합니다: 계정 생성 1. 데이터 처리 작업 2장에서 공부한 것과 같이, PyTorch에서 단일 배치(batch)를 기반으로 시퀀스 분류기(sequence classifier)를 학습하는 방법은 다음과 같습니다. import torch from transformers import AdamW, AutoTokenizer, AutoModelForSequenceClassification # 2장의 예제와 동일합니다. checkpoint = "bert-base-uncased" tokenizer = AutoTokenizer.from_pretrained(checkpoint) model = AutoModelForSequenceClassification.from_pretrained(checkpoint) sequences = [ "I've been waiting for a HuggingFace course my whole life.", "This course is amazing!", ] batch = tokenizer(sequences, padding=True, truncation=True, return_tensors="pt") # 새롭게 추가된 코드입니다. batch["labels"] = torch.tensor([1, 1]) optimizer = AdamW(model.parameters()) loss = model(**batch).loss loss.backward() optimizer.step() Downloading: 0%| | 0.00/420M [00:00<?, ?B/s] Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertForSequenceClassification: ['cls.predictions.transform.LayerNorm.bias', 'cls.predictions.bias', 'cls.predictions.transform.LayerNorm.weight', 'cls.predictions.transform.dense.weight', 'cls.predictions.transform.dense.bias', 'cls.seq_relationship.weight', 'cls.predictions.decoder.weight', 'cls.seq_relationship.bias'] - This IS expected if you are initializing BertForSequenceClassification from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model). - This IS NOT expected if you are initializing BertForSequenceClassification from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model). Some weights of BertForSequenceClassification were not initialized from the model checkpoint at bert-base-uncased and are newly initialized: ['classifier.weight', 'classifier.bias'] You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference. 물론 두 문장만으로 모델을 학습하는 것으로는 그다지 좋은 결과를 얻을 수 없습니다. 더 좋은 결과를 얻으려면, 더 큰 데이터 셋을 준비해야 합니다. 이 섹션에서는 William B. Dolan과 Chris Brockett의 논문에서 소개된 MRPC(Microsoft Research Paraphrase Corpus) 데이터 셋을 예제로 사용할 것입니다. 이 데이터 셋은 5,801건의 문장 쌍으로 구성되어 있으며 각 문장 쌍의 관계가 의역(paraphrasing) 관계인지를 나타내는 레이블이 존재합니다(즉, 두 문장이 동일한 의미인지). 데이터 셋의 규모가 그리 크지 않기 때문에 학습 과정을 쉽게 실험할 수 있습니다. 허브에서 데이터 셋 로딩 허브(hub)에는 모델만 존재하는 것이 아닙니다. 다양한 언어로 구축된 여러 데이터 셋들도 있습니다. 여기에서 다양한 데이터 셋을 탐색할 수 있으며, 이 섹션을 완료한 후에는 다른 데이터 셋을 로드하고 처리해 보기를 권장합니다 (여기에서 일반 문서 참조). 하지만 지금은 MRPC 데이터 셋에 집중합시다! 이 데이터 셋은 10개의 데이터 셋으로 구성된 GLUE 벤치마크 중 하나입니다. GLUE 벤치마크는 10가지 텍스트 분류 작업을 통해서 기계학습 모델의 성능을 측정하기 위한 학술적 벤치마크 데이터 집합입니다. Datasets 라이브러리는 허브(hub)에서 데이터 셋을 다운로드하고 캐시(cache) 기능을 수행하는 쉬운 명령어를 제공합니다. 다음과 같이 MRPC 데이터 셋을 다운로드할 수 있습니다: from datasets import load_dataset raw_datasets = load_dataset("glue", "mrpc") raw_datasets Downloading: 0%| | 0.00/7.78k [00:00<?, ?B/s] Downloading: 0%| | 0.00/4.47k [00:00<?, ?B/s] Downloading and preparing dataset glue/mrpc (download: 1.43 MiB, generated: 1.43 MiB, post-processed: Unknown size, total: 2.85 MiB) to /home/spasis/.cache/huggingface/datasets/glue/mrpc/1.0.0/dacbe3125aa31d7f70367a07a8a9e72a 5a0bfeb5fc42e75c9db75b96da6053ad... 0%| | 0/3 [00:00<?, ?it/s] Downloading: 0.00B [00:00, ?B/s] Downloading: 0.00B [00:00, ?B/s] Downloading: 0.00B [00:00, ?B/s] 0 examples [00:00, ? examples/s] 0 examples [00:00, ? examples/s] 0 examples [00:00, ? examples/s] Dataset glue downloaded and prepared to /home/spasis/.cache/huggingface/datasets/glue/mrpc/1.0.0/dacbe3125aa31d7f70367a07a8a9e72a 5a0bfeb5fc42e75c9db75b96da6053ad. Subsequent calls will reuse this data. 0%| | 0/3 [00:00<?, ?it/s] DatasetDict({ train: Dataset({ features: ['sentence1', 'sentence2', 'label', 'idx'], num_rows: 3668 }) validation: Dataset({ features: ['sentence1', 'sentence2', 'label', 'idx'], num_rows: 408 }) test: Dataset({ features: ['sentence1', 'sentence2', 'label', 'idx'], num_rows: 1725 }) }) 위 결과에서 보듯이, 학습(training), 검증(validation) 및 평가(test) 집합이 저장된 DatasetDict 객체를 얻을 수 있습니다. 이들 각각은 여러 종류의 열(columns)(sentence1, sentence2, label 및 idx)과 행(row)의 개수를 포함하는데, 여기서 행(row)의 개수는 각 집합의 문장쌍의 개수를 나타냅니다. 따라서, 학습 집합(training set)에는 3,668개의 문장 쌍, 검증 집합(validation set)에는 408개, 평가 집합(test set)에는 1,725개의 문장 쌍이 있습니다. load_dataset 명령은 기본적으로 ~/.cache/huggingface/dataset에 데이터 셋을 다운로드하고 임시저장(캐시, cache) 합니다. 2장에서 보았듯이, HF_HOME 환경 변수를 설정하여 캐시 폴더를 변경할 수 있습니다. 파이썬의 딕셔너리(dictionary)와 같이 키값으로 raw_datasets 개체의 개별 집합(학습, 검증, 평가)에 접근할 수 있습니다: raw_train_dataset = raw_datasets["train"] raw_train_dataset[0] {'sentence1': 'Amrozi accused his brother , whom he called " the witness " , of deliberately distorting his evidence .', 'sentence2': 'Referring to him as only " the witness " , Amrozi accused his brother of deliberately distorting his evidence .', 'label': 1, 'idx': 0} 위의 예에서 보듯이, 레이블(label)이 이미 정수(integers)라서 전처리(preprocessing)가 필요 없습니다. 어떤 정수가 어떤 레이블에 해당하는지 파악하기 위해서는 raw_train_dataset의 features 속성을 살펴보면 됩니다: raw_train_dataset.features {'sentence1': Value(dtype='string', id=None), 'sentence2': Value(dtype='string', id=None), 'label': ClassLabel(num_classes=2, names=['not_equivalent', 'equivalent'], names_file=None, id=None), 'idx': Value(dtype='int32', id=None)} 세부적으로, 레이블(label)은 ClassLabel 타입이고 레이블 이름에 대한 정수 매핑은 names 폴더에 저장되어 있습니다. 0은 not_equivalent를 의미하고, 1은 equivalent를 나타냅니다. 데이터 셋 전처리 데이터 셋 전처리를 위해서는 우선적으로 텍스트를 모델이 이해할 수 있는 숫자로 변환해야 합니다. 이전 장에서 보았듯이 이는 토크 나이저가 담당합니다. 토크 나이저에 단일 문장 또는 다중 문장 리스트를 입력할 수 있으므로, 다음과 같이 각 쌍의 모든 첫 번째 문장과 두 번째 문장을 각각 직접 토큰화할 수 있습니다: from transformers import AutoTokenizer checkpoint = "bert-base-uncased" tokenizer = AutoTokenizer.from_pretrained(checkpoint) tokenized_sentences_1 = tokenizer(raw_datasets["train"]["sentence1"]) tokenized_sentences_2 = tokenizer(raw_datasets["train"]["sentence2"]) 하지만 두 개의 시퀀스를 모델에 바로 전달(각각의 문장을 모델에 별도로 매개변 수로 전달) 하여 두 문장이 의역인지 아닌지에 대한 예측을 얻을 수는 없습니다. 두 시퀀스를 쌍(pair)으로 처리(단일 매개변수로 처리) 하고 적절한 전처리를 적용해야 합니다. 다행히도 토크 나이저(tokenizer)는 다음과 같이 한 쌍의 시퀀스를 가져와 BERT 모델이 요구하는 입력 형태로 구성할 수 있습니다: inputs = tokenizer("This is the first sentence.", "This is the second one.") inputs {'input_ids': [101, 2023, 2003, 1996, 2034, 6251, 1012, 102, 2023, 2003, 1996, 2117, 2028, 1012, 102], 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1], 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]} 위 코드에서 만일 첫 번째 및 두 번째 매개변수가 단일 문자열이 아니고 다중 문자열이 담긴 파이썬 리스트라면 각 리스트에 저장된 문자열(문장)의 순서대로 한 쌍씩 토큰화됩니다. 다시 말해서, 첫 번째 리스트의 첫 번째 문자열과 두 번째 리스트의 첫 번째 문자열이 하나의 문자열 쌍으로 입력되는 방식이죠. 2장에서 input_ids 및 attention_mask 키값에 대해서는 논의했지만, token_type_ids에 대한 이야기는 하지 않았습니다. 위의 예에서 보듯이, token_type_ids는 전체 입력(input_ids)의 어느 부분이 첫 번째 문장이고 어느 것이 두 번째 문장인지 모델에 알려줍니다. input_ids 내부의 ID들을 다시 단어로 디코딩 하면: tokenizer.convert_ids_to_tokens(inputs["input_ids"]) ['[CLS]', 'this', 'is', 'the', 'first', 'sentence', '.', '[SEP]', 'this', 'is', 'the', 'second', 'one', '.', '[SEP]'] 따라서 모델은 두 개의 문장으로 구성되고 입력의 형태가 "[CLS] 문장 1 [SEP] 문장 2 [SEP]"와 같이 될 것으로 짐작할 수 있습니다. 이를 token_type_ids와 정렬하면 다음과 같습니다: ['[CLS]', 'this', 'is', 'the', 'first', 'sentence', '.', '[SEP]', 'this', 'is', 'the', 'second', 'one', '.', '[SEP]'] [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1] [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1] 위에서 보는 바와 같이, "[CLS] 문장 1 [SEP]"에 해당하는 입력 부분은 token_type_id가 0이고 "문장 2 [SEP]"에 해당하는 다른 부분은 모두 1입니다. 다른 체크포인트(checkpoint)를 선택한다면, 토큰화된 입력(tokenized inputs)에 token_type_ids가 존재하지 않을 수도 있습니다. 예를 들어, DistilBERT 모델을 사용하는 경우에는 tokenizer가 token_type_ids를 반환하지 않습니다. 모델이 사전학습 과정에서 이러한 형태의 입력<NAME>으로 학습을 진행했을 경우에만 반환됩니다. 여기서, BERT는 토큰 타입 IDs를 사용하여 사전 학습되며, 1장에서 설명한 masked language modeling objectives 외에 다음 문장 예측(next sentence prediction)이라는 추가 objectives가 있습니다. 이 작업의 목표는 문장 간의 관계를 모델링 하는 것입니다. 사전 학습 과정에서 다음 문장 예측(next sentence prediction)을 사용하면 모델에 무작위로 마스킹 된 토큰(masked tokens)이 포함된 문장 쌍이 입력되고 두 번째 문장이 첫 번째 문장을 따르는지를 예측하도록 요구됩니다. 학습 과정에서 이 작업(next sentence prediction)의 난도를 높이기 위해서, 입력의 약 50% 정도는 두 문장이 원본 문서에서 연속적으로 나타나는 쌍 집합이며, 나머지 50%는 문장 쌍을 서로 다른 문서에서 추출된 문장들로 구성하였습니다. 일반적으로, 토큰화 완료된 입력에 token_type_ids가 있는지에 대해 걱정할 필요가 없습니다. 토크 나이저와 모델 모두에 동일한 체크포인트(checkpoint)를 사용하는 한, 토크 나이저는 모델에 무엇을 제공해야 하는지 알고 있기 때문에 아무런 문제가 되지 않습니다. 이제 토크 나이저가 한 쌍의 문장을 처리하는 방법을 보았으므로, 이를 전체 데이터 셋을 토큰 화(tokenize) 하는데 사용할 수 있습니다. 이전 장에서처럼, 우리는 토크 나이저에게 첫 번째 문장 리스트를 제공하고 그다음 두 번째 문장 리스트를 제공함으로써 문장 쌍 리스트를 입력할 수 있습니다. 이것은 2장에서 본 패딩(padding) 및 절단(truncation) 옵션과도 호환됩니다. 따라서 학습 데이터 셋을 전처리하는 한 가지 방법은 다음과 같습니다: tokenized_dataset = tokenizer( raw_datasets["train"]["sentence1"], raw_datasets["train"]["sentence2"], padding=True, truncation=True, ) 이 방법은 잘 작동하지만, input_ids, attention_mask, token_type_ids 및 데이터가 담긴 다차원 리스트가 키로 지정된 tokenized_dataset이라는 별도의 파이썬 딕셔너리를 반환하는 단점이 있습니다. 또한 이 방법은 토큰화하는 동안 전체 데이터 셋을 저장할 충분한 공간의 RAM이 있는 경우에만 작동합니다. 반면, Datasets 라이브러리의 데이터 셋들은 디스크에 저장된 Apache Arrow 파일이므로, 요청한 샘플만 메모리에 로드된 상태로 유지합니다. 특정 데이터를 dataset 객체로 유지하기 위해 Dataset.map() 메서드를 사용합니다. 이 방법은 토큰화(tokenization) 외에 더 많은 전처리가 필요한 경우 유연성을 발휘합니다. map() 메서드는 데이터 셋의 개별 요소에 함수(function)를 적용하여 작동하므로 입력을 토큰화하는 함수를 정의해 보겠습니다: def tokenize_function(example): return tokenizer(example["sentence1"], example["sentence2"], truncation=True) 이 함수는 데이터 셋의 개별 항목이 담긴 딕셔너리를 매개변수로 입력받아서 input_ids, attention_mask 및 token_type_ids 키가 지정된 새로운 딕셔너리를 반환합니다. 이전에 본 것처럼 토크 나이저(tokenizer)는 문장 쌍 리스트에서 작동하기 때문에 example 딕셔너리에 여러 샘플(각 키가 문장 목록임)이 포함된 경우에도 작동합니다. 이렇게 하면 map() 호출에서 batched=True 옵션을 사용할 수 있어 토큰화 속도가 크게 빨라집니다. 토크 나이저는 Tokenizers 라이브러리에서 Rust로 작성된 또 다른 토크 나이저에 의해 지원됩니다. 이 토크 나이저는 매우 빠를 수 있지만, 한 번에 많은 입력을 제공하는 경우에만 그렇습니다. 일단 현재는 토큰화 함수에서 padding 매개변수를 생략했습니다. 이는 모든 샘플들을 최대 길이로 채우는 것(padding)이 효율적이지 않기 때문입니다. 배치(batch) 형태로 실행할 때 샘플을 채우는 것(padding)이 효과를 발휘합니다. 그러면 전체 데이터 셋에서의 최대 길이가 아니라 해당 배치(batch) 내에서의 최대 길이로 채우기만(padding) 하면 되기 때문입니다. 이것은 입력의 길이가 매우 가변적일 때 많은 시간과 처리 능력을 절약할 수 있습니다! 다음은 한 번에 모든 데이터 셋에 토큰화 기능을 적용하는 방법입니다. map 메서드 호출에서 batched=True를 사용하므로 함수가 각 요소에 개별적으로 적용되지 않고 데이터 셋의 하부 집합, 즉 각 배치(batch) 내에 존재하는 모든 요소들에 한꺼번에 적용됩니다. 이 방법은 더 빠른 전처리를 가능하게 합니다: tokenized_datasets = raw_datasets.map(tokenize_function, batched=True) tokenized_datasets 0%| | 0/4 [00:00<?, ?ba/s] 0%| | 0/1 [00:00<?, ?ba/s] 0%| | 0/2 [00:00<?, ?ba/s] DatasetDict({ train: Dataset({ features: ['attention_mask', 'idx', 'input_ids', 'label', 'sentence1', 'sentence2', 'token_type_ids'], num_rows: 3668 }) validation: Dataset({ features: ['attention_mask', 'idx', 'input_ids', 'label', 'sentence1', 'sentence2', 'token_type_ids'], num_rows: 408 }) test: Dataset({ features: ['attention_mask', 'idx', 'input_ids', 'label', 'sentence1', 'sentence2', 'token_type_ids'], num_rows: 1725 }) }) Datasets 라이브러리는 데이터 셋(datasets)에 새로운 필드들을 추가합니다. 이 필드들은 전처리 함수에서 반환된 사전의 각 키(input_ids, token_type_ids, attention_mask)에 해당합니다. num_proc 매개변수를 전달하여 map()으로 전처리 기능을 적용할 때 다중 처리(multi-processing)를 사용할 수도 있습니다. Tokenizers 라이브러리는 샘플을 더 빠르게 토큰화하기 위해 이미 다중 스레드(multiple threads)를 사용하지만, 이 라이브러리에서 지원하는 "빠른 토크 나이저(fast tokenizer)"를 사용하지 않는 경우 전처리 속도가 빨라질 수 있습니다. 위의 tokenize_function은 input_ids, attention_mask 및 token_type_ids 키가 존재하는 딕셔너리를 반환하므로 이 3 개의 새로운 필드가 데이터 셋의 모든 분할(학습, 검증, 평가)에 추가됩니다. 전처리 함수가 map()을 적용한 데이터 셋의 기존 키들 즉, idx, label 등에 대한 새로운 값을 반환한 경우 기존 필드(idx, label, sentence1, sentence2 등)를 변경할 수도 있습니다. 마지막으로 해야 할 일은 전체 요소들을 배치(batch)로 분리할 때 가장 긴 요소의 길이로 모든 예제를 채우는(padding) 것입니다. 이를 동적 패딩(dynamic padding)이라고 합니다. 동적 패딩(Dynamic padding) 샘플들을 함께 모아서 지정된 크기의 배치(batch)로 구성하는 역할을 하는 함수를 콜레이트 함수(collate function)라고 합니다. 이 함수는 DataLoader를 빌드(build) 할 때 전달할 수 있는 매개변수입니다. 기본값은 단순히 샘플들을 PyTorch 텐서로 변환하고 결합하는 함수입니다. 만일 대상 샘플들이 리스트, 튜플 혹은 딕셔너리 면 재귀적으로 이 작업이 수행됩니다. 우리 예제의 경우, 입력값이 모두 동일한 크기(길이)가 아니기 때문에 이 작업이 불가능합니다. 지금까지 우리는 일부러 패딩(padding) 작업을 미뤄왔는데 그 이유는 전체 데이터 셋이 아닌 개별 배치(batch)에 대해서 별도로 패딩(padding)을 수행하여 과도하게 긴 입력으로 인한 과도한 패딩(padding) 작업을 방지하기 위함입니다. 이렇게 하면 학습 속도가 상당히 빨라지지만 TPU에서 학습하는 경우 문제가 발생할 수 있습니다. TPU는 추가적인 패딩(padding)이 필요한 경우에도 전체 데이터 셋이 고정된 형태를 선호합니다. 실제로 이를 수행하려면, 배치(batch)로 분리하려는 데이터 셋의 요소 각각에 대해서 정확한 수의 패딩(padding)을 적용할 수 있는 콜레이트 함수(collate function)를 정의해야 합니다. 다행히도, Transformers 라이브러리는 DataCollatorWithPadding을 통해 이러한 기능을 제공합니다. 이 함수는 토크 나이저를 입력으로 받습니다. 그 이유는 사용하려는 패딩 토큰(padding token)이 무엇인지와 모델이 입력의 왼쪽 혹은 오른쯕 중 어느 쪽에 패딩(padding)을 수행할지를 파악하기 위함입니다. 이 입력 하나면 모든 것이 해결됩니다: from transformers import DataCollatorWithPadding data_collator = DataCollatorWithPadding(tokenizer=tokenizer) 이 새로운 함수를 테스트하기 위해 학습 집합에서 배치(batch)로 묶을 몇 개의 샘플들을 가져오겠습니다. 여기서는 필요하지도 않을뿐더러 심지어 문자열까지도 포함하는 idx, sentence1 및 sentence2 열을 제거합니다(문자열로는 텐서를 생성할 수 없습니다). 아래에서 배치(batch) 내의 각 요소들의 길이를 살펴보세요: samples = tokenized_datasets["train"][:8] samples = {k: v for k, v in samples.items() if k not in ["idx", "sentence1", "sentence2"]} [len(x) for x in samples["input_ids"]] [50, 59, 47, 67, 59, 50, 62, 32] 당연히, 32에서 67까지 다양한 길이의 샘플을 얻을 수 있습니다. 동적 패딩(dynamic padding)은 이 배치(batch) 내의 모든 샘플들이 배치 내부에서 최대 길이인 67 길이로 패딩(padding) 되어야 함을 의미합니다. 동적 패딩(dynamic padding)이 없으면 모든 샘플들은 전체 데이터 셋의 최대 길이 또는 모델이 허용할 수 있는 최대 길이로 채워져야 합니다. data_collator가 동적으로 배치(batch)를 적절하게 패딩(padding) 하는지 다시 확인합시다: batch = data_collator(samples) {k: v.shape for k, v in batch.items()} {'attention_mask': torch.Size([8, 67]), 'input_ids': torch.Size([8, 67]), 'token_type_ids': torch.Size([8, 67]), 'labels': torch.Size([8])} 좋습니다! 원시 텍스트에서 모델이 처리할 수 있는 배치(batch) 형태로 변경되었으므로, 이제 미세 조정(fine-tuning) 할 준비가 되었습니다! 2. Trainer API를 이용한 모델 미세 조정(fine-tuning) Transformers는 Trainer 클래스를 제공함으로써 여러분의 데이터 셋을 이용하여 사전 학습된 모델(pretrained models)을 미세 조정(fine-tuning) 할 수 있도록 도와줍니다. 이전 섹션에서 설명한 모든 데이터 전처리 작업을 완료했다면, Trainer를 정의하는데 몇 가지 단계만 거치면 됩니다. 가장 어려운 부분은 Trainer.train()을 실행할 환경을 준비하는 것입니다. 이 작업 자체가 CPU에서 매우 느리게 실행되기 때문입니다. GPU가 설정되지 않은 경우, Google Colab에서 무료 GPU 또는 TPU에 액세스할 수 있습니다. 아래 코드 예제에서는 이전 섹션의 예제를 모두 실행했다고 가정합니다. 이 코드는 이번 섹션의 예제를 실행하기 위해 필요한 사항을 간략하게 요약한 것입니다: from datasets import load_dataset from transformers import AutoTokenizer, DataCollatorWithPadding raw_datasets = load_dataset("glue", "mrpc") checkpoint = "bert-base-uncased" tokenizer = AutoTokenizer.from_pretrained(checkpoint) def tokenize_function(example): return tokenizer(example["sentence1"], example["sentence2"], truncation=True) tokenized_datasets = raw_datasets.map(tokenize_function, batched=True) data_collator = DataCollatorWithPadding(tokenizer=tokenizer) 학습 (Training) Trainer를 정의하기 전에 먼저 수행할 단계는 Trainer가 학습 및 평가에 사용할 모든 하이퍼 파라미터(hyperparameters)를 포함하는 TrainingArguments 클래스를 정의하는 것입니다. 여기서 우리가 제공해야 할 유일한 매개변수는 학습된 모델이 저장될 디렉터리입니다. 나머지는 모두 기본값(default values)을 그대로 활용하면 됩니다. 기본적인 미세 조정(fine-tuning)에는 이 정도면 충분합니다. from transformers import TrainingArguments training_args = TrainingArguments("test-trainer") 두 번째 단계는 모델을 정의하는 것입니다. 이전 장에서와 같이, 두 개의 레이블이 있는 AutoModelForSequenceClassification 클래스를 사용합니다. from transformers import AutoModelForSequenceClassification model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2) 2장과 달리, 사전 학습된 모델을 인스턴스화한 후 경고(warnings)가 출력되는 것을 알 수 있습니다. 이는 BERT가 문장 쌍 분류에 대해 사전 학습되지 않았기 때문에 사전 학습된 모델의 헤드(model head)를 버리고 시퀀스 분류에 적합한 새로운 헤드를 대신 추가했기 때문입니다. 경고의 내용은 일부 가중치(weights)가 사용되지 않았으며(제거된 사전 학습 헤드에 해당하는 가중치) 일부 가중치가 무작위로 초기화되었음을(새로운 헤드에 대한 가중치) 나타냅니다. 마지막 부분에서 우리가 수행하는 문장 쌍 분류에 대한 미세 조정을 해도 좋다고 설명하고 있습니다. 모델(model), training_args, 학습 집합 및 검증 집합, data_collator 및 토크 나이저 등, 지금까지 구성된 모든 개체를 전달하여 Trainer를 정의할 수 있습니다: from transformers import Trainer trainer = Trainer( model, training_args, train_dataset=tokenized_datasets["train"], eval_dataset=tokenized_datasets["validation"], data_collator=data_collator, tokenizer=tokenizer, ) 위에서 보듯이, 토크 나이저를 전달할 때 Trainer가 사용하는 기본 data_collator는 이전에 정의된 DataCollatorWithPadding이 됩니다. 따라서 이 호출에서 data_collator=data_collator 행을 생략할 수 있습니다. 데이터 셋으로 모델을 미세 조정(fine-tuning) 하려면 Trainer의 train() 메서드를 호출하기만 하면 됩니다: trainer.train() 미세 조정이 시작되고(GPU에서 몇 분 정도 소요됨) 500단계마다 학습 손실(training loss)이 보고됩니다. 그러나 모델의 성능이 좋은지 혹은 나쁜지는 알려주지 않습니다. 그 이유는 다음과 같습니다: 학습 과정에서 평가가 수행되도록 Trainer에게 evaluation_strategy 매개변수를 "steps"(매 eval_steps마다 평가)나 "epoch"(각 epoch 마지막에 평가) 등으로 지정하지 않았습니다. 평가 방법 혹은 평가 척도를 정의한 compute_metrics() 함수를 Trainer에 지정하지 않았습니다. 평가 방법 지정이 안된 상태에서는 평가 과정에서 손실(loss)을 출력했을 것입니다. 직관적인 값은 아니지요. 평가 (Evaluation) 유용한 compute_metrics() 함수를 구현하고 이를 학습할 때 사용하는 방법을 살펴보겠습니다. 이 함수는 EvalPrediction 객체(predictions 필드와 label_ids 필드가 포함된 네임드튜플(named tuple))를 필요로 하며 문자열과 실숫값(floats)을 매핑하는 딕셔너리를 반환합니다. 여기서 문자열은 반환된 메트릭(metrics)의 이름이고 실숫값(floats)은 해당 메트릭에 기반한 평가 결과값입니다. 우선 모델에서 예측의 결과를 얻으려면 Trainer.predict() 명령을 사용할 수 있습니다: predictions = trainer.predict(tokenized_datasets["validation"]) print(predictions.predictions.shape, predictions.label_ids.shape) predict() 메서드의 출력은 3개의 필드(predictions, label_ids 및 metrics)가 있는 또 다른 네임드튜플(named tuple)입니다. metrics 필드에는 전달된 데이터 셋의 손실(loss)과 시간 메트릭(time metrics) 값만 포함됩니다. 시간 메트릭(time metrics)은 예측에 걸린 전체 및 평균 시간을 나타냅니다. compute_metrics() 함수를 구성하고 Trainer에 전달하면 해당 필드에는 compute_metrics()에서 반환한 메트릭(metrics)도 포함됩니다. 보시다시피 predictions은 모양이 408 x 2인 2차원 배열입니다. 408은 우리가 예측에 사용한 데이터 셋의 요소 개수입니다. 이는 우리가 predict()에 전달한 데이터 셋의 각 요소에 대한 로짓(logit)값들입니다. 이전 장에서 보았듯이 모든 Transformer 모델은 로짓(logit)값을 반환합니다. 이 로짓(logit)값들을 레이블과 비교할 수 있는 예측 결과로 변환하려면 두 번째 축(second axis)에 존재하는 항목에서 최댓값이 있는 인덱스를 가져와야 합니다: import numpy as np preds = np.argmax(predictions.predictions, axis=-1) 이제 preds를 레이블(labels)과 비교할 수 있습니다. compute_metric() 함수를 구성하기 위해 Datasets 라이브러리에서 제공하는 메트릭(metrics)을 사용합니다. load_metric() 함수를 사용하여 데이터 셋을 로드하는 것처럼 손쉽게 MRPC 데이터 셋과 관련된 메트릭(metrics)을 로드할 수 있습니다. 로드된 객체에는 메트릭(metrics) 계산을 수행하는 데 사용할 수 있는 compute() 메서드가 있습니다: from datasets import load_metric metric = load_metric("glue", "mrpc") metric.compute(predictions=preds, references=predictions.label_ids) 모델 헤드를 무작위로 초기화하면 계산된 메트릭이 변경될 수 있으므로 정확한 결과는 다를 수 있습니다. 여기서는 모델이 검증 집합에서 86.76%의 정확도(accuracy)와 90.69의 F1 점수를 가지고 있음을 알 수 있습니다(여러분의 결괏값과는 다를 수도 있습니다.). 이는 GLUE 벤치마크의 MRPC 데이터 셋에 대한 예측 결과를 평가하는 데 사용되는 두 가지 메트릭(metrics)입니다. BERT 논문의 테이블은 기본 모델에 대해 F1 점수 88.9를 보고했습니다. 해당 논문에서 사용된 모델은 소문자 모델(uncased model)이었고 여기서는 대소문자 구분 모델(cased model)을 활용했으므로 성능 차이가 발생하고 있습니다. 지금까지 설명한 모든 것을 함께 종합하면 compute_metrics() 함수를 얻을 수 있습니다: def compute_metrics(eval_preds): metric = load_metric("glue", "mrpc") logits, labels = eval_preds predictions = np.argmax(logits, axis=-1) return metric.compute(predictions=predictions, references=labels) 각 에포크(epoch)가 끝날 때 메트릭(metrics)을 출력하도록 하기 위해서, compute_metrics() 함수를 사용하여 새 Trainer를 정의하는 방법을 아래 코드에서 보여주고 있습니다: training_args = TrainingArguments("test-trainer", evaluation_strategy="epoch") model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2) trainer = Trainer( model, training_args, train_dataset=tokenized_datasets["train"], eval_dataset=tokenized_datasets["validation"], data_collator=data_collator, tokenizer=tokenizer, compute_metrics=compute_metrics, ) evaluation_strategy 매개변수가 "epoch"으로 설정되고 새로운 TrainingArguments와 모델을 생성합니다. 그렇지 않으면 이미 앞에서 학습된(fine-tuned) 모델의 학습을 계속해서 수행할 것입니다. 새로운 학습 실행을 시작하기 위해 다음을 실행합니다: trainer.train() 이번에는 학습 손실(training loss) 외에 각 epoch가 끝날 때 검증 손실(validation loss) 및 메트릭(metrics)을 보고합니다. 다시 말하지만, 정확한 정확도(accuracy)/F1 점수는 모델의 무작위 헤드 초기화로 인해 각각의 실행 결과가 약간 다를 수 있지만 유사한 범위 내에 있어야 합니다. Trainer는 다중 GPU 또는 TPU에서 즉시 사용할 수 있으며 혼합 정밀도 학습(mixed-precision training, 학습 매개변수에서 fp16 = True 사용하는 경우)과 같은 다양한 옵션을 제공합니다. 10장에서 지원하는 모든 옵션들을 살펴볼 것입니다. 이것으로 Trainer API를 사용한 미세 조정(fine-tuning) 방법에 대한 설명을 마칩니다. 가장 자주 수행되는 NLP 작업(tasks)에 대해 이 작업을 수행하는 예는 7장에서 제공되지만, 다음 섹션에서 이 API를 사용하지 않고 PyTorch에서 동일한 작업을 수행하는 방법을 살펴보겠습니다. 3. 전체 학습 (Full Training) 이제 Trainer 클래스를 사용하지 않고 이전 섹션에서 했던 것과 동일한 결과를 얻는 방법을 살펴보겠습니다. 다시 말하지만, 섹션 2에서 이미 데이터 처리를 완료했다고 가정합니다. 이번 섹션을 공부할 때 필요한 모든 작업을 수행하는 코드는 다음과 같습니다: from datasets import load_dataset from transformers import AutoTokenizer, DataCollatorWithPadding raw_datasets = load_dataset("glue", "mrpc") checkpoint = "bert-base-uncased" tokenizer = AutoTokenizer.from_pretrained(checkpoint) def tokenize_function(example): return tokenizer(example["sentence1"], example["sentence2"], truncation=True) tokenized_datasets = raw_datasets.map(tokenize_function, batched=True) data_collator = DataCollatorWithPadding(tokenizer=tokenizer) 학습을 위한 준비 실제로 학습 루프(training loop)를 작성하기 전에 몇 가지 객체를 정의해야 합니다. 첫 번째는 배치(batch)를 반복하는 데 사용할 dataloaders입니다. 그러나 이 dataloaders를 정의하기 전에 Trainer가 자동으로 수행한 몇 가지 작업을 직접 처리하기 위해 tokenized_datasets에 약간의 후처리를 적용해야 합니다. 구체적으로 다음을 수행해야 합니다: 모델이 필요로 하지 않는 값이 저장된 열(columns)을 제거합니다. (sentence1, sentence2 등) 열 레이블(column label)의 이름을 labels로 바꿉니다. 이는 모델이 labels라는 이름으로 매개변수를 받기 때문입니다. 파이썬 리스트 대신 PyTorch 텐서(tensors)를 반환하도록 datasets의<NAME>을 설정합니다. tokenized_datasets에는 이러한 작업을 위한 별도의 메서드들이 존재합니다: tokenized_datasets = tokenized_datasets.remove_columns(["sentence1", "sentence2", "idx"]) tokenized_datasets = tokenized_datasets.rename_column("label", "labels") tokenized_datasets.set_format("torch") tokenized_datasets["train"].column_names 위에서 보듯이 결과적으로 tokenized_datasets에는 모델이 허용하는 columns만 존재함을 알 수 있습니다. 이제 이 작업이 완료되었으므로 dataloader를 쉽게 정의할 수 있습니다: from torch.utils.data import DataLoader train_dataloader = DataLoader( tokenized_datasets["train"], shuffle=True, batch_size=8, collate_fn=data_collator, ) eval_dataloader = DataLoader( tokenized_datasets["validation"], batch_size=8, collate_fn=data_collator, ) 데이터 처리에 오류가 없는지 빠르게 확인하기 위해 다음과 같이 배치(batch)를 검사할 수 있습니다: for batch in train_dataloader: break {k: v.shape for k, v in batch.items()} 실제 데이터 형태(shapes)가 살짝 다를 수 있는데 이는 학습 dataloader에 대해 shuffle=True를 설정하고 배치(batch) 내에서의 최대 길이로 패딩(padding) 하기 때문입니다. 이제 데이터 전처리가 완전히 끝났습니다. 기계학습 실무자(ML practitioners)들에게는 만족스럽기도 하겠지만 일부 명확하지 않은 부분도 있을 수 있겠습니다. 이제 모델로 돌아가 봅시다. 이전 섹션에서 수행한 것과 동일한 방법으로 모델을 인스턴스화(instantiate) 합니다: from transformers import AutoModelForSequenceClassification model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2) 학습 과정에서 모든 것들이 원활하게 진행될 수 있는지 확인하기 위해 배치(batch)를 이 모델에 한번 전달해 봅시다: outputs = model(**batch) print(outputs.loss, outputs.logits.shape) 모든 Transformers 모델은 매개변수에 labels이 포함되어 있다면 손실(loss)과 함께 logit 값(batch 내 각 입력에 대해 logit 값이 2개이므로 크기가 8 x 2인 텐서)도 반환합니다. 학습 루프(training loop)를 작성할 준비가 거의 되었습니다! 그런데 아직 최적화 함수(optimizer) 및 학습률 스케줄러(learning rate scheduler) 지정 작업이 남아 있습니다. 여기서는 앞에서 배운 Trainer의 기본 설정을 그대로 사용하겠습니다. Trainer가 사용하는 최적화 함수는 AdamW이며 이는 Adam과 거의 동일하지만 weight decay regularization을 적용했다는 사실에 차이가 납니다: from transformers import AdamW optimizer = AdamW(model.parameters(), lr=5e-5) 마지막으로, Trainer에서 디폴트로 사용되는 학습률 스케줄러(learning rate scheduler)는 최댓값(5e-5)에서 0까지 선형 감쇠(linear decay) 합니다. 이를 적절하게 정의하려면 우리가 수행할 학습 단계의 횟수를 알아야 합니다. 이는 실행하려는 에포크(epochs) 수에 학습 배치(batch)의 개수를 곱한 것입니다. 학습 배치의 개수는 학습 dataloader의 길이와 같습니다. Trainer는 디폴트로 3개의 에포크(epochs)를 사용하므로 다음을 따릅니다: from transformers import get_scheduler num_epochs = 3 num_training_steps = num_epochs * len(train_dataloader) lr_scheduler = get_scheduler( "linear", optimizer=optimizer, num_warmup_steps=0, num_training_steps=num_training_steps, ) print(num_training_steps) 학습 루프 (Training Loop) 가용 GPU가 있는 경우 GPU를 사용하는 것이 좋습니다. CPU를 사용하면 학습은 몇 분 정도가 아니라 몇 시간이 걸립니다. 이를 위해, 모델과 배치(batch)를 적재할 장치(device)를 정의합니다: import torch device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu") model.to(device) device 이제 학습할 준비가 되었습니다! 학습이 언제 끝날지 정보를 얻기 위해 tqdm 라이브러리를 사용하여 학습 단계(training steps)를 기준으로 진행 표시줄(progress bar)을 출력할 수 있도록 합니다: from tqdm.auto import tqdm progress_bar = tqdm(range(num_training_steps)) model.train() for epoch in range(num_epochs): for batch in train_dataloader: batch = {k: v.to(device) for k, v in batch.items()} outputs = model(**batch) loss = outputs.loss loss.backward() optimizer.step() lr_scheduler.step() optimizer.zero_grad() progress_bar.update(1) 학습 루프(training loop)의 주요 부분이 본 강좌의 소개(Introduction) 장에서 소개한 내용과 매우 유사하다는 것을 알 수 있습니다. 위 코드에서는 어떠한 중간 출력도 없으므로, 모델의 성능이나 손실 등에 대해 아무것도 알려주지 않습니다. 이를 위해 평가 루프(evaluation loop)를 추가해야 합니다. 평가 루프 (Evaluation Loop) 이전에 수행했던 것처럼, Datasets 라이브러리에서 제공하는 평가 메트릭(metrics)을 사용합니다. 우리는 이미 metric.compute() 메서드를 살펴보았지만 metric.add_batch() 메서드로 평가 루프(evaluation loop)를 실행하면서 배치(batch) 별 평가 메트릭(metrics) 계산 결과를 누적할 수 있습니다. 모든 배치(batch)를 누적하고 나면 metric.compute()로 최종 결과를 얻을 수 있습니다. 평가 루프에서 이 모든 것을 구현하는 방법은 다음과 같습니다: from datasets import load_metric metric = load_metric("glue", "mrpc") model.eval() for batch in eval_dataloader: batch = {k: v.to(device) for k, v in batch.items()} with torch.no_grad(): outputs = model(**batch) logits = outputs.logits predictions = torch.argmax(logits, dim=-1) metric.add_batch(predictions=predictions, references=batch["labels"]) metric.compute() 다시 말하지만, 모델 헤드 초기화(model head initialization) 및 데이터 셔플링의 무작위성(randomness) 인해 결과가 약간 차이가 나긴 하지만 그 차이가 크면 안 됩니다. Accelerate 라이브러리를 사용한 학습 루프 가속화 앞에서 정의한 학습 루프(training loop)는 단일 CPU 또는 단일 GPU에서 제대로 작동합니다. 그러나 Accelerate 라이브러리를 사용하여 몇 가지 설정만 하면 여러 GPU 또는 TPU에서 분산 학습(distributed training)을 수행할 수 있습니다. 학습 및 검증 dataloader를 생성한 후, 학습 루프(training loop)의 형태는 다음과 같습니다: from transformers import AdamW, AutoModelForSequenceClassification, get_scheduler model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2) optimizer = AdamW(model.parameters(), lr=3e-5) device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu") model.to(device) num_epochs = 3 num_training_steps = num_epochs * len(train_dataloader) lr_scheduler = get_scheduler( "linear", optimizer=optimizer, num_warmup_steps=0, num_training_steps=num_training_steps, ) progress_bar = tqdm(range(num_training_steps)) model.train() for epoch in range(num_epochs): for batch in train_dataloader: batch = {k: v.to(device) for k, v in batch.items()} outputs = model(**batch) loss = outputs.loss loss.backward() optimizer.step() lr_scheduler.step() optimizer.zero_grad() progress_bar.update(1) 위 학습 루프를 수정한 변경 사항은 다음과 같습니다: from accelerate import Accelerator from transformers import AdamW, AutoModelForSequenceClassification, get_scheduler accelerator = Accelerator() model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2) optimizer = AdamW(model.parameters(), lr=3e-5) train_dataloader, eval_dataloader, model, optimizer = accelerator.prepare( train_dataloader, eval_dataloader, model, optimizer ) num_epochs = 3 num_training_steps = num_epochs * len(train_dataloader) lr_scheduler = get_scheduler( "linear", optimizer=optimizer, num_warmup_steps=0, num_training_steps=num_training_steps ) progress_bar = tqdm(range(num_training_steps)) model.train() for epoch in range(num_epochs): for batch in train_dataloader: outputs = model(**batch) loss = outputs.loss accelerator.backward(loss) optimizer.step() lr_scheduler.step() optimizer.zero_grad() progress_bar.update(1) 추가할 첫 번째 라인은 import 라인입니다. 두 번째 추가 라인에서 시스템 환경 설정을 파악하고 적절한 분산 설정을 초기화하는 Accelerator 개체를 인스턴스화합니다. Accelerate가 장치 배치(device placement)를 자동으로 처리하므로 장치에 모델을 배치하는 라인(model.to(device))을 제거할 수 있습니다. 아니면 원할 경우, device 대신 accelerator.device를 사용하도록 변경할 수 있습니다. 그런 다음 dataloaders, 모델(model) 및 최적화 함수(optimizer)를 accelerator.prepare()로 입력하는 부분에서 대부분의 작업이 수행됩니다. 이 과정에서 입력한 객체들을 적절한 컨테이너로 감싸서(wrapping) 분산 학습(distributed training)이 의도대로 작동되도록 합니다. 나머지 변경 사항은 device에 배치(batch)를 복사하는 라인을 제거(해당 라인을 그대로 유지하고 싶다면 device 대신에 accelerate.device를 사용하세요.) 하고 loss.backward()를 accelerator.backward()로 대치하는 작업입니다. Cloud TPU가 제공하는 속도 향상의 이점을 얻으려면 토크 나이저의 padding="max_length" 및 max_length 인수를 사용하여 샘플을 고정 길이로 채우는 것이 좋습니다. 전체 코드를 복사하여 사용하고 싶다면 Accelerate를 사용한 다음의 완전한 학습 루프(training loop)를 참고하세요: from accelerate import Accelerator from transforlers import AdamW, AutoModelForSequenceClassification, get_scheduler accelerator = Accelerator() model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2) optimizer = AdamW(model.parameters(), lr=3e-5) train_dl, eval_dl, model, optimizer = accelerator.prepare( train_dataloader, eval_dataloader, model, optimizer ) num_epochs = 3 num_training_steps = num_epochs * len(train_dl) lr_scheduler = get_scheduler( "linear", optimizer=optimizer, num_warmup_steps=0, num_training_steps=num_training_steps, ) progress_bar = tqdm(range(num_training_steps)) model.train() for epoch in range(num_epochs): for batch in train_dl: outputs = model(**batch) loss = outputs.loss accelerator.backward(loss) optimizer.step() lr_scheduler.step() optimizer.zero_grad() progress_bar.update(1) 위 코드를 train.py 스크립트에 붙여넣기하여 모든 종류의 분산 환경(distributed setup)에서 스크립트를 실행할 수 있습니다. 분산 환경에서 사용해 보려면 다음 명령을 실행하십시오 (노트북 환경에서 실행하면 안 됩니다. 반드시 서버에 로그인을 해서 실행해야 그 결과가 보입니다): accelerate config 몇 가지 질문에 답하라는 메시지가 뜨고 이 명령이 사용하는 구성 파일에 입력된 답을 덤프 하라는 메시지가 표시됩니다: accelerate launch train.py 위 명령어로 분산 학습(distributed training)을 시작합니다. Notebook에서 이것을 시도하려면(예를 들어, Colab의 TPU로 테스트하기 위해) training_function()에 코드를 붙여 넣고 다음을 사용하여 마지막 셀을 실행하세요: from accelerate import notebook_launcher notebook_launcher(training_function) Accelerate에 대한 더 많은 예제는 Accelerate repo를 참고하세요. 아래는 지금까지 공부한 모든 내용(데이터 전처리, 모델 정의, 학습 루프 지정, 단, Accelerate는 제외)을 총망라하여 정리한 코드입니다. 참고하시기 바랍니다: from datasets import load_dataset, load_metric from transformers import AutoTokenizer, DataCollatorWithPadding, AutoModelForSequenceClassification, AdamW, get_scheduler import torch from torch.utils.data import DataLoader from tqdm.auto import tqdm # 데이터 셋 적재 raw_datasets = load_dataset("glue", "mrpc") # 사전학습 언어 모델 checkpoint 이름 지정 checkpoint = "bert-base-uncased" # 지정된 사전학습 언어 모델에서 토크나이저 인스턴스화 tokenizer = AutoTokenizer.from_pretrained(checkpoint) # 토크 나이저 함수 사용자 정의화 (sentence1, sentence2 칼럼에 대해서만 토크나이징 수행) def tokenize_function(example): return tokenizer(example["sentence1"], example["sentence2"], truncation=True) # 토크나이징 수행 tokenized_datasets = raw_datasets.map(tokenize_function, batched=True) # 배치(batch) 별 패딩(padding)을 위한 data collator 정의 data_collator = DataCollatorWithPadding(tokenizer=tokenizer) # 불필요한 입력 칼럼을 제거하고 사전학습 언어 모델에 필요한 입력만 남김. tokenized_datasets = tokenized_datasets.remove_columns(["sentence1", "sentence2", "idx"]) # 데이터 셋의 label 칼럼명을 labels로 변경 tokenized_datasets = tokenized_datasets.rename_column("label", "labels") # 데이터 셋의 유형을 PyTorch tensor로 변경 tokenized_datasets.set_format("torch") # 변경된 칼럼 출력 print(tokenized_datasets["train"].column_names) # 각 종류별 데이터 로더 생성 train_dataloader = DataLoader(tokenized_datasets["train"], shuffle=True, batch_size=8, collate_fn=data_collator) eval_dataloader = DataLoader(tokenized_datasets["validation"], shuffle=True, batch_size=8, collate_fn=data_collator) # 사전학습 언어 모델 인스턴스화 model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2) # 최적화 함수 정의 optimizer = AdamW(model.parameters(), lr=5e-5) # 에포크 개수 설정 num_epochs = 3 # 학습 스텝 수 계산 num_training_steps = num_epochs * len(train_dataloader) # 학습 스케줄러 설정 lr_scheduler = get_scheduler("linear", optimizer=optimizer, num_warmup_steps=0, num_training_steps=num_training_steps) # GPU로 모델을 이동 device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu") model.to(device) # 진행 상황바 정의 progress_bar = tqdm(range(num_training_steps)) # 모델을 학습 모드로 전환 model.train() # 학습 루프 시작 for epoch in range(num_epochs): for batch in train_dataloader: # 현재 배치 중에서 입력값을 모두 GPU로 이동. batch = {k: v.to(device) for k, v in batch.items()} # 모델 실행 outputs = model(**batch) # 손실 값 가져오기 loss = outputs.loss # 역전파 수행 loss.backward() optimizer.step() lr_scheduler.step() optimizer.zero_grad() progress_bar.update(1) # 평가 메트릭 가져오기 metric = load_metric("glue", "mrpc") # 모델을 평가 모드로 전환 model.eval() for batch in eval_dataloader: batch = {k: v.to(device) for k, v in batch.items()} with torch.no_grad(): outputs = model(**batch) logits = outputs.logits predictions = torch.argmax(logits, dim=-1) metric.add_batch(predictions=predictions, references=batch["labels"]) # 평가 결과 계산 및 출력 metric.compute() 4. 3장 요약 (Summary) 지금까지 재미있었나요? 1장과 2장에서 모델과 토크 나이저에 대해 공부했고 또한 자체 데이터 셋을 가지고 모델과 토크 나이저를 미세 조정(fine-tuning) 하는 방법을 알게 되었습니다. 요약하면 3장에서는 다음의 내용을 배웠습니다: Hub의 데이터 셋(datasets)에 대해 알아보았습니다. 동적 패딩(dynamic padding) 및 콜레 이터(collator) 사용 방법을 포함하여 데이터 셋을 로드하고 전처리하는 방법을 배웠습니다. 모델에 대한 미세 조정(fine-tuning) 및 평가(evaluation) 코드를 구현했습니다. 저 수준 학습 루프(low-level training loop)를 구현했습니다. Accelerate를 이용해서 학습 루프(training loop)가 다중 GPU 또는 TPU에서 작동하도록 코드를 수정했습니다. 4장. 모델 및 토크 나이저 공유 주요 웹사이트인 Hugging Face Hub는 누구든지 새로운 최첨단(state-of-the-art) 모델 및 데이터 셋(datasets)을 발견하고, 사용하며 및 기여할 수 있는 핵심적인 플랫폼입니다. 이 사이트는 10,000개 이상의 공개적으로 사용할 수 있는 다양한 모델을 호스팅하고 있습니다. 이번 장에서는 모델(models)에 초점을 맞추고 5장에서는 데이터 셋(datasets)을 주로 살펴보겠습니다. Hub에 포함된 모델들은 Transformers 또는 NLP에 국한되지 않습니다. NLP 용 Flair 및 AllenNLP, 음성(speech) 처리를 위한 Asteroid 및 pyannote, 시각(vision)용 timm 등의 모델도 존재합니다. 이러한 각 모델들은 버전 관리(versioning) 및 재현성(reproducibility)을 지원하는 Git 리포지토리(repository)로 호스팅 됩니다. Hub에서 모델을 공유한다는 것은 커뮤니티에 모델을 공개하고 이를 쉽게 사용하려는 모든 사람이 액세스할 수 있도록 함으로써, 모델을 직접 학습할 필요가 없이 모델 공유 및 사용을 단순화하는 것을 의미합니다. 또한 Hub에서 모델을<NAME>면 해당 모델에 대해 호스팅 된 추론 API(inference API)가 자동으로 배포됩니다. 커뮤니티의 누구든지 사용자 정의 입력(custom inputs) 및 적절한 위젯(widgets)을 사용하여 모델 페이지에서 직접 무료로 테스트할 수 있습니다. 가장 좋은 점은 Hub에서 모든 공개 모델들을<NAME>고 사용하는 것이 완전히 무료라는 것입니다! 모델을 개인적으로<NAME>려는 경우 유료 플랜(paid plans)도 있습니다. 아래<NAME>상은 Hub를 탐색하는 방법을 보여줍니다. https://youtu.be/XvSGPZFEjDY 이번 장에서는 Hugging Face Hub에서 리포지토리를 만들고 관리할 것이기 때문에, huggingface.co 계정이 있어야 합니다: 계정 만들기 4장은 다른 내용에 비해서 그 중요도가 조금 낮습니다. 그래서 다른 장부터 먼저 작업을 진행하고 향후에 추가적으로 포스팅하겠습니다. 조금만 기다려주세요. 5장. Datasets 라이브러리 우리는 3장에서 Datasets 라이브러리를 처음 살펴보았고 모델을 미세조정(fine-tuning) 하는 데 3가지 주요 단계가 있음을 확인했습니다: Hugging Face Hub에서 dataset을 로드합니다. Dataset.map()을 사용하여 데이터를 전처리합니다. Metric을 로드하고 계산합니다. 하지만 이는 Datasets가 수행할 수 있는 기능의 극히 일부만 살펴본 것일 뿐입니다! 이 장에서는 이 라이브러리에 대해 보다 자세히 살펴보겠습니다. 그 과정에서 다음 질문에 대한 답을 찾을 수 있습니다: 원하는 데이터 셋이 Hub에 없으면 어떻게 할까요? 데이터 셋을 어떻게 슬라이싱하고(slice) 다이싱할(dice) 수 있을까요? (그리고 Pandas를 꼭 사용해야 한다면 어떻게 할까요?) 해당 데이터 셋이 너무 크고 노트북의 RAM의 용량이 부족할 때는 어떻게 해야 할까요? "메모리 매핑(memory mapping)"과 Apache Arrow는 도대체 무엇입니까? 나만의 데이터 셋을 생성하여 Hub에 푸시 하려면 어떻게 해야 합니까? 여기에서 배우는 세부 내용들은 6장과 7장의 고급 토큰화(advanced tokenization) 및 미세 조정(fine-tuning) 작업에 사용될 것입니다. 바로 시작해 봅시다! 1. 만일 자신의 데이터 셋이 허브에 없다면? 우리는 이제 Hugging Face Hub를 사용하여 데이터 셋을 다운로드하는 방법을 알고 있지만, 일반적으로는 노트북이나 원격 서버에 저장된 데이터로 작업하는 경우가 많습니다. 이 섹션에서는 Datasets를 사용하여 Hugging Face Hub에 존재하지 않는 데이터 셋을 로드하는 방법을 알아보겠습니다. 로컬 혹은 원격 데이터 셋으로 작업하기 Datasets는 로컬 및 원격 데이터 셋의 로딩을 처리하는 로딩 스크립트를 제공합니다. 다음과 같은 몇 가지 일반적인 데이터<NAME>을 지원합니다: Data format Loading script Example CSV & TSV csv load_dataset("csv", data_files="my_file.csv") Text files text load_dataset("text", data_files="my_file.txt") JSON & JSON Lines json load_dataset("json", data_files="my_file.jsonl") Pickled DataFrames pandas load_dataset("pandas", data_files="my_dataframe.pkl") 표에서 볼 수 있듯이, 각 데이터<NAME>에 대해 하나 이상의 파일에 대한 경로를 지정하는 data_files 인수와 함께 load_dataset() 함수에 로딩하는 데이터의<NAME>을 지정하기만 하면 됩니다. 우선 로컬 파일에서 데이터 셋을 로드하는 방법부터 시작하겠습니다. 나중에 우리는 원격 파일로 동일한 작업을 수행하는 방법을 살펴볼 것입니다. 로컬 데이터 셋 로딩하기 여기서는 예제 데이터로 이탈리아어 질의응답(question answering)을 위한 대규모 데이터 셋인 SQuAD-it dataset을 사용합니다. 학습 및 평가 집합으로 분할된 파일들은 GitHub에서 호스팅 되므로 간단한 wget 명령으로 다운로드할 수 있습니다: !wget https://github.com/crux82/squad-it/raw/master/SQuAD_it-train.json.gz !wget https://github.com/crux82/squad-it/raw/master/SQuAD_it-test.json.gz 위 명령어를 실행하면 리눅스 gzip 명령으로 압축을 풀 수 있는 SQuAD_it-train.json.gz 및 SQuAD_it-test.json.gz라는 두 개의 압축 파일이 다운로드됩니다: !gzip -dkv SQuAD_it*.json.gz 압축된 파일이 SQuAD_it-train.json, SQuAD_it-test.json 으로 바뀌었고 데이터가 JSON<NAME>으로 저장되어 있는 것을 확인할 수 있습니다. load_dataset() 함수를 사용하여 JSON 파일을 로드하려면 대상 파일이 일반적인 JSON<NAME>(파이썬의 중첩 딕셔너리와 유사)인지 아니면 JSON Lines(줄로 구분된 JSON)인지만 알면 됩니다. 대부분의 질의응답 데이터 셋들과 마찬가지로 SQuAD-it도 하나의 data 필드에 모든 텍스트가 저장된 형태로 구성된 중첩<NAME>(nested format)을 사용합니다. 이는 다음과 같이 field 매개변수를 지정하여 데이터 셋을 로드할 수 있음을 의미합니다: from datasets import load_dataset squad_it_dataset = load_dataset("json", data_files="SQuAD_it-train.json", field="data") 기본적으로 로컬 파일을 로드하면 학습 분할(train split)이 저장된 DatasetDict 개체가 생성됩니다. 이를 squad_it_dataset 객체를 참조하여 내용을 확인할 수 있습니다: squad_it_dataset 위에서 학습 분할에 존재하는 데이터의 행의 수(num_rows)와 열의 이름(features)을 보여주고 있습니다. 다음과 같이 학습 분할(train split)을 인덱싱하여 예제 중 하나의 내용을 볼 수도 있습니다: squad_it_dataset["train"][2] 좋습니다. 첫 번째 로컬 데이터 셋을 로드했습니다! 그러나 우리가 원하는 것은 단일 DatasetDict 객체에 학습 분할(training split)과 테스트 분할(test split)을 모두 포함시켜 한꺼번에 두 집합에 Dataset.map() 함수를 적용할 수 있도록 하는 것입니다. 이를 위해, data_files 매개변수에 각 분할 이름(split name)을 해당 집합 파일명에 매핑하는 딕셔너리를 지정하면 됩니다: data_files = {"train": "SQuAD_it-train.json", "test": "SQuAD_it-test.json"} squad_it_dataset = load_dataset("json", data_files=data_files, field="data") squad_it_dataset 우리가 원했던 바로 그 결과입니다. 이제 다양한 전처리 방법을 적용하여 데이터를 정리하고 토큰화하는 등의 작업을 수행할 수 있습니다. ✏ load_dataset() 함수의 data_files 인자는 단일 파일 경로, 파일 경로 리스트 또는 분할 파일 이름을 해당 파일 경로에 매핑하는 딕셔너리도 될 수 있습니다. Unix 셸에서 사용하는 규칙에 따라 지정된 패턴과 일치하는 파일을 glob할 수도 있습니다. 예를 들어, data_files="*.json"을 설정하여 디렉터리의 모든 JSON 파일을 단일 분할(split)로 glob 할 수 있습니다. 자세한 내용은 Datasets 문서를 참조하세요. Datasets의 load_dataset 함수는 실제로 입력 파일의 압축 해제를 자동으로 지원하므로 data_files 인수에 압축 파일을 직접 지정하여 gzip 사용을 건너뛸 수 있습니다: data_files = {"train": "SQuAD_it-train.json.gz", "test": "SQuAD_it-test.json.gz"} squad_it_dataset = load_dataset("json", data_files=data_files, field="data") 이 기능은 많은 GZIP 파일들을 수동으로 압축 해제하는 수고를 덜고자 할 경우에 유용할 수 있습니다. 자동 압축 해제(automatic decompression)는 ZIP 및 TAR과 같은 다른 압축<NAME>에도 적용되므로 data_files에 해당 압축 파일들을 지정하기만 하면 됩니다. 노트북이나 데스크톱에서 로컬 파일을 로드하는 방법을 알았으므로 이제 원격 파일을 로드하는 방법을 살펴보겠습니다. 원격 데이터 셋 로딩하기 회사에서 데이터 과학자나 개발자로 일하고 있다면, 분석하려는 데이터 셋이 원격 서버에 저장되어 있을 가능성이 큽니다. 다행히도 원격 파일(remote files)을 로드하는 것은 로컬 파일을 로드하는 것만큼 간단합니다! 로컬 파일에 대한 경로를 제공하는 대신 load_dataset()의 data_files 매개변수가 원격 파일이 저장된 하나 이상의 URL을 가리키게 하면 됩니다. 예를 들어, GitHub에서 호스팅 되는 SQuAD-it 데이터 셋의 경우 다음과 같이 data_files 매개변수에 SQuAD_it-*.json.gz URL을 지정할 수 있습니다. url = "https://github.com/crux82/squad-it/raw/master/" data_files = { "train": url + "SQuAD_it-train.json.gz", "test": url + "SQuAD_it-test.json.gz", } squad_it_dataset = load_dataset("json", data_files=data_files, field="data") 이렇게 하면 위에서 얻은 것과 동일한 DatasetDict 객체가 반환되지만 SQuAD_it-*.json.gz 파일을 수동으로 다운로드하고 압축을 푸는 단계를 생략할 수 있습니다. 이것으로 Hugging Face Hub에서 호스팅 되지 않는 데이터 셋을 로드하는 다양한 방법에 대한 내용을 마칩니다. 이제 우리가 작업할 데이터 셋이 확보되었으므로 다양한 데이터 랭글링(data-wrangling, 데이터 조작) 기술을 알아봅시다. ✏ GitHub 또는 UCI Machine Learning Repository에서 호스팅 되는 다른 데이터 셋을 선택하고 위에서 소개한 기술을 사용하여 로컬 및 원격으로 로드해 보십시오. 2. 데이터 셋 슬라이싱(slicing)과 다이싱(dicing) 대부분의 경우 작업 대상 데이터는 모델의 학습을 위해 완벽하게 가공되어 있지 않습니다. 이 섹션에서는 데이터 셋 정제(clean-up)를 위해 제공하는 Datasets의 다양한 기능을 살펴보겠습니다. 데이터 슬라이싱(slicing)과 다이싱(dicing) Pandas와 유사하게 Datasets는 Dataset 및 DatasetDict 객체의 내용을 조작하는 여러 기능을 제공합니다. 우리는 이미 3장에서 Dataset.map() 메서드를 만나봤고, 이 섹션에서는 우리가 사용할 수 있는 다른 함수들을 살펴볼 것입니다. 이번 섹션에서 예제로 UC Irvine Machine Learning Repository에서 호스팅 되는 Drug Review Dataset을 사용합니다. 여기에는 다양한 약물에 대한 환자 리뷰, 치료 상태 및 환자 만족도에 대한 별 10개 등급(10-star rating)이 포함되어 있습니다. 먼저 wget 및 unzip 명령으로 데이터를 다운로드하고 압축을 풀어봅시다: !wget "https://archive.ics.uci.edu/ml/machine-learning-databases/00462/drugsCom_raw.zip" !unzip drugsCom_raw.zip TSV는 구분 기호로 쉼표 대신 탭을 사용하는 CSV의 변형이므로 다음과 같이 load_dataset() 함수에 구분 기호 매개변수(delimiter)를 지정하여 파일을 로드할 수 있습니다: from datasets import load_dataset data_files = {"train": "drugsComTrain_raw.tsv", "test": "drugsComTest_raw.tsv"} # 는 Python에서 탭 문자를 나타냅니다. drug_dataset = load_dataset("csv", data_files=data_files, delimiter="\t") 어떤 종류의 데이터 분석을 수행하든지 간에 일부 무작위 샘플을 살펴봄으로써 작업 중인 데이터의 특징이나 유형을 파악하는 것은 좋은 접근법입니다. Datasets에서 Dataset.shuffle() 및 Dataset.select() 함수를 함께 연결(chaining) 하여 무작위 샘플을 가져올 수 있습니다: drug_sample = drug_dataset["train"].shuffle(seed=42).select(range(1000)) # 앞쪽의 샘플 몇 개를 가져옵니다. drug_sample[:3] 재현성(reproducibility)을 위해 Dataset.shuffle()의 seed를 고정했습니다. Dataset.select()는 반복 가능 인덱스(iterable indices)를 매개변수로 입력해야 하므로 데이터 셋에서 처음 1,000개의 예제를 가져오기 위해 range(1000)을 전달했습니다. 이 샘플들에서 우리는 해당 데이터 셋의 몇 가지 단점(quirks)을 볼 수 있습니다: "Unnamed: 0" 칼럼(column)은 확실하지는 않지만 각 환자의 익명 ID(anonymized ID)처럼 보입니다. "condition" 칼럼(column)에는 대문자와 소문자 레이블이 혼합되어 있습니다. 리뷰(review)의 길이는 다양하며 Python 줄 구분 기호(\r\n)와 '와 같은 HTML 문자 코드가 혼합되어 있습니다. Datasets를 사용하여 이러한 문제들을 처리하는 방법을 살펴보겠습니다. "Unnamed: 0" 칼럼이 환자의 식별자(anonymous ID)라는 가정이 맞는지 테스트하기 위해 Dataset.unique() 함수를 사용하여 ID의 개수가 해당 데이터 셋 분할들(splits)의 행(row)의 수와 일치하는지 확인할 수 있습니다: for split in drug_dataset.keys(): assert len(drug_dataset[split]) == len(drug_dataset[split].unique("Unnamed: 0")) 위 코드의 실행 결과가 예상을 확인시켜주는 것 같으므로, "Unnamed: 0" 칼럼의 명칭을 더 이해하기 쉬운 명칭으로 변경하여 데이터 셋을 약간 정제하겠습니다. DatasetDict.rename_column() 함수를 사용하여 한 번에 두 분할(학습 집합 및 평가 집합)에서 칼럼명을 변경할 수 있습니다: drug_dataset = drug_dataset.rename_column( original_column_name="Unnamed: 0", new_column_name="patient_id" ) drug_dataset 다음으로 Dataset.map()을 사용하여 모든 condition 레이블을 정규 화해 보겠습니다. 3장의 토큰화(tokenization)에서 했던 것처럼, 우리는 drug_dataset에서 각 분할(splits)의 모든 행에 적용할 수 있는 간단한 함수를 다음과 같이 정의할 수 있습니다: def lowercase_condition(example): return {"condition": example["condition"].lower()} drug_dataset.map(lowercase_condition) 오 이런! map 함수에 문제가 생겼습니다! 이 오류를 통해서 condition 칼럼의 일부 항목이 소문자로 변환할 수 없는 None이라는 것을 추론할 수 있습니다. Dataset.map()과 유사한 방식으로 작동하지만 데이터 셋의 단일 예제(example)를 입력받는 함수가 매개변수로 입력되는 Dataset.filter()를 사용하여 이러한 행을 삭제해 보겠습니다. 우선, 다음과 같은 명시적 함수, filter_nones를 작성하고: def filter_nones(x): return x["condition"] is not None drug_dataset.filter(filter_nones)를 실행하는 대신에, 람다 함수(lambda function)를 사용하여 한 줄로 이 작업을 수행할 수 있습니다. Python에서 람다 함수는 명시적으로 이름을 지정하지 않고 정의할 수 있는 작은 함수입니다. 다음과 같은 일반적인 형태를 취합니다: lambda <arguments> : <expression> 여기서 lambda는 Python의 특수 키워드 중 하나입니다. <arguments>는 함수에 대한 입력 매개변수를 정의하는 쉼표로 구분된 값의 리스트/세트입니다. 또한, <expression>은 실행하려는 작업을 나타냅니다. 예를 들어, 다음과 같이 숫자를 제곱하는 간단한 람다 함수를 정의할 수 있습니다: lambda x : x * x 이 함수를 입력 매개변수에 적용하려면 다음과 같이 이 함수와 매개변수를 괄호로 묶어야 합니다: (lambda x: x * x)(3) 마찬가지로, 여러 매개변수를 쉼표로 구분하여 람다 함수를 정의할 수 있습니다. 예를 들어 삼각형의 면적을 다음과 같이 계산할 수 있습니다: (lambda base, height: 0.5 * base * height)(4, 8) 람다 함수는 작은 일회성 함수(single-use function)를 정의하려는 경우에 유용합니다. 이에 대한 자세한 정보는 Andre Burgaud의 Real Python 튜토리얼을 참고하길 바랍니다. Datasets를 사용하는 상황에서는 람다 함수를 사용하여 간단한 맵(map) 및 필터(filter) 작업을 정의할 수 있으므로 이를 기반으로 데이터 셋에서 None 항목을 제거해 보겠습니다: drug_dataset = drug_dataset.filter(lambda x: x["condition"] is not None) None 항목이 제거되었기 때문에 이제 condition 칼럼(column)을 정규화할 수 있습니다: drug_dataset = drug_dataset.map(lowercase_condition) # 소문자 화가 제대로 진행되었는지 확인. drug_dataset["train"]["condition"][:3] 제대로 동작하는군요! 이제 레이블을 정리했으므로 reviews 자체를 정제하는 방법을 살펴보겠습니다. 새로운 칼럼(column) 만들기 고객 리뷰를 다룰 때마다, 각 리뷰의 단어 수를 확인하는 것이 좋습니다. 리뷰는 "Great!"와 같은 한 단어로 구성되거나 또는 수천 개의 단어로 구성된 본격적인 에세이(full-blown essays)로 작성되었을 수도 있습니다. 따라서, 사용 사례에 따라 이러한 극단적인 상황을 다르게 처리해야 합니다. 각 리뷰의 단어 수를 계산하기 위해 각 텍스트를 공백(whitespace)으로 나누는 대략적인 휴리스틱(heuristics)을 사용합니다. 각 리뷰의 단어 수를 계산하는 간단한 함수를 정의해 보겠습니다: def compute_review_length(example): return {"review_length": len(example["review"].split())} lowercase_condition() 함수와 달리 compute_review_length()는 기존 데이터 셋의 열(column) 이름들과 다른 새로운 이름의 키(review_length)를 가진 딕셔너리를 반환합니다. 이 경우 compute_review_length()가 Dataset.map()에 전달되면 데이터 셋의 모든 행에 적용되어 이 신규 review_length 열을 생성합니다: drug_dataset = drug_dataset.map(compute_review_length) # 첫 학습 예제를 살펴봅니다. drug_dataset["train"][0] 예상대로 review_length 열이 학습 집합에 추가된 것을 볼 수 있습니다. Dataset.sort()를 사용하여 이 새롭게 생성된 열(column)을 정렬하여 극단값(extreme values)이 무엇인지 확인할 수 있습니다: drug_dataset["train"].sort("review_length")[:3] 예상대로 일부 review에는 단일 단어만 포함되어 있는데, 이는 감성 분석(sentiment analysis)에는 적합할 수 있지만 condition을 예측하려는 경우에는 크게 도움이 되지는 않습니다. 데이터 셋에 새 열을 추가하는 다른 방법은 Dataset.add_column() 함수를 사용하는 것입니다. 이를 통해 새롭게 추가하고자 하는 열(column)을 Python 리스트 또는 NumPy 배열로 제공할 수 있으며 Dataset.map()이 분석에 적합하지 않은 상황에서 유용하게 활용할 수 있습니다. Dataset.filter() 함수를 사용하여 30단어 미만으로 표현된 리뷰를 제거해 보겠습니다. condition 열에서 수행한 것과 유사하게 리뷰의 길이가 이 임곗값(threshold)을 초과하도록 요구하여 매우 짧은 리뷰를 필터링할 수 있습니다: drug_dataset = drug_dataset.filter(lambda x: x["review_length"] > 30) print(drug_dataset.num_rows) 위 결과에서 보다시피, 이것은 원본 학습 및 평가 집합에서 리뷰의 약 15%를 제거했습니다. 마지막으로 우리가 해결해야 할 문제는 리뷰에 HTML 문자 코드가 있다는 것입니다. Python의 html 모듈을 사용하여 다음과 같이 이러한 문자를 이스케이프 해제(unescape) 할 수 있습니다: import html text = "I'm a transformer called BERT" html.unescape(text) Dataset.map()을 사용하여 말뭉치의 모든 HTML 문자를 이스케이프 해제합니다: drug_dataset = drug_dataset.map(lambda x: {"review": html.unescape(x["review"])}) 지금까지 살펴본 바와 같이, Dataset.map() 메서드는 데이터 처리에 매우 유용합니다. 그러나 아직도 우리는 이 메서드가 할 수 있는 기능의 일부만 살펴봤을 뿐입니다. map() 메서드의 대단한 능력 Dataset.map() 메서드의 batched 매개변수가 True로 설정되면, 호출되는 순간마다 여러 개의 예제로 구성된 하나의 배치(batch)가 한 번에 map 함수에 입력됩니다. 배치 크기(batch size)는 별도로 설정이 가능하고 디폴트 값은 1000입니다. 예를 들어, 모든 HTML 특수문자들을 이스케이프 해제(unescape) 하기 위해서 위에서 실행한 map 함수는 실행 속도가 약간 느립니다(진행 표시줄에서 소요된 시간을 읽을 수 있습니다). 리스트 컴프리 헨 션(list comprehension, 내포)를 사용하여 동시에 여러 예제를 한 번에 처리하여 속도를 높일 수 있습니다. batched=True가 지정되면 Dataset.map() 메서드의 매개변수로 전달되는 함수가 데이터 셋의 필드가 포함된 하나의 딕셔너리를 입력받지만 이 딕셔너리 내부의 각 필드값은 이제 단일 값이 아니라 리스트(list of values)입니다. Dataset.map()의 반환 값은 동일해야 합니다. 즉, 데이터 셋에 업데이트하거나 추가하려는 필드들이 존재하는 딕셔너리와 값 리스트입니다. 예를 들어, 다음 코드는 모든 HTML 문자를 이스케이프 해제하는 또 다른 방법이지만 batch=True를 사용합니다: new_drug_dataset = drug_dataset.map( lambda x: {"review": [html.unescape(o) for o in x["review"]]}, batched=True ) 주피터 노트북(jupyter notebook)에서 이 코드를 실행하면 이 명령이 이전 명령보다 훨씬 빠르게 실행되는 것을 볼 수 있습니다. 이는 review가 이미 HTML 이스케이프 해제 처리가 되었기 때문이 아닙니다. batched=True가 지정되지 않은 이전 섹션의 명령을 다시 실행하면 이전과 같은 시간이 소모됩니다. 이는 일반적으로 리스트 내 포문(list comprehension)이 for 루프에서 동일한 코드를 실행하는 것보다 더 빠르기 때문입니다. 또한 예제 하나씩이 아니라 동시에 많은 요소에 한꺼번에 접근함으로써 속도가 빨라진 것입니다. Dataset.map()을 batched=True와 함께 사용하는 것은 6장에서 살펴볼 "빠른(fast)" 토크 나이저의 속도를 잠금 해제하는(unlock) 데 필수적이며, 이는 규모가 큰 텍스트 리스트를 빠르게 토큰화할 수 있습니다. 예를 들어, 빠른 토크 나이저(fast tokenizer)로 모든 약물 리뷰(drug review)를 토큰화하기 위해서 다음과 같은 기능을 사용할 수 있습니다: from transformers import AutoTokenizer tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") def tokenize_function(examples): return tokenizer(examples["review"], truncation=True) 3장에서 보았듯이 하나 혹은 그 이상의 예제를 토크 나이저에 한 번에 전달할 수 있으므로 이 함수를 batched=True 유무에 관계없이 사용할 수 있습니다. 이제 다양한 옵션의 속도 비교를 한번 해보겠습니다. 주피터 노트북에서 속도를 측정하려는 코드 줄 앞에 %time을 추가하여 한 줄 명령의 시간을 측정할 수 있습니다: %time tokenized_dataset = drug_dataset.map(tokenize_function, batched=True) 셀의 시작 부분에 %%time을 넣어 전체 셀의 실행 시간을 측정할 수도 있습니다. 우리가 사용한 하드웨어에서는 이 명령어의 실행 시간이 10.8초로 측정되었습니다('Wall time' 뒤에 적힌 숫자를 보면 됩니다). 다음 표는 빠르고(fast) 느린(slow) 토크 나이저를 사용하여 일괄 처리(batching)를 사용하거나 사용하지 않고 얻은 결과입니다: Options Fast tokenizer Slow tokenizer batched=True 10.8s 4min41s batched=False 59.2s 5min3s 위 결과는 batched=True 옵션과 함께 빠른(fast) 토크 나이저를 사용하는 것이 일괄 처리가 없는 느린 토크 나이저보다 30배 더 빠르다는 것을 의미합니다. 이것은 정말 놀라운 일입니다! 이것이 AutoTokenizer를 사용할 때 빠른 토크 나이저가 디폴트로 지정된 이유입니다. 그리고 왜 "빠른(fast)"이라는 수식어가 붙었는지에 대한 이유기 기도하지요. 이러한 속도 향상을 가져올 수 있는 이유는 하부에서 토큰화 코드가 코드 실행을 쉽게 병렬화할 수 있게 하는 언어인 Rust에서 실행되기 때문입니다. 또한 병렬화(parallelization)는 배치 처리(batching)를 기반으로 빠른 토크 나이저가 6배 이상의 속도 향상을 가져오는 이유이기도 합니다. 단일 토큰화 작업을 병렬화할 수는 없습니다. 그러나 많은 텍스트를 동시에 토큰화하려는 경우 각각의 텍스트를 담당하는 여러 프로세스로 실행을 분할할 수 있습니다. Dataset.map()에는 자체 병렬화 기능도 있습니다. Rust가 지원되지 않기 때문에 느린 토크 나이저는 빠른 토크 나이저를 따라잡을 수 없지만 여전히 도움이 될 수 있습니다(특히 빠른 버전이 없는 토크 나이저를 사용하는 경우에는 더 그렇지요). 다중 처리를 활성화하려면 num_proc 인수를 사용하고 Dataset.map() 호출에 사용할 프로세스 수를 지정합니다: slow_tokenizer = AutoTokenizer.from_pretrained("bert-base-cased", use_fast=False) def slow_tokenize_function(examples): return slow_tokenizer(examples["review"], truncation=True) %time tokenized_dataset = drug_dataset.map(slow_tokenize_function, batched=True, num_proc=8) 사용할 최적의 프로세스 수를 결정하기 위해 속도 측정을 통해 약간의 실험을 진행할 수도 있습니다. 여기서는 num_proc=8일 때 최고의 속도 향상을 보이는 것처럼 보였습니다. 다음은 다중 처리를 사용하거나 사용하지 않고 실험한 결과입니다: Options Fast tokenizer Slow tokenizer batched=True 10.8s 4min41s batched=False 59.2s 5min3s batched=True, num_proc=8 6.52s 41.3s batched=False, num_proc=8 9.49s 45.2s 이 결과는 느린 토크 나이저의 경우 훨씬 더 합리적인 결과이지만 빠른 토크 나이저의 성능도 크게 향상되었습니다. 그러나 항상 이런 결과를 내는 것은 아닙니다. num_proc을 8이 아닌 다른 수로 지정한 경우, 테스트 결과 num_proc 옵션 없이 batched=True를 사용하는 것이 더 빠른 것으로 나타났습니다. 일반적으로 batched=True인 빠른 토크 나이저에는 Python 다중 처리를 사용하지 않는 것이 좋습니다. num_proc을 사용하여 처리 속도를 높이는 것은 일반적으로 사용 중인 함수가 자체적으로 다중 처리를 수행하지 않는 경우에만 좋은 아이디어라고 볼 수 있습니다. 이 모든 기능을 하나의 메서드 즉, Dataset.map()으로 통합한 것은 이미 그 자체로도 훌륭하지만 더 많은 유용한 기능들이 있습니다! Dataset.map() 및 batched=True를 사용하면 데이터 셋의 요소 개수를 변경할 수 있습니다. 이것은 하나의 예제(example)에서 여러 가지 학습 자질(training features)을 추가적으로 만들어야 하는 상황에서 매우 유용합니다. 그리고 이는 7장에서 수행할 여러 NLP 작업에 대한 전처리의 일부로도 수행됩니다. 일반적으로 기계 학습에서 하나의 예제(example)는 모델에 제공하는 자질(feature)의 집합으로 정의됩니다. 특정 상황에서 이러한 자질(features)은 Dataset 내의 칼럼(column) 집합으로 표현되지만, 다른 맥락에서는 여러 개의 자질(multiple features)이 하나의 단일 예제(example)에서 추출되어 단일 칼럼(column)에 속하는 경우도 있습니다. 어떻게 동작하는지 한번 봅시다! 여기서는 우리 예제(examples)들을 토큰화하고 최대 길이 128로 자릅니다. 그러나 이 과정에서 토크 나이저에게 전체 review의 앞부분에 있는 128개의 토큰으로 구성된 청크(chunk)가 아니라 텍스트의 모든 청크(chunk)를 반환하도록 요청할 것입니다. 이는 return_overflowing_tokens=True로 지정함으로써 수행할 수 있습니다: def tokenize_and_split(examples): return tokenizer( examples["review"], truncation=True, max_length=128, return_overflowing_tokens=True, ) 전체 데이터 셋에 대해서 Dataset.map()을 사용하기 전에 예제 하나에서 테스트해 보겠습니다: result = tokenize_and_split(drug_dataset["train"][0]) [len(inp) for inp in result["input_ids"]] result["input_ids"] 학습 집합의 첫 번째 예제(example)는 우리가 지정한 최대 토큰 수(128)보다 많이 토큰화되었기 때문에 두 가지 자질(feature)로 구성되었습니다. 첫 번째 자질의 길이는 128이고 두 번째 자질의 길이는 49입니다. 이제 데이터 셋의 모든 요소에 대해 이 작업을 수행합니다! tokenized_dataset = drug_dataset.map(tokenize_and_split, batched=True) 오류가 발생했습니다. 이유가 뭘까요? 오류 메시지를 보면 단서를 얻을 수 있습니다. 칼럼(column) 중 하나의 개수에 불일치가 있습니다. 하나는 개수가 1,463이고 다른 하나는 길이가 1,000입니다. Dataset.map()에 대한 Documentation을 본 적이 있다면, 이 숫자(1000)는 매핑하는 함수(tokenize_and_split)에 전달된 총 샘플 개수라는 것을 기억할 수 있을 겁니다. 여기에서 1,000개의 예제가 입력되어 1,463개의 새로운 자질들을 출력하므로 shape error가 발생했습니다. 문제는 크기가 다른 두 개의 서로 다른 데이터 셋을 혼합하려고 한다는 것입니다. 이 오류에서 drug_dataset 열에는 1,000개의 예제가 있으나 우리가 새롭게 구성하려는 tokenized_dataset에는 그보다 많은 수의 예제(1,463)가 있습니다. Dataset 객체로서는 제대로 작동할 수가 없습니다. 따라서 이전 데이터 셋의 열을 제거하거나 새로운 데이터 셋과 동일한 크기로 만들어야 합니다. remove_columns 매개변수를 지정함으로써 이를 수행할 수 있습니다: tokenized_dataset = drug_dataset.map( tokenize_and_split, batched=True, remove_columns=drug_dataset["train"].column_names ) 이제 오류 없이 작동합니다. 길이를 비교하여 새 데이터 셋에 원래 데이터 셋보다 얼마나 더 많은 요소가 있는지 확인할 수 있습니다: len(tokenized_dataset["train"]), len(drug_dataset["train"]) 앞에서 이전 열을 새 열과 같은 크기로 만들어 길이 불일치 문제를 해결할 수도 있다고 언급했습니다. 이를 위해서, return_overflowing_tokens=True를 설정할 때 토크 나이저가 반환하는 overflow_to_sample_mapping 필드가 필요합니다. 이는 우리에게 새로운 자질 인덱스에서 그것이 시작된 샘플의 인덱스로의 매핑을 제공합니다. 이를 사용하여 새로운 자질을 생성하는 횟수만큼 각 예제의 값을 반복하여 원본 데이터 셋에 있는 각 키를 올바른 크기의 값 목록과 연결할 수 있습니다: def tokenize_and_split(examples): result = tokenizer( examples["review"], truncation=True, max_length=128, return_overflowing_tokens=True, ) # 신규 인덱스와 이전 인덱스와의 매핑 추출 sample_map = result.pop("overflow_to_sample_mapping") for key, values in examples.items(): result[key] = [values[i] for i in sample_map] return result 이로써 이전 열을 제거할 필요 없이 Dataset.map()과 함께 작동하는 것을 볼 수 있습니다: tokenized_dataset = drug_dataset.map(tokenize_and_split, batched=True) tokenized_dataset 이전과 동일하게 증가된 수의 학습 자질들을 얻었지만 여기서는 모든 이전 필드를 그대로 유지했습니다. 모델을 적용한 후에 이들 이전 필드들에 대한 후처리가 필요한 경우 이 접근 방식을 사용하는 것이 좋습니다. 지금까지, Datasets를 사용하여 다양한 방식으로 데이터 셋을 전처리하는 방법을 확인했습니다. Datasets의 처리 함수들은 모델 학습에 필요한 대부분의 요구 사항을 수용하지만, DataFrame.groupby() 또는 시각화를 위한 고급 API와 같은 보다 강력한 기능을 사용하기 위해 Pandas를 사용해야 하는 경우가 있습니다. 다행히 Datasets는 Pandas, NumPy, PyTorch, TensorFlow 및 JAX와 같은 라이브러리와 상호 운용 가능하도록 설계되었습니다. 이것이 어떻게 작동하는지 살펴보겠습니다. Datasets과 DataFrames 간의 상호 변환 다양한 서드 파티 라이브러리들 간의 변환을 가능하게 하기 위해 Datasets는 Dataset.set_format() 함수를 제공합니다. 이 기능은 데이터 셋의 출력<NAME>(output format)만 변경하므로 기본 데이터 포맷(Apache Arrow)에 영향을 주지 않고 다른<NAME>으로 쉽게 전환할 수 있습니다. 우리 데이터 셋을 Pandas로 변환해 보겠습니다: drug_dataset.set_format("pandas") 이제 데이터 셋의 각 요소에 액세스할 때 딕셔너리 대신 pandas.DataFrame을 사용합니다: drug_dataset["train"][:3] drug_dataset["train"]의 모든 요소를 선택하여 전체 학습 집합에 대한 pandas.DataFrame을 생성해 보겠습니다: train_df = drug_dataset["train"][:] 내부적으로 Dataset.set_format()은 데이터 셋의 __getitem__() 던더(dunder, double under) 메서드에 대한 반환<NAME>을 변경합니다. 이것은 "pandas"<NAME>의 Dataset에서 train_df와 같은 새 객체를 생성하려는 경우 pandas.DataFrame을 얻기 위해 전체 데이터 셋을 슬라이싱(slicing)해야 함을 의미합니다. 출력<NAME>에 관계없이 drug_dataset["train"]의 유형이 Dataset 임을 직접 확인할 수 있습니다. 이제부터 우리가 원하는 모든 Pandas 기능을 사용할 수 있습니다. 예를 들어, 우리는 condition 항목의 클래스 분포를 계산하기 위해 멋진 연결(fancy chaining)을 할 수 있습니다: frequencies = ( train_df["condition"] .value_counts() .to_frame() .reset_index() .rename(columns={"index": "condition", "condition": "frequency"}) ) frequencies.head() Pandas 분석이 끝나면 다음과 같이 Dataset.from_pandas() 함수를 사용하여 항상 새로운 Dataset 객체를 생성할 수 있습니다: from datasets import Dataset freq_dataset = Dataset.from_pandas(frequencies) freq_dataset 이것으로 Datasets에서 사용할 수 있는 다양한 전처리 기술에 대한 둘러보기를 마칩니다. 섹션을 마무리하기 위해 분류기를 학습할 데이터 셋을 준비하기 위한 검증 집합(validation set)을 만들어 보겠습니다. 그전에 "pandas"에서 "arrow"로 drug_dataset의 출력<NAME>을 재설정합니다: drug_dataset.reset_format() 검증 집합(validation set) 생성 모델 성능 평가에 사용할 수 있는 평가 집합(test set)이 있지만 개발 중에 이 평가 집합을 그대로 두고 별도의 검증 집합(validation set)을 만드는 것이 좋습니다. 검증 집합(validation set)에서 모델의 성능에 만족하면 평가 집합(test set)에서 최종적인 온전성 검사(sanity check)를 수행할 수 있습니다. 이 과정은 모델이 평가 집합(test set)에 과적합되어 실제 데이터에서는 성능이 떨어지는 모델을 배포하는 위험성을 완화하는 데 도움이 됩니다. Datasets는 scikit-learn의 유명한 기능을 기반으로 하는 Dataset.train_test_split() 함수를 제공합니다. 이를 사용하여 학습 집합을 학습 및 검증 집합으로 분할합니다. 재현성(reproducibility) 유지를 위해 seed 인수를 설정하였습니다: drug_dataset_clean = drug_dataset["train"].train_test_split(train_size=0.8, seed=42) # 기본 "test" 분할을 "validation"으로 변경함. drug_dataset_clean["validation"] = drug_dataset_clean.pop("test") # 'DatasetDict'에 "test" 집합을 추가. drug_dataset_clean["test"] = drug_dataset["test"] drug_dataset_clean 좋습니다. 이제 모델을 학습할 준비가 된 데이터 셋을 완성했습니다! 섹션 5에서는 데이터 셋을 Hugging Face Hub에 업로드하는 방법을 보여주지만 지금은 로컬 컴퓨터에 데이터 셋을 저장할 수 있는 몇 가지 방법을 살펴보고 마무리하겠습니다. 데이터 셋 저장 Datasets는 다운로드한 모든 데이터 셋과 이에 대해 수행된 작업을 임시저장하지만 데이터 셋을 디스크에 저장하고 싶을 때가 있습니다 (예: 캐시가 삭제된 경우). 아래 표에서 볼 수 있듯이 Datasets는 데이터 셋을 다양한<NAME>으로 저장하는 세 가지 주요 기능을 제공합니다. Data format Function Arrow Dataset.save_to_disk() CSV Dataset.to_csv() JSON Dataset.to_json() 예를 들어, 정리된 데이터 셋을 Arrow<NAME>으로 저장해 보겠습니다: drug_dataset_clean.save_to_disk("drug-reviews") 그러면 다음과 같은 구조의 디렉터리가 생성됩니다: drug-reviews/ ├── dataset_dict.json ├── test │ ├── dataset.arrow │ ├── dataset_info.json │ └── state.json ├── train │ ├── dataset.arrow │ ├── dataset_info.json │ ├── indices.arrow │ └── state.json └── validation ├── dataset.arrow ├── dataset_info.json ├── indices.arrow └── state.json 여기서 각 분할은 자체 dataset.arrow 테이블과 dataset_info.json 및 state.json 같은 메타데이터가 존재함을 알 수 있습니다. Arrow<NAME>은 대규모 데이터 셋을 처리하고 전송하는 고성능 애플리케이션을 구축하는데 최적화된 테이블로 생각할 수 있습니다. 데이터 셋이 저장되면 다음과 같이 load_from_disk() 함수를 사용하여 로드할 수 있습니다: from datasets import load_from_disk drug_dataset_reloaded = load_from_disk("drug-reviews") drug_dataset_reloaded CSV 및 JSON<NAME>의 경우 각 분할을 별도의 파일로 저장해야 합니다. 이를 수행하는 한 가지 방법은 DatasetDict 개체의 키와 값을 반복하는 것입니다: for split, dataset in drug_dataset_clean.items(): dataset.to_json(f"drug-reviews-{split}.jsonl") 이렇게 하면 데이터 세트의 각 행이 JSON의 한 줄로 저장되는 JSON Lines<NAME>으로 각 분할이 저장됩니다. 저장된 학습 집합 파일의 첫 번째 예시는 다음과 같습니다: !head -n 1 drug-reviews-train.jsonl 그런 다음 섹션 2에서 설명한 기법을 사용하여 다음과 같이 JSON 파일을 로드할 수 있습니다: data_files = { "train": "drug-reviews-train.jsonl", "validation": "drug-reviews-validation.jsonl", "test": "drug-reviews-test.jsonl", } drug_dataset_reloaded = load_dataset("json", data_files=data_files) Datasets를 이용하여 데이터에 대한 다양한 전처리 및 후처리 기법 등을 알아봤습니다. 이제 모델 학습을 위한 정리된 데이터 셋이 있으므로 시도해 볼 수 있는 몇 가지 아이디어가 있습니다: 3장의 기법을 사용하여 약물 리뷰(drug review)를 기반으로 환자 상태를 예측할 수 있는 분류기를 학습합니다. 1장의 요약(summarization) 파이프라인을 사용하여 리뷰 요약을 생성합니다. 다음으로, 우리는 Datasets를 사용하여 하드웨어의 제약 없이 규모가 큰 데이터 셋으로 작업할 수 있는 방법을 살펴보겠습니다! 3. Datasets가 빅데이터 문제를 해결한다! 특히 BERT 또는 GPT-2와 같은 트랜스포머(transformers)를 밑바닥부터 사전 학습(pretraining) 할 계획이라면, 기가바이트 규모의 데이터 셋으로 작업하는 것이 드문 일이 아닙니다. 이런 경우에는 데이터를 로드하는 것조차 어려울 수 있습니다. 예를 들어, GPT-2를 사전 학습(pretraining) 하는 데 사용되는 WebText 코퍼스는 8백만 개 이상의 문서와 40GB의 텍스트로 구성됩니다. 이 데이터 셋을 노트북의 RAM에 로드하면 노트북이 심장마비를 일으킬 수 있습니다! 다행히도, Datasets는 이러한 한계를 극복하도록 설계되었습니다. 데이터 셋을 메모리에 매핑된(memory-mapped) 파일로 처리하여 메모리 관리 문제를 해결하고, 말뭉치의 각 항목들을 스트리밍 하여 하드 디스크 제한에서 우리를 해방시킬 수 있습니다. 이 섹션에서는 Pile로 알려진 825GB 규모의 거대한 말뭉치를 이용하여, 위에서 설명한 Datasets의 기능들을 살펴보겠습니다. 시작해 봅시다! Pile이 무엇인가요? Pile은 EleutherAI가 대규모 언어 모델을 학습하기 위해 만든 영어 텍스트 말뭉치입니다. 여기에는 학술 논문(scientific articles), GitHub 코드 리포지토리 및 필터링 된 웹 텍스트에 이르는 다양한 데이터 셋이 포함되어 있습니다. 학습 데이터는 14GB 청크로 제공되며 개별적인 구성 요소를 각각 다운로드할 수도 있습니다. 먼저 1,500만 건으로 구성된 생의학 출판물 초록 모음인 PubMed Abstracts 데이터 셋을 살펴보겠습니다. 데이터 셋은 JSON Lines<NAME>이고 zstandard 라이브러리를 사용하여 압축되므로 먼저 다음을 설치해야 합니다: !pip install zstandard # 만일 설치가 반영이 제대로 안된다면, 다음 명령어로 설치하고 커널을 다시 실행해야 합니다. # import sys # !{sys.executable} -m pip install zstandard 다음으로 5.2에서 배운 원격 파일에 대한 로딩 방법을 사용하여 데이터 셋을 메모리로 로드할 수 있습니다: from datasets import load_dataset # 아래 코드는 실행하는데 몇 분이 소요됩니다. data_files = "https://the-eye.eu/public/AI/pile_preliminary_components/PUBMED_title_abstracts_2019_baseline.jsonl.zst" pubmed_dataset = load_dataset("json", data_files=data_files, split="train") pubmed_dataset 데이터 세트에 15,518,009개의 행과 2개의 열이 있음을 알 수 있습니다. 정말 많은 양입니다! 기본적으로 Datasets는 데이터 셋을 로드하는 데 필요한 파일의 압축을 풉니다. 하드디스크 공간을 절약하려면 load_dataset()의 download_config 인수에 DownloadConfig(delete_extracted=True)를 전달할 수 있습니다. 자세한 내용은 설명서를 참조하십시오. 첫 번째 예제의 내용을 살펴보겠습니다: pubmed_dataset[0] 좋습니다. 의학 논문의 초록처럼 보입니다. 이제 해당 데이터 셋을 로드하는 데 사용한 RAM의 양을 봅시다! 메모리 매핑(memory-mapping)의 마법 Python에서 메모리 사용량을 측정하는 간단한 방법은 다음과 같이 pip로 설치할 수 있는 psutil 라이브러리를 사용하는 것입니다: !pip install psutil 다음과 같이, 현재 프로세스의 메모리 사용량을 확인할 수 있는 Process 클래스를 제공합니다: import psutil # Process.memory_info는 바이트 단위로 표시되므로 이를 메가 바이트로 변환합니다. print(f"RAM used: {psutil.Process().memory_info().rss / (1024 * 1024):.2f} MB") 여기에서 rss 속성은 프로세스가 RAM에서 차지하는 메모리 비율인 resident set size(상주 세트 크기)를 나타냅니다. 측정 과정에서 Python 인터프리터와 우리가 로드한 라이브러리가 사용하는 메모리 양도 포함되므로 데이터 셋을 로드하는 데 사용되는 실제 메모리 양은 약간 더 적습니다. 비교를 위해 dataset_size 속성을 사용하여 데이터 셋이 디스크에서 어느 정도 크기인지 봅시다. 결과는 이전과 같이 바이트로 표시되므로 수동으로 기가바이트로 변환해야 합니다: print(f"Number of files in dataset : {pubmed_dataset.dataset_size}") size_gb = pubmed_dataset.dataset_size / (1024 ** 3) print(f"Dataset size (cache file) : {size_gb:.2f} GB") 좋습니다. 거의 20GB 크기에도 불구하고 훨씬 적은 RAM으로 데이터 셋을 로드하고 액세스할 수 있습니다! Pandas에 익숙하다면 일반적으로 데이터 셋 크기보다 5~10배 많은 RAM이 필요하다는 Wes Kinney의 유명한 경험 법칙(rule of thumb) 때문에 이 결과가 놀라울 수 있습니다. 그렇다면 Datasets는 메모리 관리 문제를 어떻게 해결할까요? Datasets는 각 데이터 셋을 메모리 매핑된 파일(memory-mapped file)로 처리합니다. 이 파일은 RAM과 파일 시스템 스토리지 간의 매핑을 제공하여 라이브러리가 데이터 셋을 메모리에 완전히 로드할 필요 없이 각 요소에 액세스하고 작동할 수 있도록 해줍니다. 메모리 매핑된 파일(memory-mapped file)은 여러 프로세스에서 공유될 수도 있으므로 데이터 셋을 이동하거나 복사할 필요 없이 Dataset.map()과 같은 메서드를 병렬화할 수 있습니다. 내부적으로, 이러한 기능은 모두 Apache Arrow 메모리<NAME> 및 pyarrow 라이브러리에 의해 구현되어 데이터 로드 및 처리를 매우 빠르게 할 수 있습니다. Apache Arrow 및 Pandas와의 비교에 대한 자세한 내용은 Dejan Simic의 블로그 게시물을 확인하세요. 실제로 작동하는지 확인하기 위해 PubMed Abstracts 데이터 셋의 모든 요소를 반복하여 실행 속도 테스트를 해보겠습니다: # (2022-05-25) 이 코드에서 실행 오류가 발생합니다. 유니코드 오류가 나는데 아무래도 라이브러리 자체 오류인 것 같습니다. 계속 찾아보겠습니다. import timeit code_snippet = """batch_size = 1000 for idx in range(0, len(pubmed_dataset), batch_size): _ = pubmed_dataset[idx:idx + batch_size] """ time = timeit.timeit(stmt=code_snippet, number=1, globals=globals()) print( f"Iterated over {len(pubmed_dataset)} examples (about {size_gb:.1f} GB in " f"{time:.1f}s, i.e. {size_gb/time:.3f} GB/s" ) 여기서 우리는 Python의 timeit 모듈을 사용하여 code_snippet의 실행 시간을 측정했습니다. 일반적으로 수십 GB/s에서 수 GB/s의 속도로 데이터 셋을 반복할 수 있습니다. 이것은 대부분의 응용 프로그램에서 훌륭하게 작동하지만 때로는 노트북의 하드 드라이브에 저장하기에도 너무 큰 데이터 셋으로 작업해야 하는 상황이 있을 수 있습니다. 예를 들어, Pile 전체를 다운로드하려고 하면 825GB의 여유 디스크 공간이 필요합니다! 이러한 경우를 처리하기 위해 Datasets는 전체 데이터 셋을 다운로드할 필요 없이 즉시 요소를 다운로드하고 액세스할 수 있는 스트리밍 기능을 제공합니다. 이것이 어떻게 작동하는지 살펴보겠습니다. 스트리밍 데이터 셋 (Streaming datasets) 데이터 셋 스트리밍을 활성화하려면 streaming=True 인수를 load_dataset() 함수에 전달하기만 하면 됩니다. 예를 들어, 스트리밍 모드에서 PubMed Abstracts 데이터 셋을 다시 로드해 보겠습니다: pubmed_dataset_streamed = load_dataset( "json", data_files=data_files, split="train", streaming=True ) 우리에게 이미 친숙한 Dataset 대신 streaming=True로 반환된 객체는 IterableDataset입니다. 이름에서 알 수 있듯이 IterableDataset의 요소에 액세스하려면 반복해야 합니다. 다음과 같이 스트리밍 된 데이터 셋의 첫 번째 요소에 액세스할 수 있습니다: next(iter(pubmed_dataset_streamed)) 스트리밍 된 데이터 셋의 요소는 IterableDataset.map()을 사용하여 바로 처리할 수 있으며, 이는 학습 과정에서 입력을 토큰 화해야 하는 경우 유용합니다. 이 작업은 3장에서 데이터 셋을 토큰화하는데 사용한 방법과 동일하지만 출력이 하나씩 반환된다는 점만 다릅니다: from transformers import AutoTokenizer tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased") tokenized_dataset = pubmed_dataset_streamed.map(lambda x: tokenizer(x["text"])) next(iter(tokenized_dataset)) 스트리밍으로 토큰화 속도를 높이려면 이전 섹션에서 본 것처럼 batched=True를 전달하면 됩니다. 그러면 배치(batch) 별로 예제를 처리합니다. 기본 배치 크기는 1,000이며 batch_size 인수로 지정할 수 있습니다. IterableDataset.shuffle()을 사용하여 스트리밍 된 데이터 셋을 셔플링할 수도 있지만 Dataset.shuffle()과 달리 사전 정의된 buffer_size 개의 요소들만 셔플링합니다: shuffled_dataset = pubmed_dataset_streamed.shuffle(buffer_size=10000, seed=42) next(iter(shuffled_dataset)) 위 예에서는 버퍼의 처음 10,000개 예제에서 임의로 예제를 선택했습니다. 일단 예제에 접근하면 버퍼의 해당 지점이 말뭉치의 다음 예제로 채워집니다 (즉, 위의 경우 10,001번째 예제). Dataset.select()와 유사한 방식으로 작동하는 IterableDataset.take() 및 IterableDataset.skip() 함수를 사용하여 스트리밍 된 데이터 셋에서 요소를 선택할 수도 있습니다. 예를 들어, PubMed Abstracts 데이터 셋에서 처음 5개의 예제를 선택하기 위해 다음을 수행할 수 있습니다: dataset_head = pubmed_dataset_streamed.take(5) list(dataset_head) 마찬가지로, IterableDataset.skip() 함수를 사용하여 다음과 같이 셔플링된 데이터 셋에서 학습 및 검증 분할을 생성할 수 있습니다: # 처음 1000개의 예제를 스킵하고 나머지를 학습 집합으로 포함시킨다. train_dataset = shuffled_dataset.skip(1000) # 처음 1000개의 예제를 검증 집합으로 구성한다. validation_dataset = shuffled_dataset.take(1000) 여러 데이터 셋을 결합하여 단일 코퍼스를 생성하는 하나의 일반적인 응용방법을 설명함으로써 데이터 셋 스트리밍에 대한 설명을 마무리하겠습니다. Datasets는 IterableDataset 객체 리스트를 단일 IterableDataset으로 변환하는 interleave_datasets() 함수를 제공합니다. 여기서 새 데이터 셋의 요소는 소스 예제를 번갈아 가며 얻습니다. 이 기능은 대규모 데이터 셋을 결합하려고 할 때 특히 유용합니다. 예를 들어 미국 법원(US courts)의 법적 의견(legal opinions)이 담긴 51GB 데이터 셋인 Pile의 FreeLaw 하위 세트(subsets)들을 스트리밍 해 보겠습니다: law_dataset_streamed = load_dataset( "json", data_files="https://the-eye.eu/public/AI/pile_preliminary_components/FreeLaw_Opinions.jsonl.zst", split="train", streaming=True, ) next(iter(law_dataset_streamed)) 이 데이터 셋은 대부분의 랩톱에서 RAM에 부담을 주기에 충분하지만 어려움 없이 로드하고 액세스할 수 있습니다! 이제 FreeLaw 및 PubMed Abstracts 데이터 셋의 예제를 interleave_datasets() 함수와 결합해 보겠습니다: from itertools import islice from datasets import interleave_datasets combined_dataset = interleave_datasets([pubmed_dataset_streamed, law_dataset_streamed]) list(islice(combined_dataset, 2)) 여기에서 우리는 Python의 itertools 모듈에서 islice() 함수를 사용하여 결합된 데이터 셋에서 처음 두 예제를 선택했으며 두 소스 데이터 셋 각각의 첫 번째 예제와 일치하는 것을 볼 수 있습니다. 마지막으로 Pile을 825GB 전체로 스트리밍 하려면 다음과 같이 준비된 모든 파일을 가져올 수 있습니다: base_url = "https://the-eye.eu/public/AI/pile/" data_files = { "train": [base_url + "train/" + f"{idx:02d}.jsonl.zst" for idx in range(30)], "validation": base_url + "val.jsonl.zst", "test": base_url + "test.jsonl.zst", } pile_dataset = load_dataset("json", data_files=data_files, streaming=True) next(iter(pile_dataset["train"])) mc4 또는 oscar와 같은 대규모 Common Crawl 말뭉치 중 하나를 사용하여 선택한 국가에서 사용되는 언어 비율을 나타내는 스트리밍 다국어 데이터 셋을 만들어 보세요. 예를 들어, 스위스의 4개 국어는 독일어, 프랑스어, 이탈리아어 및 로만 시어(Romansh)이므로 사용 비율에 따라 Oscar 하위 집합을 샘플링하여 스위스 말뭉치를 만들 수 있습니다. 이제 어떠한 모양과 크기의 데이터 셋이든 이를 로드하고 처리하는 데 필요한 모든 도구를 사용할 수 있게 되었습니다. 그러나 아무리 운이 좋더라도 NLP 여정에서 당면한 문제를 해결하기 위해 실제로 본인의 데이터 셋을 만들어야 하는 시점이 올 것입니다. 이것이 다음 섹션의 주제입니다! 4. 자신만의 데이터 셋 만들기 NLP 애플리케이션을 구축하는데 필요한 데이터 셋이 존재하지 않는 경우에는 직접 만들어야 합니다. 이 섹션에서는 GitHub 리포지토리의 버그 또는 특징을 추적하는데 일반적으로 사용되는 GitHub issues 말뭉치를 만드는 방법을 보여줍니다. 이 말뭉치는 다음과 같은 다양한 목적으로 사용될 수 있습니다: 미해결 이슈(Open issues) 또는 풀 리퀘스트(pull requests)를 종료하는 데 얼마나 시간이 걸리는지 알아보기. 문제에 대한 설명(issue's description)에 기반하여 메타데이터 형태의 이슈에 태그("bug", "enhancement", 또는 "question")를 지정할 수 있는 다중 레이블 분류기(multilabel classifier) 학습 사용자의 질의와 일치하는 이슈들을 검색하기 위한 시맨틱 검색 엔진(semantic search engine) 만들기 여기에서는 말뭉치의 신규 구축에 초점을 맞추고 다음 섹션에서는 시맨틱 검색 엔진을 다룰 것입니다. 특히, 인기 있는 오픈 소스 프로젝트인 Datasets와 관련된 GitHub 이슈 집합을 사용해서 말뭉치를 구축합니다. 해당 데이터를 구하는 방법과 이러한 이슈들에 포함된 정보를 탐색하는 방법을 살펴보겠습니다. 데이터 가져오기 Repository의 이슈 탭(Issues tab)으로 이동하여 Datasets 프로젝트의 모든 이슈들을 찾을 수 있습니다. 다음 스크린숏에서 볼 수 있듯이 이 문서를 작성할 당시 331개의 미해결 이슈들(open issues)과 668개의 해결된 이슈들(closed issues)이 있었습니다: 이러한 이슈들 중 하나를 클릭하면 제목(title), 설명(description) 및 이슈를 특징짓는 레이블 집합이 포함되어 있음을 알 수 있습니다. 아래 스크린숏에 예가 나와 있습니다. 모든 리포지토리의 이슈들을 다운로드하기 위해 GitHub REST API를 사용하여 Issues endpoint를 폴링 합니다. 이 endpoint는 제목과 설명은 물론 이슈 상태에 대한 메타데이터를 포함하는 많은 필드를 포함하는 개체들로 구성된 JSON 개체(objects) 목록을 반환합니다. 이슈(issues)를 다운로드하는 한 가지 편리한 방법은 Python에서 HTTP 요청을 만드는 표준 방법인 requests 라이브러리를 사용하는 것입니다. 다음을 실행하여 라이브러리를 설치할 수 있습니다: !pip install requests 라이브러리가 설치되면 requests.get() 함수를 호출하여 이슈 엔드 포인트(Issues endpoint)에 GET 요청을 할 수 있습니다. 예를 들어, 다음 명령을 실행하여 첫 페이지의 첫 번째 이슈를 검색할 수 있습니다: import requests url = "https://api.github.com/repos/huggingface/datasets/issues? page=1&per_page=1" response = requests.get(url) 응답 객체에는 HTTP 상태 코드를 포함하여 요청에 대한 유용한 정보가 많이 포함되어 있습니다: response.status_code 여기서 200 상태는 요청이 성공했음을 의미합니다(여기에서 HTTP 상태 코드 목록을 찾을 수 있음). 하지만 우리가 관심 있는 것은 바이트, 문자열 또는 JSON과 같은 다양한<NAME>으로 액세스할 수 있는 payload입니다. 이슈가 JSON<NAME>이라는 것을 알고 있으므로 다음과 같이 페이로드(payload)를 살펴보겠습니다: response.json() 와, 정보가 많네요! 이슈를 설명하는 제목(title), 본문(body) 및 번호(number)와 같은 유용한 필드와 해당 이슈를 제기한 GitHub 사용자에 대한 정보를 볼 수 있습니다. GitHub 문서에 설명된 대로 인증되지 않은 요청은 시간당 60개 요청으로 제한됩니다. per_page 쿼리 매개변수를 늘려 수행해야 할 요청의 총수를 줄일 수 있지만, 이슈가 수천 개 이상인 저장소에서는 여전히 비율 제한에 도달하게 됩니다. 따라서 그 대신 시간당 5,000개 요청으로 속도 제한을 높일 수 있도록 개인 액세스 토큰(personal access token) 생성에 대한 GitHub의 지침을 따라야 합니다. 토큰이 있으면 요청 헤더(request header)의 일부로 포함할 수 있습니다: GITHUB_TOKEN = "ghp_..." ## 본인의 personal access token을 지정하세요. headers = {"Authorization": f"token {GITHUB_TOKEN}"} 이제 액세스 토큰이 있으므로 GitHub 리포지토리에서 모든 이슈들을 다운로드할 수 있는 함수를 생성해 보겠습니다: import time import math from pathlib import Path import pandas as pd from tqdm.notebook import tqdm def fetch_issues( owner="huggingface", repo="datasets", num_issues=10000, rate_limit=5000, issues_path=Path(".") ): if not issues_path.is_dir(): issues_path.mkdir(exist_ok=True) batch = [] all_issues = [] per_page = 100 # 페이지당 리턴 받는 이슈의 개수 num_pages = math.ceil(num_issues / per_page) base_url = "https://api.github.com/repos" for page in tqdm(range(num_pages)): # state=all로 질의하여 미해결, 해결 이슈들을 모두 가지고 온다. query = f"issues?page={page}&per_page={per_page}&state=all" issues = requests.get(f"{base_url}/{owner}/{repo}/{query}", headers=headers) batch.extend(issues.json()) if len(batch) > rate_limit and len(all_issues) < num_issues: all_issues.extend(batch) batch = [] # 다음 주기를 위해서 batch를 비운다. print(f"Reached GitHub rate limit. Sleeping for one hour ...") time.sleep(60 * 60 + 1) all_issues.extend(batch) df = pd.DataFrame.from_records(all_issues) df.to_json(f"{issues_path}/{repo}-issues.jsonl", orient="records", lines=True) print(f"Downloaded all the issues for {repo}! Dataset stored at {issues_path}/{repo}-issues.jsonl") 이제 fetch_issues()를 호출하면 시간당 요청 수에 대한 GitHub의 제한을 초과하지 않도록 모든 이슈를 일괄적으로 다운로드합니다. 결과는 repository_name-issues.jsonl 파일에 저장됩니다. 여기서 각 행은 이슈를 나타내는 JSON 객체입니다. 이 기능을 사용하여 Datasets의 모든 이슈들을 파악해 보겠습니다: # 인터넷 연결 상태에 따라, 몇 분이 걸릴 수 있습니다. fetch_issues() 이슈들이 모두 다운로드되면 5.2에서 살펴본 기법을 사용하여 로컬에서 로드할 수 있습니다: from datasets import load_dataset issues_dataset = load_dataset("json", data_files="datasets-issues.jsonl", split="train") issues_dataset 좋습니다. 첫 번째 데이터 세트를 새롭게 만들었습니다! 그런데 Datasets 리포지터리의 Issues 탭에 총 1,000개 정도의 이슈들만 표시되는데 왜 수천 개의 이슈가 있는 걸까요? 그것은 GitHub 문서에 설명된 대로 모든 pull 요청도 다운로드했기 때문입니다: "GitHub의 REST API v3는 모든 pull 요청을 이슈들로 간주하지만 모든 이슈가 pull 요청은 아닙니다. 이러한 이유로 "Issues" endpoint는 응답에서 이슈와 pull 요청을 모두 반환할 수 있습니다. pull_request 키로 pull 요청을 식별할 수 있습니다. "Issues" endpoint에서 반환된 pull 요청의 ID는 이슈 ID가 됩니다." 이슈와 pull 요청의 내용이 상당히 다르기 때문에 이들을 구별할 수 있도록 약간의 전처리를 해보겠습니다. 데이터 정제하기 위에서 인용한 GitHub 문서 내용에서는 pull_request 열(column)을 사용하여 이슈와 pull 요청을 구분할 수 있다고 알려줍니다. 차이점이 무엇인지 알아보기 위해 무작위 샘플을 살펴보겠습니다. 5.3에서 했던 것처럼 Dataset.shuffle()과 Dataset.select()를 연결하여 임의의 샘플 집합을 만든 다음 다양한 URL을 비교할 수 있도록 html_url 및 pull_request 열을 zip으로 결합합니다: sample = issues_dataset.shuffle(seed=777).select(range(3)) # URL과 pull request 엔트리를 출력합니다. for url, pr in zip(sample["html_url"], sample["pull_request"]): print(f">> URL: {url}") print(f">> Pull request: {pr}\n") 여기에서 각 pull 요청이 다양한 URL과 연결되어 있는 반면 일반 이슈에는 None 항목이 있음을 알 수 있습니다. 이 구분을 사용하여 pull_request 필드가 None 인지 여부를 확인하는 새로운 is_pull_request 열을 만들 수 있습니다: issues_dataset = issues_dataset.map(lambda x: {"is_pull_request": False if x["pull_request"] is None else True}) 일부 열을 삭제하거나 이름을 변경하여 데이터 셋을 추가로 정리할 수 있지만, 일반적으로 여러 애플리케이션에서 쉽게 사용할 수 있도록 이 단계에서는 데이터 셋을 가능한 "원래(raw)" 상태로 유지하는 것이 좋습니다. 데이터 셋을 Hugging Face Hub에 푸시 하기 전에 데이터 셋에서 누락된 한 가지를 처리해 보겠습니다. 바로 각 이슈 및 pull 요청과 관련된 주석(comments)입니다. 짐작했겠지만 GitHub REST API를 사용하여 아래에서 추가해 보겠습니다. 데이터 셋에 내용 추가 다음 스크린숏에서 볼 수 있듯이, 이슈 또는 pull 요청과 관련된 댓글은 풍부한 정보 소스를 제공합니다. 특히 라이브러리에 대한 사용자 쿼리에 응답하는 검색 엔진을 구축하는 데 관심이 있다면 이 정보는 많은 도움이 될 것입니다. GitHub REST API는 이슈 번호와 관련된 모든 주석(comments)을 반환하는 Comments endpoint를 제공합니다. 이 endpoint가 무엇을 반환하는지 테스트해 보겠습니다: issue_number = 2792 url = f"https://api.github.com/repos/huggingface/datasets/issues/{issue_number}/comments" response = requests.get(url, headers=headers) response.json() 주석(comment)이 body 필드에 저장되어 있음을 알 수 있으므로, response.json()에서 각 요소의 body 내용을 선택하여 이슈와 관련된 모든 주석(comments)을 반환하는 간단한 함수를 작성해 보겠습니다: def get_comments(issue_number): url = f"https://api.github.com/repos/huggingface/datasets/issues/{issue_number}/comments" response = requests.get(url, headers=headers) return[r["body"] for r in response.json()] get_comments(2792) 결과가 괜찮아 보입니다. 그러면 Dataset.map()을 사용하여 데이터 셋의 각 이슈에 새 주석(comments) 열을 추가해 보겠습니다: # 인터넷 연결 상태에 따라 몇 분이 소요될 수도 있습니다... issues_with_comments_dataset = issues_dataset.map(lambda x: {"comments": get_comments(x["number"])}) 마지막 단계는 증강된 데이터 셋(augmented dataset)을 원시 데이터와 함께 저장하여 둘 다 Hub에 푸시 할 수 있도록 하는 것입니다. issues_with_comments_dataset.to_json("datasets-issues-with-comments.jsonl") Hugging Face Hub에 데이터 셋 업로딩 이제 필드가 추가된 데이터 셋을 허브로 푸시 하여 커뮤니티와 공유할 수 있습니다! 데이터 셋을 업로드하기 위해 Hub 라이브러리를 사용하여 Python API를 통해 Hugging Face Hub와 상호 작용할 수 있습니다. Hub는 Transformers와 함께 설치되기 때문에 바로 사용할 수 있습니다. 예를 들어, list_datasets() 함수를 사용하여 현재 Hub에서 호스팅 되는 모든 공개 데이터 셋에 대한 정보를 얻을 수 있습니다: from huggingface_hub import list_datasets all_datasets = list_datasets() print(f"Number of datasets on Hub: {len(all_datasets)}") print(all_datasets[0]) Hub에는 현재 거의 1,500개의 데이터 셋이 있고 list_datasets() 함수는 각 데이터 셋 리포지토리에 대한 몇 가지 기본 메타데이터도 제공한다는 것을 알 수 있습니다. 우리의 목적을 위해 가장 먼저 해야 할 일은 Hub에 새 데이터 셋 리포지토리를 만드는 것입니다. 그렇게 하려면 먼저 notebook_login() 함수를 사용하여 Hugging Face Hub에 로그인하여 얻을 수 있는 인증 토큰이 필요합니다: from huggingface_hub import notebook_login notebook_login() 이렇게 하면 사용자 이름과 비밀번호를 입력할 수 있는 위젯이 생성되고 API 토큰이 ~/.huggingface/token에 저장됩니다. 터미널에서 코드를 실행하는 경우 CLI를 통해 로그인할 수 있습니다. huggingface-cli login 이 작업을 마치면 create_repo() 함수를 사용하여 새 데이터 셋 리포지터리를 만들 수 있습니다. from huggingface_hub import create_repo repo_url = create_repo(name="datasets-github-issues", repo_type="dataset") repo_url 이 예에서는 spasis 사용자 이름 아래에 github-issues라는 빈 데이터 셋 리포지토리를 만들었습니다(이 코드를 실행할 때 사용자 이름은 Hub 사용자 이름이어야 합니다!). 다음으로 허브에서 로컬 머신으로 리포지토리를 복제하고 데이터 셋 파일을 복사해 보겠습니다. Hub는 수많은 공통 Git 명령어들을 래핑 하는 편리한 Repository 클래스를 제공하므로 원격 저장소를 복제하려면 복제하려는 URL과 로컬 경로를 제공하기만 하면 됩니다: from huggingface_hub import Repository repo = Repository(local_dir="datasets-github-issues", clone_from=repo_url) !cp datasets-issues-with-comments.jsonl datasets-github-issues/ 기본적으로 다양한 파일 확장자(예: .bin, .gz 및. zip)가 Git LFS로 추적되므로 동일한 Git 워크플로 내에서 대용량 파일의 버전을 관리할 수 있습니다. 저장소의. gitattributes 파일에서 추적된 파일 확장자 목록을 찾을 수 있습니다. 목록에 JSON Lines<NAME>을 포함하려면 다음 명령을 실행할 수 있습니다: repo.lfs_track("*.jsonl") 그런 다음 Repository.push_to_hub()를 사용하여 데이터 셋을 Hub로 푸시 할 수 있습니다. repo.push_to_hub() repo_url에 포함된 URL로 이동하면 데이터 셋 파일이 업로드된 것을 볼 수 있습니다. 지금부터 누구나 load_dataset()에 리포지토리 ID를 경로 인수로 제공하여 데이터 셋을 다운로드할 수 있습니다: remote_dataset = load_dataset("spasis/datasets-github-issues", split="train") remote_dataset 좋습니다. 데이터 셋을 Hub로 푸시 했으며 다른 사람들이 사용할 수 있습니다! 한 가지 중요한 작업만 남았습니다. 말뭉치가 어떻게 생성되었는지 설명하고 커뮤니티에 유용한 기타 정보를 제공하는 데이터 셋 카드를 추가하는 것입니다. huggingface-cli와 유용한 Git 기능들을 사용하여 터미널에서 직접 Hugging Face Hub에 데이터 셋을 업로드할 수도 있습니다. 이 작업을 수행하는 방법에 대한 자세한 내용은 Datasets 가이드를 참조하세요. 데이터 셋 카드 생성 문서화가 잘 된 데이터 셋은 사용자가 데이터 셋 가 자신의 작업과 관련이 있는지를 결정하고 활용과 관련된 잠재적 편향이나 위험을 평가할 수 있도록 부가 정보를 제공하기 때문에 다른 사람들(미래의 자신을 포함하여)에게 더 유용할 수 있습니다. Hugging Face Hub에서 이 정보는 각 데이터 셋 저장소의 README.md 파일에 저장됩니다. 이 파일을 만들기 전에 수행해야 하는 두 가지 주요 단계가 있습니다: datasets-tagging 애플리케이션을 사용하여 YAML<NAME>의 메타데이터 태그를 생성합니다. 이러한 태그는 Hugging Face Hub의 다양한 검색 기능에 사용되며 커뮤니티 구성원이 데이터 셋을 쉽게 찾을 수 있도록 합니다. 여기에서 사용자 정의 데이터 셋을 생성했으므로 데이터 셋 태그 지정 리포지토리를 복제하고 애플리케이션을 로컬에서 실행해야 합니다. 인터페이스는 다음과 같습니다: 유용한 데이터 셋 카드 생성에 대한 Datasets 가이드를 읽고 템플릿으로 사용하십시오. Hub에서 직접 README.md 파일을 생성할 수 있으며 lewtun/github-issues 데이터 셋 리포지토리에서 템플릿 데이터 셋 카드를 찾을 수 있습니다. 채워진 데이터 셋 카드의 스크린숏은 아래와 같습니다. 이 섹션에서 좋은 데이터 셋을 만드는 것이 상당히 복잡할 수 있다는 것을 보았지만 다행스럽게도 그것을 업로드하고 커뮤니티와<NAME>는 것은 그렇지 않습니다. 다음 섹션에서는 여기서 만든 새로운 데이터 셋을 사용하여 입력 질문에 대한 연관 이슈(issues)와 주석(comments)를 매치시키는 의미 기반 검색 엔진을 만들어볼 것입니다. 5. FAISS를 이용한 시맨틱 검색 이전 섹션에서는 Datasets 저장소의 GitHub 이슈(issues) 및 의견(comments) 데이터 셋을 만들어봤습니다. 이 섹션에서는 이 정보를 사용하여 Datasets 라이브러리에 대한 가장 시급한 질문에 대한 답변을 찾는 데 도움이 될 수 있는 검색 엔진을 구축할 것입니다! 시맨틱 검색을 위한 임베딩 사용하기 1장에서 보았듯이 트랜스포머(Transformer) 기반 언어 모델은 텍스트 내의 각 토큰을 임베딩 벡터(embedding vector)로 나타냅니다. 개별 임베딩을 "풀링(pooling)" 하여 전체 문장, 단락 또는 (경우에 따라) 문서에 대한 벡터 표현을 생성할 수 있습니다. 그런 다음 이러한 임베딩을 사용하여 각 임베딩 사이의 내적 유사도(dot-product similarity), 또는 다른 유사도 메트릭(similarity metric)을 계산하고 가장 많이 겹치는 문서를 반환하여 코퍼스에서 유사 문서 검색을 수행할 수 있습니다. 이 섹션에서는 임베딩을 사용하여 시맨틱 검색 엔진을 개발할 것입니다. 이러한 검색 엔진은 쿼리와 문서의 키워드 매칭을 기반으로 하는 기존 접근 방식에 비해 몇 가지 장점을 제공합니다. 데이터 셋 로딩 및 준비 작업 가장 먼저 해야 할 일은 이전 섹션에서 우리가 만든 GitHub 이슈 데이터 셋을 다운로드하는 것입니다. 이에 Hub 라이브러리를 사용하여 Hugging Face Hub에서 파일이 저장된 URL을 확인합니다: from huggingface_hub import hf_hub_url data_files = hf_hub_url( repo_id="spasis/datasets-github-issues", filename="datasets-issues-with-comments.jsonl", repo_type="dataset", ) data_files data_files에 저장된 URL을 사용하여 5.2에서 소개한 방법을 사용하여 원격 데이터 셋을 로드할 수 있습니다: from datasets import load_dataset issues_dataset = load_dataset("json", data_files=data_files, split="train") issues_dataset 여기에서 load_dataset()에 기본 train 분할(split)을 지정했으므로 DatasetDict 대신 Dataset을 반환합니다. 작업의 첫 번째 순서는 pull requests를 필터링하는 것입니다. Pull requests는 사용자 쿼리(query)에 응답하는데 거의 사용되지 않고 검색 엔진에 노이즈를 발생시키기 때문입니다. 지금은 어느 정도 익숙해졌겠지만, Dataset.filter() 함수를 사용하여 데이터 셋에서 이러한 행(rows)을 제거할 수 있습니다. 이와 동시에 사용자 쿼리에 대한 답변을 제공할 수 없는 주석이 없는 행들도 필터링해 보겠습니다: issues_dataset = issues_dataset.filter( lambda x: (x["is_pull_request"] == False and len(x["comments"]) > 0) ) issues_dataset 데이터 셋에 많은 열(columns)이 있음을 알 수 있으며 이들 대부분은 검색 대상이 아닙니다. 검색 관점에서 가장 유익한 열은 title, body 및 comments이며 html_url은 소스 문제에 대한 링크를 제공합니다. Dataset.remove_columns() 함수를 사용하여 그 외의 나머지 열을 삭제해 보겠습니다: columns = issues_dataset.column_names columns_to_keep = ["title", "body", "html_url", "comments"] columns_to_remove = set(columns_to_keep).symmetric_difference(columns) issues_dataset = issues_dataset.remove_columns(columns_to_remove) issues_dataset 임베딩을 생성하기 위해 각 이슈의 comments에 해당 이슈의 title과 body 내용을 추가할 것입니다. 이러한 필드들에는 종종 유용한 컨텍스트 정보가 포함되기 때문입니다. 현재 데이터 셋의 comments 열(column)은 현재 각 이슈에 대한 여러 개의 comments 리스트이므로 각 행이 (html_url, title, body, comment) 튜플로 구성되도록 해당 열을 "분해(explode, 단 일행의 특정 필드가 여러 항목을 포함하는 경우, 이를 확장하여 여러 개의 행으로 확장하는 기법)"시켜야 합니다. Pandas에서는 DataFrame.explode() 함수를 사용하여 이 작업을 수행할 수 있습니다. 이 함수는 리스트 형태로 구성된 열(list-like column)의 각 요소에 대해 새로운 행을 생성하고 해당 열이 아닌 다른 모든 열 값을 최초 행의 값으로 복제합니다. 이 동작을 확인하기 위해 먼저 Pandas DataFrame<NAME>으로 전환해 보겠습니다: issues_dataset.set_format("pandas") df = issues_dataset[:] 우선 이 DataFrame의 다섯째 행을 살펴보면 해당 이슈와 관련된 4개의 comments가 있음을 알 수 있습니다: len(df["comments"][5].tolist()) df를 분해(explode) 할 때 이러한 각 comment에 대해 하나의 행이 새롭게 생성될 것으로 예상합니다. 다음과 같은 경우인지 확인해 보겠습니다. comments_df = df.explode("comments", ignore_index=True) comments_df.head(10) 개별 comment가 포함된 comments 열과 함께 행이 복제된 것을 볼 수 있습니다! 이제 Pandas 작업을 마쳤으므로 DataFrame을 메모리에 로드하여 Dataset으로 빠르게 다시 전환할 수 있습니다: from datasets import Dataset comments_dataset = Dataset.from_pandas(comments_df) comments_dataset 이제 우리가 작업할 수 있는 수천 개의 comments가 생성되었습니다! 이제 행당 하나의 comment가 있으므로 comment 당 단어 수를 저장하는 새로운 comments_length 열을 만들어 보겠습니다: comments_dataset = comments_dataset.map( lambda x: {"comment_length": len(x["comments"].split())} ) 이 신규 칼럼(column)을 사용하여 일반적으로 검색에 유용하지 않은 "cc @lewtun" 또는 "Thanks!"와 같은 내용을 포함하는 짧은 댓글을 필터링할 수 있습니다. 필터에 대해 선택할 정확한 숫자는 없지만 약 15단어가 좋은 시작인 것 같습니다: comments_dataset = comments_dataset.filter(lambda x: x["comment_length"] > 15 and x["body"] is not None) comments_dataset 데이터 셋을 일부 정리했으면, title, body 및 comments을 하나로 합쳐서 새 텍스트 칼럼(column)에 저장해 보겠습니다. 기존 방법대로 Dataset.map()에 전달할 수 있는 간단한 함수를 작성합니다: def concatenate_text(examples): return { "text": examples["title"] + " \n " + examples["body"] + " \n " + examples["comments"] } comments_dataset = comments_dataset.map(concatenate_text) 드디어 임베딩을 만들 준비가 되었습니다! 한번 살펴봅시다. 텍스트 임베딩 생성 2장에서 AutoModel 클래스를 사용하여 토큰 임베딩을 얻을 수 있음을 보았습니다. 우리가 해야 할 일은 모델을 로드할 적절한 체크포인트(checkpoint)를 선택하는 것입니다. 다행히 임베딩을 만드는데 특화된 sentence-transformers라는 라이브러리가 있습니다. 라이브러리 문서에 설명된 대로 지금 우리가 만들려고 하는 코드는 경우는 비대칭 의미 검색(asymmetric semantic search)의 한 예입니다. 이슈 comments과 같이 더 긴 문서에서 답을 찾고자 하는 짧은 쿼리가 있기 때문입니다. 이 문서 내의 모델 개요 테이블(model overview table)에서 multi-qa-mpnet-base-dot-v1 체크포인트가 의미 검색에 가장 좋은 성능을 나타내고 있다고 하므로 우리는 이를 애플리케이션에 사용할 것입니다. 동일한 체크포인트를 사용하여 토크 나이저도 로드합니다: from transformers import AutoTokenizer, AutoModel model_ckpt = "sentence-transformers/multi-qa-mpnet-base-dot-v1" tokenizer = AutoTokenizer.from_pretrained(model_ckpt) model = AutoModel.from_pretrained(model_ckpt) 임베딩 프로세스의 속도를 높이려면 GPU 장치에 모델과 입력을 지정하는 것이 도움이 되므로 지금 수행해 보겠습니다: import torch device = torch.device("cuda") model.to(device) 앞서 언급했듯이 GitHub 이슈 말뭉치의 각 항목을 단일 벡터로 표현하고 싶기 때문에 어떤 방식으로든 토큰 임베딩을 "풀링(pooling)" 하거나 평균화(average) 해야 합니다. 한 가지 자주 사용하는 접근 방식은 모델의 출력에 대해 [CLS] 풀링(pooling)을 수행하는 것입니다. 여기서 특수 [CLS] 토큰에 대한 last_hidden_state를 수집하기만 하면 됩니다. 다음 함수가 그 작업을 진행합니다: def cls_pooling(model_output): return model_output.last_hidden_state[:, 0] 다음으로, 문서들을 토큰화하고, GPU에 텐서(tensors)를 배치하고, 이를 모델에 공급하고, 마지막으로 출력에 CLS 풀링을 적용하는 핼퍼 함수를 만듭니다: def get_embeddings(text_list): encoded_input = tokenizer(text_list, padding=True, truncation=True, return_tensors="pt") encoded_input = {k: v.to(device) for k, v in encoded_input.items()} model_output = model(**encoded_input) return cls_pooling(model_output) 말뭉치의 첫 번째 텍스트 항목을 입력하고 출력 모양을 검사하여 함수 작동을 테스트할 수 있습니다: embedding = get_embeddings(comments_dataset["text"][0]) embedding.shape 말뭉치의 첫 번째 항목을 768차원 벡터로 변환했습니다! Dataset.map()을 사용하여 말뭉치의 각 행에 get_embeddings() 함수를 적용할 수 있으므로 다음과 같이 새 임베딩 열을 생성해 보겠습니다: embeddings_dataset = comments_dataset.map( lambda x: {"embeddings": get_embeddings(x["text"]).detach().cpu().numpy()[0]} ) 임베딩을 NumPy 배열로 변환했음에 주목하세요. 그 이유는 FAISS로 데이터 셋을 인덱싱하려고 할 때 Datasets에 이<NAME>이 필요하기 때문입니다. 이는 다음에서 설명하겠습니다. 효율적인 시맨틱 검색을 위한 FAISS 사용 이제 임베딩 데이터 셋이 있으므로 이를 검색할 방법이 필요합니다. 이를 위해 FAISS 인덱스라고 하는, Datasets 내에서의 특별한 자료 구조를 사용합니다. FAISS(Facebook AI Similarity Search)는 임베딩 벡터를 빠르게 검색하고 클러스터링 하는 효율적인 알고리즘을 제공하는 라이브러리입니다. FAISS의 기본 아이디어는 입력 임베딩과 유사한 임베딩을 찾을 수 있는 인덱스(index)라는 특수 데이터 구조를 만드는 것입니다. Datasets에서 FAISS 인덱스를 만드는 것은 간단합니다. Dataset.add_faiss_index() 함수를 사용하고 인덱스할 데이터 셋의 열을 지정합니다: embeddings_dataset.add_faiss_index(column="embeddings") 이제 Dataset.get_nearest_examples() 함수로 근접 이웃 검색(nearest neighbor lookup)을 수행하여 이 인덱스에 대한 쿼리를 수행할 수 있습니다. 먼저 다음과 같이 질문을 삽입하여 이를 테스트해 보겠습니다: question = "How can I load a dataset offline?" question_embedding = get_embeddings([question]).cpu().detach().numpy() question_embedding.shape 문서와 마찬가지로 이제 해당 쿼리를 나타내는 768차원 벡터를 만들었습니다. 이 벡터를 전체 코퍼스와 비교하여 가장 유사한 임베딩을 찾을 수 있습니다: scores, samples = embeddings_dataset.get_nearest_examples("embeddings", question_embedding, k=5) Dataset.get_nearest_examples() 함수는 쿼리와 문서 간의 중첩(유사도) 순위를 매기는 점수 튜플(tuple)과 해당 샘플 집합(여기서는 가장 잘 일치하는 5개)을 반환합니다. 쉽게 정렬할 수 있도록 pandas.DataFrame에서 수집해 보겠습니다: import pandas as pd samples_df = pd.DataFrame.from_dict(samples) samples_df["scores"] = scores samples_df.sort_values("scores", ascending=False, inplace=True) 이제 쿼리가 검색된 comments와 얼마나 잘 일치하는지 보기 위해 처음 몇 개의 행을 살펴볼 수 있습니다: for _, row in samples_df.iterrows(): print(f"COMMENT: {row.comments}") print(f"SCORE: {row.scores}") print(f"TITLE: {row.title}") print(f"URL: {row.html_url}") print("=" * 50) print() 결과가 나쁘지 않습니다. 결과 중에서 두 번째 comment가 쿼리와 일치하는 것 같습니다. 6. 5장 요약 (Summary) Datasets 라이브러리를 향한 굉장한 여행이었습니다! 여기까지 온 것을 축하합니다! 이 장에서 얻은 지식으로 다음을 수행할 수 있어야 합니다: Hugging Face Hub, 노트북 또는 회사의 원격 서버 등 어디에서나 데이터 셋을 로딩 Dataset.map() 및 Dataset.filter() 함수를 함께 사용하여 데이터를 수정, 필터링 및 증강 Dataset.set_format()을 사용하여 Pandas 및 NumPy와 같은 데이터<NAME> 간에 빠르게 전환 나만의 데이터 셋을 만들어 Hugging Face Hub에 푸시 Transformer 모델을 사용하여 문서를 임베딩하고, FAISS를 사용하여 시맨틱 검색 엔진을 구축 7장에서 트랜스포머(Transformer) 모델을 활용하여 주요 NLP 작업을 수행하는 것 대해 자세히 공부할 때, 이 모든 것을 유용하게 사용할 것입니다. 6장. Tokenizers 라이브러리 3장에서 우리는 대상 작업을 위해서 모델을 미세 조정하는 방법을 살펴보았습니다. 미세 조정 과정에서 사전 학습된 모델과 동일한 토크 나이저를 사용합니다. 하지만 모델을 처음부터 학습하고 싶을 때는 어떻게 하면 좋을까요? 이러한 경우 다른 도메인이나 언어의 말뭉치로 사전 학습된 토크 나이저를 사용하는 것은 일반적으로 차선책(suboptimal)입니다. 예를 들어, 영어 말뭉치에 대해 학습된 토크 나이저는 공백과 구두점의 사용이 매우 다르기 때문에 일본어 텍스트의 말뭉치에서 제대로 수행되지 않습니다. 이 장에서는 텍스트 말뭉치에서 새로운 토크 나이저를 학습하는 방법과 이를 언어 모델을 사전 학습하는 데 사용하는 방법을 공부합니다. 이것은 모두 Transformers 라이브러리에서 "빠른(fast)" 토크 나이저를 제공하는 Tokenizers 라이브러리를 사용함으로써 가능합니다. 이 라이브러리가 제공하는 기능들을 자세히 살펴보고 빠른 토크 나이저(fast tokenizers)가 "느린(slow)" 버전과 어떻게 다른지 살펴보겠습니다. 이 장에서 다룰 주제는 다음과 같습니다: 새로운 텍스트 말뭉치를 기반으로 특정 체크포인트의 토크 나이저와 유사한 새로운 토크 나이저를 학습시키는 방법 빠른 토크 나이저(fast tokenizers)의 특징 오늘날 NLP에서 사용되는 세 가지 주요 단어 토큰화 알고리즘의 차이점 Tokenizers 라이브러리를 사용하여 처음부터 토크 나이저를 구축하고 특정 데이터로 학습하는 방법 이 장에서 소개된 기법들은 7장에서 Python 소스 코드를 위한 언어 모델을 만드는 방법을 설명할 때 활용될 수 있습니다. 먼저 토크 나이저를 "학습(train)"시키는 것이 무엇을 의미하는지 살펴보는 것으로 시작하겠습니다. 1. 기존 토크 나이저에서 새로운 토크 나이저 학습 특정 언어 모델이 당신이 원하는 언어를 제대로 지원하지 않거나, 현재 보유한 말뭉치가 언어 모델과 다른 경우, 해당 말뭉치에 적합하게 적응된 토크 나이저를 이용하여 모델을 새롭게 학습하기 원할 수도 있습니다. 이를 위해서는 그 데이터 셋에 대한 새로운 토크 나이저를 학습해야 합니다. 하지만 이것이 정확하게 의미하는 바가 무엇일까요? 2장에서 토크 나이저를 처음 접했을 때 대부분의 트랜스포머(Transformer) 모델이 하위 단어 토큰화(subword tokenization) 알고리즘을 사용하는 것을 보았습니다. 어떤 하위 단어(subword)가 중요한지, 그리고 어떤 하위 단어(subword)가 가장 빈번하게 코퍼스에서 발생하는지 식별하기 위해, 토크 나이저는 코퍼스의 모든 텍스트를 자세히 살펴볼 필요가 있습니다. 이것이 우리가 "학습(training)"이라고 부르는 프로세스입니다. 이 학습을<NAME>는 정확한 규칙들은 사용된 토크 나이저의 유형에 따라 다르며 이 장의 뒷부분에서 세 가지 주요 알고리즘에 대해 살펴보겠습니다. 토크 나이저 학습은 모델에 대한 학습과는 다릅니다! 모델 학습은 확률적 경사 하강법(stochastic gradient descent)을 사용하여 각각의 배치(batch)에 대해 손실(loss)을 조금씩 더 작게 만듭니다. 이 과정은 본질적으로 무작위입니다(즉, 동일한 학습을 두 번 수행할 때 동일한 결과를 얻으려면 고정된 seed를 설정해야 함). 토크 나이저 학습은 주어진 말뭉치에 대해 어떤 하위 단어(subword)를 선택하는 것이 가장 좋은지 식별하려는 통계적 프로세스이며, 이를 선택하는 데 사용되는 정확한 규칙은 토큰화 알고리즘에 따라 다릅니다. 이 과정은 결정론적(deterministic)입니다. 즉, 동일한 말뭉치에서 동일한 알고리즘으로 학습하면 항상 동일한 결과를 얻을 수 있습니다. 말뭉치 모으기 Transformers에는 기존에 존재하는 것들과 동일한 특성을 가진 새로운 토크 나이저를 학습하는 데 사용할 수 있는 매우 간단한 API가 있습니다. 바로 AutoTokenizer.train_new_from_iterator()가 그것입니다. 이를 실제로 실행해 보기 위해 GPT-2를 처음부터 영어가 아닌 다른 언어로 학습하고 싶다고 가정해 보겠습니다. 첫 번째 작업은 해당 언어로 표현된 대규모의 데이터를 수집하여 학습 말뭉치로 구성하는 것입니다. 모든 사람이 이해할 수 있는 예시를 제공하기 위해 여기서는 러시아어나 중국어와 같은 언어가 아니라 특수한 영어 텍스트로 볼 수 있는 Python 소스코드 집합을 사용합니다. Datasets 라이브러리는 Python 소스코드를 모으는 데 도움을 줄 수 있습니다. 간단하게 load_dataset() 함수를 사용하여 CodeSearchNet 데이터 셋을 다운로드하고 캐시 합니다. 이 데이터 셋은 CodeSearchNet 챌린지를 위해 생성되었으며 여러 프로그래밍 언어로 된 GitHub의 오픈소스 라이브러리에서 수백만 개의 함수를 포함하고 있습니다. 이 예시에서는 이 데이터 셋의 Python 부분을 로드합니다: from datasets import load_dataset # 로드하는데 몇 분이 소요될 수 있습니다. 커피나 차를 준비하세요. raw_datasets = load_dataset("code_search_net", "python") 학습 분할(Training split)을 살펴보고 접근 가능한 열(columns)을 확인할 수 있습니다. raw_datasets["train"] 이 데이터 셋이 코드에서 독스트링(docstrings)을 분리하고 있고, 이 코드와 독스트링에 대한 토큰 화가 필요함을 알 수 있습니다. 여기서는 토크 나이저를 학습하기 위해 whole_func_string 열만을 사용할 것입니다. 우리는 학습 분할(train split)을 인덱싱하여 함수들 중 하나의 예시를 다음과 같이 볼 수 있습니다: print(raw_datasets["train"][123456]["whole_func_string"]) 가장 먼저 해야 할 일은 데이터 셋을 텍스트 리스트의 이터 레이터(iterator)로 변환하는 것입니다. 예를 들어, 텍스트 리스트의 리스트로 구성할 수 있습니다. 텍스트 리스트를 사용하면 개별 텍스트를 하나씩 처리하는 대신 텍스트 배치(batches)에 대한 학습을 통해서 토크 나이저가 더 빨라질 수 있으며, 모든 것을 한 번에 메모리에 로딩하지 않으려면 이 리스트를 이터 레이터(iterator)로 변환되어야 합니다. 말뭉치의 규모가 크다면 Datasets는 RAM에 모든 것을 로드하지 않고 데이터 셋의 요소를 디스크에 저장한다는 사실을 활용할 수 있습니다. 다음을 수행하면 각각 1,000개의 텍스트 리스트가 생성되지만 모든 것이 메모리에 로드됩니다: # 데이터 셋의 규모가 작지 않다면, 다음 라인의 주석을 제거하지 마세요. # training_corpus = [raw_datasets["train"][i: i + 1000]["whole_func_string"] for i in range(0, len(raw_datasets["train"]), 1000)] Python 제너레이터(generator)를 사용하면 실제로 필요할 때까지 Python이 메모리에 아무것도 로드하지 않도록 할 수 있습니다. 이러한 생성기를 만들려면 꺾쇠괄호(brackets)를 소괄호(parentheses)로 바꾸기만 하면 됩니다: training_corpus = ( raw_datasets["train"][i : i + 1000]["whole_func_string"] for i in range(0, len(raw_datasets["train"]), 1000) ) 위 코드는 데이터 셋의 요소를 가져오지 않습니다. Python의 for 루프에서 사용할 수 있는 객체를 생성할 뿐입니다. 텍스트는 필요할 때만 메모리로 로드되며(즉, 해당 텍스트 집합이 필요한 for-loop 단계에 있을 때만) 한 번에 1,000개의 텍스트만 로드됩니다. 이렇게 하면 거대한 데이터 셋을 처리하더라도 메모리를 완전히 소진하지 않습니다. 파이썬 제너레이터(generator) 객체의 문제점은 단 한 번만 사용할 수 있다는 것입니다. 따라서, 아래 코드의 결과는 우리가 예상한 것처럼 10개의 숫자 리스트를 두 번 출력하는 것이 아니라: gen = (i for i in range(10)) print(list(gen)) print(list(gen)) 첫 번째 print 문은 10개의 숫자를 출력하지만, 그다음은 비어있는 리스트를 출력하고 있습니다. 이것이 바로 제너레이터(generator)를 반환하는 함수를 정의하는 이유입니다: def get_training_corpus(): return ( raw_datasets["train"][i : i + 1000]["whole_func_string"] for i in range(0, len(raw_datasets["train"]), 1000) ) training_corpus = get_training_corpus() yield 문을 사용하여 for 루프 내에서 제너레이터(generator)를 정의할 수도 있습니다: def get_training_corpus(): dataset = raw_datasets["train"] for start_idx in range(0, len(dataset), 1000): samples = dataset[start_idx : start_idx + 1000] yield sampels["whole_func_string"] 이전과 동일한 제너레이터를 생성하지만 리스트 내포(list comprehension)에서 할 수 있는 것보다 더 복잡한 로직을 사용할 수 있습니다. 새로운 토크 나이저 학습 이제 텍스트 배치(batch)의 이터 레이터(iterator) 형태로 말뭉치를 구성했으므로 새로운 토크 나이저를 학습할 준비가 되었습니다. 학습을 위해서 먼저 모델과 일치시키려는 토크 나이저를 로드해야 합니다. 여기서는 GPT-2를 사용하겠습니다: from transformers import AutoTokenizer old_tokenizer = AutoTokenizer.from_pretrained("gpt2") 새로운 토크 나이저를 학습하지만, 완전히 처음부터 시작하지 않도록 하는 것이 좋습니다. 이렇게 하면 토큰화 알고리즘이나 사용하려는 특수 토큰(special tokens)에 대해 아무것도 신경 쓰거나 지정할 필요가 없습니다. 우리의 새로운 토크 나이저는 GPT-2와 정확히 동일할 것이며, 우리 말뭉치를 이용한 학습을 통해 vocabulary만 변경됩니다. 먼저 이 토크 나이저가 예제 함수(example function)를 처리하는 방법을 살펴보겠습니다: example = '''def add_numbers(a, b): """Add the two numbers `a` and `b`.""" return a + b''' tokens = old_tokenizer.tokenize(example) tokens 이 토크 나이저는 각각 공백과 줄바꿈을 나타내는 Ċ 및 Ġ와 같은 몇 가지 특수 기호를 포함하고 있습니다. 결과에서 볼 수 있듯이, 이는 효율적이지 않습니다. 여러 개의 공백이 나타날 때 토크 나이저는 이를 그룹화하여 하나의 토큰으로 표현할 수도 있는데, 여기서는 각 공백을 개별 토큰으로 표현하고 있습니다. 소스코드에서 4개 또는 8개의 공백 그룹이 나타나는 것은 매우 일반적입니다. 또한 _ 문자가 있는 단어가 익숙하지 않은지, 함수명을 약간 이상하게 분할합니다. 새로운 토크 나이저를 학습하고 이러한 문제를 해결하는지 봅시다. 이를 위해 우리는 train_new_from_iterator() 메서드를 사용할 것입니다: tokenizer = old_tokenizer.train_new_from_iterator(training_corpus, 52000) 이 명령은 말뭉치가 매우 큰 경우 시간이 걸릴 수 있지만 1.6GB 텍스트 데이터 셋의 경우에는 매우 빠릅니다(12코어가 있는 AMD Ryzen 9 3900X CPU에서 1분 16초). AutoTokenizer.train_new_from_iterator()는 사용 중인 토크 나이저가 "빠른(fast)" 토크 나이저인 경우에만 작동합니다. 다음 섹션에서 볼 수 있듯이 Transformers 라이브러리에는 두 가지 유형의 토크 나이저가 포함되어 있습니다. 한 유형은 순수하게 Python으로 작성되어 있고 다른 유형(빠른 토크 나이저)은 Tokenizers 라이브러리의 도움을 받아서 Rust 프로그래밍 언어로 작성된 토크 나이저입니다. Python은 데이터 과학 및 딥러닝 응용 프로그램에 가장 자주 사용되는 언어이지만 빠른 병렬 처리가 필요한 경우 다른 언어로 작성해야 합니다. 예를 들어, 모델 계산(model computation)의 핵심인 행렬 곱셈(matrix multiplication)은 GPU에 최적화된 C 라이브러리인 CUDA로 작성되어 있습니다. 순수한 Python으로 새로운 토크 나이저를 학습하는 것은 엄청나게 느릴 것입니다. 이는 우리가 Tokenizers 라이브러리를 개발한 이유입니다. GPU에 로드된 입력 배치(input batch)에서 모델을 실행하기 위해 CUDA 언어를 배울 필요가 없었던 것처럼 빠른 토크 나이저를 사용하기 위해 Rust를 배울 필요가 없습니다. Tokenizers 라이브러리는 내부적으로 Rust의 일부 코드를 호출하는 많은 메서드에 대한 Python 바인딩을 제공합니다. 예를 들어, 새 토크 나이저의 학습을 병렬화하거나 3장에서 보았듯이 입력 배치(batch)의 토큰화를 병렬화합니다. 대부분의 트랜스포머(Transformer) 모델에는 사용 가능한 "빠른(fast)" 토크 나이저가 있으며(여기에서 확인할 수 있는 몇 가지 예외가 있음) AutoTokenizer API는 사용 가능한 경우 항상 빠른 토크 나이저를 선택합니다. 다음 섹션에서는 토큰 분류(token classification) 및 질의응답(question answering)과 같은 작업에 정말 유용한 빠른 토크 나이저의 다른 몇 가지 특수 기능을 살펴보겠습니다. 그러나 이에 대해 알아보기 전에 위 예제에서 새로운 토크 나이저를 사용해 보겠습니다: tokens = tokenizer.tokenize(example) tokens 위 결과에서 공백(space)과 줄바꿈(newline)을 나타내는 특수 기호 Ċ 및 Ġ를 다시 볼 수 있지만, 새롭게 학습된 토크 나이저는 Python 함수(function) 코퍼스에 매우 특화된 일부 토큰을 학습했음을 알 수 있습니다. 예를 들어, 들여 쓰기를 나타내는 ĊĠĠĠ 토큰과 독스트링을 시작하는 세 개의 따옴표를 나타내는 Ġ""" 토큰이 있습니다. 토크 나이저는 _ 문자를 중심으로 함수 명도 올바르게 분할합니다. 이는 매우 간결한(compact) 표현입니다. 이에 비해, 동일한 예제에서 일반적인 영어 토크 나이저를 사용하면 더 긴 문장(혹은 토큰 시퀀스)을 얻을 수 있습니다: print(len(tokens)) print(len(old_tokenizer.tokenize(example))) 다른 예를 살펴보겠습니다: example = """class LinearLayer(): def __init__(self, input_size, output_size): self.weight = torch.randn(input_size, output_size) self.bias = torch.zeros(output_size) def __call__(self, x): return x @ self.weights + self.bias """ tokenizer.tokenize(example) 들여 쓰기에 해당하는 토큰 외에도 여기에서는 이중 들여 쓰기에 대한 토큰(ĊĠĠĠĠĠĠĠ)을 볼 수 있습니다. class, init, call, self, return과 같은 특수한 Python 단어는 각각 하나의 토큰으로 토큰화되며 _ 및.으로 분할되는 것을 볼 수 있습니다. 토크 나이저는 camel-cased name도 올바르게 분할합니다. LinearLayer는 ["ĠLinear", "Layer"]로 토큰화됩니다. 학습된 토크 나이저 저장 이제 나중에 사용할 수 있도록 새 토크 나이저를 저장해야 합니다. 모델과 마찬가지로 이 작업은 save_pretrained() 메서드로 수행됩니다: tokenizer.save_pretrained("code-search-net-tokenizer") 그러면 code-search-net-tokenizer라는 새로운 폴더가 생성되며 여기에는 토크 나이저를 다시 로드할 때 필요로 하는 모든 파일이 포함됩니다. 이 토크 나이저를 동료 및 친구와<NAME>려면 계정에 로그인하여 허브에 업로드하면 됩니다. 노트북에서 작업하는 경우 이를 도와주는 편리한 기능이 있습니다: from huggingface_hub import notebook_login notebook_login() 그러면 Hugging Face 로그인 자격 증명을 입력할 수 있는 위젯이 표시됩니다. 노트북에서 작업하지 않는 경우 터미널에 다음 줄을 입력하기만 하면 됩니다: huggingface-cli login 로그인하면 다음 명령을 실행하여 토크 나이저를 푸시 할 수 있습니다: tokenizer.push_to_hub("code-search-net-tokenizer", use_temp_dir=True) 이렇게 하면 토크 나이저 파일이 포함된 code-search-net-tokenizer라는 이름의 네임스페이스(namespace)에 새 리포지토리가 생성됩니다. 그런 다음 from_pretrained() 메서드를 사용하여 어디서나 토크 나이저를 로드할 수 있습니다: # 당신이 직접 이 섹션에서 학습한 토크 나이저를 사용하기 위해서, # 아래의 "spasis"를 당신의 실제 네임스페이스로 변경하십시오. tokenizer = AutoTokenizer.from_pretrained("spasis/code-search-net-tokenizer") 이제 언어 모델을 밑바닥부터 새롭게(from scratch) 학습하고 현재 작업에서 미세 조정(fine-tuning) 할 준비가 되었습니다! 이는 7장에서 다루겠습니다. 그러나 먼저 이 장의 나머지 부분에서 빠른 토크 나이저를 자세히 살펴보고 train_new_from_iterator() 메서드를 호출할 때 실제로 어떤 일이 발생하는지 자세히 살펴보겠습니다. 2. "빠른(fast)" 토크 나이저의 특별한 능력 이 섹션에서는 Transformers에서 토크 나이저의 기능을 자세히 살펴보겠습니다. 지금까지는 입력을 토큰화하거나 토큰 아이디를 다시 텍스트로 디코딩 하는 데만 사용했지만 토크 나이저, 특히 Tokenizers 라이브러리가 지원하는 토크 나이저는 훨씬 더 많은 작업을 수행할 수 있습니다. 이러한 추가 기능을 설명하기 위해 1장에서 처음 접한 token-classification(NER) 및 question-answering 파이프라인의 결과를 재현하는 방법을 살펴봅니다. 다음 논의에서 우리는 종종 "느린(slow)" 토크 나이저와 "빠른(fast)" 토크 나이저를 구분해서 설명합니다. "느린(slow)" 토크 나이저는 Transformers 라이브러리 내부에서 Python으로 작성된 것이고, 빠른 버전은 Rust로 작성되어 Tokenizers에서 제공하는 것입니다. 약물 검토(drug review) 데이터 셋을 토큰화하는데 빠른 혹은 느린 토크 나이저의 실행 속도를 보고한 5장의 표를 기억한다면 우리가 이를 빠르고 느린 것으로 부르는 이유를 알 수 있을 것입니다. 단일 문장을 토큰화할 때 동일한 토크 나이저의 느린 버전과 빠른 버전 간의 속도 차이가 항상 나는 것은 아닙니다. 사실, 빠른 버전은 실제로 더 느릴 수 있습니다! 많은 텍스트를 동시에 토큰화할 때만 차이를 명확하게 알 수 있습니다. 배치 인코딩 (Batch encoding) 토크 나이저의 출력은 단순한 Python 딕셔너리가 아닙니다. 우리가 얻는 것은 실제로 특별한 BatchEncoding 객체입니다. 이것은 딕셔너리의 하위 클래스이지만(이것이 이전에 우리가 문제없이 해당 결과를 색인화할 수 있었던 이유입니다), 빠른 토크 나이저에서 주로 사용하는 추가 메서드가 있습니다. 병렬화(parallelization) 기능 외에도, 빠른 토크 나이저의 주요 기능은 최종 토큰이 원본 텍스트에서 어디에 위치하는지 범위(span)를 항상 추적한다는 것입니다. 이를 오프셋 매핑(offset mapping)이라고 합니다. 이것은 차례대로 각 단어를 생성된 토큰에 매핑하거나 원본 텍스트의 각 문자를 내부 토큰에 매핑하거나 그 반대로 매핑하는 것과 같은 기능들입니다. 예를 살펴보겠습니다: from transformers import AutoTokenizer tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") example = "My name is Sylvain and I work at Hugging Face in Brooklyn." encoding = tokenizer(example) print(type(encoding)) 위에서 언급했듯이, 토크 나이저의 출력에서 BatchEncoding 객체를 얻습니다. AutoTokenizer 클래스는 기본적으로 빠른 토크 나이저를 선택하므로 이 BatchEncoding 객체가 제공하는 추가 메서드를 사용할 수 있습니다. 토크 나이저가 빠른지 느린지 확인하는 두 가지 방법이 있습니다. 우선, 토크 나이저의 is_fast 속성을 확인할 수 있습니다: tokenizer.is_fast 또는 encoding의 is_fast 속성을 확인하는 방법도 있습니다: encoding.is_fast 빠른 토크 나이저를 가지고 우리가 무엇을 할 수 있는지 봅시다. 첫째, 토큰 아이디를 다시 토큰으로 변환하지 않고도 토큰에 액세스할 수 있습니다: encoding.tokens() 이 경우 인덱스 5의 토큰은 ##yl이며, 이는 원래 문장에서 "Sylvain"이라는 단어의 일부입니다. 또한 word_ids() 메서드를 사용하여 각 토큰이 유래된 해당 단어의 인덱스를 가져올 수 있습니다: encoding.word_ids() 토크 나이저의 특수 토큰 [CLS] 및 [SEP]가 None으로 매핑된 다음, 개별 토큰들이 해당 토큰이 유래한 단어에 매핑되는 것을 볼 수 있습니다. 이 메서드는 두 개의 토큰이 같은 단어에 있는지 아니면 토큰이 단어의 시작 부분에 있는지 확인하는데 특히 유용합니다. 이를 위해 ## 접두사를 사용할 수 있지만 이는 BERT와 같은 유형의 토크 나이저에서만 작동합니다. 이 방법은 속도가 빠른 모든 유형의 토크 나이저에서 유효합니다. 다음 장에서는 이 기능을 사용하여 개체명 인식(NER) 및 품사(POS) 태깅과 같은 작업에서 각 단어에 해당하는 레이블을 토큰에 올바르게 적용하는 방법을 볼 것입니다. 마스크 언어 모델링(masked language modeling), 즉 전체 단어 마스킹(whole word masking)이라고 하는 기법에서, 동일한 단어에서 분리된 모든 토큰들을 마스킹 하는 데 사용할 수도 있습니다. 단어가 무엇인지에 대한 개념은 복잡합니다. 예를 들어, "I'll"("I will"의 축약형)은 하나의 단어일까요? 아니면 두 개일까요? 이는 실제로 토크 나이저와 적용되는 사전 토큰화(pre-tokenization) 작업에 따라 다릅니다. 일부 토크 나이저는 공백 기준으로 분할하므로 이를 한 단어로 간주합니다. 또 다른 토크 나이 저들은 공백 위에 구두점을 사용하므로 두 단어로 간주합니다. 마찬가지로, 토큰을 가져온 문장에 해당 토큰을 매핑하는데 사용할 수 있는 sentence_ids() 메서드가 있습니다(이 경우 토크 나이저에서 반환된 token_type_ids가 동일한 정보를 제공할 수 있습니다). 마지막으로 word_to_chars() 또는 token_to_chars() 및 char_to_word() 또는 char_to_token() 메서드를 통해 모든 단어 또는 토큰을 원본 텍스트의 문자에 매핑할 수 있으며 그 반대로도 매핑할 수 있습니다. 예를 들어, word_ids() 메서드는 ##yl이 인덱스 3에 있는 단어의 일부라고 알려줬지만 정확히 문장 내에서 어떤 단어에 해당하는 걸까요? 다음과 같이 알 수 있습니다: start, end = encoding.word_to_chars(3) example[start:end] 이전에 언급했듯이 이 모든 것은 빠른 토크 나이저가 오프셋(offset) 목록에서 각 토큰이 가져온 텍스트 범위(span)를 추적한다는 사실에 기반하여 구동됩니다. 활용 방법을 설명하기 위해 다음으로 token-classification 파이프라인의 결과를 수동으로 복제하는 방법을 알아보겠습니다. token-classification 파이프라인의 내부 동작 1장에서 우리는 Transformers의 pipeline() 함수를 사용하여, 텍스트의 어느 부분이 사람(person), 위치(location) 또는 조직(organization)과 같은 엔터티(entities)에 해당하는지 식별하는 작업인 NER을 처음으로 살펴봤습니다. 그런 다음 2장에서 파이프라인이 원시 텍스트를 대상으로 예측하는데 필요한 세 단계 즉, 토큰화(tokenization), 모델을 통한 입력 전달, 후처리(post-processing)를 어떻게 그룹화하는지를 보았습니다. token-classification 파이프라인의 처음 두 단계는 다른 파이프라인과 동일하지만 후처리(post-processing)는 조금 더 복잡합니다. 한번 살펴봅시다! 파이프라인으로 기본 실행 결과 도출하기 먼저, 수작업으로 비교할 결과를 얻을 수 있도록 token-classification 파이프라인을 구현해 보겠습니다. 사용되는 모델은 dbmdz/bert-large-cased-finetuned-conll03-english입니다. 이 모델은 문장에 대해 NER를 수행합니다: from transformers import pipeline token_classifier = pipeline("token-classification") token_classifier("My name is Sylvain and I work at Hugging Face in Brooklyn.") 모델은 "Sylvain"에서 분리된 각 토큰들을 모두 사람(person)으로, "Hugging Face"에서 분리된 각 토큰들을 모두 조직(organization)으로, "Brooklyn" 토큰을 위치(location)로 올바르게 식별했습니다. 파이프라인에 동일한 엔터티에 해당하는 토큰을 그룹화하도록 요청할 수도 있습니다: from transformers import pipeline token_classifier = pipeline("token-classification", aggregation_strategy="simple") token_classifier("My name is Sylvain and I work at Hugging Face in Brooklyn.") aggregation_strategy를 위와 같이 지정하면 토큰들이 하나로 합쳐진 엔터티에 대해 새롭게 계산된 스코어를 제시합니다. "simple"의 경우 스코어는 해당 개체명 내의 각 토큰에 대한 스코어의 평균입니다. 예를 들어, "Sylvain"의 스코어는 이전 예에서 S, ##yl, ##va 및 ##in 토큰에 대해 계산된 스코어의 평균입니다. 사용 가능한 다른 지정자는 다음과 같습니다: "first", 여기서 각 개체 명의 스코어는 해당 개체 명의 첫 번째 토큰의 스코어입니다(따라서 "Sylvain"의 경우 토큰 S의 점수인 0.993828이 됨). "max", 여기서 각 엔터티의 스코어는 해당 엔터티내의 토큰들 중의 최댓값 스코어입니다("Hugging Face"의 경우 "Face"의 점수는 0.98879766이 됨). "average", 여기서 각 항목의 스코어는 해당 항목을 구성하는 단어(토큰이 아닙니다) 스코어의 평균입니다(따라서 "Sylvain"의 경우 "simple" 지정자와 차이가 없지만 "Hugging Face"의 점수는 0.9819이며 "Hugging"은 0.975이고 "Face"는 0.98879입니다). 이제 pipeline() 함수를 사용하지 않고 이러한 결과를 얻는 방법을 살펴보겠습니다! 입력(inputs)에서 예측(predictions)까지 먼저 입력을 토큰화하고 모델을 통해 전달해야 합니다. 이는 2장에서 설명한 내용과 동일하게 수행됩니다. AutoXxx 클래스를 사용하여 토크 나이저와 모델을 인스턴스화한 후에 이를 예제에서 사용합니다: from transformers import AutoTokenizer, AutoModelForTokenClassification model_checkpoint = "dbmdz/bert-large-cased-finetuned-conll03-english" tokenizer = AutoTokenizer.from_pretrained(model_checkpoint) model = AutoModelForTokenClassification.from_pretrained(model_checkpoint) example = "My name is Sylvain and I work at Hugging Face in Brooklyn." inputs = tokenizer(example, return_tensors="pt") outputs = model(**inputs) 여기에서 AutoModelForTokenClassification을 사용하기 때문에 입력 시퀀스의 각 토큰에 대해 하나의 logits 세트를 얻습니다: print(inputs["input_ids"].shape) print(outputs.logits.shape) 19개의 토큰으로 구성된 1개의 시퀀스가 있는 배치(batch)가 있고 모델에는 9개의 서로 다른 레이블이 존재하므로 모델의 출력은 1 x 19 x 9의 모양을 갖습니다. text-classification 파이프라인과 마찬가지로 softmax 함수를 사용하여 해당 logits을 확률로 변환하고 argmax를 사용하여 예측 결과를 얻을 수 있습니다(softmax는 순서를 변경하지 않기 때문에 logits에 대해서 argmax를 취할 수 있습니다): import torch probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)[0].tolist() predictions = outputs.logits.argmax(dim=-1)[0].tolist() print(probabilities) print(predictions) model.config.id2label 속성에는 예측 결과를 확인하는 데 사용할 수 있는 레이블에 대한 인덱스 매핑이 포함되어 있습니다: model.config.id2label 위에서 보듯이 총 9개의 레이블이 있습니다. O는 개체명에 포함되지 않는 토큰에 대한 레이블("outside"를 나타냄)이고 각 개체명 유형, 즉 기타(miscellaneous), 인명(person), 기관명(organization), 지명(location) 각각에 대해 두 개의 레이블이 있습니다. 레이블 B-XXX는 토큰이 개체명 XXX의 시작 부분에 있음을 나타내고, 레이블 I-XXX는 토큰이 개체명 XXX의 내부에 있음을 나타냅니다. 예를 들어, 이전 예시에서 우리는 모델이 토큰 "S"를 B-PER(인명 개체 명의 시작)으로 분류하고 "##yl", "##va" 및 "##in" 토큰을 I-PER(인명 개체 명의 내부)로 분류하기를 기대했을 수도 있습니다. 그런데 위 결과에서 보는 바와 같이 4개 토큰 모두에 I-PER이라는 레이블을 부여했기 때문에 예측에 오류가 있다고 생각할 수 있지만 그렇지 않을 수도 있습니다. 실제로 이러한 B- 및 I- 레이블 표기 방식에는 IOB1 및 IOB2의 두 가지<NAME>이 있습니다. IOB2<NAME>(아래 그림에서 분홍색 태그)은 우리가 도입한<NAME>인 반면, IOB1<NAME>(파란색 태그)에서 B-로 시작하는 레이블은 동일한 유형의 인접한 두 엔터티를 구분하는 데만 사용됩니다. 우리가 사용하는 모델은 IOB1<NAME>을 사용하는 데이터 셋에서 미세 조정되었으므로 "S" 토큰에 레이블 I-PER을 할당합니다. 이 맵을 사용하여 token-classification 파이프라인의 결과를 (거의 완전히) 재현할 준비가 되었습니다. O로 분류되지 않은 각 토큰의 점수와 레이블만 가져올 수 있습니다: results = [] tokens = inputs.tokens() for idx, pred in enumerate(predictions): label = model.config.id2label[pred] if label != "O": results.append( {"entity": label, "score": probabilities[idx][pred], "word": tokens[idx]} ) print(results) 이 결과는 이전 결과와 매우 유사하지만 한 가지 차이점이 있습니다. 파이프라인은 또한 원본 문장에서 각 엔터티의 시작과 끝에 대한 정보를 제공했습니다. 여기에서 오프셋 매핑(offset mapping)이 작동합니다. 오프셋(offset)을 얻으려면 입력에 토크 나이저를 적용할 때 return_offsets_mapping=True를 설정하기만 하면 됩니다: inputs_with_offsets = tokenizer(example, return_offsets_mapping=True) inputs_with_offsets["offset_mapping"] 각 튜플은 각 토큰에 해당하는 텍스트 범위이며, 여기서 (0, 0)은 특수 토큰용으로 예약되어 있습니다. 이전에 인덱스 5의 토큰이 "##yl"이고 해당 오프셋이 (12, 14)로 지정되어 있는 것을 보았습니다. 이 오프셋으로 슬라이싱을 하면: example[12:14] '##' 없이 적절한 텍스트 범위(text span)를 얻습니다. 이를 사용하여 이제 이전 결과의 재현(reproduction)을 완료할 수 있습니다: results = [] inputs_with_offsets = tokenizer(example, return_offsets_mapping=True) tokens = inputs_with_offsets.tokens() offsets = inputs_with_offsets["offset_mapping"] for idx, pred in enumerate(predictions): label = model.config.id2label[pred] if label != 'O': start, end = offsets[idx] results.append( { "entity": label, "score": probabilities[idx][pred], "word": tokens[idx], "start": start, "end": end, } ) print(results) 이 결과는 우리가 파이프라인 실행을 통해 얻은 결과와 동일합니다! 엔터티 그룹화 오프셋을 사용하여 각 엔터티의 시작 및 끝 키를 결정하는 것은 편리하지만 해당 정보가 꼭 필요한 것은 아닙니다. 그러나 엔터티 토큰을 그룹화하려는 경우 오프셋을 사용하면 지저분한 코드를 많이 절약할 수 있습니다. 예를 들어 Hu, ##gging 및 Face 토큰을 하나로 그룹화하려는 경우, 처음 두 토큰은 ## 없이 합쳐야 하고 Face는 ##로 시작하지 않으므로 앞에 공백을 추가하여 결합해야 한다는 특수 규칙을 만들어야 합니다. 그러나 이러한 규칙들은 특정 유형의 토크 나이저에서만 작동합니다. SentencePiece 또는 Byte-Pair-Encoding 토크 나이저(이 장의 뒷부분에서 설명)에서는 또 다른 규칙 집합을 작성해야 합니다. 오프셋을 사용하면 모든 사용자 정의 코드가 사라집니다. 단지 첫 번째 토큰으로 시작하고 마지막 토큰으로 끝나는 원본 텍스트의 범위를 사용할 수 있습니다. 따라서 Hu, ##gging 및 Face 토큰의 경우, 이를 합치기 위해서 33번째 문자(Hu의 시작 부분)에서 시작하여 45번째 문자(Face의 끝부분) 앞까지 슬라이싱을 해주면 됩니다: example[33:45] 특정 엔터티에 포함된 토큰들을 그룹화하는 동안 예측 결과를 후처리하는 코드를 작성하기 위해 B-XXX 또는 I-XXX로 레이블이 지정될 수 있는 첫 번째 엔터티를 제외하고 연속적이고 I-XXX로 레이블이 지정된 엔터티를 함께 그룹화합니다. 따라서 O, 새로운 유형의 엔터티 또는 동일한 유형의 엔터티가 시작되고 있음을 알리는 B-XXX를 받으면 엔터티 그룹화를 중지합니다: import numpy as np results = [] inputs_with_offsets = tokenizer(example, return_offsets_mapping=True) tokens = inputs_with_offsets.tokens() offsets = inputs_with_offsets["offset_mapping"] idx = 0 while idx < len(predictions): pred = predictions[idx] label = model.config.id2label[pred] if label != "O": # Remove the B- or I- label = label[2:] start, _ = offsets[idx] # Grab all the tokens labeled with I-label all_scores = [] while ( idx < len(predictions) and model.config.id2label[predictions[idx]] == f"I-{label}" ): all_scores.append(probabilities[idx][pred]) _, end = offsets[idx] idx += 1 # The score is the mean of all the scores of the tokens in that grouped entity score = np.mean(all_scores).item() word = example[start:end] results.append( { "entity_group": label, "score": score, "word": word, "start": start, "end": end, } ) idx += 1 print(results) 이렇게 파이프라인 실행 결과와 동일한 결과를 얻습니다! 이 오프셋이 매우 유용하게 활용되는 또 다른 예는 질의응답(question answering)입니다. 다음 섹션에서 파이프라인을 자세히 공부하면서 Transformers 라이브러리에 있는 토크 나이저의 마지막 기능인 입력을 주어진 길이로 자를 때 넘치는 토큰을 처리하는 방법을 살펴보겠습니다. 3. QA 파이프라인에서의 "빠른(fast)" 토크 나이저 이제 question-answering 파이프라인을 살펴보고, 이전 섹션에서 그룹화된 엔터티를 구하기 위해서 수행했던 것처럼 오프셋을 활용하여 컨텍스트에서 입력 질문에 대한 답변을 직접 구하는 방법을 살펴보겠습니다. 그런 다음 절단(truncation) 될 수밖에 없는 매우 긴 컨텍스트를 처리하는 방법을 볼 것입니다. 질의응답(question answering) 작업에 관심이 없다면 이 섹션을 건너뛸 수 있습니다. question-answering 파이프라인 사용하기 1장에서 보았듯이 우리는 질문에 대한 답을 얻기 위해 다음과 같은 question-answering 파이프라인을 사용할 수 있습니다: from transformers import pipeline question_answerer = pipeline("question-answering") context = """ Transformers is backed by the three most popular deep learning libraries — Jax, PyTorch, and TensorFlow — with a seamless integration between them. It's straightforward to train your models with one before loading them for inference with the other. """ question = "Which deep learning libraries back Transformers?" question_answerer(question=question, context=context) 모델이 허용하는 최대 길이보다 긴 텍스트를 자르거나 분할할 수 없는(따라서 문서 끝에 있는 정보를 놓칠 수 있는) 다른 파이프라인과 달리, 이 파이프라인은 매우 긴 컨텍스트를 처리할 수 있으며 질문에 대한 답이 컨텍스트의 마지막에 있더라도 그 답변을 추출할 수 있습니다: long_context = """ Transformers: State of the Art NLP Transformers provides thousands of pretrained models to perform tasks on texts such as classification, information extraction, question answering, summarization, translation, text generation and more in over 100 languages. Its aim is to make cutting-edge NLP easier to use for everyone. Transformers provides APIs to quickly download and use those pretrained models on a given text, fine-tune them on your own datasets and then share them with the community on our model hub. At the same time, each python module defining an architecture is fully standalone and can be modified to enable quick research experiments. Why should I use transformers? 1. Easy-to-use state-of-the-art models: - High performance on NLU and NLG tasks. - Low barrier to entry for educators and practitioners. - Few user-facing abstractions with just three classes to learn. - A unified API for using all our pretrained models. - Lower compute costs, smaller carbon footprint: 2. Researchers can share trained models instead of always retraining. - Practitioners can reduce compute time and production costs. - Dozens of architectures with over 10,000 pretrained models, some in more than 100 languages. 3. Choose the right framework for every part of a model's lifetime: - Train state-of-the-art models in 3 lines of code. - Move a single model between TF2.0/PyTorch frameworks at will. - Seamlessly pick the right framework for training, evaluation and production. 4. Easily customize a model or an example to your needs: - We provide examples for each architecture to reproduce the results published by its original authors. - Model internals are exposed as consistently as possible. - Model files can be used independently of the library for quick experiments. Transformers is backed by the three most popular deep learning libraries — Jax, PyTorch and TensorFlow — with a seamless integration between them. It's straightforward to train your models with one before loading them for inference with the other. """ question_answerer(question=question, context=long_context) 이 모든 작업을 어떻게 수행하는지 봅시다! 질의응답을 위한 사전학습 모델 사용하기 다른 파이프라인과 마찬가지로 우선 입력을 토큰화한 다음 모델로 전달합니다. question-answering 파이프라인에 디폴트로 사용되는 체크포인트는 distillbert-base-cased-distilled-squad입니다. 체크포인트 이름 내의 "squad"는 모델이 미세 조정된 데이터 셋의 명칭입니다. 7장에서 SQuAD 데이터 셋에 대해 더 이야기할 것입니다: from transformers import AutoTokenizer, AutoModelForQuestionAnswering model_checkpoint = "distilbert-base-cased-distilled-squad" tokenizer = AutoTokenizer.from_pretrained(model_checkpoint) model = AutoModelForQuestionAnswering.from_pretrained(model_checkpoint) inputs = tokenizer(question, context, return_tensors="pt") outputs = model(**inputs) 위 코드에서 질문과 컨텍스트를 순서대로 배치시켜 쌍(pair)으로 토큰화합니다. 아래 그림을 보면 이해가 빠를 겁니다. 질의응답 모델은 지금까지 본 모델과 조금 다르게 작동합니다. 위의 그림을 예시로 보면, 모델은 정답 시작 토큰의 인덱스(여기서는 21)와 정답 마지막 토큰의 인덱스(여기서는 24)를 예측하도록 학습되었습니다. 해당 모델이 하나의 로짓(logits) 텐서를 반환하지 않고 두 개의 텐서를 반환하는 이유입니다. 하나는 정답의 시작 토큰에 해당하는 로짓(logit)이고 다른 하나는 정답의 마지막 토큰에 해당하는 로짓(logit)입니다. 이 경우 66개의 토큰이 포함된 입력이 하나가 존재하므로 다음을 얻습니다: start_logits = outputs.start_logits end_logits = outputs.end_logits print(start_logits.shape, end_logits.shape) 이러한 로짓들을 확률로 변환하기 위해 softmax 함수를 적용해야 하나, 그전에 컨텍스트(context)가 아닌 토큰 인덱스를 마스킹(masking) 해야 합니다. 입력이 [CLS] question [SEP] context [SEP]이므로 질문에 포함된 토큰과 [SEP] 토큰을 마스킹 해야 합니다. 그러나 일부 모델에서는 컨텍스트에 답이 없음을 나타내기 위해 사용할 수도 있으므로 [CLS] 토큰은 마스킹 하지 않고 그대로 유지합니다. 나중에 softmax를 적용할 것이기 때문에 마스킹(masking) 하려는 로짓을 큰 음수로 바꾸면 됩니다. 여기서는 -10000을 사용합니다: import torch sequence_ids = inputs.sequence_ids() # 컨텍스트 토큰들을 제외하고는 모두 마스킹 한다. mask = [i != 1 for i in sequence_ids] # [CLS] 토큰은 마스킹 하지 않는다. mask[0] = False mask = torch.tensor(mask)[None] start_logits[mask] = -10000 end_logits[mask] = -10000 이제 예측하고 싶지 않은 위치에 해당하는 로짓을 적절하게 마스킹 했으므로 softmax를 적용할 수 있습니다: start_probabilities = torch.nn.functional.softmax(start_logits, dim=-1)[0] end_probabilities = torch.nn.functional.softmax(end_logits, dim=-1)[0] 이 단계에서 시작 및 종료 확률의 argmax를 취할 수 있지만 시작 인덱스가 종료 인덱스보다 클 수 있으므로 몇 가지 예방 조치를 더 취해야 합니다. start_index <= end_index를 만족하는 가능한 start_index 및 end_index의 확률을 계산한 다음 가장 높은 확률을 가진 튜플 (start_index, end_index)을 선택합니다. "The answer starts at start_index" 및 "The answer ends at end_index" 이벤트가 독립적이라고 가정할 때, 답변이 start_index에서 시작하여 end_index에서 끝날 확률은 다음과 같습니다: t r p o a i i i s [ t r i d x ] e d r b b l t e [ n i 따라서 모든 점수를 계산하려면 start_index <= end_index을 만족하는 모든 t r p o a i i i s [ t r i d x ] e d r b b l t e [ n i d x ] 곱을 계산하면 됩니다. 우선, 모든 가능한 곱을 계산해 봅시다: scores = start_probabilities[:, None] * end_probabilities[None, :] 그런 다음 start_index > end_index를 만족하는 값들을 0으로 설정하여 값을 마스킹 합니다(다른 확률은 모두 양수임). torch.triu() 함수는 인수로 전달된 2D 텐서의 위쪽 삼각형 부분을 반환하므로 해당 마스킹을 수행할 수 있습니다: scores = torch.triu(scores) 이제 최댓값의 인덱스만 구하면 됩니다. PyTorch는 평탄화된 텐서(flattened tensor)의 인덱스를 반환하므로 나머지 없는 나누기, // 와 나머지 연산, %을 사용하여 start_index 및 end_index를 가져와야 합니다: max_index = scores.argmax().item() start_index = max_index // scores.shape[1] end_index = max_index % scores.shape[1] print(scores[start_index, end_index]) 아직 완료되지 않았지만 적어도 추출된 응답에 대한 정확한 점수는 계산했습니다(이전 섹션의 첫 번째 결과와 비교하여 이를 확인할 수 있습니다). ✏ Try it out! 가장 가능성이 높은 5개의 응답에 대한 시작 및 종료 인덱스를 출력해 봅시다. 응답들의 토큰 단위 start_index 및 end_index를 구했기 때문에, 이를 기반으로 이제 컨텍스트 내에서의 문자 단위 인덱스로 변환해야 합니다. 여기에서 오프셋(offset)이 매우 유용할 것입니다. 토큰 분류(token classification) 작업에서처럼 이들 인덱스들을 사용할 수 있습니다: inputs_with_offsets = tokenizer(question, context, return_offsets_mapping=True) offsets = inputs_with_offsets["offset_mapping"] start_char, _ = offsets[start_index] _, end_char = offsets[end_index] answer = context[start_char:end_char] 이제 결과를 표시하기 위해서 출력<NAME>을 지정할 수 있습니다: result = { "answer": answer, "start": start_char, "end": end_char, "score": scores[start_index, end_index] } print(result) 좋습니다! 위 결과는 앞에서 실행했던 파이프라인의 결과와 동일합니다. ✏ Try it out! 이전에 계산한 최고 점수를 사용하여 가능성이 가장 높은 5개의 응답을 표시해 봅시다. 결과를 확인하기 위해서 이전의 파이프라인으로 돌아가서 호출할 때 top_k=5를 전달하면 됩니다. 길이가 긴 컨텍스트 다루기 위에서 예제로 사용한 질문 및 길이가 긴 컨텍스트를 토큰 화해 보면 question-answering 파이프라인에서 사용된 최대 길이(384)보다 더 많은 토큰들이 출력됩니다: inputs = tokenizer(question, long_context) print(len(inputs["input_ids"])) 따라서 최대 길이만큼 입력을 절단해야 합니다. 이를 수행할 수 있는 방법은 여러 가지가 있지만 우선주의해야 할 것은 질문을 절단해서는 안 되고 컨텍스트만 절단해야 한다는 점입니다. 컨텍스트는 두 번째 문장이므로 "only_second" 절단 옵션을 사용할 수 있습니다. 이때 발생하는 문제는 질문에 대한 정답이 잘려 나간 컨텍스트에 있을 수 있다는 것입니다. 예를 들어, 아래 예시에서 정답이 컨텍스트의 끝부분에 있는 질문을 입력했다면, 해당 질문에 대한 답변은 존재하지 않습니다: inputs = tokenizer(question, long_context, max_length=384, truncation="only_second") print(tokenizer.decode(inputs["input_ids"])) 이것은 모델이 정답을 선택하는 데 어려움을 겪을 것임을 의미합니다. 이 문제를 해결하기 위해 question-answering 파이프라인을 사용하면 컨텍스트를 더 작은 청크로 분할하여 최대 길이를 지정할 수 있습니다. 정답을 찾을 수 있도록 컨텍스트를 잘못된 위치에서 분할하지 않도록 하기 위해 청크 사이에 약간의 겹침(overlap)도 포함됩니다. return_overflowing_tokens=True를 추가하여 토크 나이저("빠른" 또는 "느린")가 이를 수행하도록 할 수 있으며 stride 인수로 원하는 겹침 정도를 지정할 수 있습니다. 다음은 길이가 비교적 짧은 문장을 이용한 예시입니다: sentence = "This sentence is not too long but we are going to split it anyway." inputs = tokenizer( sentence, truncation=True, return_overflowing_tokens=True, max_length=6, stride=2 ) for ids in inputs["input_ids"]: print(tokenizer.decode(ids)) 우리가 볼 수 있듯이, 입력 문장은 inputs["input_ids"]의 각 항목이 최대 6개의 토큰을 갖는 청크들로 분할되었습니다(마지막 항목이 다른 항목과 같은 크기가 되도록 padding을 추가해야 합니다. ) 각 항목 사이에 2개씩의 토큰이 겹칩니다. 토큰화 결과를 자세히 살펴보겠습니다: print(inputs.keys()) 예상대로 input_IDs와 attention_mask가 담겨 있습니다. 마지막 키인 overflow_to_sample_mapping은 각 결과가 어느 문장에 해당하는지 알려주는 맵(map)입니다. 여기에는 우리가 토크 나이저로 전달한 (유일한) 문장에서 나온 7개의 결과가 있습니다: print(inputs["overflow_to_sample_mapping"]) 이것은 여러 문장을 함께 토큰화할 때 더 유용합니다. 예를 들어, sentences = [ "This sentence is not too long but we are going to split it anyway.", "This sentence is shorter but will still get split.", ] inputs = tokenizer( sentences, truncation=True, return_overflowing_tokens=True, max_length=6, stride=2 ) print(inputs["overflow_to_sample_mapping"]) 결과는 첫 번째 문장이 이전과 같이 7개의 청크로 분할되고 다음 4개의 청크가 두 번째 문장에서 온다는 것을 의미합니다. 이제 길이가 긴 컨텍스트로 돌아가 보겠습니다. 기본적으로 question-answering 파이프라인은 앞에서 언급한 것처럼 최대 길이 384와 모델이 미세 조정된 방식과 동일한 128의 보폭(stride)을 사용합니다. 파이프라인을 호출할 때 max_seq_len 및 stride 인수를 전달하여 해당 매개변수를 조정할 수 있습니다. 따라서 토큰화할 때 이러한 매개변수를 사용합니다. 또한 패딩(padding)을 추가하고(텐서를 구성할 수 있도록 샘플들의 길이를 동일하게 하기 위해서) 오프셋을 요청할 것입니다: inputs = tokenizer( question, long_context, stride=128, max_length=384, padding="longest", truncation="only_second", return_overflowing_tokens=True, return_offsets_mapping=True, ) 위에서 inputs에는 모델로 입력되는 input_IDs와 attention_mask뿐만 아니라, 방금 언급한 오프셋(offset) 및 overflow_to_sample_mapping이 포함됩니다. 마지막 두 가지는 모델에서 사용하는 매개변수가 아니므로 텐서로 변환하기 전에 inputs에서 이를 제거(pop) 합니다: _ = inputs.pop("overflow_to_sample_mapping") offsets = inputs.pop("offset_mapping") inputs = inputs.convert_to_tensors("pt") print(inputs["input_ids"].shape) 길이가 긴 컨텍스트는 두 개로 분할되었습니다. 따라서, 모델의 출력은 두 가지 종류의 시작 및 마지막 로짓(logits)으로 구성됩니다: outputs = model(**inputs) start_logits = outputs.start_logits end_logits = outputs.end_logits print(start_logits.shape, end_logits.shape) 이전과 마찬가지로 softmax를 취하기 전에 컨텍스트의 일부가 아닌 토큰을 먼저 마스킹 합니다. 또한 모든 패딩 토큰을 마스킹 합니다(attention_mask로 표시된 대로): sequence_ids = inputs.sequence_ids() # Mask everything apart from the tokens of the context mask = [i != 1 for i in sequence_ids] # Unmask the [CLS] token mask[0] = False # Mask all the [PAD] tokens mask = torch.logical_or(torch.tensor(mask)[None], (inputs["attention_mask"] == 0)) start_logits[mask] = -10000 end_logits[mask] = -10000 그런 다음 softmax를 사용하여 로짓(logits)을 확률로 변환할 수 있습니다: start_probabilities = torch.nn.functional.softmax(start_logits, dim=-1) end_probabilities = torch.nn.functional.softmax(end_logits, dim=-1) 다음 단계는 앞에서 길이가 짧은 컨텍스트에 대해 수행한 작업과 유사하지만 청크가 2개이므로 이를 반복합니다. 가능한 모든 답변(answer spans)에 점수를 부여한 다음 가장 좋은 점수를 받은 답변을 선택합니다: candidates = [] for start_probs, end_probs in zip(start_probabilities, end_probabilities): scores = start_probs[:, None] * end_probs[None, :] idx = torch.triu(scores).argmax().item() start_idx = idx // scores.shape[0] end_idx = idx % scores.shape[0] score = scores[start_idx, end_idx].item() candidates.append((start_idx, end_idx, score)) print(candidates) 위에서 출력된 2개의 후보는 모델이 각 청크(chunk, 길이가 길어서 분할된 컨텍스트)에서 찾을 수 있었던 최상의 답변에 해당합니다. 모델은 정답이 두 번째라고 확실히 더 확신합니다(좋은 징조입니다!). 이제 두 토큰 범위(token spans)를 컨텍스트의 문자 범위(character spans)에 매핑하기만 하면 됩니다. 우리는 가장 확실한 답변을 얻기 위해 두 번째 후보만 매핑하면 되지만, 첫 번째 청크에서 모델이 선택한 답변을 보는 것도 재미있을 것 같습니다. ✏ Try it out! 위의 코드를 수정하여 가장 가능성이 높은 5개의 답변에 대한 점수와 범위를 반환해 보세요(청크별로가 아니라 총합적으로). 우리가 이전에 가져온 오프셋은 실제로는 오프셋 리스트(list of offsets)이며 텍스트 청크당 하나의 리스트가 존재합니다: for candidate, offset in zip(candidates, offsets): start_token, end_token, score = candidate start_char, _ = offset[start_token] _, end_char = offset[end_token] answer = long_context[start_char:end_char] result = {"answer": answer, "start":start_char, "end":end_char, "score":score} print(result) 첫 번째 결과를 무시하면 이 길이가 긴 컨텍스트(long_context)에 대한 파이프라인 실행 결과와 동일한 결과를 얻습니다. ✏ Try it out! 이전에 계산한 최고 점수를 사용하여 가장 가능성이 높은 5개의 답변을 표시해 보세요(각 청크가 아닌 전체 컨텍스트에 대해). 결과를 확인하기 위해서 첫 번째 파이프라인으로 돌아가서 호출할 때 top_k=5를 전달해 봅시다. 이것으로 토크 나이저의 기능에 대한 심층 분석을 마칩니다. 다음 장에서 일반적인 NLP 작업에서 모델을 미세 조정하는 방법을 보여줄 때 여기서 배운 모든 것들을 실제로 적용할 것입니다. 4. 정규화(Normalization) 및 사전 토큰화(Pre-tokenization) 트랜스포머 모델과 함께 사용되는 가장 일반적인 3가지 하위 단어(subwword) 토큰화 알고리즘(Byte-Pair Encoding[BPE], WordPiece, Unigram)에 대해 더 자세히 알아보기 전에, 먼저 각 토크 나이저가 텍스트에 적용하는 전처리 과정을 살펴보겠습니다. 다음 그림은 토큰화 파이프라인의 단계에 대한 상위 수준의 개요를 보여주고 있습니다: 텍스트를 하위 토큰(subtokens)으로 분할하기 전에(모델에 따라), 토크 나이저는 정규화(normalization) 및 사전 토큰화(pre-tokenization) 두 단계를 수행합니다. 정규화(Normalization) 정규화 단계에는 불필요한 공백 제거, 소문자 변환(lowercasing) 및 악센트 제거 등과 같은 몇 가지 일반적인 정제 작업이 포함됩니다. NFC 또는 NFKC와 같은 유니코드 정규화(Unicode normalization) 작업과 거의 동일한 작업이 이 과정에서 수행됩니다. Transformers의 tokenizer는 Tokenizers 라이브러리에서 하부 토크 나이저에 대한 액세스를 제공하는 backend_tokenizer라는 속성을 가지고 있습니다: from transformers import AutoTokenizer tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased") print(type(tokenizer.backend_tokenizer)) 토크 나이저 객체의 normalizer 속성에는 normalize_str() 메서드가 있습니다. 이 메서드는 정규화가 수행되는 방식을 확인하는 데 사용할 수 있습니다: print(tokenizer.backend_tokenizer.normalizer.normalize_str("Héllò hôw are ü?")) 이 예에서는 bert-base-uncased 체크포인트를 선택했기 때문에 정규화 과정에서 소문자화(lowercasing)를 수행하고 악센트를 제거했습니다. ✏ Try it out! bert-base-cased 체크포인트에서 토크 나이저를 로드하고 동일한 문자열을 입력해 보세요. 토크 나이저의 대소문자 구분이 있는 버전과 소문자 변환이 된 버전 간에 볼 수 있는 주요 차이점은 무엇입니까? 사전 토큰 화(Pre-tokenization) 다음 섹션에서 볼 수 있듯이 토크 나이저는 원시 텍스트만으로는 학습될 수 없습니다. 대신에 먼저 텍스트를 단어와 같은 작은 개체들로 분할해야 합니다. 여기서 사전 토큰화(pre-tokenization) 단계가 실행됩니다. 2장에서 보았듯이 단어 기반 토크 나이저는 원시 텍스트를 단순히 공백과 구두점을 기준으로 단어로 분할할 수 있습니다. 이 단어들은 토크 나이저가 학습 과정에서 학습할 수 있는 하위 토큰(subtokens)의 경계가 됩니다. 빠른 토크 나이저(fast tokenizer)가 사전 토큰화(pre-tokenization)를 수행하는 과정을 보려면 tokenizer 객체의 pre_tokenizer 속성이 가진 pre_tokenize_str() 메서드를 사용할 수 있습니다: tokenizer.backend_tokenizer.pre_tokenizer.pre_tokenize_str("Hello, how are you?") 토크 나이저가 오프셋(offsets)을 어떻게 유지하고 있는지에 주목하세요. 이는 이전 섹션에서 사용한 오프셋 매핑을 제공하는 방법입니다. 여기서 토크 나이저는 두 개의 공백("are"와 "you" 사이에 있는)을 무시하고 하나의 공백으로 바꾸지만, "are"와 "you" 사이의 오프셋 점프(14에서 16)는 계속 유지합니다. 우리는 BERT 토크 나이저를 사용하고 있기 때문에 사전 토큰화(pre-tokenization)에는 공백(whitespace)과 구두점(puntuation) 분할이 포함됩니다. 다른 토크 나이 저들은 이 단계에서 다른 규칙을 수행할 수 있습니다. 예를 들어 GPT-2 토크 나이저를 사용하는 경우: tokenizer = AutoTokenizer.from_pretrained("gpt2") tokenizer.backend_tokenizer.pre_tokenizer.pre_tokenize_str("Hello, how are you?") 위 코드의 실행 결과와 같이, 공백과 구두점에서도 분할되지만 공백은 없애지 않고 Ġ 기호로 대체하므로 토큰을 디코딩 하면 원래 공백을 복구할 수 있습니다. 또한 BERT 토크 나이저와 달리 이 토크 나이저는 이중 공백을 무시하지 않습니다. 마지막 예로 SentencePiece 알고리즘을 기반으로 하는 T5 토크 나이저를 살펴보겠습니다: tokenizer = AutoTokenizer.from_pretrained("t5-small") tokenizer.backend_tokenizer.pre_tokenizer.pre_tokenize_str("Hello, how are you?") GPT-2 토크 나이저와 같이 T5 토크 나이저는 공백을 유지하고 특정 토큰(_)으로 대체하지만 구두점이 아닌 공백에서만 토큰을 분할합니다. 또한 기본적으로 문장 시작 부분("Hello" 앞부분)에 공백을 추가하고 "are"와 "you" 사이의 이중 공백을 무시했습니다. 지금까지 토크 나이저가 텍스트를 처리하는 각각의 방법을 조금 살펴보았으므로 하부의 토큰화 알고리즘 자체를 공부할 수 있습니다. 우선 다양한 목적으로 광범위하게 적용할 수 있는 SentencePiece를 간단히 살펴보겠습니다. 그리고 다음 3개의 섹션에서 하위 단어(subword) 토큰화에 사용되는 세 가지 주요 알고리즘이 작동하는 방식을 알아보겠습니다. SentencePiece SentencePiece는 다음 세 섹션에서 보게 될 모든 모델과 함께 사용할 수 있는 텍스트 전처리를 위한 토큰화 알고리즘입니다. 텍스트를 일련의 유니코드 문자들로 간주하고 공백을 특수 문자인 _로 치환합니다. Unigram 알고리즘(섹션 7 참조)과 함께 사용하면 사전 토큰화(pre-tokenization) 단계가 필요하지 않으므로 공백 문자가 사용되지 않는 언어(예: 중국어 또는 일본어)에 매우 유용합니다. SentencePiece의 또 다른 주요 기능은 가역적 토큰화(reversible tokenization)입니다. 공백에 대한 특별한 처리가 없기 때문에 토큰 디코딩은 토큰을 연결하고 _s를 공백으로 바꾸는 것으로 간단히 수행됩니다. 그 결과 정규화된 텍스트가 도출됩니다. 앞에서 보았듯이 BERT 토크 나이저는 반복되는 공백을 제거하므로 토큰화는 되돌릴 수 없습니다. 토큰화 알고리즘 개요 이후 섹션에서는 세 가지 주요 하위 단어 토큰화(subword tokenization) 알고리즘인 BPE(GPT-2 등에서 사용), WordPiece(예: BERT에서 사용) 및 Unigram(T5 및 그 외.)에 대해 자세히 설명합니다. 본격적으로 시작하기 전에 각각의 작동 방식에 대한 간략한 개요를 아래 표에서 보여주고 있습니다. 다음 섹션을 각각 읽은 후 그래도 이해가 되지 않는 경우에는 주저하지 말고 이 표로 다시 돌아오세요. 모델 BPE WordPiece Unigram 학습 과정(Training) 소규모 vocabulary에서 시작하여 토큰 병합 규칙을 배웁니다. 소규모 vocabulary에서 시작하여 토큰 병합 규칙을 배웁니다. 대규모 vocabulary에서 시작하여 토큰을 제거하는 규칙을 배웁니다. 학습 단계(Training step) 가장 빈번하게 발생되는 토큰 쌍을 병합합니다. 토큰 쌍의 빈도수에 기반한 최고 점수를 가진 쌍에 해당하는 토큰을 병합하고 각 개별 토큰의 빈도가 낮은 쌍에 특권을 부여합니다. 전체 코퍼스에서 계산된 손실(loss)을 최소화하는 vocabulary의 모든 토큰을 제거합니다. 학습 결과(Learns) 토큰 병합 규칙 및 vocabulary Vocabulary 각 토큰에 대한 점수가 있는 vocabulary 인코딩(Encoding) 단어를 문자들로 분할하고 학습 과정에서 습득한 병합 규칙 적용 Vocabulary의 시작 부분에서 시작하여 가장 긴 하위 단어(longest subword)를 찾은 다음 나머지 단어에 대해 동일한 작업을 수행 학습 과정에서 획득한 점수를 사용하여 가장 가능성 있는 토큰 분할을 찾음 이제 BPE에 대해서 자세히 알아봅시다! 5. Byte-Pair Encoding (BPE) 토큰화 BPE(Byte-Pair Encoding)는 초기에 텍스트를 압축하는 알고리즘으로 개발된 후, GPT 모델을 사전 학습할 때 토큰화를 위해 OpenAI에서 사용되었습니다. GPT, GPT-2, RoBERTa, BART 및 DeBERTa를 포함한 많은 트랜스포머 모델에서 사용됩니다. 이 섹션에서는 전체 구현 과정을 보여주는 것까지를 포함하여 BPE를 심층적으로 다룹니다. 토큰화 알고리즘에 대한 일반적인 개요만을 원하는 경우 이 장을 건너뛰어도 됩니다. 학습 알고리즘 BPE 학습은 정규화 및 사전 토큰화 단계가 완료된 후, 말뭉치에 사용된 고유한 단어 집합을 계산하는 것으로 시작됩니다. 그런 다음 이러한 단어들을 구성하는 데 사용된 모든 기호(글자)를 바탕으로 vocabulary를 구축합니다. 아주 간단한 예로서 말뭉치가 다음 다섯 단어를 사용한다고 가정해 봅시다: "hug", "pug", "pun", "bun", "hugs" 기본 vocabulary는 ["b", "g", "h", "n", "p", "s", "u"]가 됩니다. 실제로는 기본 vocabulary에는 최소한 모든 ASCII 문자와 일부 유니코드 문자가 포함될 것입니다. 토큰화하는 대상이 학습 말뭉치에 없는 문자를 사용하는 경우 해당 문자는 "알 수 없는 토큰(unknown token)"으로 변환됩니다. 많은 NLP 모델이 이모티콘이 포함된 콘텐츠를 분석하는데 심각한 어려움을 겪는 이유입니다. GPT-2 및 RoBERTa 토크 나이저는 이 문제를 매우 영리하게 처리합니다. 단어를 유니코드 문자가 아닌 바이트 단위로 구성된 것으로 간주합니다. 이 방법으로 기본 vocabulary는 작은 크기(256)를 갖지만 생각할 수 있는 모든 문자들이 여전히 포함될 수 있으며 알 수 없는 토큰으로 변환되지 않습니다. 이 트릭(trick)을 byte-level BPE라고 합니다. 이 기본 vocabulary를 구한 후, 기존 vocabulary의 두 요소를 새로운 것으로 병합하는 규칙인 merges를 학습함으로써 원하는 vocabulary 크기에 도달할 때까지 새 토큰을 추가합니다. 따라서 처음에는 이러한 병합으로 두 개의 문자가 있는 토큰이 생성되고 학습이 진행됨에 따라 더 긴 하위 단어(subwords)가 생성됩니다. 토크 나이저 학습 과정에서 어떤 단계에서든 BPE 알고리즘은 가장 빈번하게 출현하는 토큰 쌍을 검색합니다(여기서 "쌍"은 한 단어에서 두 개의 연속 토큰을 의미하고 토큰은 처음에는 단일 문자입니다). 검색된 고빈도 토큰 쌍이 병합되며 이러한 과정이 계속 반복됩니다. 이전 예제로 돌아가서 각 단어들의 출현 빈도가 다음과 같다고 가정해 봅시다: ("hug", 10), ("pug", 5), ("pun", 12), ("bun", 4), ("hugs", 5) 말뭉치 내에 "hug"가 10번, "pug"가 5번, "pun"이 12번, "bun"이 4번, "hugs"가 5번 출현한다는 의미입니다. 각 단어를 토큰의 목록으로 볼 수 있도록 각 단어를 문자(초기 vocabulary를 구성하는 문자)로 분할하여 학습을 시작합니다: ("h" "u" "g", 10), ("p" "u" "g", 5), ("p" "u" "n", 12), ("b" "u" "n", 4), ("h" "u" "g" "s", 5) 그런 다음 각 문자 쌍들을 살펴봅시다. ("h", "u")은 "hug" 및 "hugs"라는 단어에 존재하므로 말뭉치에서 총 15번 출현했습니다. 가장 빈번한 쌍은 아닙니다. 가장 빈번하게 출현하는 쌍은 "hug", "pug" 및 "hugs"에 있는 ("u", "g")이며 총 20번 출현했습니다. 따라서 토크 나이저가 학습한 첫 번째 병합 규칙은 ("u", "g") -> "ug"이며, 이는 "ug"가 vocabulary에 추가되고 코퍼스 내의 모든 단어에서 "u"와 "g"가 병합되어야 함을 의미합니다. 이 단계가 끝나면 vocabulary와 말뭉치가 다음과 같이 변경됩니다: Vocabulary: ["b", "g", "h", "n", "p", "s", "u", "ug"] Corpus: ("h" "ug", 10), ("p" "ug", 5), ("p" "u" "n", 12), ("b" "u" "n", 4), ("h" "ug" "s", 5) 이제 2개의 문자보다 더 긴 토큰이 생성되는 몇 가지 쌍이 코퍼스 내에 존재합니다. 예를 들어, ("h", "ug")(말뭉치에 15번 출현)가 그것입니다. 이 단계에서 가장 빈번하게 출현된 쌍은 ("u", "n")로서 말뭉치에 16번 나타나므로 학습된 두 번째 병합 규칙은 ("u", "n") -> "un"입니다. 이를 vocabulary에 추가하고 기존의 모든 항목을 병합하면 다음과 같이 됩니다: Vocabulary: ["b", "g", "h", "n", "p", "s", "u", "ug", "un"] Corpus: ("h" "ug", 10), ("p" "ug", 5), ("p" "un", 12), ("b" "un", 4), ("h" "ug" "s", 5) 이제 가장 빈번한 쌍은 ("h", "ug")이므로 병합 규칙("h", "ug") -> "hug"을 학습합니다. 처음으로 3글자로 구성된 토큰이 만들어집니다. 병합 후 코퍼스는 다음과 같습니다. Vocabulary: ["b", "g", "h", "n", "p", "s", "u", "ug", "un", "hug"] Corpus: ("hug", 10), ("p" "ug", 5), ("p" "un", 12), ("b" "un", 4), ("hug" "s", 5) 원하는 vocabulary 크기에 도달할 때까지 이 작업을 계속합니다. ✏ Now your turn! 다음 병합 규칙은 무엇일까요? 토큰화 알고리즘 토큰화는 다음 단계를 적용하여 새로운 입력을 토큰화한다는 점에서 앞에서 살펴본 학습 프로세스와 밀접하게 연관되어 있습니다: 정규화 (Normalization) 사전 토큰화 (Pre-tokenization) 단어를 개별 문자들로 분할 해당 분할에 순서대로 학습된 병합 규칙 적용 위에서 학습된 3가지 병합 규칙을 적용하여 예를 들어 보겠습니다: ("u", "g") -> "ug" ("u", "n") -> "un" ("h", "ug") -> "hug" "bug"라는 단어는 ["b", "ug"]로 토큰화됩니다. 그러나 "mug"는 기본 vocabulary에 문자 "m"이 없었기 때문에 ["[UNK]", "ug"]로 토큰화됩니다. 마찬가지로 "thug"라는 단어는 ["[UNK]", "hug"]로 토큰화됩니다. 문자 "t"는 기본 vocabulary에 없으며 병합 규칙을 적용하면 먼저 "u"와 "g"가 병합된 다음 "hu"와 "g"가 병합됩니다. ✏ Now your turn! "unhug"라는 단어가 어떻게 토큰화될까요? BPE 구현 이제 BPE 알고리즘의 구현 방법을 살펴보겠습니다. 아래에서 설명하는 코드는 대규모 말뭉치에서 실제로 사용할 수 있는 최적화된 버전이 아닙니다. 알고리즘을 쉽게 이해할 수 있도록 구성된 코드입니다. 먼저 말뭉치가 필요하므로 몇 문장으로 간단한 말뭉치를 만들어 보겠습니다: corpus = [ "This is the Hugging Face course.", "This chapter is about tokenization.", "This section shows several tokenizer algorithms.", "Hopefully, you will be able to understand how they are trained and generate tokens.", ] 다음으로, 위 말뭉치를 단어 단위로 사전 토큰 화(pre-tokenize) 해야 합니다. GPT-2에서 사용된 BPE 토크 나이저를 구현하고 있으므로 사전 토큰화(pre-tokenization)에 gpt2 토크 나이저를 사용합니다: from transformers import AutoTokenizer tokenizer = AutoTokenizer.from_pretrained("gpt2") 그런 다음 사전 토큰화를 수행하면서 말뭉치에 있는 각 단어의 빈도를 함께 계산합니다: from collections import defaultdict word_freqs = defaultdict(int) for text in corpus: words_with_offsets = tokenizer.backend_tokenizer.pre_tokenizer.pre_tokenize_str(text) new_words = [word for word, offset in words_with_offsets] for word in new_words: word_freqs[word] += 1 print(word_freqs) 다음 단계는 말뭉치에 사용된 모든 문자로 구성된 기본 vocabulary를 구하는 것입니다: alphabet = [] for word in word_freqs.keys(): for letter in word: if letter not in alphabet: alphabet.append(letter) alphabet.sort() print(alphabet) 추가적으로 해당 vocabulary의 시작 부분에 모델이 사용하는 특수 토큰을 추가합니다. GPT-2의 경우 유일한 특수 토큰은 "<|endoftext|>"입니다: vocab = ["<|endoftext|>"] + alphabet.copy() 이제 학습을 시작할 수 있도록 각 단어를 개별 문자로 분할해야 합니다: splits = {word: [c for c in word] for word in word_freqs.keys()} 이제 학습할 준비가 되었으므로 각 쌍의 빈도를 계산하는 함수를 작성해 보겠습니다. 학습의 각 단계에서 이것을 사용해야 합니다: def compute_pair_freqs(splits): pair_freqs = defaultdict(int) for word, freq in word_freqs.items(): split = splits[word] if len(split) == 1: continue for i in range(len(split) - 1): pair = (split[i], split[i+1]) pair_freqs[pair] += freq return pair_freqs 초기 분할 후 이 딕셔너리(pair-freqs)의 일부를 살펴보겠습니다: pair_freqs = compute_pair_freqs(splits) for i, key in enumerate(pair_freqs.keys()): print(f"{key}: {pair_freqs[key]}") if i > 5: break 이제 간단한 루프를 이용해서 가장 빈번하게 출현하는 쌍을 찾아보겠습니다: best_pair = "" max_freq = None for pair, freq in pair_freqs.items(): if max_freq is None or max_freq < freq: best_pair = pair max_freq = freq print(best_pair, max_freq) 따라서 학습할 첫 번째 병합은 ('Ġ', 't') -> 'Ġt'이고 vocabulary에 'Ġt'를 추가합니다: merges = {("Ġ", "t"): "Ġt"} vocab.append("Ġt") 계속하려면 splits 딕셔너리에 해당 병합을 적용해야 합니다. 이를 위해 다른 함수를 작성해 보겠습니다: def merge_pair(a, b, splits): for word in word_freqs: split = splits[word] if len(split) == 1: continue i = 0 while i < len(split) - 1: if split[i] == a and split[i + 1] == b: split = split[:i] + [a + b] + split[i + 2 :] else: i += 1 splits[word] = split return splits 이제 첫 번째 병합의 결과를 볼 수 있습니다: splits = merge_pair("Ġ", "t", splits) print(splits["Ġtrained"]) 이제 원하는 모든 병합을 학습할 때까지 반복하는 모듈을 구성할 수 있습니다. Vocabulary의 크기를 50으로 지정해 봅시다: vocab_size = 50 while len(vocab) < vocab_size: pair_freqs = compute_pair_freqs(splits) best_pair = "" max_freq = None for pair, freq in pair_freqs.items(): if max_freq is None or max_freq < freq: best_pair = pair max_freq = freq splits = merge_pair(*best_pair, splits) merges[best_pair] = best_pair[0] + best_pair[1] vocab.append(best_pair[0] + best_pair[1]) 결과적으로 19가지 병합 규칙을 학습했습니다(초기 vocabulary의 크기는 알파벳 31 - 30자, 특수 토큰 포함): print(merges) 그리고 vocabulary는 특수 토큰, 초기 알파벳 및 병합의 모든 결과로 구성됩니다: print(vocab) 동일한 말뭉치에서 train_new_from_iterator()를 사용하면 똑같은 vocabulary가 도출되지 않습니다. 이는 가장 빈번하게 출현한 쌍을 선택할 때 가장 먼저 마주치는 쌍을 선택하는 반면에, Tokenizers 라이브러리는 내부 IDs를 기반으로 첫 번째 쌍을 선택하기 때문입니다. 새로운 텍스트를 토큰화하기 위해서는 우선 사전 토큰 화(pre-tokenize) 하고 분할(split) 한 다음 학습한 모든 병합 규칙(merge rules)을 적용하면 됩니다: def tokenize(text): pre_tokenize_result = tokenizer._tokenizer.pre_tokenizer.pre_tokenize_str(text) pre_tokenized_text = [word for word, offset in pre_tokenize_result] splits = [[l for l in word] for word in pre_tokenized_text] for pair, merge in merges.items(): for idx, split in enumerate(splits): i = 0 while i < len(split) - 1: if split[i] == pair[0] and split[i + 1] == pair[1]: split = split[:i] + [merge] + split[i + 2 :] else: i += 1 splits[idx] = split return sum(splits, []) 알파벳 문자로 구성된 모든 텍스트를 토큰화할 수 있습니다: tokenize("This is not a token.") ⚠ 예외 처리를 하지 않았기 때문에 알 수 없는 문자(unknown character)가 있으면 구현에서 오류가 발생합니다. GPT-2에는 실제로 알 수 없는 토큰이 없지만(바이트 수준 BPE를 사용할 때 알 수 없는 문자를 얻는 것은 불가능합니다), 여기서는 초기 vocabulary에 가능한 모든 바이트를 포함하지 않았기 때문에 오류가 발생할 수 있습니다. 이 부분은 이 섹션의 범위를 벗어나므로 세부 사항을 생략했습니다. BPE 알고리즘에 대한 내용이 끝났습니다! 다음으로 WordPiece를 살펴보겠습니다. 6. WordPiece 토큰화 WordPiece는 Google이 BERT를 사전 학습하기 위해 개발한 토큰화 알고리즘입니다. 그 이후로 DitilBERT, MobileBERT, Funnel Transformers 및 MPNET과 같은 BERT 기반의 상당히 많은 Transformer 모델에서 재사용되었습니다. 학습 측면에서 BPE와 매우 유사하지만 실제 토큰화는 다르게 수행됩니다. 이 섹션에서는 WordPiece를 심층적으로 다루며 전체 구현 과정을 보여줍니다. 토큰화 알고리즘에 대한 일반적인 개요를 원하는 경우 생략해도 좋습니다. 학습 알고리즘 ⚠ Google은 WordPiece의 학습 알고리즘 구현을 오픈 소스로 공개하지 않았으므로 이번 섹션에서는 발표된 논문 내용을 기반으로 구현 과정을 설명합니다. 거의 100% 정확할 것입니다. BPE와 마찬가지로 WordPiece는 모델에서 사용하는 특수 토큰과 초기 알파벳을 포함한 작은 vocabulary에서 시작합니다. 접두사(예: BERT의 ##)를 추가하여 하위 단어(subwords)를 식별하기 때문에 각 단어는 처음에 해당 접두사를 단어 내부의 모든 문자에 추가하여 분할됩니다. 예를 들어 "word"는 다음과 같이 분할됩니다. w ##o ##r ##d 따라서 초기 알파벳에는 단어의 시작 부분에 있는 모든 문자들(예: 'w')과 WordPiece 접두사가 선행하는 단어 내부에 있는 문자(예: 'o', 'r', 'd')가 포함됩니다. 그런 다음 BPE와 마찬가지로 WordPiece도 병합 규칙을 학습합니다. 주요 차이점은 병합할 쌍이 선택되는 방식입니다. 가장 빈번하게 출현하는 쌍을 선택하는 대신 WordPiece는 다음 공식을 사용하여 각 쌍에 대한 점수를 계산합니다: c r = r q f a r r q f i s e e e t f e o s c n e e e t 쌍의 빈도를 각 부분의 빈도의 곱으로 나눔으로써, 알고리즘은 각 개별 부분들의 빈도가 낮은 쌍의 병합에 높은 우선순위를 부여합니다. 예를 들어, vocabulary 내에서의 출현 빈도가 높은 ("un", "##able") 쌍을 굳이 병합할 필요는 없는데, 그 이유는 "un"과 "##able" 각각이 다른 단어 내에서 매우 빈번하게 출현하여 높은 빈도를 나타내기 때문입니다. 반면에, "hu"와 "##gging"은 각각이 자주 사용되지 않기 때문에 ("hu", "##gging")과 같은 쌍은 아마도 더 빨리 병합될 것입니다("hugging"이라는 단어가 어휘에 자주 등장한다고 가정). 앞서 BPE 학습 예시에서 사용한 것과 동일한 vocabulary를 사용해서 설명하겠습니다: ("hug", 10), ("pug", 5), ("pun", 12), ("bun", 4), ("hugs", 5) 분할 결과는 다음과 같습니다: ("h" "##u" "##g", 10), ("p" "##u" "##g", 5), ("p" "##u" "##n", 12), ("b" "##u" "##n", 4), ("h" "##u" "##g" "##s", 5) 따라서 초기 vocabulary는 ["b", "h", "p", "##g", "##n", "##s", "##u"]가 됩니다(특수 토큰은 일단 잊어버립시다). 가장 빈번한 쌍은 ("##u", "##g")(현재 20회)이지만 "##u"의 개별 빈도가 매우 높아 점수가 가장 높지는 않습니다(1/36). "##u"가 포함된 모든 쌍은 실제로 동일한 점수(1/36)를 가지므로 가장 좋은 점수는 ("##g", "##s")이 가지고 있습니다(1/20). 이는 "##u"가 없는 유일한 쌍입니다. 그리고 학습된 첫 번째 병합은 ("##g", "##s") -> ("##gs")입니다. 병합할 때 두 토큰 사이의 ##을 제거하므로 vocabulary에 "##gs"를 추가하고 말뭉치의 모든 단어에 해당 병합을 적용합니다: Vocabulary: ["b", "h", "p", "##g", "##n", "##s", "##u", "##gs"] Corpus: ("h" "##u" "##g", 10), ("p" "##u" "##g", 5), ("p" "##u" "##n", 12), ("b" "##u" "##n", 4), ("h" "##u" "##gs", 5) 이 시점에서 "##u"는 가능한 모든 쌍에 있으므로 모두 동일한 점수를 가집니다. 이 경우 첫 번째 쌍이 병합되므로 ("h", "##u") -> "hu"가 학습됩니다. 그 결과는 다음과 같습니다: Vocabulary: ["b", "h", "p", "##g", "##n", "##s", "##u", "##gs", "hu"] Corpus: ("hu" "##g", 10), ("p" "##u" "##g", 5), ("p" "##u" "##n", 12), ("b" "##u" "##n", 4), ("hu" "##gs", 5) 이제 최고 점수는 ("hu", "##g") 및 ("hu", "##gs")가 동일하게 계산되므로(다른 모든 쌍의 경우 1/21이고 이 두 쌍은 1/15) 가장 큰 점수를 가진 첫 번째 쌍이 병합됩니다. Vocabulary: ["b", "h", "p", "##g", "##n", "##s", "##u", "##gs", "hu", "hug"] Corpus: ("hug", 10), ("p" "##u" "##g", 5), ("p" "##u" "##n", 12), ("b" "##u" "##n", 4), ("hu" "##gs", 5) 원하는 어휘 크기에 도달할 때까지 이 단계가 계속 반복됩니다. ✏ Now your turn! 다음 병합 규칙은 무엇일까요? 토큰화 알고리즘 토큰화는 WordPiece가 학습된 병합 규칙은 제외하고 최종 vocabulary만 저장한다는 점에서 BPE와는 다릅니다. 토큰화할 단어에서 시작하여 WordPiece는 vocabulary에 있는 가장 긴 하위 단어를 찾은 다음 분할합니다. 예를 들어, 위의 예에서 학습한 vocabulary를 사용하는 경우, 단어 "hugs"의 경우 처음부터 시작하는 가장 긴 하위 단어는 vocabulary 내부에 있는 "hug"이므로 거기에서 분할하여 ["hug", "##s"]로 분할됩니다. 그런 다음 "##s"가 vocabulary에 존재하고 이를 계속 사용할 수 있으므로 "hugs"의 토큰화 결과는 ["hug", "##s"]입니다. BPE를 사용하면 학습된 병합(merges)을 순서대로 적용하고 이를 ["hu", "##gs"]로 토큰화하므로 인코딩이 다르게 됩니다. 또 다른 예로 "bugs"라는 단어가 어떻게 토큰화되는지 봅시다. "b"는 vocabulary에 존재하는 단어의 시작 부분에서 시작하는 가장 긴 하위 단어이므로 거기서 분할하여 ["b", "##ugs"]라는 중간 결과가 도출됩니다. 다음으로 "##u"는 vocabulary에 있는 "##ugs"의 시작 부분에서 시작하는 가장 긴 하위 단어이므로 거기에서 분할하여 ["b", "##u, "##gs"]를 얻습니다. 마지막으로 "##gs"가 vocabulary에 있으므로 ["b", "##u, "##gs"]이 "bugs"의 토큰화 결과입니다. 토큰 화가 vocabulary에서 하위 단어(subword)를 더 이상 찾을 수 없는 단계에 도달하면 전체 단어를 "unknown"으로 토큰화합니다. 예를 들어 "mug"는 "bum"과 마찬가지로 ["[UNK]"]로 토큰화됩니다("b"와 "##u"로 시작할 수 있더라도 "##m"이 vocabulary에 존재하지 않으므로 결과 토큰화는 ["b", "##u", "[UNK]"]가 아니라 ["[UNK]"]입니다). 이것은 vocabulary에 없는 개별 문자만 "unknwon"으로 분류하는 BPE와의 또 다른 차이점입니다. ✏ Now your turn! "pugs"라는 단어는 어떻게 토큰화될까요? WordPiece 구현 이제 WordPiece 알고리즘의 구현을 살펴보겠습니다. BPE와 마찬가지로 아래 코드는 이해를 돕기 위해서 구현한 것이며 대규모 말뭉치에서는 사용할 수 없습니다. 우리는 BPE 예시에서와 동일한 말뭉치를 사용할 것입니다: corpus = [ "This is the Hugging Face course.", "This chapter is about tokenization.", "This section shows several tokenizer algorithms.", "Hopefully, you will be able to understand how they are trained and generate tokens.", ] 먼저 말뭉치를 단어로 사전 토큰 화(pre-tokenization) 해야 합니다. BERT와 같은 WordPiece 토크 나이저를 구현하고 있으므로 사전 토큰화에 bert-base-cased 토크 나이저를 사용합니다: from transformers import AutoTokenizer tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") 그런 다음 사전 토큰화 수행 과정에서 말뭉치에 있는 각 단어의 빈도를 계산합니다: from collections import defaultdict word_freqs = defaultdict(int) for text in corpus: words_with_offsets = tokenizer.backend_tokenizer.pre_tokenizer.pre_tokenize_str(text) new_words = [word for word, offset in words_with_offsets] for word in new_words: word_freqs[word] += 1 word_freqs 이전에 보았듯이 알파벳은 단어의 모든 첫 글자와 ## 접두사가 붙은 단어에 나타나는 다른 모든 글자로 구성된 고유한 집합입니다: alphabet = [] for word in word_freqs.keys(): if word[0] not in alphabet: alphabet.append(word[0]) for letter in word[1:]: if f"##{letter}" not in alphabet: alphabet.append(f"##{letter}") alphabet.sort() alphabet print(alphabet) 또한 해당 vocabulary의 시작 부분에 모델이 사용하는 특수 토큰을 추가합니다. BERT의 경우 ["[PAD]", "[UNK]", "[CLS]", "[SEP]", "[MASK]"]입니다: vocab = ["[PAD]", "[UNK]", "[CLS]", "[SEP]", "[MASK]"] + alphabet.copy() 다음으로 vocabulary에 존재하는 접두사가 ##이 아닌 모든 문자를 사용하여 각 단어를 분할해야 합니다: splits = { word: [c if i == 0 else f"##{c}" for i, c in enumerate(word)] for word in word_freqs.keys() } 이제 학습할 준비가 되었으므로 각 쌍의 점수를 계산하는 함수를 작성해 보겠습니다. 학습의 각 단계에서 이 함수를 사용해야 합니다: def compute_pair_scores(splits): letter_freqs = defaultdict(int) pair_freqs = defaultdict(int) for word, freq in word_freqs.items(): split = splits[word] if len(split) == 1: letter_freqs[split[0]] += freq continue for i in range(len(split) - 1): pair = (split[i], split[i + 1]) letter_freqs[split[i]] += freq pair_freqs[pair] += freq letter_freqs[split[-1]] += freq scores = { pair: freq / (letter_freqs[pair[0]] * letter_freqs[pair[1]]) for pair, freq in pair_freqs.items() } return scores 초기 분할 후 pair_scores의 일부를 살펴보겠습니다: pair_scores = compute_pair_scores(splits) for i, key in enumerate(pair_scores.keys()): print(f"{key}: {pair_scores[key]}") if i >= 5: break 이제 최고의 점수를 가진 쌍을 찾는 간단한 루프를 구현합니다: best_pair = "" max_score = None for pair, score in pair_scores.items(): if max_score is None or max_score < score: best_pair = pair max_score = score print(best_pair, max_score) 따라서 학습할 첫 번째 병합은 ('a', '##b') -> 'ab'이고 vocabulary에 'ab'를 추가합니다: vocab.append("ab") 계속하려면 splits 딕셔너리에 해당 병합을 적용해야 합니다. 이를 위해 다른 함수를 작성해 보겠습니다: def merge_pair(a, b, splits): for word in word_freqs: split = splits[word] if len(split) == 1: continue i = 0 while i < len(split) - 1: if split[i] == a and split[i + 1] == b: merge = a + b[2:] if b.startswith("##") else a + b split = split[:i] + [merge] + split[i + 2 :] else: i += 1 splits[word] = split return splits 이제 첫 번째 병합의 결과를 볼 수 있습니다: splits = merge_pair("a", "##b", splits) splits["about"] 이제 원하는 모든 병합을 모두 학습할 때까지 반복하는데 필요한 모든 것을 구현했습니다. 목표 vocabulary 크기를 70으로 합시다: vocab_size = 70 while len(vocab) < vocab_size: scores = compute_pair_scores(splits) best_pair, max_score = "", None for pair, score in scores.items(): if max_score is None or max_score < score: best_pair = pair max_score = score splits = merge_pair(*best_pair, splits) new_token = ( best_pair[0] + best_pair[1][2:] if best_pair[1].startswith("##") else best_pair[0] + best_pair[1] ) vocab.append(new_token) 생성된 vocabulary를 볼 수 있습니다: print(vocab) 보시다시피 BPE에 비해 이 토크 나이저는 단어의 일부를 토큰으로 더 빨리 학습합니다. 동일한 말뭉치에서 train_new_from_iterator()를 사용하면 똑같은 vocabulary가 나오지 않습니다. Tokenizers 라이브러리는 학습을 위해 WordPiece를 구현하지 않고(내부에 대해 완전히 확신하지 못하기 때문에) 대신 BPE를 사용하기 때문입니다. 새로운 텍스트를 토큰화하기 위해 사전 토큰화하고(pre-tokenization), 분할한 다음(split), 각 단어에 토큰화 알고리즘을 적용합니다. 즉, 첫 번째 단어의 시작 부분에서 시작하는 가장 큰 하위 단어를 찾아 분할한 다음, 두 번째 부분에서 프로세스를 반복하고 나머지 단어와 텍스트의 다음 단어에 대해 계속 반복합니다: def encode_word(word): tokens = [] while len(word) > 0: i = len(word) while i > 0 and word[:i] not in vocab: i -= 1 if i == 0: return ["[UNK]"] tokens.append(word[:i]) word = word[i:] if len(word) > 0: word = f"##{word}" return tokens Vocabulary에 존재하는 단어와 그렇지 않은 단어에 대해 테스트해 보겠습니다: print(encode_word("Hugging")) print(encode_word("HOgging")) 이제 텍스트를 토큰화하는 함수를 작성해 보겠습니다: def tokenize(text): pre_tokenize_result = tokenizer._tokenizer.pre_tokenizer.pre_tokenize_str(text) pre_tokenized_text = [word for word, offset in pre_tokenize_result] encoded_words = [encode_word(word) for word in pre_tokenized_text] return sum(encoded_words, []) 이제 어떤 텍스트를 가지고도 테스트해 볼 수 있습니다: tokenize("This is the Hugging Face course!") WordPiece 알고리즘에 대한 설명은 여기까지입니다! 이제 Unigram에 대해 알아보겠습니다. 7. Unigram 토큰화 Unigram 알고리즘은 AlBERT, T5, mBART, Big Bird 및 XLNet과 같은 모델에서 사용되는 토큰화 알고리즘인 SentencePiece에서 자주 사용됩니다. 이 섹션에서는 전체 구현을 보여주는 것을 포함하여 Unigram을 깊이 있게 다룹니다. 토큰화 알고리즘에 대한 일반적인 개요를 원하는 경우 생략해도 좋습니다. 학습 알고리즘 BPE 및 WordPiece와 비교하여 Unigram은 다른 방향으로 작동합니다. 즉, 크기가 큰 vocabulary에서 시작하여 원하는 vocabulary 크기에 도달할 때까지 토큰을 제거합니다. 기본 vocabulary를 구축하는 데 사용할 수 있는 몇 가지 옵션이 있습니다. 예를 들어, 사전 토큰화된 단어에서 가장 일반적인 부분 문자열을 취하거나 큰 규모의 vocabulary를 가진 초기 말뭉치에 BPE를 적용할 수 있습니다. 학습의 각 단계에서 Unigram 알고리즘은 현재 vocabulary가 주어졌을 때의 말뭉치에 대한 손실(loss)을 계산합니다. 그런 다음, vocabulary의 각 기호(symbol)에 대해, 해당 기호가 제거되면 전체 손실이 얼마나 증가할지 계산하고 가장 적게 증가하는 기호를 찾습니다. 이렇게 찾은 기호들(symbols)은 말뭉치에 대한 전체 손실에 더 적은 영향을 미치므로 어떤 의미에서는 "덜 필요(less needed)" 하고 제거 대상으로 가장 적합한 후보입니다. 이것은 비용이 많이 드는 작업이므로 가장 낮은 손실을 초래하는 기호 하나만 제거하지 않고, 이러한 기호들의 %(는 제어할 수 있는 하이퍼 파라미터이고 일반적으로 10 또는 20을 지정)를 제거합니다. 이 과정은 vocabulary가 원하는 크기에 도달할 때까지 반복됩니다. 모든 단어를 토큰화할 수 있도록 기본 문자들을 제거하지 않는다는 점도 중요합니다. 아직도 설명이 약간 모호한 부분이 있지요. 이 알고리즘의 핵심은 말뭉치에 대한 손실을 계산하고 vocabulary에서 일부 토큰을 제거할 때 손실이 어떻게 변하는지 확인하는 것이지만 아직 어떻게 수행하는지에 대한 내용을 설명하지 않았습니다. 이 부분은 Unigram 모델의 토큰화 알고리즘에 기반하므로 다음에 자세히 살펴보겠습니다. 역시 이전 예제의 말뭉치를 재사용합니다: ("hug", 10), ("pug", 5), ("pun", 12), ("bun", 4), ("hugs", 5) 초기 vocabulary는 위 말뭉치에 존재하는 모든 단어들의 모든 하위 문자열(substrings)로 구성됩니다. ["h", "u", "g", "hu", "ug", "p", "pu", "n", "un", "b", "bu", "s", "hug", "gs", "ugs"] 토큰화 알고리즘 Unigram 모델은 개별 토큰들의 출현 분포가 서로 독립적(i.i.d)이라는 가정을 하는 언어 모델 유형입니다. 토큰 X의 확률이 문맥에 상관없이 동일하다는 점에서 가장 단순한 언어 모델입니다. 따라서 Unigram 언어 모델을 사용하여 텍스트를 생성하는 경우 항상 가장 일반적이고 흔한(common) 토큰을 도출합니다. 특정 토큰의 확률은 말뭉치 내에서의 해당 토큰 출현 빈도를 vocabulary에 존재하는 모든 토큰들의 출현 빈도의 합으로 나눈 것입니다(확률의 합이 1이 되도록 하기 위해). 예를 들어 "ug"는 "hug", "pug" 및 "hugs"에 있으므로 말뭉치에서의 빈도는 20입니다. 다음은 vocabulary에서의 모든 하위 단어(subwords)의 빈도입니다: ("h", 15) ("u", 36) ("g", 20) ("hu", 15) ("ug", 20) ("p", 17) ("pu", 17) ("n", 16) ("un", 16) ("b", 4) ("bu", 4) ("s", 5) ("hug", 15) ("gs", 5) ("ugs", 5) 따라서 모든 빈도의 합은 210이고 하위 단어(subword) "ug"의 확률은 20/210입니다. ✏ Now your turn! 위의 빈도를 계산하는 코드를 작성하고 표시된 결과와 총합이 올바른지 다시 확인해 보세요. 이제 주어진 단어를 토큰화하기 위해, 가능한 모든 토큰 분할을 살펴보고 Unigram 모델에 따라 각각의 확률을 계산합니다. 모든 토큰의 출현 빈도가 독립적인 것으로 간주되기 때문에 이 확률은 각 토큰의 확률의 곱일뿐입니다. 예를 들어, "pug"의 토큰화 결과인 ["p", "u", "g"]의 확률은 다음과 같이 계산됩니다: ( [ p, u, g ] ) P ( p) P ( u) P ( g) 5 210 36 210 2 210 이에 비해 토큰화 결과인 ["pu", "g"]의 확률은 다음과 같습니다: ( [ p " " " ] ) P ( p " ) P ( g) 5 210 20 210 0.0022676 따라서, ["pu", "g"]이 훨씬 더 자주 출현한다고 볼 수 있겠지요. 일반적으로 가장 적은 수의 하위 토큰들로 구성된 토큰화 결과는 비교적 높은 확률(각 토큰에 대해 반복되는 210으로 나누기 때문에)을 가지며, 이는 우리가 직관적으로 원하는 결과입니다. Unigram 모델을 사용한 단어의 토큰화는 가장 높은 확률을 나타내는 분할 형태로 토큰화됩니다. "pug"의 예에서 가능한 각 분할에 대해 얻을 수 있는 확률은 다음과 같습니다: ["p", "u", "g"] : 0.000389 ["p", "ug"] : 0.0022676 ["pu", "g"] : 0.0022676 따라서 "pug"는 위 분할 방법 중에서 ["p", "ug"] 또는 ["pu", "g"]로 토큰화될 수 있습니다. 그러나 큰 규모의 말뭉치에서는 분할 방법에 대한 확률 값이 같은 경우가 매우 드뭅니다. 위의 경우에서는 가능한 모든 분할을 찾고 확률을 계산하는 것이 쉬웠지만, 일반적으로는 더 어려울 수 있습니다. 이를 위해 사용되는 고전적인 알고리즘인 Viterbi 알고리즘 이 있습니다. 본질적으로, 주어진 단어에 대한 가능한 모든 분할들을 나타낼 수 있는 그래프를 구성할 수 있습니다. 그리고 만일 주어진 단어 내의 문자 a에서 b까지의 하위 단어(subword)가 vocabulary에 존재한다면, 우리는 이 그래프 내에서 a에서 출발하여 b까지 가는 그래프 내의 가지(branch)가 있다고 말할 수 있습니다. 그리고 이 하위 단어의 확률을 해당 가지(branch)에 지정할 수 있습니다. 그래프에서 최고 점수를 얻을 경로를 찾기 위해 Viterbi 알고리즘은 단어 내의 각 위치(문자)에 대해 해당 위치에서 끝나는 경로의 최고 점수를 나타내는 분할(segmentation)을 결정합니다. 단어의 처음 위치부터 끝까지 이동하면서, 현재 위치에서 끝나는 모든 하위 단어를 검사한 다음 이 하위 단어가 시작하는 위치에서 최고의 토큰화 점수를 사용하여 최상의 점수를 찾을 수 있습니다. 그런 다음 끝에 도달하기 위해 선택한 경로를 펼치기만 하면 됩니다. 앞에서 구성한 vocabulary와 "unhug"라는 단어를 사용한 예를 살펴보겠습니다. 해당 단어의 각 위치에 대해 최고 점수로 끝나는 하위 단어는 다음과 같습니다: Character 0 (u): "u" (score 0.171429) Character 1 (n): "un" (score 0.076191) Character 2 (h): "un" "h" (score 0.005442) Character 3 (u): "un" "hu" (score 0.005442) Character 4 (g): "un" "hug" (score 0.005442) 위에서 처음부터 마지막 글자('g')까지 진행한 결과, ["un", "hug"]가 가장 높은 점수인 0.005442를 나타냈습니다. 따라서 "unhug"는 ["un", "hug"]로 토큰화됩니다. ✏ Now your turn! "huggun"이라는 단어를 토큰화하고 해당 점수를 계산해 보세요. 다시 학습 알고리즘 이제 토큰 화가 어떻게 작동하는지 보았으므로 학습 과정에서 사용된 손실(loss)에 대해 조금 더 자세히 알아보겠습니다. 각각의 주어진 단계에서 이 손실은 말뭉치 내의 모든 단어를 토큰화하여 계산됩니다. 계산 과정에서 앞에서 설명한 것처럼 현재 vocabulary와 말뭉치에 있는 각 토큰의 빈도에 의해 결정된 유니그램 모델을 사용합니다. 말뭉치의 각 단어별로 점수를 계산하며 손실은 해당 점수의 음의 로그 우도(negative log likelihood)입니다. 즉, 말뭉치에 있는 모든 단어의 l g ( ( o d ) ) 합계입니다. 위에서 설명한 말뭉치를 가지고 설명합니다: ("hug", 10), ("pug", 5), ("pun", 12), ("bun", 4), ("hugs", 5) 각 단어의 토큰화 결과 및 점수는 다음과 같습니다: "hug": ["hug"] (score 0.071428) "pug": ["pu", "g"] (score 0.007710) "pun": ["pu", "n"] (score 0.006168) "bun": ["bu", "n"] (score 0.001451) "hugs": ["hug", "s"] (score 0.001701) 따라서 손실(loss)은 다음과 같습니다: 10 * (-log(0.071428)) + 5 * (-log(0.007710)) + 12 * (-log(0.006168)) + 4 * (-log(0.001451)) + 5 * (-log(0.001701)) = 169.8 이제 각 토큰을 제거하는 것이 손실 값에 어떤 영향을 미치는지 계산해야 합니다. 이 작업은 수작업으로 하기에는 시간이 걸리므로 여기에서는 두 개의 토큰("pu", "hug")에 대해 이를 수행하고 나머지 프로세스는 아래에서 해당 작업에 대한 실제 구현이 완료되었을 때 수행합니다. 위에서 살펴보았듯이, 이 시점에서 "pug"는 동일한 점수(0.0022676)를 가진 두 개의 토큰화 결과를 가지고 있었다는 것을 기억하시지요? 바로 ["p", "ug"]와 ["pu", "g"]가 그것입니다. 따라서 "pu" 토큰을 vocabulary에서 제거하더라도 토큰화 결과가 동일한 점수를 가진 ["p", "ug"]가 되므로, 결론적으로는 위에서 계산한 것과 똑같은 손실(loss) 값이 도출되겠지요. 반면에, "hug"를 제거하면 손실 값이 더 올라가게 됩니다. 그 이유는 "hug"와 "hugs"의 토큰화 결과가 다음과 같이 되기 때문이겠지요: "hug": ["hu", "g"] (score 0.006802) # 위의 토큰화 결과보다 점수가 낮아짐. "hugs": ["hu", "gs"] (score 0.001701) 그 결과 다음 계산 결괏값만큼 손실 값이 올라가게 됩니다: - 10 * (-log(0.071428)) + 10 * (-log(0.006802)) = 23.5 결론적으로, 토큰 "pu"는 vocabulary에서 제거되겠지만 "hug"는 제거되지 않습니다. Unigram 구현 이제 지금까지 살펴본 모든 것을 코드로 구현해 보겠습니다. BPE 및 WordPiece와 마찬가지로 이것은 Unigram 알고리즘의 효율적인 구현은 아니지만 전체 알고리즘을 이해하는 데는 도움이 될 것입니다. 이전과 동일한 말뭉치를 사용합니다: corpus = [ "This is the Hugging Face course.", "This chapter is about tokenization.", "This section shows several tokenizer algorithms.", "Hopefully, you will be able to understand how they are trained and generate tokens.", ] 이번에는 xlnet-base-cased를 모델로 사용할 것입니다: from transformers import AutoTokenizer tokenizer = AutoTokenizer.from_pretrained("xlnet-base-cased") BPE 및 WordPiece의 경우와 마찬가지로 말뭉치에서 각 단어의 출현 빈도를 계산하는 것으로 시작합니다: from collections import defaultdict word_freqs = defaultdict(int) for text in corpus: words_with_offsets = tokenizer.backend_tokenizer.pre_tokenizer.pre_tokenize_str(text) new_words = [word for word, offset in words_with_offsets] for word in new_words: word_freqs[word] += 1 word_freqs 그리고 최종적으로 원하는 크기보다 더 크게 vocabulary를 초기화해야 합니다. 초기화 과정에서 vocabulary에 모든 기본 문자들을 포함해야 합니다. 그렇지 않으면 모든 단어를 토큰화할 수 없겠지요. 또한 길이가 더 긴 부분 문자열에 대해서는 가장 빈번하게 출현하는 것들만 추가할 것이므로 일단 빈도순으로 정렬을 수행합니다: char_freqs = defaultdict(int) subwords_freqs = defaultdict(int) for word, freq in word_freqs.items(): for i in range(len(word)): char_freqs[word[i]] += freq # 길이가 적어도 2 이상인 subword들을 추가함. for j in range(i + 2, len(word) + 1): subwords_freqs[word[i:j]] += freq # Subword들을 빈도 역순으로 정렬 sorted_subwords = sorted(subwords_freqs.items(), key=lambda x: x[1], reverse=True) sorted_subwords[:10] 크기가 300인 초기 vocabulary를 구성하기 위해서 앞에서 만들어진 sorted_subwords 중에서 빈도가 높은 하위 단어들을 선택합니다: token_freqs = list(char_freqs.items()) + sorted_subwords[: 300 - len(char_freqs)] token_freqs = {token: freq for token, freq in token_freqs} SentencePiece는 ESA(Enhanced Suffix Array)라는 보다 효율적인 알고리즘을 사용하여 초기 어휘를 생성합니다. 다음으로 모든 빈도의 합을 계산하여 빈도를 확률로 변환합니다. 우리 모델의 경우 확률의 로 그 값을 저장할 것입니다. 작은 숫자를 곱하는 것보다 로그를 더하는 것이 수치적으로 더 안정적이기 때문입니다. 이렇게 하면 모델 손실 계산이 단순화됩니다: from math import log total_sum = sum([freq for token, freq in token_freqs.items()]) model = {token: -log(freq / total_sum) for token, freq in token_freqs.items()} 이제 가장 중요한 부분은 Viterbi 알고리즘을 사용하여 단어를 토큰화하는 기능입니다. 이전에 보았듯이 이 알고리즘은 단어의 각 부분 문자열에 대한 최상의 분할을 계산하고 이를 best_segmentations라는 변수에 저장합니다. 단어의 각 위치당 하나의 딕셔너리(0에서 전체 길이까지)을 두 개의 키와 함께 저장합니다. 이는 가장 점수가 높은 분할(segmentation)에서 마지막 토큰의 시작 인덱스와 해당 점수입니다. 마지막 토큰의 시작 인덱스를 사용하여 목록이 완전히 채워지면 전체 분할을 검색할 수 있습니다. 목록 채우기는 단 2개의 루프로 완료됩니다. 기본 루프는 각 시작 위치로 이동하고 두 번째 루프는 해당 시작 위치에서 시작하는 모든 하위 문자열을 검토합니다. 하위 문자열이 vocabulary에 있는 경우 해당 끝 위치까지 단어의 새로운 분할이 있으며 이를 best_segmentations에 있는 것과 비교합니다. 메인 루프가 끝나면 단어의 시작 부분에 도달할 때까지 끝에서 시작하여 특정 시작 위치에서 다음 위치로 이동하면서 토큰을 기록합니다: def encode_word(word, model): best_segmentations = [{"start": 0, "score": 1}] + [ {"start": None, "score": None} for _ in range(len(word)) ] for start_idx in range(len(word)): # This should be properly filled by the previous steps of the loop best_score_at_start = best_segmentations[start_idx]["score"] for end_idx in range(start_idx + 1, len(word) + 1): token = word[start_idx:end_idx] if token in model and best_score_at_start is not None: score = model[token] + best_score_at_start # If we have found a better segmentation ending at end_idx, we update if ( best_segmentations[end_idx]["score"] is None or best_segmentations[end_idx]["score"] > score ): best_segmentations[end_idx] = {"start": start_idx, "score": score} segmentation = best_segmentations[-1] if segmentation["score"] is None: # We did not find a tokenization of the word -> unknown return ["<unk>"], None score = segmentation["score"] start = segmentation["start"] end = len(word) tokens = [] while start != 0: tokens.insert(0, word[start:end]) next_start = best_segmentations[start]["start"] end = start start = next_start tokens.insert(0, word[start:end]) return tokens, score 몇 개의 단어들로 위 함수를 테스트해 볼 수 있습니다: print(encode_word("Hopefully", model)) print(encode_word("This", model)) 이제 말뭉치에서 모델의 손실을 쉽게 계산할 수 있습니다! def compute_loss(model): loss = 0 for word, freq in word_freqs.items(): _, word_loss = encode_word(word, model) loss += freq * word_loss return loss 현재 모델에서 작동하는지 확인할 수 있습니다: compute_loss(model) 각 토큰의 점수를 계산하는 것도 그리 어렵지 않습니다. 각 토큰을 삭제하여 얻은 모델의 손실을 계산하기만 하면 됩니다: import copy def compute_scores(model): scores = {} model_loss = compute_loss(model) for token, score in model.items(): # We always keep tokens of length 1 if len(token) == 1: continue model_without_token = copy.deepcopy(model) _ = model_without_token.pop(token) scores[token] = compute_loss(model_without_token) - model_loss return scores 각 토큰에 대해서 위함수를 실행합니다: scores = compute_scores(model) print(scores["ll"]) print(scores["his"]) "ll"은 "Hopefully"의 토큰화에 사용되며 이를 제거하면 토큰 "l"을 대신 두 번 사용하게 되므로 추가적인 손실이 발생할 것으로 예상합니다. "his"는 그 자체로 토큰화된 "This" 단어 내에서만 사용되므로 손실이 0일 것으로 예상합니다. 결과는 위와 같습니다. 이 접근 방식은 매우 비효율적이므로, SentencePiece는 토큰 X가 없는 모델 손실의 근사치를 사용합니다. 처음부터 시작하는 대신 남은 vocabulary의 분할로 토큰 X를 대체합니다. 이런 식으로 모든 점수는 모델 손실과 동시에 한 번에 계산할 수 있습니다. 이제 마지막으로 해야 할 일은 모델에서 사용하는 특수 토큰을 vocabulary에 추가한 다음 원하는 크기에 도달할 때까지 vocabulary에서 토큰을 반복적으로 제거해 나가는 것입니다: percent_to_remove = 0.1 while len(model) > 100: scores = compute_scores(model) sorted_scores = sorted(scores.items(), key=lambda x: x[1]) # Remove percent_to_remove tokens with the lowest scores. for i in range(int(len(model) * percent_to_remove)): _ = token_freqs.pop(sorted_scores[i][0]) total_sum = sum([freq for token, freq in token_freqs.items()]) model = {token: -log(freq / total_sum) for token, freq in token_freqs.items()} 입력 텍스트를 토큰화하려면 사전 토큰화를 적용한 다음 encode_word() 함수를 사용하면 됩니다: def tokenize(text, model): words_with_offsets = tokenizer.backend_tokenizer.pre_tokenizer.pre_tokenize_str(text) pre_tokenized_text = [word for word, offset in words_with_offsets] encoded_words = [encode_word(word, model)[0] for word in pre_tokenized_text] return sum(encoded_words, []) tokenize("This is the Hugging Face course.", model) 유니그램에 대해서 설명했습니다. 지금쯤이면 토크 나이저에 관한 전문가가 되셨기를 바랍니다. 다음 섹션에서는 Tokenizers 라이브러리의 빌딩 블록을 탐구하고 이를 사용하여 자신만의 토크 나이저를 구축하는 방법을 공부해 보겠습니다. 8. 블록 단위로 토크 나이저 빌딩 하기 이전 섹션에서 보았듯이 토큰화는 다음과 같은 단계로 실행됩니다: 정규화 (공백이나 악센트 제거, 유니코드 정규화 등과 같이 필요하다고 여겨지는 모든 텍스트 정제 작업) 사전 토큰화 (입력을 단어들로 분리) 모델을 통한 입력 실행 (사전 토큰화된 단어들을 사용하여 토큰 시퀀스 생성) 후처리 (토큰 나이저의 특수 토큰 추가, attention mask 및 토큰 유형 ID 생성) 다시 말하지만, 전체 프로세스를 살펴보면 다음과 같습니다: Tokenizers 라이브러리는 위의 개별 단계에 대해 여러 옵션을 제공할 수 있도록 만들어졌으며, 이러한 옵션들은 목적에 따라 짜 맞춰서 활용할 수 있습니다. 이 섹션에서는 섹션 2에서 설명했던 기존 토크 나이저에서 새로운 토크 나이저를 학습하는 것과는 달리 아예 처음부터 토크 나이저를 구축하는 방법을 볼 것입니다. 이를 통해서, 생각할 수 있는 모든 종류의 토크 나이저를 만들 수 있습니다! 보다 정확하게 이 라이브러리는 중심에 Tokenizer 클래스를 중심으로 다양한 하부 모듈들이 기능별로 결합된 구성 요소(building blocks)가 결합된 형태로 구축되었습니다: normalizers에는 사용할 수 있는 모든 가능한 Normalizer 유형이 포함되어 있습니다(전체 목록은 여기에서 확인하세요). pre_tokenizers에는 사용할 수 있는 모든 가능한 유형의 PreTokenizer가 포함되어 있습니다 (전체 목록은 여기에서 확인하세요). models에는 BPE, WordPiece 및 Unigram과 같이 사용할 수 있는 다양한 유형의 Model이 포함되어 있습니다(전체 목록은 여기에서 확인하세요). trainer에는 말뭉치에서 모델을 훈련하는 데 사용할 수 있는 다양한 유형의 Trainer가 모두 포함되어 있습니다(모델 유형당 하나씩, 전체 목록은 여기). post_processors에는 사용할 수 있는 다양한 유형의 PostProcessor가 포함되어 있습니다(전체 목록은 여기에서 확인하세요). decoders에는 토큰화 출력을 디코딩 하는데 사용할 수 있는 다양한 유형의 Decoder가 포함되어 있습니다(전체 목록은 여기에서 확인하세요). 여기에서 구성 요소(building blocks)의 전체 목록을 찾을 수 있습니다. 말뭉치 확보 새로운 토크 나이저를 학습하기 위해 작은 텍스트 말뭉치를 사용합니다(예제 실행 시간을 줄이기 위해서). 말뭉치를 획득하는 단계는 이 장의 시작 부분에서 수행한 단계와 유사하지만 이번에는 WikiText-2 데이터 셋을 사용합니다: from datasets import load_dataset dataset = load_dataset("wikitext", name="wikitext-2-raw-v1", split="train") def get_training_corpus(): for i in range(0, len(dataset), 1000): yield dataset[i : i + 1000]["text"] get_training_corpus() 함수는 1,000개의 텍스트 배치(batch)를 생성하는 생성자(generator)이며 토크 나이저를 학습하는 데 사용할 것입니다. Tokenizers는 텍스트 파일에서 직접 학습될 수도 있습니다. 로컬에서 사용할 수 있는 WikiText-2의 모든 텍스트/입력을 포함하는 텍스트 파일을 생성하는 방법은 다음과 같습니다: with open("wikitext-2.txt", "w", encoding="utf-8") as f: for i in range(len(dataset)): f.write(dataset[i]["text"] + "\n") 이제 블록 단위로 BERT, GPT-2 및 XLNet 토크 나이저를 빌드 하는 방법을 보여드리겠습니다. 이 과정에서 각각 WordPiece, BPE 및 Unigram의 세 가지 주요 토큰화 알고리즘 각각의 실제 예시가 제공됩니다. BERT부터 시작하겠습니다! WordPiece 토크 나이저를 처음부터 빌딩 하기 Tokenizers 라이브러리를 사용하여 토크 나이저를 빌드 하려면 먼저 model로 Tokenizer 객체를 인스턴스화한 다음 normalizer, pre_tokenizer, post_processor 및 decoder 속성을 원하는 값으로 설정합니다. 이 예에서는 WordPiece 모델을 사용하여 Tokenizer를 만듭니다: from tokenizers import ( decoders, models, normalizers, pre_tokenizers, processors, trainers, Tokenizer, ) tokenizer = Tokenizer(models.WordPiece(unk_token="[UNK]")) 모델이 이전에 본 적이 없는 문자들을 만났을 때 무엇을 반환할지 알 수 있도록 unk_token을 지정해야 합니다. 여기서 설정할 수 있는 다른 인수에는 모델의 vocab(여기서는 모델을 학습할 것이므로 이것을 설정할 필요가 없습니다)과 각 단어의 최대 길이를 지정하는 max_input_chars_per_word(이 길이보다 더 긴 단어는 분할됨)가 포함됩니다. 토큰화의 첫 번째 단계는 정규화(normalization)입니다. BERT가 널리 사용되기 때문에 BERT에 대해 설정할 수 있는 기본적인 옵션이 포함된 BertNormalizer가 존재합니다. 지정할 수 있는 옵션에는 lowercase, strip_accents 등을 비롯하여, 모든 제어 문자를 제거하고 반복되는 공백을 단일 문자로 바꾸는 clean_text 그리고 한자(Chinese characters) 주위에 공백을 배치하는 handle_chinese_chars가 있습니다. bert-base-uncased 토크 나이저를 복제하려면 이 노멀라이저(normalizer)를 설정하면 됩니다: tokenizer.normalizer = normalizers.BertNormalizer(lowercase=True) 그러나 일반적으로 새로운 토크 나이저를 빌드 할 때 Tokenizers 라이브러리에 이미 구현된 편리한 노멀라이저에 접근할 수가 없습니다. 따라서 BERT 노멀라이저를 직접 만드는 방법을 살펴보겠습니다. 라이브러리에서는 Lowercase 노멀라이저와 StripAccents 노멀라이저를 제공하며 Sequence를 사용하여 여러 노멀라이저를 구성할 수 있습니다: tokenizer.normalizer = normalizers.Sequence( [normalizers.NFD(), normalizers.Lowercase(), normalizers.StripAccents()] ) 또한 여기서는 NFD 유니코드 노멀라이저를 사용하고 있습니다. 그렇지 않으면, StripAccents 노멀라이저가 악센트가 있는 문자를 제대로 인식하지 못하므로 제대로 동작할 수 없습니다. 이전에 보았듯이 normalize_str() 메서드를 사용하여 주어진 텍스트의 변화 양상을 확인할 수 있습니다: print(tokenizer.normalizer.normalize_str("Héllò hôw are ü?")) To go further 유니코드 문자 u"\u0085"가 포함된 문자열에서 위 2가지 노멀라이저를 테스트하면 그 결과가 동일하지 않다는 것을 확실히 알 수 있습니다. normalizers.Sequence 버전을 너무 복잡하게 만들지 않기 위해, clean_text 인수가 기본 동작인 True로 설정될 때, BertNormalizer가 필요로 하는 정규식 대체(Regex replacements)를 포함하지 않았습니다. 그러나 걱정하지 마십시오. 두 개의 normalizer.Replace를 노멀라이저 시퀀스에 추가하여 편한 BertNormalizer를 사용하지 않고도 정확히 동일한 정규화를 얻을 수 있습니다. 다음은 사전 토큰화 단계입니다. 여기서도 우리가 사용할 수 있는 사전 빌드 된 BertPreTokenizer가 있습니다: tokenizer.pre_tokenizer = pre_tokenizers.BertPreTokenizer() 또는 처음부터 빌드 할 수 있습니다: tokenizer.pre_tokenizer = pre_tokenizers.Whitespace() Whitespace 사전 토크 나이저(pre-tokenizer)는 공백은 물론, 문자, 숫자 또는 밑줄 문자가 아닌 모든 문자를 기준으로 텍스트를 분할하므로, 결국은 공백과 구두점으로 분할한다고 볼 수 있습니다: tokenizer.pre_tokenizer.pre_tokenize_str("Let's test my pre-tokenizer.") 공백만을 기준으로 분할하려면 WhitespaceSplit 사전 토크 나이저(pre-tokenizer) 대신 사용해야 합니다: pre_tokenizer = pre_tokenizers.WhitespaceSplit() pre_tokenizer.pre_tokenize_str("Let's test my pre-tokenizer.") 노멀라이저와 마찬가지로 Sequence를 사용하여 여러 사전 토크 나이저(pre-tokenizer)들을 결합할 수도 있습니다: pre_tokenizer = pre_tokenizers.Sequence( [pre_tokenizers.WhitespaceSplit(), pre_tokenizers.Punctuation()] ) pre_tokenizer.pre_tokenize_str("Let's test my pre-tokenizer.") 토큰화 파이프라인의 다음 단계는 모델을 통해 입력을 실행하는 것입니다. 이미 초기화 단계에서 모델을 지정하긴 했지만 이제 학습이 필요하며 이를 위해서 WordPieceTrainer가 필요합니다. Tokenizers에서 트레이너(trainer)를 인스턴스화할 때 기억해야 할 중요한 점은 사용하려는 모든 특수 토큰을 전달해야 한다는 것입니다. 그렇지 않으면 이들 토큰이 학습 코퍼스에 없기 때문에 어휘집(vocabulary)에 추가되지 않습니다: special_tokens = ["[UNK]", "[PAD]", "[CLS]", "[SEP]", "[MASK]"] trainer = trainers.WordPieceTrainer(vocab_size=25000, special_tokens=special_tokens) vocab_size 및 special_tokens를 지정하는 것 외에도 min_frequency(토큰이 vocabulary에 포함되기 위한 최소 출현 빈도)를 설정하거나 continue_subword_prefix(##말고 다른 기호를 사용하려는 경우)를 변경할 수 있습니다. 앞에서 정의한 반복자(iterator)를 사용하여 모델을 학습시키려면 다음 명령을 실행하기만 하면 됩니다: tokenizer.train_from_iterator(get_training_corpus(), trainer=trainer) 또한 텍스트 파일을 사용하여 토크 나이저를 학습할 수 있습니다. 다음처럼 실행하면 됩니다. 미리 비어있는 WordPiece로 모델을 다시 초기화했습니다: tokenizer.model = models.WordPiece(unk_token="[UNK]") tokenizer.train(["wikitext-2.txt"], trainer=trainer) 두 경우 모두 encode() 메서드를 호출하여 텍스트에서 토크 나이저를 테스트할 수 있습니다: encoding = tokenizer.encode("Let's test this tokenizer") print(encoding.tokens) 위에서 encoding은 다양한 속성(ids, type_ids, tokens, offsets, attention_mask, special_tokens_mask, overflowing)에 토크 나이저의 모든 필요한 출력을 포함하고 있는 Encoding 클래스의 객체입니다. 토큰화 파이프라인의 마지막 단계는 후처리(post-processing)입니다. 시작 부분에 [CLS] 토큰을 추가하고 끝부분에 [SEP] 토큰을 추가해야 합니다. 한 쌍의 문장이 있는 경우에는 각 문장 뒤에 [SEP]를 붙입니다. 이를 위해서, TemplateProcessor를 사용하지만 먼저 어휘집(vocabulary)에서 [CLS] 및 [SEP] 토큰의 ID를 알아야 합니다: cls_token_id = tokenizer.token_to_id("[CLS]") sep_token_id = tokenizer.token_to_id("[SEP]") print(cls_token_id, sep_token_id) TemplateProcessor 용 템플릿을 작성하려면 단일 문장과 문장 쌍을 처리하는 방법을 지정해야 합니다. 둘 다 사용하려는 특수 토큰을 작성합니다. 첫 번째(또는 단일) 문장은 $A로 표시되고 두 번째 문장(쌍을 인코딩하는 경우)은 $B로 표시됩니다. 이들 각각(특수 토큰 및 문장)에 대해 콜론(colon) 뒤에 해당 토큰 유형 ID도 지정합니다. 따라서 고전적인 BERT 템플릿은 다음과 같이 정의됩니다: tokenizer.post_processor = processors.TemplateProcessing( single=f"[CLS]:0 $A:0 [SEP]:0", pair=f"[CLS]:0 $A:0 [SEP]:0 $B:1 [SEP]:1", special_tokens=[("[CLS]", cls_token_id), ("[SEP]", sep_token_id)] ) 특수 토큰의 ID를 전달해야 토크 나이저가 이를 해당 ID로 적절하게 변환할 수 있습니다. 일단 추가되면 이전 예제의 결과는 다음과 같습니다: encoding = tokenizer.encode("Let's test this tokenizer.") print(encoding.tokens) 또한, 2개의 문장을 입력하면 다음과 같은 결과가 나옵니다: encoding = tokenizer.encode("Let's test this tokenizer...", "on a pair of sentences.") print(encoding.tokens) print(encoding.type_ids) 새로운 토크 나이저를 거의 완성했습니다. 마지막 단계는 디코더를 포함하는 것입니다: tokenizer.decoder = decoders.WordPiece(prefix="##") 위의 encoding을 이용해서 테스트해 보겠습니다: tokenizer.decode(encoding.ids) 좋습니다! 이제 다음과 같이 단일 JSON 파일에 토크 나이저를 저장할 수 있습니다: tokenizer.save("tokenizer.json") 그런 다음 from_file() 메서드를 사용하여 Tokenizer 객체에서 해당 파일을 다시 로드할 수 있습니다: new_tokenizer = Tokenizer.from_file("tokenizer.json") Transformers에서 우리가 만든 토크 나이저를 사용하려면 PreTrainedTokenizerFast로 래핑해야 합니다. 제너릭 클래스(generic class)를 사용하거나, 토크 나이저가 기존 모델에 해당하는 경우, 해당 클래스(여기서는 BertTokenizerFast)를 사용할 수 있습니다. 이 강의를 활용하여 새로운 토크 나이저를 구축하는 경우 첫 번째 옵션을 사용해야 합니다. PreTrainedTokenizerFast를 가지고 토크 나이저를 래핑 하려면 우리가 만든 토크 나이저를 tokenizer_object로 전달하거나 tokenizer_file로 저장한 토크 나이저 파일을 전달할 수 있습니다. 기억해야 할 중요한 점은 모든 특수 토큰을 수동으로 직접 설정해야 한다는 것입니다. PreTrainedTokenizerFast 클래스는 tokenizer 객체로부터 어떤 토큰이 마스크 토큰인지 아니면 [CLS] 토큰 등인지 추론할 수 없기 때문입니다: from transformers import PreTrainedTokenizerFast wrapped_tokenizer = PreTrainedTokenizerFast( tokenizer_object=tokenizer, unk_token="[UNK]", pad_token="[PAD]", cls_token="[CLS]", sep_token="[SEP]", mask_token="[MASK]", ) 특정 토크 나이저 클래스(예: BertTokenizerFast)를 사용하는 경우, 기본적으로 지정된 토큰(여기서는 없음)과 다른 특수 토큰만 지정하면 됩니다: from transformers import BertTokenizerFast wrapped_tokenizer = BertTokenizerFast(tokenizer_object=tokenizer) 이제 위 토크 나이저를 다른 Transformers 토크 나이저처럼 동일하게 사용할 수 있습니다. 또한, save_pretrained() 메서드로 저장하거나 push_to_hub() 메서드로 허브에 업로드할 수 있습니다. 이제까지 WordPiece 토크 나이저를 빌드 하는 방법을 보았으므로 BPE 토크 나이저에 대해서도 동일한 작업을 수행해 보겠습니다. 모든 단계를 알고 있기 때문에 조금 더 빠르게 진행하고 차이점만 강조 표시합니다. BPE 토크 나이저를 처음부터 빌딩 하기 이제 GPT-2 토크 나이저를 빌드 해 보겠습니다. BERT 토크 나이저와 마찬가지로 BPE 모델로 Tokenizer를 초기화하는 것으로 시작합니다: tokenizer = Tokenizer(models.BPE()) 앞에서와 마찬가지로 기존에 어휘집(vocabulary)이 있는 경우 모델을 해당 어휘집(vocabulary)으로 초기화할 수 있지만(이 경우 vocab과 merges를 전달해야 함) 처음부터 학습할 것이기 때문에 그럴 필요는 없습니다. 또한 GPT-2는 byte-level BPE(바이트 수준 BPE)를 사용하기 때문에 unk_token을 지정할 필요가 없습니다. GPT-2는 노멀라이저를 사용하지 않으므로 해당 단계를 건너뛰고 사전 토큰화(pre-tokenization)로 바로 이동합니다: tokenizer.pre_tokenizer = pre_tokenizers.ByteLevel(add_prefix_space=False) 여기에서 ByteLevel에 추가한 옵션은 문장 시작 부분에 공백을 추가하지 않도록 하는 옵션입니다. 이전과 동일한 사전 토큰화 결과를 아래에서 볼 수 있습니다: tokenizer.pre_tokenizer.pre_tokenize_str("Let's test pre-tokenization!") 다음은 학습이 필요한 모델입니다. GPT-2의 경우, 유일한 특수 토큰은 텍스트 끝(end-of-text) 토큰입니다: trainer = trainers.BpeTrainer(vocab_size=25000, special_tokens=["<|endoftext|>"]) tokenizer.train_from_iterator(get_training_corpus(), trainer=trainer) WordPieceTrainer와 vocab_size 및 special_tokens와 마찬가지로, 원하는 경우 min_frequency를 지정할 수 있습니다. 또는 단어 끝 접미사(end-of-word suffix)가 있는 경우(예: </w>) end_of_word_suffix 인수를 설정할 수 있습니다. 이 토크 나이저는 텍스트 파일에 대해서도 학습할 수 있습니다: tokenizer.model = models.BPE() tokenizer.train(["wikitext-2.txt"], trainer=trainer) 샘플 텍스트로 토큰화 테스트를 해보겠습니다: encoding = tokenizer.encode("Let's test this tokenizer.") print(encoding.tokens) 다음과 같이 GPT-2 토크 나이저에 대한 바이트 수준(byte-level) 후처리를 적용합니다: tokenizer.post_processor = processors.ByteLevel(trim_offsets=False) trim_offsets = False 옵션은 후처리기(post-processor)가 'Ġ'로 시작하는 토큰의 오프셋을 그대로 두어야 함을 나타냅니다. 이렇게 하면 오프셋의 시작은 단어의 첫 번째 문자가 아니라 단어 앞의 공백을 가리킵니다. 그 이유는 공백도 기술적으로 토큰의 일부이기 때문입니다. 방금 인코딩한 텍스트로 결과를 살펴보겠습니다. 여기서 'Ġtest'는 인덱스 4의 토큰입니다: sentence = "Let's test this tokenizer." encoding = tokenizer.encode(sentence) start, end = encoding.offsets[4] sentence[start:end] 마지막으로, 바이트 수준(byte-level) 디코더를 추가합니다: tokenizer.decoder = decoders.ByteLevel() 이것이 제대로 작동하는지 다시 확인할 수 있습니다: tokenizer.decode(encoding.ids) 이제 완료되었으므로, 이전과 같이 토크 나이저를 저장하고, 이를 Transformers에서 사용하기를 원하는 경우에는 PreTrainedTokenizerFast 또는 GPT2TokenizerFast를 이용하여 래핑(wrapping) 할 수 있습니다: from transformers import PreTrainedTokenizerFast wrapped_tokenizer = PreTrainedTokenizerFast( tokenizer_object=tokenizer, bos_token="<|endoftext|>", eos_token="<|endoftext|>", ) from transformers import GPT2TokenizerFast wrapped_tokenizer = GPT2TokenizerFast(tokenizer_object=tokenizer) 이제 마지막 예제로 Unigram 토크 나이저를 처음부터 빌드 하는 방법을 보여 드리겠습니다. Unigram 토크 나이저를 처음부터 빌딩 하기 이제 XLNet 토크 나이저를 빌드 해 보겠습니다. 이전 토크 나이저와 마찬가지로 Unigram 모델로 Tokenizer를 초기화하는 것으로 시작합니다: tokenizer = Tokenizer(models.Unigram()) 역시 여기서도, 어휘집(vocabulary)이 있는 경우 모델을 어휘집으로 초기화할 수 있습니다. 정규화(normalization)를 위해 XLNet은 다음과 같은 몇 가지 대체 규칙(relpacements, SentencePiece에서 제공)을 사용합니다: from tokenizers import Regex tokenizer.normalizer = normalizers.Sequence( [ normalizers.Replace("``", '"'), normalizers.Replace("''", '"'), normalizers.NFKD(), normalizers.StripAccents(), normalizers.Replace(Regex(" {2, }"), " "), ] ) 위 대체 규칙은 “ 및 ”를 ”로 대체하고, 둘 이상의 공백 시퀀스를 단일 공백으로 대체하며, 토큰화할 텍스트의 악센트를 제거합니다. 모든 SentencePiece 토크 나이저에 사용되는 사전 토크 나이저(pre-tokenizer)는 Metaspace입니다. tokenizer.pre_tokenizer = pre_tokenizers.Metaspace() 이전의 예제 텍스트에 대한 사전 토큰화 결과를 한번 보겠습니다: tokenizer.pre_tokenizer.pre_tokenize_str("Let's test the pre-tokenizer!") 다음으로 모델 학습입니다. XLNet에는 몇 가지 특별한 토큰들이 있습니다: special_tokens = ["<cls>", "<sep>", "<unk>", "<pad>", "<mask>", "<s>", "</s>"] trainer = trainers.UnigramTrainer( vocab_size=25000, special_tokens=special_tokens, unk_token="<unk>" ) tokenizer.train_from_iterator(get_training_corpus(), trainer=trainer) UnigramTrainer에서 뻬먹지 말아야 할 매우 중요한 인수는 unk_token입니다. 또한 토큰을 제거하는 각 단계에 대한 shrinking_factor(기본값은 0.75), 또는 주어진 토큰의 최대 길이를 지정하기 위한 max_piece_length(기본값은 16) 등과 같은 Unigram 알고리즘에 특화된 추가 매개변수들을 전달할 수도 있습니다. 이 토크 나이저는 역시 텍스트 파일에 대해서도 학습할 수 있습니다: tokenizer.model = models.Unigram() tokenizer.train(["wikitext-2.txt"], trainer=trainer) 샘플 텍스트에 대한 토큰화 결과를 살펴보겠습니다: encoding = tokenizer.encode("Let's test this tokenizer.") print(encoding.tokens) XLNet의 특징은 토큰 타입 ID가 2인 <cls> 토큰을 문장 끝에 추가한다는 것입니다. 결과적으로 좌측 패딩입니다. BERT와 같이 템플릿을 사용하여 모든 특수 토큰과 토큰 타입 ID를 처리할 수 있지만 그전에 먼저 <cls> 및 <sep> 토큰의 ID를 가져와야 합니다: cls_token_id = tokenizer.token_to_id("<cls>") sep_token_id = tokenizer.token_to_id("<sep>") print(cls_token_id, sep_token_id) 템플릿은 다음과 같은 형태로 구현됩니다: tokenizer.post_processor = processors.TemplateProcessing( single="$A:0 <sep>:0 <cls>:2", pair="$A:0 <sep>:0 $B:1 <sep>:1 <cls>:2", special_tokens=[("<sep>", sep_token_id), ("<cls>", cls_token_id)], ) 이제 한 쌍의 문장에 대한 인코딩이 제대로 작동하는지 테스트할 수 있습니다: encoding = tokenizer.encode("Let's test this tokenizer...", "on a pair of sentences!") print(encoding.tokens) print(encoding.type_ids) 마지막으로 Metaspace 디코더를 추가합니다: tokenizer.decoder = decoders.Metaspace() 토크 나이저 빌드를 끝냈습니다! 이전과 같이 토크 나이저를 저장하고 Transformers 내에서 사용하려면 PreTrainedTokenizerFast 또는 XLNetTokenizerFast로 래핑 할 수 있습니다. PreTrainedTokenizerFast를 사용할 때 한 가지 주의해야 할 점은 특수 토큰 지정과 더불어 Transformers 라이브러리에 왼쪽을 채우도록 지시(padding_side="left") 해야 한다는 것입니다: from transformers import PreTrainedTokenizerFast wrapped_tokenizer = PreTrainedTokenizerFast( tokenizer_object=tokenizer, bos_token="<s>", eos_token="</s>", unk_token="<unk>", pad_token="<pad>", cls_token="<cls>", sep_token="<sep>", mask_token="<mask>", padding_side="left", ) from transformers import XLNetTokenizerFast wrapped_tokenizer = XLNetTokenizerFast(tokenizer_object=tokenizer) 지금까지 다양한 요소 모듈들이 기존 토크 나이저를 새롭게 빌드 하는 데 어떻게 사용되는지 보았으므로, 이 설명을 활용하여 Tokenizers 라이브러리로 원하는 토크 나이저를 구성하고 Transformers에서 사용할 수 있어야 합니다. 7장. 주요 NLP 태스크 실제 구현 방법 우리는 3장에서 텍스트 분류(text classification)를 위한 모델을 미세 조정하는 방법을 살펴보았습니다. 이 장에서는 다음과 같은 주요 NLP 태스크들을 다룰 것입니다. 토큰 분류 (Token Classification) 마스킹 된 언어 모델링 (Masked Language Modeling) 요약 (Summarization) 번역 (Translation) 인과적 언어 모델링 사전학습 (Causal Language Modeling Pretraining like GPT-2) 질의응답 (Question Answering) 이를 위해서, Trainer API를 비롯하여, 3장에서 배운 Accelerate 라이브러리, 5장의 Datasets 라이브러리, 6장에서 살펴본 Tokenizers 라이브러리 모두를 활용해야 합니다. 또한 4장에서 했던 것처럼 각 섹션에서의 결과를 Model Hub에 업로드할 것이므로 결국은 지금까지 공부한 모든 내용이 설명되는 총체적인 챕터가 될 것입니다. 각 섹션은 독립적으로 읽을 수 있으며 Accelerate를 사용하여 Trainer API 또는 자체 학습 루프(training loop)로 모델을 학습하는 방법을 보여줍니다. 어느 부분이든 건너뛰고 가장 관심 있는 부분에 집중해도 상관없습니다. Trainer API는 내부적으로 실행되는 세세한 부분에 대해 걱정하지 않고 모델을 미세 조정하거나 학습하는데 적합하며, Accelerate가 있는 학습 루프(training loop)를 사용하면 원하는 부분을 더 쉽게 수정할 수 있습니다. 본 장의 섹션을 순서대로 읽으면 코드와 내용에 공통점이 있음을 알 수 있습니다. 이러한 반복은 의도적이므로 관심 있는 작업에 집중하고(또는 나중에 다시 돌아와서) 완전한 실행 예시를 찾을 수 있습니다. 1. 토큰 분류 (Token Classification) 우리가 살펴볼 첫 번째 NLP 응용 프로그램은 토큰 분류(token classification)입니다. 이 포괄적인 작업은 다음과 같이 "문장의 각 토큰에 레이블을 지정" 하는 것으로 정형화될 수 있는 모든 문제를 포함합니다: Named entity recognition (NER): 문장에서 개체명(혹은 엔터티, 예: 사람, 위치 또는 조직)을 찾습니다. 이 작업은 개체 명당 하나의 클래스와 "개체명이 아님(no entity)"에 대한 하나의 클래스를 사용하여 각 토큰에 레이블을 부여하는 것으로 공식화할 수 있습니다. Part-of-speech tagging (POS): 문장의 각 단어에 대한 특정 품사(명사, 동사, 형용사 등)를 지정합니다. Chunking: 동일한 개체명 혹은 엔터티에 속한 토큰을 찾습니다. 이 작업(POS 또는 NER와 결합 가능)은 청크(chunk)의 시작 부분에 있는 토큰에 한 레이블(보통 B-)을, 청크 내부에 있는 토큰에 다른 레이블(보통 I-)을, 그리고 청크에 속하지 않는 토큰에 대해서는 세 번째 레이블(보통 O)을 부여하는 것으로 공식화할 수 있습니다. 물론 다른 유형의 토큰 분류 문제들도 많이 있습니다. 위는 단지 몇 가지 대표적인 예일뿐입니다. 이 섹션에서는 사전 학습 모델(BERT)을 NER 작업에 대해 미세 조정하여 예측을 수행할 수 있게끔 합니다. 학습할 모델을 찾아 Hub에 업로드하고 여기에서 예측을 다시 확인할 수 있습니다. 데이터 준비 먼저 토큰 분류에 적합한 데이터 셋이 필요합니다. 이 섹션에서는 Reuters의 뉴스 기사가 포함된 CoNLL-2003 데이터 셋을 사용합니다. 데이터 셋이 해당 레이블이 있는 단어로 분할된 텍스트로 구성되어 있기만 한다면 여기에 설명된 데이터 처리 절차를 자신의 데이터 셋에 그대로 적용할 수 있습니다. Dataset에서 사용자 정의 데이터를 로드하는 방법에 대한 복습이 필요한 경우 5장을 다시 참조하십시오. CoNLL-2003 데이터 셋 CoNLL-2003 데이터 셋을 로드하기 위해, Datasets 라이브러리에서 load_dataset() 메서드를 사용합니다: from datasets import load_dataset # CoNLL-2003 URL이 변경되었음. raw_datasets = load_dataset("conll2003", revision="master") GLUE MRPC 데이터 셋에 대해 3장에서 본 것처럼 데이터 셋을 다운로드하고 캐시 합니다. raw_datasets 객체를 살펴보면 열(columns)이 존재함을 알 수 있으며 또한 학습, 검증 및 테스트 집합 간의 분할이 표시됩니다: raw_datasets 특히 앞서 언급한 세 가지 작업인 NER, POS 및 Chunking에 대한 레이블이 데이터 셋에 포함되어 있음을 알 수 있습니다. 다른 데이터 셋과의 가장 큰 차이점은 입력된 텍스트가 문장이나 문서로 표현되지 않고 단어의 목록으로 표현된다는 점입니다. 마지막 열은 token이라고 하지만 하위 단어 토큰화(subword tokenization)를 위해 여전히 토크 나이저를 통과해야 하는 사전 토큰 화(pre-tokenization) 된 입력이라는 의미에서 단어(word)가 포함되어 있습니다. 학습 집합의 첫 번째 요소를 살펴보겠습니다: raw_datasets["train"][0]["tokens"] 개체명 인식(named entity recognition)을 수행할 예정이므로 NER 태그를 살펴보겠습니다: raw_datasets["train"][0]["ner_tags"] 위 값들은 학습을 위해 준비된 정수 레이블이지만 데이터를 내용적으로 검토할 때 항상 유용하지는 않습니다. 텍스트 분류와 마찬가지로 데이터 셋의 features 속성을 확인하여 해당 정수가 가리키는 레이블명을 확인할 수 있습니다: ner_feature = raw_datasets["train"].features["ner_tags"] ner_feature 이 열(column)에는 ClassLabel의 시퀀스가 포함됩니다. 시퀀스 요소의 타입은 ner_feature의 feature 속성 내에 있으며 해당 feature의 names 속성을 통해서 이름 목록에 접근할 수 있습니다: label_names = ner_feature.feature.names label_names 6장에서 token-classification 파이프라인을 공부할 때 이미 이러한 레이블들을 살펴봤으나 복습 삼아 각 레이블에 대한 설명을 다시 해보겠습니다: O는 단어가 어떤 개체명에도 해당하지 않음을 의미합니다. B-PER/I-PER은 해당 단어가 person 개체 명의 시작/내부에 있음을 의미합니다. B-ORG/I-ORG는 해당 단어가 organization 개체 명의 시작/내부에 있음을 의미합니다. B-LOC/I-LOC는 해당 단어가 location 개체 명의 시작/내부에 있음을 의미합니다. B-MISC/I-MISC는 해당 단어가 miscellaneous 개체 명의 시작/내부에 있음을 의미합니다. 이제 레이블을 디코딩함으로써 다음과 같은 결과를 볼 수 있습니다: words = raw_datasets["train"][0]["tokens"] labels = raw_datasets["train"][0]["ner_tags"] line1 = "" line2 = "" for word, label in zip(words, labels): full_label = label_names[label] max_length = max(len(word), len(full_label)) line1 += word + " " * (max_length - len(word) + 1) line2 += full_label + " " * (max_length - len(full_label) + 1) print(line1) print(line2) 또한, B- 및 I- 레이블이 함께 존재하는 예시를 살펴보기 위해, 인덱스 4에 저장된 학습 집합 요소를 출력하면 다음과 같지요: words = raw_datasets["train"][4]["tokens"] labels = raw_datasets["train"][4]["ner_tags"] line1 = "" line2 = "" for word, label in zip(words, labels): full_label = label_names[label] max_length = max(len(word), len(full_label)) line1 += word + " " * (max_length - len(word) + 1) line2 += full_label + " " * (max_length - len(full_label) + 1) print(line1) print(line2) 보다시피, "European Union" 및 "Werner Zwingmann"과 같은 두 단어에 걸쳐 있는 개체명은 첫 번째 단어에 대해 B-레이블, 두 번째 단어에 대해 I-레이블이 지정됩니다. ✏ Your turn! 위와 동일한 문장들에 대해서 POS와 chunking 레이블을 출력해 보세요. 데이터 처리 앞에서 계속 강조한 바와 같이, 텍스트를 토큰 ID로 변환해야 모델이 해당 입력을 이해할 수 있습니다. 6장에서 보았듯이, 토큰 분류 작업의 경우 큰 차이점은 사전에 토큰화된 입력이 존재한다는 것입니다. 다행히도 토크 나이저 API는 이를 매우 쉽게 처리할 수 있습니다. 특별한 플래그로 tokenizer에게 입력이 미리 토큰화되어 있다고 통지하면 됩니다. 먼저 tokenizer 객체를 생성해 보겠습니다. 이전에 말했듯이 우리는 사전 학습된(pretrained) BERT 모델을 사용할 것이므로 관련 토크 나이저를 다운로드하고 캐싱 하는 것으로 시작합니다: from transformers import AutoTokenizer model_checkpoint = "bert-base-cased" tokenizer = AutoTokenizer.from_pretrained(model_checkpoint) 허브(Hub)에서 선호하는 다른 모델을 찾아서 model_checkpoint를 변경하거나 이미 사전 학습된 모델과 토크 나이저를 저장한 로컬 폴더로 지정할 수도 있습니다. 유일한 제약사항은 "빠른(fast)" 버전의 토크 나이저를 사용하기 위해서 토크 나이저가 Tokenizers 라이브러리의 도움을 받아야 한다는 것입니다. 이 큰 테이블에서 "빠른(fast)" 토크 나이저 버전과 함께 제공되는 모든 아키텍처를 볼 수 있으며, 사용 중인 tokenizer 객체가 실제로 Tokenizers의 지원을 받고 있는지 검사하기 위해서 is_fast 속성을 확인해 보면 됩니다: tokenizer.is_fast 사전 토큰화된(pre-tokenized) 입력을 토큰화하려면 is_split_into_words=True를 지정하여 tokenizer를 실행하면 됩니다: inputs = tokenizer(raw_datasets["train"][0]["tokens"], is_split_into_words=True) inputs.tokens() 보다시피 토크 나이저는 모델에서 사용하는 특수 토큰(처음에 [CLS], 끝에 [SEP])을 추가하고 대부분의 단어를 그대로 유지했습니다. 그러나 lamb라는 단어는 la와 ##mb의 두 하위 단어로 토큰화되었습니다. 이것은 입력과 레이블 사이에 불일치를 초래합니다. 레이블 목록에는 9개의 요소만 있는 반면 입력에는 12개의 토큰이 있습니다. 특수 토큰에 대한 처리는 쉽지만(시작과 끝에 있음을 알고 있기 때문이지요.), 모든 단어에 대해서 적합한 레이블로 정렬해야 합니다. 다행히도 "빠른(fast)" 토크 나이저를 사용하고 있기 때문에 Tokenizers의 유용한 기능을 사용할 수 있습니다. 즉, 각 토큰을 해당 단어에 쉽게 매핑할 수 있습니다(6장 참조): inputs.word_ids() 약간의 부가 작업으로 토큰과 일치되도록 레이블 목록을 확장할 수 있습니다. 적용할 첫 번째 규칙은 특수 토큰의 레이블의 ID가 -100이라는 것입니다. 기본적으로 -100은 우리가 사용할 손실 함수(cross entropy)에서 무시되는 인덱스이기 때문입니다. 추가적으로, 위의 토큰 식별자 리스트에서 두 번째 7에 해당하는 토큰의 레이블은 첫 번째 7에 해당하는 토큰의 레이블과 동일한 값을 가지게 됩니다. 물론 첫 번째 7에 해당하는 토큰은 B-로 시작하고 두 번째는 I-로 시작하는 레이블로 지정됩니다: def align_labels_with_tokens(labels, word_ids): new_labels = [] current_word = None for word_id in word_ids: if word_id != current_word: # 새로운 단어의 시작 토큰. current_word = word_id label = -100 if word_id is None else labels[word_id] new_labels.append(label) elif word_id is None: # 특수 토큰. new_labels.append(-100) else: # 이전 토큰과 동일한 단어에 소속된 토큰. label = labels[word_id] # 만약 레이블이 B-XXX 이면 이를 I-XXX로 변경. if label % 2 == 1: label += 1 new_labels.append(label) return new_labels 위에서 사용한 첫 번째 문장으로 이 함수를 테스트해 봅시다. labels = raw_datasets["train"][0]["ner_tags"] word_ids = inputs.word_ids() print(labels) print(align_labels_with_tokens(labels, word_ids)) 보시다시피, 함수는 시작과 끝에 두 개의 특수 토큰에 대해 -100을 추가하고 두 개의 토큰으로 분할된 토큰에 대해 0을 추가했습니다. ✏ Your turn! 일부 연구자는 단어당 하나의 레이블만 지정하고 해당 단어의 다른 하위 토큰에 -100을 할당하는 것을 선호합니다. 이는 손실(loss)에 크게 기여하는 많은 하위 토큰으로 분할되는 긴 단어를 회피하기 위함입니다. 이 규칙에 따라 레이블을 입력 ID와 정렬할 수 있도록 이전 함수를 변경해 봅시다. 전체 데이터 셋을 전처리하기 위해, 모든 입력을 토큰화하고 모든 레이블에 align_labels_with_tokens()를 적용해야 합니다. "빠른(fast)" 토크 나이저의 장점을 활용하려면 다량의 텍스트를 동시에 토큰화하는 것이 가장 좋습니다. 따라서 예제 리스트를 처리하는 함수를 작성하고 batched=True 옵션을 지정하여 Dataset.map() 메서드를 사용합니다. 이전 예제와 다른 점은 한 번에 다중 텍스트가 포함된 배치(batch)를 처리해야 하므로, word_ids() 함수의 매개변수로 현재 배치(batch)에 대한 인덱스를 매개변수로 넘겨야 한다는 것입니다. 따라서 다음과 같이 새로운 함수를 작성합니다: # examples는 단일 텍스트(문장)가 아니라 다중 텍스트임. def tokenize_and_align_labels(examples): tokenized_inputs = tokenizer( examples["tokens"], truncation=True, is_split_into_words=True ) all_labels = examples["ner_tags"] new_labels = [] for i, labels in enumerate(all_labels): word_ids = tokenized_inputs.word_ids(i) # 배치(batch) 인덱스 지정 new_labels.append(align_labels_with_tokens(labels, word_ids)) tokenized_inputs["labels"] = new_labels return tokenized_inputs 아직 입력에 대한 패딩(padding)을 수행하지 않았습니다. 나중에 데이터 콜레 이터(data collator)로 배치(batch)를 생성할 때 수행합니다. 이제 데이터 셋의 모든 분할에 대해서 한 번에 전처리를 수행할 수 있습니다: tokenized_datasets = raw_datasets.map( tokenize_and_align_labels, batched=True, remove_columns=raw_datasets["train"].column_names, ) 가장 어려운 부분을 이제 완료했습니다! 데이터가 전처리되었으므로 실제 학습은 3장에서 다뤘던 내용과 매우 유사합니다. Trainer API를 이용하여 모델 미세조정 Trainer를 활용하는 실제 코드는 이전과 동일합니다. 유일한 변경 사항은 데이터가 배치(batch)로 조합되는 방식과 메트릭(metrics) 계산 기능입니다. 데이터 콜 레이션 (Data collation) 앞서서 살펴봤던, DataCollatorWithPadding은 입력(input IDs, attention mask 및 token type IDs)에 대해서만 패딩(padding)을 수행하기 때문에 여기서는 사용할 수 없습니다. 여기서는 레이블도 입력과 똑같은 방식으로 패딩(padding)이 되어야 동일한 크기를 유지하고 -100을 패딩 값으로 사용하여 해당 예측이 손실 계산에서 무시되도록 할 수 있습니다. 이는 모두 DataCollatorForTokenClassification에 의해 수행됩니다. DataCollatorWithPadding과 마찬가지로 입력을 전처리하는 데 사용되는 tokenizer를 사용합니다: from transformers import DataCollatorForTokenClassification data_collator = DataCollatorForTokenClassification(tokenizer=tokenizer) 몇 가지 예제에서 이를 테스트하기 위해 토큰화된 학습 집합의 예제 목록을 입력으로 추가해 봅니다: batch = data_collator([tokenized_datasets["train"][i] for i in range(2)]) batch["labels"] 보다시피 두 번째 레이블 집합은 -100을 사용하여 첫 번째 레이블의 길이로 채워졌습니다. 평가 기준 (Metrics) Trainer가 매 에포크(epoch)마다 메트릭(metrics)을 계산하도록 하려면, 예측(predictions) 및 레이블(labels) 배열을 입력받아서 메트릭 이름과 해당 평가 결괏값이 포함된 딕셔너리를 반환하는 compute_metrics() 함수를 정의해야 합니다. 토큰 분류 예측을 평가하는데 많이 사용되는 전통적인 프레임워크는 seqeval입니다. 이 메트릭을 사용하려면 먼저 seqeval 라이브러리를 설치해야 합니다. 설치 시에 conda 가상환경을 사용하는 분들은 주의하시기 바랍니다. 가상환경에 seqeval을 설치하려고 하면, "conda install ..."을 사용하는 방법이 확실한데, 아나콘다에서는 seqeval을 설치할 수 없습니다. 따라서 다음과 같이 설치를 진행하셔야 합니다. # 일반적인 경우... # !pip install seqeval # 아나콘다 가상환경을 사용하는 경우... # https://stackoverflow.com/questions/59997065/pip-python-normal-site-packages-is-not-writeable/65290638 !python3 -m pip install seqeval 그런 다음 3장에서처럼 load_metric() 함수를 통해 로드할 수 있습니다: from datasets import load_metric metric = load_metric("seqeval") 이 메트릭(metric)은 우리가 일반적으로 알고 있는 표준적인 정확도(accuracy)가 아닙니다. 실제로는 레이블 목록을 정수가 아닌 문자열로 가져오므로 예측 결과와 정답 레이블을 메트릭에 전달하기 전에 디코딩 해야 합니다. 어떻게 작동하는지 봅시다. 먼저 첫 번째 학습 예제(training example)의 레이블을 가져옵니다: labels = raw_datasets["train"][0]["ner_tags"] labels = [label_names[i] for i in labels] labels 그런 다음 위 리스트의 인덱스 2에 해당하는 값("B-MISC")을 변경하여 가짜 예측을 만들 수 있습니다: predictions = labels.copy() predictions[2] = "O" metric.compute(predictions=[predictions], references=[labels]) 상당히 많은 정보가 출력됩니다. 전체뿐만 아니라 개별 개체 타입에 대한 정확도, 재현율 및 F1 점수를 구할 수 있습니다. 이제 위의 메트릭 계산 함수(metric.compute)를 활용하여 전체 점수들만 출력하도록 하겠습니다. compute_metrics() 함수를 수정하여 각자 원하는 점수들을 얻을 수 있도록 언제든지 수정 가능합니다. 아래에 구현된 compute_metrics() 함수는 먼저 로짓(logits)의 argmax를 가져와 예측(predictions)으로 변환합니다. 늘 그렇듯이, 로짓과 확률이 같은 순서이므로 softmax를 적용할 필요까지는 없습니다. 그런 다음 레이블과 예측을 정수에서 문자열로 변환해야 합니다. 레이블이 -100인 모든 값을 제거한 다음 결과를 metric.compute() 메서드에 전달합니다: import numpy as np def compute_metrics(eval_preds): logits, labels = eval_preds predictions = np.argmax(logits, axis=-1) # 무시된 인덱스(특수 토큰들)를 제거하고 레이블로 변환 true_labels = [[label_names[l] for l in label if l != -100] for label in labels] true_predictions = [ [label_names[p] for (p, l) in zip(prediction, label) if l != -100] for prediction, label in zip(predictions, labels) ] all_metrics = metric.compute(predictions=true_predictions, references=true_labels) return { "precision": all_metrics["overall_precision"], "recall": all_metrics["overall_recall"], "f1": all_metrics["overall_f1"], "accuracy": all_metrics["overall_accuracy"], } 이제 위 함수가 완성되었으므로 Trainer를 정의할 준비가 거의 완료되었습니다. 미세 조정할 model만 있으면 됩니다! 모델 정의하기 토큰 분류 문제에 대해 작업 중이므로 AutoModelForTokenClassification 클래스를 사용합니다. 이 모델을 정의할 때 기억해야 할 주요 사항은 가지고 있는 레이블 수에 대한 정보를 전달하는 것입니다. 이를 수행하는 가장 쉬운 방법은 num_labels 인수를 사용하여 해당 값을 전달하는 것이지만, 이 섹션의 시작 부분에서처럼 작동하는 멋진 추론 위젯(inference widget)을 원한다면, 올바른 레이블 대응 정보(label correspondences)를 설정하는 것이 좋습니다. ID에서 레이블로 또는 그 반대로의 매핑을 포함하는 두 개의 딕셔너리, 즉 id2label 및 label2id를 활용하여 이 대응 정보를 설정할 수 있습니다: id2label = {str(i): label for i, label in enumerate(label_names)} label2id = {v: k for k, v in id2label.items()} 이제 AutoModelForTokenClassification.from_pretrained() 메서드에 이들을 전달할 수 있으며, 모델 구성(model's configuration)에서 설정한 다음 적절하게 저장하고 허브에 업로드합니다: from transformers import AutoModelForTokenClassification model = AutoModelForTokenClassification.from_pretrained( model_checkpoint, id2label=id2label, label2id=label2id, ) 3장에서 AutoModelForSequenceClassification을 정의했을 때와 마찬가지로 모델을 생성하면 일부 가중치(사전 학습 헤드의 가중치)가 사용되지 않고 다른 가중치(새 토큰 분류 헤드의 가중치)가 무작위로 초기화된다는 경고가 발생합니다. 그리고 이 모델은 학습이 수행되어야 합니다. 잠시 후 학습을 수행하겠지만 먼저 모델에 올바른 수의 레이블이 지정되어 있는지 다시 확인하겠습니다: model.config.num_labels ⚠ 레이블 개수가 잘못 지정된 모델인 경우 나중에 Trainer.train() 메서드를 호출할 때 모호한 오류가 발생합니다(예: "CUDA error: device-side assert triggered"). 이 레이블 개수 지정 오류가 그러한 모호한 오류에 대해 사용자가 보고한 버그의 가장 큰 원인이므로 이 검사를 수행하여 예상한 수의 레이블이 있는지 확인하십시오. 모델 미세조정(fine-tuning) 하기 이제 모델을 학습할 준비가 되었습니다! Trainer를 정의하기 전에 마지막 두 가지 작업, 즉 Hugging Face에 로그인하고 학습 매개변수를 정의하는 것만 수행하면 됩니다. Jupyter Notebook에서 작업하는 경우 이를 도와주는 편리한 기능이 있습니다: from huggingface_hub import notebook_login notebook_login() 그러면 Hugging Face 로그인 자격 증명을 입력할 수 있는 위젯이 표시됩니다. 노트북에서 작업하지 않는 경우 터미널에 다음 줄을 입력하기만 하면 됩니다. huggingface-cli login 이 작업이 완료되면 TrainingArguments를 정의할 수 있습니다: from transformers import TrainingArguments args = TrainingArguments( "bert-finetuned-ner", evaluation_strategy="epoch", save_strategy="epoch", learning_rate=2e-5, num_train_epochs=3, weight_decay=0.01, push_to_hub=True, ) 대부분 이전에 보았던 것들입니다. 일부 하이퍼 파라미터(예: 학습률, 학습할 에포크 수, 가중치 감소)들을 설정했습니다. 그리고 push_to_hub=True를 지정하여 모델을 저장하고 모든 에포크가 끝날 때 모델을 평가하고 결과를 Model Hub에 업로드하려고 합니다. hub_model_id 인수를 사용하여 푸시 하려는 리포지토리의 이름을 지정할 수 있습니다. 특히, 특정 organization에 푸시 하려면 이 인수를 사용해야 합니다. 예를 들어, 모델을 huggingface-course organization에 푸시 할 때 Hub_model_id="huggingface-course/bert-finetuned-ner"를 TrainingArguments에 추가해야 합니다. 디폴트로, 사용되는 저장소는 자신의 네임스페이스에 있고 설정한 출력 디렉터리의 이름을 따서 명명되므로 이 경우에는 "sgugger/bert-finetuned-ner"가 됩니다. 사용 중인 출력 디렉터리가 이미 존재하는 경우 푸시 하려는 저장소의 로컬 복제본이어야 합니다. 그렇지 않은 경우 Trainer를 정의할 때 오류가 발생하기 때문에 새 이름을 설정해야 합니다. 마지막으로 모든 것을 Trainer에 전달하고 학습을 시작합니다: from transformers import Trainer trainer = Trainer( model=model, args=args, train_dataset=tokenized_datasets["train"], eval_dataset=tokenized_datasets["validation"], data_collator=data_collator, compute_metrics=compute_metrics, tokenizer=tokenizer, ) trainer.train() 학습이 진행되는 동안 모델이 저장될 때마다(여기서는 모든 에포크마다) 백그라운드에서 허브에 업로드됩니다. 이렇게 하면 필요한 경우 다른 서버에서 학습을 재개할 수 있습니다. 학습이 완료되면 push_to_hub() 메서드를 사용하여 모델의 최신 버전을 업로드했는지 확인합니다: trainer.push_to_hub(commit_message="Training complete") 또한 Trainer는 모든 평가 결과가 포함된 모델 카드(model card)의 초안을 작성하여 업로드합니다. 이 단계에서 Model Hub의 추론 위젯을 사용하여 모델을 테스트하고 친구와 공유할 수 있습니다. 토큰 분류 작업에서 모델을 성공적으로 미세 조정했습니다. 축하합니다! 학습 루프에 대해 좀 더 자세히 알고 싶다면 이제 Accelerate를 사용하여 동일한 작업을 수행하는 방법을 보여드리겠습니다. 사용자 정의 학습 루프 이제 전체 학습 루프(training loop)를 살펴보겠습니다. 이 코드를 활용하여 상황에 맞게 수정하여 사용할 수 있습니다. 평가에 대한 몇 가지 변경 사항을 제외하고는 3장에서 수행한 것과 매우 유사합니다. 학습을 위한 전체 준비 먼저 데이터 셋에서 DataLoader를 빌드 해야 합니다. data_collator를 collate_fn으로 재사용하고 학습 집합을 셔플링하지만 검증 집합은 셔플링하지 않습니다: from torch.utils.data import DataLoader train_dataloader = DataLoader( tokenized_datasets["train"], shuffle=True, collate_fn=data_collator, batch_size=8, ) eval_dataloader = DataLoader( tokenized_datasets["validation"], collate_fn=data_collator, batch_size=8, ) 다음으로 우리는 앞서 수행한 미세 조정을 계속해서 수행하지 않고 사전 학습된 BERT 모델에서 다시 시작하도록 모델을 다시 인스턴스화합니다: model = AutoModelForTokenClassification.from_pretrained( model_checkpoint, id2label=id2label, label2id=label2id, ) 그런 다음 최적화 함수(optimizer)가 필요합니다. Adam과 비슷하지만 가중치 감소(weight decay)가 적용되는 방식을 수정한 고전적인 AdamW를 사용할 것입니다: from torch.optim import AdamW optimizer = AdamW(model.parameters(), lr=2e-5) 위 모든 객체를 생성한 후에 이를 accelerator.prepare() 메서드로 보낼 수 있습니다: from accelerate import Accelerator accelerator = Accelerator() model, optimizer, train_dataloader, eval_dataloader = accelerator.prepare( model, optimizer, train_dataloader, eval_dataloader ) TPU에서 학습하는 경우 위의 셀에서 시작하는 모든 코드를 전용 학습 함수로 이동해야 합니다. 자세한 내용은 3장을 참조하십시오. 이제 train_dataloader를 accelerator.prepare()로 보냈으므로 그 크기(포함 개수)를 사용하여 학습 횟수(training steps)를 계산할 수 있습니다. dataloader를 생성한 후에는 항상 이 작업을 수행해야 합니다. 그 과정에서 데이터 셋의 개수를 변경하기 때문입니다. 지정된 학습률(learning rate)이 0까지 줄어드는 고전적인 선형 스케줄(linear schedule)을 사용합니다: from transformers import get_scheduler num_train_epochs = 3 num_update_steps_per_epoch = len(train_dataloader) num_training_steps = num_train_epochs * num_update_steps_per_epoch lr_scheduler = get_scheduler( "linear", optimizer=optimizer, num_warmup_steps=0, num_training_steps=num_training_steps, ) 마지막으로 모델을 Hub로 푸시 하려면 작업 폴더에 Repository 개체를 생성해야 합니다. 아직 로그인하지 않았다면 먼저 Hugging Face에 로그인하세요. 모델 ID에서 모델에 부여하려는 저장소 이름을 결정합니다. repo_name을 원하는 대로 자유롭게 바꾸셔도 됩니다. get_full_repo_name() 함수가 하는 것처럼, 사용자 이름만 포함시키면 됩니다: from huggingface_hub import Repository, get_full_repo_name model_name = "bert-finetuned-ner-accelerate" repo_name = get_full_repo_name(model_name) repo_name 그런 다음 해당 저장소를 로컬 폴더에 복제할 수 있습니다. 이미 존재하는 경우 이 로컬 폴더는 작업 중인 리포지토리의 기존 복제본이어야 합니다: output_dir = "bert-finetuned-ner-accelerate" repo = Repository(output_dir, clone_from=repo_name) 이제 repo.push_to_hub() 메서드를 호출하여 output_dir에 저장한 모든 항목들을 업로드할 수 있습니다. 이렇게 하면 각 에포크마다 그때까지 학습된 모델을 업로드하는 데 도움이 될 수 있습니다. 학습 루프 이제 전체 학습 루프를 작성할 준비가 되었습니다. 평가 부분을 단순화하기 위해 metric 객체의 입력을 구성하기 위해서 예측과 레이블을 가져와 문자열 목록으로 변환하는 다음의 postprocess() 함수를 정의합니다: def postprocess(predictions, labels): predictions = predictions.detach().cpu().clone().numpy() labels = labels.detach().cpu().clone().numpy() # Remove ignored index (special tokens) and convert to labels true_labels = [[label_names[l] for l in label if l != -100] for label in labels] true_predictions = [ [label_names[p] for (p, l) in zip(prediction, label) if l != -100] for prediction, label in zip(predictions, labels) ] return true_labels, true_predictions 이제 학습 루프를 작성해 보겠습니다. 학습 진행 방식을 표시하기 위해 진행률 표시줄(progress bar)을 정의한 후, 루프는 세 부분으로 구성됩니다: 학습(training): train_dataloader에서 반복적으로 배치(batch) 가져오기, 모델을 통한 순전파(forward pass), 역전파(backward pass) 및 최적화 단계. 평가(evaluation): 하나의 배치(batch)에서 모델의 예측 결과를 얻은 후에 다음과 같이 특수한 처리를 수행합니다. 두 개의 프로세스가 입력과 레이블을 다른 모양으로 패딩(padding) 했을 수 있으므로, gather() 메서드를 호출하기 전에 예측과 레이블을 동일한 모양으로 만들기 위해 accelerator.pad_across_processes()를 사용해야 합니다. 이렇게 하지 않으면 평가에 오류가 발생하거나 무한정 반복될 수 있습니다. 그 후, 결과를 metric.add_batch()로 보내고 평가 루프가 끝나면 metric.compute()를 호출합니다. 저장(saving) 및 업로드(uploading): 먼저 모델과 토크 나이저를 저장한 다음 repo.push_to_hub()를 호출합니다. Hub 라이브러리에 비동기 프로세스(asynchronous process)를 푸시하도록 알리기 위해 blocking=False 인수를 사용하고 있습니다. 이런 식으로 학습은 정상적으로 계속되고 이러한 (긴) 명령은 백그라운드에서 실행됩니다. 학습 루프의 전체 코드는 다음과 같습니다: from tqdm.auto import tqdm import torch progress_bar = tqdm(range(num_training_steps)) for epoch in range(num_train_epochs): # 학습 (Training) model.train() for batch in train_dataloader: outputs = model(**batch) loss = outputs.loss accelerator.backward(loss) optimizer.step() lr_scheduler.step() optimizer.zero_grad() progress_bar.update(1) # 평가 (Evaluation) model.eval() for batch in eval_dataloader: with torch.no_grad(): outputs = model(**batch) predictions = outputs.logits.argmax(dim=-1) labels = batch["labels"] # 취합 대상인 예측(predictions)과 레이블(labels)을 패딩 하기 위해서 필요함.. predictions = accelerator.pad_across_processes(predictions, dim=1, pad_index=-100) labels = accelerator.pad_across_processes(labels, dim=1, pad_index=-100) predictions_gathered = accelerator.gather(predictions) labels_gathered = accelerator.gather(labels) true_predictions, true_labels = postprocess(predictions_gathered, labels_gathered) metric.add_batch(predictions=true_predictions, references=true_labels) results = metric.compute() print( f"epoch {epoch}:", { key: results[f"overall_{key}"] for key in ["precision", "recall", "f1", "accuracy"] }, ) # 저장 및 업로드 accelerator.wait_for_everyone() unwrapped_model = accelerator.unwrap_model(model) unwrapped_model.save_pretrained(output_dir, save_function=accelerator.save) if accelerator.is_main_process: tokenizer.save_pretrained(output_dir) repo.push_to_hub( commit_message = f"Training in progress epoch {epoch}", blocking=False, ) Accelerate로 저장된 모델을 처음 접하는 경우를 대비하여 잠시 시간을 내어 위 코드에 포함된 세 줄의 코드를 살펴보겠습니다: accelerator.wait_for_everyone() unwrapped_model = accelerator.unwrap_model(model) unwrapped_model.save_pretrained(output_dir, save_function=accelerator.save) 첫 번째 줄은 설명이 필요 없습니다. 모든 프로세스가 이 지점에 도달할 때까지 기다리도록 지시합니다. 이는 저장하기 전에 모든 프로세스에서 동일한 모델이 있는지 확인하기 위한 것입니다. 그런 다음 우리가 정의한 기본 모델인 unwrapped_model을 가져옵니다. accelerator.prepare() 메서드는 모델을 분산 학습(distributed training)에서 작동하도록 변경하므로 모델에 더 이상 save_pretrained() 메서드가 없습니다. accelerator.unwrap_model() 메서드는 모델을 다시 save_pretrained()가 존재하는 일반 모델 객체로 돌려놓습니다. 마지막으로 save_pretrained()를 호출하지만 그 메서드에 torch.save() 대신 accelerate.save()를 사용하도록 지시합니다. 이 작업이 완료되면 Trainer로 학습된 것과 매우 유사한 결과를 생성하는 모델을 갖게 됩니다. 이 코드를 사용하여 학습한 모델은 huggingface-course/bert-finetuned-ner-accelerate에서 확인할 수 있습니다. 그리고 학습 루프에 대한 변경 사항을 테스트하려는 경우, 위에 표시된 코드를 편집하여 직접 구현할 수 있습니다! 미세조정된 모델 사용하기 이 섹션의 첫 부분에서 추론 위젯을 사용하여 Model Hub에서 미세 조정한 모델을 사용하는 방법을 이미 보여 주었습니다. pipeline에서 로컬로 사용하려면 적절한 모델 식별자를 지정하기만 하면 됩니다: from transformers import pipeline # 아래 내용을 본인의 checkpoint로 변경하시오. model_checkpoint = "spasis/bert-finetuned-ner" token_classifier = pipeline( "token-classification", model=model_checkpoint, aggregation_strategy="simple" ) token_classifier("My name is Sylvain and I work at Hugging Face in Brooklyn.") 좋습니다. 우리 모델은 이제 파이프라인의 기본 모델과 동일하게 작동합니다! 2. 마스크 언어 모델(Masked Language Model) 미세조정 Transformer 모델과 관련된 많은 NLP 애플리케이션의 경우, Hugging Face Hub에서 사전 학습된 모델을 가져와서 원하는 작업을 위해 데이터 셋을 이용하여 직접 미세 조정(fine-tuning) 할 수 있습니다. 사전 학습에 사용되는 말뭉치가 미세 조정에 사용되는 말뭉치와 크게 다르지 않다면 일반적으로 전이 학습(transfer learning)이 좋은 결과를 낳을 것입니다. 한편, 작업에 특화된 헤드(task-specific head)를 학습하기 전에, 먼저 보유한 데이터 셋으로 해당 언어 모델을 미세 조정(fine-tuning) 하는 경우가 있습니다. 예를 들어, 본인의 데이터 셋에 법적인 계약(legal contracts)이나 학술 논문(scientific articles) 포함된 경우 BERT와 같은 기본 Transformer 모델은 일반적으로 해당 데이터 셋에 포함된 전문 용어들을 희귀 토큰으로 취급하므로 결과 성능이 만족스럽지 않을 수 있습니다. 본인이 보유한 분야 특화 데이터를 가지고 언어 모델을 미세 조정하면 다양한 추가적 하부 작업들의 성능을 높일 수 있습니다. 그리고 일반적으로 이 미세 조정 작업은 1번만 수행하면 충분합니다! 분야 특화 데이터에 대해 사전 학습된 언어 모델을 미세 조정하는 이 프로세스를 일반적으로 도메인 어뎁테이션(domain adaptation)이라고 합니다. 이 작업은 2018년에 ULMFiT에 의해 대중화되었습니다. ULMFiT는 전이 학습(transfer learning)을 실질적으로 NLP에 적용한 최초의 신경망 아키텍처(LSTM 기반) 중 하나입니다. ULMFiT를 사용한 도메인 어뎁테이션의 예는 아래 이미지에 나와 있습니다. 이 섹션에서는 이 그림의 내용과 유사한 작업을 수행하지만 LSTM 대신 Transformer를 사용합니다! 이 섹션이 끝나면 문장을 자동 완성할 수 있는 마스크 언어 모델(masked language model)을 Hub에서 서비스할 수 있게 됩니다. 세부적으로 한번 살펴봅시다! "마스크 언어 모델링(masked language modeling)"과 "사전 학습된 모델(pretrained model)"이라는 용어가 생소하게 들린다면 1장으로 이동하여 모든 핵심 개념을 읽고 포함된<NAME>상을 시청하시기 바랍니다! 마스크 언어 모델링(MLM)을 위해 사전학습된 모델(pretrained model) 선택하기 우선 마스크 언어 모델링(masked language modeling)에 적합한 사전 학습 언어 모델을 선택해 봅시다. 다음 스크린숏과 같이 Hugging Face Hub에서 "Fill-Mask" 필터를 적용하여 후보 목록을 찾을 수 있습니다: BERT 및 RoBERTa 류의 모델들이 가장 많이 다운로드되었지만 다운스트림(downstream) 성능 손실이 거의 또는 전혀 없이 훨씬 빠르게 학습될 수 있는 DistilBERT라는 모델을 사용하겠습니다. 이 모델은 지식 증류(knowledge distillation)라고 하는 특별한 기술을 사용하여 학습되었으며, 이 기법의 특징은 BERT와 같은 큰 "교사 모델(teacher model)"이 훨씬 적은 수의 매개변수를 가진 "학생 모델(student model)"의 학습을 안내하는 데 사용된다는 것입니다. 지식 증류(knowledge distillation)의 세부 사항에 대한 설명은 여기서 다루지는 않겠습니다만, 관심이 있다면 이에 대한 모든 내용을 Natural Language Processing with Transformers(Transformers를 사용한 자연어 처리)에서 읽을 수 있습니다. AutoModelForMaskedLM 클래스를 사용하여 DitilBERT를 다운로드해 보겠습니다: from transformers import AutoModelForMaskedLM model_checkpoint = "distilbert-base-uncased" model = AutoModelForMaskedLM.from_pretrained(model_checkpoint) num_parameters() 메서드를 호출하여 이 모델에 몇 개의 매개변수가 있는지 확인할 수 있습니다: distilbert_num_parameters = model.num_parameters() / 1_000_000 print(f"'>>> DistilBERT number of parameters: {round(distilbert_num_parameters)}M'") print(f"'>>> BERT number of parameters: 110M'") 약 6,700만 개의 매개변수가 있는 DistilBERT는 BERT 기본 모델보다 약 2배 작으며 따라서 학습 시간이 2배 빠를 수 있다는 것을 알 수 있겠지요. 이제 아래의 작은 텍스트 샘플을 채우기 위해서 모델이 어떤 토큰을 제시하는지 알아봅시다: text = "This is a great [MASK]." 우리는 "날(day)", "놀이 기구(ride)", "painting(그림)"과 같은 [MASK] 토큰을 채울 수 있는 다양한 단어들을 상상할 수 있겠지요. 사전 학습된 모델의 경우 예측은 해당 모델이 학습된 코퍼스에 따라 달라집니다. 모델이 데이터에 있는 통계적 패턴을 선택하는 방법을 배우기 때문입니다. BERT와 마찬가지로 DistilBERT는 영어 Wikipedia 및 BookCorpus 데이터 셋을 바탕으로 사전 학습되었으므로 [MASK]에 대한 예측이 이러한 도메인을 반영할 것으로 예상합니다. 마스크 토큰을 예측하려면 모델에 대한 입력을 생성하기 위해 DistilBERT의 토크 나이저가 필요하므로 허브에서도 다운로드해 보겠습니다: from transformers import AutoTokenizer tokenizer = AutoTokenizer.from_pretrained(model_checkpoint) 토크 나이저와 모델을 사용하여 이제 텍스트 예제를 모델에 전달하고 로짓(logits)을 추출하고 상위 5개 후보를 출력할 수 있습니다: import torch inputs = tokenizer(text, return_tensors="pt") token_logits = model(**inputs).logits # [MASK]의 위치를 찾고, 해당 logits을 추출합니다. mask_token_index = torch.where(inputs["input_ids"] == tokenizer.mask_token_id)[1] mask_token_logits = token_logits[0, mask_token_index, :] # 가장 큰 logits 값을 가지는 [MASK] 후보를 선택합니다. top_5_tokens = torch.topk(mask_token_logits, 5, dim=1).indices[0].tolist() for token in top_5_tokens: print(f"'>>> {text.replace(tokenizer.mask_token, tokenizer.decode([token]))}'") 우리는 모델의 예측이 일상적인 용어를 도출한다는 것을 출력에서 볼 수 있습니다. 이는 영어 Wikipedia의 내용을 고려할 때 놀라운 일이 아닙니다. 이러한 특성을 좀 더 세부적이고 전문적으로 변화시키는 방법을 알아봅시다. 이제 극도로 양극화된(polarized) 영화 리뷰(movie reviews)를 사용할 것입니다! 데이터 셋 도메인 어뎁테이션(domain adaptation) 과정을 보여주기 위해서, 감정 분석 모델을 벤치마킹하는데 자주 사용되는 영화 리뷰 모음인 유명한 Large Movie Review Dataset(또는 줄여서 IMDb)를 사용합니다. 이 말뭉치를 이용하여 DitilBERT를 미세 조정함으로써 언어 모델이 사전 학습된 Wikipedia의 사실적인 데이터에서 영화 리뷰의 보다 주관적인 요소에 맞게 어휘를 조정할 것으로 기대합니다. Datasets의 load_dataset() 함수를 사용하여 Hugging Face Hub에서 데이터를 가져올 수 있습니다: from datasets import load_dataset imdb_dataset = load_dataset("imdb") imdb_dataset train 및 test 분할(splits)은 각각 25,000개의 리뷰로 구성되어 있는 반면 unsupervised라고 명명된 레이블이 지정되지 않은 분할에는 50,000개의 리뷰가 포함되어 있습니다. 어떤 종류의 텍스트를 다루고 있는지 알아보기 위해 몇 가지 샘플을 살펴보겠습니다. 이전 장에서 했던 것처럼 Dataset.shuffle() 및 Dataset.select() 함수를 연결하여 임의의 샘플을 만듭니다: sample = imdb_dataset["train"].shuffle(seed=42).select(range(3)) for row in sample: print(f"\n'>>> Review: {row['text']}'") print(f"'>>> Label: {row['label']}'") 결과를 보면 알겠지만, 실제로 영화 리뷰들입니다. 언어 모델링에 레이블이 필요하지는 않지만 0은 부정적인 리뷰를 나타내고 1은 긍정적인 리뷰를 나타냅니다. ✏ Try it out! unsupervised 분할의 무작위 샘플을 만들고 레이블이 0도 1도 아닌지 확인해 봅시다. 이 작업을 수행하는 동안 train 및 test 분할의 레이블이 실제로 0 또는 1인지 확인할 수도 있습니다. 이는 모든 NLP 실무자가 새 프로젝트를 시작할 때 수행해야 하는 데이터에 대한 완전성 검사(sanity check)입니다! 데이터를 간단히 살펴보았으므로 이제 마스크 언어 모델링을 위해 데이터를 준비하는 방법에 대해 알아보겠습니다. 우리가 보게 되겠지만, 3장에서 살펴본 시퀀스 분류 작업과는 달리 추가적으로 수행해야 하는 몇 가지 단계가 있습니다. 데이터 전처리 자동 회귀 모델링(auto-regressive modeling) 및 마스크 언어 모델링(masked language modeling) 모두에서 공통적인 전처리 단계는 모든 예제를 통합한 다음 전체 말뭉치를 동일한 크기의 청크로 분할하는 것입니다. 이는 개별 예제를 단순히 토큰화하는 일반적인 접근 방식과 매우 다릅니다. 그렇다면 왜 모든 것을 하나로 통합해야 하는 것일까요? 그 이유는 개별 예제가 너무 길면 절단되어서, 언어 모델링 작업에 유용할 수 있는 정보가 손실될 수 있기 때문입니다! 따라서 먼저 이전과 동일하게 말뭉치를 토큰화하지만 토크 나이저에서 truncation=True 옵션을 설정하지 않습니다. 가능한 경우 동일하게 word_ids를 가져올 것입니다(6장에서 설명한 대로 빠른 토크 나이저를 사용하는 경우 단어 ID는 전체 단어 마스킹을 수행하기 위해 나중에 필요하기 때문입니다). 이 과정을 수행하는 간단한 함수를 만들고, 전체 데이터 셋에 대해서 토크나이징을 수행한 뒤에는(엄밀히 따지면 토크나이징 수행 과정에서) 더 이상 불필요한 text와 label 열을 제거할 것입니다: def tokenize_function(examples): result = tokenizer(examples["text"]) if tokenizer.is_fast: result["word_ids"] = [result.word_ids(i) for i in range(len(result["input_ids"]))] return result # 빠른 멀티스레딩을 작동시키기 위해서, batched=True를 지정합니다. tokenized_datasets = imdb_dataset.map( tokenize_function, batched=True, remove_columns=["text", "label"] ) tokenized_datasets DistilBERT는 BERT와 유사한 모델이기 때문에 인코딩된 텍스트는 새롭게 추가된 word_ids뿐만 아니라 이전 장에서 본 input_ids 및 attention_mask로 구성되어 있음을 알 수 있습니다. 이제 영화 리뷰 데이터 셋 전체를 토큰화했으므로 다음 단계는 모든 리뷰를 하나로 결합하고 그 결과를 청크(chunk)로 나누는 것입니다. 그런데 이 청크는 얼마나 커야 할까요? 이것은 궁극적으로 사용 가능한 GPU 메모리의 양에 따라 결정되지만 좋은 출발점은 모델의 최대 컨텍스트 크기가 얼마인지 확인하는 것입니다. 이는 토크 나이저의 model_max_length 속성을 확인하여 알 수 있습니다: tokenizer.model_max_length 이 값은 체크포인트와 연결된 tokenizer_config.json 파일에 지정되어 있습니다. 이 경우 컨텍스트 크기가 BERT와 마찬가지로 512 토큰임을 알 수 있습니다. ✏ Try it out! BigBird 및 Longformer와 같은 일부 Transformer 모델은 BERT 및 기타 초기 Transformer 모델보다 컨텍스트 길이가 훨씬 더 깁니다. 이러한 체크포인트 중 하나에 대해 토크 나이저를 인스턴스화하고 model_max_length가 모델 카드에 인용된 내용과 일치하는지 확인해 봅시다. 따라서 Google Colab에서 제공하는 것과 같은 GPU에서 실험을 실행하기 위해 메모리에 들어갈 수 있는 약간 작은 수치를 선택합니다: chunk_size = 128 청크 크기를 작게 지정하는 것이 실제 실행 시나리오에서는 불이익을 가져올 수 있으므로 모델을 적용할 사용 사례에 해당하는 크기를 사용하는 것이 타당합니다. 이제 재미있는 부분이 나옵니다. 데이터 결합 과정을 보여주기 위해 토큰화된 학습 집합에서 몇몇 리뷰를 가져와서 리뷰당 토큰 수를 인쇄해 보겠습니다: # Slicing produces a list of lists for each feature tokenized_samples = tokenized_datasets["train"][:3] for idx, sample in enumerate(tokenized_samples["input_ids"]): print(f"'>>> Review {idx} length: {len(sample)}'") 위에서 만들어진 tokenized_samples를 간단한 딕셔너리 내포(dictionary comprehension) 문으로 다음과 같이 결합시킬 수 있습니다: concatenated_examples = { k: sum(tokenized_samples[k], []) for k in tokenized_samples.keys() } total_length = len(concatenated_examples["input_ids"]) print(f"'>>> Concatenated reviews length: {total_length}'") 좋습니다. 전체 길이가 확인되었습니다. 이제 연결된 리뷰를 block_size로 지정된 크기의 청크로 분할하겠습니다. 그러기 위해 concatenated_examples의 내용(자질, feature)을 반복하고 리스트 내포(list comprehension) 문을 사용하여 내용(자질, feature)들의 슬라이스들을 만듭니다. 결과는 각 자질(feature)에 대한 청크 딕셔너리입니다: chunks = { k: [t[i : i + chunk_size] for i in range(0, total_length, chunk_size)] for k, t in concatenated_examples.items() } for chunk in chunks["input_ids"]: print(f"'>>> Chunk length: {len(chunk)}'") 이 예에서 볼 수 있듯이 마지막 청크는 일반적으로 최대 청크 크기보다 작습니다. 이를 처리하기 위한 두 가지 주요 전략이 있습니다: chunk_size보다 작은 경우 마지막 청크를 삭제합니다. 길이가 chunk_size와 같아질 때까지 마지막 청크를 채웁니다(padding). 여기서는 첫 번째 접근 방식을 사용하므로 위에서 예제에 대해 적용된 모든 로직들을 토큰화된 데이터 셋에 적용할 수 있는 단일 함수로 구성하겠습니다: def group_texts(examples): # 모든 텍스트들을 결합한다. concatenated_examples = {k: sum(examples[k], []) for k in examples.keys()} # 결합된 텍스트들에 대한 길이를 구한다. total_length = len(concatenated_examples[list(examples.keys())[0]]) # `chunk_size`보다 작은 경우 마지막 청크를 삭제 total_length = (total_length // chunk_size) * chunk_size # max_len 길이를 가지는 chunk 단위로 슬라이스 result = { k: [t[i : i + chunk_size] for i in range(0, total_length, chunk_size)] for k, t in concatenated_examples.items() } # 새로운 레이블 칼럼을 생성 result["labels"] = result["input_ids"].copy() return result group_texts()의 마지막 단계에서 input_ids 열의 복사본인 새 labels 열을 만듭니다. 곧 보게 되겠지만, 마스크 된 언어 모델링의 목표는 입력 배치(batch)에서 무작위로 마스킹 된 토큰을 예측하는 것이고 labels 열을 생성하여 언어 모델이 학습할 정답(ground truth)을 제공하기 때문입니다. 이제 Dataset.map() 함수를 사용하여 토큰화된 데이터 셋에 group_text()를 적용해 보겠습니다: lm_datasets = tokenized_datasets.map(group_texts, batched=True) lm_datasets 텍스트를 그룹화한 다음 청크화하면 train 및 test 분할에 대해 원래 25,000개보다 훨씬 더 많은 예제가 생성되었음을 알 수 있습니다. 이는 이제 원본 말뭉치의 여러 예제에 걸쳐 있는 연속된 토큰들(contiguous tokens)에 의한 예제가 포함되어 있기 때문입니다. 청크 중 하나에서 특수 토큰인 [SEP] 및 [CLS] 토큰을 찾아 이를 명시적으로 볼 수 있습니다: tokenizer.decode(lm_datasets["train"][1]["input_ids"]) 이 예에서 두 개의 겹치는 영화 리뷰를 볼 수 있습니다. 마스크 된 언어 모델링의 레이블이 어떻게 보이는지 확인해 보겠습니다: tokenizer.decode(lm_datasets["train"][1]["labels"]) 위의 group_text() 함수에서 예상한 대로 디코딩 된 input_ids와 동일하게 보입니다. 그러면 우리 모델이 어떻게 무언가를 학습할 수 있을까요? 중요한 단계를 하나 빼먹었습니다. 바로 [MASK] 토큰을 입력의 임의 위치에 삽입하는 것입니다! 특수 데이터 수집기(data collator)를 사용하여 미세 조정 중에 이 작업을 즉석에서 수행하는 방법을 살펴보겠습니다. Trainer API를 이용하여 DistilBERT 미세조정 마스크 언어 모델을 미세 조정하는 것은 3장에서 했던 것처럼 시퀀스 분류 모델을 미세 조정하는 것과 거의 동일합니다. 유일한 차이점은 텍스트의 각 배치(batch)에서 일부 토큰을 무작위로 마스킹 할 수 있는 특수 데이터 수집기가 필요하다는 것입니다. 다행히 Transformers는 이 작업을 위한 전용 DataCollatorForLanguageModeling 클래스를 가지고 있습니다. 우리는 토큰화와 마스킹 할 토큰의 비율을 지정하는 mlm_probability 인수를 전달하기만 하면 됩니다. 여기서는 15%로 지정해 보겠습니다. 이것은 BERT에 사용되는 수치이며 논문에서 일반적으로 사용하는 수치입니다: from transformers import DataCollatorForLanguageModeling data_collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm_probability=0.15) 무작위 마스킹(random masking)이 어떻게 작동하는지 보기 위해 data_collator에 몇 가지 예시를 입력해 보겠습니다. data_collator가 연속 텍스트의 단일 청크를 나타내는 dict의 리스트인 dicts를 요구하기 때문에 배치를 collator에 공급하기 전에 먼저 데이터 셋을 반복합니다. data_collator의 입력으로 word_ids 키는 불필요하므로 이를 제거합니다: samples = [lm_datasets["train"][i] for i in range(2)] for sample in samples: _ = sample.pop("word_ids") for chunk in data_collator(samples)["input_ids"]: print(f"\n'>>> {tokenizer.decode(chunk)}'") 좋습니다. 제대로 동작하는군요! [MASK] 토큰이 텍스트의 다양한 위치에 무작위로 삽입된 것을 볼 수 있습니다. 이것들은 우리 모델이 학습 과정에서 예측해야 하는 토큰이 될 것입니다. 데이터 콜레 이터(data collator)의 장점은 배치마다 [MASK] 삽입이 무작위화된다는 것입니다! ✏ Try it out! 위의 코드를 여러 번 실행하여 눈앞에서 무작위 마스킹이 실행되는 것을 확인하십시오! 또한 tokenizer.decode() 메서드를 tokenizer.convert_ids_to_tokens()로 교체하여 때때로 주어진 단어의 단일 토큰이 마스킹 되고 다른 토큰은 마스킹 되지 않는지 확인합니다. 무작위 마스킹의 한 가지 부작용은 학습 및 테스트 집합에 대해 동일한 데이터 콜레 이터(data collator)를 사용하기 때문에 Trainer를 사용할 때 평가 메트릭이 결정적이지 않다는 것입니다. 나중에 우리가 Accelerate로 미세 조정을 할 때 사용자 지정 평가 루프의 유연성을 사용하여 임의성을 고정하는 방법을 알아보겠습니다. 마스킹 된 언어 모델링을 위해 모델을 학습할 때 사용할 수 있는 한 가지 기법은 개별 토큰뿐만 아니라 전체 단어를 함께 마스킹 하는 것입니다. 이 접근 방식을 전체 단어 마스킹(whole word masking)이라고 합니다. 전체 단어 마스킹을 사용하려면 데이터 콜레 이터(data collator)를 직접 구현해야 합니다. 데이터 콜레 이터는 샘플 목록을 가져와 일괄 처리로 변환하는 함수일 뿐입니다. 이제 이를 구현해 보겠습니다. 이전에 계산된 단어 ID들을 사용하여 단어 인덱스와 해당 토큰 사이의 맵을 만든 다음 마스크 할 단어를 무작위로 결정하고 입력에 해당 마스크를 적용합니다. 레이블은 마스크 단어에 해당하는 레이블을 제외하고 모두 -100입니다. import collections import numpy as np from transformers import default_data_collator wwm_probability = 0.2 def whole_word_masking_data_collator(features): for feature in features: word_ids = feature.pop("word_ids") # 단어와 해당 토큰 인덱스 간의 map 생성 mapping = collections.defaultdict(list) current_word_index = -1 current_word = None for idx, word_id in enumerate(word_ids): if word_id is not None: if word_id != current_word: current_word = word_id current_word_index += 1 mapping[current_word_index].append(idx) # 무작위로 단어 마스킹 mask = np.random.binomial(1, wwm_probability, (len(mapping),)) input_ids = feature["input_ids"] labels = feature["labels"] new_labels = [-100] * len(labels) for word_id in np.where(mask)[0]: word_id = word_id.item() for idx in mapping[word_id]: new_labels[idx] = labels[idx] input_ids[idx] = tokenizer.mask_token_id return default_data_collator(features) 다음으로 이전과 동일한 샘플에서 위 함수를 테스트해 볼 수 있습니다: samples = [lm_datasets["train"][i] for i in range(2)] batch = whole_word_masking_data_collator(samples) for chunk in batch["input_ids"]: print(f"\n'>>> {tokenizer.decode(chunk)}'") ✏ Try it out! 위의 코드 조각을 여러 번 실행하여 눈앞에서 무작위 마스킹이 발생하는 것을 확인하십시오! 또한 tokenizer.decode() 메서드를 tokenizer.convert_ids_to_tokens()로 교체하여 주어진 단어의 토큰이 항상 함께 마스킹 되는지 확인합니다. 이제 두 개의 데이터 콜레 이터가 있으므로 나머지 미세 조정 단계는 동일합니다. 운이 좋지 않은 경우 Google Colab에서 학습하는 데 시간이 걸릴 수 있습니다. 따라서 먼저 학습 집합의 크기를 수천 개의 예제 정도로 다운 샘플링하겠습니다. 걱정하지 마세요. 그래도 우리는 여전히 꽤 괜찮은 언어 모델을 얻을 것입니다! Datasets에서 데이터 셋을 다운 샘플링하는 빠른 방법은 5장에서 본 Dataset.train_test_split() 함수를 사용하는 것입니다: train_size = 10_000 test_size = int(0.1 * train_size) downsampled_dataset = lm_datasets["train"].train_test_split( train_size=train_size, test_size=test_size, seed=42 ) downsampled_dataset 위 코드는 학습 집합 크기가 10,000개의 예제로 설정되고 테스트 집합이 그중 10%로 설정된 새로운 학습 및 테스트 분할을 자동으로 생성했습니다. 강력한 GPU가 있는 경우 자유롭게 늘리십시오! 다음으로 해야 할 일은 Hugging Face Hub에 로그인하는 것입니다. 노트북에서 이 코드를 실행하는 경우 다음 유틸리티 함수를 사용하여 실행할 수 있습니다 from huggingface_hub import notebook_login notebook_login() 자격 증명을 입력할 수 있는 위젯이 표시됩니다. 또는 "huggingface-cli login" 명령어를 터미널에서 실행하여 로그인할 수도 있습니다. 일단 로그인하면 Trainer에 대한 인수를 지정할 수 있습니다: from transformers import TrainingArguments batch_size = 64 # Show the training loss with every epoch logging_steps = len(downsampled_dataset["train"]) // batch_size model_name = model_checkpoint.split("/")[-1] training_args = TrainingArguments( output_dir=f"{model_name}-finetuned-imdb", overwrite_output_dir=True, evaluation_strategy="epoch", learning_rate=2e-5, weight_decay=0.01, per_device_train_batch_size=batch_size, per_device_eval_batch_size=batch_size, push_to_hub=True, fp16=True, logging_steps=logging_steps, ) 여기에서 logging_steps를 포함하여 몇 가지 기본 옵션을 조정하여 각 에포크에서 학습 손실을 추적할 수 있도록 했습니다. 또한 fp16=True를 사용하여 혼합 정밀도 훈련을 활성화하여 속도를 한 번 더 향상시켰습니다. hub_model_id 인수를 사용하여 푸시 하려는 리포지토리의 이름을 지정할 수 있습니다(특히, 특정 조직에 푸시 하려면 이 인수를 사용해야 함). 예를 들어, 모델을 huggingface-course organization에 푸시 할 때 Hub_model_id="huggingface-course/distilbert-finetuned-imdb"를 TrainingArguments에 추가했습니다. 기본적으로 사용되는 저장소는 네임스페이스에 있고 설정한 출력 디렉터리의 이름을 따서 명명되므로 이 경우에는 "spasis/distilbert-finetuned-imdb"가 됩니다. 이제 Trainer를 인스턴스화하기 위한 모든 준비 작업이 끝났습니다. 여기에서는 표준 data_collator를 사용하지만 전체 단어 마스킹(whole word masking) 콜레 이터를 사용해 보고 그 결과를 비교해 볼 수도 있습니다: from transformers import Trainer trainer = Trainer( model=model, args=training_args, train_dataset=downsampled_dataset["train"], eval_dataset=downsampled_dataset["test"], data_collator=data_collator, ) 이제 trainer.train()을 실행할 준비가 되었습니다. 하지만 그전에 언어 모델의 성능을 평가하는 일반적인 지표인 perplexity에 대해 간단히 살펴보겠습니다. 언어 모델을 위한 Perplexity 학습할 레이블이 표기된 말뭉치가 제공되는 텍스트 분류(text classification) 또는 질의응답(question answering)과 같은 작업과 달리, 언어 모델링에는 명시적 레이블이 없습니다. 그렇다면 무엇이 좋은 언어 모델을 만드는지 어떻게 결정할까요? 휴대전화의 자동 고침 기능과 마찬가지로 좋은 언어 모델은 문법적으로 정확한 문장에 높은 확률을 할당하고 말도 안 되는 문장에 낮은 확률을 할당하는 모델입니다. 이 말도 안 되는 문장이 어떻게 생겼는지에 대한 더 나은 아이디어를 제공하기 위해 온라인에서 "자동 고침 실패(autocorrect fails)"의 전체 데이터 셋을 찾을 수 있습니다. 이 데이터 셋에는 사람의 전화에 있는 모델이 다소 웃기고 종종 부적절한 문장을 생성한 예시들을 볼 수 있습니다. 테스트 셋이 대부분 문법적으로 올바른 문장으로 구성되어 있다고 가정하면 언어 모델의 품질을 측정하는 한 가지 방법은 테스트셋의 모든 문장에서 다음 단어에 할당할 확률을 계산하는 것입니다. 높은 확률은 모델이 새로운 예시에 "놀라거나(surprised)" "당황하지(perplexed)" 않았음을 나타내며 언어의 기본 문법 패턴을 학습했음을 나타냅니다. 이 perplexity에 대한 다양한 수학적 정의가 있지만 우리가 사용할 것은 교차 엔트로피 손실(cross-entropy loss)의<NAME>(exponential)로 정의합니다. 따라서 Trainer.evaluate() 함수를 사용하여 테스트셋에 대한 교차 엔트로피 손실을 계산한 다음<NAME>를 취하여 사전 학습된 모델의 복잡도를 계산할 수 있습니다: import math eval_results = trainer.evaluate() print(f">>> Perplexity: {math.exp(eval_results['eval_loss']):.2f}") 낮은 perplexity 점수는 더 나은 언어 모델을 의미하며, 여기서 우리의 시작 모델이 다소 큰 점수를 가지고 있음을 알 수 있습니다. 미세 조정으로 이 점수를 낮출 수 있는지 봅시다! 이를 위해 먼저 학습 루프를 실행합니다: trainer.train() 그런 다음 이전과 같이 테스트셋에 대해 perplexity 점수를 계산합니다: eval_results = trainer.evaluate() print(f">>> Perplexity: {math.exp(eval_results['eval_loss']):.2f}") 좋습니다! Perplexity 점수가 많이 낮아졌습니다. 이는 모델이 영화 리뷰 도메인에 대해서 무언가를 배웠다는 의미입니다. 학습이 끝나면 학습 정보가 있는 모델 카드를 Hub로 푸시 할 수 있습니다(체크포인트는 학습 중에 저장됨): trainer.push_to_hub() ✏ Your turn! 데이터 콜레 이터를 전체 워드 마스킹(whole word masking) 콜레 이터로 변경한 후 위의 학습을 실행해 보세요. 더 나은 결과를 얻을까요? 지금까지 살펴본 사례에서는 학습 루프로 특별한 작업을 수행할 필요가 없었지만 어떤 경우에는 일부 사용자 정의 로직을 구현해야 할 수도 있습니다. Accelerate를 사용하는 예가 그것이죠. 한번 살펴봅시다! Accelerate를 활용한 DistilBERT 미세조정 Trainer에서 보았듯이 마스크 언어 모델을 미세 조정하는 것은 3장의 텍스트 분류 예제와 매우 유사합니다. 사실, 유일한 차이점은 특별한 데이터 콜레 이터(data collator)의 사용이며, 이미 이 섹션의 앞부분에서 다루었습니다! 그러나 DataCollatorForLanguageModeling이 모델 평가(evaluation) 과정에서 무작위 마스킹(random masking)도 적용한다는 것을 확인했습니다. 따라서 각 학습 실행에서 perplexity 점수에 약간의 변동이 있을 것입니다. 이 무작위성의 원인을 제거하는 한 가지 방법은 전체 테스트 집합에 대해서 마스킹을 한 번만 적용한 다음 Transformers의 기본 데이터 콜레 이터를 사용하여 평가를 진행하는 것입니다. 이를 어떻게 적용하는지 보기 위해 DataCollatorForLanguageModeling를 처음 접했을 때와 유사하게 개별 배치(batch)에 마스킹을 적용하는 간단한 함수를 구현해 보겠습니다: def insert_random_mask(batch): features = [dict(zip(batch, t)) for t in zip(*batch.values())] masked_inputs = data_collator(features) # 데이터 셋의 각 칼럼에 대해서 새로운 "masked" 칼럼을 생성 return {"masked_" + k: v.numpy() for k, v in masked_inputs.items()} 다음으로 이 함수를 테스트 집합에 적용하고 마스크 되지 않은 열을 삭제하여 마스크 된 열로 교체합니다. 위의 data_collator를 적절한 대체 함수로 교체하여 전체 단어 마스킹을 사용할 수 있습니다. 이 경우 아래 코드 중에서 첫 번째 라인을 제거해야 합니다: downsampled_dataset = downsampled_dataset.remove_columns(["word_ids"]) eval_dataset = downsampled_dataset["test"].map( insert_random_mask, batched=True, remove_columns=downsampled_dataset["test"].column_names, ) eval_dataset = eval_dataset.rename_columns( { "masked_input_ids": "input_ids", "masked_attention_mask": "attention_mask", "masked_labels": "labels", } ) 그런 다음 이전과 같이 dataloaders를 설정할 수 있지만 단, 평가 집합에 대해 Transformers의 default_data_collator를 사용합니다: from torch.utils.data import DataLoader from transformers import default_data_collator batch_size = 64 train_dataloader = DataLoader( downsampled_dataset["train"], shuffle=True, batch_size=batch_size, collate_fn=data_collator, ) eval_dataloader = DataLoader( eval_dataset, batch_size=batch_size, collate_fn=default_data_collator ) 여기서부터는 Accelerate의 표준 단계를 따릅니다. 첫 번째 단계는 사전 학습된 모델의 새로운 버전을 로드하는 것입니다: model = AutoModelForMaskedLM.from_pretrained(model_checkpoint) 그런 다음 옵티마이저(optimizer)를 지정해야 합니다. 우리는 표준 AdamW를 사용할 것입니다: from torch.optim import AdamW optimizer = AdamW(model.parameters(), lr=5e-5) 이제 Accelerator 객체를 가지고 학습할 모든 준비가 끝났습니다: from accelerate import Accelerator accelerator = Accelerator() model, optimizer, train_dataloader, eval_dataloader = accelerator.prepare( model, optimizer, train_dataloader, eval_dataloader ) 이제 모델, 옵티마이저 및 dataloaders가 구성되었으므로 다음과 같이 학습률 스케줄러를 지정할 수 있습니다: from transformers import get_scheduler num_train_epochs = 3 num_update_steps_per_epoch = len(train_dataloader) num_training_steps = num_train_epochs * num_update_steps_per_epoch lr_scheduler = get_scheduler( "linear", optimizer=optimizer, num_warmup_steps=0, num_training_steps=num_training_steps, ) 학습 전에 마지막으로 해야 할 일이 있습니다: Hugging Face Hub에 모델 리포지토리를 생성하세요! Hub 라이브러리를 사용하여 먼저 저장소의 전체 이름을 생성할 수 있습니다: from huggingface_hub import get_full_repo_name model_name = "distilbert-base-uncased-finetuned-imdb-accelerate" repo_name = get_full_repo_name(model_name) repo_name 그런 다음 Hub의 Repository 클래스를 사용하여 저장소를 만들고 복제합니다: from huggingface_hub import Repository import os os.environ["TOKENIZERS_PARALLELISM"] = "false" output_dir = model_name repo = Repository(output_dir, clone_from=repo_name) 위 작업이 완료되었다면 전체 학습 및 평가 루프를 작성하기만 하면 됩니다: from tqdm.auto import tqdm import torch import math progress_bar = tqdm(range(num_training_steps)) for epoch in range(num_train_epochs): # 학습 model.train() for batch in train_dataloader: outputs = model(**batch) loss = outputs.loss accelerator.backward(loss) optimizer.step() lr_scheduler.step() optimizer.zero_grad() progress_bar.update(1) # 평가 model.eval() losses = [] for step, batch in enumerate(eval_dataloader): with torch.no_grad(): outputs = model(**batch) loss = outputs.loss losses.append(accelerator.gather(loss.repeat(batch_size))) losses = torch.cat(losses) losses = losses[: len(eval_dataset)] try: perplexity = math.exp(torch.mean(losses)) except OverflowError: perplexity = float("inf") print(f">>> Epoch {epoch}: Perplexity: {perplexity}") # Save and upload accelerator.wait_for_everyone() unwrapped_model = accelerator.unwrap_model(model) unwrapped_model.save_pretrained(output_dir, save_function=accelerator.save) if accelerator.is_main_process: tokenizer.save_pretrained(output_dir) repo.push_to_hub( commit_message = f"Training in progress epoch {epoch}", blocking=False ) 좋습니다. 우리는 각 에포크의 perplexity를 평가하고 다중 학습 실행이 재현될 수 있는지를 확인할 수 있었습니다. 미세조정된 모델 사용하기 우리가 도출한 미세 조정 완료된 모델을 Hub에서 위젯을 사용하거나 Transformers의 pipeline을 통해 로컬로 상호 작용할 수 있습니다. 후자를 사용하여 fill-mask 파이프라인을 사용하여 모델을 다운로드하겠습니다: from transformers import pipeline mask_filler = pipeline( "fill-mask", model="huggingface-course/distilbert-base-uncased-finetuned-imdb" ) 그런 다음 파이프라인에 "This is a great [MASK]"라는 샘플 텍스트를 제공하고 상위 5개 예측이 무엇인지 확인할 수 있습니다: text = "This is a great [MASK]" preds = mask_filler(text) for pred in preds: print(f">>> {pred['sequence']}") 우리 모델은 영화와 더 밀접하게 관련된 단어를 예측하기 위해 가중치를 명확하게 조정했습니다! 이것으로 언어 모델 학습에 대한 첫 번째 실험을 마칩니다. 섹션 6에서는 GPT-2와 같은 자동 회귀 모델을 처음부터 학습하는 방법을 배웁니다. 자신만의 Transformer 모델을 사전 학습시키는 방법을 알고 싶다면 참고하기 바랍니다. ✏ Try it out! 도메인 어뎁테이션의 장점을 정량적으로 확인하기 위해서 사전 학습된 DistilBERT 체크포인트와 미세 조정된 DistilBERT 체크포인트 모두에 대해 IMDb 레이블 분류기를 미세 조정해 보세요. 텍스트 분류에 대한 복습이 필요하면 3장을 확인하십시오. 3. 번역 (Translation) 이제 번역(translation)에 대해서 알아봅시다. 이것은 또 다른 형태의 sequence-to-sequence 태스크입니다. 즉, 한 시퀀스에서 다른 시퀀스로 이동하는(변형하는) 것으로 공식화할 수 있는 문제입니다. 그런 의미에서 이 문제는 요약(summarization)과 매우 유사하고 여기에서 보게 될 내용을 다음과 같은 다른 sequence-to-sequence 문제에 적용할 수 있습니다: 스타일 트랜스퍼(style transfer): 특정 스타일로 작성된 텍스트를 다른 스타일로 번역하는 모델 생성(예: 격식 스타일에서 캐주얼 스타일로 또는 셰익스피어 영어에서 현대 영어로) 생성 기반 질의응답(generative question answering): 주어진 맥락(context)에서 질문에 대한 답변을 생성하는 모델 만들기 두 개(또는 그 이상) 언어로 된 충분히 큰 텍스트 코퍼스가 있는 경우 인과적 언어 모델링(causal language modeling) 섹션에서 하는 것처럼 처음부터 새로운 번역 모델을 학습할 수 있습니다. 그러나 일정 규모의 특정 언어로 표현된 말뭉치를 가지고 mT5나 mBART 등과 같은 이미 존재하는 다국어 번역 모델을 미세 조정하는 편이 훨씬 빠를 겁니다. 이 섹션에서는 KDE 앱용으로 현지화된 파일 데이터 셋인 KDE4 데이터 셋을 이용하여 영어에서 프랑스어로 번역하도록 사전 학습된 Marian 모델을 미세 조정할 것입니다. 우리가 사용할 모델은 실제로 KDE4 데이터 셋이 포함된 Opus 데이터 셋에서 가져온 대규모 프랑스어 및 영어 텍스트 코퍼스에서 사전 학습되었습니다. 그러나 우리가 사용하는 사전 학습된 모델이 학습 과정에서 해당 데이터 셋을 이미 학습했다고 하더라도 미세 조정 후에 더 나은 버전을 얻을 수 있음을 알 수 있습니다. 완료되면 다음과 같은 예측을 할 수 있는 모델을 도출할 수 있습니다: 이전 섹션에서와 같이 아래 코드를 사용하여 학습하고 Hub에 업로드할 실제 모델을 찾고 여기에서 예측 결과를 다시 확인할 수 있습니다. 데이터 준비 번역 모델을 미세 조정하거나 처음부터 사전 학습하려면 작업에 적합한 데이터 셋이 필요합니다. 이전에 언급했듯이 이 섹션에서는 KDE4 데이터 셋을 사용하지만 번역하려는 두 언어의 문장 쌍이 있는 한 자체 데이터를 사용하도록 코드를 매우 쉽게 조정할 수 있습니다. Dataset을 이용하여 사용자 정의 데이터를 로드하는 방법에 대한 복습이 필요한 경우 5장을 다시 살펴보세요. KDE4 데이터 셋 이전과 같이 load_dataset() 함수를 사용하여 데이터 셋을 다운로드합니다: from datasets import load_dataset, load_metric raw_datasets = load_dataset("kde4", lang1="en", lang2="fr") 다른 언어 쌍으로 작업하려는 경우 원하는 언어 코드를 지정하여 해당 데이터 셋을 다운로드할 수 있습니다. 이 데이터 셋에서는 총 92개 언어를 사용할 수 있습니다. 데이터 셋 카드의 언어 태그를 확장하면 모두 볼 수 있습니다. 다운로드한 데이터 셋을 한번 살펴보겠습니다. raw_datasets 총 210,173건의 문장 쌍을 포함하고 있지만 단일 분할이므로 여기서 검증 집합을 별도로 생성해야 합니다. 5장에서 보았듯이 Dataset에는 이 작업을 쉽게 수행할 수 있는 train_test_split() 메서드가 있습니다: split_datasets = raw_datasets["train"].train_test_split(train_size=0.9, seed=20) split_datasets 다음과 같이 "test" 키의 이름을 "validation"으로 바꿀 수 있습니다: split_datasets["validation"] = split_datasets.pop("test") 이제 데이터 셋의 한 요소를 살펴보겠습니다: split_datasets["train"][1]["translation"] 위와 같이 우리가 요구한 언어쌍(영어, 불어)에 해당하는 문장들이 포함된 딕셔너리가 반환됩니다. 기술적인 컴퓨터 과학 용어로 가득 찬 이 데이터 셋의 한 가지 특징은 모두 프랑스어로 완전히 번역되었다는 것입니다. 그러나 프랑스 엔지니어들은 종종 게을러서 말할 때 대부분의 컴퓨터 과학 관련 단어를 영어로 표현하고 있습니다. 예를 들어, 위 예시에서 "threads"라는 단어는 불어 문장, 특히 기술적인 대화에서 많이 나타납니다. 그러나 이 데이터 세트에서는 더 "회의를 위한 토론(fils de discussion)"으로 정확하게 번역되었습니다. 규모가 더 큰 프랑스어 및 영어 문장 말뭉치에서 사전 학습된 아래와 같은 모델은 단어를 번역하지 않고 있는 그대로 그냥 두는 더 쉬운 옵션을 사용합니다: from transformers import pipeline model_checkpoint = "Helsinki-NLP/opus-mt-en-fr" translator = pipeline("translation", model=model_checkpoint) translator("Default to expanded threads") 또 다른 예는 "plugin"이라는 단어에서 볼 수 있습니다. 이 단어는 공식적으로 프랑스어가 아니지만 대부분의 원어민이 이해하고 번역하는데 어렵지 않을 것입니다. KDE4 데이터 셋에서 이 단어는 프랑스어로 더 공식적인 "module d'extension"으로 번역되었습니다: split_datasets["train"][172]["translation"] 그러나 위의 사전 학습된 모델은 간결하고 친숙한 영어 단어를 고수합니다: translator( "Unable to import %1 using the OFX importer plugin. This file is not the correct format." ) 미세 조정된 모델이 데이터 셋의 이러한 특성을 흡수하는지 확인하는 것은 흥미로울 것입니다. ✏ Your turn! 프랑스어에서 자주 사용되는 또 다른 영어 단어는 "email"입니다. 이 단어를 사용하는 학습 데이터 셋에서 첫 번째 샘플을 찾아봅시다. 어떻게 번역됩니까? 사전 학습된 모델은 동일한 영어 문장을 어떻게 번역합니까? 데이터 처리 지금쯤이면 기본적인 절차를 알아야 합니다. 모든 텍스트는 모델이 이해할 수 있도록 토큰 ID 세트로 변환되어야 합니다. 이 작업을 위해 입력과 타깃을 모두 토큰 화해야 합니다. 첫 번째 작업은 tokenizer 객체를 만드는 것입니다. 앞서 언급했듯이 Marian English to French 사전 학습 모델을 사용할 것입니다. 다른 언어 쌍에 대해서 작업하려면 모델 체크포인트를 변경해야 합니다. Helsinki-NLP 조직은 여러 언어로 천 개 이상의 모델을 제공합니다. from transformers import AutoTokenizer model_checkpoint = "Helsinki-NLP/opus-mt-en-fr" tokenizer = AutoTokenizer.from_pretrained(model_checkpoint, return_tensors="pt") Hub에서 선호하는 다른 모델로 model_checkpoint를 바꾸거나 사전 학습된 모델과 토크 나이저를 저장한 로컬 폴더로 바꿀 수도 있습니다. mBART, mBART-50 또는 M2M100과 같은 다국어 토크 나이저를 사용하는 경우 tokenizer.src_lang 및 tokenizer.tgt_lang을 올바른 값으로 설정하여 토크 나이저에서 입력 및 대상의 언어 코드를 설정해야 합니다. 데이터 준비 과정은 매우 직관적입니다. 기억해야 할 것이 하나 있습니다. 평소와 같이 입력을 처리하지만 타깃(target)의 경우 컨텍스트 관리자 내부의 토크 나이저를 as_target_tokenizer()로 래핑 해야 합니다. Python의 컨텍스트 관리자는 with 문과 함께 도입되었으며 두 개의 관련 작업을 쌍으로 실행할 때 유용합니다. 이에 대한 가장 일반적인 예는 파일을 쓰거나 읽을 때이며, 이는 종종 다음과 같은 명령어 내에서 수행됩니다: # with open(file_path) as f: # content = f.read() 여기서 쌍으로 실행되는 두 가지 관련 작업은 파일을 열고 닫는 작업입니다. 열린 파일 f에 해당하는 객체는 with 아래의 들여 쓰기 된 블록 내부에만 존재합니다. 열기는 해당 블록보다 먼저 발생하고 블록 끝에서 닫기가 발생합니다. 따라서 하나의 샘플을 전처리하는 과정은 다음과 같습니다: en_sentence = split_datasets["train"][1]["translation"]["en"] fr_sentence = split_datasets["train"][1]["translation"]["fr"] inputs = tokenizer(en_sentence) with tokenizer.as_target_tokenizer(): targets = tokenizer(fr_sentence) 컨텍스트 관리자 내에서 대상을 토큰화하는 것을 잊어버리면 입력 토크 나이저에 의해 타깃(target)이 토큰화됩니다. 이럴 경우 Marian 모델의 경우에는 토크나이징이 제대로 동작하지 않을 겁니다: wrong_targets = tokenizer(fr_sentence) print(tokenizer.convert_ids_to_tokens(wrong_targets["input_ids"])) print(tokenizer.convert_ids_to_tokens(targets["input_ids"])) 우리가 볼 수 있듯이, 영어 토크 나이저를 사용하여 프랑스어 문장을 전처리하면 토크 나이저는 프랑스어 단어를 모르기 때문에 훨씬 더 많은 토큰이 생성됩니다. inputs과 targets은 모두 일반적인 키(input IDs, attention mask 등)가 있는 딕셔너리이므로 마지막 단계는 입력 내부에 "labels" 키를 설정하는 것입니다. 이 작업은 데이터 셋에 적용할 전처리 함수에서 수행합니다: max_input_length = 128 max_target_length = 128 def preprocess_function(examples): inputs = [ex["en"] for ex in examples["translation"]] targets = [ex["fr"] for ex in examples["translation"]] model_inputs = tokenizer(inputs, max_length=max_input_length, truncation=True) # 타깃을 위한 토크 나이저 셋업 with tokenizer.as_target_tokenizer(): labels = tokenizer(targets, max_length=max_target_length, truncation=True) model_inputs["labels"] = labels["input_ids"] return model_inputs 입력 및 출력에 대해 동일한 최대 길이를 설정했습니다. 우리가 다루고 있는 텍스트는 매우 짧기 때문에 128을 사용합니다. T5 모델(더 구체적으로 t5-xxx 체크포인트 중 하나)을 사용하는 경우, 모델은 텍스트 입력에 translate: English to French:와 같이 당면한 작업을 나타내는 접두사가 있을 것으로 예상합니다. ⚠ 타깃의 어텐션 마스크는 모델이 예상하지 못하기 때문에 주의를 기울이지 않습니다. 대신 패딩 토큰에 해당하는 레이블을 -100으로 설정해야 손실 계산에서 무시됩니다. 이 작업은 동적 패딩을 적용하기 때문에 나중에 데이터 콜레 이터에 의해 수행되지만 여기에서 패딩을 사용하는 경우 패딩 토큰에 해당하는 모든 레이블을 -100으로 설정하도록 전처리 기능을 조정해야 합니다. 이제 데이터 셋의 모든 분할에 대해 전처리를 한 번에 적용할 수 있습니다: tokenized_datasets = split_datasets.map( preprocess_function, batched=True, remove_columns=split_datasets["train"].column_names, ) 이제 데이터가 전처리되었으므로 사전 학습된 모델을 미세 조정할 준비가 되었습니다! Trainer API로 모델 미세 조정하기 Trainer를 사용하는 실제 코드는 약간만 변경하면 이전과 동일합니다. 여기에서는 Seq2SeqTrainer를 사용합니다. Seq2SeqTrainer는 Trainer의 하위 클래스로서 입력에 대한 출력을 예측하기 위해 generate() 메서드를 사용하여 평가를 적절하게 수행할 수 있습니다. 평가에 대한 내용은 메트릭(metric) 계산에 대해 이야기할 때 더 자세히 살펴보겠습니다. 먼저 미세 조정할 실제 모델이 필요합니다. 일반적인 AutoModel API를 사용합니다: from transformers import AutoModelForSeq2SeqLM model = AutoModelForSeq2SeqLM.from_pretrained(model_checkpoint) 모델 체크포인트가 번역 작업에 대해서 사전 학습된 모델을 나타내고 이를 그대로 사용하고 있으므로 누락된 가중치 또는 새로 초기화된 가중치에 대한 경고가 없습니다. 데이터 콜 레이션 (Data Collation) 동적 배치 처리(Dynamic batching)를 위한 패딩을 처리하려면 데이터 콜레 이터가 필요합니다. 이 경우 3장에서와 같이 DataCollatorWithPadding을 사용할 수 없습니다. 왜냐하면 이 메서드는 입력(input IDs, attention mask 및 token type IDs)에 대해서만 패딩을 수행하기 때문입니다. 레이블 역시 레이블에 있는 최대 길이로 채워져야 합니다. 그리고 앞서 언급했듯이 레이블을 채우는데 사용되는 패딩 값은 토크 나이저의 패딩 토큰이 아니라 -100이어야 합니다. 그래야 패딩 된 값이 손실 계산에서 무시됩니다. 이 작업은 모두 DataCollatorForSeq2Seq에 의해 수행됩니다. DataCollatorWithPadding과 마찬가지로, DataCollatorForSeq2Seq는 입력을 전처리하는 데 사용되는 tokenizer는 물론 모델 자체도 매개변수로 입력받습니다. 모델도 입력받는 이유는 이 데이터 콜레 이터가 시작 부분에 특수 토큰이 붙어 있는, 레이블 시퀀스를 우측으로 시프트(shift) 한 버전인 디코더 input IDs를 준비하는 역할도 하기 때문입니다. 이 시프트(shift) 방법은 아키텍처마다 약간씩 다르기 때문에 DataCollatorForSeq2Seq는 모델 객체를 알아야 합니다. from transformers import DataCollatorForSeq2Seq data_collator = DataCollatorForSeq2Seq(tokenizer, model=model) 몇 개의 샘플에서 이를 테스트하기 위해 이 콜레 이터에 토큰화된 학습 집합의 예제 목록을 입력해 봅시다: batch = data_collator([tokenized_datasets["train"][i] for i in range(1, 3)]) batch.keys() -100을 사용하여 레이블이 배치의 최대 길이로 채워졌는지 확인할 수 있습니다: batch["labels"] 또한 decoder_input_ids를 살펴보고 labels에 저장된 토큰 리스트의 시프트(shift) 버전인지 확인할 수 있습니다: batch["decoder_input_ids"] 다음은 데이터 셋의 첫 번째 및 두 번째 요소에 대한 레이블입니다: for i in range(1, 3): print(tokenized_datasets["train"][i]["labels"]) 이 data_collator를 Seq2SeqTrainer에 전달할 것입니다. 다음으로 평가 지표(metric)를 살펴보겠습니다. 평가 지표 (Metrics) Seq2SeqTrainer가 슈퍼클래스 Trainer에 추가하는 기능은 평가(evaluation) 또는 예측(prediction) 중에 generate() 메서드를 사용하는 기능입니다. 학습하는 동안 모델은 학습 속도를 높이기 위해, 예측하려는 토큰 이후에 존재하는 토큰을 사용하지 않도록 하려고 어텐션 마스킹과 함께 decoder_input_ids를 사용합니다. 추론하는 동안에는 레이블이 없기 때문에 이를 사용할 수 없으므로 동일한 설정으로 모델을 평가하는 것이 좋습니다. 1장에서 보았듯이 디코더는 토큰을 하나씩 예측하여 추론을 수행합니다. 이는 Transformers에서 generate() 메서드에 의해 내부적으로 구현됩니다. predict_with_generate=True로 설정하면 Seq2SeqTrainer를 사용하여 위와 같은 방법으로 모델 평가를 수행할 수 있습니다. 번역에 사용되는 전통적인 평가 지표(metric)는 BLEU 스코어로서 Kishore Papineni et al.에 의해 2002년 논문에서 소개되었습니다. BLEU 점수는 번역 결과가 레이블에 얼마나 가까운지를 평가합니다. 모델에서 생성된 번역 결과의 명료성 또는 문법적 정확성을 측정하지는 않습니다. 단지 통계 규칙을 사용하여 생성된 출력 내의 모든 단어가 타깃(target)에도 존재하는지를 측정합니다. 또한, 타깃(target)에는 반복되지 않음에도 불구하고 번역 결과에서 동일한 단어가 계속 반복될 경우에도 페널티를 부여합니다. 이는 모델이 "the the the the the"와 같은 문장을 출력하는 것을 방지합니다. 또한 타깃(target)보다 짧은 문장을 출력하는 것에도 페널티를 부과합니다. 이는 "the"와 같은 문장이 출력되는 모델을 미연에 방지하기 위해서입니다. BLEU 점수의 한 가지 약점은 이미 토큰화된 텍스트를 대상으로 하기 때문에 다른 토크 나이저를 사용하는 모델 간의 점수를 비교하기 어렵습니다. 따라서 오늘날 번역 모델을 벤치마킹하는데 가장 일반적으로 사용되는 평가 지표(metric)는 토큰화 단계를 표준화하여 이러한 약점을 해결하는 SacreBLEU입니다. 이 평가 지표를 사용하려면 먼저 SacreBLEU 라이브러리를 설치해야 합니다: !python3 -m pip install sacrebleu 그런 다음 3장에서 했던 것처럼 load_metric()을 통해 로드할 수 있습니다. from datasets import load_metric metric = load_metric("sacrebleu") 이 메트릭은 텍스트를 입력(inputs) 및 타깃(targets)으로 사용합니다. 동일한 문장에 대해 허용 가능한 번역 결과가 여러 개 있기 때문에 여러 허용 가능한 대상을 입력받도록 설계되었습니다. 우리가 사용하는 데이터 셋은 하나만 제공하지만 NLP에서 여러 문장을 레이블로 제공하는 데이터 셋들도 많이 존재합니다. 따라서 예측(predictions)은 문장 리스트여야 하지만 정답(references)은 문장 리스트의 리스트라야 합니다. 예를 한번 봅시다: predictions = [ "This plugin lets you translate web pages between several languages automatically." ] references = [ [ "This plugin allows you to automatically translate web pages between several languages." ] ] metric.compute(predictions=predictions, references=references) BLEU 점수가 46.75로 나왔고 그 점수가 나쁘지 않습니다. 참고로 "Attention Is All You Need" 논문의 원래 트랜스포머(Transformer) 모델은 영어와 프랑스어 간의 비슷한 번역 작업에서 BLEU 점수 41.8을 달성했습니다! counts 및 bp와 같은 개별 평가 지표에 대한 자세한 내용은 SacreBLEU 저장소를 참조하세요. 반면에, 번역 모델에서 자주 나오는 두 가지 잘못된 유형의 예측(반복이 많거나 너무 짧음)으로 시도하면 다소 나쁜 BLEU 점수를 얻게 됩니다: predictions = ["This This This This"] references = [ [ "This plugin allows you to automatically translate web pages between several languages." ] ] metric.compute(predictions=predictions, references=references) predictions = ["This plugin"] references = [ [ "This plugin allows you to automatically translate web pages between several languages." ] ] metric.compute(predictions=predictions, references=references) 점수는 0에서 100까지 계산될 수 있으며 높을수록 좋습니다. 모델 출력에서 평가 지표(metric)가 사용할 수 있는 텍스트로 변환하기 위해서 tokenizer.batch_decode() 메서드를 사용합니다. 레이블(정답)에서는 모든 -100을 제거하면 됩니다(토크 나이저는 패딩 토큰에 대해 자동으로 동일한 작업을 수행함): import numpy as np def compute_metrics(eval_preds): preds, labels = eval_preds # 모델이 예측 로짓(logits)외에 다른 것을 리턴하는 경우. if isinstance(preds, tuple): preds = preds[0] decoded_preds = tokenizer.batch_decode(preds, skip_special_tokens=True) # -100은 건너뛴다. labels = np.where(labels != -100, labels, tokenizer.pad_token_id) decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True) # 단순 후처리 decoded_preds = [pred.strip() for pred in decoded_preds] decoded_labels = [[label.strip()] for label in decoded_labels] result = metric.compute(predictions=decoded_preds, references=decoded_labels) return {"bleu": result["score"]} 이제 이 작업이 완료되었으므로 모델을 미세 조정할 준비가 되었습니다! 모델을 미세 조정하기 첫 번째 단계는 Hugging Face에 로그인하는 것입니다. 이로써 결과를 Model Hub에 업로드할 수 있습니다. 주피터 노트북에는 이를 도와주는 편리한 기능이 있습니다: from huggingface_hub import notebook_login notebook_login() 그러면 Hugging Face 로그인 자격 증명을 입력할 수 있는 위젯이 표시됩니다. 노트북에서 작업하지 않는 경우 터미널에 다음 줄을 입력하기만 하면 됩니다: huggingface-cli login 이 작업이 완료되면 Seq2SeqTrainingArguments를 정의할 수 있습니다. Trainer와 마찬가지로 몇 가지 필드가 더 포함된 TrainingArguments의 하위 클래스를 사용합니다: from transformers import Seq2SeqTrainingArguments args = Seq2SeqTrainingArguments( f"marian-finetuned-kde4-en-to-fr", evaluation_strategy="no", save_strategy="epoch", learning_rate=2e-5, per_device_train_batch_size=32, per_device_eval_batch_size=64, weight_decay=0.01, save_total_limit=3, num_train_epochs=3, predict_with_generate=True, fp16=True, push_to_hub=True, ) 일반적인 하이퍼 파라미터(예: 학습률, 에포크 수, 배치 크기 및 일부 가중치 감소)를 제외하고, 다음은 이전 섹션에서 본 것과 비교하여 몇 가지 변경 사항입니다: 평가에 시간이 걸리므로 정기적인 평가를 설정하지 않습니다. 우리는 학습 전과 후에 모델을 한 번만 평가할 것입니다. fp16=True로 설정하여 최신 GPU에서 학습 속도를 높입니다. 위에서 설명한 것처럼 predict_with_generate=True로 설정합니다. push_to_hub=True를 사용하여 각 에포크(epoch)가 끝날 때 Hub에 모델을 업로드합니다. hub_model_id 인수를 사용하여 푸시 하려는 저장소의 전체 이름을 지정할 수 있습니다(특히, 조직에 푸시 하려면 이 인수를 사용해야 함). 예를 들어, 모델을 huggingface-course 조직에 푸시 할 때 hub_model_id="huggingface-course/marian-finetuned-kde4-en-to-fr"을 Seq2SeqTrainingArguments에 추가하면 됩니다. 기본적으로 사용되는 저장소는 네임스페이스에 존재하고 설정한 출력 디렉터리의 이름을 따서 명명되므로 이 경우에는 "spasis/marian-finetuned-kde4-en-to-fr"(우리가 이 섹션의 시작 부분에서 링크한 모델)이 됩니다. 사용하는 출력 디렉터리가 이미 존재하는 경우 푸시 하려는 저장소의 로컬 클론이어야 합니다. 그렇지 않은 경우 Seq2SeqTrainer를 정의할 때 오류가 발생하기 때문에 새로운 이름을 설정해야 합니다. 마지막으로 모든 것을 Seq2SeqTrainer에 전달합니다. from transformers import Seq2SeqTrainer trainer = Seq2SeqTrainer( model, args, train_dataset=tokenized_datasets["train"], eval_dataset=tokenized_datasets["validation"], data_collator=data_collator, tokenizer=tokenizer, compute_metrics=compute_metrics, ) 학습하기 전에 먼저 초기 모델이 얻는 점수를 살펴보고, 미세 조정으로 상황을 악화시키고 있지 않은지 다시 확인합니다. 이 명령은 다소 시간이 걸립니다: trainer.evaluate(max_length=max_target_length) BLEU 점수 39는 그리 나쁘지 않은데, 이는 우리가 선택한 모델이 이미 영어 문장을 프랑스어 문장으로 번역하는데 효과적이다는 사실을 반영합니다. 다음으로 본격적으로 학습을 진행합니다. 역시 시간이 좀 걸립니다: trainer.train() 학습이 진행되는 동안 모델이 저장될 때마다(여기서는 모든 에포크마다) 백그라운드에서 모델이 허브에 업로드됩니다. 이런 방식으로 필요한 경우 다른 머신에서 학습을 재개할 수 있습니다. 학습이 완료되면 모델을 다시 평가해 봅시다. BLEU 점수가 개선되었기를 바랍니다! trainer.evaluate(max_length=max_target_length) 거의 14포인트 개선되었네요. 좋습니다. 마지막으로, push_to_hub() 메서드를 사용하여 최신 버전의 모델을 업로드했는지 확인합니다. Trainer는 모든 평가 결과가 포함된 모델 카드의 초안을 작성하여 업로드합니다. 이 모델 카드에는 Model Hub가 추론 데모용 위젯을 선택하는 데 도움이 되는 메타데이터가 포함되어 있습니다. 일반적으로 모델 클래스에서 올바른 위젯을 유추할 수 있으므로 아무것도 할 필요가 없지만, 이 경우 동일한 모델 클래스를 모든 종류의 sequence-to-sequence 문제에 사용할 수 있으므로 번역 모델이라고 지정합니다: trainer.push_to_hub(tags="tanslation", commit_message="Training complete") 위 명령은 방금 수행한 커밋의 URL을 반환합니다. max_target_length 서 Model Hub의 추론 위젯을 사용하여 모델을 테스트하고 친구와 공유할 수 있습니다. 번역 작업을 위해서 모델을 성공적으로 미세 조정했습니다. 축하합니다! 학습 루프에 대해 좀 더 자세히 알고 싶다면 이제 Accelerate를 사용하여 동일한 작업을 수행하는 방법을 보여드리겠습니다. 맞춤형 학습 루프 (Custom Training Loop) 이제 전체 학습 루프(full training loop)를 살펴보고 필요한 부분을 쉽게 커스터마이징할 수 있습니다. 7.2와 7.3에서 했던 것과 매우 유사할 것입니다. 학습을 위한 모든 사항 준비하기 아래 내용은 이미 몇 번씩 공부했으므로 코드를 매우 빠르게 살펴보겠습니다. 먼저 데이터 셋을 "torch"<NAME>으로 설정한 후 데이터 셋에서 DataLoader를 빌드 하여 PyTorch 텐서를 얻습니다: from torch.utils.data import DataLoader tokenized_datasets.set_format("torch") train_dataloader = DataLoader( tokenized_datasets["train"], shuffle=True, collate_fn=data_collator, batch_size=8, ) eval_dataloader = DataLoader( tokenized_datasets["validation"], collate_fn=data_collator, batch_size=8 ) 다음으로 이전의 미세 조정을 계속해서 수행하지 않고 사전 학습된 모델에서 다시 시작하도록 모델을 다시 인스턴스화합니다: model = AutoModelForSeq2SeqLM.from_pretrained(model_checkpoint) 이제 옵티마이저(optimizer)가 필요합니다: from transformers import AdamW optimizer = AdamW(model.parameters(), lr=2e-5) 지금까지 준비된 모든 객체를 Accelerator.prepare() 메서드에 보낼 수 있습니다. Colab 노트북에서 TPU를 이용하여 학습하려면 이 모든 코드를 학습 함수로 이동해야 하며 Accelerator를 인스턴스화하는 셀을 실행해서는 안 됩니다. from accelerate import Accelerator accelerator = Accelerator() model, optimizer, train_dataloader, eval_dataloader = accelerator.prepare( model, optimizer, train_dataloader, eval_dataloader ) 이제 train_dataloader를 accelerator.prepare()로 보냈으므로 길이를 사용하여 학습 단계 수를 계산할 수 있습니다. accelerator.prepare()가 DataLoader의 길이를 변경하므로 항상 dataloader를 준비한 후에 이 작업을 수행해야 합니다. 지정된 learning rate에서 0으로 변화되는 전통적인 선형 학습 스케줄러를 사용합니다: from transformers import get_scheduler num_train_epochs = 3 num_update_steps_per_epoch = len(train_dataloader) num_training_steps = num_train_epochs * num_update_steps_per_epoch lr_scheduler = get_scheduler( "linear", optimizer=optimizer, num_warmup_steps=0, num_training_steps=num_training_steps, ) 마지막으로 모델을 Hub로 푸시 하려면 작업 폴더에 Repository 객체를 생성해야 합니다. 아직 로그인하지 않았다면 먼저 Hugging Face Hub에 로그인합니다. 모델에 부여하려는 모델 ID를 기반으로 저장소 이름을 결정합니다. repo_name을 원하는 대로 자유롭게 지정해도 상관없습니다. 사용자 이름만 포함하면 get_full_repo_name()이 알아서 이름을 출력합니다: from huggingface_hub import Repository, get_full_repo_name model_name = "marian-finetuned-kde4-en-to-fr-accelerate" repo_name = get_full_repo_name(model_name) repo_name 그런 다음 해당 저장소를 로컬 폴더에 복제할 수 있습니다. 이미 존재하는 경우 이 로컬 폴더는 작업 중인 리포지토리의 복제본이어야 합니다: output_dir = "marian-finetuned-kde4-en-to-fr-accelerate" repo = Repository(output_dir, clone_from=repo_name) 이제 repo.push_to_hub() 메서드를 호출하여 output_dir에 저장한 모든 것을 업로드할 수 있습니다. 이렇게 하면 각 에포크가 끝날 때 중간 모델을 업로드하는 데 도움이 됩니다. 학습 루프 (Training loop) 이제 전체 학습 루프를 작성할 준비가 되었습니다. 평가 부분을 단순화하기 위해 예측과 레이블을 가져와 메트릭 객체가 예상하는 문자열 목록으로 변환하는 postprocess() 함수를 정의합니다: def postprocess(predictions, labels): predictions = predictions.cpu().numpy() labels = labels.cpu().numpy() decoded_preds = tokenizer.batch_decode(predictions, skip_special_tokens=True) # Replace -100 in the labels as we can't decode them labels = np.where(labels != -100, labels, tokenizer.pad_token_id) decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True) # Some simple post-processing decoded_preds = [pred.strip() for pred in decoded_preds] decoded_labels = [[label.strip()] for label in decoded_labels] return decoded_preds, decoded_labels 학습 루프는 평가 부분에서 몇 가지 차이점을 제외하고 섹션 2 및 3의 루프와 매우 유사하므로 이 차이점에 초점을 맞추겠습니다! 가장 먼저 주목해야 할 점은 예측을 수행하기 위해 generate() 메서드를 사용한다는 것입니다. 그러나 이것은 기본 모델의 메서드입니다. Accelerate가 prepare() 메서드에서 생성한 래핑 된 모델이 아닙니다. 그래서 먼저 모델의 래핑 부분을 풀고 이 메서드를 호출합니다. 두 번째 차이점은 토큰 분류와 마찬가지로 두 개의 프로세스가 입력과 레이블을 다른 모양으로 패딩 했을 수 있으므로 gather() 메서드를 호출하기 전에 Accelerator.pad_across_processes()를 사용하여 예측 결과와 레이블을 동일한 모양으로 만듭니다. 이렇게 하지 않으면 평가에 오류가 발생하거나 프로세스가 영원히 중단됩니다. from tqdm.auto import tqdm import torch import numpy as np progress_bar = tqdm(range(num_training_steps)) for epoch in range(num_train_epochs): # 학습 model.train() for batch in train_dataloader: outputs = model(**batch) loss = outputs.loss accelerator.backward(loss) optimizer.step() lr_scheduler.step() optimizer.zero_grad() progress_bar.update(1) # 평가 model.eval() for batch in tqdm(eval_dataloader): with torch.no_grad(): generated_tokens = accelerator.unwrap_model(model).generate( batch["input_ids"], attention_mask=batch["attention_mask"], max_length=128, ) labels = batch["labels"] # 예측과 레이블을 모으기 전에 함께 패딩 수행 generated_tokens = accelerator.pad_across_processes( generated_tokens, dim=1, pad_index=tokenizer.pad_token_id ) labels = accelerator.pad_across_processes(labels, dim=1, pad_index=-100) predictions_gathered = accelerator.gather(generated_tokens) labels_gathered = accelerator.gather(labels) decoded_preds, decoded_labels = postprocess(predictions_gathered, labels_gathered) metric.add_batch(predictions=decoded_preds, references=decoded_labels) results = metric.compute() print(f"epoch {epoch}, BLEU score: {results['score']:.2f}") # 저장 및 업로드 accelerator.wait_for_everyone() unwrapped_model = accelerator.unwrap_model(model) unwrapped_model.save_pretrained(output_dir, save_function=accelerator.save) if accelerator.is_main_process: tokenizer.save_pretrained(output_dir) repo.push_to_hub( commit_message=f"Training in progress epoch {epoch}", blocking=False ) 이 작업이 완료되면 Seq2SeqTrainer로 학습된 모델과 매우 유사한 결과를 갖는 모델을 갖게 됩니다. huggingface-course/marian-finetuned-kde4-en-to-fr-accelerate에서 이 코드를 사용하여 훈련한 것을 확인할 수 있습니다. 그리고 위 코드를 편집하여 학습 루프를 수정하고 테스트해 볼 수 있습니다. 미세 조정된 모델 사용하기 앞에서 추론 위젯을 사용하여 Model Hub에서 미세 조정한 모델을 사용하는 방법을 이미 살펴봤습니다. 파이프라인을 활용하여 로컬로 사용하려면 적절한 모델 식별자를 지정하기만 하면 됩니다: from transformers import pipeline model_checkpoint = "huggingface-course/marian-finetuned-kde4-en-to-fr" translator = pipeline("translation", model=model_checkpoint) translator("Default to expanded threads") 예상대로, 사전 학습된 모델은 해당 지식을 우리가 미세 조정한 말뭉치에 적용했으며 영어 단어 "threads"를 그대로 두는 대신 이제 프랑스어 공식 버전으로 번역합니다. "plugin"에 대해서도 동일합니다: translator( "Unable to import %1 using the OFX importer plugin. This file is not the correct format." ) 도메인 어뎁테이션의 또 다른 좋은 예시를 봤습니다! ✏ Your turn! 앞에서 살펴본 "email"이라는 단어가 포함된 샘플에 대해서 모델은 어떤 번역 결과를 내나요? 4. 요약 (Summarization) 이 섹션에서는 Transformer 모델을 사용하여 긴 문서를 간략하게 압축하는 방법, 즉 텍스트 요약(text summarization) 태스크를 살펴보겠습니다. 이 작업은 가장 어려운 NLP 작업 중 하나로 알려져 있는데 그 이유는 길이가 긴 구절을 이해하고 전체 문서의 핵심 주제를 포괄하는 일관된 텍스트를 생성하는 등 다양한 능력이 필요하기 때문입니다. 그러나 이러한 텍스트 요약만 잘 된다면 긴 문서를 자세히 읽어야 하는 도메인 전문가의 부담을 덜어줌으로써 다양한 비즈니스 프로세스의 속도를 높일 수 있는 강력한 도구입니다. Hugging Face 허브에는 이미 다양한 미세조정된 요약 모델이 존재하지만 이들 거의 대부분이 영어 문서만 처리할 수 있습니다. 따라서, 이 섹션에서 우리는 영어와 스페인어를 위한 이중 언어 모델을 학습하여 영어 외에 다른 언어에 대한 요약 작업의 가능성을 보여주려고 합니다. 이 섹션이 끝나면 아래 표시된 것과 같은 고객 리뷰를 요약할 수 있는 모델이 만들어질 것입니다: 앞으로 살펴보겠지만 이러한 요약 결과는 고객이 제품 리뷰에서 제공하는 제목을 통해서 학습했기 때문에 간결합니다. 이 작업에 적합한 이중 언어 말뭉치(bilingual corpus)를 구성하는 것으로 시작하겠습니다. 다중 언어 말뭉치 준비하기 Multilingual Amazon Reviews Corpus를 사용하여 이중 언어 요약기를 생성합니다. 이 말뭉치는 6개 언어로 된 Amazon 제품 리뷰로 구성되며 일반적으로 다국어 분류기를 벤치마킹하는 데 사용됩니다. 그러나 각 리뷰에는 짧은 제목이 수반되므로 이 제목을 모델이 학습할 대상 요약으로 사용할 수 있습니다! 시작하려면 Hugging Face Hub에서 영어 및 스페인어 하위 집합을 다운로드하세요: from datasets import load_dataset spanish_dataset = load_dataset("amazon_reviews_multi", "es") english_dataset = load_dataset("amazon_reviews_multi", "en") english_dataset 보시다시피, 각 언어에 대해 train 분할에 대한 200,000개의 리뷰와 validation 및 test 분할에 대한 5,000개의 리뷰가 있습니다. 우리가 관심 있는 리뷰 정보는 review_body 및 review_title 열에 포함되어 있습니다. 5장에서 배운 기법을 사용하여 학습 집합에서 무작위 샘플을 가져오는 간단한 함수를 만들어 몇 가지 예를 살펴보겠습니다: def show_samples(dataset, num_samples=3, seed=42): sample = dataset["train"].shuffle(seed=seed).select(range(num_samples)) for example in sample: print(f"\n'>> Title: {example['review_title']}'") print(f"'>> Review: {example['review_body']}'") show_samples(english_dataset) ✏ Try it out! Dataset.shuffle() 명령에서 랜덤 시드 값을 변경하여 코퍼스의 다른 리뷰를 탐색해 봅시다. 스페인어 사용자라면 spanish_dataset의 일부 리뷰를 살펴보고 제목도 합당한 요약처럼 보이는지 확인하세요. 위 샘플들은 긍정적인 샘플부터 부정적인 것들까지(그리고 그 사이의 모든 것까지!) 일반적으로 온라인에서 찾을 수 있는 다양한 리뷰를 보여줍니다. 비록 제목이 "meh"인 예시는 그다지 유용하지 않지만 다른 제목은 리뷰 자체에 대한 적절한 요약처럼 보입니다. 400,000개의 모든 리뷰에 대한 요약 모델을 학습하는 것은 단일 GPU를 사용하면 너무 오래 걸리므로 특정 제품 도메인에 국한하여 요약을 생성하는데 집중할 것입니다. 우리가 선택할 수 있는 도메인에 대한 전체적인 내용을 파악하기 위해 english_dataset을 pandas.DataFrame으로 변환하고 제품 카테고리당 리뷰 수를 계산해 보겠습니다: english_dataset.set_format("pandas") english_df = english_dataset["train"][:] # 최상위 20개의 상품에 대한 개수 보여주기... english_df["product_category"].value_counts()[:20] 영어 데이터 셋에서 가장 인기 있는 제품은 가정용품(household items), 의류(clothing) 및 무선 전자 제품(wireless electronics)에 관한 것입니다. 하지만 Amazon의 대표적인 테마 상품에 집중하기 위해 서평 요약(book review)에 집중합시다. 아마존은 도서 판매에서부터 출발했습니다! 두 가지 제품 범주(book 및 digital_e book_purchase)가 도서에 포함될 수 있으므로 이 제품들에 대해서만 두 언어로 된 데이터 셋을 필터링해 보겠습니다. 5장에서 보았듯이 Dataset.filter() 함수를 사용하면 데이터 셋을 매우 효율적으로 슬라이스할 수 있으므로 이를 수행하는 간단한 함수를 정의해 보겠습니다: def filter_books(example): return ( example["product_category"] == "book" or example["product_category"] == "digital_e book_purchase" ) 이제 이 함수를 eglish_dataset 및 spanish_dataset에 적용하면 결과에 도서 카테고리와 관련된 행만 포함됩니다. 필터를 적용하기 전에 english_dataset<NAME>을 "pandas"에서 "arrow"로 다시 전환해 보겠습니다: english_dataset.reset_format() 그런 다음 필터 기능을 적용할 수 있고 온전성 검사(sanity check)로 리뷰 샘플을 검사하여 실제로 책에 관한 것인지 확인하겠습니다: spanish_books = spanish_dataset.filter(filter_books) english_books = english_dataset.filter(filter_books) show_samples(english_books) 좋습니다. 도서에 관한 것이 아니라 달력이나 OneNote와 같은 전자 응용 프로그램과 같은 항목에 대한 리뷰도 존재함을 알 수 있습니다. 그럼에도 불구하고 전체적인 내용은 요약 모델을 학습하기에 거의 적합한 것 같습니다. 이 작업에 적합한 다양한 모델을 살펴보기 전에 마지막으로 해야 할 데이터 준비 작업이 있습니다. 영어와 스페인어 리뷰를 단일 DatasetDict 객체로 결합하는 것입니다. Datasets는 (이름에서 알 수 있듯이) 두 개의 Dataset 객체를 위아래로 쌓는 편리한 concatenate_datasets() 함수를 제공합니다. 따라서 이중 언어 데이터 셋을 만들기 위해 각 분할을 반복하고 해당 분할에 대한 데이터 셋을 연결하고 결과를 섞어서 모델이 단일 언어에 과적합되지 않도록 합니다: from datasets import concatenate_datasets, DatasetDict books_dataset = DatasetDict() for split in english_books.keys(): books_dataset[split] = concatenate_datasets( [english_books[split], spanish_books[split]] ) books_dataset[split] = books_dataset[split].shuffle(seed=42) # 몇 개의 샘플을 선택합니다. show_samples(books_dataset) 위 결과는 확실히 영어와 스페인어 리뷰가 혼합된 것처럼 보입니다! 이제 학습 말뭉치가 있으므로 마지막으로 확인해야 할 것은 리뷰와 제목의 단어 분포입니다. 이는 데이터 내에 존재하는 길이가 짧은 참조 요약들이, 하나 또는 두 단어로만 구성된 요약 결과만을 출력하도록 모델을 편향시킬 수 있는 요약 작업에 특히 중요합니다. 아래 막대그래프는 단어 분포를 보여주며 제목이 단 1-2개의 단어로 심하게 치우친 것을 볼 수 있습니다: 이 문제를 처리하기 위해 우리 모델이 더 흥미로운 요약을 생성할 수 있도록 매우 짧은 제목을 가진 리뷰를 걸러낼 것입니다. 영어와 스페인어 텍스트를 다루기 때문에 대략적인 휴리스틱을 사용하여 공백에서 제목을 분할한 후에 다음과 같이 신뢰할 수 있는 Dataset.filter() 메서드를 사용할 수 있습니다: books_dataset = books_dataset.filter(lambda x: len(x["review_title"].split()) > 2) 이제 말뭉치 준비를 완료했으므로 미세 조정할 수 있는 몇 가지 가능한 Transformer 모델을 살펴보겠습니다! 텍스트 요약을 위한 모델들 생각해 보면 텍스트 요약은 기계 번역과 비슷한 종류의 작업입니다. 다시 말해서, 리뷰 텍스트 본문을 해당 리뷰의 두드러진 특징을 포착하는 짧은 버전의 또 다른 텍스트로 "번역(translate)" 하는 작업입니다. 따라서 요약을 위한 대부분의 Transformer 모델은 1장에서 처음 만난 인코더-디코더 아키텍처(encoder-decoder architecture)를 채택하지만, 퓨샷(few-shot) 세팅을 기반으로 요약에 바로 사용할 수도 있는 GPT 모델 제품군과 같은 몇 가지 예외가 있습니다. 다음 표에는 요약을 위해 미세 조정할 수 있는 몇 가지 인기 있는 사전 학습된 모델이 나열되어 있습니다. 모델 설명 다국어 여부 GPT-2 자동 회귀 언어 모델(auto-regressive language model)로 학습되었지만 입력 텍스트 끝에 "TL;DR"을 추가하여 GPT-2가 요약을 생성하도록 할 수 있습니다. ❌ PEGASUS 다중 문장 텍스트에서 마스킹 된 문장을 예측하기 위한 pretraining objective를 사용합니다. 이 pretraining objective는 기본적인 언어 모델링보다 요약에 가까우며 인기 있는 벤치마크에서 높은 점수를 받았습니다. ❌ T5 Text-to-text 프레임워크와 관련된 모든 태스크(task)를 지원하는 범용 Transformer 아키텍처. 예를 들어, 문서를 요약하는 모델의 입력<NAME>은 summarize: ARTICLE임. ❌ mT5 101개 언어를 포함하는 다국어 Common Crawl corpus(mC4)를 이용해 사전 학습된 T5의 다국어 버전입니다. ✅ BART BERT와 GPT-2의 사전 학습 방식을 결합하여 손상된 입력을 재구성하도록 훈련된 인코더와 디코더 스택이 모두 있는 새로운 Transformer 아키텍처입니다. ❌ mBART-50 50개 언어로 사전 학습된 BART의 다국어 버전. ✅ 이 표에서 볼 수 있듯이 요약을 위한 대부분의 Transformer 모델(그리고 실제로 대부분의 NLP 작업)은 단일 언어만을 지원하고 있습니다. 이런 상황은 대상 작업이 영어나 독일어와 같은 "고자원(high-resource)" 언어로 되어 있는 경우에 유용하지만 전 세계에서 사용되는 수천 개의 다른 언어에 대해서는 그렇지 않습니다. 다행히도 mT5 및 mBART와 같은 다국어 Transformer 모델 클래스가 있습니다. 이러한 모델들은 언어 모델링을 사용하여 사전 학습되지만, 단일 언어 말뭉치에 대해 학습하는 대신 한 번에 50개 이상의 언어로 된 텍스트에 대해 공동으로 학습됩니다! 우리는 text-to-text 프레임워크에서 사전 학습된 T5를 기반으로 하는 흥미로운 아키텍처인 mT5에 초점을 맞출 것입니다. T5에서 모든 NLP 작업은 summarize:와 같은 입력된 접두사 프롬프트(prefix prompt)에 의해서 설정되며, 모델이 생성하는 텍스트는 입력 프롬프트에 해당하는 작업의 결과물입니다. 아래 그림에서 볼 수 있듯이 T5는 단일 모델로 많은 작업을 해결할 수 있으므로 매우 다재다능합니다! mT5는 접두사 프롬프트(prefix prompt)를 지원하지 않지만 T5의 다양한 기능을<NAME>고 다국어를 사용할 수 있다는 장점이 있습니다. 이제 모델을 선택했으므로 학습을 위해 데이터를 준비하는 방법을 살펴보겠습니다. ✏ Try it out! 이 섹션에서 설명하는 내용을 바탕으로 mBART도 동일한 기법으로 미세 조정하여 mT5의 결과와 비교해 보세요. 데이터 셋에서 영어에 대해서는 T5를 사용할 수도 있겠지요. T5에는 특별한 접두사 프롬프트(prefix prompt)가 있으므로 아래 전처리 단계의 입력 예제에 summarize:를 추가해야 합니다. 데이터 전처리하기 다음 작업은 리뷰와 제목을 토큰화하고 인코딩하는 것입니다. 평소처럼 사전 학습된 모델 체크포인트와 연결된 토크 나이저를 로드하는 것으로 시작합니다. 가급적 짧은 시간 내에 모델을 미세 조정할 수 있도록 mt5-small을 체크포인트로 사용할 것입니다: from transformers import AutoTokenizer model_checkpoint = "google/mt5-small" tokenizer = AutoTokenizer.from_pretrained(model_checkpoint) NLP 프로젝트의 초기 단계에서는 작은 데이터 샘플에서 "작은" 모델 클래스를 학습시키는 것이 좋습니다. 이를 통해 종단 간 워크플로(end-to-end workflow)를 더 빠르게 디버그하고 반복할 수 있습니다. 결과에 확신이 생기면 모델 체크포인트를 변경하기만 하면 언제든지 모델을 확장할 수 있습니다! 작은 예제에서 mT5 토크 나이저를 테스트해 보겠습니다: inputs = tokenizer("I loved reading the Hunger Games!") inputs 여기서 우리는 3장의 첫 번째 미세 조정 실험에서 만난 친숙한 input_ids와 attention_mask를 볼 수 있습니다. 토크 나이저의 convert_ids_to_tokens() 함수를 사용하여 이러한 입력 ID를 디코딩 하여 어떤 종류의 토크 나이저를 모델이 실행하고 있는지 살펴보겠습니다: tokenizer.convert_ids_to_tokens(inputs.input_ids) 특수 유니코드 문자인 _ 와 시퀀스 끝 토큰 </s>은 6장에서 논의한 Unigram 분할 알고리즘을 기반으로 하는 SentencePiece 토크 나이저를 사용하고 있음을 나타냅니다. Unigram은 SentencePiece가 악센트, 구두점 및 일본어와 같은 많은 언어들에 공백 문자가 없다는 사실에 대해서 영향을 받지 않게 하기 때문에 다국어 말뭉치에 특히 유용합니다. 말뭉치를 토큰화하려면 요약 작업과 관련된 특수한 상황을 처리해야 합니다. 다시 말해서, 레이블도 텍스트이기 때문에 모델의 최대 컨텍스트 크기를 초과할 수 있습니다. 즉, 모델에 지나치게 긴 입력을 전달하지 않도록 리뷰와 제목 모두에 절단 작업(truncation)을 수행해야 합니다. Transformers의 토크 나이저는 입력과 병렬로 레이블을 토큰화할 수 있는 멋진 as_target_tokenizer() 함수를 제공합니다. 이것은 일반적으로 먼저 입력을 인코딩한 다음 레이블을 별도의 열로 인코딩하는 전처리 함수 내부의 컨텍스트 관리자를 사용하여 수행됩니다. 다음은 mT5에 대해서 이 함수를 실행하는 예입니다: max_input_length = 512 max_target_length = 30 def preprocess_function(examples): model_inputs = tokenizer( examples["review_body"], max_length=max_input_length, truncation=True ) # 타깃을 위한 토크 나이저 설정 with tokenizer.as_target_tokenizer(): labels = tokenizer( examples["review_title"], max_length=max_target_length, truncation=True ) model_inputs["labels"] = labels["input_ids"] return model_inputs 무슨 일이 일어나고 있는지 이해하기 위해 이 코드를 살펴보겠습니다. 우리가 한 첫 번째 일은 max_input_length 및 max_target_length에 대한 값을 정의하는 것입니다. 이 값은 리뷰와 제목의 길이에 대한 상한선을 설정합니다. 리뷰 본문은 일반적으로 제목보다 훨씬 크기 때문에 이 값을 적절하게 조정했습니다. 그런 다음 preprocess_function() 자체에서 리뷰 본문이 먼저 토큰화되고 리뷰 제목이 as_target_tokenizer()를 이용해서 추가적으로 토큰화되는 것을 볼 수 있습니다. preprocess_function()을 사용하면 전체 코스에서 광범위하게 사용한 편리한 Dataset.map() 함수를 사용하여 전체 말뭉치를 토큰화하는 것이 간단합니다: tokenized_datasets = books_dataset.map(preprocess_function, batched=True) 말뭉치가 전처리되었으므로 요약에 일반적으로 사용되는 몇 가지 평가 지표(metrics)를 살펴보겠습니다. 앞으로 살펴보겠지만, 컴퓨터에 의해서 생성된 텍스트(machine-generated text)의 품질을 측정하는데 묘책(silver bullet)은 없습니다. 위의 Dataset.map() 함수에서 batched=True를 사용한 것을 눈치채셨을 것입니다. 이것은 1,000개(기본값)의 배치(batch)로 예제를 인코딩하고 Transformers에서 빠른 토크 나이저의 멀티스레딩 기능을 사용할 수 있도록 합니다. 가능한 경우 전처리를 최대한 활용하기 위해 batched=True를 사용해 보십시오! 텍스트 요약을 위한 평가 지표(metrics) 이 코스에서 다룬 대부분의 다른 작업과 비교할 때 요약 또는 번역과 같은 텍스트 생성 작업의 성능을 측정하는 것은 간단하지 않습니다. 예를 들어, "나는 헝거 게임을 읽는 것을 좋아했습니다"와 같은 리뷰가 주어지면 "나는 헝거 게임을 좋아했습니다" 또는 "헝거 게임은 잘 읽었습니다"와 같은 적절한 요약 결과가 여러 개 있을 수 있습니다. 분명히, 생성된 요약과 레이블 사이에 완전 일치(exact match) 기반의 평가 방법을 적용하는 것은 좋은 해결책이 아닙니다. 우리 모두는 자신만의 작문 스타일을 가지고 있기 때문에 이러한 측정 기준에서는 인간조차도 좋지 않을 것입니다. 요약 작업을 위해서 가장 일반적으로 사용되는 측정항목 중 하나는 ROUGE 점수(Recall-Oriented Understudy for Gisting Evaluation)입니다. 이 평가 지표의 기본적인 아이디어는 모델의 결과로 생성된 요약을 사람이 직접 만든 참조 요약 세트와 비교하는 것입니다. 이를 보다 쉽게 설명하기 위해 다음 두 요약을 비교한다고 가정합시다: generated_summary = "I absolutely loved reading the Hunger Games" reference_summary = "I loved reading the Hunger Games" 두 요약이 얼마나 유사한지 비교하는 한 가지 방법은 겹치는 단어의 수를 계산하는 것입니다. 이 경우에는 6이 됩니다. 그러나 이 방법은 약간 조잡하므로 그 대신 ROUGE는 겹침에 대한 정밀도 및 재현율 계산을 기반으로 합니다. 정밀도와 재현율에 대해 처음 들어보더라도 걱정하지 마세요. 모든 것을 명확하게 하기 위해 몇 가지 명쾌한 예를 함께 살펴보겠습니다. 이 메트릭은 일반적으로 분류 작업에서 발생하므로 해당 컨텍스트에서 정밀도와 재현율이 정의되는 방식을 이해하려면 scikit-learn 가이드를 확인하는 것이 좋습니다. ROUGE의 경우 재현율은 생성된 참조 요약이 캡처한 참조 요약의 양을 측정합니다. 단어만 비교한다면 재현율은 다음 공식에 따라 계산할 수 있습니다: 재현율 중첩된 단어들의 개수 참조 요약 내의 모든 단어의 개수 현 = 첩 단 들 개 참 요 내 모 단의 수 위의 간단한 예에서 이 공식은 6/6 = 1의 완벽한 재현율을 제공합니다. 즉, 참조 요약의 모든 단어는 모델에 의해 생성되었습니다. 훌륭하게 들릴 수 있지만 생성된 요약이 "I really really loved reading the Hunger Games all night"였다고 생각해 보십시오. 이것은 또한 완벽한 재현율을 보이지만 장황하기 때문에 분명히 더 나쁜 요약입니다. 이러한 상황도 함께 처리하기 위해 ROUGE 컨텍스트는 생성된 요약이 얼마나 관련이 있는지 측정하는 정밀도도 계산합니다: 정밀도 중첩된 단어들의 개수 생성된 요약 내의 모든 단어의 개수 밀 = 첩 단 들 개 생된 약의 든 어 개 이 수식을 위의 장황한 요약에 적용하면 6/10 = 0.6의 정밀도를 얻을 수 있으며, 이는 더 짧은 것으로 얻은 6/7 = 0.86의 정밀도보다 상당히 나쁩니다. 실제로 정밀도와 재현율이 모두 계산된 다음 F1 점수(정밀도와 재현율의 조화 평균)가 계산됩니다. rouge_score 패키지를 설치하면 Datasets에서 이 작업을 쉽게 수행할 수 있습니다: !python3 -m pip install rouge_score 그리고 다음과 같이 ROUGE 메트릭을 로드합니다: from datasets import load_metric rouge_score = load_metric("rouge") 그런 다음 rouge_score.compute() 함수를 사용하여 모든 메트릭을 한 번에 계산할 수 있습니다: scores = rouge_score.compute( predictions=[generated_summary], references=[reference_summary] ) scores 와우, 많은 정보가 출력되고 있습니다. 모든 것이 무엇을 의미할까요? 첫째, Datasets는 실제로 정밀도, 재현율 및 F1 점수에 대한 신뢰 구간을 계산합니다. 여기에서 볼 수 있는 low, mid 및 high 속성입니다. 또한 Datasets는 생성된 요약과 참조 요약을 비교할 때 다양한 유형의 텍스트 granularity(입도)를 기반으로 하는 다양한 ROUGE 점수를 계산합니다. rouge1은 unigram의 겹침입니다. 이것은 단지 단어 겹침을 보기 좋게 표현한 것이며 위에서 논의한 바로 그 메트릭입니다. 이를 확인하기 위해 점수의 중간 값을 추출해 보겠습니다: scores["rouge1"].mid 좋습니다. 정밀도와 재현율 숫자가 일치합니다! 이제 다른 ROUGE 점수는 무엇일까요? rouge2는 bigram 간의 겹침(단어 쌍의 겹침을 생각)을 측정하는 반면 rougeL 및 rougeLsum은 생성된 요약 및 참조 요약에서 가장 긴 공통부분 문자열을 찾아 가장 긴 일치하는 단어 시퀀스를 측정합니다. rougeLsum의 "sum"은 이 메트릭이 전체 요약 텍스트에 대해 계산되는 반면 rougeL은 개별 문장에 대한 평균으로 계산된다는 사실을 나타냅니다. ✏ Try it out! 직접 생성된 요약과 참조 요약 예를 만들고 결과 ROUGE 점수가 정밀도 및 재현율 공식을 기반으로 하는 수동 계산과 일치하는지 확인해 보세요. 보너스 점수를 얻기 위해서, 텍스트를 bigram으로 분할하고 rouge2 측정 항목의 정밀도와 재현율을 비교해 보세요. 우리는 이 ROUGE 점수를 사용하여 우리 모델의 성능을 추적할 것이지만, 그전에 모든 훌륭한 NLP 실무자가 해야 할 일을 합시다. 강력하지만 단순한 베이스라인(baseline) 모델을 만드십시오! 강력한 베이스라인 모델 만들기 텍스트 요약을 위한 일반적인 베이스라인 시스템은 일반적으로 lead-3 베이스라인이라고 부르는, 문서의 첫 세 문장을 취하는 것입니다. 문장 경계를 추적하기 위해 마침표를 사용할 수 있지만 "U.S."나 "U.N." 등과 같은 약어에서는 실패합니다. 대신 이러한 경우를 처리하는 더 나은 알고리즘이 포함된 nltk 라이브러리를 사용합니다. 다음과 같이 pip를 사용하여 패키지를 설치할 수 있습니다: !python3 -m pip install nltk 그러고 나서 구두점 규칙을 다운로드합니다. import nltk nltk.download("punkt") 다음으로, nltk에서 문장 토크 나이저를 가져와서 리뷰에서 처음 세 문장을 추출하는 간단한 함수를 만듭니다. 텍스트 요약에서의 관례는 각 요약을 줄 바꿈으로 구분하는 것이므로 이 개행문자를 포함시켜서 학습 예제에서 테스트해 보겠습니다: from nltk.tokenize import sent_tokenize def three_sentence_summary(text): return "\n".join(sent_tokenize(text)[:3]) print(three_sentence_summary(books_dataset["train"][1]["review_body"])) 이 방법이 제대로 작동하는 것 같으므로 이제 데이터 셋에서 이러한 "첫 3줄 요약"을 추출하고 이 베이스라인 방법론에 대한 ROUGE 점수를 계산하는 함수를 구현해 보겠습니다: def evaluate_baseline(dataset, metric): summaries = [three_sentence_summary(text) for text in dataset["review_body"]] return metric.compute(predictions=summaries, references=dataset["review_title"]) 그런 다음 이 함수를 사용하여 검증 집합(validation set)에 대한 ROUGE 점수를 계산하고 Pandas를 사용하여 약간 예쁘게 만들 수 있습니다: import pandas as pd score = evaluate_baseline(books_dataset["validation"], rouge_score) rouge_names = ["rouge1", "rouge2", "rougeL", "rougeLsum"] rouge_dict = dict((rn, round(score[rn].mid.fmeasure * 100, 2)) for rn in rouge_names) rouge_dict rouge2 점수가 나머지 점수보다 훨씬 낮음을 알 수 있습니다. 이는 리뷰 제목이 일반적으로 간결하여 lead-3 베이스라인이 너무 길고 장황하다는 사실을 반영하는 것 같습니다. 이제 비교할 좋은 베이스라인이 생겼으므로 mT5를 미세 조정하는 데 주의를 기울이겠습니다! Trainer API를 이용하여 mT5 미세조정 요약을 위해 모델을 미세 조정하는 것은 이 장에서 다룬 다른 작업과 매우 유사합니다. 가장 먼저 해야 할 일은 mt5-small 체크포인트에서 사전 학습된 모델을 로드하는 것입니다. 요약은 sequence-to-sequence 작업이므로 AutoModelForSeq2SeqLM 클래스를 사용하여 모델을 로드할 수 있습니다. 이 클래스는 가중치를 자동으로 다운로드하고 캐시 합니다: from transformers import AutoModelForSeq2SeqLM model = AutoModelForSeq2SeqLM.from_pretrained(model_checkpoint) 다운스트림 작업에서 모델 미세 조정에 대한 경고가 표시되지 않는데 그 이유는 sequence-to-sequence 작업의 경우 네트워크의 모든 가중치를 유지하기 때문입니다. 이것을 3장의 텍스트 분류 모델과 비교해 보세요. 여기서 사전 학습된 모델의 헤드(head)는 무작위로 초기화된 네트워크로 대체되었습니다. 다음으로 해야 할 일은 Hugging Face Hub에 로그인하는 것입니다. 노트북에서 이 코드를 실행하는 경우 다음 유틸리티 함수를 사용하여 실행할 수 있습니다: from huggingface_hub import notebook_login notebook_login() 학습 과정에서 ROUGE 점수를 계산하려면 요약을 생성해야 합니다. 다행스럽게도 Transformers는 자동으로 이 작업을 수행할 수 있는 전용 Seq2SeqTrainingArguments 및 Seq2SeqTrainer 클래스를 제공합니다! 이것이 어떻게 작동하는지 보기 위해 먼저 하이퍼 파라미터와 실험에 대한 다른 인수를 정의해 보겠습니다: from transformers import Seq2SeqTrainingArguments batch_size = 8 num_train_epochs = 8 # 매 에포크마다 training loss를 보여준다. logging_steps = len(tokenized_datasets["train"]) // batch_size model_name = model_checkpoint.split("/")[-1] args = Seq2SeqTrainingArguments( output_dir=f"{model_name}-finetuned-amazon-en-es", evaluation_strategy="epoch", learning_rate=5.6e-5, per_device_train_batch_size=batch_size, per_device_eval_batch_size=batch_size, weight_decay=0.01, save_total_limit=3, num_train_epochs=num_train_epochs, predict_with_generate=True, logging_steps=logging_steps, push_to_hub=True, ) 여기에서 predict_with_generate 인수는 평가 중에 요약을 생성하여 각 epoch에 대한 ROUGE 점수를 계산할 수 있도록 설정되었습니다. 1장에서 논의한 바와 같이 디코더는 토큰을 하나씩 예측하여 추론을 수행하며 이는 모델의 generate() 메서드로 구현됩니다. predict_with_generate=True로 설정하면 Seq2SeqTrainer가 평가를 위해 해당 방법을 사용하도록 지시합니다. 또한 학습률, 에포크 수 및 가중치 감소와 같은 기본 하이퍼 파라미터 중 일부를 조정했으며, 학습 중 최대 3개의 체크포인트만 저장하도록 save_total_limit 옵션을 설정했습니다. 이는 mT5의 "소형" 버전도 약 1 GB의 하드 드라이브 공간을 사용하고 저장하는 복사본 수를 제한하여 약간의 공간을 절약할 수 있기 때문입니다. push_to_hub=True 인수를 사용하면 학습 후 모델을 Hub로 푸시 할 수 있습니다. output_dir에 의해 정의된 위치의 사용자 프로필 아래 저장소를 찾을 수 있습니다. hub_model_id 인수를 사용하여 푸시 하려는 리포지토리의 이름을 지정할 수 있습니다(특히, 조직에 푸시 하려면 이 인수를 사용해야 함). 예를 들어, 모델을 huggingface-course organization에 푸시 할 때 hub_model_id="huggingface-course/mt5-finetuned-amazon-en-es"를 Seq2SeqTrainingArguments에 추가했습니다. 다음으로 해야 할 일은 학습 중에 모델을 평가할 수 있도록 trainer에게 compute_metrics() 함수를 제공하는 것입니다. 요약 작업을 위해서는 ROUGE 점수를 계산하기 전에 출력과 레이블을 텍스트로 디코딩 해야 하기 때문에 모델의 예측에 대해 단순히 rouge_score.compute()를 호출하는 것보다 약간 더 복잡합니다. 다음 함수는 정확히 이를 수행하며 nltk의 sent_tokenize() 함수를 사용하여 요약 문장을 줄 바꿈으로 구분합니다: import numpy as np def compute_metrics(eval_pred): predictions, labels = eval_pred # 생성된 요약을 텍스트로 디코딩 decoded_preds = tokenizer.batch_decode(predictions, skip_special_tokens=True) # 레이블 내의 -100을 교체한다. labels = np.where(labels != -100, labels, tokenizer.pad_token_id) # 레퍼런스 요약을 텍스트로 디코딩 decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True) # ROUGE는 각 문장 다음에 개행문자를 요구한다. decoded_preds = ["\n".join(sent_tokenize(pred.strip())) for pred in decoded_preds] decoded_labels = ["\n".join(sent_tokenize(label.strip())) for label in decoded_labels] # ROUGE 점수 계산 result = rouge_score.compute( predictions=decoded_preds, references=decoded_labels, use_stemmer=True ) # 중간 점수(median scores) 추출 result = {key: value.mid.fmeasure * 100 for key, value in result.items()} return {k: round(v, 4) for k, v in result.items()} 다음으로 sequence-to-sequence 작업을 위한 데이터 콜레 이터(data collator)를 정의해야 합니다. mT5는 인코더-디코더 트랜스포머 모델이기 때문에 배치(batches)를 준비할 때 한 가지 미묘하지만 중요한 점은 디코딩 하는 동안 레이블을 하나씩 오른쪽으로 이동해야 한다는 것입니다. 이는 디코더가 모델이 쉽게 기억할 수 있는 현재 또는 미래 레이블이 아닌 이전 정답 레이블만 볼 수 있도록 하기 위해 필요합니다. 이는 인과적 언어 모델링(causal language modeling)과 같은 작업의 입력에 마스크 된 셀프 어텐션(masked self-attention)이 적용되는 방식과 유사합니다. 다행히도, Transformers는 입력과 레이블을 동적으로 채우는 DataCollatorForSeq2Seq 콜레 이터를 제공합니다. 이 콜레 이터를 인스턴스화하려면 토크 나이저와 모델을 매개변수로 전달하기만 하면 됩니다: from transformers import DataCollatorForSeq2Seq data_collator = DataCollatorForSeq2Seq(tokenizer, model=model) 작은 예제 배치가 입력될 때 이 콜레 이터가 무엇을 제공하는지 봅시다. 먼저 문자열로 구성된 열을 제거해야 하는데 이는 콜레 이터가 이러한 요소를 패딩(padding) 하는 방법을 모르기 때문입니다: tokenized_datasets = tokenized_datasets.remove_columns( books_dataset["train"].column_names ) 콜레 이터는 dicts의 리스트를 입력해야 하고 각 dict는 데이터 셋의 단일 예제를 나타내므로 해당 데이터를 콜레 이터에 전달하기 전에 요구하는<NAME>으로 랭글링(wrangle)해야 합니다: features = [tokenized_datasets["train"][i] for i in range(2)] data_collator(features) 여기서 주목해야 할 점은 첫 번째 예제가 두 번째 예제보다 길기 때문에 두 번째 예제의 input_ids와 attention_mask가 오른쪽에 [PAD] 토큰(ID가 0인)으로 채워져 있다는 것입니다. 마찬가지로 labels이 -100으로 채워져서 패딩 토큰이 손실 함수에 의해 무시되는지를 확실히 할 수 있습니다. 마지막으로 첫 번째 항목에 [PAD] 토큰을 삽입하여 레이블을 오른쪽으로 이동한 새로운 decoder_input_ids를 볼 수 있습니다. 드디어 학습에 필요한 모든 준비가 끝났습니다! 이제 표준 매개변수들로 trainer를 인스턴스화하기만 하면 됩니다: from transformers import Seq2SeqTrainer trainer = Seq2SeqTrainer( model, args, train_dataset=tokenized_datasets["train"], eval_dataset=tokenized_datasets["validation"], data_collator=data_collator, tokenizer=tokenizer, compute_metrics=compute_metrics, ) 학습을 시작합니다: trainer.train() 학습하는 동안 손실이 감소하고 ROUGE 점수가 각 에포크에 따라 증가하는 것을 확인해야 합니다. 학습이 완료되면 trainer.evaluate()를 실행하여 최종 ROUGE 점수를 볼 수 있습니다: trainer.evaluate() 우리 모델이 lead-3 베이스라인을 쉽게 능가했음을 알 수 있습니다. 좋습니다! 마지막으로 할 일은 다음과 같이 모델 가중치를 Hub로 푸시 하는 것입니다. trainer.push_to_hub(commit_message="Training complete", tags="summarization") 모든 파일을 허브에 업로드하기 전에 위 코드는 체크포인트 및 구성 파일을 output_dir에 저장합니다. tags 인수를 지정하여 허브의 위젯이 mT5 아키텍처와 관련된 기본 텍스트 생성 용이 아니라 요약 파이프라인용 위젯이 되도록 합니다. 모델 tags에 대한 자세한 내용은 Hub 문서를 참조하세요. trainer.push_to_hub()의 출력은 Git 커밋 해시에 대한 URL이므로 모델 리포지토리에 적용된 변경 사항을 쉽게 확인할 수 있습니다! 이제 이 섹션을 마무리하기 전에, Accelerate에서 제공하는 저 수준 기능을 사용하여 mT5를 미세 조정할 수 있는 방법을 살펴보겠습니다. Accelerate를 이용한 mT5 미세조정 Accelerate로 모델을 미세 조정하는 것은 3장에서 본 텍스트 분류 예제와 매우 유사합니다. 주요 차이점은 학습 중에 요약을 명시적으로 생성하고 ROUGE 점수를 계산하는 방법을 정의해야 한다는 것입니다. Seq2SeqTrainer가 생성 과정을 처리했음을 기억하십시오. Accelerate에서 이 두 가지 요구 사항을 구현하는 방법을 살펴보겠습니다. 학습을 위한 모든 것들을 준비하기 가장 먼저 해야 할 일은 각 분할(split)에 대한 DataLoader를 만드는 것입니다. PyTorch dataloaders는 텐서(tensors) 배치를 입력으로 받기 때문에 데이터 셋에서<NAME>을 "torch"로 설정해야 합니다: tokenized_datasets.set_format("torch") 이제 텐서로만 구성된 데이터 셋을 얻었으므로 다음으로 할 일은 DataCollatorForSeq2Seq를 다시 인스턴스화하는 것입니다. 이를 위해 모델의 새로운 버전을 제공해야 하므로 캐시에서 다시 로드해 보겠습니다: model = AutoModelForSeq2SeqLM.from_pretrained(model_checkpoint) 그런 다음 데이터 콜레 이터를 인스턴스화하고 이를 사용하여 데이터 로더를 정의할 수 있습니다: from torch.utils.data import DataLoader batch_size = 8 train_dataloader = DataLoader( tokenized_datasets["train"], shuffle=True, collate_fn=data_collator, batch_size=batch_size, ) eval_dataloader = DataLoader( tokenized_datasets["validation"], collate_fn=data_collator, batch_size=batch_size ) 다음으로 할 일은 사용할 옵티마이저를 정의하는 것입니다. 다른 예에서와 같이 대부분의 문제에 잘 작동하는 AdamW를 사용할 것입니다: from torch.optim import AdamW optimizer = AdamW(model.parameters(), lr=2e-5) 마지막으로 모델, 옵티마이저 및 dataloader를 accelerator.prepare() 메서드에 제공합니다: from accelerate import Accelerator accelerator = Accelerator() model, optimizer, train_dataloader, eval_dataloader = accelerator.prepare( model, optimizer, train_dataloader, eval_dataloader ) TPU에서 학습하는 경우 위의 모든 코드를 전용 학습 함수로 이동해야 합니다. 자세한 내용은 3장을 참조하십시오. 이제 모든 객체들을 준비했으므로 세 가지 작업이 남아 있습니다: 학습률 스케줄(learning rate schedule)을 정의합니다. 평가를 위해 요약을 후처리하는 기능을 구현합니다. 모델을 푸시 할 수 있는 허브에 리포지토리를 만듭니다. 학습률 스케줄의 경우 이전 섹션과 같이 표준 선형 일정을 사용합니다: from transformers import get_scheduler num_train_epochs = 10 num_update_steps_per_epoch = len(train_dataloader) num_training_steps = num_train_epochs * num_update_steps_per_epoch lr_scheduler = get_scheduler( "linear", optimizer=optimizer, num_warmup_steps=0, num_training_steps=num_training_steps, ) 후처리를 위해 생성된 요약을 줄 바꿈으로 구분된 문장으로 분할하는 기능이 필요합니다. 이것은 ROUGE 메트릭이 요구하는<NAME>이며 다음 코드 스니펫으로 이를 처리할 수 있습니다: def postprocess_text(preds, labels): preds = [pred.strip() for pred in preds] labels = [label.strip() for label in labels] # ROUGE는 각 문장마다 개행문자가 들어갈 것을 요구한다. preds = ["\n".join(nltk.sent_tokenize(pred)) for pred in preds] labels = ["\n".join(nltk.sent_tokenize(label)) for label in labels] return preds, labels Seq2SeqTrainer의 compute_metrics() 함수를 정의한 방법을 기억하면 익숙할 것입니다. 마지막으로 Hugging Face Hub에 모델 리포지토리를 만들어야 합니다. 이를 위해 Hub 라이브러리를 사용할 수 있습니다. 저장소의 이름을 정의하기만 하면 됩니다. 라이브러리에는 저장소 ID와 사용자 프로필을 결합하는 유틸리티 기능이 있습니다: from huggingface_hub import get_full_repo_name model_name = "test-bert-finetuned-squad-accelerate" repo_name = get_full_repo_name(model_name) repo_name 이제 이 리포지토리 이름을 사용하여 학습 아티팩트(artifacts)를 저장할 결과 디렉터리에 로컬 버전을 복제할 수 있습니다: from huggingface_hub import Repository output_dir = "results-mt5-finetuned-squad-accelerate" repo = Repository(output_dir, clone_from=repo_name) 이렇게 하면 학습 중에 repo.push_to_hub() 메서드를 호출하여 아티팩트를 허브로 다시 푸시 할 수 있습니다! 이제 학습 루프를 작성하여 분석을 마무리하겠습니다. 학습 루프 (Training loop) 요약을 위한 학습 루프는 지금까지 우리가 살펴본 다른 Accelerate 예제와 유사하며, 대체로 다음과 같은 단계로 구분될 수 있습니다: 각 epoch에 대해 train_dataloader의 모든 예제를 반복하여 모델을 학습시킵니다. 각 에포크가 끝날 때마다 모델 요약을 생성합니다. 우선 토큰들을 생성하고 이들을 텍스트로 디코딩 합니다. 앞에서 본 것과 동일한 기술을 사용하여 ROUGE 점수를 계산합니다. 체크포인트를 저장하고 모든 것을 허브로 푸시 합니다. 여기에서 Repository 객체에 blocking=False를 지정하여 에포크당 체크포인트를 비동기적으로 푸시 할 수 있습니다. 이를 통해 기가바이트 크기의 모델을 업로드 완료하기까지 기다릴 필요 없이 학습을 계속할 수 있습니다! 위 단계는 다음 코드 블록에서 볼 수 있습니다: from tqdm.auto import tqdm import torch import numpy as np progress_bar = tqdm(range(num_training_steps)) for epoch in range(num_train_epochs): # 학습 model.train() for step, batch in enumerate(train_dataloader): outputs = model(**batch) loss = outputs.loss accelerator.backward(loss) optimizer.step() lr_scheduler.step() optimizer.zero_grad() progress_bar.update(1) # 평가 model.eval() for step, batch in enumerate(eval_dataloader): with torch.no_grad(): generated_tokens = accelerator.unwrap_model(model).generate( batch["input_ids"], attention_mask=batch["attention_mask"], ) generated_tokens = accelerator.pad_across_processes( generated_tokens, dim=1, pad_index=tokenizer.pad_token_id ) labels = batch["labels"] # 만일 최대 길이로 패딩 하지 않았으면 레이블도 역시 패딩 해야 한다. labels = accelerator.pad_across_processes( batch["labels"], dim=1, pad_index=tokenizer.pad_token_id ) generated_tokens = accelerator.gather(generated_tokens).cpu().numpy() labels = accelerator.gather(labels).cpu().numpy() # 레이블 내의 -100을 모두 교체한다. labels = np.where(labels != -100, labels, tokenizer.pad_token_id) if isinstance(generated_tokens, tuple): generated_tokens = generated_tokens[0] decoded_preds = tokenizer.batch_decode( generated_tokens, skip_special_tokens=True ) decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True) decoded_preds, decoded_labels = postprocess_text( decoded_preds, decoded_labels ) rouge_score.add_batch(predictions=decoded_preds, references=decoded_labels) # 메트릭 계산 result = rouge_score.compute() # 중간값 ROUGE 점수를 추출 result = {key: value.mid.fmeasure * 100 for key, value in result.items()} result = {k: round(v, 4) for k, v in result.items()} print(f"Epoch {epoch}:", result) # 저장 및 업로드 accelerator.wait_for_everyone() unwrapped_model = accelerator.unwrap_model(model) unwrapped_model.save_pretrained(output_dir, save_function=accelerator.save) if accelerator.is_main_process: tokenizer.save_pretrained(output_dir) repo.push_to_hub( commit_message=f"Training in progress epoch {epoch}", blocking=False ) 이게 끝입니다! 위 코드를 실행하면 Trainer로 얻은 것과 매우 유사한 모델과 결과를 얻게 됩니다. 미세 조정된 모델 사용하기 모델을 Hub로 푸시 한 후에는 다음과 같이 추론 위젯 또는 파이프라인 객체를 통해 모델을 사용할 수 있습니다: from transformers import pipeline hub_model_id = "huggingface-course/mt5-small-finetuned-amazon-en-es" summarizer = pipeline("summarization", model=hub_model_id) 우리는 요약 결과 품질이 어떤지 살펴보기 위해 테스트셋(모델이 본 적이 없는)의 몇 가지 예를 파이프라인에 제공할 수 있습니다. 먼저 리뷰, 제목 및 생성된 요약을 함께 표시하는 간단한 기능을 구현해 보겠습니다: def print_summary(idx): review = books_dataset["test"][idx]["review_body"] title = books_dataset["test"][idx]["review_title"] summary = summarizer(books_dataset["test"][idx]["review_body"])[0]["summary_text"] print(f"'>>> Review: {review}'") print(f"\n'>>> Title: {title}'") print(f"\n'>>> Summary: {summary}'") 영어 예시 중 하나를 살펴보겠습니다. print_summary(100) 결과가 나쁘지 않네요! 우리는 모델이 새로운 단어로 리뷰의 일부를 보강함으로써 실제로 추상적인 요약(abstractive summarization)을 수행할 수 있다는 것을 알 수 있습니다. 그리고 아마도 우리 모델의 가장 멋진 측면은 이중 언어를 제공한다는 점입니다. 따라서 스페인어 리뷰의 요약을 생성할 수도 있습니다: print_summary(0) 요약 결과는 영어로 "Very easy to read"로 번역되며, 이 경우에는 리뷰에서 직접 추출되었음을 알 수 있습니다. 그럼에도 불구하고 이 결과는 mT5 모델의 다재다능함을 보여주고 다국어 말뭉치를 다루는 것이 어떤 것인지 맛보게 해주었습니다! 다음 섹션에서 언어 모델을 처음부터 학습하는(from scratch) 약간 더 복잡한 작업에 관심을 가져봅시다. 5. 인과적 언어 모델(Causal Language Model)을 처음부터 학습하기 지금까지 우리는 대부분의 작업 과정에서 사전 학습된 모델을 사용하고 사전 학습 가중치를 재사용하여 해당 사용 사례(use case)에 맞게 적절하게 미세 조정했습니다. 1장에서 보았듯이 이를 일반적으로 전이 학습(transfer learning)이라고 하며 레이블이 지정된 데이터가 부족한 대부분의 실제 사용 사례(use case)에 Transformer 모델을 적용하는 매우 성공적인 전략입니다. 이 장에서는 이와는 다르게 완전히 새로운 모델을 처음부터 학습할 것입니다. 이는 당신이 데이터를 충분히 가지고 있고 해당 데이터가 기존 사전 학습 모델에 사용된 데이터와 매우 다른 데이터일 경우 좋은 접근 방법입니다. 그러나 기존 모델을 미세 조정하는 것보다 언어 모델을 사전 학습하는 데 훨씬 더 많은 컴퓨팅 리소스가 필요합니다. 새 모델을 새롭게 사전 학습시키는 것이 합리적일 수 있는 예로는 음표, DNA와 같은 분자 서열 또는 프로그래밍 코드 등으로 구성된 데이터 셋들이 있습니다. 후자는 긴 코드 시퀀스를 생성할 수 있는 OpenAI의 Codex 모델로 구동되는 TabNine 및 GitHub의 Copilot과 같은 도구 덕분에 최근 주목을 받았습니다. 이러한 텍스트 생성 작업은 GPT-2와 같은 자동 회귀(auto-regressive) 또는 인과적 언어 모델(causal language model)로 가장 잘 처리됩니다. 이 섹션에서는 코드 생성 모델의 축소 버전을 구축할 것입니다. Python 코드의 하위 집합을 사용하여 전체 함수나 클래스 대신 한 줄 완성(one-line completions)에 중점을 둘 것입니다. Python에서 데이터 작업을 수행할 때 matplotlib, seaborn, pandas 및 scikit-learn 라이브러리로 구성된 Python 데이터 과학 코드 집합과 자주 접하게 됩니다. 이러한 프레임워크를 사용할 때 특정 명령을 조회해야 하는 것이 일반적이므로 모델을 사용하여 이러한 요구를 처리할 수 있다면 좋을 것입니다. 6장에서 우리는 Python 소스 코드를 처리하기 위한 효율적인 토크 나이저를 만들었지만 여전히 필요한 것은 모델을 사전 학습할 대규모 데이터 셋입니다. 여기에서는 GitHub 리포지토리에서 파생된 Python 코드 모음에 토크 나이저를 적용합니다. 그런 다음 Trainer API와 Accelerate를 사용하여 모델을 학습합니다. 한번 시도해 봅시다! 실제로 이 섹션에 표시된 코드를 사용하여 학습되고 Hub에 업로드된 모델을 보여줍니다. 여기에서 찾을 수 있습니다. 텍스트 생성에서 약간의 무작위화(rnadomization)가 발생하기 때문에 약간 다른 결과를 얻을 수 있습니다. 데이터 모으기 Python 코드는 GitHub와 같은 코드 리포지토리에서 풍부하게 제공되며, 모든 Python 리포지토리를 스크랩하여 데이터 셋을 만드는 데 사용할 수 있습니다. 이것은 대형 GPT-2 모델을 사전 학습시키기 위해 Transformers 교과서에서 취한 접근 방식이었습니다. 작성자는 codeparrot이라는 약 2천만 개의 Python 파일이 포함된 약 180GB의 GitHub 덤프를 사용하여 데이터 셋을 구축한 다음 Hugging Face Hub에서 공유했습니다. 그러나 전체 말뭉치에 대한 학습은 계산량과 학습 시간이 너무 많이 들기 때문에, 여기서는 Python 데이터 과학 스택과 관련된 데이터 셋의 하위 집합만 사용하겠습니다. 따라서 이 스택의 라이브러리를 포함하는 모든 파일에 대해 codeparrot 데이터 셋을 필터링하여 시작하겠습니다. 데이터 셋의 크기 때문에 다운로드를 피하고 싶습니다. 대신 스트리밍 기능을 사용하여 즉석에서 필터링합니다. 앞에서 언급한 라이브러리를 사용하여 코드 샘플을 필터링하는 데 도움이 되도록 다음 함수를 사용합니다: def any_keyword_in_string(string, keywords): for keyword in keywords: if keyword in string: return True return False 두 가지 예를 가지고 테스트해 보겠습니다: filters = ["pandas", "sklearn", "matplotlib", "seaborn"] example_1 = "import numpy as np" example_2 = "import pandas as pd" print(any_keyword_in_string(example_1, filters), any_keyword_in_string(example_2, filters)) 이 함수를 사용하여 데이터 셋을 스트리밍하고 원하는 요소를 필터링하는 함수를 만들 수 있습니다: from collections import defaultdict from tqdm import tqdm from datasets import Dataset def filter_streaming_dataset(dataset, filters): filtered_dict = defaultdict(list) total = 0 for sample in tqdm(iter(dataset)): total += 1 if any_keyword_in_string(sample["content"], filters): for k, v in sample.items(): filtered_dict[k].append(v) print(f"{len(filtered_dict['content'])/total:.2%} of data after filtering.") return Dataset.from_dict(filtered_dict) 그런 다음 이 함수를 스트리밍 데이터 셋에 간단히 적용할 수 있습니다: # 이 코드 셀은 실행 시간이 매우 깁니다. 따라서 그냥 생략하고 다음으로 넘어가시기 바랍니다! from dataset import load_dataset split = "train" filters = ["pandas", "sklearn", "matplotlib", "seaborn"] data = load_dataset(f"transformersbook/codeparrot-{split}", split=split, streaming=True) filtered_data = filter_streaming_dataset(data, filters) 이렇게 필터링하면 원본 데이터 셋의 약 3%가 남게 되나 이 역시도 여전히 상당한 규모입니다. 결과 데이터 셋은 6GB이고 600,000개의 Python 스크립트로 구성됩니다! 전체 데이터 세트를 필터링하는 데 컴퓨터와 대역폭에 따라 2-3시간이 걸릴 수 있습니다. 이 많은 시간이 걸리는 프로세스를 직접 수행하고 싶지 않다면 허브에서 필터링 된 데이터 셋을 직접 다운로드할 수 있습니다: from datasets import load_dataset, DatasetDict ds_train = load_dataset("huggingface-course/codeparrot-ds-train", split="train") ds_valid = load_dataset("huggingface-course/codeparrot-ds-valid", split="validation") raw_datasets = DatasetDict( { "train": ds_train.shuffle().select(range(50000)), "valid": ds_valid.shuffle().select(range(500)) } ) raw_datasets 언어 모델을 사전 학습하는 데는 시간이 걸립니다. 먼저 위의 두 부분 행의 주석을 제거하여 데이터 샘플에서 학습 루프를 실행하고 학습이 성공적으로 완료되고 모델이 저장되었는지 확인하는 것이 좋습니다. 폴더를 만드는 것을 잊었거나 학습 루프의 끝에 오타가 있어서 마지막 단계에서 학습 실행이 실패하는 것보다 더 실망스러운 것은 없습니다! 이제 다운로드한 데이터 셋의 내용을 살펴보겠습니다. 각 필드의 처음 200자만 표시합니다: for key in raw_datasets["train"][0]: print(f"{key.upper()}: {raw_datasets['train'][0][key][:200]}") content 필드에 모델이 학습할 코드가 포함되어 있음을 알 수 있습니다. 이제 데이터 셋이 있으므로 사전 학습에 적합한<NAME>으로 텍스트를 준비해야 합니다. 데이터 셋 준비하기 첫 번째 단계는 데이터를 토큰화하여 학습에 사용할 수 있도록 하는 것입니다. 우리의 목표는 주로 짧은 함수 호출을 자동 완성하는 것이기 때문에 컨텍스트 크기를 비교적 작게 유지할 수 있습니다. 이는 모델을 훨씬 빠르게 학습할 수 있고 훨씬 적은 메모리를 필요로 한다는 이점이 있습니다. 애플리케이션이 더 많은 컨텍스트를 유지하는 것이 중요한 경우(예를 들어, 모델이 함수 정의가 있는 파일을 기반으로 단위 테스트 코드를 자동으로 작성하도록 하려는 경우), 그 수를 늘려야 합니다. 그러나 이것은 더 큰 규모의 GPU 메모리를 필요로 한다는 사실을 명심하세요. 지금은 컨텍스트 크기를 GPT-2 또는 GPT-3에서 각각 사용되는 1,024 또는 2,048과 달리 128 토큰으로 수정하겠습니다. 대부분의 문서에는 128개 이상의 토큰이 포함되어 있으므로 입력을 최대 길이로 자르면 데이터 셋의 많은 부분이 제거됩니다. 대신 6장에서 했던 것처럼 return_overflowing_tokens 옵션을 사용하여 전체 입력을 토큰화하고 여러 청크로 분할합니다. 또한 return_length 옵션을 사용하여 생성된 각 청크의 길이를 자동으로 반환합니다. 종종 마지막 청크는 컨텍스트 크기보다 작으며 패딩 문제를 피하기 위해 이러한 조각을 제거합니다. 어쨌든 데이터가 많기 때문에 크게 문제가 되지는 않습니다. 데이터 셋의 처음 두 개의 예제를 보고 이것이 어떻게 작동하는지 정확히 봅시다: from transformers import AutoTokenizer context_length = 128 tokenizer = AutoTokenizer.from_pretrained("huggingface-course/code-search-net-tokenizer") outputs = tokenizer( raw_datasets["train"][:2]["content"], truncation=True, max_length=context_length, return_overflowing_tokens=True, return_length=True, ) print(f"Input IDs length: {len(outputs['input_ids'])}") print(f"Input chunk lengths: {(outputs['length'])}") print(f"Chunk mapping: {outputs['overflow_to_sample_mapping']}") 이 두 가지 예에서 총 34개의 세그먼트를 얻었음을 알 수 있습니다. 청크 길이를 보면 두 문서의 끝에 있는 청크에 128개 미만의 토큰이 있음을 알 수 있습니다(각각 117 및 41). 이 숫자는 우리가 가지고 있는 전체 청크의 일부분에 불과하므로 안전하게 버릴 수 있습니다. overflow_to_sample_mapping 필드를 사용하면 어떤 청크가 어떤 입력 샘플에 속하는지 재구성할 수도 있습니다. 이 작업에서 우리는 Datasets에서 Dataset.map() 함수의 편리한 기능을 사용하고 있습니다. 즉, 일대일 맵이 필요하지 않습니다. 섹션 3에서 보았듯이 입력 배치보다 많거나 적은 요소로 배치를 생성할 수 있습니다. 이는 요소 수를 변경하는 데이터 증대(augmentation) 또는 데이터 필터링과 같은 작업을 수행할 때 유용합니다. 우리의 경우 각 요소를 지정된 컨텍스트 크기의 청크로 토큰화할 때 각 문서에서 많은 샘플을 만듭니다. 크기가 달라지기 때문에 기존 열을 삭제하기만 하면 됩니다. 만일 이들을 유지하려면 적절하게 반복하고 Dataset.map() 호출 내에서 반환할 수 있습니다: def tokenize(element): outputs = tokenizer( element['content'], truncation=True, max_length=context_length, return_overflowing_tokens=True, return_length=True, ) input_batch = [] for length, input_ids in zip(outputs['length'], outputs['input_ids']): if length == context_length: input_batch.append(input_ids) return {"input_ids": input_batch} tokenized_datasets = raw_datasets.map( tokenize, batched=True, remove_columns=raw_datasets["train"].column_names) tokenized_datasets 이제 각각 128개의 토큰이 있는 1,670만 개의 예제가 있으며 이는 약 21억 개의 토큰에 해당합니다. 참고로 OpenAI의 GPT-3와 Codex 모델은 각각 3,000억 개, 1,000억 개 토큰에 대해 학습을 하며, Codex 모델은 GPT-3 체크포인트에서 초기화됩니다. 이 섹션의 목표는 길이가 길고 일관된 텍스트를 생성할 수 있는 이러한 모델과 경쟁하는 것이 아니라 데이터 과학자에게 빠른 자동 완성 기능을 제공하는 축소 버전을 만드는 것입니다. 이제 데이터 셋이 준비되었으므로 모델을 설정하겠습니다! ✏ Try it out! 작은 범위의 컨텍스트를 사용하기 때문에 컨텍스트 크기보다 작은 모든 청크를 제거하는 것은 큰 문제가 되지 않았습니다. 컨텍스트 크기를 늘리면(또는 짧은 문서 모음이 있는 경우) 버려지는 청크의 비율도 늘어납니다. 데이터를 준비하는 더 효율적인 방법은 사이에 eos_token_id 토큰을 사용하여 단일 배치 내의 모든 토큰화된 샘플을 결합한 다음 결합된 시퀀스에서 청킹을 수행하는 것입니다. 연습 삼아 해당 접근 방식을 사용하도록 tokenize() 함수를 수정해 봅시다. truncation=False를 설정하고 토크 나이저에서 다른 인수를 제거하여 토큰 ID의 전체 시퀀스를 얻을 수 있습니다. 새로운 모델의 초기화 첫 번째 단계는 GPT-2 모델을 새로 초기화하는 것입니다. 소형 GPT-2 모델과 동일한 설정을 우리 모델에 사용합니다. 따라서, 사전 학습된 설정을 로드하고 토크 나이저 크기가 모델 어휘 크기와 일치하고 bos 및 eos(시퀀스의 시작 및 끝) 토큰 ID를 전달하는지 확인합니다: from transformers import AutoTokenizer, GPT2LMHeadModel, AutoConfig config = AutoConfig.from_pretrained( "gpt2", vocab_size=len(tokenizer), n_ctx=context_length, bos_token_id=tokenizer.bos_token_id, eos_token_id=tokenizer.eos_token_id ) 해당 설정으로 새 모델을 로드할 수 있습니다. 우리가 실제로 모델을 직접 초기화하기 때문에 from_pretrained() 함수를 사용하지 않는 것은 이번이 처음입니다: model = GPT2LMHeadModel(config) model_size = sum(t.numel() for t in model.parameters()) print(f"GPT-2 size: {model_size/1000**2:.1f}M parameters") 우리 모델에는 최적화해야 할 1억 2400만 개의 매개변수가 있습니다. 학습을 시작하기 전에 배치 생성을 처리할 데이터 콜레 이터를 설정해야 합니다. 언어 모델링을 위해 특별히 설계된 DataCollatorForLanguageModeling 콜레 이터를 사용할 수 있습니다(이름에서 알 수 있듯이). 배치를 쌓고 패딩 하는 것 외에도 언어 모델 레이블 생성도 처리합니다. 인과적 언어 모델링(causal language modeling)에서 입력은 레이블 역할도 합니다. 그리고 이 데이터 콜레 이터는 학습 중에 즉시 입력을 생성하므로 input_ids를 복제할 필요가 없습니다. DataCollatorForLanguageModeling은 마스크 언어 모델링(MLM)과 인과적 언어 모델링(CLM)을 모두 지원합니다. 기본적으로 MLM 용 데이터를 제공하지만 mlm=False 인수를 설정하여 CLM으로 전환할 수 있습니다: from transformers import DataCollatorForLanguageModeling tokenizer.pad_token = tokenizer.eos_token data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False) 예를 살펴보겠습니다: out = data_collator([tokenized_datasets["train"][i] for i in range(5)]) for key in out: print(f"{key} shape: {out[key].shape}") 예제가 배치로 분리되어 쌓였고 모든 텐서의 모양이 같은 것을 볼 수 있습니다. ⚠ 입력과 레이블을 시프팅(shifting)하여 정렬(align) 하는 것은 모델 내부에서 발생하므로 데이터 콜레 이터는 입력을 복사하여 레이블을 생성합니다. 이제 모델을 실제로 학습할 수 있게 모든 것이 준비되었습니다. 결국 그렇게 많은 작업이 필요하지 않았습니다! 학습을 시작하기 전에 Hugging Face에 로그인해야 합니다. 노트북에서 작업하는 경우 다음 유틸리티 기능을 사용하여 작업할 수 있습니다: from huggingface_hub import notebook_login notebook_login() 그러면 Hugging Face 로그인 자격 증명을 입력할 수 있는 위젯이 표시됩니다. 남은 일은 학습 인자(training arguments)를 구성하고 Trainer를 실행하는 것입니다. 약간의 워밍업과 256의 효과적인 배치 크기(per_device_train_batch_size * gradient_accumulation_steps)로 코사인 학습률 일정을 사용합니다. 그레이디언트 누적은 단일 배치가 메모리에 맞지 않을 때 사용되며 여러 정방향/역방향 패스를 통해 그레이디언트를 점진적으로 구축합니다. Accelerate를 사용하여 학습 루프를 만들 때 이것이 실제로 작동하는 것을 볼 수 있습니다. from transformers import Trainer, TrainingArguments args = TrainingArguments( output_dir="codeparrot-ds", per_device_train_batch_size=32, per_device_eval_batch_size=32, evaluation_strategy="steps", eval_steps=5000, logging_steps=5000, gradient_accumulation_steps=8, num_train_epochs=1, weight_decay=0.1, warmup_steps=1000, lr_scheduler_type="cosine", learning_rate=5e-4, save_steps=5000, fp16=True, push_to_hub=True, ) trainer = Trainer( model=model, tokenizer=tokenizer, args=args, data_collator=data_collator, train_dataset=tokenized_datasets["train"], eval_dataset=tokenized_datasets["valid"], ) 이제 Trainer를 시작하고 학습이 끝날 때까지 기다리면 됩니다. 학습 집합의 전체 혹은 부분 집합에서 실행하는지에 따라 각각 20시간 또는 2시간이 소요되므로 커피 몇 잔과 읽을 만한 좋은 책을 가져오세요! trainer.train() 학습이 완료되면 모델과 토크 나이저를 허브로 푸시 할 수 있습니다. ✏ Try it out! 원시 텍스트에서 GPT-2를 학습하는 데에는 TrainingArguments 외에 약 30줄의 코드만 필요했습니다. 자신의 데이터 셋으로 시도해 보고 좋은 결과를 얻을 수 있는지 확인하십시오! GPU가 여러 개인 컴퓨터에 액세스할 수 있는 경우 해당 컴퓨터에서 코드를 실행해 보세요. Trainer는 여러 대의 머신을 자동으로 관리하므로 학습 속도를 크게 높일 수 있습니다. 파이프라인을 이용한 코드 생성 이제 진실의 순간입니다. 학습된 모델이 실제로 얼마나 잘 작동하는지 봅시다! 로그에서 손실이 꾸준히 감소했음을 알 수 있지만 모델을 테스트하기 위해 특정 프롬프트에서 얼마나 잘 작동하는지 살펴보겠습니다. 그러기 위해 우리는 텍스트 생성 파이프라인에서 모델을 래핑하고 빠른 생성을 위해 가용 GPU에 이를 탑재할 것입니다: import torch from transformers import pipeline device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu") pipe = pipeline( "text-generation", model="huggingface-course/codeparrot-ds", device=device ) 산점도(scatter plot)를 만드는 간단한 작업부터 시작해 보겠습니다: txt = """\ # create some data x = np.random.randn(100) y = np.random.randn(100) # create scatter plot with x, y """ print(pipe(txt, num_return_sequences=1)[0]["generated_text"]) 결과가 정확해 보입니다. pandas 작업에서도 잘 작동할까요? 두 개의 배열에서 DataFrame을 만들 수 있는지 봅시다: txt = """\ # create some data x = np.random.randn(100) y = np.random.randn(100) # create dataframe from x and y """ print(pipe(txt, num_return_sequences=1)[0]["generated_text"]) 좋습니다. 비록 x 칼럼을 다시 삽입했지만 그래도 정확한 답입니다. 생성되는 토큰의 수가 제한되어 있으므로 다음 for 루프가 잘립니다. 좀 더 복잡한 작업을 수행할 수 있고 모델이 우리가 groupby 작업을 사용하는 데 도움을 줄 수 있는지 알아봅시다: txt = """\ # dataframe with profession, income and name df = pd.DataFrame({'profession': x, 'income':y, 'name': z}) # calculate the mean income per profession """ print(pipe(txt, num_return_sequences=1)[0]["generated_text"]) 결과가 나쁘지 않네요. 그것이 올바른 방법입니다. 마지막으로 scikit-learn에도 사용할 수 있는지, 또한 Random Forest 모델을 설정할 수 있는지 봅시다: txt = """ # import random forest regressor from scikit-learn from sklearn.ensemble import RandomForestRegressor # fit random forest model with 300 estimators on X, y: """ print(pipe(txt, num_return_sequences=1)[0]["generated_text"]) 위의 몇 가지 예를 보면 우리 모델이 Python 데이터 과학 스택의 구문 중 일부를 학습한 것 같습니다. 물론 실제 세계에 모델을 배포하기 전에 더 철저하게 평가해야 하겠지요. 그러나 때로는 주어진 사용 사례에 필요한 성능을 달성하기 위해 모델 학습 시에 다양한 방법을 도입해야 합니다. 예를 들어, 배치 크기를 동적으로 업데이트하거나 잘못된 예제를 즉시 건너뛰는 조건부 학습 루프를 갖고 싶다면 어떻게 해야 할까요? 한 가지 선택지는 Trainer를 서브 클래스로 만들고 필요한 변경 사항을 추가하는 것이지만 때로는 아예 처음부터 학습 루프를 작성하는 것이 더 간단합니다. 여기서 Accelerate가 등장합니다. Accelerate를 이용한 학습 우리는 지금까지 Trainer로 모델을 학습하는 방법을 보았습니다. 이 방법에서도 몇 가지 사용자 지정 설정 변경을 할 수 있었습니다. 그러나 때때로 우리는 학습 루프에 대한 완전한 제어를 원하거나 약간의 예외적인 변경을 원합니다. 이 경우 Accelerate는 훌륭한 선택이며 이 섹션에서는 이를 사용하여 모델을 학습시키는 단계를 살펴보겠습니다. 작업을 더 흥미롭게 만들기 위해 우리는 또한 학습 루프에 약간의 변형을 주겠습니다. 우리는 주로 데이터 과학 라이브러리에 대한 합리적인 자동 완성에 관심이 있기 때문에 이러한 라이브러리를 더 많이 사용하는 학습 샘플에 더 많은 가중치를 부여하는 것이 합리적입니다. matplotlib.pyplot, pandas, sklearn의 가장 빈번한 import 이름인 plt, pd, sk 및 fit, predict와 같은 키워드와 fit/predict 패턴을 사용하여 이러한 예를 쉽게 식별할 수 있습니다. 이것들이 각각 하나의 토큰으로 표현된다면 입력 시퀀스에서 발생하는지 쉽게 확인할 수 있습니다. 토큰에는 공백 접두어가 있을 수 있으므로 토크 나이저 어휘에서도 해당 버전을 확인할 것입니다. 이 방법이 작동하는지 확인하기 위해 여러 토큰으로 분할되어야 하는 하나의 테스트 토큰을 추가합니다: keytoken_ids = [] for keyword in [ "plt", "pd", "sk", "fit", "predict", " plt", " pd", " sk", " fit", " predict", "testtest", ]: ids = tokenizer([keyword]).input_ids[0] if len(ids) == 1: keytoken_ids.append(ids[0]) else: print(f"Keyword has not single token: {keyword}") 훌륭합니다. 잘 작동하는 것 같습니다! 이제 입력 시퀀스, 로짓 및 방금 입력으로 선택한 키 토큰을 사용하는 사용자 지정 손실 함수를 작성할 수 있습니다. 먼저 로짓과 입력을 정렬해야 합니다. 다음 토큰이 현재 토큰의 레이블이기 때문에 오른쪽으로 1만큼 이동한 입력 시퀀스가 레이블을 형성합니다. 모델은 어쨌든 첫 번째 토큰에 대한 예측을 하지 않기 때문에 입력 시퀀스의 두 번째 토큰에서 레이블을 시작하여 이를 달성할 수 있습니다. 그런 다음 전체 입력 시퀀스를 따르는 토큰에 대한 레이블이 없기 때문에 마지막 로짓을 잘라냅니다. 이를 통해 샘플당 손실을 계산하고 각 샘플에서 모든 키워드의 발생을 계산할 수 있습니다. 마지막으로 발생 횟수를 가중치로 사용하여 모든 샘플에 대한 가중 평균을 계산합니다. 키워드가 없는 샘플을 모두 버리고 싶지 않기 때문에 가중치에 1을 더합니다: from torch.nn import CrossEntropyLoss import torch def keytoken_weighted_loss(inputs, logits, keytoken_ids, alpha=1.0): # Shift so that tokens < n predict n shift_labels = inputs[..., 1:].contiguous() shift_labels = logits[..., :-1, :].contiguous() # 토큰당 손실 값 계산 loss_fct = CrossEntropyLoss(reduce=False) loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1)) # 샘플당 손실 값을 resize 하고 평균화 loss_per_sample = loss.view(shift_logits.size(0), shift_logits.size(1)).mean(axis=1) # Calculate and scale weighting weights = torch.stack([(inputs == kt).float() for kt in keytoken_ids]).sum(axis=[0, 2]) weights = alpha * (1.0 + weights) # Calculate weighted average weighted_loss = (loss_per_sample * weights).mean() return weighted_loss 이 멋진 새로운 손실 함수로 학습을 시작하기 전에 몇 가지를 준비해야 합니다. 데이터를 일괄적으로 로드하려면 dataloaders가 필요합니다. 가중치 감소 매개변수를 설정해야 합니다. 때때로 우리는 평가를 원하므로 평가 코드를 함수로 래핑 하는 것이 합리적입니다. dataloaders부터 시작하겠습니다. 데이터 셋의<NAME>을 "torch"로 설정하기만 하면 적절한 배치 크기로 PyTorch DataLoader에 전달할 수 있습니다: from torch.utils.data.dataloader import DataLoader tokenized_dataset.set_format("torch") train_dataloader = DataLoader(tokenized_dataset["train"], batch_size=32, shuffle=True) eval_dataloader = DataLoader(tokenized_dataset["valid"], batch_size=32) 다음으로, 최적화 프로그램이 추가 가중치 감소를 얻을 매개변수를 알 수 있도록 매개변수를 그룹화합니다. 일반적으로 모든 편향(bias) 및 LayerNorm 가중치 조건은 예외입니다. 이 작업을 수행하는 방법은 다음과 같습니다: weight_decay = 0.1 def get_grouped_params(model, no_decay=["bias", "LayerNorm.weight"]): params_with_wd, params_without_wd = [], [] for n, p in model.named_parameters(): if any(nd in n for nd in no_decay): params_without_wd.append(p) else: params_with_wd.append(p) return [ {"params": params_with_wd, "weight_decay": weight_decay}, {"params": params_without_wd, "weight_decay": 0.0}, ] 학습 중에 검증 세트에서 모델을 정기적으로 평가하기를 원하기 때문에 이에 대한 함수도 작성해 보겠습니다. 평가 dataloader를 통해 실행되고 프로세스 전반에 걸쳐 모든 손실을 수집합니다: def evaluate(): model.eval() losses = [] for step, batch in enumerate(eval_dataloader): with torch.no_grad(): outputs = model(batch["input_ids"], labels=batch["input_ids"]) losses.append(accelerator.gather(outputs.loss)) loss = torch.mean(torch.cat(losses)) try: perplexity = torch.exp(loss) except OverflowError: perplexity = float("inf") return loss.item(), perplexity.item() evaluate() 함수를 사용하여 정기적인 간격으로 손실과 perplexity를 보고할 수 있습니다. 다음으로, 처음부터 다시 학습 모델을 재정의합니다: model = GPT2LMHeadModel(config) 그런 다음, 가중치 감소 대상 매개변수를 분리하기 위해 이전의 함수를 사용하여 최적화 프로그램을 정의할 수 있습니다: from torch.optim import AdamW optimizer = AdamW(get_grouped_params(model), lr=5e-4) 이제 학습을 시작할 수 있도록 모델, 옵티마이저 및 dataloaders를 준비하겠습니다: from accelerate import Accelerator accelerator = Accelerator(fp16=True) model, optimizer, train_dataloader, eval_dataloader = accelerator.prepare( model, optimizer, train_dataloader, eval_dataloader ) TPU에서 학습하는 경우 위의 셀에서 시작하는 모든 코드를 전용 학습 함수로 이동해야 합니다. 자세한 내용은 3장을 참조하십시오. 이제 train_dataloader를 accelerator.prepare()로 보냈으므로 길이를 사용하여 학습 단계 수를 계산할 수 있습니다. 반드시 dataloader를 준비한 후에 이 작업을 수행해야 합니다. 길이가 변경되기 때문입니다. 또한 학습률에서 0까지의 고전적인 선형 스케줄링을 사용합니다: from transformers import get_scheduler num_train_epochs = 1 num_update_steps_per_epoch = len(train_dataloader) num_training_steps = num_train_epochs * num_update_steps_per_epoch lr_scheduler = get_scheduler( name="linear", optimizer=optimizer, num_warmup_steps=1000, num_training_steps=num_training_steps, ) 마지막으로 모델을 Hub로 푸시 하려면 작업 폴더에 Repository 객체를 생성해야 합니다. 아직 로그인하지 않았다면 먼저 Hugging Face Hub에 로그인하세요. 모델에 부여하려는 모델 ID에서 저장소 이름을 결정합니다. repo_name을 원하는 대로 자유롭게 바꾸십시오. get_full_repo_name() 함수가 수행하는 사용자 이름만 포함하면 됩니다: from huggingface_hub import Repository, get_full_repo_name model_name = "codeparrot-ds-accelerate" repo_name = get_full_repo_name(model_name) repo_name 그런 다음 해당 저장소를 로컬 폴더에 복제할 수 있습니다. 이미 존재하는 경우 이 로컬 폴더는 작업 중인 리포지토리의 기존 복제본이어야 합니다: output_dir = "codeparrot-ds-accelerate" repo = Repository(output_dir, clone_from=repo_name) 이제 repo.push_to_hub() 메서드를 호출하여 output_dir에 저장한 모든 것을 업로드할 수 있습니다. 이렇게 하면 각 에포크가 끝날 때 중간 모델을 업로드하는 데 도움이 됩니다. 학습하기 전에 평가 기능이 제대로 작동하는지 확인하기 위해 빠른 테스트를 실행해 보겠습니다: evaluate() 매우 높은 손실과 perplexity 값이지만 아직 모델을 학습하지 않았기 때문에 놀라운 일이 아닙니다. 이것으로 학습 스크립트의 핵심 부분인 학습 루프를 작성할 모든 준비가 완료되었습니다. 학습 루프에서 dataloader를 반복하고 배치를 모델에 전달합니다. 그런 다음 로짓을 사용하여 사용자 정의 손실 함수를 평가할 수 있습니다. 더 많은 단계를 집계할 때 더 큰 손실을 생성하지 않도록 그레이디언트 누적 단계의 수만큼 손실을 조절합니다. 최적화하기 전에 더 나은 수렴을 위해 그레이디언트를 클리핑(clip) 합니다. 마지막으로 몇 단계마다 새로운 evaluate() 함수를 사용하여 평가 세트의 모델을 평가합니다: from tqdm.notebook import tqdm gradient_accumulation_steps = 8 eval_steps = 5000 model.train() completed_steps = 0 for epoch in range(num_train_epochs): for step, batch in tqdm(enumerate(train_dataloader, start=1), total=num_training_steps): logits = model(batch["input_ids"]).logits loss = keytoken_weighted_loss(batch["input_ids"], logits, keytoken_ids) if step % 100 == 0: accelerator.print( { "lr": get_lr(), "samples": step * samples_per_step, "steps": completed_steps, "loss/train": loss.item() * gradient_accumulation_steps, } ) loss = loss / gradient_accumulation_steps accelerator.backward(loss) if step % gradient_accumulation_steps == 0: accelerator.clip_grad_norm_(model.parameters(), 1.0) optimizer.step() lr_scheduler.step() optimizer.zero_grad() completed_steps += 1 if (step % (eval_steps * gradient_accumulation_steps)) == 0: eval_loss, perplexity = evaluate() accelerator.print({"loss/eval": eval_loss, "perplexity": perplexity}) model.train() accelerator.wait_for_everyone() unwrapped_model = accelerator.unwrap_model(model) unwrapped_model.save_pretrained(output_dir, save_function=accelerator.save) if accelerator.is_main_process: tokenizer.save_pretrained(output_dir) repo.push_to_hub( commit_message=f"Training in progress step {step}", blocking=False ) 그게 전부입니다. 이제 GPT-2와 같은 인과적 언어 모델에 대한 고유한 사용자 지정 학습 루프가 있으므로 이를 필요에 따라 추가로 변경해서 활용할 수 있습니다. ✏ Try it out! 사용 사례에 맞는 맞춤형 손실 함수를 생성하거나 학습 루프에 다른 맞춤형 단계를 추가해 보십시오. ✏ Try it out! 긴 학습 실험을 실행할 때 TensorBoard 또는 Weights & Biases와 같은 도구를 사용하여 중요한 메트릭을 기록하는 것이 좋습니다. 학습이 어떻게 진행되고 있는지 항상 확인할 수 있도록 학습 루프에 적절한 로깅을 추가하십시오. 6. 질의응답 (Question Answering) 이제 질의응답을 살펴볼 시간입니다. 이 작업은 여러 종류가 있지만 이 섹션에서 중점적으로 다룰 작업은 추출형 질의응답(extractive question answering)입니다. 이는 문서에 대해서 질문을 제시하고 문서 자체에 존재하는 텍스트 범위(spans of text)를 해당 질문에 대한 답변으로 추출하는 작업입니다. Wikipedia 기사를 기반으로 크라우드 소싱 형태로 질문과 답변을 구축한 SQuAD 데이터 셋을 가지고 BERT 모델을 미세 조정할 것입니다. 이렇게 하면 다음과 같은 예측을 도출할 수 있는 모델이 제공됩니다: 이것은 실제로 이 섹션에 표시된 코드를 사용하여 학습되고 Hub에 업로드된 모델을 보여줍니다. 여기에서 예측을 찾아 다시 확인할 수 있습니다. BERT와 같은 인코더 전용 모델은 "누가 Transformer 아키텍처를 발명했습니까?"와 같은 사실적인 질문(factoid questions)에 대한 답변을 추출하는 데 우수한 성능을 나타내는 경향이 있습니다. 그러나 "하늘은 왜 파란색입니까?"와 같은 개방형 질문(open-ended questions)이 주어지면 제대로 처리되지 않습니다. 이런 답변하기 어려운 질문을 처리하는 경우에 T5 및 BART와 같은 인코더-디코더 모델은 일반적으로 텍스트 요약과 매우 유사한 방식으로 정보를 합성하는 데 사용됩니다. 이러한 유형의 생성 기반 질의응답(generative question answering)에 관심이 있다면 ELI5 데이터 셋을 기반으로 하는 데모를 확인해 보시기 바랍니다. 데이터 준비 추출형 질의응답의 학문적 벤치마크로 가장 많이 사용되는 데이터 셋은 SQuAD이므로 여기에서 이것을 사용하겠습니다. 정답이 없는 질문을 포함하는 더 어려운 SQuAD v2 벤치마크도 있습니다. 본인이 가진 데이터 셋에 컨텍스트 열, 질문 열, 답변 열이 포함되어 있는 한 아래 단계를 수행할 수 있습니다. SQuAD 데이터 셋 이전과 같이 load_dataset() 덕분에 데이터 셋을 한 번에 다운로드하고 캐시 할 수 있습니다: from datasets import load_dataset raw_datasets = load_dataset("squad") 그런 다음 이 객체(raw_datasets)를 보고 SQuAD 데이터 셋에 대해 자세히 알아볼 수 있습니다: raw_datasets 컨텍스트, 질문 및 답변 필드에 필요한 모든 것이 있는 것 같으므로 학습 집합의 첫 번째 요소를 출력해 보겠습니다: print("Context: ", raw_datasets["train"][0]["context"]) print("Question: ", raw_datasets["train"][0]["question"]) print("Answer: ", raw_datasets["train"][0]["answers"]) 컨텍스트 및 질문 필드는 사용하기 매우 간단합니다. 답변 필드는 두 개의 리스트 필드가 있는 사전을 가져오기 때문에 조금 더 까다롭습니다. 이<NAME>은 평가 과정에서 squad 메트릭이 요구하는<NAME>입니다. 본인 고유의 데이터를 사용하는 경우 답변을 동일한<NAME>으로 입력하는 것에 대해 걱정할 필요는 없습니다. text 필드는 다소 명확하며 answer_start 필드에는 컨텍스트에서 각 답변의 시작 문자 인덱스가 포함됩니다. 학습 과정에서 하나의 답변만 가능합니다. Dataset.filter() 메서드를 사용하여 이를 다시 확인할 수 있습니다: raw_datasets["train"].filter(lambda x: len(x["answers"]["text"]) != 1) 그러나 평가를 위해 각 샘플에 대해 몇 가지 가능한 답변이 있으며 동일하거나 다를 수 있습니다: print(raw_datasets["validation"][0]["answers"]) print(raw_datasets["validation"][2]["answers"]) 평가 스크립트는 Datasets 메트릭으로 모두 마무리되므로 자세히 다루지는 않겠습니다. 그러나 간단하게 말해서 일부 질문에는 몇 가지 가능한 답변이 있다는 것입니다. 그리고 이 스크립트(메트릭)는 예상 답변을 수용 가능한 모든 답변과 비교하여 최고 점수를 계산합니다. 예를 들어 인덱스 2의 샘플을 보면 다음과 같습니다: print(raw_datasets["validation"][2]["context"]) print(raw_datasets["validation"][2]["question"]) 우리는 위 질문에 대한 대답이 우리가 그전에 본 세 가지 가능성 중 하나일 수 있음을 알 수 있습니다. 학습 데이터 처리 학습 데이터를 전처리하는 것부터 시작하겠습니다. 어려운 부분은 컨텍스트 내의 답변에 해당하는 토큰의 시작 및 끝 위치가 될 질문의 답변에 대한 레이블을 생성하는 것입니다. 그러나 일단 서두르지 맙시다. 먼저 토크 나이저를 사용하여 입력 텍스트를 모델이 이해할 수 있는 ID로 변환해야 합니다: from transformers import AutoTokenizer model_checkpoint = "bert-base-cased" tokenizer = AutoTokenizer.from_pretrained(model_checkpoint) 이전에 언급했듯이 우리는 BERT 모델을 미세 조정할 것이지만 빠른 토크 나이저가 구현되어 있기만 한다면 다른 모델 유형을 사용할 수 있습니다. 이 큰 테이블에서 빠른 버전의 토크 나이저와 함께 제공되는 모든 아키텍처를 볼 수 있으며 사용 중인 토크 나이저 개체가 실제로 지원되는지 확인하려면 Tokenizers의 is_fast 속성을 확인하면 됩니다: tokenizer.is_fast 토크 나이저에 질문과 컨텍스트를 함께 전달할 수 있으며 특수 토큰을 적절하게 삽입하여 다음과 같은 문장을 형성합니다: [CLS] question [SEP] context [SEP] 다시 확인해 보겠습니다. context = raw_datasets["train"][0]["context"] question = raw_datasets["train"][0]["question"] inputs = tokenizer(question, context) tokenizer.decode(inputs["input_ids"]) 그러면 레이블이 답변의 시작 및 종료 토큰 인덱스가 되며, 모델은 입력에서 토큰당 하나의 시작 및 종료 로짓을 예측하는 작업을 수행하며 이론적인 레이블은 다음과 같습니다: 위 경우에는 컨텍스트가 너무 길지 않지만 데이터 셋의 일부 예시에는 우리가 설정한 최대 길이(이 경우 384)를 초과하는 매우 긴 컨텍스트가 있습니다. 6장에서 question-answering 파이프라인의 내부를 탐색할 때 보았듯이 데이터 셋의 한 샘플에서 여러 학습 자질들을 만들고 그 사이에 슬라이딩 윈도를 사용하여 긴 컨텍스트를 처리합니다. 여기서 "자질(feature)"의 의미는 단일 샘플의 일부가 분리되어 만들어진 새로운 샘플을 의미합니다. 길이가 너무 긴 컨텍스트를 가진 단일 샘플을 컨텍스트 최대 길이에 맞춰서 분할할 때, 분할된 각각의 샘플들을 자질이라고 부르고 있습니다. 현재 예제를 사용하여 이것이 어떻게 작동하는지 보기 위해 길이를 100으로 제한하고 50개 토큰의 슬라이딩 윈도를 사용할 수 있습니다. 참고로 다음 설정(기능)들을 사용합니다. max_length는 최대 길이를 설정합니다(여기서는 100). truncation="only_second"는 컨텍스트가 포함된 질문이 너무 길 때 컨텍스트(두 번째 위치에 있음)를 자릅니다. stride는 두 개의 연속 청크 사이에 겹치는 토큰 수를 설정합니다(여기서는 50개). return_overflowing_tokens=True를 지정해서 토크 나이저가 넘치기를 원한다는 것을 알립니다. inputs = tokenizer( question, context, max_length=100, truncation="only_second", stride=50, return_overflowing_tokens=True, ) for ids in inputs["input_ids"]: print(tokenizer.decode(ids)) 우리가 볼 수 있듯이 우리의 예는 4개의 입력으로 분할되었으며 각각에는 동일한 질문과 분할된 컨텍스트의 일부가 포함되어 있습니다. 질문에 대한 답변("Bernadette Soubirous")은 세 번째와 마지막 컨텍스트에만 나타나므로 이러한 방식으로 긴 컨텍스트를 처리하여 컨텍스트에 답변이 포함되지 않은 몇 가지 학습 예제들(첫 번째, 두 번째)을 추가로 만들 것입니다. 이러한 예에서 레이블은 start_position = end_position = 0이 됩니다(따라서 [CLS] 토큰을 예측함). 또한 정답이 잘린 불행한 경우에 해당 레이블을 설정하여 정답의 시작(또는 끝)만 가질 수 있도록 합니다. 답변이 컨텍스트에 완전히 포함된 예의 경우 레이블은 답변이 시작되는 토큰의 인덱스와 답변이 끝나는 토큰의 인덱스가 됩니다. 데이터 셋은 컨텍스트에서 답변의 시작 문자를 제공하고 답변의 길이를 추가하여 컨텍스트에서 끝 문자를 찾을 수 있습니다. 토큰 인덱스에 매핑하려면 6장에서 공부한 오프셋 매핑을 사용해야 합니다. return_offsets_mapping=True를 전달하여 토크 나이저가 이를 반환하도록 할 수 있습니다: inputs = tokenizer( question, context, max_length=100, truncation="only_second", stride=50, return_overflowing_tokens=True, return_offsets_mapping=True, ) inputs.keys() 보시다시피 일반적인 input IDs, token type IDs 및 attention mask는 물론 필요한 오프셋 매핑과 추가적인 overflow_to_sample_mapping을 반환합니다. 해당 값은 동시에 여러 텍스트를 토큰화할 때 유용합니다. 이는 우리의 토크 나이저가 Rust의 지원을 받는다는 사실로부터 이득을 얻을 수 있는 부분입니다. 하나의 샘플은 여러 자질들을 제공할 수 있으므로 각 자질을 원래의 예제에 매핑합니다. 여기서는 하나의 예제만 토큰화했기 때문에 0 목록을 얻습니다: inputs["overflow_to_sample_mapping"] 그러나 더 많은 예제를 토큰화하면 더 유용할 것입니다. inputs = tokenizer( raw_datasets["train"][2:6]["question"], raw_datasets["train"][2:6]["context"], max_length=100, truncation="only_second", stride=50, return_overflowing_tokens=True, return_offsets_mapping=True, ) print(f"The 4 examples give {len(inputs['input_ids'])} features.") print(f"Here is where each comes from: {inputs['overflow_to_sample_mapping']}.") 위에서 볼 수 있듯이 처음 세 가지 샘플(학습 집합의 인덱스 2, 3, 4에 해당)은 각각 4개의 자질들을 제공하고 마지막 예제(학습 집합의 인덱스 5)는 7개의 자질들을 만들었습니다. 이 정보는 각 자질을 해당 레이블에 매핑하는 데 유용합니다. 앞서 언급했듯이 해당 레이블은 다음과 같습니다: (0, 0) 정답이 컨텍스트의 해당 범위에 없는 경우 (start_position, end_position) 정답이 컨텍스트의 해당 범위에 있는 경우, start_position이 정답 시작 토큰 인덱스(input IDs에서)이고, end_position는 정답의 마지막 토큰 인덱스(input IDs에서)임 해당 컨텍스트가 위 두 가지 경우 중 어디에 속하는지 파악하기 위해서 우선 input IDs에서 컨텍스트 시작 및 끝 인텍스를 구해야 합니다. token type IDs를 사용하여 이를 수행할 수 있지만 모든 모델에 대해 반드시 이 정보가 존재하는 것은 아니기 때문에(예를 들어, DistillBERT는 이 정보가 필요하지 않습니다), 대신 토크 나이저가 반환하는 BatchEncoding의 sequence_ids() 메서드를 사용합니다. 해당 토큰 인덱스가 있으면 원래 컨텍스트 내에서 문자 범위를 나타내는 두 정수의 튜플인 해당 오프셋을 확인합니다. 따라서 이 자질의 컨텍스트 청크가 답변 이후에 시작되는지 답변이 시작되기 전에 끝나는지 감지할 수 있습니다(이 경우에는 레이블은 (0, 0)입니다). 그렇지 않은 경우 정답의 첫 번째와 마지막 토큰을 찾기 위해 루프를 돌립니다: answers = raw_datasets["train"][2:6]["answers"] start_positions = [] end_positions = [] for i, offset in enumerate(inputs["offset_mapping"]): sample_idx = inputs["overflow_to_sample_mapping"][i] answer = answers[sample_idx] start_char = answer["answer_start"][0] end_char = answer["answer_start"][0] + len(answer["text"][0]) sequence_ids = inputs.sequence_ids(i) # 컨텍스트의 시작 및 마지막을 찾는다. idx = 0 while sequence_ids[idx] != 1: idx += 1 context_start = idx while sequence_ids[idx] == 1: idx += 1 context_end = idx - 1 # 만일 정답이 컨텍스트에 완전히 포함되지 않는다면, 레이블은 (0, 0)임 if offset[context_start][0] > start_char or offset[context_end][1] < end_char: start_positions.append(0) end_positions.append(0) else: # 그렇지 않으면 정답의 시작 및 마지막 인덱스 idx = context_start while idx <= context_end and offset[idx][0] <= start_char: idx += 1 start_positions.append(idx - 1) idx = context_end while idx >= context_start and offset[idx][1] >= end_char: idx -= 1 end_positions.append(idx + 1) start_positions, end_positions 우리의 접근 방식이 올바른지 확인하기 위해 몇 가지 결과를 살펴보겠습니다. 첫 번째 자질의 경우 레이블로 (83, 85)를 찾았으므로 이론적인 정답을 83에서 85(포함)까지의 디코딩 된 토큰 범위와 비교해 보겠습니다: idx = 0 sample_idx = inputs["overflow_to_sample_mapping"][idx] answer = answers[sample_idx]["text"][0] start = start_positions[idx] end = end_positions[idx] labeled_answer = tokenizer.decode(inputs["input_ids"][idx][start : end + 1]) print(f"Theoretical answer: {answer}, labels give: {labeled_answer}") 일치하고 있습니다. 이제 레이블을 (0, 0)으로 설정한 인덱스 4를 확인하겠습니다. 이는 정답이 해당 자질의 컨텍스트 청크에 없음을 의미합니다: idx = 4 sample_idx = inputs["overflow_to_sample_mapping"][idx] answer = answers[sample_idx]["text"][0] decoded_example = tokenizer.decode(inputs["input_ids"][idx]) print(f"Theoretical answer: {answer}, decoded example: {decoded_example}") 위 문맥 안에서 정답을 볼 수 없습니다. ✏ Your turn! XLNet 아키텍처를 사용하는 경우 왼쪽에 패딩이 적용되고 질문과 컨텍스트가 전환됩니다. 방금 본 모든 코드를 XLNet 아키텍처에 적용해 봅시다(그리고 padding=True 추가). 패딩이 적용된 [CLS] 토큰은 0 위치에 있지 않을 수 있습니다. 학습 데이터를 전처리하는 방법을 단계별로 살펴보았으므로 전체 학습 데이터 셋에 적용할 함수로 그룹화할 수 있습니다. 대부분의 컨텍스트의 길이가 길 것이고 해당 샘플이 여러 자질들로 분할되므로 모든 자질을 우리가 설정한 최대 길이로 채울 것이므로 여기에 동적 패딩을 적용해도 실질적인 이점이 없습니다. max_length = 384 stride = 128 def preprocess_training_examples(examples): questions = [q.strip() for q in examples["question"]] inputs = tokenizer( questions, examples["context"], max_length=max_length, truncation="only_second", stride=stride, return_overflowing_tokens=True, return_offsets_mapping=True, padding="max_length", ) offset_mapping = inputs.pop("offset_mapping") sample_map = inputs.pop("overflow_to_sample_mapping") answers = examples["answers"] start_positions = [] end_positions = [] for i, offset in enumerate(offset_mapping): sample_idx = sample_map[i] answer = answers[sample_idx] start_char = answer["answer_start"][0] end_char = answer["answer_start"][0] + len(answer["text"][0]) sequence_ids = inputs.sequence_ids(i) idx = 0 while sequence_ids[idx] != 1: idx += 1 context_start = idx while sequence_ids[idx] == 1: idx += 1 context_end = idx - 1 if offset[context_start][0] > start_char or offset[context_end][1] < end_char: start_positions.append(0) end_positions.append(0) else: idx = context_start while idx <= context_end and offset[idx][0] <= start_char: idx += 1 start_positions.append(idx - 1) idx = context_end while idx >= context_start and offset[idx][1] >= end_char: idx -= 1 end_positions.append(idx + 1) inputs["start_positions"] = start_positions inputs["end_positions"] = end_positions return inputs 사용된 최대 길이와 슬라이딩 윈도의 길이를 결정하기 위해 두 개의 상수를 정의했으며 토큰화하기 전에 약간의 정제 작업을 추가했습니다. SQuAD 데이터 셋의 일부 질문에는 시작과 끝에 추가 공백이 있으므로(RoBERTa와 같은 모델을 사용하는 경우 토큰화할 때 공간을 차지함) 이러한 추가 공백을 제거했습니다. 이 함수를 전체 학습 집합에 적용하기 위해 batched=True 플래그와 함께 Dataset.map() 메서드를 사용합니다. 단일 샘플에서 여러 개의 자질들이 만들어질 수 있기 때문에, 데이터 셋의 개수가 달라질 수 있습니다: train_dataset = raw_datasets["train"].map( preprocess_training_examples, batched=True, remove_columns=raw_datasets["train"].column_names, ) len(raw_datasets["train"]), len(train_dataset) 보시다시피, 전처리는 대략 1,000개의 자질들을 추가했습니다. 이제 학습 집합을 사용할 준비가 되었습니다. 지금부터 검증 집합의 전처리를 살펴보겠습니다! 검증 집합 처리 검증 데이터를 전처리 하는 작업은 레이블을 생성할 필요가 없으므로 좀 쉬울 수 있습니다. 만일 검증 손실을 계산하고 싶다면 레이블을 생성해야 하는데, 검증 손실은 모델이 얼마나 좋은지 이해하는 데 실제로 도움이 되지 않습니다. 진정한 즐거움은 모델의 예측을 원래 컨텍스트의 범위로 해석하여 실제 정답을 살펴보는 것입니다. 이를 위해 오프셋 매핑과 생성된 각 자질들을 원래 예제와 일치시키는 방법을 모두 저장하면 됩니다. 원본 데이터 셋에 ID 열이 있으므로 해당 ID를 사용합니다. 여기에 추가할 유일한 작업은 오프셋 매핑을 약간 정리하는 것입니다. 여기에는 질문과 컨텍스트에 대한 오프셋이 포함되지만 후처리 단계에 들어가면 입력 ID의 어느 부분이 컨텍스트에 해당하고 어떤 부분이 질문인지 알 수 있는 방법이 없습니다. 우리가 사용한 sequence_ids() 메서드는 토크 나이저의 출력에만 사용할 수 있습니다. 따라서 질문에 해당하는 오프셋을 None으로 설정합니다: def preprocess_validation_examples(examples): questions = [q.strip() for q in examples["question"]] inputs = tokenizer( questions, examples["context"], max_length=max_length, truncation="only_second", stride=stride, return_overflowing_tokens=True, return_offsets_mapping=True, padding="max_length", ) sample_map = inputs.pop("overflow_to_sample_mapping") example_ids = [] for i in range(len(inputs["input_ids"])): sample_idx = sample_map[i] example_ids.append(examples["id"][sample_idx]) sequence_ids = inputs.sequence_ids(i) offset = inputs["offset_mapping"][i] inputs["offset_mapping"][i] = [ o if sequence_ids[k] == 1 else None for k, o in enumerate(offset) ] inputs["example_id"] = example_ids return inputs 이전과 같이 전체 검증 데이터 셋에 이 함수를 적용할 수 있습니다: validation_dataset = raw_datasets["validation"].map( preprocess_validation_examples, batched=True, remove_columns=raw_datasets["validation"].column_names, ) len(raw_datasets["validation"]), len(validation_dataset) 이 경우 몇 백 개의 샘플만 추가했으므로 검증 데이터 셋의 컨텍스트가 약간 더 짧은 것으로 보입니다. 모든 데이터를 전처리했으므로 이제 학습에 들어갈 수 있습니다. Trainer API를 이용한 모델 미세 조정(fine-tuning) 이 예제의 학습 코드는 이전 섹션의 코드와 매우 유사합니다. 가장 어려운 것은 compute_metrics() 함수를 작성하는 것입니다. 모든 샘플을 우리가 설정한 최대 길이로 패딩 한 관계로 정의할 데이터 콜레 이터가 없기 때문에 이 메트릭 계산이 실제로 우리가 걱정해야 하는 유일한 것입니다. 어려운 부분은 모델 예측을 원본 예제의 텍스트 범위(span)로 후처리하는 것입니다. 일단 그렇게 하면 Datasets 라이브러리의 메트릭이 대부분의 작업을 수행합니다. 후처리 (Post-processing) question-answering pipeline을 공부하는 동안 살펴본 것처럼 모델은 input IDs에서 답변의 시작 및 끝 위치에 대한 로짓을 출력합니다. 후처리 단계는 우리가 거기서 한 것과 유사하므로 다음 내용은 우리가 그때 취했던 조치를 빠르게 상기시켜줍니다: 컨텍스트 외부의 토큰에 해당하는 시작 및 종료 로짓을 마스킹 했습니다. 그런 다음 softmax를 사용하여 시작 및 종료 로짓을 확률로 변환했습니다. 우리는 해당 두 확률의 곱을 취하여 각 (start_token, end_token) 쌍에 점수를 부여했습니다. 유효한 답변(예: start_token이 end_token보다 값이 작은 답변들)을 산출한 최대 점수를 가진 쌍을 찾았습니다. 여기서는 실제 점수를 계산할 필요가 없기 때문에 이 프로세스를 약간 변경할 것입니다(예측된 답변에 대해서만). 이는 softmax 단계를 건너뛸 수 있음을 의미합니다. 더 빠르게 진행하기 위해 가능한 모든 (start_token, end_token) 쌍을 기록하지 않고 가장 높은 n_best 로짓(n_best=20)에 해당하는 쌍만 기록합니다. 여기서 softmax를 건너뛸 것이기 때문에 그 점수는 로짓 점수가 될 것이며 시작과 끝 로짓의 합을 계산하여 얻을 것입니다. 이 모든 과정들을 보이려면 약간의 예측 결과가 필요합니다. 아직 모델을 학습시키지 않았기 때문에 QA 파이프라인의 기본 모델을 사용하여 검증 세트의 작은 부분에 대한 예측을 생성할 것입니다. 이전과 동일한 처리 기능을 사용할 수 있습니다. 전역 상수 tokenizer에 의존하기 때문에 해당 객체를 우리가 임시로 사용하려는 모델의 토크 나이저로 변경하기만 하면 됩니다: small_eval_set = raw_datasets["validation"].select(range(100)) trained_checkpoint = "distilbert-base-cased-distilled-squad" tokenizer = AutoTokenizer.from_pretrained(trained_checkpoint) eval_set = small_eval_set.map( preprocess_validation_examples, batched=True, remove_columns=raw_datasets["validation"].column_names, ) 이제 전처리가 완료되었으므로 토크 나이저를 원래 선택한 것으로 다시 변경합니다: tokenizer = AutoTokenizer.from_pretrained(model_checkpoint) 그런 다음 모델에서 필요로 하지 않는 eval_set의 열을 제거하고 eval_set 내용 전체를 가지고 하나의 배치를 빌드하고 모델을 통해 전달합니다. GPU를 사용할 수 있는 경우 이를 더 빠르게 진행할 수 있습니다: import torch from transformers import AutoModelForQuestionAnswering eval_set_for_model = eval_set.remove_columns(["example_id", "offset_mapping"]) eval_set_for_model.set_format("torch") device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu") batch = {k: eval_set_for_model[k].to(device) for k in eval_set_for_model.column_names} trained_model = AutoModelForQuestionAnswering.from_pretrained(trained_checkpoint).to(device) with torch.no_grad(): outputs = trained_model(**batch) Trainer는 NumPy 배열로 예측을 제공하므로 시작 및 끝 로짓을 가져와 해당<NAME>으로 변환합니다: start_logits = outputs.start_logits.cpu().numpy() end_logits = outputs.end_logits.cpu().numpy() 이제 small_eval_set에서 각 예시에 대한 예상 답변을 찾아야 합니다. 단일 예시가 eval_set의 여러 자질들로 분할되었을 수 있으므로 첫 번째 단계는 small_eval_set의 각 예시를 eval_set의 해당 자질에 매핑하는 것입니다: import collections example_to_features = collections.defaultdict(list) for idx, feature in enumerate(eval_set): example_to_features[feature["example_id"]].append(idx) 이를 통해 모든 예제와 각 예제와 연결된 모든 자질들을 통해 실제로 작업을 시작할 수 있습니다. 이전에 말했듯이 다음과 같은 위치(positions)를 제외하고 n_best 시작 로짓 및 종료 로짓에 대한 로짓 점수를 살펴보겠습니다: 컨텍스트 내부에 존재하지 않는 응답 음수 길이를 가지는 응답 길이가 너무 긴 응답 (max_answer_length=30) 하나의 예시에 대해 가능한 모든 응답을 얻었으면 로짓 점수가 가장 좋은 답을 선택하면 됩니다: import numpy as np n_best = 20 max_answer_length = 30 predicted_answers = [] for example in small_eval_set: example_id = example["id"] context = example["context"] answers = [] for feature_index in example_to_features[example_id]: start_logit = start_logits[feature_index] end_logit = end_logits[feature_index] offsets = eval_set["offset_mapping"][feature_index] start_indexes = np.argsort(start_logit)[-1 : -n_best - 1 : -1].tolist() end_indexes = np.argsort(end_logit)[-1 : -n_best - 1 : -1].tolist() for start_index in start_indexes: for end_index in end_indexes: # 컨텍스트에 전체가 포함되지 않은 응답은 스킵 if offsets[start_index] is None or offsets[end_index] is None: continue # 길이가 음수이거나 max_answer_length보다 크면 스킵 if end_index < start_index or end_index - start_index + 1 > max_answer_length: continue answers.append( { "text": context[offsets[start_index][0] : offsets[end_index][1]], "logit_score": start_logit[start_index] + end_logit[end_index], } ) best_answer = max(answers, key=lambda x: x["logit_score"]) predicted_answers.append({"id": example_id, "prediction_text": best_answer["text"]}) 예상 답변의 최종<NAME>은 우리가 사용할 메트릭에서 요구하는<NAME>입니다. 평소와 같이 Datasets 라이브러리를 사용하여 로드할 수 있습니다: from datasets import load_metric metric = load_metric("squad") 이 메트릭은 위에서 본<NAME>(예제의 ID에 대한 하나의 키와 예측된 텍스트에 대한 하나의 키가 있는 사전 목록)의 예상 답변과 다음<NAME>(예제의 ID에 대한 하나의 키와 가능한 답변 즉, 정답에 대한 하나의 키가 있는 사전 목록)과 같은 이론적 답변을 요구하고 있습니다: theoretical_answers = [ {"id": ex["id"], "answers": ex["answers"]} for ex in small_eval_set ] 이제 두 목록의 첫 번째 요소를 보고 합리적인 결과를 얻었는지 확인할 수 있습니다: print(predicted_answers[0]) print(theoretical_answers[0]) 나쁘지 않네요! 이제 메트릭이 제공하는 점수를 살펴보겠습니다: metric.compute(predictions=predicted_answers, references=theoretical_answers) 다시 말하지만, SQuAD에서 미세 조정된 DitilBERT의 논문에 따르면 전체 데이터 세트에서 해당 점수에 대해 79.1 및 86.9를 얻었다는 점을 고려하면 상당히 성능이 좋습니다. 이제 Trainer에서 사용할 compute_metrics() 함수에 방금 수행한 모든 것을 넣어 보겠습니다. 일반적으로 해당 compute_metrics() 함수는 로짓 및 레이블이 있는 eval_preds 튜플만 입력받습니다. 오프셋에 대한 자질 데이터 셋과 원본 컨텍스트에 대한 예제 데이터 셋을 살펴봐야 하기 때문에 추가 구현이 좀 더 필요합니다. 따라서 학습 중에 정규 평가 결과를 얻기 위해 이 함수를 사용할 수 없습니다. 학습이 끝날 때 결과를 확인하는 데만 사용할 것입니다. compute_metrics() 함수는 이전과 동일한 단계를 그룹화합니다. 유효한 답이 나오지 않는 경우를 대비하여 소규모 검사 기능을 추가합니다(빈 문자열을 예측하는 경우에 대비하여). from tqdm.auto import tqdm def compute_metrics(start_logits, end_logits, features, examples): example_to_features = collections.defaultdict(list) for idx, feature in enumerate(features): example_to_features[feature["example_id"]].append(idx) predicted_answers = [] for example in tqdm(examples): example_id = example["id"] context = example["context"] answers = [] # 해당 예제와 연관된 모든 자질들에 대해서... for feature_index in example_to_features[example_id]: start_logit = start_logits[feature_index] end_logit = end_logits[feature_index] offsets = features[feature_index]["offset_mapping"] start_indexes = np.argsort(start_logit)[-1 : -n_best - 1 : -1].tolist() end_indexes = np.argsort(end_logit)[-1 : -n_best - 1 : -1].tolist() for start_index in start_indexes: for end_index in end_indexes: # 컨텍스트에 완전히 포함되지 않는 답변은 생략 if offsets[start_index] is None or offsets[end_index] is None: continue # 길이가 음수거나 max_answer_length를 넘는 답변은 생략 if end_index < start_index or end_index - start_index + 1 > max_answer_length: continue answer = { "text": context[offsets[start_index][0] : offsets[end_index][1]], "logit_score": start_logit[start_index] + end_logit[end_index], } answers.append(answer) if len(answers) > 0: best_answer = max(answers, key=lambda x: x["logit_score"]) predicted_answers.append( {"id": example_id, "prediction_text": best_answer["text"]} ) else: predicted_answers.append({"id": example_id, "prediction_text": ""}) theoretical_answers = [{"id": ex["id"], "answers": ex["answers"]} for ex in examples] return metric.compute(predictions=predicted_answers, references=theoretical_answers) 우리의 예측 결과에서 제대로 작동하는지 확인할 수 있습니다: compute_metrics(start_logits, end_logits, eval_set, small_eval_set) 좋아 보이네요. 이제 이를 바탕으로 모델을 미세 조정해 보겠습니다. 모델 미세 조정 이제 모델을 학습할 준비가 되었습니다. 이전과 동일하게, AutoModelForQuestionAnswering 클래스를 사용하여 먼저 생성해 보겠습니다. model = AutoModelForQuestionAnswering.from_pretrained(model_checkpoint) 예상했던 것과 같이, 일부 가중치(사전 학습 헤드의 가중치)가 사용되지 않고 다른 가중치(질문 답변 헤드의 가중치)가 무작위로 초기화된다는 경고를 받습니다. 지금쯤이면 이 경고에 익숙해져야 하지만, 이는 해당 모델이 아직 사용할 준비가 되지 않았으며 미세 조정이 필요하다는 것을 의미합니다. 모델을 Hub로 푸시 하려면 Hugging Face에 로그인해야 합니다. 노트북에서 이 코드를 실행하는 경우 로그인 자격 증명을 입력할 수 있는 위젯을 표시하는 다음 유틸리티 기능을 사용하여 실행할 수 있습니다. from huggingface_hub import notebook_login notebook_login() 이 작업이 완료되면 TrainingArguments를 정의할 수 있습니다. 메트릭을 계산하기 위해 함수를 정의할 때 말했듯이, compute_metrics() 함수의 특징 때문에 일반적인 평가 루프를 가질 수 없습니다. 이를 수행하기 위해 자체 Trainer 하위 클래스를 작성할 수 있지만(질의응답 예제 스크립트에서와 같은 접근 방식) 이 섹션에서 설명하기에는 내용이 너무 많습니다. 대신 여기에서는 학습이 끝날 때만 모델을 평가하고 아래의 "맞춤형 학습 루프(A custom training loop)"에서 정기적인 평가를 수행하는 방법을 보여줍니다. 이 부분은 실제로 Trainer API의 한계를 보여주고 있고 Accelerate 라이브러리가 빛을 발하는 부분입니다. 특정 사용 사례에 맞게 클래스를 사용자 정의하는 것은 힘든 작업일 수 있지만 완전히 공개된 학습 루프를 변형하는 것은 쉽습니다. TrainingArguments를 살펴보겠습니다: from transformers import TrainingArguments args = TrainingArguments( "bert-finetuned-squad", evaluation_strategy="no", save_strategy="epoch", learning_rate=2e-5, num_train_epochs=3, weight_decay=0.01, fp16=True, push_to_hub=True, ) 우리는 이전에 이들 대부분을 살펴본 적이 있습니다. 일부 하이퍼 파라미터(예: 학습률, 훈련할 에포크 수, 약간의 가중치 감소)를 설정하고 모든 에포크가 끝날 때 모델을 저장하고 평가를 건너뛰고, 결과를 Model Hub에 업로드하겠다고 설정합니다. 또한 fp16=True로 혼합 정밀도 학습을 활성화합니다. 이는 최근에 출시된 GPU에서 학습 속도를 크게 높일 수 있기 때문입니다. 기본적으로 사용되는 저장소는 네임스페이스에 있고 설정한 출력 디렉터리의 이름을 따서 명명되므로 이 경우에는 "spasis/bert-finetuned-squad"에 있습니다. hub_model_id를 전달하여 이를 재정의할 수 있습니다. 예를 들어, 모델을 huggingface_course 조직으로 푸시 하기 위해 우리는 hub_model_id="huggingface_course/bert-finetuned-squad"를 사용했습니다. 이는 이 섹션의 시작 부분에서 연결한 모델입니다. 사용 중인 출력 디렉터리가 존재하는 경우 푸시 하려는 저장소의 로컬 복제본이어야 합니다(따라서 Trainer를 정의할 때 오류가 발생하면 새 이름을 설정하십시오). 마지막으로 모든 것을 Trainer 클래스에 전달하고 학습을 시작합니다: from transformers import Trainer trainer = Trainer( model=model, args=args, train_dataset=train_dataset, eval_dataset=validation_dataset, tokenizer=tokenizer, ) trainer.train() 학습이 진행되는 동안 모델이 저장될 때마다(여기서는 모든 에포크) 백그라운드에서 허브에 업로드됩니다. 이렇게 하면 필요한 경우 다른 머신에서 학습을 재개할 수 있습니다. 전체 학습은 시간이 걸리므로(Titan RTX에서는 1시간 남짓) 커피를 마시거나 진행하는 동안 이해하기 어렵다고 생각한 과정의 일부를 다시 읽어보시기를 권장합니다. 또한 첫 번째 에포크가 완료되는 즉시 허브에 업로드된 일부 가중치가 표시되고 해당 페이지에서 모델을 사용할 수 있습니다. 학습이 완료되면 마침내 모델을 평가할 수 있습니다. Trainer의 predict() 메서드는 첫 번째 요소가 모델의 예측이 될 튜플을 반환합니다(여기서는 시작 및 끝 로짓과 쌍). 이것을 우리의 compute_metrics() 함수로 보냅니다: predictions, _, _ = trainer.predict(validation_dataset) start_logits, end_logits = predictions compute_metrics(start_logits, end_logits, validation_dataset, raw_datasets["validation"]) 좋습니다! 비교를 위해서 이 모델에 대한 BERT 논문에 보고된 기준 점수는 80.8과 88.5이므로 비슷한 결과를 보이고 있습니다. 마지막으로 push_to_hub() 메서드를 사용하여 최신 버전의 모델을 업로드했는지 확인합니다. trainer.push_to_hub(commit_message="Training complete") 위 실행 결과 수행한 커밋의 URL을 반환합니다: 'https://huggingface.co/sgugger/bert-finetuned-squad/commit/9dcee1fbc25946a6ed4bb32efb1bd71d5fa90b68 또한 Trainer는 모든 평가 결과가 포함된 모델 카드의 초안을 작성하여 업로드합니다. 이 단계에서 Model Hub의 추론 위젯(inference widget)을 사용하여 모델을 테스트하고 친구, 가족 및 좋아하는 애완동물과 공유할 수 있습니다. 질의응답 태스크에서 모델을 성공적으로 미세 조정했습니다. 축하합니다! ✏ Your turn! 다른 모델 아키텍처를 이용해 보고, 이 태스크에서 더 나은 성능을 보이는지 확인하십시오! 학습 루프에 대해 좀 더 자세히 알고 싶다면 이제 Accelerate를 사용하여 동일한 작업을 수행하는 방법을 보여드리겠습니다. 사용자 정의 학습 루프 이제 전체 학습 루프를 살펴보고 필요한 부분을 쉽게 수정할 수 있습니다. 평가 루프를 제외하고는 3장의 학습 루프와 매우 유사합니다. Trainer 클래스 사용에 의한 제약을 더 이상 받지 않기 때문에 모델을 정기적으로 평가할 수 있습니다. 학습을 위한 전체 준비 먼저 데이터 셋에서 DataLoaders를 빌드 해야 합니다. 데이터 셋의<NAME>을 "torch"로 설정하고 모델에서 사용하지 않는 검증 집합(validation set) 열을 제거합니다. 그런 다음 Transformers에서 제공하는 default_data_collator를 collate_fn으로 사용하고, 학습 집합은 셔플링(shuffling)을 하고 검증 집합은 하지 않습니다: from torch.utils.data import DataLoader from transformers import default_data_collator train_dataset.set_format("torch") validation_set = validation_dataset.remove_columns(["example_id", "offset_mapping"]) validation_set.set_format("torch") train_dataloader = DataLoader( train_dataset, shuffle=True, collate_fn=default_data_collator, batch_size=8, ) eval_dataloader = DataLoader( validation_set, collate_fn=default_data_collator, batch_size=8 ) 다음으로 이전의 미세 조정을 계속하지 않고 사전 학습된 BERT 모델에서 다시 시작하도록 모델을 새롭게 인스턴스화합니다. model = AutoModelForQuestionAnswering.from_pretrained(model_checkpoint) 그런 다음 최적화 프로그램이 필요합니다. 이전과 동일하게, Adam과 같은 방식이지만 가중치 감소 적용 방식이 수정된 고전적인 AdamW를 사용합니다. from torch.optim import AdamW optimizer = AdamW(model.parameters(), lr=2e-5) 해당 객체를 모두 생성한 다음 이들 모두를 accelerator.prepare() 메서드로 보내야 합니다. Colab 노트북에서 TPU를 이용하여 학습하려면 이 모든 코드를 학습 함수로 옮겨야 하며 Accelerator를 인스턴스화하는 셀을 실행해서는 안 됩니다. Accelerator에 fp16=True를 전달하여 혼합 정밀도 학습을 강제할 수 있습니다(또는 코드를 스크립트로 실행하는 경우 Accelerate 설정을 적절하게 지정해야 합니다). from accelerate import Accelerator accelerator = Accelerator(fp16=True) model, optimizer, train_dataloader, eval_dataloader = accelerator.prepare( model, optimizer, train_dataloader, eval_dataloader ) 이전 섹션에서 공부한 바와 같이, accelerator.prepare() 메서드를 거친 후의 train_dataloader 길이를 사용하여 학습 단계 수를 계산해야 합니다. 이전 섹션에서와 동일한 선형 스케쥴링을 사용합니다: from transformers import get_scheduler num_train_epochs = 3 num_update_steps_per_epoch = len(train_dataloader) num_training_steps = num_train_epochs * num_update_steps_per_epoch lr_scheduler = get_scheduler( "linear", optimizer=optimizer, num_warmup_steps=0, num_training_steps=num_training_steps, ) 모델을 Hub로 푸시 하려면 작업 폴더에 Repository 객체를 생성해야 합니다. 아직 로그인하지 않았다면 먼저 Hugging Face Hub에 로그인합니다. 모델에 부여할 모델 ID에서 저장소 이름을 결정합니다. repo_name을 원하는 대로 자유롭게 바꾸십시오. get_full_repo_name() 함수가 현재 사용자 이름만 포함하면 됩니다: from huggingface_hub import Repository, get_full_repo_name model_name = "bert-finetuned-squad-accelerate" repo_name = get_full_repo_name(model_name) repo_name 그런 다음 해당 저장소를 로컬 폴더에 복제할 수 있습니다. 이미 존재하는 경우 이 로컬 폴더는 작업 중인 리포지토리의 복제본이어야 합니다: output_dir = "bert-finetuned-squad-accelerate" repo = Repository(output_dir, clone_from=repo_name) 이제 repo.push_to_hub() 메서드를 호출하여 output_dir에 저장한 모든 것을 업로드할 수 있습니다. 이렇게 하면 각 에포크가 끝날 때 중간 모델을 업로드하는 데 도움이 됩니다. 학습 루프 이제 전체 학습 루프를 작성할 준비가 되었습니다. 학습 진행 방식을 따르기 위해 진행률 표시줄을 정의한 후 루프는 세 부분으로 구성됩니다: 학습 부분은 train_dataloader를 반복해서 참조하며 수행되면서 모델을 통해 정방향 전달(forward pass)을 수행한 다음 역방향 전달(backward pass) 및 최적화 단계를 수행합니다. 평가 부분에서는 start_logits 및 end_logits에 대한 모든 값을 수집하여 NumPy 배열로 변환합니다. 평가 루프가 완료되면 모든 결과를 연결합니다. 이때, Accelerator가 각 프로세스에서 동일한 수의 예제를 갖도록 끝에 몇 가지 샘플을 추가했을 수 있으므로 일부를 잘라내야 합니다. 저장 및 업로드 단계로서, 먼저 모델과 토크 나이저를 저장한 다음 repo.push_to_hub()를 호출합니다. 이전에 했던 것처럼, blocking=False 인수를 사용하여 Hub 라이브러리가 비동기 프로세스에서 푸시하도록 명령합니다. 이런 식으로 학습은 정상적으로 계속되고 이 (긴) 명령은 백그라운드에서 실행됩니다. 학습 루프의 전체 코드는 다음과 같습니다: from tqdm.auto import tqdm import torch progress_bar = tqdm(range(num_training_steps)) for epoch in range(num_train_epochs): # 학습 model.train() for step, batch in enumerate(train_dataloader): outputs = model(**batch) loss = outputs.loss accelerator.backward(loss) optimizer.step() lr_scheduler.step() optimizer.zero_grad() progress_bar.update(1) # 평가 model.eval() start_logits = [] end_logits = [] accelerator.print("Evaluation!") for batch in tqdm(eval_dataloader): with torch.no_grad(): outputs = model(**batch) start_logits.append(accelerator.gather(outputs.start_logits).cpu().numpy()) end_logits.append(accelerator.gather(outputs.end_logits).cpu().numpy()) start_logits = np.concatenate(start_logits) end_logits = np.concatenate(end_logits) start_logits = start_logits[: len(validation_dataset)] end_logits = end_logits[: len(validation_dataset)] metrics = compute_metrics( start_logits, end_logits, validation_dataset, raw_datasets["validation"] ) print(f"epoch {epoch}:", metrics) # 저장 및 업로드 accelerator.wait_for_everyone() unwrapped_model = accelerator.unwrap_model(model) unwrapped_model.save_pretrained(output_dir, save_function=accelerator.save) if accelerator.is_main_process: tokenizer.save_pretrained(output_dir) repo.push_to_hub(commit_message=f"Training in progress epoch {epoch}", blocking=False) Accelerate로 저장된 모델을 처음 보는 경우, 잠시 시간을 내어 함께 제공되는 세 줄의 코드를 살펴보겠습니다: acceleratorator.wiat_for_everyone() unwrapped_model = accelerator.unwrap_model(model) unwrapped_model.save_pretrained(output_dir, save_function=accelerator.save) 첫 번째 줄은 설명이 필요 없습니다. 모든 프로세스가 현재 라인까지 실행되기를 기다리는 명령어입니다. 이것은 저장하기 전에 모든 프로세스에서 동일한 모델이 있는지 확인하기 위한 것입니다. 그런 다음 우리가 정의한 기본 모델인 unwrapped_model을 가져옵니다. accelerator.prepare() 메서드는 모델을 분산 학습에서 작동하도록 변경하므로 더 이상 save_pretrained() 메서드가 없습니다. accelerator.unwrap_model() 메서드는 이 과정에 대한 실행을 취소합니다. 마지막으로 save_pretrained()를 호출하지만 그 메서드에 torch.save() 대신 accelerator.save()를 사용하도록 지시합니다. 이 작업이 완료되면 Trainer로 학습된 것과 매우 유사한 결과를 생성하는 모델을 갖게 됩니다. 이 코드를 사용하여 학습한 모델은 huggingface-course/bert-finetuned-squad-accelerate에서 확인할 수 있습니다. 그리고 학습 루프에 대한 변경 등을 시도하려면 위에 표시된 코드를 편집하여 직접 구현할 수 있습니다! 미세조정된 모델 사용하기 추론 위젯을 사용하여 Model Hub에서 미세 조정한 모델을 사용하는 방법을 이미 살펴본 적이 있습니다. 해당 모델을 pipeline에서 로컬로 사용하려면 모델 식별자를 지정하기만 하면 됩니다: from transformers import pipeline # 체크포인트를 본인 것으로 교체하면 됩니다. model_checkpoint = "spasis/bert-finetuned-squad" question_answerer = pipeline("question-answering", model=model_checkpoint) context = """ Transformers is backed by the three most popular deep learning libraries — Jax, PyTorch and TensorFlow — with a seamless integration between them. It's straightforward to train your models with one before loading them for inference with the other. """ question = "Which deep learning libraries back Transformers?" question_answerer(question=question, context=context) 이제 우리 모델은 이 파이프라인의 기본 모델과 동일하게 작동합니다! 8장. 도움 요청 방법 (How to ask for help) 8장은 현재 번역 집필 작업 중에 있습니다. 완료되는 대로 업로드하겠습니다.<|endoftext|>

전문분야 텍스트 ### 제목: 컨설팅 방법론 ### 본문: 저자는 IT 서비스 산업에서 청춘을 보내면서 개발자, 경영 진단, 전략기획, 비즈니스 컨설팅, 해외 사업 등을 경험하였고 이제 60대 초반을 바라보고 있다. 로봇과 인공지능이 난무할 듯한 도래하는 디지털 시대에 대한 반작용인가 저자는 최근 글 읽기와 글쓰기에 관심이 높아져간다. 글 읽는 것이야 저명인사들의 수많은 추천작들이 있으니 시간 날 때마다 읽을 것이지만 글쓰기는 무엇부터 시작할 수 있을까? 좋은 글을 필사하는 것도 한 방법이려니와 저자는 그동안 경험한 것들을 아직 머릿속에 남아 있을 때 정리해 보자는 목적으로 저술을 시작한다. 그 목적이 그래서일까 여러 권을 쓰고 있으니 저술이라기보다는 정리의 느낌이 더 강한데 조금 더 시간이 흐르거나 오프라인 출판으로 이어지면 Case Study 같은 것들을 추가하여 저술의 모양새를 갖추게 될 수도 있으리라 생각된다. 이번에서는 컨설팅을 다룰 것이다. 컨설팅은 많은 사람들이 흥미로워 하는 영역임과 동시에 매우 전문적이어서 배타적인 영역이기도 하다. 다음과 같은 목차로 진행될 계획인데 제대로 죽 보고 나면 어딜 가도 빠지지 않고 비즈니스 컨설팅에 대해 한 마디 할 수 있을 것이다. 그러나 책으로 도움을 얻는 것은 딱 거기까지이다. 왜냐하면 가장 중요한 것은 자신이 직접 실제로 해보는 것이기 때문이다. 저자는 뭐든지 직접 해보는 것만한 것은 없다고 생각한다. 그런 차원에서 컨설팅을 다루는 이 매거진은 왜 컨설팅 화두였는지 앞으로는 어떻게 될지 이 일을 하는 사람들은 어떻게 일하고 있는지 이해하는데 충분한 도움을 줄 것이라 생각한다. 많은 독자님들과 오다가다 글을 보게 되는 독자님들의 좋은 피드백을 기다린다. 00.FrontPage Prologue 2016년에 저자는 두 권의 책을 저술했는데 첫 번째 책이 'B2B 마케팅/영업, 21일의 여행'이라는 제목이었고 두 번째 책은 '컨설팅 다시 보기'였다. 모두 출판을 목적으로 기획했던 것들이었는데 이런저런 사정으로 아직까지 오프라인 출판으로 이어지지 않았고, 우연한 기회에 알게 된 브런치를 통해 그 내용을 공개하고 있다. 개인적으로 글을 쓰는 것은 좋은 힐링이 되는 것 같다. IT 서비스 산업에서 청춘을 보내면서 개발자, 경영 진단, 전략기획, 비즈니스 컨설팅, 해외 사업 등을 경험하였고 이제 40대 중반을 바라보고 있다. 로봇과 인공지능이 난무할 듯한 도래하는 디지털 시대에 대한 반작용인가 저자는 최근 글 읽기와 글쓰기에 관심이 높아져간다. 요즘은 주말이면 아이와 함께 도서관을 많이 찾고 있다. 글 읽는 것이야 저명인사들의 수많은 추천작들이 있으니 시간 날 때마다 읽을 것이지만 글쓰기는 무엇부터 시작할 수 있을까? 좋은 글을 필사하는 것도 한 방법이려니와 저자는 그동안 경험한 것들을 아직 머릿속에 남아 있을 때 정리해 보자는 목적으로 저술을 시작하였다. 그 목적이 그래서일까 두 권을 쓰고 나니 저술이라기보다는 정리의 느낌이 더 강한데 조금 더 시간이 흐르거나 오프라인 출판으로 이어지면 Case Study 같은 것들을 추가하여 저술의 모양새를 갖추게 될 수도 있으리라 생각된다. 이번 매거진에서는 컨설팅을 다룰 것이다. 컨설팅은 많은 사람들이 흥미로워 하는 영역임과 동시에 매우 전문적이어서 배타적인 영역이기도 하다. 다음과 같은 목차로 진행될 계획인데 제대로 죽 보고 나면 어딜 가도 빠지지 않고 비즈니스 컨설팅에 대해 한 마디 할 수 있을 것이다. 그러나 책으로 도움을 얻는 것은 딱 거기까지이다. 왜냐하면 가장 중요한 것은 자신이 직접 실제로 해보는 것이기 때문이다. 저자는 뭐든지 직접 해보는 것만한 것은 없다고 생각한다. 그런 차원에서 컨설팅을 다루는 이 매거진은 왜 컨설팅 화두였는지 앞으로는 어떻게 될지 이 일을 하는 사람들은 어떻게 일하고 있는지 이해하는데 충분한 도움을 줄 것이라 생각한다. 많은 브런치 독자님들과 오다가다 글을 보게 되는 독자님들의 좋은 피드백을 기다린다. 00. 목차 [목차] Prologue Part I. 컨설팅 산업은 부활할까? 1. 컨설팅 정의와 종류 2. 컨설팅 산업의 현황 3. 컨설팅 기업들의 전쟁 Part II. 컨설팅 스킬 1. 논리적 사고 2. 문제 해결기법 3. 커뮤니케이션 스킬 Part III. 컨설팅 도구와 기법 1. 경쟁 및 산업 분석 2. 고객 요구 분석 3. 수익성 분석 4. 역량 분석 5. 시사점 및 대안 도출 Part IV. 컨설팅 방법론 1. 프로젝트 관리 방법론 2. 경영전략 수립 방법론 3. 프로세스 혁신 4. 신사업 개발 5. 사업타당성 분석 6. 정보전략 컨설팅(BPR/ISP) 방법론 Part V. 컨설팅 사업 개발 및 이행 1. 컨설팅 사업 개발 2. 성공하는 컨설팅 사업 제안 3. 컨설팅 이행과 지식경영 Epilogue 000 PART I. 컨설팅 산업은 과연 유망한가? 어떤 일을 시작할 때는 그 일에 대한 정의(定義)를 잘 생각해 보고 바라볼 줄 알아야 한다. 그 정의에 충실할 때 본질(本質)과 이어지고 그 결과도 명확하기 때문이다. 최근 ‘컨설팅(Consulting)’이라는 단어가 여러 분야에서 많이 쓰이고 있다. ‘부동산 컨설팅’, ‘취업 컨설팅’. 심지어 개 키우는 것도 ‘Pet 컨설팅’이라는 말을 붙이고 있다. 컨설팅의 의미를 전문적인 지식을 가지고 자문(諮問)을 해준다는 측면에서는 그 명칭들은 타당할 수도 있겠다. 그런데 그런 상황을 접하면서 전직 비즈니스 컨설턴트였던 저자는 약간 아쉬움도 마음 한편에 같이 들고 있다. 오히려 컨설팅에 대한 본질(本質)은 잊어버린 채 괜히 바람만 들어가 있었던 것일까? 사실 컨설팅은 해당 업(業)에 대한 많은 지식과 경험이 필요한 고급 비즈니스이다. 그 업무 강도 또한 만만치 않아 건설 현장의 노동과 곧잘 비교되기도 한다. 또한, 항상 새로운 것을 접하고 지적 탐구를 통해 해법과 설루션을 찾아가는 것이 주요 업무이기 때문에 이런 성향의 일을 좋아할 수 있는 사람이라면 컨설턴트(Consultants)는 매우 좋은 직업이 될 수 있다. 그렇다면 역시 컨설팅 산업은 유망하다고 할 것이다. 저자의 기억에 컨설팅이라는 단어를 처음 접하게 된 것이 1996년 무렵 ‘부즈 알랜 & 해밀턴’[1]이라는 컨설팅 회사에서 발간한 파란 표지의 책 한 권을 접하면서였다. 1996년은 세기말을 맞이한다는 음울한 분위기와 함께 아시아 경제가 금융 위기를 맞이하고 있어 우리나라도 경제가 매우 어려운 상황이었다. 이듬해 1997년에는 우리나라는 국가부도 상태가 되어 국제통화기금(IMF[2])으로부터 경제 회생을 위한 구제 금융을 제공받고 관리 대상이 되어야 했던 시기였다. 파란 표지의 책은 당시 대한민국이 직면하고 있던 여러 가지 종류의 국가적 이슈를 언급하고 있었다. 그것들은 학생이었던 저자가 취업 후 처음 맞이한 대한민국의 충격적인 민낯이었다. 한 편으로는 ‘이 사람들은 누구이길래 한 나라의 상황을 어떤 기준에서 분석하고 이러 저런 조언까지 하는가?’ 하는 놀라움과 의문도 들었다. 그리고 5년 뒤 또 다른 책 한 권 ‘맥킨지 웨이(The Mckinsey Way)’을 접하게 되었다. IMF 사태 이후 국가 경영의 체계를 글로벌스탠더드(Global Standards)에 맞추기 시작하면서 경영 컨설팅이 본격적으로 우리나라 기업에 도입되기 시작했는데 그 선두에 있던 컨설팅 기업이 그 유명한 맥킨지(Mckinsey& Co.)[3]였다. 맥킨지 컨설팅이 일하는 방식을 소개한 이 책은 컨설턴트란 어떤 직업인지, 그들은 어떤 일을 하는지 대중들에게 소개한 대표적인 책이었다. 책은 베스트셀러가 되었고 당시 컨설턴트가 되고 싶은 사람들에게는 필독서가 되다시피했다. 또한, 그 책은 직장 초년생들의 MBA[4] 붐 조성에 한몫하기도 했다. 저자도 비즈니스 컨설턴트로써 6년을 일했고 수많은 프로젝트를 수행했다. 기업의 비전과 전략, 혁신을 다룬다는 측면에서 프로젝트 수행 후 높은 성취감도 있었지만, 업무 스트레스와 치열한 경쟁을 피해 많은 컨설턴트들이 컨설팅 회사에서 고객 기업 즉, 현업으로 이동하는 것도 지켜보게 되었다. 컨설팅 기법들도 더 이상 비밀스러운 그들만의 전유물이 아니게 되었으며, 이제는 고객들도 이를 잘 알게 되었다. 컨설팅 결과에 대한 부정적인 측면도 많이 나타났다. ‘경영진이나 회사의 입장에서만 바라본다’, ‘구조조정의 첨병’, ‘직원들을 위하는 방향이 없다’ 등이 그런 것들이다. 그러나 저자는 요즘 컨설팅 산업이 조금 다르게 보인다. 오늘날 산업 환경은 거의 전방위적으로 컨설팅적 사고방식을 요구한다. 저자는 현재 비즈니스 컨설턴트를 그만두고 B2B 회사에서 마케팅/영업 일을 하고 있지만 컨설팅 경험이 적지 않은 도움을 주고 있다. 그래서 저자의 경험을 기반으로 컨설팅을 다시 한번 돌아보고자 한다. 컨설팅이란 무엇이고 과거에 어떻게 일했고 어떤 도구와 기법, 방법론들이 유용했으며 기회가 되면 사업으로서의 컨설팅과 사례에 대해서도 기록하고 공유해 보려고 한다[5]. 저자는 독자들이 이 책을 통해 다음 세 가지를 얻기를 희망한다. 첫째, 컨설팅 산업을 제대로 이해하는 것. 사업은 생물처럼 계속 변화한다. 이 책을 통해서 컨설팅이란 무엇인지? 컨설턴트들은 어떤 일을 하는지 직업으로서의 컨설턴트를 생각해 볼 수 있게 될 것이다. 둘째, 컨설팅에 사용되는 다양한 도구와 기법, 방법론을 이해하고 실무에서 활용할 수 있게 되는 것. 논리적 사고(Logical Thinking)를 요구하는 다양한 컨설팅 기법은 전략기획, 경영혁신, 신사업 개발, 마케팅/영업 등 다양한 업무에서 활용 가능한 기법들이 많다. 이를 활용하여 효율적인 업무 수행에 도움이 되기를 바란다. 마지막으로 셋째, 이 책이 컨설턴트를 미래의 직업으로 생각하고 고민하는 학생들이나 컨설턴트로의 전직을 생각하는 직장인들에게 실용적인 지침서(Practical Guide)가 되었으면 한다. 저자가 컨설턴트가 되겠다고 생각했던 때는 참 막연했었다. 정보도 없었고 어떤 경로로 그렇게 되어야 하는지 알기도 어려웠다. 일하면서 조금씩 구체화해 나갔고 그 과정은 좋은 경험이었지만 뒤돌아보면 후회되는 일도 많다. 저자가 도전하던 시절과 지금의 컨설턴트의 의미나 위상은 분명히 다르지만 새롭게 전개되는 시대에 후배들이 겪을 그런 시행착오를 조금이라도 덜어주고 싶다. 이제부터 하나하나 상세히 알아보도록 하자. [1] www.boozallen.com [2] International Monetary Fund, www.imf.org [3] www.mckinsey.com [4] Master of Business Administration 경영학 석사. 대부분의 컨설팅 기업은 MBA 학위가 필수이다. [5] 컨설팅은 기업 비밀 사항을 많이 다룬다. 이 부분은 공개할 수 없으므로 그런 부분은 생략할 것이다. 같이 읽으면 좋은 책 'Management Consulting: A Guide to the Profession (3rd)', International Labour Office Publication, 1996 '맥킨지는 일하는 방식이 다르다(The Mckinsey Way)', 에단라지엘, 1999 01. 컨설팅 정의와 종류 컨설팅(Consulting)이란 무엇일까? 사전적 의미로는 ‘조언(助言)을 주는 것’이다. 그러나 실제 컨설팅 비즈니스에서는 단순히 조언을 제공하는 것을 넘어서 ‘설루션(Solution)을 제시’한다. 문제(Problems)를 파악하고 고객이 해결하기 어려운 것 또는 직접 해결하기 싫은 것들을 대신해 주면서 그 대가로 돈을 지불 받는 것이다. 설루션은 지식과 경험에서 도출되기 때문에 고객으로부터 정보를 이끌어내고 고유의 도구와 기법을 활용하여 이를 어떻게 효과적으로 전달하느냐에 따라 지급받는 대가도 천차만별(千差萬別)이다. 뛰어난 스펙(spec)으로 무장한 유학파 컨설턴트나 학위는 없지만 수 십 년 간 사업 현장에서 잔뼈가 굵은 직원이 제시한 답이 별 차이가 없을 수 있지만, 어떻게 보고되느냐 하는 것에 따라 그 가치는 서로 많이 다를 수 있다. 그래서 컨설턴트들은 그들의 지식과 경험을 제대로 전달하기 위해 논리와 분석, 보고서 작성(Documentation)과 프레젠테이션(Presentation)에 많은 공을 들인다. Part I의 제1장에서는 컨설팅의 정의와 컨설턴트에 대해 상세히 알아보도록 하자. 1.1 컨설팅의 개념 최근 더욱 널리 사용되는 ‘컨설팅’이라는 용어는 많은 사람들의 노력에도 불구하고 사실 그 정의를 내리기가 어렵다. 오래전의 일이지만 경영 컨설팅을 예를 들면 미국 애리조나 공인회계사 협회의 후원으로 결성된 경영 컨설팅 위원회는 ‘경영 컨설팅은 정의할 수 없다’라는 결론까지 내렸다고 한다. 컨설팅은 회계나 법률에서 시작하여 경영에 이르러 사업화되었다고 보는 시각이 대부분이므로 그런 서비스가 가장 많이 발달한 미국과 영국을 예로 들어 보면 다음과 같은 정의들이 있다. **"경영 컨설팅이란 기업으로 하여금 당면한 문제들을 분석, 해결할 수 있도록 또는 기업의 성공 사례를 타 기업에 접목시킬 수 있도록 도와주는 전문적인 서비스를 제공하는 것이다." Management Consulting: A Guide to the Profession **"경영 컨설팅은 특별히 훈련받고 경험을 쌓은 사람들이 기업 경영 상의 여러 가지 문제점들을 규명하고 해결할 수 있도록 실질적인 해결 방안을 제시하고 그러한 해결 방안들이 적기에 실시될 수 있도록 도와주기 위한 전문적인 서비스를 제공하는 것이다." Association of Consulting Management Engineers **"경영 컨설팅이란 특별한 분야의 전문성을 가진 전문가들이 자기들의 지식과 경험을 활용하여 경영 문제를 해결하고, 객관적이고 전반적인 시각에서 기업의 기획 과정을 지원하는 것을 말한다." Management Advisory Services Division **"경영 컨설팅은 독립적이고 능력을 갖춘 사람(들) 이 정책, 조직, 절차, 방법 상의 문제점들을 연구, 분석하고 적절한 해결책을 제시하며 나아가 이러한 해결책들을 수행할 수 있도록 돕는 것이다." Institute of Management Consults, United Kingdom **"경영 컨설팅이란 조직의 목적을 달성하는 데 있어서 경영, 업무 상의 문제점을 해결하고 새로운 기회를 발견하고 포착하여, 학습을 촉진시키고 변화를 실현하는 조직 및 관리자를 지원하는 독립적인 전문, 자문 서비스" 국제노동기구(International Labour Organization) 위에서 언급된 컨설팅 정의들을 참고하면 컨설턴트들의 업무와 요구 역량을 다음의 5가지로 유추해 볼 수 있다. 1) 독립된 입장 2) 특별한 훈련과 자질 3) 자문의 제공 4) 문제의 규명과 분석 5) 문제의 해결과 수행 이를 컨설팅을 수행하는 컨설턴트의 관점에서 좀 더 풀어보면 다음과 같다. 1) 컨설턴트는 제3자 시각(視角)이라는 독립된 입장을 보장받아야 한다. 2) 컨설턴트는 특별한 훈련과 자질 습득을 위해 전문 분야의 지식 또는 업무 경험을 축적해야 하며, 이의 입증을 위해 박사나 MBA 학위를 요구하기도 한다 3) 컨설턴트는 자문을 제공한다는 측면에서 커뮤니케이션 스킬(Communication Skills)이 매우 중요하다. 4) 컨설턴트는 문제를 파악하고 분석하기 위해 전문적인 도구와 기법을 사용하며 5) 문제의 해결과 수행이라는 측면에서 컨설턴트에게 창의적인 아이디어와 기간 내에 업무를 수행해야 할 수 있는 높은 업무 집중력이 요구된다. 이런 것들을 미루어볼 때 분명히 컨설팅은 아무나 할 수 있는 일은 아니다. 그렇다면 컨설팅을 받는 고객들은 이런 컨설턴트에게 무엇을 기대하고 있을까? 컨설턴트가 제공하는 컨설팅 서비스는 다음과 같이 4가지 관점에서 구분해 볼 수 있다. **1.2 컨설팅 서비스의 관점 컨설팅 서비스의 4가지 관점 중 가장 많은 비중을 차지하는 것은 첫 번째는 의사(Doctor)의 역할이다. 즉, 많은 기업 고객들은 기업이 제대로 운영되고 있는지 등 경영에 대한 전반적인 상황을 파악하고 처방을 받고 싶어 한다. 비전(Vision)이나 중장기 경영 전략(Corporate Strategy) 수립, 사업 포트폴리오(Business Portfolio) 정립 및 관리, 기업 구조조정(Restructuring) 등 기업 경영의 큰 그림(Big Pictures) 구상과 그 목표 달성을 위한 과제 수립 등이 컨설팅의 주요 내용이다. 주로 전략 컨설팅 기업들이 이런 주제들을 많이 다룬다. 두 번째는 탐정(Detective)의 역할이다. 기업 진단을 포함할 수 있는데 의사의 역할이 기업의 전반적인 부분을 탐색하고 다룬다면, 탐정의 역할은 특정 부분을 파고들어 보다 세밀하고 근원적인 문제들을 해결하는 것이다. 주로 프로세스 컨설팅이 이에 해당한다. 재무, 인사, 마케팅/영업, 구매, 조달, 생산, 물류, IT 등 기업의 다양한 프로세스를 개선 또는 혁신하는 것이 이 컨설팅 서비스 영역이다. 세 번째는세일맨(Salesperson)의 역할이다. 의사나 탐정 역할의 컨설팅이 수행되면 다양한 과제들이 도출되는데 요즘은 그 과제들의 상세한 개발이나 실질적인 추진을 컨설턴트가 맡기도 한다. 특히, 신규 사업 개발이나 신규 고객 발굴과 같은 새로운 영역의 개척이 많다. 비즈니스에 관심이 많은 컨설턴트들은 신사업 발굴 컨설팅을 하고 나서 아예 고객 기업으로 옮겨서 해당 사업을 직접 맡고 팀장 또는 담당 임원으로 일하는 경우도 많다. 네 번째는 고객이 하기 싫은 일을 대신해주는 경우 즉 용역 대행(Agent)의 역할이다. 물론, 앞에서 소개한 것들 모두가 고객 대신 어떤 것을 해주는 경우가 될 수도 있겠지만 고객과 컨설턴트가 서로 훌륭한 파트너가 되어서 협업하는 경우도 매우 많다. 그러나 네 번째 경우는 그런 관계가 형성되기보다는 하위 수준의 단순 업무 대행이라고 할 수 있다. 이런 풍조는 최근 컨설턴트들의 위상과도 관련이 깊은데 2000년대 중반까지만 해도 어떤 일을 할 때 전문적인 지식이 필요하거나 구조조정과 같은 소위 피를 묻히게 되는 일을 할 경우, 기업은 일의 객관성이나 사내 조직문화를 생각해서 구조조정팀의 대부분을 외부 전문가들로 구성하고 컨설턴트들을 고용하는 경우가 많았다. 그런 일에는 컨설턴트들도 매우 신중하게 움직였으며 일에 대한 의미 부여도 남달랐다. 그러나 2007년[1]을 전후로 컨설팅의 가치가 좀 퇴색되어 가는 듯한 느낌도 많이 든다. 컨설팅 산업의 침체에 따른 것인지 컨설턴트들의 자부심이나 사기도 많이 저하된 것 같다. 이런 침체된 분위기는 컨설턴트들이 독립적인 컨설팅 과제 수행보다 현업을 대신해 임시 용역 대행처럼 일하게 되는 경우가 많아지고 있기 때문이 아닐까 생각된다. 컨설턴트들이 일을 못해서 단순 용역을 맡게 되는 것은 아니고 과당경쟁으로 그들의 Value와 대가를 스스로 낮춰서 그런 것도 아닐 것이지만 사업 환경은 그렇게 변화되어 가는 것 같다. 변화하는 사업 환경은 컨설팅 서비스의 또 다른 구분자에 영향을 주고 있다. 전통적으로 기업 전략의 구조에 따라서 컨설팅 서비스는 나름의 영역을 구축하고 컨설팅 기업들 간에 이것을 서로 구분해왔는데 이제 이것도 변하고 있다. 기업의 전략은 크게 경영전략, 사업전략, 기능 및 운영 전략 등 3가지 층으로 구분하여 설명해왔고 컨설팅 서비스도 이와 연결되어 있었다. 그런데 1990년 대 이후 e-비즈니스가 급속하게 발달하면서 기존의 가치 사슬(Value Chain)이 붕괴되고 새롭게 정립되면서 변화하고 있다. Figure I-4와 같이 전통적인 모습은 피라미드 형태였는데 지금은 전략 컨설팅이 경영전략 부분을 다루고 일부 사업 전략까지 내려갈 수 있다. 그리고 IT 컨설팅으로 대표되는 ‘프로세스 컨설팅’은 기능 및 운영 전략과 관련된 것인데 최근에는 사업 전략의 일부 및 경영 전략까지도 다루고 있다. 한때 기업의 비핵심업무(Non-Core business) 중 하나였던 전산 업무가 비즈니스 모델 혁신 및 컨버전스(convergence)의 동인(動因)이 되어 버린 것이다. 메가트렌드의 변화와 더불어 컨설팅 서비스도 그 범위가 확대되고 변경되면서 컨설팅 기업들도 새로운 옷을 빠르게 입어야 할 필요가 생겼고 이는 우수한 신규 인력 채용을 넘어서서 기업 간 인수합병 같은 동적인 변화도 야기하였다. 아울러 컨설턴트들도 같이 다변화되었다. 이제 더 이상 컨설팅은 경영 컨설팅만을 의미하는 것이 아니다. 컨설팅의 의미를 전 산업에 걸쳐서 공유할 필연적인 이유가 생긴 것이다. **"컨버전스(Convergence)란 기술 혹은 제품들이 유사화[2]와 복합화[3]를 통해 기존 시장 영역 간의 구분 또는 경계가 불분명해지는 현상을 의미한다." 서울대학교 경영 대학<NAME> 교수, LG 경영전략 아카데미, 2004 [1] 2007년 엔론 사태로 인해 회계 서비스와 컨설팅 서비스 등에 대한 큰 구조조정이 있었고 그 이후 정보통신기술의 발달 등 다양한 외부 요인으로 전 세계적으로 컨설팅 산업은 양적, 질적 변화를 겪었다. [2] 기존에 서로 다른 고객 가치를 제공하던 기술 또는 제품으로부터 유사한 고객 가치가 제공됨 [3] 서로 다른 제품 및 기술들이 결합되어 새로운 고객 가치를 제공함 1.3 컨설턴트란 어떤 사람인가? 컨설턴트들이라고 하면 흔히 정장(suit and tie)을 차려 입고 점령군처럼 기업에 들어와 껄끄러운 일을 하고 소리 소문 없이 나가는 사람들의 이미지를 많이 떠올리는데 이는 과거에 구조조정의 최전선에서 컨설턴트들이 많이 일했기 때문에 그런 이미지가 형성된 것이라 생각된다. 약간 부정적인 이미지에도 불구하고 고연봉 전문직이라는 인식으로 한때 많은 사람들이 막연히 컨설턴트라는 직업을 동경하기도 하였다. 그러나 컨설턴트를 직업으로 고려하는 사람들은 이제부터 저자가 하는 이야기를 잘 새겨들어야 한다. 앞서 살펴본 컨설팅의 정의 또는 개념을 다시 생각해 보면 컨설턴트란 결국 컨설팅을 하는 사람이다. 이를 조금 다듬어보면 ‘컨설턴트란 학문적 지식과 현장 경험을 통해 의뢰자의 문제를 분석해서 현재(As-Is) 보다 나은 미래(To-Be)를 모델/모형으로 제시함으로써 기업의 경쟁력 강화에 도움을 주는 사람’으로 표현할 수 있다. 그러나 이런 컨설턴트들도 같이 일을 하다 보면 개인의 성향과 더불어 각 개인이 풍기는 컨설턴트의 특성(personalities of Consultants)이 여실히 드러나게 되는데, 가장 많이 표현되는 모습들은 정리해 보면 객관적 조언자, 선의의 중재자, 문제 해결사, 코치/교육가로 구분해 볼 수 있다. 이런 구분은 좋다/나쁘다, 더 우수하다 등의 의미가 아니라 사람이 가진 고유의 성품에 기반해서 다양한 컨설팅 업무 중에 이런 부분이 투영되어 해당 컨설턴트에게 나타난다고 이해할 수 있다. 아울러 그런 성향과 잘 매칭되는 프로젝트에 투입되면 그 성과는 100%를 초과 달성한다. 이런 컨설턴트의 성향을 동물로 재미나게 표현한 것이 있어 소개한다[1]. 첫 번째 유형은 비버(Beaver)이다. 비버의 특성을 보이는 컨설턴트들은 그야말로 엄청난 노력(Efforts)을 보이는 사람들로 대체로 과거지향적이고 프로세스 개선이나 프로세스 혁신(PI[2]) 같은 일을 잘 수행해낸다. 두 번째 유형은 여우(Fox)이다. 여우의 특성을 보이는 컨설턴트들은 문제 해결에 강점을 지닌 경우가 많다. 현재의 문제에 관심이 많으며 Trouble-shooting 같은 일을 잘 수행해낸다. 세 번째 유형은 올빼미(Owl)이다. 올빼미의 특성을 보이는 컨설턴트들은 통찰력(Insight)이 뛰어난 경우가 많으며 미래에 관심이 많고 전략 수립이나 기업의 큰 그림(Big Picture) 구상에 능하다. 마지막으로 네 번째는 돌고래(Dolphin) 유형의 컨설턴트들은 관계지향적이다. 이들 역시 미래에 관심이 많으며 조직문화, 코칭, 교육 쪽에 관심이 많다. 그렇다면 이런 비유적인 표현에 부합하는 훌륭한 컨설턴트가 되기 위해서는 어떤 능력과 자질(Skills), 또는 지식(Knowledge)과 태도(Attitude)가 필요할까? 다양한 의견을 종합해 보면 컨설턴트의 능력과 자질에 대해서는 다음과 같은 3가지 능력이 중요하다. **1) 문제해결 능력(Problem Solving skills) 2) 프로젝트 관리 능력(Project Management skills) 3) 의사소통 능력(Communication skills) 첫 번째, 문제해결능력은 객관성의 정도, 끝없는 호기심, 귀납적 추리력, 분석 및 종합 능력 등을 요구한다. 사실에 기반한(Fact-based) 사고, 가설 지향적인(Hypothesis-driven) 사고, MECE[3] 적 사고, 로직 트리(Logic Tree), 벤치마킹(Benchmarking) 등은 문제해결 능력을 발휘하는데 중요한 것들이다. 두 번째, 프로젝트 관리 능력은 컨설팅 프로젝트를 위한 가장 기본적인 능력이다. 프로젝트 관리와 관련된 국제 표준[4]도 있으며, 팀 내 또는 팀 간 플레이와 관계된 협업, 고객 관계 등이 중요하다. 세 번째는 의사소통 능력이다. 저자도 많은 컨설턴트들을 보아 왔고 같이 일했었는데, 문제해결 능력과 프로젝트 관리 능력은 개인의 노력과 반복적 훈련에 의해 발전될 수 있지만 세 번째 의사소통 능력은 개인의 노력과 무관하게 타고난 성격도 관계가 깊어 이 부분이 부족할 경우 더 많은 노력이 필요하다. 심지어 각고(刻苦)의 노력으로도 이 부분 향상이 잘되지 않으면 컨설턴트를 직업으로 취하지 않는 것이 좋다. 인터뷰(Interview)나 청취(Listening)를 통해 민감한 커뮤니케이션을 효과적으로 해야 하며, 탁월한 문장력으로 문서를 작성(Documentation) 해야 한다. 특히, 언어적 표현 능력은 대단히 중요하다(Presentation & Meeting). 그런데 컨설턴트의 기본 역량이라고 할 수 있는 이런 능력과 자질에 더해서 고객을 리딩(leading) 하기 위해서는 업(業)에 대한 다양한 지식과 경험도 갖추고 있어야 한다. 박사나 MBA 학위가 도움을 주기도 하지만 요즘같이 급변하는 세상에서는 그 효과가 2년을 채 가지 못한다. 따라서 컨설팅하고자 하는 분야에 대한 끊임없는 학습이 중요하다. 기업 경영과 관련된 컨설팅을 생각해 보면 산업 지식이나 업무 지식, 프로세스, 정보통신기술 지식 등을 잘 알고 있는 것이 좋다. 또한, 컨설턴트를 바라볼 때 능력과 자질, 지식도 있어야 하지만 무엇보다도 가장 중요한 것은 자세(Attitude)이다. 컨설턴트의 자질과 관련해서 선배들로부터 전해지는 워딩들(wordings)을 살펴보면, ‘불편부당성(Impartiality)’, ‘고객의 이익은 나의 이익’, ‘할 수 있는 것과 할 수 없는 것’, ‘넓은 시각’, ‘긍정적이고 적극적인 사고’, ‘예의 바름’, ‘변화의 수용’, ‘지속적인 학습’, ‘Know-why’, ‘Know-what’, ‘Know-where’, ‘Know-how’ 등은 빠지지 않는다. 컨설턴트의 자세를 논하면서 듣게 되는 공감 가는 표현들이지만 그중 ‘불편부당성’, 이 용어는 ‘객관적인 기록물’을 다루는 사람이라면 누구나 느낄 수 있는 딜레마(Dilemma)이기도 하지만, 컨설턴트라는 직업의 근본을 고민하게 한다. ‘불편부당성’이라는 용어는 어떤 것을 기록할 때 객관적인 입장을 취하지만, 기록물 생산자의 입장이 반영되어 있다는 의미이다. 즉, 한편으로는 이미 객관적이 아니라는 말과도 통한다. 그렇기에 컨설팅 결과는 당연히 비용을 지급하는 클라이언트가 요구하는 것이 되어야 하겠지만, 그렇게 일하는 것이 반드시 옳은 것인지는 사안에 따라 양심을 걸고 생각해 보아야 한다. 정리하면서, 저자가 컨설턴트가 되었을 때 부문장이자 파트너이셨던 분이 신입 컨설턴트들을 모아 놓고 들려줬던 이야기를 공유한다. 시간이 많이 흘렀지만 여전히 유효하다. **-Consultant has: 목표와 비전, 도전 정신, 창의력, 열정, 논리적 사고 -Consultant should have: 고객지향 마인드, 독립성, 객관성, 리더십, 친화력, 협동심 -Consultant has above all: 불굴의 정신력,<NAME>한 체력 Break #1. 훌륭한 컨설턴트가 되기 위한 레알 팁(Real Tips) 1.3장의 내용이 훌륭한 컨설턴트가 되기 위한 소위 말하는 '모범 답안'이라면 이제부터 이야기는 수많은 컨설턴트 선배들의 전언(傳言)처럼 내려오는 레알 팁이다. **(1) 먼저 글로벌 기업에서 5년 이상 근무하라 이제 국내에도 글로벌 기업들이 많이 진출하였다. 또한, 삼성전자나 LG전자 같은 대기업들은 현재 기업의 많은 부분들이 글로벌 수준에 달했다고 할 수도 있다. 학교 졸업 후 바로 컨설팅 기업에 취업하기보다는 이런 글로벌 기업들의 한국 지사나 그런 수준의 업무 복잡성을 갖춘 대기업에서 전략이나 마케팅, 구매 등 향후 컨설팅하고 싶은 업무 영역에서 몇 년 간 일해보라. 경력을 인정받으려면 한 기업에서 최소 3년 이상 일해야 하니 그 이상 근무하면서 현장의 지식을 습득하려고 노력하라. 실제 컨설팅을 할 때 살아 있는 지식을 활용할 수 있는 기반을 갖추는 것은 컨설턴트의 컨설팅 경쟁력을 높일 수 있는 매우 중요한 방법이다. 왜냐하면 살아 있는 현장의 지식과 경험만이 고객의 깊은 공감을 사기 때문이다. 살아 있는 지식과 경험이 없다면 MBA나 박사 학위 등은 이력서 한 줄에 지나지 않는다. **(2) 호수 위의 우아한, 그러나 부지런한 백조가 돼라. 컨설턴트들은 겉보기에 무언가 있어 보인다. 그런 이미지메이킹이 나쁜 것은 아니다. 그러나 그 모습 뒤에는 끊임없이 학습하며 밤새우고 공부하고 있는 컨설턴트의 또 다른 면이 있음을 항상 생각하라. 그래야 이 바닥에서 오래 살아남을 수 있다. 컨설팅은 지적 노동이자 매우 소모적인 일이다. 많은 시간을 투자하여 새로운 것을 탐구하는 연구 개발은 그 결과물이 유의미할 때 남는 것이 있다고 말할 수 있겠지만 일반적으로 컨설팅은 내가 알고 있고, 가지고 있는 것을 고객에게 ‘퍼주는 행위’이다. 컨설턴트인 나의 지식과 경험이 고갈되면 나의 가치는 당연히 떨어진다. 호수 위를 거니는 우아한 백조의 모습 그러나 수면 아래에서는 못생긴 물갈퀴 발을 쉼 없이 움직이고 있음을 기억하라! **(3) 초기의 성실함으로 고객의 신뢰를 얻어라. 프로젝트 초기에 모든 것이 결정된다. 저자의 경험으로는 하루, 늦어도 3일 내에 모든 것이 결정되었다. 프로젝트에 컨설턴트로서 투입된 첫날부터 고객을 위해 노력하고 있다는 느낌을 줄 수 있어야 한다. 고객과 같이 밤을 새우면서 일을 하던가, 같이 술 한잔하면서 고객의 고민을 들어보던가, 같이 운동을 하던가 뭐든지 좋다. 불법만 아니라면. 고객의 신뢰를 빠른 시간 내에 확보하는 것이 일을 가장 쉽게 하는 방법이다. **(4) 체력을 길러라. 글로벌 기업에서 일했고, 끊임없이 학습하고, 고객의 신뢰를 빨리 얻더라도 가장 중요한 것은 체력이다. 컨설팅은 몸과 마음을 100% 소모하는 직업 중 하나이다. 단기간에 업무 스트레스가 과중한 프로젝트를 끝내면 그동안의 야근과 밤샘으로 인해 흰머리가 생기고 피부가 노화되었음을 여실히 느낄 수 있다. 이걸 극복하는 것은 놀라운 회복력이요 그 근본은 체력이다. 보약도 중요할 수 있지만 체력 관리가 제대로 되지 않으면 컨설턴트로 오래 일하긴 어렵다. **(5) 기업의 관리회계를 파악하라. 기업의 비즈니스 모델을 이야기하고 컨설팅하기 위해서는 돈의 흐름을 잘 알아야 한다. 보고서만 예쁘게 만드는 허깨비 장표쟁이가 되기보다는, 업(業)의 본질을 바라볼 수 있는 통찰력을 키우기 위해서는 기업 고유의 관리회계 체계를 반드시 익히기 바란다. 의외로 많은 전략 컨설턴트들이 재무와 회계에 무지하다. [1] 동물에 대한 이미지가 동양과 서양이 달라서 그 특성을 설명한 것에 공감이 가지 않을 수도 있다 [2] Process Improvement 또는 Process Innovation [3] Mutually Exclusive Collectively Exhaustive 상호배제와 전체 포괄 [4] www.pmi.org PMP(Project Management Professional)라는 프로젝트 관리 공인 인증을 발급한다. 02. 컨설팅 산업의 현황 1990년대 e-비즈니스가 활성화되면서 사업을 B2B나 B2C[1]로 구분하는 방식이 널리 퍼졌다. ‘B2B’는 처음에는 전자상거래(e-commerce)에 한정된 용어였다가 지금은 ‘기업 간 거래’를 뜻하는 의미로 확장되어 사용되고 있다. B2B 제품은 Table I-2처럼 크게 8가지로 구분할 수 있는데 컨설팅은 그중 서비스 산업에 속해 있다. 직업을 선택하는 사람 입장에서 직업이 주는 성취감과 더불어 경제적인 측면에서 돈을 얼마나 벌 수 있는지 알아보는 것은 매우 중요하다. 산업별 수익률이 높은 산업에서 일한다면, 상대적으로 더 많은 수입을 올릴 수 있다[2]. 투자은행이나 증권사에서 산업별 수익률 또는 시장 수익성에 관한 리포트를 많이 발표하는데 특정 산업이나 시장 위주의 보고서가 자주 업데이트되며 전 산업을 다루는 경우는 드물다. Figure I-6은 미국의 산업별 수익률을 참고 자료를 활용해서 계산해 본 것이다[3]. 미국이 당시 세계 금융의 중심이라는 특수성으로 증권 중계 및 거래의 수익성이 가장 높은 것으로 나타났다. ERP[4]나 데이터베이스, 오피스 소프트웨어로 유명한 SAP나 Oracle, Microsoft 등이 속한 패키지 소프트웨어 산업도 37%에 달하는 높은 수익성을 보여주고 있다. 이에 비해 컨설팅 산업의 수익률은 외부에 잘 공개되고 있지는 않은데 경영 컨설팅 회사의 대부분이 주식회사가 아니라 유한회사의 형태를 가지고 있고, 실적을 외부에 공표할 의무가 없기 때문으로 생각된다. 제2장에서는 컨설팅 산업의 규모와 현황, 주요 사업자들과 변화 방향에 대해 살펴보도록 하자. **2.1 컨설팅 산업의 규모 시장조사기관인 IDC[4]에 따르면 전 세계 컨설팅 산업은 2015년 97.3에서 매년 [ ] 서 년 8.0 B까지 성장할 것으로 예측하였다. 지역별 연평균 성장률은 미주지역 8.6%, 유럽 및 중동, 아프리카 지역 7.0%, 아시아 태평양 지역 6.9%의 성장세를 보이고 있다 또한, 컨설팅 서비스 기준으로 전략 컨설팅, 운영 컨설팅, 조직 컨설팅, 재무회계, 규제 및 준수, 위험관리 컨설팅, 변화관리 컨설팅, 진단 등으로 구분될 수 있는데 조직 컨설팅과 전략 컨설팅이 2020년까지 매년 각각 8.9%, 8.8% 증가할 것으로 보인다. 최근에는 운영 컨설팅 중 IT 컨설팅이 더욱 부각되고 있다. Figure I-9와 같이 IT 컨설팅은 2015년 33B에서 년 서 2020 38로 매년 3.9% P씩 증가할 것으로 추정되고 있다. IT 컨설팅은 최근 컨버전스(Convergence)나 디지털 혁명 등과 관련된 어젠다를 맡게 되면서 전략 컨설팅과 중첩되고 있다. 특히, 전략 컨설팅 회사들과 IT 컨설팅 회사들이 과거에는 사업 규모나 일의 속성을 두고 구분을 명확히 하였으나, 디지털 영역을 두고는 그 업무의 경계나 작업의 구분이 모호해지고 있다. **2.2 유형별 컨설팅의 주요 내용 유형별 컨설팅의 내용에 대해 좀 더 알아보면 우선, 운영 컨설팅의 최근 트렌드는 비용 통제, 그중에서 비용 절감(cost saving) 부분에 주력되고 있다. 기업 고객들은 프로세스나 운영 기법을 혁신함으로써 놀랄만한 비용 혁신을 이루기를 원한다. 다음은 관련해서 최근 집중하는 영역이다. **-공급망 관리(Supply Chain Management: SCM)의 효율화 -효율적인 세금 관리 -효과적인 아웃소싱(Outsourcing) 도입 공급망 관리(SCM)는 프로세스 설계와 더불어 IT의 역할이 매우 중요하다. 기업 입장에서 최적화된 공급망 관리 체계를 성공적으로 구축하고 운영하는 것이 지상 과제이다. 글로벌 경제 환경에서 공급망이 확장되다 보니 무역은 자연스럽게 발생하고 이와 관련해 관세를 포함한 효율적인 세금 관리 부분은 글로벌 기업들의 주요 관심사 중 하나이다. 기업의 구매 형태가 점차 글로벌 소싱(Global Sourcing) 체계로 진화하면서 다양한 세금을 효율적으로 납부하고 절세하는 방안을 찾는 것이 관련 컨설팅의 주요 내용이다. 마지막 아웃소싱 부분은 기업의 비핵심업무(Non-core business)를 전문 기업에게 맡길 뿐만 아니라 기업 변신(Transformation)의 기회로 삼기 위한 전략적 선택지(Strategic Option)로서 아웃소싱을 활용하는 방안까지 포함한다. 오프쇼링(Offshoring)[6]이라든가 쉐어드 서비스(Shared Service)[7]같은 것들은 그런 고민의 연장선에 있는 것들이다. 조직 컨설팅의 경우, 사업을 보다 잘 추진하기 위한 조직 모델 재설계를 포함하여 필요한 인재 확보 및 조직 문화 구축에 주력하고 있다. 다음은 이와 관련하여 최근 주력하는 부분이다. **-인력 채용 및 소싱 -인재 관리를 통한 성과 창출 -효율적인 조직 운영 -다양한 HR 성과 지표의 효과적 관리 조직 컨설팅의 대부분은 인력 채용 및 소싱에 관한 것이다. 최근에는 HR과 관련된 다양한 인사 운영 부분을 전문적인 아웃소싱으로 많이 해결하고 있다. 인사 전략이나 인사 기획 부분을 통해 기업 고유의 문화를 구축하는 부분에 집중하고 그 외 부분은 업무 효율성을 제고하는 방향으로 운영하고 있다. 채용도 그런 측면에서 원하는 인재상에 맞추어 주기적으로 또는 수시로 채용을 진행하기 때문에 조직 컨설팅은 이런 부분에 대한 우수기업 사례의 소개 및 적용 등이 주요 내용을 이룬다. 전략 컨설팅의 경우, 과거 몇 년 간 급속하게 성장한 컨설팅 영역으로 급변하는 사업 환경에서 기업의 방향을 찾기 위한 고민으로 많이 수행되었다. 비전이나 사업전략 수립, 신사업 발굴 같은 것들이 전략 컨설팅의 주요 내용이다. 최근에는 좀 더 나아가서 다음의 것들에 초점을 맞추고 있다. **-운영전략 -내부 조율 -성장 동력 발굴 큰 방향 수립에 이어 과제들(Initiatives) 별로 상세한 운영 전략을 수립하거나 일부는 컨설턴트가 직접 수행하기도 한다. 중장기 과제의 경우, 클라이언트 내부의 조율을 위해 지속적으로 조력자(facilitators) 역할을 하기도 하며, 단순한 사업 아이템(Item) 발굴보다는 기업의 성장 동력 발굴을 위해 근본적인 기업 재조직(Rebuilding or Restructuring)까지 고민하는 경우도 많다. 재무회계 컨설팅의 최근 화두는 투명성(Transparency)의 향상과 의사 결정의 효율성 제고이다. 지난 20여 년간 ERP 구축을 화두로 많은 기업들이 재무회계 기반을 자동화하였으며, 업무에서 발생하는 각종 비용 항목들의 투명한 처리를 추구하고 있다. 또한, 최근 빅데이터(Big Data) 활용의 부상(浮上)으로 기업 내 의사결정 과정에 데이터를 본격적으로 도입, 적용하는 것이 더욱 활발해지고 있다. 기업 활동과 관련해서는 경제나 환경, 산업과 관련된 다양한 규제(regulation)나 법규의 준수(compliance)와 관련된 컴플라이언스(Compliance), 거버넌스(Governance), 위험관리(Risk Management) 컨설팅이 다음과 같은 주제를 가지고 진행되고 있다. **-규제와 법률 -글로벌화 -평판 및 대중적 인지 변화관리 컨설팅은 최근까지 인수합병(Merger& Acquisition) 후 조직 및 제도, IT의 통합과 관련된 변화관리 즉, PMI[8] 프로젝트가 화두였으나 국내에서는 인수합병이 활발하게 발생하지 않아 실제 PMI를 주제로 한 컨설팅이 많이 진행되지는 못했다. 다만, 프로젝트 내의 업무 단위 성격으로는 BPR/ISP에서도 포함되어 진행되는 등 변화관리에 대한 긍정적인 인식은 확산되어가고 있으며, 그 내용도 광범위한 영역에서 변화와 혁신을 주요 대상으로 하고 있다. 최근 변화관리 측면에서 컨설팅 기업들의 주요 관심사는 다음과 같다. **-비즈니스 모델 혁신 -운영성과 향상 -조직 및 성과관리 제고 마지막으로 진단 컨설팅은 기업의 사업과 운영을 포함한 경영 전반을 진단하는 경영 진단과 조직 역량 및 조직 문화 등으로 한정한 조직 진단으로 구분된다. 경영 진단은 주제에 따라서 전략, 마케팅, 구매, IT 등 더욱 세분화될 수 있다. 특히, 윤리경영[9]이 강조되는 오늘날 강력한 부패 척결 의지를 표명하고 실천하는 것은 기업의 큰 경쟁력으로 인정받고 있다. 다음은 최근 디지털 어젠다와 더불어 가장 핫한 IT 컨설팅에 대해 알아보자. [1] Business-to-Business Business-to-Consumer [2] 실질적인 수입은 수익률(영업이익률)과 매출 규모를 같이 생각해야 한다. [3] 글로벌 금융 위기를 두 번이나 겪은 현시점의 정보와는 다소 차이가 날 수 있어 순위 변동이 있을 수도 있다 [4] Enterprise Resource Planning 전사적 자원관리 [4] www.idc.com [5] Billion Dollars [6] 기업 운영의 일부를 해외 기업에 맡겨 처리함. 미국의 IT 운영 일부를 인도 IT 회사가 처리하여 24시간 서비스 가능하게 만드는 체계 등이 대표적인 예이다 [7] 인사, 재무, 회계, 구매 등의 서비스를 A, B, C 회사를 대상으로 대행해 주는 프로세스 아웃소싱의 한 형태. 관련 정보시스템이 같다는 점을 활용하며 최근에는 SaaS(Software as a Service)와 같은 형태로 많이 서비스된다. [8] Post-Merger Integration [9] Ethical Management. 회사 경영 및 거래에서 기업 윤리를 최우선 가치로 생각하며 투명하고 공정하며 합리적인 기업 활동을 지향하는 경영 방식 **2.3 IT 서비스 현황과 IT 컨설팅 최근 산업 전반에서 IT가 매우 중요한 역할을 하게 됨에 따라 IT 컨설팅도 과거와 달리 위상이 많이 달라졌다. IT 컨설팅은 IT 서비스의 한 영역으로 고객 맞춤형 개발이나 시스템 통합(SI)[1] 사업과 관계가 깊다. SI 사업은 고객의 요구사항에 맞추어 맞춤형 정보시스템을 구축해 주는 사업을 지칭하는 것인데 최근에는 단순 구축을 넘어서 운영 및 유지 보수, 교육 등을 전체 IT 서비스로 규정하고 이 전체를 IT 아웃소싱 사업으로 정의한다. IDC 조사에 따르면 2014년부터 2019년까지 한국의 IT 서비스 시장은 연 2.0% P 성장할 것으로 전망하며 특히 IT 컨설팅의 경우, 연 2.7% P씩 성장하여 2014년 1,800억 대 규모에서 2019년 2,000억 대 규모가 될 것으로 추정하고 있다. 한국의 IT 컨설팅 사업은 크게 공공 영역의 사업과 민간 영역의 사업으로 구분해 볼 수 있는데, 공공 IT 컨설팅은 IT 시스템 구축을 위한 BPR/ISP[2]가 대부분을<NAME>다. 이는 ‘소프트웨어 산업진흥법’ 등 관계법에 의거하여 공공 IT 시스템의 구축 전에 이를 의무적으로 수행하기 때문이다.[3] 반면, 민간 IT 컨설팅은 기업의 업무 프로세스 자동화나 비즈니스 모델 혁신을 위해 도입하는 IT 설루션 컨설팅이 대부분이다. ERP나 SCM 등 기업의 업무 프로세스와 직결되는 IT 시스템을 글로벌 기업들이 패키지 설루션 화하여 전파함으로써 많은 기업들이 이를 도입하였고, 그 과정에서 해당 기업에 맞게 일부 수정이 필요한데 설루션 컨설팅은 그런 부분에서 해당 업무 프로세스 전문가가 이를 컨설팅하여 프로세스를 개선하고 구축까지 하는 형태로 전개되었다. 한국 IT 서비스 협회[4]에서는 IT 서비스를 Table I-4와 같이 구분하고 있다. 그런데 최근에는 클라우드(Cloud) IT 서비스의 활성화로 인해 Table I-4의 분류와는 다른 형태의 IT 서비스 사업도 등장하고 있다. 클라우드 사업자들은 IT 서비스의 비용 체계를 종량제(Pay-per-Use)로 혁신함으로써 IT 인프라부터 응용 소프트웨어까지 사용한 만큼 비용을 지불하는 형태로 바뀌고 있다.[5] 클라우드 서비스의 경우, 인프라이면서 설루션인데도 몇 가지 파라미터 (parameter) 설정으로 간단하게 도입 가능하여 IT 컨설팅의 필요성이 희박하다. 반면에 최근 전 세계적인 관심을 받고 있는 제4차 산업 혁명의 도래와 관련하여 디지털 혁명이 산업 전반에서 재고려됨에 따라 디지털 전략 컨설팅은 다시 붐(boom)이다. 그러나 디지털이 처음 등장한 1980년대 초반과는 달리 디지털 마케팅(Digital Marketing)을 포함한 클라우드, 빅데이터, 사물인터넷(IoT)[6], 모바일, 로봇과 인공지능 등의 활용을 통한 기업 변신은 경쟁력 관점에 주저할 필요가 없게 되었다. 이것들로 인한 산업 패러다임 변화와 기업의 비전/전략의 수정은 당분간 수많은 컨설팅 수요를 생산할 것이다. 그러나 메가트렌드가 바뀜에 따라 컨설팅 패러다임도 바뀌고 있다. 전략 컨설팅이나 운영 컨설팅을 할 때 과거에는 알 필요 없던 IT에 대한 높은 이해가 필요하다던가, 반대로 IT 컨설팅인데도 비즈니스 모델을 다루기 위해 전략과 운영에 대한 지식이 풍부해야 하는 것 등이다. 결과적으로 이런 변화는 컨설팅 기업들의 사업 경계를 더욱 희미하게 만들고 있다. **Break #2. 디지털 마케팅과 버바리 디지털 전략 컨설팅과 관련해서 다양한 사례가 있지만 영국의 대표적인 명품 브랜드 버바리(Burberry)의 사례는 꽤 인상적이다. 버바리는 체크무늬와 트렌치코트로 매우 유명한 명품 패션 기업인데 ‘Luxury’를 추구하는 명품 산업의 특성상 폐쇄적이고 대부분의 명품기업들이 그렇듯 인터넷이나 디지털과는 관계가 없는 행보를 최근까지 해왔다. Fig I-11. 버바리 로고 및 트렌치코트 버바리의 전(前) CEO 안젤라 아렌츠(Angela Ahrendts)[7]는 디지털 전략을 적극적으로 활용하여 쓰러져 가 Fig I-12. 버바리 회생의 주역들 는 버바리를 회생시킨 것으로 유명하다. ‘버바리’가 노년을 위한 이미지가 커져가고 올드(old) 한 패션 브랜드가 되는 것을 막고자 다방면의 시사점을 점검하였는데, 그때 안젤라는 떠오르는 새로운 고객군 ‘밀레니얼 세대(Millennial Generation)’에 대해 인지하게 되었다. 1980년 ~ 2004년 사이에 태어난 밀레니얼 세대의 소비 특성은 물질적으로는 풍요롭지 않지만 그들의 개성을 표현하고자 하는 일에는 지갑을 과감하게 여는 경향이 있었고 무엇보다도 디지털 기기에 매우 익숙한 고객군이라는 것을 알게 되었다. 또한, 너무 세분화된 제품 브랜드를 경쟁력 있는 몇 가지로 통일하고 전 세계에 퍼져 있는 브랜드 관련 제반 일을 집중하게 하여 브랜드 커뮤니케이션 (Brand Communication)을 단일화하였다. 크리에이티브 디렉터인 크리스토퍼 베일리(Christoper Bailey)는 이런 일의 전권을 위임받고 안젤라와 함께 디지털 버바리를 실행에 옮겼다. Fig I-13. 버바리-인스타그램 협업 안젤라의 디지털 혁신 전략은 2009년 가을부터 패션쇼를 인스타그램(Instagram), 트위터(Twitter), 페이스북(Facebook) 등 소셜 미디어를 통해 실시간으로 볼 수 있게 제공하였으며, 패션쇼가 끝나면 온라인 스토어 버바리닷컴(burberry.com)과 오프라인 매장에서 즉시 그 옷을 구매할 수 있게 하였다. 파리 등에서 열리는 전통적인 패션쇼는 계절의 간극이 있어 여름에 패션쇼를 하면 다음 계절인 가을에 해당 옷을 파는 패턴을 보였는데 버바리는 그런 것을 없애버린 것이다. Fig I-14. 버바리 리테일숍, 영국 런던 온라인 스토어와 오프라인 매장의 결합은 버바리의 리테일 혁신 전략의 정점을 찍는데, 영국 런던의 피카다리 서커스 리젠트 거리에 있는 플래그십(Flagship) 매장에서 그 결실을 볼 수 있다(Figure I-14-①). 2014년 해당 매장을 방문한 적이 있었는데 화려하게 꾸며진 명품 매장의 외형을 넘어서서 옷 근처에 가면 거울에서 해당 옷에 대한 상세한 정보가 뜬다(Figure I-14-②). 또한, 구매한 옷에 새겨진 QR코드[8]는 스캔 시 생산 과정이나 런웨이(runway) 모습을 보여주며 고객의 경험을 확대하는 도구로 사용하고 있다(Figure I-14-④). 또한, 애플과도 상당히 높은 수준의 협업을 보여주고 있는데 오프라인 매장의 점원들은 아이패드에 탑재된 고객 데이터베이스(Customer One-to-One)를 가지고 온라인/ 오프라인 구매 목록, 사이즈, 색상, 매장 방문 기록, 추천상품 등 다양한 고객 정보를 프로파일링 하여 실시간으로 판매에 활용할 수 있게 하였으며, 결제도 아이패드를 이용하여 온라인 결제를 하게 하였다(Figure I-14-③). 아이폰 5/5S 론칭 때는 일반 카메라 대신 아이폰으로 패션쇼를 중계하였고, 애플 뮤직에 버버라 채널을 오픈하여 패션쇼에서 사용된 음원을 팔거나 애플 뮤직 사용자들의 추천곡을 패션쇼에 사용하여 ‘고객과 소통하는 젊은 버바리’라는 이미지를 확립하게 되었다. 영국 런던의 코벤트 가든 매장은 젋은이들의 유동 인구가 많아 이런 버바리의 변화를 좀 더 고려하였는데 화장품 특화 공간에 디지털 뷰티 박스(Beauty Box)를 만들었다. 디지털 뷰티 박스의 각 네일마다 RFID[9]가 부착되어 있어 화면 위 공간에 올려놓으면 사진 속 네일의 색상이 실시간으로 바뀌어 어떤 느낌인지도 확인할 수 있다(Figure I-14-⑥). 노쇠한 브랜드에서 새로운 고객군을 인지하고 디지털 마케팅을 포함한 디지털 혁신 전략을 통해 브랜드의 연령층도 낮추고 신규 고객도 확보하게 된 버버리는 혁신 전략의 첫해인 2013년 전년 대비 매출이 17% 증가하였다고 발표하기도 하였다. [1] System Integration. SI [2] Business Process Reengineering / Information Strategy Planning [3] 법률에 의거한 의무적 수행이다 보니 사업 대가 나 컨설팅 품질의 이슈가 제기되기도 한다 [4] www.itsa.or.kr [5] Infrastructure as s Service:IaaS, Platform as a Service:PaaS, Softwareas a Service: SaaS [6] Internet of Thing. [7] 안젤라는 버바리 CEO를 그만두고 2016년 애플의 리테일 스토어 및 온라인 스토어 수석 부사장으로 자리를 옮겼다. [8] Quick Response. 2차원 바코드 [9] Radio Frequency Identification 극소형칩에 제품 정보 등을 담아 안테나로 무선 송신하는 장치. 전자태그 등으로 많이 쓰임 03. 컨설팅 기업들의 전쟁 최근 다시 붐이 일고 있는 디지털 혁명에 따른 기업들의 변신은 컨설팅 기업들에게는 또 다른 호재를 주고 있다. 사실 국내외 컨설팅 산업은 2010년 즈음을 마지막으로 그 성장이 정체되거나 일부 영역은 하락세를 띄고 있다. 금융 위기에 따른 경제 불황의 여파도 있었고, 많은 컨설턴트들이 고객사에 합류하여 컨설팅 역량 자체가 고객에게 많이 이전된 까닭도 있었다. 또한, 경쟁에서 도태된 기업들은 인수합병(M&A)을 통해 그 간판을 내리게 되는 경우도 많았다. 특히, 컨설팅 사업은 대표적인 지식 사업(Knowledge Business)으로 많은 설비 투자나 자산 없이 사업이 가능하여 인수합병도 쉽게 발생한다. 주식회사보다 유한회사들이 많으며 컨설턴트들이 승진을 거듭하다 파트너(Partner)가 되면 회사의 지분을 기존의 파트너들과 나눠가지면서 책임과 권한이 더욱 강해진다. 이런 컨설팅 기업들도 2000년대 들어 몇 가지 특징을 보이면서 변화에 변화를 거듭하고 있다. 이번 장에서는 그 사정을 좀 들여다보자. 3.1 세계 컨설팅 기업들의 특징 전 세계를 무대로 각축을 벌이고 있으며 끝없이 변신 중인 소위 말하는 '쟁쟁한 컨설팅 기업들'에겐 공통된 특징들이 있다. 이 특징들은 20세기를 지나면서 급격하게 변한 사업 환경을 반영하고 있다는 것이 가장 큰 요인이라 할 수 있는데, 기업들도 궁극적으로 생존을 위해 과감한 변신을 택하고 있다고 볼 수 있다. 세계 컨설팅 기업들의 주요 특징은 다음과 같다. 회계 부문과 컨설팅 부문이 분리됨 컨설팅 영역 간의 구분이 희미해짐 사고 리더십(Thought Leadership) 강화에 집중함 첫 번째, 컨설팅 기업의 회계 부문과 컨설팅 부문의 분리는 2001년 대규모 회계 부정으로 세상을 놀라게 엔론 사태(Enron Scandal)[1]가 중요한 역할을 하였다. 이를 계기로 많은 컨설팅 회사의 회계 부문과 컨설팅 부문이 분리하게 되었는데, PwC의 경우 컨설팅 부문이 IBM에 35억 달러에 매각되어 현재 IBM Global Business Service로 이어지고 있으며, KPMG는 Bearingpoint라는 이름으로 컨설팅 부문이 독립하였다. Ernst & Young은 Cap Gemini와 함께 컨설팅 부문을 합병하여 CGE&Y로 운영되다가 다시 본래의 회계 부문과 각각 합병되었다. Deloitte도 회계와 컨설팅 부문을 분리를 고민하다 2013년 1월 전략 컨설팅 기업인 모니터그룹을 합병하기도 하였다. IT 컨설팅 업체인 Anderson Consulting은 Accenture로 사명을 바꾼 후 IT 구축 및 운영 사업까지 영역을 확장하여 전 세계 IT 서비스 1위 기업이 되었다.[2] 이들에 비해 사업 규모가 작은 중소형 컨설팅 기업들은 상황에 따라 서로 합쳐지거나 IBM, EDS[3]등 IT 서비스 기업들에 합병되었다. 이런 합종연횡(合從橫)은 각 기업들 입장에서 생존을 위해 또는 신규 사업 포트폴리오(Business Portfolio)를 구축한다는 측면에서 아주 자연스럽게 진행되었다. 두 번째 특징은 컨설팅 영역 간의 구분이 희미해졌다. 2013년 이코노미스트(Economist) 지에 기고된 기사[4]는 컨설팅 기업들이 사업 영역에 대해 임하는 자세의 변화를 극명하게 보여준다. Fig I-15. 국내외 컨설팅 기업들 해당 기사는 글로벌 Top 3 전략 컨설팅 기업들과 글로벌 Big 4 회계법인 간의 전쟁을 기술하고 있는데 컨설팅, 회계, 법, 재무 심지어 광고까지 특정 영역에서 전문적인 역량을 보유한 회사들이 컨버전스(convergence) 시대에 더 이상 이런 방식으로는 생존할 수 없음을 알고 상대방 영역으로 진입하기 시작한 것이다. 시대정신(Zeitgeist)이 통합이요 복합이고, 입체적이며 통섭(consilience)을 필요로 하는 상황에서 당연한 일인지도 모른다. 이코노미스트의 기사를 인용해 보면 우선 Top 3 전략 컨설팅 회사들은 상호 간에 벤치마킹(benchmarking) 하였다는 것을 알 수 있다. 신규 사업을 수주하기 위해 학맥이나 퇴직자 네트워크 등 동문(alumni) 네트워크를 활용했는데 사업 수주에 이런 방법을 활용하는 것은 맥킨지[5]가 유명했다. 또, 컨설팅 프로젝트가 성공하면 일부 프로젝트의 경우 성공 보수를 지급하였는데 이 방법은 베인[6]이 사용하던 방법이었고, B2B 사업을 함에도 불구하고 현재 세 곳 모두 자신들의 아이디어를 일반 대중에게 알리는 것에 매우 적극적인데 이를 처음 시작한 곳은 BCG[7]였다. 1990년대만 해도 6~18개월 동안 수행하던 컨설팅을 경제 불황으로 인해 예산도 줄게 되고 최근에는 3개월 이하의 프로젝트도 다수 발생하고 있다. 전략 컨설팅의 결과물도 CEO의 생각을 지지하기 위한 보고서를 넘어서서 ‘실행’과 관련되고 컨설턴트들도 자기가 제안한 혁신이나 개선 등의 일을 직접 맡게 되다 보니 자연스럽게 일의 성격이 실행-운영 컨설팅 영역으로 옮겨가게 되었다. 자연스럽게 미드 티어(mid-tier)에서 전략 컨설팅 영역으로 올라오던 경쟁자들을 만나게 되었고 그들은 PwC, E&Y, Deloitte, KPMG와 같은 대형 회계법인들이었다.[8] 이런 대형 회계법인들은 최근에는 맥킨지 같은 전략 컨설팅 기업들보다 더 많은 컨설팅을 하고 있다. 기술이나 시스템 통합 컨설팅들도 많아서 사람들이 더 많이 필요했고 이는 사세 확장으로 이어졌다. 그렇다고 전략 컨설팅 기업들이 위축된 것은 아니었다. 그들도 영역 확장에 따라 꾸준히 두 자릿수 성장률을 이어 나갔다. 한편, IT 영역에 있던 Accenture나 IBM[9]은 사업 포트폴리오를 확장하면서 오히려 기술에서 경영 쪽으로 컨설팅 영역을 옮겨간 경우이다. IT 영역을 필두로 제품이나 서비스 공급업체들이 컨설팅 기업을 대신하여 컨설팅 업무를 직접 수행하는 경우가 많아졌다. 심지어 Accenture는 컨설팅에서 출발하여 IT 시스템 구축 및 아웃소싱까지 서비스를 확대하여 현재 IT 서비스 기업의 포트폴리오를 가지고 있으며, 장비 회사로 출발한 IBM은 IBM GBS 운영을 통해 서비스 부문의 매출을 전체 매출의 50% 수준에 이르게 하였다. 복잡한 기계의 설치나 조작, 노하우가 필요한 경우, 공급업체가 컨설팅을 직접 수행하는 것은 B2B 설루션 사업이나 B2B 영업 측면에서 일종의 교착 효과(Lock-in Effect)[10]를 유발하면서 고객 관계를 지속시키고 강화하는 효과를 가져왔다. 마지막 세 번째 특징으로 컨설팅 산업은 지식 산업이다 보니 새로운 지식 개발을 통해 사고 리더십(Thought Leadership) 확보에 많은 투자를 한다. 많은 컨설팅 회사들이 이를 위해 화이트 페이퍼(white paper)와 같은 보고서, 저서 출간, 콘퍼런스(conference)에 큰 투자를 하고 있다. 맥킨지의 경우, 독자적 데이터 확보 및 지식 개발을 위해 연간 약 4,500억 원을 투자한다고 한다. 이와 같이 컨설팅 기업들의 오퍼링(Offering) 변화는 기존의 컨설팅 기업뿐만 아니라 제조업체와 기존 서비스 업체의 비즈니스 모델 또한 바꿔놓고 있다. 3.2 국내 컨설팅 기업 현황 국내 컨설팅 시장은 대기업을 중심으로 움직이고 있다. 삼성전자나 LG전자와 같은 일부 대기업들의 경우 기업의 규모나 프로세스의 복잡성 측면에서 이미 글로벌 기업의 반열에 올랐다고 할 수 있다. Top 3 전략 컨설팅 기업들은 당연히 이런 고객들을 핵심 타깃으로 하고 있는 반면, 금융 기관이나 중견 기업군은 Big 4 회계 법인과 라이선싱 된 국내 회계법인들이 컨설팅을 많이 수행하고 있으며, 그 내용은 금융 규제(regulation)나 컴플라이언스(compliance) 관련 컨설팅이 대부분이다. 국내 IT 컨설팅의 경우는 좀 특이한데 대기업 그룹의 경우, 계열사 중 IT 서비스를 담당하는 삼성SDS나 LG CNS와 같은 회사들이 있어서 각 그룹 계열사의 IT 컨설팅 대부분을 수행한다. LG의 경우, LG CNS의 컨설팅 부문인 엔트루 컨설팅(Entrue consulting)[11]이 그 역할을 맡고 있으며, 삼성의 경우, ‘오픈타이드(Opentide)’라는 삼성SDS 컨설팅 자회사가 있었으나, 사업 포트폴리오를 조정하면서 역시 삼성SDS의 자회사인 IT 엔지니어링 기업 미라콤 아이앤씨에 2015년 합병되었다. 민간 부문이 아닌 공공 부문 IT 컨설팅의 경우, 2008년까지만 해도 대기업 컨설팅 회사들이 BPR/ISP를 많이 수주하였으나 공공 IT 사업의 대기업 참여 금지 조항이 본격적으로 적용된 이후부터는 본 구축 사업 참여에 제약이 생기면서 대기업 컨설팅 회사들의 공공 IT 컨설팅 참가는 거의 어렵게 되었다. 그 외 중소 기업군의 경우, 외국계 컨설팅이나 회계법인들과 더불어 네모 파트너스[12] 같은 로컬 기업들도 선전하고 있다. 또한, 한국생산성본부나 한국능률협회[13] 같은 곳도 다양한 컨설팅을 수행 중이다. 그러나 전반적으로 국내 컨설팅 시장은 많이 위축되었다. 이는 전통적인 방식의 컨설팅 오퍼링(offering)이 한계에 달했기 때문인데 앞서 설명했던 것처럼 단순히 방향이나 과제를 제시하고 끝나는 것이 아니라 과제 중 일부를 컨설팅 기업이 직접 수행하면서 그 성과를 입증해야 하는 사례가 많아짐으로써 단순히 보고서를 내는 것으로 그치는 것이 아니라 제품이나 서비스를 연계하는 컨설팅을 많이 요구하고 있기 때문이다. 이런 이유로 IT 설루션 기업들은 컨설턴트들이 설루션 구축에 직접 참여하기도 하고, 어떤 컨설팅 기업들은 컨설팅 결과를 인증(certification) 체계와 연계하였다. 특히, 제조나 유통 기업들의 특정 업무 프로세스들의 경우 제품이나 서비스 경쟁력을 강화하기 위하여 글로벌 표준의 도입 요구가 많이 제기되고 있기 때문에 이를 컨설팅하고 준수할 경우, 인증을 수여하는 것을 사업 모델로 삼고 있는 컨설팅 기업들도 많이 생겨나고 있다. 이는 과거에 인건비 위주로 구성되어 있던 컨설팅 사업의 원가 모델에 변화가 발생하고 있는 것이라 할 수 있다. 오늘날 고객들을 만족시키기 위한 다양한 신규 오퍼링을 개발해야 하는 것은 컨설팅 기업들의 생존과 직결되고 있다. 또, 컨설팅 역량을 적극 활용해서 고객을 리딩 해야 하는 B2B 기업 입장에서도 컨설팅 기업 또는 컨설팅 역량은 놓칠 수 없는 카드이다. 이와 같은 이유로 많은 B2B 기업들이 영업 방식에 있어 컨설팅을 활용하고자 하는 시도가 증가하는 것은 당연하다. 3.3 컨설팅, High-level Sales 컨설팅 사업은 B2B 사업이고 수주 사업이기에 입찰(bidding)을 해야 한다. 따라서 컨설팅 기업의 시니어(senior) 컨설턴트들은 사업 수주를 위해 B2B 영업대표와 같은 역할을 하게 된다. 물론, B2B 기업의 영업대표(Sales Rep.)와 그 역할이 100% 같지는 않지만 최근 B2B 영업의 변화상을 생각해 보면 어느 정도 교집합이 발생하고 있다. 전통적으로는 컨설팅 영업은 입찰 없이 수의계약하는 것을 최고의 영업 활동으로 인정받았다. 그것도 그럴 것이 기업 경영에 대한 조언을 하는 입장이니 컨설팅이라는 일은 시장이나 학계에서 명성이 있는 전문가 집단을 초빙한다는 성격을 가지는 것이 일반적인 생각이었다. 실제로 2000년대 초반까지만 해도 외국계 전략 컨설팅 기업의 조언은 매우 영향력이 있어서 이야기를 듣고자 초빙하면 몇 장 안되는 파워포인트 자료만으로도 수 십억 원의 프로젝트를 쉽게 계약하던 시절도 있었다. 그러나 컨설팅이 보편화되고 수주 경쟁이 치열해지면서 클라이언트들은 더 이상 초빙의<NAME>을 가지기보다는 복수개의 컨설팅 업체를 놓고 선택하고 싶어 하게 되었다. 특히, 국내에서는 2000년대 초반 외국계 컨설팅 기업인 A사가 고객 기업의 핵심 비밀인 내용을 우수 사례 발굴 및 공유라는 명목으로 고객 기업의 경쟁사에서 베스트 프랙티스(Best Practice)[14]로 데이터와 자료를 활용한 일이 발생하면서 상도덕 등 윤리 문제가 제기되었고, 대기업을 중심으로 내부적으로 컨설팅 그룹을 육성하거나 컨설팅 역량을 확보하고자 하는 노력이 더욱 강화되었다. 오래전 기억이지만 저자 기억에 그 사건 이후로 컨설팅 사업은 기업 내 다양한 구 매건 중의 하나가 되었다. 요즘은 외국계이든 국내 컨설팅 기업이든 나름의 경쟁력을 가지고 ‘할 수 있는 사업’을 놓고 입찰에 응하고 있다. 더 이상 A4 용지 5장으로 사업을 수주하기는 어려운 세상이 되었다. 공공 IT 컨설팅의 경우, 제안요청서(Request For Proposal: RFP)에 부합하는 A4 용지 수십~ 수 백 장의 제안서와 팀 프로파일을 제출하고 적합한 가격 제안까지 통과되어야 사업을 수주할 수 있다. 그러나 여전히 민간 기업의 전략이나 운영 컨설팅은 동문(alumni) 네트워크를 활용하는 글로벌 Top 3 전략 컨설팅의 영향력이 강하고, 입찰을 해도 그 영향력이 충분히 발휘가 되는 것 같다. 크게 보면 결국 어떤 영업을 했느냐에 따라 사업 수주가 쉬우냐 어려우냐가 결정된다. 실제로 많은 컨설턴트 지망생들이 MBA에서 컨설팅 역량에 도움이 되는 많은 것들을 배우기도 하지만 이런 영업 활동에 필요한 인맥을 만들 수 있기 때문에 소위 말하는 ‘더 좋은 학교의 MBA’를 선호하게 된다. 그 인맥들이 기업이나 정부의 고위직으로 진출할 확률이 높기 때문이고, 그런 인맥들을 활용해서 영업 활동을 조금 더 쉽게 할 수 있을 것이라고 생각하기 때문이다. 그러나 민주공화국에서 시간이 갈수록 많은 것들이 투명하게 진행되고 있고 향후 거의 모든 사업들은 입찰이 필요할 것이다. 그때는 지식과 경험, 전문성으로 무장한 컨설팅 역량이 정말 가장 중요하다. Break #3. 컨설턴트형 영업(Consultative Sales) J 차장은 글로벌 IT기업인 I사의 유능한 영업맨이다. 기업 고객들에게 컴퓨터 장비를 납품하는 그는 적극적이며 밝은 성격으로 인상도 매우 좋으며, 타고난 친화력으로 처음 만나는 상대와도 쉽게 친해진다. 특별히 능력이 뛰어난 것은 아니지만 매우 활동적이어서 업무와 직접적인 관계가 없는 고객의 어려움도 잘 해결해 주고, 고객이 어려울 때 술 한잔 접대도 하는 등 인간적으로 고객을 대하기 때문에 영업대표로서 장점이 많은 사람이다. 회사의 제품과 서비스에 대해서도 잘 알고 있어 훌륭한 화술과 언변으로 자기가 판매하는 제품의 장점을 잘 설명할 수 있다. 또한, 자기가 판매하는 제품과 서비스의 주변 지식도 잘 알고 있어 다양한 화제로부터 셀링 포인트를 찾아내기도 한다. 즉, J 차장은 영업에 자신이 있었다. 그런데 최근 본사는 글로벌 사업 전략 차원에서 영업 전략을 수정했고 관계자로부터 자기의 영업 방식이 낡았으며 합리적이지 못하다는 피드백을 받게 되었다. 고객들도 J 차장의 여러 가지 호의에 감사하지만 무언가 아쉬운 점이 있다는 것을 슬쩍 비추기도 한다. 무엇이 잘못되고 있는 것일까? 포레스트 리서치[15]는 향후 도래할 사업 환경에서 B2B 영업의 유형을 다음과 같이 소개하였다[16]. 제품이나 서비스의 복잡도와 구매의 복잡성을 기준으로 영업 유형을 4가지 유형으로 구분하고 정의하였는데, 단순히 고객의 요청에 대응하는 ‘Order Takers’형이나 제품을 시연하고 설명하는 ‘Explainers’형보다는 불확실한 상황 속에서 고객을 가이드 할 수 있는 ‘Navigators’형이나 고객에게 많은 아이디어를 제공하고 같이 고민할 수 있는 ‘Consultants’형이 필요하다고 주장하였다. 또한, 2012년 대비 2020년까지 Consultants형을 제외한 모든 유형의 영업직들은 줄어들 것으로 예측하고 있다. 최근 소위 글로벌 기업, 특히 B2B 사업에 주력하는 기업들의 영업 대표의 이미지는 정말 변화하고 있다. 비용 효율적인 것을 넘어서서 고객을 리딩(Leading) 해야 하며 그 과정에서 고객의 이슈나 문제에 대해 좀 더 개입해야 하는 상황이 전개된다. 컨설턴트형 영업이 되라고 요구하는 것은 그런 부분에서 시작된다. 컨설턴트형 영업(Consultative Sales)이란, 고객의 니즈를 청취하며 고객의 이슈와 문제를 주도적으로 해결하고 그 과정에서 기업의 제품과 서비스 판매를 그 결과로 얻는 영업 방식이라고 설명할 수 있다. 여기에는 기존의 영업 방식에 논리적 접근과 과학적 방식이 결합되어야 한다. 관계 중심형(Humane) 영업과 컨설턴트형 영업의 특징을 비교해 보면 Table I-5와 같다. Table I-5. 컨설턴트형 영업과 관계 중심 영업의 비교 컨설턴트형 영업의 사업 개발 방식은 사업기회 발굴 시, ‘문제 해결기법’을 활용한다는 특징이 있다. Fig I-16은 컨설턴트형 영업방식의 전형적인 프로세스이다. Fig. I-16 컨설턴트형 영업의 사업 방식 문제 해결 방식을 도입함과 더불어 기존 관계 중심형 영업과의 차이점은 오퍼링(Offering) 전달 시 자기가 보유한 것 외에 시장의 모든 것을 검토하여 문제 해결에 최적화된 설루션을 제시한다는 점이다(Best-in Class). 즉, 자사의 제품이나 서비스 외 고객의 문제 해결을 위한 타사의 제품과 서비스, 상품도 모두 엮어서 고객의 문제 해결을 위한 설루션으로 제시한다. 또한, 계약 후 사후 관리 차원에서 잠재적으로 발생 가능한 위험 요소를<NAME>여 고객과 함께 대안을 찾고 추가 사업 기회를 발굴하는 단계를 거치기도 한다. 최근 컨설턴트형 영업의 역할이 부상하게 된 가장 큰 요인은 설루션 사업의 확대와 관계가 깊다. 특히, Value Sales 방식으로 영업을 하는 산업은 이런 변화를 피해 갈 수 없다. 물론, 지금까지 관계 중심형 영업에 집중해온 사람도 본인에게 부족한 부분을 컨설턴트나 기술 전문가의 도움을 받아 대응할 수는 있다. 그러나 그 순간부터 비용 효율적인 사업개발과는 멀어지게 된다. B2B 영업대표들은 당장 미흡하고 부족하게 시작할 수밖에 없지만 이런 스킬(Skill)들을 익히는 노력이 필요하고, 이를 통해 기존의 관계 중심형 영업들처럼 관계를 이용해서 일회적으로 제품을 팔고 끝나는 것이 아니라 고객의 이슈와 문제를 충분히 다룰 수 있고 이를 해결해 준다는 사고 리더십(Thoughts leadership)을 발휘할 수 있는 고객 관계를 만들어야 한다. 결국 그런 역량을 기반으로 한 고객 대응에서 건강한 사업 성과와 고객 관계가 태동되며, 고객은 B2B 영업대표를 업무적으로 신뢰할 수 있게 된다. 더 이상 형님만 찾는 세상이 아님은 분명하며 실제로 많은 컨설턴트들이 신사업 개발과 같은 사업 관련 컨설팅을 하면 이후 클라이언트사로 이직하는 경우가 많은데 이는 본인들이 가장 잘 알고 또 컨설턴트형 영업을 제일 잘할 수 있는 사람이라는 생각이 강하기 때문이다. 18세기 산업 혁명에서 기업의 모습이 구체화되고 테일러(Frederick W. Taylor. 1856 ~ 1915)의 과학적 관리법(The principles of Scientific Management) 이후 생산의 비능률성을 제거한다는 목적으로 경영 자문이 시작되면서 지금까지 100여 년 이상 컨설팅은 우리가 알게 모르게 매우 체계적으로 비즈니스의 모양을 갖추면서 발전되었다. Part I을 마무리하면서 급변하는 경영 환경으로 컨설팅 산업의 모습은 지금도 계속 변화해나가고 있으며 과연 다시 부활할 것인가라고 질문해 본다면 저자 생각에는 그럴 것 같다. 그런데 그 방식은 지금과 달라질 수 있다. 예를 들어 인공지능과 로봇의 열풍으로 거의 모든 산업 현장에서 사물인터넷(IoT)를 매우 많이 활용하게 되는 순간이 곧 도래할 것이다. 이런 기반 구조의 변화는 분명히 다양한 프로세스의 변화를 가져올 것이다. 그것은 컨설팅 사업 관점에서 보면 프로세스 개선 또는 프로세스 혁신 즉, PI 컨설팅의 대상이 된다. 블록체인(Block Chain)[17]이 3 ~ 5년 안에 활성화되면서 금융 산업의 인증 체계와 금융 결제의 전반적인 모습이 완전히 변한다. 이 또한 새로운 사업 기회가 되면서 PI 컨설팅의 대상이 된다. 현재 세계 경제는 혁신을 유발하는 기반 기술들이 끊임없이 적용되고 있으며 이런 기술들의 안착을 위해서는 비즈니스 컨설팅이 반드시 필요하다. 그러나 문제는 그런 컨설팅을 수행할 때 과거의 같은 오퍼링, 또는 과거의 같은 구분 또는 기준의 컨설턴트들이 사업과 기술이 융합되어 나타나는 이런 영역의 컨설팅을 제대로 수행해낼 수 있을 것인가? 적정한 사업 대가를 받으면서 이윤을 추구할 수 있을 것인가? 이런 부분은 각 컨설팅 기업들에게 여전히 숙제로 남아 있다. 물론, 모든 컨설팅 기업들이 그 부분에 관심을 가질 필요는 없을 것이다. 그러나 미래에 인공지능과 로봇을 넘어서서 사람의 능력이 반드시 필요한 곳이라면 당연히 마진이 높지 않을까? 자문이나 지식 서비스의 대가를 인정받는 것은 아직도 나라마다 그 수준은 다르지만 컨설팅을 위해 사용되었던 수많은 도구와 기법, 방법론들은 거듭 발달되어 오늘날 기업 경영에서 전략과 마케팅, 혁신 등 다양한 영역에서 널리 활용되고 있다. 아울러 컨설팅도 스펙트럼을 더욱 확장하여 이제는 단일 사업 이상의 의미를 품고 있다. 즉, 컨설팅 사업은 21세기를 맞아 ‘자문’이라는 속성을 간직할 뿐 아니라 타 산업 및 사업에 스며들어 직접 비즈니스를 개발하고 혁신하는 기법으로 발전하고 있는 것이다. Part II에서는 이런 컨설팅의 근간이 되며 컨설턴트라면 누구나 고민하고 훈련받는 기법과 사고 체계들에 대해서 알아보도록 하자. [1] 포츈지 등으로부터 수년간 혁신기업으로 칭송받았고 통신, 가스, 전기, 제지, 플라스틱, 석유화학, 철강 등의 포트폴리오를 가진 에너지 기업 엔론(Enron)의 회계 부정 사건. 엔론의 회계 감리사였던 유명 회계법인 아더앤더슨(Arthur Anderson)은 이 사건으로 인해 파산하게 되었다. [2] 반면에 2016년 11월 엑센츄어 코리아는 한국의 IT 서비스 기업인 메타 넷에 매각되었다. 엑센츄어의 한국 시장 철수는 업계에 충격을 주었고 한국 컨설팅 시장의 침체와 관계가 깊기도 하고 대기업 중심의 IT 서비스 시장 구성과 대기업 중심의 IT 컨설팅 사업 전개에 따른 한국 시장의 독특한 특징으로 외국계 컨설팅 기업이 한국 시장에서 성장 한계에 봉착한 것으로 보는 시각도 많다. [3] IT 아웃소싱 기업 EDS는 전략 컨설팅 기업인 AT.Kearney를 인수했으나 조직문화 차이로 큰 시너지를 보이지 못하고 ATK는 다시 지분을 사서 EDS로부터 독립하였다. EDS는 2009년 사세가 기울어 HP에 합병되었다. [4] http://www.economist.com/news/business/21577376-world-grows-more-confusing-demand-clever-consultants-booming-brainy [5] http://www.mckinsey.com/ [6] http://www.bain.com/ [7] http://www.bcg.com/ [8] www.pwc.com; www.ey.com; www.deloitte.com; www.kpmg.com [9] www.accenture.com; www.ibm.com [10] 기존의 제품보다 더 뛰어난 것이 나와도 이미 투자된 비용이나 기회비용 및 전환 비용, 혹은 복잡함이나 귀찮음으로 인해 타제품으로 쉽게 옮겨가지 못하는 것 [11] www.entrue.com [12] www.nemopartners.com [13] www.kpc.or.kr; www.kma.or.kr [14] 기업 내 특정 업무 프로세스의 성과가 세계 최고의 수준일 경우, 이를 타 산업 또는 타 분야로 확산하여 동일하거나 유사한 성과를 얻고자 하는 방법 [15] www.forrester.com [16] ‘Death of A B2B Salesman’, Forrester Research [17] 가상화폐인 비트코인 거래내역을 기록한 공개 장부. 결제 및 거래 패턴을 바꾸면서 금융 산업을 중심으로 매우 큰 파급 효과가 예상되는 영역이다. 030 PART II. 컨설팅 스킬 컨설팅 스킬(Consulting Skills)은 컨설턴트로서 갖추어야 할 기본적인 역량이다. 컨설팅 지식이라고 부르지 않고 컨설팅 스킬이라고 부르는 것은 머리로만 기억하는 것이 아니라 몸으로 익혀야 하는 것들이기 때문이다[1]. 어떤 사람들은 이런 것들을 상대적으로 더 잘할 수 있는 유전적 자질을 가지고 태어나는 경우도 분명히 있다. 그러나 단언하건대 저자는 이것들은 지식(Knowledge)이 아니라 사용하지 않으면 잊어버리게 되는 스킬(Skills)이기에 배우고 익혀서 체화(體化) 하지 않으면 곧 모두 잊어버릴 수 있다고 강조한다. 즉, 아는 것(Knowing)보다 사용하는 것(Doing)이 더 중요하다. Fig II-1. 컨설팅 스킬의 구분 컨설팅 스킬은 Figure II-1과 같이 크게 사고 스킬(Thinking Skills)과 커뮤니케이션 스킬(Communication Skills)로 구분할 수 있다. 컨설턴트의 논리적 사고 체계를 구성하는 데 도움을 주는 사고 스킬은 비즈니스 정보를 수집하고 해석할 때 정확한 판단을 할 수 있게 도와주며, 로직 트리(Logic Tree) 작성이나 문제 해결(Problem Solving) 기법의 원동력이 된다. 또한, 최근 새로운 문제 해결 기법으로 부각되고 있는 디자인 싱킹(Design Thinking)에 대해서도 알아볼 것이다. 커뮤니케이션 스킬은 클라이언트가 제공하는 정보를 듣고 정리하며 그 결과를 문서화하고 발표하는 것이다. Part II에서는 컨설팅 스킬에는 어떤 것들이 있는지, 또 어떻게 배우고 익힐 수 있는지 알아보자 [1] 지식경영(Knowledge Management)의 관점에서 우리말 지식은 영어로 ‘Knowledge’와 ‘Skills’로 구분되는데 ‘Knowledge’는 책이나 교육을 통해 머릿속에서 기억되는 것, ‘Skills’는 몸으로 움직이고 실습하여 체득하는 것으로 구분된다. 예를 들어 자동차 운전이나 스키 타는 법 등은 ‘Knowledge’가 아니라 ‘Skills’이다. 04. 논리적 사고 컨설팅 스킬(Consulting Skills)은 컨설턴트로서 갖추어야 할 기본적인 역량이다. 컨설팅 지식이라고 부르지 않고 컨설팅 스킬이라고 부르는 것은 머리로만 기억하는 것이 아니라 몸으로 익혀야 하는 것들이기 때문이다[1]. 어떤 사람들은 이런 것들을 상대적으로 더 잘할 수 있는 유전적 자질을 가지고 태어나는 경우도 분명히 있다. 그러나 단언하건대 저자는 이것들은 지식(Knowledge)이 아니라 사용하지 않으면 잊어버리게 되는 스킬(Skills)이기에 배우고 익혀서 체화(體化) 하지 않으면 곧 모두 잊어버릴 수 있다고 강조한다. 즉, 아는 것(Knowing)보다 사용하는 것(Doing)이 더 중요하다. Fig II-1. 컨설팅 스킬의 구분 컨설팅 스킬은 Figure II-1과 같이 크게 사고 스킬(Thinking Skills)과 커뮤니케이션 스킬(Communication Skills)로 구분할 수 있다. 컨설턴트의 논리적 사고 체계를 구성하는 데 도움을 주는 사고 스킬은 비즈니스 정보를 수집하고 해석할 때 정확한 판단을 할 수 있게 도와주며, 로직 트리(Logic Tree) 작성이나 문제 해결(Problem Solving) 기법의 원동력이 된다. 또한, 최근 새로운 문제 해결 기법으로 부각되고 있는 디자인 싱킹(Design Thinking)에 대해서도 알아볼 것이다. 커뮤니케이션 스킬은 클라이언트가 제공하는 정보를 듣고 정리하며 그 결과를 문서화하고 발표하는 것이다. Part II에서는 컨설팅 스킬에는 어떤 것들이 있는지, 또 어떻게 배우고 익힐 수 있는지 알아보자 [1] 지식경영(Knowledge Management)의 관점에서 우리말 지식은 영어로 ‘Knowledge’와 ‘Skills’로 구분되는데 ‘Knowledge’는 책이나 교육을 통해 머릿속에서 기억되는 것, ‘Skills’는 몸으로 움직이고 실습하여 체득하는 것으로 구분된다. 예를 들어 자동차 운전이나 스키 타는 법 등은 ‘Knowledge’가 아니라 ‘Skills’이다. 논리적 사고의 두 번째 시간으로 본격적으로 로직 트리(Logic Tree)에 대해 알아보자. 4.2 수평적 구조의 전개 - 연역적 vs. 귀납적 논리 피라미드에서 하위 소그룹들은 서로 수평적 구조를 가지면서 그 논리 구조는 연역적 혹은 귀납적 구조를 가진다고 하였다. 연역적(Deductive) 구조라는 것은 의심할 수 없는 명확한 것으로부터 이성(性)에 의해 이끌리는 것을 말한다. 즉, 논리적 구조의 선행 요소가 후행 요소의 원인이 되어 결과를 보여주는<NAME>이다. 귀납적(Inductive) 구조는 많은 사실 사이의 공통적인 본질을 구하는 방법으로 결론을<NAME>기까지 수집된 많은 자료들이 거의 MECE[1]에 가깝다. Fig II-6. 논리 피라미드의 수평적 구조 예를 들어 설명해 보면 Figure II-7은 수평적 구조 중에서 연역적 전개의 사례이다.[2] Figure II-7. 수평적 구조의 연역적 전개 사례 MECE 전개는 아니지만 (1), (2)‚, (3)ƒ은 내가 새이기 때문에 날 수 있는 논거(arguments)들을 제시하여 자연스럽게 핵심 주장인 결론 즉, (4)에 도달하게 한다. (1)이 전제나 규칙(Rule)을 제시하고 (2)‚가 그것의 사례(Case)가 되며, (3)이 규칙의 사례에 대한 결과(Result)가 된다. 그래서 주장인 (4)를 이끌어 내는 흐름이다. 따라서 연역적 구조를 갖게 될 경우에는 (1) ~ (4)에 해당하는 내용의 진실성을 우선적으로 파악하는 것이 필요하다. Figure II-8. 수평적 구조의 귀납적 전개 사례 한편, Figure II-8은 귀납적(Inductive) 전개의 사례를 보여준다. MECE 전개를 기본으로 원인 (1), (2)‚, (3)으로 보아 결과가 (4)라는 것을 추론할 수 있다. 즉, 김 씨의 첫째 아이, 둘째 아이, 셋째 아이가 모두 아들이므로 김 씨는 아들밖에 없다는 귀결을 낳게 된다. (물론, 이 경우는 김 씨의 자식은 3명뿐이라는 전제가 있어야 한다.) Figure II-9. 수평적 구조를 통한 추론 또한, 논리 피라미드의 수평적 구조에서 연역적 전개가 논거를 나열하면서 결론을 유도할 수 있다면, 귀납적 구조는 근거들로부터 결론을 추론하거나 원인과 이유(Causes and Effects)를 설명하는 데 사용할 수 있다. 그런데, 연역적 전개와 귀납적 전개의 사용에 있어도 가지 논리 구조가 전달하는 효과가 다르기 때문에 어떤 상황에서 이렇게 전개하는지 결정해야 하는 때도 있다. Figure II-10은 어떤 이유로 김포의 물류창고를 구입해야 하는 경우가 생겼는데 연역적 전개와 귀납적 전개를 통해 각각 결론을 도출하였다. 연역적 전개는 비즈니스의 문제 해결에서 가장 일반적으로 사용되는 방법으로 만약, 고객이 우리가 얻은 결과와 그 과정 모두에 관심이 많다면 이는 적절한 방법이 된다. 그러나 논거를 전개해 나가는 과정에서 어느 부분이든지 고객이 동의하지 않고 변경을 요구한다면 다음 과정 및 그 결과는 쓸모없게 되어버린다. 반면에 귀납적 전개는 결론을 지지하는 데 사용된 논거들이 각각 독립적으로 의미가 부여되기 때문에 어느 하나가 고객에게 지지 받지 못한다 할지라도 전체적인 결론에 영향을 끼치는 일은 없다. 따라서 어떤 방식의 수평적 구조를 사용하느냐는 논리를 갖추는 것 외 비즈니스 의사 결정에서 완전히 다른 결론을 가져올 수 있다. Figure II-10. 수평적 구조를 활용한 추론 사례 컨설팅을 하면서 고객과 많은 커뮤니케이션을 하게 된다. 다양한 사실들을 확인하게 되며 필요에 의해 이것들을 요약해야 할 필요도 생긴다. '이런 상황을 타개하기 위한 방법이나 방안은 없을까?’라고 자문하는 컨설턴트가 있다면 이 논리 피라미드(Figure II-11)를 사용하면 된다. Figure II-11. 논리 피라미드 종합 바바라 민토는 SCQA 프레임워크(Figure II-12)을 소개하였다. SCQA 프레임워크는 논리 피라미드를 만들기 전의 상황과 전개, 질문을 정리하여 논리적 흐름을 명확하게 하는데 사용되는 것으로 Table II-11과 같이 상황(Situation)과 전개(Complication), 질문(Question)으로 시작한다. 상황은 주제에 대한 확인된 사실로 논리 피라미드 전개의 시작점(Starting Point)이라고 할 수 있고, 전개는 상황에서 확인된 사실에 대해 일차적으로 제시된 사항들이며, 질문은 그 사실에 대한 진실성을 확인하는 것이다. 민토 피라미드(Minto Pyramid)는 질문에 대한 답(Answer)이 되면서 새로운 시작점이 된다. Break #4. SCQA 프레임워크와 논리 피라미드 Figure II-12. SCQA 종합 사실 논리 피라미드를 최상위 아이디어는 어떤 질문에 대한 답이다. 이미 어떤 상황이 전개되고 있고 그것을 인식하였고 그래서 어떻게 하면 좋을까에 대한 답이며 하위 소그룹들도 지속적으로 질문과 응답의<NAME>을 갖추면서 반복되는 것이 논리 피라미드 즉, 민토 피라미드이다. 바바라 민토(Barbara Minto)는 그녀의 저서에서 이것을 SCQA 프레임워크이라 소개하였다. SCQA는 Situation, Complication, Question, Answer의 약자인데 논리 피라미드를 전개하기 위한 도입부(Narrative or Lead-in)를 반드시 Table II-1과 같은 스토리로 정리해 볼 것을 권고하였다. Table II-1. SCQA 프레임워크의 구성 4.3 로직 트리(Logic Tree) 만들기 논리 피라미드의 기본 개념에 대해 이해했다면 이제 로직 트리(Logic Tree)를 구성해 보자. 로직 트리는 논리 피라미드와 같은 것이며 세분화의 깊이가 길어져서 보기 편하게 시계 반대 방향으로 90도 회전한 것이라 생각하면 된다. Figure II-13과 같이 로직 트리를 만들 때에는 우선 연역적으로 시작할 것인가 귀납적으로 시작할 것인가를 먼저 결정한 후 그에 따라 작업을 진행하면 된다. Figure II-13. 로직 트리 작성의 흐름 연역적 로직 트리(deductive logic tree)의 작성은 분석의 범위와 방향이 명확하거나 로직 트리 작성의 경험이 풍부한 경우 많이 활용하며 그 작성 절차는 다음과 같다. 1) 초기 질문을 작성한다. 초기 질문은 분석 대상과 범위를 명확하게 하기 위해 기술하는 것으로 주어와 술어의 형태를 취한다. (예) A 공장 가공 라인의 핵심 부품 불량률이 높은 이유는 무엇인가? 2) MECE의 원칙에 따라 트리(Tree)를 전개한다. 일반적으로 3차에 걸쳐 세분화 및 그룹핑하며 그 이하로 내려갈 경우는 MECE를 반드시 고려하지는 않는다. Figure II-14는 연역적 로직 트리의 구성을 개념적으로 표현한 것이다. 연역적 로직 트리를 검증하기 위해서는 최종 분류된 것들이 주제와 관련된 문제 전체를 포함하는가? Sub 내용들 간에 중복이 되지 않는가? 등 MECE의 원칙이 충분히 적용되었는가를 살펴본다. Figure II-14. 연역적 로직 트리의 구성 한편, 귀납적 로직 트리(Inductive logic tree)의 경우, 분석의 범위나 방향이 불명확하거나 로직 트리 작성의 경험이 부족한 경우 많이 활용한다. 데이터나 논거들을 열거하고 이를 그룹핑, 위계화하여 주제를 분석하게 된다. 귀납적 로직 트리의 경우, 각 수준 간에 ‘So What’ 또는 ‘Why So’와 같은 의미 전달이 가능하다. ‘So What’의 경우, 현재 가지고 있는 데이터 전체 또는 그룹핑된 데이터에 의하여 어떤 추론이 가능한가를 검증하는 것이다. ‘So What’을 따라가는 귀납적 로직 트리는 ‘따라서 어떤 것이 된다’라는 의미를 전달한다. 반면에 ‘Why So’를 전달하는 로직 트리는 어떤 개념의 타당성이 현재 가지고 있는 데이터 전체 또는 그룹핑된 데이터에 의해 증명된다는 것을 검증하는 것이다. ‘WhySo’를 따라가는 귀납적 로직 트리는 ‘왜 그렇게 된다’라는 의미를 전달한다. Figure II-15는 ‘So What’과 ‘Why So’의 사례를 보여주는 귀납적 로직 트리이다. Figure II-15. 귀납적 로직 트리 구성의 사례 이렇게 작성된 로직 트리는 검증을 해야 하며, 검증된 로직 트리는 ‘전략적 판단’이 가능하다. Figure II-16과 같이 과일 통조림을 만드는 기업의 예를 들면 상품<NAME>료인 과일을 의미 없이 구분하고 로직 트리를 구성하면 Figure II-16의 왼쪽과 같이 구성될 것이다. 그러나 전략적 의미를 부여하면 Figure II-16의 오른쪽과 같이 구성할 수 있다. 즉, 사람들이 껍질째 먹기에 불편한 과일을 가격이 높은 계절에 통조림으로 만들어 판매할 수 있다는 전략적 판단이 도출될 수 있다. Figure II-16. 로직 트리의 전략적 판단 또한, 다양한 관점에서 로직 트리의 검증이 필요하다. 어떤 문제에 대해 원인을 모색하는 경우 왜 그것이 원인인지 끊임없이 반복해서 ‘Why?’라고 물어보아야 하고, 해결책을 구체화하는 경우 ‘SoWhat’, ‘So How’와 같이 사고 실험을 지속적으로 해야 한다. Figure II-17. 로직 트리의 검증 로직 트리는 정말 많은 연습이 필요하다. 모두에서 말했듯이 컨설팅 스킬은 말 그대로 Knowledge가 아니라 Skills이다. 어떤 주제도 좋다. 의문에 대해 처음 2개의 가지, 그다음도 2~3개의 가지, 그다음은 가지 하나하나에 대한 사유나 근거. 끊임없이 연습하는 것이 좋다. 주제가 생각나지 않는가? 그럼 다음 질문들에 대해 로직 트리를 한번 그려보라. 저자가 강의할 때 아래 질문들은 신입 사원들에게 폭발적인 지지를 받았다. 물론, 정답은 없다. 그(그녀)의 로직일 뿐이다. 그(그녀)를 왜 만나야 하는가? 그녀(그)와 꼭 결혼해야 하는가? 나는 어디에 집을 마련할 것인가? 이 회사를 왜 다녀야 할 것인가? [1] Mutually Exclusive Collectively Exhaustive 상호 배제와 전체 포괄. 중복되지 않게 나누지만 하나도 빠짐없이. [2] 바바라 민토의 저서에서 예를 인용하였다. 05. 문제 해결 기법 로직 트리에 대해 좀 익숙해졌는가? 그렇다면 이제 본격적으로 문제 해결의 세계로 들어가 보자. 논리적 사고 및 문제 해결 기법과 관련해서 가장 많이 알려진 것은 맥킨지 컨설팅의 ‘문제 해결 7 단계 프로세스’이다. 논리적 사고에 입각한 이 문제 해결 프로세스는 모든 컨설팅 기법의 근간을 이루고 있다고 해도 무방하며 많은 글로벌 기업들이 이를 차용하여 해당 기업에 맞게 수정, 보완하여 사용하고 있다. Figure II-18은 문제 해결 7단계를 도식화한 것인데, 문제를 정의하고 그것을 구조적으로 세분화한 후, 해결 우선순위를 결정한다. 선정된 문제들의 조사 계획을 수립하고 관련 정보를 수집, 분석하여 결과를 종합하고 시사점을 토대로 해결안을 개발하는 순서이다. 이런 일련의 업무 진행 과정에서 고객 및 협업 관련자들 간의 커뮤니케이션은 지속적으로 발생하며 강조된다. 제5장에서는 문제 해결 기법에 대해 자세히 더 알아보자. Figure II-18. Mckinsey Problem Solving 7 steps 5.1 문제의 정의 및 세분화 문제의 정의 단계는 이슈나 문제를 정확하게 규명해야 하는 단계로 문제 해결의 시작점이다. 문제 해결의 환경은 대체로 매우 열악하다. 저자의 경험을 회상해 보면, 문제 해결을 위한 정보는 부족하고, 고객은 문제가 해결될 것이라는 높은 기대치를 가지고 있으며, 문제 해결을 맡은 자신이나 같이 투입된 컨설턴트들은 지식과 경험이 부족하다. 새로운 환경에서 무얼 어떻게 시작해야 할지 잘 모르며, 주어진 과제도 구체적이지 않아 도대체 무얼 원하는 것인지도 명확하지 않다. 그렇다고 주어진 시간이 여유가 있는 것도 아니다. 게다가 구성원들의 이해관계도 첨예하고 사내 정치도 걸려 있어서 이게 어떻게 풀리느냐에 따라 고객사의 어느 라인은 모두 망하게 될 수도 있다. 저자가 겪어본 대부분의 문제 해결의 환경은 이랬다. 대부분의 컨설턴트들 또는 전략기획가들도 비슷한 환경에 직면해 본 적이 있으리라 생각된다. 그러나 이 모든 것을 극복하고 문제를 해결하는 사람들이 컨설턴트들 아니던가? 어디에서 무엇부터 시작할까? 우선적으로 해야 할 것은 이슈나 문제를 정의하는 일이다. 그렇다면 문제란 무엇일까? 문제란 쉽게 말해서 목표와 현상의 차이로 발생하는 것이다. Figure II-19. 문제의 발생 원인 목표는 ‘어떻게 되면 좋겠다(Should be)’라는 이상적인 모습으로 존재하고 있고, 실제 현실은 그 목표를 달성하지 못하는 경우가 대부분이다. 이 두 가지 상태의 사이에 인식의 차이(Gap)가 존재하는데 문제(Problem)라는 것은 그때 발생하는 것이며, 그 차이를 없애주는 것이 '문제 해결(Problem Solving)'이라고 할 수 있다. 그렇다면 문제가 생기지 않게 하는 방법은 없을까? 있다. 목표를 낮게 설정하고 현상과 틀어지지 않게 맞추면 문제가 생길 이유가 전혀 없는 것이다. 그러나 이 말은 난센스(Non-Sense)이다. 기업이든 정부이든 현재보다 발전적인 모습이 되고 성장하기를 원하기 때문에 어떤 기업도 그런 방식으로 목표를 설정하지는 않는다. 그렇기 때문에 어떻게 보면 문제의 발생은 필연적이라고도 말할 수 있겠다. 이런 문제들은 여러 가지 관점에서 분류될 수 있지만 목표와 현상을 놓고 생각해 보면 크게 ‘발생형 문제’와 ‘설정형 문제’로 구분할 수 있다. 발생형 문제는 현재를 기준으로 주로 과거의 어떤 이유로 발생되어 현재까지 지속되고 있는 것들이다. 무엇이 미달된다던가 이탈되었다던가 하는 것들이다(Cause-oriented thinking). 반면, 설정형 문제는 미래의 어떤 목표를 설정하고 이를 성취하기 위해 정의되는 문제들이다. ‘무엇을 성취해야 한다’던지 ‘어떤 것을 개발해야 한다’던지 하는 것들이다. 문제를 정의하기 위해 여러 가지 것들을 생각해 볼 필요가 있는데 Table II-2와 같은 문제 정의 서 템플릿을 사용하면 체계적으로 정리할 수 있다. Table II-2. 문제 해결 정의서 Template 첫 번째 할 일은 해결할 문제를 질문<NAME>으로 써보는 것이다(Basic Question to be resolved). 해결해야 할 기본 질문은 향후 분석 작업에 초점을 맞추어 작성해야 하며, 간결하고 실행에 옮기기 용이해야 한다. 문제 정의는 상세할수록 좋지만 문제의 범위가 협소해져서 잘못된 문제를 다루게 되는 일은 없어야 한다. 두 번째는 프로젝트와 관련된 상황을 기술해 보는 것이다(Perspective/Context).문제를 둘러싸고 있는 다양한 환경적 요소들에 대해 서술해야 한다. 세 번째는 문제 해결의 성공에 대한 모습, 기준을 명확하게 정하는 일이다(Criteria for success). 성공의 기준에 대한 모습은 프로젝트 스폰서(Project Sponsor)의 생각이 가장 중요하다. 기업에서 의뢰한 컨설팅의 경우, 어떤 목표를 가져갈 것이며 기대 효과와 프로젝트의 성공에 대한 판가름을 명확하게 내야 할 필요가 있다. 네 번째는 문제 해결의 성공적인 이행 여부를 판단하는 사람을 규명하는 것이다(decision maker). 프로젝트 스폰서가 될 수도 있고 그것을 평가하는 별도의 평가자가 존재할 수도 있다. 다섯 번째도 의사결정자를 정하는 것인데 보조적 의사결정자(sub decision maker)라고도 칭한다. 보조적 의사결정자를 결정할 때는 문제 해결자(또는 문제 해결팀)을 지지하는 사람을 선정하는 것도 좋지만 좀 다른 차원의 팁(Tip)으로 오히려 문제 해결 노력을 방해할 가능성이 높은 인물을 선정하는 것이 좋다. 여섯 번째, 문제 해결을 위한 일련의 해결책과 그것을 방해할 수 있는 요인들을 정리해 보는 것이다(constraints with solution space). 이 장애 요인들은 문제 해결이 진행되면서 제거되는 경우도 많다. 마지막 일곱 번째로 문제 해결 작업을 진행하면서 추가되거나 배제되어야 할 사항들을 도출하고 요청사항으로 정리해 본다(scope of solution space). 결론적으로 문제 정의 정의서 템플릿의 (2), (3), (7)은 문제 해결을 위한 충족요건이고 (4, (5), (6)‘은 문제 해결의 걸림돌이 될 수 있다. 문제정의서의 작성을 완료했다면 이것을 기본으로 로직 트리를 그려볼 수 있다. Figure II-20은 문제 정의서가 어떻게 로직 트리로 전환되는지 보여준다. 로직 트리의 각 수준 간에는 관련성(Relevant)이 있어야 하며, 소그룹 간에는 일관성(Consistency)이 있어야 한다. 또한, MECE의 원칙을 준수하여 각 사항들을 잘게 나누어야 한다(segmentation). 즉, 전체를 분석 또는 판단이 용이한 작은 형태로 나누어야 한다(Divide and conquer). 광범위하고 복잡하게 정의된 문제들을 체계화된 관련 문제의 목록으로 작성해야 하는데, 각 질문들은 구체적이며, 완전하고, 지적으로 관리 가능한 수준의 질문들이 되는 것이 필요하다. Figure II-20. 문제 정의서의 로직 트리 변환 2.2 우선순위 선정 및 작업계획 수립 로직 트리를 이용해서 정의된 문제를 세분화하고 나면 그것들 중에서 무엇을 먼저 처리해야 하는지 결정해야 한다. 파레토 법칙(Pareto’s Rule)은 그런 경우 적절한 해답을 줄 수 있다. 이탈리아의 경제학자 빌프레도 파레토 (Vilfredo Pareto. 1848 ~ 1923)는 19세기 영국의 부(富)와 소득의 유형을 연구하다가 부의 불균형 현상이 존재한다는 것을 발견하였는데 영국 인구의 20%가 부의 80%를 차지하고 있다는 사실이었다. 현대 경영에서 파레토 법칙은 ‘전체 성과의 대부분(80%+)이 소수(20%)에 의해 창출된다’라는 의미로 더 많이 사용된다[1]. 문제 해결의 관점에서는 Figure II-21과 같이 분석의 정교화와 그 효과의 관계를 파레토 법칙의 관점에서 고려해야 한다. Figure II-21. 문제 해결에서의 파래도 법칙 적용 한편, 어떤 문제가 보다 더 중요한지 판단하기 위해서는 문제점들을 다차원 관점(Multi-dimensional view)에서 평가해 보아야 한다. Table II-3. 다차원 평가를 통한 문제 해결 우선순위의 선정 Table II-3은 문제점을 중요성, 긴급도, 난이도, 경제성 등으로 평가하고 종합평가하여 순위를 매긴 것으로 ‘생산 완료 일자가 영업의 요구 납기를 맞추지 못하는 문제’가 가장 먼저 해결해야 할 문제로 도출되었다. 우선순위 평가의 기준으로는 산업이나 기업의 현황, 문제의 성격에 따라 Table II-3에서 예로 든 것 이외에도 매우 다양하게 정의될 수 있으며 또 가중치(weight)를 두고 평가할 수도 있다. 이렇게 해결해야 할 문제의 우선순위를 결정하고 나면 각 문제별로 어떻게 분석할지 작업 계획(Work plan)을 수립해야 한다. 작업 계획은 다음 5가지 원칙을 준수해서 수립하는 것이 좋다. 조기에(As soon as possible): 데이터(특히, Critical Mass)가 수집될 때까지 기다리지 말고 현시점에서 빨리 계획을 수립함 수시로(Frequently): 수립된 작업 계획은 데이터를 살펴보면서 보완, 갱신, 개선해야 함 구체적으로(Specifically): 분석 내용과 자료의 출처를 매우 구체적으로 명시함 공동으로(Collaboratively): 팀원들과 검토하고 서로 다른 가설을 시도해야 함 마일스톤(milestones)을 따라서: 중요한 것부터 먼저 추진하며 철저한 일정관리 수행 작업 계획(Work Plan)을 체계적으로 수립하기 위해서는 Table II-4의 템플릿을 이용할 수 있다. (보통 통계적 처리를 활용하기 위해 엑셀(Excel) 같은 스프레드시트를 이용해서 정리하는 것이 좋다) Table II-4. 작업계획서 템플릿 작업 계획서 템플릿의 각 칼럼들은 다음과 같은 의미이다. 이슈(Issue/Sub Issue): 우선순위화(prioritization)을 통해 선정된 해결되어야 할 문제 가설(Hypothesis): 이슈에 대한 초기 가설 근거(Supporting Rationale): 가설을 지지하기 위한 근거 분석(Analysis): 가설과 근거의 타당성을 증명하기 위한 작업 출처(Source): 분석을 하기 위한 정보 원천 최종 산출물(End Products): 분석 결과 생성되는 마지막 결과물 책임(Responsibility): 해당 작업(work)의 책임자 기한(Timing): 해당 작업(work)을 끝내야 하는 시간 또한, 작업계획서에서 문제나 이슈에 대응하는 좋은 가설을 수립하는 것은 매우 중요한데, 노력 (efforts)을 효율적으로 배분하여 최대의 효과를 얻기 위해서는 다음과 같은 가설 수립의 5가지 고려 사항을 감안하는 것이 좋다. 명확성(Clarity) : 가설 수립 시 정의된 문제로부터 분석의 대상(Target)을 명확히 해야 한다. 정확성(Accuracy) : 어느 정도 정확해야 할지 수준을 사전에 정하는 것이 필요하며 과도한 정확성은 지양해야 한다. 간결성(Simplicity) : 가설은 논리적인 이성으로 취급할 수 있는 수준에서 최대한 간단하게 표현하는 것이 좋다. 오컴의 면도날[2] 실현성(Actionable) : 가설은 사고(思考) 실험에 그치는 것이 아니라 가설이 입증되면 언제든지 실행 가능해야 한다. 시기 적절성(Timeliness) : 가설은 주어진 시간을 고려해서 정해진 기간 안에 종료하여 효율성을 유지해야 한다. 위와 같은 5가지 고려 사항을 유념하여 가설을 수립해 보면서 방법론적 관점에서 다음과 같이 해보는 것도 좋은 가설을 수립하는 데 도움이 된다. 우선순위 선정을 통해 도출된 핵심 문제에 대해 컨설팅 팀원들과 같이 이야기해 본다. 다쿠치 기법(5 Whys)을 이용하여 가장 근본적인 원인(root cause)을 찾아본다. 주어진 정보로 가설에 대한 검증을 시도해 본다. 근거(rationale)가 부족하더라도 완벽한 검증이 되었을 경우, 어떤 모습일지 상상하면서 지속적으로 가설과 근거를 보완한다. 병렬적 사고 또는 수평적 사고 즉, 다른 차원이나 다른 측면에서 문제를 생각해 본다.(Lateral Thinking) 혁신적인 아이디어를 찾아내기 위하여 시도하는 ‘병렬적 사고’ 또는 ‘수평적 사고’는 흔히 ‘숲속에서 나무를 보는 방법’이라고도 이야기한다. 예를 들어보면, “깊이 5m의 구덩이를 두 명이 파면 1시간 걸린다고 할 때 열 명이 2시간 파면 얼마나 깊이 팔 수 있을까?” 이런 질문에 일반적인 대답은 2명/1시간일 때 5m이니 10명/2시간이면 5명/1시간으로 5m X 5명/1시간 = 25m 뭐 이런 답을 할 수도 있을 것이다. 그러나 Lateral Thinking을 한다면 대게 아래와 같은 수많은 이야기들이 나오며 상황에 맞는 논의를 통해 사고를 확대해 나가는 과정이라고 생각하면 된다. 다만, 일이 되는 방향으로 납기를 고려해서 생각해나가야만 하지 그렇지 못하면 배가 산으로 간다. 구멍은 특정 모양 또는 크기로 파야 할 수도 있고, 깊이의 제한이 있을 수도 있다. 구멍이 깊어질수록 힘이 더 들고 시간도 더 들 수 있다. 예를 들어 나오는 흙을 처리해야 한다거나, 암반이나 지하수 층이 나오는 상황이 생길 수 있다. 파내어 들어가는 것이 흙, 진흙, 모래 등 무엇이냐에 따라 달라질 수 있다. 산에서 구멍을 팔 때, 처음 몇 미터는 나무뿌리 제거 등으로 시간이 많이 걸리나 나중에는 흙만 있어 쉬울 수도 있다. 작업 공간의 제약으로 인해 한 번에 동시에 작업할 수 있는 사람은 3명을 넘지 못할 수도 있다. 사람이 많아져서 잡담 등으로 생산성이 떨어질 수도 있다. 사람이 많을수록 힘이 빠질 때 교대하기 쉬워서 더 많은 생산성이 나올 수도 있다. 날씨에 따라 생산성이 다를 수도 있다. 예를 들어 비가 온다거나 날이 갑자기 덥거나 추어지는 상황 구멍을 몇 개 파는가에 따라 달라질 수도 있다. 사람의 체력 차이로 인해 생산성이 다를 수 있다. 한 사람은 매니저로서 작업을 하지 않는다면 ...... 10 사람이 일할 때는 도구를 사용하고, 분업을 통해 생산성을 변화시킬 수도 있다. Break #5. 제퍼슨 기념관 이야기 미국 워싱턴 D.C.에는 미국 독립의 영웅이자 제3대 대통령 토마스 제퍼슨(Thomas Jefferson. 1743 ~ 1826)을 기념하기 위해 만든 제퍼슨 기념관(Thomas Jefferson Memorial)이 있다. Figure II-22. 제퍼슨 기념관 전경 Figure II-22와 같이 이오니아식 돔(Dome) 구조의 원형 대리석 건축물로 워싱턴의 유명 건축물 중 하나이다. 새하얀 대리석으로 만들어졌고 주야로 불을 밝히고 있어 그 풍경도 매우 아름답다. 그런데 이 제퍼슨 기념관이 언제부터인지 대리석이 매우 빠른 속도로 부식되어가게 되어 하얀 대리석이 검게 변하자 관리소장은 고민에 빠지게 된다. 청소 관리를 담당하는 직원들과 관리소장은 이에 대해 서로 질의응답하며 문제를 해결하기 시작하였다. 이를 좀 정리해 보면 Table II-5와 같이 나타낼 수 있으며 질문의 단계가 깊어질수록 원인 분석도 심화되어감을 알 수 있다. Table II-5. 관리소장과 청소담당 직원들 간의 대화 재구성 관리소장과 직원들은 브레인스토밍을 통해 대리석이 빨리 부식되는 근본적인 원인을 많은 나방의 출몰이라고 결론짓고 점등 시간을 해 질 무렵이 아니라 그보다 2시간 늦추어 등을 켜서 이 문제를 해결하였다고 한다. 최소한 5번의 ‘왜?’라는 질문에 대한 답을 찾는 과정(5-Whys. 타쿠치 기법이라고도 한다)을 통해 근본적인 문제점의 원인(Root Cause)을 찾고 그것에 대한 해결 방안을 찾아 나가는 이런 사고 기법은 문제를 매우 효율적으로 해결하는 데 도움을 준다. 다만, 저자의 경험에 의하면 5-Whys를 진행하면서 그 이유를 ‘특정인’에 집중하면 문제의 근원적 해결보다는 그 사람에 대한 감정적 보복으로 귀결될 확률이 크다. 물론, 감정적으로 휘둘릴 때도 있고 정말 그것이 원인이 될 수도 있겠지만 사람으로 귀결되어 감정이 더해지면 문제가 해결되는 듯싶어도 시간이 흘러 더 악화되게 되는 경우가 더 많다. 설사 그 ‘특정인’이 정말로 문제였다고 하더라도 그가 맡고 있는 지위와 역할의 문제점으로 이를 바라보고 개선하고자 노력하는 것이 동일한 문제를 야기하지 않는 현명한 해결책이라는 점을 명심하자. [1] 여기서 핵심이 되는 소수를 ‘Vital Few’, 나머지를 ‘Trivial Many’라고도 한다. [2] Occam's razor. 어떤 현상이나 논리를 설명할 때 논리적으로 가장 단순한 것이 진리일 확률이 높다는 의미. 단순성의 원칙(The Principle of Simplicity) 또는 논리 절약의 원칙(The Principle of Parsimony) 등으로 불린다. 문제 해결기법에 대해 살펴보고 있다. 문제의 정의가 중요하다고 하였고 가설을 잘 수립하고 문제의 우선순위를 결정하고 그것에 따른 작업계획을 수립하는 것까지 살펴보았다. 이어서 이번에는 해당 가설에 대한 분석 및 결과 종합에 대해 살펴보자. 5.3 분석 및 결과 종합 작업 계획(Work Plan) 수립이 끝나면 각 문제를 두고 분석 작업을 수행할 차례이다. 여기서 분석 작업이라 함은 논리적 분석 작업인데 이는 많은 데이터를 수집하고 그것의 검증을 통해 결과를 확인하는 과학적 분석 작업과 달리 가설을 기반으로 논리적인 결함을 보완 및 검증해 나가는 분석 작업이라 할 수 있다. Figure II-22는 그런 작업에서 필요한 논리적 분석 작업의 도구들이다. Figure II-22. 문제 분석을 위한 다양한 도구 '간단한 To Do List'는 아이템(Item)과 책임자, 완료일 등을 기준으로 해야 할 일들을 나열하는 것이다. 일 단위로 할 일들을 정리하여<NAME>는 것이 좋다. 'Critical Path'는 단계적으로 일을 처리하는 과정에서 반드시 해야 할 것들을 경로(Path)로 연결했을 때 소요되는 기간을 파악하여 전체 공정을 관리하는 도구이다. '논리 피라미드'와 '스토리보드'는 논리적인 글쓰기 및 보고서를 만드는 기초 자료가 되며 'Custom Format'은 Table II-4 작업계획서 템플릿처럼 그때그때 필요한 양식을 상황에 맞게 만들어 내는 기본 틀로 활용할 수 있다. 페르미 추정(Fermi Estimation) 같은 기법도 논리적 분석에서 매우 유용하다 Break #6. 페르미 추정(Fermi Problem or Fermi Estimate) 엔리코 페르미(Enrico Fermi. 1901 ~ 1954)는 이탈리아계 미국인 핵물리학자로 현대 물리학의 거장이다. 그는 기초적인 지식과 논리적인 추론을 통해 짧은 시간 안에 대략의 근사치를 계산해 내는데 매우 능통했다. 이를 따서 ‘페르미 추정’이라는 용어가 생겼는데 이것은 매년 여름 부산 해운대 해수욕장의 인파를 계산하는 것이라든지 우리의 일상생활 곳곳에서 의외로 많이 사용된다. 논리적인 사고를 원하는 직장 특히, 컨설팅 기업에 입사하게 되면 면접에서 100% 물어보는 것이 페르미 추정이다. 질문들은 언뜻 들어보면 매우 황당하다. 정답도 없다. 심지어 면접관들도 정답을 모른다. 질문의 요지는 정답이 중요한 것이 아니고 그 문제를 풀어나가는 과정이 얼마나 논리적이고 타당한지를 살펴보는 것이다. 수많은 페르미 추정 문제들이 있겠지만 Break #6에서는 그 유명한 '피아노 조율사 문제'를 다루어보자. 문제는 다음과 같다. '미국 시카고에 피아노 조율사가 몇 명 살고 있을까? (How many piano tuners are there in Chicago?)' 이게 끝이다. 질문에 대한 답변은 이제부터는 이 글을 읽는 독자님들 마음대로 답할 수 있다. 그러나 로직 트리(Logic Tree)를 접한 우리는 조금 다르게 접근해야 할 것 같다. 우선, 다음과 같은 몇 가지 가정을 해보자. 미국 시카고에는 약 500만 명이 살고 있다. 한 가구에는 평균 2명이 살고 있다. 정기적으로 피아노 조율을 받는 가구는 대략 20곳 중의 하나이다. 정기적으로 조율 받는 피아노는 평균 일 년에 한 번 조율한다. 피아노 조율사가 피아노 1대를 조율하는데 필요한 시간은 약 2시간이다. 피아노 조율사는 하루 평균 8시간, 일주일에 5일, 일 년에 50주 일한다. 이런 가정을 하면 시카고에 거주하는 피아노 조율사의 수는 125명으로 추정할 수 있다. 문장으로만 표현하니 잘 이해가 되지 않을 수도 있을 것 같다. 이것을 로직 트리로 그려보면 Figure II-23과 같다. Figure II-23. 피아노 조율사의 수를 구하기 위한 로직 트리 위에서 설립한 가정(Assumption)에 근거하여 인구 수(500만 명)에서 가구당 인구 수(2명)를 나누면 전체 가구 수(250만 가구)가 나온다. 여기에 가구당 피아노 보급률 5%(=1/20)를 곱하면 피아노 대수가 나오고(12.5만 대), 피아 노당 연간 조율 회수를 곱하면 연간 피아노 조율 회수가 나온다. 한편, 1일 조율 수와 연간 일하는 일수를 곱하면 조율사가 연간 조율하는 회수가 나오며 앞서 구한 연간 피아노 조율 회수를 조율사가 연간 조율하는 회수로 나누면 조율사의 수가 나온다. 이렇게 가정에 의해 출발한 것이지만 나름의 논리를 가지고 계산해 내는 것에 페르미 추정은 의의가 있다고 하겠다. 페르미 추정은 다음과 같은 특징이 있다. 문제에는 제한된 정보가 주어짐 주어진 제한된 정보 때문에 답을 계산하기 어려워 보이고 따라서 다양한 가정들을 통해서 답을 유추한다. 간단한 계산을 수행함. (BOTE[1]) 근사적으로 계산함 근사적 계산 및 추정을 통해 문제에 대한 통찰력을 제공함 양의 대략적인 크기(Order of Magnitude)가 중요함 크기가 10의 몇 승(Power of Ten)인가가 결정함 검증을 통해 답이 타당하다(reasonable) 는 것을 보임 복잡한 문제를 빠르게 점검하는데 유용함 더 정확하게 문제를 해결하기 위해서는 어떤 부분(또는 어떤 값)을 더 잘 이해해야 하는지 알게 됨 상상의 나래를 펼치는 것이 아니라 교양 있는 추측(educated guess)을 이용하여 논리적인 상상(Logical Imagination)을 전개하는 것이 중요함 앞서 문제의 우선순위(Priority)를 정하면서도 다루었지만 논리적 분석에 있어서 효율적으로, 효과적으로 일해야 한다. 영미권 선배 컨설턴트들로부터 전해지는 다음 팁(Tips)은 그래서 의미 있다. Always Have An Answer: 주어진 문제에 대한 가설을 세우고, 그것이 맞는지 근거를 찾고, 논리를 보완하는 일이 논리적 분석이므로 도출된 다양한 의견에 준해 발산하는 것이 아니라 지속적이고 반복적인 고찰을 통해 하나의 답이 살찌워지게 노력하라는 의미이다. KISS(Keep It Simple Stupid): 간단 명료하게 하라. 파레토 법칙을 감안하여 가장 효과가 높을 것들에 집중하라. 데이터는 어디에든 있다 : 인터넷의 시대에 네트워크에서 또는 옆 사람의 서랍 속에서 모든 문제와 정보와 답은 현장 곳곳에 있다. '정확하다'라는 말은 상대적인 개념이다: ‘보다 더 정확하게’라는 관점은 일을 끝내지 못하게 한다. 범위와 시간의 제한을 고려하면서 그 속에서 최대한 정확성을 고려하라. ‘Timeliness is next to godliness’. 이 표현은 청결은 신앙심 다음이다(Cleanlinessis next to godliness) 즉, 청결은 아주 중요하고 고귀한 미덕이라는 영어권 명구를 패러디한 것으로 납기 준수가 가장 중요하다는 말이다. 이런 팁들을 고려하여 수행한 분석 작업이 끝나면 결과를 종합하고 해결안 옵션들(Options)을 도출해야 한다[2]. 해결안 옵션 도출은 FigureII-24와 같이 5단계를 거쳐서 진행된다. Figure II-24. 해결안 옵션의 도출 및 결정 첫 번째는 목적을 명확히 하는 것이다. 두 번째는 해결책을 위해 복수의 아이디어를 검토하고 세 번째는 성과를 명확히 하기 위해 평가 기준을 명확히 해야 한다. 네 번째, 평가는 사실에 입각하고 필요한 정보에 근거하여 객관적인 평가를 진행해야 하며 다섯 번째, 복수개의 안(案)에 대한 평가 결과를 놓고 해결책을 최종의 사 결정한다. 좋은 해결책의 요건은 목표물(target)을 벗어나지 말아야 하며, 바로 행동에 옮길 수 있도록 구체적이어야 하고 (Action-oriented), 실행 주체와 눈높이를 맞추어야 하며, 마지막으로 개선의 기대치가 높아야 한다. 이런 고려 사항들을 통해서 도출된 해결책이 가장 성과가 높을 수 있다. Break #7. 문제 해결의 또 다른 관점, ECRS 논리적 사고를 통해 문제를 정의하고, 세분화하여, 문제별로 가설을 분석하고, 그에 대한 해결책들을 평가하여, 가장 성과가 큰 문제 해결책을 찾는 방안에 대해서 지금까지 살펴보았다. 이는 논리적 사고(Logical Thinking)에 기반한 매우 전통적이고도 고전적인 문제해결 방법이고 그 성과도 나쁘지 않다. 로직 트리(Logic Tree)를 활용한 문제 해결 방식은 폭포수(Waterfall) 방식으로 순차적으로 각 단계가 진행되는 문제 해결 기법이라면, 지금 설명할 ECRS 적 사고는 다양한 고려 사항들을 입체적으로 고려하여 한 번에 결론을 정리하는 방법이라 할 수 있다. ECRS는 업무 상의 문제 해결을 위하여 제거(Eliminate), 결합(Combine), 재배열 또는 교환(Rearrange), 간략화(Simplify)의 4가지 관점에서 생각하는 기법이다. 제거(Eliminate)는 ‘그만둘 수 없는가?’를 생각하는 것으로 현재의 일을 그만두기 위해서는 '그 일을 왜(또는 무엇을 위해) 하고 있는가?'라는 업무의 이유 또는 목적을 철저히 규명해야 한다. 결합(Combine)은 ‘함께 할 수 없을까’를 생각하는 것으로 몇 가지 일이나 공정을 함께 할 수 있는지를 생각해 보는 것이며, 재배열 또는 교환은 ‘순서를 바꿀 수 없는가?'를 생각하는 것으로 일의 순서를 바꾸어 문제를 해결하고자 하는 방법이다. 마지막으로 간략화(Simplify)는 ‘간단히 할 수 없을까?’를 생각하는 것으로 왜 그런 방법으로 일하는지 등에 대해 생각해 보고 간소화 가능성을 찾아가는 것이다. Figure II-25. ECRS 기법의 개념 ECRS 기법의 기본 전제는 ‘낭비가 많다’는 것이다. 기업 내 품질 활동 등과 연계해서 Table II-6과 같이 5W1H 관점에서 생각해 보면 ECRS의 각 항을 좀 더 쉽게 생각해 볼 수 있다. Table II-6. 5W1H 관점의 ECRS 문제 해결 기법과 관련해서 로직 트리를 이용한 전통적인 방법부터 ECRS를 포함하여 최근에는 디자인 싱킹(Design Thinking)에 이르기까지 매우 다양한 아이디어들이 나오고 있다. 맥킨지 7단계 기법이 문제 해결을 위한 순차적인 생각에 근거하여 문제를 정의하고 분석하고 해결하는 것이라면 ECSR는 마치 소프트웨어 공학의 Spiral 방법처럼 다양한 관점에서 파악하고 반복을 통해 점진적으로 개선해나가는 것과 같다고 할 수 있다. 디자인 싱킹은 이와 또 다르게 문제를 조망하고 해결해나가는 방법이다. 다음 장은 문제 해결의 마지막 장으로 디자인 싱킹에 대해 알아보도록 하자. [1] Back-of-the-envelope calculation 편지봉투 뒷면에 적으면서 처리할 수 있는 간단한 계산 [2] 해결안 옵션에서 아무것도 하지 않는 것(No Action)도 옵션이 되지 않는다는 것을 명심하자 트리즈(TRIZ)? 문제 해결에 디자인 싱킹(Design Thinking)은 뭐야? 로직 트리로 문제 해결을 고민하다 보면 자주 부딪히는 한계가 사고(思考) 실험의 제한성이다. 다시 말해서 '그게 진짜 그렇게 되냐?'라고 말할 경우 주춤하게 되는 경우가 종종 발생하는 것이다. 컨설팅 스킬에서 소개하는 문제 해결 기법은 다양한 통계량과 분석에 기반한 과학적 분석이 아니라 논리적 사고에 근거한 사고 실험이 중심이지만 그런 도전이 오랜 시간 지속되면서 보다 다른 관점에서 문제 해결을 바라보는 방법들이 많이 개발되었다. 트리즈(TRIZ)나 디자인 싱킹(Design Thinking)은 단순한 기법이라기보다는 하나의 방법론(Methodology)으로 나름의 도구들도 구비하고 있기에 컨설팅 스킬에서 다루기보다는 Part IV. 컨설팅 방법론에서 다룰 수도 있겠지만 '문제 해결의 카테고리' 안에서 간략하게 소개하고자 한다. 트리즈나 디자인 싱킹 모두 세상에 알려진 것은 꽤 오래전의 일이다. 그럼에도 불구하고 아직 마이너리티(Minority)를 벗어나지 못하는 것 같고 요즘 같은 실시간 정보 교류가 되는 세상에서도 특히, 한국에서는 거의 새로운 어젠다처럼 받아들여지고 있다. 다만, 기존의 복잡계(Complex System)에 살고 있는 우리는 새로운 세상을 또는 시스템을 또는 사업을 바라볼 때 이런 방법론을 활용하는 것을 적극 고민해 보는 것도 나쁘지 않을 것이다. 중요한 것은 이 장의 처음부터 계속 강조하지만 이것들은 지식이 아니라 스킬이다. 읽는 것이 아니고 직접 해보지 않으면 별 도움이 되지 않는다. 지금부터 트리즈와 디자인 싱킹을 살펴보도록 하자. 5.4 트리즈(TRIZ), 미국의 코를 꺾다. Figure II-26. 달 착륙선의 엔진 분사 이런 얘기가 있다. 1969년 아폴로 11호의 달 착륙을 앞두고 NASA의 과학자들은 고민에 빠졌다. "안전한 달 착륙을 위해 달 표면을 상세히 보기 위해서는 우주탐사선 하부에 많은 백열전구를 달아서 밝게 만들어야 한다. 그러기 위해서는 달 착륙 시 발생하는 강한 충격을 견딜 수 있는 강한 유리와 전구 등이 필요하다." NASA의 수많은 과학자들이 고민하였지만 답은 나오지 않았다. 그러던 와중 소련 출신 과학자를 초빙하여 의견을 구했는데 그가 한 말, "우주는 진공상태여서 굳이 전구에 유리를 씌우지 않아도 된다." Fact에 근거한 발상의 전환인 것이다. 실제로 이런 일이 있었는지는 모르겠다. 그러나 TRIZ가 냉전이 한창이던 1940년 대 소련(現 러시아)에서 개발된 것임을 안다면 충분히 그런 일화가 회자될 수도 있을 것 같다. TRIZ는 '창의적 문제 해결 이론'이라는 러시아어 'Teoriya Resheniya Izobretatelskikh Zadach'에서 첫 글자를 따 온 것으로 영어로는 'Theory of Inventive Problem Solving'이라는 뜻이다. 소련의 과학자 겐리히 알츠슐러(Genrich Altshuller. 1926 ~ 1998)에 의해 창안된 것으로 알려져 있는 TRIZ는 창의적 문제를 정의하고 최소의 자원을 투입해 이를 해결하는 것으로 무(無)에서 유(有)를 창조하거나 해결하는 것이 아니라 유(有)에서 유(有)를 찾는 노력을 통해 문제를 해결할 수 있다고 주창하는 이론이다. 즉, 세상의 모든 문제는 해결법들이 존재하고 있으며 우리는 그것을 찾아내면 된다는 이론이다. 이를 위해서 TRIZ는 다음과 같은 독특한 단계들을 수행한다. (1) 모순(Contradiction)의 정의 (2) 파라미터 변환 (3) 모순 행렬(Contradiction Matrix) 테이블 이용 (4) 40가지 해결 원리 중 최적 원리 선택 첫 번째, 모순의 정의는 '모든 문제는 최소한 한 가지 이상의 모순이 있다'라는 전제로 시작한다. 즉, '만약 A를 하면 B가 나빠진다'라는 것을 명확하게 이해하고 그 모순을 해결하면 문제는 해결된다는 개념이다. 이런 모순에는 크게 다음과 같은 두 가지가 있다고 한다. 물리적 모순(Physical Contradiction) 기술적 모순(Technical Contradiction) 물리적 모순은 '어느 하나가 이래야 하지만 또 저래야 한다'라는 것이다. 예를 들면 '자전거 체인은 부드럽지만 또 단단해야 한다.'라든가 '비행기 바퀴는 착륙을 위해 있어야 하지만 공기저항을 줄이기 위해 없어야 한다.'같은 것들이다. 기술적 모순은 서로 다른 2개가 충돌하여 문제를 일으키는 것으로 생각할 수 있다. 즉, '어느 하나가 좋아지면 어느 하나가 나빠진다'와 같은 것이다. 예를 들면 '연비가 좋아지면 출력이 나빠진다', '비용이 좋아지면 품질이 나빠진다.', '물가가 안정되면 경제성장이 둔화된다' 등과 같은 것이다. TRIZ에서는 이런 모순을 극복하기 위해서 분리의 원리(Seperation Principle)와 40가지 해결의 원리(40 Inventive Principles) 및 모순 행렬을 활용한다. 분리의 원리는 물리적 모순에서 주로 활용하는데 시간에 의한 분리(Seperation in Time), 공간에 의한 분리(Seperation in Space), 전체와 부분에 의한 분리(Seperation in Scale), 조건에 의한 분리(Seperation in Condition) 등이 있으며, 40가지 해결의 원리와 모순 행렬은 기술적 모순에서 활용한다. 앞서 언급한 예제를 분리의 원리에 적용해 보면 다음과 같다. 시간에 의한 분리: '비행기 바퀴는 착륙을 위해 있어야 하지만 공기저항을 줄이기 위해 없어야 한다.'라는 다음과 같이 분리될 수 있다. '랜딩 기어를 이착륙 시 동체에서 나오게 하고, 비행 시, 동체 안으로 들어가게 함.' 공간에 의한 분리: '고층 건물에 엘리베이터를 너무 많이 설치하면, 그만큼 사용 공간이 줄어든다'라는 다음과 같이 분리될 수 있다. '한 공간에 저층용, 고층용 2개의 엘리베이터를 설치함' 전체와 부분에 의한 분리: '자전거 체인은 부드럽지만 또 단단해야 한다'라는 '단단한 쇠사슬로 만들되, 분리 및 연결은 부드럽게 함'과 같이 분리될 수 있다. 모순을 정의하고 이를 분리해 내면 이제 모순을 극복하기 위해 두 번째 단계인 파라미터 변환을 진행한다. 모순의 정의에서 '만약 A 하면 B가 나빠진다'라는 것에서 A와 B의 특성을 가장 잘 반영하는 파라미터를 선택한다. TRIZ에서는 이를 위해 39가지의 파라미터를 정의하고 있고 이를 선택한다.[1] Table II-7. TRIZ 기법의 39가지 파라미터 세 번째로 할 일은 선택된 파라미터를 가지고 모순 행렬에서 설루션을 찾아보는 것이다. 모순 행렬은 TRIZ 기법 자체에서 제공하는 것으로 Figure II-27은 그 일부이다. Figure II-27. 모순 행렬(Contradiction Matrix)의 일부 예를 들어 문제의 특성을 반영한 파라미터가 17번 온도와 1번 움직이는 물체의 무게라면 6,22,36,38이라는 번호를 찾을 수 있다. 이 번호가 TRIZ의 40가지 해결책이다. 6번은 Multifuction(하나의 물건을 여러 번 사용하기), 22번은 Harmful to Useful(안 좋은 것을 좋은 것으로 바꾸기), 36번은 Phase Change(상태 전이), 38번은 Oxidant(반응 속도를 증가시키기)이다. Figure II-28. TRIZ의 40가지 해결 방안 마지막으로 찾아낸 TRIZ 해법 (6,22,36,38)을 현재 상황에 최적화하면 문제 해결은 종료된다. TRIZ가 제공하는 40가지 해결 방안은 다양한 관점에서 그 진가를 발휘할 수 있다. 위에서 선택한 설루션들을 좀 더 살펴보면 6번 Multifunction의 경우, 하나에 여러 가지 기능이 연계되는 것을 생각할 수 있다. 예를 들어 칫솔이 설태도 제거한다든지, 다기능을 가진 스위스의 군용 나이프, 스타벅스 바리스타는 주문, 제조, 서비스를 동시에 하는 것 등이 해당된다. 22번 Harmful to Useful (또는 Blessing in disguise)는 유해한 것을 사용해서 유해한 것을 없애는 것, 이이제이(以夷制夷) 같은 것이 해당할 수 있다. 예를 들어 계약 시 가격을 낮추는 대신 장기계약을 한다던가, 고객의 불편함을 창안하여 그 부분을 새로운 시장으로 개척하는 것 등이 될 수 있다. TRIZ가 좀 이해되는가? 아주 잘 정리된 문제 해결기법이긴 하지만 사실 트리즈는 쉽지 않다. 기술 관련 이슈에서 적용하기 용이하며 비즈니스로 확장하면 좀 더 유연한 또는 사용성 높은 설루션들이 필요할 수도 있다. 그런 측면에서 이제 살펴볼 디자인 싱킹은 기존의 브레인스토밍(Brainstorming)을 현실화하고 반복을 통해 구체화 나감으로써 스타트업이나 비즈니스의 빠른 피드백을 기대하는 업종에서 매우 유용하게 사용할 수 있다. 5.5 상상을 현실로, 디자인 싱킹 저자가 처음 디자인 싱킹을 접했을 때 '디자인'이라는 용어는 바이어스(Bias)를 불러일으켰다. 'IT 시스템의 사용자 인터페이스나 사용자 경험(UI/UX)과 관련된 것인가?'라는 생각도 들었고 (물론, 무관하지 않다) 아무튼 그 본질을 알기 어려웠다. 디자인 싱킹의 정의에 대해 생각해 보면 말 그대로 '디자인(Design)을 제대로 하기 위한 프로세스'라고 할 수 있다. TRIZ와 같이 디자인 싱킹도 오래전부터 정의되기 시작했는데 다음은 알려진 몇 가지 정의이다. 사회, 문화, 경제, 정치 환경 등 인간 생활의 제반 문제를 학제적인 협동을 통해 디자인의 통합적이고 종합적인 문제해결 능력과 맞물려 해결하는 과정 - 허버트 사이먼(Herbert Simon, 1969) 디자이너의 감수성과 창조적 작업 방식을 활용하여 사람들의 니즈를 실현 가능한 전략을 통해 비즈니스화할 수 있는 가치와 시장기 회로 만들어내는 훈련 방법 - 팀 브라운(Tim Brown, 2008) 혁신을 위한 사고 법으로 분석적 사고의 숙련과 직관적 사고의 창조성이 역동적으로 균형을 이룬 것 - 로저 마틴(Roger Martin, 2009) 세상에 널리 알려진 것은 2004년 SAP[2]의 후원으로 스탠퍼드 대학에 d.school이 생기면서 주목을 받게 되었고 화두가 된 것은 아무래도 디자인 기업 IDEO의 CEO 로저 마틴의 기고와 저서, 그들의 활동이 세상에 알려지고부터라고 할 수 있다. 이후 월스트리트저널이나 포츈, 맥킨지, P&G, GE, IBM, Apple 등에서 이를 적극적으로 다루고 비즈니스의 성과를 주목하였다. 디자인 싱킹은 4가지 특징을 가지는데 다음과 같다. 첫 번째, 사람 중심(Human-centered)이다. Figure II-29. Design Thinking에서 바라보는 혁신의 유형 디자인 싱킹의 출발은 사람의 관점에서 시작한다. 사람들, 사용자들, 소비자들, 고객들의 니즈 및 그들의 희망하는 바에서 출발하고 그 동기와 문제를 해결하려고 하는 것이 시작점이다. 즉, 'Empathy'가 핵심으로 타인의 Feeling을 느끼고 이해하며 '공감'하는 능력이 필요하다. 이는 과거의 공급자 중심(나 중심)에서 수요자 중심( 타인 중심)으로 사고의 전환을 요구한다. 예를 들어 '나 중심'에서는 '나의 기술과 지식으로 무엇을 만들 수 있을까?'라는 본원적 질문이 중요했다면 '타인 중심'에서는 '사람들은 무엇을 원하고 나는 무엇을 할 수 있을까?'로 본원적 질문이 전환될 수 있다. 이는 Opportunity-based Strategy에 기반한 설루션 비즈니스 모델의 사상과 통한다고 할 수 있다. (아래 글 참조) 그래서 설루션 사업 고민한다. (1/2) 설루션이 뭐라고? 아 ... 난 여태까지 잘못 알고 있었네. | B2B 영업은 영업 방식(Sales Motion)에 따라 Volume Sales와 Value Sales로 구분해 볼 수 있는데 Volume Sales는 대량(Bulk)의 제품을 유통채널을 통해 기업고객에게 판매하는 것으로, B2C 세일즈처럼 채널 및 파트너 관리가 중요하다. 그런데 Value Sales는 B2C 세일즈 또는 Volume Sales와는 상당히 brunch.co.kr/@flyingcity/8 디자인 싱킹의 두 번째 특징은 통합적 사고(Highly Creative)이다. 디자인 싱킹은 상황에 대한 다양한 관점의 관찰을 통해 기존의 대안을 뛰어넘는 새로운 해결책을 제안할 수 있게 해주며 문제의 모든 측면을 다양하게 관찰하는 통합적 사고가 핵심이다. 앞서 배웠던 로직 트리에 기반한 전통적인 문제 해결 기법이 분석적 사고에 기반하여 연역적(Deductive) 방법 및 귀납적(Inductive) 방법을 주로 활용했다면, 디자인 싱킹은 귀추 논리(abductive reasoning)[3]를 통해 분석적 사고의 숙련과 직관적 사고의 창조성이 역동적으로 균형을 이루고 있다고 말한다. 세 번째 특징은 시행착오를 통한 무수한 실험이다. (Hands-On) 토의를 중단하고 직접 손을 사용해 머릿속의 아이디어를 실현시키는 것이다. 프로토 타이핑(Prototyping)을 통해 머릿속의 가설을 테스트하고 실현시켜본다. Figure II-30. 다양한 프로토 타이핑 활동 네 번째, 특징은 반복하는 것이다. (Iterative) 디자인 싱킹은 한 번에 완성된 것을 만드는 것이 아니라 지속적인 반복을 통해 점진적으로 완성의 모습을 갖추어 나가는 것이다. 이는 스타트업(Startup)에서 MVP[4]를 개발할 때도 같은 논리로 적용될 수 있다. Figure II-31. 점진적이고 반복적인 개발 이와 같은 특징들을 고려하여 프로세스로 구성하면 다음과 같다. Figure II-32. Design Thinking 프로세스 문제의 본질을 이해하기 위하여 나의 관점이 아니라 사람의 관점에서 공감하고 요구를 정의하며 통찰력을 얻고, 창의적인 아이디어를 통해 제공하고자 하는 제품/서비스를 구상하고 이를 프로토파입과 테스트를 통해 완성도를 높여간다. 디자인 싱킹은 2000년 대 후반 IDEO를 통해 널리 알려지기 시작하면서 실리콘밸리에 불기 시작한 스타트업 기업들의 사업 추진 방법론으로 각광받았다. 특히, 린 스타트업(Lean Startup)과 접목되면서 문제와 설루션을 고민하고, 시장 수요를 점검하고 제품의 완성도를 높이며 시장 및 사업 규모를 확장하는 방법의 실효성을 인정받기 시작하였고 위에서 언급한 글로벌 대기업들도 관심을 가지게 되었다. 최근에는 국내 기업들도 문제 해결이 나 신사업 추진의 방법론으로 디자인 싱킹을 적극 활용하는 것 같다. TRIZ며 디자인 싱킹이며 매우 방대하고 전문적인 주제인데 문제 해결 카테고리에서 간략하게나마 다루어 보았다. 독자 여러분들의 문제 해결에 대한 인식과 생각이 좀 더 확장되었기를 희망한다. 다음 장에서는 컨설팅 스킬의 마지막이면서 정말 중요한 커뮤니케이션 스킬 - 인터뷰, 회의, 문서화, 프레젠테이션에 대해서 살펴보자. [1] TRIZ는 발명특허를 연구, 정리하다 발견된 것으로 주로 기술 중심의 연구개발에 유용하였다. 2003년 영국 배스 대학의 Darrell Mann 교수는 기술 연구를 위한 39가지 파라미터를 비즈니스 관점에서 사용할 수 있는 31가지로 변경하기도 하였다. [2] www.sap.com 독일의 유명 ERP 전문 기업. [3] 어떤 놀랄만한 현상이 나타났을 때 그 현상을 설명해 주는 가설을 추론하는 과정. 예를 들어 요하네스 케플러(Johannes Kepler. 1571 ~ 1630)는 화성 궤도가 타원이라는 것을 발견했을 때 어떤 연역법을 사용한 것이 아니라 그의 스승이었던 티코 브라혜(Tycho Brahe. 1546 ~ 1601)의 행성 관찰 자료를 토대로 화성 궤도가 타원이라는 것을 궁극적 가설에 도달하였다. [4] Minimum Viable Product. 최소 기능만 동작하게 하여 시나리오의 수용 여부를 보며 완성도를 높여간다 같이 읽어보면 좋은 책 kx ▶ 40 Principles: TRIZ Keys to Innovation, Genrich Altshuller, 2005 The Design of Business: Why Design Thinking is the Next Competitive Advantege, Roger L.Martin, 2009 The Lean Startup, Eric Ries, 2011 06. 커뮤니케이션 스킬(1/3) - 인터뷰 ‘총괄님, 어떻게 하면 컨설팅을 잘할 수 있나요?’, ‘무슨 좋은 기법과 도구가 있나요?’, ‘어떤 방법론이 가장 효율적인가요?’ 신입 컨설턴트들이 입사하고 그들을 이끌 지위에 오르면 이런 질문들을 곧잘 듣곤 할 것이다. 저자의 경우는 그런 질문을 들었을 때, '우선 고객의 목소리[1]에 주목하라'라고 조언해 주었다. 사실 모든 문제와 답이 거기에 있다. 고객과의 회의(meeting)와 인터뷰(interview)는 고객의 요구(demand or requirements)를 파악해 내기 위한 대표적인 커뮤니케이션 기법들이다. 이를 통해 얻어지는 시사점들은 문서화(Documentation)와 프레젠테이션(Presentation)으로 고객에게 공유된다. 그러나 제대로 된 기법의 이해 없이 사용하면 효율적이지 못하며, 그 숨은 메시지를 찾기 위해 많은 시행착오를 겪는다. 콘텐츠를 전달할 때 아마추어는 자신이 하고 싶은 말을 전달하고, 프로는 상대방이 원하는 것을 전달하는 모습을 볼 수 있다. 어떤 경우에든 효과적인 커뮤니케이션은 ‘자신의 의도대로 상대방이 생각하고 행동하도록 만드는 것’임을 잊어서는 안 된다. 3장에서는 컨설팅 스킬의 세 번째로 커뮤니케이션 스킬에 대해서 살펴보자. 너무나 많이 접할 수 있는 것들이라 ‘이것도 스킬인가?’라고 생각하고 특별하지 않게 느낄지 모르겠지만 이 장이 끝나면 그 생각이 바뀔지도 모른다. 6.1 인터뷰 잘하기 인터뷰(Interview)란 무엇일까? 클라이언트와 만나서 이야기하는 것? 인터뷰에 동반한 다른 팀원은 옆에서 무언가를 적고 있다. 이런 상황만 대강 떠올린다면 인터뷰를 잘 모르는 것이라 말할 수 있다. 인터뷰는 현안에 대한 조사를 하면서 데이터나 정보를 수집함과 동시에 고객 관계(Customer Relationship)를 만들어 나가는 고급 커뮤니케이션 기법이다. 그래서 매우 조심스럽고 그 결과의 파급 효과를 잘 고려해야 한다. 프로젝트의 성격에 따라 특정한 인터뷰의 목적을 설정할 수 있으며, 그에 따라 적정한 인터뷰의 주제, 인터뷰의 대상, 결과의 분석 방법을 선택할 수 있다. 컨설팅 프로젝트에서는 대체적으로 다음과 같은 이유로 인터뷰를 수행한다. 현황 분석을 위한 기초 자료 수집 프로젝트 주요 책임자들의 의견 청취 프로젝트의 관심을 높이고 적극적인 참여 유도 인터뷰는 일반적으로 Figure II-33과 같이 인터뷰 사전 준비를 하고, 인터뷰를 실행하며, 인터뷰 결과를 요약하는 3단계로 진행된다. Figure II-33. 인터뷰의 3단계 절차 첫 번째 단계인 인터뷰 사전 준비는 인터뷰 진행 전, 인터뷰 계획을 수립하고 인터뷰 대상을 선정하며, 세부 일정을 잡고 인터뷰 질의서를 만드는 일 등을 포함한다. 두 번째 인터뷰 실행 단계는 보통 2인 1조로 구성된 인터뷰 팀이 인터뷰 대상자들을 만나 주제와 관련된 질의응답을 진행하며 인터뷰 결과를 정리하는 것을 말하며, 세 번째 단계인 인터뷰 결과, 도출된 시사점과 핵심 현안을 파악하여 문제점 및 개선 사항 발견에 활용하는 것을 뜻한다. 모든 일이 그렇지만 인터뷰는 체계적으로 준비하지 않으면 그냥 명함 받아오는 것으로 끝나게 된다. 효율적으로 진행하기 위해서는 어떻게 해야 할까? 효율적인 인터뷰 계획서를 작성하기 위해서는 다음과 사항들을 고려하는 것이 좋다. 무엇에 집중할 것인가? 어떤 정보를 알고, 얻고 싶은가? 필요한 정보는 어떻게 확보할 것인가? 인터뷰에는 어떤 질문을 적절하게 사용해야 하는가? 누구를 인터뷰해야 하는가? 위 고려 사항들을 참고하여 누구를 어디에서 만나서 무엇을 어떻게[2] 질문할 것인지 등 인터뷰 계획서를 작성한다. 또, 인터뷰는 상황에 맞는 방법을 사용해야 하는데 가장 일반적인 방법은 인터뷰 당사자와 인터뷰 팀이 만나서 직접 이야기를 나누는 대면 인터뷰(Face-to-Face Interview)이다. 인터뷰 대상이 원격지에 있을 경우, 전화를 사용한 전화 인터뷰도 많이 사용하는 방법이며, 상대와 만나지 않고 서면으로 인터뷰하는 방법도 있다. 또한, 특정 집단에 대해 깊이 있는 인터뷰를 진행할 필요가 있을 경우, 포커스그룹 인터뷰(FocusGroup Interview. FGI)를 활용하기도 한다. Table II-8. 인터뷰의 유형 인터뷰 질의서 또한 매우 관심 깊게 준비해야 하는 것인데 그냥 질문 목록을 만들고 그칠 것이 아니라 질문자가 답변할 것으로 예상되는 내용들을 사전에 정리해 보고 그와 관련된 추가 질문이나 대응 상황 같은 것들을 정리하는 일이 필요하다. 일종의 사전 시나리오를 생각해 보는 것인데 인터뷰 전체를 주도적으로 이끌어 나갈 수 있는 원동력이 된다. 가설을 기반으로 인터뷰 대상자의 답변을 미리 채워보거나 예상되는 시사점의 정량화가 가능하다면 표나 그래프 같은 차트를 구성해 보는 것도 좋다. 단순히 인터뷰 대상자가 이야기해 주는 것을 받아 적는다는 수동적인 자세로 인터뷰를 임하면 반드시 실패한다. 따라서 사전에 인터뷰 내용에 대한 결과를 가설 기반으로 예측하여 정리해 보는 일은 중요하다. 사람들을 만나보면 분명히 뛰어난 화술과 임기 응변에 능한 사람이 상대적으로 인터뷰 수행에 유리한 것은 사실이다. 그러나 일반적으로 인터뷰는 Figure II-33과 같은 순서로 진행되기 때문에 이를 숙지하면 부드럽게 인터뷰를 진행할 수 있다. 도입부에서는 아이스브레이킹(Ice breaking)이나 스몰 토크(small talk)를 이용해서 첫 만남의 어색함 및 분위기를 푸는 작업이 필요하다. 또한, 인터뷰의 기술적인 측면을 좀 더 살펴보자면 Figure II-34과 같이 질의 단계, 정취 단계, 종합 단계의 3단계 구조를 생각해 볼 수 있다. Figure II-34. 인터뷰의 구조 질의와 관련해서는 다음과 같은 점을 유념하자. 민감한 내용이나 보안에 관련된 질문은 조심스럽게 이야기하는 것이 좋다. 인터뷰 대상자의 언어 즉, 현장의 언어로 질문하는 것이 필요하다. 컨설턴트들이 인터뷰에서 실패하는 가장 큰 요인은 현학적(衒學的)인 표현을 많이 사용한다는 것이다. 나의 지식과 경험을 뽐내는 것이 아니라 인터뷰 대상자의 이야기를 끌어내야 한다. 인터뷰 도중, 인터뷰 내용을 지지할 수 있는 문서가 있다면 반드시 확보해야 한다. 그것을 위해서라도 항상 예의 바르게 대해야 한다. 인터뷰는 감사가 아니다. 간혹, 진단과 일반 프로젝트를 혼동하여 인터뷰의 성격을 잘못 파악하는 컨설턴트들도 있는데 일반적으로 인터뷰는 관계를 만들어나가는 목적이 가장 강하다. 따라서 인터뷰 종료 후 자리를 떠나간 후에도 인터뷰 수행자들에 대해 긍정적인 이미지를 줄 수 있어야 한다. Figure II-35. 인터뷰 질의응답 인터뷰의 질문은 크게 Open Questions과 Closed Questions으로 구분할 수 있는데, Open Questions은 예, 아니오(Yes or No)와 같은 답이 아닌 열린 응답을 통해 사안에 대한 의견을 충분히 듣는<NAME>의 질문이다. Closed Questions는 그와 반대로 예, 아니오를 요구하는 질문이다. 예를 들어 ‘밥 먹었어? 응’ 이런 질문은 대화가 쉽게 끊어지고 지속적으로 연결되지 않는다. ’오늘 점심 뭐 먹었어요? 설렁탕이요. 어디서요? 사거리 앞에서 새로 생긴 곳이요‘, ‘나도 거기 봤는데 거기가 정말 맛있나 봐요?’ 등 같은 점심 먹은 것을 확인하는 질문이라도 Open Questions는 지속적으로 대화를 이어갈 수 있다. 컨설팅 인터뷰에서는 이 두 가지<NAME>을 적절하게 섞어서 활용한다. 인터뷰는 서로 그냥 이야기하는 것이 아니다. 정해진 시간에 원하는 핵심 정보를 얻고 컨설팅 프로젝트 팀의 우군과 적군도 파악해야 한다. 그래서 인터뷰 팀은 부드럽고 매끄러운 진행을 통해 원하는 결과를 얻고자 인터뷰 전략 관점에서 상당한 고민을 해야 한다. 인터뷰 과정에서 사안에 대한 의견을 표명하는 방법으로 Open questions를 기본으로 하되 고심하고 또 고심하며 Table II-9와 같은 형태의 질문은 지양해야 한다. 그렇지 않으면 늪에 빠진다. Table II-9. 지양해야 할 인터뷰 질문의 형태 또한, 인터뷰 대상자로부터 응답을 들을 때에는 유대감을 형성하고 공감을 해주어야 한다. 여기에는 비언어적 신호도 포함되는데 인터뷰 대상자와 공감하는데 필요한 몇 가지 의식적인 태도를 소개하면 다음과 같다. 성의를 보여주고 상대가 좋아하도록 노력해야 한다. 상대의 눈을 보고 이야기해야 한다. Eye-Contact은 공감적 경청을 의미한다. 거리에 유의한다. 너무 가까이 또는 너무 멀리는 좋지 않다. 질문을 한 후, 팔짱 끼고 의자를 뒤로 젖히는 행위는 최악이다. 자세는 바르게, 발을 꼬지 않는다 아울러 다음 사항들은 인터뷰 진행의 효율성을 위해 유념해야 한다. 시간 배분을 주의해야 한다. 생각했던 질문에 대한 답을 전부 들을 필요는 없다. 질문의 우선순위(priority)가 있듯이 대답의 우선순위도 있음을 유의하라 인터뷰 도중, 새로운 발견이 있으면 그것을 파고들어도 좋다. 메모가 중요하지만 모두 적을 필요는 없다. 그러나 상대가 말한 것, 그 순간 나의 판단, 순간의 생각 등은 구분해서 적는 것이 좋다. 상대에게 생각할 시간을 주라 귀뿐 아니라 눈과 마음을 열자. 상대의 감정을 중시해야 한다 인터뷰 상대에 따라 같은 주제에 의견이 상이할 경우 중시해야 한다 그리고 인터뷰 내용의 효과적인 수집 및 정리는 전체 컨설팅 작업의 효율성과 직결된다. 가장 일반적인 방법은 노트 필기(Note Taking)를 활용하는 것이다. 인터뷰 노트는 배경 설명, 주요 결과 정리, 다음 단계 정의의 순으로 정리하는 것이 좋은데 첫 번째, 배경 설명은 인터뷰의 목적, 참석자와 장소, 시간, 인터뷰 대상자, 인터뷰 분위기 등을 간략하게 요약한다. 두 번째, 주요 결과 정리는 Action을 중심으로 정리하되 인터뷰 대상자의 공식 발언 및 결론, 결론의 정리, 결론의 근거를 정리하며 마지막 다음 단계 정리는 인터뷰 이후 결과 요약 및 팀원 공유, 고객 워크숍 등 추후 계획 등을 정의한다. A4 노트를 이용한다면 용지의 절반을 접어서 왼쪽 란에는 인터뷰 질의 사항을, 오른쪽 란에는 그때그때 느낌과 판단, 중요한 것들을 적는다. 어차피 워드와 같은 문서 앱으로 정리할 것이니 노트북 컴퓨터를 이용하자 하여 인터뷰 대상자 앞에서 노트북을 펴는 것은 인터뷰 대상자를 긴장하게 만들 확률이 높다. 녹음기는 더욱더 그렇다. 따라서 노트북은 지양하고 녹음기는 필요하다면 반드시 양해를 구하고 인터뷰 대상자가 인지할 수 있도록 하자. 또한, 인터뷰에 사용하는 펜도 색깔 있는 펜을 사용하는 것이 좋은데 예를 들면 검은색이나 파란색은 인터뷰 수행자 입장에서, 빨간색은 이슈나 문제가 되는 내용, 녹색은 불확실한 내용 등을 표기하여 추가 조사가 필요한 것 등을 표기하는 것이다. 손목이 좀 아프겠지만 가급적 다양한 색의 펜을 이용하고 다음과 같은 점을 잘 생각해서 인터뷰를 정리해야 한다. 인터뷰 대상자의 발언은 완전한 인용문으로 기록한다 필요할 경우, 메모할 시간을 요청한다 인터뷰 가이드를 확대하여 그 위에 기록하는 것도 좋다 인터뷰 대상자의 생각을 표나 그래프로 형상화할 수 있다면 그때그때 정리하자. 수집된 정보는 다시 확인하고 응답자의 견해에 관심을 표명한다 잘 보이는 곳에 다음 단계(Next Step)를 요약하여 인터뷰를 마무리할 때 다음 행동을 쉽게 요약해 줄 수 있게 한다 인터뷰가 끝나면 인터뷰 대상자에게 감사 인사를 하고 돌아간다. 인터뷰 대상자가 사무실을 방문한 것이라면 잘 도착했는지 전화하는 것이 좋다. 컨설턴트와 인터뷰 대상자의 긍정적인 관계(Positive relationship)를 만들기 위함이다[3]. Figure II-36. 인터뷰 결과의 공유 인터뷰의 마지막은 결과 공유이다. 시사점을 정리하여 팀원들과<NAME>고 필요시, 고객에게 보고하게 된다. Figure II-36은 인터뷰 결과를<NAME>는 작업을 3단계로 정리하여 보여주고 있다. 첫 번째, 인터뷰 노트를 다시 정리하고 누구나 알 수 있도록 사실과 의견을 포함한다. 두 번째, 팀 브리핑(Team Briefing)을 통해 인터뷰 결과를 종합적으로 검토하고 세부적으로 작업할 것들을 결정한다. 마지막으로 시사점(Key Findings or Implications)을 객관적인 관점에서 정리하고 정량화하고자 노력한다[4]. Break #8. 기업 커뮤니케이션의 기본, 회의(Meeting) 직장 생활에서 회의(會議. Meeting)는 매우 많이 발생한다. '회의(會議)를 너무 많이 해서 회의(懷疑)가 생긴다'라는 자조(自嘲) 섞인 농담도 있을 정도이다. 그러나 최근 많은 기업들이 업무 생산성 향상 차원에서 회의의 방법이나 성격에 대해 고민을 많이 한다. 즉, '회의는 의사 결정만을 위해서 하자'라고 하는 곳이 많다. 자료 검토나 공유를 위한 회의는 가급적 지양하고 대신 이메일을 활용하도록 권장한다. 왜냐하면 그런 목적의 회의는 생산성 차원에서 좋지 못하기 때문이다. 항상 시간에 쫓기는 컨설팅 프로젝트에서 회의를 사전에 잘 설계하는 것은 매우 중요하다. Figure II-37. 회의의 설계 과정 회의의 목표를 명확히 해야 하며 누가 참석할 것인지, 시간이나 장소는 어떻게 되는지, 회의에서 다루어야 할 이슈는 무엇인지, 이슈 해결을 위해 몇 번의 회의를 진행해야 하는지, 참석자 간의 이해관계는 어떻게 살펴야 하는지 등을 고려하여 회의 어젠다의 초안(Draft)을 개발한다. 공유를 목적으로 하는 회의는 생산성 차원에서 지양하는 편이다. 컨설팅에서 시간은 더욱 중요하므로 회의를 잘 설계하는 것이 중요하다. 회의를 위한 Draft가 완성되면 팀 브리핑(Team Briefing)을 통해 상호 의견을 교환하여 보완한 후 회의를 진행한다. Figure II-37은 회의의 설계 과정을 보여준다. 이렇게 설계된 회의는 명확한 결과를 도출하기 위해 FISH 기법 같은 것을 사용하기도 한다. FISH는 효율적인 회의 진행을 위해 고안된 기법으로 구조화(Framing), 조사(Investigate), 형상화(Shaping), 정리(Harvesting)의 영문 약자를 모아 만든 용어이다. 이에 대해 좀 더 상세히 알아보자. 효과적이고 성과지향적인 회의를 위한 FISH 기법의 첫 번째, 구조화 (Framing)는 회의 계획의 부분 또는 연장선에서 생각할 수 있으며 아이스브레이킹[5]으로 그냥 지나치기 쉬운 회의 전반부를 몰입하게 해준다. 회의의 프레임은 Table II-10의 항목들을 규정하는 것에서 시작한다. Table II-10. 회의 프레임의 구성 항목 회의 프레임을 구성하면 회의의 몰입도를 높이기 위해 다음 4가지를 시도한다. Melting: 회의 참석자들이 ‘우리’라는 표현을 사용하도록 유도한다. Expectation check: 회의 참석자들이 회의에 기대하는 바를 발표할 수 있게 하고 서로 공유한다. Ground Rule 결정: 회의 참석자들을 위한 기본 규칙을 정하고 모두 합의한다. 예) 회의 시간 내 스마트폰 꺼두기 I Talk: 회의를<NAME>는 입장에서 이 회의가 왜 필요한지 지속적으로 전달해야 한다. FISH 기법의 두 번째, 조사 (Investigate)는 비정기적인 회의에서 많은 의견과 아이디어를 내는 방법들로 구성되어 있으며 회의 진행자[6]의 운영 실력(Facilitating skills)이 중요하다. Table II-11은 조사 단계에서 사용할 수 있는 다양한 아이디어 창출 기법들을 소개하고 있다. Table II-11. 다양한 아이디어 도출 기법 FISH 기법의 세 번째, 형상화 (Shaping)는 수집된 다양한 아이디어 및 의견을 정량적 기법을 활용하여 가시화하는 것이다. 어떤 결론을 정량화하는 것은 매우 중요한데 보다 객관적인 판단과 결론을 유도할 수 있다. 수집된 아이디어들을 형상화하기 위한 대표적인 기법으로 매트릭스(Matrix), 스코어카드(Scorecard), 버블 소트(Bubble sort)가 있다. 매트릭스(Matrix)는 축이 되는 기준을 먼저 선정한 후, 아이디어들을 해당 축에 맞게 평가한다. 스코어카드는 각각의 기준에 점수를 두고 이를 합계한 종합 점수를 평가하여 우선순위를 결정한다. 한 가지 아이디어씩 직접 비교하여 우선순위를 결정한다. FISH의 마지막 순서인 정리 (Harvesting)는 형상화(Shaping) 결과를 기준에 따라 적절히 분류하여 가시적으로 표현하는 것을 말한다. 이것을 파워포인트 슬라이드로 표현하면 Figure II-38과 같은 형태로 보고될 것이다. Figure II-38. 회의 내용의 정리 모든 회의에서 공통적으로 그리고 결론적으로 도출되어야 할 것은 회의 결과 누가 무엇을 할 것인지 같은 Action Item 들이다. 그것은 이어지는 다음 회의에 대한 약속일 수도 있고 다른 작업(Task)을 지시하는 것이 될 수도 있다. 회의 결과로 도출된 Action Item들은 회의 참석자나 회의 참석자가 속한 부서의 인원이 맡아서 납기 내에 결과물을 만들어내고 그것이 다음 회의에서 다시 어젠다로 다루어지게 된다. Figure II-39. 문제 해결 프로세스와 회의 프레임워크 Figure II-39는 지금까지 다룬 회의 기법인 FISH와 맥킨지의 문제 해결 7단계 기법을 같이 매핑하여 본 것이다. 회의의 목적 및 생산성을 고려한다면 반드시 적용하여 의미 있는 결과물을 도출할 수 있어야 하며, 컨설팅 프로젝트의 회의에서는 필수적으로 따르는 것이 좋다. 아울러 계획(Initiate), 실행(Execute), 평가(Feedback)로 이어지는 회의는 비정기적이며 문제 해결 성격에 가까운 회의일수록 계획 부분을 깊게 다루어야 한다. 이는 잘 설계된 계획이 시행착오를 줄일 수 있기 때문이다. [1] Voice of Customer [2] 인터뷰 기록 측면에서 노트, 비디오, 오디오, 설문 등 다양한 기록의 형태에 대한 고려도 필요하다. [3] 인터뷰 대상자에게 긍정적인 이미지를 심는 일은 매우 중요하]수 있기 때문에 추후 다른 일로 반드시 연락을 주고받을 일이 발생할 확률이 높다 [4] 정량화는 메시지 전달의 방법에서 매우 직관적으로 사실을 보여주는 중요한 기법이다. [5] Ice Breaking. 회의 시 서먹서먹한 관계를 부드럽게 하기 위해 날씨, 화젯거리 등 소소한 이야기들을 나누는 행위 [6] 회의 주최자와 회의 진행자는 회의 어젠다에 따라 다를 수 있다. 조사 단계에서는 회의 진행자의 역할이 매우 중요하다. 06. 커뮤니케이션 스킬(2/3)- 문서화 6.2 문서화(Documentation) 컨설팅 커뮤니케이션 스킬의 두 번째, 문서화(Documentation)에 대해 알아보고자 한다. 컨설팅 프로젝트의 궁극적인 산출물(Deliverables)이 프로젝트 문서라고 할 때 문서화는 사실 가장 중요하다고 말할 수 있다. 문서화 능력은 컨설턴트가 지녀야 할 궁극(窮極)의 필살기 중의 하나이다. 때로는 수십 장의 문서를 100자 이내의 단문으로, 때로는 한 줄의 문장을 수십 장의 문서로 만들 수 있는 능력은 문서화 수준의 최고봉을 말해준다. 그러기 위해서는 배경지식과 메시지를 명확하게 파악할 수 있는 통찰력을 지녀야 한다. 문서가 명확한 주제를 가지기 위해서는 명확한 결론 와 명확한 근거, 그리고 명확한 기대 사항이 있어야 한다.[1] 첫 번째, 명확한 결론은 주제에 대하여 글 쓰는 사람이 의도하는 사항의 핵심을 의미하는 것으로 평가, 판단, 또는 지시하게 된다. 주의할 점은 결론은 주제에 대한 답변의 요약으로 자신이 말하고 싶은 사항의 요약이 아니다. 때에 따라서 상황의 추이를 지켜보면 부대조건을 달아서는 안 된다. 다음의 예를 보자. "A 사업은 디지털 Signage 분야에서 획기적으로 성장이 예상되는 아이템으로 자사는 사업의 수익성과 경쟁 동향을 충분히 분석할 필요가 있다고 생각됩니다 …" 위의 내용은 결론이라고 말하기는 적합하지 않다. 위의 메시지를 보완한다면 성장의 예상 규모, 분석을 위한 향후 활동 등이 같이 표기되는 것이 좋다. 두 번째, 명확한 근거는 결론에 이르게 된 필연성에 대해 상대를 납득시키는 것으로 사실(Fact) 또는 사실에 근거한 판단(Decision)을 제시해야 한다. 동전 뒤집기 식의 근거는 설득력이 없으며, 사실 또는 사실에 근거한 판단만이 명확한 근거로서 의미가 있다. “자사는 시대의 변화를 감지하는 통찰력이 부족합니다. 따라서 시급하게 통찰력을 갖춘 마케팅 부서원들을 뽑아야 합니다…." 위의 내용이 지지를 얻기 위해서는 어떤 사유로 통찰력이 부족한지 사실과 그와 관련된 판단을 같이 제시해야 한다. 마지막으로 기대 사항은 결론에 대해 상대방으로부터 얻고자 하는 것이라 할 수 있다. 상대방이 어떤 행동을 할 것인지 명확히 해야 한다. “자사의 시장점유율이 떨어진 이유는 지금까지 말씀드렸던 바와 같이 신제품 개발 스피드에서 경쟁사에 뒤지고 있기 때문입니다. 이상으로 보고를 마치겠습니다." 위의 내용은 보고를 듣는 경영자에게 무엇을 기대하는 걸일까? 스피드(speed)라는 것에 대한 구체화, 그리고 개선 방향에 대한 사항까지 전달해 주어야 정상적인 논의가 시작될 것을 기대할 수 있다. 결론적으로 문서를 만들 때 다양한 메시지들의 명확화가 가장 중요하며 명확한 결론과 근거, 기대 사항을 잘 정리해야 한다. 비즈니스 문서를 잘 작성하기 위해서는 다음과 같은 4가지 질문에 답을 생각해 보는 것이 좋다. 1) 누구를 위해 문서를 작성하는가? 누구에게 발표하는가? (Who am I writing/speaking to?) 2) 구체적인 목적이 무엇인가? (What is my specific objective?) 3) 어떤 정보가 필수적인가? 어떤 정보가 생략되어야 하나? (What information is essential? What information should be omitted?) 4) 아이디어들을 종합하기 위한 가장 좋은 방법은 무엇인가? (What would be the most effective way to organize my ideas?) 각 질문에 대한 답을 기반으로 비즈니스 문서(business documents)를 작성해야 한다. 비즈니스 문서는 일반 문서와 달리 고유의<NAME>이나 표현법이 있으며 작성 방법도 많이 달라서 훈련받지 않으면 제대로 작성할 수 없다. 비즈니스 문서는 명확한 주제가 있으며 결론, 근거, 기대 사항 등 명확한 메시지가 있어야 한다. 논리적인 구성이 요구되며 간결하고 정확한 표현이 요구된다. 이 모든 것이 상대방의 관점에서 정리되어야 한다. 비즈니스 문서의 상대방은 회사의 지위, 직급에 따라 결정되는데 지위별 주요 관심 포인트는 Table II-12와 같다. 경영진과 중간관리자, 실무진이 관심을 가지는 사항은 모두 다르지만 결국 내가 책임지는 것은 무엇인가로 귀결된다. Table II-12. 지위별 주요 관심 포인트 그런 차원에서 전달되는 주제가 무엇인가는 명확하게 규명되어야 한다. 비즈니스 문서를 받게 되는 당사자의 입장에서 상대방의 방향, 의도를 우선적으로 고려해야 하며 내가 말하고 싶은 것을 확정하여 주제를 단일화하고, 내가 말해야 하는 것을 명확히 하여 주제의 범위를 결정해야 한다. 이를 통해 주제를 구체화시킬 때 의미 있는 비즈니스 문서가 작성된다. 비즈니스 문서가 논리적이기 위해서는 피라미드와 같은 논리 구조를 갖추면서 다음 세 가지를 준수해야 한다. 1. 피라미드의 가장 아랫부분은 근거가 사실임 2. 누락과 중복이 없음 3. 문서의 구성이 결론과 근거의 체계를 가진 피라미드 구성 문서의 주제 하에 각각의 서브 메시지가 존재하고 그것을 구성하는 사실(Facts)과 그에 준한 판단들이 나열되는데, 이것들은 중복과 누락이 없고 논리적 인과 관계를 가지게 구성해야 한다. 이런 피라미드 구조의 문서를 만들기 위해서는 다음과 같은 순서에 따라 메시지를 검토하고 정리하는 것이 필요하다. 1. 메시지 나열(list-up) 2. 동일 개념의 정보끼리 묶음(grouping) 3. 각 그룹의 대표 개념을 한 단계 위에 놓음 4. 각 그룹의 논리적 관계를 고려하여 배열 5. 각 그룹 안에 있는 메시지를 논리적 관계를 고려하여 배열 6. 논지의 중복, 누락, 비약, 데이터의 치우침과 결함 유무 확인 및 수정 1 ~ 6을 수차례 반복하면서 피라미드 구조를 갖춘 문서의 완성도를 높일 수 있다. Figure II-40은 피라미드 구조를 갖춘 문서의 작성의 개념을 나타내보았다. Figure II-40. 문서 작성의 피라미드 구조 문서 작성을 위한 모든 메시지들이 피라미드 구조 하에서 잘 정리되었다면 이제 파워포인트(MS powerpoint)나 키노트(Apple Keynote)과 같은 저작 도구를 활용해 보자. 기본적으로 이 도구들은 매우 다양한 효과를 나타낼 수 있지만 여기서는 구조적인 컨설팅 문서, 즉 비즈니스 문서 작성에 집중하고자 한다. 파워포인트나 키노트를 사용하면 슬라이드(slide)라는 개념이 있다. 빈 도화지라고 생각하면 되는데 저자는 흔히 컨설팅 보고서의 표준<NAME>이라고 알려진 맥킨지 스타일[2]을 소개하고자 한다. Figure II-41은 맥킨지 스타일의 슬라이드 포맷이다. 각 항목별로 좀 더 부연 설명하면 Figure II-41. 문서 슬라이드 포맷 - 맥킨지 스타일 ① Governing Message: 거버닝 메시지는 슬라이드에서 전달하고자 하는 정보의 핵심을 기술한 문장으로 단정적이며 간결하게 표현하여 1줄이 넘어가지 않도록 작성한다. 아울러 전/후 페이지의 연결을 감안하여 전체적인 메시지의 문맥을 조정해야 한다. ② Title: 정보를 총괄하는 어구로 분석 명일 경우가 많다. Title을 통해 차트가 무엇을 말하는지 신속 정확하게 이해할 수 있다. ③ Chart: 표나 그래프를 뜻하며 구체적인 사실을 보여주므로 Governing Message를 지지하는 정보 이다. 상대방을 이해시키는데 활용되며 정량화, 시각화하는 것이 좋다. ④ 각주: 차트에 나타난 정보의 보충적인 주석으로 차트가 방대하게 기술되면 정보의 파악이나 가시성이 좋지 않게 되므로 주요 정보의 전달을 방해하지 않도록 데이터의 안정성, 신뢰성을 위해 별도 표기하는 것이다. ⑤ 자료원: 인용한 데이터의 출처를 나타내며 데이터 신뢰성의 지표가 된다. 차후 검증을 위해서도 필요하다 ⑥ 페이지 번호: 자료 작성 시 작업의 효율화 및 자료의 보관에 유용하다. 브리핑 시에 분량에 대한 정보를 제공하는 효과가 있다 슬라이드에서 차트의 삽입은 ‘일도 일사(1圖 1事)’의 원칙을 따르는 것이 좋다. 즉, 한 페이지에 하나의 개념이 전달되도록 하는 것으로 최대한 직독성과 간결성을 추구하는 것이 좋다. 마지막으로 문서 작성이 끝나면 문서 요약을 해야 한다. ‘Executive Summary’라고 불리는 문서 요약은 피라미드 구조의 문서에서 표현된 거버닝 메시지를 슬라이드 한 장에 정리한 것이다. Figure II-42는 피라미드 구조로 작성된 문서의 요약을 개념적으로 표현한 것이다. 문서 요약은 바쁜 경영진이 전체 보고를 받기 전에 빠른 시간 안에 내용을 파악하는 것이 그 목적이므로 대단히 압축적으로 핵심 메시지만을 담고 있어야 한다. 보고의 정수(精髓)라고 할 수 있다. Figure II-42. 피라미드 구조 문서의 요약 및 사례 지금까지 컨설팅 문서 작성에 대해 살펴보았다. 마이크로소프트웨어의 오피스가 거의 대부분의 민간 기업에서 사용되고 있기 때문에 문서 저작 도구로는 MS 워드와 같은 것을 숙지하는 것이 좋고, 국내 정부 및 공공기관의 문서를 다룰 때는 한글 워드를 사용할 줄 알아야 한다. 그리고 일부 문서의 경우, 파워포인트나 키노트로 작업하게 되는데 이는 거의 프레젠테이션(Presentation)을 위한 것이다. 다음 장에서는 프레젠테이션 방법과 프레젠테이션을 위한 문서 작업에 대해 좀 더 살펴보도록 하자. [1] 연역적 전개를 고려하였다. [2] 맥킨지 컨설팅이 한국 기업들의 보고 문화에 끼친 영향은 지대하다. 보고서 포맷 및 보고 방식 등 거의 표준을 제시했다고 볼 수 있다. 그러나 요즘의 맥킨지 컨설팅 산출물은 반드시 이 포맷을 따르지는 않는다. 06. 커뮤니케이션 스킬(3/3)- 프레졘테이선 이 장에서는 컨설팅 커뮤니케이션 스킬의 마지막 순서, 프레젠테이션(Presentation)을 살펴보도록 하자. 6.3 프레젠테이션(Presentation) 컨설팅 커뮤니케이션 스킬에서 듣기와 인터뷰, 쓰기와 문서화가 연결되어 있다면, 말하기와 프레젠테이션이 또 그런 관계이다. Table II-13은 문서와 프레젠테이션의 상황을 비교해 보았다. Table II-13. 문서와 프레젠테이션의 상황 비교 즉, 비즈니스 문서에 비해 프레젠테이션은 핸디캡(Handicap)이 있고 이를 극복하기 위해서는 매우 전략적이어야 한다. 즉, 핵심과 본질에 집중해야 하며 그것을 표현함에 있어 구조적(Structural)이며 간결한 시각화(Visualization)를 사용하는 것이 좋다. 이를 이용하여 프레젠테이션을 구성할 때는 Table II-14와 같이 서론, 본론, 결론 3단계로 정리한다. Table II-14. 프레젠테이션의 구성 단계 또한, 프레젠테이션의 본문에서 전달하고자 하는 내용은 다음 3가지 요소로 구성된다. 핵심 메시지 (Key Messages) 이야기 구조 (Storyline) 변수(Arguments) 첫 번째, 프레젠테이션 핵심 메시지는 그 목적에 따라 청자(Audience)에게 정보를 제공하거나, 청자를 설득하거나, 청자가 어떤 행동을 유발하게 한다. 두 번째, 이야기 구조는 프레젠테이션의 흐름을 좌지우지한다. 귀에 쏙쏙 들어온다는 표현은 프레젠테이션이 구조적으로 구성되어 있다는 것과 일맥상통(一脈相通) 한다. MECE 원칙에 따라 이야기할 것들을 논리적으로 전개하는 것은 분명 도움이 되지만 분석을 하는 것이 아니기 때문에 하나의 메시지로 귀결되는 형태가 아니라 하나의 주제에서 간결하고 연관성 있는 다양한 메시지들이 도출될 수 있도록 구성하는 것이 필요하다. 세 번째, 변수는 이야기를 전개하면서 그 주장을 보다 객관적인 관점에서 지지하기 위해 사용된다. 단순한 숫자일 수도 있고 숫자가 많을 경우 표나 그래프로 요약하는 것이 필요하다. Table II-15는 이와 같은 3가지 요소를 기반으로 프레젠테이션 슬라이드를 구성해 본 것이다. Table II-15. 프레젠테이션 슬라이드 구성 사례 파워포인트나 키노트 같은 문서 작성 소프트웨어를 활용하여 프레젠테이션을 작성하기 전에 Table II-16과 같은 순서와 구성으로 사전에 작성해 보는 것은 좋은 습관이 될 수 있다. 저자와 같이 4장의 프레젠테이션 준비 템플릿을 활용해 보자. 시나리오는 저자에게 글로벌 기업 A사에서 한국법인장 직에 대해 제안이 와서 A사의 아시아 태평양 본부장, 사업전략 담당(나에게 제안을 하신 분), 인사 담당과 최종 인터뷰를 앞두고 프레젠테이션을 해야 하는 상황이다. Table II-16. 프레젠테이션 준비 템플릿 - 상황의 정리 우선 배경 및 목적, 화자(Audience), 프레젠테이션의 주제, 콘텐츠의 주요 내용을 Table II-16과 같은 한 장의 시트(sheet)로 정리한다. 다음은 Table II-14에서 소개한 구조대로 프레젠테이션의 서론, 본론, 결론을 생각해 본다. 서론, 본론, 결론을 구체적으로 생각해 보면서 각각 소요될 시간도 같이 생각해 본다. 이는 전체 내용을 전달하는 가장 적합한 시간을 계산하기 위함이다. Table II-17. 프레젠테이션 준비 템플릿 - 서론 서론 부분에서는 Table II-17과 같이 자기소개와 주의 환기, 동기 부여, 주요 Point 소개, 질의응답 안내 등을 정리한다. 시간은 임의로 부여했고 상황에 맞게 적절히 정하면 된다. 저자에게 ‘뭐 이런 것을 다 만드냐?’고 질문할 수도 있겠지만 이렇게 준비하는 것과 그렇지 않은 것은 프레젠테이션의 완결성에서 상당한 차이가 난다. 또한, 프레젠테이션 전문가들도 이런 식의 준비를 수없이 시행하고 그것이 머릿속에 있기 때문에 굳이 적지 않을 뿐이다. 프레젠테이션 서론을 위한 시트가 완료되면 본문을 위한 시트도 작성해 보자. 본문은 서론 준비 시트에서 정의한 핵심 내용을 적어보는 것인데 나중에 설명하겠지만 차트(표나 그래프)를 그려서 표현할 수도 있겠지만 이 단계에서는 그냥 텍스트로 죽 적어보는 것이 좋다. Table II-18. 프레젠테이션 준비 템플릿 - 본론[1] 본문에 대한 시트 정리가 끝나면 이제 마지막 결론에 대한 시트를 정리해 보자. Table II-19. 프레젠테이션 준비 템플릿 - 결론 프레젠테이션 시간과 관련해서는 중요한 황금률(Golden Rule)이 있다. 바로 18분을 넘기지 않는 것이다. 이것은 일종의 골디락스(Goldilocks)[2] 타임이라고 할 수 있는데 그 유명한 TED[3]도 어떤 연사가 발표하더라도 시간을 18분에 맞추고 있다. 이는 일종의 뇌과학에서 이야기하는 인지 밀림(Cognitive Backlog) 현상[4]을 방지하기 위한 것인데 굳이 그런 이론을 언급하지 않아도 이 시간을 넘어서면 지겨워서 집중하지 않게 된다. 많은 이들의 호응을 얻은 세계적으로 알려진 명연설, 프레젠테이션들은 거의 18분을 넘지 않는 것으로 알려져 있다. Figure II-43. 골디락스 동화와 TED 프레젠테이션을 위한 전체 시나리오를 시트와 함께 정리하여 스토리라인을 보완한 후에는 문서 저작 소프트웨어를 활용하여 프레젠테이션을 작성한다. 프레젠테이션의 내용이 많아지면 포스트잇(PostIt)과 같은 착탈식 메모지를 사용해서 스토리라인을 분해, 재배치하여 정리하고 프레젠테이션의 구조를 체계적으로 생각해 보는 것도 좋은 방법이다. 제목과 배경, 목적이 포함된 서론, 각 주제별 메시지를 담고 있는 본론, 프레젠테이션 요약 및 다음 단계에 대한 소개를 담고 있는 결론의 구성은 동일하다. Figure II-44. 포스트잇을 이용한 스토리라인 구성 스토리라인의 내용 보완과 흐름, 메시지 전달과의 관계 등이 만족스러우면 역시 문서 저작 도구를 활용하여 내용을 정리한다. 슬라이드는 크게 5가지 종류로 구성되는데 다음과 같다. 표지 슬라이드 목차 슬라이드 간지 슬라이드 내용 슬라이드 보조 슬라이드 표지 슬라이드는 프레젠테이션 제목, 발표자, 날짜, 배포나 공유 범위 등이 서술된다. 목차 슬라이드는 프레젠테이션의 목차를 보통 3수준까지 표시하며, 간지 슬라이드는 장이 바뀔 때 빈 공백의 슬라이드로 다음 장으로 넘어감을 알리는 역할을 한다. 마지막 장은 EOD(End of Documents)라고 표기하기도 한다. 내용 슬라이드는 거버닝 메시지(Governing Message)와 표나 그래프 같은 차트(Charts)가 포함되며 보조 슬라이드는 내용 슬라이드와 링크(link) 시켜 필요시 볼 수 있게 한다. 결국 이런 다양한 슬라이드는 Table II-16부터 Table II-19까지 우리가 적어보았던 프레젠테이션 내용을 옮겨놓은 것으로 프레젠테이션 스토리를 지지하도록 구성되어야 한다. Figure II-45. 프레젠테이션 슬라이드의 구성 Break #9. 나이팅게일과 그래프 그래프(Graph)는 차트(Charts)의 한 종류이다. 정량적인 데이터를 한눈에 알아보기 쉽게 표현하는 일종의 그림이라 할 수 있는데 많은 사람들이 사용하여 정형화된 것부터 아주 창의적인 형태의 것까지 매우 다양하다. 그래프 사용의 가장 큰 장점은 대용량의 통계 데이터를 시각적으로 표현하여 새로운 시사점을 찾을 수 있게 도와준다는 것이다. 실제로 제1차 세계 대전 때 나이팅게일(Florence Nightingale. 1820~ 1910)은 Figure II-46과 같은 그래프를 그렸는데 이를 '로즈 다이어그램(Rose Diagram)'이라고 한다. Figure II-46. 나이팅게일이 사용한 그래프 파이(Pie) 차트와 유사하지만 각도의 크기뿐 아니라 면적의 크기에도 의미가 부여됨으로 2차원 그래프이지만 다차원 데이터를 표현한, 엑셀이 없었던 당시의 상황으로 보면 매우 창의적인 그래프라고 할 수 있다. 나이팅게일이 이런 그래프를 그리게 된 동기는 병원에서 간호 활동을 하는 도중 전쟁에서 부상당해서 죽는 것보다 병원의 열악한 위생 환경에서 제대로 치료나 관리가 되지 못해 죽는 사람들이 훨씬 많다는 것을 알고 이를 개선해 보고자 노력했으나 제대로 지원이 되지 않자, 이를 위한 예산 마련을 위해 데이터를 축적하고 이를 표로 만들어 의원들을 설득하여 지원을 받았다고 한다. 이런 나이팅게일의 노력 덕분일까? 오늘날 경영 컨설팅에서는 많은 사람들이 주로 사용하는 그래프가 정해져 있다. 즉, 목적과 용도에 맞게 그래프를 사용하면 커뮤니케이션하기 훨씬 쉬운 것이다. Table II-20은 비즈니스 문서에서 많이 활용하는 그래프를 소개하였다. 분석의 유형과 활용 방법, 사례 그리고 적용 가능한 그래프 형태를 정리한 것으로 이를 숙지하면 데이터를 보다 의미 있게 다룰 수 있을 것이다. Table II-20. 보고서에 자주 사용하는 그래프 지금까지 논리적 사고, 문제 해결 기법, 커뮤니케이션 스킬 등 기본적인 컨설팅 스킬에 대해 살펴보았다. 컨설턴트 개인이 사고하는 방법, 이슈나 문제에 접근하는 방법, 고객의 생각을 듣고, 글로 적고, 말하는 방법은 컨설팅 업무의 전부라고 말할 수 있다. 훈련과 연습이 필요하며 지속적인 반복은 분명히 컨설팅 실력을 향상시켜준다. 어떤 로직 트리들은 많은 사람들에게 그 효용성을 인정받아 도구나 기법처럼 사용되기도 하고 지속적으로 발전해나가기도 한다. Part III에서는 이런 컨설팅 스킬을 기반으로 하는 컨설팅 도구와 기법에 대해서 알아보도록 하자. [1] 연봉 협상을 이렇게 한다는 것보다는 프레젠테이션에서 각 포인트를 정량적 요소와 함께 명확히 해야 한다는 것을 전달하는 내용이다. 연봉협상 스킬은 관련 전문가나 헤드헌터와 상담하기를! [2] 1990년대와 2000년대 중반까지의<NAME>황을 이끈 주역인 그리스펀(Alan Greenspan. 1926 ~ 현재)이 이끈 미국의 경제 호황기를 골디락스 시대라고 함. 영미권에서 꽤 유명한 '골디락스와 곰 세 마리' 동화가 있다. '골디락스'라는 소녀가 숲속 통나무집에 들어갔는데 곰 가족이 수프를 끌 여놓았고 골디락스가 이걸 큰 접시, 중간 접시, 작은 접시에 나누어 담고 맛을 보았더니 하나는 너무 뜨겁고, 하나는 너무 차갑고 중간 접시 수프가 딱 먹기 좋더라라는 내용의 동화에서 너무 뜨겁지도 차갑지도 않은 안정적으로 성장하는 경제를 표현할 때 사용함. [3] www.ted.com 기술(Technology), 오락(Entertainment), 교육(Education)을 주제로 크리스 앤더슨(Chris Anderson. 1961 ~ 현재)의 기획으로 미국의 비영리재단이 운영하는 강연회. '세상에 알릴 가치 있는 아이디어(Ideas worth spreading)'를 기치로 좋은 주제를 가진 프레젠테이션 콘텐츠를 인터넷을 통해 무료로 배포하고 있다. 영어 공부하기에도 좋다. [4] 일정 시간이 지나면 최근의 정보가 기존의 정보를 밀어내는 현상 060 PART III. 컨설팅 도구와 기법 Part III에서는 Part II를 통해 습득한 컨설팅 스킬(Consulting Skills)을 좀 더 발전시킨 컨설팅 도구와 기법들을 다루고자 한다. 대부분의 컨설팅이 현황을 분석하여 문제점과 개선 포인트를 발견하고 비전이나 전략의 개선 방향, 이행 계획을 제시하는 것이기 때문에 컨설팅 도구와 기법은 기업 내 전략 수립이나 마케팅, 신사업 개발 등에서도 다양하게 활용할 수 있다. Figure III-1. 컨설팅 도구와 기법 로드맵 Figure III-1은 Part III에서 다루고자 하는 도구와 기법의 로드맵(Roadmap)으로 기업이 속한 산업과 시장, 경쟁 환경을 분석하고 기업 고객이나 일반 소비자의 Needs를 파악하며 제품이나 서비스의 수익성을 검토하고, 기업 경쟁력의 토대가 되는 역량 등을 검토하여 시사점과 향후 개선된 모습을 위한 대안이나 전략을 수립하는 데 도움을 줄 것이다. 도구와 기법의 활용과 관련해서는 다음과 같은 이야기들이 있다. 1. 동일한 도구와 기법을 사용하지만 서로 다른 결과를 가져올 수도 있다. 2. 도구와 기법이 만병통치약은 아니다. 첫 번째 메시지는 상황에 맞는 도구와 기법을 사용해야 함을 의미한다. 수많은 도구와 기법이 있지만 모두 나름의 가정(assumption)이 있으며 그 가정을 받아들일 수 없는 경우에는 그 도구를 사용하면 안 된다. 그런 경우, 예상과 전혀 다른 결과가 나올 것이다. 두 번째 메시지는 수많은 컨설턴트, 경영학자 등<NAME>들이 수 십 년 간 쌓아온 지식과 경험으로 정제된 것이 이제부터 설명할 도구와 기법들으로써 나름의 논리를 가지고 잘 만들어진 것이지만 어떤 경우는 투입한 노력(Efforts) 대비 만족스럽지 못한 결과가 나오는 경우도 있다. 저자의 경우, AHP[1]가 그런 경험을 주었다. 전문가를 대상으로 AHP를 위한 설문도 준비하고 시간을 들여서 의견을 받아 매트릭스를 돌렸고 바쁜 프로젝트 일정에서 당시 그 노력이 상당했다. 그런데 노련한 관련 업무 전문가들과 인터뷰를 하였는데 그 내용이 AHP 결과와 크게 상이하지 않아 역시 전문가들의 통찰력(insight)이 더 중요하다는 교훈을 얻기도 하였다. Part II에서 논리적 사고를 이해하기 위해 로직 트리(Logic Tree)를 배웠다. 많은 사람들이 자주 사용하는 로직 트리는 업무와 결합하여 MECE Pockets이라는 간단한 도구로 발전하기도 하였다. 그런 것들이 분석(Analysis)의 도구로 사용되고 다양한 분석 도구들이 하나의 주제에서 결합되면 기법(Analytics)이라고 말할 수 있다. 이어지는 Part IV에서 상세히 다루겠지만 이런 다양한 도구와 기법들이 프로세스와 연계하여 템플릿(Template)화되면 그것을 방법론(Methodology)이라고 한다. 그러한 컨설팅 수행 체계를 익히기 위해 이제부터 다양한 컨설팅 도구와 기법들에 대해 상세히 살펴보도록 하자. Break #10. MECE Pockets Part II에서 살펴본 것처럼 MECE 개념은 상호 간에 중복되지 않고 전체로서 누락이 없는 상태(Mutually Exclusive Collectively Exhaustive)를 의미한다. 그러나 실제 현실 세계에서 MECE 하게 구분하는 것은 결코 쉽지 않다. 그래서 등장한 개념이 LISS이다. Figure III-2. MECE와 LISS의 개념 LISS는 선형대수학(Linear Algebra)의 개념이기도 한데 MECE던 LISS던 두 가지 모두 동일 차원에서 중복이 없어야 함을 의미하는 것으로 MECE는 빠진 것이 없는지, LISS는 중요 과제를 명확히 하는 것이 중요하다. 컨설팅 분석에서 이런 MECE 관점과 LISS 관점에서 널리 사용되는 것들을 'MECE Pockets'이라고 부르는데 다음 나열된 MECE Pockets들은 기억해두면 논리적 사고 전개에 많은 도움을 줄 것이다. 1. 사업 환경분석(PEST): 정치적(Political), 경제적(Economic), 사회문화적(Sociocultural), 기술적 (Technological) 2. 사업 환경분석(3C): 고객(Customer), 경쟁사(Competitors), 자사(Corporate) 3. 전략 수립 SWOT: 강점(Strength), 약점(Weakness), 기회(Opportunity), 위협(Threats) 4. 전략 수립 7S: Strategy, Structure, System, Staff, Skill, Shared Value, Style 5. 전략 수립 비즈니스 시스템: 연구개발, 생산, 유통, 판매, 서비스 6. 전략 수립 SPOT: Strategy, People, Organization, Technology 7. 전략 수립 STAR: Strategy, People, Process, Rewards, Structure 8. 경영진단 PPT: People, Process, Technology 9. 마케팅 4P Mix: 제품(Product), 가격(Price), 유통(Place), 홍보(Promotion) 10. 마케팅 4C: 소비자(Consumer), 비용(Cost), 편의성(Convenience), 커뮤니케이션(Communication) 11. 디지털 비즈니스 4C: Contents, Community, Communication, Commerce 12. 역할 행동 CARE: Capability, Authority, Responsibility, Evaluation 13. 경쟁 분석 5 포스: 경쟁자, 공급자, 구매자, 대체재, 신규 진입자 14. 프로세스 요건: 기준, 절차, 지식/스킬, 장비/도구 15. 프로세스의 단계 IPO: Input, Process, Output 16. 현장 Trouble 4M: Man, Machine, Material, Method 17. 제품 경쟁의 3요소 QCD: Quality, Cost, Delivery [1] Analytic Hierarchy Process 07. 경쟁 및 산업분석(1/4) 컨설팅에서 경쟁 및 산업 분석은 사업 환경 및 배경을 이해하기 위해 수행하는 중요한 분석이다. 크게 거시환경분석 즉, 메가트렌트(megatrend) 분석을 통해 거시 관점에서 기업에게 영향을 주는 정책, 경제동향 및 기술 트렌드 등을 조망하고, 3C라고 하여 고객(Customer), 경쟁(Competitors), 자사(Corporate) 관점에서 시사점을 분석한다. 도구와 기법의 관점에서 보면 시장의 규모(Size)와 성장률(Growth)을 파악하는 시장 분석, 경쟁사 프로파일링(profiling) 및 포지셔닝(positioning)을 통해 경쟁사의 현황을 파악하는 경쟁 분석, 기업 내 가치사슬 분석과 재무비율 분석을 통해 기업의 현재 모습을 확인할 수 있다. 도구와 기법의 관점에서 분석 결과 도출되는 정량적/정성적 메시지를 잘 정리하여 활용하는 것이 중요하며 특히, 핵심 분석(Core Analytics)은 컨설팅 프로젝트에서 반드시 수행하는 것이 좋다. Figure III-3은 경쟁 및 산업 분석의 도구와 기법들이 사업 환경 분석에서 어떻게 활용되고 있는지 보여준다. Figure III-3. 경쟁 및 산업 분석 로드맵 7.1 PEST 분석 시장이나 산업을 평가하기 위해 수행하는 외부환경 분석은 거시적(Macroscopic) 관점에서 시장 환경을 조망하는 것 즉, 메가트렌드(megatrend)를 다루게 되는데 가장 많이 사용되는 분석 기법이 ‘PEST 분석’이다. PEST 분석이란 외부 환경을 정치, 경제, 사회문화, 기술 관점에서 조망하고 시사점을 찾아내는 것으로 PEST는 Table III-1과 같은 개념을 내포한다. Table III-1. PEST의 개념 PEST 분석은 메가트렌드 분석을 위한 다음과 같은 질문들에 대한 답이라 할 수 있다. 각국의 정부가 주장하는 정책 기조는 무엇인가? 공통점이 있는가? 변화를<NAME>는 트렌드는 무엇인가? 변화의 속도는 얼마나 빠른가? 트렌드가 기존 사업에 끼치는 영향은 무엇인가? 새롭게 또는 기존 사업에 추가적인 기회를 제공하는 것이 있는가? 현재와 향후의 핵심기술은 무엇인가? 기술 로드맵[1]은 어떻게 변화하고 있는가? 또한, PEST 분석은 다음과 같은 장점과 단점이 있다. Table III-2. PEST 분석의 장점과 단점 Table III-3과 Figure III-4는 PEST 분석 사례이다. 일반적으로 컨설팅 PM이 Table III-3과 같이 분석 가이드를 주면, 컨설턴트들이 분석 자료를 수집하고 내용을 검토하여 Figure III-4와 같은 관점별 분석을 수행하고 시사점을 도출한다. Figure III-4. PEST 분석 가이드 및 사례 PEST 분석 - 정치적 관점(Political perspective) PEST 분석 - 경제적 관점(Economic perspective) PEST 분석 - 사회문화적 관점(Sociocultural perspective) PEST 분석 - 기술적 관점(Technological perspective) PEST 분석은 거시환경분석 프레임으로 유용하다. 그런데 전략기획이나 컨설팅에서 환경분석 작업처럼 애매한 작업이 없다. 많은 노력을 투입했는데 시사점이 내가 의도하던 것과 다른 경우가 허다하다. 그래서 분석 대상이나 내용이 발산하지 않도록 가설을 잘 수립하고 비용 효율적으로 일하는 것이 좋다. 다음은 거시환경 분석에 참고할 만 사이트이다. 랜드연구소(The RANDCorporation. www.rand.org) 전미경제조사국(NBER. www.nber.org) 한국은행(www.bok.or.kr) 기획재정부(www.mosf.go.kr) 1.2 시장 분석 시장의 크기(size) 및 점유율(growth) 분석이란 시장/세그먼트(segment) 크기와 성장을 정량화하는 것으로 Value 측면에서 특정 기간 동안의 매출(Revenue)과 수익성(Profitability)으로 표현하거나 Volume 측면에서 특정 기간 동안 생산된 단위 생산량으로 표현된다. 비즈니스 컨설팅에서 시장의 변화하는 모습을 파악하고 이를 정리하여 보여주는 것은 매우 중요한데 시장의 크기와 점유율 등이 동적으로 변화하고 있음을 알려주고, 수년 동안의 사업이나 시장 세그먼트의 변화 내역을 표현한다. 즉, 과거 수 년의 모습을 보여주고(Historically), 미래 수 년의 모습을 추정한다(Forecasting). 기업 입장에서는 시장의 크기를 얼마나 점유하고 있느냐는 경쟁의 판도를 파악하는데 매우 중요하다. 그래서 시장점유율(Market Share)이라는 측정을 중요하게 생각한다[2]. 시장 점유율은 Value 측면에서 순 매출이나 순이익의 비율을 평가하며 Volume 측면에서 단위당 생산량의 비율로 평가한다. 그래서 사업의 경쟁력을 평가하기 위해 절대적(Absolute) 혹은 상대적(Relative) 시장 점유율을 측정하고자 한다. 이는 사업(혹은 세그먼트)의 매력도(Attractiveness)를 평가하기 위함인데 사업의 크기(혹은 세그먼트의 크기)가 클수록 매력적이며, 성장 속도나 기울기 등은 시장의 질(Quality)을 평가할 수 있는 좋은 잣대가 된다. 또한, RMS[3]등 다른 분석 기법들과 결합하여 경쟁 우위[4]를 평가하는 좋은 도구가 될 수 있다. 또한, 시장분석 기법은 다음과 같은 장점과 단점이 있다. Table III-4. 시장 분석의 장단점 이와 같은 시장 분석은 크게 두 가지 작업을 하게 된다. 첫 번째, 공개된 데이터를 이용해 시장의 크기를 분석하고, 두 번째, 각 기업 고유의 시장과 사업의 크기를 산정, 비교하는 일이다. 첫 번째, 시장의 크기를 산정하는 방법은 다음 순서를 따른다. 1. 시장의 크기를 정하는 데이터 원천(Data Source)를 이해한다. 2. 데이터 원천의 신뢰성을 검증한다. 3. 2 ~ 3회 상호 검증하여 본다. 4. 시장 크기의 트렌드를 이해한다. 핵심 원인도 같이 파악한다 5. 고객 또는 해당 산업 전문가들과 같이 검증한다 이 중 데이터 원천의 신뢰성을 검증하는 일이 가장 중요한데, 많은 시장조사업체들이 자체 데이터를 확보하기 위해 취하는 방법은 해당 산업에 속한 기업들을 방문하여 데이터를 제공받는 것이다. 해당 데이터는 대부분 기업의 실적과 관계되므로 각 기업들은 법적으로 또는 의무적으로 시장조사업체들에게 그런 중요 데이터를 제공할 필요가 없기 때문에 부풀려서 제공하기 쉬우며 시장조사업체도 이를 100% 신뢰하지 않기 때문에 나름의 가중치로 보정한다. 두 번째, 각 기업 고유의 시장과 사업의 크기를 산정하는 것은 다음 순서를 따른다. 1. 시장의 크기를 정하는 주요 요인들(drivers)을 인지한다. 예를 들면, 전체 사업 또는 세그먼태 내의 고객수, 제품 또는 서비스 단위의 개수, 고객 인당 평균 구입 하는 제품 또는 서비스 개수 등 2. 미래 시장의 크기를 결정할 수 있는 주요 요인들(drivers)을 인지한다. 예를 들면, 관련 거시경제 동향, 고객 수요에 영향을 미치는 요인들의 변화, 고객 수의 증감, 인당 구매량 의 변화 등 3. 시장의 크기를 결정하는 방법론을 선정하는데, ‘Top-down 방식’과 ‘Bottom-up 방식’이 있다. Top-down 방식은 거시 변수(Macro variables) 즉, 유관 사업의 규모를 합하여 시장의 크기를 추정 하는 방식이고 Bottom-up 방식은 미시 변수(Micro variables) 즉, 고객의 개수로부터 시장의 크기를 추정하는 방식이다. 그 외 상품 및 서비스의 개수, 고객당 평균 구매단가 같은 것들이 시장의 규모를 파악 하는 데 도움을 줄 수 있다. 방법론 차원에서 Top-Down 또는 Bottom-Up 이지 실제 업무에서는 2가지 방식을 모두 적용하여 추정된 시장 규모의 정확성을 보완한다. 4. 이제 시간 변수를 고려하여 시장의 크기가 어떻게 변화했는지 계산한다. 가장 많이 이용하는 방법이 연평균 성장률(CompoundAnnual Growth Rate: CAGR)을 이용하는 방법이다. GAGR의 개념은 매년 성장률은 들쑥날쑥하겠지만 오랜 기간을 두고 일정한 비율로 성장한다고 가정하고 얼마나 성장하였는가 계산하는 것이다. 쉽게 말하면 ‘자대고 줄긋기’이다. 예를 들어 2010년 1,500억 원, 2015년 2,100억 원의 매출을 올린 기업이 5년 동안 얼마나 성장했는지 CAGR을 구해본다면 이는 다음과 같이 쓸 수 있다. 1500 *(1+CAGR)^5 = 2100; 이 식을 CAGR 관점에서 풀어보면 CAGR = (2100/1500)^(1/5) -1 이를 일반화하면 아래와 같이 표현할 수 있다. 또한, 엑셀의 rate 함수를 사용하면 보다 쉽게 계산 가능한데 다음과 같다[5]. CAGR = rate(기간, 0, -첫해 값, 마지막 해 값) = rate(5,0, -1500,2100) 5. 그 외 고려할 만한 것은 물가지수(CPI)[6] 등이다. 보정이 필요할 경우 반영하면 된다. 다음은 시장 분석을 위해 생각해 볼 수 있는 질문들이다. 기업이 속한 시장의 기본적인 구조와 특징은 무엇인가? 예. 기업 수, 고객수 산업에 속한 각 기업들의 매출액 및 그 종합은 얼마인가? 제품에 대한 각 기업들의 평균 구매단가는 얼마인가? 예. IT 투자비, 제품 구입비 산정된 시장은 어떻게 세분화할 것인가? 예. 고객별(By Customer), 지역별(By Regions), 제품별(By Products) Figure III-5는 미국 에너지부(DOE)에서 제공하는 매년 구축되는 기저전력, 분산배 전 현황, 산업이나 상업시설의 전력 구매량 등의 데이터를 참고하여 산정한 북미 전력 시장의 규모 산정 사례이다. Figure III-5. 시장 규모의 산정 사례 - 북미 전력사업 예시 Break #11. 시장의 역동성 비즈니스 컨설팅에서 시장의 역동성을 인정하고 이를 보여주는 것은 대단히 중요하다. 많은 분석 기법들이 ‘예쁘고 멋지게’ 데이터를 정리해낼지는 몰라도 순간의 단면(snapshot)을 보여주는 것에 그치기 때문에 실제 실시간 변화를 겪으며 사업 추세를 살펴야 하는 경영의 현장에서는 노력 대비 그리 큰 의미를 부여하기 어렵다. 시장의 크기를 산정하는 일도 이와 비슷한데, 시장의 크기를 산정하고 그 변화를 파악하는 일은 수익의 원천이 되는 업(業)의 기본 판을 알고자 하는 것이므로 정말 중요하지만, 신뢰할 수 있는 데이터를 얻기가 매우 어렵다. 전문시장조사를 이용하는 것도 결국 리서치 회사들이 자사를 포함해 경쟁사 등 해당 산업의 정보를 취합하여 산정해 내는 것이기 때문에 성숙된 산업의 경우, 업계 모임에서 공유되는 데이터와 별 차이가 나지 않는다(다만, 이 경우는 경쟁사와의 정보 교환이 담합의 오해를 살 수도 있기 때문에 유의해야 한다). 또한, 시장의 매력도(attractiveness)를 구할 때 단순히 시장의 크기와 점유율만으로 평가하는 것은 지극히 위험한 일이다. 실제 기업의 입장에서 가장 중요한 매력도는 수익이며 시장의 성장성이기 때문이다. 아울러 특정 시점만의 비교는 그 시장의 잠재성을 파악하기 어렵게 만드는 경향이 있다. 따라서 시장 분석을 할 때에는 시간 변수를 잘 고려해야 한다. 만일 시간 변수를 고려하기 어려운 경우에는 상황별 시나리오를 고려한다. 시장의 크기와 더불어 사업 목표를 수립할 때에는 소위, TAM(Total Addressable Market or Total Available Market)을 산정해야 한다. TAM은 잠정적으로 산정된 전체 시장의 크기(Market Full Potential)를 놓고 마케팅과 영업 활동의 집중도를 공격적(Aggressive), 일반적(Moderate), 보수적(Conservative)으로 반영한 시나리오를 설정하고 이를 반영한 시장의 크기와 사업목표를 산정하는 방법이다. 일반적으로 사업목표를 수립할 때, 전체 시장 대비 얼마의 점유가 가능하다는 것을 동적으로 표현하면서 사업 의지도 같이 보여주는 용도로 많이 활용한다. 다만, 시나리오가 정교해지려면 ‘그냥 열심히 하겠습니다’를 ‘Aggressive’로 반영하거나 하지 말고 마케팅이나 영업 자원을 정량화하여 그들의 투입 규모에 비례해서 어떻게 시장 규모와 사업 목표가 변경되는지 시나리오를 반영해야 할 것이다. Figure III-6. Total Addressible Market 적용 사업목표 - 미국 발전사업 사례 [1] IT 리서치 기업인 가트너그룹(www.gartner.com)은 기술 성숙도에 따라 기술의 포지셔닝을 추적하는 'Hype Cycle'이라 부르는 기술 로드맵을 매년 업데이트한다. TableIII-4의 기술분석 사례도 가트너그룹의 Hype Cycle을 예시로 하였다 [2] 시장 점유율이 중요하다는 관점은 규모의 경제가 유용한 시장 또는 산업이거나 B2C 사업일 경우가 많다. B2B 사업에서는 시장 점유율보다는 고객 점유율을 더 중용하기도 한다. [3] Relative Market Share 상대적 시장 점유율 [4] Competitive Advantage [5] 첫해의 값에 음수 부호를 잊지 않는 것이 중요하다 [6] Customer Price Index 07. 경쟁 및 산업분석(2/4) 경쟁 및 산업 분석의 첫 번째 순서로 메가트렌드 분석을 위한 PEST 분석과 시장의 크기를 산정하는 방법, 성장률을 계산하는 방법 등에 대해 알아보았다. 오늘은 경쟁 분석에 대해 알아보자. 1.3 경쟁 분석 경쟁 분석의 기본은 '경쟁사 프로파일링(Competitors Profiling)'과 '경쟁사 포지셔닝(Competitors Positioning)'이다. ‘경쟁사 프로파일링’이란 경쟁 기업의 정보(Filmography)를 확인하고 이를 통해 시사점을 도출하는 것을 말하며, ‘경쟁사 포지셔닝’은 각 기업 나름의 분류 기준을 가지고 경쟁사를 의미 있는 매트릭스에 배치하고 해당 상황에서 통찰력을 얻는 것을 말한다. 복수의 경쟁사를 다룰 경우, 경쟁사 매트릭스를 작성하고 분석하는데 BCG 매트릭스[1]를 응용할 수도 있고 관련해서는 다양한 기법들이 있다 Figure III-7. 경쟁사 분석 사례 – BCG 매트릭스 활용 경쟁사 프로파일링은 경쟁사 정보를 한눈에 파악하는 것이 가장 중요하기 때문에 신뢰할 수 있는 정보 원천(Source)과 함께 다음과 같은 정보를 반드시 포함하는 것이 좋다. 기업의 배경(Background): 경쟁사의 창립 시기, 주요 역사, 지배 구조 등 기업의 전략(Corporate Strategy): 경쟁사의 비전, 중장기 전략, 사업 전략 등 재무 정보(Financials): 매출, 영업이익 등 각종 수익성 지표 조직/인사(Personnel): 인력 현황, 맨파워 등 제품(Products): 제품 라인업(line-up), 연구개발 역량 등 시설(Facilities): 공장, 생산 역량 등 마케팅/영업(Marketing/Sales): 마케팅 및 영업 주요 전략, 최근 실적 등 또한, 경쟁사 프로파일링은 Table III-5와 같은 장단점이 있다. Table III-5. 경쟁사 프로파일링의 장단점[2] 경쟁사 프로파일링을 통해 기본적인 정보가 취합되면 이어서 경쟁사 포지셔닝을 해 볼 수 있다. 경쟁사 포지셔닝은 일반적으로 다음과 같은 순서로 진행한다. (1) 경쟁사의 기본 정보를 수집한다. 이를 위해서 신뢰할 수 있는 경쟁사 정보를 확보하는 노력이 필요하며 경쟁사가 상장 기업이라면 기업공시 정보를 이용하는 것이 가장 좋다. 한국 기업의 경우, 금융감독원에서 제공하는 ‘전자공시시스템’ [3]을 통해 기업의 사업 현황 즉, 매출 및 영업 이익 등 재무정보와 주요 이벤트의 추진 현황을 파악할 수 있다. 한편, 유한회사나 비상장기업의 경우, 해당 기업의 홈페이지나 별도의 전문조사 기관을 이용해야 한다. 해외 사업을 위해 외국 기업의 정보를 알아보아야 하는 경우, 해당 기업이 미국 증시에 상장되어 있다면 미국 증권 거래위원회[4]가 제공하는 정보들이 매우 유용하다. 특히 Edgar[5]를 통해 제공되는 10K와 같은 기간별 보고서들은 해당 기업의 현황을 상세히 파악하는데 많은 도움을 준다. 다만, 이런 공시 정보의 한계가 있다면 모두 과거의 데이터 또는 정보라는 점이다. 따라서 경쟁사 정보는 공시 정보를 기반으로 하되 수시로 업데이트되어야 한다. Figure III-8. 미국 증권 거래위원회가 제공하는 기업공시정보 (2) 공시정보를 기반으로 전략적 의의를 부여할 수 있는 항목을 정의하고 추가 상세 분석을 수행한다. 이를 기반으로 포지셔닝 맵(positioning map or perceptual map)을 구성한다. Figure III-9는 자동차의 가격과 품질로 사분면을 구분하고 완성차 기업들의 포지셔닝 한 사례이다. 2017년 현재는 기업의 포지션이 많이 변했을 것 같다. 여전히 독립 브랜드를 사용하지만 BMW와 MINI는 합병되어 한 회사 소속이다. Figure III-9. 경쟁사 포지셔닝 - 자동차 산업 사례 Part III에서 설명할 여러 가지 컨설팅 도구와 기법에서 그런 언급을 계속하겠지만 포지셔닝 맵의 작성도 개인적으로는 그렇게 비용 효율적인 것이라고 생각되지 않는다. 현재 경쟁하는 산업에 어떤 기업들이 있는지 파악하기 위해 일회적으로 확인할 뿐이고 실시간 현황을 반영하지 못하기 때문이다. 물론, 이 포지션이 실시간으로 바뀔 정도로 불안한 산업을 없을 것이지만 노력 대비 So-so라고 밖에 생각이 들지 않는다. 다만, 구분 또는 비교 척도를 실적 등 정량적 평가로 대체하고 버블 차트 같은 것으로 표현 가능하다면 조금 더 현실적이 될 수 있을 것이다. 사실 그런 노력으로 BCG 매트릭스 같은 것이 나왔지만 한계는 여전하다. Break #12. Apple의 포지셔닝 이야기 포지셔닝은 인지(perception)의 문제이다. ‘고객이 기업의 제품을 어떻게 생각하느냐?’는 매우 중요하다. 전형적인 B2C 포지셔닝 가이드[6]가 있고, 브랜드 전략이나 광고 등으로 그것을 실현하고자 한다. B2B 사업에서는 제품의 차별화된 특성이나 이미지를 효과적으로 전달하는 기업가치 제안(Value Proposition)이 매우 중요하며, 마케팅 믹스(Marketing Mix)를 통해 지속적으로 고객과 커뮤니케이션할 수 있어야 한다. 애플(Apple)의 경우, 1997년 다시 경영에 복귀한 스티브 잡스(Steve Jobs. 1955 ~ 2011)가 가장 먼저 고민했던 것이 애플의 ‘포지셔닝(Positioning)’이었다. 당시 애플은 IBM과 경쟁하기 위해 기업 내부 프로세스 및 공급망, 브랜드 이미지 등 거의 모든 부분을 잡스 이전과 완전히 다르게 구축하고 있었는데, 스티브 잡스는 복귀 후 이것들을 모두 바꾸면서 애플의 존재 이유에 대해 다시 한번 고민하게 되었다. 그들의 하드웨어나 운영체제(OS)는 경쟁 제품보다 우수했고 그래픽과 같은 특정 부문에서는 비교할 수도 없이 강력했지만, 스티브 잡스는 그런 부분에 대한 어필보다는 보다 근본적인 산업에서의 애플의 존재 의의와 기업의 본질에 대해 고민하고자 하였다. 이 과정에서 스티브 잡스는 마케팅팀에게 다음과 같은 질문들을 던졌다 [7]. 우리 고객들은 우리를 알기 원한다. 애플(Apple)은 누구인가? 그리고 우리는 무엇을 대표하는가? 우리는 이 세상 어디에 속해있는가? 다소 철학적으로 들릴 수도 있겠으나 스티브 잡스와 당시 애플의 마케팅팀은 위의 질문에 대해 다음과 같은 답을 도출했다. “열정을 가진 사람들은 세상을 보다 나은 곳으로 바꾸는 것이 가능하다” 이 문장을 기업의 핵심가치로 취하였고, 이후 그 유명한 캐치프레이즈 ‘Think Different!’가 탄생하였다. 이를 계기로 애플은 제2의 도약을 이루게 된다. Steve jobs 'Think Different' and Ad. 애플이라는 기업의 특징, 개인에 대한 감수성이 민감하게 작용하는 B2C 사업이라는 특성을 감안하더라도 포지셔닝에 대한 설명은 충분할 것이다. 이와 유사한 통찰력을 얻기 위해 B2B 기업의 포지셔닝도 다음 질문을 통해서 진행할 수 있다. 고객은 우리 기업에게 무엇을 기대하고 있는가? (= 고객의 니즈는 무엇인가?) 경쟁사와 비교하여 우수한 점은 무엇인가? (= 제품이나 브랜드 등 노출된 측면에서 우수한 점은 무엇인가?) 고객은 왜 우리를 선택해야 하나? (= 경쟁 대비 어떤 부분이 고객에게 어필되고 있는가? 고객 가치를 충족시키는가? 등) 경쟁 분석에서 위와 같은 질문에 대한 답을 얻기 위해 핵심 고객과 파트너를 대상으로 우리 제품의 어떤 속성이 뛰어난지, 그 속성이 고객에게 왜 중요한지, 우리 기업은 그런 부분을 얼마나 충족시키는지 등을 조사[8]하여 파악할 수 있을 때 진정한 기업의 가치(Core Value)를 알리고 이를 고객에게 제대로 제안할 수 있게 된다. 즉, 제대로 포지셔닝 하게 될 것이다. 1.4 BCG/GE 매트릭스 분석 포지셔닝을 통해 경쟁을 고민하면서 이제 자사의 영역으로 넘어오면 내가 무엇을 잘 하는지, 나의 사업은 건전한지 등을 성찰하게 된다. BCG 매트릭스는 그런 부분에 의의를 둘 수 있는 도구이다. BCG 매트릭스는 보스턴컨설팅 그룹(BCG)에서 기업의 사업 포트폴리오(business portfolio)를 분석하기 위해 개발한 도구로 사업의 규모, 상대적 시장점유율과 시장 성장률로 구성된 버블 차트(Bubble Chart)로 사업들을 각 사분면에 배치한 후, Dogs, Dilemma 영역의 사업들을 Star, Cash Cows로 키우기 위한 전략적 활동(사업 철수 포함)을 개발한다. 또한, GE는 BCG 매트릭스를 3 X 3로 확장하여 사업 포트폴리오의 분석을 보다 깊게 보고자 하였다. Figure III-10. BCG 매트릭스의 개념 BCG 매트릭스에서 활용되는 시장 점유율(Market share)[9]은 절대적 관점과 상대적 관점에서 다음과 같이 계산할 수 있다. 절대적 시장점유율(사업) = 자사의 총매출 / 시장의 크기 절대적 시장점유율(세그먼트) = 자사 세그먼트 매출 / 시장의 세그먼트 매출 상대적 시장점유율 10 = 자사의 총매출 / 최대 경쟁자의 총매출 상대적 시장점유율(세그먼트) = 자사 세그먼트 매출 / 최대 경쟁자들의 세그먼트 매출 Fig III-11. BCG/GE 매트릭스 사례 그런데 BCG/GE 매트릭스는 사업의 현황을 세련되게 설명할 수 있는 장점도 있지만 버블 차트를 그리기 위해 시장 점유율을 계산해야 하며, 경쟁사 정보에 기반한 상대적 시장점유율을 추정하기 어렵고, 또 특정 시점의 정보이므로 변화하는 상황을 적시에 반영하기 어렵다는 단점이 있다. 최근에는 매트릭스의 축을 시장 점유율 대신 매출과 영업이익률 같은 사업 실적으로 표현하여 특정 시점의 사업 실적을 평가하는 방법 등으로 더 많이 사용한다. 예를 들면 Figure III-11과 같이 성장성과 수익성이 높은 영역의 사업을 집중 육성하되 앤소프 매트릭스[11]를 사용하여 고객과 제품 관점에서 차별적 적용을 하고 결과적으로 지속적으로 수익 확보를 위한 제품 포트폴리오를 육성하자는 통찰력을 얻는 식이다. Figure III-12. BCG 매트릭스와 Ansoff 매트릭스의 활용 BCG 매트릭스는 애매한 도구이다. 사업 운용에서 해당 사업 또는 세그먼트의 규모와 포지션을 모두 보여줄 수 있는 장점이 있지만 사업의 동적인 부분을 적시에 반영하지 못하다. 그래서 저자가 과거 전략기획팀에서 일할 때는 BCG 매트릭스를 다음과 같이 활용해 보았다. 엑셀의 index와 match 함수를 이용하여 데이터가 동적으로 변할 수 있게 하고 스크롤 막대를 이용해서 그걸 조정할 수 있게 하였다. 반자동이라고나 할까? 조건에 따라 사업 세그먼트의 변화를 보여줄 수 있어서 매우 생산적인 보고가 될 것으로 기대했었다. 결과는 어땠을까? 경영 회의에서 논의가 매우 활발해졌다. 수익을 올리면 포지셔닝이 어떻게 변하는지 등을 실시간으로 시뮬레이션할 수 있게 되니까 보고도 생산성이 더해졌다. 하지만 해당 사업부장님들은 CEO/CFO와 달리 매우 부담스러워하였다. 요즘은 좋은 BI 도구들이 많이 있으니 더 효과적으로 보여줄 수도 있을 것 같다. 최신 소프트웨어들이 BCG 매트릭스의 한계를 조금씩 극복해 주고 있는지도 모르겠다. [1] Boston Consulting Group에서 만든 사업 포트폴리오 분석 매트릭스. [2] 저자도 비슷한 경험을 한 적이 있는데 시간과 노력을 들여서 만들었음에도 큰 감흥이 없다. 즉, 정리는 잘 되었는데 내용상 여기저기서 이미 조금씩 들은 이야기들이라 전략적 통찰력을 불러일으키기에는 2% 부족한 보고서가 되어버린 것이다. 경영진들은 상당히 많은 정보를 수시로 듣기 때문에 이런 유형의 분석 보고서는 적시성보다는 차별적 시사점을 찾아내는 것이 중요하다. [3] dart.fss.or.kr [4] US Securities and Exchange Commission. http://www.sec.gov [5] https://www.sec.gov/edgar/searchedgar/companysearch.html [6] B2C 마케팅에서 강조하는 4가지 포지셔닝(Positioning)은 ‘첫 번째, 고객의 기억 속에 최초가 돼라. 두 번째, 현재의 위상 특히, 일등 그룹에 속해 있음을 강조하라. 세 번째, 경쟁 상대를 재포지셔닝(Repositioning)하라. 네 번째, 지속적으로 집중하라’로 정리될 수 있다 [7] 1997년 애플 개발자 회의 발표 내용 [8] 고객의 주요 의사결정자와 인터뷰를 진행하거나 오피니언 리더들(Opinion Leaders)들을 대상으로 FGI(Focus Group Interview)를 진행하는 것이 좋다 [9] 혹자는 B2B 마케팅에서 시장점유율보다 고객 점유율 또는 기회 점유율이 더 중요하다고 말한다. 그 이유는 B2B 시장 전체를 파악하는 것이 쉽지 않고 시장 전체보다는 파레토 법칙에 의해 매출의 대부분을 차지하는 고객(군)을 얼마나 점유하느냐가 중요하기 때문이다 [10] 상대적 시장점유율의 경우, 경쟁사의 정보가 필요하다. 그런데 공시 정보 외에 경쟁사의 경영실적을 필요할 때마다 수시로 파악하는 일은 쉽지 않기에 활용하기 쉽지 않다 [11] Ansoff Matrix. 시장을 고객과 제품의 사분면으로 구분하고 단기, 중기, 장기 관점에서 어떻게 접근해야 하는지 설명 07. 경쟁 및 산업분석(3/4) 경쟁 및 산업 분석의 세 번째 시간이다. 지난번 BCG 매트릭스에 이어 자사 분석에서 많이 사용되며 그것을 확장해 산업에 대해 고찰할 수 있는 몇 가지 분석 법을 살펴보도록 하자. 1.5 Five Forces Model 마이클 포터 교수와 그의 저서 '5 Forces Model'은 사업 전략을 수립하기 위해 시장과 경쟁 즉, 산업 환경을 조망하는 기본적인 분석 방법으로 널리 알려져 있다. 마이클 포터(Michael E. Porter. 1947 ~ 현재)의 ‘5 forces model’ 분석 이외에도 ‘Value Chan 분석’을 비롯하여 다양한 산업분석 기법들을 제안하였고 널리 이것들은 알려졌다. 그러나 실제 이 기법들은 오늘날 컨설팅 현장에서 잘 활용할 수 있는 효과적인 기법이라고 권고하기는 어려운 '고전적인 경영전략 분석 기법들'이다. 노력(Efforts) 대비 활용성이 떨어지며 실시간으로 상황이 변하며 수많은 데이터가 쏟아져 나오는 시장과 경쟁의 동태적인(dynamic) 특성을 반영하지 못하는 정적인(static) 사업 현황의 스냅샷(snapshot)만을 제시하기 때문이다. 그러나 물리학에서도 아인슈타인(Albert Einstein.1879 ~ 1955)이 옳지만 가정에 가정을 더하면 뉴턴(Issac Newton. 1643 ~ 1727) 역학도 여전히 현실에서 적용 가능한 것처럼 경영학의 한 시대를 풍미하였으며, 경쟁 전략의 지평을 열었고 학문적으로도 큰 의의를 부여하기에 간략히 소개하고자 한다. 1980년 하버드 대학의 마이클 포터 교수는 그의 저서 ‘Competitive Strategy’에서 산업의 구조적 매력 도와 그 산업의 핵심 성공요소를 파악하기 위해 5가지 요소들 - 잠재적 경쟁자와 대체재의 위협, 기존 산업 간의 경쟁, 공급자와 소비자의 협상력-을 살펴보아야 한다고 주장하였고 이 요소들을 ‘Five Forces’라고 칭하였다. 기업을 두고 생산자와 공급자의 협상력을 분석하는 기본 개념(2-Model)에 경쟁자나 대체재의 위협이 있으면 소비자의 협상력이 올라간다는 개념까지 확대될 수 있다. Figure III-12는 널리 알려져 있는 Five Forces Model의 개념이다. Figure III-13. Five Forces Model (1) 신규 진입자의 위협(Threat of New Entrants) 신규 사업자로서 어떤 산업에 진출하고자 할 때에는 그 산업의 진입 장벽(Entry Barriers)을 극복해야 한다. 기존 사업자 입장에서는 타 사업자가 해당 산업에 진출하지 못하도록 진입 장벽을 높게 만드는 것은 그 산업을 구조적으로 매력적이게 만드는 방법이다. 즉, 독과점 구조를 만들어 높은 수익률을 얻을 수 있다는 의미와도 일맥상통한다. 널리 알려진 진입 장벽은 다음과 같은 것들이 있다. 규모의 경제(Economies of Scale): 진입 장벽을 구축할 수 있는 첫 번째 방안은 규모의 경제를 구성하는 것이다. 어떤 제품을 대량 생산할 수 있는 시스템을 갖춤으로써 추가 생산 시 평균 원가를 떨어뜨릴 수 있는 역량을 확보하고 있을 때 규모의 경제를 확보했다고 한다. 표준화된 제품의 대량 생산(Mass Production)[1]을 통해 원가를 절감하고,<NAME>료나 부품의 대량 구매를 통한 원자재 비용 할인, 많은 수의 제품에 대한 고정 원가 배분, 생산 설비 활용의 극대화, 대량 광고의 효과 등에서 규모의 경제를 추구할 수 있다. 브랜드 로열티(Brand Loyalty): 산업 내 기존 기업의 제품에 대한 선호도(preference)를 말한다. 선호도가 높으면 신규 진입 기업은 기존 기업의 시장 점유를 빼앗기 어렵기 때문이다. 브랜드 로열티가 진입 장벽으로서 영향력을 발휘하는 산업은 R&D 집약적 산업과 광고 집약적 산업을 들 수 있다. 이 들 산업의 특징은 신규 진입자도 막대한 R&D나 광고 비용을 쏟아부어야 하기 때문에 사업 실패 시 발생하는 매몰 비용(Sunk Cost)도 커진다. 즉, 한 번 발 담그면 빠져나오기 어렵다. 절대적 비용 우위(Absolute Cost Advantage): 선행 투자로 인한 비용 우위를 뜻한다. 즉, 쉽게 말하면 돈이 많아야 한다는 것이다. 기존 사업자가 핵심 기술이나 특허를 보유하고 있을 확률이 높기 때문에 진입자는 이를 사용하여 로열티를 지급하거나 라이선싱을 해야 한다. 그렇지 못할 경우, 대체 기술을 직접 개발해야 하는데 이 경우 더욱 많은 비용이 발생할 확률이 높다.(First Mover's Advantage) 또한, 기존 사업자가 유통망도 장악하고 있을 경우 조달 비용도 증가하므로 결국 선행투자를 통한 비용 우위 요소가 또 다른 진입 장벽을 만들게 되는 결과가 되는 것이다. [2] 정부 규제(Government Regulations): 정부 규제의 활용은 법/제도를 통해 합법적으로 진입장벽을 가장 확실하게 만들 수 있는 방법이다. 국가 경제정책과 맥락을 같이 하는 경우가 많은데 최근 환경 규제와 관련하여 유럽연합(EU)에서 자동차 산업에 적용하고 있는 EURO 6 같은 것이 대표적이다. EURO 6는 경유차 배기가스 규제 단계의 명칭으로 1992년 EURO 1 도입부터 2013년 EURO 6에 이르기까지 지속적으로 질소산화물의 배출에 대해 규제하는 것인데, EURO 6는 EURO 5보다 30~50% 더 감소시켜야 하는 까닭에 자동차 회사들은 신형 엔진을 장착하거나 별도의 저감장치를 장착하고, 차량의 무게를 줄이는 등 다양한 노력을 하고 있다. 이 규제를 충족시키는 차량만이 유럽연합에 차량 수출이 가능하므로 국내 자동차 업계도 거센 도전을 받고 있다. 각 나라마다 소위 산업화 시대를 지칭하는 시기가 조금씩 다르지만 그 기간 동안 규모의 경제를 이루게 된 기업들이나 정부 규제를 적극 활용하는 기업들을 보면 거의 글로벌 다국적 기업, 한국의 경우는 대기업들이다. (2) 기존 기업 간의 경쟁(Rivalry among the existing firms) Five Forces의 두 번째 요소는 산업 내 기존 기업 간의 경쟁으로 산업의 경쟁 구조, 수요 조건, 퇴출 장벽 등이 있다. 산업의 경쟁 구조(Industry Competitive Structure): 산업의 경쟁 구조는 쉽게 말해서 비슷한 업을 하는 기업이 산업 내 소수이냐 다수이냐를 통해 경쟁 강도가 달라지는 것을 의미한다. 산업 내 포진한 기업들의 밀집도에 따라 'Fragmented 산업' 또는 'Consolidated 산업'이라고 말하는데 소규모 다수 기업이 포진한 산업을 fragmented 산업, 독보적인 2~3개 기업이 포진한 산업을 Consolidated 산업이라 한다. 예를 들어 fragmented 산업은 노래방, 부동산 중개소 같은 것이고 consolidated 산업은 자동차, 가전기업 같은 것을 생각하면 된다. 한국의 공정거래위원회에서는 '3사 집중도 지표(3 firms concentration)'라는 것을 발표하는데 이는 산업 내 독과점 또는 담합의 개연성을 모니터링하려는 의도에서 만든 것이다. 산업 내 상위 3개 기업의 시장점유율이 높다면 독과점, 담합이라 의심할 수 있다는 가정이다. 경쟁 구조를 볼 수 있는 또 다른 요인으로 '제품차별화'가 있을 수 있는데 산업 내에서 경쟁하는 기업들이 제품의 디자인이나 품질면에서 동일할수록 소비자들은 특정 회사 제품을 선호할 이유가 없어진다. 따라서 기업 입장에서는 동질화된 제품들에 대해서 가격 외에는 경쟁할 만한 수단이 없어지게 되는데 이러한 제품을 일상재(commodity)라고 부른다. 기업의 제품이 일상 재가 되는 순간, 가격 경쟁에 돌입하게 되므로 해당 제품의 수익률은 낮아지게 된다. Table III-6. 산업의 경쟁 구조 수요 조건(Demand Condition): 수요 조건은 '수요에 따른 경쟁의 양상을 알아보는 것'으로 수요와 경쟁은 반비례 관계에 있다는 것을 이해하면 된다. 이것은 시장의 크기가 일정하다고 하는 암묵적 가정이 있다. 실제로 수요가 증가하면 시장도 확장되는 경우가 많기 때문에 치열한 경쟁 없이 기업의 매출 증가가 가능하다는 이야기도 된다. 이는 전략 경영(Strategic Management)의 목적이 가치 창출(Value Creation) 즉, '시장의 크기(Pie)를 키우자'라는 것이기 때문에 이윤 창출로 한정하지 않기 때문이다. 그런 측면에서 수요 조건은 제한적이라고 할 수 있다. 퇴출 장벽(Exit Barriers): 퇴출 장벽은 한 산업에서 어떤 기업이 사업을 철수하려고 할 때 이를 방해하는 장벽을 말한다. 퇴출 장벽이 문제가 되는 것은 수요가 줄어드는 순간이다. 수요가 줄거나 정체될 때 퇴출 장벽이 높으면 해당 산업에서 이탈할 수가 없어 과잉공급 문제를 해결하기 위해 가격경쟁을 일으키게 된다. 퇴출 장벽의 종류로 보통 3가지를 많이 이야기하는데 경제적 퇴출 장벽, 전략적 퇴출 장벽, 감정적 퇴출 장벽이 있다고 한다. 경제적 퇴출 장벽은 대규모 산업 설비처럼 투자 자산이 클 경우 발생하는 데 이를 쉽게 팔기도 어렵고 계속 보유하면 가변비용만 발생하고 생산은 할 수 없게 되므로 기존 재고 처리를 위한 가격 경쟁을 시도하게 된다. 전략적 퇴출 장벽은 타 산업과의 시너지(Synergy)가 많아서 한 쪽 산업을 포기할 수 없게 되는 경우이다. 예를 들면 면도기, 쉐이빙 폼, 애프터 쉐이브 사업의 관계이다. 서로 다른 산업이지만 교차판매(Cross-selling), 연쇄판매(Up-selling) 등을 통해 사업 간 시너지가 상당히 크다. 감정적 퇴출 장벽은 보통 처음 시작한 사업으로 쉽게 철수하지 못한 경우가 많다. '고조할아버지가 시작하셔서 5대에 걸쳐 하고 있는 사업 .... ' 뭐 이런 것이다. 그런 연유로 사업적으로 매력적이지 못하지만 쉽게 퇴출시키지 못하는 경우가 많다. 최근에는 비즈니스 모델 혁신 또는 비즈니스 모델 재창조(Business Reinvention)을 통해 기존과 전혀 다른 산업으로 탈바꿈하는 경우도 많다. 삼진 어묵 같은 경우, 부산의 유서 깊은 어묵 공장이 어묵 자체의 수요가 감소하면서 공장을 유지하기 어려워졌을 때 소유주의 아들이 베이커리 개념을 도입하여 새로운 어묵 상품을 제조, 판매하고 체험관을 만들어 사람들에게 어묵의 역사를 알리는 활동도 하면서 유명해져 부산의 어묵 산업을 다시 활성화시킨 사례로 유명하다. (3) 구매자의 협상력(Bargaining power of Buyers) 산업 구조의 세 번째 Force는 구매자의 협상력이다. 구매력(Buying Power)이라고도 하는데 다음과 같은 2가지가 구매자의 교섭력을 결정한다. 1) 제품차별화가 심할수록 구매자는 가격에 민감하지 않다. - 혁신적 서비스를 제공하는 아이폰(i-Phone)에 대해 그것이 하이엔드(High-End) 제품임이어도 구입한다. 2) 이를 B2B 사업으로 옮겨보면 판매하는 기업과 구매하는 기업 간의 협상력의 차이가 중요하다. 이 힘(Power)는 구매자의 공급자에 대한 상대적 크기이다. 산업 구조가 제품을 공급하는 많은 기업들로 이루어져 있고 수요는 작지만 그 구매 규모가 클 때 구매자가 많은 양을 구매할 때 공급 산업이 전체 판매 부분을 특정 구매자에게 의존할 때 구매자가 공급자를 낮은 비용으로 바꿀 수 있을 때 (낮은 Switching Cost) 구매자가 공급자의 제품, 가격, 비용 구조 등 해당 산업에 대해 잘 알고 있을 때 구매자가 후방 통합(또는 수직통합)을 할 능력이 있을 때, 구매자의 협상력은 크게 증가한다 (4) 공급자의 협상력(Bargaining power of Suppliers) 공급자의 협상력은 구매자의 협상력을 반대로 생각하면 된다. 공급자가 공급하는 제품에 대해 대체품이 적고 공급받는 기업에게는 매우 중요할 때(Lock-in Effect) 구매자가 속해 있는 산업이 공급자에게는 재무적 혹은 전략적으로 별로 중요하지 않을 때 공급자 제품이 차별화되어 교체 비용이 놓을 때 공급자가 전방 통합(Forward Integration)을 하겠다고 믿을 만한 위협을 할 때 구매자가 가격을 낮추기 위해 후방 통합(Backward Integration) 하겠다는 위협을 할 수 없을 때 공급자의 협상력을 높이기 위해 기업들은 흔히 카르텔(Cartel. 기업 연합 또는 기업 담합)을 형성하기도 한다. 대표적인 것이 OPEC*인데 OPEC는 산유국들의 교섭력을 높이기 위해 결성된 것이다. * OPEC (The Organization of the Petroleum Exporting Countries. 석유수출국기구) (5) 대체재의 위협(Threats of Substitute products) 이러한 공급자의 노력에도 불구하고 강력한 대체재가 존재하면 구매자의 협상력이 높아져서 해당 산업의 수익성은 낮아지거나 대체되어 버린다. mp3 플레이어는 해당 사례로 널리 언급되는데 과거 mp3 플레이어를 세계 최초로 개발하였고 시장 지배적인 위치에 있었던 한국 기업들이 mp3 플레이어의 기능을 앱으로 대체해버린 스마트폰이 나오면서 모두 시장에서 사라지게 되었다. 이러한 대체재가 그 산업의 가격 결정에 영향을 끼칠 수 있는 요인은 크게 2가지인데 다음과 같은 질문을 통해 답을 고찰해 볼 수 있다. 소비자들이 대체재로 쉽게 옮아갈 수 있는가? 대체재는 얼마나 유용한가? 실제로 80년대에 설탕 대신 감미료가 출현했지만 소비자들은 여전히 설탕을 선호하고 있으며 커피와 차의 경우 기호 식품(Favorite food)으로 자리매김하여 대체 효과가 발생하긴 하지만 한번 익숙해진 맛을 소비자들이 쉽게 바꾸지는 않는다. 살펴본 것처럼 5 Forces model은 Table III-7과 다음과 같은 장단점이 있다. Table III-7. Five Forece 분석의 장단점 마이클 포터는 해당 분석 기법의 단점을 보완하기 위해 전략 집단(Strategic Group)이나 산업 수명 주기(Industry Life Cycle) 같은 개념을 제시하기도 하였다. 현재 포터가 미국 경영학계의 주류는 아닌듯하지만 전략 관점에서 경영학을 본 최초의 사람이 아닐까 생각이 든다. 자료를 찾아보니 포터의 모형이 발표되던 시절, 이미 경제학계에서는 슘페터(Joseph Schumpeter. 1883 ~ 1950)가 일찍이 경쟁과 산업 구조의 동태적인 상호 작용을 인식하고 이에 주목하였다고 한다. 슘페터 지지자들은 현재 독점체제를 유지하고 있는 기업들도 새로운 기술, 새로운 유통망, 새로운 제품을 갖고 진입해 오는 새로운 경쟁자에 의해서 독점적 지위를 빼앗기고 시장은 점차 경쟁적인 체제로 바뀐다고 보고 있다. 따라서 어느 산업에서 구조적인 기업혁신으로 산업구조가 빠른 속도로 바뀌고 있다면, 고정된 시점에서 산업을 분석하는 포터의 방법은 기업들에게 별로 도움을 주지 못한다는 말에 동의한다. 그러나 슘페터가 말하는 기업 혁신에 의한 창조적 파괴(Creative destruction) 과정은 상당히 느리게 진행된다. 이런 점이 포터의 지지자들이<NAME>적 분석이 유효하다고 주장하는 단면이기도 하다. 그러나 최근 화두가 되고 있는 4차 산업 혁명(4IR)은 이런 전제와 가정을 마구마구 깨고 있기에 흥미로우면서도 한편 제대로 준비하지 않는다면 한순간에 사라져버리는 두려운 상황이 예상되는 것이다. 1.6 Value Chain 분석 ‘공급 사슬 분석’ 또는 ‘가치사슬 분석’이라고 불리는 이 분석 기법도 마이클 포터가 제안한 것인데 기업 활동을 본원적 활동(Primary Activities)과 지원 활동(Support Activities)으로 구분하여 본원적 활동은 가치(Value)를 창출하고, 지원 활동은 가치 창출 활동을 지원한다고 주장하였다. 대표적인 본원적 활동은 조달, 생산, 운영, 유통, 마케팅, 판매, 서비스 등이 해당하며 지원 활동은 인사, 재무, 구매, 연구개발 등이 해당한다. Figure III-14. 일반적인 제조기업의 Value Chain 그런데 의미 있는 분석이 되기 위해서는 본원적 활동이든 지원 활동이든 기업 활동이 모두 원가가 배분되어야 한다. 활동 원가 분석(Activity Based Cost Analysis: ABC 분석)이라고 하여 한때 많은 기업들이 기업 활동의 모든 비용 배분을 활동 원가 기준으로 관리하고자 시도한 적이 있었는데 대부분의 기업들이 큰 성과를 얻지 못했다. 그 이유는 ERP[3]를 활용한다 하더라도 관리를 위해 투입되는 노력 대비 활용 성과가 그다지 높지 않았기 때문이다. 포터의 시도는 기업의 본원적 활동과 지원 활동을 구분하고 Figure III-14와 같이 각 활동들에 투입되는 비용 분석을 통해 어떤 부분이 가장 많은 가치를 창출할 수 있는지 규명하고 나아가 경쟁사와의 비교를 통해 강화시켜야 할 부분 및 조정 또는 축소해야 할 부분을 파악하고자 하였으나 현실적으로 경쟁사 제품의 원가 정보를 입수하는 것은 쉽지 않으며 ABC 분석 자체가 회계 관리의 아주 이상적인 지향점 중의 하나이어서 많은 기업들이 그 사상에 공감하긴 하지만 실질적으로 그대로 수행하고 그것을 활용하여 성과를 창출하지는 못했다. Figure III-15. Value Chain 항목별 운영 비용의 분포 Table III-8. Value Chain 분석의 장단점 Table III-8은 Value Chain 분석의 장단점을 정리한 것이다. 부각되는 단점에도 불구하고 가치사슬 분석은 해당 기업이 속한 산업을 기준으로 제품의 수요 측면에서 전방 산업(Downstream)이 어떻게 변화하는지 각 부문별 수요 특성을 파악하거나, 후방 산업(Upstream) 분석을 통해 제품의 원가 및 원자재 측면의 변동성을 파악하는데 활용되곤 한다. 대부분 B2B 기업들은 중간재를 구입하여 최종 제품을 만들기 때문에 전/후방 산업 연쇄효과(Forward/Backward Linkage Effect)가 발생한다. 즉, 경기가 좋은 때는 동반하여 같이 성장하고 그 반대의 경우는 같이 쇠락한다. 때때로 전/후방 산업을 파악하기 어려울 수 있는데 최종 소비자에 가까울수록 전방 산업,<NAME>료 공급에 가까울수록 후방 산업이라 생각하면 된다. 예를 들어 자동차 산업을 생각해 볼 때 타이어 등 차량 부품 산업은 전방 산업이며, 제철산업은 차량의 원자재를 공급하는 후방 산업이다. 다음과 같은 질문으로 전/후방 산업 분석을 시작해 볼 수 있다. 원자재부터 최종 제품까지 공급 사슬의 구조는 어떠한가? 어떤 활동 또는 단계가 가장 비효율적인가? 가치 극대화를 위해 전/후방 통합이 필요한가? Break #13. 수직통합(Vertical Integration)의 장/단점 전/후방 산업을 다루다 보면 반드시 나오는 이야기가 산업 통합(Integration)이다. 경영전략 관점에서 통합은 수직 통합(Vertical Integration)과 수평 통합(Horizontal Integration)이 있다. 수직통합은 직접 자신의 투입물을 생산하거나(Backward Integration), 생산물을 유통하는 것(Forward Integration)을 말한다. Figure III-15는 수직 통합의 개념을 설명하고 있다. 이를 위해 취하는 전략적 수단의 대표적인 것이 인수합병이나 자회사 설립이다. 산업 간 Value Chain의 통합의 장단점에 대해서 상세히 알아보자. 우선적으로 살펴볼 것은 수직 통합의 가치창출 요인이다. 수직통합은 주로 핵심사업에서 경쟁적 지위를 강화할 목적으로 사용되며 다음과 같은 요인을 통해 가치를 창출한다. 생산 원가 절감 시장 비용 감소 제품 품질의 유지 특허 기술의 보호 첫 번째, 생산원가 절감은 수직 통합 중 후방 통합(Backward Integration)으로 얻어질 수 있는데,<NAME>료나 부분품을 생산공정에 유리한 조건으로 투입함으로써 효율성을 높일 수 있다. 또, 생산 공정에 대한 계획과 조정이 쉬워짐으로써 생산 원가를 절감할 수 있다. 두 번째, 시장 비용 감소는 수직통합의 전방 통합(Forward Integration)으로 얻어질 수 있으며 유통 과정 (상품 중개업자, 창고, 수송 업자 등)을 장악함으로써 관련 비용을 줄일 수 있다. 특히, 소수의 공급자로부터<NAME>료 및 부분품을 수급 받을 경우 후방 통합을 통해 관련 비용을 절감할 수 있다. 결국, 구매자가 공급자가 되라는 이야기이다. 제한된 수의 구매자도 같은 경우인데 이 경우는 전방통합을 통해 공급자가 판매상이 되라는 이야기이다. Figure III-16. 전후방 산업통합의 개념 세 번째, 제품 품질의 유지는 수직 통합을 통해 제품의 경쟁력의 일관성을 유지할 수 있다는 의미인데 후방 통합을 통해 제품의 품질 일관성을, 전방 통합을 통해 사후 서비스(A/S) 품질의 일관성을 유지할 수 있다는 생각이다. 네 번째, 특허 기술의 보호는 수직 통합을 함으로써 생산부터 판매까지 단일 기업 또는 기업 계열이 수행함으로써 관련 기술과 특허가 외부로 유출되지 않는다는 생각이다. 그러나 이런 수직 통합도 다음과 같은 단점이 있다. 원가 상의 불이익 유연성의 부족 첫 번째, 원가 상의 불이익은 자사 소유의 공급원으로부터 공급을 받으면서 오히려 원가 상의 불이익을 받게 되는 경우인데 대부분 자회사가 이런 공급 역할을 맡게 됨으로써 모기업이라는 안정적인 공급처를 확보하게 되어 해당 기업의 원가경쟁력이 약화될 수 있기 때문이다. 또한, 오버헤드(overhead) 비용이 추가되면서 경쟁 시장(open market) 대비 가격경쟁력도 떨어지는 현상이 일반적으로 발생한다. 두 번째, 유연성의 부족은 수직통합의 강도가 강하면 강할수록 새롭게 등장하는 기술이나 유통망의 혁신에 대응하기가 어려워진다. 특히, 모기업 차원에서 유연성이 극도로 떨어지는 경향이 있다. 더군다나 자회사의 경영진은 대부분 모기업에서 낙하산처럼 임명되어 가는 경우가 비일비재(非一非再) 하기 때문에 관료화를 낳게 되고, 인사 문제까지 연계되어 기업의 유연성을 더욱 떨어뜨리게 된다. 이런 수직통합의 폐해를 극복하고 해당 장점을 살리기 위해 자주 제시되는 대안은 ‘장기 계약(Long-term Contracting)’이다. 장기계약은 공급 업자 또는 판매업자들과 장기로 계약을 맺고 균일한 품질 수준 유지, 원가절감 등 경쟁 우위 확보를 위한 상호 협력을 합의하는 것이다. 여기서 가장 중요한 것은 파트너 또는 협력업체와의 ‘신뢰(Trust)’인데 계약 자체가 신뢰를 기반으로 맺어지긴 하지만 명시적인 구매 약속이라든가 공동 투자 등 대내외적으로 장기계약 관계를 천명하는 별도의 활동을 전개하기도 한다. 1.7 SWOT 분석 꽤 길게 산업구조 분석에 대해 살펴보았다. 이제 산업 환경도 살펴보면서 기업 내부의 역량도 살펴볼 차례이다. ‘지피지기 백전백승(知彼知己百戰百勝)’이라고 경쟁에서 살아남기 위해서는 경쟁사뿐 아니라 자사의 역량을 파악하는 일도 매우 중요하다. SWOT 분석은 기업의 강점(Strength), 약점 (Weakness), 기회(Opportunities)와 위협(Threat) 요인들을 파악하고 이를 경쟁 우위(Competitive Advantage) 관점에서 어떻게 활용할 것인지 전략적 시사점을 도출하기 위해 사용하는 도구이다. Figure III-17. SWOT 분석의 개념 초창기 전략 분석 프레임워크이었던 SWOT 분석은 1960년 대 하버드 비즈니스 스쿨에서 수학하던 Christensen, Andrew, Gut에 의해 개발되어 구조적 전략 분석의 기본 방향을 제시하였다고 할 수 있다. 그러나 키워드(keyword) 나열에 그치지 않으려면 SWOT 분석 시 반드시 전략 대안을 개발하고 실행 계획으로 전환할 수 있는 핵심 성공요소(CSF[4])를 개발하는 것이 필요하다. 다음은 SWOT 분석을 위한 질문들이다. 경쟁사와 비교하였을 때 자사의 강점과 약점 요인은 무엇인가? 시장의 변화를 고려하였을 때 자사에게 위기와 기회는 무엇인가? 각 전략적 시사점을 기반으로 전략 대안을 설정할 수 있는 핵심 성공 요소들(CSFs or KSFs)은 무엇인가? Figure III-16과 같이 만들어진 SWOT 매트릭스는 다음과 같은 4개의 전략 옵션이 있다. S-O 전략 W-O 전략 S-T 전략 W-T 전략 S-O 전략은 회사의 강점을 잘 활용하여 기회에 충분히 대처하기 위한 전략 대안을 개발해야 하고, W-O 전략은 기회를 활용하기 위해 약점을 극복할 수 있는 전략을 개발하는 것이며, S-T 전략은 위부의 위협에 대해 자사의 취약점을 줄이기 위해 자사의 강점을 사용할 수 있는 방법을 식별하며, W-T 전략은 외부의 위협으로부터 자사의 약점을 보완하기 위한 방어 전략을 수립하는 것이다. 이런 차원에서 종합적인 판단을 통해 SWOT 분석을 수행해야 의미 있는 결과를 도출할 수 있다. Figure III-18. SWOT 분석 전략의 도출 SWOT 분석은 그것만을 활용하는 것보다는 다른 경쟁 및 산업 분석 도구와 같이 병행하여 활용하는 것이 좋다. 대부분 SWOT 분석을 했다고 하면 4개의 Box 안에 기업의 강점과 약점, 위기와 기회를 서술하는 것으로 그치는 경우가 많다. 그런데 이렇게 하는 것은 SWOT 분석을 잘못한 것이다. SW(강점과 약점)에 대한 고민으로부터 기업 내부의 분석과 관계된 시사점을 도출할 수 있고, OT(기회와 위기)에 대한 고민으로부터 기업 외부의 환경 분석과 관련된 시사점을 도출할 수 있다. 따라서 기업 내/외부 환경을 고려한 전략적 대안을 개발하기 위해서는 Figure III-17과 같은 SWOT 매트릭스를 구성하고 그에 따른 대안을 고민하는 것이 필요하다. 또한, Five Forces 분석이나 BCG 매트릭스 기법처럼 고전적 전략 수립 기법의 하나인 SWOT 분석은 다음과 같은 장단점을 가지고 있다. Table III-9. SWOT 분석의 장/단점 너무나도 유명한 기법이라 전략 컨설팅에서 활용하는 단골 소재이기도 하다. 그러나 실제 일하다 보면 SWOT 매트릭스의 내용을 제대로 채우기 어려운 경우가 많다. 그 경우는 대부분 강점과 약점, 위기와 기회를 명확화하는데 실패했기 때문이다. 이것이 강점인지 기회인지 등등. 분석이 모호하면 시사점도 모호하다. 또한, 고전적인 전략분석 기법의 공통점은 모두 정적(static)이거나 단면의 모습만 부각된다는 것이다. 그러나 독자님 모두가 잘 알 듯이 우리가 마주하고 있는 현실은 매우 동적(dynamic)이며 입체적이며 비선형적이다. 항상 이 부분의 괴리를 어떻게 잘 채울 것인가 하는 것이 훌륭한 분석의 길잡이가 된다. 경쟁과 산업분석의 세 번째 시간에서 산업구조 분석을 통해 해당 산업과 경쟁에 대해 생각해 보았고, SWOT 분석을 통해 환경과 자사에 대해 생각해 보았다. 다음은 경쟁과 산업 분석 마지막 순서로 기업의 재무성과 분석에 대해 살펴보도록 하자. [1] 2016년부터 화두가 되고 있는 인공지능과 로봇의 활용, 원자재 혁신, 생산 기법의 첨단화 등은 '대량 생산(Mass Production)'을 '대량 맞춤(Mass Customization)'으로 바꾸고 있다. 즉, 대량 생산 제품들을 싼 맛에 구매해야 했던 시대를 넘어 소비자의 다양한 기호를 반영한 맞춤형 제품을 싸게 살 수 있는 기반을 구축하였다는 것을 뜻한다. [2] 그런데 이런 가정도 시장의 동향 및 방향을 잘 파악하고 투자하여야 한다. 2010년 초반 마쓰시다의 수도(水道) 철학에 의해 어려움을 겪었던 파나소닉의 사례를 생각해 볼 필요가 있다. Part I. B2B 사업, 무엇이 다를까? 파나소닉(Panasonic)의 회생, 그리고 CES 2017 | B2B 사업에 대한 첫 번째 이야기는 소니(SONY)와 함께 일본의 간판 전기∙전자 기업의 위치를 차지하고 있는 ‘파나소닉(PANASONIC)’의 회생 이야기로 시작해 보자. 파나소닉은 ‘마쓰시다 고노스케(松下幸之助. 1894~1989)’에 의해 창립되었는데, 마쓰시다 고노스케는 잇쇼겐메이(一生懸命) 정신으로 일본의 기업 문화를 바꾼 전설적인 인물이며 ‘나쇼 brunch.co.kr/@flyingcity/2 [3] Enterprise Resource Planning. 전사적 자원관리 시스템 [4] Critical Success Factors 같이 읽어보면 좋은 책! 경쟁전략(Competitive Strategy), 마이클 포터, 1980 07. 경쟁 및 산업분석(4/4) 7.8 재무비율 분석 이번 시간에는 경쟁 및 산업 분석의 마지막 순서로 재무분석에 대해 알아보자. 정확히 말하면 재무비율 분석이다. 경쟁력을 판단하는 중요한 잣대로 결국 '기업이 돈을 잘 벌고 있는가?'하는 것은 가장 중요한 문제이다. NGO[1]가 아닌 이상, 비전도 좋고 전략도 좋지만 결국 사업을 잘 해서 돈을 버는 것이 목적이므로 그 목적에 어느 정도 부합하고 있는지 살펴볼 필요가 있다. 재무비율 분석은 기업의 비즈니스 모델을 평가하는 궁극적인 도구이다. 사업의 성과 및 그와 관련된 다양한 지표를 분석하여 기업 경쟁력을 파악할 수 있고, 나아가 그 기업이 속한 산업 내 수익도 추정해 볼 수 있다. 산업 수익성의 개념은 대단히 중요한데 흔히 금광과 동광의 비유를 많이 든다. 내가 지하 깊숙이 들어가서 힘들게 광물을 캐지만 금을 캐는 광부과 동을 캐는 광부가 갖게 되는 대가는 완전히 다르다. 즉, 산업 수익성이 높은 산업에 속한 기업에 근무하는 근로자가 당연히 수혜가 많음을 기대할 수 있다[2]. 그래서 첫 직장이 중요하고 동일 직무라 하더라도 연봉 높은 산업을 찾게 된다. 누군가 직장/직업에 대한 고민을 할 때 그런 Tip을 알려주었더라면 많은 사람들의 인생이 달라졌을 것이리라. 일반적으로 재무비율 분석을 위해서는 3가지 재무제표를 참고한다.[3] 대차대조표 (The Balance Sheet) 손익계산서 (The Income Sheet. I/S or The Profit and Loss Account. P/L) 현금흐름표 (The Cash Flow statement. C/F) 첫 번째, 대차대조표는 특정 시점(결산시점)에 기업이 어떤 자산을 보유하고 있는지, 빚은 얼마인지, 자본은 얼마인지 보여주는 서류로서 복식부기의 좌변과 우변 즉, 차변(Debtor.Dr)과 대변(Creditor.Cr)이 같아야 함(Balance)을 원칙으로 한다. Table III-10은 대차대조표의 구성을 보여주는데[4], 이는 기업 자산의 총합은 부채의 총합과 자본의 총합을 더한 것과 같아야 한다는 원칙을 보여주고 있다. Table III-10. 대차대조표의 구성 두 번째 살펴볼 재무제표는 손익계산서이다. 손익계산서는 기업이 벌어들이는 수익을 각종 비용을 제거해나가면서 최종 이익을 만들어내는 것을 설명하는 서류로서 Figure III-18을 위에서부터 아래로 읽어나가면 된다. 기업이 매출액을 벌어들이면 거기서 직접 비용으로 구성된 원가를 차감하면 매출 총이익이 된다. Figure III-19. 손익계산서의 이익 산출[5] 매출 총이익에서 판매비와 관리비를 차감한 것이 영업이익이다. 영업이익에서 영업활동 외의 이익 예를 들어 부동산 임대료나 특허료 등 영업 외 수익을 더해주고, 영업 외 비용을 차감하면 계속 사업이익이 된다. 계속 사업이익은 IFRS[6] 도입 이전에 경상이익이라고 불리던 것으로 지분법평가이익과 같은 특별이익을 더하고 특별손실을 제하면 법인세비용 차감전순이익이 된다. 여기서 법인세를 차감하면 마지막으로 당기순이익이 나온다. 세 번째, 현금흐름표는 실제 현금흐름을 표기하기 위해 감가상각과 같이 가상으로 처리한 것을 모두 반영한다. Figure III-19를 보면 대차대조표와 손익계산서가 현금흐름표에 어떻게 반영되는지 알 수 있을 것이다. 전기에 영업활동을 잘하면 수익을 발생시키게 된다. 여기서 비용을 제하면 순이익이 남는데 이것은 주주에게 배당금으로 돌아가거나 다음 해 나의 자본에 포함된다. 즉, 전체적인 자산이 증가하게 된다. 결국, 장사를 잘하면 주주에게 이익도 주게 되고 내 자산도 증가한다는 개념이다. 여기서 현금흐름표를 보면 배당금과 이익잉여금으로 구성됨을 알 수 있다. Figure III-20. 현금흐름표의 구성 재무비율 분석은 살펴본 것처럼 재무제표의 중요 계정 값들의 비율을 구해 기업의 재무적 특성을 파악하는 것을 의미하며 Table III-11과 같이 4가지 관점에서 값을 구한다. Table III-11. 재무비율 분석의 관점 첫 번째, 수익성 비율(Profitability Ratio) 분석은 기업이 영업 활동을 얼마나 잘 하고 있는지 알아볼 수 있는 것으로 Table III-12는 기업의 수익성을 가늠할 수 있는 주요 비율을 설명하고 있다. Table III-12. 수익성 비율 분석 - 주요 비율 중심[7] 총 자본순이익률(Return on Investment)은 순이익을 총 자본(또는 총자산)으로 나눈 비율로 기업에 투자된 총 자본이 최종적으로 얼마나 많은 이익을 내었나 산출하는 비율이다. 즉, 종합적인 경영 상태를 요약해서 나타내는 비율인데 분모는 주주와 채권자가 제공한 금액이고 분자는 주주에게 귀속되는 이익이므로 서로 잘 대응되지 않지만 기업의 대차대조표(BS)와 손익계산서(IS)를 종합적으로 집약한 성과 지표라 할 수 있다. 두 번째, 유동성 비율(Liquidity Ratio) 분석. 여기서 유동성은 현금화될 수 있는 성질을 말하며 유동성이 높다는 것은 현금화가 쉽다는 말이다. 유동 비율(Current Ratio)은 은행 대출 시 채무자의 지급 능력을 판단하는 지표로 이용되어 왔기 때문에 은행가 비율(Banker’s Ratio)라고도 한다. Table III-13. 유동성 비율 분석 - 주요 비율 중심 세 번째, 레버리지 비율 분석. 레버리지(Leverage)는 지렛대 작용을 의미하는 것으로 손익 확대 효과를 가져다주는 타인자본 의존도를 지칭한다. 그러나 과도한 레버리지 효과 의존은 망하는 지름길이기도 하다. Table III-14. 레버리지 비율 분석 - 주요 비율 중심 네 번째, 시장가치 비율 분석은 해당 기업의 주가를 평가함으로써 시장 가치(Market Value)를 알 수 있는 척도가 된다. Table III-15. 시장가치 비율 분석 - 주요 비율 중심[8] 또한, 투하자본의 순이익률 (ROIC)[9] 분석도 유의미한데 사업의 원가 동인(Cost drivers)을 파악하여 어떤 조건이 원가 동인들을 변동시키는지 알아내는 것이 활용할 수 있다. Value Driver 분석은 이러한 다양한 가치 동인을 파악하여 제품 또는 산업 생명주기 속에서 어떻게 가치나 비용을 배분해야 하는지 경영 관점의 통찰력을 제공해 준다. Figure III-21. Value Driver Tree 사례 지금까지 경쟁과 산업 분석을 통해 시장과 경쟁, 자사에 대해 살펴보았다. 그런데 소개한 다양한 분석 기법들의 문제 즉, 고전적인 분석 방법의 문제들은<NAME>같이<NAME>적 분석에 치중한다는 것이다.<NAME>적 분석이 나쁘다는 것이 아니라 오늘날 급변하는 사업 환경 속에서 정보 적시성이 담보 받지 못하게 되는 경우가 많기 때문이다. 어떤 산업은 시시각각 변하며 또 어떤 산업은 매우 보수적이라 트렌드라고 할 것도 없는 산업도 있다. 경쟁 및 산업 분석을 수행하는 컨설턴트들은 그런 부분을 고려하여 어떤 도구를 사용할 것인지 그리고 또 부족한 부분을 어떻게 보완할 것인지 고민해야 한다. 이어지는 제8장에서는 사업 환경을 파악하는데 가장 중요한 '고객'에 대해서 살펴보도록 하자. [1] Non-Government Organization. 정부나 정부 관계 기관이 아닌 순수 민간단체를 지칭하는 말로 비영리를 추구한다. [2] 2017년 기준 현재 한국 산업 중에서는 금융, 정유, 반도체, 통신 등이 타 산업 대비 산업 수익성이 높다. [3] 이익 잉여분 처분 계산서는 2011년 IFRS 도입 이후부터 잘 사용하지 않는다. [4] 간혹 영어 단어 또는 문장이 훨씬 이해하기 쉽다는 느낌이 드는데 Table III-10도 그렇다 [5] Cost of goods sold: COGS, Selling goods and administrative expenses, indirect costs, and depreciation: SG&A, Earnings Before Interests and Taxes [6] International Financial Reporting Standards 기업의 회계 처리와 재무제표에 대한 국제적 통일성을 높이기 위한 국제회계기준 [7] Profit Before Interest and Tax; Return on Asset(ROA) / Return on Capital Employed(ROCE) [8] Earnings Per Share; Pricing Earning Ratio [9] Return On Invested Capital 08. 고객 요구 분석(1/3) 앞서 소개한 마이클 포터의 Value Chain 분석을 상기해 보자. 기업의 Value Chain 내 모든 활동을 유발하는 근본 원인을 생각해 보면 그것은 기업이 생산하는 제품이나 서비스를 필요로 하는 고객의 생각이라 할 수 있다. 마케팅에서는 그 생각을 단계적으로 구분하여 니즈(Needs), 원츠(Wants), 수요(Demand)로 구분한다. 수요가 좀 더 구체화되면 요구(Requirements)가 되고 기업에게 요구는 매우 실제적인 항목이 된다. 예를 들면 서울에서 부산까지 가고 싶은 생각이 있는데(니즈), 비행기를 타고 갈지 KTX를 타고 갈지 고속버스를 타고 갈지 등 교통편을 생각해 볼 필요가 있고(원츠), 비용 측면에서 볼 때 비행기보다는 가격이 싸고 고속버스보다 빨리 도착하는 KTX를 타고 가겠다고 결정하면 그것이 ‘수요’가 된다. Figure III-22. 고객 니즈/원츠/디맨드 니즈를 원츠, 수요 등으로 전환시키는 마케팅의 본질적인 역할이라면 컨설팅에서는 그걸 잘할 수 있는 방법을 가이드 하는 것이라 할 수 있다. 한편, 그런 고객의 요구를 정확하게 파악하는 일은 소위 말하는 고객 요구사항 분석에서 가장 중요한 어젠다라고 할 수 있다. 고객의 니즈는 무엇인지? 또 그것을 산업이나 시장에서 어떻게 표출하고 있는지 그런 부분을 알아내는 것이 고객 분석, 고객 요구사항 분석이다. 고객 요구 분석의 관점에서 보면 결론적으로 해야 할 일은 크게 다음 3가지이다. 어떤 고객에게 집중할 것인가? 그 고객을 어떻게 확보할 것인가? 확보된 고객을 어떻게 유지할 것인가? 시장이나 고객을 상세하게 나누어 기업의 성과 창출에 유리한 시장이나 고객을 선정하고, 어떤 제품과 서비스를 통해 고객 가치를 실현할 것인지, 형성된 고객 관계를 어떻게 지속적으로 유지할 것인지 등에 대한 전략 대안의 도출이 고객 요구 분석의 핵심이라 할 수 있다. 이제부터 이에 대해 좀 더 상세히 살펴보도록 하자. Figure III-23. 고객 요구분석 로드맵 8.1 세분화(Segmentation) 첫 번째 다룰 것은 세분화(Segmentation)이다. 세분화는 유사한 특징을 가진 것들끼리 묶어서 구분 짓는 것을 말하는데, 마케팅 전략 수립에서 시장이나 고객을 의미 있게 구분하기 위한 STP[1]의 첫 번째 단계이기도 하다. 또한, B2C 사업과 B2B 사업이 시장이나 고객 세분화를 고민하는 관점은 서로 많이 다르다. 일반적으로 시장 세분화(Market Segmentation)의 목적은 다음과 같다. 정확한 시장 상황을 파악할 수 있다. 이것은 욕구나 구매 동기 등을 파악하여 향후 변화하는 수요에 대응할 수 있는 기준이 된다. 기업의 경쟁 좌표를 설정할 수 있다. 어떤 시장에서 플레이할 것인지 또는 어떤 고객에게 제품이나 서비스를 공급할 것인지 등에 따라 경쟁 강도가 달라진다. 세분화를 통해 기업의 강점과 기회를 활용할 수 있는 시장 또는 고객을 찾아야 한다. 정확한 표적(target)의 설정이 필요하다. 세분화를 통해 각 세그먼트의 매력도를 평가하여 마케팅 활동의 방향을 설정하고 집중해야 한다. 세분시장에 대한 마케팅 성과 및 소비자 반응을 분석하여 마케팅 자원을 효율적으로 배분할 수 있어야 한다. B2C 사업의 시장 세분화는 소비자(Consumer) 개개인이 어떤 특성을 가지고 있는가를 분석하여 시장을 구분하는데 일반적으로 TableIII-16과 같은 기준을 많이 사용한다. Table III-16. 시장세분화의 변수 Table III-16의 변수들을 사용해 수차례 세분화 작업 후, 의미 있는 세분 시장(segment)이 도출되는데, 세분 시장은 다음과 같은 요건을 갖추어야 한다. 세분시장은 정보의 측정과 획득이 용이해야 한다 세분시장은 수익성이 보장되어야 한다 세분시장은 접근 용이성과 전달성이 높아야 한다 세분시장은 명확한 구분 성과 차별된 반응성이 높아야 한다 세분시장은 일관성과 지속성이 있어야 한다 또한, 시장 세분화에 이어 고객 세분화(Customer Segmentation)를 할 필요도 있는데 이때는 보통 RFM에 기준하여 분류하게 된다. RFM 이란 Recency 최근 언제 구매하였나? Frequently 얼마나 자주 구매하였나? Monetary Value 얼마나 많이 구매하였나? (금전적 관점) 위의 3가지 사항을 개인 소비자별로 평가하여 집중적으로 마케팅을 해야 할 고객 군이 무엇인지 파악하는 것이다. 요즘은 다양한 마케팅 정보를 분석하여 가상의 표본 인물을 만들고 그의 생활 속에서 다양한 시나리오를 구성하여 캠페인을 전개하는 방안도 많이 사용한다. 한편, B2C 사업과 달리 B2B 사업에서는 B2B 사업의 속성[1] 상, 시장 세분화보다는 고객 세분화에 보다 큰 의미를 부여하며 철저하게 파레토 법칙(Pareto’s Law)을 고려한다. B2B 사업에서 고객은 기업 고객으로 일반 소비자와는 그 특성이나 니즈가 매우 많이 다르기 때문이다. 고객 세분화는 기업의 전략에 따라 매우 다양하게 시도할 수 있는데 전통적이면서도 가장 일차원적인 접근은 산업 분류를 고려한 것이다. 산업의 분류 기준에 따라 고객도 생산업자(Producer), 재판매업자(Distributor or Wholesaler), 정부/유관 조직(Governmentor NGO)의 3가지로 나눌 수 있다. Figure III-24. 전통적인 고객 분류 방법 첫 번째 생산업자는 제품이나 서비스를 생산하는 기업군으로 농업, 수산업, 임업과 같은 1차 산업 기업군을 말하며, 일반 소비자나 기업들을 대상으로 다양한 제품을 제조/생산하는 2차 산업 기업군, 그리고 금융, 교통, 의료, 요식, 숙박, 레저, 엔터테인먼트 등과 같은 서비스 산업 중심의 3차 산업 기업군으로 구분될 수 있다. 두 번째, 재판매업자는 1/2/3차 산업에 속한 기업들이 생산한 재화와 용역을 유통하는 도매상과 분배 업체, 소매상 등이 이에 해당하며, 세 번째 정부/유관 조직은 연방, 주, 시 등을 포함한 정부 기관과 교육 기관, 자선단체, 공익을 목표로 하는 비영리 단체 등이 해당한다. 그런데 산업 구분에 의한 분류 방법은 전략적 시사점을 얻기 어렵기 때문에 지리적 위치(Geography), 채널(Channel), 기업 통계(Filmography) 등을 활용하여 정보의 질적 향상을 도모하기도 한다. 좀 더 풍부한 정보를 기반으로 상세한 고객 프로파일링(Customer Profiling)을 할 수 있지만 사실(Fact) 전달 수준에 그치지 않는다는 느낌이 든다면 다음과 같이 해 볼 것을 권고한다. B2B 고객 분류 시에는 경제적 관점에서 포착된 사업 기회 및 실적 등을 고려하여 고객을 분류하는 것이 바람직하며 이런 방법을 ‘Value-Based Segmentation(VBS)’라고 한다. VBS는 고객 계층화 관리(Tier Management), 파레토 법칙 등 다양한 기법들을 적용하여 고객군을 발굴할 수 있다. Figure III-25. Value Based Segmentation 사례 특히, 고객 충성도(Customer Loyalty)와 고객 관리 비용(Retention Cost)의 관점에서 매트릭스를 만들면 핵심 고객은 고객 충성도가 높아 재구매율이 높고 고객 관리비 용도 적게 드는 고객, 파트너 고객은 고객 충성도는 높지만 고객 관리 비용이 많이 드는 고객 등으로 분류할 수 있다. 실제 파트너 고객을 잘 대응하여 고객 관리 비용을 줄일 수 있다면 사업성과 창출 측면에서 매우 유익하며, 범용상품 고객에게는 범용품(Commodity)이상의 가치를 제공할 수 있다면 해당 고객을 핵심 고객으로 전환할 수도 있다. 아울러 저 성과 고객은 점진적으로 거래를 줄여나가는 것이 장기적 관점에서 기업 경영에 도움이 된다. 고객 충성도와 고객 관리 비용, 제품 구매액을 지름으로 하는 원을 가지고 버블 차트로 그려보면 Figure III-25와 같이 그려질 수 있다. 상위 Tier1, Tier 2에 속한 고객들 즉, 핵심 고객 군(Key Customer Segment)은 소수이나 기업의 제품 판매액 중 상당 비중을 차지하는 고객들을 뜻하며 과거와 현재의 고객인 기존 고객 군에 비해 잠재 고객 군은 신규 및 미래의 고객들로서 마케팅/영업 활동을 보다 집중해야 할 필요도 있다. 고객 세분화에 따른 마케팅전략을 수립하면 범용상품 고객에게 어떤 마케팅 활동을 할 것인지? 영업 측면에서는 어떤 제안을 통해 핵심 고객으로 전환할 것인지? 파트너 고객에게 소요되는 고객 관리 비용은 어떻게 감소시킬 것인지? 또한 구매액 또는 거래금액은 어떻게 증가시켜 버블의 크기를 키울 것인지 등 마케팅, 영업, 내부 혁신, 사업전략 관점의 과제 수립이 가능하게 된다. Table III-17은 세분화의 장단점을 정리한 것이다. Table III-17. 세분화 분석의 장단점 시장세분화 또는 고객 세분화를 수행하면서 다양한 생활 스타일(Life Style)을 연구하는 마케팅 관련 종사자들은 그때그때 시대상을 반영한 재미난 버즈(Buzzword)들을 많이 만들어내기도 한다. 다음은 그런 차원에서 널리 알려진 용어들이다. - DINK: Double Income No Kids - GLAM: Greying, Leisured And Moneyed - GUPPY: Gay, Upwardly Mobile, Prosperous, Professional - YUPPIE: Young Urban Prosperous Professional - SITKOM: Single Income, Two Kids, Oppressive Mortgage - WASP: White Anglo-Saxon Protestant. 8.2 군집분석(Cluster Analysis) 한자성어에 유유상종(相從)이라는 말이 있다. 비슷한 부류의 사람들이 어울림을 뜻하는 말인데 군집분석(Cluster Analysis)은 개인 또는 여러 개체 중에서 유사한 속성을 지닌 대상을 몇 개의 집단으로 그룹화한 다음, 각 집단의 성격을 파악함으로써 데이터 전체 구조의 이해에 대해 이해하고자 하는 방법이다. 쉽게 말해서 유사한 것끼리 차례대로 합쳐 나가는 것을 말하는데 여기서 유사한 정도(similarity)를 측정하기 위해 거리나 상관계수 등 통계적 기법이<NAME>된다. 예를 들면 카드사에서 VIP 고객들을 군집화하여 일반 고객군과 어떤 차이점이 있는지 파악하여 일반 고객들 중 VIP 고객들의 특성을 띤 고객(군)을 대상으로 마케팅 캠페인을 실행할 수 있다. 이런 군집분석에는 다음과 같이 2가지 방안이 있다. 계층적 군집분석 비계층적 군집분석 계층적 군집분석은 N 개의 군집을 가지고 시작하여 최종적으로 하나가 남을 때까지 유사한 것끼리 합치는 방법(Bottom-up 방식. 병합방법)과 모든 레코드를 포함한 하나의 군집에서 N 개의 군집으로 나누는 방법(Top-Down 방식, 분할 방법)이 있다. 비계층적 군집분석은 요인분석(factor analysis)을 통해 미리 군집을 예상하여 합쳐가는 방법이다. K-means 분석 같은 것이 대표적인 방법이다. 군집분석은 고객 세분화 또는 시장 세분화를 포함한 다양한 마케팅 및 영업 전략에 활용할 수 있으나 이를 이용해 통계적 의사결정을 할 때 가장 큰 문제는 군집 수(number of clusters)를 몇 개로 할 것인가를 결정하는 것이 항상 이슈이다. 학자들의 다양한 의견이 있지만 아직 결론이 나지 않았으며 분석자의 주관에 따라 다르다. 그 말은 모든 통계가 그렇듯이 통계의 유의미성을 확보하는 것이 가장 중요하며 비용 효율적인 방법이 고려되어야 한다. Table III-18은 군집분석의 장단점을 정리한 것이다. Table III-18. 군집분석의 장단점 군집분석은 통계 소프트웨어을 활용하는 것을 포함하여 통계적 이해가 기반이 되어야 하므로 이 장에서는 기본적인 개념만 소개하였다. 통계 소프트웨어는 SPSS, SAS와 같은 전문적인 프로그램을 구입하는 것도 좋지만 주머니 사정이 넉넉하지 못하다면 어둠의 경로를 이용하여 불법 소프트웨어에 탐닉하지 말고 공개 소프트웨어를 이용해 보자. 그런 측면에서 'R'은 매우 훌륭한 도구이다. 최근 빅데이터 분석이 뜨면서 대중에게 공개되고 있는 공공 데이터의 분석도 이런 R을 통해 쉽게 해볼 수 있다. 윈도, macOS, 리눅스 등 다양한 플랫폼에서 동작 가능하고 R 자체가 스크립트 프로그래밍이 가능하므로 R-Studio를 통해서 원하는 작업을 수행하여 Presentation 할 수 있다. 관심 있는 분들은 아래 사이트를 참고하시라. R 프로젝트 : 공개소프트웨어인 R을 소개하고 프로그램을 다운로드할 수 있다. https://www.r-project.org/ R Studio : R의 인터페이스를 사용하기 쉽게 만들어 소위 말하는 IDE(통합개발 환경)을 제공한다 https://www.rstudio.com/ *참고로 macOS를 사용하는 사람은 Xcode도 같이 설치해야 한다. 여기서 IDE 환경을 불러오는 듯 [1] STP: Segmentation, Targeting, Positioning [2] B2B 사업은 거래가 자주 발생하지는 않지만 규모도 크며, 거래가 한번 발생하면 지속되는 경향이 있다. 08. 고객 요구 분석(2/3) 8.3 고객 경험 분석 2000년 초반 CRM 마케팅이 한참 이야기될 때 고객 관계(Customer Relationship)라는 용어가 매우 중요했다. 고객 경험(Customer eXperience: CX)은 고객 관계 다음의 단계로서 온라인에서는 사용자 경험(UX:User eXperience)으로, 오프라인에서는 고객의 일상을 두고 다양한 고객 경험 이벤트를 발생시키는 것이 최근 CX 트렌드이다. 그런 차원에서 고객의 피드백을 실시간으로 수집하고자 하는 니즈가 커져가고 있고, IT 설루션 사업자들은 관련된 대시보드(Dashboard)의 구축 같은 것을 주요 사업 기회로 보고 있다. 고객 경험 분석의 관건은 소비자나 고객[1]이 어떻게 기업의 제품이나 서비스를 인자하게 되었으며, 어떤 계기로 그것을 구매를 결정하게 되었으며, 어떤 방식으로 구매하게 되었는지, 구매 이후 사용하면서 무엇이 좋았고 무엇이 불만이었는지, 향후 재구매한다면 어떤 기능이 보완된 것을 구매할지 등 제품의 인지부터 서비스 종료에 이르는 전 과정에서 소비자나 고객의 생각을 읽고 파악하여 그에 대응할 수 있는 또는 그것들을 사전에 충족시킬 수 있는 제품이나 서비스를 개발하고자 하는 것이다. 그런 차원에서 고객과의 모든 접점을 가장 중시해야 하며 그 접점에서 고객의 피드백을 적시에 파악하여 이를 제품과 서비스에 반영하는 것이 가장 중요하다. Figure III-26. 고객 경험의 흐름 Figure III-26은 고객이 제품과 서비스를 구매하는 과정을 놓고 각 단계별로 고객 경험이 어떻게 전달되는지를 도식화한 것이다. 결국은 고객 경험의 각 단계와 기업 내 Value Chain이 상호작용하면서 고객 경험에 대처하게 된다. 컨설팅 관점에서 이런 CX를 파악하고 분석하기 위해서는 다음과 같은 질문들에 대해 답해보아야 한다. 질문의 프레임워크는 다분히 고객 데이터를 얻기 위한 관점이다. 고객 경험을 어떻게 측정할 것인지, 프로세스를 어떻게 구현할 것인지, 어떻게 분석할 것인지, 나아가 경영에 어떻게 반영해야 할 것인지 궁극적으로 이것을 플랫폼으로 만들고자 하는 것이 고객 경험 관점에서 중요한 포인트이다. 그런 차원에서 고객 경험 분석을 위한 질문들은 다음과 같은 것들이 있다. 기업가치 측면에서 고객 경험이란 무엇인가? 어떤 고객 경험이 기업 성과에 기여하는가? 고객 경험을 어떻게 측정할 수 있는가? 어떻게 고객 경험을 분석할 수 있는가? 예. 빅데이터 분석 등 고객 경험을 관리하기 위한 IT 플랫폼은 어떤 모습인가? 지속적이고 다양한 고객 경험의 제공에도 불구하고 일관된 경험을 제공하기 위한 전략은 무엇인가? 기업의 프로세스 또는 조직문화에서 일관된 고객 경험의 피드백은 어떻게 반영될 수 있는가? 고객 경험 지향적인 기업의 조직문화는 어떤 모습인가? 최근 거의 모든 기업들의 제품과 서비스는 O2O[2]의 형태를 종착지로 플랫폼(Platform) 서비스를 갖추고자 총력을 펼치는 형국이다. 이미 소비자들이 온라인과 오프라인을 넘나들기 때문에 온라인과 오프라인의 다양한 상황을 넘나드는 고객의 피드백을 파악하고 매 순간 고객 경험을 제공해야 하는 기업들 입장에서는 마케팅 전략의 근본부터 고민이 많을 수밖에 없다. 고객을 단순히 따라가기보다는 고객 경험 분석을 통해 고객을 선도할 수 있는 방안을 찾는 것이 관건이라 할 수 있겠다. Table III-19는 고객 경험 분석의 장단점을 정리해 본 것이다. Table III-19. 고객 경험 분석의 장단점 Break #14. NPS와 고객 충성도 비즈니스 컨설팅을 하게 되면 고객 기업의 제품 및 서비스의 시장 반응을 살펴보기 위해 고객만족도(CSAT. Customer SATisfaction scores)나 고객 충성도(Customer Loyalty)를 살펴보게 된다. 고객만족도는 고객 관계를 고려해서 대부분 좋게 평가하는 까닭에 고객만족도가 높다고 해서 실제 재구매나 재계약이 발생하는 확률은 낮다[3]. 이런 부분을 감안하여 실질적인 재구매 의사를 파악하기 위해 최근 글로벌 기업들 사이에서 빠르게 확산되는 기법으로 ‘NPS’라는 것이 있다. Figure III-27. NPS 평가의 개념 NPS란, Net Promoter Score의 약자로 2003년에 Bain & Company가 소개하여 북미를 중심으로 널리 활용되고 있다[4]. NPS는 생각보다 상당히 쉽게 계산되는데 다음 질문에 대해 10점 척도로 답하여 평가한다. “How likely are you to recommend [product/service] to colleague or friend?” 즉, 동료나 친구에게 당신이 쓰고 있는 제품이나 서비스를 추천할 것인가를 물어보는 것이다. 0~6점은 비추 천자(detractors), 7~8점은 소극자(Passives), 9~10점은 홍보자 (Promoters)로 구분한다. 구매 추천을 문의하는 것이기 때문에 기존의 만족도 조사와 같다고 생각할 수 있다. 그러나 다른 조사와 달리 NPS는 질문 하나로 바이어스(Bias) 없이 매우 쉽고 빨리 직관적인 결과를 얻을 수 있다. 계산은 위의 질문에 대한 답을 응답자 수로 나누어 백분율(%)로 표기하게 되는데 -100%에서 +100%까지 나올 수 있다. 음수 값이 나올 경우는 고객 충성도가 낮다는 의미이고 조사를 하는 기업 입장에서는 무조건 양수 값이 나와야 재구매 가능성을 발견하게 된다[5]. 단일 기업이 아닌 산업 군을 대상으로 조사하면 NPS의 상한과 하한을 포함하는 범위도 산정 가능하므로 경쟁사와의 비교라든가 벤치마킹 도구로도 활용할 수 있다. 8.4 핵심 구매요소 분석 앞서 니즈(Needs)와 원츠(Wants), 디맨드(Demand)에 대해 설명했었다. 니즈에서 디맨드까지 발전하고 구매 요구사항(Requirements)로 구체화되면 비로소 고객 가치(Customer Value)에 대해 이야기해 볼 수 있다. 고객의 구매 요구사항의 관점에서 고객 가치는 '비용 대비 효과의 차이'로 매우 단순하다. 그 효과는 편익(Benefit)의 묶음이며 이것은 금전적인 측면 또는 비금전적인 측면으로 나타날 수 있다.[6] 즉 고객 가치는 다음과 같이 표현할 수 있다. Value = Benefit – Total Cost 고객이 가치를 느끼는 것은 투입된 비용보다 편익이 클 때이다. 그러나 고객 가치는 상대적인 개념이라 같은 제품을 놓고도 고객들은 서로 다르게 느낄 수 있다. B2C 제품들을 소비하는 일반 소비자들은 디자인이나 기능을 포함해서 제품을 구입한 장소나 순간 등 매우 감성적인 부분까지 포함하여 다양한 면에서 가치를 느끼는 반면, B2B 사업의 고객들은 제품 구매 시 다음 5가지 속성을 가장 중요하게 생각하고 있다.[7] 신뢰성(Reliability) 전문성(Expertise) 가치(Value) 효율성(Efficiency) 맞춤형(Customization) 신뢰성은 제품에 대한 신뢰나 관계에 대한 신뢰를 의미하는 것으로 B2B 고객들이 거래의 기본으로 생각하는 것이다. 이런 이유로 B2B 사업에서 사업 사례(Reference)가 반드시 필요하며 중요하게 언급되는 이유이기도 하다.[8] 기본 속성인 신뢰성을 갖추기 위해서는 전문성 및 가치가 입증되어야 한다. 전문성이라 함은 고객 산업 및 업무에 대한 전문성, 기술 전문성 등이 그것이며 그로 인해 시장에서 가치를 인정받는 제품을 공급받고 고객의 제품도 그로 인해 시장에서 경쟁력을 갖추게 되는 것이다. 효율성은 가치와 연결되는 속성인데 비용적 측면이 좀 더 강조된 것으로 생각할 수 있다. 마지막으로 제품 구입 시 요구되는 각종 요구사항들은 중간재이든 완성품이든 기업 고유의 것들이 많기 때문에 맞춤형은 B2B 고객들이 가장 중요하게 생각하는 것이다. 맞춤형 요구사항을 충족시키기 위해서는 다양한 고객 정보가 필요하기 때문에 이를 잘 대응한다는 것은 그만큼 고객기업이나 고객 사업을 잘 알고 있다는 것과 일맥 상통한다. 따라서 B2B 기업 입장에서 ‘맞춤형’은 고객 가치 실현에 있어서 가장 중요한 요소이다.[9] 이처럼 고객이 제품을 구매할 때 어떤 부분이 마음에 들어서, 어떤 사유로 구매하는지 분석하는 것을 ‘핵심 구매요소(Key Buying Factors: KBF) 분석’이라고 한다. 공급되는 제품의 사용 용도와 더불어 어떤 요소와 특징들이 그 제품을 구매하게 만드는지를 조사하는 것인데 KBF 분석을 수행하면 위에서 설명한 5가지 범주에 거의 들게 되고 보다 구체적인 항목으로 상술된다. 예를 들어 Figure III-28과 같이 고객 A, 고객 B, 고객 C는 제품 구입 시 가장 중요하다고 생각되는 요소들이 각각 다르다. Figure III-28. KBF 분석에 따른 가치 제안 따라서 고객 A에게는 가격적 측면에서, 고객 B는 기술력 측면에서, 고객 C는 납기 측면에서 마케팅과 영업활동이 집중되어야 성공적인 거래가 이루어질 수 있다. 이어진 Table III-20은 KBF 분석의 장단점이다. Table III-20. KBF 분석의 장단점 [1] 본문에서는 B2B 고객은 고객, B2C 고객은 소비자로 표기하였다. [2] Online-to-offline 온라인과 오프라인을 통합하는 마케팅 및 서비스 [3] 미국 소비자 조사 기관인 J.D.Power 조사에 따르면 약간 만족한다고 답한 90%의 고객 가운데 47.9%만이 제품을 재구매한 것으로 나타났으며 Bain& Company의 연구에서도 이탈 고객의 65~85%가 ‘만족’ 이상의 점수를 준 고객으로 파악되고 있다고 2011년 한국경제신문에서 인용하였다. [4] 2003년 Bain & Company의 Fred Reichheld가 하버드 비즈니스 리뷰(HBR)에 ‘The One Number You Need to Grow’’라는 글을 싣고 이후 세상에 널리 알려졌다 [5] 실제 NPS 조사 결과를 보면 상당히 낮게 값이 나온다 [6] 그러나 여러 가지 기법을 통해 정량적으로 변환 후, 궁극적으로 모두 돈으로 표현하는데 이는 커뮤니케이션 일원화를 위함이다 [7] 저자가 컨설팅 등을 수행하면서 체험한 것에 기반한 것이며 설문조사 등에 근거한 데이터가 있는 것은 아니지만 아마 Survey를 해도 비슷하게 나오지 않을까 생각한다 [8] B2B 제품에서는 그렇기에 Pilot 수행이나 Proof of Concept 같은 것이 중요하다 [9] 많은 고객들이 의외로 혁신이나 디자인 등을 위의 5가지보다 우선으로 두지 않았다 08. 고객 요구 분석(3/3) 이번 순서는 고객 요구 분석의 마지막으로 제품과 기술 관점에서 분석하는 법에 대해 살펴보자. 8.5 제품 수명주기 분석 (Product Life Cycle) 사람이 태어나서 70~80세를 산다고 하는 것처럼 제품에도 수명이 있어 어떤 제품의 도입부터 쇠퇴까지 그 기능이나 효용의 생명력이 있다고 전제하고, 그에 맞는 마케팅/영업 전략을 구사하기 위해 사용하는 것이 제품 수명주기 분석이다. 제품 수명주기(Product Life Cycel: PLC)는 보통 도입기, 성장기, 성숙기, 쇠퇴 기와같이 4단계 또는 5단계로 구분되며 그 내용은 다음과 같다. Figure III-29. 제품 수명주기 그래프 도입기(Introduction): 제품의 도입기는 전혀 새로운 때때로 진보적인 제품이나 상품이 세상에 등장한 경우이다. 스마트폰의 세계를 열었던 애플의 아이폰(iPhone)을 생각해 볼 수 있다. 도입기의 제품은 인지도를 확보하는 것이 지상과제이다. 제품에 대한 홍보와 소비자/고객에 대한 교육 등이 마케팅 전략 차원에서 필요하며 시장 진입을 위한 적합한 가격 전략 예를 들면 skimming pricing, penetrating pricing 등을 고려해야 한다. 성장기(Growth): 성장기는 도입기를 통해 제품에 대한 인식이 확장되고 본격적으로 매출이나 영업이익이 증가하는 단계를 말한다. 성장기의 제품에 대해서는 영업이익의 재투자를 통해 경쟁 대비 강력한 차별화 포인트를 확보하는 것이 중요하다. 이는 후발 시장 진입자들에게 강력한 진입 장벽을 만들 수 있는 계기가 되기 때문이다. 경쟁자가 등장하기 전까지는 skimming pricing을 유지하는 것이 좋을 수도 있고, 경쟁자가 등장하였다면 그동안 축적한 생산이나 판매 학습효과를 활용하여 가격 인하 정책을 취하는 것도 좋다. 성숙기(Maturity): 성숙기는 경쟁자들도 많고 시장점유율도 거의 고착화된 상황이다. 현상 유지가 중요하며 원가 절감을 위한 노력, 제품 완결성 등이 요구된다. 아울러 고객 맞춤형 상품이나 서비스 개발 및 다양한 가격 전략을 통해 성숙기를 지속시키는 방안이 필요하다. 쇠퇴기(Decline): 쇠퇴기는 기술적으로 노화되고 고객의 흥미를 더 이상 끌지 못하는 상태를 말한다. 기존 제품의 새로운 용도를 찾아보거나 기존 제품의 고객 가치가 통용되는 새로운 시장 개척이 필요하다. 쇠퇴기 제품은 시장에서 사라지거나 혁신을 통해 재도약하느냐의 기로에 서 있는 경우가 많으며 기존 시장을 타깃 한다면 가격은 많이 떨어지게 된다. 일부 제품의 경우, 희귀 성 또는 희소성으로 추가 이익도 달성할 수 있지만 이 경우 상당한 브랜드 경쟁력이 뒷받침되어야 한다. 그러나 PLC 개념이 항상 옳은 것은 아니며 실제 사업 환경에서는 맞지 않는 경우도 많다. 브랜드 파워와 합쳐질 경우, 생명주기가 지속되는 경우도 있고 없어질 듯한 제품들도 브랜드를 입어 다시 태어나는 경우도 많다. 일회적 사용일 것이라는 전구나 컴퓨터 사용으로 인해 없어질 것이라고 한 종이가 현재까지 존재하고 있으며 아직도 널리 사용되고 있는 것과 같은 이유이다. Table III-21은 제품 수명주기의 장단점을 정리한 것이다. Table III-21. 제품 수명주기의 장단점][1] 8.6 S-커브 분석 S-커브 분석은 기술 관점에서 사업을 보는 대표적인 분석 방법으로 대부분의 하이테크 산업(High-Tech Industry)에서 적용할 수 있다. 신기술 개발의 성과가 초반에는 별 볼일 없는데 갑자기 폭발적인 성장 궤도를 그리다가 어느 시점에 정체되어 사라지는 모양이 마치 알파벳 S와 같다고 하여 S-Curve 분석이라 부른다. Figure III-30. S-Curve의 개념 S-커브의 첫 단계는 상용화 이전의 시험 단계로 기업이 신제품을 시장에 내놓고 주목을 받으면서 완만히 성장하는 단계이다. 시간이 지나면서 제품의 결함도 노출/보완이 되고 인지도도 증가하면 대중의 관심을 끌게 되면, 갑자기 가파른 성장을 하게 된다. 그러다 소비자의 선호도가 변화하고 경쟁 제품(대체재)이 등장하면서 성장이 정체되고 퇴조기를 맞이하게 된다. 퇴조기를 극복하고 Figure III-31과 같이 주기적으로 새 S-커브로 갈아타며 성공을 거듭하는 기업을 ‘하이-퍼포먼스 기업(High Performance Company)'이라고 한다. 페이스북의 경우, 사용자 수가 2억 명에 도달하기 전까지 5년이 걸렸는데 8억 명에 도달하는 데는 2년 밖에 걸리지 않았다고 한다. 크리스텐슨(Clayton M.Christensen. 1962 ~ 현재)은 그의 혁신 이론 중 와해성 기술(Disruptive Technologies)을 설명하면서 우량 기업들이 주력 제품의 점진적 개선에만 매달리다가 결국 시장 지배력을 잃게 되는 경우를 직면하지 않기 위해서는 와해성 기술을 수용하여 새로운 시장을 찾아내야 함을 혁신의 딜레마(Dilemma)로 설명한다. 즉, 성장과 이익이 가파를 때 새로운 가치를 찾아 도전해야 지속적으로 성장 가능할 수 있다는 의미이다. Figure III-31. 고성과 기업의 S-커브 한편, S-커브는 Figure III-32와 같이 제품 수명주기 – 도입기, 성장기, 성숙기, 쇠퇴기 분석과 같이 사용할 수도 있다. S-커브의 제품 시험 단계는 제품 수명주기로 보면 도입기에 해당한다. 또한, 성장기와 성숙기는 S-커브의 성장기에 해당하고 제품 수명주기의 쇠퇴기는 S-커브의 쇠퇴 기와 매칭될 수 있다. Figure III-32. 제품 수명주기와 S-커브의 결합 Table III-22는 S-커브 분석의 장단점을 요약한 것이다 Table III-22. S-커브 분석의 장단점[2] 개인의 지식 습득이나 학습 관점에서 보더라도 S-커브는 유용한 시사점을 제공한다. Figure III-33은 S-커브의 도입부부터 성장에 이르기까지는 선순환 사이클(Virtuous Cycle)이 발생한다. S-커브의 도입부에는 선순환 사이클이 발생하여 역량 강화에 급격한 성장(Hyper Growth)을 야기하고 성장 정체기에 접어들면 악순환(Vicious Cycle)이 발생하여 지식 습득이나 역량 강화에 한계에 달하게 된다. Figure III-33. S-커브의 선순환 구조와 악순환 구조 8.7 기술 수용 곡선(Adoption Cycle) 분석 첨단 기술이 만들어내는 제품을 다루는 마케팅을 하이테크(High-tech) 마케팅이라 하는데 이와 관련해서는 제품 수명주기(PLC) 분석이나 S-커브 분석, 기술 수용 곡선 분석 등을 종합하여 분석하는 일이 매우 일반적이다. 기술 수용 곡선은 첨단 기술이 적용된 신제품들의 혁신성을 어떻게 받아들이며 이것이 어떻게 기업의 캐시카우(Cash cow)로 전환되는지를 설명하는 것이다.[3] 기술 수용 곡선에서는 Figure III-34와 같이 5가지 집단이 혁신적인 신제품에 대해 반응하게 된다. 혁신 수용자 그룹(Innovators): 새로운 기술이 나왔을 때 무조건 수용하는 그룹으로 신기술에 문제가 있거나 불편하더라도 아무런 불만을 표출하지 않는다. 선각적 수용자 그룹(Early Adopters): 신기술의 진가를 알고 이것의 경제적 가치와 전략적 의미를 높게 산다 전기 다수 수용자 그룹(Early Majority): 실용적 구매 그룹으로 신기술에 관심이 많지만 모험을 지양하고 신기술이 성숙화, 안정화될 때까지 기다리는 그룹이다 후기 다수 수용자 그룹(Late Majority): 첨단 기술에 부정적인 시각을 가지고 있으며 신기술이 업계 표준의 지위를 확보하지 못하면 수용하지 않는다. 지각 수용자 그룹(Laggards): 신기술을 결국 활용하지만 기술의 존재나 근원적 특성 등에 대해서는 알지 못한다 Figure III-34. 로저스 혁신 곡선(Roger's Innovation Curve) 하이테크 산업에서 등장하는 신기술의 대부분은 실패하는 경우가 많다. 로저스(Everett Rogers. 1931 ~ 2004)는 신기술로 만들어진 제품들이 시장 점유율 16%를 넘으면 성공할 것이라고 했던 반면, 제프리 무어(Geoffrey Moore. 1920 ~ 현재)는 선각적 수용자 그룹과 전기 다수 수용자 그룹의 심리적 차이 즉, 캐즘(Chasm)[4]을 극복하지 못하면 실패할 것이라고 주장하였다. 두 사람 의견 모두 현장 논리이므로 상황에 따라 판단할 수 있다. 어찌 되었던 선각적 수용자 그룹(Visionaries)과 실용 주의자 그룹(Pragmatists)의 특성을 구분하고 마케팅 전략에 그에 맞게 수립해야 캐즘을 극복할 수 있다는 점이 중요하다. Table III-23은 기술 수용 곡선의 장단점을 요약한 것이다 Table III-23. 기술 수용 곡선의 장단점 Break #15. 가트너그룹의 하이프 사이클 곡선(Hype cycle curve) IT 리서치 기업은 가트너 그룹(www.gartner.com)은 기술 수용 주기 곡선을 연구하다가 이 모델의 단점을 발견하게 되었다. 기술 수용 곡선의 확률 값을 누적하면 Figure III-35와 같은 형태의 S-곡선을 그리게 된다. Figure III-35. 누적 형태의 기술 수용 곡선 초기의 혁신 수용자 그룹이나 선각적 수용자 그룹을 거쳐 캐즘(chasm)을 극복하면 주류로 확대되면서 수용 도는 급격히 증가한다. 그러다 성장률이 정체되고 서서히 쇠퇴하게 되는 모양이다. 여기서 수용 도는 시장 규모라고 생각해도 되는데 시장의 성장 추이를 비교적 정확하게 모델링하고 있다고 볼 수 있다. 그런데 문제는 기술 기업들이 이 수용도를 시장 규모보다는 기술에 대한 시장의 관심도나 이해도가 증가하는 것으로 오판하고 시장 진입을 시작하면서 실패하는 경우가 많다는 것을 발견하였다. 즉, 신기술에 대한 시장의 관심도가 최고조에 달했을 때 시장의 성숙이 극에 달했다고 판단하는 오류를 범하게 되는 것이다. 또한, 관심이 식으면 시장이 이미 성숙기에 들어섰다고 판단하거나 쇠퇴기로 진입한다고 생각하여 시장을 경쟁자들에게 내주는 경우도 발생한다. 그래서 가트너는 신기술에 대한 수용 도와 시장의 관심도는 서로 별개라는 것을 ‘hype(과대한, 과장된) cycle curve’라는 것으로 표현하고 있다. Figure III-36. Hype Cycle Curve과 누적 S-Curve Figure III-36과 같이 가트너의 하이프 사이클 곡선은 시간이 지남에 따른 신기술의 관심도를 나타낸 것으로 시장이 아직 초기임에도 관심도가 극에 달하는 거품기가 있다는 점이 특이하다. 기술 수용도가 20%가 되는 시점을 지나면 시장의 관심이 점점 사그라지며 실제적인 첫 제품이 나오게 된다. 가트너는 이 20%가 되는 점을 주목하고 FigureIII-37과 같은 신기술 수명주기 곡선을 개발하고 이를 가트너 하이프 사이클 곡선(Hype Cycle Curve)으로 소개하고 있다. 거품기가 지나고 본격적인 시장규모 확충과 포지셔닝을 기대할 수 있다. Figure III-37. 가트너그룹의 Hype Cycle Curve 지금까지 고객 요구 분석에 대해 알아보았다. 마지막에 기술/제품에 관한 분석 법을 고객 요구 부분에 넣은 것은 기술 수용에 대한 고객의 관심도가 매우 중요하고 전략이나 마케팅에 적지 않게 영향을 주기 때문이다. 어떤 산업은 첨단 기술이 중요하고, 어떤 산업은 첨단 기술보다는 안정적이며 검증된 기술이 중요하다. 그런 산업이나 업무 특성이 결국 고객의 니즈, 원츠, 디맨드를 결정하는데 중요한 영향을 끼친다는 것을 잊지 말자. 경쟁 및 산업 분석에서 재무비율 분석을 살펴보았는데 다음 장에서는 그 부분을 확대하여 사업의 수익성을 검토하는 수익성 분석에 대해 살펴보도록 하자. [1] 컨 조인트 분석은 어떤 제품이나 서비스 등에 대해 여러 가지 대안들을 만들어 그 대안들에 부여하는 소비자들의 선호도를 측정하고 소비자가 각 속성(attributes)에 부여하는 상대적 중요도(relative importance)와 각 속성 수준의 효용(utility)이나 부분 가치(part-worth)를 추정하는 분석 기법을 말함 [2] 수평적 사고(Lateral Thinking)는 기존에 확립된 패턴에 의해 논리적 사고를 전개하는 것이 아니라 통찰력과 창의력을 발휘하여 새로운 측면에서 문제 해결을 시도하는 것을 의미한다. [3] 혁신 확산 이론이라는 용어로도 불리며 사회과학에서도 사용한다. [4] 캐즘은 지질학적 용어로 지층의 움직임으로 생겨난 골을 의미한다. 즉, 소비가 막 시작되다가 갑자기 뚝 꺼지는 현상을 생각하면 되는데 특히, 신기술을 적용한 제품의 경우에 많이 목격할 수 있고, 그런 기술 기반의 스타트업들이 이를 극복하지 못하면 거의 대부분 망한다. 그래서 최근에는 스타트업도 신기술 기반이 아니라 기존의 업무나 기술의 부분을 혁신하면서 길을 찾는 경우가 성공 확률이 높다. 09. 수익성 분석(1/2) 경쟁 및 산업분석의 4번째 시간에서 이미 재무비율 분석을 다루어보았다. 경쟁 및 산업 분석 (4/4) 재무비율 분석 .. 장사는 돈을 벌어야지! | 7.8 재무비율 분석 이번 시간에는 경쟁 및 산업 분석의 마지막 순서로 재무분석에 대해 알아보자. 정확히 말하면 재무비율 분석이다. 경쟁력을 판단하는 중요한 잣대로 결국 '기업이 돈을 잘 벌고 있는가?'하는 것은 가장 중요한 문제이다. NGO[1]가 아닌 이상, 비전도 좋고 전략도 좋지만 결국 사업을 잘 해서 돈을 버는 것이 목적이므로 그 목적에 어느 정 brunch.co.kr/@flyingcity/56 이 장에서는 기업의 전반적인 실적을 평가하여 해당 기업의 재무건전성을 다루는 재무비율 분석을 넘어서서 특정 사업이나 프로젝트의 수익성을 분석하는 것까지 살펴보고자 한다. 수익성 분석을 제대로 끝내면 기업의 재무건전성은 물론이고 해당 사업 또는 프로젝트에서 어떤 항목 또는 동인들(drivers)이 비용을 유발하는지 또는 가치를 창출하는지도 알 수 있을 것이다. 컨설턴트 입장에서는 그런 부분을 찾아내서 비용을 많이 유발하는 항목은 없애거나 낮은 비용 요소로 대체할 수 있는 옵션을 제시하고, 가치를 창출하는 부분은 더욱더 큰 가치를 창출할 수 있도록 제안하는 일이다. 사실 비즈니스 컨설팅의 가장 중요한 부분이라 할 수 있다. Figure III-38을 따라 지금부터 상세히 살펴보자. Figure III-38. 수익성 분석 로드맵 9.1 비용구조 분석 각 산업의 특성을 고려해 그 산업 내 원가의 회계적 인식이 다르듯[1], 그 원가를 산정하는 방법도 매우 다양하다. 원가의 3 요소라 불리는 재료비, 노무비, 경비를 취급하는 차이로 인해 다양한 원가계산법이 파생되는데 제품 원가 계산(Product Costing)을 통해 이를 알아보자. 제품 원가 ‘계상(計上)’은 ‘기업이 생산하는 재화나 용역의 원가를 측정하는 것으로 원가 자료를 확인, 집계, 분류하여 특정 원가 단위와 연관시키는 것’을 뜻한다. 산업에 따라 조금씩 차이는 있으나 일반적으로 제조 원가는 Figure III-39와 같이 구성된다. Figure III-39. 제품 원가의 산정 사례[2] 즉, 제품의 생산과 관련된 원가 요소 - 직접재료비, 직접노무비, 직접경비 등을 직접원가로 반영하고, 간접재료비, 간접노무비, 간접경비 등을 제조간접비로 반영한다. 그것이 제조원가가 되며 거기에 판매비와 일반관리비 등을 더하면 총 원가가 된다. 기업회계에서는 제조원가만 원가라 칭하고 판매비와 일반관리비, 지급이자 등은 비용으로 취급한다. 따라서 ‘매출 계획 - 목표이익 = 허용 비용 또는 허용 원가’로 계산되는 계획 손익을 개선하려면 매출을 확대하던지 허용 비용(제조원가, 판매관리비, 영업외비용 등)을 절감해야 한다. 이런 기본적인 원가 산정 개념은 다양한 방법으로 확대될 수 있는데 다음과 같이 구분할 수 있다. 원가를 집계하는 방식에 따라 다음과 같이 구분한다. 개별원가 계산(Job-Order Costing) 종합원가 계산(Process Costing) 개별원가 계산은 각 작업별로 원가를 계산하는 방식으로 고객이 요구한 작업에 대해 순차적으로 일이 진행되면서 원가가 더해지는 방식이다. 조선업이나 건설업 등에서 많이 쓰이며 특히, 건설업의 경우 공사의 진척도에 따른 공정을 산출해 현재까지 시공된 부분만큼의 소요자금을 의미하는 기성고를 고려한다. 종합원가 계산은 일정 회계 기간 동안 특정 공정에서 발생한 모든 원가를 집계하는 방법으로 정유나 화학약품 생산처럼 연속공정에 의해 제품을 대량으로 생산하는 산업에서 많이 활용한다. 또, 제품 원가에 고정 제조 간접 원가의 포함 여부에 따라 다음과 같이 구분한다 전부원가 계산(Absorption Costing) 직접원가 계산(Direct Costing) 전부원가 계산은 전통적인 원가계산 방식으로 기업회계 기준에 따라 직접비와 간접비를 구분하여 배부하는 방식으로 외부 공시를 위한 재무회계에서 사용하는 표준적인 원가 산정 기법이며, 직접원가 계산은 변동비는 제품 원가로 계상하지만 제품 생산과 무관한 고정비는 제품에 부과하지 않고 그대로 기간 원가에 일괄 집계하는 방식이다. 원가 측정 기준에 따라 다음과 같이 구분할 수도 있다. 실제원가 계산(Actual Costing) 표준원가 계산(Standard Costing) 평준 화원 가 계산(Normal Costing) 실제 원가계산은 실제 제품 구입 가격 및 수량을 기준으로 제품의 원가를 계산하는 것을 말하며, 표준원가 계산은 사전에 정해진 표준가격 및 표준수량을 바탕으로 제품의 원가를 계산하는 것을 말한다. 또한, 평준 화원 가 계산은 직접재료 원가와 직접 노무원 가는 실제원가를 적용하고, 제조 간접 원가는 설정된 예정 배부율에 따라 결정된 원가를 적용하는 방식이다. 따라서 어떤 방식의 원가계산 방법을 적용하느냐에 따라 재고자산의 평가나 기간 손익이 달라진다. 또한, 원가계산을 수행하더라도 실제 원가가 발생되면 차이가 생기는데 계획 대비 실적 매출의 증감에 의해 또는 계획 대비 실제 투입원가의 차이에 의해 손익에 변동이 생긴다. 회계적으로 이는 정합성을 가져야 하므로 지속적으로 통제 및 관리를 수행한다. 건설이나 시스템 구축과 같은 프로젝트를 수행하는 기업들의 경우, 고유의 원가 이익모델(Cost& Price Model)을 가지고 있는데 프로젝트 PM은 경영진이 승인한 목표 재무수치를 프로젝트 기간 동안 변동을 최소화하여 잘 관리하고 목표를 상회할 경우, 이익의 일부를 인센티브로 받기도 한다. 또한, 2000년대 초 전략적 경영 관리 즉, 균형성과 지표(Balanced Scorecard. BSC)와 더불어 전통적인 원가 산정 모델 문제점을 개선하기 위하여 활동기준원가 계산(Activity-Based Costing: ABC)이 주창되었다. 전통적인 원가계산의 문제점이란 제조간접비 등 개별 제품의 원가 배부에 있어서 전통적인 원가계산이 노동시간 또는 기계 시간 등 한 가지 요인을 정하고 그 요인을 기준으로 간접비를 배부하여 원가 평준화 현상을 가져오게 되었고 이는 원가 왜곡으로 이어져 ABC를 통해 투입자원이 제품이나 서비스로 변환되는 과정을 명확히 밝혀 제품이나 서비스의 원가를 계산하고자 하였다. 이는 실제 제대로 구축될 경우 경영전략 관점에서 많은 시사점을 얻을 수 있으나 오늘날 제대로 적용하는 기업은 없는 것 같다. 앞서 경쟁 및 산업분석에서 살펴보았던 Value Chain 분석도 ABC가 제대로 구축되어 있다면 훨씬 더 많은 통찰력을 제공할 수 있을 것이다. Figure III-40. 손익계산서 전환 사례 그러나 살펴본 것처럼 원가를 산정하는 것은 쉬운 작업이 아니다. 더군다나 왜 이렇게 다양한 방법을 생각해야만 할까? ‘컨설턴트가 이런 것까지 알아야 하나?’라고 생각할 수도 있겠다. 그러나 회계사 수준까지는 아니겠지만 ‘반드시 알아야 한다’. 그래야 숫자로 피드백되는 결과를 통해 해당 사업이나 프로젝트의 개선점을 발견할 수 있고, 제품 경쟁력 강화 차원에서도 아이디어를 얻을 수 있다. 예를 들어 Figure III-40에서 표현한 것처럼 전부원가 계산법에서는 잘 보이지 않던 것이 직접원가 계산법을 적용하면 변동비와 고정비를 파악할 수 있게 되었다. 변동 비율이 낮으면 공헌이익률이 높다. 즉, 손익분기점 매출액이 낮아지기 때문에 이익을 내기가 쉽다는 의미이다. 원가를 좀 쉽게 계산하는 방법은 없을까? 이미 알고 있는 사람들도 많겠지만 저자가 알고 있는 방법을 한 가지 소개하면 ‘원가율’을 이용하는 것이다. 원가율은 매출원가를 매출액으로 나눈 값인데 전년도 손익계산서를 이용해서 원가율을 계산할 수 있다. 예를 들어 전년도 매출원가가 700억이고 매출액이 1,000억이라면 원가율은 70%이다. 이 원가율을 전년도 판매한 제품 가격에 곱해주면 제품별 원가를 산정할 수 있다. 물론 이 계산은 제품별로 원가율이 같다는 전제를 가지고 있다. 규모가 큰 대기업의 경우 다양한 제품 포트폴리오를 가지고 있는데 이 경우 특별한 정책이 없다면 원가율은 상이할 수 있다. 그런 경우에 이 방법을 적용해서는 안 된다. [1] 관리회계는 산업이나 기업의 특성에 따라 다르다 [2] 판매 이익은 총 원가의 10% 가정 9.2 손익분기점 분석 손익분기점(Break Even Point: BEP)은 기업 회계에서 수익과 비용이 일치하는 점으로 이익도 손실도 생기지 않는 매출액 또는 매출량을 의미한다. 이는 경영 관점에서 매우 많은 통찰력을 제공하는데 직접원가 계산법을 상기하면서 손익분기점에 대해 알아보자. Figure III-41은 손익분기점의 개념을 설명하고 있다. Figure III-41. 손익분기점의 개념 매출액 - 변동비 = 공헌이익 … (1) 공헌이익 - 고정비 = 영업이익 … (2) 매출액 = 공헌이익 + 변동비 = (고정비 + 영업이익) + 변동비 … (3) 매출액 - (변동비+고정비) = 영업이익 … (4) 또한, 공헌이익은 매출액에서 변동비를 뺀 금액으로 고정비 회수와 이익 획득에 공헌하는 이익을 말하는데 변동 비율이 낮으면 공헌이익률이 높고, 반대로 변동 비율이 높으면 공헌이익률이 낮다. Figure III-42. 공헌이익과 변동 비율 손익분기점과 공헌이익 분석은 사업 추진 및 경영 활동에 많은 통찰력을 준다. 마케팅 관점에서는 제품 원가 산정에 대한 고민, 생산의 아웃소싱, 목표이익 획득을 위한 매출 목표 산정 등에 활용할 수 있다. Figure III-42는 고정비에 대한 언급이 없지만 고정비와 변동비를 줄이는 노력을 함께 해야 한다. 고정비 총액을 낮추기 위해 고정비 증가를 억제하거나 외주분을 줄일 수도 있다. Table III-24는 손익분기점 분석의 장단점을 요약한 것이다. Table III-24. 손익분기점 분석의 장단점 09. 수익성 분석(2/2) 9.3 사업 수익성 분석(Business Unit Profitability) 사업 수익성 분석은 기업의 사업 포트폴리오 중 특정 사업이나 세그먼트(segments)의 수익성을 분석하여 기업의 사업별 또는 경쟁사의 사업과 비교하는 기법이다. 가장 일반적으로 사용되는 방법은 영업이익률(ROS. Return On Sales)과 자본이익률(ROCE.Return On Capital Employed)이다. 특정 사업의 영업이익률은 해당 사업 본연의 활동을 통해 벌어들인 매출액에 대해 순원가를 제한 이익의 비율을 나타낸 것으로 ROS가 놓을수록 사업의 수익성이 우수한 것이다. 자본 수익률(ROCE)[4]는 해당 사업에 투입된 총 자본에 대해 얼마나 수익을 얻었느냐를 평가하는 것으로 총 자본에 대한 이자 및 세전이익의 비율을 나타낸 것이다. EBIT: Earnings Before Interests and Taxes 이자 및 세전이익. 총 자본: shareholders funds +debt Figure III-43. 사업 수익성 분석 사례 보고서의 표현은 보통 Figure III-47과 같이 기업의 사업 내용을 각 사업 단위 또는 세그먼트 단위로 구분하고(보통 계단식 차트로 표현) 각 사업 단위 또는 세그먼트의 ROS와 ROCE를 계산하고 차트로 표현한다. 제조 설비가 크게 필요하지 않은 서비스 산업의 경우, 자본 수익률을 계산하기보다는 매출(Sales)과 영업이익률(ROS)을 같이 표현하기도 한다. TableIII-25는 사업 수익성 분석의 장단점을 요약한 것이다. Table III-25. 사업 수익성 분석의 장단점 9.4 규모의 경제(Economies of Scale) 일반적으로 기업이 재화와 서비스의 생산을 증가시키면 그에 필요한 평균 비용[1]도 비례하여 증가한다. 그런데 철로 구축 등 대규모 인프라 구축이 필요한 철도 사업이나 통신이나 자동차 사업같이 제품이나 서비스 생산을 위한 대규모 설비 구축이 필요한 산업의 경우는 생산량을 늘릴수록 평균 비용이 하락하는 현상이 나타난다. 이런 효과를 '규모의 경제(Economies of Scale) 효과'라고 한다. Figure III-44는 규모의 경제 개념을 그래프로 보여준다. Figure III-44. 규모의 경제 개념 실제로 규모의 경제가 나타나는 경우는 다음의 경우이다. 연구개발, 생산설비 구축 등 초기 비용 대비 이익의 극대화 대량 생산을 위한 원자재 대량 구입으로 재료비 절감 및 물류비 감축 분업에 따른 생산 요소의 전문화 이를 통해 조기에 시장을 장악하는 자연독점 현상이 발생하기도 한다[2]. 그러나 일정 수준 이상 규모가 커지면 조직 운영비가 증가하고 기업 구조가 경직되는 등 규모의 경제 효과가 상쇄된다. 이를 ‘X-비효율성’이라고 부른다. 20세기 산업 사회에서는 기업 활동에서 가장 중요하게 생각했던 것은 자본, 원자재, 노동력으로 만들어 내는 생산성(Productivity)과 효율(Efficiency) 이었다. 즉, 최대 생산과 최대 소비가 경제 관점에서는 지상 목표였다. 그런데 어느 순간 공급이 수요를 초과해버렸고 최대 생산은 과잉 생산이 되어 낭비가 되고, 최대 소비는 가계 부채의 증가로 이어졌다. 이를 타개하기 위해서는 생산과 소비의 적정 규모 유지, 즉 ‘최적 생산과 최적 소비(또는 최소 생산과 최소 소비)’이 중요해졌고, 이미 인터넷을 통해 연결된 거대한 글로벌 시장에 효과적으로 대응하기 위해 물량을 동시에 공급하고 관리하는 것은 어떤 대기업도 감당하기 쉽지 않은 일이기 때문에 상호 간에 연계된 세계 경제는 이를 통제할 수 있는 정보화에 큰 관심을 가질 수밖에 없게 되었다. Figure III-45 사례를 보면 규모의 경제 효과가 존재하지만 1을 2배로 하여도 비용은 크게 줄어들지 않는다. 즉, '의미 있는 규모를 확보할 수 있는 최적 생산 부분이 존재한다.'는 것이다. Figure III-45. 규모의 경제 분석 사례 또한, 규모의 경제와 같이 생각해 볼 다음과 같은 개념들이 있다. 규모의 비경제(Diseconomies of Scale). 어떤 산업은 소규모로 생산하는 것이 더 유리할 때가 있는데 장인들이 생산하는 수공업품들이 거의 그렇다. 명품을 대량으로 생산하게 되면 비용이 더 증가하는 것과 같다. (이 경우, 매스티지(masstige) 상품들과는 구별해야 한다) 범위의 경제(Economies of Scope). 규모의 경제와 비슷할 것 같지만 전혀 다른 얘기로 규모의 경제는 하나의 재화를 생산할 때 이야기이고 범위의 경제는 두 개 이상의 재화를 각각 다른 생산자가 생산할 때보다 하나의 생산자가 생산할 때 비용이 감소한다는 개념으로 수직 계열화(Vertical Integration)를 택하는 동기가 된다. 경험 곡선(Experience Curve)과도 구분되는데 규모의 경제는 절대 생산량이며 경험 곡선은 누적 생산량이다. Table III-26은 규모의 경제 분석의 장단점을 정리한 것이다. Table III-26은 규모의 경제 분석의 장단점 9.5 경험 곡선 (Experience Curve) 경험 곡선 효과는 1960년에 BCG 컨설턴트였던 Bruce Hendersen에 의해 처음 사용되었고 한다. 다른 용어로 ‘학습 곡선(Learning Curve)’라고도 알려져 있는데 Hednersen은 제품이나 서비스의 누적량과 기업의 비용 사이에 일관된 관계가 있음을 발견하고 이를 분석해 본 결과, 시간이 지남에 따라 기업에서 제품이나 서비스를 생산할 때 더 빠르고 좋아진다는 것을 발견하였다. 즉, 누적 경험량이 많은 기업은 제품 생산에 소요되는 비용도 감소하고 그만큼 수익성도 증가한다는 것이다. 최근 들어서는 정량적인 측정의 중요도보다는 산업에 따라 경험 곡선이 경쟁 우위(Competitive Advantage)로 전환되는 경우도 많아서 신규 사업에서 이것을 적용할 수 있는가? 얼마만큼 빨리 적용할 수 있는가?를 알아보는 도구로 많이 사용한다. Figure III-46. 경험 곡선 분석의 사례 Figure III-46은 경험 곡선의 사례를 설명하고 있는데 이 곡선의 기울기 20%는 실제 누적 생산량이 2개 증가하면 단위 생산 비용은 20% 감소한다는 의미이다. 외삽법(extrapolation)[3]을 통해 향후 추정치도 예측할 수 있고 이것이 산업 내 제품이나 서비스 누적량으로 대체될 수 있다면 경쟁력을 가지기 위해 어느 수준까지 생산량을 확대해야 하는지 목표치도 가늠할 수 있다. 그러나 대량생산, 대량 구매, 대량소비시대에는 전략적 도구로 충분히 활용하기 유용하였으나 최근과 같은 보호무역주의 시대나 스마트 기술 발달에 따른 대량 최적화(Mass Customization) 생산 시대에는 큰 통찰력을 제공하기는 어렵다. 개념적으로 고객과 커뮤니케이션하는 용도로 유용하다. Table III-27은 경험 곡선 분석의 장단점을 요약한 것이다. Table III-27. 경험 곡선 분석의 장단점 9.6 가격탄력성(Price Elasticity) 분석 수요의 가격탄력성은 가격의 변화에 따른 수요의 민감도를 나타내는 것이다. 어떤 제품이든 가격이 오르면 수요가 줄고, 가격이 내리면 수요가 증가한다. 그런데 즉, 가격이 오르거나 내리는 정도에 따라 수요가 어느 정도 민감하게 반응하는 것인지를 정량적으로 표현하기 위해 아래 수식과 같이 수요량의 변동 비율을 가격의 변동 비율로 나눈 것이다. 수요의 가격탄력성 e가 1보다 크면 탄력적(elastic) 수요, 1보다 작으면 비탄력적(inelastic) 수요라고 한다. 2016년 있었던 담뱃값 인상 사례를 예를 들면 수요의 가격탄력성이 1보다 많이 컸다고 한다. 이는 담뱃값이 올랐지만 그에 따란 판매량 변화(감소일 것이다)는 더욱 컸다는 말로 결국 담배 회사들은 수익이 많이 줄었을 것으로 추정할 수 있다. Figure III-47. 가격탄력성 분석 사례 또한, 가격 탄력성은 다음과 같은 것들의 영향을 받는다. 대체재의 유무. 가격이 오를 때 그것을 대체할 대체품을 쉽게 구할 수 있다면 쉽게 그리 옮겨갈 수 있기 때문에 탄력성은 커진다. 대체재의 가격. 필수품이냐 사치품이냐? 즉, 필수품이면 비싸도 살 수밖에 없지만 사치품이면 가격 변동이 클 경우 구매하지 않는다. 필수품은 비탄력적 즉, 탄력성이 작고 사치품은 탄력성이 크다. 대체재의 중독. 소비재가 중독에 가까운 효과를 내면 탄력성이 작다. 술이나 담배를 끊기 어려운 것을 보면 알 수 있다. B2B 사업에는 이를 ‘Lock-in Effect(교착 효과)’라고도 설명한다. 즉, 한 번 판매해서 좋은 레퍼런스가 만들어지고 해당 제품이나 서비스에 대한 의존도가 커지면 교체 비용(switching cost)도 커지기 때문에 다른 제품이나 서비스로 교체하기 어렵게 된다. 즉, 비탄력적이라 할 수 있다. 따라서 B2B 사업은 한 번 거래가 발생하여 고객의 신뢰를 얻으면 지속될 가능성이 높다. Table III-28은 가격탄력성 분석의 장단점을 정리한 것이다. Table III-28. 가격탄력성 분석의 장단점 지금까지 비용구조 분석을 시작으로 손익분기점 분석, 사업 수익성 분석, 규모의 경제, 경험 곡선, 가격탄력성까지 살펴보았다. 3C 분석을 기준으로 보면 고객/시장, 경쟁을 이해하고 자사를 이해하기 위해 수익성 분석[5]을 살펴보았다. 전략적 대안의 판단 또는 선택을 위해 추상화 수준이 좀 높은 역량에 대해 다음 장에서 살펴보도록 하자. [1] 총생산비용 / 총생산량 [2] 대기업이 중소기업보다 더 많은 이익을 낼 수 있음을 설명하는 기반이 되기도 함 [3] 보외법이라고도 함. 보간법(내삽법)이 주어진 구간 내에서 값의 추정을 위해 사용하는 방법이라면 외사 법 또는 보외법은 구간 밖의 값을 추정하기 위해 사용하는 방법. 데이터의 경향을 보고 과거나 미래의 값을 추정할 때 많이 사용함 [4] 이와 비슷한 개념으로 투하자본수익률(ROIC. Return On Invested Capital)이 있다. 이는 사업에 집중해서 보는 것으로 영업용 순자산에 대한 세 후 영업이익률이라고 볼 수 있다. ROIC = 영업이익 / 영업용 순자산= 영업이익 / (자산총계– 비영업자산 – 영업부채) = 영업이익 / (비 영업부채 + 차입금 + 자본총계– 비영업자산) [5] 순현가분석(NPV) 같은 것도 이번 장 수익성 분석에서 다뤄질 수도 있겠으나 저자는 Part III의 마지막 장인 대안의 선택에서 같이 다룰 계획이다. 10. 역량 분석 지금까지 앞 장에서 주로 설명했던 관점은 국내외 경제 및 산업 동향, 고객의 요구 등 기업 외부의 환경과 그 변화에 대해 분석하는 도구와 기법들에 대해 주로 소개하였다. 이 장에서는 기업 내부의 역량에 대한 고찰과 그 경쟁력에 대해 분석하는 법이 중심이 될 것이다. 기업의 역량에 대해 이해하는 것은 기업의 경영 전략 수립을 위해서는 필수적이다. 고객을 감동시키기 위해서 우리의 제품이나 서비스에는 어떤 고객 가치가 담겨야 하는지? 그렇게 하기 위해서는 어떤 역량이 필요한 것인지? 이는 경쟁사와 비교해서 얼마나 강한지 등에 대한 분석이 역량 분석이라 할 수 있다. 국제노동기구는 역량을 다음과 같이 표현하였다. Competencies covers knowledge, skills, and know-how applied and mastered in a specific context ---------- ILO:R195, HRD Recommendation, 2004 지식과 스킬, 경험을 포함한다는 표현은 매우 적절함과 동시에 분석을 매우 어렵게 하는 요인이 되기도 한다. 이제부터 역량 분석에 대해 자세히 알아보자. Figure III-48. 역량 분석 로드맵 10.1 자원과 능력의 관계 경영전략 컨설팅에서 기업 전략 또는 경영 전략을 수립하기 위해서는 우선 전략 수립의 관점을 결정하는 것이 가장 중요한데, 자원 준 거론(RBV)[1] 관점에서 전략을 수립하고자 할 때는 다음과 같은 순서로 일을 진행한다. 1. 기업이 보유한 자원(Resources)과 능력(Capabilities)을 분석한다 2. 이를 최대한 활용할 전략을 수립한다 3. 수립된 전략에 필요한 자원 및 능력과 기업이 현재 보유한 자원 및 능력의 차이(Gap)를 채울 실행과제 들을 도출한다. 그렇다면 자원과 역량은 어떻게 정의되는 것일까? 자원은 크게 다음과 같은 3가지로 나뉜다. 유형 자원(Tangible Resources). 기업의 유형 자원은 그 파악과 평가가 가장 유용한 자원으로 현금과 같은 재무적 자원과 건물, 기계와 같은 물리적 자원으로 구분할 수 있다 무형 자원(Intangible Resources). 기업의 무형 자원은 쉽게 평가할 수 없으나 결코 무시할 수 없는 자원으로 대표적인 것으로 기술과 평판(Reputation)이 있다. 인적 자원(Human Resources). 인적 자원은 사람인데 사람을 자원으로 본다는 시각에 이의를 제기하는 사람들도 있지만 현대 경영에서는 매우 중요하게 다루고 있다. 지식의 원천이 되기도 하고 기계를 능가하는 성과를 보여주기도 한다 Table III-29는 다양한 기업의 자원과 측정지표를 소개하였다. Table III-29. 기업 자원의 종류 및 측정 그렇다면 기업의 능력(Capabilities)은 무엇일까? 이런 정의나 주제는 사람마다 생각이 다르고 이에 대한 논의 자체를 매우 현학적(衒學的)으로 느낄 수도 있다. 저자 생각에도 이런 논의가 그다지 실질적이지 않아 한편으로는 일에 도움이 될까 생각도 들지만 기업의 능력을 다음과 같이 정의해 보고자 한다. 예를 들어 공장 설비와 공장 직원은 위에서 언급한 것처럼 각각 기업의 유형 자원이고 인적 자원이라 할 수 있다. 그리고 이것들이 잘 융화되어 만들어 내는 생산 능력은 기업이 보유한 역량(Competencies)[2]이 될 수 있다. 즉, 기업의 역량이 제대로 발휘되기 위해서는 자원과 능력의 조합이 매우 중요한 것이다. 그런데 실제 회사 생활을 하면서 기업의 자원과 능력에 대해 생각해 보면 다음 2가지 경우를 매우 많이 접할 수 있다. 1. 하나하나의 자원으로서는 훌륭하지만 조합으로서는 형편없는 경우 2. 자원 하나하나는 별 볼일 없지만 조합으로서 큰 능력을 발휘하는 경우 자원과 능력의 조합을 중요하게 생각하고 경쟁우위나 지속 가능한 역량으로 유지하고자 하는 고민은 기업의 핵심 역량(Core Competence) 개발로 이어지게 된다. 즉, RBV 관점에서 경영 전략은 핵심 역량을 어떻게 개발하고 발전시키느냐가 가장 큰 관건이 된다.[3] 광의의 개념으로 기업의 역량(Competence)은 기업이 보유한 능력(Capabilities)과 산업에서 차지하고 있는 구조적 입지(Structural Position)로 구분할 수 있다.[4] Table III-30은 기업이 보유한 능력과 산업에서 차지하고 있는 구조적 입지에 대해 설명하고 있다. Table III-30. 기업 능력과 구조적 입지 Table III-30에서 표현된 것처럼 보유 역량과 구조적 입지가 상호보완적으로 작용하여 경쟁력의 수준이나 고객 가치의 기여도가 높은 역량이 핵심 역량으로 정의된다. 10.2 핵심 역량의 개념 기업의 역량(Competency)을 이해하기 위해 기업의 자원(Resources)과 능력(Capabilities)에 대해 앞서 살펴보았다. 프라할라드(C.K.Prahalad.1941 ~ 2010)와 하멜(GaryHamel. 1954 ~ 현재)에 의해 소개된 핵심 역량의 개념은 다음과 같다. 핵심 역량(CoreCompetence)이란, 경쟁 기업에 대해 절대적인 경쟁 우위(Competitive Advantage) 창출을 가능하게 하는 기업의 독특한 자원(Resources)과 능력(Capabilities)의 조합을 의미하는 것으로 시장에서 구입 가능하거나 재생산, 복제, 대체가 불가능한 유무형의 자산이다. 위의 정의에서도 언급되었지만 핵심 역량은 사업적 관점에서 다음 4가지 속성을 충족시켜야 한다. 1. 독창성(Uniqueness). 핵심 역량은 다양한 지식 및 경험, 기술의 결합으로 한 기업만이 가지는 독특함 으로 경쟁사 대비 차별적 우위를 가져야 한다[5]. 2. 희소성(Rareness or Inimitability).핵심 역량은 경쟁사가 모방하거나 흉내 낼 수 없어야 한다 3. 고객 수혜(Customer Benefit).핵심 역량은 기업의 고객이나 소비자들에게 혜택을 줄 수 있어야 한다. 4. 가치 창출(Value Creation). 핵심 역량은 새로운 사업 기회를 열어줘 신제품 시장으로 진입하고 타 산업 및 사업에서의 적용 가능성을 열어주어야 한다. 핵심 역량의 정의나 4가지 속성 등 경영학자들이 개념적으로 잘 설명하였으나 여전히 추상적이어서 도입된 설명이 Figure III-49와 같은 경쟁력 나무(Competency Tree)이다. Figure III-49. 경쟁력 나무 즉, 기업의 핵심 역량이 나무의 뿌리에 해당하고 핵심 제품이나 서비스는 나무의 큰 줄기나 큰 가지, 사업 영역은 작은 가지, 나뭇잎이나 열매들은 고객이나 소비자에게 전달되는 최종 제품이나 서비스로 생각하면 된다.[6] 한때, 삼성그룹은 핵심 역량 이론을 경영 전반에 녹여 반영하였는데 그때 사용한 ‘신수종 사업’이라는 용어가 정부와 산업계에 널리 알려지기도 하였다. 10.3 핵심 역량의 측정 및 관리 컨설팅에서 기업의 핵심 역량을 파악하고 평가하는 방법은 일반적으로 TableIII-31과 같이 5단계를 거쳐서 진행된다. Table III-31. 핵심 역량의 분석 단계 및 적용 기법 각 단계별로 조금 더 상세히 알아보면 첫 번째, 시장을 이해하고 기업이 보유한 강점을 파악하기 위해서는 다차원적(Multi-dimensional) 시각에서 기업의 경쟁력을 파악하고 그것을 깊게 이해해야 한다. 기업의 보유 역량, 업무 프로세스(Value Chain), 조직 구조의 역할과 책임을 인터뷰 등을 통해서 이해하고 외부 시각의 관점에서 시장 내 입지(Outside-In Perspective)를 파악하고, 내부 시각의 관점(Inside-Out Perspective)에서 현재 보유하고 있는 강점을 파악한다. 두 번째, 보유 역량을 정의하는 일은 강점의 근거와 경쟁 대비 수준을 파악하고 시장 내 성공을 위해 또는 전략적 필요성에 의해 요구되는 역량을 정의한다. 일반적으로 이는 역량과 구조적 강점으로 구분되는데 특히, 역량은 경쟁우위 및 고객 가치와 매핑되어 각 역량이 시장과 각 사업 세그먼트에서 중요함이 이해되어야 한다. 세 번째, 핵심 역량 우선순위를 결정하는 것은 Figure III-50과 같은 경쟁우위-고객 가치 매트릭스를 많이 활용한다. Figure III-50. 경쟁우위-고객 가치 매트릭스 파악된 각 역량 그룹은 시장 세그먼트 별로 역량의 중요성을 비교하고 공통적 핵심 역량을 도출하여 역량 그룹별 추진 방안 및 제반 사항을 점검한다. 네 번째, 역량 이용 및 강화 방안 도출을 위해 크로스 세그먼트(Cross-segment) 별로 공통 필요 역량을 파악하고 타 시장의 확대 적용 여부 및 신규 사업 진출에의 활용 가능성을 점검한다. 이것이 용이한 역량이 경쟁 우위를 가질 확률이 높다. 마지막 다섯 번째로 역량의 개발 및 확보를 위한 계획을 세우게 되는데 변화관리 관점에서 추진 주체를 명확히 하고 계획으로서 관리되기 위해 각종 마일스톤(milestones)을 상세하게 작성하면 된다. 이와 같은 방법으로 핵심 역량을 개발하고 관리하기 때문에 핵심 역량을 분석하는 것은 각 단계별로 진행되어 제대로 되고 있는지를 점검하면 된다. 지금까지 소개한 것은 저자가 과거에 전략기획이나 컨설팅 업무를 하면서 핵심 역량을 다룰 때 사용했던 방법들을 소개한 것이다. 그러나 어떤 방법을 사용하던 역량을 측정하고 정량화하여 관리한다는 것은 많은 어려움이 따른다. 하멜은 핵심 역량이 축적된 지식(Knowledge Stock)이 아니라 흐르는 지식(Knowledge Flow)이라고 하였다. 이는 동적인 단면의 중요성을 강조한 말이라 생각할 수 있다. 어쨌든 기업이 내부적으로 보유한 자원이 중요하다는 생각에서 출발한 핵심 역량 이론은 경영전략에서 한때 중요하게 다루어졌던 것이 사실이고 이를 강화하고 발전시키기 위해 교육의 중요성이 제고되어 기업 내 학습조직의 붐이 일었고 나아가 지식경영의 토대가 되었다. 그러나 역량의 정량적 측정에 대한 이슈도 그대로 물려받아 지식경영의 성과 측정도 도전이 많았다. 또한, 1990년대를 넘어 2000년대까지만 하여도 기업 내부의 역량을 극대화하자는 전략 기조로 내부 성장(Organic Growth) 전략이 주를 이루었으나 오늘날과 같이 급변하는 사업 환경에서는 단일 기업이 모든 혁신을 감당하는 것이 불가능하여 핵심 역량 이론은 퇴색되어 가는 느낌이다. Table III-32는 핵심 역량 분석의 장단점을 정리한 것이다. Table III-32. 핵심 역량 분석의 장단점 Break #16. 지속 경쟁우위(SCA: Sustainable Competitive Advantage) 데이비드 에이커(David Aaker. 1938 ~ 현재)는 핵심 역량과 비슷한 개념으로 '지속 경쟁우위'라는 개념을 주창하였다. 이것은 ‘경쟁우위 능력’과 ‘경쟁우위 자산’으로 구분되는데 경쟁우위 능력은 핵심 역량과 유사한 개념으로 생각할 수 있고 거기에 경쟁우위 자산을 더한 것이다. 기존의 경쟁 우위 개념이 글로벌 경쟁 시대의 도래로 지속 개발(Sustainable Development)과 같은 용어 등이 등장하면서 널리 사용되기 시작하였다. 경쟁 우위(Competitive Advantage)란 경쟁사보다 높은 성과를 달성할 수 있는 능력, 생존하고 성장할 수 있는 능력, 바라는 성과를 성취할 수 있는 능력을 의미한다. 이런 경쟁 우위는 크게 다음 2가지로 구분된다. 환경적 우위(Environmental Advantage) 조직 지식(Organizational Intelligence) 환경적 우위란, 지역적 이점 등으로 확보한 가격경쟁력이나 아웃소싱 등으로 확보한 우위를 의미하고 조직 지식이란 지식경영과 같은 기업 내부 프로세스의 경쟁력으로 인한 성공적 의사결정 지원 역량을 의미한다. 이에 대한 이해를 기반으로 지속 경쟁 우위를 그림으로 표현하면 Figure III-51과 같다. Figure III-51. 지속 경쟁우위의 개념 Figure III-51에 따르면 기업의 자원과 능력으로 만들어진 경쟁우위 A는 시간이 지나면서 경쟁우위로서의 지위를 잃게 된다. 한번 낮아진 경쟁우위는 다시 회복되기까지 시간이 걸린다. (B) 그러나 지속 경쟁우위(C)는 낮아질 때 그것을 지속시킴으로써 경쟁력을 지속적으로 유지할 수 있게 된다. 제품 리더십(Product Leadership), 운영 효율성(Operational Excellency), 고객 친밀도(Customer Intimacy) 등이 그것을 가능하게 한다. 지속 경쟁우위의 속성은 핵심 역량과 유사하여 다음과 같이 이야기하는 사람들도 있다. 모방이 어렵다(difficult to mimic) 독특하다(Unique) 지속된다(Sustainable) 경쟁사에 비해 압도적이다(superior to compete) 다양한 상황에 적응 가능하다(applicable to multiple situation) 그러나 기업의 지속 경쟁우위를 창출하는 가장 중요한 요소는 ‘가치를 창출하는지’와 ‘모방 불가능’하다는 것이다. 결론적으로 가치를 창출하는 것은 시장의 크기를 키우기 위한 여러 가지 행위를 말하며, ‘능력을 모 방 불가능하다’는 것은 유무형의 자원에 비해 능력이 모 방 불가능하다고 느끼는 이유는 기업의 능력이라는 것이 기업 외부 사람들에게 잘 보이지 않으며, 보인다 하더라고 그 결과가 보이는 것이지 원인과 과정은 거의 알 수 없고, 개개인에 속한 것이 아니라 조직의 기능과 프로세스에 종합되어 상호작용하는 수많은 요소들의 종합에 의해 발현되는 것이기 때문이다. 이러한 점은 지속 경쟁우위를 벤치마킹하는 수많은 기업들이 제대로 성과를 달성하지 못하는 이유이기도 하다. [1] Resource-based View. 기업의 내부의 자원과 역량을 분석하고 보유한 자원과 역량을 극대화할 수 있는 전략을 수립하는 전략 개발 관점의 근거가 되는 이론 [2] 경쟁우위(Competitive Advantage) 관점에서 설명하는 것도 있으나 회사 생활에서 사용할 수 있는 실증적인 비즈니스 교양서를 지향하는 본서의 특성상 깊이 서술하지는 않는다 [3] 산업조직론(IO. Industrial Organization)에 근거한 마이클 포터의 경쟁전략 이후 자원 준 거론(Resource-based view) 기반의 핵심 역량 이론은 2000년대 초반까지 중요한 경영전략 이론이 되었다. 사실 핵심 역량은 개념적으로는 공감할 수 있어도 그 측정과 관리에 있어서는 많은 논란을 낳을 수 있고 이견들이 존재할 수 있다. 이에 근간한 지식경영도 같은 범주의 도전이 있었다. 그러나 정량적 성과를 논의하기는 어렵지만 경영전략 컨설팅에서는 중요한 위치를 차지하기 때문에 살펴보는 것이 필요하다. [4] 다분히 이론적 구분인데 계속해서 설명하겠지만 핵심 역량 이론의 가장 큰 단점은 추상적이며 실제로 구체화하거나 그 성과를 측정하기 어렵다는 것이다. [5] 핵심 역량은 지식이나 교육과 깊은 관계를 가지고 있다. 그래서 그 이후 경영 트렌드는 지식경영(Knowledge Management)이 나오게 된다. 그런데 경영을 단순히 관리의 관점에서 보는 것은 좀 그렇지만 피터 드러커가 주창했듯이 측정하지 못하면 관리할 수 없고, 관리할 수 없으면 기업 성과에서는 의미가 없다. 더군다나 핵심 역량은 핵심 성공요소(KSF.Key Success Factors)와 관계도 깊다. 사람들이 관심을 가지게 되면서 핵심 역량이나 지식경영은 그 성과의 측정 및 관리라는 부분에서 많은 도전을 받게 된다. [6] 이 개념은 또 다른 관점에서 해석되어 맥킨지 컨설팅에서는 ‘Three Horizon’으로 구분하기도 했다. ‘Three Horizon’은 사업의 종류를 기반 사업, 성장사업, 미래 사업으로 구분하고 기반 사업의 수익이 성장 사업과 미래 사업을 지원하고 성장 사업은 새로운 자금원으로 키우며 미래 사업은 신사업을 다양한 옵션으로 바라본다는 관점이다. 11. 시사점 및 대안의 도출 흔히 전략적 옵션(Strategic Options)을 도출하는 것은 과학(Science)이라기보다는 예술(Art)이라고 말한다. 그만큼 분석의 결과와 시사점을 가지고도 전략적 옵션을 결정하는 것이 쉽지 않다는 말이며 산업이나 업(業)에 대한 통찰력(Insight)이 요구됨을 의미한다. 또한, 옵션이나 대안, 전략적 선택은 고유한 것으로 각 고객의 사정에 맞는 선택이 되어야 하며, 그래야 최대의 성과를 얻을 수 있다. 단순히 과제(Initiatives)들을 도출하고 확정하는 것에 끝나는 것이 아니라 가능하다면 시나리오 플래닝(Scenario Planning)이나 다양한 시뮬레이션(Simulation)을 통해 과제가 현실에서 어떻게 진행될 것이라는 것에 대한 확신도 필요하다. 컨설팅 도구와 기법을 사용해 다양한 관점에서 분석을 수행하고 선택지들을 도출하게 되면 일반적으로 전략적 선택을 하게 되는데 Table III-33과 같이 전략적 포지션에 따라 미래 포지셔닝을 위한 선택지를 결정할 수도 있다. Table III-33. 전략적 선택의 사례 (O: 유망, X: 유망하지 않음) 또한, 현재 보유한 역량이나 설루션을 기반으로 새로운 사업 기회에 대한 선택을 결정할 수도 있다.[1] 매트릭스를 현재 역량의 보유 수준과 기업의 핵심 사업이냐 아니냐를 기준으로 매트릭스를 구성하면 Figure III-51과 같은 역량-사업 매트릭스를 구성해 볼 수 있다. Figure III-51. 역량/설루션-사업 매트릭스 Part III의 마지막 제11장에서는 앞서 소개하였던 다양한 컨설팅 도구와 기법을 통해 도출된 시사점들을 종합하여 대안(Options or Alternatives)을 도출하는 방법들에 대해 생각해 보자. Figure III-52. 시사점 및 대안 도출 로드맵 11.1 사업 매력도 평가 사업 매력도 평가는 다차원 평가를 사용하는 것으로 결과적으로 보면 매우 간단하다. 지금까지 수행했던 모든 분석 기법들에 대해 가중치를 정하고 Table III-34와 같이 평가하는 것이다. Table III-34. 특정 옵션에 대한 매력도 평가 사례 Table III-34를 보면 높은 가중치를 두고 있는 시장 규모와 고객 수요 부분의 평가에서 높은 평가를 받았기 때문에 이 사업은 매력적이라고 할 수 있다. 그러나 이 사업은 경쟁 강도가 강하고 기술적 요구 사항도 높은 사업임을 알 수 있다. 사업 매력도 평가의 기준은 Table III-34에 나타난 것 이외에도 매우 다양한 항목이 있을 수 있고 그 가중치 역시 고객의 사업 상황이나 시장이나 고객에 대한 인식의 차이에 따라 변화될 수 있다. 즉, 이 경우에서 적용된 것이 저 경우에도 반드시 같으리라는 법이 없음을 유념해야 한다. 아울러 해당 고객만의 관점을 반영할 수 있는 분석 항목이나 척도를 개발해 내는 것은 컨설턴트의 유능함을 나타낼 수 있는 것이기도 하다. Table III-35는 사업 매력도 평가의 장단점을 표현한 것이다. Table III-35. 사업 매력도 평가의 장단점 11.2 순현재가치 평가 순현재가치(NPV: Net Present Value)는 미래의 특정 시점에 발생될 비용이나 수익을 현재 시점에서의 가치로 파악하는 일로 가장 기본적인 전제는 현재의 10,000원과 10년 뒤의 10,000원의 가치가 서로 다르다는 것을 이해해야 한다. 물가 상승률이나 인플레이션 등 다양한 이유로 화폐 가치는 달라지는데 NPV에서는 할인율에 의해 영향을 받는다고 하며 보통 할인율은 시장이자율 정도로 생각하면 된다. 예를 들어 3.0% 이자율로 은행에 1년 동안 1억 원을 예치시킨다고 한다면 일 년 뒤에 내가 찾을 금액은 다음과 같다. 원금 + 이자= 원금 1억 원+ (1억 원 X 3.0%) = 1억 원 X (1 + 3.0%) … (1) 이렇게 얻어진 원금과 이자의 합인 (1)을 다시 1년간 이자율 3%로 맡겨둔다면 원금 + 이자= {1억 원 X (1+3.0%)} + [{1억 원 X (1+3.0%)}X3.0%] = {1억 원 X (1+3.0%)}(1+3.0%) = 1억 원 X(1+3.0%) 2 이를 좀 일반화하면 화폐의 미래가치(FV)는 다음과 같이 표현할 수 있다. (PV는 현재가치, n은 기간) Table III-36은 순현재가치 평가의 장단점을 정리한 것이다.[2] Table III-36. 순현재가치 평가의 장단점 이상으로 Part III. 컨설팅 도구와 기법에 대해 살펴보았다. 널리 알려진 대표적인 도구와 기법들을 소개하였고 해당 산업이나 업종에 따른 다양한 도구와 기법들이 많이 있다. 특히, 논리적 사고체계를 넘어서서 통계를 활용한 과학적 기법의 영역으로 들어가면 다양한 통계기법 및 처리 알고리즘, 수치해석 알고리즘들이 있다. 이것들은 다른 저서를 참고할 필요도 있겠다. 한편, Part II에서 논리적 사고 체계에 대해 생각해 보았고, Part III에서 그것들을 기반에 둔 도구와 기법들을 살펴보았다. Part IV에서는 실질적으로 이런 다양한 도구와 기법들이 프로세스와 만났을 때 또 템플릿화 되었을 때 흔히 방법론이라고 부른다. 소프트웨어의 오픈 소스처럼 방법론도 공개된 것이 있으면 좋을 텐데 이것이야말로 컨설팅 회사들의 자산이라서 공개하지 않는다. 저자가 알고 있는 몇몇 방법론도 라이선스 이슈로 그것을 상세히 설명할 수는 없다. 그러나 큰 카테고리에서 이런 것이 있다 정도는 알면 컨설팅 사업을 이해하는데 많은 도움이 될 것이라 생각된다. Part IV에서는 그것들에 대해 알아보자. [1] RBV 관점의 대응이다. 오늘날은 내부 역량에 기반한 성장(Organic Growth) 만으로 해결하지 못하는 경우가 많기 때문에 이런 관점에 대해서는 다른 의견이 있을 수 있다. [2] 수익성 분석 및 순현재가치 평가 방법을 활용한 투자 성과 평가에 관한 것은 IV. 컨설팅 방법론의 제4장 사업타당성 분석에서 상세히 다룬다. 12. 프로젝트 관리 방법론이란? 컨설팅도 프로젝트이므로 컨설팅 방법론의 가장 근간이 되는 것은 프로젝트 관리(Project Management) 방법론이라 할 수 있다. 프로젝트에 관해서는 PMI[1]와 같은 전문교육기관이<NAME>고 있어 많은 사람들이 참고하고 있다. 이 장에서는 PMI의 가이드를 참고해서 일부 소개하고자 한다. 우선, 프로젝트가 무엇인지 생각해 보아야 한다. 다양한 산업은 물론 초등학교에서도 사용할 정도로 많이 듣던 단어인데 이를 정의해 보라 하면 쉽게 하지 못한다. 매우 다양한 관점에서 프로젝트를 정의할 수 있겠지만 그중 빠지지 말아야 할 세 가지 속성은 다음과 같다. 일시적(Temporary) 고유함(Unique) 결과물(Deliverables) 프로젝트는 일시적이다. 즉, 시작과 끝이 있어서 해당 기간 안에 프로젝트를 끝내야 한다. 또한, 프로젝트는<NAME>다. 어떤 프로젝트도 동일한 것은 없다. 마지막으로 모든 프로젝트는 결과물이 있다. 도로가 생기고 발전소가 생기는 것처럼 컨설팅 프로젝트도 문서 기반의 다양한 산출물이 남는다. 프로젝트 관리 방법론이라는 것은 이런 속성들을 가진 프로젝트를 효과적으로 운용하기 위한 가이드(guide)이 자 템플릿(template), 사례(Best practice)를 포함한 것이라 할 수 있다. Figure IV-3. 프로젝트 관리 방법론의 개념 프로젝트 관리 방법론은 Figure IV-3과 같이 5개의 프로세스가 상호작용하고 있다. 프로젝트 초기화 (Initiating)는 프로젝트 추진을 위한 각종 준비 단계라 할 수 있다. 프로젝트 계획(Planning) 단계는 일정 및 비용 계획, 추진 조직을 확정하는 단계이고 실행(Executing) 단계는 정해진 절차에 따라 일을 진행하는 단계, 종료(closing)와 모니터링 단계로 구성되어 있다. 12.1 프로젝트 관리의 개념 프로젝트 관리는 Figure IV-3에 소개된 프로젝트 업무 그룹을 좀 더 상세하게 구분하여 관리하는 것이라 할 수 있는데, 프로젝트 관리 협회(PMI)에서는 프로젝트 관리 업무를 Table IV-1과 같이 9가지 범주[1]로 나누어 소개하고 있다. Table IV-1. 프로젝트 관리의 9가지 관점 미션(mission)은 명확하지만 유한한 자원을 가지고 결과물을 만들어야 하는 프로젝트는 그 정의처럼 각 영역별 관리가 철저하게 진행되어야 한다. 범위 관리에서는 전체 일의 범위를 정의하는 일을 한다. WBS(Work Break down Structures)라 불리는 작업 분류체계를 만들어 그 순서대로 일을 수행한다. WBS는 일의 수행 주체와 기간이 표기된다. 간트(Gantt) 차트[3]<NAME>을 이용해서 누가, 언제 무엇을 시작하고 끝내는지, 그리고 어느 시점에 무엇을 점검하는지 등 마일스톤(Milestone) 같은 것을 표기하고 관리한다. Figure IV-4. 간트차트 사례 범위와 일정 관리는 기본적으로 PERT/CPM 기법[4]에 근간을 두고 있다. 자원과 시간이 배정되면 그에 따른 비용을 관리해야 한다. 프로젝트에 주어진 예산은 얼마인데 집행되는 비용은 얼마이어서 결과적으로 프로젝트 손익은 흑자이다 또는 적자이다. 예상치 못한 비용 발생을 고려하여 우발비용(Contingency Cost)를 잡기도 하며 각 공정마다 제대로 비용이 집행되고 매입, 매출이 발생하는지 목표 대비 차이(Variance)를 관리하기도 한다. 한편, 프로젝트를 추진할 팀을 구성하기 위해 인원을 수배하고 역할과 책임을 분담하는 일도 매우 중요하며 프로젝트에 필요한 장비를 구매하고 계약하는 일도 매우 중요하다. 이 모든 일들이 프로젝트 진행 과정에서 발생할 수 있는데 그와 관련하여 위험 요소를 식별하고 이를 정성적/정량적으로 관리하는 것도 필수이다. 아울러 이런 것들은 다양한 커뮤니케이션<NAME>을 빌려 공유되고 관리되어야 한다. 한마디로 프로젝트는 종합예술을 하는 것과 같아서 PM은 정말 슈퍼맨이 되어야 한다는 부담도 많이 가진다. Break #17. 프로젝트를 보는 시각 정보시스템을 개발하는 프로젝트와 관련해서는 Figure IV-5와 같은 유명한 이야기가 있다. 내용은 고객은 나무에서 그네가 타고 싶다고 한다. 그것에 대해 프로젝트 매니저(PM)가 이해한 것, 업무 분석가가 이해한 것, 개발자가 이해한 것이 각각 다르다는 것이다. 결국 고객이 나무에서 그네를 타고 싶다고 할 때는 그냥 타이어 하나 매달아도 될 것을 Figure IV-5와 같이 여러 가지 모양의 결과물이 나오게 되었다. 이런 현상은 실제로 정보시스템 개발 현장에서 심심치 않게 발생하고 있다. 고객의 만족도를 높이고 싶다면 고객이 정확하게 무엇을 원하는지를 파악해야 하고 또 그것을 정확하게 제공해야 한다. Figure IV-5. 소프트웨어 개발과 요구사항의 괴리 1.2 PMO의 역할과 책임 프로젝트의 규모가 커지거나 다수의 프로젝트를 관리해야 할 필요가 생길 때에는 고객은 PMO 서비스를 요청하기도 한다. PMO는 ‘Project Management Office’의 약자로 프로젝트 팀과는 별도로 프로젝트를 성공적으로 이끌기 위한 방법을 고민하고 이를 지원하는 사업 관리 조직이라 할 수 있다. 국내 금융 대형 IT 사업의 경우, 컨설턴트들이 PMO를 구성하여 이를 많이 지원하며 동남아 등 개발도상국의 대형 SOC 프로젝트의 경우도 전문가와 컨설턴트들이 PMO를 구성하여 프로그램/프로젝트 관리를 수행한다. 쉽게 말하면 각종 보고 와 산출물, 진척 상황 등 챙겨야 할 것들이 많아서 고객이 이를 감당하기 어려울 때 그 관리를 위해 전문가들을 고용했다고 보면 된다. PMO의 관점은 프로젝트와 거의 유사하나 그 일의 깊이와 범위가 차이가 있다. Table IV-2는 프로젝트 팀과 PMO가 프로젝트 각 영역에서 수행하고 있는 일을 비교한 것이다. Table IV-2. PMO와 프로젝트 팀의 업무 비교 PMO가 왜 필요할까? 금융권 차세대 IT 프로젝트 등을 넘어서 대형 건설 프로젝트 등에서도 PMO의 필요성은 최근 더욱 부각되고 있다. 최근 많이 회자되고 있는 사례로 송파 가든파이브 건설은 여러 가지 문제들이 지적되고 있지만 주요 엔터티(Entity)간에 커뮤니케이션이 제대로 되지 않아 발생한 문제가 매우 크다고 한다. 많은 사람들이 잘 알고 있듯이 송파 가든파이브는 청계천 복원 당시 주변 상가의 이주 대책으로 만들어진 건물이다. 건물 자체는 많은 TV 프로그램에서 본 것처럼 매우 웅장하며 훌륭한 외관을 자랑하고 있다. 그렇지만 많은 사람들이 이 프로젝트를 본래의 목적인 ‘청계천 상가의 상인들의 이주’라는 관점에서 보면 30%에 미치지 못하는 이주율이 보여주듯이 송파 가든파이브 프로젝트는 실패했다는 것에 동의한다. 그 원인을 살펴보면 발주처와 입주민, 시공사 사이의 커뮤니케이션에 문제가 많았던 것으로 파악된다. 원래 프로젝트의 발주처는 서울시였지만 이 복합단지 건설을 위한 요구사항을 낸 사람들은 청계천 상가 이주민 협의체였다. 즉 실질적인 고객이라 할 수 있는데 이주민 협의체는 멋진 건물이 되기를 바라는 마음에 이런저런 요구사항을 내었고 시공사는 이를 충실히 수행했지만 결과적으로 입주 부담금이 높아져 입주할 수 없게 되어버린 것이다. Figure IV-6. 송파 가든파이브 구상도 설계에서도 문제가 있었는데 복개 전 청계천 주변 상가의 대부분은 ‘마지꼬바(町工場(まちこうば))[5]’라고 불리던 소규모 기계가공 업체들이 많았다. 그림 그려다 주면 뭐든 뚝딱 만들어주는 도깨비방망이 같은 기업들이었지만 이들은 영세했고 복합유통단지를 목표로 만들어진 건물 안에 기름때 묻은 자신들의 장비를 놓기에는 적당하지 않다는 것을 나중에야 알게 되었다. 기계 공단을 가보면 길에 검은 띠와 반짝이는 가루들이 있는데 이것은 대부분이 기계의 윤활유가 만들어 내는 흔적이며 기계 가공 과정에서 나오는 금속 가루들인데 복합유통단지에는 그것들을 수용하고 처리할 수 없는 것이다. 적어도 그것들을 처리할 수 있는 별도의 공간이 필요했던 것이다. 결과적으로 이렇게 되었지만 계약 상 보면 시공사나 감리업체는 책임질 것이 없었다. 고객이 해달라는 대로 해주었고 감리 역시 특별히 지적할 사항이 없었기 때문이다. PMO는 바로 이런 경우에 관여하게 된다. 전문적 지식과 경험을 기반으로 한 PMO 구성원들이 고객이 진정으로 원하는 것이 무엇인지, 시공사는 고객의 요구를 제대로 충족시킬 수 있는지, 결과물은 프로젝트 본래 목적에 부합하는지 등을 판단하고 알려주는 일을 맡게 된다. 그래서 제대로 갖춰진 PMO 구성원들을 보면 해당 업에 대한 최고 전문가들로 구성되어 있는 경우가 많고 해외 대형 프로젝트에서 PMO를 수행한 경험을 가질 수 있게 되면 글로벌 인재로 거듭나면서 그런 사람에 대한 높은 수요와 대가를 지불 받게 된다. 1.3 컨설팅 프로젝트 관리 한편, 컨설팅 프로젝트는 건설이나 기계산업의 프로젝트와 달리 업무의 대부분이 문서 작업이기 때문에 철저하게 문서 산출물을 어떻게 생성하고 어떻게 고객에게 검수 받을 것인가 하는 것이 가장 중요하다. 한국의 경우, 글로벌 Top 3 전략 컨설팅 기업이 처음 진출하던 시절만 해도 경영진 보고 몇 번 하고 A4 몇 장의 보고서를 최종 산출물로 내고 철수하는 경우도 많았다.[6] 그러나 요즘은 그렇게 해서는 컨설팅 사업을 수주하고 이행하기 어렵다. 경우에 따라서는 사업 대가 대비 과도하게 생각되는 요구를 하는 경우도 있고, 고객사에도 풍부한 컨설팅 프로젝트 경험을 가진 전직 컨설턴트들이 많이 포진하고 있기 때문에 그들의 눈높이에 맞는 산출물을 만드는 것도 쉽지 않다. 저자가 경험한 바에 의하면 산출물의 질적인 부분보다도 산출물의 양적인 측면에서 가장 까다로운 것은 공공 IT 컨설팅이다. 법률에 의해 각 단계[7] 별로 어떤 문서가 만들어져 나와야 하는지 정해져 있고, 가이드가 있기 때문에 매우 정형화되어 있다. ISP와 같은 정보화 전략 계획을 위한 컨설팅 기업 고유의 방법론을 기본으로 하되 전체적인 프로젝트 관리는 정보시스템 구축 프로젝트를 테일러링 해서 사용한다. Table IV-3. 은 정보전략 컨설팅 프로젝트의 각 단계별 주요 내용과 주요 산출물을 정리해 본 것이다. 소위 말하는, Value Pack List인데 지식과 경험이 풍부한 컨설팅 기업들은 TableIV-3과 같은 형태로 폴더를 구성하고 문서 템플릿, 참고할 수 있는 사례 등을 묶어서 컨설턴트들 사이에서 공유한다. Value Pack이 잘 구성되어 있으면 고객의 상황에 맞게 약간만 수정하여 산출물들을 만들 수 있다. 컨설팅 사업이 지식 사업(Knowledge Business)이라는 것의 반증이고, 산업 유형 또는 사업 유형 등 다양한 구분에 따른 유의미한 Value Pack이 많을수록 컨설턴트들이 일의 본질에 고민할 수 있는 시간이 더 많아지며 결과적으로 보다 효율적으로 일할 수 있게 된다. 컨설팅 사업에서 Value Pack은 필수적이다. 양질의 Value Pack을 갖출수록 보다 빠르게 수준 높은 결과물을 만들어낼 수 있다. 사실문제의 본질에 대한 고민에 많은 시간을 보내야 하는데 그 짧은 기간에 프레임워크 고민하고, 문서 양식 고민하고 한다면 고객의 기대에 부응할 수 없을 것이다. 또한, 시니어 컨설턴트 이상이 되면 보통 2~3개의 프로젝트에 직간접으로 관여하게 되고 PM을 하고 있지만 다음 사업 수주를 위한 마케팅이나 영업, 제안도 해야 하기에 잘 갖추어진 Value Pack 만큼 소중한 것이 없다. 그렇지 못하면 낮에는 프로젝트 수행, 밤에는 영업이나 제안 작업이 일상이 된다 Table IV-3. IT 컨설팅 프로젝트 단계 및 주요 내역 사례[8] Table IV-3을 보고는 ‘음.. 이건 컨설팅이 아니라 구축 사업 아냐?’라고 생각하는 사람들도 있을 것이다. 이 경우 컨설팅 결과물이 정보시스템 구축 프로젝트와 이어지기 때문에 IT 컨설팅 산출물은 당연히 그것과 연관된 것도 많고, 컨설턴트들만 일하는 것이 아니라 프로젝트 팀에 아키텍처, 개발자들도 같이 합류하여 일하는 것이 일반적이다. 또한, 공공 프로젝트는 감리를 해야 하기 때문에 RFP에 있는 항목들이 제대로 준수되고 있는지를 제3자 시각의 관점에서 점검하는 일도 발생한다. 따라서 문서의 종류는 많지만 매우 정형화되어 있고 한번 제대로 경험해 보면 크게 어렵지는 않다. 저자의 경험을 돌이켜보면 공공 IT 컨설팅을 수행해 본 경험이 있는 컨설턴트들은 민간 기업의 컨설팅도 쉽게 적응해나갔다. 그러나 그 반대의 경우, 상대적으로 복잡하고 상세한 절차, 다양한 산출물의 작성 및 테일러링 경험이 부족하여 잘 대응하지 못하였다. 그렇기에 산출물의 재사용 및 자산화는 컨설팅 기업의 큰 경쟁력이 되고 있다. [1] Project Management Institute. http://www.pmi.org [2] PMI에서는 4년마다 PMBOK를 업데이트하면서 내용을 변경하고 있다. 관리 범주의 구분과 내용도 계속 업데이트되고 있는데 Table IV-1은 PMBOK 3판을 기준으로 하였다. [3] Henry Gantt(1861 ~ 1919)에 의해 창안된 공정계획 양식. 작업계획과 실제 작업량을 막대 모양의 작업시간으로 표기하고 관리함 [4] PERT: Program Evaluation and Review Technique. 1958년 미국 해군이 폴라리스 미사일 개발 프로젝트의 일정 계획 및 통제를 위해 개발함. CPM: Critical Path Method. 1957년 미국 RemintonRand 사에서 개발. PERT는 각 활동 시간을 3가지로 추정하여 평균 시간을 계산하는 일종의 확률모형인데 비해 CPM은 각 활동 시간을 확정적으로 추정함. 즉, PERT는 프로젝트의 시간적 측면만 고려하는데 비해, CPM은 시간과 비용을 모두 고려함 [5] 주로 발주자의 요구에 맞출 능력을 갖추지 못한 영세 사업장을 비하하는 의미로 사용 [6] 이 부분은 논란의 여지가 있을 수 있는데 산출물은 그렇지만 사실 CEO를 포함하여 경영진들은 또 다른 비즈니스 네트워크를 만드는 성과도 얻게 되므로 실무자가 접하는 보고서와 경영진이 얻게 되는 가치(Value)는 좀 다를 수 있다. 물론, 지식과 경험이 풍부한 컨설턴트들이 들어와서 일을 한다는 전제에서 말이다. [7] 여기서 단계는 컨설팅 방법론의 단계를 의미한다. 컨설팅 방법론은 컨설팅 기업마다 다르며, 고객과 합의하여 테일러링 한 후 결정하는 것이 일반적이다. [8] 비용 관리의 경우, 요즘은 정보시스템이 잘 구축되어 있어 비용도 사후정산보다 법인카드로 처리하는 경우도 많고, 사업 대가 청구도 전자세금계산서를 활용하는 방식이 일반화되어 있다. 120 PART VI. 컨설팅 방법론 누군가 컨설팅 업무와 기업의 다른 업무 사이의 가장 큰 차이점이 무엇인가를 물어본다면 저자는 방법론의 존재 유무라고 말하고 싶다. 방법론은 쉽게 말하면 붕어빵 틀과 같은 것이다. 붕어빵을 만들기 위해 모양대로 틀을 구상하고 난 후, 붕어빵이 먹고 싶을 때에 그 틀에다 반죽과 단팥 같은 맛있는 재료를 넣으면 붕어빵이 만들어지게 된다. 이 붕어빵 틀을 비즈니스의 세계로 가져오면 그게 바로 방법론이라 할 수 있다. 물론, 방법론은 테일러링(Tailoring)이라고 하는 고유의 업무가 존재하지만 개념은 상통한다고 할 수 있다. 일반적으로 방법론이라고 불리게 되면 다음과 같은 몇 가지 요소들을 반드시 충족해야 한다. 단계적 절차 도구와 기법 템플릿과 사례 첫 번째, 단계와 절차는 프로세스(process)라고도 할 수 있는데 어떤 단계(Phase or Stage)와 절차(Step)에 따라 진행하며 각 단계나 절차에서 해야 할 일(Tasks or Activities)을 정의하고 있다. 두 번째, 방법론은 각 단계와 절차가 제시하는 일을 하기 위해 우리가 Part II, Part III에서 살펴본 논리적 사고 체계에 기반한 도구와 기법(Tools and Techniques)을 제시하고 있다. 마지막으로 세 번째로 방법론은 그런 도구와 절차를 적용한 문서 템플릿과 사례(Templates and References)를 포함하고 있다. 이와 같은 이유로 소위 검증되었다고 하는 우수한 방법론은 많은 적용 사례를 가지고 있으며, 그 단계와 절차가 복잡하지 않고 누구나 쉽게 배우고 익힐 수 있는 것이 특징이다. 또한, 방법론은 업무 수행을 위한 일종의 가이드(Guide)로서 상세한 해설(Description)을 통해 방법론대로만 하면 누구든지 100점 만점에 80점 이상의 성과는 낼 수 있게 해준다. 여기서 20점은 모든 프로젝트가 고유(Uniqueness) 하기 때문에 그 상황에 맞게 조정해야 할 경우가 발생하며, 방법론 고유의 사상과 특색을<NAME> 채 해당 프로젝트에 맞게 각 단계나 절차, 일을 줄이거나 통합하는 일 즉, 테일러링(Tailoring) 해야 한다. 붕어빵의 비유로 돌아가 보면 반죽이 비율이 달라진다든지 단팥 대신 다른 소를 넣는다든지 하는 것이 될 것이다. 그래봐야 붕어빵이듯 그런 약간의 변화와 조정을 가미한 컨설팅 산출물이 만들어지게 되는 것이다. 2000년 대에 접어들어 비즈니스 컨설팅에서 가장 중요하게 생각하는 것은 기업의 지속성장(Sustainable Growth)이다. 거의 모든 화두가 이 '지속성장'이라는 키워드에서 출발하게 되는데 기업이 성장하기 위해서는 Figure IV-1과 같은 3가지 축이 중요하다. 이 3가지 축은 어떤 것이 먼저라고 할 것도 없이 서로 맞물려 돌아가며 선순환(Virtuous cycle)을 만들거나 악순환(Vicious cycle)을 만들게 된다. Figure IV-1. 기업 성장의 3가지 축 따라서 기업의 전략을 수립하기 전에 3가지 축 중에서 어떤 부분부터 시작할 것인지에 대해 한번 고민해 볼 필요가 있다. 예를 들면 Figure IV-2와 같은 것이다. Figure IV-2. 전략 수립의 관점 경영체질도 형편없고 경영전략도 없으며 경영 기능도 좋지 못할 경우는 가장 먼저 의식을 개선하고 기업의 체질을 개선하는 일부터 시작하는 것이 좋다. HR이나 조직문화 컨설팅이 먼저 시작되어야 하는 경우이다. 어느 정도 경영 기능은 돌아가는데 경영체질이 문제가 많아서 경영전략의 수립도 실행도 제대로 되지 않는 경우는 경영 기능을 개혁하고 기업 내 효율 향상에 집중하는 것이 좋다. 경영전략도 있고 경영 기능도 잘 돌아가고, 경영체질도 나쁘지 않은데 기업의 성장이 답보상태라면 비즈니스 모델 혁신 또는 비즈니스 모델 재창조(Business Reinvention)이 필요한 상황이다. 이런 기본 진단을 두고 Part IV에서는 현재 가장 널리 알려진 몇 가지 컨설팅 방법론들을 다루고자 한다. 컨설팅도 수주 사업이기 제안도 쓰고 입찰도 한다. 그런 컨설팅 사업 개발은 Part V에서 자세히 다루고 Part IV에서는 수주 이후, 컨설팅을 제대로 수행하기 위해 필요한 방법론을 다룰 것이다. 프로젝트 방법론은 이 모든 방법론의 기본이다. 그 외 경영전략 수립, 프로세스 혁신, 신사업 개발, 사업타당성 분석, 정보화 전략 수립 방법론에 대해 살펴볼 것이다. 이 저서를 통해 모든 것을 상세하게 설명할 수도 없고 대부분의 방법론은 컨설팅 기업의 큰 자산[1]이므로 이를 외부에 공개하는 것도 매우 제한적일 수밖에 없다. 그러나 아마 다른 곳에서 쉽게 접해보지 못했을 이야기들이 많을 것임을 확신한다. 이제부터 컨설팅 방법론의 세계로 들어가 보자. [1] 대부분의 컨설팅 방법론들은 민간 기업 고유의 지식과 경험이 종합된 것으로 무단으로 사용할 경우, 라이선스 문제가 발생한다. 해당 기업의 허락 없이 지면을 통해 상세히<NAME>는 것은 문제가 되므로 실제 그것을 경험해 보고자 한다면 해당 기업에 컨설팅 의뢰를 해보는 것도 좋은 방법이다. 13. 경영전략 수립 방법론(1/3) 꿈을 이루는 방식에는 크게 2가지 관점의 접근 방법이 있다. 일본의 전국시대를 대표했던 두 인물 오다 노부나가(織田信長. 1534 ~ 1582)와 도요토미 히데요시(豐臣秀吉. 1536 ~ 1598)는 그 2가지 접근법을 보여주었는데, 커다란 목표를 먼저 세우고 그것을 이루기 위해 최선을 다하는 것이 오다 노부나가의 꿈에 대한 접근 방식이었고, 현재의 환경에 맞는 실현 가능한 목표를 정한 뒤 한걸음 한걸음 꾸준히 전진하는 방식이 도요토미 히데요시의 접근 방식이었다. 둘 다 혼란스러운 일본의 전국시대의 일본을 통일했던[1] 사람들이지만 그 목표를 이룩한 방법은 극명한 대조를 이룬다. 경영 전략의 관점에서 이 꿈은 비전(Vision)과도 통한다. 브랜드 전략에 지대한 공헌을 한 데이비드 에이커(David A. Aaker. 1938 ~ 현재)는 기업이 전략을 운영해 나가는 데는 다음과 같은 2가지 관점(사상)이 존재한다고 하였다. 비전 주의 기회주의 첫 번째 '비전 주의'는 기업이 장기적으로 성취하고 싶은 모습 즉, 비전(Vision)을 설정하고 그것을 실현하기 위해서 기업의 모든 자원과 역량을 집중시키는 것을 말한다. 비전 주의가 지향하는 것은 큰 변화이므로 직면한 환경에서 발생하는 작은 저항들에 대해서는 크게 과민반응하지는 않는다. 자신의 길을 굳건한 신념으로 나아가자는 것이다. 두 번째 ‘기회주의’는 현실에 충실하자는 것이다. 오늘이 없이는 내일도 없으며 현재 시장과 고객의 니즈에 대응하지 못하면 불확실한 미래는 더욱 생존하기 어렵다는 전제가 깔려 있다. 이런 이상들에 반해 기회주의를 추종하는 기업들은 중장기적 방향을 상실하고 표류하기 쉽다는 단점이 있으며 비전 주의를 추종하는 기업들은 전략적 완고함에 빠져 변화에 민감하게 대응하지 못한다는 단점이 있다. 기술 변화를 예측하기 어렵고 어떤 시대보다도 불확실성이 많은 요즘은 극단적인 비전 주의나 기회주의를 구사하는 기업들은 없으나 어느 쪽에 다소 더 비중을 둘 것인지는 기업이 처한 환경의 변화 특히, 그 속도와 범위와 관련지어 깊이 고민해야 한다. 전략 수립의 관점에 비전 주의와 기회주의가 있는 것처럼 전략 수립의 접근 방법도 다음과 같이 크게 2가지로 나눌 수 있다.[2] 논리적 접근 의지적 접근 논리적 접근은 Part III에서 살펴본 컨설팅 도구와 기법을 충실히 사용하여 그 시사점을 전략 수립에 활용하게 되는데, 대표적인 것이 자사의 강점과 약점 분석, 핵심 역량 분석 등을 이용하여 더 잘할 수 있는 것과 하지 말아야 할 것들을 전략의 선택지로 도출하게 된다. 의지적 접근은 현재 보유한 기업의 역량보다 기업이 도달하고자 하는 목적지 또는 꿈을 기반으로 한다. 즉, 비전을 수립하고 이를 달성하기 위한 방법론을 전개해 나아가는 방법이다. 오늘날의 경영전략 수립 방법은 논리적 접근과 의지적 접근이 혼합되어 있다고 생각할 수 있다. 논리적 접근은 핵심 역량이나 경쟁우위가 명확한 기업에 유리하다. 그런 것이 없는 기업이 전략을 세울 때는 바람직하지 않다. 그럴 경우, 의지적 접근을 통해 나아가야 할 방향을 중장기적으로 제시하는 방법을 취한다. 그런데 전 세계의 기업들을 놓고 보면 누구나 인정할 수 있는 핵심 역량을 보유한 기업들은 정말 손에 꼽을 것이다. 그리고 그들 기업도 처음부터 그렇지 않았고 창업주나 최고경영자의 의지가 문을 열었다 볼 수 있다. 따라서 오늘날 경영 전략 수립의 접근은 의지적 접근에서 시작하는 것이 많으며 다만, 그 비전의 실현 가능성 측면에서 현실에서 실행 가능한 과제들을 어떻게 전략적 의지(Strategic Intents)와 이어나갈 것인가가 관건이 된다. 제13장에서는 이와 관련하여 기업의 전략 수립 방법론에 대해 자세히 알아보자. 13.1 전략 수립의 접근 방법 경영전략을 수립하거나 재정립하기 위해 업무(work)의 관점에서 보면<NAME>적 측면과 동태적 측면으로 구분해 볼 수 있다. 첫 번째,<NAME>적(Static) 측면에서 살펴보는 것은 콘텐츠가 강조되는 관점으로 기업의 비전부터 전사 경영전략, 사업전략, 기능 전략이 일관되게 하나의 흐름을 이루도록 구성하는 것이 중요하다. Figure IV-7. 경영전략의 구성 -<NAME>적 측면 이를 도식화해보면 Figure IV-7과 같은 집의 형태로 많이 그려내는데, 전사 경영혁신을 위해 비전과 포트폴리오를 재정립하고 기업 전략을 수립하며 도출된 전략 과제를 실행하기 위한 실행전략을 수립한 후, 이를 변화 관리하여 경영 혁신의 성과를 달성하는 구조를 보여주고 있다. 집을 구성하고 있는 각 영역별로 점검해야 할 질문들이 있으며 그 질문에 대한 답을 찾아가면서 전략 수립이 진행된다. 각 단계별 질문과 내용들을 정리해 보면 다음과 같다. (1) 비전 재정립: ‘기업의 새로운 도약을 위한 비전(Vision)은 무엇인가?’ - 기업의 미션(Mission)이나 비전(Vision), 기업 이념을 재정립해야 한다. (2) 포트폴리오 재정립: ‘사업 포트폴리오는 합리적인가?’ - 현재 포트폴리오의 위상 파악 - 가치 창출 카테고리별 경영혁신 방안 수립 - 포트폴리오 비전 초안 마련 - 포트폴리오 비전 및 실행계획 확정 (3) 기업 전략 수립: 경영 목표 및 이익 달성을 위한 전략은 무엇인가? - 중장기 발전 계획 및 Migration Path - 성공적 비전 달성을 위한 전략과제 도출 - 신규 사업기회 탐색 및 추진안 수립 - 전략 과제의 우선순위화 및 Quick Win 과제 도출 (4) 전략과제의 성공적 실행전략: 기업 목표 달성을 위한 수행 방안은 무엇인가? - 전략 달성을 위한 최적의 조직구조 설계 - 거래선별 수익성 관리체계 정립 - 전략적 투자 개선 및 조정 - 혁신적 비용 절감 - 사업 간 시너지(synergy) 개선 - 비용 절감의 기회 요소 도출 - 사업 기회별 전략적 목표 제시 및 관리체계 수립 - Value Chain 상의 프로세스 개선 방안 제시 (5) 변화관리: 전략과제의 성공적 달성을 위한 변화관리 방안은 무엇인가? - 재무 및 성과 계획 작성 지원 - 전략과제 달성을 위한 지원사항 도출 - Communication 계획 수립 두 번째, 동태적(Dynamic) 측면에서 살펴보는 것으로 프로세스(process)가 강조되는 관점이라 할 수 있다. 이는 기업이 외부 환경과 내부 역량 분석을 통해 기업의 강점과 향후의 변화를 파악하고 이를 바탕으로 최적의 의사결정을 수행하는 것이다. 이를 그림으로 표현해 보면 Figure IV-8과 같은 흐름으로 표현할 수 있다. Figure IV-8. 경영전략의 구성 - 동태적 측면 외부 환경 분석 및 내부 역량 분석을 위해 산업 및 사업 환경 분석을 수행하고 강점과 약점을 구체적으로 파악한다. 이를 미래 트렌드와 맞추어 사업 모델이나 조직의 변화 방향으로 표현한다. 실행 가능한 전략적 옵션을 도출하고 이를 정량화하여 실행 타당성을 분석하고 결과를 평가한다. 일반적으로 전략 컨설팅을 수행하게 되면 동태적 접근 방법을 통해 경영 전략의 다양한 과제(Initiatives)를 도출하는 경우가 많으며 전략경영 관점의 성과 평가를 컨설팅할 경우,<NAME>적 관점에서 KPI를 체계적으로 수립하게 된다. 다음 장에서는 이것들에 대해 좀 더 자세히 알아보자. Break #18. 경영전략 수립과 전략적 의사결정 전략 수립 프레임워크에 대한 정보는 차고 넘쳐서 관련된 책 한 권 본 사람들은 거의 대부분 자신만의 전략 수립 프레임워크를 개발할 수 있다. 그 정도로 특별한 것도 아니며 어려운 것도 아니다. 문제는 실제로 그런 경험을 얼마나 해 보았으냐 하는 것인데 글로벌 Top 3 컨설팅 펌의 컨설턴트들도 그 노련함에 있어서는 경험의 유무, 정도에 따라 큰 차이를 보인다. 방법론 테일러링을 제대로 못해서 뒤죽박죽이 되는 경우도 많고 고객으로부터 챌린지를 받고 떠나는 경우도 허다하다. 저자의 생각에 그것은 컨설턴트 개인의 역량이 부족하다기보다는 '경험의 부족(Lack of Experience)'에서 오는 미흡한 변화관리 능력 때문이라 생각된다. 그래서 신입 컨설턴트들은 선임/시니어 컨설턴트들과 반드시 함께 프로젝트에 투입되는 것이 회사에도 개인에게도 바람직하다. 각설하고 이 장에서 경영전략 수립 프레임워크를<NAME>적, 동태적 관점에서 예를 들었지만 또 Figure IV-9와 같이 생각하는 사람들도 많다. 이 프레임워크(Framework)가 맞다 틀리다가 아니라 이런 생각이고 저런 생각이므로 가져다가 상황에 맞게 적용하면 된다. 즉, 테일러링 하면 되는 것이고 해당 프레임워크가 좋다고 평가할 수 있는 것은 여러 사람이 알아보기 쉽고 이해하기 쉽고 또<NAME>기 용이하며 전략 실행의 결과가 잘 나올 수 있게 설계된 그런 프레임워크가 좋다고 평가받을 수 있다. Figure IV-9. 비전 및 전략 수립 프로세스 그래서 과거에는 컨설팅 펌의 방법론들을 철저히 비공개, 비밀 시 하였으나 웹으로 거의 모든 정보가 실시간으로 공유되는 요즘은 그런 비밀이 오래가지도 못하기 때문에 예전에 비해 많이 공개하고 있다. 컨설팅 펌 입장에서는 이는 사실상의 표준(De Facto Standard)이 누리는 효과를 한번 누려보겠다는 포석도 있는 셈이다. Figure IV-9에 대해 좀 더 이야기해 보면 결국 경영전략을 수립하는 모든 단계는 전략적 의사결정(decision making)이며 각 단계별 전략이 유의미하게 작동된다는 말은 의사결정 프로세스가 잘 작동하고 있다고 생각할 수 있는 것이다. 또, Figure IV-10과 같은 프레임워크도 있다. Figure IV-10. 경영전략 수립 프레임워크 Figure IV-10은 전사 차원의 Top-Down 중장기 경영전략과 사업부(SBU) 최적화를 추구하는 Bottom-Up 정보를 연계하여 중장기 경영전략과 사업부 전략이 상호 일관성(Alignment)을 유지하고 둘 간의 상호보완성을 고려한 프레임워크라고 할 수 있다. Figure IV-10과 같은 경영전략 수립 프레임워크가 소개되면 반드시 Figure IV-11과 같은(또는 이와 유사한) 사업 전략(business strategy) 프레임워크가 동반된다. Figure IV-11. 사업전략 수립 프레임워크 Figure IV-11은 주요 제품 및 서비스, 주요 고객, 경쟁자, 공급자, 제공 경로 등을 고려한 사업 단위 전략 수립 프레임워크를 도식화한 것이다. 결국 전략 옵션 또는 전략 대안을 개발하여 실행하고 평가하는 것으로 되어 있다. 사업전략 수립에 사용되는 각종 분석 기법은 Part III에서 소개한 것들을 활용하면 된다. [1] 사실 오다 노부나가가 80% 이상 전국시대의 일본을 통일하고 죽게 되자, 오다 노부나가의 하인부터 시작해서 장군까지 오른 도요토미 히데요시가 완전한 통일을 이루게 된다. [2] 실제로 논리적 접근과 의지적 접근은 다르지만 많은 컨설팅 펌의 전략 수립 방법론은 이것들이 서로 섞여 있다는 느낌이 많이 든다. 그렇기에 잘못 적용하면 죽도 밥도 안되는 이상한 결론이 나오는 경우도 많다. 13. 경영전략 수립 방법론(2/3) 13.2 경영전략 수립 프레임워크 13.1장에서 살펴본 것처럼 기업의 비전 수립 관점이나 기업의 경영 전략을 수립하는 방법은 매우 다양하다. 2000년대 들어 경영전략은 두 가지 큰 화두에서 여러 가지 파생적인 논의, 이론, 방법론, 사례들이 정리되고 있는데 그 하나는 자원 준 거론[1]에 기반한 ‘Resource-based Strategy’이고 다른 하나는 ‘Opportunity-based Strategy’이다. Table IV-4는 두 가지 관점의 전략을 비교한 것인데 각각의 전략 수립 방법을 추종하는 기업들도 역량 주의를 추종하는 기업들과 기회주의를 추종하는 기업들로 구분해 볼 수 있다. Table IV-4. 경영전략 트렌드의 비교 첫 번째, 역량 주의를 추종하는 기업들은 기업의 강점과 약점을 잘 파악하여 변화하는 환경이나 시장에 어떻게 적응할 것인지, 그렇게 하기 위해 어떤 역량이나 자원을 극대화할 것인지 고민한다. Figure IV-12는 역량 주의 관점에서 경영전략을 수립하는 방법을 설명한 것이다. Figure IV-12. 경영전략 수립의 절차 - 역량 주의 관점 크게 'Foresight Step', 'Insight Step', 'Strategy Formulation Step'의 3단계로 나누어볼 수 있다. Foresight Step은 외부환경 분석을 통해 미래에 대한 선견지명(先見之明. Foresight)를 이끌어내는 것을 목표로 한다고 볼 수 있다. 메가트렌드(Megatrend) 분석이나 산업 분석, 시장 분석, 경쟁 분석 등을 주요 기법으로 사용할 수 있다. Insight Step은 기업의 강점과 약점, 경쟁 현황, Value Chain 등을 분석하여 통찰력(Insight)을 가지고 경쟁 우위를 명확화하는 단계이며, Strategy Formulation Step은 두 가지 분석의 시사점을 종합하여 비전(Vision)을 정립하고 비전 달성을 위한 전략과 전략 과제를 개발하는 단계이다. 특히, 중장기 경영 목표를 정량화하는 과정에서 BHAG[2]을 명시하기도 한다. 두 번째, 기회주의를 추종하는 기업들은 시장의 기회, 좀 더 구체화하면 고객의 니즈를 간파해야 한다. 고객의 니즈를 충족시키기 위해 내가 가지고 있지 않은 것(자원)까지 연결하고 융합하여 고객에게 제공하는 것으로 대부분의 설루션 기업들이 이런 전략을 취한다[3]. 기회주의에 기반한 설루션 비즈니스 모델링을 생각해 본다면 Figure IV-13과 같이 표현할 수 있다. Figure IV-13. 경영전략 수립의 절차 - 설루션 비즈니스 모델 전략 수립 설루션 비즈니스 모델링은 크게 6단계로 나뉘는데 그 내용은 다음과 같다. (1) 이슈 및 문제 인식 - 진단이나 컨설팅을 통해 고객성과 창출의 이슈나 문제를 발견함 (2) 설루션 개념 정립 - 고객의 이슈나 문제의 해결 방안을 탐색함 (3) 제품/서비스 구성 - 개념화된 설루션을 구성하기 위한 제품(상품) 및 서비스 탐색. 필요시 연구개발(R&D)을 하기도 하나 C&D나 A&D[4]가 보다 비용 효율적일 수 있다. (4) 프로세스 및 인프라 확보 -<NAME> 가능한 내/외부 자원을 결합하여 프로세스와 인프라 확립 (5) 오퍼링(제품/서비스) 공급 - 개별 고객 맞춤형 제품 및 서비스 공급 (6) 고객의 성과 확인 - 고객에게 설루션 오퍼링을 제공하고 고객의 성과를 확인 이처럼 설루션 비즈니스를 추구하는 기업의 경우, 시장의 기회나 고객의 니즈를 발굴하기 위해 컨설팅 기능이 중요하게 부각되며 이를 핵심 역량으로 추구하려고 하는 경향이 많다. 그래서 설루션 사업 고민한다. (1/2) 설루션이 뭐라고? 아 ... 난 여태까지 잘못 알고 있었네. | B2B 영업은 영업 방식(Sales Motion)에 따라 Volume Sales와 Value Sales로 구분해 볼 수 있는데 Volume Sales는 대량(Bulk)의 제품을 유통채널을 통해 기업고객에게 판매하는 것으로, B2C 세일즈처럼 채널 및 파트너 관리가 중요하다. 그런데 Value Sales는 B2C 세일즈 또는 Volume Sales와는 상당히 brunch.co.kr/@flyingcity/8 13.3 경영전략 운영 프레임워크- BSC 경영전략 운영 프레임워크 이란 결국 전략과제들이 어떻게 실행되는지 모니터링하고 그 성과를 체계적으로 달성할 수 있도록 관리하는 것이다. 이와 관련하여 가장 널리 알려진 컨설팅 기법은 균형성과 지표(Balanced Scorecard. BSC)를 활용하는 것이다. BSC는 전략 목표에 근거하여 재무, 고객, 프로세스, 성장과 학습 관점의 핵심 성공요소를 측정 가능한 KPI로 구체화하여 조직 전체의 전략 목표에 대한 커뮤니케이션 수단을 제공하고 전사 역량을 전략 목표에 집중시킴으로써 사업 전략을 실행으로 전환시켜주는 경영전략 운영 프레임워크이다. Figure IV-14는 BSC 체계 하에서 비전부터 KPI까지 목표에 합치되고 있음을 보여준다. Figure IV-14. BSC의 개념 Figure IV-15는 BSC의 각 수준별 고려 사항들과 사례를 나타내고 있다. '재무', '고객', '내부 프로세스', '학습과 성장'이라는 BSC 4가지 관점에서 핵심 성공요소를 도출하고 핵심성과지표와 실제 목표를 연계하여 종합적인 경영 체계를 수립한다. Figure IV-15의 핵심 성공요소 아래 그림은 전략맵(Strategy Map)이라고 불리는 것인데 BSC의 4가지 관점에서 중요하게 생각하는 전략 영역을 도식화하여 서로 연계성을 보여주는 것이다. 당연히 KISS 원칙[5]이 중요하다. 맵이 너무 많고 복잡하며 그 연계가 실타래 엮인 것 같다면 생각을 좀 더 해보아야 한다. Figure IV-15. BSC의 주요 내용 또한, BSC 컨설팅은 Figure IV-16과 같이 크게 성과측정 모델과 설루션 구축의 두 단계를 걸쳐 진행된다. 1단계 컨설팅은 기업의 성과 창출 요소를 이해하고 그 성과를 정량적으로 측정하기 위해 핵심성과지표(KPI: Key Performance Indicators)를 도출하는 것을 컨설팅의 주요 내용으로 진행하며, 2단계는 각 현장에서 KPI의 성과 입력이 쉽도록 또 성과를 취합하고 모니터링하는 일이 쉽도록 하는 정보시스템을 설계하고 구축하는 것이 핵심이 된다. 2단계에서 BSC 컨설턴트는 KPI 설계를 시스템 수준까지 상세하게 하거나 프로젝트 PMO로 활동하게 된다. Figure IV-16. BSC 수립 방법론 사례 저자가 BSC를 처음 접한 것은 2004년이었는데 BSC는 그즈음 전략경영의 성과관리 도구로 화두가 되고 있었다. 컨설팅 기업들은 크게 3가지 접근 방법을 취했는데 글로벌 Top 3 전략 컨설팅 기업과 글로벌 Big 4 회계 펌의 컨설팅 파트, 그리고 SI 기업이나 IT 설루션 기업들의 컨설팅 파트가 사업을<NAME>였다. 결과적으로 보면 SI 기업이나 IT 설루션 기업의 컨설팅 파트가 좋은 성과를 얻었다. 글로벌 Top 3전략 컨설팅 기업들은 BSC의 전략적 의미를 제시하고 기업 혁신의 방향을<NAME>는 부분에 집중하였고 이로 인해 분명히 선도적인 입지를 갖게 되었으나 그 이상도 그 이하도 아니었다. 글로벌 Big 4 회계 펌의 컨설팅 파트들은 전략 펌보다 1, 2 레벨 더 낮게 실질적으로 컨설팅을 진행할 수 있었다. 기존의 회계 시스템과 새로운 방식의 성과를 연동시킨다는 측면에서 가장 잘 진행할 수도 있었을 것이다. 그러나 단순히 컨설팅만을 생각하는 것이 아니라 BSC 시스템 차원으로 시장이 커지면서 실질적인 시스템의 구축까지 책임져야 하는 IT 설루션 기업들이 가장 유리한 고지를 차지하게 되었다. IT 설루션 기업들은 데이터웨어하우스(DW) 시스템을 적극 이용하려는 전략을 사용했는데 크게 2가지 관점이 강조되었다. 데이터 입력 및 수집 데이터 모니터링 (Dashboard) 데이터 모니터링부터 이야기하자면 BI(Business Intelligence)라고 부르는 영역을 통해 원하는 데이터를 보다 쉽게 볼 수 있게 다양한 그래프와 표, 실시간 표출 등을 강조하였다. 그러나 데이터 입력이나 수집은 문제였다. 결론적으로 BSC는 지금도 그렇지만 2가지 큰 문제에 봉착해 있다. 첫 번째는 비전부터 전략, 실행과제까지 연계한 기업의 성과를 재무 측면에 치우치지 않고 균형 있게 보여줄 수 있느냐에 대한 부분에서 정성적인 부분의 성과를 여전히 인정받지 못하고 있다. 이는 정량화의 이슈와 맞물린다. 두 번째는 다양한 성과 데이터의 적시 입력 및 수집의 문제이다. 이 부분은 최근 제4차 산업 혁명의 논의가 활발해지면서 로봇이나 자동화 영역이 확장되면 될수록 빨리 해결될 것으로 보인다. BSC가 알려진 지 몇 해 있으면 30년이 된다. 아마 새롭게 조명 받을 수도 있을 것 같다. [1] Resource-based View: RBV [2] Big Hairy Audacious Goal 예. 2020년 영업이익 5조 원 [3] 기회주의를 취한다고 해서 기업의 강점과 약점을 고려하지 않는 것은 아니다. 다만, 전략의 큰 그림이 자원의 보유 여부에 제한을 받지 않는다고 할 수 있다. [4] Connect & Development ; Acquisition & Development [5] Keep It Simple, Stupid 간단한 것, 간략한 것이 좋다. 13. 경영전략 수립 방법론(3/3) 가장 널리 사용되는 '포트폴리오(Portfolio)'의 의미는 '서류 가방' 또는 '자료 수집철'이라는 의미인데 광고산업에서는 다양한 작품집을 뜻하며 건축, 투자를 포함해서 포트폴리오는 의미 있는 무언가를 종합하여 나타냄을 뜻한다. 비즈니스 컨설팅에서 포트폴리오는 금융 투자의 포트폴리오 의미와 가장 가까울 것 같다. 사업을 의미 있는 기준으로 정의하고 구분하여 지속적으로 변화관리하는 것이 포트폴리오 관리(Portfolio Management)이다. 사업 자체가 대상이 될 수도 있고, 제품이나 브랜드도 그 대상이 될 수도 있다. 경영전략 수립 방법론의 마지막 순서에서는 사업 포트폴리오 관리에 대해 생각해 보자. 13.4 사업 포트폴리오 분석 인트로에서 간단히 언급했지만 포트폴리오(Portfolio)라는 것은 전략적 사업 목표를 달성하는데 유리하도록 그룹으로 묶어 작업의 효율적 관리를 촉진할 수 있는 프로젝트(Projects), 프로그램(Programs), 기타 작업의 집합체라 생각할 수 있다. 포트폴리오 내의 사업들은 서로 종속 관계에 있거나 직접 연관될 필요는 없으며, 포트폴리오 관리(Portfolio Management)라는 것은 특정한 전략 사업 목표를 달성하기 위해 전략적 중요도나 재무적 중요도에 따라 사업별 우선순위를 식별하고 결정하여 이를 관리 및 통제하는 기법을 의미한다. 경영 진단에도 활용할 수 있는데 사업 단위별 전략적 적합성과 재무적 적합성을 분석하고 종합하여 평가한다. 이를 그림으로 표현해 보면 Figure IV-17과 같다. Figure IV-17. 사업 포트폴리오 분석의 개념 사업 포트폴리오는 전략적 적합도와 재무적 적합도의 건전성을 기준으로 4분 면으로 나누면 투자를 증대하고 사업 성장을 가속화 시켜야 할 영역과 사업을 축소해야 할 영역, 수익성을 개선해야 할 영역, 잠재 기회를 발굴해야 할 영역 등으로 구분될 수 있다. 전략적 적합도도 경쟁 입지와 시장 매력도를 기준으로 구분하여 전략 적합성을 구분해 볼 수 있으며, 재무적 적합도도 매출 규모나 수익성을 기준으로 자원(resources)을 지속해서 투입해야 할 곳과 철수해야 할 곳으로 구분할 수 있다.[1] 전략 적합도 매트릭스를 조금 상세화 시켜보면 Figure IV-18과 같다. Figure IV-18. 전략 적합성 매트릭스 시장의 성장성과 경쟁 강도[2]를 통해 사업의 잠재성(Business Potential)을 파악하고, 시장점유율 분석 등을 통해 경쟁 입지를 파악하여 실질적으로 단위 사업이 어떻게 포지셔닝 되는지 알아보는 것이다. 조금 더 구체적인 항목들을 살펴보면 Figure IV-19와 같다. Figure IV-19. 전략 적합성 평가 Logic Tree 사례 시장 매력도를 평가하기 위해 규모, 산업 수익성, 구조적 매력도 등을 점검해 보는 것이 필요하고 입지와 역량을 평가하기 위해 현재 사업적 입지, 경쟁사의 역량 등을 평가해야 한다. 재무적 적합도는 사업의 실현(Realization) 및 재무적 성과(Performance) 측면을 평가하는 관점으로 사업 단위별 시장 매력도는 투자 매출 규모와 수익성에 따라 사업 단위별 재무적 적합성을 분석한다. 재무 적합도 매트릭스를 표현해 보면 Figure IV-20과 같다. 재무 적합성 매트릭스를 구성할 때에는 재무적 시나리오를 계량화하는 분석이 병행되어야 한다. 예를 들면 CFROI[3] 등 수익성 분석, 자금 소요 계획, 현금 유동성 확보/계획/실현 가능성 등을 옵션으로 두고 변경 여부에 따라 시뮬레이션한 후, 매트릭스에 반영하는 것이 좋다. 저자가 CFROI의 개념을 처음 접한 것이 2004년이었다. CFROI는 현금흐름 투자수익률, 'Cash Flow Return On Investment'의 약자로 당시 경영 성과를 측정하기 위해 널리 사용하던 EVA(경제적 부가가치. Economic Value Added)보다 진일보한 좋은 지표라고 알려졌었다. 그 개념은 기업들이 투자 대비 얼마나 현금 창출을 잘하고 있는가를 살펴보는 것인데 CFROI가 높으면 기업이 부(富)를 창출하여 주주들에게 가치를 제공하고 있다는 의미이다. 해외에서는 주식투자 특히, 가치 투자를 위한 밸류에이션(Valuation)에서 많이 활용한다. 그러나 국내에서는 여전히 영업이익/영업이익률이 중요하게 생각되고 있으며 주주배당을 위해서는 영업이익에서 모든 세금 부분을 제한 당기순이익이 가장 중요하게 평가되고 있다. Figure IV-20. 재무 적합성 매트릭스 지금까지 살펴본 전략 적합도 매트릭스와 재무 적합도 매트릭스를 참고하여 단위 사업별로 평가(scoring)를 해서 그것을 하나의 매트릭스에 표현하면 사업 포트폴리오가 되는 것이다. Figure IV-21은 그 과정을 도식화해 본 것이다. 5점 척도를 기준으로 평가해도 좋고, 결과가 나온 것을 차례로 반영하고 종합하여 합산하면 된다. Figure IV-21. 사업 포트폴리오 평가의 개념 평가된 사업 포트폴리오를 관리하는 것은 Figure IV-22와 같은 순서로 진행할 수 있다. Figure IV-22. 사업 포트폴리오 관리의 절차 전략 적합성을 판단하기 위해 다양한 데이터를 수집하여 분석하고 평가한 후, 정해진 기준에 따라 점수를 매겨서 포트폴리오를 구성한다. 전략적 의사결정에 따라 사업 단위 또는 세그먼트를 조정하고 [4], 그 결과를 반영하여 자원을 배분한다.[5] 또한, TableIV-5는 사업 포트폴리오 관리의 장단점을 정리한 것인데<NAME>적 관점의 경영전략 수립에 기초하고 있어 Part III에서 소개한 BCG 매트릭스 분석의 특징을 많이 가지고 있다. 즉, 사업의 동적인 측면을 설명하기는 어렵다. 따라서 이런 유의 차트를 의미 있게 프레젠테이션 하기 위해서는 데이터와 연계하여 실시간 시뮬레이션할 수 있게 해야 한다. Table IV-5. 사업 포트폴리오 분석의 장단점 Break #19. Three Horizons of Growth Figure IV-23. Three Horizons of Growth Figure IV-22의 5번째 단계는 포트폴리오 관리인데 결국 포트폴리오 분석을 통해 그것을 재구성하였다면 자원 투입과 더불어 지속적으로 그것을 관리하는 것이 중요하다. 이와 관련하여 맥킨지 컨설턴트였던 Mehrdad Baghai는 1999년 그의 저서 'The Alchemy of Growth'에서 Figure IV-23과 같은 개념을 소개하였다. 사업 포트폴리오를 정비하면서 사업 단위의 구분을 3가지로 구분하고 그에 맞게 전략적 의사결정을 내려야 한다는 것인데 그 세 가지는 주력사업, 승부 사업, 미래사업으로 표현된다. 이것을 성장 파이프라인(Growth Pipeline)이라고 표현했는데 그 목적은 주력 사업이 쇠퇴할 경우, 새로운 성장엔진이 이를 적기에 대체할 수 있는 균형을 달성하는 것이다. 첫 번째, 주력 사업(Protecting the Core)은 고객들이 해당 기업을 생각할 때 가장 먼저 떠올리는 사업 즉, 그 기업의 핵심 사업을 의미하며 수익이나 현금흐름의 상당부문을<NAME>다. 기업의 단기 성과에 지대한 영향을 끼치며 자금이나 기술 측면에서 성장의 원동력을 제공하는 사업이다. 이 영역의 사업들은 경쟁력과 잠재력을 극대화하기 위해 노력해야 한다. 상품과 서비스를 다양화하고 새로운 마케팅 전략을 개발하고 필요하면 사업 철수 및 매각을 통한 구조조정도 필요하며 생산성 향상이나 비용 절감 같은 화두들이 동반되는 영역이다. 두 번째, 승부 사업(Changing the Game)은 개념이 자리를 잡아 급속도로 성장하는 사업으로 대규모 투자만 뒷받침되면 기업 전체를 변모시킬 수 있는 유망 사업 군이다. 기존 핵심사업과 관련이 깊을 수도 있다. 비교적 단기간 내 기업의 주력사업에 대한 보완적인 역할을 수행해야 하며, 궁극적으로 주력 사업을 대체해야 한다. 매출과 시장점유율을 동시에 높이는 것이 필요하며 지속적인 확장을 위해 연속된 투자가 동반되어야 한다. 세 번째, 미래 사업(Creating the New)은 장기적으로 추진할 사업의 씨앗(seed)으로 높은 잠재력을 가지고 있어 현재 활동이나 자금이 소규모 투자되고 있는 사업 또는 프로젝트가 해당될 수 있다. 장기적인 관점에서 시장의 다양한 요구에 부응하여 미래의 성장을 책임질 수 있는 사업 또는 옵션이 이에 해당된다. 자원을 많이 투자하지 않으면서 가능성이 높은 옵션을 많이 발굴하는 것이 지상과제가 된다. 지속성장(Sustainable Growth)의 관점에서 보면 당연히 이처럼 생각할 수 있다. 지금 대한민국의 많은 기업들이 이 문제로 신음하고 있다. 이 글을 읽는 여러분의 기업은 이와 같은 프레임워크를 적용했을 때 주력사업, 승부 사업, 미래사업이라 부를 만한 것들이 있는가? [1] 여기서 소개한 기준은 저자의 경험에 따른 것이고 사업 포트폴리오 분석의 기준은 기업의 상황에 따라 얼마든지 변경될 수 있다. [2] 이는 산업 수익성으로 표현될 수 있는데 산업 수익성이 높으면 경쟁 강도가 낮다고 생각할 수 있다. [3] Cash Flow Return On Investment [4] 사업 단위의 조정 및 배치와 관련해서는 고전적인 분석법인 BCG 매트릭스와 Ansoff 매트릭스가 많이 활용된다. 아래 글 참조 경쟁 및 산업 분석 (2/4) BCG/GE 매트릭스 분석, 경쟁 분석 | 경쟁 및 산업 분석의 첫 번째 순서로 메가트렌드 분석을 위한 PEST 분석과 시장의 크기를 산정하는 방법, 성장률을 계산하는 방법 등에 대해 알아보았다. 오늘은 경쟁 분석에 대해 알아보자. 1.3 경쟁 분석 경쟁 분석의 기본은 '경쟁사 프로파일링(Competitors Profiling)'과 '경쟁사 포지셔닝(Competitors Positioning)' brunch.co.kr/@flyingcity/54 [5] 'Three horizon of Growth'를 많이 따른다. 14. 프로세스 혁신 방법론(1/2) 경영전략 수립과 더불어 프로세스 혁신(Process Innovation) 부분은 가장 인기 좋은 컨설팅 영역이다. 우선, 프로세스 혁신에 대해 이야기하기 전에 프로세스란 무엇인지, 혁신이란 무엇인지 생각해 보는 것이 좋겠다. 첫 번째, 프로세스에 대해 이야기해 보자. 프로세스에 대한 사전적 정의를 비롯하여 다양한 의견들이 있지만 저자 개인적으로 눈에 가장 쏙 들어오는 것은 아무래도 Table IV-6처럼 6-시그마[1] 관점에서 표현하는 것이라 생각된다. 신사업 개발을 위한 프레임워크로도 쓰이는 SIPOC는 각각 공급자, 투입, 프로세스, 산출, 고객의 영어 단어 앞 글자를 따서 만든 개념으로 프로세스를 규명하기에 유용한 개념이다. Table IV-6. 6-시그마의 SIPOC 프로세스는 산업이나 업종에 따라 그 정의를 달리할 수 있고 그 구분도 매우 다양하게 정의할 수 있다. 그러나 기본적으로 지켜지는 정의는 시작과 끝이 명확하고 독립적이며 업무 프로세스의 의미 있는 산출물 단위로 구분한다. 경영전략 컨설팅에서 가치 사슬(Value Chain) 분석 또는 공급 사슬 분석을 수행하지만 실제 업무에서는 그보다는 업무-기능 모델 (Function-Process Model)을 더 많이 사용한다. Figure IV-24는 FP 모델을 예시적으로 표현한 것이다. Figure IV-24. 업무기능 모델 사례 FP 모델은 기능(Function), 프로세스(Mega Process or Process), 하위 프로세스(Sub Process), 기본 프로세스 또는 기본 활동(Elementary Process or Activity)로 구분된다. 기능(Function)은 기업의 목적 달성을 위해 관련된 업무를 유기적으로 묶은 것의 집합으로 실행력은 없으나 Value Chain의 기본 단위가 된다. 예: 생산관리, 연구개발, 영업 등 프로세스(Process)는 실행할 수 있는 단위로 정의된 업무 활동을 의미한다. 일의 시작과 끝이 있으며 실질적으로 일을 수행한다. 복수개의 하위 프로세스로 구성되어 있으며 여러 부서를 거쳐서 일어난다. 예: 기준정보 관리, 조직 관리, 품질 검사 등 하위 프로세스(Sub Process)는 프로세스의 구성 요소로 복수개의 기본 프로세스 또는 기본 활동으로 구성된다. 기본 프로세스 또는 기본 활동(Elementary process or Activities)은 업무(business)의 의미를 가지는 최소 단위 활동으로 한 사람이 한 장소에서 시작과 끝을 통해 일을 완수한다는 개념을 가지고 있으며 FP 모델링의 근간이자 개선 목표의 기본 단위가 된다. FP 모델은 산업에 따라 약간씩 차이가 나지만 공통적인 부분도 많다. 프로세스 혁신(PI)는 FP 모델 내 가치가 전달되는 핵심적인 과정(Critical Path)의 혁신을 목표로 하게 된다. 또한, 프로세스는 구분을 용이하게 하기 위해 계층(Hierarchy) 구조에 따라 구조화하며, 구조화 이후 이를 구분하여 식별하기 위해 수준별 ID (Identification)를 부여하는데 이는 향후 분석의 중요한 기준이 된다. 구조화 작업이 끝나면 프로세스 정의서를 작성한다. 프로세스 정의서는 Figure IV-25와 같이 프로세스 구성도, 프로세스 흐름도, 프로세스 상세 설명의 3가지로 구성된다. Figure IV-25. 프로세스 정의서의 구성 - 구성도, 흐름도, 상세 설명 프로세스 구성도는 전체 프로세스를 한눈에 볼 수 있도록 구성하는 것으로 가능한 상호 연결을 표시하는 것이 좋다 프로세스 흐름도는 전체 프로세스를 한눈에 볼 수 있도록 구성하되 하위 프로세스 간의 관계, 수작업 및 시스템을 이용한 자동화 일 처리, 승인 및 검토 여부에 따른 분기, Trigger Point 등을 구분하여 표기한다 프로세스별 상세 설명은 각 기본 활동(Activity)에 대한 상세 수행 방법이나 지침, 원칙, 입출력 관계, 수행 주체 등을 상세하게 설명한다. 또한, 프로세스 변화 내역과 이를 달성하기 위한 현업의 실행과제, 준수 여부를 파악할 수 있는 측정지표 등을 같이 표기하여 종합적으로 관리하는 것이 좋다. Figure IV-26. 프로세스 정의서 예시(1) PI 컨설팅을 위해서 FP 모델을 활용하는 것은 매우 일반적이며 필수적이다. 그러나 아마 FP 모델 작업을 해 본 대부분의 컨설턴트들은 FP 모델의 효용성에 대해 의문을 제기할 수 있을 것이다. 사실 FP 모델을 적용하여 프로세스 정의서를 작성하는 일은 상당히 많은 노력과 시간이 필요하다. PI를 제대로 하기 위해 상세하게 업무 모델을 분석하는 경우가 아니라면 큰 의미 부여를 하기는 어렵다. 즉, 무언가 있어 보이기는 하지만 고객과 단순한 커뮤니케이션이 목적이라면 다른 도구와 기법을 고민하는 것이 더 효율적일 수 있다. Figure IV-27. 프로세스 정의서 예시(2) 프로세스에 대한 이야기가 길었다. 두 번째, 혁신(Innovation)에 대해 생각해 보자. 혁신에 대한 다양한 정의(definition)가 있는데 그것들 중 몇 가지를 소개하면 다음과 같다. “the process of making improvements by introducing something new” ---- Wikipedia “the act of introducing something new or something newly introduced” ----- The American Heritage Dictionary “the introduction of something new; new idea, method, or device ---- Merriam Webster Online “change that creates new dimension of performance” ---- Peter Drucker 위 정의들로부터 도출된 공통된 개념이 ‘change’ 또는 ‘introduction’, 그리고 ‘new’이다. 즉, 혁신의 본질은 ‘새로운 것의 도입 또는 그것으로 인한 변화’로 생각할 수 있다. 이런 혁신은 Table IV-7과 같이 다양한 영역에서 적용될 수 있다. Table IV-7. 경영혁신의 다양한 적용 그런데 기업들은 왜 혁신(Innovation)을 왜 하고자 할까? 슘페터(Joseph Schumpeter. 1883 ~ 1950)는 새로운 재화의 도입을 위해, 새로운 생산 방식의 적용을 위해, 새로운 시장의 개척 등을 위해 혁신이 필요하다고 하였다. 궁극적으로 이는 더 많은 경제적 부(富)의 창출과 직결된다. 즉, 기업의 가치 창출과 직결되는 것이다. 나아가서 오늘날 혁신은 단순히 가치 창출만을 위함이 아닌 생존을 위한 혁신의 차원까지 올라가기도 한다. 변하지 못하면 사라지는 것이 정글의 법칙이기 때문이다. 강한 자가 살아남는 것이 아니라 살아남는 것이 강한 자라는 말은 혁신의 동기가 되기에 충분하다. [1] 기업에서 제품의 전략적 의미와 품질 수준을 극대화하기 위해 다양한 문제들을 정의하고 이를 해결하는 수준을 계량화하여 평가하고 관리하는 것을 의미한 6-시그마란, 변동을 표현하는 표준편차로 제품 100만 개당 0.002개 이하의 결함 즉, 거의 무결점 수준의 품질 수준을 지칭하는 용어임 14. 프로세스 혁신 방법로(2/2) 14.1 다양한 경영혁신의 방법 급변하는 경제 및 시장 환경의 변화는 경영 패러다임의 변화를 유발하였다. 특히, 경영 패러다임의 변화에 따라 기업의 경영혁신 기법들도 지속적으로 변화 발전하였는데 Figure IV-28은 그 변천을 보여준다. Figure IV-28. 경영 패러다임 변화에 따른 경영혁신 활동의 변천 1990년대 이후 특히 경영혁신 기법들이 다양화되고 있는데 제조 산업에 속한 기업들을 중심으로 기업 나름의 경영혁신 기법들의 구축하고 만족할 만한 성과를 얻어 이를 산업 전반으로 전파하였다. 일본 중심의 TPS[1], 미국 중심의 6 시그마, TOC[2], BPR, PI 등이 그것인데 Table IV-8은 널리 알려진 기법들의 특징을 보여준다. Table IV-8. 주요 경영혁신 기법들의 특징[3] 특히, IT의 급속한 발달과 함께 더욱 부각되고 있는 PI에 대해 좀 더 알아보자. PI 이란, 사업을 보다 효율적이고 수익성 높게 수행하고 고객에게 더 나은 서비스를 제공하기 위해 정보기술(IT)을 이용해서 프로세스를 재설계하는 것이다. Table IV-9는 프로세스 혁신과 프로세스 개선을 비교해 본 것이다. Table IV-9. 프로세스 혁신과 프로세스 개선의 비교 프로세스 혁신이 가장 큰 성과를 얻기 쉬운 기업은 산업이 성장기나 성숙기에 속해 있는 기업들이다. 산업 초기는 산업 고유의 프로세스라는 것이 제대로 정립되지 않은 상태이며, 산업 성장기는 원가나 비용 절감 등 경쟁이 심화되는 상황으로 다양한 혁신에 대한 고민이 요구되는 시기이기 때문이다. 또한, 산업 성숙기는 기존 경쟁의 기반 위에 혁신하지 않으면 쇠퇴할 수밖에 없다는 절박함이 팽배하게 되어 혁신에 대한 강한 갈망이 생길 수 있다. 이런 배경적 이해를 가지고 PI 방법론에 대해 좀 더 살펴보자. 경영혁신이 성공적인 성과를 거두기 위해서는 회사의 정책이나 관리 구조, 가치 체계의 변화까지도 필요할 수 있는데 그렇지 못하고 프로세스의 개선에 집중될 경우, 그 효과가 크지 않거나 지속되기 어려운 경우도 많다. 따라서 경영혁신 프로젝트를 성공적으로 추진하기 위해서는 반드시 최고 경영자를 비롯한 경영진의 지지를 얻어야 한다. 14.2 PI 방법론 PI는 ERP[4] 시스템 구축과 깊은 관계가 있고 그에 따라 추진 방법도 크게 두 가지로 구분된다. SAP와 Oracle[5]과 같은 설루션 기업들이 제공하는 상용 패키지(Package)를 이용하여 구축하는 방법과 기업의 전(全) 프로세스를 검토하고 직접 정보시스템을 개발하는 방법(In-house 개발)이 있다. Table IV-10은 두 가지 접근법을 비교하고 있다. Table IV-10. PI 추진 접근법 비교 우선, 패키지 중심의 추진 방법은 Top-Down 관점에서 기업의 비전과 전략 목표를 확인한 후, 핵심 성공요소(CSF)와 KPI 목표를 설정한 후, 프로세스 이슈를 도출하고 이를 개선하는 모델을 구성하고 그에 맞게 패키지 시스템을 커스터마이징(customizing) 한다. 반면, 프로세스 중심의 추진 방법은 Top-Down 관점에서 기업의 비전과 전략 목표 확인함과 동시에 Bottom-Up 관점에서 각 업무 영역의 KPI 및 목표를 도출하고 그 차이(gap)를 극복하는 대안을 찾아 프로세스에 반영하고 이를 정보시스템으로 직접 개발한다.[6] 1980년대 ERP가 소개되고 PI/ERP 사업이 꾸준히 이어졌으나 구축 이후 운영까지 생각해 보면 패키지 적용의 경우, 글로벌 표준을 도입하고 적용, 운용한다는 장점은 있으나 패키지 라이선스 비용이 과다하다는 지적이 있고, 프로세스 중심의 직접 개발은 기업의 전 프로세스를 대상으로 최적화된 시스템을 구축할 수 있으나 글로벌 표준과 멀고 운영 및 유지 보수가 복잡해질 수 있다는 단점이 있다. 그러나 최근에는 많은 기업들이 글로벌 표준 프로세스를 이미 도입하고 있어 그에 준한 값싼 IT 구축 및 운영을 고려하고 있고, 클라우드 기반의 SaaS 서비스가 떠오르고 있어 ERP도 서비스 형태로 구매하기도 한다. 14.3 PI와 6-시그마의 비교 PI와 더불어 많이 사용되는 프로세스 혁신 방법으로 6-시그마 기법이 있다. 6시그마는 Figure IV-29에서 보는 것처럼 그 목적과 관점이 PI와는 좀 다르다. PI가 일회적인 방법으로 기업의 구조적 개선 기반 조성을 목적하는 것인 반면, 6 시그마는 특정 프로세스의 품질을 중심으로 지속적인 개선을 추구한다. Figure IV-29. PI와 6-시그마의 관점 비교 Table IV-11은 PI와 6-시그마를 비교한 것이다. Table IV-11. PI와 6-시그마의 비교 6-시그마 기법은 모토롤라에 의해 시작되어 GE에 의해 널리 알려지게 되었고 제조 산업에서 널리 사용되었다. 그러다가 프로세스 혁신에 대한 효용성을 인정받아 전 산업으로 확장되었다.[7] 이후 PI와 같이 연계되어 중장기 과제는 PI로, 단기과제는 6-시그마로 다양한 혁신과제들을 수행하기도 하였다. 최근에는 PI와 6-시그마의 붐이 많이 수그러진 편이다. 혁신의 피로도를 호소하는 이유도 있고 과거와 달리 각 기업의 사정에 맞는 다양한 혁신 기법들을 기업들이 찾았기 때문일 수도 있다. 저자 개인 생각에는 조만간 PI 영역이 또 한 번 뜰 것 같다. 왜냐하면 제4차 산업혁명 때문이다. 정확히 말하면 온 사방 천지에 깔릴 IoT[8] 기반 때문일 것이다. 로봇이나 인공지능의 도입으로 전통적인 기업의 제조나 운영 프로세스가 완전히 바뀌고 있다. 크고 작은 프로세스 개선/혁신의 건이 매우 많이 발생할 것이다. 그러나 컨설팅 기업 입장에서 그 건건을 제대로 대응할 수 있을지 의문이다. 그것은 이해도의 차이도 있을 것이고 사업비의 이슈도 있을 것이기 때문이다. 그런 배경을 읽고 있기에 기업들은 더 이상 컨설턴트들의 손을 빌리기보다는 자체적으로 그것을 수행할 수 있는 능력을 키우고자 하는지 모른다. 어쨌든 경영혁신은 그 방법이 무엇이든 기업이라는 것이 존재하는 이상 앞으로도 지속적일 수밖에 없는 컨설팅 테마이다. 한마디로 돈 되는 영역이다. [1] Toyota Production System [2] Theory of Constraints [3] Dave Nave, “How to compare lean, 6 sigma, and TOC”,Quality Progress, March 2002 [4] Enterprise Resource Planning 전사적 자원관리 [5] www.sap.com; www.oracle.com [6] 제조 산업이 아니라 금융산업 등 기타 타 산업의 PI는 거의 후자(In-house 개발)를 많이 채택하였으나 상용 패키지를 제공하는 설루션 기업들도 제조 산업뿐 아니라 타 산업의 사례를 많이 확보하고 있는 중이다. [7] 한때 제조업 기반의 혁신 기법이 서비스 산업에 적합할까 하는 것이 화두인 적이 있었다. 저자 사견으로는 억지로 적용할 필요는 없을 것 같다. [8] Internet of Thing. 사물인터넷 15. 신사업 개발 방법론(1/2) 저자 사견이지만 경영전략, 경영혁신과 더불어 비즈니스 컨설팅의 최고 인기 테마는 신사업 개발(New Business Development: NBD)이다. 흔히 ‘NBD’라고도 불리는 신사업 개발 컨설팅은 사업타당성 분석(Feasibility Study: F/S)과 곧잘 비교되는데 그 과정이 상당히 비슷하면서도 NBD가 아이템을 찾는 것에 집중된다고 한다면 F/S는 발굴된 신사업 아이템이 실제 제대로 작동할 것인지를 판단하는 것으로 서로 그 관점이나 일의 성격이 조금 다르다. 또한, 신제품 개발은 흔히 R&D 전략과 같이 연계하여 고민되는 것으로 협의의 사업 개발 또는 사업 개발의 한 범주라고 할 수 있다. 컨설팅 프로젝트로 생각해 본다면 1차적으로 체계적인 접근을 통해 고객이 성공적으로 신사업을 개발할 수 있게 도와주는 일이 있고, 2차적으로는 그렇게 개발된 신사업을 컨설턴트 본인이<NAME>여 직접 실행하는 것이다. 전자는 신사업 개발 컨설팅이 될 것이요 후자는 신사업 개발이 될 것인데 무엇을 하던 본 장의 내용은 유익할 것이다. 신사업을 다루면서 가장 중요한 것은 비즈니스 모델(Business Model)에 대한 이해이다. 비즈니스 모델이라는 용어는 1990년대 초반 e-비즈니스의 산실이었던 미국 실리콘밸리의 수많은 벤처기업들(Venture)이 많이 사용하면서 널리 알려졌는데, 인터넷을 매개로 하는 다양한 아이디어를 가지고 친구와 동료, 선후배들이 둘, 셋 모여 만든 벤처기업들은 기존 기업들에 비해 회사를 설립하거나 운영할 때 소요되는 자금이 상대적으로 부족하였다. 따라서 벤처기업들은 그들의 사업방식을 주요 자금 주인 은행이나 벤처 캐피털(Venture Capital)들에게 충분하고 명확하게 설명할 필요가 있었다. 이때 도입된 개념이 비즈니스 모델이다. 1980년 대까지만 하여도 기업의 경영현황을 설명하기 위해 널리 쓰이던 ‘전략(Strategy)’이라는 용어는 사업 환경과 경쟁 방식을 분석하면서 사업의 비전 (Vision)을 달성하기 위한 실행과제와 그 이행방식을 표현하였다면, ‘비즈니스 모델'이라는 용어는 고객과의 관계를 강조하고 어떻게 상거래가 실현되며 그 과정에서 어떻게 수익이 창출되는지 설명하는 것에 보다 집중하였다고 볼 수 있다. 비즈니스 모델은 특별한 원칙 없이 그림이나 글 등 다양한 방식으로 설명되었고 이를 통해 자본가들과 보다 쉽게 커뮤니케이션할 수 있었다. 이후 비즈니스 모델은 2017년 현재 기업 활동을 설명하는 훌륭한 방법 중의 하나가 되어 있다. 비즈니스 모델의 형태를 표현하는 B2B나 B2C라는 용어는 각각 ‘Business-To-Business’, ‘Business-To-Consumer’의 약자로서 비즈니스 모델을 전자상거래 대상의 관점에서 이분화하여 B2B 전자상거래(B2B e-Commerce)는 기업 고객을 대상으로, B2C 전자상거래(B2C e-Commerce)는 일반 소비자를 대상으로 제품을 판매하는 상황을 지칭하던 용어였는데, 현재는 전자상거래뿐 아니라 모든 산업 분야에서 B2B는 ‘기업 간 거래’, B2C는 ‘기업-개인 간 거래’라는 개념으로 자연스럽게 확장되어 사용되고 있다. B2B는 그 의미가 좀 더 확장되어 대상 고객이 국가나 정부기관, 공기업이 될 경우, B2G(Business-To-Government), 고객의 고객까지 생각할 경우 B2B2B, B2B2C, B2B2G 등의 다양한 파생적 개념들까지 나타나게 되었다. Figure IV-30은 재화의 흐름으로 살펴본 B2B 기업과 B2C 기업의 관계이다. Figure IV-30. 재화의 흐름과 B2B, B2C의 개념 15.1 비즈니스 모델의 개념 비즈니스 모델에 대한 수많은 정의가 있고 사업가(Entrepreneur)들의 경험적 이야기들이 있기 때문에 그 개념을 수학 문제와 같이 딱딱 떨어지는 답처럼 이야기하는 것이 옳지 않을 수 있지만 제15장에서는 저자가 보아왔던 다양한 개념 중 가장 많이 공감하는 개념을 소개하고자 한다. 미국의 경영학자 피터 드러커(Peter Drucker. 1909 ~ 2005)와 전(前) 베인 앤컴퍼니(Bain & Co.) 파트너였던 조안 마그 레타(Joan Magretta)가 주창한 것이다. 저자는 이들의 의견들을 종합해서 Figure IV-31과 같이 도식화해보았다. Figure IV-31. 비즈니스 모델에 대한 고찰 조안 마그 레타는 비즈니스 모델을 성공적으로 설명하기 위해서는 두 가지 테스트 즉, ‘Narrative Test’와 ‘Number Test’를 통과해야 한다고 하였고[1], 피터 드러커는 비즈니스 모델의 본질을 파악하기 위해서 고객과 제품, 제공 방식에 대한 잘 알아야 한다고 하였다. 첫 번째, ‘Narrative Test’이라 함은 스토리텔링(Story-telling)과 통하는 표현으로 투자자들에게 내 사업의 이야기를 재미있고 생생하게 전달할 수 있어야 한다는 것이다. 여기서 ‘재미있다’는 말은 ‘우스갯소리를 하라’라는 것이 아니라 ‘보다 쉽고 현실감 있게 전달하여 투자자들로 하여금 내용에 몰입되게 해야 한다’라는 의미이다.[2] 피터 드러커의 의견[3]을 곁들이면 어떤 고객(WHO)에게 고객 가치(Customer Value)와 제품/서비스(WHAT)를 어떻게(HOW) 제공하겠다는 것을 아주 명확하게 이야기할 수 있어야 한다. 즉, 기업가가 구상하는 비즈니스 모델에서 고객은 누구이며 기업의 제품이나 서비스는 무엇이며, 어떤 체계(생산방식, 물류방식, 판매 방식 등)를 통해 오퍼링(Offering)을 고객에게 제공하겠다는 것을 간단 명료하게 설명할 수 있어야 한다. 두 번째, ‘Number Test’는 재무성과에 대한 것 즉, 돈의 흐름을 통해 그 결과가 플러스인가 마이너스인가에 대한 것이다. Narrative Test를 진행하면서 언급되는 다양한 활동에 투입된 돈은 얼마이며 결론적으로 이 비즈니스를 통해 돈은 얼마를 벌 수 있는지 즉, 현금 흐름(Cash flow)을 명료하게 보여줌으로써 투자자가 이 사업에 대한 투자를 확신할 수 있게 해야 한다. 물론 추청 재무제표(Pro Forma)의<NAME>을 띄게 될 것이므로 실제 일이 진행되면서 변경될 소지가 있을 수 있으나 투자자는 Narrative Test를 통해 충분히 사업에 대해 매력을 느꼈고 Number Test를 통해서 돈이 된다고 생각한다면 당연히 투자하게 될 것이다. 특히, Number Test는 최종적인 가격이 만들어져서 수익에 대해 논의할 수 있는 수준이 되어야 한다. 위의 두 가지 관점 테스트는 수많은 전략기획가, 컨설턴트와 기업가들에 의해 널리 사용되고 또 정리되었는데, 2004년 오스터왈더(1974 ~ present)에 의해 ‘Narrative Test’를 훌륭하게 표현할 수 있는 도구인 비즈니스 모델 캔버스(Business Model Canvas. BMC)가 소개되면서 또 한 번 전기를 맞이하게 되었다. Figure IV-32는 BMC를 나타내고 있는데 사용법은 간단하다. Figure IV-32. 비즈니스 모델 캔버스 템플릿 Figure IV-32와 같은 그림을 A4 용지 또는 더 큰 종이에 인쇄하여 벽에 붙이고 사업모델에 대한 다양한 이야기들을 브레인스토밍(Brainstorming)과 같은 방법을 통해 각 섹션에 붙여보는 것이다. 9개 요소가 있다고 하여 '9-Block'이라고도 불리는데 그 항목은 다음과 같다. BMC를 읽는 방법은 첫 번째 가치 제안(Value Proposition)을 정의하는 일로 시작한다. 가치 제안(Value Proposition)은 궁극적으로 기업과 고객에게 어떤 가치를 제공할 것인지를 정의하는 것이다. 제품이나 서비스의 기능적 가치 이외에 사회적 가치까지 크게 접근하는 것이 좋다. 가치 제안 정의가 끝나면 BMC에서 가치 제안의 좌측은 가치 생산(Value Production)을 하는 영역으로 어떻게 기업의 제품이나 서비스가 생산되는지를 설명하는 부분이다. 핵심 자원(Key Resources)은 기업의 제품과 서비스를 구축하기 위해 필요한 물적 자원, 인적자원 등을 정의해 본다. 핵심 파트너(Key Partnerships)는 기업의 제품이나 서비스를 구축하기 위해 필요한 외부 이해관계자들을 적어본다. 핵심 활동(Key Activities)은 핵심 자원과 핵심 파트너를 통해 가치 제안을 수행하기 위한 활동이다. 특별한 제작이나 조달이 될 수도 있고, 고객을 이해하는 방식이 될 수도 있다. 비용(Cost Structure)은 가치 생산을 위해 소요되는 재무적 내역을 기술해 보는 것이다. 로직 트리(Logic Tree)를 생각해서 주요 비용 항목(Cost Drivers)들을 정의하는 것으로 충분하다. 가치 생산 부분이 정의되면 우측의 가치 전달(Value Delivery)을 생각해 본다. 고객(Customer Segments) 부분은 어떤 고객을 대상으로 할 것인지 정리해 본다. 그 고객은 대부분 목표 고객(Target Customer)이 된다. 채널(Channels)은 어떤 방식을 통해 제품과 서비스를 고객에게 전달할 것인지 고민해 본다. 고객 관계(Customer Relationships)는 제품과 서비스를 공급한 고객과 어떻게 지속적으로 관계를 유지하기 위한 방법들을 고민해 본다. 수익(Revenue Streams)은 결과적으로 가치 생산된 제품과 서비스가 고객에게 가치 전달된 후 고객이 기업에게 대가를 지불하는 방식과 내용에 대한 것이다. BMC는 일회적으로 사용하기보다는 사업모델을 지속적으로 정교화하면서 9 블록의 내용을 발전시키고 확정하는 것이 필요하다. [1] Joan Magretta, ‘Why Business Models Matter?’, HBR, 2002 [2] 대화의 기술이나 화법도 효과적인 전달에 분명히 영향을 끼칠 수 있으나 이 장에서 그 효과는 배제한다 [3] Peter Drucker’s age-old questions, HBR, 1999 15. 신사업 개발 방법론(2/2) 15.2 신사업 니즈(Needs)의 명확화 비즈니스 모델의 개념을 이해했다면 이제 본격적으로 신사업 개발에 대해 고민해 보자. 첫 번째 순서는 신사업의 니즈(Needs)를 명확히 해야 하는 것이다. 즉, 신사업의 방향을 설정하는 것과 프로젝트의 목표를 설정하고, 어떤 인원으로 팀을 구성할 것인지 등을 결정하는 일이다. Figure IV-33은 신사업 니즈를 명확화하기 위해 로직 트리를 구성해 본 것인데 이를 통해 사업 니즈를 명확히 하고 사업 발굴의 방향을 경영진과 컨센서스(concensus) 하는 것이 필요하다. Figure IV-33. 신사업 니즈의 명확화 또한, 신사업 니즈가 확인되면 어떤 관점에서 사업 아이디어를 선택하고 지지할 것인지 기준이나 가이드라인을 설정해야 하는데 이 규칙에 의해 신사업 아이디어나 아이템들은 최종적으로 선택된다. Figure IV-34는 신사업 가이드라인(guideline)을 예시적으로 구성해 본 것으로 가이드라인 설정의 관점을 사업적 관점이나 재무적 관점에서 정하고 경영진 및 관련자 인터뷰와 실무진 워크숍을 통해 이를 결정하고 신사업 개발의 Ground Rule을 확정한다. Figure IV-34. 신사업 가이드라인의 작성 사례 사업의 실현 가능성의 측면에서 이런 스크리닝(screening) 기준을 사전에 가져간다는 것은 바람직할 수 있으나 한편으로는 매우 창의롭고 자유로와야 할 신사업 개발을 가로막는 벽이 되기도 한다. 적절한 시행착오(Trade-Off)가 필요하지만 시간과 자원이 부족한 현장에서 이를 밸런스 하기는 쉬운 일이 아니며, 실제로 신사업 개발을 하면서 이것 안되고 저래서 안되고 하는 이유로 좋은 아이디어가 벽에 부딪히는 경우가 매우 많다. 그럼에도 불구하고 그것을 극복하고 혁신하는 기업들은 기회를 잡게 된다. 즉, 아이디어가 없는 것이 아니라 많은 사람들이 생각하는 아이디어이지만 그걸 '실현시키는 실행력'과 '한계를 극복하는 혁신'이 실질적으로 신사업을 성공시킨다. 15.3 신사업 아이디어의 선정 - BMO 평가 신사업 니즈를 명확히 정의하면 본격적으로 사업 개발에 들어가야 할 차례이다. 사업 아이디어는 Table IV-12와 같이 처음 개념화되고 시간이 지남에 따라 성장하여 사업 포트폴리오에 반영되고 결국 생명을 다하게 된다. Table IV-12. 기업의 신사업 발굴 과정 사업 아이디어를 평가하는 다양한 방법이 있지만 이 장에서는 BMO 기법을 소개하고자 한다. BMO는 개발자인 Bruce Merrifield와 Ohe의 이름을 딴 평가 기법으로 원래는 기술의 사업화를 위해 유망 기술을 판별하는 방법이었는데 일본의 大江 建(Takeru Ohe) 교수가 아이디어를 더해 사업 기회의 스크리닝 기법으로 발전하였다. 개념은 간단하다. BMO 평가는 사업 아이템을 3단계로 평가하는데 다음과 같다. 1) 사업이 얼마나 매력적인가? 2) 사업이 자사에 얼마나 적합한가? 3) 어느 정도 성공 확률을 가지는가? 첫 번째, 평가를 위해 매력도 분석을 하는데 BMO 평가는 시장의 규모(매출 또는 이익 가능성), 성장성, 경쟁력, 리스크 분산도, 업계 재구축 가능성, 사회적 우위성 등 6가지 매력도 지표를 가지고 각각 10점씩 60점으로 평가한다. 두 번째, 적합성 분석을 위해 자금력, 마케팅력, 제조력, 기술력, 원자재 확보 능력, 경영 지원 등 적합성 지표를 각각 10점씩 60점으로 평가한다. Table IV-13은 BMO 매력도 평가 기준의 사례[1]이다. Table IV-13. BMO 평가 매력도 지표의 사례 각 항목당 배점을 고려하여 60점 만점 기준으로 점수를 환산해 볼 수 있다. 또한, Table IV-14는 BMO 평가의 적합도 평가 기준의 사례이다. Table IV-14. BMO 평가의 적합도 평가 지표 사례 Table IV-13과 TableIV-14를 활용하여 사업 아이디어의 매력 도와 적합도를 계산한 다음, Figure IV-35와 같은 BMO 평가 맵을 작성한다. Figure IV-35. BMO 평가 결과와 사업 참여 여부 매력 도와 적합도의 조합에 의해 적절한 값이 산출되는 경우에 한 해 신사업 참여를 결정하면 된다. 참여 방법은 독자적으로 사업을 전개하던지 제휴(Strategic Alliance), 합병(Merge), 매수 등 다양한 방법들이 있다. BMO 평가는 정성적인 평가도 많이 들어가지만 대략적으로 신사업의 전체 모습을 파악하기에 유용하며, 재무분석 시뮬레이션을 아무리 정확하게 하여도 미래를 예측할 수 없는 상황이기 때문에 일단 시작할지 하지 않을지 빠르게 생각해 보는 좋은 도구이다. 다음 장에서는 만약에 실행한다고 하면 어느 정도 실현 가능성이 있는지 조금 더 깊게 살펴보는 사업타당성 분석에 대해 알아보자. [1] BMO 매력도 평가의 관건은 정확한 값이 아니라 기준의 어느 구간에 속해 있는 냐가 중요하다. 같이 읽어보면 좋은 책! 'The Business Model Ontology – A Proposition In A Design Science Approach’, Alexander Osterwalder, 2004 16. 사업타당성 분석 신사업을 개발하고 론칭(launching) 하기까지 사실은 사업타당성 분석(Feasibility Study: F/S)이라는 이름으로 이런저런 '돌 두드리기'를 하는 기업들이 많다. 사업이나 투자의 규모가 클수록 그런 경향은 다분한데 도로나 철로, 댐이나 다리 건설 등과 같은 대규모 토목공사나 건설공사의 경우 엔지니어링 업체[1]가 F/S를 많이 하게 된다. 내용은 설계를 포함할 수도 있고 경우에 따라서는 Pre F/S(Preliminary F/S)라고 F/S 이전에 기초 조사 프로젝트가 나오는 경우가 많다. 해외 건설 사업 또는 해외 건설 사업과 동반된 해외 IT 사업이 그런 경향이 다분한데, Pre F/S 이후에도 사업이 추진되기까지는 F/S를 하고 또 제안까지 2~3년 걸리는 등 진척이 매우 느리다. 어쨌든 이 F/S의 개념[2]은 전 산업을 포괄하여 적정성 평가라고 하는 틀로 거의 동일하다. 때때로 기술적인(Technological) 부분의 평가가 있는데 그 부분이 해당 산업 또는 도메인(Domain)의 영향이 가장 크다고 할 수 있고, 재무적 평가 영역으로 가면 거의 동일하다고 할 수 있다. 결국, 사업타당성 분석은 발굴된 사업 또는 프로젝트를 대상으로 미래에 예상되는 경제 상황을 고려하여 시장, 기술, 경제성, 공익성(또는 정책성) 등을 분석하고 해당 사업 또는 프로젝트의 성공 가능성을 평가하는 총체적인 과정이라 설명할 수 있다. 위키피디아[3]에서는 사업타당성 분석을 다음과 같이 표현하고 있다. Feasibility Studies aim to objectively and rationally uncoverthe strengths and weakness of the existing business or proposed venture, opportunities, and threats as presented by environment, the resources requiredto carry throught and ultimately the prospects for success --- Wikipedia ‘현존하는 비즈니스 모델 또는 제안하는 신사업의 강점과 약점, 제한된 유한한 자원과 환경, 성공하기 위한 궁극적인 기회와 위기 등에 대한 고찰이 필요하다’고 언급하고 있다. 이쯤 되면 사업 전략과 사업 계획, 사업타당성 분석은 도대체 어떻게 서로 다른지 의아해할 수도 있다. 각 용어마다 동일한 ‘사업’이라는 단어가 포함되어 있어 더 혼란스러울 수 있는데 우선 ‘사업 전략(business strategy)’이라는 용어가 내포하고 있는 것 중에 가장 중요한 의미는 사업의 비전(vision)과 가치(value)이다. ‘사업 계획(business planning)’은 사업 전략에 실질적인 자원 배분(Resources Allocation)을 하는 것이다. 즉, 사업 계획이란 수립된 사업 전략의 실행을 위해 여러 가지 활동들을 누가, 언제, 어떻게 하겠다는 것을 천명한 것이다. ‘사업타당성 분석(feasibility study)’은 사업 계획 수준의 상세한 자원 배분은 하지 않지만 해당 사업을 추진하기 위해 수립된 전략을 수행할 경우, 필요한 총비용과 총수익을 산정하여 해당 사업이 돈을 벌 수 있는가 또는 사회적 편익(Social Benefits)이 발생하는가를 판별하는 일이라 할 수 있다. 따라서 사업타당성 분석을 수행하는 것은 해당 사업을 대상으로 사업 전략이나 사업 계획을 수립하는 활동들이 상당 부분 포함된다. 사업타당성 분석 보고서는 다음 항목들에 대해 서술한다.[4] 사업 개요(Business Introduction) 제품 및 서비스 개요(Product or Service) 구현 기술(Technology) 시장 환경(Market Environment) 경쟁 환경(Competition) 산업 구조 및 현황(Industry) 비즈니스 모델(Business Model) 마케팅 및 영업 전략(Market and Sales Strategy) 생산운영 요구사항(Production Operations Requirements) 규제 및 환경 이슈(Regulations and Environmental Issues) 주요 위험 요소들(Critical Risk Factors) 재무 예측(Financial Prediction) 결론(Conclusion) 또한, 모든 사업타당성 분석 결과 물들은 위의 항목들을 거의 포함하지만 검토하고자 하는 사업이 민간사업인지 공공사업인지에 따라 그 수행 근거나 강조하는 부분이 좀 다르다. 제16장에서는 이런 점을 생각하면서 사업타당성 분석에 대해서 상세히 알아보자. 16.1 민간 영역의 사업타당성 분석 민간 영역(Private Sector)의 사업타당성 분석은 Figure IV-36과 같은 흐름을 가지고 진행된다. Figure IV-36. 민간영역 사업타당성 분석의 기본 개념 사업의 비전과 가치에 대해 CEO를 비롯한 사업 이해관계자들이 공감할 수 있어야 하고, 시장 분석을 통해 수요를 예측하며 기술타당성 분석을 위해 투자비를 예측한다. 수익과 비용 분석을 통해 현금의 유출입을 산정한 후, 경제성 평가를 통해 수익성이 있다고 판단되면, 자금조달 계획을 수립하고 사업을 추진하는 순서로 일이 진행된다. 민간 기업의 사업타당성 분석이다 보니 이 과정에서 법/제도 부분에 대해 점검해야 하는 것들이 있다. 예를 들면, 한국의 경우, 세법이나 공정거래법, IFRS의 영향 등을 살펴야 하는데 세법은 해당 사업이 법인세 공제나 감면 혜택이 있는지 검토해야 한다. 정부의 주요 정책에 의해 추진되는 사업 아이템의 경우, 그런 혜택이 존재할 수 있다. 또한, 공정거래법의 경우, 대기업 그룹이 신사업을 추진할 때 민감하게 검토되는 부분인데 주식 취득을 제한한다든지, 진입 제한 산업이 존재한다든지, 계열 편입신고에서 독점 여부 등으로 문제가 발생할 수 있다. 또한, IFRS와 같은 회계 처리의 문제에서도 수익의 인식 기준이나 부채성 충당금의 인식 등이 연결되어 있는 기업 간의 실적 통합 시 악영향이 생기지 않도록 면밀히 검토해야 한다. 그 외에도 사업타당성 분석은 투자에 대한 합리적 판단을<NAME>는 것이므로 금융시장의 현황이 대단히 중요한데 환율이나 금리 변동을 잘 살펴야 한다. 특히, 해외투자 사업의 경우, 해당 국의 법인세법, 부가세 법, 해외법인의 송금제한 등과 관련해서 대응책을 마련해야만 현금이 정상적으로 유통될 수 있다. Figure IV-36과 같은 흐름의 업무 진행을 통해 경제성 평가를 수행하고 수익성이 있다고 판단될 경우, 자금조달 계획을 수립하게 된다. Figure IV-37. 자금조달 계획의 개념 사업을 추진하기 위해서는 Figure IV-37과 같이 인건비, 재료비, 마케팅, 기타 비용 등 투자금이 필요하다. 이를 기업 내 자기자본과 타인자본을 융통하여 사업 자금을 마련하는 것이 자금조달 계획인데 어떤 사업가도 마찬가지이겠지만 자기자본은 작게, 타인자본은 저렴하게 빌려와서 사업을 하고 싶어 한다. 공공사업의 경우, 이런 고민은 상대적으로 좀 덜하다. 일반적으로 공공사업은 공공의 편익(Benefit)이 목적이기 때문에 실질적인 편익이 발생될 수 있는 제품이나 서비스를 공급하는 것이 목적이고 한편으로는 명분이 대단히 중요하기 때문에 그 명분을 어떻게 잘 만들 수 있느냐가 또한 컨설팅 포인트가 된다. 16.2 공공 영역의 사업타당성 분석 정부가 주관하는 공공 영역(Public Sector) 사업은 예산의 효율적 집행을 위해 예비타당성 조사의 대상과 범위를 확대하고 있다. 공공사업은 돈을 벌기 위한 것이 아니라 국가가 국민을 대상으로 공공성을 가진 다양한 서비스를 제공함으로써 국민들의 편익을 증진시키는 것을 가장 큰 목적으로 생각한다. 세금으로 걷어진 예산을 집행하는 공공사업이다 보니 국가 재정(budget)을 투입하더라도 규모가 큰 사업의 경우, 사업 진행을 위해서는 기획재정부가 제시하는 예비타당성 조사(이하 예타)를 수행한다. Table IV-15. 민간사업과 공공사업의 사업타당성 조사 비교 국내 공공사업의 예비타당성 조사는 Figure IV-38과 같이 크게 다음 5가지 분석을 진행한다. 사업 기초자료 분석 경제적 분석 정책적 분석 지역 균형 발전 분석 다기준 분석(AHP) Figure IV-38. 예비타당성 조사 수행체계 이 중 경제성 분석은 민간 기업에서 추진하는 비즈니스 모델의 수익성 분석에 대응할 수 있는데 손익분기점(Break Even Point: BEP)이나 목표 이자율, 수익 등을 구하는 것처럼 비용-편익 분석(Cost-Benefit Analysis)을 수행한다.[5] 총비용과 총 편익의 비율을 산정하는 B/C 비율을 구하게 되는데, B/C 비율이 1보다 클 때 경제적 타당성을 확보한다고 간주한다. 또한, 모든 분석 결과를 종합하여 다기준 분석 또는 계층화 분석 법(Analytic Hierarchy Process: AHP)을 수행하게 되는데 AHP가 0.5 이상이면 사업 시행이 바람직하다고 생각한다. Break #19. 전문가의 통찰력? AHP? AHP는 '쌍대 비교(Pairwise Comparison)'라는 간단한 방법을 통해서 비교 대상 간의 가중치(중요도)를 도출한다. 비교 대상이 다수 개일 경우 이들을 동시에 고려하여 그들 사이의 가중치를 계산하기란 사실상 불가능하다. 그러나 비교 대상(또는 비교 요소)를 1:1로 만들어주면 쉽게 비교할 수 있다. AHP의 가중치 도출은 비교 요소들을 상위 요소(또는 판단 기준)에 대해 1:1 비교를 통해 비율척도를 도출하고 그 비율척도를 기초로 고유치(Eignevalue)를 계산하여 요소별 가중치를 산정해 내는 방법이다. 이 과정에서 일관성<NAME>를 산출하여 의사결정자의 판단이 논리적으로 일관성을 유지하고 있는 정도를 보여줌으로써 판단의 오류를 수정할 수 있는 기회를 제공하기도 한다. 그러나 사견이지만 뛰어난 통찰력을 가진 전문가의 판단 결과를 뒤엎는 결론을 이끌지는 못하였다. 다만, 그것의 논리적 또는 산술적 근거를 제시할 수 있다. 간단한 예를 들어 AHP를 수행해 보자. 앞서 알아본 BSC의 4가지 관점 즉, 재무적 관점(A), 고객 관점(B), 내부 프로세스 관점(C), 학습과 성장 관점(D) 간의 중요도를 산출해 보는 사례이다. 각 관점에서 대해 40%, 30%, 25%, 5%와 같은 임의의 절대치를 부여하는 것이 아니라 'A가 B보다 약간 중요하다'라든가 'B가 C보다 매우 중요하다'와 같은 일상적인 표현을 통해 각 관점 간의 비교를 수행해 보자. 4개의 관점 A, B, C, D에 대해 비교 행렬의 요솟값으로 1-9까지의 숫자를 부여한다.[6] Figure IV-39와 같은 비교 행렬(Comparison Matrix)가 만들어진다. 즉, A(재무적 관점)은 Figure IV-39. 비교 행렬 B(고객 관점)보다 약간 중요하다는 표현이다.(3배 중요하다가 아니다). 대각선 아래의 란에는 대각선 위쪽 해당 란의 역수를 자동적으로 부여한다. 다음 단계로 작성된 비교 행렬의 주 고유벡터를 활용하여 위의 1:1 비교 결과를 통합한다. 우선 Figure IV-39의 쌍대 비교 매트릭스의 각 열(column)에 대한 합계를 Figure IV-40과 같이 구한다. Figure IV-40. 비교 행렬 계산(1) 그다음 각 열의 합계 값으로 각 열의 각 요소를 나누어 표준화(normalization) 하고, 표준화된 매트릭스에서 각 행의 합계를 구한 다음, 이를 요소의 개수인 4로 나누면 각 요소의 평균 가중치, 즉 우선순위/중요도 벡터가 구해진다.(Figure IV-41) Figure IV-41. 비교 행렬 (2) 이렇게 함으로써 최종적으로 4개 관점 각각의 중요도가 도출되었다. 즉, 재무적 관점(A), 고객 관점(B), 내부 프로세스 관점(C), 학습과 성장 관점(D)의 가중치가 각각 0.512, 0.238, 0.078, 0.172라는 이야기 히다. 이것의 해석은 가장 중요하게 생각한 재무적 관점(A)은 다른 3개를 합한 것보다 큰 51.2%의 중요도를 가진다는 의미이다. 따라서 이 회사에서 BSC의 관리에서 어느 부분의 KPI 관리에 더 집중해야 할 것인지 효율적인 의사결정을 할 수 있게 해준다. 실제 AHP는 기법 자체는 어렵지 않으며 엑셀이나 전문 분석 도구를 이용한 데이터 처리 그리고 무엇보다도 제대로 입력된 데이터가 가장 중요하다. 어떤 분석이든 'Garbage in, Garbage out' 원칙은 불변의 진리이다. [1] 건설업에서는 엔지니어링 업체가 컨설팅 업체라고 생각할 수 있다. [2] 건설 사업 소위, 도로, 철도, 공항, 항만 등 국가기반 시설을 구축하는 SOC(Social Overhead Capital. 사회간접자본) 사업에서 F/S는 가장 일반화되어 있으며 SOC 사업은 크게 다음 3단계로 진행된다. (1) 사업타당성 분석(Feasibility Study: F/S) (2) 엔지니어링/구매/건설(Engineering/Procurement/Construction: EPC) (3) 운영 관리(Operation and Management: O&M) [3] http://www.wikipedia.org [4] 이 순서는 보고서 목차가 아니다. 사업타당성 분석 보고서는 사업의 종류나 고객의 요구사항에 맞게 이 항목들을 적절히 취합, 정리하여 목차를 결정한다. [5] 비용-편익 분석이 적절하지 않은 순수 R&D 사업은 비용-효과(Cost-Effectiveness) 분석을 수행한다. [6] AHP에서 9점 척도를 사용하는 것은 심리학의 '자극-반응 이론'에서 도출된 연구 결과에 따라 A와 B의 선호도가 같은 경우 1, 약간 좋은 경우 3, 꽤 좋은 경우 5, 매우 좋은 경우 7, 월등히 좋은 경우 9로 평가한다. 6.3 투자/사업 가치 평가 법 사업타당성 분석의 마지막 단계는 경제성 분석이라고 부르는 부분이다. 혹자는 수익성 분석이라고도 말하는데 엄밀히 말하면 수익성 분석은 아니다. 영업이익이나 영업이익률, 당기순이익 등 기업이 얼마나 돈을 벌 수 있는가를 계산하는 것이 아니라 투자 기간이나 투자된 현금흐름을 가지고 사업이 타당한 것인가를 살펴보기 때문에 수익성 분석이라는 말보다는 경제성 분석이라는 말이 올바른 용어이다. 널리 활용되고 있는 4가지 방법에 대해 살펴보자. [#1. 회수기간법(PP: Payback Period Method)] 회수기간법은 투자 안에 소요되는 원금을 회수하는 기간을 구하여 투자의사 결정을 하는 방법으로 매우 간단한데 다음과 같이 계산한다. 회수기간법의 장점은 계산이 간단하고 이해하기 쉬우며, 자금 사정의 안정 측면에서 유동성을 선호하고, 기준 시점 이후의 현금 흐름의 불확실성을 조정할 수 있다. 단점은 화폐의 시간가치를 무시하여 임의의 기준시점이 필요하고, 기준시점 이후의 현금흐름은 무시하기 때문에 R&D와 같은 장기/신규 사업의 평가도구로서는 적합하지 않다. 의사결정 기준은 독립적인 투자 안의 경우, 목표 회수기간보다 짧은 투자 안을 선택하며 상호 배타적인 투자 안의 경우, 목표 회수기간보다 짧은 투자 안 중 가장 짧은 투자 안을 선택한다. 예를 들어보면 다음과 같다. 각각 10,000원을 투자한 투자 안 A, B의 회수기간을 계산해 보면 (1) 투자 안 A - 1차년 + 2차년 + 1,000 = 10,000 - 2년 + 1,000/3,000 = 2.33년 (2) 투자 안 B - 1차년 + 2차년 + 3차년 +4,000 = 10,000 - 4년 따라서 회수기간이 2.33년으로 4년보다 짧은 투자 안 A를 채택한다. [#2. 회계적 이익률법(ARR: Accounting Rate of Return Method)] 회계적 이익률법은 투자액에 대한 연평균 회계적 순이익률에 의거하여 투자 의사 결정을 하는 방법으로 다음과 같이 계산한다. 회계적 이익률법의 장점은 계산이 간단하고 이해하기 쉬우며, 회계자료를 바로 이용할 수 있어 편리하다. 단점은 화폐의 시간가치를 무시하여 실제 수익률이 아니며 목표이익률 결정이 자의적이다. 또한, 회계변경에 따른 차이로 객관성이 저하될 수 있다. 의사결정 기준은 독립적인 투자 안의 경우, 이익률이 높은 투자 안을 선택하며 상호 배타적인 투자 안의 경우, 목표이익률보다 높은 투자 안 중 가장 이익률이 높은 투자 안을 선택한다. 예를 들면 다음과 같다. 회계적 이익률법에 따르면 (1) 연평균 장부가액 = 9,000+ 6,000 + 3,000 + 0 = 18,000; 18,000 / 4 = 4,500 (2) 연평균 순이익 = (3,000 + 2,000+1,000) / 3 = 2,000 (1차년도 이익) 12,000 – 6,000 – 3,000 = 3,000 (2차년도 이익) 10,000 – 5,000 – 3,000 = 2,000 (3차년도 이익) 8,000 – 4,000 – 3,000 = 1,000 회계적 이익률 = 연평균 순이익 / 평균 투자액 = 2,000 / 4,500 = 44% [#3. 내부 수익률법(IRR: Internal Rate of Return Method)] 내부수익률법은 투자 안의 내부수익률을 구하여 이를 요구수익률(자본비용)과 비교함으로써 투자의사를 결정하는 방법으로 다음과 같이 계산한다. 산식이 좀 어렵게 보이는데 미래 현금유출의 현가와 미래 현금유입의 현가가 같아지는 이자율을 구하면 그게 IRR이다. 장점은 이해하고 의사소통하기 쉬우며 순 현재가치 법(NPV)과 밀접하게 관련되어 있고 종종 동일한 의사결정이 내려진다. 단점은 자본비용을 구하기 어렵다. 의사결정 기준은 독립적인 투자 안의 경우, IRR >요구 수익률(자본비용, k)인 경우, 상호 배타적인 투자 안의 경우, IRR > k이면서 IRR이 가장 큰 투자 안을 선택한다. 예를 들면 다음과 같다. 투자 안 A, B의 내부수익률을 계산해 보면 (1) 투자 안 A 24,000 = 10,320 / (1+r) + 10,320 / (1+r) 2 + … + 9,120 / (1+r) 5 r = 29.66% (2) 투자 안 B 32,000 = 12,160 / (1+ r) + 12,160 / (1+r) 2 + … + 12,160 / (1+r) 5 r = 26.07% 따라서 의사결정은 내부수익률이 높은 투자 안 A를 채택한다. IRR의 경우, NPV와 더불어 비교적 많이 사용하는 방법이므로 스프레드시트(spreadsheet) 소프트웨어에서 보통 함수를 제공하고 있다. MS EXCEL을 기준으로 하면 IRR 함수를 사용해서 내부수익률 r을 계산할 수 있다. 초기 투자 값(음수)부터 마지막 투자 값까지 나열하고 IRR 함수를 이용해서 선택하면 내부수익률을 계산해 준다. [#4. 순 현재가치 법(NPV: Net Present Value Method)] 순 현재가치 법은 투자로 인한 미래의 현금유입을 적절한 할인율로 할인한 금액에서 미래의 현금 유출을 할인한 금액을 차감하여 구한 NPV를 근거로 투자를 결정하는 방법으로 다음과 같이 계산한다. NPV는 '현금 유입의 현가 - 현금 유출의 현가'를 계산하여 0보다 크면 수익성이 있다고 판단한다. 장점은 화폐의 시간가치를 고려하고 있으며 오직 현금흐름 기대치와 자본비용만이 고려될 뿐 회계적 수치와는 무관하다. 단점은 할인율의 추정이 어려우며 미래 추정에 따라 결과가 자의적일 수 있다. 의사결정 기준은 톡립적인 투자 안의 경우, NPV > 0, 상호배탁적인 투자 안의 경우 NPV > 0이면서 NPV가 가장 큰 투자 안을 채택한다. 예를 들면 다음과 같다. (자본비용은 20%를 가정한다) 투자 안 A, B의 NPV를 계산해 보면 (1) 투자 안 A 10,320 / (1 + 0.2) + 10,320 / (1 + 0.2) 2 + … + 10,320 / (1 + 0.2) 5– 24,000 = 5,108 (2) 투자 안 B 12,160 / (1 + 0.2) + 12,160 / (1 + 0.2) 2 + … + 12,160 / (1 + 0.2) 5– 32,000 = 4,366 따라서 의사결정은 NPV> 0이면서 값이 더 큰 투자 안 A를 채택한다. 앞서 살펴본 IRR처럼 NPV도 MS EXCEL을 이용하여 계산할 수 있다. 초기 투자 안부 터 마지막 투자 값까지 나열한 후 NPV 함수를 이용하여 계산한다. NPV 함수는 NPV(v1, v2:v3)+v4에서 v1은 자본비용 또는 연간할인율이고 v2부터 v3는 투자된 값들, v4는 초기 투자 값이다. 주의할 점은 v4는 실제 마이너스 값이지만 엑셀 산식에서는 값만 더해준다. 사업타당성 분석에서 가장 손쉽게 활용할 수 있는 소프트웨어는 MS EXCEL과 같은 스프레드시트인데 스프레드시트도 잘 모델링 하여 값을 입력하고 보기 좋게 템플릿으로 만들어 놓으면 매우 유용하다. 사실 좋은 컨설팅 펌은 이런 것들을 이미 도구화하여 그들의 귀중한 지적 자산(Knowledge Asset)으로서 활용하고 있다. 여기서 소개한 방법 이외에도 매우 다양하고 전문적인 가치 평가 법들이 존재하지만 사실 크게 쓸 일이 없다. 외국계 기업의 인수합병(M&A)을 다룬다면 DCF(현금흐름 할인법. Discount Cash Flow)는 알아두면 좋다. 개념은 NPV 계산과 같이 순현금 가치, 순현금흐름 특히, 잉여현금흐름(FCF. Free Cash Flow)를 가지고 계산하는 것으로 유사하다 할 수 있다. 정확도로 생각해 보면 단정적인 사실보다는 확률로 표현해야 할 일이 생기기 때문에 몬테카를로 시뮬레이션 기법 같은 것을<NAME>해서 확률분포의 개념을<NAME>하기도 하지만 결과적으로 큰 차이가 나지는 않는다. 보다 전문적인 설명을 할 수 있다는 것을 보이는 정도. 사업타당성 분석에서 유의할 것은 가정에 가정을 두고 말 그대로 타당성을 검토하는 것이기 때문에 숫자에 매몰되면 안 된다. 전체적인 맥락에서 이 사업이 추진 가능한 것인가를 검토해야 하고 사업 관점(business perspective)에서, 재무 관점(financial perspective)에서, 법/제도 관점(legal & regulation perspective)에서 이 사업을 진행할 수 있는가를 적정 판단하면 되는 것이다. 그리고 기업 내부의 정서나 역량 등도 사실 사업타당성에서 중요한 포인트가 될 수 있다. 경영진 입장에서는 돈이 되냐 안되냐가 가장 중요한 포인트가 될 수 있겠지만 재무적 타당성을 평가하는 기법들이 100% 신뢰할 수 있는 값이 아니고 임의의 가정도 많이 들어가기 때문에 종합적인 관점에서 검토하고 옵션이나 대안을 제시하는 것이 좋다. 17. 정보전략 컨설팅 방법론 정보통신기술의 발달은 비즈니스 모델의 급격한 변화와 다양한 업종 간의 컨버전스(convergence)를 유발하였는데 컨설팅도 예외는 아니었다. Figure IV-42는 기업 비전과 정보화 전략의 관계를 표현하고 있는데 기업의 최종 목표인 비전(vision) 달성을 위한 다양한 사업 목표가 있고, 그것에 영향을 주는 핵심 성공요소(CSFs)들이 있다. 핵심 성공요소들은 기업의 기능과 프로세스의 영향을 받고 이것이 기업의 정보시스템(응용과 인프라)에서 기인한다는 의미로, 결론적으로 정보시스템은 기업의 비전과 상호 연관되게 설계되어야 한다는 의미를 담고 있다. 즉, 기업의 비전 달성 또는 목표 달성과 무관한 IT 투자는 진행되어서는 안되다는 이야기이다. 이런 이유로 전통적인 경영혁신 컨설팅인 BPR[1]과 정보전략계획(ISP[2])은 하나의 컨설팅 프로젝트로 합쳐지는 추세이다. 제17장에서는 BPR/ISP에 대해 살펴보자. Figure IV-42. 기업 비전과 정보화 전략의 관계 17.1 BPR의 이해 BPR의 창시자인 마이클 해머(Michael M.Hammer. 1948 ~ 2008)는 BPR에 대해 다음과 같이 말하였다. BPR 이란 비용, 품질, 서비스, 속도 등 주요 성과측정지표 측면에서 획기적인 개선을 이루기 위해 업무처리 절차를 근본적으로 재고찰하고 합리적으로 재설계하는 것이다. 또, 변화관리와 리더십 전문가인 코터(J.P.Kotter. 1947 ~ 현재)는 BPR을 다음과 같이 정의하고 있다. BPR 이란 계속 새롭게 변화하는 시장 환경에 효과적으로 대응하기 위하여 사업 수행 방법을 근본적으로 변화시키는 활동이다. 마이클 해머는 BPR의 핵심에 대해 근본적으로 재고찰, 합리적 재설계를 주창하였고 코터의 경우, 사업 수행 방법의 근본적 변화를 강조하였다. 이런 BPR을 Figure IV-41과 같이 크게 3가지 유형으로 구분할 수 있는데 첫 번째 기능별 개선, 두 번째 업무재설계, 세 번째 업무 재고찰로 구분할 수 있다. 기능 개선은 기존의 업무기능을 개선하여 더 향상되고(Better), 더 빠르고(Faster), 더 지능적으로(Smarter) 만드는 것이다. 이 부분은 IT의 영향을 가장 많이 받는 부분이다. 업무재설계는 기존 부서의 경계를 초월해서 가치 사슬(Value Chain)을 재설계한다고 할 수 있는데 조직 재설계와 맞물려 진행되는 경우가 많다. 또한, 업무 재고찰은 무(無)에서 유(有)를 창조하는 것을 말한다. 어떻게 전개되던 BPR은 변화를 가져오는 것이기 때문에 기존의 저항을 극복하고 변화관리를 잘 해야 한다. Figure IV-43. BPR의 유형 및 범위 17.2 BPR과 ISP의 관계 원래 ISP는 제임스 마틴(James Martin. 1933 ~ 2013)의 정보공학(Information Engineering) 이론 중 계획 수립 부분을 칭하던 용어였다. ISP란, 조직이나 기관의 비전을 달성하기 위해 어떻게 효과적으로 정보기술(IT)을 적용하고 연계할 것인가에 대한 전략과 해결책을 찾고 실행계획을 수립해나가는 일련의 과정이라 말할 수 있다. 기업이나 정부기관들의 비전과 목표가 정보시스템으로 반영되도록 하고 정보시스템은 핵심 기능과 프로세스를 지원하도록 장기적인 계획이 필요하게 된다. 이런 목적에 따라 작업 방법이나 절차, 산출물, 기법 등을 논리적으로 정리해놓은 체계가 필요하게 되며 정보전략계획 방법론은 이러한 필요를 충족하게 된다. 앞서 얘기한 것처럼 모든 ISP 방법론은 제임스 마틴의 정보공학에 그 원류를 두고 있으나 최근 컨설팅 펌들의 ISP 방법론은 Figure IV-44의 점선 상자처럼 BPR 작업을 내포하고 있다. Figure IV-44. 컨설팅 기업들의 ISP 방법론 BPR은 1980년대 경영혁신의 바람과 함께 태동하여 많은 컨설팅업체들이 수행해왔지만 유행처럼 지나가버렸고 BPR 방법론은 제조/생산부분의 PI 영역과 ICT 산업의 ISP 영역으로 스며들어버렸다. 물론, BPR의 유형 II, III과 같은 경우는 별도로 사업이 나오기도 하지만 이 역시 구조조정 컨설팅이 커버하는 경우가 많다. 한편, ISP는 Figure IV-45와 같이 BPR을 수용함으로써 작업의 논리성이나 효과성을 높일 수 있게 되었다. 지금이야 별거 아닌 듯 이야기할 수 있으나 90년대 초반 급속한 IT의 발달과 더불어 기존 컨설팅의 큰 사업 영역이었던 BPR이 ISP로 흡수되어 작업이 진행될 때는 큰 충격이었다. 일거리가 하나 없어지는 것과 같은 효과이기 때문이다. 사실 BPR은 경영 컨설팅 기업들이 구조조정이나 경영혁신 방법론으로 주로 사용하였고, ISP는 프로세스 컨설팅의 범주에서 IT 컨설팅 기업들이 주로 사용하던 방법론이었기 때문이다. Part I에서 이미 언급하였지만 컨설팅 사업 영역의 경계가 무너지면서 발생한 일 중 하나라고 생각할 수 있다. Figure IV-45. BPR과 ISP의 연계 Break #20. 컨설팅 서비스의 분화 Figure IV-46. 컨설팅 서비스 구분 컨설팅 서비스에 대한 구분은 Part I에서 이미 다루었는데 Figure IV-46과 같이 전략(Strategy), 전술(Tactics), 업무(Process), 자원(Resources), 변화(Change)로 나누어 생각해 볼 수도 있다. 이중 강조되는 사안에 대해 컨설팅 속성이 결정되고 컨설팅 기업들은 그것을 오퍼링(Offering)으로 제공하고 있다. 이를 6가지 유형으로 나누어 보면 다음과 같으며 이중 옅은 회색 부분이 ISP에서 다룰 수 있는 부분이다. Strategic Business Planning : 고객이 전반적인 사업전략 수립을 요구함. (예. 디지털 비즈니스 전략) Business Information Planning : 고객이 전략과 목표는 정의하였으나 목표 달성을 위한 과제들이 우선순위나 Value를 어떻게 정리해야 하는지 모름 Business Process Reengineering : 고객이 조직 내 급격한 변화를 실행에 옮길 필요가 있으나 외부에서 비즈니스 프로세스를 재설계하고 구현할 수 있게 도움이 필요한 경우 Business Process Improvement : 고객은 어느 프로세스가 재설계되어야 하는지 명확히 알고 있지만, 외부 전문가가 재설계와 이행에 도움을 주어야 하는 경우 Combined, Company-wide, Integration Planning and Process Reengineering : 고객이 비즈니스 상의 급격한 변화를 필요로 하나 어디에 초점을 맞추어야 하고, 어떻게 가장 큰 효과를 얻을 영역을 파악할지 자신이 없으며, 외부 전문가가 필요한 변화 프로그램을 설계하고 실행해 주기를 원하는 경우 Information Technology Planning : 고객이 정보기술이나 다른 자원들이 어떻게 사용되고 있는지 외부 전문가에게 진단받고자 하는 경우 종종 정보전략과 계획을 함께 필요로 함 17.3 BPR/ISP 테일러링 모든 방법론이 그렇지만 프로젝트 상황에 따라 방법론을 재단하는 테일러링(Tailoring)은 컨설팅 방법론의 유연함과 컨설팅 PM의 유능함을 나타내준다. 17.3에서 소개하는 BPR/ISP 프레임워크는 과거 저자가 경험했던 것을 수정하여 나타내 본 것이다.[3] 첫 번째, Figure IV-47은 정보전략계획의 흐름에 중점을 두고 아이콘과 함께 사용하여 전체적인 프로젝트 흐름을 표현한 것이다. 이슈 분석 150건, 개선 기회 도출 42건, 14대 개선과제 정의 등 도출된 시사점과 성과들을 정량화함으로써 성과를 가시적으로 표현하고자 하였다. Figure IV-47. A 기업 정보화 전략계획 프레임워크 두 번째, Figure IV-48은 B 기업에서 수행했던 BPR/ISP 프레임워크인데 특이한 점은 미래 정보화 모델의 설계 부분에서 EA 관점을 도입했다는 것이다. 일반적으로 ISP에서 미래 모델 설계 관점은 하드웨어, 네트워크, 소프트웨어 또는 인프라 아키텍처, 소프트웨어 아키텍처 등의 구분을 많이 사용하였으나 2000년대 중반 이후 2010년 초반까지는 그 부분을 업무(Business Architecture: BA), 응용 소프트웨어 아키텍처(Application Architecture: AA), 데이터 아키텍처(Data Architecture: DA), 기술 아키텍처(Technical Architecture: TA)의 4가지로 구분하여 각 수준별로 상세하게 관리하고자 하였다. 그러나 현실적으로 그 사상대로 시스템을 구현하고 관리하는 일이 노력(Efforts) 대비 큰 성과를 거두지 못하였고 번거로워 지금은 거의 사용하지 않는다. Figure IV-48은 기술 아키텍처 중 보안 부분이 중요하게 부각되어 그 부분을 구분한 것이다. 전반적인 흐름은 환경분석, 업무 및 기술 현황 분석, 개선방향 도출, 업무 및 시스템 비전 설정, 각 영역별 상세 과제 개발, 과제 실행계획 수립으로 BPR/ISP의 체계를 준수하고 있다. 또, 한 가지 특이한 점은 변화관리 방안에 대한 영역이 있는데 변화관리 컨설팅의 주제가 있을 정도로 중요한 부분이지만 여기서는 전체 과제 수행의 유연성을 위해 실제 실행하면서 누가 어떻게 조율하겠다는 내용이 포함되어 있다. Figure IV-48. B 기업 BPR/ISP 프레임워크 세 번째, Figure IV-49은 C 정부기관에서 수행했던 BPR/ISP 프레임워크인데 특이한 점은 IT 거버넌스(IT Governance)와 예비타당성 조사가 같이 병행되었다. 고객은 차세대 시스템을 기획하면서 IT 자원과 정보, 조직을 기관의 목표와 연계하여 보다 명확하게 관리하기 위해 도입을 고려하였고 BPR/ISP에서 그것을 같이 고려하게 되었다. 또한, 전국 단위의 시스템을 구축하기 위해서는 대규모 투자가 발생하는 점을 고려하여 시스템 구축의 ROI가 의미 있는지 같이 점검해 보기로 하였으며 그 과정으로 국가 재정 금액이 많아서 예비타당성 조사도 수행하였다. Figure IV-49을 보면 그런 측면에서 IT 거버넌스를 수행하기 위해 IT 프로세스 및 정보화 조직에 대한 현황 분석을 심도 있게 수행하였으며 BPR/ISP에서 도출되는 결과보다 상세한 수준으로 미래 모델에 반영하게 되었다. 또한, 정보시스템 구축을 위한 예산 수립과 더불이 ROI 분석이 병행 수행되었다. Figure IV-49. C 정부기관 BPR/ISP 프레임워크 세 개의 BPR/ISP 프레임워크 모두가 하나의 방법론을 테일러링 한 것이다. 방법론을 처음 접하거나 잘 모르는 사람들은 유연한 방법론을 보고 너무 간단해서 이게 가이드가 될 것인가 의심을 하는 경우도 되지만 실제로 프로젝트를 수행해 보면 그 강력한 효과를 체험할 수 있다. 저자도 저명한 외국계 컨설팅 기업의 방법론을 포함하여 몇 가지를 사용해 보고 벤치마킹해보았는데 저자가 컨설팅 할 때 사용했던 것이 가장 유연하고 사용하기 좋았다. 지금까지 Part II에서 논리적 사고체계와 문제 해결기법, 커뮤니케이션 스킬 등 컨설팅 스킬에 대해 살펴보았고, Part III에서 컨설팅 이행에 필요한 다양한 컨설팅 도구와 기법에 대해 알아보았으며, Part IV에서는 컨설팅 스킬 및 도구와 기법이 아우러진 컨설팅 방법론에 대해 알아보았다. 이것들을 기반으로 Part V에서는 컨설팅 사업은 어떻게 개발하는지 그리고 컨설팅 이행에 대해 살펴보도록 하자. [1] Business Process Reengineering. 기업의 업무 프로세스를 자동화 도구를 사용하여 개선/혁신하는 것 [2] Information Strategy Planning. 정보전략계획 [3] 컨설팅 산출물은 대부분 대외비이므로 외부 공개 때에서는 그런 부분이 문제가 되지 않도록 해야 한다. 본서에서 소개되는 몇 가지 슬라이드도 그런 부분을 충분히 고려하여 생략하고 수정한 것이다 170 PART V. 컨설팅 사업 개발 및 이행 Part II에서 컨설팅 글쓰기에 대한 기본적인 사항들에 대해 알아보았고, Part III에서 다양한 컨설팅 기법들에 대해서도 알아보았다. Part IV에서는 가장 많이 활용되는 컨설팅 방법론에 대해서도 알아보았다. 이 모든 것이 사실 Part V에서 다룰 컨설팅 사업개발 및 이행을 위한 것이다. 컨설팅도 비즈니스이기 때문에 영업도 필요하고 다른 사업처럼 사업 발굴 과정에서 고민해야 할 것들이 많다. 컨설팅 사업은 B2B 사업에 속하는데 B2B 사업의 영업 방식[1] 중 밸류 세일즈(Value Sales)를 해야 한다. 밸류 세일즈는 고객의 이슈나 문제 해결이 중요하며 그것들을 해결하기 위해 사업자는 고객에게 어떤 가치(Value)를 제공할 수 있을 것인지가 영업 성공의 관건이 된다. 그래서 고객의 이슈나 문제 해결을 위한 고유의 해결 방안 또는 방법론이 필요하며 이것을 설루션(Solution)과 연계하여 제공한다. 최근에는 IT의 발달로 인해 거의 모든 B2B 기업들은 그들의 제품이나 서비스를 설루션 사업으로 변화시키고 있다. 따라서 B2B 영업이라 함은 거의 설루션 영업이며, 컨설팅 영업도 당연히 이런 범주 또는 관점에서 고려해야 할 것들이 증가하고 있다. Part V에서는 B2B 사업으로서 컨설팅 사업개발과 그 개발 방법론에 대해 살펴보도록 하자. [1] B2B 영업은 영업 방식(Sales Motion)에 따라 Volume Sales와 Value Sales로 구분할 수 있다. Volume Sales는 채널을 활용해서 대단위의 원자재나 부품을 유통하는 형태가 많으며, Value Sales는 설루션 사업의 형태를 띠고 있다. 18. 컨설팅 사업개발 개요 B2B 사업은 리드[1]의 생성과 관리로부터 시작된다고 할 수 있다. ‘리드(lead)’라는 단어는 한글로 그 뉘앙스를 표현하기 좀 어려운데 ‘기업의 제품을 구매하고자 하는 니즈, 의도, 예산을 가진 개인이나 조직의 신상 정보’ 정도로 번역될 수 있다. 즉, 거칠게 이야기하면 리드는 ‘연락처(Contact)’이다. 컨설팅도 B2B 사업이므로 마케팅 리드(MQLs) [2]나 세일즈 리드(SQLs) [3]를 관리하여 궁극적으로 파이프라인 즉, 사업기회관리(Tier Management: TM)를 하는 것이 대단히 중요하다. 컨설팅 사업은 다른 B2B 사업에 비해 규모가 크지 않기 때문에 큰 것 한 건(Big Deal)보다는 작은 다양한 사업 기회를 가지고 있는 것이 사업의 지속성이나 연속성 관점에서 좋다. Figure V-1은 흔히 말하는 ‘세일즈 깔때기’인데 다양한 사업 리드들이 정보가 보완되면서 영업 기회로 전환되고 수주되는 것을 표현하고 있다. 보통 하나의 사업을 수주하기 위해서는 4~5배수 기회를 가지는 것이 좋다. 이 장에서는 컨설팅 사업개발에 대해 살펴보도록 하자. Figure V-1. 세일즈 깔때기(Sales Funnel) 18.1 컨설팅 사업 리드 관리 컨설팅 기업이 시장이나 고객들에게 알려지게 되는 것은 그들의 생각(Thoughts) 이 시장을 선도하고, 그것이 클라이언트의 사업에 도움이 된다고 느낄 때이다. 즉, 컨설팅 기업 입장에서는 그들의 생각을 시장과 고객에게 효과적으로 알리는 최고의 마케팅 방안을 찾아야 한다. Table V-1은 온라인 또는 오프라인 채널을 이용하여 컨설팅 기업들이 펼치는 마케팅 활동, 나아가서는 브랜딩 활동을 정리해 본 것이다. Table V-1. 컨설팅 기업의 브랜드 제고를 위한 마케팅 활동 이는 설루션 사업을 지향하는 다른 B2B 기업들과 별반 다를 것이 없다. 설루션 기업들은 그들의 제품을 사전에 일부 사용해 본다든지 하는 행위가 추가될 뿐이다. 브랜드 인지도(Brand Recognition) 측면에서 효과적인 마케팅 방안을 찾아야 한다. 컨설팅 사업의 주가가 한창 좋던 시절에는 이런 브랜딩 활동이 없이도 고객이 직접 연락해온 적도 많아서, 다른 B2B 사업의 영업대표들이 고객들을 찾아가는 영업을 하던 것과 비교하여 컨설팅 영업은 상위 수준의 고급 영업이라 평하기도 하였다. 그러나 경제 불황인 요즘은 이미 구조화된 컨설팅 시장에 새롭게 진입하는 것 자체가 쉽지 않고, 중소 규모의 컨설팅 기업들이 이합집산하여 신규 기업을 만들어도 실적(references)을 꼼꼼히 챙겨 보는 고객들도 많아져서 이름을 알리는 일이 결코 쉽지 않다. 어쨌든 마케팅 리드(MQLs)를 확보하고, 세일즈 리드(SQLs)로 전환하여 제안 및 입찰을 진행하는 것은 다른 B2B 사업의 영업활동과 동일하다고 할 수 있다. 컨설턴트도 영업해야 할지 몰랐습니다. 과거에 입사한지 얼마 되지 않은 선임 컨설턴트가 내게 했던 이야기이다. 시니어 컨설턴트들(Senior Consultants)이나 파트너들(Partners)은 하는 일의 70% 이상이 소위 말하는 ‘영업’이다. 저자가 경험한 컨설팅 사업은 독립 컨설팅 기업이 아니라 IT 서비스 기업의 컨설팅 부문에 속해 있었기 때문에 상대적으로 독립 컨설팅 기업의 컨설턴트들이 느끼는 사업 수주에 대한 압박감은 상대적으로 덜했지만[4] 컨설턴트를 알리고 컨설팅 오퍼링을 소개하는 일은 동일하였다. ‘훌륭한 영업대표(Sales Rep.)는 특별한 도구가 필요 없다’는 말은 거짓이다. 훌륭한 영업대표가 되면서 이미 자신도 모르는 사이에 수많은 도구(Tools)의 도움을 받고 그 자신이 그것을 활용하고 있다. 아래 내용은 B2B 마케팅이나 B2B 영업을 위한 몇 가지 도구를 소개한다. ‘에이 이게 무슨 도구야?’라고 폄하해버릴지도 모르지만 컨설턴트는 경우에 따라 마케팅과 영업을 구분하지 않고 본인이 그것을 모두 해야 하는 경우가 많기 때문에 ‘모두 내가 챙긴다’는 생각으로 살펴보면 될 것이다. [B2B 마케팅 도구] (1) 웹 페이지 인터넷 시대에 웹페이지는 필수이다. 기업 홈페이지는 컨설팅 기업을 소개하는 정보를 비롯하여 실적, 산업 정보들을 같이 기재함으로써 리드를 수집하는 좋은 도구가 된다. 콘텐츠가 많다면 특정 주제를 상세히 풀 수 있는 마이크로사이트(mircosite)를 구축하는 것도 좋은 방법이다. (2) 화이트 페이퍼(White papers) 발간 컨설턴트들이 실수하는 것 중 하나가 ‘고객이 자기보다 하수’라고 생각하는 것이다. 그러나 실제로 많은 고객들을 만나보면 대부분은 해당 산업이나 업무의 전문가들이다. 다만 그들은 그들 머리 속이나 현장에 펼쳐진 지식과 경험들을 정리하는 것에서 많은 어려움을 느끼는 경우가 많다. 따라서 그들이 속한 산업 동향 소식이나 트렌드에 대한 소개와 함께 그들이 보유한 지식과 경험을 정리할 수 있는 가이드를 화이트 페이퍼 (white paper)를 통해 제공해 준다면 사업 수주의 80% 이상을 한 것과 같다. 다음과 같은 제목을 단 화이트 페이퍼들은 고객의 눈길을 끌게 되어 있다. 예를 들어 ‘~를 하는 방법’, ‘왜 ~를 하는가?’, ‘XX의 실수를 피하는 3가지 요인’ 등 전략적인 제목을 가진 화이트 페이퍼를 발간해 보자. 물론, 양질의 콘텐츠는 기본이다. (3) 블로그(Blog) 운영 블로그는 특정 주제에 대한 의견을 웹(web) 상에서 개진함으로써 고객과 쌍방향 커뮤니케이션을 만들어 낼 수 있는 좋은 도구이다. 때때로 블로그를 통해 마케팅 리드(MQLs)를 발굴할 수도 있으며, 바로 영업 단계 로 전환될 수도 있다. 또, 블로그와 연계된 링크(Link)를 잘 활용하여 고객이 원하는 다른 정보를 소개하는 웹 페이지나 전자상거래 플랫폼에 좀 더 관심과 기대를 가질 수 있도록 구성할 수도 있다. 그러나 무엇보다도 블로그 자체의 콘텐츠가 가장 중요하다. 다른 소셜미디어(social media) 플랫폼으로 전문가 그룹을 위한 링크드 인[5]이나 페이스북[6]도 매우 유명한데 짧은 글을 빨리 배포하는 용도와 비교적 장문의 콘텐츠를 공유하는 것으로 활용 용도를 다르게 가져가는 것이 좋다. (4) 인포그래픽스(Infographics) 다양한 정량적 정보를 그래픽 처리한 것이다. 잘 만들어진 인포그래픽스는 그 활용도가 매우 높으며 쉽게 인용할 수 있다. 매우 직관적이므로 제품의 특성이나 기업의 특징을 설명하기 유용하며 웹페이지나 프레젠테이션 자료에서 재사용할 수도 있다. 컨설팅 영역에서는 산업 동향 소개에 많이 사용한다. (5) 프레젠테이션 자료 기업의 제품이나 서비스를 설명하는 잘 만들어진 프레젠테이션 자료는 마케팅 활동에 반드시 필요하다. 배포할 수 있는 브로슈어(Brochure)나 리플릿(Leaflet) 같은 것도 같은 용도로 활용할 수 있다. (6) 명함 영업대표만 명함이 있는 것이 아니다. 모든 명함이 그렇지만 가능하면 차별화되게 디자인하여 다시 한번 손이 가게 하는 것이 좋은데 기업 CI[7]의 영향도 있고 명함 디자인 그 자체의 효과는 컨설팅 산업에서는 좀 덜한 것 같다. 다만, 컨설턴트의 명함은 충분히 전략적으로 활용될 수 있다. 아무래도 컨설턴트라고 하면 다시 한번 보게 된다. 위의 것들이 마케팅 관점에서 활용할 수 있는 도구들이라면 이제부터 소개할 것들은 영업 차원에서 활용할 수 있는 것들이다. [B2B 영업 도구] (1) 기업 소개 메일 처음 고객과 접촉하게 될 때 약간 상투적인 문구와 함께 보내지는 기업 소개 메일은 고객들로 하여금 준비된 자세 또는 전문가적 모습을 기대하게 만든다. 물론, 직접 만나서 그 기대가 깨지는 최악의 경우도 있겠지만 만나기 며칠 전부터 만남의 목적이나 기대, 제공하는 가치에 대해 조금씩 전해주는 것은 전통적인 방법이다. (2) 뉴스레터 신규 고객이든 기존 고객이든 지속적인 만남과 접촉이 중요하다. 뉴스레터는 자칫 스팸 메일처럼 처리될 수도 있으나 기업의 상황을 알리는 가장 쉬운 방법으로 꾸준히 보내는 것이 좋다. 고객의 이메일을 통해 뉴스 레터를 보낸다는 것은 적어도 마케팅 리드는 확보한 상황이라 할 수 있기 때문에 이를 통해 연락해오는 고객은 세일즈 리드를 가지고 있다고 보아도 무방하다. (3) 프레젠테이션 마케팅 도구로서 단순히 공유되는 프레젠테이션 자료가 실제 컨설턴트(이때 컨설턴트는 영업대표와 같다고 볼 수 있다)를 통해 실제 발표되면서 그 빛을 발한다. ‘보는 것이 믿는 것이다(Seeing is believing)’라는 말처럼 실제 내용을 들어보면서 더 많이 이해되는 것은 당연한 일이다. 영업대표라면 본인이 기업과 본인이 판매하는 제품에 대한 정보는 확실하게 알고 있어야 하는데, 컨설턴트의 경우, 시니어 컨설턴트 이상이 되면 본인이 마케터와 영업대표의 역할을 동시에 해야 하기 때문에 프레젠테이션 역량은 문서화 역량과 더불어 매우 중요하다. (4) 제품 시연(Demonstration) 요즘은 제품 시연과 프레젠테이션이 병행하여 진행되는 경우도 많다. 말이 무슨 필요가 있는가? 실제로 보여 준다. 또는 시뮬레이션(Simulation) 하여 고객이 상상한 것을 실현해 준다. 제품 시연을 통한 영업 방법은 저자의 경험에 의하면 가장 효과가 크다. IT 설루션 컨설턴트들의 경우, 제품 시연은 매우 중요하다. 설루션을 팔면서 기능 설명부터 적용 사례 등 전반적인 사업전략을 설명할 수 있어야 하기 때문이다. (5) 구매자 정보 ‘Persona Guide’라고 불리기도 하는데 구매 의사결정에서 핵심 구매자의 성향을 파악하기 위해 반드시 수집되어야 하는 정보들이다. 어떤 관점에서 제품을 강조하며, 어떤 부분을 면밀히 보려 하는가 등 구매 포인트가 표출되는 경우가 많다. 또한, Powerbase를 파악하기 위해서라도 이는 반드시 확보해야 하며 궁극적으로 Power map 작성이 도움을 줄 수 있다. 컨설턴트들은 대부분의 경우, 최고경영자를 포함하여 임원들과 많은 시간을 가지게 되는데 그들과 이야기하면서 기업의 구매가 어떻게 발생하는지 어떤 부분이 아쉬운지, 어떤 것들을 도와줄 수 있는지 파악하는 것이 중요하다. (6) 경쟁사 정보 많이 알면 알수록 좋다. 영업 활동에 방해가 되는 경쟁사를 합법적인 범위 내에서 어떻게 제거할 것인가 하는 문제는 기업들의 간의 경쟁에서 영업이 고민해야 할 최고의<NAME> 중 하나이다. 경쟁사 프로파일링을 통해 체계적으로 파악해야 한다. (7) 고객 평판 B2B 사업에서 고객은 기업이므로 상호 윈윈(Win-Win) 하는 파트너십을 구축하고자 하는 고객이 가장 이상적이라 할 수 있다. 그런 대우를 받기 위한 기술이나 역량의 축적도 중요하겠지만, 컨설팅 기업이 제공 하는 가치를 인정하면서 그런 대우를 해줄 수 있는 고객인지도 중요하다. 성공 스토리를 만들기 위해서는 고객 평판도 점검해야 하며 성공적인 제품 공급과 관계 형성을 통해 만들어진 고객 평판은 최고의 영업 도구가 된다. 기업 고객이 나서서 우리 제품과 서비스를 스스로 알려주니 이보다 좋은 일이 없지 않은가? (8) 질의응답 사전 영어로는 ‘Conversation Guide’라고 한다. 산업에 따라서 다르지만 고객의 니즈를 파악할 때 문의하는 질문들은 매우 정형적이다. 영업 활동이 체계적으로 지식DB화되어 있다면 유형별로 이런 질문들과 응답, 대응 상황 등이 정리되어 있고 교육 교재로도 존재할 수 있다. 노련한 시니어 컨설턴트라면 아마 직접 작성해서 후배들에게 배포할 것이다 (9) 전문가 네트워크 오늘날 B2B 영업대표는 산업 현장의 슈퍼맨이 되기를 요구받고 있다. 그러나 현실적으로 모든 것을 다 대응하고 처리하기는 불가능하며 적재적소에 그 일을 대신해 줄 또는 지원해 줄 사람들을 알고 있어야 한다. 특히, 전문 분야의 의견을 청취해서 고객에게 전해줄 수 있다면 고객에게 훨씬 신뢰를 줄 수 있을 것이다. 컨설턴트도 마찬가지이다. 사내의 지식 전문가(Knowledge Expert) 그룹을 활용하여 빨리 이슈나 문제에 대응할 수 있어야 한다. (10) ROI 계산기 엑셀을 사용하던 정보시스템을 활용하던 사업에 들어가는 원가와 이익을 항상 생각해야 하는 입장에서 ROI는 매우 중요하다. 컨설팅의 대부분 원가는 인건비이겠지만 최근 설루션을 서비스를 제공하는 또는 라이선싱을 고민하는 기업의 경우, 원가 요소와 그에 맞는 가격 전략을 수립하여 최고의 ROI를 달성하는 비즈니스라는 측면에서 가장 중요하다 Break #20. 영업기회관리(Tier Management: TM) TM은 B2B 기업에서 세일즈 리드(SQL)를 효과적으로 관리하기 위해 인적(Sales Resources), 물적(Budget), 시간(Time) 자원을 적절하게 배분하여 최상의 영업 성과를 얻고자 하는 방법이다. 그러나 보다 중요한 것은 TM을 통해서 ‘추구하는 비즈니스의 성격을 정확하게 규정하고 나아가는 것’이다. 타 B2B 사업과 달리 컨설팅 사업은 사업 규모가 크지 않아 TM 같은 것을 하지 않고 주먹구구식으로 영업기회 리스트를 관리하는 회사들도 많다. 그러나 사업은 생명체와 같아서 지속적으로 변하기 때문에 사업 수주 이전까지 지속적으로 관리해야 한다. 이를 위해 TM은 비즈니스 생명주기를 명확하게 인지하고 적절한 비용과 자원을 적시에 투입하여 최상의 사업 성과를 얻는 안목을 키우는 도구로 활용할 수 있다. 그러나 TM은 추상적 개념이므로 실제 업무 현장에서 이것을 어떻게 사용할 것인지에 대해서는 잘 알려져 있지 않으며 논리와 프레임워크를 좋아하는 컨설팅 기업들마다 고유의 영업기회 관리 방법이 있다. 특별한 아이디어가 없다면 다음과 같이 해보자. (1) 사업기회들을 Tier 4에서 Tier 1까지 4가지로 분류하여 순위(Ranking)을 매긴다. 현재 Tier 4 영역에 있는 사업 기회들은 영업 정보가 보완되면 미래에 Tier 1 영역으로 이동해 갈 것이다. (2) 각 Tier에 배치된 사업 기회들을 영업 단계와 매핑 시킨다. 영업 단계는 각 산업 또는 각 기업마다 고유의 기준이 있겠지만 일반적으로 초기 접촉, 사업기회 개발, 사업기회 평가, 제안 및 계약, 종료 및 결과 리뷰의 5단계로 나눌 수 있다. (3) 정치적, 사회적, 문화적 요소 등 시장 상황을 정확히 파악하여 정보를 충실히 보완하고 사업 프로파일과 순위를 업데이트한다. (4) 시장 환경의 타임라인을 단기(2~4개월), 중기(5~12개월), 장기(12~24개월)로 구분하여 생각해 본다. (5) 주어진 자원-인적/물적/시간을 적절하게 배분한다. (1) ~ (5)를 종합하여 영업 단계와 연계시키면 Table V-1과 같다. 최초의 고객 접촉부터 최종 사업 수주까지 보통 Tier 4 ~ Tier 1로 나누어 관리하지만, Tier 0도 매우 중요하다. Tier 0의 경우, 성공적으로 사업을 수주하여 계약으로 이어지는 경우도 있지만, 실 주하였을 경우 ‘실주의 원인이 무엇인지?’, ‘앞으로 어떻게 할 것인지?’ 등 영업 활동의 처음부터 마지막까지 상황을 관계자들과 함께 상호 검토해 보는 일 즉, ‘포스트모템(Postmortem)’을 진행하고 전 입찰 과정 및 결과의 교훈(lesson learned)을 정리해야 한다. Table V-2. TM의 단계 및 주요 내용 [1] 일반적으로 Warm, Hot, Cold의 3가지 리드로 구분하며, 보통 이메일 주소나 URL 정도의 마케팅 리드가 담당자 전화번호를 추가하고 업데이트되면 세일즈 리드로 전환된다. [2] Marketing Qualified Leads [3] Sales Qualified Leads [4] 대체적으로 IT 서비스 기업에는 해당 사업 도메인을 책임지고 있는 영업이 있어서 컨설팅까지 같이 영업하는 경우가 많고, 컨설턴트들은 영업 지원의 역할을 한다. 물론, 강한 오너십(ownership)을 가진 시니어 컨설턴트들은 직접 영업하고 사업개발을 하는 경우도 많다. [5] www.linkedin.com [6] www.facebook.com [7] Corporate Identity 18.2 입찰과 계약 세일즈 리드를 확보하면 본격적으로 제안과 입찰을 하게 된다. B2B 사업은 일반 대중이 소비자인 B2C 사업과 달리 기업이나 정부가 서비스를 구매하기 때문에 거의 대부분 경쟁 입찰을 하게 된다. 그래서 B2B 사업에서는 고객의 구매 프로세스를 이해하는 것이 매우 중요하다. 글로벌 리서치 회사 CEB[1]가 직원 5,000명 이상의 B2B 기업의 구매담당자를 대상으로 조사한 결과에 의하면 한 건의 구매계약 체결까지 평균 5.4명의 공식적인 승인이 필요하다고 한다. ‘통합구매센터’같은 조직이 있는 기업들은 납품받는 제품들에 대해 고유의 검토 절차가 있으며 때때로 단순히 견적을 요구하는 것이 아니라 입찰을 진행하는 경우도 많다. Figure V-2. B2C 사업과 B2B 사업의 구매 프로세스 Figure V-2는 B2B/B2C 구매 프로세스를 비교해 본 것인데 B2C 구매는 다양한 마케팅 요인과 환경적 요인에 영향받으며 전적으로 개인의 판단에 의해 이루어지는 반면, B2B 구매의 경우 자사 제품을 고객에게 노출하는 것부터 시작해서 그 절차도 복잡하지만 고객 관계를 장기적이며 지속적인 관계로 만들어가는 것이 중요하며 구매 후 성과평가 시점에서 고객의 목소리(Voice of Customer:VoC)를 청취하는 것은 매우 중요하다. 이는 VoC를 통해서 제품의 개선 및 차별화 요인들을 파악할 수 있고, 고객의 Pain points 또는 Unmet Needs를 발견할 수 있기 때문이다. 이 부분은 제품이나 서비스의 재구매와 직결된다. 컨설팅 사업도 컨설팅 결과가 어떤가에 따라 컨설팅 기업의 평판(reputation)이 결정되는 것이다. 고객 요구사항을 충족시킨 후, 고객의 Pain points를 터치하거나 Unmet Needs를 해소시킬 수 있다면, 그 고객은 거의 핵심 고객으로 전환된다. 타 B2B 기업과 달리 컨설팅 기업은 사람이 중요한 자산(assets)이므로 그들의 역량을 표현하는 방법은 결국 성공적인 결과와 실적으로 만들어진 브랜드(Brand), 그리고 좋은 인재밖에는 없다. 이 부분에서 국내 IT 컨설팅 시장을 살펴보면 IT 서비스 기업의 한 부서이거나 IT 서비스 기업을 모회사로 둔 컨설팅 기업의 경우, 이런 부분에서 상대적으로 노력(efforts)을 덜 수 있었다. 왜냐하면 IT 서비스 조직의 영업대표가 컨설팅 사업의 영업도 맡았기 때문이다.[2] 그런 조직에 속한 컨설턴트들은 사업의 수주보다는 수주된 컨설팅 프로젝트만 잘 수행하면 되었다. 그러나 외국계 컨설팅 기업이나 이런 영업 활동이 필요한 컨설팅 기업의 경우, 지속적인 수주잔고 확대는 중요한 성과 지표 중의 하나였기에 낮에는 기존에 수주한 컨설팅 프로젝트를 수행하면서 밤에는 타 사업의 수주를 위해 제안서를 쓰는 일도 비일비재하였다.[3] 그래서 많은 컨설팅 기업들은 그런 제안에 드는 노력을 감소시키고자 C-레벨 영업[4]을 선호하였고, 마케팅 활동을 통해 기업의 주요 경영자들에게 접근하고자 노력하였다. 사업이 발주되면 제안요청서(Rfp)에 따라 제안서를 작성하여 제출하고 입찰 결과 우선협상 대상자(Preferred Bidder)로 선정되면 사업의 범위 및 가격 등에 대해 협상하게 된다. 첫 번째 협상 항목인 사업의 범위는 제안요청서의 내용을 기본으로 하지만 계약 시점에 다시 한번 확인하게 된다. 기간 내 제안 내용대로 컨설팅을 진행할 수 있는지 등을 다시 한번 고객과 확약하고 경우에 따라 범위를 조정하였다. 두 번째 협상 항목인 가격은 범위에 의존적이며 컨설팅 기업의 노하우가 담기게 된다. 컨설팅 비용의 대부분은 컨설턴트들의 몸값 즉, 인건비이기 때문에 컨설팅 기업 입장에서는 이를 어떻게 지켜내느냐가 그들 수익과 직결되었다. 일반적으로 B2B 사업은 다음과 같은 3가지 종류의 가격이 존재한다. 원가에 의한 가격 경쟁입찰에 의한 가격 공시가에 의한 가격 원가에 의한 가격 결정은 원자재, 인건비, 간접비 등 비용 요소를 중시하는 제조기업들의 가격 결정 방법으로 판매자는 생산과 판매비용에 합당한 이익을 얻고 투자에 대한 위험을 최소화하는 차원에서 가격을 결정하고, 구매자는 판매자가 생산 학습효과에 의해 비용 절감이 가능할 것이라는 추정하에 산정되는 이익을 반영한 가격을 기대한다. 경쟁입찰에 의한 가격 결정은 가격이 시장에 의해 결정되는 것이 아니라 구매자와 판매자가 서로 협상하여 결정하고자 할 때 사용한다. 우선협상 대상자로 선정된 기업과 가격을 최종 협상하고 계약을 맺는다. 마지막으로 공시가에 의한 결정은 B2G 사업에서 많이 사용되는데 시장가격을 참고하여 구매가격을 결정한 다음 정부조달기관을 통해 공시한다. 입찰을 통해 공시가에 가장 많이 근접한 기업을 선정한 후 제품을 구매한다. 그러나 구분은 위와 같이 하였지만 실제로는 보다 다양한 상황이 생기기도 한다. Figure V-3. 가격 전략 매트릭스 Figure V-3의 가격 전략 매트릭스는 사업개발 관점에서 고심해 볼 필요가 있는데 높은 브랜딩 파워와 시장 지배적인 서비스를 보유하고 있을 때 ‘프리미엄 가격(Premium Price)’을 구사할 수 있다. 또, 이렇게 확보된 이익을 활용해 경쟁사가 시장에 진입할 때 침투가격 (Penetration Price)을 취함으로써 경쟁 컨설팅 기업이 시장에 안착하지 못하게 하는 진입 장벽(Entry Barrier)을 구축하기도 한다. 그러나 민간기업을 대상으로 하는 컨설팅 사업에서는 의도적으로 프리미엄 가격이나 스키밍 가격(Skimming Price)을 구사하는 경우가 많다. 컨설팅 서비스의 가치를 인정받고 강력한 고객 리더십이 확보된 경우는 당연히 프리미엄 가격이 적용될 수 있다. 또, 시장 진입자의 경우도 스키밍 가격을 고려하지 침투 가격이나 이코노미 가격을 고려하지는 않는데, 이는 경제 불황에도 산업 가치 자체를 고려하여 서비스 가치를 지켜내려는 의도가 담겨 있다. 그러나 기업의 생존을 고려했을 때 모든 컨설팅 기업이 이런 정책을 지속적으로 유지할 수 있을지 지켜볼 일이다. 또한, 국내 공공 IT 컨설팅의 경우는 컨설팅 사업 대가를 공시하기 때문에 이를 기준으로 사업 범위와 업무 난이도를 확정하면 사업비용이 자동적으로 확정되게 된다. 또한, IT 설루션 기업의 경우, 컨설팅 수수료를 받지 않는 기업들도 있는데 설루션 가격(solution pricing) 정책을 구사하면서 컨설팅 비용을 설루션 가격 내 비용 요소로 포함시킨 경우가 많기 때문이다. 이는 연구개발비의 회수를 감안해서 매우 성공적인 시장 진출 성과가 있거나 그 부분을 투자로 볼 때 가능한 가격 전략이다. 사업 범위와 가격을 고객과 최종 합의하면 계약을 맺게 된다. 다양한 계약 조건이 있을 수 있지만 컨설팅 사업 관점에서는 비밀유지 계약(NDA)[6]이나 보안서약서가 가장 중요하다. 컨설팅을 하게 되면 기업의 기밀 사항을 많이 다루기 때문에 그런 내용들이 기업 외부로 유출되어 기업에 손해를 끼치지 않게 하기 위함이다. 1.3 컨설팅 사업비의 산정 컨설팅 사업비를 산정하는 방법은 지금까지 업계 표준이라고 할만한 것은 없다. 한때 경영 컨설팅의 경우, 부르는 것이 값이었고 공공 IT 컨설팅의 경우, 정부에서 컨설팅 사업 대가 방식을 제공하고 그것을 적용하는데 이는 민간기업 사업 대가 대비 매우 박하다. 그래도 일반적인 관점에서 계약 방식을 생각해 보자면 첫 번째 뽑는 것은 T&M[6] 방식 계약이다. 단어 뜻 그대로 시간당 투입 비용을 청구하는 것이다. T&M 계약은 고정 계약 요소와 원가정산 계약 요소를 모두 가지고 있는데 프로젝트 기간이 길어지면 주(week)나 월(month)로 산정하고 사무실 비용 등 간접비와 이익 등을 합하여 컨설팅 대가를 청구한다. 또 다른 대표적인 계약 방식은 고정계약(FP[7]) 방식을 이용하는 것이다. 총액 계약(Lump Sum)이라고도 불리는데 모든 작업들에 대해 계약 금액을 확정하는 것이다. 이 경우는 서비스 공급자는 계약서 내 작업지시서(Contract SOW[8])가 관심사였다. 서비스 공급자가 ‘무슨 일을 어떻게 해야 하는가?’하는 것에 대해 고객과 명확한 합의를 해야 한다.[9] 국내 공공 IT 컨설팅의 사업 대가 산정 방식은 이를 응용했다고 볼 수 있다. 과업에 대한 컨설팅<NAME> 산정과 업무 난이도 값을 어떻게 조정해도 총 대가의 상한 값을 초과할 수 없게 만들어 놓았다. 마지막으로 원가정산(CR[9])방식 계약도 많이 쓰인다. 이 경우 업무 범위를 잘 알기 어려울 경우에 많이 체결하는 계약 방식인데 어떻게 보면 구매자의 리스크가 가장 큰 계약 방식이다. 일이 언제 어떻게 끝날지 모르기 때문이다. 해외 사업 추진 시 현지 업무 지원을 위해 컨설턴트를 고용하기도 하는데 이때 체결하는 계약은 대부분 CR 계약이다. CR 계약의 경우 사후 정산 시, 예기치 못한 문제가 발생할 수도 있다. 해당국의 노동법이나 국제 관행 같은 것들이 문제가 되는데 계약 해지 3개월 전의 사전 통보라든가 연금(pension) 같은 것을 고려해야 한다던가 하는 문제들도 발생하므로 해당 지식이 없다면 현지의 신뢰할 수 있는 로펌(law firm)이나 법률사무소의 도움을 받는 것이 좋다. 국내 IT 컨설팅 부분을 좀 더 살펴보면 공공분야 가이드가 매년 갱신되고 있다. 물가지수 등을 지속적으로 반영하지만 Top 3 전략 컨설팅사에게 지불하는 비용에는 항상 미치지 못한다. 2016년 12월 국내 공공 IT 서비스 사업을 위해 발표된 소프트웨어 사업 대가 산정 가이드에 따르면 사업 대가 산정의 핵심은 여전히 컨설팅<NAME>와 투입 공수(MM: Man/Months) 산정에 의존한다.(Table V-3 참고) 컨설팅<NAME>는 업무별 가중치와 업무별 난이도의 곱으로 계산되는데 재정 사업의 특수성을 감안하여 사업 대가의 상한이 정해져 있다. Table V-3. 소프트웨어 사업 대가 산정 - 컨설팅 사례 Break #21. 컨설턴트로서 나의 몸값은 얼마인가? 경제환경과 사회가 변하면서 평생직장의 개념은 사라지고 자기가 배우고 익힌 전문적인 경험을 자문하면서 돈을 버는 사람들이 많아지고 있다. 컨설턴트(Consultant) 또는 자문(Advisor) 들이다. 정말 특수한 영역, 자신밖에 모르는 영역의 컨설팅 가격은 부르는 것이 값이겠지만, 세상에 그런 영역은 드물고 따라서 오늘날 대부분의 컨설팅 가격은 그 내역을 공개하라고 한다. 시니어 컨설턴트들은 사업 대가를 산정하면서 이런저런 계산을 하게 되니 컨설턴트 대가가 어떻게 산정되는지 대강 알 수 있다.[11] 그러나 신입 컨설턴트들은 PM 역할을 하지 않으니 상대적으로 그런 경험이 없을 것이다. 그런데 이 글을 읽는 독자가 신입 컨설턴트라면 혹시 이런 생각 해 본 적 없는가? 나의 대가로 일천만 원 이상 매월 청구해서 고객이 지불하고 있는 것으로 아는데 왜 내 월급은 왜 이것밖에 안되는가? 그런 의문이 들거나 그런 생각이 들었던 적이 있다면 이제부터 잘 읽어보기 바란다. 그리고 앞으로 본인이 프리랜서(Freelancer) 컨설턴트로 독립한다면 그런 부분의 일부를 더 챙길 수도 있을 것이다. 이제부터 소개할 컨설팅 대가 모델은 시간별 요금을 산정하는 것을 기본으로 하며 모든 제세공과금은 개인이 부담하는 것으로 한다. 즉, 의료보험을 포함한 각종 세금 관련 사항은 본인이 직접 챙겨야 하며, 기업 소속으로서 받았던 나름의 복지 혜택도 모두 사라진다는 것을 명심하자. [12] 첫 번째, 시간당 요율을 계산한다. 어떤 컨설턴트가 회사 소속이었을 때 연봉 6,000만 원에 인센티브 등 각종 수당 1,500만 원을 받던 사람이라고 가정하자. 유급휴가는 2주(14일), 점심시간 제외 하루 8시간, 주 5일 근무한다면 그의 시간당 급료는 (A)이다. (연봉+기타 수당)/(50주*40시간) = 3.75만 원/시간 .... (A) 여기서 중요한 것은 A의 3배를 취하는 것이다. 즉, 3.75만 원/시간 *3 = 11.25만 원/시간을 소수 첫째 자리에서 올림 한 12만원를 시간당 요율로 정한다. 즉, 이 사람은 12만 원/시간의 임금 요율을 가진다. (A) 값의 3배를 하는 이유는 매우 중요한데, 실제로 1/3은 본인이 가져가는 실제 임금이고 또 다른 1/3은 각종 보험처리, 세금 등 비용으로, 마지막 1/3은 행정이나 사무비품 관련 비용이라고 생각하면 된다. 실제로 산정된 금액의 2/3는 과거 컨설팅 회사에 소속되어 있었을 때 간접비나 오버헤드 비용으로 처리되던 것들이며 프리랜서가 되었다고 해서 이 부분을 안 하는 것은 아니므로 개인적으로 감당해야 한다. 두 번째, 컨설팅 일일 비용의 계산 앞서 계산한 시간당 요율을 활용하여 일당을 계산한다. 하루 8시간 근무 시 12만 원 * 8 = 96만 원을 청구할 수 있다. 세 번째, 프로젝트 컨설팅 비용의 청구 위의 사람이 실제 프로젝트에 투입되면 투입시간을 기준으로 청구서를 작성해야 한다. 예를 들어 하루 8시간 근무 기준 5일 동안 투입된다면 12만 원/시간 * 8시간 * 5일 = 480만 원(VAT 포함)을 청구할 수 있다. 시간당 요율 계산은 일반적으로 3배의 법칙이 인정받고 있다. 그러나 만약 고용 측에서 깎아달라고 하면 그 부분을 조정해야 하는데 세금도 포함해서 다양한 비용을 감당해야 하므로 잘 고민해서 협상해야 한다. 프로젝트 컨설팅 비용과 관련하여 영미권에서는 물리학자 Niels Bohr와 관련된 재미난 조크가 전해오는데 다음과 같다. 회사의 기계가 고장 났는데 Niels Bohr의 옛 학교 친구인 회사 소유주는 그 문제를 해결하기 위해 Niels Nohr를 회사로 초빙한다. Niels Bohr는 기계를 잠시 살펴보더니 기계 옆에 'X' 표시하고 망치로 그 부분을 세게 두드리라고 말하고 돌아간다. 나중에 청구서를 받아본 친구는 깜짝 놀라 Niels Bohr에게 전화를 걸었다. "Niels, 자넨 5분 정도밖에 있지 않았는데 $10,000 청구서는 무엇인가? 자세한 내역을 같이 알려주게!" Niels Bohr는 알았다고 하고 상세 내역이 담긴 청구서를 다시 보냈다. 친구는 새로운 청구서를 열어보았더니 다음과 같았다. INVOICE Drawing X on the side of your machine $ 1 Knowing where to put the X $ 9,999 ————————————— ———————— —————————— Total $10,000 청구한 그대로 돈을 받았는지는 모르겠다. 그러나 컨설턴트는 자신이 하는 일의 가치를 알아야 자신의 대가를 제대로 정의하고 청구할 수 있고 그것은 서구 사회에서 인정받고 있는 것 같다. 네 번째, 성과급 기반 대가 어떤 고객은 시간당 요율을 인정하지 않고 커미션(commission)을 포함한 성과급을 제안하는 경우도 있다. 그러나 이 경우 위험 요소도 있는데 기업의 성과측정 이슈가 고스란히 따라온다. 즉, 지표의 정의 및 측정, 성과평가 기준 시점 등을 어떻게 정의하느냐가 매우 중요하다. 성과급의 긍정적인 부분만 믿고 기본 대가 청구 없이 고객에게 끌려다닐 수도 있고 변화관리를 잘 해야 할 상황이다. 다섯 번째, 실적 데이터를 활용한 전략적 청구 이 부분은 시간당 요율을 좀 더 정밀하게 계산하여 기본급 형태로 청구하고 나머지 비용은 사후 정산(Reimbursement)의<NAME>을 갖는 청구 방식으로 저자도 일하면서 이런 방식으로 청구하는 컨설턴트들을 고용해 보았고 프리랜서 컨설턴트들이 가장 선호하는 방식이다. 내용을 알기 위해 첫 번째 언급했던 내용들을 조금 더 정교화해 보자. (이 경우, 3배수 원칙은 고려하지 않는다) [Step #1. 시간당 요율 정교화] 1년 52주를 휴일, 휴가, 병가 등의 합해서 6주 정도를 제외하고 46주를 기준으로 한다. 주 5일 8시간 근무를 기준으로 하면 일 년은 46주 * 5일 * 8시간 = 1,840시간을 일할 수 있다..... (B) [Step #2. 청구 가능 시간의 산정] 1,840시간을 산출하였지만 실제 그 시간을 모두 일할 수 있는 것은 아니다. 또한, 어떤 시간은 업무와 관계없는 일에 시간을 사용할 수도 있다. 예를 들어 관리, 서류 준비 등 부외 잡일에 (B) 시간의 20%, 마케팅/네트워킹, 일을 구하는데 (B) 시간의 20%, 일과 관련 없는 일에 (B) 시간의 10%를 사용한다면 실제 업무와 관련된 시간은 1,840 * 50% = 920시간이다. ..... (C) [Step #3. 최고의 회수율 고려] 선의를 보여 청구 가능 시간을 920시간으로 했지만 모든 고객이 이를 인정하지는 않을 것이므로 명확한 수수료 책정을 위해 이 부분 5% 정도를 감안하면 920 * 95% = 874시간. .... (D). 실질적으로 일 년 중 업무에 사용할 수 있는 청구 가능 시간은 (D)가 된다고 할 수 있다. 앞서 얘기한 연봉 6,000만 원, 수당 1,500만 원을 받는 사람을 생각해 보면 (6,000 + 1,500)/874시간 = 8.58만 원/시간 .... (E) [Step #4. 간접비 고려] Step #3에서 산정된 금액이 모두 순이익이 되는 컨설팅 사업이라면 관계없지만 대부분의 경우, 다양한 간접비 항목을 고려해야 한다. 아래와 같은 항목들이 있을 수 있다. (처음 시작하는 것을 기준으로 하였다) - 사무실 임대료 또는 모기지 이자 - 사무실 집기 - 인터넷 등 통신 비용 - 노트북 또는 데스크톱 컴퓨터 - 프린터 - 배송 및 우송료 - 프린터 토너 및 잉크 - 종이, 문방구 등 사무용품 - 명함 - 회계 및 법률서비스 - 사무실 가구 - 책상, 의자, 선반, 캐비닛, 조명 등 - 사업 면허 및 허가 - 보험 - 건강, 생명, 장애, 책임 등 - 자동차 - 보험, 정비, 가스, 임대 - 광고 및 마케팅 - 구독 - 전문 협회 - 전문적인 목적을 위한 식사 및 접대 - 평생 교육 - 전문 회의, 콘퍼런스 및 전시회 - 청소용품 및 청소 서비스 그 외 더 많은 항목들이 오버헤드 비용으로 발생할 수 있다. 몇몇 서비스는 개인이 처리한다 해도 기본적으로 비용이 소요되므로 이를 잘 계산해야 한다. 여기서는 예를 들어 2,000만 원이 사용된다고 해보자. (회사에서도 마찬가지이지만 오버헤드 비용을 절약하면 이익 창출에 적지 않은 도움이 된다). 이 비용을 청구 가능 시간으로 나누면 2,000만 원 / 874시간 = 2.28만 원/시간 ... (F) 프리랜서 컨설턴트가 청구할 수 있는 수수료는 (E) + (F) = 8.58만 원/시간 + 2.28만 원/시간 = 10.86만 원/시간 ... (G)가 산출된다. 프리랜서 컨설턴트는 또 일을 언제 얻게 될지 모르기 때문에 그런 위험요소 부담을 없애기 위해 수수료에 이익을 10% ~ 33% 정도 부과한다. 첫 계약이 될 것이니 10%만 생각해 본다면 10.86만 원/시간 * 1.1 = 11.94만 원/시간 ... 소수점 올림 하여 12만 원/시간 ... (H)가 시간당 요율이 된다. 앞서 소개한 3배의 법칙에서 대략 산정한 12만 원과 같아졌다. 일부러 같게 만든 것은 아니지만 결과적으로 그렇게 되었다. 실제 청구내역은 이렇지만 본인이 오버헤드 비용 부분을 절감할 수 있다면 순익은 높아지게 될 것이다. 위의 글을 순서대로 죽 따라왔다면 이건 마치 기업의 원가계산하는 것과 거의 흡사하지 않은가? 그렇다. 같은 절차를 밟았다. 컨설팅 수수료가 원가이고 거기에 이익을 붙인 것이다. 한 가지 더 생각해 보면 이는 서비스 요금이지만 그 근본 사상이 Head Count 방식과 같다. 즉, 여러분 자신이 100% 일에 몰두해야 받을 수 있는 돈이다. 기업은 어떤가? 그런 부분 혁신을 위해 설루션 비즈니스로 전환하면서 제품의 단가를 한 번에 다 받는 것이 아니고 서비스로 청구한다. 즉, 설루션 비즈니스의 가격 모델을 잘 벤치마킹하면 컨설팅 수수료도 다르게 청구할 수 있다는 말이다. 멀티 프로젝트를 뛸 수 있을까? 대가는 더 비싸게 청구할 수 있을까? 숙제라 생각하자. 여섯 번째, 사후 정산 처리 컨설팅 계약이 체결된 후에도 일하다 보면 나의 청구내역과 관계없는 그러나 일하면서 반드시 필요한 비용이 발생할 수 있다. 저자의 경우, 해외 콘퍼런스에 급하게 가야 했는데 미처 등록을 못해서 컨설턴트가 대신 등록해 주고 비용을 지불하였다. 물론, 그는 나중에 이것도 영수증과 같이 청구하였고 그것을 정산해 주었다.(Reimbursement) 즉, 컨설팅 계약 시 제시된 청구 내역이 아니더라도 얼마든지 상호 간의 비용 정산을 해줄 수 있어야 한다. 일곱 번째, '나의 몸값은 얼마인가?'라는 다소 도발적인 질문에 대해 이제 답을 해보면 종교적, 철학적 의미를 배제하고 철저하게 시장 원리로 자신이 현재 얼마짜리인지 계산해 볼 필요는 있다. 기업에 있었을 때 연봉이 높았다면 당연히 컨설턴트로 일할 때도 그 수준 또는 이상을 받을 수 있어야 한다. 그러기 위해서 프리랜서가 아니라 현재 기업에 몸담고 있는 사람이라면 현재에 충실함이 향후 몸값에도 영향을 준다는 사실을 잊지 말자. 프리랜서 컨설턴트라면 오버헤드 비용은 가능하면 줄이고, 현재 일의 성과를 고객에게 인정받아 재계약 시에는 이익률을 10% 이상 청구할 수 있도록 노력하자! [13] [1] www.cebglobal.com [2] 컨설팅을 잘 모르는 B2B 영업대표가 컨설팅 사업을 주도할 수는 없었으므로 컨설턴트와 같이 사업개발을 진행하였고 이는 비용 효율적 관점에서 경쟁력 이슈가 제기되었다. [3] 이 부분에 대한 평가는 저자가 컨설턴트로 일하던 때나 지금이나 힘들지만 사업을 발굴하는 역량을 키울 수 있다는 쪽과 과도한 노동량으로 컨설턴트의 생명(물리적인 생명)이 더 짧아진다는 쪽으로 양분되고 있다 [4] 사고 리더십(Thought Leadership) 활동을 포함한 마케팅 활동이 경영진들에게 어필된다면 입찰 없이 사업을 수주하게 되는 경우도 많았다. 이는 시장 리더십(Market Leadership) 확보와 별개로 사업 측면의 실속을 거둘 수 있는 방법으로 Top 3 전략 컨설팅 기업들 등 이 오래전부터 시도해왔던 방법이다. [5] Non-Disclosure Agreement [6] Time and Materials Contract [7] Fixed Price [8] Statements of Work 작업지시서 [9] 사실 이 부분은 이슈가 첨예하다. 잘 지켜지지 않기 때문이다. 컨설팅 프로젝트에서 범위 초과는 항상 있는 일이며 고객 관계를 위해 대부분의 컨설팅 기업들은 그것을 수용한다. 그러나 무엇이 Win-win 방안인지는 고객과 컨설팅 기업이 같이 깊게 고민해야 한다. [10] Cost Reimbursable [11] 회사마다 관리회계 기준이 다르므로 조금씩 다르다. [12] 'http://consultantjournal.com/blog/setting-consulting-fee-rates'의 내용과 개인 경험을 토대로 재정리하였다. [13] 사실 컨설팅 계약 시 청구내역을 상세하게 이익률까지 적어내라고 하는 고객은 없다. 자세한 내역을 묻지 않는 고객도 많다. 그건 일종의 불문율이고 시간당 요율이 비싸면 계약하지 않고 다른 컨설턴트를 찾을 수도 있기 때문이다. 그리고 컨설팅의 속성 상, 그 사람 아니면 안 되는 경우가 많아서 계약하려는 것이다. 그러나 컨설턴트 개인 입장에서는 어떻게 내역을 만들어 청구할 것인지 정도는 알고 있어야 하기에 하는 얘기이다. 19. 성공하는 컨설팅 사업 제안 19.2 제안 프레젠테이션의 구성 제안 프레젠테이션은 제안서를 심사해야 하는 평가 위원들 입장에서는 방대한 제안서를 읽기 전에 주요 사항을 누군가가 논리적으로 알기 쉽게 설명해 준다는 측면에서 매우 유용한 자료라 할 수 있다. 논리적이고 구조적이며 또 감동까지 주어야 하는 프레젠테이션의 원조를 찾아보면 그리스의 철학자 아리스토텔레스(Aristotle. BC 384 ~ BC 322)까지 올라갈 수 있다. 프레젠테이션의 논리적 구조와 스토리텔링을 생각해 보면 논리학 (Logic)과 시학(Poetica)을 만든 아리스토텔레스야말로 최고의 프레젠터(presenter)였을 법하다. 대중연설과 프레젠테이션은 청중을 대상으로 한다는 점은 같지만 그<NAME>이나 방법은 좀 다른데, 파워포인트와 같은 발표 도구를 활용한다고 전제하면 21세기에 들어서 최고의 프레젠터는 Apple의 전(前) CEO였던 고(故) 스티브 잡스(Steve Jobs. 1955 ~ 2011)를 많이 떠 올린다. 애플 개발자 콘퍼런스에서 아이폰을 멋지게 소개하던 모습 등 군더더기 없고 간결하지만 인상적인 프레젠테이션을 보여주었기 때문이다. 그리고, 요즘은 많이 없어졌지만 브랜드 호텔의 소개<NAME>상도 좋은 프레젠테이션 사례이다. 유명한 연예인이나 호텔 매니저가 직접 호텔을 소개하는 이 비디오 클립은 호텔방에 들어가면 자동으로 TV가 켜지면서 부드러운 음악과 함께 호텔의 이곳저곳을 설명해 주었던 기억이 있다. 어떤 보조자료도 없이 육하원칙에 입각해 매우 간단명료하게 메시지를 전달하였지만 아주 인상적이었던 좋은 프레젠테이션이었던 것으로 기억된다. 사실 어떤 방식을 선택하던, 어떤 이야기를 하던, 어떤 매체나 어떤 미디어를 선택하던 프레젠테이션을 성공적으로 잘 수행하려면 아래 두 가지가 가장 중요하다. 미리 많이 연습할 것 시작 후 2분 안에 관객의 시선을 확보할 것 이것만 잘되면 프레젠테이션은 사실 성공이라 할 수 있다. 그럼에도 불구하고 제안 프레젠테이션은 문서의 구성 및 작성부터 이런저런 챙겨야 할 것들이 있다. 제안 프레젠테이션은 다음과 같이 정의할 수 있다. 제안 프레젠테이션(Proposal Presentation)이란, 제안 내용을 논리적이고 설득력 있게 구성하고 한정된 시간 내에 평가 위원들에게 제안 내용을 정확하게 전달하여 감동을 줌으로써 프레젠터(Presenter)가 의도한 대로 평가 위원들이 판단하고 의사결정할 수 있도록 하는 커뮤니케이션 기법 제안 내용, 논리, 설득력, 한정된 시간, 정확, 전달, 감동, 판단, 의사결정, 커뮤니케이션 기법 등이 주요 키워드가 될 수 있다. 이를 기반으로 제안 프레젠테이션에서 고려해야 할 것들을 생각해 보면 Figure V-7과 같이 청중 분석, 프레젠테이션 구조, 발표 매체의 선정, 프레젠테이션 문서, 개인적 스타일 등에 대해 고민해 볼 필요가 있다. 이 중 청중 분석은 가장 중요한데 프레젠테이션을 듣는 사람 즉, 청중이 누구인지 파악하는 것이다. 청중의 규모나 성별, 지식 및 태도, 특히 니즈에 대해 명확하게 파악하고 있어야 정확한 메시지 전달이 가능하다. Figure V-7. 제안 프레젠테이션 고려 사항 저자가 경험한 컨설턴트들은 대부분 훌륭한 언변을 갖추고 있다. 그게 타고났던 연습을 통해서 익혔던 아주 훌륭한 사람들이 많았다. 프레젠테이션은 하나의 쇼(Show)이고 프레젠터는 그 쇼의 최고 배우이기 때문에 프레젠테이션 문서는 좋은 각본이 되어야 한다. 프레젠테이션 발표 자료의 구조는 다양한 관점에서 이야기할 수 있지만 가장 쉬운 접근은 도입, 전개, 결말 또는 서론, 본론, 결론으로 풀어지는 3단계 접근법이다. Table V-7은 논리적 관점에서 3단계로 내용을 구성할 때 주요 고려 사항과 예시이다. Table V-7. 프레젠테이션의 3단 구성 Table V-7과 같이 프레젠테이션 발표 자료의 구조를 결정하면 청중의 입장에서 다음 세 가지를 충분히 검토해 보아야 한다. 1. 프레젠테이션 자료의 콘텐츠가 이해되는가? 2. 프레젠테이션 자료의 흐름이 있는가? 3. 프레젠테이션 자료에서 강조하는 것이 보이는가? 제안 프레젠테이션은 제안서의 정수를 집약하는 것이므로 제안 전략 및 내용이 제안 프레젠테이션에 그대로 녹아들어야 한다. 예를 들어 공공 IT 컨설팅은 Table V-8과 같은 목차로 구성될 수 있다. 첫 번째, 제안 개요 혹은 사업의 이해라고 명명되는 부분은 제안하는 사업에 대해 사업자가 잘 이해하고 있다는 것을 서술하는 장으로 사업이 어떤 배경에서 발주되었는지 어떤 목적이나 니즈로 고객이 이것을 고민하고 있는지를 임팩트(impact) 있게 요약하는 부분이다. 보통 제안요청서를 많이 참고하지만 컨설턴트의 통찰력과 정보력을 기반으로 경쟁사가 파악하지 못했던 사실이나 고객의 니즈를 표현해 줄 경우 평가 위원들은 깊은 인상을 받는다. 유사 사업에 대한 경험이나 실적, 인정받는 대표적인 성공적인 사례(Best Practice)가 있다면 충분히 표현하는 것이 좋다. 두 번째, 사업 수행전략은 제안전략에서 도출된 전략들을 전략 하나 당 1~2장의 슬라이드에 도식화하여 담아내는 것으로 프레젠테이션의 핵심 내용이라 할 수 있다. 요즘은 뜸하지만 한때는 의미 있는 영어 단어로 제안전략을 응축하여 많이 표현하였다. (예를 들면 SMART[1] 전략) 제안 전략을 하나의 의미 있는 단어로 표현하고 브랜드화하여 고객의 깊은 인지를 유도할 수 있는 좋은 기법이지만 억지로 작명하면 매우 어색해지기도 한다. Table V-8. 공공 IT 컨설팅 제안 프레젠테이션 목차 사례 사업전략은 보통 4~5개 정도가 적정하다. 공공 IT 사업을 예를 들면 사업전략 1 ~ 3은 해당 제안의 성격에 따라 상이하고 사업전략 4, 5는 훌륭한 사람이 참가합니다, 방법론이나 체계적인 지원이 뒷받침합니다 등으로 정형화되어 있다. 각 사업전략 당 전략 실행과제들이 서술되는데 보통 3개 정도가 적당하다. 해당 전략을 실행하기 위한 구체적인 활동 계획을 표현한다. 시스템 구축을 잘 하기 위해 특별한 도구를 도입한다던 지 선진 사례를 반영하기 위해 벤치마킹을 추진하겠다든지 등등 경쟁사와 차별화된 전략 개발과 실행계획 수립이 제안 성공 여부, 사업 수주 여부를 결정한다. 또한, 그 과제 수행의 기대효과를 표현함으로써 전체적으로 이 일이 진행되었을 때 어떤 부분이 좋아지는지 프레젠테이션을 듣는 내내 관심이 이어지게 하는 것이 좋다[2]. 사업 관리와 지원방안도 매우 정형적인데 PM을 비롯하여 어떻게 인력이 구성되는지, 어떤 일정으로 추진되며 단계별 보고는 언제 몇 번 하는지 등이 표현된다. 품질보증 방안은 산업 표준을 준수한다던 지 주요 인증 (Certification) 같은 것이 있다면 그 부분을 잘 표현하여 고객의 신뢰를 더 얻을 수 있다. 프로젝트 관리 방안은 주먹구구식으로 일을 하는 것이 아니라 체계적인 방법론과 자동화 도구를 활용하고 있음을 강조할 수 있다. 마지막 상생 협력 방안은 사업의 규모가 커서 컨소시엄으로 일을 추진할 때 상호 간에 어떻게 협력하여 성공적으로 일을 수행할 것인지에 대한 방안을 서술하게 된다. 한편, 발주처가 전형적인 목차를 제시하는 공공사업(B2G)이 아니라 민간기업이 발주하는 사업(B2B)의 경우는 좀 더 창의적인 목차를 구성할 수 있다. 사안에 따라 다르겠지만 가장 보편적으로 활용하는 방안은 문제 제기와 해답을 제시하면서 고객과 공감을 가져가는 방법이다. 즉, 고객이 기업의 제품이나 설루션을 선택하도록 할 때 ‘왜?’라는 화두를 던지고 그 ‘답’을 제시하여 결과적으로 제안사의 제품이나 설루션을 선택하게 하는 것이다. 이 경우 프레젠테이션을 할 때 좀 중요하게 생각해야 할 것은 그 질문에 제시하는 ‘답’을 직접적으로 ‘우리 제품이나 설루션입니다’라고 하는 것은 하수(下數)라고 볼 수 있다. 보다 전문가적인 입지를 가져가고자 한다면 그 ‘답’은 매우 객관적인 관점에서 제시되어야 한다. 그리고 다양한 비교 – 경쟁사 제품과의 비교도 좋다. –를 통해 고객이 우리 제품이나 설루션을 선택할 수밖에 없게 만드는 것이 장기적인 고객 관계를 만들어 나가는 좋은 방법이다. Table V-9는 민간사업의 제안 프레젠테이션 목차를 생각해 본 것이다. Table V-9. 민간기업 컨설팅의 제안 프레젠테이션 목차 사례 첫 번째는 문제의 인식이다. 제안을 하면서 고객이 당면한 문제를 잘 이해하고 있다는 것을 충분히 보여주어야 한다. 그냥 ‘열심히 잘 하겠습니다’는 오늘날 사업 환경에서 더 이상 통하지 않으며 고객의 니즈나 문제에 대한 충분한 이해를 보여줌으로써 사업을 믿고 맡길 수 있다는 고객의 신뢰를 확보해야 한다. 그렇기에 고객에 대한 깊은 이해가 중요하며 컨설턴트의 통찰력이 강조되는 것이다. 두 번째는 그 문제/니즈에 대응하고 있는 경쟁자들의 동태를 비교 분석하는 것이다. 이것은 기업의 차별화 포인트를 표현할 수 있는 부분이다. 중요한 것은 경쟁사가 제대로 못하고 있다는 것을 부각하는 것이 아니라 그 부분을 ‘우리 제품이나 설루션은 이렇게 해결할 수 있다’를 강조해야 한다.[3] 세 번째는 문제 분석, 비교 분석 등에서 도출된 많은 과제 중 선택과 집중을 통하여 가장 중요한 과제가 무엇인지 고객과 공감하는 것이다. 이 부분에서 평가 위원들과 싱크(Sync) 되면 거의 사업을 수주했다고 볼 수 있다. 네 번째 대안 제시는 실질적으로 제안사가 고객 기업에게 제공할 수 있는 가치를 보여주는 부분인데 경쟁사와는 차별된 제품이나 설루션으로 고객의 니즈를 충족시켜주거나 고객의 문제를 해결할 수 있음을 보여주는 부분이다. 마지막으로 그것을 어떤 실행계획으로 추진할 것인지 등을 설명하는 것으로 프레젠테이션을 마무리할 수 있다. 프레젠테이션 발표 자료의 구성에 절대적인 기준은 없지만 다음과 같이 구성하면 보기 좋다. (파워포인트를 사용하여 작성한다고 가정) (1) 프레젠테이션 첫 장은 대부분 표지가 차지하는데 제목(47pt), 부제목(36pt), 이름(24pt)가 무난함 (2) 이어지는 본문의 구성은 소제목(28pt), 본문(18pt)로 하고 서체는 한 가지만 사용하는 것이 좋다. 예를 들어 맑은 고딕체의 굵기 조정 (L, M, B) (3) 발표 자료를 구성할 때 내용이 수렴되게 하는 것이 좋다. 즉, 다음 절차로 문서를 구성할 때 마지막 결론이 수렴되는 형태이다. (1) Take Attention (2) Transition (3) Main Stream (4) Conclusion 19.3 차별화된 프레젠테이션 프레젠테이션에 있어 프레젠터가 개방적인 성격을 가지고 있고 여러 사람 앞에 나서기 좋아하는 사람이 상대적으로 유리한 것은 사실이다. 그러나 고객의 감동까지 가지 못하는 경우도 많이 보았는데 컨설턴트 자신의 지식과 경험이 아닌 것을 발표하는 경우는 아무리 연습을 했을지언정 고객 감동을 가져온 경우는 드물었다. 문서에 적용할 단어나 어휘, 말로 표현해야 할 것들은 청중의 기대에 부합해야 하며 핵심적인 문장을 중심으로 잘 표현해야 한다. 특히 지시적인 언어를 사용하면 주의를 집중시키는 효과가 있다. 예를 들면 Table V-10과 같은 것이다. Table V-10. 프레젠테이션 표현 사례 또한, 적극적으로 자신 있게, 문법에 맞는 구조로 표현하는 것이 좋다. Table V-11은 그런 사례들이다. Table V-11. 적극적인 말하기와 사례 그 외 목소리 톤, 자세, 시각 등 프레젠터가 전문가로서 신뢰할 수 있는 사람으로 비칠 수 있도록 노력해야 한다. 발표 태도나 자세 등은 평소 개인적인 습관과 관계가 깊은데 쉽게 바뀌지 않으므로 시간을 두고 리허설(Rehearsal)을 통해 가능하면 많이 연습해야 한다. 마지막으로 프레젠테이션이 끝나면 질의응답을 받게 된다. 질의응답을 최소화하기 위해서는 사전에 전략적으로 질의가 나올 수 있는 항목들을 프레젠테이션 안에서 충분히 녹여서 설명하는 것이 좋다. 경우에 따라 질의응답 대응 팀(Red Team)을 별도로 구성하기도 하고 사전 질문을 만들고 제안팀 또는 내/외부 유관 조직을 별도로<NAME>해서 현장 시뮬레이션을 해보기도 한다. 어찌 되었던 프레젠테이션에 임하는 가장 좋은 자세는 ‘연습’과 또 ‘연습’뿐이다. 컨설팅에 대해 다시 생각해 보는 항해가 거의 끝나간다. 지식경영(Knowledge Management)는 핵심 역량 이론과 더불어 1990년대 후반부터 2000년대 초반까지 전 세계적으로 화두가 되었던 오래된 주제이지만 대표적인 지식서비스 산업인 '컨설팅 사업'과는 떼어놀 수 없는 관계에 있는 중요한 영역이다. 본 저서의 마지막 장인 제20장은 컨설팅 이행과 지식경영에 대해 살펴보자. [1] 피터 드러커의 SMART는 사업목표(MBO) 작성 시 고려해야 할 Specific, Measurable, Action-oriented, Realistic, Timely의 약자를 의미함 [2] 문서 작성의 기술적 방법으로는 부표나 레전드(legend)를 이용하여 프레젠테이션의 흐름을 지속적으로 이어가는 것이 필요하다. [3] 간혹 광고 등에서 보이는 네거티브 전략은 수많은 업종에서 불문율처럼 되어 있다. 일종의 상도를 고려한 것인데 네거티브 전략과 차별화 전략을 잘 구분해야 할 것이다. 같이 읽어보면 좋은 책 kx ▶ Say It With Charts: The Executive’s Guide to Visual Communication, Gene Zelazny, McGraw-Hill, 2001 Say It With Presentation: How to Design and Deliver Successful Business Presentations, Gene Zelazny, McGraw-Hill, 2006 20. 컨설팅 이행과 지식경영 컨설팅 이행의 핵심은 데이터 분석 및 보고서 작성이지만 그 기반이 되는 것은 제안을 위해 본 사안에 대해 가졌던 전략적 사고를 지속적으로 유지하는 것이다. Table V-12는 전략적 사고의 단계적 흐름을 설명한 것인데 컨설팅 제안이던 컨설팅 이행이던 사고의 기본적인 흐름으로서 숙지해야 할 사항들이다. 컨설팅 기업의 지식과 경험, 도구를 충분히 활용하기 위해서는 지식 자산의 효율적 구축과 활용, 그리고 그것을 지원하는 인프라의 구축이 무엇보다도 중요하다. 제20장에서는 그것들에 대해 살펴보자. Table V-12. 전략적 사고의 단계 20.1 컨설팅 산출물 일(work)의 관점에서 보면 컨설팅은 프로젝트의 한 종류로서 시작과 끝이 있고 각각의 컨설팅마다 고유한 특색이 있으며 그 수행 결과는 반드시 산출물(deliverables)로 만들어진다. 대표적인 컨설팅 산출물은 보고서(Report)인데, 컨설팅의 종류와 성격에 따라서 그 세부적인 내역은 달라질 수 있으나 많은 컨설팅 프로젝트에서 공통적으로 만들어내는 보고서는 다음의 세 가지이다. 착수 보고서(Inception Report) 'Kick-Off Meeting 보고서'라고도 부르는 착수 보고서는 컨설팅 제안서에서 제시했던 컨설팅 이행 방안들을 선발된 투입 인원들과 함께 제시한 기간 안에 수행하겠음을 고객에게 천명하는 보고서이다. 민간 기업이 발주한 경영전략 컨설팅의 경우 최고경영자(CEO)를 대상으로 보고하는 경우가 많고, IT 컨설팅의 경우 IT 담당 임원(CIO)에게 주로 보고한다. 공식적으로 고객에게 프로젝트가 시작되었음을 알리는 것을 목표로 하기 때문에 해당 프로젝트의 의의, 수행 방안, 기대효과, 팀원 소개, 향후 계획 등에 대해 잘 정리해서 보고하는 것이 중요하며, 컨설팅 프로젝트를 실질적으로 도와줄 고객기업 내 각 부서장들 및 실무진들과 공식적으로 처음 대면하는 순간 일수 있으므로 매우 전략적으로 대응해야 한다. 중간 보고서(Interim Report) 중간보고서는 프로젝트 착수 이후에 수행한 현황 분석의 결과와 개선 기회 분야 선정에 대한 동의를 얻는 것을 목표로 한다. 가설을 기반으로 이슈나 문제 해결을 위한 해법이나 설루션에 대한 큰 그림(Big Picture)을 제시하고 향후 일정에 대해 소개한다. 프로젝트 기간이 길 경우, 고객의 요청에 의해 월별/분기별 보고를 요구받기도 하며, 현황 분석을 위한 워크숍(workshop)이나 인터뷰(interview)가 종료되면 보통 중간보고를 준비한다. 종료 보고서(Final Report) 종료 보고서는 중간보고서에서 제시된 개선 기회 분야를 현장에서 실행하기 위해 개발한 프로그램과 실행과제(Key Initiatives 또는 Quick win 과제), 그 과제를 이행하기 위해 필요한 후속 연계 프로젝트나 후속 조치사항 등의 이행 계획에 대해 최고경영자와 경영진들의 동의와 추진 권한을 얻는 것을 목표로 한다. 컨설팅 프로젝트가 잘 진행되면 보통 종료 보고 전에 후속 프로젝트에 대한 이야기가 고객과 함께 오고 가며 재계약을 하게 된다. 컨설팅 보고서는 ‘누가 작성했느냐?’보다 ‘실행에 옮길 수 있느냐?’가 더 중요하며 문제 해결을 위한 설루션을 제시할 수 있을 때 그 가치가 더욱 빛난다. 그런데 이런 결과는 훌륭한 컨설팅 PM과 컨설팅 팀만으로 수행할 수 있는 것은 아니다. 소위 말하는 백오피스(Back Office) 팀이 반드시 있어야 한다. 즉, 지원조직이 필요하다. 20.2 CoE의 운영 오늘날은 인터넷 등 다양한 통신망으로 연결된 글로벌 연결시대이다 보니 사업이나 기술도 성공 사례를 포함하여 거의 모든 것이 실시간(realtime)으로 전 세계에 공유되고 있다. 기업 조직의 형태도 마찬가지인데 GE로부터 시작된 사업부 조직(SBU), IBM이나 마이크로소프트가 채택하고 있는 매트릭스 조직 등 다양한 기업 조직의 형태는 그 기업의 경쟁력 확보에 매우 중요한 역할을 한다. 그중에 ‘Center of Excellence’라고 불리는 조직 형태가 있다. 산업 및 업종에 따라 그 의미를 조금씩 달리하기도 하지만 컨설팅 산업에서 CoE는 ‘컨설턴트 육성’과 ‘컨설팅 사업의 백오피스 역할’을 수행한다. 그 내용을 살펴보면 첫 번째, 컨설턴트 육성 및 관리이다. 이제 막 입사한 신입 컨설턴트들에게 컨설팅 스킬이나 도구와 기법, 방법론 등을 가르치면서 컨설턴트로서의 기본 소양을 쌓게 도와준다. 일반적으로 컨설팅 프로젝트는 각 산업 도메인에 속한 시니어 컨설턴트들이 프로젝트를 발굴하면 대부분 본인이 PM을 하고 CoE를 통해 투입될 인원을 수배하는 절차를 거쳐 프로젝트 팀을 구성한다.[1] 따라서 훌륭한 역량을 보유한 좋은 인재들을 육성하고 관리하는 것은 CoE의 중요한 역할이자 목표가 된다. 두 번째, 백오피스(Back Office)로서 컨설팅 지식과 수행 사례를 관리하는 일이다. CoE와 약간 다른 개념이지만 ‘Competency Center(CC)’나 ‘Resource Center(RC)’라고 하는 조직 형태가 인력을 육성하고 프로젝트에 투입하며 그들의 가동률을 관리하는 일에 집중한다면, CoE는 한 발 나아가서 방법론이나 도구와 기법 등 컨설팅의 핵심 지식(Core Knowledge)을 개발 및 관리하며 각 프로젝트 현장에 배포, 지원하는 일도 맡는다. 또한, 자원과 역량이 허락한다면 산업 리서치를 직접 수행하여 보고서를 만들어내기도 하고, 다양한 분석을 수행해서 고객에게 트렌드와 통찰력을 제공할 수 있는 많은 자료들을 생성한다. 웹페이지나 소셜미디어를 운영하며 마케팅을 하기도 하고 산업이나 기술 콘퍼런스를 개최하여 고객들을 초빙하고 그들의 사고 리더십(Thought Leadership)을 소개하는 시간을 갖기도 한다. 맥킨지나 베인, 엑센츄어 등 역사가 오래된 외국계 컨설팅 기업들은 이 백오피스 기능이 매우 우수하다. 다양한 지적 자산을 개발하고 컨설턴트들에게<NAME>여 컨설턴트들의 프로젝트를 도와주고 또 그 수행 사례를 반영하여 방법론이나 도구, 기법이 정제될 수 있도록 도와준다. 이 우수 성공 사례(Best Practice)나 공유되는 다양한 경험들을 활용하여 프로젝트를 보다 쉽게 수행할 수 있게 도와주고 있다. Break #22. 매트릭스 조직 매트릭스 조직은 글로벌 기업들의 대표적인 조직 형태로 글로벌 사업을 추진하는 가장 이상적인 형태의 조직이라고 불린다. 매트릭스 조직은 Figure V-8처럼 기업의 제품과 서비스를 개발하고 생산하는 조직을 수평적(Horizontal)으로 놓고, 산업 또는 사업영역에 기반하는 사업 조직을 수직적(Vertical)으로 배치한다. 매트릭스 조직에서 수직적 배치 조직이 고객과 커뮤니케이션하며 사업을 담당한다. 즉, 수평 조직은 제품 서비스, 설루션 개발에 주력하고 수직 조직은 고객채널 역할을 하면서 수평조직이 만들어내는 제품과 서비스, 설루션을 고객에게 판매하는 역할을 맡는다. 사업의 복잡성에 따라 3~5축 또는 그 이상을 이루는 매트릭스 조직 형태도 있다. 매트릭스 조직의 성공 여부는 각 조직 간의 커뮤니케이션의 효율성에 달려 있다. 조직이 성숙하지 못하여 커뮤니케이션이 어려우면 관련 비용은 매우 높아진다. Figure V-8. 매트릭스 조직의 개념도 수직 조직이 맡는 고객기업 또는 사업영역, 그것을 B2B 사업에서는 어카운트 2라고 부른다. B2B 기업의 성과는 철저히 파레토 법칙을 따르기 때문에 어카운트 관리를 어떻게 수행해 내느냐에 따라 사업의 성공 여부가 달려있다고 해도 과언이 아니다 따라서 거래하는 고객 중 핵심 고객군을 파악하고 선별된 고객들은 집중 관리할 필요가 있다. 동일한 시장과 산업에서도 고객별로 중요하게 생각하는 포인트가 다르다. 어떤 고객은 최저가를 원하며, 어떤 고객은 전담 서비스, 어떤 고객은 검증된 기술 등 다양한 고객의 니즈가 존재하고 있다. 그런 다양한 니즈를 비용 효율적으로 대응하고 최고의 가치를 제공하기 위해 많은 기업들이 핵심 어카운트 관리(Key Account Management: KAM)에 주력하고 있다. 20.3 지식경영 컨설팅은 지식 경제(Knowledge Economy) 시대의 대표적인 지식 산업(Knowledge Business)이다. 1990년대 후반부터 2000년대 초반까지 이런 인식과 트렌드에 따라 지식 경영(Knowledge Management) 열풍이 불기도 하였다. 지식을 정의하고 지식을 관리한다는 취지로 지식관리시스템(KMS)을 구축하기도 하고 내부 프로세스를 혁신하는 등 기업마다 다양한 시도가 있었고 그 과정에서 다양한 성공과 한계가 나타났다. 20년이 지난 지금은 과거와 같이 지식경영이 그렇게 하이라이트 되고 있지는 않지만 컨설팅 기업들은 그들의 핵심 자산(Core Asset)이 지식경영에 기반한 지식 데이터베이스(Knowledge-Base)라고 말하는 것에 대해 주저하지 않는다. 그만큼 지식의 공유와 확대 생산이 중요하기 때문이다. 컨설팅 기업에서 지식을<NAME>는 수단은 크게 지식경영 시스템(Knowledge Management System: KMS)을 활용하는 것과 지식 커뮤니티를 이용하는 두 가지이다. 첫 번째, KMS를 이용하는 것은 크게 4개의 Level 또는 성숙도로 생각해 볼 수 있는데 첫 번째 시도이자 가장 기본적인 것은 프로젝트 산출물을 수집하고 분류하며 검색 시스템을 활용하여 많은 컨설턴트들이 그것을 재사용하면 방법론화하거나 핵심 지식으로 관리하는 식이다. 일종의 지식 저장소(Knowledge Repository) 형태인데 이런 수준을 KMS Level #1이라 할 수 있다. 조금 더 성숙하여 KMS Level #2가 되면 이런저런 저장소가 매우 많아지기 때문에 그것을 모두 묶어서 포탈(Portal)로 씌우고 우수한 검색 엔진을 통해 다양하고 효과적인 검색을 가능하게 한다. KMS Level #3가 되면 KMS가 별도의 정보시스템이 아니라 일반적인 업무 시스템으로 녹아져 버린다. 별도의 KMS가 없어지기 때문에 지식경영을 하지 않는 것처럼 보이지만 사실은 그것을 업무 흐름에 녹인다. 즉, 업무 흐름(Workflow)을 구현하고 단계적으로 업무를 진행하면서 표준이나 사례, 템플릿처럼 활용하여 일의 생산성을 극대화할 수 있도록 구현한다. 마지막으로 KMS Level #4가 되면 그렇게 만들어진 업무 시스템을 서비스 단위로 언제 어디서나 사용할 수 있도록 클라우드나 모바일 환경으로 구현한다. 이것이 정보시스템 관점에서 본 KMS의 발달 모습이라고 설명할 수 있다. 첫 번째가 소위<NAME>지(Explicit Knowledge)의 생성과 활용에 대한 접근 방법과 발달 과정이라고 한다면, 두 번째는 암묵지(Implicit Knowledge) 즉, 사람 머릿속의 지식이나 경험 등을<NAME>는 것이다. 영화 매트릭스처럼 코드를 뒤통수에 꽂고 지식을 내려받는 일은 지금 현재에는 불가능하기 때문에 알려진 가장 좋은 방법은 커뮤니티[3]를 이용하여 면대 면(face-to-face) 접촉을 활성화하는 것이다. 업무 시간의 일정 부분(예를 들면 1/5 정도)를 최근 화두가 되고 있는 산업이나 기술에 대한 연구와 스터디, 새로운 방식의 시도나 본인이 하고 싶은 일을 자유롭게 진행하고 같은 동기나 관심을 가진 사람들끼리 모여 커뮤니티 안에서 활발하게 진행하는 것이다. 이런 방법으로 인적 네트워크를 활성화하고 궁극적으로 전문가 네트워크(Knowledge Experts)로 발전할 수 있게 한다. 앞서 소개한 CoE 조직이 이런 부분을 리드할 수도 있다. 컨설팅 사업개발과 이행도 결국 지식경영이 보이지 않게 동작하면서 컨설팅 펌의 자산으로 역량으로 쌓여나갈 수 있을 때 보다 높은 생산성으로 훌륭하게 수행할 수 있을 것이라고 생각한다. 프리랜서 컨설턴트들을 만나서 이야기를 듣다 보면 가장 아쉬워하는 것이 KMS이다. 그들이 기업에 속해 있었을 때는 그 방대한 자료와 다양한 네트워크를 활용하여 여려움을 해결하면서 아쉬운 줄 몰랐는데 독립하여 일을 하다 보니 그 부분의 혜택이 아쉽고 그립더라 하는 이야기는 프리랜서 컨설턴트 누구를 만나던 공통된 이야기이다. 21.epilogue 컨설팅 이행의 핵심은 데이터 분석 및 보고서 작성이지만 그 기반이 되는 것은 제안을 위해 본 사안에 대해 가졌던 전략적 사고를 지속적으로 유지하는 것이다. Table V-12는 전략적 사고의 단계적 흐름을 설명한 것인데 컨설팅 제안이던 컨설팅 이행이던 사고의 기본적인 흐름으로서 숙지해야 할 사항들이다. 컨설팅 기업의 지식과 경험, 도구를 충분히 활용하기 위해서는 지식 자산의 효율적 구축과 활용, 그리고 그것을 지원하는 인프라의 구축이 무엇보다도 중요하다. 제20장에서는 그것들에 대해 살펴보자. Table V-12. 전략적 사고의 단계 20.1 컨설팅 산출물 일(work)의 관점에서 보면 컨설팅은 프로젝트의 한 종류로서 시작과 끝이 있고 각각의 컨설팅마다 고유한 특색이 있으며 그 수행 결과는 반드시 산출물(deliverables)로 만들어진다. 대표적인 컨설팅 산출물은 보고서(Report)인데, 컨설팅의 종류와 성격에 따라서 그 세부적인 내역은 달라질 수 있으나 많은 컨설팅 프로젝트에서 공통적으로 만들어내는 보고서는 다음의 세 가지이다. 착수 보고서(Inception Report) 'Kick-Off Meeting 보고서'라고도 부르는 착수 보고서는 컨설팅 제안서에서 제시했던 컨설팅 이행 방안들을 선발된 투입 인원들과 함께 제시한 기간 안에 수행하겠음을 고객에게 천명하는 보고서이다. 민간 기업이 발주한 경영전략 컨설팅의 경우 최고경영자(CEO)를 대상으로 보고하는 경우가 많고, IT 컨설팅의 경우 IT 담당 임원(CIO)에게 주로 보고한다. 공식적으로 고객에게 프로젝트가 시작되었음을 알리는 것을 목표로 하기 때문에 해당 프로젝트의 의의, 수행 방안, 기대효과, 팀원 소개, 향후 계획 등에 대해 잘 정리해서 보고하는 것이 중요하며, 컨설팅 프로젝트를 실질적으로 도와줄 고객기업 내 각 부서장들 및 실무진들과 공식적으로 처음 대면하는 순간 일수 있으므로 매우 전략적으로 대응해야 한다. 중간 보고서(Interim Report) 중간보고서는 프로젝트 착수 이후에 수행한 현황 분석의 결과와 개선 기회 분야 선정에 대한 동의를 얻는 것을 목표로 한다. 가설을 기반으로 이슈나 문제 해결을 위한 해법이나 설루션에 대한 큰 그림(Big Picture)을 제시하고 향후 일정에 대해 소개한다. 프로젝트 기간이 길 경우, 고객의 요청에 의해 월별/분기별 보고를 요구받기도 하며, 현황 분석을 위한 워크숍(workshop)이나 인터뷰(interview)가 종료되면 보통 중간보고를 준비한다. 종료 보고서(Final Report) 종료 보고서는 중간보고서에서 제시된 개선 기회 분야를 현장에서 실행하기 위해 개발한 프로그램과 실행과제(Key Initiatives 또는 Quick win 과제), 그 과제를 이행하기 위해 필요한 후속 연계 프로젝트나 후속 조치사항 등의 이행 계획에 대해 최고경영자와 경영진들의 동의와 추진 권한을 얻는 것을 목표로 한다. 컨설팅 프로젝트가 잘 진행되면 보통 종료 보고 전에 후속 프로젝트에 대한 이야기가 고객과 함께 오고 가며 재계약을 하게 된다. 컨설팅 보고서는 ‘누가 작성했느냐?’보다 ‘실행에 옮길 수 있느냐?’가 더 중요하며 문제 해결을 위한 설루션을 제시할 수 있을 때 그 가치가 더욱 빛난다. 그런데 이런 결과는 훌륭한 컨설팅 PM과 컨설팅 팀만으로 수행할 수 있는 것은 아니다. 소위 말하는 백오피스(Back Office) 팀이 반드시 있어야 한다. 즉, 지원조직이 필요하다. 20.2 CoE의 운영 오늘날은 인터넷 등 다양한 통신망으로 연결된 글로벌 연결시대이다 보니 사업이나 기술도 성공 사례를 포함하여 거의 모든 것이 실시간(realtime)으로 전 세계에 공유되고 있다. 기업 조직의 형태도 마찬가지인데 GE로부터 시작된 사업부 조직(SBU), IBM이나 마이크로소프트가 채택하고 있는 매트릭스 조직 등 다양한 기업 조직의 형태는 그 기업의 경쟁력 확보에 매우 중요한 역할을 한다. 그중에 ‘Center of Excellence’라고 불리는 조직 형태가 있다. 산업 및 업종에 따라 그 의미를 조금씩 달리하기도 하지만 컨설팅 산업에서 CoE는 ‘컨설턴트 육성’과 ‘컨설팅 사업의 백오피스 역할’을 수행한다. 그 내용을 살펴보면 첫 번째, 컨설턴트 육성 및 관리이다. 이제 막 입사한 신입 컨설턴트들에게 컨설팅 스킬이나 도구와 기법, 방법론 등을 가르치면서 컨설턴트로서의 기본 소양을 쌓게 도와준다. 일반적으로 컨설팅 프로젝트는 각 산업 도메인에 속한 시니어 컨설턴트들이 프로젝트를 발굴하면 대부분 본인이 PM을 하고 CoE를 통해 투입될 인원을 수배하는 절차를 거쳐 프로젝트 팀을 구성한다.[1] 따라서 훌륭한 역량을 보유한 좋은 인재들을 육성하고 관리하는 것은 CoE의 중요한 역할이자 목표가 된다. 두 번째, 백오피스(Back Office)로서 컨설팅 지식과 수행 사례를 관리하는 일이다. CoE와 약간 다른 개념이지만 ‘Competency Center(CC)’나 ‘Resource Center(RC)’라고 하는 조직 형태가 인력을 육성하고 프로젝트에 투입하며 그들의 가동률을 관리하는 일에 집중한다면, CoE는 한 발 나아가서 방법론이나 도구와 기법 등 컨설팅의 핵심 지식(Core Knowledge)을 개발 및 관리하며 각 프로젝트 현장에 배포, 지원하는 일도 맡는다. 또한, 자원과 역량이 허락한다면 산업 리서치를 직접 수행하여 보고서를 만들어내기도 하고, 다양한 분석을 수행해서 고객에게 트렌드와 통찰력을 제공할 수 있는 많은 자료들을 생성한다. 웹페이지나 소셜미디어를 운영하며 마케팅을 하기도 하고 산업이나 기술 콘퍼런스를 개최하여 고객들을 초빙하고 그들의 사고 리더십(Thought Leadership)을 소개하는 시간을 갖기도 한다. 맥킨지나 베인, 엑센츄어 등 역사가 오래된 외국계 컨설팅 기업들은 이 백오피스 기능이 매우 우수하다. 다양한 지적 자산을 개발하고 컨설턴트들에게<NAME>여 컨설턴트들의 프로젝트를 도와주고 또 그 수행 사례를 반영하여 방법론이나 도구, 기법이 정제될 수 있도록 도와준다. 이 우수 성공 사례(Best Practice)나 공유되는 다양한 경험들을 활용하여 프로젝트를 보다 쉽게 수행할 수 있게 도와주고 있다. Break #22. 매트릭스 조직 매트릭스 조직은 글로벌 기업들의 대표적인 조직 형태로 글로벌 사업을 추진하는 가장 이상적인 형태의 조직이라고 불린다. 매트릭스 조직은 Figure V-8처럼 기업의 제품과 서비스를 개발하고 생산하는 조직을 수평적(Horizontal)으로 놓고, 산업 또는 사업영역에 기반하는 사업 조직을 수직적(Vertical)으로 배치한다. 매트릭스 조직에서 수직적 배치 조직이 고객과 커뮤니케이션하며 사업을 담당한다. 즉, 수평 조직은 제품 서비스, 설루션 개발에 주력하고 수직 조직은 고객채널 역할을 하면서 수평조직이 만들어내는 제품과 서비스, 설루션을 고객에게 판매하는 역할을 맡는다. 사업의 복잡성에 따라 3~5축 또는 그 이상을 이루는 매트릭스 조직 형태도 있다. 매트릭스 조직의 성공 여부는 각 조직 간의 커뮤니케이션의 효율성에 달려 있다. 조직이 성숙하지 못하여 커뮤니케이션이 어려우면 관련 비용은 매우 높아진다. Figure V-8. 매트릭스 조직의 개념도 수직 조직이 맡는 고객기업 또는 사업영역, 그것을 B2B 사업에서는 어카운트 2라고 부른다. B2B 기업의 성과는 철저히 파레토 법칙을 따르기 때문에 어카운트 관리를 어떻게 수행해 내느냐에 따라 사업의 성공 여부가 달려있다고 해도 과언이 아니다 따라서 거래하는 고객 중 핵심 고객군을 파악하고 선별된 고객들은 집중 관리할 필요가 있다. 동일한 시장과 산업에서도 고객별로 중요하게 생각하는 포인트가 다르다. 어떤 고객은 최저가를 원하며, 어떤 고객은 전담 서비스, 어떤 고객은 검증된 기술 등 다양한 고객의 니즈가 존재하고 있다. 그런 다양한 니즈를 비용 효율적으로 대응하고 최고의 가치를 제공하기 위해 많은 기업들이 핵심 어카운트 관리(Key Account Management: KAM)에 주력하고 있다. 20.3 지식경영 컨설팅은 지식 경제(Knowledge Economy) 시대의 대표적인 지식 산업(Knowledge Business)이다. 1990년대 후반부터 2000년대 초반까지 이런 인식과 트렌드에 따라 지식 경영(Knowledge Management) 열풍이 불기도 하였다. 지식을 정의하고 지식을 관리한다는 취지로 지식관리시스템(KMS)을 구축하기도 하고 내부 프로세스를 혁신하는 등 기업마다 다양한 시도가 있었고 그 과정에서 다양한 성공과 한계가 나타났다. 20년이 지난 지금은 과거와 같이 지식경영이 그렇게 하이라이트 되고 있지는 않지만 컨설팅 기업들은 그들의 핵심 자산(Core Asset)이 지식경영에 기반한 지식 데이터베이스(Knowledge-Base)라고 말하는 것에 대해 주저하지 않는다. 그만큼 지식의 공유와 확대 생산이 중요하기 때문이다. 컨설팅 기업에서 지식을<NAME>는 수단은 크게 지식경영 시스템(Knowledge Management System: KMS)을 활용하는 것과 지식 커뮤니티를 이용하는 두 가지이다. 첫 번째, KMS를 이용하는 것은 크게 4개의 Level 또는 성숙도로 생각해 볼 수 있는데 첫 번째 시도이자 가장 기본적인 것은 프로젝트 산출물을 수집하고 분류하며 검색 시스템을 활용하여 많은 컨설턴트들이 그것을 재사용하면 방법론화하거나 핵심 지식으로 관리하는 식이다. 일종의 지식 저장소(Knowledge Repository) 형태인데 이런 수준을 KMS Level #1이라 할 수 있다. 조금 더 성숙하여 KMS Level #2가 되면 이런저런 저장소가 매우 많아지기 때문에 그것을 모두 묶어서 포탈(Portal)로 씌우고 우수한 검색 엔진을 통해 다양하고 효과적인 검색을 가능하게 한다. KMS Level #3가 되면 KMS가 별도의 정보시스템이 아니라 일반적인 업무 시스템으로 녹아져 버린다. 별도의 KMS가 없어지기 때문에 지식경영을 하지 않는 것처럼 보이지만 사실은 그것을 업무 흐름에 녹인다. 즉, 업무 흐름(Workflow)을 구현하고 단계적으로 업무를 진행하면서 표준이나 사례, 템플릿처럼 활용하여 일의 생산성을 극대화할 수 있도록 구현한다. 마지막으로 KMS Level #4가 되면 그렇게 만들어진 업무 시스템을 서비스 단위로 언제 어디서나 사용할 수 있도록 클라우드나 모바일 환경으로 구현한다. 이것이 정보시스템 관점에서 본 KMS의 발달 모습이라고 설명할 수 있다. 첫 번째가 소위<NAME>지(Explicit Knowledge)의 생성과 활용에 대한 접근 방법과 발달 과정이라고 한다면, 두 번째는 암묵지(Implicit Knowledge) 즉, 사람 머릿속의 지식이나 경험 등을<NAME>는 것이다. 영화 매트릭스처럼 코드를 뒤통수에 꽂고 지식을 내려받는 일은 지금 현재에는 불가능하기 때문에 알려진 가장 좋은 방법은 커뮤니티[3]를 이용하여 면대 면(face-to-face) 접촉을 활성화하는 것이다. 업무 시간의 일정 부분(예를 들면 1/5 정도)를 최근 화두가 되고 있는 산업이나 기술에 대한 연구와 스터디, 새로운 방식의 시도나 본인이 하고 싶은 일을 자유롭게 진행하고 같은 동기나 관심을 가진 사람들끼리 모여 커뮤니티 안에서 활발하게 진행하는 것이다. 이런 방법으로 인적 네트워크를 활성화하고 궁극적으로 전문가 네트워크(Knowledge Experts)로 발전할 수 있게 한다. 앞서 소개한 CoE 조직이 이런 부분을 리드할 수도 있다. 컨설팅 사업개발과 이행도 결국 지식경영이 보이지 않게 동작하면서 컨설팅 펌의 자산으로 역량으로 쌓여나갈 수 있을 때 보다 높은 생산성으로 훌륭하게 수행할 수 있을 것이라고 생각한다. 프리랜서 컨설턴트들을 만나서 이야기를 듣다 보면 가장 아쉬워하는 것이 KMS이다. 그들이 기업에 속해 있었을 때는 그 방대한 자료와 다양한 네트워크를 활용하여 여려움을 해결하면서 아쉬운 줄 몰랐는데 독립하여 일을 하다 보니 그 부분의 혜택이 아쉽고 그립더라 하는 이야기는 프리랜서 컨설턴트 누구를 만나던 공통된 이야기이다.<|endoftext|>

전문분야 텍스트 ### 제목: [ 문과생도 할 수 있는 ] 따라하면 다 되는 파이썬 업무자동화 ### 본문: "따라 하면 다 되는 파이썬 업무 자동화"는 실무 경험을 토대로, 파이썬의 여러 기능을 활용하여 일상의 업무를 효율적으로 자동화할 수 있는 방법들을 소개합니다. 저자는 본인의 실무 경험을 바탕으로, 파이썬을 활용하여 업무의 복잡성을 줄이고, 생산성을 높이는 다양한 방법들을 상세하게 소개합니다. 책에는 엑셀 데이터 처리부터 웹 스크레이핑까지, 다양한 실습 예제가 포함되어 있어 실제 업무에 즉시 적용할 수 있습니다. 특히, 이 책은 파이썬을 처음 접하는 초보자를 대상으로 하고 있어, 어려운 프로그래밍 용어나 개념 대신, 이해하기 쉬운 설명과 함께 실제 업무에 바로 도입할 수 있는 실용적인 내용을 담고 있습니다. 현대의 직장 생활에서 효율성은 선택이 아닌 필수입니다. 이 책을 통해, 파이썬의 강력한 업무 자동화 능력을 체험하고, 일상 업무의 효율성을 한 단계 끌어올릴 수 있을 것입니다. 01. 파이썬 시작하기 파이썬 시작하기 1. 파이썬을 활용해야 하는 이유 처음 프로그래밍으로 업무 자동화를 하고자 마음을 먹고 프로그래밍에 대해서 찾아보다 보면 Java, C++, JavaScript, R 등 수많은 프로그래밍 언어들이 있다는 것을 알게 됩니다. 각각의 프로그래밍 언어는 모두 특정 분야나 상황에서 뛰어난 성능과 편리함을 제공합니다. 그렇지만 '업무 자동화'라는 넓은 범주에서 초보자가 접근하기에 가장 저변이 넓고, 사용하기 쉬우며, 실질적인 결과물을 빠르게 얻을 수 있는 언어는 바로 '파이썬'입니다. 파이썬은 직관적이고 읽기 쉬운 문법으로 초보자도 배우기 어렵지 않습니다. 파이썬의 문법은 일반적인 영어 문장과 유사하여 이해하기 쉬우며 코드의 가독성이 뛰어납니다. 그로 인해 깊이 있는 수준까지 공부하지 않아도 빠르게 업무 자동화에 적용할 수 있습니다. 그리고 데이터 분석부터 웹 개발, 엑셀 작업, 이메일 관리, 더 나아가서는 인공 지능, 머신 러닝까지 다양한 분야에 활용할 수 있습니다. 또한 파이썬은 다른 프로그래밍 언어나 툴과의 연동이 쉽기 때문에 이를 통해 기존 시스템과의 호환성 문제를 최소화하면서 업무 자동화를 진행할 수 있습니다. 또한 커뮤니티가 활발하다는 것도 큰 장점입니다. 초보자가 처음 코드를 작성하다 보면 예상치 못한 오류에 당황할 수 있는데, 파이썬을 사용하는 전 세계적으로 수많은 개발자들의 다양한 자료와 튜토리얼을 찾아 문제를 해결할 수도 있고 다양한 커뮤니티를 통해 문제에 대한 도움을 받을 수도 있습니다. 이와 같이 많은 장점을 가진 파이썬이기에 프로그래밍을 알지 못하는 초보자들도 파이썬을 활용한다면 충분히 자신의 업무를 자동화시킬 수 있습니다. 이 책을 통해 매일의 반복적인 업무들을 파이썬에게 맡겨두고 커피를 한잔할 수 있는 여유가 생기기를 바랍니다. 2. 아나콘다 설치와 주피터 노트북 사용하기 1. 아나콘다(Anaconda) 설치 파이썬을 사용하기 위해서는 먼저 파이썬을 설치해야 할 것입니다. 따로 파이썬만 설치할 수도 있지만, 여기서는 '아나콘다'를 설치하는 것을 권장합니다. 파이썬 업무 자동화를 하다 보면 다양한 '라이브러리'나 '패키지'를 활용하게 됩니다. 패키지나 라이브러리의 개념에 대해서는 뒤에서 다시 학습하겠지만, 일단은 여러 기능들을 제공하는 툴이라고 생각하면 됩니다. 이러한 패키지나 라이브러리를 사용하려면 각각을 직접 설치해야 하는데, '아나콘다'를 설치하면 파이썬도 설치되면서 우리가 뒤에서 사용할 Pandas나 Numpy 등 여러 패키지도 함께 설치됩니다. 또한 conda 패키지 관리자를 통해 다른 필요한 라이브러리와 패키지도 쉽게 설치하고 관리할 수 있습니다. 여기서는 윈도 환경을 기준으로 두고 아나콘다를 설치하는 방법에 대해 소개합니다. 링크 : https://www.anaconda.com/distribution/ 위 사이트 링크로 이동하여 사이트 하단으로 이동하면 (저자가 이 책을 작성할 당시 기준) 좌측에 파이썬 3.7 버전과 우측에 파이썬 2.7 버전의 아나콘다 설치 파일이 있습니다. 여기서는 파이썬 3.7 버전 64 비트를 설치합니다. 설치 파일을 실행한 후에 다른 윈도 프로그램을 설치하는 것과 마찬가지로 Next >를 누르면서 설치를 완료하면 됩니다. 아나콘다를 다 설치했다면 아나콘다 프롬프트를 오픈하겠습니다. 아나콘다 프롬프트를 열었다면 아나콘다 프롬프트에 아래의 커맨드를 입력하여 아나콘다 파이썬 패키지를 전부 최신 버전으로 업데이트합니다. > conda update -n base conda > conda update --all 2. 주피터 노트북 사용하기 +구글 Co-lab 이용하기 구글 Co-lab은 온라인에서 파이썬 코딩을 실행할 수 있도록 만든 환경으로, Co-lab을 이용하면 컴퓨터에 파이썬을 설치할 필요 없고, 인터넷만 되면 어디서든 접속이 가능하고, 내 컴퓨터보다 빠르게 코딩을 할 수 있다는 장점이 있습니다. 무료로 사용이 가능하지만 연속 연결 시간은 최대 90분, 하루 이용 시간은 12시간이라는 제한이 있어서 너무 오래 걸리는 작업은 적합하지 않을 수 있습니다. Co-lab 접속하기 https://colab.research.google.com/notebooks/welcome.ipynb 위의 링크를 통해 접속한 후, 구글 아이디로 로그인 -> 파일 - 새 노트를 클릭하여 Co-lab 구동 시작 이외에도 포털사이트에서 구글 코랩을 검색하여 접속하거나, 구글 드라이브에서 만들기 - 더 보기 - Google Colaboratory를 클릭해서 접속할 수도 있습니다. 이렇게 생성한 Co-lab 파일은 이후 구글 드라이브(내 드라이브 - Colab Notebooks)에서 확인이 가능합니다. Co-lab 파일명 변경하기 실행된 Co-lab 파일의 왼쪽 상단에 파일명을 클릭하면 변경이 가능합니다. (보통 처음 생성되는 파일은 Untitled_.ipynb 이름으로 생성됩니다.) 다른 방법으로는, 구글 드라이브에 들어가서 바꾸고자 하는 파일을 클릭 후, 상단 메뉴바의 오른쪽에 위치한 세로 점 세 개 버튼을 누르고 이름 바꾸기를 클릭하여 변경할 수 있습니다. 4. 크롬 브라우저 설치하기 크롬 브라우저 설치하기 웹스크래핑을 위해 크롬 브라우저를 설치합니다. 다른 브라우저도 가능하지만 본 저서에서는 크롬으로 진행할 예정이기 때문에 크롬 브라우저를 설치해 줍니다. 1) 직접 아래의 url로 접속 https://www.google.com/chrome/ 2) 포털사이트에서 '크롬 브라우저' or '크롬 브라우저 설치'를 검색하여 구글 크롬 사이트로 접속 열리는 다음과 같은 크롬 홈페이지에서 'Chrome 다운로드'버튼 클릭하여 설치 파일을 다운로드합니다. 다운로드한 설치 파일을 실행하여 설치를 진행합니다. 02. 파이썬 기초 이 챕터에서는 먼저 파이썬과 친해지기 위해 기초 문법에 대해 학습하겠습니다. 변수와 자료형, 연산자, 조건문 등 파이썬을 시작하는 데 있어 필수적인 개념들을 다룰 것입니다. 이 챕터는 이론 설명뿐만 아니라 실용적인 예제를 포함하고 있습니다. 단순히 이론을 읽고 넘어가는 것보다 실제로 코드를 작성하며 개념을 체화하는 것이 훨씬 더 효과적이기 때문에 예제 코드들을 그냥 눈으로 보기보다는 직접 똑같이 따라 하며 실행해 보는 것을 권장합니다. 이 책에 대한 학습을 마친 후 진정으로 파이썬으로 업무 자동화를 하기 위해서는 단순히 책을 따라 하고 끝나는 것이 아니라, 책의 예제 코드를 가지고 각자의 업무 환경에 맞춰 적절하게 코드를 추가하고 변형해야 합니다. 그렇게 하기 위해서는 기본적인 문법과 도구들에 대한 충분한 이해가 바탕이 되어야 합니다. 이 챕터를 통해 기초의 틀을 탄탄히 세워서 뒤에 이어질 복잡한 코드의 세계로 넘어갈 준비를 하시길 바랍니다. 02-00. 기본 작성법 주석 주석은 프로그램 코드에서 사람에게 의미 있는 설명이나 메모를 추가하는 것입니다. 주석은 실제로 실행되는 코드에는 영향을 주지 않으며, 코드를 이해하고 사용하는 개발자에게 도움을 주기 위해 존재합니다. 파이썬에서 주석은 # 기호로 시작합니다. # 기호 뒤의 모든 내용은 파이썬 인터프리터에 의해 무시되고 코드 실행에 영향을 주지 않습니다. 예를 들어, 다음과 같이 코드에 주석을 추가할 수 있습니다: # 이것은 주석입니다. 프로그램 실행에 영향을 주지 않습니다. # 아래 코드는 두 정수를 더하는 예시입니다. x = 5 # 변수 x에 정숫값 5를 할당합니다. y = 10 # 변수 y에 정숫값 10을 할당합니다. result = x + y # x와 y를 더한 값을 result 변수에 할당합니다. print("결과:", result) # 결과를 출력합니다. 위의 코드에서 주석은 # 기호로 시작하며, 주석 내용은 코드에 대한 설명이나 메모입니다. 주석은 프로그램 실행에 영향을 주지 않기 때문에 코드를 이해하고 수정하는 데 도움이 됩니다. 위의 코드처럼 주석이 짧을 경우 # 기호를 사용하여 뒤에 내용을 입력하면 되지만, 여러 줄의 코드를 주석 처리해야 하는 경우 모든 행에 # 기호를 적지 않고 다음의 방법으로 여러 줄을 한 번에 주석 처리 가능합니다. 시작 지점에 ''' (작은따옴표 3개) 또는 """ (큰따옴표 3개)를 사용한 후, 주석이 끝난 부분에 다시 ''' 또는 """를 사용합니다. 주석을 시작할 때 사용했던 기호와 동일한 기호를 반복하여 종료합니다. 주의할 점은 여러 줄 주석 내에서의 코드는 주석으로 처리되기 때문에 실제로는 실행되지 않습니다. 따라서 주석이 끝난 이후에 원하는 코드를 작성해야 합니다. ''' 이 부분은 여러 줄 주석입니다. print("주석 내의 코드") # 이 코드는 주석 처리됩니다. ''' print("주석 이후의 코드") # 주석이 끝난 이후의 코드입니다. 위의 코드에서 여러 줄 주석은 '''로 시작하여 '''로 종료되었습니다. 주석 내의 코드는 주석 처리되기 때문에 실행되지 않고, 주석이 끝난 이후의 코드가 실행됩니다. 주석은 코드에 대한 설명 외에도 코드를 임시로 비활성화하거나, 코드의 일부를 빠르게 주석 처리하여 테스트하는 등의 용도로 활용할 수 있습니다. 개발자들은 주석을 사용하여 코드를 문서화하고 다른 사람과의 협업 시에 코드를 이해하기 쉽게 만들 수 있습니다. 한 행에 여러 문장 작성하기 파이썬에서는 보통 한 행에 한 개의 문장을 쓰지만 필요에 따라 한 행에 여러 문장을 작성할 수 있습니다. 이러한 방식을 사용하면 코드를 간결하게 작성할 수 있습니다. 한 행에 여러 문장을 작성할 때는 문장 사이에 세미콜론(;)을 사용하여 구분합니다. 세미콜론은 문장의 끝을 나타내는 역할을 하며, 한 행 안에서 여러 문장을 구분하는 용도로 사용됩니다. x = 1; y = 2; z = x + y 위의 코드는 한 행에 세 개의 문장을 작성한 예시입니다. 첫 번째 문장은 변수 x에 정수 1을 할당하고, 두 번째 문장은 변수 y에 정수 2를 할당하며, 세 번째 문장은 변수 z에 x + y의 값을 할당합니다. 한 행에 여러 문장을 작성하는 것은 코드를 간결하게 만들 수 있지만, 가독성에 영향을 줄 수 있습니다. 따라서 한 행에 여러 문장을 작성할 때는 코드의 가독성을 고려하여 적절하게 사용하는 것이 좋습니다. 한 문장을 여러 행에 작성하기 위의 내용과는 반대로 한 문장을 여러 행에 나눠서도 작성할 수 있습니다. 이를 통해 긴 문장을 여러 줄에 걸쳐 작성하거나 가독성을 높일 수 있습니다. 한 문장을 여러 행에 작성할 때는 문장을 나누는 지점에서 줄 바꿈을 하면 됩니다. 파이썬은 문장이 줄 바꿈 될 때마다 문장이 계속된다는 것을 인식합니다. 줄 바꿈을 하는 방법에는 여러 가지가 있습니다. 가장 간단한 방법은 문장을 나누는 지점에서 줄 끝에 백슬래시(\)를 추가하는 것입니다. 백슬래시는 줄 바꿈을 의미하는 특수 문자로, 파이썬에게 문장이 계속된다는 것을 알려줍니다. 예를 들어, 다음과 같이 한 문장을 여러 행에 나눠서 작성할 수 있습니다: 변수 = 값 1 + \ 값 2 + \ 값 3 위의 예시에서는 한 문장을 세 줄에 걸쳐 작성하였습니다. 줄 바꿈 할 때마다 백슬래시를 사용하여 문장이 계속된다고 알려주었습니다. 따라서 변수에는 값 1 + 값 2 + 값 3의 결과가 할당됩니다. 또 다른 방법으로는 괄호((), [], {})를 사용하여 문장을 묶어줄 수도 있습니다. 파이썬은 괄호 안에 있는 문장들을 한 문장으로 인식하므로, 여러 줄에 걸친 문장을 괄호로 묶으면 한 문장으로 처리됩니다. 예를 들어, 다음과 같이 괄호를 사용하여 한 문장을 여러 행에 나눠서 작성할 수 있습니다: 변수 = (값 1 + 값 2 + 값 3) 위의 예시에서는 괄호로 묶여 있는 세 개의 줄이 한 문장으로 처리됩니다. 따라서 변수에는 값 1 + 값 2 + 값 3의 결과가 할당됩니다. 들여쓰기 파이썬에서 들여 쓰기(indentation)는 코드 블록의 시작과 끝을 표시합니다. 일정한 공백(스페이스 또는 탭)을 사용하여 구현되는데, 일반적으로는 스페이스 4개를 사용하는 방법이 가장 널리 사용되고 있습니다. 코드 블록은 일련의 문장들을 함께 그룹화하는 데 사용되는 구조로, 조건문(if 문, 반복문 등)이나 함수 정의 등에서 자주 사용됩니다. 들여 쓰기는 코드 블록의 시작을 표시하기 위해 사용되며, 동일한 블록에 속하는 코드들은 동일한 수준으로 들여 쓰기를 합니다. 즉, 들여쓰기 수준이 같은 코드들은 동일한 코드 블록에 속하며, 들여쓰기 수준이 다른 코드는 서로 다른 코드 블록에 속합니다. 예를 들어, if 문을 사용하여 조건에 따라 코드 블록을 실행하는 경우 다음과 같이 들여 쓰기가 사용됩니다. if 조건: # 조건이 참일 경우 실행되는 코드 블록 문장 1 문장 2 문장 3 # if 문 블록 종료 다음 코드... 위의 코드에서 if 문의 조건이 참이면 들여 쓰기 된 블록 안의 문장들이 실행됩니다. 들여쓰기 수준이 줄어드는 부분을 보면 if 문의 블록이 끝나는 것을 알 수 있습니다. 들여 쓰기를 잘못 사용하면 오류가 발생할 수 있으므로, 파이썬에서는 일관된 들여 쓰기를 유지해야 합니다. 02-01. 변수와 자료형 Ⅰ 변수 변수는 값을 저장하기 위해 사용되는 "상자"나 "그릇"으로 생각할 수 있습니다. 이 "상자"는 특정한 이름을 가지고 있고, 그 안에는 값을 담을 수 있습니다. 예를 들어, 우리가 숫자 10을 기록하기 위해 "number_box"라는 변수를 만들고 싶다면, 다음과 같이 변수를 생성할 수 있습니다. number_box = 10 위의 코드는 number_box라는 이름을 가진 변수를 만들고, 그 안에 10이라는 값을 저장하는 것입니다. 이제 우리는 number_box라는 변수를 사용하여 해당 값을 나중에 참조할 수 있습니다. 변수는 이름을 통해 값을 식별하고 사용할 수 있습니다. 이름은 개발자가 지정할 수 있으며, 변수 이름은 일반적으로 소문자와 언더 스코어 _로 구성됩니다. 예를 들어, 다음과 같이 여러 개의 변수를 만들 수 있습니다. age = 25 name = "유재석" is_student = True 위의 코드는 age, name, is_student라는 세 개의 변수를 만드는 예시입니다. age 변수에는 정숫값 25가, name 변수에는 문자열 "유재석"이, is_student 변수에는 참을 나타내는 부울 값 True가 할당되었습니다. 이렇게 변수를 사용하면 프로그램에서 데이터를 저장하고 나중에 필요할 때 사용할 수 있습니다. 예를 들어, 위의 변수들을 사용하여 다음과 같이 출력할 수 있습니다. print("이름:", name) print("나이:", age) print("학생 여부:", is_student) 결과는 다음과 같이 출력될 것입니다. # 결괏값 이름:<NAME> 나이: 25 학생 여부: True 파이썬에는 함수라는 것이 있고 수학에서처럼 어떤 기능을 수행하는 역할을 한다고 이해하면 됩니다. 함수에 대해서는 뒤에 '02-04. 함수와 클래스'에서 자세히 다루겠지만 그전에 먼저 함수를 사용하여 이해가 필요한 경우에는 해당 함수에 대해서 간략하게 설명하겠습니다. 앞에서 사용한 print()라는 함수는 자료를 출력할 때 사용합니다. print()의 괄호 안에 출력하고 싶은 내용을 입력하면 값을 화면에 출력하며 쉼표(,)를 사용해 여러 값을 출력할 수 있습니다. 위의 코드에서 print("이름:", name)과 같이 사용하였는데 "이름:"처럼 큰따옴표(")를 사용하면 따옴표 안에 있는 내용을 그대로 출력합니다. 그 뒤에 name은 따옴표 없이 입력되었는데 그러면 해당 문자열은 변수라고 인식되어 변수에 할당된 값을 출력합니다. 따라서 print("이름:", name)으로 출력된 결괏값이 이름:<NAME>이 되는 것입니다. 다시 변수로 돌아와서 변수에 대해 더 알아보겠습니다. 변수는 값이 변경될 수 있습니다. 새로운 값을 변수에 할당하면 이전 값은 대체됩니다. age = 30 print("나이:", age) # 결괏값 나이: 30 위의 코드에서 age 변수에 30이라는 새로운 값을 할당하였고, 그 후에 age 변수를 출력하면 값이 변경된 것을 확인할 수 있습니다. 이렇게 변수를 사용하면 데이터를 저장하고 조작할 수 있으며, 코드의 가독성과 재사용성을 높일 수 있습니다. 변수에 할당한 데이터의 유형(자료형)에 따라 변수의 유형이 정해집니다. age 변수에는 30이라는 숫자를 할당했기 때문에 변수 age는 숫자형 변수, name이라는 변수에는<NAME>이라는 문자열을 넣었으므로 변수 name은 문자열 자료형 변수입니다. 만약 변수에 기존에 할당한 유형이 아닌 다른 자료형을 넣으면 그 순간 변수의 유형도 변경됩니다. 변수명은 숫자로 시작할 수 없으며, 밑줄 이외의 기호는 사용할 수 없습니다. 또한 다음과 같이 파이썬에서 특정 목적을 위해 예약되어 있는 단어들(예약어)들은 변수명으로 사용할 수 없습니다. and del from None True as elif global nonlocal try assert else if not while break except import or with class False in pass yield continue finally is raise def for lambda return 위의 예제 코드에서도 나이를 변수에 할당할 때는 변수명을 'age'로, 사람의 이름을 할당할 때는 변수명을 'name'으로 만든 것처럼, 변수명을 지을 때는 실제 해당 변수에 할당되어 있는 자료가 무엇인지를 알아보기 쉬운 변수명으로 지정해 주어야 복잡한 코드를 작성할 때 변수를 쉽게 식별할 수 있습니다. 자료형 파이썬에서 자료형은 값의 종류 또는 유형을 나타냅니다. 자료형은 데이터를 다루고 조작하는 데 필요한 규칙과 연산을 정의합니다. 파이썬은 여러 가지 자료형을 제공하며, 각각의 자료형은 특정한 유형의 값을 저장하고 처리하는 데 사용됩니다. 주요 파이썬 자료형을 하나씩 살펴보겠습니다. 1. 숫자 파이썬의 숫자 자료형에는 정수형(int)과 실수형(float)이 있습니다. 1) 정수 (int) 정수 자료형은 숫자에 소수점이 없는 양의 정수(양수)와 음의 정수(음수) 값을 저장합니다. 예를 들어, 10, -5, 0과 같은 정수는 정수 자료형으로 표현됩니다. 다음은 10을 변수 x에 할당하는 예시입니다. x = 10 # x 변수에 정숫값 10을 할당 그러면 위와 같이 값이 할당된 x 변수의 자료형을 한 번 확인해 보겠습니다. type(x) 아래와 같이 type() 함수를 사용하여 자료형을 확인할 수 있습니다. # 결괏값 int 위의 코드를 실행하면 해당 변수의 자료형이 int(정수형)라고 출력됩니다. 2) 실수 (float) 실수 자료형은 소수점을 포함하는 숫자 값을 저장합니다. 예를 들어, 3.14, -0.5, 2.0과 같은 실수는 실수 자료형으로 표현됩니다. y = 3.14 # y 변수에 실숫값 3.14를 할당 type(y) # 결괏값 float 연산자 숫자 자료형끼리는 연산도 가능합니다. 숫자 자료형으로 할 수 있는 몇 가지 연산자를 알아보겠습니다. 연산자 의미 예시 결괏값 a + b a와 b 더하기 5 + 3 8 a - b a에서 b 빼기 5 - 3 2 a * b a와 b 곱하기 5 * 3 15 a / b a를 b로 나누기 5 / 3 1.6666666666666667 a // b a를 b로 나눴을 때의 몫 5 // 3 1 a % b a를 b로 나눴을 때의 나머지 5 % 3 2 a ** b a의 b 거듭제곱 5 ** 3 125 우리가 흔히 알고 있는 연산자와 유사하기 때문에 숫자 자료형의 연산자를 이해하기는 어렵지 않습니다. 여기서 기억할 점은 기본적으로 정수끼리의 연산은 결괏값도 정수로 나오고 실수끼리의 연산은 결괏값도 실수로 나오지만, 나눗셈 연산의 결괏값은 항상 실수(float)로 반환됩니다. 정수끼리 나누기도 실수 연산으로 처리가 되기 때문에, 4 / 2를 실행했을 때 2가 반환되는 것이 아니라 2.0이 반환됩니다. 만약 정수와 실수를 혼합하여 연산할 경우에는 결괏값으로 실수가 반환됩니다. 또한 연산자가 여러 개일 경우에는 연산자의 우선순위에 따라 연산이 수행됩니다. 우선순위 역시 우리가 알고 있는 숫자 연산 규칙과 유사하여 1) 괄호() 안을 먼저 계산하고, 그다음 2)<NAME> 계산, 3) 곱셈 나눗셈 계산, 마지막으로 4) 덧셈과 뺄셈 계산을 진행합니다. 연산자의 우선순위가 같을 때는 왼쪽에서 오른쪽으로 연산이 진행됩니다. 2. 문자열 (str) 문자열 자료형은 말 그대로 문자가 나열된 문자의 집합으로, 파이썬에서는 작은따옴표(')나 큰따옴표(")로 둘러싼 형태로 표현합니다. 예를 들어, "Hello, World!"나 'Python'과 같은 문자열은 문자열 자료형으로 표현됩니다. name = "유재석" # name 변수에 문자열 "유재석"을 할당 type(name) # 결괏값 str 문자열 "유재석"을 name 변수에 할당한 후 type() 함수로 확인해 보면 str(문자열)이 반환됩니다. 만약 문자열 안에 따옴표를 써야 할 경우에는 문자열에 포함되지 않는 따옴표의 종류를 사용해서 문자열을 표현합니다. '"안녕"이라고 소녀가 말했다.' "What's it?" 위와 같이 문자열에 큰따옴표(")를 써야 할 경우에는 작은따옴표(')로 문자열을 표시하고, 반대로 문자열에 작은따옴표를 쓸 경우에는 큰따옴표로 문자열 자료형을 표현합니다. 만약 큰따옴표와 작은따옴표 모두 문자열에 사용해야 하는 경우라면, 이스케이프 코드를 사용하거나 문자열 전체를 삼중 큰따옴표(""")나 삼중 작은따옴표(''')로 감싸줍니다. 이스케이프 코드는 파이썬에서 특별한 의미를 나타내거나 어떤 기능을 하기로 약속되어 있는 문자나 기호를 다른 의미로 사용하기 위한 특수 코드입니다. 즉, 큰따옴표나 작은따옴표를 원래 약속되어 있던 기능(문자열 표시 기능) 대신 문자열로 사용하기 위해 이스케이프 코드를 사용하는 것입니다. 문자열에서 따옴표를 사용하기 위한 이스케이프 코드는 큰따옴표나 작은따옴표 앞에 (백슬래시)를 붙이면 됩니다. 즉, \' 또는 \"로 사용하면 됩니다. 아래는 큰따옴표로 문자열 표시를 하면서 이스케이프 코드를 사용하여 문자열 안에도 큰따옴표를 사용하는 예시 코드입니다. "\"안녕\"이라고 소녀가 말했다." 이스케이프 코드를 사용하지 않고 삼중 큰따옴표(""")나 삼중 작은따옴표(''')를 사용하여 문자열 표시를 하는 방법도 있습니다. string = ''' "안녕"이라고 소녀가 말했다. '무슨 뜻이지?' 소년은 마음속으로 생각했다. ''' print(string) # 결괏값 "안녕"이라고 소녀가 말했다. '무슨 뜻이지?' 소년은 마음속으로 생각했다. 위와 같이 삼중 따옴표(''' 또는 """)를 사용할 경우에는 줄 바꿈 등 그 안에 포함된 문자열의 형태까지 그대로 저장하기 때문에, 여러 행의 문자열을 그대로 입력하고 싶을 때에도 삼중 따옴표를 사용하면 편리합니다. 위의 예시에서 print()로 출력된 결괏값의 첫 줄과 마지막 줄에 빈 줄이 반환된 이유는 문자열 안에 줄 바꿈으로 공백 라인이 포함되어 있기 때문입니다. 문자열은 공백까지 포함하며 문자열의 가장 앞이나 뒤에 공백이 있는 경우에도 그 공백까지 문자열로 인식합니다. 따라서 아래에서 다룰 문자열 연산자로 문자열끼리 연산을 할 때에도 공백까지 포함하여 연산됩니다. 연산자 문자열 자료형도 연산이 가능합니다. 문자열 자료형에서 사용할 수 있는 주요 연산자는 다음과 같습니다. 연산자 의미 예시 결괏값 a + b 문자열 a와 문자열 b를 연결하기 'Hello' + 'World' 'HelloWorld' a * b 문자열 a를 숫자 b 만큼 반복하기 'Hello' * 3 'HelloHelloHello' a in b 문자열 a가 문자열 b에 포함 여부 확인 (True/False 값 반환) 'ello' in 'Hello' 'True' a not in b 문자열 a가 문자열 b에 미포함 여부 확인 (True/False 값 반환) 'aaa' in 'Hello' 'True' a ==, !=, <, <=, >, >= b 문자열 a와 문자열 b를 사전 순서로 비교 (True/False 값 반환) 'apple' < 'banana' 'True' 여기서 다룬 연산자 외에도 파이썬 문자열을 다루는 여러 방법이 있습니다. 데이터 관련 업무를 파이썬으로 자동화할 때 문자열을 다양한 방식으로 처리해야 하는 경우가 많기 때문에, 이는 뒤의 '02-09. 문자열 처리' 챕터에서 더 자세히 알아보겠습니다. 3. 부울 (bool): 부울 자료형은 논리적으로 참(True) 또는 거짓(False)을 표현하는 자료형입니다. 주로 조건 문과 논리 연산에서 사용됩니다. True와 False는 따옴표 없이 사용하며, 대소문자를 구분하므로 소문자 true나 false로는 사용하지 않습니다. is_valid = True type(is_valid) # 결괏값 bool 위와 같이 부울 값 True를 할당한 변수 is_valid의 자료형을 type() 함수로 확인해 보면 bool(부울 자료형)이라고 출력되는 것을 볼 수 있습니다. 연산자 부울 자료형과 함께 사용하는 연산자는 논리 연산자와 비교 연산자입니다. 논리 연산자에는 논리곱(and), 논리합(or), 논리 부정(not)이 있으며, 비교 연산자는 등호와 부등호 등을 사용하여 비교를 수행하는 연산자입니다. 비교 연산자는 비교를 하여 결괏값이 참인지 거짓인지를 확인하기 때문에 항상 결괏값이 True 또는 False로 반환됩니다. 아래는 부울 자료형을 다룰 때 기본적으로 사용하는 주요 논리 연산자와 비교 연산자입니다. 연산자 의미 예시 결괏값 a and b a와 b 두 값이 모두 참일 경우에만 참을 반환 True and False False a or b a와 b 두 값 중 하나라도 참이면 참을 반환 True or False True not a a가 참이면 거짓을 반환, 거짓이면 참을 반환 not True False a ==, !=, <, <=, >, >= b a와 b를 비교 (True/False 값 반환) True == False False 연산 규칙에 따라 괄호가 있을 경우에는 괄호부터, 그다음에는 왼쪽에서 오른쪽 순서로 연산을 수행합니다. 여러 논리 연산자를 수행해야 하는 경우에는 not > and > or 순서로 연산을 진행합니다. 만약 논리 연산자와 비교 연산자가 함께 사용될 경우에는 비교 연산자가 논리 연산자보다 높은 우선순위를 가집니다. 따라서 비교 연산자를 수행한 후에 논리 연산자를 수행합니다. x = 5 y = 10 z = 20 result = (x < y or x > z) and (y == 10) print(result) # 결괏값 True 위의 예시를 연산 순서대로 살펴보면 먼저 괄호 안에 있는 연산을 먼저 수행합니다. 괄호 안에는 논리 연산자와 비교 연산자가 함께 있기 때문에 우선순위에 따라 비교 연산이 먼저 진행됩니다. 괄호 안의 1차 연산은 다음과 같습니다. ① x < y : 5 < 10을 연산하여 결괏값 True를 반환 ② x > z : 5 > 20을 연산하여 결괏값 False를 반환 ③ y == 10 : 10 == 10을 연산하여 결괏값 True를 반환 그다음, 첫 번째 괄호 안에서 ①의 결괏값과 ②의 결괏값을 가지고 논리합(or) 연산을 진행합니다. ④ (x < y or x > z)에서 or 연산: (True or False)를 연산하여 결괏값 True를 반환 마지막으로 ④의 결괏값과 ③의 결괏값을 가지고 논리합(and) 연산을 수행합니다. ⑤ (x < y or x > z) and (y == 10)에서 and 연산: (True) and (True)를 연산하여 결괏값 True를 반환 따라서 위의 연산을 진행한 result 변수의 최종 값은 True가 됩니다. 02-02. 자료형 Ⅱ 4. 리스트 (list) 지금까지 알아본 숫자, 문자열, 부울 자료형이 값을 하나씩 가지는 자료형이었다면, 앞으로 알아볼 자료형들은 여러 값을 묶어서 다룰 수 있는 일종의 집합 형태의 자료형입니다. 먼저 리스트에 대해서 알아보겠습니다. 리스트도 여러 값을 하나의 변수에 저장합니다. 저장할 때는 대괄호 []를 사용하여 이 자료가 리스트라는 것을 표현하며, 리스트의 각 요소는 쉼표(,)로 구분합니다. fruits = ["사과", "바나나", "오렌지"] print(fruits) # 결괏값 ['사과', '바나나', '오렌지'] 위의 예시처럼 리스트 자료형은 print로 출력했을 때 결괏값에 [] 대괄호가 포함되어 이 자료가 리스트라는 것을 나타냅니다. type() 함수를 실행하면 list라고 반환하는 것을 확인할 수 있습니다. 리스트에 넣을 수 있는 데이터는 숫자, 문자열, 부울 등 그 어떤 데이터 타입이든 리스트의 요소로 넣을 수 있습니다. 또 다른 리스트 자체를 리스트의 요소로 넣을 수도 있고 빈 리스트 []도 넣을 수 있습니다. food = [ ['사과', '바나나', '오렌지'], ['우유', '치즈', '요구르트' ], [ ] ] 이렇게 리스트 안에 리스트를 요소로 넣어 여러 리스트를 중첩한 경우, 이를 중첩한 개수에 따라 이중 리스트, 삼중 리스트라고 부르기도 합니다. 리스트가 포함하고 있는 요소의 개수를 확인하기 위해서는 len() 함수를 이용합니다. len() 함수는 리스트 외에도 뒤에서 배울 튜플, 세트, 딕셔너리 등 요소를 여러 개 가지고 있는 자료의 길이(요소의 개수)를 반환하는 함수입니다. len() 괄호 안에 확인하고 싶은 자료를 넣어줍니다. 위에서 생성한 food 리스트의 길이를 확인해 보겠습니다. len(food) # 결괏값 리스트 food의 요소의 개수로 3을 반환합니다. food 리스트에 포함된 각각의 리스트들을 하나의 요소로 인식한다는 것을 확인할 수 있습니다. 연산자 리스트 자료형도 연산이 가능합니다. 연산의 방식은 문자열 자료형과 유사하게 두 리스트를 연결하거나 리스트를 반복하여 새로운 리스트를 생성합니다. 연산자 의미 예시 결괏값 a + b 리스트 a와 리스트 b를 연결하기 [ '사과', '바나나' ] + [ '오렌지' ] ['사과', '바나나', '오렌지'] a * b 리스트 a를 숫자 b 만큼 반복하기 [ '사과', '바나나' ] * 2 ['사과', '바나나', '사과', '바나나'] 위의 연산 결과에서도 알 수 있듯 리스트는 요소의 중복을 허용하기 때문에 같은 값을 리스트에 여러 번 저장할 수 있습니다. 리스트 인덱싱 리스트의 각 요소는 순서를 가지고 있으며 그 순서가 변경되지 않기 때문에 인덱스(순서 번호)를 사용하여 요소를 가져오거나 바꿀 수 있습니다. 인덱스는 0부터 시작하기 때문에 첫 번째 요소의 인덱스는 0이며, 요소의 개수가 총 n 개인 리스트에서 마지막 요소의 인덱스는 n-1이 됩니다. 인덱스(i)를 사용하여 list[i]로 리스트의 요소에 접근합니다. fruits = ["사과", "바나나", "오렌지"] fruits[0] # 결괏값 '사과' 위의 예시에서 fruits[0]으로 리스트의 첫 번째 요소인 '사과'를 반환하였습니다. 마지막 요소를 반환하고자 한다면 fruits[2]를 실행할 수도 있지만, 다른 방법으로 음수(-)를 사용할 수도 있습니다. 인덱스가 음수인 음수 인덱싱은 요소를 가리키는 순서가 반대가 됩니다. 다만 -0은 없기 때문에 가장 마지막 요소를 가리키는 음수 인덱스는 -1, 그 바로 앞 요소는 -2가 됩니다. fruits[-2]를 실행하여 결과를 확인해 보겠습니다. fruits[-2] # 결괏값 '바나나' 뒤에서 두 번째 요소인 '바나나'가 반환된 것을 확인할 수 있습니다. 만약 리스트 안에 있는 리스트(이중 리스트)의 요소를 가지고 오려면 인덱스를 이중으로 중첩하여 원하는 요소를 가지고 올 수 있습니다. 아래의 예시에서 '요구르트'를 추출해 보겠습니다. food = [ ['사과', '바나나', '오렌지'], ['우유', '치즈', '요구르트' ], [ ] ] food[1][-1] # 결괏값 '요구르트' 바깥쪽 리스트(food)의 두 번째 요소[1]에 먼저 접근한 다음, 안쪽 리스트(['우유', '치즈', '요구르트' ])에서 [-1]로 가장 마지막 요소 '요구르트'에 접근합니다. 이와 같은 방식으로 중첩된 리스트의 요소에도 접근할 수 있습니다. 리스트 요소 변경하기 만약 리스트에 특정 요소를 변경하고자 한다면, 이렇게 인덱스로 요소에 접근하여 해당 요소를 다른 값으로 변경할 수 있습니다. 위의 예시에서 두 번째 요소를 '감자'로 변경해 보겠습니다. food[1] = '감자' print(food) # 결괏값 [['사과', '바나나', '오렌지'], '감자', []] food[1]으로 리스트의 두 번째 요소에 접근하여 해당 요소를 '감자'라는 문자열 데이터로 변경하였습니다. 리스트 요소 삭제하기 요소를 삭제할 때도 인덱스로 접근하여 삭제할 수 있습니다. 아래는 두 번째 요소를 삭제하는 예시입니다. del food[1] print(food) # 결괏값 [['사과', '바나나', '오렌지'], []] 위에서 변경했던 두 번째 요소 '감자'가 삭제된 것을 확인할 수 있습니다. 리스트의 요소를 삭제할 경우 리스트는 남아있는 요소들의 개수에 따라 인덱스를 다시 설정하게 됩니다. 따라서 위의 예시에서 빈 리스트는 원래 세 번째 요소였지만 "감자"가 삭제된 후에는 두 번째 요소로 재설정됩니다. 리스트 슬라이싱 앞에서 학습한 인덱싱으로는 리스트에서 하나의 요소에 접근할 수 있었습니다. 만약 요소 하나가 아닌 특정 범위를 가지고 오려면 인덱싱이 아닌 슬라이싱을 사용해야 합니다. 슬라이싱은 리스트의 일부분을 잘라내어 가져오는 기능으로, 시작 인덱스부터 종료 인덱스까지의 범위를 가지고 와서 새로운 리스트를 만듭니다. 기본적으로는 list[start:end]의<NAME>으로 범위를 지정하여 슬라이싱합니다. 여기서 유의할 점은 start에는 가져올 범위의 시작 인덱스를 입력하지만, end에는 가져올 범위의 마지막 인덱스가 아닌 그다음 인덱스를 입력합니다. end는 가져올 범위에 포함되지 않고 그 바로 앞 인덱스까지 가져오기 때문에 원하는 범위의 마지막 인덱스의 바로 다음 인덱스를 end에 입력해 줍니다. 만약 start를 생략하면 리스트의 첫 번째 요소부터 범위가 시작되고, 반대로 end를 설정하면 리스트의 마지막 요소까지로 끝나는 범위가 설정됩니다. 따라서 start와 end 둘 다 생략할 경우에는 리스트의 처음부터 끝까지 범위가 설정되어 가지고 오고자 하는 리스트의 모든 요소를 갖는 새로운 리스트를 반환합니다. 다음은 0부터 9까지 숫자를 요소로 갖는 리스트에서 2부터 6까지의 숫자를 슬라이싱 하는 예시입니다. number = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ] slice1 = number[2:7] print(slice1) # 결괏값 [2, 3, 4, 5, 6] 슬라이싱에서도 마찬가지로 음수 인덱스를 사용할 수도 있습니다. 위의 예시에서 number[2:7] 대신 number[2:-3]으로 슬라이싱해도 동일한 결과가 실행됩니다. 슬라이싱을 할 때 간격을 지정해서 요소를 건너뛰며 가져오는 것도 가능합니다. list[start:end:step]의 형태로 가장 뒤에 건너뛸 간격을 입력하면 됩니다. 예를 들어 위의 예시에서 간격을 2로 넣어보겠습니다. number = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ] slice2 = number[2:7:2] print(slice2) # 결괏값 [2, 4, 6] number[2:7:2]로 세 번째 요소부터 일곱 번째 요소까지 가지고 오되 2개씩 건너뛰며 가지고 옵니다. 리스트 메서드 파이썬에서는 문자열, 리스트 등 각 자료형마다 자신만의 고유한 기능, 작업들을 수행할 수 있는데, 이러한 기능들을 메서드라고 부릅니다. 메서드를 사용하는 방법은 해당 데이터 뒤에 온점(.)을 붙이고 메서드의 이름을 적어서 실행합니다. 즉, 리스트에서 메서드를 사용하고자 한다면 list.method() 형태가 됩니다. 리스트에서 주로 사용하는 메서드들을 살펴보겠습니다. 1) append() 리스트의 끝에 요소를 하나씩 추가합니다. append(item)의 형태로 괄호 안에 리스트에 넣고자 하는 데이터를 입력합니다. fruits = [ '사과', '바나나' ] fruits.append('오렌지') print(fruits) # 결괏값 ['사과', '바나나', '오렌지'] 리스트에 요소를 추가하는 것도 인덱스[i]로 가능할 것 같지만, 기본적으로 인덱싱은 존재하는 인덱스에 대해서만 가능합니다. 즉, 없는 인덱스에 접근하라고 할 경우에는 오류가 발생합니다. 예를 들어 리스트의 총 길이가 3인 인덱스에서 리스트[3]을 실행하면 오류를 반환합니다. 따라서 새로운 요소를 추가할 때는 인덱스를 사용하지 않고 append()나 뒤에서 배울 insert(), extend()와 같은 메서드를 사용합니다. 2) insert() insert() 메서드는 지정한 인덱스 위치에 요소을 삽입합니다. 리스트의 끝이 아닌 특정한 지점에 항목을 추가하고 싶을 때 사용합니다. insert(index, item)의<NAME>으로 괄호 안에 지정하고자 하는 위치(인덱스)와 넣고자 하는 데이터를 입력합니다. fruits = [ '사과', '바나나' ] fruits.insert(1, '파인애플') print(fruits) # 결괏값 ['사과', '파인애플', '바나나'] 3) extend() extend() 메서드는 리스트의 끝에 여러 요소를 추가합니다. extend() 메서드로 입력할 수 있는 자료형은 리스트나 뒤에서 배울 튜플과 같이 요소를 여러 개 가지고 있어서 하나씩 접근하여 반복 작업이 가능한(iterable) 형태의 자료형입니다. extend() 메서드는 이러한 iterable 한 형태의 자료형을 전달받아 자료의 여러 요소를 각각 하나씩 리스트에 추가하는<NAME>으로 작동합니다. 예시를 통해 살펴보겠습니다. fruits = [ '사과', '바나나' ] fruits.extend(['딸기', '망고']) print(fruits) # 결괏값 ['사과', '바나나', '딸기', '망고'] 실행된 결과를 보면 extend()로 추가해 준 리스트 ['딸기', '망고']의 요소들이 각각 fruits의 원소들로 하나씩 추가된 것을 알 수 있습니다. 동일한 리스트를 위에서 학습했던 append() 메서드로 추가해 보겠습니다. fruits = [ '사과', '바나나' ] fruits.append(['딸기', '망고']) print(fruits) # 결괏값 ['사과', '바나나', ['딸기', '망고']] 결괏값이 다른 것을 알 수 있습니다. append()는 전달받은 데이터를 하나의 데이터로 보고 전체를 리스트의 요소로 추가합니다. 반면 extend()는 전달받은 데이터에 여러 요소가 있을 경우, 리스트에 요소들을 각각 추가합니다. 만약 요소가 하나뿐인 자료를 extend() 메서드에 전달할 경우에는 해당 요소 하나만 추가됩니다. 그러나 우리가 생각하기에는 요소가 하나라고 생각하는 자료도 extend()는 그 작동 방식 때문에 요소를 여러 개로 인식할 수 있습니다. fruits = [ '사과', '바나나' ] fruits.extend('3') fruits.extend('100') fruits.extend('파인애플') print(fruits) # 결괏값 ['사과', '바나나', '3', '1', '0', '0', '파', '인', '애', '플'] extend() 메서드는 반복 가능한 자료만 전달받기 때문에 숫자 자료형은 입력할 수 없어서 예시에서는 작은따옴표(')로 문자열로 표현하여 전달하였습니다. 위의 예시에서 보면 extend() 메서드에 전달한 값 '3', '100', '파인애플'은 모두 문자열 하나로 생각할 수 있습니다. 그러나 extend() 메서드의 입장에서는 전달받은 자료들이 모두 반복 가능한 자료이기 때문에 항목을 각각 나누어서 리스트의 요소로 입력하게 됩니다. '3'은 나눌 수 있는 항목이 없기 때문에 '3' 그대로 하나의 요소로 추가되었지만, '100'은 '1'과 '0'과 '0'으로, '파인애플'은 '파','인','애','플'로 항목들을 나눌 수 있기 때문에 문자 하나씩 나뉘어서 리스트에 추가됩니다. 위와 같은 경우에는 extend()가 아니라 append()를 사용하여야 원하는 문자열 그대로 리스트에 요소로 추가할 수 있습니다. 따라서 리스트에 요소들을 추가할 때는 최종적으로 리스트에 넣고자 하는 형태에 따라 append()나 extend()를 구분하여 사용해 주어야 합니다. 4) remove() remove() 메서드는 리스트에서 첫 번째로 나타나는 지정한 항목을 삭제합니다. remove(item)의 형태로 삭제하고자 하는 데이터의 값을 괄호() 안에 입력합니다. fruits = [ '사과', '바나나' ] fruits.remove('사과') print(fruits) # 결괏값 ['바나나'] remove()는 리스트에서 첫 번째로 나타나는 동일한 항목을 삭제하기 때문에, 리스트 안에 삭제하고자 하는 동일한 데이터가 여러 개 있다면 remove()를 여러 번 실행해야 합니다. 5) pop() pop() 메서드는 지정한 인덱스의 항목을 리스트에서 제거하고 그 항목을 반환합니다. 인덱스를 지정하지 않으면 마지막 항목이 제거되고 반환됩니다. pop(index)의 형태로 사용하여 인덱스에 해당하는 요소를 제거하고 반환하지만, pop()만 사용하면 마지막 항목을 제거하고 반환합니다. fruits = [ '사과', '바나나' ] pop1 = fruits.pop() print(pop1) print(fruits) # 결괏값 바나나 ['사과'] 6) index() index() 메서드는 지정한 항목과 일치하는 첫 번째 인덱스를 반환합니다. index(item)의 형태로 실행합니다. fruits = [ '사과', '바나나' ] idx = fruits.index('사과') print(idx) # 결괏값 7) count() count() 메서드는 count(item)의<NAME>으로 사용되는 메서드로, 리스트에서 지정한 항목의 개수를 반환합니다. fruits = [ '사과', '바나나', '사과', '사과', '바나나' ] cnt = fruits.count('사과') print(cnt) # 결괏값 8) sort() sort() 메서드는 리스트의 항목들을 정렬하는 함수입니다. 괄호 안에 아무 옵션도 설정하지 않고 sort()로 실행할 경우에는 메서드의 기본 정렬 설정대로 정렬됩니다. 리스트의 요소들이 숫자인 경우에는 작은 숫자부터 큰 숫자 순서로 정렬되고, 리스트의 요소들이 문자열인 경우에는 알파벳순, 가나다순 등 사전 순서대로 정렬됩니다. 만약 리스트 안에 숫자와 문자열, 리스트 등 여러 타입의 요소들이 혼합되어 있는 경우에 sort()를 실행하면 순서를 알 수 없기 때문에 에러가 발생합니다. fruits = [ '사과', '바나나', '파인애플', '딸기' ] fruits.sort() print(fruits) # 결괏값 ['딸기', '바나나', '사과', '파인애플'] 정렬할 때 sort()에 정렬 기준(key)과 역순 정렬(reverse) 옵션을 별도로 지정할 수도 있습니다. 위의 예시에서 정렬 기준을 문자열의 길이를 기준으로 하되 역순 정렬을 True로 설정해 보겠습니다. fruits = [ '사과', '바나나', '파인애플', '딸기' ] fruits.sort(key=len, reverse=True) print(fruits) # 결괏값 ['파인애플', '바나나', '사과', '딸기'] 문자열의 길이 순서대로 정렬하였으며, 역순 정렬을 설정하여서 문자열의 길이가 긴 것부터 순서대로 정렬이 되었습니다. 문자열의 길이가 같은 경우에는 가나다순으로 정렬되지만 위의 예시에서는 역순이기 때문에 동일한 길이인 요소들('딸기', '사과')이 가나다의 역순으로 정렬되었습니다. 9) reverse() reverse() 메서드는 리스트 요소들의 순서를 반대로 뒤집는 메서드입니다. 별도의 인자를 받지 않기 때문에 reverse() 형태로만 사용합니다. fruits = [ '사과', '바나나', '파인애플', '딸기' ] fruits.reverse() print(fruits) # 결괏값 ['딸기', '파인애플', '바나나', '사과'] 10) clear() clear() 메서드는 리스트의 모든 요소들을 삭제합니다. fruits = [ '사과', '바나나', '파인애플', '딸기' ] fruits.clear() print(fruits) # 결괏값 [] 5. 튜플 (tuple) 튜플도 리스트처럼 여러 요소를 포함하는 자료형으로 동작이나 활용법이 리스트와 유사합니다. 튜플이 리스트와 다른 점은 내부의 요소를 변경할 수 없다는 점입니다. 리스트는 처음 생성 후에 요소를 다른 값으로 수정하거나 새로운 요소를 추가, 삭제할 수 있지만 튜플은 한 번 생성한 후에는 그 내부의 요소를 변경하는 것이 불가능합니다. 그리고 리스트를 생성할 때는 대괄호([])를 사용했다면, 튜플을 생성할 때는 소괄호(())를 사용하거나 또는 소괄호 없이 쉼표로 요소를 나열함으로써 튜플을 생성합니다. tuple1 = (1, 2, 3, 4) print(tuple1) tuple2 = 3, 4, 5, 6 print(tuple2) # 결괏값 (1, 2, 3, 4) (3, 4, 5, 6) 결괏값을 보면 소괄호로 생성한 tuple1이나 소괄호 없이 나열하여 생성한 tupe2 모두 출력했을 때 동일하게 튜플형으로 반환되는 것을 확인할 수 있습니다. type()으로 자료형을 확인해도 두 경우 모두 tuple로 반환됩니다. 튜플 역시 리스트와 동일하게 어떤 자료형이든 요소로 포함할 수 있으며, 여러 자료형을 혼합하여 요소로 가질 수도 있습니다. 다만 튜플 생성 시 유의할 점은, 요소를 하나만 갖는 튜플을 생성할 때는 해당 요소 뒤에 다음 요소가 없더라도 반드시 쉼표를 입력해 주어야 합니다. 만약 쉼표를 입력하지 않을 경우에는 그냥 변수에 자료를 할당하는 것으로 간주되기 때문입니다. tup1 = (1) print(tup1) tup2 = (1, ) print(tup2) # 결괏값 (1, ) 위의 예시에서 보면 tup1은 소괄호는 사용하였지만 첫 번째 요소 뒤에 쉼표를 입력하지 않았기 때문에 튜플로 간주되지 않았습니다. 따라서 print()로 출력했을 때도 튜플이라는 소괄호 없이 숫자 1만 출력된 것을 볼 수 있습니다. 그에 반해 tup2는 첫 번째 요소 뒤에 쉼표를 입력했기 때문에 tup2는 튜플이라고 간주되었습니다. type()으로 자료형을 확인해 봐도 type(tup1)을 실행하면 int가 반환되지만 type(tup2)를 실행하면 tuple이 반환됩니다. 튜플도 리스트와 마찬가지로 len() 함수로 튜플 요소의 개수를 확인할 수 있습니다. 연산자 튜플에서도 리스트와 동일하게 연산자를 사용하여 새로운 튜플을 생성할 수 있습니다. 연산자 의미 예시 결괏값 a + b 튜플 a와 튜플 b를 연결하기 ( '사과', '바나나' ) + ( '오렌지' , ) ('사과', '바나나', '오렌지') a * b 튜플 a를 숫자 b 만큼 반복하기 ( '사과', '바나나' ) * 2 ('사과', '바나나', '사과', '바나나') 튜플 인덱싱과 슬라이싱 튜플도 리스트와 마찬가지로 요소에 순서가 부여되기 때문에 인덱스로 각각의 요소에 접근하고 슬라이싱으로 특정 부분을 가져오는 것이 가능합니다. 다음은 튜플 인덱싱과 슬라이싱의 예시 코드입니다. tuple1 = (1, 2, 3, 4) print(tuple1[2]) # 튜플 인덱싱 print(tuple1[:2]) # 튜플 슬라이싱 # 결괏값 (1, 2) 위의 코드에서 tuple1[2]로 튜플의 세 번째 요소에 접근하였으며, tuple1[:2]로 튜플의 첫 번째 요소부터 두 번째 요소까지 슬라이싱 하였습니다. 이와 같이 튜플에서도 리스트와 유사하게 인덱싱과 슬라이싱으로 요소에 접근할 수 있습니다. 하지만 튜플은 요소를 변경할 수 없기 때문에 리스트와 다르게 인덱싱을 통해 요소를 수정하거나 삭제하는 것은 불가능합니다. 만약 tuple1[2] = 8 과같이 요소를 변경하려고 하면 TypeError 오류가 발생합니다. 튜플 메서드 튜플은 요소를 변경할 수 없는 특성 때문에 리스트에 비해 사용할 수 있는 메서드의 종류가 제한적입니다. append()나 insert(), extend()처럼 요소를 추가하는 메서드나 remove(), pop(), clear()와 같이 요소를 삭제하는 메서드, 그리고 요소의 순서를 변경하는 sort()나 reverse() 메서드도 사용할 수 없습니다. 1) index() 앞서 살펴본 바와 같이 튜플도 요소에 순서가 부여되기 때문에 요소마다 인덱스를 갖게 됩니다. 따라서 index() 메서드로 주어진 데이터와 일치하는 요소들 중 첫 번째 요소의 인덱스를 반환합니다. 만약 주어진 데이터가 튜플이 없으면 오류(ValueError)가 발생합니다. t = (1, 2, 3, 2, 4, 5) print(t.index(2)) # 결괏값 2) count() 튜플에서도 동일하게 주어진 데이터가 튜플 내에 몇 번 나타나는지 그 개수를 반환합니다. t = (1, 2, 3, 2, 4, 5) print(t.count(2)) # 결괏값 6. 세트 (set) 세트(set) 자료형은 수학의 집합과 같은 개념입니다. 리스트나 튜플과 유사하게 여러 데이터를 요소로 갖지만, 세트는 요소의 순서가 없고 같은 요소끼리는 중복을 허용하지 않는다는 점이 리스트나 튜플과 다릅니다. 또한 세트는 새로운 요소를 추가하거나 기존의 요소를 삭제할 수는 있지만 한번 생성된 세트의 요소는 다른 값으로 변경할 수 없습니다. 세트를 만들 때는 중괄호({})를 이용하여 만듭니다. fruits = {"사과", "바나나", "딸기", "사과"} print(fruits) # 결괏값 {'딸기', '사과', '바나나'} 위에서 print() 함수로 출력된 결괏값을 보면 앞에서 학습한 리스트나 튜플을 출력했을 때와는 다른 점이 있습니다. 바로 세트를 생성할 때 입력한 순서와는 다르게 세트가 출력되었다는 점입니다. 또한 입력할 때는 "사과"를 2번 중복하여 입력했지만, 세트를 출력했을 때는 "사과"가 하나만 포함되어 있습니다. 이를 통해 세트는 중복 값을 허용하지 않으며 요소에 순서를 부여하지 않는다는 것을 다시 한번 확인할 수 있습니다. 이와 같이 세트의 요소에는 순서가 없기 때문에 세트에서는 인덱싱이나 슬라이싱을 사용할 수 없습니다. 세트도 리스트나 튜플처럼 여러 타입의 자료형을 혼합하여 요소로 가질 수 있습니다. 하지만 변경이 불가능한 자료형만 세트의 요소로 넣을 수 있습니다. 따라서 요소를 변경할 수 있는 자료형인 리스트나 튜플, 딕셔너리는 세트의 요소로 포함될 수 없습니다. 연산자 앞서 세트는 수학의 집합과 같은 개념이라고 학습했습니다. 따라서 세트의 연산도 집합의 연산인 합집합, 교집합, 차집합 등을 수행할 수 있습니다. 연산자 의미 예시 결괏값 A | B 세트 A와 세트 B의 합집합(A ∪ B) { '사과', '바나나' } | { '오렌지'} {'사과', '바나나', '오렌지'} A & B 세트 A와 세트 B의 교집합(A ∩ B) { '사과', '바나나' } & {'바나나'} {'바나나'} A - B 세트 A와 세트 B의 차집합(A-B) { '사과', '바나나' } - {'바나나'} {'사과'} A ^ B 세트 A와 세트 B의 대칭 차집합(A △ B) { '사과', '바나나' } ^ {'바나나', '딸기'} {'딸기', '사과'} 세트 메서드 세트는 이미 생성된 요소를 변경할 수는 없지만 새로운 요소를 추가하거나 기존 요소를 삭제할 수 있기 때문에 이와 같은 기능을 하는 메서드는 사용이 가능합니다. 다음은 세트에서 주로 사용하는 메서드의 종류입니다. 아래 표의 예시 코드는 세트 s1 = {1, 2, 3}과 s2 = {2, 3, 4}를 바탕으로 각 메서드를 사용하는 예시이며 결괏값은 해당 메서드가 반영되어 변경된 세트입니다. 메서드 의미 예시 결괏값 add(element) 세트에 요소 추가 s1.add(4) s1 = {1, 2, 3, 4} remove(element) 요소를 세트에서 삭제(없으면 에러 발생) s1.remove(2) s1 = {1, 3} discard(element) 요소를 세트에서 삭제(없어도 에러 발생하지 않음) s1.discard(2) s1 = {1, 3} pop() 임의의 요소를 세트에서 삭제하고 그 요소를 반환(빈 세트인 경우 에러 발생) s1.pop() 예측 불가 clear() 세트의 모든 요소 삭제 s1.clear() s1 = {} union(set) 여러 세트들의 합집합 s1.union(s2) {1, 2, 3, 4} intersection(set) 여러 세트들의 교집합 s1.intersection(s2) {2, 3} difference(set) 첫 번째 세트와 다른 세트들의 차집합 s1.difference(s2) {1} 7. 딕셔너리 (dictionary) 딕셔너리는 키(key)와 값(value)의 쌍으로 데이터를 저장하는 자료형입니다. 딕셔너리는 중괄호({})를 사용하여 표현하고, 각 항목은 '키 : 값'의 형태로 입력됩니다. 아래는 딕셔너리를 생성하는 예입니다. person = { "name": "한솔", "age": 29, "city": "서울" } type(person) # 결괏값 dict type()의 결과로 출력된 값 dict는 딕셔너리를 의미합니다. dict()를 이용하여 딕셔너리를 생성할 수도 있습니다. dict()의 괄호 안에 '키(key) = 값(value)'의 형태로 키와 값의 쌍을 입력하고 동일하게 쉼표로 구분하면 됩니다. 아래는 dict()를 이용하여 위와 동일하게 딕셔너리를 생성하는 예시입니다. person = dict(name = "한솔", age = 29, city = "서울" ) print(person) # 결괏값 {'name': '한솔', 'age': 29, 'city': '서울'} 딕셔너리는 키와 값이 쌍을 이루기 때문에 키를 이용하여 해당 키에 연결된 값에 접근할 수 있습니다. 중복된 키는 허용되지 않으며 같은 키를 두 번 사용하면 마지막 값이 저장됩니다. 또한 키는 문자열, 숫자, 튜플과 같은 변하지 않는 자료형으로만 사용 가능합니다. 값으로는 어떠한 종류의 자료형도 사용할 수 있습니다. 위의 예시에서 만든 딕셔너리에서 키를 통해 키에 대응하는 값을 가져와보겠습니다. print(person["age"]) # 결괏값 29 리스트나 튜플에서 인덱스를 사용하여 요소에 접근하는 것처럼 딕셔너리에서는 인덱스 대신 키로 값에 접근합니다. 리스트나 튜플의 인덱싱에서 해당 인덱스가 없을 때는 오류가 발생하는 것처럼, 딕셔너리에서도 해당 키가 없으면 에러가 발생합니다. 또한 키를 이용하여 값에 접근한 다음 새로운 값으로 변경하거나 새로운 키와 값의 쌍을 추가/삭제하는 것도 가능합니다. dictionary[key] = new_value와 같이 값을 입력하며, 딕셔너리에 해당 키가 존재할 경우에는 기존 값을 새로운 값(new_value)으로 대체합니다. 만약 딕셔너리에 해당 키가 존재하지 않을 경우에는 입력한 키와 값의 쌍을 새로 딕셔너리에 추가합니다. person = { "name": "한솔", "age": 29, "city": "서울" } person["age"] = 30 person["job"] = "의사" print(person) # 결괏값 {'name': '한솔', 'age': 30, 'city': '서울', 'job': '의사'} 위의 예시에서 딕셔너리에 "age"라는 키가 이미 있었기 때문에 기존에 "age"에 연결된 값 29가 30으로 변경되었습니다. 그리고 딕셔너리에 "job"이라는 키는 존재하지 않기 때문에 "job : 의사"라는 새로운 키와 값의 쌍이 딕셔너리에 추가되었습니다. 딕셔너리에서 키와 값의 쌍을 삭제할 때는 del을 사용합니다. del person["job"] 삭제를 할 때도 키를 삭제하면 연결된 값까지 모두 삭제됩니다. 이때 만약 딕셔너리에 키가 없으면 에러가 발생합니다. 딕셔너리에 특정한 키가 있는지 확인해 볼 수도 있습니다. '찾고자 하는 키 in 딕셔너리'를 이용하여 확인할 수 있으며 결괏값은 부울 자료형(True/False)로 반환됩니다. person = { "name": "한솔", "age": 29, "city": "서울" } print("job" in person) # 결괏값 False 딕셔너리 메서드 딕셔너리에서 사용할 수 있는 주요 메서드에 대해 알아보겠습니다. 아래의 예시는 'person = { "name": "한솔", "age": 29, "city": "서울" }'을 가지고 각 메서드를 실행하는 예시입니다. 메서드 의미 예시 결괏값 keys() 딕셔너리의 모든 키를 반환 person.keys() dict_keys(['name', 'age', 'city']) values() 딕셔너리의 모든 값을 반환 person.values() dict_values(['한솔', 29, '서울']) items() 딕셔너리의 모든 키와 값의 쌍을 반환 person.items() dict_items([('name', '한솔'), ('age', 29), ('city', '서울')]) get(key) 지정된 키에 대응하는 값을 반환(없으면 None을 반환) person.get("city") '서울' pop() 지정된 키와 그에 대응하는 값을 삭제하고 그 값을 반환 person.pop("name") '한솔' clear() 딕셔너리의 모든 항목 삭제 person.clear() person = {} 지금까지 파이썬에서 사용되는 다양한 자료형에 대해 알아보았습니다. 이러한 자료형들은 프로그램에서 다양한 종류의 데이터를 다루기 위해 사용됩니다. 각 자료형은 특정한 연산들을 지원하며, 그에 따라 다른 방식으로 조작될 수 있습니다. 이전에 언급한 바와 같이 자료형은 변수에 값이 할당될 때 자동으로 추론되기 때문에 별도의 선언이 필요하지 않습니다. 파이썬은 동적 타이핑(dynamic typing) 언어로, 변수의 자료형은 할당된 값에 따라 자동으로 결정됩니다. 02-03. 조건 문과 반복문 이번 챕터에서는 파이썬의 제어문에 대해서 학습하겠습니다. 제어문은 프로그램의 흐름을 제어하는 구문으로, 조건문으로 특정 조건을 설정하여 조건에 따라 다르게 동작하게 하거나 반복문으로 특정 작업을 반복적으로 수행하게 만드는 역할을 합니다. 조건 문과 반복문에 대해서 하나씩 살펴보겠습니다. 조건문 조건문은 말 그대로 특정한 조건을 설정하여 조건에 따라 어떤 동작을 하도록 만드는 구문으로, if 문을 사용하여 조건문을 만듭니다. if 문은 단독으로도 사용할 수 있지만 else, elif 구문을 사용하여 여러 조건을 추가할 수도 있습니다. 1) if 문 먼저 if 문에 대해 학습하겠습니다. if 문은 주어진 조건이 참(True)인지 거짓(False)인지 검사하고 그에 맞는 코드를 실행합니다. if 문의 기본 구조는 아래와 같습니다. if 조건 : 조건이 참일 경우에 수행할 코드 블록 if 뒤에 조건을 입력한 다음 콜론(:)을 입력하고 줄 바꿈을 실행합니다. 그리고 다음 줄에 조건이 참일 경우에 수행할 코드를 입력합니다. 이때 주의할 점은, 반드시 공백 네 칸 또는 한 탭(Tab)을 띄워 들여 쓰기를 한 다음 코드를 입력해야 합니다. 주피터 노트북에서는 콜론(:) 입력 후 엔터키로 줄바꿈을 실행하면 자동으로 들여 쓰기가 되기 때문에 바로 코드를 입력하면 됩니다. 들여 쓰기에 대해서는 이후 '02-09. 기타 문법'에서 자세히 다뤄보겠습니다. age = 4 if age < 7: print("어린이 가격이 적용됩니다.") # 결괏값 어린이 가격이 적용됩니다. 위의 예제 코드에서 if 문을 살펴보면, age가 20 미만일 경우(True)에 print()를 수행합니다. 만약 age가 20 이상인 경우(False)에는 print()를 실행하지 않습니다. 이와 같이 조건문에서는 주어진 조건의 참과 거짓을 판별해야 하므로 비교 연산이나 논리 연산 등을 조합하여 참/거짓 여부를 검사할 수 있는 조건으로 설정해야 합니다. 2) elif와 else 위에서 알아본 if 문을 단독으로 사용하면 조건에 맞는 경우에 수행할 코드만 입력할 수 있었습니다. 조건이 참(True)일 때는 A를 수행하지만, 거짓(False)인 경우에는 B를 수행하도록 설정하려면 if 문에 else를 함께 사용해 주어야 합니다. else를 포함한 if 문의 구조는 다음과 같습니다. if 조건 : 조건이 참일 경우에 수행할 코드 블록 else: 조건이 거짓일 경우에 수행할 코드 블록 조건이 거짓일 경우에는 무조건 else로 넘어오기 때문에 else 뒤에는 조건을 적지 않고 콜론(:)을 바로 입력합니다. 그리고 동일하게 들여 쓰기를 한 다음 조건이 거짓일 때 실행할 코드를 입력합니다. 그리고 여기서 더 나아가 조건을 여러 개 설정하고 싶을 때는 elif로 조건을 추가할 수 있습니다. 즉, 조건 1이 참일 경우에 실행할 코드, 조건 1은 거짓이지만 조건 2는 참일 경우에 실행할 코드, 그리고 조건 1과 조건 2 모두 거짓일 때 실행할 코드를 각각 설정할 수 있습니다. if 조건 1: 조건 1이 참일 경우에 수행할 코드 블록 elif 조건 2: 조건 1은 거짓이지만 조건 2가 참일 경우 수행할 코드 블록 elif 조건 3: 조건 1과 조건 2는 거짓이지만 조건 3이 참일 경우 수행할 코드 블룩 else: 조건 1과 조건 2, 조건 3 모두 거짓일 경우에 수행할 코드 블록 elif 뒤에는 또 다른 조건을 입력하고, 이전의 조건은 거짓이지만 해당 조건은 참일 때 수행할 코드를 설정해 줍니다. 위의 구조에서 보면 알 수 있듯 조건을 여러 개 설정하고자 한다면 elif를 여러 번 사용하는 것도 가능합니다. 아래는 elif와 else를 사용한 예시 코드입니다. age = 18 if age < 7: print("어린이 가격이 적용됩니다.") elif 7 <= age < 20: print("청소년 가격이 적용됩니다.") else: print("성인 가격이 적용됩니다.") # 결괏값 청소년 가격이 적용됩니다. 3) 중첩 조건문 조건의 참/거짓 판별 후에 코드를 실행하는 것이 아니라 또 다른 조건문을 추가할 수도 있습니다. 이를 중첩 조건문이라고 하는데, 중첩 조건문은 코드 블록에 조건문을 추가하면 됩니다. age = 1 if age < 7: if age < 3: print("3세 미만은 무료입니다.") else: print("어린이 가격이 적용됩니다.") elif 7 <= age < 20: print("청소년 가격이 적용됩니다.") else: print("성인 가격이 적용됩니다.") # 결괏값 3세 미만은 무료입니다. 위의 코드에서 age가 7미만인 첫 번째 조건에서 참인 경우 그 안의 또 다른 조건문으로 넘어갑니다. 해당 조건문 안에 또다시 if와 else가 있어서 age가 3 미만인 경우와 그렇지 않은 경우로 조건이 다시 나누어집니다. 이와 같은 방식으로 조건문을 중첩하여 사용할 수도 있습니다. 반복문 특정 작업을 반복시키는 반복문에는 for 문과 while 문이 있습니다. for 문은 범위를 지정하여 해당 범위만큼 코드를 반복하고, while 문은 특정 조건을 지정하여 조건이 만족되는 동안 계속해서 코드를 반복 실행합니다. for 문과 while 문을 각각 살펴보겠습니다. 1. for 문 for 문은 앞서 설명한 것과 같이 지정된 범위만큼 반복을 실행합니다. 따라서 범위를 지정해 주어야 하고 반복해서 수행할 작업을 전달해 주어야 합니다. for 문의 기본 구조는 다음과 같습니다. for 변수 in 반복할 범위: 반복해서 수행할 코드 블록 for 뒤에 '변수 in 반복할 범위'를 적은 다음 if 문에서와 마찬가지로 콜론(:)을 써주고 줄을 바꿉니다. 그리고 수행할 코드 블록의 앞에 마찬가지로 공백 네 칸 또는 탭(Tab) 한 칸을 입력해 들여 쓰기를 합니다. for 뒤에 나오는 변수는 반복할 범위 안의 각 항목을 하나씩 가리키는 역할을 합니다. 즉, 반복할 범위에서 하나씩 항목을 가지고 와서 변수에 저장하고 그 변수로 다음 줄의 코드를 실행합니다. 그리고 해당 변수에 대한 코드 수행을 마치면 도돌이표처럼 다시 윗줄로 돌아가서 범위에서 다음 항목을 가지고 오고 변수에 저장해 코드를 수행하는 작업을 반복합니다. 이러한 반복 작업은 지정된 범위가 끝날 때까지 반복됩니다. 반복할 범위는 어디서부터 어디까지를 반복할지를 정하는 부분으로 range() 함수를 이용하여 숫자 범위를 지정하는 방법을 통해 반복 횟수를 지정할 수도 있고, 리스트나 튜플, 문자열, 딕셔너리 등 여러 요소를 포함하고 있는 객체(iterable)를 사용하여 해당 요소들을 하나씩 순회하며 반복 작업을 수행하도록 명령할 수도 있습니다. 실제 예시 코드를 살펴보겠습니다. for i in range(5): print(i) # 결괏값 1 3 range() 함수는 연속된 숫자를 생성하는 데 사용되는 파이썬 내장 함수로 for 문과 함께 사용하여 일정한 횟수만큼 반복할 수 있게 합니다. range(시작 값, 종료 값, 간격)으로 숫자 생성 옵션을 지정할 수 있습니다. 시작 값과 간격은 생략이 가능하지만 종료 값은 생략할 수 없으며, 마지막으로 반환되는 숫자는 종료 값이 아닌 종료 값보다 1 작은 숫자입니다. range 함수는 기본적으로 종료 값을 생략할 수 없기 때문에 range() 함수 안에 숫자가 하나만 입력될 경우 파이썬은 자동적으로 종료 값이 입력되었다고 간주합니다. 숫자를 2개 입력할 경우에는 시작 값과 종료 값으로 인식되며 간격은 자동적으로 1씩 증가합니다. 따라서 range(5)는 시작 값이 생략되어 가장 처음 숫자인 0부터 시작하며 마지막 숫자는 5보다 1 작은 수인 4가 됩니다. 그로 인해 위의 for 문에서 반복 범위는 0부터 4까지 숫자가 되며 각 숫자 항목이 하나씩 변수 i에 저장되며 각 변수를 가지고 print() 함수가 실행됩니다. 해당 범위 안에서 코드를 반복 수행한 결과로 0부터 4까지 숫자가 하나씩 출력되었습니다. 그러면 이번에는 리스트를 가지고 for 문을 사용하는 코드를 살펴보겠습니다. fruits = ['사과', '바나나', '딸기'] for fruit in fruits: print(fruit) # 결괏값 사과 바나나 딸기 이번에는 반복할 범위를 리스트 fruits로 지정하였습니다. 따라서 리스트의 각 요소에 하나씩 접근하여 가지고 온 다음 변수 fruit에 저장하고 해당 변수로 코드를 실행하는 작업을 반복합니다. 리스트의 모든 항목에 대해 반복 작업을 수행한 다음에는 작업이 종료됩니다. 실제 코드에서 for 문을 사용하다 보면 여러 리스트를 동시에 반복 작업을 해야 하거나 또는 리스트의에서 반복 작업을 수행할 때 각 요소에 해당하는 인덱스가 함께 필요한 경우들이 있습니다. 이럴 때 사용할 수 있는 함수에 대해 알아보겠습니다. enumerate enumerate은 반복 가능한 객체(리스트, 튜플, 문자열 등)를 입력받아 각 요소와 해당 요소의 인덱스를 튜플 형태로 반환합니다. 인덱스는 기본적으로 0부터 시작하며 원하는 다른 시작 값이 있는 경우에는 값을 별도로 설정할 수도 있습니다. 사용방법은 for 문 뒤에 리스트에서 가져온 요소의 값을 저장할 변수와 요소의 인덱스를 저장할 변수, 총 2개의 변수를 설정하고 enumerate() 안에 리스트를 넣어줍니다. 기본 구조는 다음과 같습니다. for 인덱스 변수, 값 변수 in enumerate(리스트): 반복해서 수행할 코드 블록 그러면 실제 코드에서 실행했을 때 어떻게 작동하는지 print() 함수로 인덱스와 값을 출력함으로써 작동 방법을 살펴보겠습니다. fruits = ['사과', '바나나', '딸기'] for idx, fruit in enumerate(fruits): print(idx, fruit) # 결괏값 0 사과 1 바나나 2 딸기 fruits 리스트에서 항목을 가지고 오는데 항목에 대한 인덱스는 변수 idx에, 항목에 대한 값을 변수 fruit에 저장합니다. 그리고 다음 라인의 코드를 실행한 후 다시 리스트에서 다음 항목을 가져와 작업을 반복합니다. 시작 인덱스를 별도로 지정하지 않았기 때문에 0부터 시작하였습니다. 출력된 결괏값을 보면 항목이 다음으로 넘어갈 때마다 idx 변수에 할당된 인덱스도 같이 변경된 것을 확인할 수 있습니다. zip 이번에는 여러 개의 리스트를 for 문으로 함께 작업하는 방법을 살펴보겠습니다. 여러 리스트를 작업할 때는 zip() 함수를 사용합니다. zip() 함수는 두 개 이상의 반복 가능한 객체(iterable)를 인자로 전달받아서 같은 위치에 있는 요소들을 묶어 튜플로 반환합니다. 기본 구조는 다음과 같습니다. for 변수 1, 변수 2 zip(리스트 1, 리스트 2): 반복해서 수행할 코드 블록 각 리스트에서 항목을 하나씩 가져와서 변수 1과 변수 2에 각각 저장한 다음 두 변수로 뒷 줄의 코드를 수행합니다. zip() 함수로 반환되는 튜플의 수는 가장 짧은 반복 가능한 객체의 길이에 따라 결정됩니다. 즉, 만약 리스트 A의 요소가 리스트 B의 요소보다 적을 경우 반복 작업은 리스트 A의 요소의 개수로 길이가 제한되며, 리스트 B에 남는 요소는 무시됩니다. 아래 코드를 살펴보면 이해하기 쉽습니다. fruits = ["사과", "바나나", "멜론"] colors = ["빨강", "노랑"] for fruit, color in zip(fruits, colors): print(fruit, color) # 결괏값 사과 빨강 바나나 노랑 리스트 fruits와 colors에서 각각 동일한 위치에 있는 요소(사과 - 빨강, 바나나 - 노랑)를 가지고 옵니다. 리스트 fruits에는 세 번째 요소로 "딸기"가 있지만, 리스트 colors에는 세 번째 요소가 없기 때문에 for 문에서는 두 번째 요소까지 코드를 수행한 다음 반복문을 종료합니다. zip() 함수를 사용하지 않고, 인덱스를 이용하여 여러 개의 리스트를 반복문에 사용하는 방법도 있습니다. 다만, 인덱스를 사용할 때는 존재하지 않는 인덱스를 호출하면 에러가 발생하기 때문에 모든 리스트의 길이가 동일해야 합니다. 아래는 인덱스를 사용하여 두 리스트를 다루는 방법입니다. for 인덱스를 저장할 변수 in range(len(리스트 1)): 반복해서 수행할 코드 블록 위의 기본 구조에서 살펴보면 한 개의 리스트만 사용되었기 때문에 의아할 수 있습니다. 다시 풀어서 살펴보겠습니다. 먼저 len() 함수를 사용하여 리스트 1의 길이를 숫자로 반환합니다. range() 함수에는 숫자를 입력해야 하기 때문에 리스트의 길이를 확인하여 range()의 인자로 넣어줍니다. 그 결과, range() 함수는 리스트 1의 길이를 범위로 하여 숫자를 하나씩 반환하게 됩니다. 0부터 시작하기 때문에 이렇게 하나씩 출력되는 숫자는 리스트 1의 인덱스와 동일하게 됩니다. 그리고 리스트 1과 리스트 2는 길이가 동일한 리스트이기 때문에 인덱스 번호로 하나씩 접근하면 같은 위치에 있는 요소들에 접근하는 결과를 얻을 수 있습니다. 아래의 예시 코드를 보면 이해하기 쉬워집니다. fruits = ["사과", "바나나", "멜론"] colors = ["빨강", "노랑", "초록"] for i in range(len(fruits)): print(fruits[i], colors[i]) # 결괏값 사과 빨강 바나나 노랑 멜론 초록 len(fruits)로 fruits의 길이(3)를 숫자로 반환합니다. 그 결과 range(3)이 되어 0부터 2까지 숫자를 하나씩 차례로 반환하게 됩니다. 숫자가 하나씩 반환되어 변수 i에 저장되고 i를 가지고 다음 줄의 코드를 실행합니다. fruits[i]와 colors[i]로 각각의 리스트에서 인덱스가 현재 숫자 i인 요소에 접근하여 print()로 출력합니다. 이중 for 문 두 개의 리스트를 반복문에서 사용할 때 for 문을 중첩해서 사용하는 것도 가능합니다. 이를 이중 for 문이라고 하며, 외부 for 문에서 각 항목을 반복할 때마다 내부의 for 문 전체를 반복합니다. 이중 for 문의 기본 구조는 다음과 같습니다. for 변수 1 in 반복할 범위 1: for 변수 2 in 반복할 범위 2: 반복해서 수행할 코드 블록 이와 같은 이중 for 문은 여러 개의 리스트에서 가능한 모든 조합을 생성하거나 중첩된 데이터나 조합이 필요한 경우에 사용합니다. 아래는 이중 for 문을 사용하여 구구단을 출력해 보는 예시 코드입니다. for i in range(2, 10): for j in range(1, 10): print(f"{i} x {j} = {i*j}") print("----------") # 결괏값 2 x 1 = 2 2 x 2 = 4 2 x 3 = 6 ...(중략)... 9 x 8 = 72 9 x 9 = 81 ---------- 출력값의 길이 때문에 위에서는 결괏값의 일부를 생략하였지만, 실제 콘솔에서 실행해 보면 2단부터 9단까지 모든 구구단이 출력되는 것을 확인할 수 있습니다. 다시 코드를 살펴보면, 먼저 외부 for 문에서 range(2, 10)으로 2부터 9까지 숫자를 차례로 하나씩 반환하고 변수 i에 넣어 다음 라인의 코드를 실행합니다. 다음 라인이 다시 내부 for 문이기 때문에 내부 for 문이 실행됩니다. 내부 for 문에서는 range(1, 10)으로 1부터 9까지 숫자가 차례로 반환되어 j에 저장된 후 다음 라인의 코드 print()를 실행합니다. print()의 괄호에 f"{i} x {j} = {i*j}"로 알파벳 f와 중괄호({})가 사용되었습니다. 이는 문자열 포메이팅(foramting)으로 문자열 앞에 f를 사용하여 포메이팅이라는 표시를 해주고, 큰따옴표(") 안에 출력할 문자열을 넣어주는<NAME>으로 사용됩니다. 큰따옴표(") 안의 문자열 중에서 {}안에 있는 문자열은 변수명으로 간주됩니다. 따라서 {} 안의 문자열을 변수명으로 하는 변수에 할당된 값이 해당 위치에 대응하여 출력됩니다. 포메이팅에 대해서는 '02-09. 문자열 처리'에서 다시 한번 자세히 다루겠습니다. 여기서는 print(f"{i} x {j} = {ij}")에서 {i}, {j}, {ij}에 현재 숫자(i, j)가 전달되어 출력된다고 이해하면 됩니다. 즉, 위의 코드에서 처음 실행되는 작업은 i가 2일 때 j가 1로 '2 x 1 = 2'가 출력됩니다. i가 2일 때 j가 1부터 9까지 반복되고 그다음 i가 3이 되면 다시 또 j가 1부터 9까지 반복됩니다. 이와 같은 방식으로 이중 for 문이 작동하다가 i가 9일 때 j도 9인 마지막 항목의 작업을 수행한 후 전체 반복문이 종료됩니다. 컴프리 헨 션(Comprehension) 컴프리 헨 션(List Comprehension)은 파이썬에서 for 문을 사용하여 리스트나 튜플, 딕셔너리를 생성할 때 사용하는 방식입니다. 리스트를 생성할 때 코드를 간결하게 표현할 수 있으며 코드의 가독성을 향상시킵니다. 주로 다른 반복 가능한 객체로부터 새로운 리스트(튜플, 딕셔너리)를 만들 때 사용하기 때문에 for 문으로 요소들을 순회하며 if 문을 함께 사용하여 조건을 서정하 기도합니다. 여기서는 그중 많이 사용하는 리스트 컴프리헨션을 학습해겠습니다. 리스트 컴프리헨션의 기본 구조는 다음과 같습니다. [표현식 for 변수 in 반복 가능한 객체(범위) if 조건] 먼저 for 변수 in 반복 가능한 객체(범위)까지는 for 문과 같다고 생각하면 됩니다. 반복할 범위를 지정하고 해당 범위에서 하나씩 요소를 가지고 와서 변수에 할당합니다. 그다음 가지고 온 변수를 리스트에 어떻게 저장할지 표현식에 따라 처리를 한 다음 리스트의 요소로 저장합니다. 이와 같은 과정을 지정한 범위만큼 반복하여 리스트를 생성합니다. 뒤에 if는 말 그대로 조건을 설정하는 것으로 조건이 참(True)일 경우에만 표현식이 실행됩니다. 특정한 조건을 설정하지 않을 때는 if 문을 생략할 수 있습니다. 다음은 리스트 컴프리헨션으로 리스트를 생성하는 기본 예제입니다. numbers = [x for x in range(10)] print(numbers) # 결괏값 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] range(10)으로 0부터 9까지 숫자 범위 안에서 숫자를 하나씩 가지고 와서 변수 x에 저장합니다. 여기서는 표현식에 별다른 연산 없이 x 그대로 리스트에 저장하라고 명령했기 때문에 각 변수가 그대로 리스트의 요소로 저장됩니다. 위와 동일한 코드에서 조건을 설정하여 0부터 9까지의 숫자 중 짝수만 생성해 보겠습니다. even_numbers = [x for x in range(10) if x % 2 == 0] print(even_numbers) # 결괏값 [0, 2, 4, 6, 8] 여기서는 if 뒤에 조건으로 x % 2 == 0이 추가되었습니다. 변수 x를 2로 나누었을 때 나머지가 0인 경우, 즉, 2의 배수일 경우에만 가지고 오도록 하여 짝수만 리스트에 저장합니다. 위의 코드처럼 변수를 그대로 리스트에 저장할 수도 있지만, 표현식 부분에서 변수를 가지고 다양한 연산이나 처리를 실행할 수도 있습니다. 이번에는 표현식에 연산을 추가해 보겠습니다. squared_numbers = [x**2 for x in range(10)] print(squared_numbers) # 결괏값 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 여기서는 변수 x에 저장된 숫자를 제곱하여 그 값을 리스트에 저장합니다. 이와 같은 산술 연산 외에도 함수 등을 활용하여 다양한 처리를 하도록 명령할 수 있습니다. 그리고 for 문과 if 문을 여러 개 중첩하여 더 복잡한 리스트 컴프리헨션도 만들 수 있습니다. 다만 너무 복잡한 로직을 포함하게 되면 오히려 코드의 가독성이 떨어질 수 있습니다. 2. while 문 이번에는 반복문 중 while 문을 학습해 보겠습니다. while 문은 조건에 따라 반복을 실행하기 때문에 조건과 반복할 작업을 입력해 주어야 합니다. while 문의 기본 구조는 다음과 같습니다. while 조건: 반복을 수행할 코드 블록 while 뒤에 참/거짓 여부를 확인할 수 있는 조건을 입력하고 콜론(:)을 입력한 다음 줄바꿈을 실행합니다. 그리고 다른 조건문이나 반복 문과 마찬가지로 공백 네 칸 또는 탭(Tab) 한 칸을 띄어 들여 쓰기를 한 다음 반복을 실행할 코드를 입력합니다. 아래는 while 문을 사용한 반복 문의 예입니다. count = 0 while count < 5: print(count) count = count + 1 # 결괏값 1 3 count = 0으로 값이 0인 count 변수를 먼저 생성합니다. 그리고 while 문으로 넘어가는데 조건이 count < 5로 count 변수의 값이 5 미만일 경우에만 다음 줄의 코드 블록을 수행하도록 설정하였습니다. 먼저 처음에는 count의 값이 0이기 때문에 조건이 참(True)이 되어 count를 출력하고 카운트의 값에 1이 추가됩니다. 코드 실행이 끝난 후 다시 while 문으로 돌아갑니다. count에 1이 추가되었기 때문에 현재 count = 1입니다. 현재 count 변수의 값이 다시 조건에 맞는지 검사합니다. 이번에도 조건이 참이기 때문에 다음 줄의 코드를 실행합니다. 이렇게 계속해서 반복문이 실행되다가 count의 값이 5가 되면 조건이 거짓(False)이 되기 때문에 while 문을 빠져나오게 됩니다. while 문도 동작을 반복하는 역할을 하기 때문에 for 문으로 만든 반복문을 코드를 수정하여 while 문으로 만들 수 있습니다. 물론 반대로 while 문이 사용된 반복문을 수정하여 for 문으로 만들 수도 있습니다. 다만 for 문은 범위를 지정해야 하고 while 문은 조건을 지정해야 하는 특성으로 인해 반복문을 사용하는 상황에 따라 특정 반복문을 사용하는 것이 더 간결하고 쉬울 때가 있습니다. 보통 while 문은 조건의 결과에 따라 반복 횟수가 동적으로 결정되는 경우에 유용합니다. 그러나 반복 횟수가 미리 알려져 있는 경우에는 for 문을 사용하는 것이 더 적합할 수 있습니다. 무한 반복 while 문에서 만약 조건이 항상 참일 경우에는 무한 반복을 실행하게 되는데, 뒤에서 배울 'break'문을 사용하여 특정 조건일 경우 종료되게 하거나 프로그램이 수동으로 종료될 때까지 해당 작업을 계속 실행합니다. 참고로 프로그램을 수동으로 종료하려면 파이썬 콘솔에서 키보드 Ctrl 과 C를 입력하거나 주피터 노트북에서는 상단의 Kernel 메뉴 - Interrupt를 클릭하거나 툴 바에서 정지 버튼(■)을 클릭합니다. 다음은 무한 반복을 실행하는 while 문의 예시입니다. while True: print("무한 반복") while 문은 조건이 참일 경우에 코드를 실행하는데 위의 코드에서는 조건 자체가 참(True)이기 때문에 이 조건은 절대 거짓(False)이 되지 않습니다. 따라서 거짓이어야 반복문이 종료되는데 항상 참인 조건이기 때문에 위의 while 문은 무한 반복에 빠지게 됩니다. 위의 코드를 실행하면 "무한 반복"이라는 문자열이 계속해서 화면에 출력되는 것을 볼 수 있습니다. 코드 자체에 break로 반복을 종료하는 특정 조건을 설정하지 않았기 때문에 위의 코드가 실행된 경우에는 수동으로 프로그램을 중지해야 합니다. break와 continue 반복문에서 흐름을 바꿔주는 break와 continue에 대해서 알아보겠습니다. 앞에서 while 문의 무한 루프를 멈추는 방법 중 하나로 break를 사용하는 방법이 있다고 학습했습니다. break는 반복문에서 반복 작업을 종료시켜서 반복문을 빠져나오게 하는 역할을 하고 continue는 반복문에서 현재 진행 중인 회차를 멈추고 다음 회차의 반복으로 넘어가게 합니다. 다시 말해 특정 조건에서 반복을 멈추게 하려면 break를, 특정 조건에서는 작업을 수행하지 않고 다음 반복으로 넘어가려면 continue를 사용하면 됩니다. 코드를 통해 이해해 보겠습니다. for i in range(10): if i == 3: continue if i == 7: break print(i) # 결괏값 1 4 6 먼저 반복문 자체는 0부터 9까지 숫자를 하나씩 가지고 와서 i에 대입한 다음, 아래에 들여쓰기 되어 있는 코드 블록을 실행합니다. 코드 블록에 진입하면 실제 수행할 코드 앞에 if 문으로 조건을 설정하였는데, 첫 번째 if 문에서는 if i == 3이면 continue라고 되어 있습니다. 이는 i가 3일 경우에는 다음 if 문과 print() 함수로 넘어가지 않고 다음 회차로 넘어가라는 의미입니다. continue는 if 문 다음 라인에 한 번 더 들여쓰기 되어 있는데, 이렇게 한 번 더 들여 쓰기는 바로 위의 if 문에서 조건이 참일 경우에만 수행되는 코드를 뜻합니다. 만약 i가 3이 아닌 경우에는 continue를 건너뛰고 그다음 if 문(if i == 7)을 만나게 됩니다. 여기서는 만약 i가 7일 경우에는 break, 즉, 반복문을 종료하라는 의미입니다. 그리고 만약 i가 3도 아니고 7도 아닐 경우에는 마지막 라인의 print() 함수를 수행하게 됩니다. 이처럼 continue와 break를 활용하면 다양한 조건에서 반복 문의 흐름을 변경할 수 있습니다. 02-04. 함수와 클래스 함수 파이썬에는 특정 작업을 수행하는 코드 블록인 함수가 있습니다. 함수를 사용하면 해당 작업을 할 때마다 코드를 일일이 작성하지 않아도 함수를 통해 쉽고 간결하게 작업을 실행시킬 수 있어 코드의 재사용성을 높이고 구조를 개선하는 데 도움을 줍니다. 함수에는 파이썬에서 제공하는 내장함 수도 있지만 직접 특정 작업을 수행하는 함수를 정의하여 사용할 수도 있습니다. 1) 함수 정의와 호출 먼저 함수를 직접 정의하여 사용하는 방법을 학습해 보겠습니다. 함수를 정의한다는 것은 어떤 작업을 수행하는 코드 블록을 만드는 것을 의미합니다. 파이썬에서는 def 키워드를 사용하여 함수를 정의합니다. 다음은 함수를 정의하는 기본 구조입니다. def 함수 이름(매개변수 1, 매개변수 2, ...): 코드 블록 return 반환값 def 키워드 뒤에 함수를 호출할 때 사용할 함수의 이름을 넣어줍니다. 주로 해당 함수의 기능을 나타내는 이름으로 사용합니다. 함수 이름으로는 영어 알파벳 소문자와 밑줄 기호(_)를 사용할 수 있으며 공백은 허용하지 않습니다. 함수를 여러 개 정의할 경우 함수 이름을 중복하지 않도록 주의해야 합니다. 이미 정의된 함수와 동일한 이름으로 함수를 다시 정의하면 기존의 함수를 덮어씁니다. 함수 이름 뒤에는 () 괄호로 매개변수들을 넣어줍니다. 매개변수는 함수를 호출할 때 전달될 값을 받기 위한 변수를 의미합니다. 함수가 호출될 때 이 매개변수는 함수를 호출하는 코드에서 제공하는 실제 값을 받게 됩니다. 매개변수는 파라미터(parameter)라고도 부르며, 함수에서 매개변수로 전달하는 실제 값은 인자(argument) 또는 인수라고 부릅니다. 코드에 따라 매개변수가 여러 개 필요한 경우에는 필요한 만큼 매개변수를 입력하고, 필요하지 않으면 매개변수를 입력하지 않아도 됩니다. 매개변수 뒤에는 콜론(:)을 입력하여 줄바꿈을 하고, 함수가 호출될 때 실행될 코드들을 입력합니다. 만약 코드 실행 후에 어떤 값을 반환해야 할 때는 마지막 줄에 'return 반환값'을 입력합니다. 코드 블록과 return 반환값을 입력할 때는 모두 들여 쓰기를 합니다. 위와 같이 정의한 함수를 사용할 때는 '함수명()'을 사용하여 함수를 호출합니다. 함수명(인자 1, 인자 2, 인자 3, ...) 만약 매개변수를 설정하여 인자가 필요하다면 함수명()의 괄호 안에 인자를 넣어서 호출합니다. 매개변수가 여러 개일 경우, 함수를 호출할 때 전달하는 인자의 개수가 매개변수의 개수와 동일해야 하며, 순서도 일치시켜서 전달해야 합니다. 매개변수를 설정하지 않았을 경우에는 괄호 안에 아무것도 입력하지 않고 '함수명()'의 형태로 호출합니다. 다음은 함수를 정의하고, 정의한 함수를 호출하는 예제 코드입니다. def add(a, b): result = a + b return result sum_result = add(10, 20) # 함수 호출 print(sum_result) # 결괏값 30 위의 예시에서 add라는 이름의 함수를 정의했습니다. 이 함수는 두 개의 매개변수 a와 b를 받아서 둘의 합을 반환합니다. add 함수를 호출할 때 인자로 10과 20을 전달하였으며, 10과 20은 각각 매개변수 a와 b에 할당됩니다. a = 10, b = 20으로 함수 내부에서 코드 result = a + b를 실행합니다. 그리고 함수가 종료될 때 result 변수에 저장된 값을 반환합니다. 이렇게 반환된 값을 sum_result 변수에 할당하였습니다. 이와 같이 반환값이 있는 함수는 반환 값을 변수에 할당하여 활용할 수 있습니다. 함수를 정의할 때 여러 값을 반환하도록 만들 수도 있습니다. 여러 값을 반환하려면 return 뒤에 반환값을 쉼표로 나열하면 됩니다. 이렇게 반환되는 값들은 튜플로 묶여서 반환됩니다. def calculate(x, y): sum_val = x + y diff_val = x - y return sum_val, diff_val result = calculate(10, 5) print(result) # 결괏값 (15, 5) 위의 예제에서는 calculate 함수는 반환값으로 sum_val과 diff_val 2개를 반환하도록 정의되었습니다. 따라서 반환된 결괏값이 할당된 result를 출력하면 두 반환값 15와 5가 튜플로 묶여서 반환된 것을 확인할 수 있습니다. 이렇게 반환된 결괏값을 하나의 튜플이 아니라 각각 따로 사용하고자 한다면 튜플을 "언 패킹" 하면 됩니다. 언 패킹(unpacking)이란 튜플, 리스트 등 복합 데이터 구조의 요소를 여러 개의 변수에 한 번에 할당하는 기술을 의미합니다. 위의 코드에서 반환값을 sum_val과 diff_val이라는 변수에 각각 할당해 보겠습니다. sum_val, diff_val = calculate(10, 5) print(sum_val) print(diff_val) # 결괏값 15 이렇게 언 패킹을 통해 값들을 편리하게 추출 가능합니다. 이처럼 함수에서 여러 값을 반환하고, 반환된 값을 언 패킹으로 여러 변수에 할당하는 방식은 파이썬에서 자주 사용되고 있습니다. 기본 매개변수 함수를 정의할 때 매개변수에 기본값(default value)을 설정할 수 있습니다. 이렇게 설정된 매개변수를 "기본 매개변수(default parameter)"라고 부릅니다. 이렇게 기본 매개변수를 설정하면 함수 호출 시 해당 매개변수에 대한 인자를 전달하지 않았을 때 기본값이 사용됩니다. 기본값으로 사용하지 않고 다른 값을 사용하려면 함수 호출 시에 인자를 입력하면 됩니다. 기본 매개변수를 지정하는 방법은 다음과 같습니다. def 함수 이름(매개변수 1=기본값 1, 매개변수 2=기본값 2, ...): 코드 블록 return 반환값 기본 매개변수를 지정하여 함수를 정의해 보겠습니다. def example(x, y=5): print(x, y) example(x=10) # 결괏값 10 20 위의 예제 코드에서 함수 example은 x와 y 두 개의 매개변수가 있으며, 그중 y는 기본값이 5로 지정되어 있습니다. 따라서 example(x=10)으로 함수를 호출할 때 매개변수 y에 할당할 인자를 전달하지 않아도 y는 기본값 5로 입력되어 함수가 실행됩니다. 위의 코드에서 알 수 있듯 여러 개의 매개변수 중 기본값이 있는 매개변수와 기본값이 없는 매개변수를 혼합하여 함수를 정의할 수도 있습니다. 이때 주의할 점은 기본값이 없는 매개변수가 기본값이 있는 매개변수보다 항상 앞에 위치해야 합니다. 그리고 기본값이 없는 매개변수는 함수 호출 시 반드시 인자를 전달해야 합니다. 기본 매개변수가 여러 개일 때, 함수 호출 시에 전달받은 인자의 개수가 매개변수의 개수보다 적으면 앞의 매개변수부터 순차적으로 입력되며 나머지 매개변수에는 기본값이 입력됩니다. 함수에 인자를 입력할 때 그냥 값만 전달할 수도 있지만, 매 개변 수명을 지정하여 값을 전달할 수도 있습니다. 다음의 예시에서 살펴보겠습니다. def example(x, y=5, z=7): print(x, y, z) example(10, z=6) #결괏값 10 5 6 위의 코드에서 함수를 호출할 때 전달한 첫 번째 인자 10은 매개변수 x에 할당됩니다. 그리고 y는 기본값이 할당되고, z에는 전달한 6이 입력됩니다. 만약 위의 예시에서 example(10, 6)으로 함수를 호출했다면 매개변수 z가 아닌 y에 6이 할당되고 매개변수 z에는 기본값인 7이 할당되었을 것입니다. 따라서 인자를 순서와 상관없이 입력할 때나 기본값이 있는 특정 매개변수를 건너뛰고 다음 매개변수에 인자를 전달할 때에는 매 개변 수명을 지정하여 인자를 입력해야 합니다. 그리고 위의 예시 코드(example(10, z=6))에서처럼 인자로 값만 전달하는 방식(10)과 매개변수를 지정하여 입력하는 방식(z=6)을 혼합하여 사용할 경우에는 값만 전달하는 방식이 매개변수를 지정하여 입력하는 방식보다 앞에 와야 합니다. 지역변수와 전역변수 함수를 사용하면 함수 안에서 변수를 생성하고 해당 변수로 다른 작업을 수행하게 됩니다. 이렇게 함수 안에서 생성된 변수를 지역변수(local variable)라고 합니다. 그리고 이와 반대되는 개념으로 함수 밖에서 생성된 변수는 전역변수(global variable)라고 합니다. 함수 내부에서 정의된 변수(지역 변수)는 함수를 실행하는 동안 함수 안에서만 사용할 수 있으며 함수 외부에서는 접근할 수 없습니다. 함수를 실행하는 동안만 사용되기 때문에 함수가 종료되면 지역변수는 메모리에서 제거됩니다. 반면 전역변수는 함수 안이나 밖 어디서나 사용할 수 있으며, 프로그램이 종료될 때까지 메모리에 남아있습니다. 아래의 예제를 통해 지역변수와 전역변수의 개념을 이해해 보겠습니다. x = 10 # 전역변수 def my_function(): y = 5 # 지역변수 print("지역변수 y =", y) print("전역변수 x =", x) my_function() print(y) # 결괏값 지역변수 y = 5 전역변수 x = 10 --------------------------------------------------- NameError: name 'y' is not defined 위의 코드에서 x = 10은 def로 정의한 my_function() 함수의 밖에서 생성한 변수입니다. 따라서 변수 x는 전역변수입니다. 이와 달리 y = 5는 my_function() 함수를 정의할 때 그 안에서 생성된 변수이기 때문에 변수 y는 지역변수입니다. my_function() 함수를 호출했을 때는 print로 지역변수 y와 전역변수 x 모두 출력하여 지역변수 y = 5와 전역변수 x = 10을 반환하였습니다. 하지만 그다음 라인에서 실행한 코드 print(y)는 함수를 호출하지 않고 함수의 밖에서 지역변수 y에 접근하려고 하였습니다. 하지만 위에서 호출한 함수가 종료된 후 이미 지역변수 y = 5는 메모리에서 지워졌기 때문에 파이썬에 변수 y는 존재하지 않게 됩니다. 그로 인해 print()로 y 변수 출력을 시도하면 오류(Name Error)가 발생하게 됩니다. 전역변수는 함수 안에서도 사용이 가능하지만, 만약 함수 안에서 전역변수의 값을 변경하려면 global 키워드(global 전역 변수명)를 사용해야 합니다. 만약 global을 사용하지 않고 함수 안에서 전역 변수명에 다른 값을 할당하면, 파이썬은 기존의 전역변수의 값을 변경한 것이 아닌 함수 안에서 새로운 지역변수를 생성하는 것으로 간주합니다. 아래의 예시에서 확인해 보겠습니다. x = 10 y = 5 def update_x(): global x x = 20 y = 20 print("함수 안에서 호출한 x와 y 값:", x, y) update_x() print("함수 밖에서 호출한 x와 y 값:", x, y) # 결괏값 함수 안에서 호출한 x와 y 값: 20 20 함수 밖에서 호출한 x와 y 값: 20 5 위의 코드에서 x와 y 변수 모두 함수 update_x()의 밖에서 생성된 전역변수입니다. update_x() 함수 안에서 두 전역변수의 값을 변경하기 위해 x와 y 변수에 모두 20을 할당하였습니다. 이때 변수 x에 대해서는 함수 안에서 global 키워드를 사용하여 global x로 전역변수를 선언해 주었지만 변수 y에 대해서는 global로 선언해 주지 않았습니다. 그로 인해 전역변수 x의 값은 20으로 변경되었지만 전역변수 y의 값은 변경되지 않았습니다. 대신 y = 20이라는 새로운 지역변수가 함수 안에 생성되었습니다. 따라서 함수 안에서 y 값을 출력했을 때는 지역변수 y의 값인 20이 출력되었고, 함수 밖에서 y 값을 출력했을 때는 기존 전역변수 y에 할당된 값 5가 그대로 출력되었습니다. 전역변수의 사용은 코드의 복잡성을 증가시키며, 예기치 않은 오류의 원인이 될 수 있습니다. 따라서 함수 안에서만 사용되는 변수일 경우에는 전역변수 대신 함수의 인자로 전달하여 지역변수로 사용하는 것이 좋습니다. 2) 내장함수 파이썬에는 이미 특정 기능을 수행하도록 정의된 함수들이 있습니다. 이를 내장함수(Built-in function)라고 하는데, 이와 같은 내장함수는 따로 모듈을 불러올 필요 없이 파이썬에서 기본적으로 제공하여 사용할 수 있습니다. 파이썬에는 수많은 내장함수가 있으며, 이러한 내장함수는 기본적인 프로그래밍 작업을 간편하게 수행할 수 있도록 도와줍니다. 이미 우리가 앞에서 사용했던 print()나 len(), type()과 같은 함수들이 바로 파이썬 내장함수입니다. 여기서는 자주 사용되는 내장함수들을 좀 더 알아보겠습니다. 내장함수 기능 예시 int() 실수나 문자열(정수<NAME>)을 정수로 변환 int("123") float() 정수나 문자열(정수/실수<NAME>)을 실수로 변환 float(3) str() 주어진 값(정수, 실수, 리스트 등)을 문자열로 변환 str(123) list() 문자열, 튜플, 세트 등을 리스트로 변환 list({1, 2, 3}) tuple() 리스트, 문자열, 세트 등을 튜플로 변환 tuple([1, 2, 3]) set() 리스트, 문자열, 튜플 등을 세트로 변환 set([1, 2, 3]) dict() 키와 값이 쌍으로 나열된 항목들을 딕셔너리로 변환 dict([('a', 1), ('b', 2)]) max() 주어진 입력값 중 가장 큰 값을 반환 max(3, 1, 7, 4, 6) min() 주어진 입력값 중 가장 작은 값을 반환 min(3, 1, 7, 4, 6) sum() 숫자로 구성된 목록의 합계를 반환 sum([1, 2, 3, 4, 5]) input() 사용자로부터 키보드 입력을 받아 문자열로 반환 input() 위의 내장함수 중 몇 가지를 실행해 보겠습니다. list() list() 함수에 튜플이나 세트를 넣어서 리스트로 변환할 수도 있지만, 문자열을 인자로 넣으면 문자열에 포함된 문자들이 각각 리스트의 요소로 저장됩니다. lst = list("hello") print(lst) # 결괏값 ['h', 'e', 'l', 'l', 'o'] 문자열 "hello"의 각 문자들을 요소로 하는 lst 리스트가 생성되었습니다. set() 이번에는 리스트를 세트로 변환해 보겠습니다. 세트는 중복 값을 허용하지 않고 순서가 없기 때문에 리스트나 튜플, 문자열 등을 세트로 변환할 때 중복된 값이 있으면 그중 하나의 값만 요소로 저장됩니다. 또한 요소의 순서도 유지되지 않습니다. set([4, 1, 2, 2, 3, 1]) # 결괏값 {1, 2, 3, 4} 기존 리스트에서 중복된 값 1과 2는 세트로 변환될 때 하나씩만 저장되었습니다. 그리고 변환된 세트를 보면 기존 리스트와 순서도 다른 것을 확인할 수 있습니다. sum() 이번에는 sum() 함수로 여러 요소들의 합을 구해보겠습니다. numbers = [1, 2, 3, 4, 5] total_num = sum(numbers, 10) print(total_num) # 결괏값 25 sum()은 숫자 데이터로 구성된 자료들을 인자로 받아 모든 요소의 합을 반환하는 함수입니다. 이때 전달받는 인자는 숫자로 구성된 목록이나 반복 가능한 객체여야 합니다. 숫자들을 직접 인자로 전달하면 함수는 제대로 동작하지 않습니다. 주로 리스트나 튜플과 같은 반복 가능한 객체를 인자로 사용합니다. 하지만 위의 예시 코드에서는 sum() 함수에 직접 10이라는 숫자를 전달했는데 오류가 나지 않았습니다. sum()은 두 개의 인자를 받을 수 있는데, 첫 번째 인자는 반복 가능한(iterable) 객체를 넣어야 하며 주로 리스트나 튜플을 넣습니다. 두 번째 인자는 선택적으로 넣을 수 있는데 이 두 번째 인자를 start라고 부릅니다. 이 인자는 결과 합계의 시작 값입니다. 만약 이 두 번째 인자를 입력하지 않으면 기본값으로 0이 입력됩니다. 즉, 위의 코드에서 sum(numbers, 10)은 리스트 numbers의 모든 요소를 더하는데 그 시작 값을 10으로 설정하여 numbers의 합에 10을 더한 값을 반환하게 됩니다. 앞에서 sum()의 인자로 숫자를 전달하면 안 된다는 것은 반복 가능한 객체만을 전달해야 하는 첫 번째 인자로 숫자를 전달하면 안 된다는 의미이며, start의 값으로는 단일 숫자를 직접 입력할 수 있습니다. input() 마지막으로 살펴볼 내장함수는 input()입니다. input()은 파이썬에서 사용자로부터 콘솔 입력을 받기 위한 함수입니다. 사용자가 입력한 내용은 문자열로 반환됩니다. 이 함수를 사용하면 프로그램에서 동적으로 데이터를 받을 수 있어, 대화형 프로그램을 만드는데 유용합니다. 기본적인 사용법은 다음과 같습니다. user_input = input() 코드를 실행하면 사용자는 키보드로 데이터를 입력할 수 있고, 입력이 끝난 후 키보드의 Enter 키를 누르면 입력한 데이터가 user_input 변수에 저장됩니다. word = input() print(f"입력한 문자는 {word}입니다.") 주피터 노트북에서 위의 코드를 실행하면 아래와 같이 데이터를 입력할 수 있는 네모 상자가 생깁니다. 사용자는 아래 네모 상자를 클릭하여 데이터를 입력 후에 키보드의 Enter 키를 누릅니다. 상자에 "가방"이라는 글자를 입력한 다음 Enter 키를 누르면 아래와 같이 실행됩니다. # 결괏값 가방 입력한 문자는 가방입니다. 입력값 "가방"이 출력되고, 그다음에 print() 함수가 실행되어 "입력한 문자는 가방입니다."라는 문자열이 출력됩니다. 여기서 input()의 결과로 입력값 "가방"이 출력된 것은 주피터 노트북의 특성 때문이며, 다른 파이썬 환경에서 input() 함수를 실행하면 입력값을 반환하기만 할 뿐 자동으로 출력하지 않습니다. 이렇게 사용자가 입력한 데이터가 word 변수에 저장되고, 이 word 변수를 가지고 다음 라인의 print() 함수가 실행됩니다. 사용자에게 데이터를 입력받을 때 데이터 입력에 대한 어떤 메시지를 표시할 수도 있습니다. input() 함수는 선택적으로 문자열 인자를 받을 수 있습니다. 이렇게 전달한 문자열은 사용자에게 입력을 안내하는 프롬프트로 화면에 표시됩니다. 아래는 문자열 인자를 추가하여 input() 함수를 사용한 예시입니다. word = input("원하는 단어를 입력하세요: ") print(f"입력한 문자는 {word}입니다.") 위의 코드에서 "원하는 단어를 입력하세요: "라는 프롬프트 문자열입니다. 위의 코드를 실행하면 화면에 아래와 같이 표시됩니다. 사용자는 이 메시지를 보고 네모 상자에 원하는 단어를 입력해야 하는 것을 알 수 있습니다. 위의 네모 상자에도 동일하게 "가방"이라는 단어를 입력해 보겠습니다. # 결괏값 원하는 단어를 입력하세요: 가방 입력한 문자는 가방입니다. input()의 결과로 문자열 인자와 입력값이 모두 출력이 됩니다. input() 함수 사용 시 유의할 점은, input() 함수를 통해 받은 값은 기본적으로 문자열 형태입니다. 숫자나 다른 자료형으로 사용하려면 데이터를 입력받은 후에 다른 자료형으로 변환시켜야 합니다. 아래는 전달받은 데이터를 가지고 연산을 하기 위해 int()를 사용하여 데이터를 정수형으로 변환하는 예시입니다. age = input("현재 나이를 입력하세요: ") age = int(age) print(f"내년 당신의 나이는 {age + 1}세입니다.") # 결괏값 (입력값이 25일 때) 현재 나이를 입력하세요: 25 내년 당신의 나이는 26세입니다. 클래스(Class) 앞에서 함수는 특정 기능을 수행하는 코드들을 묶은 것으로 해당 기능이 필요할 때마다 함수만 호출하여 간편하게 사용할 수 있다고 학습했습니다. 함수에서 더 나아간 개념으로 파이썬에는 클래스라는 개념이 있습니다. 클래스는 일종의 설계도나 틀과 같은 것으로, 이 설계도를 토대로 실제로 사용할 수 있는 "객체"를 만들어냅니다. 클래스로부터 생성된 각 객체를 클래스의 인스턴스라고 하며, 이러한 인스턴스는 고유한 속성값을 갖고 클래스에서 정의된 메서드를 공유합니다. 이와 같이 클래스를 통해 객체를 만들고 활용하는 프로그래밍을 객체 지향 프로그래밍(Object-Oriented Programming, OOP)이라고 합니다. 코드를 작성할 때 클래스를 반드시 사용해야 하는 것은 아닙니다. 클래스를 사용하지 않고도 같은 동작을 코드로 풀어서 구현할 수 있습니다. 그렇지만 클래스를 사용함으로써 코드의 반복을 줄일 수 있고, 규모가 크고 복잡한 프로그램에서 코드에 대한 이해도를 높이고 유지 보수를 용이하게 해줍니다. 1) 클래스 선언하기 클래스를 만드는 것을 클래스를 선언한다고 표현합니다. 클래스를 선언하는 기본 구조는 다음과 같습니다. class 클래스명(): # 클래스 변수 (선택적) 변수명 = 값 # 초기화 메서드 (생성자, 선택적) def __init__(self, 매개변수 1, 매개변수 2, ...): 코드 블록 # 메서드 (선택적) def 메서드명(self, 매개변수 1, 매개변수 2, ...): 코드 블록 ... 클래스를 선언할 때는 class 키워드를 사용합니다. class 키워드 뒤에 클래스명을 입력합니다. 클래스명은 일반적으로 파스칼 케이스(PascalCase)로 작성합니다. 파스칼 케이스는 여러 단어를 연결하여 문자열을 만들 때 각 단어의 첫 글자를 대문자로 표기하는 방식이며 띄어쓰기 없이 단어를 연결합니다. 예를 들어, my class를 파스칼 케이스로 작성하면 MyClass가 됩니다. 클래스명 뒤에는 소괄호()와 콜론(:)을 순차적으로 입력하고 줄바꿈을 해줍니다. 이때 소괄호 안에는 특정 클래스나 여러 클래스를 명시하여 해당 클래스를 상속받을 수 있습니다. 특정 클래스를 상속받지 않는 경우에는 괄호를 생략할 수 있습니다. 클래스 상속에 대해서는 뒤에서 다시 다루도록 하겠습니다. 클래스명 다음 줄부터 해당 클래스에 포함되는 코드 블록을 작성하는데, 코드 블록은 모두 들여 쓰기를 하여 작성합니다. 코드 블록에는 메서드를 정의하거나 속성을 입력하며, 이때 메서드를 정의하는 순서나 속성의 순서는 코드의 실행 결과에는 영향을 주지 않습니다. 메서드(method)란 클래스에서 정의한 함수로, 해당 클래스의 인스턴스(객체)와 연관됩니다. 메서드는 첫 번째 매개변수로 그 객체 또는 클래스를 참조하는 self를 받습니다. self는 객체 생성 후 객체 자신을 참조하는 데 사용됩니다. self 뒤에는 필요에 따라 매개변수를 추가로 입력합니다. 매개변수가 필요하지 않을 경우에는 생략 가능합니다. 클래스에 메서드를 포함하고자 할 때 메서드명을 지정해야 하지만, 클래스에서 사용되는 특별한 메서드로 이미 이름이 정해진 메서드 __init__()이 있습니다. __init__() 메서드는 클래스의 인스턴스가 생성될 때 자동으로 호출되는 특별한 메서드로, 생성자라고도 합니다. 인스턴스 변수의 초기화와 같이 인스턴스의 초기 상태를 설정하는 역할을 하기 때문에 클래스의 의도와 구조를 빠르게 파악하기 위해 일반적으로 클래스의 시작 부분에 위치합니다. 클래스에서 사용하는 변수에는 클래스 변수(class variable)와 인스턴스 변수(instance variable)가 있습니다. 클래스 변수는 클래스 내부에서 정의(클래스 변수명 = 값) 되지만 메서드의 바깥에서 선언되는 변수입니다. 즉, 클래스에 속하는 변수로 해당 클래스의 모든 인스턴스들이 공유합니다. 이 변수는 클래스를 통해 접근(클래스명. 클래스 변수명) 할 수도 있고 인스턴스를 통해 접근(인스턴스명.클래스 변수명) 할 수도 있습니다. 주로 해당 클래스의 모든 객체들에 공통적으로 사용되는 값을 저장할 때 사용됩니다. 인스턴스 변수는 클래스 안에서도 메서드 내에서 정의되는 변수로, 'self'를 사용하여 정의(self. 인스턴스 변수명 = 값) 합니다. 이 변수는 특정 클래스 인스턴스에 속하며, 각 인스턴스는 자신만의 인스턴스 변숫값을 가집니다. 주로 각 객체의 고유한 상태나 데이터를 저장할 때 사용됩니다. 인스턴스 변수는 인스턴스를 통해서만 접근(인스턴스명.인스턴스 변수명) 할 수 있습니다. 클래스를 선언하는 예시 코드를 살펴보겠습니다. class Car: # 클래스 변수 total_cars = 0 # 전체 생성된 자동차의 수를 저장하는 클래스 변수 def __init__(self, brand, model): # 초기화 함수 # 인스턴스 변수 self.brand = brand # 자동차의 브랜드 초기화 self.model = model # 자동차의 모델명 초기화 # 새로운 자동차 객체가 생성될 때마다 전체_자동차_수를 1씩 증가 Car.total_cars = Car.total_cars + 1 # 메서드 def display_info(self): """자동차의 정보를 출력하는 메서드""" return f"이 자동차는 {self.brand} {self.model}입니다." 위의 예시는 Car라는 클래스를 선언하는 코드입니다. 먼저 total_cars = 0으로 클래스 변수를 만들어줍니다. 이 클래스 변수로 전체 생성된 자동차의 수를 저장합니다. def __init__으로 초기화 함수를 정의합니다. 함수의 두 번째, 세 번째 매개변수로 brand와 model을 전달받아 self.brand = brand와 self.model = model로 인스턴스 변수를 초기화합니다. 그리고 Car.total_cars = Car.total_cars + 1로 새로운 자동차 객체가 생성될 때마다 전체 자동차 수를 1씩 증가시킵니다. 그리고 문자열과 인스턴스 변수를 함께 출력하는 display_info() 메서드도 정의하였습니다. 2) 객체 생성 및 활용하기 이번에는 선언한 클래스에서 객체를 생성하고 인스턴스 변수와 메서드를 활용하는 방법을 알아보겠습니다. 클래스에서 객체를 생성하는 방법은 다음과 같습니다. 객체명 = 클래스명(인자 1, 인자 2, ...) 객체를 생성할 때는 init 메서드에 설정된 매개변수의 개수와 순서가 일치하는 인자들을 괄호 안에 함께 전달합니다. 클래스에서 함수를 만들 때 입력했던 첫 번째 매개변수 self는 입력하지 않습니다. 만약 init 메서드에 매개변수가 없거나 모든 매개변수에 기본값이 설정되어 있다면 객체를 생성할 때 매개변수를 전달하지 않아도 됩니다. 이와 같이 객체를 생성하는 것을 객체 인스턴스화라고도 표현합니다. 위와 같이 객체를 생성한 후에는 인스턴스의 변수에 접근해 속성을 가져오거나 메서드를 사용할 수 있습니다. 인스턴스 변수에 접근하는 방법은 앞에서 학습한 것과 같이 인스턴스명.인스턴스 변수명입니다. 그리고 메서드는 인스턴스명.메서드명(인자1, 인자 2, ...)로 실행할 수 있습니다. 여기서 인자는 메서드를 정의할 때 설정했던 매개변수의 개수와 순서에 일치해야 합니다. 매개변수가 없는 경우에는 인자는 생략하고 빈 소괄호()로 실행합니다. 여기서도 self는 입력하지 않습니다. # 클래스를 사용하여 객체 생성 car1 = Car("현대", "소나타") car2 = Car("기아", "K5") # 객체의 메서드 호출 print(car1.display_info()) print(car2.display_info()) # 클래스 변수에 접근 print(Car.total_cars) # 결괏값 이 자동차는 현대 소나타입니다. 이 자동차는 기아 K5입니다. 앞에서 선언했던 클래스 Car의 인스턴스 car1과 car2를 생성하고 display_info() 메서드를 사용하여 인스턴스 변수를 포함한 문자열을 출력하였습니다. 그리고 마지막에는 print(Car.total_cars)로 클래스 변수도 출력해 보았습니다. 3) 클래스 상속 클래스 상속은 객체 지향 프로그래밍에서의 핵심 개념 중 하나로, 어떤 클래스(부모 클래스 또는 슈퍼 클래스)의 속성과 메서드를 다른 클래스(자식 클래스 또는 서브 클래스)가 물려받을 수 있게 하는 작동 원리입니다. 상속을 사용하면 코드의 재사용성을 높일 수 있으며, 기존 코드를 변경하지 않고 기능을 확장하거나 수정할 수 있습니다. 상속을 받을 때는 class 키워드를 사용하여 클래스를 선언할 때 클래스명 뒤 소괄호() 안에 상속받을 부모 클래스명을 입력합니다. class 부모 클래스: ... class 자식 클래스(부모 클래스): ... 자식 클래스는 부모 클래스의 모든 속성과 메서드를 상속받지만, 필요에 따라 일부를 재정의(overriding) 하여 사용할 수 있습니다. 다른 클래스를 상속받는 클래스의 예시 코드는 다음과 같습니다. # 부모 클래스로 사용할 Animal 클래스 class Animal: def __init__(self, name): self.name = name def make_sound(self): print("동물의 소리") # Animal 클래스를 상속받는 Dog 클래스 class Dog(Animal): def make_sound(self): # Animal 클래스의 make_sound 메서드를 재정의 print(f"{self.name}가 멍멍!") # Animal 클래스를 상속받는 Cat 클래스 class Cat(Animal): pass # 고양이 클래스는 Animal 클래스의 모든 메서드를 그대로 상속 # 객체 생성 및 활용 dog1 = Dog("맥스") dog1.make_sound() cat1 = Cat("피치") cat1.make_sound() # 결괏값 맥스가 멍멍! 동물의 소리 먼저 부모 클래스로 사용할 Animal 클래스를 선언하였습니다. Animal 클래스에 포함된 요소를 살펴보면 init 메서드와 make_sound 메서드가 있습니다. init 메서드로 인스턴스 변수 name을 초기화하고, make_sound 메서드는 "동물의 소리"라는 문자열을 출력합니다. 이 Animal 클래스를 상속받는 Dog 클래스를 생성합니다. Class Dog(Animal):와 같이 클래스를 선언할 때 클래스명 뒤 괄호에 부모 클래스명(Animal)을 넣어줍니다. 이를 통해 Animal 클래스의 모든 속성과 메서드를 상속받을 수 있지만, 상속받은 메서드 중 make_sound 메서드를 재정의하여 print()로 출력할 문자열의 내용을 변경하였습니다. 그리고 동일한 방식으로 Animal 클래스를 상속받는 또 다른 클래스 Cat을 선언합니다. Cat 클래스는 Animal 클래스의 모든 메서드를 그대로 상속하기 위해 코드 블록에 pass만 입력하였습니다. 이제 상속받은 두 클래스의 객체를 생성해 보겠습니다. Dog 클래스의 객체 dog1을 생성합니다. 인자로 "맥스"를 입력하여 init 메서드에 전달되었으며 인스턴스 변수 name에 "맥스"가 저장됩니다. Cat 클래스의 객체 cat1도 동일한 방식으로 생성합니다. 이렇게 생성한 dog1과 cat1으로 각각 make_sound 메서드를 실행했을 때, 출력된 값이 각각 다른 것을 확인할 수 있습니다. object 클래스 object 클래스는 파이썬에서 모든 클래스의 기본 클래스입니다. 다시 말해, 파이썬의 모든 클래스는 명시적으로 다른 클래스를 상속받지 않는 한, 암시적으로 object 클래스를 상속받게 됩니다. 이 object 클래스는 파이썬의 모든 객체의 기본적인 메서드들(예: init, str, repr 등)을 제공합니다. 따라서 사용자 정의 클래스에서 이러한 기본 메서드를 재정의하지 않는 한 object 클래스의 기본 구현이 사용됩니다. class Person: # 암시적으로 object 클래스를 상속 def __init__(self, name): self.name = name 사실 위의 코드는 아래와 같습니다. class Person(object): # 명시적으로 object 클래스를 상속 def __init__(self, name): self.name = name 그렇지만 지금 사용되는 파이썬(3.x)은 클래스를 정의할 때 명시적으로 object를 상속받을 필요가 없습니다. 따라서 대부분의 코드에서 object 클래스를 상속한다는 (object)를 생략하고 class Person:과 같은<NAME>으로 클래스를 정의하게 됩니다. 지금까지 함수와 클래스의 기본적인 내용에 대해 살펴보았습니다. 사실 함수와 클래스는 훨씬 더 깊고 복잡한 주제이며, 매우 다양한 기능과 사용법이 있습니다. 하지만 지금까지 학습한 함수와 클래스의 기본적인 이해를 바탕으로 업무 자동화를 하기에는 충분할 것이라 생각합니다. 함수와 클래스에 대해 더 깊이 알기 위해서는 아래의 파이썬 공식 문서를 참고하기를 바랍니다. *파이썬 공식 문서(함수): https://docs.python.org/3/tutorial/controlflow.html#defining-functions *파이썬 공식 문서(클래스): https://docs.python.org/3/tutorial/classes.html 02-05. 모듈, 패키지, 라이브러리 이번 챕터에서는 모듈과 패키지, 그리고 라이브러리에 대해 학습하겠습니다. 모듈(module) 지금까지 배운 변수와 함수, 클래스 등의 코드를 모아서 하나의 파일로 저장하면 지금 실행하고 있는 프로그램 외에도 다른 프로그램에서도 불러와서 코드를 실행할 수 있습니다. 이렇게 어떤 특정한 작업을 하기 위해 관련된 여러 변수와 함수, 클래스 등을 모아서 만들어진 하나의. py 파일을 "모듈"이라고 합니다. 모듈은 함수, 변수, 클래스 등을 정의할 수 있으며, 이를 다른 파이썬 파일에서 재사용하기 위해 만들어집니다. 예를 들어, 우리가 숫자 계산과 관련된 여러 기능(더하기, 빼기, 곱하기, 나누기)을 자주 사용한다면, 이러한 기능들을 모아서 calculator.py라는 파일에 저장할 수 있습니다. 이 calculator.py 파일은 계산기(calculator) 모듈이라고 할 수 있습니다. 모듈 생성하기 모듈은 모듈명.py의<NAME>으로 파일을 저장하여 만들 수 있습니다. 모듈명은 소문자로 작성하며 여러 단어를 연결해야 하는 경우에는 일반적으로 밑줄(_)을 사용해 단어를 연결합니다. 저장하는 방법은 코드를 작성한 후에 텍스트 에디터나 IDE에서 해당 파일을. py 확장자로 저장하면 됩니다. 주피터 노트북에서는 상단의 'File'메뉴에서 'Download as' > 'Python (.py)' 옵션을 선택하면 현재 노트북의 모든 코드 셀의 내용을. py 확장자로 저장할 수 있습니다. # calculator.py def add(a, b): return a + b def subtract(a, b): return a - b # ... 기타 다른 계산 함수들 위의 코드에서는 calculator 모듈에 여러 계산 함수들을 정의하였습니다. 이렇게 모듈을 만들면 이후 다른 파이썬 코드에서도 계산이 필요한 경우 이 calculator 모듈을 불러와서 사용할 수 있기 때문에 편리합니다. 모듈을 만들 때 유의할 점은 math와 같이 파이썬 표준 라이브러리에 이미 존재하는 모듈명으로 모듈을 만드는 것은 피해야 합니다. 이렇게 생성한 모듈은 import 모듈명으로 불러와서 사용할 수 있습니다. 위에서 생성한 calculator 모듈을 불러와서 add 함수를 실행해 보겠습니다. import calculator result = calculator.add(4, 55) print(result) # 결괏값 59 import calculator로 해당 모듈을 불러오고, 이렇게 임포트 한 모듈에 포함된 함수나 클래스, 변수를 사용할 때는 모듈. 함수(), 모듈. 클래스(), 모듈. 변수와 같은<NAME>으로 사용합니다. 모듈을 불러올 때는 여러 가지 방법을 사용할 수 있습니다. import 모듈명 from 모듈명 import 변수명/함수명/클래스명 하나는 앞서 살펴본 것처럼 import 모듈명으로 모듈 전체를 불러오는 것이고, 또 다른 방법은 from 모듈명 import 변수명(함수명/클래스명)으로 지정된 함수나 변수만 불러오는 것입니다. 두 가지 방식에는 몇 가지 차이점이 있습니다. 위의 예제를 가지고 설명하면 import calculator를 실행하면 calculator 모듈 전체를 불러오기 때문에 모듈에 포함된 변수나 함수, 클래스 모두를 사용할 수 있습니다. 대신 모듈에 정의된 함수나 변수를 사용할 때 calculator.add(4, 55)처럼 모듈 이름을 접두사로 사용해야 합니다. 반면, 두 번째 방식을 사용하여 from calculator import add, subtract와 같이 불러오면 지정된 함수나 변수만 현재 이름 공간(namespace)에 직접 불러옵니다. 따라서 불러온 함수나 변수를 사용할 때 모듈 이름을 접두사로 사용할 필요가 없어 add(4, 55)와 같은 방식으로 간결하게 코드 사용이 가능합니다. 또한 필요한 항목만 불러오기 때문에 메모리와 성능 측면에서 효율적입니다. 다만 첫 번째 방법은 함수나 변수 호출 시 모듈의 이름을 명시적으로 사용하기 때문에 다른 모듈과 이름이 충돌할 가능성이 줄어들지만, 두 번째 방법은 현재 이름 공간에 동일한 이름의 다른 함수나 변수가 있으면 충돌이 발생할 수 있습니다. 또한 두 번째 방식을 사용할 경우 직접 지정한 항목 외에는 해당 모듈에 포함된 다른 함수나 변수를 사용할 수 없습니다. 여기서 이름 공간(namespace)는 변수, 함수, 클래스, 모듈 등의 식별자(identifier)가 저장되는 공간을 의미합니다. 즉, 이름과 객체가 연결되어 저장되는 공간이라고 볼 수 있습니다. 프로그램에서 정의된 변수나 함수가 저장되는 전역 이름 공간(Global Namespace), 함수나 메서드 내부에서 정의된 변수가 저장되는 지역 이름 공간(Local Namespace), 파이썬에 기본적으로 포함된 내장 함수와 예외들이 저장되는 내장 이름 공간(Built-in Namespace) 등 파이썬에는 여러 이름 공간이 존재합니다. 모듈을 import 하면 모듈 이름 공간이 생기는데, 모듈은 각 모듈별로 각자의 네임스페이스를 갖기 때문에 변수나 함수 이름의 충돌을 피할 수 있습니다. from 모듈명 import * from 모듈명 import 변수명(함수명/클래스명) 대신에 from 모듈명 import *를 사용하여 해당 모듈에 정의된 모든 변수, 함수, 클래스 등을 직접 가져오는 방식도 있습니다. 이 방식을 사용하면 모듈 내의 모든 항목을 모듈명 없이 바로 사용할 수 있습니다. 하지만 앞서 언급했던 이름 충돌과 같은 이슈가 발생할 수 있고, 불필요한 항목까지 모두 import되어 비효율적일 수 있습니다. import 모듈명 as 별명 from 모듈명 import 변수명/함수명/클래스명 as 별명 또 다른 방법으로는 as 키워드를 사용하여 불러온 모듈에 다른 이름(별명)을 붙여줄 수 있습니다. import 모듈명 as 별명으로 as 뒤에 별명을 넣어주면 해당 모듈을 별명으로 사용할 수 있습니다. from 모듈명 import 변수명/함수명/클래스명 as 별명로 사용하면 지정한 항목을 별명으로 가지고 옵니다. calculator 모듈의 add 함수를 사용한다고 가정할 때, import calculator as cal로 가져오면 cal.add(4, 55)로 함수를 사용합니다. from calculator import add as cal_add로 가져오면 cal_add(4, 55)로 사용할 수 있습니다. 보통 이와 같은 방식은 임포트 하는 모듈의 이름이 너무 길거나 복잡할 때, 또는 다른 모듈과 이름이 충돌할 위험이 있거나 보다 직관적인 이름으로 항목을 참조하고 싶은 경우에 사용합니다. 주피터 노트북에서 모듈 사용 시 유의사항 주피터 노트북에서는 한 번 import된 모듈을 수정한 후에 다시 import 해도 수정된 내용이 반영되지 않습니다. 이는 주피터 노트북이 모듈을 메모리에 한 번 로드한 후에는 같은 세션에서는 해당 모듈의 새로운 버전을 다시 가져오지 않기 때문입니다. 따라서 모듈의 수정된 내용을 반영하려면 상단 메뉴에서 'Kernel > Restart'를 선택하여 커널을 재시작하고 모듈을 다시 import 하거나 importlib 라이브러리의 reload 함수를 사용하여 모듈을 다시 로드하여야 합니다. importlib의 reload 함수는 다음과 같이 사용합니다. from importlib import reload reload(모듈명) reload를 사용하면 전체 커널을 재시작하지 않고도 수정된 내용을 반영할 수 있기 때문에 개발 중에 모듈을 자주 수정하는 경우에는 reload를 사용하는 것이 더 효율적일 수 있습니다. 내장 모듈 파이썬에는 표준 라이브러리의 일부로 파이썬 설치와 함께 제공되는 모듈들이 있습니다. 이러한 모듈을 내장 모듈이라고 하며, 이러한 모듈은 별도의 설치 없이 import 명령을 사용하여 바로 사용할 수 있습니다. 내장 모듈은 다양한 프로그램이 작업을 위한 기능들을 제공합니다. 예를 들어 datetime 모듈은 날짜와 시간 관련 기능을 제공하고, os 모듈은 운영체제와 상호작용하기 위한 함수들을 제공합니다. 앞으로 파이썬 업무 자동화를 위해 학습할 내용들에도 여러 내장 모듈을 사용하는 방법이 포함되어 있습니다. 따라서 이후 각 내장모듈을 사용할 때 각각의 모듈에 대해 살펴보도록 하겠습니다. 패키지(Package) 패키지는 여러 모듈을 묶어놓은 구조를 말합니다. 파이썬에서 패키지는 디렉터리(폴더)와 그 디렉터리 내의 모듈로 구성되어 있습니다. 패키지를 사용함으로써 모듈들을 계층적(디렉터리 구조)으로 관리할 수 있게 되며, 이는 큰 프로젝트나 라이브러리의 구조화에 큰 도움이 됩니다. 우리가 파이썬 업무 자동화를 위해 패키지를 만들지는 않을 것이기 때문에 여기서는 간략하게 패키지의 개념을 이해하고 패키지를 사용하는 방법에 대해 알아보겠습니다. 패키지는 디렉터리와 모듈로 구성되어 있습니다. 디렉터리는 패키지를 구성하는 기본 단위로, 디렉터리 안에는 여러 모듈과 서브 디렉터리(서브 패키지)가 포함될 수 있습니다. 각 디렉터리가 패키지로 인식되게 하는 파일로 init.py이라는 특별한 파일이 있습니다. 파이썬 3.3 이전에는 이 파일이 있어야만 디렉터리가 패키지로 인식되었지만 3.3 이후로는 init.py 파일이 없어도 디렉터리가 패키지로 인식됩니다. 하지만 이 파일에 패키지 초기화 코드를 포함할 수도 있고, 이전 버전과의 호환성을 위해서도 보통 이 파일을 포함시키는 편입니다. 패키지 구조의 예를 살펴보겠습니다. my_package/ ├── __init__.py ├── module1.py └── sub_package/ ├── __init__.py └── module2.py 위의 my_package 패키지는 init.py와 module1.py가 패키지에 포함되어 있으며 그 하위에 sub_package 폴더가 있습니다. 그리고 이 sub_package 패키지에는 또다시 init.py와 module2.py가 포함되어 있습니다. 패키지를 사용할 때는 파이썬 스크립트나 인터프리터에서 import 문을 사용하여 패키지나 패키지 내의 모듈을 가져옵니다. 예시를 통해 사용 방법에 대한 이해를 돕기 위해 위의 my_package 패키지에서 'module1.py'에는 다음과 같은 함수가 정의되어 있다고 가정해 보겠습니다. def hello(): return "Hello from module1!" 먼저 패키지 전체를 가져오는 기본 방법은 다음과 같습니다. import 패키지 명[.하위 폴더명] 위의 패키지 구조 예시에서 사용한 my_package 패키지로 설명하자면, import my_package로 패키지 전체를 가져옵니다. 이렇게 불러오면 my_pakcage 내의 모듈은 별도로 가져오지 않는 한 접근할 수 없습니다. 따라서 모듈 내의 함수나 클래스, 변수를 사용하고자 할 때도 패키지명[.하위폴더명].모듈명.변수명/함수명/클래스명의<NAME>으로 호출해야 합니다. modul1의 hello 함수를 사용하려면 my_package.module1.hello()의 형태로 호출해야 합니다. 위와 같이 패키지 전체를 가지고 오는 대신 패키지의 특정 모듈만 가져올 수도 있습니다. import 패키지명[.하위폴더명].모듈명 위와 같은 방식을 예시 코드에서 사용한다면 import my_package.module1으로 module1을 가져올 수 있습니다. 다만 이 방식도 동일하게 모듈에 있는 함수나 클래스, 변수 등을 사용하려면 전체 경로를 명시해야 합니다. 즉, 동일하게 my_package.module1.hello()로 hello 함수를 사용할 수 있습니다. 이처럼 전체 경로를 명시하는 번거로움을 줄이려면 'from ... import ...'의 형태를 사용하면 됩니다. from 패키지 명[.하위 폴더명] import 모듈명 이 방식으로 module1을 불러온다면 from my_package import module1이 될 것입니다. 하위 폴더 sub_package에 있는 module2를 불러올 경우에는 from my_package.sub_package import module2가 될 것입니다. 이와 같이 from ... import ...<NAME>을 사용하면 모듈을 직접적으로 현재 네임스페이스로 불러와서 module1의 함수, 클래스, 변수 등을 직접 참조할 수 있게 됩니다. 따라서 모듈에 포함된 항목을 사용할 때는 모듈명.변수명/함수명/클래스명으로 호출합니다. 이와 같은 방식으로 hello 함수를 사용한다면 module1.hello()로 호출할 수 있습니다. 위의 방식보다도 더 간단하게 함수나 변수, 클래스를 호출하려면 다음과 같이 직접 변수나 함수, 클래스를 지정하여 import 하면 됩니다. from 패키지명[.하위폴더명].모듈명 import 변수명/함수명/클래스명 이와 같은 방식으로 hello 함수를 가지고 온다면 from my_package.module1 import hello가 될 것입니다. 이렇게 특정 함수나 변수, 클래스를 import 할 경우 모듈명을 사용할 필요 없이 hello()와 같이 바로 해당 항목을 호출할 수 있습니다. 또는 모듈의 모든 변수, 함수, 클래스를 가져오되 모듈명 없이 간단하게 사용하려면 다음과 같은 방식을 사용합니다. from 패키지명[.하위폴더명].모듈명 import * 이처럼 from ... import ...<NAME>도 다양하게 사용할 수 있습니다. 다만 from ... import ... 방식을 사용하면 같은 이름의 다른 모듈이나 항목들(변수, 함수, 클래스)이 이미 임포트 되어 있다면 이름 충돌이 발생할 수 있기 때문에 이를 주의해야 합니다. 지금까지 살펴본 모든 import 방식에 as 키워드를 추가로 사용할 수도 있습니다. import 패키지 명[.하위 폴더명] as 별명 import 패키지 명[.하위 폴더명].모듈명 as 별명 from 패키지 명[.하위 폴더명] import 모듈명 as 별명 from 패키지명[.하위폴더명].모듈명 import 변수명/함수명/클래스명 as 별명 패키지를 불러오기 위해 import 문을 사용할 때 몇 가지 주의할 점이 있습니다. 하나는 파이썬의 sys.path에 패키지가 위치한 디렉터리가 포함되어 있어야 한다는 것입니다. 파이썬에서 모듈을 임포트 할 때, 해당 모듈이 어디에 위치해 있는지 찾기 위해 sys.path라는 변수에 등록된 경로들을 참조합니다. sys는 파이썬의 표준 라이브러리 중 하나로, 파이썬 인터프리터와 관련된 연산들을 제공하는 모듈입니다. sys.path는 sys 모듈 내의 변수로, 파이썬이 모듈을 어디에서 찾아야 하는지 알려주는 경로 리스트입니다. 기본적으로 현재 작업 중인 디렉터리(즉, 파이썬 스크립트를 실행한 디렉터리)는 sys.path에 포함되어 있습니다. 따라서 현재 디렉터리에 있는 파이썬 파일은 바로 임포트 할 수 있습니다. 하지만 다른 위치에 있는 모듈을 임포트 하려면, 그 위치가 sys.path에 포함되어 있어야 합니다. sys.path에 경로를 추가할 때는 append를 사용합니다. 경로 리스트에를 경로를 추가하는 코드는 다음과 같습니다. import sys sys.path.append('/path/to/directory') 위의 코드를 사용하면 /path/to/directory가 sys.path에 추가됩니다. 이렇게 하면 해당 디렉터리에 있는 파이썬 모듈이나 패키지를 임포트 할 수 있습니다. 그리고 패키지 내부에서 다른 모듈을 참조할 때는 '상대 경로'를 사용해서 임포트 할 수 있습니다. 예를 들어, moduleA와 moduleB 두 개의 모듈이 동일한 패키지 안에 있다고 가정합니다. 이때 moduleA에서 moduleB의 함수나 클래스를 사용하려면, from .moduleB import 함수명처럼 점(.)을 사용한 상대 경로를 사용하여 임포트 할 수 있습니다. 여기서 점(.)은 "현재 패키지"를 의미합니다. 즉, 현재 패키지의 다른 모듈을 가져온다면 from . import 모듈명이 나 from .모듈명 import 함수명/변수명/클래스명으로 사용하고, 하위 패키지의 모듈이라면 from. 하위 패키지 import 모듈명 또는 from .하위패키지.모듈명 import 함수명/변수명/클래스 명의<NAME>으로 다른 모듈을 상대 참조합니다. 패키지를 사용하면 여러 모듈을 그룹화하여 관리하고, 코드를 더욱 구조화하여 프로젝트의 규모가 커져도 유지 보수와 확장이 쉽습니다. 또한 관련 모듈과 데이터를 함께 묶어서 재사용하거나 다른 사람들과<NAME>기 쉽다는 장점이 있습니다. 파이썬에는 전 세계의 많은 개발자들이 만든 다양한 패키지들이 있으며, 공개된 패키지들도 많아서 필요한 패키지를 설치해서 사용하는 것이 가능합니다. 예를 들어 pandas는 데이터 분석 및 조작을 위한 라이브러리로 테이블<NAME>의 데이터를 다루기 위한 데이터 프레임(DataFrame) 객체를 다루며, beautifulsoup4는 웹 스크래핑을 위한 도구로 HTML과 XML을 파싱 하게 해줍니다. 여기서 언급한 pandas와 beautifulsoup은 우리도 업무 자동화를 위해 학습할 패키지들로 뒤에서 자세히 다루겠습니다. 이러한 공개 패키지는 윈도 명령창에서 pip install 패키 지명으로 설치하거나 주피터 노트북에서! pip install 패키 지명으로 설치하여 사용할 수 있습니다. 파이썬 패키지 저장소(PyPI: https://pypi.org/)에서 필요한 패키지를 검색하고 패키지에 대한 정보를 확인할 수 있습니다. 라이브러리(Library) 라이브러리는 하나 이상의 관련 모듈이나 패키지들의 집합을 의미합니다. 특정 작업을 쉽게 처리할 수 있도록 사전에 정의된 코드의 집합체라고 볼 수 있습니다. 앞에서 학습한 "패키지"와 "라이브러리"라는 용어는 종종 혼용되어 사용되기도 합니다. 여러 모듈이나 서브 패키지들을 포함하며 디렉터리로 구조화한 것을 '패키지'라고 하고, 그런 패키지를 포함한 더 큰 의미의 코드의 집합체를 '라이브러리'라고 하지만 실제로는 두 용어가 구분 없이 사용되고 있습니다. 예를 들어, requests는 "HTTP 요청을 위한 파이썬 라이브러리"라고도 설명되지만 동시에 패키지 형태로 구성되어 있어 "패키지"라고도 불립니다. 라이브러리를 설치하고 사용하는 방식도 패키지에서 학습한 내용과 같습니다. 라이브러리를 설치할 때도 동일하게 pip 명령어로 설치하며, 불러올 때도 import를 사용합니다. 라이브러리도 마찬가지로 from ... import ...<NAME>으로 특정 모듈이나 함수 등을 지정하여 불러오는 것도 가능합니다. 그리고 라이브러리를 불러온 방식에 따라 포함된 요소를 호출하는 방식이 달라집니다. 라이브러리를 설치하기 전에는 해당 라이브러리의 공식 문서나 홈페이지를 참조하여 호환성, 필요한 의존성 등을 확인하는 것이 좋습니다. 라이브러리가 특정 파이썬 버전에 최적화되어 작성되었을 수도 있고, 라이브러리에 포함된 어떠한 기능을 제공하기 위해 다른 라이브러리들이 필요할 수도 있습니다. 따라서 공식 문서나 홈페이지를 통해 필요한 정보를 충분히 확인하는 것을 권장합니다. 또한 라이브러리의 버전에 따라 기능이나 사용법이 다를 수 있으므로, 특정 버전을 사용해야 하는 경우 pip install 라이브러리명==버전번호<NAME>으로 설치하면 됩니다. 지금까지 모듈과 패키지, 라이브러리에 대해 학습합니다. 간단하게 요약하면, 모듈은 하나의 파이썬 파일, 패키지는 여러 모듈들을 구조적으로 관리하는 방법, 그리고 라이브러리는 특정 기능을 제공하기 위한 코드의 집합(모듈 또는 패키지)이라고 볼 수 있습니다. 02-06. 경로 설정 이번 장에서는 경로와 관련된 파이썬의 여러 기능들에 대해 학습하겠습니다. 업무 자동화를 하기 위해서 특정 경로에 있는 파일을 파이썬으로 읽어오거나 다른 경로에 저장하는 등 파이썬에 경로에 대한 정보를 전달해야 하는 경우가 많이 있습니다. 파이썬에서는 경로를 처리하는 몇 가지 방식들이 있어서 상황과 작업 스타일에 따라 원하는 방식으로 경로를 처리하면 됩니다. 절대 경로와 상대 경로 경로를 처리하는 방법에 대해 학습하기 전에 파이썬에서 경로를 지정하는 두 가지 방식을 먼저 살펴보겠습니다. 앞서 '02-05. 모듈, 패키지, 라이브러리' 챕터에서 잠깐 언급한 것처럼, os 모듈은 운영체제와 상호작용하기 위한 함수들을 제공하는 모듈입니다. 따라서 os 모듈을 통해 파일 및 디렉터리 경로를 처리할 수 있습니다. 그리고 os.path 하위 모듈을 통해 경로 관련 다양한 함수도 사용할 수 있습니다. os 모듈과 os.path로 경로를 처리하는 몇 가지 함수들을 살펴보겠습니다. os 모듈은 파이썬의 표준 라이브러리에 포함되어 있는 모듈로 import os로 불러와서 바로 사용할 수 있습니다. 함수 의미 예시 getcwd() 현재 작업 디렉터리를 반환 os.getcwd() mkdir() 지정된 경로에 새로운 디렉터리(폴더)를 생성 os.mkdir(path) exists() 지정된 경로가 존재하는지 확인 (True/False 값 반환) os.path.exists(path) isdir() 지정된 경로가 디렉터리인지 확인 (True/False 값 반환) os.path.isdir(path) isfile() 지정된 경로가 파일인지 확인(True/False 값 반환) os.path.isfile(path) abspath() 지정된 경로의 절대 경로를 반환 os.path.abspath(path) join() 운영 체제에 맞게 경로를 연결하여 새 경로를 생성 os.path.join(path1, path2) split() 경로를 디렉터리와 파일로 분리(튜플로 반환) os.path.split() 위의 함수들 중 join()과 split()을 조금 더 살펴보겠습니다. 먼저 os.path.join() 함수는 여러 개의 경로 구성 요소를 안전하게 결합하여 하나의 경로 문자열을 생성하는 데 사용됩니다. 이 함수는 운영 체제에 따라 적절한 디렉터리 구분 문자(예: 윈도에서는 역슬래시(), 대부분의 UNIX 기반 시스템에서는 슬래시(/))를 사용하여 경로를 결합합니다. 직접 경로 구분 문자를 사용하여 문자열을 결합하는 방식으로 경로를 만들 수도 있지만, 다른 운영 체제에서 코드를 실행할 경우 오류가 발생할 수 있습니다. 그렇지만 os.path.join()을 사용하면 코드가 여러 플랫폼에서 예상대로 동작하게 됩니다. import os path1 = "mydir" path2 = "myfile.txt" # 디렉터리 구분 문자(\)를 사용하여 경로 결합 # 이스케이프 처리를 피하기 위해 역슬래시를 두 번 사용(\\) full_path = path1 + "\\" + path2 print(full_path) import os path1 = "mydir" path2 = "myfile.txt" # os.path.join()을 사용하여 경로 결합 full_path = os.path.join(path1, path2) print(full_path) # 결괏값 mydir\myfile.txt 위의 두 코드 모두 "mydir"과 "myfile.txt"를 결합하여 경로를 생성하였습니다. 첫 번째 예제 코드인 문자열을 직접 결합하는 방식과 두 번째 예제 코드인 os.path.join()을 사용하는 방식 모두 결과는 동일하게 "mydir\myfile.txt" 경로를 생성하였습니다. 그렇지만 문자열 직접 결합과는 달리 os.path.join()을 사용하면 어떤 운영체제에서든 오류 없이 경로를 생성할 수 있습니다. 다음으로 os.path.split()을 살펴보겠습니다. os.path.split() 함수는 파일 경로를 분리하여 디렉터리와 파일명으로 반환합니다. 이 함수는 주어진 경로의 마지막 구성 요소와 그 이전의 부분으로 경로를 나누어 튜플 형태로 반환합니다. 반환되는 튜플을 언 패킹하여 두 개의 변수에 각각 저장하여 추가 작업이 가능합니다. import os path = "C:/Users/User Name/Documents/example.txt" directory, filename = os.path.split(path) print("디렉터리:", directory) print("파일명:", filename) # 결괏값 디렉터리: C:/Users/User Name/Documents 파일명: example.txt 이 함수는 디렉터리 구조를 분석할 때 유용하게 사용될 수 있습니다. 특히 주어진 파일 경로에서 상위 디렉터리와 파일명을 분리할 때 이 함수를 사용하면 간단하게 작업을 수행할 수 있습니다. 뒤에서 학습할 '03-01. 윈도 폴더 및 파일 다루기'에서 특정 경로에 있는 폴더나 파일을 다룰 때 os 모듈이나 os.path 모듈을 사용할 예정입니다. 따라서 다른 os 모듈은 뒤에 다시 한번 자세히 알아보겠습니다. 2) pathlib 모듈 pathlib은 파이썬 3.4부터 표준 라이브러리에 포함된 모듈로, 파일 시스템 경로를 객체 지향적으로 다루기 위해 설계되었습니다. os 및 os.path와는 다르게, pathlib은 경로를 문자열이 아닌 객체로 처리하므로, 경로와 관련된 다양한 작업을 더 직관적이고 간결하게 수행할 수 있습니다. pathlib 모듈의 주요 클래스로 Path 클래스가 있습니다. Path 클래스를 사용하여 경로를 다루는 방법에 대해 알아보겠습니다. 먼저 아래와 같이 pathlib의 Path 클래스를 import 한 후 Path 클래스의 객체를 생성합니다. from pathlib import Path p = Path('C:/Users/User Name/Documents/example.txt') Path 클래스의 객체(p)를 생성할 때 Path()의 괄호 안에 경로를 입력합니다. 경로는 절대 경로와 상대 경로 모두 가능합니다. 객체를 생성한 후 Path 클래스의 속성과 메서드를 사용할 수 있습니다. 다음은 주로 사용되는 Path 클래스의 속성입니다. 예시 부분에서는 위에서 생성한 객체(p)를 사용하였습니다. 속성 의미 예시 parts 지정된 경로를 구성하는 요소들을 튜플로 반환 p.parts drive 지정된 경로의 드라이브 부분을 반환 p.drive root 지정된 경로의 루트 부분을 반환 p.root anchor 지정된 경로의 드라이브와 루트 부분을 반환 p.anchor name 지정된 경로의 파일 이름을 반환 p.name suffix 지정된 경로의 확장자를 반환 p.suffix stem 지정된 경로의 파일 이름을 반환(확장자 제외) p.stem 다음은 Path 클래스의 주요 메서드입니다. 역시 동일하게 위에서 생성한 객체(p)를 사용하여 예시 코드를 작성하였습니다. 메서드 의미 예시 cwd() 현재 작업 디렉터리를 반환 p.cwd() home() 홈 디렉터리를 반환 p.home() exists() 지정된 경로가 존재하는지 확인 (True/False 값 반환) p.exists() is_dir() 지정된 경로가 디렉터리인지 확인 (True/False 값 반환) p.is_dir() is_file() 지정된 경로가 파일인지 확인(True/False 값 반환) p.is_file() resolve() 상대 경로를 절대 경로로 변환하여 반환 p.resolve() joinpath() 운영 체제에 맞게 경로를 연결하여 새 경로를 생성 p.joinpath(path1, path2) rmdir() 빈 디렉터리를 삭제 p.rmdir() mkdir() 지정된 경로에 새로운 디렉터리(폴더)를 생성 p.mkdir() unlink() 파일 또는 심벌릭 링크를 삭제 p.unlink() touch() 지정된 디렉터리에 빈 파일을 생성 p.touch() 몇 가지 속성과 메서드를 같이 살펴보겠습니다. 먼저 joinpath 메서드는 여러 경로 구성요소들을 결합하여 하나의 경로를 만듭니다. 이 메서드는 다양한 운영 체제에서 작동하도록 설계되었기 때문에 OS 별로 경로를 구분하는 문자(/ 또는 )에 대해 걱정할 필요가 없습니다. 이와 같이 os 모듈과 pathlib 모듈은 모두 파일과 디렉터리의 절대 경로와 상대 경로를 다룰 수 있으며, 같은 기능을 하거나 유사한 결과를 이끌어낼 수도 있습니다. 그렇지만 pathlib은 객체지향적이고 직관적인 인터페이스를 제공하며, os의 기능을 포함해 더 풍부한 메서드와 속성을 제공하고 있어 더 많은 작업들을 쉽게 할 수 있다는 장점이 있습니다. 참고) 윈도 명령어 파이썬 프로그램 내에서도 윈도 명령어를 실행할 수 있습니다. 윈도 명령어란 윈도 운영 체제에서 명령 프롬프트(Command Prompt)를 통해 실행할 수 있는 명령어를 의미합니다. 이러한 윈도 명령어 중에도 디렉터리나 파일, 경로와 관련된 관련된 명령어들이 있습니다. 경로 관련 주요 윈도 명령어에 대해서도 알아보겠습니다. 아래에서 예시 부분은 주피터 노트북에서 실행할 때의 예시 코드입니다. 있고, 어떤 명령어는 없는 것을 볼 수 있습니다. 기본적으로는 느낌표(!)를 명령어 앞에 붙여서 실행하지만 일부 명령어는 바로 명령어만 사용하여 실행할 수 있습니다. 위의 명령어 중 cd 명령어의 경우, 주피터 노트북에서 실행할 경우 디렉터리 변경이 임시적이며 지속되지 않습니다. 즉, cd 명령어를 실행하여 디렉터리를 변경한 후, 그 셀에서의 이후의 명령어들은 그 변경된 디렉터리에서 실행되지 않습니다. 따라서 cd로 변경한 디렉터리에 대한 내용을 확인하거나 추가적인 명령어를 실행하려면! cd new_directory && dir와 같이 모든 명령어를 동일한 셀에서 실행해야 합니다. 위에서 살펴본 명령어들은 운영 체제에 종속적이기 때문에 윈도가 아닌 리눅스나 macOS에서는 다르게 작동하게 됩니다. 또한 윈도 명령어를 사용하게 되면 작업을 수행할 때 발생하는 에러나 예외를 파이썬에서 직접 처리하기 어려울 수 있으며, 보안 이슈가 발생할 수도 있습니다. 따라서 파이썬에서 윈도 명령어를 이용해 파일이나 디렉터리, 경로를 다루는 것은 가능하지만 앞에서 배운 os 모듈이나 pathlib을 이용하는 것이 더 안전합니다. 02-07. 정규식 정규 표현식(정규식, Regular Expression)이란 간단히 말해서 형태에 특정한 규칙이 있는 문자열을 의미합니다. 특정한 형태의 문자열을 검색하거나 추출, 치환하는 등의 작업을 위해 문자열의 패턴을 정의하는 도구라고 생각하면 됩니다. 정규식은 파이썬뿐만 아니라 다른 여러 프로그램 언어나 텍스트 편집기에서도 널리 통용되는 개념입니다. 정규식은 그 내용이 매우 광범위하고 복잡합니다. 따라서 지금 여기서 정규식에 대해 깊이 학습하기보다는 파이썬 업무 자동화에서 사용할 수 있는 간단한 정규식들을 위주로 간략히 알아보도록 하겠습니다. 메타 문자 정규식에서는 문자열의 패턴을 만들 때 특별한 의미로 사용하는 문자들이 있습니다. 그 문자들을 메타 문자라고 하며, 여러 메타 문자들을 조합하여 다양한 문자열의 패턴을 표현할 수 있습니다. 주로 많이 사용되는 메타 문자를 살펴보겠습니다. 메타 문자 의미 . 하나의 문자 자릿수를 의미 (공백을 제외한 모든 문자 가능) ^ 문자열의 시작 패턴 $ 문자열의 끝 패턴 * 바로 앞에 있는 문자가 0번 이상 반복 + 바로 앞에 있는 문자가 1번 이상 반복 ? 바로 앞에 있는 문자가 있을 수도 없을 수도 있음 {n} 바로 앞에 있는 문자가 n 번 반복 {n, m} 바로 앞에 있는 문자가 최소 n 번 이상 최대 m 번 이하로 반복 () 괄호 안의 문자들을 그룹으로 처리 [] 괄호 안의 문자들 중 하나와 일치 [^] ^뒤에 있는 괄호 안의 문자들 제외 [-] -앞과 뒤에 있는 문자들 사이의 문자 | |앞의 문자 또는(OR) |뒤의 문자 메타 문자 중에는 백슬래시()와 영어 알파벳의 조합으로 사용되는 특수 문자도 있습니다. 메타 문자 의미 \d 숫자 한자리를 의미. [0-9]와 동일 \D 숫자가 아닌 문자 한자리 \w 문자 한자리. 알파벳+숫자+언더 스코어( _ ) 중 하나의 문자. [a-zA-Z0-9_]와 동일 \W 알파벳+숫자+언더 스코어( _ )가 아닌 문자 한자리 \s 공백이나 탭 한자리 \S 공백이나 탭이 아닌 문자 한자리 여기서 살펴본 메타 문자는 일부이며 사용할 수 있는 메타 문자는 훨씬 다양합니다. 메타 문자에 대해 더 자세히 알고 싶다면 파이썬 공식 문서에서 're'모듈에 관한 부분을 참고하면 됩니다. Python 공식 문서 (re 모듈) : https://docs.python.org/ko/3/library/re.html 're'모듈을 활용한 정규식 작업 이제 위에서 알아본 메타 문자를 활용한 간단한 정규식 작업들을 알아보겠습니다. 먼저 import로 파이썬의 내장 모듈인 're'를 불러옵니다. import re 다음은 're'모듈에서 주로 사용되는 몇 가지 함수들입니다. re.match() 're'모듈의 match 함수는 문자열의 시작 부분이 정규식 패턴과 일치하는지 확인하는 함수입니다. 패턴과 문자열 시작 부분이 일치하지 않으면 'None'을 반환합니다. import re # 패턴 정의: 하나 이상의 숫자에 일치 pattern = r"\d+" # 검사할 문자열 string = "123abc" # 문자열의 시작부터 패턴과 일치하는 부분을 찾기 result = re.match(pattern, string) # 결과가 있으면 일치하는 문자열을 출력 if result: print("일치: ", result.group()) else: print("불일치") # 결괏값 일치: 123 위의 코드에서 정의된 정규식 패턴은 "\d+"로 하나 이상의 숫자에 일치한다는 의미입니다. re.match()로 문자열 "123abc"의 시작 부분이 패턴과 일치하는지 확인하였으며, 시작 부분의 "123"이 패턴과 일치하여 결과를 반환했습니다. re.search() re.search()는 문자열에서 정규식 패턴과 일치하는 첫 번째 부분을 찾습니다. 패턴과 일치하는 부분을 찾으면 match 객체를 반환하고, 찾지 못하면 None을 반환합니다. import re # 패턴 정의: 하나 이상의 숫자에 일치 pattern = r"\d+" # 검사할 문자열 string = "abc123def456" # 문자열에서 패턴과 일치하는 첫 번째 부분을 찾기 result = re.search(pattern, string) # 결과가 있으면 일치하는 문자열을 출력 if result: print("일치: ", result.group()) else: print("불일치") # 결괏값 일치: 123 re.search()로 문자열에서 주어진 정규식 패턴("\d+")과 일치하는 부분이 있는지 찾습니다. 문자열 "abc123def456"에는 패턴과 일치하는 부분이 있기 때문에 if 문에서 일치할 때에 해당하는 결괏값을 반환합니다. re.findall() re.findall()은 문자열에서 정규식 패턴과 일치하는 모든 부분을 찾아 리스트로 반환합니다. 일치하는 부분이 없으면 빈 리스트를 반환합니다. import re # 패턴 정의: 하나 이상의 숫자에 일치 pattern = r"\d+" # 검사할 문자열 string = "abc123def456" # 문자열에서 패턴과 일치하는 모든 부분을 찾아 리스트로 반환 result = re.findall(pattern, string) print("일치: ", result) # 결괏값 일치: ['123', '456'] re.findall()은 일치하는 모든 부분을 찾기 때문에 앞서 re.search()를 실행했을 때와 출력된 내용이 다른 것을 알 수 있습니다. 만약 일치하는 부분이 하나라면 re.search()를 실행했을 때와 값은 동일하겠지만 re.findall()은 그 결과를 리스트로 반환하기 때문에 반환된 형태는 다를 것입니다. re.sub() 문자열에서 정규식 패턴과 일치하는 부분을 다른 문자열로 대체합니다. 대체 문자열은 repl 파라미터로 지정됩니다. import re # 패턴 정의: 하나 이상의 숫자에 일치 pattern = r"\d+" # 검사할 문자열 string = "abc123def456" # 대체할 문자열 replacement = "000" # 문자열에서 패턴과 일치하는 부분을 다른 문자열로 대체 result = re.sub(pattern, replacement, string) print("결과: ", result) # 결괏값 결과: abc000def000 re.sub()은 기본적으로 정규식 패턴과 일치하는 모든 부분을 찾아서 주어진 문자열로 대체합니다. 하지만 일치하는 모든 부분을 대체하지 않고 특정 일치 항목까지만 대체 작업을 실행하는 것도 가능합니다. 그렇게 하기 위해서는 re.sub()을 사용할 때 count를 설정해 주어야 합니다. 예를 들어 count=1로 설정한다면 첫 번째 일치 항목까지만 대체 작업을 실행한다는 의미입니다. 별도의 count 값을 주지 않으면 count=0이 기본값으로 설정되어 있어 일치하는 모든 부분을 대체합니다. re.compile 정규식 패턴을 컴파일(컴퓨터가 이해할 수 있는 형태로 변환) 하여 정규식 객체를 반환합니다. 컴파일된 객체는 여러 메서드(match(), search(), findall(), sub() 등)를 제공하여 정규식 작업을 수행할 수 있습니다. import re # 패턴 정의: 하나 이상의 숫자에 일치 pattern = re.compile(r"\d+") # 검사할 문자열 string = "abc123def456" # 컴파일된 정규식 객체를 사용하여 search 메서드 호출 result = pattern.search(string) # 결과가 있으면 일치하는 문자열을 출력 if result: print("일치: ", result.group()) else: print("불일치") # 결괏값 일치: 123 지금까지 이전 예제들에서는 패턴을 컴파일하지 않고, pattern = r"\d+"와 같이 단순히 문자열을 pattern 변수에 저장하였는데 이는 단순히 정규식의 패턴을 정의한 것이라고 볼 수 있습니다. 이와 달리 pattern = re.compile(r"\d+")처럼 re.compile 함수를 사용하면 단순히 패턴을 정의한 것에 그치지 않고 해당 정규식 패턴을 미리 컴파일(컴퓨터가 이해할 수 있는 형태로 변환) 하여 pattern 변수에 저장합니다. 앞에서와 같이 컴파일하지 않은 패턴을 사용하여 re 모듈의 함수를 호출하면, 파이썬은 호출할 때마다 내부적으로 매번 패턴을 컴파일하게 됩니다. 하지만 미리 컴파일한 패턴을 사용하면, 여러 번 함수를 호출하여 정규식 연산을 수행해도 정규식 패턴을 처음에 한 번만 컴파일 하기 때문에 성능이 향상됩니다. 지금까지 파이썬 정규 표현식에 대해 간략히 알아보았습니다. 정규 표현식을 알면 이후 배우게 될 문서를 다루는 코드와 결합하여 데이터 작업에 사용할 수 있습니다. 복잡한 문자열에서 필요한 정보만 추출하거나 데이터를 정제하는 작업 등 다양한 영역에서 활용할 수 있습니다. 앞서 말했듯 여기서 다룬 정규식과 're'모듈의 내용은 일부이며, 더 자세히 정규식에 대해 알고 싶다면 파이썬 공식 문서를 참고하기 바랍니다. 02-08. 기타 문법 예외 처리 파이썬에서 코드를 작성해서 실행하다 보면 다양한 오류가 발생하는 것을 볼 수 있습니다. 메모리 부족과 같이 시스템의 문제로 발생한 오류(Error)도 있지만, 프로그램이 정상적으로 실행하다가 뜻밖의 경우를 마주쳐서 발생하는 오류도 있을 수 있습니다. 예를 들어 파이썬으로 나누기 연산을 실행하는데 분모에 숫자 0이 전달된다면 나누기를 할 수 없어서 오류가 발생할 것입니다. 이처럼 프로그램 실행 중에 예기치 못한 상황을 마주쳤을 때 발생하는 오류를 예외(Exception)라고 합니다. 오류가 발생하면 프로그램이 중단되는데, 예외 상황일 때 어떻게 처리할지를 미리 설정해두면 프로그램이 갑자기 종료되는 것을 방지할 수 있습니다. 예외 처리를 할 때는 보통 try ~ except를 사용합니다. 기본 구조는 다음과 같습니다. try: 원래 실행하려는 코드 블록 except: 예외 처리 코드 블록 영어 단어 try의 뜻인 '시도하다'를 생각하면 이해하기 쉬운데, 원래의 코드를 시도해 보고 에러가 발생하면(except) 예외 처리 코드를 실행하라는 의미입니다. 기본적으로는 try와 except 뒤에는 바로 콜론(:)을 붙인 다음 줄바꿈을 하고, 들여 쓰기를 한 다음 코드를 입력합니다. 다음은 try ~ except를 사용하여 예외 처리를 하는 예시 코드입니다. numbers = [1, 2, 3] try: print(numbers[3]) except: print("해당 인덱스에 대한 요소가 리스트에 없습니다.") # 결괏값 해당 인덱스에 대한 요소가 리스트에 없습니다. 위의 예시 코드에서는 총요소가 3개인 numbers 리스트에서 네 번째 요소(numbers[3])를 가져오도록 하는 코드입니다. try ~ except를 사용하여 코드를 실행하고 만약 예외가 발생할 경우 "해당 인덱스에 대한 요소가 리스트에 없습니다."를 출력하도록 예외 처리를 하였습니다. 위에서 발생한 오류는 IndexError인데, 만약 발생하는 오류의 종류를 알고 해당 오류에 대해서만 예외 처리를 하고 싶다면 except 바로 뒤에 오류의 종류를 넣어줍니다. 다음은 오류의 종류를 지정하여 예외 처리를 하는 예시입니다. try: result = 10 / 0 print(result) except ZeroDivisionError: print("0으로 나눌 수 없습니다.") # 결괏값 0으로 나눌 수 없습니다. 위에서 발생한 오류는 숫자를 0으로 나눌 수 없어서 생긴 오류(ZeroDivisionError)입니다. 따라서 except ZeroDivisionError:를 사용하여 해당 오류에 대해서만 예외 처리를 하였습니다. 예외 처리의 또 다른 방법 중 하나는 예외가 발생하든 안 하든 상관없이 항상 특정한 작업을 수행하도록 finally를 사용하는 것입니다. finally는 다음과 같은 구조로 사용됩니다. try: 원래 실행하려는 코드 블록 except: 예외 처리 코드 블록 finally: 마지막으로 항상 수행하는 코드 블록 이 경우에는 코드를 실행했을 때 오류가 없다면 try 뒤의 코드 블록이 실행되고, 오류가 발생한 경우에는 except 뒤의 코드 블록이 실행되지만 두 경우 모두 마지막에는 finally 뒤의 코드 블록이 항상 실행됩니다. 다음과 같이 except를 쓰지 않고 try ~ finally로 사용하기도 합니다. try: 원래 실행하려는 코드 블록 finally: 마지막으로 항상 수행하는 코드 블록 다음은 finally를 사용한 예시 코드입니다. my_list = [1, 2, 3, 4, 5] try: print(my_list[10]) except IndexError: print("해당 인덱스는 리스트 범위를 벗어났습니다.") finally: print("이 코드는 항상 실행됩니다.") # 결괏값 해당 인덱스는 리스트 범위를 벗어났습니다. 이 코드는 항상 실행됩니다. 복합 대입 연산자 파이썬에서는 대입 연산자를 축약하여 사용할 수 있는 복합 대입 연산자들이 있습니다. 이러한 복합 대입 연산자들은 변수의 값을 갱신하거나 연산한 결과를 변수에 할당하는 데 사용됩니다. 덧셈 복합 대입 연산자 (+=): 이 연산자는 변수에 값을 더한 후 결과를 변수에 다시 할당합니다. 예를 들어, x += 5는 x = x + 5와 동일한 효과를 가지며, x에 현재 값에 5를 더한 결과를 다시 x에 할당합니다. x = 10 x += 5 # x = x + 5와 동일 print(x) # 출력 결과: 15 뺄셈 복합 대입 연산자 (-=): 이 연산자는 변수에서 값을 뺀 후 결과를 변수에 다시 할당합니다. 예를 들어, x -= 3은 x = x - 3과 동일한 효과를 가지며, x에서 현재 값에 3을 뺀 결과를 다시 x에 할당합니다. x = 10 x -= 3 # x = x - 3과 동일 print(x) # 출력 결과: 7 곱셈 복합 대입 연산자 (*=): 이 연산자는 변수의 값을 곱한 후 결과를 변수에 다시 할당합니다. 예를 들어, x *= 2는 x = x * 2와 동일한 효과를 가지며, x의 현재 값에 2를 곱한 결과를 다시 x에 할당합니다. x = 5 x *= 2 # x = x * 2와 동일 print(x) # 출력 결과: 10 나눗셈 복합 대입 연산자 (/=): 이 연산자는 변수의 값을 나눈 후 결과를 변수에 다시 할당합니다. 예를 들어, x /= 3은 x = x / 3과 동일한 효과를 가지며, x의 현재 값에 3으로 나눈 결과를 다시 x에 할당합니다. x = 15 x /= 3 # x = x / 3과 동일 print(x) # 출력 결과: 5.0 (나눗셈 결과는 실수로 표현됨) 나머지 복합 대입 연산자 (%=): 이 연산자는 변수를 다른 값으로 나눈 나머지를 변수에 다시 할당합니다. 예를 들어, x %= 4는 x = x % 4와 동일한 효과를 가지며, x의 현재 값에 4로 나눈 나머지를 다시 x에 할당합니다. x = 10 x %= 4 # x = x % 4와 동일 print(x) # 출력 결과: 2 이러한 복합 대입 연산자들은 코드를 간결하게 작성하고 가독성을 높일 수 있습니다. 변수의 값을 갱신하거나 연산한 결과를 할당할 때 유용하게 사용할 수 있으며, 반복문 등에서 특히 자주 사용됩니다. 02-09. 문자열 처리 이번 챕터에서는 다양한 문자열 처리 방법에 대해 학습하겠습니다. 업무 자동화를 하기 위해서는 실제 업무에서 사용하는 데이터를 읽어와야 하고, 읽어온 데이터를 분석하거나 추가 가공을 할 수도 있습니다. 이러한 처리를 하기 위해서는 먼저 읽어온 데이터에 불필요한 문자열이 있으면 제거해 주거나, 문자열들을 서로 연결하거나 분리하는 등의 가공을 먼저 해주어야 합니다. 파이썬에는 이와 같은 문자열 처리를 간편하게 해주는 다양한 내장 메서드와 연산자를 제공합니다. 여기서는 주요 문자열 처리 방법에 대해 알아보겠습니다. 기본 문자열 연산 앞에서 학습한 것처럼 문자열도 연산이 가능합니다. a + b : 문자열 a와 문자열 b를 연결하기 a = "Hello" + " " + "World" print(a) # 결괏값 Hello World a * b : 문자열 a를 숫자 b 만큼 반복하기 a = "Hello " * 3 print(a) # 결괏값 Hello Hello Hello 문자열 인덱싱 및 슬라이싱 문자열도 인덱싱과 슬라이싱이 가능합니다. 문자열 인덱싱은 문자열에 포함된 각 문자에 인덱스를 부여해 특정 위치에 있는 문자에 접근합니다. 문자열 인덱싱도 마찬가지로 인덱스는 0부터 시작합니다. s = "Python" first_char = s[0] last_char = s[-1] print(first_char) print(last_char) # 결괏값 n 문자열 "Python"에서 첫 번째 인덱스(s[0])와 마지막 인덱스(s[-1])에 접근합니다. 예시에서 보는 것처럼 문자열 인덱싱에서도 음수 인덱스 사용이 가능하여 문자열의 끝에서부터 문자에 접근할 수 있습니다. 문자열에 인덱스가 부여되기 때문에 슬라이싱으로 문자열의 일부를 추출하는 것도 가능합니다. 문자열 슬라이싱도 역시 동일하게 문자열[start:end] 형태로 사용하며, end의 인덱스는 포함되지 않습니다. s = "Python" sub_string = s[1:4] print(sub_string) # 결괏값 yth 리스트 슬라이싱에서와 마찬가지로 시작이나 끝의 인덱스를 생략하여 각각 처음부터 시작하거나 마지막까지 슬라이 싱하는 것이 가능하며, 간격을 건너뛰며 문자열을 가지고 올 수도 있습니다. 문자열 메서드 1) 대소문자 변환: lower(), upper() 파이썬은 알파벳의 대문자와 소문자를 구분합니다. 따라서 문자열을 비교할 때 대소문자 구분 없이 비교하려면 문자열을 대문자 또는 소문자로 변환해야 합니다. lower() 메서드는 모든 대문자를 소문자로 변환하고, 반대로 upper() 메서드는 모든 소문자를 대문자로 변환합니다. s = "Python" print(s.lower()) print(s.upper()) # 결괏값 python PYTHON 2) 문자열 분리 및 결합: split(), join() 문자열을 특정 문자나 문자열을 기준으로 분리하거나 여러 개의 문자열을 하나로 결합해야 하는 경우에는 각각 split()과 join() 메서드를 사용합니다. 문자열을 분리할 때 사용하느 split() 메서드의 사용법은 다음과 같습니다. str.split(sep=None, maxsplit=-1) 이 메서드는 주어진 구분자('sep')를 기준으로 문자열(str)을 여러 부분으로 나누어 리스트로 반환합니다. 여기서 괄호 안의 부분은 생략할 수 있습니다. sep를 지정하지 않으면 기본값으로 공백 문자(스페이스, 탭, 줄바꿈 등)를 사용합니다. maxsplit은 분리할 최대 횟수를 의미하며, 기본값은 -1로 제한 없이 분리한다는 뜻입니다. 문자열을 결합할 때 사용하는 join() 메서드의 기본 사용법은 다음과 같습니다. str.join(iterable) 이 메서드는 주어진 반복 가능한 객체('iterable', 보통 리스트나 튜플)의 문자열 원소들을 하나의 문자열로 결합합니다. 결합 시 구분자 문자열(str)이 각 원소 사이에 삽입됩니다. 다음은 split()과 join() 메서드를 활용하여 문자열을 분리하고 결합시키는 예시 코드입니다. s = "Hello, World" words = s.split(", ") new_string = " ".join(words) print(words) print(new_string) # 결괏값 ['Hello', 'World'] 'Hello World' 위의 코드에서 s.split(", ")은 문자열("Hello, World")을 분리하기 위해 split 메서드에 쉼표(,)를 구분자로 전달합니다. 그리고 문자열이 분리되어 리스트로 저장된 words 변수를 사용해 " ".join(words)로 공백을 구분자로 하여 문자열을 재결합합니다. 출력된 결괏값을 보면 첫 번째 변수 words에 저장된 값(분리된 각 문자열을 요소로 하는 리스트)과 두 번째 변수 new_string(공백을 구분자로 재결합된 문자열)이 각각 출력되었습니다. 3) 불필요한 문자열 제거: strip() strip() 메서드는 문자열의 시작과 끝에서 지정된 문자들을 제거합니다. 주로 문자열의 앞뒤에 있는 공백(스페이스, 탭, 줄바꿈 등)을 제거할 때 사용됩니다. strip()의 기본 사용법은 다음과 같습니다. str.strip(chars=None) chars 인자에 특정 문자나 문자열을 지정하면 해당 문자들만 문자열(str)의 앞과 뒤에서 제거됩니다. chars 인자를 지정하지 않으면 기본적으로 공백문자를 제거하며, 이와 같이 사용할 경우에는 괄호 안을 생략할 수 있습니다. 만약 문자열(str)의 앞과 뒤에 지정한 문자열이 없으면 str을 그대로 반환합니다. chars에 여러 개의 문자를 지정할 수도 있으며, 여러 개의 문자를 지정할 경우에 순서는 상관이 없습니다. s = " Hello " s.strip() # 결괏값 'Hello' 위의 코드에서는 s.strip()으로 인자에 아무것도 입력하지 않아 문자열 " Hello "의 앞뒤 공백 문자가 제거되었습니다. strip() 메서드와 비슷한 두 가지 관련 메서드로 lstrip()과 rstrip()이 있습니다. lstrip()은 문자열의 왼쪽(시작) 부분에서만 지정된 문자들을 제거하며, rstrip()은 문자열의 오른쪽(끝) 부분에서만 지정된 문자열을 제공합니다. 만약 사용할 문자열 데이터에서 시작 부분이나 끝부분 중 한 쪽에만 제거할 문자열이 있는 경우에는 lstrip()이나 rstrip()을 사용합니다. 4) 문자열 찾기: find(), count(), startswith(), endswith() 특정 문자열이 포함되어 있는지 찾는 여러 메서드들을 알아보겠습니다. find() 먼저 find() 메서드는 다음과 같이 사용합니다. str.find(substr, start, end) find() 메서드는 주어진 문자열(str)에서 찾으려는 검색 문자열(substr)이 시작하는 첫 인덱스를 반환합니다. 문자열의 위치는 0부터 시작하며, 찾으려는 문자열(substr)이 주어진 문자열(str)에 없을 경우 -1을 반환합니다. 검색 문자열(substr)이 주어진 문자열(str)에 여러 번 나올 경우에도 해당 문자열이 처음 나온 위치의 인덱스만 반환됩니다. 위의 기본 구조에서 괄호 안의 substr은 찾을 문자열이며, start는 검색을 시작할 인덱스, end는 검색을 종료할 인덱스를 의미합니다. 따라서 start와 end를 설정하면 주어진 문자열(str)에서도 특정 범위를 지정하여 검색 문자열(substr)을 찾을 수 있습니다. start와 end 옵션은 입력하지 않을 수 있으며, start를 지정하지 않으면 처음부터 검색하고 end를 지정하지 않으면 문자열 끝까지 검색합니다. 다음은 find()를 사용하는 예시 코드입니다. s = "Hello, World" s.find("World") # 결괏값 문자열 "Hello, World"에서 검색 문자("World")를 찾고 해당 문자열이 시작하는 첫 인덱스, 즉, W가 시작하는 인덱스인 7을 반환합니다. count() find()가 검색 문자열이 시작하는 첫 인덱스를 반환한다면, count()는 검색 문자열이 몇 개 포함되어 있는지를 개수를 반환합니다. count()의 기본 사용법은 다음과 같습니다. str.count(substr, start, end) substr은 찾으려는 검색 문자열이며, find() 메서드와 마찬가지로 start와 end로 검색을 시작하거나 종료할 인덱스를 지정할 수 있습니다. 반환값은 문자열(str)에 검색 문자열(substr)이 포함된 횟수이며 포함되지 않았을 경우에는 0을 반환합니다. 다음은 count()를 사용한 예시 코드입니다. s = "Hello, World. Welcome to the World of Python." count_world = s.count("World") print(count_world) # 결괏값 startswith()와 endswith() 이번에 살펴볼 startswith()와 endswith()는 각각 주어진 문자열이 검색 문자열로 시작하거나 끝나는지를 확인하는 메서드입니다. 사용법은 다음과 같습니다. str.startswith(prefix, start, end) str.endswith(suffix, start, end) startswith()는 주어진 문자열(str)이 확인하려는 시작 문자열(prefix)로 시작하면 True를 반환하고 그렇지 않으면 False를 반환합니다. endswith()는 주어진 문자열(str)이 확인하려는 종료 문자열(suffix)로 끝나면 True를 반환하고 그렇지 않으면 False를 반환합니다. find()나 count()처럼 start와 end 옵션을 지정하여 확인하려는 범위를 지정할 수도 있습니다. 다음은 startswith() 메서드와 endswith() 메서드를 사용하는 예시 코드입니다. s = "Hello, World" is_starting = s.startswith("Hell") is_ending = s.endswith("orld") print(is_starting) print(is_ending) # 결괏값 True True 문자열 교체: replace() replace() 메서드는 주어진 문자열에서 지정한 문자열을 찾아 다른 문자열로 바꿀 때 사용합니다. str.replace(old, new, count) replace() 메서드는 주어진 문자열(str)에서 지정된 문자열(old)을 찾아서 새로운 문자열(new)로 대체합니다. count는 대체 작업을 수행할 횟수로, 지정하지 않을 경우에는 모든 지정된 문자열(old)을 새로운 문자열(new)로 대체합니다. s = "apple apple apple" result = s.replace("apple", "orange", 2) print(result) # 결괏값 orange orange apple 위의 예시 코드에서는 대체할 횟수를 2로 지정하였기 때문에 전체 문자열 시작 부분부터 "apple"과 일치하는 두 개의 문자열이 "orange"로 대체되었습니다. 문자열 포맷팅 문자열 포맷팅은 문자열 내에 특정 값을 삽입하거나, 문자열을 특정<NAME>에 맞게 변경할 때 사용합니다. 파이썬에서 문자열 포맷팅을 할 수 있는 여러 방법들을 알아보겠습니다. 1) % 포맷팅 % 포맷팅은 문자열 내에서 포맷 지정자를 사용하여 값을 삽입할 위치와<NAME>을 지정합니다. 기본 구조는 다음과 같습니다. "포맷 지정자가 포함된 문자열" % (삽입할 값) 큰따옴표(") 사이에 포맷 지정자가 포함된 문자열을 입력하고 뒤에 % 기호를 사용한 뒤 소괄호()에 포맷 지정자의 위치에 대체하여 삽입할 값을 입력합니다. 포맷 지정자는 문자열 안에서 변수나 값의 정확한 표시 위치와 표시<NAME>을 지정하는 역할을 합니다. 주요 포맷 지정자는 다음과 같습니다. 포맷 지정자 의미 %s 문자열 %d 정수 %f 부동소수점 숫자 %x 16진수 %o 8진수 %e<NAME> 표기법으로 표현된 부동소수점 숫자 설명 보다 실제 사용한 예시를 보면 이해가 쉬워집니다. 포맷 지정자를 사용하는 예를 살펴보겠습니다. name = "Alice" "Hello, %s" % name # 결괏값 'Hello, Alice' "Hello, %s"라는 문자열 안에 포맷 지정자 %s가 포함되어 있습니다. 이 포맷 지정자는 문자열 포맷 지정자로 해당 위치에 문자열의<NAME>으로 값을 삽입합니다. % name으로 변수 name의 값을 포맷 지정자 위치에 삽입합니다. 그 결과 name 변수의 값인 Alice가 해당 위치에 삽입되어 최종 결괏값 'Hello, Alice'를 반환합니다. print("I have %d apples and % 0.2f oranges." % (5, 4.5678)) # 결괏값 I have 5 apples and 4.57 oranges. 이번에는 정수를 삽입하는 %d와 부동소수점 숫자를 삽입할 수 있는 %f가 문자열 안에 포함되어 있습니다. 삽입할 값은 각각 5와 4.5678로 삽입할 순서에 맞게 소괄호() 안에 쉼표(,)를 사용하여 나열되어 있습니다. 따라서 %d의 위치에는 정숫값 5가, %f의 위치에는 부동소수점 숫자 4.5678이 삽입됩니다. 이때 %f 사이에 0.2라는 숫자가 들어있어 문자열 안에 % 0.2f가 표시되어 있습니다. 이는 소수점 두 번째 자리까지만 표시하라는 의미입니다. 이처럼 %f를 사용할 때 소수점 자릿수를 지정할 수 있습니다. 그 결과 4.5678이 그대로 삽입되지 않고 소수점 둘째 자리까지만 표시되어 4.57이 삽입된 것을 볼 수 있습니다. 2) str.format() 메서드 str.format() 메서드는 문자열 내의 중괄호 {}를 포맷 지정자로 사용하여 값을 삽입합니다. 기본 사용법은 다음과 같습니다. "중괄호 {}가 포함된 문자열".format(삽입할 값) 문자열 안에 중괄호가 포함되어 있고 중괄호가 있는 위치에 삽입할 값을 format() 메서드의 인수로 전달합니다. 문자열 안에 여러 중괄호가 있어 여러 값을 삽입할 경우에는 삽입할 순서대로 인수들을 쉼표로 나열합니다. print("I have {} apples and {} oranges.".format(5, 4)) # 결괏값 I have 5 apples and 4 oranges. 또는 다음과 같이 중괄호 안에 인덱스를 넣어서 인수들을 순서대로 할당할 수도 있고, 키워드를 사용하여 특정 값을 지정하는 방법을 사용할 수도 있습니다. 다음은 각각 중괄호 안에 인덱스와 키워드를 사용한 예시 코드입니다. print("My name is {0} and I am {1} years old.".format("Alice", 30)) print("My name is {name} and I am {age} years old.".format(name="Alice", age=30)) # 결괏값 My name is Alice and I am 30 years old. My name is Alice and I am 30 years old. str.format() 메서드는 리스트나 딕셔너리 등 다양한 데이터 타입과 함께 사용될 수 있습니다. fruits = ["apple", "banana", "cherry"] print("I like {} and {}.".format(fruits[0], fruits[2])) # 결괏값 I like apple and cherry. 위의 예제에서는 리스트의 요소를 인덱싱으로 접근하여 format() 메서드의 인수로 입력하였습니다. 이와 같은 방식으로 리스트의 특정 요소들을 format() 메서드의 인수로 전달할 수 있습니다. 다음은 format() 메서드를 딕셔너리와 함께 사용한 예시입니다. person = {'name': 'Alice', 'age': 30} print("My name is {person[name]} and I am {person[age]} years old.".format(person=person)) # 결괏값 My name is Alice and I am 30 years old. {person[name]}과 같이 딕셔너리 person의 키 name과 age를 중괄호 안에 넣어서 각 키에 해당하는 값을 가져와 중괄호에 할당합니다. 또는 아래와 같이 format()의 인수로 넣을 딕셔너리명 앞에 기호 ** 을 붙여 딕셔너리를 언 패킹하는 방식을 사용할 수도 있습니다. 딕셔너리를 언 패킹하면 문자열 부분의 중괄호 안에 {name}과 같이 딕셔너리의 키만 넣어서 표시할 수 있습니다. print("My name is {name} and I am {age} years old.".format(**person)) str.format() 메서드는 문자열 포맷팅에 유연하게 대응할 수 있도록 많은 기능들을 제공하며, 특히 복잡한 포맷팅이나 다양한 데이터 타입을 다룰 때 유용합니다. 3) f-strings 파이썬 3.6에서 도입된 f-strings는 문자열 앞에 f 또는 F 접두어를 붙이면, {} 내에 변수나 표현식을 직접 작성하여 포맷팅 할 수 있습니다. f"{변수나 표현식}이 포함된 문자열" f-strings의 기본 사용법은 위와 같이 문자열 앞에 f나 F를 붙여줍니다. 그리고 문자열 안에는 중괄호{}가 포함되어 있으며 중괄호 안에는 변수나 표현식이 입력되어 있습니다. 다음의 예시를 통해 설명해 보겠습니다. name = "지형" age = 28 print(f"제 이름은 {name}이고 나이는 {age}세입니다.") print(f"5 곱하기 4는 {5 * 4}.") # 결괏값 제 이름은 지형이고 나이는 28세입니다. 5 곱하기 4는 20. 첫 번째 print() 부분을 보면, 먼저 문자열 앞에 접두어로 f를 사용하였고, 문자열 내의 중괄호에 변수명 name과 age가 각각 입력되어 있습니다. 따라서 이 코드를 실행하면 {name}과 {age} 부분에 각 변수에 저장된 값들이 할당됩니다. print(f"5 곱하기 4는 {5 * 4}.")에서는 중괄호 {} 안에 표현식 5 * 4가 입력되어 있습니다. 이와 같이 표현식이 입력되어 있을 경우에는 코드가 실행되면 중괄호 안의 표현식이 계산된 후 결괏값이 해당 중괄호에 할당됩니다. 중괄호 안에 콜론(:)을 사용하여 해당 위치에서의 출력<NAME>을 지정할 수도 있습니다. 문자열 정렬, 너비 지정, 숫자<NAME> 등과 같은 다양한<NAME> 지정이 가능합니다. 아래에서 몇 가지<NAME>을 지정하는 예시 코드를 함께 살펴보겠습니다. ratio = 0.756 print(f"Conversion rate: {ratio:.2%}") # 결괏값 Conversion rate: 75.60% 위의 예시 코드는 숫자<NAME>을 지정하는 방법을 보여줍니다. 중괄호 부분 {ratio:.2%}만 살펴보면 변수 ratio 뒤에 콜론(:)을 사용한 다음. 2%를<NAME>으로 지정하였습니다. 여기서 '.2'는 소수점 둘째 자리까지만 표현한다는 의미이며, %는 숫자 뒤에 기호 %를 붙이라는 의미입니다. 그로 인해 75.60%가 해당 위치에 할당되었습니다. 다음은 정렬 옵션과 출력 너비를 지정하는 예시 코드입니다. name = "Alice" print(f"{name:<10}") print(f"{name:>10}") print(f"{name:^10}") # 결괏값 Alice Alice Alice 위의 코드에서 중괄호 {name:<10}의 '<'은 변수 name을 할당하되 문자열을 왼쪽 정렬하라는 의미입니다. 숫자 '10'은 전체 출력 너비를 10으로 설정하는 것으로, 값인 Alice가 해당 위치에 할당되면서 왼쪽 정렬 후 뒤에 5개의 공백이 추가됩니다. {name:>10}와 {name:^10}도 같은 원리로 작동하며 '>'는 오른쪽 정렬, '^'는 가운데 정렬을 의미합니다. 모두 출력 너비를 10으로 설정했기 때문에 {name:>10}에서는 Alice가 오른쪽 정렬되고 그 앞에 5개의 공백이 추가되며, {name:^10}는 가운데 정렬이기 때문에 Alice의 앞과 뒤에 각각 2개와 3개의 공백이 추가됩니다. 그리고 f-strings 역시 format() 메서드와 마찬가지로 리스트나 딕셔너리 등 다양한 데이터 타입과 함께 사용할 수 있습니다. 다음은 리스트를 함께 사용한 예시 코드입니다. fruits = ["apple", "banana", "cherry"] print(f"I like {fruits[0]} and {fruits[2]}.") # 결괏값 I like apple and cherry. 다음은 f-strings에 딕셔너리를 함께 사용한 예시입니다. person = {'name': 'Alice', 'age': 30} print(f"My name is {person['name']} and I am {person['age']} years old.") # 결괏값 My name is Alice and I am 30 years old. f-strings는 코드를 간결하고 읽기 쉽게 만들어주기 때문에 문자열 포맷팅을 할 때 많이 사용되는 도구 중 하나입니다. 지금까지 문자열을 처리하는 여러 방식들에 대해 살펴보았습니다. 각각의 방식에는 기능적인 특성이나 장단점들이 있기 때문에 상황에 따라 적절한 방식을 선택하여 사용하는 것이 좋습니다. 앞으로 학습할 여러 코드에서도 필요에 따라 문자열 처리를 함께 진행할 예정입니다. 03. 파일 다루기 실무에서 진행되는 다양한 업무들은 특성에 따라 광범위한 데이터 및 파일<NAME>을 요구합니다. 모든 업무가 엑셀로만 진행되지 않으며, 때로는 CSV 파일이나 단순한 텍스트 파일을 사용할 때도 있으며, 파일이나 폴더를 이동, 복사, 삭제하는 작업도 자주 발생합니다. 이번 챕터에서는 파이썬을 활용하여 윈도에서 파일과 폴더를 효율적으로 관리하는 방법을 배울 예정입니다. 파일 시스템을 조작하는 기본적인 방법부터 시작하여, 단순 텍스트 파일과 CSV 파일을 읽고 쓰는 방법에 대해 알아볼 예정입니다. 파이썬은 이러한 작업들을 간소화하고 자동화하여, 복잡한 업무 프로세스를 단순화할 수 있게 도와줍니다. 엑셀이나 다른 오피스 프로그램은 뒤에서 자세하게 다룰 예정이며, 이번 챕터에서는 파이썬의 기본적인 파일 핸들링 기능에 중점을 두고 학습하겠습니다. 03-01. 윈도 폴더 및 파일 다루기 파이썬으로 윈도 특정 경로에 폴더를 생성하거나 이동시킬 수 있으며, 마찬가지로 파일을 복사하거나 파일의 이름을 변경하는 등의 작업을 실행할 수 있습니다. 이렇게 윈도의 폴더나 파일을 다루기 위해서는 주로 os 라이브러리나 shutil 라이브러리를 사용합니다. os 라이브러리는 운영체제와 관련된 함수나 클래스를 제공하는 라이브러리로, 운영체제와 상호작용할 수 있는 여러 기능을 제공합니다. 파일명 변경이나 폴더 생성과 같이 파일과 폴더를 다루는 함수와 클래스도 일부 포함되어 있습니다. shutil 라이브러리는 파일이나 폴더에 특화된 라이브러리로 파일을 복사하거나 이동하는 등의 작업을 할 수 있습니다. 두 라이브러리의 특성과 기능이 조금씩 다르기 때문에 두 라이브러리를 모두 이용하면 파이썬에서 폴더와 파일 작업을 보다 편하게 실행할 수 있습니다. 이 두 라이브러리는 파이썬에 기본으로 포함되어 있기 때문에 별도로 설치가 필요하지 않습니다. 파일(폴더) 존재 유무 확인 어떤 특정 경로에 파일이나 폴더를 생성하려고 할 때, 이미 그 경로에 동일한 이름의 파일이나 폴더가 있으면 오류가 발생할 것입니다. 따라서 파일이나 폴더가 이미 존재하고 있는지 확인하는 작업이 필요합니다. 이때 사용하는 함수는 os.path.exists()입니다. import os if not os.path.exists('C:\\users\\Book'): # C 드라이브 users에 'Book' 폴더가 있는지 확인 print("폴더 없음") else: print("폴더 있음") 파일이 있는지도 동일하게 확인이 가능하며, 파일의 경우 뒤에 확장자를 포함해야 합니다. 여기서는 파이썬이 실행된 위치가 아닌 특정 경로의 폴더를 다루는 것을 가정하여 전체 경로를 적어주었지만, 실행 경로와 동일한 경우 전체 경로를 적지 않아도 됩니다. 특정 폴더 내 목록 확인 위에서와 같이 특정한 폴더명이나 파일명을 주고 존재 유무를 확인할 수도 있지만, 해당 경로에 있는 전체 파일과 폴더를 확인하는 것도 가능합니다. 이때 사용하는 메서드는 os.listdir()로 전체 목록을 리스트 형태로 반환합니다. import os lists = os.listdir(C:\\users\\Book) # C 드라이브 users 내 Book 폴더에 있는 파일과 폴더 목록 반환 print(lists) # 결괏값 [ '2023', '2023-10-21.xlsx', '2023-10-30.xlsx', 'Untitled.ipynb', '월별 구매 고객 리스트. xlsx' ] 출력된 리스트에서 뒤에 확장자가 없는 요소는 폴더를 의미하며 파일들은 파일명 뒤에 확장자를 포함하여 출력됩니다. 또한 폴더와 파일을 구분하지 않고 파일명/폴더명(숫자 - 영어 - 한글)을 기준으로 순서가 결정됩니다. 폴더 생성 폴더를 생성하는 메서드는 os.makedirs()입니다. 여기서는 폴더가 해당 경로에 존재하지 않으면 폴더를 생성하도록 해보겠습니다. import os if not os.path.exists('C:\\users\\Book'): # C 드라이브 users에 'Book' 폴더가 없으면 아래 명령어 수행 os.makedirs('C:\\users\\Book') # 경로에 'Book'폴더 생성 폴더 이름 변경 생성된 폴더의 이름의 변경해 보겠습니다. 위에서와 마찬가지로 폴더가 존재하지 않아 오류가 발생하는 것을 방지하기 위해 폴더가 있으면 변경하도록 조건을 설정하겠습니다. import os if os.path.exists('C:\\users\\Book'): # C 드라이브 users에 'Book' 폴더가 있으면 아래 명령어 수행 os.rename('C:\\users\\Book', 'C:\\users\\2023') # 폴더명을 'Book'에서 '2023'으로 변경 os.rename()은 위와 같이 폴더명을 변경하는 코드이지만, 만약 폴더의 이름을 변경할 때 경로까지도 변경하고자 한다면 다른 함수를 추가할 필요 없이 os.rename()만으로도 폴더의 이동도 함께 가능합니다. 즉, 변경할 이름을 지정할 때 이동시킬 경로까지도 함께 전달해 주면 이름이 변경된 채로 폴더의 위치가 이동됩니다. 폴더 복사 생성한 폴더를 다른 경로로 복사하는 방법을 알아보겠습니다. shutil.copytree()로 폴더를 복사할 수 있는데 이 메서드는 폴더에만 적용되기 때문에 복사할 원본이 파일이면 오류가 발생합니다. 또한 해당 폴더를 복사할 경로에 이미 폴더가 존재하는 경우에도 오류가 발생하기 때문에, 여기서는 대상 경로에 복사할 폴더가 없는 경우에만 폴더 복사를 실행하도록 조건을 넣어주겠습니다. import os import shutil path_from = 'C:\\users\\2023\\sample' # 복사할 원본 폴더 경로 path_to = 'C:\\users\\2023\\10월\\sample' # 복사 완료 후의 최종 폴더 경로 if not os.path.exists(path_to): shutil.copytree(path_from, path_to) shutil.copytree()를 직관적으로 볼 수 있도록, 이번에는 복사할 원본 폴더의 경로와 복사를 완료한 다음의 최종 폴더 경로를 미리 변수 path_from과 path_to에 저장하였습니다. shutil.copytree()에는 복사할 원본 폴더 경로와 대상 폴더 경로, 이렇게 두 가지 경로를 입력해 줍니다. 위의 예시 코드에서는 원본 폴더를 다른 경로에 복사하는 것이기 때문에 동일한 폴더명으로 복사했습니다. 만약 원본 폴더 경로와 동일한 경로에 똑같은 폴더를 다른 이름으로 복사하고자 한다면 폴더명만 변경해 주면 됩니다. 폴더 삭제 import shutil path = 'C:\\users\\2023\\10월\\sample' # 삭제할 폴더 경로 if os.path.exists(path): shutil.rmtree(path) shutil.rmtree()는 입력받은 경로 폴더를 삭제하는 함수이기 때문에, 폴더가 아닌 파일을 입력값으로 주면 오류가 발생합니다. 그리고 입력받은 폴더가 존재하지 않을 경우에도 오류가 발생합니다. 지금까지 폴더를 다루는 방법을 주로 알아보았다면 이번에는 파일 다루는 방법들을 소개하겠습니다. 파이썬으로 텍스트 파일이나 csv 파일을 생성하는 방법은 뒤에서 자세히 다룰 예정이기 때문에 여기서는 생성된 파일의 이름을 변경하고 복사, 삭제하는 방법들을 살펴보겠습니다. 파일 복사 파일을 복사할 때는 shutil.copyfile()을 사용하며, 원본 파일의 내용을 입력된 대상 파일명으로 복사합니다. import shutil shutil.copyfile('example.txt', 'example_copied.txt') 위의 코드에서는 'example.txt' 파일을 동일한 경로에 'example_copied.txt'로 복사합니다. 만약 해당 경로에 입력된 대상 파일명과 동일한 파일이 이미 존재할 경우, 기존에 있던 내용은 사라지고 원본 파일의 내용이 덮어쓰입니다. 파일 이동 파일을 이동할 때는 shutil.move()를 사용합니다. import shutil file_from = 'example_copied.txt' file_to = './2023\\example_copied.txt' shutil.move(file_from, file_to) shutil.move()에 이동시킬 원본 파일 경로와 이동 완료 후의 파일 경로를 입력값으로 줍니다. 이동 완료 후의 파일 경로를 입력값으로 줄 때 파일명을 기존과 다르게 설정하면, 파일 이동 시 파일명도 함께 변경이 가능합니다. 파일 삭제 파일을 삭제할 때는 os 라이브러리의 remove()나 unlink() 두 가지 함수를 사용합니다. remove()와 unlink() 두 함수 모두 입력값으로 받은 경로의 파일을 삭제하며 코드의<NAME>도 동일합니다. 따라서 두 함수 중 자유롭게 선택하여 사용이 가능합니다. 여기서는 os.remove()로 파일을 삭제해 보겠습니다. import os if os.path.exists('example.txt'): os.remove('example.txt') 위의 os.remove('example.txt') 대신 os.unlink('example.txt')를 넣어줄 수도 있습니다. 두 함수 모두 파일을 입력값으로 받기 때문에 입력값이 폴더인 경우에는 오류가 발생하며, 입력값으로 받은 파일이 존재하지 않는 경우에도 오류가 발생합니다. 지금까지 파이썬에서 폴더와 파일을 다루는 여러 방법들을 살펴보았습니다. 위에서 살펴본 내용 외에도 os와 shutil 라이브러리는 다양한 기능을 제공하고 있으므로, 추가적인 기능에 대해서는 공식 문서를 참고하시기를 추천드립니다. os 모듈 문서: https://docs.python.org/3/library/os.html shutil 모듈 문서: https://docs.python.org/3/library/shutil.html 03-02. 텍스트 파일 읽고 쓰기 텍스트 파일 읽기 파이썬에서 텍스트 파일을 읽는 가장 기본적인 방법은 open() 함수와 read() 메서드를 사용하는 것입니다. # 'example.txt' 파일 열기 ( 읽기 모드 'r', 인코딩 방식 ' utf-8') file = open('example.txt', 'r', encoding = 'utf-8') # 파일 읽기 content = file.read() # 파일 닫기 file.close() # 읽어온 파일 내용 출력 print(content) 파이썬 내장 함수 open()으로 텍스트 파일을 열어서 read()로 파일을 읽은 후 close()로 닫아줍니다. open()으로 파일을 불러올 때 파일의 위치가 파이썬의 실행 위치와 동일할 경우 파일명만 입력하면 되지만, 파일이 다른 경로에 위치해있을 경우 전체 경로를 포함하여 파일 이름을 입력해 주어야 합니다. 파일을 열 때, 파일을 어떻게 사용할 것인지 파일의 속성 모드를 옵션을 지정해 줄 수 있습니다. 위에서는 파일을 읽어오기 위해 'r' 읽기 모드를 사용했습니다. 파일 열기로 사용할 수 있는 모드(mode)의 종류는 다음과 같습니다. 종류 모드 설명 작업 'r' 읽기 모드 (기본). 모드를 지정하지 않으면 기본 읽기 모드로 실행. 파일이 없으면 오류 발생 작업 'w' 쓰기 모드. 같은 이름의 파일이 있으면 기존 파일을 덮어쓰며, 없을 경우 새 파일을 생성 작업 'a' 추가 모드. 기존에 저장된 파일의 끝에 새로운 내용을 추가. 기존 파일이 없으면 새 파일을 생성 작업 'x' 쓰기 모드. 같은 이름의 파일이 존재하지 않을 경우에만 새 파일을 생성. 이미 있으면 오류 발생 작업 '+' 읽기와 쓰기 혼합 모드 (예: 'r+', 'w+', 'a+') 형식 'b' 이진 모드. 파일을 이진(binary)<NAME>으로 실행 형식 't' 텍스트 모드 (기본). 파일을 텍스트(text)<NAME>으로 실행. 지정하지 않으면 기본 텍스트 모드로 실행 작업 방식인 'r', 'w', 'x', 'a'와 파일<NAME>인 'b', 't'는 'rb', 'wt'와 같이 혼합하여 사용이 가능합니다. 둘 다 지정하지 않을 경우 기본적으로 'rt'인 텍스트 파일 읽기 모드가 선택됩니다. 파일 속성 외에 인코딩 방식도 옵션으로 지정할 수 있으며, 별도로 지정하지 않으면 기본 인코딩 방식으로 작업을 진행합니다. *인코딩이란 텍스트나 정보를 컴퓨터가 이해하는 언어로 변환하는 것을 의미합니다. 즉, 컴퓨터가 데이터를 어떻게 읽고 쓸지를 결정하는 규칙이라고 볼 수 있습니다. 인코딩을 해주는 방식도 여러 종류가 있는데, 작업할 데이터에 따라 특정한 인코딩 방식으로 실행하지 않으면 글자가 깨지는 경우가 있을 수 있습니다. 한글의 경우 주로 utf-8이나 euc-kr, cp949 등의 인코딩 방식을 사용하며, 한글 윈도 환경에서 cp949로 인코딩한 텍스트 파일을 open()으로 열 때는 인코딩 옵션을 생략해도 파일을 문제없이 읽고 쓸 수 있습니다. with 문으로 파일 읽기 위에서 학습한 코드에서는 작업이 끝났을 때 별도로 close()로 파일을 닫아주었습니다. 파일을 가져올 때 with 문을 사용하면 파일을 닫는 명령을 하지 않아도 자동으로 파일을 닫아 편리합니다. 아래는 with 문으로 동일하게 파일을 여는 코드입니다. # 'example.txt' 파일 열기 ( 읽기 모드 'r', 인코딩 방식 ' utf-8') with open('example.txt', 'r', encoding = 'utf-8') as file: content = file.read() # 파일 읽기 print(content) # 읽어온 파일 내용 출력 위의 코드에서 보듯 별도로 close() 작업을 하지 않아도 파일을 자동적으로 닫아줍니다. 텍스트 파일 쓰기 다음으로 이번에는 텍스트 파일을 쓰는 방법을 알아보겠습니다. # 'example.txt' 파일 열기 ( 쓰기 모드 'w', 인코딩 방식 ' utf-8') file = open('example.txt', 'w', encoding = 'utf-8') # 문자열 쓰기 file.write('Hello, \n world!') # 파일 닫기 file.close() 파일을 쓰는 코드도 읽을 때의 코드와 매우 유사한 것을 알 수 있습니다. 파일을 열 때 모드만 'w'로 변경하면 데이터를 쓸 수 있습니다. 여기서 유의해야 할 점은, write() 함수는 자동 줄 바꿈이 되지 않기 때문에 줄 바꿈이 필요할 경우에는 직접 개행문자를 추가해 줍니다. *개행문자는 텍스트에서 줄을 바꿔 새로운 줄을 시작할 때 사용되는 특수문자입니다. 개행문자에는 캐리지 리턴(Carriage Return, 줄여서 CR)과 라인피드(Line Feed, 줄여서 LF)가 포함됩니다. 캐리지 리턴(CR)은 백슬래시(\)와 영어 r이 결합된 '\r'이며, 라인피드(LF)는 백슬래시(\)와 영어 n이 결합된 '\n'의 형태입니다. CR은 맨 앞으로 이동하라는 의미이며 LF는 다음 줄로 이동하라는 뜻입니다. 의미만 생각하면 LF만 있으면 될 것 같은데 CR이 있는 이유는 옛날 타자기로 문서를 작성하는 방식에서 유래했기 때문입니다. 운영체제에 따라 개행문자를 사용하는 방식이 다른데, 윈도에서는 CR과 LF가 결합된 '\r\n'으로, 리눅스나 macOS에서는 '\n'만을 사용하여 줄바꿈을 실행합니다. 파이썬에서는 '\n'만 사용해도 줄바꿈이 되기 때문에 여기서 다룰 예제에서는 '\n'으로 사용하겠습니다. 쓰기 모드도 읽기 모드와 동일하게 with 문으로 실행할 수 있습니다. 다음은 with 문으로 동일하게 텍스트 파일을 쓰는 코드입니다. # 'example.txt' 파일 열기 ( 쓰기 모드 'w', 인코딩 방식 ' utf-8') with open('example.txt', 'w') as file: file.write('Hello, \n world!') # 문자열 쓰기 파일이 잘 생성됐는지 확인하기 위해 윈도 type 명령으로 텍스트 파일의 내용을 출력해 보겠습니다. !type C:\user\example.txt # 출력값 Hello, world! 텍스트 파일을 한 줄씩 읽고 쓰기 앞에서는 텍스트 파일을 읽거나 쓸 때 전체 파일을 한 번에 작업하는 방식을 사용하였습니다. 이번에는 한 줄씩 읽거나 쓰는 방법을 알아보겠습니다. 한 줄씩 읽기 'readline()' 또는 'readlines()'를 사용하면 파일을 한 줄씩 읽어 처리할 수 있습니다. readline()과 readlines()는 작업 방식이 조금 다른데, readline()은 파일의 현재 위치에서 한 줄씩만 읽어서 문자열을 반환하고, readlines()는 모든 라인을 읽어서 각 라인을 요소로 갖는 리스트를 반환합니다. readline() 먼저 readline()부터 살펴보겠습니다. readline()은 파일의 현재 위치에서 하나의 라인만 읽어 문자열로 반환합니다. 즉, 처음 파일을 연 후 readline()을 실행하면 파일의 첫 줄을 반환합니다. 그러고 나서 위치를 다음 라인의 시작 지점으로 이동합니다. 여기서 다시 한번 readline()을 실행하면, 이번에는 두 번째 라인이 반환되는 것입니다. 이렇게 한 줄씩 읽어서 문자열을 반환하며, 파일의 끝에 도달하면 빈 문자열('')을 반환합니다. 문자열을 읽어올 때는 그 라인의 개행문자(\n)도 포함하여 반환되는데, 파일의 마지막 줄을 반환할 때는 텍스트 파일이 생성된 운영체제에 따라 개행문자가 없는 경우도 있습니다. 그리고 한 줄을 반환했을 때 다른 문자열 없이 개행 문자만 반환된다면 그 줄은 공백인 줄입니다. 실제 코드로는 어떻게 작동하는지 보겠습니다. # 'example.txt' 파일을 읽기 모드 'r'로 열기 with open('example.txt', 'r') as file: line1 = file.readline() # 파일의 첫 줄 읽기 line2 = file.readline() # 파일의 그다음 줄 읽기 print(line1, line2) # 출력값 Hello, world! 한 줄씩 읽어오는 readline()으로 파일 전체를 읽으려면 어떻게 해야 할까요? 위의 코드처럼 모든 라인에 대해 각각 코드를 쓰지 않고 while 문으로 전체 파일을 읽어오게 할 수 있습니다. # 'example.txt' 파일을 읽기 모드 'r'로 열기 with open('example.txt', 'r') as file: line = file.readline() # 파일의 첫 줄 읽기 while line: # 파일 끝에 도달하기 전까지 아래의 코드를 수행 print(line.strip()) # 줄바꿈 문자를 제거하고 읽어온 줄을 출력 line = file.readline() # 다음 줄을 읽기 파일을 한 줄씩 읽어올 때 while 문으로 조건을 넣어 readline()을 반복하는 코드입니다. 더 이상 읽어올 라인이 없는 파일의 끝에 도달하기 전까지 readline()로 그 다음줄을 읽어오는 작업을 반복함으로써 전체 텍스트 파일을 읽어올 수 있습니다. 읽어온 줄을 출력할 때 사용된. strip()은 불필요한 문자열을 삭제하는 메서드입니다. 각 라인에 개행문자가 포함되어 있는데 이를 제거하지 않고 그대로 출력하면 뒤에 빈 줄이 함께 출력됩니다. 이러한 불필요한 공백을 제거하기 위해 strip()을 사용하였으며, 이 메서드에 대해서는 뒤에서 다시 한번 알아보겠습니다. readlines() 이번에는 그러면 readlines()를 살펴보겠습니다. readlines()는 모든 줄을 읽은 다음, 읽은 모든 라인을 요소로 하는 리스트를 반환합니다. 파일 전체를 읽어오기 때문에 readline()과 달리 readlines()는 한 번만 실행하면 됩니다. 다만, 이 메서드는 읽어온 전체 내용을 메모리에 로드하기 때문에, 큰 파일을 다룰 때는 메모리 문제가 발생할 수 있습니다. with open('example.txt', 'r') as file: lines = file.readlines() # 파일의 전체의 내용 읽기 print(lines) # 리스트형으로 저장된 전체 내용 출력 # 결괏값 ['Hello, \n', ' world!'] readlines()로 한 번에 파일 전체를 읽어온 다음 출력해 보았습니다. 출력된 결괏값을 보면 각 라인이 각각 리스트의 요소로 할당되어 있음을 알 수 있습니다. 그리고 각 라인에는 readline()을 사용할 때와 동일하게 개행문자가 포함되어 있습니다. 앞에서와 마찬가지로 개행문자를 빼주려면, 여기서는 for 문을 사용합니다. with open('example.txt', 'r') as file: lines = file.readlines() # 파일의 전체의 내용 읽기 for line in lines: # 리스트의 요소를 하나씩 순회하며 아래의 코드를 실행 print(line.strip()) # 줄바꿈 문자를 제거하고 읽어온 줄을 출력 # 결괏값 Hello, world! 먼저 readlines()로 파일의 전체 내용을 읽어와 리스트형으로 저장합니다. 저장된 리스트의 각 요소에 하나씩 접근하여. strip()으로 공백을 제거하고 그 내용을 출력합니다. 여기서는 리스트 전체를 출력하는 것이 아니라 각 요소를 하나씩 출력하기 때문에 출력된 결괏값도 앞선 코드와 다르게 리스트형이 아니게 됩니다. 한 줄씩 쓰기 이번에는 그러면 한 줄씩 쓰는 방법을 알아보겠습니다. 한 줄씩 쓸 때도 write()와 writelines() 두 가지 방법이 있습니다. write() # 각 줄마다 입력할 내용을 리스트로 저장 lines = ['Hello, world!', 'Hello, again!'] with open('example.txt', 'w') as file: for line in lines: # 저장된 리스트의 각 요소에 접근하여 아래 작업을 실행 file.write(f"{line}\n") # 내용을 파일에 쓰고 줄 바꿈 작성된 결과를 확인하기 위해 앞에서와 마찬가지로 윈도 type 명령으로 파일 내용을 표시해 보겠습니다. !type C:\user\example.txt # 출력값 Hello, world! Hello, again! 한 줄씩 쓰기 위해서 먼저 각 라인에 들어갈 내용을 리스트로 만들어줍니다. 그다음 for 문으로 반복하여 리스트의 요소를 하나씩 파일에 쓰고 줄 바꿈을 실행하는 방식으로 한 줄씩 데이터를 입력합니다. 여기서는 개행문자를 추가해 주기 위해 포메이팅을 사용했습니다. writelines() writelines()는 readlines()처럼 여러 줄을 한 번에 작업하는 메서드입니다. 그렇기 때문에 각 문자열에 개행문자가 포함되어 있어야 합니다. # 각 줄마다 입력할 내용을 리스트로 저장 lines = ['Hello, world!\n', 'Hello, again!'] with open('example.txt', 'w') as file: file.writelines(lines) # 리스트로 저장된 lines 전체를 파일에 쓰기 # 윈도 type 명령어로 파일을 실행한 결괏값 Hello, world! Hello, again! writelines()는 for 문이 나 다른 조건문이 별도로 필요하지 않아 더 편하게 파일 쓰기가 가능합니다. 다만, 앞서 설명한 바와 같이 개행문자가 이미 각 문자열의 뒤에 포함되어 있어야 하기 때문에, 그렇지 않은 경우에는 개행문자를 뒤에 붙여주는 데이터 처리를 먼저 해주어야 합니다. 'r+'모드와 seek 함수 r+모드로 파일을 실행하면 읽기와 쓰기가 모두 가능한 모드라는 것을 앞에서 알아보았습니다. r+모드로 파일을 열 때는 현재 위치를 가리키는 파일 포인터를 제어하기 위해 주로 seek() 함수를 함께 쓰는 경우가 많습니다. 파일을 읽을 때와 쓸 때 모두 파일 포인터가 변하기 때문에 자칫 생각과 다른 위치에서 작업이 실행되는 경우가 있기 때문입니다. 예를 들어, r+모드로 파일을 열면, 파일 포인터는 기본적으로 파일의 시작 위치에 배치됩니다. 이 상태 그대로 write()로 쓰기 작업을 실행하면, 기존 파일의 내용이 덮어쓰일 위험이 있습니다. 이런 위험을 피하기 위해 seek()으로 파일 포인터를 변경한 다음 작업을 진행하면 안전하게 읽기와 쓰기가 가능합니다. seek() 함수는 파일 내 특정 위치로 파일 포인터를 이동시킵니다. r+모드에서 seek() 함수를 같이 사용하는 코드의 예시를 살펴보겠습니다. with open('example.txt', 'r+') as f: content = f.read() # 파일의 모든 내용을 읽기 ( 읽기 ① ) print('Before:', content) f.seek(0) # 파일 포인터를 파일 시작 부분으로 이동 f.write('We can change it. \n') # 파일 내용 덮어쓰기 ( 쓰기 ) content = f.read() # 현재 위치에서 파일 읽기 ( 읽기 ② ) print('After:', content) f.seek(0) # 파일 포인터를 파일 시작 부분으로 이동 content = f.read() # 현재 위치에서 다시 파일 읽기 ( 읽기 ③ ) print('Final:', content) # 결괏값 Before: Hello, world! Hello, again! After: o, again! Final: We can change it. o, again! 코드에서 읽기가 여러 번 반복되고 있기 때문에 명확한 설명을 위해 '읽기 ① / ② / ③'으로 구분 짓겠습니다. 먼저 파일을 r+ 모드로 열어서 전체 내용을 읽어오는 읽기 ①을 실행합니다. 결괏값에서 "Before: " 뒷부분에 출력된 내용을 보면 기존 파일 전체 내용인 "Hello, world!(줄바꿈) Hello, again!"이 출력된 것을 볼 수 있습니다. 그다음 파일에 "We can change it."이라는 내용을 쓰는데 파일의 앞부분부터 덮어쓰기 위해 다시 파일 포인터를 시작 부분으로 이동합니다. 만약 파일 끝에 내용을 추가하고자 한다면, 읽기 ① 이 끝난 다음 파일 포인터를 이동하지 않은 채로 쓰기를 실행하면 됩니다. 파일 쓰기가 끝난 다음 읽기 ②를 실행해 보았습니다. 우리가 덮어쓴 내용을 포함한 전체 내용이 다시 출력될 것 같지만, "After: " 뒤에 출력된 결괏값을 보면 덮어쓰고 난 뒷부분인 "o, again!"만 출력됩니다. 쓰기가 끝난 뒤 파일 포인터의 현재 위치에서 read()가 실행되기 때문입니다. seek(0)으로 다시 파일 포인터를 시작 위치로 이동한 후 읽기 ③을 실행합니다. "Final: " 뒤의 최종 출력값이 "We can change it.(줄바꿈) o, again!"으로, 쓰기 작업 후의 전체 내용이 출력되었습니다. 이와 같이 r+모드로 작업할 때는 seek() 함수를 사용해 작업할 위치로 이동합니다. 위의 코드에서는 시작 위치로 이동을 위해 seek(0)을 호출했습니다. '0'은 절댓값으로 언제나 파일의 시작 위치를 의미합니다. seek()은 인자 값으로 숫자를 전달받는데, 만일 시작이 아닌 중간 지점으로 이동하고자 한다면 그 위치로 가기 위해 얼마큼 이동해야 하는지 숫자를 전달해야 합니다. 여기서의 숫자는 사람이 세는 글자 수와는 다르게 컴퓨터가 읽는 단위인 바이트(byte)를 의미합니다. 즉, 현재 포인터의 위치를 기준으로 몇 바이트 떨어진 곳으로 이동해야 하는지를 컴퓨터에게 알려줘야 하는 것입니다. 영어나 공백은 자릿수 하나당 1바이트로 비교적 계산하기 용이하지만, 한글은 글자당 3바이트이기 때문에 계산이 조금 더 복잡해집니다. 위치를 잘못 이동한 채로 쓰기 작업을 진행하면 내용이 덮어쓰이기 때문에 중간지점으로 이동할 때는 주의해야 합니다. 03-03. csv 파일 다루기 csv 파일은 Comma-separated Values의 약자로 즉, 콤마로 구분된 데이터 파일입니다. 엑셀과 같이 테이블 형태로 파일을 작성할 수 있으면서도,<NAME>이 간단하고 파일의 크기도 작아 대량의 데이터를 다뤄야 하는 공공기관이나 기업에서도 많이 사용되는 파일<NAME>입니다. 이름, 나이, 직업 박은영, 30, 엔지니어 김세 빛, 25, 디자이너 안희수,35,의사 정현욱, 40, 선생님 강찬영,22,학생 위의 csv 파일 예시에서 콤마(,)로 구분되어 있는 것을 줄로 치환하여 생각하면 표와 동일한 형태라는 것을 알 수 있습니다. 이처럼 csv 파일은 테이블 형태로 작성되기 때문에 엑셀 프로그램에서도 csv 파일을 열고 추가적인 데이터 작업을 할 수 있다는 장점이 있습니다. 물론 단순 텍스트 파일이기 때문에 엑셀 프로그램 외에도 모든 다른 텍스트 편집기에서도 파일을 열 수 있습니다. 파이썬에서 openpyxl이나 pandas로 엑셀 파일 다루는 방법은 뒤에서 자세히 배울 예정이기 때문에, 여기서는 csv 파일을 다루는 기본 방법들에 대해서만 간단하게 살펴보겠습니다. csv 파일 쓰기 import csv # csv 파일을 쓰기 모드 'w'로 열기(인코딩 'cp949', 라인 종료 문자 설정 'newline = '') with open('example.csv', 'w', encoding='cp949', newline='') as file: csv_writer = csv.writer(file) # 파일 객체를 csv.writer 객체로 변환 csv_writer.writerow(['이름', '나이', '직업']) # 헤더 작성 csv_writer.writerow(['박은영', 30, '엔지니어']) # 데이터 행 추가 csv_writer.writerow(['김세 빛', 25, '디자이너']) csv_writer.writerow(['안희수', 35, '의사']) csv_writer.writerow(['정현욱', 40, '선생님']) csv_writer.writerow(['강찬영', 22, '학생']) # 윈도 type 명령어로 파일을 실행한 결괏값 이름, 나이, 직업 박은영, 30, 엔지니어 김세 빛, 25, 디자이너 안희수,35,의사 정현욱, 40, 선생님 강찬영,22,학생 csv 파일을 열 때도 앞서 텍스트 파일을 열 때와 같이 open()을 사용합니다. 여기서도 with 문으로 파일을 열어 별도의 닫기 close() 명령 없이 파일 작업을 완료했습니다. 불러온 파일을 csv.writer 객체로 변환한 다음 writerrow()를 사용하여 행별로 데이터를 입력합니다. 데이터는 리스트나 튜플의 형태로 입력하며, 리스트나 튜플의 각 요소가 csv 파일의 하나의 셀로 취급됩니다. 파일을 열 때 newline=''이라는 것이 추가된 것이 보입니다. newline=''은 줄 바꿈을 어떻게 처리할 것인지를 정해주는 옵션이라고 생각하면 됩니다. 앞서 3-2. 텍스트 파일 다루기에서 운영체제에 따라 개행문자가 다르며 윈도에서는 '\r\n'으로 사용한다는 것을 알아보았습니다. 프로그램의 종류나 파이썬 라이브러리마다 사용하는 개행문자는 다를 수 있는데, 파이썬에서 csv 파일에 데이터를 입력할 때 쓰는 csv.writer()는 줄 바꿈으로 '\r\n'을 사용합니다. 즉, 데이터의 각 행 뒤에 '\r\n'이 삽입됩니다. 그런데 윈도에서는 텍스트 파일을 다룰 때 파일에 있는 '\n'을 윈도의 줄바꿈 스타일인 '\r\n'으로 자동으로 변환합니다. 이로 인해 csv.writer()로 작성한 csv 파일의 각 행 뒤의 '\r\n'는 '\r\r\n'으로 변환됩니다. 윈도의 텍스트 프로그램(메모장)에서는 파일이 정상적으로 보이지만, 엑셀과 같은 스프레드시트 프로그램에서 파일을 열면 '\r\r\n'을 두 개의 다른 행으로 해석해서 빈 행을 추가하게 됩니다. 위의 코드를 newline 옵션을 넣지 않고 실행하여 csv 파일을 생성한 뒤 윈도 메모장과 엑셀 프로그램에서 각각 실행해 보겠습니다. 윈도 메모장으로 파일 열기 엑셀 프로그램으로 파일 열기 동일한 파일이지만 엑셀 프로그램에서 열 때는 각 행 사이에 빈 행이 추가된 것을 알 수 있습니다. 이러한 불필요한 공백 문제를 해결하기 위해 csv 파일을 열 때 newline=''을 옵션을 사용합니다. 이 옵션을 추가하면 파이썬이 운영체제에 맞는 적절한 줄바꿈 문자를 알아서 자동으로 사용해 줍니다. 따라서 파이썬으로 csv 파일에 접근하여 데이터 작업을 진행하고자 한다면 newline='' 옵션을 기본으로 함께 넣어주는 편이 좋습니다. csv 파일 읽기 이번에는 csv 파일을 읽어보겠습니다. csv 파일을 쓸 때와 동일하게 open()으로 파일을 열고 csv.reader()로 파일을 읽어줍니다. import csv # csv 파일을 읽기 모드 'r'로 열기(인코딩 'cp949') with open('example.csv', 'r', encoding='cp949') as file: csv_reader = csv.reader(file) # 파일 객체를 csv.reader 객체로 변환 for row in csv_reader: # 파일 행별로 읽기 print(row) # 결괏값 ['이름', '나이', '직업'] ['박은영', '30', '엔지니어'] ['김세 빛', '25', '디자이너'] ['안희수', '35', '의사'] ['정현욱', '40', '선생님'] ['강찬영', '22', '학생'] csv.reader는 기본적으로 행 단위로 데이터를 읽어와서 리스트로 반환합니다. 위의 코드에서는 전체 데이터를 읽기 위해 for 문을 사용하여 각 행마다 접근하여 읽기 작업을 실행했습니다. 헤더 건너뛰기 csv 파일의 첫 행에 헤더가 있을 때, 첫 행을 제외하고 파일을 읽는 법을 살펴보겠습니다. 위의 csv 파일 읽기에서 csv.reader는 행 단위로 데이터를 가지고 온다는 것을 학습했습니다. 현재 행에서 다음 행으로 위치를 이동하는 특성을 활용하여 첫 행을 제외한 읽기를 쉽게 실행할 수 있습니다. 위의 예제 코드에서 next() 함수를 사용하여 헤더를 제외해 보겠습니다. import csv with open('example.csv', 'r', encoding='cp949') as file: csv_reader = csv.reader(file) next(csv_reader) # 첫 행 건너뛰기 for row in csv_reader: # 두 번째 행부터 행별로 읽기 print(row) # 결괏값 ['박은영', '30', '엔지니어'] ['김세 빛', '25', '디자이너'] ['안희수', '35', '의사'] ['정현욱', '40', '선생님'] ['강찬영', '22', '학생'] next() 함수는 객체의 현재 위치에서 다음 원소를 반환하고, 위치를 한 칸 앞으로 이동시킵니다. csv.reader에서도 next() 함수를 사용할 수 있어 원하는 행을 건너뛰거나 특정 위치부터 데이터를 읽을 수 있습니다. 딕셔너리 형태로 읽기 앞에서는 csv 파일을 행별로 읽어오는 방법을 살펴보았다면, 이번에는 딕셔너리 형태로 읽는 방법을 알아보겠습니다. csv.DictReader는 csv 파일을 읽어서 각 행을 딕셔너리 형태로 반환합니다. 딕셔너리의 키는 csv 파일의 헤더(첫 번째 행)에서 가져옵니다. with open('example.csv', 'r', encoding='cp949') as file: # csv.DictReader 객체 생성: 파일의 첫 번째 행을 헤더로 사용하여 나머지 행을 사전 형태로 읽기 csv_dict_reader = csv.DictReader(file) # csv_dict_reader 객체를 순회하면서 각 행을 출력 for row in csv_dict_reader: # 헤더인 '이름', '나이', '직업'을 키로 사용하여 각 행의 해당 열 값을 출력 print(row['이름'], row['나이'], row['직업']) # 결괏값 박은영 30 엔지니어 김세 빛 25 디자이너 안희수 35 의사 정현욱 40 선생님 강찬영 22 학생 csv.DictReader는 인자로 받은 파일의 내용을 사전 형태로 읽을 수 있는 객체(csv_dict_reader)를 생성합니다. csv.DictReader의 객체도 한 행씩 접근하며 반복 작업이 가능한, 즉, 반복 가능(iterable) 한 객체이기 때문에 여기서도 for 문으로 각 행을 순회합니다. 첫 행을 키로 사용하여 각 행의 열값이 각각 딕셔너리 형태로 저장되어 있기 때문에 전체 데이터를 출력하기 위해 각 셀별로 딕셔너리의 키값을 출력하도록 하였습니다. 만약 위에서처럼 행 전체를 출력할 경우, 결괏값은 딕셔너리 형태로 반환됩니다. with open('example.csv', 'r', encoding='cp949') as file: csv_dict_reader = csv.DictReader(file) for row in csv_dict_reader: print(row) # 각 행 전체를 출력 # 결괏값 {'이름': '박은영', '나이': '30', '직업': '엔지니어'} {'이름': '김세 빛', '나이': '25', '직업': '디자이너'} {'이름': '안희수', '나이': '35', '직업': '의사'} {'이름': '정현욱', '나이': '40', '직업': '선생님'} {'이름': '강찬영', '나이': '22', '직업': '학생'} 결괏값이 딕셔너리 형태임을 확인할 수 있습니다. 이렇게 DictReader로 파일을 읽으면 열 이름(헤더)를 기준으로 파일 작업이 가능하기 때문에 열 순서가 변경되어도 코드를 수정할 필요가 없다는 장점이 있습니다. 특정 열을 추출하여 선택적으로 작업할 수도 있으며, 인덱스 번호가 아닌 열 이름이 사용되어 코드의 가독성도 향상됩니다. 다른 구분자로 읽기/쓰기 데이터가 콤마(,)로 구분된 csv 파일 외에도 tab으로 구분된 tsv 파일(Tab-Separated Values)도 있습니다. 콤마가 탭으로 바뀌었다는 점 외에는 파일의<NAME>이 유사하기 때문에 tsv 파일도 파이썬에서 동일한 방식으로 읽고 쓸 수 있습니다. # 'example.tsv' 파일을 읽기 모드('r')와 cp949 인코딩으로 열기 with open('example.tsv', 'r', encoding='cp949') as file: # csv.reader 객체 생성, 구분자를 탭('\t')으로 지정 csv_reader = csv.reader(file, delimiter='\t') # csv_reader 객체를 순회하면서 각 행을 출력 for row in csv_reader: print(row) #결괏값 ['박은영', '30', '엔지니어'] ['김세 빛', '25', '디자이너'] ['안희수', '35', '의사'] ['정현욱', '40', '선생님'] ['강찬영', '22', '학생'] 코드는 csv 파일과 동일하지만 구분자(delimiter)를 탭('\t')으로 지정하면 tsv 파일 작업이 가능합니다. 위의 코드에서는 파일을 읽는 csv.reader를 사용하였지만, 파일을 쓸 때 사용하는 csv.writer()에도 구분자(delimiter)를 지정하여 콤마(,)가 아닌 다른 구분자를 사용하는 파일로 작성할 수 있습니다. 다른 따옴표 문자로 읽기/쓰기 csv 파일에서 만약 콤마가 구분자가 아닌 데이터의 값으로 쓰였다면, 해당 콤마가 구분자가 아니라는 것을 알려주는 표시가 있어야 합니다. csv.reader나 csv.writer는 그 표시로 큰따옴표(")를 사용합니다. 큰따옴표 사이에 있는 콤마는 문자로 간주하여 처리한다는 의미입니다. 그런데 작성된 csv 파일이 그 표시를 큰따옴표가 아닌 다른 따옴표를 썼다면 그 사실을 csv.reader나 csv.writer에게 전달해 줘야 할 것입니다. 그럴 때 사용하는 옵션이 'quotechar'입니다. 실제 예시에서 확인해 보기 위해 다음과 같은 'example2.csv' 파일이 있다고 가정하겠습니다. # example2.csv' 파일 이름, 나이, 직업 박은영, 30, 엔지니어 김세 빛, 25, '디자이너, 인플루언서' 안희수,35,'의사, 프로그래머' 정현욱, 40, 선생님 강찬영,22,학생 직업이 2개인 경우가 있어서 그 내용이 콤마(,)로 나열되어 있으며, 3번째와 4번째 행에서 이렇게 콤마가 포함된 직업 열의 값 전체를 하나의 문자열로 간주한다는 의미로 그 내용이 작은따옴표(')로 묶여있습니다. quotechar을 별도로 지정하지 않고 csv 파일을 읽어오는 코드를 실행해 보겠습니다. with open('example2.csv', 'r', encoding='cp949') as file: # csv.reader 객체 생성 csv_reader = csv.reader(file) for row in csv_reader: print(row) # 결괏값 ['이름', '나이', '직업'] ['박은영', '30', '엔지니어'] ['김세 빛', '25', "'디자이너", " 인플루언서'"] ['안희수', '35', "'의사", " 프로그래머'"] ['정현욱', '40', '선생님'] ['강찬영', '22', '학생'] 결괏값을 보면 세 번째와 네 번째 행에 있던 2개의 직업이 각각의 셀로 나뉘어 출력되었습니다. 콤마(,)가 문자열이 아닌 구분자로 간주된 것입니다. 또한 작은따옴표(')가 문자열로 인식되어 직업 값의 앞뒤에 포함되어 출력되었습니다. 그러면 이번에는 동일한 코드에서 quotechar 옵션으로 작은따옴표를 넣어보겠습니다. with open('example2.csv', 'r', encoding='cp949') as file: # csv.reader 객체 생성( 따옴표 문자를 작은따옴표(')로 설정) csv_reader = csv.reader(file, quotechar="'") for row in csv_reader: print(row) # 결괏값 ['이름', '나이', '직업'] ['박은영', '30', '엔지니어'] ['김세 빛', '25', '디자이너, 인플루언서'] ['안희수', '35', '의사, 프로그래머'] ['정현욱', '40', '선생님'] ['강찬영', '22', '학생'] 여기서는 세 번째, 네 번째 행의 직업 값이 작은 다른 행과 동일하게 하나의 셀로 출력된 것을 볼 수가 있습니다. 앞에서 문자열로 인식되었던 작은따옴표도 사라졌습니다. 이처럼 기본 큰따옴표(")가 아닌 다른 따옴표로 문자열 표시를 해주는 경우 quotechar 옵션을 지정합니다. 이는 csv.reader로 파일을 읽을 때뿐만 아니라 csv.writer로 파일을 쓸 때도 동일한 옵션을 지정할 수 있습니다. 지금까지 파이썬의 csv 모듈을 사용하여 csv 파일을 다루는 방법에 대해 알아보았습니다. 비교적 간단한 데이터 작업인 경우에는 csv 모듈을 이용해 csv 파일을 다룰 수 있지만, 이보다 더 복잡한 데이터 처리가 필요한 경우에는 뒤에서 배울 pandas와 같은 라이브러리가 더 적합할 수 있습니다. 04. 엑셀(Excel) 파일 다루기(openpyxl) 실제 업무에서 가장 많이 다루는 파일<NAME> 중 하나인 엑셀 데이터를 파이썬으로 작업하는 방법을 학습하겠습니다. 엑셀은 수많은 데이터를 정리하거나 여러 가지 연산 작업, 차트 및 그래프 그리기 등 데이터를 처리하는데 특화되어 있기 때문에 데이터 작업에서 자주 사용되는 프로그램입니다. 다만, 엑셀에도 아쉬운 점들이 있는데 ①대량의 데이터를 다루거나 복잡한 작업을 해야 할 경우 처리 속도가 느려지며, ②엑셀 데이터에 접근하기 위해서는 반드시 엑셀 프로그램을 열어야 하며, ③여러 개의 엑셀 파일을 동시에 작업하기 어렵다는 점 등입니다. 파이썬으로 엑셀 작업을 할 경우 이러한 단점들이 보완되어 작업이 더 빠르고 편리해질 수 있습니다. 파이썬에는 Pandas, OpenPyXL, xlrd 등 엑셀을 다루는 다양한 라이브러리가 있으며, 이러한 라이브러리를 이용하면 복잡한 데이터 변환 및 분석 작업이 가능합니다. 수백 개의 엑셀 파일을 하나로 합치거나, 특정 조건에 맞는 데이터만 추출하는 등의 반복 작업은 코드 몇 줄로 자동화할 수 있으며, 또한 메모리의 한계 내에서는 거의 제한 없이 데이터를 처리할 수 있으므로, 대량의 데이터를 작업할 때 엑셀에서보다 더 빠른 처리가 가능합니다. 파이썬에서 엑셀을 지원하는 몇 가지 라이브러리 중 여기서는 엑셀 파일의 읽기/쓰기가 가능하고 여러 고급 기능도 제공되어 다양한 상황에서 사용할 수 있는 OpenPyXL 라이브러리를 사용합니다. 이후 데이터 분석 부분에서 Pandas를 활용하는 방법도 추가로 살펴볼 예정입니다. OpenPyXL은 엑셀 2010 이후 버전의 파일부터 지원하며, 2010보다 이전 버전을 사용해야 하는 경우 XlsxWriter나 xlrd/xlwt 등 다른 라이브러리를 사용해야 합니다. 04-01. 엑셀 파일 생성 및 데이터 입력 엑셀 파일 생성 및 셀 단위로 데이터 입력하기 먼저 OpenPyXL 라이브러리를 설치합니다. pip install openpyxl 설치가 완료되었다면 이제 다음의 코드를 실행하여 엑셀 파일을 만들어보겠습니다. # openpyxl 라이브러리에서 Workbook을 import from openpyxl import Workbook # Workbook 객체 생성 wb= Workbook() # 현재 활성화된 워크시트 선택 후 ws 변수에 할당 ws = wb.active #시트 제목을 '수강생_정보'로 변경 ws.title = "수강생_정보" #시트의 A1 셀에 '이철수'라는 데이터를 입력 ws['A1'] = '이철수' # 워크북을 '수강생_리스트. xlsx' 엑셀 파일을 저장합니다 wb.save("수강생_리스트. xlsx") #워크북 닫기 wb.close() 위의 코드는 새로운 엑셀 워크북을 생성하여 '수강생_정보'라는 워크시트의 A1에 '이철수'이라고 입력한 후, "수강생_리스트. xlsx"라는 엑셀 파일로 저장한다는 내용입니다. 코드를 실행하면, 파이썬을 실행한 위치에서 "수강생_리스트"라는 이름의 엑셀 파일이 생성된 것을 확인할 수 있습니다. 행 단위로 데이터 입력하기 이번에는 시트에 여러 데이터를 넣고 새로운 시트도 추가해 보겠습니다. from openpyxl import Workbook wb = Workbook() ws = wb.active ws.title = "수강생_정보" # 시트에 추가할 칼럼의 목록을 리스트형으로 'column'이라는 변수에 지정 column = ['번호', '이름', '과목'] # column 리스트 목록을 시트 첫 행에 입력 ws.append(column) # 시트에 추가할 데이터를 리스트형으로 'row'라는 변수에 지정 row = [1, '이철수', '수학'] # append로 row의 목록을 column 아래 행에 입력 ws.append(row) # '중간평가', '기말 평가' 두 개의 시트 추가 wb.create_sheet('중간평가') wb.create_sheet('기말 평가') wb.save("수강생_리스트. xlsx") wb.close() 이번에는 시트에 칼럼을 추가하고, 여러 데이터(1, '이철수', '수학')를 한 번에 시트에 입력하는 방법을 알아보았습니다. 데이터 하나를 엑셀 특정 셀에 입력할 때는 셀의 위치를 지정해서 ws['A1'] = '이철수' 와 같이 데이터를 입력했으나, 한 행에 입력할 여러 데이터를 한 번에 추가하고자 할 때는 해당 데이터를 리스트형으로 만들어준 후, append 메서드를 사용하여 입력합니다. append는 시트의 가장 마지막 행 다음부터 리스트의 각 요소를 삽입합니다. 따라서 만약 여러 행의 데이터를 한 번에 입력하고자 한다면, 각 행에 입력할 데이터를 리스트형으로 만들고 해당 리스트들을 포함하는 리스트를 만든 후 반복해서 append를 사용하여 시트에 입력합니다. # 각 행의 데이터 리스트를 포함하는 리스트를 만들어 row에 저장 row = [[1, '이철수', '수학'], [3, '김미소', '영어'], [2, '최학준', '컴퓨터']] # row 리스트를 첫 번째 키를 기준으로 정렬 row = sorted(row, key = itemgetter(0)) # row 리스트를 for 문으로 반복하여 시트에 입력 for data in row: ws.append(data) 리스트 그대로 엑셀 행에 순서대로 입력하는 경우에는 정렬을 따로 해줄 필요가 없지만, 데이터의 순서가 섞여있는 경우라면 특정 행을 기준으로 데이터를 먼저 정렬해 줍니다. sorted는 순서가 있는 자료형(리스트, 튜플)을 정렬하여 반환해 주는 파이썬 내장함 수로 기본적으로는 오름차순으로 정렬합니다. 정렬할 때 key 값에 어떤 특정한 키나 함수를 입력해 주면 정렬 방식을 조절할 수 있는데, 여기서 key 값으로 itemgetter() 함수를 사용하면 리스트나 튜플, 딕셔너리에서 특정 위치나 키의 항목을 가져옵니다. row = sorted(row, key = itemgetter(0)) 여기서 itemgetter(0)은 리스트의 첫 번째 요소를 기준으로 정렬하겠다는 의미입니다. 기준을 여러 개로 지정하고자 한다면 itemgetter(1, 0) 이렇게 기준 값을 여러 개로 넣어주면 됩니다. 기준 값이 여러 개인 경우에는 입력된 순서대로 기준 값이 되어 정렬합니다. 즉, itemgetter(1, 0)이면 두 번째 요소를 기준으로 먼저 정렬한 후에 첫 번째 요소를 기준으로 정렬한다는 의미입니다. 위의 코드로 생성된 파일을 열어보면 첫 행에는 칼럼이 입력되어 있고, 그 다음행부터는 리스트의 첫 번째 키인 숫자(1, 2, 3)를 기준으로 정렬된 3개의 데이터행이 입력된 것을 확인할 수 있습니다. 엑셀 열 이름 - 인덱스 변환 파이썬 OpenPyXL로 데이터 작업을 할 때 기본적으로는 열 이름을 엑셀<NAME>과 동일하게 영어 알파벳 'A', 'B', 'C'로 입력하여 사용합니다. 하지만 특정 열 간의 연산을 수행하거나 특정 열에 기반해서 다른 열에 데이터를 쓰는 등 특수한 상황에서는 열 이름 대신 열에 해당하는 인덱스 값이 필요한 경우가 있습니다. OpenPyXL 라이브러리는 이러한 엑셀 열 이름과 인덱스 번호 간의 변환을 지원하는 기능을 제공하고 있어 쉽게 변환이 가능합니다. 인덱스 번호로부터 엑셀 열 이름 얻기: openpyxl.utils.cell.get_column_letter(인덱스 번호) 엑셀 열 이름으로부터 인덱스 번호 얻기: openpyxl.utils.cell.column_index_from_string(열 이름) # OpenPyXL의 유틸리티 함수에서 get_column_letter와 column_dindex_from_string 함수 import from openpyxl.utils.cell import get_column_letter, column_index_from_string # 인덱스 번호 16에 해당하는 엑셀 열 이름 얻기 index = 16 print(get_column_letter(index)) # 엑셀 열 이름 'AB'에 해당하는 인덱스 번호 얻기 print(column_index_from_string('AB')) 위의 코드를 실행하면 인덱스 번호 16에 해당하는 열 이름은 'P'이고, 열 이름 'AB'에 해당하는 인덱스 번호는 28인 것을 알 수 있습니다. 이처럼 엑셀 작업 중 열 이름과 인덱스 번호 변환이 필요한 경우 함수로 값을 찾아줍니다. 열 단위로 데이터 입력하기 엑셀에 열 단위로 한 번에 데이터를 입력하는 방법을 알아보겠습니다. 열 단위로 데이터를 입력하는 방법은 행 단위로 입력할 수 있는 append와 같은 함수는 없습니다. 따라서 열 단위로 입력할 때는 주로 셀에 하나씩 접근해서 입력하게 하는 방법을 사용합니다. 여기서는 열 단위로 입력할 수 있는 몇 가지 방법을 소개합니다. 1) 'cell' 메서드 사용 from openpyxl import Workbook wb = Workbook() ws = wb.active ws.title = "수강생_정보" # 열로 입력할 데이터를 리스트로 만들어 'data'에 저장 data = [ '이철수', '김미소', '최학준' ] # for 문으로 'A'열의 각 셀에 순서대로 접근하여 데이터를 입력 for i, value in enumerate(data): ws.cell(row=i+1, column=1, value=value) wb.save("수강생_리스트. xlsx") 'cell' 메서드는 각 셀의 위치를 행(row)과 열(column)로 지정하여 값을 입력할 수 있습니다. 위의 코드에서 행(row)은 하나씩 숫자가 늘어나서 다음 행으로 이동하고, 열(column)은 인덱스 번호 1, 즉, 'A열'을 의미합니다. 따라서 'A'열의 각 행을 순서대로 접근하면서 'data' 리스트의 요소를 하나씩 입력합니다. 2) 열 이름 활용 from openpyxl import Workbook from openpyxl.utils import get_column_letter wb = Workbook() ws = wb.active ws.title = "수강생_정보" # 열로 입력할 데이터를 리스트로 만들어 'data'에 저장 data = [ '이철수', '김미소', '최학준' ] # 입력할 열의 인덱스 번호를 열이름으로 변환하여 'column_name'에 저장 column_name = get_column_letter(1) # 데이터를 입력할 열의 각 셀의 위치를 for 문으로 생성한 후 'data'의 값을 하나씩 입력 for i, value in enumerate(data): ws[f"{column_name}{i+1}"] = value wb.save("수강생_리스트. xlsx") 이 방식은 데이터를 입력할 열의 모든 셀에 각각 접근하여 데이터를 입력합니다. 열의 각 셀에 해당하는 위치값을 for 문으로 자동 생성하는데, ws[f"{column_name}{i+1}"]에서 열의 값은 'column_name'인 'A'열로 고정하고, i가 증가함에 따라 행의 값이 하나씩 증가하면서 A1, A2, ... 순서대로 셀의 위치값이 생성됩니다. 이렇게 출력된 셀의 위치에 차례대로 접근하면서 'data'의 원소들을 입력합니다. 3) iter_cols() 함수 사용 from openpyxl import Workbook wb = Workbook() ws = wb.active ws.title = "수강생_정보" # 열로 입력할 데이터를 리스트로 만들어 'data'에 저장 data = [ '이철수', '김미소', '최학준' ] # A 열의 셀을 순회할 수 있는 iterator를 가져오는데, 여기서 최대행을 'data'의 원소 개수로 지정 col_cells = ws.iter_cols(min_col=1, max_col=1, max_row=len(data)) # 이중 for 문으로 B 열의 각 셀을 순환하며 'data' 리스트의 원소를 차례대로 입력 for col in col_cells: for i, cell in enumerate(col): cell.value = data[i] wb.save("수강생_리스트. xlsx") 'iter_cols()'는 열 단위로 셀을 순회하는 함수로, 여기서는 하나의 열에만 데이터를 입력하기 위해 'min_col(시작 열의 인덱스 번호)'와 'max_col(종료 열의 인덱스 번호)'을 열의 인덱스 값인 1을 넣어주어 'A'열만 순회하도록 설정했습니다. 또한 데이터를 입력할 행의 범위도 지정해 주기 위해 'max_row'는 입력할 데이터의 개수로 제한했습니다. 이렇게 범위가 지정된 'iter_cols()' 함수를 통해 데이터를 입력할 셀의 위치들이 반환되어 'col_cells'에 리스트로 저장됩니다. 그러면 첫 번째 for 문으로 'col_cells'에 저장된 원소를 불러와서 각 셀의 위치를 지정하고, 두 번째 for 문으로 각각의 셀에 'data'의 원소를 차례대로 입력합니다. 4) 행과 열의 인덱스 번호로 데이터 입력 from openpyxl import Workbook wb = Workbook() ws = wb.active ws.title = "수강생_정보" # A열과 B 열에 입력할 데이터를 이중 리스트로 만들어 'data'에 저장 data = [ [ '이철수', '김미소', '최학준' ], [ '수학', '영어', '컴퓨터' ] ] # 이중 for 문으로 열의 인덱스 번호와 행의 인덱스 번호로 셀에 데이터를 입력 for col_idx, col_data in enumerate(data, start=1): for row_idx, row_data in enumerate(col_data): ws.cell(row=row_idx+1, column=col_idx, value=row_data) wb.save("수강생_리스트. xlsx") 위의 코드에서는 A열과 B 열에 입력할 데이터를 각각 리스트로 만들고, 두 개의 리스트를 열 순서대로 원소로 넣어 이중 리스트를 만들어줍니다. 그다음 이중 for 문으로 행과 열의 인덱스 번호를 출력하는데, 'start=1'로 지정하여 첫 번째 열부터 차례대로 데이터를 입력하도록 합니다. 만약, 첫 번째 열이 아닌 특정 열부터 입력을 시작하려면 해당 열의 인덱스 번호를 시작열로 지정해 줍니다. 데이터를 입력할 열과 열 사이에 공백을 넣고자 한다면, 이중 리스트에서 각 리스트 사이에 원하는 공백 열의 개수만큼 빈 리스트 '[]' 넣어주면 그만큼 열을 건너뛰고 그다음 열에 데이터를 입력합니다. 04-02. 엑셀 데이터 읽기 생성된 엑셀 파일 불러오기 새롭게 엑셀 파일을 생성하지 않고 기존에 만들어진 파일을 불러와서 데이터를 추가하거나 수정하는 작업을 해야 하는 경우도 있습니다. 이번에는 이미 생성되어 있는 파일을 불러온 후 특정 워크시트를 선택하여 작업하는 방법을 알아보겠습니다. 파일이 엑셀 프로그램으로 열려 있는 경우에도 파이썬에서 접근할 때 오류가 날 수 있기 때문에 읽어오려는 파일이 열려있다면 모두 종료한 후 코드를 실행합니다. 엑셀 파일을 불러올 때 openpyxl은 파일에 저장된 모든 요소들(items)을 가지고 올 수 없습니다. 불러올 때 이미 지나 차트 등의 내용이 사라질 수 있습니다. 따라서 엑셀 파일을 불러와 작업을 한 후 저장할 때는 기존 파일명이 아닌 다른 이름으로 저장하여 기존 엑셀 파일의 이미 지나 차트가 지워지지 않도록 유의해야 합니다. # openpyxl 라이브러리에서 load_workbook을 import from openpyxl import load_workbook # '월별 구매 고객 리스트. xlsx' 엑셀 파일 불러오기 wb = load_workbook(filename='월별 구매 고객 리스트. xlsx') # 첫 번째 시트 불러오기 ws = wb.active 이미 생성되어 있는 파일을 불러올 때, 해당 파일이 파이썬을 실행한 위치(실행 경로)에 저장되어 있어야 합니다. 만약 다른 위치에 있는 파일을 불러오고자 한다면, load_workbook(filename)의 파일명을 적을 때 파일의 위치까지 포함해야 로딩이 가능합니다. 예를 들어, C 드라이브 > 사용자 > 2023이라는 폴더에 저장된 '월별 구매 고객 리스트. xlsx'파일을 불러온다면 아래와 같이 경로를 함께 넣어줍니다. wb = load_workbook(filename='C:\Users\2023\월별 구매 고객 리스트. xlsx') 직접 경로를 입력하지 않고 os.path를 활용한 경로 입력도 가능합니다. 특정 시트 지정하여 불러오기 위의 코드에서는 파일의 활성화된 시트를 불러오도록 wb.active를 사용하여 워크시트를 설정했습니다. 첫 번째 시트가 아닌 다른 시트를 불러와서 작업을 하기 위해서는 대괄호('[ ]')를 사용하거나 'get_sheet_by_name()' 메서드를 사용합니다. 1) 대괄호 '[ ]'를 사용하여 특정 시트 불러오기 from openpyxl import load_workbook # 엑셀 파일 불러오기 wb = load_workbook(filename='월별 구매 고객 리스트. xlsx') # '10월' 시트 불러오기 ws = wb['10월'] # 'A1'셀의 값 가져오기 ws['A1'].value 2) 'get_sheet_by_name()' 메서드로 특정 시트 불러오기 from openpyxl import load_workbook # 엑셀 파일 불러오기 wb = load_workbook(filename='월별 구매 고객 리스트. xlsx') # '10월' 시트 불러오기 ws = wb.get_sheet_by_name('10월') # 'A1'셀의 값 가져오기 ws['A1'].value 위의 두 코드 모두 동일하게 '10월'이라는 시트를 불러오고 있습니다. 다만, 첫 번째 방법은 신버전이지만, 두 번째 방법인 'get_sheet_by_name()'은 구버전 방식이라 실행 시 코드는 문제없이 작동하나 DeprecationWarning 경고가 뜰 수 있습니다. 만약 시트명을 정확히 알지 못하거나 전체 시트명 확인이 필요한 경우, 파일에 포함된 전체 시트의 목록을 출력할 수 있습니다. from openpyxl import load_workbook # 엑셀 파일 불러오기 wb = load_workbook(filename='월별 구매 고객 리스트. xlsx') # 시트 이름들을 가져오기 sheet_names = wb.sheetnames # 시트 이름들 출력 print(sheet_names) # 출력값 ['10월', '11월', '12월', '2023년_전체'] 시트 전체 데이터 가져오기 시트를 불러온 후 ws['A1'].value 코드로 해당 시트의 A1 셀의 값을 불러왔습니다. 셀 하나의 값이 아닌 전체 데이터를 읽기 위해서는 행마다 순회하면서 한 행의 모든 셀 값을 가져오도록 실행할 수 있습니다. from openpyxl import load_workbook # 엑셀 파일 불러오기 wb = load_workbook(filename='월별 구매 고객 리스트. xlsx') # '10월' 시트 불러오기 ws = wb['10월'] # 전체 데이터를 순회하며 읽기 for row in ws.rows: row_values = [cell.value for cell in row] print(row_values) # 출력값 ['10월', None, None, None, None, None] ['구매일자', '구매 제품', '수량', '고객명', '소속', '기존 고객 여부', '단가', '총액'] [datetime.datetime(2023, 10, 3, 0, 0), 'A 제품', 2, '김철원', '최강 회사', '기존', 20000, '=C3*G3'] [datetime.datetime(2023, 10, 16, 0, 0), 'B 제품', 1, '이 남연', '다 알 아연 구소', '신규', 18000, '=C4*G4'] [datetime.datetime(2023, 10, 22, 0, 0), 'B 제품', 1, '최연화', '일일 컴퍼니', '신규', 18000, '=C5*G5'] [datetime.datetime(2023, 10, 29, 0, 0), 'C 제품', 4, '황수지', '소속 없음', '신규', 36000, '=C6*G6'] [datetime.datetime(2023, 10, 29, 0, 0), 'D 제품', 2, '유진태', '소속 없음', '기존', 68000, '=C7*G7'] 특정 행을 기준으로 데이터 가져오기 위의 코드 실행 결과를 보면, 첫 번째 행에서는 A1 셀에 '10월'이라는 값만 있고 두 번째 행은 테이블의 열이름이 저장되어 있습니다. 즉, 실제 데이터가 시작되는 행은 세 번째 행부터라는 것을 알 수 있습니다. 데이터 작업을 위해 첫 번째와 두 번째 행을 제외한 실제 데이터 테이블만 출력해 보겠습니다. rows()로 데이터 가져오기 from openpyxl import load_workbook # 엑셀 파일 불러오기 wb = load_workbook(filename='월별 구매 고객 리스트. xlsx') # '10월' 시트 불러오기 ws = wb['10월'] # 첫 번째와 두 번째 행을 제외하고 나머지 행을 리스트로 변환 new_rows = list(ws.rows)[2:] # 나머지 행을 순회하며 읽기 for row in new_rows: row_values = [cell.value for cell in row] print(row_values) # 출력값 [datetime.datetime(2023, 10, 3, 0, 0), 'A 제품', 2, '김철원', '최강 회사', '기존', 20000, '=C3*G3'] [datetime.datetime(2023, 10, 16, 0, 0), 'B 제품', 1, '이 남연', '다 알 아연 구소', '신규', 18000, '=C4*G4'] [datetime.datetime(2023, 10, 22, 0, 0), 'B 제품', 1, '최연화', '일일 컴퍼니', '신규', 18000, '=C5*G5'] [datetime.datetime(2023, 10, 29, 0, 0), 'C 제품', 4, '황수지', '소속 없음', '신규', 36000, '=C6*G6'] [datetime.datetime(2023, 10, 29, 0, 0), 'D 제품', 2, '유진태', '소속 없음', '기존', 68000, '=C7*G7'] 첫 번째 행을 제외한 나머지 행 전체를 리스트로 변환하여 'new_rows'에 저장한 후, 'new_rows'의 전체 행을 순회하여 데이터를 가져오도록 실행했습니다. iter_rows로 데이터 가져오기 iter_rows 메서드를 활용해도 위의 내용을 동일하게 실행할 수 있습니다. iter_rows는 엑셀 워크시트의 특정 행 범위를 반복하기 위해 사용됩니다. 시트의 특정 부분만 선택적으로 읽어 처리할 수 있으며, 행과 열의 특정 범위를 지정하여 그 부분만 반복할 수도 있습니다. from openpyxl import load_workbook # 엑셀 파일 불러오기 wb = load_workbook(filename='월별 구매 고객 리스트. xlsx') # '10월' 시트 불러오기 ws = wb['10월'] # 3번째 행부터 마지막 행까지를 순회하며 값을 읽기 (min_row =3) for row in ws.iter_rows(min_row=3, values_only=True): print(row) # 결괏값 (datetime.datetime(2023, 10, 3, 0, 0), 'A 제품', 2, '김철원', '최강 회사', '기존', 20000, '=C3*G3') (datetime.datetime(2023, 10, 16, 0, 0), 'B 제품', 1, '이 남연', '다 알 아연 구소', '신규', 18000, '=C4*G4') (datetime.datetime(2023, 10, 22, 0, 0), 'B 제품', 1, '최연화', '일일 컴퍼니', '신규', 18000, '=C5*G5') (datetime.datetime(2023, 10, 29, 0, 0), 'C 제품', 4, '황수지', '소속 없음', '신규', 36000, '=C6*G6') (datetime.datetime(2023, 10, 29, 0, 0), 'D 제품', 2, '유진태', '소속 없음', '기존', 68000, '=C7*G7') iter_rows로 시트의 각 행을 반복 가능한 객체로 생성한 다음 for 문으로 행을 순회하여 출력합니다. 파라 미트를 사용해 시트의 특정 부분만 가져오게 할 수 있는데, 여기서는 세 번째 행부터 마지막행까지를 가져오기 위해 'min_row=3'으로 시작할 행만 지정하였습니다. 주요 파라미터를 간략히 살펴보겠습니다. min_row : 반복을 시작할 행의 인덱스(지정하지 않으면 첫 번째 행부터 시작) max_row : 반복을 마칠 행의 인덱스(지정하지 않으면 마지막 행까지 반복) min_col : 반복을 시작할 열의 인덱스(지정하지 않으면 첫 번째 열부터 시작) max_col : 반복을 마칠 열의 인덱스(지정하지 않으면 마지막 열까지 반복) values_only : Ture일 경우 셀 값을 반환(지정하지 않으면 셀 객체를 반환) 위의 여러 파라미터를 조합하여 원하는 범위의 데이터만 선택적으로 처리가 가능합니다. 수식을 계산하여 데이터 가져오기 위의 코드 출력값에서 가장 마지막 열을 보면, 특정한 값이 아닌 '= C3 * G3'과 같이 수식이 출력된 것을 알 수 있습니다. 기존 엑셀 파일에 수식이 작성되어 있는 경우, 파이썬에서 데이터를 불러올 때 별도의 설정을 하지 않으면 계산된 결과가 아닌 수식 자체를 가지고 옵니다. 수식 자체가 아닌 계산된 결괏값이 필요하다면 load_workbook()으로 데이터를 가져올 때 'data_only = True'를 추가해 주어야 합니다. 그러면 위의 동일한 코드에 'data_only = True'를 추가해 보겠습니다. from openpyxl import load_workbook # 엑셀 파일 불러오기 (수식이 계산된 결괏값을 가져오도록 인수 설정) wb = load_workbook(filename='월별 구매 고객 리스트. xlsx', data_only = True) # '10월' 시트 불러오기 ws = wb['10월'] # 첫 번째와 두 번째 행을 제외하고 나머지 행을 리스트로 변환 new_rows = list(ws.rows)[2:] # 나머지 행을 순회하며 읽기 for row in new_rows: row_values = [cell.value for cell in row] print(row_values) # 출력값 [datetime.datetime(2023, 10, 3, 0, 0), 'A 제품', 2, '김철원', '최강 회사', '기존', 20000, 40000] [datetime.datetime(2023, 10, 16, 0, 0), 'B 제품', 1, '이 남연', '다 알 아연 구소', '신규', 18000, 18000] [datetime.datetime(2023, 10, 22, 0, 0), 'B 제품', 1, '최연화', '일일 컴퍼니', '신규', 18000, 18000] [datetime.datetime(2023, 10, 29, 0, 0), 'C 제품', 4, '황수지', '소속 없음', '신규', 36000, 144000] [datetime.datetime(2023, 10, 29, 0, 0), 'D 제품', 2, '유진태', '소속 없음', '기존', 68000, 136000] 이번에는 마지막 열이 수식으로 출력되지 않고, 수식 계산을 완료한 값이 출력된 것을 확인할 수 있습니다. 실무에서 사용되는 엑셀 파일에는 수식이 포함되는 경우가 많기 때문에 그럴 때는 이와 같이 'data_only =True'를 넣어주면 편리합니다. 다만, 이 경우에도 작업 완료 후 기존 엑셀 파일과 동일한 파일명으로 덮어쓰면 기존파일에 있던 수식이 지워지므로 다른 이름으로 저장하여 원본을 별도로 보존하는 편이 데이터 관리에 좋습니다. 열을 지정하여 데이터 가져오기 이번에는 특정 열을 지정하는 방법을 알아보겠습니다. rows()로 데이터 가져오기 from openpyxl import load_workbook # 엑셀 파일 불러오기 wb = load_workbook(filename='월별 구매 고객 리스트. xlsx') # '10월' 시트 불러오기 ws = wb['10월'] # 첫 번째와 두 번째 행을 제외하고 나머지 행을 리스트로 변환 new_rows = list(ws.rows)[2:] # 나머지 행을 순회하며 B 열과 C 열의 데이터만 읽기 for row in new_rows: print(row[1].value, row[2].value) # 출력값 구매 제품 수량 A 제품 2 B 제품 1 B 제품 1 C 제품 4 D 제품 2 열의 인덱스 번호를 사용하면 출력할 열을 지정할 수 있습니다. 위의 방식을 활용하여 특정 행과 특정 열에 해당하는 데이터만 자유자재로 출력이 가능합니다. iter_cols로 데이터 가져오기 '3-4-1. 엑셀 파일 생성 및 데이터 입력'에서 열 단위로 데이터를 입력하는 방법 중 하나로 iter_cols를 사용하는 방법을 학습했습니다. 앞서 특정 행을 지정할 때 사용한 iter_rows처럼 iter_cols도 파라미터를 활용해 특정 범위를 지정할 수 있습니다. 그러면 위의 코드를 iter_cols를 활용한 코드로 수정해 보겠습니다. from openpyxl import load_workbook # 엑셀 파일 불러오기 wb = load_workbook(filename='월별 구매 고객 리스트. xlsx') # '10월' 시트 불러오기 ws = wb['10월'] # B 열과 C 열 데이터만 순회하기 (인덱스는 1부터 시작하므로 B 열은 2, C 열은 3입니다) for col in ws.iter_cols(min_col=2, max_col=3, min_row=3): for cell in col: print(cell.value) # 결괏값 A 제품 B 제품 B 제품 C 제품 D 제품 1 4 'min_col=2'로 두 번째 열(B)부터 시작하였고, 'max_col=3'으로 세 번째 열(C)까지 열 범위를 지정하고, 'min_row=3'으로 세 번째 행부터 마지막 행까지로 행의 범위를 지정하였습니다. iter_rows를 사용했을 때와 비교하면 사용한 파라미터의 이름이 동일한 것을 알 수 있습니다. 즉, iter_cols와 iter_rows는 동일한 파라미터의 종류로 범위를 지정합니다. 다만, 차이점이 있다면 iter_rows는 각 행의 셀들을 순회하는 방식으로 데이터를 반환하기 때문에 행 단위로 데이터를 처리하고, iter_cols는 각 열의 셀을 순회하는 방식으로 데이터를 반환하기 때문에 열 단위로 데이터를 처리할 수 있습니다. iter_cols를 사용했을 때 출력된 결괏값을 보면 B 열의 데이터가 먼저 출력된 다음에 C 열의 데이터가 이어서 출력되었습니다. 이와 같이 iter_cols는 열 단위로 데이터를 작업할 수 있습니다. 특정 조건을 기준으로 데이터 가져오기 엑셀의 필터처럼 openpyxl을 이용하여 특정 조건에 해당하는 데이터를 가져올 수 있습니다. 위의 데이터에서 수량이 2개 이상인 데이터만 출력해 보겠습니다. from openpyxl import load_workbook # 엑셀 파일 불러오기 wb = load_workbook(filename='월별 구매 고객 리스트. xlsx') # '10월' 시트 불러오기 ws = wb['10월'] # 첫 번째와 두 번째 행을 제외하고 나머지 행을 리스트로 변환 new_rows = list(ws.rows)[2:] # 나머지 행을 순회하며 읽기 for row in new_rows: if row[2].value >= 2: print(row[1].value, row[2].value) # 출력값 A 제품 2 C 제품 4 D 제품 2 이와 같이 if 문을 활용하여 특정 조건을 지정해 줄 수 있습니다. 단, 위의 코드처럼 숫자를 기준으로 조건을 거는 경우, 해당 열의 데이터가 숫자형 데이터이어야 하며 그렇지 않은 경우에는 int()나 float() 등을 사용하여 숫자형으로 먼저 변환해 주어야 합니다. 암호화된 엑셀 파일 다루기 openpyxl 라이브러리는 엑셀 파일을 불러올 때 암호화된 파일은 지원하지 않습니다. 따라서 이럴 경우 작업 실행 전에 미리 엑셀 파일의 암호를 해제하고 코드를 실행하거나 msoffcrypto-tool을 사용하여야 합니다. msoffcrypto-tool을 사용하면 암호화된 엑셀과 워드 파일을 읽을 수 있습니다. 먼저 pip 명령어로 msoffcrypto-tool을 설치합니다. pip install msoffcrypto-tool openpyxl 아래는 설치된 msoffcrypto-tool을 사용해 openpyxl로 암호화된 엑셀 파일("월별 구매 고객 리스트_잠김. xlsx", 암호: 1234)을 읽어 와서 행 단위로 데이터를 출력하는 예시 코드입니다. import msoffcrypto from openpyxl import load_workbook # 암호화된 엑셀 파일 지정 file = msoffcrypto.OfficeFile(open("월별 구매 고객 리스트_잠김. xlsx", "rb")) # 파일 암호 해제 file.load_key(password="1234") # 암호 해제된 데이터를 새 파일에 저장 with open("월별구매고객리스트_잠김해제.xlsx", "wb") as f: file.decrypt(f) # 암호 해제된 파일 읽기 wb = load_workbook("월별구매고객리스트_잠김해제.xlsx") ws = wb.active # 워크시트의 모든 행을 순회하여 출력 for row in ws.iter_rows(values_only=True): print(row) # 암호 해제된 임시 파일 삭제 import os os.remove("월별구매고객리스트_잠김해제.xlsx") # 결괏값 ('12월', None, None, None, None, None, None, None) ('구매일자', '구매 제품', '수량', '고객명', '소속', '기존 고객 여부', '단가', '매출액') (datetime.datetime(2023, 12, 13, 0, 0), 'C 제품', 2, '강지원', '학생', '기존', 36000, '=C3*G3') (datetime.datetime(2023, 12, 17, 0, 0), 'C 제품', 1, '최민은', '아자코퍼레이션', '신규', 36000, '=C4*G4') (datetime.datetime(2023, 12, 22, 0, 0), 'B 제품', 1, '박서은', '상상 대학교', '신규', 18000, '=C5*G5') (datetime.datetime(2023, 12, 27, 0, 0), 'A 제품', 4, '임지은', '주식회사 지은', '신규', 20000, '=C6*G6') msoffcrypto를 사용하여 파일 암호 해제하는 방법을 자세히 살펴보겠습니다. import msoffcrypto from openpyxl import load_workbook # 암호화된 엑셀 파일 지정 file = msoffcrypto.OfficeFile(open("월별 구매 고객 리스트_잠김. xlsx", "rb")) 먼저 msoffcrypto를 import 한 후에, open()과 msoffcrypto.OfficeFile()로 암호화된 엑셀 파일을 지정해 줍니다. # 파일 암호 해제 file.load_key(password="1234") # 암호 해제된 데이터를 새 파일에 저장 with open("월별구매고객리스트_잠김해제.xlsx", "wb") as f: file.decrypt(f) 그다음, load_key() 메서드에 패스워드 "1234"를 전달합니다. 전달받은 패스워드를 사용해 decrypt()로 파일의 암호를 해제하고, 이렇게 암호가 해제된 데이터를 "월별구매고객리스트_잠김해제.xlsx"라는 새 파일로 저장합니다. # 암호 해제된 파일 읽기 wb = load_workbook("월별구매고객리스트_잠김해제.xlsx") ws = wb.active # 워크시트의 모든 행을 순회하여 출력 for row in ws.iter_rows(values_only=True): print(row) # 암호 해제된 임시 파일 삭제 import os os.remove("월별구매고객리스트_잠김해제.xlsx") 이렇게 암호 해제 후 새로 저장된 파일로 데이터 작업을 수행합니다. 작업 완료 후 코드를 종료할 수도 있지만, 여기서는 os.remove를 사용해 암호를 해제한 파일을 다시 삭제하도록 명령하였습니다. 암호화된 파일의 패스워드를 알고 있는 경우에는 이처럼 msoffcrypto-tool 라이브러리를 활용해 파일의 내용을 확인할 수 있습니다. 만약 msoffcrypto-tool을 사용하는 것이 번거롭다면 엑셀 파일의 암호를 수동으로 먼저 해제한 후에 파이썬으로 데이터 작업을 실행하면 됩니다. 04-03. 엑셀 서식 설정하기 이번에는 파이썬으로 엑셀을 다룰 때 서식을 설정하는 방법을 알아보겠습니다. openpyxl도 글꼴과 셀 서식, 표시<NAME> 등 기본적인 엑셀 서식을 설정하는 기능을 제공하고 있습니다. 다양한 엑셀 서식 중 주요한 서식 설정 몇 가지를 알아보겠습니다. 글꼴과 셀 스타일 설정 글꼴 설정 'Font' 클래스를 사용하여 글꼴을 설정할 수 있습니다. from openpyxl import Workbook from openpyxl.styles import Font wb = Workbook() ws = wb.active cell = ws['A1'] cell.value = "Hello World" # 폰트 스타일 설정: 빨간색, 이탤릭 체, 볼드체, 20포인트 사이즈로 설정 cell.font = Font(color='FF0000', italic=True, bold=True, size=20) wb.save('엑셀 서식. xlsx') # 저장된 엑셀 파일 실행 화면('엑셀 서식. xlsx') openpyxl.styles의 Font 클래스를 불러온 후 시트 A1 셀에 글꼴 서식을 설정하였습니다. color로 글자색을 지정하고, italic으로 기울임을, bold로 글자의 굵기를, size로 글자 크기를 설정할 수 있습니다. 이러한 글꼴 옵션들 중 필요한 것들만 선택적으로 지정할 수 있습니다. 셀 서식 설정 이번에는 셀 서식을 설정하는 코드를 추가해 보겠습니다. from openpyxl import Workbook from openpyxl.styles import Font wb = Workbook() ws = wb.active cell = ws['A1'] cell.value = "Hello World" # 폰트 스타일 설정: 빨간색, 이탤릭 체, 볼드체, 20포인트 사이즈로 설정 cell.font = Font(color='FF0000', italic=True, bold=True, size=20) # 셀 너비 설정 (A 열의 너비를 50으로 설정) ws.column_dimensions['A'].width = 50 # 셀 높이 설정 (1 행의 높이를 50으로 설정) ws.row_dimensions[1].height = 50 # 셀 배경값 설정 (노란색, 색상 코드 'FFFF00') from openpyxl.styles import PatternFill yellow_fill = PatternFill(start_color='FFFF00', end_color='FFFF00', fill_type='solid') cell.fill = yellow_fill # 셀 테두리 설정: 모든 사이드에 얇은 테두리 스타일 적용 from openpyxl.styles import Border, Side thin_border = Border(left=Side(style='thin'), right=Side(style='thin'), top=Side(style='thin'), bottom=Side(style='thin')) cell.border = thin_border # 셀 정렬 설정: 셀 내용을 수평 및 수직 중앙 정렬 from openpyxl.styles import Alignment cell.alignment = Alignment(horizontal='center', vertical='center') wb.save('엑셀 서식. xlsx') # 저장된 엑셀 파일 실행 화면('엑셀 서식. xlsx') 셀 서식 코드를 하나씩 살펴보겠습니다. # 셀 너비 설정 (A 열의 너비를 50으로 설정) ws.column_dimensions['A'].width = 50 # 셀 높이 설정 (1 행의 높이를 50으로 설정) ws.row_dimensions[1].height = 50 셀의 너비와 높이를 설정하려면 열과 행의 width와 height 속성을 사용해야 합니다. 이러한 속성은 column_dimensions와 row_dimensions를 통해 접근할 수 있습니다. 열 이름과 행 번호를 각각 전달해 위치를 지정하고 width와 height에 설정값을 입력합니다. 여기서 코드상 너비와 높이의 설정값을 둘 다 50으로 넣었는데 실제 생성된 파일을 열어보면 너비와 높이가 같아 보이지 않아서 의아할 수 있습니다. 이는 엑셀의 기본 너비와 높이 단위가 다르게 설정되어 있기 때문입니다. 행 높이 단위는 포인트(pt)로 1포인트는 우리에게 익숙한 cm 기준으로는 약 0.035cm입니다. 이와 달리 열 너비는 문자 너비 단위로, 너비 1은 표준 글꼴 서식의 한 글자를 표시할 수 있는 크기입니다. 이처럼 엑셀의 높이와 너비 단위가 다르기 때문에 이 점을 감안하고 설정하고자 하는 크기 값을 입력해 주어야 합니다. # 셀 배경값 설정 (노란색, 색상 코드 'FFFF00') from openpyxl.styles import PatternFill yellow_fill = PatternFill(start_color='FFFF00', end_color='FFFF00', fill_type='solid') cell.fill = yellow_fill 다음은 셀 배경색 설정입니다. 셀의 배경색은 openpyxl.styles 모듈의 PatternFill 클래스를 사용하여 설정할 수 있습니다. PatternFill을 사용할 때 fill_type으로 배경색의 패턴 유형을 결정합니다. 여기서는 단색으로 넣기 위해 fill_type을 'solid'로 입력하였습니다. 그리고 start_color와 end_color로 색상의 값을 전달합니다. 컬러의 속성이 두 가지인 이유는 그러데이션 효과를 적용할 때 시작 부분과 종료 부분에서 사용할 색상이 필요하기 때문입니다. 그렇지만 그러데이션이 아닌 단색인 경우에도 두 값을 모두 입력해 줘야 하며, 그럴 경우 위의 코드처럼 시작 색상과 종료 색상을 모두 동일한 값으로 지정합니다. 색상의 값은 HTML 색상 코드로 설정합니다. # 셀 테두리 설정: 모든 사이드에 얇은 테두리 스타일 적용 from openpyxl.styles import Border, Side thin_border = Border(left=Side(style='thin'), right=Side(style='thin'), top=Side(style='thin'), bottom=Side(style='thin')) cell.border = thin_border 셀의 테두리는 openpyxl.styles의 Border와 Side 클래스로 서식을 설정할 수 있습니다. Border로 셀에 테두리를 설정할 방향을 지정하고, Side로 테두리의 스타일을 지정합니다. 여기서는 상하좌우에 모두 테두리 스타일을 얇게 만들도록 모두 동일하게 Side(style='thin')을 입력했습니다. 매개변수 'left', 'right', 'top', 'bottom'의 스타일을 각각 다르게 지정하면 점선, 두꺼운 테두리 등 셀의 상하좌우 테두리의 스타일을 각각 설정할 수 있습니다. # 셀 정렬 설정: 셀 내용을 수평 및 수직 중앙 정렬 from openpyxl.styles import Alignment cell.alignment = Alignment(horizontal='center', vertical='center') 셀에 입력된 텍스트의 정렬 방법은 openpyxl.styles의 Alignment 클래스로 설정합니다. Alignment의 매개변수 horizontal로 수평 정렬 방식을, vertical로 수직 정렬 방식을 지정합니다. 여기서는 수직과 수평 모두 'center'으로 설정하여 텍스트가 셀의 수직 중앙에 위치합니다. 표시<NAME> 설정 앞에서 셀과 글자의 스타일을 설정했다면 이번에는 셀에 입력된 데이터의<NAME>을 설정해 보겠습니다. 소수점 자릿수와 천 단위 구분 기호 서식 설정 다양한 숫자 데이터를 다루는 실무에서는 주로 데이터의 성격에 따라 숫자의<NAME>을 다르게 표현하는 경우가 많습니다. openpyxl의 number_format을 이용해서 천 단위 구분 기호, 소수점 자릿수 등 숫자를 표시하는 방식을 지정해 보겠습니다. ws['A1'] = 1234567.890123 # 천 단위 구분 기호와 소수점 자릿수 지정 ws['A1'].number_format = '#,##0.00' 소수점 자릿수는 마침표(.)를 사용하여 표시합니다. number_format 속성에 서식 코드를 넣을 때 마침표 뒤에 자릿수를 나타내는 0 또는 #을 붙여서 소수점 아래 몇 번째 자리까지 표시할지 지정합니다. 숫자 서식에서 자릿수를 0으로 사용할 때와 #으로 사용할 때는 표시되는 결괏값에 조금 차이가 있습니다. 0을 사용하면 유효하지 않은 0을 포함하고, #은 유효하지 않은 0을 생략합니다. 예를 들어, 셀의 값이 0.0일 경우, 0은 둘 다 유효하지 않습니다. 이때 서식을 #.#으로 지정하면 유효하지 않은 0을 제외하고 '.'만 나타납니다. 그래서 이 경우 데이터를 표시하려면 서식을 0.0으로 지정해야 합니다. 숫자 서식에 천 단위 구분 기호도 넣어줄 수 있는데, 자릿수를 나타내는 #과 0을 사용해 천 단위마다 쉼표(,)를 입력합니다. 즉, #,###이나 #,##0과 같이 서식을 입력하는데 데이터가 0일 때 공백으로 표시하려면 #,###을, 0으로 그대로 표시하려면 #,##0을 사용합니다. 통화 기호와 퍼센트 서식 설정 천 단위 구분 기호를 통화 기호와 같이 사용하여 금액을 나타내도록 서식을 설정할 수도 있습니다. ws['D1'] = 1234567.89 # 통화 기호와 천 단위 구분 단위 표시 ws['D1'].number_format = '₩#,##0' 위에서 사용한 숫자<NAME> 앞에 통화 기호를 더해주면 금액을 표시할 수 있습니다. 원화는 소수점이 없기 때문에 위의 예제에서는 소수점 자릿수를 표현하지 않았지만, 달러와 같이 소수점을 같이 사용하는 통화일 경우에는 소수점 자릿수도 같이 사용하면 됩니다. ws['B1'] = 0.12345 # 퍼센트<NAME>으로 표시 ws['B1'].number_format = '0.00%' 이와 동일한 방식으로 퍼센트<NAME>도 표시할 수 있습니다. 표시할 소수점 자릿수를 지정한 후 그 뒤에 퍼센트(%) 기호를 붙여주면 백분율로 값을 표시합니다. 날짜와 시간 서식 설정 이번에는 날짜와 시간<NAME>을 표시하는 서식을 설정해 보겠습니다. from datetime import datetime ws['C1'] = datetime(2023, 9, 7) # 날짜 서식 설정 ws['C1'].number_format = 'MM-DD-YYYY' 파이썬에서 날짜와 시간을 처리할 때는 datetime 모듈을 사용합니다. 여기서는 datetime 모듈의 datetime 클래스를 불러와 23년 9월 7일이라는 특정 날짜를 나타냈습니다. 그다음 '연도-월-일'<NAME>으로 날짜를 표시하기 위해 서식을 'YYYY-MM-DD'로 설정합니다. 날짜 외에 시간도 함께 표시하려면 'hh(시간)'와 'mm(분)'으로 서식을 지정해 주면 됩니다. 04-04. 실전! 조건에 맞는 데이터만 추출하여 새 파일로 저장하기 실무에서는 한 파일의 데이터를 복사하여 다른 엑셀 파일에 붙여 넣거나 여러 파일을 하나로 합쳐야 하는 경우들이 많이 발생합니다. 한 번 발생하는 업무라면 복사와 붙여넣기를 수작업으로 진행하는 것이 빠르겠지만, 매월 / 매주 / 매일 발생하는 업무라면 이러한 데이터 합치기 작업도 자동화하는 것이 업무 시간과 리소스를 단축시켜줄 것입니다. 앞에서 학습한 내용을 응용하여 엑셀 문서 간 데이터를 옮기는 작업을 해보겠습니다. 하나의 문서에서 데이터 복사하여 새 파일로 저장하기 앞서 사용했던 '월별 구매 고객 리스트. xlsx'의 '10월', '11월', '12월' 시트에서 신규 고객에 해당하는 리스트만 별도로 추출한 후 제품별로 시트를 분리하여 저장하는 코드를 알아보겠습니다. 우선, '10월' 하나의 시트에서 신규 고객에 해당하는 리스트를 먼저 추출해 보겠습니다. from openpyxl import load_workbook # 엑셀 파일 불러오기 wb = load_workbook(filename='월별 구매 고객 리스트. xlsx', data_only=True) # '10월' 시트 불러오기 ws = wb['10월'] # 첫 번째와 두 번째 행을 제외하고 나머지 행을 리스트로 변환 new_rows = list(ws.rows)[2:] # F 열(인덱스 5)이 '신규'인 데이터만 추출 for row in new_rows: if row[5].value == '신규': row_values = [cell.value for cell in row] print(row_values) new_wb.save(filename='제품별 신규 고객 리스트. xlsx') # 출력값 [datetime.datetime(2023, 10, 16, 0, 0), 'B 제품', 1, '이 남연', '다 알 아연 구소', '신규', 18000, 18000] [datetime.datetime(2023, 10, 22, 0, 0), 'B 제품', 1, '최연화', '일일 컴퍼니', '신규', 18000, 18000] [datetime.datetime(2023, 10, 29, 0, 0), 'C 제품', 4, '황수지', '소속 없음', '신규', 36000, 144000] 신규/기존 고객 여부는 '월별 구매 고객 리스트. xlsx'의 '10월' 시트 F 열에 구분되어 있는데, F 열은 인덱스로는 5이므로 if row[5].value == '신규': 조건문으로 신규 고객만 데이터를 추출할 수 있습니다. 만약 인덱스 번호를 모르는 경우에는 앞서 학습했던 ' 열이름 - 인덱스 변환 ' 함수(column_index_from_string(열 이름))를 사용하면 됩니다. 그러면 이번에는<NAME>이 동일한 '11월', '12월' 시트까지 모두 동일한 작업을 실행하는 방법을 알아보겠습니다. from openpyxl import load_workbook # 엑셀 파일 불러오기 wb = load_workbook(filename='월별 구매 고객 리스트. xlsx', data_only=True) # 처리할 월별 시트를 목록을 리스트 형태로 저장 months = ['10월', '11월', '12월'] # 각 월별로 반복 for month in months: ws = wb[month] # 해당 월의 시트 불러오기 new_rows = list(ws.rows)[2:] # 첫 번째와 두 번째 행을 제외하고 나머지 행을 리스트로 변환 # F 열(인덱스 5)이 '신규'인 데이터만 추출 for row in new_rows: if row[5].value == '신규': row_values = [cell.value for cell in row] print(row_values) #출력값 [datetime.datetime(2023, 10, 16, 0, 0), 'B 제품', 1, '이 남연', '다 알 아연 구소', '신규', 18000, 18000] [datetime.datetime(2023, 10, 22, 0, 0), 'B 제품', 1, '최연화', '일일 컴퍼니', '신규', 18000, 18000] [datetime.datetime(2023, 10, 29, 0, 0), 'C 제품', 4, '황수지', '소속 없음', '신규', 36000, 144000] [datetime.datetime(2023, 11, 16, 0, 0), 'C 제품', 1, '윤서원', '㈜서원', '신규', 36000, 36000] [datetime.datetime(2023, 11, 28, 0, 0), 'A 제품', 1, '윤서우', '주식회사 라이언', '신규', 20000, 20000] [datetime.datetime(2023, 11, 30, 0, 0), 'A 제품', 2, '이도준', '아름 대학교', '신규', 20000, 40000] [datetime.datetime(2023, 12, 17, 0, 0), 'C 제품', 1, '최민은', '아자코퍼레이션', '신규', 36000, 36000] [datetime.datetime(2023, 12, 22, 0, 0), 'B 제품', 1, '박서은', '상상 대학교', '신규', 18000, 18000] [datetime.datetime(2023, 12, 27, 0, 0), 'A 제품', 4, '임지은', '주식회사 지은', '신규', 20000, 80000] 모든 시트의<NAME>이 동일하므로 실행할 시트의 목록을 리스트형으로 저장한 다음 for 문으로 해당 시트들을 모두 돌며 코드를 실행시킵니다. 만약<NAME>이 다르다면 코드를 각각 다르게 써야 하기 때문에 이런 경우에는<NAME>을 먼저 동일하게 수정하는 전처리를 해주는 것이 편리합니다. 그러면 마지막으로 이렇게 추출한 데이터를 제품별로 나눠서 각각의 시트로 저장해 보겠습니다. 제품별로 어떤 시트에 데이터가 저장되어 있는지 직관적으로 알 수 있도록 시트 이름은 각각의 제품명으로 저장하겠습니다. from openpyxl import load_workbook from openpyxl import Workbook # 원본 엑셀 파일 불러오기 wb = load_workbook(filename='월별 구매 고객 리스트. xlsx', data_only=True) # 새로운 엑셀 파일 생성 new_wb = Workbook() new_ws = new_wb.active # 처리할 월별 시트를 목록을 리스트 형태로 저장 months = ['10월', '11월', '12월'] # 각 월별로 반복 for month in months: ws = wb[month] index_row = [cell.value for cell in list(ws.rows)[1]] # 원본 파일의 두 번째 행(인덱스) new_rows = list(ws.rows)[2:] # 첫 번째와 두 번째 행을 제외하고 나머지 행을 리스트로 변환 # 데이터 분류 및 저장 for row in new_rows: if row[5].value == '신규': # F 열(인덱스 5)이 '신규'인 경우 product = row[1].value # B 열(인덱스 1)의 제품 이름 # 해당 제품 시트가 없으면 새로 생성 if product not in new_wb.sheetnames: new_wb.create_sheet(title=product) product_ws = new_wb[product] product_ws.append(index_row) # 인덱스 행을 새 시트의 첫 번째 행에 추가 # 해당 시트를 선택 product_ws = new_wb[product] # 데이터 추가 product_ws.append([cell.value for cell in row]) # 임시로 만든 시트 삭제 del new_wb['Sheet'] # 새로운 엑셀 파일 저장 new_wb.save(filename='제품별 신규 고객 리스트. xlsx') # 저장된 엑셀 파일 실행 화면('제품별 신규 고객 리스트. xlsx') 위의 코드를 하나씩 다시 한번 살펴보겠습니다. new_wb = Workbook() new_ws = new_wb.active 먼저 추출한 데이터를 새 파일로 저장하기 위해 새로운 엑셀 워크북을 생성합니다. 여기서 기억해야 할 점은 워크시트의 이름을 별도로 지정하지 않으면 처음 생성된 워크시트의 시트명은 'Sheet'입니다. # 처리할 월별 시트를 목록을 리스트 형태로 저장 months = ['10월', '11월', '12월'] # 각 월별로 반복 for month in months: ws = wb[month] index_row = [cell.value for cell in list(ws.rows)[1]] # 원본 파일의 두 번째 행(인덱스) new_rows = list(ws.rows)[2:] # 첫 번째와 두 번째 행을 제외하고 나머지 행을 리스트로 변환 위에서 해본 것처럼 시트 목록을 리스트 형태로 저장한 후 for 문으로 모든 시트를 돌며 동일한 작업을 실행해 줍니다. 여기서 위의 코드와 다르게 추가된 부분은 index_row = [cell.value for cell in list(ws.rows)[1]]입니다. 원본 데이터 '월별 구매 고객 리스트. xlsx'에서 데이터를 추출할 때 인덱스 부분을 제외하고 정보가 저장되어 있는 세 번째 행부터 데이터를 가지고 오게 한 것을 기억할 것입니다. 그대로 새로운 파일에 저장하면 그 파일에는 인덱스 정보가 없어 그 데이터가 각각 어떤 정보를 의미하는지 알 수 없게 됩니다. 따라서 인덱스를 다시 넣어주기 위해 원본 파일의 두 번째 행을 가져와서 'index_row'라는 변수로 저장해 줍니다. 그러면 데이터를 가져올 때 그냥 두 번째 행부터 가져오면 되지 않을까 생각할 수도 있지만, 그럴 경우 데이터에 신규 고객이라는 조건을 걸어 추출할 때 다시 인덱스 행이 제외되기 때문에 별도의 변수로 저장합니다. # 데이터 분류 및 저장 for row in new_rows: if row[5].value == '신규': # F 열(인덱스 5)이 '신규'인 경우 이제 모든 시트에서 행마다 돌면서 코드를 수행하는 데, if 문으로 먼저 F 열을 기준으로 '신규'인 고객에 해당할 경우 아래의 작업을 실행합니다. product = row[1].value # B 열(인덱스 1)의 제품 이름 # 해당 제품 시트가 없으면 새로 생성 if product not in new_wb.sheetnames: new_wb.create_sheet(title=product) '신규'인 고객에 해당하는 행에서 B 열(인덱스 1)에 있는 제품 이름을 가지고 와서 'product'라는 변수로 저장합니다. 동일한 제품 이름에 해당하는 시트로 데이터를 보내주기 위해, 파일의 전체 시트 목록에서 제품명과 동일한 시트명이 없는 경우 시트를 먼저 생성하도록 명령합니다. product_ws = new_wb[product] product_ws.append(index_row) # 인덱스 행을 새 시트의 첫 번째 행에 추가 그리고 제품명과 동일한 이름으로 생성된 시트의 첫 행에 인덱스행을 추가해 줍니다. # 해당 시트를 선택 product_ws = new_wb[product] # 데이터 추가 product_ws.append([cell.value for cell in row]) 시트를 생성하는 if 문이 종료된 후, 다시 제품명과 동일한 이름의 시트를 선택하여 그 행의 데이터를 시트에 추가합니다. 앞에서 리스트로 저장해놓은 모든 시트의 모든 행을 돌면서 위의 작업을 실행하여 데이터를 각 시트로 저장합니다. # 임시로 만든 시트 삭제 del new_wb['Sheet'] # 새로운 엑셀 파일 저장 new_wb.save(filename='제품별 신규 고객 리스트. xlsx') 그대로 파일에 저장해도 데이터는 이미 다 옮겨져있지만, 처음 엑셀 파일을 생성할 때 생성된 기본 활성 시트 "Sheet"도 엑셀 파일에 빈 시트로 남아있게 됩니다. 따라서 조금 더 깔끔한 업무 처리를 위해 "Sheet"를 시트를 삭제한 후 파일로 저장합니다. 04-05. 실전! 일자별 팩스 내역 여러 개를 하나의 파일로 합치기 동일한<NAME>의 엑셀 파일 여러 개를 하나의 파일로 합치기 이번에는 동일한<NAME>의 엑셀 파일이 여러 개인 경우 하나의 파일로 합치는 방법을 알아보겠습니다. 예를 들어, A 회사에 전자 팩스가 수신될 때마다 요약된 정보가 각각 엑셀 파일로 하나씩 생성된다고 가정해 보겠습니다. 파일명이 수신된 일자와 시간으로 저장된다고 해도 특정 시간대에 여러 개의 팩스가 한 번에 올 경우, 특정한 어떤 팩스의 발신번호를 찾기 위해서는 그 시간대의 모든 파일을 하나씩 열어봐야 하는 번거로움을 감수해야 합니다. 이러한 파일을 일단 위나 주 단위로, 혹은 월단위로 하나의 파일로 묶어서 저장한다면, 굳이 하나씩 열어보지 않아도 하나의 파일에서 원하는 내용을 볼 수 있을 것입니다. 위의 예시처럼 10월에 생성된 30개의 팩스 요약 파일을 하나의 파일로 모두 합쳐서 저장하는 코드를 알아보겠습니다. 각각의 파일은 "YYYY-MM-DD hhmm.xlsx"의<NAME>으로 팩스 수신 일시가 파일명으로 저장되어 있습니다. 그리고 파일이 저장된 위치에는 팩스 파일만이 아니라 다른 엑셀 파일들도 저장되어 있는 경우를 가정해 보겠습니다. 앞서 '3-11 윈도 폴더 및 파일 다루기'에서 배운 listdir 함수를 활용해 전체 파일 목록을 가져와서 팩스 파일명 규칙에 해당하는 파일만 추출한다면 파일을 골라낼 수 있을 것입니다. 실제 코드로 살펴보겠습니다. from openpyxl import Workbook, load_workbook import os import re # 새로운 엑셀 파일 생성 new_wb = Workbook() new_ws = new_wb.active new_ws.title = "수신 내역" # 헤더 행 추가 new_ws.append(['수신 시간', '발신번호', '페이지 수', '용량']) # 파일 명에 맞는 정규 표현식 패턴 pattern = re.compile(r'\d{4}-\d{2}-\d{2} \d{4}\.xlsx') # 현재 디렉터리의 모든 파일을 순회 for filename in os.listdir('.'): if pattern.match(filename): # 엑셀 파일 불러오기 wb = load_workbook(filename) ws = wb.active # 첫 번째 행 (헤더)은 제외하고 데이터를 새로운 엑셀 파일에 추가 for row in ws.iter_rows(min_row=2, values_only=True): new_ws.append(row) # 새로운 엑셀 파일 저장 new_wb.save('10월 팩스 수신 내역. xlsx') # 저장된 엑셀 파일 실행 화면('10월 팩스 수신 내역. xlsx') 코드를 실행하니 각 파일에 저장되어 있던 내용을 가져와서 하나의 파일로 생성이 완료되었습니다. 코드를 자세히 살펴보겠습니다. from openpyxl import Workbook, load_workbook import os import re 엑셀 데이터 작업을 위해 openpyxl을 import 합니다. 그리고 이번에는 폴더에 있는 파일명을 가지고 오는 작업과 정규식을 활용해 파일명의<NAME>을 구분해서 추출하는 작업도 실행하기 위해 os 라이브러리와 re 라이브러리도 함께 불러옵니다. # 새로운 엑셀 파일 생성 new_wb = Workbook() new_ws = new_wb.active new_ws.title = "수신 내역" # 헤더 행 추가 new_ws.append(['수신 시간', '발신번호', '페이지 수', '용량']) 새로 저장할 엑셀 파일(new_wb)을 생성하여 시트(new_ws) 제목을 "수신 내역"으로 저장합니다. 새로 저장될 파일에서도 각 열별로 어떤 데이터인지 알 수 있도록 시트 첫 줄에 append()로 헤더 행을 추가해 줍니다. # 파일 명에 맞는 정규 표현식 패턴 pattern = re.compile(r'\d{4}-\d{2}-\d{2} \d{4}\.xlsx') 앞에서 학습했던 정규 표현식을 활용하여 추출할 파일명 패턴을 컴파일합니다. 여기서 입력한 패턴은 '숫자 4자리(YYYY)-숫자 2자리(MM)-숫자 2자리(DD) '공백 한 칸' 숫자 4자리(hhmm)'로 작성된 문자열을 의미합니다. # 현재 디렉터리의 모든 파일을 순회 for filename in os.listdir('.'): if pattern.match(filename): # 엑셀 파일 불러오기 wb = load_workbook(filename) ws = wb.active os.listdir()로 현재 파이썬 실행 위치('.')에 있는 모든 파일을 순회합니다. 각각의 파일명을 가지고 온 다음 위에서 지정한 정규식 패턴과 파일명의<NAME>이 일치하는지 확인합니다. 일치할 경우에는 해당 엑셀 파일의 활성화된 시트를 불러옵니다. # 첫 번째 행 (헤더)은 제외하고 데이터를 새로운 엑셀 파일에 추가 for row in ws.iter_rows(min_row=2, values_only=True): new_ws.append(row) # 새로운 엑셀 파일 저장 new_wb.save('10월 팩스 수신 내역. xlsx') 가지고 온 시트의 두 번째 행부터 마지막 행까지 순회하면서 행 단위로 데이터를 읽어와서 append()로 new_ws 시트에 추가합니다. 전체 파일에 대한 작업이 끝나면 '10월 팩스 수신 내역. xlsx'으로 저장합니다. 이와 같이 앞서 배운 정규식을 활용해 파일명이 특정 문자열<NAME>에 해당하는 파일들만 추출하여 하나의 엑셀 파일로 만들 수 있습니다. 05. 워드(Word) 파일 다루기 회사의 공식 문서나 보고서, 계약서 등과 같이 비즈니스에서 특정한 양식으로 작성되는 여러 문서들은 워드(Word) 파일로 작성하는 경우가 많습니다. 워드는 사용자 친화적인 인터페이스와 다양한 기능들 덕분에 비즈니스에서 없어서는 안 될 필수 도구로 자리 잡았습니다. 그러나 이러한 편리함에도 불구하고, 반복적이고 단순한 작업이 많이 요구되면 시간 소모가 많아지고 작업 중 실수할 가능성도 높아집니다. 파이썬을 활용하여 워드 파일을 작성하면 이러한 단점을 보완할 수 있습니다. 코드를 사용하여 문서를 생성하기 때문에 데이터의 정확도를 높이고 작업 시간도 줄일 수 있습니다. 반복적인 워드 업무는 자동화하여 업무 프로세스를 간소화할 수도 있습니다. 워드 파일을 다룰 때 주로 사용하게 될 라이브러리는 python-docx입니다. python-docx 라이브러리로 문서를 자동으로 생성하고, 수정하고, 특정 양식을 적용하는 등의 작업을 수행할 수 있습니다. 이번 챕터에서는 python-docx 라이브러리의 기본적인 사용 방법을 소개하고, 워드 파일을 읽고 쓰는 방법, 텍스트 스타일을 적용하는 방법 등을 배울 예정입니다. 더 나아가, 라이브러리의 고급 기능을 활용하여 복잡한 워드 문서도 쉽게 작성할 수 있는 방법을 알아보겠습니다. 05-01. 워드 파일 생성 및 데이터 입력 워드 파일 다루기에 사용할 python-docx 라이브러리를 먼저 설치하겠습니다. pip install python-docx 워드 문서 생성하기 from docx import Document # 새로운 워드 문서 생성 doc = Document() # 워드 문서 읽어오기 doc = Document('회의록. docx') # 파일 저장 doc.save('example.docx') 설치한 docx 모듈을 import 한 다음, Document 클래스의 인스턴스를 생성하여 새로운 워드 문서를 생성합니다. 새로 파일을 생성하지 않고 기존 파일을 읽어올 때도 동일하게 Document 클래스를 사용하는데, 불러올 파일 경로를 인자로 전달해 주면 됩니다. 작업이 완료되면, save 메서드를 사용하여 문서를 저장합니다. 이때, 새로운 이름을 지정하여 새 파일로 저장할 수도 있고, 기존 파일 이름을 사용하여 덮어쓸 수도 있습니다. 텍스트 추가하기 제목 추가하기 from docx import Document from docx.enum.text import WD_ALIGN_PARAGRAPH # 워드 문서 생성 doc = Document() # 제목 추가 title = doc.add_heading('제목을 이곳에 작성합니다', level=0) title.alignment = WD_ALIGN_PARAGRAPH.CENTER doc.save('example.docx') # 저장된 워드 파일 실행 화면('example.docx') 생성한 워드 문서에 제목을 추가해 보겠습니다. 제목을 추가할 때는 add_heading 메서드를 사용하며, 작성할 제목의 내용과 제목의 레벨(level)을 설정합니다. 레벨(level) 매개변수는 0부터 9까지의 숫자를 전달받습니다. 이 숫자에 따라 제목의 글자 크기와 형태, 즉 제목의 스타일이 결정됩니다. 여기서는 레벨 0으로 제목 스타일을 설정했습니다. 그리고 이렇게 워드에 추가한 제목은 왼쪽으로 정렬된 상태이기 때문에 가운데 정렬(title.alignment = WD_ALIGN_PARAGRAPH.CENTER)을 적용하였습니다. 아래는 Level0부터 Level10까지 레벨 매개변수를 각각 적용한 제목 스타일이며 단순히 글자가 작아지기만 하는 것이 아니라 색깔이나 밑줄, 기울임 등 스타일이 각각 다르게 적용됩니다. 텍스트 추가하기 다음은 단락을 추가하여 텍스트를 작성해 보겠습니다. from docx import Document from docx.enum.text import WD_ALIGN_PARAGRAPH doc = Document() title = doc.add_heading('제목을 이곳에 작성합니다', level=0) title.alignment = WD_ALIGN_PARAGRAPH.CENTER # 단락 추가 p = doc.add_paragraph('첫 번째 단락입니다') doc.save('example.docx') # 저장된 워드 파일 실행 화면('example.docx') 먼저 add_paragraph 메서드로 단락을 추가하면서 단락에 입력할 내용도 함께 전달합니다. 단락에 텍스트를 추가할 때는 add_run 메서드를 사용할 수도 있습니다. 위의 코드에 p.add_run('입력할 내용')을 추가한다면 '입력할 내용'이 p 단락에 추가됩니다. 단락 끼워 넣기 단락을 추가할 때 문서의 제일 아래에 위치하는 것이 아니라 특정 단락 앞에 끼워 넣어야 할 경우에는 insert_paragraph_before 메서드를 사용합니다. 다음은 insert_paragraph_before 메서드를 사용한 코드의 예시입니다. from docx import Document from docx.enum.text import WD_ALIGN_PARAGRAPH doc = Document() title = doc.add_heading('제목을 이곳에 작성합니다', level=0) title.alignment = WD_ALIGN_PARAGRAPH.CENTER p = doc.add_paragraph('첫 번째 단락입니다') # 두 번째, 세 번째 단락을 추가 p2 = doc.add_paragraph('이것은 두 번째 단락입니다.') p3 = doc.add_paragraph('이것은 세 번째 단락입니다.') # 첫 번째 단락 앞에 새 단락 끼워 넣기 p.insert_paragraph_before('이것은 첫 번째 단락 앞에 새로 끼워 넣은 단락입니다.') doc.save('example.docx') # 저장된 워드 파일 실행 화면('example.docx') 추가된 두 번째 단락(p2)과 세 번째 단락(p3)을 보면 기존에 작성되어 있던 첫 번째 단락 아래에 단락들이 추가되어 있습니다. 즉, add_paragraph로 단락을 여러 개 추가하면 문서의 제일 끝에 이어서 단락을 추가한다는 것을 알 수 있습니다. 이와 달리 insert_paragraph_before 메서드를 사용하면 문서의 끝부분이 아닌 기존 단락의 앞부분에 새로운 단락을 추가해 줍니다. 여기서는 제일 첫 단락 앞에 새로운 단락을 추가해 주었습니다. 기존에 작성된 문서에 단락을 추가해야 할 경우 이 메서드를 이용하여 손쉽게 수정할 수 있습니다. 단락 수정하기 이번에는 이미 작성되어 있는 단락의 내용을 수정해 보겠습니다. from docx import Document from docx.enum.text import WD_ALIGN_PARAGRAPH doc = Document() title = doc.add_heading('제목을 이곳에 작성합니다', level=0) title.alignment = WD_ALIGN_PARAGRAPH.CENTER p = doc.add_paragraph('첫 번째 단락입니다') p2 = doc.add_paragraph('이것은 두 번째 단락입니다.') p3 = doc.add_paragraph('이것은 세 번째 단락입니다.') p.insert_paragraph_before('이것은 첫 번째 단락 앞에 새로 끼워 넣은 단락입니다.') # 두 번째 단락 텍스트 변경 p2.clear() p2.add_run('두 번째 단락의 텍스트가 변경되었습니다.') doc.save('example.docx') # 저장된 워드 파일 실행 화면('example.docx') 기존에 작성되어 있던 두 번째 단락(p2)의 텍스트를 변경하기 위해 먼저 p2 단락의 내용을 clear 메서드로 삭제합니다. 그 후, add_run으로 변경할 텍스트를 다시 입력합니다. 표와 리스트, 이미지 추가하기 표 추가하기 add_table 메서드를 사용하여 워드 문서에 표를 추가할 수 있습니다. 이 메서드를 통해 행과 열을 지정하고, 셀에 텍스트를 추가할 수 있습니다. from docx import Document doc = Document() p = doc.add_paragraph('첫 번째 단락입니다') # 3x3 크기의 표 추가 table = doc.add_table(rows=3, cols=3) table.style = 'Table Grid' # 표의 각 셀에 격자 선 추가 # 첫 번째 행의 셀들을 hdr_cells 변수에 할당하고 각 셀에 헤더 데이터 추가 hdr_cells = table.rows[0].cells hdr_cells[0].text = '헤더 1' hdr_cells[1].text = '헤더 2' hdr_cells[2].text = '헤더 3' # for 문으로 각 행의 셀에 접근하여 두 번째와 세 번째 행에 데이터 추가 for i in range(1, 3): row_cells = table.rows[i].cells row_cells[0].text = f'행 {i}, 열 1' row_cells[1].text = f'행 {i}, 열 2' row_cells[2].text = f'행 {i}, 열 3' doc.save('example.docx') # 저장된 워드 파일 실행 화면('example.docx') 위의 예제 코드에서 표를 추가한 부분을 자세히 살펴보겠습니다. # 3x3 크기의 표 추가 table = doc.add_table(rows=3, cols=3) table.style = 'Table Grid' # 표의 각 셀에 격자 선 추가 먼저 add_table 메서드로 표를 생성합니다. 표의 크기는 rows와 cols에 행과 열의 개수를 각각 입력하여 결정합니다. 여기서는 3x3 크기의 표를 만들기 위해 rows와 cols에 동일하게 3을 넣어주었습니다. 그리고 표의 전체 셀에 격자선을 추가하기 위해 table.style = 'Table Grid'로 표 스타일을 설정합니다. 격자 선 외에도 python-docx 라이브러리에서 미리 정의된 여러 표 스타일이 있습니다. 이외의 표 스타일에 대해 더 알아보기 원한다면 python-docx 공식 문서의 'Table' 섹션을 참고하기 바랍니다. python-docx 공식 문서(Table 섹션) : https://python-docx.readthedocs.io/en/latest/api/table.html # 첫 번째 행의 셀들을 hdr_cells 변수에 할당하고 각 셀에 헤더 데이터 추가 hdr_cells = table.rows[0].cells hdr_cells[0].text = '헤더 1' hdr_cells[1].text = '헤더 2' hdr_cells[2].text = '헤더 3' 표에 헤더(열 이름)을 추가해 주기 위해 첫 번째 행의 셀들을 hdr_cells 변수에 할당합니다. 그리고 각 셀에 차례대로 접근하여 헤더 값을 입력합니다. # for 문으로 각 행의 셀에 접근하여 두 번째와 세 번째 행에 데이터 추가 for i in range(1, 3): row_cells = table.rows[i].cells row_cells[0].text = f'행 {i}, 열 1' row_cells[1].text = f'행 {i}, 열 2' row_cells[2].text = f'행 {i}, 열 3' 헤더를 제외한 표의 나머지 셀에 데이터를 입력해 줍니다. 여기서는 각 셀에 해당하는 행 번호와 열 번호를 입력해 주기 위해 for 문과 포메이팅을 사용해 데이터를 입력했습니다. 리스트 추가하기 이번에는 워드 문서에 리스트를 추가해 보겠습니다. from docx import Document doc = Document() p = doc.add_paragraph('첫 번째 단락입니다') # 리스트 추가 doc.add_paragraph( '첫 번째 항목', style='List Number' ) doc.add_paragraph( '두 번째 항목', style='List Number' ) doc.save('example.docx') # 저장된 워드 파일 실행 화면('example.docx') 번호가 매겨진 리스트를 작성하기 위해 add_paragraph으로 항목을 추가합니다. 이때 style을 'List Number'로 지정하여 번호가 매겨진 리스트 스타일을 적용합니다. from docx import Document from docx.shared import Inches doc = Document() p = doc.add_paragraph('첫 번째 단락입니다\n') # 이미지 추가 p.add_run().add_picture('C:\Users\그림 폴더\그림 1.png', width=Inches(1.5)) doc.save('example.docx') # 저장된 워드 파일 실행 화면('example.docx') add_picture 메서드를 호출하여 이미지를 추가합니다. 추가할 이미지 파일의 경로를 전달해 주고, 해당 이미지를 너비와 높이를 지정해 줍니다. 여기서는 Inches(1.5)로 이미지의 너비를 1.5 인치로 설정하였으며, 높이 값은 넣지 않음으로써 높이는 비율에 따라 자동으로 설정하도록 만들었습니다. 만약 너비와 높이 둘 다 인수를 지정하지 않으면 원본 이미지의 크기로 이미지가 삽입됩니다. 그럴 경우 이미지의 크기에 따라 문서 내에서 이미지가 너무 크거나 너무 작게 표시될 수 있으니 이 점을 유의해야 합니다. 위의 코드에서는 add_run과 add_picture 메서드를 같이 사용하였지만, add_picture만 단독으로 사용하여도 이미지를 입력할 수 있습니다. add_run과 같이 사용할 때와 add_picture만 단독으로 사용할 때의 차이점은 이미지 삽입 위치가 달라진다는 것입니다. 만약 위의 코드에서 add_picture만 단독으로 사용한다면, 첫 번째 단락의 뒤에 이미지가 삽입됩니다. add_run과 add_picture를 같이 사용하면 단락 안에 텍스트처럼 이미지를 추가할 수 있습니다. 위의 코드로 생성된 파일을 얼핏 보면 첫 번째 단락 뒤에 생성된 것 같지만, 단락에 텍스트를 입력할 때 개행문자('\n')를 넣어주어 단락 안에서 줄바꿈을 실행하고 이미지가 입력된 것입니다. 개행문자를 삭제하고 코드를 실행하면, 텍스트 옆에 이미지가 삽입되는 것을 확인할 수 있을 것입니다. 05-02. 워드 파일 서식 설정하기 이번에는 앞에서 학습한 워드 파일의 데이터 입력 코드에 서식을 설정하는 내용을 추가해 보겠습니다. 텍스트 서식 설정하기 워드 파일을 생성한 후 단락을 추가하여 텍스트를 작성하고 텍스트에 서식까지 지정해 보겠습니다. from docx import Document from docx.shared import Pt, RGBColor #글자 크기와 글자색 서식 지정을 위해 docx.shared를 import from docx.oxml.ns import qn # 한글 글꼴 설정을 위해 docx.oxml.ns를 import doc = Document() para = doc.add_paragraph() run = para.add_run('텍스트에 서식을 설정합니다.') # 글자 서식 지정(굵게, 기울임, 밑줄) run.bold = True run.italic = True run.underline = True # 글꼴 설정 run.font.name = '맑은 고딕' run._r.rPr.rFonts.set(qn('w:eastAsia'), '맑은 고딕') #글자 크기 조정 run.font.size = Pt(12) # 글자 색상 설정 run.font.color.rgb = RGBColor(0x42, 0x24, 0xE9) doc.save('example.docx') # 저장된 워드 파일 실행 화면('example.docx') add_paragraph로 생성한 단락에 add_run으로 텍스트를 입력하여 run 객체를 생성합니다. 이 run 객체에 글자 서식을 추가하는데 먼저 굵게, 기울임, 그리고 밑줄을 설정하였습니다. 굵게, 기울임, 밑줄은 각각 bold와 italic, underline 속성을 True로 설정하여 적용합니다. 글자체를 지정할 때는 font.name을 사용하며, 사용할 글꼴의 이름을 전달해 주어야 합니다. 여기서 유의할 점은 영어 글꼴인 경우에는 font.name만으로도 바로 글자체를 적용할 수 있지만, 한글 글꼴인 경우에는 qn('w:eastAsia')를 추가로 사용하여야 합니다. 그리고 이 qn 함수를 사용하기 위해 'from docx.oxml.ns import qn'로 docx.oxml.ns를 추가로 import 해줘야 합니다. 텍스트에 특정 글꼴을 설정하기 위해서는 시스템에 해당 글꼴이 설치되어 있어야 합니다. 글자 크기 지정을 위해서 from docx.shared import Pt를 실행합니다. 입력한 텍스트의 크기는 font.size 속성을 사용하여 변경하며, 글자 크기의 단위는 워드의 기본 단위인 '포인트' 단위로 지정합니다. 글자색을 설정하기 위해 'from docx.shared import RGBColor'를 실행합니다. 여기서는 글자 크기를 지정하는 Pt 클래스도 같이 사용했기 때문에 from docx.shared import Pt, RGBColor로 한 번에 import 하였습니다. 글자색은 font.color.rgb 속성을 통해 설정하며, 이때 RGB(Red, Green, Blue) 값으로 색상을 지정합니다. RGB 값을 지정할 때는 16진수(예: 0x42) 또는 10진수(예: 66)로 각 색상의 강도를 표현할 수 있습니다. 여기서는 16진수로 RGB 값을 전달하여 RGBColor(0x42, 0x24, 0xE9) 진한 파란색을 설정하였습니다. 단락 서식 설정하기 from docx import Document from docx.shared import Pt from docx.enum.text import WD_ALIGN_PARAGRAPH doc = Document() para1 = doc.add_paragraph('첫 번째 단락입니다.\n 첫 번째 단락의 두 번째 줄입니다.') para2 = doc.add_paragraph('두 번째 단락입니다.\n 두 번째 단락의 두 번째 줄입니다.') #단락의 텍스트를 중앙으로 정렬 para2.alignment = WD_ALIGN_PARAGRAPH.CENTER # 단락 1의 줄 간격을 12포인트로 설정합니다. para1.paragraph_format.line_spacing = Pt(12) # 줄 간격 설정 # 단락 2의 줄 간격을 20포인트로 설정합니다. para2.paragraph_format.line_spacing = Pt(20) # 줄 간격 설정 # '볼드체'라는 텍스트를 단락에 추가하고, 이 텍스트를 볼드체로 설정합니다. para2.add_run('볼드체').bold = True # ' 및 이탤릭 체'라는 텍스트를 단락에 추가하고, 이 텍스트를 이탤릭 체로 설정합니다. para2.add_run(' 및 이탤릭 체').italic = True doc.save('example.docx') # 저장된 워드 파일 실행 화면('example.docx') 위의 코드에서는 단락의 서식을 설정해 보았습니다. 단락의 텍스트 정렬을 변경하기 위해 'from docx.enum.text import WD_ALIGN_PARAGRAPH'를 실행합니다. 여기서는 단락 2의 텍스트를 가운데로 정렬하기 위해 alignment 속성을 중앙(WD_ALIGN_PARAGRAPH.CENTER)으로 설정하였습니다. 이외에 왼쪽으로 정렬하고자 할 때는 WD_ALIGN_PARAGRAPH.LEFT로, 오른쪽으로 정렬하고자 할 때는 WD_ALIGN_PARAGRAPH.RIGHT로 설정 가능하며, 단락 1과 같이 정렬을 따로 설정하지 않으면 왼쪽 정렬로 적용됩니다. 다음으로 paragraph_format.line_spacing으로 단락 내의 텍스트 라인 사이의 간격을 조절합니다. 간격을 비교하기 위해 단락 1의 줄 간격을 12포인트로, 단락 2는 20포인트로 설정했습니다. 워드 파일 실행 화면을 보면 단락 1과 단락 2에서의 라인 간격이 다른 것을 확인할 수 있습니다. 그리고 단락 전체의 텍스트 서식을 변경하지 않고 일부 텍스트만 서식을 설정할 수도 있습니다. 'para2.add_run('볼드체').bold = True'으로 단락 2에 '볼드체'라는 텍스트를 입력할 때 bold 속성을 True로 설정하여, 입력된 텍스트에만 글자 서식을 굵게 설정하였습니다. 머리글과 꼬리 글 입력하기 이번에는 문서에 머리글과 꼬리 글을 추가해 보겠습니다. header와 footer 객체를 사용하여 머리글과 꼬리 글에 각각 접근할 수 있습니다. from docx import Document doc = Document() para1 = doc.add_paragraph('첫 번째 단락입니다.') # 머리글 추가 # 문서의 첫 번째 섹션을 지정한 후 header(머리글)를 가져와 'header' 변수에 할당 section = doc.sections[0] header = section.header # 머리글의 첫 번째 단락을 가져와 'p' 변수에 할당 후 텍스트 설정 p = header.paragraphs[0] p.text = "머리글을 추가합니다." # 꼬리 글 추가 # footer(꼬리 글)를 가져와 'footer' 변수에 할당 footer = section.footer # 꼬리의 첫 번째 단락을 가져와 'p2' 변수에 할당 후 텍스트 설정 p2 = footer.paragraphs[0] p2.text = "꼬리 글을 추가합니다." doc.save('example.docx') # 저장된 워드 파일 실행 화면('example.docx') (가운데 빈 영역 생략) 머리글과 꼬리 글을 설정하기 위해 먼저 'doc.sections[0]를 통해 문서의 첫 번째 섹션에 접근합니다. 워드 문서는 여러 섹션으로 구성될 수 있고, 각 섹션은 별도의 머리글과 꼬리 글을 가질 수 있습니다. 섹션은 문서의 하위 단위로 페이지와는 다른 개념입니다. 섹션 별로 각기 다른 서식이나 레이아웃, 머리글/꼬리 글 등을 독립적으로 가집니다. 보통 대부분의 워드 문서는 하나의 섹션을 포함하기 때문에 일반적으로는 sections[0]으로 첫 번째 섹션만 선택하여 문서 전체의 머리글/꼬리 글을 설정합니다. 섹션이 여러 개일 경우 섹션 번호를 각각 선택하여 머리글과 꼬리 글을 설정합니다. 머리글을 설정하려면, 첫 번째 섹션의 머리글 객체를 가져와서 section.header로 접근합니다. 이 객체의 paragraphs[0] 메서드를 사용하여 첫 번째 단락에 접근한 다음, text 속성을 사용하여 텍스트를 설정합니다. 만약 기존에 입력되어 있던 텍스트가 있을 경우, text 속성을 사용하면 기존에 있던 텍스트는 삭제되고 새로운 텍스트가 설정됩니다. 꼬리 글을 설정하는 방법은 머리글을 설정하는 방법과 동일하며 머리글 객체(header) 대신 꼬리 글 객체(footer)를 사용합니다. 이러한 방식으로 문서의 각 페이지에 반복되는 텍스트나 이미지 등을 삽입할 수 있으며, 특히 회사 로고, 문서 제목, 작성자 정보, 페이지 번호 등을 표시하는 데 유용합니다. 05-03. 워드 파일 읽기 이번에는 파이썬으로 워드 파일을 읽어오는 방법을 학습해 보겠습니다. 단락 읽기 from docx import Document # 워드 파일 열기 doc = Document('example.docx') # 단락 읽기 for para in doc.paragraphs: print(para.text) python-docx 라이브러리의 Document 클래스에 불러올 파일의 경로를 전달하여 파일을 열어줍니다. 그리고 doc.paragraphs로 모든 단락에 접근하여 for 문으로 각 단락의 내용을 출력해옵니다. 단락과 텍스트의 서식 확인 워드 문서의 단락의 정렬이나 단락 내 텍스트에 서식이 설정되어 있는 경우 설정된 서식을 확인할 수 있습니다. from docx import Document from docx.enum.text import WD_ALIGN_PARAGRAPH # 문서를 열어서 객체로 가져옵니다. doc = Document('example.docx') # 각 단락의 서식을 확인합니다. for index, paragraph in enumerate(doc.paragraphs): print(f"단락 번호 {index}:") print(f" 정렬: {paragraph.alignment}") # 각 단락 내에서 개별 텍스트 런의 서식을 확인합니다. for run in paragraph.runs: print(f" 텍스트 내용: {run.text}") print(f" 굵게: {run.bold}") print(f" 기울임: {run.italic}") print(f" 밑줄: {run.underline}") print(f" 글꼴: {run.font.name}") print(f" 글자 크기: {run.font.size}") print(f" 글자색: {run.font.color.rgb}") print('-' * 20) # 단락 간 구분선 # 결괏값 단락 번호 0: 정렬: None 텍스트 내용: 첫 번째 단락의 텍스트에 서식을 설정합니다. 굵게: True 기울임: True 밑줄: True 글꼴: 맑은 고딕 글자 크기: 152400 글자색: 4224E9 -------------------- 단락 번호 1: 정렬: CENTER (1) 텍스트 내용: 두 번째 단락입니다. 두 번째 단락의 두 번째 줄입니다. 굵게: None 기울임: None 밑줄: None 글꼴: None 글자 크기: None 글자색: None -------------------- 모든 단락과 각 단락 내 모든 텍스트에 대한 서식을 확인하기 위해 각 단락과 텍스트를 순회하도록 for 문을 사용하여 서식을 확인합니다. 그리고 설정된 서식을 우리도 알 수 있도록 각 서식을 출력하도록 코드를 작성합니다. 서식을 확인할 때는 기본적으로 서식을 설정했던 코드로 확인한다고 이해하면 됩니다. 위의 코드를 자세히 살펴보겠습니다. # 각 단락의 서식을 확인합니다. for index, paragraph in enumerate(doc.paragraphs): print(f"단락 번호 {index}:") print(f" 정렬: {paragraph.alignment}") 먼저 각 단락에 접근하여 index로 몇 번째 단락인지 단락의 번호를 확인하고, paragraph.alignment로 단락의 정렬 서식을 확인합니다. 이때 정렬을 설정할 때와 마찬가지로 'from docx.enum.text import WD_ALIGN_PARAGRAPH'를 먼저 실행해 주어야 합니다. 위의 코드에서 첫 번째 단락의 paragraph.alignment의 출력값을 확인하면 'None'이라고 출력되어 있는 것을 알 수 있습니다. 즉, 서식을 별도로 설정하지 않았을 경우에는 'None'이 출력됩니다. 두 번째 단락에서는 정렬 서식으로 'CENTER (1)'이 출력되었으며, 이는 중앙 정렬이 설정되어 있다는 의미입니다. 오른쪽 정렬일 경우에는 'RIGHT (2)'가 반환됩니다. # 각 단락 내에서 개별 텍스트 런의 서식을 확인합니다. for run in paragraph.runs: print(f" 텍스트 내용: {run.text}") print(f" 굵게: {run.bold}") print(f" 기울임: {run.italic}") print(f" 밑줄: {run.underline}") print(f" 글꼴: {run.font.name}") print(f" 글자 크기: {run.font.size.pt if run.font.size else None}") print(f" 글자색: {run.font.color.rgb}") print('-' * 20) # 단락 간 구분선 python-docx 라이브러리를 사용하여 문서의 텍스트 서식을 분석할 때, 각 런(run)의 특정 서식 속성들을 개별적으로 확인할 수 있습니다. 여기서 '런'이란, 하나의 단락 내에서 서로 다른 서식을 가진 텍스트 구간을 의미합니다. 각 단락 내의 런들을 순회함으로써 런에 적용된 서식을 확인할 수 있습니다. 여기서 글자 크기를 확인하는 코드에만 if 문이 들어가 있는데 글자 크기를 원래 워드 기본 글자 단위인 포인트로 반환할 때 에러를 방지하기 위해 if 문을 사용하였습니다. python-docx 라이브러리에서 글자 크기는 'Pt' 객체로 반환되며, 이 'Pt' 객체의 'pt' 속성을 통해 우리는 글자 크기를 '포인트' 단위로 얻을 수 있습니다. 예를 들어, run.font.size.pt 코드는 글자 크기를 포인트 단위로 반환합니다. 단, pt 속성은 글자 크기가 설정되어 있지 않아 run.font.size 값이 'None'인 경우에는 에러가 발생합니다. 그래서 위의 코드에서는 글자 크기가 'None'이 아닌 경우에만 'pt' 속성을 사용하도록 if 문을 사용하여 조건을 설정했습니다. 표 읽기 워드 문서에서 표를 찾아 각 셀의 내용을 읽어오는 것도 가능합니다. doc.tables를 통해 문서 내의 모든 표에 접근합니다. from docx import Document doc = Document('example5.docx') # 표 읽기 for table in doc.tables: for row in table.rows: for cell in row.cells: print(cell.text) # 결괏값 헤더 1 헤더 2 헤더 3 행 1 & 열 1 행 1 & 열 2 행 1 & 열 3 행 2 & 열 1 행 2 & 열 2 행 2 & 열 3 출력된 결괏값을 보면 'example.docx' 워드 문서에 3x3 크기의 표가 생성되어 있으며, 첫 행은 '헤더 1/2/3'이, 그리고 두 번째와 세 번째 행에는 각 셀에 해당하는 행과 열이 값으로 입력되어 있는 것을 알 수 있습니다. 위의 코드에서는 table.rows를 사용하여 표의 각 행에 접근하고, row.cells를 통해 각 셀의 텍스트를 출력합니다. doc.tables는 문서 내 모든 표에 접근하기 때문에 만약 문서에 표가 여러 개 포함되어 있을 경우 모든 표의 셀 값이 차례대로 반환됩니다. 머리글과 꼬리 글 읽기 문서에 설정되어 있는 머리글과 꼬리 글을 읽어보겠습니다. 머리글과 꼬리 글을 설정할 때와 마찬가지로 섹션 별로 설정되어 있는 머리글과 꼬리 글을 읽어오기 위해 doc.sections를 사용하여 문서의 각 섹션에 대한 정보를 가져옵니다. from docx import Document doc = Document('example.docx') # 머리글 읽기 for section in doc.sections: header = section.header for paragraph in header.paragraphs: print(paragraph.text) # 꼬리 글 읽기 for section in doc.sections: footer = section.footer for paragraph in footer.paragraphs: print(paragraph.text) section.header와 section.footer를 사용하여 각 섹션의 머리글과 꼬리 글에 접근하였으며, 머리글과 꼬리 글의 단락별로 입력되어 있는 텍스트를 출력합니다. 이미지 추출하기 워드 문서에 이미지가 삽입되어 있는 경우, python-docx 라이브러리는 직접적으로 이미지를 추출하는 기능을 제공하지 않기 때문에 docx2txt 라이브러리로 가져오는 것이 편리합니다. docx2txt 라이브러리를 사용하기 위해 pip로 라이브러리를 먼저 설치합니다. pip install docx2txt 설치한 docx2txt 라이브러리로 이미지를 추출하는 예제 코드는 다음과 같습니다. import docx2txt # docx2txt를 사용하여 이미지 추출 docx2txt.process('example.docx', './추출한 이미지 폴더/') # 이미지가 저장된 폴더('추출한 이미지 폴더') 화면 docx2txt.process에 첫 번째 인자로 추출할 워드 파일을 전달하고, 두 번째 인자로 이미지를 추출한 후 저장할 폴더의 경로를 전달합니다. 만약 파이썬이 실행되는 현재 경로에 바로 저장하고자 한다면 두 번째 인자로 '.' 값을 전달합니다. docx2txt는 경로만을 전달하며, 이미지를 저장할 때 파일명을 별도로 지정하는 옵션은 제공하지 않습니다. 'image1', 'image2'와 같이 image+숫자<NAME>으로 파일 내 이미지의 순서대로 파일명이 결정됩니다. 위에서 코드를 실행 후 폴더 경로를 캡처한 이미지를 보면, 'thumbnail.jpeg'와 'image1.png'가 생성되어 있습니다. 여기서 'thumbnail.jpeg'로 추출된 이미지는 워드의 미리 보기 이미지로 사용되는 섬네일 이미지입니다. 문서 탐색기나 파일 관리 프로그램에서 보이는 작은 미리 보기 이미지도 이 동일한 섬네일 이미지입니다. 따라서 문서에 이러한 섬네일 이미지가 있을 경우에는 이 이미지도 'thumbnail.jpeg'로 함께 추출됩니다. docx2txt는 기본적으로 텍스트와 이미지를 모두 추출하는 라이브러리입니다. 그렇지만 위의 코드에서는 텍스트 데이터를 변수에 할당하지 않았습니다. 그렇기 때문에 코드 실행 시 텍스트는 콘솔에만 반환되고 실제 디스크에는 저장되지 않기 때문에 이미지만 파일로 추출할 수 있습니다. 지금까지 작성된 워드 문서를 파이썬으로 읽어오는 방법을 알아보았습니다. 파이썬으로 생성한 워드 파일이 아닌 수동으로 작성하고 서식을 설정한 워드 문서도 위에서 소개한 방법들로 대부분 읽어와서 작업이 가능합니다. 그러나 라이브러리의 한계 때문에 일부 복잡한 서식이나 매크로 등은 python-docx로 완벽하게 다루지 못할 수 있습니다. 따라서 파이썬에서 워드 파일을 읽어와서 핸들링할 때 파일이 제대로 불러와지는지는 추가로 확인하는 것이 좋습니다. 05-04. 실전! 고객 구매리스트를 활용하여 고객별 송장 파일 자동 생성하기 앞에서 학습한 코드를 활용하여 워드 템플릿을 가지고 문서를 작성해 보겠습니다. 워드 템플릿에 데이터 넣기 회사에서 제품을 구매한 고객에게 발송하는 송장 템플릿에 고객의 데이터와 구매한 제품, 단가, 합계 금액 등의 정보를 넣어보겠습니다. 아래와 같은 송장 파일이 있다고 가정합니다. '송장. docx' 먼저 파일의 어떤 위치에 어떤 정보를 넣어야 하는지 파악하기 위해 파이썬으로 송장 템플릿을 읽어와서 단락과 텍스트의 인덱스, 입력되어 있는 텍스트의 내용을 확인해 보겠습니다. from docx import Document # 워드 파일 열기 doc = Document('송장. docx') # 단락 읽기 for index, paragraph in enumerate(doc.paragraphs): print(f"단락 번호 {index}:") # 단락 인덱스 출력 # 각 단락 내에서 개별 텍스트 런의 서식을 확인합니다. for index, run in enumerate(paragraph.runs): print(f" 텍스트 번호: {index}") print(f" 텍스트 내용: {run.text}") # 표 확인하기 # 문서에 있는 모든 표를 순회 for table_index, table in enumerate(doc.tables): print(f"표 {table_index}:") #표의 인덱스 출력 # 표의 각 행을 순회 for row_index, row in enumerate(table.rows): print(f" 행 {row_index}:") # 행 번호 출력 # 행의 각 셀을 순회 for cell_index, cell in enumerate(row.cells): print(f" 셀 {cell_index}: {cell.text}") # 셀의 인덱스 출력 print('-' * 20) # 단락 간 구분선 # 결괏값 (출력값이 너무 길어 중간 생략합니다.) 단락 번호 0: 텍스트 번호: 0 텍스트 내용: 송장 단락 번호 1: 텍스트 번호: 0 텍스트 내용: 회사명 텍스트 번호: 1 텍스트 내용: : 텍스트 번호: 2 텍스트 내용: 룰루 텍스트 번호: 3 텍스트 내용: 텍스트 번호: 4 텍스트 내용: 솔루션즈 텍스트 번호: 5 텍스트 내용: (중략) 표 0: 행 0: 셀 0: 제품 셀 1: 수량 셀 2: 단가 셀 3: 합계 행 1: 셀 0: 셀 1: 셀 2: 셀 3: (중략) -------------------- python-docx 라이브러리로 문서를 다룰 때, 단락이나 각 단락의 텍스트 런의 인덱스를 가지고 데이터를 입력할 위치 정보를 전달하기 때문에 인덱스를 추출하는 코드를 실행합니다. 문서 내 모든 단락과 텍스트 런, 표에 모두 접근하여 인덱스와 내용을 출력하였으며, 위의 결괏값에는 생략하였지만, 실제 코드를 실행하여 반환된 결괏값을 보면 데이터를 입력해야 하는 고객 정보 부분은 세 번째 단락(인덱스: 2)에 해당하며 고객명, 고객 주소, 고객 연락처의 텍스트 런은 각각 2, 5, 8이라는 것을 알 수 있습니다. 표의 경우에는 행 번호나 셀 번호를 비교적 직관적으로 알기 쉽지만 위와 같이 코드를 통해서도 출력이 가능합니다. 그러면 이렇게 파악한 인덱스를 가지고 템플릿에 데이터를 넣어보겠습니다. from docx import Document # 워드 문서 불러오기 doc = Document('송장. docx') # 고객 정보를 입력해야 하는 단락 지정 target_paragraph = doc.paragraphs[2] # 각 라벨 뒤에 텍스트 추가 target_paragraph.runs[2].add_text('이호연') target_paragraph.runs[5].add_text('서울시 마포구 서교동') target_paragraph.runs[8].add_text('070-333-4444') # 구매 내역을 입력할 표 지정 table = doc.tables[0] # 표에 입력할 데이터를 'data' 변수에 리스트로 저장 data = [ ["제품 1", "2", "12,000","24,000"] ] # 헤더를 제외한 표의 두 번째 행부터 각 셀에 data를 입력 for i, row_data in enumerate(data): for j, cell_data in enumerate(row_data): table.cell(i+1, j).text = cell_data # 표의 마지막 행의 마지막 셀에 '총합계' 값을 입력 table.rows[-1].cells[-1].text = '240,000' # 문서 저장 doc.save('이호연_송장. docx') '이호연_송장. docx' 사용할 워드 템플릿 파일을 읽어온 다음, 고객 정보를 입력할 부분인 세 번째 단락(doc.paragraphs[2])을 찾아서 target_paragraph 변수에 할당합니다. 텍스트를 입력할 텍스트 런의 인덱스(target_paragraph.runs[2])를 전달하여 add_text로 내용('이호연')을 입력합니다. 고객 주소와 고객 연락처도 같은 방식으로 데이터를 입력합니다. 표에도 데이터를 입력하기 위해 doc.tables[0]으로 문서의 첫 번째 표를 찾아 table 변수에 할당합니다. 표의 경우 데이터를 행별로 입력하며, 각 셀의 위치값(행과 열의 인덱스)이 규칙적이기 때문에 for 문으로 셀의 위치를 바꿔주며 데이터를 입력합니다. 이 작업을 위해 먼저 행별로 입력할 데이터를 이중 리스트로 만들어줍니다. 이중 for 문으로 모든 행을 순회하며 각 행별로 모든 셀에 접근합니다. 그리고 이중 리스트의 원소를 하나씩 꺼내어 셀마다 데이터를 입력합니다. 송장 템플릿의 표에서 가장 마지막 행에는 구매한 전체 제품에 대한 총합계 금액을 입력하도록 되어 있습니다. 마지막행의 마지막 셀이라 'table.rows[-1].cells[-1]'로 위치를 전달하여 text로 '240,000'의 값을 입력합니다. 템플릿을 활용하여 여러 파일 한 번에 작성하기 위와 같이 파이썬으로 템플릿에 데이터를 입력할 수 있다면, 제품을 구매한 여러 고객에게 전달할 송장들을 한 번에 생성하는 것도 가능할 것입니다. '구매 고객 리스트. xlsx' 위와 같이 구매한 고객의 정보와 구매 내역이 엑셀 파일로 정리되어 있다고 가정해 보겠습니다. 파이썬으로 엑셀 파일의 내용을 가지고 와서 고객에게 보낼 각각의 송장 파일을 작성하도록 해보겠습니다. from openpyxl import load_workbook from docx import Document from docx.enum.text import WD_PARAGRAPH_ALIGNMENT # 엑셀 파일 불러오기 wb = load_workbook('구매 고객 리스트. xlsx', data_only = True) ws = wb.active # 엑셀 파일의 각 행에 대해 워드 파일 생성 for row_idx, row in enumerate(ws.iter_rows(values_only=True)): # 헤더 행은 건너뛰기 if row_idx == 0: continue # 데이터가 없는 행을 건너뛰기 if not any(row): continue # 워드 템플릿 파일 불러오기 doc = Document('송장. docx') # 고객 정보를 입력해야 하는 단락 지정 target_paragraph = doc.paragraphs[2] # 각 라벨 뒤에 텍스트 추가 target_paragraph.runs[2].add_text(str(row[0])) # 고객명 target_paragraph.runs[5].add_text(str(row[1])) # 고객 주소 target_paragraph.runs[8].add_text(str(row[2])) # 고객 연락처 # 구매 내역을 입력할 표 지정 table = doc.tables[0] # 표에 입력할 데이터 설정 data = [ [str(row[3]), int(row[4]), f"{int(row[5]) if row[5] is not None else 0:,}", f"{int(row[6]) if row[6] is not None else 0:,}"] ] # 헤더를 제외한 표의 두 번째 행부터 각 셀에 data를 입력 for i, row_data in enumerate(data): for j, cell_data in enumerate(row_data): cell = table.cell(i+1, j) cell.text = cell_data for paragraph in cell.paragraphs: paragraph.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER # 표의 마지막 행의 마지막 셀에 '총합계' 값을 입력 table.rows[-1].cells[-1].text = f"{int(row[6]) if row[6] is not None else 0:,}" for paragraph in table.rows[-1].cells[-1].paragraphs: paragraph.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER # 문서 저장 (고객명을 파일명에 사용) doc.save(f'./송장 폴더/{row[0]}_송장. docx') # 송장 파일이 생성된 폴더('송장 폴더') 화면 '이상훈_송장. docx'파일에 데이터가 입력된 모습 이전 챕터에서 학습한 openpyxl로 엑셀 파일 다루는 방법과 본 챕터의 python-docx로 워드 파일 다루기를 종합하여 엑셀 파일의 데이터를 가져와서 워드 파일을 생성하는 코드를 완성했습니다. 위의 코드를 부분마다 나눠서 자세히 살펴보겠습니다. # 엑셀 파일 불러오기 wb = load_workbook('구매 고객 리스트. xlsx', data_only = True) ws = wb.active # 엑셀 파일의 각 행에 대해 워드 파일 생성 for row_idx, row in enumerate(ws.iter_rows(values_only=True)): # 헤더 행은 건너뛰기 if row_idx == 0: continue # 데이터가 없는 행을 건너뛰기 if not any(row): continue 먼저 load_workbook으로 '구매 고객 리스트. xlsx' 파일을 가져왔습니다. 엑셀 파일에 수식이 있었기 때문에 'data_only = True'를 넣어 수식의 결괏값을 가지고 옵니다. 엑셀 파일의 각 행에 대해 워드 파일 생성하기 위해서 for 문으로 엑셀 데이터를 행마다 순회합니다. 하나의 행에서 데이터를 가져온 다음 워드 작업을 실행하여 워드 파일을 생성하기까지가 작업의 한 사이클이기 때문에 전체 코드는 for 문안으로 넣어줍니다. 엑셀 데이터의 첫 행은 헤더(열이름) 행이기 때문에 행 인덱스가 0인 경우는 continue로 건너뛰도록 if 문으로 조건을 걸어줍니다. 그리고 행에 데이터가 없는 경우에도 해당 행을 건너뛰도록 any() 함수를 사용하여 if 문을 한 번 더 실행합니다. any() 함수는 반복 가능한 객체(여기서는 행)에 있는 어떤 값이라도 참이면 'True'를, 모든 값이 거짓을 경우 'False'를 반환합니다. 따라서 위의 코드에서는 현재 행의 모든 셀 이 비어있다면 해당 행을 건너뛰라는 의미로 if not any(row):를 사용하였습니다. 만약 빈 행을 건너뛰라는 조건을 넣지 않으면 'None'을 입력값으로 한 'None_송장. docx' 파일이 생성될 것입니다. # 워드 템플릿 파일 불러오기 doc = Document('송장. docx') # 고객 정보를 입력해야 하는 단락 지정 target_paragraph = doc.paragraphs[2] # 각 라벨 뒤에 텍스트 추가 target_paragraph.runs[2].add_text(str(row[0])) # 고객명 target_paragraph.runs[5].add_text(str(row[1])) # 고객 주소 target_paragraph.runs[8].add_text(str(row[2])) # 고객 연락처 엑셀 파일을 열어서 행별로 데이터에 접근하였으니 이제 다음으로 데이터를 입력할 워드 템플릿 파일을 가져오겠습니다. 앞에서 하나의 송장 파일을 만들 때와 동일하게 단락을 지정하고 텍스트 런에 텍스트를 입력하는 방식은 동일합니다. 다만 여기서는 반복 작업으로 각 행의 첫 번째 열(고객명), 두 번째 열(고객 주소), 그리고 세 번째 열(고객 연락처)을 가지고 와서 입력합니다. row로 셀 값을 가지고 올 때 데이터가 문자열이기 때문에 str로 지정합니다. # 구매 내역을 입력할 표 지정 table = doc.tables[0] # 표에 입력할 데이터 설정 data = [ [str(row[3]), int(row[4]), f"{int(row[5]) if row[5] is not None else 0:,}", f"{int(row[6]) if row[6] is not None else 0:,}"] ] 다음은 워드 템플릿의 표에 데이터를 입력해 보겠습니다. 문서 내 표가 하나이기 때문에 첫 번째 표(doc.tables[0])를 찾아옵니다. 표에 입력할 데이터를 설정하여 이중 리스트로 저장합니다. 이때 리스트의 첫 번째 원소는 문자열이고 두 번째 원소는 수량을 나타내는 값으로 한자리 숫자 데이터이기 때문에 별도의 작업이 필요하지 않아 각각 'str(row[3])', 'int(row[4])'로 비교적 간단하게 데이터를 가져왔습니다. 세 번째, 네 번째 원소는 금액을 나타내는 숫자형 데이터이기 때문에 파일을 더 완성도 있게 만들기 위해 숫자 데이터에 천 단위 구분 기호(,)를 추가합니다. 천 단위 구분 기호를 넣기 위해서는 '02. 파이썬 기초'의 '02-09. 문자열 처리'에서 학습한 'format'함수나 'f-string'을 사용하여 숫자를 천 단위로 구분하여 문자열로 변환해야 합니다. 위의 코드에서는 f"{number:,}"로 구분 기호를 입력하였습니다. 단, 변환할 때 if 문으로 조건을 넣어주었는데 int() 함수에 'None'값이 전달될 경우 에러가 발생하기 때문입니다. 따라서 'None' 값인지 확인한 후 'None'일 경우에는 0을 반환하고 그렇지 않을 경우에는 해당 셀의 값을 그대로 사용하도록 조건을 넣어주었습니다. # 헤더를 제외한 표의 두 번째 행부터 각 셀에 data를 입력 for i, row_data in enumerate(data): for j, cell_data in enumerate(row_data): cell = table.cell(i+1, j) cell.text = cell_data for paragraph in cell.paragraphs: paragraph.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER # 표의 마지막 행의 마지막 셀에 '총합계' 값을 입력 table.rows[-1].cells[-1].text = f"{int(row[6]) if row[6] is not None else 0:,}" for paragraph in table.rows[-1].cells[-1].paragraphs: paragraph.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER 위에서 설정한 데이터를 이제 표의 각 셀에 넣어줍니다. 이중 for 문으로 표의 전체 행을 순회하면서 현재 행의 각각의 열에 차례대로 접근하여 모든 셀에 데이터를 넣어줍니다. 단, 표의 헤더를 제외하기 위해 입력할 셀의 위치(table.cell)를 한 행 아래(i+1)로 설정합니다. 그리고 표에 입력된 데이터를 가운데 정렬시키기 위해 paragraph.alignment로 정렬 서식을 설정합니다. 표의 마지막 행의 마지막 셀에 입력하는 '총합계' 데이터도 동일하게 천 단위 구분 기호와 가운데 정렬 서식을 적용해 줍니다. # 문서 저장 (고객명을 파일명에 사용) doc.save(f'./송장 폴더/{row[0]}_송장. docx') 문서를 저장할 때도 파일명을 '고객명_송장. docx'<NAME>으로 저장하기 위해 row[0]으로 엑셀 데이터의 첫 열에 있는 고객명을 가지고 와서 f-string으로 파일명에 적용합니다. 지금까지 파이썬으로 워드 파일을 다루는 방법에 대해 학습하였습니다. 위에서 학습한 예제처럼 파이썬으로 워드의 템플릿을 활용해 작업을 빠르게 처리할 수 있으며, 더 나아가 엑셀 파일과도 연동시켜서 더 복잡한 작업을 자동화시킬 수도 있습니다. 06. 파워포인트(Powerpoint) 파일 다루기 비즈니스에서 발표는 빼놓을 수 없는 주된 업무 중 하나라고 볼 수 있습니다. 실적에 대한 발표, 향후 계획과 비전에 대한 발표, 시장 동향 분석이나 개발 사항에 대한 발표 등 거의 대부분의 모든 업무 분야에서 발표가 이루어지고 있다고 해도 과언이 아닐 것입니다. 그리고 이러한 발표를 위한 자료로 주로 사용되는 도구가 바로 파워포인트입니다. 파워포인트는 시각적으로 풍부하고, 구조화된 정보 전달을 가능하게 해주는 뛰어난 프로그램입니다. 하지만 수동으로 일일이 슬라이드를 작성하는 것은 시간이 많이 걸리고 반복적인 작업이 수반되곤 합니다. 파이썬을 이용하면, 이러한 반복적인 작업을 최소화하며, 동시에 정교하고 표준화된 파워포인트 발표 자료를 빠르게 만들어낼 수 있습니다. 또한 데이터베이스, 엑셀 등 다양한 데이터 소스에서 정보를 가져와 파워포인트에 통합할 수 있으며, 회사나 조직에서 사용하는 템플릿을 사용해 자동으로 발표 자료를 작성하는 것도 가능합니다. 이를 통해 시간 절약은 물론이고 일관된 퀄리티의 자료를 만들 수 있게 도와줍니다. 파이썬으로 파워포인트 파일을 다루기 위해 우리가 주로 사용할 라이브러리는 python-pptx입니다. 이 라이브러리를 사용하면 파워포인트 파일을 생성, 수정, 그리고 읽는 것이 가능해집니다. 이 챕터에서 python-pptx 라이브러리의 기본적인 사용 방법부터 이미지, 차트, 텍스트 및 테이블을 포함하는 다양한 요소를 파워포인트 파일에 추가하는 방법을 알아보겠습니다. 06-01. 파워포인트 파일 생성 및 텍스트 추가 python-pptx 라이브러리를 사용하여 기본적인 파워포인트 작업을 수행하는 방법을 알아보겠습니다. 먼저 pip로 라이브러리를 설치합니다. # python-pptx 라이브러리 설치 pip install python-pptx 파워포인트 파일과 객체 생성하기 이제 새로운 파워포인트 파일을 생성해 보겠습니다. 그리고 파일에 객체를 생성하고 기본 슬라이드도 하나 추가해 보겠습니다. from pptx import Presentation # Presentation 객체를 생성하여 프레젠테이션을 초기화 prs = Presentation() # 첫 번째 슬라이드 레이아웃 선택 slide_layout = prs.slide_layouts[0] # 선택한 레이아웃을 사용하여 새 슬라이드 추가 slide = prs.slides.add_slide(slide_layout) # 파일 저장 prs.save('presentation.pptx') 파워포인트 파일 생성을 위해 python-pptx 라이브러리에서 Presentation 클래스를 가져옵니다. Presentation 클래스의 인스턴스를 생성하여 새로운 프레젠테이션을 초기화합니다. 그리고 slide_layouts 리스트에서 슬라이드 레이아웃을 선택합니다. 여기서는 제목 슬라이드인 첫 번째 레이아웃(slide_layouts[0])을 선택하였습니다. 파워포인트에서 슬라이드 레이아웃은 슬라이드의 기본 디자인과 포맷을 정의합니다. 제목, 본문, 그림, 차트, 테이블 등 다양한 개체틀(placeholder)을 포함할 수 있으며, 레이아웃에 따라 포함하고 있는 개체틀의 종류와 개수가 다릅니다. slide_layouts 리스트는 python-pptx 라이브러리에서 제공하는 레이아웃 리스트로, 해당 리스트에서 특정 레이아웃을 선택하여 프레젠테이션에 슬라이드를 추가할 수 있습니다. 위의 코드에서는 add_slide 메서드를 사용하여 슬라이드를 추가하고 선택한 레이아웃을 설정하였습니다. 마지막으로 현재의 프레젠테이션을 파일로 저장할 때는 save 메서드를 사용하며, 파일을 저장할 경로를 포함하여 저장할 파일명을 전달합니다. 레이아웃 리스트 확인하기 앞서 말한 것처럼 slide_layouts 리스트에는 프레젠테이션에 사용 가능한 여러 레이아웃이 포함되어 있습니다. 어떤 레이아웃을 사용할지 알고 있는 경우라면 해당 레이아웃의 인덱스 번호를 사용하면 되겠지만, 사용 가능한 레이아웃들이 무엇인지 모르거나 레이아웃의 인덱스 번호를 모르는 경우에는 레이아웃 리스트를 확인할 필요가 있습니다. 다음의 코드를 사용하여 레이아웃들의 인덱스와 이름을 출력하여 확인할 수 있습니다. from pptx import Presentation prs = Presentation() # 사용 가능한 모든 슬라이드 레이아웃의 인덱스와 이름 출력 for i, layout in enumerate(prs.slide_layouts): print(f"Layout {i}: {layout.name}") # 결괏값 Layout 0: Title Slide Layout 1: Title and Content Layout 2: Section Header Layout 3: Two Content Layout 4: Comparison Layout 5: Title Only Layout 6: Blank Layout 7: Content with Caption Layout 8: Picture with Caption Layout 9: Title and Vertical Text Layout 10: Vertical Title and Text 텍스트 추가하기 이번에는 생성한 프레젠테이션 슬라이드에 텍스트를 추가해 보겠습니다. 아래 예제에서는 제목과 부제목이 있는 슬라이드 레이아웃을 추가하여 제목과 부제목을 입력합니다. from pptx import Presentation prs = Presentation() slide_layout = prs.slide_layouts[0] slide = prs.slides.add_slide(slide_layout) # 슬라이드에 제목과 부제목 추가 title = slide.shapes.title subtitle = slide.placeholders[1] # 제목과 부제목 텍스트 박스에 각각 텍스트를 추가 title.text = "Hello, World!" subtitle.text = "파이썬 파워포인트 자동화" prs.save('presentation.pptx') 'presentation.pptx'파일 실행 화면 shapes.title과 placeholders[1] 속성으로 제목과 부제목 텍스트 박스를 추가하고 각 텍스트 박스에 내용을 추가합니다. 여기서 텍스트 박스 개체틀(placeholder)을 추가하기 위해서는 placeholder의 인덱스를 전달해야 합니다. 개체틀(placeholder) 확인하기 슬라이드 레이아웃에 정의된 다양한 요소들은 개체틀(placeholder)이라는 객체를 통해 접근할 수 있습니다. 각 placeholder는 슬라이드에 특정 위치와 역할(예: 제목, 부제목, 본문, 그림, 차트, 테이블 등)이 할당된 텍스트 박스 또는 객체를 나타냅니다. placeholder에 접근하는 방법은 주로 인덱스 번호를 사용하는 것이며, 이 번호는 레이아웃에 따라 달라집니다. 각 레이아웃에 포함된 placeholder의 종류와 인덱스를 확인하기 위해 slide.placeholders 리스트를 사용하여 각 placeholder에 접근할 수 있습니다. 그리고 placeholder의 인덱스 번호는 레이아웃 디자인에 따라 결정됩니다. 특정 슬라이드 레이아웃의 placeholder 인덱스와 그들의 역할을 알아내려면, 슬라이드의 모든 placeholder를 순회하면서 각 placeholder의 인덱스 번호와 이름을 출력하는 코드를 사용할 수 있습니다. from pptx import Presentation prs = Presentation() slide_layout = prs.slide_layouts[0] slide = prs.slides.add_slide(slide_layout) # 선택된 슬라이드의 모든 placeholder의 인덱스와 이름을 반환 for i, placeholder in enumerate(slide.placeholders): print(f"Placeholder {i}: {placeholder.name}") # 결괏값 Placeholder 0: Title 1 Placeholder 1: Subtitle 2 위의 코드를 실행하면 각 placeholder의 인덱스 번호와 이름을 출력하여, 어떤 인덱스가 어떤 역할을 하는지 알려줍니다. 이를 통해 원하는 placeholder에 텍스트 또는 객체를 추가하는 데 사용할 올바른 인덱스 번호를 찾을 수 있습니다. 여기서 주목할 부분은 위의 코드에서 제목을 추가할 때는 placeholders[0]가 아닌 shapes.title로 텍스트 박스를 추가했다는 점입니다. 코드에서 사용한 레이아웃(slide_layouts[0]), 제목 슬라이드)에는 제목 텍스트 박스와 부제목 텍스트 박스가 포함되어 있고 각각의 인덱스 번호는 placeholders[0]과 placeholders[1]입니다. 제목 텍스트 박스를 추가할 때 shapes.title이 아닌 placeholders[0]으로 사용해도 동일하게 제목 텍스트를 입력할 수 있습니다. 하지만 shapes.title을 사용한 이유는 슬라이드 레이아웃에 따라서 slide.placeholders[0]이 항상 제목을 나타내지 않을 수 있기 때문입니다. slide.shapes.title 속성은 슬라이드의 제목 placeholder에 명시적으로 접근하는 방법을 제공하며, 이는 코드를 더 명확하고 읽기 쉽게 만듭니다. 그것은 슬라이드에 제목이 항상 있을 것이라는 암시적 가정을 하고 있으며, 제목 텍스트 박스가 레이아웃에서 첫 번째 placeholder로 정의되어 있지 않은 경우에도 제목에 접근할 수 있게 해줍니다. 다시 말해, slide.shapes.title를 사용하면, 슬라이드 레이아웃이 어떻게 설계되었는지에 상관없이 항상 제목 placeholder에 안전하게 접근할 수 있습니다. 반면, slide.placeholders[0]을 사용하면, 슬라이드 레이아웃에 따라 예기치 않은 결과를 얻을 수 있습니다. 따라서, 제목에 접근할 때는 slide.shapes.title를 사용하는 것이 더 정확하게 제목을 입력하는 방법입니다. 개체틀(placeholder) 추가하기 슬라이드 레이아웃에 포함되어 있는 개체틀 외에 추가로 개체틀이 필요할 경우, 기존 placeholder를 복제하거나 새로운 shape를 추가할 수 있습니다. 아래 코드에서는 슬라이드 레이아웃[1]을 가지고 와서 파워포인트 파일을 생성하였습니다. 레이아웃[1]의 콘솔에서 placeholder 리스트를 출력해 보면 'Placeholder 0: Title 1'과 'Placeholder 1: Content Placeholder 2'만 출력되어 총 2개의 개체틀을 포함하고 있다는 것을 확인할 수 있습니다. 이 기존 2개의 개체틀 외에 또 하나의 개체틀을 추가하여 보겠습니다. from pptx import Presentation from pptx.util import Inches prs = Presentation() slide_layout = prs.slide_layouts[1] slide = prs.slides.add_slide(slide_layout) title = slide.shapes.title subtitle = slide.placeholders[1] title.text = "제목" subtitle.text = "부제목" # 새로운 텍스트 박스를 슬라이드에 추가 left = Inches(1) # 텍스트 박스의 가로 위치(슬라이드 왼쪽 끝으로부터 떨어진 거리) top = Inches(2) # 텍스트 박스의 세로 위치(슬라이드 위쪽 끝으로부터 떨어진 거리) width = Inches(5) # 텍스트 박스의 가로 길이 height = Inches(1.5) #텍스트 박스의 세로 길이 textbox = slide.shapes.add_textbox(left, top, width, height) # 새로 생성한 텍스트 박스에 텍스트 추가 frame = textbox.text_frame p = frame.add_paragraph() p.text = "새로운 텍스트 박스에 추가된 텍스트" # 결과를 파워포인트 파일로 저장 prs.save('powerpoint_ex.pptx') 'powerpoint_ex.pptx'파일 실행 화면 기존 placeholder와 새로 추가된 placeholder를 구분하기 쉽게 기존 placeholder에 각각 '제목'과 '부제목'이라는 텍스트를 입력하였습니다. 이제 새로운 텍스트 박스를 슬라이드에 추가합니다. placeholder를 새로 추가할 때 그 위치나 크기를 지정할 수 있습니다. 위치와 크기를 지정하는 인자들은 다음과 같습니다. left : 텍스트 박스의 가로 위치(슬라이드 왼쪽 끝으로부터 떨어진 거리) top : 텍스트 박스의 세로 위치(슬라이드 위쪽 끝으로부터 떨어진 거리) width : 텍스트 박스의 가로 길이 height :텍스트 박스의 세로 길이 위의 코드에서는 단위로 인치(Inches)를 사용하였지만, 인치 외에도 센티미터(Cm), 포인트(Pt), 픽셀(Px) 등 여러 종류의 단위를 자유롭게 선택하여 값을 지정할 수 있습니다. 이렇게 설정한 수치를 가지고 add_textbox로 텍스트 박스를 추가합니다. add_textbox 메서드는 텍스트 박스의 크기나 위치값을 필수로 요구하기 때문에 하나라도 값을 지정하지 않으면 에러가 발생합니다. 그리고 유의할 점은 위의 코드(add_textbox(left, top, width, height))에서처럼 크기와 위치값을 변수에 할당한 다음에 각각의 변수를 add_text에 전달할 경우, 'left', 'top', 'width', 'height' 파라미터의 순서가 바뀌면 텍스트 박스의 위치와 크기가 의도와 다르게 설정됩니다. 인자의 순서에 따라 함수에 위치와 크기 값이 전달되기 때문입니다. 만약 순서에 구애받지 않고 사용하려면, 아래와 같이 키워드 인자(이름을 지정하여 인자를 전달)를 사용하여야 합니다. # 키워드 인자를 사용 textbox = slide.shapes.add_textbox(top=top, left=left, width=width, height=height) 위와 같은 방식으로 추가할 텍스트 박스의 크기와 위치를 지정하고, 레이아웃에 새로운 텍스트 박스를 추가할 수 있습니다. 리스트 추가하기 이번에는 파이썬을 사용하여 파워포인트에 리스트를 추가하는 방법에 대해 알아보겠습니다. from pptx import Presentation prs = Presentation() slide_layout = prs.slide_layouts[1] slide = prs.slides.add_slide(slide_layout) slide.shapes.title.text = "파이썬의 장점" tf = slide.placeholders[1].text_frame # 텍스트 박스에 리스트의 첫 번째 항목 추가 tf.text = "쉬운 사용법" # 첫 번째 항목에 대한 하위 항목 추가 p = tf.add_paragraph() p.text = "직관적인 문법" p.level = 1 # 리스트의 두 번째 항목 추가 p = tf.add_paragraph() p.text = "높은 생산성" p.level = 0 # 두 번째 항목에 대한 하위 항목 추가 p = tf.add_paragraph() p.text = "빠른 개발 속도" p.level = 1 # 리스트의 세 번째 항목 추가 p = tf.add_paragraph() p.text = "다양한 라이브러리와 프레임워크" p.level = 0 # 세 번째 항목에 대한 하위 항목 추가 p = tf.add_paragraph() p.text = "머신 러닝, 웹 개발 등에 유용" p.level = 1 # 파일 저장 prs.save('presentation_with_list.pptx') 'presentation_with_list.pptx' 파일 실행 화면 파이썬의 장점에 대해 리스트 형태로 파워포인트 슬라이드에 작성해 보았습니다. 먼저 추가한 슬라이드 레이아웃에 텍스트를 입력하기 위해 placeholders[1]에 접근하여 text_frame 객체를 얻습니다. 리스트의 첫 번째 항목을 텍스트 박스에 추가합니다. 첫 줄에 바로 입력하면 되기 때문에 'text_frame.text'를 사용하여 설정합니다. 따라서 위의 코드에서는 tf.text = "쉬운 사용법"로 입력하였습니다. 바로 그다음에 이어지는 코드들을 봐도 알 수 있듯, 첫 줄 이후에 추가되는 리스트의 항목들은 text_frame.text이 아닌 add_paragraph() 메서드를 사용하여 추가합니다. 물론 첫 번째 항목도 add_paragraph()를 사용하여 추가할 수는 있지만, 그렇게 할 경우에는 첫 줄이 비어있는 채로 두 번째 줄부터 리스트가 시작합니다. 리스트에 첫 번째 항목을 추가한 다음, 첫 번째 항목에 대한 하위 항목을 추가합니다. 추가하는 방식은 상위 항목과 하위 항목 모두 동일하게 add_paragraph()을 사용하며, level 속성을 변경하여 해당 내용이 하위 항목으로 설정됩니다. level 속성의 값은 0부터 시작하며 값이 클수록 더 깊은 하위 레벨을 나타냅니다. 0은 최상위 항목이기 때문에 단락에 텍스트를 설정하면 기본적으로 0으로 설정됩니다. 따라서 level이 0일 경우에는 level 속성 지정을 생략해도 됩니다. 위의 코드에서는 첫 번째 항목("쉬운 사용법" - level 0)에 대한 하위 항목이기 때문에 "직관적인 문법"이라는 텍스트의 level을 1로 설정하였습니다. 만약 "직관적인 문법"에 대한 하위 항목이 있다면 level 2로 지정하게 될 것입니다. 이와 같은 방식으로 두 번째와 세 번째 리스트 항목들과 각각의 하위 항목들도 추가합니다. 최종 생성된 파일을 보면, 리스트의 각 항목에 글머리 기호(bullet point, 불릿 포인트)가 추가되어 있습니다. 그리고 상위 항목과 하위 항목의 글머리 기호도 서로 다른 기호로 표시되어 있습니다. 위의 코드에서는 별도로 기호를 지정하지 않았는데 글머리 기호가 설정된 이유는 기본 레이아웃에 글머리 기호 설정이 포함되어 있기 때문입니다. 즉, 글머리 기호는 레이아웃에 정의되어 있는 설정 그대로 출력되며, python-pptx 라이브러리로는 글머리 기호의 스타일을 변경할 수 없습니다. 텍스트 서식 설정하기 텍스트 박스에 서식을 추가해 보겠습니다. from pptx import Presentation from pptx.util import Inches, Pt from pptx.enum.text import PP_PARAGRAPH_ALIGNMENT from pptx.dml.color import RGBColor prs = Presentation() slide_layout = prs.slide_layouts[5] slide = prs.slides.add_slide(slide_layout) slide.shapes.title.text = "서식 설정하기" # 슬라이드에 텍스트 박스 추가 left = top = Inches(1) width = height = Inches(5) txBox = slide.shapes.add_textbox(left, top, width, height) tf = txBox.text_frame # 첫 번째 단락 추가 및 글꼴 스타일 설정 p = tf.add_paragraph() p.text = "서식을 설정한 텍스트" p.font.name = '나눔 바른 고딕' # 글꼴 설정 p.font.bold = True p.font.size = Pt(30) p.font.color.rgb = RGBColor(0x42, 0x24, 0xE9) # RGBColor 클래스를 사용하여 글꼴 색상 설정 p.alignment = PP_PARAGRAPH_ALIGNMENT.CENTER # 텍스트 정렬 설정 prs.save('presentation_kor.pptx') 'presentation_kor.pptx' 파일 실행 화면' 텍스트를 추가하고 서식을 설정해 보았습니다. 텍스트를 추가하는 부분은 동일하기 때문에 서식을 추가하는 부분만 살펴보겠습니다. 먼저 글꼴은 font.name 속성을 사용하며, 글꼴의 종류를 지정해 줍니다. 한국어 글꼴과 영어 글꼴 모두 동일한 방식으로 설정합니다. 단, 설정하고자 하는 글꼴이 시스템에 설치가 되어 있어야 합니다. 굵게 (bold), 기울임 (italic), 밑줄 (underline) 등의 글자 서식은 font 객체의 속성을 True로 설정하여 적용할 수 있습니다. 글자의 크기는 font.size 속성으로 설정합니다. 파워포인트의 기본 글자 크기 단위와 동일하게 포인트 단위를 사용하기 위해 from pptx.util import Pt를 실행한 후, Pt()로 크기를 설정해 줍니다. font.color.rgb 속성을 사용하여 글자 색상을 지정합니다. RGBColor 클래스를 사용하여 RGB 코드 (예: 파란색 코드)를 전달합니다. 클래스 사용을 위해 from pptx.dml.color import RGBColor를 먼저 실행해 주어야 합니다. PP_PARAGRAPH_ALIGNMENT 열거형을 사용하여 단락 정렬을 설정할 수 있습니다. 여기서는 가운데 정렬 (CENTER)을 사용했습니다. 또한, LEFT로 왼쪽 정렬, RIGHT로 오른쪽 정렬을 설정할 수 있습니다. 정렬 서식을 위해서는 from pptx.enum.text import PP_PARAGRAPH_ALIGNMENT를 실행해 주어야 합니다. 이 방법으로 텍스트 서식을 설정할 수 있으며, 서식을 지정하지 않으면 기본 레이아웃의 서식이 자동 적용됩니다. 표 추가하기 add_table 메서드로 슬라이드에 표를 추가하는 방법을 알아보겠습니다. 다음은 3행 2열의 표를 생성하고 각 셀에 행과 열의 값을 텍스트로 추가하는 예제입니다. from pptx import Presentation from pptx.util import Inches prs = Presentation() slide_layout = prs.slide_layouts[5] slide = prs.slides.add_slide(slide_layout) slide.shapes.title.text = "표 추가하기" # 표 추가 위치 및 크기 설정 left = Inches(2) top = Inches(2) width = Inches(6) height = Inches(4.5) # 표 추가 (3행 2열) rows, cols = 3, 2 table = slide.shapes.add_table(rows, cols, left, top, width, height).table # 표에 텍스트 추가 table.cell(0, 0).text = "열이름 1" table.cell(0, 1).text = "열이름 2" table.cell(1, 0).text = "1 행, 1 열" table.cell(1, 1).text = "1 행, 2 열" table.cell(2, 0).text = "2 행, 1 열" table.cell(2, 1).text = "2 행, 2 열" prs.save('presentation_with_table.pptx') 'presentation_with_table.pptx' 파일 실행 화면 슬라이드에 add_table 메서드를 사용하여 표를 추가합니다. 추가할 표의 행과 열의 수, 그리고 표의 크기와 위치를 설정한 후, add_table 메 서드에 행의 수, 열의 수, 위치, 크기 순으로 인자로 전달합니다. table.cell(row, col).text 메서드를 사용하여 각 셀에 텍스트를 추가합니다. 앞서 엑셀이나 워드 파일에 표를 추가할 때 학습한 것처럼 표에 입력할 데이터를 2차원의 리스트로 생성한 다음 이중 for 문으로 각 셀에 접근하여 데이터를 입력하는 것도 가능합니다. 표의 서식 설정 python-pptx 라이브러리로 표를 추가할 때 표의 속성을 별도로 설정하지 않으면 위의 예제와 같이 기본 스타일이 적용되어 생성됩니다. 행 높이나 열 너비, 테두리 스타일이나 셀 배경색 등 표의 다양한 속성을 직접 설정할 수도 있습니다. 표의 속성을 설정하는 몇 가지 예제 코드를 알아보겠습니다. # 행 높이 설정 for row in table.rows: row.height = Inches(1) # 열 너비 설정 for col in table.columns: col.width = Inches(3) row.height와 col.width로 각각 행 높이와 열 너비를 설정할 수 있습니다. 모든 행의 높이와 모든 열의 너비를 동일하게 설정해 주기 위해 for 문을 사용합니다. 만약 각 행이나 각 열에 대해 서로 다른 높이/너비를 설정하려면 개별적으로 행과 열에 접근하여 수치를 설정해야 합니다. 만약 열이 2개이며 첫 번째 열의 너비는 2인치로, 두 번째 열의 너비는 4인치로 설정하려면 아래와 같은 코드를 사용합니다. table.columns[0].width = Inches(2) table.columns[1].width = Inches(4) 이번에는 셀의 서식을 설정하는 방법입니다. 특정 셀에 배경색과 글자 서식을 설정하려면 다음과 같은 코드를 사용합니다. # 특정 셀의 배경색 설정 table.cell(0, 0).fill.solid() table.cell(0, 0).fill.fore_color.rgb = RGBColor(91, 155, 213) table.cell(0, 0)로 서식을 설정할 셀을 참조합니다. 배경색을 설정할 때는 fill 속성을 사용하고 solid() 메서드를 사용하여 단색 배경을 설정합니다. cell.fill.fore_color_rgb 속성을 사용하여 RGB<NAME>으로 색상을 설정해 줍니다. RGB<NAME>으로 배경색을 설정하기 위해서는 사전에 from pptx.dml.color import RGBColor가 실행되어 있어야 합니다. 다음과 같이 특정 셀의 글자색이나 글자 크기도 서식을 변경할 수 있습니다. # 특정 셀의 글자 서식 설정 table.cell(0, 0).text_frame.paragraphs[0].runs[0].font.size = Pt(20) table.cell(0, 0).text_frame.paragraphs[0].runs[0].font.color.rgb = RGBColor(255, 255, 0) table.cell(0, 0)로 동일하게 서식을 설정할 셀을 참조한 다음, font.size로 글자의 크기를, font.color.rgb로 글자의 컬러를 설정합니다. 여기서 주의할 점은 먼저 텍스트를 셀에 할당하고 나서 해당 텍스트에 대한 글꼴을 설정해야 합니다. 만약 글꼴을 먼저 설정해 놓은 다음 텍스트를 할당하면, 파이썬에서는 텍스트를 할당할 때 기본 글자 서식으로 셀에 덮어쓰기 때문에 기존 서식이 사라지게 됩니다. 따라서 텍스트를 할당한 후에 글꼴을 설정합니다. 학습한 서식 설정 코드를 활용하여 표의 행 높이와 열 너비를 설정하고, 0, 0셀에 배경색과 글자 서식을 추가한 코드는 다음과 같습니다. from pptx.enum.text import PP_PARAGRAPH_ALIGNMENT from pptx.dml.color import RGBColor from pptx import Presentation from pptx.util import Inches prs = Presentation() slide_layout = prs.slide_layouts[5] slide = prs.slides.add_slide(slide_layout) slide.shapes.title.text = "표 추가하기" # 표 추가 위치 및 크기 설정 left = Inches(2) top = Inches(2) width = Inches(6) height = Inches(4.5) # 표 추가 (3행 2열) rows, cols = 3, 2 table = slide.shapes.add_table(rows, cols, left, top, width, height).table # 행 높이 설정 for row in table.rows: row.height = Inches(1) # 열 너비 설정 for col in table.columns: col.width = Inches(3) # 표에 텍스트 추가 table.cell(0, 0).text = "열이름 1" table.cell(0, 1).text = "열이름 2" table.cell(1, 0).text = "1 행, 1 열" table.cell(1, 1).text = "1 행, 2 열" table.cell(2, 0).text = "2 행, 1 열" table.cell(2, 1).text = "2 행, 2 열" # 특정 셀의 글꼴 설정 table.cell(0, 0).text_frame.paragraphs[0].runs[0].font.size = Pt(40) table.cell(0, 0).text_frame.paragraphs[0].runs[0].font.color.rgb = RGBColor(255, 255, 0) # 특정 셀의 배경색 설정 table.cell(0, 0).fill.solid() table.cell(0, 0).fill.fore_color.rgb = RGBColor(91, 155, 213) prs.save('presentation_with_table2.pptx') 'presentation_with_table2.pptx' 파일 실행 화면 06-02. 파워포인트 파일 그래픽 요소 추가 파이썬에서 파워포인트에 도형, 이미지, 차트 등 그래픽 요소들을 추가할 수 있습니다. 다양한 그래픽 요소들 중 대표적인 몇 가지 요소들을 추가하는 방법을 알아보겠습니다. 도형 추가하기 파워포인트 슬라이드에 도형을 추가하는 방법을 알아보겠습니다. 아래의 예제 코드에서는 슬라이드에 색이 있는 둥근 직사각형을 추가해 보겠습니다. from pptx import Presentation from pptx.util import Inches from pptx.dml.color import RGBColor from pptx.enum.shapes import MSO_SHAPE prs = Presentation() slide_layout = prs.slide_layouts[5] slide = prs.slides.add_slide(slide_layout) slide.shapes.title.text = "도형 추가하기" # 둥근 직사각형을 추가 left = Inches(2) top = Inches(2) width = Inches(6) height = Inches(4.5) shape = slide.shapes.add_shape(MSO_SHAPE.ROUNDED_RECTANGLE, left, top, width, height) # 도형의 속성 설정 shape.fill.solid() # 단색 채우기 shape.fill.fore_color.rgb = RGBColor(91, 155, 213) # 채우기 색상 설정(파란색) shape.line.color.rgb = RGBColor(0, 0, 0) # 테두리 색상 설정(검은색) # 텍스트를 추가 후 서식 설정 shape.text = "둥근 직사각형" shape.text_frame.paragraphs[0].font.bold = True shape.text_frame.paragraphs[0].font.size = Inches(0.5) prs.save('presentation_with_graphics.pptx') 'presentation_with_graphics.pptx' 파일 실행 화면 파워포인트에 도형을 추가할 때는 from pptx.enum.shapes import MSO_SHAPE를 사용해 MSO_SHPAE라는 열거형(enum)을 가져와야 합니다. MSO는 Microsoft Office의 약자이며, SHAPE는 그래픽의 형태를 나타냅니다. 즉, 마이크로소프트 오피스 프로그램에서 사용할 수 있는 각종 그래픽 요소들(직사각형, 원, 화살표 등)을 정의하고 있어서 이를 통해 특정 형태의 그래픽 요소들을 쉽게 추가할 수 있습니다. 위의 코드에서는 MSO_SHAPE.ROUNDED_RECTANGLE로 둥근 모서리의 직사각형을 생성합니다. slide.shapes.add_shape 메서드를 호출할 때 첫 번째 인자로 MSO_SHAPE 열거형을 전달하여 도형의 종류를 결정합니다. 그리고 left, top, width, height 인자를 차례 전달하여 도형의 위치와 크기를 지정합니다. 이렇게 생성한 도형에 추가적인 속성을 지정할 수 있습니다. # 도형의 속성 설정 shape.fill.solid() # 단색 채우기 shape.fill.fore_color.rgb = RGBColor(91, 155, 213) # 채우기 색상 설정(파란색) shape.line.color.rgb = RGBColor(0, 0, 0) # 테두리 색상 설정(검은색) fill 메서드로 도형의 색을 채울 수 있습니다. 색을 채울 때는 단색 채우기 외에도 그러데이션, 질감(무늬), 그림 배경 등 여러 가지 채우기 스타일 중에 원하는 스타일을 선택할 수 있습니다. 여기서는 단색으로 도형을 채우기 위해 fill.solid()를 사용하였습니다. 도형에 색을 채울 때 채우기 색상은 RGB 색상 코드를 사용합니다. 단색 채우기에서는 주된 색상 하나만 필요하기 때문에 fill.fore_color.rgb 만으로 색을 지정합니다. 질감 효과 등 두 번째 색상을 필요로 하는 채우기 효과를 적용할 경우에는 back_color로 다른 색상을 추가로 지정해 주어야 합니다. 여기서는 shape.fill.fore_color.rgb = RGBColor(91, 155, 213)로 도형에 단색으로 파란색을 채워주었습니다. line 메서드로 테두리를 설정합니다. 테두리의 컬러도 동일하게 RGB 코드로 값을 입력합니다. 위의 코드에서는 검은색 테두리를 설정하기 위해 shape.line.color.rgb = RGBColor(0, 0, 0)를 사용하였습니다. 위의 코드에서는 설정하지 않았지만 shadow 메서드로 도형에 그림자 효과를 적용할 수도 있습니다. 그림자의 투명도나 색상, 반경 등 그림자의 속성도 설정할 수 있습니다. 그렇지만 그림자 효과 외에 부드러운 가장자리 효과, 네온 효과 등 다른 기타 고급 효과를 적용하는 기능은 아직 python-pptx 라이브러리에서는 제공하지 않습니다. # 텍스트를 추가 후 서식 설정 shape.text = "둥근 직사각형" shape.text_frame.paragraphs[0].font.bold = True shape.text_frame.paragraphs[0].font.size = Inches(0.5) shape.text 속성으로 도형에 텍스트를 추가할 수도 있습니다. 이 속성을 사용하면 도형에 텍스트를 입력할 수 있습니다. shape.text 속성을 사용하여 텍스트를 설정하면, 이전에 도형에 설정된 모든 텍스트가 삭제되고 새 텍스트가 삽입됩니다. 도형에 입력한 텍스트에 추가적인 서식을 설정하기 위해서는 위의 코드에서처럼 shape.text_frame 속성을 사용해야 합니다. text_frame을 사용하면 도형에 여러 단락을 추가하고 각각의 단락에 다른 서식을 설정할 수 있습니다. 위의 예제 코드에서는 첫 번째 단락에 추가된 텍스트의 서식을 굵게 변경하고, 글자 크기도 지정하였습니다. 이와 같이 python-pptx로 슬라이드에 다양한 종류의 도형을 추가하고 도형의 서식을 설정할 수 있으며, 도형 안에 텍스트를 추가하고 텍스트의 서식을 설정하는 것도 가능합니다. 이미지 추가하기 파워포인트에 이미지를 추가하는 것도 python-pptx 라이브러리로 가능합니다. from pptx import Presentation from pptx.util import Inches prs = Presentation() slide_layout = prs.slide_layouts[5] slide = prs.slides.add_slide(slide_layout) # 이미지 경로를 지정 (여기서는 동일한 폴더에 있는 'image1.png' 파일을 사용) img_path = 'image1.png' # 이미지의 위치와 크기를 지정 left = top = Inches(1) width = height = Inches(5) # 이미지를 슬라이드에 추가 slide.shapes.add_picture(img_path, left, top, width, height) prs.save('presentation_with_image.pptx') 'presentation_with_graphics.pptx' 파일 실행 화면 슬라이드에 이미지를 추가하기 위해 이미지 파일의 경로를 전달합니다. 위의 예제 코드에서는 실행 경로와 동일한 경로의 파일을 사용하여 파일명만 전달했지만, 다른 경로의 이미지 파일을 가지고 올 경우에는 전체 경로를 전달합니다. 그리고 이미지를 추가하는 방식도 도형을 추가할 때와 마찬가지로 삽입할 이미지의 크기와 위치를 설정해야 합니다. 여기서는 위치의 값으로 모두 1인치를 전달하여 왼쪽 상단으로부터 1인치 x1인치 떨어진 위치로 지정하였으며, 이미지의 크기는 가로와 세로 동일하게 5인치 x5인치의 크기로 설정했습니다. 이렇게 설정한 이미지의 경로, 위치, 크기의 값을 add_picture 메서드에 인자로 전달하여 슬라이드에 이미지를 추가합니다. 도형이나 이미지를 삽입할 때 크기나 위치가 겹치게 될 경우, 먼저 삽입된 객체가 뒤에 위치하게 되고, 나중에 삽입된 객체가 앞에 위치하게 됩니다. 즉, 코드에서 나중에 추가된 객체가 슬라이드에서 상단에 보이게 됩니다. python-pptx 라이브러리는 이미 삽입된 도형이나 이미지의 순서를 변경하는 기능은 제공하지 않습니다. 따라서 객체의 순서를 조절하려면 삽입 순서를 변경하여 코드를 조절해야 합니다. 차트 추가하기 이번에는 python-pptx 라이브러리를 사용하여 차트를 추가하는 방법을 살펴보겠습니다. 예제에서는 기본적인 막대 차트를 추가해 보겠습니다. from pptx import Presentation from pptx.chart.data import CategoryChartData from pptx.enum.chart import XL_CHART_TYPE from pptx.util import Inches prs = Presentation() slide_layout = prs.slide_layouts[5] slide = prs.slides.add_slide(slide_layout) slide.shapes.title.text = "차트 추가하기" # 차트 데이터를 정의합니다 chart_data = CategoryChartData() chart_data.categories = ['A 제품', 'B 제품', 'C 제품'] chart_data.add_series('잔류오염도', (9.2, 11.4, 16.7)) # 차트를 추가할 위치와 크기를 지정합니다 x, y, cx, cy = Inches(2), Inches(2), Inches(6), Inches(4.5) # 슬라이드에 차트를 추가합니다 chart = slide.shapes.add_chart( XL_CHART_TYPE.COLUMN_CLUSTERED, x, y, cx, cy, chart_data ).chart # 차트 제목을 설정합니다 chart.has_title = True chart.chart_title.text_frame.text = "제품별 세정력 측정" # X와 Y 축의 제목을 설정합니다 chart.category_axis.axis_title.text_frame.text = "제품" chart.value_axis.axis_title.text_frame.text = "제품 사용 후 잔류 오염도" prs.save('presentation_with_chart.pptx') 'presentation_with_chart.pptx' 파일 실행 화면 차트를 추가할 때는 차트의 종류, 축 제목, 수치 데이터, 크기 및 위치 등 다양한 정보가 필요하기 때문에 코드가 조금 복잡하게 느껴질 수 있습니다. 위의 예제 코드를 자세하게 나누어 살펴보겠습니다. from pptx import Presentation from pptx.chart.data import CategoryChartData from pptx.enum.chart import XL_CHART_TYPE from pptx.util import Inches 차트를 만들 때는 기본 Presentation 클래스와 차트 크기를 지정하기 위한 Inches 함수 외에도 차트의 종류를 정의하는 XL_CHART_TYPE 열거형, 그리고 차트 데이터를 관리하기 위한 CategoryChartData 클래스가 추가로 필요합니다. 따라서 위의 모듈과 클래스를 먼저 불러옵니다. prs = Presentation() slide_layout = prs.slide_layouts[5] slide = prs.slides.add_slide(slide_layout) slide.shapes.title.text = "차트 추가하기" # 차트 데이터를 정의합니다 chart_data = CategoryChartData() chart_data.categories = ['A 제품', 'B 제품', 'C 제품'] chart_data.add_series('잔류오염도', (9.2, 11.4, 16.7)) 슬라이드 레이아웃을 정의하고 새 슬라이드에 제목을 추가한 다음, CategoryChartData()로 차트 데이터를 정의합니다. categories로 카테고리를 설정하고 add_series로 각 카테고리별 데이터의 시리즈를 생성합니다. 차트에서 데이터를 묶어 "시리즈"라는 그룹으로 만들며, 이렇게 생성된 하나의 시리즈는 차트에서 특정 데이터 세트를 표현하게 됩니다. 이 데이터 세트는 차트에서 한 줄(라인 차트의 경우)이나 한 그룹의 막대(막대 차트의 경우) 등으로 표현됩니다. 시리즈를 여러 개 추가할 수도 있는데, 이 경우 각 시리즈는 차트에 별개의 라인이나 막대 그룹으로 표시되어 여러 데이터 세트를 함께 비교할 수 있게 합니다. 여기서는 "잔류오염도"라는 이름으로 시리즈를 생성하였습니다. # 차트를 추가할 위치와 크기를 지정합니다 x, y, cx, cy = Inches(2), Inches(2), Inches(6), Inches(4.5) 차트를 추가할 위치와 크기를 지정합니다. 여기서는 위치는 x, y 변수에 크기는 cx, cy 변수에 값을 할당했습니다. # 슬라이드에 차트를 추가합니다 chart = slide.shapes.add_chart( XL_CHART_TYPE.COLUMN_CLUSTERED, x, y, cx, cy, chart_data ).chart add_chart 메 서드로 슬라이드에 차트를 추가합니다. add_chart 메 서드에 차트의 유형, 위치, 크기, 그리고 차트 데이터를 전달하여 차트를 생성합니다. 여기서는 차트의 종류를 COLUMN_CLUSTERED(수직 막대 차트)로 지정하였습니다. # 차트 제목을 설정합니다 chart.has_title = True chart.chart_title.text_frame.text = "제품별 세정력 측정" # X와 Y 축의 제목을 설정합니다 chart.category_axis.axis_title.text_frame.text = "제품" chart.value_axis.axis_title.text_frame.text = "제품 사용 후 잔류 오염도" prs.save('presentation_with_chart.pptx') 차트의 제목과 X축, Y 축의 제목을 설정합니다. 차트 제목을 입력하기 위해서는 has_title 속성을 True로 설정하여 제목을 활성화해주어야 합니다. chart_title.text_frame.text를 사용하여 제목 텍스트를 설정합니다. X축과 Y 축의 축제목은 chart.category_axis.axis_title.text_frame.text와 chart.value_axis.axis_title.text_frame.text로 각각 설정 가능합니다. 위의 예제에서 추가한 수직 막대 차트 외에도 다양한 차트 유형을 선택할 수 있습니다. pptx.enum.chart.XL_CHART_TYPE 열거형을 조회하면 사용 가능한 차트의 유형을 확인 가능합니다. 아래의 코드를 실행하여 차트 유형의 전체 목록을 출력할 수 있습니다. from pptx.enum.chart import XL_CHART_TYPE # 가능한 차트 유형을 나열합니다 chart_types = [attr for attr in dir(XL_CHART_TYPE) if not callable(getattr(XL_CHART_TYPE, attr)) and not attr.startswith("__")] for chart_type in chart_types: print(chart_type) # 결괏값 AREA AREA_STACKED AREA_STACKED_100 BAR_CLUSTERED BAR_OF_PIE BAR_STACKED BAR_STACKED_100 BUBBLE BUBBLE_THREE_D_EFFECT COLUMN_CLUSTERED COLUMN_STACKED (중략) 06-03. 파워포인트 파일 읽기 파워포인트 파일 열기 python-pptx를 사용하여 파워포인트 파일을 열어 봅시다. from pptx import Presentation # 기존의 파워포인트 파일 열기 prs = Presentation('presentation_with_list.pptx') 파일을 여는 것은 간단하게 Presentation()에 열고자 하는 파일의 경로를 전달하면 됩니다. 슬라이드 제목과 본문 텍스트 추출 그러면 이번에는 위에서 열었던 파일을 텍스트를 추출해 보겠습니다. 각 슬라이드에서 제목과 본문 텍스트를 추출하려면 슬라이드의 각 요소를 순환하며 텍스트를 찾아야 합니다. from pptx import Presentation prs = Presentation('presentation_with_list.pptx') # 각 슬라이드의 제목과 본문 텍스트를 출력 for slide_number, slide in enumerate(prs.slides): #전체 슬라이드를 순회 print(f"Slide {slide_number+1}") # 슬라이드의 제목 출력 (제목이 있는 경우) if slide.shapes.title: print(f"Title: {slide.shapes.title.text}") # 슬라이드의 본문 텍스트 출력 #각 슬라이드에 포함된 모든 개체(도형, 텍스트 상자, 표 등)를 순회 for shape in slide.shapes: # 현재 개체의 형태가 텍스트 상자인지 확인, 텍스트 상자일 경우 아래 코드를 실행 if hasattr(shape, "text_frame") and shape.text_frame: for paragraph in shape.text_frame.paragraphs: # 텍스트 상자의 모든 단락을 순회 for run in paragraph.runs: # 현재 단락의 텍스트 런에 접근 print(run.text) #현재 텍스트 런을 출력 # 결괏값 Slide 1 Title: 파이썬의 장점 1 파이썬의 장점 1 쉬운 사용법 직관적인 문법 Slide 2 Title: 파이썬의 장점 2 파이썬의 장점 2 높은 생산성 빠른 개발 속도 Slide 3 Title: 파이썬의 장점 3 파이썬의 장점 3 다양한 라이브러리와 프레임워크 머신 러닝, 웹 개발 등에 유용 전체 슬라이드를 순회하며, 각 슬라이드에 포함된 개체를 모두 순회하여 텍스트 추출하도록 이중 for 문을 사용하였습니다. 먼저 슬라이드에 제목이 포함되어 있는지 확인하고, 있다면 제목을 출력합니다. 그다음에는 제목을 포함한 모든 텍스트를 출력합니다. if 문에 hasattr로 슬라이드에 포함된 개체의 형태가 텍스트인지 구분하도록 조건을 설정(if hasattr(shape, "text") and shape.text_frame) 하고, 텍스트인 경우에만 텍스트의 내용을 출력합니다. 그리고 텍스트를 출력할 때 몇 번째 슬라이드에서 출력한 것인지 직관적으로 알 수 있도록 슬라이드 번호를 함께 출력합니다. (print(f"Slide {slide_number+1}: {shape.text}")) 추출된 결괏값을 보면 해당 파일은 3개의 슬라이드로 구성되어 있으며, 각 슬라이드에는 "파이썬의 장점 1/2/3"이라는 제목과 본문의 내용이 작성되어 있음을 알 수 있습니다. 추출한 텍스트를 파일에 저장 위에서 추출한 텍스트를 파일에 저장하려면, 텍스트를 문자열 변수에 추가한 후 파일에 쓸 수 있습니다. from pptx import Presentation prs = Presentation('presentation_with_list.pptx') extracted_text = "" # 빈 문자열 변수 'extracted_text'를 생성 for slide_number, slide in enumerate(prs.slides): for shape in slide.shapes: # 텍스트일 경우, extracted_text에 슬라이드 번호와 텍스트 내용을 추가 if hasattr(shape, "text"): extracted_text += f"Slide {slide_number+1}: {shape.text}\n" with open('extracted_text.txt', 'w') as file: file.write(extracted_text) 위의 코드를 실행하면 파워포인트 파일의 텍스트가 'extracted_text.txt'라는 파일에 저장됩니다. 텍스트를 파일로 추출하고자 할 때는 위와 같은 방식으로 파일에 저장할 수 있습니다. 표 데이터 추출하기 이번에는 표의 데이터를 추출하는 방법을 알아보겠습니다. 표의 데이터를 추출하려면 각 셀의 내용을 순회하여 데이터를 가져와야 합니다. 아래 예제는 파워포인트 슬라이드에서 표를 찾고, 그 안의 데이터를 출력하는 코드입니다. from pptx import Presentation prs = Presentation("presentation_with_table.pptx") # 전체 슬라이드를 순회하며 표를 찾아 데이터를 추출 for slide_number, slide in enumerate(prs.slides): #각 슬라이드에 포함된 모든 개체(도형, 텍스트 상자, 표 등)를 순회 for shape in slide.shapes: if hasattr(shape, "table"): # 현재 개체의 형태가 표인지 확인 table = shape.table # 현재 표를 table 변수에 할당 for row in table.rows: # 테이블의 모든 행을 순회 for cell in row.cells: # 현재 행의 모든 셀을 순회 print(cell.text) #현재 셀의 텍스트를 출력 # 결괏값 열이름 1 열이름 2 1 행, 1 열 1 행, 2 열 2 행, 1 열 2 행, 2 열 텍스트를 출력할 때와 마찬가지로 표의 데이터를 출력하기 위해서도 각 슬라이드에 포함된 모든 개체를 순회하며 개체가 표인지 확인합니다. 표인 경우에는 해당 표의 객체를 가져와 모든 행을 순회하며, 각 행에서는 모든 셀을 순회합니다. 이렇게 셀을 순회하며 셀에 입력된 텍스트를 출력합니다. 이미지 파일 추출하기 python-pptx 라이브러리는 직접적으로 이미지를 추출하는 기능을 제공하지 않기 때문에, 파워포인트에서 이미지를 추출하기 위해서는 이미지의 바이트 데이터를 가져와 파일로 저장하는 방법을 사용해야 합니다. 다음은 파워포인트 파일에서 이미지를 추출하는 예제 코드입니다. from pptx import Presentation prs = Presentation("presentation_with_image.pptx") # 전체 슬라이드를 순회 for slide_number, slide in enumerate(prs.slides): # 각 슬라이드에서 모든 개체(shape)를 순회 for shape in slide.shapes: # 현재 개체가 이미지의 속성을 가지고 있는지 확인하고, 이미지일 경우 아래 코드를 실행 if hasattr(shape, "image"): # 이미지의 바이트 데이터와 확장자를 가져와 변수에 할당 image_stream = shape.image.blob image_format = shape.image.ext # 바이트 데이터를 사용하여 이미지 파일을 생성 with open(f"slide_{slide_number}_image.{image_format}", "wb") as img_file: img_file.write(image_stream) 이미지를 추출하기 위해 먼저 전체 슬라이드와 모든 개체를 순회하며 hasattr 함수를 사용하여 이미지 개체를 찾습니다. 그다음, image.blob과 image.ext로 각각 이미지의 바이트 데이터와 확장자를 가져옵니다. 이미지를 가져와서 파일로 저장할 때 원래의 확장자가 아닌 다른 확장자로 파일을 저장하는 것은 가능합니다. 그렇지만 그럴 경우 일부<NAME>에 따라 이미지가 깨질 수 있기 때문에 여기서는 원래의 확장자로 저장하기 위해 확장자도 가져왔습니다. 가지고 온 바이트 데이터를 사용하여 이미지 파일을 저장합니다. 저장할 때 파일의 확장자는 원래 확장자로 지정하였습니다. 이렇게 코드를 실행한 결과, 실행 경로에 'slide_0_image.png'파일이 생성되었습니다. 차트 데이터 추출하기 python-pptx 라이브러리로 슬라이드에 포함된 차트 데이터도 추출할 수 있습니다. 아래 예제는 차트를 찾고, 차트 데이터를 출력하는 코드입니다. from pptx import Presentation prs = Presentation("presentation_with_chart.pptx") # 전체 슬라이드를 순회 for slide_number, slide in enumerate(prs.slides): # 각 슬라이드 내의 모든 개체를 순회 for shape in slide.shapes: # if 문과 hasattr 함수를 사용하여 현재 개체가 차트인지 확인하고 차트일 경우 chart에 할당 if hasattr(shape, "chart"): chart = shape.chart # 차트 내의 모든 시리즈를 순회 for series in chart.series: print(f"Series title: {series.name}") # 시리즈 이름을 출력 # 첫 번째 플롯(plot)의 카테고리와 값(즉, x 값과 y 값)의 쌍을 순회 for x_val, y_val in zip(chart.plots[0].categories, series.values): print(f"Data point: x={x_val}, y={y_val}") # 결괏값 Series title: 잔류오염도 Data point: x=A 제품, y=9.2 Data point: x=B 제품, y=11.4 Data point: x=C 제품, y=16.7 위 코드 예제를 차트를 읽는 부분을 중점으로 자세히 살펴보겠습니다. for slide_number, slide in enumerate(prs.slides): for shape in slide.shapes: # if 문과 hasattr 함수를 사용하여 현재 개체가 차트인지 확인하고 차트일 경우 chart에 할당 if hasattr(shape, "chart"): chart = shape.chart 각 슬라이드를 돌며 모든 개체 중 차트 객체를 찾습니다. 현재 개체가 차트일 경우 변수 chart에 할당합니다. # 차트 내의 모든 시리즈를 순회 for series in chart.series: print(f"Series title: {series.name}") # 시리즈 이름을 출력 차트의 모든 시리즈를 돌며 시리즈의 이름을 출력합니다. 예제 코드에서는 시리즈가 하나였지만, 한 차트에 시리즈가 여러 개인 경우도 있으므로 시리즈를 순회합니다. # 첫 번째 플롯(plot)의 카테고리와 값(즉, x 값과 y 값)의 쌍을 순회 for x_val, y_val in zip(chart.plots[0].categories, series.values): print(f"Data point: x={x_val}, y={y_val}") 첫 번째 플롯에서 카테고리와 값(즉, x 값과 y 값)의 쌍을 순회하며 그 값을 출력합니다. 여기서 플롯이란 차트에서 데이터를 시각적으로 표현하는 영역을 의미합니다. 위의 예제 파일에서는 수직 막대 차트만을 사용하여 플롯이 하나지만, 하나의 차트에 라인 플롯과 바 플롯을 동시에 표현하는 경우처럼 두 개의 서로 다른 플롯이 하나의 차트에서 사용되는 경우도 있습니다. 플롯이 여러 개인 경우에는 각 플롯을 순회하여 각각의 플롯에서 데이터를 추출해야 합니다. chart.plots[0].categories으로 첫 번째 플롯의 카테고리, 즉 x 값을 가져오고, series.values로 데이터 값, 즉, y 값을 가지고 옵니다. 이렇게 가져온 x 값과 y 값을 zip 함수를 사용하여 한 쌍으로 묶어 순회합니다. 추출된 결괏값을 통해 예제 파일에는 하나의 차트가 포함되어 있다는 것을 알 수 있습니다. 시리즈의 이름으로 봤을 때 제품별 잔류오염도를 차트에서 표현하고 있으며, A 제품의 잔류 오염도 수치는 9.2, B 제품은 11.4, C 제품은 16.7이라는 것을 간략하게 확인할 수 있습니다. 위와 같은 방식으로 파워포인트에 포함된 차트를 읽어올 수 있습니다. 06-04. 실전! 판매량 데이터를 활용하여 프레젠테이션 자료 자동 생성하기 엑셀 데이터로 파워포인트 만들기 앞에서 학습한 코드를 바탕으로 다른 문서의 데이터를 연동하여 파워포인트 파일을 작성해 보겠습니다. 여기서는 '제품별 판매내역. xlsx'이라는 엑셀 파일의 데이터를 가지고 와서 파워포인트로 프레젠테이션 자료를 만드는 코드를 학습해 보겠습니다. '제품별 판매내역. xlsx' 파일 실행 화면 엑셀 파일에는 각각 A/B/C 제품 시트가 있고 각 시트에는 1월부터 6월까지 판매량과 판매 금액이 표로 작성되어 있습니다. 이 제품별 판매 내역을 가지고 와서 파워포인트에 제품별로 슬라이드를 만들고, 월별 판매내역이 정리된 표와 월별 판매량을 한눈에 비교할 수 있는 막대 차트를 생성해 보겠습니다. 그리고 전체 제품에 대한 판매 추이도 라인 플롯으로 표현하여 하나의 슬라이드에 추가해 보겠습니다. 다음은 예제 코드와 실제 코드로 생성한 파일의 실행 화면입니다. from openpyxl import load_workbook from pptx import Presentation from pptx.util import Inches from pptx.enum.chart import XL_CHART_TYPE from pptx.chart.data import CategoryChartData # 엑셀 파일에서 데이터 불러오기 wb = load_workbook('제품별 판매내역. xlsx') sheet_names = wb.sheetnames # 파워포인트 객체 생성 prs = Presentation() # 표지 슬라이드 추가 slide_layout = prs.slide_layouts[0] slide = prs.slides.add_slide(slide_layout) slide.shapes.title.text = "상반기 제품별 판매 현황 분석" # 제품별 판매량 데이터를 저장하기 위한 딕셔너리 sales_data = {} # 각 제품별 슬라이드 생성 for sheet_name in sheet_names: sheet = wb[sheet_name] # 제품 전체 판매 데이터 저장 (판매월, 판매량, 판매금액) data = [list(map(str, row)) for row in sheet.iter_rows(values_only=True)] # 제품의 판매량 데이터 저장 sales_data[sheet_name] = [list(map(int, row[1:2])) for row in data[1:]] # 슬라이드 추가 slide_layout = prs.slide_layouts[5] slide = prs.slides.add_slide(slide_layout) slide.shapes.title.text = f"{sheet_name}" # 표 추가 rows, cols = len(data), len(data[0]) table = slide.shapes.add_table(rows+1, cols, Inches(0.3), Inches(2), Inches(4.3), Inches(3.8)).table # "월별 판매 현황" 추가 table.cell(0, 0).text = "월별 판매 현황" table.cell(0, 0).merge(table.cell(0, cols - 1)) # 데이터를 표에 추가 for row_idx, row_val in enumerate(data): for col_idx, val in enumerate(row_val): table.cell(row_idx+1, col_idx).text = str(val) # 차트 데이터 설정 chart_data = CategoryChartData() chart_data.categories = [row[0] for row in data[1:]] chart_data.add_series('상반기 판매량 변화', (row[1] for row in data[1:])) # 차트 추가 x, y, cx, cy = Inches(5), Inches(1.8), Inches(4.5), Inches(4.2) chart = slide.shapes.add_chart(XL_CHART_TYPE.COLUMN_CLUSTERED, x, y, cx, cy, chart_data).chart # 차트 설정 chart.has_legend = False chart.plots[0].has_data_labels = True # 전체 판매 추이 슬라이드 생성 slide_layout = prs.slide_layouts[5] slide = prs.slides.add_slide(slide_layout) slide.shapes.title.text = "제품별 판매 추이" # 전체 판매 추이 차트 데이터 설정 chart_data = CategoryChartData() chart_data.categories = [row[0] for row in data[1:]] for sheet_name, sales in sales_data.items(): chart_data.add_series(sheet_name, (sale[0] for sale in sales)) # 전체 판매 추이 차트 추가 x, y, cx, cy = Inches(1), Inches(2), Inches(8), Inches(4.5) chart = slide.shapes.add_chart(XL_CHART_TYPE.LINE, x, y, cx, cy, chart_data).chart # 차트 설정 chart.has_legend = True chart.legend.include_in_layout = False chart.category_axis.has_major_gridlines = False # 마지막 슬라이드 추가 slide_layout = prs.slide_layouts[0] slide = prs.slides.add_slide(slide_layout) slide.shapes.title.text = "감사합니다." # 결과 저장 prs.save('상반기_제품별_판매 현황_분석. pptx') '상반기_제품별_판매 현황_분석. pptx' 파일 실행 화면 엑셀과 파워포인트 두 가지 응용프로그램을 사용하고, 파워포인트에 표, 차트 등 여러 객체를 추가했기 때문에 코드가 비교적 길고 복잡합니다. 위의 실행 코드를 자세히 나눠서 살펴보겠습니다. 1) 필요한 모듈과 클래스 불러오기 from openpyxl import load_workbook from pptx import Presentation from pptx.util import Inches from pptx.enum.chart import XL_CHART_TYPE from pptx.chart.data import CategoryChartData 엑셀 파일에서 데이터를 가져오기 위한 openpyxl 라이브러리와 파워포인트 파일 작업을 위한 python-pptx 라이브러리를 불러옵니다. 파워포인트에서 객체의 크기를 인치로 지정하기 위해 필요한 유틸리티 함수 Inches와 차트의 유형(XL_CHART_TYPE)을 선택할 수 있는 열거형, 차트에 데이터를 추가할 수 있게 해주는 CategoryChartData 클래스를 추가로 불러옵니다. 2) 엑셀 데이터 불러오기 & 파워포인트 객체 생성하기 # 엑셀 파일에서 데이터 불러오기 wb = load_workbook('제품별 판매내역. xlsx') sheet_names = wb.sheetnames # 파워포인트 객체 생성 prs = Presentation() # 표지 슬라이드 추가 slide_layout = prs.slide_layouts[0] slide = prs.slides.add_slide(slide_layout) slide.shapes.title.text = "상반기 제품별 판매 현황 분석" 먼저 엑셀 파일에서 데이터를 가져오기 위해 load_workbook으로 엑셀 파일을 불러옵니다. 이 예제에서는 엑셀 파일에 여러 시트가 존재하고 시트별로 모든 데이터를 사용할 예정이기 때문에 wb.sheetnames로 전체 시트명을 가지고 와서 sheet_names 변수에 할당합니다. 새 파워포인트를 만들기 위해 Presentation()으로 파워포인트 객체를 생성하고 표지 슬라이드를 추가합니다. 본 예제에서는 표지에 제목 텍스트만 넣기 위해 슬라이드 레이아웃 중 첫 번째 레이아웃(prs.slide_layouts[0])으로 지정하여 prs.slides.add_slide(slide_layout)로 슬라이드를 추가하였습니다. 그다음 제목 텍스트를 추가하기 위해 slide.shapes.title.text를 사용하여 "상반기 제품별 판매 현황 분석"이라는 텍스트를 입력하였습니다. 3) 판매량 데이터 가져오기 - 1 (빈 딕셔너리 생성과 엑셀 전체 시트 순회하기) # 제품별 판매량 데이터를 저장하기 위한 딕셔너리 sales_data = {} # 엑셀 전체 시트를 순회 for sheet_name in sheet_names: sheet = wb[sheet_name] 가저온 엑셀 파일에서 제품별로 데이터를 추출하여 딕셔너리 형태로 저장하기 위해 빈 딕셔너리 {}를 생성하여 sales_data 변수에 할당합니다. 엑셀 파일에는 제품별로 시트가 나누어져 있으며 파워포인트도 제품별로 각각의 슬라이드를 생성하기 때문에, 하나의 시트에서 데이터를 불러오는 것부터 슬라이드를 생성하기까지를 하나의 과정으로 보면 총 세 번의 과정을 거쳐야 합니다. 이 세 번의 과정은 시트 데이터만 달라질 뿐 과정 자체는 모두 동일하기 때문에 for 문으로 반복할 수 있습니다. for sheet_name in sheet_names:로 전체 시트명 리스트에서 각 시트 이름을 순회하여 sheet_name 변수에 할당합니다. sheet = wb[sheet_name]로 현재 순회 중인 시트명을 사용하여 워크북('wb')에서 해당 시트를 가져옵니다. 4) 판매량 데이터 가져오기 - 2 (엑셀 시트별 전체 데이터 이중 리스트로 저장하기) # 제품 전체 판매 데이터 저장 (판매월, 판매량, 판매금액) data = [list(map(str, row)) for row in sheet.iter_rows(values_only=True)] 이 라인에서는 iter_rows로 현재 시트의 모든 행을 순회하며 각 행의 각 셀 값을 문자열로 변환합니다. map(str, row) 코드는 row의 각 요소에 str 함수(문자열 변환 함수)를 적용합니다. 그런 다음 list() 함수를 사용하여 결과 map 객체를 리스트로 변환합니다. 이렇게 변환된 리스트를 감싸는 더 큰 리스트(이중 리스트)를 만들기 위해 리스트 조건제시법(list comprehension)을 사용합니다. 그리고 시트에서 행을 순회할 때 수식이 있을 경우 수식이 계산된 후의 값을 가지고 오게 하기 위해 values_only=True를 설정합니다. 이렇게 가져온 행별 데이터 이중 리스트는 data 변수에 할당하였으며, 뒤에 만들 제품별 슬라이드에서 표와 막대 차트의 데이터로 사용할 예정입니다. A 제품 시트를 순회 후 print(data) 실행한 결괏값 [['판매월', '판매량', '판매금액'], ['1월', '70', '140000'], ['2월', '65', '130000'], ['3월', '80', '160000'], ['4월', '75', '150000'], ['5월', '82', '164000'], ['6월', '73', '146000']] 이해를 돕기 위해 data 변수를 출력한 결과를 보여드립니다. 위에서 출력된 이중 리스트는 'A 제품'시트를 순회하여 가지고 온 data 변수를 출력하였을 때 콘솔에 반환된 결과입니다. 5) 판매량 데이터 가져오기 - 3 (엑셀 시트별 판매량 데이터만 딕셔너리에 저장하기) # 제품의 판매량 데이터 저장 sales_data[sheet_name] = [list(map(int, row[1:2])) for row in data[1:]] 이 라인에서는 각 행의 두 번째 열(인덱스 1)의 값을 정수로 변환하여 새로운 이중 리스트를 생성하고, 제품명을 키로 하는 딕셔너리에 저장합니다. 여기에서도 리스트 조건제시법(list comprehension)이 사용되었습니다. data[1:]로 바로 위 줄의 코드를 통해 생성한 data 리스트에서 헤더 행인 첫 번째 행(인덱스 0)을 제외한 모든 행을 가져옵니다. 이렇게 가져온 모든 행을 for 문으로 순회하며 각 row에 대해 연산을 수행합니다. ( for row in data[1:]) row[1:2]로 각 row에서 두 번째 요소만을 가져옵니다. 앞에 문법 부분에서 학습한 것처럼, 파이썬에서 list[a:b]는 리스트에서 a 인덱스부터 b-1 인덱스까지의 부분을 가져오는데, 여기서는 1부터 2미만이므로 실제로는 1번 인덱스만 가져오게 됩니다. 하지만 결과는 리스트 형태로 반환되므로 원소가 하나인 리스트를 얻게 됩니다. map 함수로 row[1:2]로 얻은 하나의 원소를 갖는 리스트에 int 함수를 적용하여 해당 원소(문자열)를 정수로 변환합니다. 그리고 이렇게 반환한 맵 객체를 다시 리스트로 변환(list()) 하여 원소 하나를 갖는 리스트를 얻습니다. 이러한 과정을 data 리스트의 첫 행을 제외한 모든 행을 순회하며 수행한 다음, 그 결과를 담은 이중 리스트를 생성합니다. 그러면 결과적으로 1열에 있던 판매량 데이터가 정수 형태의 리스트로 변환되어 저장됩니다. 그리고 마지막으로 이렇게 생성된 이중 리스트를 sales_data 딕셔너리에 현재 처리 중인 시트명, 즉, 제품명을 키로 사용하여 저장합니다. 이렇게 하면 각 시트의 판매량 데이터를 각 값이 정수인 이중 리스트로 변환하여 sales_data 딕셔너리에 저장하는 과정이 완료됩니다. 결과적으로 sales_data 딕셔너리는 각 제품명이 키이고 판매량 데이터 리스트를 값으로 하는 항목들로 채워집니다. 전체 시트 순회 후 최종 생성된 딕셔너리를 print(sales_data)로 출력한 결괏값 {'A 제품': [[70], [65], [80], [75], [82], [73]], 'B 제품': [[40], [48], [45], [42], [34], [37]], 'C 제품': [[33], [50], [44], [53], [62], [48]]} for 문으로 전체 시트를 모두 순회한 후 최종 생성된 sales_data 딕셔너리를 print()로 출력한다면 위와 같이 반환될 것입니다. 이렇게 딕셔너리 형태로 저장하는 이유는 뒤에 5번째 슬라이드에서 이 딕셔너리로 제품별 판매량 변화 추이를 라인 차트로 만들기 위함입니다. 6) 제품별 슬라이드 추가하고 표 생성하기 # 슬라이드 추가 slide_layout = prs.slide_layouts[5] slide = prs.slides.add_slide(slide_layout) slide.shapes.title.text = f"{sheet_name}" # 표 추가 rows, cols = len(data), len(data[0]) table = slide.shapes.add_table(rows+1, cols, Inches(0.3), Inches(2), Inches(4.3), Inches(3.8)).table 제품별 슬라이드를 추가합니다. 슬라이드 레이아웃 리스트 중 6번째 레이아웃으로 선택하였습니다. 시트명(sheet_name)을 가져와서 슬라이드의 제목으로 입력합니다. 현재 선택된 제품(시트명)에 해당하는 판매 데이터를 표로 입력하기 위해 표를 먼저 생성합니다. 위에서 판매 데이터를 행별로 가지고 와서 data에 이중 리스트로 저장하였기 때문에 행의 수는 data의 길이(len)로 지정하고, 열은 data의 첫 번째 원소의 길이로 지정합니다. data의 첫 번째 원소는 원본 시트의 첫 번째 행, 즉 헤더 행이 리스트 형태로 저장되어 있기 때문에 헤더 행의 길이로 열의 개수를 지정할 수 있습니다. 그리고 이렇게 지정한 행과 열의 개수와 표의 크기 및 위치의 값을 전달하여 add_table로 표를 추가합니다. 이때 행의 개수가 rows+1로 행이 하나 더 추가되었는데 그 이유는 바로 다음 코드 라인에 나오듯 표의 첫 행에 표의 제목을 넣어주기 위함입니다. 7) 생성된 표에 데이터 추가하기 # "월별 판매 현황" 추가 table.cell(0, 0).text = "월별 판매 현황" table.cell(0, 0).merge(table.cell(0, cols - 1)) # 데이터를 표에 추가 for row_idx, row_val in enumerate(data): for col_idx, val in enumerate(row_val): table.cell(row_idx+1, col_idx).text = str(val) 슬라이드에 생성된 표의 첫 번째 셀(0, 0)에 "월별 판매 현황"이라는 텍스트를 추가합니다. 그리고 행의 모든 셀을 병합합니다. 셀을 병합할 때는 table.cell()로 병합을 시작할 셀과 끝낼 셀을 각각 참조합니다. 여기서는 첫 행의 첫 열에 위치한 셀(table.cell(0, 0))부터 첫 행의 마지막 열(table.cell(0, cols - 1))까지 병합합니다. 마지막 열의 인덱스를 숫자로 직접 입력할 수도 있지만 위와 같이 'cols - 1'을 사용할 수도 있습니다. 그리고. merge(...) 메서드를 사용하는데 이 메서드는 병합을 시작할 셀 객체에서 호출되고 그 인자로 병합될 마지막 셀 객체를 받습니다. 그 결과 시작 셀과 마지막 셀 사이에 있는 모든 셀을 병합하여 하나의 큰 셀을 만듭니다. 텍스트가 입력된 표의 첫 행을 제외하고, 표의 두 번째 행부터 마지막 행까지 데이터를 입력합니다. 이중 for 문으로 행과 열을 순회하며 data의 원소를 표에 넣어줍니다. 넣을 때는 str로 모든 데이터를 문자열로 반환하여 입력합니다. 8) 차트 데이터 설정하기 # 차트 데이터 설정 chart_data = CategoryChartData() chart_data.categories = [row[0] for row in data[1:]] chart_data.add_series('상반기 판매량 변화', (row[1] for row in data[1:])) 월별 판매량 차트 생성을 위해 차트에 사용할 데이터를 먼저 설정합니다. 차트 데이터 정의를 위해 CategoryChartData() 클래스의 인스턴스를 생성하여 chart_data라는 변수에 할당합니다. 다음으로는 chart_data.categories를 사용하여 카테고리를 설정합니다. 차트에는 값 데이터만 필요하기 때문에 data 리스트의 첫 번째 행(헤더행)을 제외한 나머지 행을 순회하며 각 행의 첫 번째 열의 값을 가져옵니다. 여기서 첫 번째 열은 판매월을 가리키며, 월별 데이터를 차트에 표현하기 위해 x 축의 값으로 각 판매월을 설정하였습니다. 그다음으로는 add_series 메서드로 시리즈를 추가합니다. add_series는 두 개의 인자를 받는데 첫 번째 인자는 시리즈의 이름이며 두 번째의 인자는 데이터 시리즈의 값들(리스트, 튜플, 제너레이터 등 반복 가능한 객체)입니다. 여기서는 제너레이터(generator expression)을 사용해 data 리스트의 두 번째 행부터 모든 행을 순회하며 두 번째 열의 값(=판매량)을 가져와 데이터 시리즈를 생성합니다. 제너레이터는 리스트, 세트, 딕셔너리 등 순회 가능한 객체를 생성해 주는 함수로, 쉽게 말하면 리스트 조건제시법(list comprehension)과 비슷하지만 대괄호 [] 대신 괄호 ()를 사용한다고 이해하면 됩니다. 여기서도 순회 가능한 시리즈 값들을 만들기 위해 제너레이터를 사용하였습니다. 9) 막대 차트 추가하고 차트 설정하기 # 차트 추가 x, y, cx, cy = Inches(5), Inches(1.8), Inches(4.5), Inches(4.2) chart = slide.shapes.add_chart(XL_CHART_TYPE.COLUMN_CLUSTERED, x, y, cx, cy, chart_data).chart # 차트 설정 chart.has_legend = False chart.plots[0].has_data_labels = True 이제 슬라이드에 차트를 추가합니다. 먼저 x와 y로 차트의 위치를, cx와 cy로 차트의 너비와 높이를 인치 단위로 설정합니다. 그다음 add_chart 메 서드에 차트의 유형, 위치, 크기, 그리고 차트 데이터를 전달하여 차트를 생성합니다. 예제 코드에서는 XL_CHART_TYPE.COLUMN_CLUSTERED로 수직 막대 차트를 선택하였습니다. 이어서 차트의 위치와 크기의 값을 설정한 x, y, cx, cy 변수를 차례로 전달하고, 마지막으로 차트 데이터를 담고 있는 chart_data 변수를 전달합니다. 그리고 끝에. chart 속성을 사용하여 차트 객체를 가져옵니다. chart.has_legend를 False로 설정하여 차트의 범례(legend)를 숨깁니다. 그리고 chart.plots[0].has_data_labels를 True로 설정하여 첫 번째 플롯의 데이터 레이블을 활성화하여 차트 상에 각 데이터 포인트의 값을 표시합니다. 11) 슬라이드 추가하기 & 라인 차트 추가를 위한 데이터 설정하기 # 전체 판매 추이 슬라이드 생성 slide_layout = prs.slide_layouts[5] slide = prs.slides.add_slide(slide_layout) slide.shapes.title.text = "제품별 판매 추이" # 전체 판매 추이 차트 데이터 설정 chart_data = CategoryChartData() chart_data.categories = [row[0] for row in data[1:]] for sheet_name, sales in sales_data.items(): chart_data.add_series(sheet_name, (sale[0] for sale in sales)) 이번에는 전체 제품들의 판매량 데이터를 가지고 판매 추이를 비교하여 볼 수 있는 라인 차트를 생성합니다. 차트를 삽입할 슬라이드를 먼저 추가하고 "제품별 판매 추이"라는 타이틀을 입력합니다. 여기서도 차트 데이터를 설정하기 위해 CategoryChartData() 클래스를 사용합니다. 그리고 동일하게 판매월을 카테고리로 설정하기 위해 data 리스트의 첫 번째 열을 가져옵니다. 마찬가지로 헤더행은 제외합니다. 다음 라인에서는 sales_data.items()를 사용하여 딕셔너리의 키와 값에 해당하는 각 시트명(=제품명)과 판매량 데이터(sales) 쌍을 반복문에서 사용합니다. add_series 메서드를 호출하여 각 제품의 판매량 데이터를 차트에 시리즈로 추가합니다. 시리즈의 이름은 시트명(=제품명)이고 값은 각 월의 판매량(sales[0])으로 설정합니다. 12) 라인 차트 추가하기 & 차트 설정하기 # 전체 판매 추이 차트 추가 x, y, cx, cy = Inches(1), Inches(2), Inches(8), Inches(4.5) chart = slide.shapes.add_chart(XL_CHART_TYPE.LINE, x, y, cx, cy, chart_data).chart # 차트 설정 chart.has_legend = True chart.legend.include_in_layout = False chart.category_axis.has_major_gridlines = False 슬라이드에 삽입할 차트의 위치와 크기를 설정하고, add_chart로 차트를 생성합니다. 이번에는 XL_CHART_TYPE.LINE으로 라인 차트를 선택하였고, 위의 막대 차트를 생성할 때와 마찬가지로 차트의 유형, 위치, 크기, 그리고 차트 데이터를 순서대로 add_chart에 전달합니다. 끝에는. chart로 차트 객체를 가져옵니다. 라인 차트에 표시된 라인이 총 3개이므로 각 라인이 무엇을 나타내는지 한눈에 알 수 있도록 chart.has_legend = True로 범례(legend)를 표시하도록 설정합니다. chart.legend.include_in_layout = False는 범례가 차트 레이아웃의 일부로 포함되지 않도록 설정하는 코드로, 차트와 범례가 서로 겹치지 않도록 설정합니다. 마지막 차트 설정은 chart.category_axis.has_major_gridlines = False로 x축(카테고리 축)의 주요 그리드 라인을 표시하지 않도록 설정했습니다. 13) 마지막 슬라이드 추가하기 & 파일로 저장하기 # 마지막 슬라이드 추가 slide_layout = prs.slide_layouts[0] slide = prs.slides.add_slide(slide_layout) slide.shapes.title.text = "감사합니다." # 결과 저장 prs.save('상반기_제품별_판매 현황_분석. pptx') 마지막 슬라이드를 추가하여 텍스트를 입력한 후, 최종 파일을 '상반기_제품별_판매 현황_분석. pptx'로 디렉터리에 저장합니다. 06-05. 응용! 파워포인트 프레젠테이션으로<NAME>상 자동 생성하기 이번에는 앞에서 배운 기본 파워포인트 사용법을 활용하여 만든 파워포인트 프레젠테이션을 파이썬에서 자동으로<NAME>상으로 저장하는 방법을 학습해 보겠습니다. 파워포인트로<NAME>상 만들기(win32) 지금까지 우리가 파워포인트를 다룰 때 주로 사용한 python-pptx 라이브러리는 파워포인트를<NAME>상으로 직접 변환하는 기능을 제공하지 않습니다. 대신 pywin32라이브러리를 통해 파워포인트 프레젠테이션을<NAME>상으로 내보낼 수 있습니다. pywin32는 Windows 운영 체제에서 동작하는 프로그램을 파이썬 언어로 쉽게 작성할 수 있도록 도와주는 도구 패키지입니다. 이 패키지는 Windows의 특정 기능들을 파이썬에서 사용할 수 있게 해주는 여러 모듈과 라이브러리를 포함하고 있습니다. Windows 관리 도구에 접근하거나 그래픽 사용자 인터페이스(GUI)를 조작하는 등 다양한 기능을 제공하며, 우리가 여기서 사용할 COM 객체를 다루는 기능도 포함하고 있습니다. COM 객체는 마이크로소프트의 프로그래밍 모델로, 이를 통해 MS Office 애플리케이션들(Word, Excel, Powerpoint 등)을 파이썬으로 조작할 수 있습니다. 여기서는 pywin32를 이용한 파워포인트의 영상 자동화 부분에 초점을 두고 학습해 보겠습니다. 먼저 pip 명령으로 pywin32패키지를 설치합니다. pip install pywin32 그러면 설치한 pywin32를 이용하여 파워포인트를<NAME>상으로 변환하는 방법을 알아보겠습니다. 예제에서는 아래의 이미지와 같이 'makevideo.pptx'라는 파워포인트 프레젠테이션을<NAME>상으로 변환해 보겠습니다. 본 프레젠테이션은 총 12개의 슬라이드로 구성되어 있습니다. 먼저 win32com.client를 불러와야 합니다. win32com.client는 pywin32 패키지의 일부로, 앞서 설명한 것처럼 윈도의 COM 객체를 파이썬에서 생성하고 액세스하는 데 사용되는 모듈입니다. win32com.client로 파일을<NAME>상으로 변환하는 예제 코드는 다음과 같습니다. import win32com.client # 파워포인트 열기 powerpoint = win32com.client.Dispatch("PowerPoint.Application") # 파워포인트 프레젠테이션 불러오기 presentation_path = r"C:\\users\2023\makevideo.pptx" presentation = powerpoint.Presentations.Open(presentation_path, WithWindow=False) # 프레젠테이션을<NAME>상으로 내보내기 powerpoint.Presentations(1).CreateVideo( FileName="C:\\users\2023\makevideo.mp4", UseTimingsAndNarrations=True, DefaultSlideDuration=2, Quality=85, VertResolution=1080, FramesPerSecond=30, ) # 파워포인트 닫기 powerpoint.Quit() 먼저 win32com.client.Dispatch 함수로 파워포인트 응용프로그램을 시작합니다. 그다음<NAME>상 변환에 사용할 파워포인트 프레젠테이션을 powerpoint.Presentations.Open(presentation_path, WithWindow=False)으로 열어줍니다. 여기서 WithWindow 옵션은 파워포인트 창을 활성화할 것인지를 결정하는 옵션입니다. True로 할 경우에는 창이 띄워져서 우리도 직접 확인할 수 있으며, False로 할 경우에는 창이 비활성화된 상태에서 작업을 진행합니다. powerpoint.Presentations(1)로 열려있는 첫 번째 프레젠테이션에 접근합니다. 그리고 CreativeVideo 메 서드를 사용하여 해당 프레젠테이션을<NAME>상 파일로 변환하고 'FileName'으로 전달한 지정 경로와 파일명으로 파일을 저장합니다. 이때 여러 매개변수를 사용하여<NAME>상 변환 옵션을 설정할 수 있습니다. 위의 예제 코드에서 사용한 몇 가지 옵션들을 살펴보겠습니다. UseTimingsAndNarrations=True는 슬라이드 쇼에서 설정한 타이밍과 내레이션을<NAME>상에 포함하여 저장할 수 있습니다. 다시 말해, 각 슬라이드에 설정된 전환 시간과 오디오 설명 등이 그대로<NAME>상에 반영됩니다. 이 옵션을 False로 설정하면, 슬라이드 쇼 타이밍과 내레이션은<NAME>상에 포함되지 않으며 기본 전환 시간이 사용됩니다. DefaultSlideDuration=2 슬라이드가 표시되는 기본 시간을 지정하는 옵션이며, 값은 초 단위로 지정합니다. 예제 코드에서는 2로 지정하여 2초마다 다음 슬라이드로 넘어가게 설정하였습니다. 3.25초와 같이 소수점으로도 설정 가능합니다. Quality=85<NAME>상의 전반적인 품질을 지정하는 데 사용됩니다. 값은 0부터 100까지의 범위에서 지정할 수 있으며, 높은 값은 높은 품질을 의미합니다. VertResolution=1080은<NAME>상의 수직 해상도를 지정합니다. 해상도를 조절하여<NAME>상의 화질을 설정할 수 있으며 값이 높아질수록 해상도가 높아집니다. 일반적으로 720p, 1080p 등의 값이 사용됩니다. FramesPerSecond=30은<NAME>상의 프레임 속도를 지정합니다. 프레임 속도는 초당 프레임 수(FPS)를 나타내며, 일반적으로 24, 30, 60 등의 값이 사용됩니다. 높은 FPS 값은 더 매끄러운<NAME>상을 생성하지만 파일 크기가 커질 수 있습니다. 동영상 생성이 다 끝난 후에는 powerpoint.Quit()으로 파워포인트를 닫아줍니다. 위의 예제 코드를 활용하여 간단하게 파워포인트 프레젠테이션을 mp4<NAME>상으로 자동 변환할 수 있습니다. 'makevideo.mp4' 파일 실행 화면 캡처 동영상 여러 개 합치기 위와 같이 프레젠테이션을<NAME>상으로 변환한 후에 다른<NAME>상을 이어서 붙일 수 있습니다. 이번에는 'concatvideo.mp4'와 위에서 만든 'makevideo.mp4'를 이어붙여서 하나의<NAME>상 파일로 만들어보겠습니다. pip install moviepy 동영상을 합칠 때에는 파이썬으로<NAME>상을 편집하는 기능을 제공하는 라이브러리인 moviepy를 사용하겠습니다. 따라서 라이브러리 사용을 위해 먼저 위와 같이 pip로 설치한 후 라이브러리를 불러옵니다. from moviepy.editor import * #<NAME>상 불러오기 video1 = VideoFileClip("C:\\users\2023\concatvideo.mp4").without_audio() video2 = VideoFileClip("C:\\users\2023\makevideo.mp4") #<NAME>상 합치기 final_video = concatenate_videoclips([video1, video2], method="compose") # 합친<NAME>상 저장하기 final_video.write_videofile("C:\\users\2023\combined_video.mp4", codec='libx264') 동영상을 합치기 위해 VideoFileClip 함수를 사용하여 원하는 경로에서 두 개의 비디오 클립을 불러옵니다.<NAME>상을 불러올 때 첫 번째<NAME>상 뒤에 붙은 without_audio() 메서드는 비디오 클립의 소리를 제거해 줍니다. 모든 영상을 불러올 때 이 메서드를 사용할 경우, 최종적으로 합쳐진<NAME>상에는 소리가 없게 됩니다. 위에서 불러온 2개의<NAME>상을 concatenate_videoclips([video1, video2], method="compose")로 합쳐줍니다. concatenate_videoclips 함수는 여러 비디오 클립을 리스트로 받아서 하나의 비디오로 합쳐주는 함수로, 여기서는 video1과 video2를 합치기 위해 두 개의 변수를 리스트로 전달합니다. method="compose"는 concatenate_videoclips 함수에서<NAME>상 클립을 합칠 때 사용되는 방식을 지정하는 인자입니다. 기본값은 chain으로 모든 클립이 동일한 크기(동일한 해상도)일 때만 작동합니다. compose는 클립들의 해상도가 다를 경우에는 영상을 합칠 때 그중 가장 큰 클립의 해상도에 맞춥니다. 해상도가 더 작은<NAME>상은 해상도를 맞추기 위해 검은색 배경 위 중앙에 영상이 위치합니다. 모든 영상의 해상도가 동일하다면 method 인자를 생략 가능하며, 다를 경우에는 compose로 지정하여야<NAME>상이 정상적으로 합쳐집니다. 이렇게 합친<NAME>상은 write_videofile 함수로 지정된 경로에 저장합니다. codec 파라미터는<NAME>상 인코딩 방식을 지정하는데, 여기서는 'libx264'를 사용하여 H.264 방식으로 인코딩하도록 지정하였습니다. 해당 경로에서 보면 'concatvideo.mp4'와 'makevideo.mp4'가 연속적으로 합쳐진 'combined_video.mp4' 파일이 생성된 것을 확인할 수 있습니다. 동영상에 배경음악 추가하기 이번에는<NAME>상에 배경음악을 추가해 보겠습니다. 이전 예제에서 만든 영상 파일 "combined_video.mp4"에 "Societys Dream - Mini Vandals.mp3"를 배경음악으로 넣어보겠습니다. "combined_video.mp4"는 총 재생 길이가 48초이며, 배경음악 mp3 파일은 총 길이가 2분 14초입니다. 영상에 배경음악을 넣을 때 음원과 영상의 길이가 많지 않는다면<NAME>상이 끝나도 음악이 계속 재생되거나<NAME>상 재생 도중 음악이 갑자기 멈추는 문제가 생길 수 있습니다. 하지만 파이썬으로<NAME>상의 길이에 맞게 음원을 자르거나 음원을 반복시키도록 할 수 있습니다. 아래의 예제 코드에서 자세히 알아보겠습니다. from moviepy.editor import * #<NAME>상 파일 불러오기 video = VideoFileClip("C:\\users\2023\combined_video.mp4") # 배경 음악 불러오기 background_music = AudioFileClip('C:\\users\2023\Societys Dream - Mini Vandals.mp3') #<NAME>상의 길이에 맞게 배경음악을 자르거나 반복 if background_music.duration > video.duration: background_music = background_music.subclip(0, video.duration) else: background_music = background_music.fx(vfx.audio_loop, duration=video.duration) #<NAME>상에 배경 음악 추가 final_video = video.set_audio(background_music) # 결과<NAME>상 저장 final_video.write_videofile('C:\\users\2023\output_video.mp4', codec='libx264') 먼저 VideoFileClip 함수와 AudioFileClip 함수를 사용하여 원하는 경로에서<NAME>상과 음원을 각각 불러옵니다. 그다음 배경음악의 길이를<NAME>상의 길이에 맞게 조정하는 작업을 합니다. if 문에<NAME>상이나 음원의 길이를 초 단위로 반환하는 duration 속성을 이용하여 부등호('>', '<')로 음원이<NAME>상의 길이보다 긴 경우와 그 반대의 경우를 각각 설정해 줍니다. 음원의 길이가<NAME>상의 길이보다 긴 경우에는 subclip 메 서드를 사용하여<NAME>상의 길이만큼 음원을 잘라줍니다. subclip 메 서드는 추출하려는 클립의 시작 시점과 종료 시점을 인자로 받기 때문에, background_music = background_music.subclip(0, video.duration) 여기서 0은 음원의 가장 처음부터 시작해서<NAME>상의 길이(video.duration)까지 자르라는 의미입니다. subclip(1, 49)처럼 직접 원하는 시점을 입력하는 것도 가능합니다. 반대의 경우로 음원이<NAME>상의 길이보다 짧은 경우에는 fx 메 서드와 vfx.audio_loop 함수를 사용하여 배경음악을<NAME>상의 길이만큼 반복시킵니다. fx는 moviepy 라이브러리에서 여러 효과를 적용하기 위한 메서드로, vfx는 video effects를 의미하고 audio_loop는 오디오 클립을 주어진 시간 동안 반복하게 만드는 효과입니다. background_music = background_music.fx(vfx.audio_loop, duration=video.duration) 여기서는 반복하는 시간을<NAME>상의 길이로 설정하였으며, duration=48과 같이 원하는 지속 시간을 초 단위로 직접 입력할 수도 있습니다. 이렇게 길이를 동일하게 설정 완료한 음원을 set_audio 메 서드를 사용해<NAME>상에 넣어줍니다. 그리고 작업이 끝난 영상을 write_videofile 함수로 지정된 경로에 저장합니다. 이와 같이 위의 코드를 활용하여 별도의 번거로운 음원 편집 작업 없이 파이썬으로 간편하게 음원의 길이를 편집하여<NAME>상에 음원을 추가할 수 있습니다. 07. 데이터 분석 이 챕터에서는 판다스(Pandas)라는 라이브러리를 활용한 데이터 분석에 대해 학습하겠습니다. 데이터 분석은 주어진 데이터를 통해 유용한 정보와 의미를 찾아내는 과정을 말합니다. 예를 들어, 어떤 상품의 판매 데이터를 분석한다면 그 상품의 판매량이 어느 시기에 높아지는지, 어떤 요인들이 판매량에 영향을 미치는지 등의 인사이트를 얻을 수 있습니다. 이렇게 얻은 정보는 재고 관리, 마케팅 전략 등의 업무에 활용할 수 있습니다. 판다스는 파이썬에서 데이터를 쉽게 다룰 수 있게 해주는 라이브러리입니다. 판다스는 다양한 데이터<NAME>을 지원하며 데이터 정제나 변환, 집계, 그리고 통계 분석 등 데이터 분석의 전 과정에 필요한 다양한 기능들을 제공합니다. 또한 다른 시각화 라이브러리와의 호환성이 좋아 데이터를 분석하며 시각화도 쉽게 할 수 있습니다. 이러한 많은 장점으로 인해 판다스는 데이터 분석에 있어 필수적인 라이브러리로 여겨지고 있습니다. 여기서는 판다스의 기본 사용법부터 실무에 활용하는 예까지 함께 학습해 보겠습니다. 실제 업무에서 사용되는 크고 복잡한 데이터로 학습하기 위해 이번 챕터에서는 공공데이터의 자료를 가지고 학습을 진행하겠습니다.<|endoftext|>

전문분야 텍스트 ### 제목: 통계학 -SPSS를 사용하여- ### 본문: SPSS 사용방법 소개 01. 데이터 다루기 데이터 다루기 데이터 입력, 수정, 분석, 저장 데이터 가져오기 텍스트 파일 불러오기 가중치 설정 1. 데이터 가져오고 변경하기 SPSS 데이터 파일은 확장자가. SAV 파일이다. 이 파일은 여기에서 다운로드한다. 이 파일을 클릭하면 SPSS가 실행되고 파일이 열린다. 데이터 보기 시트 데이터 보기(Data View) 시트는 사용자가 직접 자료를 입력, 수정 및 삭제를 할 수 있다. 변수 보기 시트 변수 보기(Variable View) 시트에서 변수에 대하여 이름은 변수명을 입력하는 것으로 변수명은 첫 번째 글자는 반드시 문자이어야 하고, 특수문자는 삽입할 수 없고(_ , $ 제외), 숫자는 첫 글자는 제외하고 사용할 수 있다. 유형은 변수의 데이터 타입을 설정하는 것으로 숫자, 문자, 날짜 등이 있다. 너비는 데이터 보기의 각 변수에 값이 들어갈 데이터의 크기를 설정하는 것으로 한글은 한 문자를 2로 영어는 한 문자를 1로 여긴다. 소수점 이하 자리는 원 자료에 대하여 보이는 소수점 자릿수로 유효하지 않은 숫자는 0으로 표시한다. 설명은 변수에 대하여 설명을 길게 할 수 있는 것으로 이름에 변수 이름을 설정하는 것과 다르게 제약 없이 어떠한 문자도 입력이 가능하다. 통계분석 출력 결과에 설명이 있으면 이름값은 출력되지 않고 설명이 출력된다. 값 이산형, 범주형 자료인 경우 데이터 보기에 숫자로 입력하고, 여기서 숫자에 대응하는 값에 대하여 설명을 삽입할 수 있다. 문자가 원 자료에 저장된 경우 일부 분석에서 제약사항이 있기 때문에 분석이 불가능하므로 이 기능을 사용하는 것을 권장한다. 결측값 설정은 한 값, 또는 범위로 설정할 수 있다. 열은 데이터 보기에서 보이는 열의 너비이다. 맞춤은 정열의 방법을 설정한다. 기본적으로 문자는 왼쪽, 숫자는 오른쪽에 정열 된다. 측도은 자료의 형태가 척도형, 명목형, 순위형 중 선택한다. 변수 계산 변수 계산은 이미 있는 변수들과 연산하여 새로운 변수를 만든다. 아래의 화면은 "변환(Transform) ->변수 계산(Compute)" 메뉴를 선택하였다. 대상 변수(Targer Variable)에 BMI, 숫자 표현식(Numeric Expression)에 bmi(body mass index, 체질량지수) = g 2 를 변수와 제곱 승 등을 이용하여 아래 그림과 같이 입력한다. 키보드로 직접 입력하면 오타가 발생할 수 있으므로 마우스를 사용하는 것을 권한다. 변수 계산 결과 확인 생성된 변수를 테이터 보기(Data Variable) 시트에서 다음 그림과 확인할 수 있다. 코딩 변경 코딩 변경은 기존에 있는 변수를 몇 개의 범주로 나누어 새로운 변수를 만든다. 코딩 변경은 다음과 같이 두 가지가 있다. 같은 변수로 코딩 변경(Into Same Variables) : 기존에 존재하는 변수의 값이 변경하는 변수로 변함. 기존에 존재하는 변숫값은 사라짐 다른 변수로 코딩 변경(Into Different Variables) : 기존에 존재하는 변숫값을 이용하여 새로운 변숫값 생성 다음은 다른 변수로 코딩 변경하는 과정이다. "변환(Transform)->다른 변수로 코딩 변경(Into Different Variables)" 메뉴를 선택한다. bmi 변수를 선택하고 버튼을 누르면 변경할 변수가 추가되고 출력 변수(Output Variable)에 바뀔 이름을 입력한 후 "바꾸기(Change)" 버튼을 누른다. "기존 값 및 새로운 값(Old and New Values)" 버튼을 누르면 기존에 존재하는 변수(bmi)에 여러 조건을 입력하여 새로운 변수를 생성할 수 있다. 조건을 주는 과정은 다음 화면에 있다. 기존 값 및 새로운 값 BMI 변수를 범위에 따라 6개 등급으로 나누는 과정이다. 이 화면에서 bmi 변수는 최솟값에서 18.5는 1 18.5에서 23 은 2 23에서 25는 3 25에서 30 은 4 30에서 35는 5 35에서 최댓값까지는 6 으로 변경하려고 한다. 등급으로 나누는 과정은 "기존 값(Old Value)->범위(Range)"를 선택 "범위(Range)->최젓값에서 다음 값까지 범위(Lowest through)" 입력창에 "18.5"를 입력 "새로운 값(New Value)->기준값(Value)"을 선택하고 1을 입력 "추가(Add)" 버튼을 누른다. 이고 각 범주에 대하여 동일한 과정을 거치면 연속형 자료를 범주형 자료로 변환하여 새로운 변수를 생성할 수 있다. 코딩 변경 결과 확인 기존에 존재하는 변수에서 새로운 변수로 자료를 생성한 결과이다. 변숫값 설명 - 변수 보기 시트에서 이름이 등급인 레코드(행)에서 값 필드(열)이 교차하는 없음의 버튼을 누른다. 생성된 등급 변수는 1에서 6으로 분류하여 저장되었으며 이 값들은 각각 1 은 저체중 2는 정상 3 은 과체중 4는 1 단계 비만 5는 2 단계 비만 6 은 3 단계 비만 으로 통계분석 결과에서 출력되도록 설정하려면 다음 그림과 같다. SPSS 명령 코드 * Encoding: UTF-8. COMPUTE bmi=Weight / (Height / 100) ** 2. EXECUTE. RECODE bmi (Lowest thru 18.5=1) (18.5 thru 23=2) (23 thru 25=3) (25 thru 30=4) (30 thru 35=5) (35 thru Highest=6) INTO 등급. EXECUTE. VALUE LABELS 등급 1 "저체중" 2 "정상" 3 "과체중" 4 " 1단계 비만" 5 " 2단계 비만" 6 " 3단계 비만". 2. 텍스트 파일 불러오기 SPSS 데이터 파일(확장자. SAV)이 아닌 외부 데이터를 불러오는 과정에 대하여 알아보자. 그림과 같이 "파일(File)->열기(Open)->데이터(Data)" 메뉴를 선택한다. 여기서 사용한 자료는 여기에서 구할 수 있다. 불러올 파일이 있는 폴더로 이동한다. "파일<NAME>"을 "모든 파일"로 바꾸어 모든 파일 중에서 외부 데이터가 보이도록 한다. 해당 파일을 선택한 후 "열기" 버튼을 누른다. 텍스트 가져오기 마법사 "텍스트 가져오기 마법사 6단계 중 1단계(Text Import Wizard)" 화면이 보인다. 설정값을 변경하지 말고 "다음" 버튼을 누른다. "텍스트 가져오기 마법사 2단계(Text Import Wizard)"에서는 SPSS 셀에 들어갈 자료를 공백이나 탭 등 구분자로 할 것인가 한 셀에 들어갈 자료의 크기를 "구분자에 의한 배열(Delimited)" "고정 너비로 배열(Fixed Width)" 중 하나를 선택하고, 불러들일 파일의 첫 행에 변수의 이름이 있는지 선택한다. 설정값을 변경하지 말고 "다음" 버튼을 누른다. 구분자에 의한 배열(Delimited)을 선택한 경우 "텍스트 가져오기 마법사 3단계(Text Import Wizard)"에서는 몇 줄부터 몇 줄까지 자료를 가져올 것인지 설정하는 단계이다. 설정값을 변경하지 않고 "다음" 버튼을 누른다. "텍스트 가져오기 마법사 4단계(Text Import Wizard)"에서는 구분자를 설정하는 단계이다. 각 변수를 구분할 구분자는 여러 개를 지정해도 된다. 설정값을 변경하지 말고 "다음" 버튼을 누른다. "텍스트 가져오기 마법사 5단계(Text Import Wizard)"에서는 "변수 이름(Variable Name)"과 "데이터<NAME>(Data Format)"을 지정하는 단계이다. 그 이전 단계에서 이미 지정되어야만 이 단계에서 설정을 할 수 있다. 설정값을 변경하지 않고 "다음" 버튼을 누른다. "텍스트 가져오기 마법사 6단계(Text Import Wizard)"에서는 불러온 파일을 저장할 것인지 설정하고, SPSS 스크립트를 삽입할 것인지 설정하는 단계이다. 설정값을 변경하지 않고 "마침" 버튼을 누른다. 텍스트 데이터 가져오기를 마치면 다음과 같은 화면이 나타난다. SPSS 파일<NAME>으로 저장 불러온 파일을 SPSS 데이터<NAME>(확장자. SAV)로 저장한다. 변수 보기 시트에서 범주형 자료값에 레이블 추가 "변수 보기(Variable View)" 시트에서 이름에 변수명을 "키", "몸무게", "출생연도", "종교", "성별", "결혼 여부"로 입력한다. 값에 종교는 1 은 불교, 2는 기독교, 3 은 가톨릭, 4는 없음 성별에 1 은여, 2는 남 결혼 여부에 1 은 기혼, 2는 미혼 으로 설정한다. 변숫값 설명 - 변수에 레이블 입력 변숫값을 설명하는 화면이다. "변수 보기(Variable View)" 시트에서 "값(Value)"을 선택하면 다음과 같은 화면이 나타난다. 여기에 적당한 값을 "추가(Add)" 하고 입력이 완료되면 "확인(OK)" 버튼을 누른다. SPSS 데이터<NAME>으로 저장 불러온 자료의 설정이 완료되면 저장하여 이후에 사용이 가능하도록 특정한 폴더를 선택한 후 SPSS 파일로 저장한다. SPSS 명령 코드 * Encoding: UTF-8. RENAME VARIABLES (V1=키) (V2=몸무게) (V3=출생연도) (V4=종교) (V5=성별) (V6=결혼 여부). VALUE LABELS 종교 1 "불교" 2 "기독교" 3 "가톨릭" 4 "없음". VALUE LABELS 성별 1 "여" 2 "남". VALUE LABELS 결혼 여부 1 "기혼" 2 "미혼". 3. 데이터 입력, 수정, 분석, 저장 SPSS 실행 화면 SPSS를 처음으로 실행한 화면이다. 시트는 데이터 보기와 변수 보기가 있다. 화면은 데이터 보기 시트이다. 변수 보기 시트 변수 보기 시트 초기 화면이다. 변수 보기 시트 선택은 프로그램 아래에서 변수 보기 시트를 마우스로 클릭한다. 자료 입력 데이터 보기 시트에 자료를 입력한다. 자료입력은 반드시 열로 입력한다. 행으로 입력하는 것이 아님에 주의한다. 아래 화면에서 데이터를 입력하면 일어나는 현상 변수에 값을 입력하면 변수명이 자동으로 만들어진다. 소수점 이하 2자리가 자동으로 만들어진다. 문자 입력은 한글 1개 문자와 영어 2개 문자만 입력 가능하다. 문자는 "강원도, 강원도, 경기도, 서울"을 입력했지만 한 문자만 입력되었다. 변수 보기 시트에서 속성값을 변경할 수 있다. 변수 보기 시트 화면 값을 입력한 결과 변수 보기 시트에 변경된 것은 다음과 같다. 이름이 VAR0001로 시작한다 유형이 숫자와 문자로 설정된다. 너비는 자료 입력 범위 설정이다. 열은 화면에서 보이는 열의 너비(width)이다. 변수 보기에서 속성 값 설정 이름은 종교, 신장, 지역으로 변경 문자 변수 너비를 8로 변경 소수점 이하 자릿수를 2에서 0으로 변경 문자 변수 열 너비를 8로 변경 데이터 보기 시트 변수 보기 시트에서 속성 값 변경 결과를 데이터 보기에서 확인 데이터 저장 입력한 데이터를 저장한다. 데이터 저장 입력한 데이터를 SPSS<NAME>으로 저장한다. 데이터 저장할 때 확장자는. SAV이다. 기술통계량 구하기 간단한 분석을 하고 그 출력 결과를 저장하자. 기술 통계 메뉴를 실행한다. 변수 선택 신장을 선택하고 화살표 버튼을 누르면 변수에 신장 변수가 추가된다. 출력 결과 기술 통계 출력 결과이다 출력물은 명령어와 분석 결과이다. 출력 결과 저장 출력 결과 창에서 파일->저장 버튼을 클릭한다. 출력 결과 저장 출력 결과는 저장하고 이후 별도로 실행하면 그 내용을 그대로 사용할 수 있다. 출력 파일 확장자는. SPV이다. 명령문 데이터 프로그램이나 출력 프로그램에 상관없이 새 파일 -> 명령문을 실행한다. 명령문 명령문 실행 화면이다. 출력 결과 출력 결과 프로그램에서 명령문을 복사한다. 명령문은 로그를 눌러도 선택된다. 명령문 명령문 창에 붙여넣기 한다. 명령문 실행 명령문 실행은 명령어를 마우스로 선택하고, 선택영역 실행 버튼을 클릭한다. 출력 결과 명령문 실행 결과는 출력창에서 확인한다. 명령문 명령문 저장은 새 파일 -> 저장을 실행한다. 명령문 명령문 확장자는. SPS이다. 출력 결과 출력 결과는 대부분 표와 그림이며 이것들은 복사하여 다른 응용프르고램에 붙여넣기 할 수 있다. 엑셀에 붙여넣기 SPSS에서 출력한 표를 엑셀에 붙여넣기 하였다. 아래한글에 붙여넣기 SPSS에서 출력한 표를 아래한글에 붙여넣기 하였다. 출력 결과 엑셀파일로 내보내기 내보낼 개체를 Ctrl 키를 누르고 선택한다. 선택된 개체는 노란색으로 표시된다. 내볼낼 개체는 선택, 유형은 Excel 2007 이상, 찾아보기를 누른다. 저장할 폴더와 파일명을 입력한다. 저장할 폴더와 파일명을 확인한다. 저장한 엑셀 파일을 열어 내용을 확인한다. 연습문제 다음 표는 Titanic 자료 일부이다. pclass survived sex age sibsp parch fare 1 1 female 29 0 0 211.3375 1 0 female 2 1 2 151.5500 1 0 male 30 1 2 151.5500 1 0 female 25 1 2 151.5500 1 1 male 48 0 0 26.5500 2 0 male 44 0 0 13.0000 2 1 female 6 0 1 33.0000 2 0 male 28 0 1 33.0000 2 1 male 62 0 0 10.5000 2 0 male 30 0 0 10.5000 2 1 female 7 0 2 26.2500 3 0 female 6 4 2 31.2750 3 0 female 2 4 2 31.2750 3 1 female 17 4 2 7.9250 3 0 female 38 4 2 7.7750 3 0 female 9 4 2 31.2750 3 0 female 11 4 2 31.2750 3 0 male 39 1 5 31.2750 3 1 male 27 0 0 7.7958 3 0 male 26 0 0 7.7750 3 0 female 39 1 5 31.2750 Titanic 1 SPSS에 표에 있는 자료를 입력한다. sex 변수는 숫자로 입력하고 값에서 레이블을 넣는다. 아래 값을 변수명으로 입력하고 pclass, survied 변수는 값에 레이블을 넣는다. pclass: 객실 등급(1=Upper, 2=Middle, 3=Lower) survived 생존 여부(0=죽음, 1=생존) sex: 성별 age:나이 sibsp:같이 탄 형제자매와 배우자 숫자 parch: 같이 탄 부모와 자식 숫자 fare:요금 2 입력한 데이터는 titanic.sav로 저장한다. 3 pclass, survived, sex 변수에 대한 빈도 분석을 한다. 4 pclass, survived, sex 변수에 대한 원그림을 그린다. 5 age, sibsp, parch, fare 변수에 대한 기술 통계를 구한다. 6 출력 결과는 titanic.spv로 저장한다. 7 실행한 명령문은 titanic.sps로 저장한다. 8 titanic.sps 파일에 있는 명령문을 실행한다. 9 빈도 분석, 원그림, 기술 통계를 titanic.xlsx 엑셀파일로 내보낸다. 단 로그 제외 10 만든 4개 파일을 titanic.zip로 압출하여 과제로 제출한다. 4. 가중치 설정 변수에 가중치 설정 범주형 자료인 경우 자료값이 여러 번 반복되는 경우가 있다. 그 예로 어떤 여론 조사에서 찬성과 반대를 묻는 경우, 그 값은 여러 번 반복되어 조사될 것이다. 이런 경우 요약된 값으로 즉, 찬성이 몇 명이고 반대가 몇 명으로 입력하는 것이 가중치 설정이다. 자료 입력 각 셀에 값을 화면과 같이 입력한다. 이름 변경과 값 추가 변수 보기 시트에서 이름값을 성별, 인원으로 변경하고 성별 행과 값 열이 교차하는 셀에서 버튼을 누른다. 값 레이블 기준값에 데이터 보기 시트에서 입력한 값을 입력하고, 레이블에 결과 출력에서 볼 값을 입력한다. 즉 1은 남자, 2는 여자로 보인다. 값 레이블 값 입력을 마쳤으면 확인 버튼을 누른다. 소수점 이하 자릿수와 값 레이블 소수점 이하 자릿수는 0, 값은 변경한 값이 보인다. 수정을 원하면 값의 버튼을 누른다. 값 레이블 변경 화면 성별에서 1은 남자, 2는 여자로 보인다. 이 화면이 보이지 않으면 표준 도구에서 값 레이블 버튼을 누른다. 빈도 분석 빈도 분석을 실시한다. 빈도 분석에 변수 추가 빈도 분석할 성별 변수를 추가한다. 빈도 적용 안됨 가중치가 적용되지 않아 빈도가 각각 1로 출력된다. 우리가 원하는 것은 100이다. 가중 케이스 메뉴 가중 케이스 메뉴를 실행한다. 가중치 적용할 변수 설정 가중치 적용 변수를 지정한다. 빈도 분석 빈도 분석 메뉴를 실행한다. 가중치 적용한 빈도 분석 가중치가 적용돼 변수를 확인할 수 있다. 5. 데이터 선택 전체 데이터에서 일부만 사용하여 분석할 경우가 있다. 이때 데이터 선택 메뉴를 사용하면 유용하다. 데이터 선택은 아래 그림과 같이 데이터 -> 케이스 선택 메뉴를 선택한다. 실습자료는 여기에서 구한다. 조건을 만족하는 케이스에서 조건 버튼을 누른다. 식 입력 박스에 몸무게가 40 미만이거나 68 초과를 입력한다. 입력할 때 오류를 방지하려면 마우스를 이용한다. 선택된 케이스는 filter_$ 변수에 Selected 값과 함께 표시되고 선택되지 않은 케이스는 filter_$ 변수에 Not Selected 값이 표시되고, 번호에 사선이 표시된다. 6. 실습자료 다음은 성별에 따른 교내 흡연장소에 대한 의견이다. 성별에 따라 흡연장소에 대한 의견 차이가 있는지 알아보려고 조사하였다. SPSS에 자료를 입력하여 교차분석하고 분석 결과를 적는다. 분석은 분석자가 적합하게 행 또는 열에 대한 백분율을 출력하고 자기 의견을 적는다. 성별 흡연장소 설치 합계 너무 많다 적당하다 너무 적다 남자 378 247 21 646 여자 388 186 30 604 합계 766 433 51 1250 교내 흡연장소 의견 여기를 눌러 데이터를 다운로드한다. 첫 행은 변수가 포함되어 있다. 성별 1은 '남자', 2는 '여자'이고 의견 1은 '너무 많다', 2는 '적당하다', 3은 '너무 적다'를 숫자로 입력하였다. 각 변숫값에 레이블을 한다. 이 데이터에 대하여 교차분석으로 분석하고 그 결과를 적는다. 성적에 대한 자료가 여기에 있다. 성적은 출석 10%(10점), 과제 20%(20점), 중간 30%(100점), 기말 40%(100점)이다. 괄호 안 값은 해당 시험에서 득점할 수 있는 최고 점수이다. 총점은 100점으로 환산하고 등급을 A+, A, B+, B, C+, C0, D+, D, F로 나눈다. 02. 그래프 그리기 그래프(Graph) 막대그래프 히스토그램 원그래프 줄기-잎 그림 산점도 상자 그림 1. 막대그래프(barplot) 막대그래프 특성 각 범주에서 도수의 크기를 막대로 그린 그래프로 막대의 길이는 도수나 상대도수의 양이 표현 각 범주 간 도수 비교에 용이 범주형 자료, 이산형 자료, 연속형 자료 모두 가능 연속형 자료보다 범주형 자료, 이산형 자료 표현에 적합 막대그래프 작성 막대그래프를 작성하는 화면이다. 막대그래프 작성에 사용한 자료는 여기에서 구할 수 있다. 메뉴 그래프(G)->레거시 대화 상자->막대 도표(B)(Graphs->Bar)를 선택한다. 막대도표선택 사용자가 그릴 막대 도표를 선택한다. 단순 : 한 변수에 대하여 막대그래프를 작성하는 경우 수평 누적 : 막대그래프를 작성할 변수를 설정하고 다시 수평으로 구분할 변수를 설정하여 그래프를 작성 수직 누적 : 막대그래프를 작성할 변수를 설정하고 다시 수직으로 구분할 변수를 설정하여 그래프를 작성 여기에서는 "수평 누적" 형태의 막대 도표를 그린 경우를 보여준 것이다. "도표에 표시할 데이터"는 "케이스 집단들의 요 약 값" : 각 범주별로 빈도수를 계산하여 막대도표를 작성. "개별 변수의 요 약 값" : 변수를 자료값으로 하여 막대 도표를 작성. "각 케이스의 값" : 이미 계산된 자료값을 막대 도표로 작성. 에서 하나를 선택한다. 변수 설정 "범주축"에 "결혼 여부" 변수를 선택하고, "수평 누적 기준 변수"에 "종교" 변수를 선택한다. 출력 및 결과 완성된 막대도표를 SPSS 뷰어에서 확인할 수 있다. 막대그래프 작성 결과 기혼자가 미혼자에 비해 월등하게 많다. titanic 자료로 막대그래프 작성하는 python code # 필요한 라이브러리 불러오기 import pandas as pd import matplotlib.pyplot as plt # 타이타닉 데이터 셋 불러오기 titanic = pd.read_csv('https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv') #타이타닉 자료에 대한 정보 titanic.info() # 성별에 따른 생존자 수 막대그래프 그리기 survived_by_sex = titanic.groupby('Sex')['Survived'].sum() ax = survived_by_sex.plot(kind='bar', rot=0, color='green') ax.set_xlabel('Sex') ax.set_ylabel('Number of Survivors') plt.show() # 좌석 등급에 따른 생존자 수 막대그래프 그리기 survived_by_class = titanic.groupby('Pclass')['Survived'].sum() ax = survived_by_class.plot(kind='bar', rot=0, color='blue') ax.set_xlabel('Passenger Class') ax.set_ylabel('Number of Survivors') plt.show() # 탑승 항구에 따른 생존자 수 막대그래프 그리기 survived_by_embarked = titanic.groupby('Embarked')['Survived'].sum() ax = survived_by_embarked.plot(kind='bar', rot=0, color='red') ax.set_xlabel('Port of Embarkation') ax.set_ylabel('Number of Survivors') plt.show() # 연령대별 생존자 수 막대그래프 그리기 titanic['AgeGroup'] = pd.cut(titanic['Age'], bins=[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]) survived_by_agegroup = titanic.groupby('AgeGroup')['Survived'].sum() ax = survived_by_agegroup.plot(kind='bar', rot=0, color='purple') ax.set_xlabel('Age Group') ax.set_ylabel('Number of Survivors') plt.show() 2. 히스토그램(histogram) 히스토그램 특성 연속형 자료에서 계급(階級; class)에 대하여 도수나 상대도수를 막대그래프와 유사(似) 한 모양을 그리는 그림 계급(class) : 연속형 자료에서 관측 값을 여러 개의 구간(區間)으로 나눈 것 계급 높이는 상대도수 계급구간의 폭幅 대 수 급 간 폭 ( ) 또는 도수 계급구간의 폭 수 급 간 폭 이다. 계급 높이가 상대도수 계급구간의 폭幅 대 수 급 간 폭 ( ) 이면 모든 면적은 1이다. 각 계급 구간은 길이가 같지 않아도 된다. 연속형 자료에서 용이(容) 하게 사용된다. 가장 적합한 히스토그램은 사용자가 범주의 개수를 변경하면서 여러 히스토그램을 작성하여 자료의 윤곽(廓)을 파악하는데 용이한 히스토그램을 선택한다. 계급 수와 구간이 같더라도 시작점이 다르면 그래프의 전체적인 형태가 변하는 단점(短點)이 있다. 히스토그램 작성 다음은 히스토그램을 작성해 보자. 히스토그램 작성에 사용한 자료는 여기에서 구할 수 있다. 먼저 그림에 보이는 것과 같이 그래프(Graphs)->레거시 대화 상자 -> 히스토그램(Histogram) 메뉴를 선택한다. 변수 설정 히스토그램을 작성할 변수를 선택한다. 선택한 변수를 변수에 추가하고 확인 버튼을 누르면 선택한 변수에 대한 히스토그램이 그려진다. 정규곡선 출력을 선택하면 정규분포 곡선이 히스토그램과 같이 그려진다. 출력 및 결과 편집 기본 설정값으로 작성된 히스토그램이다. 이 그래프를 수정하려면 아래의 그림에 보이는 것과 같이 그림 영역에 마우스를 위치시킨 후 마우스 오른쪽 버튼을 누르고 내용 편집->별도의 창에서 메뉴를 선택하거나 마우스 왼쪽 버튼을 더블 클릭한다. 특성창에서 그래프 편집 그림을 수정할 수 있는 도표 편집기가 열린다. 이 창에서 그래프에 마우스를 위치한 후 마우스 왼쪽 버튼을 클릭하면 그림과 같이 여러 가지 메뉴를 선택할 수 있는 항목들이 나온다. 특성 창 메뉴를 선택하면 마우스가 위치한 곳에서 변경할 수 있는 것들이 나타난다. 그래프에서 특별히 변경을 원하는 부분이 있으면 특성 창이 열려있는 상태에서 그 부분을 클릭한다. 히스트그램 계급 편집 예를 들어 히스토그램의 계급의 개수나 너비의 길이를 변경하려면 특성 창이 열린 상태에서 계급(막대)를 클릭한다. 히스토그램 옵션을 선택한다. X 축의 사용자 정의에서 구간 수나 구간 너비에 사용자가 원하는 값을 입력한다. 히스토그램 그래프 편집 완성 계급의 수를 7개로 적용한 후 도표 편집기이다 도표 편집기 종료 도표 편집기에서 설정을 완료한 후 창을 닫으면 출력 결과 창에 변경된 내용이 저장된다. 3. 원그래프(pie chart) 원그래프 특성 원을 작성(作成) 하고 관측 값에 대한 상대도수가 차지하는 비율(比)을 호(弧, arc)로 작성하여 원에 각각의 호를 연결(結) 한 그림 각 범주 또는 몇 개의 범주가 전체(全體)에서 차지하는 비율을 파악(把握) 하기에 용이(容) 원그래프 작성 다음은 원그래프를 작성해 보자. 원그래프 작성에 사용한 자료는 여기에서 구할 수 있다. 원그래프 실행은 그래프(Graphs)->레거시 대화 상자 -> 원형 차트 메뉴를 선택한다. 원형 차트 창이 나타나고 차트에 표시할 데이터를 정의한다. 기본값인 케이스 집단들의 요 약 값을 선택한다. 변수 선택 원그래프 작성에 사용할 변수를 선택한다. 출력 결과 원그래프 출력 결과이다. 이 출력 결과는 편집이 가능하다. 원 안에서 마우스 오른쪽 버튼을 누르면 나타나는 메뉴에서 내용 편집 -> 별도의 창에서를 클릭한다. 도표 편집기 원그래프를 편집할 창이다. 원그래프에서 각 범주에 값을 표시해 보자. 원그래프에 마우스 오른쪽 버튼을 클릭하여 데이터 레이블 표시를 클릭한다. 도표 편집기 특성창 데이터 값 레이블 기본값은 빈도이고 더 추가할 수 있는 것은 성별과 퍼센트이다. 표시 안 함에 있는 항목을 표시에 추가하면 원그래프에 레이블이 추가된다. 도표 편집기를 창 닫기 버튼을 클릭하여 종료한다. 출력 결과 도표 편집기에서 편집을 완료하면 적용된 내용이 출력 결과에 나타난다. 4. 줄기-잎 그림(stem and leaf plot) 줄기-잎 그림 특성 관측 값의 자릿수를 기준으로 줄기와 잎으로 나눈 그림 잎 단위를 줄기로 하고 순서대로 잎에 해당하는 자료를 순서대로 입력 막대그래프의 특징을 가지고 있으며, 자료의 손실이 없음 적은 양의 자료에 적합 줄기-잎 그림 그리기 다음은 줄기 - 잎 그림을 작성해 보자. 원그래프 작성에 사용한 자료는 여기에서 구할 수 있다. 변수 설정 종속변수와 요인 변수 설정하고 표시에서는 통계량과 도표를 모두 표시할 수 있다. 데이터 탐색: 도표 기술 통계에서 줄기와 잎 그림을 선택한다. 출력과 분석 키는 성별이 여자인 경우를 보여준다. 남자는 아래에 있다. 줄기 너비는 10으로 줄기에 10을 곱한 것이 단위가 된다. 15는 150이다. 잎은 1개 숫자가 1개 자료이다. 00은 키의 일의 단위 값이 각각 00이다. 5. 산점도(scatter plot) 산점도는 두 변수의 순서쌍에 대한 선점 ( 1 Y) ( 2 2 ) ( n Y) 을 평면에 작성한 그래프이다. SPSS 작성 다음은 산점도를 작성해 보자. 원그래프 작성에 사용한 자료는 여기에서 구할 수 있다. 먼저 그림에 보이는 것과 같이 그래프(Graphs)->레거시 대화 상자 -> 산점도/점 도표 메뉴를 선택한다. 산점도 종류 정의 작성할 산점도를 선택한다. 기본값인 단순 산점도를 선택한다. 변수 설정 단순 산점도에 필요한 변수는 평면좌표이므로 축과 출 2개이다. 출력 결과 출력 결과 화면이다. 출력 결과 편집은 내용 편집 -> 별도의 창에서를 클릭한다. 도표 편집기 도표 편집기에서 회귀선을 추가하는 편집을 해 보자 도표 편집기 창에서 편집은 그림에서 마우스 오른쪽을 클릭하여 나오는 메뉴에서 추가 전체 회귀선 적합을 누르거나 표준 메뉴에서 해당 메뉴를 선택한다. 도표 편집기 특성창 회귀선 적합 탭에서 선형은 기본값이다. 편집 후 그래프 도표 편집을 마치면 창 닫기 버튼을 클릭하고 그 결과를 출력 결과 창에서 확인한다. 6. 상자 그림(box plot) 상자–수염 그림(box – whisker plot)이라고도 부름 최소(最小) 값, 제1 사분위수(Q1), 제2 사분위수(Q2), 제3사분위 수(Q3), 최댓값 등 5 개의 통계량을 이용하여 작성한 그림 자료의 범위(範圍), 사분위수(四分位數)의 위치 파악에 편리 이상점(常點, outlier) 판별(判別)에 사용 두 개 이상의 변수에도 상자 그림 작성(作成) 가능 Q2 : 중앙(中央) 값 IQR(Interquartile Range) : 사분위수 범위(Q3–Q1) SPSS 작성 다음은 상자 그림을 작성해 보자. 상자 그림 작성에 사용한 자료는 여기에서 구할 수 있다. 먼저 그림에 보이는 것과 같이 그래프(Graphs)->레거시 대화 상자 -> 상자도 표 메뉴를 선택한다. 상자도 표 정의 어떤 상지 그림을 그릴 것인지 정의한다. 기본값인 단순을 선택한다. 변수 설정 상자 그림에 사용할 변수 설정과 요인으로 나눌 볌주를 선택한다. 출력 결과 여, 남에 대한 키의 상자 그림이다. 남자는 Q1에서 Q2 사이에 많은 사람들이 몰려있다. 남자에서 이상점이 있으며 그 값은 데이토 보기 시트에서 85번째 자료이다. 여자는 이상점도 없고 자료가 고르게 분포하고 있다. 03. 통계량 구하기 기술 통계량(descriptive statistics) 빈도 분석 기술 통계 데이터 탐색 1. 빈도 분석 도수분포표 특성 관측(觀測) 값을 몇 개의 범주로 나눈 다음 그 범주에 속하는 관측 값의 개수(도수, frequency)와 그 도수를 전체 관측 값 개수로 나눈 값(상대(相對) 도수, relative frequency)에 대한 표 범주형 자료, 이산형(散型) 자료, 연속형(續型) 자료 모두 가능 빈도 분석 빈도 분석은 도수분포표 작성하는 것이다. 범주형 자료에 대한 도수(frequency)와 상대도수(relative frequency)를 구하는 과정에 대하여 알아보자. 그림에 보이는 것과 같이 "분석->기술통계량->빈도분석" 메뉴를 선택한다. 분석에 사용한 자료는 여기에서 구할 수 있다. 변수 설정 더 많은 통계량은 "통계량" 버튼을 눌러 선택할 수 있다. 결과 빈도 분석 결과이다. 2. 기술 통계 통계량 편차 = 관측 값 - 평균 = i X 평균 모든 관측 값의 합 관측 값의 개수 ( ― ) 모든 관측 값의 합 관측 값의 개수 x + + n = i 1 X n 합계 = X 편차의 합 = 0 = ( i X) ∑ i n X 표준편차 편차의 제곱합 = 편차의 제곱합 − = ( i X) n 1 분산 편차의 제곱합 2 편차의 제곱합 − = ( i X) n 1 범위 : 최댓값 - 최솟값 최솟값 : 자료 중 가장 작은 값 최댓값 : 자료 중 가장 큰 값 평균의 표준오차 = n 왜도(歪度, skewness) 3 ∑ = n ( i X) / S γ >인 경우 3 0 인 경우 3 0 인 경우 3 0 인 경우 첨도(尖度, kurtosis) 4 ∑ = n ( i X) / S − γ = 이면 표준정규분포이고, 4 0 이면 표준정규분포보다 더 뾰족하며, 4 0 이면 덜 뾰족하다. SPSS 과정 통계학에서 많이 사용되는 평균, 중앙값, 분산, 표준편차 등을 구하는 과정에 대하여 알아보자. 그림에 보이는 것과 같이 "분석->기술통계량->기술통계" 메뉴를 선택한다. 분석에 사용한 자료는 여기에서 구할 수 있다. 변수 설정과 여러 통계량 선택 변수에 나이를 추가하고 다른 통계량을 구하려면 옵션 버튼을 누른다. 옵션 창에서 구할 통계량을 선택하고 계속 버튼을 누른 후 기술 통계 창에서 확인을 누르면 출력 결과를 구할 수 있다. 결과 및 분석 분석 결과로 최솟값, 최댓값, 범위, 평균, 표준편차 등 여러 통 계량이 출력되었다. 3. 데이터 탐색 데이터 탐색 데이터 탐색은 통계학에서 많이 사용되는 평균, 중앙값, 분산, 표준편차 등과 같은 통계량과 그래프를 요인별로 구한다. 데이터 탐색 실행은 "분석->기술통계량->데이터 탐색" 메뉴를 선택한다. 분석에 사용한 자료는 여기에 있다. 변수 선택 종속변수에 나이를 추가하고 요인에 결혼 여부를 추가한 후 통계량 창과 도표 창에 출력에 원하는 것들을 선택하고 실행 버튼을 클릭한다. 출력 및 분석 데이터 탐색 결과로 통계량과 그래프가 출력되었다. 04. 상관분석 상관분석 상관분석은 두 변수의 상관관계를 알아보는 분석방법이다. 먼저 두 변수의 상관성은 산점도(scatter plot)로 파악하고 상관계수로 구체화할 수 있다. 상관계수 편 상관계수 1. 상관계수 상관분석 산점도는 두 개의 연속형 변수에 대한 관계를 그림으로 대략적으로 파악하는 정보를 제공하기에 구체적인 정보라고 하기에는 부족하다. 상관계수는 두 개의 연속형 변수에 대한 수치로 구체적인 정보를 제공한다. 단순 회귀, 산점도, 상관계수는 함께 분석하는 것이 좋다. 산점도와 단순 회귀 및 Pearson 표본상관계수 모의실험은 여기를 누르면 확인할 수 있다. 상관계수 계산 개의 관측 값을 가지는 두 변수의 짝은 ( 1 Y) ( 2 Y) ⋯ ( n Y) 로 표현하며 이 관계는 산점도와 상관계수로 확인할 수 있다. 상관계수 종류는 Pearson 표본상관계수 Pearson 표본상관계수는 x = i 1 ( i x) ( i y) i 1 ( i x) ∑ = n ( i y)로 구한다. ¯ y는 표본평균이다. 표본상관계수 성질 두 변수에 대한 상관계수는 항상 1 1 사이의 값을 가짐 상관계수가 양수(陽數)이면 양의 상관관계가 있다고 표현 상관계수가 1에 가까우면 강한 양의 상관관계가 있음 상관계수가 음수(陰數)이면 음의 상관관계가 있다고 표현 상관계수가 -1에 가까우면 강한 음의 상관관계 상관계수가 0에 가까우면 두 변수 간 선형성(線形性, linear)이 없다고 표현 두 변수가 독립이면 상관계수는 0이나 상관계수가 0이더라도 두 변수는 독립이 아닐 수 있음 Kendal 순위상관계수 Kendal 순위상관계수는 = P 2 ( − ) 1 4 n ( − ) 1 로 구한다.는 두 변수의 순위가 일치하는 자료의 총합이다. 은 자료수 Kendal 순위상관계수는 두 변수에서 한 변수를 오름차순으로 정렬하고, 나머지 변수가 순위의 일치성이 있는지를 나타내는 통계량이다. 다음 자료는 키와 몸무게 순위를 오름차순으로 정렬하였다. 이 자료에 대한 Kendal 순위상관계수를 계산해 보자. 사람 A B C D E F G H 키 순위 1 2 3 4 5 6 7 8 몸무게 순위 3 4 1 2 5 7 8 6 5 4 5 4 3 1 0 0 A 사람인 경우 몸무게 순위가 3이고 이 순위 값보다 큰 순위 값이 5개(4,5,6,7,8) B 사람인 경우 몸무게 순위가 4이고 이후 이 순위 값보다 큰 순위 값이 4개(5,6,7,8) C 사람인 경우 몸무게 순위가 1이고 이후 이 순위 값보다 큰 순위 값이 5개(2,5,6,7,8) 순위가 일치하는 자료의 수는 = + + + + + + + = 22 이다. 따라 수 Kendal 순위상관계수는 = × 22 × − = 0.57 Spearman 순위상관계수 Spearman 순위상관계수는 − ∑ i n ( 2 1 ) 로 구한다. i 는 두 변수의 순위 차이다. 다음 자료로 Spearman 순위상관계수를 구해보자. x 86 97 99 100 100 103 106 110 113 113 y 0 20 28 50 28 28 7 17 7 12 x 순위 1 2 3 4.5 4.5 6 7 8 9.5 9.5 y 순위 1 6 8 10 8 8 2.5 5 2.5 4 순위 차 0 4 5 5.5 3.5 2 4.5 3 7 5.5 순위 차 0 16 25 30.25 12.25 4 20.25 9 49 30.25 식에 대입하여 Spearman 순위상관계수를 구하면 − × 196 10 ( 100 1 ) − 0.18788 이다. 상관분석 시작 아버지 키와 아들 키가 서로 상관있는지 상관계수(Correlation Coefficient)를 구해보자. 자료는 여기를 누르면 구할 수 있다. 상관계수는 "분석->상관분석->이변량 상관계수" 메뉴를 선택한다. 변수와 상관계수 선택 두 변수 "father", "son"을 "변수"에 삽입하고 세 개의 상관계수를 선택한 후 다음 "확인" 버튼을 누른다. 상관계수 계산 결과 Pearson 표본상관계수를 구한 화면이다. 상관계수가 0.501임을 알 수 있다. 예상보다 상관계수가 작다. 비모수 상관관계 비모수 상관계수는 Spearman 순위상관계수와 Kendal 순위상관계수에 대하여 별도로 계산한다. 2. 편 상관계수 편 상관계수(partial correlation coefficient) 편상관계수는 부분 상관계수로도 부른다. 종속변수 와 설명변수 1 x, , p 인 선형모형이 있다. 선형모형에서 편상관계수는 다른 변수가 주는 요인 − 개를 제어하고 두 변수의 순수한 상관관계를 나타낸다. 변수 와 1 의 편상관계수는 설명변수 2 ⋯ x를 제어 변수로 하고 나머지 두 변수의 순수한 상관계수이다. 제어 변수는 회귀 모형에서 회귀 제곱합에 포함된 설명력이다. 그러므로 제어 변수가 회귀 모형에 포함된 상태에서 두 변수가 서로 상관성이 있는지 판단한다. 회귀분석에서 2 ⋯ x 가 회귀 모형에 포함된 상태에서 설명변수 1 이 반응 변수를 설명하는지 판단한다. 분석 결과 유의하지 않은 결과가 나오면 반응 변수는 설명변수를 잘 설명하지 못함을 의미한다. 선형모형에서 두 변수 와 1 편 상관계수 Y x | 2 x, , p 계산은 Y x | 2 x, , p t 2 d ( S) 로 한다. 는 0 β =에서 검정통계량이고, f ( S) 는 오차 제곱 합의 자유도 − −이다. 또한 2 F 이므로 Y x | 2 x, , p F + f ( S) 이다. 예제 자료 다음은 편상관계수에 사용할 자료이다. 이 자료는 [1]에서 참고하였다. 이 자료는 기억 범위(memory span)는 나이(age)와 말 속도(speech rate)에 어느 정도 영향을 받는지 알아보자. (Memory span) 14 23 30 50 39 67 1 (age) 4 7 10 10 2 (Speech rate) 2 4 6 참고문헌 [1]. Abdi, H., Dowling, W.J., Valentin, D., Edelman, B., & Posamentier M. (2002). Experimental Design and research methods. Unpublished manuscript. Richardson: The University of Texas at Dallas, Program in Cognition. 편 상관분석 시작 기억 범위(memory span), 나이(age), 말 속도(speech rate)는 어떤 관련이 있는지 알아보자. 자료는 여기를 누르면 구할 수 있다. 상관계수는 "분석->상관분석->편상 관계 수" 메뉴를 선택한다. 변수와 제어 변수 선택 제어 변수는 Speech rate이고 상관계수를 구할 변수는 age, Memory span이다. 출력 및 결과 통제변수가 speech rate인 경우 두 변수의 편 상관계수이다. 유의 확률이 0.415로 상관계수는 의미가 없다. 변수와 제어 변수 선택 제어 변수는 age이고 상관계수를 구할 변수는 Speech rate, Memory span이다. 출력 및 결과 통제변수가 age인 경우 두 변수의 편 상관계수이다. 유의 확률이 0.047로 상관계수는 의미가 있다. 상관분석 세 변수에 대한 상관계수를 구해보자. 출력 및 분석 세 변수에서 두 변수를 선택하여 구한 세 개의 상관계수는 모두 의미가 있다. 회귀분석 회귀분석과 편 상관분석의 관계가 어떻게 되는지 알아보자. 회귀분석은 "분석->회귀분석->선형" 메뉴를 선택한다. 변수 설정 및 모형 선택 종속변수에 Memory span, 독립변수에 age, Speech rate, 방법에 입력을 설정한다. 출력 결과 및 분석 출력 결과 age, Speech rate 변수의 유의 확률은 0.415, 0.047로 편 상관계수의 결괏값과 동일하다. 즉 회귀분석 모형에서 방법에 입력을 선택하면 편 상관계수 구하는 방법과 같다. 단순 회귀분석 독립변수 1개와 종속변수 1개에 대한 회귀분석을 실행하자. 종속변수에 Memory span, 독립변수에 age, 방법에 입력을 설정한다. 출력 결과 및 분석 출력 결과 Memory span과 age 변수의 유의 확률은 0.054로 상관계수의 결괏값과 동일하다. 단순 회귀분석 독립변수 1개와 종속변수 1개에 대한 회귀분석을 실행하자. 종속변수에 Memory span, 독립변수에 Speech rate, 방법에 입력을 설정한다. 출력 결과 및 분석 출력 결과 Memory span과 Speech rate 변수의 유의 확률은 0.004로 상관계수의 결괏값과 동일하다. 05. 평균 비교 평균 비교에 대한 검정 단일 표본 독립인 두 표본 대응 표본 일원 배치 분산분석 이원 배치 분산분석 1. 단일 표본 단일 표본 평균 비교 이 분석방법은 한 집단의 평균이 특정한 값이라고 주장할 수 있는지 알아본다. 예를 들어 수업 듣는 학생 중 남학생 키의 평균이 175cm 인지 궁금하다. 이 방법은 남학생 평균이 175cm보다 같은지, 큰지, 작은지를 과학적으로 결정한다. 단일 표본 평균 비교 이론적 내용 이 검정은 한 집단의 평균값이 특정한 값이라고 할 수 있는지 검정하는 방법이다. ① 귀무가설 0 μ μ (의미 : 어느 집단의 평균은 0 이다.)이며, 예전에 조사한 결과 알려진 평균이다. 대립가설 1 는 다음 세 가지 중 하나를 연구자가 정한다. 대립가설 1 μ μ (의미 : 어느 집단의 평균은 0 보다 크다.) 단 측 검정 대립가설 1 μ μ (의미 : 어느 집단의 평균은 0 보다 작다.) 단 측 검정 대립가설 1 μ μ (의미 : 어느 집단의 평균은 0 이 아니다. 즉 0 보다 크거나 0 보다 작다) 양측검정 ② SPSS로 통계적 모형의 출력 결과를 얻는다. ③ 연구자는 SPSS 출력 결과에서 유의 확률을 확인하여 귀무가설( 0 )의 기각, 채택 여부를 결정한다. SPSS 분석 과정 어떤 집단에서 남자 키의 평균이 175보다 작다고 주장할 수 있는지 검정해 보자. 분석에 사용한 자료는 여기를 누르면 구할 수 있다. 특정한 값 선택 먼저 자료는 남, 여 모두 포함하고 있으므로, 남자 자료만 별도로 분석할 수 있게 선택한다. 특정 값만 선택하려면 데이터->케이스 선택 메뉴를 선택한다. 조건을 만작하는 케이스 설정 조건을 만족하는 케이스에서 조건 버튼을 누르고 성별=2를 입력하면 남자 자료만 선택된다. 선택한 케이스 확인 다음 화면은 여자 자료는 선택되지 않았고 남자 자료만 선택된 것을 확인할 수 있다. 단일 표본 검정 실행 일표본 평균 비교는 분석->평균 비교->일표본 T 검정 메뉴를 선택한다. 검정 변수와 검정 값 설정 검정 변수에 키 변수를 클릭하여 입력하고, 검정 값에 귀무가설 175를 입력한다. 출력 결과와 분석 분석 결과 일표본 평균은 171.37이고 귀무가설 0 175 가 참인지 검정한 결과 유의 확률이 0.006으로 매우 유의한 값이 나왔기에 귀무가설을 기각한다. 출력 결과 평균 차이(171.37-175)에 대한 95% 신뢰구간은 ( 6.10 − 1.17 ) 이다. 따라서 모평균에 대한 95% 신뢰구간은 각 값에 175를 더한 ( 168.9 173.83 ) 이다. 2. 독립인 두 표본 독립인 두 표본 평균 비교 이 분석방법은 서로 독립인 집단의 평균이 같은지 알아본다. 예를 들어 설별에 따라 평균 키가 같은지, 다른지 궁금하다. 이 방법은 두 집단의 평균을 비교한다. 독립인 두 표본 평균 비교 이론적 내용 이 검정 법은 독립인 두 집단의 평균이 같다고 할 수 있는지 분석하는 방법이다. 등 분산성 검정 먼저 두 집단이 분산이 같은지 다른지에 따라 통계량을 계산하는 식이 다르다. 따라서 두 집단의 분산이 같은지 검정한다. 이것을 등 분산성 검정이라고 한다. 두 집단의 분산부교 과정은 다음과 같다. ① 가설 설정(Levene 검정) 귀무가설 0 σ 2 σ 2 (의미 : 두 집단의 분산은 같다.) 대립가설 1 σ 2 σ 2 (의미 : 두 집단의 분산은 같지 않다.) ② SPSS의 출력 결과에서 Levene 등 분산 검정의 유의 확률을 확인한다. ③ 등 분산성에 대한 검정 결과 해석 및 평균 비교 방법 선택 유의 확률이 0.05보다 작으면 두 집단의 분산은 서로 다르다. 유의 확률이 0.05보다 크면 두 집단의 분산은 서로 같다. 독립인 두 집단 평균 비교 두 집단의 평균 비교 과정은 다음과 같다. ① 귀무가설 0 μ − 2 0 (의미 : 두 집단의 평균 차이는 0이다.) 대립가설 1 은 다음 세 가지 중 하나를 연구자가 정한다. 대립가설 1 μ − 2 0 (의미 : 두 집단의 평균 차이는 0보다 크다.) 단 측 검정 대립가설 1 μ − 2 0 (의미 : 두 집단의 평균 차이는 0보다 작다.) 단 측 검정 대립가설 1 μ − 2 0 (의미 : 두 집단의 평균 차이는 0이 아니다. 즉 두 집단의 평균 차이는 0보다 크거나 0보다 작다) 양측검정 ② SPSS로 통계적 모형에 대하여 출력 결과를 얻는다. ③ 연구자는 SPSS 출력 결과에서 유의 확률을 확인하여 귀무가설( 0 )의 기각, 채택 여부를 결정하고, 그 결과를 해석한다. SPSS 분석방법 독립 표본 검정 실행 독립인 두 표본 평균 비교는 분석->평균 비교->독립 표본 T 검정 메뉴를 선택한다. 분석에 사용한 자료는 여기를 누르면 구할 수 있다. 검정 변수와 집단 변수 설정 검정 변수에 키를 입력하고, 집단 변수에 성별을 입력하고 집단 정의를 눌러 성별에 입력된 숫자 값 1, 2를 입력한다. 출력 및 결과 분석 출력 결과 분석에서 집단 통계량에서 여자 평균 키는 160.98이고 남자 평균 키는 171.37로 계산되었으며 평균 차이가 표준편차보다 크므로 두 집단의 평균이 다를 수도 있다고 짐작할 수 있겠다. 분석 과정은 두 집단 분산이 같은지에 따라 계산이 다르므로 두 집단 등 분산성을 먼저 검정한다. 두 집단의 분산이 같은지에 대한 귀무가설 0 σ 2 2 =에 대한 검정 결과 유의 확률이 0.394로 유의하지 않는 값이므로 두 집단의 분산은 같다고 가정할 수 있다. 등 분산성 검정 결과 유의하면 등 분산성을 가정할 수 없으므로 등 분산을 가정하지 않음에 있는 통계량으로 평균 차이에 대하여 가설검정한다. 등 분산인 경우 두 집단의 평균이 같은지 귀무가설 0 μ = 2 에 검정 결과 유의 확률이 0.000으로 매우 유의한 결과가 계산되었기에 두 집단의 평균은 통계적으로 같지 않다고 할 수 있다. 3. 대응 표본 대응 표본 평균 비교 두 집단의 자료가 쌍으로 된 경우, 두 집단 차이의 평균을라고 할 때 이 값에 대한 검정 방법이다. 쌍으로 된 자료는 한 개체에서 두 번 자료를 관측하거나 동일한 종류의 기계 두 대에서 자료를 관측하는 경우이다. 동일한 종류 기계인 경우, 차로 예로 하면 소나타 1대와 다른 소나타 1대를 갖고 측정한다. 개체는 독립적으로 다르지만 모든 조건은 같다고 가정한다. 만일 두 집단의 차이가 없다면 는 0이 된다. 대응 표본 평균 비교 이론적 내용 ① 귀무가설 0 δ δ (의미 : 쌍으로 구성된 두 집단 차이의 평균은 0 이다.) 대립가설 1 은 다음 세 가지 중 하나를 연구자가 정한다. 대립가설 1 δ δ (의미 : 쌍으로 구성된 두 집단 차이의 평균은 0보다 크다.) 단 측 검정 대립가설 1 δ δ (의미 : 쌍으로 구성된 두 집단 차이의 평균은 0보다 작다.) 단 측 검정 대립가설 1 δ δ (의미 : 쌍으로 구성된 두 집단 차이의 평균은 0이 아니다. 양측검정 즉 쌍으로 구성된 두 집단 차이의 평균은 0보다 크거나 0보다 작다) ② SPSS로 통계적 모델에 대하여 출력 결과를 얻는다. ③ 연구자는 SPSS 출력 결과에서 유의 확률을 확인하여 귀무가설( 0 )의 기각, 채택 여부를 결정하고, 그 결과를 해석한다. SPSS 분석 과정 대응 표본 평균 비교는 한 개체에서 두 번 반복 측정한 자료이다. 다음 분석 자료는 말을 더듬는 환자에 대하여 10명을 대상으로 약을 투여하고 말 더듬는 횟수를 조사한 결과이다. 자료는 여기를 누르면 구할 수 있다. 대응 표본 실행 대응 표본 평균 비교는 분석 -> 평균 비교 -> 대용 표본 T 검정 메뉴를 선택한다. 분석 결과 유의 확률이 0.020으로 유의한 결과가 계산되었으므로 두 변수 차이의 평균은 통계적으로 0이 아니라고 할 수 있다. 즉 차이가 있다. 대응 표본 변수 설정 대응 변수에 치료전 치료 후 변수를 한 줄에 모두 넣는다. 출력 및 결과 분석 출력 결과 분석에서 대응 표본 통계량에서 치료전 평균은 3.1, 치료 후 평균은 1.7로 상당히 말더듬 횟수가 줄어든 것으로 예상된다. 두 변수 차이의 평균 검정은 귀무가설 0 μ = 0 일 때 검정이다. 여기서 0 는 두 변수 차이는 | − | 이다. 두 변수의 차이가 없다고 한다면 0 0 이다. 검정 결과 유의 확률이 0.02로 유의하였으므로 두 변수 차이의 평균 D 은 0이 아니라고 통계적으로 말할 수 있다. 대응 표본을 일표본 분석으로 실행 변수 계산 두 변수 차이는 변환 -> 변수 계산 메뉴를 클릭하여 구한다. 변수 계산 과정 목표 변수에 변수명 차이를 입력하고 치료전 - 치료 후 수식을 마우스를 사용하여 입력한다. 직접 입력해도 되지만 오류를 줄이려면 마우스를 이용하는 것이 좋다. 단일 변수로 변수 계산 확인 SPSS 데이터 창에서 변수 계산 메뉴로 계산된 차이 변수 결과를 확인할 수 있다. 일표본 검정 실행 단일 표본 검정은 일표본 T 검정 메뉴를 클릭한다. 일표본 검정에서 검정 변수와 검정 값 설정 검정 변수에 차이 변수를 추가하고 검정 값에 0을 입력한다. 출력 및 결과 확인 출력 결과 단일 표본 검정 결과와 대응 표본 결과가 동일하다. 대응 표본 결과는 위에 있으며 그림을 클릭해도 확인할 수 있다. 4. 독립인 k 표본 - 일원 배치 분산분석 일원 배치 분산분석 관측 값 분해 관측 값은 다음과 같이 표현할 수 있다. 관측 값 전체 평균 처리 편차 잔차 측 = ( 체 균 ) ( 리 편 ) ( 차 ) i = ¯. ( ¯. Y. ) ( i − ¯. ) 초등학교 학생들은 반별로 책 읽는 권수의 평균이 다른지 알아보려고 1년간 책 읽는 횟수를 조사하였다. 다음은 초등학교 4개 학급을 대상으로 1년간 책을 읽은 횟수이다. 반별로 책 읽는 권수의 평균 차이가 있으려면 집단 간 편차(처리 편차)가 집단 내 편차(잔차)보다 커야 한다. 학급 각 학생의 책 읽는 횟수 전체 평균 반 반 급 학의 책 읽 횟 전 평 Y j ¯. ( 반 반 반 반 ) ( 10 15 12 15 14 18 21 15 17 16 14 15 17 15 18 12 15 17 15 16 15 ) ( 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 ) 학급별 평균 차이 학급 안에서 평균 차이 급 평 차 학 안 서 평 차 Y i − ¯. i − ¯. ( 3 3 3 3 3 2 2 1 1 1 0 0 0 ) ( 2 − 0 − 1 − 1 − − 1 1 − 0 0 0 ) 제곱합 분해 관측 값 총 평균 처리 편차 잔차 총제곱합처리제곱합잔차제곱합 ( 측 − 평 ) ( 리 편 ) ( 차 ) i 1 ∑ = n ( i − ―. ) = i 1 ∑ = n [ ( ―. Y. ) ( i ∑ = k j 1 i [ ( ―. Y. ) + ( ―. Y. ) ( i − ―. ) ( ∑ = k j 1 i ( ―. Y. ) + i 1 ∑ = n 2 ( ―. Y. ) ( i − ―. ) i ∑ = k j 1 i ( ―. Y. ) + i 1 2 ( ―. Y. ) j 1 i ( i − ―. ) 0 i ∑ = k i ( ―. Y. ) + i 1 ∑ = n ( i − ―. ) 제 합 처 제 합 잔 제 합 일원 배치 분산분석 자료구조 일원 배치 분산분석(one-way ANalysis Of VAriance)에 대한 자료구조는 다음과 같다. 처리 집단 처리 처리 ⋯ 처리 자료 11 21 Y 1 12 22 Y 2 ⋮ ⋮ 1 1 2 2 Y n 평균 ¯ 1. ¯ 2. Y g 전체 평균 ¯. 합계 j 1 1 1 ∑ = n Y j ∑ = n Y j 일원 배치 자료구조 전체 평균은 ¯. ∑ = g j 1 i i ∑ = g i 이고 각 처리 집단 평균은 ¯. ∑ = n Y j i 이다. 일원 배치 분산분석 모형 일원 배치 분산분석 모형은 (1) i = + i ϵ j ϵ j N ( , 2 ) 이다. 식 (1)에서는 상수항,는 요인 변수, 은 오차이다. 식 (1)을 자세히 나타내면 (2) i = + ( ¯. Y. ) ( i − ¯. ) 이다. 식 (2)에서 양변을 제곱하고 합을 구하면 총 제곱합 상수 (3) i 1 ∑ = n Y j ⏞ 제 합 ∑ = g j 1 i ¯. ⏞ 수 ∑ = g j 1 i ( ¯. Y. ) ⏞ S r + i 1 ∑ = n ( i − ¯. ) ⏞ S 식 (3)에서 전체 평균인 상수항 를 왼쪽으로 보내고 양변의 제곱합(sum of squares)을 구하면 (4) i 1 ∑ = n ( i − ¯. ) ⏞ S = i 1 ∑ = n ( ¯. Y. ) ⏞ S r + i 1 ∑ = n ( i − ¯. ) ⏞ S이며 각 제곱합은 다음과 같다. S (sum of squares total)는 전체 제곱합 S r (sum of squares treatment)는 처리 제곱합 S (sum of squares error)는 오차 제곱합 다음은 처리 집단에 대한 분산분석 표이다. 은 전체 자료수,는 처리 집단 수이다. 요인 제곱합 자유도 평균 제곱합 F 값 r a e e t S r g 1 S r = S / ( − ) S r / S E r r S N g S = S / ( − ) o a S T − 일원 배치 분산분석 표 일원 배치 분산분석 모형의 가정 통계 모형 i의 가정은 서로 독립 정규분포 분산이 모두 동일 이다. 집단별 평균 비교 가설은 "모든 집단의 평균은 모두 같다"이라며 0 α = 2 ⋯ α이다. 사후 검정 분석 결과가 집단별 평균 비교에서 평균이 같지 않은 집단이 있다면 어떤 집단의 평균이 다른지 검정한다. 사후 검정방법은 여러 가지가 있으며 SPSS에서 분석방법은 약 20여 개를 제공한다. 분석방법은 두 집단의 평균을 비교하며 개 집단인 경우 평균을 비교하는 가짓수는 C = ( − )이다. 예를 들어 집단 수가 5개이면 C = × 2 10 이다. 가설은 0 | i α | 0 ≠이다. 일원 배치 분산분석 실습자료 분석에 사용할 자료이다. 이 자료는 이원 배치 분석에서 한 요인을 더 나누어 사용한다. 요인 1 41 43 50 51 43 53 54 46 45 55 56 60 58 62 62 2 56 47 45 46 49 58 54 49 61 52 62 59 55 68 63 3 43 56 48 46 47 59 46 58 54 55 69 63 56 62 67 Maxwell & Delaney 2004 p339 요인 1 41 43 50 56 47 45 46 49 43 56 48 46 47 2 51 43 53 54 46 58 54 49 61 52 62 59 46 58 54 3 45 55 56 60 58 62 62 59 55 68 63 55 69 63 56 62 67 Maxwell & Delaney 2004 p339 SPSS 분석 과정 SPSS 실습자료는 여기에서 구할 수 있다. 2열, 3열에 있는 grpA, grpB 변수는 분산분석에서 사용할 독립변수이고 4열 ~ 11열은 회귀분석에서 사용할 독립변수로 더미 변수이다. 일원 배치 실행 일원 배치 분산분석은 분석 -> 평균 비교 -> 일원 배치 분산분석 메뉴를 선택한다. 요인 변수와 종속변수 설정 종속변수에 변숫값을 넣고, 요인에 변수 grpA를 누르고 옵션 버튼을 누른다. 옵션 설정 옵션에서 기술 통계, 분산 동질성 검정, Welch를 선택하고 계속 버튼을 누른다. 기술 통계 : 각 요인의 항목에 대한 평균, 분산 등 기초통계량 확인 분산 동질성 검정 : 요인의 각 집단별 분산이 동일한지 검정 Welch : 집단별 분산이 다른 경우, 평균이 평균이 모두 같은지 검정 출력 및 결과 분석 출력 결과 통계적 해석은 요인에 대한 모든 집단의 분산이 같은지 등 분산성을 검정한다. 귀무가설 0 σ 2 σ 2 σ 2 이다. 요인에 대한 집단의 평균 비교는 귀무가설 0 μ = 2 μ인 경우 가설검정에서 등 분산성을 가정하면 분산분석 표(ANOVA) 등 분산성을 가정할 수 없으면 Brown-Forsythe 검정 또는 Welch 검정으로 검정한다. 기술 통계에서 모든 집단의 평균 차이가 표준편차 차이보다 작기 때문에 각 집단별 평균 차이는 없을 수 있다고 예상할 수 있다. 분산의 동질설 검정 결과 모든 항목에서 유의 확률이 0.05보다 크기 때문에 유의하지 않아 귀무가설 0 σ 2 σ 2 σ 2 을 기각할 수 없으므로 각 집단의 분산은 같다고 통계적으로 가정한다. 각 집단별 평균 비교는 각 집단별 분산이 모두 같다고 가정할 수 있기에 ANOVA로 귀무가설 0 μ = 2 μ 검정한 결과, 유의 확률이 0.401로 유의하지 않아 귀무가설을 기각할 수 없으므로 각 집단 평균은 모두 같다고 통계적으로 주장할 수 있다. 만일 각 집단 평균으 모두 같다고 할 수 없는 경우, 평균이 다른 집단이 존재하기 때문에 사후 검정으로 어떤 집단의 평균이 같지 않은지 검정할 수 있다. 이 경우는 여기서 분석을 종료한다. B 요인에 대한 분석 다른 변수 grpB에 대한 분산분석을 한다. 종속변수에 값, 요인에 grpB를 추가한다. B 요인에 대한 출력 및 결과 분석 출력 결과 통계적 해석은 집단별 평균 차이가 표준편차보다 크기 때문에 집단별 평균 차이가 있을 것이라고 의심할 수 있다. 분산의 동질성 검정 결과 유의수준이 모든 항목에서 0.05보다 크기 때문에 귀무가설 0 σ 2 σ 2 σ 2 을 기각할 수 없으므로 각 집단의 분산은 모두 같다고 통계적으로 가정할 수 있다. 각 집단에 대한 등 분산을 가정할 수 있기 때문에 각 집단 평균이 모두 같은지 귀무가설 0 μ = 2 μ에 검정을 ANOVA로 계산한 결과 유의 확률이 0.000으로 매우 유의한 결과가 계산되었다. 그러므로 모든 집단의 평균은 같다에 대한 가설은 기각하고 적어도 한 집단의 평균이 같지 않다는 귀무가설의 역을 채택한다. 각 집단별 평균 비교는 2 개 집단씩하고 비교하는 개수는 집단 수가 일 때 ( 2 ) 이다. 여기서 집단 개수가 3개이므로 총 비교 횟수는 ( 2 ) 3 이다. 다중비교, 사후 검정 모든 집단의 평균이 같다는 귀무가설 0 μ = 2 μ 이 기각되었으므로 어떤 집단 평균이 다른지 사후 검정을 실시한다. 사후 검정은 일원 배치 분산분석 창에서 사후분석 버튼을 클릭한다. 등 분산성 검정 결과 모든 집단 분산이 같다고 가정할 수 있으므로 등 분산을 가정함에서 사용할 수 있는 분석방법 14개 중 많이 사용되는 Scheffe, Tukey, Duncan 분석방법을 사용하였다. 두 집단 평균이 같은지 가설 검정은 유의수준 5%에서 실시하였다. 다중비교 결과 분석 방법 출력 결과 분석은 다중비교에서 유의수준 0.05에서 의미 있게 집단 차이를 보이는 쌍들은 별표(*)로 표시하여 강조하였다. 즉 유의 확률이 0.05보다 작은 것들은 의미가 있고 집단 간 평균 차이가 있다고 통계적으로 주장할 수 있다. 두 집단의 평규은 같다는 귀무가설 0 | i μ | 0 i j 에 대한 검정 결과 해석이다. 집단 B1과 집단 B2 평균 차이는 -5.872로 유의 확률이 0.019로 유의하다. 집단 B1과 집단 B3 평균 차이는 -12.244로 유의 확률이 0.00로 매우 유의하다. 집단 B2과 집단 B3 평균 차이는 -6.373로 유의 확률이 0.06로 유의하다. 평균 차이 비교 방법은 6 가지이나 부호만 다른 동일한 결과를 2번 제시했기에 3가지이다. 즉 1 B 나 2 B이나 결과는 동일하다. 각 집단에 대하여 평균이 같은 집단을 묶는 동질적 부분집합에서 B1, B2, B3 집단은 서로 평균이 다른 집단이기에 각각 다른 1, 2, 3 집단에 표시되었다. 5. 독립인 k, l 표본 - 이원 배치 분산분석 이원 배치 분산분석 이원 배치 분산분석(two-way ANalysis Of VAriance) 은 일반 선형모형 메뉴에서 분석한다. 그리고 일원 배치 분산분석과 분석 방법 차이가 많기에 자료분석 전에 이론을 소개한다. 먼저 이원 배치 분산분석의 자료 구조를 살펴보면 다음과 같다. A 2 j b 평균 합계 Y 111 Y 112 ⋯ Y 11 Y 121 Y 122 ⋯ Y 12 Y j, 1 2 ⋯ Y j ⋯ 1 1 Y b, , 1 ¯ 1. ∑ = b k 1 Y j 2 211 Y 212 ⋯ Y 21 Y 221 Y 222 ⋯ Y 22 Y j, 2 2 ⋯ Y j ⋯ 2 1 Y b, , 2 ¯ 2. ∑ = b k 1 Y j ⋮ ⋮ ⋮ ⋮ ⋮ Y 11 Y 12 ⋯ Y 1 Y 21 Y 22 ⋯ Y 2 ⋯ i 1 Y j, , i n Y b, i 2 ⋯ Y b ¯. ∑ = b k 1 Y j ⋮ ⋮ ⋮ ⋮ ⋮ Y 11 Y 12 ⋯ Y 1 Y 21 Y 22 ⋯ Y 2 Y j, a 2 ⋯ Y j ⋯ a 1 Y b, , a ¯. ∑ = b k 1 Y j 평균 ¯ .1 Y .2 ⋯ ¯ j ⋯ ¯ b Y. . 합계 i 1 ∑ = n i k i 1 ∑ = n i k ∑ = a k 1 Y j ⋯ i 1 ∑ = n i k i 1 ∑ = b k 1 Y j 이원 배치 자료구조 상호작용이 있는 이원 배치 분산분석 이원 배치 분산분석 모형은 (1) i k μ α + j γ j ϵ j , ϵ j ∼ ( , 2 ) 이다. 식 (1)에서는 상수항, ,는 요인 변수,는 교호작용, 은 오차이다. 식 (1)을 자세히 나타내면 (2) i k μ ( ¯. − ¯. ) ( ¯ j − ¯. ) ( ¯ j − ¯. − ¯ j + ¯. ) ( i k Y i . ) 이다. 식 (2)에서 양변을 제곱하고 합을 구하면 총 제곱합 상수 (3) i j k i k ⏞ 제 합 ∑, , Y. . ⏞ 수 ∑, , ( ¯. − ¯. ) ⏞ S + i j k ( ¯ j − ¯. ) ⏞ S + i j k ( ¯ j − ¯. − ¯ j + ¯. ) ⏞ S B ∑, , ( i k Y i . ) ⏞ S이며 전체 제곱합이다. SPSS 출력에서는 합계이다. 식(2)에서 전체 평균인 상수항 를 왼쪽으로 보내고 양변의 제곱합(sum of squares)을 구하면 (4) i j k ( i k Y. . ) ⏞ S = i j k ( ¯. − ¯. ) ⏞ S + i j k ( ¯ j − ¯. ) ⏞ S + i j k ( ¯ j − ¯. − ¯ j + ¯. ) ⏞ S B ∑, , ( i k Y i . ) ⏞ S이며 각 제곱합은 다음과 같다. S (sum of squares total)는 수정된 전체 제곱합 S (sum of squares factor A)는 A 요인 제곱합 S (sum of squares factor B)는 B 요인 제곱합 S B (sum of squares interaction of A B)는 요인 A와 B의 상호작용 제곱합 S (sum of squares error)는 오차 제곱합 다음은 두 요인 A, B에 대한 분산분석 표이다. 요인 제곱합 자유도 평균 제곱합 F 값 S A − M A S A ( − ) S / S B S b 1 S = S / ( − ) S / S A B S B ( − ) ( − ) S B S A / ( ( − ) ( − ) ) S B M E r o S E b ( − ) S = S / ( b ( − ) ) o a S T b − 이원 배치 분산분석 표 상호작용이 없는 이원 배치 분산분석 상호작용이 유의하지 않으면 분산분석 표에서 상호작용 제곱합을 오차 제곱합에 합한다. 이것을 상호작용의 풀링(pooling)이라고 부른다. 상호작용이 없을 때 이원 배치 분산분석 모형은 (5) i k μ α + j ϵ j , ϵ j ∼ ( , 2 ) 이다. 식 (5)에서는 상수항, ,는 요인 변수, 은 오차이다. 식 (5)를 자세히 나타내면 (6) i k μ ( ¯. − ¯. ) ( ¯ j − ¯. ) ( ¯ j − ¯. − ¯ j + ¯. ) 이다. 식 (6)의 양변을 제곱하고 합을 구하면 총 제곱합 상수 (7) i j k i k ⏞ 제 합 ∑, , Y. . ⏞ 수 ∑, , ( ¯. − ¯. ) ⏞ S + i j k ( ¯ j − ¯. ) ⏞ S + i j k ( ¯ j − ¯. − ¯ j + ¯. ) ⏞ S이며 전체 제곱합이다. 이 값은 SPSS 출력에서 합계이다. 식 (6)에서 전체 평균인 상수항 를 왼쪽으로 보내고 양변의 제곱합(sum of squares)을 구하면 (8) i j k ( i k Y. . ) ⏞ S = i j k ( ¯. − ¯. ) ⏞ S + i j k ( ¯ j − ¯. ) ⏞ S + i j k ( ¯ j − ¯. − ¯ j + ¯. ) ⏞ S이며 각 제곱합은 다음과 같다. S (sum of squares total)는 수정된 전체 제곱합 S (sum of squares factor A)는 A 요인 제곱합 S (sum of squares factor B)는 B 요인 제곱합 S (sum of squares error)는 오차 제곱합 다음은 두 요인 A, B에 대한 분산분석 표이다. 요인 제곱합 자유도 평균 제곱합 F 값 S A − M A S A ( − ) S / S B S b 1 S = S / ( − ) S / S E r r S a n a b 1 S = S / ( b − − + ) o a S T b − 이원 배치 분산분석 표(상호작용 제외) Type I, II, III sum of squares 이원 배치 분산분석은 여러 가지 제곱합을 사용하며 일원 배치 분산분석에 사용하는 제곱합과 비교해 보자. 이원 배치 분산분석은 일반 선형모형에서 Type I, II, III, III Sum of Squares 4 개 제곱합으로 분석한다. 이 제곱합은 위계적 회귀분석을 바로 구할 수 있다. 위계적 회귀분석은 일부 변수를 통제하고 어떤 한 변수가 추가될 때 설명력이 의미 있는지 판단하는 분석방법이다. 따라서 여러 개 회귀식을 구하여 위계적 회귀분석에 적용할 필요가 없다. Type I Type II Type III ANOVA S ( | ) S ( | , ) S ( | , , ) S ( | ) S ( | ) S ( | , ) S ( | , , ) S ( | ) × S ( | , , ) S ( | , , ) S ( | , , ) S ( , , | ) S ( | ) S ( | ) 여러 가지 제곱합 사용한 제곱합에 대한 설명이다. S ( , , , ) S ( ) S ( | ) S ( | , ) S ( | , , ) S ( , , B ) ∑, , Y j 2 : 전체 모형에서 총 제곱합이다. SPSS 출력에서 전체이다. S ( , , | ) S T ∑, , ( i k Y. . ) : 수정 제곱합으로 전체 모형 제곱합에서 절편을 뺀 값이다. SPSS 출력에서 수정된 합계이다. S ( | ) S ( ) S A ∑, , ( ¯. − ¯. ) : 가 있는 모형에서 가 추가될 때 제곱 합의 증가량 S ( | ) S ( ) S B ∑, , ( ¯ j − ¯. ) : 가 있는 모형에서 가 추가될 때 제곱 합의 증가량 S ( | , ) S ( | ) S ( , ) S ( ) μ α 가 있는 모형에서 가 추가될 때 제곱 합의 증가량 S ( | , , ) S ( B A B ) S ( , , B ) S ( , ) μ α β 가 있는 모형에서 가 추가될 때 제곱 합의 증가량 Type I SS Type I 제곱합은 순차 제곱합(sequential sum of squares)으로도 부르고 속성은 다음과 같다. 축소모형에 주인자 A, B와 교호작용 AB가 차례로 추가될 때 발생하는 증가량으로 순차 제곱합이라고 부른다. 인자가 모형에 추가되는 순서가 중요하며 순서가 바뀌면 각 인자의 제곱합이 변한다. 각 제곱합은 모두 합하면 전체 제곱합 S ( , , , ) Type II SS Type II 제곱합은 모든 주인자가 포함된 모형에서 한 개의 인자가 제거될 때 발생하는 제곱 합의 감소량이다. 인자가 추가되는 순서에 제곱합이 영향받지 않는다. 각 제곱합은 모두 합하면 전체 제곱합 S ( , , , ) 와 같지 않다. Type III SS Type III 제곱합은 모든 주인자와 교호작용이 포함된 완전 모형에서 한 개의 인자가 제거될 때 발생하는 제곱 합의 감소량이다. 인자가 추가되는 순서에 제곱합이 영향받지 않는다. 각 제곱합은 모두 합하면 전체 제곱합 S ( , , , ) 와 같지 않다. 부분 제곱합(partial sum of squares)라고 부른다. 이원 배치 분산분석 실습 자료 이원 배치 분산분석에 사용할 자료는 일원 배치 분산분석에서 사용한 자료를 한 요인으로 더 세분한 것이다. 요인 1 2 3 요인 1 41 43 50 51 43 53 54 46 45 55 56 60 58 62 62 2 56 47 45 46 49 58 54 49 61 52 62 59 55 68 63 3 43 56 48 46 47 59 46 58 54 55 69 63 56 62 67 Maxwell & Delaney 2004 p339 SPSS 분석 과정 이원 배치 분산분석 실습자료는 여기에서 구할 수 있다. SPSS 데이터 시트에서 2열, 3열에 있는 grpA, grpB 변수는 분산분석에서 사용할 독립변수이고 4열 ~ 11열은 회귀분석에서 사용할 독립변수로 더미 변수이다. 일반 선형모형 분석 이원 배치 분산분석은 분석 -> 일반 선형모형 -> 일변량 메뉴를 선택한다. 2개 요인과 종속변수 설정 종속변수에 값을 추가하고 고정 요인에 grpA, grpB 순서로 변수를 추가한다. Type I SS (변수 추가 순서가 grpA, grpB인 경우) 모형 설정에서 완전 요인 모형은 모든 요인과 교호작용이 추가된다. 항 설정은 사용자가 추가할 요인을 선택할 수 있다. 사용자 정의 항 설정은 사용자가 입력한 요인 중에서 특정 요인을 모형에 추가한다. 제곱합은 제 I 유형을 선택한다. 모형을 절편에 추가한다. 출력 및 결과 분석 출력 결과 통계량에 대한 분석은 다음과 같다. 다음 사용한 숫자 기호 ①, ②, ③, ④, ⑤, ⑥, ⑦, ⑧은 SPSS 출력 결과 통계량에 표시한 것이다. ① 전제 S ( , , , B ) = ② + ③ ② 수정된 합계 S ( , , B α ) = ④ + ⑤ + ⑥ + ⑦ = ⑦ + ⑧ ③ 절편 제곱합 S ( ) S ( | ) S ( ) 101.111 , 표 1에서 S ( ) 101.111 S ( | , ) S ( , ) S ( ) 1253.189 , 표 3 회귀 제곱합 S ( , ) 에서 표 1 S ( ) 을 뺀 S ( , ) S R ( ) 1354.300 101.111 1253.189 S ( B α A B ) 14.184 , 표 6 S ( , , B ) 에서 표 3 S ( , ) 를 뺀 S ( , , B ) S R ( , ) 1368.487 1354.300 14.187 이다. ⑦ 오차 제곱합; SSE = ② - ⑧ ⑧ 수정된 모형; S ( , , B α ) S E = ④ + ⑤ + ⑥ = ② - ⑦ 출력 결과 분석은 귀무가설 0 α 0 에 대하여 유의 확률이 0.178로 유의하지 않다. grpA 변수에서 집단 간 평균 차이는 없다고 통계적으로 주장할 수 있다. 귀무가설 0 β 0 에 대하여 유의 확률이 0.000으로 매우 유의하다. grpB 변수에서 집단 간 평균 차이는 적어도 한 쌍 이상 존재한다고 통계적으로 주장할 수 있다. 귀무가설 0 γ 0 에 대하여 유의 확률이 0.972로 유의하지 않다. 두 변수 grpA, grpB의 교호작용은 없다고 통계적으로 주장할 수 있다. 다음 그림은 Type I SS 출력 결과로 변수 추가 순서가 grpA, grpB이다. Type I SS (변수 추가 순서가 grpB, grpA인 경우) 종속변수에 값을 추가하고 고정 요인에 grpB, grpA 순서로 변수를 추가한다. 다음 그림은 Type I SS 설정에서 변수 추가 순서가 grpB, grpA이다. 출력 및 결과 분석 모형 설정에서 완전 요인 모형은 모든 요인과 교호작용이 추가된다. 항 설정은 사용자가 추가할 요인을 선택할 수 있다. 사용자 정의 항 설정은 사용자가 입력한 요인 중에서 특정 요인을 모형에 추가한다. 제곱합은 제 I 유형을 선택한다. 모형을 절편에 추가한다. 다음 그림은 Type I SS 설정에서 변수 추가 순서가 grpB, grpA이다. 출력 결과 통계량에 대한 분석은 다음과 같다. 다음 사용한 숫자 기호 ①, ②, ③, ④, ⑤, ⑥, ⑦, ⑧은 SPSS 출력 결과 통계량에 표시한 것이다. ① 전제 S ( , , , B ) = ② + ③ ② 수정된 합계 S ( , , B α ) = ④ + ⑤ + ⑥ + ⑦ = ⑦ + ⑧ ③ 절편 제곱합 S ( ) S ( | ) 1115.818 표 2에서 S ( ) 1115.818 S ( | , ) S ( , ) S ( ) 238.483 은 표 3의 회귀 제곱합 S ( , ) 에서 표 2의 S ( ) 를 뺀 S ( , ) S R ( ) 1354.300 1115.818 238.483 이다. S ( B α A B ) S ( B A B ) 14.187 은 표 6 S ( , , B ) 에서 표 3 S ( , ) 를 뺀 S ( , , B ) S R ( , ) 1368.487 1354.300 14.187 이다. ⑦ 오차 제곱합; SSE = ② - ⑧ ⑧ 수정된 모형; S ( , , B α ) S E = ④ + ⑤ + ⑥ = ② - ⑦ Type I SS는 변수 추가 순서에 따라 값이 다른 것을 두 결과를 보고 확인할 수 있다. 출력 결과 분석은 귀무가설 0 β 0 에 대하여 유의 확률이 0.000으로 매우 유의하다. grpB 변수에서 집단 간 평균 차이는 적어도 한 쌍 이상 존재한다고 통계적으로 주장할 수 있다. 귀무가설 0 α 0 에 대하여 유의 확률이 0.022로 유의하다. grpA 변수에서 집단 간 평균 차이는 적어도 한 쌍 이상 존재고 통계적으로 주장할 수 있다. 귀무가설 0 γ 0 에 대하여 유의 확률이 0.972로 유의하지 않다. 두 변수 grpA, grpB의 교호작용은 없다고 통계적으로 주장할 수 있다. 다음 그림은 Type I SS 출력 결과에서 변수 추가 순서가 grpB, grpA이다. Type II SS 모형 설정에서 완전 요인 모형은 모든 요인과 교호작용이 추가된다. 항 설정은 사용자가 추가할 요인을 선택할 수 있다. 사용자 정의 항 설정은 사용자가 입력한 요인 중에서 특정 요인을 모형에 추가한다. 제곱합은 제 II 유형을 선택한다. 모형을 절편에 추가한다. 다음 그림은 Type II SS 설정에서 상호작용을 수동으로 추가한 것이다. 출력 결과 통계량에 대한 분석은 다음과 같다. 다음 사용한 숫자 기호 ①, ②, ③, ④, ⑤, ⑥, ⑦, ⑧은 SPSS 출력 결과 통계량에 표시한 것이다. ① 전제 S ( , , , B ) = ② + ③ ② 수정된 합계 S ( , , B α ) = ⑦ + ⑧ ③ 절편 제곱합 S ( ) S ( | , ) S ( , ) S ( ) 238.483 은 표 3 회귀 제곱합 S ( , ) 에서 표 2 S ( ) 를 뺀 S ( , ) S R ( ) 1354.300 1115.818 238.483 S ( | , ) S ( , ) S ( ) 1253.189 는 표 3 회귀 제곱합 S ( , ) 에서 표 1 S ( ) 를 뺀 S ( , ) S R ( ) 1354.300 101.111 1253.189 S ( B α A B ) S ( B A B ) 14.187 은 표 6 S ( , , B ) 에서 표 3 S ( , ) 를 뺀 S ( , , B ) S R ( , ) 1368.487 1354.300 14.187 이다. ⑦ 오차 제곱합; SSE = ② - ⑧ ⑧ 수정된 모형; S ( , , B α ) S E = ② - ⑦ 출력 결과 분석은 귀무가설 0 α 0 에 대하여 유의 확률이 0.022로 유의하다. grpA 변수에서 집단 간 평균 차이는 적어도 한 쌍 이상 존재한다고 통계적으로 주장할 수 있다. 귀무가설 0 β 0 에 대하여 유의 확률이 0.000으로 매우 유의하다. grpB 변수에서 집단 간 평균 차이는 적어도 한 쌍 이상 존재한다고 통계적으로 주장할 수 있다. 귀무가설 0 γ 0 에 대하여 유의 확률이 0.972로 유의하지 않다. 두 변수 grpA, grpB의 교호작용은 없다고 통계적으로 주장할 수 있다. 다음 그림은 Type II SS 출력 결과이다. Type III SS 모형 설정에서 완전 요인 모형은 모든 요인과 교호작용이 추가된다. 항 설정은 사용자가 추가할 요인을 선택할 수 있다. 사용자 정의 항 설정은 사용자가 입력한 요인 중에서 특정 요인을 모형에 추가한다. 제곱합은 제 III 유형을 선택한다. 모형을 절편에 추가한다. 다음 그림은 Type III SS 설정에서 상호작용을 수동으로 추가하였다. 출력 결과 통계량에 대한 분석은 다음과 같다. ① 전제 S ( , , , B ) = ② + ③ ② 수정된 합계 S ( , , B α ) = ⑦ + ⑧ ③ 절편 제곱합 S ( ) S ( | , , B ) S ( | , B ) 204.762 는 표 6 S ( , , B ) 에서 표 5 S ( , B ) 를 뺀 S ( , , B ) S R ( , B ) 1368.487 1163.728 204.762 이다. S ( | , , B ) S ( | , B ) 1181.105 는 표 6 S ( , , B ) 에서 표 4 S ( , B ) 를 뺀 S ( , , B ) S R ( , B ) 1368.487 187.382 1181.105 이다. S ( B α A B ) S ( B A B ) 14.187 은 표 6 S ( , , B ) 에서 표 3 S ( , ) 를 뺀 S ( , , B ) S R ( , ) 1368.487 1354.300 14.187 이다. ⑦ 오차 제곱합; SSE = ② - ⑧ ⑧ 수정된 모형; S ( , , B α ) S E = ② - ⑦ 출력 결과 분석은 귀무가설 0 α 0 에 대하여 유의 확률이 0.036으로 유의하다. grpA 변수에서 집단 간 평균 차이는 적어도 한 쌍 이상 존재한고 통계적으로 주장할 수 있다. 귀무가설 0 β 0 에 대하여 유의 확률이 0.000으로 매우 유의하다. grpB 변수에서 집단 간 평균 차이는 적어도 한 쌍 이상 존재한다고 통계적으로 주장할 수 있다. 귀무가설 0 γ 0 에 대하여 유의 확률이 0.972로 유의하지 않다. 두 변수 grpA, grpB의 교호작용은 없다고 통계적으로 주장할 수 있다. 다음 그림은 Type III SS 출력 결과이다. 회귀식에 대한 분산분석 표 다음은 Type I SS, Type II SS, Type III SS를 계산하기 위하여 회귀식에 대한 분산분석 표를 구하였다. 회귀식에 대한 분산분석 표는 데이터 파일을 열고 SPSS 명령어 파일에서 REGRESSION PROCEDURE 부분을 선택하여 실행하면 출력을 바로 구할 수 있다. 또한 일반 선형모형을 구하는 명령어도 포함되어 있다. 회귀 추정식 ^ β 0 β 1 1 β 2 2 의 분산분석 표이다(표 1). 회귀 추정식 ^ β 0 β 1 1 β 2 2 의 분산분석 표이다(표 2). 회귀 추정식 ^ β 0 β 1 1 β 2 2 β 3 1 β 4 2 의 분산분석 표이다(표 3). 회귀 추정식 ^ β 0 β 1 1 β 2 2 β 3 1 1 β 4 1 2 β 5 2 1 β 6 2 2 의 분산분석 표이다(표 4). 회귀 추정식 ^ β 0 β 1 1 β 2 2 β 3 1 1 β 4 1 2 β 5 2 1 β 6 2 2 의 분산분석 표이다(표 5). 회귀 추정식 ^ β 0 β 1 1 β 2 2 β 3 1 β 4 2 β 5 1 1 β 6 1 2 β 7 2 1 β 8 2 2 의 분산분석 표이다(표 6). 06. 비율 비교 비율 비교 검정 단일 표본 독립인 두 표본 1. 단일 표본 단일 표본 비율 추론 사례 1 : 대통령 선거에서 A 후보자 지지율이 궁금하고, 그 값에 대한 오차 범위가 알고 싶을 때 이 방법을 사용한다. 사례 2 : 어떤 특정한 암의 경우에 수술을 시행한 후 완치되는 비율이 30%로 알려져 있다. 이 암에 걸린 60명의 환자를 대상으로 수술뿐 아니라 수술 전후에 일정 기간 방사선 치료를 병행하였더니 60명 중 27명이 완치되었다고 한다. 이 자료로부터 수술만 하는 것보다 방사선치료를 병행하는 것이 암의 완치율(p)을 높이는데 효과가 있다고 할 수 있는지 알아하자. 완치 유무 환자 수 완치 27 치료 중 33 합계 60 단일 표본 비율 추론 이론적 내용 단일 표본 비율에 대한 100 ( − ) 신뢰구간 또는 ( ^ z / p ( − ^ ) , p + α 2 ^ ( − ^ ) ) 또는 ^ z / p ( − ^ ) 여기서 ^ X 은 표본 비율,는 성공 횟수, α 2 는 표준정규분포 분위수, 은 자료의 개수 대통령 선거에서 A 후보 득표율은 ^ X로 예측하고, 오차 범위는 α 2 ^ ( − ^ )이다. 단일 표본 비율에 대한 검정 ① 귀무가설 0 p p (의미 : 어느 집단의 성공 비율은 0 이다.)이며, 예전에 조사한 결과 알려진 평균이다. 대립가설은 다음 세 가지 중 하나를 연구자가 정한다. 대립가설 1 p p (의미 : 어느 집단의 성공 비율은 0 보다 크다.) 단 측 검정 대립가설 1 p p (의미 : 어느 집단의 성공 비율은 0 보다 작다.) 단 측 검정 대립가설 1 p p (의미 : 어느 집단의 성공 비율은 0 이 아니다. 즉 0 보다 크거나 0 보다 작다) 양측검정 ② 연구자는 유의수준에 대한 기각역을 구하고 조사한 자료를 이용하여 검정통계량 = ^ p p ( − 0 ) 과 유의 확률(p-value)을 구한다. ③ 연구자는 유의 확률과 유의수준의 대소나 기각역에 검정통계량이 포함되는지 확인하여 귀무가설( 0 )의 기각, 채택 여부를 결정하고, 그 결과를 해석한다. SPSS 분석 과정 데이터 입력 표에 있는 자료는 원자료를 요약한 것으로 직접 SPSS에 입력하자. 자료 입력은 파일 -> 새 파일 -> 데이터 메뉴를 선택한다. 변숫값에 변수 이름, 소수점, 값 설정 새 파일을 만들면 두 개 시트가 보인다. 데이터 보기 시트는 자료를 입력하고, 변수 보기 시트는 입력한 변수를 설정한다. 자료에서 해당 변수는 열에 입력한다. 첫 열은 숫자로 입력하였지만 이후 레이블을 추가하여 문자로 출력되게 설정할 것이다. 두 번째 열은 환자 수를 입력한다. 변수에 적용 결과 확인 변수 보기 시트에서 변수에 설정된 기본값을 변경한다. 이름은 변수명으로 환자 유무와 암 환자 수를 입력한다. 현재 변수들은 소수점이 필요 없으므로 소수점 이하 자릿수는 0으로 변경한다. 값 속성에서 환자 유무는 1을 완치, 2를 치료 중으로 레이블을 붙여 숫자에 해당 값을 표현한다. 가중 케이스 설정 변수에 설정한 값이 잘 적용되었는지 확인한다. 만일 값에 레이블 한 값이 보이지 않으면 보기 - > 값 레이블 메뉴를 선택하거나 버튼을 클릭하면 보인다. 현재 입력된 값은 원자료를 요약한 자료로 빈도를 모든 변수에 적용하려면 가중치 변수를 설정해야 한다. 가중치는 데이터 -> 가중 케이스 메뉴를 선택한다. 가중 케이스 창에서 가중 케이스 지정에 빈도 변수는 암 환자 수로 설정한다. 카이제곱 검정 실행 이제 자료 설정이 완료되었고, 단일 표본 비율 검정은 분석 -> 비모수 검정 -> 레거시 대화상자 -> 카이제곱 검정 메뉴를 선택한다. 범주형 자료 비율 설정 카이제곱 검정 창에서 검정 변수에 환자 유무 변수를 추가하고 기댓값에 귀무가설 0 p 0.3 을 설정한다. 기댓값은 각 범주 값에 대한 비율을 입력한다. 예를 들어 3,7로 입력하거나 30,70으로 입력해도 된다. 기댓값에 입력하는 값의 순서는 검정 변수에서 범주 값의 오름차순이다. 출력 및 결과 분석 출력 결과에서 빈도는 각 값을 잘 입력하였는지, 또 가중치는 잘 적용하였는지 확인한다. 단일 표본 비율 검정은 표준정규분포로 검정한다. 그러나 검정통계량은 카이 제곱 통계량이다. 다음은 카이제곱분포 2 ( ) 와 표준정규분포의 관계이다. 2 χ ( ) α ( ) Z / 이와 같은 관계를 이용하여 단일 표본 비율 Z - 검정에 카이제곱분포를 활용한다. 귀무가설 0 p 0.3 일 때 대립가설 1 p 0 (양측검정)에 대한 유의 확률은 0.011 이고 대립가설 1 p 0.3 (단 측 검정)에 대한 유의 확률은 0.011 = 0.0055 이다. 그 이유는 카이제곱분포 확률 값 [ > p ] p 는 정규분포 확률 값이 [ > p 2 ] P [ < Z / ] p 이기 때문이다. SPSS 출력에서 카이 제곱 유의 확률은 [ 2 6.429 ] 0.011 을 계산하였고 정규분포에서 유의 확률은 [ > 6.429 2.535547 ] P [ > 6.429 − 2.535547 ] 0.011 분석 결과 양측검정에 대하여 유의 확률이 0.011로 유의하므로 귀무가설 0 p 0.3 를 기각한다. 따라서 자료에서 치료 비율 27 60 0.45 는 이전 완치율 0.3과는 통계적으로 차이가 있다. 2. 독립인 두 표본 독립인 두 표본 비율 추론 어떤 화학적인 처리가 씨의 발아 비율을 높이는데 효과가 있는지 알아보기 위하여 화학적 처리가 된 100 개의 씨와, 처리되지 않은 보통의 씨 150 개를 파종하여 발아되는 것을 관찰하였다. 그 결과 화학적으로 처리된 씨는 88 개, 보통 씨는 126 개가 발아되었다. 화학적인 씨가 발아 비율을 높인다고 할 수 있는지 검정하자. 발 아유무 합계 발아 불량 씨앗 종류 화학처리 88 12 100 보통 126 24 150 합계 214 36 250 독립인 두 표본 추론 이론적 내용 독립인 두 집단의 비율 차이 1 p에 대한 100 ( − ) 신뢰구간(두 표본이 모두 클 때; 1 1 10 n ( − 1 ) 10 n p ≥ 10 n ( − 2 ) 10 ) ( ( ^ − ^ ) z / p 1 ( − ^ ) 1 p 2 ( − ^ ) 2 ( ^ − ^ ) z / p 또는 또는 ( ^ − ^ ) z / p 1 ( − ^ ) 1 p 2 ( − ^ ) 2 여기서 ^ = n, ^ = n는 표본 비율,는 이항분포의 총 시행 횟수 1 에서 성공인 횟수,는 이항분포의 총 시행 횟수 2 에서 성공인 횟수, α 2 는 표준정규분포 분위수, 1 n는 자료의 개수 독립인 두 집단의 비율 차이 1 p에 대한 검정(두 표본이 모두 클 때; 1 1 10 n ( − 1 ) 10 n p ≥ 10 n ( − 2 ) 10 ) ① 귀무가설 0 p − 2 0 (의미 : 두 집단의 평균은 같다) 대립가설은 다음 세 가지 중 하나를 연구자가 정한다. 대립가설 1 p − 2 0 단 측 검정 대립가설 1 p − 2 0 단 측 검정 대립가설 1 p − 2 0 양측검정 ② 연구자는 유의수준에 대한 기각역을 구하고 조사한 자료를 이용하여 검정통계량 = ( 1 − 2 ) ^ ( − ^ ) n + n 과 유의 확률(p-value)을 구한다. 두 집단의 합동 비율 추정량은 ^ X Y 1 n이다. ③ 연구자는 유의 확률과 유의수준의 대소나 기각역에 검정통계량이 포함되는지 확인하여 귀무가설( 0 )의 기각, 채택 여부를 결정하고, 그 결과를 해석한다. SPSS 분석 과정 데이터 보기 시트에 자료 입력 새 파일을 만들어 표에 있는 자료를 입력한다. 자료는 데이터 보기 시트에 다음과 같이 입력한다. 첫 번째 변수는 첫 번째 열에 입력하며 표에서 행 번호에 해당된다. 두 번째 변수는 두 번째 열에 입력하며 표에서 열 번호에 해당된다. 세 번째 변수는 세 번째 열에 입력하며 표에서 각 셀에 해당되는 값이다. 1행 1열은 88, 1행 2열은 12, 2행 1열은 126, 2행 2열은 24이다. 변수 보기 시트에 변숫값 설정 변수 보기 시트에 입력된 변수의 특성 값을 설정한다. 이름에 변수 이름을 변경한다. 소수점 이하 자리는 이 자료에 해당되지 않으므로 0으로 설정한다. 값은 범주형 자료에 대하여 레이블을 설정한다. 씨앗 종류 변수는 기준값 1은 레이블 화학처리, 기준값 2는 보통 발 아유무 변수는 기준값 1은 레이블 발아, 기준값 2는 불량으로 설정한다. 설정한 변숫값 확인 변수에 설정한 값이 잘 적용되었는지 확인한다. 만일 값에 레이블 한 값이 보이지 않으면 보기 - > 값 레이블 메뉴를 선택하거나 버튼을 클릭하면 보인다. 가중 케이스 설정 현재 입력된 값은 원자료를 요약한 자료로 빈도를 모든 변수에 적용하려면 가중치 변수를 설정해야 한다. 가중치는 데이터 -> 가중 케이스 메뉴를 선택한다. 가중 케이스 창에서 가중 케이스 지정에 빈도 변수는 개수로 설정한다. 교차분석 실행 독립인 두 표본 비율 검정은 분석 -> 기술통계량 -> 교차분석 메뉴를 선택한다. 교차분석 창에서 행에 씨앗 종류, 열에 발 아유무 변수를 추가한다. 그리고 통계량 버튼을 누른다. 통계량 창에서 카이 제곱을 선택한다. 결과 및 분석 분석 결과 두 변수에 대한 교차분석 표가 출력된다. 교차분석 표에 값이 잘 입력되었는지, 가중치는 잘 설정되었는지 확인한다. 독립인 두 표본 비율 검정은 표준정규분포로 검정한다. 그러나 검정통계량은 카이 제곱 통계량이다. 다음은 카이제곱분포 2 ( ) 와 표준정규분포의 관계이다. 2 χ ( ) α ( ) Z / 이와 같은 관계를 이용하여 독립인 두 표본 비율 - 검정에 카이제곱분포를 활용한다. 귀무가설 0 p − 2 0 일 때 대립가설 1 p − 2 0 (양측검정)에 대한 유의 확률은 0.378 이고 대립가설 1 p − 2 0 (단 측 검정)에 대한 유의 확률은 0.378 = 0.189 이다. 그 이유는 카이제곱분포 확률 값 [ > p ] p 는 정규분포 확률 값이 [ > p 2 ] P [ < Z / ] p 이기 때문이다. SPSS 출력에서 카이 제곱 유의 확률은 [ 2 0.779 ] 0.378 을 계산하였고 정규분포에서 유의 확률은 [ > 0.779 0.8826098 ] P [ < 0.779 − 0.8826098 ] 0.378 분석 결과 양측검정에 대하여 유의 확률이 0.378로 유의하지 않으므로 귀무가설 0 p − 2 0 를 기각 못한다. 따라서 자료에서 발아 비율 ^ = 88 100 0.88 p 2 126 150 0.84 는 통계적으로 비율 차이가 없다. 07. 회귀분석 회귀분석 소개 회귀(regression)는 갈톤 경(Sir Francis Galton, 1822-1911)이 1885년 발표한 "Regression toward mediocrity in hereditary stature''에 처음으로 사용 아버지 키의 유전적 성질과 자식들 키의 정규곡선의 문제 독립변수(independent variable) : 종속변수에 영향을 주는 변수 종속변수(dependent variable) : 독립변수의 영향을 받는 변수 영향을 주는 여러 변수와 영향을 받는 한 변수와의 관계에 대한 모델 설정과 그 모델에 대한 추론 단순 선형회귀 모형(simple linear regression model) : 독립변수와 종속변수가 각각 한 개인 경우의 단순회귀모형 다중선형회귀모형(multiple linear regression model) : 두 개 이상의 독립변수와 한 개의 종속변수의 선형회귀 모형 오늘날 사회의 다양한 분야에서 활용 범위가 넓은 분석방법임 1. 단순 선형 회귀 모형 단순 선형 회귀 모형 독립변수와 종속변수가 각각 한 개씩 이루어진 단순 선형회귀 모형 단순 선형 회귀 모형 : i β + 1 i ε, i 1 2. . , β, 1 은 직선식을 결정하는 미지의 회귀 모수 오차 i 들은 서로 독립이고 평균이 0이고 분산이 2 인 정규분포를 따름 i i 번째 시행에서 독립변수 i 로 고정시켰을 때 종속변수의 값임. i N ( 0 β x, 2 ) 0 β 추정 최소제곱법으로 모수 추정 최소제곱법(least squares method) : 편차의 제곱합을 최소화하는 모수를 찾는 방법 단순회귀 최소제곱법에 의한 단순 회귀 추정식은 ^ β 0 β 1 i 잔차 i y − ^ = i ( ^ + ^ x) 잔차의 제곱합 = i 1 e 2 ∑ = n [ i ( ^ + ^ x) ] 을 편 미분하면 q β = i 1 ( 2 ) [ i ( ^ + ^ x) ] q β = i 1 ( 2 ) i [ i ( ^ + ^ x) ] 위 두 식을 정규방정식이라 하며, 0 β에 대한 해를 구한다. i 1 y = β + 1 i 1 x ∑ = n i i β ∑ = n i β ∑ = n i 두 식에서 0 β의 해를 구하면 1 n ( i 1 x y) ( i 1 x) ( i 1 y) ( i 1 x 2 ) ( i 1 x ) , β = i 1 y − 1 i 1 x n 사용할 기호들을 정리하면 다음과 같다 x = i 1 ( i x) = i 1 x 2 1 ( i 1 x) S y ∑ = n ( i y) = i 1 y 2 1 ( i 1 y) S y ∑ = n ( i x) ( i y) ∑ = n i i 1 ( i 1 x) ( i 1 y) 모집단에서 추출한 임의표본 ( i y) i 1 2. . n 의 추정 회귀계수는 ^ = x S x β 0 y − ^ x 회귀식 분해 단순 회귀에서 두 변수 관계는 i y i e = ^ + ^ x + i β 0 β 1 i 이고, 양변에 ¯ 를 빼면 i y = ^ − ¯ e = ^ + ^ x − ¯ y − ^ − ^ x이다. 이 식에서 회귀 제곱합은 S = i 1 ( ^ − ― ) = ^ S y 이고 잔차 제곱합은 S = e 2 ∑ ( i β 0 β 1 i ) = y − x 2 x이다. 제곱합 분해는 총 제곱합 회귀 제곱합 잔차 제곱합 ( i y) = ( ^ − ― ) + ( i y i ) S T ( 총 제곱합 ) S R ( 회귀 제곱합 ) S E ( 잔차 제곱합 ) 이다. 다음 표는 단순 선형회귀에 대한 분산분석 표이다. 요인 제곱합 자유도 평균 제곱합 F 회귀 S = i 1 ( ^ − ― ) = ^ S y M R S R M R S 잔차 S = i 1 ( i y i ) = y − ^ S y − M E S E − 합계 S = i 1 ( i y) = y n 1 단순 선형회귀 분산분석 표 단순 선형회귀 예제 다음은 어떤 약의 복용량과 효과가 지속되는 시간을 기록하였다. 자료출처 : 개정판 통계학 -엑셀을 이용한 분석- 김진경 등(2008) 복용량( ) 3 3 4 5 6 6 7 8 8 9 시간( ) 9 5 12 9 14 16 22 18 24 22 복용량과 시간 다음 분산분석 표에서 유의 확률이 0.001보다 작기 때문에 귀무가설 0 β = 을 기각한다. 따라서 1 값은 유의하다. 요인 제곱합 자유도 평균 제곱합 F 유의 확률 회귀 S = i 1 ( ^ − ― ) = ^ S y 307.247 M R S R = 307.247 S M E 38.615 0.001 잔차 S = i 1 ( i y i ) = y − ^ S y 63.653 − = M E S E − = 7.957 합계 S = i 1 ( i y) = y = 370.900 − = 단순 선형회귀 분산분석 표 SPSS를 이용하기 각 자료를 입력한다. 회귀분석 실행은 분석 회귀분석 선형회귀 메뉴를 클릭한다. 자료는 독립변수와 종속변수로 구분하여 입력한다. 분석 결과 2 , 분산분석 표, 각 회귀계수에 대한 통계량이 출력된다. 분산분석 표는 위의 표에서 계산한 값과 같음을 확인한다. 분산분석 표에서 독립변수에 대한 회귀계수가 유의하고 상수항에 대한 회귀계수가 유의한지 검정한다. 유의 확률은 상수( 0 )가 0.707 으로 유의하지 않기 때문에 값이 의미가 없고, 즉,이라고 할 수 있고, 복욕량( 1 )이 0.000 으로 유의하므로 계수가 통계적으로 의미 있다. 독립변수에 대한 통계량은 ANOVA 분석 결과와 계수 분석 결과가 동일한 값이다. 그 이유는 t 분포와 F 분포의 관계가 α 2 ( ) F, , , 2 p ( − ) − F, 이기 때문에 ANOVA 분석 = 38.615 와 계수에서 = 6.214 t = 38.625 값이 같다. 직선 위 점이 평균인 확률분포 | =의 정규분포 회귀식 분해 기댓값, 신뢰대, 예측대 기댓값 : ^ β 0 β 1 신뢰대(confidence band) : ^ t / ( − ) 1 + ( − ¯ ) S x where = ^ 예측대(prediction band) : ^ t / ( − ) 1 1 + ( − ¯ ) S x 2. 다중선형 회귀모형 다중 선형회귀(multiple linear regression)는 독립변수가 2개 이상인 경우이다. 일반적인 다중선형 회귀모형은 종속변수 와 − 개 독립변수 1 X, , p 1 가 있으며 관계식은 [ ] β + 1 1 β X + + p 1 p 1 이다. 이 식을 각 자료마다 표현하면 i β + 1 i + 2 i + + p 1 i p 1 ϵ, i 1 2 ⋯ n 이다. i 는 오차로 이에 대한 가정은 평균이, 분산이 2 이고 서로 독립이라 가정한다. 회귀식을 행렬로 나타내면 n 1 X × β × + n 1 이다. 다중회귀식에서 각 항은 다음과 같이 정의한다. = ( 1 2 Y) X ( 1 x ′ x ′ ) ( X 11 12 X, − 1 21 22 X, − ⋮ ⋮ ⋮ X 1 n ⋯ n p 1 ) β ( 0 1 β − ) ϵ ( 1 2 ϵ) 여기서는 종속변수이고,는 디자인 행렬(design matrix)라고 부르며 첫 열은 상수항이고 나머지는 독립변수이다. 다중 선형회귀 분해 다중 선형회귀에서 제곱합 분해는 총 제곱합 회귀 제곱합 잔차 제곱합 i 1 ( i Y) = i 1 ( ^ − ― ) + i 1 ( i Y i ) S T ( 제 합 ) S R ( 귀 곱 ) S E ( 차 곱 ) 제곱합 분해를 벡터와 행렬의 이차<NAME>으로 표현하면 다음과 같다. 총 제곱합 SST는 S = i 1 ( i Y) = i 1 Y 2 n ― = i 1 Y 2 1 ( i 1 Y)으로 나타낸다. i 1 Y 2 y y ∑ = n i 1 y 이므로 S = ′ − n ′ 11 y y ( − n) = ′ Ty 여기서 사용한 벡터나 행렬은 다음과 같다. n 1 ( 1 1 ) I × = ( 0 0 1 0 ⋮ ⋮ 0 1 ) J × = 11 = ( 1 1 1 1 ⋮ ⋮ 1 1 ) 회귀 제곱합 SSR은 S = i 1 ( i − ― ) = i 1 Y ^ − Y 2 ∑ = n i 2 1 ( i 1 Y)으로 나타낸다. i 1 Y ^ = ( Xb ) ( Xb ) b ( ′ ) 1 ′, i 1 Y = ′이므로 S = ( Xb ) ( Xb ) 1 y 11 y y X ( ′ ) 1 ′ ( ′ ) 1 ′ − n ′ 11 y y X ( ′ ) 1 ′ − n ′ 11 y y X ( ′ ) 1 ′ − n ′ 11 y y ( ( ′ ) 1 ′ 1 J ) = ′ Ry 잔차 제곱합 SSE은 S = i 1 ( i Y ^ ) = ( − ^ ) ( − ^ ) ( − Xb ) ( − Xb ) y y 2 ′ Xb b X Xb y y 2 ′ ( ′ ) 1 ′ + ′ ( ′ ) 1 ′ ( ′ ) 1 = ′ − ′ ( ′ ) 1 ′ = ′ ( − ( ′ ) 1 ′ ) = ′ Ey 으로 나타낸다. 다음은 다중회귀분석 분산분석 표이다. 요인 제곱합 자유도 평균 제곱합 F 회귀 S = i 1 ( ^ − ― ) = ′ Ry − M R S R − M R S 잔차 S = i 1 ( i Y i ) = ′ Ey − M E S E − 합계 S = i 1 ( i Y) = ′ Ty − 다중 선형회귀 분산분석 표 다중선형 회귀모형에서 변수 선택 방법 SPSS에서 모형에 변수를 선택하거나 제거는 부분 F - 검정(partial F-test)을 사용한다. 최초 변수 선택은 = S i S i i 1 ⋯ p 1 통계량 중 가장 유의한 변수이다. 이후 두 번째 변수 선택은 = S ( i X) S ( i X) i 1 ⋯ p 1 i j 에서 통계량 중 가장 유의한 변수이다. 세 번째 변수 선택은 = S ( i X, k ) S ( i X, k ) i 1 ⋯ p 1 i j k 에서 통계량 중 가장 유의한 변수이다. 변수 제거는 = S ( i X, 2 ⋯ X ( ) ⋯ X − ) S ( 1 X, , p 1 ) i 1 ⋯ p 1 X ( ) X 변수 제외일 때 통계량에서 가장 유의하지 않은 변수이다. SPSS에서 변수 선택할 때는 유의수준 0.05, 제거할 때는 유의수준 0.1이 기본값이다. 당뇨병 자료 다음은 다중 선형회귀분석에 사용할 자료에 대한 설명이다. **Data Set Characteristics:** :Number of Instances: 442 :Number of Attributes: First 10 columns are numeric predictive values :Target: Column 11 is a quantitative measure of disease progression one year after baseline :Attribute Information: - age age in years - sex - bmi body mass index - bp average blood pressure - s1 tc, T-Cells (a type of white blood cells) - s2 ldl, low-density lipoproteins - s3 hdl, high-density lipoproteins - s4 tch, thyroid stimulating hormone - s5 ltg, lamotrigine - s6 glu, blood sugar level 당뇨병 자료가 있는 위치 https://www4.stat.ncsu.edu/~boos/var.select/diabetes.tab.txt SPSS로 당뇨병 자료에 대한 다중회귀분석 당뇨병 자료는 위 사이트에서 텍스트 파일을 다운로드하고 SPSS 데이터 보기 시트에서 연다. 회귀분석 실행은 분석 회귀분석 선형회귀 메뉴를 클릭한다. 종속변수에 변수 Y, 독립변수에 나머지 변수를 모두 입력하고, 모형 선택 방법은 단계 선택을 선택한다. 선형회귀 창에서 통계량을 클릭하고 통계량 창에서 출력할 통계량 선택 선형회귀 창에서 옵션을 클릭하고 옵션 창에서 모형에 추가할 변수 선택 기준 설정 분석 결과 모형 요약에서 2 과 수정된 2 값이 변수가 추가될수록 증가하므로 모형의 설명력이 좋다. Durbin-Watson 통계량이 2 근처에 있으면 오차가 서로 독립인데, 통계량이 2.043이므로 오차의 독립성이 보장된다. 분산분석 표에서 최종 모형은 변수 6개가 추가되었을 때 최고 적합 모형으로 판단하였다. VIF 값이 10 이상인 값은 없어 공선성이 없다고 판단할 수 있지만 S1 변수가 8.8로 약간 높기 때문에 이 변수에 대한 공선성을 약간 의심해 볼 필요가 있다. 3. 로지스틱 회귀 모형 상대위험도와 승산비 표 1은 아스피린 복용 여부와 심근경색 발병 유무 관계를 나타내었다. 이 조사는 22,071명 남성을 임의로 두 집단으로 나누고 아스피린과 위약을 복용한 후 5년 동안 심근경색 발병 유무를 기록하였다. 두 집단을 확률화로 나누고 현재부터 미래의 일정 기간까지 조사하는 연구 방법을 후향적 연구(prospective study)이라고 한다. 집단 심근경색 합 발병함 발병 안 함 placebo 189 10,845 11,034 aspirin 104 10,933 11,037 표 1. 아스피린과 심근경색 표 1 출처는 다음과 같다. source: Priliminary Report: Findongs from the Aspirin Component of the Ongoing Physician' Health Study. N. Engl. J. Med., 318:262-264(1988). 표 2는 북부 이탈리아의 30개 관상 동맥 치료실에서 심근경색이 있는 환자 262 명과 다른 급성 질환이 있는 환자 519명이다. 이 조사는 1983년에서 1988년까지 과거 자료를 관찰하였다. 이와 같이 현시점에서 과거 자료를 조사하는 것을 후향적 연구(retrospective study) 또는 특정한 질병이 있는 환자를 관찰자가 결정하기에 사례-대조 연구(case-control study)라고 한다. 심장질환 흡연 경험 심근경색 대조군 합 있음 172 173 345 없음 90 346 436 합 262 519 781 표 2. 흡연과 심근경색 표 2 출처는 다음과 같다. source: A Gramenzi et al., J. Epidemiol. and Commun. Health, 43: 214-217 (1989). 변수의 결과가 각각 두 개 범주로 나눈 경우 분할표 자료에서 연관성에 대한 측도는 상대위험률(relative risk)과 승산비(odds ratio)가 있다. 상대위험도는 실험 군 위험률 대조군 위험률 RR 실 군 위 률 조 위 률 이다. 표 1에서 아스피린에 대한 상대위험도는 RR 189 11 034 104 11 037 1.82 이다. 위약을 복용한 사람에 대한 상대 위험도는 1.82 이다. 즉 상대위험도는 심근경색 발병 비율은 아스피린을 복용하지 않는 사람이 복용하는 사람보다 82 더 높다. 상대위험률은 코호트 연구(cohort study)나 실험 군과 대조군이 사전에 정의하고 관찰하는 경우 실험 결과에서 계산할 수 있다. 상대위험률은 직관적으로 이해가 쉽지만, 사례-대조 연구(case-control study)와 같이 대조군과 실험 군 수가 실험가에 의해 정해지면 임의성이 없게 되어 확률을 논할 수 없으므로 상대위험률은 사용할 수 없다. 그래서 이런 경우는 승산비를 사용한다. 어떤 확률에 대한 승산(odds)은 odds p −이다. = 0.8 이면 승산은 odds 0.8 − 0.8 4 이다. 위 식에서 확률은 승산으로 표현하면 = odds + odds 이다. 승산이 이면 확률 는 = 1 4 0.8 이다. 승산비(odds ratio)는 실험 군 승산 와 대조군 승산 비율이다. × 분할표에서 첫 행의 성공 확률을 1 이면 첫 행 승산은 odds = 1 − 1 이고, 두 번째 행의 성공 확률을 2 이면 두 번째 행 승산은 odds = 2 − 2 이다. 1 2 3 0. ˙ 이고 2 0.8 이면 각 승산은 odds = 0. ˙ 0. ˙ 2 odds = 0.8 0.2 4 이다. 따라서 승산비는 = odds odds = 4 0.5 이다. 승산비와 상대위험도의 관계는 승산비 상대위험도 산 = 1 ( − 1 ) 2 ( − 2 ) 상 위 도 ( − 2 − 1 ) 이다. 1 p 모두 작으면 ( − 2 − 1 ) 이 1에 가깝게 되므로 승산비와 상대위험도는 비슷한 값을 같다. 표 1에서 플래 시보 심근경색 발병률과 아스피린 심근경색 발병률은 모두 0에 가깝다. 이 경우 승산비와 상대위험도는 비슷한 것으로 예상할 수 있다. 표 1에서 계산하면 승산비는 1.83 이고 상대위험도는 1.82 이다. 실험자가 표본을 미리 정해서 확률을 구할 수 없는 경우, 즉 사례-조사연구는 상대위험도를 구할 수 없다. 두 변수, 가 있다고 하자. 조건부 확률에서 한 범주의 값에 대하여 다른 범주의 값이 작을 때, 즉 변수에 대하여 확률 ( = ) 이 작을 때 승산비와 상대위험도는 비슷한 값을 가진다. 따라서 가 주어진 경우의 조건부 확률을 추정하면 ( = | ) 가 작을 값을 가질 것으로 예상되는 경우 표본 승산비는 상대위험도와 비슷한 값을 가진다. 표 2에서 흡연 유무에 따른 승산비는 172 346 90 173 3.82 이다. 흡연 경험을 흡연비 흡연 = { ( 연 ) 1 ( 흡 ) } , 심장질환을 기타 질환 심근경색 = { ( 타 환 ) 1 ( 근 색 ) } 라고 하면, ( = | = ) P ( = | = ) 모두 작은 값이므로 상대위험도를 대략 3.82 로 추정할 수 있다. 해석하면 흡연 경험이 있는 사람이 흡연 경험이 없는 사람보다 심근경색에 걸릴 확률이 약 배 높다고 추정할 수 있다. 이진형 로지스틱 회귀 모형 반응 변수 ∈ { , } 인 베르누이 시행인 경우, 설명변수와 함께 표현하면 | = ∼ ( , ( ) ) 분포로 나타낼 수 있다. ( ) 에 대한 함수는 logit ( ( ) ) log ( ( ) − ( ) ) ( ; ) β + 1 1 ⋯ β x η ( ; ) logit ( ( ) ) ( ) e ( ; ) + η ( ; ) 로 표현한다. 로짓(logit) 함수에서 계산한 분포함수 ( ) 를 로지스틱 회귀 모형(logistic regression model)이라고 한다. 로지스틱 회귀 모형에 대한 우도 함수(likelihood function)는 반응 변수 가 베르누이 시행이므로 다음과 같이 표현단 다. ( ) ∏ = n ( i ) i ( − ( i ) ) − i 로그-우도 함수는 ( ) ∑ = n [ i log p ( i ) ( − i ) log ( − ( i ) ) ] ∑ = n [ i log p ( i ) − ( i ) log ( − ( i ) ) ] ∑ = n [ i ( i ) log ( + η ( i ) ) ] 이다. 로지스틱 회귀 모형을 구하는 것은 로그-우도함수에서 를 구하는 것이다. 로지스틱 회귀 모형에서 회귀계수는 로그-우도 함수가 최대가 될 때 값이다. 함수가 위로 볼록인 경우 최댓값은 1차 미분한 함수가 0일 때 해이다. 회귀 계수는 테일러급수 전개(Taylor series expansion)로 구한다. 테일러급수에서 다음과 같은 식을 얻는다. = ( ^ ) f ( 0 ) f ( 0 ) ( ^ x) ^ x = f ( 0 ) ′ ( 0 ) ^ x − ( 0 ) ′ ( 0 ) 해는 위의 식에서 반복하여 계산하고 이전 값과 새 값의 차이 = x − 0 가 < 10 3 일 때 새 값 ^ 이다. 이렇게 비선형 방정식의 해를 구하는 것을 Newton-Raphson 방법이라고 한다. 예를 들어 두 함수 1 ( ) sin ( ) f ( ) x 해를 Newton_Raphson 방법으로 구하자. 두 함수의 해는 ( ) sin ( ) x 해와 같다. ( ) 의 도함수 ′ ( ) cos ( ) 2이다. 해는 두 함수가 교차하는 곳이다. 아래 그림은 두 함수가 교차하는 두 점을 표시하였다. 한 점은 원점이므로 해는 과 0.876 이다. 두 번째 해는 엑셀에서 목푯값 찾기로 계산하였다. 함수의 해는 아래 식을 반복하여 구한다. ^ x − sin ( 0 ) x 2 cos ( 0 ) 2 0 0 2 를 시작 값으로 반복하여 값을 구하면 이전 값과 새 값의 차이 = x new x old 가 < 10 3 x = 0.877 가 함수 ( ) 의 해다. 1 x − sin ( 0 ) x 2 cos ( 0 ) 2 0 1.300 2.000 sin ( 2.000 ) 2.000 cos ( 2.000 ) 2 2 x − sin ( 1 ) x 2 cos ( 1 ) 2 1 0.989 1.300 sin ( 1.300 ) 1.300 cos ( 1.300 ) 2 3 x − sin ( 2 ) x 2 cos ( 2 ) 2 2 0.889 0.989 sin ( 0.989 ) 0.989 cos ( 0.989 ) 2 4 x − sin ( 3 ) x 2 cos ( 3 ) 2 3 0.877 0.889 sin ( 0.889 ) 0.889 cos ( 0.889 ) 2 5 x − sin ( 4 ) x 2 cos ( 4 ) 2 4 0.877 0.877 sin ( 0.877 ) 0.877 cos ( 0.877 ) 2 다음 그림은 함수 ( ) sin ( ) x의 해를 초깃값 0 2 에서 시작하여 Newton-Raphson 방법으로 구하는 과정을 보여준다. 회귀 모형에서 1차 미분인 스코어(score) 함수 ( ^ ) 와 2차 미분인 헤시 안(Hessian) 함수 ( ^ ) 로 회귀계수 추정치 ^ 을 구하면 = ( ^ ) S ( 0 ) H ( 0 ) ( ^ β) ( 0 ) ( ^ β) − ( 0 ) ^ β − ( 0 ) 1 ( 0 ) 이다. ^ 계산은 로그-우도 함수를 초기화한다. ^ β − ( 0 ) 1 ( 0 ) 를 구한다. 로그-우도 함수에 ^ β 값을 적용한 ( ^ ) l ( 0 ) 를 계산한다. ( ^ ) l ( 0 ) 이고 l ( ^ ) l ( 0 ) < 10 6 이면 ^ 를 해로 정한다. 그렇지 않으면 0 β으로 값을 바꾸고 2 번으로 가서 조건을 만족할 때까지 반복한다.에 대한 로그-우도 함수의 1차 미분인 스코어(score) 함수는 ( ) = ∂ j ( ) ∑ = n [ i i − η ( ) + η ( ) i ] ∑ = n [ i p ( i ) ] i 이고에 대한 로그-우도 함수 2차 미분인 헤시 안(Hessian) 함수는 ( ) k ∂ ∂ j β l ( ) − i 1 [ ( i ) ( − ( i ) ) i x k ] − i 1 V x j i이다. 위 식에서 i 는 베르누이 시행 분산으로 다음 식에서 구한다. ∂ k ( i ) ∂ β ( η ( i ) + η ( i ) ) e ( i ) ( + η ( i ) ) i − η ( i ) η ( i ) ( + η ( i ) ) = i 1 p ( i ) ( − ( i ) ) variance i = i 1 V x k 로지스틱 회귀 모형 성능 평가 로지스틱 회귀분석에서 모형의 성능 평가는 혼동행렬(confusion matrix)을 작성하여 활용한다. 실제 상태 실제 양성 실제 음성 유병률(prevalence) TP FN + 정밀도(accuracy) TP TN + 예 상 태 양성 참인 양성(TP) 거짓 양성(FP) type I error 양성 예측도(PPV) TP TP FP 거짓양성예측도(FDR) FP TP FP 음성 거짓 음성(FN) type II error 참인 음성(TN) 거짓 음성 예측도(FOR) FN FN TN 음성 예측도(NPV) TN FN TN 민감도(TPR) TP TP FN 거짓 음성률(FPR) FP FP TN 양성 가능성 승산(LR+) TPR FPR 진단 승산비 LR LR F1 점수 2 PPV TPR PPV TPR 거짓양성률(FNR) FN TP FN 특이도(TNR) TN FP TN 음성 가능성 승산(LR) FNR TNR 혼동행렬(confusion matrix) 혼동행렬에 사용한 용어는 다음과 같다. condition positive(P) : 주어진 데이터에서 실제로 양성 condition negative(N) : 주어진 데이터에서 실제로 음성 ture positive(TP) : 실제 양성이고 예측도 양성 ture negative(TN) : 실제 음성이고 예측도 음성 false positive(FP) : 실제 음성이고 예측은 양성 false negative(FN) : 실제 양성이고 예측은 음성 sensitivity, recall, hit rate or true positive rate(TPR) : 민감도, 재현성, 참인 양성 비율 TPR TP = TP TP FN 1 FNR specificity, selectivity or true negative rate (TNR) : 특이도, 참인 음성 비율 TNR TN = TN TN FP 1 FNR precision or positive predictive value (PPV) : 양성 예측도 PPV TP TP FP 1 FDR negative predictive value (NPV) : 음성 예측도 NPV FN FN TN 1 FOR \item miss rate or false negative rate (FNR) : 거짓 음성 비율 FNR FN = FN TP FN 1 TPR fall-out or false positive rate (FPR) : 거짓 양성 비율 FPR FP = FP FP TN 1 TNR false discovery rate (FDR) FDR FP FP TP 1 PPV false omission rate (FOR) FOR FN FN TN 1 NPV Threat score (TS) or Critical Success Index (CSI) TS TP TP FN FP accuracy (ACC) : 정확도 ACC TP TN + = TP TN TP FN FP TN F1 score : F1 점수 1 2 PPV TPR PPV TPR 2 TP TP FP FN Matthews correlation coefficient (MCC) MCC TP TN FP FN ( TP FP ) ( TP FN ) ( TN FP ) ( TN FN ) Informedness or Bookmaker Informedness (BM) BM TPR TNR 1 Markedness (MK) MK PPV NPV 1 혼동행렬 예 실제 상태(내시경으로 대장암 판정) 실제 양성(P) 30 실제 음성(N) , 000 유병률(prevalence) 1.5 = TP FN + = 20 10 30 2 000 정밀도(accuracy) 90.6 = TP TN + = 20 1 820 30 2 000 변 혈 사 양성 판정 참인 양성(TP) 20 거짓 양성(FP) 180 양성 예측도(PPV) 10.0 = TP TP FP 20 20 180 거짓양성예측도(FDR) 90.0 = FP TP FP 180 20 180 음성 판정 거짓 음성(FN) 10 참인 음성(TN) , 820 거짓 음성 예측도(FOR) 0.5 = FN FN TN 10 10 1 820 음성 예측도(NPV) 99.5 = TN FN TN 1 820 10 1 820 민감도(TPR) 66.7 = TP TP FN 20 20 10 거짓 음성률(FPR) 9.0 = FP FP TN 180 180 1 820 양성 가능성 승산(LR+) TPR FPR 0.667 0.090 7.41 진단 승산비 LR LR = 7.41 0.37 20.2 F1 점수 2 PPV TPR PPV TPR 2 0.100 0.667 0.100 0.667 0.17 거짓양성률(FNR) 33.3 = FN TP FN 10 10 20 특이도(TNR) 91.0 = TN FP TN 1 820 180 1 820 음성 가능성 승산(LR) FNR TNR 0.333 0.910 0.37 혼동행렬(confusion matrix) 예 Python 실습 Python 코드에서 사용한 데이터 파일은 캐글 사이트에서 구했고, titanic 폴더에 저장한다. 캐글 위치는 여기를 누르면 해당 사이트로 이동한다. import warnings import numpy as np import pandas as pd from sklearn.preprocessing import LabelEncoder from sklearn.linear_model import LogisticRegression from sklearn.metrics import roc_auc_score, accuracy_score, precision_score, recall_score, confusion_matrix, f1_score, confusion_matrix, precision_recall_curve from sklearn.model_selection import train_test_split warnings.filterwarnings(action='ignore') pd.set_option('display.width',500) X_train = pd.read_csv('titanic/train.csv') X_test = pd.read_csv('titanic/test.csv') X_train['Age'].fillna(X_train['Age'].mean(),inplace=True) X_train['Cabin'].fillna('N',inplace=True) X_train['Embarked'].fillna('N',inplace=True) X_train['Cabin'] = X_train['Cabin'].str[0] X_train.drop(['PassengerId','Name','Ticket'],axis=1, inplace=True) print(X_train['Survived'].value_counts()) def data_preprocessing(enc, df): for i in df.columns: if df[i].dtype == 'object': df[i] = enc.fit_transform(df[i]) return df enc = LabelEncoder() X = data_preprocessing(enc, X_train) Y = X['Survived'] X = X.drop('Survived',axis=1) X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.4, random_state=11) X=X_train T=X_test model = LogisticRegression() model.fit(X_train, y_train) print(X_train.columns) coef = model.coef_ print('회귀계수 \n',coef) pred = model.predict_proba(T)[:,1] pred2 = model.predict(T) roc_auc = roc_auc_score(y_test, pred) print('roc : {0:.4f}'.format(roc_auc)) acc = accuracy_score(y_test, pred2) print('정확도 : {0:.4f}'.format(acc)) precision = precision_score(y_test, pred2) print('정밀도 : {0:.4f}'.format(precision)) recall = recall_score(y_test, pred2) print('재현율 : {0:.4f}'.format(recall)) f1 = f1_score(y_test, pred2) print('f1 : {0:.4f}'.format(f1)) confusion = confusion_matrix(y_test, pred2) print('혼동행렬 백분율 \n',confusion/confusion.sum()) print('혼동행렬 \n',confusion) 결과는 죽은 사람이 549명, 생존 사람이 342명이다. 그다음 출력은 독립변수들이다. 회귀계수는 Pclass, Sex, 순이다. 혼동행렬은 전체 자료 중에서 20% 자료를 테스트 데이터로 사용하였다. 0 549 1 342 Name: Survived, dtype: int64 Index(['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'Cabin', 'Embarked'], dtype='object') 회귀계수 [[-9.26702177e-01 -2.88072643e+00 -3.79510684e-02 -2.98038720e-01 -9.14543335e-02 6.20201004e-04 -1.05251360e-01 -5.37820987e-02]] roc : 0.8487 정확도 : 0.7983 정밀도 : 0.7479 재현율 : 0.6794 f1 : 0.7120 혼동행렬 백분율 [[0.54901961 0.08403361] [0.11764706 0.24929972]] 혼동행렬 [[196 30] [ 42 89]] SPSS 실습 예제 파일은 캐글에서 다운로드하여 분석에 필요 없는 변수는 삭제하고 변경이 필요한 변수는 수정하였다. 수정한 파일은 여기에서 데이터 파일을 누르고 titanic_train을 클릭하여 다운로드한다. Age 변수에서 결측치는 평균으로 변경하였다. Cabin 변수에서 결측치는 'N' 값으로 변경하였다. 그리고 각 값에서 한 문자만 가져왔다. Embarked 변수에서 결측치는 'N' 값으로 변경하였다. PassengerId, Name, Ticket 변수는 필요 없다고 판단하여 제거하였다. ▼ 타이타닉 자료를 SPSS로 읽은 화면이다. ▼ 로지스틱 회귀 모형 실행은 분석 회귀분석 이분형 로지스틱 메뉴를 선택한다. ▼ 종속변수에 Survived, 블록에 나머지 변수를 추가하고 범주형 버튼을 클릭한다. ▼ 범주형 공변량에 화면에 보이는 변수를 추가한다. ▼ 블록 화면에 범주형 자료로 처리된 것을 확인한다. 저장 버튼을 누른다. ▼ 선택한 확률, 소속 집단이 SPSS 시트에 추가된다. 확률은 0에서 1사이 값이다. 소속 집단은 확률 값이 0.5보다 크면 1, 작으면 0으로 판단한다. ▼ 정분류 값을 보려면 분류 도표를 선택한다. ▼ 변수 선택 방법은 앞으로(forward method)이다. ▼ SPSS 데이터 보기 시트에 실제 값과 예측값이 보인다. PRE_1 변숫값은 확률이고, PGR_1 변숫값은 소속 집단으로 분류한 값이다. 아래 화면에 실제 사망자를 생존자로 잘못 예측한 값이 있다. ▼ 최종 단계에서 분류 표에 정확도는 82.2%이다. 위의 python에서 값 79.83% 보다 큰 값이다. SPSS는 모형을 세운 자료와 검증한 자료가 동일하지만 python은 모형을 세운 자료와 검증한 자료가 다르다. 따라서 SPSS 결과는 과적합이 있는 것으로 예상할 수 있다. ▼ 최종 단계에서 선택한 변수들이다. 로지스틱 회귀 모형에서 선형결합식은 다음과 같다. ( | ) − 41.461 1.611 I Pclass 1 0.993 I Pclass 2 + 19.808 따라서 로지스틱 회귀 추정식은 다음과 같다. i e ( i β ) η ( i β ) 1 이 식에 값을 입력한 결과가 확률이고 0.5 보다 크면 1, 작으면 0으로 판별한다. ▼ 실제 값과 예측값이 있는 위치를 그래프에 표현하였다. SPSS 결과에 대한 혼동행렬 실제 상태 실제 생존(P) 342 실제 사망(N) 549 생존율 38.4 = TP FN + = 257 85 342 549 정밀도(accuracy) 82.2 = TP TN + = 257 475 342 549 존 망 정 생존 판정 참인 생존(TP) 257 거짓 생존(FP) 74 생존 예측도(PPV) 77.6 = TP TP FP 257 257 74 거짓 생존 예측도(FDR) 22.4 = FP TP FP 74 257 74 사망 판정 거짓 사망(FN) 85 참인 사망(TN) 475 거짓 사망 예측도(FOR) 15.2 = FN FN TN 85 85 475 사망 예측도(NPV) 84.8 = TN FN TN 475 85 475 민감도(TPR) 75.1 = TP TP FN 257 257 85 거짓 사망률(FPR) 13.5 = FP FP TN 74 74 475 생존 가능성 승산(LR+) TPR FPR 0.751 0.135 5.58 진단 승산비 LR LR = 5.58 0.29 19.41 F1 점수 2 PPV TPR PPV TPR 2 0.751 0.776 0.751 0.776 0.76 거짓 생존율(FNR) 24.9 = FN TP FN 85 257 85 특이도(TNR) 86.5 = TN FP TN 475 74 475 사망 가능성 승산(LR) FNR TNR 0.249 0.865 0.29 타이타닉 자료 혼동행렬(confusion matrix) 다진 형 로지스틱 회귀 모형 개의 수준을 갖고 있는 명목형 반응 변수 와 이를 설명하는 개의 설명변수 1 x, , M 을 갖는 다항 로지스틱 회귀 모형을 고려하자. 반응 변수 가 택하는 값의 집합은 = , ,로 나타낼 수 있으며 설명변수 = ( 1 … x) 가 택하는 값의 집합은 M 의 부분집합인로 나타내기로 한다. 이때 설명변수의 확률변수를 라고 하면 반응 변수와 설명변수는 확률변수 쌍 ( , ) 를 구성한다. ∈이고 ∈에 대하여 조건부 확률 ( = | = ) 가 양수 값을 가진다고 가정할 때 (1) ( | ) log P ( = | = ) ( = | = ) x X k K 라 하면 ( | ) 0 이다. 식 (1)에<NAME>를 취하면 ( = | = ) ( = | = ) e ( | ) 이므로, 양변을 각각에 대하여 합하면 k ( = | = ) 1 ( ∫ pdf ( ) x 1 ) 이므로 ( = | = ) 1 e ( | ) 이다. 따라서 주어진 에서 의 조건부 확률은 (2) ( = | = ; ) e ( | ) θ ( | ) ⋯ e ( | ) x X k K 로 나타낼 수 있다. 여기서 식 (2)를 다항 로지스틱 회귀 모형 (polychotomous regression model, multinomial logistic regression model)이라 하고, 특별히 = 인 경우를 로지스틱 회귀 모형 (logistic regression model)이라 부른다. ( | = ) (3) ( | = ; ) β 0 β 1 1 ⋯ β M M 1 k K 1 로 선형 가법모형이 된다. = ( 10 11 β M 20 21 β M K 1 0 K 1 1 β − , ) 벡터의 원소 수는 ( − ) ( + ) 이다. 는 범주 개수이고, 은 독립변수 개수이다. 식 (2)에서 (4) ( = | = ; ) e ( | ; ) θ ( | ; ) ⋯ e ( | ; ) e ( ; ) e ( | ; ) c ( ; ) pdf of polynomial logistic regression 다항 로지스틱 회귀 모형에 대한 우도 함수(likelihood function)는 ( ) ∏ = n θ ( | ; ) c ( ; ) 이고, 로그 우도 함수(log-likelihood function)는 ( ) i 1 [ ( | ; ) c ( ; ) ] 이다. 이 함수에서 모수 을 Newton-Raphson 방법으로 구한다. 이 방법은 이진형 로지스틱에서 계산한 것과 같다. 로그-우도 함수에서 항목(term)에 대한 편미분은 ∂ k j θ ( | i β ) x 1 δ 1 where k k { if 1 k if 1 k 이다. 식 (4)에서 분모는 ( ; ) log ( θ ( | ; ) ⋯ e ( | ; ) ) 이고, 이 항목을 편 미분하면 ∂ k j c ( i β ) e ( 1 X ; ) k θ ( | i β ) ∂ k j θ ( 1 X ; ) ≤ 1 K 1이다. 위에서 편 미분한 두 개 식을 이용하여 1차 편미분인 스코어 함수는 ∂ k j [ ( | i β ) c ( i β ) ] [ ∂ k j θ ( 1 X ; ) ] k k [ θ ( 1 X ; ) c ( i β ) ] ∂ k j θ ( 1 X [ k k e ( 1 X ; ) c ( i β ) ] j이고 2차 편미분인 헤시 안 함수는 2 β 1 1 β 2 2 [ ( | i β ) [ ( | i β ) ] = − ( i β ) ] where = ∂ ∂ k j ∂ k = ∂ β 2 2 [ θ ( 1 X ; ) k θ ( | i β ) − ∂ k j x 1 [ θ ( 1 x 1 [ θ ( 1 X ; ) c ( i β ) ] ∂ k j = j [ θ ( 1 X ; ) c ( i β ) ] [ x 2 k k + j e ( 2 X ; ) c ( i β ) ] x 1 j [ θ ( 1 X ; ) c ( i β ) ] [ 또한 추정하려는 모형 ( | = ) 에 연속형 변수의 텐서곱과 범주형 변수의 직합을 고려한다면 다음과 같이 ( | = ; ) β 0 β 1 1 ⋯ β M M β 12 1 2 나타낸다. 4. 로그 선형모형 2차원 분할표 2차원 분할표에서 범주형 변수의 표현이다. 행의 범주 개수는 개고 열의 범주 개수는 개다. X 1 Y ⋯ J 합계 1 11 n j n J 1 ⋮ ⋮ ⋮ ⋮ i i ⋯ i ⋯ i n + ⋮ ⋮ ⋮ X n 1 n j n J I 합계 + ⋯ + ⋯ + n 빈도수에 대한 분할표 다음은 각 셀의 확률에 대한 2차원 변수 분할표이다. X 1 Y ⋯ J 합계 1 11 π j π J 1 ⋮ ⋮ ⋮ ⋮ i i ⋯ i ⋯ i π + ⋮ ⋮ ⋮ X π 1 π j π J I 합계 + ⋯ + ⋯ + 1 확률에 대한 분할표 로그 선형모형 - 2차원 분할표 2차원 분할표에서 독립성에 대한 조건은 i = π + + for all i j 이다. 이 식에서 양변에 로그를 취하면 log μ j log n log π + log π j for all i j 식은 로그 선형결합식으로 표현된다. × 분할표를 로그 선형결합으로 표현하면 아래와 같다. log μ j μ λ X λ Y i j 1 2 이 표에서 윗첨자는<NAME>의 거듭제곱이 아니라 해당 범주형 변수이다. 위 식에서 각 항은 i = log π + ∑ = 2 k 2 j = log π j ∑ = 2 + 2 = log n ∑ = 2 k 2 ∑ = 2 + 2 이다. 이 모형이 × 분할표의 독립 로그 선형모형(independent log-linear model)이다. i , λ Y 는 범주형 변수, Y 의 효과이다. 모수는 모형 식별을 위해 각 수준에서 합이 0이 되어야 한다. 따라서 λ X 0 ∑ j =이다. 범주형 변수가 서로 독립이 아니라면 × 분할표를 로그 선형결합 모형은 아래와 같다. log μ j μ λ X λ Y λ j Y i j 1 2 각 항은 i = log π + ∑ = 2 k 2 j = log π j ∑ = 2 + 2 i X = log π j ∑ = 2 l 1 π l μ log n ∑ = 2 k 2 ∑ = 2 + 2 ∑ = 2 l 1 π l이다. 이 모형을 × 분할표의 포화 로그 선형모형(saturated log-linear model)이라고 한다. 모형에서 모든 가능성 있는 모수를 모두 포함한 모형을 포화 모형이라고 한다. 만일 포화 모형에서 두 변수가 독립이면 독립 로그 선형모형이 된다. 두 변수의 독립성 검정 두 변수의 독립성 검정에 대한 가설은 0 λ j Y 0 이다. 두 변수의 독립성 검정은 Pearson 2 검정과 우도비 검정(likelihood ratio test, 尤度比 檢定)으로 할 수 있다. Pearson 2 검정은 각 셀 값의 평균이 이상일 때 근사하는 제약조건이 있지만 우도비 검정은 조건이 없다. 우도비는 귀무가설 조건에서 최대우도함수( 0 )를 모수의 제약이 없는 경우 최대우도함수( )로 나눈 값 로 계산한다. 즉 우도비는 max 0 max = i 1 ∏ = l ( ^ j i) i이다. 식에서 ^ j n + + /이다. 우도비 검정에 사용하는 통계량은 2 − log λ 2 i 1 ∑ = l i log ( i μ i) 이다. 2 통계량은 근사적으로 자유도가 1인 2 분포를 따른다고 알려져 있다. 참고로 Pearson 2 검정에 사용하는 통계량은 2 ∑ = k j 1 ( i − ^ j ) μ i이다. 가변 수 만들기 회귀분석에서 범주형 변수를 설명변수로 사용할 경우 원래 변수의 값을 그대로 사용할 수 없는 경우가 많다. 예를 들어 지역을 조사하고 변숫값에 강원도(1), 경기도(2), 서울시(3), 인천시(4)로 입력했다고 가정하자. 이 값을 그대로 분석에 사용하면 4는 2의 2배이므로 그만큼 가중치를 가지게 된다. 따라서 값이 구분적인 명목이라면 가중치가 동일하게 변환해야 된다. 이런 경우 원래의 변수를 여러 개의 가변 수 (dummy variable)로 변환하여 생성된 가변 수를 설명변수로 사용한다. 범주 개수가 개일 때 − 개 가변 수 만들기 1 범주형 변수 가 갖는 값이, , , 중 하나로써 범주 수가 개인 경우 가변 수는 ( − ) 개가 만들어지며 이때 각 가변 수는 c I [ i c ] 로 1 또는 0 값을 갖는다 ( = , , C 1 ). 범주가 4개인 경우 가변 수 변환은 다음과 같다. 그 외 그 외 그 외 1 1 I [ = ] { c 1 그 외 2 2 I [ = ] { c 2 그 외 3 3 I [ = ] { c 3 그 외 원자료의 범주가 4 개인 경우 가변 수 변환하는 예는 다음과 같다. D D D ( 1 2 3 4 ) ( 0 1 0 1 0 0 0 0 1 0 0 0 ) 범주 개수가 개일 때 − 개 가변 수 만들기 2 범주형 변수에 범주 개수가 개인 경우, 자유도는 −이다. 가변 수 c 는 범주 값이 이면, 범주 값이 이면 1 , 나머지는이다. 그 외 c I [ i c ] { c 1 1 = 0 외 범주가 4개인 경우 가변 수 변환은 다음과 같다. 그 외 그 외 그 외 1 1 I [ = ] { c 1 1 = 0 외 2 2 I [ = ] { c 2 1 = 0 외 3 3 I [ = ] { c 3 1 = 0 외 원자료의 범주가 4 개인 경우 가변 수 변환하는 예는 다음과 같다. D D D ( 1 2 3 4 ) ( 0 1 0 1 0 0 0 0 1 1 1 1 1 1 1 ) 직합으로 가변 수 만들기 이 방법은 범주형 자료를 모형에 추가할 때 앞의 일반적인 가변 수 방법 대신에 직합(direct sum)을 사용하여 각 범주에 대한 가변 수와 두 개 이상의 범주가 합해진 가변 수를 모형에 추가한다. 직합을 사용한 가변 수의 생성은 다음과 같다. 범주의 개수가 이면 가변 수는 C 2 개를 만든다. 범주형 자료를 가변 수로 변경하기 위하여 1에서 C 2 까지 자연수를 모두 이진수로 변환한다. 이진수의 최대 자릿수는 C 1 이며 이진수의 숫자 개수는 이진수 0 자리에서 이진수 C 1 자리까지 개다. 십진수를 변환한 이진수가 C 1 C 1 ⋯ b − 2 − + + 0 0 일 때 c 1 은 가변 수에서 범주에 대하여 1 또는 0을 결정한다 ( ≤ ≤ − ). 번째 가변 수 A 는 십진수를 이진수 i 0 − I [ i 1 ] i 로 표현할 때 십진수인 범주형 자료는 가변 수 그 외 A { I [ i 1 ] i 0 ⋯ C 1 그 외 로 변환한다. 즉 범주형 자료는 가변 수의 이진수 c 1 로 결정되며 i 1 i ( , − ) 인 범주는 가변 수 변환 값이 모두 1이고, 그 이외는 0이다. 예를 들어 범주가 개인 경우 Category dummy 1 dummy 3 dummy 2 − 1 ( ) I [ = ] { c 1 c 1 11 ( ) I [ = , ] { c 1 2 o.w 11 ⏞ 0 ( ) I [ ≠ ] { c 1 c 1 c C 에서 가변 수 1 b = 인 경우로, 범주가 = 인 경우만 가변 수 값이 1이고 그 이외의 경우는 0이며, 가변 수 3 b = , 1 1 인 범주 = 과 범주 = 일 때 가변 수 값이 1이고 그 이외의 경우는 0이며 맨 끝에 만드는 C 2 번째 가변 수 2 −는 이진수로 변환할 경우 11 ⏞ 0 ( ) 이므로 = 인 경우만 가변 수 값이 0이고 나머지 범주 값 ≠ 은 가변 수 값이 1이다. 예를 들어 범주의 개수가 = 일 때 가변 수로 변환하면 가변 수의 개수는 3 2 6 개다. 범주 =에 대한 가변 수의 이진수 범위는 ( 001 ( ) ) 2 − = ( 110 ( ) ) 이다. 범주형 자료는 다음과 같이 가변 수 조건에 맞게 아래와 같이 값을 설정한다 그 외 그 외 그 외 그 외 그 외 그 외 1 1 ( 001 ( ) ) I [ = ] { c 1 그 외 2 2 ( 010 ( ) ) I [ = ] { c 2 그 외 3 3 ( 011 ( ) ) I [ = , ] { c 1 2 그 외 4 4 ( 100 ( ) ) I [ = ] { c 3 그 외 5 5 ( 101 ( ) ) I [ = , ] { c 1 3 그 외 6 6 ( 110 ( ) ) I [ = , ] { c 2 3 그 외 범주가 3 개인 경우 직합(direct sum)을 고려한 가변 수 변환은 다음과 같다. 원자료 자 D D D D D D ( 1 2 3 3 ) ( 0 0 0 0 0 0 1 0 1 1 0 1 1 0 1 0 1 1 0 1 1 0 1 1 ) 로그 선형모형의 디자인 행렬 다음은 확률에 대한 × 분할표이다. X 1 2 합계 1 11 12 1 X π 21 22 2 합계 + π 2 확률에 대한 × 분할표 디자인 행렬 1 × 모형에서 독립 로그 선형모형에 대한 디자인 행렬이다. 독립변수는, 가 있고, 반응 변수는 확률 값 11 π 12 π 21 π 22 이다. 디자인 행렬 구성은 상수와 범주형 변수,이다. 가변 수는 범주형 변수에 대하여 i 1 2 ⋯ C 일 때 그 외 c I [ i c ] { x = 0 외 으로 만든다. 각 변수마다 범주 개수가 개이므로 가변 수 값은 과 이 된다. SPSS에서 이 과정으로 가변 수를 만든다. 상수 모수 log ( ) ( log ( 11 ) log ( 12 ) log ( 21 ) log ( 22 ) ) 상 X ( 1 1 0 0 1 0 ) 수 ( λ λ) 디자인 행렬 2 반응 변수는 로짓함수에 적용하여 3개로 줄인다. 따라서 반응 변수는 1 log ( 11 p 22 ) F = log ( 12 p 22 ) F = log ( 21 p 22 ) 로 변환한다. 디자인 행렬 구성은 상수와 범주형 변수, 그리고 두 변수의 교호작용 ×이다. 가변 수는 범주형 변수에 대하여 i 1 2 ⋯ C 일 때 그 외 c I [ i c ] { x = − x = 0 외 으로 만든다. SAS에서 이런 방법으로 가변 수를 만들어 분석에 사용한다. 아래 가변 수 만드는 방법은 여기를 참조하였다. 각 변수마다 범주 개수가 개이므로 가변 수 값은 과 1 이 된다. 포화 모형인 경우, 교호작용 가변 수는 각 가변 수 값을 곱한다. 상수 log ( ) ( log ( 11 ) log ( 12 ) log ( 21 ) log ( 22 ) ) 상 X X Y ( 1 1 1 1 1 − 1 1 − − 1 ) − ( 1 1 ) ( 1 1 1 1 1 − − − 1 ) − ( 1 1 ) 여기서 와는 모수 벡터이고 와는 확률 합이 1이라는 제한에 필요한 정규화 상수이다. ( 1 2 3 ) ( 0 − 0 0 1 0 − ) ( log ( 11 ) log ( 12 ) log ( 21 ) log ( 22 ) ) ( 0 − 0 0 1 0 − ) ( 1 1 1 1 1 − − − 1 ) = ( 2 2 − 0 − ) 2 2 모형에서 교호작용을 제외한 독립 로그 선형모형에서 디자인 행렬은 다음과 같다. 상수 ( log ( 11 ) log ( 12 ) log ( 21 ) log ( 22 ) ) 상 X ( 1 1 − 1 1 1 1 1 ) − ( 1 1 ) ( 1 − − 1 1 1 ) − ( 1 1 ) 여기서 와는 모수 벡터이고 와는 확률 합이 1이라는 제한에 필요한 정규화 상수이다. ( 1 2 3 ) ( 0 − 0 0 1 0 − ) ( log ( 11 ) log ( 12 ) log ( 21 ) log ( 22 ) ) ( 0 − 0 0 1 0 − ) ( 1 − − 1 1 1 ) = ( 2 0 2 ) 로그 선형모형 - 3차원 분할표 2차원 분할표는 포화 모형에서 교호작용을 사용하였다. 3차원 분할표는 포화 모형이 아니더라도 교호작용을 사용할 수 있다. 3차원 분할표에서 변수 상호 간의 독립성은 조건부 독립(conditional independence) i | = + k π + 주변 독립(marginal independence) i + π + π j 상호 독립(mutual independence) i k π + π j π + 결합 독립(joint independence) i k π + π j 중 하나이다. 다음은 3차원 분할표에서 표현할 수 있는 모형이다. 세 변수 서로 독립 에 대한의 결합 독립 에 대한의 조건부 독립 조건 없는 세 변수 서로 독립 포화 모형 log μ j = + i + j + k 세 변 서 log μ j = + i + j + k + i X XY 대 log μ j = + i + j + k + i X + j Y XY 대 Z log μ j = + i + j + k + i X + j Y + k Z 조 없 세 변 log μ j = + i + j + k + i X + j Y + k Z + i k Y 포 5. 편의 회귀 모형 1. Lasso 회귀분석이란? Lasso 회귀분석은 Ridge 회귀분석과 마찬가지로 변수 선택과 모형 축소를 위한 방법 중 하나이다. Lasso는 Least Absolute Shrinkage and Selection Operator의 약어로, 변수 선택과 모형 축소를 위해 L1 규제를 적용한다. 즉, Lasso 회귀분석은 입력 변수 중에서 유용한 변수들만 선택하고, 나머지는 버리는 방법이다. Lasso 회귀분석의 수식 Lasso 회귀분석은 다음과 같은 수식으로 나타낼 수 있다. i i i e i 1 ( i β − j 1 x j j ) subject to j 1 | j ≤ 여기서 i 는 종속 변수이고, i는 독립 변수의 번째 관측치에 대한 번째 요소이다. j j 번째 독립 변수의 계수를 나타내며, 0 는 절편이다.는 L1 규제 계수이다. Lasso 회귀분석의 특징 Lasso 회귀분석은 Ridge 회귀분석과 비교하여 다음과 같은 특징을 가진다. Lasso 회귀분석은 L1 규제를 사용하므로, 계수가 0인 변수를 선택하게 된다. 이는 변수 선택에 유용하다. Lasso 회귀분석은 Ridge 회귀분석보다 모형 축소 효과가 더 강하다. Lasso 회귀분석은 변수 선택과 모형 축소를 위해 L1 규제를 사용하므로, 해석이 용이하다. Lasso 회귀분석의 예시 다음은 Python에서 Lasso 회귀분석을 수행하는 예시 코드이다. from sklearn.linear_model import Lasso from sklearn.datasets import load_boston from sklearn.preprocessing import StandardScaler boston = load_boston() X = boston.data y = boston.target scaler = StandardScaler() X = scaler.fit_transform(X) lasso = Lasso(alpha=0.1) lasso.fit(X, y) print(lasso.coef_) 이 예시 코드에서는 보스턴 주택 가격 데이터 셋을 이용하여 Lasso 회귀분석을 수행하고 있다. 먼저, 데이터를 StandardScaler를 이용하여 표준화한 후, Lasso 모델을 정의하고 alpha 값을 설정하여 학습을 진행하고 있다. 마지막으로, 학습된 모델의 계수를 출력하고 있다. 2. Ridge 회귀분석이란? Ridge 회귀분석은 일반적인 최소제곱법(OLS)의 문제점을 보완하기 위해 개발된 회귀분석 방법 중 하나이다. Ridge 회귀분석은 입력 변수들의 공선성 문제를 해결하고, 모형의 안정성을 높이기 위해 L2 규제를 적용한다. Ridge 회귀분석의 수식 Ridge 회귀분석은 다음과 같은 수식으로 나타낼 수 있다. i i i e i 1 ( i β − j 1 x j j ) subject to j 1 β 2 s 여기서 i 는 종속 변수이고, i는 독립 변수의 번째 관측치에 대한 번째 요소이다. j j 번째 독립 변수의 계수를 나타내며, 0 는 절편이다.는 L2 규제 계수이다. Ridge 회귀분석의 특징 Ridge 회귀분석은 다음과 같은 특징을 가진다. Ridge 회귀분석은 L2 규제를 사용하므로, 계수가 0이 되지 않고 작아지게 된다. 이는 변수 선택보다는 모형 축소에 유용하다. Ridge 회귀분석은 입력 변수들의 공선성 문제를 해결할 수 있다. Ridge 회귀분석은 모형의 안정성을 높일 수 있다. Ridge 회귀분석의 예시 다음은 Python에서 Ridge 회귀분석을 수행하는 예시 코드이다. from sklearn.linear_model import Ridge from sklearn.datasets import load_boston from sklearn.preprocessing import StandardScaler boston = load_boston() X = boston.data y = boston.target scaler = StandardScaler() X = scaler.fit_transform(X) ridge = Ridge(alpha=0.1) ridge.fit(X, y) print(ridge.coef_) 이 예시 코드에서는 보스턴 주택 가격 데이터 셋을 이용하여 Ridge 회귀분석을 수행하고 있다. 먼저, 데이터를 StandardScaler를 이용하여 표준화한 후, Ridge 모델을 정의하고 alpha 값을 설정하여 학습을 진행하고 있다. 마지막으로, 학습된 모델의 계수를 출력하고 있다. 3. Elastic Net 회귀분석이란? Elastic Net 회귀분석은 Ridge 회귀분석과 Lasso 회귀분석의 단점을 보완하기 위해 개발된 회귀분석 방법 중 하나이다. Elastic Net 회귀분석은 L1 규제와 L2 규제를 조합하여 적용하며, 변수 선택과 모형 축소를 동시에 수행할 수 있다는 장점을 가진다. Elastic Net 회귀분석의 수식 Elastic Net 회귀분석은 다음과 같은 수식으로 나타낼 수 있다. i i i e i 1 ( i β − j 1 x j j ) + 1 j 1 | j + 2 j 1 β 2 여기서 i 는 종속 변수이고, i는 독립 변수의 번째 관측치에 대한 번째 요소이다. j j 번째 독립 변수의 계수를 나타내며, 0 는 절편이다. 1 α는 각각 L1 규제 계수와 L2 규제 계수이다. Elastic Net 회귀분석의 특징 Elastic Net 회귀분석은 다음과 같은 특징을 가진다. Elastic Net 회귀분석은 L1 규제와 L2 규제를 조합하여 적용하므로, Lasso 회귀분석과 Ridge 회귀분석의 장점을 모두 가지고 있다. Elastic Net 회귀분석은 변수 선택과 모형 축소를 동시에 수행할 수 있다. Elastic Net 회귀분석은 입력 변수들 간의 공선성 문제를 해결할 수 있다. Elastic Net 회귀분석의 예시 다음은 Python에서 Elastic Net 회귀분석을 수행하는 예시 코드이다. from sklearn.linear_model import ElasticNet from sklearn.datasets import load_boston from sklearn.preprocessing import StandardScaler boston = load_boston() X = boston.data y = boston.target scaler = StandardScaler() X = scaler.fit_transform(X) elasticnet = ElasticNet(alpha=0.1, l1_ratio=0.5) elasticnet.fit(X, y) print(elasticnet.coef_) 이 예시 코드에서는 보스턴 주택 가격 데이터 셋을 이용하여 Elastic Net 회귀분석을 수행하고 있다. 먼저, 데이터를 StandardScaler를 이용하여 표준화한 후, ElasticNet 모델을 정의하고 alpha 값과 l1_ratio 값을 설정하여 학습을 진행하고 있다. 08. 범주형 자료분석 범주형 자료를 정리한 분할표(contingency table)는 자료 수집 방법 따라 해석을 다르게 한다. 자료 수집 방법에 따라 범주형 자료 분석 방법을 독립성 검정(independence test)과 동질성 검정(homogeneity test)으로 나누어 소개한다. 1. 독립성 검정 두 변수에 대한 범주형 자료 수집 방법이 관찰연구(observational study)인 경우 두 변수가 서로 영향을 주는지 카이 제곱 독립성 검정으로 두 집단의 독립성을 검정한다. 독립성 검정 계산 결과는 동질성 검정 계산 결과와 동일하다. 다음 자료는 A 도시에서 전동 킥보드 사용자 중 사고가 발생하여 병원에 온 환자를 6개월 동안 조사한 결과이다. 보호구 착용 여부와 부상 정도는 서로 영향을 주는지 검정하라. 부상 정도 보호구 착용 2주 이하 4주 이하 5주 이상 합계 착용 10 17 7 34 미착용 23 12 5 40 합계 33 29 12 74 보호구 착용과 부상 정도 SPSS 분석 과정 자료입력 표에 있는 자료는 원자료를 요약한 것으로 직접 SPSS에 입력한다. 자료 입력은 파일 -> 새 파일 -> 데이터 메뉴를 선택한다. 변숫값에 변수 이름, 소수점, 값 설정 새 파일을 만들면 두 개 시트가 보인다. 데이터 보기 시트는 자료를 입력하고, 변수 보기 시트는 입력한 변수를 설정한다. 자료에서 해당 변수는 열에 입력한다. 첫 열과 둘째 열은 숫자로 입력하였지만 이후 레이블을 추가하여 문자로 출력되게 설정한다. 셋째 열은 환자 수를 입력한다. 변수에 적용 결과 확인 변수 보기 시트에서 변수에 설정된 기본값을 변경한다. 이름은 변수명으로 보호구 착용, 부상 정도, 빈도를 입력한다. 현재 변수들은 소수점이 필요 없으므로 소수점 이하 자릿수는 0으로 변경한다. 값 속성에서 보호구 착용은 1을 착용, 2를 미착용, 부상 정도는 1을 2주 이하, 2를 4주 이하, 3을 5주 이상으로 레이블을 붙여 숫자에 해당 값을 표현한다. 변수에 설정한 값이 잘 적용되었는지 확인한다. 만일 값에 레이블 한 값이 보이지 않으면 보기 - > 값 레이블 메뉴를 선택하거나 버튼을 클릭하면 보인다. 가중 케이스 설정 현재 입력된 값은 원자료를 요약한 자료로 빈도를 모든 변수에 적용하려면 가중치 변수를 설정해야 한다. 가중치는 데이터 -> 가중 케이스 메뉴를 선택한다. 가중 케이스 창에서 가중 케이스 지정에 빈도 변수는 빈도로 설정한다. 카이제곱 검정 실행 이제 자료 설정이 완료되었고, 단일 표본 비율 검정은 분석 -> 기술통계량 -> 교차분석 메뉴를 선택한다. 행에 보호구 착용, 열에 부상 정도를 추가하고 통계량 버튼을 클릭하여 카이 제곱을 선택한다. 분석 결과 검정 결과 Pearson 카이 제곱에서 유의 확률이 0.053으로 귀무가설 0 "두 집단은 서로 영향을 주지 않는다."를 기각할 수 없다. 따라서 보호구 착용 유무와 부상 정도는 서로 영향이 없다. 2. 동질성 검정 두 변수에 대한 범주형 자료 수집 방법이 실험연구(experimental study)인 경우 임의로 나눈 각 집단의 항목마다 비율이 같은지 동질성 검정을 한다. 동질성(homogeneity) 검정은 독립성 검정과 계산 과정과 결과가 동일하다. 제약회사에서 개발한 신약이 효과가 있는지 조사한 결과이다. 신약과 기존 약과 차이가 있는지 검정하라. 약 효과 약 종류 효과 좋음 효과 보통 효과 없음 합계 신약 45 25 30 100 기존 약 30 30 40 100 합계 75 55 70 200 기존 약과 신약의 효과 09. 적합도 검정 적합도 검정은 추출한 표본분포가 귀무가설 분포와 동일성을 검정하는 방법이다. 1. 카이제곱 검정 적합도 검정(goodness of fit test)은 측정 자료나 관측 자료가 특정 분포를 따르는지 검정한다. 멘델의 유전법직 9:3:3:1이 올바른지 판단하려고 강낭콩을 재배하고 종류 별로 나눈 결과이다. 모양과 색 둥글고 황색 둥글고 녹색 누름 지고 황색 주름지고 녹색 합계 관측 값 107 38 45 10 200 기댓값 16 200 115.5 16 200 37.5 16 200 37.5 16 200 12.5 200 멘델 법칙 일주일 전 2개 정당 지지율이 7:3이라고 알려졌는데, 이 비율이 지속되는지 조사한 결과이다. A B 합계 60 40 100 정당 지지율 비율에 대한 일반화된 경우를 다항분포라고 하며 식은 다음과 같다. ( 1 x, , k ) n x x ⋯ k 1 1 2 2 p x 다음은 다항분포 성질이다. ( ) n i a ( ) n i ( − i ) o ( i X) − p p . ( ≠ ) 다항분포에서 확률은 많은 연산이 필요하여 직접 계산하지 않고 카이 제곱( 2 ) 분포로 계산한 확률 값을 사용한다. 2. Kolmogorov-Smirnov 검정 임의표본 1 X, , n 에 대한 경험적 분포함수 n 정의는 다음과 같다. n ( ) number of ( i x ) = n i 1 1 [ ∞ x ] ( i ) 여기서 [ ∞ x ] ( i ) 는 지시함 수로 i x 이면 1 그렇지 않으면 0이다. 누적분포함수 ( ) 에 대한 Kolmogorov-Smirnov 통계량은 다음과 같다. n sup | n ( ) F ( ) 분포 적합성에 대한 귀무가설 0 X ∼ i F i 1 2 ⋯ n 이 검정통계량은 D = sup | n ( ) F ( )이다. 검정통계량 분포함수는 Pr ( D ≤ ) 1 2 k 1 ( 1 ) − e 2 2 2 2 x k 1 e ( k 1 ) π / 3. Shapior-Wilk 검정 Shapior-Wilk 검정은 확률 표본 1 X, , n 이 정규분포 모집단에서 추출한 자료인지 검정한다. 정규분포 적합성에 대한 귀무가설 0 X ∼ i N ( , 2 ) i 1 2 ⋯ n 이며 가설검정에 사용하는 검정통계량은 = ( i 1 a x ( ) ) ∑ = n ( i x)이고 ( ) : 순서 통계량으로 표본에서 번째로 작은 값이다. ¯ : 표본평균 i ( 1 … a) m V 1이며는 벡터 놈(norm)으로 = V 1 | ( T − V 1 ) / 10. 자료 이 장은 자료 종류와 자료 요약에 관하여 살펴본다. 1. 자료 종류 자료 종류 자료는 어떤 현상을 설명하려고 수치적 특성이나 사실적 특성을 나타낸 것이다. 자료 형태 양적 자료(quantitative data) : 자료의 값이 크기에 관심이 있는 자료(연속형 자료, 이산형 자료) 질적 자료(qualitative data) : 자료의 값이 크기가 아니라 내용에 관심이 있는 자료(범주형 자료) 자료 측정 척도 명목 척도(nominal scale) : 어느 집단에 속하는지 사용하는 척도 순위 척도(ordinal scale) : 측정 대상이 서열관계를 나타내는 척도 구간 척도(interval scale) : 측정 대상의 양을 나타내는 척도로 비율 관계가 의미 없음. 절대 0이 존재하지 않음.(예 : 온도, 시간 등) 비율 척도(ratio scale) : 구간 척도의 특성을 포함하면서 비율 관계가 의미 있는 척도. 절대 0이 존재함.(길이, 무게 등) 범주형 자료(categorical data) 자료에 대한 성별이나 출신 지역과 같이 조사대상에 질적인 분류의 목적으로 만들어지거나 정책에 대한 만족도나 본인이 행복한 정도와 같이 정확하게 반응 값을 측정할 수 없어 아주 만족, 만족, 불만족, 아주 불만족 등과 같이 범주로써 측정한 자료. 명목 자료(nominal data) : 남녀, 색상. 출신 지역 등. 순서자료(ordinal data) : (상층, 중층, 하층), (소년, 중년, 장년, 노년), 3단(5단, 7단) 척도 등. 측정형 자료(measurement data, 수치적 자료) 이산형 자료(discrete data) : 자녀의 수, 발생 회수(교통사고 발생 수)와 같이 자료의 값이 셀 수 있는 경우 연속형 자료(continuous data) : 신장, 체중, 수명 등과 같이 연속적인 값을 가질 수 있는 자료 2. 숫자로 자료 요약 숫자로 자료 요약 많은 자료를 몇 개의 의미(意味) 있는 수치로 요약 자료의 분포상태(分布狀態)를 알 수 있는 통계기법(統計技法) 사용 중심 위치의 측도(中心測度, measure of center) : 어떤 값을 중심(中心)으로 분포(分布) 되어 있는지 나타내는 측도로 평균(平均, mean), 중앙(中央) 값(median), 최빈(最頻) 값(mode) 퍼진 정도의 측도(measure of dispersion) : 자료가 각 중심 위치에서 얼마나 흩어져 있는지 나타내는 측도로 분산(分散, variance), 표준편차(標準偏差, standard deviation), 범위(範圍, range), 사분위수 범위(四分位數 範圍, interquartile range) 중심 위치(中心位置) 평균(平均, mean, average) 모든 관측 값의 합을 자료의 개수로 나눈 값으로 산술평균(算術平均, arithmetic average)이라고 부름 모 평균(母平均, population mean)은 모집단 자료에 대한 평균이며, 그 값을 (mu)로 표기 표본평균(標本平均, sample mean)은 표본집단 자료에 대한 평균이며, 그 값을 ― (X bar)로 표기 평균은 모든 관측 값이 반영되기 때문에 극단적으로 크거나 작은 값(이상점, 異常點, outlier)에 영향을 많이 받음 절사 평균(切捨平均, trimmed mean)을 사용하면 극단(極端, extreme) 적인 값의 영향을 줄일 수 있음 자료의 성격에 따라 기하평균(幾何平均, geometric mean), 조화평균(調和平均, harmonic mean)이 있음 모평균 모든 자료의 합 자료의 개수 평 ( ) 모든 자료의 합 자료의 개수 x + + N 표본평균 모든 관측 값의 합 관측 값의 개수 본 균 ( ― ) 모든 관측 값의 합 관측 값의 개수 x + + n } 보기 : 평균 구하기 어떤 과목에서 6명의 학생의 점수가 다음과 같다. 표본평균을 구해보자. 89 74 91 88 72 84 ― 89 74 91 88 72 84 = 83 절사 평균(切捨平均, trimmed mean) 너무 큰 값과 작은 값을 제외한 나머지 자료에 대한 평균으로 보통 절사한 자료의 비율을 표시하기 위해 % 절사 평균이라고 표현함 % 절사 평균은 자료를 순서대로 나열했을 때 상위(上位) % 의 자료와 하위(下位) % 의 자료를 제외한 나머지 자료의 평균 보기 : 절사 평균 피겨스케이팅 경기에서 10명의 심사위원(審査委員)이 한 선수에 대한 채점(採點) 결과이다. 10 9 10 9 10 9 10 9 10 2 10% 절사 평균은 얼마인가? 최고점 (最高點) 10점과 최저점(最低點) 2점을 제외한 나머지 자료 8개의 평균인 9.5점이다. 사분위수 평균 (四分位數 平均, trimean) 자료를 순서대로 나열한 후 25 , 50 , 75의 위치에 있는 자료의 값을 각각 제1사분위 수, 제2사분위 수 및 제3사분위 수라고 함 이들은 각각 1 Q 및 3 로 나타낸다. 사분위수 평균은 중앙값과 산술평균 장점(長點)을 취(取) 하고자 제안된 것으로 1 2 2 Q 4 중앙값 (中央値, median) 전체 관측 값을 크기 순서(順序)로 배열(配列) 하였을 경우 가운데 위치하는 값 관측 값의 크기보다 관측 값의 위치(位置)가 중요 관측 값의 변화에 민감하지 않다. 즉 극단(極端, extreme) 적으로 큰 값이나 작은 값(이상점, 異常點, outlier)에 영향을 받지 않음 중앙값 구하기 관측 값을 크기 순서로 배열 자료의 개수가 홀수이면 + 2 번째 자료값이 중앙값 자료의 개수가 짝수이면 2 번째 관측 값과 2 1 번째 관측 값 사이의 중간값이나 평균이 중앙값 보기 : 중앙값 어떤 과목에서 6명의 학생의 점수가 다음과 같다. 중앙값을 구해보자. 89 74 91 88 72 84 학생들의 성적을 순서대로 배열하면 72 74 84 88 89 91이고 관측 값의 개수가 짝수이기 때문에 2 번째 관측 값 84와 2 1 번째 관측 값 88의 평균 86이 중앙값임 다음과 같이 자료 개수가 홀수일 때 중앙값은 얼마인가? 6.4 7.8 8.1 9.2 10.5 중앙값은 + 2 3 번째 값인 8.1임 최빈값 (最頻數, mode) 관측 값 중에서 가장 자주 나오는 값 연속형 자료에서 도수분포표로 자료를 그룹화하여 최대의 도수를 갖는 계급구간의 중간값을 최빈값으로 함 이산형 자료의 경우 최빈값을 대푯값으로 사용하기도 함 보기 : 최빈값 다음 자료에서 최빈값은 무엇인가? 2 5 5 3 5 2 위 자료에서 2는 두 번, 3은 한 번, 5는 세 번이므로 5가 최빈값임 퍼진 정도 중심 위치에서 얼마나 흩어져 있는지 나타내는 측도 분산(分散, variance), 표준편차(標準偏差, standard deviation) 평균에서 퍼진 척도로 사용 자료에 대한 편차(deviation)의 합은 항상 0이므로 평균에서 흩어짐의 척도로 사용할 수 없음 ( ∑ ( i X) ∑ ( i μ ) 0 ) 모분산(母分散, population variance)은 편차偏差의 제곱합 2 편차(偏差)의 제곱합 = ( i μ ) N 모 표준편차(population standard deviation)}는 모분산의 양(陽)의 제곱근 = 2 표본 분산(標本分散, sample variance)은 편차의 제곱합 2 편차의 제곱합 − = ( i X) n 1 표본표준편차는 표본 분산의 양의 제곱근 = 2 평균이 같고 분산이 다른 경우 평균이 다르고 분산이 같은 경우 보기 : 분산, 표준편차 어떤 과목에서 6명의 학생의 점수가 다음과 같다. 분산과 표준편차를 구해보자. 89 74 91 88 72 84 2 ( 89 83 ) + + ( 84 83 ) 6 1 65.6 = 65.6 8.099382693 범위(range) 범위는 (관측 값 중에서 {최댓값}) - (관측 값 중에서 최솟값) 범위는 간편하게 구할 수 있고 해석이 용이 양 끝점에서 값이 결정되기 때문에 중간의 관측 값을 알 수 없음 극단 적으로 큰 값이나 작은 값(\textgt{이상점})에 많은 영향을 받음 보기 : 범위 어떤 과목에서 6명의 학생의 점수가 다음과 같다. 자료의 범위를 구해보자. 89 74 91 88 72 84 범위 = 최댓값 - 최솟값 = 91 - 72 = 19 백분위수(百分位數, percentile) 백분위수는 관측 값을 크기 순서로 배열하였을 때 ( ≤ p ) p and P ( ≥ p ) 1 p 를 만족하는 p 백분위수는 100 p 백분위 수로 표현 백분위수는 관측 값의 규모에는 상관없고, 관측 값의 순서에만 상관있음 백분위수 구하는 과정 관측 값을 작은 순서로 배열함 관측 값의 개수(n)에 백분율(p)를 곱함 × 가 정수(整數)이면, × 번째로 작은 값과 × + 번째로 작은 관측 값의 평균이 100 p 백분위 수임 × 가 정수가 아니면, ×의 정수 부분에 1을 더한 값 m을 구하고 m 번째 작은 관측 값을 100 p 백분위 수임 사분위수(四分位數, quartile) 관측 값을 크기 순서로 배열하였을 때 전체를 사등분한 값 제1 사분위수 : 1 제25백 분 위수 제2 사분위수 : 2 제50백 분 위수 = 중앙값 제3 사분위수 : 3 제75백 분 위수 사분위수 범위(interquartile range, IQR) : 제3 사분위수 - 제1 사분위수 사분위수 범위는 중앙값을 중심 척도로 사용하는 경우 퍼진 정도의 척도로 사용 보기 : 사분위수 서울의 한 전철역에서 인천의 한 전철역까지 소요되는 시간을 기록한 자료가 다음과 같다(단위 : 분). 이 자료에서 제50 백분위 수인 중앙값과 제20 백분위수를 구하자. 42 40 38 37 43 39 78 38 45 44 40 38 41 35 31 44 이 자료를 오름차순으로 재배열하면 31 35 37 38 38 38 39 40 40 41 42 43 44 44 45 78 이고 관측 값의 개수가 16이므로 제50 백분위수는 16 0.5 8 이므로 8 번째 작은 값 40과 9 번째 작은 값 40의 평균인 40이고, 제20 백분위수는 16 0.2 3.2 이므로 (3+1) 번째 작은 값인 38이다. 대칭성 - 왜도(歪度, skewness) 분포(分布)의 대칭성(對稱性)을 나타내는 척도 3 E [ ( − σ ) ] μ σ = [ ( − ) ] ( [ ( − ) ] ) / = 3 2 / 자료가 오른쪽에 많은 경우(skewed to the left, 왼쪽으로 뒤틀림(歪))는 왜도 가 음수(陰數, negative skew; 3 0 )는 평균 중앙값 최빈값 순이다. 자료가 왼쪽에 많은 경우(skewed to the right, 오른쪽으로 뒤틀림(歪))는 왜도 가 양수(陽數, positive skew; 3 0 )는 최빈값 중앙값 평균 순이다. 자료가 대칭인 경우는 왜도 가 0( 3 0 ) 보기 : 왜도 세 분포의 통계량이 다음과 같다. 각 분포의 대칭성에 대하여 설명하라. 평균 중앙값 최빈값 왜도 분포 1 29 26 20 3 0 분포 2 71 74 80 3 0 분포 3 50 50 50 3 0 표 족함 - 첨도(尖度, kurtosis) 분포(分布)의 뾰족함(尖)을 나타내는 척도로 분포가 뾰족하면 평균에 자료가 많이 몰려있고, 뾰족하지 않으면 자료가 평균에서 멀리 있음 4 E [ ( − σ ) ] 3 μ σ − = ( − ) ( [ ( − ) ] ) − 자료가 표준정규분포보다 평균에서 흩어져 있음(표준정규분포보다 뾰족하지 않음; 4 0 ) 표준정규분포보다 자료가 평균에 많이 몰려있음(표준정규분포보다 뾰족함; 4 0 ) 표준정규분포 첨 도는 0( 4 0 ) 보기 : 첨도 세 분포의 통계량이 다음과 같다. 각 분포의 뾰족함에 대하여 설명하라. 평균 표준편차 첨도 분포 1 0 0.5 4 0 분포 2 0 1 4 0 분포 3 0 2 4 0 변동계수 중심 위치나 단위가 다른 두 개 이상의 분포의 서로 상대적인 퍼진 정도의 측도 변동계수 = 표준편차 표본평균 준 차 본 균 100 보기 : 변동계수 한 투자자가 A 회사의 주식과 B 회사의 주식 중 하나를 매입하기 위하여 6일 동안 조사한 두 회사의 마감 가격은 다음과 같다. A 회사 주식과 B 회사 주식 가격의 표본평균, 표준편차, 변동계수 등을 구하여 퍼진 정도를 비교하자. 날짜 A 회사 B 회사 날짜 A 회사 B 회사 1 76,300 6,400 4 77,200 6,900 2 77,400 7,000 5 76,900 7,300 3 77,900 7,400 6 78,800 7,600 ― = 77 417 ― = 7100 A 861 B 429 V = 1.11 V = 6.04 11. 확률분포 확률 확률의 공리(確의 公理, probability axioms) ( ) 1 ( ) P ( 1 ) ⋯ P ( n ) ( i A = , i j ) ≤ ( ) 1 여기서 i A = , i j 는 서로 배반(disjoint)이라 하며 이다. 확률 공리를 이용하여 두 사건,의 합은 이며 ( ∪ ) P ( ) P ( ) P ( ∩ ) 이다. ( ∪ ) P ( ) P ( c B ) ( ) P ( ∩ ) P ( c B ) ( c B ) P ( ) P ( ∩ ) P ( ∪ ) P ( ) P ( ) P ( ∩ ) 확률 공간 임의 실험(任意實驗, random experiment) : 실험 결과가 어떻게 될지 예측할 수 없는 실험 표본공간(標本空間, sample space : ) : 한 실험에서 나올 수 있는 모든 결과들의 모임 사상, 사건(事象, 事件, event : ) : 표본공간의 부분집합으로 어떤 특성을 갖는 결과들의 모임. ∈이고 ∈, ∈라고 하면 c F B ∈ 와 ∩ ∈, ∪ ∈ 을 만족함 근원 사상(根源事象, elementary outcomes) : 표본공간을 구성하는 개개의 결과( 1 ω, . ) 확률(確, probability; ( ) ) : 동일한 조건 하에서 한 가지 실험을 반복할 때 그 사상이 일어나리라고 예상되는 횟수의 비율( ( ) ) 확률공간 예 동전을 한 번 던지는 경우 표본공간 : = , 사건 : = , , , , 확률 [ ] P [ ∩ ] 0 [ ] 0.5 [ ] 0.5 [ , ] P [ ∪ ] 1 표본공간 예 어느 주말 오후 경부고속도로상에서 버스전용차로제를 위반하는 차의 대수를 조사한다. 이때 조사대상의 승용차가 200대 일 때 표본공간과 50 초과의 차들이 위반하게 되는 사상( )을 근원사상으로 표현하면 표본공간 : = , , , , 200 사상 : = 101 ⋯ 200 임의 실험(任意實驗, random experiment) 결과 표본공간(標本空間, sample space)의 근원사상(根元事象, elementary event)들 표현 동전을 두 번 던진 경우 근원사상은 { H H, H T } ⋅ 반을 묻는 여론조사에서 근원사상은 찬성 반대 { 성 반 } 어떤 도시에서 일주일 동안 발생한 교통사고의 횟수는 { , , , } 시행 결과(施行結果)보다 시행 결과의 수치적 함수에 관심이 있는 경우 주사위를 두 번 던진 경우 눈의 합은 { , , , 12 } 동전을 열 번 던진 경우 앞면이 나온 수는 { , , , 10 } 확률변수 확률변수(確變數, random variable)는 각각의 근원사상들에 실숫값을 대응시키는 함수로 영문 대문자, , 등으로 표시 :공정한 동전을 세 번 던진 경우 앞면 수는 동전의 앞면,는 동전의 뒷면을 나타냄 실험 결과(근원사상) 대응되는 값 HHH 3 HHT 2 HTH 2 HTT 1 THH 2 THT 1 TTH 1 TTT 0 확률변수 특성 하나의 근원사상에는 오직 하나의 값만 대응 여러 개의 근원사상이 같은의 값에 대응될 수 있음 확률변수의 값에서 역으로 대응하는 사상은 반드시 존재 이산확률변수 이산확률변수(散確變數, discrete random variable)는 확률변수 가 가질 수 값들이 유한개(有限, finite) 주사위 눈의 수 {1, 2, 3, 4, 5, 6} 공정한 동전을 3 번 던진 경우 앞면 수 {0, 1, 2, 3 } 무한 게이나 셀 수 있는(countably infinite) 경우 자연수 집합 {1, 2, } 정수 집합 { ,-2, -1, 0, 1, 2, } 연속확률변수 연속확률변수(續確變數, continuous random variable)는 확률변수 가 가질 수 값들이 무한 개이며 셀 수 없는 경우 중화요리 배달시간 [0, ) 어떤 기계의 측정오차(測定誤差) ( ∞ ∞ ) 확률분포 확률분포(確分布, probability distribution)는 확률변수가 갖는 값들과 그에 대응하는 확률 값을 나타낸 것으로 표나 수식으로 표현한다. 확률분포 예 공정한 동전을 세 번 던진 경우 앞면 수의 확률분포는 다음과 같이 표와 식으로 표현한다. 확률변수의 값 확률의 값에 대응되는 사상 0 1/8 { T } 1 3/8 { T, H, T } 2 3/8 { H, T, H } 3 1/8 { H } ( ) { ( x ) ( 2 ) ( − 2 ) − if = , , , 0 otherwise 이산확률변수의 확률분포 확률 질량 함수(確率質量函數, probability mass function)는 이산확률변수에서 확률 ( i ) 가 특정한 규칙을 갖는 경우에 식으로 표현한다. 확률변수의 값( i ) 1 2 x 합계 확률 ( i ) P ( = i ) ( 1 ) ( 2 ) f ( n ) 확률 질량 함수의 조건 ( i ) 0 i 1 2 ⋯ ( ) ∑ i Ω ( i ) 1 확률분포의 기댓값과 표준편차 확률변수 X의 기댓값(평균, ) 확률변수가 취하는 값 그 값을 가질 확률 ( ) ∑ ( 확률변수가 취하는 값 ) ( 그 값을 가질 확률 ) ∑ i f ( i ) 확률변수 X의 분산( 2 )과 표준편차( ) 의 분산 편차 확률의 분산 ∑ ( 차 ) × 률 a ( ) E ( − ) = ( i μ ) f ( i ) D ( ) V r ( ) 분산 2 계산식 평균 = x ⋅ ( i ) 모든 확률 합은 f ( i ) 1 분산 계산 a ( ) ∑ ( i μ ) f ( i ) ∑ ( i − x ⋅ + 2 ) ( i ) ∑ i f ( i ) 2 ∑ i f ( i ) μ μ ∑ ( i ) 1 ∑ i f ( i ) μ 확률분포의 기댓값과 표준편차 예 확률변수는 공정한 동전을 세 번 던진 경우 앞면 수일 때 확률분포 : 3 2 2 1 2 1 1 0 합 ( ) 8 8 8 8 8 8 8 8 X 의 기댓값 : + + + + + + + 8 1.5의 분산 : ( − 1.5 ) + ( − 1.5 ) + + ( − 1.5 ) 8 0.75의 표준편차 : ( − 1.5 ) + ( − 1.5 ) + + ( − 1.5 ) 8 0.87 확률변수를 정리하면 확률분포 : = i 3 2 1 0 합 ( ) 8 8 8 8 E ( ) ∑ i f ( i ) 3 1 + ⋅ 8 1 3 + ⋅ 8 1.5 a ( ) E ( − ) = ( i μ ) f ( i ) ( − 1.5 ) ⋅ 8 ( − 1.5 ) ⋅ 8 ( − 1.5 ) ⋅ 8 ( − 1.5 ) ⋅ 8 0.75 a ( ) E ( − ) = x 2 ( i ) μ = 2 1 + 2 3 + 2 3 + 2 1 − 1.5 = 0.75 D ( ) V R ( ) 0.75 0.87 확률변수 문제 어떤 사람이 100,000 장의 행운권을 뽑는 경우 기댓값은? 상금(천 원) 매수 1,000 1 100 4 10 10 1 100 0 99,885 합계 100,000 천원 ( ) 1 000 1 100 000 100 4 100 000 10 10 100 000 1 100 100 000 0 100 99 885 0.016 ( 원 ) 확률변수 문제 2 확률변수의 기댓값, 분산, 표준편차를 계산하라. 0 2 4 f ( ) 0.1 0.2 0.4 0.2 0.1 E ( ) ∑ ⋅ ( ) 0 0.1 ⋯ 4 0.1 2.0 a ( ) ∑ ( i μ ) f ( i ) ( − 2.0 ) × 0.1 ⋯ ( − 2.0 ) × 0.1 1.2 ∑ i f ( i ) μ = 2 0.1 ⋯ 4 × 0.1 2.0 = 1.2 D ( ) 1.2 1.095 확률변수 문제 3 다음은 로또에 대한 표이다. 경우의 수와 확률은 매주 추첨하는 로또에 적용되는 것이다. 나머지 열은 특정한 주에 추첨된 로또의 정보이다. 이 주에 추첨된 로또의 당첨금에 대한 기댓값은 얼마인가? 등수 경우의수 확률 당첨 수 상대도 수 당첨금 1인당 당첨금 배분율 1등 1 0.00001% 18 0.00002% 30,052,052,640 1,669,558,480 25.20% 2등 6 0.00007% 70 0.00006% 5,008,675,490 71,552,507 4.20% 3등 228 0.00280% 2,824 0.00237% 5,008,677,464 1,773,611 4.20% 4등 11,115 0.13646% 143,314 0.12019% 7,165,700,000 50,000 6.01% 5등 182,780 2.24406% 2,477,370 2.07757% 12,386,850,000 5,000 10.39% 낙첨 7,950,930 97.61659% 116,620,311 97.79981% - - 50.00% 합 8,145,060 100.00000% 119,243,907 100.00000% 119,243,907,000 500 100.00% 기댓값은 빈도수와 기댓값의 곱의 합을 총빈도수로 나눈다. , 669 558 480 18 71 552 507 70 1 773 611 2 824 50 000 143 314 5 000 2 477 370 0 116 620 311 119 243 907 500 로또 구입 비용은 1장에 1,000원이고 기댓값은 500원이다. 12. 이산 확률분포 베르누이 시행(Bernoulli trial) 이항분포(binomial distribution) 음이항분포(negative binomial distribution) 기하 분포(geometric distribution) 초기하분포(hypergeometric distribution) 포아송분포(Poisson distribution) 1. 베르누이 시행(Bernoulli trial) 어떤 시행에서 그 결과가 성공(S)과 실패(F) 두 가지이며, 각 시행은 서로 독립인 경우 각 시행은 성공(S), 실패(F) 두 결과. 각 시행에서 성공일 확률은 ( ) p , 실패할 확률은 ( ) 1 p 로 그 값이 일정. 각 시행은 서로 독립으로 각 시행의 결과가 서로 다른 시행에 영향을 주지 않음. ( ) { x ( − ) − if = , 0 otherwise 이항분포를 이해하려면 알아야 되는 몇 가지 수식을 소개한다. ! n ( − ) ⋯ 2 1 0 = n r n ( − ) = ( − ) ⋯ ( − + ) ( − ) ( − ) = ( − ) ⋯ ( − + ) C = ! ( − ) ×! ( r ) n ( − ) ⋯ ( − + ) ( − ) r × ( − ) = ( − ) ⋯ ( − + ) ! ( + ) = ( 0 ) 0 n ( 1 ) 1 n 1 ⋯ ( x ) x n x ⋯ ( n ) n 0 ( r ) ( n r ) ( r ) ( − r ) ( − r 1 ) ( + ) = ( + ) ( + ) − = ( + ) − + ( + ) − ∑ = k ( r ) ( k r ) ( + k ) ( + ) + = ( + ) ( + ) = [ ( 0 ) ( 1 ) + + ( m ) m ] [ ( 0 ) ( 1 ) + + ( n ) n ] 서로 다른 5개 숫자를 배열하는 경우의 수는? ! 5 4 3 2 1 120 국회의원 후보자 3 명이 다른 3개 장소에서 5일 동안 선거<NAME>는 경우의 수는? P = ! ( − ) = × × × × 2 1 5 4 3 60 우리나라에서 45개 숫자 중 6개를 순서에 상관없이 맞추면 당첨되는 로또 복권의 경우의 수는? 45 6 45 44 43 42 41 40 × × × × × = , 145 060 ( 100 1 ) 을 계산하면? ( 0 ) 100 1 + ( 1 ) 100 1 + ( 2 ) 100 1 + ( 3 ) 100 1 = + × 100 3 10 000 1 000 000 1 030 301 이항분포(binomial distribution) 성공할 확률이 인 베르누이 시행을 번 반복할 때, 성공의 횟수를 라 하면 확률변수의 확률분포 확률변수의 확률분포가 ∼ Bin( , )일 때, = , , ,에 대한 확률 질량 함수 ( ) { ( x ) x ( − ) − if = , , , 0 o.w : 베르누이 시행의 반복 횟수 : 각 시행에서 성공일 확률. ( ) : 번 시행 중 성공의 회수의 확률분포를 이항분포라 하고 ∼ Bin ( , ) 로 표현 이항분포에서 이항계수는 시행 회수 이 커지면 계산량이 급격히 증가한다. 또한 이 매우 커지면 손으로 확률 계산은 불가능하다. 따라서 이항분포의 확률은 시행 회수 이 30 이하이면 이항분포 표를 이용하고 시행 회수 이 30 보다 크면 정규분포 근사를 이용하여 구한다. 확률변수의 분포가 i ( , ) 일 때 기댓값 ( ) , 분산 a ( ) , 표준편차 d ( ) E ( ) n V r ( ) n ( − ) d ( ) n ( − ) 이다. 이항분포 문제 확률변수 가 이항분포를 따르고 = , = 0.35 일 때, 다음의 확률을 구하면? [ ≤ ] [ ≥ ] [ = or X 4 ] 확률변수의 확률분포가 ∼ Bin( , 0.35 )일 때, = , , ,에 대한 확률 질량 함수는 다음과 같다. ( ) { ( x ) 0.35 ( − 0.35 ) − if = , , , 0 o.w [ ≤ ] P [ = ] P [ = ] P [ = ] ( 0 ) 0.35 × ( − 0.35 ) + ( 1 ) 0.35 × ( − 0.35 ) + ( 2 ) 0.35 × ( − 0.35 ) = 0.7648 [ ≥ ] 1 ( [ = ] P [ = ] ) 0.5716 [ = or X 4 ] P [ = ] P [ = ] ( 2 ) 0.35 × 0.65 + ( 4 ) 0.35 × 0.65 = 0.3364 0.0488 0.3852 음이항분포 음이항분포(negative binomial distribution)는 성공할 확률이 인 베르누이 시행에서 번째에 번째 성공의 횟수가 발생할 때 확률변수의 확률분포이다. 확률변수의 확률분포가 ∼ NB ( , ) 일 때, = , + ,에 대한 확률 질량 함수 ( ) { ( − r 1 ) r ( − ) − if = , + , 0 o.w : 각 시행에서 성공일 확률 ( ) : 번 시행 회수, : 번 성공 회수의 확률분포를 이항분포라 하고 ∼ NB ( , ) 로 표현 음이항분포의 평균, 분산, 표준편차 확률변수의 분포가 NB ( , ) 일 때 평균 ( ) , 분산 a ( ) , 표준편차 d ( ) E ( ) r p a ( ) r − p s ( ) r − p 음이항분포 실제 문제 어떤 어린이가 전염성 질병에 노출되었을 때 질병에 감염될 확률이 0.4이다. 10 번째 아이가 질병에 노출되었을 때 3 번째로 질병에 감염되었을 확률은 얼마인가? B ( 10 3 0.4 ) ( 2 ) ( 0.4 ) ( − 0.4 ) = 0.0645 기하 분포 기하 분포(geometric distribution)는 성공할 확률이 인 베르누이 시행을 독립적으로 시행할 때, 첫 번째 성공이 발생할 때 확률변수의 확률분포이다. 음이항분포에서 첫 번째 성공에 대한 분포 NB( , )가 기하 분포임. ( ) { ( − ) − if = , , 0 o.w 기하 분포의 평균, 분산, 표준편차 확률변수의 분포가 NB ( , ) 일 때 평균 ( ) , 분산 a ( ) , 표준편차 d ( ) E ( ) 1 V r ( ) 1 p 2 d ( ) 1 p 2 기하 분포 실제 문제 어떤 어린이가 전염성 질병에 노출되었을 때 질병에 감염될 확률이 0.4이다. 5 번째 아이가 질병에 노출되었을 때 첫 번째로 질병에 감염되었을 확률은 얼마인가? ( , 0.4 ) 0.4 ( − 0.4 ) = 0.0518 초기하분포 초기하분포(hypergeometric distribution)는 유한 모집단에서 비복원 추출하는 경우 성공인 횟수를 의 분포이다. 확률변수의 확률 질량 함수는 ( ) { ( x ) ( − n x ) ( n ) if = a ( , + − ) ⋯ m n ( , ) o.w : 모집단의 크기, : 표본의 크기 : 모집단 내에서 범주에 속하는 구성 원소의 수 : 표본 내에서 범주에 속하는 구성 원소의 수 초기하분포의 평균 분산, 표준편차 확률변수의 분포가 초기하분포를 따를 때 기댓값 ( ) , 분산 a ( ) , 표준편차 d ( ) E ( ) n V r ( ) n ( − ) N n − s ( ) n ( − ) N n − 초기하분포 실제 문제 상자에 빨간 공 5개, 흰 공 4개가 있다. 이 상자에서 임의로 3개의 공을 비복원 추출한다고 하자. 표본 공간을 기술해 보자. 각 근원사상에 대한 확률을 구해보자 확률변수 X를 추출한 3개의 공에서 흰 공의 수일 때 확률분포를 작성하라. 포아송분포 이항분포에서 →, → 0 일 때 분포의 극한 형태는 다음과 같다. ( ; , ) ( x ) ( n ) ( − n ) − = ( − ) ( − ) ( − + ) ! ( n ) ( − n ) − = ( − n ) ( − n ) ( − − n ) ! x [ ( − n ) n λ ] λ ( − n → 라 놓으면 ( − n ) ( − n ) ( − − n ) 1 ( − n ) x 1 ( − n ) n λ 이 된다. 따라서 극한 분포는 다음과 같다. ( , ) λ e λ! f r x 0 1 2. . 이항분포 문제 사람이 여름에 탈진할 확률이 0.005라고 알려져 있다. 더운 여름날 어떤 장소에 사람이 3000명 있다고 하자. 이 사람 중 18명이 탈진할 확률이 얼마인지 이항분포로 구하면 ( 3000 18 ) 0.005 18 0.995 2982 이다. 이 식은 이항분포로 계산하면 계산량이 엄청나게 많다. 어떻게 계산할지 생각해 보자. 포아송분포 포아송분포(poisson distribution)는 매 순간마다 사건 발생이 가능하나 사건 발생 확률은 아주 작은 경우에 이용되는 확률모형이다. 확률변수 가 평균이 인 포아송 분포를 따른다고 할 때 확률함수는 ( ) { − m x if = , , 0 o.w 이다. 포아송분포 가정 주어진 구간에서 사건의 평균 발생 횟수는 구간의 시작점에는 관계가 없고 구간의 길이에만 영향을 받는다. 한순간에 2회 이상 사건이 발생할 확률은 거의 0에 가깝다. 한 구간에서 발생한 사건의 횟수는 겹치지 않는 다른 구간에서 발생한 사건의 수에 영향을 받지 않는다. 포아송분포와 이항분포의 관계 이항분포의 확률은 ≥ 20, and ≤ 0.05 일 때 포아 송 근사가 좋다고 알려져 있고 ≥ 100, and p 10 인 경우 포아 송 근사가 매주 좋다고 알려져 있다. 포아송분포 문제 포아송분포를 따르는 확률변수 X에 대하여 다음 확률을 구해보자. =3일 때 [ = ] P [ ≤ ] =4일 때 [ ≤ ≤ ] P [ = 10 ] =0.5일 때 [ = ] P [ ≥ ] 어느 가정집에 평일 평균 5통의 전화가 온다고 한다. 어느 평일 전화가 한 통도 오지 않을 확률을 구해보자. 어느 부동산 중개업소에서는 한 달에 평균 3건의 매매를 성사시킨다고 한다. 부동산 매매가 계절의 영향을 받는다고 한다면 포아송분포의 어느 성질을 위반하는 것인가? 13. 연속확률분포 확률밀도함수(probabillity density distribution) 정규분포(normal distribution) t-분포(t distribution) 카이제곱분포( 2 distribution) F-분포(F distribution) 연속확률분포 성질 확률변수 가 가질 수 값들이 무한 개이며 셀 수 없는 경우 피자 배달시간 [0, ) 어떤 측정 기기의 측정오차(測定誤差) ( ∞ ∞ ) 확률밀도함수(確密度函數, probability density function) 연속확률변수에서 확률 ( i ) 가 특정한 규칙을 갖는 경우에 식으로 표현한 것. 확률밀도함수 조건(條件) 모든 x 값에 대하여 ( ) 0 ( ≤ ≤ ) ∫ b ( ) x ( ∞ X ∞ ) ∫ ∞ f ( ) x 1 확률밀도함수 성질(性質) 연속확률변수가 어떤 주어진 x 값을 갖게 될 확률 [ = ] 0 이다. 따라서 임의의 값에서 사이의 구간 확률은 다음과 같다. [ ≤ ≤ ] P [ < ≤ ] P [ ≤ < ] P [ < < ] 정규분포 정규분포(normal distribution)는 연속확률변수 X가 위치 모수(location parameter) 평균 와 크기 모수(scale parameter) 표준편차를 가지는 분포로 그래프의 형태는 종 모양(bell curve)이고 표현은 ∼ N ( , 2 ) 임. 정규분포 성질 평균에 대하여 좌우로 대칭, 최빈값=중앙값=평균 평균 는 중심 위치를 나타내고, 표준편차는 평균 로부터 퍼져있는 정도를 나타냄 정규분포에서 [ − σ X μ 1 ] 정규분포에서 [ − σ X μ 2 ] 정규분포에서 [ − σ X μ 3 ] 정규분포에서 [ − σ X μ k ] 표준정규분포 확률변수 X가 ( , 2 ) 일 때, 평균이이고 분산이 2 로 변환하는 것을 정규분포 표준화라고 한다. 또한 이 확률변수를 표준정규분포 확률변수라고 하며로 쓴다. 표준화된 확률변수는 = − σ 이며 ( , 2 ) 인 정규분포이다. 정규분포 확률은 직접 손으로 계산하기가 수월하지 않기에 표준정규분포에 대한 확률표를 제공하며 이것을 표준정규분포 표라고 한다. 정규분포 표로 확률 계산 표준정규분포 표는 확률분포 표에서 제공한다. 정규분포 표에서 확률은 어느 방향부터 계산하는지 확인한다. 정규분포를 만든 사람에 따라 방향이 다를 수 있다. 아래 표에서 그래프의 면적은 식이나 그래프를 보면 ( ∞ z ] 이다. 정규분포 표에서는 이차원 평면에서 축 좌표값이다. 첫 열은 값이 3.5 부터 아래로 0.1씩 증가한다. 첫 행은 값이 소수점 이하 둘째 자리에 해당된다. 첫 행과 첫 열을 제외한 모든 값은 표준정규분포에서 면적이다. 첫 행과 첫 열을 제외한 값은 ∞ 에서 첫 행과 첫 열의 교차점까지 면적이다. 그림에서 첫 열의 1.9 와 첫 행의 0.06 의 교차점은 표준정규분포 값 1.96 이고, 이때 ( ∞ − 1.96 ] 까지 면적은 0.0025 이다. 그림에서 p 값은 ∞ 에서까지 면적이이다. 표준정규분포 계산 정규 확률변수를 표준 정규 확률변수로 변환 표준정규분포 표로부터 계산된 에 대한 확률을 찾음 정규분포는 대칭이기 때문에 [ < z ] P [ > ] 1 P [ ≥ z ] 로 계산함. 표준정규분포 문제 확률 [ < 0.15 or Z 1.6 ] 을 계산하라. P [ > 1.6 ] P [ < 0.15 ] P [ < 1.6 ] P [ < 0.15 ] ( P [ > 1.6 ] P [ < 1.6 ] ) 0.0548 0.4404 0.4952 표와 그림으로 설명 실제 문제 어느 대학교에서 A 과목 중간고사 성적은 분포가 평균이 63이고 분산이 100인 정규분포를 따른다고 한다. 50점 이하의 학생은 몇 퍼센트나 되겠는가? 상위 10% 학생에게 A를 준다고 한다면 몇 점 이상이 되어야 A를 받을 수 있겠는가? 1 번 문제 풀이 : [ ≤ 50 ] P ( − 63 10 50 63 10 ) P [ ≤ 1.3 ] 0.0968 2 번 문제 풀이 : [ ≥ ] 0.10 0.10 P [ ≥ 1.28 ] P ( − 63 10 1.28 ) P [ ≥ 75.8 ] t - 분포(t distribution) t 분포는 다음과 같다. 1908년 영국의 과학자 고셋(W. C. Gosset)이 Biometrika에 소개 이 논문은 필명인 Student라는 이름으로 출간 모집단의 분포가 정규분포이고 표본의 크기가 작은 경우 표본평균 ― 의 분포 모수는 자유도(degree of freedom)이며 모양은 종 형태이고, 0에서 대칭인 분포 자유도가 커지면 정규분포에 가깝게 됨 ( ) Γ ( + 2 ) ν ( 2 ) ( + 2 ) ν 1 for ∞ t ∞ 정규분포와 t 분포 비교 그림에서 ( ) 는 표준정규분포 ( ) 는 자유도가 5인 t 분포 ( ) 는 자유도가 2인 t 분포 이다. t 분포는 자유도가 커지면 정규분포에 가깝게 되며, 자유도가 이면 표준정규분포와 동일하다. t 분포 표로 확률 계산 t 분포 표는 확률분포 표에서 제공한다. t 분포 표에서 확률은 어느 방향부터 계산하는지 확인한다. t 분포를 만든 사람에 따라 방향이 다를 수 있다. 아래 표에서 그래프의 면적은 식이나 그래프를 보면 [ , ) 이다. t 분포 표에서는 이차원 평면에서 축 좌표값이다. 첫 열 d.f는 자유도(degree of freedom)다. 첫 행 는 [ , ) 까지 면적이다. 첫 행과 첫 열을 제외한 모든 값은 t 분포에서 값으로 좌표평면에서 축 값이다. 첫 행과 첫 열을 제외한 값은 자유도가 d.f이고 [ , ) 면적이 인 첫 행과 첫 열의 교차점의 값이다. 그림에서 첫 열 d.f가 9이고 첫 행 가 0.05 일 때 교차점은 t 분포 값 이 1.8331 이다. t 분포 표의 문제점은 제한적인 면적만 구할 수 있기에 자세한 것은 컴퓨터를 이용하여 계산한다. t 분포 문제 자유도가 9인 t 분포를 갖는 통계량에 대하여 ( b t b ) 0.9 를 만족시키는 를 찾아라. t 분포는 을 중심으로 대칭이므로 ( ∞ − )와 ( , )에 각각 % 의 확률이 존재한다. 자유도가 9인 t 분포에서 상위 % 확률인 제 95 백분위수를 구하면 1.8331 이다. 따라서 t 분포 표에서 0.05 ( ) 1.833 t 0.95 ( ) − 1.833 이다. 2 분포 2 분포 표는 확률분포 표에서 제공한다. 2 분포는 1900년 Karl Pearson이 제안한 분포 감마 분포의 특별한 분포 감마 분포 a m ( , ) 1 ( ) α α 1 − / χ 분포 a m ( , = / , = ) 1 ( / ) v 2 v − e x 2 2 분포는 2 검정과 분산 추론에 사용 모수(parameter)는 자유도가 있고, 모양(shape)은 비대칭형 표준정규분포의 제곱은 자유도가 1인 카이제곱분포임. 2 χ ( ) 2 분포들 2 분포가 적용되는 분석방법 모집단의 표준편차에 대한 추론 적합도 검정(goodness--of--fit test) 동질성 검정(homogeneity test) 독립성 검정(independence test) 표준편차에 대한 추론 정규모집단 ( , 2 ) 에서 추출된 표본을 1 ⋯ X이라 할 때, i 1 ( i X) σ = ( − ) 2 2 χ ( − ) 은 자유도가 − 인 2 분포를 따른다고 하고, 이것을 기호로는 2 ( − ) 로 표현한다. 2 분포 표로 확률 계산 2 분포 표에서 확률은 어느 방향부터 계산하는지 확인한다. 2 분포를 만든 사람에 따라 방향이 다를 수 있다. 아래 표에서 그래프의 면적은 식을 보면 [ 2 − ) 이다. 2 분포 표에서 2 는 이차원 평면에서 x 축 좌표값이다. 첫 열 d.f는 자유도(degree of freedom)다. 첫 행 는 [ 2 − ) 까지 면적이다. 첫 행과 첫 열을 제외한 모든 값은 2 분포에서 2 값으로 좌표평면에서 축 값이다. 첫 행과 첫 열을 제외한 값은 자유도가 d.f이고 면적이 인 첫 행과 첫 열의 교차점의 2 값이다. 그림에서 첫 열 d.f가 5이고 첫 행 가 0.95 일 때 교차점은 2 분포 값 1.1455 이다. 2 분포 표의 문제점은 제한적인 면적에 해당되는 값만 구할 수 있기에 자세한 것은 컴퓨터를 이용하여 계산한다. 2 분포 문제 2 분포 표에서 자유도가 5인 상, 하위 % 의 확률을 주는 값을 찾아라. 2 분포 표를 보면 0.95 ( ) 1.15 0.05 ( ) 11.07 F 분포 통계학자 피셔(R. A. Fisher)가 제안한 확률분포 세 집단의 평균 비교에 사용 두 집단의 분산 비율 추론에 사용(한 집단 분산 추론은 2 분포) ( ; 1 ν) Γ ( 1 ν 2 ) ( 1 ) ( 2 ) ( 1 2 ) 1 x 1 2 [ + ( 1 2 ) ] 1 ν 2 F - 분포는 서로 독립인 v 2 χ 2 일 때 = v 2 v χ 2 / 2 카이 제곱과 마찬가지로 양의 구간에서만 확률 값을 갖는다. 분포 모양은 비대칭형이다. α v, 2 1 F − , 2 v 과 같다. t 분포와 F 분포의 관계 : α 2 ( ) F, , , 2 p ( − ) − F, F 분포들 F 분포 표로 확률 계산 F 분포 표는 확률분포 표에서 F - 분포 표( = 0.05 )나 F - 분포 표( = 0.01 )을 제공한다. F 분포 표에서 확률은 어느 방향부터 계산하는지 확인한다. F 분포를 만든 사람에 따라 방향이 다를 수 있다. 아래 표에서 = 0.5 는 F 분포에서 [ , ∞ ) 의 면적이다. F 분포 표에서는 이차원 평면에서 축 좌표값이다. 첫 행 1 은 F 분포의 첫 번째 자유도(degree of freedom)다. 첫 열 2 는 F 분포의 두 번째 자유도(degree of freedom)다. 첫 행과 첫 열을 제외한 모든 값은 F 분포에서 = 0.05 일 때 값으로 좌표평면에서 축 값이다. 첫 행과 첫 열을 제외한 값은 첫 번째 자유도가 1 이고 두 번째 자유도가 2 이며 면적 = 0.05 일 때 교차점의 값이다. 그림에서 첫 번째 자유도가 1 10 이고 두 번째 자유도가 2 20 이며 면적 = 0.05 일 때 교차점은 F 분포 값 2.35 이다. F 분포 표의 문제점은 제한적인 면적에 해당되는 값만 구할 수 있기에 자세한 것은 컴퓨터를 이용하여 계산한다. 14. 표본분포 표본분포 모집단에서 뽑은 표본의 분포 통계 용어 추론(推論, inference) : 표본에서 모집단의 성질을 알아내는 것 모수(母數, parameter) : 수치로 표현되는 모집단의 특성(예 : , ) 통계량(統計量, statistic) : 표본의 관측 값에서 계산된 수치 함수(예 : ― s ) 표본분포(標本分布, sampling distribution) : 통계량의 확률분포 임의표본(任意標本, random sample) : 모집단에서 추출한 표본으로 1 X, , n 은 서로 독립이고 모두 모집단의 분포와 동일한 분포를 가짐 iid(independent and identically distributed) : 임의표본과 동일한 의미 통계량 성질 모수의 참값과 통계량은 통상적으로 같지 않음 통계량은 추출한 표본에만 영향을 받음 다른 표본은 추출하면 통계량의 값은 변함 표본분포 작성방법 모든 가능한 표본의 종류 나열 각 표본에서 통계량의 값을 구함 통계량의 값에 대응하는 확률 계산 표본평균의 분포 표본평균 ― 의 기댓값과 분산 모집단기대값 ( ― ) E [ 1 ⋯ X n ] 1 [ ( 1 ) μ ⋯ E ( n ) μ n ] μ (모집단 기댓값) 모집단의 분산 표본의 크기 a ( ― ) V r [ 1 ⋯ X n ] 1 2 [ a ( 1 ) σ + + a ( n ) σ ⏞ ] σ n 모집단의 분산 표본의 크기 모집단의 표준편차 표본의 크기 d ( ― ) V r ( ― ) σ = 모집단의 표준편차 표본의 크기 정규분포에서 표본평균 ― 분포 모평균이이고 모 표준편차가 인 정규모집단에서 개의 표본을 임의로 추출할 때, 표본평균 ― 의 분포는 ( , 2 n ) 인 정규분포를 따른다. 모집단이 정규분포이면 표본평균 ― 의 분포도 정규분포이다. 표본분포 예 숫자 (1,2,3)에서 중복을 허락하여 숫자 2 개를 뽑는 경우는 2 9 가지. f ( ) f ( ) 2 ( ) 1 1/3 1/3 1/3 2 1/3 2/3 4/3 3 1/3 3/3 9/3 합계 1 6/3 14/3 모집단 분포 = 3 2 2 14 − 2 2 σ 2 ( 1 x) (1,1) (1,2) (1,3) (2,1) (2,2) (2,3) (3,1) (3,2) (3,3) ― 1 1.5 2 1.5 2 2.5 2 2.5 3 확률 9 9 9 9 9 9 9 9 9 ― 값과 확률 ― 가 가지는 값( ― ) 1 1.5 2 2.5 3 합계 ( ― ) 9 9 9 9 9 x f ( ― ) 9 9 9 9 9 3 ― f ( ― ) 9 4.5 12 12.5 9 13 X의 확률분포 = 3 2 2 13 − 2 1 = 2 σ 1 = 2 중심극한정리 모집단의 평균이이고 분산이 2 일 때, 임의표본(random sample) 개의 표본평균을 ― 라고 하자. 중심극한정리(中心極限定理, central limit theorem)} 표본평균 ― 의 분포가 lim → Pr ( n z ) Φ ( ) lim → Pr ( ― − σ n z ) Φ ( ) → 일 때 N(0,1)인 표준정규분포를 따른다. 표본 수를 무한대로 뽑는 것은 불가능하므로, 실제로 이 충분히 클 때(보통 30 이상) 표본평균 ―는 ( , 2 n ) 인 정규분포를 따른다. 이 정리는 모집단의 분포를 모르더라도 표본평균의 분포를 알 수 있다는 점에서 분석에 유용하게 사용된다. 중심극한정리 예 평균이 82이고 분산이 144인 모집단에 대하여 표본의 크기가 64일 때, 표본평균이 81에서 83 사이에 있을 확률은? 중심극한정리에 의하여 표본평균은 ― N ( 82 ( 12 ) ) 이다. [ 81 X ≤ 83 ] P [ 81 82 / ≤ ― 82 / ≤ 83 82 / ] P [ 0.67 Z 0.67 ] 0.4950 위의 문제에서 표본의 크기가 100일 때 확률을 구하면 $$ [ 81 X ≤ 83 ] P [ 81 82 / ≤ ― 82 / ≤ 83 82 / ] P [ 1 Z 1 ] 0.5953 = 64 일 때 확률 = 100 일 때 확률 15. 통계적 추론 통계적 추론 통계적 추론(統計的 推論, statistical inference)은 추출된 표본으로부터 모집단의 일반적인 특성을 추론한다. 추정 점 추정(點檢定, point estimation) : 미지수인 모수에 대한 추측 구간추정(區間推定, interval estimation) : 추측 지를 수치화된 정확도와 함께 제시 검정 모수에 대한 가설이 적합한지 적합하지 않은지 추출된 표본으로부터 판단 추론 예 어떤 집단 남자 평균 키에 대한 추론 점 추정(點推定) :를 하나의 값으로 추정한다. 구간추정(區間推定) :를 포함할 만한 적당한 구간을 정한다 가설검정(假說檢定) : 값이 다른 집단 평균값 175cm와 다른지 판단한다. 어떤 집단 남자 평균 키에 대한 추론 결과 점 추정(點推定) : 남자 평균 키는 171.37일 것이다 구간추정(區間推定) : 남자 평균 키는 95% 신뢰수준에서 (168.9, 173.83)에 포함될 것이다. 가설검정(假說檢定) : 값이 다른 집단 평균값인 175cm와 다른지 판단은 유의수준 5%에서 유의 확률이 0.006으로 키가 175cm보다 작다고 할 수 있다. 분석 자료 추론에 사용한 자료는 평균 비교 단일 표본에 사용한 자료이다. 1. 추정 모집단에서 뽑은 표본의 분포 점 추정(point estimation) 모집단 평균인 모평균에 대한 추정 모수 : 모집단의 평균 로 추정 대상 자료 : 평균이, 표준편차가 에서 임의추출한 표본( 1 ⋯ X) 추정량 : 표본평균 ― 를 계산하여 모집단 평균 로 추정. ( ― ) μ 추정량의 표준오차 : 추정량의 정확도로. ( ― ) σ. 모집단 평균인 모평균에 대한 추정 예 모수 : 남자 전체 평균 는 실제로 모름 자료 : 남자 19명은 표본( 1 ⋯ X 19 )이다. 추정량 : 표본평균 ― 171.37 추정량의 표준오차 : n σ 를 모르기 때문에 계산할 수 없음. 추정된 표준오차 : n 5.112 19 1.173 구간추정(interval estimation) 구간추정(區間推定, Interval Estimation) : 추정량 분포를 사용하여 표본으로부터 모수가 포함될 것이라 예상되는 구간추정 신뢰구간(信賴區間, Confidence Interval) : 구간추정에서 제시되는 그 구간 신뢰구간은 (하한 값, 상한 값)의 형태로 구성 모집단에서 추출한 표본마다 계산되는 신뢰구간은 서로 다를 수 있음 가장 확실한 신뢰구간 : ( ∞ ∞ ) 어떤 정보도 제공하지 못함 신뢰수준(信賴水準, Confidence Level)}} : 신뢰구간에 모수를 포함할 확률로 보통 90%, 95%, 99%를 사용 신뢰수준 또는 신뢰도는 100 ( − ) 또는 −로 표시 모평균에 대한 신뢰구간 계산 과정 주어진 정규분포 ∼ ( , 2 ) 를 표준정규분포 ( , 2 ) 로 변환한다. 신뢰수준 100 ( − )에 대한 표준정규분포의 분위수 α 2 를 구한다. 신뢰수준 100 ( − )에 대한 표준정규분포의 범위를 구한다. 표준정규분포의 범위에 대한 부등식을 모평균에 대한 부등식으로 구한다.에 대한 부등식의 범위가 신뢰수준 100 ( − )에 대한 신뢰구간이다. 모평균에 대한 신뢰구간 계산 모집단에서 추출한 표본이 큰 경우(약 30 이상)는 중심극한정리에 의하여 표본평균 ― N ( , 2 n ) 을 따른다. 이 분포를 표준화하면 표준정규분포 ( , ) 이 된다. ( X − σ n < α 2 ) 1 α ( z / σ < ― μ z / σ) 1 α ( ― z / σ < < ― z / σ ― ) 1 α 위 식에서 모평균에 대한 100 ( − ) 신뢰구간은 ( ― z / σ, ― z / σ) 이다. 모수에 대한 100 ( − ) 신뢰구간 추정량 오차한계 추정량 번째 분위수 모수의 표준오차 추정량 ( ^ ) 오차한계(margin of error) 추정량 ( ^ ) α 번째 분위수 ( 2 th quantile ) 모수의 표준오차 (s.e( ^ ) ) ― Z / × n 모평균에 대한 신뢰구간 - 그래프로 신뢰구간의 길이 개념 조건이 모두 동일한 조건에서 신뢰도 100 ( − ) 가 커지거나 모집단에서 추출하는 표본의 개수 이 작아지거나 분산 2 이 커지면 신뢰구간의 길이는 커지게 된다. 남자 키에 대한 신뢰구간 학생 평균 키에 대한 95% 신뢰구간 ( ― Z / × n X + α 2 σ) ( 171.37 1.96 5.112 19 171.37 1.96 5.112 19 ) ( 169.07 173.67 ) 배의 평균 질량에 대한 신뢰구간 어느 배농장에서 올해 수확한 배의 평균무게( )에 대하여 알아보기 위해 배 36 개를 추출하여 무게를 달았더니 ― 706 , s 25 이 나왔다고 한다. 이때에 대한 95%, 99% 신뢰구간을 구하고 비교하자. 배 평균 질량에 대한 95% 신뢰구간 배 평균 질량에 대한 99% 신뢰구간 모평균에 대한 신뢰구간 풀이 95 신뢰구간은 = 0.05 이므로 α 2 1.96 이다. 따라서 주어진 자료로부터 95% 신뢰구간은 다음과 같다 ( 706 1.96 25 36 706 1.96 25 36 ) ( 697.83 714.17 ) or 706 8.17 99 신뢰구간은 = 0.01 이므로 α 2 2.575 이다. 따라서 주어진 자료로부터 99\% 신뢰구간은 다음과 같다 ( 706 2.575 25 36 706 2.575 25 36 ) ( 695.27 716.73 ) or 706 10.73 위의 결과로 신뢰수준이 커지는 것은 α 2 가 커지게 된다. 따라서 95 신뢰구간보다 99 신뢰구간의 길이가 더 길다. 신뢰구간 의미 평균 가 0이고, 분산 2 을 모르는 정규분포에서 표본 수가 = 인 표본 추출 과정을 100회 반복하고, 이 모든 과정을 10회 반복한 결과 모평균 =에 대한 95% 신뢰구간 100 10 모 평균을 포함하는 신뢰구간의 상대도수가 953 1000 0.953 https://hmkang98.github.io/stat/에서 실행할 수 있음 2. 검정 모집단 평균에 대한 검정 가설검정(假說檢定)이 필요한 예 높은 혈중 콜레스테롤 수치는 심혈관 질환의 원인으로 알려져 있다. 어느 도시에서 콜레스테롤 수치를 낮추면 시민들이 건강할 것으로 예상한다. 콜레스테롤 수치를 줄이는 방법은 좋은 식사습관과 규칙적인 운동 방법을 언론매체나 의료기관에서 1년간 홍보하였다. 캠페인이 성인의 콜레스테롤 양을 줄이는 효과가 있었는지 검증하려고 그 도시의 성인 50명을 대상으로 콜레스테롤 수치를 측정하였다. 캠페인을 시작 전에 조사한 결과, 이 도시 성인의 콜레스테롤 수치는 평균이 200(mg/dL)이고 표준편차는 28(mg/dL)인 분포였다. 캠페인 진행한 후 성인 50명을 뽑아 콜레스테롤 수치의 평균( ― )을 계산하였다. 이 경우 성인의 콜레스테롤 양이 줄었는지 판단하려면 어떻게 해야 하는가? 콜레스테롤 수치가 낮아졌는지 판단하기 위하여 모든 성인을 조사하는 것은 비용도 많이 필요하고 쉽지 않음 캠페인 후 그 도시의 성인 중 명 표본추출 캠페인 후 성인의 콜레스테롤 수치 모평균 가 200mg/dL보다 작다고 할 수 있는지 통계적으로 판단 ― 가 얼마나 작아야 가 200mg/dL보다 작다고 주장할 수 있을까? 가설검정 과정 3 단계 검정할 가설을 설정한다. 표본을 뽑아 가설검정에 필요한 계산을 한다. 설정한 가설이 옳은지 옳지 않은지 판단한다. 가설검정에 사용하는 용어(用語)와 개념(槪念) 가설검정(假說檢定, testing statistical hypothesis) 모수에 대한 가설이 적합한지 추출한 표본으로 판단 가설(假說, hypothesis) 귀무가설(歸無假說, null hypothesis, 0 ) : 없다고 주장하는 가설 대립가설(對立假說, alternate hypothesis, 1 ) : 있다고 주장하는 가설 두 가설은 서로 공통점이 없다. 즉 0 H = 가설 설정 적용 사례 0 : 도시의 성인 콜레스테롤 수치 평균 는 200mg/dL이다. 즉 콜레스테롤 수치는 과거 1년 전과 차이가 없다. 1 : 도시의 성인 콜레스테롤 수치 평균 는 200mg/dL보다 작다. 즉 콜레스테롤 수치는 과거 1년 전과 차이가 있으며 작다고 주장한다. 가설 판정 연구자는 귀무가설 0 판정 기준을 설정한다. 기준은 상위 5%, 하위 5%, 상 하위 2.5% 등으로 설정한다. 설정한 기준에 포함되는지 않는지 판정하는 경계점을 임곗값(threshold)이라고 한다. 연구자는 표본에서 통계량을 계산한다. 귀무가설을 기각/채택 판정은 임계점을 기준으로 판단한다. 가설 판정 적용 사례 귀무가설 0 는 도시의 성인 콜레스테롤 수치 평균 는 200mg/dL이다. 대립가설 1 은 도시의 성인 콜레스테롤 수치 평균 는 200mg/dL보다 작다. 대립가설 1 을 근거로 귀무가설 0 기각 판정 기준은 하위 5%이다. 귀무가설 0 기각/채택 임곗값은 193.49mg/dL이다. 표본평균이 193.49mg/dL 이하이면 귀무가설 0 를 기각하고 초과면 채택한다. 추출한 표본에서 계산한 표뵨평균이 195mg/dL이라면 귀무가설 0 를 채택한다. 추출한 표본에서 계산한 표뵨평균이 192mg/dL이라면 귀무가설 0 를 기각한다. 실제 상태와 가설 판정 판정 실제 0 기각(棄却) 못함 0 기각(棄却) 0 참 옳은 결정 제1종 오류 확률 0 거짓 제2종 오류 확률 옳은 결정 판정과 오류 제1종 오류 확률(type I error probability, ) : 없는데 있다고 판정하는 오류 확률. 실제 상태는 귀무가설( 0 )이 옳지만 잘못 판정하여 귀무가설( 0 )을 기각하는 오류 확률 제2종 오류 확률(type II error probability, ) : 있는데 없다고 판정하는 오류 확률. 실제 상태는 귀무가설( 0 )이 옳지 않지만 잘못 판정하여 귀무가설( 0 )을 기각하지 않는 오류 확률 검정력(power, − ): 있는데 있다고 판정하는 확률. 실제 상태는 귀무가설( 0 )이 옳지 않아 귀무가설( 0 )을 기각하는 확률 실제상태와 가설 판정 적용 사례 판정 실제 = 200mg/dL < 200mg/dL = 200mg/dL 옳은 결정 제1종 오류 확률 < 200mg/dL 제2종 오류 확률 옳은 결정 가설 판정과 오류 적용 사례 제1종 오류 확률(type I error probability, ) : 성인 콜레스테롤 수치의 평균 는 200임에도 불구하고 잘못 예측하여 200보다 작다고 판정하는 오류 제2종 오류 확률(type II error probability, ) : 성인 콜레스테롤 수치의 평균 는 200보다 작음에도 불구하고 잘못하여 200으로 판정하는 오류 검정력(power, − ): 실제 성인 콜레스테롤 수치가 200보다 작을 때, 성인 콜레스테롤 수치가 200보다 작다고 판정하는 확률 귀무가설, 대립가설, , , 기각역, 검정력 , 관계를 크게 하면 가 작아짐 를 작게하면 가 크게 됨, , power, effect size 관계 효과 크기(effect size) : 두 가설 평균 차이 μ − 1로 이 값이 크면 검정력(power, − )가 커진다. , , power, effect size 관계 두 가설 평균 차이 μ − 1 가 작아져 검정력(power, − )이 작아지고 제2종 오류( )가 커진다. , , power, effect size 관계 두 가설 평균 차이 μ − 1 가 커져서 검정력(power, − )이 커지고 제2종 오류( )가 작아진다. 검정에 사용하는 용어 유의수준(significance level, ) : 연구자가 일어날 수 있는 경우인지, 드믈게 일어나는 경우인지 판단하기 위한 그 기준을 설정한다. 묵시적으로 5%가 표준이다. 기각역(critical region) : 유의수준이 설정되면 드믈게 일어나는 경우의 영역이다. 검정통계량(test statistic) : 관측 값에서 검정에 사용할 통계량으로 예로 표본평균 ― 가 있다. 유의 확률(p-값, p-value) : 표본평균이 ― 가 귀무가설 0 에서 발생할 누적 확률이다. 모평균에 대한 통계적 가설검정 단계 귀무가설( 0 )과 대립가설( 1 )을 설정한다. 두 가설은 서로 상반된 가설로 대부분 연구자 또는 조사자는 주장하는 대립가설( 1 )이 의미 있게 귀무가설( 0 )을 기각하기 원한다. 유의수준에 대한 귀무가설( 0 )을 기각하는 영역인 기각역을 설정한다. 그리고 추출한 표본에서 검정통계량과 유의 확률을 계산한다. 검정통계량이 기각역에 속하면(유의 확률이 유의수준보다 작으면) 귀무가설( 0 )을 기각한다. 가설 설정 모평균에 대한 가설검정에서 귀무가설( 0 )은 0 μ μ 일 때 대립가설( 1 )은 귀무가설과 공통부분이 없게 1 μ μ → one sided test 1 μ μ → one sided test 1 μ μ 즉 1 μ μ 또는 1 μ − 0 two sided test 유의수준(signicance level, )으로 기각역(reject area) 계산 연구자는 스스로 귀무가설을 기각하는 유의수준을 설정 연구자가 결정한 유의수준에 대한 기각역을 계산 기각역은 대립가설 종류에 따라 세 가지로 설정할 수 있음 1 μ μ 일 때 기각역은 : ― c 이거나 : ― μ / = > α 2 1 μ μ 일 때 기각역은 : ― c 이거나 : ― μ / = < z / H : ≠ 0 일 때 기각역은 : X | c }}로 : ― c or ― − 이거나 : X − σ n = Z > α 2 R Z z / or < z / 기각역 부등호 방향은 대립가설 부등호 방향과 동일하다. 실제로 분석에서 기각역은 관심의 대상이 아니고, 기각역에 검정통계량 ― 의 포함 유무이다. 기각역에 검정통계량 ― 가 포함되면 귀무가설( 0 )을 기각한다. 같은 의미로 유의수준이 유의 확률보다 크면 귀무가설( 0 )을 기각한다. 유의수준은 묵시적으로 0.05이며, 유의 확률이 0.05보다 작으면 연구자들은 "분석 결과 유의 확률(p--value)이 0.05보다 작으면 의미 있는 결과가 나온 것이다."라고 표현한다. 단 측 검정( 1 μ μ)에서 유의수준에 대한 기각역 기각역은 대립가설 방향과 동일하며 영역이 한 쪽만 있기에 단 측 검정이다. 단 측 검정( 1 μ μ)에서 유의수준에 대한 기각역 기각역은 대립가설 방향과 동일하며 영역이 한 쪽만 있기에 단 측 검정이다. 양측검정( 1 μ μ)에서 유의수준에 대한 기각역 기각역은 대립가설 방향과 동일하며 영역이 양쪽에 있으므로 양측검정이다. 검정통계량으로 유의 확률 계산 유의 확률은 세 개의 대립가설에 대하여 기각역의 부등호 방향과 동일하게 검정통계량의 관측 값으로 계산 양측검정인 경우, 유의 확률은 검정통계량의 관측 값으로 계산한 결과에 2를 곱합 유의 확률은 손으로 계산하기가 쉽지 않으므로 컴퓨터를 이용 대부분 통계 프로그램이 양측검정 결과를 제시하기 때문에, 단 측 검정인 경우에는 2로 나눈 값이 유의 확률 값임 1 μ μ 일 때 [ ― x ] 이거나 [ ― μ / = > 0 ] 1 μ μ 일 때 [ ― x ] 이거나 [ ― μ / = < z ] 1 μ μ }} 일 때 [ ― x ] 2 or [ ― x ] 2 이거나 [ ― μ / = > 0 ] 2 or [ ― μ / = < z ] 2 유의수준과 기각역 연구자가 유의수준( )을 설정하면 기각역을 계산한다. 검정통계량과 유의 확률 연구자는 표본에서 구한 검정통계량으로 유의 확률을 계산한다. 이 검정통계량은 기각역에 포함되지 않는다. 유의수준 는 유의 확률 2 보다 작다. 검정통계량과 유의 확률 연구자는 표본에서 구한 검정통계량으로 유의 확률을 계산한다. 이 검정통계량은 기각역에 포함된다. 유의수준 는 유의 확률 1 보다 크다. 유의수준과 기각역, 검정통계량과 유의 확률 연구자는 유의수준을 설정하고 기각역을 구한다. 검정통계량 p 은 기각역에 포함되고 p는 기각역에 포함되지 않는다. 유의 확률이 유의수준 보다 작으면 검정통계량이 기각역에 포함되어 귀무가설을 기각한다. 귀무가설 0 기각 유의수준( ) 유의 확률( -값)이면 귀무가설 0 기각 통계적 가설검정 사례 가설 설정 0 : 성인 콜레스테롤 수치의 평균 는 200mg/dL이다. 1 : 성인 콜레스테롤 수치의 평균 는 200mg/dL보다 작다. 유의 확률, 유의수준, 검정통계량, 기각역 유의수준 = 0.05 (사용자가 설정) 기각역 : ≤ 1.645 or ― 193.49 ( = 0.05 σ 28 n 50 ) 0.05 P [ ≤ 1.645 ] P ( ― 200 28 50 − 1.645 ) P [ ― 200 1.645 28 50 ] P [ ― 193.49 ] 검정통계량 : ① ― 195 P [ ― 195 ] P ( ― 200 28 50 195 200 28 50 ) P [ ≤ 1.2627 ] 0.1034 X = 192 (표본에서 계산) P [ ― 192 ] P ( ― 200 28 50 192 200 28 50 ) P [ ≤ 2.0203 ] 0.0217 유의 확률 : ① [ ― 195 ] 0.1034 , ② [ ― 192 ] 0.0217 결론 ① 검정통계량이 기각역에 포함되지 않으므로 귀무가설( 0 )을 기각 못함 ② 검정통계량이 기각역에 포함되므로 귀무가설( 0 )을 기각 모평균에 대한 검정을 그림으로 모평균에 대한 검정을 그림으로 귀무가설 기각/채택 판정은 다음과 같이 결정한다. 귀무가설 0 에 대하여 검정통계량이 유의수준 를 갖는 기각역에 포함되거나 유의 확률 p-value가 유의수준 보다 작으면 귀무가설을 기각한다. 귀무가설 기각/채택 판정 정보 검정통계량이 기각역에 포함 유무로 ① 귀무가설 0 기각/채택을 판정 유의 확률 p-value와 유의수준 관계은 ① 0 기각/채택 판정과 ② p-value 확률이 기각/채택 강도 제공 신뢰구간과 양측검정 관계 모평균에 대한 검정 요약 표본의 크기가 큰 경우 모평균에 대한 귀무가설( 0 μ μ)을 검정하기 위한 통계량은 다음과 같다. ― μ s n 표본이 작아도 모집단이 정규분포를 따르면 위의 통계량을 사용한다. 표본 크기가 큰 경우, 검정통계량 분포는 0 가 맞을 때 ( , ) 을 따른다. 일 때 단 측 검정 일 때 단 측 검정 일 때 양측검정 1 μ μ 일 때 : ≤ z or > 단 측 검정 1 μ μ 일 때 : ≥ α or > 단 측 검정 1 μ μ 일 때 : Z ≥ α 2 or > 양측검정 표본 크기가 작은 경우, 검정통계량 분포는 0 가 맞을 때 ( . = − ) 을 따른다. 일 때 단 측 검정 일 때 단 측 검정 일 때 양측검정 1 μ μ 일 때 : ≤ t or > 단 측 검정 1 μ μ 일 때 : ≥ α or > 단 측 검정 1 μ μ 일 때 : t ≥ α 2 or > 양측검정 귀무가설 0 에 대하여 검정통계량이 유의수준 를 갖는 기각역에 포함되거나 유의 확률 p-value가 유의수준 보다 작으면 귀무가설을 기각한다. 최종 핵심 : p-value α 이면 귀무가설 0 기각 16. 확률분포 표 확률분포 표 이항분포 표 포아송분포표 표준정규분포 표 t - 분포 표 2 분포 표 F - 분포 표( = 0.05 ) F - 분포 표( = 0.1 )<|endoftext|>

전문분야 텍스트 ### 제목: 한땀한땀 딥러닝 컴퓨터 비전 백과사전 ### 본문: 가짜 연구소 스터디 활동으로 모인 스터디 러너분들이 딥러닝 컴퓨터 비전에 쓰이는 기초적인 개념 와 배경지식을 정리한 백과사전입니다. 경험이 많지 않은 분들이 같이 스터디를 하면서 한 땀 한 땀 내용을 정리했습니다. (초보가 정리했기에 초보의 시선으로 쓰였습니다) 정리한 내용들은 모두 웹과 인터넷을 공부하면서 필수적이라고 생각되는 개념들을 정리했습니다. 입문자분들의 성장에 큰 도움이 되었으면 좋겠습니다. 감사합니다 작성자 <NAME>(<EMAIL>) <NAME>(<EMAIL>) <NAME>(<EMAIL>) <NAME>(<EMAIL>) <NAME>(<EMAIL>) 대표 메일 <EMAIL> 혹시 틀린 내용이 있으면 대표 메일로 알려주시면 검토 후에 수정하겠습니다 1. 딥러닝 기초 딥러닝 기초에 대한 설명입니다. 퍼셉트론부터 기초적인 딥러닝 개념들에 대한 설명입니다. (1) 딥러닝과 신경망 1) 퍼셉트론과 신경망 퍼셉트론은 신경망의 기본 구성요소입니다. 신경망(Neural Net)의 기본 스트럭처를 보면 보통 아래와 같이 그립니다. 이중 빨간색 박스를 친 부분, 신경망의 구성요소를 퍼셉트론이라고 합니다. 퍼셉트론의 구성 요소 하나의 퍼셉트론을 확대하여 구성요소를 확인해 보겠습니다. 그림과 같이 퍼셉트론은 입력(inputs), 가중치(Connection Weight), 바이어스(bias), 합 연산(Sum), 활성 함수(Activation Function)로 구성되어 있습니다. 활성화 함수는 다양한 것이 많으나 퍼셉트론 쳅터에서는 활성 함수(Activation Function)을 단순화하여 입력이 0보다 작으면 0을 출력으로 입력이 0보다 크면 1을 출력하는 계단함수(Step function)라고 가정하겠습니다 하나의 퍼셉트론에서 이루어지는 연산은 "입력의 가중합" → "활성화 함수 적용" 이 두 단계가 전부입니다. 하나의 퍼셉트론으로 가능한 연산과 의미 하나의 퍼셉트론으로는 Linearly Separable Problem만 해결할 수 있습니다. 학습을 잘해서 아래와 같이 가중치가 고정되었다고 가정해 보겠습니다. 이렇게 짜인 한 개의 퍼셉트론은 우측의 표에 나온 AND 연산이 가능합니다. 두 번째로 아래와 같이 가중치가 고정되었다고 가정하면 OR 연산이 가능합니다. 또한 조금만 더 생각해 보면 한 개의 퍼셉트론은 NOT 연산도 가능합니다. 최종적으로 하나의 퍼셉트론은 입력(X)의 공간에서 그려보면 하나의 직선(하이퍼 플레인)을 의미하고 이것은 하나의 퍼셉트론은 AND, OR, NOT 연산을 통해서 Linearly Separable 문제를 해결할 수 있다는 의미를 갖습니다. AND, OR, NOT 3가지 연산이 가능하다는 것은 현재 컴퓨터에서 존재하는 3가지 기본 연산을 할 수 있다는 의미이고 이것은 퍼셉트론 여러 개를 연결하면 이론적으로는 기존 컴퓨터에서 소화하는 모든 연산(함수)를 재현할 수 있다는 것을 뜻합니다. 이런 퍼셉트론을 층(Layer) 단위로 배치하고 나열하여 만들어진 아키텍처들을 신경망(Neural Network) 혹은 모델이라고 합니다. 네트워크(Network), 모델(Model) 등 다양한 용어로 풀이되지만 해당 단어들을 보시게 되신다면 아래와 같이 여러 개 퍼셉트론이 뒤섞여 있는 구조를 지칭하는 단어라고 생각하시면 될 것 같습니다. (정확한 사전 정의보다는 빠른 이해를 위해 직관적인 표현과 관념적인 표현을 사용했습니다) 신경망으로 해결 가능한 문제들 퍼셉트론 덩어리에 활성화 함수, 네트워크 구조 변경을 통해서 문제를 잘 해결할 수 있습니다. 대표적으로 신경망으로 해결할 수 있는 문제는 Classification(분류) 문제와 Regression(회귀) 문제로 나눌 수 있습니다. Classification(분류) 실생활에서의 많은 문제는 분류(Classification) 문제에 해당합니다. 예로 들면 혈액형의 이미 지을 통해서 통해서 혈액형이 무엇인지 분류하거나. 자동차의 전장, 전폭, 전고에 따라서 소형, 중형, 대형 분류하거나. 사진 이미지의 개, 고양이 구분과 같이 속하는 클래스를 예상(Prediction) 하는 문제에 활용이 가능합니다. Image Classification, Image Segmentation도 Classification에 해당합니다. 일반적으로 Classification에서는 보통 데이터를 구성하는 클래스 개수와 동일하게 Output 레이어의 퍼셉트론의 개수를 정합니다. 예를 들어 [개, 고양이, 코끼리] 분류 문제의 경우 마지막 노드의 수는 3개가 되고 혈액형 분류 문제의 경우 마지막 노드의 수는 [A, B, O, AB] 4개로 구성합니다. Regression(회귀) 분류를 제외한 다른 문제는 회귀(Regression) 문제에 해당합니다. 숫자를 맞추는 문제라고 생각하시면 편할 것 같습니다. 얼굴 사진으로 사람의 나이를 예측하거나, 구매한 물건으로 계산 금액을 예측하는 것들을 회귀 문제라고 할 수 있습니다. 회귀 문제는 앞서 Classification 과는 다르게 몇 개의 노드로 구성된다고 말씀을 드릴 수는 없습니다. 하지만, 간단한 문제의 경우 마지막 레이어에 한 개의 퍼셉트론으로 두고, 0과 1을 출력하는 활성화 함수가 아니라 넓은 숫자 범위를 가지는 활성화 함수로 변경하여 적용해 볼 수 있습니다. 2) 학습 알고리즘 지도 학습에서 데이터(X, Y)가 준비가 되었고 특정한 모델(model)을 사용하기로 정했다면 남은 것은 가중치(Weight)를 결정하는 문제가 남게 됩니다. 보통 딥러닝에서 말하는 학습(Training)이란 퍼셉트론 사이 모든 가중치(Connection Weight)를 주어진 데이터 맞게 세팅하는 것을 뜻합니다. 지도 학습(Supervised Learning)은 일반적으로 다음 순서로 학습이 진행됩니다. [순서 1] : 모든 커넥션에 임의에 가중치를 부여합니다. [순서 2] : 가중치를 이용하여 라벨(Y)과 예측값(Prediction)의 에러(Error)를 계산합니다. [순서 3] : 에러(Error)를 각 가중치로 미분하여 기울기(Gradient)를 구합니다. [순서 4] : 기울기(Gradient)에 작은 상수를 곱하고 이 값을 기존 가중치에서 빼주어 가중치를 업데이트합니다. [순서 4] → [순서 2]로 돌아갑니다. 위 과정을 학문적으로 정확한 설명보다는 직관적으로 이해가 갈 수 있게 간단한 그림과 표현으로 정리하겠습니다.(사실 수식으로 정확하게 정리할 자신도 없습니다 ) [순서 1] 앞에서 설명한 퍼셉트론 연산이 입력층(Input layer)부터 순차적으로 이루어집니다. "이전 퍼셉트론 출력의 가중합" → "활성화 함수 적용"이 네트워크를 따라서 계속 이루어지고, 위의 이미지를 예로 들면 마지막 퍼셉트론에서 활성화 함수를 적용한 것이 예측치가 될 것입니다. 예상하신 것과 같이 당연히 [순서 1]에서 무작위로 배정된 가중치이기에 이 예측값은 절대로 맞을 리가 없습니다. [순서 2] 뉴럴넷을 통해 계산된 예측치(Prediction)과 라벨 값(Y)의 에러(Error)를 구합니다. 사실 에러(Error)의 정의가 굉장히 모호하다고 생각하실 것 같습니다. 에러(Error)는 개발자가 선택한 특정 함수를 이용하여 계산됩니다. 딥러닝에서 중요한 부분 중에 하나는 이 에러를 구하는 함수를 정의하는 것이고 어떤 정의하느냐에 따라 최종적으로 신경망에 업데이트되는 가중치의 값이 달라집니다. 왜냐면 대부분 딥러닝의 학습 메커니즘이 에러 함숫값을 최대화 혹은 최소화하도록 구성되어 있기 때문입니다. 일반적으로 분류 문제의 경우는 Cross Entropy Error를 이용하고, 회귀 문제의 경우 Mean Squared Error를 이용합니다. 앞으로 소개해 드릴 컴퓨터 비전의 각 분야에는 다행히 사용하는 에러 함수가 고정되어 있는 경우가 많습니다. 하지만 앞으로 각 분야에서 더 좋은 에러 함수는 개발이 될 것이고, 관심이 가는 분야에 자주 쓰이는 에러 함수가 있다면 해당 알고리즘을 주의 깊게 봐야 할 필요는 있다고 생각합니다. 대충 에러 함수라고 설명드리긴 했지만 일반적인 용어가 있습니다. 목적함수(Objective Function), 로스 펑션(Loss function)이 그것이며 해당 용어가 나오면, 라벨 값과 예측값의 차이를 의미하는구나라고 이해하시면 될 것 같습니다. 보통 로스 펑션이라고 하며 이것은 함수의 출력값(Loss)가 클수록 라벨과의 차이가 크다는 것을 의미합니다. 학습 알고리즘은 반복을 통해 이 로스 값이 최소가 되도록 가중치를 조금씩 변경합니다. [순서 3] 에러는 무엇으로 구성되어 있는지 먼저 보겠습니다. 예를 들기 위해 회귀 문제에 자주 사용되는 MSE를 로스 펑션으로 사용한다고 하겠습니다. 여기에서 X, Y 값은 고정된 상수이고 가중치(w)들만이 고정되지 않은 변수입니다. 따라서 로스 펑션은 가중치(w)들의 함수라고 할 수 있습니다. 학습의 목적은 주어진 데이터(X, Y)에 대해서 가중치(w)들을 적절히 세팅해서 에러가 최소가 되도록 하는 것입니다. 미분해서 0이 되는 가중치(w)을 찾으면 좋겠지만 아쉽게 수백만 개의 변수(가중치)들이 엉켜있어 그렇게 구하는 것은 단순한 뉴럴넷이 아니고서는 불가능합니다 대신 최적해(Global optimum)를 찾는 것이 아니라 반복을 통해서 그중에서 제일 로스 값을 작게 만드는(minimize) 가중치(Local optimum)를 찾는 것은 가능합니다. 각 가중치(w)들 세팅된 현재 지점에서의 기울기를 먼저 구해보면 기울기의 반대 방향으로 향하는 것이 에러의 값을 감소시킨다는 것을 알 수 있습니다. 쉽게 생각하면 현재 위치 기울기의 반대 방향으로 가충치를 이동하면 무조건 에러는 감소하게 됩니다. [순서 4] 이제 가중치 방향을 알았으니 이동할 크기를 정해야 합니다. 가중치의 이동할 양은 개발자가 결정합니다. 크게 이동하면 많이 어긋날 수 있으니 보통은 작은 값으로 선택합니다. 선택한 작은 값에 기울기의 반대 방향을 곱하고 이 크기만큼 가중치를 이동합니다. 3) 활성화 함수 다시 한번 퍼셉트론으로 돌아가겠습니다. 결국에 퍼셉트론의 출력값은 "Activation_Function(모든 퍼셉트론 입력의 가중 합)"이 됩니다. 활성화 함수의 종류와 선택 활성화 함수는 아래와 같이 다양한 종류가 있고 신경망을 개발할 때 사람이 선택 가능합니다. 활성화 함수의 선택은 신경망의 예측 성능에 영향을 미칩니다, 논문을 보니 보통은 하나씩 다 해봐서 성능이 좋은 것을 선택하는 것 같습니다. 마지막 활성화 함수는 전체 뉴럴넷의 출력값을 결정하기 때문에 중요한 의미를 갖습니다. 예를 들어 1장에서 말씀드린 회귀 문제 예측하기 위한 신경망의 경우 Sigmoid와 같이 0~1사이의 범위만을 갖는 활성화 함수를 사용하면 트레이닝을 아무리 진행해도 오차(Error)가 감소가 되지 않을 것입니다. 일반적으로 이중 분류 문제 True(1), False(0)를 예측하는 경우 마지막 레이어의 활성화 함수를 Sigmoid를 사용해서 두 개 중 어느 클래스에 가까운지 예측합니다. 주택 가격 예측과 같은 회귀 문제의 경우 마지막 퍼셉트론에 활성화 함수를 사용하지 않고 가중 합하여 예측값를 계산하거나, ReLU와 같이 값이 무한한 활성화 함수를 사용할 수 있습니다. 최소한 활성화 함수 출력 범위 내에 라벨 값(Y)들이 포함되어 있어야 정상적인 학습이 진행됩니다. 활성화 함수는 왜 필요할까? 조금 생소한 용어지만, 활성화 함수는 신경망에 비선형성(non-linearity)을 더해줍니다. 사실 딥러닝으로 해결하려는 문제들은 대부분 단순한 문제들이 아닙니다. 굉장히 복잡하고 난잡한 문제들이기 때문에 데이터 속에 숨겨 저 있는 진짜 회귀 선, 경계면은 입력 데이터(X)의 다차원 공간에서 굉장히 해괴한 곡선(비선형)의 모습을 보여줍니다. 만약 활성화 함수를 사용하지 않고 입력 데이터(X)에 가중합만 이용한다면 복잡하고 유연한 함수를 생성 것이 아니라 데이터의 선형 변형(Transformation)만을 하기 때문에 복잡한 진짜 회귀 선, 경계면에 핏팅하기가 어렵습니다. 그냥 심플하게 정리하면, 활성화 함수를 써야만 주어진 데이터를 설명하는 복잡한 형상의 선이나 경계면을 찾을 수 있습니다 4) 로스 펑션 앞에서 학습 알고리즘에서 에러 함수라고 말씀드렸지만, 다양한 논문 및 참고 자료에는 에러 함수라는 용어보다는 로스 펑션(Loss function)이 더 일반적인 것으로 보입니다. 로스 펑션은 라벨 값과 예측값의 차이를 로스(Loss)라고 말하고 이들을 계산하기 위한 함수를 의미합니다. 그리고 학습은 로스(Loss)를 최소화하는 방향으로 가중치를 업데이트하며 진행됩니다. 학습의 진행이 로스(Loss)를 최소화하는 방향으로 진행되기 때문에, 로스 펑션(Loss function)을 제대로 정하는 것은 매우 중요합니다. 같은 네트워크를 사용한다고 하더라도 로스 펑션을 바꾸면 가중치는 다른 값으로 업데이트가 진행되고 최종적으로 뉴럴넷의 성능이 달라지게 됩니다. 로스 펑션은 목적에 맞도록 변경되는 경우도 많고 연구자의 의도에 따라 변형되는 경우가 많아 케이스별로 추가 학습이 필요합니다. 여기에서는 분류(Classification)과 회귀(Regression)에 가장 많이 쓰이는 MSE와 Cross Entropy를 정리해 보도록 하겠습니다. Mean Squared Error 가장 직관적인 로스 펑션입니다. 라벨 값과 예측값 차이의 제곱을 로스로 계산하는 로스 펑션입니다. 예측값이 라벨 값보다 크게 예측되거나 작게 예측되건 간에 제곱을 곱해주어 미분이 깔끔합니다. 회귀(Regression) 문제에서 광범위하게 사용되고 있습니다. Cross Entropy Cross Entropy(아래부터는 CE로 사용하겠습니다)는 분류 문제에서 사용되는 로스 펑션입니다. CE 이전에 분류 문제에서 중요한 한 가지를 더 정리할 필요가 있습니다. 소프트맥스(Softmax) 함수인데 사실 함수이긴 하지만 그냥 퍼셉트론 사이에 끼어있는 하나의 레이어로 이해하는 것이 더 직관적입니다. True, False와 같이 두 개를 클래스를 분류하는 문제가 아니라 [강아지, 고양이, 하마, 사슴, 기린]과 같은 다항 분류 문제에서는 마지막 퍼셉트론의 활성화 함수를 Sigmoid로 바꾸는 것만으로는 예측할 수 없습니다. 그냥 Output 레이어 이전 레어어 퍼셉트론들에 마음대로(?) 활성화 함수을 붙이고 이 값들을 Softmax 레이어를 통과시키면, Softmax 레이어 안에서는 이전 레이어 출력값의 크기에 따른 각각의 비율을 계산하여 최종 출력값으로 내보냅니다. 그렇기 때문에 각 클래스를 대표하는 모든 노드들의 출력값의 합은 1이고 범위는 0~1사이로 제한됩니다. 이 상태에서 CE의 로스를 계산할 수 있습니다. log 함수에서 0~1의 사이는 모두 음수로 출력되기 때문에 앞에 -(마이너스)가 붙었고 라벨은 해당하는 카테고리 값만 1을 가지고 있어 로스 값은 정답 클래스의 확률을 낮게 계산할수록 로스(Loss) 값이 크게 계산됩니다. 특수한 경우가 아니면 다음 반복 시에는 정답 클래스의 확률이 높게 계산되도록 가중치가 업데이트됩니다. 5) 옵티마이저 일반적으로는 Optimizer라고 합니다. 뉴럴넷의 가중치를 업데이트하는 알고리즘이라고 생각하시면 이해가 간편하실 것 같습니다. 가중치를 업데이트하는 방법은 경사하강법에서 생기는 여러 가지 단점을 극복하기 위해 다양한 알고리즘이 제안되었습니다. 웹에서 너무 잘 표현한 한 장의 이미지가 있어 먼저 보고 설명을 계속하겠습니다. (공부하는 입장에서 정리를 너무 잘 된 그림이라고 생각합니다 ) 기존에 경사하강법(GD)을 사용할 때 생기는 문제점에 대해서 먼저 설명드리고 이를 보완하기 위해 어떻게 발전했는지 큰 줄기를 설명드리겠습니다. GD(Gradient Descent)의 문제점 첫 번째 문제점은 모든 데이터를 다 계산하고 발생한 모든 에러를 합(Sum) 하여 가중치(Weight)를 업데이트합니다. 하지만 실제 학습에 사용하기에는 큰 문제가 생깁니다. 뉴럴넷이 성능을 발휘하기 위해 가중치를 업데이트하기 위해서는 전체 데이터 셋을 이용하여 수십 번의 가중치를 업데이트해야 합니다. 하지만 GD의 경우 너무 느리고, 메모리 소모가 많습니다. 예시로 1000개의 데이터 셋이 존재하고, 뉴럴넷의 가중치가 200개 존재한다고 가정해 보겠습니다. GD의 방법은 1000개의 데이터 셋에 대해 모든 gradient를 더한(Sum) 한 값에 학습률을 곱하여 가중치를 업데이트합니다. 다시 말해, 1Epoch에 1번의 update가 이뤄집니다. (※ 트레이닝 데이터를 모두 활용하여 학습을 진행한 것을 1Epoch이라고 합니다.) 예시의 경우에는 모든 가중치를 "한번" 변화시키기 위해서 약 1000*200번의 gradient 계산이 필요합니다. GD는 모든 데이터에서 Gradient의 계산이 종료될 때까지 업데이트가 이뤄지지 않아 너무 많은 메모리와 시간을 필요로 합니다. SGD(Stochastic Gradient Descent) 이러한 문제점을 해결하기 위해 약간의 트릭을 추가한 SGD 옵티마이저가 생겨났습니다. SGD는 전체가 아니라 배치(Batch) 단위로 가중치 업데이트하자는 아이디어입니다. (※ 배치(Batch)란 전체 데이터를 동일한 숫자로 나눈 것을 말합니다) 1000개의 데이터 셋을 200개 1배치로 묶으면, 1epoch 당 총 5번의 업데이트가 일어납니다. 정말 운 좋게 기울기의 변화가 없는 얼리 스톱의 조건이 3~4번째에서 배치에서 일어났다면 학습이 조기 종료할 수도 있습니다. 앞으로 소개해 드릴 옵티마이저는 배치 아이디어를 적용시킨 SGD를 기본으로 사용합니다. GD, SGD의 개선 몇 가지 조금 복잡한 몇 가지의 개념을 활용함으로써 SGD, GD를 더욱 발전시킨 옵티마이저들이 존재합니다. 크게 2가지 방법을 사용해서 옵티마이저의 성능을 개선했습니다. ① 과거의 진행 방향을 참고하는 관성(Momentum)을 사용합니다 (ex) Momentum, NAG ② 이제까지 계산된 Gradient에 따라 다른 학습률(Adaptive Learing Rate)을 가지도록 합니다 (ex) Adagrad, RMSProp ③ 관성(Momentum)과 스텝 사이즈 변화(Adaptive Learning Rate) 두 가지를 다 고려합니다. (ex) Adam Momentum 모멘텀은 물리의 관성 개념을 옵티마이저에 적용했습니다. 모멘텀은 step에서의 gradient η과 이제까지의(과거) 이동한 gradient의 exponential average를 더해줍니다. 식을 보면 굉장히 복잡해 보이지만 사실은 그저 과거의 gradient의 파라미터(γ)로 조절하여 더해줄 뿐입니다. 모멘텀 개념이 적용된 옵티마이저를 사용하면 SGD가 가지지 못했던 장점을 가질 수 있습니다. 첫 번째로, 관성이 붙어 Local optimum을 벗어날 수도(?) 있습니다. 두 번째로, 궤적이 크게 변동하지 않아, SGD보다 안정적으로 Gradient가 하강합니다. Nesterov Accelerated Gradient(NAG) Momentum의 단점은 가중치(Weight)의 이동량을 계산하기 위해 Momentum과 Gradient 두 가지를 한 번에 업데이트해야 합니다. NAG에서는 업데이트가 과도하게 계산되는 것을 줄이기 위해, Momentum과 Gradient의 순서를 분할합니다. 현재 위치에서 t 시점으로 Momentum만 계산하여 이동을 하고, 이동한 곳을 기준으로 Gradient를 계산하여 두 번째로 이동합니다. NAG는 한 번에 먼 이동이 아니라, 순서를 나누어 이동하므로 Momentum보다 부드러운 궤적을 가지게 되고 모멘텀과 같이 과도한 업데이트가 일어나지 않습니다. Adagrad Adagrad 옵티마이저(Optimizer)부터는 기존에 상수였던 학습률(η, 러닝 레이트, Learing rate)을 선택적으로 조절하는 옵티마이저 입니다. 현시점까지의 계산되었던 모든 Gradient의 제곱합에 반비례하는 학습률을 가집니다. 다시 말해, 학습이 진행될수록 이동량은 줄어들게 됩니다. 물론, Global Optimum 근처에서의 이동량 감소는 좋은 경우이지만, Global Optimum 근처까지 도달하지 못했는데도 이동량이 줄어드는 것은 큰 단점입니다. 다음의 RMSprop는 이런 점을 보완했습니다. RMSProp 앞에서 말씀드린 Adagrad Optimizer의 단점을 개선한 옵티마이저입니다. 크게 바뀌지는 않았습니다. 과거 Gradient의 값들과 현재 gradient 값들의 비율을 하이퍼 파라미터로 조절합니다. Adam RMSProp + Momentum Adaptive Learning rate와 Momentum 개념이 합쳐진 옵티마이저입니다. 두 가지가 합쳐졌기에 하이퍼 파라미터는 두 개를 가집니다 여러 코드를 볼 때 현제 제일 많이 사용하는 옵티마이저 같습니다. Reference https://icim.nims.re.kr/post/easyMath/428 https://needjarvis.tistory.com/694 6) 딥러닝 테크닉 딥러닝은 다른 ML에 비해 뛰어난 성능을 발휘하는 방법이지만, 학습하기가 까다롭습니다. 이번 쳅터에서는 딥러닝의 성능과 학습을 위해 개발된 몇 가지 방법들을 살펴보겠습니다. 기울기 사라짐(Gradient Vanishing) 문제와 활성화 함수(Activation Function) 딥러닝에서 복잡한 문제를 해결하기 위해서는 보통 사용자가 여러 개의 Layer를 쌓습니다. 이렇게 복잡한 Layer가 쌓였을 경우 발생하는 대표적인 문제가 기울기 사라짐(Gradient Vanishing)입니다. 앞에서 설명드린 것과 같이 뉴럴넷 학습에서는 오차 역전파 방법을 사용합니다. 오차 역전파는 필연적으로 과거 사용된 활성화 함수의 도함수가 여러 번 곱해지게 됩니다. 이때 만약 Sigmoid와 같은 활성화 함수를 사용했다면, 필연적으로 기울기 사라짐 문제가 발생합니다. 시그모이드의 함수 그래프를 보면 위와 같이 생겼고, 도함수는 우측과 같습니다. 때문에 도함수 값은 0~1/4 사이 값을 가지게 됩니다. 이런 도함수 값이 거듭해서 곱해지게 될 경우 필연적으로 0으로 값이 수렴하게 됩니다. 따라서 오차의 그레이디언트 값(dE/dw)은 0이 되어 가중치는 더 이상 업데이트가 되지 않는 현상이 발생합니다. 이런 현상은 활성화 함수의 도함수가 여러 번 곱해지는 Input Layer 근방에서 더 크게 나타나게 됩니다. 이 문제는 활성화 함수(Activiation Function)을 변경해 어느 정도 막을 수 있습니다. ReLU 함수는 도함수 값이 0 또는 1로 결정이 되게 됩니다. 오차를 앞 레이어에 전달하지 않거나 100% 전달하거나 둘 중 하나로 학습이 진행되기 때문에 거듭 곱해진다고 해서 다행히 Sigmoid와 같이 Gradient Vanishing 문제가 필연적으로 발생하지 않습니다. 하지만, 희박한 확률이지만 특정 layer에서 모든 퍼셉트론들의 도함수 값이 0이 되어버려 Gradient Vanishing이 발생할 수 있습니다. (이 문제를 개선한 Leaky ReLU와 같은 함수도 존재합니다) 이런 이유로 일반적으로 Hidden Layer에서는 활성화 함수로 ReLU 계열을 사용하고 마지막 Output Layer에서만 Sigmoid와 같이 목적에 맞는 활성화 함수를 사용합니다. 오버 피팅(Overfitting)과 정규화(Regularization) 딥러닝에서 가장 흔하게 나타나고 해결하기 어려운 문제는 오버 피팅(Overfitting)입니다. 언더, 오버 피팅(Overfitting)에 대해 설명하고, 이 현상을 막기 위한 대표적인 3가지 방법 Early Stop, Weight decay, Dropout에 대해서 소개하겠습니다. 언더 피팅(Underfitting), 오버 피팅(Overfitting) 지도 학습 딥러닝 모델(Supervised Deep Learning)의 목표는 주어진 데이터를 이용해 데이터를 잘 설명하는 모델을 만들고, 만들어진 모델을 이용해서 학습하지 않은 데이터에서도 예측력이 우수한 모델을 만드는 것이 목표입니다. 이를 위해서 우리는 Gradient descent를 이용해서 예측값(Prediction)과 현상(Label) 간의 오차(Loss)를 최대한 줄이는 방법을 이용하여 학습(Training) 하였습니다. 딥러닝 학습에 사용한 신경망 구조가 너무 단순(too simple) 해서 Training 데이터와 Test 데이터 모두를 설명하고 예측하지 못하는 경우를 우리는 언더 피팅 현상이라고 합니다. 반면에 딥러닝 학습에 복잡한 모델(too complex)을 사용하면 Training 데이터에 대해서는 정확히 설명할 수 있으나, Test 데이터의 예측력은 매우 떨어지게 됩니다. 이런 케이스를 Overfitting이라고 합니다. Underfitting 문제의 설루션은 (주어진 데이터를 더 잘 설명하는) 적당한 모델을 선택/개발하는 방법과 학습을 더 많이 하는 방법이 있습니다. 하지만 이미 충분히 복잡한 신경망에서 나타나는 Overfitting 문제의 해결을 위해서는 기존 학습 알고리즘에 여러 가지 정규화(Regularization) 방법을 추가해서 해결합니다. 얼리 스톱(Early stopping) 오버 피팅을 막는 가장 손쉬운 방법입니다. 트레이닝 세트에 가중치가 최적화되기 이전에 학습을 조기종료 시키는 방법입니다. 물론 가중치 업데이트에 테스트 세트를 포함시키지 않고 에러 모니터링만 합니다. 테스트셋의 학습이 진행될수록 사용자가 지정한 횟수(ex, 5회) 동안 로스가 상승한다면 오버핏이 나타난다고 간주하고 학습을 중지합니다. Weight decay 로스 펑션에 추가적인 페널티 텀을 붙여서 로스 펑션을 수정하여 학습하는 방법입니다. 보통은 L2 Regularization을 사용하니 L2를 기준으로 설명드리겠습니다. 첫 번째 E(W)의 식은 앞서 설명드린 것과 같이 Label과 Prediction 과의 Error를 최소화되도록 학습이 진행되고 뒤의 λ*(W^2)는 가중치의 L2 norm을 최소화하라는 말과 같습니다. 모순적인 요구 조건이 두 가지로 섞여 있습니다. 일반적으로 가중치의 L2 norm을 최소화하면 Error는 상승하고, Error를 최소화하면 L2 norm의 값은 상승하게 됩니다. 정리하면, 두 가지 요구사항 가중치의 L2 norm과 Error를 합쳤을 때 최소화하는 적당한(?) 가중치를 찾으라는 요구 조건으로 해석할 수 있습니다. 이러한 요구 조건을 만족시키면 뉴럴넷은 Training data에 최적화된 가중치가 아니라 모든 퍼셉트론의 가중치가 일정 수준 이상을 가지는 균형적인 가중치로 학습이 됩니다. Dropout 랜덤 포레스트의 앙상블과 매우 유사한 방법입니다. 랜덤 포레스트는 서로 다른 Feature를 랜덤으로 선택하고 만들어진 Decision Tree들의 앙상블로 결괏값을 예측하는 모델입니다. 뉴럴넷의 Dropout도 이것과 매우 흡사한 방법입니다. 미니 배치마다 히든 레이어에서 임의의 노드들을 랜덤으로 선택해서 학습을 진행합니다. 남겨진 퍼셉트론과 연결된 가중치는 drop 안 할 때보다 더 강한 가중치 값을 가지게 됩니다. 하지만, 실제 테스트(inference) 시에는 drop 하지 않고 모든 가중치에 (1-drop_rate)%를 곱해 전체 가중치를 한번 스케일링하여 Prediction 합니다. 7) 성능 평가(★작성 중) ... (2) 딥러닝 기본 네트워크 딥러닝 기본 구조인 MLP, CNN, RNN 그리고 트랜스포머와 오토 인코더에 대한 설명입니다. 1) MLP(★작성 중) ... 2) CNN CNN 이란? 이미지에 특화된 신경망 구조입니다. 학습 파라미터의 개수가 FC 구조에 비해 매우 적어, 다른 네트워크에 비해 효율적인 구조입니다. (사실 이 분야, 저 분야에 다 쓰여서... 이미지에 특화되었다고 하기에도 어렵습니다) 안 쓰이는 곳이 없는 네트워크 구조이므로 깊은 이해가 필요한 신경망입니다. 커널(kernel) 커널(kernel)은 필터(filter), 마스크(mask)와 같은 말입니다. 커널의 기능은 이미지로부터 내가 원하는 정보(특징)만을 추출하는 것입니다. 커널은 이미지 데이터를 지정된 간격(stride)으로 움직이며 합성곱(convolution)을 수행하고 합성곱 연산을 통해 나온 결과가 feature map입니다. 커널은 이미지의 특징을 찾아내기 위한 공용 파라미터입니다. 일반적으로 (2,2), (3,3) 등의 정사각 행렬로 정의되고 CNN에서 학습의 대상은 필터 파라미터입니다. 입력 데이터의 각각의 채널에서 지정된 간격으로 순회하며 합성 곱을 하고 모든 채널의 합성곱의 합인 feature map이 출력으로 나옵니다. stride가 1인 필터 적용 입력 채널이 여러 개인 경우 MLP는 모든 edge가 각자의 weight 값을 갖기 때문에 파라미터 수가 많이 필요하지만 CNN에서 filter는 모든 입력 노드에 하나의 filter를 적용하기 때문에 파라미터 수가 엄청나게 감소하여 연산 속도와 효율성이 증가합니다. 풀링(Pooling) CNN에서 pooling layer는 네트워크의 파라미터 개수나 연산량을 줄이기 위해 input에서 spatial 하게 downsampling을 진행해 사이즈를 줄이는 역할을 합니다. 일반적으로 CNN에서는 Convolution layer 다음에 들어갑니다. 본문에서 소개하는 max pooling 외에도 average pooling, L2-norm pooling 등 다양한 pooling 방법이 있습니다. Pooling(downsampling)이 필요한 이유는, featuremap의 weight parameter 개수를 줄이기 위함입니다. pooling layer가 없다면, 너무 많은 weight parameter가 생기고, 심각한 overfitting을 유도할 수도 있고, 많은 연산을 필요로 하게 됩니다. 또한 Pooling을 사용하면 연속적인 ConvNet 층이 점점 커지는 window를 보도록 만들어 (receptive field를 넓힘) 필터의 공간적인 계층구조를 형성하는 데 도움을 줄 수 있습니다. Pooling의 Hyper parameter : filter size : stride Max pooling Max pooling은 유의미한 정보가 높은 signal (activation function의 output)을 가질 것이라는 가정이 기저에 있습니다. 고로 보고자 하는 영역 안에서 가장 높은 값 하나를 넘깁니다. Back propagation과 Max pooling Convolution이나 Average pooling은 기본적으로 선형변환이라 미분이 가능하지만 maxout 연산은 미분이 불가능하기 때문에 chain rule을 이용할 수 없습니다. 최댓값이 속해있는 요소의 local gradient는 1, 나머지의 gradient는 0으로 두는 drop out에서의 backprop과 비슷한 아이디어로 backpropagation을 진행할 수 있습니다. Average pooling 우리가 보고자 하는 위치에서 평균값을 넘기는 것이 noise도 줄이고 그 영역을 잘 설명하는 값이니 좋을 것이다!라고 생각할 수도 있습니다. 이런 가정하에서 평균값을 넘기는 방법을 Average pooling이라고 합니다. Average pooling은 과거 LeNet에서 사용된 역사가 있으나, 현재는 max pooling이 성능이 좋다고 알려져 잘 쓰이지 않습니다. 그 이유는 다른 Pooling method와 비교하면 알기 쉬운데, 아래 그림은 하나의 그림에 average pooling, max pooling, min pooling을 진행한 결과입니다. 결과를 보면, Average pooling은 이미지를 전체적으로 smoothing 시키는 경향이 있어 sharp feature를 잡아내지 못하는 문제가 있음을 알 수 있습니다. Min pooling min pooling은 왜 일반적으로 쓰이지 못할까요? 이는 많은 Activation function들이 0이하의 값을 어떻게 취급하는지를 생각해 보면 어려움을 알 수 있습니다. 특히 ReLU의 경우 0 이하의 값은 전부 0으로 처리해 넘기기 때문에 층이 깊어질수록 min pooling을 하게 되면 의미 있는 정보가 넘어가기 어려울 수 있습니다. Reference cs230 cheat sheet cs231n lecture note Maxpooling vs minpooling vs average pooling 3) RNN(★작성 중) RNN 이란? 순환 신경망(Recurrent Neural Network) 은 인공 신경망(ANN)의 한 종류로, 유닛 간의 연결이 순환적인 구조를 가짐에 따라 순차적인 정보를 모델링 할 수 있는 신경망입니다. CNN과 같은 다른 신경망들은 메모리가 없으므로, 시계열 데이터 같은 sequential 한 데이터를 처리하기 위해서는 전체 시퀀스를 하나의 벡터로 넣어줘야 합니다. 이런 네트워크를 feed forward network라고 합니다. RNN은 이와 반대로, 내부의 메모리를 가지기 때문에 시퀀스 형태의 입력을 처리할 수 있습니다. 개념적인 이해 및 구조 개념적으로 RNN을 나타내보자면, 위와 같습니다. 현재 상태( )에서 다음 상태( + )의 자신에게로 보내는 출력값을 우리는 hidden state라고 하고, 여기서는 t 로 나타냈습니다. 이를 좀 더 구체적으로 나타내면, 위의 그림과 같습니다. activation function에 들어가는 값은 에서 hiddenstate로 들어오는 x x 와 이전 hidden state에서 다음 hidden state로 넘어가는 h h − 을 더한 값입니다. 이러한 RNN을 timestep에 따라 펼치는 것을 unfolding이라고 하는데, 다음과 같은 구조가 나타날 수 있습니다. 이들은 다양한 분야에서 응용될 수 있는데, one to one의 경우 일반적인 vanilla neural net과 같고, one to many의 경우 Image captioning, many to one에서는 감정 분석, many to many는 기계번역 또는 video labeling 등 분야에서 주로 사용됩니다. Bidirectional RNN은 bidirectional 하게 연결될 수도 있습니다. bidirectional RNN의 구조는 다음과 같습니다. bidirectional 하다는 것의 의미는 꼭 시간 순서대로 hidden state를 넘어가는 것이 아니라 이전 hidden state로 전달되기도 하는 등 양 방향으로 전달이 가능하다는 것입니다. 순환 뉴런(Recurrent Neurons) RNN은 위 그림과 같이 출력을 다시 입력으로 받는 부분이 있습니다. 해당 뉴런을 각 타임 스텝마다 쪼개어 펼쳐보면 아래와 같은 구조로 이전 타임 스텝의 출력을 다음 스텝의 입력으로 넣어주는 구조입니다. 각 타임 스텝의 순환 뉴런은 두 개의 가중치를 갖고 있습니다. x 는 입력인 t 에 대한 가중치이고 y 는 이전 단계의 출력인 t 1 에 대한 가중치입니다. t 를 식으로 나타내면 다음과 같고 CNN처럼 bias 값을 갖고 있습니다. 타임 스텝 t에서 미니 배치에 있는 각 샘플에 대한 순환 층의 출력은 다음과 같습니다. t 는 모든 샘플의 임력값을 담고 있는 행렬이고, x 는 현재 타임 스텝 t의 입력에 대한 가중치를 담고 있는 행렬, y 는 이전 타임 스텝 t-1의 출력에 대한 가중치를 담고 있는 행렬입니다. t X 와 t 로 나타내어지기 때문에, 타임 스텝 t = 0부터 모든 입력에 대한 함수라고 할 수 있습니다. 메모리 셀 입력과 출력 시퀀스 i) LSTM LSTM 이란 LSTM은 RNN의 한 종류로, RNN의 장기 의존성 문제(long-term dependencies)를 해결하기 위해서 나온 모델입니다. 따라서 직전 데이터뿐만 아니라, 좀 더 거시적으로 과거 데이터를 고려하여 미래 데이터를 예측하기 위해 나온 모델입니다. LSTM 네트워크 구조 위의 그림과 같이 모든 RNN은 Neural Network 모듈을 반복시키는 체인과 같은 형태를 하고 있습니다. 기본적으로 RNN에서는 이렇게 반복되는 간단한 구조를 가지고 있습니다. LSTM도 똑같이 체인 구조를 가지고 있지만, 4개의 Layer가 특별한 방식으로 서로 정보를 주고받도록 되어있습니다. 이제 LSTM의 핵심 아이디어를 설명해 드리겠습니다. 위 그림과 같이 총 6개의 파라미터와 4개의 게이트로 이루어져 있습니다. Cell State LSTM의 핵심 부분입니다. 모듈 그림 위에서 수평으로 이어진 위 선에 해당합니다. Cell State는 컨베이어 벨트와 같아서 작은 linear interaction만을 적용시키면서 전체 체인을 계속 구동 시킵니다. 정보가 전혀 바뀌지 않고 그대로만 흐르게 하는 부분입니다. 또한 State가 꽤 오래 경과하더라도 Gradient가 잘 전파됩니다. 그리고 Gate라고 불리는 구조에 의해서 정보가 추가되거나 제거되며, Gate는 Training을 통해서 어떤 정보를 유지하고 버릴지 학습합니다. Forget Gate 이 Gate는 과거의 정보를 버릴지 말지 결정하는 과정입니다. 이 결정은 Sigmoid layer에 의해서 결정이 됩니다. 이 과정에서는 t 1 x를 받아서 0과 1 사이의 값을 t 1 에 보내줍니다. 그 값이 1이면 "모든 정보를 보존해라"가 되고, 0이면 "죄다 갖다 버려라"가 됩니다. Input Gate 이 Gate는 현재 정보를 기억하기 위한 게이트입니다. 현재의 Cell state 값에 얼마나 더할지 말지를 정하는 역할입니다. Update 과거 Cell State를 새로운 State로 업데이트하는 과정입니다. Forget Gate를 통해서 얼마나 버릴지, Input Gate에서 얼마나 더할지를 정했으므로 이 Update 과정에서 계산을 해서 Cell State로 업데이트를 해줍니다. Output Gate 어떤 출력값을 출력할지 결정하는 과정으로 최종적으로 얻어진 Cell State 값을 얼마나 빼낼지 결정하는 역할을 해줍니다. Reference RNN :: LSTM(Long Short Term Memory) 톺아보기 LSTM 이란? RNN, LSTM, GRU란? Long Short-Term Memory (LSTM) 이해하기 ii) GRU(★작성 중) ... 4) 트랜스포머(★작성 중) ... 5) 오토인 코더(★작성 중) ... (3) 딥러닝 응용 뉴럴넷 기본 연산과는 관련이 크지 않으나 Task를 불문하고 자주 활용되고 등장하는 개념들입니다. 데이터의 부족을 극복하고 Robust 하게 만드는 Data Augmentation 학습된 뉴럴넷을 재활용하는 방법인 Pretraining, Transfer Learning, Fine-Tuning 그리도 뉴럴넷의 큰 단점인 Under/Overfitting에 대한 기본적인 방법을 다뤘습니다. 1) Data Augmentation 딥러닝은 기본적으로 많은 데이터가 존재해야 학습이 잘됩니다. 또한 딥러닝의 고질적인 문제인 overfitting을 해결하기 위해 충분히 많은, 양질의 데이터를 필요로 합니다. 그러나 데이터의 수를 늘리는 것은 비용과 시간이 많이 필요하며, 어떤 경우에는 데이터 수집하거나 가공하는 것조차 어려운 경우도 많습니다. 1) 수집이 어려운 경우의 예 자율주행 인공지능 개선을 위해 눈/비/황사/사고 등 특수 상황에 대한 데이터가 필요한 경우 보안지역 감시 영상 데이터가 필요한 경우 신체 주요 부위 혹은 개인 사생활을 침해할 수 있는 데이터 수집이 필요한 경우 사고 견적 산출 인공지능 학습을 위해 필요한 파손 차량 데이터 획득을 위해 차량을 파손하기는 어려움 2) 가공이 어려운 경우의 예 의료, 법률 데이터와 같이 전문적인 지식이 없으면 가공이 어려운 경우 평가자의 주관에 따라 판단 정도가 다를 수 있는 경우 (ex, 인물 표정) 작업자가 가공 중 혐오감을 느낄 수 있는 경우 (ex, 음란물, 폭력적 장면) 이를 해결하기 위해 기존의 데이터를 이용해 새롭게 데이터를 창조하는 Data Augmentation 기법이 다양하게 개발되었습니다. 데이터의 종류에 따라 다양한 augmentation 방법이 있지만 이미지 데이터에 대해서만 다루기로 하겠습니다. 1) Basic image manipulation Geometric Transformation Color space transformations Mixing images Random Erasing Kernel Filters 2) Deep learning approach Adversarial training GAN Data augmentation Neural style Transfer 3) Meta Learning Neural augmentation Autoaugmentation Smart augmentation Data augmentation의 방법에는 여러 가지가 있지만 지켜야 할 점이 있습니다. Semantically Invariant Transformation, 즉 Data에서 중요한 부분을 보존하는 선에서 최대한 augmentation 하는 것이 좋다는 의미입니다. 1) Basic image manipulation Geometric Transformation은 기존 이미지를 Crop, Rotate, Contrast, Invert, Flip 시켜 새로운 이미지를 만들어내는 방식입니다. Color space transformations은 기존 이미지의 RGB 값을 조정하여 새로운 이미지를 만들어내는 방식입니다. Mixing images은 두 image를 0~1 사이의 λ 값을 통해 Weighted Linear Interpolation 해주는 기법으로, Label도 λ값에 비례하여 지정합니다. Random Erasing: 이미지의 랜덤 한 영역을 지워서 새로운 이미지를 만들어냅니다. Basic image manipulation 방법을 조합: CutMix는 Mixing images와 Random Erasing 방법을 합친 방법입니다. A image에서 box를 쳐서<NAME> 다음 그 빈 영역을 B image로부터 patch를 추출하여 집어넣습니다. Patch의 면적에 비례하여 Label도 섞어 지정합니다. PuzzleMix는 cutmix를 개량한 방법입니다. 두 이미지에서 중요한 feature는 보존하면서 섞도록 합니다 자세한 설명은 여기를 참고하세요. 2) Deep learning approach Adversarial training Adversarial attack 이란 DNN이 잘못된 결과를 산출하도록 의도적으로 조작시킨 입력값 (adversarial example)을 생성하여 training model에 제시하는 것을 말한다. 예를 들어 57%의 정확도로 아래 그림을 panda로 분류하는 모델이 있다고 하자. 육안상으로 구별할 수 없는 어떤 노이즈를 주어 이미지를 조작한 뒤 해당 모델에 제시한. 사람의 눈에는 여전히 판다로 보이지만 DNN 모델은 이를 긴팔원숭이(Gibbon)으로 분류하고 있다. Adversarial attack은 매우 위험한 결과를 초래할 수 있다. 대표적인 예시로 도로 교통 표지판에 작은 스티커를 붙여 "STOP" 표지판을 "시속 45마일 속도 제한" 신호로 오 분류하게 만들 수 있다고 한다. 자율주행 자동차가 이런 Adversarial attack에 노출된다면? 정말 큰 사고로 이어질 수도 있다. Adversarial attack에 대한 자세한 내용은 여기 참고 Adversarial Example을 만드는 알고리즘은 이미 개발되어 있다. Adversarial training 이란 Adversarial example을 여러 개 제작하여 모델에 제시한 다음 어떤 상황에서 모델이 오 분류를 일으키는지 확인하고 모델을 수정하여 전체적인 성능을 높이는 학습 방법이다. GAN Data augmentation GAN (Generative Adversarial Networks) 모델을 이용해 기존 데이터와 유사한 샘플을 생성하여 데이터 수를 늘린다. (아래 사진 참고) 3) Meta Learning Autoaugmentation 수많은 data augmentation 방법 중 해당 데이터 셋에 적합한 기법을 제시하는 모델을 AutoAugmentation이라고 합니다. 구글은 자주 사용되는 16가지 data augmentation 기법들 중 최적의 조합을 찾기 위해 PPO(Proximal Policy Optimization)로 학습하여 AutoAugmentation을 시행합니다. 다만, 계산량이 매우 많고, 탐색 공간이 커 시간이 매우 오래 걸리고 사용할 수 있는 환경도 제한적이라고 합니다. AutoAugmentation의 계산 속도를 개선하기 위한 여러 방법이 제시되었습니다. 그 예로 Population Based Augmentation, Fast AutoAugment, Faster AutoAugment 등이 있습니다. RandAugmentation 이전의 기법들이 적합한 augmentation 기법을 찾는 모델이라면, RandAugmentation은 특정 모델을 찾는 것이 아니라 batch마다 적용할 augmentation 방법을 랜덤으로 추출하여 적용하는 기법입니다. 성능은 다른 모델과 큰 차이가 없으나 코드가 단순하다는 장점이 있습니다. Reference A survey on Image Data Augmentation for Deep Learning Youtube|딥러닝 논문 읽기 모임 [DMQA Open Seminar] Data Augmentation 2) Pre-training, Transfer learning & Fine-tuning Transfer learning의 필요성 MNIST와 같은 흑백 이미지를 인식하는 모델을 만들기 위해서는 최소 3개의 convolution layer와 1개의 fully connected layer가 필요하며, 이를 학습시키기 위해 일반적인 1개의 CPU에서는 1시간 정도 소요됩니다. CIFAR-10 등에서 사용되는 고해상도 컬러 이미지를 인식하기 위해서는 최소 5개의 convolution layer와 2개의 fully connected layer가 필요하며, 이를 학습시키기 위해 일반적인 1개의 CPU에서는 수 백~수천 시간이 소요됩니다. 요새 사용하는 큰 덩치의 CNN을 학습 시키려면 엄청나게 많은 시간이 필요합니다. 이미 학습되어 있는 CNN 모델, 즉 Pre-trained CNN을 가져와서 분석하고자 하는 데이터에 맞도록 Fine-tuning (미세 조정) 하여 사용하면 맨 밑바닥부터 학습 시키는 것에 비해 소요 시간이 획기적으로 줄어듭니다! 이와 같은 방법을 Transfer learning (전이 학습)이라고 합니다. Transfer learning은 왜 작동할까? 다량의 동물 사진을 주고 학습시킨 모델을 사용하여 자동차나 오토바이 등의 탈것을 분류하는 문제를 해결할 수 있을까요? 분류하고자 하는 대상이 매우 달라 일견 보기에는 잘 작동하지 않을 것 같지만 fine-tuning을 거치면 꽤 좋은 성능을 보입니다. 딥러닝 모델의 중요한 성격 중 하나는 모델의 초기 층은 "일반적인(general)" 특징을 추출하도록 하는 학습이 이루어지는 반면에, 모델의 마지막 층에 가까워질수록 특정 데이터 셋 또는 특정 문제에서만 나타날 수 있는 "구체적인(specific)" 특징을 추출해 내도록 하는 고도화된 학습이 이루어진다는 점입니다. 위의 예시에서 pre-trained CNN의 초기 층은 모서리나 경계, 곡선 등을 검출하는 층이고, 마지막 층은 동물 각각의 세세한 특성을 추출하는 층이라고 생각해 볼 수 있습니다. 따라서 초기 층은 다른 데이터 셋의 이미지들을 학습할 때도 재사용될 수 있지만, 마지막 층은 새로운 문제를 맞이할 때마다 새로 학습이 필요합니다. Fine-tuning 시 고려할 점 Fine-tuning을 하기 위해서는 기존에 학습된 layer에 데이터를 추가로 학습시켜, 파라미터를 업데이트해야 합니다. 이때 주의할 점은, pre-trained CNN이 학습한 데이터와 우리가 학습 시키고자 하는 데이터가 얼마나 유사한지, 데이터의 양은 얼마인지에 따라 Fine-tuning 시킬 영역 및 정도가 달라진다는 것이죠. 새로 훈련할 데이터가 적지만, original 데이터와 유사할 경우 데이터의 양이 적어, 전체 네트워크를 fine-tuning 하는 것은 over-fitting의 위험이 있기에 하지 않음. 새로 학습할 데이터는 original 데이터와 유사하기 때문에 최종 classfier layer만 학습해도 잘 작동함. 새로 훈련할 데이터가 적으며, original 데이터와 다른 경우 이 경우 데이터의 양이 적고, 데이터가 서로 다르기 때문에, 네트워크의 마지막 classifier layer만 학습하는 것은 좋지 않음. 따라서, 네트워크 초기 부분의 특정 layer를 학습시키는 게 좋음. 새로 훈련할 데이터가 많으며, original 데이터와 유사할 경우 새로 학습할 데이터의 양이 많다는 것은, over-fitting의 위험이 낮다는 뜻이므로 전체 layer를 fine-tuning을 하거나 마지막 몇 개의 layer만 fine-tuning 하거나 마지막 몇 개의 layer를 날려버리는 방법이 있음. 새로 훈련할 데이터가 많지만, original 데이터와 다른 경우 데이터가 많기 때문에, 아예 새로운 ConvNet을 만들 수도 있지만, 이 경우에도 transfer learning의 효율이 더 좋음. 이런 경우 전체 네트워크를 fine-tuning 해도 됨. Transfer learning 구현 예시 새로 훈련할 데이터가 적지만, original 데이터와 유사할 경우 마지막 classifier layer만 fine-tuning 하는 경우를 예시로 보겠습니다. Pre-trained CNN은 VGGnet을 사용하였습니다. ① tf.constant를 이용해 VGG의 convolution layer와 fully connected layr의 weight과 bias를 그대로 가져온다. ② tf.Variable을 이용해 classifier layer는 초기화하여 세팅한다. ③ 해당 weight와 bias를 이용해 Transfer learning model을 만든다. ④ Loss와 optimizer를 설정하고 학습 데이터를 넣어 학습시킨다. 전체 코드를 보고 싶다면 여기를 참고 Reference Transfer Learning(전 이 학습)이란? 3) Under/Over-fitting 해결 방법 Overfitting Overfitting(과대적 합)이란 모델이 Train set에서는 좋은 성능을 내지만 Validation set에서는 낮은 성능을 내는 경우를 말합니다. 즉 Train 데이터에 모델이 너무 적합하게 학습되어 있기 때문에 Train 데이터가 아닌 다른 데이터가 들어오게 되면 정확도가 떨어지는 현상입니다. Overfitting 해결 방법 Overfitting은 모델의 성능을 떨어트리는 주요 문제입니다. 따라서 이러한 문제를 해결하기 위한 다양한 방법이 있습니다. 1. 데이터양 늘리기 모델은 데이터의 양이 적을수록 해당 데이터의 특징 패턴이나 노이즈까지 암기해버려서 Overfitting이 될 확률이 높습니다. 그래서 데이터의 양을 늘릴수록 모델은 일반적인 패턴을 할습하여 Overfitting을 방지할 수 있습니다. 데이터의 양을 늘리는 방법으로는 Data Augmentation 이곳에 설명이 되어있으니 참고하시면 됩니다. 2. 모델의 복잡도 줄이기 인공지능 신경망의 복잡도는 Hidden layer의 수나 매개변수의 수 등으로 결정이 됩니다. Overfitting 현상이 포착되었을 때, 인공 신경망 모델에 대해서 할 수 있는 한 가지 조치는 인공 신경망의 복잡도를 줄이는 방법입니다. 3. Dropout 사용하기 Dropout은 학습 과정에서 신경망의 일부를 사용하지 않는 방법입니다. 예를 들어서 Dropout의 비율을 0.5로 한다면 아래 그림처럼 학습 과정마다 랜덤으로 절반의 뉴런을 사용하지 않고 절반만 사용하게 됩니다. Dropout은 신경망 학습 시에만 사용하고, 예측 시에는 사용하지 않는 것이 일반적입니다. 학습 시에 인공 신경망이 특정 뉴런 또는 특정 조합에 너무 의존적이게 되는 것을 방지해 주고, 매번 랜덤 선택으로 뉴런들을 사용하지 않으므로 서로 다른 신경망들을 앙상블 하여 사용하는 것 같은 효과를 내어 과적합을 방지합니다. 4. 출력층 직전 은닉층의 노드 수 줄이기 통계학에서 Overfitting을 해결하는 방법은 쓸데없는 변수를 제거해서 입력 변수의 수를 줄이는 것인데, 통계학 관점에서 출력층 직전 은닉층 노드 수는 설명 변수의 수가 됩니다. 따라서 의미 있는 설명 변수들을 남기기 위해 출력 직전 노드를 줄이는 것입니다. 5. Batch Normalization 뉴럴 네트워크에서 각 활성함수의 미분 값은 역전파 과정 속에서 계속 곱해지기 때문에 중요한 부분 중 하나입니다. 시그 모이드 함수의 경우 일정 수준 이상 혹은 이하의 값이 입력되었을 때 미분 값이 0에 가까워지게 되는데 이때 Gradient Vanishing 문제가 발생합니다. 이렇게 되면 파라미터의 업데이트가 거의 일어나지 않고 수렴 속도도 아주 느리게 되기 때문에 최적화에 실패하게 됩니다. 따라서 이를 해결하기 위해서는 Batch Normalization이 이용됩니다. mini batch 별로 분산과 표준편차를 구해 분포를 조정합니다. Under Fitting Underfitting은 이미 있는 Train set도 학습을 하지 못한 상태를 의미합니다. 즉 아직 학습이 덜 된 모델이라고 생각하면 편합니다. 이 문제가 발생하는 이유는 학습 반복 횟수가 너무 적고, 데이터의 특성에 비해 모델이 너무 간단하기 때문입니다. 또한 데이터양이 너무 적은 문제도 있을 수 있습니다. Reference 머신러닝 - 과대적 합(overfitting)과 과소 적합(underfitting), 정규화 모델 튜닝 하는 방법 - 과대 적합과 과소 적합 과적합과 과소 적합 (Overfitting & Underfitting) (4) 설명 가능한 AI Neural Network는 서로 복잡하게 연결된 수백만 개 이상의 parameter가 비선형으로 상호작용하는 구조로, 사람이 그 많은 parameter를 직접 계산하고 의미를 파악하기는 불가능하고 back propagation 덕에 간신히 parameter update만 가능한 구조입니다. 복잡한 구조 덕에 성능은 기존 기계학습보다도 월등히 높아졌지만 Neural Network가 왜 그런 결과를 도출했는지는 알 수 없다는 단점이 있습니다. 그래서 흔히 Neural Network를 Black Box라고 부르기도 합니다. 이 때문에 많은 사람들이 Neural Network가 왜 작동하는지, 도대체 왜 그런 결론에 도달한 것인지 설명하기 위해 많은 노력을 해왔습니다. 그런 노력들에 대해 조사해 보기 전애 왜 우리가 Neural Network를 설명해야 하는지 사례를 통해 알아보겠습니다. ▷ A 병원이 최근 암을 진단하는 AI를 도입했다고 하자. B 씨는 배탈이 난 것 같아서 병원에 방문했다가 AI로부터 암 판정을 받았다. 어떤 증상 때문에 암이라고 진단했는지는 설명하지 않고 최신 AI 알고리즘이 빅데이터를 기반으로 예측했다고 한다. B 씨는 정밀검사를 받아야 할지 고민에 빠진다. ▷ 약 18,000명의 범죄자를 중심으로 향후 2년 내<NAME> 가능성을 예측하기 위해 범죄 예측 알고리즘을 이용했는데 흑인의<NAME> 가능성을 백인보다 45% 높게 예측했다. 흑인의<NAME> 가능을 왜 더 높게 예측했는지는 알 수 없었다. 그러나 실제 동일 기간의<NAME>률을 조사한 결과 백인의<NAME>률이 흑인보다 높았다. 또한 Neural Network이 설명함으로써 해당 모델을 통제하고, 성능을 개선하는 데 도움을 받을 수 있습니다. Reference 설명 가능 인공지능이란? (A Survey on XAI) Peeking Inside the Black-Box: A Survey on Explainable Artificial Intelligence (XAI) A survey of methods for explaining black box models 1) Visualizing the layers of DNN 딥러닝 모델은 어떻게 해서 이런 결과를<NAME>게 되었는지 해석할 수 없다고 비판받곤 합니다. (Black box라고도 불리죠.) 이미지를 다루는 딥러닝 모델의 경우 Layer 중간중간 섞인 non-linear activation function으로 인해 더더욱 해석이 힘든 경우가 많습니다. 이런 단점을 해결해 보고자 딥러닝 모델을 시각화 (visualization) 하기 위한 여러 방법들이 제시되어 있습니다. 대표적인 시각화(visualization) 방법으로 아래와 같은 방법들이 있습니다. Feature vector visualization using t-SNE/PCA Activation Visualization Maximally Activating Images / Patches Maximization by Optimization & Deep Dream Occlusion Feature vector visualization using t-SNE/PCA 이미지를 분류 네트워크에 넣고 나오는 마지막 Layer(분류되기 전 마지막 Layer)의 출력값은 입력에 비해 축소된 차원(Dimension)를 갖습니다. 축소된 값들을 Feature vector라고 하며 이들은 이미지의 강력한 특징들을 표현한 새로운 벡터가 됩니다. 이미지들에서 추출된 Feature vector들도 Dims가 많아 Visualization을 바로 하기는 힘들기 때문에 PCA/t-SNE 등을 이용해 2,3 차원으로 축소하고, Reduction된 Feature vector를 이용하여 이미지들을 좌표평면에 시각화해 볼 수 있습니다. 이 같은 Visualization을 통해서 이웃 이미지들을 확인하여 Feature vector가 잘 추출되었는지 시각적으로 확인할 수 있습니다. Activation Visualization 이미지를 딥러닝 모델에 제시하면 Intermediate layer를 통과하면서 생성된 feature map 각각을 들여다보는 방법이 있습니다. 일반적인 머신러닝 모델에서 feature를 ‘들여다본다’ 함은, feature로 계산된 값의 크기를 비교하고 통계적 분포 등을 조사하는 것이 될 것입니다. 그러나 컨볼루션 신경망의 feature map은 그 특유의 2차원적 구조 때문에 이를 마치 이미지처럼 그려볼 수 있다는 장점이 있습니다. 특정 이미지를 입력했을 때의 각 feature map이 ‘활성화된(activation)’ 정도를 보여주는 Activation map은 어떤 뉴런(노드)에서 어떤 특징을 추출했는지 볼 수 있습니다. 예시를 들어 이용해 설명해 보겠습니다. 아래 사진은 Conv5 Layer을 통과하고 나온 Feature map인데, 특정 노드의 Activation 값이 매우 밝게 빛나는 것을 볼 수 있습니다. 이 노드를 확대해 input image와 비교해 보면 "사람의 얼굴"이라는 특징을 잡아낸다고 생각해 볼 수 있습니다. Maximally Activating Images / Patches Activation Visualization 이후로, 각 feature map이 커버하는 시각적 특징이 정확히 무엇인지 더욱 효과적으로 찾고 가시화하고자 하는 시도가 자연스럽게 늘어났습니다. 그중 하나로 Maximally Activating Images/Patches라는 방법이 있습니다. 특정 Intermediate feature map을 최대로 활성화(Maximum activation) 하는 input image를 찾는 것을 Maximmaly Activating Imge 찾는다고 말합니다. 보통은 상위 몇 개의 Maximally Activating Images를 일단 뽑아낸 뒤 이들 각각에 대하여 Activation Visualization을 추가로 수행함으로써, 해당 feature map이 Maximally Activating Images 상의 어느 부분에 초점을 맞추는지 보다 면밀하게 확인할 수 있고 이 영역을 Maximally Activating Patches라고 합니다. 아래 이미지를 예로 들면 Conv5 layer를 통해서 생성된 128개의 채널 중 17번째 채널을 목표로 해보겠습니다. 이 채널을 통과해 생성된 filter map을 Maximum activation 시킨 영역, 즉 Maximally Activating Patches를 살펴보면 눈, 코, 이니셜 등 input image 상 특정 영역인 것을 확인할 수 있습니다. Maximization by Optimization & Deep Dream Maximally Activating Images / Patches는 feature map 등이 커버하는 시각적 특징을 파악하기 위해 다수의 데이터 셋을 필요로 한다는 단점이 있습니다. 만약 현재 보유하고 있는 이미지 수가 매우 적다면 어떻게 할까요? 보유한 데이터 셋에 의존하지 않고 feature map 등이 커버하는 시각적 특징을 좀 더 직접적으로 조사하고자, gradient ascent(경사 상승 법)에 기반한 optimization을 통해 타깃 feature map을 최대로 활성화하는 input image를 직접 생성하는 접근이 시도되었습니다. 이러한 방법을 Maximization by Optimization라고 합니다. 위 그림과 같이 랜덤 노이즈(random noise) 형태의 이미지에서 출발하여, 특정한 하나의 feature map F을 타깃으로 지정합니다. feature map F의 현재 이미지 X에 대한 gradient (dF/dX)를 계산하고 이를 현재 이미지에 더해주어, 기존보다 해당 feature map을 더 강하게 활성화시키는 새로운 이미지 X1을 얻습니다. 이를 충분히 반복하여 해당 feature map을 ‘최대로 활성화시키는 이미지’를 얻을 수 있습니다. 아래의 예시 그림들은 각기 다른 feature map을 기준으로 하여 Maximization by Optimization 시행한 결과들입니다. 대체로 앞쪽 layer에 위치한 feature map들의 경우 단순하고 반복적인 패턴(edges, textures)을 커버하는 경향을 보이며, 뒤쪽 layer에 위치한 feature map들의 경우 그보다는 좀 더 복잡한 무늬, 모종의 사물의 일부분 또는 전체를 커버하는 경향을 보임을 확인할 수 있습니다. Maximization by Optimization의 타깃을 feature map 대신 layer로 설정할 경우, 아래의 예시 그림들과 같이 상당히 드라마틱한 결과를 얻을 수 있습니다. 이들이 마치 꿈속에서만 등장할 것 같은 생소한 인상을 주었기 때문에, 연구자들은 여기에 ‘DeepDream‘이라는 이름을 붙였습니다. 해석 가능성의 측면에서 봤을 땐 feature map 각각에 대한 관찰 결과에 비해 다소 난해한 듯한 특징을 보여주고 있습니다. 아래 사진은 Imagenet의 데이터 셋과 Inception model을 바탕으로 하여 DeepDream 모델을 생성한 후 임의의 image를 넣어 생성한 사진입니다. 자세히 보면 기존 이미지에 개가 융합되어 있는 것을 볼 수 있습니다. Occlusion 먼저 원본 이미지의 일정 부분을 Occlusion(폐색) 시킵니다. 쉽게 말해서 특정 부분을 가린다고 보시면 될 것 같습니다. 그 뒤에 네트워크를 통과시켜서 Predict score가 크게 떨어진다면 앞서 우리가 폐색시킨 부분이 중요한 영역임을 직관적으로 알 수 있습니다 (변화율이 클수록 더욱더 중요한 부분으로 예상할 수 있습니다). 위와 같은 방법으로 이미지의 모든 영역을 반복, Score가 변하는 정도를 Heat map으로 표현합니다. (아래 이미지에서 붉은 영역이 Predict score가 크게 떨어진 영역입니다.) 해당 과정을 통해서 분류에 결정적 영역을 미치는 Patch를 Original image 영역에서 시각화 가능합니다. 관련 정보 및 Reference https://towardsdatascience.com/visualization-attention-part-3-84a43958e48b 블로그 | CS231n 12강. Visualizing and Understanding Stanford University School of Engineering | Lecture 2 | Image Classification Stanford University School of Engineering | Lecture 12 | Visualizing and Understanding INTERPRETABLE MACHINE LEARNING 개요: (2) 이미지 인식 문제에서의 딥러닝 모델의 주요 해석 방법 2) CAM, Grad CAM CAM (Class Activation Map) 보통 CNN의 구조를 생각해 보면, Input - Conv Layers - FC Layers으로 이루어졌습니다. CNN의 마지막 레이어를 FC-Layer로 Flatten 시키면 각 픽셀들의 위치 정보를 잃게 됩니다. 따라서 Classification의 정확도가 아무리 높더라도, 우리는 그 CNN 이 무엇을 보고 특정 class로 분류했는지 알 수 없었습니다. 2016년 공개된 논문 Learning Deep Features for Discriminative Localization에서는 FC Layer 대신에, GAP (Global Average Pooling) 을 적용하면 특정 클래스 이미지의 Heat Map 을 생성할 수 있고, 이 Heat Map 을 통해 CNN 이 어떻게 그 이미지를 특정 클래스로 예측했는지를 이해할 수 있다고 주장하고 있습니다. GAP (Global Average Pooling) Global Average Pooling (GAP) layer을 통해 각각의 feature map마다 Global average pooling (각 feature map에 포함된 모든 원소 값을 평균함)을 시행합니다. 그 결과 GAP layer로 들어오는 feature map의 channel 수와 동일한 길이의 벡터를 얻게 됩니다. (위의 그림에서는 벡터의 길이가 4가 되겠죠.) GAP 뒤에는 FC layer가 하나 붙어있고 GAP에서 출력한 벡터를 Input으로 줍니다. 아래 그림에서는 GAP을 통해 길이 6인 벡터가 출력되었고 FC layer를 통과시켜 토르/아이언맨/스파이더맨/캡틴 아메리카 중 하나로 Input image를 분류하게 됩니다. 각 FC layer의 weight는 학습을 통해서 구합니다. 해당 weight 1~6을 각 feature map에 곱한 뒤 각 pixel 별로 더해주어 최종 heat map을 출력하게 됩니다. CAM의 결과 굉장히 단순한 구조여 어서 이게 정말 작동하나 싶지만 CAM을 통해 얻어낸 Heat map 결과를 보면 꽤나 그럴 듯합니다. 위 그림을 보면 해당 객체가 있는 영역이 빨갛게 표시된 것을 볼 수 있죠. cleaning the floor, cooking 같이 동작을 나타내는 이미지도 해당 객체를 잘 집어내고 있는 모습을 볼 수 있습니다. 그럼 CAM은 왜 작동을 하는 것일까요? 마지막 convolution layer를 통과한 feature map은 input image의 전체 내용을 함축하고 있기 때문입니다. 때문에 마지막 Feature map이 아닌 중간에 위치한 featue map에서는 CAM을 통해 Heatmap을 추출할 수 없다는 단점이 발생합니다. CAM의 단점 CAM 구조의 단점은 아래와 같습니다. CAM의 단점을 극복하기 위해 Grad-CAM이 2017년 등장하였습니다. - Global average pooling layer를 반드시 사용하고 뒤에는 FC layer가 붙어있음. - 해당 FC layer의 weight를 구하기 위해 학습을 시켜야 함. - 마지막 convolution layer를 통과해 나온 feature map에 대해서만 CAM을 통해 Heat map 추출이 가능함 Grad-CAM CAM의 구조 Grad-CAM의 구조 Grad-CAM은 CAM과 무엇이 다를까요? - 기존 CNN 모델 구조의 변화 없음. 즉, Global average pooling 없이 FC layer가 두 개 존재 - 기존 CNN 모델의 재학습이 필요 없음. 각 Feature map에 곱해줄 weight를 학습이 아닌 미분(gradient)을 통해 구하기 때문. 예를 들어 위 그림처럼 k=6개의 feature map을 이용해 y=2, 아이언맨으로 분류한다고 해봅시다. class c에 대한 점수 y_c (before the softmax)을 각 원소로 미분합니다. (back propagation 하듯이 말이죠.) 이 미분 값은 각 Feature map의 원소가 특정 class에 주는 영향력이 됩니다. 각 feature map에 포함된 모든 원소의 미분 값을 모두 더하여 neuron importance weight, a를 구하면, 이 a는 해당 feature map이 특정 class에 주는 영향력이 됩니다. neuron importance weight, a와 각 k 개의 Feature map을 곱하여 weight sum of Feature map을 구함 → ReLU를 취하여 최종 Grad-CAM에 의한 Heatmap이 출력 ReLU를 취한 이유는 오직 관심 있는 class에 positive 영향을 주는 feature에만 관심이 있기 때문입니다. 즉, y_c를 증가시키기 위해서 증가되어야 할 intensity를 가지는 pixel을 말합니다. ReLU를 적용하지 않으면, localization에서 더 나쁜 성능을 보여준다고 합니다. Reference 원논문 Learning Deep Features for Discriminative Localization Grad-CAM: Visual Explanations from Deep Networks via Gradient-based Localization Youtube iAI POSTECH | CAM 김성범 인공지능 공학 연구소 | Class Activation Map (CAM), GradCAM 블로그 CNN visualization: CAM and Grad-CAM 설명 CAM 구현 Grad-CAM(Gradient-weighted Class Activation Mapping), 코드 포함 2. Image Classification(이미지 분류) 가장 간단하나 어떻게 보면 가장 중요한 Task입니다. 개/고양이를 구분해 내는 아키텍처부터 시작해서 더 나아가 이미지의 정해진 Category를 예측하는 아키텍처입니다. 이 아키텍처는 다른 Task의 Backbone으로 이용되기도 하며, 가장 실험적인 시도가 먼저 이루어지고 있습니다. (1) 이미지 분류 아이디어 이미지 분류란 말 그대로 인공지능이 이미지를 분류해 주는 것입니다. 강아지 사진과 고양이 사진을 사람에게 보여주면, 시각 이미지와 상식을 통해 사진을 구별해 낼 수 있습니다. 컴퓨터는 이미지 분류를 어떻게 해낼까요? 우선 이미지를 입력받습니다. 예를 들어 고양이 사진을 입력받는다고 할 때, 컴퓨터에는 이미 강아지, 고양이, 트럭 등 미리 정해둔 카테고리가 존재합니다. 즉 컴퓨터는 입력 사진이 어떤 카테고리에 속할지 결정을 해야 합니다. 사람에게는 간단한 문제이지만 컴퓨터에게는 복잡한 문제입니다. 컴퓨터에게 고양이 이미지는 아주 큰 격자 모양의 숫자 집합으로 보입니다. W * H * C (W : width , H : height, C : channel (RGB 그림의 경우 3)) 개의 픽셀 값으로 이루어져 있습니다. 하지만 이 숫자 집합으로는 고양이를 구별해 내기 어렵습니다. 같은 이미지를 보더라도 명암의 차이, 관점의 차이 등이 있을 수 있기 때문입니다. 따라서 아래와 같은 사항을 극복해야 합니다. 시점 변화(Viewpoint variation) : 이미지를 어느 방향에서 찍었는지에 따라 같은 대상도 다르게 보일 수 있습니다. 크기 변화(Scale variation) : 대상의 크기 변화에 따라 컴퓨터에게 다른 이미지로 인식될 수 있습니다. 변형(Deformation) : 강체가 아닌 대상은 형태가 변형될 수 있습니다. 폐색(Occlusion) : 대상이 다른 물체에 의해 가려지거나 일부분만 보일 수 있습니다. 광원 조건(Illumination condition) : 조명을 받는지 유무와 그 정도에 따라 이미지가 다르게 보일 수 있습니다. 배경 클러터(Background clutter) : 대상이 배경에 섞여들어가 구분이 어려울 수 있습니다. 클래스 간 구별(Intra-class variation) : 대상이 속하는 레이블(클래스)의 범위가 너무 포괄적이어서 그 대상을 특정 짓지 못할 수 있습니다. 이미지 분류 방법 1. 데이터 기반 방법(Data-Driven Approach) 데이터 기반 방식에는 Nearest Neighbor Classifier, K-Nearest Neighbor Classifier 두 가지 방식이 있습니다. 1-1. Nearest Neighbor Classifier Nearest Neighbor(NN)은 컨볼루션 신경망 방법과는 아무 상관이 없고 실제 문제를 풀 때 자주 사용되지는 않지만, 이미지 분류 문제에 대한 기본적인 접근 방법을 알 수 있도록 합니다. 예측 단계에서는 투입된 이미지와 가장 가까운 데이터의 레이블을 통해 예측하는 방법입니다. 이미지와 이미지의 가까운 정도(distance)는 다양한 지표 (metric) 이 있지만 그중 한 가지인 L1 distance는 다음과 같습니다. 1 ( 1 I) ∑ | p − p | L1 외에도 다양한 Metric을 사용할 수 있습니다. L2 distance는 다음과 같습니다. 2 ( 1 I) ∑ ( p − p) L1 L2 distance의 차이 L1과 L2는 p-norm 계열의 distance measure입니다. 그러면 L1과 L2의 차이는 L2 distance는 L1 distance를 사용하는 것보다 차이가 큰 것에 더 관대하지 않다는 것입니다. 즉, L1 이 아닌 L2 distance를 쓴다는 것은 여러 개의 dimension에서 적당한 차이를 보이는 것보다 하나의 dimension에서 큰 차이를 보이는 것에 더 페널티를 많이 준다는 의미입니다. 1-2. K-Nearest Neighbor Classifier NN은 단점이 많은 알고리즘입니다. 먼저, NN 은 단 하나의 label만 prediction에서 고려하기 때문에 안정성이 떨어지는 결과를 보여줍니다. 이를 보완하기 위해 k-nearest neighbor (KNN)를 활용할 수 있습니다. 이 방법은 예측 단계에서 인풋과 가까운 순으로 총 k 개의 데이터의 레이블을 구한 후, 가장 빈번하게 나오는 레이블로 예측하는 방법입니다. 이렇게 여러 개로부터 가장 빈번하게 나오는 것을 예측 결과로 하는 것을 머신러닝에서는 voting이라고 부릅니다. KNN은 학습 데이터 셋에서 가장 가까운 하나의 이미지만을 찾는 것이 아니라, 가장 가까운 k 개의 이미지를 찾아서 테스트 이미지의 라벨에 대해 투표하도록 하는 것입니다. k = 1 인 경우, 원래의 Nearest Neighbor 분류기가 됩니다. 직관적으로 k 값이 커질수록 분류기는 이상점(outlier)에 더<NAME>하고, 분류 경계가 부드러워지는 효과가 있습니다. NN에는 이상치 (outlier)를 중심으로 섬과 같은 지역 (decision boundary) 가 생긴다는 것을 알 수 있습니다. 하지만 KNN의 경우, 이상치에 더 둔감하는 것을 알 수 있습니다. NN의 경우 이상치에 민감하기 때문에 트레이닝 데이터에 국한된 규칙을 배울 가능성이 높습니다. 하지만 KNN 을 사용하면 처음 보는 데이터 (unseen data) 대한 성능 (generalization)이 높습니다. 1-3 Bayesian Classifier 베이지안 분류를 위해서는 먼저 베이즈 정리에 대해 알아야 합니다. 베이지안 분류기는 이 베이즈 정리를 이용하여 입력 데이터가 특정 카테고리에 속하는지 분류합니다. 2. 규칙 기반 방법(Rule-Driven Approach) 규칙 기반 학습 방법은 주어진 입력에 대해서 결괏값을 도출하는 방법으로 if-then 방식이라고도 합니다. 예제(example)에 대해 가설(hypothesis)를 세우고 결과(concept)를 도출합니다. 이러한 방식은 귀납적 사고방식입니다. 규칙 기반 방법으로는 Find-S 알고리즘, Version space/ Candidate 알고리즘이 있습니다. 규칙 기반 학습이 타당하기 위해서는 몇 가지 가정을 해야 합니다. 1. 우리가 알아볼 세상에서는 관측 오차(observation errors)가 없다. 2. 일관성이 없는 관측 또한 존재하지 않는다. 3. 어떤 확률론적 요소(stochastic element)도 존재하지 않는다. 4. 우리가 관측하는 정보가 시스템에 있는 모든 정보이다. 이 네 가지 가정을 모두 만족하는 곳을 완벽한 세계(perfect world)라고 말하고 규칙 기반 학습은 완벽한 세계에서 타당할 수 있습니다. 2-1 Find-S 알고리즘 Find-S 알고리즘은 가장 구체적인 가설에서 시작하여 점점 General 한 가설을 찾아내는 방법입니다. 가장 중요한 점은 예제 중 positive training example만 선별한다는 것입니다. 특정 예제로부터 도출된 결과를 다른 예제들에 반복하여 적용하여 변경된 부분만 don't care condition으로 설정하고 최종적인 가설을 만들어 냅니다. 밑의 예시를 통해 자세히 알아보겠습니다. 위의 표는 하늘, 날씨, 바람 등의 요소를 보고 운동을 즐길 수 있는지 없는지 나타내고 있는 표입니다. 이 예제에서 positive example은 Enjoy Sport가 Yes 일 경우입니다. 우리의 목적은 운동을 즐길 수 있는 조건의 일반적인 가설을 세우는 것입니다. 먼저 모든 칼럼인 sky, temp, humid, wind, water, forecast를 보면서 시작합니다. 첫 번째 행을 본다면 Sunny, Warm, Normal, Strong, Warm, Same인 경우에 positive 함을 알 수 있습니다. 그 후 두 번째 행을 보면 Humid 부분만 다르고 마찬가지로 positive 합니다. 즉 Humid를 i don't care condition으로 지정함으로써 가설을 좀 더 일반화할 수 있게 되었습니다. 3번째 행은 positive 하지 않기 때문에 pass 합니다. 4번째 행은 water와 forecast 부분이 기존과 다르게 되어 두 칼럼이 i don't care 하게 됩니다. 최종적으로 Sky = Sunny, Temp = Warm, Wind = Strong 한 경우에는 무조건 운동을 즐길 수 있는 날이라는 일반화된 가설을 얻게 됩니다. Find-S 알고리즘은 현실 세계에서 사용하기에 한계가 존재하는 알고리즘입니다. 실제 세상을 저렇게 단순하지 않으며 고려해야 할 부분이 훨씬 더 많습니다. 또한 최종적으로 하나의 일반화된 가설을 도출하기 때문에 가설의 집합이 존재하는 경우를 고려하지 않습니다. 예를 들면 하늘이 맑은 상황(전제 조건)에서 따뜻하고 바람이 강하게 불때(1), 춥지만 바람이 약하게 불때(2) 운동을 즐길 수 있다고 가정하겠습니다. 저 2가지 조건에서만 운동을 즐길 수 있는 것인데 Find-S 알고리즘에서는 하늘이 맑을 때 운동을 할 수 있다는 일반화된 가설을 도출하게 됩니다. 2-2 Candidate Algorithm 하나의 일반적인 가설을 도출하는 Find-S 알고리즘에서 발전된 형태로, 예제에 일치하는 모든 가설의 집합(version space)를 도출하는 알고리즘입니다. 위의 구조에서 G는 매우 Ganeral 한 가설에서 시작하고 S는 매우 Specific 한 가설에서 시작합니다. G는 negative 예제, S는 positive 예제라고 볼 수 있습니다. 각자 조건을 더하거나 빼다 보면 G와 S가 결국 만나게 되는데 이 부분이 모든 가설의 집합인 Version Space가 됩니다. 위의 예시에서 S는 3가지 칼럼을 갖는 하나의 요소가 남았고 G는 1가지 칼럼을 갖는 두 개의 요소가 남았습니다. 이를 통해 우리는 총 6개의 가설을 얻을 수 있습니다. Sunny & Strong Sunny & Warm Warm & Strong Sunny Warm Sunny & Warm & Strong 즉 6개의 후보(Candidate) 가설을 도출해 낸 것입니다. Candidate 방법은 일반화된 하나의 가설을 뽑아내진 못하지만 여러 상황을 고려할 수 있다는 점에서 Find-S보다는 타당한 알고리즘입니다. 하지만 어떤 가설이 정확한지 알 수 없기에 이 또한 현실 세계에서는 사용할 수 없습니다. 결론 결론적으로 우리의 세계는 완벽한 세계가 아니기 때문에 규칙 기반 학습보다는 데이터 기반 학습을 통해 인공지능을 학습시킵니다. 세상은 완벽해질 수 없기 때문에 앞으로도 데이터 기반 학습이 발전할 것으로 예상됩니다. Reference 규칙 기반 방법 이미지 : https://yngie-c.github.io/machine%20learning/2020/04/05/rule_based/ 1) 이미지 분류 데이터 셋 소개 MNIST MNIST(Modified National Institute of Standards and Technology database) 데이터는 손으로 써 여진 숫자 0-9로, 훈련을 위한 60,000개의 이미지와 테스트를 위한 1,000개의 이미지로 이루어져 있습니다. 28x28의 크기로 정규화 및 중앙 정렬되어 있습니다. 모든 데이터 셋은 채널이 하나인 흑백 이미지입니다. 1990년대 Yann LeCun에 의해 제시되었으며 고등학생들의 글씨인 NIST SD-1 과 인구조사국 직원들의 글씨인 NIST SD-3로부터 3만 개씩 뽑아 training set을, 5천 개씩 뽑아 test set을 만들었습니다. MNIST dataset은 Yann LeCun's website에서 다운로드 가능합니다. MNIST의 구조 각 이미지는 28 * 28 = 784의 구조로 이루어져 있으며, 흑백 이미지이기에 한 개의 채널을 갖습니다. 55000개의 Training set의 구조를 본다면, [55000, 784]의 tensor로 구성됨을 알 수 있습니다. 이들의 label의 구조는 [55000, 10] (0 ~ 9의 숫자이므로)으로 이루어집니다. CIFAR CIFAR-10 CIFAR-10 (Canadian Institute for Advanced Reseacrh -10) 데이터 셋에는 50,000개의 Training set과 10,000개의 test set으로 구성된 총 60,000개의 이미지가 있습니다. 총 label 비행기, 자동차, 새, 고양이, 사슴, 개, 개구리, 말, 배, 트럭으로 총 10개이며, 각 이미지는 3channel, 32x32 image입니다. CIFAR-100 CIFAR-100 데이터 셋은 동일한 수의 이미지를 가지고 있지만, 100개의 label을 포함하고 있으며, 클래스 당 600개의 이미지만 있습니다. CIFAR-100 데이터 셋은 20개의 Superclass로 묶어지며, 모든 이미지는 본인이 속한 class인 "fine"label과 본인이 속한 Superclass인 "coarse"label 2개의 label을 갖게 됩니다. Superclass Classes aquatic mammals beaver, dolphin, otter, seal, whale fish aquarium fish, flatfish, ray, shark, trout flowers orchids, poppies, roses, sunflowers, tulips food containers bottles, bowls, cans, cups, plates fruit and vegetables apples, mushrooms, oranges, pears, sweet peppers household electrical devices clock, computer keyboard, lamp, telephone, television household furniture bed, chair, couch, table, wardrobe insects bee, beetle, butterfly, caterpillar, cockroach large carnivores bear, leopard, lion, tiger, wolf large man-made outdoor things bridge, castle, house, road, skyscraper large natural outdoor scenes cloud, forest, mountain, plain, sea large omnivores and herbivores camel, cattle, chimpanzee, elephant, kangaroo medium-sized mammals fox, porcupine, possum, raccoon, skunk non-insect invertebrates crab, lobster, snail, spider, worm people baby, boy, girl, man, woman reptiles crocodile, dinosaur, lizard, snake, turtle small mammals hamster, mouse, rabbit, shrew, squirrel trees maple, oak, palm, pine, willow vehicles 1 bicycle, bus, motorcycle, pickup truck, train vehicles 2 lawn-mower, rocket, streetcar, tank, tractor Fashion MNIST Fashion MNIST는 MNIST의 대안으로 만들어진 데이터 셋입니다. 기존의 MNIST는 너무 쉬워서 어떤 방법론을 사용하더라도 대부분 높은 정확도를 보이는 문제가 있었습니다. Fashion MNIST는 MNIST보다는 좀 더 어려운 문제이나, 기본적인 구조는 MNIST와 마찬가지로 60,000개의 training set과, 10,000 개의 test set으로 이루어져 있으며 MNIST를 완벽히 대체할 수 있습니다. Label 역시 MNIST와 마찬가지로 0-9까지 10개로 다음과 같습니다. Label Description 0 T-shirt/top 1 Trouser 2 Pullover 3 Dress 4 Coat 5 Sandal 6 Shirt 7 Sneaker 8 Bag 9 Ankle boot ImageNet ImageNet은 대표적인 대규모 데이터 셋으로, 20,000개가 넘는 카테고리를 가지고 있으며, 각 카테고리별로 수백 개의 이미지를 포함하고 있습니다. Fei-Fei Li의 아이디어로 2006년부터 image net을 만드는 프로젝트가 시작되었습니다. Image Net의 데이터는, Classification을 위해 Amazon Mechanical Turk 서비스로 사람이 이릴히 분류하도록 해 만들었습니다. ImageNet의 데이터 셋은 ILSVRC(ImageNet Large Scale Visual Recognition Challenge)에서도 쓰입니다. 2013년에 컴퓨터 비전을 기반으로 한 모델이 1위를<NAME> 후 그 이후로 계속 딥러닝 모델이 우승을 차지하고 있습니다. paperswithcode에서 현재까지의 ILSVRC에서 우승한 모델들의 top 1 accuracy, 파라미터 수 등을 확인할 수 있습니다. Reference Yann LeCun's website Tensorflow MNIST tutorial for beginner CIFAR-10 and CIFAR-100 datasets Tensorflow fashion MNIST 튜토리얼 Fashion-MNIST (2) 이미지 분류 모델 이해를 위한 사전 지식(★작성 중) ... (3) 이미지 분류 모델들 Image Classification 아키텍처를 모델에 사용된 Layer 수로 구분했습니다. 1) LeNet, AlexNet, ZFNet(레이어 8개 이하) LeNet-5 LeNet은 CNN을 처음 개발한 Yann LeCun의 연구팀이 1998년에 제시한 단순한 CNN입니다. LeNet의 등장 배경 LeNet 이전의 패턴인식에서 이용되는 모델은 Hand-designed feature extractor로 특징을 추출하고 FC multi layer networks를 분류기로 이용했으나, 이 방법은 여러 가지 문제가 있었습니다. Hand designed feature extractor는 관련 있는 정보만 수집하고 무관한 정보는 제거하는데, feature extractor에 의해 추출된 정보만 가지고 classifier의 학습이 진행되므로 학습에 제한이 있었습니다. LeCun은 feature extractor 그 자체에서 학습이 이루어져야 한다고 생각했습니다. 이미지를 FC로 전환해 학습하는 방식은 너무 많은 parameter를 포함합니다. 입력값의 Topology가 완전히 무시됩니다. 이미지는 기본적으로 2D 구조를 가지고 있는데, 이는 공간적으로 매우 큰 상관관계가 있습니다. FC는 이미지를 일렬로 펼치기 때문에, 이런 공간적인 관계를 완전히 무시하게 됩니다. LeCun은 이 문제의 해결점으로 CNN을 제시합니다. CNN은 classifier뿐 아니라 feature를 추출하는 단계 역시 학습이 진행되고, Weight sharing과 Local connectivity에 의해 파라미터 수를 줄일 수 있으며, 이미지의 공간적인 Topology를 반영할 수 있습니다. LeNet의 구조 위 LeNet의 구조입니다. 여기서 주목할 점은 C3 layer인데, 모든 S2 feature map이 C3의 feature map에 연결되지 않았습니다. C3의 feature map과 연결된 S2의 feature map은 아래와 같이 생겼습니다. 저자들은 모든 feature map을 연결하지 않아 Connection을 줄일 수 있고, 서로 다른 입력값을 취하도록 해서 C3의 각 feature map이 서로 다른 feature를 추출하기 위해 그렇게 했다고 설명합니다. 단계별로 LeNet이 어떻게 나타나는지를 아래에서 확인할 수 있습니다. LeNet의 특징 Filter size : 5x5 stride : 1 Pooling : 2x2 average pooling Activation function: 대부분의 unit이 sigmoid를 사용. F6에서는 tanh를 사용. 최종적인 output layer인 F7에서는 RBF (Euclidian Radia basis function unit)을 사용 loss function : MSE Reference 원본 paper : Gradient-based learning applied to document recognition (Y.Lecunn et al. , 1998) Yann LeCun 's MNIST Demo 딥러닝 공부방 | LeNet-5 (1998), 파이 토치로 구현하기 AlexNet AlexNet은 2012년 Alex Krizhevsky , Ilya Sutskever, Geoffrey Hinton에 의해 제시된 CNN architecture로 기본적인 구조는 LeNet과 비슷하나, GPU 2대를 이용하여 빠른 연산이 가능해지면서 병렬적인 구조를 가지게 됩니다. AlexNet의 특징 Activation function 처음으로 ReLU 사용. RELU를 사용하면 기존에 사용하던 Tanh, Sigmoid function에 비해 6배 빠르게 원하는 수준 이하의 error rate에 도달할 수 있습니다. Over-fitting 방지를 위해 도입한 방법 Data augmentation : 데이터 셋 이미지를 좌우 반전을 시키거나 (flip augmentation), 이미지를 잘라서 (Crop augmentation) 데이터 수를 늘림. 또 RGB 값을 조정하여 (jittering) 데이터 수를 늘림. Dropout: rate 0.5 Norm layer 사용 : 원시적인 형태의 batch normalization , 지금은 쓰이지 않음 Batch size 128 SGD momentum 0.9 learning rate 1e-2 , validation accuracy에 따라 manual 하게 낮춤 L2 weigh decay 5e-4 7 CNN ensemble : error 18.2 % --> 15.4% Reference 원본 paper : ImageNet Classification with Deep Convolutional Neural Network (A, Krizhevsky et al. , 2012) PIEW 9 | AI 인공지능 기초 CNN 아키텍처 '알렉스 넷' 논문 리뷰 ZFNet AlexNet에 이허 ILSVRC 2013에서 우승한 구조이며 역시 CNN 기반 모델입니다. CNN 모델의 고질적인 문제는 Black box, 즉 특정 layer는 이미지의 어떤 부분을 검출하는지, 모델이 왜 잘 작동하는지 알 수 없다는 점입니다. ZFNet은 feature map을 시각화하여 블랙박스를 들여다보고, 모델의 성능을 개선하는 것을 목표로 고안되었습니다. 위 그림과 같이 n-1 번째 pooled maps이 "Convolution > ReLU activation > Max Pooling"을 통과하여 n 번째 Pooled Maps을 생성하였다고 해봅시다. 저자들은 n 번째 Pooled Maps에 해당 구조의 역과정을 수행하여 n-1 번째 pooled maps을 복원 (reconstruction) 해보고자 하였습니다. 1. Max unpooling: max pooling을 할 때 위치 정보를 같이 기억합니다. max pooling의 역과정을 수행할 때 max 값이 위치했던 영역에 max 값을 집어넣고 나머지 영역은 0으로 채웁니다. 2. ReLU: ReLU를 통과하면 양수는 그대로 값이 보존되지만 음수 값은 모두 0으로 변경됩니다. 음수 값이 모두 소실되기 때문에 ReLU의 역과 정은 (양수 → 양수, 0 → 0)이 됩니다. (저자들은 음수 값을 복원하지 못하고 0으로 처리해도 그 영향이 미미하다고 주장합니다.) 3. Transposed Convolution: Convolution의 역과정으로 Transposed convolution을 시행하였습니다. Transposed Convolution에 대한 자세한 설명은 여기를 참고하세요. AlexNet의 각 layer를 시각화한 결과 Layer 1이나 2를 시각화한 결과 이미지의 모서리, 경계, 색과 같은 Low level feature를 잡아내는 것을 볼 수 있습니다. Layer 3에서는 전반적인 패턴, 사물과 객체의 경계를 잡아내고 있습니다. Layer 5에서는 사물이나 개체의 전부를 보여주며 각각 다른 위치나 자세를 취하고 있는 모습을 잡아내고 있습니다. AlexNet을 수정하여 ZFNet으로 feature map을 시각화할 수 있으니 어떤 식으로 CNN 구조를 수정하면 성능이 좋아질지 어느 정도 예측할 수 있게 되었습니다. 여러 차례 수정을 거쳐 최종적으로 만들어낸 ZFNet의 구조는 아래와 같습니다. 최종적으로 ImageNet으로 테스트했을 때, Test set Top-5 error가 16.4%에서 11.7%로 감소했습니다. Reference ZFNet 이란 DSBA | CNN Localization (ZFNet&Deep Taylor Decomposition) DSBA | Introduction to Image Classification Basic Networks : AlexNet, ZFNet, VGGNet, ResNet Review: ZFNet — Winner of ILSVRC 2013 (Image Classification) Docs » Computer vision » Convolutional Neural Network » ZFNet 2) VGG, GoogLeNet(레이어 22개 이하) 우리는 앞서 8 layer 이하의 비교적 적은 수의 layer를 가진 CNN model 들을 보았습니다. 지금부터 살펴볼 VGG, GoogleNet의 부 터는 layer가 더 깊게 쌓이기 시작합니다. 두 논문 모두 논문 제목에서부터 본인들이 layer를 깊게 쌓았음을 강조하고 있을 정도로, 더 네트워크를 깊게 만들었음은 이전 모델들과의 핵심적인 차이점이자, 좋은 성능을 내는 이유이기도 합니다. 더 깊은 네트워크가 좋은 이유는 2) 더 깊은 딥러닝 모델들에서 간략히 설명했습니다. 그러나 네트워크를 깊게 쌓는다는 것은 생각보다 당시에는 쉬운 일이 아니었습니다. Gradient vasnishing /exploding 과 같은 문제를 효과적으로 해결할 수 있어야 하고, 파라미터 수가 늘어나 overfitting을 야기할 수 있기 때문입니다. 여기서 설명할 VGG, GoogLeNet, ResNet은 전술한 문제들을 해결하는 방법이 조금씩 다릅니다. 어떻게 이런 문제들을 해결하는지 집중해서 살펴보도록 하겠습니다. VGG-16 / VGG-19 VGGNet은 ILSVRC' 14에서<NAME>승을<NAME> 모델로, 당시 7.3 %의 Top 5 error를 보였습니다. 13년도에 우승했던 ZFNet 이 11.7%의 Top 5 error를 보였던 것을 감안하면 상당히 많이 향상된 것으로 볼 수 있습니다. AlexNet, ZFNet이 모두 8개의 층을 사용하는 반면 네트워크를 16-19 층까지 쌓아 VGG를 기점으로 네트워크의 구조가 많이 깊어지게 됩니다. VGGNet의 특징 3x3의, 보다 작은 필터를 사용합니다. ( VGG 이전에는 5x5를 주로 사용했습니다. ) 작은 필터가 주는 효과 필터의 사이즈를 줄이면서 보다 깊게 쌓았을 때 더 효율적인 receptive field를 가지게 됩니다. 더 넓은 필터를 쓰고 얇은 층을 쌓는 것이나, 작은 필터를 쓰고 깊게 쌓는 것이나 receptive field가 같다는 의미입니다. Layer가 깊어지면서 다수의 activation function을 통과하므로 더 많은 non-linearity를 줄 수 있게 됩니다. 층 당 더 적은 수의 파라미터를 사용하게 됩니다. ex) 10×10 image에 7×7 filter 적용하여 4×4 feature map 생성 → parameter 개수: 49개 ex) 10×10 image에 3×3 filter 3번 적용하여 4×4 feature map 생성 → parameter 개수: 9개씩 3번 총 27개 padding을 이용해 이미지 사이즈를 유지하게 됩니다. padding이 주는 효과 이전에는 Convolution 연산의 특징상 Layer가 깊어지게 되면 가장자리 부분이 주는 영향력이 점점 줄어들게 되고 이미지 사이즈를 유지할 수 없었습니다. 그러나 VGG부터는 padding을 도입하면서 Network가 깊어져도 이미지 사이즈를 유지할 수 있게 됩니다. Framework 별 사용법 VGG는 대부분의 deep learning framework(pytorch, tensorflow 등)에서 pre-trained 된 모델을 바로 사용할 수 있습니다. 필요에 따라서는, pre-trained된 weight 없이 network architecture만 가져오는 것도 가능합니다. Keras Keras에서는 keras.applications 모듈에서 import 할 수 있습니다. keras에서는 VGG 16, 19 모두 지원하고 있습니다만, keras document에 있는 VGG16에 대한 설명을 보면서 사용법을 익혀보도록 하겠습니다. tf.keras.applications.VGG16( include_top=True, weights="imagenet", input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation="softmax", ) 실제로 모델을 사용할 때는 아래와 같이 이용이 가능합니다. VGG16, 19 모두 kereas.Model object를 return 합니다. model.summary() 함수를 이용하면 전체 구조를 출력해 확인할 수 있습니다. from keras.applications import vgg16 model = vgg16.VGG16(weights ='imagenet', include_top = True) model.summary() model.summary()의 output, VGG16 구조 (주의) PyTorch PyTorch에서는 pytorch hub를 통해 구현된 architecture를 받을 수도 있고, torchvision 라이브러리를 이용할 수도 있습니다. 공식적으로는 vgg11, vgg16, vgg 19 그리고 각 모델에 batch normalization이 추가된 버전으로 총 6가지를 제공하고 있습니다. 공식 사이트에서 간단한 classification 예제를 보여주고 있습니다. (https://pytorch.org/hub/pytorch_vision_vgg/) torch hub import torch model = torch.hub.load('pytorch/vision:v0.10.0', 'vgg16', pretrained=True) # pre-trained weight가 필요 없을 때는 False torchvision import torchvision model = torchvision.models.vgg16(pretrained=True) Reference cs231n VGGNet paper : Very Deep Convolutional Networks for Large-Scale Image Recognition PIEW9|VGGNET GoogLeNet (inception - v1) 영화 Inception에서는, 다른 사람의 꿈에 접속하고, 꿈속의 꿈에 접속하고, 꿈속의 꿈속의 꿈에 접속하는 식으로 계속 깊이 들어가 표적의 무의식에 도달해 어떤 생각을 심어주거나 하는 내용을 담고 있습니다. GoogleNet의 핵심이 되는 Inception module의 이름이 이 영화에서 비롯된 것입니다. GoogleNet은 ILSVRC' 14에서 우승을 차지했으며, "Going Deeper with Convolutions"라는 논문의 제목답게 전년도에 우승한 ZFNet보다 무려 14층을 더 쌓아, 22층의 구조를 만듭니다. 현재는 GoogleNet보다 성능이 더 좋은 네트워크들이 많이 등장했지만, Inception module이라는 아이디어는 최근까지도 다른 모델에서 응용되기도 하고 또 Classification에 쓰이지는 않더라도, 좋은 Feature selector 로서 컴퓨터 비전 분야의 다른 문제 해결에 아직까지도 활발히 이용되고 있습니다. GoogleNet의 특징 22 layers 효과적인 "Inception" module FC layer 없음 (Output layer 에서만 한번 나옴) 오직 500만 개의 파라미터 사용 ILSVRC'14 우승, 6.7 % top 5 error Inception module GoogLeNet은 Inception module이 여러 차례 반복되는 형태로 이루어집니다. 우리는 직접 하나하나 테스트해보기 전에 어느 위치에 어떤 크기의 필터를 쓰는 것이 optimal 인지, 혹은 이 자리에 pooling이 들어가는 게 optimal 일 지 정확하게 알 수 있을까요? VGG는 3x3을 쓰지만 과연 3x3이 optimal일까요? 우리는 모릅니다. Inception module의 기본적인 아이디어는 우리는 뭐가 optimal 인지 모르지만! 다해서 넣어보자 그럼 optimal을 뽑아내도록 학습하겠지!! 입니다. (흥미롭게도 같은 Google에서 Semantic segmentation을 위해 제시한 DeepLab과도 철학이 유사합니다.) 그래서 1x1 convolution, 3x3 convolution, 5x5 convolution 그리고 3x3 max pooling 4가지를 병렬적으로 처리하고 output을 concat 합니다. 이것이 naive inception module입니다. 하지만 이는 실제로는 잘 작동하지 않았습니다. 여러 가지 convolution 및 pooling의 output을 하나로 concat 하는 것은 dimension을 상당히 늘릴 수밖에 없었고 너무나도 비효율적이었습니다. 그래서 이번에는 Inception module 안에 1x1 convolution 층을 추가합니다. Convolution 연산은 연산량이 많으니까, Convolution 연산 전에 dimension을 줄여주고, max pooling은 Convolution에 비해 간단하니 연산 이후에 dimension을 줄여 모든 output을 concat 합니다. 이렇게 inception은 계산상의 어려움 없이 layer를 늘릴 수 있게 됩니다. 병렬적으로 수행된 연산들은 Inception module을 나오면서 아래와 같이 Concat 되어 다음 Layer로 넘어갑니다. 1x1 Convolution의 역할 Inception module 안에 들어가는 1x1 Convolution은 Network in Network (Lin et al)에서 소개된 개념으로 inception에서는 Bottleneck layer라고도 부릅니다. 1x1 convolution은 Dimension이 깊은 network에 대해 각 포인트마다 중요하다고 생각되는 정보를 뽑아내는 역할을 한다고도 볼 수 있습니다. Inception에서는 Channel 수를 줄여 계산상에서의 이점을 보도록 도와주고, 비선형성을 증가시켜 더 복잡한 함수도 approximation 할 수 있도록 도와주는 역할을 합니다. Inception의 Auxilary classifier GoogleNet에는 Auxilary classifier라고 하는 중간중간에 Output을 내는 구조가 있습니다. GoogleNet에서 처음 도입한 방법으로, 중간중간에 Output을 먼저 만들고 이를 Back propagation 시 반영해 Layer가 깊어짐에 따라 발생할 수 있는 Gradient vanishing / explosion 을 방지합니다. 제일 초창기 모델인 GoogleNet (Inception-v1)의 경우에는 Auxilary classifier를 2개 썼으나, Inception-v2, v3부터는 Auxilary classifier를 하나로 줄였고, Inception-v4부터는 Auxilary classifier를 아예 사용하지 않습니다. 왜 요즘은 Auxilary classifier를 사용하지 않을까요? Auxilary classifier에는 한 가지 문제가 있습니다. 초반 Layer에서 output을 내고 이걸 Backpropagation에 반영하면 당연하게도 초반 Layer에서 잘 Classification을 잘 학습시킬 수 있는 방향이 어느 정도 반영되어 학습이 진행될 것입니다. 이에 따라 최종 Classification layer에서 Optimal 한 feature가 뽑히지 않는 문제가 있습니다. Framework 별 사용법 VGG 와 마찬가지로 대부분의 deep learning frame work에서 바로 사용할 수 있습니다. Keras Keras에서는 keras.applications 모듈에서 import 할 수 있습니다. Keras document에 있는 InceptionV3에 대한 설명을 보면서 사용법을 익혀보도록 하겠습니다. tf.keras.applications.InceptionV3( include_top=True, # classification (softmax) 부분을 포함할 것인지 선택하는 것입니다. weights="imagenet", # imageNet으로 pre-trained 된 모델을 받을 것인지를 선택하는 것입니다. 만약 pre-trained 된 모델을 받길 원하지 않는다면 None으로 넣으면 됩니다. input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation="softmax", ) 실제로 모델을 사용할 때는 아래와 같이 이용이 가능합니다. InceptionV3는 kereas.Model object를 return 합니다. model.summary() 함수를 이용하면 전체 구조를 출력해 확인할 수 있습니다. from keras.applications import inception_v3 model = inceotion_v3.InceptionV3(weights='imagenet', include_top=True) model.summary() model.summary()의 output, Inception V3의 구조 (주의) Pytorch VGG와 마찬가지로 torch hub와 torchvision 라이브러리에서 이용할 수 있습니다. Inception - V3와 GoogLeNet을 지원하고 있습니다. 공식 사이트에서 간단한 classification 예제를 보여주고 있습니다. (https://pytorch.org/hub/pytorch_vision_inception_v3/ torchhub import torch model = torch.hub.load('pytorch/vision:v0.10.0', 'inception_v3', pretrained=True) torchvision import torchvision model = torchvision.models.inception_v3(pretrained=True) Reference Youtube|Idea Factory KAIST 논문 : Going Deeper with Convolutions (Szegedy et al) cs231n C4W2L05 Network In Network 3) ResNet, ResNet의 확장(레이어 152개 이하) ResNet CNN을 연구하면서 기존 모델들은 Layer을 깊게 쌓을수록 성능이 더 좋아질 것이라고 예상했지만, 실제로는 20층 이상부터 성능이 낮아지는 현상인 Degradation 문제가 발생했습니다. ResNet은 Residual Learning이라는 개념을 통해 모델의 층이 깊어져도 학습이 잘 되도록 구현한 모델입니다. ResNet은 무려 152층까지 네트워크를 쌓으며 ILSVRC'15와 COCO'15에서 우승하게 됩니다. 처음으로 Human error를 능가하는 3.57%의 top5 error를 보입니다. ResNet에서 제시하는 Residual Learning이라는 개념은 이후 많은 모델들에서 응용되었으며, 아직까지도 많은 사람들이 성능도 좋고, 구현도 편하고 단순하다는 점 때문에 ResNet을 유용하게 사용하고 있습니다. 매우 깊은 네트워크의 문제점 Inception과 VGG가 보다 '깊은' 네트워크임을 강조하면서 ILSVRC에서 좋은 성적을 거두게 되었지만 사람들은 과연 네트워크가 깊어지는 것만으로 성능을 향상시킬 수 있을까라는 의문을 가지게 되었습니다. "plain" convolutional neural network에서 Layer를 무작정 늘렸을 때 성능이 오히려 떨어졌기 때문입니다. Training에서도, Test에서도 성능이 좋지 않았기 때문에 우리는 이것이 Overfitting 때문이 아님을 알 수 있습니다. 우선 직관적으로 우리는 Gradient vanishing / explosion이 발생할 수 있음을 알 수 있습니다. 이것 외에도 우리는 Degradation Problem이라고 부르는, layer가 어느 정도 이상으로 깊어지면 오히려 성능이 안 좋아지는 현상이 벌어짐을 알 수 있습니다. 이 현상의 원인을 어떤 사람들은 layer가 깊어졌을 때 Optimization이 제대로 되지 않아서라고 추측했습니다. 만약에 Optimization 문제라면 우리는 1) 새로운 Optimizer를 만들거나, 2) 깊어지더라도 쉽게 Optimization을 할 수 있는 새로운 Architecture를 만들어 문제를 해결할 수 있습니다. Optimizer를 새로 만드는 것은 매우 어려운 문제이기 때문에 많은 사람들은 새로운 Network를 만드는데 집중했습니다. Residual block H(x)를 기존의 네트워크라고 할 때, H(x)를 복잡한 함수에 근사 시키는 것보다 F(x) := H(x) - x 일 때, H(x) = F(x) + x이고, F(x) + x를 근사 시키는 것이 더 쉬울 것이라는 아이디어에서 출발합니다. 원래 Output에서 자기 자신을 빼는 것이 F(x)의 정의이므로, 'Residual learning'이라는 이름을 갖게 됩니다. 또한, x가 F(x)를 통과하고 나서 다시 x를 더해주기 때문에 이를 Skip Connection이라고 부릅니다. x : 입력값 F(x) : CNN Layer -> ReLU -> CNN Layer 을 통과한 출력값 H(x) : CNN Layer -> ReLU -> CNN Layer -> ReLU를 통과한 출력값 기존 신경망은 H(x)가 정답 값 y에 정확히 매핑이 되는 함수를 찾는 것을 목적으로 했습니다. 즉 신경망은 학습을 하면서 H(x) -y의 값을 최소화시키면서 결국 H(x) = y가 되는 함수를 찾았습니다. 위 그림에서 H(x)는 Identity를 매핑해주는 함수이기 때문에 H(x)-x를 최소화하면서 H(x) = x 가 되는 것을 목표로 합니다. 기존 신경망이 H(x) - x = 0을 만들려 했다면 ResNet은 H(x) - x = F(x)로 두어 F(x)를 최소화시키려고 합니다. 즉 F(x) = 0이라는 목표를 두고 학습을 진행합니다. 이렇게 학습을 진행하면 F(x) = 0이라는 목푯값이 주어지기 때문에 학습이 더 쉬워집니다. 결국 H(x) = F(x) + x 가 되는데 이때 입력값인 x를 사용하기 위해 쓰는 것이 Skip Connection입니다. 즉 Skip Connection은 입력 값이 일정 층들을 건너뛰어 출력에 더할 수 있게 하는 역할을 합니다. 아래에서처럼 일반적인 CNN에서 나타나는 "main path"와 Skip connection에 의해 연결되는 "short cut"을 가지게 됩니다. Plain neural network와 비교했을 때 Layer를 상당히 깊게 쌓았음에도 적게 쌓았을 때보다 에러가 낮으며 degradation problem이 발생하지 않은 것을 알 수 있습니다. Plain과 비교했을 때 ResNet은 아래와 같이 Shortcut으로 이어진 것을 볼 수 있습니다. Deeper bottleneck architecture 50층 이상의 깊은 모델에서는 Inception에서와 마찬가지로, 연산 상의 이점을 위해 "bottleneck" layer (1x1 convolution)을 이용했습니다. 기존의 Residual Block은 한 블록에 Convolution Layer(3X3) 2개가 있는 구조였습니다. Bottleneck 구조는 오른쪽 그림의 구조로 바꾸었는데 층이 하나 더 생겼지만 Convolution Layer(1X1) 2개를 사용하기 때문에 파라미터 수가 감소하여 연산량이 줄어들었습니다. 또한 Layer가 많아짐에 따라 Activation Function이 증가하여 더 많은 non-linearity가 들어갔습니다. 즉 Input을 기존보다 다양하게 가공할 수 있게 되었습니다. 결론적으로 ResNet은 Skip Connection을 이용한 Shortcut과 Bottleneck 구조를 이용하여 더 깊게 층을 쌓을 수 있었습니다. ResNet 초창기 논문에서는 110 Layer에서 가장 적은 에러가 나왔고, 1000개 이상의 layer가 쌓였을 때는 오버 피팅이 일어났다고 합니다. ResNet이 잘 되는 이유 원 논문에서는 자신들이 어떤 이론을 바탕으로 결과를 도출했다기보다는 경험적으로 residual block을 쓰니 결과가 좋게 나왔다고 말합니다. 그럼에도 불구하고 ResNet이 왜 잘 동작하는지 설명하려는 많은 노력이 있었고, 아직까지도 많은 사람들이 연구하고 있습니다. 그중에서 소개할 한 가지는 바로 Residual Net이 만들어내는 모델을 이용하는 것은 Optimal depth에서의 모델을 사용하는 것과 비슷하다는 가설입니다. 우리는 쉽게 Optimal depth를 알 수가 없습니다. 20층이 Optimal 인지, 30층이 optimal 인지, 100층이 optimal 인지 아무도 모릅니다. 하지만, degradation problem은 야속하게도 우리는 알 수 없는 optimal depth를 넘어가면 바로 일어납니다. ResNet은 엄청나게 깊은 네트워크를 만들어주고, Optimal depth에서의 값을 바로 Output으로 보내버릴 수 있습니다. 이게 어떻게 가능할까요? 바로 Skip connection 때문입니다. ResNet은 Skip connection이 존재하기 때문에 Main path에서 Optimal depth 이후의 Weight와 Bias가 전부 0에 수렴하도록 학습된다면 Optimal depth에서의 Output이 바로 Classification으로 넘어갈 수 있습니다. 즉 Optimal depth 이후의 block은 모두 빈 깡통이라는 것입니다. 예를 들어 27층이 Optimal depth인데 ResNet 50에서 학습을 한다면, 28층부터 Classification 전까지의 weight와 bias를 전부 0으로 만들어버리는 겁니다. 그러면 27층에서의 output이 바로 Classification에서 이용되고, 이는 Optimal depth의 네트워크를 그대로 사용하는 것과 같다고 볼 수 있습니다. ResNet의 확장 Identify Mappings in Deep Residual Networks Wide Residual Networks ResNeXt Deep Networks with Stochastic Depth SeNet DenseNet Reference DeepLearning AI | C4W2L03 Resnets cs231n 원 논문: Deep Residual Learning for Image Recognition (He et al.) Residual block 사진 : https://mole-starseeker.tistory.com/12 4) Vision transformer(★작성 중) NLP 분야에서의 트랜스포머를 컴퓨터 비전에 적용한 네트워크입니다. CNN만 이용한 네트워크 보다 좋은 성능을 보여주고 있습니다. 쳅터1에서 정리한 Transformer을 이해하고 있다는 전제하에 AN IMAGE IS WORTH 16X16 WORDS : TRANSFORMERS FOR IMAGE RECOGNITION AT SCALE 논문에서 이미지를 어떻게 Transformer에 적용했는지 중심으로 리뷰하겠습니다. 요약 논문에서 제시한 ViT는 NLP 분야에서의 Transformer의 Encoder 부분(Self-Attention)을 그대로 응용하였습니다. 논문이 주는 강력한 메시지는 Vision Task에서 CNN을 이용하지 않고 충분한 퍼포먼스를 낼 수 있다는 점을 보여줬다는 점이라고 생각합니다. 다만, 단점 역시 존재합니다. 충분한 데이터 셋으로 Pretrain 하고 타깃 도메인에 Fine-tuning해야 성능을 제대로 발휘한다는 점입니다. 논문에서 표현한 한 장의 대표 이미지가 모든 과정을 잘 표현하고 있으므로, 대표 이미지 하나를 보여드리고 ViT 알고리즘을 순서대로 따라가 보도록 하겠습니다. 네트워크 구조 1. Image Patch 만들기 트랜스포머는 NLP 분야에서 출발한 만큼 1D 임베딩들을 필요로 합니다. 논문 저자들은 이미지 패치를 만들어 1D임배딩을 만들어 나갑니다. 이해를 돕기 위해 대표 이미지 기준으로 설명드리면 [300,300,3]의 이미지를 [100,100,3] 이미지 9개로 만들었습니다. 2-1. Patch Embedding 만들기 패치화된 각 이미지를 1차원으로 만듭니다 (Linear Projection). 앞서 하나의 패치가 [100,100,3]이었다면 각 픽셀들을 일렬로 이어 붙여서 [1,100X100X3]인 1차원으로 만듭니다. (이 뒤부터는 NLP의 Transformer 인코딩과 동일합니다, 정리를 위해서 다시 리뷰하도록 하겠습니다) 2-2. Class token 만들기 BERT의 CLS token과 유사하게, 저자들은 임베딩된 patch의 맨 앞에 하나의 학습 가능한 Class token을 추가하였습니다. 이 Class token은 Transformer의 여러 encoder 층을 거쳐 최종 output으로 나왔을 때, 이미지에 대한 1차원 representation vector로서의 역할을 수행합니다. (BERT의 CLS Token과 거의 동일한 역할을 수행하므로 이에 대해 먼저 공부하면 이해가 빠릅니다. BERT에 대해 공부하려면 딥러닝을 이용한 자연어 처리 입문 | BERT를 참고하세요. CLS Token이 왜 전체 문장의 representation vector로 작용하는지 이해하려면 여기를 참고하세요.) 2-3. Position Embedding 1차원으로 만든 벡터에 같은 차원의 Position Embedding을 더해줍니다. Position Embedding은 오리지널 Transformer와 같이 임배딩에 순서 정보를 부여하기 위해서입니다. (하지만 이 부분은 Optional이라고 소개한 사이트도 있는 것으로 보아 꼭 필요한 알고리즘은 아닌 것 같습니다) 위 과정을 마치면 전체 이미지는 [1, 100X100X3] 차원의 embedding vector 10개로 정의되며, 이후 Transformer의 Encoder로 들어가게 됩니다. 3-1. Layer Normalization 모든 이미지 임배딩을 채널 기준으로 Layer Normalization을 합니다. 3-2. Multi-Head Self Attention (MSA) Patch + Position Embedding을 이용하여 Self-Attention을 수행하기 위해 임배딩 1개당 1개씩의 q(쿼리),k(키),v(밸류)를 학습 가중치 W_q, W_k, W_v를 이용하여 구합니다 만약 num_heads를 12이라고 하면 각 임배딩마다 [1, 100X100X3/12] 차원의 q, k, v를 가지게 됩니다. 이렇게 구한 q, k, v를 이용하여 Attention Value를 구하고 이것들을 차원 방향으로 concat 하여 Multi-Head Attention을 만듭니다. 12번 self-attention을 수행한다고 하면 image patch 한 개의 Attention Value Matrix는 [1, 100X100X3/12] 차원을 가집니다. num_heads 개수인 12개 Attention Value Matrix를 구하여 차원 방향으로 Concat 하면 한 개의 image patch 당 [1,100X100X3] 개의 오리지널 임배딩의 차원을 회복합니다. 3-3. Residual Connection (잔차 연결) 2단계에서 구한 Input 임배딩과 3- 2단계에서 구한 Multi-Head Attention을 더해 잔차 연결을 합니다. ([10, 1,100X100X3]로 차원이 동일합니다) 4-1. Layer Normalization 3- 3단계에서 잔차 연결한 Matrix를 3-1번과 동일하게 채널 기준으로 Normalization을 실시합니다. 4-2. Multi Layer Perceptron (MLP) 두 개의 Linear Layer로 구성되며 첫 번째 레이어에서 임배딩 사이즈를 확장하고 두 번째 레이어에서 원래의 임배딩 사이즈로 복원합니다. 4-3. Residual Connection (잔차 연결) 4- 2단계에서 구한 Matrix와 3- 3단계의 Matrix를 더해 최종 output feature를 만듭니다. 2번 input embedding이 3 & 4단계를 거쳐 최종 output feature를 만드는 과정을 수식으로 정리하면 아래 (1)~(3)처럼 표현할 수 있습니다. 5. Multi Layer Perceptron (MLP) head 여기부터 Transformer의 output 출력단이라고 할 수 있으며 일반적인 CNN의 Image classfier와 동일합니다. 특이한 것은 Class token만을 사용한다는 점입니다. 앞서 말했듯 Class token이 Transformer의 여러 encoder 층과 Layer Normalization을 거쳐 최종 output, y가 나왔을 때, 이 y가 이미지에 대한 1차원 representation vector로서의 역할을 수행하기 때문입니다. MLP는 y를 Flatten 한 후 단순 Linear Layer를 통과시켜 classification을 수행합니다. ViT Training & Fine-Tuning 일반적으로 large-scale dataset에 대해 ViT를 pre-train 하고 downstream task에 대해 fine-tuning을 수행합니다. 이를 위해 pre-trained Multi Layer Perceptron (MLP) head를 제거하고 0으로 초기화된 D × K feedforward layer를 추가합니다. 여기서 D는 100X100X3, K는 downstream class의 개수입니다. ViT의 성능 ViT의 단점, 한계 Reference 원논문 AN IMAGE IS WORTH 16X16 WORDS : TRANSFORMERS FOR IMAGE RECOGNITION AT SCALE Youtube DMQA Open Seminar | Transformer in Computer Vision 블로그 ViT(Vision Transformer) 해체 신서 논문 요약 Vision 분야에서 드디어 Transformer가 등장 딥 러닝을 이용한 자연어 처리 입문 6) CoAtNet(Convolution+Transformer) Background 2021년 6월, Google AI 팀에서 EfficientNet-V2와 함께 발표한 CoatNet은 발표와 동시에 ImageNet top 1 accuracy SOTA를 갈아치운 모델로 Convolution과 Attention을 합친 방법을 제시했습니다. 이런 방법이 제안된 배경에 대해 생각해 봅시다. ViT의 문제점. ViT는 확실히 JFT-300(대충 3억 개 정도..) 같은 엄청난 양의 데이터가 주어졌을 때는 CNN보다 성능이 좋지만, 그렇지 못할 때는 일반적으로 vanilla ResNet보다도 성능이 떨어집니다. 이렇게 ViT가 적은 데이터 셋에서 성능이 떨어지는 이유는, CNN이 가지는 고유의 inductive bias(지금까지 만나보지 못했던 이미지를 봤을 때 정확한 판단을 내리기 위해 사용하는 추가적인 가정)보다 ViT가 가지는 inductive bias가 약하기 때문입니다. 예를 들어 CNN의 inductive bias는 "Locality"입니다. 모델의 설계 자체에 Vision task는 지역적인 정보에서 중요한 게 많다는 가정이 깔려있는 것입니다. 실제로도 이는 Vision task에서는 적절한 가정입니디. CNN 특유의 generalization이 잘 된다는 특징 역시 이 가정을 기반으로 한 모델이기에 가능한 것입니다. 하지만 CNN은 Global 한 정보를 잘 이용하지 못한다는 단점이 있습니다. 그래서 CNN은 receptive field를 넓히기 위해 층을 깊게 쌓는 식으로 진화해 왔습니다. 그렇다면 CNN의 Locality와 ViT의 Self-attention, Input-dependent weightning을 모두 이용할 수 있는 방법은 없을까요? 당연히 이런 시도를 한 사람들이 있었습니다. 하지만 지금까지의 연구들은 어떻게 Convolution에 Self-attention의 특징을 추가할지, 어떻게 ViT에 Convolution의 특징을 추가할지를 고민하는 방향으로 진행되었습니다. 하지만 어떻게 넣느냐 만큼이나 중요한 것이 각각의 특징을 얼마나 포함시켜 섞을지도 중요한 문제입니다. CoatNet은 이를 고려하여 제시된 모델입니다. Convolution과 Attention CNN과 transformer를 베이스로 한 architecture는 상술했듯 각각의 장단점이 있습니다. Convolution과 Attention을 합치기 위해서는 이 둘의 특징을 분석해 볼 필요가 있습니다. 그래서 CoatNet의 저자들은 둘 각각의 시스템적인 분석을 진행했고 요약하자면 아래와 같습니다. Convolution layer는 빠르게 수렴할 수 있고, 특유의 inductive bias(Locality, parameter sharing) 덕택에 generalization을 잘한다. (translation equivariance) Translation equivariance Equivariance란, 함수의 입력이 바뀌면 출력 또한 바뀐다는 의미로 입력의 위치가 변하면 출력도 동일하게 변한다는 의미입니다. CNN의 Classification은 max pooling으로 인해 translation invariance 하게 이루어지지만, Convolution layer 자체는 translation equivariance 합니다. CNN의 inductive bias로 꼽히는 Locality와 Parameter sharing에 주목해 봅시다. Locality는 입력 이미지의 일부 지역의 픽셀만 고려하는 특징이고, Parameter sharing은 Conv kernel의 weight가 모두 공유되는 특징입니다. Convolution layer가 Translation equivalence라는 특징을 갖는 것은 이 두 가지 때문입니다. 논문에서는 주로 MobileNet의 MBConv block에 초점을 맞췄는데, Attention의 FFN이 채널을 늘였다가 줄이는 Inverted Bottle neck이 MBConv와 유사하다고 판단했다고 합니다. Attention은 CNN과 반대로 Global receptive field를 가지고, Input-dependent 한 weight는 여러 spatial position들 사이의 관계성을 잘 포착할 수 있으며, CNN과 비교했을 때 Capacity가 높다. > 더 큰 dataset에 적합하다. 이런 점들을 놓고 보면 Computer vision의 문제를 해결하기 위해 우리는 Conv layer로부터 Translation Equivariance를, Attention layer로부터는 Input-adaptive weighting과 Global receptive field라는 장점을 가져와야 한다고 생각해 볼 수 있습니다. 저자들은 이를 단순히 Attention에 Global static convolution kernel을 추가해서 시도했습니다. Softmax 후에 넣을지, 전에 넣을지 두 가지 경우로 나눌 수 있습니다. 이런 방법을 Relative Attention이라고 정의했습니다. 다양한 Block들을 어떻게 합칠 것인가? Attention의 실용성을 해치는 가장 큰 원인은 토큰의 제곱으로 증가하는 연산량입니다. Attention을 기반으로 한 architecture들은 다양한 방법으로 Attention의 연산 방식을 바꿔 연산량을 줄이려는 시도를 했고 ViT의 경우 이미지를 패치로 잘라 토큰을 줄이는 전략을 취했습니다. CoatNet에서는 multi-stage layout을 이용해, ConvNet이 5개의 stage를 갖도록 구성했습니다. S0는 simple 2-layer convolution이, S1에서는 MBConv block과 Squeeze-excitation이 적용되었습니다. S2-S4까지는 Convolution이 Local pattern 처리에 유리하다는 가정에 입각해 각 stage의 초반부에는 Convolution(MBConv)을 넣고, 뒤쪽에는 Transformer stage를 넣었습니다. C를 Convolution, T를 transformer라고 했을 때 C-C-C-C, C-C-C-T, C-C-T-T, C-T-T-T로 구성되었다고 합니다. 모델 결정 저자들은 Convolution의 장점이었던 generalization과, Attention의 장점이었던 model Capacity의 관점에서 비교를 진행했습니다. 여기서 용어에 대해 한번 다시 정의를 해보겠습니다. Generalization : train과 validation score의 최소 gap. Capacity : Overfit 없이 학습할 수 있는 데이터 셋의 크기. Generalization Generalization 성능은 ImageNet-1K 성능으로 비교했습니다. ViT의 경우 Low-level information processing이 부족해 일반화 성능이 떨어졌고, Convolution layer가 많을수록 일반화 성능이 좋아졌습니다. C-C-C-C C-C-C-T C-C-T-T C-T-T-T ViT REL Capacity 예상과는 다르게 ViT이 중간 정도의 Capacity만 가졌으며, C-C-T-T / C-T-T-T가 더 Capacity가 높았는데 이는 많은 transformer block이 vision에서는 높은 Capacity를 얻는데 필수적이지 않거나, ViT Stem이 너무 많은 정보를 잃어버림을 의미한다고 해석할 수 있습니다. C-C-T-T C-T-T-T ViT REL C-C-C-T C-C-C-C 추가적으로 C-C-T-T와 C-T-T-T 사이에서 어느 것이 더 괜찮은지 결정하기 위해 JFT로 pre training 시킨 후 fine tuning을 해서 성능 비교를 해보았는데, C-C-T-T가 더 괜찮은 성능을 보였다고 합니다. C-C-T-T가 최종적으로 성능이 제일 괜찮았기 때문에, 최종 구조는 최대한 C-C-T-T에 가깝게 결정되었습니다. 성능 평가 기존 SOTA 들과 비교했을 때 살짝 더 좋은 성능을 내는데 성공했으며, 21K pretrained를 1K로 transfer 했을 때는 더 괜찮은 성능을 보였습니다. ViT가 처음 제시되었을 때 사람들은 이제 Convolution을 통해 해결하던 많은 문제들이 ViT로 대체되지 않겠냐고 추측했었는데요, 이렇듯 Convolution과 Attention의 장점을 결합한 새로운 모델이 또 한 번 SOTA를 갈아치우면서 새로운 가능성을 열었다고 볼 수 있겠습니다. Reference 논문 : https://arxiv.org/abs/2106.04803 국문정리된 블로그 (많은 부분을 참고함.) : https://creamnuts.github.io/short%20review/coatnet/ 영문 정리된 블로그 : https://andlukyane.com/blog/paper-review-coatnet inductive bias에 대한 설명 https://velog.io/@euisuk-chung/Inductive-Bias란 https://visionhong.tistory.com/25 https://robot-vision-develop-story.tistory.com/29. (4) 이미지 분류 모델 평가 방법(★작성 중) Introduction 머신러닝에서 모델의 평가는 문제가 분류(Classification) 문제이냐, 회귀(Regression) 문제이냐에 따라 달라지게 됩니다. 각 알고리즘마다 특성에 차이가 있기 때문에 이를 반영해 모델을 정확하게 평가할 지표가 필요합니다. Classification의 성능 평가 Confusion matrix Precision - Recall F1 score Accuracy AUC , ROC curve Regression의 성능 평가 MSE Coefficientg of determination 3. Image Segmentation(이미지 분할) Image Segmentation은 입력 이미지에서 픽셀의 각 클래스를 구분하는 Task입니다. (1) 이미지 분할 아이디어 이미지 분할 바운딩 박스(Bounding box)로 검출된 물체들을 나타내는 객체 검출(Object detection) 과는 다르게 이미지 분할(Image segmentation)은 픽셀의 분류(Classification) 문제입니다. 네트워크가 입력 이미지 안의 모든 픽셀을 (지정된 개수의) 클래스로 분류하는 것을 목표로 합니다. 이미지 분할의 종류 이미지 분할은 Sementic segmentation과 Instance segmentation으로 세부적으로 나눠집니다. Semantic Segmentation은 각 Pixel이 어떤 클래스인지 구분하는 문제이고 Instance Segmentation은 더 나아가 같은 사물 안에서 서로 다른 객체(Instacne)까지 구분하는 문제라 할 수 있습니다. 아래 그림을 보시면 Segmentation의 차이가 직관적으로 이해가 되실 겁니다. 이미지 분할 네트워크는 아래의 첫 번째 이미지와 같이 각 pixel이 N 개의 클래스 중 어떤 클래스에 속하는지를 나타낸 Segmentation map을 출력합니다. (Segmentation map은 클래스의 개수와 동일하게 N 개의 채널로 구성되어 있습니다) 최종적으로는 두 번째 이미지와 같이 Segmentation map에 argmax를 통해서 아래 이미지처럼 1채널 이미지를 출력으로 내보냅니다. 이미지 분할 네트워크의 기본 구조 : 인코더 & 디코더(Encoder & Decoder) 이미지 분할에 사용되는 많은 네트워크는 이미지의 사이즈를 줄이는 Encoder-Decoder로 구성되어 있으며 이미지 분할의 핵심 아이디어는 아래와 같습니다. ① 입력 이미지의 W, H를 줄이고 채널수를 늘려 피처의 개수를 증가시킨다 ② W, H를 입력 이미지의 사이즈로 회복, 채널수는 클래스의 사이로 맞춰 Segmentation map을 생성한다 물론 입력 이미지 W, H를 보존하면서 피처를 추출하면 좋겠으나 메모리 문제로 입력 이미지의 W, H를 유지하며 피처를 추출할 수가 없습니다 위와 같이 네트워크를 구성하고 학습을 진행하면 Instance/Sementic 별 픽셀이 분할되도록 네트워크의 가중치가 학습됩니다 Reference sementic segmentation 첫걸음 cs231n : lecture 11 detection and segmentation (2) 이미지 분할 모델 이해를 위한 사전 지식 1) Down-sampling Downsampling 이란 신호처리에서 말하는 용어로 sample의 개수를 줄이는 처리 과정을 의미합니다. 딥러닝에서는 인코딩할 때 data의 개수를 줄이는 처리 과정이라고 보시면 이해하시는데 어려움이 없으실 겁니다. Pooling 이미 익숙한 개념이고 앞에서도 설명한 내용이지만, 간단하게 Pooling에 대해서 먼저 정리하고 넘어가겠습니다. 특정한 규칙(Max, Average)에 의해서 Kernel 내에서 값을 만들어 내거나 추출하는 방법입니다 대표적인 Max_pooling과 Average_pooling을 간단하게 한번 알아보겠습니다. 위 이미지와 같이 해당 영역(kernel) 내에서 평균 혹은 최댓값을 계산하여 요약된 데이터를 만들어냅니다. 이처럼 Pooling의 방법으로 Downsampling을 하는 방법이 일반적입니다. 보통은 Average pooling보다는 Max pooling이 더 많이 사용됩니다. (Average pooling의 경우 필연적으로 발생하는 문제가 좀 있습니다, 논문, 교재에서 별도 언급이 없으면 Max pooling으로 생각하시면 됩니다) Dilated (Atrous) convolution Convolution도 Down Sampling의 한 방법으로 사용할 수 있습니다. 하지만 앞서 설명드린 Pooling 계열과는 다르게 학습과정을 거치므로 보다 효과적으로 down sampling 할 수 있습니다. 하지만 receptive field를 크게 하기가 어렵다는 단점이 있습니다. receptive field를 크게 하면 trainable parameter가 무수히 늘어나기 때문입니다. 이와 같은 단점을 보완하기 위해서 고안해낸 방법이 Dilated convolution입니다. Atrous는 프랑스어로 'A trous'(구멍이 있는)에서 나온 말입니다. " Dilated (Atrous) convolution의 filter는 일반적인 convolution filter 사이에 빈 공간을 넣어서 구멍이 뚫려 있는 듯한 구조를 가집니다. Semantic Segmentation에서 높은 성능을 내기 위해서는 CNN의 마지막 feature map에 존재하는 한 픽셀이 입력값에서 어느 크기의 영역에서 커버하는지를 결정하는 receptive field가 얼마나 큰 지가 중요합니다. Atrous convolution을 수행하면 기존 convolution과 동일한 양의 파라미터와 계산량을 유지하면서도, receptive field는 커집니다. Atrous convolution을 시행할 때는 확장 비율(dilation rate, r)를 지정하여 filter 사이에 빈 공간을 얼마나 둘지를 결정합니다. Depthwise convolution 일반적인 convolution 연산을 수행하면 하나의 filter를 입력 영상의 모든 채널에 적용하고 그 출력물을 더하여 하나의 feature map을 출력합니다. 그 결과 특정 채널만의 Spatial Feature를 추출하는 것이 불가능하다는 단점이 있습니다. 아래 그림으로 설명해 보자면 input image의 R, G, B 채널 모두에 같은 filter를 적용하기에 R 채널 특이적인 spatial feature를 추출할 수 없다는 뜻입니다. 또한 이전에 언급했듯이 convolution layer가 깊어질수록 연산량이 증폭된다는 단점도 있습니다. 이런 단점을 해결하고자 제시된 것이 Depthwise convolution입니다. Depthwise convolution에서 하려고 하는 것은 각 channel마다 spatial feature를 추출하는 것이므로 각 Channel 별 filter가 존재합니다. 이러한 특징으로 인해 input channel 수와 output channel 수가 같게 됩니다. 아래 그림처럼 Depth-wise Convolution은 한 번 통과하면, 하나로 병합되지 않고, (R, G, B)가 각각 Feature Map이 됩니다. 특정 채널만의 Spatial Feature를 추출하는 것이 가능해진 모습입니다. 이제 Parameter와 연산량 측면에서 기존 convolution과 Depthwise convolution를 비교해 보겠습니다. W : input/ouput의 width H : input/ouput의 height C : input의 channel K : kernel의 크기 M : output의 channel No. of Parameters 기존 convolution에서 하나의 filter가 가지는 parameter 크기는 K x K x C가 되는 것을 쉽게 알 수 있습니다. 하나의 filter에서 나오는 output은 output channel 중 하나에 해당하니, output을 M 개의 channel로 만들어 주려면 이러한 filter의 개수가 총 M 개 있어야 합니다. 따라서 총 parameter 수는 K x K x C x M 개가 됩니다. 반면 Depthwise convolution을 시행하면 convolution filter가 가지는 parameter 크기는 K x K x C가 됩니다. 하나의 filter에서 나오는 output이 output channel 전체에 해당하므로 총 parameter 수는 K x K x C 개가 됩니다. Computational Cost 기존 convolution와 Depthwise convolution 모두 output 크기가 H x W이므로, parameter 개수 x H x W 번 연산을 해야 하나의 output 완성됩니다. Depthwise separable convolution Depthwise separable convolution은 Depthwise convolution 뒤에 1x 1 convolution을 연결한 구조입니다. Depthwise separable convolution은 기존 Convolution 필터가 Spatial dimension과 Channel dimension을 동시에 처리하던 것을 따로 분리시켜 각각 처리하는 방법으로 해석할 수 있습니다. 두 축을 분리시켜 처리를 하더라도, 최종 결괏값은 두 축 모두를 처리한 것이므로 기존 convolution이 수행하던 역할을 대체할 수 있습니다. Depthwise separable convolution은 기존 Convolution에 비해 parameter의 수와 연산량이 훨씬 적다는 장점이 있습니다. 핵심은 연산량이 높은 곳에서는 최대한 Feature Map을 적게 생성하고, 연산량이 낮은 곳에서 Feature Map의 숫자를 조절하는 것입니다. No. of Parameters 기존 convolution에서 하나의 filter가 가지는 총 parameter 수는 K x K x C x M 개입니다. Depthwise convolution을 시행하면 총 parameter 수는 K x K x C 개가 됩니다. Depthwise seperable convolution은 Depthwise convolution에 1x1x C 크기의 Convolution을 M 개 연결한 것이므로 총 parameter 수는 K x K x C + 1 x 1x C x M 개가 됩니다. Computational Cost Depthwise seperable convolution 역시 output 크기가 H x W이므로, parameter 개수 x H x W 번 연산을 해야 하나의 output 완성됩니다. (Atrous convolution, Depthwise separable convolution은 sementic segmentation 모델 중 상위 성능을 보이는 Deep lab에서 공통적으로 사용하는 방법이므로 Deep lab을 공부하시다가 다시 한번 돌아와서 공부하는 것도 도움이 되겠습니다.) Reference 완숙의 에구머니 | Deep Lab Enough is not enough | 딥러닝에서 사용되는 다양한 Convolution 기법들 Different types of Convolutions 2) Up-sampling(★작성 중) Up sampling은 Down sampling의 반대로 디코딩 시 복원하기 위해서 data의 크기를 늘리는 처리 과정이라고 생각하시면 쉽게 이해 가능합니다. Upsampling의 방법 중 대표적인 것을 설명하겠습니다. Unpooling Unpooling은 Maxpooling을 거꾸로 재현하여 주변 픽셀들을 동일한 값으로 채우거나 (Nearest Neighbor Unpooling), 0으로 채워주는 방식(Bed of NailsUnpooling)입니다. Max Unpooling Unpooling 방식에는 한 가지 문제가 있습니다. 위의 그림처럼 2X2의 Matrix로 Max pooling된 data가 있다고 해봅시다. 이를 원래 사이즈인 4X4의 Matrix로 Unpooling 하게 되면 원래 Max pooled된 값의 위치를 알 수 없습니다. 이를 개선하기 위해 Max Unpooling이라는 방법을 사용합니다. 위 그림과 같이 Max pooling할 때의 선택된 값들의 위치를 기억해 원래 자료의 동일한 위치에 Max 값을 위치시켜 Unpooling 합니다. Bilinear Interpolation ... Deconvolution 많은 문헌에서 Deconvolution과 Transposed convolution을 혼용하여 사용하지만 두 개념은 사실 다릅니다. Decovnolution은 convolution의 역연산으로 inversed matrix (역행렬) 을 이용합니다. Convolution 연산을 수식으로 나타내면 다음과 같습니다. f * i = o (f는 filter(또는 kernel), *는 convolution 연산, i는 input, o는 output) Deconvolution은 f, i, o 값을 모두 다 알고 있는 상황에서 f 역행렬 * o라는 연산을 통해 i를 알아내는 과정이라고 할 수 있습니다. Deconvolution 연산을 수식으로 나타내면 다음과 같습니다. inverse matrix of f * i = o Transposed Convolution (Backward Strided Convolution) Transposed Convolution은 기존에 알고 있던 f의 역행렬을 구하는 것이 아니라 학습을 통해 새로운 f를 구한다는 점에서 Deconvolution과 구별됩니다. Transposed convolution 연산을 수식으로 나타내면 다음과 같습니다. f' * i = o 여기서 f'는 학습을 통해 만들어낸 새로운 filter입니다. 그렇다면 이름에 "transposed(전치, 행과 열이 바뀜)"라는 단어는 왜 붙어있을까요? 이를 이해하기 위해 일반적인 convolution의 계산 과정이 실제로는 어떻게 이루어지고 있는지 확인할 필요가 있습니다. 3x3 kernel * 4x4 input = 2x2 output 을 도출하기 위해 일반적인 convolution의 matrix 연산은 아래와 같이 수행됩니다. ⓐ 3x3 kernel은 4x16 sparse matrix로 변환 ⓑ 4x4 input은 16x1 vector로 변환 ⓒ 4x1 output vector를 2x2 output으로 변환 Transposed convolution은 3x3 kernel * 2x2 input = 4x4 output을 도출하는 것이 목표이므로 아래와 같이 연산합니다. ⓐ 3x3 kernel은 16x4 sparse matrix로 변환 ⓑ 2x2 input은 4x1 vector로 변환 ⓒ16x1 output vector를 4x4 output으로 변환 그림을 자세히 보시면 transposed convolution 할 때 가중치 w의 위치가 transposed 된 것을 볼 수 있습니다. 그림에서는 가중치 w의 위치만 전치되고 값은 보존된 것처럼 그려놨지만 실제로는 위치도 전치되고, 가중치의 값도 변합니다. 우리는 input, output 값을 알고 있으므로 학습을 통해 최적의 가중치 값을 찾아가게 됩니다. Transposed convolution의 구현 keras에서 transposed convolution을 구현할 때는 아래와 같이 Conv2DTranspose를 통해 구현하게 됩니다. 이때 stride 값을 어떻게 하는지에 따라 output의 크기가 달라집니다. 아래 애니메이션을 보면 왜 이런 결과가 나왔는지 이해할 수 있습니다. 파란색 feature map이 2x2 input이고, 초록색 feature map이 4x4 또는 5x5 output입니다. 일반적인 Convolution과 Transposed Convolution에서 stride의 의미가 반대입니다. - 일반적인 Convolution에서 stride 2 = 한 번에 input 원소 두 칸씩 움직인다. - Transposed Convolution에서 stride 2 = 2칸 움직여야 다음 input 원소에 도달한다. transposed convolution에서 stride =1 인 경우 아래 그림처럼 작동하여 최종 output 크기는 4x4입니다. transposed convolution에서 stride =2 인 경우 아래 그림처럼 작동하여 최종 output 크기는 5x5입니다. Reference CNN에서 Pooling 이란? Pooling을 사용하는 이유, Pooling의 특징, Pooling의 효과 원논문 | A guide to convolution arithmetic for deep learning JINHYO AI Blog | CS231n의 Transposed Convolution은 Deconvolution에 가까운 Transposed Convolution이다 Loner의 학습노트 |Transpose Convolution 간단 정리 (3) 이미지 분할 모델들 이미지 분할의 대표적인 논문의 모델들을 정리했습니다. 1) FCN FCN은 이미지 분류에서 우수한 성능을 보인 CNN 기반 모델(AlexNet, VGG16, GoogLeNet)을 Semantic Segmentation Task를 수행할 수 있도록 변형시킨 모델입니다. (FCN 네트워크는 이미지 분류 문제를 먼저 트레이닝 시킨 후 모델을 튜닝해 학습하는 Transfer Learning으로 구현합니다) 이후 나온 Semantic Segmentation 방법은 대부분 FCN의 아이디어를 기반으로 했습니다. 네트워크 핵심 아이디어 이미지 분류는 이미지 내의 모든 픽셀에서 Feature를 추출(Extraction) 하고, 추출한 Feature들을 분류기(Classifier)에 넣어 입력 이미지(Total)의 Class를 예측하는 구조로 만들어져 있습니다. 이미지 분할은 이미지 분류에서 좀 더 나아가서 이미지(Total)의 Class를 예측하는 것이 아니라 이미지를 이루는 모든 픽셀들의 Class를 예측하는 문제로 생각해 볼 수 있습니다. FCN은 기존 이미지 분류에서 쓰인 네트워크를 트레인 된 상태에서(Pretrain) Feature Extraction 레이어는 그대로 재활용하여 Feature를 추출하고 FC 레이어를 버리고 1X1 Conv 그리고 Up-sampling(Transpose Convolution)로 변경하여(Fine-Tuning) 픽셀 클래스 분류와 입력 이미지와 같은 사이즈 회복을 하도록 네트워크가 구성되었습니다. 네트워크 구조 FCN의 구조는 크게 4단계로 나뉩니다. Convolution Layer를 통해 Feature 추출 1x1 Convolution Layer를 이용해 피처 맵의 채널수를 데이터 셋 객체의 개수와 동일하게 변경 (Class Presence Heat Map 추출) Up-sampling: 낮은 해상도의 Heat Map을 Upsampling(=Transposed Convolution) 한 뒤, 입력 이미지와 같은 크기의 Map 생성 최종 피처 맵과 라벨 피처 맵의 차이를 이용하여 네트워크 학습 하지만 기본 FCN 네트워크에는 큰 문제가 있습니다. VGG16에서 입력 이미지의 크기가 224x224 인 경우 5개의 convolution block을 통과하면 Feature map의 크기는 7x7이 됩니다. 마찬가지로 FCN에서도 기존 입력 이미지 (크기 H x W)가 5개의 convolution block을 통과하면 H/32 x W/32 크기의 Feature map을 얻게 됩니다. Feature map의 한 픽셀은 입력 이미지의 32 x 32 pixel를 대표하게 됩니다. 이처럼 Feature map은 낮은 해상도를 가져 입력 이미지의 위치 정보를 '대략적으로만' 가지고 있습니다. 문제는 3번 Up-sampling 과정에서 발생합니다. 입력 이미지 위치 정보를 '대략적으로' 가지고 있는 feature map을 Up-sampling 하여 얻은 segmentation map은 기존 입력 이미지와 비교했을 때 뭉뚱그려져 있고 디테일하지 못합니다. Up-sampling by Transposed convolution 뭉그러짐 문제를 해결하기 위해 먼저 드는 생각은 Down-sampling을 하지 않아 feature map이 작아지지 않도록 하는 것입니다. 그러나 Down-sampling을 통해 feature map의 사이즈를 줄이는 과정이 없다면 연산량이 급격히 늘어나 학습에 필요한 시간 및 비용이 너무 커지게 됩니다. 때문에 Down-sampling은 필수적이고 이를 해결하기 위해 효과적인 Up-sampling을 위한 방법이 여러 개 고안됩니다. (Up-sampling에 대한 자세한 설명은 여기를 참고하세요) FCN에서는 Transposed convolution을 이용하여 Up-sampling을 진행하였습니다. Skip architecture FCN의 개발자들은 좀 더 디테일한 segmentation map을 얻기 위해, Skip architecture라는 기법을 제안했습니다. 앞에서 설명과 같이 최종 피처 맵(Feature map)은 지역 정보를 '대략적으로 유지'하고 있어 이미지가 뭉개지는 것을 보완한 방법입니다. 피처 추출 단계의 피처 맵도 업 샘플링에 포함(Sum) 하여 위치 정보 손실을 막 자라는 것이 핵심 아이디어입니다. FCN 확장 모델 FCN-32s 5번의 convolution block을 통과해 1/32만큼 줄어든 5번 Feature map(5번 Feature map 크기는 7x7) 5번 Feature map이 convolution layer를 통과하여 같은 크기의 6번 Feature map을 얻음 6번 Feature map을 한 번에 32배 upsampling (H/32 x W/32 크기를 H x W 크기로) FCN-16s 4번의 convolution block을 통과해 1/16 만큼 줄어든 4번 Feature map, 4번 Feature map 크기는 14x14 6번 Feature map을 2배 upsampling (H/32 x W/32 크기를 H/16 x W/16 크기로) 한 것과 4번 Feature map을 Sum 한다.(4-1번 Feature map) 새롭게 얻은 4-1번 Feature map 을 한 번에 16배 upsampling (H/16 x W/16 크기를 H x W 크기로) FCN-8s FCN-16s과 유사한 Step이 추가됩니다. 4-1번 Feature map을 2배 upsampling(H/16 x W/16 크기를 H/8 x W/8 크기로) 한 것과 3번 Feature map을 Sum 한다.(3-1번 Feature map) 3-1번 Feature map을 한 번에 8배 upsampling (H/8 x W/8 크기를 H x W 크기로) 결과 이미지를 보면 위치 정보가 더 잘 전달되어 FCN-32s → FCN-16s → FCN-8s 순서로 더 정교해졌음을 알 수 있습니다. 네트워크 트레이닝 이미지 분할 트레이닝을 하기 위한 데이터 셋은 {인력 데이터 : 이미지, 라벨 데이터 : 픽셀이 속하는 클래스}로 구성됩니다. 그리고 네트워크를 통해서 나온 출력값(Matrix)도 라벨 데이터와 같은 포맷으로 픽셀의 클래스를 값으로 갖는 피처 맵입니다. 손실 함수(Loss function)은 모든 픽셀의 크로스 엔트로피를 구하고 이를 모두 더하여 최종적으로 손실(loss)를 구합니다. (논문에서는 Multinomial logistic loss라 표기했습니다) 네트워크 장단점 및 시사점 Skip architecture 아이디어 최종적으로 나오는 피처에 local 정보를 추가하는 Skip architecture 아이디어는 파라미터의 큰 증가 없이 성능을 비약적으로 향상시켰을 뿐 아니라, 후속 연구에도 큰 영향을 미쳤습니다. "이미지 분류" 네트워크를 "이미지 분할" 네트워크에 적용 서로 다른 Task의 네트워크를 활용하여 문제를 잘 해결했습니다. 이미지 분류는 당시 엄청난 성능 향상이 이뤄지고 있는 상태였고, 이러한 베이스 모델을 수정하여 이미지 분할에 적용시켜 큰 성능 향상을 가져왔습니다. 이미지 분류 네트워크에서 추출하는 피처를 이미지 분할에 수정 없이 사용 가능하다는 점을 보여주었습니다. FC 레이어를 삭제하여 이미지 분할을 구현 가능하도록 만들었습니다 AlexNet, VGG 등 이미지 분류에 자주 쓰이는 FC 레이어를 이용하여 이미지 분할을 하는데 적합하지 않습니다. 대표적인 이유 몇 가지를 정리해 보면 다음과 같습니다. ① FC layer(Fully connected layer)를 통과하고 나면 이미지의 위치 정보가 사라지기 때문입니다. ② FC layer는 고정된 크기의 input image만 받을 수 있기 때문입니다. ③ FC layer는 파라미터 개수를 너무 많이 필요로 합니다. 위치 정보의 소실 고정된 Input image 크기 Dense layer에 가중치 개수가 고정되어 있기 때문에 바로 앞 레이어의 Feature Map의 크기도 고정되며, 연쇄적으로 각 레이어의 Feature Map 크기와 Input Image 크기 역시 고정됩니다. FC layer는 파라미터 개수를 너무 많이 필요로 한다. FC 레이어를 이용하여 픽셀마다의 클래스를 예측하게 구성하게 하거나 혹은 Class Presence Heat Map을 만들려면 파라미터터의 수가 너무 많이 증가합니다. 예를 들어 아주 작은 4X4의 피처 맵에서 2X2(=4)의 히트맵을 추출해낸다고 하면 FC 레이어로는 4X4X4개의 Weight가 필요합니다. 보통 피처 맵이 4X4보다 훨씬 크고, 또 뒤이어지는 Up-sampling을 생각하면 어마어마한 컴퓨터 성능을 필요로 하게 됩니다. 이러한 문제를 해결하기 위해, FCN 모델은 아래 그림처럼 fully connected 레이어를 1x1 convolution 레이어로 바꿨습니다. 레퍼런스 DL | Sementic segmentation FCN 논문 리뷰 — Fully Convolutional Networks for Semantic Segmentation 2-1. Fully Convolutional Networks(FCN) Time Traveler 블로그 2) SegNet SegNet은 2016년에 공개된 모델로, 도로를 달리면서 촬영한 영상(road scene)에 대해 pixel-wise semantic segmentation 하기 위해 설계된 모델입니다. 저자(Alex Kendall)의 유튜브 채널에서 실제로 road scene에 적용한 결과를 볼 수 있습니다. 도로와 보도는 일견 보기에 비슷해 보이지만 두 class 간의 경계를 잘 구분하는 것이 매우 중요합니다. (해당 모델은 자율주행에 큰 역할을 한 모델이라고 합니다. 도로와 보도를 구분하지 못하면 정말 큰 사고가 나겠죠?) 문제는 기존의 sementic segmentation 모델들의 해상도가 매우 떨어진다는 점입니다. Max pooling, sub-sampling 연산을 수행하다 보면 coarse(추상적인, 알맹이가 큰) feature map이 만들어지게 되는데, 이런 feature map으로는 픽셀 단위로 정교하게 segmentation을 할 수 없습니다. FCN에서는 이를 해결하기 위해 Skip architecture 등 다양한 해결 방법을 시도했었으나, 역시 정교하지 못했습니다. 또한 자율주행을 위해서는 실시간으로 빠르게 segmentation이 가능해야 합니다. 정확도가 높다고 하더라도 계산량이 많거나 parameter 수가 많으면 빠르게 segmentation을 할 수 없습니다. 따라서 memory 및 inference time 측면에서 효율적으로 동작할 수 있어야 합니다. 이런 문제를 해결하고자 등장한 모델이 SegNet입니다. SegNet은 Encoder - Decoder로 구성되어 있다는 특징이 있고, 해당 구조는 최근의 모델에서도 흔히 사용되고 있는 만큼 sementic segmantation 분야에 전체적으로 큰 영향을 끼친 구조로 볼 수 있습니다. 네트워크 구조 1) Encoder Network 원본 논문에서는 VGG16의 구조에서 FC layer를 뺀 13개의 layer를 사용하여 연산량을 줄였습니다. 일반적으로 encoder-decoder network에서 encoder로 CNN을 이용할 경우 FC layer를 뺍니다. Classification을 할 것이 아니라면 FC가 중요한 역할을 하지도 않는 데다가 계산량이 너무 많이 들기 때문이죠. 2) Decoder Network Decoder network는 각 encoder network에 대응하여 (mirrored) 존재합니다. Encoder의 pooling layer는 Up-sampling layer로 대체되어 있고 Up-sampling layer 뒤에는 Conv + batch norm + ReLU가 연결됩니다. Coarse feature map이 생기는 이유는 pooling 및 convolution 연산 때문에 feature map의 정보가 소실되기 때문입니다. Decoder에서 up-sampling을 할 때 Encoder의 feature map 정보를 decoder로 전달할 수 있다면 소실된 정보를 다시 찾는 것이니까 pixel 단위로 정교하게 segmentation을 할 수 있을 것입니다. Encoder의 feature map 정보를 decoder로 전달하는 가장 정확한 방법은 전체 feature map을 저장해 두었다가 Up-sampling 할 때 모두 Decoder로 전달하는 것입니다. 그러나 이 방식을 수행하기 위해서는 많은 메모리가 필요합니다. 그래서, SegNet에서는 max-pooling indices (위치 정보)만을 저장해두었다 이후 Max Unpooling을 진행합니다. (Max Unpooling에 대해서는 따로 정리해두었으니 Up-sampling 이 글을 참고하세요.) 그러면 accuracy는 아주 조금 감소하지만 memory는 크게 아낄 수 있습니다. Max Unpooling 방식으로 Up-sampling을 하면 그 외에도 아래와 같은 장점이 있습니다. 1. FCN에서는 Transposed convolution으로 upsampling을 진행했습니다. SegNet은 Transposed convolution을 사용하지 않기 때문에 학습 파라미터가 없어 전체 parameter 개수를 줄일 수 있습니다. 2. 전체 모델은 end-to-end 학습이 가능합니다. 3. 다른 encoder-decoder<NAME>에 응용될 수 있고, 변형도 가능합니다. 3) Softmax classifier Decoder의 output은 K-class softmax classifier로 들어가 최종적으로는 각 픽셀마다의 독립적인 확률 값으로 계산됩니다. 위 결과에서, 각 픽셀 별로 가장 확률이 높은 class만을 출력하면 최종 segmentation이 됩니다. SegNet의 성능 원 논문은 SegNet의 성능을 다른 architecture (FCN, DeepLab-LargeFOV, DeconvNet 등)와 비교한 결과를 제시하고 있습니다. SegNet의 성능을 2가지 scene segmentation benchmark에서 평가하였습니다. 1. Cam Vid dataset - road scene segmentation 2. SUN RGB-D dataset - indoor scene segmentation 정량적 평가 척도로 총 4가지 metric을 사용하였습니다. 1. Global accuracy (G): 데이터 셋 전체의 픽셀 수에서 올바르게 분류된 픽셀의 수 2. Class average accuracy (C): 각 클래스마다 accuracy를 계산한 뒤, 평균 낸 것 3. mIoU 4. Boundary F1 Score (BF): 2 * precision * recall / (recall + precision) Cam Vid dataset SegNet, DeconvNet이 가장 좋은 성능을 보입니다 SUN RGB-D dataset SegNet은 다른 모델들과 비교해서 G, C, mIoU, BF 모두에서 우수한 성능을 보입니다 Reference https://eremo2002.tistory.com/120 SegNet의 원리 SegNet: A Deep Convolutional Encoder-Decoder Architecture for Image Segmentation 3) U-Net 원래 UNET은 ISBI cell tracking challenge 2015 대회에서 등장한 모델입니다. 이 대회에서 사용된 데이터 셋의 특성은 다음과 같습니다. Dataset: Transmitted light microscopy images (Phase contrast and DIC) Transmitted light microscopy images: 투과 광선 현미경 검사 Phase contrast: 위상차 현미경 DIC (Differential interference contrast microscope) = 차등간섭대비 현미경 Input size: 512x512 pixel, 30개(딥러닝에 사용한 데이터가 고작 30개입니다...) 네트워크 핵심 아이디어 U-Net 네트워크는 매우 아름다운(?) 모습을 가지고 있습니다. 또한 이름도 너무 잘 지어(?) 네트워크 모양이 정말 U입니다. U-Net 네트워크의 핵심 아이디어는 3가지로 요약할 수 있습니다. 첫 번째, 인코더(Contract path)의 피처 맵을 디코더 피처 맵에 Concat 하여 위치 정보 전달 두 번째, 데이터 셋의 전처리, 변형(deformation)을 이용하여 데이터 수 증가 세 번째, 테두리(border line)를 더 잘 분할하기 위해 Weight를 추가한 손실 함수(Loss function) 네트워크 구조 UNET은 3부분으로 나누어 볼 수 있습니다. 일반적으로 Semantic Segmentation 모델들은 Down-sampling을 통해 크기가 줄어들었다가 다시 Up-sampling을 통해 크기가 늘어나는 구조를 취하는데, U-Net 논문에서는 이를 각각 Contracting Path, Expanding Path라고 부릅니다. Contracting Path: 점진적으로 넓은 범위의 이미지 픽셀을 보며 의미 정보(Context Information)을 추출 Bottle Neck: 수축 경로에서 확장 경로로 전환되는 전환 구간 Expanding Path: 의미 정보를 픽셀 위치정보와 결합(Localization) 하여 각 픽셀마다 어떤 객체에 속하는지를 구분 Skip Architecture U-Net에서도 FCN과 비슷하게 Skip Architecture를 활용하였습니다. 동일한 Level에서 나온 Feature map을 더한다는 점이 FCN의 Skip architecture와 다른 점이라고 할 수 있습니다. 다만, 그림을 자세히 보시면 Contracting Path의 Feature map이 Expanding Path의 Feature map보다 큰 것을 알 수 있습니다. 이는 Contracting Path에서 여러 번의 패딩이 없는 3×3 Convolution Layer를 지나면서 Feature map의 크기가 줄어들기 때문입니다. Contracting Path의 Feature map의 테두리 부분을 자른 후 크기를 동일하게 맞추어 두 feature map을 합쳐 줍니다. 입력 이미지(Input image)에 적용한 기법들 모델의 성능을 높이기 위해 저자들은 input image에 다양한 기법들을 적용하였습니다. ① Overlap-tile strategy & Mirroring Extrapolation ② Data Augmentation 이에 대해 하나하나 살펴보겠습니다. 실제로 의료 데이터는 크기가 천차만별이고 사이즈나 해상도가 큰 경우가 많습니다. 이런 데이터를 사용하려면 크기를 적당히 잘라서 딥러닝 모델에 제시해 주어야 합니다. 일반적인 딥러닝 모델은 sliding window가 전체 이미지 위로 조금씩 이동하여 해당 영역을 각각의 DNN에 제시합니다. 하지만 이미 사용한 영역의 일부를 다음 순서에서도 다시 훑어보기 때문에 계산량이 많아집니다. 당연히 input image 크기가 클수록 모델의 속도가 확연히 저하됩니다. UNET의 저자들은 patch 탐색 방식을 사용하여 이 같은 문제를 해결하였습니다. 위의 그림처럼 Patch 탐색은 이미지를 격자 모양으로 잘랐기 때문에 중첩되는 부분이 존재하지 않습니다. 이미 훑어본 영역은 깔끔하게 넘기고 다음 patch부터 탐색을 시작하므로 속도 면에 있어 훨씬 나은 성능을 보입니다. 그럼 다양한 크기의 input image를 어떻게 UNET 모델에 넣을 일정한 크기의 patch로 만들 수 있을까요? 또 부족한 데이터의 숫자를 어떻게 증가시킬 수 있을까요? 논문의 저자들은 데이터에 대한 이해로 이 문제를 멋지게 해결하였습니다. 우리가 예전(?)에 배운 세포 등의 데이터에는 아래 사진과 같이 반복적인 구조를 보입니다. 논문의 저자들은 컴패티션 대회의 의학 데이터에 두 가지 가정을 세웠습니다. ① 일단 작게 자르고 부족한 크기의 이미지는 테두리에 좌우대칭 패딩(Padding)을 하자. 테두리를 좌우대칭을 하는 것이 0으로 채워 넣는 제로 패딩보다 실제 삭제되지 않은 모습에 더 가까울 것이다. ② Cell들은 유사한 형상이므로 기초적인 변형들(deformation)을 주어도 실제로 있을법한 데이터가 될 것이다. 아래에서 두 가지 가정을 이용하여 논문에서 데이터 전처리와 변형을 어떻게 구현했는지 좀 더 자세하게 설명하도록 하겠습니다. (아마, 두 가지 가설이 잘 들어맞았기에 당시에 큰 격차로 SOTA의 위치를 차지했겠죠?) ① Overlap-tile strategy & Mirroring Extrapolation 데이터 전처리 UNET의 구조를 보면 388×388 크기의 Segmentation map을 얻기 위해 572×572 크기의 Input image가 필요합니다. 위 그림에서 파란색 patch를 Input image로 제시하면 노란색 영역의 Segmentation map이 출력되는 것입니다. 이미지 크기가 줄어들어 나오는 이유는 UNET에서 padding 없이 Convolution 연산을 반복적으로 수행했기 때문입니다. 이 같은 missing data 문제를 해결하기 위해 사용한 것이 mirroring extrapolation입니다. 파란색 박스의 빈 공간을 노란색 영역이 거울에 반사된 형태로 채우는 방식입니다. 물론 해당 영역을 zero pixel로 채울 수도 있었겠지만 mirroring extrapolation을 하면서 data augmentation의 효과를 줄 수 있어 좌우대칭을 해도 큰 영향이 없는 세포 등의 의학 데이터에서는 zero padding 보다 나은 방법이라고 생각합니다. ② Data Augmentation Sementic segmentation은 pixel 별로 class labeling 해주어야 해서 학습 데이터가 적은 편입니다. 게다가 ISBI cell tracking challenge 2015에서 제공한 데이터는 고작 30개입니다. UNET 저자들이 논문에서 언급한 data augmentation 방식은 총 4가지입니다. ① Shift ② Rotation ③ Gray value ④ Elastic Deformation 그중 Elastic Deformation은 Pixel이 랜덤하게 다른 방향으로 뒤틀리도록 변형하는 방식입니다. 아래 그림을 보면 elastic deformation을 해도 현실 세계에 있을 법하게 변형되는 것을 볼 수 있습니다. 저자들인 이러한 기법들을 활용하여 데이터를 증가시켰습니다. 네트워크 트레이닝 논문의 저자들은 손실 함수(Loss func)를 픽셀마다의 구한 에너지 펑션(Energy function)의 총합으로 구현하였습니다. 픽셀의 예측값(Prediction)에 SoftMax를 구하고 이 구한 값에 크로스 엔트로피(Cross Entropy)를 하였습니다. 그리고 특이하게 크로스 엔트로피에 픽셀 고유의 Weight를 곱함으로써 픽셀의 Loss 값을 계산하였습니다. 여기서 픽셀 고유의 Weight는 노드와 연결된 Weight를 의미하는 것이 아니라. 논문의 저자들이 경계선(border) 라인에 더 강한 학습을 시키기 위해서 가우시안 분포(Gaussian distribution)을 가정하고 경계선 픽셀 더 큰 Loss를 주었습니다. 모든 픽셀마다 각자의 Weight를 가지고 있고, 만약 픽셀이 경계선 픽셀일 경우 더 큰 손실 값(Loss)을 가지게 됩니다. (학습전에 경계선과 경계선 아닌 픽셀들의 Weight를 모두 구했고 이것을 weight map으로 구현하여 개발 시 사용했습니다) 이러한 경계선에 특화된 로스 펑션을 통해서 더욱 Segmentation에 최적화된 학습을 할 수 있었습니다. ※ 수식 및 자세한 내용을 알고 싶은 분은 Time Traveler 블로그에 자세히 나와 있으니 참고해 주세요. 네트워크 장점/단점/한계점 U-Net 네트워크는 FCN에서 나온 아이디어인 Skip architecture를 더욱 확장해서 사용한 모습을 보여주었습니다. 이후 개발된 화지 분리(Speech Separation) 등의 Segment를 하는 네트워크는 U-Net의 형상과 매우 유사합니다. 물론 이 논문은 제안한 네트워크 구조도 우수하지만 포인트는 부족한 데이터의 양을 극복하기 위해 고안한 전처리(Preprocessing)과 데이터 보충(Data augmentation)에 있다고 생각합니다. 물론 특정 데이터에 한정된 기법이기는 하지만, 데이터 도메인에 대한 깊은 이해를 토대로 문제 해결하는 것이 매우 인상 깊은 논문이었습니다. 레퍼런스 [논문 리뷰] - U-Net : Convolutional Networks for Biomedical Image Segmentation, MICCAI 2015 [Paper Review] U-Net: Convolutional Networks for Biomedical Image Segmentation Youtube|The right way to segment large images by applying a trained U-Net model on smaller patches Time Traveler 4) DeepLab V3+ DeepLab v1~v3+ architecture는 구글에서 제시한 모델로, 2015년부터 현재에 이르기까지 계속해서 업데이트를 하고 있는 모델입니다. DeepLab 시리즈는 여러 segmentation model 중 성능이 상위권에 포진되어 있습니다. DeepLab 시리즈의 발전은 아래와 같이 이루어졌는데, 최근 모델들은 모두 앞선 모델들을 계승하면서 조금씩 추가되는 항목이 생깁니다. 아래 개념들을 하나씩 살펴보면서 각 모델 별 차이점을 알아보겠습니다. DeepLab V1 : Atrous convolution을 처음 적용 DeepLab V2 : multi-scale context를 적용하기 위한 Atrous spatial pyramid pooling(ASPP) 제안 DeepLab V3 : 기존 ResNet 구조에 Atrous convolution을 활용 DeepLab V3+ : Depthwise separable convolution과 Atrous convolution을 결합한 Atrous separable convolution을 제안. 사용하고 있는 개념 Atrous convolution classification이나 object detection에서 사용되는 신경망들을 semantic segmentation에 이용하는 경우, 여러 번의 convolution과 pooling을 거치면서 디테일한 정보가 줄어들고 특성이 점점 추상화되는 단점이 있었습니다. FCN의 경우 이를 skip layer를 통해 해결했지만, skip layer를 사용하게 되면 receptive field가 고정되어 다양한 scale의 object에 대응하기 힘들다는 단점이 있었습니다. 이를 해결하기 위해 Deep lap V1~ V3에서는 Atrous convolution을 이용하고 있습니다. (Atrous convolution에 대해서는 따로 정리하고 있으니 Down-sampling을 읽어보세요.) Atrous convolution을 이용하면 기존 convolution과 동일한 양의 파라미터와 계산량을 유지하면서도, receptive field는 커집니다. 아래 그림을 통해 단순히 Pooling - Convolution 후 Upsampling 하는 것과 Dilated Convolution을 하는 것의 차이를 볼 수 있습니다. 전자의 경우 Pooling을 하면서 공간적 정보의 손실이 발생하는 데 이를 그대로 upsampling 하면서 해상도가 떨어지게 됩니다. 하지만 dilated convolution을 하게 되면, Receptive field를 크게 가져가면서도 Pooling 없어 정보의 손실을 최소화할 수 있어 해상도가 보다 좋은 output을 얻을 수 있습니다. Atrous Spatial Pyramid Pooling (ASPP) 여담이지만 Atrous Spatial Pyramid Pooling (ASPP)는 ResNet의 설계자인 Kaiming He의 SPPNet에서 소개되는 Spatial pyramid Pooling 기법에 영감을 받아 만들어진 것으로 보입니다. DeepLab V2에서 제안된 방법으로, feature map으로부터 확장 비율 (dilation rate, r)가 다른 Atrous convolution을 병렬로 적용한 뒤 다시 합쳐주는 방법입니다. 아래 그림처럼 확장 비율 (dilation rate, r)을 6 ~ 24까지 다양하게 변화하면서 다양한 receptive field를 볼 수 있도록 적용하였습니다. ASPP를 활용하면 다양한 크기의 feature map을 뽑아내 섞어서 활용할 수 있습니다. Receptive field가 정해져있어 작은 물체가 무시되거나 이상하게 인식되는 FCN과 비교했을 때 직관적으로 괜찮은 접근법이라는 것을 알 수 있습니다. Depthwise separable convolution (Depthwise convolution과 Depthwise separable convolution에 대해서는 따로 정리하고 있으니 Down-sampling을 읽어보세요.) Depthwise Separable convolution은 기존 Convolution 필터가 Spatial dimension과 Channel dimension을 동시에 처리하던 것을 따로 분리시켜 각각 처리하는 방법으로 해석할 수 있습니다. 두 축을 분리시켜 처리를 하더라도, 최종 결괏값은 두 축 모두를 처리한 것이므로 기존 convolution이 수행하던 역할을 대체할 수 있습니다. 그러나 기존 convolution 연산과 비교했을 때 사용하는 파라미터 수와 연산량을 획기적으로 줄일 수 있기 때문에 이런 구조를 사용하고 있습니다. Xception model Xception은 구글이 2017년에 발표한 모델로, 2015년에 ILSVRC 대회에서 2등을 한 Google의 Inception-V3 모델보다 훨씬 좋은 결과를 냈습니다. 아래 내용은 블로그 글을 가져온 것으로 자세한 내용에 대해서는 해당 글을 참고하세요. Xception의 중점 포인트: Modified Depthwise Separable Convolution Xception의 목적: 연산량과 parameter의 개수를 줄여서, 큰 이미지 인식을 고속화 시키자! 장점: VGG처럼 네트워크의 구조가 간단해서 (inception 과 달리..) 활용도가 높다! 논문에서 얘기하는 Xception의 바탕이 된 개념들 VGG16의 구조: Deep 하게 쌓아가는 구조를 따왔음 Inception Family: Conv를 할 때 몇 개의 branch로 factorize 해서 진행하는 것의 장점을 알려줬음 Depthwise Separable Convolution을 적용함 Xception의 구조는 Entry, Middle, Exit의 3개 구조로 나뉩니다. DeepLab V3+ Architecture 2018년 2월에 구글이 공개한 DeepLab V3+의 구조에 대해 알아보겠습니다. 이 모델은 앞선 모델들의 방법을 모두 계승하고 있습니다. DeepLab V3+의 특성을 정리하면 아래와 같습니다. 2가지의 인코더를 제시함. DeepLab V3를 인코더로 변형된 Xception를 인코더로 Atrous Convolution, ASPP와 Depth-wise Separable Convolution 을 적용 Skip architecture로 Encoder - Decoder가 연결되어 있음 DeepLab V3를 Encoder로 한 모델 DeepLab V3는 위와 같은 구조이고 Atrous Spatial Pyramid Pooling (ASPP)를 Encoder에 사용해 feature들을 추출합니다. DeepLab V3 encoder를 통과해서 나온 feature map은 원본 사진의 해상도보다 16배가 작습니다 (Output Stride: 16). 16으로 한 이유는 실험 결과 속도와 정확도의 좋은 trade-off point였기 때문입니다. DeepLab V3의 decoder에서는 encoder feature map을 단순히 16배 bilinear up-sample 합니다. 하지만 이러면 segmentation 해상도가 너무 떨어지는 단점이 있습니다. 따라서 DeepLab V3+에서는 이전의 FCN이나 UNET에서 사용하였던 것처럼 Skip architecture를 도입하여 Encoder와 Decoder를 연결시켜줍니다. DeepLab V3를 Encoder로 한 모델의 구조에 대해 다른 그림으로 한 번 설명해 보겠습니다. Encoder에서 나온 최종 feature map에 대해 4배 bilinear upsample을 수행합니다. Encoder 중간에서 나온 feature map (Low-Level Features)을 1x1 convolution을 적용하여 channel을 줄입니다. (2번 과정을 통해 1번과 2번 feature map이 concatenation이 가능해집니다.) 1번과 2번 feature map을 concatenate 합니다. 3x3 convolution layers를 거친 후 마지막 1x1 convolution을 거쳐 output을 뽑아냅니다. 4배 bilinear upsample을 수행하여 원래 input size로 복원된 최종 segmentated data를 출력합니다. 변형된 Xception을 Encoder로 한 모델 Xception 과 비슷하게 변형해서 사용합니다. 기존의 Xception 과 비교해서 (1) 더 깊고 (2) Max Pooling을 stride가 있는 Depthwise Separable Convolution로 바꾸었고 (3) 3x3 Depthwise Convolution 후에 Batch Normalization 과 ReLU를 더해주었습니다. DeepLab V3+의 loss function & training ImageNet의 데이터로 pre-train된 ResNet-101 또는 modified aligned Xception을 backbone network로 사용했습니다. POLY learning rate policy: 초기 learning rate=0.007로 설정하고, 아래와 같은 식을 따라 점점 learning rate을 줄여나가는 "poly" learning rate policy를 사용했습니다. Crop size: 513x513 crop image를 사용 Batch normalization: batch size = 16을 사용 DeepLab V3+의 성능 2018/02 PASCAL VOC 2012 와 Cityscapes dataset에서 State-of-art를 달성하였습니다. DeepLab Code 파이 토치를 이용해 DeepLab을 하나의 파라미터로 간단하게 구현했습니다. 다음과 같은 구조로 구현을 해보겠습니다. import numpy as np import torch from torch.nn import Conv2d from PIL import Image import matplotlib.pyplot as plt import requests from scipy.ndimage import zoom as resize 우선 필요한 라이브러리입니다. 그리고 imput으로 들어갈 이미지를 불러옵니다. url_Image = "http://raw.githubusercontent.com/jmlipman/jmlipman.github.io/master/images/kumamon.jpeg" im = Image.open(requests.get(url_Image, stream=True).raw).convert("L") plt.imshow(im, cmap="gray") plt.show() im = np.array(im) 위의 구조와 같이 두 가지의 컨볼루션을 구성해 줍니다. kernel_size = 7 dilation = 1 stride = 1 padding = 3 #Define a 2D convolutions conv_1 = Conv2d(in_channels=1, out_channels=1, kernel_size=kernel_size, dilation=dilation, padding=padding) kernel_size = 7 dilation = 2 stride = 1 padding = 6 conv_2 = Conv2d(in_channels=1, out_channels=1, kernel_size=kernel_size, dilation=dilation, padding=padding) #Use the same weights and bias conv_2.weight.data = conv_1.weight.data conv_2.bias.data = conv_1.bias.data 첫 번째 구조는 Downsampling을 해주고, Image를 Conv_1에 적용시켜준 후 Upsampling을 진행합니다. # 1) Downsampling 100x100 -> 50x50 im1 = resize(im, (0.5,0.5)).reshape(1,1,50,50) # 2) Apply the Convolution to that Image input_image = torch.Tensor(im1) output_image = conv_1(input_image).detach().numpy()[0,0] # 3) Upsample upsampled = resize(output_image, (2,2)) 두 번째 구조는 이미 만들어놓은 Conv_2에 적용시켜줍니다. im2 = im.reshape(1, 1, 100, 100) imput_image = torch.Tensor(im2) output_image = conv_2(input_image).detach().numpy()[0,0] 마지막으로 결과를 출력해 줍니다. plt.figure(figsize=(10,5)) plt.subplot(121) plt.imshow(output_image) plt.subplot(122) plt.imshow(upsampled) plt.show() Reference DeepLab V3+ 원논문:Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation Youtube DeepLab: Semantic Image Segmentation 블로그 Enough is not enough | 딥러닝에서 사용되는 다양한 Convolution 기법들 Different types of Convolutions Deep Lab ASPP(Atrous Spatial Pyramid Pooling) DeepLab V3+ 이제는 기본 모델이 된 'Xception' 이해하기 (4) 이미지 분할 모델 평가 방법(★작성 중) ... 4. Object detection(객체 검출) 컴퓨터 비전에서 가장 신기하고 재미있고 실용적인 Task라고 생각합니다. 주어진 이미지에서 각 인스턴스들의 사이즈를 박스 테두리로 예측하고 해당 인스턴스의 클래스를 예측하는 Task입니다. (1) 객체 검출 아이디어 객체 검출(object detection)은 한 이미지에서 객체와 이 객체를 둘러싸는 가장 작은 직사각형으로 정의되는 bounding box를 찾는 작업입니다. Image classification과 비교해 보자면, Image classification는 객체마다 label을 붙이는데 초점을 맞추지만, object detection에서는 label을 붙이는 것뿐 아니라, 이미지 상에서의 좌표를 출력할 수 있어야 합니다. 비슷한 개념인 Image localization과 Image classification, object detection을 비교한다면 아래와 같습니다. Image classification : 하나의 object에 대해 무엇인지를 분류함. Image localization : 하나의 object에 대해 어디에 위치하는지 파악함. Object detection : 여러 가지 물체에 대해서 위치를 파악하고, 각각이 무엇에 해당하는지를 파악함. 객체 검출의 역사 (옮겨갈 예정) 객체 검출은 Image descriptor를 기반으로 합니다. 예를 들어 '자전거'라는 객체를 탐지하려면, 자전거가 포함된 몇 장의 사진으로부터 자전거의 특정 부분을 나타낼 수 있는 descriptor를 추출할 수 있어야 합니다. 알고리즘이 이 객체를 찾을 때 목표하는 이미지에서 이 descriptor를 다시 찾으려고 할 것입니다. 이미지에서 특정 물체를 찾기 위해 일반적으로 사용되는 기법은 floating window 기법입니다. 이는, 이미지를 작은 직사각형 형태로 돌면서 검사해 가장 일치하는 descriptor를 가진 부분이 이 객체를 포함하는 부분이라고 간주합니다. 이 방법은 이미지를 회전시키거나 색이 바뀌더라도 영향을 주지 않고, 훈련 데이터가 많이 필요하지 않으며 대부분의 객체에 작동한다는 장점이 있지만 정확도가 높지 못하다는 단점이 있었습니다. 1990년대 초반부터 신경망을 사용했으나 정확도 측면에서 큰 성공을 보지는 못했고, 2010년에 들어서야 ImageNet에서 image descriptor 기법을 신경망이 뛰어넘기 시작했습니다. 1) 객체 검출 데이터 셋 소개 Image classification에서와 마찬가지로, Object detection에 쓰이는 데이터 셋은 정말 다양하게 존재합니다. 최근에는 Google, Facebook, Microsoft와 같은 기업들이 대규모 데이터 셋들을 공개하고 있고, 공개되고 있는 데이터 셋의 난이도가 올라가고 있습니다. 그중 중요하고 자주 쓰이는 것들에 대해 다뤄보겠습니다. PASCAL VOC PASCAL VOC는 2005년에서 2012년까지 진행되었던 PASCAL VOC challenge에서 쓰이던 데이터 셋입니다. 그중 PASCAL 2007과 PASCAL 2012 데이터 셋이 벤치마크 데이터 셋으로 자주 쓰입니다. VOC 데이터 셋 구조 XML format Annotation: Class Bounding box (x, y, w, h) Pose: 각각의 오브젝트의 방향성 정보 Truncated: 객체가 해당 이미지에 온전히 표현되지 못하고 잘려나갔는지 Difficult: 인식하기 어려운지 Image sets JPEG Images Segmentation class: sementic segmentation을 학습하기 위한 labeled images Segmentation object: instance segmentation을 학습하기 위한 labeled images VOC 데이터 셋 크기 이미지 개수: object detection: 총 9,963개의 주석이 달린(annotated) 이미지가 포함. 이 중에서 5,011개가 학습 데이터 segmentation: 422개의 학습 데이터 이미지당 평균 object 수: 2.4개 이미지당 평균 class 수: 1.4개 class 개수 20개 ImageNet ImageNet Large Scale Visual Recognition Challenge (ILSVRC) 대회에서 Image classification, Object detection 성능 평가 데이터 셋으로 사용되었습니다. 그중 ILSVRC 2012 데이터 셋이 자주 쓰입니다. ImageNet 데이터 셋 크기 이미지 개수: 1000k class 개수 1000개 ImageNet 데이터 셋의 단점 이미지 내 object가 큰 편임 object가 중앙에 위치 이미지당 object 수가 적음 위의 문제점 때문에 PASCAL VOC나 ImageNet이 현실세계 사진에서는 object를 잘 포착하지 못한다는 문제점이 있었습니다. 이런 문제점을 해결하기 위해 2014년 COCO 데이터 셋이 등장합니다. COCO COCO 데이터 셋 구조 JSON format Annotation: Class Bounding box (x, y, w, h) Segmentation JPEG Images COCO 데이터 셋의 장점 다양한 크기의 물체가 존재 높은 비율로 작은 물체들이 존재 Object들이 혼잡하게 존재하고, occlusion(폐색)이 많이 존재 덜 iconic 합니다. 여기서 iconic의 의미는 이미지가 특정 카테고리에 명확하게 속해있는 경우를 말합니다. 예를 들어 아래 이미지의 (a)의 이미지들은 누가 봐도 명확하게 개, 소 등의 명확하게 특정 카테고리에 속한 걸 누구나 알 수 있습니다. (b)의 이미지들은 (a)보다는 모호하지만, 특정 카테고리에 속하다고 말할 수 있습니다. 그런데 (c)의 경우 어떤 카테고리에 속하는지 분류하기가 모호합니다. 현실 세계 사진에서는 (a)나 (b)보단 (c)에 속하는 경우가 훨씬 많이 존재합니다. COCO 데이터 셋 크기 이미지 개수: 학습(training) 데이터 셋: 118,000장의 이미지 검증(validation) 데이터 셋: 5,000장의 이미지 테스트(test) 데이터 셋: 41,000장의 이미지 이미지당 평균 object 수: 8개 이미지당 평균 class 수: 3.5개 class 개수 91개 수행하는 task classification object detection semantic segmentation instance segmentation pose estimation etc Reference Object Detection 주요 데이터 세트 소개 Object Detection Dataset 리뷰 PASCAL VOC MS COCO (2) 객체 검출 모델 이해를 위한 사전 지식 ... 1) General process of object detection 서론 Object detection은 초창기 컴퓨터 비전 모델에서부터 최근의 learning-based object detector까지 오랜 세월 연구가 되어온 분야입니다. 하지만 그 process는 크게 변하지 않고 learning-based든, 고전적인 방법이든 어느 정도 정해진 방법이 있는데요. 이 문서에서는 object detection의 general flow에 대해 알아보도록 하겠습니다. 1. Specify Object Model 보통은 Object detection이 목적으로 하는 건 이 세상의 모든 물체를 다 detection 하는 것이 아닙니다. 우리가 정해주는 몇 가지 물체들에 한정되는 경우들이 많죠. Object detection의 첫 번째 단계인 Object model을 구체화하는 것은 우리가 어떤 object를 detection 할지 정하고 feature를 define 하는 단계입니다. 현재 유행 중인 NN을 베이스로 한 모델들은 사람이 뽑아낼 feature를 정해주지 않기 때문에 이 과정이 생략됩니다. (그저 어떤 object를 detection 할지만 선택하면 됩니다.) 하지만 최근에는 이러한 고전적인 방법들을 domain knowledge로 이용해 learning-based detection에서도 이용하려는 움직임이 있습니다. 이 문서에서는 이런 고전적인 방법들을 매우 가볍게 한번 다뤄보도록 하겠습니다. 사실 여기서 제시된 방법들 말고도 정말 많은 방법들이 있습니다. 이 문서에서는 유명한 고전적인 방법 몇 가지에만 포커스를 맞춰보겠습니다. 종류 1. Statistical Template in Bounding Box 이 방법에서는 object는 이미지 어딘가에 존재하고, Feature는 bounding box의 coordinate에 대해 정의됩니다. 자세한 방법은 아래에서 설명해 보겠습니다. 좋은 feature란 무엇일까요? 모름지기 좋은 feature라면, 1) 같은 object라면 비슷한 feature가 뽑혀야 할 것이고 2) 같은 object라면 주변의 환경에 구애받지 않고 꾸준히 비슷하게 뽑혀야 하고 3) flat이나 edge 같은 영역이 아닌 corner 같은 주변과 차별화되는 부분을 뽑아야 하고 4) feature에 상응하는 descriptor를 달 수 있어야 합니다. 아래 이미지에서는 edge에서 밝기 변화가 일어나는 것에 따라 강력한 edge의 방향들만 뽑아서 feature로 사용합니다. 또한 feature 스스로를 descriptor로 이용합니다. 이러면 같은 이미지를 보여줬을 때, (illumination 같은 강력한 방해가 있지 않다면) 환경이 달라져도 비슷한 feature를 뽑아낼 것입니다. 또한 SIFT와 비슷한 방법을 사용하고 있기에 강력한 feature라는 것도 알 수 있고, 스스로가 descriptior이기에 descriptor도 바로 정의가 됩니다. 2. Articulated parts 사람의 얼굴이나 기계 같은 경우는 정형화된 구조가 있습니다. 이런 경우 Object는 부분 요소요소들의 configuration이 되겠지요. 이런 경우에는 이 구조를 feature로 이용할 수 있을 것입니다. 이런 구조는 현재도 feature로 이용되기도 하지만, detection 그 자체보다는 사실 역으로 pose estimation을 할 때나, graphics 쪽에서 애니메이션을 위해 아직 많이 사용하는 구조입니다. 3. Hybrid Template & body 이 구조는 2가지 모델을 합쳐서 사용하는데요, 앞서 설명했던 방법과 deformation model이라는 다른 모델을 합쳐서 자전거를 탐지하는 방법입니다. 2. Generate Hypothesis 서론 1번 단계에서 우리는 어떤 Object를 뽑을지, 그리고 뽑을 ojbect에 대한 db화를 끝낸 상태입니다. 2번 단계에서는, 우리는 Ojbect의 후보군을 뽑고 Scoring 해볼 것입니다. Sliding Window Sliding window는 Scale을 고려하면서 모든 pixel location에 대해서 일정 크기의 patch 만큼 돌아다니면서 검사하는 방법입니다. 모든 pixel location을 도는 것은 어렵지 않아 보이지만, scale을 고려하는 것은 어떻게 해야 할지 감이 잘 잡히지 않지요? 이미지의 전체 크기를 늘리고 줄이면 됩니다. 이 과정은 작은 물체든 큰 물체든 detection 하기 위해서 필요합니다. 이 과정을 통해 내가 가지고 있는 feature와 비슷한 사이즈로 candidate를 만들 수 있습니다. 이 방법에는 여러 가지 문제점이 있는데요, 앞서 제가 sliding window에서는 이미지를 늘리거나 줄이면서 크기가 다르더라도 object를 detection 한다고 말씀드렸습니다만, 이미지를 늘리게 되면 overhead가 발생할 수도 있겠죠. 이런 경우에는 그림 사이즈를 늘리기보다는, patch의 사이즈를 줄이면 됩니다. 또한 요즘에는 objectness를 추정하는 방법들이 있어서 이 영역만 가지고 candidate를 만들 수 있는 방법이 있습니다. 자세한 설명은 문서를 통해 하도록 하겠습니다. 3. Score Hypothesis Score hypothesis는 알려진 Classifier를 이용해 진행합니다. learning-based object detector라면 앞서 (2)에서 배운 Classifier 모델들을 각 패치마다 이용하여 object 별 점수를 얻을 수 있고, 고전적인 모델들은 SVM을 보통 이용했습니다. 4. Resolve Score Non-max Suppression Sliding window를 통해 각 patch 별로 scoring을 하게 되면, 사실 YOLO 등 최근의 알고리즘이라고 해도 모두 갖는 한 가지 문제가 있습니다. 이미지의 주변에 있는 patch들이 전부 높은 score를 갖게 된다는 점입니다. object 주위로 좋은 score를 갖는 bounding box가 여러 개 생기겠죠. 그중에서 제일 좋은 거 하나를 뽑기 위한 방법이 NMS입니다. 방법은 심플합니다. 이 object 주변에 존재하는 bounding box 들을 score 기준으로 sorting 해서 제일 좋은 거 하나만 남기고 제거하는 것입니다. 당연히 optimal 한 solution이라고 보기는 어렵고, Local maximum을 찾는 방법이라고 볼 수 있습니다. 자세한 과정은 추후 문서에서 서술하도록 하겠습니다. 실제 모델에서의 이해 이 모델은 2005년에 CVPR에서 제시된 보행자를 detection 하는 Dalal-Triggs detector라고 하는 모델입니다. general flow가 어떻게 적용되었는지만 가볍게 보도록 합시다. (이미 정답으로 사용할 사람에 대한 HOG feature는 존재하는 상태) 64x128의 window 사이즈로 sliding window를 통해 candidate를 뽑고 이에 따른 HOG를 계산합니다. -> step 2 HOG(histogram of gradient)는 일종의 feature입니다. 아래 (a) 번 그림이 silehouse contour를 입힌 gradient map입니다. 이 자체를 feature로 이용합니다. 이 전제 gradient map을 이용해 Histogram에 집어넣고 descriptor를 붙입니다. (SIFT와 비슷한 방법입니다.) (e)가 descriptor를 붙인 모습이고요. SVM classifier를 통해 scoring 합니다. -> step 3 NMS를 통해 overlapping detection을 제거합니다. -> step4 Reference Object Detection with Discriminatively Trained Part Based Models (Felzenszwalb et al. 2008) : http://cs.brown.edu/people/pfelzens/papers/lsvm-pami.pdf Histograms of Oriented Gradients for Human Detection (Dalal et al. 2005) : https://lear.inrialpes.fr/people/triggs/pubs/Dalal-cvpr05.pdf 2) Localization Sliding window object detection Sliding window는 (1)에서 간략하게 소개가 되었었는데요, 모든 location에 대해 scale을 고려하여 object candidate를 만드는 방법입니다. 구체적으로는 임의의 크기를 가진 patch가 pixel-wise로 이미지 전체를 순회하면서 candidate를 만들어냄과 동시에, 이미지의 크기를 늘리거나 줄이 object의 크기에 구애받지 않고 우리가 원하는 object를 찾도록 해주는 방법입니다. 앞서 말했듯 object의 사이즈가 작을 때는 이미지의 사이즈를 늘리는 건 candidate가 기하급수적으로 늘어나게 되면서 overhead를 일으킬 수 있기 때문에 wiindow size를 줄여서 시행합니다. Sliding window의 구체적인 작동법 예를 들어 우리가 차를 detection 하는 모델을 만들길 원한다면, 우리가 원하는 patch size 안에서 차를 classification 하는 CNN 모델을 한번 생각해 볼 수 있을 것입니다. sliding winodw가 만들어내는 candidate들은 patch 각각이 차인지, 아닌지 분류하고 scoring 할 수 있을 것입니다. Sliding window의 문제점 Sliding window의 가장 큰 문제점은 어마 무시한 계산량입니다. 기존의 컴퓨터 비전 분야에서는 Linear classifier를 이용했기에 그나마 합리적인 시간 안에 처리가 가능했지만 위에서 말했듯 CNN 같은 DL 기반의 classifier를 같이 활용한다고 하면 매우 많은 계산 비용이 듭니다. pixel 단위로 성능이 왔다 갔다 하는 object detection의 특성상 stride를 넓히는 것은 좋은 선택이 아닙니다. 하지만 여전히 pixel-wise로 전체 location을 다 돈다면 계산 비용이 너무 많이 들겠죠. Convolutional implementation sliding windows 그래서, 이 계산 비용이라는 문제를 해결하기 위해 사람들은 "왜 이 문제가 발생했는지"에 대해 생각을 해보는데요. 이건 Pixel-wise로 Patch를 자르는 과정 자체가 문제 아니냐!!!! 전체 이미지를 밀어 넣을 수는 없을까? 하는 고민으로 이어집니다. 일반적으로 CNN Classifier는 우리가 정해준 일정한 patch size 만큼의 이미지만 받게 되는데요. 이는 CNN 안에 포함된 FC(Fully Connected) layer 때문입니다. CNN은 앞단은 Convolution으로 이루어진 Conv net, 뒷단은 FC layer로 이루어진 Dense net이 있습니다. 문제는 Dense net이죠. 파라미터 개수가 fix 되어있기 때문에, 전체 샘플에 대해서 입력의 개수가 제한이 되게 됩니다. Convolution으로만 구성이 되면 모든 사이즈의 이미지를 다 받을 수 있다는 것을 우리는 알고 있죠. 그러면 Dense net을 Convolution 연산으로 모두 대체할 수는 없을까요? 대체할 수 있습니다. 예를 들어 마지막 Conv net이 5x5x16이었다면, padding 없이 5x5 convolution을 시켜버립니다. 그러면 1x1의 output이 생기겠죠? 이때 output이 400개가 나오도록 filter의 개수를 400개를 쓰면 됩니다. 이 뒤로도 1x1 convolution을 해서 똑같이 진행해 최종적으로 element가 4개로 이루어진 필터를 만들면 됩니다. 이 상황에서 FC는 Fully Convolutional layer라고 볼 수 있겠죠. 신기한 건, output이 조금 바뀌는데요. original patch size에 딱 맞게 넣어주면 output이 1x1x4로 딱 맞게 나오는데, original patch size보다 크게 넣어주면 좀 남습니다. 아래에서는 original patch size가 14x14인데, 16x16으로 넣어주니 2x2로 더 큰값이 남습니다. 각각 [ c b, y b, h ] 로 4개씩 달려있겠죠. 여기서 output에서 좌상단의 파란색 영역만 따라가보면요, 정확히 원본에서도 좌상단에 위치하는 것을 알 수 있는데요.(이는 나머지 영역대에서도 마찬가지입니다.) 만약에 좌 상단에 있는 output의 결과가 [1, x, x, x,]로 나왔다고 해봅시다. object가 있다는 의미이죠. 이때 우 하단의 output이 [0, x, x, x]로 나왔다면 말이죠, 이 영역은 background라는 걸 의미합니다. 그러면 두 영역이 overlapping 되는 부분은 우리가 어떻게 해석해야 할까요?(파란색 박스를 한 칸 옮겨보세요) 이건 모릅니다. 마치 stride를 2로 주고 sliding window를 하는 것과 같은 상황입니다. 앞서 말했듯 stride를 주는 것이 좋은 선택은 아니죠. 그러면 이런 남는 공간이 안 나오게 촘촘하게 만들려면 어떻게 해야 할까요? network size를 조금 수정해 주면 됩니다. 이 상황이라면 3x3으로 output이 나오도록 수정해 준다면 비는 공간 없이 모든 공간에서 값을 얻어낼 수 있습니다. Fully convolutional layer를 통해 구현하면 Overlap 되는 정보들을 빠르게 걸러낼 수 있습니다. 그림 전체가 한번 들어가면 한 번에 처리되어 나오기에 속도 면에서는 매우 빨라지겠지요. 성능 면에서는 파라미터가 매우 줄어들기 때문에 어찌 보면 양날의 검입니다. 파라미터가 많으면 복잡한 function도 approximation이 가능하죠. 파라미터 수가 줄어든다는 것은 그런 복잡한 문제는 풀기 어려워짐을 의미합니다. 데이터가 많다면 Fully connected layer로 구현하는 것이 더 좋을 수도 있을 것입니다. 그래도 만약에 파라미터 비슷하다고 가정하면 Fully convolutional layer를 통해 구현하는 것이 조금 더 장점이 있을 수 있습니다. 엄청나게 작은 object를 찾는 상황을 가정해 보죠. 그러면 일반적인 sliding window를 사용할 때는 그림 사이즈를 키우거나, patch size를 줄이거나 해야 하는데요. 어찌 되었든 그림의 resolution을 건들게 됩니다. (patch size를 줄여도 결국 classifier에 들어갈 때는 classifier의 input size 만큼 키워야 하기 때문) 하지만 Fully convolutional layer는 resolution을 건들 이유가 없죠. 또한 이렇게 구현하면 엄청나게 큰 object가 들어왔을 때 대처가 안된다는 단점이 있습니다. Selective Search sliding window 방법의 단점을 극복하기 위해 ROI (Range of Interest)를 제시하는 방법이 등장합니다. 이는 이미지에서 객체 (object)가 있을 법한 영역을 제시하고 이 영역에 대해서만 classification 하는 모듈입니다. ROI를 찾아내는 방법에는 여러 가지가 있는데 대표적인 것은 selective search, RPN 등이 있다. Selective Search는 Segmentation 분야에 많이 쓰이는 알고리즘이고 과정을 간략히 설명하면 아래와 같습니다. (1) 주변 pixel 간의 유사도를 평가합니다. (2) 비슷한 영역을 합쳐서 segmented area를 만듭니다. (3) 다시 해당 segmented area를 합쳐서 더 큰 segmented area를 만듭니다. (4) 2-3 과정을 반복하여 최종적으로 2000여 개의 ROI를 만듭니다. RPN (Region Proposal Network) Selective Search를 적용한 R-CNN, Fast R-CNN의 경우 Region Proposal에 굉장히 시간이 오래 걸렸습니다. 이를 개선하기 위해 새롭게 등장한 방법이 바로 RPN (Region Proposal Network)입니다. RPN을 사용한 모델은 Faster R-CNN입니다. RPN에서 주목할 것은 Anchor box라는 새로운 개념의 등장입니다. Anchor box는 bounding box가 될 후보군으로, 미리 정해둔 크기와 비율을 가집니다. 추후 학습을 통해 Bounding box가 아닐 것 같은 anchor box는 NMS (Non-maximum suppression)을 통해 후보군에서 탈락시키고, 가능성 있는 anchor box에 대해서만 Regression 하여 최종 bounding box를 찾아냅니다. 이제부터 원논문 저자들이 사용한 방식을 설명해 보겠습니다. 1. 특정 비율과 크기를 가지는 k (= 9) 개의 anchor box를 설정합니다. 2. Input image를 pre-trained CNN에 넣어 H x W x C 크기의 feature map을 뽑아냅니다. 3. feature map에 대해 3X3 filter with 1 stride and 1 padding convolution을 수행합니다. convolution 결과 H x W x C 크기의 intermediate layer가 출력됩니다. 4. intermediate layer를 받아서 1 x 1 convolution을 classification 과 Bounding box regression에 대해 각각 수행합니다. classification layer: intermediate layer의 특정 지점을 중심으로 하는 anchor box 9개를 그려보고, 이 anchor box에 object가 있는지 없는지 판별합니다. (각 anchor box를 모두 classification 해버리면 연산량이 너무 많아집니다. 네트워크를 가볍게 만들기 위해 binary classification을 수행했습니다.) 그 결과 채널 수는 2 x k(= 9)가 되고 최종 출력은 H x W x k x 2입니다. 이 값들을 적절히 reshape 해준 다음 Softmax를 적용하여 해당 anchor box에 object가 있을 확률 값을 얻습니다. Bounding box regression layer: intermediate layer의 특정 지점을 중심으로 하는 anchor box 9개를 그려봅니다. 그 결과 채널 수는 4 x k(= 9)가 되고 최종 출력은 H x W x k x 4입니다. 이 데이터는 이후에 학습을 통해 anchor box의 위치, 크기를 정밀하게 조정하여 object를 정확하게 detection 하는 bounding box를 설정합니다. 5. 이제 앞서 얻은 값들로 최종 Bounding box를 찾아야 합니다. 먼저 Non-Maximum-Suppressio을 통해서 object가 있을 확률이 높은 n 개의 Anchor box를 추려냅니다. 이후 학습을 통해 classification과 Bounding box regression을 동시에 end-to-end로 진행합니다. (학습의 자세한 내용은 Faster R-CNN에서 다루겠습니다.) Selective Search가 2000개의 RoI를 제시하는데 반해 RPN은 800개 정도의 RoI를 제시합니다. 또한 CPU에서 작동하는 Selective Search와는 달리 GPU에서 작동하므로 속도는 더더욱 빠릅니다. Unified detection 1-stage detection 중 하나인 YOLO에서 사용하는 기법입니다. 기존의 Object Dection은 1) region proposal 2) classification 이렇게 두 단계로 나누어서 진행했다면 Unified detection은 한 번에 Object Detection을 수행합니다. 어떻게 그것이 가능한지 알아보겠습니다. input image를 S X S 개의 grid cell로 나눕니다. 각 grid cell마다 Bounding box prediction, box confidence score, Conditional class probability를 구합니다. Bounding box prediction (x, y, w, h): object가 있을 만한 영역에 B 개의 Bounding Box를 그리고, Bounding box의 위치 및 크기를 (x, y, w, h)로 표시합니다. box confidence score (Pc): 해당 Bounding box마다 box confidence score (Pc)를 계산합니다. box confidence score (Pc)= Pr(Object) x IoU box confidence score는 해당 grid cell에 object가 있을 확률" Pr(Object)"와 있다면 Ground truth boudning box와 예상한 bouding box가 얼마나 겹쳐지는지 평가하는 "IoU"를 곱한 값입니다. Conditional class probability (Ci): Ci은 object가 Bounding box 안에 있을 때 해당 object가 i 번째 class에 해당할 확률입니다. 위의 그림에서는 총 20개의 class로 classification 하기 때문에 C1부터 C20까지의 값을 구했습니다. (3) 최종적으로 각 grid cell에서 뽑아낸 벡터의 크기는 B*(4+1) + C 가 됩니다. 뽑아낸 벡터의 형태를 보면 YOLO는 입력 이미지를 작은 grid cell로 나누고, 각 grid cell 별로 Bounding box 예측 와 classification을 동시에 수행한다는 것을 알 수 있습니다. (위의 설명은 간소화된 설명으로 자세한 내용은 (4) 객체 검출 - YOLO에서 자세히 다루겠습니다. ) Reference 논문: Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks OverFeat:Integrated Recognition, Localization and Detection using Convolutional Networks 블로그: 갈아먹는 Object Detection Faster R-CNN Sliding window는 무엇일까? 유튜브: KoreaUniv DSBA | You Only Look Once : Unified, Real-Time Object Detection C4W3L03 3) NMS (Non-Maximum Suppression) & Anchor box 서론 앞서 1) General process of object detection에서 언급했듯, 대다수의 object detection algorithm은 object가 존재하는 위치 주변에 여러 개의 score가 높은 bounding box를 만든다는 문제점이 있습니다. 이 중 하나의 bounding box만을 선택해야 하는데, 이때 적용하는 기법이 non-max suppression입니다. 즉, Non-Maximum Suppression은 object detector가 예측한 bounding box 중에서 정확한 bounding box를 선택하도록 하는 기법입니다. optimal 한 solution 일 수는 없고 local maxima를 찾는 방법이라고 볼 수 있습니다. NMS에 대한 일반적인 내용이 궁금하시다면 여기를 참고하시고 YOLO에서 사용된 NMS에 대해 알고 싶다면 이 블로그에 아주 자세히 설명이 나와있습니다. 일반적인 NMS NMS의 과정 모든 Bounding box는 자신이 해당 객체를 얼마나 잘 잡아내지 나타내는 confidence score를 가집니다. 모든 bounding box에 대하여 threshold 이하의 confidence score를 가지는 Bounding Box는 제거합니다. Confidence score가 일정 수준 이하인 bounding box 들에 대해 일차적으로 필터링을 거치는 과정입니다. 남은 Bounding Box들을 Confidence score 기준 모두 내림차순 정렬합니다. 맨 앞에 있는 Bounding box 하나를 기준으로 잡고, 다른 bounding box와 IoU 값을 구합니다. IoU가 threshold 이상인 Bounding box들은 제거합니다. Bounding box끼리 IoU가 높을수록, 즉 많이 겹쳐질수록 같은 물체를 검출하고 있다고 판단하기 때문입니다. 해당 과정을 순차적으로 시행하여 모든 Bounding box를 비교하고 제거합니다. Confidense threshold가 높을수록, IoU threshold가 낮을수록 더 많은 bounding box가 제거됩니다. 예시 Confidence score의 threshold를 0.4라고 지정하면 Confidence score가 0.4 이하인 bounding box들은 모두 제거됩니다. 아래 그림이 그 결과입니다. Bounding box를 Confidence score 기준 내림차순 정렬합니다. 그 결과 [0.9 박스, 0.8 박스, 0.7 박스, 0.65 박스, 0.6 박스(왼쪽), 0.6 박스(오른쪽)] 이렇게 됩니다. Confidence score 0.9인 bounding box를 기준으로 잡고 뒤의 모든 박스를 비교합니다. 0.8 박스와는 겹치지 않으므로 남겨둠. 0.7 박스와 IoU가 threshold 이상이므로 이 박스는 0.9 박스와 같은 것을 가리킨다고 간주하고 제거함. 0.65 박스, 0.6 박스(왼쪽) 과는 겹치지 않으므로 남겨둠. 0.6 박스(오른쪽)와 IoU가 또 threshold 이상이므로 제거함. 이제 0.8 박스를 기준으로 뒤의 모든 박스와 비교합니다. 결과적으로 그림에서 하얀 박스가 NMS를 돌리고 남은 박스이고, 빨간 박스는 NMS 과정으로 제거된 박스입니다. YOLO에서의 Non-Max Suppression 이후 문서에서 설명될 YOLO 역시 non-max suppression을 이용하는데요, 이 경우 추가적으로 고려해야 할 점이 있고 다른 방법을 통해 이 문제를 해결하기도 합니다. 과정 모든 output prediction은 [ c b, y b, w ] 형태의 array 일 것입니다. Cell마다 c 0.6 인 박스를 버립니다. 남아있는 것 중에서 c 가 가장 큰 값을 고릅니다. 선택한 박스와 o > 0.5 인 다른 bounding 박스를 모두 제거합니다. 이 과정을 다시 반복합니다. (그다음으로 c 가 높은 박스를 고름) 예시 예를 들어 YOLO를 통해 얻어낸 bounding box가 아래와 같이 만들어졌다고 가정해 봅시다. 그러면 c 가 0.9인 bounding box가 제일 먼저 선택이 되고, 이와 겹치는 0.6, 0.7은 이 bounding box와 IoU가 눈으로 봐도 0.5는 넘을 것 같죠? 제거될 것입니다. 다시 c 를 선택하는 단계로 돌아와서 그다음으로는 왼쪽에 있는 c 가 0.8인 bounding box가 선택되고 0.7은 제거될 것입니다. NMS의 문제점과 Anchor box 하지만 이런 방법에는 문제점이 있습니다. 바로 object끼리 겹칠 때 다른 object에 대한 bounding box까지 날아갈 수 있다는 것인데요. 현실에서는 object끼리 겹치는 경우가 매우 많습니다. 이를테면 아래와 같은 상황에서 그냥 NMS를 이용한다면, 자동차에 대해서 detection을 하면 트럭 같은 경우는 detection을 못하고 날아갈 수도 있겠죠? 이 문제를 해결하기 위해 나온 방법이 Anchor box입니다. Anchor box는 탐지하려는 객체의 모양을 정해놓고 객체가 탐지되었을 때 어떤 anchor box와 유사한지 판단해서 벡터 값을 할당하는 방법입니다. 아래와 같이 Anchor box가 2개라면 vector는 원래 벡터에서 두 개를 이어붙인 것과 같이 생기게 됩니다. ( [ c b, y b, z c, 2 c, c b, y b, z c, 2 c ] ) detection을 할 때는 detection을 통해 예측한 object의 boundary box가 anchor box1에 유사한지 2에 유사한지 IoU를 비교합니다. IoU 계산 후 높은 IoU를 갖는 anchor box 자리에 할당합니다. Reference YOLO, Object Detection Network 홍러닝 | NMS(Non-Maximum Suppression) IoU(Intersection of Union), NMS(Non-Maximum Suppression) C4W3L08 (3) 객체 검출 모델들(★작성 중) 원스 테이지와 투 스테이지 모델의 차이점 설명 1) 투 스테이지 모델들 ... 1) R-CNN R-CNN R-CNN 시리즈들의 시작을 연 방법입니다. CNN을 사용하여 object detection task의 정확도와 속도를 획기적으로 향상시켰으나 초기 모델인 만큼 복잡하고, 엄청 오래 걸립니다. 네트워크 구조 1. Image Input 2. Region proposal Selective search 알고리즘을 통해 ROI를 2000여 개 정도의 Region을 뽑아내어 bounding box를 생성합니다. Selective Search 알고리즘은 Segmentation 분야에 많이 쓰이는 알고리즘이며, 객체와 주변 간의 색감(Color), 질감(Texture) 차이, 다른 물체에 애워쌓여있는지(Enclosed) 여부 등을 파악해서 다양한 전략으로 물체의 위치를 파악할 수 있도록 하는 알고리즘입니다. 아래 그림과 같이 Bounding box들을 Random 하게 많이 생성을 하고 이들을 조금씩 Merge 해나가면서 물체를 인식해나가는 방식으로 되어있습니다.  3. Warping CNN에 넣기 전에 같은 사이즈(227 x 227)로 warping 해야 합니다. bounding box 크기의 비율은 고려하지 않고 일률적으로 같은 사이즈로 만들기 때문에 이 과정에서 input image가 왜곡되고 정보가 소실되는 현상이 발생합니다. 4. CNN feature extract 3번의 과정을 통해 크기가 조절된 Bounding box를 CNN 모델에 넣습니다. 저자들은 이미지 넷 데이터(ILSVRC2012 classification)로 미리 학습된 CNN 모델을 가져온 다음 Object Detection 용 데이터 셋으로 fine tuning 하는 방식을 취했습니다. 5. Image Classification with SVM (Support Vector Machine) CNN을 통해 추출한 벡터를 가지고 각각의 클래스 별로 SVM Classifier를 학습시킵니다. (CNN Classifier를 쓰지 않고 SVM을 쓰는 이유는 그냥 CNN Classifier를 쓰는 것이 SVM을 썼을 때보다 mAP 성능이 4% 정도 낮아졌기 때문이라고 함) SVM Classification을 한 후의 2000여 개의 bounding box들은 어떤 물체일 확률 값을 갖게 됩니다. 6. Non-Maximum Suppression 2000여 개의 bounding box는 어떤 객체일 확률 값을 갖게 되었지만 이 박스를 모두 사용하지 않습니다. 동일 물체에 여러 개의 bounding box가 설정되는 경우가 있기 때문이죠. 이런 경우 Non-Maximum Suppression을 통해 객체 전체를 대상화할 수 있는 bounding box 한 개를 선택합니다. 7. Bounding box regression (BBR) Selective Search로 찾은 Bounding Box 위치가 부정확하기에 Bounding Box Regression을 시행합니다. bounding box 위치 선정을 교정하고 모델의 성능을 높이기 위한 과정이라고 생각하면 되겠습니다. Ground Truth, G 와 초기 Bounding Box, P의 위치는 중심점 좌표 (x, y)와 box의 크기 (width, height)를 결합하여 표시할 수 있습니다. P (x, y, w, h)가 input으로 들어왔을 때 이를 이동시켜 G를 잘 예측하는 것이 목표. dx, dy, exp(dw), exp(dh)를 각각 곱하여 예측치 G_hat을 만듭니다. d 함수는 P를 G_hat으로 이동시키기 위해서 필요한 이동량을 의미하며 BBR에서 학습시키는 것은 이 d 함 수입니다. t 함수는 P를 G로 이동시키기 위해서 필요한 이동량을 의미하며 d 함수와 형태는 동일합니다. loss function은 "t 함수와 d 함수의 MSE" + "L2 normalization"을 추가한 형태입니다. 단점 R-CNN은 당시에는 획기적이었지만 여러 단점이 존재했는데, 아래와 같습니다. AlexNet을 그대로 사용하기 위해 image를 강제로 변형 시켜야 합니다. warping 하는 과정에서 input 이미지가 왜곡되고 정보 손실이 발생합니다 Selective Search를 통해 뽑힌 2000개의 Region proposal 후보를 모두 CNN에 집어넣기 때문에 training / testing 시간이 오래 걸립니다. Selective Search나 SVM이 GPU에 적합한 구조가 아닙니다. Computation sharing이 일어나지 않습니다. (CNN, SVM, Bounding Box Regression 총 세 가지의 모델이 결합된 형태로 한 번에 학습이 불가능합니다. 즉, end-to-end 훈련이 불가능하다는 뜻입니다. SVM, Bounding Box Regression을 학습시켜도 Back propagation이 안 되므로 CNN은 업데이트되지 않습니다. ) Reference 객체 검출(Object Detection) 딥러닝 기술: R-CNN, Fast R-CNN, Faster R-CNN 발전 과정 핵심 요약 PR-012: Faster R-CNN : Towards Real-Time Object Detection with Region Proposal Networks 갈아먹는 머신러닝|R-CNN 실전 텐서 플로 2를 활용한 딥러닝-컴퓨터 비전 Deep Learning AI : C4W3L01~10 cs231n - Lecture 11 Detection and Segmentation R-CNN을 알아보자 2) Fast R-CNN 네트워크 구조 Fast R-CNN은 이전에 서술한 R-CNN의 단점인 1) AlexNet을 그대로 사용하기 위해 Image를 224x224 크기로 강제로 warping 시켰기 때문에 이미지 변형으로 인한 성능 손실이 존재, 2) Selective Search를 통해 뽑힌 2000개의 Image Proposal 후보를 모두 CNN 모델에 집어넣기 때문에, training, testing 시간이 매우 오래 걸림, 3) Selective Search나 SVM이 GPU를 사용하기엔 적합한 구조가 아님, 4) 뒷부분에서 수행한 Computation을 Share 하지 않음을 보완하고자 나온 방법입니다. 전체적인 구조는 아래와 같습니다. 1-1. CNN Feature extraction Input image를 미리 학습된 CNN을 통과시켜 feature map을 추출합니다. 저자들은 VGG16 모델을 변형하여 사용합니다. 1-2. Region proposal Selective Search를 통해서 찾은 각각의 RoI에 대하여 bounding box를 그립니다. 2. Region projection 1-2 과정에서 찾은 bounding box를 1-1 과정에서 찾은 feature map 위에 투영(projection) 합니다. Selective search를 통해 얻은 bounding box는 sub-sampling 과정을 거치지 않은 반면, 원본 이미지의 feature map은 sub-sampling 과정을 여러 번 거쳐 크기가 작아졌습니다. 작아진 feature map에서 bounding box에 해당하는 영역을 찾아야 하는데, 이는 bounding box의 크기와 중심 좌표를 sub sampling ratio에 맞게 변경시켜줌으로써 가능합니다. 3. RoI Pooling 추출한 RoI feature map을 max-pooling 하여 고정된 크기의 pooling map을 만듭니다. 이를 위해 ROI feature map 위에 grid를 그리고 각 셀에 대하여 max pooling을 수행합니다. RoI pooling을 이용함으로써 랜덤 한 크기를 가지는 ROI projection이 FC layer에 들어갈 수 있도록 고정된 크기를 갖게 됩니다. 4. Image Classification & Bounding Box Prediction 3번 과정을 통해 얻은 feature map을 FC layer에 통과시켜 feature vector를 얻습니다. 이 feature vector를 이용하여 classification과 bounding box prediction을 각각 수행합니다. 5. Loss function & training 4에서 발생한 발생한 classification loss & bounding box prediction loss를 이용해 back propagation 하여 전체 모델을 학습시키면 됩니다. (저자들은 layer conv layer3까지의 가중치 값은 고정하고, 이후 layer의 가중치가 학습될 수 있도록 할 때 가장 성능이 좋았다고 주장합니다) 이때, classificaiton loss와 bounding box regression loss를 적절히 엮어주어 multi-task loss를 만들면 classification & bounding box regression을 동시에 진행하는 효과를 볼 수 있습니다. 참고) - u: positive sample인 경우 1, negative sample인 경우 0으로 설정되는 index parameter입니다. - smooth L1: 저자들은 실험 과정에서 라벨 값과 지나치게 차이가 많이 나는 outlier 예측 값에 대해 L2 distance로 계산하여 적용할 경우 gradient가 explode 해버리는 현상을 관찰했다고 합니다. 이를 방지하기 위해서 smooth_L1을 추가한 것입니다. Non maximum suppression 예측한 bounding box에 대하여 Non maximum suppression을 통해 최적의 bounding box만을 출력하게 됩니다. 숫자로 보는 네트워크 구조 논문에서 저자들이 작성한 네트워크 구조를 숫자와 함께 보도록 하겠습니다. 1-1. CNN Feature extraction Input image를 VGG16의 layer 13까지 통과시켜 feature map을 추출합니다. 그 결과 14x14x512 feature map이 추출됩니다. 1-2. Region proposal Selective Search를 통해서 찾은 각각의 RoI에 대하여 bounding box를 그립니다. 약 2000여 개의 Bounding box가 생성됩니다. 2. Region projection 1-1번에서 뽑아낸 14x14x512 feature map을 기준으로 Region projection을 진행합니다. 3. RoI Pooling VGG16의 마지막 max pooling layer를 RoI pooling layer로 대체합니다. 이때 RoI pooling을 통해 출력되는 feature map은 (FC layer에 들어갈 수 있도록) 크기를 7x7x512로 설정해 줍니다. - Input : 14x14 sized 512 feature maps/bounding box, total, 2000 bounding box - Output : 7x7x512 feature maps/bounding box, total 2000 bounding box - 각 bounding box마다 7x7x512의 feature map을 flatten 한 후 fc layer에 입력하여 4096 크기의 feature vector를 얻습니다. 4-1. Image Classification 4096 크기의 feature vector를 FC layer에 입력합니다. FC layer는 K 개의 class와 배경을 포함하여 (K+1) 개를 예측할 수 있도록 (K+1) 크기의 Feature vector를 출력합니다. 2000여 개의 Bounding box가 한 번씩 FC layer를 통과하여 (K+1) 크기의 Feature vector를 1개씩 갖게 됩니다. 4-2. Bounding Box Prediction 4096 크기의 feature vector를 FC layer에 입력합니다. FC layer는 class 별로 bounding box의 좌표를 예측할 수 있도록 (K+1) x4 크기의 Feature vector를 출력합니다. 2000여 개의 Bounding box가 한 번씩 FC layer를 통과하여 (K+1) x4 크기의 Feature vector를 1개씩 갖게 됩니다. 5. training Multi-task loss를 사용하여 하나의 region proposal에 대한 Classifier와 Bounding box regressor의 loss를 반환합니다. 이후 Backpropagation을 통해 Image Classifier, Bounding box regressor, CNN을 한 번에 학습시킵니다. (다만 VGG16의 conv layer3까지의 가중치 값은 고정하고, 이후 layer의 가중치가 학습됩니다.) 장점 Fast R-CNN에는 1개의 CNN 연산만 등장합니다. 이전 R-CNN에서 CNN 연산을 2000여 번 하던 것에 비해서 연산량이 매우 감소했고 속도도 빨라졌습니다. CNN fine tuning, boundnig box regression, classification을 모두 하나의 네트워크에서 학습시키는 end-to-end 기법을 제시하였습니다. Pascal VOC 2007 데이터 셋을 대상으로 mAP 66%를 기록합니다. 단점 R-CNN보다 훨씬 빠르다고는 하지만 여전히 느립니다. 계산량을 보세요. 빠를 수가 없겠죠 Region proposal 에만 2초가 걸립니다. Reference 객체 검출(Object Detection) 딥러닝 기술: R-CNN, Fast R-CNN, Faster R-CNN 발전 과정 핵심 요약 PR-012: Faster R-CNN : Towards Real-Time Object Detection with Region Proposal Networks Herbwood | Fast R-CNN 논문 리뷰 갈아먹는 머신러닝|R-CNN 실전 텐서 플로 2를 활용한 딥러닝-컴퓨터 비전 Deep Learning AI : C4W3L01~10 cs231n - Lecture 11 Detection and Segmentation 3) Faster R-CNN 네트워크 구조 Faster R-CNN의 핵심 아이디어는 Region Proposal Network입니다. 기존 Fast R-CNN의 구조를 그대로 가져오면서 Selective Search를 제거하고 RPN을 통해서 RoI를 계산합니다. 이를 통해 RPN은 Selective Search가 2000개의 RoI를 계산하는 데 반해 800개 정도의 RoI를 계산하면서도 더 높은 정확도를 보입니다. 원본 이미지를 pre-trained된 CNN 모델에 입력하여 feature map이 추출됩니다. feature map은 RPN에 전달되어 적절한 region proposals을 산출합니다. Region proposals와 1) 과정에서 얻은 feature map을 통해 RoI pooling을 수행하여 고정된 크기의 feature map을 얻습니다. Fast R-CNN 모델에 고정된 크기의 feature map을 입력하여 Classification과 Bounding box regression을 수행합니다. 네트워크 구조 심화 1. feature extraction by pre-trained VGG-16 pre-trained된 VGG16 모델에 800x800x3 크기의 원본 이미지를 입력하여 50x50x512 크기의 feature map을 얻습니다. 2. Generate Anchors by Anchor generation layer Region proposals를 추출하기에 앞서 원본 이미지에 대하여 anchor box를 생성하는 과정이 필요합니다. 원본 이미지의 크기에 sub-sampling ratio를 곱한 만큼의 grid cell이 생성되며, 이를 기준으로 각 grid cell마다 9개의 anchor box를 생성합니다. 즉, 원본 이미지에 50x50(=800x1/16 x 800x1/16) 개의 grid cell이 생성되고, 각 grid cell마다 9개의 anchor box를 생성하므로 총 22500(=50x50x9) 개의 anchor box가 생성됩니다. 3. Class scores and Bounding box regressor by RPN RPN은 VGG16으로부터 feature map을 입력받아 anchor에 대한 class score, bounding box regressor를 반환하는 역할을 합니다. **RPN(Region Proposal Network)** RPN은 원본 이미지에서 region proposals를 추출하는 네트워크입니다. 원본 이미지에서 anchor box를 생성하면 수많은 region proposals가 만들어집니다. RPN은 region proposals에 대하여 class score를 매기고, bounding box coefficient를 출력하는 기능을 합니다. 1) 원본 이미지를 pre-trained된 VGG 모델에 입력하여 feature map을 얻습니다. 2) 위에서 얻은 feature map에 대하여 3x3 conv 연산을 적용합니다. 이때 feature map의 크기가 유지될 수 있도록 padding을 추가합니다. 3) class score를 매기기 위해서 feature map에 대하여 1x1 conv 연산을 적용합니다. 이때 출력하는 feature map의 channel 수가 2x9가 되도록 설정합니다. RPN에서는 후보 영역이 어떤 class에 해당하는지까지 구체적인 분류를 하지 않고 객체가 포함되어 있는지 만을 분류합니다. 또한 anchor box를 각 grid cell마다 9개가 되도록 설정했습니다. 따라서 channel 수는 2(object 여부) x 9(anchor box 9개)가 됩니다. 4) bounding box regressor를 얻기 위해 feature map에 대하여 1x1 conv 연산을 적용합니다. 이때 출력하는 feature map의 channel 수가 4(bounding box regressor) x9(anchor box 9개)가 되도록 설정합니다. RPN의 출력 결과는 위와 같습니다. 좌측 표는 anchor box의 종류에 따라 객체 포함 여부를 나타낸 feature map이며, 우측 표는 anchor box의 종류에 따라 bounding box regressor를 나타낸 feature map입니다. 이를 통해 8x8 grid cell마다 9개의 anchor box가 생성되어 총 576(=8x8x9) 개의 region proposals가 추출되며, feature map을 통해 각각에 대한 객체 포함 여부와 bounding box regressor를 파악할 수 있습니다. 이후 class score에 따라 상위 N 개의 region proposals만을 추출하고, Non maximum suppression을 적용하여 최적의 region proposals만을 Fast R-CNN에 전달하게 됩니다. 4. Region proposal by Proposal layer Proposal layer에서는 2) 번 과정에서 생성된 anchor boxes와 RPN에서 반환한 class scores와 bounding box regressor를 사용하여 region proposals를 추출하는 작업을 수행합니다. 먼저 Non maximum suppression을 적용하여 부적절한 객체를 제거한 후, class score 상위 N 개의 anchor box를 추출합니다. 이후 regression coefficients를 anchor box에 적용하여 anchor box가 객체의 위치를 더 잘 detect 하도록 조정합니다. 5. Select anchors for training RPN by Anchor target layer Anchor target layer의 목표는 RPN이 학습하는 데 사용할 수 있는 anchor를 선택하는 것입니다. 먼저 2) 번 과정에서 생성한 anchor box 중에서 원본 이미지의 경계를 벗어나지 않는 anchor box를 선택합니다. 그다음 positive/negative 데이터를 sampling 해줍니다. 여기 positive sample은 객체가 존재하는 foreground, negative sample은 객체가 존재하지 않는 background를 의미합니다. 전체 anchor box 중에서 1) ground truth box와 가장 큰 IoU 값을 가지는 경우 2) ground truth box와의 IoU 값이 0.7 이상인 경우에 해당하는 box를 positive sample로 선정합니다. 반면 ground truth box와의 IoU 값이 0.3 이하인 경우에는 negative sample로 선정합니다. IoU 값이 0.3~0.7인 anchor box는 무시합니다. 이러한 과정을 통해 RPN을 학습시키는데 사용할 데이터 셋을 구성하게 됩니다. 6. Select anchors for training Fast R-CNN by Proposal Target layer Proposal target layer의 목표는 proposal layer에서 나온 region proposals 중에서 Fast R-CNN 모델을 학습시키기 위한 유용한 sample을 선택하는 것입니다. 여기서 선택된 region proposals는 1) 번 과정을 통해 출력된 feature map에 RoI pooling을 수행하게 됩니다. 먼저 region proposals와 ground truth box와의 IoU를 계산하여 0.5 이상일 경우 positive, 0.1~0.5 사이일 경우 negative sample로 label 됩니다. 7. Max pooling by RoI pooling 원본 이미지를 VGG16 모델에 입력하여 얻은 feature map과 6) 과정을 통해 얻은 sample을 사용하여 RoI pooling을 수행합니다. 이를 통해 고정된 크기의 feature map이 출력됩니다. RoI pooling에 대한 자세한 설명은 Fast R-CNN 논문 리뷰를 참고하시기 바랍니다. 8. Train Fast R-CNN by Multi-task loss 나머지 과정은 Fast R-CNN 모델의 동작 순서와 동일합니다. 입력받은 feature map을 fc layer에 입력하여 4096 크기의 feature vector를 얻습니다. 이후 feature vector를 Classifier와 Bounding box regressor에 입력하여 (class의 수가 K라고 할 때) 각각 (K+1), (K+1) x 4 크기의 feature vector를 출력합니다. 출력된 결과를 사용하여 Multi-task loss를 통해 Fast R-CNN 모델을 학습시킵니다. Loss Function RPN은 앞서서 Classificaiton과 Bounding Box Regression을 수행하였는데, Loss Function은 이 두 가지 Task에서 얻은 Loss를 엮은 형태를 취하고 있습니다. 여기서 i는 하나의 앵커를 말합니다. pi는 classsification을 통해서 얻은 해당 엥커가 오브젝트일 확률을 의미합니다. ti는 bounding box regression을 통해서 얻은 박스 조정 값 벡터를 의미합니다. pi와 ti는 ground truth 라벨에 해당합니다. Classification은 log loss를 통해서 계산합니다. Regression loss의 경우 Fast R-CNN에서 소개되었던 smoothL1 함수를 사용합니다. Faster R-CNN의 장점 그동안 Selective Search를 사용하여 계산해왔던 Region Proposal 단계를 Neural Network 안으로 끌어와서 진정한 의미의 end-to-end object detection 모델을 제시하였습니다. 모든 단계를 다 합쳐서 5fps라는 빠른 속도를 내며 Pascal VOC를 기준으로 78.8%라는 성능을 냅니다. Reference Faster R-CNN 논문 참신 러닝 (Fresh-Learning) 갈아먹는 머신러닝 JinWon Lee 님의 Faster R-CNN 모델 설명 영상 약초의 숲으로 놀러 오세요 Faster R-CNN 설명 2) 원 스테이지 모델들 .... 1) YOLO V1(★작성 중) One-stage Detector의 시작을 연 YOLO V1 네트워크입니다. YOLO 계열은 글을 작성하고 있는 현재까지도 대표적인 One-Stage Detector로 자리 잡고 있으며 버전이 업데이트될수록 다른 네트워크의 장점을 흡수, 발전하여 성능이 비약적으로 향상되고 있습니다. 객체 검출 네트워크의 성능을 평가하는 큰 두 가지 지표가 있습니다. mAP로 측정하는 정확도, FPS로 측정하는 수행 시간(inference time)입니다. YOLO V1이 나왔을 당시에 정확도(mAP)는 Two-stage Detector인 Faster R-CNN보다 부족했지만 속도(FPS)에서는 매우 큰 성능 향상을 가져왔습니다. YOLO 네트워크의 구조를 순서대로 살펴보면서 어떤 포인트에서 이러한 성능 향상을 가능하게 했는지 살펴보겠습니다. Network 구조 총 24개의 convolutional layers과 2개의 fully connected layers으로 구성되어 있습니다. 학습 측면에서 네트워크를 큰 그룹으로 나누면 "Pretrain Network", "Training Network" 2그룹으로 나눌 수 있습니다. Pretrained Network Pretrained Network는 Pre-trained GoogleLeNet을 Fine-Tuning 하여 사용합니다. (물론 Reduction Layer 등 약간의 차이는 있으나, YOLO 네트워크에서 중요한 부분은 아니라고 생각합니다.) Pre-trained GoogleLeNet은 이미지 분류에 사용했던 네트워크여서 input image에 대한 공간 정보(Spatial Information)를 추출할 수 있습니다. 이런 특성 덕분에 Object detection을 하는데 사용될 수 있습니다. Training Network Pretrained GoogleNet은 이미지 분류에 사용되었던 모델이므로 Object detection을 하기 위해서 4개의 Convolutional layer와 2개의 Fully connected layer를 더해줍니다. 그리고 이 부분을 따로 학습하는 과정이 필요합니다. training network까지 거치고 나면 최종적으로 7 x 7 x 30 크기의 Prediction tensors가 출력됩니다. 이 네트워크의 Output 값을 보면 이상하게 생각될 겁니다.(제가 그랬습니다) 왜 Pretrain+Training Newtork는 488X448X3 해상도의 이미지가 들어왔는데 7X7X30 매트릭스로 객체 검출이 마무리가 될까요? (사실 마무리는 아니고 이 뒤에 Final detection 하는 과정이 추가됩니다.) 하지만 YOLO에서 Training 네트워크의 Output이 트레이닝과 매우 상관이 있고 YOLO의 철학(?)이 가장 잘 녹아있는 부분이므로 Training Network의 Output에 대한 설명을 리뷰해 보겠습니다. Unified detection 7 X 7 X 30 논문에서는 (448x448) 크기의 이미지를 CNN을 이용하여 (7x7) 크기의 feature map을 추출합니다. 앞서 Pretrain Network에서 CNN을 이용했으므로 공간 정보(Spatial Information)는 보존되고, 이것은 그리드를 나눈 것과 같이 생각할 수 있습니다. (7x7) 매트릭스의 (1,1) 번째의 행렬 값은 인풋 이미지의 (0~64, 0~64) 범위의 픽셀에서 피처가 추출된 것으로 볼 수 있습니다. Training Network는 이렇게 구역(Grid)마다 객체 탐지를 수행하여 결과를 출력합니다. 7 X 7 X 30 YOLO 이전의 Two-stage detectors는 객체의 class와 bounding box의 좌표를 리스트로 내보냈습니다. {(비행기, 100, 200, 30, 40)} 이것처럼요. YOLO는 하나의 벡터에 class와 bounding box의 좌표, 그리고 예측에 대한 confidence score 값을 한 번에 내보냅니다. 구역(Grid)마다 30차원의 값을 가지게 됩니다. 논문에서는 각 Grid마다 서로 다른 사이즈의 2개의 bounding box를 이용하였습니다. 첫 번째, 1~5차원의 값은 해당 Grid에서 첫 번째 bounding box(BB)에서 탐지가 된 객체의 bound box에 대한 정보로 채워져 있습니다. [객체가 탐지된 BB의 x좌표 중심, 객체가 탐지된 BB의 y좌표 중심, BB의 너비, BB의 높이, BB 확률]와 같이 정보를 채우게 됩니다. 두 번째, 6~10차원의 값은 첫 번째와 동일한 순서로 두 번째 BB에서 탐지된 객체의 정보가 들어갑니다. 세 번째, 11~30차원의 값은 첫 번째 BB에서 탐지된 객체의 20개 클래스에 대한 확률 값으로 채워칩니다. 논문에서 사용된 데이터 셋이 20개의 클래스로 구성된 데이터였으므로 20개의 차원을 갖습니다. Detection Procedure 이렇게 나온 Training output matrix를 최종적으로 prediction 값으로 변환하기 위한 마지막 절차입니다. 앞서 나온 각각의 차원 값에 다음과 같은 연산을 진행합니다. 위와 같이 BB의 confidence score와 class의 probability를 곱하여 BB들의 Class specific confidence score를 구합니다. 논문에서는 7X7개의 Grid 당 2개의 BB로 구성되어 있었으므로 전체 Class specific confidence score 개수는 7X7X2 = 98개의 bounding box에 대한 정보가 계산됩니다. 이제 98개의 bb의 정보들에 대해서 NMS를 수행하여 탐지된 객체의 prediction 결과만을 얻어냅니다. 네트워크 트레이닝 네트워크 성능 네트워크 장단점 Reference CURG 블로그 2) SSD (Single Shot Multibox Detector) Yolo는 정확도 측면에선 다소 제약이 있었습니다. 또한 작은 물체들은 잘 잡아내지 못한다는 문제가 있었습니다. SSD는 이러한 한계점을 극복하고자 하는 시도에서 출발하게 됩니다. SSD는 기존 R-CNN, YOLO의 구조를 교묘하게 짜깁기하여 구성되어 있습니다. 이전 모델과 다른, SSD 특징점은 Multi Scale Feature Maps for Detection, Default Boxes Generation이라고 보았습니다. 이 두 가지 요소에 집중하여 살펴 보시는 게 좋겠습니다. Network 구조 0. Default box generation 특정한 가로, 세로 비를 갖는 default box k 개를 미리 설정합니다. Default box는 YOLO의 Anchor box와 비슷한 개념으로 bounding box가 될 후보라고 생각하시면 됩니다. feature map 위에 default box를 그린 뒤 Image Classification & Default Boxes Prediction을 진행할 것입니다. 1. Image Input 300x300 크기의 input image를 입력받습니다. YOLO는 448x448 크기의 input image를 받았습니다. YOLO보다 저 해상도 데이터에서도 잘 작동함을 알 수 있습니다. 2. CNN Feature extraction pretrained된 VGG-16의 Conv5_3층까지 통과하며 Feature를 추출합니다 3. Image Classification & Default Boxes Prediction convolution layer 4_3에서 추출한 Featuer map을 이용해 default box의 위치 예측과 classification을 수행합니다. 여기서 Default box는 YOLO의 Anchor box와 비슷한 개념이라고 생각하시면 되겠습니다. default box의 수를 k, 예측하려는 class의 수를 c라고 할 때, output feature map의 channel 수는 k x (C+4)가 되도록 설계합니다. (4는 default box의 x, y, w, h에 해당합니다. Yolo와 비슷하죠?) SSD 모델은 예측하려는 class의 수가 20개이고, 배경도 class에 포함하기에 c=21입니다. 4. Multi Scale Feature Maps for Detection convolution layer 7, 8_2, 9_2, 10_2, 11_2에서 추출한 Featuer map에 대해서도 default box의 위치 예측과 classification을 수행합니다. convolution layer 4_3, 7, 8_2, 9_2, 10_2, 11_2라는 총 6개의 서로 다른 scale의 feature map을 예측에 사용합니다. YOLO V1과 네트워크 디자인을 비교해 보겠습니다. SSD는 다양한 사이즈의 Feature map 38X38, 19X19, 10X10, 5X5, 1X1에서 검출을 하는 반면에 YOLO V1에서는 단 하나 사이즈의 Feature map 7X7에서만 객체 검출을 하고 있습니다. 5. NMS(Non-maximum suppression) 여러 feature map에서 생성된 default box에 대해 NMS를 시행하여 최종 결과를 도출합니다 Default Boxes Generation SSD에서는 특정한 가로, 세로 비를 갖는 default box k 개를 미리 설정하고 각 grid cell 별로 default box를 그려본 다음 Image Classification & Default Boxes Prediction을 진행한다고 했습니다. 문제는 convolution layer 4_3, 7, 8_2, 9_2, 10_2, 11_2에서 뽑아낸 총 6개의 Feature map이 존재하는데, 각 feature map은 크기가 다르므로 grid cell도 크기도 달라진다 다르다는 것입니다. 따라서 6개의 featuer map마다 input image 대비 default box의 크기 비율 Sk을 지정해 주어야 합니다. 예를 들어 원본 이미지의 크기가 300x300이고 default box width:height가 1:1이라고 했을 때 앞쪽 Layer의 s = 0.9로 정하여 default box의 크기는 30x30 (=300x0.1 x 300 x 0.9)가 되고, 뒤쪽 Layer의 s = 0.1로 정하여 default box의 크기는 30x30 (=300x0.1 x 300 x 0.1)가 되는 것입니다. (이해가 잘 안된다면 TimeTraveler | SSD 이 글을 참고하세요) Sk의 수식적 표현 Feature Map의 개수는 m개 이고, 임의의 Smin과 Smax를 설정합니다. Sk는 Smin과 Smax 사이를 m-1개의 구간으로 나누어 등간격의 값을 가지도록 합니다. 원 논문에서는 m=6이라고 했고, 첫 번째 Feature Map에선 Input image 크기 대비 0.2 비율을 가진 작은 default box를 설정하기 위해 s_min은 0.2, 6 번째 Feature Map에서는 Input image 크기 대비 0.9 비율을 가진 큰 default box를 설정하기 위해 s_max = 0.9, 로 설정했으며 최종 Sk는 [0.2, 0.34, 0.48, 0.62, 0.76, 0.9]가 됩니다. Default box의 width/height 비율 설정 input image 대비 default box의 크기 비율 Sk을 정했다면 이제는 default box 자체의 가로, 세로 비를 지정해야 합니다. 이런 식으로 다소 복잡하게 정의가 되어있습니다. 만약 a_r = 2라면 가로 : 세로 비는 2:1이 되고, a_r = 3이라면 가로 : 세로 비는 3:1이 됩니다. SSD Network 구조를 보시면 default box 개수가 4개인 layer도 있고 6개인 layer도 있습니다. (개수를 다르게 설정한 이유에 대해 원 논문에서는 그냥 경험적으로 해봤더니 더 성능이 좋더라~라고 되어 있습니다.) Default box 4개인 경우 - a = 1, 2, 1/2를 사용하여 가로 : 세로 비가 1:1, 2:1, 1:2인 default box 3개를 만들고 - 추가적으로 S'k & a =1 값을 가지는 가로 : 세로 비가 1:1인 default box 1개를 만들어 사용합니다. Default box 6개인 경우 - a = 1, 2, 3, 1/2, 1/3를 사용하여 가로 : 세로 비가 1:1, 2:1, 3:1, 1:2, 1:3인 default box 5개를 만들고 - 추가적으로 S'k & a =1 값을 가지는 가로 : 세로 비가 1:1인 default box 1개를 만들어 사용합니다. Multi Scale Feature Maps for Detection Yolo는 Input image를 7x7 크기의 featuer map에 대해서 Object Detection을 수행하기 때문에 1개의 Bounding box가 1개의 객체만을 잡아낼 수 있고, 1개의 Bounding box 안에 작은 객체가 여러 개 있는 경우 해당 객체를 잡아내지 못하는 문제가 있었습니다. SSD는 convolution layer를 통과하면서 생성된 다수의 feature map에서 모두 Object Detection을 수행합니다. 앞쪽 layer에서는 작은 객체를 검출하고, 뒤쪽 layer에서는 큰 객체를 검출하게 되므로 YOLO의 단점을 해결할 수 있습니다. 또한 Multi Scale Feature Maps for Detection을 시행하는 경우 여러 layer에서 object detection을 시행하므로 정확도가 올라갑니다. 8x8 feature map에서 detection을 시행하는 경우와 4x4 feature map에서 detection을 시행하는 경우를 예시로 비교해 보겠습니다. 특정한 가로, 세로 비를 갖는 default box k 개를 미리 설정합니다. (default box는 R-CNN에서 사용했던 Anchor box와 비슷하다고 생각하면 됩니다.) CNN의 특성상 앞쪽 Layer는 grid cell 크기가 작고, 뒤쪽 layer는 grid cell 크기가 큽니다. 따라서 8x8 feature map의 default box는 작은 객체 (위 그림에서 고양이)를 검출하고, 4x4 feature map의 default box는 큰 객체 (위 그림에서 강아지)를 검출하게 됩니다. Select candidate default boxes by Hard Negative Mining 서로 다른 scale의 default box를 각 Feature map에 적용한 경우 총 default box의 수는 8732 (=38x38x4 + 19x19x6 + 10x10x6 + 5x5x6 + 3x3x6 + 1x1x4) 개입니다. 이 모든 default box를 학습시키기에는 효율이 떨어집니다. 이 효율을 높이기 위해 저자들은 Hard Negative Mining이라는 기법을 도입합니다. Hard Negative Mining은 사실 우리에게 굉장히 친숙한 기법입니다. 우리가 객관식 5지 선다에서 헷갈리는 문제가 생기면 어떻게 하나요? 1번이 가장 정답인 것 같고 2,3번은 알쏭달쏭하고 4,5번은 확실히 아닌 것 같다고 하면 4,5번은<NAME>고 1,2,3번 중에 고민하죠. Hard Negative Mining은 바로 그 기법에 해당합니다. 우선 default box 안에 객체가 있다고 판단한 default box를 추립니다. (원 논문에서는 ground truth와 IoU 0.5 이상인 box를 positive로, IoU 0.5 미만이면 negative로 label 합니다.) 위의 과정을 거치면 대부분의 default box들은 negative로 label 되어있습니다. (보통 이미지에서 객체보다는 배경에 해당되는 영역이 많으니까요) 이때 모든 negative labeled data를 학습에 사용하게 되면 positive와 negative 학습 데이터의 Class imbalance 문제로 이어질 수 있습니다. Hard Negative Mining을 통해 모든 negative 데이터를 학습에 사용하는 것이 아니라 confidence loss가 높은 negative 데이터만을 사용하였습니다. 즉, negative라고 label 하긴 했지만 알쏭달쏭하다고 판단했던 default box들을 추린다는 뜻입니다. negative label default box : positive label default box = 3:1 비율을 유지하여 학습에 사용합니다. (저자들은 실험적으로 이 비율이 제일 optimal 하다고 합니다.) Loss function 전체 손실 함수는 localization loss (loc)와 confidence loss (conf)의 합으로 구성됩니다. ( , , , ) 1 ( c n ( , ) α l c ( , , ) ) N : Ground truth box와 매칭된 default box의 개수, N=0이라면 Loss가 0이 됩니다. l : 예측한 box g : gt box c : confidence score(물체일 확률) α : weight term, 디폴트 값으로 α = 1을 사용 c n ( , ) − i P s x j l g ( i ^ ) ∑ ∈ e l g ( i ^ ) w e e c p = x ( i) p x ( i) l c ( , , ) ∑ ∈ o N m c, y w h i k m o h 1 ( i − j ^ ) localization loss (loc)는 l과 g을 파라미터로 가지는 Smooth L1 loss function입니다. l: 예측한 box의 (x, y, w, h) 좌표 g: ground truth box의 (x, y, w, h) 좌표 x_k_ij는 i 번째 default box와 class가 k인 j 번째 ground truth box와의 매칭 여부를 알려주는 indicator parameter로, 매칭될 경우 1, 그렇지 않을 경우 0 장점 YOLO V1보다는 FPS는 소폭 상승했습니다만 mAP는 매우 크게 상승했습니다. end-to-end 학습을 할 수 있게 구축했으며 저 해상도 이미지에서도 높은 정확도를 가집니다. YOLO와 달리 Fully Convolution Network을 사용하지 않았습니다. 이를 통해 얻는 장점을 아래와 같습니다. Fully Convolution Network를 통과하면서 디테일한 정보들이 사라지는 문제점이 있었는데 이를 해소하였습니다. Parameter 개수가 급격히 감소하여 처리 속도가 매우 빨라졌습니다. 단점 YOLO보다 개선되었다고는 하지만 여전히 작은 크기의 물체를 잘 찾아내지 못합니다. 작은 물체는 앞쪽 layer에서 생성된 Feature map을 이용하여 object detection을 수행하기 때문입니다. 앞쪽 layer를 이용하여 object detection을 수행하는 것은 Depth가 충분히 깊지 않은 CNN 모델로 Object detection을 수행하는 것과 비슷합니다. 이를 극복하기 위해 저자들은 Data Augmentation을 사용합니다. 위 그림처럼 기존 input image를 축소하고 나머지 여백에는 input image의 평균값으로 채워 넣은 새로운 data를 만듭니다. 이런 데이터들로 학습을 시키니 성능 개선이 나타났다고 합니다. Reference Youtube SSD: Single Shot MultiBox Detector 블로그 TimeTraveler | SSD 갈아먹는 머신러닝 | SSD herbwoord | SSD 평범한 개발일지 | SSD: Single Shot MultiBox Detector 3) DETR (Detection with Transformer) 지금까지 object detection 모델을 설명하기 위해서 Region proposal, Anchor box, NMS 등등 새로운 개념들이 많이 등장했습니다. 이런 개념들은 이해하기 어려운 것뿐만 아니라 실제로 구현하기 어렵고 코드가 길어진다는 단점이 있었습니다. 2020년 Facebook 팀은 이런 개념들을 적용하지 않아 네트워크 구조가 단순하면서 end-to-end 학습이 가능한 DETR (End-to-end object detection with transformers)을 공개했습니다. 논문의 abstract를 보면 아래와 같이 해당 모델을 설명하고 있습니다. 무슨 말인지 차근차근 알아보겠습니다. "DETR are a set-based global loss that forces unique predictions via bi-partite matching and a transformer encoder-decoder architecture." 네트워크 구조 DETR은 CNN Backbone + Transformer + FFN (Feed Forward Network)로 구성되어 있습니다. 매우 간단해서 PyTorch로 구현한 코드도 굉장히 짧고 깔끔합니다. CNN Backbone input image를 CNN Backbone을 통과시켜 feature map을 뽑아냅니다. 이 feature map이 transformer에 들어갈 수 있도록 처리를 해주어야 합니다. ⓐ input image 크기는 H_0 x W_0 ⓑ CNN을 통과하여 출력된 feature map은 C × H × W (ResNet50을 사용하였기 때문에 C=2048, H = H_0/32, W = W_0/32) ⓒ 1x1 convolution을 적용하여 d × H × W 형태로 바꿈 (C>d) ⓓ transformer에 들어가기 위해서는 2차원이어야 하므로, d × H × W의 3차원에서 d × HW의 2차원으로 구조를 바꿈. Transformer Encoder (파란색 박스) d × HW의 feature matrix에 Positional encoding 정보를 더한 matrix를 multi-head self-attention에 통과시킵니다. Transformer의 특성상 입력 matrix와 출력 matrix의 크기는 동일합니다. Decoder (분홍색 박스) N 개의 bounding box에 대해 N 개의 object query를 생성합니다. 초기 object query는 0으로 설정되어 있습니다. (보라색 박스) Decoder는 앞서 설명한 N 개의 object query를 입력받아 multi-head self-attention을 거쳐 가공된 N 개의 unit을 출력합니다. (노란색 박스) 이 N 개의 unit들이 Query로, 그리고 encoder의 출력 unit들이 Key와 Value로 작동하여 encoder-decoder multi-head attention을 수행합니다. (초록색 박스) 최종적으로 N 개의 unit들은 각각 FFN을 거쳐 object class와 box 정보를 출력합니다. FFN (Feed Forward Network) Transformer의 결과로 나온 N 개의 unit은 FFN을 통과하여 class와 bounding box의 크기와 위치를 동시에 예측합니다. 이때 bi-partite matching을 통해 각 bounding box가 겹치지 않도록 합니다. (이에 대한 자세한 설명은 loss function & Training에서 설명하겠습니다.) Original Transformer와 무엇이 다른가? Original Transformer("Attention is All You Need")와 DETR의 transformer 구조는 비슷하면서 약간 다릅니다. 1. Positional encoding 하는 위치가 다릅니다. CNN Backbone으로 뽑아낸 feature matrix d × HW에는 위치 정보가 소실되어 있습니다. 기존의 Transformer도 이와 같은 문제점을 해결하기 위해 Positional encoding을 더해주었죠. DETR도 마찬가지로 Positional encoding을 더해주는데 위치가 살짝 다릅니다. 2) Autoregression이 아닌 Parallel 방식으로 output을 출력합니다. 기존 Transformer는 단어 한 개씩 순차적으로 출력값을 내놓습니다. Autoregression은 현재 output 값을 출력하기 위해 이전 단계까지 출력한 output 값을 참고하는 방식입니다. 반면 DETR에서 사용한 Transformer는 Paralle 방식으로, 즉 모든 output 값을 통째로 출력하는 방식입니다. Bipartite Matching DETR은 충분히 큰 수의 Bounding box를 N 개 설정하고 이에 대해서 class와 bounding box의 크기 및 위치를 예측합니다. 아래 그림처럼 Input image 상에 2개의 object만 존재한다면 2개의 bounding box에 대해서는 class, bounding box의 크기 및 위치를 예측하고, 나머지 2개에 대해서는 no object를 출력하게 됩니다. 다만 앞서 언급했듯이 DETR은 Autoregression이 아닌 Parallel 방식으로 output을 출력하므로 N 개의 Bouding box가 동시에 출력됩니다. 즉 N 개의 bounding box가 어떤 ground-truth object를 검출하고 있는지 알 수 없다는 것입니다. 만약 그림에서 분홍색 boudning box가 1번 갈매기에 대한 bouding box였다면 loss 값이 작겠지만, 만약 2번 갈매기에 대한 bouding box였다면 loss 값이 크겠죠? 따라서 bounding box가 ground truth의 어떤 object를 검출하고 있는지 1 대 1로 매칭을 해주는 과정이 필요하며 이를 bipartite matching이라고 합니다. (Bipartite matching이 궁금하다면 여기를 참고하세요.) Loss function & Training σ: Ground truth의 object set의 순열 σ_ hat: L_match를 최소로 하는 예측 bounding box set의 순열 y: Ground truth의 object set // y_hat: 예측한 N object set c: class label // p(c): 해당 class에 속할 확률 b: bounding box의 위치와 크기 (x, y, w, h) L_match ground truth의 bounding box와 예측 bounding box가 정보가 잘 matching 되었을 때 낮은 값을 가지도록 합니다. 1-1. p(c): 해당 class로 예측한 확률. 앞에 (-)가 붙어있으므로 해당 확률이 높을수록 L_match가 작아짐 1-2. L_box: ground truth의 bounding box와 예측 bounding box 사이의 loss. 두 box가 비슷할수록 L_match가 작아짐. bounding box의 크기가 클수록 L1 loss가 커지기 때문에 아래와 같이 bounding box 간 IOU loss를 더하여 이를 보정해 줌 σ_ hat L_match를 최소로 하는 예측 bounding box 순서 σ_ hat 을 찾습니다. Hungarian loss σ_ hat를 찾았으면 bipartite matching이 완료된 것이므로 이제 Loss를 구할 수 있습니다. Loss는 아래와 같이 Hungarian loss를 계산합니다. (일반적인 object detection 모델에서 사용하는 loss와 유사합니다만 Hungarian loss가 궁금하다면 여기를 참고하세요.) 이 Loss를 최소화하는 방식으로 학습이 진행됩니다. 장점 Transformer를 object detection에 최초로 적용했습니다. COCO dataset에 대해서 Faster R-CNN baseline 급의 정확도와 런타임 성능을 보여주었습니다. End-to-End training이 가능합니다. 아주 간단명료한 구조 + 깔끔한 코드! 단점 Transformer의 특성상 학습하는데 굉장히 많은 시간이 필요합니다. small object detection 성능이 떨어집니다. Reference 원논문: End-to-end object detection with transformers 원논문의 PyTorch 구현 동빈나 | DETR: End-to-End Object Detection with Transformer JinWon Lee | End-to-End Object Detection with Transformers(DETR) 정리는 습관 | End-to-end object detection with transformers 빠르게 이해하기(DETR 리뷰) KP's blog| End-to-End Object Detection with Transformers (4) 객체 검출 모델 평가 방법 개요 객체 검출 문제에 대해서 성능을 평가하기 위해서는 다음 3가지 요소가 고려되어야 합니다. 경계 상자 정밀도(Bounding box precision) : 정확한 경계 상자 (너무 크지도, 너무 작지도 않은)를 제공하는가? 재현율(recall) : 모든 객체를 찾았는가? 클래스 정밀도(Class precision) : 객체마다 정확한 클래스를 출력했는가? 연구자들이 서로 다른 객체 탐지 모델을 비교하기 위해서는 공통의 평가 지표가 필요합니다. 특히 객체 검출에 있어서는 훈련셋으로 주어지는 데이터 자체가 사람이 임의로 경계 상자를 그린 것이기 때문에, 즉 human annotation에 의존하고 있기 때문에 이것이 반드시 진리라고 볼 수 없고 이에 따라 성능 평가를 할 때도 이런 점을 고려해야 합니다. mAP(mean Average Precision) 예를 들어 2개의 알고리즘을 비교한다고 가정해 보겠습니다. 첫 번째 알고리즘은 사람을 검출할 수 있는 검출률은 99%이지만, 1장당 10건 정도 오검출이 발생합니다. 두 번째 알고리즘은 사람을 검출할 수 있는 검출률은 50% 지만 오검출은 전혀 발생하지 않습니다. 그럼 이 상황에서 어느 알고리즘이 좋다고 말할 수 있을까요? 우리는 여기서 검출률과 오검출이 발생할 가능성 모두를 고려해서 성능을 평가해야 함을 알 수 있습니다. 정밀도와 재현율 mAP를 계산하기 위해서는 먼저 정밀도(precision)와 재현율(recall, 검출률)이 계산되어야 합니다. 일반적으로 통계학에서 정의하기로는 정밀도와 재현율을 측정하기 위해서 다음 네 가지가 정의되어야 합니다. TP (true positive) : 실제 참인 것을 참으로 예측한 수 FP (false positive) : 실제 거짓인 것을 참으로 예측한 수 FN (false negative) : 실제 참인 것을 거짓으로 예측한 수 TN (true negative) : 실제 거짓인 것을 거짓으로 예측한 수 이를 객체 검출의 문제에 대입해 본다면 이렇게 생각해 볼 수 있습니다. 실제 상황 예측 결과 Positive TP, 옳은 검출 FN, 검출되어야 할 것이 검출되지 않음 Negative FP, 틀린 검출 TN, 검출되지 말아야 할 것이 검출되지 않음 정밀도와 재현율은 다음과 같이 정의됩니다. r c s o = P P F = P l D t c i n r c l = P P F = P l G o n T u h 정밀도(precision)은 예측된 결과가 얼마나 정확한지를 나타내는 지표입니다. 참이라고 예측한 것 중에서 정답을 맞힌 것의 비율을 알 수 있습니다. 재현율(recall)은 GT(실제 참인 것들) 중에 얼마나 정답을 맞혔는지를 나타내는 지표입니다. 참이라고 예측해야 할 객체들 중에 참이라고 맞게 예측한 것의 비율을 알 수 있습니다. 예측이 실제 분류와 일치하면 FP나 FN이 없기 때문에 1에 수렴하지만, 모델이 안정적이지 못한 특징을 기반으로 예측을 한다면 FP가 늘어나 정밀도가 떨어지고 모델이 너무 엄격한 기준으로 간주한다면 FN이 많아져 recall이 낮아집니다. 정밀도 - 재현율 곡선 일반적으로 정밀도-재현율 곡선은 신뢰도 임곗값마다 모델의 정밀도와 재현율을 시각화해서 보여주는 것으로 정의합니다. 신뢰도가 낮은 예측은 유지할 필요가 없으므로, 신뢰도 임곗값 T 이하의 예측은 제거하고 고려합니다. 만약 T가 1에 가까우면, 정밀도는 높지만 재현율은 낮아집니다. : 놓치는 객체가 많아져 재현율이 낮아지고, 신뢰도가 높은 예측만 유지해 FP의 수는 떨어져 정밀도가 높아집니다. 만약 T가 0에 가까우면, 정밀도는 낮지만 재현율은 높아집니다. : 대부분의 예측을 유지해서 FN이 낮아지고, 재현율이 높아집니다. 대신 FP가 많아져 정밀도가 낮아집니다. AP와 mAP precision-recall curve로 많은 정보를 얻을 수 있지만, 숫자 하나로 신뢰도를 나타내는 것이 이해하기 편리합니다. AP(average precision)는 곡선의 아래 영역으로, 항상 0-1사이의 값을 갖습니다. mAP(mean Average Precision)은 각 클래스마다의 AP 평균에 해당합니다. 숫자가 높을수록 좋습니다. AP(Averager Precision)은 재현율(recall)을 0부터 1까지 일정 단위로 증가시키면서 계산합니다. 재현율과 정밀도는 반비례 관계이기 때문에 재현율이 증가함에 따라 정밀도가 감소하게 됩니다. 이때 각 단위마다 정밀도 값을 계산하여 평균을 구한 것이 AP입니다. 그리고 이렇게 각각의 클래스의 AP 값을 계산한 후 평균을 낸 것이 mAP입니다. IoU(Intersection over Union) 앞서 AP에 대해 설명하면서, FP와 TP가 실제 값과 예측이 일치하는 또는 일치하지 않는 개수에 따라 정의된다고 했습니다. 그럼 언제 일치하는지는 어떻게 결정할까요? 두 집합이 얼마나 겹치는지 측정하는 자카르 지표(Jaccard index)를 기본적으로 사용합니다. 이를 IoU(Intersection over Union)이라고도 부르고, 다음과 같이 정의합니다. IOU에는 기준이 되는 Threshold 값을 지정하는 것이 중요합니다. Threshold 값을 통해 TP와 FP를 구분하게 됩니다. TP : IoU >= Threshold FP : IoU < Threshold Threshold 값이 작아질수록 TP가 커지게 되어 Recall 값이 증가합니다. IoU를 나타내는 식은 다음과 같습니다. o ( , ) | ∩ | A B = A B ( A + B − A B) 이를 이미지를 통해 나타내자면 아래와 같습니다. 이를 통해 이해할 수 있는 건, IoU는 예측한 bounding box와 실제(사람이 정해준) bounding box가 겹치는 영역이 넓으면 넓을수록 높은 값을 나타낸다는 것입니다. 왜 교집합만 사용하지 않고 이런 분수로 나타내서 계산할까요? 교집합은 절대적인 수치이지 상대적이지 못합니다. 예를 들어 두 개의 큰 bounding box는 겹치는 정도는 비슷해도 훨씬 많은 픽셀이 겹치게 될 것입니다. 그래서 합집합으로 나눠 비율을 지표로 이용합니다. IoU 임곗값 Object detection 문제에서 TP와 FP를 계산할 때 bounding box가 일치하는지의 여부에 따라 참인지 거짓인지가 달라지게 됩니다. 보통은 IoU 임곗값을 기준으로 bounding box가 일치하는지, 일치하지 않는지를 결정합니다. 예를 들어 위 그림과 같은 상황이라면, 1,4,5는 정해진 truth (초록색) 과 절반 이상 겹치므로 IoU 임곗값이 0.5라면 참으로 간주되지만, 2,3은 FP로 간주됩니다. IoU의 임곗값이 높아지면 TP에 해당하는 예측은 줄고, FP에 해당하는 예측은 늘어날 것입니다. Reference Object Detection의 정의와 Metric mAP(mean Average Precision) 실전 텐서 플로 2를 활용한 컴퓨터 비전 (베냐민 플랜치, 엘리엇 안드레스) IoU gif 5. Image Captioning(이미지 캡셔닝) 모든 Task가 그렇지만 신기한 분야입니다. 이미지를 입력하면 해당 이미지를 잘 설명하는 문장을 생성해 내는 Task입니다. 컴퓨터 비전과 NLP가 합쳐진 영역으로 NLP에 대한 지식도 필요한 Task입니다. (1) 이미지 캡셔닝 아이디어 <img 이미지가 주어졌을 때 이미지의 각 물체와 상황을 판단하고 설명하는 문장이 만들어지는 것을 text generation이라고 합니다. image captioning은 이미지 내에 있는 객체에 대한 판단뿐만 아니라 객체들 간의 관계를 파악하고 자연어의 형태로 알맞게 표현하는 문제도 겸하고 있어 컴퓨터 비전과 자연어 처리의 종합적인 이해를 필요로 합니다. 이미지를 문장으로 바꾼 후 NLP 분야와 결합하여 다양하게 활용할 수 있고 비교적 용량이 큰 데이터인 이미지를 텍스트로 바꾸기 때문에 저장 공간이 획기적으로 줄어들 수 있습니다. 이미지 캡셔닝 활용 사례 이미지에 캡션을 추가해 검색의 효율성이 증가합니다. 기존에는 텍스트만으로 검색이 가능했지만 이미지를 텍스트화하여 검색이 가능하게 바꾸어 주었기 때문에 검색 효율이 더 좋아집니다. 시각 장애인이나 저시력자들에게 도움을 줄 수 있습니다. 이미지를 텍스트화한 후 TTS(Text To Speak) 기술을 이용하여 음성으로 읽어주어 앞의 상황이나 그림에 대해 설명해 줄 수 있습니다. 미술 치료 분야에서 치료사의 주관을 배제하고 이미지 캡셔닝을 이용하여 객관적으로 미술에 대한 설명을 함으로써 치료의 일관성을 부여할 수 있습니다. (참고 : https://www.earticle.net/Article/A366290) 이미지 분할 네트워크의 기본 구조 : CNN & RNN 이미지 캡셔닝에 기본 네트워크는 이미지 특징을 추출하기 위한 CNN과 문장으로 나타내기 위한 RNN 을 주로 사용합니다. ① 입력 이미지를 CNN을 통과시켜 특징들을 추출한다. ② 추출한 특징들을 RNN에 대입하여 문장을 만들 수 있도록, 이미지 데이터 셋과 이미지에 대한 캡션들을 토대로 학습시킨다. 사진과 같이 입력 이미지를 CNN을 이용해 특징을 추출하고 attention과 LSTM을 이용한 RNN 모델을 통과하여 각 특징에 맞는 단어들을 얻어내고 이미지를 설명하는 문장을 완성합니다. 이미지 캡셔닝 단계 1. CNN을 이용한 특징 추출 RGB 3채널의 인풋 데이터를 ResNet-101을 이용하여 특징을 추출합니다. 2. Attention Network를 이용하여 단어 생성 Attention Network를 통과하여 중요한 부분에 가중치를 두어 단어를 추출해 냅니다. 가중치가 높은 부분을 이용해 사진을 한 문장으로 설명할 수 있는 물체, 행위 등을 추출해 냅니다. 3. RNN을 이용하여 문장 완성 가중치를 바탕으로 추출해낸 이미지의 주요 단어들을 RNN을 통해 조합하여 문장을 완성합니다. 주요 단어들로 문장을 완성했기 때문에 배경과 같은 중요하지 않은 부분은 누락될 수 있지만 한 문장으로 간결하게 이미지를 설명해낼 수 있습니다. 전체 구조 마무리 예시 사진을 통해 나온 문장인 'a man holds a football'을 Google 검색창에 검색한 결과입니다. 이미지 캡셔닝 성공 예시 물체와 상황을 정확히 인지한 경우 한 문장으로 이미지를 잘 설명하고 있는 것을 알 수 있습니다. 어텐션을 이용하여 중요한 부분에 집중하여 사진의 특징을 정확하게 텍스트로 나타내어 주었습니다. 테니스 같은 경우 테니스 동작에 대한 학습이 이루어졌다면 더욱 정확하게 행위를 설명할 수 있었을 것입니다. 이미지 캡셔닝 실패 예시 털옷을 입은 여자 사진에서 털옷을 고양이로 인식을 하여 여자가 고양이를 들고 있다고 잘못 해석하였습니다. 또한 물구나무 선 사람을 그냥 서있다고 인식하거나, 있지도 않은 새가 있다고 하거나, 야구선수가 공을 받고 있는데 던지고 있다고 하는 등 잘못 해석하는 예시들입니다. 이러한 실패는 물체나 행위를 잘못 인지한 상황으로 어느 한 가지라도 잘못 추출하면 아예 다른 설명이 되어버릴 수 있기 때문에 상당한 정확성이 요구됩니다. Reference 원 논문 https://k.kakaocdn.net/dn 참고 블로그 [https://throwexception.tistory.com/1203] 1) 이미지 캡셔닝 데이터 셋 UIUC Pascal sentence only 1000 images to train and test models simple captions and images 25% captions do not contain verbs. 15% contain static verbs like sit, stand, wear, look etc. Flickr 8k, Flickr 30k 82,783 images in Flickr 8k, >30,000 images in Flickr 30k Images were manually selected to focus mainly on people and animals performing actions. 5 captions per image. Captions contain graded human quality scores for 5,822 captions, with scores ranging from 1 (the selected caption is unrelated to the image.) to 4 (the selected caption described the image w/o any errors) 21% contain static verbs like sit, stand, wear, look etc. MS COCO 120k train & validation images (a lot more than Pascal or Flickr) 5 captions per image. instance level segmentations labels with 91 object classes and 2.5M labelled instances Standard benchmark for image caption generation task 255,000 human judgments were collected. The judgments capture the dimensions of overall caption quality (M1-M2), correctness (M3), detailedness (M4) and saliency (M5) Abstract Scenes Dataset 1002 sets of scenes with 10 images in each Reduced variability than real word scenes Descriptions have non-visual attributes Provide segmentation labels. Reference Univ. of Toronto, Kaustav Kundu | Datasets and Metrics for Image Captioning Generation 서울대학교 대학원 컴퓨터공학부 석사논문<NAME> | 의미적으로 보강된 비지도 학습 기반의 이미지 캡셔닝 (2) 이미지 캡셔닝 모델 이해를 위한 사전 지식 1) 워드 임베딩 워드 임베딩(Word Embedding) 워드 임베딩이란 단어를 벡터로 표현하는 방법으로 단어를 밀집 표현으로 변환하는 것입니다. 단어를 밀집 벡터(dense vector)의 형태로 표현하는 방법을 워드 임베딩(word embedding)이라고 합니다. 그리고 이 밀집 벡터를 워드 임베딩 과정을 통해 나온 결과라고 하여 임베딩 벡터(embedding vector)라고도 합니다. 워드 임베딩 방법론으로는 LSA, Word2Vec, FastText, Glove 등이 있습니다. 케라스에서 제공하는 도구인 Embedding()는 앞서 언급한 방법들을 사용하지는 않지만, 단어를 랜덤 한 값을 가지는 밀집 벡터로 변환한 뒤에, 인공 신경망의 가중치를 학습하는 것과 같은 방식으로 단어 벡터를 학습하는 방법을 사용합니다. 1. 희소 표현(Sparse Representation) 단어를 표현할 때 모든 단어 개수로 벡터 차원을 설정하고, 표현하고자 하는 인덱스 값만 1로 설정하고 나머지는 0으로 표현하는 원-핫 벡터로 표현하는 방법이 희소 표현이라고 합니다. Ex) 고양이 = [ 0 0 0 0 1 0 0 0 0 0 0 0 ... 중략 ... 0] # 이때 1 뒤의 0의 수는 9995개. 이러한 희소 벡터의 문제점은 단어의 개수가 늘어나면 벡터의 차원이 한없이 커진다는 점입니다. 원-핫 벡터로 표현할 때는 갖고 있는 단어가 10,000개였다면 벡터의 차원은 10,000이어야 합니다. 심지어 그중에서 단어의 인덱스에 해당되는 부분만 1이고 나머지는 0의 값을 가져야만 했습니다. 단어 집합이 클수록 고차원의 벡터가 됩니다. 예를 들어 단어가 10,000개 있고 고양이라는 단어의 인덱스는 5였다면 원 핫 벡터는 이렇게 표현되어야 했습니다. 이러한 벡터 표현은 공간적 낭비를 불러일으킵니다. 희소 표현의 일종인 DTM과 같은 경우에도 특정 문서에 여러 단어가 다수 등장하였으나, 다른 많은 문서에서는 해당 특정 문서에 등장했던 단어들이 전부 등장하지 않는다면 역시나 행렬의 많은 값이 0이 되면서 공간적 낭비를 일으킵니다. 그뿐만 아니라, 원-핫 벡터는 단어의 의미를 담지 못한다는 단점을 갖고 있습니다. 2. 밀집 표현(Dense Representation) 밀집 표현은 벡터의 차원을 단어 집합의 크기로 상정하지 않습니다. 사용자가 설정한 값으로 모든 단어의 벡터 표현의 차원을 맞춥니다. 또한, 이 과정에서 더 이상 0과 1만 가진 값이 아니라 실숫값을 가지게 됩니다. Ex) 고양이 = [0.2 1.8 1.1 -2.1 1.1 2.8 ... 중략 ...] # 이 벡터의 차원은 128 이 경우 벡터의 차원이 조밀해졌다고 하여 밀집 벡터(dense vector)라고 합니다. Reference 딥 러닝을 이용한 자연어 처리 입문 2) Word2Vec Word2Vec 단어 간 유사도를 반영할 수 있도록 단어의 의미를 벡터화할 수 있는 방법이 필요합니다. 이를 위한 대표적인 방법이 Word2Vec입니다. Word2Vec에는 CBOW(Continuous Bag of Words)와 Skip-Gram 두 가지 방식이 있습니다. CBOW는 주변에 있는 단어들을 가지고, 중간에 있는 단어들을 예측하는 방법입니다. 반대로, Skip-Gram은 중간에 있는 단어로 주변 단어들을 예측하는 방법입니다. 메커니즘 자체는 거의 동일하기 때문에 CBOW를 이해한다면 Skip-Gram도 손쉽게 이해 가능합니다. 1. CBOW(Continuous Bag of Words) CBOW의 기본 아이디어는 주변 단어를 통해 주어진 단어를 예측하는 것입니다. 총 단어가 C 개라고 할 때 앞뒤로 C/2개의 단어를 통해 주어진 단어를 예측하는 방법입니다. 예문 : "The fat cat sat on the mat" {"The", "fat", "cat", "on", "the", "mat"}으로부터 sat을 예측하는 것은 CBOW가 하는 일입니다. 이때 예측해야 하는 단어 sat을 중심 단어(center word)라고 하고, 예측에 사용되는 단어들을 주변 단어(context word)라고 합니다. 중심 단어를 기준으로 앞뒤로 몇 개의 단어를 볼지 선택하는 범위를 윈도(Window)라고 합니다. 예를 들어 위 예문에서 중심 단어가 cat이고 Window가 2라면 "The", "fat", "on", "the" 단어를 참고합니다. 위 그림처럼 학습시킬 문장의 모든 단어들을 원-핫 인코딩 시켜줍니다. 그다음 window = m으로 설정하고 하나의 Center 단어에 대해 주변 단어의 벡터를 Input으로 넣어줍니다. 수식으로 나타내면 아래와 같습니다. CBOW 방식의 파라미터는 Input layer -> Hidden layer로 가는 weights와 Hidden layer -> Output layer로 가는 weights입니다. CBOW 신경망을 학습시켜 나온 최적의 가중치가 바로 워드 임베딩된 벡터입니다. CBOW 모델은 맥락 단어로부터 타깃 단어를 예측하는 모델이라고 했습니다. 따라서 CBOW 모델의 입력은 맥락 단어의 원-핫 벡터이고, 출력은 타깃 단어의 원-핫 벡터입니다. 아래는 CBOW 신경망 모델의 개괄적인 모습입니다. Window가 2일 때의 예이며, 입력인 맥락 단어는 fat, cat, on, the이며 출력인 타깃 단어는 sat입니다. 아래 그림에서 입출력 데이터가 모두 원-핫 벡터이며 지면 관계상 fat과 the는 생략되어 있습니다. 여기서 투사층(projection layer)의 크기는 M인데 이는 워드 임베딩 결과의 차원입니다. 아래 그림에서 M은 5입니다. 입력층(input layer)에서의 가중치 행렬 W의 크기는 V x M입니다. V는 단어의 개수이므로 위 그림에서 V = 7입니다. 따라서 가중치 행렬 W의 크기는 7 x 5입니다. 반면 출력층의 W' 행렬의 크기는 M x V, 즉 5 x 7입니다. W와 W'는 서로 다른 행렬임에 주의해야 합니다. CBOW 신경망 모델은 입력 벡터(맥락 단어)를 통해 출력 벡터(타깃 단어)를 맞추기 위해 계속해서 학습하며 이 가중치 행렬 W와 W'을 갱신합니다. 입력층의 입력 벡터와 가중치 행렬 W가 어떻게 곱해지는지 보겠습니다. 위 그림에서 맥락 단어의 원-핫 벡터를 x라 표기했습니다. 예를 들어 x_cat (cat에 대한 웟-핫 벡터)은 3번째 인덱스만 1이고 나머지는 다 0입니다. 이와 가중치 행렬 W를 곱해주면 W의 3행에 해당하는 벡터가 도출됩니다. 그저 가중치 행렬 W에서 '입력 벡터에서 1이 포함된 인덱스'에 해당하는 행을 추출하는 작업일 뿐입니다. 다시 말해, 원-핫 벡터 x에서 1의 값을 가지고 있는 인덱스를 i라 할 때, 가중치 행렬 W의 i번째 행을 가져오는 작업입니다. 뒤에서도 말하겠지만 가중치 행렬 W가 결국 우리가 구하고자 하는 워드 임베딩 결과입니다. 즉 좋은 워드 임베딩 값을 구하기 위해서는 가중치 행렬 W를 잘 학습해야 합니다. 입력인 맥락 단어가 총 4개이므로 각 입력 원-핫 벡터와 가중치 행렬 W를 곱한 벡터 v가 4개 도출될 것입니다. 이제 이 벡터들의 평균 벡터를 구해야 합니다. 구해진 모든 v 벡터 (v_fat, v_eat, v_on, v_the)를 더한 뒤 4로 나누어주면 됩니다. 4는 어떻게 나온 값일까요? 2 x (window size)입니다. 앞서 윈도 사이즈를 2로 정했기 때문에 타깃 단어 앞뒤로 2개의 맥락 단어를 입력 값으로 사용했습니다. 따라서 2 x 2 = 4이므로 4로 나누어주면 됩니다. 이제 평균 벡터 v를 구했습니다. 평균 벡터 v의 크기는 M입니다. (즉 5입니다.) 위에서 구한 평균 벡터 v를 출력층 가중치 행렬 W'와 곱합니다. 곱해서 얻어진 z 벡터의 크기는 V (즉 7)입니다. 이 벡터 z에 소프트맥스(Softmax)를 취해주면 확률 값에 해당하는 벡터 값이 구해집니다. 소프트맥스를 취해주면 모든 원소의 합이 1인 상태로 바뀌기 때문에 확률을 나타내는 것이라 보면 됩니다. 소프트맥스를 취해준 벡터와 실제 타깃 단어의 원-핫 벡터의 손실 함수(Loss function)로 cross-entropy를 사용합니다. cross-entropy에 대해 수식을 제외하고 직관적으로 설명하면 다음과 같습니다. 우리가 원하는 타깃 단어의 원-핫 벡터는 (0, 0, 0, 1, 0, 0, 0)입니다. 우리가 마지막에 소프트맥스를 취해준 벡터가 (0, 0, 0, 1, 0, 0, 0)에 가까울수록 cross-entropy 값은 0이 되고, (0, 0, 0, 1, 0, 0, 0)과 달라질수록 1에 가까운 값이 됩니다. 즉, 손실 함수로 cross-entropy를 사용한다는 것은 CBOW 신경망을 통해 최종적으로 도출한 벡터가 타깃 벡터와 최대한 똑같아지게 하라는 뜻입니다. 이런 식으로 학습을 반복하며 가중치 행렬 W와 W'를 갱신합니다. 학습이 잘 되면 W와 W'의 값은 거의 비슷하기 때문에 어떤 것을 워드 임베딩 행렬로 사용해도 됩니다. 때로는 W와 W'의 평균값을 사용합니다. 학습을 진행할수록 맥락으로부터 타깃 단어를 잘 추측하는 방향으로 가중치 행렬 W가 갱신됩니다. 그리고 이렇게 해서 얻은 분산 표현 W에는 '단어의 의미'도 잘 녹아 있습니다. 2. Skip-gram CBOW에서는 주변 단어를 통해 중심 단어를 예측했다면, Skip-gram은 중심 단어에서 주변 단어를 예측합니다. 앞서 언급한 예문에 대해서 동일하게 윈도 크기가 2일 때, 데이터 셋은 다음과 같이 구성됩니다. 신경망을 도식화해보면 다음과 같습니다. 중심 단어에 대해서 주변 단어를 예측하므로 투사층에서 벡터들의 평균을 구하는 과정은 없습니다. 여러 논문에서 성능 비교를 진행했을 때, 전반적으로 Skip-gram이 CBOW보다 성능이 좋다고 알려져 있습니다. Reference 딥 러닝을 이용한 자연어 처리 입문 귀퉁이 서재 블로그 (3) 이미지 캡셔닝 모델들 ... 1) Show and Tell 네트워크 핵심 아이디어 2015년 구글에서 공개한 "Show and Tell: A Neural Image Caption Generator"에서 공개한 NIC 모델입니다. 앞에서 소개 드린 이미지 캡셔닝 아이디어(이미지 캡셔닝의 문제를 기계번역으로 생각하겠다)의 시작이 된 논문입니다. 이미지의 임배딩을 추출하는 CNNs 네트워크로는 GoogleNet을 이용하였고 문장을 생성하는 RNNs 네트워크로는 Seq2Seq을 이용하였습니다. 이미지 캡셔닝 네트워크는 NLP 분야와 큰 연관관계가 있습니다... 저는 컴퓨터 비전보다 NLP에 더 가깝다는 생각이 듭니다. 상세 개념들을 설명드리기에는 지식도 부족하고 컴퓨터 비전의 범위를 벗어나서 부득이하게 NLP를 조금은 알고 있다는 가정하에 문서를 기술해 나가겠습니다. NLP의 설명이 필요하신 분은 위키독스의 딥러닝을 이용한 자연어 처리 입문을 강추합니다. 논문은 단순한 네트워크에 대한 설명뿐만이 아니라 이미지 캡셔닝에서 생각 봐야 할 주제를 다루고 있습니다. "평가 방법(Metric)에 대한 한계"와 "그럼에도 저자들이 설명하기 위해 이용한 여러 가지 Metric"입니다. 적절한 Metric이 없어 숫자로 정확한 성능을 표현하지는 못하나 여러 불완전한 Metric으로 측정해 보았을 때 이전 네트워크들에 비해서 매우 큰 발전을 보여준 논문입니다. 네트워크 구조 네트워크는 이미지 분류에 사용된 GoogleNet과 기계번역(Machine Translation)의 Seq2Seq 모델을 이어서 붙인 모습입니다. CNN 인코더(GoogleNet) 이미지 분류에 사용된 GoogleNet을 거의 그대로 이용하였습니다. 하지만 과 적합(Overfit)을 방지하기 위해서 ImageNet 데이터 셋을 이용하여 Pretrain 하였습니다. 마지막 FC layer를 추가하여 워드 임배딩과 같은 차원(2048→512)으로 맞추기 위해 사용하고, 그 외의 네트워크 앞 부분 Weight들은 Freezing 하였습니다. 이렇게 추출(Extraction) 된 피처(feature)들은 기존 Seq2Seq 네트워크의 Context Vector와 동일한 개념으로 이용됩니다. RNN 디코더(Seq2Seq) 이 부분도 기존 Seq2Seq의 인코더 부분을 그대로 이용하였습니다.(^^;;) 이미지 임배딩과 차원을 맞추어 Label 원핫벡터를 워드임배딩 이후 512차원이 되도록 정의해 모델을 구현했습니다. 네트워크는 기존 다른 Task의 SOTA 네트워크(이미지 분류의 GoogleNet, 기계번역의 Seq2Seq)를 이어 붙였습니다. 두 가지 네트워크를 잘 아신다면 어려움 없이 이해되실 겁니다. 네트워크 트레이닝 손실 함수(Loss function) 가중치를 업데이트하기 위한 손실 함수는 아래와 같이 정의 가능합니다. 이미지가 주어졌을 때 각 스텝에서 예측한(Prediction) 워드임배딩과 짝 지어진 Label의 워드임배딩(S, embedding word) 과의 분포(Distribution) 차이의 합을 이용하였습니다. 코드에서는 위 식에다 -1을 곱하여 유사도가 높을수록 손실 값(Loss)가 감소하도록 하여 훈련합니다. 컴퓨터 비전에서는 조금 어색한 손실함 수지만, 기계번역(Machine Translation)에는 많이 쓰는 손실함 수입니다. (추가적인 학습이 필요하신 분은 negative log likelihood 검색을 추천드립니다) 손실 함수를 이용하여 업데이트되는 가중치들은 세 가지 그룹입니다. "CNN의 최상단 레이어", "워드임배딩 벡터", "LSTM의 파라미터" (CNN 인코더의 파라미터들은 Pretrain 됩니다) 데이터 셋(Dataset) Pascal VOC2008, Flickr8k, Flickr30k, MSCOCO, SBU data를 사용했습니다. SBU를 제외하고는 모두 5개의 correct sentence 라벨이 있습니다. SBU 데이터는 Flickr라는 사이트에 이미지를 올릴 때 같이 올린 이미지 설명으로 학습 시 일종의 noise로 작동합니다. (인터넷에 사진을 올리면서 아무렇게 끼적거린 설명이라고 생각하면 왜 noise로 작동하는지 대충 짐작할 수 있습니다) 나머지 4개의 data set으로 학습을 하고 Pascal 데이터는 test를 위해서만 사용하였습니다. 인퍼런스(inference) 네트워크 트레이닝과 관련된 부분은 아니지만, 실제 모델 활용 시에 예측(Prediction) 문장의 후보(Candidate)들을 구하는 BeamSearch 기법을 사용했습니다. Seq2Seq에서는 step 당 문장의 각 단어들을 예측하는데, 각 step에서의 최고의 예측이 종합적으로는 최고가 아닐 수 있기 때문입니다. 문장 2개를 예로 들겠습니다. ① [나는, 버스를, 탔습니다] ② [나는, 버스는, 그것은] 두 문장에서 분명 첫 번째 문장의 단어가 더 자연스럽고 잘 설명하였으나 각 step에서 가장 최고 확률의 워드를 택하면 두 번째 문장과 같이 예측될 수 있습니다. 때문에 논문에서는 각 step에서 20개의 후보군을 뽑아서 여러 경우의 수를 만들어 최종적으로는 가장 좋은 시퀀스를 선택하는 빔 서치(BeamSearch) 방법을 이용합니다. 네트워크 평가 모델 평가의 어려움에 대해서 과연 사진을 잘 설명하는 문장에서 Ground Truth가 존재할까요? 위 사진의 GT(Ground Truth) 캡셔닝은 무엇일까요? ① 사람 3명이 길을 걷는다. ② 사람들이 차도 옆을 걸어간다. ③ 남자가 나무로 된 길을 건너간다. 이미지 캡셔닝 Task에서는 이미지 분류와는 어떻게 보면 Ground Truth라는 것이 없습니다. 현재까지는 사람의 주관적인 평가 방법 외에는 100% 성능을 평가할 Metric이 부족합니다. 때문에 저자들은 다양한 관점에서 여려가지 평가 척도(BLUE, METEOR, Cider, recall@k...)를 이용하여 모델의 성능을 보여주었습니다. Generation Result BLEU, METEOR, CIDER라는 자동, 정량적 지표로 평가한 결과 높은 성능을 보임을 알 수 있습니다. 아래 Table 1,2에서 Human은 5개의 correct sentence label 중 하나를 선택해 나머지 4개와 비교하여 도출한 값입니다. Generation Divsersity Discussion 모델이 생성하는 caption 중 학습 데이터에 포함되지 않은 새로운 caption이 만들어질 확률은 얼마나 될까요? 저자들은 모델이 생성한 새로운 caption의 예시를 아래 Table 3에서 제시하고 있습니다. 각 input image에 대해 BLEU score가 가장 좋은 caption을 뽑아보면 약 80%는 기존 학습 데이터에 포함되어 있던 문장들이었습니다. 다만 BLEU score가 높은 순으로 15개의 caption을 뽑아보면 약 50% 정도는 새로운 문장이었다고 합니다. Human Evaluation 사람을 이용해 NIC를 포함한 다양한 ML 모델에서 생성된 Caption을 평가하도록 해보았습니다. 모델들에서 생성한 Caption에서 랭킹을 매겨 평가한 결과는 다음과 같습니다. (R@1은 NO.1으로 꼽힌 캡션의 개수라고 보시면 될 것 같습니다) 다른 모델과 대비해서는 아주 큰 성능 차이를 보입니다. 사람이 NIC에서 만들어진 캡셔닝에 주관적인 점수를 매겨 분류한 결과는 아래에서 보실 수 있습니다. "Described without errors"에 해당하는 caption들은 굉장히 정확하지만, (1열 2번째의 frisbee는 어떻게 저것을 이해했지라는 NIC의 대단함도 보입니다) "Unrelated to the image"에 해당하는 caption은 어디를 보고 이런 caption이 생성되었는지 의아할 정도입니다. 사람이 만든 캡셔닝과 NIC가 만들어낸 캡셔닝을 다른 사람이 채점한 결과는 다음과 같습니다. Flickr-8k: GT (Ground truth)와 비교했을 때 NIC (Neural Image Caption)의 성능이 현저히 떨어지는 것을 볼 수 있습니다. 이는 NIC 성능의 한계를 보여주는 자료이기도 하지만, 자동&정량적 평가 지표인 BLEU의 한계를 보여주는 것이기도 합니다. (BLUE-4에서는 사람이 만든 캡셔닝보다 NIC에서 만들어낸 캡션의 점수가 오히려 더 높았습니다) 네트워크의 장단점 및 한계점 Show and Tell 논문은 "CNN 네트워크를 이용하여 뽑아낸 Feature를 NLP 분야의 Context Vector로 이용 가능하다"라는 큰 아이디어의 시사점을 준 논문이라고 생각합니다. (너무 강력) 논문을 쓸 당시('15)의 SOTA인 GoogleNet과 Seq2Seq를 이용했으니, 최근의 SOTA들의 결합으로는 더 좋은 성능의 네트워크 구현이 가능하지 않을까 생각합니다. 비슷한 맥락에서 Seq2Seq의 단점인 한정된 숫자의 Context Vector 문제도 유전 받았고요... (이 문제점을 해결하기 위해 Show, Attention and Tell 논문이 나왔습니다) 개인적으로는 논문을 읽고도 퀘스천이 여러 가지 남습니다만 '15년 논문이므로 다음 논문들에서 이러한 점이 해결되리라 기대합니다. 캡셔닝에서 사물(Object) 간의 연관관계 정보는 디코더(Seq2Seq)에서 추가가 되는 걸까요? 사전훈련(Pretrain) 된 워드 임배딩(Word Embedding)은 왜 성능이 좋지 못하였을까요? 사전훈련(Pretrain) 된 GoogleNet이 아니라 아예 처음부터 Train 했으면 이미지에서 연관관계의 특징을 잡아 더 좋은 결과가 나올 수 있지 않을까요? 레퍼런스 https://uding.tistory.com/20 https://yseon99.tistory.com/110 2) Show, Attend and Tell 이전 논문인 Show and Tell은 단점을 가지고 있습니다. CNN의 FC layer를 통과한 context vector를 이용하여 image captioning을 진행하므로 항상 같은 context vector를 참고하여 캡셔닝을 생성하게 됩니다. 또한 FC layer를 통과하면서 기존 이미지에서 공간 정보를 잃어버려 이미지의 어느 부분을 보고 캡셔닝을 생성했는지 네트워크 분석이 불가능합니다. 이러한 점을 보완하여 저자들이 발표한 Show, Attention and Tell(2016) 논문에서는 이미지에서 추출된 피처(Extract Feature)들을 한 개의 고정된 벡터(Context Vector)로 만들지 않고 어텐션(Attention) 메커니즘을 이용하여 1개의 워드를 예측하는 스텝마다 다른 분포의 벡터들을 생성하여 디코더의 입력으로 이용하록 네트워크를 구성했습니다. 더 나아가 어텐션을 메커니즘을 2가지 방법(Soft/Hard)로 적용하여 각각의 성능 및 분석 결과를 보여줍니다. 네트워크 구조 논문 전체(~22 페이지)에서 네트워크의 전체 구조가 나타난 Figure는 딱 한 개입니다. 이전 Show and Tell 논문과 비슷하게 네트워크의 구조가 혁신적이고 독창적인 구조를 만들어냈다기보다 기계번역에서 존재했던 네트워크와 기법들을 잘 연결시켜서 이미지 캡션 문제를 풀었다고 생각합니다.(제 생각..) Figure1에서 1,2,4번에 해당하는 내용은 Show and Tell과 동일합니다. 하지만 3번 순서인 RNN with attention이 가장 생소할 것입니다. 따라서 이 부분을 집중하여 소개하도록 하겠습니다. 어텐션 메커니즘(Attention mechanism) 논문에서는 CNNs를 이용해요 생성된 피처 맵(Feature map)을 어텐션을 이용하여 매 스태프마다 RNNs에 입력합니다. 과거 Show and Tell 논문에서도 피처 벡터(Feature Vector)를 매 스텝마다 입력으로 사용했지만, 과 적합(Overfit)이 발생하여 해당 과정을 삭제하였다고 저자들을 말했습니다. 하지만 매번 주어지는 이미지의 정보를 항상 동일한 피처 벡터(Feature Vector)가 아니라 매번 다른 가중치를 고려한 어텐션 메커니즘을 이용한 피처 벡터라면 결과는 달라집니다. (발퀄의 이미지이지만) 위의 그림을 이용해서 설명하도록 하겠습니다. 피처 맵(3X3X128)을 LSTM 셀에 넣어 첫 번째 워드 임배딩을 가장 잘 유추해 낼 수 있는 어텐션 분포를 구합니다. 어텐션 분포는 피처 맵과 같은 차원(3X3)이나 채널수는 1로 구해집니다. 이렇게 구한 어텐션 분포 1을 피처 맵의 각 채널과 곱하여 1X128 차원의 Weighted 피처 벡터를 만듭니다. 그리고 첫 번째 워드 임배딩(문장의 시작을 알려주는 워드임배딩)과 같이 LSTM 셀로 넣어줍니다. LSTM은 2개의 Matrix를 출력하게 되는데 예측 워드와 다음 워드의 어텐션 분포입니다. (이렇게 각 스텝마다 다음 워드를 예측하기 위한 서로 다른 어텐션 분포를 생성합니다) LSTM 셀의 입장에서는 이전 워드와 예측할 워드의 정보가 담겨있는 Context Vector를 입력받게 되는 것입니다. 논문에서는 위와 같은 어텐션 메커니즘(Soft attention)을 더 보완하여 추가적으로 Hard 어텐션 메커니즘을 적용하였습니다. RNN with Attention (Visual Attention) Attention에 대한 개념은 여기에 따로 정리하고 있으니, 해당 내용을 먼저 읽어보시길 추천드립니다. 저는 Show, Attentoin and Tell 논문에 나온 Visual Attention에 대해서 설명하도록 하겠습니다. (논문이 상당히 불친절하고 설명하고 있는 자료가 많지 않아 정확도가 떨어질 수 있으니 양해 부탁드립니다.) 위의 그림처럼 기존 Show and tell 논문에서 LSTM으로 입력되는 context vector는 CNN의 FC layer를 통과한 vector였습니다. 아래 그림처럼 Show, attend and tell 논문에서는 CNN의 Feature Map (L x D) 을 LSTM에 제시합니다. 논문에서는 CNN 모델로 VGG 16을 사용했고 14 x 14 x 256 크기의 Feature map을 사용했습니다. 14 x 14는 flatten 시켜서 196 x 256 크기의 feature map를 LSTM에 제시합니다. 이제 Feature Map을 이용하여 어떻게 Attention Value를 만들어 내는지 정리해 보겠습니다. L x D 크기의 Feature map을 0번째 Hidden cell h0에 넣어 첫 번째 attention value a1 (L x 1) 을 구합니다. 첫 번째 attention value와 Feature Map을 곱하여 하나의 Weighted feature z1를 만듭니다. 이렇게 구해진 Weighted feature z1과 First word(y1)를 1번째 Hidden cell h1의 Input으로 사용합니다. 1번째 Hidden cell h1의 Output으로는 2가지가 나옵니다. 하나는 0번째 Hidden cell h0의 Output과 같은 Attention value a2가 나오고 다른 하나는 Prediction Word의 원핫 벡터 distribution인 d1이 나옵니다. 이와 같은 재귀적으로 반복하여 이미지에 대한 캡셔닝을 구할 수 있습니다. 이때 해당 논문에서는 attention value a를 구하는 방식을 두 가지 제시하고 있으며 각각을 soft attention, hard attention이라고 부릅니다. Soft attention의 수식적 이해 Soft attention은 우리가 흔히 쓰는 attention 개념입니다. 미분가능한 형태이므로 Back propagation을 통해 학습을 진행합니다. 반면, Hard Attention은 미분 불가능한 형태로 학습을 위해 강화 학습을 사용합니다. 사실 Hard attention은 이해하기 어렵고 많이 쓰이는 방법이 아니기에 설명을 생략하겠습니다. * i, f, c, o, h = input, forget, memory, output, hidden state of LSTM E = embedding matrix y = output word * z = context vector, capturing the visual information associated with a particular input location* LSTM cell의 구조를 보면 이렇게 복잡하게 되어있습니다. 기존의 LSTM 구조와 비슷하게 input, forget, output gate가 존재하는데 각 gate로 들어가는 요소들이 조금 다릅니다. h_t-1: t-1 번째 cell에서 출력된 hidden state Ey_t-1: t-1 번째 cell에서 출력된 output word y_t-1의 Embedding matrix Z_t: t 번째 context vector z 를 input으로 넣어줍니다. 여기서 context vector z는 "capturing the visual information associated with a particular input location", 즉 feature map의 특정 영역의 정보를 담고 있는 vector입니다. 이 모델의 핵심은 context vector z를 구하는 것입니다. a는 feature map L x D에서 뽑아낸 Vector입니다. a의 크기는 D이고 총 L 개가 존재합니다. t 번째 LSTM cell에 들어갈 알파는 L 개의 a와 h_t-1 사이에서 구한 attention value이며 각 알파값을 모두 더하면 1이 됩니다. f_att = attention value를 구하는 함수이고, Soft attention은 우리가 흔히 쓰는 attention 개념이니 f_att가 어떤 식으로 작동하는 함수인지 아실 수 있을 것입니다. 이렇게 구한 a와 알파를 곱하여 context vector z를 구합니다. 네트워크 결과 분석 Soft, Hard Attention 네트워크에서 캡셔닝을 할 때의 어텐션 부분을 시각화 한 부분입니다. Soft는 어텐션 한 부분이 분포의 형태를 보이고, Hard는 참고한 부분이 1과 0으로 확실하게 나누어져 있네요. 하지만 각 이미지에서 어텐션 영역이 동일하지 않다는 것은 조금 더 생각해야 할 부분으로 생각됩니다. Attention with Caption 네트워크에서 캡션을 생성할 때 이미지에서 어텐션 한 부분을 보여줍니다. 어텐션 메커니즘을 이용하니 NIC와 다르게 해석 가능하다는 점이 큰 장점으로 보입니다. 논문에서는 잘못 생성한 캡셔닝의 사례들도 아래와 같이 보여줍니다. 네트워크 성능 네트워크의 성능은 NIC보다 모두 다 높은 것으로 나왔습니다. 그리고 Soft와 Hard에서는 Hard Attention을 적용한 모델이 성능이 더 좋게 나왔습니다. 이미지 캡셔닝은 NLP와 결합된 내용이라 컴퓨터 비전 네트워크만 간신히 이해한 입장에서는 매우 어렵고 생소한 내용이 많았습니다ㅜ 추가적으로 학습하는 대로 위 논문의 내용을 보충하도록 하겠습니다. 레퍼런스 원논문 | Show, Attend and Tell: Neural Image Caption Generation with Visual Attention 윤형빈 프로젝트 개발 | attention models, image captioning, machine translation Information and Intelligence | Attention (5): Show, Attend and Tell https://sunshower76.github.io/deeplearning/2020/08/24/CS231n-Lecture10/ (4) 모델 평가 Image captioning 결과를 사람이 직접 평가하는 Human evaluation은 정확하지만 비용과 시간이 너무 많이 든다는 단점이 있습니다. 또한, 사람이 직접 평가하기 때문에, 평가하려는 언어에 대한 제한이 발생하게 됩니다. 이러한 문제를 해결하기 위해 다양한 자동 평가 지표들이 개발되었습니다. 그중 여러 논문에 반복적으로 등장하는 대표적 평가 지표를 소개합니다. Perplexity (PPL) PPL은 언어 모델을 평가하기 위한 지표로 흔히 사용됩니다. Perplexity는 "당혹, 혼란, 곤혹"이라는 뜻입니다. 그러니까 여기서 PPL은 '헷갈리는 정도'로 이해합시다. 단어 뜻을 생각해 보면 PPL 수치가 '낮을수록' 언어 모델의 성능이 좋다는 것을 이해할 수 있습니다. Perplexity는 아래와 같은 식으로 계산합니다. 즉 각 단어 w1~ w_n이 조합되어 해당 문장이 만들어질 확률에 -1/n을 취한 값입니다. " I can play the piano." 이 문장이 만들어질 확률을 계산하기 위해서는 앞에서부터 차례대로 각각의 단어가 나타날 조건부 확률을 계산하고 이를 Chain Rule로 묶어주면 됩니다. 이를 일반화하면 다음과 같습니다. PPL을 이용한 언어 모델 평가 PPL은 "언어 모델이 특정 시점에서 평균적으로 몇 개의 선택지를 가지고 고민하는지 평가" 하는 지표라고 생각하기도 합니다. 가령, 언어 모델의 PPL이 10이 나왔다고 해봅시다. 해당 언어 모델은 테스트 데이터에 대해서 다음 단어를 예측하는 모든 시점(time-step)마다 평균적으로 10개의 단어를 가지고 어떤 것이 정답인지 고민하고 있다고 볼 수 있습니다. P ( ) P ( 1 w, 3. . w) 1 = ( 10 ) 1 = 10 1 10 같은 테스트 데이터에 대해서 두 언어 모델의 PPL 값을 비교하면, 두 언어 모델 중 어떤 것이 성능이 좋은지 판단이 가능합니다. 예를 들어 A 모델은 PPL이 10, B 모델은 20이라고 했을 때 A 모델은 10개의 선택지 중에서 고민하는 거고, B 모델은 20개의 선택지 중에서 고민하는 중이므로 당연히 A 모델의 성능이 더 좋은 것입니다. Reference Wikidocs, 딥러닝을 이용한 자연어 처리 입문 | Perplexity JH Programming| Language Model (1) N-Gram, Perplexity BLEU BLEU score의 한계 같은 의미의 다른 단어여도 다른 단어를 쓰면 틀렸다고 판단한다. 즉, 단어 간의 유사성을 고려하지 않는다. BLEU는 단어별 가중치가 없기 때문에 중요한 단어가 대체되든, 안 중요한 단어가 대체되든 비슷한 점수가 나온다. Reference DeepLearningAI | Bleu Score (Optional) 딥러닝 논문 읽기 모임 | BLEU - a Method for Automatic Evaluation of Machine Translation 논문 리뷰 BLEU: a Method for Automatic Evaluation of Machine Translation (2002 ACL) HULK의 개인 공부용 블로그 | BLEU의 모든 것 METEOR 어려워서 패스...... 후후........ CIDEr : Consensus-based Image Description Evaluation 한국어로 된 자료는 고사하고 영어로 된 자료도 별로 없어 직접 논문을 읽고 설명하는 글입니다. 정확도가 낮으니 감안하고 봐주세요. NEW reference sentence dataset 준비하기 기존의 Image captioning 데이터 셋은 일반적으로 Image 하나에 5개의 reference sentece가 붙어있는데, 저자는 reference sentece 5개는 너무 적다고 판단했습니다. UIUC Pascal Sentence Dataset에서 1000장의 image를, Abstract Scenes Dataset에서 500장의 image를 추린 뒤 모든 Image에 대해 50개의 reference sentence을 붙여서 PASCAL-50S, ABSTRACT-50S라는 데이터 셋을 준비했습니다. (각 데이터 셋의 Reference sentence를 제작하기 위해 무려 465명, 683명을<NAME>했다고 합니다.) CIDEr Metric CIDEr은 기본적으로 TF-IDF의 아이디어를 따릅니다. (TF-IDF에 대한 자세한 설명은 여기를 참고하세요.) Wk는 특정 모델이 생성한 Candidate sentence로부터 구한 n-gram 원소들입니다. 특정 모델이 "An eagle is perched among trees."라는 Candidate sentence를 만들었다고 해봅시다. - W1은 [An, Eagle, is, perched, among, trees] 가 되겠고 - W2는 [An Eagle, Eagle is, is perched, perched among, among trees] 가 됩니다. 아래 식은 각 n-gram 원소들에 대해 TF-IDF 값을 구하는 과정입니다. 위 식에서 h_k(Sij)는 n-gram Wk가 reference sentence Sij에 등장하는 횟수입니다. I는 해당 데이터 셋에 존재하는 전체 Image 개수입니다. 파란색 박스는 n-gram Wk가 reference sentece에 등장하는 비율을 나타내므로 TF에 해당합니다. 초록색 박스는 n-gram Wk가 전체 Image 중 p 번째 image인 Ip에 대한 50개의 reference sentence에서 몇 번 등장하는지 나타냅니다. 따라서 빨간색 박스는 IDF에 해당한다 볼 수 있습니다. Candidate sentence의 n-gram 원소들에 대해 각각 g_k(Sij) 값을 구한 뒤 이를 모아 벡터화하여 g^n(Sij)를 구합니다. "An eagle is perched among trees."라는 Candidate sentence에 대해 1-gram 원소별 g_k(Sij) 값이 각각 a, b, c, d, e, f라고 하면 g^1(Sij)는 [a, b, c, d, e, f]가 되는 식입니다. 비슷한 식으로 g^n(Ci)도 구한 뒤 g^n(Ci)와 g^n(Sij)의 코사인 유사도를 구하여 CIDEr_n(Ci, Si) 값을 구합니다. 즉 candidate sentece에 포함된 n-gram 원소들에 대해 candidate sentence 내 TF-IDF 벡터와 reference sentece 내 TF-IDF 벡터를 구한 뒤 두 벡터의 코사인 유사도를 구하는 것입니다. 최종 CIDEr(Ci, Si) 값은 아래와 같이 구합니다. w_n = 1/N입니다. (1-gram ~ 3-gram을 비교하겠다고 하면 N=3이겠고 1-gram ~ 4-gram을 비교하겠다고 하면 N=4겠죠?) Reference 원논문: Vedantam, Ramakrishna, C. Lawrence Zitnick, and Devi Parikh. "Cider: Consensus-based image description evaluation." Proceedings of the IEEE conference on computer vision and pattern recognition. 2015. SPICE: Semantic Propositional Image Caption Evaluation 한국어로 된 자료는 고사하고 영어로 된 자료도 별로 없어 직접 논문을 읽고 설명하는 글입니다. 정확도가 낮으니 감안하고 봐주세요. 기존의 BLEU, METEOR, CIDEr 같은 방법들은 대체로 candidate sentence와 reference sentence의 n-gram 간 유사도를 평가하였습니다. 그러나 아래와 같은 예시를 통해 "n-gram 간 유사도 비교"의 한계를 발견할 수 있습니다. (a) A young girl standing on top of a tennis court. (b) A giraffe standing on top of a green field. (c) A shiny metal pot filled with some diced veggies. (d) The pan on the stove has chopped vegetables in it. (a)와 (b)는 완전히 다른 의미를 담고 있는 문장이지만 standing on top of a라는 공통 구절을 가지기에 n-gram 유사도는 매우 높습니다. 반면 (c)와 (d)는 거의 비슷한 의미를 담고 있는 문장이지만 공통 구절이 거의 없어서 n-gram 유사도는 형편없습니다. 이와 같은 문제를 해결하고자 저자들은 SPICE라는 새로운 평가 방식을 도입합니다. Semantic scene graphs candidate sentence와 reference sentence를 분석하여 Semantic scene graphs를 만드는 것이 핵심입니다. Semantic scene graphs는 object, attribute, relations 간의 관계 그래프라고 정의할 수 있습니다. 우선 문장에서 핵심이 되는 명사가 object이고, 이를 수식하는 단어가 attriutes입니다. 그리고 두 object 사이의 관계를 나타내는 단어를 relations라고 했습니다. 논문에서 제시한 Fig1, Fig2를 통해 Object, attribute, relation의 개념을 이해할 수 있습니다. (저자들이 Standford Scene Graph Parser라는 방식을 약간 수정하여 semantic scene graphs를 그리고 있다고 하니 만약 이해가 되지 않는다면 이 개념을 찾아보는 것도 도움이 될 것입니다.) SPICE Meteric candidate sentence = c, scene graphs of candidate caption c = G(c) reference sentece = s, scene graphs of reference caption s = G(s) the set of object mentions in c = O(c) the set of relations between objects in c = E(c) the set of attributes associated with objects in c = K(c) 위에서 정의한 O(c), E(c), K(c)의 합집합을 Tuple, T(G(c))라고 하였습니다. Fig 1.의 "A young girl standing on top of a tennis court."라는 candidate sentence에 대한 T(G(c))를 구해보면 아래와 같이 표현됩니다. T(G(c))와 T(G(s))를 각각 구한 뒤, Tuple의 원소가 몇 개나 같은지 평가합니다. 이때 lemmatized word form이 같으면 같다고 평가하였습니다. (lemmatization의 자세한 내용은 여기를 참고) 또한 wordnet의 같은 synset에 포함되면 같다고 평가하였습니다. (wordnet synset의 자세한 내용은 여기를 참고) 저자들은 기존의 BLEU, METEOR, CIDEr score에 비해 SPICE score가 성능이 더 좋다고 논문에서 제시하고 있습니다. 다만 SPICE score는 Object, attribute, relation에만 집중하다 보니 syntax의 오류, 즉 언어의 문법적, 구조적 오류가 발생한 경우 제대로 집어내지 못한다는 한계가 있습니다. Reference 원논문: SPICE: Semantic Propositional Image Caption Evaluation 딥러닝을 이용한 자연어 처리 입문 | 어간 추출(Stemming) and 표제어 추출(Lemmatization) 위키백과 | 워드 넷 6. Visual Embedding(비주얼 임배딩) 컴퓨터 비전에서 가장 실용적인 Task라고 생각합니다. 구글, 네이버의 이미지 검색을 생각하면 가장 쉽게 이해되실 것 같습니다. 이미지를 뉴럴넷으로 활용해 벡터 표현하여 적용하는 영역들을 하나로 묶었습니다. (1) 비주얼 임배딩 아이디어 이제까지 우리가 정리한 모든에 서는 암시적으로 CNN을 이용하여 비주얼 임배딩을 추출하는 과정이 있었습니다. 예를 들어 쳅터1의 이미지 분류(Image Classification)의 이미지 분류 네트워크와 로스 펑션으로 돌아가 보겠습니다. 이미지 분류 네트워크에서 클래스 분류 이전에 있는 마지막 FC layer의 벡터들은 어떤 의미가 있을까요? FC layer의 출력 백터(임배딩 벡터)는 벡터공간에서의 한 포인트(Point)이라고 할 수 있습니다. 왜냐하면 FC 레이어의 출력값은 로스 펑션의 목적에 맞게 분류(Classification) 하기 위한 최적의 벡터(Vector space)를 학습했을 것이고. 분류에 최적화된 임배딩 벡터(Embedding vector)들은 공간상에서 가까운 위치에 모여 클러스터를 이루게 됩니다. 임배딩 벡터 개념은 실용적인 애플리케이션(application)을 만들 수 있습니다. 비주얼 임배딩의 활용 임배딩 활용은 사전에 다양한 이미지에서 추출한 임배딩을 저장할 수 있는 DB가 있을 때 큰 효과를 낼 수 있습니다. 대표적으로 Face Recognition과 Image recommendation이 있습니다. Face recognition Face recognition은 역할에 따라 2가지 카테고리로 나눌 수 있습니다. Face identification은 사진의 이미지가 누구인지 판단하는 기술을 의미하고 Face verification은 촬영된 사진의 인물이 타깃 인물과 일치하는지를 판단하는 기술로 구분됩니다. Image recommendation system 입력 이미지(Query Image)를 넣으면 유사한 상품들을 추천해 주는 기능입니다. 시각적 특징뿐만이 아니라 상품 검색에서는 다양한 유사도 기준(Color, Size, Shape 등) 여러 가지가 존재할 수 있습니다. 이러한 애플리케이션들은 뼈대는 주어진 이미지(Query Image)에서 비주얼 임배딩을 추출하고 DB에 저장된 다른 이미지들의 비주얼 임배딩들과 공간에서 유사도(Similarity)를 구하는 프로세스를 거치도록 시스템이 구성되어 있습니다. 이러한 애플리케이션들의 핵심은 어떤 기준 유사성 기준에 맞춰 라벨을 붙이고 학습을 진행했는지가 중요합니다. 때문에 이 주제는 비지도 학습(Unsupervised learning)과도 많은 연관이 있습니다. 이번 쳅터에서는 라벨이 명확한 Face Recognition 예시로 정리하겠습니다. 로스 펑션(Loss function) 앞에 말씀드린 이미지 분류(Image Classification) CNN 네트워크 + Cross Entropy Loss로 학습이 완료되었다고 가정해 보겠습니다. 이때 사용한 네트워크를 이용하여 어떤 이미지를 인코딩하였을 때 민희 사진 임배딩과 유사하다면 이 이미지는 민희의 이미지일까요? 앞서 이해를 돕기 위해서 비슷한 클러스터를 이룬다고 설명드렸지만, 사실 100% 장담할 수는 없습니다. 이미지 분류 네트워크를 Cross Entropy Loss로 학습하고 Face Recognition에 사용하면 문제를 가지고 있습니다. 근본적으로 Cross entropy 로스는 비주얼 임배딩 추출에 최적화된 로스 펑션이 아니기에 Training(분류 훈련)과 Inference(비주얼 임배딩 활용)의 갭이 존재합니다. 그리고 이런 방식을 사용하게 된다면 클래스가 늘어날 경우에 매번 재학습을 해야만 성능을 보장할 수 있습니다. 때문에 비주얼 임배딩을 활용하기 위해서는 일반적으로 Contrastive, Triplet과 같이 임배딩을 이용하여 로스 값을 구하는 명시적인 로스 펑션(+네트워크 구조)을 사용할 필요가 있습니다. 이어지는 내용에서는 비주얼 임배딩을 추출하는 네트워크 구조, 로스 펑션과 트레이닝 방법에 대해 정리하도록 하겠습니다. (2) 비주얼 임배딩을 위한 사전 지식 1) One-shot learning(★작성 중) 비슷한 이미지를 찾는 문제를 기존의 classification model로 해결하려고 하면 아래와 같은 문제점이 발생합니다. 1) 모든 N 개의 class에 대하여 학습을 진행할 만큼의 충분한 데이터가 필요하고 2) N 개의 class를 분류할 수 있는 모델에서 기존에 없던 class의 데이터가 제시된 경우 모델을 처음부터 학습시켜야 함 이러한 문제를 해결하기 위한 방안으로써 one-shot learning 또는 few-shot learning 계열의 학습 방법론이 고안되기 시작했습니다. One-shot / Few-shot learning 이란 무엇인가 우리는 지금까지 Fully supervised learning을 기반으로 Computer vision에서의 문제를 해결하는 방법들을 배워왔습니다. 하지만 이는 사람이 이미지를 인지하고 학습하는 과정과 상당한 차이를 보입니다. 전통적인 딥러닝 모델에서는 가령 아래의 예시에서 우리는 허스키 사진을 주면 허스키로 구분하고, 코끼리 사진을 주면 코끼리로 구분이 가능할 것입니다. 하지만 만약 여기 예시에는 없는 다람쥐 사진 두 개를 주면 둘이 '비슷하다'라는 결론을 낼 수 있을까요? 아마도 불가능할 것입니다. 하지만 사람에서는 가능하죠. 어떻게 가능할까요? 우리는 "구분하는 법"을 학습하기 때문입니다. 다르게 말하면 "배우는 법을 배우는"(learn to learn) 것입니다. 우리는 살면서 사자와 호랑이가 다르다는 것을 배우고 토끼와 차가 다르다는 것을 배우고 상당히 많은 물체를 구분 짓는 법을 학습해왔습니다. 그렇기에 우리는 다람쥐 사진 두 장을 보고 둘이 비슷하다는 사실을 유추해낼 수 있고, 다람쥐와 차를 쉽게 구분할 수 있을 것입니다. 설령 처음 보는 물체라고 할지라도 문제없이 우리는 적은 수의 사진만 보고도 물체를 구분 지을 수 있습니다. Few shot learning의 핵심이 여기서 옵니다. One-shot / Few-shot learning의 학습방법 Few shot learning에서의 데이터는 training에 이용되는 Support set과 테스트에 이용되는 Query로 나뉩니다. 이런 Few shot learning task를 보통 N-way K-shot problem이라고 부르는데, label 당 Support set에서의 이미지 수를 K라고 하고, N은 label의 수입니다. 지금부터 다룰 One-shot learning은 Few shot learning의 극단적인 예시로 K가 1, 즉 label 당 이미지를 하나씩만 보여주고 학습하는 방법입니다. 1) Distance 기반 학습 Distance 기반 학습의 핵심 아이디어는, 아래와 같은 "distance function"을 정의하는 것입니다. ( m 1 i g) degree of difference between images 여기서 $D(img1, img2) > 2) Graph neural network 기반 학습 Reference Few shot learning Siamese Neural Networks (샴 네트워크) 개념 이해하기 https://youtu.be/96b_weTZb2w 2) Siamese Network 샴 네트워크는 Siamese Neural Networks for One-shot Image Recognition라는 논문에서 처음 등장했습니다. 클래스가 많아 이미지 분류 네트워크를 전이(Transfer) 하여 사용할 수 없고, 클래스 사진을 대량으로 구할 수 없을 때 추가적인 학습(Re-training) 없이 새로운 클래스에 대해서도 좋은 성능을 낼 수 있도록 모델이 설계되었습니다. (one-shot learning을 사용한 모델입니다) 샴 네트워크는 두 사진을 입력으로 받고, 동일한 CNN 네트워크로 두 이미지에서 비주얼 임배딩을 각각 추출합니다. 비주얼 임배딩 벡터 간의 거리(Distance)를 구하고 거리를 유사도 값으로 출력(0~1) 합니다. 트레이닝(Training)은 다음 순서로 이루어집니다. 입력 데이터(Input 1, Input 2) 쌍을 준비합니다. 동일한 클래스 쌍의 경우 출력값을 1로, 다를 경우 0으로 합니다. 파라미터를<NAME>는 CNN을 통과시켜 각 입력에 대한 임베딩 값 (Embedding 1, Embedding 2)을 얻습니다. 두 임베딩 사이의 거리를 계산합니다. L1, L2 norm 등의 방법을 사용합니다. 두 입력이 같은 클래스 면 거리를 가깝게, 다른 클래스 면 거리를 멀게 하는 Contrastive loss를 이용하여 학습합니다. 네트워크가 매우 특별하지는 않습니다. 하지만 뉴럴넷의 복수 사용, 특별한 로스 펑션 사용이 기존과 차별되는 네트워크입니다. Reference 원 논문: Siamese Neural Networks for One-shot Image Recognition 유튜브 DeepLearningAI | Siamese network 고려대학교 산업경영공학부 DSBA 연구실 Siamese neural networks for one-shot image recognition 블로그 샴 네트워크를 이용한 문제 이미지 검색 기능 만들기 Siamese Neural Networks (샴 네트워크) 개념 이해하기 Siamese Neural Networks for One-shot Image Recognition 3) Contrastive Loss 이해를 돕기 위해 "철수", "영희", "민희"의 사진을 각각 100개씩 가지고 있다고 가정하겠습니다. 이미지 2개씩 랜덤으로 뽑아 짝을 지어서 이미지 세트(Set)를 만듭니다. 그리고 같은 사람일 경우 라벨은 1, 다른 사람일 경우 0으로 합니다. {(철수-철수, 1), (영희-철수, 0), (철수-민희, 0), (영희-영희, 1), ....} 이제 각각의 이미지에서 CNN을 이용하여 임배딩을 추출하고 임배딩간의 거리(Distance)를 이용하여 로스 값을 구하여 학습합니다. 식의 의미를 분석해 보면 다음과 같습니다. 라벨이 1인 경우에는 임배딩간의 거리가 Loss 값이 됩니다. 같은 클래스인 경우는 거리를 0이 되도록 학습이 진행됩니다. 라벨의 0인 경우에는 (1-y)는 1이 되므로 없는 것으로 가정하고 해석하겠습니다. max() 가 이용되었으므르 경우를 2가지로 쪼개보겠습니다. Case 1) α(margin) > Distance인 경우 : 로스 값이 존재하고 Distance가 α만큼의 크기가 되도록 CNN의 파라미터 업데이트가 진행됩니다. Case 2) α < Distance인 경우 : max 함수를 거치면 Loss가 0이므로 가중치 업데이트가 없습니다. 복잡하게 보이지만 요약하면 서로 같은 클래스인 경우에는 임배딩간 거리가 0이 되도록 서로 다른 클래스일 경우 거리가 α(margin) 이상이 되도록 학습한다는 의미입니다. Contrastive Loss 한계점 ①α(margin)은 사람이 정해줘야 하는 값(하이퍼 파라미터)입니다. 하지만 거리의 대상이 되는 엘리먼트들이 CNN 통해 임배딩 되었기에 사람 입장에서는 직관적으로 거리 값을 이해할 수 없습니다. 여러 번 시도 없이는 최적(Optimum) α(margin)을 정하기 어렵습니다. ② Distance가 α(margin) 값보다 작은 모든 경우에 결국에는 모든 임배딩간 거리가 α(margin)으로 수렴하여 정보를 잃어버릴 수 있습니다. ②번 한계점을 보완할 수 있는 FaceNet(+Triplet Loss)에서 제안하였습니다. 4) FaceNet 샴 네트워크가 두 개 입력 이미지 간의 유사도를 비교해서 로스를 계산해서 역전파 했다면, FaceNet(2015)에서 제시한 구조는 세 개의 입력 이미지 간의 유사도를 비교하는 모델입니다. 트레이닝 시 이미지는 다음과 같이 준비됩니다. Anchor 이미지 : 기준이 되는 이미지 Positive 이미지 : Anchor 이미지와 같은 클래스의 이미지 Negative 이미지 : Anchor 이미지와 다른 클래스의 이미지 FaceNet 아키텍처 각 이미지에서 동일한(Weight sharing) CNN으로 비주얼 임배딩을 뽑아내고, 임배딩간의 거리를 이용하여 Triplet 로스 값을 구합니다. FaceNet이 샴 네트워크와 구조적 다른 것은 네트워크 마지막이 이미지 간 유사도가 아니라 임배딩으로 끝난다는 점입니다. FaceNet은 임배딩만을 이용한 직접적인 로스 펑션(Triplet Loss)을 제안하여 Face Recognition 발전에 기여하였습니다. FaceNet의 장점 FaceNet이 Siamese Network에 비해 가지는 장점으로는 순위 매기기(Ranking)가 가능하다는 점입니다. Siamese Networ은 입력 이미지와 다른 이미지의 유사도를 0~1의 절대적 유사도(absolute similarity)만 알 수 있으나 FaceNet은 입력 이미지(Anchor)와 나머지 두 이미지와 거리를 통해서 상대적 유사도(relative similarity)를 알 수 있기에 순위 매기기(Ranking)가 가능하다는 장점이 있습니다. Reference 유튜브 DeepLearningAI | Triplet Loss 블로그 Pairwise / Triplet Loss Triplet Loss 간단 정리 5) Triplet Loss Triple Loss는 입력 이미지 3개(anchor, positive, negative)의 비주얼 임배딩을 이용하여 계산됩니다. 여기에서 [ ]+의 표시는 max 함수를 의미합니다. 손실은 위와 같이 계산됩니다. Contrastive Loss에서 "같은 클래스 사이 거리" = "0", "다른 클래스 사이의 거리" = "α 이상"과는 다르게 선택된 Positive, Negative 클래스 간의 상대적인 거리를 고려하여 학습이 진행됩니다. 때문에 같은 Positive 클래스에 속해 있더라도 매우 비슷한 이미지 간은 학습 완료 이후에도 더 가까운 거리를 유지할 수 있게 해줍니다. (그래서 앞서 말씀드린 Ranking과 같은 계산이 가능합니다) 학습이 이상적으로 완료된 이후에는 추출된 임배딩을 벡터공간에서 시각화해보면 아래와 같은 분포를 가지게 됩니다. (3) 비주얼 임배딩을 이용한 분야 1) Face recognition Similarity learning이 활용되는 분야에는 Face recognition 분야가 있습니다. Face recognition 기술은 얼굴을 포함하는 입력 정지 영상 또는 비디오에 대해 얼굴 영역의 자동적인 검출 및 분석을 통해 해당 얼굴이 어떤 인물인지 판별해 내는 기술로 패턴인식 및 컴퓨터 비전 분야에서 오랫동안 연구되어 온 분야입니다. 얼굴인식 기술은 응용에 따라 얼굴 검증(Face Verification) 그리고 얼굴 식별(Face Identification) 기술로 구분할 수 있습니다. 얼굴 검증(Face Verification): 입력으로 들어오는 두 개의 얼굴 영상이 동일 인물인지를 판단하는 1:1 검증 문제 얼굴 식별(Face Identification): 입력으로 들어오는 하나의 얼굴 영상이 사전에 등록된 N 명의 인물 중 어떤 인물에 해당하는지 판단하는 1:N 검증 문제 Image Classification 방식으로 Face recognition을 하려면 엄청난 수의 데이터를 수집해야 합니다. 또한 기존 학습 데이터에 없는 새로운 사람이 추가될 경우 네트워크를 다시 학습해야 하는 문제가 발생하게 됩니다. 이런 한계를 보완하기 위하여, Face recognition에는 Similarity learning을 활용합니다. 핵심은 DB에 보유한 Class의 대표 이미지와 입력된 Input 이미지 간의 distance를 구하고 이 distance를 가지고 어떤 사람인지를 판단하는 것이지요. 여기서 distance는 Raw 이미지를 가지고 비교하지는 않습니다. 사진 속 얼굴 위치가 제각기 다르거나 그 촬영 각도가 다르면 얼굴 인식 정확도가 낮아질 수 있기 때문입니다. 따라서 사진에서 얼굴 영역을 찾아 동일한 형태의 정면 얼굴을 추출하는 전처리 과정이 선행되어야 합니다. 일반적인 전처리 과정은 다음과 같습니다. 1) face detection, 얼굴 검출: 시스템에 입력된 이미지에서 얼굴 영역을 찾음 (face detection, 얼굴 검출), 2) face alignment, 얼굴 정렬: 눈과 코 등 얼굴의 특징을 나타내는 점을 찾음 3) 이 특징점을 이용해 얼굴 영역을 동일한 형태와 크기로 변경합니다 전처리를 거친 이미지를 CNN 네트워크를 통과시켜 embedding 하고 출력된 feature vector 간의 거리를 구합니다. 얼굴 인식에서는 같은 얼굴이면 distance가 작게, 다른 얼굴이면 distance를 크게 나오도록 네트워크를 학습시키는 것이 중요하며, 대개 loss function으로 Triplet Loss를 사용합니다. Introduction 얼굴 인식 모델 중 2015년에 나온 FaceNet: A Unified Embedding for Face Recognition and Clustering을 정리해 보겠습니다. 얼굴 인식 모델에서 가장 중요한 개념인 Triplet Loss가 처음 등장한 논문입니다. FaceNet은 각각의 얼굴 이미지를 128차원으로 임베딩한 후 유클리드 공간에서 이미지 간의 거리를 비교하여 Face recognition / verification / clustering을 하도록 하였습니다. 기존 모델들과 다르게 face alignment를 수행하지 않고도 accuracy 99.63% (LFW dataset), 95.12% (YTF dataset)의 높은 성능을 보이며, end-to-end training이 가능하다는 것이 FaceNet이 가지는 장점입니다. 네트워크 구조 CNN network를 이용하여 input image에 대해 128차원의 embedding vector를 추출하였습니다. 사용한 CNN은 2015년 당시 고성능이었던 ZF net과 GoogLeNet입니다. 이전 모델들은 2D, 3D의 face alignment를 수행하였지만, FaceNet은 그런 과정을 생략하고 이미지를 통째로 CNN에 제시하였습니다. 사용한 ZF Net 구조 중 하나 사용한 GoogLeNet 구조 중 하나 Loss function - Triplet loss 자세한 내용은 Triplet Loss에 대해 정리한 문서를 참고하세요. 저자들은 모델의 성능을 높이기 위해서 Hard Positive / Hard Negative / Semi-Hard Negative 데이터를 추가로 지정하였습니다. Hard Positive data와 Hard Negative data 쌍을 모델에 제시하여 학습시키면 더 빠른 convergence가 가능했다고 합니다. Hard Positive data - 같은 사람이지만 다른 사람처럼 보이는 사람. - anchor data와 positive data의 embedding vector 간 거리를 최대로 만드는 데이터입니다. Hard Negative data - 다른 사람이지만 같은 사람처럼 보이는 사람 - anchor data와 negative data의 embedding vector 간 거리를 최소로 만드는 데이터입니다. 전체 데이터 셋에서 argmax, argmin을 계산하여 Hard positive, Hard negative를 구하려면 연산량이 너무 많아집니다. 이를 해결하기 위해 저자들은 한 사람의 이미지 중에서 Hard positive data를 약 40여 개를 골라 mini-batch로 선정하였습니다. 그리고 랜덤하게 구한 negative image 중 무작위로 골라 mini-batch에 추가하였습니다. 저자들은 Hard Negative data를 사용하여 모델을 학습시키는 경우 모든 embedding vector f(x)를 0으로 만드는 처참한 결과를 만들 수 있기 때문에 Hard Negative data 대신 Semi-hard negative data를 사용했다고 합니다. Semi-hard negative data는 위의 식에서 볼 수 있듯이 Euclidean distance가 Positive data보다 살짝 큰 데이터입니다. 즉 margin α (anchor - positive, anchor- negative 사이의 거리가 확연히 차이가 나도록 해주는 장치)가 없어서 positive data와 구분이 어려운 데이터인 것이죠. 데이터 셋 LFW (Labeled Faces in the Wild) 통제되지 않는 환경에서의 안면 인식 문제를 연구하기 위해 디자인된 얼굴 사진 데이터 셋입니다. 인물의 이름이 라벨링 된 1680여 명의 사람이 포함되어 있으며 13,233 개의 이미지로 구성되어 있습니다. YTF (YouTube Faces) You Tube에서 다운로드한 영상으로 구성된 얼굴 인식 영상 데이터 셋입니다.<NAME>상에서의 통제되지 않은 안면 인식의 문제 해결을 위해 디자인되었습니다. 1,595명의 사람이 포함되어 있으며, 3,425개의<NAME>상으로 구성되어 있습니다. 성능 FaceNet의 여러 구조들이 갖는 성능을 비교한 그래프입니다. (NN = ZF Net, NNS = GoogLeNet) 얼굴 크기에 맞게 이미지를 잘라주는 과정을 추가로 수행하면 LFW에서 98.87%의 정확도를 보였고, 추가적인 alignment를 했을 경우에는 99.63%까지 정확도가 오르는 것을 보여주었으며, YTF에서는 95.12%의 정확도를 보여주었다고 합니다. False accept는 다른 사람을 같다고 분류한 경우이고, False reject는 같은 사람을 다르다고 분류한 경우입니다. 사실 몇 개는 인간이 보기에도 알아보기 힘들 정도 기 때문에 모델의 성능이 대단히 높다는 것을 알 수 있습니다. Reference 원논문: FaceNet: A Unified Embedding for Face Recognition and Clustering 블로그 DeepLeraningAI | What is face recognition 딥러닝 기반 고성능 얼굴인식 기술 동향 kakaoenterprise | 얼굴인식 알고리즘 선행 연구를 소개합니다 내 마음대로 FaceNet 논문 리뷰 - Triplet Loss란? Face Recognition 2. FaceNet 논문 리뷰 2) Visual Recommendation system 추천 시스템이란? 추천 시스템은 영화, 쇼핑, 음악 등 다양한 영역에서 제공하고 있는 기능이기 때문에 아마 많은 분들에게 익숙할 것입니다. 추천 시스템은 이용자가 앱을 사용하면서 제공하면 수많은 데이터를 필터링해 사용자 간의 유사도, 아이템 간의 유사도를 알아내고, 이용자의 선호도와 관심사를 바탕으로 비슷한 제품을 추천해 줍니다. 추천 시스템 방법론에 대해 아주 간략하게만 다루어 보면 다음과 같이 구분이 가능합니다. 1. Content-based Filtering (콘텐츠 기반 필터링) 콘텐츠 기반 필터링은 유저가 관심 있는 아이템의 속성을 분석하여 새로운 아이템을 추천해 주는 것입니다. 뒤에서 설명드릴 Collaborative Filtering(Item-based)와 다른 점은 다른 유저의 정보가 사용되지 않는다는 점입니다. 내가 산 옷과 비슷하게 생긴 옷을 추천해 주거나 뉴스 기사가 비슷하거나 관련된 다른 뉴스를 추천해 주는 경우에 자주 사용됩니다. 이러한 콘텐츠 기반 필터링은 아이템들의 feature를 잘 추출하기 위해 어떤 feature extraction 방법을 선택하는지가 중요하고, 추출된 feature를 통해 아이템을 비교할 유사도(Similarity)에 대한 선택도 중요합니다. 2. Collaborative Filtering (협업 필터링) 협업 필터링은 사용자 그룹이 형성되어 있고, 그들 간의 평가 점수와 선호도를 고려하여, 사용자의 예측 점수와 선호도가 결정됩니다. 한마디로, 사용자와 비슷한 다른 사용자를 찾아서 그 사용자는 어떤 평가를 했는지를 살펴보는 방식입니다. 2_1. Memory-based Filtering User-Item Matrix로부터 도출되는 유사도 기반으로 아이템을 추천을 합니다. 2_1_1. User-based 유저 간의 선호도(아이팀에 대한 점수)나 구매 이력을 비교하여 추천하는 방법을 User-based CF라고 합니다. 예를 들면, 유저 A가 [포도, 딸기, 수박, 귤]를 샀다고 하면, 유저 A와 가장 유사한 쇼핑 목록을 갖고 있는 유저 B [딸기, 슈박]에게 [귤, 포도]를 추천해 주는 것입니다. 2_1_2. Item-based User-based와는 반대로 아이템 간의 유저 목록을 비교하여 추천하는 방법입니다. 예를 들면, 수박을 [유저 A, 유저 B, 유저 C]가 구매를 했다면, 수박을 산 유저의 목록과 가장 비슷한 포도 [유저 A, 유저 B]을 유저 C에게 추천하는 것입니다. 2_2. Model-based Filtering Model-based CF는 User-Item interaction을 머신러닝이나 딥러닝과 같은 모델을 학습하는 것을 말합니다. 장바구니 분석(Association rule)과 같이 아이템 간의 관계를 학습할 수도 있고, Clustering을 통해 유사한 아이템이나 유저 간의 그룹을 형성할 수도 있습니다. 이 외에도 Matrix Factorization, Bayesian Network, Decision Tree 등 많은 방법론이 사용됩니다. Collaborative Filtering (협업 필터링)이 가지는 장/단점은 아래와 같습니다. * 장점 : 아이템에 대한 콘텐츠의 정보 없이 사용 가능 * 단점 1 Cold Start : ‘새로 시작할 때 곤란함’을 의미하며, 평가되지 않은 아이템에 대해 추천을 하지 않습니다. * 단점 2 Data Sparsity : 수많은 유저와 아이템 사이에 경험하지 못한 데이터의 대부분을 차지함 (Ex. 온라인 쇼핑몰에서 내가 구매한 목록보다 구매하지 않은 목록이 압도적으로 많음) * 단점 3 Scalability : 유저와 아이템의 수가 많아질수록 데이터의 크기가 기하급수로 커짐 3. Hybrid Filtering 콘텐츠 기반 필터링과 협업 필터링은 장단점이 있기 때문에 두 방법을 같이 활용하는 방법을 Hybrid Filtering이라고 합니다. Visual similarity를 이용한 추천 시스템 추천 시스템 중 Visual similarity, 즉 시각적 유사성을 기반으로 비슷한 제품을 추천해 주는 시스템입니다. 추천된 이미지는 선택한 이미지와 유사한 색, 질감 및 모양과 같은 시각적 속성을 가지게 됩니다. 유저가 관심 있는 아이템의 속성을 분석하여 새로운 아이템을 추천해 준다는 점에서 Content-based filtering에 해당되겠죠? Visual similarity를 이용한 추천 시스템 중 Deep Learning based Large Scale Visual Recommendation and Search for E-Commerce, 2017라는 논문을 읽고 정리해 보겠습니다. Introduction 전통적인 전자 상거래 검색 엔진은 텍스트를 사용하는 텍스트 기반 검색만 지원하므로 패션 카테고리 검색에 성능이 제한적입니다. 패션 카테고리 검색은 특히나 제품의 이미지 데이터가 중요하기 때문입니다. 또한 기존에 사용하던 Collaborative filtering (협업 필터링) 기법들은 사용자의 클릭이나 구매 이력 등에 집중하므로 제품의 이미지 데이터는 무시하는 특성이 있으며, cold start (구매 이력이 없는 신상품의 경우 충분한 사용자 데이터가 없으므로 추천하지 않는 특성)와 같은 문제가 발생합니다. 이번 논문에서 달성하고자 한 Visual Recommendation (catalog 이미지와 비슷한 다른 catalog 이미지를 찾아주는 시스템)과 Visual Search (사용자가 올린 이미지와 비슷한 catalog 이미지를 찾아주는 시스템)의 목표는 사용자가 연예인이 입은 드레스이거나 친구가 소유한 핸드백 같은 아이템의 사진을 업로드하여 제품을 검색할 수 있도록 하는 것입니다. 이를 위해 해결해야 할 문제로는 크게 3가지가 있습니다. catalog 이미지라고 하더라도 같은 제품에 대해 수없이 많은 사진이 존재한다는 점입니다. 그림 (a)에서 보듯 옷걸이에 걸린 사진, 마네킹이 입은 사진, 모델이 입은 사진 등 다양하고 빛이나 촬영 각도에 따라 다양한 사진이 존재하기 때문입니다. 사람이 생각하는 "유사함"은 꽤나 모호하고 복잡합니다. 그림 (b)에서 보듯 "기괴한 그림"이 그려진 티셔츠라는 측면에서 사람들은 이를 유사하다고 생각합니다. 이를 위해 딥러닝 모델은 단순히 색이나 모양, 질감과 같은 낮은 수준의 feature가 아닌 더 높은 수준의 feature를 이해할 수 있어야 합니다. Visual Search (사용자가 올린 이미지와 비슷한 catalog 이미지를 찾아주는 시스템)을 실현하기 위해서는 사용자가 올린 이미지에 포함된 불필요한 배경, 안 좋은 조명, 잘린 제품 사진 등 다양한 문제를 해결해야 합니다. 해당 논문에서는 end-to-end로 Visual Recommendation과 Visual Search가 가능한 모델 VisNet을 설계하였고, 해당 모델을 학습시키기 위해 필수적인 데이터 셋을 만드는 방법론을 제시하고 있습니다. 네트워크 구조 VisNet의 네트워크 구조는 Triplet network를 기본으로 하며 비교적 간단합니다. Feature extraction을 위해 Deep layer & Shallow layer라는 두 개의 병렬적 네트워크를 사용합니다. Deep layer에는 VGG-16을 이용하여, Shallow layer에는 얕은 convolution layer를 사용하여 Feature extraction을 진행합니다. Deep layer & Shallow layer를 동시에 사용하기에 Input image의 high level & low level detail을 모두 잡아낼 수 있었다고 합니다. input 값으로 query/positive/negative image 3개의 이미지 세트를 준비합니다. positive image는 query image와 유사한 이미지이고, negative image는 query image와 유사하지 않은 이미지입니다. input image를 모두 VisNet에 통과시켜 Feature vector를 구하고, 각 Feature vector 사이의 Euclidean distance를 구합니다. Loss function으로는 아래와 같은 Triplet loss를 사용합니다. 데이터 셋 모델을 학습시키기 위해 사용한 데이터 셋은 두 개입니다. 1) Flipkart Fashion Dataset: 저자들이 독자적으로 제작한 데이터 셋으로 모두 catalog 이미지입니다. 수많은 이미지 데이터 속에서 유사도를 평가하여 query image / positive image/ negative image 데이터 셋을 나누는 과정이 필요합니다. BISS (Basic Image Similarity Scorer)라는 지표를 도입하여 이미지 데이터 간 유사도를 정량적으로 평가하였습니다. 저자들이 사용한 BISS는 아래 3가지입니다. 1. AlexNet을 통과시켜 얻은 feature vecotor 2. ColorHist: 이미지의 색상 히스토그램 3. PatterNet: 이미지의 패턴을 인식하도록 훈련된 AlexNet을 통과시켜 얻은 feature vector 각 BISS들은 query image마다 1000 nearest neighbor를 선별하고, 그중 유사도가 높은 상위 200개를 positive image라고 설정하였습니다. 하위 500-1000개는 in-class negative image (query image와 일부 유사하지만 다른 이미지)라고 하였고 1000 nearest neighbor에 포함되지 않은 다른 이미지는 out-of-class negative (query image와 완전히 다른 이미지)라고 했습니다. 2) Exact Street2Shop Dataset: 공개 데이터 셋으로 25개의 다른 온라인 판매 사이트에서 수집한 404,683개의 물건 사진 (shop photo)과 20,357개의 거리에서 촬영한 사진(street photo)을 포함한 데이터 셋으로 총 39,479 종류의 옷이 shop photo - street photo 쌍을 이루고 있습니다. 성능 Visual Recommendation VisNet을 이용해 Visual Recommendation (catalog 이미지와 비슷한 다른 catalog 이미지를 찾아주는 시스템)을 시행한 결과는 아래 Table 1에 제시되어 있습니다. 사람에게 5000개의 query image와 각 query image에 대해 VisNet이 추천한 image 쌍을 제시하고 very bad / bad/ good / excellent 4단계로 평가하도록 하였습니다. 97%의 사람이 VisNet 추천 결과에 대해 excellent라고 평가한 것을 볼 수 있습니다. 이는 AlexNet, PatternNet, ColorHist을 이용하여 n-nearest neighbor로 추천한 image들 보다 확연히 좋은 성능을 보여줍니다. Visual Search VisNet을 이용해 Visual Search (사용자가 올린 이미지와 비슷한 catalog 이미지를 찾아주는 시스템)을 시행한 결과는 아래 Table 2에 제시되어 있습니다. 각 query image에 대해 VisNet이 추천한 image를 k 개 제시하고 기존의 Street2Shop Dataset 내에서 실제로 쌍을 이루고 있는지 평가하였습니다. AlexNet을 사용하였을 때는 아주 처참한 결과를 볼 수 있고, VisNet w/o Shallow layers을 사용한 경우 대폭 성능이 개선된 것을 확인할 수 있습니다. 또한 VisNet with Shallow layers을 사용한 경우 성능이 약 3% 더 좋아진 것을 볼 수 있습니다. Reference 블로그 Product Recommendation based on Visual Similarity on the web: Machine Learning / Data Science/ Deep Learning 추천 시스템(Recommendation System) 개요 추천 시스템 (1) - 개요 및 알고리즘 The Future of Visual Recommender Systems: Four Practical State-Of-The-Art Techniques 관련 논문 Deep Learning based Recommender System: A Survey and New Perspectives Deep Learning based Large Scale Visual Recommendation and Search for E-Commerce (4) 비주얼 임배딩 모델 평가(★작성 중) .... 7. Generative model(생성 모델) 가장 핫한 분야입니다. 정말 이게 인공지능으로 했나가 의심될 정도로 빠르게 발전하고 있는 분야입니다. 최근('21)에는 생성 모델을 이용하여 가상 모델까지 속속 보이네요. 앞으로 많은 연구가 이루어져 크게 발전이 될 것이라 보이는 분야입니다. 생성 모델로 만들었을 것이라 생각되는 가상 모델 '로지' (1) 생성 모델 아이디어 생성 모델이란 무엇일까? 생성 모델(generative model)은 주어진 학습 데이터를 학습하고 학습 데이터의 분포를 따르는 유사 데이터를 생성하는 모델입니다. 즉, 주어진 training data와 같은 distribution을 가진 새로운 sample을 만들어내는 모델입니다. 지금까지 앞서 다뤘던 컴퓨터 비전에서의 문제들은 대부분이 일반적인 classification에 기반한 문제로서 feature space 상에서 우리가 찾고자 하는 label로 구분 지을 수 있는 classifier를 찾는 문제였습니다. 하지만 generative model은 classifier를 찾는 것이 목적이 아닌, training set의 distribution을 배우는데 목적을 두고 있습니다. 데이터 각각을 label로 구분하지 않고, 전체 데이터의 joint distribution을 학습합니다. 세상에 실제로 존재하는 것은 아니지만 마치 존재할 것 같은 특히 우리가 학습시켜준 데이터들 사이에 정말로 존재할 것 같은 데이터를 만들어내는 것이 generative model의 목적입니다. 위의 그림에 나와있는 P_model(x)와 P_data가 유사하도록 학습을 해줍니다. 여기서 P_model은 Generative model이 만들어낸 Generated Sample들의 분포이고 P_data는 Training data, 즉 Real World의 데이터들의 분포입니다. 여기서는 두 가지 대분류가 있습니다. P_model을 확실하게 정의하는 Explicit Density Estimation(ex. VAE, Approximate Density, etc.)과 Model을 정의하지 않고 P_model에서 sample을 생성하는 Implicit Density(ex. GAN, Markov Chain, etc.)입니다. 위의 그림과 같이 생성 모델은 실제 세계의 데이터로부터 비슷한 Fake Data를 생성할 수 있습니다. 또한, Time-series data 등은 생성 모델에서 시뮬레이션이나 Planning에 사용 가능합니다. 예를 들어 아래 이미지에서 강아지 이미지를 만들어내는 generative model을 구축한다고 해봅시다. 이때 우리가 원하는 것은, model의 distribution이 실제 데이터, 즉 d t 와 가장 가깝도록 만드는 것입니다. 그렇다면 어떻게 되어야 할까요? 아래 상황이라면 녹색으로 표현된 model distribution, θ p a a 사이의 거리, 가 최소화되는 문제로 정의할 수 있을 것입니다. min ∈ d ( data p) generative model을 이용해 해결하는 문제는 3가지 정도로 요약할 수 있습니다. Density estimation : 주어진 datapoint x에 대해서 model에 의해 할당되는 확률($p_{\theta}(x)}을 구할 수 있을까? Sampling : training에는 존재하지 않지만, training과 가장 비슷한 분포를 나타내는 model distribution으로 이미지를 만들어낼 수 있을까? Unsupervised representation learning : 특정 datapoint x에서 의미 있는 feature representation을 학습할 수 있을까? 좋은 generative model이라면, 위의 예시에 빗대어 표현했을 때 density estimation을 목표로 한다면 개라는 이미지에 대해서는 높은 θ ( ) 를, 그 외의 이미지에서는 낮은 확률을 보일 수 있어야 하고 sampling을 목표로 한다면, 학습된 데이터 셋에는 없지만 확실히 강아지인 이미지를 만들어낼 수 있어야 하고, representation learning을 목표로 한다면 개 품종과 같은 높은 수준의 feature를 찾아낼 수 있어야 할 것입니다. generative model이 해결하고자 하는 문제들의 특성상 정량적인 evaluation은 non-trivial 합니다. 일부 정량적인 지표가 있긴 하지만, 특히 sampling이나 representation learning의 경우 만들어낸 이미지에 대한, 찾아낸 feature에 대한 질적인 특징을 반영하지 못합니다. 고로 generative model의 정량적인 evaluation 방법을 개발하는 것은 매우 활발하게 연구가 진행되고 있는 영역입니다. 또한, 모든 generative model들이 모든 상황에서 효율적이고 좋은 성능을 아직까지 보이지는 못합니다. 현재 많은 사람들에 의해서 유행하고 있는 GAN의 경우에도 사용할 수 있는 상황이 매우 한정적입니다. Discrimitve vs Generative 왜 Generative model이 필요 한가? Dataset의 증가 generative model은 training set이 부족한 상황에서 더 training 을 만들어내는데 사용될 수 있습니다. Computer vision에서 사용되는 많은 구조들은 점점 더 많은 데이터 셋을 요구하고 있습니다. 특히나 최근 들어 유행처럼 번지고 있는 vision transformer를 베이스로 한 구조들은 기존의 CNN을 베이스로 한 모델보다 훨씬 더 많은 양의 training을 필요로 합니다. 하지만 사람이 일일이 classification을 하면서 데이터 셋을 만드는 데에는 많은 시간과 노동력이 투입되며, 현실적인 한계 역시 존재합니다. 아래 이미지는 MNIST에서 그럴듯한 training을 만들어 낸 예시입니다. Style transfer & artwork Style transfer, 또는 Image-to-image translation이라고 불리는 이 작업은 다양한 artwork에 응용될 수 있습니다. 아래 예시는 색이 없는 스케치에 realistic 한 coloring을 해주는 모델입니다. 아래와 같이 실제 사진을 베이스로 만화 그림체같이 이미지를 바꾸어주는데 응용이 되기도 합니다. 실제로 국내에서는 웹툰 그림체로 실제 사진을 바꾸어주는 필터가 카메라 앱에서 사용되기도 했습니다. Super resolution 아래 예시는 super resolution에 generative model을 적용한 것입니다. 대표적인 super resolution 모델 중 하나인 SRGAN의 경우 픽셀 단위 resolution도 더 고해상도로 transfer 할 수 있습니다. 생성 모델의 애플리케이션 예술적 스타일 이전 방법 예술 스타일을 어떤 이미지 대상으로 옮기는 과정입니다. 예를 들어 이미지의 예술적 스타일과 다른 이미지의 내용을 결합해 새로운 이미지를 만들 수 있다. 다음 사진은 이미지 A가 예술 스타일로 다른 이미지들과 결합한 결과물입니다. 동영상의 다음 프레임 예측 방법 생성<NAME>상 모델을 사용해 미래의 프레임을 예측할 수 있습니다. 로터(Lotter)가 제안한 다음 이미지에서 왼쪽의 이미지는 이전 프레임 모델이고, 오른쪽은 실측값입니다. 즉 이전 프레임의 얼굴을 보고 다른 각도에서의 얼굴 모습 데이터를 예측해낸 것입니다. 슈퍼 해상도 이미지 슈퍼 해상도는 작은 이미지에서 고해상도 이미지를 만드는 과정입니다. 전통적으로 보간법은 더 큰 이미지를 만들기 위해 사용됐습니다. 그러나 보간법은 매끄러운 효과를 주기 때문에 고주파 세부 사항들을 놓치게 됩니다. 다음 사진은 초고해상도라는 특정 목적을 위해 레딕(Ledig)이 제안한 SRResNet 모델의 예로 원본 이미지보다 더 높은 해상도인 것처럼 보입니다. 이미지를 다른 이미지로 변환하기 이미지는 특정 목적을 가진 다른 이미지를 생성하는 데 사용될 수 있습니다. 이러한 작업을 '이미지를 다른 이미지로 변환하기(an inmage to image translation)'이라고 합니다. 텍스트로 이미지 생성하기 텍스트 설명을 가지고 이미지를 생성합니다. 다음은 리드(Reed)의 자연을 설명한 텍스트에서 그림을 생성한 예시입니다. 사진으로부터 3D 모델 생성 우(Wu)가 제안한 생성 모델을 사용해 2D 이미지로부터 3D 이미지를 생성합니다. 이러한 프로세스는 로봇 공학, 증강 현실, 애니메이션 산업 등에서 유용합니다 Generative model의 종류 Reference Stanford, cs231n : lecture 13 Generative models lecture note CMU, 10-708 PGM : lecture 17-18 Deep generative models lecture note https://minsuksung-ai.tistory.com/12 https://machinelearningmastery.com/impressive-applications-of-generative-adversarial-networks/ https://developers.google.com/machine-learning/gan/generative cs236 lecture slide : https://deepgenerativemodels.github.io/notes/index.html Gatys_Image_Style_Transfer_CVPR_2016_paper https://arxiv.org/pdf/1511.06380.pdf https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix (2) 생성 모델을 위한 사전 지식 1) 생성 모델의 역사(★작성 중) 초창기 생성 모델 아이디어 Boltzman machine Boltzman machine은 입력층 1개, 은닉층 1개 그리고 모든 node들을 잇는 edge로 구성되어 있습니다. RBM 과는 다르게 같은 layer 안에서도 연결이 있는 모델입니다. 볼츠만 머신은 에너지 기반 모형인데요. 볼츠만 머신의 결합 확률 분포는 아래와 같은 에너지 함수를 통해 정의됩니다. 여기서 ( ) 는 하나의 에너지 함수이고, Z는 x ( ) 1 이 되게 하는 (확률의 합이 1이 되게 하는) 분할함수입니다. ( ) e p ( E ( ) ) 에너지 함수는 아래와 같이 정의합니다. ( ) − ⊤ x b x RBM (Restricted Boltzman Machine, 1980) RBM은 입력층(visible layer) 1개 은닉층(hidden layer) 1개로 구성되어 있습니다. 모든 hidden layer의 노드 들은 visible layer와 연결되어 있고, 그 역도 마찬가지인데요. 같은 layer 안에서는 연결이 되어있지 않습니다(이를 bipartite graph라고 부릅니다). 이러한 특성 때문에 "제한된" 볼츠만 머신이라고 불리는 것입니다. Perceptron의 output은 결정론적인 것에 비해 RBN은 확률에 따라서 입력을 은닉층에 전달할지 전달하지 않을지 결정해 보냅니다. output 역시 확률 값으로 해석할 수 있는 것이 나옵니다. 자세한 설명은 생략하겠으나, reference의 블로그 및 Deep Learning(Ian goodfellow)에서 자세히 설명하고 있으니 참고가 될 것입니다. DBN(Deep belief network, 2006) DBN은 2006년에 제안되어 최초로 Deep 한 network 구조를 훈련할 수 있었던 모델이었습니다. DBN은 여러 개의 hidden layer를 가진 생성 모델입니다. 기본적인 구조는 RBM을 stacking 해서 깊게 쌓아 올린 것입니다. 우리 대부분이 Deep neural network를 학습할 때 사용하는, "gradient descent"에는 익숙할 것입니다. 오차를 토대로 output layer에서부터 chain rule을 이용해 input layer까지 교정해나가는 방법이죠. 이 방법에는 아직까지도 존재하는 문제점이 있는데요, Gradient vanishing / explosion입니다. 심층 모델의 학습에서는 대부분 발생하는 문제이기도 하죠. 당대에는 이 문제 해결이 불가능하다고 보고 네트워크를 깊게 쌓기보다는 kernel machine 등을 연구했었는데요, DBN은 거꾸로 아래층에서 위로 올라가면서 pre-training을 하면서 모델을 깊게 쌓아 올리는 방법을 씁니다. 이를 layer-wise pretraining이라고 부릅니다. 아래에서 위로 어떻게 올라갈까요? 여기서 unsupervised learning의 개념이 나옵니다. DBN에서는 v(vision layer, input)만 알고 있다고 가정하고, 이 입력이 어떤 h (hidden layer, 나아가서 y)의 값으로부터 만들어졌을까?를 추론합니다. 이 과정을 한번 풀어서 생각해 보면 예를 들어 h와 w를 랜덤하게 초기화했다고 해 봄 시다. 그러면 맨 처음 층에서 엉터리 h1와 w1가 있겠죠. 엉터리 h라도 이걸 토대로 x(입력 데이터)를 추론할 수 있고 x로 h를 추론할 수도 있는데요, 이 과정을 반복하면서 필터 w를 학습시킵니다. h1이 입력이고 x'이 출력일 때 x'이 최대한 x와 같은 값을 만들 수 있도록요. 그리고 w1을 freeze 시키고 그다음 단계에서 똑같은 작업을 진행합니다. 학습 과정을 정리해 보자면 아래와 같습니다. pixel 값을 FC로 풀어서 첫 번째 층을 학습한 후(layer-wise pretraining) hidden layer의 출력 벡터를 구한다. 하위 hidden layer의 출력 벡터를 입력으로 보고 다음 layer에 대해서 학습을 진행 (반복) 이후 wake-sleep algorithm을 통해 미세 조정 아래는 DBN을 이용해 MNIST 이미지 생성한 결과입니다. Neural Network model Training of DGMs via an EM style framework 1980~ 현대 현대의 모델들 중 몇 가지는 (3)에서 자세히 논의될 예정입니다만, 여기서는 어떠한 아이디어에 기초해 나온 것인지 시대적인 흐름만 파악해 보도록 하겠습니다. Deep Boltzmann Machines (DBM, 2009) Variational Autoencoder (VAE, 2014) Generative Adversarial Network (GAN, 2014) Reference CMU, 10-708 PGM lecture note : https://sailinglab.github.io/pgm-spring-2019/notes/lecture-17/ RBM : https://idplab-konkuk.tistory.com/14 DBN : https://bi.snu.ac.kr/Courses/ML2016/LectureNote/LectureNote_ch5.pdf Deep Learning (Ian Goodfellow, 2016) 2) Variational Inference & Wake sleep algorithm(★작성 중) Inference model과 Generative model Inference model Posterior probability Variational approximation to the posterior Recognition model이라고 불리기도 함. (Neural network로 구현한다면) Inference network, Recognition network로 불림. (Probablistic) Encoder Generative model prior + conditional / joint probability Likelihood model (Neural network로 구현한다면) Generative network로 불림. 보통 Generator로서 작용 (Probablistic) Decoder Variational Inference Variational Inference는 사후 확률 (Posterior probability)를 approximation 하는 방법입니다. EM algorithm Wake sleep algorithm Reference https://hyeongminlee.github.io/post/bnn003_vi/ https://sailinglab.github.io/pgm-spring-2019/notes/lecture-17/ 유튜브 : Variational Inference (AAILab Kaist) 10-708 (CMU, Probablistic Graphical Modeling) video lectue : https://sailinglab.github.io/pgm-spring-2019/lectures/ (3) 생성 모델들 1) VAE(Variational Auto-Encoder) VAE란? VAE는 Input image X를 잘 설명하는 feature를 추출하여 Latent vector z에 담고, 이 Latent vector z를 통해 X와 유사하지만 완전히 새로운 데이터를 생성하는 것을 목표로 합니다. 이때 각 feature가 가우시안 분포를 따른다고 가정하고 latent z는 각 feature의 평균과 분산값을 나타냅니다. 예를 들어 한국인의 얼굴을 그리기 위해 눈, 코, 입 등의 feature를 Latent vector z에 담고, 그 z를 이용해 그럴듯한 한국인의 얼굴을 그려내는 것입니다. latent vector z는 한국인 눈 모양의 평균 및 분산, 한국인 코 길이의 평균 및 분산, 한국인 머리카락 길이의 평균 및 분산 등등의 정보를 담고 있다고 생각할 수 있겠습니다. → p ∗ ( ) θ ( | ( ) ) 수식을 약간 곁들여 이를 표현하면 위와 같이 나타낼 수 있습니다. p(z): latent vector z의 확률밀도함수. 가우시안 분포를 따른다고 가정 p(x|z): 주어진 z에서 특정 x가 나올 조건부 확률에 대한 확률밀도함수 θ: 모델의 파라미터 VAE의 구조 Input image X를 Encoder에 통과시켜 Latent vector z를 구하고, Latent vector z를 다시 Decoder에 통과시켜 기존 input image X와 비슷하지만 새로운 이미지 X를 찾아내는 구조입니다. VAE는 input image가 들어오면 그 이미지에서의 다양한 특징들이 각각의 확률 변수가 되는 어떤 확률 분포를 만들게 됩니다. 이런 확률 분포를 잘 찾아내고, 확률 값이 높은 부분을 이용하면 실제에 있을법한 이미지를 새롭게 만들 수 있을 것입니다. VAE의 수식적 증명 모델의 파라미터θ가 주어졌을 때 우리가 원하는 정답인 x가 나올 확률이 p θ(x) 높을수록 좋은 모델이라고 할 수 있습니다. 즉 p θ(X)를 최대화하는 방향으로 VAE의 파라미터θ를 학습시키게 됩니다. VAE는 Intractable Density를 구할 수 있으며, 여러 수식을 전개하여 Lower Bound 값을 구할 수 있다. VAE 장단점 장점 : 확률 모델을 기반으로 했기 때문에, 잠재 코드를 더 유연하게 계산할 수 있다. 단점 : Density를 직접적으로 구한 것이 아니기 때문에 Pixel RNN/CNN 과같이 직접적으로 Density를 구한 모델보다는 성능이 떨어진다. AE vs. VAE VAE(Variational AutoEncoder)는 기존의 AutoEncoder와 탄생 배경이 다르지만 구조가 상당히 비슷해서 Variational AE라는 이름이 붙은 것입니다. 즉, VAE와 AE는 엄연히 다릅니다. AutoEncoder의 목적은 Encoder에 있습니다. AE는 Encoder 학습을 위해 Decoder를 붙인 것입니다. 반대로 VAE의 목적은 Decoder에 있습니다. Decoder 학습을 위해 Encoder를 붙인 것입니다. VAE는 단순히 입력값을 재구성하는 AE에서 발전한 구조로 추출된 잠재 코드의 값을 하나의 숫자로 나타내는 것이 아니라, 가우시안 확률 분포에 기반한 확률 값으로 나타낸다. AE : 잠재 코드 값이 어떤 하나의 값 VAE : 잠재 코드 값이 평균과 분산으로 표현되는 어떤 가우시안 분포 아래 그림은 MNist 데이터를 각각 AE와 VAE로 특징을 추출해 표현한 그림이다. 각 점의 색깔은 MNIST 데이터인 0~9의 숫자를 나타낸다. AE가 만들어낸 잠재 공간은 군집이 비교적 넓게 퍼져있고, 중심으로 잘 뭉쳐있지 않지만, VAE가 만들어낸 잠재 공간은 중심으로 더 잘 뭉쳐져 있는 것을 확인할 수 있다. 따라서 원본 데이터를 재생하는데 AE에 비해서 VAE가 더 좋은 성능을 보인다는 것을 알 수 있다. 즉 VAE를 통해서 데이터의 특징을 파악하는 게 더 유리하다. Reference Idea Factor KAIST | AutoEncoder and Variational AutoEncoder - 딥러닝 홀로서기 Auto-Encoding Variational Bayes 논문 정리 NAVER D2 | 이활석 - 오토 인코더의 모든 것 김태유's blog | VAE(Auto-Encoding Variational Bayes) 직관적 이해 2018, DEC 20 VAE (Variational Auto Encoder)를 사용한 생성 모델링 2) Generative Adversarial Networks (GANs) Background GAN은 2014년, Ian Goodfellow의 "Generative Adversarial Network"라는 논문에서 처음 제시되었습니다. CNN의 창시자인 Lecun은 지난 20년 동안 나온 아이디어 중에 가장 멋있는 아이디어라고 칭송하기도 했습니다. GAN은 구조 자체의 이해가 어렵지 않기 때문에, 다양한 분야에서 많은 연구자들에 의해 연구가 되어왔습니다. 아래 이미지는 GAN이 제시된 2014년부터 2020년까지 GAN을 주제로 한 논문 수를 나타내는 차트로, 상당히 빠른 속도로 많은 사람들에게 연구가 되어오고 있음을 확인할 수 있습니다. 많은 도메인에서, 많은 연구자들이 뛰어들고 있는 만큼 짧은 시간 동안 상당한 발전을 보였습니다. 2014년에 나온 vanilla GAN과 최근 나온 StyleGAN의 아웃풋을 비교해 보면 4년이라는 짧은 기간 동안 크게 발전한 것을 확인할 수 있습니다. How GAN works? Intuition 위 그림은 GAN을 설명할 때 가장 많이 나오는 그림인데요, 이는 처음 GAN을 제시한 Ian goodfellow 가 GAN을 위조지폐범과 경찰에 빗대어 설명했기 때문입니다. 위조지폐범은 최대한 진짜 같은 지폐를 만들어 경찰을 속이고, 경찰은 위조지폐범이 만들어낸 지폐와 진짜 지폐를 대조하면서 둘을 구분할 수 있는 차이점을 계속해서 찾아내게 됩니다. 이 과정에서 위조지폐범은 점점 더 정교한 지폐를 만들어 경찰을 속이기 위해 노력하고 경찰은 완벽히 판별하기 위해 더 노력하게 됩니다. 서로 경쟁적인 학습이 계속되다 보면, 어느 순간 경찰이 진짜 지폐와 구분할 수 없을 정도로 비슷한 지폐를 만들 수 있게 될 것입니다. GAN의 기본 철학을 이해해 보자면, 주어진 문제는, "복잡한 고차원의 training distribution에서 sampling을 하고 싶다." 라면 이를 해결하기 위해, simple distribution(e.g. random noise)를 샘플링 해서, Training distribution 을 따르는 Transformation을 시킬 수 있는 파라미터를 학습하자!는 전략을 취하는 것입니다. likelihood - free model Generator and discriminator GAN에는 위조지폐범에 해당하는 Generator(G) 와 경찰에 해당하는 Discriminator(D) 가 존재합니다. Generator는 real data의 distribution을 학습해 fake 데이터를 만드는 일을 합니다. → 최종적으로 이를 Discriminator가 최대한 헷갈리게 하는 것을 목표로 합니다. Discriminator는 smaple이 realdata(training)인지 아닌지를 구분합니다. → 최종적으로 Fake 이미지를 최대한 잘 판별하는 것 을 목표로 합니다. Adversarial learning 지금부터 training data의 distribution인 d t 와 Generator가 만들어낸 이미지의 분포인 g ( ( ) ) 사이를 discriminator가 구분할 수 있는 확률을라고 해보겠습니다. 첫 번째 사진에서 볼 수 있듯, 처음에는 discriminator가 fake 이미지와 실제 이미지를 구분해 내기가 매우 쉽습니다. 이 상황에서는 가 매우 낮을 것입니다. 이후, discriminator를 고정 후 generaotr를 좀 더 잘 만들어낼 수 있게 업데이트한다면, 점점 discriminator가 구분하기 힘들어집니다. 그러면 discriminator는 더 잘 구분해낼 수 있도록 다시 업데이트가 될 것입니다. 이 과정을 계속 반복하다 보면, 결국 discriminator가 점점 더 많이 틀리게 되고 = /에 수렴하게 됩니다. discriminator가 완전히 구분하지 못하는 맨 마지막 이미지를 보면, g p a a 즉 완전히 똑같은 분포를 가지게 됩니다. GAN의 기본 구조를 요약하자면 다음과 같습니다. (initial로 고정된) G로 생성 → D로 classify, 업데이트 → (D를 constant로 만들고) G 업데이트 → (업데이트된 상태로 고정된 ) G로 생성 → D로 classify → (D를 constant로 만들고) G 업데이트 ... (반복) ... → 이 과정을 반복하다가 D(x) = 1/2, 즉 discriminator가 구분할 수 없는 상태가 됨. g p a a Objective function of GAN min max V ( θ D) E ∼ data [ log D ( ) ] E ∼ ( ) [ log ( GAN의 objective function입니다. 그냥 보면 굉장히 복잡할 것 같지만, 사실 뜯어서 보면 정말 간단 명료한 룰입니다. 그러므로 이걸 GAN의 구조에 맞게 하나씩 뜯어서 생각을 해봅시다. Discriminator의 Objective function discriminator는 만들어낸 데이터 x가 실제 데이터라면 1을 리턴하고, fake image라면 0을 리턴하는 classifier라고 생각할 수 있습니다. 지금부터 ( ) 가 disriminator의 리턴 값이라고 정의하겠습니다. 이때 discriminator의 objective function은 아래와 같이 정의할 수 있습니다. 실제 이미지가 input 일 때 실제 이미지를 잘 예측했다면, D(x) = 1이므로, log(D(x)) = 0이 되고 만약에 fake 이미지로 예측했다면, D(x) = 0이므로, log(D(x)) = - \infinity 입니다. 만약에 fake 이미지가 input 일 때 실제 이미지로 예측했다면 D(x) = 1이므로, log(1-D(x) ) = - \infinity 가 되고, 제대로 예측했다면 log(1-D(x)) = 0이 됩니다. 즉, Discriminator의 objective function은 최댓값이 0, 최솟값은 - \infinity 이며, 우리가 원하는 것은 항상 제대로 예측하는 discriminator가 되는 것, 즉 항상 최댓값인 0의 성능을 보이기를 원합니다. 그렇다면 지금까지와는 다르게 gradient ascending, 즉 최대 기울기를 향해 학습이 되어야 할 것입니다. Generator의 objective function 그렇다면 generator의 objective function은 어떻게 생겨야 할까요? generator를 업데이트하는데 있어서, discriminator가 실제 이미지에 대해 어떻게 판별했는지가 중요한 정보일까요? 아닙니다. generator는 자기가 만든 fake 이미지가 얼마나 discriminator를 헷갈리게 했는지 이것만이 중요한 정보입니다. 그래서 discriminator objective function의 뒷부분, fake 이미지에 대한 결과만 이용하면 됩니다. discriminator와 마찬가지로 최소 - \infinity , 최대 0의 값을 가지는 문제가 되지만, 이때는 반대로 discriminator를 속이는 것이 목표이기 때문에 gradient descent를 시행합니다. 즉 generator가 만들어낸 fake 이미지를 실제 이미지라고 분류했을 때, 그 방향으로 gradient update를 진행하는 것입니다. GAN의 Objective function 이제 감이 오시나요? GAN의 objective function은 discriminator의 objective function과 generator의 objective function을 합친 것입니다. 최소화가 되어야 하는 generator ( ) 와 최대화가 되어야 하는 discriminator ( )의 objective function으로 대응해 생각해 보면 완전히 같다는 것을 알 수 있습니다. min max V ( θ D) E ∼ data [ log D ( ) ] E ∼ ( ) [ log ( Optimizing GAN g p a a 가 정말 global optimum 인가? GAN의 기본 가정은 g p a a 일 때를 optimum이라고 가정하는 것인데요, 과연 이것이 합당한 가정일까요? 첫 번 때로, 지금부터 어떤 G에 대해서든 optimal 한 discriminator를 갖고 있다고 생각해 봅시다. 이때 (고정된 G에 대한) D의 성능을 다음과 같이 정의할 수 있습니다. optimal 하다면 0.5로 수렴하겠죠. G = d t ( ) d t ( ) p ( ) 이 optimal 한 D에 대한 objective function은 아래와 같을 것입니다. max V ( , ) E ∼ d t [ o D ( ) ] E ∼ G [ o ( − ( ) ] 위의 식에서 기댓값을 x에 대한 함수로 나타내어 표시해 보겠습니다. ( , ) ∫ p a a ( ) [ o D ( ) ] p ( ) [ o ( − ( ) ] 어떤 ( , ) R에 대해서든 → l g ( ) b o ( − ) [ , ] dptj a b 에 maximum으로 도달한다는 사실이 알려져 있습니다. 이걸 위의 식에 대입해서 생각해 보면 d t 부분이 a, g 부분이 b가 되어, optimal maximum에 도달한다는 것을 증명할 수 있습니다. Jenson-Shannon Divergence (JSD) 위에서 구한 optimal D, G = d t ( ) d t ( ) p ( ) 를 objective function에 직접 넣어봅시다. x p a a [ o ( d t ( ) d t ( ) p ( ) ) ] E ∼ G [ o ( − ( d t ( ) d t ( ) p ( ) ) ] E ∼ d t [ o ( d t ( ) d t ( ) p ( ) ) ] E ∼ G [ o ( ( G ( ) d t ( ) p ( ) ) ] E ∼ d t [ o ( d t ( ) d t ( ) p ( ) ) ] E ∼ G [ o ( ( G ( ) d t ( ) p ( ) ) ] l g 이렇게 정의를 할 수 있는데요, 양옆의 구조가 상당히 비슷하죠. 이 부분을 KL-divergence라고 해서 K로 나타냅니다. 그럼 위의 식은, 아래와 같이 정리됩니다. D L [ d t, d t + G ] D L [ G p a a p 2 ] l g 여기서 K로 정의된 부분을 합쳐서 2 * Jenson- Shannon Divergence로 정의할 수 있습니다. 2 J D [ d t, G ] l g Jenson-shannon divergence는 symmetric KL divergence라고도 불리는데요. 식을 토대로 다음의 4가지 성질을 유도할 수 있습니다. * 1) J D ( , ) >= 2) J D ( , ) 0 i f = 3) J D ( , ) >= J D ( , ) * 4) J D ( , ) (Jenson-Shannon Distance)는 triangle inequality를 만족합니다. Optimizing GAN Code implementation 코드 구현을 따로 문서로 분리하지 않고, 여기서 같이 보여주는 게 좋을 것 같음. (가능한 것만) Limitation 1) Training instability 이론만 보면 GAN은 상당히 이상적인 모델일 것 같지만, GAN은 쉽게 training이 되지 않습니다. 아래 그림은 GAN으로 training 했을 때 epoch에 따른 loss를 나타낸 것입니다. GAN은 처음에는 training이 잘 되지만, epoch이 길어질수록 엄청나게 oscilation이 일어나고, loss가 떨어지지 않아 안정화가 되지 않는 것을 확인할 수 있습니다. 왜 이런 현상이 발생할까요? 이는 GAN이 기초로 하는 가정 자체가 비현실적이기 때문입니다. GAN은 generator와 discriminator가 서로가 서로를 속이는 과정에서 generator가 data distribution에 근사하는 것을 목적으로 합니다. 하지만, 번갈아가면서 업데이트를 진행하는 특성상 generator가 좋아지면 discriminator도 좋아지고, discriminator가 좋아지면 generator도 좋아지고, 서로가 서로의 분포에 근사해가면서 끝나지 않는 숨바꼭질을 무한히 반복하게 됩니다. 이로 인해 discriminator, generator 모두 서로 자리를 바꾸어가며 쫓아다니게 되고, global optimum에 수렴하지 못하게 됩니다. 이런 현상을 oscilation이라고 합니다. 2) Mode collapse " 나는 한 놈만 팬다 " Model collapse를 가장 잘 나타내는 말입니다. 여러 가지 training을 보여줘도, 우연에 의해 먼저 만들어진 몇 가지 이미지와 지나치게 비슷하게 나오는 것입니다. GAN을 training 할 때 보여주는 많은 수의 training set 중에서 우연히 딱 하나의 training image 와 비슷한 image를 generation 했다고 가정해 봅시다. 그렇게 되면, 그 이미지와 비슷한 결과물을 냈으니 그 이미지와 최대한 비슷하게 만드는 쪽으로 gradient update가 일어나게 되고, 상당히 많은 수의 training set을 보여줬음에도 불구하고 몇 가지 이미지에 대해서만 비슷한 결과물을 생성하게 됩니다. 위의 예시는 MNIST data set을 가지고 훈련된 결과물인데요, 첫 번째 줄은 model collapse 문제를 해결하기 위해 만들어진 unrolledGAN의 결과물이고, 두 번째 줄은 vanilla GAN의 결과물입니다. 생성한 샘플이 다양하게 되지 못하고 한두 가지 샘플과 비슷한 결과물만 생성되는 것을 볼 수 있습니다. Further study goodfellow에 의해 GAN이라는 architecture가 제시된 이후, GAN은 여러 가지 분야로 응용되기도 했고 앞서 말한 문제점들을 해결하기 위한 여러 가지 시도가 있었습니다. 아래 이미지를 통해 GAN의 후속 연구들을 볼 수 있습니다. Reference 및 추천 자료 https://ysbsb.github.io/gan/2020/06/17/GAN-newbie-guide.html [how tot rain GAN?] https://github.com/soumith/ganhacks https://towardsdatascience.com/understanding-and-optimizing-gans-going-back-to-first-principles-e5df8835ae18 cs236 lecture note : [GAN] https://deepgenerativemodels.github.io/notes/GAN/ 3) DCGAN(Deep Convolution GAN) GAN을 활용하여 셀 수도 없을 만큼 다양한 GAN 응용 논문들이 있지만, 가장 기본적인 응용 GAN 논문부터 다뤄보려고 합니다. 2016년 발표된 논문 Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks에서 처음 등장한 Deep Convolutional Generative Adversarial Nets (DCGAN)입니다. Original GAN을 이용해 생성한 a) MNIST, b) TFD, c&d) CIFAR-10 데이터 2014년 Ian Goodfellow가 공개한 기존의 GAN은 MNIST 같은 비교적 단순한 이미지에서는 잘 작동했지만 CIFAR-10 같이 조금만 이미지가 복잡해져도 성능이 그다지 좋지 않았습니다. 또한 대부분의 Deep neural network와 마찬가지로 black box model이었기에 성능을 개선하기에도 쉽지 않았죠. 또 이때 당시만 하더라도 GAN이 생성한 결과물이 얼마나 잘 만들었는지 평가할 수 있는 지표가 없었습니다. 이런 문제점을 해결하기 위해 등장한 모델이 DCGAN입니다. DCGAN 네트워크 구조 Fully connected layer와 Pooling layer를 최대한 배제하고 Strided Convolution과 Transposed Convolution으로 네트워크 구조를 만들었습니다. Fully connected layer와 Max-pooling layer는 매개변수의 수를 줄일 수 있지만 이미지의 위치 정보를 잃어버릴 수 있다는 단점이 있습니다. Generator와 Discriminator에 배치 정규화(Batch Nomalization)을 사용하였습니다. 이는 입력 데이터가 치우쳐져 있을 경우의 평균과 분산을 조정해 주는 역할을 합니다. 따라서 back propagation을 시행했을 때 각 레이에 어 제대로 전달되도록 해 학습이 안정적으로 이루어지는데 중요한 역할을 하였습니다. 마지막 layer를 제외하고 생성자의 모든 layer에 ReLU activation를 사용하였습니다. 마지막 layer에는 Tanh를 사용하였습니다. Discriminator의 모든 레이어에 LeakyReLU를 사용하였습니다. 저자들이 다수의 실험을 통해 찾아낸 최적의 구조는 아래와 같습니다. DCGAN의 Generator 구조 DCGAN의 성능 DCGAN을 LSUN(Large-scale Scene Understanding) 데이터 셋을 이용하여 학습시키고 1 epoch 후에 얻은 결과가 Figure 2.에 제시되어 있습니다. 5 epoch 후에 얻을 결과는 Figure 3.에 제시되어 있는데 성능이 훨씬 더 좋아졌음을 확인할 수 있습니다. DCGAN의 학습 DCGAN의 학습이 잘 이뤄졌는지 확인하기 위해 여러 가지 검증 방법을 도입했습니다. 그중 하나가 잠재 공간 (latent space, z)에 실제 데이터의 특성이 투영됐는지 살펴보는 것이었습니다. 사람 얼굴을 생성하는 모델이 잘 학습되면 성별, 머리 색깔, 얼굴 방향, 안경 착용 여부 등의 의미 있는 단위들이 잠재 공간에 드러나게 됩니다. 따라서 생성자의 입력인 100차원짜리 'z' 벡터의 값을 바꾸면 생성자의 출력인 이미지의 속성을 바꿀 수 있습니다. 아래 사진은 DCGAN이 생성한 사람 얼굴 이미지에서 얼굴 방향에 해당하는 'z' 벡터의 값을 바꾸어서 얼굴이 바라보는 방향을 바꾼 것입니다. 이것이 가능하다는 것은 생성자가 얼굴의 의미적인 속성을 학습했다는 것을 뜻합니다. Reference 원논문 Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks 블로그 DCGAN, cGAN and SAGAN & the CIFAR-10 dataset 라온피플 머신러닝 아카데미 | DCGAN 쉽게 씐 GAN 4) SRGAN(Super Resolution GAN) Image Super Resolution (이하 SR)은 저 해상도(Low Resolution) 이미지를 고해상도 이미지(High Resolution) 이미지로 변환시키는 문제를 말합니다. SR이 사용되는 분야는 무궁무진한데, 과거의 TV에서 사용하던 HD(1280 x 720) 해상도의 영상을 최신 TV에 맞게 UHD(3840 x 2160)으로 변환하여 더욱 선명한 화질로 감상을 할 수 있게 하거나, 우주에서 촬영한 이미지의 경우 피사체의 크기가 작아서 분별이 어려운 경우에도 SR이 적용될 수 있습니다. 일반적으로 SIngle Image Super Resolution 문제를 접근하는 방식은 크게 3가지가 존재합니다. Interpolation-based method Reconstruction-based method (Deep) Learning-based method 이를 모두 다루기는 어려우니 이 글에서는 Deep Learning-based method, 그중에서도 2017년 공개된 논문 Photo-Realistic Single Image Super Resolution Using a Generative Adversarial Network에서 처음 등장한 SR GAN을 중점적으로 소개드릴 예정입니다. Introduction Super Resolution의 (Deep) Learning-based method의 초기 모델부터 GAN을 사용한 것은 아니었습니다. 최초로 deep learning을 super resolution에 적용한 SRCNN 이후 더 빠르고, 더 깊은 CNN 모델들이 제시되었음에도 불구하고 해결되지 않은 문제점이 있었습니다. How do we recover the finer texture details when we super-resolve at large upscaling factors? 기존 SR 모델 중 하나인 SRResNet이 생성한 이미지를 매우 확대해 보면, original HR image와 비교했을 때 texture detail이 떨어지는 것을 확인할 수 있습니다. 저자들은 이 원인이 기존 SR 모델들의 loss function에 있다고 보았습니다. 기존 SR 모델들의 목표는 보통 복구된 HR 이미지와 원본 이미지의 pixel 값을 비교하여 pixel-wise MSE를 최소화하는 것입니다. 그러나 pixel-wise loss를 사용하면 high texture detail을 제대로 잡아내지 못하는 한계가 있습니다. 저자들은 이전 연구와는 다르게 VGG network의 high-level feature map을 이용한 perceptual loss를 제시하여 이런 문제를 해결하였다고 합니다. 네트워크 구조 Generator network, G 이미지에 나와있는 것처럼 똑같은 layout을 지닌 B 개의 residual block으로 구성되어 있습니다. Residual block의 구성 - kernel size: 3 x 3 - kernel 개수: 64 - stride: 1 - Batch normalization layer - Activation function: ParametricReLU 일반적으로 convolution layer를 이용하면 그 image의 차원은 작아지거나 동일하게 유지됩니다. super resolution을 위해 image의 dimension을 증가시켜야 하는데 여기서 이용된 방식이 sub-pixel convolution이라고 합니다. (논문에서는 이 방법을 사용했다고 하고 넘어갑니다. 이는 2016. 9 CVPR, Real-Time Single Image and Video Super-Resolution Using an Efficient Sub-Pixel Convolutional Neural Network에서 소개된 방법으로 궁금하면 읽어보세요.) Discriminator Network, D LeakyReLU(α=0.2)를 사용했고, max-pooling은 이미지 크기를 줄이므로 사용하지 않았습니다. - 3 × 3 kernel을 사용하는 conv layer 8개로 구성 - feature map의 수는 VGG network처럼 64부터 512까지 커짐. 마지막 feature maps 뒤에는 dense layer 두 개, 그리고 classification을 위한 sigmoid가 붙습니다. Loss function - Perceptual loss Loss function으로 Perceptual loss를 사용하며 content loss와 adversarial loss로 구성되어 있습니다. 이중 adversarial loss는 우리가 일반적으로 알고 있는 GAN의 loss와 비슷합니다. 조금 특별한 부분은 Content loss입니다. Adversarial loss G n R ∑ = N log D D ( θ ( L) ) D D ( θ ( L) ) 는 Generator가 생성한 이미지를 진짜라고 판단할 확률로 앞에 - 가 붙어있으므로 이를 최소화하는 방향으로 학습합니다. 기존 GAN loss는 log (1-x)의 형태로 되어있으나 이러면 training 초반 부에 학습이 느리다는 단점이 있다고 합니다. 이를 -log (x) 형태로 바꾸어주면 학습 속도가 훨씬 빨라진다고 하네요. Content loss V G i j R 1 i j i j x 1 i j y 1 i j ( i j ( ( H) , ) ϕ, ( θ ( L) ) , ) Φ_ i, j = Feature map obtained by the jth convolution (after activation) before the ith maxpooling layer within the VGG 19 network 시그마 안에 값 = Generator가 생성한 이미지와 original HR 이미지로부터 얻은 Feature map 사이의 Euclidean distance Wi, j & Hi, j = the dimensions of the respective feature maps within the VGG network. Content loss는 Perceptual Losses for Real-Time Style Transfer and Super-Resolution라는 논문에서 처음 제시된 Perceptual loss와 거의 동일하며, 이에 대해 잘 서술하고 있는 블로그 글을 읽어보시길 바랍니다. 여기서는 간단히만 설명하겠습니다. Generator을 이용해 얻어낸 가짜 고해상도 이미지를 진짜 고해상도 이미지와 Pixel by pixel로 비교하는 것을 Per-pixel loss라고 하고, 각 이미지를 pre-trained CNN 모델에 통과시켜 얻어낸 feature map을 비교하는 것을 Perceptual loss라고 합니다. 동일한 이미지이나 한 pixel씩 오른쪽으로 밀려있는 두 이미지가 있다고 가정해 보겠습니다. 이런 경우 loss는 0 이어야 하겠지만 per-pixel loss를 구하면 절대 0이 될 수 없습니다. per-pixel loss의 이러한 단점은 super resolution의 고질적인 문제인 Ill-posed problem 때문에 더 부각됩니다. [Ill-posed problem 예시] Ill-posed problem 이란 저 해상도 이미지를 고해상도로 복원을 해야 하는데, 가능한 고해상도의 이미지가 여러 개 존재하는 것을 말합니다. GAN 모델을 이용하여 여러 개의 가능한 고해상도 이미지 (아래 그림상 Possible solutions)를 구하여도 MSE based Per-pixel loss를 사용하면 possible solutions 들을 평균 내는 결과를 취하게 되므로, GAN이 생성한 다양한 high texture detail들이 smoothing 되는 결과를 초래합니다. 이런 단점을 해결하기 위해 저자들은 GAN이 생성한 HR 이미지와 Original HR 이미지를 Pretrained VGG 19에 통과시켜 얻은 Feature map 사이의 Euclidean distance를 구하여 content loss를 구하였습니다. 성능 SR GAN이 생성한 이미지를 매우 확대해 보면, SRResNet이 만든 이미지와 비교했을 때 texture detail이 좋아졌음을 확인할 수 있습니다. 또한 MOS (Mean Opinion score) testing을 진행하였을 때 SRGAN의 엄청난 성능을 확인했습니다. MOS (Mean Opinion score) testing은 26명의 사람에 세 1점(bad)부터 5점 (excellent)까지 점수를 매기도록 한 것입니다. (기존 Super Resolution rating에서 흔히 사용하던 PSNR이나 SSIM과 같은 점수를 사용하지 않은 이유는 해당 점수들이 MSE를 이용하여 기계적으로 점수를 산출할 뿐, 실제 사람의 평가를 제대로 반영하지 못하는 한계를 보였기 때문이라고 합니다.) Reference 원논문 Perceptual Losses for Real-Time Style Transfer and Super-Resolution Photo-Realistic Single Image Super Resolution Using a Generative Adversarial Network Youtube DMQA Open Seminar | Image Super Resolution Photo-Realistic Single Image Super Resolution Using a Generative Adversarial Network 블로그 Super Resolution 개론 Perceptual loss SR GAN 논문 리뷰 작심삼일 | SRGAN 리뷰 Photo-Realistic Single Image Super-Resolution Using a Generative Adversarial Network (CVPR 17) 5) Cycle GAN image to image translation 이란 이미지 데이터 셋을 사용하여 input 이미지와 output 이미지를 mapping 하는 것을 목표로 하는 생성 모델의 한 분야입니다. 흑백 이미지에 컬러를 입힌다든지, 낮 사진을 밤 사진으로 만든다든지, 테두리만 주어진 사진을 실제 물건같이 만드는 것이 가능하죠. 최근 인공지능 채색이나 사진 복구, 그림체 변형 등의 앱 등에서 자주 사용되는 분야입니다. image to image translation의 대표적 모델로 Pix-2-Pix, Cycle GAN, Style GAN 등이 있습니다. Pix-2-Pix가 처음 등장하였고 이후 Pix-2-Pix의 단점을 해결하기 위해 Cycle GAN이 등장하였습니다. (두 논문은 같은 Berkeley AI Research(BAIR) 랩실에서 발표된 논문이기도 하며 Cycle GAN의 원저자는 심지어 한국인!) Style GAN은 Cycle GAN을 베이스로 하여 개발되었고요. 이해를 돕기 위해 간단하게 Pix-2-Pix에 대해 먼저 알아보고 Cycle GAN에 대해 알아보겠습니다. Related work - Pix-2-Pix 일반적인 CNN 모델에서 설정하듯, Generator가 만들어낸 이미지와 실제 이미지 사이의 유클라디안 거리를 최소화하도록 Loss function을 설정하면 아래와 같이 표현됩니다. x = input image, G(x) = 모델이 생성한 이미지, y = Ground truth 문제는 이런 loss function을 설정하면 가운데 사진과 같이 뿌옇게 (blurring) 표현된 output이 나온다는 것입니다. 이는 Generator가 input image만 보면 벽이 나무로 되어있는지, 흰색 벽돌로 되어있는지 / 새의 깃털 색이 어떤지 전혀 알 수 없습니다. 따라서 Generator는 어느 것을 택해도 loss가 너무 커지지 않도록 애매한 중간값을 택하는 경향을 보이게 되어 애매한 결과물을 도출하는 것입니다. 이를 해결하기 위해 저자들은 conditional GAN (cGAN)을 추가하였습니다. (conditional GAN까지 다루면 너무 길어지니 잘 설명된 Conditional GAN 관련 글을 참고하세요.) GAN은 어떤 데이터 분포를 입력받아 실제에 가깝게 데이터를 생성하는 모델이기 때문에 input image와 비슷하나 다른, 새로운 이미지를 생성하게 됩니다. cGAN은 ground truth (y)를 추가로 Generator에 제시하여 input image를 ground truth (y)와 '연관된' 이미지로 전환할 수 있습니다. 이러한 cGAN의 특성은 image to image translation의 목표, 즉 특정 이미지를 제시하고 해당 이미지를 우리가 원하는 방향으로 변환하는데 아주 적합하다고 할 수 있겠습니다. Pix-2-Pix의 loss function 최종 pix2pix의 loss function은 다음과 같습니다. 첫 번째 항은 cGAN의 loss function입니다. (x, y, z가 위의 그림과 다릅니다. 유의해서 봐주세요. z = random noise vector, y = input image, x= ground truth) 두 번째 항은 만들어낸 이미지와 실제 이미지 간의 격차를 줄여주는 loss function인 L1 loss function입니다. Pix-2-Pix의 성능과 한계 아래 사진을 통해 확인할 수 있듯이 cGAN과 L1 loss를 모두 사용한 경우 가장 훌륭한 결과가 나온 것을 알 수 있습니다. 문제는 Pix-2-Pix를 학습시키기 위해 paired image 데이 셋이 필요하다는 것입니다. 아래 그림처럼 말 사진에 얼룩말이 가진 특징을 씌워서 얼룩말로 변환하려면 말 사진과 동일한 포즈와 크기의 얼룩말 사진, 즉 paired image를 가지고 학습을 시켜야 합니다. Pix-2-Pix 학습을 위해 paired image 데이터를 구하는 비용이 크며 어떤 경우 불가능하기도 합니다. 예를 들어 흑백 사진을 컬러 사진으로 바꾸기 위한 training dataset은 구성하기 쉽지만, 피카소의 그림을 실물 이미지로 바꾸기 위한 데이터 셋을 구성하기는 불가능합니다. 이런 단점을 해결하기 위해 등장한 모델이 Cycle GAN입니다. Cycle GAN의 구조 unpaired image 데이터를 가지고 image to image translation를 하는 것이 cycle GAN의 목적이라고 했습니다. 이때 모델의 loss function을 GAN의 Loss function으로 사용하는 경우 Mode collapse라는 문제가 발생합니다. Mode collapse를 간단히 설명한 그림은 위와 같습니다. 실제 데이터 분포가 p(x) (파란색 실선)라고 주어졌을 때, 우리는 generator가 이 실제 데이터의 분포와 유사하게 학습하기를 바랍니다. 그러나 GAN loss를 이용해 학습을 하다 보면 Generator가 q'(x) (초록색 점선)과 같이 하나의 mode에만 강하게 몰리게 되는 경우가 발생합니다. 이렇게 되면 input의 특징을 다 잊어버리고 똑같은 출력을 생성하게 되는데 이를 Mode collapse라고 합니다. 이를 해결하기 위해 기존의 Generator G 외에 Generator F를 추가한 순환구조가 등장합니다. input image에서 output image로 매핑하는 동작 과정을 forward consistency라고 하고, 반대의 과정을 backward consistency라고 합니다. Generator G와 F를 거쳐서 한 바퀴 돌아오면 다시 자기 자신으로 돌아와야 하기 때문에 순환 일관성(Cycle Consistency)이라고 했고, Input image와 Generator G, F 한 바퀴를 돌아 생성된 Output image 간의 차이를 cycle consistency loss라고 했습니다. Forward cycle consistency - X를 Generator G에 넣어 G(X), 혹은 Y_hat를 출력함 - Y와 G(X)를 Discriminator에 제시하여 결과물 Dy를 출력함 - G(X), 혹은 Y_hat을 Generator F에 넣어 X_hat으로 복구함 - 결론: x → G(x) → F(G(x)) ≈ x Backward cycle consistency - Y를 Generator F에 넣어 F(Y), 혹은 X_hat를 출력함 - X와 F(Y)를 Discriminator에 제시하여 결과물 Dx를 출력함 - F(Y), 혹은 X_hat을 Generator G에 넣어 Y_hat으로 복구함 - 결론: y → F(y) → G(F(y)) ≈ y cycleGAN 구조의 핵심은 input을 주었을 때 의도한 방향으로 바꾸되, 이걸 다시 원래의 input으로 되돌릴 수 있을 정도로 바꾸라는 것입니다. (복잡한 수식 없이 머릿속으로 그려만 봐도 이런 구조를 사용하면 mode collapse를 해결할 수 있을 것 같죠? Cycle GAN의 loss function Cycle GAN의 loss function은 아래와 같이 나타낼 수 있으며, 각 항목은 크게 두 부분으로 나누어집니다. Adverarial Loss CycleGAN 역시 생성 모델이기에 adversarial loss를 사용합니다. 하지만 여기서 알아둬야 할 점은 일반적인 GAN처럼 Cross Entropy loss를 사용하지 않고 Least Square loss를 사용한다는 점입니다. (Cross Entropy loss를 사용하는 것보다 성능이 좋았다고 합니다.) Forward & Backward Adverarial Loss를 모두 더해줍니다. G N ( , Y X Y ) E p a a ( ) [ log D ( ) ] E p a a ( ) [ log ( − Y ( ( ) ) ) ] Cycle Consistency Loss c c ( , ) E p a a ( ) [ | ( ( ) ) x | ] E p a a ( ) [ | ( ( ) ) y | ] 성능 본 논문에서는 다양한 예시를 들며 Cycle GAN의 성능을 보여줍니다. Cycle GAN의 활용 Style Transfer Season Transfer Photo generation from paintings 모네의 그림을 사진처럼 바꿔줍니다. Photo enhancement 스마트폰으로 찍은 사진을 DSLR로 찍은 것처럼 바꿔줍니다. 한계 이미지의 모양을 바꾸진 못합니다. CycleGAN은 주로 분위기나 색상을 바꾸는 것으로 스타일을 학습하여 다른 이미지를 생성합니다. 그러다 보니 피사체의 모양 자체는 바꿀 수가 없었습니다. EX) 사과를 오렌지로 바꾸는 작업 데이터 셋의 분포가 불안정하면 이미지를 제대로 생성할 수 없게 됩니다. EX) 사람을 태운 말을 얼룩말로 바꿀 때 사람까지 얼룩말이 되는 것은 데이터 셋에 사람이 말을 탄 데이터가 없기 때문 Reference 원논문 Unpaired Image-to-Image Translation using Cycle-Consistent Adversarial Networks 블로그 Loner의 학습노트 | Cycle GAN 간단 설명 Conditional GAN Pix-2-Pix Cycle GAN 작심삼일 | Cycle GAN Youtube 동빈나 | CycleGAN - 딥러닝 기반의 이미지 변환 기법 CycleGAN을 사용하여 이미지 간의 연결 찾기 - 저자 직강 6) Disco GAN Disco GAN 이란? Disco GAN은 앞에서 나온 Cycle GAN과 매우 유사한 방식의 알고리즘입니다. 기존의 Pix2Pix 모델의 한계점은 Paired Dataset이 필요하다는 점이었습니다. 말을 통해 얼룩말을 생성하려면 생성하려는 얼룩말과 똑같은 자세로 있는 말이 필요했습니다. Paired Dataset은 구하기 어렵고, 존재하지 않을 확률이 큽니다. Disco GAN은 Paired Dataset이 구하기 힘든 경우에도 Style Transfer가 가능하게 한 GAN 알고리즘입니다. Disco GAN 구조 reconstruction loss를 갖는 네트워크들은 단방향으로만 학습이 이루어졌었는데 Disco GAN은 이를 해결하기 위해 양방향으로 가능하게 두 개의 const loss를 갖는 구조로 이루어져 있습니다. 2개의 Discriminator와 4개의 Generator로 이루어져 있고, 학습을 시킬 때 위 그림과 같이 두 가지 네트워크를 갖습니다. 두 네트워크에서 첫 번째 생성자의 출력을 서로<NAME>면서 양방향으로 학습을 하게 됩니다. Loss Function Input Image xA 생성자 GAB를 거쳐 xAB가 출력됩니다. 해당 출력이 GBA를 거치면 xABA가 출력됩니다. 즉 xABA는 xA 가 두 Generator를 거쳐 생성된 이미지입니다. GAB에게는 LCONSTA와 LGANB가 전달됩니다. LCONSTA는 입력이 2개의 generator들을 거친 후에 얼마나 잘 생성되었는지를 측정한 것이고, LGANB는 생성된 이미지가 B 도메인에서 얼마나 사실적인지를 측정한 것입니다. 훈련을 하는 동안 생성자 GAB는 A도 메인에서 B 도메인으로 매핑되는 것을 학습합니다. A가 B로 매핑된 후 다시 B에서 A로 reconstruct 합니다. 이렇게 두 generator GAB와 GBA의 결과로 생성된 XAB와 XBA는 각각의 Discriminator인 LDA와 LDB의 입력으로 들어갑니다. Generator와 Dicriminator의 loss function은 위의 식과 같이 정의됩니다. 즉 도메인 A와 도메인 B에서 구한 것의 합으로 나타냅니다. Loss GAN과 Loss const 모두 두 개가 존재하고 2가지의 네트워크가 각각의 Loss를 공유함으로써 GAN에서 자주 발생하는 mode collapse problem을 어느 정도 해결했습니다. 네트워크 구조 Generator 구조 Discriminator 구조 Disco GAN 성능 사람의 성별을 바꾸거나, 머리 색을 바꾸고, 안경을 없앤 모습, 몇 년 후의 모습 등을 생성해 내었습니다. 해당 예시에서는 굉장히 높은 성능으로 생성된 사진들이 모두 이질감 없이 잘 생성된 것을 확인할 수 있습니다. Disco GAN의 활용 왼쪽이 Input이고 오른쪽이 Output입니다. 1. 신발 그림과 신발 신발을 통해 비슷한 그림을 생성하거나, 그림을 통해 비슷한 스타일의 신발을 생성합니다. 2. 가방 그림과 가방 가방을 통해 비슷한 그림을 생성하거나, 그림을 통해 비슷한 스타일의 가방을 생성합니다. 3. 신발과 가방 가방과 비슷한 스타일의 신발을 생성하거나, 신발과 비슷한 스타일의 가방을 생성합니다. 4. 말 영상 얼룩말로 말 영상을 얼룩말로 바꾸었습니다. 한계 Reference https://github.com/taeoh-kim/Pytorch_DiscoGAN Disco GAN 논문 7) Improved Techniques for Training GANs GAN을 훈련할 때 사용할 수 있는 팁에 대해서 정리하겠습니다. 이 내용은 Improved Techniques for Training GAN에 기록된 내용으로 저자들의 경험적인 팁 중 3가지 내용만 정리하도록 하겠습니다. (논문에서는 총 5가지 테크닉을 제안했습니다) Feature Matching G(Generator)의 로스 펑션을 변경하는 방법입니니다. 기존에 G의 로스 펑션은 아래와 같았습니다. 이미지에도 기록했지만, 이 로스 펑션은 "G(Generator)가 D(Discriminator)를 잘못 판단하게 하라"라는 의미를 가지고 있습니다. 하지만 저자들은 G의 로스 펑션을 아래와 같이 살짝 변경하는 방법을 제안했습니다. "G에서 생성된 이미지의 피처와 진짜(Real) 이미지의 임배딩 피처와 유사하게(거리가 적게) 하라" 저자들은 D의 로스 펑션 변경은 불안정한 GAN의 학습에 효과를 보여주었다고 합니다. Minibatch discrimination 모드 붕괴가 일어날 때, G가 하나의 D를 잘 속이는 꿀 이미지만을 생성해서 보내줍니다. G가 계속해서 같은 이미지를 생성하고 있다는 정보를 D에게 추가로 제공하는 방법입니다. 위의 Feature Matching를 이용한 네트워크를 아래와 같이 표현했을 때 (G가 생성하는 이미지의 피처 벡터 = f(x)) Minibatch discrimination은 아래와 같이 피처의 정보뿐 아니라 1배치 이미지들의 유사도 정보 O(x)도 피처 벡터에 concat 하여 제공합니다. Historical Average G와 D의 각 로스 펑션에 아래의 추가적인 페널티 텀을 추가하는 방법입니다. GAN 네트워크가 수렴하지 않을 때 Loss Space에서 보면 아래와 같이 Loss가 뱅글뱅글 돌며 발산하는 현상을 보입니다. 하지만 여기에 과거 Parameter의 Average 값을 페널티 텀으로 로스 펑션에 추가하면 수렴할 때 나타나는 파라미터의 급격한 변동을 막아 학습이 거듭될수록 댐핑 효과를 주어 수렴할 수 있다고 합니다. (사실 무슨 말인지 모르.) Reference GAN — Ways to improve GAN performance (4) 생성 모델의 평가 Generative model의 평가는 Ground truth가 없기 때문에 통상적인 다른 supervised learning 계열 문제에 비하면 상대적으로 어려운 편입니다. 그래도 평가를 해야 성능을 비교해 볼 수 있겠죠? 많은 연구자들이 평가 지표의 개발에 뛰어들었습니다. 아마 각각의 metric을 좀 더 찾아보시면 매우 어렵게 설명이 되어있을 텐데요. 이 문서에서는 intuition을 잡는 것을 목적으로 가볍게 설명을 해드리려고 합니다. "평가"라는 것을 하기 전에, 우리가 평가를 하기 위해서는 "무엇"에 초점을 맞춰야 할지 한번 생각해 보죠. Generative model이 해결하고자 하는 task는 크게 3가지 정도로 나눌 수 있었습니다 : 1) Density estimation, 2) Sampling / Generation , 3) Latent representation learning. 당연하게도 우리가 풀고자 하는 task에 따라 어떤 것을 중점에 두고 평가를 해야 할지는 달라지게 되겠죠? 생성 모델이 만들어내는 결과물이 달라질 테니 어찌 보면 당연한 것입니다. 우리는 앞선 설명에서 많은 문제를 Sampling / generation을 가정하고 이해해왔기에 이 문서에서도 이에 초점을 맞춰 한번 설명을 해보도록 하겠습니다. Generative model은 Training set의 분포를 학습하는 것이 목표입니다. 특히나 Sampling / generation 문제라면 training data에 거의 근사하는 임의의 샘플을 봅아내는 것이 목적이겠지요. 사람은 뽑힌 샘플 중 어느 쪽이 더 잘 나왔는지를 쉽게 알아낼 수 있습니다. 대충 봤을 때 오른쪽이 좋아 보이죠? 사람이 이를 어떤 기준을 두고 판단할까요? 한번 생각해 봅시다. 우리는 "좋은 샘플"이라고 말할 때 생성된 이미지가 얼마나 진짜 같은지를 먼저 고려할 것입니다. 왼쪽 이미지가 좀 더 현실적인 이미지들이 많이 보이지요? 이는 이미지의 품질(quality) 과 직결되는 문제일 것입니다. 또한, 만들어진 이미지들의 다양성(diversity) 역시 중요한 가치일 것입니다. GAN에서 아무리 realistic 한 이미지를 만들어내더라도 Model collapse가 일어나 같은 것만 계속 뽑아낸다면 좋은 모델이라고 말하기 힘들겠죠. 그렇다면 평가 지표 역시, 이 둘을 고려해서 만들어질 수 있다면 좋을 것입니다. Evaluation Sample quality (1) - Inception score Inception score는 generative model 중 GAN의 성능을 평가할 때 사용되는 방법이고, 2가지 가정에 기초하고 있습니다. Inception score 계산 시에 중요하게 보는 metric인 sharpness와 diversity가 있습니다. 이 둘에 대해 설명하기 전에, Entropy의 개념에 대해 한번 짚어봅시다. Entropy는 다른 분야에서 통용되는 의미와 같이 "무질서도"를 의미합니다. 특히 c(y|x)에 대한 무질서도를 의미합니다. entropy가 높다는 것은 랜덤 변수 x에 대해서 예측되는 y의 값이 여러 가지라는 것, 즉 y를 예측하기 힘들다는 것이고, entropy가 낮다는 것은 랜덤 변수 x에 대해서 예측되는 y의 수가 적다는 것, 즉 x에 대한 y를 예측할 수 있음을 의미합니다. Sharpness (S) MNIST를 가지고 가상의 숫자 이미지를 만들었다고 해봅시다. 이미지를 가지고 "4"에 해당하는 손글씨 이미지를 만들었는데, 숫자 인식기가 이를 4라고 인식한다면 좋은 퀄리티로 잘 만들어졌다고 볼 수 있겠죠. 즉, classifier가 주어진 이미지 x를 가지고 y라고 잘 classification 하면, 이미지 x는 잘 만든 이미지인 것입니다. sharpness가 크다는 것은, classifier가 확신을 가지고 prediction을 만든다는 것이고, 이는 Clssifier의 predictive distribution ( c(y|x) )가 low entropy를 가짐을 의미합니다. = x ( x p [ c ( | ) log c ( | ) y ] ) Diversity (D) 좋은 quality의 이미지를 만드는 것만큼 중요한 것이, 다양한 이미지를 만드는 것입니다. 우리가 넣어준 샘플들의 결괏값 들의 entropy(c(y))를 보면 이게 1도 나오고 2도 나오고, 9도 나오고 다양하게 나오는 것을 확인할 수 있습니다. Diversity 공식은 아래와 같습니다. = x ( E p [ c ( | ) log c ( ) y ] ) 여기서 c(y)는 marginal distribution을 의미하는데요, 생성된 영상의 Diversity가 크다는 것은 marginal distribution인 c(y)가 큰 entropy를 가짐을 의미합니다. ( ) E p ( | ) Inception score (IS) Inception score는 앞서 소개된 2가지 기준, sharpness와 diversity를 곱해 계산됩니다. 둘 다 좋아야 좋은 결과가 나오겠죠? 상당히 심플하지만 실제로 사람이 판단을 내리는 기준과 상응하는 면이 있습니다. 실제로도 사람이 판단을 했을 때의 결과와 correlation이 높다고 알려져 있습니다. 만약에 Classifier를 이용할 수 없는 상황이면, imageNet으로 pre-training 된 Inception model을 이용해서 이름이 Inception score가 되었다고 합니다. S D S Evaluation Sample quality (2) - Frechet Inception Distance (FID) 아이디어 우리가 만든 생성 모델이 만들어낸 이미지를 다른 네트워크를 가지고 한번 확인해 보면 어떨까? 하는 아이디어에서 시작합니다. 예를 들면, 우리가 만들어낸 네트워크가 A라고 해봅시다. 이 네트워크는 바다 이미지를 만들어내는 생성 모델입니다. 이 A가 만들어낸 이미지를 pre-trained된 Inception network에 넣어보는 것입니다. Inception에서 만들어낸 이미지에 대해 뽑아낸 feature가 있을 것이고, 또 실제 바다 이미지를 넣어서 feature를 뽑을 수도 있겠지요? 이 만들어낸 이미지에 대한 feature와, 실제 바다 이미지에 대한 feature가 비슷하다면 좋은 모델이라고 말하고 싶다! 하는 것이 FID의 기본 철학입니다. Computing FID FID의 계산은 아래와 같이 이루어집니다. I = μ − G 2 T ( T Σ − ( T G ) / ) * T = test set, G = generated image set 수식은 복잡하지만, 하나씩 뜯어서 생각해 보면 어렵지 않습니다. 크게는 평균에 대한 부분인 앞부분, 공분산(covariance)에 대한 부분인 뒷부분으로 나눌 수 있습니다. 첫 번째 부분인 μ − G 2 부터 살펴보죠. 예를 들어 우리의 생성 모델이 자연지형에 대한 이미지를 만드는 모델이라고 해봅시다. 이 모델은 바다에 대해서는 상당히 좋은 성능을 보이는데, 산림 이미지를 만들 때는 좋은 성능을 안 보일지도 모릅니다. 우연히 우리가 하나의 이미지만 가지고 테스트를 했는데 바다 이미지를 만들어서 되게 좋은 성능을 보인다고 판단한다면 이건 올바른 방법일까요? 당연히 아니겠지요. 그래서 우리는 여러 개의 이미지를 만들어서 다양한 이미지에 대해 결과가 어떻게 나와야 하는지를 봐야 할 것입니다. 이때 만들어낸 이미지들을 pre-trained 된 모델에 집어넣어 전부 feature를 뽑아보는데, 이 만들어진 feature 들에 대한 평균값이 G 입니다. 또 마찬가지로, 실제 자연지형의 이미지도 같은 과정을 진행해 이를 T 라고 합니다. 두 평균값을 비교한 metric이 FID의 첫 번째 부분이 되겠습니다. 이를 통해 우리는 이미지가 실제 이미지와 얼마나 비슷한지 (quality)를 알 수 있을 것입니다. 첫 번째 부분을 통해 우리는 quality는 알아낼 수 있지만, diversity는 알아낼 수 없습니다. 두 번째 부분인 r ( T Σ − ( T G ) / ) 는 이에 집중하는 부분입니다. sample 이 만들어내는 feature들 간의 statistics , 이를테면 Covariance 같은 다른 성분들도 비슷한 성질을 가졌으면 좋겠다는 것입니다. FID는 작으면 작을수록, test와 generated image 사이의 차이가 작다는 의미이기에 좋은 모델임을 말합니다. Evaluation Sample quality (3) - Kernel Inception Distance (KID) 아이디어 KID는 MMD(Maximum Mean Discrepancy)를 feature space에서 진행하는 것을 의미합니다. 간단하게는 실제 이미지와 가짜 이미지, 실제 이미지와 가짜 이미지의 세트 간의 similarity를 보는 방법이라고 볼 수 있습니다. Computing KID KID는 FID와 상당히 비슷합니다. 실제 이미지 셋 p, 가짜 이미지 셋을 q라고 하겠습니다. p에서 그림 2장을 뽑고 두 이미지 간의 차이를 구합니다. 이 일을 계속 반복하여 이미지들 간의 차이가 어떻게 되는지에 대한 기댓값을 구합니다. 똑같은 일을 q에 대해서도 진행합니다. 마지막으로 하나는 p에서, 다른 하나는 q에서 뽑은 값으로 또 평균적인 차이를 구합니다. 아래 식은 진짜 이미지 p만 가지고 구한 값 + 가짜 이미지 q만 가지고 구한 값 - 2 * 진짜 이미지와 가짜 이미지 하나씩을 가지고 구한 값을 의미합니다. M ( , ) E, ′ p [ ( , ′ ) ] E, ′ q [ ( , ′ ) ] 2 x p x q [ FID와의 비교 FID는 biased 될 수 있지만, KID는 unbiased 합니다. FID는 O(n) 안에 evaluation이 될 수 있지만, KID는 O(n^2) 정도의 time complexity를 필요로 합니다. Evaluating Latent Representation Reference 원 논문 Inception score : https://arxiv.org/abs/1606.03498 FID : https://arxiv.org/pdf/1706.08500.pdf KID : https://arxiv.org/abs/1801.01401 블로그 A simple explanation of the Inception Score (David mack, 2019) : https://medium.com/octavian-ai/a-simple-explanation-of-the-inception-score-372dff6a8c7a 주 참고 자료 : CS 6785 lecture 13 slide (Cornell university, Volodymyr Kuleshov) https://canvas.cornell.edu/courses/27332/assignments/syllabus Appendix A. 피처 시각화와 딥 드림(★작성 중) ... Appendix B. Multimodal NN multi modal 이란 여러 가지 형태의 정보를 통해 소통하는 환경을 말합니다. 여기서 modality는 데이터의 종류를 의미합니다. 실제 세계에서는 많은 형태의 데이터들이 집합된 형태로 우리는 정보를 접하고 있습니다. 예를 들어 인스타그램을 볼 때 우리는, 친구가 올린 영상을 보고, 영상에 있는 소리를 듣고, 게시물에 태그 된 단어들을 보고, 친구가 영상에 대해 쓴 설명도 봅니다. 유튜브에서 영상을 볼 때도, 영상, 소리, 자막, 댓글, 영상에 대한 설명 등 굉장히 많은 정보를 한 번에 받아들입니다. Multimodal learning이 필요한 이유 지금까지 우리는, 한 가지의 정보만을 이용하는 모델을 배워왔습니다. 그러나, 실제 사람은 감각기관을 통해 들어오는 정보를 복합적으로 사용하여 세상을 인지합니다. 예를 들어 아래 정지 표시를 보면 우리는 빨간색이라는 색깔 정보, 'STOP'이라는 context 정보, 손바닥이라는 이미지 등 여러 정보를 얻을 수 있습니다. 하지만 우린 흑백으로 된 표지판을 봐도 이것이 정지 표시라는 것을 알 수 있고, 심지어는 우리가 모르는 언어로 적혀있어도, 위험한 sign이라는 것을 짐작할 수 있습니다. 한 가지의 modality만 가지고 정보를 이해하는 것보다 여러 가지 modality를 통해 이해하는 것이 더 정확한 파악에 도움을 줄 수 있습니다. 때로는 여러 가지 modality를 이용하는 것이 필수적일 수도 있습니다. 위 상황에서 일본어를 모르는 사람이 붉은색 표시 없이 '止まれ'라고만 쓰여있는 표지판을 봤다면 정지 표시인지 전혀 몰랐을 것입니다. Multimodal learning의 전략 multimodal elarning의 가장 큰 문제점은 modality마다 data의 representation이 다르며, data가 상당히 noisy 하다는 것입니다. 이를 해결하기 위해 보통은 하나의 modality에 대해 pre-training을 시키고 embedding을 통해 결합하는 방식으로 multimodal learning을 구현합니다. Google Open Images Open Images는 2016년 처음 공개되었고 2020년 Version 6가 나온 상태입니다. 해당 데이터 셋은 59.9M 개의 이미지, 20000개의 Category를 보유한 데이터 셋이며, 기존 데이터 image localization뿐만 아니라 segmentation, image captioning 등을 수행할 수 있도록 방대한 주석이 달려있습니다. 특징적인 것은 localized narratives라는 새로운 형태의 multi-modal annotation입니다. 하나의 이미지에 대해 object detection, segmentation이 가능하도록 라벨링 되어있을 뿐만 아니라, 사람의 목소리로 된 해설, 텍스트로 된 해설(caption)이 덧붙여져 있으며 특이하게 마우스 커서도 하나의 annotation으로 들어가 있습니다. 500k 이상의 이미지에 대해 해당 주석이 달려있는 방대한 자료입니다. 위의 그림처럼 사람은 미리 작성된 image caption을 읽으며 이미지를 설명합니다. 이와 동시에 직접 이미지 위에 마우스 커서를 움직이면서 설명하도록 하여, 하나의 이미지를 음성+마우스 커서 + image caption이 동시에 서술하도록 합니다. 마우스 커서를 라벨링 데이터로 쓰는 데이터 셋은 아마 처음인 것 같은데요, 구글은 이 데이터가 사람들이 어떻게 이미지를 인식하고 설명하는지 알려주는 좋은 자료라고 말하고 있습니다. open images는 기존 image caption 데이터에서 아쉬운 점을 보강하였습니다. 우선 객체 간 관계를 설명하는 말을 다수 포함하였습니다. 아래 이미지처럼 “man riding a skateboard”, “man and woman holding hands”, and “dog catching a flying disk”.와 같은 문장을 추가하였습니다. 또한 "Person is jumping and smiling." "Person is laying down." 과같이 사람의 행동을 설명하는 말을 다수 추가하였습니다. Reference Google Open Images<|endoftext|>

전문분야 텍스트 ### 제목: 공학자를 위한 PySide2 ### 본문: 이 책은 공학자를 위한 Python의 자매 책이다. History 2019.5.13 : 1차 편집 완료 0. 들어가기 전에 이 책은 이 책은 공학자를 위한 Python의 자매 책이다. Qt의 공식 Python 바인딩인 PySide2에 대한 기본적인 사용법을 기술하고 있다(QML은 제외) Windows 환경에서 Anaconda 배포본을 사용한다고 가정한다(Anaconda 설치는 공학자를 위한 Python 참조) PySide2 Python에서 GUI를 사용할 때는 Qt의 Python 바인딩인 PyQt를 주로 사용한다. PyQt는 Riverbank Computing이라는 회사에서 제작한 것으로, GPL와 상용 라이선스로 제공된다. PyQt4는 Qt4를 PyQt5는 Qt5를 대상으로 한다. LGPL 라이선스가 없다는 점이 아쉬운 점이다. 한편 Qt의 제작사는 Qt4를 대상으로 PySide라는 Python 바인딩을 제공하였지만, Qt5에 대해서는 제공하지 않다가 최근 PySide2라는 Qt5 용 Python 바인딩을 제공하기 시작했다. Qt와 마찬가지로 GPL, LGPL, 상용 라이선스를 제공한다. PyQt5와 PySide2의 API는 매우 비슷하기 때문에 약간의 수정만으로 PyQt5 소스를 PySide2에서 사용할 수 있다. PyQt5 : Riverbank Computing 제공, 인터넷에서 충분히 많은 리소스를 구할 수 있다는 점이 장점 PySide2 : Qt for Python 프로젝트(Qt 제작사 공식 Python 배포본). LGPL 라이선스가 있다는 점이 특징. 주요 참고 자료 Qt for Python : PySide2 사이트 Qt Documentation : Qt 온라인 헬프 PyQt : PyQt 사이트 PyQt5 Tutorial : 파이썬으로 만드는 나만의 GUI 프로그램 : PyQt5 대상 PyQT5 - Python Tutorial Rapid GUI Programming with Python and Qt : PyQt4로 작성되었지만 설명이 잘 되어 있다. 예제 소스를 PyQt5로 포팅 한 것을 인터넷에서 찾을 수 있다. PySide2 설치 Anaconda 배포본에는 PyQt5가 포함되어 있다. PySide2는 pip로 설치한다. > pip install PySide2 PySide2의 Qt 버전 확인 >>> import PySide2 >>> PySide2.__version__ '5.12.2' >>> import PySide2.QtCore >>> PySide2.QtCore.__version__ '5.12.2' >>> PySide2.QtCore.qVersion() '5.12.2' __version__은 PySide2의 버전을 확인하는 것이고 QtCore::qVersion()은 QtCore DLL 모듈 수준에서의 버전이다. 이 둘은 동일해야 한다. PySide2의 Qt 버전은 5.12.2 임을 알 수 있다. PyQt5의 Qt 버전 확인 import PyQt5.QtCore PyQt5.QtCore.qVersion() Out[4]: '5.9.7' PyQt5는 별도의 version 멤버를 제공하지 않는다. QtCore::qVersion()를 통해 확인해야 한다. PyQt5의 Qt 버전은 5.9.7 임을 알 수 있다. 설치 경로 특히 Anaconda 배포본을 사용할 때는 PyQt5와 경로가 중복될 수 있으므로 주의해야 한다. PyQt5 : PyQt5 설치 경로 : C:\ProgramData\Anaconda3\Lib\site-packages\PyQt5 PyQt5가 사용하는 Qt DLL 경로 : C:\ProgramData\Anaconda3\Library\bin PyQt5가 사용하는 plugin 경로 : C:\ProgramData\Anaconda3\Library\plugins PySide2 PySide2 설치 경로: C:\ProgramData\Anaconda3\Lib\site-packages\PySide2 PySide2가 사용하는 Qt DLL 경로 : C:\ProgramData\Anaconda3\Lib\site-packages\PySide2 PySide2가 사용하는 plugin 경로 : C:\ProgramData\Anaconda3\Lib\site-packages\PySide2\plugins PySide2의 예제 파일은 다음 경로에 있다. * C:\ProgramData\Anaconda3\Lib\site-packages\PySide2\examples HelloQt 다음은 PyQt5와 PySide2를 이용한 간단한 예제이다. (HelloQt 실행 전경) HelloQtPyQt5.py (PyQt5 예제) from PyQt5.QtWidgets import QApplication, QWidget, QLabel import sys if __name__ == '__main__': app = QApplication(sys.argv) window = QWidget() window.resize(289,170) window.setWindowTitle("FIrst Qt Program") label = QLabel('Hello Qt',window) label.move(110,80) window.show() app.exec_() HelloQt.py (PySide2 예제) if __name__ == '__main__': from PySide2.QtCore import QCoreApplication QCoreApplication.setLibraryPaths(['C:\ProgramData\Anaconda3\Lib\site-packages\PySide2\plugins']) from PySide2.QtWidgets import QApplication, QWidget, QLabel import sys if __name__ == '__main__': app = QApplication(sys.argv) window = QWidget() window.resize(289,170) window.setWindowTitle("FIrst Qt Program") label = QLabel('Hello Qt',window) label.move(110,80) window.show() app.exec_() PySide2를 사용하려면 패키지 명칭 PyQt5가 PySide2로 변경되고, 라이브러리 패스를 지정하는 부분이 있는 것 이외에는 완전히 동일함을 알 수 있다. PyQt5나 PySide2를 구동하려면 올바른 plugins 경로가 지정되어야 한다. PyQt5는 Anaconda에 설치되어 있기 때문에 이를 고려할 필요가 없다. 하지만 추가로 인스톨 한 PySide2를 사용하려면 setLibraryPaths(..)로 코드에서 적용하거나, 환경 변수 QT_PLUGIN_PATH를 지정해야 한다. 코드에서 적용하는 방법 if __name__ == "__main__": from PySide2.QtCore import QCoreApplication QCoreApplication.setLibraryPaths(['C:\ProgramData\Anaconda3\Lib\site-packages\PySide2\plugins']) ... 환경 변수에 설정하는 방법 set QT_PLUGIN_PATH=C:\ProgramData\Anaconda3\Lib\site-packages\PySide2\plugins PySide2와 PyQt5의 차이점 동시에 PySide2와 PyQt5가 설치 시 실행환경에 주의 PySide2는 LGPL을 지원한다. 대부분의 API가 매우 유사하다. 단지 최상위 모듈 명인 PySide2와 PyQt5만 변경하면 코드가 작동하지만 다음에 유의한다. PySide2는 Qt의 QString을 제공하지 않고 파이썬 문자열(str를 사용한다. PySide2는 QVariant를 제공하지 않는다. 1. 개념 잡기 HelloQt 프로그램 분석 앞서에서 제시했던 HelloQt 프로그램을 분석하고 이를 통해 Qt 프로그램의 기본 구조, 위젯, 부모-자식 관계를 이해할 수 있다. HelloQt.py from PySide2.QtWidgets import * import sys if __name__ == '__main__': app = QApplication(sys.argv) window = QWidget() window.resize(289,170) window.setWindowTitle("FIrst Qt Program") label = QLabel('Hello Qt',window) label.move(110,80) window.show() app.exec_() from PySide2.QtWidgets import *는 QtWidgets 모듈의 모든 클래스를 임포트 한다. Qt는 여러 가지 모듈로 구성되어 있고, 그 하위에 QWidget, QLabel 등 다양한 클래스가 있다. 다음과 같이 * 대신 개별 클래스를 임포트 해도 되며, 이 경우 IDE에서 code completion이 작동한다. from PySide2.QtWidgets import QApplication, QWidget, QLabel if __name__ == '__main__': 블록은 C++ 코드의 main() 함수에 대응한다. 먼저 QApplication 객체는 프로그램을 대표하는 객체이다. QWidget 객체로 최상위 창을 만들고 그 창 내부에 자식 창인 QLabel을 만든다. 최상위 창에 대한 show() 멤버를 호출하고, 최종적으로 QApplication 객체이 exec_() 멤버를 호출하여 메시지 루프를 가동하게 된다. QWidget인 QLabel 등은 위젯 객체이다. 위젯은 화면에 보이는 창을 의미하는 데 사용자 입력에 반응할 수 있다. 모든 위젯의 최상위 클래스는 QWidget이다. QLabel은 QWidget을 상속받아 만든 화면에 글자를 표시하는 기능을 가진 위젯이다. QWidget은 모든 위젯의 최상위 클래스이기도 한 동시에 그 자체로 다른 위젯을 자식 창으로 담는 기능(컨테이너 위젯)을 가지고 있다. Qt에서 위젯은 객체 간의 부모-자식 관계를 구성한다. 최상위 창은 부모 위젯이 없지만, 자식 위젯은 부모 위젯이 있어야 한다. 위에서 QLabel은 window 객체를 부모 위젯을 가지고 있다(label = QLabel('Hello Qt',window)에서 두 번째 인자는 부모 위젯 객체를 지정한 것이다). 객체 간의 부모-자식 관계가 설정되면 부모 객체가 삭제될 때 자식 객체까지 삭제되게 된다. 창의 경우에는 보이기 안 보기이가 설정 역시 별도이 설정이 없는 경우 부모가 담당한다. 즉 위 예에서 window가 삭제될 때 label도 같이 삭제되며, window가 화면에 나타나거나 안 보게 될 때 label도 같이 나타나고 안 보이게 된다. 0. 들어가기 전에에서 제시한 QT_PLUGIN_PATH 설정이 올바르게 되어야 실행 가능하다.(코드에서 반영 또는 QT_PLUGIN_PATH 환경 변수 설정). 이후 코드 모두 동일 Logon1 예제 Logon1 예제는 그림과 같이 아이디와 패스워드를 입력받는 프로그램이다. 이를 통해 레이아웃, 리소스, 시그널-슬롯, 열거 변수의 개념을 이해할 수 있다. Logon1 예제는 Logon.qrc라는 리소스 파일과 Logon1.py라는 소스로 구성되어 있다. 리소스 파일인 Logon.qrc는 xml 파일 포맷이며 여기에서 사용한 것은 다음과 같다. Logon.qrc <RCC> <qresource prefix="/"> <file>images/ok.png</file> </qresource> </RCC> 버턴 이미지 ok.png는 Logon.qrc이 있는 디렉터리 하위의 images에 있다고 가정한다 .qrc 리소스 파일을 사용하려면 아래와 같이 pyside2-rcc 유틸러티로 파이썬 파일로 변환해 준다. > pyside2-rcc -o Logon_rc.py -py3 Logon.qrc 이제 리소스 파일 원본 대신 변환된 파이썬 리소스 파일을 임포트 하여 사용하게 된다. 아래는 소스 파일이다. Logon1.py import sys from PySide2.QtWidgets import (QApplication, QWidget, QLabel, QLineEdit, QGridLayout, QPushButton, QHBoxLayout, QVBoxLayout) from PySide2.QtGui import QIcon from PySide2.QtCore import Qt #from PySide2.QtCore import SIGNAL, SLOT, QObject import Logon_rc if __name__ == '__main__': app = QApplication(sys.argv) logon = QWidget() labelId = QLabel('&Id :') labelId.setAlignment(Qt.AlignRight | Qt.AlignVCenter) labelPW = QLabel('&Password:') lineEditId = QLineEdit() lineEditPW = QLineEdit() lineEditPW.setEchoMode(QLineEdit.Password) labelId.setBuddy(lineEditId) labelPW.setBuddy(lineEditPW) buttonOk = QPushButton("&Ok") buttonOk.setIcon(QIcon(":/ok.png")) layout1 = QGridLayout() layout1.addWidget(labelId, 0,0) layout1.addWidget(lineEditId, 0,1); layout1.addWidget(labelPW, 1,0) layout1.addWidget(lineEditPW, 1,1) layout2 = QHBoxLayout() layout2.addStretch() layout2.addWidget(buttonOk) mainLayout = QVBoxLayout() mainLayout.addLayout(layout1) mainLayout.addLayout(layout2) logon.setLayout(mainLayout) logon.setWindowTitle('Log on') logon.setWindowIcon(QIcon(":/images/ok.png")) # buttonOk.clicked.connect(app.quit) logon.show() app.exec_() 코드에서 import Logon_rc는. qrc 파일을 파이썬 파일로 변환한 파일을 임포트 한 것이다. QIcon(":/images/ok.png") 등과 같이 리소스를 의미하는 : 기호와 경로를 지정하여 아이콘의 이미지로 사용할 수 있게 된다. QWidget을 컨테이너로 사용할 때 자식 위젯의 위치를 직접 계산하여 배치하는 것은 상당한 어려울 뿐만 아니라 위젯의 크기가 변경될 때 텍스트가 잘려나가는 등의 문제점이 발생한다. Qt는 레이아웃(layout) 클래스를 도입해 이 문제를 해결하고 있다. 예제에서는 QGridLayout, QHBoxLayout, QVBoxLayout이라는 레이아웃 클래스를 적용하였다. 이를 통해 아래 그림과 같이 구성되며 윈도 크기를 변경하여도 적절하게 자식 창이 배치되는 것을 알 수 있다. 코드에서 명시적으로 객체 부모-자식 관계를 설정하지 않았지만 logon.setLayout(mainLayout) 호출 시 자동으로 설정되게 된다. Qt는 어떤 객체에서 시그널을 발생시키고 이를 슬롯 함수에서 처리하는 시그널-슬롯이라는 독특한 메커니즘을 제공한다. 코드에서 buttonOk.clicked.connect(app.quit)는 Ok 버턴에 반응하여 프로그램을 종료하도록 하고 있다. QPushButton 클래스는 자신이 눌리게 되면 clicked()라는 시그널을 발생시키며, QApplication은 close()라는 슬롯 함수를 제공하는 데 이 함수는 프로그램을 종료하는 역할을 한다. 원래 C++ Qt에 따르는 예전 문법에서는 다음과 같이 QtCore에 정의된 SIGNAL(), SLOT()이라는 매크로를 사용한 것이고 코드와 같은<NAME>은 PyQt5를 흉내 내어 새롭게 도입된 방법이다. from PySide2.QtCore import SIGNAL, SLOT, QObject ... QObject.connect(buttonOk, SIGNAL('clicked()'),app, SLOT('quit()')) 시그널-슬롯은 Qt에서 제공하는 고 수준의 명령 처리 방식으로 이해할 수 있으며, 대부분 Qt 클래스의 최상위 클래스인 QObject로부터 상속받은 클래스에서 사용 가능하다. 한편, 저 수준의 명령 처리 방식으로 위젯을 대상으로 하는 메시지(이벤트)가 있다. Qt는 다양한 열거 변수를 사용한다. 공통적인 열거 변수는 QtCore.Qt에 정의되어 있으며, 개별 클래스에서도 정의되는 경우가 있다. labelId.setAlignment(Qt.AlignRight | Qt.AlignVCenter)에 사용된 AlignRight와 AlignVCenter는 전자의 예이고, lineEditPW.setEchoMode(QLineEdit.Password)의 Password는 후자의 예이다. Logon2 예제 Logon2 예제는 Logon1 예제의 구조를 변경한 예제로서 서브클래싱 과 사용자 정의 시그널 를 이해할 수 있다. Logon2.py import sys from PySide2.QtWidgets import (QApplication, QWidget, QLabel, QLineEdit, QGridLayout, QPushButton, QHBoxLayout, QVBoxLayout, QMessageBox) from PySide2.QtGui import QIcon from PySide2.QtCore import Qt, Signal import Logon_rc class Logon(QWidget): ok = Signal() def __init__(self, ids, pws, parent=None): QWidget.__init__(self, parent) self.listIds = ids self.listPWs = pws self.labelId = QLabel('&Id :') self.labelId.setAlignment(Qt.AlignRight | Qt.AlignVCenter) self.labelPW = QLabel('&Password:') self.lineEditId = QLineEdit() self.lineEditPW = QLineEdit() self.lineEditPW.setEchoMode(QLineEdit.Password) self.labelId.setBuddy(self.lineEditId) self.labelPW.setBuddy(self.lineEditPW) self.buttonOk = QPushButton("&Ok") self.buttonOk.setIcon(QIcon(":/images/ok.png")) layout1 = QGridLayout() layout1.addWidget(self.labelId, 0,0) layout1.addWidget(self.lineEditId, 0,1); layout1.addWidget(self.labelPW, 1,0) layout1.addWidget(self.lineEditPW, 1,1) layout2 = QHBoxLayout() layout2.addStretch() layout2.addWidget(self.buttonOk) mainLayout = QVBoxLayout() mainLayout.addLayout(layout1) mainLayout.addLayout(layout2) self.setLayout(mainLayout) self.setWindowTitle('Log on') self.setWindowIcon(QIcon(":/images/ok.png")) self.buttonOk.clicked.connect(self.onOk) def onOk(self): if (self.lineEditId.text() not in self.listIds): QMessageBox.critical(self,"Logon error","Unregistered user") self.lineEditId.setFocus() else: idx = self.listIds.index(self.lineEditId.text()) if self.lineEditPW.text() != self.listPWs[idx] : QMessageBox.critical(self,"Logon error","Incroreect password") self.lineEditPW.setFocus() else: self.ok.emit() if __name__ == '__main__': app = QApplication(sys.argv) ids = ['James','John','Jane'] pws = ['123','456','789'] logon = Logon(ids, pws) logon.ok.connect(app.exit) logon.show() app.exec_() 서브클래싱(subclassing)은 클래스 라이브러리에서 상속을 통해 기능을 확장하는 기법을 의미한다. Qt 역시 C++ 클래스 라이브러리이므로 이를 적극 활용하였다. Logon1 예제는 '__main__' 블록에서 서브클래싱없이 QWidget 클래스를 직접 사용했다. 반면에 Logon2는 QWidget을 서브클래싱한 Logon 클래스를 정의하고, QLabel, QLineEdit 등을 레이아웃 클래스로 배치하였다. Qt에서 객체 간의 부모-자식 관계를 구성하기 위해 보통은 생성자의 마지막 인자를 부모 객체 parent로 지정하는 규약을 관습적으로 사용한다. 따라서 Logon 클래스의 생성자는 def __init__(self, ids, pws, parent=None): 와 같이 정의하였다. Logon 클래스에 포함되는 여러 창이 다시 사용할 것을 대비하여 라인 에디트 위젯과 버턴 위젯(self.lineEditId, self.lineEditPW, self.buttonOk)을 멤버 변수로 지정한다. 반면에 다시 사용되지 않는 라벨 위젯과 레이아웃 객체는 그렇지 않다. 다만 객체 간의 부모-자식 관계는 유지되며, 부모가 자식 객체의 삭제를 책임진다. Logon 클래스는 버턴이 눌 리 때 반응하도록 새로운 시그널인 ok()를 정의하고 있다. 시그널을 정의하는 하는 것은 QtCore에 있는 Signal 클래스의 객체로 정의한 후 필요시 emit()를 호출하면 된다. 다음은 주로 사용하는 코드의 형태이다. 시그널을 갖기 위해서는 반드시 QObject로부터 상속받아야 한다. from PySide2.QtCore import Signal # Must inherit QObject for signals class Communicate(QObject): speak = Signal() def __init__(self): super(Communicate, self).__init__() self.speak.connect(self.say_hello) def speaking_method(self): self.speak.emit() def say_hello(self): print("Hello") someone = Communicate() someone.speaking_method.connect(some_slot) # 시그널-슬롯 연결 개념 잡기 Qt는 C++ 클래스 라이브러리이고, PySide2는 이에 대한 파이썬 바인딩이다. 다음은 Qt 라이브러리의 개념을 잡기 위해서 알아야 할 주요 특징들이다. QObject : Qt 라이브러리의 최상위 클래스로 (1) 객체 간의 부모-자식 관계와 (2) 시그널-슬롯 기능을 지원하기 위해 만들어졌다. 대부분의 Qt 클래스가 QObject로부터 상속받는다. 그렇지 않은 클래스는 부모-자식 관계가 없고, 시그널-슬롯을 사용할 수 없다는 것을 의미한다. QWidget : 창 클래스의 최상위 클래스. 그 자체로 다른 자식 창을 담는 컨테이너로 사용되기도 한다. 객체의 부모-자식 관계 : 앞서 설명한 것과 같다. 레이아웃 클래스 : 앞서에서 설명 시그널-슬롯 : 앞서에서 설명. 고 수준의 명령 처리로 이해할 수 있다. 서브클래싱 : 객체지향 프로그래밍에서 클래스를 확장하는 기법을 의미(Qt나 PySide2의 특징이 아닌 객체지향프로그래밍의 특징으로 Qt에서 광범위하게 사용함) 이벤트 처리 : 창에서 발생하는 다양한 메시지(이벤트) 처리. 시그널-슬로과 비교할 때 저 수준의 명령 처리이다. 보통 새로운 위젯 클래스를 구현할 때 필요하다. 예를 들어 QPushButton의 경우 clicked() 시그널에만 관심이 있을 뿐 시그널을 만들어 내는 저 수준의 마우스 이벤트나 키 이벤트를 알 필요가 없다. 하지만 QWidget을 서브클래싱하여 직접 커스텀 위젯을 작성할 때는 마우스, 키, 페인트, 타이머 이벤트 등을 사용해야 할 필요가 있다. 예를 들어 위젯에 그리기를 수행하려면 반드시 페인트 이벤트를 처리해야 한다. 열거 변수 : 앞서에서 설명 리소스 파일(.qrc 파일) : 앞서에서 설명 Ui 파일(.ui 파일) : 그래픽 하게 인터페이스를 구축할 때 사용되는 파일. Qt Designer로 만들어 낼 수 있다. 2. 위젯 기초 위젯 Qt 프로그램은 만드는 것은 위젯을 만들고 조합하는 작업이라고 할 수 있다. 사용자가 만든 위젯을 커스텀 위젯(custom widget)이라 하는데 커스텀 위젯은 서브클래싱(subclassing)을 통해 만들어 낸다. 그 방법은 다음과 같다. QWidget을 컨테이너를 사용해 다른 위젯을 그 속에 배치해서 만들거나(이 경우도 QWidget에서 상속받기 때문에 서브클래싱 범주에 들어감) 버턴, 입력, 아이템 위젯같이 Qt가 제공하는 내장 위젯(built-in widget)을 서브클래싱하거나 QWidget을 직접 서브클래싱 등의 방법을 통해 만들어 낼 수 있다. 이 중에서 (1)은 이미 Logon2 예제를 통해 만들어 보았다. 커스텀 위젯을 만드는 것은 직접 코드로 작성해도 되지만 Qt Designer로 시각적으로 폼(form)을 작성하여 쉽게 만들 수 있다. 위젯 둘러보기 QWidget의 자식 클래스로 Qt가 제공하는 다양한 위젯이 있습니다. 다음은 주요 위젯을 간단히 정리한 것이다. 버턴 버턴으로는 QPushButton, QToolButton, QCheckBox, QRadioButton 등이 있다. QPushButton이 일반 버턴이고, QCheckBox, QRadioButton은 각각 체크 버턴, 라디오 버턴이다. QToolButton은 QPushButton과 동일하지만 액션(QAction)과 연결할 수 있는 버턴으로 툴바(QToolBar)에서 주로 사용된다. 액션은 메뉴, 툴바 버턴, 키보드 단축키(shortcuts) 등을 통합해서 지원하기 위해 도입된 개념이다. (버턴 위젯) 입력 위젯과 표시 위젯 간단한 입력이 가능한 위젯으로는 QLineEdit, QComboBox, QSlider, QSpinBox 등이 흔히 사용된다. QLineEdit는 한 줄짜리 에디터 위젯이고, QComboBox는 드롭 다운 이 가능한 리스트와 한 줄 에디터 위젯이 결합된 위젯이다. 여러 줄을 편집하는 에디터 위젯으로는 QTextEdit와 QPlainTextEdit가 있습니다. QPlainTextEdit는 간단한 서식만 줄 수 있는 반면 QTextEdit는 리치 텍스트(rich text) 서식을 줄 수 있다. 표시 위젯 중에는 QLabel이 가장 흔히 사용된다. 고급 표시 위젯으로 QCalender, QWebView 등이 있다. (입력 위젯과 표시 위젯) 컨테이너 다른 위젯에 대한 컨테이너로 사용되는 QGroupBox, QTabWidget, QStackedWidget, QDockWidget, QSpliter, QScrollArea 등이 있다. QTabWidget이나 QStackWidget으로 형태가 변경되는 세련된 다이얼로그를 구성할 수 있다. (컨테이너 위젯 : 출처 ParaView) 아이템 뷰 위젯 아이템을 테이블, 리스트, 트리로 표시하는 위젯으로 QTableWidget, QListWidget, QTreeWidget 등이 있다. 또한 이들과 같은 기능을 하지만 Qt의 모델-뷰 구조를 지원하는 QTableView, QListView, QTreeView 등이 있다. (아이템 뷰) 2.1 Qt Designer 소개 Qt Designer 커스텀 위젯, 다이얼로그, 메인 윈도 등을 코드로 작성할 수도 있지만 이것은 매우 지겨운 작업이다. Qt는 Qt Designer를 통해 시각적을 쉽게 이를 수행할 수 있다. 사용하는 방법은 다음의 절차에 따른다. 시각적으로 위젯을 디자인하여 이를 XML<NAME>의. ui 파일로 저장한다. 이를 pyside2-uic 유틸러티로 .ui 파일을 파이썬 파일로 변환하여 사용된다. 변환된 파이썬 파일에 정의된 Ui_xxx 형태의 클래스를 이용하여 코드에 반영한다. Qt Designer 실행과 인터페이스 Qt Designer는 PySide2를 인스톨하면 같이 설치된다. 실행은 커맨드 프롬프트에서 다음으로 실행 가능하다. > designer 실행<NAME> 다음과 같다. 메뉴와 툴바가 있으며, 화면 중앙에 폼이 표시된다. 5개의 툴 패널이 좌우에 도킹 윈도로 있습니다. 위젯 상자(Widget Box): 적용 가능한 Qt 위젯이 있다. 위젯을 선택한 후 폼으로 드래그 드롭하면 폼에 위젯이 생성된다. 속성 편집기(Property Editor): 선택된 위젯의 속성을 설정할 수 있다. 객체 탐색기(Object Inspector): 폼의 위젯들의 부모-자식 관계를 보여 준다. 리소스 탐색기(Resource Browser): 리소스 파일을 편집할 수 있다. 동작 편집기(Action Editor): 액션(QAction)을 편집할 수 있다. 시그널/슬롯 편집기(Singal/Slot Editor): 위젯 간의 시그널-슬롯을 보여 주며 시그널-슬롯을 편집할 수 있다. Qt Designer는 다음의 4가지 모드에서 실행된다. 위젯 편집(Edit widgets): 자식 위젯을 생성하고 속성을 초기화하며, 레이아웃을 설정한다. 시그널/슬롯 편집(Edit Signals/Slots): 자식 위젯 간의 시그널/슬롯을 설정한다. 친구 편집(Edit Buddies): QLabel의 버디를 지정한다. 탭 순서 편집(Edit Tab Order): 탭 순서(탭키로 이동되는 포커스의 순서)를 설정한다. 보통은 위젯 편집(Edit widgets) 모드에서 폼을 작성하고, 작성이 끝난 후 나머지 모드로 들어가 작업을 수행한다. 4가지 모드는 메뉴바의 편집(Edit)에서 찾을 수 있다. 2.2 폼으로 작성하는 위젯 Logon3 예제는 코드로 작성한 Logon2 예제의 위젯 Logon을 Qt Designer로 작성하는 예제이다. 폼 만들기(Logon.ui 파일) images/ok.png 파일을 준비한다. Qt Designer를 실행한다(커맨드 프롬프트에서 designer 타이핑) File/New 메뉴를 선택해 표시되는 다이얼로그에서 “Widget”을 선택한다. 저장을 눌러 Logon.ui라는 이름으로 저장합니다. 속성 편집기에서 Logon 위젯에 대한 속성을 지정한다. objectName을 Logon, Window Title로는 Log on, windowIcon으로는 ok.png를 선택해 준다. ok.png를 선택하기 위해서는 리소스로 지정되어 있어야 하는 데 아래 그림의 순서로 Logon.qrc 이름으로 리소스 파일을 저장하고, ok.png 파일을 리소스로 선택 준다. Widget Box에서 Label, Line Edit, Push Button, Horizontal Spacer 등을 찾아 마우스로 드래그해서 아래 그림처럼 폼에 배치하고 폼의의 크기도 적절히 조정해 준다. 라벨과 버턴을 클릭해서 텍스트를 "&Id:", "&Password:", "&Ok"로 바꾸어 준다. 이 작업은 속성 편집기에서 text 속성으로 지정할 수도 있다. 폼 내의 위젯들은 자신의 고유 이름을 가지는데 이를 objectName이라고 한다. 필요할 경우 디폴트로 생성된 objectName 대신 의미 있는 이름으로 대체해 주어야 한다. 객체 탐색기에서 아래 그림처럼 위젯의 objectName을 변경한다. 이 작업을 Property Editor에서 objectName 속성에서 변경할 수도 있다. lineEditPW를 선택한 후 속성 편집기에서 echoMode를 Password로 설정해 주고, buttonOk를 선택하여 icon 속성에 리소스 중 ok.png로 설정해 준다. 이제 레이아웃을 설정한다. 먼저 labelId, lineEditId, labelPW, lineEditPW를 선택해 메뉴에서 Form/Layout in a Grid를 선택한다(또는 툴바의 행렬 형태이 아이콘 ). 위젯의 다중 선택은 Ctrl을 누른 채로 마우스로 선택하면 된다. 스페이서와 buttonOk를 선택해 메뉴에서 Form/Layout Horizontally를 선택한다(또는 툴바의 가로 삼선 아이콘). 폼의 바탕을 마우스로 클릭하거나 Object Inspector에서 Logon을 선택한 후 메뉴에서 Form/Layout Vertically를 선택한다(또는 툴바의 세로 삼선 아이콘). 이제 라벨의 버디를 친구 편집(Edit Buddies) 모드에서 지정하고, 탭 순서를 검토한다. 메뉴에서 “편집/친구 편집”을 선택하면 친구 편집 모드로 진입이다. labelId를 마우스로 선택하고 lineEditId로 드래그하면 아래 그림처럼 버디가 설정된다. 버디가 설정되고 나면 “&Id"가 아니라 "Id"형태로 바뀌게 된다. 동일한 작업을 labelPW와 lineEditPW에도 수행한다. 메뉴에서 Edit/Edit Tab Order를 선택해 Edit Tab Order 모드로 진입한다. 마우스를 클릭해 아래 그림처럼 순서가 되도록 한다. .ui 파일 컴파일(.ui -> .py) .ui 파일은 pyside2-uic 유틸러티로 ui_xxx.py 형태의 파이썬 파일로 변환한다. .ui 파일에서 사용된. qrc 파일 역시 pyside2-rcc을 이용해 파이썬 파일로 변환해 주어야 한다. > pyside2-uic Logon.ui > ui_logon.py > pyside2-rcc -o Logon_rc.py -py3 Logon.qrc 생성된 ui_logon.py는 다음과 같은 형태이다. ... from PySide2 import QtCore, QtGui, QtWidgets class Ui_Logon(object): def setupUi(self, Logon): ... self.labelId = QtWidgets.QLabel(Logon) self.lineEditId = QtWidgets.QLineEdit(Logon) ... QtCore.QMetaObject.connectSlotsByName(Logon) ... import Logon_rc 생성된 ui_logon.py를 보면 Ui_Logon 클래스가 자동 생성됨을 알 수 있다. 또한 import Logon_rc로 리소스 파일을 파이썬으로 변환한 파일을 사용한다. 파이썬 코드에서 사용하기 이제. ui 파일에서 생성된 Ui_Logon 클래스를 사용한다. Logon3.py import sys from PySide2.QtWidgets import (QApplication, QWidget, QLabel, QLineEdit, QGridLayout, QPushButton, QHBoxLayout, QVBoxLayout, QMessageBox) from PySide2.QtGui import QIcon from PySide2.QtCore import Qt, Signal from ui_logon import Ui_Logon class Logon(QWidget): ok = Signal() def __init__(self, ids, pws, parent=None): QWidget.__init__(self, parent) self.listIds = ids self.listPWs = pws self.ui = Ui_Logon() self.ui.setupUi(self) self.ui.buttonOk.clicked.connect(self.onOk) def onOk(self): if (self.ui.lineEditId.text() not in self.listIds): QMessageBox.critical(self,"Logon error","Unregistered user") self.ui.lineEditId.setFocus() else: idx = self.listIds.index(self.ui.lineEditId.text()) if self.ui.lineEditPW.text() != self.listPWs[idx] : QMessageBox.critical(self,"Logon error","Incroreect password") self.ui.lineEditPW.setFocus() else: self.ok.emit() if __name__ == '__main__': app = QApplication(sys.argv) ids = ['James','John','Jane'] pws = ['123','456','789'] logon = Logon(ids, pws) logon.ok.connect(app.exit) logon.show() app.exec_() 생성자에서 Ui_Logon 클래스 객체를 생성하고 setupUi(parent)를 호출한다. self.ui = Ui_Logon() self.ui.setupUi(self) Ui_Logon 클래스 내에 정의되어 있는 자식 위젯은 self.ui.buttonOk 등과 같이 접근하여 코드를 완성하면 된다. 2.3 기본 내장 위젯 - 버턴 Qt의 버턴 클래스로는 QPushButton, QCheckBox, QRadioButton, QToolButton 등이 있으며 이들은 QAbstractButton으로부터 상속받는다. QAbstractButton는 모든 버턴 클래스에서 사용할 수 있는 공통적인 함수와 시그널을 정의하고 있는데, 주요 함수로는 setText(str), setIcon(icon) 등이 있고, 시그널로는 clicked(), pressed(), released(), toggled(bool) 등이 있다. 다음은 기본 버턴인 QPushButton을 사용한 예이다. self.button = QPushButton("&Ok",self) self.button.addIcon(QIcon(":/images/apply.png") self.button.clicked.connect(self.okButtonClicked) QCheckBox에서는 clicked() 시그널보다는 toggled(bool) 시그널을 연결해 사용한다. self.button = QCheckBox("&Case Sensitivity",self) self.button.toggled.connect(onCaseSensity) QRadioButton은 서로 배타적인 선택이 가능한 버턴을 의미한다. QRadioButton은 같은 부모 객체를 갖는 라디오 버턴끼리 서로 배타적인 선택이 가능하다. 따라서 다음과 같이 별도 작업 없이 생성하는 것만으로도 배타적인 선택이 가능하다. box = QGroupBox("Sex",self) self.button1 = QRadioButton("Male",box) button2 = QRadioButton("Female",box) self.button1.toggled.connect(self.onMale) 이 코드에서 두 버턴은 QGroupBox를 같은 부모로 가지고 있으며, 서로 배타적인 선택이 된다. 또한 button1에 대해서만 toggled(bool) 시그널을 연결해 주었다. ButtonDemo 예제 이 예제는 버턴 위젯을 위한 간단한 예이다. 버턴의 시그널에 반응하는 슬롯을 정의하고 그 결과를 콘솔에 출력해 준다. ButtonDemo.py from PySide2.QtWidgets import (QApplication, QWidget, QPushButton, QCheckBox, QRadioButton, QVBoxLayout, QGroupBox) import sys class MyForm(QWidget): def __init__(self, parent=None): QWidget.__init__(self, parent) self.setWindowTitle('Button Demo') self.button = QPushButton('&Ok',self) self.button.clicked.connect(self.okButtonClicked) self.checkBox = QCheckBox('&Case sensitivity',self) self.checkBox.toggled.connect(self.onCaseSensitivity) box = QGroupBox("Sex",self) self.button1 = QRadioButton("Male",box) self.button2 = QRadioButton("Female",box) self.button1.setChecked(True) groupBoxLayout = QVBoxLayout(box) groupBoxLayout.addWidget(self.button1) groupBoxLayout.addWidget(self.button2) self.button1.toggled.connect(self.onMale) mainlayout = QVBoxLayout() mainlayout.addWidget(self.button) mainlayout.addWidget(self.checkBox) mainlayout.addWidget(box) self.setLayout(mainlayout) def okButtonClicked(self): print('okButtonClicked') def onCaseSensitivity(self, toggle): print('okCaseSensitity',toggle) print(self.checkBox.isChecked()) def onMale(self, toggle): print('onMale',toggle) if __name__ == '__main__': app = QApplication(sys.argv) form = MyForm() form.show() app.exec_() 2.4 기본 내장 위젯 - QLabel QLabel은 문자열이나 이미지를 표시하는 라벨 위젯로 보통 QLineEdit로 조합하여 이를 설명하는 텍스트 라벨로 많이 사용된다. textLabel = QLabel(self) textLabel.setText("&Name") self.lineEdit = QLineEdit(self) textLabel.setBuddy(self.lineEdit); 위 코드에서 라벨 텍스트의 &기호는 단축키에 반응하도록 한다. 라벨에 QLineEdit나 QComboBox를 지정하면 단축키가 눌릴 때 버디로 지정된 위젯이 포커스를 받게 된다. 위 코드에서는 단축키 'N'이 눌리면 self.lineEdit가 포커스가 갖는다. QLabel에 문자열을 지정할 때 간단한 HTML 구문을 사용할 수 있습니다. label = QLabel("<h2><i>Hello</i> <font color=red>Qt!</h2>",self) QLabel은 문자열을 표시하는 라벨 이외에도 이미지 라벨로 사용할 수 있다. 단순히 QLabel.setPixmap() 함수로 픽스 맵을 설정해 주면 문자열 대신 이미지가 표시됩니다. imageLabel = QLabel(self) imageLabel.setPixmap(QPixmap("./test1.png")) # 컴파일 폴더에 있는 경우 또는 imageLabel.setPixmap(QPixmap(":/image/test1.png") # 리소스에 있는 경우 QLabel의 이러한 기능을 이용하여 이미지를 보여 주는 프로그램을 손쉽게 작성할 수 있습니다. ImageViewer 여기에서는 Qt 온라인 예제 중 ImageViewer를 간단하게 수정한 예제를 통해 그림과 같은 간단한 이미지 뷰어를 만들어 본다. ImageViewer.py from PySide2.QtWidgets import (QApplication, QWidget, QVBoxLayout, QLabel, QFrame, QSizePolicy, QPushButton, QFileDialog, QMessageBox) from PySide2.QtGui import QPixmap, QImage import sys class MainWindow(QWidget): def __init__(self, parent=None): QWidget.__init__(self, parent) self.setWindowTitle('Image viewer') self.imageLabel=QLabel() self.imageLabel.setFrameStyle(QFrame.Panel | QFrame.Sunken) self.imageLabel.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored) self.imageLabel.setScaledContents(True) self.imageLabel.setPixmap(QPixmap()) openButton = QPushButton("Load image") layout = QVBoxLayout() layout.addWidget(self.imageLabel) layout.addWidget(openButton) self.setLayout(layout) openButton.clicked.connect(self.open) self.resize(QApplication.primaryScreen().availableSize()*2/5) def open(self): fileName, _ = QFileDialog.getOpenFileName(self, "Open Image File",".","Images (*.png *.xpm *.jpg)") if fileName != "": self.load(fileName) def load(self, fileName): image = QImage(fileName) if image.isNull(): QMessageBox.information(self, QApplication.applicationName(), "Cannot load "+fileName) self.setWindowTitle("Image viewer") self.setPixmap(QPixmap()) self.imageLabel.setPixmap(QPixmap.fromImage(image)) self.setWindowTitle(fileName) if __name__ == '__main__': app = QApplication(sys.argv) mainWindow = MainWindow() mainWindow.show() app.exec_() QWideget을 서브클래싱한 MainWindow에는 이미지를 표시한 QLabel 객체인 self.imageLabel, 파일 열기 버턴이 배치된다. self.imageLabel에 setPixmap(pixmap) 멤버로 픽스 맵을 지정하는데 픽스맵(QPximap 객체)은 메모리상의 이미지이다. 버턴이 눌리면 파일 이름을 알아낸 뒤 QImage 객체(파일 상의 이미지)로 변환하고 다시 메모리상의 이미지인 픽스 맵으로 변환하여 self.imageLabel에 지정하면 화면에 표시된다. QFileDialog는 파일 열기, 저장을 위한 파일 이름을 받아오는 공용 다이얼로그이다. QFileDialog.getOpenFileName(...)는 편의 함수로서 정적 클래스 멤버 함수이다. fileName, selectedFilter = QFileDialog.getOpenFileName(parent, title, dir, filters,...) QMessageBox는 화면에 간단한 메시지를 표시하는 클래스로 표시되는 메시지의 유형에 따라 information(...) , question(...) , warning(...) , critical(...) 등의 정적 클래스 멤버 함수 형태의 편의 함수가 있다. information(...)은 정보를 표시하는 용도의 메시지 박스를 보여준다. 2.5 기본 내장 위젯 - QLineEdit와 QComboBox QLineEdit QLineEdit는 한 줄짜리 에디터 위젯으로 보통 textChanged() 시그널에 커스톰 슬롯을 연결하여 사용한다. setReadOnly(bool)를 통해 읽기 전용으로 만들 수도 있으며, setEchoMode()로 패스워드 입력형태로 만들어 낼 수도 있다. setPlaceholderText()로 어떤 텍스트를 표시되게 하고 실제 입력할 때는 그 텍스트가 없어지도록(즉, 미리 사용자에게 어떤 힌트를 주는 역할을 하도록) 할 수 있다. self.lineEdit = QLineEdit(self) self.lineEdit.setReadOnly(True) self.passwordEdit = QLineEdit(self) self.passwordEdit.setPlaceholderText("Set your password") self.passwordEdit.setEchMode(QLineEdit.Password); textChanged() 시그널 이외에 많이 사용되는 시그널로 editingFinished()와 returnPressed()이다. 둘 다 리턴/엔터키를 누를 때 발생되며, editionFinished()는 포커를 잃을 때에도 발생된다. QComboBox QComboBox는 QLineEdit와 드롭 다운 리스트가 합쳐진 형태이다. QCombBox에서는 currrentIndexChanged(), editTextChanged() 시그널이 흔히 사용된다. addItem() 등으로 아이템을 추가할 수 있고, 디폴트로 에디팅이 불가능하며 보통 currentIndexChanged() 시그널로 연결하여 사용한다. 다음은 setEditable(True)를 호출해 에디팅이 가능하도록 설정한 콤보 박스이다. self.comboBox = QComboBox(self) self.comboBox.addItem("Apple") self.comboBox.addItem("StrawBerry") self.comboBox.addItem("Water Melon") self.comboBox.setEditable(True) comboBox.currentIndexChanged.connect(self.onSelected) # QComboBox.currentIndexChanged(str) -- self.onSelected(str) currentIndexChanged(int)로 전달되는 인덱스나 currentIndex() 함수로 알아낼 수 있는 인덱스는 현재 아이템의 인덱스이다. clear() 등을 수행한 후에는 -1이 된다. QComboBox의 내용이 프로그램 실행 도중 바뀌는 경우에는 clear(), addItem()을 적절해 조합하면 된다. 이 경우에는 보통 아이템의 내용에 맞도록 QComboBox의 크기를 조절할 수 있도록 한다. self.comboBox = QComboBox(self) self.comboBox.setSizeAdjustPolocy(QComboBox.AdjustToContents) self.comboBox.currentIndexChanged.connect(onComboBoxChanged) # QComboBox.currentIndexChanged(int) -- self.onComboBoxChanged(int) self.combBox.addItem("Apple") # 초기 아이템 설정 .... // 아이템이 바뀔 때 self.comboBox.clear() # 이때도 currentIndexChanged() 시그널 발생함. index = -1임에 주의 self.comboBox.addItem("Graph") ... 밸리데이터 QLineEdit와 QComboBox로 입력을 받을 때 입력이 가능한 유효 문자열을 밸리 데이터(QValidator)로 제한할 수 있다. Qt는 QIntValidator, QDoubleValidor, QRegExpValidator 등의 3 종류의 밸리 데이터 클래스가 있다. 사용하는 방법은 밸리 데이터를 생성한 후 QLineEdit나 QComboBox의 setValidator(validator) 함수를 호출해 주면 된다. 다음은 QIntValidator와 QDoubleValidator를 사용한 예이다. self.lineEdit.setValidator(QIntValidator(self)) # 정수 self.lineEdit.setValidator(QIntValidator(100,999, self)) # 100.. 999사이의 정수 self.lineEdit.setValidator(QDoubleValidator(self)) # 실수, 1.2, -1.3, 1E-2 등 가능 self.lineEdit.setValidator(QDoubleValidator(-0.1, 100, 2, self)) # -0.1, 100 사이의 실수, 2개의 소수 자릿수만 허용. QIntValidator와 QDoubleValidator는 생성자 또는 setRange() 함수로 최소, 최대, 소수점(QDoubleValidator인 경우에만)을 동시에 설정한다. 경우에 따라서 별도로 지정할 필요가 있는 데 이때는 setBottom(), setTop(), setDecimals()(QDoubleValidator인 경우에만)이다. 예를 들어 0. 이상으로 입력받기 위해서는 다음과 같습니다. validator = QDoubleValidator(self) validator.setBottom(0.) self.lineEdit.setValidator(validator) 정규식을 사용하는 QRegExpValidator는 복잡한 패턴을 지원하는 정규식 클래스 QRegExp를 이용한다. regExp = QRegExp("[A-Za-z][1-9][0-9]{0,2}") self.lineEdit.setValidator(QRegExpValidator(regExp, self)) 코드에서는 첫 번째 문자는 대소문자의 알파벳이고, 두 번째는 1-9사이의 숫자가, 이후 0-9사이의 숫자가 0개부터 2개까지 올 수 있도록 lineEdit의 입력을 제한한다는 의미이다. []로 둘러싼 부분이 하나의 문자를 의미하고 {}는 범위를 지정하는 데 사용된다. 다음은 간단한 QRegExp의 예이다. regExp = QRegExp(“[A-Za-z]*") # 알파벳만 임의의 개수만큼 가능 regExp = QRegExp("[0-9]*") # 숫자만 임의의 개수만큼 가능 regExp = QRegExp("[A-Za-z0-9]*") # 알파벳과 숫자만 임의의 개수만큼 가능 *는 {}와 달리 임의 개수가 가능한 것을 알리기 위해 사용되었다. QLineEdit나 QComboBox에 밸리 데이터를 지정하는 것은 Qt Designer에서 수행할 수 없기 때문에 직접 코드로 작성해 주어야 한다. 2.6 기본 내장 위젯 - QSpinBox, QSlider, QProgressBar QSpinBox는 스핀 박스를, QSlider는 수평 또는 수직 슬라이더를, QProgressBar는 진행사항을 나타내는 데 사용된다. QSpinBox QSpinBox는 setRange(int, int)로 범위로 지정한다. setSuffix(str)으로 접두어를 붙일 수 있고, setSingStep(int)으로 스텝 사이즈를 지정할 수 있다. setValue(int)로 값을 지정할 수 있으며, value()로 값을 얻어낸다. setValue(int)는 슬롯 함수이며, 대표적인 시그널은 valueChanged(int)이다. 다음은 QSpinBox를 생성한 일반적인 코드이다. spin = QSpinBox(self) self.spin.setRange(20,30) self.spin.setSuffix(" km") self.spin.setSingleStep(2) self.spin.setValue(24) self.spin.valueChanged.connect(self.do_something) QSlider QSlider는 생성자에서 가로 세로 배치 형상을 Qt.Orientation 상수(Qt.Horizontal 또는 Qt.Vertical)에 담아 생성할 수 있다. self.slider = QSlider(Qt.Horizontal, this); self.slider = QSlider(self); // QSlider(Qt.Vertical, self)와 동일 QSlider의 주요 함수들은 QSpinBox와 아주 유사한데 setRange(min, max), setSingleStep(int), setValue(int), value(), valueChanged(int) 등이 동일한 의미로 사용된다. QProgressBar QProgressBar는 보통 긴 작업을 수행할 때 진행 상황을 표시하기 위해 사용되는데 QSlider와 개념이 같지만 위젯 스스로 입력을 받지 못한다. 범위는 setRange(min, max)로, 수평 또는 수직 배치 형상은 setOrientation(orient)로, 정렬은 setAlignment(alignment)를 사용한다. setFormat(format)을 이용해 표시되는 텍스트의 포맷을 정의할 수 있다. setValue(int) 슬롯 함수를 이용해 현재의 값을 설정한다. self.progressBar = QProgressBar(self) self.progressBar.setOrientation(Qt.Vertical) # 디폴트가 Qt.Horizontal self.progressBar.setAlignment(Qt.AlignCenter) # 중간에 표시되는 텍트가 중앙에 나타남 self.progressBar.setRange(0,100) self.progressBar.setFormat("%v km") # 10 km 형태로 표시, 디폴트는 %p self.someSignal.connect(self.progressBar.setValue) setFormat(format)에서 fomat을 문자열로 지정할 때는 %p, %v, %m를 이용하는데, 각각 주어진 범위에 대한 퍼센트, 실제 값, 스텝 수를 대표한다. SpinSliderProgressDemo SpinSliderProgressDemo는 세 위젯을 조합하여 만든 간단한 예이다. QSpin과 QSlider에 값을 변경하면 나머지 위젯까지 값이 변경되도록 시그널/슬롯 연결을 하였다. 소스 코드는 다음과 같다. SpinSliderProgressDemo.py import sys from PySide2.QtWidgets import (QApplication, QWidget, QSpinBox, QSlider, QProgressBar, QHBoxLayout) from PySide2.QtCore import Qt if __name__ == '__main__': app = QApplication(sys.argv) form = QWidget() spin = QSpinBox() spin.setRange(0,100) slider = QSlider(Qt.Horizontal) slider.setRange(0,100) progressBar = QProgressBar() progressBar.setAlignment(Qt.AlignCenter) progressBar.setRange(0,100) spin.valueChanged.connect(slider.setValue) # valuChanged(int), setValue(int) slider.valueChanged.connect(spin.setValue) spin.valueChanged.connect(progressBar.setValue) layout = QHBoxLayout() layout.addWidget(spin) layout.addWidget(slider) layout.addWidget(progressBar) form.setLayout(layout) form.setWindowTitle('SpinSliderProgressDemo') form.show() app.exec_() 2.7 기본 내장 위젯 - QGroupBox와 QFrame QGroupBox QGroupBox는 다른 위젯을 묶어 주는 역할을 하는 일종의 컨테이너 위젯이다. 그룹 박스 내에 들어가는 위젯은 그룹 박스의 자식 위젯으로 설정하고, 레이아웃 클래스로 자식 위젯을 배치해 준다. 따라서 그룹 박스의 보이기 상태(show 또는 hide), 활성화 상태(enabled/disabled)가 그룹 박스 내의 모든 위젯에 적용된다. self.appleCheckBox = QCheckBox("apple") self.grapeCheckBox = QCheckBox("grape") layout = QVBoxLayout() layout.addWidget(appleCheckBox) layout.addWidget(grapeCheckBox) self.groupBox = QGroupBox("title",self) self.groupBox.setLayout(layout) # appleCheckBox, grapeCheckBox는 자식 위젯이 됩 한편 그룹 박스는 setCheckable(True)로 체크 가능하도록 설정할 수 있으며, 이 경우 setChecked(bool) 슬롯과 toggled(bool) 시그널을 사용할 수 있다. 또한 체크가 된 상태이면 그룹 박스가 활성화(enabled) 되지만, 체가가 해제되면 그룹 박스가 비활성화(disabled) 된다. 이때 그룹 박스 내의 모든 자식 위젯도 부모-자식 관계로부터 활성/비활성화된다. QFrame QFrame은 프레임을 부과된 QWidget이라고 생각할 수 있다. QMenu, QLabel, QTextEdit 등 프레임이 있는 위젯들은 QFrame의 자식 클래스이다. 직접 QFrame을 QWidget처럼 컨테이너로 사용하기도 한다. setFrameStyle()이나 setLineWidth() 등이 흔히 사용되는 메쏘드이다. ImageViewer 예제에서 QLabel 클래스를 대상으로 setFrameStyle()을 사용한 적이 있다. QLabel은 QFrame의 자식 위젯인데, QFrame은 QWidget의 자식 클래스로 프레임이 있는 QWidget 정도로 이해할 수 있다. 컨테이너로 사용할 때는 직접 코딩에서 사용하기보다는 Qt Designer에서 사용하는 것이 쉽다. 2.8 내장 위젯 서브클래싱 커스텀 위젯은 Qt가 제공하는 내장 위젯(built-in widget)을 서브클래싱해서 작성할 수도 있다. 이번 절에서는 QLineEdit를 서브클래싱하여 포커스를 가질 때 배경색이 바뀌는 위젯을 만들어 봅니다. 예제 프로그램 명칭은 LineEdit이다. LineEdit.py from PySide2.QtWidgets import QApplication, QLineEdit, QWidget, QVBoxLayout from PySide2.QtGui import QPalette, QColor import sys class LineEdit(QLineEdit): def __init__(self, parent=None): QLineEdit.__init__(self, parent) self.clearOnFocus = False self.originalPalette = self.palette() self.newPalette = QPalette(self.palette()) # copy constructor self.newPalette.setColor(QPalette.Normal, QPalette.Base, QColor(200,255,125)) def setColorOnFocus(self, color): self.newPalette.setColor(QPalette.Normal, QPalette.Base, color) def setClearOnFocus(self, clear): self.clearOnFocus = clear def focusInEvent(self, e): self.setPalette(self.newPalette) if self.clearOnFocus : self.clear() QLineEdit.focusInEvent(self, e) def focusOutEvent(self, e): self.setPalette(self.originalPalette) QLineEdit.focusOutEvent(self, e) if __name__ == '__main__': app = QApplication(sys.argv) mainWindow = QWidget() lineEditId = LineEdit(mainWindow) lineEditPW = LineEdit(mainWindow) lineEditPW.setEchoMode(QLineEdit.Password) lineEditPW.setClearOnFocus(True) layout = QVBoxLayout() layout.addWidget(lineEditId) layout.addWidget(lineEditPW) mainWindow.setLayout(layout) mainWindow.setWindowTitle("Line Edit") mainWindow.show() app.exec_() LineEdit 클래스는 QLinEdit를 서브클래싱하였다. 라인 에디트 위젯은 포커스를 가지면 배경 색상이 연녹색으로 바뀌고, 잃으면 원래 색상으로 변경된다. 위젯의 배경 색상은 QPalette로 표현되는 팔레트를 변경하는 것으로 변경할 수 있다. 생성자에서 원래의 팔레트를 저장하고, 포커스를 얻고 잃을 때 팔레트를 스위칭 해준다. focusInEvent(self, event), focusOutEvent(self, event)는 포커스를 얻고 잃을 때 발생되는 이벤트에 반응하는 이벤트 핸들러이다. 이벤트 핸들러 내에서 팔레트를 변경하는 작업을 수행한 후 자신의 부모 클래스인 QLineEdit의 이벤트 핸들러를 호출하여 원래 처리해야 할 작업이 정상적으로 처리될 수 있도록 한다. 3. 다이얼로그 다이얼로그는 QWidget의 자식 클래스인 QDialog로 추상화되어 있다. 다이얼로그를 만든다는 것은 QDialog를 서브클래싱한 커스텀 다이얼로그에 자식 위젯을 배치하는 것이라고 할 수 있다. 다시 말하면 QWidget에 자식 위젯을 배치하여 커스텀 위젯을 만든 것과 동일한 방식으로 다이얼로그를 만들어 낼 수 있다. 역시 코드로 만들 수도 있고, Qt Designer로 폼(form)을 만들어 이용할 수 있다. QWidget을 부모 클래스로 가지는 일반 위젯은 다른 위젯의 구성요소로 포함될 수 있고, 그 위젯 위에 항상 붙어 있게 e 된다. 반면에 QDialog를 부모 클래스로 하는 다이얼로그는 부모 위젯이 있더라도 항상 팝업 되어 나타내고, 다른 위젯의 구성요소로 포함될 수 없다. 정리하면 QWidget을 상속하여 만든 위젯은 일종의 기본 블록(building block)이고, 다이얼로그는 사용자와 상호작용하는 하나의 독립된 단위이다. 다이얼로그는 사용하는 방식에 따라 모달(modal) 또는 모덜리스(modeless) 다이얼로그로 구분된다. 모달 다이얼로그는 다이얼로그가 활성화된 후 닫을 때까지 다른 작업을 수행할 수 없는 다이얼로그이다. 모덜리스 다이얼로그는 활성화한 채로 다른 작업을 수행할 수 있는 다이얼로그이다. 텍스트 편집 프로그램에 있는 파일 열기 다이얼로그가 모달 다이얼로그의 대표적인 예이고, 찾기 다이얼로그가 모달리스 다이얼로그의 대표적인 예이다. 다이얼로그를 설계할 때 모달이냐 모달리스냐에 따라 차이가 나기 때문에 이 부분을 처음부터 염두에 두고 설계해야 한다. 3.1 모달 다이얼로그 모달(modal) 다이얼로그는 다이얼로그가 활성화된 후 닫을 때까지 다른 작업을 수행할 수 없는 다이얼로그로 보통 Ok, Cancel 버턴을 가진다. Ok 버턴에서는 QDialog에서 제공하는 accept() 슬롯을 연결하고, Cancel 버턴에서는 reject() 슬롯을 연결하여 제작된다. 다이얼로그를 호출하는 것은 QDialog.exec_() 함수를 호출하고, 수행이 끝난 후 다이얼로그로부터 정보를 읽어들이는 방식으로 코드를 작성한다. class MyDialog(QDialog): def __init__(self, parent=None): QDialog.__init__(self, parent) # 또는 super().__init__(parent) # okButton, cancelButton 생성 ... okButton.clicked.connect(self.accept) # accept() 슬롯에 연결 cancelButton.clicked.connect(self.reject) # reject() 슬롯에 연결 ... # 사용하는 쪽 myDialog = MyDialog(self) if myDialog.exec_(): ... # okButton 이 눌릴 때의 처리 else: .... # cancelButton이 눌릴 때의 처리 다이얼로그는 코드를 통해 작성하는 방식과 Qt Designer를 이용한 폼을 이용하는 두 가지 방식으로 작성할 수 있다. GridDialog1 그림과 같은 GridDialog라는 커스텀 모달 다이얼로그를 작성해 보고, 모달 다이얼로그를 호출해 사용하는 방법을 다루기로 한다. 그림에서 메뉴를 선택하면 GridDialog가 나타나고 Ok를 선택하면 화면에 선택된 옵션들이 나타난다. 이미지 준비 (images 디렉터리에 ok.png, cancel.png) 리소스 파일 GridDialog.rc <RCC> <qresource prefix="/"> <file>images/ok.png</file> </qresource> </RCC> 리소스 컴파일 > pyside2-rcc -o GridDialog_rc.py -py3 GridDialog.qrc 다음은 코드이다. GridDialog1.py from PySide2.QtWidgets import (QApplication, QMainWindow, QTextEdit, QAction, QMenu, QMenuBar, QDialog, QLabel, QLineEdit, QGroupBox, QCheckBox, QPushButton, QGridLayout, QHBoxLayout, QVBoxLayout) from PySide2.QtGui import QIcon, QDoubleValidator import GridDialog_rc import sys class GridDialog(QDialog): def __init__(self, x, y, useGrid, useSnap, parent): QDialog.__init__(self, parent) xLabel = QLabel("&X:") yLabel = QLabel("&Y:") self.xLineEdit = QLineEdit(str(x)) self.yLineEdit = QLineEdit(str(y)) xLabel.setBuddy(self.xLineEdit) yLabel.setBuddy(self.yLineEdit) validator = QDoubleValidator(self) validator.setBottom(0.) self.xLineEdit.setValidator(validator) self.yLineEdit.setValidator(validator) self.useGridGroupBox = QGroupBox("Use &Grid") self.useGridGroupBox.setCheckable(True) self.useGridGroupBox.setChecked(useGrid) self.useSnapCheckBox = QCheckBox("Use &Snap") self.useSnapCheckBox.setChecked(useSnap) self.useSnapCheckBox.setEnabled(useGrid) okButton = QPushButton("&Ok") okButton.setIcon(QIcon(":/ok.png")) okButton.setDefault(True) cancelButton = QPushButton("&Cancel") cancelButton.setIcon(QIcon(":/cancel.png")) gridLayout = QGridLayout() gridLayout.addWidget(xLabel, 0,0) gridLayout.addWidget(self.xLineEdit, 0,1) gridLayout.addWidget(yLabel, 1,0) gridLayout.addWidget(self.yLineEdit, 1,1) self.useGridGroupBox.setLayout(gridLayout) buttonLayout = QHBoxLayout() buttonLayout.addWidget(okButton) buttonLayout.addWidget(cancelButton) mainLayout = QVBoxLayout() mainLayout.addWidget(self.useGridGroupBox) mainLayout.addWidget(self.useSnapCheckBox) mainLayout.addLayout(buttonLayout) self.setLayout(mainLayout) self.setWindowTitle('Set Grid') # toggled(bool) - setEnabled(bool) self.useGridGroupBox.toggled.connect(self.useSnapCheckBox.setEnabled) okButton.clicked.connect(self.accept) # clicked() - accept() cancelButton.clicked.connect(self.reject) # clicked() - reject() def gridInfo(self): x = float(self.xLineEdit.text()) y = float(self.yLineEdit.text()) useGrid = self.useGridGroupBox.isChecked() useSnap = self.useSnapCheckBox.isChecked() return (x, y, useGrid, useSnap) class MainWindow(QMainWindow): def __init__(self, parent=None): QMainWindow.__init__(self, parent) self.textEdit = QTextEdit() self.setCentralWidget(self.textEdit) action = QAction('set grid',self) action.triggered.connect(self.setGrid) myMenu = self.menuBar().addMenu("&action") myMenu.addAction(action) self.x = 10 self.y = 10 self.useGrid = True self.useSnap = False def setGrid(self): gridDialog = GridDialog(self.x, self.y, self.useGrid, self.useSnap, self) if gridDialog.exec(): self.x, self.y, self.useGrid, self.useSnap = gridDialog.gridInfo() log = "Ok : useGrid ="+str(self.useGrid) + \ ", useSnap = " + str(self.useSnap) + \ ", x= " + str(self.x) + ", y = " + str(self.y) self.textEdit.append(log) else: self.textEdit.append("Cancel") if __name__ == '__main__': app = QApplication(sys.argv) mainWindow = MainWindow() mainWindow.resize(400,300) mainWindow.show() mainWindow.setWindowTitle("Test GridDialog") mainWindow.show() app.exec_() 메인 윈도 클래스(QMainWndow)는 중앙 위젯(centralWidget)을 가지고, 사용자 입력을 위해 메뉴, 툴바, 상태 바 등을 갖는 메인 창을 위한 클래스이다. QMainWindow.setCentralWidget(widget)을 통해 중앙 위젯을 등록한다. Qt는 메뉴, 툴바, 키보드 단축키(shortcuts)을 통합해서 선택 등에 대해서 작업할 수 있도록 액션(QAction)을 도입하였다. 액션을 대상으로 액션이 선택될 때 triggered()라는 시그널이 발생하므로, 작업 처리를 위한 슬롯 함수를 연결하여 액션에 반응한 코드를 작성한다. 예를 들어 메뉴를 구성하는 경우 각 메뉴 아이템에 대한 액션을 생성하고 시그널-슬롯을 연결한 후 이를 메뉴에 추가하면 된다. 자세한 사항은 4.1 액션, 메뉴, 상태 바에 설명되어 있다. 3.2 폼으로 작성하는 모달 다이얼로그 앞서의 GridDialog1과 동일한 예제를 Qt Designer로 폼으로 만든 후 작성할 수 있다. GridDialog2 먼저 아래와 같이 Qt Deginer와 GridDialog.ui를 준비한다. 아래와 같이 리소스와 ui를 파이썬 파일로 변환한다. > pyside2-rcc -o GridDialog_rc.py -py3 GridDialog.qrc > pyside2-uic GridDialog.ui > ui_girddialog.py 소스 코드는 다음과 같다. GridDialog2.py ... 앞서와 동일 import GridDialog_rc from ui_griddialog import Ui_GridDialog class GridDialog(QDialog): def __init__(self, x, y, useGrid, useSnap, parent): QDialog.__init__(self, parent) self.ui = Ui_GridDialog() self.ui.setupUi(self) self.ui.xLineEdit.setText(str(x)) self.ui.yLineEdit.setText(str(y)) validator = QDoubleValidator(self) validator.setBottom(0.) self.ui.xLineEdit.setValidator(validator) self.ui.yLineEdit.setValidator(validator) self.ui.useGridGroupBox.setChecked(useGrid) self.ui.useSnapCheckBox.setChecked(useSnap) self.ui.useSnapCheckBox.setEnabled(useGrid) def gridInfo(self): x = float(self.ui.xLineEdit.text()) y = float(self.ui.yLineEdit.text()) useGrid = self.ui.useGridGroupBox.isChecked() useSnap = self.ui.useSnapCheckBox.isChecked() return (x, y, useGrid, useSnap) class MainWindow(QMainWindow): ... 앞서와 동일 if __name__ == '__main__': ... 앞서와 동일 3.3 모덜리스 다이얼로그 모달리스(modeless) 다이얼로그는 다이얼로그가 떠있는 상태에서 다른 작업을 할 수 있는 다이얼로그이다. Ok, Cancel 버턴을 가지는 모달 다이얼로그와 달리 Close 버턴으로 다이얼로그를 닫도록 설계되며 다른 버턴이나 위젯에 대한 반응으로 즉시 작업을 수행하도록 설계한다. FindReplaceDialog1 여기에서 FindReplaceDialog1 예제는 코드로만 작성한 것이고, FindReplaceDialog2는 폼으로 작성한 예제이다. 이미지(find.png)와 리소스 파일(FindReplaceDialog.qrc)을 준비한다. <RCC> <qresource prefix="/"> <file>images/find.png</file> </qresource> </RCC> >pyside2-rcc -o FindReplaceDialog_rc.py -py3 FindReplaceDialog.qrc if __name__ == '__main__': from PySide2.QtCore import QCoreApplication QCoreApplication.setLibraryPaths(['C:\ProgramData\Anaconda3\Lib\site-packages\PySide2\plugins']) from PySide2.QtWidgets import QApplication, QMainWindow, QTextEdit, QAction import sys from PySide2.QtWidgets import (QDialog, QLabel, QComboBox, QPushButton, QGroupBox, QCheckBox, QGridLayout, QVBoxLayout, QHBoxLayout) from PySide2.QtGui import QIcon from PySide2.QtCore import Signal import FindReplaceDialog_rc class FindReplaceDialog(QDialog): find = Signal(str, bool, bool, bool) # find(findText, matchWholeWord, matchCase, upward) replace = Signal(str, str, bool, bool, bool) # replace(findText, replaceText, matchWoleWord, matchCase, upward) replaceAll = Signal(str, str, bool, bool, bool) # replaceAll(findText, replaceText, matchWoleWord, matchCase, upward) def __init__(self, parent=None): QDialog.__init__(self, parent) self.setWindowTitle("Find/Replace..."); self.setWindowIcon(QIcon(":images/find.png")); # widget and layout self.findLabel = QLabel("&Option") self.replaceLabel = QLabel("Re&place with: ") self.findComboBox = QComboBox() self.replaceComboBox = QComboBox() self.optionGroupBox = QGroupBox("&Option") self.wordCheckBox = QCheckBox("Match whole word") self.caseCheckBox = QCheckBox("Match case") self.upwardCheckBox = QCheckBox("Upward") self.findButton = QPushButton("&Find") self.replaceButton = QPushButton("&Replace") self.replaceAllButton = QPushButton("Replace &All") self.closeButton = QPushButton("&Close") formLayout = QGridLayout() formLayout.addWidget(self.findLabel, 0,0) formLayout.addWidget(self.findComboBox, 0,1) formLayout.addWidget(self.replaceLabel, 1,0) formLayout.addWidget(self.replaceComboBox, 1,1) groupBoxLayout = QVBoxLayout() groupBoxLayout.addWidget(self.wordCheckBox) groupBoxLayout.addWidget(self.caseCheckBox) groupBoxLayout.addWidget(self.upwardCheckBox) self.optionGroupBox.setLayout(groupBoxLayout) leftLayout = QVBoxLayout() leftLayout.addLayout(formLayout) leftLayout.addWidget(self.optionGroupBox) rightLayout = QVBoxLayout() rightLayout.addWidget(self.findButton) rightLayout.addWidget(self.replaceButton) rightLayout.addWidget(self.replaceAllButton) rightLayout.addWidget(self.closeButton) rightLayout.addStretch() mainLayout = QHBoxLayout() mainLayout.addLayout(leftLayout) mainLayout.addLayout(rightLayout) self.setLayout(mainLayout) # some stuffs for child widget self.findLabel.setBuddy(self.findComboBox) self.replaceLabel.setBuddy(self.replaceComboBox) self.findComboBox.setMinimumWidth(160) self.findComboBox.setEditable(True) self.replaceComboBox.setEditable(True) self.findButton.setDefault(True) self.findButton.setEnabled(False) self.replaceButton.setEnabled(False) self.replaceAllButton.setEnabled(False) # signal slot self.closeButton.clicked.connect(self.close) self.findComboBox.editTextChanged.connect(self.enableButtons) self.findComboBox.currentIndexChanged.connect(self.enableButtons) self.replaceComboBox.editTextChanged.connect(self.enableButtons) self.replaceComboBox.currentIndexChanged.connect(self.enableButtons) self.findButton.clicked.connect(self.onFind) self.replaceButton.clicked.connect(self.onReplace) self.replaceAllButton.clicked.connect(self.onReplaceAll) def enableButtons(self): findText = self.findComboBox.currentText() if findText != '': self.findButton.setEnabled(True) replaceText = self.replaceComboBox.currentText() if findText != "" and replaceText != "": self.replaceButton.setEnabled(True) self.replaceAllButton.setEnabled(True) def onFind(self): findText = self.findComboBox.currentText() matchWholeWord = self.wordCheckBox.isChecked() matchCase = self.caseCheckBox.isChecked() upward = self.upwardCheckBox.isChecked() index = self.findComboBox.findText(findText) if index != 1: self.findComboBox.removeItem(index) self.findComboBox.insertItem(0, findText) self.findComboBox.setCurrentIndex(0) self.find.emit(findText, matchWholeWord, matchCase, upward) def onReplace(self): findText = self.findComboBox.currentText() replaceText = self.replaceComboBox.currentText() matchWholeWord = self.wordCheckBox.isChecked() matchCase = self.caseCheckBox.isChecked() upward = self.upwardCheckBox.isChecked() index = self.findComboBox.findText(findText) if index != 1: self.findComboBox.removeItem(index) self.findComboBox.insertItem(0, findText) self.findComboBox.setCurrentIndex(0) index = self.replaceComboBox.findText(replaceText) if index != 1: self.replaceComboBox.removeItem(index) self.replaceComboBox.insertItem(0, replaceText) self.replaceComboBox.setCurrentIndex(0) self.replace.emit(findText, replaceText, matchWholeWord, matchCase, upward) def onReplaceAll(self): findText = self.findComboBox.currentText() replaceText = self.replaceComboBox.currentText() matchWholeWord = self.wordCheckBox.isChecked() matchCase = self.caseCheckBox.isChecked() upward = self.upwardCheckBox.isChecked() index = self.findComboBox.findText(findText) if index != 1: self.findComboBox.removeItem(index) self.findComboBox.insertItem(0, findText) self.findComboBox.setCurrentIndex(0) index = self.replaceComboBox.findText(replaceText) if index != 1: self.replaceComboBox.removeItem(index) self.replaceComboBox.insertItem(0, replaceText) self.replaceComboBox.setCurrentIndex(0) self.replaceAll.emit(findText, replaceText, matchWholeWord, matchCase, upward) class MainWindow(QMainWindow): def __init__(self, parent=None): QMainWindow.__init__(self, parent) self.textEdit = QTextEdit() self.setCentralWidget(self.textEdit) action = QAction("Test",self) action.triggered.connect(self.findReplace) myMenu = self.menuBar().addMenu("&Test") myMenu.addAction(action) self.findReplaceDialog = None def findReplace(self): if self.findReplaceDialog is None: self.findReplaceDialog = FindReplaceDialog() self.findReplaceDialog.find.connect(self.find) self.findReplaceDialog.replace.connect(self.replace) self.findReplaceDialog.replaceAll.connect(self.replaceAll) self.findReplaceDialog.show() self.findReplaceDialog.raise_() # Note raise_() not raise() self.findReplaceDialog.activateWindow() def find(self, findText, matchWholeWord, matchCase, upward): log = "Find operation " + findText + \ "\nMatchWoleWord : " + str(matchWholeWord) + \ "\nMatchCase : " + str(matchCase) + \ "\nUpward : " + str(upward) self.textEdit.append(log) def replace(self, findText, replaceText, matchWholeWord, matchCase, upward): log = "Replace operation " + findText + " " + replaceText + \ "\nMatchWoleWord : " + str(matchWholeWord) + \ "\nMatchCase : " + str(matchCase) + \ "\nUpward : " + str(upward) self.textEdit.append(log) def replaceAll(self, findText, replaceText, matchWholeWord, matchCase, upward): log = "ReplaceAll operation " + findText + " " + replaceText + \ "\nMatchWoleWord : " + str(matchWholeWord) + \ "\nMatchCase : " + str(matchCase) + \ "\nUpward : " + str(upward) self.textEdit.append(log) if __name__ == '__main__': app = QApplication(sys.argv) mainWindow = MainWindow() mainWindow.show() app.exec_() 3.5 폼으로 작성하는 모덜리스 다이얼로그 앞서의 GridDialog1과 동일한 예제를 Qt Designer로 폼으로 만든 후 작성할 수 있다. FindReplaceDialog2 먼저 아래와 같이 Qt Deginer와 GridDialog.ui를 준비한다. 아래와 같이 리소스와 ui를 파이썬 파일로 변환한다. > pyside2-rcc -o FindReplaceDialog_rc.py -py3 FindReplaceDialog.qrc > pyside2-uic FindReplaceDialog.ui > ui_findreplacedialog.py 소스 코드는 다음과 같다. FindReplaceDialog2.py if __name__ == '__main__': from PySide2.QtCore import QCoreApplication QCoreApplication.setLibraryPaths(['C:\ProgramData\Anaconda3\Lib\site-packages\PySide2\plugins']) from PySide2.QtWidgets import QApplication, QMainWindow, QTextEdit, QAction import sys from PySide2.QtWidgets import QDialog from PySide2.QtGui import QIcon from PySide2.QtCore import Signal from ui_findreplacedialog import Ui_FindReplaceDialog class FindReplaceDialog(QDialog): find = Signal(str, bool, bool, bool) # find(findText, matchWholeWord, matchCase, upward) replace = Signal(str, str, bool, bool, bool) # replace(findText, replaceText, matchWoleWord, matchCase, upward) replaceAll = Signal(str, str, bool, bool, bool) # replaceAll(findText, replaceText, matchWoleWord, matchCase, upward) def __init__(self, parent=None): QDialog.__init__(self, parent) self.setWindowTitle("Find/Replace..."); self.setWindowIcon(QIcon(":images/find.png")); self.ui = Ui_FindReplaceDialog() self.ui.setupUi(self) # some stuffs for child widget self.ui.findButton.setEnabled(False) self.ui.replaceButton.setEnabled(False) self.ui.replaceAllButton.setEnabled(False) # signal slot self.ui.closeButton.clicked.connect(self.close) self.ui.findComboBox.editTextChanged.connect(self.enableButtons) self.ui.findComboBox.currentIndexChanged.connect(self.enableButtons) self.ui.replaceComboBox.editTextChanged.connect(self.enableButtons) self.ui.replaceComboBox.currentIndexChanged.connect(self.enableButtons) self.ui.findButton.clicked.connect(self.onFind) self.ui.replaceButton.clicked.connect(self.onReplace) self.ui.replaceAllButton.clicked.connect(self.onReplaceAll) def enableButtons(self): findText = self.ui.findComboBox.currentText() if findText != '': self.ui.findButton.setEnabled(True) replaceText = self.ui.replaceComboBox.currentText() if findText != "" and replaceText != "": self.ui.replaceButton.setEnabled(True) self.ui.replaceAllButton.setEnabled(True) def onFind(self): findText = self.ui.findComboBox.currentText() matchWholeWord = self.ui.wordCheckBox.isChecked() matchCase = self.ui.caseCheckBox.isChecked() upward = self.ui.upwardCheckBox.isChecked() index = self.ui.findComboBox.findText(findText) if index != 1: self.ui.findComboBox.removeItem(index) self.ui.findComboBox.insertItem(0, findText) self.ui.findComboBox.setCurrentIndex(0) self.find.emit(findText, matchWholeWord, matchCase, upward) def onReplace(self): findText = self.ui.findComboBox.currentText() replaceText = self.ui.replaceComboBox.currentText() matchWholeWord = self.ui.wordCheckBox.isChecked() matchCase = self.ui.caseCheckBox.isChecked() upward = self.ui.upwardCheckBox.isChecked() index = self.ui.findComboBox.findText(findText) if index != 1: self.ui.findComboBox.removeItem(index) self.ui.findComboBox.insertItem(0, findText) self.ui.findComboBox.setCurrentIndex(0) index = self.ui.replaceComboBox.findText(replaceText) if index != 1: self.ui.replaceComboBox.removeItem(index) self.ui.replaceComboBox.insertItem(0, replaceText) self.ui.replaceComboBox.setCurrentIndex(0) self.replace.emit(findText, replaceText, matchWholeWord, matchCase, upward) def onReplaceAll(self): findText = self.ui.findComboBox.currentText() replaceText = self.ui.replaceComboBox.currentText() matchWholeWord = self.ui.wordCheckBox.isChecked() matchCase = self.ui.caseCheckBox.isChecked() upward = self.ui.upwardCheckBox.isChecked() index = self.ui.findComboBox.findText(findText) if index != 1: self.ui.findComboBox.removeItem(index) self.ui.findComboBox.insertItem(0, findText) self.ui.findComboBox.setCurrentIndex(0) index = self.ui.replaceComboBox.findText(replaceText) if index != 1: self.ui.replaceComboBox.removeItem(index) self.ui.replaceComboBox.insertItem(0, replaceText) self.ui.replaceComboBox.setCurrentIndex(0) self.replaceAll.emit(findText, replaceText, matchWholeWord, matchCase, upward) class MainWindow(QMainWindow): ... 앞서와 동일 if __name__ == '__main__': ... 앞서와 동일 3.6 표준 다이얼로그 Qt에서는 표준 다이얼로그(standard dialog) 또는 내장 다이얼로그(built-in dialog)라고 불리는 흔히 사용되는 몇몇<NAME>의 다이얼로그를 제공한다. 아래 표는 Qt에서 제공하는 표준 다이얼로그를 나열한 것으로 모두 QDialog를 상속하여 구현되었다. 표준 다이얼로그 중 QInputDialog, QMessageBox, QErrorMessage, QProgressDialog는 사용자에게 간단한 메시지나 정보를 알려주고, 그 응답을 받는 역할을 하기 때문에 피드백 다이얼로그(feedback dialog)라고 한다 반면에, QFileDialog, QColorDialog, QFontDialog, QPageSetupDialog, QPrintDialog, QPrintPreviewDialog는 시스템 차원에서 지원하는 다이얼로그이기 때문에 공용 다이얼로그(common dialog)로 분류된다. QErrorMessage와 QProcessDialog만 모덜리스 다이얼로그로 사용되고, 나머지 표준 다이얼로그는 모달 다이얼로그로 사용되는 특징이 있다. 한편, 프린터와 관련된 QPrintDialog, QPageSetupDialog, QPrintPreviewDialog는 Qt Print Support 모듈이고, 나머지는 모두 Qt Widgets 모듈에 속한다. 3.7 표준 다이얼로그 - 피드백 다이얼로그 Qt에서는 표준 다이얼로그(standard dialog) 또는 내장 다이얼로그(built-in dialog)라고 불리는 흔히 사용되는 몇몇<NAME>의 다이얼로그를 제공한다. 아래 표는 Qt에서 제공하는 표준 다이얼로그를 나열한 것으로 모두 QDialog를 상속하여 구현되었다. FeedbackDlgDemo.py from PySide2.QtWidgets import (QApplication, QMainWindow, QTextEdit, QAction, QErrorMessage, QInputDialog, QLineEdit, QMessageBox,) import sys class MainWindow(QMainWindow): def __init__(self, parent=None): QMainWindow.__init__(self, parent) self.logWindow = QTextEdit(self) self.logWindow.setReadOnly(True) self.setCentralWidget(self.logWindow) # Testing QInputDialog actionInt = QAction("QInputDialog::getInt()",self) actionDouble = QAction("QInputDialog::getDouble()",self) actionText = QAction("QInputDialog::getText()",self) actionMultiLineText = QAction("QInputDialog::getMultiLineText",self) actionItem = QAction("QInputDialog::getItem()",self) inputDialogMenu = self.menuBar().addMenu("Q&InputDialog") inputDialogMenu.addAction(actionInt) inputDialogMenu.addAction(actionDouble) inputDialogMenu.addAction(actionText) inputDialogMenu.addAction(actionMultiLineText) inputDialogMenu.addAction(actionItem) actionInt.triggered.connect(self.getInt) actionDouble.triggered.connect(self.getDouble) actionText.triggered.connect(self.getText) actionMultiLineText.triggered.connect(self.getMultiLineText) actionItem.triggered.connect(self.getItem) # Testing for QMessageBox actionAbout = QAction("QMessageBox::about()",self) actionInformation = QAction("QMessageBox::information()",self) actionQuestion = QAction("QMessageBox::question()",self) actionWarning = QAction("QMessageBox::warning()",self) actionCritical = QAction("QMessageBox::critcal()",self) messgeWidgetMenu = self.menuBar().addMenu("Q&MessageBox") messgeWidgetMenu.addAction(actionAbout) messgeWidgetMenu.addAction(actionInformation) messgeWidgetMenu.addAction(actionQuestion) messgeWidgetMenu.addAction(actionWarning) messgeWidgetMenu.addAction(actionCritical) actionAbout.triggered.connect(self.aboutMessage) actionInformation.triggered.connect(self.informationMessage) actionQuestion.triggered.connect(self.questionMessage) actionWarning.triggered.connect(self.warningMessage) actionCritical.triggered.connect(self.criticalMessage) # Testing for QErrorMessage self.errorMessageDialog = QErrorMessage(self); self.errorMessageDialog.setWindowTitle("Error"); actionErrorMessage = QAction("QErrorMessage::show()",self); errorWidgetMenu = self.menuBar().addMenu("QErrorMessage"); errorWidgetMenu.addAction(actionErrorMessage); actionErrorMessage.triggered.connect(self.errorMessage); def getInt(self): value, ok = QInputDialog.getInt(self,"Input value", "Percentange:", 25,0,100,1) if ok: self.logWindow.append(">>> " + str(value)) def getDouble(self): value, ok = QInputDialog.getDouble(self,"Input value","Amount:", 37.56, -1000,1000,2) if ok: self.logWindow.append(">>> " + str(value)) def getText(self): text, ok = QInputDialog.getText(self,"Input text","Enter text:", QLineEdit.Normal,"Enter") if ok and text != "": self.logWindow.append(">>> " + text) def getMultiLineText(self): text, ok = QInputDialog.getMultiLineText(self,"Input text", "Adress:","John Doe\nFreedom Stress") if ok and text != "": self.logWindow.append(">>> " + text) def getItem(self): text, ok = QInputDialog.getItem(self,"Select season","Season:", ["Spring","Summer","Fall","Winter"],0, False) if ok and text != "": self.logWindow.append(">>> " + text) def aboutMessage(self): QMessageBox.about(self,"About Section Designer", "<h2>Section Designer 1.1</h2>" "<p>Copyright © 2014 Qt5Programming Inc." "<p>Section Designer is a small application that " "computes section properties, moment-curvature diagram, and many other."); def informationMessage(self): QMessageBox.information(self,"Assign Workspace", "Failed to assign the directory as workspace") def questionMessage(self): r = QMessageBox.question(self,"Licence agreement", "Do you agree the follwoing license?" "<p> 1. Use the SW as <strong>educational purpose</strong>." "<p> 2. Report the bugs in use", QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel) if r == QMessageBox.Yes: self.logWindow.append("Yes") elif r == QMessageBox.No: self.logWindow.append("No") else: self.logWindow.append("Cancel") def warningMessage(self): r = QMessageBox.warning(self,"Warning: Delete Node", "Cannot delete the connected node only." "<p>Delete all connected line? ", QMessageBox.Yes | QMessageBox.No) if r == QMessageBox.Yes: self.logWindow.append("Yes") else: self.logWindow.append("No") def criticalMessage(self): r = QMessageBox.critical(self,"Error: Analysis error", "Some input is not proper", QMessageBox.Abort | QMessageBox.Retry | QMessageBox.Ignore) if r == QMessageBox.Abort: self.logWindow.append("Abort") elif r == QMessageBox.Retry: self.logWindow.append("Retry") else: self.logWindow.append("Ignore") def errorMessage(self): self.errorMessageDialog.showMessage( "<h2>Error 663</h2><p>Cannot find file") if __name__ == '__main__': app = QApplication(sys.argv) mainWindow = MainWindow() mainWindow.resize(400,300) mainWindow.setWindowTitle("Feedback dialog") mainWindow.show() mainWindow.show() app.exec_() 3.8 표준 다이얼로그 - 공용 다이얼로그 공용 다이얼로그로는 파일, 색상, 폰트 선택을 위한 QFileDialog, QColorDialog, QFontDialog와 프린터 지원을 위한 QPrintDialog, QPageSetupDialog, QPrintPreviewDialog가 있다. 여기에서는 QFileDialog, QColorDialog, QFontDialog만 설명한다. QFileDialog QFileDialog는 정적 편의 함수 getOpenFileName(), getSaveFileName() 이 파일 열기 및 저장 관련 메뉴에 반응하여 호출할 수 있다. 다음은 전형적인 코드 조각이다. class MainWindow(QMainWindow): ... def open(self): if self.okToContinue(): fileName, selectedFilter = QFileDialog.getOpenFileName(self,"Open Image File",".", "Image files (*.jpg *.png);; XPM file (*.xpm)") if fileName != "": self.load(fileName) if QFileInfo(fileName).suffix() == "jpg" : ... something with .jpg file elif QFileInfo(fileName).suffix() == "png" : ... something with .png file else: ... something with .xpm file def saveAs(self): fileName, _ = QFileDialog.getSaveFileName(self,"Save Datafile", ".", "Data files (*.dat)") if fileName == "": return False return self.saveFile(fileName) 위 코드에서 마지막 인자에서 파일 필터(filter)를 지정하고 있다. 확장자는 설명문 (*.ext) 형태의 포맷이다. *.ext에 스페이스로 여러 확장자를 기입할 수 있고 설명문 자체가 바뀌는 경우에는 ;; 기호를 사용하면 된다. 코드에서 QFileInfo 클래스는 파일명으로부터 다양한 정보를 얻어낼 수 있는 편의 클래스이다. 위에서는 확장자를 검토하는 데 사용하였다. QFileDialog는 여러 개의 파일 경로를 얻는 getOpenFileNames(), 디렉터리를 얻는 getExistingDirectory(), URL을 얻는 getOpenFileUrl() 등 다양한 유형의 정적 편의 함수가 있다. QFontDialog와 QColorDialog QFontDialog는 폰트를 선택하는 다이얼로그로 QFont 클래스와 연동하여 사용하며, QColorDialog는 QColor 객체와 연동하여 색상을 선택해 주는 다이얼로그이다. class MainWindow(QMainWindow): ... def setFont(self): (ok, font) = QFontDialog.getFont(QFont("Helvetica [Cronyx]", 10), self) if ok: someLabel->setText( "family:{}, pointSize:{}, weight:{}, italic:{}".format( font.family().font.pointSize(),font.weight(),font.italic()) ) # 폰트 이름, 포인트 크기, 웨이트(클수록 두꺼워짐), 이탤릭 여부 출력 someLabel.setFont(font) def setColor(self): color = QColorDialog.getColor(Qt.green, self, "Select Color") if color.isValid(): someLabel.append(color.name()) someLabel.setPalette(QPalette(color)) someLabel.setAutoFillBackground(true) 4. 메인 윈도 메인 윈도는 최상위창으로 생성되는 메뉴, 툴바, 상태 바 등을 갖는 위젯을 의미한다. Qt에서 메인 윈도는 QMainWindow를 서브클래싱해서 만든다. QMainWindow에서는 아래 그림과 같이 상하좌우에 메뉴(QMenuBar), 툴바(QToolBar), 상태 바(QStatusBar) 등을 쉽게 배치할 수 있다. 또한 도킹 윈도(QDockWidget으로 서브클래싱) 영역도 정해져 있습니다. 가운데 영역에 들어가는 위젯을 중앙 위젯(Central widget)이라고 하는 데 QWidget에서 상속받은 위젯이면 된다. 여기에는 QTextEdit 같은 내장 Qt 위젯을 둘 수도 있고, 직접 작성한 커스텀 위젯을 둘 수도 있고, QMdiArea, QTabWidget 같은 컨테이너 위젯을 둘 수도 있다. QMdiArea로는 고전적인 MDI 인터페이스를 구축할 수 있고, QTabWidget을 사용하면 탭 문서 형태의 인터페이스를 구축할 수 있다. 메인 윈도의 센트럴 위젯은 QMainWindow.setCentralWidget() 함수를 생성자에서 호출해 주면 된다. 다음 그림은 실제 프로그램에서 메인 윈도의 모습을 나타낸 것입니다. 메인 윈도는 생성자에서 메뉴, 툴바, 상태 바, 센트럴 위젯 설정 등등 다양한 초기화 작업을 수행한다. 다음은 QMainWindow를 서브클래싱한 커스텀 메인 윈도 클래스의 일반적인 생성자 구조를 나타낸 것이다. class MainWindow(QMainWindow): def __init__(self, parent=None): QMainWindow.__init__(self, parent) self.setWindowTitle('Shape') self.setWindowIcon(QIcon(":/images/qt.png")) self.shapeWidget = ShapeWidget() self.setCentralWidget(self.shapeWidget) self.createActions() self.createMenus() self.createContextMenu() self.createToolBar() self.createStatusBar() self.readSettings() self.myModalessDialog = None def createActions(self): .... 위 코드는 단위 블록으로 분리하여 함수로 표현하는 리팩토링(refactoring) 형태로 제시하였다. 그 이유는 메인 윈도의 생성자에 편집할 내용이 많기 때문이다. 생성자에서 액션(QAction)이라는 것을 생성함을 알 수 있다. Qt는 메뉴 아이템과 툴바 툴버턴에 대한 명령을 일원화하기 위해 QAction 클래스를 도입하였다. 액션 생성 후 메뉴, 컨텍스트 메뉴, 툴바, 상태 바 등을 생성합니다. readSettings()는 응용프로그램의 창의 위치, 툴바나 도킹 위젯의 상태 등과 같은 각종 설정을 읽어오는 역할을 담당한다. QSettings라는 클래스를 이용하는데 이 클래스는 다양한 플랫폼을 지원한다. 예를 들어 윈도우즈의 경우 레지스트리를 사용하도록 합니다. 마지막으로 모덜리스다이얼로그 같은 필요한 초기화 작업을 수행한다. 4.1 액션, 메뉴, 상태 바 액션 일반 Qt는 메뉴, 툴바, 상태 바 등을 편리하게 생성하고 관리할 수 있는 액션(QAction)이라는 개념을 도입하였다. QAction에 메뉴에 표시되는 문자열(text), 아이콘(icon), 단축키(shortcut), 툴팁(tooltip), 상태 바에 나타나는 팁 문자열(statustip), 와츠 디스 문자열(whatsthis) 등을 지정할 수 있다. 액션을 메뉴(QMenu)에 addAction()으로 추가하는 것으로 액션에 지정한 문자열과 아이콘을 가진 메뉴 아이템이 된다. 툴바(QToolBar)는 콤보 박스 등의 위젯이 올 수도 있지만 보통 메뉴 아이템과 1:1로 대응하는 툴버턴으로 구성되어 있다. 툴바의 툴버턴 역시 addAction()을 통해 QAction에 지정한 아이콘을 갖는 툴버턴으로 간단하게 생성된다. 또한 위젯의 컨텍스트 메뉴에 대해서도 액션을 이용하면 쉽게 구현 가능하다. 사실 QWidget은 자신의 내부에 QAction의 리스트를 유지하고 있습니다. QWidget.addAction()은 여기에 액션을 추가하는 함수이다. 대부분의 위젯들은 이 액션을 컨텍스트 메뉴를 구성하는 데 사용한다. 상태 바와는 액션과 연관된 메뉴 아이템이나 툴바에 마우스를 위치하면 지정된 문자열이 표시된다. 이와 같은 방식으로 하나의 행위를 하는 액션을 생성해서 메뉴, 툴바, 상태 바를 일원화하여 관리 가능하다. 메뉴 아이템이나 툴바 버턴을 선택한 경우 연결되어 있는 액션에서 triggered(), toggled(bool) 등과 같은 시그널을 발생시키며, 이를 슬롯에 연결함으로써 편리하게 사용할 수 있다. 다음은 메인 윈도에서 액션으로 메뉴와 툴바를 구성하는 일반적인 절차와 예이다. 액션을 만들고 설정한다(아이콘, 단축키, 팁, slot 함수 연결 등) 메뉴를 생성하고, 만들어둔 액션을 추가한다(QMenu.addAction() 함수) 툴바를 생성하고, 만들어둔 액션을 추가한다(QToolBar.addAction() 함수) class MainWindow(QMainWindow): def __init__(self, parent=None): QMainWindow.__init__(self, parent) self.setWindowTitle('Shape') self.setWindowIcon(QIcon(":/images/qt.png")) self.myWidget = MyWidget() self.setCentralWidget(self.myWidget) # 액션을 생성한다. self.newAction = QAction("&New", self) self.newAction.setIcon(QIcon(":/images/new.png") self.newAction.setShortcut("Ctrl+N") # or newAction.setShortcut(QKeySequence::New) self.newAction.setStatusTip("Create a new file") self.newAction.triggered.connect(newFile) ... self.copyAction = QAction("&Copy", self) ... self.copyAction.triggered.connect(myWidget.copy) # MyWidget::copy() 슬롯과 연결 # 메뉴를 만든다 fileMenu = self.menuBar().addMenu("&File") fileMenu.addAction(self.newAction) ... sperator = fileMenu.addSeparator() fileMenu.addAction(self.exitAction) # 툴바를 만든다 fileToolBar = self.addToolBar("&File") fileToolBar.addAction(self.copyAction) ... # 상태 바를 만든다 .... def newFile(self): ... ... 코드를 살펴보면 QAction을 생성할 때 텍스트, 아이콘, 단축키, 상태 바에 표시될 내용 등 다양한 속성을 지정할 수 있다. 생성된 QAction은 triggered() 시그널과 이를 처리할 슬롯을 적절히 연결한다. 단축키는 setShortcut()에서 “Ctrl+N” 문자열을 지정하여 Ctrl+N이 눌릴 때 작동하도록 하였다. Qt에는 각 플랫폼마다 표준적으로 사용되는 단축키 조합을 정의하고 있다. 예를 들어 File New에 대해서는 문자열인 “Ctrl+N” 대신 QKeySequence.New를 지정하면 플랫폼에서 표준적으로 사용되는 단축키 조합이 적용된다. 자세한 리스트는 Qt 헬프의 QKeySequence 클래스의 설명에서 찾을 수 있으며 다음은 대표적인 표준 단축키 조합을 나열한 것이다. 파일 메뉴 : QKeySequence.New, QKeySequence::Open, QKeySequence::Save, QKeySequence::SaveAs, QKeySequence::Print, QKeySequence::Quit 편집 메뉴 : QKeySequence::Copy, QKeySequence::Cut, QKeySequence::Redo, QKeySequence::Undo QAction.setStatusTip(text)로 메뉴나 툴바의 아이템이 포커스를 가질 때 상태 바에 text가 표시되게 된다. 만약 액션에 관련된 아이템이 포커스가 없을 때 어떤 내용을 표시하기 위해서는 QLabel을 추가해 상황에 맞도록 값을 변경해 줄 수 있다. 비슷한 함수로 QAction.setToolTip(text)이 있다. 이 함수는 툴바에 포커스가 있을 때 툴팁에 나타낼 텍스트를 지정한다. 만약 툴팁 텍스트가 지정되지 않을 경우에는 QAction의 텍스트가 지정된다. 보통 툴팁은 짧게 보여주기 위해 메뉴 아이템과 동일하게 설정하므로 잘 사용되지 않는다. 사용자에게 헬프를 제공하는 또 다른 함수로는 QAction.setWhatsThis(text)가 있다. 액션의 생성이 끝나면 단순히 QMenu.addAction()이나 QToolBar.addAction()으로 액션을 추가하기만 하면 메뉴와 툴바의 구성이 끝난다. 코드에서 menuBar()는 MainWindow의 메뉴바(QMenuBar)를 리턴한다. 처음 호출될 때 메뉴바가 생성된다. addToolBar("File") 역시 처음 호출될 때 File이라는 이름의 툴바가 생성되고 리턴된다. 분리자 역시 액션으로 표현한다. 하지만 분리 자는 액션을 생성해서 메뉴나 툴바에 넣는 것이 아니라 QMenu.addSeparator()나 QToolBar.AddSeperator()를 이용하여 생성해 준다. 이 함수들은 분리자를 지칭하는 QAction 객체를 리턴한다. 체크 액션 액션 중에는 체크 가능한 액션이 존재할 수 있다. QAction.setCheckable(true)을 설정해 주는 것으로 만들어 낼 수 있다. 일반 액션이 triggered() 시그널을 이용해 슬롯 함수에 연결한 반면 체크 액션은 toggled(bool)이나 triggered(bool) 시그널을 사용한다. checkAction = QAction(self) ... set icon, shortcut, status tips checkAction.setCheckable(True) checAction.setChecked(True) checkAction.toggled.connect(self.someSlot) # someSlot(bool) 체크 액션에 아이콘을 넣는 경우에 On/Off 상태에 따라 다른 아이콘을 넣을 필요가 있다면 다음과 같이 QIcon에 두 개 이상의 리소스 파일을 상태에 따라 설정해 주면 된다. icon= QIcon(self) icon.addFile(":/images/normal.png", QSize(), QIcon.Normal, QIcon.Off) icon.addFile(":/images/pressed.png", QSize(), QIcon.Normal, QIcon.On) someAction.setIcon(icon) 일반적으로 단순한 체크 액션은 toggled(bool) 시그널을 사용하지만 경우에 따라서 triggered(bool) 시그널을 사용해야만 하는 경우가 있다. toggeled(bool)은 사용자가 마우스 등으로 액션의 상태를 변경하거나 setCheck(bool) 함수를 호출해 프로그램에서 변경하든 항상 발생하는 시그널인 반면, triggered(bool)은 사용자가 상태를 변경할 때만 발생하고 setCheck(bool) 호출에는 시그널을 발생시키지 않는다. 이 둘은 미묘한 차이가 있는 데 잘 선택해서 사용해야 한다. 만약 setCheck(bool) 함수를 사용해야 하고 액션의 상태가 복잡하게 얽혀 있는 경우 triggered(bool)를 사용하는 것이 좋다. toggled(bool)을 사용하는 경우 심한 경우 무한 루프에 빠지기도 한다. 액션의 상태 액션에는 활성화 상태와 체크 상태라는 두 가지 상태가 존재할 수 있다. 이중 체크 상태는 setCheckable(True)로 체크 액션으로 설정했을 때만 존재한다. 예를 들어 에디팅 프로그램을 작성한다고 하면 어떤 영역을 선택했을 때만 복사 액션이 활성화되도록 프로그램을 작성하는 것이 좋다. 액션의 활성화 상태는 setEnabled(bool) 함수로 설정할 수 있고 디폴트로 액션을 활성화 상태에 있다. 이 함수는 슬롯 함수이므로 적절한 상황에서 반응하도록 시그널과 연결하면 된다. 액션의 수가 많고 보다 복잡한 상황이라면 액션의 상태를 조정해 주는 함수(예를 들어 updateActions(self)라는 함수)를 작성한 다음 이 함수에서 일괄적으로 처리할 수 있다. 이 함수를 슬롯 함수로 만들어 어떤 시그널에 연결하거나 수동으로 상황이 바뀔 때마다 호출해 주면 된다. 체크 액션의 체크 상태로 toggled(bool) 시그널을 사용하지 않고 같은 방식으로 처리 가능하다. Qt는 액션을 도입해 메뉴, 툴바, 상태 바 등을 편리하게 일원화할 수 있지만 MFC(Microsoft Foundation Class Library)와 달리 액션의 상태(활성화 여부, 체크 여부 등)를 갱신하는 이벤트가 존재하기 않기 때문에 프로그램을 작성할 때 이점에 유의해야 한다. 액션 그룹(QActionGroup) 아래 그림처럼 몇 개의 체크 액션을 묶어 그중 하나만 선택 가능하도록 할 경우가 있다. 이런 경우에는 QActionGroup으로 묶어 주어야 한다. QActionGroup은 일반 툴버턴에도 적용 가능하지만 대부분 체크 버턴을 묶는데 사용한다. redAction = QAction("&Red",self) ... set icon, shortcut, tool tips, status tips redAction.setCheckable(True) redAction.setChecked(True) # initial check greenAction = QAction("&Green",self) ... set icon, shortcut, tool tips, status tips greenAction.setCheckable(True); blueAction = QAction("&Blue",self) ... set icon, shortcut, tool tips, status tips blueAction.setCheckable(True) colorActionGroup = QActionGroup(self) colorActionGroup.addAction(redAction) colorActionGroup.addAction(greenAction) colorActionGroup.addAction(blueAction) redAction.setChecked(True) # actionGroup 중 하나의 액션을 체크 상태로 초기화 colorActionGroup.triggered.connect(self.setColor) # triggered(QAction*) - self.setColor(QAction*) 위 코드에서 QActionGroup에 addAction(action)으로 체크 버턴 그룹에 포함된 액션을 순차적으로 추가한 후, 초기에 체크 상태에 있는 액선에 대해 QAction.setChecked(True)를 실행해 줍니다. 마지막으로 QActionGroup.triggered(QAction) 시그널을 적당한 슬롯 함수에 연결한다. QActionGroup.triggered(QAction) 시그널은 그룹 내의 체크 액션이 사용자에 의해 선택될 때 선택된 체크 액션을 인자로 발생하는 시그널이다. 개별 체크 액션의 triggered(bool)나 toggled(bool)를 사용해도 되지만 체크 액션 그룹에 대해서는 위 코드와 같이 작성하는 것이 편리하다. 상태 바 액션을 생성할 때 QAction::setStatusTip()으로 지정한 내용은 액션에 포커스가 있을 때(예를 들어 메뉴 아이템이나 툴바 버턴에 마우스가 올려질 때)만 상태 바에 표시된다. 그 외의 경에 상태 바에 어떤 내용을 표현하려면 QLabel을 addWidget() 함수로 상태 바에 추가하여 QLabel.setText()로 쓰기를 수행하면 된다. 다음은 다음절에서 다룰 Shape이라는 프로그램에서 상태 바에 라벨을 추가하고, mousePostionChanged()라는 시그널에 QLabel.setText() 슬롯을 연결한 것이다. self.locationLabel = QLabel(" ( 0, 0) ") self.locationLabel.setAlignment(Qt.AlignHCenter) self.locationLabel.setMinimumSize(locationLabel.sizeHint()) self.shape.mousePositionChanged.connect(self.locationLabel.setText) # locationLabel.setText(str) slot self.status Bar().addWidget(self.locationLabel) 위 예는 1개의 QLabel 위젯을 추가했지만 다양한 위젯을 여러 개 추가할 수도 있다. 4.2 툴바와 도킹 위젯 툴바(QToolBar)와 도킹 위젯(QDockWidget)는 메인 윈도에 도킹되거나 독립된 윈도로 떠 있을 수 있는 윈도이다. 둘 다 메인 윈도에 상하좌우 4개의 도킹 영역을 가지고 있다. 거의 비슷한 거동을 보이지만 툴바는 addAction(), insertAction()으로 쉽게 툴버턴을 갖는 액션을 추가할 수 있으며 addSeparator(), insertSeprator() 등으로 구분선을 넣을 수 있다는 점에서 도킹 윈도와 다르다. 툴바 툴바에 액션으로 편리하게 생성하는 툴버턴으로 부족할 경우에 QSpinBox, QComboBox 등을 비교적 간단한 위젯을 addWidget()으로 추가할 수 있다. 다음은 툴버턴과 QComboBox를 동시에 갖는 툴바이다. ... create copyAction, cutAction, ... self.combo = QComboBox(self) self.combo.addItem("Item 1") self.combo.addItem("Item 2") self.combo.currentIndexChanged.connect(self.setSomething) # setSomething(int) self.addToolBarBreak(Qt.TopToolBarArea) # insert toolbar break editToolBar = QToolBar() editToolBar.setObjectName("editToolBar") # assign object name editToolBar.addAction(self.cutAction) editToolBar.addAction(self.copyAction) editToolBar.addWidget(self.combo) self.combo.setMinimumSize(self.combo.sizeHint().width(),editToolBar.iconSize().height()) editToolBar.setAllowedAreas(Qt.TopToolBarArea | Qt.BottomToolBarArea) 위 코드에서 먼저 QComboBox를 하나 생성하고, 툴바에 addWidget()으로 추가한다. QComboBox에서 흔히 사용되는 시그널은 currentIndexChanged(int)와 currentIndexChanged(str)이다. 이 시그널로 적절한 커스텀 시그널에 연결하여 명령을 수행하도록 한다. 툴바까지 생성한 후에 setMinimunSize()를 호출한 부분이 있다. 이것은 툴버턴의 크기와 높이를 같게 하기 위해 호출된 것이다. 툴바의 위치를 제어하기 위해 setAllowedAreas()를 호출했다. 이 함수 호출로 툴바가 메인 윈도의 상, 하에만 붙도록 한다. QMainWindow.addToolBarBreak()는 여러 툴바가 같은 영역에 있을 때 다음 열이 나 행에 나누기를 하도록 한다. addToolBarBreak()와 비슷한 기능을 하는 함수로 특정 위치에 구분선을 넣은 insertToolBarBreak(beforeToolBar)가 있다. setObjectName()은 객체의 명칭을 지정하는 함수이다. 이 함수는 뒤에 설명한다. 아래 그림은 액션으로 추가 가능한 툴버턴 이외에, QComboBox 등 다양한 위젯으로 구성한 툴바 예이다. 툴바의 도킹 영역은 디폴트로 메인 윈도의 4개의 모서리 영역에 도킹될 수 있다. 이를 제어하는 함수가 QToolBar.setAllowedAreas(areas)이다. 또한 QMainWIndow.addToolBar(area, toolbar) 함수로 메인 윈도의 툴바로 등록하는데 이때 초기 툴바 위치를 지정할 수 있다. 사용되는 인자는 Qt.ToolBarArea 열거 변수를 사용하는 데 다음을 사용할 수 있다. Qt.ToolBarArea : Qt.LeftToolBarArea, Qt.RightToolBarArea, Qt.TopToolBarArea, Qt.BottomToolBarArea, Qt.AllToolBarAreas, Qt::NoToolBarArea 예를 들어 QMainWindow.addToolBar(toolbar)는 QMainWindow.addToolBar(Qt.TopToolBarArea, toolbar)를 호출하는 것과 같다. 도킹 위젯 도킹 위젯(QDockWidget)은 수평 또는 수직으로만 존재하는 툴바(QToolBar)와 달리 자유로운 형태를 가질 수 있다. 따라서 여러 위젯을 자유롭게 배치할 수 있다. QDockWidget은 다른 위젯을 래핑(wrapping) 하여 사용하는 데 래핑 할 위젯을 QDockWidget.setWidget(contentWidget)을 호출하여 래핑(wrapping) 한다. 도킹 윈도는 자신만의 타이틀 바를 가지면 닫기 버턴 역시 가지고 있다. 만약 타이틀바가 있는 툴바를 만들려면 QToolBar를 단순히 QDockWidget으로 래핑 하면 된다. 다음은 QWidget을 컨테이너로 하여 여러 위젯을 배치한 후 QDockWidget에 래핑 한 예이다. dockWidgetContent = QWidget() ... widget에 버턴, 콤보 박스 등을 추가 self.dockingWidget = QDockWidget("Icon panel") # 타이틀 설정 self.dockingWidget.setObjectName("IconPanel") self.dockingWidget.setWidget(dockWidgetContent) # 래핑 할 위젯 설정 self.dockingWidget.setAllowedAreas(Qt.LeftDockWidgetArea|Qt.RightDockWidgetArea) self.dockingWidget.setFloating(True) self.addDockWidget(Qt.RightDockWidgetArea, self.dockingWidget) # 초기 위치 및 도킹 위젯을 메인 윈도의 # 도킹 윈도로 설정 다음은 트리 위젯(QTreeWidget)을 래핑 한 예이다. self.shapesDockWidget = QDockWidget("Shapes") self.shapesDockWidget.setObjectName("shapesDockWidget"); self.shapesDockWidget.setWidget(treeWidget); self.shapesDockWidget.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea) self.shapeDockWidget.setFloating(True) self.addDockWidget(Qt.RightDockWidgetArea, self.shapesDockWidget); 위 코드에서 QDockWidget.setAllowedAreas()는 도킹 위젯이 도킹될 수 있는 영역을 지정하는 함수이다. 또한 QMainWindow.addDockWidget(dockWidget)에서 도킹 위젯의 초기 위치와 부모 위젯으로 메인 윈도를 설정한다. QMainWindow::setCorner(corner, area)는 코너 영역을 좌우 도킹 위젯이 차지할지 상하 도킹 위젯이 차지할지를 결정한다. 디폴트는 상하 도킹 위젯이 코너 영역을 우선적으로<NAME>다. QDockWidget.setAllowedAreas(area) ; QMainWindow.addDockWidget(area, dockwidget) QMainWindow.setCorner(corner, area) 위에서 area는 Qt.DockWidgetArea, corner는 Qt.Corner 열거 상수로 다음과 같다. enum Qt.DockWidgetArea Qt.LeftDockWidgetArea Qt.RightDockWidgetArea Qt.TopDockWidgetArea Qt.BottomDockWidgetArea Qt.AllDockWidgetAreas Qt.NoDockWidgetArea enum Qt.Corner Qt.TopLeftCorner Qt.TopRightCorner Qt.BottomLeftCorner Qt.BottomRightCorner QMainWindow는 자신의 모든 툴바, 도킹 윈도에 대한 컨텍스트 메뉴를 자동으로 제공한다. 이을 통해 사용자가 도킹 윈도와 툴바를 닫거나 활성화할 수 있다. 아래 그림은 툴바 영역 중 빈 공간에서 마우스 오른쪽 버턴을 선택해 표시되는 컨텍스트 메뉴의 예를 나타낸 것이다. 4.4 Shape 예제 메인 윈도의 사용법을 알아보기 위해 아래 그림과 같이 Shape이라는 간단한 프로그램을 작성해 본다. 이미지 준비 리소스 준비(Shape.qrc) <RCC> <qresource prefix="/"> <file>images/qt.png</file> <file>images/circle.png</file> <file>images/exit.png</file> <file>images/rectangle.png</file> <file>images/triangle.png</file> </qresource> </RCC> 리소스 컴파일 >pyside2-rcc -o Shape_rc.py -py3 Shape.qrc Shape1.py ## ShapeWidget from PySide2.QtWidgets import QWidget from PySide2.QtGui import QPalette, QPainter from PySide2.QtCore import Signal, Qt, QRect, QPointF class ShapeWidget(QWidget): mousePositionChanged = Signal(str) # mousePositionChanged(pos) NONE, RECTANGLE, TRIANGLE, CIRCLE = 0, 1, 2, 3 # constants def __init__(self, parent=None): QWidget.__init__(self, parent) self.setBackgroundRole(QPalette.Light) self.setAutoFillBackground(True) self.shape = ShapeWidget.NONE self.color = Qt.blue # slots def rectangle(self): self.shape = ShapeWidget.RECTANGLE self.update() def triangle(self): self.shape = ShapeWidget.TRIANGLE self.update() def circle(self): self.shape = ShapeWidget.CIRCLE self.update() def red(self): self.color = Qt.red self.update() def green(self): self.color = Qt.green self.update() def blue(self): self.color = Qt.blue self.update() def setMouseTracking(self, track): QWidget.setMouseTracking(self, track) # event handler def mouseMoveEvent(self, event): pos = "({},{})".format(event.x(),event.y()) self.mousePositionChanged.emit(pos) def paintEvent(self, event): painter = QPainter(self) painter.setPen(self.color) r = QRect(self.width()/4, self.height()/4, self.width()/2, self.height()/2) if self.shape == ShapeWidget.RECTANGLE: painter.drawRect(r) elif self.shape == ShapeWidget.TRIANGLE: points = [ QPointF(r.left()+r.width()/2, r.top()), r.bottomLeft(), r.bottomRight()] painter.drawPolygon(points) elif self.shape == ShapeWidget.CIRCLE: painter.drawEllipse(r) from PySide2.QtWidgets import (QMainWindow, QAction, QActionGroup, QToolBar, QLabel, QMessageBox) from PySide2.QtGui import QIcon from PySide2.QtCore import QSettings import Shape_rc class MainWindow(QMainWindow): def __init__(self, parent=None): QMainWindow.__init__(self, parent) self.setWindowTitle('Shape') self.setWindowIcon(QIcon(":/images/qt.png")) self.shapeWidget = ShapeWidget() self.setCentralWidget(self.shapeWidget) self.createActions(); self.createMenus(); self.createContextMenu(); self.createToolBar(); self.createStatusBar(); self.readSettings(); def createActions(self): # create actions self.exitAction = QAction("E&xit",self) self.exitAction.setIcon(QIcon(":/images/exit.png")) self.exitAction.setShortcut("Ctrl+Q") self.exitAction.setStatusTip("Exit the application") self.exitAction.triggered.connect(self.close) self.triangleAction = QAction("&Triangle",self) self.triangleAction.setIcon(QIcon(":/images/triangle.png")) self.triangleAction.setShortcut("Ctrl+T"); self.triangleAction.setStatusTip("Draw a triangle") self.triangleAction.triggered.connect(self.shapeWidget.triangle) self.rectangleAction = QAction("&Rectangle",self) self.rectangleAction.setIcon(QIcon(":/images/rectangle.png")); self.rectangleAction.setShortcut("Ctrl+R") self.rectangleAction.setStatusTip("Draw a rectangle"); self.rectangleAction.triggered.connect(self.shapeWidget.rectangle) self.circleAction = QAction("&Circle",self) self.circleAction.setIcon(QIcon(":/images/circle.png")) self.circleAction.setShortcut("Ctrl+C") self.circleAction.setStatusTip("Draw a circle") self.circleAction.triggered.connect(self.shapeWidget.circle) # actions for colors self.redAction = QAction("&Red",self) self.redAction.setStatusTip("Set red color") self.redAction.setCheckable(True) self.redAction.triggered.connect(self.shapeWidget.red) self.greenAction = QAction("&Green",self) self.greenAction.setStatusTip("Set green color") self.greenAction.setCheckable(True); self.greenAction.triggered.connect(self.shapeWidget.green) self.blueAction = QAction("&Blue",self) self.blueAction.setStatusTip("Set blue color") self.blueAction.setCheckable(True) self.blueAction.triggered.connect(self.shapeWidget.blue) self.colorActionGroup = QActionGroup(self) self.colorActionGroup.addAction(self.redAction); self.colorActionGroup.addAction(self.greenAction); self.colorActionGroup.addAction(self.blueAction); self.redAction.setChecked(True); self.colorActionGroup.triggered.connect(self.setColor) # (triggered(QAction*)),this, SLOT(setColor(QAction*))); # mouse tracking self.mouseTrackingAction = QAction("M&ouse tracking",self) self.mouseTrackingAction.setStatusTip("mouse tracking on/off") self.mouseTrackingAction.setCheckable(True) self.mouseTrackingAction.setChecked(self.shapeWidget.hasMouseTracking()) self.mouseTrackingAction.triggered.connect(self.shapeWidget.setMouseTracking) #connect(mouseTrackingAction, SIGNAL(triggered(bool)), shapeWidget, SLOT(setMouseTracking(bool))); # about self.aboutAction = QAction("&About",self) self.aboutAction.setStatusTip("Show the application's About box") self.aboutAction.triggered.connect(self.about) def createMenus(self): fileMenu = self.menuBar().addMenu("&File") fileMenu.addAction(self.exitAction) shapeMenu = self.menuBar().addMenu("&Shape") shapeMenu.addAction(self.triangleAction); shapeMenu.addAction(self.rectangleAction); shapeMenu.addAction(self.circleAction); colorMenu = self.menuBar().addMenu("&Color") colorMenu.addAction(self.redAction) colorMenu.addAction(self.greenAction) colorMenu.addAction(self.blueAction) mouseMenu = self.menuBar().addMenu("&Mouse") mouseMenu.addAction(self.mouseTrackingAction) aboutMenu = self.menuBar().addMenu("&About") aboutMenu.addAction(self.aboutAction) def createContextMenu(self): self.shapeWidget.addAction(self.triangleAction) self.shapeWidget.addAction(self.rectangleAction) self.shapeWidget.addAction(self.circleAction) self.shapeWidget.addAction(self.redAction) self.shapeWidget.addAction(self.greenAction) self.shapeWidget.addAction(self.blueAction) self.shapeWidget.setContextMenuPolicy(Qt.ActionsContextMenu) def createToolBar(self): shapeToolBar = self.addToolBar("&Shape") shapeToolBar.setObjectName("ShapeToolBar") shapeToolBar.addAction(self.triangleAction) shapeToolBar.addAction(self.rectangleAction) shapeToolBar.addAction(self.circleAction) def createStatusBar(self): locationLabel = QLabel(" ( 0, 0) ") locationLabel.setAlignment(Qt.AlignHCenter) locationLabel.setMinimumSize(locationLabel.sizeHint()) self.shapeWidget.mousePositionChanged.connect(locationLabel.setText) # shapeWidget.mousePositionChanged(str) - QLabel.setText(str) self.status Bar().addWidget(locationLabel) def readSettings(self): settings = QSettings("Qt5Programming Inc.", "Shape") self.restoreGeometry(settings.value("geometry")) self.restoreState(settings.value("state")) def writeSettings(self): settings = QSettings("Qt5Programming Inc.", "Shape") self.saveGeometry() settings.setValue("geometry", self.saveGeometry()) settings.setValue("state",self.saveState()) # event def closeEvent(self, event): self.writeSettings() # slot def setColor(self, action): if action == self.redAction: self.shapeWidget.red() elif action == self.greenAction: self.shapeWidget.green() else: self.shapeWidget.blue() def about(self): QMessageBox.about(self, "About Shape", "<h2>Shape 1.0</h2>" "<p>Copyright © 2014 Q5Programming Inc." "<p>Shape is a small application that " "demonstrates QAction, QMainWindow, QMenuBar, " "QStatusBar, QToolBar, and many other " "Qt classes.") import sys from PySide2.QtWidgets import QApplication if __name__ == '__main__': app = QApplication(sys.argv) mainWindow = MainWindow() mainWindow.show() app.exec_() 4.6 컨텍스트 메뉴 컨텍스트 메뉴는 오른쪽 마우스의 눌림 해제가 발생하는 순간 팝업 되는 메뉴를 의미한다. Qt는 오른쪽 마우스 클릭이 일어나면 mousePressEvent(), mouseReleaseEvent(), contextMenuEvent()의 순서로 이벤트를 발생시키게 된다. 컨텍스트 메뉴를 처리하려면 contextMenuEvent() 핸들러를 오버라이드(override) 하여 처리하면 된다. def contextMenuEvent(self, event): # QContextMenuEvent ... 이제 contextMenuEvent() 핸들러에서 QMenu 객체에 대해 exec_() 함수 호출을 수행하면 팝업메뉴가 나타나게 된다. 다음은 커스텀 위젯에서 contextMenuEvent() 핸들러를 통해 처리하는 문제를 나타낸 것이다. class myWidget(QWidget): def __init__(self, parent=None): QWidget.__init__(self, parent) ... 액션 생성 - self.copyAction, self.deleteAction, self.pasteAction, ... def contextMenuEvent(self, event): # QContextMenuEvent menu = QMenu(self) menu.addAction(self.cutAct) menu.addAction(self.copyAct) menu.addAction(self.pasteAct) menu.addSeperator() ... menu.exec_(event.globalPos()) ... 위 코드는 myWidget 소유의 self.copyAction, self.deleteAction, self.pasteAction을 생성자에서 만들어 둔 다음 contextMenEvent() 핸들러에서 메뉴 QMenu를 스택에 생성하고, exec_()를 호출하는 방식이다. 컨텍스트 메뉴 자체를 위젯 소유로 만들어 미리 생성자에서 만들어 둔 다음 contextMenuEvent() 핸들러에서 exec_()만 호출하는 방식도 가능합니다. class myWidget(QWidget): def __init__(self, parent=None): QWidget.__init__(self, parent) ... 액션 생성 - self.copyAction, self.deleteAction, self.pasteAction, ... self.contextMenu = QMenu(self) self.contextMenu = QMenu(self) self.contextMenu.addAction(self.cutAct) self.contextMenu.addAction(self.copyAct) self.contextMenu.addAction(self.pasteAct) self.contextMenu.addSeperator() ... def contextMenuEvent(self, event): # QContextMenuEvent self.contextMenu.exec_(event.globalPos()) ... 사실 컨텍스트 메뉴를 위한 전용 이벤트 핸들러인 contextMenuEvent()가 없더라도 mouseReleaseEvent() 핸들러를 처리하도록 구현할 수 있다. Qt가 컨텍스트 메뉴를 위한 전용 이벤트와 핸들러를 제공하는 이유는 QWidget에 컨텍스트 메뉴와 관련된 몇 가지 정책을 부여할 수 있도록 하고, 이를 통해 쉽게 컨텍스트 메뉴를 구현하도록 하기 위해서이다. 다음은 그 정책을 정하는 함수에 대한 설명입니다. QWidget.setContextMenuPolicy(contextMenuPolicy) contextMenuPolicy는 Qt.ContextMenuPolicy라는 enum으로 정의되어 있으며 다음의 값을 가질 수 있다. Qt.DefaultContextMenu : contextMenuEvent() 이벤트 핸들러 호출 (QWidget의 디폴트 값). Qt.DefaultContextMenu가 contextMenuEvent() 핸들러를 호출하는 기본 방식이다. 나머지 정책은 마우스 버턴이 눌림 해제되어도 이 핸들러를 호출하지 않는다. 커스텀 위젯에서 Qt.DefaultContextMenu 정책을 부여하고 contextMenuEvent()를 오버라이드 하는 경우에는 인자로 전달되는 QContextMenuEvent는 디폴트로 accepted 상태이다. 즉 조작을 하지 않으면 그 위젯에서 처리된 후 부모 위젯으로 메시지가 전달되지 않는다. 디폴트로 QWidget은 Qt.DefaultContextMenu를 정책으로 사용하고 있으며 QWidget.contextMenuEvent() 핸들러에서는 이벤트를 강제로 무시(ignore) 한다. 이것은 컨텍스트 메뉴 이벤트가 발생하지만 커스텀 위젯에서 이벤트 핸들러를 재정의하지 않으면 부모 위젯으로 컨텍스트 메뉴 이벤트가 전달된다는 의미이다. Qt.NoContextMenu : 컨텍스트 메뉴 이벤트를 자신이 처리하지 않고 보모 위젯으로 위임 (위젯에 컨텍스트 메뉴가 없을 때 주로 설정). Qt::NoContextMenu는 contextMenuEvent()에서 아무 처리를 하지 않고 단순히 QContextMenuEvent을 ignored 상태로 만들어 부모 위젯으로 이벤트 처리를 위임하는 것과 같다. Qt.PreventContextMenu : 컨텍스트 메뉴 이벤트를 자신이 처리하지 않을 뿐만 아니라 보모 위젯으로 위임하지도 않음. 이 정책을 부과한 위젯은 컨텍스트 메뉴가 팝업 되지 않음. Qt::PreventContextMenu는 Qt.NoContextMenu와 같지만 QContextMenuEvent의 속성을 accept로 유지하여 부모 위젯에서 이벤트 처리를 하지 못하도록 한다. Qt.ActionsContextMenu : 이 정책을 설정하면 위젯의 보유하고 있는 액션 리스트를 컨텍스트 메뉴로 표시한다. 위젯에 따라 자신만의 액션을 가지고 있어서 그 액션을 컨텍스트 메뉴로 처리하도록 하는 경우가 있다. 예를 들어 QLineEdit와 같은 에디팅 위젯들은 복사, 삭제 등과 같은 자신만의 컨텍스트 메뉴를 디폴트로 가지고 있다. 이러한 이유로 Qt는 QWidget이 액션 리스트(QAction의 리스트)를 유지토록 설계되어 있다. Qt.CustomContextMenu : customContextMenuRequest(point) 시그널을 발생 시. Qt.CustomContextMenu 정책은 부모 위젯(보통 메인 윈도)에서 자식 위젯의 컨텍스트 메뉴를 세련되게 제어할 수 있다. 위 예에서 rectangleAction, redAction 등은 메인 윈도가 소유하고 있는 액션이기 때문에 shape 위젯에서 구체적인 메뉴 형태를 알 수 없다. 이때는 Qt.CustomContextMenu 정책을 사용하는 것이 좋다. class MainWindow(QMainWindow): def __init__(self, parent=None): self.shape = Shape() self.setCentralWidget(self.shape) self.exitAction = QAction("E&xit", self) ... self.shape.setContextMenuPolicy(Qt.CustomContextMenu) self.shape.customContextMenuRequested.connect(self.showShapeContextMenu) def showShapeContextMenu(self, pos): menu = QMenu(self) ... triangleAction, rectangleAction 등으로 메뉴구성 menu.exec_(QCursor.pos()); # do not use pos in args, which is relative to widget .... Qt::CustomContextMenu의 또 다른 사용 예는 자식 위젯이 액션을 소유하고 있고, 이 액션에 다른 액션을 추가하여 컨텍스트 메뉴를 나타내고자 할 때이다. class MainWindow(QMainWindow): def __init__(self, parent=None): self.myWidget = MyWidget() # myWidget은 copy, cut 등의 액션 리스트를 가지고 있음. self.setCentralWidget(self.myWidget) self.myWidget.setContextMenuPolicy(Qt.CustomContextMenu); self.myWidget.customContextMenuRequested.connect(showShapeContextMenu) ... def showShapeContextMenu(self, pos): menu = QMenu(self) menu.addActions(self.myWidget); ... MainWindow의 액션 추가 menu.exec_(QCursor::pos()) 마지막에 설명한 부분에서 다시 한번 시그널-슬롯의 위력을 알 수 있다. 정리하면, 위젯을 설계할 때 자신과 자신과 관련된 액션을 가지도록 설계할 때는 컨텍스트 메뉴과 관련해 다음과 같이 설계하는 것이 일반적이다. 커스텀 위젯이 Qt.DefaultContextMenu 정책을 갖도록 하고 contextMenuEvent()를 처리한다. 만약 커스텀 위젯을 사용하는 위젯(주로 메인 윈도)에서 컨텍스트 메뉴를 변경하고자 할 때는 Qt.CustomContextMenu 정책을 부과하고 customContextMenuRequested()와 연결하는 슬롯을 재정의하도록 한다. 특수한 경우로 미리 정의된 custumContextMenuRequested()를 사용하지 않고 직접 시그널을 작성하는 경우도 있다. 예를 들어 Shift 키와 오른쪽 마우스 버턴이 함께 누른 후 이후 마우스 움직임에 따라 화면을 확대하는 위젯을 작성한다고 하면 customContextMenuRequested()는 약간 이상하게 작동한다. 그 이유는 오른쪽 마우스 버턴이 해제될 때 항상 이 시그널이 발생하기 때문입니다. 이 경우에는 Qt.PreventContextMenu 정책을 지정하고 mouseReleaseEvent()에서 조건에 맞는 커스텀 시그널(예를 들어 myConstextedMenuRequested()을 발생시키도록 한다. 이 시그널을 사용하는 것은 customContextMenuRequested()와 동일하다. class MyZoomWidget(QWidget): contextMenuRequested = Signal() def __init__(self, parent=None): QWidget.__init__(self, parent) self.setContextMenuPolicy(Qt::PreventContextMenu); ... def mouseReleaseEvent(self, event): # QMouseEvent if e->button() == Qt.RightButton: if in zoom mode ... something for zooming else contextMenuRequested.emit() 5. 위젯 고급 이번 장에서는 QWidget에 대해 심화하여 설명합니다. 5.1 이벤트 이벤트와 이벤트 핸들러 이벤트 혹은 메시지라는 것은 GUI 운영 체계에서 사용되는 개념이다. 예를 들어 어떤 프로그램에 대해 마우스 조작을 하는 경우 관련 이벤트를 그 프로그램에 발생시켜 처리하게 한다. 프로그램은 자신만의 이벤트큐를 가지고 있는데 관련된 위젯에 이벤트를 처리하도록 요청하게 된다. 이벤트를 처리하는 함수를 이벤트 핸들러라고 부르며, QWidget은 미리 정의된 여러 개의 이벤트 핸들러를 가상함 수로 정의하고 있다. 따라서 이벤트를 처리하기 위해서는 이벤트 핸들러를 재정의해 주어야 한다. 다음은 QWidget에서 정의하고 있는 주요 이벤트 핸들러를 나타낸 것이다. 이벤트 핸들러의 인자로는 QEvent를 최상위 클래스로 갖는 각종 이벤트 클래스의 객체가 사용된다. class QWidget: ... def paintEvent(self, event): # QPaintEvent 객체, 다시 그리기가 필요할 때 def void resizeEvent(self, event): # QResizeEvent 객체, 위젯 크기가 변경되었을 때 def void enterEvent(self, event): # QEvent 객체, 마우스가 위젯 내로 들어왔을 때 def void leaveEvent(self, event): # QEvent 객체, 마우스가 위젯 밖으로 나갈 때 def void mouseMoveEvent(self, event): # QMouseEvent 객체, 마우스 이동 시 def mousePressEvent(self, event): # QMouseEvent 객체, 마우스 버턴(왼쪽이든 오른쪽이던)이 누를 때 def mouseReleaseEvent(self, event): # QMouseEvent 객체, 눌러진 마우스 버턴을 해제할 때 def mouseDoubleClickEvent(self, event): # QMouseEvent 객체, 더블클릭 시 def wheelEvent(self, event): # QWheelEvent 객체, 마우스 휠 def contextMenuEvent(self, event): # QContextMenuEvent 객체, 컨텍스트 메뉴가 필요할 때(오른 마우스 버턴) def focusInEvent(self, event): # QFocusEvent 객체, 키보드 입력 포커스를 가질 때 def focusOutEvent(self, event): # QFocusEvent 객체, 키보드 입력 포커스를 잃을 때 def keyPressEvent(self, event): # QKeyEvent, 키를 누를 때 def keyReleaseEvent(self, event): # QKeyEvent, 누를 키를 해제할 때 def inputMethodEvent(self, event): # QInputMethodEvent 객체, 아시아 문자에 대한 키 입력 def closeEvent(self, event): # QCloseEvent 객체, 위젯을 닫을 때 def dragEnterEvent(self, event): # QDragEnterEvent 객체, 위젯 내로 드래그 되어 들어올 때 def dragLeaveEvent(self, event): # QDragLeaveEvent 객체, 위젯 밖으로 드래그 되어 나갈 때 def dragMoveEvent(self, event): # QDropEvent 객체, 드래그하며 움직일 때 def dropEvent(self, event): # 드롭될 때 def hideEvent(self, event): # QHideEvent 객체, 위젯이 화면에서 감춰질 때 def showEvent(self, event): # QShowEvent 객체, 위젯이 화면에서 나타날 때 ... 예외적으로 타이머 이벤트(QTimerEvent)는 QObject를 대상으로 발생한다. class QObject: ... def timerEvent(self, event) #QTimerEvent 객체, ... 이벤트의 처리 방식 이벤트는 다음과 같은 세 가지 방식 중 하나에 의해 발생되고 처리된다. 윈도 시스템에서 발생되어 이벤트루프로 처리되는 경우(spontaneous event) Qt나 애플리케이션에서 포스트(Posted) 되어 이벤트루프로 처리되는 경우(posted event) Qt나 애플리케이션에서 보내져(Sented) 대상 객체로 바로 전달되는 이벤트(sented event) (1), (2)에 해당하는 이벤트 루프는 메인 함수(__main__ 부분)의 끝에 호출되는 QApplication.exec_()에서 가동되는데, 이 함수는 개념적으로 다음과 같은 형태이다. while(!exit_was_called) { while(! posted_event_queue_is_empty) process_next_posted_event(); while(! spontaneous_event_queue_is_empty) process_next_spontaneous_event(); while(! posted_event_queue_is_empty) process_next_posted_event(); } 먼저 posted event에 대한 이벤트 루프가 큐가 빌 때까지 처리한다. 두 번째로 시스템에서 직접 발생되는 이벤트인 spontaneous event에 대한 이벤트 루프를 큐가 빌 때까지 처리한다. 마지막으로 posted event에 대한 처리를 다시 하게 되는데 그 이유는 spontaneous event의 결과 posted event가 생성될 수 있기 때문이다. 결론적으로는 spontaneous event와 posted event가 큐 형태의 이벤트 루프를 통해 처리된다. 직접 해당 객체로 이벤트를 보내는 sented event는 대상 객체가 그 이벤트가 처리될 때까지 기다리지만(blocked), 이벤트 루프를 통하게 되면 이벤트를 압축하고 처리 가능할 때 처리하게 된다. 예를 들어 QPaintEvent나 QResizeEvent의 경우 이벤트 루프를 통해 처리하게 되면, 짧은 시간 내에 여러 번 발생하게 되면 한 번만 처리하도록 압축이 되어 효율적으로 처리 가능하다. 이벤트가 필요한 이유 Qt의 시그널/슬롯의 강력한 기능으로 이벤트(event)를 직접 처리할 일을 별로 없다. 하지만 다음의 경우 필요하다 커스텀 위젯을 제작할 때는 이벤트의 처리가 필요하다. 특히 화면 그리기를 수행하기 위해서는 페인트 이벤트(QPaintEvent)를 처리해야만 한다. 특정 이벤트가 발생할 때 시그널을 발생시킬 때도 이벤트의 처리가 필요하다. 5.2 페인트 이벤트와 위젯 그리기 위젯을 대상으로 그리기를 수행할 때는 반드시 paintEvent(QPaintEvent) 핸들러 내에서 QPainter로 그리기를 수행해야 한다. QPaintEvent는 페인트 이벤트는 위젯이 뒤에 있다가 앞으로 나오게 되어 새로 그리기를 수행할 필요가 있을 운영 체계에 의해 발생한다. 또는 프로그램에서 QWidget.update(), QWidget.repaint()에 의해 강제로 발생되기도 한다. RenderMinimalWidget 다음은 위젯에 그리기를 수행한 최소한의 코드를 제시한 RenderMinimalWidget 예제이다. RenderMinimalWidget.py from PySide2.QtWidgets import QWidget from PySide2.QtGui import QPalette, QPainter, QPen, QBrush, QFont from PySide2.QtCore import Qt, QRect class RenderArea(QWidget): def __init__(self, parent=None): QWidget.__init__(self, parent) self.setAutoFillBackground(True) # 배경을 칠하도록 설정 self.setBackgroundRole(QPalette.Base) # 배경색 QPalette.Base로 설정 def paintEvent(self, event): painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing, True) painter.setPen(QPen(Qt.black, 4, Qt.DotLine, Qt.RoundCap)) # 펜 설절 painter.setBrush(QBrush(Qt.green, Qt.SolidPattern)) # 브러시 설정 painter.setFont(QFont("Arial",30)) rect = QRect(80,80,400,200) painter.drawRoundRect(rect, 50,50) # 경계선은 펜, 내부는 브러시 painter.drawText(rect, Qt.AlignCenter,"Hello, Qt!") # 펜의 색상, 폰트 사용 from PySide2.QtWidgets import QApplication import sys if __name__ == "__main__": app = QApplication(sys.argv) renderArea = RenderArea() renderArea.setWindowTitle("Render Minimal") renderArea.resize(530,360) renderArea.show() app.exec_() 5.3 입력 이벤트와 QCloseEvent 입력 이벤트 이벤트 중에는 입력 이벤트(input event)는 부모 위젯으로 전파(propagated) 되는 이벤트들이다. 키 이벤트, 마우스 이벤트, 휠 이벤트, 컨텍스트 메뉴 이벤트 등이 이런 범주에 들어간다. 이런 이벤트들은 accept(), ignore() 함수로 이벤트 클래스의 bool 타입의 accepted 속성을 설정하고 해제하는 작업이 필요하다. 이벤트를 accept 한다는 의미는 이미 이벤트를 처리했으니 더 이상 부모 위젯으로 전파하지 말라는 의미이고, ignore 한다는 것은 부모 위젯으로 이벤트를 전파하라는 의미이다. 예를 들어 A라는 위젯이 B 위젯의 자식 위젯이라면, A 위젯에서 이벤트를 무시하면 B 위젯이 처리할 수 있도록 이벤트가 전파되게 된다. 다음은 대표적인 예인 키 이벤트에 대해 ESC 키에 반응하도록 구현한 예이다. class MyWidget(QWidget): def __init__(self, parent=None): QWidget.__init__(self, parent) self.setFocusPolicy(Qt.StrongFocus); // enable keyPressEvent() ... def keyPressEvent(event): # QKeyEvent : event if event.key() == Qt.Key_Escape: self.doEscape() # event->accept() ... dummy call else: QWidget.keyPressEvent(self, event) # event->ignore() is called by default ... 엄밀하게 QKeyEvent는 이벤트 핸들러가 있는 위젯에서 처리될 경우 accept()를 호출하여야 하고 처리하지 않는 경우에는 ignore()를 호출해서 부모 위젯이 처리하도록 키 이벤트를 전파하도록 한다. 위 코드에서 QWidget.keyPressEvent(event)는 단순히 event.ignore()를 호출하면, QKeyEvent는 accepted 플래그가 초기부터 True이므로 accept() 호출이 없더라도 이벤트 핸들러가 리턴되면 accept()를 호출한 것과 같다. 만약 위 코드를 accept()와 ignore()를 써서 작성한다면 다음과 같다. class MyWidget(QWidget): def __init__(self, parent=None): QWidget.__init__(self, parent) self.setFocusPolicy(Qt.StrongFocus); // enable keyPressEvent() ... def keyPressEvent(event): # QKeyEvent : event if event.key() == Qt.Key_Escape: self.doEscape() event.. accept() else: event.ignore() ... QWidget 외에 위젯에서 상속받는 경우에는 키 이벤트 핸들러의 디폴트 거동이 어떤지를 파악해서 부모 클래스의 키 이벤트 핸들러를 호출해 주어야 한다. QCloseEvent QCloseEvent는 accept()와 ignore() 함수의 호출이 약간 다른 의미를 갖는다. 다음 대표적인 QCloseEvent에 대한 이벤트 핸들러이다. class MainWindow(QMainWindow): ... def closeEvent(self, event): # QCloseEvent if self.userReallyWantsToQuit(): ... do something before quit event.accept() else: event.ignore() ... QCloseEvent 핸들러에서는 accept()를 호출하면 닫기 이벤트를 정상적으로 처리하라, 즉 창을 닫으라는 의미이고, ignore()는 닫기 이벤트를 무시하고 아무 일이 없다는 듯 닫기 이벤트가 발생하지 않은 원상태로 되돌린다. 5.4 위젯 속성과 이벤트 어떤 이벤트는 위젯의 속성에 따라 발생 여부가 결정되는 경우가 있다. mouseMoveEvent(QMouseEvent) 핸들러는 디폴트로 마우스가 눌린 상태로 이동해야 발생한다. 마우스 이동 시 마우스 눌림과 상관없이 마우스 이동 이벤트가 발생하게 하려면 QWidget.setMouseTracking(True)를 호출해야 주어야 한다. keyPressEvent(QKeyEvent), focusInEvent(QFocusEvent), focusOutEvent(QFocuseEvent)를 위젯에서 하용하려면 위젯의 focusPolicy 속성을 포커스를 받도록 QWidget.setFocusPolicy(Qt.StrongFocus) 등을 호출해서 설정해 주어야 한다. 적용 가능한 포커스 정책은 Qt.StrongFocus 이외에 Qt.TabFocus, Qt.ClickFocus가 있습니다. Qt::TabFocus는 탭키로 포커스를 준다. Qt::ClickFocus는 마우스 클릭으로 포커스를 준다 Qt::StrongFocus는 이 둘의 조합으로 탭 키나 마우스 클릭이 발생했을 때 그 위젯으로 포커스를 준다. contextMenuEvent(QContextMenuEvent)는 QWdiget.setContextMenuPolicy(Qt.DefaultCo- ntextMenu)를 설정해야 발생한다. inputMethodEvent(QInputMethodEvent)는 setAttribute(Qt.WA_InputMethodEnabled)를 설정해야 발생한다. dropEvent(QDropEvent)는 setAcceptDrops(True)를 설정해야 발생한다. 이벤트 핸들러는 위젯에 시그널을 발생시키는 용도로 많이 사용된다. 다음은 어떤 위젯의 마우스 이동할 때 positionChanged() 시그널을 발생시킨 예이다. class MyWidget(QWidget): mousePositionChanged = Signal(str) # mousePositonChanged(str) def __init__(self, parent=None): QWidget.__init__(self, parent) self.setMouseTracking(True) ... def mouseMoveEvent(self, event): # QMouseEvent event pos = "({},{})".format(event.x(),event.y()) self.mousePositionChanged.emit(pos) ... 5.5 타이머 이벤트 QTimerEvent 타이머 이벤트(QTimerEvent)는 위젯이 아닌 QObject를 대상으로 발생하기 때문에 GUI 요소가 아니더라도 자유롭게 사용할 수 있다. QObject의 startTimer(millisecond)로 밀리초 단위로 타이머 이벤트를 발생시킬 수 있다. 타이머의 처리는 timerEvent() 핸들러를 이용한다. 사용이 끝나면 killTimer(id)로 타이머를 종료합니다. startTimer(millisecond)를 호출하면 할당된 타이머의 고유번호(timerId)를 리턴합니다. 타이머 자체는 운영 체계에서 관리하는 자원이며, 여러 개의 타이머를 사용할 수도 있다. 따라서 할당된 타이머에는 고유번호가 있게 된다. 이 번호를 이용해 killTimer(id)로 타이머를 멈추게 합니다. 또한 timerEvent() 핸들러에서 event.timerId()로 타이머 이벤트를 발생시킨 타이머를 식별할 수 있다. 다음은 1개의 타이머를 사용하는 일반적인 코드이다. class MyObject(QObject): ... def OnStartTimer(self): self.timerId = self.startTimer(10) # 10 milliseconds def OnKillTimer(self): self.killTimer(timerId); def timerEvent(self, event): # QTimerEvent if event.timerId() != self.timerId: super().timerEvnet(event); .... something to process the timer event QTimer Qt는 타이머 이벤트를 처리하는 대신 편리한 시그널/슬롯 메커니즘을 이용할 수 있도록 QTimer라는 클래스를 제공한다. QTimer는 QObject로부터 상속받은 클래스로 start(millisecond), stop() 슬롯 함수와 timeout() 시그널을 제공한다. start(millisecond)로 QTimer 클래스 내의 타이머를 시작합니다. QTimer 클래스는 주어진 시간이 되면 timeout() 시그널을 발생 시게 되므로 timeout() 시그널을 연결하여 다른 작업하도록 할 수 있다. stop()은 타이머를 종료한다. QTimer는 1개의 타이머를 내장하고 그 고유번호를 관리하기 때문에 QTimer를 활용할 때는 고유번호 대신 QTimer 객체 자체를 고유번호처럼 사용하면 된다. 다음은 AnalogClock 예제에서 QTimer 관련 사항을 발췌한 것입니다. class AnalogClock(QWidget): updated = Signal(QTime) #updated(QTime currentTime); def __init__(self, parent=None): QWidget.__init__(self, parent) ... timer = QTimer(self) timer.timeout.connect(self.update) timer.start(1000) def paintEvent(self, event): ...그리기 코드 self.updated.emit(time) AnalogClock 위젯은 화면에 1초에 한번 그리기를 수행한다. 생성자에서 단순히 타이머를 생성하고 timeout() 시그널을 update() 슬롯으로 연결하였다. 1초 간격으로 타이머를 시작하므로 1초 단위로 timeout() 시그널이 발생하게 되면 자동적으로 update()가 호출됩니다. update() 호출로 paintEvent() 핸들러가 작동한다. 또한 AnalogClock:update(QTime)이라는 시그널을 1초 단위로 발생하도록 paintEvent()핸들어 마지막에 정의하고 있다. 만약 QTimer를 이용하지 않고 위젯(위젯도 QObject 자식 클래스이므로)에 내장된 타이머를 이용하는 경우 다음과 코드가 작성되어야 합니다. 비교하면 QTimer의 장점을 이해할 수 있습니다. class AnalogClock(QWidget): updated = Signal(QTime) #updated(QTime currentTime); def __init__(self, parent=None): QWidget.__init__(self, parent) ... self.timeId = self.startTime(1000) def timeEvent(self, event): # QTimerEvent if event.timerId() != self.timeId : super().timerEvent(event) self.update() def paintEvent(self, event): ...그리기 코드 self.updated.emit(time) def closeEvent(event): # QCloseEvent self.killTimer(self.timeId) if self.userReallyWantsToQuit() : event.accept() else: event.ignore() QTimer는 단 한 번만 발생하는 타이머 이벤트를 시그널/슬롯 메커니즘으로 처리하는 기능을 제공한다. 정적 함수(static function)인 `QTimer.singleShot(miliseconds, slotFunction)을 호출하면 된다 QTimer.singleShot(200, self.updateCaption) 위 코드는 200 밀리초 후 updateCaption() 슬롯을 실행하도록 한다. 5.6 레이아웃 위젯의 형상 QWidget에는 자신의 현재 형상과 관련해서 부모 위젯에 대해 상대적인 좌표값을 담고 있는 QRect 타입의 geometry, frameGeometry 멤버를 가지고 있다. 위젯의 위치가 변경되거나 크기가 바뀔 때마다 이 두 변수의 값은 현재 값으로 유지된다. 위젯의 클라이언트 영역의 크기는 width(), height(), size(), rect() 등 어느 것을 써도 상관없다. 이때 기본적인 좌표계는 위젯이 좌측 상단을 (0,0)으로 하고 +x 방향은 오른쪽, +y는 아래 방향이다. 픽셀 단위가 사용되면 이 좌표계가 뷰포트 좌표계이다. 이때 오른쪽 하단의 끝점은 (width()-1, height()-1)인 점에 주의해야 한다. 레이아웃 위젯의 레이아웃을 지정하는 방법에는 다음의 세 가지가 있다. 직접 gemoerty 변수를 변경하는 방법 : QWidget.setGeomerty(x, y, w, h), QWidget.resize(w, h) 등의 함수로 geometry 변수를 변경하는 직접 위젯의 초기 위치를 지정하는 방법이다. 일반적으로 최상위 위젯으로 사용될 경우에만 사용됩니다. 자식 위젯에서 사용할 경우 부모 위젯 내의 상대 위치를 직접 계산해야 하고, 사용자가 윈도 크기를 변경할 수 없으며 글꼴에 따라 일부 텍스트가 잘려나가는 등의 문제점을 가지고 있다. resizeEvent() 핸들러를 처리하는 방법 : 위젯의 크기가 바뀔 경우 QResizeEvent가 발생한다. 이때 resizeEvent(QResizeEvent) 핸들러에서 처리는 방법으로 레이아웃을 결정할 수 있다. 이 방법은 프로그래머의 코딩에 의한 것이므로 상당한 하드코딩이 필요합니다. 따라서 레이아웃 클래스를 사용하는 것이 적절하지 않을 때 제한적으로 사용됩니다. 레이아웃 클래스를 이용하는 방법 : Qt의 독특하면서도 강력한 기능인 레이아웃 클래스를 이용하는 것이다. 레이아웃 클래스는 QWidget의 sizeHint(), mimimumSizeHint(), sizePolicy라는 멤버를 이용해 레이아웃을 결정하게 된다. 보다 자세한 자세한 사항은 뒤에 다시 설명한다. 레이아웃이 작동되는 방식을 이해할 때 최상위 위젯과 자식 위젯 중 어떤 위젯으로 사용되는 가에 따라 QResizeEvent가 발생하는 조건을 정확하게 이해해야 한다. ▪ 최상위 위젯의 경우 사용자가 위젯의 크기를 직접 바꾸거나, resize(w, h)를 호출할 때 발생한다. ▪ 자식 위젯으로 사용되는 경우에는 레이아웃 클래스로 관리될 때는 레이아웃이 바뀔 때마다, 레이아웃 클래스로 관리되지 않을 때는 프로그래머가 직접 resize(w, h)를 호출해야 발생한다. 자식 위젯으로 사용되고 레이아웃으로 관리되고 있는 경우에도 레이아웃 클래스가 자신의 자식 위젯에 대해 resize(w, h)를 호출하게 되고 결국 QResizeEvent가 발생하게 된다. 하지만 레이아웃 매니저(레이아웃 클래스의 객체)로 관리되는 자식 위젯에 대해 프로그램 가 직접 resize(w, h)나 setGeometry() 등을 호출하면 무시된다. 한편, resizeEvent() 핸들러 내에서 resize()를 호출한다면 무한 루프에 빠지게 되므로 주의해야 한다. 또한 QWidget::resize() 핸들러는 mimimumSize, maximumSize라는 멤버를 이용해 최소 및 최소 크기에 대한 제한 값으로 사용하므로 그 이하 또는 그 이상 크기가 조절되지 않도록 한다. 두 멤버는 setMinimumSize(), setMaximumSize() 함수로 설정할 수 있는 데 QWidget의 디폴트 값은 (0,0)과 (1677721,1677721)로 설정되어 있다. 레이아웃 매니저 커스텀 위젯을 제작할 때는 자식 위젯으로 사용될 경우를 대비해서 레이아웃 매니저(레이아웃 클래스의 객체)로 적절히 레이아웃이 되도록 작성해야 한다. 마찬가지로 Qt가 제공하는 QPushButton, QLabel, QLineEdit 등의 기본 위젯들도 자식 위젯으로 사용될 때 어떻게 레이 아웃되는지를 이해하고 있어야 한다. 레이아웃 매니저(레이아웃 클래스의 객체)로 관리될 때 자식 위젯들이 레이아웃을 결정하는 데는 다음과 같은 QWidget의 멤버가 사용된다. minimumSize, maximumSize : 위젯의 크기 변화가 가능한 최소 및 최소 크기를 의미한다. QWidget의 디폴트 값은 각각 (0,0)과 (16777215,16777215)이다. setMinimumSize(), setMaximumSize()로 변경할 수 있다. 두 값은 동일하게 한다면 더 이상 크기 변화가 되는다. 편의 함수로 setFixedSize() 함수는 인자로 주어진 값으로 동일한 minimumSize와 maximumSize로 설정해 준다. sizeHint()와 mimimumSizeHint(), sizePolicy : 이 값들은 레이아웃 매니저로 관리될 때 의미를 갖는 값이다. sizeHint()에서 리턴되는 크기는 위젯이 가지는 이상적인 크기를 의미한다. minimumSizeHint()는 이상적인 최소 크기를 의미하는 데 레이아웃 매니저로 관리될 때 그 이하로 크기가 줄지 않도록 한다. 만약 minimumSize가 설정되어 있으면(minimumSize가 (0,0)이 아니면) 사용되지 않는다. sizeHint()와 minimumSizeHint()는 가상함 수로 항상 호출되기만 하는 값이므로 외부에서 변경이 불가능하며, 변경하려면 커스텀 위젯을 만들고 다음의 가상 함수를 재정의해 주어야 한다. class CustomWidget(QWidget): ... def sizeHint(self): ... # QSize 리턴 def mimimumSizeHint(self): ... # QSize 리턴 sizeHint()는 크기 정책(sizePolicy)에서 어떤 식으로 활용할 건지 결정한다. 크기 정책(QSizePolicy 클래스)으로는 Fixed, Minimum, Maximum, Preference, Expanding이 있고, QWidget.setSizePolicy()로 설정할 수 있다. QWidget.setSizePolicy(horizontalSizePolicy, verticalSizePolicy) 위에서 horizontalSizePolicy, verticalSizePolicty는 QSizePolicy.Policy라는 열거 상수로 다음을 사용할 수 있다. QSizePolicy.Fixed : 위젯의 크기는 sizeHint()가 나타내는 크기로 고정됨 QSizePolicy.Minimum : sizeHint()가 최소이며서 최적의 크기. 필요한 경우 늘어날 수 있음. QSizePolicy.Maximum : 위젯의 sizeHint()가 최대이면 최적의 크기. 필요한 경우 줄어들 수 있음. 최소 크기는 minimumSizeHint(). QSizePolicy.Preferred : 위젯의 sizeHint()가 최적의 크기. 줄거나 늘어날 수 있음. 최소 크기는 minimumSizeHint(). QSizePolicy.Expanding : 위젯의 sizeHint()가 최적의 크기. 줄거나 늘어날 수 있음. 공간이 더 있는 경우 이를 사용함. 최소 크기는 minimumSizeHint(). QSizePolicy.MinimumExpanding : sizeHint()가 최소이며서 최적의 크기. 필요한 경우 늘어날 수 있음. 공간이 더 있는 경우 이를 사용함. 최소 크기는 minimumSizeHint(). QSizePolicy.Ignored : sizeHint() 무시. 위젯은 가능한 공간을 가집. QLineEdit, QComboBox 등과 같이 Qt가 제공하는 기본 위젯들은 대부분 자신만의 sizePolicy, sizeHint()와 mimimumSizeHint()를 가진다. 예를 들어 QLineEdit는 수평 및 수직 방향의 sizePolicy가 각각 QSizePolicy.Minimum, QSizePolicy.Fixed이고, 수평 방향으로는 15-20개의 문자와 수직 방향으로 1개 문자 높이 정도로 sizeHint()를 재정의하고 있다. 따라서 QLineEdit를 레이아웃 매니저로 관리하는 경우 수평방향으로는 15-20 문자를 갖는 크기로 배치되면서 필요한 경우 늘어날 수 있지만, 수직 방향으로는 고정된 크기 값을 갖는다. QLineEdit는 minimumSizeHint()를 1개 문자가 들어갈 정도로 재정의하고 있다. QSizePolicy.Minimum 일 때 필요 없는 minimumSizeHint()를 재정의한 것은 QSizePolicy.Preferred, QSizePolicy.Expanding, QSizePolicy.MinimumExpanding 등과 같이 줄어들 여지가 있는 sizePolicy로 바꿀 경우를 대비해서이다. 커스텀 위젯을 제작할 때 레이아웃 클래스에 의해 관리되도록 하려면 다음과 같이 관련된 코드를 작성해야 한다. 생성자에서 QWidget.setSizePolocy()을 호출하여 위젯의 디폴트 크기 정책을 설정한다. QWidget.sizeHint()를 위젯의 적절한 크기를 리턴하도록 재정의한다. 줄어들 여지가 있는 sizePolicy를 대비하여 QWidget.mimumSizeHint()를 위젯의 최소 크기를 리턴하도록 재정의한다. 커스텀 위젯의 멤버 함수 작성 시 sizeHint()가 변경될 수 있는 작업하거나, sizePolicy를 변경한 경우 QWidget.updateGeometry()를 호출한다. 높이와 폭를 제어하고자 할 때는 setHeightForWidth(True)를 호출하여 height-for-width 플래그를 활성화하고(보통 생성자에서), QWidget.heightForWidth()를 재정의한다. (1), (2)가 필수사항이고, (3)은 줄어들 수 있는 sizePolicy를 지정하는 경우를 대비하여 최소 크기를 정의하는 데 사용된다. 만약 QSizePolicy.Fixed, QSizePolicy.Minimum, QSizePolicy.Ignored만 사용한다고 가정한다면 minimumSizeHint()를 재정의할 필요 없다. (4)는 커스텀 위젯 내부의 어떤 행위로 인해(멤버 함수 구현 시) 레이아웃이 변경될 때 호출해 줍니다. (5)는 거의 사용될 일이 없다. 5.7 서브클래싱시 주의사항 지금까지 설명한 사항을 요약하여 QWidget에서 직접 서브클래싱으로 커스텀 위젯을 만드는 경우에 대해서 필요한 개략적인 형태의 클래스 형태는 다음과 같습니다. class MyWidget(QWidget): def __init__(self,....,parent=None): QWidget.__init__(self, parent) # 필요시 관련 속성 설정 self.setAttribute(Qt.QA_DeleteOnClose, True); self.setAttribute(Qt.QA_StaticContents, True); self.setAttribute(Qt.QA_Hover, True); self.setMouseTracking(True); self.setFocusPolicy(Qt.StrongFocus) self.setContextMenuPolicy(Qt.DefaultContextMenu) self.setAcceptDrops(True); self.setAttribute(Qt.WA_InputMethodEnabled, True); self.setAttribute(Qt.WA_KeyCompression, True); # 필요시 배경색 설정 self.setBackgrundRole(QPalette.Dark); self.setAutoFillBackground(True); # 디폴트 sizePolicy 설정 self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum); ... # 레이아웃 관련 함수 재정의 def sizeHint(self): ... def mimimumSizeHint(self): ... # 이벤트 핸들러를 재정의 def keypressEvent(event): ... ... def paintEvent(event): # 다시 그리기가 필요할 때 ... 5.8 AnalogClock AnalogClock 예제는 앞서에서 배운 위젯의 특성을 이용한 것이다. 그리기 코드에 대한 설명은 6.4 AnalogClock 예제 분석을 참조하도록 한다. AnalogClock.py from PySide2.QtWidgets import QWidget, QSizePolicy from PySide2.QtCore import Signal, Qt, QTimer, QTime, QPoint, QRectF, QSize from PySide2.QtGui import QPainter, QColor, QRadialGradient, QPen class AnalogClock(QWidget): updated = Signal(QTime) #updated(QTime currentTime); def __init__(self, parent=None): QWidget.__init__(self, parent) self.backgroundColor = Qt.gray self.timeZoneOffset = 0 self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum) timer = QTimer(self) timer.timeout.connect(self.update) timer.start(1000) def sizeHint(self): return QSize(200,200) def setBgColor(self, newColor): self.backgroundColor = newColor def setTimeZone(self, hourOffset): self.timeZoneOffset = min(max(-12, hourOffset),12)*3600 self.update() def paintEvent(self, event): hourHand = [QPoint(7,8), QPoint(-7,8), QPoint(0, -40)] minuteHand = [QPoint(7,8), QPoint(-7,8), QPoint(0, -70)] secondHand = [QPoint(0,8),QPoint(0, -80)] hourColor = QColor(127,0,127) minuteColor = QColor(0,127,127,191) secondColor = QColor(255,0,0,191) side = min(self.width(),self.height()) time = QTime.currentTime() # static function time = time.addSecs(self.timeZoneOffset) painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing, True) painter.translate(self.width()/2, self.height()/2) painter.scale(side/200.0, side/200.0) # Draw circle radialGradient = QRadialGradient(0,0,100, -40, -40) # center, radius, focalPoint radialGradient.setColorAt(0.0, Qt.white) radialGradient.setColorAt(1.,self.backgroundColor) painter.setBrush(radialGradient) painter.setPen(QPen(Qt.darkGray, 0)) # darkGray cosmetic pen painter.drawEllipse(QRectF(-97, -97,194,194)) # Draw minute tick painter.setPen(minuteColor) for j in range(60): if (j % 5) != 0: painter.drawLine(92,0,96,0) painter.rotate(6.0) # draw hour hand painter.setPen(Qt.NoPen) painter.setBrush(hourColor) painter.save() painter.rotate(30.0*((time.hour()+time.minute()/60.0))) painter.drawConvexPolygon(hourHand) painter.restore() # draw hour tick painter.setPen(hourColor) for i in range(12): painter.drawLine(88,0,96,0) painter.rotate(30.0) # draw mimute hand painter.setPen(Qt.NoPen) painter.setBrush(minuteColor) painter.save() painter.rotate(6.8*(time.minute()+time.second()/60.0)) painter.drawConvexPolygon(minuteHand) painter.restore() # Draw second hand painter.setPen(secondColor) painter.save() painter.rotate(6.0*time.second()) painter.drawLine(secondHand[0],secondHand[1]) painter.restore() self.updated.emit(time) from PySide2.QtWidgets import QApplication import sys if __name__ == "__main__": app = QApplication(sys.argv) clock = AnalogClock() clock.setWindowTitle("Render Minimal") clock.resize(530,360) clock.show() app.exec_() 6. 그래픽스 Qt의 그리기는 2차원과 3차원으로 구분하는데, 각각 QPainter와 Open GL API를 사용합니다. 이 책은 QPainter API를 대상으로 설명한다. Qt 페인팅 시스템 Qt의 페인팅 시스템은 QPainter, QPaintEngine, QPaintDevice로 구성되어 있다. 아래 그림에 나타낸 것과 같이 QPainter API를 통해 화면(즉, 위젯)이나 이미지 파일, 출력장치에 그리기를 할 수 있다. QPainter는 그리기 작업을 담당한다. 여러 API를 통해 그리기를 수행할 수 있다. QPaintEngine은 QPainter와 QPaintDevice에서 내부적으로 사용되는 클래스로 프로그램 개발자가 알아두어야 할 필요는 거의 없다. QPaintDevice는 QPainter로 그릴 2차원 영역을 추상화한 것이다. 페인트 디바이스 중 QWidget은 위젯의 최상위 클래스로 화면을 의미한다. 페인트 디바이스 중 QImage, QPixamp, QBitmap, QPicture, QSvgGenerator는 Qt에는 이미지 데이터를 다루기 위한 5개의 클래스이다. QImage는 입출력에 최적화되어 있으며 픽셀 단위로 이미지를 다루는 용도로 사용되는 반면, QPixmap은 화면에 이미지를 출력하는 데 최적화되어 있다. 쉽게 표현하면 QImage는 메인 메모리상의 이미지이고 QPixmap은 비디오카드상에 존재한다고 할 수 있다. QPixmap은 빠른 대신 하드웨어에 의존하며, QImage는 플랫폼에 의존하지 않는다. 보통 QPixmap은 명시적인(explicit) 더블 버퍼링(double buffering)에 사용되고, QImage는 픽셀 단위의 작업이 필요한 고품질의 이미지 작업을 할 때 사용된다. QBitmap은 QPixmap의 자식 클래스로 흑백 픽스 맵을 의미한다. QPicture는 QPainter API 명령을 저장하고 리플레이하는 장치이다. Qt는 윈도우즈 메타파일인 WMF나 EMF를 지원하지 않지만 QPicture를 통해 QPainter의 명령을 저장하는 방식으로 Qt 전용의 메타파일(metafile)을 지원한다. QSvgGenerator는 표준 벡터 그래픽 파일인 SVG 파일을 생성하는 사용된다. QPrinter는 프린터 디바이스를 의미하는 데 보통 QPrintDialog로 프린터를 찾아서 사용한다. QPrinter를 이용할 때 PDF 프린터 드라이버가 있으면 PDF로 출력 가능하다. 만약 없다면 QPdfWriter를 사용하여 PDF 문서를 만들 수 있다. QWidget과 QPrinter를 제외하면 모두 Qt GUI 모듈에 포함되고, QSvgGenrator, QPrinter, QPdfWriter는 쓰기 전용이다. QPainter 사용법 QPainter는 생성할 때 자신의 작업을 수행할 대상 디바이스를 생성자 QPainter(QPainterDevice)에서 지정한다. 이후 작업은 그리기와 관련된 API를 동일하게 적용할 수 있다. 다만 위젯에 그리기(=화면에 그리기)는 반드시 paintEvent(event) 이벤트 핸들러에서 수행되어 한다. # 위젯에 그리기를 수행할 때 def paintEvent(self, event): painter = QPainter(self) ... #이미지에 그리기를 수행할 때 imagePainter = QPainter(image) # image는 QImage의 객체 ... # 프린터에 그리기를 수행할 때 printerPainter = QPainter(printer) # printer는 QPrinter 객체 ... Qt에서는 이와 같이 클래스 상속 개념을 통해 다양한 디바이스의 출력을 동일한 작업으로 수행할 수 있도록 하고 있다. 예를 들어 화면의 내용을 출력하고자 할 때 많이 쓰는 기법 중에 하나가 QPaintDevice를 인자로 그리기를 수행하는 함수를 작성한 후 여건에 따라 이 함수를 호출하는 것다. class MyWidget(QWidget): ... def drawScreen(self, device): painter = QPainter(device) painter.setRenderHint(QPainter.Antialiasing, true) painter.setPen(QPen(Qt.black, 4, Qt::DotLine, Qt.RoundCap)) # 펜 설정 painter.setBrush(QBrush(Qt.green, Qt.SolidPattern)) # 브러시 설정 painter.setFont(QFont("Arial",30)) # 폰트 설정 rect = QRect(80,80,400,200) painter.drawRoundedRect(rect, 50,50) # 경계선은 펜, 내부는 브러시 painter.drawText(rect, Qt.AlignCenter,"Hello, Qt!") # 펜의 색상, 폰트 사용 def paintEvent(self, event): self.drawScreen(self) def printSomething(self): printer = QPrinter() dialog = QPrintDialog(printer, self) if dialog.exec_(): self.drawScreen(printer); def exportToImageFile(self): pixmap = QPixmap(self.size()) pixmap.fill(self.palette().color(self.backgroundRole())) self.drawScreen(pixmap) pixmap.save(‘./test.png’) 6.1 QPainter 이번 절은 예제를 먼저 소개하고 순차적으로 설명한다. RenderLab 예제는 아래 그림처럼 QPainter의 기능을 테스트하는 예제이다. 먼저 리소스 파일과 리소스 컴파일이다. RenderLab.qrc <!DOCTYPE RCC><RCC version="1.0"> <qresource> <file>images/brick.png</file> <file>images/qt-logo.png</file> </qresource> </RCC> >pyside2-rcc -o RenderArea_rc.py -py3 RenderArea.qrc 소스코드는 다음과 같다. 코드는 drawScene() 함수에서 그리기 작업이 이루어지고 이 함수를 paintEvent()나 print_(), exportToFile() 시에서 공통적으로 사용하는 것이 특징이다. drawScene()의 그리기 작업은 선택한 메뉴에 반응하여 여러 작업을 하도록 분배하고 있다. 각 작업에 대한 함수는 이어지는 문서에서 설명과 함께 소개한다. RenderLab.py from PySide2.QtWidgets import QWidget, QActionGroup, QAction, QFileDialog from PySide2.QtPrintSupport import QPrintDialog, QPrinter from PySide2.QtGui import (QPainter, QPen, QBrush, QFont, QPalette, QPainterPath, QPixmap, QLinearGradient, QConicalGradient, QRadialGradient, QPdfWriter, QColor, QRegion) from PySide2.QtCore import Qt, QRect, QRectF, QPoint, QPointF, QFileInfo from PySide2.QtSvg import QSvgGenerator import RenderArea_rc class RenderArea(QWidget): def __init__(self, parent=None): super().__init__(parent) self.setAutoFillBackground(True) self.setBackgroundRole(QPalette.Base) # load resource self.pixmapLogo = QPixmap() self.pixmapLogo.load(":/images/qt-logo.png") self.pixmapTexture = QPixmap() self.pixmapTexture.load(":/images/brick.png") # scene actions self.actionGroupScene = QActionGroup(self) texts = ["Draw Rendering API" , "Draw Qt::GlobalColor", "Draw Qt::PenStyle" , "Draw Qt::PenCapStyle and Qt::PenJoinStyle", "Draw Qt::BrushStyle" , "Draw Qt::FillRule", "Draw Path" , "Draw Text" , "Draw Gradient", "Drawing on Clipping Region" , "Draw Transform"] for i in range(len(texts)): action = QAction(texts[i],self) action.setCheckable(True) self.actionGroupScene.addAction(action) self.actionGroupScene.actions()[0].setChecked(True) self.actionGroupScene.triggered.connect(self.update) def sceneActions(self): return self.actionGroupScene def paintEvent(self, event): self.drawScene(self) def print_(self): printer = QPrinter() dialog = QPrintDialog(printer, self) if dialog.exec_(): drawScene(printer) def exportToFile(self): fileName,_ = QFileDialog.getSaveFileName(self,"Export file",".", "JPG file(*.jpg);;PNG file (*.png);;PDF file (*.pdf);;SVG file (*.svg)") if fileName == "": return if QFileInfo(fileName).suffix() == "jpg" or QFileInfo(fileName).suffix() == "png" : pixmap = QPixmap(self.size()) pixmap.fill(self.palette().color(self.backgroundRole())) self.drawScene(pixmap) pixmap.save(fileName) elif QFileInfo(fileName).suffix == "svg" : svgGenerator = QSvgGenerator() svgGenerator.setFile(fileName) self.drawScene(svgGenerator) else: pdfWriter = QPdfWriter(fileName) self.drawScene(pdfWriter) def drawScene(self, device): text = self.actionGroupScene.checkedAction().text() if text == "Draw Rendering API": self.drawRenderingAPI(device) elif text == "Draw Qt::GlobalColor": self.drawGlobalColor(device) elif text == "Draw Qt::PenStyle": self.drawPenStyle(device) elif text == "Draw Qt::PenCapStyle and Qt::PenJoinStyle": self.drawPenCapJoinStyle(device) elif text == "Draw Qt::BrushStyle": self.drawBrushStyle(device) elif text == "Draw Qt::FillRule": self.drawFillRule(device) elif text == "Draw Path": self.drawPath(device) elif text == "Draw Text": self.drawText(device) elif text == "Draw Gradient": self.drawGradient(device) elif text == "Drawing on Clipping Region": self.drawClipping(device) elif text == "Draw Transform": self.drawTransform(device) def drawRenderingAPI(self, device): ... def drawGlobalColor(self, device): ... def drawPenStyle(self, device): ... def drawPenCapJoinStyle(self, device): ... def drawBrushStyle(self, device): ... def drawFillRule(self, device): ... def drawPath(self, device): ... def drawText(self, device): ... def drawGradient(self, device): ... def drawClipping(self, device): ... def drawTransform(self, device): ... from PySide2.QtWidgets import QMainWindow, QAction class MainWindow(QMainWindow): def __init__(self, parent=None): super().__init__(parent) self.renderArea = RenderArea(self) self.setCentralWidget(self.renderArea) actionPrint = QAction("&Print",self) actionPrint.triggered.connect(self.renderArea.print_) actionExport = QAction("&Export",self) actionExport.triggered.connect(self.renderArea.exportToFile) menuPrint = self.menuBar().addMenu("&PaintDevice") menuPrint.addAction(actionPrint) menuPrint.addAction(actionExport) menuScene = self.menuBar().addMenu("&Scene") menuScene.addActions(self.renderArea.sceneActions().actions()) from PySide2.QtWidgets import QApplication import sys if __name__ == '__main__': app = QApplication(sys.argv) mainWindow = MainWindow() mainWindow.resize(1100,401) mainWindow.show() app.exec_() 6.1.1 그리기 1 아래 그림은 RenderArea.drawRenderingAPI()가 실행된 전경으로 QPainter의 drawXXX() 형태의 그리기 함수 중 drawImage(), drawPicture() 등 일부 함수를 제외하고 주로 사용되는 함수를 이용해 그리기를 수행한 것이다. RenderLab.drawRenderingAPI(self, device) def drawRenderingAPI(self, device): painter = QPainter(device) painter.setRenderHint(QPainter.Antialiasing, True) painter.setPen(QPen(Qt.black, 2, Qt.SolidLine, Qt.RoundCap)) painter.setBrush(QBrush(Qt.darkGreen, Qt.SolidPattern)) painter.setFont(QFont("Arial",12)) rect = QRect(10,20,180,120) rectText = QRect(0,140,200,40) rects = [QRect(10,20,100,80),QRect(80,60,100,80)] points = [QPoint(20,120),QPoint(40,20),QPoint(140,60),QPoint(180,120)] path = QPainterPath() path.moveTo(40,120) path.lineTo(40,60) path.cubicTo(180,0,100,100,180,120) startAngle = 90*16 arcLength = 120*16 # point painter.translate(10,10) painter.drawPoint(rect.center()) painter.drawText(rectText, Qt.AlignCenter,"drawPoint()") # points painter.translate(200,0) painter.drawPoints(points) painter.drawText(rectText, Qt.AlignCenter,"drawPoints()") # line painter.translate(200,0) painter.drawLine(rect.topLeft(),rect.bottomRight()) painter.drawText(rectText, Qt.AlignCenter,"drawLine()") # lines painter.translate(200,0) painter.drawLines(points) painter.drawText(rectText, Qt.AlignCenter,"drawLines()") # rectangle painter.translate(200, 0) painter.drawRect(rect) painter.drawText(rectText, Qt.AlignCenter, "drawRect()") # rectangles painter.translate(200, 0) painter.drawRects(rects) painter.drawText(rectText, Qt.AlignCenter, "drawRects()") # rounded rect painter.translate(-1000,200) painter.drawRoundedRect(rect, 25,25, Qt.RelativeSize) painter.drawText(rectText, Qt.AlignCenter,"drawRoundRect()") # ellipse painter.translate(200,0) painter.drawEllipse(rect) painter.drawText(rectText, Qt.AlignCenter,"drawEllipse()") # polyLine painter.translate(200,0) painter.drawPolyline(points) painter.drawText(rectText, Qt.AlignCenter,"drawPolyline()") # polygon painter.translate(200,0) painter.drawPolygon(points) painter.drawText(rectText, Qt.AlignCenter,"drawPolygon()") # convex polygon painter.translate(200,0) painter.drawConvexPolygon(points) painter.drawText(rectText, Qt.AlignCenter,"drawConvexPolygon()") # arc painter.translate(200,0) painter.drawArc(rect, startAngle, arcLength) painter.drawText(rectText, Qt.AlignCenter,"drawArc()") # chord painter.translate(-1000,200) painter.drawChord(rect, startAngle, arcLength) painter.drawText(rectText, Qt.AlignCenter,"drawChord()") # pie painter.translate(200,0) painter.drawPie(rect, startAngle, arcLength) painter.drawText(rectText, Qt.AlignCenter,"drawPie()") # path painter.translate(200,0) painter.drawPath(path) painter.drawText(rectText, Qt.AlignCenter,"drawPath()") # text painter.translate(200,0) painter.drawText(rect, Qt.AlignCenter,"Hello Qt") painter.drawText(rectText, Qt.AlignCenter,"drawText()") # pixmap painter.translate(200,0) painter.drawPixmap(40,40, self.pixmapLogo) painter.drawText(rectText, Qt.AlignCenter,"drawPixmap()") # fillRect linGradient = QLinearGradient(rect.bottomRight(),rect.topLeft()) linGradient.setColorAt(0, Qt.darkGreen) linGradient.setColorAt(0.5, Qt.green) linGradient.setColorAt(1.0, Qt.white) brush = QBrush(linGradient) painter.translate(200,0) painter.fillRect(rect, brush) painter.drawText(rectText, Qt.AlignCenter,"fillRect()") painter.translate(x, y)는 QPainter의 좌표계를 평행이동하는 역할을 수 행합니다. 여기에서는 drawXXX() 함수를 그릴 때 QPoint, QRect 등으로 지정한 좌표값을 상대 좌표로 활용하기 위해 사용하였다. 보조 클래스 QPainter의 drawXXX() 함수에서는 QPoint, QLine, QRect, QPolygon 등과 같은 점, 선, 사각형, 폴리곤 등을 나타내는 자료구조를 담은 보조 클래스가 많이 사용된다. QPointF, QLineF, QRectF, QPolygonF 등과 같이 F로 끝나는 클래스는 실수형 값을 사용한다. 2차원 그래픽스를 담당하는 QPainter에서 그리기 대상인 화면은 정수로 좌표를 표현하지만, 치수 계산이 많은 경우 라운드 오프 에러를 줄이기 위해 실수형의 보조 클래스가 도입되었다. 또한 뒤에 설명할 앤티얼라이싱이 활성화된 경우 특별한 의미를 갖기도 한다. 보조 클래스 중 가장 유용한 클래스는 QRect입니다. 이들 클래스는 left(), right(), width(), height(), center(), bottomLeft(), topRight() 등과 같이 다양한 함수를 제공한다. 주의할 점은 관례적으로 right()와 bottom()이 각각 left()+width()-1, top()+height()-1 등 1픽셀만큼 작은 값을 리턴한다는 점이다. 만약 정확한 값을 구하려면 left() + width(), right() + height()를 쓰야 한다. QRect는 translate(x, y), translated(x, y), contains(), intersects() 등의 다양한 연산 함수를 제공합니다. rect = QRect(10,10,100,50) # x, y, width, height rect.translate(10,20) # (10,20) 만큼 평행이동 if rect.contains(5,20): # (5,10)이 rect에 포함되는지 검토 ... rect = rectA.intersected(rectB) // rectA와 rectB의 교차 영역을 리턴 QPolygon는 OPoint, QPolygonF는 QPointF의 배열로 이해할 수 있으며, 영역이므로 QRect 등가 유사하게 subtracted(), tranlsate(), united(), intersected(), containsPoint() 등 영역과 관련된 함수를 가진다. 기본 그리기 함수들 점과 선을 그리는 drawPoint(), drawPoints(), drawLine(), drawLines() 함수이고, QPainter의 펜 속성(QPen) 속성이 사용된다. 사각형은 drawRect(), drawRects(), 모서리가 둥근 사각형은 drawRoundedRect(), 타원은 drawEllipse()로 그린다. 경계선을 그릴 때는 QPainter의 펜(QPen) 속성, 내부는 브러시(QBrush) 속성이 사용된다. 폴리 라인(polyline)은 경계선만 있는 도형을 의미하고, 폴리곤은 내부가 곾찬 도형을 의미한다. 따라서 폴리 라인은 펜(QPen) 속성만을 폴리곤은 펜(QPen)과 브러시(QBrush) 속성을 이용한다. 폴리 라인은 drawPolyline(), 폴리곤은 drawPolygon(), drawConvexPolygon()을 사용한다. drawConvexPolygon()은 drawPolygon()과 같은데 그리기 속도가 우수하지만, 폴리곤 내각이 180도 보가 큰 경우(non-convex인 경우) 플랫폼에 따라 의도하지 않게 그려질 수 있다. drawPolygon()의 Qt::FillRule은 폴리곤이나 뒤에 설명한 패스로 구성되는 도형의 내부를 결정하는 알고리즘을 정의한다. Qt.OddEvenFill 또는 Qt.WindingFill을 선택할 수 있다. 일반적인 경우 차이가 없지만 아래 그림과 같이 별 모양처럼 폴리곤처럼 선분들이 교차하여 내부에 또 다른 영역을 형성하면 그 의미가 생긴다. Qt.OddEvenFill은 내외부가 번갈아 나오며(폴리곤 외부의 한점에서 수평으로 선을 폴리곤을 구성하는 선분을 만나면 브러시로 칠하고, Qt.WindingFill은 도형 외곽선 안쪽을 모두 칠한다. 아크(arc)는 현을, 코드(chord)는 현과 현의 양단을 잇는 선분을 가진 도형을, 파이(pie)는 현과 원점을 잇는 도형을 의미한다. 아크(arc)를 펜(QPen) 속성만 이용하며, 코드(chord) 및 파이(pie)는 펜과 브러시 속성을 이용한다. drawArc(), drawChord(), drawPie() 등의 함수르 사용한다. startAngle, spanAngle는 1/16도 단위이다( 360도가 되려면 5760=16 * 360). 각의 기준점은 3시 방향이며, +값은 반시계 방향, -값은 시계방향이다. 6.1.2 그리기 2 패스 패스(QPainterPath)를 이용하면 직선뿐만 아니라 곡선이 포함된 복잡한 도형을 그릴 수 있다. 패스는 moveTo(), lineTo(), cubicTo(), quadTo()라는 4개의 기본 함수를 연속적으로 호출하여 구성할 수 있다. lineTo(), cubicTo(), quadTo()는 현재 점 위치(currentPosition()로 얻을 수 있음)에서 주어진 다름 점 정보로 직선이나 2차, 3차 베지어 곡선을 그리는 함수입니다. 호출이 끝나면 현재 점 위치는 직선 또는 곡선의 끝점으로 변경된다. moveTo()는 단순히 현재 점 위치를 옮기는 역할을 한다. QPainterPath의 lineTo() 등과 같은 그리기 함수는 실수형을 기본적으로 사용한다. quadTo()로 그리는 2차 베지어 곡선은 시작점, 끝점, 제어점으로 구성되는데 시작점은 패스의 현재 점 위치를 사용하게 되고, 나머지 제어점과 끝점으로 인자를 구성한다. cubicTo()로 그리는 3차 베지어 곡선은 제어점이 1개 더 있는 형태이다. 연결된 선이나 곡선을 서브 패스(sub path)라고 하는데 패스 내에는 여러 서브 패스가 올 수 있다. 예를 들어 moveTo()를 호출하면 연결된 선이나 곡선이 끊어지면서 서브 패스가 생성된다. closeSubpath()는 강제로 서브 패스를 만들고 현 위치를 (0,0)으로 초기화한다. addEllipse(), addPolygon(), addRect(), addRoundedRect(), addArc() 등의 함수는 이들 4개의 기본 함수를 이용하여 구현되어 있으며, QPainter.drawEllipse() 등과 같이 QPainter의 대응하는 함수와 유사한 형태로 사용할 수 있다. 한편, addText(point, font, text) 함수로 주어진 폰트의 문자열의 윤곽선을 갖는 도형으로 패스를 만들 수 있다. 아래 그림은 RenderLab 예제의 RenderArea.drawPath()를 실행한 모습이다. 왼쪽 도형은 addRect()로 사각형을 그린 후, 2개의 베지어 곡선으로 패스를 구성한 것입니다. 내부에 칠하는 것은 디폴트인 Qt::OddFill이 설정에 따라 그린 것이다. 만약 이를 바꾸려면 path.setFillRule(Qt::WindingFill)을 호출하여 바꿀 수 있다. 오른쪽 도형은 문자열의 윤곽선을 이용해 패스를 구성한 것이다. 내부를 칠하는 브러시로 그래디 언트를 설정하였다. RenderArea.drawPath() def drawPath(self, device): painter = QPainter(device) painter.setRenderHint(QPainter.Antialiasing, True) painter.translate(50,50) painter.scale(2,2) # basic path path = QPainterPath() path.addRect(20,20,60,60) path.moveTo(0,0) path.cubicTo(99, 0,50,50,99,99) path.cubicTo( 0,99,50,50, 0, 0) path.contains(QPointF(40,40)) painter.setPen(QPen(QColor(79,106,25),1,Qt.SolidLine, Qt.FlatCap, Qt.MiterJoin)) painter.setBrush(QColor(122,163,39)) painter.drawPath(path) # text outline path linearGradient = QLinearGradient(0,0,200,200) linearGradient.setColorAt(0.,Qt.blue) linearGradient.setColorAt(1.,Qt.white) font = QFont("Helvetical",80) baseline = QPointF(100,80) outlinePath = QPainterPath() outlinePath.addText(baseline, font,"Qt") painter.setBrush(linearGradient) painter.setPen(Qt.NoPen) painter.drawPath(outlinePath) QPainterPath의 기타 함수로는 패스 내에 클리핑 영역을 설정하는 addRegion(), 패스를 폴리곤으로 변경하는 toFillPolygon(), toFillPolygons(), toSubpathPolygons(), 패스를 연경하는 addPath(), connectPath(), 점, 사각형, 패스 등의 도형이 현 패스 내에 있는지를 판단하는 contains() 함수 등이 있다. 텍스트 텍스트은 drawText() 함수로 QPainter에 설정된 펜의 색상과 폰트로 그린다. Qt.NoPen으로 펜 스타일을 지정하면 화면상에 텍스트가 나타나지 않는 점에 주의해야 한다. 또한, QPainter의 백그라운 브러시를 설정할 경우 텍스트가 나타나는 영역의 배경색을 칠할 수 있다. painter = QPainter(self) ... painter.setPen(Qt.red) # 색상 painter.setBackground(Qt.gray) # 백그라운드 브러시 painter.setBackgroundMode(Qt.OpaqueMode) # 백그라운 브러시 enable painter.setFont(QFont("Arial",15)) # 폰트 painter.drawText(10,10, “Hello, Qt”); drawText() 함수는 (1) 단순히 위치를 지정하는 버전과 (2) 사각형과 정렬 방식(alignment)를 동시에 지정하는 버전 류의 함수가 있다. drawText(x, y, text) 등은 (1)에 해당하고, drawText(rect, flags, text, boundingRect) 등은 (2)에 해당한다. 다음 그림은 RenderLab 예제의 RenderArea.drawText()를 실행한 결과이다. (1) 유형의 drawText() 함수에서 지정된 위치는 그림과 같이 좌측 하단부에 있다. RenderLab.drawText() def drawText(self, device): painter = QPainter(device) painter.setRenderHint(QPainter.Antialiasing, True) painter.setFont(QFont("Arial",100)) painter.setPen(Qt.blue) painter.setBackground(Qt.gray); painter.setBackgroundMode(Qt.OpaqueMode) point = QPointF(100,200) rect = QRectF(450,50,400,200) painter.drawText(point,"Qt") painter.setPen(QPen(Qt.red, 10)) painter.drawPoint(point) painter.drawText(rect, Qt.AlignCenter,"Qt") painter.setPen(QPen(Qt.red, 1)) painter.drawRect(rect) 이미지 이미지는 drawPixmap() 또는 drawImage()로 그릴 수 있다. 각각 픽스맵(QPixmap)과 QImage를 그리는데 사용된다. 이들 함수는 다양한 오버로드 버전을 제공하는 데 점만을 주어지면 이미지 왜곡 없이 표시하지만 사각영역이나 스케일링 관련 인자를 추가로 지정하면 그림에 왜곡이 발생하게 된다. fillRect()와 fillPath() 사각영역이 난 패스로 구성되는 영역을 외곽선 없이 그리는 것은 fillRect() 또는 fillPath()를 통해 수행할 수 있다. 이 함수들은 drawRect()나 drawPath()에서 펜을 Qt.NoPen으로 설정하여 그린 것과 같다. 대신 브러시를 QPainter의 속성으로 사용된 브러시 대신 함수의 인자로 주어진 브러시를 사용한다(fillRect(rect, brush), fillPath(path, brush) ). 6.1.3 속성 - 안티에일라이싱 이번 절에서는 QPainter의 기본 속성인 펜, 브러시, 폰트를 포함한 여러 속성을 심화해서 설명한다. 논리적 표현과 픽셀 표현, 안티에일라이싱(antialiasing) QPainter에서는 특별하게 좌표계를 지정하지 않으면 좌측 상단이 원점 (0,0)이고, 오른쪽으로 +x, 아래쪽으로 +y인 좌표계를 사용한다. 논리적으로 정의할 수 있는 점, 선, 면 등이 화면에 표현될 때는 픽셀 단위로 표현되기 때문에 어떤 규칙에 의해 픽셀을 채우 개 된다. 예를 들어 논리적으로 (2,3) 위치의 점은 픽셀의 중심점이 (2.5,3.5)인 픽셀을 채우게 된다. 아래 그림에서 QLine(2, 7, 6, 1)은(2,7)과 (6,1)을 잇는 선분이다. 실제 픽셀 단위의 화면에 표현될 때는 두 번째 열과 같이 (2.5,7.5)와 (1.5,6.5)를 중심점으로 갖는 픽셀을 연결하는 선분이 되며 이때 지그재그 형태로 표현되게 된다. 이와 같이 높은 해상도의 신호를 낮은 해상도에서 나타낼 때, 또는 논리적인 표현을 이산적으료 표현할 때 패턴이 깨지는 현상을 에일리어싱(aliasing)이라고 한다. 안티에일리어싱(antialiasing)은 에일리어싱을 최소화하는 방법을 의미하는데, 쉽게 말해서 안티에일리어싱을 적용하면 도형의 경계선을 보다 자연스럽게 그릴 수 있다. 안티에얼리어싱을 적용하면 그린 사선의 논리적인 표현으로 구성된 선분의 좌우로 대칭이 되도록 픽셀일 채워짐을 알 수 있다. 그런 이유에서 QPainter를 생성한 후 대부분이 코드에서 다음과 같이 활성화를 해준다. painter = QPainter(self) painter.setRenderHint(QPainter::Antialising, True) ... 에얼리어싱인 경우 펜 두께가 짝수(even number)이면 논리적으로 주어진 좌표값에서 대칭으로 표현되지만, 홀수(odd number)이면 오른쪽과 아래쪽으로 1 픽셀만큼 더 그리게 된다. 하지만 안티에얼리어싱에서는 가능한 논리적인 표현에 맞는 선을 구성하고, 대칭이 되도록 픽셀을 채운다. 따라서 QRectF 와 같은 실수형을 사용할 때 더 큰 의미를 갖게 된다. 참고로 QPainter.setRenderHint() 함수는 QPainter.Antialiasing 외에도 텍스트의 안티에일리어싱을 지정하는 QPainter.TextAntialiasing, 부드러운 픽스 맵 변환 알고리즘을 쓰도록 하는 QPainter.SmoothPixmapTransform 등을 속성을 지정하는 데 사용된다. 이중 Qt 페인트 시스템은 텍스트에 대한 안티에일리어싱을 항상 수행하기 때문에 QPainter.TextAntialiasing은 사용할 필요가 없다. 만약 QPainter.Antialiasing과 QPainter.SmoothPixmapTransform을 동시에 지정할 때는 다음과 같다. painter = QPainter(device) # 드로잉에 대한 안티 에어리어 싱과 부드러운 픽스 맵 변환을 동시에 지정할 때 painter.setRenderHints(QPainter.Antialising|QPainter.SmoothPixmapTransform) ... 6.1.4 속성 - 색상 Qt에서 색상은 QColor 클래스를 통해 색상을 표현하며, QColor로 펜이나 브러시 등 색상 정보를 설정하는 데 사용한다. QColor는 RGB(red, green, blue), HSV(hue, saturation, value), CMYK(cyan, magenta, yellow, black) 색상을 지원한다. 이들 색상을 구성하는 성분에 불투명도를 지정하는 A(alpha) 성분까지 포함해서 표현되는 색상을 완전하게 정의하게 된다. 각 성분은 정수로 표현할 때는 0~255의 값을 가지고, 실수로 표현할 때는 0.~1.의 갖는다. QColor의 생성자는 기본적으로 RGB 색상에 기초하고 있습니다. 대표적인 생성자는 다음과 같다. QColor(r, g, b, a=255) # QColor ( int r, int g, int b, int a = 255 ) in C++, a=255가 불투명을 의미 QColor(name) # QColor ( const QString& name) in C++ QColor(color) # QColor ( Qt::GlobalColor color) in C++ 첫 번째 성성자는 a를 포함한 각 성분을 정숫값으로 지정한다. 두 번째 생성자는 #으로 시작하는 특수 문자열을 이용한다. red = QColor(“#ff0000”) # #rrggbb 포맷, rr 등은 16진수, QColor red(255,0,0); 와 동일 red = QColor(“#ffff0000”) # #aarrggbb 포맷, aa 등은 16진수, QColor red(255,0,0,255)와 동일 세 번째 성성자는 Qt.red, Qt.blue 등 Qt.GlobalColor 열거형으로 미리 지정되어 있는 색상을 이용하는 것이다. darkGreen = QColor(Qt.darkGreen) HSV, CMYK 색상은 fromHsv(h, s, v, a=255), fromCmyk(c, m, y, k, a=255) 등의 정적 멤버 함수(static member function) 으 이용하면 된다. QColor red = QColor::fromHsv(0,255,255); QColor red = QColor::fromCmyk(0,255,255,0); 또한 각각에 대한 실수 버전의 함수인 fromHsvF(h, s, v, a=1.), fromCmykF(h, s, l, a=1.)이 있으며, fromRgb(r, g, b, a=255), fromRgbF(r, g, b, a=1.) 등도 제공 합한. 한편, 각 색상 성분을 제공하는 다양한 함수를 제공한다. 예를 들어 RGB 색상의 r 성분을 구하기 우해서는 정수 버전의 red(), 실수 버전의 redF() 등을 사용할 수 있다. QColor의 함수 중에서는 주어지 색상을 조금 밝게 또는 어둡게 만들어 내는 ligher(),darker() 함수가 유용할 수 있다. 둘 모다 자신 색상의 변경 없이 새로운 색상을 리턴한다. red QColor(255,0,0) lightRed = red.lighter() darkRed = red.darker() 색상과 관련된 주제로는 팔레트(QPalette)가 있다. 팔레트에서 정의한 각종 색상을 가져다 사용할 수도 있다. 주의할 점은 위젯의 배경색은 QPainter의 속성이 아니므로 QWidget을 제외한 QImage, QPixmap 등의 기타 페인트 디바이스(QPaintDevice로부터 상속받은 클래스)에는 영향이 없다는 점이다. 다음은 RenderLab 예제의 RenderArea.drawGlobalColor()를 실행한 결과와 소스코드이다. RenderArea::drawGlobalColors() def drawGlobalColor(self, device): gcolors = [Qt.white, Qt.black, Qt.cyan, Qt.darkCyan, Qt.red, Qt.darkRed, Qt.magenta, Qt.darkMagenta, Qt.green, Qt.darkGreen, Qt.yellow, Qt.darkYellow, Qt.blue, Qt.darkBlue, Qt.gray, Qt.darkGray, Qt.lightGray] gcolorNames = ["Qt.white", "Qt.black", "Qt.cyan", "Qt.darkCyan", "Qt.red", "Qt.darkRed", "Qt.magenta", "Qt.darkMagenta", "Qt.green", "Qt.darkGreen", "Qt.yellow", "Qt.darkYellow", "Qt.blue", "Qt.darkBlue", "Qt.gray", "Qt.darkGray", "Qt.lightGray"] painter = QPainter(device) painter.setRenderHint(QPainter.Antialiasing, True) painter.setFont(QFont("Arial",15)) rectTitle = QRect(0,0,4*280+30,50) rect = QRect(0,0,280,50) painter.translate(10,10) # draw title painter.setPen(Qt.NoPen) painter.setBrush(Qt.lightGray) painter.drawRect(rectTitle) painter.setPen(QPen(Qt.black, 1, Qt.SolidLine)) painter.drawText(rectTitle, Qt.AlignCenter,"Qt.GlobalColor enum") painter.translate(0,60) for i in range(17): if i and i%4 == 0: painter.translate(-290*4,60) painter.setPen(QPen(Qt.NoPen)) painter.setBrush(QBrush(gcolors[i])) painter.drawRect(rect) if i%2: painter.setPen(Qt.white) else: painter.setPen(Qt.black) if gcolors[i] == Qt.blue: painter.setPen(Qt.white) painter.drawText(rect, Qt.AlignCenter, gcolorNames[i]) painter.translate(290,0) 6.1.5 속성 - 펜 펜(QPen)은 색상, 폭, 선종류, 선의 끝 모양(cap style), 조인 유형(join style) 등의 속성을 가지며, 선과 도형의 윤곽선을 그리는 데 사용된다. 텍스트를 그릴 때는(drawText()) 펜의 색상 정보만 사용된다. 대표적인 생성자는 다음과 같다. QPen(brush, width, style=Qt.SolidLine, cap=Qt.SquareCap, join=Qt.BevelJoin) QPen(color) 첫 번째 생성자가 펜의 속성을 모두 지정할 수 있는 생성자이고, 두 번 재는 색상만 지정하는 형태이다. 첫 번째 생성자에서 펜의 속성으로 브러시(QBrush), 펜 폭(width), 펜 스타일(Qt.PenStyle), 펜 캡 스타일(Qt.PenCapStyle), 펜 조인 스타일(Qt.PenJoinStyle)이 있는 있는 것을 알 수 있다. 속성으로 색상(QColor)가 아닌 브러시(QBrush)가 사용되는데, 그 이유는 펜으로 하여금 단순한 선이 아닌 어떤 패턴을 가질 수 있도록 하기 위해서이다. QBrush의 다양한 생성자 중에서 QColor나 Qt.GlobalColor 열거 변수(Qt.red 등)를 인자로 받는 생성자가 존재한다. QBrush(color, style=Qt.SolidPattern) 따라서 예제 코드에서는 첫 번째 생성자를 다음과 같이 사용할 수도 있다. painter.setPen(QPen(QColor(255,0,0),0, Qt.DotLine) painter.setPen(QPen(Qt.black, 12, Qt.DashDotLine, Qt.RoundCap)) 즉, 패턴을 갖지 않는 펜(즉, 솔리드 브러시를 갖는 펜)을 위와 같이 색상을 첫 번째 인자로 지정하여 사용할 수 있다. 생성자에서 지정하는 정보는 setBrush(), setColor(), setPenStyle(), setPenCapStyle() 등을 통해 개별적으로 그 속성을 지정할 수도 있다. 펜의 크기(width)는 생성자 또는 setWidth(width)으로 지정 가능하다. 크기가 0인 펜을 뒤에서 다룰 좌표계와 무관하게 1개 픽셀 크기의 펜을 의미한다. 이를 코즈메틱 펜(cosmetic pen)이라고 한다, 화면에 표시되지 않는 펜은 펜 스타일로 Qt.NoPen 지정해야 한다. 아래에서 펜의 스타일(Qt.PenStyle 열거형)에 대한 그림과 코드를 나타낸다. RenderArea::drawPenStyle() def drawPenStyle(self, device): styles = [Qt.NoPen, Qt.SolidLine, Qt.DashLine, Qt.DotLine, Qt.DashDotLine, Qt.DashDotDotLine] styleNames = ["Qt.NoPen", "Qt.SolidLine", "Qt.DashLine", "Qt.DotLine","Qt.DashDotLine","Qt.DashDotDotLine"] painter = QPainter(device) painter.setRenderHint(QPainter.Antialiasing, True) painter.setFont(QFont("Arial",15)) rectTitle = QRect(0,0,220*5+10*4,50) rect = QRect(0,0,220,50) painter.translate(10,10) # draw title painter.setPen(Qt.NoPen) painter.setBrush(Qt.lightGray) painter.drawRect(rectTitle) painter.setPen(QPen(Qt.black, 1, Qt.SolidLine)) painter.drawText(rectTitle, Qt.AlignCenter,"Qt::PenStyle enum and pen width") painter.translate(0,60) painter.setBrush(Qt.lightGray) for width in range(4): painter.translate(230,0) painter.setPen(Qt.NoPen) painter.setBrush(Qt.lightGray) painter.drawRect(rect) painter.setPen(Qt.black) painter.drawText(rect, Qt.AlignCenter,"Pen Width={}".format(width)) for style in range(5): painter.translate(-230*4,60) painter.setPen(Qt.NoPen) painter.setBrush(Qt.lightGray) painter.drawRect(rect) painter.setPen(Qt.black) painter.drawText(rect, Qt.AlignCenter, styleNames[style]) for width in range(4): painter.translate(230,0) painter.setPen(QPen(Qt.black, width, styles[style])) painter.drawLine(rect.left(),rect.top()+rect.height()/2, rect.right(),rect.top()+rect.height()/2) 두께가 두꺼운 펜의 경우 선의 끝단과 선과 선이 꺾이는 부분에 대한 속성을 각각 Qt.PenCapStyle과 Qt.PenJoinStyle로 지정할 필요가 있습니다. 아래 그림과 코드에서 각각의 열거 변수에 대해 나열하였다. RenderArea::drawPenCapJoinStyle() def drawPenCapJoinStyle(self, device): penCapStyles = [Qt.FlatCap, Qt.SquareCap, Qt.RoundCap] penCapStyleNames = ["Qt.FlatCap","Qt.SquareCap","Qt.RoundCap"] penJoinStyles = [Qt.MiterJoin, Qt.BevelJoin, Qt.RoundJoin] penJoinStyleNames = ["Qt.MiterJoin","Qt.BevelJoin","Qt.RoundJoin"] painter = QPainter(device) painter.setRenderHint(QPainter.Antialiasing, True) painter.setFont(QFont("Arial",15)) rectTitle = QRect(0,0,410,50) rect = QRect(0,0,200,50) points = [QPoint(0,15),QPoint(45,0),QPoint(30,45)] painter.save() painter.translate(10,10) # title painter.setPen(Qt.NoPen) painter.setBrush(Qt.lightGray) painter.drawRect(rectTitle) painter.setPen(Qt.black) painter.drawText(rectTitle, Qt.AlignCenter,"Qt::PenCapStyle enum") painter.translate(0,60) for i in range(3): print(i) painter.setPen(Qt.NoPen) painter.setBrush(Qt.lightGray) painter.drawRect(rect) painter.setPen(Qt.black) painter.drawText(rect, Qt.AlignCenter, penCapStyleNames[i]) painter.translate(210,0) painter.setPen(QPen(Qt.red, 10, Qt.SolidLine, penCapStyles[i])) painter.setBrush(Qt.NoBrush) painter.drawLine(rect.left()+20, rect.top()+rect.height()/2, rect.right()-20,rect.top()+rect.height()/2) painter.translate(-210,60) # PenJoinStyle painter.restore() painter.translate(500,10) # title painter.setPen(Qt.NoPen) painter.setBrush(Qt.lightGray) painter.drawRect(rectTitle) painter.setPen(Qt.black) painter.drawText(rectTitle, Qt.AlignCenter,"Qt::PenJoinStyle enum") painter.translate(0,60) for i in range(3): painter.setPen(Qt.NoPen) painter.setBrush(Qt.lightGray) painter.drawRect(rect) painter.setPen(Qt.black) painter.drawText(rect, Qt.AlignCenter, penJoinStyleNames[i]) painter.translate(260,0) painter.setPen(QPen(Qt.red, 10, Qt.SolidLine, Qt.SquareCap, penJoinStyles[i])) painter.setBrush(Qt.NoBrush) painter.drawPolyline(points) painter.translate(-260,60) 6.1.6 속성 - 브러시 브러시는 도형의 내부를 칠하는 데 사용되는 패턴이다. 펜의 패턴을 그리는 데에도 사용될 수 있다. 대표적인 생성자는 다음과 같다. QBrush(color, style=Qt.SolidPattern) # 일반 브러시 QBrush(pixmap) 또는 QBrush(image) # 텍스처 브러시 QBrush(gradient) # 그 레디 언트 브러시 첫 번째는 색상과 함께 미리 정의된 패턴으로 브러시를 생성한다. Qt.BrushStyle 열거 상수인 style로 Qt.SolidPattern, Qt.Dense1Pattern 등을 다양하게 지정할 수 있다. 두 번째 픽스 맵 또는 QImage 객체를 텍스처로 활용하는 브러시이다. 이 생성자를 사용하면 내부적으로 브러시 스타일이 Qt.TextureBrush가 설정된다. 세 번째 그래디 언트 패턴을 활용하는 브러시이다. 이 생성자를 사용하면 적용되는 그래디 언트에 따라 Qt.LinearGradientPattern, Qt.ConicalGradientPattern, Qt.RadialGradientPattern 등이 브러시 스타일로 지정된다. 다음은 브러시 스타인과 관련된 그림과 소스 코드이다. RendearArea::drawBrushStyle() def drawBrushStyle(self, device): brushStyles = [Qt.NoBrush, Qt.SolidPattern, Qt.Dense1Pattern, Qt.Dense2Pattern, Qt.Dense3Pattern, Qt.Dense4Pattern, Qt.Dense5Pattern, Qt.Dense6Pattern, Qt.Dense7Pattern, Qt.HorPattern, Qt.VerPattern, Qt.CrossPattern, Qt.BDiagPattern, Qt.FDiagPattern, Qt.DiagCrossPattern, Qt.LinearGradientPattern, Qt.ConicalGradientPattern, Qt.RadialGradientPattern, Qt.TexturePattern] brushStyleNames = ["Qt.NoBrush" , "Qt.SolidPattern" , "Qt.Dense1Pattern" , "Qt.Dense2Pattern", "Qt.Dense3Pattern" , "Qt.Dense4Pattern" , "Qt.Dense5Pattern" , "Qt.Dense6Pattern", "Qt.Dense7Pattern" , "Qt.HorPattern" , "Qt.VerPattern" ,"Qt.CrossPattern", "Qt.BDiagPattern" , "Qt.FDiagPattern" , "Qt.DiagCrossPattern", "Qt.LinearGradientPattern" , "Qt.ConicalGradientPattern" , "Qt.RadialGradientPattern", "Qt.TexturePattern"] painter = QPainter(device) painter.setRenderHint(QPainter.Antialiasing, True) painter.setFont(QFont("Arial",15)) rectTitle = QRect(0,0,250*4+30,50) rect = QRect(0,0,250,50) painter.translate(10,10) # draw title painter.setPen(Qt.NoPen) painter.setBrush(Qt.lightGray) painter.drawRect(rectTitle) painter.setPen(QPen(Qt.black, 1, Qt.SolidLine)) painter.drawText(rectTitle, Qt.AlignCenter,"Qt.BrushStyle enum") painter.translate(-260,60) # draw color painter.setFont(QFont("Arial",12)) for i in range(len(brushStyles)): if i and i%2 == 0: painter.translate(-260*3,60) else: painter.translate(260,0) painter.setPen(Qt.NoPen) painter.setBrush(Qt.lightGray) painter.drawRect(rect) painter.setPen(Qt.black) painter.drawText(rect, Qt.AlignCenter, brushStyleNames[i]) painter.translate(260,0) painter.setPen(Qt.NoPen) if brushStyles[i] == Qt.LinearGradientPattern: linearGradient = QLinearGradient(rect.topLeft(),rect.bottomRight()) linearGradient.setColorAt(0. ,Qt.white) linearGradient.setColorAt(0.2, Qt.green) linearGradient.setColorAt(1.0, Qt.black) painter.setBrush(linearGradient) elif brushStyles[i] == Qt.ConicalGradientPattern: conicalGradient = QConicalGradient(rect.center(),rect.width()) conicalGradient.setColorAt(0. ,Qt.white) conicalGradient.setColorAt(0.2, Qt.green) conicalGradient.setColorAt(1.0, Qt.black) painter.setBrush(conicalGradient) elif brushStyles[i] == Qt.RadialGradientPattern: radialGradient = QRadialGradient(rect.center(),rect.width()) radialGradient.setColorAt(0. ,Qt.white) radialGradient.setColorAt(0.2, Qt.green) radialGradient.setColorAt(1.0, Qt.black) painter.setBrush(radialGradient) elif brushStyles[i] == Qt.TexturePattern: painter.setBrush(self.pixmapTexture) else: painter.setBrush(QBrush(Qt.darkCyan, brushStyles[i])) painter.drawRect(rect) Qt에서는 선형, 원형, 방사 형태의 그래디 언트를 QLinearGradient, QRadialGradient, QConicalGradient 클래스를 통해 지원한다. 이들 클래스로 생성한 그래디 언트 객체는 QBrush로 전달하면 그래디 언트를 갖는 브러시를 생성할 수 있다. 다음은 QLinearGradient를 생성하여 브러시에 설정한 예이다. gradient = QLinearGradient(startPoint, endPoint) gradient.setColorAt(0.0, Qt.white) # setAt(r, color) r = 0~1 gradient.setColorAt(0.2, Qt.green) gradient.setColorAt(1.0, Qt.blue) painter.setBrush(gradient) QLinearGradient는 시작점과 끝점을 잊는 선분을 기준으로 선형적으로 그래디 언트를 생성한다. 생성자에서 시작점과 끝점을 지정하고, 선분 사이의 상대 길이 r과 색상을 인자로 하는 setColor(r, color)를 호출하여 생성할 수 있다. 이때 r은 0~1 사이의 값이다. QRadialGradient와 QConicalGradient도 자신의 생성자로 기준점 등의 속성을 지정하고, setColor(r, color)를 호출하는 것으로 생성할 수 있다. 다음은 각 그래디 언트 클래스이 생성자이다. * QLinearGradient : 시작점과 끝점 QLinearGradient(startPoint, finalPoint) QLinearGradient(x1, y1, x2, y2) * QRadialGradient : 중심과 반지점, 초점 QRadialGradient(centerPoint, radius, focalPoint) QRadialGradient(cx, cy, radius, fx, fy) (3) QConicalGradient : 중심점과 각 QConicalGradient(center, angle) QConicalGradient(cx, cy, angle) 아래는 RenderArea::drawGradient()의 실행 전경과 코드이다. 여기에서 그레이디언트를 브러시로 설정하여 원을 그렸으며, 모두 r=0, r=0.5, r=1.에 대응하는 세 가지 색상을 지정하였다. RenderArea::drawGradient() def drawGradient(self, device): painter = QPainter(device) painter.setRenderHint(QPainter.Antialiasing, True) painter.translate(100,100) painter.scale(2,2) linearGradient = QLinearGradient(QPointF(0,0),QPointF(100,100)) linearGradient.setColorAt(0, Qt.white) linearGradient.setColorAt(0.5, Qt.blue) linearGradient.setColorAt(1.0, Qt.cyan) painter.setBrush(QBrush(linearGradient)) painter.drawEllipse(QRectF(0,0,100,100)) painter.translate(150,0) radialGradient = QRadialGradient(QPointF(50,50),50, QPoint(30,30)) # center, radius, focalPoint radialGradient.setColorAt(0, Qt.white) radialGradient.setColorAt(0.5, Qt.blue) radialGradient.setColorAt(1.0, Qt.cyan) painter.setBrush(QBrush(radialGradient)) painter.drawEllipse(QRectF(0,0,100,100)) painter.translate(150,0) conicalGradient = QConicalGradient(QPointF(50,50),90) conicalGradient.setColorAt(0, Qt.white) conicalGradient.setColorAt(0.5, Qt.blue) conicalGradient.setColorAt(1.0, Qt.cyan) painter.setBrush(QBrush(conicalGradient)) painter.drawEllipse(QRectF(0,0,100,100)) 6.1.7 속성 - 백그라운드 브러시, 폰트, 클리핑, 불투명도 백그라운드 브러시 백그라운드 브러시는 점선이나 텍스트, 비트맵을 그릴 빈 공간에 채워지는 브러시를 의미한다. 위젯의 백그라운드를 칠하는데 사용되는 것을 의미하는 것은 아니다. 이를 가능하게 하려면 먼저 QPainter의 backgroundMode를 Qt.Opacity로 설정하고, setBackgorund(brush)로 브러시를 설정해야 한다. 디폴트로 backgroundMode는 Qt.Transparent이므로, 이 경우에는 설정된 백그라운드 브러시가 적용되지 않는다. 폰트 폰트는 drawText()로 텍스트를 출력할 때 사용된다. 다음은 폰트 이름(font family), 포인트 크기(point), 강조(weight), 이탤릭 여부를 지정할 수 있는 대표적인 생성자이다. QFont(familyName, pointSize=-1, weight = -1, italic = False) weight는 0 - 99 사이의 Qt.Light, Qt.Normal, Qt.Bold, Qt.DemiBold, Qt.Black 등의 미리 정의된 값이 있다. 다음은 대표적인 예제이다. serifFont = QFont("Times", 10, QFont.Bold); sansFont = QFont("Helvetica [Cronyx]", 12); 대표적인 폰트 이름으로 "Times", "Arial" 등이 있습니다. 만약 일치하는 폰트를 못 찾을 경우에는 적절한 폰트를 선택하게 된다. 폰트의 크기는 포인트로 지정할 수도 있고, 픽셀 단위로 지정할 수 있다. 생성자에서는 포인트 크기로 만 지정 가능하지만, setPixelSize()로 픽셀 단위로 지정할 수 있다. drawText() 함수로 텍스트를 그릴 때는 색상은 페인터에 설정된 펜의 색상을 이용한다. 하지만 펜의 색상 정보를 제외한 다른 정보는 사용되지 않으며 페인터의 브러시 역시 사용되지 않는다. 클리핑 영역 클리핑 영역(clipping region)은 그리기가 수행되는 영역을 의미한다. 클리핑 영역 외에 그리기를 수행한 것은 무시된다. QPainter에 setClipRegion(region)이나 setClipRect(rect) 등의 함수를 이용해 클리핑 영역을 설정하고, 그리기를 수행하면 그 영역 내에서만 그리기를 수행하도록 할 수 있습니다. def paint def paintEvent(self, event): r1 = QRegion(QRect(100, 100, 200, 80)) # r1: rectangular region r2 = QRegion(QRect(170, 110, 60, 60),QRegion::Ellipse) # r2: elliptic region r3 = r1.subtracted(r2); # r3: r2-r1 (subtraction) painter=QPainter(self) painter.setClipRegion(r3) ... # paint clipped graphics 위 코드 조각에서는 영역을 나타내는 클래스인 QRegion을 두 개 생성한 후, 한쪽 영역에서 다른 영역을 뺀 영역을 생성하고 클리핑 영역으로 설정했다. 아래 그림은 RenderLab 예제의 RenderArea::darwClipping()을 수행한 결과로서 클리핑 여부에 따라 그리기 영역을 제어할 수 있음을 알 수 있다. paintEvent() 핸들러의 인자로 전달되는 QPaintEvent 객체는 region()에 Qt의 페인트 시스템 차원에서 관리되는 클리핑 영역 정보를 담고 있다. 이 클리핑 영역과 QPainter.setClipRegion()으로 설정하는 클리핑 영역을 서로 다르다. RenderArea::drawClipping() def drawClipping(self, device): r1 = QRegion(QRect(100,100,200,80)) # r1: rectangular region r2 = QRegion(QRect(170, 110, 60, 60),QRegion.Ellipse) # r2: elliptic region r3 = r1.subtracted(r2) # r3: r2-r1 (subtraction) painter = QPainter(device) painter.setRenderHint(QPainter.Antialiasing, True) painter.setFont(QFont("Arial",15)) painter.save() painter.setPen(Qt.red) for i in range(60): painter.drawLine(0,5*i, 400,5*i) painter.setPen(Qt.black) painter.drawText(QRect(100,100,200,80),Qt.AlignCenter,"unclipped region") painter.restore() painter.translate(400,0) painter.setClipRegion(r3) painter.setPen(Qt.red) for i in range(60): painter.drawLine(0,5*i, 400,5*i) painter.setPen(Qt.black) painter.drawText(QRect(100,100,200,80),Qt.AlignCenter,"clipped region") 불투명도 QPainter의 속성으로 불투명도(opacity)를 setOpacity(opacity)로 지정할 수 있다. opacity는 0과 1사이의 값을 가질 수 있다. opacity=1은 완전히 불투명이며 디폴트 값이다. opacity=0는 완전히 투명이다. 6.1.8 속성 - 좌표변환 QPainter는 디폴트로 적용된 페인트 디바이스의 좌표계(보통 픽셀 단위)를 사용한다. 하지만 다양한 좌표변환(coordinate transformation)을 지원한다. QPainter에서 사용하는 좌표계로는 장치(device), 윈도(window), 세계(world) 좌표계가 있다. QPainter로 그린 물체는 세계 좌표계를 대상으로 한다. 이후 변환 행렬(transformation matrix)을 통해 윈도 좌표계로 변환되고, 설정된 뷰포트(viewport), 윈도(window) 사각형 값에 따라 다시 장치 좌표계로 변환됩니다. 디폴트 값으로 변환 행렬은 단위행렬이고, 윈도와 뷰포트 사각형은 위젯의 클라이언트 영역이 된다. 즉 디폴트로 좌측 상단이 원점 (0,0)이고, 오른쪽으로 +x, 아래쪽으로 +y인 픽셀 단위인 장치 좌표계에 그리기를 수행하는 것이 된다. 윈도 좌표계를 설정하는 것은 setWindow(x, y, w, h)와 setViewport(x, y, w, h)로 화면상에 윈도 및 뷰포트 사각형을 설정하는 것으로 이루어진다. 윈도 사각형은 화면에 그리기를 수행하는 논리 좌표계인 윈도 좌표계로 지정되는 사각형이고, 뷰포트 사각형이 윈도 사각형과 동일한 영역을<NAME>는 디바이스 좌표계 상의 사각영역을 의미한다. 이 두 함수를 이용해 다양한 좌표변환을 수행할 수 있지만 정수형 인자만을 받기 때문에 제한적으로 사용된다. 변환 행렬을 이용하는 방법이 보다 효율적이므로 여기에서는 다루지 않는다. 좌표변환 방법으로 추전되는 방법은 별도의 윈도 좌표계를 설정하지 않고(즉, 디폴트를 사용하고), 변환 행렬을 이용해 좌표변환을 수행하는 것이다. QPainter로 그릴 물체를 임의의 좌표계에서 그린 후 변환 행렬을 통해 장치 좌표계로 변환하는 것이다(여기에서는 윈도 좌표계와 장치 좌표계가 동일한 좌표계로 가정). 변환 행렬은 QTransform 클래스의 객체를 생성한 후 QPainter.setTransform(T)를 호출하여 설정한다. QPainter 내부에는 한 개의 변환 행렬만을 가지고 있고, 초기에는 단위행렬이다. setTransform(T)을 연속적으로 호출하면 변환이 중첩되게 된다. T1 = QTransform(...) T2 = QTransform(...) T3 = QTransform(...) painter.setTransform(T1) painter.setTransform(T2) painter.setTransform(T3; ... T = T3*T2*T1으로 구성되는 변환이 적용 ... deviceCoordinate = T*localCoordinate 형태의 변환 적용 QTransform은 * 연산자를 제공하기 때문에 다음과 같이 변환 행렬을 구성한 후 한꺼번에 설정하는 것 역시 가능하다. T1 = QTransform(...) T2 = QTransform(...) T3 = QTransform(...) T = T3*T2*T1 painter.setTransform(T) ... T = T3*T2*T1으로 구성되는 변환이 적용 ... deviceCoordinate = T*localCoordinate 형태의 변환 적용 QPainter에 설정된 변환 행렬은 resetTranform()을 호출하여 단위행렬로 초기화할 수 있다. QTransform 클래스는 3x3 행렬을 저장하고, (x, y, w) 형태의 2차원 동차 좌표계(homogeneous)에 대한 변환을 정의한다. 따라서 QTransform 클래스를 직접 조작하려면 까다롭다. 대신 흔히 사용되는 변환인 평행, 회전, 크기, 전단 변환을 translate(dx, dx), rotate(angle), scale(sx, sy), shear(sh, sv) 등의 편의 함수를 사용하는 것이 편리하다. ▪ 방법 1 : QPainter의 편의 함수 사용 painter = QPainter(self) # T = I ... indentity matrix transform.translate(50,50) # T = (translation)*T = translation transform.rotate(45.0) # T = (rotation)*T = rotation*translation transform.scale(0.5,1.0) # T = (scale)*T = scale*rotation*translation ▪ 방법 2: QTransform의 편의 함수 사용 후 setTransform() 호출 painter = QPainter(this) # T = I ... indentity matrix transform = QTransform() transform.translate(50,50) # T = (translation)*T = translation transform.rotate(45.0) # T = (rotation)*T = rotation*translation transform.scale(0.5,1.0) # T = (scale)*T = scale*rotation*translation painter.setTransform(transform) ... T = (scale)*(rotation)*(translation)으로 구성되는 변환이 적용 ... deviceCoordinate = T*localCoordinate 형태의 변환 적용 아래 그림은 네 가지 편의 함수에서 수행하는 변환을 나타낸 것이다. 그림에서 행렬 T는 내부적으로 생성되는 QTransform의 변환 행렬이다. 한편, QTransform 클래스는 map(), mapRect(), mapToPolygon() 등과 같이 직접 좌표변환을 편의 함수를 제공한다. point = transform.map(QPointF(0,0)) rect = transform.mapRect(QRectF(0,0,1,1)) # shear, rotation이 포함되어 있으면 # bounding rect로 변환 poygon = transform.mapToPolygon(QRectF(0,0,1,1)) 아래 그림과 코드는 RenderLab 예제의 RenderArea.drawTransform()을 실행한 결과와 코드이다. 그림과 같은 꽃을 그리기 위해 해 먼저 임의로 설정한 좌표계를 기준으로 꽃잎 하나를 생성해 둔다. 이후 평행이동, 크기 변환을 수행하여 중심 위치와 크기를 설정하고, 이후 회전 변환으로 8개의 꽃잎을 갖는 꽃을 완성하였다. . RenderArea.drawTransform() def drawTransform(self, device): painter = QPainter(device) painter.setRenderHint(QPainter.Antialiasing, True) floralLeaf = QPainterPath() floralLeaf.cubicTo(-30,100, +30,100,0,0); gradient = QRadialGradient(QPointF(0,50),50, QPointF(0,50)) gradient.setColorAt(0.,Qt.white) gradient.setColorAt(0.5, Qt.red) gradient.setColorAt(1.,Qt.white) painter.setBrush(gradient) painter.setPen(Qt.NoPen) painter.translate(200,200) painter.scale(2,2) for i in range(8): painter.drawPath(floralLeaf) painter.rotate(45) 6.1.9 속성 - 기타 save()와 restore() QPainter의 save()와 restore() 호출을 통해 현 상태의 속성을 저장하고 다시 되돌릴 수 있다. painter = QPainter(self) ...속성 설정 painter.save(); ... 속성 설정 및 그리기 painter.restore() ... Composition 여기에서는 소개하지 않음. 6.2 AnalogClock 예제 분석 이번 절에서는 설명을 미뤄왔던 AnalogClock의 paintEvent() 핸들러의 소스코드에 대해 설명한다. 소스코드를 다시 소개하면 다음과 같다. class AnalogClock(QWidget): ... def paintEvent(self, event): hourHand = [QPoint(7,8), QPoint(-7,8), QPoint(0, -40)] minuteHand = [QPoint(7,8), QPoint(-7,8), QPoint(0, -70)] secondHand = [QPoint(0,8),QPoint(0, -80)] hourColor = QColor(127,0,127) minuteColor = QColor(0,127,127,191) secondColor = QColor(255,0,0,191) side = min(self.width(),self.height()) time = QTime.currentTime() # static function time = time.addSecs(self.timeZoneOffset) painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing, True) painter.translate(self.width()/2, self.height()/2) painter.scale(side/200.0, side/200.0) # Draw circle radialGradient = QRadialGradient(0,0,100, -40, -40) # center, radius, focalPoint radialGradient.setColorAt(0.0, Qt.white) radialGradient.setColorAt(1.,self.backgroundColor) painter.setBrush(radialGradient) painter.setPen(QPen(Qt.darkGray, 0)) # darkGray cosmetic pen painter.drawEllipse(QRectF(-97, -97,194,194)) # Draw minute tick painter.setPen(minuteColor) for j in range(60): if (j % 5) != 0: painter.drawLine(92,0,96,0) painter.rotate(6.0) # draw hour hand painter.setPen(Qt.NoPen) painter.setBrush(hourColor) painter.save() painter.rotate(30.0*((time.hour()+time.minute()/60.0))) painter.drawConvexPolygon(hourHand) painter.restore() # draw hour tick painter.setPen(hourColor) for i in range(12): painter.drawLine(88,0,96,0) painter.rotate(30.0) # draw mimute hand painter.setPen(Qt.NoPen) painter.setBrush(minuteColor) painter.save() painter.rotate(6.8*(time.minute()+time.second()/60.0)) painter.drawConvexPolygon(minuteHand) painter.restore() # Draw second hand painter.setPen(secondColor) painter.save() painter.rotate(6.0*time.second()) painter.drawLine(secondHand[0],secondHand[1]) painter.restore() self.updated.emit(time) 임의의 좌표계로 시침, 분침, 초침을 정의하고, 사용할 컬러를 정의한다. 위젯의 최소 변의 길이를 구하고, 현재 시간을 시간대(time zone)을 고려해 구한다. 위젯의 중심으로 좌표계를 평행이동하고, 위젯의 크기에 맞추어 크기 변환을 한다. 이때 시계의 크기는 200을 가정하였습니다. 앞서 시침, 분침, 초침의 좌표 역시 이 크기를 기준으로 설정한 것이다. AnalogClock에 원형의 배경을 그래디 언트로 그린다. 원 외부에 분을 표시하는 틱(minute tick)을 그립니다. 이때 6도씩 회전 변환을 사용한다. 현재 시간에 맞추어 회전 변환을 적용하여 시침을 그린다. 그리기 전후로 save()와 restore()를 호출하여 변환을 포함한 속성을 다시 환원한다. 원 외부에 시을 표시하는 틱(hour tick)을 그립니다. 이때 30도씩 회전 변환을 사용한다. 현재 시간에 맞추어 회전 변환을 적용하여 분침과 초침을 그립니다. 그리기 전후로 save()와 restore()를 호출하여 변환을 포함한 속성을 다시 환원한다. updated(QTime) 시그널을 발생시킨다. 7. 아이템 뷰 아이템 뷰 다양한 데이터를 일목요연하게 보여주기 위해 많이 사용되는 것이 리스트, 테이블, 트리 등이다. Qt에서 이를 위해 아이템 뷰 클래스(item view class)인 QListView, QTableView, QTreeView를 제공한다. 이들 클래스는 GUI 프로그램을 만드는데 흔히 사용되는 MVC(모델-뷰-컨트롤러) 디자인패턴를 변형한 모델-뷰 아키텍처로 설계되어 있으며, QAbstractItemView를 부모 클래스로 하고 있다. 아이템 뷰 클래스의 간편화된 버전으로 QTableWidget, QListWidget, QTreeWidget 등이 있는 데 이들은 모델-뷰 구조를 사용하지 않는 편의 위젯으로 보통 아이템 뷰 편의 클래스(item view convience class)로 불린다. 이때 데이터는 모델이 아닌 개별 아이템으로 지정된다. 아이템 뷰 클래스는 아래 그림과 같은 상속관계를 이루며 최상위 클래스는 QAbstractItemView이다. 이 책에서는 모델-뷰 아키텍처의 설명을 최소화하고 아이템 뷰 편의 클래스(item view convience class) 위주로 설명한다. 모델-뷰 구조 맛보기 : FileSystem 예제 이 책에서 QListView, QTableView, QTreeView를 다루지 않지만 다음의 간단한 예를 통해 아이템 뷰 클래스의 작동 방식을 이해할 수 있다. 예제는 각 아이템 뷰에서 공통으로 사용될 수 있는 모델(여기서는 파일시스템에 대한 미리 정의되어 있는 모델이다)을 적용하는 것으로 외관만 각 아이템 뷰 클래스 특성에 따라 표시되게 된다. FileSystem.py from PySide2.QtWidgets import (QApplication, QSplitter, QFileSystemModel, QTreeView, QListView, QTableView) from PySide2.QtCore import QDir import sys if __name__ == '__main__': app = QApplication(sys.argv) splitter = QSplitter() model = QFileSystemModel(app) model.setRootPath(QDir.currentPath()) treeView = QTreeView(splitter) treeView.setModel(model) treeView.setRootIndex(model.index(QDir.currentPath())) listView = QListView(splitter) listView.setModel(model) listView.setRootIndex(model.index(QDir.currentPath())) tableView = QTableView(splitter) tableView.setModel(model) tableView.setRootIndex(model.index(QDir.currentPath())) splitter.setWindowTitle("Three views onto the same file system model") splitter.show() app.exec_() 7.1 공통 속성 QAbstractItemView에는 모든 아이템 뷰에서 공통적으로 사용되는 몇몇 속성이 있다. 에디트 트리거(edit trigger) 에디트 트리거는 아이템 뷰 위젯의 아이템을 선택한 한 후 어떤 행위로 편집모드로 들어갈 건지를 의미한다. editTriggers()와 setEditTriggers(triggers)로 값을 조회하거나 설정할 수 있다. triggers는 QAbstractItemView.EditTriger 열거 상수의 조합이며 이 열거 상수는 다음 값을 가질 수 있다. QAbstractItemView.NoEditTriggers : 편집 불가 QAbstractItemView.CurrentChanged : 현재 아이템이 바뀔 때 QAbstractItemView.DoubleClicked : 아이템 더블클릭 시 QAbstractItemView.SelectedClicked : 이미 선택되어 있는 아이템을 클리 할 때 QAbstractItemView.EditKeyPressed : 에디트 키가 눌릴 때 QAbstractItemView.AnyKeyPressed : 선택된 아이템에 대해 아무 키가 눌릴 때 디폴트 값은 다음과 같다. 리스트 뷰와 트리뷰(QListView, QListWidget, QTreeView, QTreeWidget) : DoubleClicked|EditKeyPressed 테이블 뷰(QTableView, QTableWidget) : DoubleClicked|EditKeyPressed|AnyKeyPressed 아이템 뷰가 편집 가능하려면 NoEditTriggers를 제외한 editTriggers가 설정되어 있어야 하고, 연결된 모델이나 아이템이 편집 가능해야 한다. 선택 모드 선택 모드는 마우스나 키보드 등으로 아이템을 선택하는 방식을 지정한다. selectionMode()와 setSelectionMode(mode)로 조회하거나 설정할 수 있다. mode는 QAbstractItemView.SelectionMode 열거 상수로 다음 값을 가질 수 있다. QAbstrationItemView.NoSelection : 선택 불가능하게 설정 QAbstractionItemView.SingleSelection : 하나의 아이템만을 선택 가능 QAbstractionItemView.ContiguousSection : 연속된 블록으로 선택 가능 QAbstractionItemView.ExtendedSelection : Shift 키의 조합 연속된 블록을 확장 가능하고, Ctrl 키 조합으로 다중 블록 선택 가능 디폴트 값은 다음과 같다. 리스트 뷰와 트리뷰(QListView, QListWidget, QTreeView, QTreeWidget) : SingleSelection 테이블 뷰(QTableView, QTableWidget) : ExtendedSelection 아이템 뷰에서 아이템이 선택되려면 NoSelection이 아닌 모드로 지정되어 있어야 하고, 연결된 모델이나 아이템의 속성값이 선택 가능하도록 지정되어 있어야 한다. alternatingRowColor QAbstractItemView는 뷰의 외관과 관련해 많이 사용되는 setAlternatingRowColor(bool) 함수를 가지고 있다. 이 함수로 alternatingRowColor 변수를 True로 설정하면 그림처럼 행과 행이 서로 다른 색이 번갈아 나오게 되어 보기 좋게 된다. QHeaderView 테이블 위젯(QTableView, QTableWidget)이나 트리 위젯(QTreeView, QTreeWidget)은 아래 그림과 같이 헤더 부분을 가지고 있다. 헤더 부분을 표시하는 위젯이 QHeaderView으로 이 위젯은 테이블이나 트리 위젯을 생성할 때 내부적으로 생성되어 표시된다. 경우에 따라서 이 QHeaderView를 제어해서 보다 보기 좋게 꾸밀 필요가 있다. QHeaderView는 QTableView.horizontalHeader(), QTableView.verticalHeader (), QTreeView.header() 등으로 얻을 수 있다. 테이블의 행 또는 열, 트리의 열에 해당하는 부분을 섹션(section)이라고 하는 데, 섹션의 ResizeMode를 QHeaderView의 setSectionResizeMode(mode)을 통해 수행한다. table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch) setSectionResizeMode(index, mode)를 통해 수행할 수도 있다. index는 몇 번째 섹션인지를 지정하는 인자이고, mode는 QHeaderView::ResizeMode 열거 상수로 다음 값을 갖는다. QHeaderView.Interactive - 사용자가 섹션 크기를 변경할 수 있음. defaultSectionSize가 기본 크기 QHeaderView.Fixed - 고정된 섹션 크기. defaultSectionSize가 기본 크기 QHeaderView.Stretch - 가능한 공간으로 자동으로 섹션 크기 조정 QHeaderView.ResizeToContents : 내용에 따라 자동으로 섹션 크기 조정 많이 사용되는 QHeaderView::Interactive나 QHeaderView::Stretch이다. 특히 헤더의 섹션 수가 작을 경우에는 QHeaderView.Stretch를 사용하는 것이 좋다. 아래 그림은 수평방향 QHeaderView를 대상으로 아래 코드로 QHeaderView.Stretch를 수평방향 헤더 뷰에 적용 전후의 모습이다. tableView.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch) 한편 디폴트로 항상 화면에 나타나는 헤더를 QWiget.hide()나 QWidget.setVisibility(False)를 호출하여 화면상에서 제거할 수 있다. tableView.verticalHeader().setVisibility(False); 드래그 드롭 관련 드래그 드롭과 관련된 dragDropMode, dragEnabled, defaultDropAction 등을 설정하는 함수군을 제공합니다. 7.2 QListWidget에서 제시하는 예제에서 설명한다. 7.2 QListWidget QListWidget에 리스트 형태로 표시하는 위젯이다. 표시되는 데이터는 QListWidgetItem으로 추상화한다. 아이템을 추가하는 방법은 아이템(QListWidgetItem 객체) 생성 후 addItem(item), insertItem(item)으로 추가한다. 텍스트만 저장하는 아이템인 경우 addItem(str), insertItem(i, str) 등의 편의 함수가 있다. listWidget = QListWidget(self) listWidget.setAlternateColors(True) itemA = QListWidgetItem() itemA.setText("A") listWidget.addItem(itemA) # 아이템 생성 후 addItem(listItem) 호출 listWidget.addItem("B") # 텍스트만 저장하는 아이템인 경우 addItem(str) 간편 함수 ... itemC = QListWidgetItem() newC.setText("C") listWidget.insertItem(2, itemC) # 아이템 생성 후, 2 위치에 삽입, insertItem(i, listItem) listWidget.insertItem(3, "D") # 3 위치에 삽입, insertItem(i, listItem)의 간편 버전 전체 아이템의 개수는 count()로 구할 수 있고, item(row)로 row 위치의 아이템을 얻을 수 있다. 현재 선택된 아이템은 currentItem()으로 구할 수 있고, setCurrentItem()으로 현재 아이템을 설정할 수 있다. 사용자가 키보드나 마우스로 현 선택 아이템을 변경할 경우 currentItemChanged() 시그널을 발생시킨다. 리스트 위젯에서 아이템을 제거하는 것은 아이템을 takeItem(row)를 사용한다. takeItem(row)으로 얻은 item은 다른 리스트 위젯에 추가하면 아이템 이동이 일어나고 사용하지 않으면 자동으로 삭제된다. . # 삭제하는 경우 listWidget.takeItem(row); # 이동하는 경우 item = listWidget.takeItem(row); listWidget2.addItem(item) 주의 : C++ Qt에서는 item(i), currentItem()으로 item을 얻어낸 뒤 delete 연산을 수행해도 아이템이 삭제된다. 하지만 PySide2는 이가 작동하지 않으며, takeItem(i)으로 리스트 위젯에서 아이템을 삭제해야 한다. QListWidget은 디폴트로 편집이 불가능한 읽기 전용이다. 그 이유는 에디트 트리거(editTriggers)는 설정되어 있지만 아이템의 속성에 Qt::ItemIsEditable이 포함되어 있지 않기 때문이다. 또한 SingleSlectionMode의 선택 모드로 아이템을 선택할 수 있다. 다음은 QListWidget와 QListWidgetItem의 관련된 속성을 나타낸 것이다. QListWidget의 디폴트 속성 editTriggers : QAbstractItemView::DoubleClicked|QAbstractItemView::EditKeyPressed selectionMode : QAbstractItemView::SingleSelection QListWidgetItem의 디폴트 속성( flags() ): Qt::ItemIsSelectable|Qt::ItemIsUserCheckable|Qt::ItemIsEnabled|Qt::ItemIsDragEnabled 다음 코드는 디폴트 에디트 트리거를 변경하고 아이템에 대한 편집 속성을 부과해 리스트 위젯을 편집 가능하도록 한 예이다. listWidget = QListWidget(self) listWidget.setSelectionMode(QAbstractItemView.ExtendedSelection); listWidget.setEditTriggers(QAbstractItemView.DoubleClicked | QAbstractItemView.AnyKeyPressed) item = QListWidgetItem("AAA") item.setFlags(item.flags() | Qt::ItemIsEditable) listWidget.addItem(item) ActiveSet 예제 QListWidge을 이용한 예로 아래 그림과 같이 다이얼로그에 두 개의 리스트 위젯을 배치하여 활성화된 집합을 만드는 다이얼로그를 만든다. 다이얼로그에서 화살표 모양의 툴버턴으로 좌․우 리스트 위젯의 아이템들이 이동할 수 있다. 드래그 드롭 역시 지원한다. 다음은 리소스 파일과 리소스 컴파일 과정입니다. ActiveSet.qrc <RCC> <qresource prefix="/"> <file>images/forward.png</file> <file>images/backward.png</file> </qresource> </RCC> > pyside2-rcc -o ActiveSet_rc.py -py3 ActiveSet.qrc 다음은 소스코드입니다. ActiveSet.py from PySide2.QtWidgets import (QDialog, QCheckBox, QPushButton, QToolButton, QListWidget, QListWidgetItem, QLabel, QVBoxLayout, QHBoxLayout) from PySide2.QtGui import QIcon from PySide2.QtCore import QSize, Qt import ActiveSet_rc class ActiveSetDialog(QDialog): def __init__(self, parent=None): super().__init__(parent) showSetCB = QCheckBox("Show SelectedSet") applyPB = QPushButton("&Apply") closePB = QPushButton("&Close") toActiveTB = QToolButton() toActiveTB.setIcon(QIcon(":/images/forward.png")) toActiveTB.setIconSize(QSize(32,32)) toActiveTB.setAutoRaise(True) toInactiveTB = QToolButton() toInactiveTB.setIcon(QIcon(":/images/backward.png")) toInactiveTB.setIconSize(QSize(32,32)) toInactiveTB.setAutoRaise(True) self.inactiveSetLW = QListWidget() self.inactiveSetLW.setAlternatingRowColors(True) self.inactiveSetLW.addItem("Set 1") self.inactiveSetLW.addItem("Set 2") self.inactiveSetLW.addItem("Set 3") self.inactiveSetLW.addItem("Set 4") self.activeSetLW = QListWidget() self.activeSetLW.setAlternatingRowColors(True) self.activeSetLW.addItem("Set 10") self.activeSetLW.addItem("Set 11") self.activeSetLW.addItem("Set 12") inactiveLabel = QLabel("Inactive Set") activeLabel = QLabel("Active Set") left = QVBoxLayout() left.addWidget(inactiveLabel) left.addWidget(self.inactiveSetLW) center = QVBoxLayout() center.addStretch() center.addWidget(toActiveTB) center.addWidget(toInactiveTB) center.addStretch() right = QVBoxLayout() right.addWidget(activeLabel) right.addWidget(self.activeSetLW) top = QHBoxLayout() top.addLayout(left) top.addLayout(center) top.addLayout(right) bottom = QHBoxLayout() bottom.addWidget(showSetCB) bottom.addStretch() bottom.addWidget(applyPB) bottom.addWidget(closePB) mainLayout = QVBoxLayout() mainLayout.addLayout(top) mainLayout.addLayout(bottom) self.setLayout(mainLayout) # drag-drop setting self.inactiveSetLW.setDragEnabled(True) self.inactiveSetLW.viewport().setAcceptDrops(True) self.inactiveSetLW.setDropIndicatorShown(True) self.inactiveSetLW.setDefaultDropAction(Qt.MoveAction) self.activeSetLW.setDragEnabled(True) self.activeSetLW.viewport().setAcceptDrops(True) self.activeSetLW.setDropIndicatorShown(True) self.activeSetLW.setDefaultDropAction(Qt.MoveAction) # signal-slot closePB.clicked.connect(self.close) toActiveTB.clicked.connect(self.onToActiveSet) toInactiveTB.clicked.connect(self.onToInactiveSet) def onToActiveSet(self): self.moveCurrentItem(self.inactiveSetLW, self.activeSetLW) def onToInactiveSet(self): self.moveCurrentItem(self.activeSetLW, self.inactiveSetLW) def moveCurrentItem(self, source, target): if source.currentItem() : row = source.currentRow() target.addItem(source.takeItem(row)) from PySide2.QtWidgets import QApplication import sys if __name__ == "__main__": app = QApplication(sys.argv) dialog = ActiveSetDialog() dialog.show() app.exec_() 소스코드 중에서 설명하지 않은 부분은 드래그 드롭과 관련돼 부분입니다. 아이템 뷰 클래스로 국한할 경우 QDragEnterEvent, QDragMoveEvent, QDragLeaveEvent, QDropEvent 등의 메시지 처리 없이 간편하게 드래그 드롭을 구현할 수 있다. 특히 아이템 뷰 편의 클래스로 한정할 경우 위젯 속성을 몇 개 설정해 주는 것만으로 구현할 수 있다. 아이템이 드래그 될 수 있도록 뷰의 dragEnabled를 true로 설정한다. 뷰 속으로 드롭될 수 있도록 뷰의 viewport()의 acceptDrops를 true로 설정한다. 드롭될 위치를 보여주기 위해, 뷰의 showDorpIndicator 속성를 설정해 준다. 필요한 경우 dragDropMode와 defaultDropAction 속성을 적절히 설정해 준다. 다음 코드는 복사로 드래그 드롭이 되도록 설정한 예이다. listWidget = QListWidget(self) listWidget.setSelectionMode(QAbstractItemView::SingleSelection) listWidget.setDragEnabled(True) listWidget.viewport()->setAcceptDrops(True) listWidget.setDropIndicatorShown(True) 만약 뷰내에서만 아이템을 움직일 경우 다음을 설정해 주어야 한다. listWidget.setDragDropMode(QAbstractItemView.InternalMove) 7.3 QTableWidget QTableWidget을 사용할 때는 미리 행과 열 크기를 지정하고 아이템을 삽입한다. 행과 행과 열의 크기는 생성자에서 지정할 수도 있고, setRowCount(row), setColumnCount(column)로 지정할 수도 있다. 아이템(QTableWidgetItem)은 setItem(row, column, item)으로 설정해 준다. 이때 지정되어 있는 행과 열 크기 범위를 넘어가는 위치를 지정할 경우 원치 않는 곳에 아이템이 추가되므로 주의한다. 이들 함수들에 대응하는 rowCount(), columnCount(), item(row, column) 등의 겟터(getter) 함수가 있다. # Creation tableWidget = QTableWidget(self) tableWidget.setRowCount(12) tableWidget.setColumnCount(3) # ortableWidget = QTableWidget(12,3, self) itemA = QTableWidgetItem("itemA") tableWidget.setItem(0,1, itemA) itemB = QTableWidgetItem() itemB.setText("itemB") itemB.setIcon(QIcon(":/images/xxx.png")) tableWidget.setItem(3,2, itemB) 테이블에서 m-by-n 크기로 크기를 설정했다고 해서 모든 셀에 QTableWidgetItem 객체가 생성되는 것이 아니다. 아이템 객체는 setItem()으로 직접 생성한 아이템을 지정하거나, 쓰기 가능한 QTableWidget에서 아직 아이템 객체가 없는 없는 빈 셀(cell)에 대해 에디팅 모드로 진입할 때 QTableWidget이 직접 생성해 준다. 다시 말하면 화면에 보이는 빈 셀은 아이템 객체가 아직 생성되진 않는 셀과 아이템 객체가 있지만 아직 아이템의 데이터가 없다는 것을 의미한다. 따라서 item(row, column)으로 리턴되는 아이템을 사용할 때는 다음과 같이 if 문으로 검토하는 것이 좋다(아이템이 없는 경우 None을 리턴함) item = tableWidget.item(row, column) if item: x = float(item.text()) 빈 셀에 대해 에디팅 모드로 진입해 편집할 때 QTableWidget 이 아이템 객체를 자동으로 생성하는 경우를 대비하기 위해 QTableWidgetItem을 오버라이드 하여 사용자 정의의 아이템 클래스를 사용할 때는 이 클래스의 형을 setItemPrototype()를 호출하여 미리 등록해야 하고, 아이템 클래스는 clone() 가상 함수를 오버라이드 해야 한다. 행과 열의 헤더의 레이블은 디폴트로 1, 2, ... 등과 같이 숫자로 지정됩니다. item(), setItem(), currentItem() 등의 함수에서 셀의 위치를 지정하는 데 0에서 시작하는 것과 비교할 때 1씩 큰 숫자이므로 혼돈하지 않도록 한다. 다음 그림은 헤더 레이블을 디폴트 값으로 한 경우에 대한 셀의 인덱스를 보여주고 있다. table = QTableWidget(6,3) table.setAlternatingRowColors(true) table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch) for i=0 in range(table.rowCount()): for j=0 in range(table->columnCount()): item = QTableWidgetItem() text = "({},{})".format(i).format(j) item.setText(text) item.setTextAlignment(Qt.AlignCenter) table.setItem(i, j, item) 헤더의 레이블을 바꿀 때는 setHorizontalHeaderItem(column, item), setVerticalHeaderItem(row, item)으로 설정해 한다. 이때 item은 QTableWidgetItem 객체이다. 문자열만 존재할 경우에는 setHorizontalHeaderLabels(stringList), setVerticalHeaderLabels(stringList) 등의 편의 함수를 사용할 수 있다. 다음 그림은 수직 헤더를 보이지 않도록 설정하고 수평 헤더에 대해서만 “Name", "Age", "Sex" 등과 같은 문자열을 갖도록 설정한 예이다. table = QTableWidget(6,3) table.setAlternatingRowColors(True) table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch) table.setHorizontalHeaderLabels(["Name" ,"Age" , "Sex" ]) table.verticalHeader().setVisible(False) for i in range(leftTable.rowCount()): for j in range(leftTable.columnCount()): item = QTableWidgetItem() item.setTextAlignment(Qt.AlignCenter) table.setItem(i, j, item) 테이블의 아이템을 삭제하는 것은 takeItem(i, j)를 이용한다. clear() 함수는 행과 열 크기는 그대로 둔 채 모든 헤더 아이템을 포함한 모든 아이템 객체를 삭제해 테이블을 비운다. 비슷한 함수로 clearContents()가 있는 데 이 함수는 헤더 아이템을 제외한 모든 아이템을 삭제한다. 동적으로 행이나 열을 추가하는 함수가 insertRow(row), insertColumn(column)이다. 이 함수의 호출로 행이나 열이 추가되면서 테이블의 크기가 증가하게 됩니다. 하지만 이 함수 호출로 아이템 객체가 추가되지는 않는다. 반대로 removeRow(row), removeColumn(colum)으로 삭제할 수 있다. clear(), clearContents(), insertRow(row), insertColumn(column), removeRow(row), removeColumn(column) 등은 모두 슬롯 함수이므로 시그널에 연결해 테이블의 행, 열을 추가하거나<NAME>는데 사용할 수 있다. QTableWidget은 디폴트로 편집 가능하며, 디폴트 선택 모드는 ExtendedSelection이다. 다음은 편집과 선택 모드와 관련된 QTableWidget 및 QTableWidgetItem의 디폴트 값을 정리한 것이다. * QTableWidget의 디폴트 editTriggers : QAbstractItemView.DoubleClicked|QAbstractItemView.EditKeyPressed|QAbstractItemView.AnyKeyPressed * QTableWidget의 디폴트 selectionMode : QAbstractItemView.ExtendedSelection * QTableWidgetItem의 디폴트 속성( flags() ): Qt.ItemIsEditable|Qt.ItemIsSelectable|Qt.ItemIsUserCheckable|Qt.ItemIsEnabled|Qt.ItemIsDragEnabled|Qt.ItemIsDropEnabled 만약 읽기 전용이고 하나의 아이템만을 선택 가능하도록 하려면 다음과 같다. tableWidget.setEditTriggers(QAbstractItemView.NoEditTriggers) tableWidget.setSelectionMode(QAbstractItemView.SingleSelection) 현재의 셀과 아이템은 currentCell(), currentItem() 등으로 알아낼 수 있고, 반대로 setCurrrentCell(), setCurrentItem()으로 설정할 수 있다. 비슷한 유형의 함수인 currentRow(), currentColumn()은 현재 셀의 행이나 열 번호를 리턴한다. QTableWidget에는 cellActivated(), itemEntered(), itemChanged(), itemSelectionChanged() 등의 다양한 시그널이 있다. 가장 많이 사용되는 시그널은 itemChanged(item)이다. 사용 예는 다음과 같다. tableWidget.itemChanged.connect(self.itemChanged) 셀의 선택영역을 selectedRanges()를 통해 알아낼 수 있습니다. 이 함수는 QTableWidgetSelectionRange 객체의 리스트를 리턴하는데 아이템 객체가 존재 여부에 상관없이 그 범위를 QTableWidgetSelectionRange에 담아 리턴한다. 비슷한 함수로 QTableWidgetItem의 리스트를 리턴하는 selectedItems()가 있는데 이 함수는 선택 영역 중 빈 셀을 제외한 아이템을 리스트에 담아 리턴한다. XYTable1 예제는 XY 테이블 데이터를 보여주는 다이얼로그이다. 이 테이블은 2개의 열을 가지며 주어진 xy 데이터를 보여준다. 셀을 선택하여 클립보드를 통해 복사(copy) 하여 엑셀 등에 붙여 넣을 수 있다. from PySide2.QtWidgets import (QDialog, QTableWidget, QTableWidgetItem, QHeaderView, QPushButton, QHBoxLayout, QVBoxLayout, QAbstractItemView, QShortcut) from PySide2.QtGui import QKeySequence from PySide2.QtCore import QPointF, Qt class XYTableDialog(QDialog): def __init__(self, coordinates, parent=None): super().__init__(parent) self.rowCount = len(coordinates) self.table = QTableWidget() self.table.setRowCount(len(coordinates)) self.table.setColumnCount(2) self.table.setAlternatingRowColors(True) self.table.setSelectionMode(QAbstractItemView.ContiguousSelection) self.table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch) self.table.setFocusPolicy(Qt.StrongFocus) self.table.setHorizontalHeaderLabels(["X", "Y"]) for row in range(len(coordinates)): point = coordinates[row] itemX = QTableWidgetItem(str(point.x())) itemX.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter) self.table.setItem(row, 0, itemX) itemY = QTableWidgetItem(str(point.y())) itemY.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter) self.table.setItem(row, 1, itemY) copyShortcut = QShortcut(QKeySequence.Copy, self) copyShortcut.activated.connect(self.copy) self.closeButton = QPushButton("&Close") bottomLayout = QHBoxLayout() bottomLayout.addStretch() bottomLayout.addWidget(self.closeButton) layout = QVBoxLayout() layout.addWidget(self.table) layout.addLayout(bottomLayout) self.setLayout(layout) self.closeButton.clicked.connect(self.close) def coordinate(self): coord = [] for i in range(self.table.rowCount()): itemX = self.table.item(i, 0) itemY = self.table.item(i, 1) pt = QPointF(float(itemX.text()),float(itemY.text())) coord.append(pt) return coord def copy(self): selectedRangeList = self.table.selectedRanges() if selectedRangeList == [] : return text = "" selectedRange = selectedRangeList[0] for i in range(selectedRange.rowCount()): if i > 0: text += "\n" for j in range(selectedRange.columnCount()): if j > 0: text += "\t" itemA = self.table.item(selectedRange.topRow()+i, selectedRange.leftColumn()+j) if itemA : text += itemA.text() text += '\n' QApplication.clipboard().setText(text) from PySide2.QtWidgets import QApplication import sys if __name__ == '__main__': app = QApplication(sys.argv) coordinates = [QPointF(0.0, 0.9), QPointF(0.2, 11.0), QPointF(0.4, 15.4), QPointF(0.6, 12.9), QPointF(0.8, 8.5), QPointF(1.0, 7.1), QPointF(1.2, 4.0), QPointF(1.4, 13.6), QPointF(1.6, 22.2), QPointF(1.8, 22.2)] dlg = XYTableDialog(coordinates) dlg.show() app.exec_() QShortcut 은 단축키에 반응하도록 한다. 클립보드는 \t와 으로 구분되는 데이터를 사용한다. 이를 통해 엑셀 등으로 복사할 수 있다. 엑셀에서 복사를 수행할 때도 같은 포맷으로 클립보드로 복사된다. 1 3 2 1 → 1\t3\n2\t1\n3\t\4\n 3 4 XYTable2 앞서의 XYTable1 예제를 개선하기 위해 QTableWidget을 서브클래싱한다. 다음 기능이 추가되었다. Enter나 Return 키에 반응하여 입력을 완료하고 아래 셀로 이동하는 기능 paste 기능(더 큰 영역이 복사되는 경우 행이 늘어남) from PySide2.QtWidgets import (QDialog, QTableWidget, QTableWidgetItem, QHeaderView, QPushButton, QHBoxLayout, QVBoxLayout, QAbstractItemView, QShortcut, QLineEdit) from PySide2.QtGui import QKeySequence from PySide2.QtCore import QPointF, Qt import numpy as np # incremental row + keypress event class MyTable(QTableWidget): def __init__(self, horizonatlHearderLabels, parent=None): super().__init__(parent) self.setColumnCount(len(horizonatlHearderLabels)) self.setRowCount(1) self.setAlternatingRowColors(True) self.setSelectionMode(QAbstractItemView.ContiguousSelection) self.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch) self.setFocusPolicy(Qt.StrongFocus) self.setHorizontalHeaderLabels(horizonatlHearderLabels) for i in range(self.rowCount()): for j in range(self.columnCount()): item = QTableWidgetItem("") item.setTextAlignment(Qt.AlignRight|Qt.AlignVCenter) self.setItem(i, j, item) copyShortcut = QShortcut(QKeySequence.Copy, self) pasteShortcut = QShortcut(QKeySequence.Paste, self) copyShortcut.activated.connect(self.copy) pasteShortcut.activated.connect(self.paste) def setData(self, data): self.setRowCount(0) # erase data row, col = data.shape self.setColumnCount(col) self.setRowCount(row) print(data) for i in range(self.rowCount()): for j in range(self.columnCount()): item = QTableWidgetItem(str(data[i, j])) item.setTextAlignment(Qt.AlignRight|Qt.AlignVCenter) self.setItem(i, j, item) def data(self): r = np.zeros(self.rowCount(),self.columnCount()) for i in range(self.rowCount()): for j in range(self.columnCount()): r[i, j]=float(self.items(i, j).text()) return r def keyPressEvent(self, event): super().keyPressEvent(event) if event.key() == Qt.Key_Return or event.key() == Qt.Key_Enter : i = self.currentRow() + 1 j = self.currentColumn() if i == self.rowCount(): self.setRowCount(i+1) for kk in range(self.columnCount()): item = QTableWidgetItem() item.setTextAlignment(Qt.AlignRight|Qt.AlignVCenter) self.setItem(i, kk, item) self.setCurrentCell(i, j) event.accept() def copy(self): selectedRangeList = self.selectedRanges() if selectedRangeList == [] : return text = "" selectedRange = selectedRangeList[0] for i in range(selectedRange.rowCount()): if i > 0: text += "\n" for j in range(selectedRange.columnCount()): if j > 0: text += "\t" itemA = self.item(selectedRange.topRow()+i, selectedRange.leftColumn()+j) if itemA : text += itemA.text() text += '\n' QApplication.clipboard().setText(text) def paste(self): # 1\t2\n2\t3\n text = QApplication.clipboard().text() rows = text.split('\n') numRows = len(rows)-1 numColumns = rows[0].count('\t')+1 if self.currentRow()+numRows > self.rowCount(): prevRowCount = self.rowCount() self.setRowCount(self.currentRow()+numRows) for i in range(prevRowCount, self.currentRow()+numRows): for kk in range(self.columnCount()): item = QTableWidgetItem() item.setTextAlignment(Qt.AlignRight|Qt.AlignVCenter) self.setItem(i, kk, item) for i in range(numRows): columns = rows[i].split('\t') for j in range(numColumns): row = self.currentRow()+i column = self.currentColumn()+j if column < self.columnCount(): self.item(row, column).setText(columns[j]) class XYTableDialog(QDialog): def __init__(self, horizonatlHearderLabels, data, parent=None): super().__init__(parent) self.table = MyTable(horizonatlHearderLabels, parent) self.table.setData(data) self.closeButton = QPushButton("&Close") bottomLayout = QHBoxLayout() bottomLayout.addStretch() bottomLayout.addWidget(self.closeButton) layout = QVBoxLayout() layout.addWidget(self.table) layout.addLayout(bottomLayout) self.setLayout(layout) self.closeButton.clicked.connect(self.close) from PySide2.QtWidgets import QApplication import sys if __name__ == '__main__': app = QApplication(sys.argv) data = np.array([ [0.0,0.9 ], [0.2,11.0], [0.4,15.4], [0.6,12.9], [0.8,8.5 ], [1.0,7.1], [1.2,4.0 ], [1.4,13.6], [1.6,22.2], [1.8,22.2]]) dlg = XYTableDialog(["X","Y"],data) dlg.show() # table = MyTable(["X","Y","Z"]) # table.setData(data) # table.show() app.exec_() 7.4 QTreeWidget 트리 위젯(QTreeWidget)은 첫 번째 열(column)에 트리 형태의 아이템이 배치되고, 옵션인 두 번째 칼럼부터는 리스트 형태로 어떤 값을 표현할 수 있는 위젯이다. 디폴트 열 개수는 1개이다. 즉, 트리만 표현된니다. setColumnCount(column)로 행 개수를 지정할 수 있다. 트리 위젯의 아이템(QTreeWidgetItem)은 아이템 객체끼리 부모-자식 관계를 이루도록 구성되며 최상위 아이템은 QTreeWidget을 부모로 갖도록 설정한다. 다음 코드는 열 개수를 한 개로 트리만 표현하도록 한 예이다. 이 경우에는 헤더가 보이 않도록 설정해야 한다. treeWidget = QTreeWidget(mainWindow) treeWidget.setAlternatingRowColors(True) treeWidget.header().setVisible(False) itemTop1 = QTreeWidgetItem(treeWidget) itemTop1.setText(0, "QAbstractItemView") itemChild1 = QTreeWidgetItem(itemTop1) itemChild1.setText(0, "QListView") itemChild2 = QTreeWidgetItem(itemTop1) itemChild2.setText(0, "QTreeView") itemTop2 = QTreeWidgetItem(treeWidget) itemTop2.setText(0, "QAbstractItemModel") itemChild3 = QTreeWidgetItem(itemTop2) itemChild3.setText(0, "QListModel") itemChild4 = QTreeWidgetItem(itemChild3) itemChild4.setText(0, "QStringListModel") QTreeWidget의 헤더는 디폴트로 화면에 나타나기 때문에 treeWidget().header().setVisible(false)를 호출해 주었다. 위 코드에서 최상위 아이템은 생성할 때 트리 위젯의 포인터를 인자로 주어 생성했다. 이후 자식 아이템은 다른 아이템을 부모로 하여 생성한 것이다. 최상위 아이템을 지정하는 또 다른 방법은 invisibleItem()의 자식이나 addTopLevelItem()이나 insertTopLevelItem()을 사용하는 방법이 있다. invisibleItem()은 QTreeWidget 내에 존재하는 루트 아이템을 리턴하는데 엄밀하게 최상위 아이템은 이 루트 아이템의 자식이다. 다음은 최상위 아이템으로 만드는 방법을 정리한 것이다. # treeWidget을 부모로 생성 item = QTreeWidgetItem(treeWidget) # treeWidget 내의 invisibleItem()을 부모로 생성 item = QTreeWidgetItem(treeWidget.invisibleItem()) # 부모 없이 생성 후 addTopLevelItem() 호출 item = new QTreeWidgetItem() item.insertTopLevelItem(item) # 마지막 최상위 아이템으로 삽입 # 부모 없이 생성 후 insertTopLevelItem() 호출 item = QTreeWidgetItem() item.insertTopLevelItem(3, item) # 4번째 최상위 아이템으로 삽입 만약 열 수가 2 이상인 경우일 경우에는 보통 헤더도 존재하도록 설계하는 것이 일반적이다. 헤더에 나타나는 라벨로는 QTableWidget처럼 1,2, ... 이 디폴트로 표시된다. 이를 변경하려면 setHeaderItem()으로 설정한다. treeWidget = QTreeWidget(mainWindow) treeWidget.setColumnCount(2) treeWidget.setHeaderLabels([ "Class", "Descriptions"] ) treeWidget.setAlternatingRowColors(True); treeWidget.header().setSectionResizeMode(QHeaderView.Stretch) itemTop1 = QTreeWidgetItem(treeWidget,["QAbstractItemView", "base clase of item view"]) itemChild1 = QTreeWidgetItem(itemTop1, ["QListView","list view"]) itemChild2 = QTreeWidgetItem(itemTop1) itemChild2.setText(0, "QTreeView") itemChild2.setText(1, "tree view") itemTop2 = QTreeWidgetItem(treeWidget) itemTop2.setText(0, "QAbstractItemModel") itemTop2.setText(1, "base class of item model") itemChild3 = QTreeWidgetItem(itemTop2) itemChild3.setText(0, "QListModel") itemChild3.setText(1, "list model") itemChild4 = QTreeWidgetItem(itemChild3) itemChild4.setText(0, "QStringListModel") itemChild4.setText(1, "string list model") 위 코드에서는 두 가지 방법으로 QTreeWidgetItem을 문자열 데이터를 설정했다. 트리 위젯의 아이템은 clear()로 지울 수 있고, collapseItem(item), expandItem(item)으로 자식 아이템이 안 보이게 접거나, 보이게 확장할 수 있다. 이들 함수들은 슬롯 함수이기도 합니다. 주로 사용되는 시그널 함수는 currentItemChanged(currentItem, previsousItem), itemActivated(item, colum) 등이 있다. 트리 위젯은 디폴트로 편집이 불가능합니다. 그 이유도 트리 위젯이 편집 트리거는 가지지만 QTreeWidgetItem이 Qt::ItemIsEditable 속성을 갖지 않기 때문이다. 리스트 위젯에서 제시한 방법과 동일한 방법으로 편집 가능하게 할 수 있다. QTreeWidget의 디폴트 editTriggers : QAbstractItemView.DoubleClicked|QAbstractItemView.EditKeyPressed QTreeWidget의 디폴트 selectionMode : QAbstractItemView.SingleSelection QTreeWidgetItem의 디폴트 속성( flags() ) Qt.ItemIsSelectable|Qt.ItemIsUserCheckable|Qt.ItemIsEnabled|Qt.ItemIsDragEnabled|Qt.ItemIsDropEnabled 8. 기타 ... 8.1 독립 실행파일 파이썬에서 독립 실행파일을 만드는 툴로는 PyInstaller, py2exe, cx_Freeze 등이 있다. 여기에서 PyInstaller를 이용한 방법을 설명한다. 설치 > pip install pyinstaller 사용법 > pyinstaller program.py # 기본 방법 > pyinstaller -w program.py # 콘솔 창 없애기 > pyinstaller -w -F program.py # 콘솔 창 없애기 + 1개 파일 PySide2가 LGPL 임을 감안할 때 1개 파일로 만드는 방법은 라이선스 규약상 사용할 수 없음에 유의한다. --> 이제 PySide2 프로그램이 작동하지 않음 next try 콘다로 인스톨(관리자 권한) conda install -c conda-forge pyinstaller 8.2 Matplotlib 연계 PySide2에서 Matplotlib을 연계하여 사용할 수 있다. 사용법 개관은 다음과 같다. Matplotlib은 저 수준의 라이브러리(Qt4, Qt5, Cairo, tk 등등)을 대상(backends)으로 선택적으로 구동된다. PySide2나 PyQt5 등 Qt5를 사용하는 경우 다음과 같이 임포트 하여 사용한다. from matplotlib.backends.backend_qt5agg import FigureCanvas Qt5 backend로 선택 시 FigureCanvas 클래스는 FigureCanvasQT를 재정의한 것이며, QWidget과 FigureCanvasBase로부터 다중 상속을 받으며, 생성자의 유일한 인자는 Matplotlib이 Figure 객체이다. class FigureCanvasQT(QtWidgets.QWidget, FigureCanvasBase): def __init__(self, figure): ... FigureCanvas가 QWidget에서 상속받기 때문에 하나의 위젯처럼 사용 가능하다. 다만 Matplotlib API는 명령어 방식이 아닌 객체지향 방식의 API를 사용한다. HelloMatplotlib HelloMatplotlib 예제는 FigureCanvas를 QWidget으로 사용하여 그림을 그리는 간단한 예제이다. HelloMatplotlib.py import sys from PySide2.QtWidgets import QApplication from matplotlib.backends.backend_qt5agg import FigureCanvas from matplotlib.figure import Figure if __name__ == "__main__": import numpy as np app = QApplication(sys.argv) x = np.linspace(0,1,50) y1 = np.cos(4*np.pi*x) y2 = np.cos(4*np.pi*x)*np.exp(-2*x) canvasWidget = FigureCanvas(Figure(figsize=(6,4))) ax = canvasWidget.figure.add_subplot(2,1,1) ax.plot(x, y1,'r-*',lw=1) ax.grid(True) ax.set_ylabel(r'$sin(4 \pi x)$') ax.axis([0,1, -1.5,1.5]) ax = canvasWidget.figure.add_subplot(2,1,2) ax.plot(x, y2,'b--o',lw=1) ax.grid(True) ax.set_xlabel('x') ax.set_ylabel(r'$ e^{-2x} sin(4\pi x) $') ax.axis([0,1, -1.5,1.5]) canvasWidget.figure.tight_layout() canvasWidget.show() app.exec_() FigureCanvas 객체 canvasWidget을 생성한 후 캔버스의 멤버로 Figure 클래스 객체인 figure를 대상으로 객체지향 API로 작성되어 있다. Plot from file 두 번째 예제는 FigureCanvas를 자식 위젯으로 사용한 예이다. if __name__ == "__main__": from PySide2.QtCore import QCoreApplication QCoreApplication.setLibraryPaths(['C:\ProgramData\Anaconda3\Lib\site-packages\PySide2\plugins']) import sys from PySide2.QtWidgets import QWidget, QApplication, QVBoxLayout from matplotlib.backends.backend_qt5agg import FigureCanvas from matplotlib.figure import Figure from matplotlib import rcParams class MatplotlibWidget(QWidget): def __init__(self): QWidget.__init__(self) self.canvas = FigureCanvas(Figure()) vertLayout = QVBoxLayout() vertLayout.addWidget(self.canvas) self.setLayout(vertLayout) self.axes = self.canvas.figure.add_subplot(111) if __name__ == "__main__": import numpy as np app = QApplication(sys.argv) window = MatplotlibWidget() window.show() x = np.linspace(0,10.,50) window.axes.plot(x, np.sin(x)) window.axes.plot(x, np.sin(x),'*') app.exec_() if __name__ == "__main__": from PySide2.QtCore import QCoreApplication QCoreApplication.setLibraryPaths(['C:\ProgramData\Anaconda3\Lib\site-packages\PySide2\plugins']) import time import numpy as np import sys from PySide2.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout) from PySide2.QtCore import Qt from matplotlib.backends.backend_qt5agg import FigureCanvas from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolbar from matplotlib.figure import Figure class ApplicationWindow(QMainWindow): def __init__(self): super().__init__() self._main = QWidget() self.setCentralWidget(self._main) layout = QVBoxLayout(self._main) static_canvas = FigureCanvas(Figure(figsize=(5, 3))) layout.addWidget(static_canvas) self.addToolBar(NavigationToolbar(static_canvas, self)) dynamic_canvas = FigureCanvas(Figure(figsize=(5, 3))) layout.addWidget(dynamic_canvas) self.addToolBar(Qt.BottomToolBarArea, NavigationToolbar(dynamic_canvas, self)) self._static_ax = static_canvas.figure.subplots() t = np.linspace(0, 10, 501) self._static_ax.plot(t, np.tan(t), ".") self._dynamic_ax = dynamic_canvas.figure.subplots() self._timer = dynamic_canvas.new_timer(100, [(self._update_canvas, (), {})]) self._timer.start() def _update_canvas(self): self._dynamic_ax.clear() t = np.linspace(0, 10, 101) # Shift the sinusoid as a function of time. self._dynamic_ax.plot(t, np.sin(t + time.time())) self._dynamic_ax.figure.canvas.draw() if __name__ == "__main__": app = QApplication(sys.argv) window = ApplicationWindow() window.show() app.exec_() input('...') 8.3 VTK 연계 VTK는 3차원 시각화 라이브러리이다. C++ 라이브러리이며 Python 바인딩이 제공된다. 인스톨은 다음과 같다. > pip install vtk PySide2를 사용하기 위해서는 VTK 8.2 이상이 필요하나 2-19.5.12 기준으로 pip 인스톨 된 VTK 8.1.2이다. 따라서 PySide2가 정상적으로 작동하지 않는다(PyQt5만 정상 지원) SimpleVTK.py 8. 단어 학습기 Google TTS를 이용한 단어 학습기 player = new QMediaPlayer; // ... player->setMedia(QUrl::fromLocalFile("/Users/me/Music/coolsong.mp3")); player->setVolume(50); player->play(); 주의할 점은 메시지 루프가 가동되고 있어야 한다. 따라서 if __name__ == '__main__': from PySide2.QtCore import QCoreApplication QCoreApplication.setLibraryPaths(['C:\ProgramData\Anaconda3\Lib\site-packages\PySide2\plugins']) from PySide2.QtMultimedia import QMediaPlayer from PySide2.QtCore import QUrl from PySide2.QtWidgets import QWidget, QPushButton, QApplication import sys if __name__ == '__main__': app = QApplication(sys.argv) player = QMediaPlayer() player.setMedia(QUrl.fromLocalFile(r'D:\Home\Music\ABBA.mp3')) player.setVolume(50) player.play() app.exec_() Qt의 TTS 사용 준비 사항 : 설정/지역 및 언어에 "한국어", "English"가 표시되어 있는 지 확인하고, 각 언어를 선택해 옵션으로 들어가 TTS가 되도록 설정한다.<|endoftext|>

전문분야 텍스트 ### 제목: 딥 러닝을 이용한 자연어 처리 입문 ### 본문: 많은 분들의 피드백으로 수년간 보완된 입문자를 위한 딥 러닝 자연어 처리 교재 E-book입니다. 오프라인 출판물 기준으로 코드 포함 약 1,000 페이지 이상의 분량을 가지고 있습니다. 기본적인 텍스트 전처리부터 BERT와 같은 PLM의 다양한 다운스트림 태스크를 다룹니다. 대부분의 내용을 무료로 공개하여 이 웹 사이트를 통해 자연어 처리를 입문할 수 있습니다. 단, BERT 실습과 같은 심화 내용은 유료 E-book ( 구매 시 이 책의 PDF 파일 제공 ) 에서만 확인할 수 있습니다. 이 책은 자연어 처리와 딥 러닝 입문자를 대상으로 하지만, 파이썬은 이미 어느 정도 안다고 가정합니다. 이 책은 텐서 플로의 케라스 API를 주로 사용합니다. (무슨 내용인지 몰라도 이 책으로 시작 가능!) 2022-01-01일 자로 깃허브 저장소를 생성하였습니다. 각 py 파일에 Colab 링크가 기재돼 있으니 해당 링크를 통해 Colab 실습도 가능합니다. github : https://github.com/ukairia777/tensorflow-nlp-tutorial 댓글 또는 피드백(질문/지적) 또는 이메일 환영합니다. 각 내용에 대한 페이지마다 댓글 버튼 옆을 보면 피드백 버튼이 있습니다. 위키독스 회원가입이 번거로우시다면 피드백 버튼으로 의견 주셔도 댓글로 답변드립니다. 감사합니다. 동일 저자가 만든 PyTorch 학습 자료 : https://wikidocs.net/book/2788 공부를 위해 모든 모델 아키텍처를 직접 파워포인트로 그렸으며 아래 링크에서 공유합니다. 이 책의 이미지 자료 공유 (영리적 목적 제외 사용 가능) : https://www.slideshare.net/wonjoonyoo/ss-188835227 00. 글쓴이 소개 및 e-mail 저희는 취미로 글을 쓰고 있는 현업 딥 러닝 엔지니어입니다. 그 과정에서 다른 분들과 저 모두에게 도움이 되면 더 좋겠습니다. 영어에 비해 한국어 자료가 많이 부족한 이 분야에서 많은 의견 공유를 통해 함께 성장하기를 바랍니다. 실수로 질문을 놓치기도 하지만 적절치 못한 질문은 답변드리지 않을 수 있습니다. 컨설팅은 진행하고 있으나 아직 학생이신 분들의 과제 대행은 해드리지 않고 있으니 문의하지 말아주세요. 저자 공동 E-mail : <EMAIL> - <NAME> (전 삼성 AI 연구원 / 현 AI 겸임 교수) - 연세대, 인천대, 서울예대, 경희대, 중앙대 등 다수 NLP 강의 진행 경력 있으며 과외, 강의 문의는 이메일로 부탁드립니다. - 현재 오픈한 정규 강의: https://learningspoons.com/course/detail/nlp-pipeline/ - <NAME> (현 대기업 딥 러닝 연구원) - 다양한 도메인에서 BERT, Instruct GPT, 한국어 LLM을 튜닝하며 자연어 처리 모델을 개발하고 있습니다. 감사합니다. 이 책의 실습 코드들이 있는 저자의 깃허브 저장소입니다. py 파일에 Colab 링크가 기재돼 있으니 참고하세요. github : https://github.com/ukairia777/tensorflow-nlp-tutorial 실제 판매되고 있는 책입니다. full Copy 하여 블로그 포스팅 또는 출판물에 사용하시면 안 됩니다. 저작물이므로 구매하신 E-book 파일을 타인에게 함부로 배포해서는 안 됩니다. 본 자료에 대한 허가되지 않은 배포를 금지합니다. 기타 교재 관련 문의는 현재 페이지의 댓글 또는 이메일로 연락 주세요. 00. 비공개 콘텐츠 & E-book 구매 안내 이 책의 대부분의 내용은 이미 웹 사이트에 공개가 된 상태입니다. 하지만 일부 심화 내용은 유료 교재인 E-book(구매 시 PDF 제공)에만 공개가 됩니다. 특히 18챕터인 BERT의 실습 부분(분류, NLI, 개체명 인식, 기계 독해/질의응답) 은 유료 E-book에서만 확인 가능합니다. 유료 E-book을 구매하실 경우 웹 사이트에서는 비공개 처리되었던 내용이 모두 공개된 '딥 러닝을 이용한 자연어 처리 입문'의 최종 완성 PDF 파일을 다운로드하실 수 있습니다. 총합 약 1,000 페이지로 약 300 페이지씩 세 권으로 분권한 세 개의 파일이 제공됩니다. 목차 이동 기능도 제공되고 있으므로 페이지가 많은 것은 걱정하지 않으셔도 됩니다. 1권 : 1챕터 ~ 7챕터 2권 : 8챕터 ~ 12챕터 3권 : 13챕터 ~ 21챕터 (Part 2. 심화 과정 전체) 교재를 구매 후 책 내용에서 이해가 안 되는 부분이나 코드가 실행이 안 되는 부분은 저자 이메일로 연락 주시면 답변드리겠습니다. 온라인 교재의 장점을 살려 코드 최신화를 항시 목표로 하고 있습니다. 선생님, 교수님들이 수업 교재로 구매하여 사용하시는 경우에는 별도 강의 노트(PPT 파일)를 제공해 드리고 있습니다. 이 경우 저자 이메일로 따로 연락 주세요. 000. Part 1. 기본 과정 난이도를 고려하여 책을 두 파트로 나눴습니다. 1챕터부터 12챕터를 기본 과정이라 합니다. 13챕터부터 끝까지를 심화 과정으로 합니다. 01. 자연어 처리(natural language processing) 준비하기 자연어(natural language)란 우리가 일상생활에서 사용하는 언어를 말합니다. 자연어 처리(natural language processing)란 이러한 자연어의 의미를 분석하여 컴퓨터가 처리할 수 있도록 하는 일을 말합니다. 자연어 처리는 음성 인식, 내용 요약, 번역, 사용자의 감성 분석, 텍스트 분류 작업(스팸 메일 분류, 뉴스 기사 카테고리 분류), 질의응답 시스템, 챗봇과 같은 곳에서 사용되는 분야입니다. 최근 딥 러닝의 뛰어난 성능이 괄목할 만한 성과를 얻으면서, 인공지능이 IT 분야의 중요 키워드로 떠오르고 있습니다. 자연어 처리는 기계에게 인간의 언어를 이해시킨다는 점에서 인공지능에서 가장 의미 있는 연구 분야이면서도 아직도 정복되어야 할 산이 많은 분야입니다. 이 책에서는 자연어 처리에 필요한 전처리 방법, 딥 러닝 이전 주류로 사용되었던 통계 기반의 언어 모델, 그리고 자연어 처리의 비약적인 성능을 이루어낸 딥 러닝을 이용한 자연어 처리에 대한 전반적인 지식을 다룹니다. 이번 챕터는 자연어 처리 공부를 시작하기에 앞서 기본적인 세팅 방법과 앞으로 공부하게 될 머신 러닝에 대한 전체적인 워크플로에 대해서 다룹니다. 01-01 아나콘다(Anaconda)와 코랩(Colab) 머신 러닝 실습을 하기 위해서는 많은 패키지가 필요합니다. 이를 일일이 설치하는 것보다는 필요한 패키지들을 모아놓은 파이썬 배포판 '아나콘다'를 설치하는 것을 권장합니다. 아나콘다는 Numpy, Pandas, Jupyter Notebook, IPython, scikit-learn, matplotlib, seaborn, nltk 등 이 책에서 사용할 대부분의 패키지를 전부 포함하고 있습니다. 여기서는 윈도 환경을 기준으로 두고 아나콘다를 설치하는 방법과 인터넷을 통해 편하게 사용할 수 있는 파이썬 실습 환경인 구글의 코랩(Colab)을 소개합니다. 1. 아나콘다(Anaconda) 설치 링크 : https://www.anaconda.com/distribution/ 위 사이트 링크로 이동하여 사이트 하단으로 이동하면 (저자가 이 책을 작성할 당시 기준) 좌측에 파이썬 3.7 버전과 우측에 파이썬 2.7 버전의 아나콘다 설치 파일이 있습니다. 여기서는 파이썬 3.7 버전 64 비트를 설치합니다. 설치 파일을 실행한 후에 다른 윈도 프로그램을 설치하는 것과 마찬가지로 Next >를 누르면서 설치를 완료하면 됩니다. 아나콘다를 설치하면 머신 러닝을 위한 기본적인 파이썬 패키지들은 자동으로 설치가 됩니다. 다만 텐서 플로, 케라스, 젠심, 코엔엘파이와 같은 패키지들은 별도 설치가 필요한데 이에 대해서는 뒤에서 추가적으로 설명하겠습니다. 아나콘다를 다 설치했다면 아나콘다 프롬프트를 오픈하겠습니다. 아나콘다 프롬프트를 열었다면 아나콘다 프롬프트에 아래의 커맨드를 입력하여 아나콘다 파이썬 패키지를 전부 최신 버전으로 업데이트합니다. > conda update -n base conda > conda update --all 이 책이 작성되었을 당시에는 파이썬 3.7 버전이 최신 버전이었지만, 독자분들이 파이썬을 설치하기 위해서 아나콘다 페이지에 접속하였을 때는 3.7보다 더욱 최신 버전으로 업데이트가 되었을 수 있습니다. 이 경우 무작정 파이썬 최신 버전을 설치하는 것은 좋은 방법이 아닙니다. 일반적으로 아래의 링크에서 파이썬 버전과 호환되는 텐서 플로 버전에 대한 안내가 나와있으니 반드시 설치 전 확인이 필요합니다. 링크 : https://www.tensorflow.org/install/pip? hl=ko 예를 들어 위 페이지에서 'Python 3.9 지원에는 Tensorflow 2.5 이상이 필요합니다.'라고 기재돼 있다면, 파이썬 3.9를 설치하였을 때는 반드시 Tensorflow는 2.5 이상을 설치해야만 합니다. 2. 구글의 코랩(Colab) 텐서 플로는 기본적으로 64비트 플랫폼만을 지원하므로 32비트 환경에서는 딥 러닝 실습 환경을 구축하기에는 많은 애로 사항이 있습니다. 또는 개인의 컴퓨터 사양이나 다른 이유로 아나콘다나 여러 패키지 설치가 어려운 경우도 있을 것입니다. 이런 경우에는 인터넷만 된다면 바로 파이썬을 실습할 수 있는 구글의 코랩(Colab)이 있습니다. 구글의 Colab은 뒤에서 설명하게 될 '주피터 노트북'과 매우 유사한 실습 환경을 제공합니다. Colab 주소 : https://colab.research.google.com/ 구글의 Colab에 접속하는 방법은 위의 URL을 통해서 접속하거나, 구글(http://www.google.co.kr/)에서 Colab이라고 검색해서 접속할 수 있습니다. 1) 파이썬 실습하기 Colab 사용 시에는 구글 계정이 필요하므로 구글 아이디가 없으신 분들은 먼저 회원가입 후 로그인부터 해주세요. 로그인 후 좌측 상단에서 파일 > 새 노트를 클릭합니다. 조금만 기다리면 파이썬을 실습할 수 있는 실습 환경 창이 뜨게 됩니다. 이때 위 그림과 같이 Colab에서 코드를 작성하는 부분의 단위를 '셀'이라고 합니다. 그림에서 보이는 좌측 상단의 '+ 코드' 버튼을 클릭하여 새로운 셀을 추가할 수 있으며, 셀에서 코드를 작성하고 Shift + Enter 키를 눌러서 코드를 실행할 수 있습니다. 셀에 3 + 5라는 코드를 작성하고, Shift + Enter를 누르면 8이라는 결과가 나오게 됩니다. 좌측에 [1]은 해당 코드가 몇 번째로 실행되었는지를 의미합니다. 셀을 추가해 보면서 다른 파이썬 코드도 추가적으로 작성해 보세요. 2) 무료로 GPU 사용하기 딥 러닝에서는 CPU보다는 GPU를 사용합니다. Colab에서 실습할 때의 장점은 GPU를 무료로 사용할 수 있다는 점입니다. GPU가 장착된 컴퓨터가 없는 딥 러닝 입문자들은 향후 이 책의 실습을 진행할 때 Colab에서 GPU를 사용하면서 딥 러닝을 공부하는 것을 강하게 권장 드립니다. GPU를 사용하지 않고 실습을 진행하면 딥 러닝 모델을 학습하는 시간이 지나치게 소요될 수 있습니다. Colab에서 GPU를 사용하는 방법은 새 노트에 진입했을 때 상단에서 런타임 > 런타임 유형 변경을 클릭합니다. 노트 설정의 하드웨어 가속기 > GPU를 선택 후 저장을 누릅니다. 이후 실습을 진행합니다. 3) 파일 업로드 구글의 Colab에서 데이터를 업로드하여 해당 데이터로 실습을 하고자 한다면, 좌측 상단에서 폴더 모양의 버튼을 클릭합니다. 그 후 위 방향의 화살표(↑)가 그려진 버튼을 클릭하여 파일을 업로드할 수 있습니다. 위 그림에서 숫자 1번 버튼과 숫자 2번 버튼이 각각 이에 해당합니다. 예를 들어 test.txt 파일을 업로드한다고 해봅시다. 업로드 후에는 파일 목록에 test.txt 파일이 보입니다. 01-02 필요 프레임워크와 라이브러리 아나콘다를 설치했다면 기본적으로 Numpy, Pandas, Jupyter notebook, scikit-learn, matplotlib, seaborn, nltk 등이 이미 설치돼 있습니다. 그래서 아나콘다에 포함되어 있지 않은 tensorflow, keras, gensim과 같은 패키지만 별도로 pip를 통해 설치합니다. 하지만 컴퓨터에 아나콘다를 설치하지 않고 단순히 파이썬만 설치된 상태라면 위에서 언급한 모든 패키지를 pip로 설치해야 합니다. 여기서는 윈도 환경을 기준으로 설명합니다. 1. 텐서 플로(Tensorflow) 텐서 플로는 구글이 2015년에 공개한 머신 러닝 오픈소스 라이브러리입니다. 머신 러닝과 딥 러닝을 직관적이고 손쉽게 할 수 있도록 설계되었습니다. 뒤의 딥 러닝 실습을 위해서 텐서 플로를 설치해야 합니다. 아나콘다 프롬프트(Anaconda Prompt) 또는 명령 프롬프트를 통해서 설치할 수 있습니다. 아나콘다 프롬프트를 열었다면 아나콘다 프롬프트에 아래의 커맨드를 입력하여 텐서 플로를 설치합니다. > pip install tensorflow 이제 ipython 쉘을 실행하여 텐서 플로가 정상 설치되었는지 확인하는 의미에서 텐서 플로를 임포트하고 버전을 확인합니다. > ipython ... In [1]: import tensorflow as tf In [2]: tf.__version__ Out[2]: '2.0.0' 텐서 플로 2.0이 설치되었습니다. 이해를 돕기 위해 제 컴퓨터 화면의 스크린숏을 아래에 첨부하였습니다. 쉘을 나올 때는 exit라는 커맨드로 나올 수 있습니다. 다른 패키지들도 동일한 방식으로 설치 및 정상적으로 설치가 되었는지 버전을 확인하면 됩니다. 앞으로 저자가 각 패키지의 버전들을 기재하는 이유는 저자가 해당 버전으로 실습했으므로 참고하라는 의미에서 공개하는 것이지, 독자가 더 높은 버전임에도 저자가 공개한 버전들과 동일해야 한다는 의미는 아닙니다. 텐서 플로는 주로 tf라는 명칭으로 임포트 하는 것이 관례입니다. 2. 케라스(Keras) 케라스(Keras)는 딥 러닝 프레임워크인 텐서 플로에 대한 추상화된 API를 제공합니다. 케라스는 백엔드로 텐서 플로를 사용하며, 좀 더 쉽게 딥 러닝을 사용할 수 있게 해줍니다. 쉽게 말해, 텐서 플로 코드를 훨씬 간단하게 작성할 수 있습니다. > pip install keras 케라스를 설치 후에 사용할 수도 있지만, 텐서 플로에서 케라스를 사용할 수도 있습니다. 영어 커뮤니티에서는 순수 케라스를 keras라고 표기한다면, 텐서 플로에서 케라스 API를 사용하는 경우는 tf.keras라고 표기합니다. 이 두 가지는 실제로 문법도 많은 면에서 같아서 keras 코드를 tf.keras로 변경하는 건 아주 쉽고, keras를 학습하였다면 tf.keras도 금방 익숙하게 사용할 수 있습니다. 케라스 개발자인 프랑수아 숄레(François Chollet)는 앞으로는 keras보다는 tf.keras를 사용할 것을 권장합니다. 이 책에서도 주로 tf.keras를 사용합니다. > ipython ... In [1]: import keras In [2]: keras.__version__ Out[2]: '2.3.1' 3. 젠심(Gensim) 젠심(Gensim)은 머신 러닝을 사용하여 토픽 모델링과 자연어 처리 등을 수행할 수 있게 해주는 오픈 소스 라이브러리입니다. 이 책에서도 젠심을 사용하여 Word2Vec 등 다양한 모델들을 학습해 볼 것입니다. > pip install gensim > ipython ... In [1]: import gensim In [2]: gensim.__version__ Out[2]: '3.8.1' 4. 사이킷런(Scikit-learn) 사이킷런(Scikit-learn)은 파이썬 머신러닝 라이브러리입니다. 사이킷런을 통해 나이브 베이즈 분류, 서포트 벡터 머신 등 다양한 머신 러닝 모듈을 불러올 수 있습니다. 또한, 사이킷런에는 머신러닝을 연습하기 위한 아이리스 데이터, 당뇨병 데이터 등 자체 데이터 또한 제공하고 있습니다. 사이킷런은 위 패키지들과 달리 아나콘다로 자동 설치되지만 아나콘다를 설치하지 않았다면 아래의 커맨드로 Scikit-learn을 별도 설치할 수 있습니다. > pip install scikit-learn > ipython ... In [1]: import sklearn In [2]: sklearn.__version__ Out[2]: '0.21.3' 5. 주피터 노트북(Jupyter Notebook) 주피터 노트북은 웹에서 코드를 작성하고 실행할 수 있는 오픈소스 웹 애플리케이션입니다. 이 책의 모든 코드들은 기본적으로 본인의 컴퓨터에 설치된 주피터 노트북 또는 주피터 노트북과 실습 환경이 유사한 구글의 코랩(Colab)을 사용한다고 가정합니다. 주피터 노트북도 아나콘다를 설치하면 자동으로 설치돼 있습니다. 아나콘다를 설치하지 않았다면 아래의 커맨드로 Jupyter notebook을 별도 설치할 수 있습니다. > pip install jupyter 설치가 완료되었으면 프롬프트에서 다음 명령어를 통해 주피터 노트북을 실행할 수 있습니다. > jupyter notebook 해당 명령어를 치면 웹 브라우저가 자동으로 열리면서 주피터 노트북이 실행됩니다. 만약 실행되지 않는다면, 직접 실행시켜야 합니다. 웹 브라우저를 열고 프롬프트에서 나오고 있는 주소인 "localhost:8888"에 접속합니다. 1) 새로운 노트 실행 주피터 노트북에서는 노트를 생성해서 해당 노트에 코드를 작성할 수 있습니다. 화면 우측의 New 버튼을 누르고, Python3을 눌러서 새로운 노트를 실행해 봅시다. 2) 셀에 코드 작성해 보기 노트가 실행되면 In [ ]이라는 문자가 적힌 텍스트 상자가 나옵니다. 주피터 노트북에서는 해당 텍스트 상자의 단위를 셀(cell)이라고 부릅니다. 해당 셀에 코드를 입력하고 [Cell] → [Run Cells]를 클릭하면 실행됩니다. 만약, 마우스로 일일이 실행하는 것이 번거롭게 느껴진다면 키보드의 Shift + Enter를 통해서 현재 셀 실행 후 다음 셀로 이동합니다. 이는 구글의 Colab에서 설명했던 실행 방식과 동일한 방식입니다. 01-03 자연어 처리를 위한 NLTK와 KoNLPy 설치하기 다음 챕터인 텍스트 전처리(Text preprocessing) 챕터에서는 전처리를 위한 이론에 대해서 학습하고, 그 이론을 바탕으로 실습을 진행하게 됩니다. 이번 챕터에서는 실습에 필요한 기본적인 자연어 패키지들을 소개합니다. 1. NLTK와 NLTK Data 설치 엔엘티케이(NLTK)는 자연어 처리를 위한 파이썬 패키지입니다. 아나콘다를 설치하였다면 NLTK는 기본적으로 설치가 되어 있습니다. 아나콘다를 설치하지 않았다면 아래의 커맨드로 NLTK를 별도 설치할 수 있습니다. > pip install nltk > ipython ... In [1]: import nltk In [2]: nltk.__version__ Out[2]: '3.4.5' NLTK의 기능을 제대로 사용하기 위해서는 NLTK Data라는 여러 데이터를 추가적으로 설치해야 합니다. 이를 위해서는 파이썬 코드 내에서 import nltk 이후에 nltk.download()라는 코드를 수행하여 설치합니다. In [3]: nltk.download() 해당 코드를 실행 후에 NLTK 실습에 필요한 각종 패키지와 코퍼스를 다운로드할 수 있습니다. 이를 통칭하여 NLTK Data라고 하겠습니다. 만약, NLTK 실습을 수행하던 도중에 에러가 발생한다면 아래의 2번과 3번 가이드를 참고하시기 바랍니다. 2. NLTK Data가 설치되지 않은 경우 NLTK는 각 실습마다 필요한 NLTK Data가 있습니다. 만약 해당 실습에 필요한 NLTK Data가 설치되지 않은 경우에는 코드 실행 시에 아래와 같은 경고문이 나타납니다. LookupError: ********************************************************************** Resource treebank not found. Please use the NLTK Downloader to obtain the resource: >>> import nltk >>> nltk.download('treebank') ********************************************************************** 위의 경우에는 NLTK Data 중에서 'treebank'라는 리소스가 설치되지 않았을 경우입니다. 이 경우 위의 안내처럼 주피터 노트북 또는 iPython 쉘 안에서 동일하게 코드를 수행하면 됩니다. In [1]: import nltk In [2]: nltk.download('treebank') 3. NLTK Data 설치 시 에러가 발생할 경우 링크 : https://github.com/nltk/nltk_data 설치 시 에러가 발생한다면, 수동 설치를 진행하여 정해진 경로에 위치시켜야 합니다. 수동 설치를 진행할 수 있는 경로는 nltk_data의 깃허브 주소와 nltk_data 공식 사이트 두 곳이 있습니다. 우선 nltk_data의 깃허브 사이트의 링크는 위와 같습니다. 위 링크의 packages 디렉터리에서 필요한 nltk_data 파일들을 모두 다운로드할 수 있습니다. 예를 들어서 토큰화 작업을 위해 'punkt' 파일이 필요하다면, nltk_data/packages/tokenizer 경로에서 punkt.zip 파일을 다운로드하면 됩니다. 이렇게 필요한 파일들을 다운로드한 후, 각 O/S 별 정해진 경로에 위치시킵니다. 각 O/S 별 정해진 경로는 다음과 같습니다. 윈도 : C:/nltk_data 또는 D:/nltk_data UNIX : /usr/local/share/nltk_data/ 또는 /usr/share/nltk_data 가장 간단한 방법으로는 packages 디렉터리 전체를 다운로드해 경로에 위치시키는 방법도 있습니다. 링크 : http://www.nltk.org/nltk_data/ 수동 설치를 진행할 수 있는 사이트로 nltk_data 공식 사이트도 있습니다. 토큰화 작업이 필요한 상황이라고 다시 가정합시다. 그렇다면 위 링크로 이동해 CTRL + F를 눌러 'tokenizer'를 검색하고, 검색에 나오는 106. Punkt Tokenizer Models [ download | source ] 해당 줄을 찾은 뒤, download 버튼을 누르면 됩니다. 그러면 punkt.zip 파일을 다운로드할 수 있습니다. 다운로드 후 위치시켜야 하는 알맞은 경로는 위에서 언급한 경로와 동일합니다. 4. KoNLPy 설치 코엔엘파이(KoNLPy)는 한국어 자연어 처리를 위한 형태소 분석기 패키지입니다. 프롬프트에서 아래 커맨드로 설치합니다. > pip install konlpy > ipython ... In [1]: import konlpy In [2]: konlpy.__version__ Out[2]: '0.5.1' 5. 윈도에서 KoNLPy 에러가 발생하는 경우 윈도에서 KoNLPy를 설치하거나 실행 시 JDK 관련 오류나 JPype 오류에 부딪히는 경우가 있습니다. 이는 KoNLPy가 JAVA로 구성되어 있기 때문인데 오류 해결을 위해서는 JDK 1.7 이상의 버전과 JPype가 설치되어 있어야 합니다. 1) JDK 설치 우선 JDK를 1.7 버전 이상으로 설치해야 합니다. 설치 주소 : https://www.oracle.com/technetwork/java/javase/downloads/index.html 설치한 후에는 JDK가 설치된 경로를 찾아야 합니다. 예를 들어 저자의 경우에는 jdk가 아래의 경로에 설치되어 있습니다. 경로 : C:\Program Files\Java\jdk-11.0.1 11.0.1과 같이 버전에 대한 숫자는 어떤 버전을 설치했느냐에 따라 다를 수 있습니다. 2) JDK 환경 변수 설치 경로를 찾았다면 해당 경로를 복사합니다. 해당 경로를 윈도 환경 변수에 추가해야 하기 때문입니다. 윈도 10기준) 제어판 > 시스템 및 보안 > 시스템 > 고급 시스템 설정 > 고급 > 환경 변수 새로 만들기(N)...를 누르고 JAVA_HOME이라는 환경 변수를 만듭니다. 환경 변수의 값은 앞서 찾았던 jdk 설치 경로입니다. 이제 KoNLPy를 사용하기 위한 JDK 설정을 마쳤습니다. 3) JPype 설치 이제 JAVA와 Python을 연결해 주는 역할을 하는 JPype를 설치해야 합니다. 설치 주소 : https://github.com/jpype-project/jpype/releases 해당 링크에서 Assets라고 기재된 곳에서 적절한 버전을 설치해야 하는데 cp27은 파이썬 2.7, cp36은 파이썬 3.6을 의미합니다. 저자가 책을 집필할 당시에는 파이썬 3.6을 사용하고 있었으므로 cp36이라고 적힌 JPype를 설치했습니다. 또 사용하는 윈도 O/S가 32비트인지, 64비트인지에 따라서 설치 JPype가 다른데, 윈도 32비트를 사용하고 있다면 win32를, 윈도 64비트를 사용하고 있다면 win_amd64를 설치해야 합니다. 예를 들어 파이썬 3.6, 윈도 64비트를 사용 중이라면 JPype1-0.6.3-cp36-cp36m-win_amd64.whl를 다운로드합니다. 프롬프트에서 해당 파일의 경로로 이동하여 아래 커맨드를 통해 설치합니다. > pip install JPype1-0.6.3-cp36-cp36m-win_amd64.whl 이제 JPype의 설치가 완료되었다면, KoNLPy를 사용할 준비가 되었습니다. 참고 : KoNLPy 수행 시 자바 오류는, 파이썬 bit와 자바 bit가 다른 경우도 발생하는 것 같습니다. 가장 확실한 해결 방법은 설치된 자바를 전부<NAME>고 최신 버전(JRE, JDK)으로 새로 깔면 대부분 해결됩니다. 01-04 판다스(Pandas) and 넘파이(Numpy) and 맷플롭립(Matplotlib) 데이터 분석을 위한 필수 패키지 삼대장이 있습니다. 바로 Pandas와 Numpy 그리고 Matplotlib입니다. 세 개의 패키지 모두 아나콘다를 설치했다면 추가 설치 없이 사용할 수 있습니다. 이 세 개의 패키지를 간단히 실습해 봅시다. 1. 판다스(Pandas) 판다스(Pandas)는 파이썬 데이터 처리를 위한 라이브러리입니다. 파이썬을 이용한 데이터 분석과 같은 작업에서 필수 라이브러리로 알려져 있습니다. 참고할 수 있는 Pandas 링크는 다음과 같습니다. 링크 : http://pandas.pydata.org/pandas-docs/stable/ 아나콘다를 설치하지 않았다면 아래의 커맨드로 Pandas를 별도 설치할 수 있습니다. pip install pandas > ipython ... In [1]: import pandas as pd In [2]: pd.__version__ Out[2]: '0.25.1' Pandas의 경우 pd라는 명칭으로 임포트 하는 것이 관례입니다. import pandas as pd Pandas는 총 세 가지의 데이터 구조를 사용합니다. 시리즈(Series) 데이터 프레임(DataFrame) 패널(Panel) 이 중 데이터 프레임이 가장 많이 사용되며 여기서는 시리즈와 데이터 프레임에 대해서 다룹니다. 1) 시리즈(Series) 시리즈 클래스는 1차원 배열의 값(values)에 각 값에 대응되는 인덱스(index)를 부여할 수 있는 구조를 갖고 있습니다. sr = pd.Series([17000, 18000, 1000, 5000], index=["피자", "치킨", "콜라", "맥주"]) print('시리즈 출력 :') print('-'*15) print(sr) 시리즈 출력 : --------------- 피자 17000 치킨 18000 콜라 1000 맥주 5000 dtype: int64 값(values)과 인덱스(index)를 출력합니다. print('시리즈의 값 : {}'.format(sr.values)) print('시리즈의 인덱스 : {}'.format(sr.index)) 시리즈의 값 : [17000 18000 1000 5000] 시리즈의 인덱스 : Index(['피자', '치킨', '콜라', '맥주'], dtype='object') 2) 데이터 프레임(DataFrame) 데이터 프레임은 2차원 리스트를 매개변수로 전달합니다. 2차원이므로 행방향 인덱스(index)와 열 방향 인덱스(column)가 존재합니다. 다시 말해 행과 열을 가지는 자료구조입니다. 시리즈가 인덱스(index)와 값(values)으로 구성된다면, 데이터 프레임은 열(columns)까지 추가되어 열(columns), 인덱스(index), 값(values)으로 구성됩니다. 이 세 개의 구성 요소로부터 데이터 프레임을 생성해 봅시다. values = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] index = ['one', 'two', 'three'] columns = ['A', 'B', 'C'] df = pd.DataFrame(values, index=index, columns=columns) print('데이터 프레임 출력 :') print('-'*18) print(df) 데이터 프레임 출력 : ------------------ A B C one 1 2 3 two 4 5 6 three 7 8 9 생성된 데이터 프레임으로부터 인덱스(index), 값(values), 열(columns)을 각각 출력해 보겠습니다. print('데이터 프레임의 인덱스 : {}'.format(df.index)) print('데이터 프레임의 열이름: {}'.format(df.columns)) print('데이터 프레임의 값 :') print('-'*18) print(df.values) 데이터 프레임의 인덱스 : Index(['one', 'two', 'three'], dtype='object') 데이터 프레임의 열이름: Index(['A', 'B', 'C'], dtype='object') 데이터 프레임의 값 : ------------------ [[1 2 3] [4 5 6] [7 8 9]] 3) 데이터 프레임의 생성 데이터 프레임은 리스트(List), 시리즈(Series), 딕셔너리(dict), Numpy의 ndarrays, 또 다른 데이터 프레임으로부터 생성할 수 있습니다. 여기서는 리스트와 딕셔너리를 사용하여 데이터 프레임을 생성해 보겠습니다. 우선 이중 리스트로 생성하는 경우입니다. # 리스트로 생성하기 data = [ ['1000', 'Steve', 90.72], ['1001', 'James', 78.09], ['1002', 'Doyeon', 98.43], ['1003', 'Jane', 64.19], ['1004', 'Pilwoong', 81.30], ['1005', 'Tony', 99.14], ] df = pd.DataFrame(data) print(df) 0 1 2 0 1000 Steve 90.72 1 1001 James 78.09 2 1002 Doyeon 98.43 3 1003 Jane 64.19 4 1004 Pilwoong 81.30 5 1005 Tony 99.14 생성된 데이터 프레임에 열(columns)을 지정해 줄 수 있습니다. 열이름을 지정하고 출력해 봅시다. df = pd.DataFrame(data, columns=['학번', '이름', '점수']) print(df) 학번 이름 점수 0 1000 Steve 90.72 1 1001 James 78.09 2 1002 Doyeon 98.43 3 1003 Jane 64.19 4 1004 Pilwoong 81.30 5 1005 Tony 99.14 파이썬 자료구조 중 하나인 딕셔너리(dictionary)를 통해 데이터 프레임을 생성해 보겠습니다. # 딕셔너리로 생성하기 data = { '학번' : ['1000', '1001', '1002', '1003', '1004', '1005'], '이름' : [ 'Steve', 'James', 'Doyeon', 'Jane', 'Pilwoong', 'Tony'], '점수': [90.72, 78.09, 98.43, 64.19, 81.30, 99.14] } df = pd.DataFrame(data) print(df) 학번 이름 점수 0 1000 Steve 90.72 1 1001 James 78.09 2 1002 Doyeon 98.43 3 1003 Jane 64.19 4 1004 Pilwoong 81.30 5 1005 Tony 99.14 4) 데이터 프레임 조회하기 아래의 명령어는 데이터 프레임에서 원하는 구간만 확인하기 위한 명령어로서 유용하게 사용됩니다. df.head(n) - 앞 부분을 n 개만 보기 df.tail(n) - 뒷부분을 n 개만 보기 df['열 이름'] - 해당되는 열을 확인 위에서 사용한 데이터 프레임을 그대로 사용하여 실습해 봅시다. # 앞 부분을 3개만 보기 print(df.head(3)) 학번 이름 점수 0 1000 Steve 90.72 1 1001 James 78.09 2 1002 Doyeon 98.43 # 뒷부분을 3개만 보기 print(df.tail(3)) 학번 이름 점수 3 1003 Jane 64.19 4 1004 Pilwoong 81.30 5 1005 Tony 99.14 # '학번'에 해당되는 열을 보기 print(df['학번']) 0 1000 1 1001 2 1002 3 1003 4 1004 5 1005 Name: 학번, dtype: object 5) 외부 데이터 읽기 Pandas는 CSV, 텍스트, Excel, SQL, HTML, JSON 등 다양한 데이터 파일을 읽고 데이터 프레임을 생성할 수 있습니다. 예를 들어 csv 파일을 읽을 때는 pandas.read_csv()를 통해 읽을 수 있습니다. 다음과 같은 example.csv 파일이 있다고 합시다. df = pd.read_csv('example.csv') print(df) student id name score 0 1000 Steve 90.72 1 1001 James 78.09 2 1002 Doyeon 98.43 3 1003 Jane 64.19 4 1004 Pilwoong 81.30 5 1005 Tony 99.14 이 경우 인덱스가 자동으로 부여됩니다. 인덱스를 출력해 보겠습니다. print(df.index) RangeIndex(start=0, stop=6, step=1) 2. 넘파이(Numpy) 넘파이(Numpy)는 수치 데이터를 다루는 파이썬 패키지입니다. Numpy의 핵심이라고 불리는 다차원 행렬 자료구조인 ndarray를 통해 벡터 및 행렬을 사용하는 선형 대수 계산에서 주로 사용됩니다. Numpy는 편의성뿐만 아니라, 속도 면에서도 순수 파이썬에 비해 압도적으로 빠르다는 장점이 있습니다. 아나콘다를 설치하지 않았다면 아래의 커맨드로 Numpy를 별도 설치할 수 있습니다. pip install numpy > ipython ... In [1]: import numpy as np In [2]: np.__version__ Out[2]: '1.16.5' Numpy의 경우 np라는 명칭으로 임포트 하는 것이 관례입니다. import numpy as np 1) np.array() Numpy의 핵심은 ndarray입니다. np.array()는 리스트, 튜플, 배열로부터 ndarray를 생성합니다. 파이썬 자료구조 중 하나인 리스트를 가지고 1차원 배열을 생성해 보겠습니다. # 1차원 배열 vec = np.array([1, 2, 3, 4, 5]) print(vec) [1 2 3 4 5] 2차원 배열을 만들어보겠습니다. 주의할 점은 array() 안에 하나의 리스트만 들어가므로 리스트의 리스트를 넣어야 합니다. # 2차원 배열 mat = np.array([[10, 20, 30], [ 60, 70, 80]]) print(mat) [[10 20 30] [60 70 80]] 두 배열의 타입을 확인해 봅시다. print('vec의 타입 :',type(vec)) print('mat의 타입 :',type(mat)) vec의 타입 : <class 'numpy.ndarray'> mat의 타입 : <class 'numpy.ndarray'> 동일하게 타입이 numpy.ndarray라고 나오게 됩니다. Numpy 배열에는 축의 개수(ndim)와 크기(shape)라는 개념이 존재하는데, 배열의 크기를 정확히 숙지하는 것은 딥 러닝에서 매우 중요합니다. 축의 개수와 크기가 어떤 의미를 가지는지에 대해서는 머신 러닝 챕터에서 벡터와 행렬 연산을 설명할 때 언급하겠습니다. print('vec의 축의 개수 :',vec.ndim) # 축의 개수 출력 print('vec의 크기(shape) :',vec.shape) # 크기 출력 vec의 축의 개수 : 1 vec의 크기(shape) : (5, ) print('mat의 축의 개수 :',mat.ndim) # 축의 개수 출력 print('mat의 크기(shape) :',mat.shape) # 크기 출력 mat의 축의 개수 : 2 mat의 크기(shape) : (2, 3) 2) ndarray의 초기화 위에서는 리스트를 가지고 ndarray를 생성했지만 ndarray를 만드는 다양한 다른 방법이 존재합니다. 이 외에도 다양한 방법이 존재하므로 필요에 따라서 다양한 배열을 생성할 수 있습니다. np.zeros()는 배열의 모든 원소에 0을 삽입합니다. # 모든 값이 0인 2x3 배열 생성. zero_mat = np.zeros((2,3)) print(zero_mat) [[0. 0. 0.] [0. 0. 0.]] np.ones()는 배열의 모든 원소에 1을 삽입합니다. # 모든 값이 1인 2x3 배열 생성. one_mat = np.ones((2,3)) print(one_mat) [[1. 1. 1.] [1. 1. 1.]] np.full()은 배열에 사용자가 지정한 값을 삽입합니다. # 모든 값이 특정 상수인 배열 생성. 이 경우 7. same_value_mat = np.full((2,2), 7) print(same_value_mat) [[7 7] [7 7]] np.eye()는 대각선으로는 1이고 나머지는 0인 2차원 배열을 생성합니다. # 대각선 값이 1이고 나머지 값이 0인 2차원 배열을 생성. eye_mat = np.eye(3) print(eye_mat) [[1. 0. 0.] [0. 1. 0.]] [0. 0. 1.]] np.random.random()은 임의의 값을 가지는 배열을 생성합니다. # 임의의 값으로 채워진 배열 생성 random_mat = np.random.random((2,2)) # 임의의 값으로 채워진 배열 생성 print(random_mat) [[0.3111881 0.72996102] [0.65667734 0.40758328]] 이 외에도 Numpy에는 배열을 만드는 다양한 방법이 존재하므로 필요한 방법을 사용하여 배열을 생성할 수 있습니다. 3) np.arange() np.arange(n)은 0부터 n-1까지의 값을 가지는 배열을 생성합니다. # 0부터 9까지 range_vec = np.arange(10) print(range_vec) [0 1 2 3 4 5 6 7 8 9] np.arange(i, j, k)는 i부터 j-1까지 k씩 증가하는 배열을 생성합니다. # 1부터 9까지 +2씩 적용되는 범위 n = 2 range_n_step_vec = np.arange(1, 10, n) print(range_n_step_vec) [1 3 5 7 9] 4) np.reshape() np.reshape()은 내부 데이터는 변경하지 않으면서 배열의 구조를 바꿉니다. 0부터 29까지의 숫자를 생성하는 arange(30)을 수행한 후, 원소의 개수가 30개이므로 5행 6열의 행렬로 변경해 봅시다. reshape_mat = np.array(np.arange(30)).reshape((5,6)) print(reshape_mat) [[ 0 1 2 3 4 5] [ 6 7 8 9 10 11] [12 13 14 15 16 17] [18 19 20 21 22 23] [24 25 26 27 28 29]] 5) Numpy 슬라이싱 ndarray를 통해 만든 다차원 배열은 파이썬의 자료구조인 리스트처럼 슬라이싱(slicing) 기능을 지원합니다. 슬라이싱 기능을 사용하여 특정 행이나 열들의 원소들을 접근할 수 있습니다. mat = np.array([[1, 2, 3], [4, 5, 6]]) print(mat) [[1 2 3] [4 5 6]] # 첫 번째 행 출력 slicing_mat = mat[0, :] print(slicing_mat) [1 2 3] # 두 번째 열 출력 slicing_mat = mat[:, 1] print(slicing_mat) [2 5] 6) Numpy 정수 인덱싱(integer indexing) 슬라이싱을 사용하면 배열로부터 부분 배열을 추출할 수 있지만, 연속적이지 않은 원소로 배열을 만들 경우에는 슬라이싱으로는 만들 수 없습니다. 예를 들어서 2행 2열의 원소와 5행 5열의 원소를 뽑아서 하나의 배열로 만들고자 하는 경우가 그렇습니다. 이런 경우에는 인덱싱을 사용하여 배열을 구성할 수 있습니다. 인덱싱은 원하는 위치의 원소들을 뽑을 수 있습니다. mat = np.array([[1, 2], [4, 5], [7, 8]]) print(mat) [[1 2] [4 5] [7 8]] 특정 위치의 원소만을 가져와봅시다. # 1행 0열의 원소 # => 0부터 카운트하므로 두 번째 행 첫 번째 열의 원소. print(mat[1, 0]) 특정 위치의 원소 두 개를 가져와 새로운 배열을 만들어봅시다. # mat[[2행, 1행],[0열, 1열]] # 각 행과 열의 쌍을 매칭하면 2행 0열, 1행 1열의 두 개의 원소. indexing_mat = mat[[2, 1],[0, 1]] print(indexing_mat) [7 5] 7) Numpy 연산 Numpy를 사용하면 배열 간 연산을 손쉽게 수행할 수 있습니다. 덧셈, 뺄셈, 곱셈, 나눗셈을 위해서는 연산자 +, -, *, /를 사용할 수 있으며 또는 np.add(), np.subtract(), np.multiply(), np.divide()를 사용할 수도 있습니다. x = np.array([1,2,3]) y = np.array([4,5,6]) # result = np.add(x, y)와 동일. result = x + y print(result) [5 7 9] # result = np.subtract(x, y)와 동일. result = x - y print(result) [-3 -3 -3] # result = np.multiply(result, x)와 동일. result = result * x print(result) [-3 -6 -9] # result = np.divide(result, x)와 동일. result = result / x print(result) [-3. -3. -3.] 위에서 *를 통해 수행한 것은 요소별 곱입니다. Numpy에서 벡터와 행렬곱 또는 행렬 곱을 위해서는 dot()을 사용해야 합니다. mat1 = np.array([[1,2],[3,4]]) mat2 = np.array([[5,6],[7,8]]) mat3 = np.dot(mat1, mat2) print(mat3) [[19 22] [43 50]] 3. 맷플롯립(Matplotlib) 맷플롯립(Matplotlib)은 데이터를 차트(chart)나 플롯(plot)으로 시각화하는 패키지입니다. 데이터 분석에서 Matplotlib은 데이터 분석 이전에 데이터 이해를 위한 시각화나, 데이터 분석 후에 결과를 시각화하기 위해서 사용됩니다. 아나콘다를 설치하지 않았다면 아래의 커맨드로 Matplotlib를 별도 설치할 수 있습니다. pip install matplotlib > ipython ... In [1]: import matplotlib as mpl In [2]: mpl.__version__ Out[2]: '2.2.3' Matplotlib을 다 설치하였다면 Matplotlib의 주요 모듈인 pyplot를 관례상 plt라는 명칭으로 임포트 해봅시다. import matplotlib.pyplot as plt 1) 라인 플롯 그리기 plot()은 라인 플롯을 그리는 기능을 수행합니다. plot()에 x축과 y 축의 값을 기재하고 그림을 표시하는 show()를 통해서 시각화해봅시다. 그래프에는 title('제목')을 사용하여 제목을 지정할 수 있습니다. 여기서는 그래프에 'test'라는 제목을 넣어봅시다. 주피터 노트북에서는 show()를 사용하지 않더라도 그래프가 자동으로 렌더링 되므로 그래프가 시각화가 되지만 다른 개발 환경에서 사용할 때를 가정하여 show()를 코드에 삽입하였습니다. plt.title('test') plt.plot([1,2,3,4],[2,4,8,6]) plt.show() 2) 축 레이블 삽입하기 x축과 y 축 각각에 축이름을 삽입하고 싶다면 xlabel('넣고 싶은 축이름')과 ylabel('넣고 싶은 축이름')을 사용합니다. 위의 그래프에 hours와 score라는 축이름을 각각 추가해 봅시다. plt.title('test') plt.plot([1,2,3,4],[2,4,8,6]) plt.xlabel('hours') plt.ylabel('score') plt.show() 3) 라인 추가와 범례 삽입하기 다수의 plot()을 하나의 그래프에 나타낼 수 있습니다. 여러 개의 라인 플롯을 동시에 사용할 경우에는 각 선이 어떤 데이터를 나타내는지를 보여주기 위해 범례(legend)를 사용할 수 있습니다. plt.title('students') plt.plot([1,2,3,4],[2,4,8,6]) plt.plot([1.5,2.5,3.5,4.5],[3,5,8,10]) # 라인 새로 추가 plt.xlabel('hours') plt.ylabel('score') plt.legend(['A student', 'B student']) # 범례 삽입 plt.show() 좀 더 다양한 형태의 그래프를 그리는 실습은 딥 러닝 챕터의 인공 신경망 훑어보기 실습에서 확인할 수 있습니다. 01-05 판다스 프로파일링(Pandas-Profiling) 좋은 요리를 위해서는 조리 방법도 중요하지만, 그만큼 중요한 것은 갖고 있는 재료의 상태입니다. 재료가 상하거나 문제가 있다면 좋은 요리가 나올 수 없습니다. 마찬가지로 좋은 머신 러닝 결과를 얻기 위해서는 데이터의 성격을 파악하는 과정이 선행되어야 합니다. 이 과정에서 데이터 내 값의 분포, 변수 간의 관계, Null 값과 같은 결측값(missing values) 존재 유무 등을 파악하게 되는데 이와 같이 데이터를 파악하는 과정을 EDA(Exploratory Data Analysis, 탐색적 데이터 분석)이라고 합니다. 이번에는 방대한 양의 데이터를 가진 데이터 프레임을. profile_report()라는 단 한 줄의 명령으로 탐색하는 패키지인 판다스 프로파일링(pandas-profiling)을 소개합니다. 프롬프트에서 아래의 pip 명령을 통해 패키지를 설치합니다. pip install -U pandas-profiling 1. 실습 파일 불러오기 실습을 위해 아래의 링크에서 spam.csv란 파일을 다운로드해 보겠습니다. 해당 데이터 셋은 스팸 메일 분류하기 챕터에서 재사용됩니다. 다운로드 링크 : https://www.kaggle.com/uciml/sms-spam-collection-dataset spam.csv를 다운로드했다면 해당 파일을 주피터 노트북에 가져와보겠습니다. import pandas as pd import pandas_profiling data = pd.read_csv('spam.csv 파일의 경로',encoding='latin1') # 윈도 바탕화면에서 작업한 저자의 경우에는 # data = pd.read_csv(r'C:\Users\USER\Desktop\spam.csv',encoding='latin1') 다운로드한 spam.csv 파일을 Pandas를 이용하여 data에 저장하였습니다. 5개의 행만 출력해 보겠습니다. data[:5] 이 데이터에는 총 5개의 열이 있는데, 여기서 Unnamed라는 이름의 3개의 열은 5개의 행만 출력했음에도 벌써 Null 값이 보입니다. v1열은 해당 메일이 스팸인지 아닌지를 나타내는 레이블에 해당되는 열입니다. ham은 정상 메일을 의미하고, spam은 스팸 메일을 의미합니다. v2열은 메일의 본문을 담고 있습니다. pandas-profiling을 통해 해당 데이터를 좀 더 자세히 살펴보겠습니다. 2. 리포트 생성하기 pr=data.profile_report() # 프로파일링 결과 리포트를 pr에 저장 # data.profile_report() # 바로 결과 보기 데이터 프레임에. profile_report()를 사용하여 데이터를 프로파일링 한 리포트를 생성할 수 있습니다. 만약 저장할 변수를 지정하지 않으면 주피터 노트북에서 바로 리포트를 확인할 수 있습니다. pr.to_file('./pr_report.html') # pr_report.html 파일로 저장 주피터 노트북으로 리포트를 확인할 수도 있겠지만, 위의 명령을 통해 HTML 파일로 저장하는 것도 가능합니다. 3. 리포트 살펴보기 이제 저장할 리포트를 주피터 노트북에 출력하여 리포트 내용을 살펴보겠습니다. pr # pr에 저장했던 리포트 출력 1) 개요(Overview) Overview는 데이터의 전체적인 개요를 보여줍니다. 데이터의 크기, 변수의 수, 결측값(missing value) 비율, 데이터의 종류는 어떤 것이 있는지를 볼 수 있습니다. Dataset info를 보겠습니다. 해당 데이터는 총 5,572개의 샘플(행)을 가지고 있으며, 5개의 열을 가지고 있습니다. 하나의 값을 셀이라고 하였을 때, 총 5,572 × 5개의 셀 이 존재하지만 그중 16,648개(59.8%)가 결측값(missing values)으로 확인됩니다. Warnings를 보면 사실 결측값들은 Unnamed라는 3개의 열에 존재합니다. 3개의 열 모두는 99% 이상이 결측값을 갖고 있어 데이터에서 별다른 의미를 갖지 못합니다. 앞서 메일의 본문을 의미한다고 했던 v2열은 총 5,169개의 중복되지 않은 값(distinct value)을 갖고 있습니다. 총 샘플의 개수가 5,572개인 것을 감안하면 403개의 메일은 중복이 존재한다는 의미입니다. 2) 변수(Variables) 변수(Variables)는 데이터에 존재하는 모든 특성 변수들에 대한 결측값, 중복을 제외한 유일한 값(unique values)의 개수 등의 통계치를 보여줍니다. 또한 상위 5개의 값에 대해서는 우측에 바 그래프로 시각화한 결과를 제공합니다. 우선 Unnamed라는 이름을 가진 3개의 열에 대해서 보겠습니다. 앞서 개요에서 봤듯이 3개의 열 모두 99% 이상의 값이 결 측 값입니다. 예를 들어 Unnamed_2 열은 총 5,572개의 값 중에서 5,522개가 결 측 값입니다. 이는 총 50개의 결측값이 아닌 값이 존재함을 의미합니다. 그리고 그중 중복을 제거한 유일한 값의 개수는 44개입니다. 이번에는 다른 2개의 열인 v1과 v2를 보겠습니다. v2는 메일의 본문이고, v1은 해당 메일이 정상 메일(ham)인지, 스팸 메일(spam)인지 유무가 기재돼 있습니다. v1의 경우 유일한 값의 개수(distinct count)가 2개뿐으로 5,572개의 값 중에서 우측의 바 그래프를 통해 4,825개가 ham이고 747개가 spam인 것을 알 수 있습니다. 이는 데이터에서 정상 메일 샘플이 훨씬 많다는 것을 보여줍니다. v2의 경우 5,572개의 메일 본문 중에서 중복을 제외하면 5,169개의 유일한 내용의 메일 본문을 갖고 있습니다. 그중 중복이 가장 많은 메일은 Sorry, I'll call later라는 내용의 메일로 총 30개의 메일이 존재합니다. 또한 v1과 v2 모두 결측값(missing values)은 존재하지 않는데, 이는 결과적으로 데이터 전처리를 수행할 때, Unnamed라는 3개의 열을 제거하고 나서는 별도의 결측값 전처리는 필요가 없음을 의미합니다. 이번에는 바 그래프 우측 하단에 있는 상세사항 확인하기(Toggle details)를 눌러보겠습니다. 3) 상세사항 확인하기(Toggle details) 우선 v1의 상세사항 확인하기(Toggle details)를 누른 결과는 위와 같습니다. 상세사항 확인하기에서는 총 2개의 탭이 존재하는데, 첫 번째 탭인 빈도 값(common values)에서는 앞서 바 그래프로 확인했던 각 값의 분포를 좀 더 상세하게 보여줍니다. v1의 경우, ham이 총 4,825개로 이는 전체 값 중 86.6%에 해당되며, spam은 747개로 전체 값 중에서는 13.4%에 해당됩니다. 두 번째 탭인 구성(composition)에서는 전체 값의 최대 길이, 최소 길이, 평균 길이와 값의 구성에 대해서 볼 수 있습니다. v1의 모든 값들은 spam 또는 ham이라는 1개 단어만 존재하지만, 여기서의 길이는 단어 단위로 측정한 길이가 아니라 문자열 길이므로 spam의 길이인 4가 최대 길이(max length)가 되고, ham의 길이인 3이 최소 길이(min length)가 됩니다. 4,825개의 4의 길이를 가진 값과 747개의 값의 3의 길이를 평균 길이는 3.134063173이 됩니다. 또한 v1 열의 모든 값들은 숫자, 공백, 특수 문자 등이 없이 알파벳만으로 구성되므로 Contains chars에서만 True가 됩니다. 이번에는 v2의 상세사항 확인하기를 눌러보겠습니다. 중복이 존재하는 상위 10개 메일의 내용을 확인할 수 있습니다. 구성(composition)을 눌러보면 값의 최대 길이는 910, 최소 길이는 2, 평균 길이는 80.11880833임을 알 수 있습니다. 그리고 메일 본문에서는 글자, 숫자, 공백, 특수문자 등이 모두 포함돼 있으므로 모든 Contains에 True를 보여줍니다. 위 데이터에 대해서는 더 이상 불필요한 정보들이므로 이하 설명은 생략하겠지만, pandas-profiling은 위에서 열거한 기능들 외에도 수치형 데이터를 위한 상관계수(correlations), 결측값에 대한 히트맵(headmap), 수지도(dendrogram) 등의 기능을 지원합니다. 01-06 머신 러닝 워크플로(Machine Learning Workflow) 이번 챕터에서는 데이터 사이언스(Data Science) 또는 머신 러닝(Machine Learning) 과정에서 거치는 전반적인 과정에 대해서 알아보겠습니다. 이 책의 제목은 딥 러닝(Deep Learning)을 이용한 자연어 처리이지만, 딥 러닝 또한 머신 러닝의 한 갈래로 딥 러닝 워크플로 또한 머신 러닝 워크플로우로 간주할 수 있습니다. 1. 머신 러닝 워크플로(Machine Learning Workflow) 데이터를 수집하고 머신 러닝을 하는 과정을 크게 6가지로 나누면, 아래의 그림과 같습니다. 1) 수집(Acquisition) 머신 러닝을 하기 위해서는 기계에 학습시켜야 할 데이터가 필요합니다. 자연어 처리의 경우, 자연어 데이터를 말뭉치 또는 코퍼스(corpus)라고 부르는데 코퍼스의 의미를 풀이하면, 조사나 연구 목적에 의해서 특정 도메인으로부터 수집된 텍스트 집합을 말합니다. 텍스트 데이터의 파일<NAME>은 txt 파일, csv 파일, xml 파일 등 다양하며 그 출처도 음성 데이터, 웹 수집기를 통해 수집된 데이터, 영화 리뷰 등 다양합니다. 2) 점검 및 탐색(Inspection and exploration) 데이터가 수집되었다면, 이제 데이터를 점검하고 탐색하는 단계입니다. 여기서는 데이터의 구조, 노이즈 데이터, 머신 러닝 적용을 위해서 데이터를 어떻게 정제해야 하는지 등을 파악해야 합니다. 이 단계를 탐색적 데이터 분석(Exploratory Data Analysis, EDA) 단계라고도 하는데 이는 독립 변수, 종속 변수, 변수 유형, 변수의 데이터 타입 등을 점검하며 데이터의 특징과 내재하는 구조적 관계를 알아내는 과정을 의미합니다. 이 과정에서 시각화와 간단한 통계 테스트를 진행하기도 합니다. 3) 전처리 및 정제(Preprocessing and Cleaning) 데이터에 대한 파악이 끝났다면, 머신 러닝 워크플로에서 가장 까다로운 작업 중 하나인 데이터 전처리 과정에 들어갑니다. 이 단계는 많은 단계를 포함하고 있는데, 가령 자연어 처리라면 토큰화, 정제, 정규화, 불용어 제거 등의 단계를 포함합니다. 빠르고 정확한 데이터 전처리를 하기 위해서는 사용하고 있는 툴(이 책에서는 파이썬)에 대한 다양한 라이브러리에 대한 지식이 필요합니다. 정말 까다로운 전처리의 경우에는 전처리 과정에서 머신 러닝이 사용되기도 합니다. 4) 모델링 및 훈련(Modeling and Training) 데이터 전처리가 끝났다면, 머신 러닝에 대한 코드를 작성하는 단계인 모델링 단계에 들어갑니다. 적절한 머신 러닝 알고리즘을 선택하여 모델링이 끝났다면, 전처리가 완료된 데이터를 머신 러닝 알고리즘을 통해 기계에게 학습(training) 시킵니다. 이를 훈련이라고도 하는데, 이 두 용어를 혼용해서 사용합니다. 기계가 데이터에 대한 학습을 마치고 나서 훈련이 제대로 되었다면 그 후에 기계는 우리가 원하는 태스크(task)인 기계 번역, 음성 인식, 텍스트 분류 등의 자연어 처리 작업을 수행할 수 있게 됩니다. 여기서 주의해야 할 점은 대부분의 경우에서 모든 데이터를 기계에게 학습시켜서는 안 된다는 점입니다. 뒤의 실습에서 보게 되겠지만 데이터 중 일부는 테스트용으로 남겨두고 훈련용 데이터만 훈련에 사용해야 합니다. 그래야만 기계가 학습을 하고 나서, 테스트용 데이터를 통해서 현재 성능이 얼마나 되는지를 측정할 수 있으며 과 적합(overfitting) 상황을 막을 수 있습니다. 사실 최선은 훈련용, 테스트용으로 두 가지만 나누는 것보다는 훈련용, 검증용, 테스트용. 데이터를 이렇게 세 가지로 나누고 훈련용 데이터만 훈련에 사용하는 것입니다. 검증용과 테스트용의 차이는 무엇일까요? 수능 시험에 비유하자면 훈련용은 학습지, 검증용은 모의고사, 테스트용은 수능 시험이라고 볼 수 있습니다. 학습지를 풀고 수능 시험을 볼 수도 있겠지만, 모의고사를 풀며 부족한 부분이 무엇인지 검증하고 보완하는 단계를 하나 더 놓는 방법도 있겠지요. 사실 현업의 경우라면 검증용 데이터는 거의 필수적입니다. 검증용 데이터는 현재 모델의 성능. 즉, 기계가 훈련용 데이터로 얼마나 제대로 학습이 되었는지를 판단하는 용으로 사용되며 검증용 데이터를 사용하여 모델의 성능을 개선하는 데 사용됩니다. 테스트용 데이터는 모델의 최종 성능을 평가하는 데이터로 모델의 성능을 개선하는 일에 사용되는 것이 아니라, 모델의 성능을 수치화하여 평가하기 위해 사용됩니다. 쉽게 말해 시험에 비유하면 채점하는 단계입니다. 이 책에서는 실습 상황에 따라서 훈련용, 검증용, 테스트용 세 가지를 모두 사용하거나 때로는 훈련용, 테스트용 두 가지만 사용하기도 합니다. 하지만 현업에서 최선은 검증용 데이터 또한 사용하는 것임을 기억해둡시다. 5) 평가(Evaluation) 미리 언급하였는데, 기계가 다 학습이 되었다면 테스트용 데이터로 성능을 평가하게 됩니다. 평가 방법은 기계가 예측한 데이터가 테스트용 데이터의 실제 정답과 얼마나 가까운지를 측정합니다. 6) 배포(Deployment) 평가 단계에서 기계가 성공적으로 훈련이 된 것으로 판단된다면 완성된 모델이 배포되는 단계가 됩니다. 다만, 여기서 완성된 모델에 대한 전체적인 피드백으로 인해 모델을 업데이트해야 하는 상황이 온다면 수집 단계로 돌아갈 수 있습니다. 02. 텍스트 전처리(Text preprocessing) 텍스트 전처리는 풀고자 하는 문제의 용도에 맞게 텍스트를 사전에 처리하는 작업입니다. 요리를 할 때 재료를 제대로 손질하지 않으면, 요리가 엉망이 되는 것처럼 텍스트에 제대로 전처리를 하지 않으면 뒤에서 배울 자연어 처리 기법들이 제대로 동작하지 않습니다. 이번 챕터에서는 텍스트를 위한 다양한 전처리 방법들에 대해서 다룹니다. 02-01 토큰화(Tokenization) 자연어 처리에서 크롤링 등으로 얻어낸 코퍼스 데이터가 필요에 맞게 전처리되지 않은 상태라면, 해당 데이터를 사용하고자 하는 용도에 맞게 토큰화(tokenization) & 정제(cleaning) & 정규화(normalization) 하는 일을 하게 됩니다. 이번에는 그중에서도 토큰화에 대해서 학습합니다. 주어진 코퍼스(corpus)에서 토큰(token)이라 불리는 단위로 나누는 작업을 토큰화(tokenization)라고 합니다. 토큰의 단위가 상황에 따라 다르지만, 보통 의미 있는 단위로 토큰을 정의합니다. 여기서는 토큰화에 대한 발생할 수 있는 여러 가지 상황에 대해서 언급하여 토큰화에 대한 개념을 이해합니다. 이어서 NLTK, KoNLPY를 통해 실습을 진행하며 토큰화를 수행합니다. 1. 단어 토큰화(Word Tokenization) 토큰의 기준을 단어(word)로 하는 경우, 단어 토큰화(word tokenization)라고 합니다. 다만, 여기서 단어(word)는 단어 단위 외에도 단 어구, 의미를 갖는 문자열로도 간주되기도 합니다. 예를 들어보겠습니다. 아래의 입력으로부터 구두점(punctuation)과 같은 문자는 제외하는 간단한 단어 토큰화 작업을 해봅시다. 구두점이란 마침표(.), 콤마(,), 물음표(?), 세미콜론(;), 느낌표(!) 등과 같은 기호를 말합니다. 입력: Time is an illusion. Lunchtime double so! 이러한 입력으로부터 구두점을 제외한 토큰화 작업의 결과는 다음과 같습니다. 출력 : "Time", "is", "an", "illustion", "Lunchtime", "double", "so" 이 예제에서 토큰화 작업은 굉장히 간단합니다. 구두점을<NAME> 뒤에 띄어쓰기(whitespace)를 기준으로 잘라냈습니다. 하지만 이 예제는 토큰화의 가장 기초적인 예제를 보여준 것에 불과합니다. 보통 토큰화 작업은 단순히 구두점이나 특수문자를 전부 제거하는 정제(cleaning) 작업을 수행하는 것만으로 해결되지 않습니다. 구두점이나 특수문자를 전부 제거하면 토큰이 의미를 잃어버리는 경우가 발생하기도 합니다. 심지어 띄어쓰기 단위로 자르면 사실상 단어 토큰이 구분되는 영어와 달리, 한국어는 띄어쓰기만으로는 단어 토큰을 구분하기 어렵습니다. 그 이유는 뒤에서 언급하겠습니다. 2. 토큰화 중 생기는 선택의 순간 토큰화를 하다 보면, 예상하지 못한 경우가 있어서 토큰화의 기준을 생각해 봐야 하는 경우가 발생합니다. 물론, 이러한 선택은 해당 데이터를 가지고 어떤 용도로 사용할 것인지에 따라서 그 용도에 영향이 없는 기준으로 정하면 됩니다. 예를 들어 영어권 언어에서 아포스트로피를(')가 들어가 있는 단어는 어떻게 토큰으로 분류해야 하는지에 대한 선택의 문제를 보여드리겠습니다. 다음과 같은 문장이 있다고 해봅시다. Don't be fooled by the dark sounding name, Mr. Jone's Orphanage is as cheery as cheery goes for a pastry shop. 아포스트로피가 들어간 상황에서 Don't와 Jone's는 어떻게 토큰화할 수 있을까요? 다양한 선택지가 있습니다. Don't Don t Dont Do n't Jone's Jone s Jone Jones 이 중 사용자가 원하는 결과가 나오도록 토큰화 도구를 직접 설계할 수도 있겠지만, 기존에 공개된 도구들을 사용하였을 때의 결과가 사용자의 목적과 일치한다면 해당 도구를 사용할 수도 있을 것입니다. NLTK는 영어 코퍼스를 토큰화하기 위한 도구들을 제공합니다. 그중 word_tokenize와 WordPunctTokenizer를 사용해서 아포스트로피를 어떻게 처리하는지 확인해 보겠습니다. from nltk.tokenize import word_tokenize from nltk.tokenize import WordPunctTokenizer from tensorflow.keras.preprocessing.text import text_to_word_sequence 우선 word_tokenize를 사용해 봅시다. print('단어 토큰화 1 :',word_tokenize("Don't be fooled by the dark sounding name, Mr. Jone's Orphanage is as cheery as cheery goes for a pastry shop.")) 단어 토큰화 1 : ['Do', "n't", 'be', 'fooled', 'by', 'the', 'dark', 'sounding', 'name', ',', 'Mr.', 'Jone', "'s", 'Orphanage', 'is', 'as', 'cheery', 'as', 'cheery', 'goes', 'for', 'a', 'pastry', 'shop', '.'] word_tokenize는 Don't를 Do와 n't로 분리하였으며, 반면 Jone's는 Jone과 's로 분리한 것을 확인할 수 있습니다. 그렇다면, wordPunctTokenizer는 아포스트로피가 들어간 코퍼스를 어떻게 처리할까요? print('단어 토큰화 2 :',WordPunctTokenizer().tokenize("Don't be fooled by the dark sounding name, Mr. Jone's Orphanage is as cheery as cheery goes for a pastry shop.")) ['Don', "'", 't', 'be', 'fooled', 'by', 'the', 'dark', 'sounding', 'name', ',', 'Mr', '.', 'Jone', "'", 's', 'Orphanage', 'is', 'as', 'cheery', 'as', 'cheery', 'goes', 'for', 'a', 'pastry', 'shop', '.'] WordPunctTokenizer는 구두점을 별도로 분류하는 특징을 갖고 있기 때문에, 앞서 확인했던 word_tokenize와는 달리 Don't를 Don과 '와 t로 분리하였으며, 이와 마찬가지로 Jone's를 Jone과 '와 s로 분리한 것을 확인할 수 있습니다. 케라스 또한 토큰화 도구로서 text_to_word_sequence를 지원합니다. print('단어 토큰화 3 :',text_to_word_sequence("Don't be fooled by the dark sounding name, Mr. Jone's Orphanage is as cheery as cheery goes for a pastry shop.")) 단어 토큰화 3 : ["don't", 'be', 'fooled', 'by', 'the', 'dark', 'sounding', 'name', 'mr', "jone's", 'orphanage', 'is', 'as', 'cheery', 'as', 'cheery', 'goes', 'for', 'a', 'pastry', 'shop'] 케라스의 text_to_word_sequence는 기본적으로 모든 알파벳을 소문자로 바꾸면서 마침표나 콤마, 느낌표 등의 구두점을 제거합니다. 하지만 don't나 jone's와 같은 경우 아포스트로피는 보존하는 것을 볼 수 있습니다. 3. 토큰화에서 고려해야 할 사항 토큰화 작업을 단순하게 코퍼스에서 구두점을 제외하고 공백 기준으로 잘라내는 작업이라고 간주할 수는 없습니다. 이러한 일은 보다 섬세한 알고리즘이 필요한데 그 이유를 정리해 봅니다. 1) 구두점이나 특수 문자를 단순 제외해서는 안 된다. 갖고 있는 코퍼스에서 단어들을 걸러낼 때, 구두점이나 특수 문자를 단순히 제외하는 것은 옳지 않습니다. 코퍼스에 대한 정제 작업을 진행하다 보면, 구두점조차도 하나의 토큰으로 분류하기도 합니다. 가장 기본적인 예를 들어보자면, 마침표(.)와 같은 경우는 문장의 경계를 알 수 있는데 도움이 되므로 단어를 뽑아낼 때, 마침표(.)를 제외하지 않을 수 있습니다. 또 다른 예로 단어 자체에 구두점을 갖고 있는 경우도 있는데, m.p.h나 Ph.D나 AT&T 같은 경우가 있습니다. 또 특수 문자의 달러나 슬래시(/)로 예를 들어보면, $45.55와 같은 가격을 의미하기도 하고, 01/02/06은 날짜를 의미하기도 합니다. 보통 이런 경우 45.55를 하나로 취급하고 45와 55로 따로 분류하고 싶지는 않을 수 있습니다. 숫자 사이에 콤마(,)가 들어가는 경우도 있습니다. 보통 수치를 표현할 때는 123,456,789와 같이 세 자리 단위로 컴마가 있습니다. 2) 줄임말과 단어 내에 띄어쓰기가 있는 경우. 토큰화 작업에서 종종 영어권 언어의 아포스트로피(')는 압축된 단어를 다시 펼치는 역할을 하기도 합니다. 예를 들어 what're는 what are의 줄임말이며, we're는 we are의 줄임말입니다. 위의 예에서 re를 접어(clitic)이라고 합니다. 즉, 단어가 줄임말로 쓰일 때 생기는 형태를 말합니다. 가령 I am을 줄인 I'm이 있을 때, m을 접어라고 합니다. New York이라는 단어나 rock 'n' roll이라는 단어를 봅시다. 이 단어들은 하나의 단어이지만 중간에 띄어쓰기가 존재합니다. 사용 용도에 따라서, 하나의 단어 사이에 띄어쓰기가 있는 경우에도 하나의 토큰으로 봐야 하는 경우도 있을 수 있으므로, 토큰화 작업은 저러한 단어를 하나로 인식할 수 있는 능력도 가져야 합니다. 3) 표준 토큰화 예제 이해를 돕기 위해 표준으로 쓰이고 있는 토큰화 방법 중 하나인 Penn Treebank Tokenization의 규칙에 대해서 소개하고, 토큰화의 결과를 확인해 보겠습니다. 규칙 1. 하이픈으로 구성된 단어는 하나로<NAME>다. 규칙 2. doesn't와 같이 아포스트로피로 '접어'가 함께하는 단어는 분리해 준다. 해당 표준에 아래의 문장을 입력으로 넣어봅니다. "Starting a home-based restaurant may be an ideal. it doesn't have a food chain or restaurant of their own." from nltk.tokenize import TreebankWordTokenizer tokenizer = TreebankWordTokenizer() text = "Starting a home-based restaurant may be an ideal. it doesn't have a food chain or restaurant of their own." print('트리 뱅크 워드 토크 나이저 :',tokenizer.tokenize(text)) 트리 뱅크 워드 토크 나이저 : ['Starting', 'a', 'home-based', 'restaurant', 'may', 'be', 'an', 'ideal.', 'it', 'does', "n't", 'have', 'a', 'food', 'chain', 'or', 'restaurant', 'of', 'their', 'own', '.'] 결과를 보면, 각각 규칙 1과 규칙 2에 따라서 home-based는 하나의 토큰으로 취급하고 있으며, dosen't의 경우 does와 n't는 분리되었음을 볼 수 있습니다. 4. 문장 토큰화(Sentence Tokenization) 이번에는 토큰의 단위가 문장(sentence)일 경우를 논의해 보겠습니다. 이 작업은 갖고 있는 코퍼스 내에서 문장 단위로 구분하는 작업으로 때로는 문장 분류(sentence segmentation)라고도 부릅니다. 보통 갖고 있는 코퍼스가 정제되지 않은 상태라면, 코퍼스는 문장 단위로 구분되어 있지 않아서 이를 사용하고자 하는 용도에 맞게 문장 토큰 화가 필요할 수 있습니다. 어떻게 주어진 코퍼스로부터 문장 단위로 분류할 수 있을까요? 직관적으로 생각해 봤을 때는? 나 마침표(.)나! 기준으로 문장을 잘라내면 되지 않을까라고 생각할 수 있지만, 꼭 그렇지만은 않습니다. !나?는 문장의 구분을 위한 꽤 명확한 구분자(boundary) 역할을 하지만 마침표는 그렇지 않기 때문입니다. 마침표는 문장의 끝이 아니더라도 등장할 수 있습니다. EX1) IP 192.168.56.31 서버에 들어가서 로그 파일 저장해서 aaa@gmail.com로 결과 좀 보내줘. 그 후 점심 먹으러 가자. EX2) Since I'm actively looking for Ph.D. students, I get the same question a dozen times every year. 예를 들어 위의 예제에 마침표를 기준으로 문장 토큰화를 적용해 본다면 어떨까요? 첫 번째 예제에서는 보내줘.에서 그리고 두 번째 예제에서는 year.에서 처음으로 문장이 끝난 것으로 인식하는 것이 제대로 문장의 끝을 예측했다고 볼 수 있습니다. 하지만 단순히 마침표(.)로 문장을 구분 짓는다고 가정하면, 문장의 끝이 나오기 전에 이미 마침표가 여러 번 등장하여 예상한 결과가 나오지 않게 됩니다. 사용하는 코퍼스가 어떤 국적의 언어인지, 또는 해당 코퍼스 내에서 특수문자들이 어떻게 사용되고 있는지에 따라서 직접 규칙들을 정의해 볼 수 있겠습니다. 100% 정확도를 얻는 일은 쉬운 일이 아닌데, 갖고 있는 코퍼스 데이터에 오타나, 문장의 구성이 엉망이라면 정해놓은 규칙이 소용이 없을 수 있기 때문입니다. NLTK에서는 영어 문장의 토큰화를 수행하는 sent_tokenize를 지원하고 있습니다. NLTK를 통해 문장 토큰화를 실습해 보겠습니다. from nltk.tokenize import sent_tokenize text = "His barber kept his word. But keeping such a huge secret to himself was driving him crazy. Finally, the barber went up a mountain and almost to the edge of a cliff. He dug a hole in the midst of some reeds. He looked about, to make sure no one was near." print('문장 토큰화 1 :',sent_tokenize(text)) 문장 토큰화 1 : ['His barber kept his word.', 'But keeping such a huge secret to himself was driving him crazy.', 'Finally, the barber went up a mountain and almost to the edge of a cliff.', 'He dug a hole in the midst of some reeds.', 'He looked about, to make sure no one was near.'] 위 코드는 text에 저장된 여러 개의 문장들로부터 문장을 구분하는 코드입니다. 출력 결과를 보면 성공적으로 모든 문장을 구분해 내었음을 볼 수 있습니다. 그렇다면 이번에는 문장 중간에 마침표가 다수 등장하는 경우에 대해서도 실습해 보겠습니다. text = "I am actively looking for Ph.D. students. and you are a Ph.D student." print('문장 토큰화 2 :',sent_tokenize(text)) 문장 토큰화 2 : ['I am actively looking for Ph.D. students.', 'and you are a Ph.D student.'] NLTK는 단순히 마침표를 구분자로 하여 문장을 구분하지 않았기 때문에, Ph.D.를 문장 내의 단어로 인식하여 성공적으로 인식하는 것을 볼 수 있습니다. 한국어에 대한 문장 토큰화 도구 또한 존재합니다. 한국어의 경우에는 박상길 님이 개발한 KSS(Korean Sentence Splitter)를 추천합니다. 다음과 같이 KSS를 설치합니다. pip install kss KSS를 통해서 문장 토큰화를 진행해 보겠습니다. import kss text = '딥 러닝 자연어 처리가 재미있기는 합니다. 그런데 문제는 영어보다 한국어로 할 때 너무 어렵습니다. 이제 해보면 알걸요?' print('한국어 문장 토큰화 :',kss.split_sentences(text)) 한국어 문장 토큰화 : ['딥 러닝 자연어 처리가 재미있기는 합니다.', '그런데 문제는 영어보다 한국어로 할 때 너무 어렵습니다.', '이제 해보면 알걸요?'] 출력 결과는 정상적으로 모든 문장이 분리된 결과를 보여줍니다. 5. 한국어에서의 토큰화의 어려움. 영어는 New York과 같은 합성어나 he's 와 같이 줄임말에 대한 예외 처리만 한다면, 띄어쓰기(whitespace)를 기준으로 하는 띄어쓰기 토큰화를 수행해도 단어 토큰 화가 잘 작동합니다. 거의 대부분의 경우에서 단어 단위로 띄어쓰기가 이루어지기 때문에 띄어쓰기 토큰화와 단어 토큰 화가 거의 같기 때문입니다. 하지만 한국어는 영어와는 달리 띄어쓰기만으로는 토큰화를 하기에 부족합니다. 한국어의 경우에는 띄어쓰기 단위가 되는 단위를 '어절'이라고 하는데 어절 토큰화는 한국어 NLP에서 지양되고 있습니다. 어절 토큰화와 단어 토큰화는 같지 않기 때문입니다. 그 근본적인 이유는 한국어가 영어와는 다른 형태를 가지는 언어인 교착어라는 점에서 기인합니다. 교착어란 조사, 어미 등을 붙여서 말을 만드는 언어를 말합니다. 1) 교착어의 특성 예를 들어봅시다. 영어와는 달리 한국어에는 조사라는 것이 존재합니다. 예를 들어 한국어에 그(he/him)라는 주어나 목적어가 들어간 문장이 있다고 합시다. 이 경우, 그라는 단어 하나에도 '그가', '그에게', '그를', '그와', '그는'과 같이 다양한 조사가 '그'라는 글자 뒤에 띄어쓰기 없이 바로 붙게 됩니다. 자연어 처리를 하다 보면 같은 단어임에도 서로 다른 조사가 붙어서 다른 단어로 인식이 되면 자연어 처리가 힘들고 번거로워지는 경우가 많습니다. 대부분의 한국어 NLP에서 조사는 분리해 줄 필요가 있습니다. 띄어쓰기 단위가 영어처럼 독립적인 단어라면 띄어쓰기 단위로 토큰화를 하면 되겠지만 한국어는 어절이 독립적인 단어로 구성되는 것이 아니라 조사 등의 무언가가 붙어있는 경우가 많아서 이를 전부 분리해 줘야 한다는 의미입니다. 한국어 토큰화에서는 형태소(morpheme) 란 개념을 반드시 이해해야 합니다. 형태소(morpheme)란 뜻을 가진 가장 작은 말의 단위를 말합니다. 이 형태소에는 두 가지 형태소가 있는데 자립 형태소와 의존 형태소입니다. 자립 형태소 : 접사, 어미, 조사와 상관없이 자립하여 사용할 수 있는 형태소. 그 자체로 단어가 된다. 체언(명사, 대명사, 수사), 수식언(관형사, 부사), 감탄사 등이 있다. 의존 형태소 : 다른 형태소와 결합하여 사용되는 형태소. 접사, 어미, 조사, 어간을 말한다. 예를 들어 다음과 같은 문장이 있다고 합시다. 문장 : 에디가 책을 읽었다 이 문장을 띄어쓰기 단위 토큰화를 수행한다면 다음과 같은 결과를 얻습니다. ['에디가', '책을', '읽었다'] 하지만 이를 형태소 단위로 분해하면 다음과 같습니다. 자립 형태소 : 에디, 책 의존 형태소 : -가, -을, 읽-, -었, -다 '에디'라는 사람 이름과 '책'이라는 명사를 얻어낼 수 있습니다. 이를 통해 유추할 수 있는 것은 한국어에서 영어에서의 단어 토큰화와 유사한 형태를 얻으려면 어절 토큰 화가 아니라 형태소 토큰화를 수행해야 한다는 겁니다. 2) 한국어는 띄어쓰기가 영어보다 잘 지켜지지 않는다. 사용하는 한국어 코퍼스가 뉴스 기사와 같이 띄어쓰기를 철저하게 지키려고 노력하는 글이라면 좋겠지만, 많은 경우에 띄어쓰기가 틀렸거나 지켜지지 않는 코퍼스가 많습니다. 한국어는 영어권 언어와 비교하여 띄어쓰기가 어렵고 잘 지켜지지 않는 경향이 있습니다. 그 이유는 여러 견해가 있으나, 가장 기본적인 견해는 한국어의 경우 띄어쓰기가 지켜지지 않아도 글을 쉽게 이해할 수 있는 언어라는 점입니다. 띄어쓰기가 없던 한국어에 띄어쓰기가 보편화된 것도 근대(1933년, 한글맞춤법통일안)의 일입니다. 띄어쓰기를 전혀 하지 않은 한국어와 영어 두 가지 경우를 봅시다. EX1) 제가 이렇게 띄어쓰기를 전혀 하지 않고 글을 썼다고 하더라도 글을 이해할 수 있습니다. EX2) Tobeornottobethatisthequestion 영어의 경우에는 띄어쓰기를 하지 않으면 손쉽게 알아보기 어려운 문장들이 생깁니다. 이는 한국어(모아쓰기 방식)와 영어(풀어쓰기 방식)라는 언어적 특성의 차이에 기인합니다. 이 책에서는 모아쓰기와 풀어쓰기에 대한 설명은 하지 않겠습니다. 다만, 결론적으로 한국어는 수많은 코퍼스에서 띄어쓰기가 무시되는 경우가 많아 자연어 처리가 어려워졌다는 것입니다. 6. 품사 태깅(Part-of-speech tagging) 단어는 표기는 같지만 품사에 따라서 단어의 의미가 달라지기도 합니다. 예를 들어서 영어 단어 'fly'는 동사로는 '날다'라는 의미를 갖지만, 명사로는 '파리'라는 의미를 갖고 있습니다. 한국어도 마찬가지입니다. '못'이라는 단어는 명사로서는 망치를 사용해서 목재 따위를 고정하는 물건을 의미합니다. 하지만 부사로서의 '못'은 '먹는다', '달린다'와 같은 동작 동사를 할 수 없다는 의미로 쓰입니다. 결국 단어의 의미를 제대로 파악하기 위해서는 해당 단어가 어떤 품사로 쓰였는지 보는 것이 주요 지표가 될 수도 있습니다. 그에 따라 단어 토큰화 과정에서 각 단어가 어떤 품사로 쓰였는지를 구분해놓기도 하는데, 이 작업을 품사 태깅(part-of-speech tagging)이라고 합니다. NLTK와 KoNLPy를 통해 품사 태깅 실습을 진행합니다. 7. NLTK와 KoNLPy를 이용한 영어, 한국어 토큰화 실습 NLTK에서는 Penn Treebank POS Tags라는 기준을 사용하여 품사를 태깅 합니다. from nltk.tokenize import word_tokenize from nltk.tag import pos_tag text = "I am actively looking for Ph.D. students. and you are a Ph.D. student." tokenized_sentence = word_tokenize(text) print('단어 토큰화 :',tokenized_sentence) print('품사 태깅 :',pos_tag(tokenized_sentence)) 단어 토큰화 : ['I', 'am', 'actively', 'looking', 'for', 'Ph.D.', 'students', '.', 'and', 'you', 'are', 'a', 'Ph.D.', 'student', '.'] 품사 태깅 : [('I', 'PRP'), ('am', 'VBP'), ('actively', 'RB'), ('looking', 'VBG'), ('for', 'IN'), ('Ph.D.', 'NNP'), ('students', 'NNS'), ('.', '.'), ('and', 'CC'), ('you', 'PRP'), ('are', 'VBP'), ('a', 'DT'), ('Ph.D.', 'NNP'), ('student', 'NN'), ('.', '.')] 영어 문장에 대해서 토큰화를 수행한 결과를 입력으로 품사 태깅을 수행하였습니다. Penn Treebank POG Tags에서 PRP는 인칭 대명사, VBP는 동사, RB는 부사, VBG는 현재 부사, IN은 전치사, NNP는 고유 명사, NNS는 복수형 명사, CC는 접속사, DT는 관사를 의미합니다. 한국어 자연어 처리를 위해서는 KoNLPy(코엔엘파이)라는 파이썬 패키지를 사용할 수 있습니다. 코엔엘파이를 통해서 사용할 수 있는 형태소 분석기로 Okt(Open Korea Text), 메캅(Mecab), 코모란(Komoran), 한 나눔(Hannanum), 꼬꼬마(Kkma)가 있습니다. 한국어 NLP에서 형태소 분석기를 사용하여 단어 토큰화. 더 정확히는 형태소 토큰화(morpheme tokenization)를 수행해 보겠습니다. 여기서는 Okt와 꼬꼬마 두 개의 형태소 분석기를 사용하여 토큰화를 수행하겠습니다. from konlpy.tag import Okt from konlpy.tag import Kkma okt = Okt() kkma = Kkma() print('OKT 형태소 분석 :',okt.morphs("열심히 코딩한 당신, 연휴에는 여행을 가봐요")) print('OKT 품사 태깅 :',okt.pos("열심히 코딩한 당신, 연휴에는 여행을 가봐요")) print('OKT 명사 추출 :',okt.nouns("열심히 코딩한 당신, 연휴에는 여행을 가봐요")) OKT 형태소 분석 : ['열심히', '코딩', '한', '당신', ',', '연휴', '에는', '여행', '을', '가봐요'] OKT 품사 태깅 : [('열심히', 'Adverb'), ('코딩', 'Noun'), ('한', 'Josa'), ('당신', 'Noun'), (',', 'Punctuation'), ('연휴', 'Noun'), ('에는', 'Josa'), ('여행', 'Noun'), ('을', 'Josa'), ('가봐요', 'Verb')] OKT 명사 추출 : ['코딩', '당신', '연휴', '여행'] 위의 예제는 Okt 형태소 분석기로 토큰화를 시도해 본 예제입니다. 각각의 메서드는 아래와 같은 기능을 갖고 있습니다. 1) morphs : 형태소 추출 2) pos : 품사 태깅(Part-of-speech tagging) 3) nouns : 명사 추출 앞서 언급한 코엔엘파이의 형태소 분석기들은 공통적으로 이 메서드들을 제공하고 있습니다. 위 예제에서 형태소 추출과 품사 태깅 메서드의 결과를 보면 조사를 기본적으로 분리하고 있음을 확인할 수 있습니다. 한국어 NLP에서 전처리에 형태소 분석기를 사용하는 것은 굉장히 유용합니다. 이번에는 꼬꼬마 형태소 분석기를 사용하여 같은 문장에 대해서 토큰화를 진행해 봅시다. print('꼬꼬마 형태소 분석 :',kkma.morphs("열심히 코딩한 당신, 연휴에는 여행을 가봐요")) print('꼬꼬마 품사 태깅 :',kkma.pos("열심히 코딩한 당신, 연휴에는 여행을 가봐요")) print('꼬꼬마 명사 추출 :',kkma.nouns("열심히 코딩한 당신, 연휴에는 여행을 가봐요")) 꼬꼬마 형태소 분석 : ['열심히', '코딩', '하', 'ㄴ', '당신', ',', '연휴', '에', '는', '여행', '을', '가보', '아요'] 꼬꼬마 품사 태깅 : [('열심히', 'MAG'), ('코딩', 'NNG'), ('하', 'XSV'), ('ㄴ', 'ETD'), ('당신', 'NP'), (',', 'SP'), ('연휴', 'NNG'), ('에', 'JKM'), ('는', 'JX'), ('여행', 'NNG'), ('을', 'JKO'), ('가보', 'VV'), ('아요', 'EFN')] 꼬꼬마 명사 추출 : ['코딩', '당신', '연휴', '여행'] 앞서 사용한 Okt 형태소 분석기와 결과가 다른 것을 볼 수 있습니다. 각 형태소 분석기는 성능과 결과가 다르게 나오기 때문에, 형태소 분석기의 선택은 사용하고자 하는 필요 용도에 어떤 형태소 분석기가 가장 적절한지를 판단하고 사용하면 됩니다. 예를 들어서 속도를 중시한다면 메캅을 사용할 수 있습니다. 02-02 정제(Cleaning) and 정규화(Normalization) 코퍼스에서 용도에 맞게 토큰을 분류하는 작업을 토큰화(tokenization)라고 하며, 토큰화 작업 전, 후에는 텍스트 데이터를 용도에 맞게 정제(cleaning) 및 정규화(normalization) 하는 일이 항상 함께합니다. 정제 및 정규화의 목적은 각각 다음과 같습니다. 정제(cleaning) : 갖고 있는 코퍼스로부터 노이즈 데이터를 제거한다. 정규화(normalization) : 표현 방법이 다른 단어들을 통합시켜서 같은 단어로 만들어준다. 정제 작업은 토큰화 작업에 방해가 되는 부분들을 배제시키고 토큰화 작업을 수행하기 위해서 토큰화 작업보다 앞서 이루어지기도 하지만, 토큰화 작업 이후에도 여전히 남아있는 노이즈들을 제거하기 위해 지속적으로 이루어지기도 합니다. 사실 완벽한 정제 작업은 어려운 편이라서, 대부분의 경우 이 정도면 됐다.라는 일종의 합의점을 찾기도 합니다. 1. 규칙에 기반한 표기가 다른 단어들의 통합 필요에 따라 직접 코딩을 통해 정의할 수 있는 정규화 규칙의 예로서 같은 의미를 갖고 있음에도, 표기가 다른 단어들을 하나의 단어로 정규화하는 방법을 사용할 수 있습니다. 가령, USA와 US는 같은 의미를 가지므로 하나의 단어로 정규화해볼 수 있습니다. uh-huh와 uhhuh는 형태는 다르지만 여전히 같은 의미를 갖고 있습니다. 이러한 정규화를 거치게 되면, US를 찾아도 USA도 함께 찾을 수 있을 것입니다. 뒤에서 표기가 다른 단어들을 통합하는 방법인 어간 추출(stemming)과 표제어 추출(lemmatizaiton)에 대해서 더 자세히 알아봅니다. 2. 대, 소문자 통합 영어권 언어에서 대, 소문자를 통합하는 것은 단어의 개수를 줄일 수 있는 또 다른 정규화 방법입니다. 영어권 언어에서 대문자는 문장의 맨 앞 등과 같은 특정 상황에서만 쓰이고, 대부분의 글은 소문자로 작성되기 때문에 대, 소문자 통합 작업은 대부분 대문자를 소문자로 변환하는 소문자 변환작업으로 이루어지게 됩니다. 소문자 변환이 왜 유용한지 예를 들어보도록 하겠습니다. 가령, Automobile이라는 단어가 문장의 첫 단어였기 때문에 A가 대문자였다고 생각해 봅시다. 여기에 소문자 변환을 사용하면, automobile을 찾는 질의(query)의 결과로서 Automobile도 찾을 수 있게 됩니다. 검색 엔진에서 사용자가 페라리 차량에 관심이 있어서 페라리를 검색해 본다고 합시다. 엄밀히 말해서 사실 사용자가 검색을 통해 찾고자 하는 결과는 a Ferrari car라고 봐야 합니다. 하지만 검색 엔진은 소문자 변환을 적용했을 것이기 때문에 ferrari만 쳐도 원하는 결과를 얻을 수 있을 것입니다. 물론 대문자와 소문자를 무작정 통합해서는 안 됩니다. 대문자와 소문자가 구분되어야 하는 경우도 있습니다. 가령 미국을 뜻하는 단어 US와 우리를 뜻하는 us는 구분되어야 합니다. 또 회사 이름(General Motors)나, 사람 이름(Bush) 등은 대문자로 유지되는 것이 옳습니다. 모든 토큰을 소문자로 만드는 것이 문제를 가져온다면, 또 다른 대안은 일부만 소문자로 변환시키는 방법도 있습니다. 가령, 이런 규칙은 어떨까요? 문장의 맨 앞에서 나오는 단어의 대문자만 소문자로 바꾸고, 다른 단어들은 전부 대문자인 상태로 놔두는 것입니다. 이러한 작업은 더 많은 변수를 사용해서 소문자 변환을 언제 사용할지 결정하는 머신 러닝 시퀀스 모델로 더 정확하게 진행시킬 수 있습니다. 하지만 만약 올바른 대문자 단어를 얻고 싶은 상황에서 훈련에 사용하는 코퍼스가 사용자들이 단어의 대문자, 소문자의 올바른 사용 방법과 상관없이 소문자를 사용하는 사람들로부터 나온 데이터라면 이러한 방법 또한 그다지 도움이 되지 않을 수 있습니다. 결국에는 예외 사항을 크게 고려하지 않고, 모든 코퍼스를 소문자로 바꾸는 것이 종종 더 실용적인 해결책이 되기도 합니다. 3. 불필요한 단어의 제거 정제 작업에서 제거해야 하는 노이즈 데이터(noise data)는 자연어가 아니면서 아무 의미도 갖지 않는 글자들(특수 문자 등)을 의미하기도 하지만, 분석하고자 하는 목적에 맞지 않는 불필요 단어들을 노이즈 데이터라고 하기도 합니다. 불필요 단어들을 제거하는 방법으로는 불용어 제거와 등장 빈도가 적은 단어, 길이가 짧은 단어들을 제거하는 방법이 있습니다. 불용어 제거는 불용어 챕터에서 더욱 자세히 다루기로 하고, 여기서는 등장 빈도가 적은 단어와 길이가 짧은 단어를 제거하는 경우에 대해서 간략히 설명하겠습니다. (1) 등장 빈도가 적은 단어 때로는 텍스트 데이터에서 너무 적게 등장해서 자연어 처리에 도움이 되지 않는 단어들이 존재합니다. 예를 들어 입력된 메일이 정상 메일인지 스팸 메일인지를 분류하는 스팸 메일 분류기를 설계한다고 가정해 보겠습니다. 총 100,000개의 메일을 가지고 정상 메일에서는 어떤 단어들이 주로 등장하고, 스팸 메일에서는 어떤 단어들이 주로 등장하는지를 가지고 설계하고자 합니다. 그런데 이때 100,000개의 메일 데이터에서 총합 5번 밖에 등장하지 않은 단어가 있다면 이 단어는 직관적으로 분류에 거의 도움이 되지 않을 것임을 알 수 있습니다. (2) 길이가 짧은 단어 영어권 언어에서는 길이가 짧은 단어를 삭제하는 것만으로도 어느 정도 자연어 처리에서 크게 의미가 없는 단어들을 제거하는 효과를 볼 수 있다고 알려져 있습니다. 즉, 영어권 언어에서 길이가 짧은 단어들은 대부분 불용어에 해당됩니다. 사실 길이가 짧은 단어를 제거하는 2차 이유는 길이를 조건으로 텍스트를 삭제하면서 단어가 아닌 구두점들까지도 한꺼번에 제거하기 위함도 있습니다. 하지만 한국어에서는 길이가 짧은 단어라고 삭제하는 이런 방법이 크게 유효하지 않을 수 있는데 그 이유에 대해서 정리해 보도록 하겠습니다. 단정적으로 말할 수는 없지만, 영어 단어의 평균 길이는 6~7 정도이며, 한국어 단어의 평균 길이는 2~3 정도로 추정되고 있습니다. 두 나라의 단어 평균 길이가 몇 인지에 대해서는 확실히 말하기 어렵지만 그럼에도 확실한 사실은 영어 단어의 길이가 한국어 단어의 길이보다는 평균적으로 길다는 점입니다. 이는 영어 단어와 한국어 단어에서 각 한 글자가 가진 의미의 크기가 다르다는 점에서 기인합니다. 한국어 단어는 한자어가 많고, 한 글자만으로도 이미 의미를 가진 경우가 많습니다. 예를 들어 '학교'라는 한국어 단어를 생각해 보면, 배울 학(學)과 학교 교(校)로 글자 하나, 하나가 이미 함축적인 의미를 갖고 있어 두 글자만으로 학교라는 단어를 표현합니다. 하지만 영어의 경우에는 학교라는 글자를 표현하기 위해서는 s, c, h, o, o, l이라는 총 6개의 글자가 필요합니다. 다른 예로는 전설 속 동물인 용()을 표현하기 위해서는 한국어로는 한 글자 면 충분하지만, 영어에서는 d, r, a, g, o, n이라는 총 6개의 글자가 필요합니다. 이러한 특성으로 인해 영어는 길이가 2~3 이하인 단어를 제거하는 것만으로도 크게 의미를 갖지 못하는 단어를 줄이는 효과를 갖고 있습니다. 예를 들어 갖고 있는 텍스트 데이터에서 길이가 1인 단어를 제거하는 코드를 수행하면 대부분의 자연어 처리에서 의미를 갖지 못하는 단어인 관사 'a'와 주어로 쓰이는 'I'가 제거됩니다. 마찬가지로 길이가 2인 단어를 제거한다고 하면 it, at, to, on, in, by 등과 같은 대부분 불용어에 해당되는 단어들이 제거됩니다. 필요에 따라서는 길이가 3인 단어도 제거할 수 있지만, 이 경우 fox, dog, car 등 길이가 3인 명사들이 제거되기 시작하므로 사용하고자 하는 데이터에서 해당 방법을 사용해도 되는지에 대한 고민이 필요합니다. import re text = "I was wondering if anyone out there could enlighten me on this car." # 길이가 1~2인 단어들을 정규 표현식을 이용하여 삭제 shortword = re.compile(r'\W*\b\w{1,2}\b') print(shortword.sub('', text)) was wondering anyone out there could enlighten this car. 4. 정규 표현식(Regular Expression) 얻어낸 코퍼스에서 노이즈 데이터의 특징을 잡아낼 수 있다면, 정규 표현식을 통해서 이를 제거할 수 있는 경우가 많습니다. 가령, HTML 문서로부터 가져온 코퍼스라면 문서 여기저기에 HTML 태그가 있습니다. 뉴스 기사를 크롤링 했다면, 기사마다 게재 시간이 적혀져 있을 수 있습니다. 정규 표현식은 이러한 코퍼스 내에 계속해서 등장하는 글자들을 규칙에 기반하여 한 번에 제거하는 방식으로서 매우 유용합니다. 이 책에서도 전처리를 위해 정규 표현식을 앞으로 종종 사용하게 될 겁니다. 예를 들어 위에서 길이가 짧은 단어를 제거할 때도, 정규 표현식이 유용하게 사용되었습니다. 정규 표현식에 대한 자세한 내용은 뒤에서 좀 더 상세하게 다룹니다. 02-03 어간 추출(Stemming) and 표제어 추출(Lemmatization) 정규화 기법 중 코퍼스에 있는 단어의 개수를 줄일 수 있는 기법인 표제어 추출(lemmatization)과 어간 추출(stemming)의 개념에 대해서 알아봅니다. 또한 이 둘의 결과가 어떻게 다른지 이해합니다. 이 두 작업이 갖고 있는 의미는 눈으로 봤을 때는 서로 다른 단어들이지만, 하나의 단어로 일반화시킬 수 있다면 하나의 단어로 일반화시켜서 문서 내의 단어 수를 줄이겠다는 것입니다. 이러한 방법들은 단어의 빈도수를 기반으로 문제를 풀고자 하는 뒤에서 학습하게 될 BoW(Bag of Words) 표현을 사용하는 자연어 처리 문제에서 주로 사용됩니다. 자연어 처리에서 전처리, 더 정확히는 정규화의 지향점은 언제나 갖고 있는 코퍼스로부터 복잡성을 줄이는 일입니다. 1. 표제어 추출(Lemmatization) 표제어(Lemma)는 한글로는 '표제어' 또는 '기본 사전형 단어' 정도의 의미를 갖습니다. 표제어 추출은 단어들로부터 표제어를 찾아가는 과정입니다. 표제어 추출은 단어들이 다른 형태를 가지더라도, 그 뿌리 단어를 찾아가서 단어의 개수를 줄일 수 있는지 판단합니다. 예를 들어서 am, are, is는 서로 다른 스펠링이지만 그 뿌리 단어는 be라고 볼 수 있습니다. 이때, 이 단어들의 표제어는 be라고 합니다. 표제어 추출을 하는 가장 섬세한 방법은 단어의 형태학적 파싱을 먼저 진행하는 것입니다. 형태소란 '의미를 가진 가장 작은 단위'를 뜻합니다. 그리고 형태학(morphology)이란 형태소로부터 단어들을 만들어가는 학문을 뜻합니다. 형태소의 종류로 어간(stem)과 접사(affix)가 존재합니다. 1) 어간(stem) : 단어의 의미를 담고 있는 단어의 핵심 부분. 2) 접사(affix) : 단어에 추가적인 의미를 주는 부분. 형태학적 파싱은 이 두 가지 구성 요소를 분리하는 작업을 말합니다. 가령, cats라는 단어에 대해 형태학적 파싱을 수행한다면, 형태학적 파싱은 결과로 cat(어간)와 -s(접사)를 분리합니다. 꼭 두 가지로 분리되지 않는 경우도 있습니다. 단어 fox는 형태학적 파싱을 한다고 하더라도 더 이상 분리할 수 없습니다. fox는 독립적인 형태소이기 때문입니다. 이와 유사하게 cat 또한 더 이상 분리되지 않습니다. NLTK에서는 표제어 추출을 위한 도구인 WordNetLemmatizer를 지원합니다. 이를 통해 표제어 추출을 실습해 보겠습니다. from nltk.stem import WordNetLemmatizer lemmatizer = WordNetLemmatizer() words = ['policy', 'doing', 'organization', 'have', 'going', 'love', 'lives', 'fly', 'dies', 'watched', 'has', 'starting'] print('표제어 추출 전 :',words) print('표제어 추출 후 :',[lemmatizer.lemmatize(word) for word in words]) 표제어 추출 전 : ['policy', 'doing', 'organization', 'have', 'going', 'love', 'lives', 'fly', 'dies', 'watched', 'has', 'starting'] 표제어 추출 후 : ['policy', 'doing', 'organization', 'have', 'going', 'love', 'life', 'fly', 'dy', 'watched', 'ha', 'starting'] 표제어 추출은 뒤에서 언급할 어간 추출과는 달리 단어의 형태가 적절히 보존되는 양상을 보이는 특징이 있습니다. 하지만 그럼에도 위의 결과에서는 dy나 ha와 같이 의미를 알 수 없는 적절하지 못한 단어를 출력하고 있습니다. 이는 표제어 추출기(lemmatizer)가 본래 단어의 품사 정보를 알아야만 정확한 결과를 얻을 수 있기 때문입니다. WordNetLemmatizer는 입력으로 단어가 동사 품사라는 사실을 알려줄 수 있습니다. 즉, dies와 watched, has가 문장에서 동사로 쓰였다는 것을 알려준다면 표제어 추출기는 품사의 정보를 보존하면서 정확한 Lemma를 출력하게 됩니다. lemmatizer.lemmatize('dies', 'v') 'die' lemmatizer.lemmatize('watched', 'v') 'watch' lemmatizer.lemmatize('has', 'v') 'have' 표제어 추출은 문맥을 고려하며 수행했을 때의 결과는 해당 단어의 품사 정보를 보존합니다. 하지만 어간 추출을 수행한 결과는 품사 정보가 보존되지 않습니다. 더 정확히는 어간 추출을 한 결과는 사전에 존재하지 않는 단어일 경우가 많습니다. 2. 어간 추출(Stemming) 어간(Stem)을 추출하는 작업을 어간 추출(stemming)이라고 합니다. 어간 추출은 형태학적 분석을 단순화한 버전이라고 볼 수도 있고, 정해진 규칙만 보고 단어의 어미를 자르는 어림짐작의 작업이라고 볼 수도 있습니다. 이 작업은 섬세한 작업이 아니기 때문에 어간 추출 후에 나오는 결과 단어는 사전에 존재하지 않는 단어일 수도 있습니다. 예제를 보면 쉽게 이해할 수 있습니다. 어간 추출 알고리즘 중 하나인 포터 알고리즘(Porter Algorithm)에 아래의 문자열을 입력으로 넣는다고 해봅시다. This was not the map we found in Billy Bones's chest, but an accurate copy, complete in all things--names and heights and soundings--with the single exception of the red crosses and the written notes. from nltk.stem import PorterStemmer from nltk.tokenize import word_tokenize stemmer = PorterStemmer() sentence = "This was not the map we found in Billy Bones's chest, but an accurate copy, complete in all things--names and heights and soundings--with the single exception of the red crosses and the written notes." tokenized_sentence = word_tokenize(sentence) print('어간 추출 전 :', tokenized_sentence) print('어간 추출 후 :',[stemmer.stem(word) for word in tokenized_sentence]) 어간 추출 전 : ['This', 'was', 'not', 'the', 'map', 'we', 'found', 'in', 'Billy', 'Bones', "'s", 'chest', ',', 'but', 'an', 'accurate', 'copy', ',', 'complete', 'in', 'all', 'things', '--', 'names', 'and', 'heights', 'and', 'soundings', '--', 'with', 'the', 'single', 'exception', 'of', 'the', 'red', 'crosses', 'and', 'the', 'written', 'notes', '.'] 어간 추출 후 : ['thi', 'wa', 'not', 'the', 'map', 'we', 'found', 'in', 'billi', 'bone', "'s", 'chest', ',', 'but', 'an', 'accur', 'copi', ',', 'complet', 'in', 'all', 'thing', '--', 'name', 'and', 'height', 'and', 'sound', '--', 'with', 'the', 'singl', 'except', 'of', 'the', 'red', 'cross', 'and', 'the', 'written', 'note', '.'] 규칙 기반의 접근을 하고 있으므로 어간 추출 후의 결과에는 사전에 없는 단어들도 포함되어 있습니다. 가령, 포터 알고리즘의 어간 추출은 이러한 규칙들을 가집니다. ALIZE → AL ANCE → 제거 ICAL → IC 위의 규칙에 따르면 좌측의 단어는 우측의 단어와 같은 결과를 얻게 됩니다. formalize → formal allowance → allow electricical → electric 실제 코드를 통해 확인해 봅시다. words = ['formalize', 'allowance', 'electricical'] print('어간 추출 전 :',words) print('어간 추출 후 :',[stemmer.stem(word) for word in words]) 어간 추출 전 : ['formalize', 'allowance', 'electricical'] 어간 추출 후 : ['formal', 'allow', 'electric'] ※ Porter 알고리즘의 상세 규칙은 마틴 포터의 홈페이지에서 확인할 수 있다. 어간 추출 속도는 표제어 추출보다 일반적으로 빠른데, 포터 어간 추출기는 정밀하게 설계되어 정확도가 높으므로 영어 자연어 처리에서 어간 추출을 하고자 한다면 가장 준수한 선택입니다. NLTK에서는 포터 알고리즘 외에도 랭커스터 스태머(Lancaster Stemmer) 알고리즘을 지원합니다. 이번에는 포터 알고리즘과 랭커스터 스태머 알고리즘으로 각각 어간 추출을 진행했을 때, 이 둘의 결과를 비교해 보겠습니다. from nltk.stem import PorterStemmer from nltk.stem import LancasterStemmer porter_stemmer = PorterStemmer() lancaster_stemmer = LancasterStemmer() words = ['policy', 'doing', 'organization', 'have', 'going', 'love', 'lives', 'fly', 'dies', 'watched', 'has', 'starting'] print('어간 추출 전 :', words) print('포터 스테머의 어간 추출 후:',[porter_stemmer.stem(w) for w in words]) print('랭커스터 스테머의 어간 추출 후:',[lancaster_stemmer.stem(w) for w in words]) 어간 추출 전 : ['policy', 'doing', 'organization', 'have', 'going', 'love', 'lives', 'fly', 'dies', 'watched', 'has', 'starting'] 포터 스테머의 어간 추출 후: ['polici', 'do', 'organ', 'have', 'go', 'love', 'live', 'fli', 'die', 'watch', 'ha', 'start'] 랭커스터 스테머의 어간 추출 후: ['policy', 'doing', 'org', 'hav', 'going', 'lov', 'liv', 'fly', 'die', 'watch', 'has', 'start'] 동일한 단어들의 나열에 대해서 두 스태머는 전혀 다른 결과를 보여줍니다. 두 스태머 알고리즘은 서로 다른 알고리즘을 사용하기 때문입니다. 그렇기 때문에 이미 알려진 알고리즘을 사용할 때는, 사용하고자 하는 코퍼스에 스태머를 적용해 보고 어떤 스태머가 해당 코퍼스에 적합한지를 판단한 후에 사용하여야 합니다. 이런 규칙에 기반한 알고리즘은 종종 제대로 된 일반화를 수행하지 못할 수 있습니다. 어간 추출을 하고 나서 일반화가 지나치게 되거나, 또는 덜 되거나 하는 경우입니다. 예를 들어 포터 알고리즘에서 organization을 어간 추출했을 때의 결과를 봅시다. organization → organ organization과 organ은 완전히 다른 단어임에도 organization에 대해서 어간 추출을 했더니 organ이라는 단어가 나왔습니다. organ에 대해서 어간 추출을 한다고 하더라도 결과는 역시 organ이 되기 때문에, 두 단어에 대해서 어간 추출을 한다면 동일한 어간을 갖게 됩니다. 이는 의미가 동일한 경우에만 같은 단어를 얻기를 원하는 정규화의 목적에는 맞지 않습니다. 마지막으로 동일한 단어에 대해서 표제어 추출과 어간 추출을 각각 수행했을 때, 결과에서 어떤 차이가 있는지 간단한 예를 보겠습니다. Stemming am → am the going → the go having → hav Lemmatization am → be the going → the going having → have 3. 한국어에서의 어간 추출 한국어의 어간에 대해서 간략히 설명합니다. 한국어는 아래의 표와 같이 5 언 9품사의 구조를 가지고 있습니다. 언 품사 체언 명사, 대명사, 수사 수식언 관형사, 부사 관계 언 조사 독립언 감탄사 용언 동사, 형용사 이 중 용언에 해당되는 '동사'와 '형용사'는 어간(stem)과 어미(ending)의 결합으로 구성됩니다. 앞으로 용언이라고 언급하는 부분은 전부 동사와 형용사를 포함하여 언급하는 개념입니다. (1) 활용(conjugation) 활용(conjugation)은 한국어에서만 가지는 특징이 아니라, 인도유럽어(indo-european language)에서도 주로 볼 수 있는 언어적 특징 중 하나를 말하는 통칭적인 개념입니다. 다만, 여기서는 한국어에 한정하여 설명합니다. 활용이란 용언의 어간(stem)이 어미(ending)를 가지는 일을 말합니다. 어간(stem) : 용언(동사, 형용사)을 활용할 때, 원칙적으로 모양이 변하지 않는 부분. 활용에서 어미에 선행하는 부분. 때론 어간의 모양도 바뀔 수 있음(예: 긋다, 긋고, 그어서, 그어라). 어미(ending): 용언의 어간 뒤에 붙어서 활용하면서 변하는 부분이며, 여러 문법적 기능을 수행 활용은 어간이 어미를 취할 때, 어간의 모습이 일정하다면 규칙 활용, 어간이나 어미의 모습이 변하는 불규칙 활용으로 나뉩니다. (2) 규칙 활용 규칙 활용은 어간이 어미를 취할 때, 어간의 모습이 일정합니다. 아래의 예제는 어간과 어미가 합쳐질 때, 어간의 형태가 바뀌지 않음을 보여줍니다. 잡/어간 + 다/어미 이 경우에는 어간이 어미가 붙기 전의 모습과 어미가 붙은 후의 모습이 같으므로, 규칙 기반으로 어미를 단순히 분리해 주면 어간 추출이 됩니다. (3) 불규칙 활용 불규칙 활용은 어간이 어미를 취할 때 어간의 모습이 바뀌거나 취하는 어미가 특수한 어미일 경우를 말합니다. 예를 들어 ‘듣-, 돕-, 곱-, 잇-, 오르-, 노랗-’ 등이 ‘듣/들-, 돕/도우-, 곱/고우-, 잇/이-, 올/올-, 노랗/노라-’와 같이 어간의<NAME>이 달라지는 일이 있거나 ‘오르+ 아/어→올라, 하+아/어→하여, 이르+아/어→이르러, 푸르+아/어→푸르러’와 같이 일반적인 어미가 아닌 특수한 어미를 취하는 경우 불규칙활용을 하는 예에 속합니다. 이 경우에는 어간이 어미가 붙는 과정에서 어간의 모습이 바뀌었으므로 단순한 분리만으로 어간 추출이 되지 않고 좀 더 복잡한 규칙을 필요로 합니다. 아래의 링크는 다양한 불규칙 활용의 예를 보여줍니다. 링크 : https://namu.wiki/w/한국어/불규칙%20활용 02-04 불용어(Stopword) 갖고 있는 데이터에서 유의미한 단어 토큰만을 선별하기 위해서는 큰 의미가 없는 단어 토큰을 제거하는 작업이 필요합니다. 여기서 큰 의미가 없다는 것은 자주 등장하지만 분석을 하는 것에 있어서는 큰 도움이 되지 않는 단어들을 말합니다. 예를 들면, I, my, me, over, 조사, 접미사 같은 단어들은 문장에서는 자주 등장하지만 실제 의미 분석을 하는 데는 거의 기여하는 바가 없는 경우가 있습니다. 이러한 단어들을 불용어(stopword)라고 하며, NLTK에서는 위와 같은 100여 개 이상의 영어 단어들을 불용어로 패키지 내에서 미리 정의하고 있습니다. 물론 불용어는 개발자가 직접 정의할 수도 있습니다. 이번에는 영어 문장에서 NLTK가 정의한 영어 불용어를 제거하는 실습을 하고, 한국어 문장에서 직접 정의한 불용어를 제거해 보겠습니다. NLTK 실습에서는 1챕터에서 언급했듯이 NLTK Data가 필요합니다. 만약, 데이터가 없다는 에러가 발생 시에는 nltk.download(필요한 데이터)라는 커맨드를 통해 다운로드할 수 있습니다. from nltk.corpus import stopwords from nltk.tokenize import word_tokenize from konlpy.tag import Okt 1. NLTK에서 불용어 확인하기 stop_words_list = stopwords.words('english') print('불용어 개수 :', len(stop_words_list)) print('불용어 10개 출력 :',stop_words_list[:10]) 불용어 개수 : 179 불용어 10개 출력 : ['i', 'me', 'my', 'myself', 'we', 'our', 'ours', 'ourselves', 'you', "you're"] stopwords.words("english")는 NLTK가 정의한 영어 불용어 리스트를 리턴합니다. 출력 결과가 100개 이상이기 때문에 여기서는 간단히 10개만 확인해 보았습니다. 'i', 'me', 'my'와 같은 단어들을 NLTK에서 불용어로 정의하고 있음을 확인할 수 있습니다. 2. NLTK를 통해서 불용어 제거하기 example = "Family is not an important thing. It's everything." stop_words = set(stopwords.words('english')) word_tokens = word_tokenize(example) result = [] for word in word_tokens: if word not in stop_words: result.append(word) print('불용어 제거 전 :',word_tokens) print('불용어 제거 후 :',result) 불용어 제거 전 : ['Family', 'is', 'not', 'an', 'important', 'thing', '.', 'It', "'s", 'everything', '.'] 불용어 제거 후 : ['Family', 'important', 'thing', '.', 'It', "'s", 'everything', '.'] 위 코드는 "Family is not an important thing. It's everything."라는 임의의 문장을 정의하고, NLTK의 word_tokenize를 통해서 단어 토큰화를 수행합니다. 그리고 단어 토큰화 결과로부터 NLTK가 정의하고 있는 불용어를 제외한 결과를 출력하고 있습니다. 결과적으로 'is', 'not', 'an'과 같은 단어들이 문장에서 제거되었음을 볼 수 있습니다. 3. 한국어에서 불용어 제거하기 한국어에서 불용어를 제거하는 방법으로는 간단하게는 토큰화 후에 조사, 접속사 등을 제거하는 방법이 있습니다. 하지만 불용어를 제거하려고 하다 보면 조사나 접속사와 같은 단어들뿐만 아니라 명사, 형용사와 같은 단어들 중에서 불용어로서 제거하고 싶은 단어들이 생기기도 합니다. 결국에는 사용자가 직접 불용어 사전을 만들게 되는 경우가 많습니다. 이번에는 직접 불용어를 정의해 보고, 주어진 문장으로부터 사용자가 정의한 불용어 사전으로부터 불용어를 제거해 보겠습니다. 아래의 불용어는 임의 선정한 것으로 실제 의미 있는 선정 기준이 아닙니다. okt = Okt() example = "고기를 아무렇게나 구우려고 하면 안 돼. 고기라고 다 같은 게 아니거든. 예컨대 삼겹살을 구울 때는 중요한 게 있지." stop_words = "를 아무렇게나 구 우려 고 안 돼 같은 게 구울 때는" stop_words = set(stop_words.split(' ')) word_tokens = okt.morphs(example) result = [word for word in word_tokens if not word in stop_words] print('불용어 제거 전 :',word_tokens) print('불용어 제거 후 :',result) 불용어 제거 전 : ['고기', '를', '아무렇게나', '구', '우려', '고', '하면', '안', '돼', '.', '고기', '라고', '다', '같은', '게', '아니거든', '.', '예컨대', '삼겹살', '을', '구울', '때', '는', '중요한', '게', '있지', '.'] 불용어 제거 후 : ['고기', '하면', '.', '고기', '라고', '다', '아니거든', '.', '예컨대', '삼겹살', '을', '중요한', '있지', '.'] 아래의 링크는 보편적으로 선택할 수 있는 한국어 불용어 리스트를 보여줍니다. 하지만 여전히 절대적인 기준은 아닙니다. 링크 : https://www.ranks.nl/stopwords/korean 불용어가 많은 경우에는 코드 내에서 직접 정의하지 않고 txt 파일이나 csv 파일로 정리해놓고 이를 불러와서 사용하기도 합니다. 02-05 정규 표현식(Regular Expression) 텍스트 전처리에서 정규 표현식은 아주 유용한 도구입니다. 이번에는 파이썬에서 지원하고 있는 정규 표현식 모듈 re의 사용 방법과 NLTK를 통한 정규 표현식을 이용한 토큰화에 대해서 알아봅니다. 1. 정규 표현식 문법과 모듈 함수 파이썬에서는 정규 표현식 모듈 re을 지원하므로, 이를 이용하면 특정 규칙이 있는 텍스트 데이터를 빠르게 정제할 수 있습니다. 정규 표현식을 위해 사용되는 특수 문자와 모듈 함수에 대해서 표를 통해 정리해 보겠습니다. 표만으로는 이해하기 어렵습니다. 표 아래의 실습과 표를 병행하여 이해하시는 것이 좋습니다. 1) 정규 표현식 문법 정규 표현식을 위해 사용되는 문법 중 특수 문자들은 아래와 같습니다. 특수 문자 설명 . 한 개의 임의의 문자를 나타냅니다. (줄바꿈 문자인 \n는 제외) ? 앞의 문자가 존재할 수도 있고, 존재하지 않을 수도 있습니다. (문자가 0개 또는 1개) * 앞의 문자가 무한개로 존재할 수도 있고, 존재하지 않을 수도 있습니다. (문자가 0개 이상) + 앞의 문자가 최소 한 개 이상 존재합니다. (문자가 1개 이상) ^ 뒤의 문자열로 문자열이 시작됩니다. $ 앞의 문자열로 문자열이 끝납니다. {숫자} 숫자만큼 반복합니다. {숫자 1, 숫자 2} 숫자 1 이상 숫자 2 이하만큼 반복합니다. ?, *, +를 이것으로 대체할 수 있습니다. {숫자,} 숫자 이상만큼 반복합니다. [ ] 대괄호 안의 문자들 중 한 개의 문자와 매치합니다. [amk]라고 한다면 a 또는 m 또는 k 중 하나라도 존재하면 매치를 의미합니다. [a-z]와 같이 범위를 지정할 수도 있습니다. [a-zA-Z]는 알파벳 전체를 의미하는 범위이며, 문자열에 알파벳이 존재하면 매치를 의미합니다. [^문자] 해당 문자를 제외한 문자를 매치합니다. l AlB와 같이 쓰이며 A 또는 B의 의미를 가집니다. 정규 표현식 문법에는 역 슬래쉬(\)를 이용하여 자주 쓰이는 문자 규칙들이 있습니다. 문자 규칙 설명 \\\ 역 슬래쉬 문자 자체를 의미합니다 \\d 모든 숫자를 의미합니다. [0-9]와 의미가 동일합니다. \\D 숫자를 제외한 모든 문자를 의미합니다. [^0-9]와 의미가 동일합니다. \\s 공백을 의미합니다. [ \t\n\r\f\v]와 의미가 동일합니다. \\S 공백을 제외한 문자를 의미합니다. [^ \t\n\r\f\v]와 의미가 동일합니다. \\w 문자 또는 숫자를 의미합니다. [a-zA-Z0-9]와 의미가 동일합니다. \\W 문자 또는 숫자가 아닌 문자를 의미합니다. [^a-zA-Z0-9]와 의미가 동일합니다. 2) 정규 표현식 모듈 함수 정규 표현식 모듈에서 지원하는 함수는 이와 같습니다. 모듈 함수 설명 re.compile() 정규 표현식을 컴파일하는 함수입니다. 다시 말해, 파이썬에게 전해주는 역할을 합니다. 찾고자 하는 패턴이 빈번한 경우에는 미리 컴파일해놓고 사용하면 속도와 편 의성면에서 유리합니다. re.search() 문자열 전체에 대해서 정규 표현식과 매치되는지를 검색합니다. re.match() 문자열의 처음이 정규 표현식과 매치되는지를 검색합니다. re.split() 정규 표현식을 기준으로 문자열을 분리하여 리스트로 리턴합니다. re.findall() 문자열에서 정규 표현식과 매치되는 모든 경우의 문자열을 찾아서 리스트로 리턴합니다. 만약, 매치되는 문자열이 없다면 빈 리스트가 리턴됩니다. re.finditer() 문자열에서 정규 표현식과 매치되는 모든 경우의 문자열에 대한 이터 레이터 객체를 리턴합니다. re.sub() 문자열에서 정규 표현식과 일치하는 부분에 대해서 다른 문자열로 대체합니다. 앞으로 진행될 실습에서는 re.compile()에 정규 표현식을 컴파일하고, re.search()를 통해서 해당 정규 표현식이 입력 텍스트와 매치되는지를 확인하면서 각 정규 표현식에 대해서 이해해 보겠습니다. re.search()는 매치된다면 Match Object를 리턴하고 매치되지 않으면 아무런 값도 출력되지 않습니다. 2. 정규 표현식 실습 앞서 표로 봤던 정규 표현식을 예시를 통해 이해해 보겠습니다. import re 1) . 기호 .은 한 개의 임의의 문자를 나타냅니다. 예를 들어서 정규 표현식이 a.c라고 합시다. a와 c 사이에는 어떤 1개의 문자라도 올 수 있습니다. akc, azc, avc, a5c, a! c와 같은 형태는 모두 a.c의 정규 표현식과 매치됩니다. r = re.compile("a.c") r.search("kkk") # 아무런 결과도 출력되지 않는다. r.search("abc") <_sre.SRE_Match object; span=(0, 3), match='abc'> .은 어떤 문자로도 인식될 수 있기 때문에 abc라는 문자열은 a.c라는 정규 표현식 패턴으로 매치됩니다. 2) ?기호 ?는? 앞의 문자가 존재할 수도 있고 존재하지 않을 수도 있는 경우를 나타냅니다. 예를 들어서 정규 표현식이 ab? c라고 합시다. 이 경우 이 정규 표현식에서의 b는 있다고 취급할 수도 있고, 없다고 취급할 수도 있습니다. 즉, abc와 ac 모두 매치할 수 있습니다. r = re.compile("ab?c") r.search("abbc") # 아무런 결과도 출력되지 않는다. r.search("abc") <_sre.SRE_Match object; span=(0, 3), match='abc'> b가 있는 것으로 판단하여 abc를 매치했습니다. r.search("ac") <_sre.SRE_Match object; span=(0, 2), match='ac'> b가 없는 것으로 판단하여 ac를 매치했습니다. 3) *기호 *은 바로 앞의 문자가 0개 이상일 경우를 나타냅니다. 앞의 문자는 존재하지 않을 수도 있으며, 또는 여러 개일 수도 있습니다. 정규 표현식이 ab*c라면 ac, abc, abbc, abbbc 등과 매치할 수 있으며 b의 개수는 무수히 많을 수 있습니다. r = re.compile("ab*c") r.search("a") # 아무런 결과도 출력되지 않는다. r.search("ac") <_sre.SRE_Match object; span=(0, 2), match='ac'> r.search("abc") <_sre.SRE_Match object; span=(0, 3), match='abc'> r.search("abbbbc") <_sre.SRE_Match object; span=(0, 6), match='abbbbc'> 4) +기호 +는 *와 유사합니다. 다른 점은 앞의 문자가 최소 1개 이상이어야 합니다. 정규 표현식이 ab+c라고 한다면 ac는 매치되지 않습니다. 하지만 abc, abbc, abbbc 등과 매치할 수 있으며 b의 개수는 무수히 많을 수 있습니다. r = re.compile("ab+c") r.search("ac") # 아무런 결과도 출력되지 않는다. r.search("abc") <_sre.SRE_Match object; span=(0, 3), match='abc'> r.search("abbbbc") <_sre.SRE_Match object; span=(0, 6), match='abbbbc'> 5) ^기호 ^는 시작되는 문자열을 지정합니다. 정규 표현식이 ^ab라면 문자열 ab로 시작되는 경우 매치합니다. r = re.compile("^ab") # 아무런 결과도 출력되지 않는다. r.search("bbc") r.search("zab") r.search("abz") <re.Match object; span=(0, 2), match='ab'> 6) {숫자} 기호 문자에 해당 기호를 붙이면, 해당 문자를 숫자만큼 반복한 것을 나타냅니다. 예를 들어서 정규 표현식이 ab{2}c라면 a와 c 사이에 b가 존재하면서 b가 2개인 문자열에 대해서 매치합니다. r = re.compile("ab{2}c") # 아무런 결과도 출력되지 않는다. r.search("ac") r.search("abc") r.search("abbbbbc") r.search("abbc") <_sre.SRE_Match object; span=(0, 4), match='abbc'> 7) {숫자 1, 숫자 2} 기호 문자에 해당 기호를 붙이면, 해당 문자를 숫자 1 이상 숫자 2 이하만큼 반복합니다. 예를 들어서 정규 표현식이 ab{2,8}c라면 a와 c 사이에 b가 존재하면서 b는 2개 이상 8개 이하인 문자열에 대해서 매치합니다. r = re.compile("ab{2,8}c") # 아무런 결과도 출력되지 않는다. r.search("ac") r.search("abc") r.search("abbbbbbbbbc") r.search("abbc") <_sre.SRE_Match object; span=(0, 4), match='abbc'> r.search("abbbbbbbbc") <_sre.SRE_Match object; span=(0, 10), match='abbbbbbbbc'> 8) {숫자,} 기호 문자에 해당 기호를 붙이면 해당 문자를 숫자 이상만큼 반복합니다. 예를 들어서 정규 표현식이 a{2, }bc라면 뒤에 bc가 붙으면서 a의 개수가 2개 이상인 경우인 문자열과 매치합니다. 또한 만약 {0, }을 쓴다면 *와 동일한 의미가 되며, {1, }을 쓴다면 +와 동일한 의미가 됩니다. r = re.compile("a{2, }bc") # 아무런 결과도 출력되지 않는다. r.search("bc") r.search("aa") r.search("aabc") <_sre.SRE_Match object; span=(0, 4), match='aabc'> r.search("aaaaaaaabc") <_sre.SRE_Match object; span=(0, 10), match='aaaaaaaabc'> 9) [ ] 기호 [ ] 안에 문자들을 넣으면 그 문자들 중 한 개의 문자와 매치라는 의미를 가집니다. 예를 들어서 정규 표현식이 [abc] 라면, a 또는 b 또는 c가 들어가 있는 문자열과 매치됩니다. 범위를 지정하는 것도 가능합니다. [a-zA-Z]는 알파벳 전부를 의미하며, [0-9]는 숫자 전부를 의미합니다. r = re.compile("[abc]") # [abc]는 [a-c]와 같다. r.search("zzz") # 아무런 결과도 출력되지 않는다. r.search("a") <_sre.SRE_Match object; span=(0, 1), match='a'> r.search("aaaaaaa") <_sre.SRE_Match object; span=(0, 1), match='a'> r.search("baac") <_sre.SRE_Match object; span=(0, 1), match='b'> 이번에는 알파벳 소문자에 대해서 범위 지정하여 정규 표현식을 만들어보고 문자열과 매치해 보겠습니다. r = re.compile("[a-z]") # 아무런 결과도 출력되지 않는다. r.search("AAA") r.search("111") r.search("aBC") <_sre.SRE_Match object; span=(0, 1), match='a'> 10) [^문자] 기호 [^문자]는 ^기호 뒤에 붙은 문자들을 제외한 모든 문자를 매치하는 역할을 합니다. 예를 들어서 [^abc]라는 정규 표현식이 있다면, a 또는 b 또는 c가 들어간 문자열을 제외한 모든 문자열을 매치합니다. r = re.compile("[^abc]") # 아무런 결과도 출력되지 않는다. r.search("a") r.search("ab") r.search("b") r.search("d") <_sre.SRE_Match object; span=(0, 1), match='d'> r.search("1") <_sre.SRE_Match object; span=(0, 1), match='1'> 3. 정규 표현식 모듈 함수 예제 앞서 re.compile()과 re.search()를 사용해 보았습니다. 다른 정규 표현식 모듈 함수에 대해서 실습을 진행해 보겠습니다. (1) re.match() 와 re.search()의 차이 search()가 정규 표현식 전체에 대해서 문자열이 매치하는지를 본다면, match()는 문자열의 첫 부분부터 정규 표현식과 매치하는지를 확인합니다. 문자열 중간에 찾을 패턴이 있더라도 match 함수는 문자열의 시작에서 패턴이 일치하지 않으면 찾지 않습니다. r = re.compile("ab.") r.match("kkkabc") # 아무런 결과도 출력되지 않는다. r.search("kkkabc") <_sre.SRE_Match object; span=(3, 6), match='abc'> r.match("abckkk") <_sre.SRE_Match object; span=(0, 3), match='abc'> 위 경우 정규 표현식이 ab. 이기 때문에, ab 다음에는 어떤 한 글자가 존재할 수 있다는 패턴을 의미합니다. search 모듈 함수에 kkkabc라는 문자열을 넣어 매치되는지 확인한다면 abc라는 문자열에서 매치되어 Match object를 리턴합니다. 하지만 match 모듈 함수의 경우 앞 부분이 ab. 와 매치되지 않기 때문에, 아무런 결과도 출력되지 않습니다. 하지만 반대로 abckkk로 매치를 시도해 보면, 시작 부분에서 패턴과 매치되었기 때문에 정상적으로 Match object를 리턴합니다. (2) re.split() split() 함수는 입력된 정규 표현식을 기준으로 문자열들을 분리하여 리스트로 리턴합니다. 토큰화에 유용하게 쓰일 수 있습니다. 공백을 기준으로 문자열 분리를 수행하고 결과로서 리스트를 리턴해봅시다. # 공백 기준 분리 text = "사과 딸기 수박 멜론 바나나" re.split(" ", text) ['사과', '딸기', '수박', '멜론', '바나나'] 이와 유사하게 줄바꿈이나 다른 정규 표현식을 기준으로 텍스트를 분리할 수도 있습니다. # 줄바꿈 기준 분리 text = """사과 딸기 수박 멜론 바나나""" re.split("\n", text) ['사과', '딸기', '수박', '멜론', '바나나'] # '+'를 기준으로 분리 text = "사과+딸기+수박+멜론+바나나" re.split("\+", text) ['사과', '딸기', '수박', '멜론', '바나나'] (3) re.findall() findall() 함수는 정규 표현식과 매치되는 모든 문자열들을 리스트로 리턴합니다. 단, 매치되는 문자열이 없다면 빈 리스트를 리턴합니다. 임의의 텍스트에 정규 표현식으로 숫자를 의미하는 규칙으로 findall()을 수행하면 전체 텍스트로부터 숫자만 찾아내서 리스트로 리턴합니다. text = """이름 : 김철수 전화번호 : 010 - 1234 - 1234 나이 : 30 성별 : 남""" re.findall("\d+", text) ['010', '1234', '1234', '30'] 하지만 만약 입력 텍스트에 숫자가 없다면 빈 리스트를 리턴하게 됩니다. re.findall("\d+", "문자열입니다.") [] (4) re.sub() sub() 함수는 정규 표현식 패턴과 일치하는 문자열을 찾아 다른 문자열로 대체할 수 있습니다. 아래와 같은 정제 작업에 많이 사용되는데, 영어 문장에 각주 등과 같은 이유로 특수 문자가 섞여있는 경우에 특수 문자를 제거하고 싶다면 알파벳 외의 문자는 공백으로 처리하는 등의 용도로 쓸 수 있습니다. text = "Regular expression : A regular expression, regex or regexp[1] (sometimes called a rational expression)[2][3] is, in theoretical computer science and formal language theory, a sequence of characters that define a search pattern." preprocessed_text = re.sub('[^a-zA-Z]', ' ', text) print(preprocessed_text) 'Regular expression A regular expression regex or regexp sometimes called a rational expression is in theoretical computer science and formal language theory a sequence of characters that define a search pattern ' 4. 정규 표현식 텍스트 전처리 예제 다음과 같은 임의의 텍스트가 있다고 해봅시다. 테이블<NAME>의 데이터를 텍스트에 저장하였습니다. text = """100 John PROF 101 James STUD 102 Mac STUD""" \s+는 공백을 찾아내는 정규 표현식입니다. 뒤에 붙는 +는 최소 1개 이상의 패턴을 찾아낸다는 의미입니다. s는 공백을 의미하기 때문에 최소 1개 이상의 공백인 패턴을 찾아냅니다. split은 주어진 정규 표현식을 기준으로 분리하므로 결과는 아래와 같습니다. re.split('\s+', text) ['100', 'John', 'PROF', '101', 'James', 'STUD', '102', 'Mac', 'STUD'] 공백을 기준으로 값이 구분되었습니다. 해당 입력으로부터 숫자만을 뽑아온다고 해봅시다. 여기서 \d는 숫자에 해당되는 정규 표현식입니다. +를 붙이면 최소 1개 이상의 숫자에 해당하는 값을 의미합니다. findall()은 해당 표현식에 일치하는 값을 찾아냅니다. re.findall('\d+',text) ['100', '101', '102] 이번에는 텍스트로부터 대문자인 행의 값만 가져와봅시다. 이 경우 정규 표현식에 대문자를 기준으로 매치시키면 됩니다. 하지만 정규 표현식에 대문자라는 기준만을 넣을 경우에는 문자열을 가져오는 것이 아니라 모든 대문자 각각을 갖고 오게 됩니다. re.findall('[A-Z]',text) ['J', 'P', 'R', 'O', 'F', 'J', 'S', 'T', 'U', 'D', 'M', 'S', 'T', 'U', 'D'] 대문자가 연속적으로 네 번 등장하는 경우라는 조건을 추가해 봅시다. re.findall('[A-Z]{4}',text) ['PROF', 'STUD', 'STUD'] 대문자로 구성된 문자열들을 가져옵니다. 이름의 경우에는 대문자와 소문자가 섞여있는 상황입니다. 이름에 대한 행의 값을 갖고 오고 싶다면 처음에 대문자가 등장한 후에 소문자가 여러 번 등장하는 경우에 매치하게 합니다. re.findall('[A-Z][a-z]+',text) ['John', 'James', 'Mac'] 5. 정규 표현식을 이용한 토큰화 NLTK에서는 정규 표현식을 사용해서 단어 토큰화를 수행하는 RegexpTokenizer를 지원합니다. RegexpTokenizer()에서 괄호 안에 하나의 토큰으로 규정하기를 원하는 정규 표현식을 넣어서 토큰화를 수행합니다. tokenizer1에 사용한 \w+는 문자 또는 숫자가 1개 이상인 경우를 의미합니다. tokenizer2에서는 공백을 기준으로 토큰화하도록 했습니다. gaps=true는 해당 정규 표현식을 토큰으로 나누기 위한 기준으로 사용한다는 의미입니다. 만약 gaps=True라는 부분을 기재하지 않는다면, 토큰화의 결과는 공백들만 나오게 됩니다. tokenizer2의 결과는 위의 tokenizer1의 결과와는 달리 아포스트로피나 온점을 제외하지 않고 토큰 화가 수행된 것을 확인할 수 있습니다. from nltk.tokenize import RegexpTokenizer text = "Don't be fooled by the dark sounding name, Mr. Jone's Orphanage is as cheery as cheery goes for a pastry shop" tokenizer1 = RegexpTokenizer("[\w]+") tokenizer2 = RegexpTokenizer("\s+", gaps=True) print(tokenizer1.tokenize(text)) print(tokenizer2.tokenize(text)) ['Don', 't', 'be', 'fooled', 'by', 'the', 'dark', 'sounding', 'name', 'Mr', 'Jone', 's', 'Orphanage', 'is', 'as', 'cheery', 'as', 'cheery', 'goes', 'for', 'a', 'pastry', 'shop'] ["Don't", 'be', 'fooled', 'by', 'the', 'dark', 'sounding', 'name,', 'Mr.', "Jone's", 'Orphanage', 'is', 'as', 'cheery', 'as', 'cheery', 'goes', 'for', 'a', 'pastry', 'shop'] 02-06 정수 인코딩(Integer Encoding) 컴퓨터는 텍스트보다는 숫자를 더 잘 처리할 수 있습니다. 이를 위해 자연어 처리에서는 텍스트를 숫자로 바꾸는 여러 가지 기법들이 있습니다. 그리고 그러한 기법들을 본격적으로 적용시키기 위한 첫 단계로 각 단어를 고유한 정수에 매핑(mapping) 시키는 전처리 작업이 필요할 때가 있습니다. 예를 들어 갖고 있는 텍스트에 단어가 5,000개가 있다면, 5,000개의 단어들 각각에 1번부터 5,000번까지 단어와 매핑되는 고유한 정수. 다른 표현으로는 인덱스를 부여합니다. 가령, book은 150번, dog는 171번, love는 192번, books는 212번과 같이 숫자가 부여됩니다. 인덱스를 부여하는 방법은 여러 가지가 있을 수 있는데 랜덤으로 부여하기도 하지만, 보통은 단어 등장 빈도수를 기준으로 정렬한 뒤에 부여합니다. 1. 정수 인코딩(Integer Encoding) 왜 이러한 작업이 필요한 지에 대해서는 뒤에서 원-핫 인코딩 실습이나, 워드 임베딩 챕터 등에서 알아보기로 하고 여기서는 어떤 과정으로 단어에 정수 인덱스를 부여하는지에 대해서만 정리하겠습니다. 단어에 정수를 부여하는 방법 중 하나로 단어를 빈도수 순으로 정렬한 단어 집합(vocabulary)을 만들고, 빈도수가 높은 순서대로 차례로 낮은 숫자부터 정수를 부여하는 방법이 있습니다. 이해를 돕기 위해 단어의 빈도수가 적당하게 분포되도록 의도적으로 만든 텍스트 데이터를 가지고 실습해 보겠습니다. 1) dictionary 사용하기 from nltk.tokenize import sent_tokenize from nltk.tokenize import word_tokenize from nltk.corpus import stopwords raw_text = "A barber is a person. a barber is good person. a barber is huge person. he Knew A Secret! The Secret He Kept is huge secret. Huge secret. His barber kept his word. a barber kept his word. His barber kept his secret. But keeping and keeping such a huge secret to himself was driving the barber crazy. the barber went up a huge mountain." 우선 여러 문장이 함께 있는 텍스트 데이터로부터 문장 토큰화를 수행해 보겠습니다. # 문장 토큰화 sentences = sent_tokenize(raw_text) print(sentences) ['A barber is a person.', 'a barber is good person.', 'a barber is huge person.', 'he Knew A Secret!', 'The Secret He Kept is huge secret.', 'Huge secret.', 'His barber kept his word.', 'a barber kept his word.', 'His barber kept his secret.', 'But keeping and keeping such a huge secret to himself was driving the barber crazy.', 'the barber went up a huge mountain.'] 기존의 텍스트 데이터가 문장 단위로 토큰화된 것을 확인할 수 있습니다. 이제 정제 작업과 정규화 작업을 병행하며, 단어 토큰화를 수행합니다. 여기서는 단어들을 소문자화하여 단어의 개수를 통일시키고, 불용어와 단어 길이가 2이하인 경우에 대해서 단어를 일부 제외해 주었습니다. 텍스트를 수치화하는 단계라는 것은 본격적으로 자연어 처리 작업에 들어간다는 의미이므로, 단어가 텍스트일 때만 할 수 있는 최대한의 전처리를 끝내놓아야 합니다. vocab = {} preprocessed_sentences = [] stop_words = set(stopwords.words('english')) for sentence in sentences: # 단어 토큰화 tokenized_sentence = word_tokenize(sentence) result = [] for word in tokenized_sentence: word = word.lower() # 모든 단어를 소문자화하여 단어의 개수를 줄인다. if word not in stop_words: # 단어 토큰화된 결과에 대해서 불용어를 제거한다. if len(word) > 2: # 단어 길이가 2이하인 경우에 대하여 추가로 단어를 제거한다. result.append(word) if word not in vocab: vocab[word] = 0 vocab[word] += 1 preprocessed_sentences.append(result) print(preprocessed_sentences) [['barber', 'person'], ['barber', 'good', 'person'], ['barber', 'huge', 'person'], ['knew', 'secret'], ['secret', 'kept', 'huge', 'secret'], ['huge', 'secret'], ['barber', 'kept', 'word'], ['barber', 'kept', 'word'], ['barber', 'kept', 'secret'], ['keeping', 'keeping', 'huge', 'secret', 'driving', 'barber', 'crazy'], ['barber', 'went', 'huge', 'mountain']] 현재 vocab에는 각 단어에 대한 빈도수가 기록돼 있습니다. vocab을 출력해 보겠습니다. print('단어 집합 :',vocab) 단어 집합 : {'barber': 8, 'person': 3, 'good': 1, 'huge': 5, 'knew': 1, 'secret': 6, 'kept': 4, 'word': 2, 'keeping': 2, 'driving': 1, 'crazy': 1, 'went': 1, 'mountain': 1} 파이썬의 딕셔너리 구조로 단어를 키(key)로, 단어에 대한 빈도수가 값(value)으로 저장돼 있습니다. vocab에 단어를 입력하면 빈도수를 리턴합니다. # 'barber'라는 단어의 빈도수 출력 print(vocab["barber"]) 이제 빈도수가 높은 순서대로 정렬해 보겠습니다. vocab_sorted = sorted(vocab.items(), key = lambda x:x[1], reverse = True) print(vocab_sorted) [('barber', 8), ('secret', 6), ('huge', 5), ('kept', 4), ('person', 3), ('word', 2), ('keeping', 2), ('good', 1), ('knew', 1), ('driving', 1), ('crazy', 1), ('went', 1), ('mountain', 1)] 높은 빈도수를 가진 단어일수록 낮은 정수를 부여합니다. 정수는 1부터 부여합니다. word_to_index = {} i = 0 for (word, frequency) in vocab_sorted : if frequency > 1 : # 빈도수가 작은 단어는 제외. i = i + 1 word_to_index[word] = i print(word_to_index) {'barber': 1, 'secret': 2, 'huge': 3, 'kept': 4, 'person': 5, 'word': 6, 'keeping': 7} 1의 인덱스를 가진 단어가 가장 빈도수가 높은 단어가 됩니다. 그리고 이러한 작업을 수행하는 동시에 각 단어의 빈도수를 알 경우에만 할 수 있는 전처리인 빈도수가 적은 단어를 제외하는 작업을 수행했습니다. 등장 빈도가 낮은 단어는 자연어 처리에서 의미를 가지지 않을 가능성이 높기 때문입니다. 여기서는 빈도수가 1인 단어들은 전부 제외했습니다. 자연어 처리를 하다 보면, 텍스트 데이터에 있는 단어를 모두 사용하기보다는 빈도수가 가장 높은 n 개의 단어만 사용하고 싶은 경우가 많습니다. 위 단어들은 빈도수가 높은 순으로 낮은 정수가 부여돼 있으므로 빈도수 상위 n 개의 단어만 사용하고 싶다고 하면 vocab에서 정숫값이 1부터 n까지인 단어들만 사용하면 됩니다. 여기서는 상위 5개 단어만 사용한다고 가정하겠습니다. vocab_size = 5 # 인덱스가 5 초과인 단어 제거 words_frequency = [word for word, index in word_to_index.items() if index >= vocab_size + 1] # 해당 단어에 대한 인덱스 정보를 삭제 for w in words_frequency: del word_to_index[w] print(word_to_index) {'barber': 1, 'secret': 2, 'huge': 3, 'kept': 4, 'person': 5} word_to_index에는 빈도수가 높은 상위 5개의 단어만 저장되었습니다. word_to_index를 사용하여 단어 토큰 화가 된 상태로 저장된 sentences에 있는 각 단어를 정수로 바꾸는 작업을 하겠습니다. 예를 들어 sentences에서 첫 번째 문장은 ['barber', 'person']이었는데, 이 문장에 대해서는 [1, 5]로 인코딩합니다. 그런데 두 번째 문장인 ['barber', 'good', 'person']에는 더 이상 word_to_index에는 존재하지 않는 단어인 'good'이라는 단어가 있습니다. 이처럼 단어 집합에 존재하지 않는 단어들이 생기는 상황을 Out-Of-Vocabulary(단어 집합에 없는 단어) 문제라고 합니다. 약자로 'OOV 문제'라고도 합니다. word_to_index에 'OOV'란 단어를 새롭게 추가하고, 단어 집합에 없는 단어들은 'OOV'의 인덱스로 인코딩하겠습니다. word_to_index['OOV'] = len(word_to_index) + 1 print(word_to_index) {'barber': 1, 'secret': 2, 'huge': 3, 'kept': 4, 'person': 5, 'OOV': 6} 이제 word_to_index를 사용하여 sentences의 모든 단어들을 매핑되는 정수로 인코딩하겠습니다. encoded_sentences = [] for sentence in preprocessed_sentences: encoded_sentence = [] for word in sentence: try: # 단어 집합에 있는 단어라면 해당 단어의 정수를 리턴. encoded_sentence.append(word_to_index[word]) except KeyError: # 만약 단어 집합에 없는 단어라면 'OOV'의 정수를 리턴. encoded_sentence.append(word_to_index['OOV']) encoded_sentences.append(encoded_sentence) print(encoded_sentences) [[1, 5], [1, 6, 5], [1, 3, 5], [6, 2], [2, 4, 3, 2], [3, 2], [1, 4, 6], [1, 4, 6], [1, 4, 2], [6, 6, 3, 2, 6, 1, 6], [1, 6, 3, 6]] 지금까지 파이썬의 dictionary 자료형으로 정수 인코딩을 진행해 보았습니다. 그런데 이보다는 좀 더 쉽게 하기 위해서 Counter, FreqDist, enumerate를 사용하거나, 케라스 토크 나이저를 사용하는 것을 권장합니다. 2) Counter 사용하기 from collections import Counter print(preprocessed_sentences) [['barber', 'person'], ['barber', 'good', 'person'], ['barber', 'huge', 'person'], ['knew', 'secret'], ['secret', 'kept', 'huge', 'secret'], ['huge', 'secret'], ['barber', 'kept', 'word'], ['barber', 'kept', 'word'], ['barber', 'kept', 'secret'], ['keeping', 'keeping', 'huge', 'secret', 'driving', 'barber', 'crazy'], ['barber', 'went', 'huge', 'mountain']] 현재 sentences는 단어 토큰 화가 된 결과가 저장돼 있습니다. 단어 집합(vocabulary)을 만들기 위해서 sentences에서 문장의 경계인 [, ]를 제거하고 단어들을 하나의 리스트로 만들겠습니다. # words = np.hstack(preprocessed_sentences)으로도 수행 가능. all_words_list = sum(preprocessed_sentences, []) print(all_words_list) ['barber', 'person', 'barber', 'good', 'person', 'barber', 'huge', 'person', 'knew', 'secret', 'secret', 'kept', 'huge', 'secret', 'huge', 'secret', 'barber', 'kept', 'word', 'barber', 'kept', 'word', 'barber', 'kept', 'secret', 'keeping', 'keeping', 'huge', 'secret', 'driving', 'barber', 'crazy', 'barber', 'went', 'huge', 'mountain'] 이를 파이썬의 Counter()의 입력으로 사용하면 중복을 제거하고 단어의 빈도수를 기록합니다. # 파이썬의 Counter 모듈을 이용하여 단어의 빈도수 카운트 vocab = Counter(all_words_list) print(vocab) Counter({'barber': 8, 'secret': 6, 'huge': 5, 'kept': 4, 'person': 3, 'word': 2, 'keeping': 2, 'good': 1, 'knew': 1, 'driving': 1, 'crazy': 1, 'went': 1, 'mountain': 1}) 단어를 키(key)로, 단어에 대한 빈도수가 값(value)으로 저장돼 있습니다. vocab에 단어를 입력하면 빈도수를 리턴합니다. print(vocab["barber"]) # 'barber'라는 단어의 빈도수 출력 barber란 단어가 총 8번 등장하였습니다. most_common()는 상위 빈도수를 가진 주어진 수의 단어만을 리턴합니다. 이를 사용하여 등장 빈도수가 높은 단어들을 원하는 개수만큼만 얻을 수 있습니다. 등장 빈도수 상위 5개의 단어만 단어 집합으로 저장해 봅시다. vocab_size = 5 vocab = vocab.most_common(vocab_size) # 등장 빈도수가 높은 상위 5개의 단어만 저장 vocab [('barber', 8), ('secret', 6), ('huge', 5), ('kept', 4), ('person', 3)] 이제 높은 빈도수를 가진 단어일수록 낮은 정수 인덱스를 부여합니다. word_to_index = {} i = 0 for (word, frequency) in vocab : i = i + 1 word_to_index[word] = i print(word_to_index) {'barber': 1, 'secret': 2, 'huge': 3, 'kept': 4, 'person': 5} 3) NLTK의 FreqDist 사용하기 NLTK에서는 빈도수 계산 도구인 FreqDist()를 지원합니다. 위에서 사용한 Counter()랑 같은 방법으로 사용할 수 있습니다. from nltk import FreqDist import numpy as np # np.hstack으로 문장 구분을 제거 vocab = FreqDist(np.hstack(preprocessed_sentences)) 단어를 키(key)로, 단어에 대한 빈도수가 값(value)으로 저장돼 있습니다. vocab에 단어를 입력하면 빈도수를 리턴합니다. print(vocab["barber"]) # 'barber'라는 단어의 빈도수 출력 barber란 단어가 총 8번 등장하였습니다. most_common()는 상위 빈도수를 가진 주어진 수의 단어만을 리턴합니다. 이를 사용하여 등장 빈도수가 높은 단어들을 원하는 개수만큼만 얻을 수 있습니다. 등장 빈도수 상위 5개의 단어만 단어 집합으로 저장해 봅시다. vocab_size = 5 vocab = vocab.most_common(vocab_size) # 등장 빈도수가 높은 상위 5개의 단어만 저장 print(vocab) [('barber', 8), ('secret', 6), ('huge', 5), ('kept', 4), ('person', 3)] 앞서 Counter()를 사용했을 때와 결과가 같습니다. 이전 실습들과 마찬가지로 높은 빈도수를 가진 단어일수록 낮은 정수 인덱스를 부여합니다. 그런데 이번에는 enumerate()를 사용하여 좀 더 짧은 코드로 인덱스를 부여하겠습니다. word_to_index = {word[0] : index + 1 for index, word in enumerate(vocab)} print(word_to_index) {'barber': 1, 'secret': 2, 'huge': 3, 'kept': 4, 'person': 5} 위와 같이 인덱스를 부여할 때는 enumerate()를 사용하는 것이 편리합니다. enumerate()에 대해서 간단히 소개해 보겠습니다. 4) enumerate 이해하기 enumerate()는 순서가 있는 자료형(list, set, tuple, dictionary, string)을 입력으로 받아 인덱스를 순차적으로 함께 리턴한다는 특징이 있습니다. 간단한 예제를 통해 enumerate()를 이해해 봅시다. test_input = ['a', 'b', 'c', 'd', 'e'] for index, value in enumerate(test_input): # 입력의 순서대로 0부터 인덱스를 부여함. print("value : {}, index: {}".format(value, index)) value : a, index: 0 value : b, index: 1 value : c, index: 2 value : d, index: 3 value : e, index: 4 위의 출력 결과는 리스트의 모든 토큰에 대해서 인덱스가 순차적으로 증가되며 부여된 것을 보여줍니다. 2. 케라스(Keras)의 텍스트 전처리 케라스(Keras)는 기본적인 전처리를 위한 도구들을 제공합니다. 때로는 정수 인코딩을 위해서 케라스의 전처리 도구인 토크 나이저를 사용하기도 하는데, 사용 방법과 그 특징에 대해서 이해해 보겠습니다. from tensorflow.keras.preprocessing.text import Tokenizer preprocessed_sentences = [['barber', 'person'], ['barber', 'good', 'person'], ['barber', 'huge', 'person'], ['knew', 'secret'], ['secret', 'kept', 'huge', 'secret'], ['huge', 'secret'], ['barber', 'kept', 'word'], ['barber', 'kept', 'word'], ['barber', 'kept', 'secret'], ['keeping', 'keeping', 'huge', 'secret', 'driving', 'barber', 'crazy'], ['barber', 'went', 'huge', 'mountain']] 단어 토큰화까지 수행된 앞서 사용한 텍스트 데이터와 동일한 데이터를 사용합니다. tokenizer = Tokenizer() # fit_on_texts() 안에 코퍼스를 입력으로 하면 빈도수를 기준으로 단어 집합을 생성. tokenizer.fit_on_texts(preprocessed_sentences) fit_on_texts는 입력한 텍스트로부터 단어 빈도수가 높은 순으로 낮은 정수 인덱스를 부여하는데, 정확히 앞서 설명한 정수 인코딩 작업이 이루어진다고 보면 됩니다. 각 단어에 인덱스가 어떻게 부여되었는지를 보려면, word_index를 사용합니다. print(tokenizer.word_index) {'barber': 1, 'secret': 2, 'huge': 3, 'kept': 4, 'person': 5, 'word': 6, 'keeping': 7, 'good': 8, 'knew': 9, 'driving': 10, 'crazy': 11, 'went': 12, 'mountain': 13} 각 단어의 빈도수가 높은 순서대로 인덱스가 부여된 것을 확인할 수 있습니다. 각 단어가 카운트를 수행하였을 때 몇 개였는지를 보고자 한다면 word_counts를 사용합니다. print(tokenizer.word_counts) OrderedDict([('barber', 8), ('person', 3), ('good', 1), ('huge', 5), ('knew', 1), ('secret', 6), ('kept', 4), ('word', 2), ('keeping', 2), ('driving', 1), ('crazy', 1), ('went', 1), ('mountain', 1)]) texts_to_sequences()는 입력으로 들어온 코퍼스에 대해서 각 단어를 이미 정해진 인덱스로 변환합니다. print(tokenizer.texts_to_sequences(preprocessed_sentences)) [[1, 5], [1, 8, 5], [1, 3, 5], [9, 2], [2, 4, 3, 2], [3, 2], [1, 4, 6], [1, 4, 6], [1, 4, 2], [7, 7, 3, 2, 10, 1, 11], [1, 12, 3, 13]] 앞서 빈도수가 가장 높은 단어 n 개만을 사용하기 위해서 most_common()을 사용했었습니다. 케라스 토크 나이저에서는 tokenizer = Tokenizer(num_words=숫자)와 같은 방법으로 빈도수가 높은 상위 몇 개의 단어만 사용하겠다고 지정할 수 있습니다. 여기서는 1번 단어부터 5번 단어까지만 사용하겠습니다. 상위 5개 단어를 사용한다고 토크 나이저를 재정의 해보겠습니다. vocab_size = 5 tokenizer = Tokenizer(num_words = vocab_size + 1) # 상위 5개 단어만 사용 tokenizer.fit_on_texts(preprocessed_sentences) num_words에서 +1을 더해서 값을 넣어주는 이유는 num_words는 숫자를 0부터 카운트합니다. 만약 5를 넣으면 0 ~ 4번 단어 보존을 의미하게 되므로 뒤의 실습에서 1번 단어부터 4번 단어만 남게 됩니다. 그렇기 때문에 1 ~ 5번 단어까지 사용하고 싶다면 num_words에 숫자 5를 넣어주는 것이 아니라 5+1인 값을 넣어주어야 합니다. 실질적으로 숫자 0에 지정된 단어가 존재하지 않는데도 케라스 토크 나이저가 숫자 0까지 단어 집합의 크기로 산정하는 이유는 자연어 처리에서 패딩(padding)이라는 작업 때문입니다. 이에 대해서는 뒤에 다루게 되므로 여기서는 케라스 토크 나이저를 사용할 때는 숫자 0도 단어 집합의 크기로 고려해야 한다고만 이해합시다. 다시 word_index를 확인해 보겠습니다. print(tokenizer.word_index) {'barber': 1, 'secret': 2, 'huge': 3, 'kept': 4, 'person': 5, 'word': 6, 'keeping': 7, 'good': 8, 'knew': 9, 'driving': 10, 'crazy': 11, 'went': 12, 'mountain': 13} 상위 5개의 단어만 사용하겠다고 선언하였는데 여전히 13개의 단어가 모두 출력됩니다. word_counts를 확인해 보겠습니다. print(tokenizer.word_counts) OrderedDict([('barber', 8), ('person', 3), ('good', 1), ('huge', 5), ('knew', 1), ('secret', 6), ('kept', 4), ('word', 2), ('keeping', 2), ('driving', 1), ('crazy', 1), ('went', 1), ('mountain', 1)]) word_counts에서도 마찬가지로 13개의 단어가 모두 출력됩니다. 사실 실제 적용은 texts_to_sequences를 사용할 때 적용이 됩니다. print(tokenizer.texts_to_sequences(preprocessed_sentences)) [[1, 5], [1, 5], [1, 3, 5], [2], [2, 4, 3, 2], [3, 2], [1, 4], [1, 4], [1, 4, 2], [3, 2, 1], [1, 3]] 코퍼스에 대해서 각 단어를 이미 정해진 인덱스로 변환하는데, 상위 5개의 단어만을 사용하겠다고 지정하였으므로 1번 단어부터 5번 단어까지만 보존되고 나머지 단어들은 제거된 것을 볼 수 있습니다. 경험상 굳이 필요하다고 생각하지는 않지만, 만약 word_index와 word_counts에서도 지정된 num_words 만큼의 단어만 남기고 싶다면 아래의 코드도 방법입니다. tokenizer = Tokenizer() tokenizer.fit_on_texts(preprocessed_sentences) vocab_size = 5 words_frequency = [word for word, index in tokenizer.word_index.items() if index >= vocab_size + 1] # 인덱스가 5 초과인 단어 제거 for word in words_frequency: del tokenizer.word_index[word] # 해당 단어에 대한 인덱스 정보를 삭제 del tokenizer.word_counts[word] # 해당 단어에 대한 카운트 정보를 삭제 print(tokenizer.word_index) print(tokenizer.word_counts) print(tokenizer.texts_to_sequences(preprocessed_sentences)) {'barber': 1, 'secret': 2, 'huge': 3, 'kept': 4, 'person': 5} OrderedDict([('barber', 8), ('person', 3), ('huge', 5), ('secret', 6), ('kept', 4)]) [[1, 5], [1, 5], [1, 3, 5], [2], [2, 4, 3, 2], [3, 2], [1, 4], [1, 4], [1, 4, 2], [3, 2, 1], [1, 3]] 케라스 토크 나이저는 기본적으로 단어 집합에 없는 단어인 OOV에 대해서는 단어를 정수로 바꾸는 과정에서 아예 단어를 제거한다는 특징이 있습니다. 단어 집합에 없는 단어들은 OOV로 간주하여 보존하고 싶다면 Tokenizer의 인자 oov_token을 사용합니다. # 숫자 0과 OOV를 고려해서 단어 집합의 크기는 +2 vocab_size = 5 tokenizer = Tokenizer(num_words = vocab_size + 2, oov_token = 'OOV') tokenizer.fit_on_texts(preprocessed_sentences) 만약 oov_token을 사용하기로 했다면 케라스 토크 나이저는 기본적으로 'OOV'의 인덱스를 1로 합니다. print('단어 OOV의 인덱스 : {}'.format(tokenizer.word_index['OOV'])) 단어 OOV의 인덱스 : 1 이제 코퍼스에 대해서 정수 인코딩을 진행합니다. print(tokenizer.texts_to_sequences(preprocessed_sentences)) [[2, 6], [2, 1, 6], [2, 4, 6], [1, 3], [3, 5, 4, 3], [4, 3], [2, 5, 1], [2, 5, 1], [2, 5, 3], [1, 1, 4, 3, 1, 2, 1], [2, 1, 4, 1]] 빈도수 상위 5개의 단어는 2 ~ 6까지의 인덱스를 가졌으며, 그 외 단어 집합에 없는 'good'과 같은 단어들은 전부 'OOV'의 인덱스인 1로 인코딩되었습니다. 02-07 패딩(Padding) 자연어 처리를 하다 보면 각 문장(또는 문서)은 서로 길이가 다를 수 있습니다. 그런데 기계는 길이가 전부 동일한 문서들에 대해서는 하나의 행렬로 보고, 한꺼번에 묶어서 처리할 수 있습니다. 다시 말해 병렬 연산을 위해서 여러 문장의 길이를 임의로 동일하게 맞춰주는 작업이 필요할 때가 있습니다. 실습을 통해 이해해 봅시다. 1. Numpy로 패딩 하기 import numpy as np from tensorflow.keras.preprocessing.text import Tokenizer 정수 인코딩 챕터에서 수행했던 실습을 그대로 반복해 보겠습니다. 아래와 같이 텍스트 데이터가 있습니다. preprocessed_sentences = [['barber', 'person'], ['barber', 'good', 'person'], ['barber', 'huge', 'person'], ['knew', 'secret'], ['secret', 'kept', 'huge', 'secret'], ['huge', 'secret'], ['barber', 'kept', 'word'], ['barber', 'kept', 'word'], ['barber', 'kept', 'secret'], ['keeping', 'keeping', 'huge', 'secret', 'driving', 'barber', 'crazy'], ['barber', 'went', 'huge', 'mountain']] 단어 집합을 만들고, 정수 인코딩을 수행합니다. tokenizer = Tokenizer() tokenizer.fit_on_texts(preprocessed_sentences) encoded = tokenizer.texts_to_sequences(preprocessed_sentences) print(encoded) 모든 단어가 고유한 정수로 변환되었습니다. [[1, 5], [1, 8, 5], [1, 3, 5], [9, 2], [2, 4, 3, 2], [3, 2], [1, 4, 6], [1, 4, 6], [1, 4, 2], [7, 7, 3, 2, 10, 1, 11], [1, 12, 3, 13]] 모두 동일한 길이로 맞춰주기 위해서 이 중에서 가장 길이가 긴 문장의 길이를 계산해 보겠습니다. max_len = max(len(item) for item in encoded) print('최대 길이 :',max_len) 최대 길이 : 7 가장 길이가 긴 문장의 길이는 7입니다. 모든 문장의 길이를 7로 맞춰주겠습니다. 이때 가상의 단어 'PAD'를 사용합니다. 'PAD'라는 단어가 있다고 가정하고, 이 단어는 0번 단어라고 정의합니다. 길이가 7보다 짧은 문장에는 숫자 0을 채워서 길이 7로 맞춰줍니다. for sentence in encoded: while len(sentence) < max_len: sentence.append(0) padded_np = np.array(encoded) padded_np array([[ 1, 5, 0, 0, 0, 0, 0], [ 1, 8, 5, 0, 0, 0, 0], [ 1, 3, 5, 0, 0, 0, 0], [ 9, 2, 0, 0, 0, 0, 0], [ 2, 4, 3, 2, 0, 0, 0], [ 3, 2, 0, 0, 0, 0, 0], [ 1, 4, 6, 0, 0, 0, 0], [ 1, 4, 6, 0, 0, 0, 0], [ 1, 4, 2, 0, 0, 0, 0], [ 7, 7, 3, 2, 10, 1, 11], [ 1, 12, 3, 13, 0, 0, 0]]) 길이가 7보다 짧은 문장에는 전부 숫자 0이 뒤로 붙어서 모든 문장의 길이가 전부 7이 된 것을 알 수 있습니다. 기계는 이들을 하나의 행렬로 보고, 병렬 처리를 할 수 있습니다. 또한, 0번 단어는 사실 아무런 의미도 없는 단어이기 때문에 자연어 처리하는 과정에서 기계는 0번 단어를 무시하게 될 것입니다. 이와 같이 데이터에 특정 값을 채워서 데이터의 크기(shape)를 조정하는 것을 패딩(padding)이라고 합니다. 숫자 0을 사용하고 있다면 제로 패딩(zero padding)이라고 합니다. 2. 케라스 전처리 도구로 패딩 하기 케라스에서는 위와 같은 패딩을 위해 pad_sequences()를 제공하고 있습니다. from tensorflow.keras.preprocessing.sequence import pad_sequences encoded 값이 위에서 이미 패딩 후의 결과로 저장되었기 때문에 패딩 이전의 값으로 다시 되돌리겠습니다. encoded = tokenizer.texts_to_sequences(preprocessed_sentences) print(encoded) [[1, 5], [1, 8, 5], [1, 3, 5], [9, 2], [2, 4, 3, 2], [3, 2], [1, 4, 6], [1, 4, 6], [1, 4, 2], [7, 7, 3, 2, 10, 1, 11], [1, 12, 3, 13]] 케라스의 pad_sequences를 사용하여 패딩을 해봅시다. padded = pad_sequences(encoded) padded array([[ 0, 0, 0, 0, 0, 1, 5], [ 0, 0, 0, 0, 1, 8, 5], [ 0, 0, 0, 0, 1, 3, 5], [ 0, 0, 0, 0, 0, 9, 2], [ 0, 0, 0, 2, 4, 3, 2], [ 0, 0, 0, 0, 0, 3, 2], [ 0, 0, 0, 0, 1, 4, 6], [ 0, 0, 0, 0, 1, 4, 6], [ 0, 0, 0, 0, 1, 4, 2], [ 7, 7, 3, 2, 10, 1, 11], [ 0, 0, 0, 1, 12, 3, 13]], dtype=int32) Numpy로 패딩을 진행하였을 때와는 패딩 결과가 다른데 그 이유는 pad_sequences는 기본적으로 문서의 뒤에 0을 채우는 것이 아니라 앞에 0으로 채우기 때문입니다. 뒤에 0을 채우고 싶다면 인자로 padding='post'를 주면 됩니다. padded = pad_sequences(encoded, padding='post') padded array([[ 1, 5, 0, 0, 0, 0, 0], [ 1, 8, 5, 0, 0, 0, 0], [ 1, 3, 5, 0, 0, 0, 0], [ 9, 2, 0, 0, 0, 0, 0], [ 2, 4, 3, 2, 0, 0, 0], [ 3, 2, 0, 0, 0, 0, 0], [ 1, 4, 6, 0, 0, 0, 0], [ 1, 4, 6, 0, 0, 0, 0], [ 1, 4, 2, 0, 0, 0, 0], [ 7, 7, 3, 2, 10, 1, 11], [ 1, 12, 3, 13, 0, 0, 0]], dtype=int32) Numpy를 이용하여 패딩을 했을 때와 결과가 동일합니다. 실제로 결과가 동일한지 두 결과를 비교합니다. (padded == padded_np).all() True True 값이 리턴됩니다. 두 결과가 동일하다는 의미입니다. 지금까지는 가장 긴 길이를 가진 문서의 길이를 기준으로 패딩을 한다고 가정하였지만, 실제로는 꼭 가장 긴 문서의 길이를 기준으로 해야 하는 것은 아닙니다. 가령, 모든 문서의 평균 길이가 20인데 문서 1개의 길이가 5,000이라고 해서 굳이 모든 문서의 길이를 5,000으로 패딩 할 필요는 없을 수 있습니다. 이와 같은 경우에는 길이에 제한을 두고 패딩 할 수 있습니다. maxlen의 인자로 정수를 주면, 해당 정수로 모든 문서의 길이를 동일하게 합니다. padded = pad_sequences(encoded, padding='post', maxlen=5) padded array([[ 1, 5, 0, 0, 0], [ 1, 8, 5, 0, 0], [ 1, 3, 5, 0, 0], [ 9, 2, 0, 0, 0], [ 2, 4, 3, 2, 0], [ 3, 2, 0, 0, 0], [ 1, 4, 6, 0, 0], [ 1, 4, 6, 0, 0], [ 1, 4, 2, 0, 0], [ 3, 2, 10, 1, 11], [ 1, 12, 3, 13, 0]], dtype=int32) 길이가 5보다 짧은 문서들은 0으로 패딩 되고, 기존에 5보다 길었다면 데이터가 손실됩니다. 가령, 뒤에서 두 번째 문장은 본래 [ 7, 7, 3, 2, 10, 1, 11]였으나 현재는 [ 3, 2, 10, 1, 11]로 변경된 것을 볼 수 있습니다. 만약, 데이터가 손실될 경우에 앞의 단어가 아니라 뒤의 단어가 삭제되도록 하고 싶다면 truncating이라는 인자를 사용합니다. truncating='post'를 사용할 경우 뒤의 단어가 삭제됩니다. padded = pad_sequences(encoded, padding='post', truncating='post', maxlen=5) padded array([[ 1, 5, 0, 0, 0], [ 1, 8, 5, 0, 0], [ 1, 3, 5, 0, 0], [ 9, 2, 0, 0, 0], [ 2, 4, 3, 2, 0], [ 3, 2, 0, 0, 0], [ 1, 4, 6, 0, 0], [ 1, 4, 6, 0, 0], [ 1, 4, 2, 0, 0], [ 7, 7, 3, 2, 10], [ 1, 12, 3, 13, 0]], dtype=int32) 숫자 0으로 패딩 하는 것은 널리 퍼진 관례이긴 하지만, 반드시 지켜야 하는 규칙은 아닙니다. 만약, 숫자 0이 아니라 다른 숫자를 패딩을 위한 숫자로 사용하고 싶다면 이 또한 가능합니다. 현재 사용된 정수들과 겹치지 않도록, 단어 집합의 크기에 +1을 한 숫자로 사용해 봅시다. last_value = len(tokenizer.word_index) + 1 # 단어 집합의 크기보다 1 큰 숫자를 사용 print(last_value) 14 현재 단어가 총 13개이고, 1번부터 13번까지 정수가 사용되었으므로 단어 집합의 크기에 +1을 하면 마지막 숫자인 13보다 1이 큰 14를 얻습니다. pad_sequences의 인자로 value를 사용하면 0이 아닌 다른 숫자로 패딩이 가능합니다. padded = pad_sequences(encoded, padding='post', value=last_value) padded array([[ 1, 5, 14, 14, 14, 14, 14], [ 1, 8, 5, 14, 14, 14, 14], [ 1, 3, 5, 14, 14, 14, 14], [ 9, 2, 14, 14, 14, 14, 14], [ 2, 4, 3, 2, 14, 14, 14], [ 3, 2, 14, 14, 14, 14, 14], [ 1, 4, 6, 14, 14, 14, 14], [ 1, 4, 6, 14, 14, 14, 14], [ 1, 4, 2, 14, 14, 14, 14], [ 7, 7, 3, 2, 10, 1, 11], [ 1, 12, 3, 13, 14, 14, 14]], dtype=int32) 02-08 원-핫 인코딩(One-Hot Encoding) 컴퓨터 또는 기계는 문자보다는 숫자를 더 잘 처리할 수 있습니다. 이를 위해 자연어 처리에서는 문자를 숫자로 바꾸는 여러 가지 기법들이 있습니다. 원-핫 인코딩(One-Hot Encoding)은 그 많은 기법 중에서 단어를 표현하는 가장 기본적인 표현 방법이며, 머신 러닝, 딥 러닝을 하기 위해서는 반드시 배워야 하는 표현 방법입니다. 원-핫 인코딩에 대해서 배우기에 앞서 단어 집합(vocabulary)에 대해서 정의해 보겠습니다. 단어 집합은 앞으로 자연어 처리에서 계속 나오는 개념이기 때문에 여기서 이해하고 가야 합니다. 단어 집합은 서로 다른 단어들의 집합입니다. 여기서 혼동이 없도록 서로 다른 단어라는 정의에 대해서 좀 더 주목할 필요가 있습니다. 단어 집합(vocabulary)에서는 기본적으로 book과 books와 같이 단어의 변형 형태도 다른 단어로 간주합니다. 이 책에서는 앞으로 단어 집합에 있는 단어들을 가지고, 문자를 숫자. 더 구체적으로는 벡터로 바꾸는 원-핫 인코딩을 포함한 여러 방법에 대해서 배우게 됩니다. 원-핫 인코딩을 위해서 먼저 해야 할 일은 단어 집합을 만드는 일입니다. 텍스트의 모든 단어를 중복을 허용하지 않고 모아놓으면 이를 단어 집합이라고 합니다. 그리고 이 단어 집합에 고유한 정수를 부여하는 정수 인코딩을 진행합니다. 텍스트에 단어가 총 5,000개가 존재한다면, 단어 집합의 크기는 5,000입니다. 5,000개의 단어가 있는 이 단어 집합의 단어들마다 1번부터 5,000번까지 인덱스를 부여한다고 해보겠습니다. 가령, book은 150번, dog는 171번, love는 192번, books는 212번과 같이 부여할 수 있습니다. 이제 각 단어에 고유한 정수 인덱스를 부여하였다고 합시다. 이 숫자로 바뀐 단어들을 벡터로 다루고 싶다면 어떻게 하면 될까요? 1. 원-핫 인코딩(One-Hot Encoding)이란? 원-핫 인코딩은 단어 집합의 크기를 벡터의 차원으로 하고, 표현하고 싶은 단어의 인덱스에 1의 값을 부여하고, 다른 인덱스에는 0을 부여하는 단어의 벡터 표현 방식입니다. 이렇게 표현된 벡터를 원-핫 벡터(One-Hot vector)라고 합니다. 원-핫 인코딩을 두 가지 과정으로 정리해 보겠습니다. 첫째, 정수 인코딩을 수행합니다. 다시 말해 각 단어에 고유한 정수를 부여합니다. 둘째, 표현하고 싶은 단어의 고유한 정수를 인덱스로 간주하고 해당 위치에 1을 부여하고, 다른 단어의 인덱스의 위치에는 0을 부여합니다. 한국어 문장을 예제로 원-핫 벡터를 만들어보겠습니다. 문장 : 나는 자연어 처리를 배운다 Okt 형태소 분석기를 통해서 문장에 대해서 토큰화를 수행합니다. from konlpy.tag import Okt okt = Okt() tokens = okt.morphs("나는 자연어 처리를 배운다") print(tokens) ['나', '는', '자연어', '처리', '를', '배운다'] 각 토큰에 대해서 고유한 정수를 부여합니다. 지금은 문장이 짧기 때문에 각 단어의 빈도수를 고려하지 않지만, 빈도수 순으로 단어를 정렬하여 정수를 부여하는 경우가 많습니다. word_to_index = {word : index for index, word in enumerate(tokens)} print('단어 집합 :',word_to_index) 단어 집합 : {'나': 0, '는': 1, '자연어': 2, '처리': 3, '를': 4, '배운다': 5} 토큰을 입력하면 해당 토큰에 대한 원-핫 벡터를 만들어내는 함수를 만들었습니다. def one_hot_encoding(word, word_to_index): one_hot_vector = [0]*(len(word_to_index)) index = word_to_index[word] one_hot_vector[index] = 1 return one_hot_vector '자연어'라는 단어의 원-핫 벡터를 얻어봅시다. one_hot_encoding("자연어", word_to_index) [0, 0, 1, 0, 0, 0] '자연어'는 정수 2이므로 원-핫 벡터는 인덱스 2의 값이 1이며, 나머지 값은 0인 벡터가 나옵니다. 2. 케라스(Keras)를 이용한 원-핫 인코딩(One-Hot Encoding) 위에서는 원-핫 인코딩을 이해하기 위해 파이썬으로 직접 코드를 작성하였지만, 케라스는 원-핫 인코딩을 수행하는 유용한 도구 to_categorical()를 지원합니다. 이번에는 케라스만으로 정수 인코딩과 원-핫 인코딩을 순차적으로 진행해 보도록 하겠습니다. text = "나랑 점심 먹으러 갈래 점심 메뉴는 햄버거 갈래 갈래 햄버거 최고야" 위와 같은 문장이 있다고 했을 때, 케라스 토크 나이저를 이용한 정수 인코딩은 다음과 같습니다. from tensorflow.keras.preprocessing.text import Tokenizer from tensorflow.keras.utils import to_categorical text = "나랑 점심 먹으러 갈래 점심 메뉴는 햄버거 갈래 갈래 햄버거 최고야" tokenizer = Tokenizer() tokenizer.fit_on_texts([text]) print('단어 집합 :',tokenizer.word_index) 단어 집합 : {'갈래': 1, '점심': 2, '햄버거': 3, '나랑': 4, '먹으러': 5, '메뉴는': 6, '최고야': 7} 위와 같이 생성된 단어 집합(vocabulary)에 있는 단어들로만 구성된 텍스트가 있다면, texts_to_sequences()를 통해서 이를 정수 시퀀스로 변환 가능합니다. 생성된 단어 집합 내의 일부 단어들로만 구성된 서브 텍스트인 sub_text를 만들어 확인해 보겠습니다. sub_text = "점심 먹으러 갈래 메뉴는 햄버거 최고야" encoded = tokenizer.texts_to_sequences([sub_text])[0] print(encoded) [2, 5, 1, 6, 3, 7] 지금까지 진행한 것은 이미 이전에 정수 인코딩 실습을 하며 배운 내용입니다. 이제 해당 결과를 가지고, 원-핫 인코딩을 진행해 보겠습니다. 케라스는 정수 인코딩 된 결과로부터 원-핫 인코딩을 수행하는 to_categorical()를 지원합니다. one_hot = to_categorical(encoded) print(one_hot) [[0. 0. 1. 0. 0. 0. 0. 0.] # 인덱스 2의 원-핫 벡터 [0. 0. 0. 0. 0. 1. 0. 0.] # 인덱스 5의 원-핫 벡터 [0. 1. 0. 0. 0. 0. 0. 0.] # 인덱스 1의 원-핫 벡터 [0. 0. 0. 0. 0. 0. 1. 0.] # 인덱스 6의 원-핫 벡터 [0. 0. 0. 1. 0. 0. 0. 0.] # 인덱스 3의 원-핫 벡터 [0. 0. 0. 0. 0. 0. 0. 1.]] # 인덱스 7의 원-핫 벡터 위의 결과는 "점심 먹으러 갈래 메뉴는 햄버거 최고야"라는 문장이 [2, 5, 1, 6, 3, 7]로 정수 인코딩이 되고 나서, 각각의 인코딩 된 결과를 인덱스로 원-핫 인코딩이 수행된 모습을 보여줍니다. 3. 원-핫 인코딩(One-Hot Encoding)의 한계 이러한 표현 방식은 단어의 개수가 늘어날수록, 벡터를 저장하기 위해 필요한 공간이 계속 늘어난다는 단점이 있습니다. 다른 표현으로는 벡터의 차원이 늘어난다고 표현합니다. 원 핫 벡터는 단어 집합의 크기가 곧 벡터의 차원 수가 됩니다. 가령, 단어가 1,000개인 코퍼스를 가지고 원 핫 벡터를 만들면, 모든 단어 각각은 모두 1,000개의 차원을 가진 벡터가 됩니다. 다시 말해 모든 단어 각각은 하나의 값만 1을 가지고, 999개의 값은 0의 값을 가지는 벡터가 되는데 이는 저장 공간 측면에서는 매우 비효율적인 표현 방법입니다. 또한 원-핫 벡터는 단어의 유사도를 표현하지 못한다는 단점이 있습니다. 예를 들어서 늑대, 호랑이, 강아지, 고양이라는 4개의 단어에 대해서 원-핫 인코딩을 해서 각각, [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]이라는 원-핫 벡터를 부여받았다고 합시다. 이때 원-핫 벡터로는 강아지와 늑대가 유사하고, 호랑이와 고양이가 유사하다는 것을 표현할 수가 없습니다. 좀 더 극단적으로는 강아지, 개, 냉장고라는 단어가 있을 때 강아지라는 단어가 개와 냉장고라는 단어 중 어떤 단어와 더 유사한지도 알 수 없습니다. 단어 간 유사성을 알 수 없다는 단점은 검색 시스템 등에서는 문제가 될 소지가 있습니다. 가령, 여행을 가려고 웹 검색창에 '삿포로 숙소'라는 단어를 검색한다고 합시다. 제대로 된 검색 시스템이라면, '삿포로 숙소'라는 검색어에 대해서 '삿포로 게스트 하우스', '삿포로 료칸', '삿포로 호텔'과 같은 유사 단어에 대한 결과도 함께 보여줄 수 있어야 합니다. 하지만 단어 간 유사성을 계산할 수 없다면, '게스트 하우스'와 '료칸'과 '호텔'이라는 연관 검색어를 보여줄 수 없습니다. 이러한 단점을 해결하기 위해 단어의 잠재 의미를 반영하여 다차원 공간에 벡터화하는 기법으로 크게 두 가지가 있습니다. 첫째는 카운트 기반의 벡터화 방법인 LSA(잠재 의미 분석), HAL 등이 있으며, 둘째는 예측 기반으로 벡터화하는 NNLM, RNNLM, Word2Vec, FastText 등이 있습니다. 그리고 카운트 기반과 예측 기반 두 가지 방법을 모두 사용하는 방법으로 GloVe라는 방법이 존재합니다. 여기서 언급한 방법들 중 대부분은 워드 임베딩 챕터에서 다루게 됩니다. 02-09 데이터의 분리(Splitting Data) 머신 러닝 모델을 학습시키고 평가하기 위해서는 데이터를 적절하게 분리하는 작업이 필요합니다. 이 책에서는 대부분의 경우에서 지도 학습(Supervised Learning)을 다루는데, 이번에는 지도 학습을 위한 데이터 분리 작업에 대해서 배웁니다. import pandas as pd import numpy as np from sklearn.model_selection import train_test_split 1. 지도 학습(Supervised Learning) 지도 학습의 훈련 데이터는 문제지를 연상케 합니다. 지도 학습의 훈련 데이터는 정답이 무엇인지 맞춰 하는 '문제'에 해당되는 데이터와 레이블이라고 부르는 '정답'이 적혀있는 데이터로 구성되어 있습니다. 쉽게 비유하면, 기계는 정답이 적혀져 있는 문제지를 문제와 정답을 함께 보면서 열심히 공부하고, 향후에 정답이 없는 문제에 대해서도 정답을 잘 예측해야 합니다. 예를 들어 스팸 메일 분류기를 위한 데이터 같은 경우에는 메일의 본문과 해당 메일이 정상 메일인지, 스팸 메일인지 적혀있는 레이블로 구성돼 있습니다. 예를 들어 아래와 같은<NAME>의 데이터가 약 20,000개 있다고 가정해 보겠습니다. 이 데이터는 두 개의 열로 구성되는데, 바로 메일의 본문에 해당되는 첫 번째 열과 해당 메일이 정상 메일인지 스팸 메일인지가 적혀있는 정답에 해당되는 두 번째 열입니다. 그리고 이러한 데이터 배열이 총 20,000개의 행을 가집니다. 텍스트(메일의 내용) 레이블(스팸 여부) 당신에게 드리는 마지막 혜택! ... 스팸 메일 내일 뵐 수 있을지 확인 부탁... 정상 메일 ... ... (광고) 멋있어질 수 있는... 스팸 메일 기계를 지도하는 선생님의 입장이 되어보겠습니다. 기계를 훈련시키기 위해서 데이터를 총 4개로 나눕니다. 우선 메일의 내용이 담긴 첫 번째 열을 X에 저장합니다. 그리고 메일이 스팸인지 정상인지 정답이 적혀있는 두 번째 열을 y에 저장합니다. 이제 문제지에 해당되는 20,000개의 X와 정답지에 해당되는 20,000개의 y가 생겼습니다. 그리고 이제 이 X와 y에 대해서 일부 데이터를 또다시 분리합니다. 이는 문제지를 다 공부하고 나서 실력을 평가하기 위해서 시험(test) 용으로 일부로 일부 문제와 해당 문제의 정답지를 분리해놓는 것입니다. 여기서는 2,000개를 분리한다고 가정하겠습니다. 이때 분리 시에는 여전히 X와 y의 매핑 관계를 유지해야 합니다. 어떤 X(문제)에 대한 어떤 y(정답)인지 바로 찾을 수 있어야 합니다. 이렇게 되면 학습용에 해당되는 18,000개의 X, y의 쌍과 시험용에 해당되는 2000개의 X, y의 쌍이 생깁니다 이 책에서는 이 유형의 데이터들에게 일반적으로 다음과 같은 변수명을 부여합니다. <훈련 데이터> X_train : 문제지 데이터 y_train : 문제지에 대한 정답 데이터. <테스트 데이터> X_test : 시험지 데이터. y_test : 시험지에 대한 정답 데이터. 기계는 이제부터 X_train과 y_train에 대해서 학습을 합니다. 기계는 학습 상태에서는 정답지인 y_train을 볼 수 있기 때문에 18,000개의 문제지 X_train과 y_train을 함께 보면서 어떤 메일 내용일 때 정상 메일인지 스팸 메일인지를 열심히 규칙을 도출해나가면서 정리해나갑니다. 그리고 학습을 다 한 기계에게 y_test는 보여주지 않고, X_test에 대해서 정답을 예측하게 합니다. 그리고 기계가 예측한 답과 실제 정답인 y_test를 비교하면서 기계가 정답을 얼마나 맞췄는지를 평가합니다. 이 수치가 기계의 정확도(Accuracy)가 됩니다. 2. X와 y 분리하기 1) zip 함수를 이용하여 분리하기 zip() 함수는 동일한 개수를 가지는 시퀀스 자료형에서 각 순서에 등장하는 원소들끼리 묶어주는 역할을 합니다. 리스트의 리스트 구성에서 zip 함수는 X와 y를 분리하는데 유용합니다. 우선 zip 함수가 어떤 역할을 하는지 확인해 보도록 하겠습니다. X, y = zip(['a', 1], ['b', 2], ['c', 3]) print('X 데이터 :',X) print('y 데이터 :',y) X 데이터 : ('a', 'b', 'c') y 데이터 : (1, 2, 3) 각 데이터에서 첫 번째로 등장한 원소들끼리 묶이고, 두 번째로 등장한 원소들끼리 묶인 것을 볼 수 있습니다. # 리스트의 리스트 또는 행렬 또는 뒤에서 배울 개념인 2D 텐서. sequences = [['a', 1], ['b', 2], ['c', 3]] X, y = zip(*sequences) print('X 데이터 :',X) print('y 데이터 :',y) X 데이터 : ('a', 'b', 'c') y 데이터 : (1, 2, 3) 각 데이터에서 첫 번째로 등장한 원소들끼리 묶이고, 두 번째로 등장한 원소들끼리 묶인 것을 볼 수 있습니다. 이를 각각 X 데이터와 y 데이터로 사용할 수 있습니다. 2) 데이터 프레임을 이용하여 분리하기 values = [['당신에게 드리는 마지막 혜택!', 1], ['내일 뵐 수 있을지 확인 부탁드...', 0], ['도연 씨. 잘 지내시죠? 오랜 만입...', 0], ['(광고) AI로 주가를 예측할 수 있다!', 1]] columns = ['메일 본문', '스팸 메일 유무'] df = pd.DataFrame(values, columns=columns) df 데이터 프레임은 열의 이름으로 각 열에 접근이 가능하므로, 이를 이용하면 손쉽게 X 데이터와 y 데이터를 분리할 수 있습니다. X = df['메일 본문'] y = df['스팸 메일 유무'] X와 y 데이터를 출력해 보겠습니다. print('X 데이터 :',X.to_list()) print('y 데이터 :',y.to_list()) X 데이터 : ['당신에게 드리는 마지막 혜택!', '내일 뵐 수 있을지 확인 부탁드...', '도연 씨. 잘 지내시죠? 오랜 만입...', '(광고) AI로 주가를 예측할 수 있다!'] y 데이터 : [1, 0, 0, 1] 3) Numpy를 이용하여 분리하기 임의의 데이터를 만들어서 Numpy의 슬라이싱(slicing)을 사용하여 데이터를 분리해 봅시다. np_array = np.arange(0,16).reshape((4,4)) print('전체 데이터 :') print(np_array) 전체 데이터 : [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11] [12 13 14 15]] 마지막 열을 제외하고 X 데이터에 저장합니다. 마지막 열만을 y 데이터에 저장합니다. X = np_array[:, :3] y = np_array[:,3] print('X 데이터 :') print(X) print('y 데이터 :',y) X 데이터 : [[ 0 1 2] [ 4 5 6] [ 8 9 10] [12 13 14]] y 데이터 : [ 3 7 11 15] 3. 테스트 데이터 분리하기 이번에는 이미 X와 y가 분리된 데이터에 대해서 테스트 데이터를 분리하는 과정에 대해서 알아보겠습니다. 1) 사이킷 런을 이용하여 분리하기 사이킷런은 학습용 테스트와 테스트용 데이터를 쉽게 분리할 수 있게 해주는 train_test_split()를 지원합니다. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size= 0.2, random_state=1234) 각 인자는 다음을 의미합니다. train_size와 test_size는 둘 중 하나만 기재해도 됩니다. X : 독립 변수 데이터. (배열이나 데이터 프레임) y : 종속 변수 데이터. 레이블 데이터. test_size : 테스트용 데이터 개수를 지정한다. 1보다 작은 실수를 기재할 경우, 비율을 나타낸다. train_size : 학습용 데이터의 개수를 지정한다. 1보다 작은 실수를 기재할 경우, 비율을 나타낸다. random_state : 난수 시드 예를 들어보겠습니다. 임의로 X 데이터와 y 데이터를 생성했습니다. # 임의로 X와 y 데이터를 생성 X, y = np.arange(10).reshape((5, 2)), range(5) print('X 전체 데이터 :') print(X) print('y 전체 데이터 :') print(list(y)) X 전체 데이터 : [[0 1] [2 3] [4 5] [6 7] [8 9]] y 전체 데이터 : [0, 1, 2, 3, 4] 여기서는 7:3의 비율로 데이터를 분리합니다. train_test_split()은 기본적으로 데이터의 순서를 섞고 나서 훈련 데이터와 테스트 데이터를 분리합니다. 만약, random_state의 값을 특정 숫자로 기재해 준 뒤에 다음에도 동일한 숫자로 기재해 주면 항상 동일한 훈련 데이터와 테스트 데이터를 얻을 수 있습니다. 하지만 값을 변경하면 다른 순서로 섞인 채 분리되므로 이전과 다른 훈련 데이터와 테스트 데이터를 얻습니다. 실습을 통해서 이해해 봅시다. random_state 값을 임의로 1234로 지정했습니다. # 7:3의 비율로 훈련 데이터와 테스트 데이터 분리 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234) 70%의 비율로 분리된 X의 훈련 데이터와 30%의 비율로 분리된 X의 테스트 데이터입니다. print('X 훈련 데이터 :') print(X_train) print('X 테스트 데이터 :') print(X_test) X 훈련 데이터 : [[2 3] [4 5] [6 7]] X 테스트 데이터 : [[8 9] [0 1]] 70%의 비율로 분리된 y의 훈련 데이터와 30%의 비율로 분리된 y의 테스트 데이터입니다. print('y 훈련 데이터 :') print(y_train) print('y 테스트 데이터 :') print(y_test) y 훈련 데이터 : [1, 2, 3] y 테스트 데이터 : [4, 0] 출력 결과를 보면 데이터를 어느 중간 부분에서 앞과 뒤로 자른 것이 아니라 앞에 있던 샘플이 뒤로 가기도 하고, 데이터의 순서가 전반적으로 섞이면서 분리된 것을 확인할 수 있습니다. random_state의 의미를 이해하기 위해서 이번에는 random_state의 값을 임의로 다른 값인 1을 주고 다시 분리해 보겠습니다. 그리고 y 데이터를 출력해 봅시다. # random_state의 값을 변경 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1) print('y 훈련 데이터 :') print(y_train) print('y 테스트 데이터 :') print(y_test) y 훈련 데이터 : [4, 0, 3] y 테스트 데이터 : [2, 1] random_state 값이 1234일 때와 전혀 다른 y 데이터가 출력됩니다. 데이터가 다른 순서로 섞였다는 의미입니다. 이번에는 다시 random_state의 값을 1234로 주고 다시 y 데이터를 출력해 봅시다. # random_state을 이전의 값이었던 1234로 변경 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234) print('y 훈련 데이터 :') print(y_train) print('y 테스트 데이터 :') print(y_test) y 훈련 데이터 : [1, 2, 3] y 테스트 데이터 : [4, 0] 이전과 동일한 y 데이터가 출력됩니다. random_state의 값을 고정해두면 실행할 때마다 항상 동일한 순서로 데이터를 섞으므로, 동일한 코드를 다음에 재현하고자 할 때 사용할 수 있습니다. 2) 수동으로 분리하기 데이터를 분리하는 방법 중 하나는 수동으로 분리하는 것입니다. 우선 임의로 X 데이터와 y 데이터를 만들어보겠습니다. # 실습을 위해 임의로 X와 y가 이미 분리된 데이터를 생성 X, y = np.arange(0,24).reshape((12,2)), range(12) print('X 전체 데이터 :') print(X) print('y 전체 데이터 :') print(list(y)) X 전체 데이터 : [[ 0 1] [ 2 3] [ 4 5] [ 6 7] [ 8 9] [10 11] [12 13] [14 15] [16 17] [18 19] [20 21] [22 23]] y 전체 데이터 : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] 훈련 데이터의 개수와 테스트 데이터의 개수를 정해보겠습니다. num_of_train은 훈련 데이터의 개수를 의미하며, num_of_test는 테스트 데이터의 개수를 의미합니다. num_of_train = int(len(X) * 0.8) # 데이터의 전체 길이의 80%에 해당하는 길이값을 구한다. num_of_test = int(len(X) - num_of_train) # 전체 길이에서 80%에 해당하는 길이를 뺀다. print('훈련 데이터의 크기 :',num_of_train) print('테스트 데이터의 크기 :',num_of_test) 훈련 데이터의 크기 : 9 테스트 데이터의 크기 : 3 아직 훈련 데이터와 테스트 데이터를 나눈 것이 아니라 이 두 개의 개수를 몇 개로 할지 정하기만 한 상태입니다. 여기서 num_of_test를 len(X) * 0.2로 계산해서는 안 됩니다. 데이터에 누락이 발생할 수 있습니다. 예를 들어서 전체 데이터의 개수가 4,518이라고 가정했을 때 4,518의 80%의 값은 3,614.4로 소수점을 내리면 3,614가 됩니다. 또한 4,518의 20%의 값은 903.6으로 소수점을 내리면 903이 됩니다. 그리고 3,614 + 903 = 4517이므로 데이터 1개가 누락이 됩니다. 그러므로 어느 한 쪽을 먼저 계산하고 그 값만큼 제외하는 방식으로 계산해야 합니다. X_test = X[num_of_train:] # 전체 데이터 중에서 20%만큼 뒤의 데이터 저장 y_test = y[num_of_train:] # 전체 데이터 중에서 20%만큼 뒤의 데이터 저장 X_train = X[:num_of_train] # 전체 데이터 중에서 80%만큼 앞의 데이터 저장 y_train = y[:num_of_train] # 전체 데이터 중에서 80%만큼 앞의 데이터 저장 데이터를 나눌 때는 num_of_train와 같이 하나의 변수만 사용하면 데이터의 누락을 방지할 수 있습니다. 앞에서 구한 데이터의 개수만큼 훈련 데이터와 테스트 데이터를 분할합니다. 그리고 테스트 데이터를 출력하여 정상적으로 분리되었는지 확인합니다. print('X 테스트 데이터 :') print(X_test) print('y 테스트 데이터 :') print(list(y_test)) X 테스트 데이터 : [[18 19] [20 21] [22 23]] y 테스트 데이터 : [9, 10, 11] 각 길이가 3인 것을 확인했습니다. train_test_split()과 다른 점은 데이터가 섞이지 않은 채 어느 지점에서 데이터를 앞과 뒤로 분리했다는 점입니다. 만약, 수동으로 분리하게 된다면 데이터를 분리하기 전에 수동으로 데이터를 섞는 과정이 필요할 수 있습니다. 실제로 뒤에서 이러한 실습들을 진행합니다. 02-10 한국어 전처리 패키지(Text Preprocessing Tools for Korean Text) 유용한 한국어 전처리 패키지를 정리해 봅시다. 앞서 소개한 형태소와 문장 토크나이징 도구들인 KoNLPy와 KSS(Korean Sentence Splitter)와 함께 유용하게 사용할 수 있는 패키지들입니다. 1. PyKoSpacing pip install git+https://github.com/haven-jeon/PyKoSpacing.git 전희 원님이 개발한 PyKoSpacing은 띄어쓰기가 되어있지 않은 문장을 띄어쓰기를 한 문장으로 변환해 주는 패키지입니다. PyKoSpacing은 대용량 코퍼스를 학습하여 만들어진 띄어쓰기 딥 러닝 모델로 준수한 성능을 가지고 있습니다. sent = '김철수는 극중 두 인격의 사나이 이광수 역을 맡았다. 철수는 한국 유일의 태권도 전승자를 가리는 결전의 날을 앞두고 10년간 함께 훈련한 사형인 유연재(김광수 분)를 찾으러 속세로 내려온 인물이다.' 임의의 문장을 임의로 띄어쓰기가 없는 문장으로 만들었습니다. new_sent = sent.replace(" ", '') # 띄어쓰기가 없는 문장 임의로 만들기 print(new_sent) 김철수는극중두인격의사나이이광수역을맡았다.철수는한국유일의태권도전승자를가리는결전의날을앞두고10년간함께훈련한사형인유연재(김광수분)를찾으러속세로내려온인물이다. 이를 PyKoSpacing의 입력으로 사용하여 원 문장과 비교해 봅시다. from pykospacing import Spacing spacing = Spacing() kospacing_sent = spacing(new_sent) print(sent) print(kospacing_sent) 김철수는 극중 두 인격의 사나이 이광수 역을 맡았다. 철수는 한국 유일의 태권도 전승자를 가리는 결전의 날을 앞두고 10년간 함께 훈련한 사형인 유연재(김광수 분)를 찾으러 속세로 내려온 인물이다. 김철수는 극중 두 인격의 사나이 이광수 역을 맡았다. 철수는 한국 유일의 태권도 전승자를 가리는 결전의 날을 앞두고 10년간 함께 훈련한 사형인 유연재(김광수 분)를 찾으러 속세로 내려온 인물이다. 정확하게 결과가 일치합니다. 2. Py-Hanspell pip install git+https://github.com/ssut/py-hanspell.git Py-Hanspell은 네이버 한글 맞춤법 검사기를 바탕으로 만들어진 패키지입니다. from hanspell import spell_checker sent = "맞춤법 틀리면 왜 안돼? 쓰고 싶은 대로 쓰면 되지 " spelled_sent = spell_checker.check(sent) hanspell_sent = spelled_sent.checked print(hanspell_sent) 맞춤법 틀리면 왜 안돼? 쓰고 싶은 대로 쓰면 되지 이 패키지는 띄어쓰기 또한 보정합니다. PyKoSpacing에 사용한 예제를 그대로 사용해 봅시다. spelled_sent = spell_checker.check(new_sent) hanspell_sent = spelled_sent.checked print(hanspell_sent) print(kospacing_sent) # 앞서 사용한 kospacing 패키지에서 얻은 결과 김철수는 극 중 두 인격의 사나이 이광수 역을 맡았다. 철수는 한국 유일의 태권도 전승자를 가리는 결전의 날을 앞두고 10년간 함께 훈련한 사형인 유연제(김광수 분)를 찾으러 속세로 내려온 인물이다. 김철수는 극중 두 인격의 사나이 이광수 역을 맡았다. 철수는 한국 유일의 태권도 전승자를 가리는 결전의 날을 앞두고 10년간 함께 훈련한 사형인 유연재(김광수 분)를 찾으러 속세로 내려온 인물이다. PyKoSpacing과 결과가 거의 비슷하지만 조금 다릅니다. 3. SOYNLP를 이용한 단어 토큰화 soynlp는 품사 태깅, 단어 토큰화 등을 지원하는 단어 토크 나이저입니다. 비지도 학습으로 단어 토큰화를 한다는 특징을 갖고 있으며, 데이터에 자주 등장하는 단어들을 단어로 분석합니다. soynlp 단어 토크 나이저는 내부적으로 단어 점수 표로 동작합니다. 이 점수는 응집 확률(cohesion probability)과 브랜칭 엔트로피(branching entropy)를 활용합니다. pip install soynlp 1. 신조어 문제 soynlp를 소개하기 전에 기존의 형태소 분석기가 가진 문제는 무엇이었는지, SOYNLP가 어떤 점에서 유용한지 정리해 봅시다. 기존의 형태소 분석기는 신조어나 형태소 분석기에 등록되지 않은 단어 같은 경우에는 제대로 구분하지 못하는 단점이 있었습니다. from konlpy.tag import Okt tokenizer = Okt() print(tokenizer.morphs('에이비식스<NAME> 1월 최애돌 기부 요정')) ['에이', '비식스', '이대', '휘', '1월', '최애', '돌', '기부', '요정'] 에이비 식스는 아이돌의 이름이고,<NAME>는 에이비 식스의 멤버이며, 최애돌은 최고로 애정 하는 캐릭터라는 뜻이지만 위의 형태소 분석 결과에서는 전부 분리된 결과를 보여줍니다. 그렇다면 텍스트 데이터에서 특정 문자 시퀀스가 함께 자주 등장하는 빈도가 높고, 앞뒤로 조사 또는 완전히 다른 단어가 등장하는 것을 고려해서 해당 문자 시퀀스를 형태소라고 판단하는 단어 토크 나이저라면 어떨까요? 예를 들어 에이비 식스라는 문자열이 자주 연결되어 등장한다면 한 단어라고 판단하고, 또한 에이비 식스라는 단어 앞, 뒤에 '최고', '가수', '실력'과 같은 독립된 다른 단어들이 계속해서 등장한다면 에이비 식스를 한 단어로 파악하는 식이지요. 그리고 이런 아이디어를 가진 단어 토크 나이저가 soynlp입니다. 2. 학습하기 soynlp는 기본적으로 학습에 기반한 토크 나이저이므로 학습에 필요한 한국어 문서를 다운로드합니다. import urllib.request from soynlp import DoublespaceLineCorpus from soynlp.word import WordExtractor urllib.request.urlretrieve("https://raw.githubusercontent.com/lovit/soynlp/master/tutorials/2016-10-20.txt", filename="2016-10-20.txt") 훈련 데이터를 다수의 문서로 분리합니다. # 훈련 데이터를 다수의 문서로 분리 corpus = DoublespaceLineCorpus("2016-10-20.txt") len(corpus) 30091 총 3만 91개의 문서가 존재합니다. 상위 3개의 문서만 출력해 봅시다. 지면의 한계로 중략하였습니다. i = 0 for document in corpus: if len(document) > 0: print(document) i = i+1 if i == 3: break 19 1990 52 1 22 오패산 터널 총격전 용의자 검거 서울 연합뉴스 경찰 관계자들이 19일 오후 서울 강북구 오패산 터널 인근에서 사제 총기를 발사해 경찰을 살해한 용의자 성모 씨를 검거하고 있다 ... 중략 ... 숲에서 발견됐고 일부는 성씨가 소지한 가방 안에 있었다 테헤란 연합뉴스 강훈상 특파원 이용 승객수 기준 세계 최대 공항인 아랍에미리트 두바이 국제공항은 19일 현지시간 이 공항을 이륙하는 모든 항공기의 탑승객은 삼성전자의 갤럭시노트7을 휴대하면 안 된다고 밝혔다 ... 중략 ... 이런 조치는 두바이 국제공항뿐 아니라 신공항인 두바이 월드센터에도 적용된다 배터리 폭발 문제로 회수된 갤럭시노트7 연합뉴스 자료 사진 정상 출력되는 것을 확인하였습니다. soynlp는 학습 기반의 단어 토크 나이저이므로 기존의 KoNLPy에서 제공하는 형태소 분석기들과는 달리 학습 과정을 거쳐야 합니다. 이는 전체 코퍼스로부터 응집 확률과 브랜칭 엔트로피 단어 점수표를 만드는 과정입니다. WordExtractor.extract()를 통해서 전체 코퍼스에 대해 단어 점수표를 계산합니다. word_extractor = WordExtractor() word_extractor.train(corpus) word_score_table = word_extractor.extract() training was done. used memory 5.186 Gb all cohesion probabilities was computed. # words = 223348 all branching entropies was computed # words = 361598 all accessor variety was computed # words = 361598 학습이 완료되었습니다. 3. SOYNLP의 응집 확률(cohesion probability) 응집 확률은 내부 문자열(substring)이 얼마나 응집하여 자주 등장하는지를 판단하는 척도입니다. 응집 확률은 문자열을 문자 단위로 분리하여 내부 문자열을 만드는 과정에서 왼쪽부터 순서대로 문자를 추가하면서 각 문자열이 주어졌을 때 그다음 문자가 나올 확률을 계산하여 누적 곱을 한 값입니다. 이 값이 높을수록 전체 코퍼스에서 이 문자열 시퀀스는 하나의 단어로 등장할 가능성이 높습니다. 수식은 아래와 같습니다. '반포 한강공원에'라는 7의 길이를 가진 문자 시퀀스에 대해서 각 내부 문자열의 스코어를 구하는 과정은 아래와 같습니다. 실습을 통해 직접 응집 확률을 계산해 보겠습니다. '반포한'의 응집 확률을 계산해 봅시다. word_score_table["반포한"].cohesion_forward 0.08838002913645132 그렇다면 '반포 한강'의 응집 확률은 '반포한'의 응집 확률보다 높을까요? word_score_table["반포 한강"].cohesion_forward 0.19841268168224552 '반포 한강'은 '반포한'보다 응집 확률이 높습니다. 그렇다면 '반포한강공'은 어떨까요? word_score_table["반포한강공"].cohesion_forward 0.2972877884078849 역시나 '반포 한강'보다 응집 확률이 높습니다. '반포 한강공원'은 어떨까요? word_score_table["반포 한강공원"].cohesion_forward 0.37891487632839754 '반포한강공'보다 응집 확률이 높습니다. 여기다가 조사 '에'를 붙인 '반포 한강공원에'는 어떨까요? word_score_table["반포 한강공원에"].cohesion_forward 0.33492963377557666 오히려 '반포 한강공원'보다 응집도가 낮아집니다. 결국 결합 도는 '반포 한강공원'일 때가 가장 높았습니다. 응집도를 통해 판단하기에 하나의 단어로 판단하기에 가장 적합한 문자열은 '반포 한강공원'이라고 볼 수 있겠습니다. 4. SOYNLP의 브랜칭 엔트로피(branching entropy) Branching Entropy는 확률 분포의 엔트로피 값을 사용합니다. 이는 주어진 문자열에서 얼마나 다음 문자가 등장할 수 있는지를 판단하는 척도입니다. 퀴즈를 하나 내보겠습니다. 제가 어떤 단어를 생각 중인데, 한 문자씩 말해드릴 테니까 매번 다음 문자를 맞추는 것이 퀴즈입니다. 첫 번째 문자는 '디'입니다. 다음에 등장할 문자를 맞춰보세요. 솔직히 가늠이 잘 안 가지요? '디'로 시작하는 단어가 얼마나 많은데요. 정답은 '스'입니다. 이제 '디스'까지 나왔네요. '디스 '다음 문자는 뭘까요? '디스카운트'라는 단어가 있으니까 '카'일까? 아니면 '디스코드'라는 단어가 있으니까 '코'인가? 생각해 보니 '디스코'가 정답일 수도 있겠네요. 그러면 '코'인가? '디스아너드'라는 게임이 있으니까 '아'? 이 단어들을 생각하신 분들은 전부 틀렸습니다. 정답은 '플'이었습니다. '디스플'까지 왔습니다. 다음 문자 맞춰보세요. 이제 좀 명백해집니다. 정답은 '레'입니다. '디스플레이' 다음에는 어떤 문자일까요? 정답은 '이'입니다. 제가 생각한 단어는 '디스플레이'였습니다. 브랜칭 엔트로피를 주어진 문자 시퀀스에서 다음 문자 예측을 위해 헷갈리는 정도로 비유해 봅시다. 브랜칭 엔트로피의 값은 하나의 완성된 단어에 가까워질수록 문맥으로 인해 점점 정확히 예측할 수 있게 되면서 점점 줄어드는 양상을 보입니다. word_score_table["디스"].right_branching_entropy 1.6371694761537934 word_score_table["디스플"].right_branching_entropy -0.0 '디스' 다음에는 다양한 문자가 올 수 있으니까 1.63이라는 값을 가지는 반면, '디스플'이라는 문자열 다음에는 다음 문자로 '레'가 오는 것이 너무나 명백하기 때문에 0이란 값을 가집니다. word_score_table["디스플레이"].right_branching_entropy -0.0 word_score_table["디스플레이"].right_branching_entropy 3.1400392861792916 갑자기 값이 증가합니다. 그 이유는 문자 시퀀스 '디스플레이'라는 문자 시퀀스 다음에는 조사나 다른 단어와 같은 다양한 경우가 있을 수 있기 때문입니다. 이는 하나의 단어가 끝나면 그 경계 부분부터 다시 브랜칭 엔트로피 값이 증가하게 됨을 의미합니다. 그리고 이 값으로 단어를 판단하는 것이 가능하겠죠? 5. SOYNLP의 L tokenizer 한국어는 띄어쓰기 단위로 나눈 어절 토큰은 주로 L 토큰 + R 토큰의<NAME>을 가질 때가 많습니다. 예를 들어서 '공원에'는 '공원 +에'로 나눌 수 있겠지요. 또는 '공부하는'은 '공부 + 하는'으로 나눌 수도 있을 것입니다. L 토크 나이저는 L 토큰 + R 토큰으로 나누되, 분리 기준을 점수가 가장 높은 L 토큰을 찾아내는 원리를 가지고 있습니다. from soynlp.tokenizer import LTokenizer scores = {word:score.cohesion_forward for word, score in word_score_table.items()} l_tokenizer = LTokenizer(scores=scores) l_tokenizer.tokenize("국제사회와 우리의 노력들로 범죄를 척결하자", flatten=False) [('국제사회', '와'), ('우리', '의'), ('노력', '들로'), ('범죄', '를'), ('척결', '하자')] 6. 최대 점수 토크 나이저 최대 점수 토크 나이저는 띄어쓰기가 되지 않는 문장에서 점수가 높은 글자 시퀀스를 순차적으로 찾아내는 토크 나이저입니다. 띄어쓰기가 되어 있지 않은 문장을 넣어서 점수를 통해 토큰화된 결과를 보겠습니다. from soynlp.tokenizer import MaxScoreTokenizer maxscore_tokenizer = MaxScoreTokenizer(scores=scores) maxscore_tokenizer.tokenize("국제사회와 우리의 노력들로 범죄를 척결하자") ['국제사회', '와', '우리', '의', '노력', '들로', '범죄', '를', '척결', '하자'] 4. SOYNLP를 이용한 반복되는 문자 정제 SNS나 채팅 데이터와 같은 한국어 데이터의 경우에는 ㅋㅋ, ㅎㅎ 등의 이모티콘의 경우 불필요하게 연속되는 경우가 많은데 ㅋㅋ, ㅋㅋㅋ, ㅋㅋㅋㅋ와 같은 경우를 모두 서로 다른 단어로 처리하는 것은 불필요합니다. 이에 반복되는 것은 하나로 정규화시켜줍니다. from soynlp.normalizer import * print(emoticon_normalize('앜ㅋㅋㅋㅋ이영화존잼쓰ㅠㅠㅠㅠㅠ', num_repeats=2)) print(emoticon_normalize('앜ㅋㅋㅋㅋㅋㅋㅋㅋㅋ이영화존잼쓰ㅠㅠㅠㅠ', num_repeats=2)) print(emoticon_normalize('앜ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ이영화존잼쓰ㅠㅠㅠㅠㅠㅠ', num_repeats=2)) print(emoticon_normalize('앜ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ이영화존잼쓰ㅠㅠㅠㅠㅠㅠㅠㅠ', num_repeats=2)) 아ㅋㅋ영화존잼쓰ㅠㅠ 아ㅋㅋ영화존잼쓰ㅠㅠ 아ㅋㅋ영화존잼쓰ㅠㅠ 아ㅋㅋ영화존잼쓰ㅠㅠ 의미 없게 반복되는 것은 비단 이모티콘에 한정되지 않습니다. print(repeat_normalize('와하하하하하하하하하핫', num_repeats=2)) print(repeat_normalize('와하하 하하 하하 핫', num_repeats=2)) print(repeat_normalize('와하하 하하 핫', num_repeats=2)) 와하하 핫 와하하 핫 와하하 핫 5. Customized KoNLPy 영어권 언어는 띄어쓰기만 해도 단어들이 잘 분리되지만, 한국어는 그렇지 않다고 앞에서 몇 차례 언급했었습니다. 한국어 데이터를 사용하여 모델을 구현하는 것만큼 이번에는 형태소 분석기를 사용해서 단어 토큰화를 해보겠습니다. 그런데 형태소 분석기를 사용할 때, 이런 상황에 봉착한다면 어떻게 해야 할까요? 형태소 분석 입력 : '은경이는 사무실로 갔습니다.' 형태소 분석 결과 : ['은', '경이', '는', '사무실', '로', '갔습니다', '.'] 사실 위문장에서 '은경이'는 사람 이름이므로 제대로 된 결과를 얻기 위해서는 '은', '경이'와 같이 글자가 분리되는 것이 아니라 '은경이' 또는 최소한 '은경'이라는 단어 토큰을 얻어야만 합니다. 이런 경우에는 형태소 분석기에 사용자 사전을 추가해 줄 수 있습니다. '은경이'는 하나의 단어이기 때문에 분리하지 말라고 형태소 분석기에 알려주는 것입니다. 사용자 사전을 추가하는 방법은 형태소 분석기마다 다른데, 생각보다 복잡한 경우들이 많습니다. 이번 실습에서는 Customized Konlpy라는 사용자 사전 추가가 매우 쉬운 패키지를 사용합니다. pip install customized_konlpy customized_konlpy에서 제공하는 형태소 분석기 Twitter를 사용하여 앞서 소개했던 예문을 단어 토큰화해봅시다. from ckonlpy.tag import Twitter twitter = Twitter() twitter.morphs('은경이는 사무실로 갔습니다.') ['은', '경이', '는', '사무실', '로', '갔습니다', '.'] 앞서 소개한 예시와 마찬가지로 '은경이'라는 단어가 '은', '경이'와 같이 분리됩니다. 이때, 형태소 분석기 Twitter에 add_dictionary('단어', '품사')와 같은<NAME>으로 사전 추가를 해줄 수 있습니다. twitter.add_dictionary('은경이', 'Noun') 제대로 반영되었는지 동일한 예문을 다시 형태소 분석해 봅시다. twitter.morphs('은경이는 사무실로 갔습니다.') ['은경이', '는', '사무실', '로', '갔습니다', '.'] '은경이'라는 단어가 제대로 하나의 토큰으로 인식되는 것을 확인할 수 있습니다. 03. 언어 모델(Language Model) 언어 모델(Languagel Model)이란 단어 시퀀스(문장)에 확률을 할당하는 모델을 말합니다. 어떤 문장들이 있을 때, 기계가 이 문장은 적절해! 이 문장은 말이 안 돼!라고 사람처럼 정확히 판단할 수 있다면, 기계의 자연어 처리의 성능이 뛰어나다 할 수 있습니다. 이번 챕터에서는 통계에 기반한 전통적인 언어 모델(Statistical Languagel Model, SLM)에 대해서 학습합니다. 통계에 기반한 언어 모델은 우리가 실제 사용하는 자연어를 근사하기에는 많은 한계가 있었고, 요즘 들어 인공 신경망이 그러한 한계를 많이 해결해 주면서 통계 기반 언어 모델은 많이 사용 용도가 줄었습니다. 하지만 그럼에도 통계 기반 방법론에 대한 이해는 언어 모델에 대한 전체적인 시야를 갖는 일에 도움이 됩니다. 03-01 언어 모델(Language Model)이란? 언어 모델(Language Model, LM)은 언어라는 현상을 모델링하고 자 단어 시퀀스(문장)에 확률을 할당(assign) 하는 모델입니다. 언어 모델을 만드는 방법은 크게는 통계를 이용한 방법과 인공 신경망을 이용한 방법으로 구분할 수 있습니다. 최근에는 통계를 이용한 방법보다는 인공 신경망을 이용한 방법이 더 좋은 성능을 보여주고 있습니다. 최근 핫한 자연어 처리의 기술인 GPT나 BERT 또한 인공 신경망 언어 모델의 개념을 사용하여 만들어졌습니다. 이번 챕터에서는 언어 모델의 개념과 언어 모델의 전통적 접근 방식인 통계적 언어 모델에 대해서 배웁니다. 1. 언어 모델(Language Model) 언어 모델은 단어 시퀀스에 확률을 할당(assign) 하는 일을 하는 모델입니다. 이를 조금 풀어서 쓰면, 언어 모델은 가장 자연스러운 단어 시퀀스를 찾아내는 모델입니다. 단어 시퀀스에 확률을 할당하게 하기 위해서 가장 보편적으로 사용되는 방법은 언어 모델이 이전 단어들이 주어졌을 때 다음 단어를 예측하도록 하는 것입니다. 다른 유형의 언어 모델로는 주어진 양쪽의 단어들로부터 가운데 비어있는 단어를 예측하는 언어 모델이 있습니다. 이는 문장의 가운데에 있는 단어를 비워놓고 양쪽의 문맥을 통해서 빈칸의 단어인지 맞추는 고등학교 수험 시험의 빈칸 추론 문제와 비슷합니다. 이 유형의 언어 모델은 BERT 챕터에서 다루게 될 예정이고, 그때까지는 이전 단어들로부터 다음 단어를 예측하는 방식에만 집중합니다. 언어 모델에 -ing를 붙인 언어 모델링(Language Modeling)은 주어진 단어들로부터 아직 모르는 단어를 예측하는 작업을 말합니다. 즉, 언어 모델이 이전 단어들로부터 다음 단어를 예측하는 일은 언어 모델링입니다. 자연어 처리로 유명한 스탠퍼드 대학교에서는 언어 모델을 문법(grammar)이라고 비유하기도 합니다. 언어 모델이 단어들의 조합이 얼마나 적절한지, 또는 해당 문장이 얼마나 적합한지를 알려주는 일을 하는 것이 마치 문법이 하는 일 같기 때문입니다. 2. 단어 시퀀스의 확률 할당 자연어 처리에서 단어 시퀀스에 확률을 할당하는 일이 왜 필요할까요? 예를 들어보겠습니다. 여기서 대문자 P는 확률을 의미합니다. a. 기계 번역(Machine Translation): P(나는 버스를 탔다) > P(나는 버스를 태운다) : 언어 모델은 두 문장을 비교하여 좌측의 문장의 확률이 더 높다고 판단합니다. b. 오타 교정(Spell Correction) 선생님이 교실로 부리나케 P(달려갔다) > P(잘려갔다) : 언어 모델은 두 문장을 비교하여 좌측의 문장의 확률이 더 높다고 판단합니다. c. 음성 인식(Speech Recognition) P(나는 메롱을 먹는다) < P(나는 멜론을 먹는다) : 언어 모델은 두 문장을 비교하여 우측의 문장의 확률이 더 높다고 판단합니다. 언어 모델은 위와 같이 확률을 통해 보다 적절한 문장을 판단합니다. 3. 주어진 이전 단어들로부터 다음 단어 예측하기 언어 모델은 단어 시퀀스에 확률을 할당하는 모델입니다. 그리고 단어 시퀀스에 확률을 할당하기 위해서 가장 보편적으로 사용하는 방법은 이전 단어들이 주어졌을 때, 다음 단어를 예측하도록 하는 것입니다. 이를 조건부 확률로 표현해 보겠습니다. A. 단어 시퀀스의 확률 하나의 단어를, 단어 시퀀스를 대문자라고 한다면, 개의 단어가 등장하는 단어 시퀀스의 확률은 다음과 같습니다. ( ) P ( 1 w, 3 w, 5. . w) B. 다음 단어 등장 확률 다음 단어 등장 확률을 식으로 표현해 보겠습니다. -1개의 단어가 나열된 상태에서 번째 단어의 확률은 다음과 같습니다. ( n w, . , n 1 ) |의 기호는 조건부 확률(conditional probability)을 의미합니다. 예를 들어 다섯 번째 단어의 확률은 아래와 같습니다. ( 5 w, 2 w, 4 ) 전체 단어 시퀀스의 확률은 모든 단어가 예측되고 나서야 알 수 있으므로 단어 시퀀스의 확률은 다음과 같습니다. ( ) P ( 1 w, 3 w, 5. . n ) ∏ = n ( i w, . , 4. 언어 모델의 간단한 직관 비행기를 타려고 공항에 갔는데 지각을 하는 바람에 비행기를 [?]라는 문장이 있습니다. '비행기를' 다음에 어떤 단어가 오게 될지 사람은 쉽게 '놓쳤다'라고 예상할 수 있습니다. 우리 지식에 기반하여 나올 수 있는 여러 단어들을 후보에 놓고 놓쳤다는 단어가 나올 확률이 가장 높다고 판단하였기 때문입니다. 그렇다면 기계에게 위문장을 주고, '비행기를' 다음에 나올 단어를 예측해 보라고 한다면 과연 어떻게 최대한 정확히 예측할 수 있을까요? 기계도 비슷합니다. 앞에 어떤 단어들이 나왔는지 고려하여 후보가 될 수 있는 여러 단어들에 대해서 확률을 예측해 보고 가장 높은 확률을 가진 단어를 선택합니다. 앞에 어떤 단어들이 나왔는지 고려하여 후보가 될 수 있는 여러 단어들에 대해서 등장 확률을 추정하고 가장 높은 확률을 가진 단어를 선택합니다. 5. 검색 엔진에서의 언어 모델의 예 검색 엔진이 입력된 단어들의 나열에 대해서 다음 단어를 예측하는 언어 모델을 사용하고 있습니다. 03-02 통계적 언어 모델(Statistical Language Model, SLM) 언어 모델의 전통적인 접근 방법인 통계적 언어 모델을 소개합니다. 통계적 언어 모델이 통계적인 접근 방법으로 어떻게 언어를 모델링 하는지 배워보겠습니다. 통계적 언어 모델(Statistical Language Model)은 줄여서 SLM이라고 합니다. 1. 조건부 확률 조건부 확률은 두 확률 ( ) P ( ) 에 대해서 아래와 같은 관계를 갖습니다. ( | ) P ( , ) P ( ) ( , ) P ( ) ( | ) 더 많은 확률에 대해서 일반화해봅시다. 4개의 확률이 조건부 확률의 관계를 가질 때, 아래와 같이 표현할 수 있습니다. ( , , , ) P ( ) ( | ) ( | , ) ( | , , ) 이를 조건부 확률의 연쇄 법칙(chain rule)이라고 합니다. 이제는 4개가 아닌 개에 대해서 일반화를 해봅시다. ( 1 x, 3. x) P ( 1 ) ( 2 x) ( 3 x, 2 ) . P ( n x 조건부 확률에 대한 정의를 통해 문장의 확률을 구해보겠습니다. 2. 문장에 대한 확률 문장 'An adorable little boy is spreading smiles'의 확률 ( An adorable little boy is spreading smiles ) 를 식으로 표현해 봅시다. 각 단어는 문맥이라는 관계로 인해 이전 단어의 영향을 받아 나온 단어입니다. 그리고 모든 단어로부터 하나의 문장이 완성됩니다. 그렇기 때문에 문장의 확률을 구하고자 조건부 확률을 사용하겠습니다. 앞서 언급한 조건부 확률의 일반화 식을 문장의 확률 관점에서 다시 적어보면 문장의 확률은 각 단어들이 이전 단어가 주어졌을 때 다음 단어로 등장할 확률의 곱으로 구성됩니다. ( 1 w, 3 w, 5. . n ) ∏ = n ( n w, . , n 1 ) 위의 문장에 해당 식을 적용해 보면 다음과 같습니다. ( An adorable little boy is spreading smiles ) P ( An ) P ( adorable|An ) P ( little|An adorable ) P ( boy|An adorable little ) P ( is|An adorable little boy ) P ( spreading|An adorable little boy is ) P ( smiles|An adorable little boy is spreading ) 문장의 확률을 구하기 위해서 각 단어에 대한 예측 확률들을 곱합니다. 3. 카운트 기반의 접근 문장의 확률을 구하기 위해서 다음 단어에 대한 예측 확률을 모두 곱한다는 것은 알았습니다. 그렇다면 SLM은 이전 단어로부터 다음 단어에 대한 확률은 어떻게 구할까요? 정답은 카운트에 기반하여 확률을 계산합니다. An adorable little boy가 나왔을 때, is가 나올 확률인 ( is|An adorable little boy ) 를 구해봅시다. (is|An adorable little boy ) count(An adorable little boy is ) count(An adorable little boy ) 그 확률은 위와 같습니다. 예를 들어 기계가 학습한 코퍼스 데이터에서 An adorable little boy가 100번 등장했는데 그다음에 is가 등장한 경우는 30번이라고 합시다. 이 경우 ( is|An adorable little boy ) 는 30%입니다. 4. 카운트 기반 접근의 한계 - 희소 문제(Sparsity Problem) 언어 모델은 실생활에서 사용되는 언어의 확률 분포를 근사 모델링 합니다. 실제로 정확하게 알아볼 방법은 없겠지만 현실에서도 An adorable little boy가 나왔을 때 is가 나올 확률이라는 것이 존재합니다. 이를 실제 자연어의 확률 분포, 현실에서의 확률 분포라고 명칭 합시다. 기계에게 많은 코퍼스를 훈련시켜서 언어 모델을 통해 현실에서의 확률 분포를 근사하는 것이 언어 모델의 목표입니다. 그런데 카운트 기반으로 접근하려고 한다면 갖고 있는 코퍼스(corpus). 즉, 다시 말해 기계가 훈련하는 데이터는 정말 방대한 양이 필요합니다. (is|An adorable little boy ) count(An adorable little boy is ) count(An adorable little boy ) 예를 들어 위와 같이 (is|An adorable little boy ) 를 구하는 경우에서 기계가 훈련한 코퍼스에 An adorable little boy is라는 단어 시퀀스가 없었다면 이 단어 시퀀스에 대한 확률은 0이 됩니다. 또는 An adorable little boy라는 단어 시퀀스가 없었다면 분모가 0이 되어 확률은 정의되지 않습니다. 그렇다면 코퍼스에 단어 시퀀스가 없다고 해서 이 확률을 0 또는 정의되지 않는 확률이라고 하는 것이 정확한 모델링 방법일까요? 아닙니다. 현실에선 An adorable little boy is라는 단어 시퀀스가 존재하고 또 문법에도 적합하므로 정답일 가능성 또한 높습니다. 이와 같이 충분한 데이터를 관측하지 못하여 언어를 정확히 모델링 하지 못하는 문제를 희소 문제(sparsity problem)라고 합니다. 위 문제를 완화하는 방법으로 바로 이어서 배우게 되는 n-gram 언어 모델이나 이 책에서 다루지는 않지만 스무딩이나 백오프와 같은 여러 가지 일반화(generalization) 기법이 존재합니다. 하지만 희소 문제에 대한 근본적인 해결책은 되지 못하였습니다. 결국 이러한 한계로 인해 언어 모델의 트렌드는 통계적 언어 모델에서 인공 신경망 언어 모델로 넘어가게 됩니다. 03-03 N-gram 언어 모델(N-gram Language Model) n-gram 언어 모델은 여전히 카운트에 기반한 통계적 접근을 사용하고 있으므로 SLM의 일종입니다. 다만, 앞서 배운 언어 모델과는 달리 이전에 등장한 모든 단어를 고려하는 것이 아니라 일부 단어만 고려하는 접근 방법을 사용합니다. 그리고 이때 일부 단어를 몇 개 보느냐를 결정하는데 이것이 n-gram에서의 n이 가지는 의미입니다. 1. 코퍼스에서 카운트하지 못하는 경우의 감소. SLM의 한계는 훈련 코퍼스에 확률을 계산하고 싶은 문장이나 단어가 없을 수 있다는 점입니다. 그리고 확률을 계산하고 싶은 문장이 길어질수록 갖고 있는 코퍼스에서 그 문장이 존재하지 않을 가능성이 높습니다. 다시 말하면 카운트할 수 없을 가능성이 높습니다. 그런데 다음과 같이 참고하는 단어들을 줄이면 카운트를 할 수 있을 가능성을 높일 수 있습니다. ( is|An adorable little boy ) P ( is|boy ) 가령, An adorable little boy가 나왔을 때 is가 나올 확률을 그냥 boy가 나왔을 때 is가 나올 확률로 생각해 보는 건 어떨까요? 갖고 있는 코퍼스에 An adorable little boy is가 있을 가능성보다는 boy is라는 더 짧은 단어 시퀀스가 존재할 가능성이 더 높습니다. 조금 지나친 일반화로 느껴진다면 아래와 같이 little boy가 나왔을 때 is가 나올 확률로 생각하는 것도 대안입니다. ( is|An adorable little boy ) P ( is|little boy ) 즉, 앞에서는 An adorable little boy가 나왔을 때 is가 나올 확률을 구하기 위해서는 An adorable little boy가 나온 횟수와 An adorable little boy is가 나온 횟수를 카운트해야만 했지만, 이제는 단어의 확률을 구하고자 기준 단어의 앞 단어를 전부 포함해서 카운트하는 것이 아니라, 앞 단어 중 임의의 개수만 포함해서 카운트하여 근사하자는 것입니다. 이렇게 하면 갖고 있는 코퍼스에서 해당 단어의 시퀀스를 카운트할 확률이 높아집니다. 2. N-gram 이때 임의의 개수를 정하기 위한 기준을 위해 사용하는 것이 n-gram입니다. n-gram은 n 개의 연속적인 단어 나열을 의미합니다. 갖고 있는 코퍼스에서 n 개의 단어 뭉치 단위로 끊어서 이를 하나의 토큰으로 간주합니다. 예를 들어서 문장 An adorable little boy is spreading smiles이 있을 때, 각 n에 대해서 n-gram을 전부 구해보면 다음과 같습니다. unigrams : an, adorable, little, boy, is, spreading, smiles bigrams : an adorable, adorable little, little boy, boy is, is spreading, spreading smiles trigrams : an adorable little, adorable little boy, little boy is, boy is spreading, is spreading smiles 4-grams : an adorable little boy, adorable little boy is, little boy is spreading, boy is spreading smiles n-gram을 사용할 때는 n이 1일 때는 유니그램(unigram), 2일 때는 바이 그램(bigram), 3일 때는 트라이 그램(trigram)이라고 명명하고 n이 4 이상일 때는 gram 앞에 그대로 숫자를 붙여서 명명합니다. 출처에 따라서는 유니그램, 바이 그램, 트라이 그램 또한 각각 1-gram, 2-gram, 3-gram이라고 하기도 합니다. n-gram을 이용한 언어 모델을 설계해 보겠습니다. n-gram을 통한 언어 모델에서는 다음에 나올 단어의 예측은 오직 n-1개의 단어에만 의존합니다. 예를 들어 'An adorable little boy is spreading' 다음에 나올 단어를 예측하고 싶다고 할 때, n=4라고 한 4-gram을 이용한 언어 모델을 사용한다고 합시다. 이 경우, spreading 다음에 올 단어를 예측하는 것은 n-1에 해당되는 앞의 3개의 단어만을 고려합니다. ( |boy is spreading ) count(boy is spreading w ) count(boy is spreading) 만약 갖고 있는 코퍼스에서 boy is spreading가 1,000번 등장했다고 합시다. 그리고 boy is spreading insults가 500번 등장했으며, boy is spreading smiles가 200번 등장했다고 합시다. 그렇게 되면 boy is spreading 다음에 insults가 등장할 확률은 50%이며, smiles가 등장할 확률은 20%입니다. 확률적 선택에 따라 우리는 insults가 더 맞는다고 판단하게 됩니다. ( insults|boy is spreading ) 0.500 ( smiles|boy is spreading ) 0.200 3. N-gram Language Model의 한계 앞서 4-gram을 통한 언어 모델의 동작 방식을 확인했습니다. 그런데 조금 의문이 남습니다. 앞서 본 4-gram 언어 모델은 주어진 문장에서 앞에 있던 단어인 '작고 사랑스러운(an adorable little)'이라는 수식어를 제거하고, 반영하지 않았습니다. 그런데 '작고 사랑스러운' 수식어까지 모두 고려하여 작고 사랑하는 소년이 하는 행동에 대해 다음 단어를 예측하는 언어 모델이었다면 과연 '작고 사랑스러운 소년이' '모욕을 퍼트렸다'라는 부정적인 내용이 '웃음 지었다'라는 긍정적인 내용 대신 선택되었을까요? 물론 코퍼스 데이터를 어떻게 가정하느냐의 나름이고, 전혀 말이 안 되는 문장은 아니지만 여기서 지적하고 싶은 것은 n-gram은 앞의 단어 몇 개만 보다 보니 의도하고 싶은 대로 문장을 끝맺음하지 못하는 경우가 생긴다는 점입니다. 문장을 읽다 보면 앞 부분과 뒷부분의 문맥이 전혀 연결 안 되는 경우도 생길 수 있습니다. 결론만 말하자면, 전체 문장을 고려한 언어 모델보다는 정확도가 떨어질 수밖에 없습니다. 이를 토대로 n-gram 모델에 대한 한계점을 정리해 보겠습니다. (1) 희소 문제(Sparsity Problem) 문장에 존재하는 앞에 나온 단어를 모두 보는 것보다 일부 단어만을 보는 것으로 현실적으로 코퍼스에서 카운트할 수 있는 확률을 높일 수는 있었지만, n-gram 언어 모델도 여전히 n-gram에 대한 희소 문제가 존재합니다. (2) n을 선택하는 것은 trade-off 문제. 앞에서 몇 개의 단어를 볼지 n을 정하는 것은 trade-off가 존재합니다. 임의의 개수인 n을 1보다는 2로 선택하는 것은 거의 대부분의 경우에서 언어 모델의 성능을 높일 수 있습니다. 가령, spreading만 보는 것보다는 is spreading을 보고 다음 단어를 예측하는 것이 더 정확하기 때문입니다. 이 경우 훈련 데이터가 적절한 데이터였다면 언어 모델이 적어도 spreading 다음에 동사를 고르지 않을 것입니다. n을 크게 선택하면 실제 훈련 코퍼스에서 해당 n-gram을 카운트할 수 있는 확률은 적어지므로 희소 문제는 점점 심각해집니다. 또한 n이 커질수록 모델 사이즈가 커진다는 문제점도 있습니다. 기본적으로 코퍼스의 모든 n-gram에 대해서 카운트를 해야 하기 때문입니다. n을 작게 선택하면 훈련 코퍼스에서 카운트는 잘 되겠지만 근사의 정확도는 현실의 확률분포와 멀어집니다. 그렇기 때문에 적절한 n을 선택해야 합니다. 앞서 언급한 trade-off 문제로 인해 정확도를 높이려면 n은 최대 5를 넘게 잡아서는 안 된다고 권장되고 있습니다. n이 성능에 영향을 주는 것을 확인할 수 있는 유명한 예제 하나를 보겠습니다. 스탠퍼드 대학교의 공유 자료에 따르면, 월스트리트 저널에서 3,800만 개의 단어 토큰에 대하여 n-gram 언어 모델을 학습하고, 1,500만 개의 테스트 데이터에 대해서 테스트를 했을 때 다음과 같은 성능이 나왔다고 합니다. 뒤에서 배우겠지만, 펄 플렉서티(perplexity)는 수치가 낮을수록 더 좋은 성능을 나타냅니다. Unigram Bigram Trigram Perplexity 962 170 109 위의 결과는 n을 1에서 2, 2에서 3으로 올릴 때마다 성능이 올라가는 것을 보여줍니다. 4. 적용 분야(Domain)에 맞는 코퍼스의 수집 어떤 분야인지, 어떤 애플리케이션인지에 따라서 특정 단어들의 확률 분포는 당연히 다릅니다. 가령, 마케팅 분야에서는 마케팅 단어가 빈번하게 등장할 것이고, 의료 분야에서는 의료 관련 단어가 당연히 빈번하게 등장합니다. 이 경우 언어 모델에 사용하는 코퍼스를 해당 도메인의 코퍼스를 사용한다면 당연히 언어 모델이 제대로 된 언어 생성을 할 가능성이 높아집니다. 때로는 이를 언어 모델의 약점이라고 하는 경우도 있는데, 훈련에 사용된 도메인 코퍼스가 무엇이냐에 따라서 성능이 비약적으로 달라지기 때문입니다. 5. 인공 신경망을 이용한 언어 모델(Neural Network Based Language Model) 여기서는 다루지 않겠지만, N-gram Language Model의 한계점을 극복하기 위해 분모, 분자에 숫자를 더해서 카운트했을 때 0이 되는 것을 방지하는 등의 여러 일반화(generalization) 방법들이 존재합니다. 하지만 그럼에도 본질적으로 n-gram 언어 모델에 대한 취약점을 완전히 해결하지는 못하였고, 이를 위한 대안으로 N-gram Language Model보다 대체적으로 성능이 우수한 인공 신경망을 이용한 언어 모델이 많이 사용되고 있습니다. 03-04 한국어에서의 언어 모델(Language Model for Korean Sentences) 영어나 기타 언어에 비해서 한국어는 언어 모델로 다음 단어를 예측하기가 훨씬 까다롭습니다. 1. 한국어는 어순이 중요하지 않다. 한국어에서는 어순이 중요하지 않습니다. 그래서 이전 단어가 주어졌을 때, 다음 단어가 나타날 확률을 구해야 하는데 어순이 중요하지 않다는 것은 다음 단어로 어떤 단어든 등장할 수 있다는 의미입니다. 예를 들어보겠습니다. 1. 나는 운동을 합니다 체육관에서. 2. 나는 체육관에서 운동을 합니다. 3. 체육관에서 운동을 합니다. 4. 나는 운동을 체육관에서 합니다. 4개의 문장은 전부 의미가 통하는 것을 볼 수 있습니다. 심지어 '나는'이라는 주어를 생략해도 말이 돼버립니다. 이렇게 단어 순서를 뒤죽박죽으로 바꾸어놔도 한국어는 의미가 전달되기 때문에 확률에 기반한 언어 모델이 제대로 다음 단어를 예측하기가 어렵습니다. 2. 한국어는 교착어이다. 한국어는 교착어입니다. 이는 한국어에서의 언어 모델 작동을 어렵게 만듭니다. 띄어쓰기 단위인 어절 단위로 토큰화를 할 경우에는 문장에서 발생 가능한 단어의 수가 굉장히 늘어납니다. 대표적인 예로 교착어인 한국어에는 조사가 있습니다. 영어는 기본적으로 조사가 없습니다. 하지만 한국어에는 어떤 행동을 하는 동사의 주어나 목적어를 위해서 조사라는 것이 있습니다. 가령 '그녀'라는 단어 하나만 해도 그녀가, 그녀를, 그녀의, 그녀와, 그녀로, 그녀께서, 그녀처럼 등과 같이 다양한 경우가 존재합니다. 그렇기 때문에, 한국어에서는 토큰화를 통해 접사나 조사 등을 분리하는 것은 중요한 작업이 되기도 합니다. 3. 한국어는 띄어쓰기가 제대로 지켜지지 않는다. 한국어는 띄어쓰기를 제대로 하지 않아도 의미가 전달되며, 띄어쓰기 규칙 또한 상대적으로 까다로운 언어이기 때문에 자연어 처리를 하는 것에 있어서 한국어 코퍼스는 띄어쓰기가 제대로 지켜지지 않는 경우가 많습니다. 토큰이 제대로 분리되지 않는 채 훈련 데이터로 사용된다면 언어 모델은 제대로 동작하지 않습니다. 03-05 펄 플렉서티(Perplexity, PPL) 두 개의 모델 A, B가 있을 때 이 모델의 성능은 어떻게 비교할 수 있을까요? 두 개의 모델을 오타 교정, 기계 번역 등의 평가에 투입해 볼 수 있겠습니다. 그리고 두 모델이 해당 업무의 성능을 누가 더 잘했는지를 비교하면 되겠습니다. 그런데 두 모델의 성능을 비교하고자, 일일이 모델들에 대해서 실제 작업을 시켜보고 정확도를 비교하는 작업은 공수가 너무 많이 드는 작업입니다. 만약 비교해야 하는 모델이 두 개가 아니라 그 이상의 수라면 시간은 비교해야 하는 모델의 수만큼 배로 늘어날 수도 있습니다. 이러한 평가보다는 어쩌면 조금은 부정확할 수는 있어도 테스트 데이터에 대해서 빠르게 식으로 계산되는 더 간단한 평가 방법이 있습니다. 바로 모델 내에서 자신의 성능을 수치화하여 결과를 내놓는 펄 플렉서티(perplexity)입니다. 1. 언어 모델의 평가 방법(Evaluation metric) : PPL 펄 플렉서티(perplexity)는 언어 모델을 평가하기 위한 평가 지표입니다. 보통 줄여서 PPL이라고 표현합니다. 왜 perplexity라는 용어를 사용했을까요? 영어에서 'perplexed'는 '헷갈리는'과 유사한 의미를 가집니다. 그러니까 여기서 PPL은 '헷갈리는 정도'로 이해합시다. PPL를 처음 배울 때 다소 낯설게 느껴질 수 있는 점이 있다면, PPL은 수치가 높으면 좋은 성능을 의미하는 것이 아니라, '낮을수록' 언어 모델의 성능이 좋다는 것을 의미한다는 점입니다. PPL은 문장의 길이로 정규화된 문장 확률의 역수입니다. 문장의 길이가 이라고 하였을 때의 PPL은 다음과 같습니다. P ( ) P ( 1 w, 3. . w) 1 = P ( 1 w, 3. . N 문장의 확률에 체인 룰(chain rule)을 적용하면 아래와 같습니다. P ( ) 1 ( 1 w, 3. . w) = ∏ = N ( i w, 2 여기에 n-gram을 적용해 볼 수도 있습니다. 예를 들어 bigram 언어 모델의 경우에는 식이 아래와 같습니다. P ( ) 1 i 1 P ( i w − ) 2. 분기 계수(Branching factor) PPL은 선택할 수 있는 가능한 경우의 수를 의미하는 분기 계수(branching factor)입니다. PPL은 이 언어 모델이 특정 시점에서 평균적으로 몇 개의 선택지를 가지고 고민하고 있는지를 의미합니다. 가령, 언어 모델에 어떤 테스트 데이터을 주고 측정했더니 PPL이 10이 나왔다고 해봅시다. 그렇다면 해당 언어 모델은 테스트 데이터에 대해서 다음 단어를 예측하는 모든 시점(time step)마다 평균 10개의 단어를 가지고 어떤 것이 정답인지 고민하고 있다고 볼 수 있습니다. 같은 테스트 데이터에 대해서 두 언어 모델의 PPL을 각각 계산 후에 PPL의 값을 비교하면, 두 언어 모델 중 PPL이 더 낮은 언어 모델의 성능이 더 좋다고 볼 수 있습니다. P ( ) P ( 1 w, 3. . w) 1 = ( 10 ) 1 = 10 1 10 단, 평가 방법에 있어서 주의할 점은 PPL의 값이 낮다는 것은 테스트 데이터 상에서 높은 정확도를 보인다는 것이지, 사람이 직접 느끼기에 좋은 언어 모델이라는 것을 반드시 의미하진 않는다는 점입니다. 또한 언어 모델의 PPL은 테스트 데이터에 의존하므로 두 개 이상의 언어 모델을 비교할 때는 정량적으로 양이 많고, 또한 도메인에 알맞은 동일한 테스트 데이터를 사용해야 신뢰도가 높다는 것입니다. 3. 기존 언어 모델 Vs. 인공 신경망을 이용한 언어 모델. 페이스북 AI 연구팀은 앞서 배운 n-gram 언어 모델과 이후 배우게 될 딥 러닝을 이용한 언어 모델에 대해서 PPL로 성능 테스트를 한 표를 공개한 바 있습니다. 링크 : https://engineering.fb.com/2016/10/25/ml-applications/building-an-efficient-neural-language-model-over-a-billion-words/ 표에서 맨 위의 줄의 언어 모델이 n-gram을 이용한 언어 모델이며 PPL이 67.6으로 측정되었습니다. 5-gram을 사용하였으며, 5-gram 앞에 Interpolated Kneser-Ney라는 이름이 붙었는데 이 책에서는 별도 설명을 생략하겠다고 했던 일반화(generalization) 방법이 사용된 모델입니다. 반면, 그 아래의 모델들은 인공 신경망을 이용한 언어 모델들로 페이스북 AI 연구팀이 자신들의 언어 모델을 다른 언어 모델과 비교하고자 하는 목적으로 기록하였습니다. 아직 RNN과 LSTM 등이 무엇인지 배우지는 않았지만, 인공 신경망을 이용한 언어 모델들은 대부분 n-gram을 이용한 언어 모델보다 더 좋은 성능 평가를 받았음을 확인할 수 있습니다. 03-06 조건부 확률(Conditional Probability) 이 챕터는 언어 모델(Language Model)과 n-gram의 근간이 되는 조건부 확률의 이해를 위해 작성하는 부록 개념의 예제 챕터입니다. A = 학생이 남학생인 사건 B = 학생이 여학생인 사건 C = 학생이 중학생인 사건 D = 학생이 고등학생인 사건 이라고 했을 때, 아래의 확률을 계산해 보겠습니다. 1. 학생을 뽑았을 때, 남학생일 확률 ( ) =180/360=0.5 2. 학생을 뽑았을 때, 고등학생이면서 남학생일 확률 ( ∩ ) = 80/360 3. 고등학생 중 한 명을 뽑았을 때, 남학생일 확률 ( | ) = 80/200 = ( ∩ ) P ( ) = (80/360)/(200/360) = 80/200 = 0.4 04. 카운트 기반의 단어 표현(Count based word Representation) 자연어 처리에서 텍스트를 표현하는 방법으로는 여러 가지 방법이 있습니다. 이번 챕터에서는 그중 정보 검색과 텍스트 마이닝 분야에서 주로 사용되는 카운트 기반의 텍스트 표현 방법인 DTM(Document Term Matrix)과 TF-IDF(Term Frequency-Inverse Document Frequency)에 대해서 다룹니다. 텍스트를 위와 같은 방식으로 수치화를 하고 나면, 통계적인 접근 방법을 통해 여러 문서로 이루어진 텍스트 데이터가 있을 때 어떤 단어가 특정 문서 내에서 얼마나 중요한 것인지를 나타내거나, 문서의 핵심어 추출, 검색 엔진에서 검색 결과의 순위 결정, 문서들 간의 유사도를 구하는 등의 용도로 사용할 수 있습니다. 04-01 다양한 단어의 표현 방법 여기서는 카운트 기반의 단어 표현 방법 외에도 다양한 단어의 표현 방법에는 어떤 것이 있으며, 앞으로 이 책에서는 어떤 순서로 단어 표현 방법을 학습하게 될 것인지에 대해서 먼저 설명합니다. 1. 단어의 표현 방법 단어의 표현 방법은 크게 국소 표현(Local Representation) 방법과 분산 표현(Distributed Representation) 방법으로 나뉩니다. 국소 표현 방법은 해당 단어 그 자체만 보고, 특정 값을 매핑하여 단어를 표현하는 방법이며, 분산 표현 방법은 그 단어를 표현하고자 주변을 참고하여 단어를 표현하는 방법입니다. 예를 들어 puppy(강아지), cute(귀여운), lovely(사랑스러운)라는 단어가 있을 때 각 단어에 1번, 2번, 3번 등과 같은 숫자를 매핑(mapping) 하여 부여한다면 이는 국소 표현 방법에 해당됩니다. 반면, 분산 표현 방법의 예를 하나 들어보면 해당 단어를 표현하기 위해 주변 단어를 참고합니다. puppy(강아지)라는 단어 근처에는 주로 cute(귀여운), lovely(사랑스러운)이라는 단어가 자주 등장하므로, puppy라는 단어는 cute, lovely 한 느낌이 다로 단어를 정의합니다. 이렇게 되면 이 두 방법의 차이는 국소 표현 방법은 단어의 의미, 뉘앙스를 표현할 수 없지만, 분산 표현 방법은 단어의 뉘앙스를 표현할 수 있게 됩니다. 또한 비슷한 의미로 국소 표현 방법(Local Representation)을 이산 표현(Discrete Representation)이라고도 하며, 분산 표현(Distributed Representation)을 연속 표현(Continuous Represnetation)이라고도 합니다. 추가 의견으로 구글의 연구원 토마스 미코 로브(Tomas Mikolov)는 2016년에 한 발표에서 잠재 의미 분석(LSA)이나 잠재 디리클레 할당(LDA)과 같은 방법들은 단어의 의미를 표현할 수 있다는 점에서 연속 표현(Continuous Represnetation)이지만, 엄밀히 말해서 다른 접근의 방법론을 사용하고 있는 워드투벡터(Word2vec)와 같은 분산 표현(Distributed Representation)은 아닌 것으로 분류하여 연속 표현을 분산 표현을 포괄하고 있는 더 큰 개념으로 설명하기도 했습니다. 2. 단어 표현의 카테고리화 이 책에서는 아래와 같은 기준으로 단어 표현을 카테고리화하여 작성되었습니다. 이번 챕터의 Bag of Words는 국소 표현에(Local Representation)에 속하며, 단어의 빈도수를 카운트(Count) 하여 단어를 수치화하는 단어 표현 방법입니다. 이 챕터에서는 BoW와 그의 확장인 DTM(또는 TDM)에 대해서 학습하고, 이러한 빈도수 기반 단어 표현에 단어의 중요도에 따른 가중치를 줄 수 있는 TF-IDF에 대해서 학습합니다. 워드 임베딩 챕터에서는 연속 표현(Continuous Representation)에 속하면서, 예측(prediction)을 기반으로 단어의 뉘앙스를 표현하는 워드투벡터(Word2Vec)와 그의 확장인 패스트 텍스트(FastText)를 학습하고, 예측과 카운트라는 두 가지 방법이 모두 사용된 글로브(GloVe)에 대해서 학습합니다. 04-02 Bag of Words(BoW) 단어의 등장 순서를 고려하지 않는 빈도수 기반의 단어 표현 방법인 Bag of Words에 대해서 학습합니다. 1. Bag of Words란? Bag of Words란 단어들의 순서는 전혀 고려하지 않고, 단어들의 출현 빈도(frequency)에만 집중하는 텍스트 데이터의 수치화 표현 방법입니다. Bag of Words를 직역하면 단어들의 가방이라는 의미입니다. 단어들이 들어있는 가방을 상상해 봅시다. 갖고 있는 어떤 텍스트 문서에 있는 단어들을 가방에다가 전부 넣습니다. 그 후에는 이 가방을 흔들어 단어들을 섞습니다. 만약, 해당 문서 내에서 특정 단어가 N 번 등장했다면, 이 가방에는 그 특정 단어가 N 개 있게 됩니다. 또한 가방을 흔들어서 단어를 섞었기 때문에 더 이상 단어의 순서는 중요하지 않습니다. BoW를 만드는 과정을 이렇게 두 가지 과정으로 생각해 보겠습니다. (1) 각 단어에 고유한 정수 인덱스를 부여합니다. # 단어 집합 생성. (2) 각 인덱스의 위치에 단어 토큰의 등장 횟수를 기록한 벡터를 만듭니다. 한국어 예제를 통해서 BoW에 대해서 이해해 보도록 하겠습니다. 문서 1 : 정부가 발표하는 물가 상승률과 소비자가 느끼는 물가 상승률은 다르다. 문서 1에 대해서 BoW를 만들어보겠습니다. 아래의 함수는 입력된 문서에 대해서 단어 집합(vocaburary)을 만들어 각 단어에 정수 인덱스를 할당하고, BoW를 만듭니다. from konlpy.tag import Okt okt = Okt() def build_bag_of_words(document): # 온점 제거 및 형태소 분석 document = document.replace('.', '') tokenized_document = okt.morphs(document) word_to_index = {} bow = [] for word in tokenized_document: if word not in word_to_index.keys(): word_to_index[word] = len(word_to_index) # BoW에 전부 기본값 1을 넣는다. bow.insert(len(word_to_index) - 1, 1) else: # 재등장하는 단어의 인덱스 index = word_to_index.get(word) # 재등장한 단어는 해당하는 인덱스의 위치에 1을 더한다. bow[index] = bow[index] + 1 return word_to_index, bow 해당 함수에 문서 1을 입력으로 넣어봅시다. doc1 = "정부가 발표하는 물가 상승률과 소비자가 느끼는 물가 상승률은 다르다." vocab, bow = build_bag_of_words(doc1) print('vocabulary :', vocab) print('bag of words vector :', bow) vocabulary : {'정부': 0, '가': 1, '발표': 2, '하는': 3, '물가 상승률': 4, '과': 5, '소비자': 6, '느끼는': 7, '은': 8, '다르다': 9} bag of words vector : [1, 2, 1, 1, 2, 1, 1, 1, 1, 1] 문서 1에 각 단어에 대해서 인덱스를 부여한 결과는 첫 번째 출력 결과입니다. 문서 1의 BoW는 두 번째 출력 결과입니다. 두 번째 출력 결과를 보면, 인덱스 4에 해당하는 물가 상승률은 두 번 언급되었기 때문에 인덱스 4에 해당하는 값이 2입니다. 인덱스는 0부터 시작됨에 주의합니다. 다시 말해 물가 상승률은 BoW에서 다섯 번째 값입니다. 만약, 한국어에서 불용어에 해당되는 조사들 또한 제거한다면 더 정제된 BoW를 만들 수도 있습니다. 2. Bag of Words의 다른 예제들 문서 2 : 소비자는 주로 소비하는 상품을 기준으로 물가 상승률을 느낀다. 위의 함수에 임의의 문서 2를 입력으로 하여 결과를 확인해 봅시다. doc2 = '소비자는 주로 소비하는 상품을 기준으로 물가 상승률을 느낀다.' vocab, bow = build_bag_of_words(doc2) print('vocabulary :', vocab) print('bag of words vector :', bow) vocabulary : {'소비자': 0, '는': 1, '주로': 2, '소비': 3, '하는': 4, '상품': 5, '을': 6, '기준': 7, '으로': 8, '물가 상승률': 9, '느낀다': 10} bag of words vector : [1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1] 문서 1과 문서 2를 합쳐서 문서 3이라고 명명하고, BoW를 만들 수도 있습니다. 문서 3: 정부가 발표하는 물가 상승률과 소비자가 느끼는 물가 상승률은 다르다. 소비자는 주로 소비하는 상품을 기준으로 물가 상승률을 느낀다. doc3 = doc1 + ' ' + doc2 vocab, bow = build_bag_of_words(doc3) print('vocabulary :', vocab) print('bag of words vector :', bow) vocabulary : {'정부': 0, '가': 1, '발표': 2, '하는': 3, '물가 상승률': 4, '과': 5, '소비자': 6, '느끼는': 7, '은': 8, '다르다': 9, '는': 10, '주로': 11, '소비': 12, '상품': 13, '을': 14, '기준': 15, '으로': 16, '느낀다': 17} bag of words vector : [1, 2, 1, 2, 3, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1] 문서 3의 단어 집합은 문서 1과 문서 2의 단어들을 모두 포함하고 있는 것들을 볼 수 있습니다. BoW는 종종 여러 문서의 단어 집합을 합친 뒤에, 해당 단어 집합에 대한 각 문서의 BoW를 구하기도 합니다. 가령, 문서 3에 대한 단어 집합을 기준으로 문서 1, 문서 2의 BoW를 만든다고 한다면 결과는 아래와 같습니다. 문서 3 단어 집합에 대한 문서 1 BoW : [1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0] 문서 3 단어 집합에 대한 문서 2 BoW : [0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 2, 1, 1, 1] 문서 3 단어 집합에서 물가 상승률이라는 단어는 인덱스가 4에 해당됩니다. 물가 상승률이라는 단어는 문서 1에서는 2회 등장하며, 문서 2에서는 1회 등장하였기 때문에 두 BoW의 인덱스 4의 값은 각각 2와 1이 되는 것을 볼 수 있습니다. BoW는 각 단어가 등장한 횟수를 수치화하는 텍스트 표현 방법이므로 주로 어떤 단어가 얼마나 등장했는지를 기준으로 문서가 어떤 성격의 문서인지를 판단하는 작업에 쓰입니다. 즉, 분류 문제나 여러 문서 간의 유사도를 구하는 문제에 주로 쓰입니다. 가령, '달리기', '체력', '근력'과 같은 단어가 자주 등장하면 해당 문서를 체육 관련 문서로 분류할 수 있을 것이며, '미분', '방정식', '부등식'과 같은 단어가 자주 등장한다면 수학 관련 문서로 분류할 수 있습니다. 3. CountVectorizer 클래스로 BoW 만들기 사이킷 런에서는 단어의 빈도를 Count 하여 Vector로 만드는 CountVectorizer 클래스를 지원합니다. 이를 이용하면 영어에 대해서는 손쉽게 BoW를 만들 수 있습니다. CountVectorizer로 간단하고 빠르게 BoW를 만드는 실습을 진행해 보도록 하겠습니다. from sklearn.feature_extraction.text import CountVectorizer corpus = ['you know I want your love. because I love you.'] vector = CountVectorizer() # 코퍼스로부터 각 단어의 빈도수를 기록 print('bag of words vector :', vector.fit_transform(corpus).toarray()) # 각 단어의 인덱스가 어떻게 부여되었는지를 출력 print('vocabulary :',vector.vocabulary_) bag of words vector : [[1 1 2 1 2 1]] vocabulary : {'you': 4, 'know': 1, 'want': 3, 'your': 5, 'love': 2, 'because': 0} 예제 문장에서 you와 love는 두 번씩 언급되었으므로 각각 인덱스 2와 인덱스 4에서 2의 값을 가지며, 그 외의 값에서는 1의 값을 가지는 것을 볼 수 있습니다. 또한 알파벳 I는 BoW를 만드는 과정에서 사라졌는데, 이는 CountVectorizer가 기본적으로 길이가 2 이상인 문자에 대해서만 토큰으로 인식하기 때문입니다. 정제(Cleaning) 챕터에서 언급했듯이, 영어에서는 길이가 짧은 문자를 제거하는 것 또한 전처리 작업으로 고려되기도 합니다. 주의할 것은 CountVectorizer는 단지 띄어쓰기만을 기준으로 단어를 자르는 낮은 수준의 토큰화를 진행하고 BoW를 만든다는 점입니다. 이는 영어의 경우 띄어쓰기만으로 토큰 화가 수행되기 때문에 문제가 없지만 한국어에 CountVectorizer를 적용하면, 조사 등의 이유로 제대로 BoW가 만들어지지 않음을 의미합니다. 예를 들어, 앞서 BoW를 만드는데 사용했던 '정부가 발표하는 물가 상승률과 소비자가 느끼는 물가 상승률은 다르다.'라는 문장을 CountVectorizer를 사용하여 BoW로 만들 경우, CountVectorizer는 '물가 상승률'이라는 단어를 인식하지 못합니다. CountVectorizer는 띄어쓰기를 기준으로 분리한 뒤에 '물가 상승률과'와 '물가 상승률은'으로 조사를 포함해서 하나의 단어로 판단하기 때문에 서로 다른 두 단어로 인식합니다. 그리고 '물가 상승률과'와 '물가 상승률은'이 각자 다른 인덱스에서 1이라는 빈도의 값을 갖게 됩니다. 4. 불용어를 제거한 BoW 만들기 앞서 불용어는 자연어 처리에서 별로 의미를 갖지 않는 단어들이라고 언급한 바 있습니다. BoW를 사용한다는 것은 그 문서에서 각 단어가 얼마나 자주 등장했는지를 보겠다는 것입니다. 그리고 각 단어에 대한 빈도수를 수치화하겠다는 것은 결국 텍스트 내에서 어떤 단어들이 중요한지를 보고 싶다는 의미를 함축하고 있습니다. 그렇다면 BoW를 만들 때 불용어를 제거하는 일은 자연어 처리의 정확도를 높이기 위해서 선택할 수 있는 전처리 기법입니다. 영어의 BoW를 만들기 위해 사용하는 CountVectorizer는 불용어를 지정하면, 불용어는 제외하고 BoW를 만들 수 있도록 불용어 제거 기능을 지원하고 있습니다. from sklearn.feature_extraction.text import CountVectorizer from nltk.corpus import stopwords (1) 사용자가 직접 정의한 불용어 사용 text = ["Family is not an important thing. It's everything."] vect = CountVectorizer(stop_words=["the", "a", "an", "is", "not"]) print('bag of words vector :',vect.fit_transform(text).toarray()) print('vocabulary :',vect.vocabulary_) bag of words vector : [[1 1 1 1 1]] vocabulary : {'family': 1, 'important': 2, 'thing': 4, 'it': 3, 'everything': 0} (2) CountVectorizer에서 제공하는 자체 불용어 사용 text = ["Family is not an important thing. It's everything."] vect = CountVectorizer(stop_words="english") print('bag of words vector :',vect.fit_transform(text).toarray()) print('vocabulary :',vect.vocabulary_) bag of words vector : [[1 1 1]] vocabulary : {'family': 0, 'important': 1, 'thing': 2} (3) NLTK에서 지원하는 불용어 사용 text = ["Family is not an important thing. It's everything."] stop_words = stopwords.words("english") vect = CountVectorizer(stop_words=stop_words) print('bag of words vector :',vect.fit_transform(text).toarray()) print('vocabulary :',vect.vocabulary_) bag of words vector : [[1 1 1 1]] vocabulary : {'family': 1, 'important': 2, 'thing': 3, 'everything': 0} 04-03 문서 단어 행렬(Document-Term Matrix, DTM) 서로 다른 문서들의 BoW들을 결합한 표현 방법인 문서 단어 행렬(Document-Term Matrix, DTM) 표현 방법을 배워보겠습니다. 이하 DTM이라고 명명합니다. 행과 열을 반대로 선택하면 TDM이라고 부르기도 합니다. 이렇게 하면 서로 다른 문서들을 비교할 수 있게 됩니다. 1. 문서 단어 행렬(Document-Term Matrix, DTM)의 표기법 문서 단어 행렬(Document-Term Matrix, DTM)이란 다수의 문서에서 등장하는 각 단어들의 빈도를 행렬로 표현한 것을 말합니다. 쉽게 생각하면 각 문서에 대한 BoW를 하나의 행렬로 만든 것으로 생각할 수 있으며, BoW와 다른 표현 방법이 아니라 BoW 표현을 다수의 문서에 대해서 행렬로 표현하고 부르는 용어입니다. 예를 들어서 이렇게 4개의 문서가 있다고 합시다. 문서 1 : 먹고 싶은 사과 문서 2 : 먹고 싶은 바나나 문서 3 : 길고 노란 바나나 바나나 문서 4 : 저는 과일이 좋아요 띄어쓰기 단위 토큰화를 수행한다고 가정하고, 문서 단어 행렬로 표현하면 다음과 같습니다. 과일이 길고 노란 먹고 바나나 사과 싶은 저는 좋아요 문서 1 0 0 0 1 0 1 1 0 0 문서 2 0 0 0 1 1 0 1 0 0 문서 3 0 1 1 0 2 0 0 0 0 문서 4 1 0 0 0 0 0 0 1 1 각 문서에서 등장한 단어의 빈도를 행렬의 값으로 표기합니다. 문서 단어 행렬은 문서들을 서로 비교할 수 있도록 수치화할 수 있다는 점에서 의의를 갖습니다. 만약 필요에 따라서는 형태소 분석기로 단어 토큰화를 수행하고, 불용어에 해당되는 조사들 또한 제거하여 더 정제된 DTM을 만들 수도 있을 것입니다. 2. 문서 단어 행렬(Document-Term Matrix)의 한계 DTM은 매우 간단하고 구현하기도 쉽지만, 본질적으로 가지는 몇 가지 한계들이 있습니다. 1) 희소 표현(Sparse representation) 원-핫 벡터는 단어 집합의 크기가 벡터의 차원이 되고 대부분의 값이 0이 되는 벡터입니다. 원-핫 벡터는 공간적 낭비와 계산 리소스를 증가시킬 수 있다는 점에서 단점을 가집니다. DTM도 마찬가지입니다. DTM에서의 각 행을 문서 벡터라고 해봅시다. 각 문서 벡터의 차원은 원-핫 벡터와 마찬가지로 전체 단어 집합의 크기를 가집니다. 만약 가지고 있는 전체 코퍼스가 방대한 데이터라면 문서 벡터의 차원은 수만 이상의 차원을 가질 수도 있습니다. 또한 많은 문서 벡터가 대부분의 값이 0을 가질 수도 있습니다. 당장 위에서 예로 들었던 문서 단어 행렬의 모든 행이 0이 아닌 값보다 0의 값이 더 많은 것을 볼 수 있습니다. 원-핫 벡터나 DTM과 같은 대부분의 값이 0인 표현을 희소 벡터(sparse vector) 또는 희소 행렬(sparse matrix)라고 부르는데, 희소 벡터는 많은 양의 저장 공간과 높은 계산 복잡도를 요구합니다. 이러한 이유로 전처리를 통해 단어 집합의 크기를 줄이는 일은 BoW 표현을 사용하는 모델에서 중요할 수 있습니다. 앞서 배운 텍스트 전처리 방법을 사용하여 구두점, 빈도수가 낮은 단어, 불용어를 제거하고, 어간이나 표제어 추출을 통해 단어를 정규화하여 단어 집합의 크기를 줄일 수 있습니다. 2) 단순 빈도 수 기반 접근 여러 문서에 등장하는 모든 단어에 대해서 빈도 표기를 하는 이런 방법은 때로는 한계를 가지기도 합니다. 예를 들어 영어에 대해서 DTM을 만들었을 때, 불용어인 the는 어떤 문서이든 자주 등장할 수밖에 없습니다. 그런데 유사한 문서인지 비교하고 싶은 문서 1, 문서 2, 문서 3에서 동일하게 the가 빈도수가 높다고 해서 이 문서들이 유사한 문서라고 판단해서는 안 됩니다. 각 문서에는 중요한 단어와 불필요한 단어들이 혼재되어 있습니다. 앞서 불용어(stopwords)와 같은 단어들은 빈도수가 높더라도 자연어 처리에 있어 의미를 갖지 못하는 단어라고 언급한 바 있습니다. 그렇다면 DTM에 불용어와 중요한 단어에 대해서 가중치를 줄 수 있는 방법은 없을까요? 이러한 아이디어를 적용한 TF-IDF를 이어서 학습해 봅시다. 사이킷런의 CountVectorizer를 사용하여 DTM을 만드는 실습 또한 TF-IDF를 설명하면서 진행하겠습니다. 04-04 TF-IDF(Term Frequency-Inverse Document Frequency) 이번에는 DTM 내에 있는 각 단어에 대한 중요도를 계산할 수 있는 TF-IDF 가중치에 대해서 알아보겠습니다. TF-IDF를 사용하면, 기존의 DTM을 사용하는 것보다 보다 많은 정보를 고려하여 문서들을 비교할 수 있습니다. TF-IDF가 DTM보다 항상 좋은 성능을 보장하는 것은 아니지만, 많은 경우에서 DTM보다 더 좋은 성능을 얻을 수 있습니다. 1. TF-IDF(단어 빈도-역 문서 빈도, Term Frequency-Inverse Document Frequency) TF-IDF(Term Frequency-Inverse Document Frequency)는 단어의 빈도와 역 문서 빈도(문서의 빈도에 특정 식을 취함)를 사용하여 DTM 내의 각 단어들마다 중요한 정도를 가중치로 주는 방법입니다. 우선 DTM을 만든 후, TF-IDF 가중치를 부여합니다. TF-IDF는 주로 문서의 유사도를 구하는 작업, 검색 시스템에서 검색 결과의 중요도를 정하는 작업, 문서 내에서 특정 단어의 중요도를 구하는 작업 등에 쓰일 수 있습니다. TF-IDF는 TF와 IDF를 곱한 값을 의미하는 데 이를 식으로 표현해 보겠습니다. 문서를 d, 단어를 t, 문서의 총개수를 n이라고 표현할 때 TF, DF, IDF는 각각 다음과 같이 정의할 수 있습니다. (1) tf(d, t) : 특정 문서 d에서의 특정 단어 t의 등장 횟수. 생소한 글자 때문에 어려워 보일 수 있지만, 잘 생각해 보면 TF는 이미 앞에서 구한 적이 있습니다. TF는 앞에서 배운 DTM의 예제에서 각 단어들이 가진 값들입니다. DTM이 각 문서에서의 각 단어의 등장 빈도를 나타내는 값이었기 때문입니다. (2) df(t) : 특정 단어 t가 등장한 문서의 수. 여기서 특정 단어가 각 문서, 또는 문서들에서 몇 번 등장했는지는 관심 가지지 않으며 오직 특정 단어 t가 등장한 문서의 수에만 관심을 가집니다. 앞서 배운 DTM에서 바나나는 문서 2와 문서 3에서 등장했습니다. 이 경우, 바나나의 df는 2입니다. 문서 3에서 바나나가 두 번 등장했지만, 그것은 중요한 게 아닙니다. 심지어 바나나란 단어가 문서 2에서 100번 등장했고, 문서 3에서 200번 등장했다고 하더라도 바나나의 df는 2가 됩니다. (3) idf(t) : df(t)에 반비례하는 수. d ( ) l g ( 1 d ( ) ) IDF라는 이름을 보고 DF의 역수가 아닐까 생각했다면, IDF는 DF의 역수를 취하고 싶은 것이 맞습니다. 그런데 log와 분모에 1을 더해주는 식에 의아하실 수 있습니다. log를 사용하지 않았을 때, IDF를 DF의 역수( d ( ) 라는 식)로 사용한다면 총 문서의 수 n이 커질수록, IDF의 값은 기하급수적으로 커지게 됩니다. 그렇기 때문에 log를 사용합니다. 왜 log가 필요한지 n=1,000,000일 때의 예를 들어봅시다. log의 밑은 10을 사용한다고 가정하였을 때 결과는 아래와 같습니다. d ( ) l g ( / f ( ) ) = , 000 000 단어 d ( ) d ( , ) word1 1 6 word2 100 4 word3 1,000 3 word4 10,000 2 word5 100,000 1 word6 1,000,000 0 그렇다면 log를 사용하지 않으면 idf의 값이 어떻게 커지는지 보겠습니다. d ( ) n d ( ) = , 000 000 단어 d ( ) d ( ) word1 1 1,000,000 word2 100 10,000 word3 1,000 1,000 word4 10,000 100 word5 100,000 10 word6 1,000,000 1 또 다른 직관적인 설명은 불용어 등과 같이 자주 쓰이는 단어들은 비교적 자주 쓰이지 않는 단어들보다 최소 수십 배 자주 등장합니다. 그런데 비교적 자주 쓰이지 않는 단어들조차 희귀 단어들과 비교하면 또 최소 수백 배는 더 자주 등장하는 편입니다. 이 때문에 log를 씌워주지 않으면, 희귀 단어들에 엄청난 가중치가 부여될 수 있습니다. 로그를 씌우면 이런 격차를 줄이는 효과가 있습니다. log 안의 식에서 분모에 1을 더해주는 이유는 첫 번째 이유로는 특정 단어가 전체 문서에서 등장하지 않을 경우에 분모가 0이 되는 상황을 방지하기 위함입니다. TF-IDF는 모든 문서에서 자주 등장하는 단어는 중요도가 낮다고 판단하며, 특정 문서에서만 자주 등장하는 단어는 중요도가 높다고 판단합니다. TF-IDF 값이 낮으면 중요도가 낮은 것이며, TF-IDF 값이 크면 중요도가 큰 것입니다. 즉, the나 a와 같이 불용어의 경우에는 모든 문서에 자주 등장하기 마련이기 때문에 자연스럽게 불용어의 TF-IDF의 값은 다른 단어의 TF-IDF에 비해서 낮아지게 됩니다. 과일이 길고 노란 먹고 바나나 사과 싶은 저는 좋아요 문서 1 0 0 0 1 0 1 1 0 0 문서 2 0 0 0 1 1 0 1 0 0 문서 3 0 1 1 0 2 0 0 0 0 문서 4 1 0 0 0 0 0 0 1 1 앞서 DTM을 설명하기 위해 들었던 위의 예제를 가지고 TF-IDF에 대해 이해해 보겠습니다. 우선 TF는 앞서 사용한 DTM을 그대로 사용하면, 그것이 각 문서에서의 각 단어의 TF가 됩니다. 이제 구해야 할 것은 TF와 곱해야 할 값인 IDF입니다. 로그는 자연 로그를 사용하도록 하겠습니다. 자연 로그는 로그의 밑을 자연 상수 e(e=2.718281...)를 사용하는 로그를 말합니다. IDF 계산을 위해 사용하는 로그의 밑은 TF-IDF를 사용하는 사용자가 임의로 정할 수 있는데, 여기서 로그는 마치 기존의 값에 곱하여 값의 크기를 조절하는 상수의 역할을 합니다. 각종 프로그래밍 언어에서 패키지로 지원하는 TF-IDF의 로그는 대부분 자연 로그를 사용합니다. 여기서도 자연 로그를 사용하겠습니다. 자연 로그는 보통 log라고 표현하지 않고, ln이라고 표현합니다. 단어 IDF(역 문서 빈도) 과일이 ln(4/(1+1)) = 0.693147 길고 ln(4/(1+1)) = 0.693147 노란 ln(4/(1+1)) = 0.693147 먹고 ln(4/(2+1)) = 0.287682 바나나 ln(4/(2+1)) = 0.287682 사과 ln(4/(1+1)) = 0.693147 싶은 ln(4/(2+1)) = 0.287682 저는 ln(4/(1+1)) = 0.693147 좋아요 ln(4/(1+1)) = 0.693147 문서의 총 수는 4이기 때문에 ln 안에서 분자는 늘 4로 동일합니다. 분모의 경우에는 각 단어가 등장한 문서의 수(DF)를 의미하는데, 예를 들어서 '먹고'의 경우에는 총 2개의 문서(문서 1, 문서 2)에 등장했기 때문에 2라는 값을 가집니다. 각 단어에 대해서 IDF의 값을 비교해 보면 문서 1개에만 등장한 단어와 문서 2개에만 등장한 단어는 값의 차이를 보입니다. IDF는 여러 문서에서 등장한 단어의 가중치를 낮추는 역할을 하기 때문입니다. TF-IDF를 계산해 보겠습니다. 각 단어의 TF는 DTM에서의 각 단어의 값과 같으므로, 앞서 사용한 DTM에서 단어 별로 위의 IDF 값을 곱해주면 TF-IDF 값을 얻습니다. 과일이 길고 노란 먹고 바나나 사과 싶은 저는 좋아요 문서 1 0 0 0 0.287682 0 0.693147 0.287682 0 0 문서 2 0 0 0 0.287682 0.287682 0 0.287682 0 0 문서 3 0 0.693147 0.693147 0 0.575364 0 0 0 0 문서 4 0.693147 0 0 0 0 0 0 0.693147 0.693147 사실 예제 문서가 굉장히 간단하기 때문에 계산은 매우 쉽습니다. 문서 3에서의 바나나만 TF 값이 2이므로 IDF에 2를 곱해주고, 나머진 TF 값이 1이므로 그대로 IDF 값을 가져오면 됩니다. 문서 2에서의 바나나의 TF-IDF 가중치와 문서 3에서의 바나나의 TF-IDF 가중치가 다른 것을 볼 수 있습니다. 수식적으로 말하면, TF가 각각 1과 2로 달랐기 때문인데 TF-IDF에서의 관점에서 보자면 TF-IDF는 특정 문서에서 자주 등장하는 단어는 그 문서 내에서 중요한 단어로 판단하기 때문입니다. 문서 2에서는 바나나를 한 번 언급했지만, 문서 3에서는 바나나를 두 번 언급했기 때문에 문서 3에서의 바나나를 더욱 중요한 단어라고 판단하는 것입니다. 2. 파이썬으로 TF-IDF 직접 구현하기 위의 계산 과정을 파이썬으로 직접 구현해 보겠습니다. 앞의 설명에서 사용한 4개의 문서를 docs에 저장합니다. import pandas as pd # 데이터 프레임 사용을 위해 from math import log # IDF 계산을 위해 docs = [ '먹고 싶은 사과', '먹고 싶은 바나나', '길고 노란 바나나 바나나', '저는 과일이 좋아요' ] vocab = list(set(w for doc in docs for w in doc.split())) vocab.sort() TF, IDF, 그리고 TF-IDF 값을 구하는 함수를 구현합니다. # 총 문서의 수 N = len(docs) def tf(t, d): return d.count(t) def idf(t): df = 0 for doc in docs: df += t in doc return log(N/(df+1)) def tfidf(t, d): return tf(t, d)* idf(t) TF를 구해보겠습니다. 다시 말해 DTM을 데이터 프레임에 저장하여 출력해 보겠습니다. result = [] # 각 문서에 대해서 아래 연산을 반복 for i in range(N): result.append([]) d = docs[i] for j in range(len(vocab)): t = vocab[j] result[-1].append(tf(t, d)) tf_ = pd.DataFrame(result, columns = vocab) 정상적으로 DTM이 출력되었습니다. 각 단어에 대한 IDF 값을 구해봅시다. result = [] for j in range(len(vocab)): t = vocab[j] result.append(idf(t)) idf_ = pd.DataFrame(result, index=vocab, columns=["IDF"]) idf_ 위에서 수기로 구한 IDF 값들과 정확히 일치합니다. TF-IDF 행렬을 출력해 봅시다. result = [] for i in range(N): result.append([]) d = docs[i] for j in range(len(vocab)): t = vocab[j] result[-1].append(tfidf(t, d)) tfidf_ = pd.DataFrame(result, columns = vocab) tfidf_ TF-IDF의 가장 기본적인 식에 대해서 학습하고 실제로 구현하는 실습을 진행해 보았습니다. 사실 실제 TF-IDF 구현을 제공하고 있는 많은 머신 러닝 패키지들은 패키지마다 식이 조금씩 상이하지만, 위에서 배운 식과는 다른 조정된 식을 사용합니다. 그 이유는 위의 기본적인 식을 바탕으로 한 구현에는 몇 가지 문제점이 존재하기 때문입니다. 만약 전체 문서의 수 이 4인데, f ( ) 의 값이 3인 경우에는 어떤 일이 벌어질까요? f ( ) 에 1이 더해지면서 log 항의 분자와 분모의 값이 같아지게 됩니다. 이는 o의 진수 값이 1이 되면서 d ( , ) 의 값이 0이 됨을 의미합니다. 식으로 표현하면 d ( , ) l g ( / ( f ( ) 1 ) ) 0 입니다. IDF의 값이 0이라면 더 이상 가중치의 역할을 수행하지 못합니다. 아래에서 실습할 사이킷런의 TF-IDF 구현체 또한 위의 식에서 조정된 식을 사용하고 있습니다. 3. 사이킷런을 이용한 DTM과 TF-IDF 실습 사이킷런을 통해 DTM과 TF-IDF를 만들어보겠습니다. BoW를 설명하며 배운 CountVectorizer를 사용하면 DTM을 만들 수 있습니다. from sklearn.feature_extraction.text import CountVectorizer corpus = [ 'you know I want your love', 'I like you', 'what should I do ', ] vector = CountVectorizer() # 코퍼스로부터 각 단어의 빈도수를 기록 print(vector.fit_transform(corpus).toarray()) # 각 단어와 매핑된 인덱스 출력 print(vector.vocabulary_) [[0 1 0 1 0 1 0 1 1] [0 0 1 0 0 0 0 1 0] [1 0 0 0 1 0 1 0 0]] {'you': 7, 'know': 1, 'want': 5, 'your': 8, 'love': 3, 'like': 2, 'what': 6, 'should': 4, 'do': 0} DTM이 완성되었습니다. DTM에서 각 단어의 인덱스가 어떻게 부여되었는지를 확인하기 위해, 인덱스를 확인해 보았습니다. 첫 번째 열의 경우에는 0의 인덱스를 가진 do입니다. do는 세 번째 문서에만 등장했기 때문에, 세 번째 행에서만 1의 값을 가집니다. 두 번째 열의 경우에는 1의 인덱스를 가진 know입니다. know는 첫 번째 문서에만 등장했으므로 첫 번째 행에서만 1의 값을 가집니다. 사이킷런은 TF-IDF를 자동 계산해 주는 TfidfVectorizer를 제공합니다. 사이킷런의 TF-IDF는 위에서 배웠던 보편적인 TF-IDF 기본 식에서 조정된 식을 사용합니다. 요약하자면, IDF의 로그 항의 분자에 1을 더해주며, 로그항에 1을 더해주고, TF-IDF에 L2 정규화라는 방법으로 값을 조정하는 등의 차이로 TF-IDF가 가진 의도는 여전히 그대로 갖고 있습니다. from sklearn.feature_extraction.text import TfidfVectorizer corpus = [ 'you know I want your love', 'I like you', 'what should I do ', ] tfidfv = TfidfVectorizer().fit(corpus) print(tfidfv.transform(corpus).toarray()) print(tfidfv.vocabulary_) [[0. 0.46735098 0. 0.46735098 0. 0.46735098 0. 0.35543247 0.46735098] [0. 0. 0.79596054 0. 0. 0. 0. 0.60534851 0. ] [0.57735027 0. 0. 0. 0.57735027 0. 0.57735027 0. 0. ]] {'you': 7, 'know': 1, 'want': 5, 'your': 8, 'love': 3, 'like': 2, 'what': 6, 'should': 4, 'do': 0} BoW, DTM, TF-IDF에 대해서 전부 학습했습니다. 문서들 간의 유사도를 구하기 위한 재료 손질하는 방법을 배운 셈입니다. 케라스로도 DTM과 TF-IDF 행렬을 만들 수 있는데, 이는 딥 러닝 챕터의 다층 퍼셉트론으로 텍스트 분류하기 실습에서 별도로 다루겠습니다. 다음 챕터에서 유사도를 구하는 방법과 이를 이용한 실습을 진행해 보겠습니다. 사이킷런의 TF-IDF의 수식을 이해하고 싶은 분들을 위해서 위키독스 웹 사이트에 댓글로 설명해놨습니다. 궁금하신 분들은 참고하세요. 05. 벡터의 유사도(Vector Similarity) 문장이나 문서의 유사도를 구하는 작업은 자연어 처리의 주요 주제 중 하나입니다. 사람들이 인식하는 문서의 유사도는 주로 문서들 간에 동일한 단어 또는 비슷한 단어가 얼마나 공통적으로 많이 사용되었는지에 의존합니다. 기계도 마찬가지입니다. 기계가 계산하는 문서의 유사도의 성능은 각 문서의 단어들을 어떤 방법으로 수치화하여 표현했는지(DTM, Word2Vec 등), 문서 간의 단어들의 차이를 어떤 방법(유클리드 거리, 코사인 유사도 등)으로 계산했는지에 달려있습니다. 05-01 코사인 유사도(Cosine Similarity) BoW에 기반한 단어 표현 방법인 DTM, TF-IDF, 또는 뒤에서 배우게 될 Word2Vec 등과 같이 단어를 수치화할 수 있는 방법을 이해했다면 이러한 표현 방법에 대해서 코사인 유사도를 이용하여 문서의 유사도를 구하는 게 가능합니다. 1. 코사인 유사도(Cosine Similarity) 코사인 유사도는 두 벡터 간의 코사인 각도를 이용하여 구할 수 있는 두 벡터의 유사도를 의미합니다. 두 벡터의 방향이 완전히 동일한 경우에는 1의 값을 가지며, 90°의 각을 이루면 0, 180°로 반대의 방향을 가지면 -1의 값을 갖게 됩니다. 즉, 결국 코사인 유사도는 -1 이상 1 이하의 값을 가지며 값이 1에 가까울수록 유사도가 높다고 판단할 수 있습니다. 이를 직관적으로 이해하면 두 벡터가 가리키는 방향이 얼마나 유사한가를 의미합니다. 두 벡터 A, B에 대해서 코사인 유사도는 식으로 표현하면 다음과 같습니다. i i a i y c s ( ) A B | | | B | ∑ = n i B ∑ = n ( i ) × i 1 ( 문서 단어 행렬이나 TF-IDF 행렬을 통해서 문서의 유사도를 구하는 경우에는 문서 단어 행렬이나 TF-IDF 행렬이 각각의 특징 벡터 A, B가 됩니다. 예시를 통해 문서 단어 행렬에 대해서 코사인 유사도를 구해봅시다. 문서 1 : 저는 사과 좋아요 문서 2 : 저는 바나나 좋아요 문서 3 : 저는 바나나 좋아요 저는 바나나 좋아요 띄어쓰기 기준 토큰화를 진행했다고 가정하고, 위의 세 문서에 대해서 문서 단어 행렬을 만들면 이와 같습니다. 바나나 사과 저는 좋아요 문서 1 0 1 1 1 문서 2 1 0 1 1 문서 3 2 0 2 2 Numpy를 사용해서 코사인 유사도를 계산하는 함수를 구현하고 각 문서 벡터 간의 코사인 유사도를 계산해 보겠습니다. import numpy as np from numpy import dot from numpy.linalg import norm def cos_sim(A, B): return dot(A, B)/(norm(A)*norm(B)) doc1 = np.array([0,1,1,1]) doc2 = np.array([1,0,1,1]) doc3 = np.array([2,0,2,2]) print('문서 1과 문서 2의 유사도 :',cos_sim(doc1, doc2)) print('문서 1과 문서 3의 유사도 :',cos_sim(doc1, doc3)) print('문서 2와 문서 3의 유사도 :',cos_sim(doc2, doc3)) 문서 1과 문서 2의 유사도 : 0.67 문서 1과 문서 3의 유사도 : 0.67 문서 2과 문서 3의 유사도 : 1.00 눈여겨볼 만한 점은 문서 1과 문서 2의 코사인 유사도와 문서 1과 문서 3의 코사인 유사도가 같다는 점과 문서 2와 문서 3의 코사인 유사도가 1이 나온다는 것입니다. 앞서 1은 두 벡터의 방향이 완전히 동일한 경우에 1이 나오며, 코사인 유사도 관점에서는 유사도의 값이 최대임을 의미한다고 언급한 바 있습니다. 문서 3은 문서 2에서 단지 모든 단어의 빈도수가 1씩 증가했을 뿐입니다. 다시 말해 한 문서 내의 모든 단어의 빈도수가 동일하게 증가하는 경우에는 기존의 문서와 코사인 유사도의 값이 1이라는 것입니다. 이것이 시사하는 점은 무엇일까요? 예를 들어보겠습니다. 문서 A와 B가 동일한 주제의 문서. 문서 C는 다른 주제의 문서라고 해봅시다. 그리고 문서 A와 문서 C의 문서의 길이는 거의 차이가 나지 않지만, 문서 B의 경우 문서 A의 길이보다 두 배의 길이를 가진다고 가정하겠습니다. 이런 경우 유클리드 거리로 유사도를 연산하면 문서 A가 문서 B보다 문서 C와 유사도가 더 높게 나오는 상황이 발생할 수 있습니다. 이는 유사도 연산에 문서의 길이가 영향을 받았기 때문인데, 이런 경우 코사인 유사도가 해결책이 될 수 있습니다. 코사인 유사도는 유사도를 구할 때 벡터의 방향(패턴)에 초점을 두므로 코사인 유사도는 문서의 길이가 다른 상황에서 비교적 공정한 비교를 할 수 있도록 도와줍니다. 2. 유사도를 이용한 추천 시스템 구현하기 캐글에서 사용되었던 영화 데이터 셋을 가지고 영화 추천 시스템을 만들어보겠습니다. TF-IDF와 코사인 유사도만으로 영화의 줄거리에 기반해서 영화를 추천하는 추천 시스템을 만들 수 있습니다. 다운로드 링크 : https://www.kaggle.com/rounakbanik/the-movies-dataset 원본 파일은 위 링크에서 movies_metadata.csv 파일을 다운로드하면 됩니다. 해당 데이터는 총 24개의 열을 가진 45,466개의 샘플로 구성된 영화 정보 데이터입니다. import pandas as pd from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.metrics.pairwise import cosine_similarity data = pd.read_csv('movies_metadata.csv', low_memory=False) data.head(2) 다운로드한 훈련 데이터에서 상위 2개의 샘플만 출력하여 데이터의<NAME>을 확인합니다. ... original_title overview ... title video vote_average vote_count 0 ... Toy Story Led by Woody, Andy's toys live happily in his ... 중략 ... ... Toy Story False 7.7 5415.0 1 ... Jumanji When siblings Judy and Peter discover an encha ... 중략 ... ... Jumanji False 6.9 2413.0 훈련 데이터는 총 24개의 열을 갖고 있으나 책의 지면의 한계로 일부 생략합니다. 여기서 코사인 유사도에 사용할 데이터는 영화 제목에 해당하는 title 열과 줄거리에 해당하는 overview 열입니다. 좋아하는 영화를 입력하면, 해당 영화의 줄거리와 유사한 줄거리의 영화를 찾아서 추천하는 시스템을 만들 것입니다. # 상위 2만 개의 샘플을 data에 저장 data = data.head(20000) 만약 훈련 데이터의 양을 줄이고 학습을 진행하고자 한다면 위와 같이 데이터를 줄여서 재저장할 수 있습니다. 여기서는 상위 20,000개의 샘플만 사용하겠습니다. TF-IDF를 연산할 때 데이터에 Null 값이 들어있으면 에러가 발생합니다. TF-IDF의 대상이 되는 data의 overview 열에 결측값에 해당하는 Null 값이 있는지 확인합니다. # overview 열에 존재하는 모든 결측값을 전부 카운트하여 출력 print('overview 열의 결측값의 수:',data['overview'].isnull().sum()) overview 열의 결측값의 수: 135 135개의 Null 값이 있다고 합니다. 이 경우 결측값을 가진 행을 제거하는 pandas의 dropna()나 결측값이 있던 행에 특정 값으로 채워 넣는 pandas의 fillna()를 사용할 수 있습니다. 괄호 안에 Null 대신 넣고자 하는 값을 넣으면 되는데, 여기서는 빈 값(empty value)으로 대체하였습니다. # 결측값을 빈 값으로 대체 data['overview'] = data['overview'].fillna('') Null 값을 빈 값으로 대체하였습니다. overview 열에 대해서 TF-IDF 행렬을 구한 후 행렬의 크기를 출력해 봅시다. tfidf = TfidfVectorizer(stop_words='english') tfidf_matrix = tfidf.fit_transform(data['overview']) print('TF-IDF 행렬의 크기(shape) :',tfidf_matrix.shape) TF-IDF 행렬의 크기(shape) : (20000, 47487) TF-IDF 행렬의 크기는 20,000의 행을 가지고 47,847의 열을 가지는 행렬입니다. 다시 말해 20,000개의 영화를 표현하기 위해서 총 47,487개의 단어가 사용되었음을 의미합니다. 또는 47,847차원의 문서 벡터가 20,000개가 존재한다고도 표현할 수 있을 겁니다. 이제 20,000개의 문서 벡터에 대해서 상호 간의 코사인 유사도를 구합니다. cosine_sim = cosine_similarity(tfidf_matrix, tfidf_matrix) print('코사인 유사도 연산 결과 :',cosine_sim.shape) 코사인 유사도 연산 결과 : (20000, 20000) 코사인 유사도 연산 결과로는 20,000행 20,000열의 행렬을 얻습니다. 이는 20,000개의 각 문서 벡터(영화 줄거리 벡터)와 자기 자신을 포함한 20,000개의 문서 벡터 간의 유사도가 기록된 행렬입니다. 모든 20,000개 영화의 상호 유사도가 기록돼 있습니다. 이제 기존 데이터 프레임으로부터 영화의 타이틀을 key, 영화의 인덱스를 value로 하는 딕셔너리 title_to_index를 만들어둡니다. title_to_index = dict(zip(data['title'], data.index)) # 영화 제목 Father of the Bride Part II의 인덱스를 리턴 idx = title_to_index['Father of the Bride Part II'] print(idx) 선택한 영화의 제목을 입력하면 코사인 유사도를 통해 가장 overview가 유사한 10개의 영화를 찾아내는 함수를 만듭니다. def get_recommendations(title, cosine_sim=cosine_sim): # 선택한 영화의 타이틀로부터 해당 영화의 인덱스를 받아온다. idx = title_to_index[title] # 해당 영화와 모든 영화와의 유사도를 가져온다. sim_scores = list(enumerate(cosine_sim[idx])) # 유사도에 따라 영화들을 정렬한다. sim_scores = sorted(sim_scores, key=lambda x: x[1], reverse=True) # 가장 유사한 10개의 영화를 받아온다. sim_scores = sim_scores[1:11] # 가장 유사한 10개의 영화의 인덱스를 얻는다. movie_indices = [idx[0] for idx in sim_scores] # 가장 유사한 10개의 영화의 제목을 리턴한다. return data['title'].iloc[movie_indices] 영화 다크 나이트 라이즈와 overview가 유사한 영화들을 찾아보겠습니다. get_recommendations('The Dark Knight Rises') 12481 The Dark Knight 150 Batman Forever 1328 Batman Returns 15511 Batman: Under the Red Hood 585 Batman 9230 Batman Beyond: Return of the Joker 18035 Batman: Year One 19792 Batman: The Dark Knight Returns, Part 1 3095 Batman: Mask of the Phantasm 10122 Batman Begins Name: title, dtype: object 가장 유사한 영화가 출력되는데, 영화 다크 나이트가 첫 번째고, 그 외에도 전부 배트맨 영화를 찾아낸 것을 확인할 수 있습니다. 05-02여러 가지 유사도 기법 문서의 유사도를 구하기 위한 방법으로는 코사인 유사도 외에도 여러 가지 방법들이 있습니다. 여기서는 문서의 유사도를 구할 수 있는 다른 방법들을 학습합니다. 1. 유클리드 거리(Euclidean distance) 유클리드 거리(euclidean distance)는 문서의 유사도를 구할 때 자카르 유사도나 코사인 유사도만큼, 유용한 방법은 아닙니다. 하지만 여러 가지 방법을 이해하고, 시도해 보는 것 자체만으로 다른 개념들을 이해할 때 도움이 되므로 의미가 있습니다. 다차원 공간에서 두 개의 점 와 가 각각 = ( 1 p, 3. . p) q ( 1 q, 3. . q) 의 좌표를 가질 때 두 점 사이의 거리를 계산하는 유클리드 거리 공식은 다음과 같습니다. ( 1 p) + ( 2 p) + . . + ( n p) = i 1 ( i p) 다차원 공간이라고 가정하면, 처음 보는 입장에서는 식이 너무 복잡해 보입니다. 좀 더 쉽게 이해하기 위해서 2차원 공간이라고 가정하고 두 점 사이의 거리를 좌표 평면 상에서 시각화해보겠습니다. 2차원 좌표 평면 상에서 두 점 와 사이의 직선거리를 구하는 문제입니다. 위의 경우에는 직각 삼각형으로 표현이 가능하므로, 중학교 수학 과정인 피타고라스의 정리를 통해 와 사이의 거리를 계산할 수 있습니다. 즉, 2차원 좌표 평면에서 두 점 사이의 유클리드 거리 공식은 피타고라스의 정리를 통해 두 점 사이의 거리를 구하는 것과 동일합니다. 다시 원점으로 돌아가서 여러 문서에 대해서 유사도를 구하고자 유클리드 거리 공식을 사용한다는 것은, 앞서 본 2차원을 단어의 총개수만큼의 차원으로 확장하는 것과 같습니다. 예를 들어 아래와 같은 DTM이 있다고 합시다. 바나나 사과 저는 좋아요 문서 1 2 3 0 1 문서 2 1 2 3 1 문서 3 2 1 2 2 단어의 개수가 4개이므로, 이는 4차원 공간에 문서 1, 문서 2, 문서 3을 배치하는 것과 같습니다. 이때 다음과 같은 문서 Q에 대해서 문서 1, 문서 2, 문서 3 중 가장 유사한 문서를 찾아내고자 합니다. 바나나 사과 저는 좋아요 문서 Q 1 1 0 1 이때 유클리드 거리를 통해 유사도를 구하려고 한다면, 문서 Q 또한 다른 문서들처럼 4차원 공간에 배치시켰다는 관점에서 4차원 공간에서의 각각의 문서들과의 유클리드 거리를 구하면 됩니다. 이를 파이썬 코드로 구현해 보겠습니다. import numpy as np def dist(x, y): return np.sqrt(np.sum((x-y)**2)) doc1 = np.array((2,3,0,1)) doc2 = np.array((1,2,3,1)) doc3 = np.array((2,1,2,2)) docQ = np.array((1,1,0,1)) print('문서 1과 문서 Q의 거리 :',dist(doc1, docQ)) print('문서 2과 문서 Q의 거리 :',dist(doc2, docQ)) print('문서 3과 문서 Q의 거리 :',dist(doc3, docQ)) 문서 1과 문서 Q의 거리 : 2.23606797749979 문서 2과 문서 Q의 거리 : 3.1622776601683795 문서 3과 문서 Q의 거리 : 2.449489742783178 유클리드 거리의 값이 가장 작다는 것은 문서 간 거리가 가장 가깝다는 것을 의미합니다. 즉, 문서 1이 문서 Q와 가장 유사하다고 볼 수 있습니다. 2. 자카르 유사도(Jaccard similarity) A와 B 두 개의 집합이 있다고 합시다. 이때 교집합은 두 개의 집합에서 공통으로 가지고 있는 원소들의 집합을 말합니다. 즉, 합집합에서 교집합의 비율을 구한다면 두 집합 A와 B의 유사도를 구할 수 있다는 것이 자카르 유사도(jaccard similarity)의 아이디어입니다. 자카르 유사도는 0과 1사이의 값을 가지며, 만약 두 집합이 동일하다면 1의 값을 가지고, 두 집합의 공통 원소가 없다면 0의 값을 갖습니다. 자카르 유사도를 구하는 함수를 라고 하였을 때, 자카르 유사도 함수는 아래와 같습니다. ( , ) | ∩ | A B = A B | | | | | ∩ | 두 개의 비교할 문서를 각각 o 1 d c라고 했을 때 o 1 d c의 문서의 유사도를 구하기 위한 자카르 유사도는 이와 같습니다. ( o 1 d c) d c ∩ o 2 o 1 d c 두 문서 o 1 d c 사이의 자카르 유사도 ( o 1 d c) 는 두 집합의 교집합 크기를 두 집합의 합집합 크기로 나눈 값으로 정의됩니다. 간단한 예를 통해서 이해해 보겠습니다. doc1 = "apple banana everyone like likey watch card holder" doc2 = "apple banana coupon passport love you" # 토큰화 tokenized_doc1 = doc1.split() tokenized_doc2 = doc2.split() print('문서 1 :',tokenized_doc1) print('문서 2 :',tokenized_doc2) 문서 1 : ['apple', 'banana', 'everyone', 'like', 'likey', 'watch', 'card', 'holder'] 문서 2 : ['apple', 'banana', 'coupon', 'passport', 'love', 'you'] 문서 1과 문서 2의 합집합을 구해보겠습니다. union = set(tokenized_doc1).union(set(tokenized_doc2)) print('문서 1과 문서 2의 합집합 :',union) 문서 1과 문서 2의 합집합 : {'you', 'passport', 'watch', 'card', 'love', 'everyone', 'apple', 'likey', 'like', 'banana', 'holder', 'coupon'} 문서 1과 문서 2의 합집합의 단어의 총개수는 12개입니다. 이제 문서 1과 문서 2의 교집합을 구해보겠습니다. 문서 1과 문서 2에서 둘 다 등장한 단어를 찾으면 됩니다. intersection = set(tokenized_doc1).intersection(set(tokenized_doc2)) print('문서 1과 문서 2의 교집합 :',intersection) 문서 1과 문서 2의 교집합 : {'apple', 'banana'} 문서 1과 문서 2에서 둘 다 등장한 단어는 banana와 apple 총 2개입니다. 이제 교집합의 크기를 합집합의 크기로 나누면 자카르 유사도가 계산됩니다. print('자카르 유사도 :',len(intersection)/len(union)) 자카르 유사도 : 0.16666666666666666 06. 머신 러닝(Machine Learning) 개요 머신 러닝은 영상 처리, 번역기, 음성 인식, 스팸 메일 탐지 등 굉장히 다양한 분야에서 응용되고 있습니다. 특히 머신 러닝의 한 갈래인 딥 러닝은 자연어 처리 엔지니어에게 필수 역량이 되어가고 있습입니다. 이번 챕터에서는 머신 러닝의 개념과 선형 회귀, 로지스틱 회귀, 소프트맥스 회귀와 같은 기본적인 모델을 이해합니다. 그리고 이러한 이해를 바탕으로 다음 딥 러닝 챕터에서 기본적인 모델로부터 딥 러닝 모델로 개념을 확장해 보겠습니다. 06-01 머신 러닝이란(What is Machine Learning?) 딥 러닝을 포함하고 있는 개념인 머신 러닝(Machine Learning)의 개념에 대해서 학습합니다. 1. 머신 러닝(Machine Learning)이 아닌 접근 방법의 한계 머신 러닝이 아닌 기존의 프로그래밍 작성 방식을 통해서는 해결하기 어려운 문제 예시를 하나 들어보겠습니다. 예시 : 주어진 사진으로부터 고양이 사진인지 강아지 사진인지 판별하는 일. 위 문제는 실제 2017년에 있었던 DGIST의 딥 러닝<NAME>대회의 문제입니다. 사진을 보고 고양이 사진인지, 강아지 사진인지 판단하는 건 사람에게는 너무나 쉬운 일입니다. 그런데 이 문제를 풀 수 있는 프로그램을 작성하는 것은 상당히 난해한 수준입니다. 입력된 이미지로부터 강아지와 고양이를 구분할 수 있는 코드를 어떻게 작성할 수 있을까요? def prediction(이미지 as input): 어떻게 코딩해야 하지? return 결과 사진이란 건 사진을 보는 각도, 조명, 타깃의 변형(고양이의 자세)에 따라서 너무나 천차만별이라 사진으로부터 공통된 명확한 특징을 잡아내는 것이 쉽지 않습니다. 사실, 결론을 미리 말씀드리면 해당 프로그램은 숫자를 정렬하는 것과 같은 명확한 알고리즘이 애초에 존재하지 않습니다. 이러한 이미지 인식 분야에서 규칙을 정의하고 특징을 잡아내기 위한 많은 시도들이 있었습니다. 이미지 내의 경계선과 같은 것들을 찾아내서 알고리즘화하려고 시도하고, 다른 사진 이미지가 들어오면 전반적인 상태를 비교하여 분류하려고 한 것입니다. 하지만 그러한 시도들은 결국 특징을 잡아내는 것에 한계가 있을 수밖에 없었습니다. 결국 요즘에 이르러서는 사진으로부터 대상을 찾아내는 일은 사람이 규칙을 정의하는 것이 아니라 머신 러닝으로 문제를 해결하고 있습니다. 2. 머신 러닝 방식 머신 러닝이 위에서 언급한 예시 문제를 해결할 수 있는 이유는 해결을 위한 접근 방식이 기존의 프로그래밍 방식과는 다르기 때문입니다. 위 이미지에서 위쪽은 기존의 프로그래밍의 접근 방식, 아래쪽은 머신 러닝의 접근 방식을 보여줍니다. 머신 러닝은 데이터가 주어지면, 기계가 스스로 데이터로부터 규칙성을 찾는 것에 집중합니다. 주어진 데이터로부터 규칙성을 찾는 과정을 우리는 훈련(training) 또는 학습(learning)이라고 합니다. 일단 규칙성을 발견하고 나면, 그 후에 들어오는 새로운 데이터에 대해서 발견한 규칙성을 기준으로 정답을 찾아내는데 이는 기존의 프로그래밍 방식으로 접근하기 어려웠던 문제의 해결책이 되기도 합니다. 이미지를 예시로 들었지만 자연어 처리도 이미지 처리만큼이나 어려운 문제들이 많습니다. 최근에는 머신 러닝의 한 갈래인 딥 러닝이 자연어 처리에서 굉장히 뛰어난 성능을 보여주고 있습니다. 단적으로, 구글 번역기와 같은 기계 번역기가 그러한데, 이러한 번역기는 사람이 직접 규칙을 정의해서 만드는 것보다 딥 러닝으로 모델이 스스로 규칙을 찾아내도록 구현하는 것이 훨씬 더 좋은 성능을 얻을 수 있습니다. 06-02 머신 러닝 훑어보기 머신 러닝의 특징을 이해하고, 주요 용어에 미리 친숙해져봅시다. 1. 머신 러닝 모델의 평가 머신 러닝을 위한 데이터를 준비했다면 기계를 학습하기 전 해당 데이터를 훈련용, 검증용, 테스트용 이렇게 세 가지로 분리하는 것이 일반적입니다. 훈련 데이터는 머신 러닝 모델을 학습하는 용도입니다. 테스트 데이터는 학습한 머신 러닝 모델의 성능을 평가하기 위한 용도입니다. 그렇다면 검증용 데이터의 용도는 무엇일까요? 검증용 데이터는 모델의 성능을 평가하기 위한 용도가 아니라 모델의 성능을 조정하기 위한 용도입니다. 더 정확히는 모델이 훈련 데이터에 과 적합(overfitting) 이 되고 있는지 판단하거나 하이퍼 파라미터의 조정을 위한 용도입니다. 하이퍼 파라미터와 매개변수라는 용어를 정리해둡시다. 하이퍼 파라미터(초 매개변수) : 모델의 성능에 영향을 주는 사람이 값을 지정하는 변수. 매개변수 : 가중치와 편향. 학습을 하는 동안 값이 계속해서 변하는 수. 아직 이 장에서는 검증용 데이터와 하이퍼 파라미터의 개념이 어떤 의미인지 와닿지 않아도 괜찮습니다. 이 개념은 앞으로 지속적으로 언급하게 될 것입니다. 이 두 변수의 가장 큰 차이는 하이퍼 파라미터는 보통 사용자가 직접 정해줄 수 있는 변수라는 점입니다. 뒤의 선형 회귀에서 배우게 되는 경사 하강법에서 학습률(learning rate)이나, 딥 러닝에서 뉴런의 수나 층의 수와 같은 것들이 대표적인 하이퍼 파라미터입니다. 반면, 가중치와 편향과 같은 매개변수는 사용자가 결정해 주는 값이 아니라 모델이 학습하는 과정에서 얻어지는 값입니다. 훈련용 데이터로 훈련을 모두 시킨 모델은 검증용 데이터를 사용하여 정확도를 검증하며 하이퍼 파라미터를 튜닝(tuning) 합니다. 검증용 데이터에 대해서 높은 정확도를 얻도록 하이퍼 파라미터의 값을 바꿔보는 것입니다. 이렇게 튜닝하는 과정에서 모델은 검증용 데이터의 정확도를 높이는 방향으로 점차적으로 수정됩니다. 튜닝 과정을 모두 끝내고 모델의 최종 평가를 하고자 한다면, 이제 검증용 데이터로 모델을 평가하는 것은 적합하지 않습니다. 모델은 검증용 데이터의 정확도를 높이기 위해서 수정돼 온 모델이기 때문입니다. 모델에 대한 평가는 이제 모델이 한 번도 보지 못한 데이터인 테스트 데이터의 몫입니다. 수학 능력 시험을 준비하는 수험생으로 비유하자면 훈련 데이터는 실제 공부를 위한 문제지, 검증 데이터는 모의고사, 테스트 데이터는 실력을 최종적으로 평가하는 수능 시험이라고 볼 수 있습니다. 2. 분류(Classification)와 회귀(Regression) 전부는 아니지만 머신 러닝의 많은 문제는 분류 또는 회귀 문제에 속합니다. 이번 챕터에서는 머신 러닝 기법 중 선형 회귀(Lineare Regression)와 로지스틱 회귀(Logistic Regression)를 다루는데 선형 회귀는 대표적인 회귀 문제에 속하고, 로지스틱 회귀는 (이름은 회귀이지만) 대표적인 분류 문제에 속합니다. 분류는 또한 이진 분류(Binary Classification)과 다중 클래스 분류(Multi-Class Classification)로 나뉩니다. 엄밀히는 다중 레이블 분류(Multi-lable Classification)라는 또 다른 문제가 존재하지만, 이 책에서는 이진 분류와 다중 클래스 분류만을 다룹니다. 1) 이진 분류 문제(Binary Classification) 이진 분류는 주어진 입력에 대해서 두 개의 선택지 중 하나의 답을 선택해야 하는 경우를 말합니다. 종합시험 성적표를 보고 최종적으로 합격, 불합격인지 판단하는 문제, 메일을 보고 나서 정상 메일, 스팸 메일인지를 판단하는 문제 등이 이에 속합니다. 2) 다중 클래스 분류(Multi-class Classification) 다중 클래스 분류는 주어진 입력에 대해서 세 개 이상의 선택지 중에서 답을 선택해야 하는 경우를 말합니다. 예를 들어 서점 직원이 일을 하는데 과학, 영어, IT, 학습지, 만화라는 레이블이 붙어있는 5개의 책장이 있다고 합시다. 새 책이 입고되면, 이 책은 다섯 개의 책장 중에서 분야에 맞는 적절한 책장에 책을 넣어야 합니다. 이 경우는 현실에서의 다중 클래스 분류 문제라고 할 수 있겠습니다. 3) 회귀 문제(Regression) 회귀 문제는 분류 문제처럼 둘 중 하나를 선택해야 한다거나, 책이 입고되었을 때 5개의 책장 중 하나의 책장을 골라야 하는 경우처럼 정답이 몇 개의 정해진 선택지 중에서 정해져 있는 경우가 아니라 어떠한 연속적인 값의 범위 내에서 예측값이 나오는 경우를 말합니다. 예를 들어서 역과의 거리, 인구 밀도, 방의 개수 등을 입력하면 부동산 가격을 예측하는 머신 러닝 모델이 있다고 해봅시다. 머신 러닝 모델이 부동산 가격을 7억 8,456만 3,450원으로 예측하는 경우도 있을 것이고, 8억 1257만 300원으로 예측하는 경우도 있을 수 있습니다. 특정 값의 범위 내에서는 어떤 숫자도 나올 수 있습니다. 기존의 분류 문제와 같이 분리된(비연속적인) 답이 결과가 아니라 연속된 값을 결과로 가지는 이러한 문제를 회귀 문제라고 부릅니다. 회귀 문제의 예시로 시계열 데이터(Time Series Data)를 이용한 주가 예측, 생산량 예측,<NAME> 예측 등이 있습니다. 3. 지도 학습과 비지도 학습 머신 러닝은 크게 지도 학습, 비지도 학습, 강화 학습으로 나눕니다. 강화 학습은 이 책의 범위를 벗어나므로 설명하지 않습니다. 그리고 큰 갈래로서는 자주 언급되지는 않지만 딥 러닝 자연어 처리에서 중요한 학습 방법 중 하나인 자기 지도 학습(Self-Supervised Learning, SSL)에 대해서도 언급해 보겠습니다. 1) 지도 학습(Supervised Learning) 지도 학습이란 레이블(Label)이라는 정답과 함께 학습하는 것을 말합니다. 자연어 처리는 대부분 지도 학습에 속합니다. 앞으로 우리가 풀게 될 자연어 처리의 많은 문제들은 레이블이 존재하는 경우가 많기 때문입니다. 이는 앞서 2챕터의 데이터의 분리를 설명하며 상세히 설명한 바 있습니다. 레이블이라는 말 외에도, 실제 값 등으로 부르기도 하는데 이 책에서는 이 용어들을 상황에 따라서 바꿔서 사용합니다. 기계는 예측값과 실제 값의 차이인 오차를 줄이는 방식으로 학습을 하게 되는데 예측값은 ^ 과같이 표현하기도 합니다. 2) 비지도 학습(Unsupervised Learning) 비지도 학습은 데이터에 별도의 레이블이 없이 학습하는 것을 말합니다. 예를 들어 텍스트 처리 분야의 토픽 모델링 알고리즘인 LSA나 LDA는 비지도 학습에 속합니다. LSA와 LDA는 온라인 웹 사이트 위키독스의 e-book( https://wikidocs.net/30707 )에서 볼 수 있습니다. 3) 자기 지도 학습(Self-Supervised Learning, SSL) 레이블이 없는 데이터가 주어지면, 모델이 학습을 위해서 스스로 데이터로부터 레이블을 만들어서 학습하는 경우를 자기 지도 학습이라고 합니다. 대표적인 예시로는 Word2Vec과 같은 워드 임베딩 알고리즘이나, BERT와 같은 언어 모델의 학습 방법을 들 수 있습니다. 이들이 어떻게 레이블을 만들어 학습하는지에 대한 설명은 Word2Vec과 BERT를 설명하는 페이지를 참고 바랍니다. 4. 샘플(Sample)과 특성(Feature) 많은 머신 러닝 문제가 1개 이상의 독립 변수를 가지고 종속 변수를 예측하는 문제입니다. 머신 러닝 모델 중 특히 인공 신경망은 독립 변수, 종속 변수, 가중치, 편향 등을 행렬 연산을 통해 연산하는 경우가 많습니다. 앞으로 인공 신경망을 배우게 되면 훈련 데이터를 행렬로 표현하는 경우를 많이 보게 됩니다. 독립 변수의 행렬을 X라고 하였을 때, 독립 변수의 개수가 n 개고 데이터의 개수가 m인 행렬 X는 다음과 같습니다. 이때 머신 러닝에서는 하나의 데이터. 행렬 관점에서는 하나의 행을 샘플(Sample)이라고 부릅니다. (데이터베이스에서 레코드라고 부르는 단위입니다.) 그리고 종속 변수를 예측하기 위한 각각의 독립 변수를 특성(Feature)이라고 부릅니다. 행렬 관점에서는 각 열에 해당됩니다. 5. 혼동 행렬(Confusion Matrix) 머신 러닝에서는 맞춘 문제 수를 전체 문제 수로 나눈 값을 정확도(Accuracy)라고 합니다. 하지만 정확도는 맞춘 결과와 다른 결과에 대한 세부적인 내용을 알려주지는 않습니다. 이를 위해서 사용하는 것이 혼동 행렬(Confusion Matrix)입니다. 예를 들어 참(True)와 거짓(False) 둘 중 하나를 예측하는 문제였다고 가정해 봅시다. 아래의 혼동 행렬에서 각 열은 예측값을 나타내며, 각 행은 실제 값을 나타냅니다. 예측 참 예측 거짓 실제 참 TP FN 실제 거짓 FP TN 머신 러닝에서는 다음과 같은 네 가지 케이스에 대해서 각각 TP, FP, FN, TN을 정의합니다. True Positive(TP) : 실제 True인 정답을 True라고 예측 (정답) False Positive(FP) : 실제 False인 정답을 True라고 예측 (오답) False Negative(FN) : 실제 True인 정답을 False라고 예측 (오답) True Negative(TN) : 실제 False인 정답을 False라고 예측 (정답) 이 개념을 사용하면 정밀도(Precision)과 재현율(Recall)이 됩니다. 1) 정밀도(Precision) 정밀도란 모델이 True라고 분류한 것 중에서 실제 True인 것의 비율입니다. 정밀도 정밀도 T T + P 2) 재현율(Recall) 재현율이란 실제 True인 것 중에서 모델이 True라고 예측한 것의 비율입니다. 재현율 재현율 T T + N Precision이나 Recall은 모두 실제 True인 정답을 모델이 True라고 예측한 경우. 즉, TP에 관심이 있습니다. 두 식 모두 분자가 TP임에 주목합시다. 3) 정확도(Accuracy) 정확도(Accuracy)는 우리가 일반적으로 실생활에서도 가장 많이 사용하는 지표입니다. 전체 예측한 데이터 중에서 정답을 맞힌 것에 대한 비율입니다. TP, FP, FN, TN을 가지고 수식을 설명하면 다음과 같습니다. 정확도 정확도 T + N P F + P T 그런데 Accuracy로 성능을 예측하는 것이 적절하지 않은 때가 있습니다. 비가 오는 날을 예측하는 모델을 만들었다고 했을 때, 200일 동안 총 6일만 비가 왔다고 해봅시다. 그런데 이 모델은 200일 내내 날씨가 맑았다고 예측했습니다. 이 모델은 200번 중 총 6회 틀렸습니다. 194/200=0.97이므로 정확도는 97%입니다. 하지만 정작 비가 온 날은 하나도 못 맞춘 셈입니다. 또 다른 예를 들어봅시다. 스팸 메일을 분류하는 스팸 메일 분류기를 만들었습니다. 메일 100개 중 스팸 메일은 5개였습니다. 스팸 메일 분류기는 모두 정상 메일이라고 탐지했습니다. 정확도는 95%입니다. 그런데 정작 스팸 메일은 하나도 못 찾아낸 셈입니다. 이렇게 실질적으로 더 중요한 경우에 대한 데이터가 전체 데이터에서 너무 적은 비율을<NAME>다면 정확도는 좋은 측정 지표가 될 수 없습니다. 이런 경우에는 F1-Score를 사용하며, 이에 대해서는 개체명 인식 챕터에서 설명하겠습니다. 6. 과 적합(Overfitting)과 과소 적합(Underfitting) 학생의 입장이 되어 하나의 문제지를 과하도록 많이 풀어서 문제 번호만 봐도 정답을 맞힐 수 있게 되었다고 가정합시다. 그런데 너무 오랜 시간 하나의 문제지만 반복해서 푼 나머지 다른 문제를 풀거나 시험을 봤을 때 점수가 안 좋다면 그게 의미가 있을까요? 머신 러닝에서 과 적합(Overfitting) 이란 위의 비유처럼 훈련 데이터를 과하게 학습한 경우를 말합니다. 머신 러닝 모델이 학습에 사용하는 훈련 데이터는 실제로 앞으로 기계가 풀어야 할 현실의 수많은 문제에 비하면 극히 일부에 불과한 데이터입니다. 기계가 훈련 데이터에 대해서만 과하게 학습하면 성능 측정을 위한 데이터인 테스트 데이터나 실제 서비스에서는 정확도가 좋지 않은 현상이 발생합니다. 과적합 상황에서는 훈련 데이터에 대해서는 오차가 낮지만, 테스트 데이터에 대해서는 오차가 커집니다. 아래의 그래프는 과적합 상황에서 발생할 수 있는 훈련 데이터에 대한 훈련 횟수에 따른 훈련 데이터의 오차와 테스트 데이터의 오차(또는 손실이라고도 부릅니다.)의 변화를 보여줍니다. 위 그래프는 뒤의 RNN을 이용한 텍스트 분류 챕터의 스팸 메일 분류하기 실습에서 훈련 데이터에 대한 훈련 횟수를 30 에포크로 주어서 의도적으로 과적합을 발생시킨 그래프입니다. y 축은 오차(loss), X 축의 에포크(epoch)는 전체 훈련 데이터에 대한 훈련 횟수를 의미하며, 사람으로 비유하면 동일한 문제지(훈련 데이터)를 반복해서 푼 횟수입니다. 에포크가 지나치게 크면 훈련 데이터에 과적합이 발생합니다. 스팸 메일 분류하기 실습은 에포크가 3~4에서 테스트 데이터에 대한 정확도가 가장 높고, 에포크가 그 이상을 넘어가면 과적합이 발생합니다. 위의 그래프는 에포크가 증가할수록 테스트 데이터에 대한 오차가 점차 증가하는 양상을 보여줍니다. 과적합은 다르게 설명하면 훈련 데이터에 대한 정확도는 높지만, 테스트 데이터는 정확도가 낮은 상황이라고 말할 수도 있습니다. 이런 상황을 방지하기 위해서는 테스트 데이터의 오차가 증가하기 전이나, 정확도가 감소하기 전에 훈련을 멈추는 것이 바람직합니다. 반면, 테스트 데이터의 성능이 올라갈 여지가 있음에도 훈련을 덜 한 상태를 과소 적합(Underfitting)이라고 합니다. 과소 적합은 훈련 자체가 부족한 상태이므로 훈련 횟수인 에포크가 지나치게 적으면 발생할 수 있습니다. 과대 적합과는 달리 과소 적합은 훈련 자체를 너무 적게 한 상태이므로 훈련 데이터에 대해서도 정확도가 낮다는 특징이 있습니다. 이러한 두 가지 현상을 과적합과 과소 적합이라고 부르는 이유는 머신 러닝에서 학습 또는 훈련이라고 하는 과정을 적합(fitting)이라고도 부르기 때문입니다. 모델이 주어진 데이터에 대해서 적합해져가는 과정이기 때문입니다. 이러한 이유로 케라스에서는 기계를 학습시킬 때 fit()을 호출합니다. 바로 뒤의 선형 회귀 실습에서 보게 될 것입니다. 딥 러닝을 할 때는 과적합을 막을 수 있는 드롭아웃(Dropout), 조기 종료(Early Stopping)과 같은 몇 가지 방법이 존재하는데 이는 뒤의 딥 러닝 챕터에서 소개합니다. 과적합과 과소 적합을 설명하면서 테스트 데이터를 사용하여 판단할 수 있다고 설명하였지만, 더 정확히 설명하면 현업에서는 테스트 데이터를 두 가지 용도로 분리하여 사용하는 것이 더 바람직합니다. 각각의 용도는 과적합 모니터링과 하이퍼 파라미터 튜닝을 위한 테스트 데이터와 오직 성능 평가만을 위한 테스트 데이터입니다. 그리고 전자의 테스트 데이터를 검증 데이터라고 부릅니다. 앞에서 데이터를 훈련 데이터, 검증 데이터, 테스트 데이터 세 가지로 나누어야 한다고 언급했던 것을 기억하시나요? 과적합 방지를 고려한 일반적인 딥 러닝 모델의 학습 과정은 다음과 같습니다. Step 1. 주어진 데이터를 훈련 데이터, 검증 데이터, 테스트 데이터로 나눈다. 가령, 6:2:2 비율로 나눌 수 있다. Step 2. 훈련 데이터로 모델을 학습한다. (에포크 +1) Step 3. 검증 데이터로 모델을 평가하여 검증 데이터에 대한 정확도와 오차(loss)를 계산한다. Step 4. 검증 데이터의 오차가 증가하였다면 과적합 징후이므로 학습 종료 후 Step 5로 이동, 아니라면 Step 2.로 재이동한다. Step 5. 모델의 학습이 종료되었으니 테스트 데이터로 모델을 평가한다. 06-03 선형 회귀(Linear Regression) 딥 러닝을 이해하기 위해서는 선형 회귀(Linear Regression)와 로지스틱 회귀(Logsitic Regression)를 이해할 필요가 있습니다. 이번 챕터에서는 머신 러닝에서 쓰이는 용어인 가설(Hypothesis), 손실 함수(Loss Function) 그리고 경사 하강법(Gradient Descent)에 대한 개념과 선형 회귀에 대해서 이해합니다. 1. 선형 회귀(Linear Regression) 시험공부하는 시간을 늘리면 늘릴수록 성적이 잘 나옵니다. 하루에 걷는 횟수를 늘릴수록, 몸무게는 줄어듭니다. 집의 평수가 클수록, 집의 매매 가격은 비싼 경향이 있습니다. 이는 수학적으로 생각해 보면 어떤 요인의 수치에 따라서 특정 요인의 수치가 영향을 받고 있다고 말할 수 있습니다. 조금 더 수학적인 표현을 써보면 어떤 변수의 값에 따라서 특정 변수의 값이 영향을 받고 있다고 볼 수 있습니다. 다른 변수의 값을 변하게 하는 변수를, 변수에 의해서 값이 종속적으로 변하는 변수라고 해봅시다. 이때 변수의 값은 독립적으로 변할 수 있는 것에 반해, 값은 계속해서의 값에 의해서, 종속적으로 결정되므로를 독립 변수,를 종속 변수라고도 합니다. 선형 회귀는 한 개 이상의 독립 변수 와의 선형 관계를 모델링 합니다. 만약, 독립 변수 가 1개라면 단순 선형 회귀라고 합니다. 1) 단순 선형 회귀 분석(Simple Linear Regression Analysis) = x b 위의 수식은 단순 선형 회귀의 수식을 보여줍니다. 여기서 독립 변수 와 곱해지는 값 를 머신 러닝에서는 가중치(weight), 별도로 더해지는 값 를 편향(bias)이라고 합니다. 직선의 방정식에서는 각각 직선의 기울기와 절편을 의미합니다. 와 가 없이 와 란 수식은 는 와 같다는 하나의 식밖에 표현하지 못합니다. 그래프 상으로 말하면 하나의 직선밖에 표현하지 못합니다. = 다시 말해 와의 값에 따라서 와 가 표현하는 직선은 무궁무진해집니다. 2) 다중 선형 회귀 분석(Multiple Linear Regression Analysis) = 1 1 w x + . w x + 집의 매매 가격은 단순히 집의 평수가 크다고 결정되는 게 아니라 집의 층의 수, 방의 개수, 지하철역과의 거리와도 영향이 있습니다. 이러한 다수의 요소를 가지고 집의 매매 가격을 예측해 보고 싶습니다.는 여전히 1개이지만 이제는 1개가 아니라 여러 개가 되었습니다. 이를 다중 선형 회귀 분석이라고 합니다. 이에 대한 실습은 뒤에서 진행합니다. 2. 가설(Hypothesis) 세우기 단순 선형 회귀를 가지고 문제를 풀어봅시다. 어떤 학생의 공부 시간에 따라서 다음과 같은 점수를 얻었다는 데이터가 있습니다. hours( ) score( ) 2 25 3 50 4 42 5 61 이를 좌표 평면에 그려보면 다음과 같습니다. 알고 있는 데이터로부터 와의 관계를 유추하고, 이 학생이 6시간, 7시간, 8시간을 공부하였을 때의 성적을 예측해 보고 싶습니다.와의 관계를 유추하기 위해서 수학적으로 식을 세워보게 되는데 머신 러닝에서는 이러한 식을 가설(Hypothesis)이라고 합니다. 아래의 ( ) 에서는 Hypothesis를 의미합니다. ( ) w + 위의 그림은 와의 값에 따라서 천차만별로 그려지는 직선의 모습을 보여줍니다. 중학교 수학 과정인 직선의 방정식을 알고 있다면, 위의 가설에서는 직선의 기울기이고는 절편으로 직선을 표현함을 알 수 있습니다. 결국 선형 회귀는 주어진 데이터로부터 와의 관계를 가장 잘 나타내는 직선을 그리는 일을 말합니다. 그리고 어떤 직선인지 결정하는 것은 와의 값이므로 선형 회귀에서 해야 할 일은 결국 적절한 와를 찾아내는 일이 됩니다. 아직은 방법을 모르지만, 어떤 방법을 사용하여 적절한 와의 값을 찾은 덕택에 와의 관계를 가장 잘 나타내는 직선을 위의 좌표 평면 상에서 그렸다고 한 번 가정해 보겠습니다. 이 직선을 가 6일 때, 7일 때, 8일 때에 대해서도 계속해서 직선을 그저 이어 그린다면 이 학생이 6시간을 공부했을 때, 7시간을 공부했을 때, 8시간을 공부했을 때의 예상 점수를 말할 수 있게 됩니다. 그저 가 각각 6일 때, 7일 때, 8일 때의 값을 확인하면 되기 때문입니다. 3. 비용 함수(Cost function) : 평균 제곱 오차(MSE) 앞서 주어진 데이터에서 와의 관계를 와를 이용하여 식을 세우는 일을 가설이라고 언급했습니다. 그리고 이제 해야 할 일은 문제에 대한 규칙을 가장 잘 표현하는 와를 찾는 일입니다. 머신 러닝은 와를 찾기 위해서 실제 값과 가설로부터 얻은 예측값의 오차를 계산하는 식을 세우고, 이 식의 값을 최소화하는 최적의 와를 찾아냅니다. 이때 실제 값과 예측값에 대한 오차에 대한 식을 목적 함수(Objective function) 또는 비용 함수(Cost function) 또는 손실 함수(Loss function)라고 합니다. 함수의 값을 최소화하거나, 최대화하거나 하는 목적을 가진 함수를 목적 함수(Objective function)라고 합니다. 그리고 값을 최소화하려고 하면 이를 비용 함수(Cost function) 또는 손실 함수(Loss function)라고 합니다. 이 세 가지는 엄밀히는 같은 의미는 아니지만, 이 책에서는 목적 함수, 비용 함수, 손실 함수란 용어를 같은 의미로 혼용해서 사용합니다. 비용 함수는 단순히 실제 값과 예측값에 대한 오차를 표현하면 되는 것이 아니라, 예측값의 오차를 줄이는 일에 최적화된 식이어야 합니다. 앞으로 배울 러닝, 딥 러닝에는 다양한 문제들이 있고, 각 문제들에는 적합한 비용 함수들이 있습니다. 회귀 문제의 경우에는 주로 평균 제곱 오차(Mean Squared Error, MSE)가 사용됩니다. 위의 그래프에 임의의의 값 13과 임의의의 값 1을 가진 직선을 그렸습니다. 임의로 그린 직선으로 정답이 아닙니다. 이제 이 직선으로부터 서서히 와의 값을 바꾸면서 정답인 직선을 찾아내야 합니다. 사실 와의 관계를 가장 잘 나타내는 직선을 그린다는 것은 위의 그림에서 모든 점들과 위치적으로 가장 가까운 직선을 그린다는 것과 같습니다. 이제 오차(error)를 정의하겠습니다. 오차는 주어진 데이터에서 각에서의 실제 값 와 위의 직선에서 예측하고 있는 ( ) 값의 차이를 말합니다. 즉, 위의 그림에서 ↕는 각 점에서의 오차의 크기를 보여줍니다. 오차를 줄여가면서 와의 값을 찾아내기 위해서는 전체 오차의 크기를 구해야 합니다. 오차의 크기를 측정하기 위한 가장 기본적인 방법은 각 오차를 모두 더하는 방법이 있습니다. 위의 = 13 + 직선이 예측한 예측값을 각각 실제 값으로부터 오차를 계산하여 표를 만들어보면 아래와 같습니다. hours( ) 2 3 4 5 실제 값 25 50 42 61 예측값 27 40 53 66 오차 -2 10 -9 -5 그런데, 수식적으로 단순히 '오차 = 실제 값 - 예측값'이라고 정의한 후에 모든 오차를 더하면 음수 오차도 있고, 양수 오차도 있으므로 오차의 절대적인 크기를 구할 수가 없습니다. 그래서 모든 오차를 제곱하여 더하는 방법을 사용합니다. 다시 말해 위의 그림에서의 모든 점과 직선 사이의 ↕ 거리를 제곱하고 모두 더합니다. 이를 수식으로 표현하면 아래와 같습니다. 단, 여기서 은 갖고 있는 데이터의 개수를 의미합니다. i 1 [ ( ) H ( ( ) ) ] = ( 2 ) + 10 + ( 9 ) + ( 5 ) = 210 이때 데이터의 개수인으로 나누면, 오차의 제곱합에 대한 평균을 구할 수 있는데 이를 평균 제곱 오차(Mean Squered Error, MSE)라고 합니다. 수식은 아래와 같습니다. n i 1 [ ( ) H ( ( ) ) ] = 210 4 52.5 = 13 +의 예측값과 실제 값의 평균 제곱 오차의 값은 52.5입니다. 평균 제곱 오차의 값을 최솟값으로 만드는 와를 찾아내는 것이 정답인 직선을 찾아내는 일입니다. 평균 제곱 오차를 와에 의한 비용 함수(Cost function)로 재정의해 보면 다음과 같습니다. o t ( , ) 1 ∑ = n [ ( ) H ( ( ) ) ] 모든 점들과의 오차가 클수록 평균 제곱 오차는 커지며, 오차가 작아질수록 평균 제곱 오차는 작아집니다. 그러므로 이 평균 최소 오차. 즉, o t ( , ) 를 최소가 되게 만드는 와를 구하면 결과적으로 와의 관계를 가장 잘 나타내는 직선을 그릴 수 있습니다. , → i i i e c s ( , ) 4. 옵티마이저(Optimizer) : 경사하강법(Gradient Descent) 선형 회귀를 포함한 수많은 머신 러닝, 딥 러닝의 학습은 결국 비용 함수를 최소화하는 매개 변수인 와 을 찾기 위한 작업을 수행합니다. 이때 사용되는 알고리즘을 옵티마이저(Optimizer) 또는 최적화 알고리즘이라고 부릅니다. 그리고 이 옵티마이저를 통해 적절한 와를 찾아내는 과정을 머신 러닝에서 훈련(training) 또는 학습(learning)이라고 부릅니다. 여기서는 가장 기본적인 옵티마이저 알고리즘인 경사 하강법(Gradient Descent)에 대해서 배웁니다. 경사 하강법을 이해하기 위해서 cost와 기울기와의 관계를 이해해 보겠습니다.는 머신 러닝 용어로는 가중치라고 불리지만, 직선의 방정식 관점에서 보면 직선의 기울기를 의미하고 있습니다. 아래의 그래프는 기울기 가 지나치게 높거나, 낮을 때 어떻게 오차가 커지는 모습을 보여줍니다. 위의 그림에서 주황색선은 기울기 가 20일 때, 초록색선은 기울기 가 1일 때를 보여줍니다. 각각 = 20 , =에 해당되는 직선입니다. ↕는 각 점에서의 실제 값과 두 직선의 예측값과의 오차를 보여줍니다. 이는 앞서 예측에 사용했던 = 13 + 직선보다 확연히 큰 오차 값들입니다. 즉, 기울기가 지나치게 크면 실제 값과 예측값의 오차가 커지고, 기울기가 지나치게 작아도 실제 값과 예측값의 오차가 커집니다. 사실 또한 마찬가지인데 가 지나치게 크거나 작으면 오차가 커집니다. 설명의 편의를 위해 편향 가 없이 단순히 가중치 만을 사용한 = x 라는 가설 ( ) 를 가지고, 경사 하강법을 수행한다고 해보겠습니다. 비용 함수의 값 o t ( ) 는 cost라고 줄여서 표현해 보겠습니다. 이에 따라와 cost의 관계를 그래프로 표현하면 다음과 같습니다. 기울기 가 무한대로 커지면 커질수록 cost의 값 또한 무한대로 커지고, 반대로 기울기 가 무한대로 작아져도 cost의 값은 무한대로 커집니다. 위의 그래프에서 cost가 가장 작을 때는 볼록한 부분의 맨 아래 부분입니다. 기계가 해야 할 일은 cost가 가장 최솟값을 가지게 하는 를 찾는 일이므로, 볼록한 부분의 맨 아랫부분의의 값을 찾아야 합니다. 기계는 임의의 랜덤 값 값을 정한 뒤에, 맨 아래의 볼록한 부분을 향해 점차의 값을 수정해나갑니다. 위의 그림은 값이 점차 수정되는 과정을 보여줍니다. 그리고 이를 가능하게 하는 것이 경사 하강법(Gradient Descent)입니다. 이를 이해하기 위해서는 고등학교 수학 과정인 미분을 이해해야 합니다. 경사 하강법은 미분을 배우게 되면 가장 처음 배우게 되는 개념인 한 점에서의 순간 변화율 또는 다른 표현으로는 접선에서의 기울기의 개념을 사용합니다. 위의 그림에서 초록색 선은 가 임의의 값을 가지게 되는 네 가지의 경우에 대해서, 그래프 상으로 접선의 기울기를 보여줍니다. 주목할 것은 맨 아래의 볼록한 부분으로 갈수록 접선의 기울기가 점차 작아진다는 점입니다. 그리고 맨 아래의 볼록한 부분에서는 결국 접선의 기울기가 0이 됩니다. 그래프 상으로는 초록색 화살표가 수평이 되는 지점입니다. 즉, cost가 최소화가 되는 지점은 접선의 기울기가 0이 되는 지점이며, 또한 미분 값이 0이 되는 지점입니다. 경사 하강법의 아이디어는 비용 함수(Cost function)를 미분하여 현재에서의 접선의 기울기를 구하고, 접선의 기울기가 낮은 방향으로의 값을 변경하고 다시 미분하고 이 과정을 접선의 기울기가 0인 곳을 향해의 값을 변경하는 작업을 반복하는 것에 있습니다. 비용 함수(Cost function)는 아래와 같았습니다. o t ( , ) 1 ∑ = n [ ( ) H ( ( ) ) ] 이제 비용(cost)를 최소화하는 를 구하기 위해를 업데이트하는 식은 다음과 같습니다. 이를 접선의 기울기가 0이 될 때까지 반복합니다. := − ∂ w o t ( ) 위의 식은 현재에서의 접선의 기울기와 와 곱한 값을 현재에서 빼서 새로운의 값으로 한다는 것을 의미합니다. 는 여기서 학습률(learning rate)이라고 하는데, 우선 는 생각하지 않고 현재에서 현재에서의 접선의 기울기를 빼는 행위가 어떤 의미가 있는지 알아보겠습니다. 위의 그림은 접선의 기울기가 음수일 때, 0일 때, 양수일 때를 보여줍니다. 접선의 기울기가 음수일 때의 수식은 아래와 같이 표현할 수 있습니다. 음수 기울기 := − ( 음수 기울기 ) 기울기가 음수 면 '음수를 빼는 것'은 곧 '해당 값을 양수로 바꾸고 더하는 것'과 같습니다. (가령, 어떤 수에서 -2를 뺀다는 것은 해당 숫자에 2를 더하는 것과 같습니다.) 결국 음수 기울기를 빼면의 값이 증가하게 되는데 이는 결과적으로 접선의 기울기가 0인 방향으로의 값이 조정됩니다. 만약, 접선의 기울기가 양수라면 위의 수식은 아래와 같이 표현할 수 있습니다. 양수 기울기 := − ( 양수 기울기 ) 기울기가 양수면의 값이 감소하게 되는데 이는 결과적으로 기울기가 0인 방향으로의 값이 조정됩니다. 결국, 아래의 수식은 접선의 기울기가 음수거나, 양수일 때 모두 접선의 기울기가 0인 방향으로의 값을 조정합니다. := − ∂ w o t ( ) 그렇다면 여기서 학습률(learning rate)이라고 말하는 는 어떤 의미를 가질까요? 학습률 은의 값을 변경할 때, 얼마나 크게 변경할지를 결정하며 0과 1사이의 값을 가지도록 합니다. 예를 들어서 0.01이 될 수 있겠습니다. 학습률은 를 그래프의 한 점으로 보고 접선의 기울기가 0일 때까지 경사를 따라 내려간다는 관점에서는 얼마나 큰 폭으로 이동할지를 결정합니다. 직관적으로 생각하기에 학습률의 값을 무작정 크게 하면 접선의 기울기가 최소값이 되는 를 빠르게 찾을 수 있을 것 같지만 그렇지 않습니다. 위의 그림은 학습률 가 지나치게 높은 값을 가질 때, 접선의 기울기가 0이 되는 를 찾아가는 것이 아니라 o t 의 값이 발산하는 상황을 보여줍니다. 반대로 학습률 가 지나치게 낮은 값을 가지면 학습 속도가 느려지므로 적당한 의 값을 찾아내는 것도 중요합니다. 지금까지는 는 배제시키고 최적의 를 찾아내는 것에만 초점을 맞추어 경사 하강법의 원리에 대해서 배웠는데, 실제 경사 하강법은 와에 대해서 동시에 경사 하강법을 수행하면서 최적의 와의 값을 찾아갑니다. 정리하자면 가설, 비용 함수, 옵티마이저는 머신 러닝 분야에서 사용되는 포괄적 개념입니다. 풀고자 하는 각 문제에 따라 가설, 비용 함수, 옵티마이저는 전부 다를 수 있으며 선형 회귀에 가장 적합한 비용 함수와 옵티마이저가 알려져 있는데 이번 챕터에서 언급된 MSE와 경사 하강법이 각각 이에 해당됩니다. 06-04 자동 미분과 선형 회귀 실습 선형 회귀를 텐서 플로와 케라스를 통해 구현해 봅시다. 1. 자동 미분 import tensorflow as tf tape_gradient()는 자동 미분 기능을 수행합니다. 임의로 w +라는 식을 세워보고,에 대해 미분해 보겠습니다. w = tf.Variable(2.) def f(w): y = w**2 z = 2*y + 5 return z gradients를 출력하면에 대해 미분한 값이 저장된 것을 확인할 수 있습니다. with tf.GradientTape() as tape: z = f(w) gradients = tape.gradient(z, [w]) print(gradients) [<tf.Tensor: shape=(), dtype=float32, numpy=8.0>] 이 자동 미분 기능을 사용하여 선형 회귀를 구현해 봅시다. 2. 자동 미분을 이용한 선형 회귀 구현 우선 가중치 변수 w와 b를 선언합니다. 학습될 값이므로 임의의 값인 4와 1로 초기화하였습니다. # 학습될 가중치 변수를 선언 w = tf.Variable(4.0) b = tf.Variable(1.0) 가설을 함수로서 정의합니다. @tf.function def hypothesis(x): return w*x + b 현재의 가설에서 w와 b는 각각 4와 1이므로 임의의 입력값을 넣었을 때의 결과는 다음과 같습니다. x_test = [3.5, 5, 5.5, 6] print(hypothesis(x_test).numpy()) [15. 21. 23. 25.] 다음과 같이 평균 제곱 오차를 손실 함수로서 정의합니다. @tf.function def mse_loss(y_pred, y): # 두 개의 차이 값을 제곱을 해서 평균을 취한다. return tf.reduce_mean(tf.square(y_pred - y)) 여기서 사용할 데이터는 x와 y가 약 10배의 차이를 가지는 데이터입니다. x = [1, 2, 3, 4, 5, 6, 7, 8, 9] # 공부하는 시간 y = [11, 22, 33, 44, 53, 66, 77, 87, 95] # 각 공부 하는 시간에 매핑되는 성적 옵티마이저는 경사 하강법을 사용하되, 학습률(learning rate)는 0.01을 사용합니다. optimizer = tf.optimizers.SGD(0.01) 약 300번에 걸쳐서 경사 하강법을 수행하겠습니다. for i in range(301): with tf.GradientTape() as tape: # 현재 파라미터에 기반한 입력 x에 대한 예측값을 y_pred y_pred = hypothesis(x) # 평균 제곱 오차를 계산 cost = mse_loss(y_pred, y) # 손실 함수에 대한 파라미터의 미분 값 계산 gradients = tape.gradient(cost, [w, b]) # 파라미터 업데이트 optimizer.apply_gradients(zip(gradients, [w, b])) if i % 10 == 0: print("epoch : {:3} | w의 값 : {:5.4f} | b의 값 : {:5.4} | cost : {:5.6f}".format(i, w.numpy(), b.numpy(), cost)) epoch : 0 | w의 값 : 8.2133 | b의 값 : 1.664 | cost : 1402.555542 ... 중략 ... epoch : 280 | w의 값 : 10.6221 | b의 값 : 1.191 | cost : 1.091434 epoch : 290 | w의 값 : 10.6245 | b의 값 : 1.176 | cost : 1.088940 epoch : 300 | w의 값 : 10.6269 | b의 값 : 1.161 | cost : 1.086645 w와 b 값이 계속 업데이트 됨에 따라서 cost가 지속적으로 줄어드는 것을 확인할 수 있습니다. 학습된 w와 b의 값에 대해서 임의 입력을 넣었을 경우의 예측값을 확인해 봅시다. x_test = [3.5, 5, 5.5, 6] print(hypothesis(x_test).numpy()) [38.35479 54.295143 59.608593 64.92204 ] 모델을 구현하는 방법은 한 가지가 아닙니다. 텐서 플로의 경우, 케라스라는 고 수준의 API를 사용하면 모델을 이보다 좀 더 쉽게 구현할 수 있습니다. 이번에는 선형 회귀 모델을 케라스로 구현해 봅시다. 3. 케라스로 구현하는 선형 회귀 케라스에 대해서는 뒤의 딥 러닝 챕터에서 더 자세히 배우겠지만, 간단하게 케라스를 이용해서 선형 회귀를 구현해 봅시다. 케라스로 모델을 만드는 기본적인<NAME>은 다음과 같습니다. Sequential로 model이라는 이름의 모델을 만들고, 그리고 add를 통해 입력과 출력 벡터의 차원과 같은 필요한 정보들을 추가해갑니다. 아래의 예시 코드를 봅시다. 첫 번째 인자인 1은 출력의 차원을 정의합니다. 일반적으로 output_dim으로 표현되는 인자입니다. 두 번째 인자인 input_dim은 입력의 차원을 정의하는데 이번 실습과 같이 1개의 실수를 가지고 하는 1개의 실수를 예측하는 단순 선형 회귀를 구현하는 경우에는 각각 1의 값을 가집니다.. # 예시 코드. 실행 불가. model = Sequential() model.add(keras.layers.Dense(1, input_dim=1)) 실습을 진행해 봅시다. 아래의 코드는 간단하지만, 지금까지 배운 것들이 집대성된 코드입니다. 우선 공부한 시간을, 각 공부 한 시간에 따른 성적을라고 해봅시다. activation은 어떤 함수를 사용할 것인지를 의미하는데 선형 회귀를 사용할 경우에는 linear라고 기재합니다. 옵티마이저로 기본 경사 하강법을 사용하고 싶다면, sgd라고 기재합니다. 학습률은 0.01로 정하였습니다. 손실 함수로는 평균 제곱 오차를 사 용합니다. 그리고 전체 데이터에 대한 훈련 횟수는 300으로 합니다. import numpy as np import matplotlib.pyplot as plt from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense from tensorflow.keras import optimizers x = [1, 2, 3, 4, 5, 6, 7, 8, 9] # 공부하는 시간 y = [11, 22, 33, 44, 53, 66, 77, 87, 95] # 각 공부 하는 시간에 매핑되는 성적 model = Sequential() # 출력 y의 차원은 1. 입력 x의 차원(input_dim)은 1 # 선형 회귀이므로 activation은 'linear' model.add(Dense(1, input_dim=1, activation='linear')) # sgd는 경사 하강법을 의미. 학습률(learning rate, lr)은 0.01. sgd = optimizers.SGD(lr=0.01) # 손실 함수(Loss function)은 평균제곱오차 mse를 사용합니다. model.compile(optimizer=sgd, loss='mse', metrics=['mse']) # 주어진 x와 y 데이터에 대해서 오차를 최소화하는 작업을 300번 시도합니다. model.fit(x, y, epochs=300) 학습이 끝났습니다. 최종적으로 선택된 오차를 최소화하는 직선을 그래프로 그려보겠습니다. plt.plot(x, model.predict(x), 'b', x, y, 'k.') 위의 그래프에서 각 점은 우리가 실제 주었던 실제 값에 해당되며, 직선은 실제 값으로부터 오차를 최소화하는 와의 값을 가지는 직선입니다. 이 직선을 통해 9시간 30분을 공부하였을 때의 시험 성적을 예측하게 해봅시다. model.predict()은 학습이 완료된 모델이 입력된 데이터에 대해서 어떤 값을 예측하는지를 보여줍니다. print(model.predict([9.5])) [[98.556465]] 9시간 30분을 공부하면 약 98.5점을 얻는다고 예측하고 있습니다. 06-05 로지스틱 회귀(Logistic Regression) 일상 속 풀고자 하는 많은 문제 중에서는 두 개의 선택지 중에서 정답을 고르는 문제가 많습니다. 예를 들어 시험을 봤는데 이 시험 점수가 합격인지 불합격인지가 궁금할 수도 있고, 어떤 메일을 받았을 때 이게 정상 메일인지 스팸 메일인지를 분류하는 문제도 그렇습니다. 이렇게 둘 중 하나를 결정하는 문제를 이진 분류(Binary Classification)라고 합니다. 그리고 이런 문제를 풀기 위한 대표적인 알고리즘으로 로지스틱 회귀(Logistic Regression)가 있습니다. 1. 이진 분류(Binary Classification) 앞서 선형 회귀를 설명하며 공부 시간과 성적 간의 관계를 직선의 방정식으로 표현한다는 가설 하에, 주어진 데이터로부터 가중치 와 편향 를 찾아 데이터를 가장 잘 표현하는 직선을 찾았습니다. 그런데 이번에 배울 둘 중 하나의 선택지 중에서 정답을 고르는 이진 분류 문제는 직선으로 표현하는 것이 적절하지 않습니다. 학생들이 시험 성적에 따라서 합격, 불합격이 기재된 데이터가 있다고 가정해 봅시다. 시험 성적이라면, 합불 결과는입니다. 이 데이터로부터 특정 점수를 얻었을 때의 합격, 불합격 여부를 판정하는 모델을 만들고자 합시다. score( ) result( ) 45 불합격 50 불합격 55 불합격 60 합격 65 합격 70 합격 위 데이터에서 합격을 1, 불합격을 0이라고 하였을 때 그래프를 그려보면 아래와 같습니다. 이러한 점들을 표현하는 그래프는 알파벳의 S자 형태로 표현됩니다. 이러한 와의 관계를 표현하기 위해서는 직선을 표현하는 함수가 아니라 S자 형태로 표현할 수 있는 함수가 필요합니다. 직선을 사용할 경우 보통 분류 작업이 제대로 동작하지 않습니다. 이번 예제의 경우 실제 값. 즉, 레이블에 해당하는 가 0 또는 1이라는 두 가지 값만을 가지므로, 이 문제를 풀기 위해서 예측값은 0과 1사이의 값을 가지도록 합니다. 0과 1사이의 값을 확률로 해석하면 문제를 풀기가 훨씬 용이해집니다. 최종 예측값이 0.5보다 작으면 0으로 예측했다고 판단하고, 0.5보다 크면 1로 예측했다고 판단합니다. 만약 = x b 의 직선을 사용할 경우, 값이 음의 무한대부터 양의 무한대와 같은 큰 수들도 가질 수 있는데 이는 직선이 분류 문제에 적합하지 않은 두 번째 이유입니다. 출력이 0과 1사이의 값을 가지면서 S자 형태로 그려지는 함수로 시그모이드 함수(Sigmoid function)가 있습니다. 2. 시그모이드 함수(Sigmoid function) 시그모이드 함수는 종종 σ로 축약해서 표현하기도 합니다. 로지스틱 회귀를 풀기 위한 가설을 세워봅시다. ( ) 1 + − ( x b ) s g o d ( x b ) σ ( x b ) 여기서 e(e=2.718281...)는 자연 상수라 불리는 숫자입니다. 여기서 구해야 할 것은 여전히 주어진 데이터에 가장 적합한 가중치 (weight)와 편향 (bias)입니다. 인공 지능 알고리즘이 하는 것은 결국 주어진 데이터에 적합한 가중치 와를 구하는 것입니다. 시그모이드 함수를 그래프로 시각화해봅시다. import numpy as np import matplotlib.pyplot as plt 아래의 그래프는 는 1,는 0임을 가정한 그래프입니다. def sigmoid(x): return 1/(1+np.exp(-x)) x = np.arange(-5.0, 5.0, 0.1) y = sigmoid(x) plt.plot(x, y, 'g') plt.plot([0,0],[1.0,0.0], ':') # 가운데 점선 추가 plt.title('Sigmoid Function') plt.show() 위의 그래프에서 시그모이드 함수는 출력값을 0과 1사이의 값으로 조정하여 반환합니다. 마치 S자의 모양을 연상시킵니다. 가 0일 때 출력값은 0.5의 값을 가집니다. 가 증가하면 1에 수렴합니다. 가중치 와 편향 이 출력값에 어떤 영향을 미치는지 시각화를 통해 알아보겠습니다. 우선의 값을 변화시키고 이에 따른 그래프를 확인해 봅시다. def sigmoid(x): return 1/(1+np.exp(-x)) x = np.arange(-5.0, 5.0, 0.1) y1 = sigmoid(0.5*x) y2 = sigmoid(x) y3 = sigmoid(2*x) plt.plot(x, y1, 'r', linestyle='--') # w의 값이 0.5일 때 plt.plot(x, y2, 'g') # w의 값이 1일 때 plt.plot(x, y3, 'b', linestyle='--') # w의 값이 2일 때 plt.plot([0,0],[1.0,0.0], ':') # 가운데 점선 추가 plt.title('Sigmoid Function') plt.show() 위 그래프는 의 값이 0.5일 때 빨간색 선,의 값이 1일 때는 초록색선, 의 값이 2일 때 파란색 선이 나오도록 하였습니다.의 값에 따라 그래프의 경사도가 변합니다. 선형 회귀에서 직선을 표현할 때, 가중치는 직선의 기울기를 의미했지만 여기서는 그래프의 경사도를 결정합니다.의 값이 커지면 경사가 커지고의 값이 작아지면 경사가 작아집니다.의 값에 따라서 그래프가 어떻게 변하는지 보겠습니다. def sigmoid(x): return 1/(1+np.exp(-x)) x = np.arange(-5.0, 5.0, 0.1) y1 = sigmoid(x+0.5) y2 = sigmoid(x+1) y3 = sigmoid(x+1.5) plt.plot(x, y1, 'r', linestyle='--') # x + 0.5 plt.plot(x, y2, 'g') # x + 1 plt.plot(x, y3, 'b', linestyle='--') # x + 1.5 plt.plot([0,0],[1.0,0.0], ':') # 가운데 점선 추가 plt.title('Sigmoid Function') plt.show() 위 그래프는 값에 따라서 그래프가 이동하는 것을 보여줍니다. 시그모이드 함수는 입력값이 커지면 1에 수렴하고, 입력값이 작아지면 0에 수렴합니다. 0부터의 1까지의 값을 가지는데 출력값이 0.5 이상이면 1(True), 0.5이하면 0(False)로 만들면 이진 분류 문제를 풀기 위해서 사용할 수 있습니다. 3. 비용 함수(Cost function) 로지스틱 회귀 또한 경사 하강법을 사용하여 가중치를 찾아내지만, 비용 함수로는 평균 제곱 오차를 사용하지 않습니다. 평균 제곱 오차를 로지스틱 회귀의 비용 함수로 사용했을 때는 좋지 않은 로컬 미니멈에 빠질 가능성이 지나치게 높아 문제 해결이 어렵습니다. 로지스틱 회귀에서 평균 제곱 오차를 비용 함수로 사용하면, 경사 하강법을 사용하였을 때 찾고자 하는 최솟값이 아닌 잘못된 최솟값에 빠질 가능성이 매우 높습니다. 이를 전체 함수에 걸쳐 최솟값인 글로벌 미니멈(Global Minimum) 이 아닌 특정 구역에서의 최솟값인 로컬 미니멈(Local Minimum)에 도달했다고 합니다. 로컬 미니멈에 지나치게 쉽게 빠지는 비용 함수는 cost가 가능한 한 최소가 되는 가중치를 찾는다는 목적에는 좋지 않은 선택입니니다. 그리고 로지스틱 회귀에서의 평균 제곱 오차는 바로 그 좋지 않은 선택에 해당합니다. 로지스틱 회귀라는 문제에서 가중치를 최소로 만드는 적절한 새로운 비용 함수를 찾아야 합니다. 가중치를 최소화하는 아래의 어떤 함수를 목적 함수라고 합시다.는 목적 함수(objective function)를 의미합니다. ( ) 1 ∑ = n ( ( ( ) ) y ( ) ) ) 아직 완성된 식이 아닙니다. 위의 식에서 샘플 데이터의 개수가 개고, 어떤 함수 가 실제 값 i 와 예측값 ( i ) 의 오차를 나타내는 함수라고 할 때, 여기서 새로운 함수를 어떻게 정의하느냐에 따라서 가중치를 최소화하는 적절한 목적 함수가 완성됩니다. 목적 함수는 전체 데이터에 대해서 어떤 함수의 값의 평균을 계산하고 있습니다. 적절한 가중치를 찾기 위해서 결과적으로 실제 값과 예측값에 대한 오차를 줄여야 하므로 여기서 이는 비용 함수(cost function)라고 하겠습니다. 식을 다시 쓰면 아래와 같습니다. ( ) 1 ∑ = n o t ( ( ( ) ) y ( ) ) ) 시그모이드 함수는 0과 1사이의 값을 반환합니다. 이는 실제 값이 0일 때 값이 1에 가까워지면 오차가 커지며 실제 값이 1일 때 값이 0에 가까워지면 오차가 커짐을 의미합니다. 그리고 이를 반영할 수 있는 함수는 로그 함수를 통해 표현 가능합니다. if = → cost ( ( ) y ) − log ( ( ) ) if = → cost ( ( ) y ) − log ( − ( ) )의 실제 값이 1일 때 l g ( ) 그래프를 사용하고의 실제 값이 0일 때 l g ( − ( ) ) 그래프를 사용해야 합니다. 위의 두 식을 그래프 상으로 표현하면 아래와 같습니다. 실제 값 가 1일 때의 그래프를 파란색 선으로 표현하였으며, 실제 값 가 0일 때의 그래프를 빨간색 선으로 표현하였습니다. 위의 그래프를 간략히 설명하면, 실제 값이 1일 때, 예측값인 ( ) 의 값이 1이면 오차가 0이므로 당연히 cost는 0이 됩니다. 반면, 실제 값이 1일 때, ( ) 가 0으로 수렴하면 cost는 무한대로 발산합니다. 실제 값이 0인 경우는 그 반대로 이해하면 됩니다. 이는 다음과 같이 하나의 식으로 표현할 수 있습니다. cost ( ( ) y ) − [ l g ( ) ( − ) o ( − ( ) ) ] 자세히 보면 와 ( − ) 가 식 중간에 들어갔고, 두 개의 식을 -로 묶은 것 외에는 기존의 두 식이 들어가 있는 것을 볼 수 있습니다. 가 0이면 l g ( ) 가 없어지고, 가 1이면 ( − ) o ( − ( ) ) 가 없어지는데 이는 각각 가 1일 때와 가 0일 때의 앞서 본 식과 동일합니다. 결과적으로 로지스틱 회귀의 목적 함수는 아래와 같습니다. ( ) − n i 1 [ ( ) o H ( ( ) ) ( − ( ) ) o ( − ( ( ) ) ) ] 이때 로지스틱 회귀에서 찾아낸 비용 함수를 크로스 엔트로피(Cross Entropy) 함수라고 합니다. 결론적으로 로지스틱 회귀는 비용 함수로 크로스 엔트로피 함수를 사용하며, 가중치를 찾기 위해서 크로스 엔트로피 함수의 평균을 취한 함수를 사용합니다. 크로스 엔트로피 함수는 소프트맥스 회귀의 비용 함수이기도 하므로 뒤에서 재 언급합니다. 06-06 로지스틱 회귀 실습 로지스틱 회귀를 케라스를 통해 구현해 봅시다. 1. 케라스로 구현하는 로지스틱 회귀 독립 변수 데이터를, 숫자 10 이상인 경우에는 1, 미만인 경우에는 0을 부여한 레이블 데이터를 라고 해봅시다. 이번 데이터는 앞서 배운 단순 선형 회귀 때와 마찬가지로 1개의 실수로부터 1개의 실수인 를 예측하는 매핑 관계를 가지므로 Dense의 output_dim, input_dim 인자 값으로 각각 1을 기재합니다. 시그모이드 함수를 사용할 것이므로 activation의 인자 값으로는 sigmoid를 기재해 줍니다. 옵티마이저로는 가장 기본적인 경사 하강 법인 sgd를 사용하였습니다. 시그모이드 함수를 사용한 이진 분류 문제에 손실 함수로 크로스 엔트로피 함수를 사용할 경우 binary_crossentropy를 기재해 주면 됩니다. 에포크는 200으로 합니다. import numpy as np import matplotlib.pyplot as plt from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense from tensorflow.keras import optimizers x = np.array([-50, -40, -30, -20, -10, -5, 0, 5, 10, 20, 30, 40, 50]) y = np.array([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1]) # 숫자 10부터 1 model = Sequential() model.add(Dense(1, input_dim=1, activation='sigmoid')) sgd = optimizers.SGD(lr=0.01) model.compile(optimizer=sgd, loss='binary_crossentropy', metrics=['binary_accuracy']) model.fit(x, y, epochs=200) 총 200회에 걸쳐 전체 데이터에 대한 오차를 최소화하는 와를 찾아내는 작업을 합니다. 저자의 경우 약 190회부터 정확도가 100%가 나오기 시작했습니다. 실제 값과 오차를 최소화하도록 값이 변경된 와의 값을 가진 모델을 이용하여 그래프를 그려보겠습니다. plt.plot(x, model.predict(x), 'b', x, y, 'k.')의 값이 5와 10사이의 어떤 값일 때 값이 0.5가 넘기 시작하는 것처럼 보입니다. 정확도가 100%가 나왔었기 때문에 적어도의 값이 5일 때는 값이 0.5보다 작고,의 값이 10일 때는 값이 0.5를 넘을 것입니다. 이제 의 값이 5보다 작은 값일 때와의 값이 10보다 클 때에 대해서 값을 출력해 봅시다. print(model.predict([1, 2, 3, 4, 4.5])) print(model.predict([11, 21, 31, 41, 500])) [[0.21071826] [0.26909265] [0.33673897] [0.41180944] [0.45120454]] [[0.86910886] [0.99398106] [0.99975663] [0.9999902 ] [1. ]]의 값이 5보다 작을 때는 0.5보다 작은 값을,의 값이 10보다 클 때는 0.5보다 큰 값을 출력하는 것을 볼 수 있습니다. 06-07 다중 입력에 대한 실습 독립 변수 가 2개 이상인 경우에 대해서 학습합니다. 비용 함수와 옵티마이저 등을 사용하는 방법은 동일합니다. import numpy as np from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense from tensorflow.keras import optimizers 1. 다중 선형 회귀 딥 러닝 챕터로 들어가게 되면 대부분의 입력들은 독립 변수가 2개 이상입니다. 모델을 직접 코딩하는 관점에서는 입력 벡터의 차원이 2 이상이라고 할 수 있습니다.를 결정하는 데 있어 독립 변수가 3개인 선형 회귀를 풀어봅시다. 중간고사, 기말고사, 그리고 추가 점수를 어떤 공식을 통해 최종 점수를 계산한 데이터가 있습니다. Midterm( 1 ) Final( 2 ) Added point( 3 ) Score($1000)(y) 70 85 11 73 71 89 18 82 50 80 20 72 99 20 10 57 50 10 10 34 20 99 10 58 40 50 20 56 ( ) w x + 2 2 w x + 3개의 특성을 가진 벡터 [ 1 x, 3 ] 를 대문자로 표기합니다. 위 데이터의 샘플 중 상위 5개의 데이터만 훈련에 사용하고, 나머지 2개는 테스트에 사용해 보겠습니다. 입력의 차원이 3으로 바뀌면서, input_dim의 인자 값이 3으로 변경됩니다. 이는 입력 벡터의의 원소의 개수가 3개라고도 표현할 수 있고, 입력 벡터의 차원이 3임을 의미합니다. # 중간고사, 기말고사, 가산점 점수 X = np.array([[70,85,11], [71,89,18], [50,80,20], [99,20,10], [50,10,10]]) y = np.array([73, 82 ,72, 57, 34]) # 최종 성적 model = Sequential() model.add(Dense(1, input_dim=3, activation='linear')) sgd = optimizers.SGD(learning_rate=0.0001) model.compile(optimizer=sgd, loss='mse', metrics=['mse']) model.fit(X, y, epochs=2000) 모델의 학습이 끝났습니다. 학습된 모델에 입력 X에 대한 예측을 해봅시다. print(model.predict(X)) [[73.15294 ] [81.98001 ] [71.93192 ] [57.161617] [33.669353]] 실제 값에 근접한 예측을 하는 것을 볼 수 있습니다. 훈련할 때 사용하지 않았던 데이터를 가지고 예측 작업을 수행해 보겠습니다. X_test = np.array([[20,99,10], [40,50,20]]) print(model.predict(X_test)) [[58.08134 ] [55.734634]] 2. 다중 로지스틱 회귀를 결정하는 데 있어 독립 변수 가 2개인 로지스틱 회귀를 풀어봅시다. 꽃받침(Sepal)의 길이와 꽃잎(Petal)의 길이와 해당 꽃이 A 인지 B 인지가 적혀져 있는 데이터가 있을 때, 새로 조사한 꽃받침의 길이와 꽃잎의 길이로부터 무슨 꽃인지 예측할 수 있는 모델을 만들고자 한다면 이때 독립 변수는 2개가 됩니다. SepalLengthCm( 1 ) PetalLengthCm( 2 ) Species(y) 5.1 3.5 A 4.7 3.2 A 5.2 1.8 B 7 4.1 A 5.1 2.1 B ( ) s g o d ( 1 1 w x + ) 2개의 특성을 가진 벡터 [ 1 x ] 를 대문자로 표기합니다. 독립 변수가 2개인 좀 간단한 새로운 예를 들어서 이를 케라스로 구현해 봅시다. 두 개의 입력 1 x의 합이 2 이상이면 출력값 가 1이 되고 두 개의 입력의 합이 2미만인 경우에만 출력값이 0이 되는 로직을 구현해 봅시다. 앞서 실습한 로지스틱 회귀 코드와 거의 동일한데 달라진 점은 입력의 차원이 2로 바뀌면서 input_dim의 값이 2라는 점입니다. 이는 입력 벡터의 차원이 2임을 의미합니다. X = np.array([[0, 0], [0, 1], [1, 0], [0, 2], [1, 1], [2, 0]]) y = np.array([0, 0, 0, 1, 1, 1]) model = Sequential() model.add(Dense(1, input_dim=2, activation='sigmoid')) model.compile(optimizer='sgd', loss='binary_crossentropy', metrics=['binary_accuracy']) model.fit(X, y, epochs=2000) 2000에포크 정도로 학습을 멈추고 각 입력에 대해서 출력값이 0.5보다 크고 작은지를 확인해 보겠습니다. print(model.predict(X)) [[0.23379876] [0.48773268] [0.4808667 ] [0.7481605 ] [0.74294543] [0.7376603 ]] 입력의 합이 2 이상인 경우에는 전부 값이 0.5를 넘는 것을 볼 수 있습니다. 3. 인공 신경망 다이어그램 다중 로지스틱 회귀를 인공 신경망의 형태로 표현하면 다음과 같습니다. 아직 인공 신경망을 배우지 않았음에도 이렇게 다이어그램으로 표현해 보는 이유는 로지스틱 회귀를 일종의 인공 신경망 구조로 해석해도 무방함을 보여주기 위함입니다. = i m i ( 1 1 w x + 3 3. . w x + ) σ ( 1 06-08 벡터와 행렬 연산 앞서 독립 변수 가 2개 이상인 선형 회귀와 로지스틱 회귀에 대해서 배웠습니다. 그런데 다음 실습인 소프트맥스 회귀에서는 종속 변수의 종류도 3개 이상이 되면서 더욱 복잡해집니다. 그리고 이러한 식들이 겹겹이 누적되면 인공 신경망의 개념이 됩니다. 케라스는 사용하기가 편리해서 이런 고민을 할 일이 상대적으로 적지만, Numpy나 텐서 플로의 로우-레벨(low-level)의 머신 러닝 개발을 하게 되면 각 변수들의 연산을 벡터와 행렬 연산으로 이해할 수 있어야 합니다. 다시 말해 사용자가 데이터와 변수의 개수로부터 행렬의 크기, 더 나아가 텐서의 크기를 산정할 수 있어야 합니다. 기본적인 벡터와 행렬 연산에 대해서 이해해 보겠습니다. 1. 벡터와 행렬과 텐서 벡터는 크기와 방향을 가진 양입니다. 숫자가 나열된 형상이며 파이썬에서는 1차원 배열 또는 리스트로 표현합니다. 반면, 행렬은 행과 열을 가지는 2차원 형상을 가진 구조입니다. 파이썬에서는 2차원 배열로 표현합니다. 가로줄을 행(row)라고 하며, 세로줄을 열(column)이라고 합니다. 3차원부터는 주로 텐서라고 부릅니다. 텐서는 파이썬에서는 3차원 이상의 배열로 표현합니다. 2. 텐서(Tensor) 인공 신경망은 복잡한 모델 내의 연산을 주로 행렬 연산을 통해 해결합니다. 그런데 여기서 말하는 행렬 연산이란 단순히 2차원 배열을 통한 행렬 연산만을 의미하는 것이 아닙니다. 머신 러닝의 입, 출력이 복잡해지면 3차원 텐서에 대한 이해가 필수로 요구됩니다. 예를 들어 인공 신경망 모델 중 하나인 RNN에서는 3차원 텐서에 대한 개념 이해 없이는 이해하기가 쉽지 않습니다. Numpy를 사용하여 텐서를 설명해 보겠습니다. import numpy as np 1) 0차원 텐서(스칼라) 스칼라는 하나의 실숫값으로 이루어진 데이터를 말합니다. 이를 0차원 텐서라고 합니다. 차원을 영어로 Dimension이라고 하므로 0D 텐서라고도 합니다. d = np.array(5) print('텐서의 차원 :',d.ndim) print('텐서의 크기(shape) :',d.shape) 텐서의 차원 : 0 텐서의 크기(shape) : () Numpy의 ndim을 출력했을 때 나오는 값에 주목합시다. ndim을 출력했을 때 나오는 값을 우리는 축(axis)의 개수 또는 텐서의 차원이라고 부릅니다. 반드시 이 두 용어를 기억해둡시다. 2) 1차원 텐서(벡터) 숫자를 배열한 것을 벡터라고 합니다. 벡터는 1차원 텐서입니다. 주의할 점은 벡터에서도 차원이라는 용어를 쓰는데, 벡터의 차원과 텐서의 차원은 다른 개념이라는 점입니다. 아래의 예제는 4차원 벡터이지만, 1차원 텐서입니다. 1D 텐서라고도 합니다. d = np.array([1, 2, 3, 4]) print('텐서의 차원 :',d.ndim) print('텐서의 크기(shape) :',d.shape) 텐서의 차원 : 1 텐서의 크기(shape) : (4, ) 벡터의 차원과 텐서의 차원의 정의로 인해 혼동할 수 있는데 벡터에서의 차원은 하나의 축에 놓인 원소의 개수를 의미하는 것이고, 텐서에서의 차원은 축의 개수를 의미합니다. 3) 2차원 텐서(행렬) 행과 열이 존재하는 벡터의 배열. 즉, 행렬(matrix)을 2차원 텐서라고 합니다. 2D 텐서라고도 합니다. # 3행 4열의 행렬 d = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]) print('텐서의 차원 :',d.ndim) print('텐서의 크기(shape) :',d.shape) 텐서의 차원 : 2 텐서의 크기(shape) : (3, 4) 텐서의 크기(shape)에 대해서도 정리합시다. 텐서의 크기란, 각 축을 따라서 얼마나 많은 차원이 있는지를 나타낸 값입니다. 텐서의 크기를 바로 머릿속으로 떠올릴 수 있으면 모델 설계 시에 유용합니다. 처음에는 어려울 수도 있는데, 순차적으로 확장해나가며 생각하는 것도 방법입니다. 위의 경우 3개의 커다란 데이터가 있는데 그 각각의 커다란 데이터는 작은 데이터 4개로 이루어졌다고 생각할 수 있습니다. 4) 3차원 텐서(다차원 배열) 행렬 또는 2차원 텐서를 단위로 한 번 더 배열하면 3차원 텐서라고 부릅니다. 3D 텐서라고도 합니다. 사실 위에서 언급한 0차원 ~ 2차원 텐서는 각각 스칼라, 벡터, 행렬이라고 해도 무방하므로 3차원 이상의 텐서부터 본격적으로 텐서라고 부릅니다. 데이터 사이언스 분야 한정으로 주로 3차원 이상의 배열을 텐서라고 부른다고 이해해도 좋습니다. 3D 텐서는 적어도 여기서는 3차원 배열로 이해하면 되겠습니다. 이 3차원 텐서의 구조를 이해하지 않으면, 복잡한 인공 신경망의 입, 출력값을 이해하는 것이 쉽지 않습니다. 개념 자체는 어렵지 않지만 반드시 알아야 하는 개념입니다. d = np.array([ [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [10, 11, 12, 13, 14]], [[15, 16, 17, 18, 19], [19, 20, 21, 22, 23], [23, 24, 25, 26, 27]] ]) print('텐서의 차원 :',d.ndim) print('텐서의 크기(shape) :',d.shape) 텐서의 차원 : 3 텐서의 크기(shape) : (2, 3, 5) 자연어 처리에서 특히 자주 보게 되는 것이 이 3D 텐서입니다. 3D 텐서는 시퀀스 데이터(sequence data)를 표현할 때 자주 사용되기 때문입니다. 여기서 시퀀스 데이터는 주로 단어의 시퀀스를 의미하며, 시퀀스는 주로 문장이나 문서, 뉴스 기사 등의 텍스트가 될 수 있습니다. 이 경우 3D 텐서는 (samples, timesteps, word_dim)이 됩니다. 또는 일괄로 처리하기 위해 데이터를 묶는 단위인 배치의 개념에 대해서 뒤에서 배울 텐데 (batch_size, timesteps, word_dim)이라고도 볼 수 있습니다. samples 또는 batch_size는 샘플의 개수, timesteps는 시퀀스의 길이, word_dim은 단어를 표현하는 벡터의 차원을 의미합니다. 더 상세한 설명은 RNN 챕터에서 배우게 되겠지만 자연어 처리에서 왜 3D 텐서의 개념이 사용되는지 간단한 예를 들어봅시다. 다음과 같은 3개의 훈련 데이터가 있다고 해봅시다. 문서 1 : I like NLP 문서 2 : I like DL 문서 3 : DL is AI 이를 인공 신경망의 모델의 입력으로 사용하기 위해서는 각 단어를 벡터 화해야 합니다. 단어를 벡터화하는 방법으로는 원-핫 인코딩이나 워드 임베딩이라는 방법이 대표적입니다. 워드 임베딩은 아직 배우지 않았으므로 원-핫 인코딩으로 각 단어를 벡터화해보겠습니다. 단어 One-hot vector I [1 0 0 0 0 0] like [0 1 0 0 0 0] NLP [0 0 1 0 0 0] DL [0 0 0 1 0 0] is [0 0 0 0 1 0] AI [0 0 0 0 0 1] 훈련 데이터의 단어들을 모두 원-핫 벡터로 바꿔서 인공 신경망의 입력으로 한꺼번에 사용한다고 하면 다음과 같습니다. 이렇게 훈련 데이터를 다수 묶어 입력으로 사용하는 것을 딥 러닝에서는 배치(Batch)라고 합니다. [[[1, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0]], [[1, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0]], [[0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 1]]] 이는 (3, 3, 6)의 크기를 가지는 3D 텐서입니다. 5) 그 이상의 텐서 3차원 텐서를 배열로 합치면 4차원 텐서가 됩니다. 4차원 텐서를 배열로 합치면 5차원 텐서가 됩니다. 이렇게 텐서는 다차원 배열로서 계속해서 확장될 수 있습니다. 위의 그림은 각 텐서를 도형으로 시각화한 모습을 보여줍니다. 6) 케라스에서의 텐서 앞서 Numpy로 각 텐서의 ndim(차원)과 shape(크기)를 출력했었습니다. 예를 들어 위의 예제에서는 3차원 텐서의 크기(shape)는 (2, 3, 5)였습니다. 케라스에서는 신경망의 층에 입력의 크기(shape)를 인자로 줄 때 input_shape라는 인자를 사용합니다. 실제 예시는 뒤 챕터들에서 보겠지만 input_shape는 배치 크기를 제외하고 차원을 지정하는데, 예를 들어 input_shape(6, 5)라는 인자 값을 사용한다면 이 텐서의 크기는 (?, 6, 5)을 의미합니다. 배치 크기는 지정해 주기 전까지는 알 수 없기 때문에? 가 됩니다. 만약 배치 크기까지 지정해 주고 싶다면 batch_input_shape=(8, 2, 10)와 같이 인자를 주면 이 텐서의 크기는 (8, 2, 10)을 의미합니다. 그 외에도 입력의 속성수를 의미하는 input_dim, 시퀀스 데이터의 길이를 의미하는 input_length 등의 인자도 사용하는데, input_shape의 두 개의 인자는 (input_length, input_dim)입니다. 3. 벡터와 행렬의 연산 벡터와 행렬의 기본적인 연산에 대해서 알아보겠습니다. import numpy as np 1) 벡터와 행렬의 덧셈과 뺄셈 같은 크기의 두 개의 벡터나 행렬은 덧셈과 뺄셈을 할 수 있습니다. 이 경우 같은 위치의 원소끼리 연산하면 됩니다. 이러한 연산을 요소별(element-wise) 연산이라고 합니다. 다음과 같이 A와 B라는 두 개의 벡터가 있다고 해봅시다. = [ 4 ] B [ 2 ] 이때 두 벡터 A와 B의 덧셈과 뺄셈은 아래와 같습니다. + = [ 4 ] [ 2 ] [ 6 ] − = [ 4 ] [ 2 ] [ 2 ] Numpy를 이용하여 이를 구현할 수 있습니다. A = np.array([8, 4, 5]) B = np.array([1, 2, 3]) print('도 벡터의 합 :',A+B) print('도 벡터의 차 :',A-B) 두 행렬의 합 : [9 6 8] 두 행렬의 차 : [7 2 2] 행렬도 마찬가지입니다. A와 B라는 두 개의 행렬이 있다고 하였을 때, 두 행렬 A와 B의 덧셈과 뺄셈은 아래와 같습니다. = [ 10 20 30 40 50 60 70 80 ] B [ 6 7 8 2 3 4 ] + = [ 10 20 30 40 50 60 70 80 ] [ 6 7 8 2 3 4 ] [ 15 26 37 48 51 62 73 84 ] − = [ 10 20 30 40 50 60 70 80 ] [ 6 7 8 2 3 4 ] [ 14 23 32 49 58 67 76 ] Numpy를 이용하여 이를 구현할 수 있습니다. A = np.array([[10, 20, 30, 40], [50, 60, 70, 80]]) B = np.array([[5, 6, 7, 8],[1, 2, 3, 4]]) print('도 행렬의 합 :') print(A + B) print('도 행렬의 차 :') print(A - B) 두 행렬의 합 : [[15 26 37 48] [51 62 73 84]] 두 행렬의 차 : [[ 5 14 23 32] [49 58 67 76]] 2) 벡터의 내적과 행렬의 곱셈 벡터의 점곱(dot product) 또는 내적(inner product)에 대해 알아봅시다. 벡터의 내적은 연산을 점(dot)으로 표현하여 ⋅ 와 같이 표현하기도 합니다. 내적이 성립하기 위해서는 두 벡터의 차원이 같아야 하며, 두 벡터 중 앞의 벡터가 행벡터(가로 방향 벡터)이고 뒤의 벡터가 열벡터(세로 방향 벡터) 여야 합니다. 아래는 두 벡터의 차원이 같고 곱셈의 대상이 각각 행벡터이고 열벡터일 때 내적이 이루어지는 모습을 보여줍니다. 벡터의 내적의 결과는 스칼라가 된다는 특징이 있습니다. 스칼라 ⋅ = [ 2 3 ] [ 5 ] 1 4 2 5 3 6 32 (스칼라) Numpy를 이용하여 이를 구현할 수 있습니다. A = np.array([1, 2, 3]) B = np.array([4, 5, 6]) print('도 벡터의 내적 :',np.dot(A, B)) 두 벡터의 내적 : 32 행렬의 곱셈을 이해하기 위해서는 벡터의 내적을 이해해야 합니다. 행렬의 곱셈은 왼쪽 행렬의 행벡터(가로 방향 벡터)와 오른쪽 행렬의 열벡터(세로 방향 벡터)의 내적(대응하는 원소들의 곱의 합)이 결과 행렬의 원소가 되는 것으로 이루어집니다. 다음과 같이 A와 B라는 두 개의 행렬이 있다고 하였을 때, 두 행렬 A와 B의 행렬의 곱셈은 아래와 같습니다. = [ 3 4 ] B [ 7 8 ] B [ 3 4 ] [ 7 8 ] [ × + × 1 7 3 8 × + × 2 7 4 8 ] [ 23 31 34 46 ] Numpy를 이용하여 이를 구현할 수 있습니다. A = np.array([[1, 3],[2, 4]]) B = np.array([[5, 7],[6, 8]]) print('도 행렬의 행렬곱 :') print(np.matmul(A, B)) 두 행렬의 행렬곱 : [[23 31] [34 46]] 행렬의 곱셈은 딥 러닝을 이해하기 위해 필수적인 개념이므로 반드시 숙지해야 합니다. 행렬 곱셈에서의 주요한 두 가지 조건 또한 반드시 기억해둡시다. 두 행렬의 곱 A × B이 성립되기 위해서는 행렬 A의 열의 개수와 행렬 B의 행의 개수는 같아야 한다. 두 행렬의 곱 A × B의 결과로 나온 행렬 AB의 크기는 A의 행의 개수와 B의 열의 개수를 가진다. 벡터와 행렬의 곱 또는 행렬과 벡터의 곱 또한 행렬의 곱셈과 동일한 원리로 이루어집니다. 4. 다중 선형 회귀 행렬 연산으로 이해하기 독립 변수가 2개 이상일 때, 1개의 종속 변수를 예측하는 문제를 행렬의 연산으로 표현한다면 어떻게 될까요? 다중 선형 회귀나 다중 로지스틱 회귀가 이러한 연산의 예인데, 여기서는 다중 선형 회귀를 통해 예를 들어보겠습니다. 다음은 독립 변수 가 n 개인 다중 선형 회귀 수식입니다. = 1 1 w x + 3 3. . w x + 이는 입력 벡터 [ 1. . n ] 와 가중치 벡터 [ 1. . w ] 의 내적으로 표현할 수 있습니다. = [ 1 x x ⋅ ⋅ x ] [ 1 2 3 ⋅ w ] b x w + 2 2 x w + 또는 가중치 벡터 [ 1. . w ] 와 입력 벡터 [ 1. . n ] 의 내적으로 표현할 수도 있습니다. = [ 1 w w ⋅ ⋅ w ] [ 1 2 3 ⋅ x ] b x w + 2 2 x w 샘플의 개수가 많을 경우에는 행렬의 곱셈으로 표현이 가능합니다. 다음은 집의 크기, 방의 수, 층의 수, 집이 얼마나 오래되었는지와 집의 가격이 기록된 부동산 데이터라고 가정합시다. 해당 데이터를 학습하여 새로운 집의 정보가 들어왔을 때, 집의 가격을 예측하는 모델을 구현한다고 해봅시다. size( e t)( 1 ) number of bedrooms( 2 ) number of floors( 3 ) age of home( 4 ) price($1000)(y) 1800 2 1 10 207 1200 4 2 20 176 1700 3 2 15 213 1500 5 1 10 234 1100 2 2 10 155 위 데이터에 대해서 입력 행렬 와 가중치 벡터의 곱으로 표현하면 다음과 같습니다. [ 11 x 12 x 13 x 14 21 x 22 x 23 x 24 31 x 32 x 33 x 34 41 x 42 x 43 x 44 51 x 52 x 53 x 54 ] [ 1 2 3 4 ] [ 11 1 x 12 2 x 13 3 x 14 4 21 1 x 22 2 x 23 3 x 24 4 31 1 x 32 2 x 33 3 x 34 4 41 1 x 42 2 x 43 3 x 44 4 51 1 x 52 2 x 53 3 x 54 4 여기에 편향 벡터를 더 해주면 위 데이터에 대한 전체 가설 수식 ( ) 를 표현할 수 있습니다. [ 11 1 x 12 2 x 13 3 x 14 4 21 1 x 22 2 x 23 3 x 24 4 31 1 x 32 2 x 33 3 x 34 4 41 1 x 42 2 x 43 3 x 44 4 51 1 x 52 2 x 53 3 x 54 4 ] [ b b ] [ 1 2 3 4 5 ] ( ) X + 위의 수식에서 입력 행렬 는 5행 4열의 크기를 가집니다. 출력 벡터를 라고 하였을 때는 5행 1열의 크기를 가집니다. 여기서 곱셈이 성립하기 위해서 가중치 벡터의 크기는 4행 1열을 가져야 함을 추론할 수 있습니다. 만약 가중치 벡터를 앞에 두고 입력 행렬을 뒤에 두고 행렬 연산을 한다면 이는 아래와 같습니다. [ 1 w w w ] [ 11 x 21 x 31 x 41 x 51 12 x 22 x 32 x 42 x 52 13 x 23 x 33 x 43 x 53 14 x 24 x 34 x 44 x 54 ] [ b b b b ] [ 1 수학적 관례로 아래와 같이 수식으로 표현할 때는 주로 가중치 가 입력의 앞에 오는 편입니다. ( ) W + 인공 신경망도 본질적으로 위와 같은 행렬 연산입니다. 5. 샘플(Sample)과 특성(Feature) 훈련 데이터의 입력 행렬을라고 하였을 때 샘플(Sample)과 특성(Feature)의 정의는 다음과 같습니다. 머신 러닝에서는 데이터를 셀 수 있는 단위로 구분할 때, 각각을 샘플이라고 부르며, 종속 변수를 예측하기 위한 각각의 독립 변수를 특성이라고 부릅니다. 6. 가중치와 편향 행렬의 크기 결정 앞서 언급하였던 행렬 곱셈의 두 가지 주요한 조건을 기억해둡시다. 두 행렬의 곱 J × K이 성립되기 위해서는 행렬 J의 열의 개수와 행렬 K의 행의 개수는 같아야 한다. 두 행렬의 곱 J × K의 결과로 나온 행렬 JK의 크기는 J의 행의 개수와 K의 열의 개수를 가진다. 이로부터 입력과 출력의 행렬의 크기로부터 가중치 행렬 W와 편향 행렬 B의 크기를 찾아낼 수 있습니다. 독립 변수 행렬을 X, 종속 변수 행렬을 Y라고 하였을 때, 이때 행렬 X를 입력 행렬(Input Matrix), Y를 출력 행렬(Output Matrix)이라고 합시다. 이제 입력 행렬의 크기와 출력 행렬의 크기로부터 W 행렬과 B 행렬의 크기를 추론해 봅시다. 행렬의 덧셈에 해당되는 B 행렬은 Y 행렬의 크기에 영향을 주지 않습니다. 그러므로 B 행렬의 크기는 Y 행렬의 크기와 같습니다. 행렬의 곱셈이 성립되려면 행렬의 곱셈에서 앞에 있는 행렬의 열의 크기와 뒤에 있는 행렬의 행의 크기는 같아야 합니다. 그러므로 입력 행렬 X로부터 W 행렬의 행의 크기가 결정됩니다. 두 행렬의 곱의 결과로서 나온 행렬의 열의 크기는 행렬의 곱셈에서 뒤에 있는 행렬의 열의 크기와 동일합니다. 그러므로 출력 행렬 Y로부터 W 행렬의 열의 크기가 결정됩니다. 입력 행렬과 출력 행렬의 크기로부터 가중치 행렬과 편향 행렬의 크기를 추정할 수 있다면, 딥 러닝 모델을 구현하였을 때 해당 모델에 존재하는 총 매개변수의 개수를 계산하기 쉽습니다. 어떤 딥 러닝 모델의 총 매개변수의 개수는 해당 모델에 존재하는 가중치 행렬과 편향 행렬의 모든 원소의 수이기 때문입니다. 06-09 소프트맥스 회귀(Softmax Regression) 앞서 로지스틱 회귀를 통해 2개의 선택지 중에서 1개를 고르는 이진 분류(Binary Classification)를 풀어봤습니다. 이번에는 3개 이상의 선택지 중에서 1개를 고르는 다중 클래스 분류 문제를 위한 소프트맥스 회귀(Softmax Regression)에 대해서 배웁니다. 1. 다중 클래스 분류(Multi-class Classification) 앞서 로지스틱 회귀에서 사용한 시그모이드 함수는 입력된 데이터에 대해서 0과 1사이의 값을 출력하여 해당 값이 둘 중 하나에 속할 확률로 해석할 수 있도록 만들어주었습니다. 예를 들어 0이 정상 메일, 1이 스팸 메일이라고 정의해놓는다면 시그모이드 함수의 0과 1사이의 출력값을 스팸 메일일 확률로 해석할 수 있었습니다. 확률 값이 0.5를 넘으면 1에 가까우니 스팸 메일로 판단하면 되고, 그 반대라면 정상 메일로 판단하면 됩니다. 이진 분류가 두 개의 선택지 중 하나를 고르는 문제였다면, 세 개 이상의 선택지 중 하나를 고르는 문제를 다중 클래스 분류라고 합니다. 아래의 붓꽃 품종 예측 데이터는 꽃받침 길이, 꽃받침 넓이, 꽃잎 길이, 꽃잎 넓이로부터 setosa, versicolor, virginica라는 3개의 품종 중 어떤 품종인지를 예측하는 문제를 위한 데이터로 전형적인 다중 클래스 분류 문제를 위한 데이터입니다. SepalLengthCm( 1 ) SepalWidthCm( 2 ) PetalLengthCm( 3 ) PetalWidthCm( 4 ) Species(y) 5.1 3.5 1.4 0.2 setosa 4.9 3.0 1.4 0.2 setosa 5.8 2.6 4.0 1.2 versicolor 6.7 3.0 5.2 2.3 virginica 5.6 2.8 4.9 2.0 virginica 여기에 앞서 배운 시그모이드 함수를 사용해 본다면 어떨까요? 어쩌면 입력된 샘플 데이터에 대해서 각 정답지에 대해서 시그모이드 함수를 적용해 볼 수 있습니다. 만약 그렇게 한다면, setosa가 정답일 확률은 0.8, versicolor가 정답일 확률은 0.2, virginica가 정답일 확률은 0.4 등과 같은 출력을 얻게 됩니다. 그런데 이 전체 확률의 합계가 1이 되도록 하여 전체 선택지에 걸친 확률로 바꿀 순 없을까요? 예를 들어 샘플 데이터가 입력으로 들어오면 모델이 setosa 일 확률이 0.7, versicolor 일 확률 0.05, virginica 일 확률이 0.25과 같이 세 개의 확률의 총합이 1인 예측값을 얻도록 하자는 것입니다. 그리고 이 경우 확률 값이 가장 높은 setosa로 예측한 것으로 간주하고자 합니다. 이럴 때 사용할 수 있는 것이 소프트맥스 함수입니다. 2. 소프트맥스 함수(Softmax function) 소프트맥스 함수는 선택해야 하는 선택지의 총개수를 k라고 할 때, k 차원의 벡터를 입력받아 각 클래스에 대한 확률을 추정합니다. 우선 수식에 대해 설명하고, 그 후에는 그림으로 이해해 보겠습니다. 1) 소프트맥스 함수의 이해 k 차원의 벡터에서 i 번째 원소를 i , i 번째 클래스가 정답일 확률을 i 로 나타낸다고 하였을 때 소프트맥스 함수는 i 를 다음과 같이 정의합니다. i e i j 1 e j f r i 1 2. . 위에서 풀어야 하는 문제에 소프트맥스 함수를 차근차근 적용해 봅시다. 위에서 풀어야 하는 문제의 경우 k=3이므로 3차원 벡터 = [ 1 z z ] 의 입력을 받으면 소프트맥스 함수는 아래와 같은 출력을 리턴합니다. 예측값 o t a ( ) [ z ∑ = 3 z e 2 j 1 e j e 3 j 1 e j ] [ 1 p, 3 ] p, 2 p 각각은 1번 클래스가 정답일 확률, 2번 클래스가 정답일 확률, 3번 클래스가 정답일 확률을 나타내며 각각 0과 1사이의 값으로 총합은 1이 됩니다. 여기서 분류하고자 하는 3개의 클래스는 virginica, setosa, versicolor이므로 이는 결국 주어진 입력이 virginica 일 확률, setosa 일 확률, versicolor 일 확률을 나타내는 값을 의미합니다. 여기서는 i가 1일 때는 virginica 일 확률을 나타내고, 2일 때는 setosa 일 확률, 3일 때는 versicolor 일 확률이라고 지정하였다고 합시다. 이 지정 순서는 문제를 풀고자 하는 사람의 무작위 선택입니다. 이에 따라 식을 문제에 맞게 다시 쓰면 아래와 같습니다. o t a ( ) [ z ∑ = 3 z e 2 j 1 e j e 3 j 1 e j ] [ 1 p, 3 ] 다소 복잡해 보이지만 어려운 개념이 아닙니다. 분류하고자 하는 클래스가 k 개일 때, k 차원의 벡터를 입력받아서 모든 벡터 원소의 값을 0과 1사이의 값으로 값을 변경하여 다시 k 차원의 벡터를 반환한다는 내용을 식으로 기재했습니다. 방금 배운 개념을 그림을 통해 다시 설명해 보겠습니다. 2) 그림을 통한 이해 위의 그림에 점차 살을 붙여가는 식으로 설명합니다. 여기서는 샘플 데이터를 1개씩 입력으로 받아 처리한다고 가정해 봅시다. 즉, 배치 크기가 1입니다. 위의 그림에는 두 가지 의문이 있습니다. 첫 번째 질문은 소프트맥스 함수의 입력에 대한 의문입니다. 하나의 샘플 데이터는 4개의 독립 변수를 가지는데 이는 모델이 4차원 벡터를 입력으로 받음을 의미합니다. 그런데 소프트맥스의 함수의 입력으로 사용되는 벡터는 벡터의 차원이 분류하고자 하는 클래스의 개수가 되어야 하므로 어떤 가중치 연산을 통해 3차원 벡터로 변환되어야 합니다. 위의 그림에서는 소프트맥스 함수의 입력으로 사용되는 3차원 벡터를 로 표현하였습니다. 샘플 데이터 벡터를 소프트맥스 함수의 입력 벡터로 차원을 축소하는 방법은 간단합니다. 소프트맥스 함수의 입력 벡터의 차원 수만큼 결괏값이 나오도록 가중치 곱을 진행합니다. 위의 그림에서 화살표는 총 (4 × 3 = 12) 12개이며 전부 다른 가중치를 가지고, 학습 과정에서 점차적으로 오차를 최소화하는 가중치로 값이 변경됩니다. 두 번째 질문은 오차 계산 방법에 대한 의문입니다. 소프트맥스 함수의 출력은 분류하고자 하는 클래스의 개수만큼 차원을 가지는 벡터로 각 원소는 0과 1사이의 값을 가집니다. 이 각각은 특정 클래스가 정답일 확률을 나타냅니다. 여기서는 첫 번째 원소인 1 은 virginica가 정답일 확률, 두 번째 원소인 2 는 setosa가 정답일 확률, 세 번째 원소인 3 은 versicolor가 정답일 확률로 고려하고자 합니다. 그렇다면 이 예측값과 비교를 할 수 있는 실제 값의 표현 방법이 있어야 합니다. 소프트맥스 회귀에서는 실제 값을 원-핫 벡터로 표현합니다. 위의 그림은 소프트맥스 함수의 출력 벡터의 첫 번째 원소 1 가 virginica가 정답일 확률, 두 번째 원소 2 가 setosa가 정답일 확률, 세 번째 원소 3 가 versicolor가 정답일 확률을 의미한다고 하였을 때, 각 실제 값의 정수 인코딩은 1, 2, 3이 되고 이에 원-핫 인코딩을 수행하여 실제 값을 원-핫 벡터로 수치화한 것을 보여줍니다. 예를 들어 현재 풀고 있는 샘플 데이터의 실제 값이 setosa라면 setosa의 원-핫 벡터는 [0 1 0]입니다. 이 경우, 예측값과 실제 값의 오차가 0이 되는 경우는 소프트맥스 함수의 결과가 [0 1 0]이 되는 경우입니다. 이 두 벡터의 오차를 계산하기 위해서 소프트맥스 회귀는 비용 함수로 크로스 엔트로피 함수를 사용하는데, 이는 뒤에서 비용 함수를 설명하는 부분에서 다시 언급하겠습니다. 앞서 배운 선형 회귀나 로지스틱 회귀와 마찬가지로 오차로부터 가중치를 업데이트합니다. 더 정확히는 선형 회귀나 로지스틱 회귀와 마찬가지로 편향 또한 업데이트의 대상이 되는 매개 변수입니다. 소프트맥스 회귀를 벡터와 행렬 연산으로 이해해 봅시다. 입력을 특성(feature)의 수만큼의 차원을 가진 입력 벡터라고 하고, 가중치 행렬을, 편향을라고 하였을 때, 소프트맥스 회귀에서 예측값을 구하는 과정을 벡터와 행렬 연산으로 표현하면 아래와 같습니다. 여기서 4는 특성의 수이며 3은 클래스의 개수에 해당됩니다. 3. 원-핫 벡터의 무작위성 꼭 실제 값을 원-핫 벡터로 표현해야만 다중 클래스 분류 문제를 풀 수 있는 것은 아니지만, 대부분의 다중 클래스 분류 문제가 각 클래스 간의 관계가 균등하다는 점에서 원-핫 벡터는 이러한 점을 표현할 수 있는 적절한 표현 방법입니다. 다수의 클래스를 분류하는 문제에서는 이진 분류처럼 2개의 숫자 레이블이 아니라 클래스의 개수만큼 숫자 레이블이 필요합니다. 이때 직관적으로 생각해 볼 수 있는 레이블링 방법은 분류해야 할 클래스 전체에 정수 인코딩을 하는 겁니다. 예를 들어서 분류해야 할 레이블이 {red, green, blue}와 같이 3개라면 각각 0, 1, 2로 레이블을 합니다. 또는 분류해야 할 클래스가 4개고 인덱스를 숫자 1부터 시작하고 싶다고 하면 {baby, child, adolescent, adult}라면 1, 2, 3, 4로 레이블을 해볼 수 있습니다. 그런데 일반적인 다중 클래스 분류 문제에서 레이블링 방법으로는 위와 같은 정수 인코딩이 아니라 원-핫 인코딩을 사용하는 것이 보다 클래스의 성질을 잘 표현하였다고 할 수 있습니다. 그 이유를 알아봅시다. Banana, Tomato, Apple라는 3개의 클래스가 존재하는 문제가 있다고 해봅시다. 레이블은 정수 인코딩을 사용하여 각각 1, 2, 3을 부여하였습니다. 손실 함수로 선형 회귀 실습에서 배운 평균 제곱 오차 MSE를 사용하면 정수 인코딩이 어떤 오해를 불러일으킬 수 있는지 확인할 수 있습니다. 아래의 식은 앞서 선형 회귀에서 배웠던 MSE를 다시 그대로 가져온 것입니다. ^ 는 예측값을 의미합니다. o s f n t o = n i ( i y ^ ) 직관적인 오차 크기 비교를 위해 평균을 구하는 수식은 제외하고 제곱 오차로만 판단해 봅시다. 실제 값이 Tomato 일 때 예측값이 Banana이었다면 제곱 오차는 다음과 같습니다. ( − ) = 실제 값이 Apple 일 때 예측값이 Banana이었다면 제곱 오차는 다음과 같습니다. ( − ) = 즉, Banana과 Tomato 사이의 오차보다 Banana과 Apple의 오차가 더 큽니다. 이는 기계에게 Banana가 Apple보다는 Tomato에 더 가깝다는 정보를 주는 것과 다름없습니다. 더 많은 클래스에 대해서 정수 인코딩을 수행했다고 해봅시다. {Banana :1, Tomato :2, Apple :3, Strawberry :4, ... Water melon :10} 이 정수 인코딩은 Banana가 Water melon보다는 Tomato에 더 가깝다는 의미를 담고 있습니다. 이는 사용자가 부여하고자 했던 정보가 아닙니다. 이러한 정수 인코딩의 순서 정보가 도움이 되는 분류 문제도 물론 있습니다. 바로 각 클래스가 순서의 의미를 갖고 있어서 회귀를 통해서 분류 문제를 풀 수 있는 경우입니다. 예를 들어 {baby, child, adolescent, adult}나 {1층, 2층, 3층, 4층}이나 {10대, 20대, 30대, 40대}와 같은 경우가 이에 해당됩니다. 하지만 일반적인 분류 문제에서는 각 클래스는 순서의 의미를 갖고 있지 않으므로 각 클래스 간의 오차는 균등한 것이 옳습니다. 정수 인코딩과 달리 원-핫 인코딩은 분류 문제 모든 클래스 간의 관계를 균등하게 분배합니다. 아래는 세 개의 카테고리에 대해서 원-핫 인코딩을 통해서 레이블을 인코딩했을 때 각 클래스 간의 제곱 오차가 균등함을 보여줍니다. ( ( , , ) ( , , ) ) = ( − ) + ( − ) + ( − ) = ( ( , , ) ( , , ) ) = ( − ) + ( − ) + ( − ) = 다르게 표현하면 모든 클래스에 대해서 원-핫 인코딩을 통해 얻은 원-핫 벡터들은 모든 쌍에 대해서 유클리드 거리를 구해도 전부 유클리드 거리가 동일합니다. 원-핫 벡터는 이처럼 각 클래스의 표현 방법이 무작위성을 가진다는 점을 표현할 수 있습니다. 뒤에서 다시 언급되겠지만 이러한 원-핫 벡터의 관계의 무작위성은 때로는 단어의 유사성을 구할 수 없다는 단점으로 언급되기도 합니다. 4. 비용 함수(Cost function) 소프트맥스 회귀에서는 비용 함수로 크로스 엔트로피 함수를 사용합니다. 여기서는 소프트맥스 회귀에서의 크로스 엔트로피 함수뿐만 아니라, 다양한 표기 방법에 대해서 이해해 보겠습니다. 1) 크로스 엔트로피 함수 아래에서는 실제 값을 나타내며,는 클래스의 개수로 정의합니다. j 는 실제 값 원-핫 벡터의 번째 인덱스를 의미하며, j 는 샘플 데이터가 번째 클래스일 확률을 나타냅니다. 표기에 따라서 ^로 표현하기도 합니다. o t − j 1 y l g ( j ) 이 함수가 왜 비용 함수로 적합한지 알아보겠습니다. 가 실제 값 원-핫 벡터에서 1을 가진 원소의 인덱스라고 한다면, c 1 y 가를 정확하게 예측한 경우가 됩니다. 이를 식에 대입해 보면 1 o ( ) 0 이 되기 때문에, 결과적으로 ^ y 를 정확하게 예측한 경우의 크로스 엔트로피 함수의 값은 0이 됩니다. 즉, ∑ = k j l g ( j ) 이 값을 최소화하는 방향으로 학습해야 합니다. 이를 개의 전체 데이터에 대한 평균을 구한다고 하면 최종 비용 함수는 다음과 같습니다. o t − n i 1 ∑ = k j ( ) l g ( j ( ) ) 2) 이진 분류에서의 크로스 엔트로피 함수 로지스틱 회귀에서 배운 크로스 엔트로피 함수식과 달라 보이지만, 본질적으로는 동일한 함수식입니다. 로지스틱 회귀의 크로스 엔트로피 함수식으로부터 소프트맥스 회귀의 크로스 엔트로피 함수식을 도출해 봅시다. o t − ( l g ( ) ( − ) l g ( − ( ) ) ) 위의 식은 앞서 로지스틱 회귀에서 배웠던 크로스 엔트로피의 함수식을 보여줍니다. 위의 식에서 를 1 1 y y로 치환하고 ( ) p, − ( ) p로 치환해 봅시다. 결과적으로 아래의 식을 얻을 수 있습니다. ( 1 l g ( 1 ) y l g ( 2 ) ) 이 식은 아래와 같이 표현할 수 있습니다. ( i 1 y l g p) 소프트맥스 회귀에서는 k의 값이 고정된 값이 아니므로 2를 k로 변경합니다. ( i 1 y l g p) 위의 식은 결과적으로 소프트맥스 회귀의 식과 동일합니다. 역으로 소프트맥스 회귀에서 로지스틱 회귀의 크로스 엔트로피 함수식을 얻는 것은 k를 2로 하고, 1 y를 각각 와 −로 치환하고, 1 p를 각각 ( ) 1 H ( ) 로 치환하면 됩니다. 정리하면 소프트맥스 함수의 최종 비용 함수에서 가 2라고 가정하면 결국 로지스틱 회귀의 비용 함수와 같습니다. o t − n i 1 ∑ = k j ( ) l g ( j ( ) ) − n i 1 [ ( ) o ( ( ) ) ( − 5. 인공 신경망 다이어그램 n 개의 특성을 가지고 m 개의 클래스를 분류하는 소프트맥스 회귀를 뒤에서 배우게 되는 인공 신경망의 형태로 표현하면 다음과 같습니다. 소프트맥스 회귀 또한 하나의 인공 신경망으로 볼 수 있습니다. 사실 위의 그림은 앞서 소프트맥스 함수를 사용하기 위해 설명했던 아래의 그림에서 특성의 개수를 으로 하고, 클래스의 개수를 으로 일반화한 뒤에 그림을 좀 더 요약해서 표현한 것으로 봐도 무방합니다. 06-10 소프트맥스 회귀 실습 이번에 실습할 데이터는 앞서 다중 클래스 분류를 설명하기 위해 예시로 들었던 붓꽃 품종 분류 문제입니다. 데이터를 직접 다운로드하고, 데이터에 대한 탐색 과정을 거친 후 모델을 설계해 보겠습니다. 데이터 다운로드 링크 : https://www.kaggle.com/saurabh00007/iriscsv 1. 아이리스 품종 데이터에 대한 이해 import pandas as pd import seaborn as sns import matplotlib.pyplot as plt import urllib.request from sklearn.model_selection import train_test_split from tensorflow.keras.utils import to_categorical iris.csv 파일을 데이터 프레임으로 로드한 후 5개의 샘플을 출력해 보겠습니다. urllib.request.urlretrieve("https://raw.githubusercontent.com/ukairia777/tensorflow-nlp-tutorial/main/06.%20Machine%20Learning/dataset/Iris.csv", filename="Iris.csv") data = pd.read_csv('Iris.csv', encoding='latin1') print('샘플의 개수 :', len(data)) print(data[:5]) 샘플의 개수 : 150 Id SepalLengthCm SepalWidthCm PetalLengthCm PetalWidthCm Species 0 1 5.1 3.5 1.4 0.2 Iris-setosa 1 2 4.9 3.0 1.4 0.2 Iris-setosa 2 3 4.7 3.2 1.3 0.2 Iris-setosa 3 4 4.6 3.1 1.5 0.2 Iris-setosa 4 5 5.0 3.6 1.4 0.2 Iris-setosa 데이터는 6개의 열로 구성된 총 150개의 샘플로 구성돼 있습니다. 각 샘플의 인덱스를 의미하는 첫 번째 열인 Id는 실질적으로 의미는 없는 열입니다. 그 후 특성(feature)에 해당하는 SepalLengthCm, SepalWidthCm, PetalLengthCm, PetalWidthCm 4개의 열이 존재합니다. 마지막 열 Species는 해당 샘플이 어떤 품종인지를 의미하며 여기서 예측해야 하는 레이블에 해당됩니다. Species 열에서 품종이 몇 개 존재하는지 출력합니다. # 중복을 허용하지 않고, 있는 데이터의 모든 종류를 출력 print("품종 종류:", data["Species"].unique(), sep="\n") 품종 종류: ['Iris-setosa' 'Iris-versicolor' 'Iris-virginica'] Species는 Iris-setosa, Iris-versicolor, Iris-virginica라는 3개의 품종으로 구성돼 있습니다. 즉, 이번 데이터를 가지고 푸는 문제는 주어진 샘플 데이터의 4개의 특성으로부터 3개 중 어떤 품종인지를 예측하는 문제가 되겠습니다. 3개의 품종이 4개의 특성에 대해서 어떤 분포를 가지고 있는지 시각화해봅시다. seaborn의 pairplot은 데이터 프레임을 입력으로 받아 데이터 프레임의 각 열의 조합에 따라서 산점도(scatter plot)를 그립니다. sns.set(style="ticks", color_codes=True) g = sns.pairplot(data, hue="Species", palette="husl") 해당 입력의 경우에는 4개의 특성에 해당하는 SepalLengthCm, SepalWidthCm, PetalLengthCm, PetalWidthCm에 대해서 모든 쌍(pair)의 조합인 16개의 경우에 대해서 산점도를 그립니다. 만약 동일한 특성의 쌍일 경우에는 히스토그램으로 나타내는데 가령, SepalLengthCm와 SepalLengthCm의 조합이 그렇습니다. seaborn의 barplot을 통해 종과 특성에 대한 연관 관계를 출력할 수도 있습니다. 예를 들어 각종에 따른 SepalWidthCm의 값을 확인해 봅시다. # 각종과 특성에 대한 연관 관계 sns.barplot(x='Species', y='SepalWidthCm', data=data, ci=None) 150개의 샘플 데이터 중에서 Species 열에서 각 품종이 몇 개 있는지 확인합니다. data['Species'].value_counts().plot(kind='bar') 동일하게 50개씩 존재합니다. 각 레이블에 대한 분포가 균일합니다. 소프트맥스 회귀 모델을 구성하기 위해 전처리를 진행해야 합니다. 레이블에 해당하는 Species 열에 대해서 전부 수치화를 진행해 봅시다. 우선 원-핫 인코딩을 수행하기 전 정수 인코딩을 수행합니다. 정상적으로 정수 인코딩이 수행되었는지 확인하기 위하여 다시 한번 값의 분포를 출력합니다. # Iris-virginica는 0, Iris-setosa는 1, Iris-versicolor는 2가 됨. data['Species'] = data['Species'].replace(['Iris-virginica','Iris-setosa','Iris-versicolor'],[0,1,2]) data['Species'].value_counts().plot(kind='bar') 여전히 동일한 분포를 보입니다. 특성과 품종을 각각 종속 변수와 독립 변수 데이터로 분리하는 작업을 수행하고, 정확하게 분리가 되었는지 확인하기 위해 데이터 중 상위 5개씩 출력해 보겠습니다. # X 데이터. 특성은 총 4개. data_X = data[['SepalLengthCm', 'SepalWidthCm', 'PetalLengthCm', 'PetalWidthCm']].values # Y 데이터. 예측 대상. data_y = data['Species'].values print(data_X[:5]) print(data_y[:5]) [[5.1 3.5 1.4 0.2] [4.9 3. 1.4 0.2] [4.7 3.2 1.3 0.2] [4.6 3.1 1.5 0.2] [5. 3.6 1.4 0.2]] [1 1 1 1 1] 훈련 데이터와 테스트 데이터를 분리하고 레이블에 대한 원-핫 인코딩을 수행해합니다. 그리고 원-핫 인코딩이 진행되었는지 확인하기 위해 훈련 데이터의 레이블과 테스트 데이터의 레이블을 상위 5개씩 출력합니다. # 훈련 데이터와 테스트 데이터를 8:2로 나눈다. (X_train, X_test, y_train, y_test) = train_test_split(data_X, data_y, train_size=0.8, random_state=1) # 원-핫 인코딩 y_train = to_categorical(y_train) y_test = to_categorical(y_test) print(y_train[:5]) print(y_test[:5]) [[0. 0. 1.] [1. 0. 0.] [0. 0. 1.] [1. 0. 0.] [1. 0. 0.]] [[0. 1. 0.] [0. 0. 1.] [0. 0. 1.] [0. 1. 0.] [1. 0. 0.]] 전처리 단계가 모두 끝이 났습니다. 2. 소프트맥스 회귀 입력의 차원이 4이므로 input_dim의 인자 값이 4로 변경되었습니다. 출력의 차원이 3이므로 input_dim=4 앞의 인자 값이 3입니다. 또한 활성화 함수로는 소프트맥스 함수를 사용하므로 activation의 인자 값으로 'softmax'를 사용합니다. 오차 함수로는 크로스 엔트로피 함수를 사용합니다. 시그모이드 함수를 사용한 이진 분류 문제에서는 binary_crossentropy를 사용하였지만, 다중 클래스 분류 문제에서는 'categorical_crossentropy를 사용합니다. 옵티마이저로는 경사 하강법의 일종인 아담(adam)을 사용해 보았습니다. 아담에 대한 설명은 딥 러닝 챕터에서 다룹니다. 전체 데이터에 대한 훈련 횟수는 200입니다. 이번에는 테스트 데이터를 별도로 분리해서 평가에 사용하였는데, validation_data=()에 테스트 데이터를 기재해 주면 실제로는 훈련에는 사용하지 않으면서 각 훈련 횟수마다 테스트 데이터에 대한 정확도를 출력합니다. 즉, 정확도가 전체 데이터에 대한 훈련 1회(1 에포크)마다 측정되고는 있지만 기계는 해당 데이터를 가지고 가중치를 업데이트하지 않습니다. from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense model = Sequential() model.add(Dense(3, input_dim=4, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) history = model.fit(X_train, y_train, epochs=200, batch_size=1, validation_data=(X_test, y_test)) 출력에서 accuracy은 훈련 데이터에 대한 정확도이고, val_accuracy은 테스트 데이터에 대한 정확도를 의미합니다. 이번에는 각 에포크당 훈련 데이터와 테스트 데이터에 대한 정확도를 측정했으므로 한 번 에포크에 따른 정확도를 그래프로 출력해 보겠습니다. epochs = range(1, len(history.history['accuracy']) + 1) plt.plot(epochs, history.history['loss']) plt.plot(epochs, history.history['val_loss']) plt.title('model loss') plt.ylabel('loss') plt.xlabel('epoch') plt.legend(['train', 'val'], loc='upper left') plt.show() 에포크가 증가함에 따라 오차(loss)가 점차적으로 줄어드는 것을 볼 수 있습니다. 케라스에서 테스트 데이터의 정확도를 측정하는 용도로 제공하고 있는 evaluate()를 통해 테스트 데이터에 대한 정확도를 다시 출력해 보겠습니다. print("\n 테스트 정확도: %.4f" % (model.evaluate(X_test, y_test)[1])) 테스트 정확도: 0.9667 테스트 데이터에 대해서 96.67%의 정확도를 얻었습니다. 07. 딥 러닝(Deep Learning) 개요 딥 러닝(Deep Learning)은 머신 러닝(Machine Learning)의 특정한 한 분야로서 인공 신경망(Artificial Neural Network)의 층을 연속적으로 깊게 쌓아 올려 데이터를 학습하는 방식을 말합니다. 딥 러닝이 화두가 되기 시작한 것은 2010년대의 비교적 최근의 일이지만, 딥 러닝의 기본 구조인 인공 신경망의 역사는 생각보다 오래되었습니다. 이번 챕터에서는 딥 러닝을 보다 쉽게 이해하기 위해 1957년의 초기 인공 신경망인 퍼셉트론에서부터 설명을 시작하여 층을 깊게 쌓아 학습하는 딥 러닝까지 개념을 점차적으로 확장해 보겠습니다. 추가적으로 이번 챕터에서는 피드 포워드 신경망과 같은 기본적인 인공 신경망 용어들과 케라스의 사용 방법에 대해서 학습합니다. 07-01 퍼셉트론(Perceptron) 인공 신경망은 수많은 머신 러닝 방법 중 하나입니다. 하지만 최근 인공 신경망을 복잡하게 쌓아 올린 딥 러닝이 다른 머신 러닝 방법들을 뛰어넘는 성능을 보여주는 사례가 늘면서, 전통적인 머신 러닝과 딥 러닝을 구분해서 이해해야 한다는 목소리가 커지고 있습니다. 딥 러닝을 이해하기 위해서는 우선 인공 신경망에 대한 이해가 필요한데, 여기서는 초기의 인공 신경망인 퍼셉트론(Perceptron)에 대해서 이해합니다. 1. 퍼셉트론(Perceptron) 퍼셉트론(Perceptron)은 프랑크 로젠블라트(Frank Rosenblatt)가 1957년에 제안한 초기 형태의 인공 신경망으로 다수의 입력으로부터 하나의 결과를 내보내는 알고리즘입니다. 퍼셉트론은 실제 뇌를 구성하는 신경 세포 뉴런의 동작과 유사한데, 신경 세포 뉴런의 그림을 먼저 보도록 하겠습니다. 뉴런은 가지돌기에서 신호를 받아들이고, 이 신호가 일정치 이상의 크기를 가지면 축삭돌기를 통해서 신호를 전달합니다. 다수의 입력을 받는 퍼셉트론의 그림을 보겠습니다. 신경 세포 뉴런의 입력 신호와 출력 신호가 퍼셉트론에서 각각 입력값과 출력값에 해당됩니다.는 입력값을 의미하며,는 가중치(Weight),는 출력값입니다. 그림 안의 원은 인공 뉴런에 해당됩니다. 실제 신경 세포 뉴런에서의 신호를 전달하는 축삭돌기의 역할을 퍼셉트론에서는 가중치가 대신합니다. 각각의 인공 뉴런에서 보내진 입력값 는 각각의 가중치 와 함께 종착지인 인공 뉴런에 전달되고 있습니다. 각각의 입력값에는 각각의 가중치가 존재하는데, 이때 가중치의 값이 크면 클수록 해당 입력 값이 중요하다는 것을 의미합니다. 각 입력값이 가중치와 곱해져서 인공 뉴런에 보내지고, 각 입력값과 그에 해당되는 가중치의 곱의 전체 합이 임계치(threshold)를 넘으면 종착지에 있는 인공 뉴런은 출력 신호로서 1을 출력하고, 그렇지 않을 경우에는 0을 출력합니다. 이러한 함수를 계단 함수(Step function)라고 하며, 아래는 그래프는 계단 함수의 하나의 예를 보여줍니다. 이때 계단 함수에 사용된 이 임계치 값을 수식으로 표현할 때는 보통 세타(Θ)로 표현합니다. 식으로 표현하면 다음과 같습니다. f i w x ≥ → = i ∑ n i i < → = 위의 식에서 임계치를 좌변으로 넘기고 편향 (bias)로 표현할 수도 있습니다. 편향 또한 퍼셉트론의 입력으로 사용됩니다. 보통 그림으로 표현할 때는 입력값이 1로 고정되고 편향 가 곱해지는 변수로 표현됩니다. f i w x + ≥ → = i ∑ n i i b 0 y 0 이 책을 포함한 많은 인공 신경망 자료에서 편의상 편향 가 그림이나 수식에서 생략돼서 표현되기도 하지만 실제로는 편향 또한 딥 러닝이 최적의 값을 찾아야 할 변수 중 하나입니다. 뒤에서 배우겠지만 이렇게 뉴런에서 출력값을 변경시키는 함수를 활성화 함수(Activation Function)라고 합니다. 초기 인공 신경망 모델인 퍼셉트론은 활성화 함수로 계단 함수를 사용하였지만, 그 뒤에 등장한 여러 가지 발전된 신경망들은 계단 함수 외에도 여러 다양한 활성화 함수를 사용하기 시작했습니다. 사실 앞서 배운 시그모이드 함수나 소프트맥스 함수 또한 활성화 함수 중 하나입니다. 퍼셉트론을 배우기 전에 로지스틱 회귀를 먼저 배운 이유도 여기에 있습니다. 퍼셉트론의 활성화 함수는 계단 함수이지만 여기서 활성화 함수를 시그모이드 함수로 변경하면 방금 배운 퍼셉트론은 곧 이진 분류를 수행하는 로지스틱 회귀와 동일함을 알 수 있습니다. 다시 말하면 로지스틱 회귀 모델이 인공 신경망에서는 하나의 인공 뉴런으로 볼 수 있습니다. 로지스틱 회귀를 수행하는 인공 뉴런과 위에서 배운 퍼셉트론의 차이는 오직 활성화 함수의 차이입니다. 인공 뉴런 : 활성화 함수 ( i w x + ) 위의 퍼셉트론(인공 뉴런 종류 중 하나) : 계단 함수 ( i w x + ) 2. 단층 퍼셉트론(Single-Layer Perceptron) 위에서 배운 퍼셉트론을 단층 퍼셉트론이라고 합니다. 퍼셉트론은 단층 퍼셉트론과 다층 퍼셉트론으로 나누어지는데, 단층 퍼셉트론은 값을 보내는 단계과 값을 받아서 출력하는 두 단계로만 이루어집니다. 이때 이 각 단계를 보통 층(layer)이라고 부르며, 이 두 개의 층을 입력층(input layer)과 출력층(output layer)이라고 합니다. 단층 퍼셉트론이 어떤 일을 할 수 있으며 한계는 무엇인지 학습해 보겠습니다. 컴퓨터는 두 개의 값 0과 1을 입력해 하나의 값을 출력하는 회로가 모여 만들어지는데, 이 회로를 게이트(gate)라고 부릅니다. 초기 형태의 인공 신경망인 단층 퍼셉트론은 간단한 XOR 게이트조차도 구현할 수 없는 부족한 인공 신경망이라는 지적을 받았습니다. 단층 퍼셉트론을 이용하면 AND, NAND, OR 게이트는 구현 가능합니다. 게이트 연산에 쓰이는 것은 두 개의 입력값과 하나의 출력값입니다. AND 게이트란 두 개의 입력값 1 x 이 각각 0 또는 1의 값을 가질 수 있으면서 모두 1인 경우에만 출력값 가 1이 나오는 구조를 말합니다. 단층 퍼셉트론의 식을 통해 AND 게이트를 만족하는 두 개의 가중치와 편향 값에는 뭐가 있을까요? 각각 1 w,라고 한다면 [0.5, 0.5, -0.7], [0.5, 0.5, -0.8] 또는 [1.0, 1.0, -1.0] 등 이 외에도 다양한 가중치와 편향의 조합이 나올 수 있습니다. 이해를 돕기 위해서 AND 게이트를 위한 매개변수 값을 가진 단층 퍼셉트론의 식을 파이썬 코드로 간단하게 구현해 봅시다. def AND_gate(x1, x2): w1 = 0.5 w2 = 0.5 b = -0.7 result = x1*w1 + x2*w2 + b if result <= 0: return 0 else: return 1 위의 함수에 AND 게이트의 입력값을 모두 넣어보면 오직 두 개의 입력값이 1인 경우에만 1을 출력합니다. AND_gate(0, 0), AND_gate(0, 1), AND_gate(1, 0), AND_gate(1, 1) (0, 0, 0, 1) 그렇다면 두 개의 입력값이 1인 경우에만 출력값이 0, 나머지 입력값의 쌍(pair)에 대해서는 모두 출력값이 1이 나오는 NAND 게이트는 어떨까요? 앞서 언급했던 AND 게이트를 충족하는 가중치와 편향 값인 [0.5, 0.5, -0.7]에 -를 붙여서 [-0.5, -0.5, +0.7]을 단층 퍼셉트론의 식에 넣어보면 NAND 게이트를 충족합니다. 파이썬 코드를 통해서 이를 확인해 봅시다. def NAND_gate(x1, x2): w1 = -0.5 w2 = -0.5 b = 0.7 result = x1*w1 + x2*w2 + b if result <= 0: return 0 else: return 1 단지 같은 코드에 함수 이름과 가중치와 편향만 바꿨을 뿐입니다. 퍼셉트론의 구조는 같기 때문입니다. NAND_gate(0, 0), NAND_gate(0, 1), NAND_gate(1, 0), NAND_gate(1, 1) (1, 1, 1, 0) NAND 게이트를 구현한 파이썬 코드에 입력값을 넣자, 두 개의 입력값이 1인 경우에만 0이 나오는 것을 확인할 수 있습니다. 퍼셉트론으로 NAND 게이트를 구현한 것입니다. [-0.5, -0.5, -0.7] 외에도 퍼셉트론이 NAND 게이트의 동작을 하도록 하는 다양한 가중치와 편향의 값들이 있을 것입니다. 두 개의 입력이 모두 0인 경우에 출력값이 0이고 나머지 경우에는 모두 출력값이 1인 OR 게이트 또한 적절한 가중치 값과 편향 값만 찾으면 단층 퍼셉트론의 식으로 구현할 수 있습니다. 예를 들어 각각 가중치와 편향에 대해서 [0.6, 0.6, -0.5]를 선택하면 OR 게이트를 충족합니다. def OR_gate(x1, x2): w1 = 0.6 w2 = 0.6 b = -0.5 result = x1*w1 + x2*w2 + b if result <= 0: return 0 else: return 1 OR_gate(0, 0), OR_gate(0, 1), OR_gate(1, 0), OR_gate(1, 1) (0, 1, 1, 1) 이 외에도 이를 충족하는 다양한 가중치와 편향의 값이 있습니다. 이처럼 단층 퍼셉트론은 AND 게이트, NAND 게이트, OR 게이트를 구현할 수 있으나 지금부터 설명할 XOR 게이트는 구현할 수 없습니다. XOR 게이트는 입력값 두 개가 서로 다른 값을 갖고 있을 때에만 출력값이 1이 되고, 입력값 두 개가 서로 같은 값을 가지면 출력값이 0이 되는 게이트입니다. 위의 파이썬 코드에 아무리 수많은 가중치와 편향을 넣어봐도 XOR 게이트를 구현하는 것은 불가능합니다. 그 이유는 단층 퍼셉트론은 직선 하나로 두 영역을 나눌 수 있는 문제에 대해서만 구현이 가능하기 때문입니다. 예를 들어 AND 게이트에 대한 단층 퍼셉트론을 시각화해보면 다음과 같습니다. 그림에서는 출력값 0을 하얀색 원, 1을 검은색 원으로 표현했습니다. AND 게이트를 충족하려면 하얀색 원과 검은색 원을 직선으로 나누게 됩니다. 마찬가지로 NAND 게이트나 OR 게이트에 대해서도 시각화를 했을 때 직선으로 나누는 것이 가능합니다. 그렇다면 XOR 게이트는 어떨까요? XOR 게이트는 입력값 두 개가 서로 다른 값을 갖고 있을 때에만 출력값이 1이 되고, 입력값 두 개가 서로 같은 값을 가지면 출력값이 0이 되는 게이트입니다. XOR 게이트를 시각화해보면 다음과 같습니다. 하얀색 원과 검은색 원을 직선 하나로 나누는 것은 불가능하므로 단층 퍼셉트론으로는 XOR 게이트를 구현할 수 없습니다. 위의 좌측 그림과 같이 적어도 두 개의 선이 필요합니다. 이를 어떻게 해결할 수 있을까요? 이에 대한 해답은 다층 퍼셉트론입니다. 다층 퍼셉트론을 사용하면 여러 개의 선으로 분류하는 효과를 얻을 수 있습니다. 3. 다층 퍼셉트론(MultiLayer Perceptron, MLP) XOR 게이트는 기존의 AND, NAND, OR 게이트를 조합하면 만들 수 있습니다. 퍼셉트론 관점에서 말하면 층을 더 쌓으면 만들 수 있습니다. 다층 퍼셉트론과 단층 퍼셉트론의 차이는 단층 퍼셉트론은 입력층과 출력층만 존재하지만, 다층 퍼셉트론은 중간에 층을 더 추가하였다는 점입니다. 이렇게 입력층과 출력층 사이에 존재하는 층을 은닉층(hidden layer)이라고 합니다. 즉, 다층 퍼셉트론은 중간에 은닉층이 존재한다는 점이 단층 퍼셉트론과 다릅니다. 다층 퍼셉트론은 줄여서 MLP라고도 부릅니다. 위의 그림은 AND, NAND, OR 게이트를 조합하여 XOR 게이트를 구현한 다층 퍼셉트론의 예입니다. (실제 구현은 숙제로 남겨두겠습니다. 힌트를 드리자면 위의 단층 퍼셉트론에서 사용한 함수들을 그대로 사용하면 됩니다.) XOR 예제에서는 은닉층 1개만으로 문제를 해결할 수 있었지만, 다층 퍼셉트론은 본래 은닉층이 1개 이상인 퍼셉트론을 말합니다. 즉, XOR 문제나 기타 복잡한 문제를 해결하기 위해서 다층 퍼셉트론은 중간에 수많은 은닉층을 더 추가할 수 있습니다. 은닉층의 개수는 2개일 수도 있고, 수십 개일 수도 있고 사용자가 설정하기 나름입니다. 아래는 더 어려운 문제를 풀기 위해서 은닉층이 하나 더 추가되고(이 경우에는 은닉층이 2개), 뉴런의 개수를 늘린 다층 퍼셉트론의 모습을 보여줍니다. 위와 같이 은닉층이 2개 이상인 신경망을 심층 신경망(Deep Neural Network, DNN)이라고 합니다. 심층 신경망은 다층 퍼셉트론만 이야기하는 것이 아니라, 여러 변형된 다양한 신경망들도 은닉층이 2개 이상이 되면 심층 신경망이라고 합니다. 지금까지는 OR, AND, XOR 게이트 등. 퍼셉트론이 제대로 된 정답을 출력할 때까지 저자가 직접 가중치를 바꿔보면서 적절한 가중치를 수동으로 찾았습니다. 하지만 이제는 기계가 가중치를 스스로 찾아내도록 자동화시켜야 하는데, 이것이 머신 러닝에서 말하는 훈련(training) 또는 학습(learning) 단계에 해당됩니다. 앞서 선형 회귀와 로지스틱 회귀에서 보았듯이 손실 함수(Loss function)와 옵티마이저(Optimizer)를 사용합니다. 그리고 만약 학습을 시키는 인공 신경망이 심층 신경망일 경우에는 이를 심층 신경망을 학습시킨다고 하여, 딥 러닝(Deep Learning)이라고 합니다. 07-02 인공 신경망(Artificial Neural Network) 훑어보기 인공 신경망에 대한 기본적인 내용들을 정리합니다. 1. 피드 포워드 신경망(Feed-Forward Neural Network, FFNN) 위 그림의 다층 퍼셉트론(MLP)과 같이 오직 입력층에서 출력층 방향으로 연산이 전개되는 신경망을 피드 포워드 신경망(Feed-Forward Neural Network, FFNN)이라고 합니다. 위의 그림은 FFNN에 속하지 않는 RNN이라는 신경망을 보여줍니다. 이 신경망은 은닉층의 출력값을 출력층으로도 값을 보내지만, 동시에 은닉층의 출력값이 다시 은닉층의 입력으로 사용됩니다. 2. 전결합층(Fully-connected layer, FC, Dense layer) 다층 퍼셉트론은 은닉층과 출력층에 있는 모든 뉴런은 바로 이전 층의 모든 뉴런과 연결돼 있었습니다. 그와 같이 어떤 층의 모든 뉴런이 이전 층의 모든 뉴런과 연결돼 있는 층을 전결합층(Fully-connected layer) 또는 완전연결층이라고 합니다. 줄여서 FC라고 부르기도 합니다. 앞서 본 다층 퍼셉트론의 모든 은닉층과 출력층은 전결합층입니다. 동일한 의미로 밀집층(Dense layer)이라고 부르기도 하는데, 케라스에서는 밀집층을 구현할 때 Dense()를 사용합니다. 3. 활성화 함수(Activation Function) 앞서 배운 퍼셉트론에서는 계단 함수(Step function)를 통해 출력값이 0이 될지, 1이 될지를 결정했습니다. 이러한 메커니즘은 실제 뇌를 구성하는 신경 세포 뉴런이 전위가 일정치 이상이 되면 시냅스가 서로 화학적으로 연결되는 모습을 모방한 것입니다. 이렇게 은닉층과 출력층의 뉴런에서 출력값을 결정하는 함수를 활성화 함수(Activation function)라고 하는데 계단 함수는 이러한 활성화 함수의 하나의 예제에 불과합니다. 다양한 활성화 함수에 대해서 정리해 봅시다. 일부는 머신 러닝 챕터에서 이미 봤던 함수들입니다. (1) 활성화 함수의 특징 - 비선형 함수(Nonlinear function) 활성화 함수의 특징은 선형 함수가 아닌 비선형 함수여야 한다는 점입니다. 선형 함수란 출력이 입력의 상수배만큼 변하는 함수를 선형함수라고 합니다. 예를 들어 ( ) w +라는 함수가 있을 때, 와는 상수입니다. 이 식을 그래프로 시각화하면 직선입니다. 반대로 비선형 함수는 직선 1개로는 그릴 수 없는 함수를 말합니다. 인공 신경망에서 활성화 함수는 비선형 함수여야 합니다. 앞서 퍼셉트론에서도 계단 함수라는 활성화 함수를 사용했는데 계단 함수 또한 비선형 함수에 속합니다. 인공 신경망의 능력을 높이기 위해서는 은닉층을 계속해서 추가해야 합니다. 그런데 만약 활성화 함수로 선형 함수를 사용하게 되면 은닉층을 쌓을 수가 없습니다. 예를 들어 활성화 함수로 선형 함수를 선택하고, 층을 계속 쌓는다고 가정해 보겠습니다. 활성화 함수는 ( ) w라고 가정합니다. 여기다가 은닉층을 두 개 추가한다고 하면 출력층을 포함해서 ( ) f ( ( ( ) ) ) 가 됩니다. 이를 식으로 표현하면 × × ×입니다. 그런데 이는 잘 생각해 보면의 세 제곱값을 라고 정의해버리면 ( ) k 와 같이 다시 표현이 가능합니다. 이 경우, 선형 함수로 은닉층을 여러 번 추가하더라도 1회 추가한 것과 차이가 없음을 알 수 있습니다. 활성화 함수가 존재하지 않는 선형 함수 층을 사용하지 않는다는 의미는 아닙니다. 종종 활성화 함수를 사용하지 않는 층을 비선형 층들과 함께 인공 신경망의 일부로서 추가하는 경우도 있는데, 학습 가능한 가중치가 새로 생긴다는 점에서 의미가 있습니다. 이와 같이 선형 함수를 사용한 층을 활성화 함수를 사용하는 은닉층과 구분하기 위해서 이 책에서는 선형층(linear layer)이나 투사층(projection layer) 등의 다른 표현을 사용하여 표현합니다. 뒤의 챕터에서 언급할 임베딩 층(embedding layer)도 일종의 선형층입니다. 임베딩 층에는 활성화 함수가 존재하지 않습니다. 활성화 함수를 사용하는 일반적인 은닉층을 선형층과 대비되는 표현을 사용하면 비선형층(nonlinear layer)입니다. 파이썬을 통해 주로 사용되는 활성화 함수를 직접 그려봅시다. import numpy as np import matplotlib.pyplot as plt (2) 계단 함수(Step function) def step(x): return np.array(x > 0, dtype=np.int) x = np.arange(-5.0, 5.0, 0.1) # -5.0부터 5.0까지 0.1 간격 생성 y = step(x) plt.title('Step Function') plt.plot(x, y) plt.show() 계단 함수는 거의 사용되지 않지만 퍼셉트론을 통해 인공 신경망을 처음 배울 때 접하게 되는 활성화 함수입니다. (3) 시그모이드 함수(Sigmoid function)와 기울기 소실 시그모이드 함수를 사용한 인공 신경망이 있다고 가정해 보겠습니다. 위 인공 신경망의 학습 과정은 다음과 같습니다. 우선 인공 신경망은 입력에 대해서 순전파(forward propagation) 연산을 하고, 그리고 순전파 연산을 통해 나온 예측값과 실제 값의 오차를 손실 함수(loss function)을 통해 계산하고, 그리고 이 손실(오차라고도 부릅니다. loss)을 미분을 통해서 기울기(gradient)를 구하고, 이를 통해 출력층에서 입력층 방향으로 가중치와 편향을 업데이트하는 과정인 역전파(back propagation)를 수행합니다. 역전파에 대해서는 뒤에서 더 자세히 설명하겠지만 일단 여기에서는 인공 신경망에서 출력층에서 입력층 방향으로 가중치와 편향을 업데이트하는 과정이라고만 언급해두겠습니다. 역전파 과정에서 인공 신경망은 경사 하강법을 사용합니다. 이 시그모이드 함수의 문제점은 미분을 해서 기울기(gradient)를 구할 때 발생합니다. # 시그모이드 함수 그래프를 그리는 코드 def sigmoid(x): return 1/(1+np.exp(-x)) x = np.arange(-5.0, 5.0, 0.1) y = sigmoid(x) plt.plot(x, y) plt.plot([0,0],[1.0,0.0], ':') # 가운데 점선 추가 plt.title('Sigmoid Function') plt.show() 위 그래프는 시그모이드 함수의 그래프를 보여줍니다. 시그모이드 함수의 출력값이 0 또는 1에 가까워지면, 그래프의 기울기가 완만해지는 모습을 볼 수 있습니다. 기울기가 완만해지는 구간을 주황색, 그렇지 않은 구간을 초록색으로 칠해보겠습니다. 주황색 구간에서는 미분 값이 0에 가까운 아주 작은 값입니다. 초록색 구간에서의 미분 값은 최댓값이 0.25입니다. 다시 말해 시그모이드 함수를 미분한 값은 적어도 0.25 이하의 값입니다. 시그모이드 함수를 활성화 함수로 하는 인공 신경망의 층을 쌓는다면, 가중치와 편향을 업데이트하는 과정인 역전파 과정에서 0에 가까운 값이 누적해서 곱해지게 되면서, 앞단에는 기울기(미분 값)가 잘 전달되지 않게 됩니다. 이러한 현상을 기울기 소실(Vanishing Gradient) 문제라고 합니다. 시그모이드 함수를 사용하는 은닉층의 개수가 다수가 될 경우에는 0에 가까운 기울기가 계속 곱해지면 앞단에서는 거의 기울기를 전파 받을 수 없게 됩니다. 다시 말해 매개변수 가 업데이트되지 않아 학습이 되지를 않습니다. 위의 그림은 은닉층이 깊은 신경망에서 기울기 소실 문제로 인해 출력층과 가까운 은닉층에서는 기울기가 잘 전파되지만, 앞단으로 갈수록 기울기가 제대로 전파되지 않는 모습을 보여줍니다. 결론적으로 시그모이드 함수의 은닉층에서의 사용은 지양됩니다. 시그모이드 함수는 주로 이진 분류를 위해 출력층에서 사용합니다. (4) 하이퍼볼릭탄젠트 함수(Hyperbolic tangent function) 하이퍼볼릭탄젠트 함수(tanh)는 입력값을 -1과 1사이의 값으로 변환합니다. 그래프를 그려보겠습니다. x = np.arange(-5.0, 5.0, 0.1) # -5.0부터 5.0까지 0.1 간격 생성 y = np.tanh(x) plt.plot(x, y) plt.plot([0,0],[1.0, -1.0], ':') plt.axhline(y=0, color='orange', linestyle='--') plt.title('Tanh Function') plt.show() 하이퍼볼릭탄젠트 함수도 -1과 1에 가까운 출력값을 출력할 때, 시그모이드 함수와 같은 문제가 발생합니다. 그러나 하이퍼볼릭탄젠트 함수의 경우에는 시그모이드 함수와는 달리 0을 중심으로 하고 있으며 하이퍼볼릭탄젠트 함수를 미분했을 때의 최댓값은 1로 시그모이드 함수의 최댓값인 0.25보다는 큽니다. 다시 말해 미분했을 때 시그모이드 함수보다는 전반적으로 큰 값이 나오게 됩니다. 그래서 시그모이드 함수보다는 기울기 소실 증상이 적은 편이며 은닉층에서 시그모이드 함수보다는 선호됩니다. (5) 렐루 함수(ReLU) 인공 신경망의 은닉층에서 가장 인기 있는 함수입니다. 수식은 ( ) m x ( , ) 로 아주 간단합니다. def relu(x): return np.maximum(0, x) x = np.arange(-5.0, 5.0, 0.1) y = relu(x) plt.plot(x, y) plt.plot([0,0],[5.0,0.0], ':') plt.title('Relu Function') plt.show() 렐루 함수는 음수를 입력하면 0을 출력하고, 양수를 입력하면 입력값을 그대로 반환하는 것이 특징인 함수로 출력값이 특정 양수 값에 수렴하지 않습니다. 0 이상의 입력값의 경우에는 미분 값이 항상 1입니다. 깊은 신경망의 은닉층에서 시그모이드 함수보다 훨씬 더 잘 작동합니다. 그뿐만 아니라, 렐루 함수는 시그모이드 함수와 하이퍼볼릭탄젠트 함수와 같이 어떤 연산이 필요한 것이 아니라 단순 임계값이므로 연산 속도도 빠릅니다. 하지만 여전히 문제점이 존재하는데, 입력값이 음수 면 기울기. 즉, 미분 값도 0이 됩니다. 그리고 이 뉴런은 다시 회생하는 것이 매우 어렵습니다. 이 문제를 죽은 렐루(dying ReLU)라고 합니다. (6) 리키 렐루(Leaky ReLU) 죽은 렐루를 보완하기 위해 ReLU의 변형 함수들이 등장하기 시작했습니다. 변형 함수는 여러 개가 있지만 여기서는 Leaky ReLU에 대해서만 소개합니다. Leaky ReLU는 입력값이 음수일 경우에 0이 아니라 0.001과 같은 매우 작은 수를 반환하도록 되어있습니다. 수식은 ( ) m x ( x x ) 로 아주 간단합니다. a는 하이퍼 파라미터로 Leaky('새는') 정도를 결정하며 일반적으로는 0.01의 값을 가집니다. 여기서 말하는 '새는 정도'라는 것은 입력값의 음수일 때의 기울기를 비유하고 있습니다. a = 0.1 def leaky_relu(x): return np.maximum(a*x, x) x = np.arange(-5.0, 5.0, 0.1) y = leaky_relu(x) plt.plot(x, y) plt.plot([0,0],[5.0,0.0], ':') plt.title('Leaky ReLU Function') plt.show() 위의 그래프에서는 새는 모습을 확실히 보여주기 위해 a를 0.1로 잡았습니다. 위와 같이 입력값이 음수라도 기울기가 0이 되지 않으면 ReLU는 죽지 않습니다. (7) 소프트맥스 함수(Softmax function) 은닉층에서는 ReLU(또는 ReLU 변형) 함수들을 사용하는 것이 일반적입니다. 반면, 소프트맥스 함수는 시그모이드 함수처럼 출력층에서 주로 사용됩니다. 시그모이드 함수가 두 가지 선택지 중 하나를 고르는 이진 분류 (Binary Classification) 문제에 사용된다면 소프트맥스 함수는 세 가지 이상의 (상호 배타적인) 선택지 중 하나를 고르는 다중 클래스 분류(MultiClass Classification) 문제에 주로 사용됩니다. 다시 말해서 딥 러닝으로 이진 분류를 할 때는 출력층에 앞서 배운 로지스틱 회귀를 사용하고, 딥 러닝으로 다중 클래스 분류 문제를 풀 때는 출력층에 소프트맥스 회귀를 사용한다고 생각할 수 있습니다. x = np.arange(-5.0, 5.0, 0.1) # -5.0부터 5.0까지 0.1 간격 생성 y = np.exp(x) / np.sum(np.exp(x)) plt.plot(x, y) plt.title('Softmax Function') plt.show() 07-03 행렬곱으로 이해하는 신경망 인공 신경망에서 입력층에서 출력층 방향으로 연산을 진행하는 과정을 순전파(Forward Propagation)라고 합니다. 다르게 말하면 주어진 입력이 입력층으로 들어가서 은닉층을 지나 출력층에서 예측값을 얻는 과정을 순전 파라고 합니다. 여기서는 신경망의 순전 파는 결과적으로 행렬의 곱셈으로 이해할 수 있다는 것과 다층 퍼셉트론 내의 학습 가능한 매개변수인 가중치 와 편향의 개수를 추정하는 방법에 대해서 학습합니다. 1. 순전파(Foward Propagation) 활성화 함수, 은닉층의 수, 각 은닉층의 뉴런 수 등 딥 러닝 모델을 설계하고 나면 입력값은 입력층, 은닉층을 지나면서 각 층에서의 가중치와 함께 연산되며 출력층으로 향합니다. 그리고 출력층에서 모든 연산을 마친 예측값이 나오게 됩니다. 이와 같이 입력층에서 출력층 방향으로 예측값의 연산이 진행되는 과정을 순전 파라고 합니다. 2. 행렬곱으로 순전파 이해하기 위와 같은 인공 신경망이 있다고 해봅시다. 입력의 차원이 3, 출력의 차원이 2인 위 인공 신경망을 구현해 본다면 다음과 같습니다. from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense model = Sequential() # 3개의 입력과 2개의 출력 model.add(Dense(2, input_dim=3, activation='softmax')) 소프트맥스 회귀를 한다고 가정하고 활성화 함수는 소프트맥스 함수를 임의로 기재하였습니다. 인공 신경망이란 표현이 아직 어색한다면 앞에서 배운 소프트맥스 회귀 모델을 만들었다고 생각해도 되겠습니다. 소프트맥스 회귀는 출력 벡터의 차원을 2로 두면 이진 분류를 수행하는 모델이 됩니다. 로지스틱 회귀가 아닌 소프트맥스 회귀로도 이진 분류는 수행 가능함을 기억해둡시다. 케라스에서는 .summary()를 사용하면 해당 모델에 존재하는 모든 매개변수(가중치 와 편향의 개수)를 확인할 수 있습니다. model.summary() Model: "sequential" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= dense (Dense) (None, 2) 8 ================================================================= Total params: 8 Trainable params: 8 Non-trainable params: 0 _________________________________________________________________ 매개변수의 수가 8개라고 나옵니다. 위 신경망에서 학습 가능한 매개변수인 와의 개수가 총 합해서 8개라는 의미입니다. 실제로 그런지 위 신경망을 행렬의 곱셈 관점에서 이해해 봅시다. 위 모델은 입력의 차원이 3, 출력의 차원이 2입니다. 또는 신경망의 용어로서 표현한다면, 입력층의 뉴런이 3개, 출력층의 뉴런이 2개라고 말할 수 있습니다. 위 신경망 그림에서 화살표 각각은 가중치를 의미하고 있습니다. 3개의 뉴런과 2개의 뉴런 사이에는 총 6개의 화살표가 존재하는데, 이는 위 신경망에서 가중치의 개수가 6개임을 의미합니다. 이를 행렬곱 관점에서는 3차원 벡터에서 2차원 벡터가 되기 위해서 3 × 2 행렬을 곱했다고 이해할 수 있습니다. 그리고 이 행렬 각각의 원소가 각각의 가 되는 것입니다. 위 그림에서는 1 에 연결되는 화살표 1 w, 3 를 주황색으로 표현하고, 2 에 연결되는 화살표 4 w, 6 를 초록색으로 표현했습니다. 일반적으로 동그란 뉴런과 화살표로 표현하는 인공 신경망의 그림에서는 편향의 경우에는 편의상 생략되는 경우가 많지만, 인공 신경망 내부적으로는 편향의 연산 또한 존재합니다. 위 그림에서 뉴런과 화살표로 표현한 인공 신경망의 그림에서는 편향을 표현하지 않았지만, 행렬 연산식에서는 1 b를 표현하였습니다. 편향의 개수는 항상 출력의 차원을 기준으로 개수를 확인하면 됩니다. 위의 인공 신경망의 경우에는 출력의 차원이 2인데, 이에 따라서 편향 또한 1 b로 두 개입니다. 가중치의 개수가 1 w, 3 w, 5 w로 총 6개이며 편향의 개수가 1 b로 두 개이므로 총 학습 가능한 매개변수의 수는 8개입니다. 이는 앞서 model.summary()를 하였을 때 확인한 매개변수의 수인 8개와 일치합니다. 1 y를 구하는 과정을 수식으로 표현한다면 다음과 같이 표현할 수 있습니다. 1 x w + 2 2 x w + 1 2 x w + 2 5 x w + 2 [ 1 y ] s f m x ( [ 1 h ] ) 좀 더 간단하게 식을 표현해 보겠습니다. 입력 1 x, 3 을 벡터로 명명합니다. = [ 1 x, 3 ] 그리고 1 w, 3 w, 5 w를 원소로 하는 3 × 2 행렬을 가중치 행렬, 그리고 편향 1 2 를 원소로 하는 벡터를, 그리고 1 y를 원소로 하는 출력 벡터를 로 명명합시다. 이 경우, 위의 인공 신경망은 다음과 같이 표현할 수 있습니다. 다시 말해 수식은 다음과 같습니다. = W B 3. 행렬곱으로 병렬 연산 이해하기 인공 신경망을 행렬곱으로 구현할 때의 흥미로운 점은 행렬 곱을 사용하면 병렬 연산도 가능하다는 점입니다. 위의 예시에서는 데이터 중 1개의 샘플만을 처리한다고 가정했습습니다. 이번에는 인공 신경망이 4개의 샘플을 동시에 처리해 본다고 가정해 봅시다. 4개의 샘플을 하나의 행렬로 정의하고 인공 신경망의 순전파를 행렬곱으로 표현하면 다음과 같습니다. 여기서 혼동하지 말아야 할 것은 인공 신경망의 4개의 샘플을 동시에 처리하고 있지만, 여기서 학습 가능한 매개변수의 수는 여전히 8개라는 점입니다. 이렇게 인공 신경망이 다수의 샘플을 동시에 처리하는 것을 우리는 '배치 연산'이라고 부릅니다. 난이도를 올려서 중간에 층을 더 추가해 봅시다. 4. 행렬곱으로 다층 퍼셉트론의 순전파 이해하기 위와 같은 인공 신경망이 있다고 합시다. 주어진 인공 신경망을 케라스로 구현해 본다면 아래와 같이 구현할 수 있습니다. 1) 코드로 구현하기 from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense model = Sequential() # 4개의 입력과 8개의 출력 model.add(Dense(8, input_dim=4, activation='relu')) # 이어서 8개의 출력 model.add(Dense(8, activation='relu')) # 이어서 3개의 출력 model.add(Dense(3, activation='softmax')) 위의 코드의 주석에서 () 괄호 안의 값은 각 층에서의 뉴런의 수를 의미하며 입력층부터 출력층까지 순차적으로 인공 신경망의 층을 한 층씩 추가하였습니다. 케라스를 사용하면 이렇게 간단하게 층을 딥하게 쌓은 딥 러닝 모델을 구현할 수 있습니다. 2) 행렬의 크기 추정해 보기 우선 각 층을 기준으로 입력과 출력의 개수를 정리하면 다음과 같습니다. 입력층 : 4개의 입력과 8개의 출력 은닉층 1 : 8개의 입력과 8개의 출력 은닉층 2 : 8개의 입력과 3개의 출력 출력층 : 3개의 입력과 3개의 출력 위의 정보를 가지고 층마다 생기는 가중치와 편향 행렬의 크기를 추정해 봅시다. 단, 배치 크기는 1을 가정합니다. 1. 입력층 ⇒ 은닉층 1 앞서 벡터와 행렬 연산을 설명하며 배운 바에 따르면, 입력 행렬, 가중치 행렬, 편향 행렬, 출력 행렬은 다음과 같은 크기 관계를 가집니다. m × n W × j B × j Y × j layer 1의 입력 행렬의 크기는 1 × 4입니다. layer 1의 출력은 8개이므로, 그에 따라 출력 행렬의 크기는 1 × 8이 됩니다. 1 × 4 W × j B × j Y × 8 그런데 가중치 행렬의 행은 입력 행렬의 열과 같아야 하므로 아래와 같습니다. 1 × 4 W × j B × j Y × 8 편향 행렬 는 출력 행렬의 크기에 영향을 주지 않으므로 편향 행렬의 크기는 출력 행렬의 크기와 같습니다. 1 × 4 W × j B × 8 Y × 8 가중치 행렬의 열은 출력 행렬의 열과 동일해야 합니다. 1 4 W × + 1 8 Y × 입력층과 은닉층 1 사이의 가중치 행렬과 편향 행렬의 크기를 구했습니다. 2. 은닉층 1 ⇒ 은닉층 2 이제 입력층 ⇒ 은닉층 1에서의 출력 행렬 는 은닉층 2에서는 입력 행렬로 다시 명명해 봅시다. 은닉층 1 ⇒ 은닉층 2 : 1 8 W × + 1 8 Y × 3. 은닉층 2 ⇒ 은닉층 3 이제 은닉층 2 ⇒ 은닉층 3에서의 출력 행렬 는 은닉층 3에서는 입력 행렬로 다시 명명해 봅시다. 은닉층 2 ⇒ 은닉층 3 : 1 8 W × + 1 3 Y × 은닉층과 출력층에 활성화 함수 relu와 softmax가 존재하지만 활성화 함수는 행렬의 크기에 영향을 주지 않습니다. 인공 신경망이 입력층에서 은닉층을 지나 출력층에서 예측값을 계산하기까지의 과정을 행렬 연산으로 가정하고 행렬의 크기를 추정해 보았습니다. 이와 같이 순전파를 진행하고 예측값을 구하고 나서 이다음에 인공 신경망이 해야 할 일은 예측값과 실제 값으로부터 오차를 계산하고, 오차로부터 가중치와 편향을 업데이트하는 일입니다. 즉, 인공 신경망의 학습 단계에 해당됩니다. 이때 인공 신경망은 순전파와는 반대 방향으로 연산을 진행하며 가중치를 업데이트하는데, 이 과정을 역전파(BackPropagation)라고 합니다. 인공 신경망의 역전파에 대해서는 뒤에서 다룹니다. 07-04 딥 러닝의 학습 방법 딥 러닝의 학습 방법의 이해를 위해 필요한 개념인 손실 함수, 옵티마이저, 에포크의 개념에 대해서 정리합니다. 1. 손실 함수(Loss function) 손실 함수는 실제 값과 예측값의 차이를 수치화해 주는 함수입니다. 이 두 값의 차이. 즉, 오차가 클수록 손실 함수의 값은 크고 오차가 작을수록 손실 함수의 값은 작아집니다. 회귀에서는 평균 제곱 오차, 분류 문제에서는 크로스 엔트로피를 주로 손실 함수로 사용합니다. 손실 함수의 값을 최소화하는 두 개의 매개변수인 가중치 와 편향의 값을 찾는 것이 딥 러닝의 학습 과정이므로 손실 함수의 선정은 매우 중요합니다. 앞서 설명했던 손실 함수를 정리해 봅시다. 1) MSE(Mean Squared Error, MSE) 평균 제곱 오차는 선형 회귀를 학습할 때 배웠던 손실 함수입니다. 연속형 변수를 예측할 때 사용됩니다. 다음과 같이 compile의 loss에 문자열 'mse'라고 기재하여 사용할 수 있습니다. model.compile(optimizer='adam', loss='mse', metrics=['mse']) compile의 loss는 tf.keras.losses.Loss 인스턴스를 호출하므로 위 코드는 아래와 같이 사용할 수도 있습니다. model.compile(optimizer='adam', loss=tf.keras.losses.MeanSquaredError(), metrics=['mse']) 딥 러닝 자연어 처리는 대부분 분류 문제이므로 평균 제곱 오차보다는 아래의 크로스 엔트로피 함수들을 주로 사용합니다. 2) 이진 크로스 엔트로피(Binary Cross-Entropy) 이항 교차 엔트로피라고도 부르는 손실 함수입니다. 출력층에서 시그모이드 함수를 사용하는 이진 분류 (Binary Classification)의 경우 binary_crossentropy를 사용합니다. compile의 loss에 문자열로 'binary_crossentropy'를 기재해 주면 됩니다. 이는 로지스틱 회귀에서 사용했던 손실 함수입니다. model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['acc']) compile의 loss는 tf.keras.losses.Loss 인스턴스를 호출하므로 위 코드는 아래와 같이 사용할 수도 있습니다. model.compile(loss=tf.keras.losses.BinaryCrossentropy(), optimizer='adam', metrics=['acc']) 3) 카테고리칼 크로스 엔트로피(Categorical Cross-Entropy) 범주형 교차 엔트로피라고도 부르는 손실 함수입니다. 출력층에서 소프트맥스 함수를 사용하는 다중 클래스 분류(Multi-Class Classification)일 경우 categorical_crossentropy를 사용합니다. compile의 loss에 문자열로 'categorical_crossentropy'를 기재해 주면 됩니다. 소프트맥스 회귀에서 사용했던 손실 함수입니다. model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc']) compile의 loss는 tf.keras.losses.Loss 인스턴스를 호출하므로 위 코드는 아래와 같이 사용할 수도 있습니다. model.compile(loss=tf.keras.losses.CategoricalCrossentropy(), optimizer='adam', metrics=['acc']) 만약 레이블에 대해서 원-핫 인코딩 과정을 생략하고, 정숫값을 가진 레이블에 대해서 다중 클래스 분류를 수행하고 싶다면 다음과 같이 'sparse_categorical_crossentropy'를 사용합니다. model.compile(loss='sparse_categorical_crossentropy', optimizer='adam', metrics=['acc']) 위 코드는 아래와 같이 사용할 수도 있습니다. model.compile(loss=tf.keras.losses.SparseCategoricalCrossentropy(), optimizer='adam', metrics=['acc']) 4) 그 외에 다양한 손실 함수들 아래의 텐서 플로 공식 문서 링크에서 방금 언급하지 않은 손실 함수 외에도 다양한 손실 함수들을 확인할 수 있습니다. https://www.tensorflow.org/api_docs/python/tf/keras/losses 지금까지 자주 사용하는 손실 함수 몇 가지에 대해서 정리해 봤습니다. 위 compile 코드에서 optimizer='adam'이라는 부분에 주목해 봅시다. 이는 아담이라는 옵티마이저를 사용했다는 의미입니다. 손실 함수의 선정만큼이나 옵티마이저의 선정 또한 중요합니다. 이어서 옵티마이저에 대해서 정리해 봅시다. 2. 배치 크기(Batch Size)에 따른 경사 하강법 손실 함수의 값을 줄여나가면서 학습하는 방법은 어떤 옵티마이저를 사용하느냐에 따라 달라집니다. 여기서 배치(Batch)라는 개념에 대한 이해가 필요합니다. 배치는 가중치 등의 매개 변수의 값을 조정하기 위해 사용하는 데이터의 양을 말합니다. 전체 데이터를 가지고 매개 변수의 값을 조정할 수도 있고, 정해준 양의 데이터만 가지고도 매개 변수의 값을 조정할 수 있습니다. 1) 배치 경사 하강법(Batch Gradient Descent) 배치 경사 하강법(Batch Gradient Descent)은 가장 기본적인 경사 하강법입니다. 배치 경사 하강법은 옵티마이저 중 하나로 오차(loss)를 구할 때 전체 데이터를 고려합니다. 딥 러닝에서는 전체 데이터에 대한 한 번의 훈련 횟수를 1 에포크라고 하는데, 배치 경사 하강법은 한 번의 에포크에 모든 매개변수 업데이트를 단 한 번 수행합니다. 배치 경사 하강법은 전체 데이터를 고려해서 학습하므로 한 번의 매개 변수 업데이트에 시간이 오래 걸리며, 메모리를 크게 요구한다는 단점이 있습니다. model.fit(X_train, y_train, batch_size=len(X_train)) 2) 배치 크기가 1인 확률적 경사 하강법(Stochastic Gradient Descent, SGD) 기존의 배치 경사 하강법은 전체 데이터에 대해서 계산을 하다 보니 시간이 너무 오래 걸린다는 단점이 있습니다. 배치 크기가 1인 확률적 경사 하강법은 매개변수 값을 조정 시 전체 데이터가 아니라 랜덤으로 선택한 하나의 데이터에 대해서만 계산하는 방법입니다. 더 적은 데이터를 사용하므로 더 빠르게 계산할 수 있습니다. 위 그림에서 좌측은 배치 경사 하강법, 우측은 배치 크기가 1인 확률적 경사 하강법이 최적해를 찾아가는 모습을 보여주고 있습니다. 확률적 경사 하강법은 매개변수의 변경폭이 불안정하고, 때로는 배치 경사 하강법보다 정확도가 낮을 수도 있지만 하나의 데이터에 대해서만 메모리에 저장하면 되므로 자원이 적은 컴퓨터에서도 쉽게 사용 가능하다는 장점이 있습니다. 케라스에서는 아래와 같이 사용합니다. model.fit(X_train, y_train, batch_size=1) 3) 미니 배치 경사 하강법(Mini-Batch Gradient Descent) 전체 데이터도, 1개의 데이터도 아닐 때, 배치 크기를 지정하여 해당 데이터 개수만큼에 대해서 계산하여 매개 변수의 값을 조정하는 경사 하강법을 미니 배치 경사 하강법이라고 합니다. 미니 배치 경사 하강법은 전체 데이터를 계산하는 것보다 빠르며, SGD보다 안정적이라는 장점이 있습니다. 가장 많이 사용되는 경사 하강법으로 앞으로 이 책에서도 주로 배치 크기를 지정하여 미니 배치 경사 하강법으로 학습하게 될 것입니다. 아래의 코드는 배치 크기를 128로 지정했을 경우를 보여줍니다. model.fit(X_train, y_train, batch_size=128) 배치 크기는 일반적으로 2의 n 제곱에 해당하는 숫자로 선택하는 것이 보편적입니다. 만약, model.fit()에서 배치 크기를 별도로 지정해 주지 않을 경우에 기본값은 2의 5제곱에 해당하는 숫자인 32로 설정됩니다. 지금까지 배치 크기에 따른 학습 방법의 차이를 알아봤습니다. 앞으로는 경사 하강법의 알고리즘 자체를 조금씩 달리한 다양한 옵티마이저에 대해서 설명합니다. 3. 옵티마이저(Optimizer) 1) 모멘텀(Momentum) 모멘텀(Momentum)은 관성이라는 물리학의 법칙을 응용한 방법입니다. 모멘텀 경사 하강법에 관성을 더 해줍니다. 모멘텀은 경사 하강법에서 계산된 접선의 기울기에 한 시점 전의 접선의 기울기 값을 일정한 비율만큼 반영합니다. 이렇게 하면 마치 언덕에서 공이 내려올 때, 중간에 작은 웅덩이에 빠지더라도 관성의 힘으로 넘어서는 효과를 줄 수 있습니다. 전체 함수에 걸쳐 최솟값을 글로벌 미니멈(Global Minimum)이라고 하고, 글로벌 미니멈이 아닌 특정 구역에서의 최솟값인 로컬 미니멈(Local Minimum)이라고 합니다. 로컬 미니멈에 도달하였을 때 글로벌 미니멈으로 잘못 인식하여 탈출하지 못하였을 상황에서 모멘텀. 즉, 관성의 힘을 빌리면 값이 조절되면서 현재의 로컬 미니멈에서 탈출하고 글로벌 미니멈 내지는 더 낮은 로컬 미니멈으로 갈 수 있는 효과를 얻을 수도 있습니다. tf.keras.optimizers.SGD(lr=0.01, momentum=0.9) 2) 아다 그라드(Adagrad) 매개변수들은 각자 의미하는 바가 다른데, 모든 매개변수에 동일한 학습률(learning rate)을 적용하는 것은 비효율적입니다. 아다 그라드는 각 매개변수에 서로 다른 학습률을 적용시킵니다. 이때 변화가 많은 매개변수는 학습률이 작게 설정되고 변화가 적은 매개변수는 학습률을 높게 설정시킵니다. tf.keras.optimizers.Adagrad(lr=0.01, epsilon=1e-6) 3) 알엠에스프롭(RMSprop) 아다 그라드는 학습을 계속 진행한 경우에는, 나중에 가서는 학습률이 지나치게 떨어진다는 단점이 있는데 이를 다른 수식으로 대체하여 이러한 단점을 개선하였습니다. tf.keras.optimizers.RMSprop(lr=0.001, rho=0.9, epsilon=1e-06) 4) 아담(Adam) 아담은 알엠에스프롭과 모멘텀 두 가지를 합친 듯한 방법으로, 방향과 학습률 두 가지를 모두 잡기 위한 방법입니다. tf.keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False) 5) 사용 방법 각 옵티마이저 인스턴스는 compile의 optimizer에서 호출합니다. 예를 들어 아담(adam)은 다음과 같이 코드를 작성합니다. adam = tf.keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False) model.compile(loss='categorical_crossentropy', optimizer=adam, metrics=['acc']) 하지만 다음과 같이 단순히 문자열로 'adam'으로 작성하더라도 동작합니다. model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc']) 다른 옵티마이저들도 마찬가지입니다. optimizer='sgd', optimizer='rmsprop'와 같이 각 옵티마이저를 문자열로 호출할 수 있습니다. 케라스의 옵티마이저 사용법은 아래의 링크에서 좀 더 상세히 확인할 수 있습니다. 링크 : https://www.tensorflow.org/api_docs/python/tf/keras/optimizers 4. 역전파(BackPropagation) 이 부분은 05) 역전파 챕터로 별도 작성되었습니다. 5. 에포크와 배치 크기와 이터레이션(Epochs and Batch size and Iteration) 기계는 실제 값과 예측값의 오차로부터 옵티마이저를 통해서 가중치를 업데이트합니다. 머신 러닝에서는 이 과정을 학습이라고 합니다. 이를 현실의 학습에 비유하면 사람은 문제지의 문제를 풀고, 정답지의 정답을 보면서 채점을 하면서 부족했던 점을 깨달으며 머릿속의 지식이 업데이트되는 과정입니다. 그런데 사람마다 동일한 문제지와 정답지를 주더라도 공부 방법은 사실 천차만별입니다. 어떤 사람은 문제지 하나를 다 풀고 나서 정답을 채점하는데 어떤 사람은 문제지의 문제를 10개 단위로 끊어서 공부합니다. 문제 10개를 풀고 채점하고 다시 다음 문제 10개를 풀고 채점하고 반복하는 방식으로 학습하는 방식입니다. 또한 게으른 사람은 문제지를 세 번 공부하는데, 성실한 사람은 문제지의 문제를 달달 외울 만큼 문제지를 100번 공부합니다. 기계도 똑같습니다. 같은 문제지와 정답지를 주더라도 공부 방법을 다르게 설정할 수 있습니다. 위 그림은 에포크와 배치 크기와 이터레이션의 차이를 보여줍니다. 1) 에포크(Epoch) 에포크란 인공 신경망에서 전체 데이터에 대해서 순전파와 역전파가 끝난 상태를 말합니다. 전체 데이터를 하나의 문제지에 비유한다면 문제지의 모든 문제를 끝까지 다 풀고, 정답지로 채점을 하여 문제지에 대한 공부를 한 번 끝낸 상태를 말합니다. 만약 에포크가 50이라고 하면, 전체 데이터 단위로는 총 50번 학습합니다. 문제지에 비유하면 문제지를 50번 푼 셈입니다. 이 에포크 횟수가 지나치거나 너무 적으면 앞서 배운 과적합과 과소 적합이 발생할 수 있습니다. 2) 배치 크기(Batch size) 배치 크기는 몇 개의 데이터 단위로 매개변수를 업데이트하는지를 말합니다. 현실에 비유하면 문제지에서 몇 개씩 문제를 풀고 나서 정답지를 확인하느냐의 문제입니다. 사람은 문제를 풀고 정답을 보는 순간 부족했던 점을 깨달으며 지식이 업데이트된다고 하였습니다. 기계 입장에서는 실제 값과 예측값으로부터 오차를 계산하고 옵티마이저가 매개변수를 업데이트합니다. 여기서 중요한 포인트는 업데이트가 시작되는 시점이 정답지/실제 값을 확인하는 시점이라는 겁니다. 사람이 2,000 문제가 수록되어 있는 문제지의 문제를 200개 단위로 풀고 채점한다고 하면 이때 배치 크기는 200입니다. 기계는 배치 크기가 200이면 200개의 샘플 단위로 가중치를 업데이트합니다. 여기서 주의할 점은 배치 크기와 배치의 수는 다른 개념이라는 점입니다. 전체 데이터가 2,000일 때 배치 크기를 200으로 준다면 배치의 수는 10입니다. 이는 에포크에서 배치 크기를 나눠준 값(2,000/200 = 10)이기도 합니다. 이때 배치의 수를 이터레이션이라고 합니다. 3) 이터레이션(Iteration) 또는 스텝(Step) 이터레이션이란 한 번의 에포크를 끝내기 위해서 필요한 배치의 수를 말합니다. 또는 한 번의 에포크 내에서 이루어지는 매개변수의 업데이트 횟수이기도 합니다. 전체 데이터가 2,000일 때 배치 크기를 200으로 한다면 이터레이션의 수는 총 10입니다. 이는 한 번의 에포크 당 매개변수 업데이트가 10번 이루어진다는 것을 의미합니다. 배치 크기가 1인 확률적 경사 하강법을 이 개념을 가지고 다시 설명하면 배치 크기가 1이므로 모든 이터레이션마다 하나의 데이터를 선택하여 경사 하강법을 수행합니다. 이터레이션은 스텝(Step)이라고 부르기도 하므로 두 용어 모두 기억해둡시다. 07-05 역전파(BackPropagation) 이해하기 인공 신경망이 순전파 과정을 진행하여 예측값과 실제 값의 오차를 계산하였을 때 어떻게 역전파 과정에서 경사 하강법을 사용하여 가중치를 업데이트하는지 직접 계산을 통해 이해해 봅시다. 1. 인공 신경망의 이해(Neural Network Overview) 우선 예제를 위해 사용될 인공 신경망을 소개합니다. 역전파의 이해를 위해서 여기서 사용할 인공 신경망은 입력층, 은닉층, 출력층 이렇게 3개의 층을 가집니다. 또한 해당 인공 신경망은 두 개의 입력과, 두 개의 은닉층 뉴런, 두 개의 출력층 뉴런을 사용합니다. 은닉층과 출력층의 모든 뉴런은 활성화 함수로 시그모이드 함수를 사용합니다. 위의 그림은 여기서 사용할 인공 신경망의 모습을 보여줍니다. 은닉층과 출력층의 모든 뉴런에서 변수 가 존재하는데 여기서 변수는 이전층의 모든 입력이 각각의 가중치와 곱해진 값들이 모두 더해진 가중합을 의미합니다. 이 값은 뉴런에서 아직 시그모이드 함수를 거치지 않은 상태입니다. 즉, 활성화 함수의 입력을 의미합니다. 우측의 |를 지나서 존재하는 변수 또는 는 가 시그모이드 함수를 지난 후의 값으로 각 뉴런의 출력값을 의미합니다. 이번 역전파 예제에서는 인공 신경망에 존재하는 모든 가중치에 대해서 역전파를 통해 업데이트하는 것을 목표로 합니다. 해당 인공 신경망은 편향 는 고려하지 않습니다. 2. 순전파(Forward Propagation) 주어진 값이 위의 그림과 같을 때 순전파를 진행해 봅시다. 위의 그림에서 소수점 앞의 0은 생략하였습니다. 예를 들어. 25는 0.25를 의미합니다. 파란색 숫자는 입력값을 의미하며, 빨간색 숫자는 각 가중치의 값을 의미합니다. 앞으로 진행하는 계산의 결괏값은 소수점 아래 여덟 번째 자리까지 반올림하여 표기합니다. 각 입력은 입력층에서 은닉층 방향으로 향하면서 각 입력에 해당하는 가중치와 곱해지고, 결과적으로 가중 합으로 계산되어 은닉층 뉴런의 시그모이드 함수의 입력값이 됩니다. 1 z는 시그모이드 함수의 입력으로 사용되는 각각의 값에 해당됩니다. 1 w x + 2 2 0.3 0.1 0.25 0.2 0.08 2 w x + 4 2 0.4 0.1 0.35 0.2 0.11 1 z는 각각의 은닉층 뉴런에서 시그모이드 함수를 지나게 되는데 시그모이드 함수가 리턴하는 결괏값은 은닉층 뉴런의 최종 출력값입니다. 식에서는 각각 1 h에 해당되며, 아래의 결과와 같습니다. 1 s g o d ( 1 ) 0.51998934 2 s g o d ( 2 ) 0.52747230 1 h 이 두 값은 다시 출력층의 뉴런으로 향하게 되는데 이때 다시 각각의 값에 해당되는 가중치와 곱해지고, 다시 가중 합 되어 출력층 뉴런의 시그모이드 함수의 입력값이 됩니다. 식에서는 각각 3 z에 해당됩니다. 3 w h + 6 2 0.45 h + 0.4 h = 0.44498412 4 w h + 8 2 0.7 h + 0.6 h = 0.68047592 3 z 이 출력층 뉴런에서 시그모이드 함수를 지난 값은 이 인공 신경망이 최종적으로 계산한 출력값입니다. 실제 값을 예측하기 위한 값으로서 예측값이라고도 부릅니다. 1 s g o d ( 3 ) 0.60944600 2 s g o d ( 4 ) 0.66384491 이제 해야 할 일은 예측값과 실제 값의 오차를 계산하기 위한 오차 함수를 선택하는 것입니다. 오차(Error)를 계산하기 위한 손실 함수(Loss function)로는 평균 제곱 오차 MSE를 사용합니다. 식에서는 실제 값을 target이라고 표현하였으며, 순전파를 통해 나온 예측값을 output으로 표현하였습니다. 그리고 각 오차를 모두 더하면 전체 오차 t t l 가 됩니다. o = 2 ( a g t 1 o t u o) = 0.02193381 o = 2 ( a g t 2 o t u o) = 0.00203809 t t l E 1 E 2 0.02397190 3. 역전파 1단계(BackPropagation Step 1) 순전파가 입력층에서 출력층으로 향한다면 역전파는 반대로 출력층에서 입력층 방향으로 계산하면서 가중치를 업데이트해갑니다. 출력층 바로 이전의 은닉층을 N 층이라고 하였을 때, 출력층과 N 층 사이의 가중치를 업데이트하는 단계를 역전파 1단계, 그리고 N 층과 N 층의 이전층 사이의 가중치를 업데이트하는 단계를 역전파 2단계라고 해봅시다. 역전파 1단계에서 업데이트해야 할 가중치는 5 w, 7 w 총 4개입니다. 원리 자체는 동일하므로 우선 5 에 대해서 먼저 업데이트를 진행해 보겠습니다. 경사 하강법을 수행하려면 가중치 5 를 업데이트하기 위해서 E o a ∂ 5 를 계산해야 합니다. E o a ∂ 5 를 계산하기 위해 미분의 연쇄 법칙(Chain rule)에 따라서 이와 같이 풀어쓸 수 있습니다. E o a ∂ 5 ∂ t t l o × o ∂ 3 ∂ 3 w 위의 식에서 우변의 세 개의 각 항에 대해서 순서대로 계산해 봅시다. 우선 첫 번째 항에 대해서 계산해 보겠습니다. 미분을 진행하기 전에 t t l 의 값을 상기해 봅시다. t t l 은 앞서 순전파를 진행하고 계산했던 전체 오차 값입니다. 식은 다음과 같습니다. t t l 1 ( a g t 1 o t u o) + 2 ( a g t 2 o t u o) 이에 E o a ∂ 1 는 다음과 같습니다. E o a ∂ 1 2 1 ( a g t 1 o t u o) − × ( 1 ) 0 E o a ∂ 1 − ( a g t 1 o t u o) − ( 0.4 0.60944600 ) 0.20944600 이제 두 번째 항을 주목해 봅시다. 1 이라는 값은 시그모이드 함수의 출력값입니다. 그런데 시그모이드 함수의 미분은 ( ) ( − ( ) ) 입니다. 앞으로의 계산 과정에서도 계속해서 시그모이드 함수를 미분해야 하는 상황이 생기므로 기억해둡시다. 이에 따라서 두 번째 항의 미분 결과는 다음과 같습니다. (시그모이드 함수 미분 참고 링크 : https://en.wikipedia.org/wiki/Logistic_function#Derivative) o ∂ 3 o × ( − 1 ) 0.60944600 ( − 0.60944600 ) 0.23802157 마지막으로 세 번째 항은 1 의 값과 동일합니다. z ∂ 5 h = 0.51998934 우변의 모든 항을 계산하였습니다. 이제 이 값을 모두 곱해주면 됩니다. E o a ∂ 5 0.20944600 0.23802157 0.51998934 0.02592286 이제 앞서 배웠던 경사 하강법을 통해 가중치를 업데이트할 때가 왔습니다! 하이퍼 파라미터에 해당되는 학습률(learning rate)는 0.5라고 가정합니다. 5 = 5 α E o a ∂ 5 0.45 0.5 0.02592286 0.43703857 이와 같은 원리로 6 , w + w + 을 계산할 수 있습니다. E o a ∂ 6 ∂ t t l o × o ∂ 3 ∂ 3 w → 6 = 0.38685205 E o a ∂ 7 ∂ t t l o × o ∂ 4 ∂ 4 w → 7 = 0.69629578 E o a ∂ 8 ∂ t t l o × o ∂ 4 ∂ 4 w → 8 = 0.59624247 4. 역전파 2단계(BackPropagation Step 2) 1단계를 완료하였다면 이제 입력층 방향으로 이동하며 다시 계산을 이어갑니다. 위의 그림에서 빨간색 화살표는 순전파의 정반대 방향인 역전파의 방향을 보여줍니다. 현재 인공 신경망은 은닉층이 1개밖에 없으므로 이번 단계가 마지막 단계입니다. 하지만 은닉층이 더 많은 경우라면 입력층 방향으로 한 단계씩 계속해서 계산해가야 합니다. 이번 단계에서 계산할 가중치는 1 w, 3 w입니다. 원리 자체는 동일하므로 우선 1 에 대해서 먼저 업데이트를 진행해 보겠습니다. 경사 하강법을 수행하려면 가중치 1 를 업데이트하기 위해서 E o a ∂ 1 를 계산해야 합니다. E o a ∂ 1 를 계산하기 위해 미분의 연쇄 법칙(Chain rule)에 따라서 이와 같이 풀어쓸 수 있습니다. E o a ∂ 1 ∂ t t l h × h ∂ 1 ∂ 1 w 위의 식에서 우변의 첫 번째 항인 E o a ∂ 1 는 다음과 같이 다시 식을 풀어서 쓸 수 있습니다. E o a ∂ 1 ∂ o ∂ 1 ∂ o ∂ 1 위의 식의 우변의 두 항을 각각 구해봅시다. 우선 첫 번째 항 E 1 h에 대해서 항을 분해 및 계산해 보겠습니다. E 1 h = E 1 z × z ∂ 1 ∂ o ∂ 1 ∂ 1 z × z ∂ 1 − ( a g t 1 o t u o) o × ( − 1 ) w = 0.20944600 0.23802157 0.45 0.02243370 이와 같은 원리로 E 2 h 또한 구합니다. E 2 h = E 2 z × z ∂ 1 ∂ o ∂ 2 ∂ 2 z × z ∂ 1 0.00997311 E o a ∂ 1 0.02243370 0.00997311 0.03240681 이제 E o a ∂ 1 를 구하기 위해서 필요한 첫 번째 항을 구했습니다. 나머지 두 항에 대해서 구해보도록 하겠습니다. h ∂ 1 h × ( − 1 ) 0.51998934 ( − 0.51998934 ) 0.24960043 z ∂ 1 x = 0.1 즉, E o a ∂ 1 는 다음과 같습니다. E o a ∂ 1 0.03240681 0.24960043 0.1 0.00080888 이제 앞서 배웠던 경사 하강법을 통해 가중치를 업데이트할 수 있습니다. 1 = 1 α E o a ∂ 1 0.3 0.5 0.00080888 0.29959556 이와 같은 원리로 2 , w + w + 을 계산할 수 있습니다. E o a ∂ 2 ∂ t t l h × h ∂ 1 ∂ 1 w → 2 = 0.24919112 E o a ∂ 3 ∂ t t l h × h ∂ 2 ∂ 2 w → 3 = 0.39964496 E o a ∂ 4 ∂ t t l h × h ∂ 2 ∂ 2 w → 4 = 0.34928991 5. 결과 확인 업데이트된 가중치에 대해서 다시 한번 순전파를 진행하여 오차가 감소하였는지 확인해 보겠습니다. 1 w x + 2 2 0.29959556 0.1 0.24919112 0.2 0.07979778 2 w x + 4 2 0.39964496 0.1 0.34928991 0.2 0.10982248 1 s g o d ( 1 ) 0.51993887 2 s g o d ( 2 ) 0.52742806 3 w h + 6 2 0.43703857 h + 0.38685205 h = 0.43126996 4 w h + 8 2 0.69629578 h + 0.59624247 h = 0.67650625 1 s g o d ( 3 ) 0.60617688 2 s g o d ( 4 ) 0.66295848 o = 2 ( a g t 1 o t u o) = 0.02125445 o = 2 ( a g t 2 o t u o) = 0.00198189 t t l E 1 E 2 0.02323634 기존의 전체 오차 t t l 가 0.02397190였으므로 1번의 역전파로 오차가 감소한 것을 확인할 수 있습니다. 인공 신경망의 학습은 오차를 최소화하는 가중치를 찾는 목적으로 순전파와 역전파를 반복하는 것을 말합니다. 07-06 과 적합(Overfitting)을 막는 방법들 학습 데이터에 모델이 과적합되는 현상은 모델의 성능을 떨어트리는 주요 이슈입니다. 모델이 과적합되면 훈련 데이터에 대한 정확도는 높을지라도, 새로운 데이터. 즉, 검증 데이터나 테스트 데이터에 대해서는 제대로 동작하지 않습니다. 이는 모델이 학습 데이터를 불필요할 정도로 과하게 암기하여 훈련 데이터에 포함된 노이즈까지 학습한 상태라고 해석할 수 있습니다. 이번에는 모델의 과적합을 막을 수 있는 여러 가지 방법에 대해서 논의합니다. 특히 이 책은 딥 러닝을 다루고 있으므로, 인공 신경망의 과적합을 막는 방법에 초점을 둡니다. 1. 데이터의 양을 늘리기 모델은 데이터의 양이 적을 경우, 해당 데이터의 특정 패턴이나 노이즈까지 쉽게 암기하기 되므로 과적합 현상이 발생할 확률이 늘어납니다. 그렇기 때문에 데이터의 양을 늘릴수록 모델은 데이터의 일반적인 패턴을 학습하여 과적합을 방지할 수 있습니다. 만약, 데이터의 양이 적을 경우에는 의도적으로 기존의 데이터를 조금씩 변형하고 추가하여 데이터의 양을 늘리기도 하는데 이를 데이터 증식 또는 증강(Data Augmentation)이라고 합니다. 이미지의 경우에는 데이터 증식이 많이 사용되는데 이미지를 돌리거나 노이즈를 추가하고, 일부분을 수정하는 등으로 데이터를 증식시킵니다. 텍스트 데이터의 경우에는 데이터를 증강하는 방법으로 번역 후 재번역을 통해 새로운 데이터를 만들어내는 역 번역(Back Translation) 등의 방법이 있습니다. 2. 모델의 복잡도 줄이기 인공 신경망의 복잡도는 은닉층(hidden layer)의 수나 매개변수의 수 등으로 결정됩니다. 과적합 현상이 포착되었을 때, 인공 신경망 모델에 대해서 할 수 있는 한 가지 조치는 인공 신경망의 복잡도를 줄이는 것입니다. 인공 신경망에서는 모델에 있는 매개변수들의 수를 모델의 수용력(capacity)이라고 하기도 합니다. 3. 가중치 규제(Regularization) 적용하기 복잡한 모델이 간단한 모델보다 과적합될 가능성이 높습니다. 그리고 간단한 모델은 적은 수의 매개변수를 가진 모델을 말합니다. 복잡한 모델을 좀 더 간단하게 하는 방법으로 가중치 규제(Regularization)가 있습니다. L1 규제 : 가중치 w들의 절댓값 합계를 비용 함수에 추가합니다. L1 노름이라고도 합니다. L2 규제 : 모든 가중치 w들의 제곱합을 비용 함수에 추가합니다. L2 노름이라고도 합니다. L1 규제는 기존의 비용 함수에 모든 가중치에 대해서 ∣ ∣ 를 더 한 값을 비용 함수로 하고, L2 규제는 기존의 비용 함수에 모든 가중치에 대해서 2 w를 더 한 값을 비용 함수로 합니다.는 규제의 강도를 정하는 하이퍼 파라미터입니다. 가 크다면 모델이 훈련 데이터에 대해서 적합한 매개 변수를 찾는 것보다 규제를 위해 추가된 항들을 작게 유지하는 것을 우선한다는 의미가 됩니다. 이 두 식 모두 비용 함수를 최소화하기 위해서는 가중치 w들의 값이 작아져야 한다는 특징이 있습니다. L1 규제로 예를 들어봅시다. L1 규제를 사용하면 비용 함수가 최소가 되게 하는 가중치와 편향을 찾는 동시에 가중치들의 절댓값의 합도 최소가 되어야 합니다. 이렇게 되면, 가중치 w의 값들은 0 또는 0에 가까이 작아져야 하므로 어떤 특성들은 모델을 만들 때 거의 사용되지 않게 됩니다. 예를 들어 ( ) w x + 2 2 w x + 4 4 라는 수식이 있다고 해봅시다. 여기에 L1 규제를 사용하였더니, 3 의 값이 0이 되었다고 해봅시다. 이는 3 특성은 사실 모델의 결과에 별 영향을 주지 못하는 특성임을 의미합니다. L2 규제는 L1 규제와는 달리 가중치들의 제곱을 최소화하므로 w의 값이 완전히 0이 되기보다는 0에 가까워지기는 경향을 띕니다. L1 규제는 어떤 특성들이 모델에 영향을 주고 있는지를 정확히 판단하고자 할 때 유용합니다. 만약, 이런 판단이 필요 없다면 경험적으로는 L2 규제가 더 잘 동작하므로 L2 규제를 더 권장합니다. 인공 신경망에서 L2 규제는 가중치 감쇠(weight decay)라고도 부릅니다. 책에 따라서는 Regularization를 정규화로 번역하기도 하지만, 이는 정규화(Normalization)와 혼동될 수 있으므로 규제 또는 정형화라는 번역이 바람직한 것 같습니다. 인공 신경망에서 정규화(Normalization)라는 용어가 쓰이는 기법으로는 또 배치 정규화, 층 정규화 등이 있습니다. 4. 드롭아웃(Dropout) 드롭아웃은 학습 과정에서 신경망의 일부를 사용하지 않는 방법입니다. 위의 그림은 드롭아웃 전과 후의 신경망을 비교하고 있습니다. 예를 들어 드롭아웃의 비율을 0.5로 한다면 학습 과정마다 랜덤으로 절반의 뉴런을 사용하지 않고, 절반의 뉴런만을 사용합니다. 드롭아웃은 신경망 학습 시에만 사용하고, 예측 시에는 사용하지 않는 것이 일반적입니다. 학습 시에 인공 신경망이 특정 뉴런 또는 특정 조합에 너무 의존적이게 되는 것을 방지해 주고, 매번 랜덤 선택으로 뉴런들을 사용하지 않으므로 서로 다른 신경망들을 앙상블 하여 사용하는 것 같은 효과를 내어 과적합을 방지합니다. 케라스에서는 다음과 같은 방법으로 드롭아웃을 모델에 추가할 수 있습니다. from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dropout, Dense max_words = 10000 num_classes = 46 model = Sequential() model.add(Dense(256, input_shape=(max_words,), activation='relu')) model.add(Dropout(0.5)) # 드롭아웃 추가. 비율은 50% model.add(Dense(128, activation='relu')) model.add(Dropout(0.5)) # 드롭아웃 추가. 비율은 50% model.add(Dense(num_classes, activation='softmax')) 07-07 기울기 소실(Gradient Vanishing)과 폭주(Exploding) 깊은 인공 신경망을 학습하다 보면 역전파 과정에서 입력층으로 갈수록 기울기(Gradient)가 점차적으로 작아지는 현상이 발생할 수 있습니다. 입력층에 가까운 층들에서 가중치들이 업데이트가 제대로 되지 않으면 결국 최적의 모델을 찾을 수 없게 됩니다. 이를 기울기 소실(Gradient Vanishing)이라고 합니다. 반대의 경우도 있습니다. 기울기가 점차 커지더니 가중치들이 비정상적으로 큰 값이 되면서 결국 발산되기도 합니다. 이를 기울기 폭주(Gradient Exploding)라고 하며, 다음 챕터에서 배울 순환 신경망(Recurrent Neural Network, RNN)에서 쉽게 발생할 수 있습니다. 여기서는 기울기 소실 또는 기울기 폭주를 막는 방법들에 대해서 다룹니다. 1. ReLU와 ReLU의 변형들 앞에서 배운 내용을 간단히 복습해 봅시다. 시그모이드 함수를 사용하면 입력의 절댓값이 클 경우에 시그모이드 함수의 출력값이 0 또는 1에 수렴하면서 기울기가 0에 가까워집니다. 그래서 역전파 과정에서 전파 시킬 기울기가 점차 사라져서 입력층 방향으로 갈수록 제대로 역전파가 되지 않는 기울기 소실 문제가 발생할 수 있습니다. 기울기 소실을 완화하는 가장 간단한 방법은 은닉층의 활성화 함수로 시그모이드나 하이퍼볼릭탄젠트 함수 대신에 ReLU나 ReLU의 변형 함수와 같은 Leaky ReLU를 사용하는 것입니다. 은닉층에서는 시그모이드 함수를 사용하지 마세요. Leaky ReLU를 사용하면 모든 입력값에 대해서 기울기가 0에 수렴하지 않아 죽은 ReLU 문제를 해결합니다. 은닉층에서는 ReLU나 Leaky ReLU와 같은 ReLU 함수의 변형들을 사용하세요. 2. 그래디 언트 클리핑(Gradient Clipping) 그래디 언트 클리핑은 말 그대로 기울기 값을 자르는 것을 의미합니다. 기울기 폭주를 막기 위해 임곗값을 넘지 않도록 값을 자릅니다. 다시 말해서 임계치만큼 크기를 감소시킵니다. 이는 뒤에서 배울 신경망인 RNN에서 유용합니다. RNN은 역전파 과정에서 시점을 역행하면서 기울기를 구하는데, 이때 기울기가 너무 커질 수 있기 때문입니다. 케라스에서는 다음과 같은 방법으로 그래디 언트 클리핑을 수행합니다. from tensorflow.keras import optimizers Adam = optimizers.Adam(lr=0.0001, clipnorm=1.) 3. 가중치 초기화(Weight initialization) 같은 모델을 훈련시키더라도 가중치가 초기에 어떤 값을 가졌느냐에 따라서 모델의 훈련 결과가 달라지기도 합니다. 다시 말해 가중치 초기화만 적절히 해줘도 기울기 소실 문제과 같은 문제를 완화시킬 수 있습니다. 1) 세이비어 초기화(Xavier Initialization) 논문 : http://proceedings.mlr.press/v9/glorot10a/glorot10a.pdf 2010년 세이비어 글로럿과 요슈아 벤 지 오는 가중치 초기화가 모델에 미치는 영향을 분석하여 새로운 초기화 방법을 제안했습니다. 이 초기화 방법은 제안한 사람의 이름을 따서 세이비어(Xavier Initialization) 초기화 또는 글로럿 초기화(Glorot Initialization)라고 합니다. 이 방법은 균등 분포(Uniform Distribution) 또는 정규 분포(Normal distribution)로 초기화할 때 두 가지 경우로 나뉘며, 이전 층의 뉴런 개수와 다음 층의 뉴런 개수를 가지고 식을 세웁니다. 이전 층의 뉴런의 개수를 i, 다음 층의 뉴런의 개수를 o t 이라고 해봅시다. 글로럿과 벤 지 오의 논문에서는 균등 분포를 사용하여 가중치를 초기화할 경우 다음과 같은 균등 분포 범위를 사용하라고 합니다. ∼ n f r ( 6 i + o t + n n n u) 다시 말해 n n n u 를 이라고 하였을 때, m + 사이의 균등 분포를 의미합니다. 정규 분포로 초기화할 경우에는 평균이 0이고, 표준 편차 σ가 다음을 만족하도록 합니다. = n n n u 세이비어 초기화는 여러 층의 기울기 분산 사이에 균형을 맞춰서 특정 층이 너무 주목을 받거나 다른 층이 뒤처지는 것을 막습니다. 그런데 세이비어 초기화는 시그모이드 함수나 하이퍼볼릭 탄젠트 함수와 같은 S자 형태인 활성화 함수와 함께 사용할 경우에는 좋은 성능을 보이지만, ReLU와 함께 사용할 경우에는 성능이 좋지 않습니다. ReLU 함수 또는 ReLU의 변형 함수들을 활성화 함수로 사용할 경우에는 다른 초기화 방법을 사용하는 것이 좋은데, 이를 He 초기화(He initialization)라고 합니다. 2) He 초기화(He initialization) 논문 : https://www.cv-foundation.org/openaccess/content_iccv_2015/papers/He_Delving_Deep_into_ICCV_2015_paper.pdf He 초기화(He initialization)는 세이비어 초기화와 유사하게 정규 분포와 균등 분포 두 가지 경우로 나뉩니다. 다만, He 초기화는 세이비어 초기화와 다르게 다음 층의 뉴런의 수를 반영하지 않습니다. 전과 같이 이전 층의 뉴런의 개수를 i이라고 해봅시다. He 초기화는 균등 분포로 초기화할 경우에는 다음과 같은 균등 분포 범위를 가지도록 합니다. ∼ n f r ( 6 i , + n n ) 정규 분포로 초기화할 경우에는 표준 편차 σ가 다음을 만족하도록 합니다. = n n 시그모이드 함수나 하이퍼볼릭탄젠트 함수를 사용할 경우에는 세이비어 초기화 방법이 효율적입니다. ReLU 계열 함수를 사용할 경우에는 He 초기화 방법이 효율적입니다. ReLU + He 초기화 방법이 좀 더 보편적입니다. 4. 배치 정규화(Batch Normalization) ReLU 계열의 함수와 He 초기화를 사용하는 것만으로도 어느 정도 기울기 소실과 폭주를 완화시킬 수 있지만, 이 두 방법을 사용하더라도 훈련 중에 언제든 다시 발생할 수 있습니다. 기울기 소실이나 폭주를 예방하는 또 다른 방법은 배치 정규화(Batch Normalization)입니다. 배치 정규화는 인공 신경망의 각 층에 들어가는 입력을 평균과 분산으로 정규화하여 학습을 효율적으로 만듭니다. 1) 내부 공변량 변화(Internal Covariate Shift) 배치 정규화를 이해하기 위해서는 내부 공변량 변화(Internal Covariate Shift)를 이해할 필요가 있습니다. 내부 공변량 변화란 학습 과정에서 층 별로 입력 데이터 분포가 달라지는 현상을 말합니다. 이전 층들의 학습에 의해 이전 층의 가중치 값이 바뀌게 되면, 현재 층에 전달되는 입력 데이터의 분포가 현재 층이 학습했던 시점의 분포와 차이가 발생합니다. 배치 정규화를 제안한 논문에서는 기울기 소실/폭주 등의 딥 러닝 모델의 불안전성이 층마다 입력의 분포가 달라지기 때문이라고 주장합니다. (배치 정규화를 제안한 논문에서는 이렇게 주장했지만, 뒤에 이어서는 이에 대한 반박들이 나오기는 했습니다. 하지만 그 이유가 어찌 되었든 배치 정규화가 학습을 돕는다는 것은 명백합니다.) 공변량 변화는 훈련 데이터의 분포와 테스트 데이터의 분포가 다른 경우를 의미합니다. 내부 공변량 변화는 신경망 층 사이에서 발생하는 입력 데이터의 분포 변화를 의미합니다. 2) 배치 정규화(Batch Normalization) 배치 정규화(Batch Normalization)는 표현 그대로 한 번에 들어오는 배치 단위로 정규화하는 것을 말합니다. 배치 정규화는 각 층에서 활성화 함수를 통과하기 전에 수행됩니다. 배치 정규화를 요약하면 다음과 같습니다. 입력에 대해 평균을 0으로 만들고, 정규화를 합니다. 그리고 정규화 된 데이터에 대해서 스케일과 시프트를 수행합니다. 이때 두 개의 매개변수 γ와 β를 사용하는데, γ는 스케일을 위해 사용하고, β는 시프트를 하는 것에 사용하며 다음 레이어에 일정한 범위의 값들만 전달되게 합니다. 배치 정규화의 수식은 다음과 같습니다. 아래에서 N 은 배치 정규화를 의미합니다. Input : 미니 배치 = { ( ) x ( ) . . x ( ) } Output : ( ) B γ β ( ( ) ) 미니 배치에 대한 평균 계산 B 1 ∑ = m ( ) # 미니 배치에 대한 평균 계산 미니 배치에 대한 분산 계산 B ← m i 1 ( ( ) μ) # 미니 배치에 대한 분산 계산 정규화 ^ ( ) x ( ) μ σ 2 ε # 정규화 스케일 조정γ과 시프트β를 통한 선형연산 ( ) γ ^ ( ) β B γ β ( ( ) ) # 스케일 조정(γ)과 시프트(β)를 통한 선형 연산 은 미니 배치에 있는 샘플의 수 B 는 미니 배치에 대한 평균. B 는 미니 배치에 대한 표준편차. ^ ( ) 은 평균이 0이고 정규화 된 입력 데이터. 은 2 가 0일 때, 분모가 0이 되는 것을 막는 작은 양수. 보편적으로 10 5는 정규화 된 데이터에 대한 스케일 매개변수로 학습 대상 는 정규화 된 데이터에 대한 시프트 매개변수로 학습 대상 ( ) 는 스케일과 시프트를 통해 조정한 N 의 최종 결과 배치 정규화는 학습 시 배치 단위의 평균과 분산들을 차례대로 받아 이동 평균과 이동 분산을 저장해놓았다가 테스트할 때는 해당 배치의 평균과 분산을 구하지 않고 구해놓았던 평균과 분산으로 정규화를 합니다. 배치 정규화를 사용하면 시그모이드 함수나 하이퍼볼릭탄젠트 함수를 사용하더라도 기울기 소실 문제가 크게 개선됩니다. 가중치 초기화에 훨씬 덜 민감해집니다. 훨씬 큰 학습률을 사용할 수 있어 학습 속도를 개선합니다. 미니 배치마다 평균과 표준편차를 계산하여 사용하므로 훈련 데이터에 일종의 잡음 주입의 부수 효과로 과적합을 방지하는 효과도 냅니다. 다시 말해, 마치 드롭아웃과 비슷한 효과를 냅니다. 물론, 드롭아웃과 함께 사용하는 것이 좋습니다. 배치 정규화는 모델을 복잡하게 하며, 추가 계산을 하는 것이므로 테스트 데이터에 대한 예측 시에 실행 시간이 느려집니다. 그래서 서비스 속도를 고려하는 관점에서는 배치 정규화가 꼭 필요한지 고민이 필요합니다. 배치 정규화의 효과는 굉장하지만 내부 공변량 변화 때문은 아니라는 논문도 있습니다. : https://arxiv.org/pdf/1805.11604.pdf 3) 배치 정규화의 한계 배치 정규화는 뛰어난 방법이지만 몇 가지 한계가 존재합니다. 1. 미니 배치 크기에 의존적이다. 배치 정규화는 너무 작은 배치 크기에서는 잘 동작하지 않을 수 있습니다. 단적으로 배치 크기를 1로 하게 되면 분산은 0이 됩니다. 작은 미니 배치에서는 배치 정규화의 효과가 극단적으로 작용되어 훈련에 악영향을 줄 수 있습니다. 배치 정규화를 적용할 때는 작은 미니 배치보다는 크기가 어느 정도 되는 미니 배치에서 하는 것이 좋습니다. 이처럼 배치 정규화는 배치 크기에 의존적인 면이 있습니다. 2. RNN에 적용하기 어렵다. 뒤에서 배우겠지만, RNN은 각 시점(time step)마다 다른 통계치를 가집니다. 이는 RNN에 배치 정규화를 적용하는 것을 어렵게 만듭니다. RNN에서 배치 정규화를 적용하기 위한 몇 가지 논문이 제시되어 있지만, 여기서는 이를 소개하는 대신 배치 크기에도 의존적이지 않으며, RNN에도 적용하는 것이 수월한 층 정규화(layer normalization)라는 방법을 소개하고자 합니다. 5. 층 정규화(Layer Normalization) 층 정규화를 이해하기에 앞서 배치 정규화를 시각화해보겠습니다. 다음은 이 3이고, 특성의 수가 4일 때의 배치 정규화를 보여줍니다. 미니 배치란 동일한 특성(feature) 개수들을 가진 다수의 샘플들을 의미함을 상기합시다. 반면, 층 정규화는 다음과 같습니다. 07-08 케라스(Keras) 훑어보기 이 책에서는 딥 러닝을 쉽게 할 수 있는 파이썬 라이브러리인 케라스(Keras)를 사용합니다. 케라스는 유저가 손쉽게 딥 러닝을 구현할 수 있도록 도와주는 상위 레벨의 인터페이스로 딥 러닝을 쉽게 구현할 수 있도록 해줍니다. 케라스의 모든 기능들을 열거하는 것만으로도 한 권의 책의 분량이므로 여기서 전부 다룰 수는 없습니다. 가장 좋은 방법은 케라 스나 텐서 플로 공식 문서( https://keras.io/ or https://www.tensorflow.org/guide/keras? hl=ko)를 참고하는 것입니다. 여기서는 대표적으로 사용되는 케라스의 도구들을 이해합니다. 1. 전처리(Preprocessing) Tokenizer() : 토큰화와 정수 인코딩을 위해 사용됩니다. 다음은 훈련 데이터로부터 단어 집합을 생성하고, 해당 단어 집합으로 임의의 문장을 정수 인코딩하는 과정을 보여줍니다. from tensorflow.keras.preprocessing.text import Tokenizer from tensorflow.keras.preprocessing.sequence import pad_sequences tokenizer = Tokenizer() train_text = "The earth is an awesome place live" # 단어 집합 생성 tokenizer.fit_on_texts([train_text]) # 정수 인코딩 sub_text = "The earth is an great place live" sequences = tokenizer.texts_to_sequences([sub_text])[0] print("정수 인코딩 : ",sequences) print("단어 집합 : ",tokenizer.word_index) 정수 인코딩 : [1, 2, 3, 4, 6, 7] 단어 집합 : {'the': 1, 'earth': 2, 'is': 3, 'an': 4, 'awesome': 5, 'place': 6, 'live': 7} 출력 결과를 보면 great는 단어 집합(vocabulary)에 없으므로 출력되지 않습니다. pad_sequence() : 전체 훈련 데이터에서 각 샘플의 길이는 서로 다를 수 있습니다. 또는 각 문서 또는 각 문장은 단어의 수가 제각각입니다. 모델의 입력으로 사용하려면 모든 샘플의 길이를 동일하게 맞추어야 할 때가 있습니다. 이를 자연어 처리에서는 패딩(padding) 작업이라고 하는데, 보통 숫자 0을 넣어서 길이가 다른 샘플들의 길이를 맞춰줍니다. 케라스에서는 pad_sequence()를 사용합니다. pad_sequence()는 정해준 길이보다 길이가 긴 샘플은 값을 일부 자르고, 정해준 길이보다 길이가 짧은 샘플은 값을 0으로 채웁니다. pad_sequences([[1, 2, 3], [3, 4, 5, 6], [7, 8]], maxlen=3, padding='pre') array([[1, 2, 3], [4, 5, 6], [0, 7, 8]], dtype=int32) 첫 번째 인자 = 패딩을 진행할 데이터 maxlen = 모든 데이터에 대해서 정규화 할 길이 padding = 'pre'를 선택하면 앞에 0을 채우고 'post'를 선택하면 뒤에 0을 채움. 2. 워드 임베딩(Word Embedding) 워드 임베딩 챕터에서 다루겠지만, 워드 임베딩이란 텍스트 내의 단어들을 밀집 벡터(dense vector)로 만드는 것을 말합니다. 앞서 배운 개념인 원-핫 벡터와 비교해 봅시다. 원-핫 벡터는 대부분이 0의 값을 가지고, 단 하나의 1의 값을 가지는 벡터이며 벡터의 차원이 대체적으로 크다는 성질을 가졌습니다. Ex) [0 1 0 0 0 0 ... 중략 ... 0 0 0 0 0 0 0] # 차원이 굉장히 크면서 대부분의 값이 0 원-핫 벡터는 단어 집합의 크기만큼 벡터의 차원을 가지며 단어 벡터 간의 유의미한 유사도를 구할 수 없다는 단점이 있습니다. 반면 워드 임베딩으로부터 얻은 임베딩 벡터는 상대적으로 저차원을 가지며 모든 원소의 값이 실수입니다. Ex) [0.1 -1.2 0.8 0.2 1.8] # 상대적으로 저차원이며 실숫값을 가짐 간단히 표로 정리하면 아래와 같습니다. ----- 원-핫 벡터 임베딩 벡터 차원 고차원(단어 집합의 크기) 저차원 다른 표현 대부분의 값이 0이 대부분인 희소 벡터 모든 값이 실수인 밀집 벡터 표현 방법 수동 훈련 데이터로부터 학습함 값의 타입 1과 0 실수 단어를 원-핫 벡터로 만드는 과정을 원-핫 인코딩이라고 한다면, 단어를 밀집 벡터로 만드는 작업을 워드 임베딩(word embedding)이라고 합니다. 밀집 벡터는 워드 임베딩 과정을 통해 나온 결과므로 임베딩 벡터(embedding vector)라고도 합니다. 원-핫 벡터의 차원이 주로 20,000 이상을 넘어가는 것과는 달리 임베딩 벡터는 주로 256, 512, 1024 등의 차원을 가집니다. 임베딩 벡터는 초기에는 랜덤 값을 가지지만, 인공 신경망의 가중치가 학습되는 방법과 같은 방식으로 값이 학습되며 변경됩니다. Embedding() : Embedding()은 단어를 밀집 벡터로 만드는 역할을 합니다. 인공 신경망 용어로는 임베딩 층(embedding layer)을 만드는 역할을 합니다. Embedding()은 정수 인코딩이 된 단어들을 입력을 받아서 임베딩을 수행합니다. Embedding()은 (number of samples, input_length)인 2D 정수 텐서를 입력받습니다. 이때 각 sample은 정수 인코딩이 된 결과로, 정수의 시퀀스입니다. Embedding()은 워드 임베딩 작업을 수행하고 (number of samples, input_length, embedding word dimensionality)인 3D 텐서를 리턴합니다. 아래의 코드는 실제 동작되는 코드가 아니라 의사 코드(pseudo-code)로 임베딩의 개념 이해를 돕기 위해서 작성되었습니다. # 1. 토큰화 tokenized_text = [['Hope', 'to', 'see', 'you', 'soon'], ['Nice', 'to', 'see', 'you', 'again']] # 2. 각 단어에 대한 정수 인코딩 encoded_text = [[0, 1, 2, 3, 4],[5, 1, 2, 3, 6]] # 3. 위 정수 인코딩 데이터가 아래의 임베딩 층의 입력이 된다. vocab_size = 7 embedding_dim = 2 Embedding(vocab_size, embedding_dim, input_length=5) # 각 정수는 아래의 테이블의 인덱스로 사용되며 Embedding()은 각 단어마다 임베딩 벡터를 리턴한다. +------------+------------+ | index | embedding | +------------+------------+ | 0 | [1.2, 3.1] | | 1 | [0.1, 4.2] | | 2 | [1.0, 3.1] | | 3 | [0.3, 2.1] | | 4 | [2.2, 1.4] | | 5 | [0.7, 1.7] | | 6 | [4.1, 2.0] | +------------+------------+ # 위의 표는 임베딩 벡터가 된 결과를 예로서 정리한 것이고 Embedding()의 출력인 3D 텐서를 보여주는 것이 아님. Embedding()의 대표적인 인자는 다음과 같습니다. 첫 번째 인자 = 단어 집합의 크기. 즉, 총 단어의 개수 두 번째 인자 = 임베딩 벡터의 출력 차원. 결과로서 나오는 임베딩 벡터의 크기 input_length = 입력 시퀀스의 길이 3. 모델링(Modeling) Sequential() : 인공 신경망 챕터에서 입력층, 은닉층, 출력층에 대해서 배웠습니다. 케라스에서는 이러한 층을 구성하기 위해 Sequential()을 사용합니다. Sequential()을 model로 선언한 뒤에 model.add()라는 코드를 통해 층을 단계적으로 추가합니다. 아래는 model.add()로 층을 추가하는 예제 코드를 보여줍니다. 실제로는 세 개의 온점 대신에 층의 이름을 기재해야 합니다. from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense model = Sequential() model.add(...) # 층 추가 model.add(...) # 층 추가 model.add(...) # 층 추가 Embedding()을 통해 생성하는 임베딩 층(embedding layer)을 추가하는 예시를 봅시다. model = Sequential() model.add(Embedding(vocab_size, output_dim, input_length)) 전결합층(fully-connected layer)을 추가하는 예시를 보겠습니다. model = Sequential() model.add(Dense(1, input_dim=3, activation='relu')) 위의 코드에서 Dense()는 한번 사용되었지만 더 많은 층을 추가할 수 있습니다. Dense()의 대표적인 인자를 보겠습니다. 첫 번째 인자 = 출력 뉴런의 수. input_dim = 입력 뉴런의 수. (입력의 차원) activation = 활성화 함수. - linear : 디폴트 값으로 별도 활성화 함수 없이 입력 뉴런과 가중치의 계산 결과 그대로 출력. - sigmoid : 이진 분류 문제에서 출력층에 주로 사용되는 활성화 함수. - softmax : 셋 이상의 선택지 중 하나를 택하는 다중 클래스 분류 문제에서 출력층에 주로 사용되는 활성화 함수. - relu : 은닉층에 주로 사용되는 활성화 함수. 위 코드에서 사용된 Dense()의 의미를 보겠습니다. 첫 번째 인자의 값은 1인데 이는 총 1개의 출력 뉴런을 의미합니다. Dense()의 두 번째 인자인 input_dim은 입력층의 뉴런 수를 의미합니다. 이 경우에는 3입니다. 3개의 입력층 뉴런과 1개의 출력층 뉴런을 만들었습니다. 이를 시각화하면 다음과 같습니다. Dense()를 사용하여 전결합층을 하나 더 추가해 보겠습니다. model = Sequential() model.add(Dense(8, input_dim=4, activation='relu')) model.add(Dense(1, activation='sigmoid')) # 출력층 이번에는 Dense()가 두 번 사용되었습니다. Dense()가 처음 사용되었을 때와 추가로 사용되었을 때의 인자는 조금 다릅니다. 첫 번째 사용된 Dense()의 8이라는 값은 더 이상 출력층의 뉴런이 아니라 은닉층의 뉴런입니다. 층이 하나 더 생겼기 때문입니다. 두 번째 Dense()는 input_dim 인자가 없는데, 이는 이미 이전 층의 뉴런 수가 8개임을 알고 있기 때문입니다. 위 코드에서 두 번째 Dense()는 마지막 층이므로, 첫 번째 인자 1은 결국 출력층의 뉴런 개수가 됩니다. 이를 시각화하면 다음과 같습니다. 이 외에도 LSTM, GRU, Convolution2D, BatchNormalization 등 다양한 층을 만들 수 있습니다. 일부는 뒤에서 배웁니다. summary() : 모델의 정보를 요약해서 보여줍니다. model.summary() _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= dense_1 (Dense) (None, 8) 40 _________________________________________________________________ dense_2 (Dense) (None, 1) 9 ================================================================= Total params: 49 Trainable params: 49 Non-trainable params: 0 _________________________________________________________________ 4. 컴파일(Compile)과 훈련(Training) 아래의 코드는 RNN을 이용하여 이진 분류를 하는 전형적인 코드를 보여줍니다. RNN은 다음 챕터에서 학습합니다. 임베딩층, 은닉층, 출력층을 추가하여 모델을 설계한 후에, 마지막으로 컴파일을 합니다. compile() : 모델을 기계가 이해할 수 있도록 컴파일 합니다. 손실 함수와 옵티마이저, 메트릭 함수를 선택합니다. from tensorflow.keras.layers import SimpleRNN, Embedding, Dense from tensorflow.keras.models import Sequential vocab_size = 10000 embedding_dim = 32 hidden_units = 32 model = Sequential() model.add(Embedding(vocab_size, embedding_dim)) model.add(SimpleRNN(hidden_units)) model.add(Dense(1, activation='sigmoid')) model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc']) optimizer = 훈련 과정을 설정하는 옵티마이저를 설정합니다. loss = 훈련 과정에서 사용할 손실 함수(loss function)를 설정합니다. metrics = 훈련을 모니터링하기 위한 지표를 선택합니다. 대표적으로 사용되는 손실 함수와 활성화 함수의 조합은 다음과 같습니다. 더 많은 함수는 공식 문서를 참고 바랍니다. 문제 유형 손실 함수명 출력층의 활성화 함수명 참고 실습 회귀 문제 mean_squared_error - 선형 회귀 실습 다중 클래스 분류 categorical_crossentropy 소프트맥스 로이터 뉴스 분류하기 다중 클래스 분류 sparse_categorical_crossentropy 소프트맥스 양방향 LSTM를 이용한 품사 태깅 이진 분류 binary_crossentropy 시그모이드 IMDB 리뷰 감성 분류하기 sparse_categorical_crossentropy는 categorical_crossentropy와 동일하게 다중 클래스 분류에서 사용하지만, 레이블을 원-핫 인코딩하지 않고 정수 인코딩 된 상태에서 수행 가능하다는 점이 다릅니다. fit() : 모델을 학습합니다. 모델이 오차로부터 매개 변수를 업데이트하는 과정을 학습, 훈련, 또는 적합(fitting)이라고 하는데, 모델이 데이터에 적합해가는 과정이기 때문입니다. 그런 의미에서 fit()은 모델의 훈련을 시작합니다. # 위의 compile() 코드의 연장선상인 코드 model.fit(X_train, y_train, epochs=10, batch_size=32) 첫 번째 인자 = 훈련 데이터에 해당됩니다. 두 번째 인자 = 지도 학습에서 레이블 데이터에 해당됩니다. epochs = 에포크. 에포크 1은 전체 데이터를 한차례 훑고 지나갔음을 의미함. 정숫값 기재 필요. 총 훈련 횟수를 정의합니다. batch_size = 배치 크기. 기본값은 32. 미니 배치 경사 하강법을 사용하고 싶지 않을 경우에는 batch_size=None을 기재합니다. 좀 더 많은 인자를 사용할 때를 보겠습니다. model.fit(X_train, y_train, epochs=10, batch_size=32, verbose=0, validation_data(X_val, y_val)) validation_data(x_val, y_val) = 검증 데이터(validation data)를 사용합니다. 일반적으로 검증 데이터를 사용하면 각 에포크마다 검증 데이터의 정확도나 오차를 함께 출력하는데, 이 정확도는 훈련이 잘 되고 있는지를 보여줄 뿐이며 실제로 모델이 검증 데이터를 학습하지는 않습니다. 검증 데이터의 오차(loss)가 낮아지다가 높아지기 시작하면 이는 과 적합(overfitting)의 신호입니다. validation_split = validation_data와 동일하게 검증 데이터를 사용하기 위한 용도로 validation_data 대신 사용할 수 있습니다. 검증 데이터를 지정하는 것이 아니라 훈련 데이터와 훈련 데이터의 레이블인 X_train과 y_train에서 일정 비율 분리하여 이를 검증 데이터로 사용합니다. # 훈련 데이터의 20%를 검증 데이터로 사용. model.fit(X_train, y_train, epochs=10, batch_size=32, verbose=0, validation_split=0.2)) verbose = 학습 중 출력되는 문구를 설정합니다. - 0 : 아무것도 출력하지 않습니다. - 1 : 훈련의 진행도를 보여주는 진행 막대를 보여줍니다. - 2 : 미니 배치마다 손실 정보를 출력합니다. 아래는 verbose의 값이 1일 때와 2일 때를 보여줍니다. # verbose = 1일 경우. Epoch 88/100 7/7 [==============================] - 0s 143us/step - loss: 0.1029 - acc: 1.0000 # verbose = 2일 경우. Epoch 88/100 - 0s - loss: 0.1475 - acc: 1.0000 5. 평가(Evaluation)와 예측(Prediction) evaluate() : 테스트 데이터를 통해 학습한 모델에 대한 정확도를 평가합니다. # 위의 fit() 코드의 연장선상인 코드 model.evaluate(X_test, y_test, batch_size=32) 첫 번째 인자 = 테스트 데이터에 해당됩니다. 두 번째 인자 = 지도 학습에서 레이블 테스트 데이터에 해당됩니다. batch_size = 배치 크기. predict() : 임의의 입력에 대한 모델의 출력값을 확인합니다. # 위의 fit() 코드의 연장선상인 코드 model.predict(X_input, batch_size=32) 첫 번째 인자 = 예측하고자 하는 데이터. batch_size = 배치 크기. 6. 모델의 저장(Save)과 로드(Load) 복습을 위한 스터디나 실제 애플리케이션 개발 단계에서 구현한 모델을 저장하고 불러오는 일은 중요합니다. 모델을 저장한다는 것은 학습이 끝난 신경망의 구조를 보존하고 계속해서 사용할 수 있다는 의미입니다. save() : 인공 신경망 모델을 hdf5 파일에 저장합니다. model.save("model_name.h5") load_model() : 저장해둔 모델을 불러옵니다. from tensorflow.keras.models import load_model model = load_model("model_name.h5") 07-09 케라스의 함수형 API(Keras Functional API) 앞서 구현한 선형, 로지스틱, 소프트맥스 회귀 모델들과 케라스 훑어보기 실습에서 배운 케라스의 모델 설계 방식은 Sequential API을 사용한 것입니다. 그런데 Sequential API는 여러 층을<NAME>거나 다양한 종류의 입력과 출력을 사용하는 등의 복잡한 모델을 만드는 일에는 한계가 있습니다. 이번에는 더욱 복잡한 모델을 생성할 수 있는 방식인 Functional API(함수형 API)에 대해서 알아봅니다. Functional API에 대한 자세한 소개는 케라스 공식 문서에서도 확인할 수 있습니다. 링크 : https://keras.io/getting-started/functional-api-guide/ 1. Sequential API로 만든 모델 두 가지 API의 차이를 이해하기 위해서 앞서 배운 Sequential API를 사용하여 기본적인 모델을 만들어봅시다. from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense model = Sequential() model.add(Dense(3, input_dim=4, activation='softmax')) 위와 같은 방식은 직관적이고 편리하지만 단순히 층을 쌓는 것만으로는 구현할 수 없는 복잡한 신경망을 구현할 수 없습니다. 따라서 초심자에게 적합한 API이지만, 전문가가 되기 위해서는 결과적으로 Functional API를 학습해야 합니다. 2. Functional API로 만든 모델 Functional API는 각 층을 일종의 함수(function)로서 정의합니다. 그리고 각 함수를 조합하기 위한 연산자들을 제공하는데, 이를 이용하여 신경망을 설계합니다. Functional API로 FFNN, RNN 등 다양한 모델을 만들면서 기존의 sequential API와의 차이를 이해해 봅시다. Functional API는 입력의 크기(shape)를 명시한 입력층(Input layer)을 모델의 앞단에 정의해 주어야 합니다. 1) 전 결합 피드 포워드 신경망(Fully-connected FFNN) Sequential API와는 다르게 functional API에서는 입력 데이터의 크기(shape)를 인자로 입력층을 정의해 주어야 합니다. 피드 포워드 신경망(Fully-connected FFNN)을 만든다고 가정해 보겠습니다. from tensorflow.keras.layers import Input, Dense from tensorflow.keras.models import Model inputs = Input(shape=(10, )) 위의 코드는 10개의 입력을 받는 입력층을 보여줍니다. 위의 코드에 은닉층과 출력층을 추가해 봅시다. inputs = Input(shape=(10, )) hidden1 = Dense(64, activation='relu')(inputs) # <- 새로 추가 hidden2 = Dense(64, activation='relu')(hidden1) # <- 새로 추가 output = Dense(1, activation='sigmoid')(hidden2) # <- 새로 추가 위의 코드를 하나의 모델로 구성해 보겠습니다. 이는 Model에 입력 텐서와 출력 텐서를 정의하여 완성됩니다. inputs = Input(shape=(10, )) hidden1 = Dense(64, activation='relu')(inputs) hidden2 = Dense(64, activation='relu')(hidden1) output = Dense(1, activation='sigmoid')(hidden2) model = Model(inputs=inputs, outputs=output) # <- 새로 추가 지금까지의 내용을 정리하면 다음과 같습니다. Input() 함수에 입력의 크기를 정의합니다. 이전층을 다음층 함수의 입력으로 사용하고, 변수에 할당합니다. Model() 함수에 입력과 출력을 정의합니다. 이를 model로 저장하면 sequential API를 사용할 때와 마찬가지로 model.compile, model.fit 등을 사용 가능합니다. model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) # model.fit(data, labels) 이번에는 변수명을 달리해서 FFNN을 만들어보겠습니다. 이번에는 은닉층과 출력층의 변수를 전부 x로 통일하였습니다. inputs = Input(shape=(10, )) x = Dense(8, activation="relu")(inputs) x = Dense(4, activation="relu")(x) x = Dense(1, activation="linear")(x) model = Model(inputs, x) 이번에는 위에서 배운 내용을 바탕으로 선형 회귀와 로지스틱 회귀를 Functional API로 구현해 봅시다. 2) 선형 회귀(Linear Regression) 앞서 ( https://wikidocs.net/111472 ) Sequential API로 구현했던 선형 회귀를 Functional API로 구현해 봅시다. from tensorflow.keras.layers import Input, Dense from tensorflow.keras import optimizers from tensorflow.keras.models import Model X = [1, 2, 3, 4, 5, 6, 7, 8, 9] # 공부하는 시간 y = [11, 22, 33, 44, 53, 66, 77, 87, 95] # 각 공부 하는 시간에 매핑되는 성적 inputs = Input(shape=(1, )) output = Dense(1, activation='linear')(inputs) linear_model = Model(inputs, output) sgd = optimizers.SGD(lr=0.01) linear_model.compile(optimizer=sgd, loss='mse', metrics=['mse']) linear_model.fit(X, y, epochs=300) 그 외에 다양한 다른 예제들을 구현해 봅시다. 3) 로지스틱 회귀(Logistic Regression) from tensorflow.keras.layers import Input, Dense from tensorflow.keras.models import Model inputs = Input(shape=(3, )) output = Dense(1, activation='sigmoid')(inputs) logistic_model = Model(inputs, output) 4) 다중 입력을 받는 모델(model that accepts multiple inputs) functional API를 사용하면 아래와 같이 다중 입력과 다중 출력을 가지는 모델도 만들 수 있습니다. # 최종 완성된 다중 입력, 다중 출력 모델의 예 model = Model(inputs=[a1, a2], outputs=[b1, b2, b3]) 이번에는 다중 입력을 받는 모델을 입력층부터 출력층까지 설계해 보겠습니다. from tensorflow.keras.layers import Input, Dense, concatenate from tensorflow.keras.models import Model # 두 개의 입력층을 정의 inputA = Input(shape=(64, )) inputB = Input(shape=(128, )) # 첫 번째 입력층으로부터 분기되어 진행되는 인공 신경망을 정의 x = Dense(16, activation="relu")(inputA) x = Dense(8, activation="relu")(x) x = Model(inputs=inputA, outputs=x) # 두 번째 입력층으로부터 분기되어 진행되는 인공 신경망을 정의 y = Dense(64, activation="relu")(inputB) y = Dense(32, activation="relu")(y) y = Dense(8, activation="relu")(y) y = Model(inputs=inputB, outputs=y) # 두 개의 인공 신경망의 출력을 연결(concatenate) result = concatenate([x.output, y.output]) z = Dense(2, activation="relu")(result) z = Dense(1, activation="linear")(z) model = Model(inputs=[x.input, y.input], outputs=z) 위 모델은 두 개의 입력층으로부터 분기되어 진행된 후 마지막에는 하나의 출력을 예측하는 모델입니다. 5) RNN(Recurrence Neural Network) 은닉층 사용하기 이번에는 RNN 은닉층을 가지는 모델을 설계해 봅시다. 여기서는 하나의 특성(feature)에 50개의 시점(time-step)을 입력으로 받는 모델을 설계해 보겠습니다. RNN에 대한 구체적인 내용은 다음 챕터인 RNN 챕터에서 배웁니다. from tensorflow.keras.layers import Input, Dense, LSTM from tensorflow.keras.models import Model inputs = Input(shape=(50,1)) lstm_layer = LSTM(10)(inputs) x = Dense(10, activation='relu')(lstm_layer) output = Dense(1, activation='sigmoid')(x) model = Model(inputs=inputs, outputs=output) 다수의 입력과 다수의 출력을 가지는 좀 더 다양한 예제는 앞서 소개한 케라스 공식 문서에서 확인할 수 있습니다. 6) 다르게 보이지만 동일한 표기 케라스의 Functional API가 익숙하지 않은 상태에서 Functional API를 사용한 코드를 보다가 혼동할 수 있는 점이 한 가지 있습니다. 바로 동일한 의미를 가지지만, 하나의 줄로 표현할 수 있는 코드를 두 개의 줄로 표현한 경우입니다. result = Dense(128)(input) 위 코드는 아래와 같이 두 개의 줄로 표현할 수 있습니다. dense = Dense(128) result = dense(input) 07-10 케라스 서브클래싱 API(Keras Subclassing API) 케라스의 구현 방식에는 Sequential API, Functional API 외에도 Subclassing API라는 구현 방식이 존재합니다. 1. 서브클래싱 API로 구현한 선형 회귀 앞서 ( https://wikidocs.net/111472 )에서 Sequential API로 구현했던 선형 회귀를 Subclassing API로 구현한다면 다음과 같습니다. import tensorflow as tf class LinearRegression(tf.keras.Model): def __init__(self): super(LinearRegression, self).__init__() self.linear_layer = tf.keras.layers.Dense(1, input_dim=1, activation='linear') def call(self, x): y_pred = self.linear_layer(x) return y_pred model = LinearRegression() X = [1, 2, 3, 4, 5, 6, 7, 8, 9] # 공부하는 시간 y = [11, 22, 33, 44, 53, 66, 77, 87, 95] # 각 공부 하는 시간에 맵핑되는 성적 sgd = tf.keras.optimizers.SGD(lr=0.01) model.compile(optimizer=sgd, loss='mse', metrics=['mse']) model.fit(X, y, epochs=300) 클래스(class) 형태의 모델은 tf.keras.Model을 상속받습니다. 그리고 init()에서 모델의 구조와 동적을 정의하는 생성자를 정의합니다. 이는 파이썬에서 객체가 갖는 속성값을 초기화하는 역할로, 객체가 생성될 때 자동으호 호출됩니다. super() 함수를 부르면 여기서 만든 클래스는 tf.keras.Model 클래스의 속성들을 가지고 초기화됩니다. call() 함수는 모델이 데이터를 입력받아 예측값을 리턴하는 포워드(forward) 연산을 진행시키는 함수입니다. ( ) 식에 입력 로부터 예측된 를 얻는 것을 forward 연산이라고 합니다. 2. 언제 서브클래싱 API를 써야 할까? Sequential API는 간단한 모델을 구현하기에 적합합니다. Functional API로는 Sequential API로 구현할 수 없는 복잡한 모델들을 구현 가능합니다. 그런데 Subclassing API로는 Functional API가 구현할 수 없는 모델들조차 구현할 수 있는 경우가 있습니다. Functional API는 기본적으로 딥 러닝 모델을 DAG(directed acyclic graph)로 취급합니다. 실제로 대부분의 딥 러닝 모델이 이에 속하기는 하지만, 항상 그렇지는 않습니다. 예를 들어서 재귀 네트워크나 트리 RNN은 이 가정을 따르지 않으며 Functional API에서 구현할 수 없습니다. 이를 반대로 해석하면 대부분의 딥 러닝 모델은 Functional API 수준에서도 전부 구현이 가능하다는 의미이기도 합니다. 그래서 Subclassing API는 밑바닥부터 새로운 수준의 아키텍처를 구현해야 하는 실험적 연구를 하는 연구자들에게 적합합니다. 3. 세 가지 구현 방식 비교. 1) Sequential API 장점 : 단순하게 층을 쌓는 방식으로 쉽고 사용하기가 간단합니다. 단점 : 다수의 입력(multi-input), 다수의 출력(multi-output)을 가진 모델 또는 층 간의 연결(concatenate)이나 덧셈(Add)과 같은 연산을 하는 모델을 구현하기에는 적합하지 않습니다. 이런 모델들의 구현은 Functional API를 사용해야 합니다. 2) Functional API 장점 : Sequential API로는 구현하기 어려운 복잡한 모델들을 구현할 수 있습니다. 단점 : 입력의 크기(shape)를 명시한 입력층(Input layer)을 모델의 앞단에 정의해 주어야 합니다. 가령, 아래의 코드를 봅시다. # 선형 회귀 구현 코드의 일부 발췌 inputs = Input(shape=(1, )) # <-- 해당 부분 output = Dense(1, activation='linear')(inputs) linear_model = Model(inputs, output) sgd = optimizers.SGD(lr=0.01) linear_model.compile(optimizer=sgd, loss='mse', metrics=['mse']) linear_model.fit(X, y, epochs=300) 3) Subclassing API 장점 : Functional API로도 구현할 수 없는 모델들조차 구현이 가능합니다. 단점 : 객체 지향 프로그래밍(Object-oriented programming)에 익숙해야 하므로 코드 사용이 가장 까다롭습니다. 07-11 다층 퍼셉트론(MultiLayer Perceptron, MLP)으로 텍스트 분류하기 다층 퍼셉트론(Multilayer Perceptron, MLP)으로 텍스트 분류를 수행합니다. 1. 다층 퍼셉트론(MultiLayer Perceptron, MLP) 앞서 단층 퍼셉트론의 형태에서 은닉층이 1개 이상 추가된 신경망을 다층 퍼셉트론(MLP)이라고 한다고 배웠습니다. 다층 퍼셉트론은 피드 포워드 신경망(Feed Forward Neural Network, FFNN)의 가장 기본적인 형태입니다. 피드 포워드 신경망은 입력층에서 출력층으로 오직 한 방향으로만 연산 방향이 정해져 있는 신경망을 말합니다. 뒤에서는 순환 신경망(RNN)과 분산 표현(distributed representation)이라는 새로운 개념들을 사용하여 각종 자연어 처리 실습을 하게 될 텐데, 이번 실습의 목적은 위 두 가지 개념 없이 지금까지 배운 개념만으로도 자연어 처리를 할 수 있다는 것을 보여주기 위함입니다. 2. 케라스의 texts_to_matrix() 이해하기 MLP로 텍스트 분류를 수행하기 전에 이번에 사용할 도구인 케라스 Tokenizer의 texts_to_matrix()를 이해해 봅시다. import numpy as np from tensorflow.keras.preprocessing.text import Tokenizer 우선 케라스의 전처리 도구인 Tokenizer를 임포트 합니다. texts = ['먹고 싶은 사과', '먹고 싶은 바나나', '길고 노란 바나나 바나나', '저는 과일이 좋아요'] 위 텍스트 데이터에 대해서 정수 인코딩을 수행합니다. tokenizer = Tokenizer() tokenizer.fit_on_texts(texts) print(tokenizer.word_index) {'바나나': 1, '먹고': 2, '싶은': 3, '사과': 4, '길고': 5, '노란': 6, '저는': 7, '과일이': 8, '좋아요': 9} 각 단어에 숫자 1부터 시작하는 정수 인덱스가 부여되었습니다. 텍스트 데이터에 texts_to_matrix()를 사용해 보겠습니다. texts_to_matrix()란 이름에서 알 수 있지만, 이 도구는 입력된 텍스트 데이터로부터 행렬(matrix)를 만드는 도구입니다. texts_to_matrx()는 총 4개의 모드를 지원하는데 각 모드는 'binary', 'count', 'freq', 'tfidf'로 총 4개입니다. 우선 'count' 모드를 사용해 봅시다. print(tokenizer.texts_to_matrix(texts, mode = 'count')) # texts_to_matrix의 입력으로 texts를 넣고, 모드는 'count' [[0. 0. 1. 1. 1. 0. 0. 0. 0. 0.] [0. 1. 1. 1. 0. 0. 0. 0. 0. 0.] [0. 2. 0. 0. 0. 1. 1. 0. 0. 0.] [0. 0. 0. 0. 0. 0. 0. 1. 1. 1.]] 위의 경우는 총 4개의 모드 중에서 'count' 모드를 사용했을 경우입니다. 'count'를 사용하면 우리가 앞서 배운 문서 단어 행렬(Document-Term Matrix, DTM)을 생성합니다. DTM에서의 인덱스는 앞서 확인한 word_index의 결과입니다. 다만 주의할 점은 각 단어에 부여되는 인덱스는 1부터 시작하는 반면에 완성되는 행렬의 인덱스는 0부터 시작합니다. 실제로 단어의 개수는 9개였지만 완성된 행렬의 열의 개수는 10개인 것과 첫 번째 열은 모든 행에서 값이 0인 것을 볼 수 있습니다. 인덱스 0에는 그 어떤 단어도 할당되지 않았기 때문입니다. 우선, 네 번째 행을 보겠습니다. 네 번째 행은 테스트 데이터에서 네 번째 문장을 의미합니다. 네 번째 행은 8번째 열, 9번째 열, 10번째 열에서 1의 값을 가집니다. 이는 7번 단어, 8번 단어, 9번 단어가 네 번째 문장에서 1개씩 존재함을 의미합니다. 위에서 정수 인코딩 된 결과를 보면 7번 단어는 '저는', 8번 단어는 '과일이', 9번 단어는 '좋아요'입니다. 세 번째 행의 첫 번째 열의 값은 2인데, 이는 세 번째 문장에서 1번 인덱스를 가진 바나나가 두 번 등장했기 때문입니다. 앞서 배웠듯이 DTM은 bag of words를 기반으로 하므로 단어 순서 정보는 보존되지 않습니다. 사실 더 구체적으로는 4개의 모든 모드에서 단어 순서 정보는 보존되지 않습니다. 'binary' 모드를 보겠습니다. print(tokenizer.texts_to_matrix(texts, mode = 'binary')) [[0. 0. 1. 1. 1. 0. 0. 0. 0. 0.] [0. 1. 1. 1. 0. 0. 0. 0. 0. 0.] [0. 1. 0. 0. 0. 1. 1. 0. 0. 0.] [0. 0. 0. 0. 0. 0. 0. 1. 1. 1.]] DTM과 결과가 매우 유사해 보입니다. 다만 세 번째 행, 두 번째 열의 값이 DTM에서는 2였는데 여기서는 1로 바뀌었습니다. 그 이유는 'binary' 모드는 해당 단어가 존재하는지만 관심을 가지고 해당 단어가 몇 개였는지는 무시하기 때문입니다. 해당 단어가 존재하면 1, 단어가 존재하지 않으면 0의 값을 가집니다. 즉, 단어의 존재 유무로만 행렬을 표현합니다. 'tfidf' 모드를 보겠습니다. print(tokenizer.texts_to_matrix(texts, mode = 'tfidf').round(2)) # 둘째 자리까지 반올림하여 출력 [[0. 0. 0.85 0.85 1.1 0. 0. 0. 0. 0. ] [0. 0.85 0.85 0.85 0. 0. 0. 0. 0. 0. ] [0. 1.43 0. 0. 0. 1.1 1.1 0. 0. 0. ] [0. 0. 0. 0. 0. 0. 0. 1.1 1.1 1.1 ]] 'tfidf' 모드는 말 그대로 TF-IDF 행렬을 만듭니다. 다만, TF-IDF 실습에서 배운 기본식이나 사이킷런의 TfidfVectorizer에서 사용하는 식이랑 또 조금 다릅니다. 앞서 배운 기본식에서 TF는 각 문서에서의 각 단어의 빈도였다면 'tfidf' 모드에서는 TF를 각 문서에서의 각 단어의 빈도에 자연 로그를 씌우고 1을 더한 값으로 정의했습니다. idf에서는 앞서 배운 기본식에서 로그는 자연 로그를 사용하고, 로그 안의 분수에 1을 추가로 더했습니다. 물론, 이러한 식을 굳이 기억할 필요는 없고 여전히 TF-IDF의 기존 의도를 갖고 있다고 이해하면 됩니다. print(tokenizer.texts_to_matrix(texts, mode = 'freq').round(2)) # 둘째 자리까지 반올림하여 출력 [[0. 0. 0.33 0.33 0.33 0. 0. 0. 0. 0. ] [0. 0.33 0.33 0.33 0. 0. 0. 0. 0. 0. ] [0. 0.5 0. 0. 0. 0.25 0.25 0. 0. 0. ] [0. 0. 0. 0. 0. 0. 0. 0.33 0.33 0.33]] 마지막으로 'freq' 모드입니다. 'freq' 모드는 각 문서에서의 각 단어의 등장 횟수를 분자로, 각 문서의 크기(각 문서에서 등장한 모든 단어의 개수의 총합)를 분모로 하는 표현 방법입니다. 예를 들어 세 번째 행을 보겠습니다. 세 번째 문장은 '길고 노란 바나나 바나나'였습니다. 문서의 크기는 4인데, 바나나는 총 2회 등장했습니다. 이에 따라서 세 번째 문장에서의 단어 '바나나'의 값은 위의 행렬에서 0.5가 됩니다. 반면에 '길고', '노란'이라는 두 단어는 각 1회 등장했으므로 각자 1/4의 값인 0.25의 값을 가집니다. 3. 20개 뉴스 그룹(Twenty Newsgroups) 데이터에 대한 이해 import pandas as pd from sklearn.datasets import fetch_20newsgroups import matplotlib.pyplot as plt from tensorflow.keras.preprocessing.text import Tokenizer from tensorflow.keras.utils import to_categorical 사이킷런에서는 20개의 다른 주제를 가진 18,846개의 뉴스 그룹 이메일 데이터를 제공합니다. newsdata = fetch_20newsgroups(subset = 'train') # 'train'을 기재하면 훈련 데이터만 리턴한다. 위의 subset의 값으로 'all'을 넣으면 전체 데이터인 18,846개의 샘플을 다운로드할 수 있으며, 'train'을 넣으면 훈련 데이터를, 'test'를 넣으면 테스트 데이터를 다운로드할 수 있습니다. newsdata.keys()를 출력하면 해당 데이터의 속성을 확인할 수 있습니다. print(newsdata.keys()) dict_keys(['data', 'filenames', 'target_names', 'target', 'DESCR']) 해당 데이터는 data, filenames, target_names, target, DESCR, description이라는 6개 속성을 갖고 있습니다. 이 중 실제로 훈련에 사용할 속성은 이메일 본문인 data와 메일이 어떤 주제인지 기재된 숫자 레이블인 target입니다. 우선 훈련용 샘플의 개수를 보겠습니다. print('훈련용 샘플의 개수 : {}'.format(len(newsdata.data))) 훈련용 샘플의 개수 : 11314 훈련 샘플은 11,314개가 존재합니다. target_names에는 20개의 주제의 이름을 담고 있습니다. 어떤 주제가 있는지 확인해 보겠습니다. print('총 주제의 개수 : {}'.format(len(newsdata.target_names))) print(newsdata.target_names) 총 주제의 개수 : 20 ['alt.atheism', 'comp.graphics', 'comp.os.ms-windows.misc', 'comp.sys.ibm.pc.hardware', 'comp.sys.mac.hardware', 'comp.windows.x', 'misc.forsale', 'rec.autos', 'rec.motorcycles', 'rec.sport.baseball', 'rec.sport.hockey', 'sci.crypt', 'sci.electronics', 'sci.med', 'sci.space', 'soc.religion.christian', 'talk.politics.guns', 'talk.politics.mideast', 'talk.politics.misc', 'talk.religion.misc'] 이번 실습의 목적은 테스트 데이터에서 이메일 본문을 보고 20개의 주제 중 어떤 주제인지를 맞추는 것입니다. 레이블인 target에는 총 0부터 19까지의 숫자가 들어가 있는데 첫 번째 샘플의 경우에는 몇 번 주제인지 확인해 보겠습니다. print('첫 번째 샘플의 레이블 : {}'.format(newsdata.target[0])) 첫 번째 샘플의 레이블 : 7 첫 번째 샘플의 레이블의 값은 7입니다. 숫자만으로는 앞서 target_names를 통해 확인한 20개의 주제 중에서 어떤 주제를 의미하는지 알 수가 없습니다. 7이 실제로 어떤 주제를 나타내는지는 target_names[] 안에 숫자를 입력하여 알 수 있습니다. print('7번 레이블이 의미하는 주제 : {}'.format(newsdata.target_names[7])) 7번 레이블이 의미하는 주제 : rec.autos 7번 레이블은 rec.autos라는 주제입니다. 즉, 첫 번째 샘플의 주제는 rec.autos입니다. 첫 번째 샘플의 본문 내용을 확인해 봅시다. print(newsdata.data[0]) # 첫 번째 샘플 출력 From: lerxst@wam.umd.edu (where's my thing) Subject: WHAT car is this!? Nntp-Posting-Host: rac3.wam.umd.edu Organization: University of Maryland, College Park Lines: 15 I was wondering if anyone out there could enlighten me on this car I saw the other day. It was a 2-door sports car, looked to be from the late 60s/ early 70s. It was called a Bricklin. The doors were really small. In addition, the front bumper was separate from the rest of the body. This is all I know. If anyone can tellme a model name, engine specs, years of production, where this car is made, history, or whatever info you have on this funky looking car, please e-mail. Thanks, - IL ---- brought to you by your neighborhood Lerxst ---- 이메일의 내용을 보니 스포츠카에 대한 글로 보입니다. 이 글의 레이블은 7이고, 7번 레이블은 rec.autos란 주제를 의미합니다. 훈련에 사용될 메일 본문인 data와 레이블인 target을 데이터 프레임으로 만들어서 데이터에 대한 통계적인 정보들을 알아보겠습니다. data로부터 데이터 프레임을 생성하고, target 열을 추가한 뒤에 상위 5개의 행을 출력합니다. data = pd.DataFrame(newsdata.data, columns = ['email']) data['target'] = pd.Series(newsdata.target) data[:5] 메일 본문에 해당하는 email 열과 레이블에 해당되는 target 열, 2개의 열로 구성된 데이터 프레임이 생성된 것을 볼 수 있습니다. data.info() <class 'pandas.core.frame.DataFrame'> RangeIndex: 11314 entries, 0 to 11313 Data columns (total 2 columns): news 11314 non-null object target 11314 non-null int32 dtypes: int32(1), object(1) memory usage: 132.7+ KB news 열은 문자열, target 열은 정수형 데이터입니다. 혹시 Null 값을 가진 샘플이 있는지 isnull().values.any()로도 확인 가능합니다. data.isnull().values.any() False False는 데이터에 별도의 Null 값은 없음을 의미합니다. nunique()를 통해 샘플 중 중복을 제거한 개수를 확인할 수 있습니다. print('중복을 제외한 샘플의 수 : {}'.format(data['email'].nunique())) print('중복을 제외한 주제의 수 : {}'.format(data['target'].nunique())) 중복을 제외한 샘플의 수 : 11314 중복을 제외한 주제의 수 : 20 레이블 값의 분포를 시각화해보겠습니다. data['target'].value_counts().plot(kind='bar'); 10번 레이블의 수가 가장 많고, 19번 레이블의 수가 가장 적으며 대체적으로 400 ~ 600개 사이의 분포를 보입니다. 이번에는 각 레이블이 몇 개 있는지 구체적인 수치로 확인해 보겠습니다. print(data.groupby('target').size().reset_index(name='count')) target count 0 0 480 1 1 584 2 2 591 3 3 590 4 4 578 5 5 593 6 6 585 7 7 594 8 8 598 9 9 597 10 10 600 11 11 595 12 12 591 13 13 594 14 14 593 15 15 599 16 16 546 17 17 564 18 18 465 19 19 377 데이터 프레임으로부터 다시 메일 본문과 레이블을 분리하고, 테스트 데이터 또한 불러오겠습니다. subset에 'test'를 기재하면 테스트 데이터를 불러옵니다. 훈련 데이터와 테스트 데이터의 본문과 레이블을 각각 저장합니다. newsdata_test = fetch_20newsgroups(subset='test', shuffle=True) train_email = data['email'] train_label = data['target'] test_email = newsdata_test.data test_label = newsdata_test.target 훈련 데이터와 테스트 데이터가 모두 준비되었습니다. 케라스의 토크 나이저 도구를 사용하여 전처리를 진행해 봅시다. vocab_size = 10000 num_classes = 20 우선 필요한 변수들을 정의합니다. vocab_size는 이번 실습에서 사용할 최대 단어 개수를 정의하는 변수입니다. 뒤에서 케라스 토크 나이저를 사용하면 빈도수 순으로 인덱스를 부여하므로, 빈도수가 가장 높은 상위 vocab_size 개수만큼의 단어를 사용합니다. def prepare_data(train_data, test_data, mode): # 전처리 함수 tokenizer = Tokenizer(num_words = vocab_size) # vocab_size 개수만큼의 단어만 사용한다. tokenizer.fit_on_texts(train_data) X_train = tokenizer.texts_to_matrix(train_data, mode=mode) # 샘플 수 × vocab_size 크기의 행렬 생성 X_test = tokenizer.texts_to_matrix(test_data, mode=mode) # 샘플 수 × vocab_size 크기의 행렬 생성 return X_train, X_test, tokenizer.index_word 케라스 토크 나이저로 전처리를 수행하는 함수인 prepare_data를 만들었습니다. 해당 함수는 케라스 토크 나이저를 통해 단어 토큰화를 수행하고, 앞서 배운 texts_to_matrix()를 사용하여 훈련 데이터와 테스트 데이터를 'binary', 'count', 'tfidf', 'freq' 4개의 모드 중 사용자가 정한 모드로 변환합니다. X_train, X_test, index_to_word = prepare_data(train_email, test_email, 'binary') # binary 모드로 변환 y_train = to_categorical(train_label, num_classes) # 원-핫 인코딩 y_test = to_categorical(test_label, num_classes) # 원-핫 인코딩 메일 본문에 대해서는 'binary' 모드로 변환하고, 훈련 데이터와 테스트 데이터의 레이블은 원-핫 인코딩을 수행하였습니다. print('훈련 샘플 본문의 크기 : {}'.format(X_train.shape)) print('훈련 샘플 레이블의 크기 : {}'.format(y_train.shape)) print('테스트 샘플 본문의 크기 : {}'.format(X_test.shape)) print('테스트 샘플 레이블의 크기 : {}'.format(y_test.shape)) 훈련 샘플 본문의 크기 : (11314, 10000) 훈련 샘플 레이블의 크기 : (11314, 20) 테스트 샘플 본문의 크기 : (7532, 10000) 테스트 샘플 레이블의 크기 : (7532, 20) 훈련 데이터와 테스트 데이터 모두 메일 본문의 크기가 샘플의 수 × 10,000의 행렬로 변환되었는데, 열의 개수가 10,000인 것은 위의 prepard_data 함수 내부에서 Tokenizer의 num_words의 인자로 vocab_size를 지정해 주었기 때문입니다. 사실 단어의 정수 인덱스는 1부터 시작하지만, 행렬의 인덱스는 0부터 시작하여 0번 인덱스는 사용되지 않으므로 실제로 행렬에는 빈도수 기준 상위 9,999개의 단어가 표현된 셈입니다. 빈도수 상위 1번 단어와 9,999번 단어를 확인해 보겠습니다. print('빈도수 상위 1번 단어 : {}'.format(index_to_word[1])) print('빈도수 상위 9999번 단어 : {}'.format(index_to_word[9999])) 빈도수 상위 1번 단어 : the 빈도수 상위 9999번 단어 : mic 불용어에 해당되는 단어 'the'가 빈도수 상위 1번 단어가 된 것을 확인할 수 있습니다. 4. 다층 퍼셉트론(Multilayer Perceptron, MLP)을 사용하여 텍스트 분류하기 모델을 설계해 보겠습니다. 우선 모델 설계에 필요한 도구들을 임포트 합니다. from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Dropout 다층 퍼셉트론을 설계합니다. def fit_and_evaluate(X_train, y_train, X_test, y_test): model = Sequential() model.add(Dense(256, input_shape=(vocab_size,), activation='relu')) model.add(Dropout(0.5)) model.add(Dense(128, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(num_classes, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.fit(X_train, y_train, batch_size=128, epochs=5, verbose=1, validation_split=0.1) score = model.evaluate(X_test, y_test, batch_size=128, verbose=0) return score[1] 모델 설계를 fit_and_evaluate라는 함수 내에 정의하였는데, 모델을 함수 내에 정의한 이유는 이번 실습에서는 입력값을 바꿔가면서 모델을 여러 번 호출하기 위함입니다. 우선은 모델의 아키텍처에 집중해 보겠습니다. 위의 그림은 현재 설계한 신경망의 구조를 보여줍니다. 현재 설계한 다층 퍼셉트론은 총 4개의 층을 가지고 있습니다. vocab_size의 크기를 가진 입력층, 256개의 뉴런을 가진 첫 번째 은닉층, 128개의 뉴런을 가진 두 번째 은닉층, num_classes의 크기를 가진 출력층입니다. 또한 이번에 설계한 다층 퍼셉트론은 은닉층이 2개이므로 깊은 신경망(Deep Neural Network, DNN)입니다. 코드로 돌아가 보겠습니다. 위 모델에서는 과적합을 막기 위해서 두 번의 드롭아웃(Dropout)을 적용하였습니다. 이 문제는 다중 클래스 분류 문제입니다. 여러 개의 선택지 중에서 하나의 선택지를 고르는 문제인데, 이 경우 20개의 주제 중에서 모델은 자신이 정답이라고 생각하는 1개의 주제를 예측해야 합니다. 다중 클래스 분류 문제이므로 출력층의 활성화 함수로는 소프트맥스 함수를 사용하고, 손실 함수로는 크로스 엔트로피(categorical_crossentropy) 함수를 사용하였습니다. 모델을 훈련시켜보겠습니다. 이번에는 앞서 배운 texts_to_matrix()의 4개의 모드에 대해서 전부 모델의 결과를 확인해 보겠습니다. modes = ['binary', 'count', 'tfidf', 'freq'] # 4개의 모드를 리스트에 저장. for mode in modes: # 4개의 모드에 대해서 각각 아래의 작업을 반복한다. X_train, X_test, _ = prepare_data(train_email, test_email, mode) # 모드에 따라서 데이터를 전처리 score = fit_and_evaluate(X_train, y_train, X_test, y_test) # 모델을 훈련하고 평가. print(mode+' 모드의 테스트 정확도:', score) 각 모드에 대해서 총 5회의 에포크를 수행하는 데, 각 모드에 대한 정확도는 다음과 같이 나왔습니다. binary 모드의 테스트 정확도: 0.8312533 count 모드의 테스트 정확도: 0.8239511 tfidf 모드의 테스트 정확도: 0.8381572 freq 모드의 테스트 정확도: 0.6902549 대체적으로 82% ~ 83%의 비슷한 정확도를 보이는데, 'freq' 모드에서만 정확도가 69%가 나왔습니다. 아무래도 'freq' 모드는 이번 문제를 풀기 위한 적절한 전처리 방법이 아니었던 것 같습니다. 07-12 피드 포워드 신경망 언어 모델(Neural Network Language Model, NNLM) 파이썬 등과 같은 프로그래밍 언어를 사용할 때는 명세돼 있는 튜플, 클래스 등과 같은 용어와 작성할 때 지켜야 하는 문법을 바탕으로 코드를 작성합니다. 문법에 맞지 않으면 에러가 발생하므로 명세된 규칙을 지키는 것은 필수적입니다. 자연어는 어떨까요? 자연어에도 문법이라는 규칙이 있기는 하지만, 많은 예외 사항, 시간에 따른 언어의 변화, 중의성과 모호성 문제 등을 전부 명세하기란 어렵습니다. 기계가 자연어를 표현하도록 규칙으로 명세하기가 어려운 상황에서 대안은 규칙 기반 접근이 아닌 기계가 주어진 자연어 데이터를 학습하게 하는 것입니다. 과거에는 기계가 자연어를 학습하게 하는 방법으로 통계적인 접근을 사용했으나, 최근에는 인공 신경망을 사용하는 방법이 자연어 처리에서 더 좋은 성능을 얻고 있습니다. 번역기, 음성 인식 등과 같이 자연어 생성(Natural Language Generation, NLG)의 기반으로 사용되는 언어 모델도 마찬가지입니다. 통계적 언어 모델(Statistical Language Model, SLM)에서 다양한 구조의 인공 신경망을 사용한 언어 모델들로 대체되기 시작했습니다. 여기서는 신경망 언어 모델의 시초인 피드 포워드 신경망 언어 모델(Feed Forward Neural Network Language Model)에 대해서 학습합니다. 여기서는 간단히 줄여 NNLM이라고 합시다. 뒤에서 RNNLM, BiLM 등 보다 발전된 신경망 언어 모델들을 배웁니다. 이 모델은 제안되었을 당시 NPLM(Neural Probabilistic Language Model)이라는 이름을 갖고 있었습니다. 1. 기존 N-gram 언어 모델의 한계 언어 모델은 문장에 확률을 할당하는 모델이며, 주어진 문맥으로부터 아직 모르는 단어를 예측하는 것을 언어 모델링이라고 한다고 언급한 바 있습니다. 다음은 이전 단어들로부터 다음 단어를 예측하는 언어 모델링(Language Modeling)의 예를 보여줍니다. # 다음 단어 예측하기 An adorable little boy is spreading ____ 위문장을 가지고 앞서 배운 n-gram 언어 모델이 언어 모델링을 하는 방법을 복습해 봅시다. n-gram 언어 모델은 언어 모델링에 바로 앞 n-1개의 단어를 참고합니다. 4-gram 언어 모델이라고 가정해 봅시다. 모델은 바로 앞 3개의 단어만 참고하며 더 앞의 단어들은 무시합니다. 위 예제에서 다음 단어 예측에 사용되는 단어는 boy, is, spreading입니다. ( |boy is spreading ) count(boy is spreading w ) count(boy is spreading) 그 후에는 훈련 코퍼스에서 (n-1)-gram을 카운트한 것을 분모로, n-gram을 카운트한 것을 분자로 하여 다음 단어가 등장 확률을 예측했습니다. 예를 들어 갖고 있는 코퍼스에서 boy is spreading가 1,000번, boy is spreading insults가 500번, boy is spreading smiles가 200번 등장했다면 각 확률은 아래와 같습니다. ( insults|boy is spreading ) 0.500 ( smiles|boy is spreading ) 0.200 하지만 이러한 n-gram 언어 모델은 충분한 데이터를 관측하지 못하면 언어를 정확히 모델링 하지 못하는 희소 문제(sparsity problem) 가 있었습니다. 예를 들어 훈련 코퍼스에 ' boy is spreading smile '라는 단어 시퀀스가 존재하지 않으면 n-gram 언어 모델에서 해당 단어 시퀀스의 확률 ( smiles|boy is spreading ) 는 0이 됩니다. 이는 언어 모델이 판단하기에 boy is spreading 다음에는 smiles 이란 단어가 나올 수 없다는 의미이지만 해당 단어 시퀀스는 현실에서 존재 가능한 시퀀스이므로 적절한 모델링이 아닙니다. 2. 단어의 의미적 유사성 희소 문제는 기계가 단어의 의미적 유사성을 알 수 있다면 해결할 수 있는 문제입니다. 실제 사람의 사례를 들어 이야기해 보겠습니다. 저자는 최근 '톺아보다'라는 생소한 단어를 배웠고, '톺아보다'가 '샅샅이 살펴보다'와 유사한 의미임을 학습했습니다. 그리고 '발표 자료를 살펴보다'라는 표현 대신 '발표 자료를 톺아보다'라는 표현을 써봤습니다. 저는 '발표 자료를 톺아보다'라는 예문을 어디서 읽은 적은 없지만 두 단어가 유사함을 학습하였으므로 단어를 대신 선택하여 자연어 생성을 할 수 있었습니다. 기계도 마찬가지입니다. '발표 자료를 살펴보다'라는 단어 시퀀스는 존재하지만, '발표 자료를 톺아보다'라는 단어 시퀀스는 존재하지 않는 코퍼스를 학습한 언어 모델이 있다고 가정해 봅시다. 언어 모델은 아래 선택지에서 다음 단어를 예측해야 합니다. 톺아보다 발표 자료를 ( 톺아보다|발표 자료를 ) 냠냠하다 발표 자료를 ( 냠냠하다|발표 자료를 ) 저자의 경우에는 '살펴보다'와 '톺아보다'의 유사성을 학습하였고 이를 근거로 두 선택지 중에서 '톺아보다'가 더 맞는 선택이라고 판단할 수 있습니다. 하지만 n-gram 언어 모델은 '발표 자료를' 다음에 '톺아보다'가 나올 확률 톺아보다 발표 자료를 ( 톺아보다|발표 자료를 를 0으로 연산합니다. n-gram 언어 모델은 '살펴보다'와 '톺아보다'의 단어의 유사도를 알 수 없으므로 예측에 고려할 수 없습니다. 만약 언어 모델 또한 단어의 의미적 유사성을 학습할 수 있도록 설계한다면, 훈련 코퍼스에 없는 단어 시퀀스에 대한 예측이라도 유사한 단어가 사용된 단어 시퀀스를 참고하여 보다 정확한 예측을 할 수 있습니다. 그리고 이러한 아이디어를 반영한 언어 모델이 신경망 언어 모델 NNLM입니다. 그리고 이 아이디어는 단어 벡터 간 유사도를 구할 수 있는 벡터를 얻어내는 워드 임베딩(word embedding)의 아이디어이기도 합니다. NNLM이 어떻게 훈련 과정에서 단어의 유사도를 학습할 수 있는지 알아봅시다. 3. 피드 포워드 신경망 언어 모델(NNLM) NNLM이 언어 모델링을 학습하는 과정을 보겠습니다. 이해를 위해 간소화된 형태로 설명합니다. 예문 : "what will the fat cat sit on" 예를 들어 훈련 코퍼스에 위와 같은 문장이 있다고 해봅시다. 언어 모델은 주어진 단어 시퀀스로부터 다음 단어를 예측합니다. 훈련 과정에서는 'what will the fat cat'이라는 단어 시퀀스가 입력으로 주어지면, 다음 단어 'sit'을 예측하는 방식으로 훈련됩니다. 훈련 코퍼스가 준비된 상태에서 가장 먼저 해야 할 일은 기계가 단어를 인식할 수 있도록 모든 단어를 수치화하는 것입니다. 훈련 코퍼스에 7개의 단어만 존재한다고 가정했을 때 위 단어들을 다음과 같이 원-핫 인코딩 할 수 있습니다. what = [1, 0, 0, 0, 0, 0, 0] will = [0, 1, 0, 0, 0, 0, 0] the = [0, 0, 1, 0, 0, 0, 0] fat = [0, 0, 0, 1, 0, 0, 0] cat = [0, 0, 0, 0, 1, 0, 0] sit = [0, 0, 0, 0, 0, 1, 0] on = [0, 0, 0, 0, 0, 0, 1] 모든 단어가 단어 집합(vocabulary)의 크기인 7의 차원을 가지는 원-핫 벡터가 되었습니다. 이 원-핫 벡터들이 훈련을 위한 NNLM의 입력이면서 예측을 위한 레이블이 됩니다. 'what will the fat cat'를 입력을 받아서 'sit'을 예측하는 일은 기계에게 what, will, the, fat, cat의 원-핫 벡터를 입력받아 sit의 원-핫 벡터를 예측하는 문제입니다. NNLM은 n-gram 언어 모델처럼 다음 단어를 예측할 때, 앞의 모든 단어를 참고하는 것이 아니라 정해진 개수의 단어만을 참고합니다. 이 개수를 n이라고 하고 n을 4라고 해봅시다. 이때, 언어 모델은 'what will the fat cat'라는 단어 시퀀스가 주어졌을 때, 다음 단어를 예측하기 위해 앞의 4개 단어 'will the fat cat'까지만 참고하고 그 앞 단어인 what은 무시합니다. 이 범위를 윈도(window)라고 하기도 하는데, 여기서 윈도의 크기인 n은 4입니다. NNLM의 구조를 보겠습니다. NNLM은 위의 그림과 같이 총 4개의 층(layer)으로 이루어진 인공 신경망입니다. 입력층(input layer)을 보면 앞에서 윈도의 크기는 4로 정하였으므로 입력은 4개의 단어 'will, the, fat, cat'의 원-핫 벡터입니다. 출력층(output layer)을 보면 모델이 예측해야 하는 정답에 해당되는 단어 sit의 원-핫 벡터는 모델이 예측한 값의 오차를 구하기 위해 레이블로서 사용됩니다. 그리고 오차로부터 손실 함수를 사용하여 인공 신경망이 학습을 하게 됩니다. 내부 메커니즘을 따라가봅시다. 4개의 원-핫 벡터를 입력받은 NNLM은 다음층인 투사층(projection layer)을 지나게 됩니다. 인공 신경망에서 입력층과 출력층 사이의 층은 보통 은닉층이라고 부르는데, 여기서 투사층이라고 명명한 이 층은 일반 은닉층과 다르게 가중치 행렬과의 곱셈은 이루어지지만 활성화 함수가 존재하지 않습니다. 투사층의 크기를 M으로 설정하면, 각 입력 단어들은 투사층에서 V × M 크기의 가중치 행렬과 곱해집니다. 여기서 V는 단어 집합의 크기를 의미합니다. 만약 원-핫 벡터의 차원이 7이고, M이 5라면 가중치 행렬 W는 7 × 5 행렬이 됩니다. 각 단어의 원-핫 벡터와 가중치 W 행렬의 곱이 어떻게 이루어지는지 보겠습니다. 위 그림에서는 각 원-핫 벡터를 로 표기하였습니다. 원-핫 벡터의 특성으로 인해 i 번째 인덱스에 1이라는 값을 가지고 그 외의 0의 값을 가지는 원-핫 벡터와 가중치 W 행렬의 곱은 사실 W 행렬의 i번째 행을 그대로 읽어오는 것과(lookup) 동일합니다. 그래서 이 작업을 룩업 테이블(lookup table)이라고 합니다. 룩업 테이블 후에는 V 차원을 가지는 원-핫 벡터는 이보다 더 차원이 작은 M 차원의 벡터로 매핑됩니다. 위 그림에서 단어 fat을 의미하는 원-핫 벡터를 f t 으로 표현했고, 테이블 룩업 과정을 거친 후의 단어 벡터는 f t 으로 표현했습니다. 이 벡터들은 초기에는 랜덤 한 값을 가지지만 학습 과정에서 값이 계속 변경되는데 이 단어 벡터를 임베딩 벡터(embedding vector)라고 합니다. 각 단어가 테이블 룩 업을 통해 임베딩 벡터로 변경되고, 투사층에서 모든 임베딩 벡터들의 값은 연결됩니다(concatenate). 여기서 벡터의 연결 연산은 벡터들을 이어붙이는 것을 의미합니다. 가령, 5차원 벡터 4개를 연결한다는 의미는 20차원 벡터를 얻는다는 의미입니다.를 각 단어의 원-핫 벡터, NNLM이 예측하고자 하는 단어가 문장에서 번째 단어라고 하고, 윈도의 크기를, 룩업 테이블을 의미하는 함수를 o k p , 세미콜론(;)을 연결 기호로 하였을 때 투사층을 식으로 표현하면 아래와 같습니다. 투사층 : l y r ( o k p ( t n ) . . l o u ( t 2 ) l o u ( t 1 ) ) ( t n. . e − ; t 1 ) 일반적인 은닉층이 활성화 함수를 사용하는 비선형층(nonlinear layer)인 것과는 달리 투사층은 활성화 함수가 존재하지 않는 선형층(linear layer)이라는 점이 다소 생소하지만, 이다음은 다시 은닉층을 사용하는 일반적인 피드 포워드 신경망과 동일합니다. 투사층의 결과는 h의 크기를 가지는 은닉층을 지납니다. 일반적인 피드 포워드 신경망에서 은닉층을 지난다는 것은 은닉층의 입력은 가중치 곱해진 후 편향이 더해져 활성화 함수의 입력이 된다는 의미입니다. 이때의 가중치와 편향을 h b이라고 하고, 은닉층의 활성화 함수를 하이퍼볼릭탄젠트 함수라고 하였을 때, 은닉층을 식으로 표현하면 아래와 같습니다. 은닉층 : l y r t n ( h l y r b) 은닉층의 출력은 V의 크기를 가지는 출력층으로 향합니다. 이 과정에서 다시 또 다른 가중치와 곱해지고 편향이 더해지면, 입력이었던 원-핫 벡터들과 동일하게 V 차원의 벡터를 얻습니다. 만약 입력 벡터의 차원이 7이었다면 해당 벡터도 동일한 차원 수를 가집니다. 출력층에서는 활성화 함수로 소프트맥스(softmax) 함수를 사용하는데, V 차원의 벡터는 소프트맥스 함수를 지나면서 벡터의 각 원소는 0과 1사이의 실숫값을 가지며 총합은 1이 되는 상태로 바뀝니다. 이 벡터를 NNLM의 예측값이라는 의미에서 ^ 라고 합시다. 이를 식으로 표현하면 아래와 같습니다. 출력층 : ^ s f m x ( y l y r b) 벡터 ^ 의 각 차원 안에서의 값이 의미하는 것은 이와 같습니다. ^ 의 j 번째 인덱스가 가진 0과 1사이의 값은 j 번째 단어가 다음 단어일 확률을 나타냅니다. 그리고 ^ 는 실제 값. 즉, 실제 정답에 해당되는 단어인 원-핫 벡터의 값에 가까워져야 합니다. 실제 값에 해당되는 다음 단어를 라고 했을 때, 이 두 벡터가 가까워지게 하기 위해서 NNLM는 손실 함수로 크로스 엔트로피(cross-entropy) 함수를 사용합니다. 해당 문제는 단어 집합의 모든 단어라는 V 개의 선택지 중 정답인 'sit'을 예측해야 하는 다중 클래스 분류 문제입니다. 그리고 역전파가 이루어지면 모든 가중치 행렬들이 학습되는데, 여기에는 투사층에서의 가중치 행렬도 포함되므로 임베딩 벡터 값 또한 학습됩니다. 이번 예제에서는 7개의 단어만 사용했지만, 만약 충분한 훈련 데이터가 있다는 가정 하에 NNLM이 얻을 수 있는 이점은 무엇일까요? NNLM의 핵심은 충분한 양의 훈련 코퍼스를 위와 같은 과정으로 학습한다면 결과적으로 수많은 문장에서 유사한 목적으로 사용되는 단어들은 결국 유사한 임베딩 벡터 값을 얻게 되는 것에 있습니다. 이렇게 되면 훈련이 끝난 후 다음 단어를 예측 과정에서 (마치 앞서 언급한 저자의 '톺아보기'와 같은 예시처럼) 훈련 코퍼스에서 없던 단어 시퀀스라 하더라도 다음 단어를 선택할 수 있습니다. 단어 간 유사도를 구할 수 있는 임베딩 벡터의 아이디어는 Word2Vec, FastText, GloVe 등으로 발전되어서 딥 러닝 자연어 처리 모델에서는 필수적으로 사용되는 방법이 되었습니다. 임베딩 벡터에 대해서는 워드 임베딩 챕터에서 좀 더 자세히 다룹니다. 4. NNLM의 이점과 한계 NNLM은 기존 n-gram 언어 모델의 한계를 개선하였지만 여전히 가지는 문제점이 있습니다. 1) 기존 모델에서의 개선점 NNLM은 단어를 표현하기 위해 임베딩 벡터를 사용함으로써 단어의 유사도를 계산할 수 있었습니다. 그리고 이를 통해 희소 문제(sparsity problem)를 해결하였습니다. 2) 고정된 길이의 입력(Fixed-length input) NNLM이 극복하지 못한 한계 또한 존재합니다. NNLM은 n-gram 언어 모델과 마찬가지로 다음 단어를 예측하기 위해 모든 이전 단어를 참고하는 것이 아니라 정해진 n 개의 단어만을 참고할 수 있습니다. 이 한계를 극복할 수 있는 언어 모델이 있는데, 다음 챕터에서 배우게 될 RNN(Recurrent Neural Network)을 사용한 RNN 언어 모델(Recurrent Neural Network Language Model, RNNLM)입니다. 08. 순환 신경망(Recurrent Neural Network) 앞서 배운 피드 포워드 신경망은 입력의 길이가 고정되어 있어 자연어 처리를 위한 신경망으로는 한계가 있었습니다. 결국 다양한 길이의 입력 시퀀스를 처리할 수 있는 인공 신경망이 필요하게 되었는데, 자연어 처리에 대표적으로 사용되는 인공 신경망이 바로 순환 신경망(Recurrent Neural Network, RNN)입니다. 이번 챕터에서는 가장 기본적인 순환 신경망인 바닐라 RNN, 이를 개선한 LSTM, GRU에 대해서 학습해 봅시다. LSTM과 GRU를 이해한다면 텍스트 분류나 기계 번역과 같은 다양한 자연어 처리 문제들을 풀 수 있습니다. 08-01 순환 신경망(Recurrent Neural Network, RNN) RNN(Recurrent Neural Network)은 입력과 출력을 시퀀스 단위로 처리하는 시퀀스(Sequence) 모델입니다. 번역기를 생각해 보면 입력은 번역하고자 하는 단어의 시퀀스인 문장입니다. 출력에 해당되는 번역된 문장 또한 단어의 시퀀스입니다. 이와 같이 시퀀스들을 처리하기 위해 고안된 모델들을 시퀀스 모델이라고 합니다. 그중 RNN은 가장 기본적인 인공 신경망 시퀀스 모델입니다. 뒤에서 배우는 LSTM이나 GRU 또한 근본적으로 RNN에 속합니다. RNN을 이해하고 'RNN을 이용한 텍스트 분류' 챕터, '태깅 작업' 챕터, 'RNN을 이용한 인코더-디코더' 챕터에서 실습을 진행합니다. 용어는 비슷하지만 순환 신경망과 재귀 신경망(Recursive Neural Network)은 전혀 다른 개념입니다. 1. 순환 신경망(Recurrent Neural Network, RNN) 앞서 배운 신경망들은 전부 은닉층에서 활성화 함수를 지난 값은 오직 출력층 방향으로만 향했습니다. 이와 같은 신경망들을 피드 포워드 신경망(Feed Forward Neural Network)이라고 합니다. 그런데 그렇지 않은 신경망들이 있습니다. RNN(Recurrent Neural Network) 또한 그중 하나입니다. RNN은 은닉층의 노드에서 활성화 함수를 통해 나온 결괏값을 출력층 방향으로도 보내면서, 다시 은닉층 노드의 다음 계산의 입력으로 보내는 특징을 갖고 있습니다. 위의 그림을 보겠습니다.는 입력층의 입력 벡터,는 출력층의 출력 벡터입니다. 실제로는 편향 도 입력으로 존재할 수 있지만 앞으로의 그림에서는 생략합니다. RNN에서 은닉층에서 활성화 함수를 통해 결과를 내보내는 역할을 하는 노드를 셀(cell)이라고 합니다. 이 셀은 이전의 값을 기억하려고 하는 일종의 메모리 역할을 수행하므로 이를 메모리 셀 또는 RNN 셀이라고 표현합니다. 은닉층의 메모리 셀은 각각의 시점(time step)에서 바로 이전 시점에서의 은닉층의 메모리 셀에서 나온 값을 자신의 입력으로 사용하는 재귀적 활동을 하고 있습니다. 앞으로는 현재 시점을 변수 t로 표현하겠습니다. 이는 현재 시점 t에서의 메모리 셀 이 갖고 있는 값은 과거의 메모리 셀들의 값에 영향을 받은 것임을 의미합니다. 그렇다면 메모리 셀 이 갖고 있는 이 값은 뭐라고 부를까요? 메모리 셀 이 출력층 방향 또는 다음 시점인 t+1의 자신에게 보내는 값을 은닉 상태(hidden state)라고 합니다. 다시 말해 t 시점의 메모리 셀은 t-1 시점의 메모리 셀 이 보낸 은닉 상태 값을 t 시점의 은닉 상태 계산을 위한 입력값으로 사용합니다. RNN을 표현할 때는 일반적으로 위의 그림에서 좌측과 같이 화살표로 사이클을 그려서 재귀 형태로 표현하기도 하지만, 우측과 같이 사이클을 그리는 화살표 대신 여러 시점으로 펼쳐서 표현하기도 합니다. 두 그림은 동일한 그림으로 단지 사이클을 그리는 화살표를 사용하여 표현하였느냐, 시점의 흐름에 따라서 표현하였느냐의 차이일 뿐 둘 다 동일한 RNN을 표현하고 있습니다. 피드 포워드 신경망에서는 뉴런이라는 단위를 사용했지만, RNN에서는 뉴런이라는 단위보다는 입력층과 출력층에서는 각각 입력 벡터와 출력 벡터, 은닉층에서는 은닉 상태라는 표현을 주로 사용합니다. 위의 그림에서 회색과 초록색으로 표현한 각 네모들은 기본적으로 벡터 단위를 가정하고 있습니다. 피드 포워드 신경망과의 차이를 비교하기 위해서 RNN을 뉴런 단위로 시각화해보겠습니다. 위의 그림은 입력 벡터의 차원이 4, 은닉 상태의 크기가 2, 출력층의 출력 벡터의 차원이 2인 RNN이 시점이 2일 때의 모습을 보여줍니다. 다시 말해 뉴런 단위로 해석하면 입력층의 뉴런 수는 4, 은닉층의 뉴런 수는 2, 출력층의 뉴런 수는 2입니다. RNN은 입력과 출력의 길이를 다르게 설계할 수 있으므로 다양한 용도로 사용할 수 있습니다. 위 그림은 입력과 출력의 길이에 따라서 달라지는 RNN의 다양한 형태를 보여줍니다. 위 구조가 자연어 처리에서 어떻게 사용될 수 있는지 예를 들어봅시다. RNN 셀의 각 시점의 입, 출력의 단위는 사용자가 정의하기 나름이지만 가장 보편적인 단위는 '단어 벡터'입니다. 예를 들어 하나의 입력에 대해서 여러 개의 출력을 의미하는 일 대다(one-to-many) 구조의 모델은 하나의 이미지 입력에 대해서 사진의 제목을 출력하는 이미지 캡셔닝(Image Captioning) 작업에 사용할 수 있습니다. 사진의 제목은 단어들의 나열이므로 시퀀스 출력입니다. 또한 단어 시퀀스에 대해서 하나의 출력을 하는 다 대 일(many-to-one) 구조의 모델은 입력 문서가 긍정적인지 부정적인지를 판별하는 감성 분류(sentiment classification), 또는 메일이 정상 메일인지 스팸 메일인지 판별하는 스팸 메일 분류(spam detection) 등에 사용할 수 있습니다. 위 그림은 RNN으로 스팸 메일을 분류할 때의 아키텍처를 보여줍니다. 이러한 예제들은 'RNN을 이용한 텍스트 분류' 챕터에서 배웁니다. 다 대다(many-to-many) 구조의 모델의 경우에는 사용자가 문장을 입력하면 대답 문장을 출력하는 챗봇과 입력 문장으로부터 번역된 문장을 출력하는 번역기, 또는 '태깅 작업' 챕터에서 배우는 개체명 인식이나 품사 태깅과 같은 작업이 속합니다. 위 그림은 개체명 인식을 수행할 때의 RNN 아키텍처를 보여줍니다. RNN에 대한 수식을 정의해 보겠습니다. 현재 시점 t에서의 은닉 상태 값을 t 라고 정의하겠습니다. 은닉층의 메모리 셀은 t 를 계산하기 위해서 총 두 개의 가중치를 가집니다. 하나는 입력층을 위한 가중치 x 이고, 하나는 이전 시점 t-1의 은닉 상태 값인 t 1 을 위한 가중치 h 입니다. 이를 식으로 표현하면 다음과 같습니다. 은닉층 : t t n ( x t W h − + ) 출력층 : t f ( y t b ) 단,는 비선형 활성화 함수 중 하나. RNN의 은닉층 연산을 벡터와 행렬 연산으로 이해해 봅시다. 자연어 처리에서 RNN의 입력 t 는 대부분의 경우 단어 벡터로 간주할 수 있는데, 단어 벡터의 차원을라고 하고, 은닉 상태의 크기를 h 라고 하였을 때 각 벡터와 행렬의 크기는 다음과 같습니다. t ( × ) x ( h d ) h ( h D) t 1 ( h 1 ) : ( h 1 ) 배치 크기가 1이고, 와 h 두 값 모두를 4로 가정하였을 때, RNN의 은닉층 연산을 그림으로 표현하면 아래와 같습니다. 이때 t 를 계산하기 위한 활성화 함수로는 주로 하이퍼볼릭탄젠트 함수(tanh)가 사용됩니다. 위의 식에서 각각의 가중치 x W, y 의 값은 하나의 층에서는 모든 시점에서 값을 동일하게 공유합니다. 하지만 은닉층이 2개 이상일 경우에는 각 은닉층에서의 가중치는 서로 다릅니다. 출력층은 결과값인 t 를 계산하기 위한 활성화 함수로는 푸는 문제에 따라서 다를 텐데, 예를 들어서 이진 분류를 해야 하는 경우라면 출력층에 로지스틱 회귀를 사용하여 시그모이드 함수를 사용할 수 있고 다중 클래스 분류를 해야 하는 경우라면 출력층에 소프트맥스 회귀를 사용하여로 소프트맥스 함수를 사용할 수 있습니다. 2. 케라스(Keras)로 RNN 구현하기 케라스로 RNN 층을 추가하는 코드는 다음과 같습니다. from tensorflow.keras.layers import SimpleRNN model.add(SimpleRNN(hidden_units)) 인자를 사용할 때를 보겠습니다. # 추가 인자를 사용할 때 model.add(SimpleRNN(hidden_units, input_shape=(timesteps, input_dim))) # 다른 표기 model.add(SimpleRNN(hidden_units, input_length=M, input_dim=N)) hidden_units = 은닉 상태의 크기를 정의. 메모리 셀 이다음 시점의 메모리 셀과 출력층으로 보내는 값의 크기(output_dim)와도 동일. RNN의 용량(capacity)을 늘린다고 보면 되며, 중소형 모델의 경우 보통 128, 256, 512, 1024 등의 값을 가진다. timesteps = 입력 시퀀스의 길이(input_length)라고 표현하기도 함. 시점의 수. input_dim = 입력의 크기. RNN 층은 (batch_size, timesteps, input_dim) 크기의 3D 텐서를 입력으로 받습니다. batch_size는 한 번에 학습하는 데이터의 개수를 말합니다. 여기서부터는 텐서의 개념을 반드시 이해해야 하므로 벡터와 행렬 연산 챕터의 텐서 설명을 참고하시기 바랍니다. 다만, 이러한 표현은 사람이나 문헌에 따라서, 또는 풀고자 하는 문제에 따라서 종종 다르게 기재되는데의 그림은 문제와 상황에 따라서 다르게 표현되는 입력 3D 텐서의 대표적인 표현들을 보여줍니다. 주의할 점은 위 코드는 출력층까지 포함한 인공 신경망 코드가 아니라 주로 은닉층으로 간주할 수 있는 하나의 RNN 층에 대한 코드입니다. 해당 코드가 리턴하는 결괏값은 하나의 은닉 상태 또는 정의하기에 따라 여러 개의 시점의 은닉 상태입니다. 아래의 그림은 만약 전결합층(Fully-connected layer)을 출력층으로 사용하였을 경우의 인공 신경망 그림과 은닉층까지만 표현한 그림의 차이를 보여줍니다. 그렇다면 RNN 층은 위에서 설명한 입력 3D 텐서를 입력받아서 어떻게 은닉 상태를 출력할까요? RNN 층은 사용자의 설정에 따라 두 가지 종류의 출력을 내보냅니다. 메모리 셀의 최종 시점의 은닉 상태만을 리턴하고 자 한다면 (batch_size, output_dim) 크기의 2D 텐서를 리턴합니다. 하지만, 메모리 셀의 각 시점(time step)의 은닉 상태 값들을 모아서 전체 시퀀스를 리턴하고 자 한다면 (batch_size, timesteps, output_dim) 크기의 3D 텐서를 리턴합니다. 이는 RNN 층의 return_sequences 매개 변수에 True를 설정하여 설정이 가능합니다. output_dim은 앞서 코드에서 정의한 hidden_units의 값으로 설정됩니다. 위의 그림은 time step=3일 때, return_sequences = True를 설정했을 때와 그렇지 않았을 때 어떤 차이가 있는지를 보여줍니다. return_sequences=True를 선택하면 메모리 셀 이 모든 시점(time step)에 대해서 은닉 상태 값을 출력하며, 별도 기재하지 않거나 return_sequences=False로 선택할 경우에는 메모리 셀은 하나의 은닉 상태 값만을 출력합니다. 그리고 이 하나의 값은 마지막 시점(time step)의 메모리 셀의 은닉 상태 값입니다. 마지막 은닉 상태만 전달하도록 하면 다 대 일(many-to-one) 문제를 풀 수 있고, 모든 시점의 은닉 상태를 전달하도록 하면, 다음층에 RNN 은닉층이 하나 더 있는 경우이거나 다 대다(many-to-many) 문제를 풀 수 있습니다. 뒤에서 배우는 LSTM이나 GRU도 내부 메커니즘은 다르지만 model.add()를 통해서 층을 추가하는 코드는 SimpleRNN 코드와 같은 형태를 가집니다. 실습을 통해 모델 내부적으로 출력 결과를 어떻게 정의하는지 이해해 봅시다. from tensorflow.keras.models import Sequential from tensorflow.keras.layers import SimpleRNN model = Sequential() model.add(SimpleRNN(3, input_shape=(2,10))) # model.add(SimpleRNN(3, input_length=2, input_dim=10))와 동일함. model.summary() _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= simple_rnn_1 (SimpleRNN) (None, 3) 42 ================================================================= Total params: 42 Trainable params: 42 Non-trainable params: 0 _________________________________________________________________ 출력값이 (batch_size, output_dim) 크기의 2D 텐서일 때, output_dim은 hidden_units의 값인 3입니다. 이 경우 batch_size를 현 단계에서는 알 수 없으므로 (None, 3)이 됩니다. 이번에는 batch_size를 미리 정의해 보겠습니다. model = Sequential() model.add(SimpleRNN(3, batch_input_shape=(8,2,10))) model.summary() _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= simple_rnn_2 (SimpleRNN) (8, 3) 42 ================================================================= Total params: 42 Trainable params: 42 Non-trainable params: 0 _________________________________________________________________ batch_size를 8로 기재하면 출력의 크기가 (8, 3)이 됩니다. return_sequences 매개 변수에 True를 기재하여 출력값으로 (batch_size, timesteps, output_dim) 크기의 3D 텐서를 리턴하도록 모델을 만들어 보겠습니다. model = Sequential() model.add(SimpleRNN(3, batch_input_shape=(8,2,10), return_sequences=True)) model.summary() _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= simple_rnn_3 (SimpleRNN) (8, 2, 3) 42 ================================================================= Total params: 42 Trainable params: 42 Non-trainable params: 0 _________________________________________________________________ 출력의 크기가 (8, 2, 3)이 됩니다. 3. 파이썬으로 RNN 구현하기 직접 Numpy로 RNN 층을 구현해 보겠습니다. 앞서 메모리 셀에서 은닉 상태를 계산하는 식을 다음과 같이 정의하였습니다. t t n ( x t W h − + ) 실제 구현에 앞서 간단히 가상의 코드(pseudocode)를 작성해 보겠습니다. # 아래의 코드는 가상의 코드(pseudocode)로 실제 동작하는 코드가 아님. hidden_state_t = 0 # 초기 은닉 상태를 0(벡터)로 초기화 for input_t in input_length: # 각 시점마다 입력을 받는다. output_t = tanh(input_t, hidden_state_t) # 각 시점에 대해서 입력과 은닉 상태를 가지고 연산 hidden_state_t = output_t # 계산 결과는 현재 시점의 은닉 상태가 된다. 우선 t 시점의 은닉 상태를 hidden_state_t라는 변수로 선언하였고, 입력 데이터의 길이를 input_length로 선언하였습니다. 이 경우, 입력 데이터의 길이는 곧 총 시점의 수(timesteps)가 됩니다. 그리고 t 시점의 입력값을 input_t로 선언하였습니다. 각 메모리 셀은 각 시점마다 input_t와 hidden_sate_t(이전 상태의 은닉 상태)를 입력으로 활성화 함수인 하이퍼볼릭탄젠트 함수를 통해 현시점의 hidden_state_t를 계산합니다. 가상의 코드를 통해 간단히 개념 정립을 해보았습니다. RNN 층을 실제 동작되는 코드로 구현해 보겠습니다. 아래의 코드는 이해를 돕기 위해 (timesteps, input_dim) 크기의 2D 텐서를 입력으로 받았다고 가정하였으나, 실제로 케라스에서는 (batch_size, timesteps, input_dim)의 크기의 3D 텐서를 입력으로 받는 것을 기억합시다. timesteps는 시점의 수입니다. 자연어 처리에서는 보통 문장의 길이입니다. input_dim은 입력의 차원입니다. 자연어 처리에서는 보통 단어 벡터의 차원입니다. hidden_units는 은닉 상태의 크기로 메모리 셀의 용량입니다. 초기 은닉 상태는 0의 값을 가지는 벡터로 초기화합니다. 초기 은닉 상태를 출력해 보겠습니다. import numpy as np timesteps = 10 input_dim = 4 hidden_units = 8 # 입력에 해당되는 2D 텐서 inputs = np.random.random((timesteps, input_dim)) # 초기 은닉 상태는 0(벡터)로 초기화 hidden_state_t = np.zeros((hidden_units,)) print('초기 은닉 상태 :',hidden_state_t) 초기 은닉 상태 : [0. 0. 0. 0. 0. 0. 0. 0.] 은닉 상태의 크기를 8로 정의하였으므로 8의 차원을 가지는 0의 값으로 구성된 벡터가 출력됩니다. 가중치와 편향을 각 크기에 맞게 정의하고 크기를 출력해 보겠습니다. Wx = np.random.random((hidden_units, input_dim)) # (8, 4) 크기의 2D 텐서 생성. 입력에 대한 가중치. Wh = np.random.random((hidden_units, hidden_units)) # (8, 8) 크기의 2D 텐서 생성. 은닉 상태에 대한 가중치. b = np.random.random((hidden_units,)) # (8, ) 크기의 1D 텐서 생성. 이 값은 편향(bias). print('가중치 Wx의 크기(shape) :',np.shape(Wx)) print('가중치 Wh의 크기(shape) :',np.shape(Wh)) print('편향의 크기(shape) :',np.shape(b)) 가중치 Wx의 크기(shape) : (8, 4) 가중치 Wh의 크기(shape) : (8, 8) 편향의 크기(shape) : (8, ) 각 가중치와 편향의 크기는 다음과 같습니다. Wx는 (은닉 상태의 크기 × 입력의 차원), Wh는 (은닉 상태의 크기 × 은닉 상태의 크기), b는 (은닉 상태의 크기)의 크기를 가집니다. 이제 모든 시점의 은닉 상태를 출력한다고 가정하고, RNN 층을 동작시켜봅시다. total_hidden_states = [] # 각 시점 별 입력값. for input_t in inputs: # Wx * Xt + Wh * Ht-1 + b(bias) output_t = np.tanh(np.dot(Wx, input_t) + np.dot(Wh, hidden_state_t) + b) # 각 시점 t 별 메모리 셀의 출력의 크기는 (timestep t, output_dim) # 각 시점의 은닉 상태의 값을 계속해서 누적 total_hidden_states.append(list(output_t)) hidden_state_t = output_t # 출력 시 값을 깔끔하게 해주는 용도. total_hidden_states = np.stack(total_hidden_states, axis = 0) # (timesteps, output_dim) print('모든 시점의 은닉 상태 :') print(total_hidden_states) 모든 시점의 은닉 상태 : [[0.85575076 0.71627213 0.87703694 0.83938496 0.81045543 0.86482715 0.76387233 0.60007514] [0.99982366 0.99985897 0.99928638 0.99989791 0.99998252 0.99977656 0.99997677 0.9998397 ] [0.99997583 0.99996057 0.99972541 0.99997993 0.99998684 0.99954936 0.99997638 0.99993143] [0.99997782 0.99996494 0.99966651 0.99997989 0.99999115 0.99980087 0.99999107 0.9999622 ] [0.99997231 0.99996091 0.99976218 0.99998483 0.9999955 0.99989239 0.99999339 0.99997324] [0.99997082 0.99998754 0.99962158 0.99996278 0.99999331 0.99978731 0.99998831 0.99993414] [0.99997427 0.99998367 0.99978331 0.99998173 0.99999579 0.99983689 0.99999058 0.99995531] [0.99992591 0.99996115 0.99941212 0.99991593 0.999986 0.99966571 0.99995842 0.99987795] [0.99997139 0.99997192 0.99960794 0.99996751 0.99998795 0.9996674 0.99998177 0.99993016] [0.99997659 0.99998915 0.99985392 0.99998726 0.99999773 0.99988295 0.99999316 0.99996326]] 4. 깊은 순환 신경망(Deep Recurrent Neural Network) 앞서 RNN도 다수의 은닉층을 가질 수 있다고 언급한 바 있습니다. 위의 그림은 순환 신경망에서 은닉층이 1개 더 추가되어 은닉층이 2개인 깊은(deep) 순환 신경망의 모습을 보여줍니다. 은닉층을 2개 추가하는 경우 코드는 아래와 같습니다. model = Sequential() model.add(SimpleRNN(hidden_units, input_length=10, input_dim=5, return_sequences=True)) model.add(SimpleRNN(hidden_units, return_sequences=True)) 위의 코드에서 첫 번째 은닉층은 다음 은닉층이 존재하므로 return_sequences = True를 설정하여 모든 시점에 대해서 은닉 상태 값을 다음 은닉층으로 보내주고 있습니다. 5. 양방향 순환 신경망(Bidirectional Recurrent Neural Network) 양방향 순환 신경망은 시점 t에서의 출력값을 예측할 때 이전 시점의 입력뿐만 아니라, 이후 시점의 입력 또한 예측에 기여할 수 있다는 아이디어에 기반합니다. 빈칸 채우기 문제에 비유하여 보겠습니다. 운동을 열심히 하는 것은 [ ]을 늘리는데 효과적이다. 1) 근육 2) 지방 3) 스트레스 '운동을 열심히 하는 것은 [ ]을 늘리는데 효과적이다.'라는 문장에서 문맥 상으로 정답은 '근육'입니다. 위의 빈칸 채우기 문제를 풀 때 이전에 나온 단어들만으로 빈칸을 채우려고 시도해 보면 정보가 부족합니다. '운동을 열심히 하는 것은'까지만 주고 뒤의 단어들은 가린 채 빈칸의 정답이 될 수 있는 세 개의 선택지 중 고르는 것은 뒤의 단어들까지 알고 있는 상태보다 명백히 정답을 결정하기가 어렵습니다. RNN이 풀고자 하는 문제 중에서는 과거 시점의 입력뿐만 아니라 미래 시점의 입력에 힌트가 있는 경우도 많습니다. 그래서 이전과 이후의 시점 모두를 고려해서 현재 시점의 예측을 더욱 정확하게 할 수 있도록 고안된 것이 양방향 RNN입니다. 양방향 RNN은 하나의 출력값을 예측하기 위해 기본적으로 두 개의 메모리 셀을 사용합니다. 첫 번째 메모리 셀은 앞에서 배운 것처럼 앞 시점의 은닉 상태(Forward States)를 전달받아 현재의 은닉 상태를 계산합니다. 위의 그림에서는 주황색 메모리 셀에 해당됩니다. 두 번째 메모리 셀은 앞에서 배운 것과는 다릅니다. 앞 시점의 은닉 상태가 아니라 뒤 시점의 은닉 상태(Backward States)를 전달받아 현재의 은닉 상태를 계산합니다. 입력 시퀀스를 반대 방향으로 읽는 것입니다. 위의 그림에서는 초록색 메모리 셀에 해당됩니다. 그리고 이 두 개의 값 모두가 현재 시점의 출력층에서 출력값을 예측하기 위해 사용됩니다. from tensorflow.keras.layers import Bidirectional timesteps = 10 input_dim = 5 model = Sequential() model.add(Bidirectional(SimpleRNN(hidden_units, return_sequences=True), input_shape=(timesteps, input_dim))) 양방향 RNN도 다수의 은닉층을 가질 수 있습니다. 아래의 그림은 양방향 순환 신경망에서 은닉층이 1개 더 추가되어 은닉층이 2개인 깊은(deep) 양방향 순환 신경망의 모습을 보여줍니다. 다른 인공 신경망 모델들도 마찬가지이지만, 은닉층을 무조건 추가한다고 해서 모델의 성능이 좋아지는 것은 아닙니다. 은닉층을 추가하면 학습할 수 있는 양이 많아지지만 반대로 훈련 데이터 또한 많은 양이 필요합니다. 아래의 코드는 은닉층이 4개인 경우를 보여줍니다. model = Sequential() model.add(Bidirectional(SimpleRNN(hidden_units, return_sequences=True), input_shape=(timesteps, input_dim))) model.add(Bidirectional(SimpleRNN(hidden_units, return_sequences=True))) model.add(Bidirectional(SimpleRNN(hidden_units, return_sequences=True))) model.add(Bidirectional(SimpleRNN(hidden_units, return_sequences=True))) 양방향 RNN은 태깅 작업 챕터의 실습에서 사용해 보겠습니다. 6. 점검 퀴즈 RNN을 제대로 이해했는지 퀴즈를 통해서 확인해 보세요! 모델에 대한 설명이 다음과 같을 때, 총 파라미터 개수를 구해보세요. Embedding을 사용하며, 단어 집합(Vocabulary)의 크기가 5,000이고 임베딩 벡터의 차원은 100입니다. 은닉층에서는 Simple RNN을 사용하며, 은닉 상태의 크기는 128입니다. 훈련에 사용하는 모든 샘플의 길이는 30으로 가정합니다. 이진 분류를 수행하는 모델로, 출력층의 뉴런은 1개로 시그모이드 함수를 사용합니다. 은닉층은 1개입니다. 정답은 위키독스 웹 사이트의 댓글에 남겨두었습니다. 08-02 장단기 메모리(Long Short-Term Memory, LSTM) 바닐라 아이스크림이 가장 기본적인 맛을 가진 아이스크림인 것처럼, 앞서 배운 RNN을 가장 단순한 형태의 RNN이라고 하여 바닐라 RNN(Vanilla RNN)이라고 합니다. (케 라스에서는 SimpleRNN) 바닐라 RNN 이후 바닐라 RNN의 한계를 극복하기 위한 다양한 RNN의 변형이 나왔습니다. 이번에 배우게 될 LSTM도 그중 하나입니다. 앞으로의 설명에서 LSTM과 비교하여 RNN을 언급하는 것은 전부 바닐라 RNN을 말합니다. 1. 바닐라 RNN의 한계 앞에서 바닐라 RNN은 출력 결과가 이전의 계산 결과에 의존한다는 것을 언급한 바 있습니다. 하지만 바닐라 RNN은 비교적 짧은 시퀀스(sequence)에 대해서만 효과를 보이는 단점이 있습니다. 바닐라 RNN의 시점(time step)이 길어질수록 앞의 정보가 뒤로 충분히 전달되지 못하는 현상이 발생합니다. 위의 그림은 첫 번째 입력값인 1 의 정보량을 짙은 남색으로 표현했을 때, 색이 점차 얕아지는 것으로 시점이 지날수록 1 의 정보량이 손실되어가는 과정을 표현하였습니다. 뒤로 갈수록 1 의 정보량은 손실되고, 시점이 충분히 긴 상황에서는 1 의 전체 정보에 대한 영향력은 거의 의미가 없을 수도 있습니다. 어쩌면 가장 중요한 정보가 시점의 앞 쪽에 위치할 수도 있습니다. RNN으로 만든 언어 모델이 다음 단어를 예측하는 과정을 생각해 봅시다. 예를 들어 ''모스크바에 여행을 왔는데 건물도 예쁘고 먹을 것도 맛있었어. 그런데 글쎄 직장 상사한테 전화가 왔어. 어디냐고 묻더라고 그래서 나는 말했지. 저 여행 왔는데요. 여기 ___'' 다음 단어를 예측하기 위해서는 장소 정보가 필요합니다. 그런데 장소 정보에 해당되는 단어인 '모스크바'는 앞에 위치하고 있고, RNN이 충분한 기억력을 가지고 있지 못한다면 다음 단어를 엉뚱하게 예측합니다. 이를 장기 의존성 문제(the problem of Long-Term Dependencies)라고 합니다. 2. 바닐라 RNN 내부 열어보기 LSTM에 대해서 이해해 보기 전에 바닐라 RNN의 뚜껑을 열어보겠습니다. 위의 그림은 바닐라 RNN의 내부 구조를 보여줍니다. 이 책에서는 RNN 계열의 인공 신경망의 그림에서는 편향 를 생략합니다. 위의 그림에 편향 를 그린다면 t 옆에 tanh로 향하는 또 하나의 입력선을 그리면 됩니다. t t n ( x t W h − + ) 바닐라 RNN은 t h −이라는 두 개의 입력이 각각의 가중치와 곱해져서 메모리 셀의 입력이 됩니다. 그리고 이를 하이퍼볼릭탄젠트 함수의 입력으로 사용하고 이 값은 은닉층의 출력인 은닉 상태가 됩니다. 3. LSTM(Long Short-Term Memory) 위의 그림은 LSTM의 전체적인 내부의 모습을 보여줍니다. 전통적인 RNN의 이러한 단점을 보완한 RNN의 일종을 장단기 메모리(Long Short-Term Memory)라고 하며, 줄여서 LSTM이라고 합니다. LSTM은 은닉층의 메모리 셀에 입력 게이트, 망각 게이트, 출력 게이트를 추가하여 불필요한 기억을<NAME>고, 기억해야 할 것들을 정합니다. 요약하면 LSTM은 은닉 상태(hidden state)를 계산하는 식이 전통적인 RNN보다 조금 더 복잡해졌으며 셀 상태(cell state)라는 값을 추가하였습니다. 위의 그림에서는 t 시점의 셀 상태를 t 로 표현하고 있습니다. LSTM은 RNN과 비교하여 긴 시퀀스의 입력을 처리하는데 탁월한 성능을 보입니다. 셀 상태는 위의 그림에서 왼쪽에서 오른쪽으로 가는 굵은 선입니다. 셀 상태 또한 이전에 배운 은닉 상태처럼 이전 시점의 셀 상태가 다음 시점의 셀 상태를 구하기 위한 입력으로서 사용됩니다. 은닉 상태의 값과 셀 상태의 값을 구하기 위해서 새로 추가된 3개의 게이트를 사용합니다. 각 게이트는 삭제 게이트, 입력 게이트, 출력 게이트라고 부르며 이 3개의 게이트에는 공통적으로 시그모이드 함수가 존재합니다. 시그모이드 함수를 지나면 0과 1사이의 값이 나오게 되는데 이 값들을 가지고 게이트를 조절합니다. 아래의 내용을 참고로 각 게이트에 대해서 알아보겠습니다. 이하 식에서 σ는 시그모이드 함수를 의미합니다. 이하 식에서 tanh는 하이퍼볼릭탄젠트 함수를 의미합니다. x, x, x, x는 t 와 함께 각 게이트에서 사용되는 4개의 가중치입니다. h, h, h, h는 t 1 와 함께 각 게이트에서 사용되는 4개의 가중치입니다. i b, f b는 각 게이트에서 사용되는 4개의 편향입니다. (1) 입력 게이트 t σ ( x x + h h − + i ) t t n ( x x + h h − + g ) 입력 게이트는 현재 정보를 기억하기 위한 게이트입니다. 우선 현재 시점 t의 값과 입력 게이트로 이어지는 가중치 x를 곱한 값과 이전 시점 t-1의 은닉 상태가 입력 게이트로 이어지는 가중치 h를 곱한 값을 더하여 시그모이드 함수를 지납니다. 이를 t 라고 합니다. 그리고 현재 시점 t의 값과 입력 게이트로 이어지는 가중치 x를 곱한 값과 이전 시점 t-1의 은닉 상태가 입력 게이트로 이어지는 가중치 h를 곱한 값을 더하여 하이퍼볼릭탄젠트 함수를 지납니다. 이를 t 라고 합니다. 시그모이드 함수를 지나 0과 1사이의 값을 가지는 t 과 하이퍼볼릭탄젠트 함수를 지나 -1과 1사이의 값을 가지는 t . 이 두 개의 값을 가지고 이번에 선택된 기억할 정보의 양을 정하는데, 구체적으로 어떻게 결정하는지는 아래에서 배우게 될 셀 상태 수식을 참고합니다. (2) 삭제 게이트 t σ ( x x + h h − + f ) 삭제 게이트는 기억을 삭제하기 위한 게이트입니다. 현재 시점 t의 값과 이전 시점 t-1의 은닉 상태가 시그모이드 함수를 지나게 됩니다. 시그모이드 함수를 지나면 0과 1 사이의 값이 나오게 되는데, 이 값이 곧 삭제 과정을 거친 정보의 양입니다. 0에 가까울수록 정보가 많이 삭제된 것이고 1에 가까울수록 정보를 온전히 기억한 것입니다. 이를 가지고 셀 상태를 구하게 되는데, 구체적으로는 아래에서 배우게 될 셀 상태 수식을 참고합니다. (3) 셀 상태 t f ∘ t 1 i ∘ t 셀 상태 t 를 구하는 방법을 알아보겠습니다. 삭제 게이트에서 일부 기억을 잃은 상태입니다. 입력 게이트에서 구한 t g 이 두 개의 값에 대해서 원소별 곱(entrywise product)을 진행합니다. 다시 말해 같은 크기의 두 행렬이 있을 때 같은 위치의 성분끼리 곱하는 것을 말합니다. 여기서는 식으로 로 표현합니다. 이것이 이번에 선택된 기억할 값입니다. 입력 게이트에서 선택된 기억을 삭제 게이트의 결괏값과 더합니다. 이 값을 현재 시점 t의 셀 상태라고 하며, 이 값은 다음 t+1 시점의 LSTM 셀로 넘겨집니다. 삭제 게이트와 입력 게이트의 영향력을 이해해 봅시다. 만약 삭제 게이트의 출력값인 t 가 0이 된다면, 이전 시점의 셀 상태의 값인 t 1 은 현재 시점의 셀 상태의 값을 결정하기 위한 영향력이 0이 되면서, 오직 입력 게이트의 결과만이 현재 시점의 셀 상태의 값 t 을 결정할 수 있습니다. 이는 삭제 게이트가 완전히 닫히고 입력 게이트를 연 상태를 의미합니다. 반대로 입력 게이트의 t 값을 0이라고 한다면, 현재 시점의 셀 상태의 값 t 는 오직 이전 시점의 셀 상태의 값 t 1 의 값에만 의존합니다. 이는 입력 게이트를 완전히 닫고 삭제 게이트만을 연 상태를 의미합니다. 결과적으로 삭제 게이트는 이전 시점의 입력을 얼마나 반영할지를 의미하고, 입력 게이트는 현재 시점의 입력을 얼마나 반영할지를 결정합니다. (4) 출력 게이트와 은닉 상태 t σ ( x x + h h − + o ) t o ∘ a h ( t ) 출력 게이트는 현재 시점 t의 값과 이전 시점 t-1의 은닉 상태가 시그모이드 함수를 지난 값입니다. 해당 값은 현재 시점 t의 은닉 상태를 결정하는 일에 쓰이게 됩니다. 셀 상태의 값이 하이퍼볼릭탄젠트 함수를 지나 -1과 1사이의 값이 되고, 해당 값은 출력 게이트의 값과 연산되면서, 값이 걸러지는 효과가 발생하여 은닉 상태가 됩니다. 은닉 상태의 값은 또한 출력층으로도 향합니다. 08-03 게이트 순환 유닛(Gated Recurrent Unit, GRU) GRU(Gated Recurrent Unit)는 2014년 뉴욕대학교 조경현 교수님이 집필한 논문에서 제안되었습니다. GRU는 LSTM의 장기 의존성 문제에 대한 해결책을 유지하면서, 은닉 상태를 업데이트하는 계산을 줄였습니다. 다시 말해서, GRU는 성능은 LSTM과 유사하면서 복잡했던 LSTM의 구조를 간단화 시켰습니다. 1. GRU(Gated Recurrent Unit) LSTM에서는 출력, 입력, 삭제 게이트라는 3개의 게이트가 존재했습니다. 반면, GRU에서는 업데이트 게이트와 리셋 게이트 두 가지 게이트만이 존재합니다. GRU는 LSTM보다 학습 속도가 빠르다고 알려져 있지만 여러 평가에서 GRU는 LSTM과 비슷한 성능을 보인다고 알려져 있습니다. t σ ( x x + h h − + r ) t σ ( x x + h h − + z ) t t n ( h ( t h − ) W g t b) t ( − t ) g + t h − GRU와 LSTM 중 어떤 것이 모델의 성능 면에서 더 낫다고 단정 지어 말할 수 없으며, 기존에 LSTM을 사용하면서 최적의 하이퍼 파라미터를 찾아낸 상황이라면 굳이 GRU로 바꿔서 사용할 필요는 없습니다. 경험적으로 데이터양이 적을 때는 매개 변수의 양이 적은 GRU가 조금 더 낫고, 데이터양이 더 많으면 LSTM이 더 낫다고도 합니다. GRU보다 LSTM에 대한 연구나 사용량이 더 많은데, 이는 LSTM이 더 먼저 나온 구조이기 때문입니다. 2. 케라스에서의 GRU(Gated Recurrent Unit) 케라스에서는 역시 GRU에 대한 구현을 지원합니다. 사용 방법은 SimpleRNN이나 LSTM과 같습니다. model.add(GRU(hidden_size, input_shape=(timesteps, input_dim))) 08-04 케라스의 SimpleRNN과 LSTM 이해하기 케라스의 SimpleRNN과 LSTM을 이해해 봅니다. 1. 임의의 입력 생성하기 import numpy as np import tensorflow as tf from tensorflow.keras.layers import SimpleRNN, LSTM, Bidirectional 우선 RNN과 LSTM을 테스트하기 위한 임의의 입력을 만듭니다. train_X = [[0.1, 4.2, 1.5, 1.1, 2.8], [1.0, 3.1, 2.5, 0.7, 1.1], [0.3, 2.1, 1.5, 2.1, 0.1], [2.2, 1.4, 0.5, 0.9, 1.1]] print(np.shape(train_X)) (4, 5) 위 입력은 단어 벡터의 차원은 5이고, 문장의 길이가 4인 경우를 가정한 입력입니다. 다시 말해 4번의 시점(timesteps)이 존재하고, 각 시점마다 5차원의 단어 벡터가 입력으로 사용됩니다. 그런데 앞서 RNN은 2D 텐서가 아니라 3D 텐서를 입력을 받는다고 언급한 바 있습니다. 즉, 위에서 만든 2D 텐서를 3D 텐서로 변경합니다. 이는 배치 크기 1을 추가해주므로서 해결합니다. train_X = [[[0.1, 4.2, 1.5, 1.1, 2.8], [1.0, 3.1, 2.5, 0.7, 1.1], [0.3, 2.1, 1.5, 2.1, 0.1], [2.2, 1.4, 0.5, 0.9, 1.1]]] train_X = np.array(train_X, dtype=np.float32) print(train_X.shape) (1, 4, 5) (batch_size, timesteps, input_dim)에 해당되는 (1, 4, 5)의 크기를 가지는 3D 텐서가 생성되었습니다. batch_size는 한 번에 RNN이 학습하는 데이터의 양을 의미하지만, 여기서는 샘플이 1개밖에 없으므로 batch_size는 1입니다. 2. SimpleRNN 이해하기 위에서 생성한 데이터를 SimpleRNN의 입력으로 사용하여 SimpleRNN의 출력값을 이해해 보겠습니다. SimpleRNN에는 여러 인자가 있으며 대표적인 인자로 return_sequences와 return_state가 있습니다. 기본값으로는 둘 다 False로 지정돼 있으므로 별도 지정을 하지 않을 경우에는 False로 처리됩니다. 우선, 은닉 상태의 크기를 3으로 지정하고, 두 인자 값이 모두 False 일 때의 출력값을 보겠습니다. 앞으로의 실습에서 SimpleRNN을 매번<NAME>언하므로 은닉 상태의 값 자체는 매번 초기화되어 이전 출력과 값의 일관성은 없습니다. 그래서 출력값 자체보다는 해당 값의 크기(shape)에 주목해야 합니다. rnn = SimpleRNN(3) # rnn = SimpleRNN(3, return_sequences=False, return_state=False)와 동일. hidden_state = rnn(train_X) print('hidden state : {}, shape: {}'.format(hidden_state, hidden_state.shape)) hidden state : [[-0.866719 0.95010996 -0.99262357]], shape: (1, 3) (1, 3) 크기의 텐서가 출력되는데, 이는 마지막 시점의 은닉 상태입니다. 은닉 상태의 크기를 3으로 지정했음을 주목합시다. 기본적으로 return_sequences가 False인 경우에는 SimpleRNN은 마지막 시점의 은닉 상태만 출력합니다. 이번에는 return_sequences를 True로 지정하여 모든 시점의 은닉 상태를 출력해 봅시다. rnn = SimpleRNN(3, return_sequences=True) hidden_states = rnn(train_X) print('hidden states : {}, shape: {}'.format(hidden_states, hidden_states.shape)) hidden states : [[[ 0.92948604 -0.9985648 0.98355013] [ 0.89172053 -0.9984244 0.191779 ] [ 0.6681082 -0.96070355 0.6493537 ] [ 0.95280755 -0.98054564 0.7224146 ]]], shape: (1, 4, 3) (1, 4, 3) 크기의 텐서가 출력됩니다. 앞서 입력 데이터는 (1, 4, 5)의 크기를 가지는 3D 텐서였고, 그중 4가 시점(timesteps)에 해당하는 값이므로 모든 시점에 대해서 은닉 상태의 값을 출력하여 (1, 4, 3) 크기의 텐서를 출력하는 것입니다. return_state가 True 일 경우에는 return_sequences의 True/False 여부와 상관없이 마지막 시점의 은닉 상태를 출력합니다. 가령, return_sequences가 True이면서, return_state를 True로 할 경우 SimpleRNN은 두 개의 출력을 리턴합니다. rnn = SimpleRNN(3, return_sequences=True, return_state=True) hidden_states, last_state = rnn(train_X) print('hidden states : {}, shape: {}'.format(hidden_states, hidden_states.shape)) print('last hidden state : {}, shape: {}'.format(last_state, last_state.shape)) hidden states : [[[ 0.29839835 -0.99608386 0.2994854 ] [ 0.9160876 0.01154806 0.86181474] [-0.20252597 -0.9270214 0.9696659 ] [-0.5144398 -0.5037417 0.96605766]]], shape: (1, 4, 3) last hidden state : [[-0.5144398 -0.5037417 0.96605766]], shape: (1, 3) 첫 번째 출력은 return_sequences=True로 인한 출력으로 모든 시점의 은닉 상태입니다. 두 번째 출력은 return_state=True로 인한 출력으로 마지막 시점의 은닉 상태입니다. 실제로 출력을 보면 모든 시점의 은닉 상태인 (1, 4, 3) 텐서의 마지막 벡터 값이 return_state=True로 인해 출력된 벡터 값과 일치하는 것을 볼 수 있습니다. (둘 다 [-0.5144398 -0.5037417 0.96605766]) 그렇다면 return_sequences는 False인데, retun_state가 True인 경우는 어떨까요? rnn = SimpleRNN(3, return_sequences=False, return_state=True) hidden_state, last_state = rnn(train_X) print('hidden state : {}, shape: {}'.format(hidden_state, hidden_state.shape)) print('last hidden state : {}, shape: {}'.format(last_state, last_state.shape)) hidden state : [[0.07532981 0.97772664 0.97351676]], shape: (1, 3) last hidden state : [[0.07532981 0.97772664 0.97351676]], shape: (1, 3) 두 개의 출력 모두 마지막 시점의 은닉 상태를 출력하게 됩니다. 3. LSTM 이해하기 실제로 SimpleRNN이 사용되는 경우는 거의 없습니다. 이보다는 LSTM이나 GRU을 주로 사용하는데, 이번에는 임의의 입력에 대해서 LSTM을 사용할 경우를 보겠습니다. 우선 return_sequences를 False로 두고, return_state가 True인 경우를 봅시다. lstm = LSTM(3, return_sequences=False, return_state=True) hidden_state, last_state, last_cell_state = lstm(train_X) print('hidden state : {}, shape: {}'.format(hidden_state, hidden_state.shape)) print('last hidden state : {}, shape: {}'.format(last_state, last_state.shape)) print('last cell state : {}, shape: {}'.format(last_cell_state, last_cell_state.shape)) hidden state : [[-0.00263056 0.20051427 -0.22501363]], shape: (1, 3) last hidden state : [[-0.00263056 0.20051427 -0.22501363]], shape: (1, 3) last cell state : [[-0.04346419 0.44769213 -0.2644241 ]], shape: (1, 3) 이번에는 SimpleRNN 때와는 달리, 세 개의 결과를 반환합니다. return_sequences가 False이므로 우선 첫 번째 결과는 마지막 시점의 은닉 상태입니다. 그런데 LSTM이 SimpleRNN과 다른 점은 return_state를 True로 둔 경우에는 마지막 시점의 은닉 상태뿐만 아니라 셀 상태까지 반환한다는 점입니다. 이번에는 return_sequences를 True로 바꿔보겠습니다. lstm = LSTM(3, return_sequences=True, return_state=True) hidden_states, last_hidden_state, last_cell_state = lstm(train_X) print('hidden states : {}, shape: {}'.format(hidden_states, hidden_states.shape)) print('last hidden state : {}, shape: {}'.format(last_hidden_state, last_hidden_state.shape)) print('last cell state : {}, shape: {}'.format(last_cell_state, last_cell_state.shape)) hidden states : [[[ 0.1383949 0.01107763 -0.00315794] [ 0.0859854 0.03685492 -0.01836833] [-0.02512104 0.12305924 -0.0891041 ] [-0.27381724 0.05733536 -0.04240693]]], shape: (1, 4, 3) last hidden state : [[-0.27381724 0.05733536 -0.04240693]], shape: (1, 3) last cell state : [[-0.39230722 1.5474017 -0.6344505 ]], shape: (1, 3) return_state가 True이므로 두 번째 출력값이 마지막 은닉 상태, 세 번째 출력값이 마지막 셀 상태인 것은 변함없지만 return_sequences가 True이므로 첫 번째 출력값은 모든 시점의 은닉 상태가 출력됩니다. 4. Bidirectional(LSTM) 이해하기 난이도를 조금 올려서 양방향 LSTM의 출력값을 확인해 보겠습니다. return_sequences가 True인 경우와 False인 경우에 대해서 은닉 상태의 값이 어떻게 바뀌는지 직접 비교하기 위해서 이번에는 출력되는 은닉 상태의 값을 고정시켜주겠습니다. k_init = tf.keras.initializers.Constant(value=0.1) b_init = tf.keras.initializers.Constant(value=0) r_init = tf.keras.initializers.Constant(value=0.1) 우선 return_sequences가 False이고, return_state가 True인 경우입니다. bilstm = Bidirectional(LSTM(3, return_sequences=False, return_state=True, \ kernel_initializer=k_init, bias_initializer=b_init, recurrent_initializer=r_init)) hidden_states, forward_h, forward_c, backward_h, backward_c = bilstm(train_X) print('hidden states : {}, shape: {}'.format(hidden_states, hidden_states.shape)) print('forward state : {}, shape: {}'.format(forward_h, forward_h.shape)) print('backward state : {}, shape: {}'.format(backward_h, backward_h.shape)) hidden states : [[0.6303139 0.6303139 0.6303139 0.70387346 0.70387346 0.70387346]], shape: (1, 6) forward state : [[0.6303139 0.6303139 0.6303139]], shape: (1, 3) backward state : [[0.70387346 0.70387346 0.70387346]], shape: (1, 3) 이번에는 무려 5개의 값을 반환합니다. return_state가 True인 경우에는 정방향 LSTM의 은닉 상태와 셀 상태, 역방향 LSTM의 은닉 상태와 셀 상태 4가지를 반환하기 때문입니다. 다만, 셀 상태는 각각 forward_c와 backward_c에 저장만 하고 출력하지 않았습니다. 첫 번째 출력값의 크기가 (1, 6)인 것에 주목합시다. 이는 return_sequences가 False인 경우 정방향 LSTM의 마지막 시점의 은닉 상태와 역방향 LSTM의 첫 번째 시점의 은닉 상태가 연결된 채 반환되기 때문입니다. 그림으로 표현하면 아래와 같이 연결되어 다음층에서 사용됩니다. 마찬가지로 return_state가 True인 경우에 반환한 은닉 상태의 값인 forward_h와 backward_h는 각각 정방향 LSTM의 마지막 시점의 은닉 상태와 역방향 LSTM의 첫 번째 시점의 은닉 상태 값입니다. 그리고 이 두 값을 연결한 값이 hidden_states에 출력되는 값입니다. 이를 이용한 실습은 'RNN을 이용한 텍스트 분류 챕터'에서의 한국어 스팀 리뷰 분류하기 실습( https://wikidocs.net/94748 )을 참고하세요. 정방향 LSTM의 마지막 시점의 은닉 상태 값과 역방향 LSTM의 첫 번째 은닉 상태 값을 기억해둡시다. 정방향 LSTM의 마지막 시점의 은닉 상태 값 : [0.6303139 0.6303139 0.6303139] 역방향 LSTM의 첫 번째 시점의 은닉 상태 값 : [0.70387346 0.70387346 0.70387346] 현재 은닉 상태의 값을 고정시켜두었기 때문에 return_sequences를 True로 할 경우, 출력이 어떻게 바뀌는지 비교가 가능합니다. bilstm = Bidirectional(LSTM(3, return_sequences=True, return_state=True, \ kernel_initializer=k_init, bias_initializer=b_init, recurrent_initializer=r_init)) hidden_states, forward_h, forward_c, backward_h, backward_c = bilstm(train_X) print('hidden states : {}, shape: {}'.format(hidden_states, hidden_states.shape)) print('forward state : {}, shape: {}'.format(forward_h, forward_h.shape)) print('backward state : {}, shape: {}'.format(backward_h, backward_h.shape)) hidden states : [[[0.3590648 0.3590648 0.3590648 0.70387346 0.70387346 0.70387346] [0.5511133 0.5511133 0.5511133 0.5886358 0.5886358 0.5886358 ] [0.5911575 0.5911575 0.5911575 0.39516988 0.39516988 0.39516988] [0.6303139 0.6303139 0.6303139 0.21942243 0.21942243 0.21942243]]], shape: (1, 4, 6) forward state : [[0.6303139 0.6303139 0.6303139]], shape: (1, 3) backward state : [[0.70387346 0.70387346 0.70387346]], shape: (1, 3) hidden states의 출력값에서는 이제 모든 시점의 은닉 상태가 출력됩니다. 역방향 LSTM의 첫 번째 시점의 은닉 상태는 더 이상 정방향 LSTM의 마지막 시점의 은닉 상태와 연결되는 것이 아니라 정방향 LSTM의 첫 번째 시점의 은닉 상태와 연결됩니다. 그림으로 표현하면 다음과 같이 연결되어 다음층의 입력으로 사용됩니다. 08-05 RNN 언어 모델(Recurrent Neural Network Language Model, RNNLM) RNN을 이용하여 언어 모델을 구현한 RNN 언어 모델에 대해서 배웁니다. 1. RNN 언어 모델(Recurrent Neural Network Language Model, RNNLM) 앞서 n-gram 언어 모델과 NNLM은 고정된 개수의 단어만을 입력으로 받아야 한다는 단점이 있었습니다. 하지만 시점(time step)이라는 개념이 도입된 RNN으로 언어 모델을 만들면 입력의 길이를 고정하지 않을 수 있습니다. 이처럼 RNN으로 만든 언어 모델을 RNNLM(Recurrent Neural Network Language Model)이라고 합니다. RNNLM이 언어 모델링을 학습하는 과정을 보겠습니다. 이해를 위해 간소화된 형태로 설명합니다. 예문 : 'what will the fat cat sit on' 예를 들어 훈련 코퍼스에 위와 같은 문장이 있다고 해봅시다. 언어 모델은 주어진 단어 시퀀스로부터 다음 단어를 예측하는 모델입니다. 아래의 그림은 RNNLM이 어떻게 이전 시점의 단어들과 현재 시점의 단어로 다음 단어를 예측하는지를 보여줍니다. RNNLM은 기본적으로 예측 과정에서 이전 시점의 출력을 현재 시점의 입력으로 합니다. RNNLM은 what을 입력받으면, will을 예측하고 이 will은 다음 시점의 입력이 되어 the를 예측합니다. 그리고 the는 또다시 다음 시점의 입력이 되고 해당 시점에서는 fat을 예측합니다. 그리고 이 또한 다시 다음 시점의 입력이 됩니다. 결과적으로 세 번째 시점에서 fat은 앞서 나온 what, will, the라는 시퀀스로 인해 결정된 단어이며, 네 번째 시점의 cat은 앞서 나온 what, will, the, fat이라는 시퀀스로 인해 결정된 단어입니다. 사실 위 과정은 훈련이 끝난 모델의 테스트 과정 동안(실제 사용할 때)의 이야기입니다. 훈련 과정에서는 이전 시점의 예측 결과를 다음 시점의 입력으로 넣으면서 예측하는 것이 아니라, what will the fat cat sit on라는 훈련 샘플이 있다면, what will the fat cat sit 시퀀스를 모델의 입력으로 넣으면, will the fat cat sit on를 예측하도록 훈련됩니다. will, the, fat, cat, sit, on는 각 시점의 레이블입니다. 이러한 RNN 훈련 기법을 교사 강요(teacher forcing)라고 합니다. 교사 강요(teacher forcing)란, 테스트 과정에서 t 시점의 출력이 t+1 시점의 입력으로 사용되는 RNN 모델을 훈련시킬 때 사용하는 훈련 기법입니다. 훈련할 때 교사 강요를 사용할 경우, 모델이 t 시점에서 예측한 값을 t+1 시점에 입력으로 사용하지 않고, t 시점의 레이블. 즉, 실제 알고 있는 정답을 t+1 시점의 입력으로 사용합니다. 물론, 훈련 과정에서도 이전 시점의 출력을 다음 시점의 입력으로 사용하면서 훈련 시킬 수도 있지만 이는 한 번 잘못 예측하면 뒤에서의 예측까지 영향을 미쳐 훈련 시간이 느려지게 되므로 교사 강요를 사용하여 RNN을 좀 더 빠르고 효과적으로 훈련시킬 수 있습니다. 훈련 과정 동안 출력층에서 사용하는 활성화 함수는 소프트맥스 함수입니다. 그리고 모델이 예측한 값과 실제 레이블과의 오차를 계산하기 위해서 손실 함수로 크로스 엔트로피 함수를 사용합니다. 이해를 돕기 위해 앞서 배운 NNLM의 그림과 유사한 형태로 RNNLM을 다시 시각화해보겠습니다. RNNLM의 구조를 보겠습니다. RNNLM은 위의 그림과 같이 총 4개의 층(layer)으로 이루어진 인공 신경망입니다. 우선 입력층(input layer)을 봅시다. RNNLM의 현시점(timestep)은 4로 가정합니다. 그래서 4번째 입력 단어인 fat의 원-핫 벡터가 입력이 됩니다. 출력층(output layer)을 봅시다. 모델이 예측해야 하는 정답에 해당되는 단어 cat의 원-핫 벡터는 출력층에서 모델이 예측한 값의 오차를 구하기 위해 사용될 예정입니다. 그리고 이 오차로부터 손실 함수를 사용해 인공 신경망이 학습을 하게 됩니다. 조금 더 구체적으로 살펴보겠습니다. 현시점의 입력 단어의 원-핫 벡터 t 를 입력받은 RNNLM은 우선 임베딩층(embedding layer)을 지납니다. 이 임베딩층은 기본적으로 NNLM에서 배운 투사층(projection layer)입니다. NNLM에서는 룩업 테이블을 수행하는 층을 투사층라고 표현했지만, 이미 투사층의 결과로 얻는 벡터를 임베딩 벡터라고 부른다고 NNLM에서 학습하였으므로, 앞으로는 임베딩 벡터를 얻는 투사층을 임베딩층(embedding layer)이라는 표현을 사용할 겁니다. 단어 집합의 크기가 V 일 때, 임베딩 벡터의 크기를 M으로 설정하면, 각 입력 단어들은 임베딩층에서 V × M 크기의 임베딩 행렬과 곱해집니다. 여기서 V는 단어 집합의 크기를 의미합니다. 만약 원-핫 벡터의 차원이 7이고, M이 5라면 임베딩 행렬은 7 × 5 행렬이 됩니다. 그리고 이 임베딩 행렬은 역전파 과정에서 다른 가중치들과 함께 학습됩니다. 이는 NNLM에서 이미 배운 개념입니다. 임베딩층 : t l o u ( t ) 여기서부터는 다시 RNN을 복습하는 것과 같습니다. 이 임베딩 벡터는 은닉층에서 이전 시점의 은닉 상태인 t 1 과 함께 다음의 연산을 하여 현재 시점의 은닉 상태 t 를 계산하게 됩니다. 은닉층 : t t n ( x t W h − + ) 출력층에서는 활성화 함수로 소프트맥스(softmax) 함수를 사용하는데, V 차원의 벡터는 소프트맥스 함수를 지나면서 각 원소는 0과 1사이의 실숫값을 가지며 총합은 1이 되는 상태로 바뀝니다. 이렇게 나온 벡터를 RNNLM의 t 시점의 예측값이라는 의미에서 t라고 합시다. 이를 식으로 표현하면 아래와 같습니다. 출력층 : t = o t a ( y t b ) 벡터 t의 각 차원 안에서의 값이 의미하는 것은 이와 같습니다. t의 j 번째 인덱스가 가진 0과 1사이의 값은 j 번째 단어가 다음 단어일 확률을 나타냅니다. 그리고 t는 실제 값. 즉, 실제 정답에 해당되는 단어인 원-핫 벡터의 값에 가까워져야 합니다. 실제 값에 해당되는 다음 단어를 라고 했을 때, 이 두 벡터가 가까워지게 하기 위해서 RNNLM는 손실 함수로 cross-entropy 함수를 사용합니다. 그리고 역전파가 이루어지면서 가중치 행렬들이 학습되는데, 이 과정에서 임베딩 벡터 값들도 학습이 됩니다. 룩업 테이블의 대상이 되는 테이블인 임베딩 행렬을라고 하였을 때, 결과적으로 RNNLM에서 학습 과정에서 학습되는 가중치 행렬은 다음의, x W, y 4개입니다. 뒤의 글자 단위 RNN 실습에서 RNN 언어 모델을 구현해 보면서 훈련 과정과 테스트 과정의 차이를 이해해 보겠습니다. 08-06 RNN을 이용한 텍스트 생성(Text Generation using RNN) 다 대 일(many-to-one) 구조의 RNN을 사용하여 문맥을 반영해서 텍스트를 생성하는 모델을 만들어봅시다. 1. RNN을 이용하여 텍스트 생성하기 예를 들어서 '경마장에 있는 말이 뛰고 있다'와 '그의 말이 법이다'와 '가는 말이 고와야 오는 말이 곱다'라는 세 가지 문장이 있다고 해봅시다. 모델이 문맥을 학습할 수 있도록 전체 문장의 앞의 단어들을 전부 고려하여 학습하도록 데이터를 재구성한다면 아래와 같이 총 11개의 샘플이 구성됩니다. samples y 1 경마장에 있는 2 경마장에 있는 말이 3 경마장에 있는 말이 뛰고 4 경마장에 있는 말이 뛰고 있다 5 그의 말이 6 그의 말이 법이다 7 가는 말이 8 가는 말이 고와야 9 가는 말이 고와야 오는 10 가는 말이 고와야 오는 말이 11 가는 말이 고와야 오는 말이 곱다 1) 데이터에 대한 이해와 전처리 import numpy as np from tensorflow.keras.preprocessing.text import Tokenizer from tensorflow.keras.preprocessing.sequence import pad_sequences from tensorflow.keras.utils import to_categorical 우선 예제로 언급한 3개의 한국어 문장을 저장합니다. text = """경마장에 있는 말이 뛰고 있다\n 그의 말이 법이다\n 가는 말이 고와야 오는 말이 곱다\n""" 단어 집합을 생성하고 크기를 확인해 보겠습니다. 단어 집합의 크기를 저장할 때는 케라스 토크 나이저의 정수 인코딩은 인덱스가 1부터 시작하지만, 패딩을 위한 0을 고려하여 +1을 해줍니다. tokenizer = Tokenizer() tokenizer.fit_on_texts([text]) vocab_size = len(tokenizer.word_index) + 1 print('단어 집합의 크기 : %d' % vocab_size) 단어 집합의 크기 : 12 각 단어와 단어에 부여된 정수 인덱스를 출력해 보겠습니다. print(tokenizer.word_index) {'말이': 1, '경마장에': 2, '있는': 3, '뛰고': 4, '있다': 5, '그의': 6, '법이다': 7, '가는': 8, '고와야': 9, '오는': 10, '곱다': 11} 훈련 데이터를 만들어보겠습니다. sequences = list() for line in text.split('\n'): # 줄바꿈 문자를 기준으로 문장 토큰화 encoded = tokenizer.texts_to_sequences([line])[0] for i in range(1, len(encoded)): sequence = encoded[:i+1] sequences.append(sequence) print('학습에 사용할 샘플의 개수: %d' % len(sequences)) 학습에 사용할 샘플의 개수: 11 샘플의 개수는 총 11개가 나옵니다. 전체 샘플을 출력해 봅시다. print(sequences) [[2, 3], [2, 3, 1], [2, 3, 1, 4], [2, 3, 1, 4, 5], [6, 1], [6, 1, 7], [8, 1], [8, 1, 9], [8, 1, 9, 10], [8, 1, 9, 10, 1], [8, 1, 9, 10, 1, 11]] 위의 데이터는 아직 레이블로 사용될 단어를 분리하지 않은 훈련 데이터입니다. [2, 3]은 [경마장에, 있는]에 해당되며 [2, 3, 1]은 [경마장에, 있는, 말이]에 해당됩니다. 전체 훈련 데이터에 대해서 맨 우측에 있는 단어에 대해서만 레이블로 분리해야 합니다. 우선 전체 샘플에 대해서 길이를 일치시켜 줍니다. 가장 긴 샘플의 길이를 기준으로 합니다. 현재 육안으로 봤을 때, 길이가 가장 긴 샘플은 [8, 1, 9, 10, 1, 11]이고 길이는 6입니다. 이를 코드로는 다음과 같이 구할 수 있습니다. max_len = max(len(l) for l in sequences) # 모든 샘플에서 길이가 가장 긴 샘플의 길이 출력 print('샘플의 최대 길이 : {}'.format(max_len)) 샘플의 최대 길이 : 6 전체 훈련 데이터에서 가장 긴 샘플의 길이가 6임을 확인하였습니다. 전체 샘플의 길이를 6으로 패딩 합니다. sequences = pad_sequences(sequences, maxlen=max_len, padding='pre') pad_sequences()는 모든 샘플에 대해서 0을 사용하여 길이를 맞춰줍니다. maxlen의 값으로 6을 주면 모든 샘플의 길이를 6으로 맞춰주며, padding의 인자로 'pre'를 주면 길이가 6보다 짧은 샘플의 앞에 0으로 채웁니다. 전체 훈련 데이터를 출력해 봅니다. print(sequences) [[ 0 0 0 0 2 3] [ 0 0 0 2 3 1] [ 0 0 2 3 1 4] [ 0 2 3 1 4 5] [ 0 0 0 0 6 1] [ 0 0 0 6 1 7] [ 0 0 0 0 8 1] [ 0 0 0 8 1 9] [ 0 0 8 1 9 10] [ 0 8 1 9 10 1] [ 8 1 9 10 1 11]] 길이가 6보다 짧은 모든 샘플에 대해서 앞에 0을 채워서 모든 샘플의 길이를 6으로 바꿨습니다. 이제 각 샘플의 마지막 단어를 레이블로 분리합시다. 레이블의 분리는 Numpy를 이용해서 가능합니다. 리스트의 마지막 값을 제외하고 저장한 것은 X, 리스트의 마지막 값만 저장한 것은 y. 이는 레이블에 해당됩니다. sequences = np.array(sequences) X = sequences[:,:-1] y = sequences[:,-1] 분리된 X와 y에 대해서 출력해 보면 다음과 같습니다. print(X) [[ 0 0 0 0 2] [ 0 0 0 2 3] [ 0 0 2 3 1] [ 0 2 3 1 4] [ 0 0 0 0 6] [ 0 0 0 6 1] [ 0 0 0 0 8] [ 0 0 0 8 1] [ 0 0 8 1 9] [ 0 8 1 9 10] [ 8 1 9 10 1]] print(y) [ 3 1 4 5 1 7 1 9 10 1 11] 레이블이 분리되었습니다. RNN 모델에 훈련 데이터를 훈련 시키기 전에 레이블에 대해서 원-핫 인코딩을 수행합니다. y = to_categorical(y, num_classes=vocab_size) 원-핫 인코딩이 수행되었는지 출력합니다. print(y) [[0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0.] # 3에 대한 원-핫 벡터 [0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] # 1에 대한 원-핫 벡터 [0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0.] # 4에 대한 원-핫 벡터 [0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0.] # 5에 대한 원-핫 벡터 [0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] # 1에 대한 원-핫 벡터 [0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0.] # 7에 대한 원-핫 벡터 [0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] # 1에 대한 원-핫 벡터 [0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0.] # 9에 대한 원-핫 벡터 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0.] # 10에 대한 원-핫 벡터 [0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] # 1에 대한 원-핫 벡터 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]] # 11에 대한 원-핫 벡터 정상적으로 원-핫 인코딩이 수행된 것을 볼 수 있습니다. 2) 모델 설계하기 RNN 모델에 데이터를 훈련시킵니다. from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Embedding, Dense, SimpleRNN 하이퍼 파라미터인 임베딩 벡터의 차원은 10, 은닉 상태의 크기는 32입니다. 다 대 일 구조의 RNN을 사용합니다. 전결합층(Fully Connected Layer)을 출력층으로 단어 집합 크기만큼의 뉴런을 배치하여 모델을 설계합니다. 해당 모델은 마지막 시점에서 모든 가능한 단어 중 하나의 단어를 예측하는 다중 클래스 분류 문제를 수행하는 모델입니다. 다중 클래스 분류 문제의 경우, 출력층에 소프트맥스 회귀를 사용해야 하므로 활성화 함수로는 소프트맥스 함수를 사용하고, 손실 함수로 크로스 엔트로피 함수를 사용하여 200 에포크를 수행합니다. embedding_dim = 10 hidden_units = 32 model = Sequential() model.add(Embedding(vocab_size, embedding_dim)) model.add(SimpleRNN(hidden_units)) model.add(Dense(vocab_size, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.fit(X, y, epochs=200, verbose=2) 모델이 정확하게 예측하고 있는지 문장을 생성하는 함수를 만들어서 출력해 봅시다. def sentence_generation(model, tokenizer, current_word, n): # 모델, 토크 나이저, 현재 단어, 반복할 횟수 init_word = current_word sentence = '' # n 번 반복 for _ in range(n): # 현재 단어에 대한 정수 인코딩과 패딩 encoded = tokenizer.texts_to_sequences([current_word])[0] encoded = pad_sequences([encoded], maxlen=5, padding='pre') # 입력한 X(현재 단어)에 대해서 Y를 예측하고 Y(예측한 단어)를 result에 저장. result = model.predict(encoded, verbose=0) result = np.argmax(result, axis=1) for word, index in tokenizer.word_index.items(): # 만약 예측한 단어와 인덱스와 동일한 단어가 있다면 break if index == result: break # 현재 단어 + ' ' + 예측 단어를 현재 단어로 변경 current_word = current_word + ' ' + word # 예측 단어를 문장에 저장 sentence = sentence + ' ' + word sentence = init_word + sentence return sentence 입력된 단어로부터 다음 단어를 예측해서 문장을 생성하는 함수를 만들었습니다. '경마장에'라는 단어 뒤에는 총 4개의 단어가 있으므로 4번 예측해 봅시다. print(sentence_generation(model, tokenizer, '경마장에', 4)) 경마장에 있는 말이 뛰고 있다 print(sentence_generation(model, tokenizer, '그의', 2)) 그의 말이 법이다 print(sentence_generation(model, tokenizer, '가는', 5)) 가는 말이 고와야 오는 말이 곱다 앞의 문맥을 기준으로 '말이'라는 단어 다음에 나올 단어를 기존의 훈련 데이터와 일치하게 예측함을 보여줍니다. 이 모델은 충분한 훈련 데이터를 갖고 있지 못하므로 위에서 문장의 길이에 맞게 적절하게 예측해야 하는 횟수 4, 2, 5를 각각 인자 값으로 주었습니다. 이 이상의 숫자를 주면 기계는 '있다', '법이다', '곱다' 다음에 나오는 단어가 무엇인지 배운 적이 없으므로 임의 예측을 합니다. 이번에는 더 많은 훈련 데이터를 가지고 실습해 봅시다. 2. LSTM을 이용하여 텍스트 생성하기 이번에는 LSTM을 통해 보다 많은 데이터로 텍스트를 생성해 보겠습니다. 본질적으로 앞에서 한 것과 동일한 실습입니다. 1) 데이터에 대한 이해와 전처리 사용할 데이터는 뉴욕 타임스 기사의 제목입니다. 아래의 링크에서 ArticlesApril2018.csv 데이터를 다운로드합니다. 파일 다운로드 링크 : https://www.kaggle.com/aashita/nyt-comments import pandas as pd import numpy as np from string import punctuation from tensorflow.keras.preprocessing.text import Tokenizer from tensorflow.keras.preprocessing.sequence import pad_sequences from tensorflow.keras.utils import to_categorical 다운로드한 훈련 데이터를 데이터 프레임에 저장합니다. df = pd.read_csv('ArticlesApril2018.csv') df.head() 책의 지면의 한계로 이번 출력 화면은 생략 열의 개수가 굉장히 많기 때문에 한눈에 보기 어렵습니다. 어떤 열이 있고, 열이 총 몇 개가 있는지 출력해 봅시다. print('열의 개수: ',len(df.columns)) print(df.columns) 열의 개수: 15 Index(['articleID', 'articleWordCount', 'byline', 'documentType', 'headline', 'keywords', 'multimedia', 'newDesk', 'printPage', 'pubDate', 'sectionName', 'snippet', 'source', 'typeOfMaterial', 'webURL'], dtype='object') 총 15개의 열이 존재합니다. 여기서 사용할 열은 제목에 해당되는 headline 열입니다. Null 값이 있는지 확인해 봅시다. print(df['headline'].isnull().values.any()) False Null 값은 별도로 없는 것으로 보입니다. headline 열에서 모든 신문 기사의 제목을 뽑아서 하나의 리스트로 저장해 보도록 하겠습니다. headline = [] # 헤드라인의 값들을 리스트로 저장 headline.extend(list(df.headline.values)) headline[:5] headline이라는 리스트에 모든 신문 기사의 제목을 저장했습니다. 저장한 리스트에서 상위 5개만 출력해 보았습니다. ['Former N.F.L. Cheerleaders’ Settlement Offer: $1 and a Meeting With Goodell', 'E.P.A. to Unveil a New Rule. Its Effect: Less Science in Policymaking.', 'The New Noma, Explained', 'Unknown', 'Unknown'] 네 번째와 다섯 번째 샘플에 Unknown 값이 들어가 있습니다. headline 전체에 걸쳐서 Unknown 값을 가진 샘플이 있을 것으로 추정됩니다. 비록 Null 값은 아니지만 실습에 도움이 되지 않는 노이즈 데이터이므로 제거해 줄 필요가 있습니다. 제거하기 전에 현재 샘플의 개수를 확인해 보고 제거 전, 후의 샘플의 개수를 비교해 봅시다. print('총 샘플의 개수 : {}'.format(len(headline))) 총 샘플의 개수 : 1324 노이즈 데이터를 제거하기 전 신문 기사의 제목 샘플은 총 1,324개입니다. Unknown 값을 가진 샘플을 제거합니다. headline = [word for word in headline if word != "Unknown"] print('노이즈 값 제거 후 샘플의 개수 : {}'.format(len(headline))) 노이즈 값 제거 후 샘플의 개수 : 1214 샘플의 수가 1,324에서 1,214로 110개의 샘플이 제거되었는데 기존에 출력했던 5개의 샘플을 출력해 봅시다. headline[:5] ['Former N.F.L. Cheerleaders’ Settlement Offer: $1 and a Meeting With Goodell', 'E.P.A. to Unveil a New Rule. Its Effect: Less Science in Policymaking.', 'The New Noma, Explained', 'How a Bag of Texas Dirt Became a Times Tradition', 'Is School a Place for Self-Expression?'] 기존에 네 번째, 다섯 번째 샘플에서는 Unknown 값이 있었는데 현재는 제거가 되었습니다. 이제 데이터 전처리를 수행합니다. 여기서 선택한 전처리는 구두점 제거와 단어의 소문자화입니다. 전처리를 수행하고, 다시 샘플 5개를 출력합니다. def repreprocessing(raw_sentence): preproceseed_sentence = raw_sentence.encode("utf8").decode("ascii",'ignore') # 구두점 제거와 동시에 소문자화 return ''.join(word for word in preproceseed_sentence if word not in punctuation).lower() preprocessed_headline = [repreprocessing(x) for x in headline] preprocessed_headline[:5] ['former nfl cheerleaders settlement offer 1 and a meeting with goodell', 'epa to unveil a new rule its effect less science in policymaking', 'the new noma explained', 'how a bag of texas dirt became a times tradition', 'is school a place for selfexpression'] 기존의 출력과 비교하면 모든 단어들이 소문자화되었으며 N.F.L.이나 Cheerleaders’ 등과 같이 기존에 구두점이 붙어있던 단어들에서 구두점이 제거되었습니다. 단어 집합(vocabulary)을 만들고 크기를 확인합니다. tokenizer = Tokenizer() tokenizer.fit_on_texts(preprocessed_headline) vocab_size = len(tokenizer.word_index) + 1 print('단어 집합의 크기 : %d' % vocab_size) 단어 집합의 크기 : 3494 총 3,494개의 단어가 존재합니다. 정수 인코딩을 진행하는 동시에 하나의 문장을 여러 줄로 분해하여 훈련 데이터를 구성합니다. sequences = list() for sentence in preprocessed_headline: # 각 샘플에 대한 정수 인코딩 encoded = tokenizer.texts_to_sequences([sentence])[0] for i in range(1, len(encoded)): sequence = encoded[:i+1] sequences.append(sequence) sequences[:11] [[99, 269], # former nfl [99, 269, 371], # former nfl cheerleaders [99, 269, 371, 1115], # former nfl cheerleaders settlement [99, 269, 371, 1115, 582], # former nfl cheerleaders settlement offer [99, 269, 371, 1115, 582, 52], # 'former nfl cheerleaders settlement offer 1 [99, 269, 371, 1115, 582, 52, 7], # former nfl cheerleaders settlement offer 1 and [99, 269, 371, 1115, 582, 52, 7, 2], # ... 이하 생략 ... [99, 269, 371, 1115, 582, 52, 7, 2, 372], [99, 269, 371, 1115, 582, 52, 7, 2, 372, 10], [99, 269, 371, 1115, 582, 52, 7, 2, 372, 10, 1116], # 모든 단어가 사용된 완전한 첫 번째 문장 # 바로 위의 줄은 : former nfl cheerleaders settlement offer 1 and a meeting with goodell [100, 3]] # epa to에 해당되며 두 번째 문장이 시작됨. 이해를 돕기 위해 출력 결과에 주석을 추가하였습니다. 왜 하나의 문장을 저렇게 나눌까요? 예를 들어 '경마장에 있는 말이 뛰고 있다'라는 문장 하나가 있을 때, 최종적으로 원하는 훈련 데이터의 형태는 다음과 같습니다. 하나의 단어를 예측하기 위해 이전에 등장한 단어들을 모두 참고하는 것입니다. samples y 1 경마장에 있는 2 경마장에 있는 말이 3 경마장에 있는 말이 뛰고 4 경마장에 있는 말이 뛰고 있다 위의 sequences는 모든 문장을 각 단어가 각 시점(time step)마다 하나씩 추가적으로 등장하는 형태로 만들기는 했지만, 아직 예측할 단어에 해당되는 레이블을 분리하는 작업까지는 수행하지 않은 상태입니다. 어떤 정수가 어떤 단어를 의미하는지 알아보기 위해 인덱스로부터 단어를 찾는 index_to_word를 만듭니다. index_to_word = {} for key, value in tokenizer.word_index.items(): # 인덱스를 단어로 바꾸기 위해 index_to_word를 생성 index_to_word[value] = key print('빈도수 상위 582번 단어 : {}'.format(index_to_word[582])) 빈도수 상위 582번 단어 : offer 582이라는 인덱스를 가진 단어는 본래 offer라는 단어였습니다. 원한다면 다른 숫자로도 시도해 보세요. 이제 데이터를 분리하기 전에 전체 샘플의 길이를 동일하게 만드는 패딩 작업을 수행합니다. 패딩 작업을 수행하기 전에 가장 긴 샘플의 길이를 확인합니다. max_len = max(len(l) for l in sequences) print('샘플의 최대 길이 : {}'.format(max_len)) 샘플의 최대 길이 : 24 가장 긴 샘플의 길이인 24로 모든 샘플의 길이를 패딩 하겠습니다. sequences = pad_sequences(sequences, maxlen=max_len, padding='pre') print(sequences[:3]) [[ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 99 269] [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 99 269 371] [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 99 269 371 1115] padding='pre'를 설정하여 샘플의 길이가 24보다 짧은 경우에 앞에 0으로 패딩 되었습니다. 이제 맨 우측 단어만 레이블로 분리합니다. sequences = np.array(sequences) X = sequences[:,:-1] y = sequences[:,-1] print(X[:3]) [[ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 99] [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 99 269] [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 99 269 371] 훈련 데이터 X에서 3개의 샘플만 출력해 보았는데, 맨 우측에 있던 정숫값 269, 371, 1115가 사라진 것을 볼 수 있습니다. 그뿐만 아니라, 각 샘플의 길이가 24에서 23으로 줄었습니다. print(y[:3]) [ 269 371 1115] 훈련 데이터 y 중 3개의 샘플만 출력해 보았는데, 기존 훈련 데이터에서 맨 우측에 있던 정수들이 별도로 저장되었습니다. y = to_categorical(y, num_classes=vocab_size) 레이블 데이터 y에 대해서 원-핫 인코딩을 수행하였습니다. 이제 모델을 설계합니다. 2) 모델 설계하기 from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Embedding, Dense, LSTM 하이퍼 파라미터인 임베딩 벡터의 차원은 10, 은닉 상태의 크기는 128입니다. 다 대 일 구조의 LSTM을 사용합니다. 전결합층(Fully Connected Layer)을 출력층으로 단어 집합 크기만큼의 뉴런을 배치하여 모델을 설계합니다. 해당 모델은 마지막 시점에서 모든 가능한 단어 중 하나의 단어를 예측하는 다중 클래스 분류 문제를 수행하는 모델입니다. 다중 클래스 분류 문제의 경우, 출력층에 소프트맥스 회귀를 사용해야 하므로 활성화 함수로는 소프트맥스 함수를 사용하고, 손실 함수로 크로스 엔트로피 함수를 사용하여 200 에포크를 수행합니다. embedding_dim = 10 hidden_units = 128 model = Sequential() model.add(Embedding(vocab_size, embedding_dim)) model.add(LSTM(hidden_units)) model.add(Dense(vocab_size, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.fit(X, y, epochs=200, verbose=2) 문장을 생성하는 함수 sentence_generation을 만들어서 문장을 생성해 봅시다. def sentence_generation(model, tokenizer, current_word, n): # 모델, 토크 나이저, 현재 단어, 반복할 횟수 init_word = current_word sentence = '' # n 번 반복 for _ in range(n): encoded = tokenizer.texts_to_sequences([current_word])[0] encoded = pad_sequences([encoded], maxlen=max_len-1, padding='pre') # 입력한 X(현재 단어)에 대해서 y를 예측하고 y(예측한 단어)를 result에 저장. result = model.predict(encoded, verbose=0) result = np.argmax(result, axis=1) for word, index in tokenizer.word_index.items(): # 만약 예측한 단어와 인덱스와 동일한 단어가 있다면 if index == result: break # 현재 단어 + ' ' + 예측 단어를 현재 단어로 변경 current_word = current_word + ' ' + word # 예측 단어를 문장에 저장 sentence = sentence + ' ' + word sentence = init_word + sentence return sentence 임의의 단어 'i'에 대해서 10개의 단어를 추가 생성해 봅시다. print(sentence_generation(model, tokenizer, 'i', 10)) i disapprove of school vouchers can i still apply for them 임의의 단어 'how'에 대해서 10개의 단어를 추가 생성해 봅시다. print(sentence_generation(model, tokenizer, 'how', 10)) how to make facebook more accountable will so your neighbor chasing 08-07 문자 단위 RNN(Char RNN) 지금까지 배운 RNN은 전부 입력과 출력의 단위가 단어 벡터였습니다. 하지만 입출력의 단위를 단어 레벨(word-level)에서 문자 레벨(character-level)로 변경하여 RNN을 구현할 수 있습니다. 위의 그림은 문자 단위 RNN을 다 대다(Many-to-Many) 구조로 구현한 경우, 다 대 일(Many-to-One) 구조로 구현한 경우 두 가지를 보여줍니다. 여기서는 이 두 가지 모두 구현해 보겠습니다. 첫 번째로 구현할 것은 다 대다 구조를 이용한 언어 모델입니다. 1. 문자 단위 RNN 언어 모델(Char RNNLM) 이전 시점의 예측 문자를 다음 시점의 입력으로 사용하는 문자 단위 RNN 언어 모델을 구현해 봅시다. 앞서 배운 단어 단위 RNN 언어 모델과 다른 점은 단어 단위가 아니라 문자 단위를 입, 출력으로 사용하므로 임베딩층(embedding layer)을 여기서는 사용하지 않겠습니다. 여기서는 언어 모델의 훈련 과정과 테스트 과정의 차이를 이해하는데 집중합니다. 다운로드 링크 : http://www.gutenberg.org/files/11/11-0.txt 고전 소설들은 저작권에 보호받지 않으므로 무료로 다운로드할 수 있습니다. 위의 링크에서 '이상한 나라의 앨리스(Alice’s Adventures in Wonderland)'라는 소설을 다운로드합니다. 1) 데이터에 대한 이해와 전처리 데이터를 로드하고 특수문자를 제거하고 단어를 소문자화하는 간단한 전처리를 수행합니다. import numpy as np import urllib.request from tensorflow.keras.utils import to_categorical # 데이터 로드 urllib.request.urlretrieve("http://www.gutenberg.org/files/11/11-0.txt", filename="11-0.txt") f = open('11-0.txt', 'rb') sentences = [] for sentence in f: # 데이터로부터 한 줄씩 읽는다. sentence = sentence.strip() # strip()을 통해 \r, \n을 제거한다. sentence = sentence.lower() # 소문자화. sentence = sentence.decode('ascii', 'ignore') # \xe2\x80\x99 등과 같은 바이트 열 제거 if len(sentence) > 0: sentences.append(sentence) f.close() 전처리가 수행된 결과가 리스트에 저장되었습니다. 리스트에서 5개의 원소만 출력해 보겠습니다. sentences[:5] ['the project gutenberg e book of alices adventures in wonderland, by lewis carroll', 'this e book is for the use of anyone anywhere in the united states and', 'most other parts of the world at no cost and with almost no restrictions', 'whatsoever. you may copy it, give it away or re-use it under the terms', 'of the project gutenberg license included with this e book or online at'] 리스트의 원소는 문자열로 구성돼 있는데 의미 있게 문장 토큰 화가 된 상태는 아닙니다. 이를 하나의 문자열로 통합하겠습니다. total_data = ' '.join(sentences) print('문자열의 길이 또는 총 문자의 개수: %d' % len(total_data)) 문자열의 길이 또는 총 문자의 개수: 159484 하나의 문자열로 통합되었고, 문자열의 길이는 약 15만 9천입니다. 일부 출력해 보겠습니다. print(total_data[:200]) the project gutenberg e book of alices adventures in wonderland, by lewis carroll this e book is for the use of anyone anywhere in the united states and most other parts of the world at no cost and with 이 문자열로부터 문자 집합을 만들겠습니다. 기존에는 중복을 제거한 단어들의 모음인 단어 집합(vocabulary)을 만들었으나, 이번에 만들 집합은 단어 집합이 아니라 문자 집합입니다. char_vocab = sorted(list(set(total_data))) vocab_size = len(char_vocab) print ('문자 집합의 크기 : {}'.format(vocab_size)) 문자 집합의 크기 : 56 영어가 훈련 데이터일 때 문자 집합의 크기는 단어 집합을 사용했을 경우보다 집합의 크기가 현저히 작습니다. 아무리 훈련 코퍼스에 수십만 개 이상의 많은 영어 단어가 존재한다고 하더라도, 영어 단어를 표현하기 위해서 사용되는 문자는 26개의 알파벳뿐이기 때문입니다. 만약 훈련 데이터의 알파벳이 대, 소문자가 구분된 상태라고 하더라도 모든 영어 단어는 총 52개의 알파벳으로 표현 가능합니다. 어떤 방대한 양의 텍스트라도 집합의 크기를 적게 가져갈 수 있다는 것은 구현과 테스트를 굉장히 쉽게 할 수 있다는 이점을 가지므로, RNN의 동작 메커니즘 이해를 위한 토이 프로젝트 용도로 유용합니다. 문자 집합의 각 문자에 정수를 부여하고 출력해 보겠습니다. # 문자에 고유한 정수 부여 char_to_index = dict((char, index) for index, char in enumerate(char_vocab)) print('문자 집합 :',char_to_index) 문자 집합 : {' ': 0, '!': 1, '"': 2, '#': 3, '$': 4, '%': 5, "'": 6, '(': 7, ')': 8, '*': 9, ',': 10, '-': 11, '.': 12, '/': 13, '0': 14, '1': 15, '2': 16, '3': 17, '4': 18, '5': 19, '6': 20, '7': 21, '8': 22, '9': 23, ':': 24, ';': 25, '?': 26, '[': 27, ']': 28, '_': 29, 'a': 30, 'b': 31, 'c': 32, 'd': 33, 'e': 34, 'f': 35, 'g': 36, 'h': 37, 'i': 38, 'j': 39, 'k': 40, 'l': 41, 'm': 42, 'n': 43, 'o': 44, 'p': 45, 'q': 46, 'r': 47, 's': 48, 't': 49, 'u': 50, 'v': 51, 'w': 52, 'x': 53, 'y': 54, 'z': 55} 정수 0부터 28까지는 공백을 포함한 각종 구두점, 특수문자가 존재하고, 정수 29부터 54까지는 a부터 z까지 총 26개의 알파벳 소문자가 문자 집합에 포함돼 있습니다. 반대로 정수로부터 문자를 리턴하는 index_to_char을 만듭니다. index_to_char = {} for key, value in char_to_index.items(): index_to_char[value] = key 훈련 데이터를 구성해 보겠습니다. 훈련 데이터 구성을 위한 간소화된 예를 들어봅시다. 훈련 데이터에 apple이라는 시퀀스가 있고, 입력의 길이를 4라고 정하였을 때 데이터의 구성은 어떻게 될까요? 입력의 길이가 4이므로 입력 시퀀스와 예측해야 하는 출력 시퀀스 모두 길이는 4가 됩니다. 다시 말해 RNN은 총 네 번의 시점을(timestep)을 가질 수 있다는 의미입니다. apple은 다섯 글자이지만 입력의 길이는 4이므로 'appl'까지만 입력으로 사용할 수 있습니다. 그리고 언어 모델은 다음 시점의 입력을 예측해야 하는 모델이므로 'pple'를 예측하도록 데이터가 구성됩니다. # appl (입력 시퀀스) -> pple (예측해야 하는 시퀀스) train_X = 'appl' train_y = 'pple' 이제 15만 9천의 길이를 가진 문자열로부터 다수의 샘플들을 만들어보겠습니다. 데이터를 만드는 방법은 문장 샘플의 길이를 정하고, 해당 길이만큼 문자열 전체를 등분하는 것입니다. 여기서는 문장의 길이를 60으로 정했는데, 결국 15만 9천을 60으로 나눈 수가 샘플의 수가 됩니다. 몇 개의 샘플을 만들 수 있을지 그 개수를 계산해 봅시다. seq_length = 60 # 문자열의 길이를 seq_length로 나누면 전처리 후 생겨날 샘플 수 n_samples = int(np.floor((len(total_data) - 1) / seq_length)) print ('샘플의 수 : {}'.format(n_samples)) 샘플의 수 : 2658 여기서는 총 샘플의 수가 2,658개가 될 예정입니다. 이제 전처리를 진행합니다. 전처리가 어떻게 진행되었는지는 전처리 후 얻은 train_X와 train_y를 통해 설명하겠습니다. train_X = [] train_y = [] for i in range(n_samples): # 0:60 -> 60:120 -> 120:180로 loop를 돌면서 문장 샘플을 1개씩 pick. X_sample = total_data[i * seq_length: (i + 1) * seq_length] # 정수 인코딩 X_encoded = [char_to_index[c] for c in X_sample] train_X.append(X_encoded) # 오른쪽으로 1칸 시프트 y_sample = total_data[i * seq_length + 1: (i + 1) * seq_length + 1] y_encoded = [char_to_index[c] for c in y_sample] train_y.append(y_encoded) train_X와 train_y의 첫 번째 샘플을 출력해 봅시다. print('X 데이터의 첫 번째 샘플 :',train_X[0]) print('y 데이터의 첫 번째 샘플 :',train_y[0]) print('-'*50) print('X 데이터의 첫 번째 샘플 디코딩 :',[index_to_char[i] for i in train_X[0]]) print('y 데이터의 첫 번째 샘플 디코딩 :',[index_to_char[i] for i in train_y[0]]) X 데이터의 첫 번째 샘플 : [49, 37, 34, 0, 45, 47, 44, 39, 34, 32, 49, 0, 36, 50, 49, 34, 43, 31, 34, 47, 36, 0, 34, 31, 44, 44, 40, 0, 44, 35, 0, 30, 41, 38, 32, 34, 48, 0, 30, 33, 51, 34, 43, 49, 50, 47, 34, 48, 0, 38, 43, 0, 52, 44, 43, 33, 34, 47, 41, 30] y 데이터의 첫 번째 샘플 : [37, 34, 0, 45, 47, 44, 39, 34, 32, 49, 0, 36, 50, 49, 34, 43, 31, 34, 47, 36, 0, 34, 31, 44, 44, 40, 0, 44, 35, 0, 30, 41, 38, 32, 34, 48, 0, 30, 33, 51, 34, 43, 49, 50, 47, 34, 48, 0, 38, 43, 0, 52, 44, 43, 33, 34, 47, 41, 30, 43] -------------------------------------------------- X 데이터의 첫 번째 샘플 디코딩 : ['t', 'h', 'e', ' ', 'p', 'r', 'o', 'j', 'e', 'c', 't', ' ', 'g', 'u', 't', 'e', 'n', 'b', 'e', 'r', 'g', ' ', 'e', 'b', 'o', 'o', 'k', ' ', 'o', 'f', ' ', 'a', 'l', 'i', 'c', 'e', 's', ' ', 'a', 'd', 'v', 'e', 'n', 't', 'u', 'r', 'e', 's', ' ', 'i', 'n', ' ', 'w', 'o', 'n', 'd', 'e', 'r', 'l', 'a'] y 데이터의 첫 번째 샘플 디코딩 : ['h', 'e', ' ', 'p', 'r', 'o', 'j', 'e', 'c', 't', ' ', 'g', 'u', 't', 'e', 'n', 'b', 'e', 'r', 'g', ' ', 'e', 'b', 'o', 'o', 'k', ' ', 'o', 'f', ' ', 'a', 'l', 'i', 'c', 'e', 's', ' ', 'a', 'd', 'v', 'e', 'n', 't', 'u', 'r', 'e', 's', ' ', 'i', 'n', ' ', 'w', 'o', 'n', 'd', 'e', 'r', 'l', 'a', 'n'] train_y[0]은 train_X[0]에서 오른쪽으로 한 칸 시프트 된 문장임을 알 수 있습니다. train_X와 train_y의 두 번째 샘플. 즉, 인덱스가 1번인 샘플을 출력하여 데이터의 구성을 확인해 봅시다. print(train_X[1]) [43, 33, 10, 0, 31, 54, 0, 41, 34, 52, 38, 48, 0, 32, 30, 47, 47, 44, 41, 41, 0, 49, 37, 38, 48, 0, 34, 31, 44, 44, 40, 0, 38, 48, 0, 35, 44, 47, 0, 49, 37, 34, 0, 50, 48, 34, 0, 44, 35, 0, 30, 43, 54, 44, 43, 34, 0, 30, 43, 54] print(train_y[1]) [33, 10, 0, 31, 54, 0, 41, 34, 52, 38, 48, 0, 32, 30, 47, 47, 44, 41, 41, 0, 49, 37, 38, 48, 0, 34, 31, 44, 44, 40, 0, 38, 48, 0, 35, 44, 47, 0, 49, 37, 34, 0, 50, 48, 34, 0, 44, 35, 0, 30, 43, 54, 44, 43, 34, 0, 30, 43, 54, 52] 마찬가지로 train_y[1]은 train_X[1]에서 오른쪽으로 한 칸 시프트 된 문장임을 알 수 있습니다. 이제 train_X와 train_y에 대해서 원-핫 인코딩을 수행합니다. 문자 단위 RNN에서는 입력 시퀀스에 대해서 워드 임베딩을 하지 않습니다. 다시 말해 임베딩층(embedding layer)을 사용하지 않을 것이므로, 입력 시퀀스인 train_X에 대해서도 원-핫 인코딩을 합니다. train_X = to_categorical(train_X) train_y = to_categorical(train_y) print('train_X의 크기(shape) : {}'.format(train_X.shape)) # 원-핫 인코딩 print('train_y의 크기(shape) : {}'.format(train_y.shape)) # 원-핫 인코딩 train_X의 크기(shape) : (2658, 60, 56) train_y의 크기(shape) : (2658, 60, 56) train_X와 train_y의 크기는 2,658 × 60 × 56입니다. 이는 샘플의 수(No. of samples)가 2,658개, 입력 시퀀스의 길이(input_length)가 60, 각 벡터의 차원(input_dim)이 55임을 의미합니다. 원-핫 벡터의 차원은 문자 집합의 크기인 56이어야 하므로 원-핫 인코딩이 수행되었음을 알 수 있습니다. 2) 모델 설계하기 하이퍼 파라미터인 은닉 상태의 크기는 256입니다. 모델은 다 대다 구조의 LSTM을 사용하며, LSTM 은닉층은 두 개를 사용합니다. 전결합층(Fully Connected Layer)을 출력층으로 문자 집합 크기만큼의 뉴런을 배치하여 모델을 설계합니다. 해당 모델은 모든 시점에서 모든 가능한 문자 중 하나의 문자를 예측하는 다중 클래스 분류 문제를 수행하는 모델입니다. 출력층에 소프트맥스 회귀를 사용해야 하므로 활성화 함수로는 소프트맥스 함수를 사용하고, 손실 함수로 크로스 엔트로피 함수를 사용하여 80 에포크를 수행합니다. from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, LSTM, TimeDistributed hidden_units = 256 model = Sequential() model.add(LSTM(hidden_units, input_shape=(None, train_X.shape[2]), return_sequences=True)) model.add(LSTM(hidden_units, return_sequences=True)) model.add(TimeDistributed(Dense(vocab_size, activation='softmax'))) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.fit(train_X, train_y, epochs=80, verbose=2) 특정 문자를 주면 다음 문자를 계속해서 생성해 내는 sentence_generation 함수를 구현합니다. 인자로 학습한 모델. 그리고 모델로 다음 문자를 몇 번 생성할 것인지 횟수를 전달해 주면, 해당 함수는 임의로 시작 문자를 정한 뒤에 정해진 횟수만큼의 다음 문자를 지속적으로 예측하여 문장을 생성해냅니다. def sentence_generation(model, length): # 문자에 대한 랜덤 한 정수 생성 ix = [np.random.randint(vocab_size)] # 랜덤 한 정수로부터 매핑되는 문자 생성 y_char = [index_to_char[ix[-1]]] print(ix[-1],'번 문자',y_char[-1],'로 예측을 시작!') # (1, length, 55) 크기의 X 생성. 즉, LSTM의 입력 시퀀스 생성 X = np.zeros((1, length, vocab_size)) for i in range(length): # X[0][i][예측한 문자의 인덱스] = 1, 즉, 예측 문자를 다음 입력 시퀀스에 추가 X[0][i][ix[-1]] = 1 print(index_to_char[ix[-1]], end="") ix = np.argmax(model.predict(X[:, :i+1, :])[0], 1) y_char.append(index_to_char[ix[-1]]) return ('').join(y_char) result = sentence_generation(model, 100) print(result) 49 번 문자 u로 예측을 시작! ury-men would have done just as well. the twelve jurors were to say in that dide. he went on in a di' 자세히 보면 사실 말이 되지 않는 문장이지만, 언뜻 보기에 그럴듯해 보이는 문장을 생성해냅니다. 2. 문자 단위 RNN(Char RNN)으로 텍스트 생성하기 이번에는 다 대 일 구조의 RNN을 문자 단위로 학습시키고, 텍스트 생성을 해보겠습니다. 1) 데이터에 대한 이해와 전처리 import numpy as np from tensorflow.keras.utils import to_categorical 다음과 같이 제가 임의로 만든 엉터리 노래 가사가 있습니다. raw_text = ''' I get on with life as a programmer, I like to contemplate beer. But when I start to daydream, My mind turns straight to wine. Do I love wine more than beer? I like to use words about beer. But when I stop my talking, My mind turns straight to wine. I hate bugs and errors. But I just think back to wine, And I'm happy once again. I like to hang out with programming and deep learning. But when left alone, My mind turns straight to wine. ''' 위의 텍스트에 존재하는 단락 구분을 없애고 하나의 문자열로 재저장하겠습니다. tokens = raw_text.split() raw_text = ' '.join(tokens) print(raw_text) I get on with life as a programmer, I like to contemplate beer. But when I start to daydream, My mind turns straight to wine. Do I love wine more than beer? I like to use words about beer. But when I stop my talking, My mind turns straight to wine. I hate bugs and errors. But I just think back to wine, And I'm happy once again. I like to hang out with programming and deep learning. But when left alone, My mind turns straight to wine. 단락 구분이 없어지고 하나의 문자열로 재저장되었습니다. 이로부터 문자 집합을 만들어보겠습니다. 기존에는 중복을 제거한 단어들의 모음인 단어 집합(vocabulary)을 만들었으나, 이번에 만들 집합은 단어 집합이 아니라 문자 집합입니다. # 중복을 제거한 문자 집합 생성 char_vocab = sorted(list(set(raw_text))) vocab_size = len(char_vocab) print('문자 집합 :',char_vocab) print ('문자 집합의 크기 : {}'.format(vocab_size)) 문자 집합 : [' ', "'", ',', '.', '?', 'A', 'B', 'D', 'I', 'M', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'r', 's', 't', 'u', 'v', 'w', 'y'] 문자 집합의 크기 : 33 알파벳 또는 구두점 등의 단위의 집합인 문자 집합이 생성되었습니다. 문자 집합의 크기는 33입니다. char_to_index = dict((char, index) for index, char in enumerate(char_vocab)) # 문자에 고유한 정수 인덱스 부여 print(char_to_index) {' ': 0, "'": 1, ',': 2, '.': 3, '?': 4, 'A': 5, 'B': 6, 'D': 7, 'I': 8, 'M': 9, 'a': 10, 'b': 11, 'c': 12, 'd': 13, 'e': 14, 'f': 15, 'g': 16, 'h': 17, 'i': 18, 'j': 19, 'k': 20, 'l': 21, 'm': 22, 'n': 23, 'o': 24, 'p': 25, 'r': 26, 's': 27, 't': 28, 'u': 29, 'v': 30, 'w': 31, 'y': 32} 이번 실습의 문자 집합의 경우 훈련 데이터에 등장한 알파벳의 대, 소문자를 구분하고 구두점과 공백을 포함하였습니다. 이제 훈련에 사용할 문장 샘플들을 만들어보겠습니다. 여기서는 RNN을 이용한 생성한 텍스트 챕터와 유사하게 데이터를 구성합니다. 다만, 단위가 문자 단위라는 점이 다릅니다. 예를 들어 훈련 데이터에 student라는 단어가 있고, 입력 시퀀스의 길이를 5라고 한다면 입력 시퀀스와 예측해야 하는 문자는 다음과 같이 구성됩니다. 5개의 입력 문자 시퀀스로부터 다음 문자 시퀀스를 예측하는 것입니다. 즉, RNN의 시점(timesteps)은 5번입니다. stude -> n tuden -> t 여기서는 입력 시퀀스의 길이가 10가 되도록 데이터를 구성하겠습니다. 예측 대상인 문자도 필요하므로 길이가 11이 되도록 데이터를 구성합니다. length = 11 sequences = [] for i in range(length, len(raw_text)): seq = raw_text[i-length:i] # 길이 11의 문자열을 지속적으로 만든다. sequences.append(seq) print('총 훈련 샘플의 수: %d' % len(sequences)) 총 훈련 샘플의 수: 426 총 샘플의 수는 426개가 완성되었습니다. 이 중 10개만 출력해 보겠습니다. sequences[:10] ['I get on wi', ' get on wit', 'get on with', 'et on with ', 't on with l', ' on with li', 'on with lif', 'n with life', ' with life ', 'with life a'] 첫 번째 문장이었던 'I get on with life as a programmer,'가 10개의 샘플로 분리된 것을 확인할 수 있습니다. 다른 문장들에 대해서도 sequences에 모두 저장돼 있습니다. 원한다면, sequences[30:45] 등과 같이 인덱스 범위를 변경하여 출력해 보시기 바랍니다. 이제 앞서 만든 char_to_index를 사용하여 전체 데이터에 대해서 정수 인코딩을 수행합니다. encoded_sequences = [] for sequence in sequences: # 전체 데이터에서 문장 샘플을 1개씩 꺼낸다. encoded_sequence = [char_to_index[char] for char in sequence] # 문장 샘플에서 각 문자에 대해서 정수 인코딩을 수행. encoded_sequences.append(encoded_sequence) 정수 인코딩 된 결과가 X에 저장되었습니다. 5개만 출력해 보겠습니다. encoded_sequences[:5] [8, 0, 16, 14, 28, 0, 24, 23, 0, 31, 18] [0, 16, 14, 28, 0, 24, 23, 0, 31, 18, 28] [16, 14, 28, 0, 24, 23, 0, 31, 18, 28, 17] [14, 28, 0, 24, 23, 0, 31, 18, 28, 17, 0] [28, 0, 24, 23, 0, 31, 18, 28, 17, 0, 21] 정수 인코딩이 수행되었습니다. 예측 대상인 문자를 분리시켜주는 작업을 해봅시다. 모든 샘플 문장에 대해서 마지막 문자를 분리하여 마지막 문자가 분리된 샘플은 X_data에 저장하고, 마지막 문자는 y_data에 저장합니다. encoded_sequences = np.array(encoded_sequences) # 맨 마지막 위치의 문자를 분리 X_data = encoded_sequences[:,:-1] # 맨 마지막 위치의 문자를 저장 y_data = encoded_sequences[:,-1] 정상적으로 분리가 되었는지 X와 y 둘 다 5개씩 출력해 보겠습니다. print(X_data[:5]) print(y_data[:5]) [ 8 0 16 14 28 0 24 23 0 31] [ 0 16 14 28 0 24 23 0 31 18] [16 14 28 0 24 23 0 31 18 28] [14 28 0 24 23 0 31 18 28 17] [28 0 24 23 0 31 18 28 17 0] [18 28 17 0 21] 앞서 출력한 5개의 샘플에서 각각 맨 뒤의 문자였던 18, 28, 17, 0, 21이 별도로 분리되어 y에 저장되었습니다. 이제 X와 y에 대해서 원-핫 인코딩을 수행해 보겠습니다. # 원-핫 인코딩 X_data_one_hot = [to_categorical(encoded, num_classes=vocab_size) for encoded in X_data] X_data_one_hot = np.array(X_data_one_hot) y_data_one_hot = to_categorical(y_data, num_classes=vocab_size) 원-핫 인코딩이 수행되었는지 확인하기 위해 수행한 후의 X의 크기(shape)를 보겠습니다. print(X_data_one_hot.shape) (426, 10, 33) 현재 X의 크기는 426 × 10 × 33입니다. 이는 샘플의 수(No. of samples)가 426개, 입력 시퀀스의 길이(input_length)가 10, 각 벡터의 차원(input_dim)이 33임을 의미합니다. 원-핫 벡터의 차원은 문자 집합의 크기인 33이어야 하므로 X에 대해서 원-핫 인코딩이 수행되었음을 알 수 있습니다. 2) 모델 설계하기 하이퍼 파라미터인 은닉 상태의 크기는 64입니다. 모델은 다 대 일 구조의 LSTM을 사용합니다. 전결합층(Fully Connected Layer)을 출력층으로 문자 집합 크기만큼의 뉴런을 배치하여 모델을 설계합니다. 해당 모델은 마지막 시점에서 모든 가능한 문자 중 하나의 문자를 예측하는 다중 클래스 분류 문제를 수행하는 모델입니다. 다중 클래스 분류 문제의 경우, 출력층에 소프트맥스 회귀를 사용해야 하므로 활성화 함수로는 소프트맥스 함수를 사용하고, 손실 함수로 크로스 엔트로피 함수를 사용하여 100 에포크를 수행합니다. from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, LSTM from tensorflow.keras.preprocessing.sequence import pad_sequences hidden_units = 64 model = Sequential() model.add(LSTM(hidden_units, input_shape=(X_data_one_hot.shape[1], X_data_one_hot.shape[2]))) model.add(Dense(vocab_size, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.fit(X_data_one_hot, y_data_one_hot, epochs=100, verbose=2) 문장을 생성하는 함수 sentence_generation을 만들어서 문장을 생성해 봅시다. 해당 함수는 문자열을 입력하면, 해당 문자열로부터 다음 문자를 예측하는 것을 반복하여 최종적으로 문장을 완성합니다. def sentence_generation(model, char_to_index, seq_length, seed_text, n): # 초기 시퀀스 init_text = seed_text sentence = '' # 다음 문자 예측은 총 n 번만 반복. for _ in range(n): encoded = [char_to_index[char] for char in seed_text] # 현재 시퀀스에 대한 정수 인코딩 encoded = pad_sequences([encoded], maxlen=seq_length, padding='pre') # 데이터에 대한 패딩 encoded = to_categorical(encoded, num_classes=len(char_to_index)) # 입력한 X(현재 시퀀스)에 대해서 y를 예측하고 y(예측한 문자)를 result에 저장. result = model.predict(encoded, verbose=0) result = np.argmax(result, axis=1) for char, index in char_to_index.items(): if index == result: break # 현재 시퀀스 + 예측 문자를 현재 시퀀스로 변경 seed_text = seed_text + char # 예측 문자를 문장에 저장 sentence = sentence + char # n 번의 다음 문자 예측이 끝나면 최종 완성된 문장을 리턴. sentence = init_text + sentence return sentence print(sentence_generation(model, char_to_index, 10, 'I get on w', 80)) I get on with life as a programmer, I like to hang out with programming and deep learning. 두 개의 문장이 출력되었습니다. 이 두 문장은 훈련 데이터에서는 연속적으로 나온 적이 없는 두 문장임에도 모델이 임의로 생성해냈습니다. 09. 워드 임베딩(Word Embedding) 텍스트를 컴퓨터가 이해하고, 효율적으로 처리하게 하기 위해서는 컴퓨터가 이해할 수 있도록 텍스트를 적절히 숫자로 변환해야 합니다. 단어를 표현하는 방법에 따라서 자연어 처리의 성능이 크게 달라지기 때문에 단어를 수치화하기 위한 많은 연구가 있었고, 현재에 이르러서는 각 단어를 인공 신경망 학습을 통해 벡터화하는 워드 임베딩이라는 방법이 가장 많이 사용되고 있습니다. 09-01 워드 임베딩(Word Embedding) 워드 임베딩(Word Embedding)은 단어를 벡터로 표현하는 방법으로, 단어를 밀집 표현으로 변환합니다. 희소 표현, 밀집 표현, 그리고 워드 임베딩에 대한 개념을 학습합니다. 1. 희소 표현(Sparse Representation) 앞서 원-핫 인코딩을 통해서 나온 원-핫 벡터들은 표현하고자 하는 단어의 인덱스의 값만 1이고, 나머지 인덱스에는 전부 0으로 표현되는 벡터 표현 방법이었습니다. 이렇게 벡터 또는 행렬(matrix)의 값이 대부분이 0으로 표현되는 방법을 희소 표현(sparse representation)이라고 합니다. 원-핫 벡터는 희소 벡터(sparse vector)입니다. 이러한 희소 벡터의 문제점은 단어의 개수가 늘어나면 벡터의 차원이 한없이 커진다는 점입니다. 원-핫 벡터로 표현할 때는 갖고 있는 코퍼스에 단어가 10,000개였다면 벡터의 차원은 10,000이어야만 했습니다. 심지어 그중에서 단어의 인덱스에 해당되는 부분만 1이고 나머지는 0의 값을 가져야만 했습니다. 단어 집합이 클수록 고차원의 벡터가 됩니다. 예를 들어 단어가 10,000개 있고 인덱스가 0부터 시작하면서 강아지란 단어의 인덱스는 4였다면 원 핫 벡터는 이렇게 표현되어야 했습니다. Ex) 강아지 = [ 0 0 0 0 1 0 0 0 0 0 0 0 ... 중략 ... 0] # 이때 1 뒤의 0의 수는 9995개. 이러한 벡터 표현은 공간적 낭비를 불러일으킵니다. 공간적 낭비를 일으키는 것은 원-핫 벡터뿐만은 아닙니다. 희소 표현의 일종인 DTM과 같은 경우에도 특정 문서에 여러 단어가 다수 등장하였으나, 다른 많은 문서에서는 해당 특정 문서에 등장했던 단어들이 전부 등장하지 않는다면 역시나 행렬의 많은 값이 0이 되면서 공간적 낭비를 일으킵니다. 이러한 관점에서 DTM은 희소 행렬입니다. 원-핫 벡터와 같은 희소 벡터의 문제점은 단어의 의미를 표현하지 못한다는 점입니다. 2. 밀집 표현(Dense Representation) 희소 표현과 반대되는 표현으로 밀집 표현(dense representation)이 있습니다. 밀집 표현은 벡터의 차원을 단어 집합의 크기로 상정하지 않습니다. 사용자가 설정한 값으로 모든 단어의 벡터 표현의 차원을 맞춥니다. 또한, 이 과정에서 더 이상 0과 1만 가진 값이 아니라 실숫값을 가지게 됩니다. 다시 희소 표현의 예를 가져와봅시다. Ex) 강아지 = [ 0 0 0 0 1 0 0 0 0 0 0 0 ... 중략 ... 0] # 이때 1 뒤의 0의 수는 9995개. 차원은 10,000 예를 들어 10,000개의 단어가 있을 때 강아지란 단어를 표현하기 위해서는 위와 같은 표현을 사용했습니다. 하지만 밀집 표현을 사용하고, 사용자가 밀집 표현의 차원을 128로 설정한다면, 모든 단어의 벡터 표현의 차원은 128로 바뀌면서 모든 값이 실수가 됩니다. Ex) 강아지 = [0.2 1.8 1.1 -2.1 1.1 2.8 ... 중략 ...] # 이 벡터의 차원은 128 이 경우 벡터의 차원이 조밀해졌다고 하여 밀집 벡터(dense vector)라고 합니다. 3. 워드 임베딩(Word Embedding) 단어를 밀집 벡터(dense vector)의 형태로 표현하는 방법을 워드 임베딩(word embedding)이라고 합니다. 그리고 이 밀집 벡터를 워드 임베딩 과정을 통해 나온 결과라고 하여 임베딩 벡터(embedding vector)라고도 합니다. 워드 임베딩 방법론으로는 LSA, Word2Vec, FastText, Glove 등이 있습니다. 케라스에서 제공하는 도구인 Embedding()는 앞서 언급한 방법들을 사용하지는 않지만, 단어를 랜덤 한 값을 가지는 밀집 벡터로 변환한 뒤에, 인공 신경망의 가중치를 학습하는 것과 같은 방식으로 단어 벡터를 학습하는 방법을 사용합니다. 아래의 표는 앞서 배운 원-핫 벡터와 지금 배우고 있는 임베딩 벡터의 차이를 보여줍니다. 원-핫 벡터 임베딩 벡터 차원 고차원(단어 집합의 크기) 저차원 다른 표현 희소 벡터의 일종 밀집 벡터의 일종 표현 방법 수동 훈련 데이터로부터 학습함 값의 타입 1과 0 실수 Embedding()을 사용하는 것과 Word2Vec, Glove 등의 방법을 사용하는 것에 대한 비교는 사전 훈련된 워드 임베딩 실습에서 다룹니다. 09-02 워드투벡터(Word2Vec) 앞서 원-핫 벡터는 단어 벡터 간 유의미한 유사도를 계산할 수 없다는 단점이 있음을 언급한 적이 있습니다. 그래서 단어 벡터 간 유의미한 유사도를 반영할 수 있도록 단어의 의미를 수치화할 수 있는 방법이 필요합니다. 이를 위해서 사용되는 대표적인 방법이 워드투벡터(Word2Vec)입니다. Word2Vec의 개념을 설명하기 앞서 Word2Vec가 어떤 일을 할 수 있는지 확인해 보겠습니다. http://w.elnn.kr/search/ 위 사이트는 한국어 단어에 대해서 벡터 연산을 해볼 수 있는 사이트입니다. 위 사이트에서는 단어들(실제로는 Word2Vec 벡터)로 더하기, 빼기 연산을 할 수 있습니다. 예를 들어 아래의 식에서 좌변을 집어넣으면, 우변의 답들이 나옵니다. 한국 - 서울 + 도쿄 = 일본 박찬호 - 야구 + 축구 = 호나우두 신기하게도 단어가 가지고 있는 의미들을 가지고 연산을 하고 있는 것처럼 보입니다. 이런 연산이 가능한 이유는 각 단어 벡터가 단어 벡터 간 유사도를 반영한 값을 가지고 있기 때문입니다. 어떻게 가능한 것일까요? 1. 희소 표현(Sparse Representation) 앞서 원-핫 인코딩을 통해서 얻은 원-핫 벡터는 표현하고자 하는 단어의 인덱스의 값만 1이고, 나머지 인덱스에는 전부 0으로 표현되는 벡터 표현 방법이었습니다. 이와 같이 벡터 또는 행렬의 값이 대부분이 0으로 표현되는 방법을 희소 표현(sparse representation)이라고 합니다. 하지만 이러한 표현 방법은 각 단어 벡터 간 유의미한 유사성을 표현할 수 없다는 단점이 있었고, 대안으로 단어의 의미를 다차원 공간에 벡터화하는 방법을 사용하는데 이러한 표현을 분산 표현(distributed representation)이라고 합니다. 그리고 분산 표현을 이용하여 단어 간 의미적 유사성을 벡터화하는 작업을 워드 임베딩(embedding)이라 부르며 이렇게 표현된 벡터를 임베딩 벡터(embedding vector)라고 합니다. 2. 분산 표현(Distributed Representation) 분산 표현(distributed representation) 방법은 기본적으로 분포 가설(distributional hypothesis)이라는 가정 하에 만들어진 표현 방법입니다. 이 가정은 '비슷한 문맥에서 등장하는 단어들은 비슷한 의미를 가진다'라는 가정입니다. 강아지란 단어는 귀엽다, 예쁘다, 애교 등의 단어가 주로 함께 등장하는데 분포 가설에 따라서 해당 내용을 가진 텍스트의 단어들을 벡터화한다면 해당 단어 벡터들은 유사한 벡터 값을 가집니다. 분산 표현은 분포 가설을 이용하여 텍스트를 학습하고, 단어의 의미를 벡터의 여러 차원에 분산하여 표현합니다. 이렇게 표현된 벡터들은 원-핫 벡터처럼 벡터의 차원이 단어 집합(vocabulary)의 크기일 필요가 없으므로, 벡터의 차원이 상대적으로 저차원으로 줄어듭니다. 예를 들어 갖고 있는 텍스트 데이터에 단어가 10,000개 있고 인덱스는 0부터 시작하며 강아지란 단어의 인덱스는 4였다면 강아지란 단어를 표현하는 원-핫 벡터는 다음과 같습니다. Ex) 강아지 = [ 0 0 0 0 1 0 0 0 0 0 0 0 ... 중략 ... 0] 1이란 값 뒤에 9,995개의 0의 값을 가지는 벡터가 됩니다. 하지만 Word2Vec으로 임베딩 된 벡터는 굳이 벡터 차원이 단어 집합의 크기가 될 필요가 없습니다. 강아지란 단어를 표현하기 위해 사용자가 설정한 차원의 수를 가지는 벡터가 되며 각 차원의 값은 실숫값을 가집니다. Ex) 강아지 = [0.2 0.3 0.5 0.7 0.2 ... 중략 ... 0.2] 요약하면 희소 표현이 고차원에 각 차원이 분리된 표현 방법이었다면, 분산 표현은 저차원에 단어의 의미를 여러 차원에다가 분산하여 표현합니다. 이런 표현 방법을 사용하면 단어 벡터 간 유의미한 유사도를 계산할 수 있습니다. 이를 위한 대표적인 학습 방법이 Word2Vec입니다. 3. CBOW(Continuous Bag of Words) Word2Vec의 학습 방식에는 CBOW(Continuous Bag of Words)와 Skip-Gram 두 가지 방식이 있습니다. CBOW는 주변에 있는 단어들을 입력으로 중간에 있는 단어들을 예측하는 방법입니다. 반대로, Skip-Gram은 중간에 있는 단어들을 입력으로 주변 단어들을 예측하는 방법입니다. 메커니즘 자체는 거의 동일합니다. 먼저 CBOW에 대해서 알아보겠습니다. 이해를 위해 매우 간소화된 예시로 설명합니다. 예문 : "The fat cat sat on the mat" 예를 들어서 갖고 있는 코퍼스에 위와 같은 예문이 있다고 합시다. ['The', 'fat', 'cat', 'on', 'the', 'mat']으로부터 sat을 예측하는 것은 CBOW가 하는 일입니다. 이때 예측해야 하는 단어 sat을 중심 단어(center word)라고 하고, 예측에 사용되는 단어들을 주변 단어(context word)라고 합니다. 중심 단어를 예측하기 위해서 앞, 뒤로 몇 개의 단어를 볼지를 결정해야 하는데 이 범위를 윈도(window)라고 합니다. 예를 들어 윈도 크기가 2이고, 예측하고자 하는 중심 단어가 sat이라고 한다면 앞의 두 단어인 fat와 cat, 그리고 뒤의 두 단어인 on, the를 입력으로 사용합니다. 윈도 크기가 n이라고 한다면, 실제 중심 단어를 예측하기 위해 참고하려고 하는 주변 단어의 개수는 2n입니다. 윈도 크기가 정해지면 윈도를 옆으로 움직여서 주변 단어와 중심 단어의 선택을 변경해가며 학습을 위한 데이터 셋을 만드는데 이 방법을 슬라이딩 윈도(sliding window)라고 합니다. 위 그림에서 좌측의 중심 단어와 주변 단어의 변화는 윈도 크기가 2일 때, 슬라이딩 윈도가 어떤 식으로 이루어지면서 데이터 셋을 만드는지 보여줍니다. Word2Vec에서 입력은 모두 원-핫 벡터가 되어야 하는데, 우측 그림은 중심 단어와 주변 단어를 어떻게 선택했을 때에 따라서 각각 어떤 원-핫 벡터가 되는지를 보여줍니다. 위 그림은 결국 CBOW를 위한 전체 데이터 셋을 보여주는 것입니다. CBOW의 인공 신경망을 간단히 도식화하면 위와 같습니다. 입력층(Input layer)의 입력으로서 앞, 뒤로 사용자가 정한 윈도 크기 범위 안에 있는 주변 단어들의 원-핫 벡터가 들어가게 되고, 출력층(Output layer)에서 예측하고자 하는 중간 단어의 원-핫 벡터가 레이블로서 필요합니다. 위 그림에서 알 수 있는 사실은 Word2Vec은 은닉층이 다수인 딥 러닝(deep learning) 모델이 아니라 은닉층이 1개인 얕은 신경망(shallow neural network)이라는 점입니다. 또한 Word2Vec의 은닉층은 일반적인 은닉층과는 달리 활성화 함수가 존재하지 않으며 룩업 테이블이라는 연산을 담당하는 층으로 투사층(projection layer)이라고 부르기도 합니다. CBOW의 인공 신경망을 좀 더 확대하여, 동작 메커니즘에 대해서 상세하게 알아보겠습니다. 이 그림에서 주목해야 할 것은 두 가지입니다. 하나는 투사층의 크기가 M이라는 점입니다. CBOW에서 투사층의 크기 M은 임베딩하고 난 벡터의 차원이 됩니다. 위의 그림에서 투사층의 크기는 M=5이므로 CBOW를 수행하고 나서 얻는 각 단어의 임베딩 벡터의 차원은 5가 될 것입니다. 두 번째는 입력층과 투사층 사이의 가중치 W는 V × M 행렬이며, 투사층에서 출력층 사이의 가중치 W'는 M × V 행렬이라는 점입니다. 여기서 V는 단어 집합의 크기를 의미합니다. 즉, 위의 그림처럼 원-핫 벡터의 차원이 7이고, M은 5라면 가중치 W는 7 × 5 행렬이고, W'는 5 × 7 행렬이 될 것입니다. 주의할 점은 이 두 행렬은 동일한 행렬을 전치(transpose) 한 것이 아니라, 서로 다른 행렬이라는 점입니다. 인공 신경망의 훈련 전에 이 가중치 행렬 W와 W'는 랜덤 값을 가지게 됩니다. CBOW는 주변 단어로 중심 단어를 더 정확히 맞추기 위해 계속해서 이 W와 W'를 학습해가는 구조입니다. 입력으로 들어오는 주변 단어의 원-핫 벡터와 가중치 W 행렬의 곱이 어떻게 이루어지는지 보겠습니다. 위 그림에서는 각 주변 단어의 원-핫 벡터를 로 표기하였습니다. 입력 벡터는 원-핫 벡터입니다. i 번째 인덱스에 1이라는 값을 가지고 그 외의 0의 값을 가지는 입력 벡터와 가중치 W 행렬의 곱은 사실 W 행렬의 i번째 행을 그대로 읽어오는 것과(lookup) 동일합니다. 이 작업을 룩업 테이블(lookup table)이라고 합니다. 앞서 CBOW의 목적은 W와 W'를 잘 훈련시키는 것이라고 언급한 적이 있는데, 그 이유가 여기서 lookup 해온 W의 각 행벡터가 Word2Vec 학습 후에는 각 단어의 M 차원의 임베딩 벡터로 간주되기 때문입니다. 이렇게 주변 단어의 원-핫 벡터에 대해서 가중치 W가 곱해서 생긴 결과 벡터들은 투사층에서 만나 이 벡터들의 평균인 벡터를 구하게 됩니다. 만약 윈도 크기 n=2라면, 입력 벡터의 총개수는 2n이므로 중간 단어를 예측하기 위해서는 총 4개가 입력 벡터로 사용됩니다. 그렇기 때문에 평균을 구할 때는 4개의 결과 벡터에 대해서 평균을 구하게 됩니다. 투사층에서 벡터의 평균을 구하는 부분은 CBOW가 Skip-Gram과 다른 차이점이기도 합니다. 뒤에서 보게 되겠지만, Skip-Gram은 입력이 중심 단어 하나이기 때문에 투사층에서 벡터의 평균을 구하지 않습니다. 이렇게 구해진 평균 벡터는 두 번째 가중치 행렬 W'와 곱해집니다. 곱셈의 결과로는 원-핫 벡터들과 차원이 V로 동일한 벡터가 나옵니다. 만약 입력 벡터의 차원이 7이었다면 여기서 나오는 벡터도 마찬가지입니다. 이 벡터에 CBOW는 소프트맥스(softmax) 함수를 지나면서 벡터의 각 원소들의 값은 0과 1사이의 실수로, 총합은 1이 됩니다. 다중 클래스 분류 문제를 위한 일종의 스코어 벡터(score vector)입니다. 스코어 벡터의 j 번째 인덱스가 가진 0과 1사이의 값은 j 번째 단어가 중심 단어일 확률을 나타냅니다. 그리고 이 스코어 벡터의 값은 레이블에 해당하는 벡터인 중심 단어 원-핫 벡터의 값에 가까워져야 합니다. 스코어 벡터를 ^ 라고 하겠습니다. 중심 단어의 원-핫 벡터를 로 했을 때, 이 두 벡터 값의 오차를 줄이기 위해 CBOW는 손실 함수(loss function)로 크로스 엔트로피(cross-entropy) 함수를 사용합니다. 크로스 엔트로피 함수에 중심 단어인 원-핫 벡터와 스코어 벡터를 입력값으로 넣고, 이를 식으로 표현하면 다음과 같습니다. 아래의 식에서 V는 단어 집합의 크기입니다. o t ( ^ y ) − j 1 y l g ( j) 역전파(Back Propagation)를 수행하면 W와 W'가 학습이 되는데, 학습이 다 되었다면 M 차원의 크기를 갖는 W의 행렬의 행을 각 단어의 임베딩 벡터로 사용하거나 W와 W' 행렬 두 가지 모두를 가지고 임베딩 벡터를 사용하기도 합니다. 4. Skip-gram CBOW에서는 주변 단어를 통해 중심 단어를 예측했다면, Skip-gram은 중심 단어에서 주변 단어를 예측합니다. 앞서 언급한 예문에 대해서 동일하게 윈도 크기가 2일 때, 데이터 셋은 다음과 같이 구성됩니다. 인공 신경망을 도식화해보면 아래와 같습니다. 중심 단어에 대해서 주변 단어를 예측하므로 투사층에서 벡터들의 평균을 구하는 과정은 없습니다. 여러 논문에서 성능 비교를 진행했을 때 전반적으로 Skip-gram이 CBOW보다 성능이 좋다고 알려져 있습니다. 5. NNLM Vs. Word2Vec 워드 임베딩의 개념 자체는 피드 포워드 신경망 언어 모델(NNLM)을 설명하며 이미 학습한 적이 있습니다. NNLM은 단어 벡터 간 유사도를 구할 수 있도록 워드 임베딩의 개념을 도입하였고, 워드 임베딩 자체에 집중하여 NNLM의 느린 학습 속도와 정확도를 개선하여 탄생한 것이 Word2Vec입니다. NNLM과 Word2Vec의 차이를 비교해 봅시다. 우선 예측하는 대상이 달라졌습니다. NNLM은 다음 단어를 예측하는 언어 모델이 목적이므로 다음 단어를 예측하지만, Word2Vec(CBOW)은 워드 임베딩 자체가 목적이므로 다음 단어가 아닌 중심 단어를 예측하게 하여 학습합니다. 중심 단어를 예측하므로 NNLM이 예측 단어의 이전 단어들만을 참고하였던 것과는 달리, Word2Vec은 예측 단어의 전, 후 단어들을 모두 참고합니다. 구조도 달라졌습니다. 위의 그림은 n을 학습에 사용하는 단어의 수, m을 임베딩 벡터의 차원, h를 은닉층의 크기, V를 단어 집합의 크기라고 하였을 때 NNLM과 Word2Vec의 차이를 보여줍니다. Word2Vec은 우선 NNLM에 존재하던 활성화 함수가 있는 은닉층을 제거하였습니다. 이에 따라 투사층 다음에 바로 출력층으로 연결되는 구조입니다. Word2Vec이 NNLM보다 학습 속도에서 강점을 가지는 이유는 은닉층을 제거한 것뿐만 아니라 추가적으로 사용되는 기법들 덕분이기도 합니다. 대표적인 기법으로 계층적 소프트맥스(hierarchical softmax)와 네거티브 샘플링(negative sampling)이 있는데 이 책에서는 네거티브 샘플링에 대해서 설명합니다. 이는 '네거티브 샘플링을 이용한 Word2Vec 구현' 실습을 참고 바랍니다. Word2Vec과 NNLM의 연산량을 비교하여 학습 속도가 왜 차이 나는지 이해해 봅시다. 우선 입력층에서 투사층, 투사층에서 은닉층, 은닉층에서 출력층으로 향하며 발생하는 NNLM의 연산량을 보겠습니다. NNLM : ( × ) ( × × ) ( × ) 추가적인 기법들까지 사용하였을 때 Word2Vec은 출력층에서의 연산에서 를 o ( ) 로 바꿀 수 있는데 이에 따라 Word2Vec의 연산량은 아래와 같으며 이는 NNLM보다 훨씬 빠른 학습 속도를 가집니다. Word2Vec : ( × ) ( × o ( ) ) 09-03 영어/한국어 Word2Vec 실습 gensim 패키지에서 제공하는 이미 구현된 Word2Vec을 사용하여 영어와 한국어 데이터를 학습합니다. 1. 영어 Word2Vec 만들기 파이썬의 gensim 패키지에는 Word2Vec을 지원하고 있어, gensim 패키지를 이용하면 손쉽게 단어를 임베딩 벡터로 변환시킬 수 있습니다. 영어로 된 코퍼스를 다운로드해 전처리를 수행하고, 전처리한 데이터를 바탕으로 Word2Vec 작업을 진행하겠습니다. import re import urllib.request import zipfile from lxml import etree from nltk.tokenize import word_tokenize, sent_tokenize 1) 훈련 데이터 이해하기 훈련 데이터를 다운로드합니다. # 데이터 다운로드 urllib.request.urlretrieve("https://raw.githubusercontent.com/ukairia777/tensorflow-nlp-tutorial/main/09.%20Word%20Embedding/dataset/ted_en-20160408.xml", filename="ted_en-20160408.xml") 훈련 데이터 파일은 xml 문법으로 작성되어 있어 자연어를 얻기 위해서는 전처리가 필요합니다. 얻고자 하는 실질적 데이터는 영어 문장으로 만 구성된 내용을 담고 있는 <content>와 </content> 사이의 내용입니다. 전처리 작업을 통해 xml 문법들은 제거하고, 해당 데이터만 가져와야 합니다. 뿐만 아니라, <content>와 </content> 사이의 내용 중에는 (Laughter)나 (Applause)와 같은 배경음을 나타내는 단어도 등장하는데 이 또한 제거해야 합니다. <file id="1"> <head> <url>http://www.ted.com/talks/knut_haanaes_two_reasons_companies_fail_and_how_to_avoid_them</url> <pagesize>72832</pagesize> ... xml 문법 중략 ... <content> Here are two reasons companies fail: they only do more of the same, or they only do what's new. To me the real, real solution to quality growth is figuring out the balance between two activities: ... content 내용 중략 ... To me, the irony about the Facit story is hearing about the Facit engineers, who had bought cheap, small electronic calculators in Japan that they used to double-check their calculators. (Laughter) ... content 내용 중략 ... (Applause) </content> </file> <file id="2"> <head> <url>http://www.ted.com/talks/lisa_nip_how_humans_could_evolve_to_survive_in_space<url> ... 이하 중략 ... 2) 훈련 데이터 전처리하기 위 데이터를 위한 전처리 코드는 아래와 같습니다. targetXML = open('ted_en-20160408.xml', 'r', encoding='UTF8') target_text = etree.parse(targetXML) # xml 파일로부터 <content>와 </content> 사이의 내용만 가져온다. parse_text = '\n'.join(target_text.xpath('//content/text()')) # 정규 표현식의 sub 모듈을 통해 content 중간에 등장하는 (Audio), (Laughter) 등의 배경음 부분을 제거. # 해당 코드는 괄호로 구성된 내용을 제거. content_text = re.sub(r'\([^)]*\)', '', parse_text) # 입력 코퍼스에 대해서 NLTK를 이용하여 문장 토큰화를 수행. sent_text = sent_tokenize(content_text) # 각 문장에 대해서 구두점을 제거하고, 대문자를 소문자로 변환. normalized_text = [] for string in sent_text: tokens = re.sub(r"[^a-z0-9]+", " ", string.lower()) normalized_text.append(tokens) # 각 문장에 대해서 NLTK를 이용하여 단어 토큰화를 수행. result = [word_tokenize(sentence) for sentence in normalized_text] print('총 샘플의 개수 : {}'.format(len(result))) 총 샘플의 개수 : 273424 총 샘플의 개수는 약 27만 3천 개입니다. # 샘플 3개만 출력 for line in result[:3]: print(line) ['here', 'are', 'two', 'reasons', 'companies', 'fail', 'they', 'only', 'do', 'more', 'of', 'the', 'same', 'or', 'they', 'only', 'do', 'what', 's', 'new'] ['to', 'me', 'the', 'real', 'real', 'solution', 'to', 'quality', 'growth', 'is', 'figuring', 'out', 'the', 'balance', 'between', 'two', 'activities', 'exploration', 'and', 'exploitation'] ['both', 'are', 'necessary', 'but', 'it', 'can', 'be', 'too', 'much', 'of', 'a', 'good', 'thing'] 상위 3개 문장만 출력해 보았는데 토큰 화가 수행되었음을 볼 수 있습니다. Word2Vec 모델에 텍스트 데이터를 훈련시킵니다. 3) Word2Vec 훈련시키기 from gensim.models import Word2Vec from gensim.models import KeyedVectors model = Word2Vec(sentences=result, vector_size=100, window=5, min_count=5, workers=4, sg=0) Word2Vec의 하이퍼 파라미터 값은 다음과 같습니다. vector_size = 워드 벡터의 특징 값. 즉, 임베딩 된 벡터의 차원. window = 컨텍스트 윈도 크기 min_count = 단어 최소 빈도 수 제한 (빈도가 적은 단어들은 학습하지 않는다.) workers = 학습을 위한 프로세스 수 sg = 0은 CBOW, 1은 Skip-gram. Word2Vec에 대해서 학습을 진행하였습니다. Word2Vec는 입력한 단어에 대해서 가장 유사한 단어들을 출력하는 model.wv.most_similar을 지원합니다. man과 가장 유사한 단어들은 어떤 단어들일까요? model_result = model.wv.most_similar("man") print(model_result) [('woman', 0.842622697353363), ('guy', 0.8178728818893433), ('boy', 0.7774451375007629), ('lady', 0.7767927646636963), ('girl', 0.7583760023117065), ('gentleman', 0.7437191009521484), ('soldier', 0.7413754463195801), ('poet', 0.7060446739196777), ('kid', 0.6925194263458252), ('friend', 0.6572611331939697)] man과 유사한 단어로 woman, guy, boy, lady, girl, gentleman, soldier, kid 등을 출력하는 것을 볼 수 있습니다. Word2Vec를 통해 단어의 유사도를 계산할 수 있게 되었습니다. 4) Word2Vec 모델 저장하고 로드하기 공들여 학습한 모델을 언제든 나중에 다시 사용할 수 있도록 컴퓨터 파일로 저장하고 다시 로드해 보겠습니다. 이 모델을 가지고 향후 시각화를 진행할 예정이므로 꼭 저장해 주세요. model.wv.save_word2vec_format('eng_w2v') # 모델 저장 loaded_model = KeyedVectors.load_word2vec_format("eng_w2v") # 모델 로드 로드한 모델에 대해서 다시 man과 유사한 단어를 출력해 보겠습니다. model_result = loaded_model.most_similar("man") print(model_result) [('woman', 0.842622697353363), ('guy', 0.8178728818893433), ('boy', 0.7774451375007629), ('lady', 0.7767927646636963), ('girl', 0.7583760023117065), ('gentleman', 0.7437191009521484), ('soldier', 0.7413754463195801), ('poet', 0.7060446739196777), ('kid', 0.6925194263458252), ('friend', 0.6572611331939697)] 2. 한국어 Word2Vec 만들기(네이버 영화 리뷰) 네이버 영화 리뷰 데이터로 한국어 Word2Vec을 만들어봅시다. import pandas as pd import matplotlib.pyplot as plt import urllib.request from gensim.models.word2vec import Word2Vec from konlpy.tag import Okt 네이버 영화 리뷰 데이터를 다운로드합니다. urllib.request.urlretrieve("https://raw.githubusercontent.com/e9t/nsmc/master/ratings.txt", filename="ratings.txt") 네이버 영화 리뷰 데이터를 데이터 프레임으로 로드하고 상위 5개의 행을 출력해 봅시다. train_data = pd.read_table('ratings.txt') train_data[:5] # 상위 5개 출력 총 리뷰 개수를 확인해 보겠습니다. print(len(train_data)) # 리뷰 개수 출력 200000 총 20만 개의 샘플이 존재하는데, 결측값 유무를 확인합니다. # NULL 값 존재 유무 print(train_data.isnull().values.any()) True 결측값이 존재하므로 결측값이 존재하는 행을 제거합니다. train_data = train_data.dropna(how = 'any') # Null 값이 존재하는 행 제거 print(train_data.isnull().values.any()) # Null 값이 존재하는지 확인 False 결측값이 삭제된 후의 리뷰 개수를 확인합니다. print(len(train_data)) # 리뷰 개수 출력 199992 총 199,992개의 리뷰가 존재합니다. 정규 표현식을 통해 한글이 아닌 경우 제거하는 전처리를 진행합니다. # 정규 표현식을 통한 한글 외 문자 제거 train_data['document'] = train_data['document'].str.replace("[^ㄱ-ㅎㅏ-ㅣ가-힣 ]","") train_data[:5] # 상위 5개 출력 학습 시에 사용하고 싶지 않은 단어들인 불용어를 제거하겠습니다. 형태소 분석기 Okt를 사용하여 각 문장에 대해서 일종의 단어 내지는 형태소 단위로 나누는 토큰화를 수행합니다. 다소 시간이 소요될 수 있습니다. # 불용어 정의 stopwords = ['의','가','이','은','들','는','좀','잘','그냥','과','도','를','으로','자','에','와','한','하다'] # 형태소 분석기 OKT를 사용한 토큰화 작업 (다소 시간 소요) okt = Okt() tokenized_data = [] for sentence in tqdm(train_data['document']): tokenized_sentence = okt.morphs(sentence, stem=True) # 토큰화 stopwords_removed_sentence = [word for word in tokenized_sentence if not word in stopwords] # 불용어 제거 tokenized_data.append(stopwords_removed_sentence) 토큰 화가 된 상태에서는 각 리뷰의 길이 분포 또한 확인이 가능합니다. # 리뷰 길이 분포 확인 print('리뷰의 최대 길이 :',max(len(review) for review in tokenized_data)) print('리뷰의 평균 길이 :',sum(map(len, tokenized_data))/len(tokenized_data)) plt.hist([len(review) for review in tokenized_data], bins=50) plt.xlabel('length of samples') plt.ylabel('number of samples') plt.show() 리뷰의 최대 길이 : 72 리뷰의 평균 길이 : 10.716703668146726 Word2Vec으로 토큰화된 네이버 영화 리뷰 데이터를 학습합니다. from gensim.models import Word2Vec model = Word2Vec(sentences = tokenized_data, vector_size = 100, window = 5, min_count = 5, workers = 4, sg = 0) 학습이 다 되었다면 Word2Vec 임베딩 행렬의 크기를 확인합니다. # 완성된 임베딩 매트릭스의 크기 확인 model.wv.vectors.shape (16477, 100) 총 16,477개의 단어가 존재하며 각 단어는 100차원으로 구성돼 있습니다. '최민식'과 유사한 단어들을 뽑아봅시다. print(model.wv.most_similar("최민식")) [('한석규', 0.8789200782775879), ('안성기', 0.8757420778274536), ('김수현', 0.855679452419281), ('이민호', 0.854516863822937), ('김명민', 0.8525030612945557), ('최민수', 0.8492398262023926), ('이성재', 0.8478372097015381), ('윤제문', 0.8470626473426819), ('김창완', 0.8456774950027466), ('이주승', 0.8442063927650452)] '히어로'와 유사한 단어들을 뽑아봅시다. print(model.wv.most_similar("히어로")) [('슬래셔', 0.8747539520263672), ('누아르', 0.8666149377822876), ('무협', 0.8423701524734497), ('호러', 0.8372749090194702), ('물의', 0.8365858793258667), ('무비', 0.8260530233383179), ('물', 0.8197994232177734), ('홍콩', 0.8120777606964111), ('블록버스터', 0.8021541833877563), ('블랙', 0.7880141139030457)] 3. 사전 훈련된 Word2Vec 임베딩(Pre-trained Word2Vec embedding) 소개 자연어 처리 작업을 할 때, 케라스의 Embedding()를 사용하여 갖고 있는 훈련 데이터로부터 처음부터 임베딩 벡터를 훈련시키기도 하지만, 위키피디아 등의 방대한 데이터로 사전에 훈련된 워드 임베딩(pre-trained word embedding vector)를 가지고 와서 해당 벡터들의 값을 원하는 작업에 사용할 수도 있습니다. 예를 들어서 감성 분류 작업을 하는데 훈련 데이터의 양이 부족한 상황이라면, 다른 방대한 데이터를 Word2Vec이나 GloVe 등으로 사전에 학습시켜놓은 임베딩 벡터들을 가지고 와서 모델의 입력으로 사용하는 것이 때로는 더 좋은 성능을 얻을 수 있습니다. 사전 훈련된 워드 임베딩을 가져와서 간단히 단어들의 유사도를 구해보는 실습을 해보겠습니다. 실제로 모델에 적용해 보는 실습은 향후에 진행합니다. 구글이 제공하는 사전 훈련된(미리 학습돼 있는) Word2Vec 모델을 사용하는 방법에 대해서 알아보겠습니다. 구글은 사전 훈련된 3백만 개의 Word2Vec 단어 벡터들을 제공합니다. 각 임베딩 벡터의 차원은 300입니다. gensim을 통해서 이 모델을 불러오는 건 매우 간단합니다. 이 모델을 다운로드하고 파일 경로를 기재하면 됩니다. 모델 다운로드 경로 : https://drive.google.com/file/d/0B7XkCwpI5KDYNlNUTTlSS21pQmM/edit 압축 파일의 용량은 약 1.5GB이지만, 파일의 압축을 풀면 약 3.3GB의 파일이 나옵니다. import gensim import urllib.request # 구글의 사전 훈련된 Word2Vec 모델을 로드. urllib.request.urlretrieve("https://s3.amazonaws.com/dl4j-distribution/GoogleNews-vectors-negative300.bin.gz", \ filename="GoogleNews-vectors-negative300.bin.gz") word2vec_model = gensim.models.KeyedVectors.load_word2vec_format('GoogleNews-vectors-negative300.bin.gz', binary=True) 모델의 크기(shape)를 확인해 봅시다. print(word2vec_model.vectors.shape) (3000000, 300) 모델의 크기는 3,000,000 x 300입니다. 즉, 3백만 개의 단어와 각 단어의 차원은 300입니다. 파일의 크기가 3기가가 넘는 이유를 계산해 보면 아래와 같습니다. 3 million words * 300 features * 4bytes/feature = ~3.35GB 사전 훈련된 임베딩을 사용하여 두 단어의 유사도를 계산해 봅시다. print(word2vec_model.similarity('this', 'is')) print(word2vec_model.similarity('post', 'book')) 0.407970363878 0.0572043891977 단어 'book'의 벡터를 출력해 봅시다. print(word2vec_model['book']) [ 0.11279297 -0.02612305 -0.04492188 0.06982422 0.140625 0.03039551 -0.04370117 0.24511719 0.08740234 -0.05053711 0.23144531 -0.07470703 ... 300개의 값이 출력되는 관계로 중략 ... 0.03637695 -0.16796875 -0.01483154 0.09667969 -0.05761719 -0.00515747] 참고 : Word2vec 모델은 자연어 처리에서 단어를 밀집 벡터로 만들어주는 단어 임베딩 방법론이지만 최근에 들어서는 자연어 처리를 넘어서 추천 시스템에도 사용되고 있는 모델입니다. 적당하게 데이터를 나열해 주면 Word2vec은 위치가 근접한 데이터를 유사도가 높은 벡터를 만들어준다는 점에서 착안된 아이디어입니다. 관심 있는 분들은 구글에 'item2vec'을 검색해 보세요. 09-04 네거티브 샘플링을 이용한 Word2Vec 구현(Skip-Gram with Negative Sampling, SGNS) 네거티브 샘플링(Negative Sampling)을 사용하는 Word2Vec을 직접 케라스(Keras)를 통해 구현해 봅시다. 1. 네거티브 샘플링(Negative Sampling) Word2Vec의 출력층에서는 소프트맥스 함수를 지난 단어 집합 크기의 벡터와 실제 값인 원-핫 벡터와의 오차를 구하고 이로부터 임베딩 테이블에 있는 모든 단어에 대한 임베딩 벡터 값을 업데이트합니다. 만약 단어 집합의 크기가 수만 이상에 달한다면 이 작업은 굉장히 무거운 작업이므로, Word2Vec은 꽤나 학습하기에 무거운 모델이 됩니다. Word2Vec은 역전파 과정에서 모든 단어의 임베딩 벡터 값의 업데이트를 수행하지만, 만약 현재 집중하고 있는 중심 단어와 주변 단어가 '강아지'와 '고양이', '귀여운'과 같은 단어라면, 사실 이 단어들과 별 연관 관계가 없는 '돈가스'나 '컴퓨터'와 같은 수많은 단어의 임베딩 벡터 값까지 업데이트하는 것은 비효율적입니다. 네거티브 샘플링은 Word2Vec이 학습 과정에서 전체 단어 집합이 아니라 일부 단어 집합에만 집중할 수 있도록 하는 방법입니다. 가령, 현재 집중하고 있는 주변 단어가 '고양이', '귀여운'이라고 해봅시다. 여기에 '돈가스', '컴퓨터', '회의실'과 같은 단어 집합에서 무작위로 선택된 주변 단어가 아닌 단어들을 일부 가져옵니다. 이렇게 하나의 중심 단어에 대해서 전체 단어 집합보다 훨씬 작은 단어 집합을 만들어놓고 마지막 단계를 이진 분류 문제로 변환합니다. 주변 단어들을 긍정(positive), 랜덤으로 샘플링 된 단어들을 부정(negative)으로 레이블링한다면 이진 분류 문제를 위한 데이터 셋이 됩니다. 이는 기존의 단어 집합의 크기만큼의 선택지를 두고 다중 클래스 분류 문제를 풀던 Word2Vec보다 훨씬 연산량에서 효율적입니다. 2. 네거티브 샘플링 Skip-Gram(Skip-Gram with Negative Sampling, SGNS) 앞서 배운 Skip-gram을 상기해 봅시다. Skip-gram은 중심 단어로부터 주변 단어를 예측하는 모델이었습니다. 위와 같은 문장이 있다고 한다면, Skip-gram은 중심 단어 cat으로부터 주변 단어 The, fat, sat, on을 예측합니다. 기존의 Skip-gram 모델을 일종의 주황 박스로 생각해 본다면, 아래의 그림과 같이 입력은 중심 단어, 모델의 예측은 주변 단어인 구조입니다. 하지만 네거티브 샘플링을 사용하는 Skip-gram(Skip-Gram with Negative Sampling, SGNS) 이하 SGNS는 이와는 다른 접근 방식을 취합니다. SGNS는 다음과 같이 중심 단어와 주변 단어가 모두 입력이 되고, 이 두 단어가 실제로 윈도 크기 내에 존재하는 이웃 관계인지 그 확률을 예측합니다. 기존의 Skip-gram 데이터 셋을 SGNS의 데이터 셋으로 바꾸는 과정을 봅시다. 위의 그림에서 좌측의 테이블은 기존의 Skip-gram을 학습하기 위한 데이터 셋입니다. Skip-gram은 기본적으로 중심 단어를 입력, 주변 단어를 레이블로 합니다. 하지만 SGNS를 학습하고 싶다면, 이 데이터 셋을 우측의 테이블과 같이 수정할 필요가 있습니다. 우선, 기존의 Skip-gram 데이터 셋에서 중심 단어와 주변 단어를 각각 입력 1, 입력 2로 둡니다. 이 둘은 실제로 윈도 크기 내에서 이웃 관계였므로 레이블은 1로 합니다. 이제 레이블이 0인 샘플들을 준비할 차례입니다. 실제로는 입력 1(중심 단어)와 주변 단어 관계가 아닌 단어들을 입력 2로 삼기 위해서 단어 집합에서 랜덤으로 선택한 단어들을 입력 2로 하고, 레이블을 0으로 합니다. 이제 이 데이터 셋은 입력 1과 입력 2가 실제로 윈도 크기 내에서 이웃 관계인 경우에는 레이블이 1, 아닌 경우에는 레이블이 0인 데이터 셋이 됩니다. 그리고 이제 두 개의 임베딩 테이블을 준비합니다. 두 임베딩 테이블은 훈련 데이터의 단어 집합의 크기를 가지므로 크기가 같습니다. 두 테이블 중 하나는 입력 1인 중심 단어의 테이블 룩 업을 위한 임베딩 테이블이고, 하나는 입력 2인 주변 단어의 테이블 룩 업을 위한 임베딩 테이블입니다. 각 단어는 각 임베딩 테이블을 테이블 룩 업하여 임베딩 벡터로 변환됩니다. 각 임베딩 테이블을 통해 테이블 룩 업하여 임베딩 벡터로 변환되었다면 그 후의 연산은 매우 간단합니다. 중심 단어와 주변 단어의 내적 값을 이 모델의 예측값으로 하고, 레이블과의 오차로부터 역전파 하여 중심 단어와 주변 단어의 임베딩 벡터 값을 업데이트합니다. 학습 후에는 좌측의 임베딩 행렬을 임베딩 벡터로 사용할 수도 있고, 두 행렬을 더한 후 사용하거나 두 행렬을 연결(concatenate) 해서 사용할 수도 있습니다. 아래의 실습에서는 좌측의 행렬을 사용하는 방식을 택했습니다. 3. 20뉴스 그룹 데이터 전처리하기 import pandas as pd import numpy as np import nltk from nltk.corpus import stopwords from sklearn.datasets import fetch_20newsgroups from tensorflow.keras.preprocessing.text import Tokenizer 20뉴스 그룹 데이터를 사용합니다. 이번 실습에서는 하나의 샘플에 최소 단어 2개는 있어야 합니다. 그래야만 중심 단어, 주변 단어의 관계가 성립하며 그렇지 않으면 샘플을 구성할 수 없어 에러가 발생합니다. 전처리 과정에서 지속적으로 이를 만족하지 않는 샘플들을 제거하겠습니다. dataset = fetch_20newsgroups(shuffle=True, random_state=1, remove=('headers', 'footers', 'quotes')) documents = dataset.data print('총 샘플 수 :',len(documents)) 총 샘플 수 : 11314 총 샘플 수는 11,314개입니다. 전처리를 진행해 봅시다. 불필요한 토큰을 제거하고, 소문자화를 통해 정규화를 진행합니다. news_df = pd.DataFrame({'document':documents}) # 특수 문자 제거 news_df['clean_doc'] = news_df['document'].str.replace("[^a-zA-Z]", " ") # 길이가 3이하인 단어는 제거 (길이가 짧은 단어 제거) news_df['clean_doc'] = news_df['clean_doc'].apply(lambda x: ' '.join([w for w in x.split() if len(w)>3])) # 전체 단어에 대한 소문자 변환 news_df['clean_doc'] = news_df['clean_doc'].apply(lambda x: x.lower()) 현재 데이터 프레임에 Null 값이 있는지 확인합니다. news_df.isnull().values.any() False Null 값이 없지만, 빈 값(empy) 유무도 확인해야 합니다. 모든 빈 값을 Null 값으로 변환하고, 다시 Null 값이 있는지 확인합니다. news_df.replace("", float("NaN"), inplace=True) news_df.isnull().values.any() True Null 값이 있음을 확인했습니다. Null 값을 제거합니다. news_df.dropna(inplace=True) print('총 샘플 수 :',len(news_df)) 총 샘플 수 : 10995 샘플 수가 일부 줄어든 것을 확인할 수 있습니다. NLTK에서 정의한 불용어 리스트를 사용하여 불용어를 제거합니다. # 불용어를 제거 stop_words = stopwords.words('english') tokenized_doc = news_df['clean_doc'].apply(lambda x: x.split()) tokenized_doc = tokenized_doc.apply(lambda x: [item for item in x if item not in stop_words]) tokenized_doc = tokenized_doc.to_list() 불용어를 제거하였으므로 단어의 수가 줄어들었습니다. 모든 샘플 중 단어가 1개 이하인 경우를 모두 찾아 제거하겠습니다. # 단어가 1개 이하인 샘플의 인덱스를 찾아서 저장하고, 해당 샘플들은 제거. drop_train = [index for index, sentence in enumerate(tokenized_doc) if len(sentence) <= 1] tokenized_doc = np.delete(tokenized_doc, drop_train, axis=0) print('총 샘플 수 :',len(tokenized_doc)) 총 샘플 수 : 10940 샘플 수가 다시 줄어들었습니다. 단어 집합을 생성하고, 정수 인코딩을 진행합니다. tokenizer = Tokenizer() tokenizer.fit_on_texts(tokenized_doc) word2idx = tokenizer.word_index idx2word = {value : key for key, value in word2idx.items()} encoded = tokenizer.texts_to_sequences(tokenized_doc) 상위 2개의 샘플을 출력해 봅시다. print(encoded[:2]) [[9, 59, 603, 207, 3278, 1495, 474, 702, 9470, 13686, 5533, 15227, 702, 442, 702, 70, 1148, 1095, 1036, 20294, 984, 705, 4294, 702, 217, 207, 1979, 15228, 13686, 4865, 4520, 87, 1530, 6, 52, 149, 581, 661, 4406, 4988, 4866, 1920, 755, 10668, 1102, 7837, 442, 957, 10669, 634, 51, 228, 2669, 4989, 178, 66, 222, 4521, 6066, 68, 4295], [1026, 532, 2, 60, 98, 582, 107, 800, 23, 79, 4522, 333, 7838, 864, 421, 3825, 458, 6488, 458, 2700, 4730, 333, 23, 9, 4731, 7262, 186, 310, 146, 170, 642, 1260, 107, 33568, 13, 985, 33569, 33570, 9471, 11491]] 단어 집합의 크기를 확인합니다. vocab_size = len(word2idx) + 1 print('단어 집합의 크기 :', vocab_size) 단어 집합의 크기 : 64277 총 64,277개의 단어가 존재합니다. 4. 네거티브 샘플링을 통한 데이터 셋 구성하기 토큰화, 정제, 정규화, 불용어 제거, 정수 인코딩까지 일반적인 전처리 과정을 거쳤습니다. 네거티브 샘플링을 통한 데이터 셋을 구성할 차례입니다. 이를 위해서는 네거티브 샘플링을 위해서 케라스에서 제공하는 전처리 도구인 skipgrams를 사용합니다. 어떤 전처리가 수행되는지 그 결과를 확인하기 위해서 (꽤 시간이 소요되는 작업이므로) 상위 10개의 뉴스그룹 샘플에 대해서만 수행해 봅시다. from tensorflow.keras.preprocessing.sequence import skipgrams # 네거티브 샘플링 skip_grams = [skipgrams(sample, vocabulary_size=vocab_size, window_size=10) for sample in encoded[:10]] 결과를 확인합니다. 10개의 뉴스그룹 샘플에 대해서 모두 수행되었지만, 첫 번째 뉴스그룹 샘플에 대해서만 확인해 보겠습니다. # 첫 번째 샘플인 skip_grams[0] 내 skipgrams로 형성된 데이터 셋 확인 pairs, labels = skip_grams[0][0], skip_grams[0][1] for i in range(5): print("({:s} ({:d}), {:s} ({:d})) -> {:d}".format( idx2word[pairs[i][0]], pairs[i][0], idx2word[pairs[i][1]], pairs[i][1], labels[i])) (commited (7837), badar (34572)) -> 0 (whole (217), realize (1036)) -> 1 (reason (149), commited (7837)) -> 1 (letter (705), rediculous (15227)) -> 1 (reputation (5533), midonrnax (47527)) -> 0 윈도 크기 내에서 중심 단어, 주변 단어의 관계를 가지는 경우에는 1의 레이블을 갖도록 하고, 그렇지 않은 경우는 0의 레이블을 가지도록 하여 데이터 셋을 구성합니다. 이 과정은 각각의 뉴스그룹 샘플에 대해서 동일한 프로세스로 수행됩니다. print('전체 샘플 수 :',len(skip_grams)) 전체 샘플 수 : 10 encoded 중 상위 10개의 뉴스그룹 샘플에 대해서만 수행하였으므로 10이 출력됩니다. 그리고 10개의 뉴스그룹 샘플 각각은 수많은 중심 단어, 주변 단어의 쌍으로 된 샘플들을 갖고 있습니다. 첫 번째 뉴스그룹 샘플이 가지고 있는 pairs와 labels의 개수를 출력해 봅시다. # 첫 번째 뉴스그룹 샘플에 대해서 생긴 pairs와 labels의 개수 print(len(pairs)) print(len(labels)) 2220 2220 이 작업을 모든 뉴스그룹 샘플에 대해서 수행합니다. skip_grams = [skipgrams(sample, vocabulary_size=vocab_size, window_size=10) for sample in encoded] 5. Skip-Gram with Negative Sampling(SGNS) 구현하기 from tensorflow.keras.models import Sequential, Model from tensorflow.keras.layers import Embedding, Reshape, Activation, Input from tensorflow.keras.layers import Dot from tensorflow.keras.utils import plot_model from IPython.display import SVG 하이퍼 파라미터인 임베딩 벡터의 차원은 100으로 정하고, 두 개의 임베딩 층을 추가합니다. embedding_dim = 100 # 중심 단어를 위한 임베딩 테이블 w_inputs = Input(shape=(1, ), dtype='int32') word_embedding = Embedding(vocab_size, embedding_dim)(w_inputs) # 주변 단어를 위한 임베딩 테이블 c_inputs = Input(shape=(1, ), dtype='int32') context_embedding = Embedding(vocab_size, embedding_dim)(c_inputs) 각 임베딩 테이블은 중심 단어와 주변 단어 각각을 위한 임베딩 테이블이며 각 단어는 임베딩 테이블을 거쳐서 내적을 수행하고, 내적의 결과는 1 또는 0을 예측하기 위해서 시그모이드 함수를 활성화 함수로 거쳐 최종 예측값을 얻습니다. dot_product = Dot(axes=2)([word_embedding, context_embedding]) dot_product = Reshape((1, ), input_shape=(1, 1))(dot_product) output = Activation('sigmoid')(dot_product) model = Model(inputs=[w_inputs, c_inputs], outputs=output) model.summary() model.compile(loss='binary_crossentropy', optimizer='adam') plot_model(model, to_file='model3.png', show_shapes=True, show_layer_names=True, rankdir='TB') 모델의 학습은 5에포크 수행하겠습니다. for epoch in range(1, 6): loss = 0 for _, elem in enumerate(skip_grams): first_elem = np.array(list(zip(*elem[0]))[0], dtype='int32') second_elem = np.array(list(zip(*elem[0]))[1], dtype='int32') labels = np.array(elem[1], dtype='int32') X = [first_elem, second_elem] Y = labels loss += model.train_on_batch(X, Y) print('Epoch :',epoch, 'Loss :',loss) Epoch: 1 Loss: 4339.997158139944 Epoch: 2 Loss: 3549.69356325455 Epoch: 3 Loss: 3295.072506020777 Epoch: 4 Loss: 3038.1063768607564 Epoch: 5 Loss: 2790.9479411702487 6. 결과 확인하기 학습된 모델의 결과를 확인해 보겠습니다. 학습된 임베딩 벡터들을 vector.txt에 저장합니다. 그 후 이를 gensim의 models.KeyedVectors.load_word2vec_format()으로 로드하면 쉽게 단어 벡터 간 유사도를 구할 수 있습니다. import gensim f = open('vectors.txt' ,'w') f.write('{} {}\n'.format(vocab_size-1, embed_size)) vectors = model.get_weights()[0] for word, i in tokenizer.word_index.items(): f.write('{} {}\n'.format(word, ' '.join(map(str, list(vectors[i, :]))))) f.close() # 모델 로드 w2v = gensim.models.KeyedVectors.load_word2vec_format('./vectors.txt', binary=False) w2v.most_similar(positive=['soldiers']) [('lebanese', 0.7539176940917969), ('troops', 0.7515299916267395), ('occupying', 0.7322258949279785), ('attacking', 0.7247686386108398), ('villagers', 0.7217503786087036), ('israeli', 0.7071422338485718), ('villages', 0.7000206708908081), ('wounded', 0.6976917386054993), ('lebanon', 0.6933401823043823), ('arab', 0.692956268787384)] w2v.most_similar(positive=['doctor']) [('nerve', 0.6576169729232788), ('migraine', 0.6502577066421509), ('patient', 0.6377599835395813), ('disease', 0.6300654411315918), ('quack', 0.6101700663566589), ('cardiac', 0.606243371963501), ('infection', 0.6030253171920776), ('medication', 0.6001783013343811), ('suffering', 0.593578040599823), ('hurt', 0.5818471908569336)] w2v.most_similar(positive=['police']) [('prohibit', 0.6182408332824707), ('provisions', 0.5706381797790527), ('cops', 0.565453290939331), ('army', 0.563193142414093), ('possess', 0.5538119673728943), ('armed', 0.5535427331924438), ('rkba', 0.5533647537231445), ('ksanti', 0.5518242716789246), ('courts', 0.5495947599411011), ('officers', 0.5477950572967529)] w2v.most_similar(positive=['knife']) [('knives', 0.7748741507530212), ('caucasus', 0.7227305769920349), ('defence', 0.7217429280281067), ('males', 0.7207540273666382), ('heretics', 0.7145630717277527), ('azerbaijanis', 0.7136125564575195), ('advocate', 0.7055186629295349), ('officers', 0.7020978927612305), ('punished', 0.7012225389480591), ('taxation', 0.7001351118087769)] w2v.most_similar(positive=['engine']) [('brakes', 0.7013274431228638), ('cylinder', 0.6680346727371216), ('brake', 0.6459399461746216), ('seat', 0.6365581154823303), ('gasoline', 0.6263373494148254), ('honda', 0.611443281173706), ('mounted', 0.6093355417251587), ('ventilator', 0.5999234318733215), ('adjustable', 0.5938659310340881), ('propellants', 0.5935063362121582)] 09-05) 글로브(GloVe) 글로브(Global Vectors for Word Representation, GloVe)는 카운트 기반과 예측 기반을 모두 사용하는 방법론으로 2014년에 미국 스탠퍼드 대학에서 개발한 단어 임베딩 방법론입니다. 앞서 학습하였던 기존의 카운트 기반의 LSA(Latent Semantic Analysis)와 예측 기반의 Word2Vec의 단점을 지적하며 이를 보완한다는 목적으로 나왔고, 실제로도 Word2Vec 만큼 뛰어난 성능을 보여줍니다. 현재까지의 연구에 따르면 단정적으로 Word2Vec와 GloVe 중에서 어떤 것이 더 뛰어나다고 말할 수는 없고, 이 두 가지 전부를 사용해 보고 성능이 더 좋은 것을 사용하는 것이 바람직합니다. 1. 기존 방법론에 대한 비판 기존의 방법론을 언급해 보겠습니다. LSA는 DTM이나 TF-IDF 행렬과 같이 각 문서에서의 각 단어의 빈도수를 카운트 한 행렬이라는 전체적인 통계 정보를 입력으로 받아 차원을 축소(Truncated SVD) 하여 잠재된 의미를 끌어내는 방법론이었습니다. 반면, Word2Vec는 실제 값과 예측값에 대한 오차를 손실 함수를 통해 줄여나가며 학습하는 예측 기반의 방법론이었습니다. 서로 다른 방법을 사용하는 이 두 방법론은 각각 장, 단점이 있습니다. LSA는 카운트 기반으로 코퍼스의 전체적인 통계 정보를 고려하기는 하지만, 왕:남자 = 여왕:? (정답은 여자)와 같은 단어 의미의 유추 작업(Analogy task)에는 성능이 떨어집니다. Word2Vec는 예측 기반으로 단어 간 유추 작업에는 LSA보다 뛰어나지만, 임베딩 벡터가 윈도 크기 내에서만 주변 단어를 고려하기 때문에 코퍼스의 전체적인 통계 정보를 반영하지 못합니다. GloVe는 이러한 기존 방법론들의 각각의 한계를 지적하며, LSA의 메커니즘이었던 카운트 기반의 방법과 Word2Vec의 메커니즘이었던 예측 기반의 방법론 두 가지를 모두 사용합니다. 2. 윈도 기반 동시 등장 행렬(Window based Co-occurrence Matrix) 단어의 동시 등장 행렬은 행과 열을 전체 단어 집합의 단어들로 구성하고, i 단어의 윈도 크기(Window Size) 내에서 k 단어가 등장한 횟수를 i 행 k 열에 기재한 행렬을 말합니다. 예제를 보면 어렵지 않습니다. 아래와 같은 3개 문서로 구성된 텍스트 데이터가 있다고 해봅시다. I like deep learning I like NLP I enjoy flying 윈도 크기가 N 일 때는 좌, 우에 존재하는 N 개의 단어만 참고하게 됩니다. 윈도 크기가 1일 때, 위의 텍스트를 가지고 구성한 동시 등장 행렬은 다음과 같습니다. 카운트 I like enjoy deep learning NLP flying I 0 2 1 0 0 0 0 like 2 0 0 1 0 1 0 enjoy 1 0 0 0 0 0 1 deep 0 1 0 0 1 0 0 learning 0 0 0 1 0 0 0 NLP 0 1 0 0 0 0 0 flying 0 0 1 0 0 0 0 위 행렬은 행렬을 전치(Transpose) 해도 동일한 행렬이 된다는 특징이 있습니다. 그 이유는 i 단어의 윈도 크기 내에서 k 단어가 등장한 빈도는 반대로 k 단어의 윈도 크기 내에서 i 단어가 등장한 빈도와 동일하기 때문입니다. 위의 테이블은 스탠퍼드 대학교의 자연어 처리 강의를 참고하였습니다. 링크 : http://web.stanford.edu/class/cs224n/slides/cs224n-2019-lecture02-wordvecs2.pdf 3. 동시 등장 확률(Co-occurrence Probability) 동시 등장 행렬에 대해서 이해했으니, 동시 등장 확률에 대해서 이해해 봅시다. 아래의 표는 어떤 동시 등장 행렬을 가지고 정리한 동시 등장 확률(Co-occurrence Probability)을 보여줍니다. 그렇다면, 동시 등장 확률이란 무엇일까요? 동시 등장 확률 ( | i ) 는 동시 등장 행렬로부터 특정 단어 i의 전체 등장 횟수를 카운트하고, 특정 단어 i가 등장했을 때 어떤 단어 k가 등장한 횟수를 카운트하여 계산한 조건부 확률입니다. ( | i ) 에서 i를 중심 단어(Center Word), k를 주변 단어(Context Word)라고 했을 때, 위에서 배운 동시 등장 행렬에서 중심 단어 i의 행의 모든 값을 더한 값을 분모로 하고 i 행 k 열의 값을 분자로 한 값이라고 볼 수 있겠습니다. 다음은 GloVe의 제안 논문에서 가져온 동시 등장 확률을 표로 정리한 하나의 예입니다. 동시 등장 확률과 크기 관계 비(ratio) k=solid k=gas k=water k=fasion P(k l ice) 0.00019 0.000066 0.003 0.000017 P(k l steam) 0.000022 0.00078 0.0022 0.000018 P(k l ice) / P(k l steam) 8.9 0.085 1.36 0.96 위의 표를 통해 알 수 있는 사실은 ice가 등장했을 때 solid가 등장할 확률 0.00019은 steam이 등장했을 때 solid가 등장할 확률인 0.000022보다 약 8.9배 크다는 겁니다. 그도 그럴 것이 solid는 '단단한'이라는 의미를 가졌으니까 '증기'라는 의미를 가지는 steam보다는 당연히 '얼음'이라는 의미를 가지는 ice라는 단어와 더 자주 등장할 겁니다. 수식적으로 다시 정리하여 언급하면 k가 solid 일 때, P(solid l ice) / P(solid l steam)를 계산한 값은 8.9가 나옵니다. 이 값은 1보다는 매우 큰 값입니다. 왜냐면 P(solid | ice)의 값은 크고, P(solid | steam)의 값은 작기 때문입니다. 그런데 k를 solid가 아니라 gas로 바꾸면 얘기는 완전히 달라집니다. gas는 ice보다는 steam과 더 자주 등장하므로, P(gas l ice) / P(gas l steam)를 계산한 값은 1보다 훨씬 작은 값인 0.085가 나옵니다. 반면, k가 water인 경우에는 solid와 steam 두 단어 모두와 동시 등장하는 경우가 많으므로 1에 가까운 값이 나오고, k가 fasion인 경우에는 solid와 steam 두 단어 모두와 동시 등장하는 경우가 적으므로 1에 가까운 값이 나옵니다. 보기 쉽도록 조금 단순화해서 표현한 표는 다음과 같습니다. 동시 등장 확률과 크기 관계 비(ratio) k=solid k=gas k=water k=fasion P(k l ice) 큰 값 작은 값 큰 값 작은 값 P(k l steam) 작은 값 큰 값 큰 값 작은 값 P(k l ice) / P(k l steam) 큰 값 작은 값 1에 가까움 1에 가까움 동시 등장 행렬과 동시 등장 확률의 이해를 바탕으로 손실 함수를 설계해 보겠습니다. 4. 손실 함수(Loss function) 우선 손실 함수를 설명하기 전에 각 용어를 정리해 보겠습니다. : 동시 등장 행렬(Co-occurrence Matrix) i : 중심 단어 i가 등장했을 때 윈도 내 주변 단어 j가 등장하는 횟수 i ∑ X j : 동시 등장 행렬에서 i 행의 값을 모두 더한 값 i : ( | i ) X k i : 중심 단어 i가 등장했을 때 윈도 내 주변 단어 k가 등장할 확률 Ex) P(solid l ice) = 단어 ice가 등장했을 때 단어 solid가 등장할 확률 i P k P k P k 로 나눠준 값 Ex) P(solid l ice) / P(solid l steam) = 8.9 i : 중심 단어 i의 임베딩 벡터 k : 주변 단어 k의 임베딩 벡터 GloVe의 아이디어를 한 줄로 요약하면 '임베딩 된 중심 단어와 주변 단어 벡터의 내적이 전체 코퍼스에서의 동시 등장 확률이 되도록 만드는 것'입니다. 즉, 이를 만족하도록 임베딩 벡터를 만드는 것이 목표입니다. 이를 식으로 표현하면 다음과 같습니다. o p o u t ( i w ~ ) P ( | i ) P k 뒤에서 보게 되겠지만, 더 정확히는 GloVe는 아래와 같은 관계를 가지도록 임베딩 벡터를 설계합니다. o p o u t ( i w ~ ) l g P ( | i ) l g P k 임베딩 벡터들을 만들기 위한 손실 함수를 처음부터 차근차근 설계해 보겠습니다. 가장 중요한 것은 단어 간의 관계를 잘 표현하는 함수여야 한다는 겁니다. 이를 위해 앞서 배운 개념인 i / j를 식에 사용합니다. GloVe의 연구진들은 벡터 i w, k를 가지고 어떤 함수를 수행하면, i / j 가 나온다는 초기 식으로부터 전개를 시작합니다. ( i w , w ~ ) P k j 아직 이 함수 가 어떤 식을 가지고 있는지는 정해진 게 없습니다. 위의 목적에 맞게 근사할 수 있는 함수식은 무수히 많겠으나 최적의 식에 다가가기 위해서 차근, 차근 디테일을 추가해 보겠습니다. 함수는 두 단어 사이의 동시 등장 확률의 크기 관계 비(ratio) 정보를 벡터 공간에 인코딩하는 것이 목적입니다. 이를 위해 GloVe 연구진들은 i w라는 두 벡터의 차이를 함수의 입력으로 사용하는 것을 제안합니다. ( i w , w ~ ) P k j 그런데 우변은 스칼라 값이고 좌변은 벡터 값입니다. 이를 성립하기 해주기 위해서 함수의 두 입력에 내적(Dot product)을 수행합니다. ( ( i w) w ~ ) P k j 정리하면, 선형 공간(Linear space)에서 단어의 의미 관계를 표현하기 위해 뺄셈과 내적을 택했습니다. 여기서 함수 가 만족해야 할 필수 조건이 있습니다. 중심 단어 와 주변 단어 ~ 라는 선택 기준은 실제로는 무작위 선택이므로 이 둘의 관계는 자유롭게 교환될 수 있도록 해야 합니다. 이것이 성립되게 하기 위해서 GloVe 연구진은 함수 가 실수의 덥셈과 양수의 곱셈에 대해서 준동형(Homomorphism)을 만족하도록 합니다. 생소한 용어라서 말이 어려워 보이는데, 정리하면 와에 대해서 함수 가 ( + ) F ( ) ( ) 와 같도록 만족시켜야 한다는 의미입니다. 식으로 나타내면 아래와 같습니다. ( + ) F ( ) ( ) ∀, b R 이 준동<NAME>을 현재 전개하던 GloVe 식에 적용할 수 있도록 조금씩 바꿔볼 겁니다. 전개하던 GloVe 식에 따르면, 함수는 결괏값으로 스칼라 값( i P k )이 나와야 합니다. 준동<NAME>에서 와 가 각각 벡터 값이라면 함수의 결괏값으로는 스칼라 값이 나올 수 없지만, 와 가 각각 사실 두 벡터의 내적 값이라고 하면 결괏값으로 스칼라 값이 나올 수 있습니다. 그러므로 위의 준동<NAME>을 아래와 같이 바꿔보겠습니다. 여기서 1 v , v , v는 각각 벡터 값입니다. 아래의 는 벡터를 의미합니다. ( 1 v + 3 v) F ( 1 v) ( 3 v) ∀ 1 v , v , v ∈ 그런데 앞서 작성한 GloVe 식에서는 i w라는 두 벡터의 차이를 함수의 입력으로 받았습니다. GloVe 식에 바로 적용을 위해 준동형 식을 이를 뺄셈에 대한 준동<NAME>으로 변경합니다. 그렇게 되면 곱셈도 나눗셈으로 바뀝니다. ( 1 v − 3 v) F ( 1 v) ( 3 v) ∀ 1 v , v , v ∈ 이 준동형 식을 GloVe 식에 적용해 보겠습니다. 우선, 함수의 우변은 다음과 같이 바뀌어야 합니다. ( ( i w) w ~ ) F ( i w ~ ) ( j w ~ ) 그런데 이전의 식에 따르면 우변은 본래 i P k 였으므로, 결과적으로 다음과 같습니다. i P k F ( i w ~ ) ( j w ~ ) ( i w ~ ) P k X k i 좌변을 풀어쓰면 다음과 같습니다. ( i w ~ − w T k) F ( i w ~ ) ( j w ~ ) 이는 뺄셈에 대한 준동<NAME>의 형태와 정확히 일치합니다. 이를 만족하는 함수를 찾아야 할 때입니다. 그리고 이를 정확하게 만족시키는 함수가 있는데 바로<NAME> 함수(Exponential function)입니다.를<NAME> 함수 x라고 해봅시다. x ( i w ~ − w T k) e p ( i w ~ ) x ( j w ~ ) x ( i w ~ ) P k X k i 위의 두 번째 식으로부터 다음과 같은 식을 얻을 수 있습니다. i w ~ l g P k l g ( i X) l g X k l g X 그런데 여기서 상기해야 할 것은 앞서 언급했듯이, 사실 i w ~ 는 두 값의 위치를 서로 바꾸어도 식이 성립해야 합니다. i의 정의를 생각해 보면 k 와도 같습니다. 그런데 이게 성립되려면 위의 식에서 o X 항이 걸림돌입니다. 이 부분만 없다면 이를 성립시킬 수 있습니다. 그래서 GloVe 연구팀은 이 o X 항을 i 에 대한 편향 i 라는 상수항으로 대체하기로 합니다. 같은 이유로 k에 대한 편향 k를 추가합니다. i w ~ b + k = o X k 이 식이 손실 함수의 핵심이 되는 식입니다. 우변의 값과의 차이를 최소화는 방향으로 좌변의 4개의 항은 학습을 통해 값이 바뀌는 변수들이 됩니다. 즉, 손실 함수는 다음과 같이 일반화될 수 있습니다. o s f n t o = m n 1 ( m w ~ b + n − o X n ) 여기서는 단어 집합의 크기를 의미합니다. 그런데 아직 최적의 손실 함수라기에는 부족합니다. GloVe 연구진은 o X k 에서 i 값이 0이 될 수 있음을 지적합니다. 대안 중 하나는 o X k 항을 o ( + i) 로 변경하는 것입니다. 하지만 이렇게 해도 여전히 해결되지 않는 문제가 있습니다. 바로 동시 등장 행렬 는 마치 DTM처럼 희소 행렬(Sparse Matrix) 일 가능성이 다분하다는 점입니다. 동시 등장 행렬에는 많은 값이 0이거나, 동시 등장 빈도가 적어서 많은 값이 작은 수치를 가지는 경우가 많습니다. 이에 대한 가중치를 주는 고민을 하게 되는데 GloVe 연구팀이 선택한 것은 바로 i의 값에 영향을 받는 가중치 함수(Weighting function) ( i) 를 손실 함수에 도입하는 것입니다. GloVe에 도입되는 ( i) 의 그래프를 보겠습니다. GloVe의 손실 함수에서 사용하는 가중치 함수는 동시 출현 빈도가 높은 단어 쌍에 낮은 가중치를 부여하고, 동시 출현 빈도가 낮은 단어 쌍에 높은 가중치를 부여합니다. 이 이유는 주로 두 가지입니다. 고빈도 단어 쌍이 모델을 지나치게 지배하는 것을 방지합니다. 예를 들어, 'the'와 같은 불용어는 거의 모든 단어와 함께 빈번하게 나타나지만, 이는 그것들이 서로 의미적으로 가깝다는 것을 의미하지는 않습니다. 그러므로 이러한 단어 쌍에 대한 가중치를 줄이는 것은 모델이 보다 다양한 패턴을 학습하는 데 도움이 됩니다. 또한, 희소한 단어 쌍의 정보를 보존합니다. 비록 희소한 단어 쌍이지만, 단어 사이의 관계는 여전히 중요할 수 있습니다. 예를 들어, 'astronaut'와 'space'는 함께 나타나는 빈도가 비교적 낮을 수 있지만, 이 두 단어 사이의 관계는 굉장히 강합니다. 따라서, 이 가중치 함수는 단순히 동시 출현 빈도가 높은 단어 쌍만 고려하는 것이 아니라, 더 다양한 단어 쌍 간의 관계를 학습하는 데 도움이 됩니다. 이는 모델이 보다 정확하고 다양한 단어 의미를 포착하는 데 도움이 됩니다. 함수는 1보다 큰 값을 반환하지 않도록 하여 가중치는 0과 1 사이의 값을 가집니다. 이 방식은 동시 출현 횟수가 m x 즉, 가장 높은 동시 출현 횟수를 초과하는 단어 쌍에 대해 가중치를 제한하므로, 아주 높은 동시 출현 횟수를 가진 단어 쌍이 학습에 과도한 영향을 미치는 것을 방지합니다. 이 함수의 값을 손실 함수에 곱해주면 가중치의 역할을 할 수 있습니다. 이 함수 ( ) 의 식은 다음과 같이 정의됩니다. ( ) m n ( , ( / m x ) / ) 최종적으로 다음과 같은 일반화된 손실 함수를 얻어낼 수 있습니다. o s f n t o = m n 1 f ( m) ( m w ~ b + n − o X n GloVe 패키지를 설치 및 실습하고 훈련 결과를 확인해 보겠습니다. 5. GloVe 훈련시키기 실습을 위해 프롬프트에서 아래 커맨드로 GloVe 패키지를 설치합니다. pip install glove_python_binary GloVe의 입력이 되는 훈련 데이터는 '영어와 한국어 Word2Vec 학습하기' 챕터에서 사용한 영어 데이터를 재사용합니다. 모든 동일한 전처리를 마치고 이전과 동일하게 result에 결과가 저장되어 있다고 가정합니다. from glove import Corpus, Glove corpus = Corpus() # 훈련 데이터로부터 GloVe에서 사용할 동시 등장 행렬 생성 corpus.fit(result, window=5) glove = Glove(no_components=100, learning_rate=0.05) # 학습에 이용할 스레드의 개수는 4로 설정, 에포크는 20. glove.fit(corpus.matrix, epochs=20, no_threads=4, verbose=True) glove.add_dictionary(corpus.dictionary) 학습이 완료되었습니다. glove.most_similar()는 입력 단어의 가장 유사한 단어들의 리스트를 리턴합니다. print(glove.most_similar("man")) [('woman', 0.9621753707315267), ('guy', 0.8860281455579162), ('girl', 0.8609057388487154), ('kid', 0.8383640509911114)] print(glove.most_similar("boy")) [('girl', 0.9436601252235809), ('kid', 0.8400949618225224), ('woman', 0.8397250531245034), ('man', 0.8303093585541573)] print(glove.most_similar("university")) [('harvard', 0.8690162017225468), ('cambridge', 0.8373272000675909), ('mit', 0.8288055170365777), ('stanford', 0.8212712738131419)] print(glove.most_similar("water")) [('air', 0.838286550826724), ('clean', 0.8326093688298345), ('fresh', 0.8232884971285377), ('electricity', 0.8097066570385377)] print(glove.most_similar("physics")) [('chemistry', 0.8379143027061764), ('biology', 0.827856517644139), ('economics', 0.775563255616767), ('finance', 0.7736692309034663)] print(glove.most_similar("muscle")) [('skeletal', 0.7977490484723809), ('tissue', 0.7714119298512192), ('nerve', 0.7477850181231441), ('stem', 0.7222964725687838)] print(glove.most_similar("clean")) [('water', 0.8264213732980569), ('fresh', 0.7850091074483321), ('wind', 0.7711854196846724), ('heat', 0.7646505765422197)] 사전 훈련된 GloVe를 사용하는 방법은 다음 챕터에서 다룹니다. 참고 자료 https://towardsdatascience.com/light-on-math-ml-intuitive-guide-to-understanding-glove-embeddings-b13b4f19c010 09-06 패스트 텍스트(FastText) 단어를 벡터로 만드는 또 다른 방법으로는 페이스북에서 개발한 FastText가 있습니다. Word2Vec 이후에 나온 것이기 때문에, 메커니즘 자체는 Word2Vec의 확장이라고 볼 수 있습니다. Word2Vec와 FastText와의 가장 큰 차이점이라면 Word2Vec는 단어를 쪼개질 수 없는 단위로 생각한다면, FastText는 하나의 단어 안에도 여러 단어들이 존재하는 것으로 간주합니다. 내부 단어. 즉, 서브 워드(subword)를 고려하여 학습합니다. 1. 내부 단어(subword)의 학습 FastText에서는 각 단어는 글자 단위 n-gram의 구성으로 취급합니다. n을 몇으로 결정하는지에 따라서 단어들이 얼마나 분리되는지 결정됩니다. 예를 들어서 n을 3으로 잡은 트라이 그램(tri-gram)의 경우, apple은 app, ppl, ple로 분리하고 이들을 벡터로 만듭니다. 더 정확히는 시작과 끝을 의미하는 <, >를 도입하여 아래의 5개 내부 단어(subword) 토큰을 벡터로 만듭니다. # n = 3인 경우 <ap, app, ppl, ple, le> 그리고 여기에 추가적으로 하나를 더 벡터화하는데, 기존 단어에 <, 와 >를 붙인 토큰입니다. # 특별 토큰 <apple> 다시 말해 n = 3인 경우, FastText는 단어 apple에 대해서 다음의 6개의 토큰을 벡터화하는 것입니다. # n = 3인 경우 <ap, app, ppl, ple, le>, <apple> 그런데 실제 사용할 때는 n의 최솟값과 최댓값으로 범위를 설정할 수 있는데, 기본값으로는 각각 3과 6으로 설정돼 있습니다. 다시 말해 최솟값 = 3, 최댓값 = 6인 경우라면, 단어 apple에 대해서 FastText는 아래 내부 단어들을 벡터화합니다. # n = 3 ~ 6인 경우 <ap, app, ppl, ppl, le>, <app, appl, pple, ple>, <appl, pple>, ..., <apple> 여기서 내부 단어들을 벡터화한다는 의미는 저 단어들에 대해서 Word2Vec을 수행한다는 의미입니다. 위와 같이 내부 단어들의 벡터 값을 얻었다면, 단어 apple의 벡터 값은 저 위 벡터 값들의 총합으로 구성합니다. apple = <ap + app + ppl + ppl + le> + <app + appl + pple + ple> + <appl + pple> + , ..., +<apple> 그리고 이런 방법은 Word2Vec에서는 얻을 수 없었던 강점을 가집니다. 2. 모르는 단어(Out Of Vocabulary, OOV)에 대한 대응 FastText의 인공 신경망을 학습한 후에는 데이터 셋의 모든 단어의 각 n-gram에 대해서 워드 임베딩이 됩니다. 이렇게 되면 장점은 데이터 셋만 충분한다면 위와 같은 내부 단어(Subword)를 통해 모르는 단어(Out Of Vocabulary, OOV)에 대해서도 다른 단어와의 유사도를 계산할 수 있다는 점입니다. 가령, FastText에서 birthplace(출생지)란 단어를 학습하지 않은 상태라고 해봅시다. 하지만 다른 단어에서 birth와 place라는 내부 단어가 있었다면, FastText는 birthplace의 벡터를 얻을 수 있습니다. 이는 모르는 단어에 제대로 대처할 수 없는 Word2Vec, GloVe와는 다른 점입니다. 3. 단어 집합 내 빈도 수가 적었던 단어(Rare Word)에 대한 대응 Word2Vec의 경우에는 등장 빈도 수가 적은 단어(rare word)에 대해서는 임베딩의 정확도가 높지 않다는 단점이 있었습니다. 참고할 수 있는 경우의 수가 적다 보니 정확하게 임베딩이 되지 않는 경우입니다. 하지만 FastText의 경우, 만약 단어가 희귀 단어라도, 그 단어의 n-gram이 다른 단어의 n-gram과 겹치는 경우라면, Word2Vec과 비교하여 비교적 높은 임베딩 벡터 값을 얻습니다. FastText가 노이즈가 많은 코퍼스에서 강점을 가진 것 또한 이와 같은 이유입니다. 모든 훈련 코퍼스에 오타(Typo)나 맞춤법이 틀린 단어가 없으면 이상적이겠지만, 실제 많은 비정형 데이터에는 오타가 섞여있습니다. 그리고 오타가 섞인 단어는 당연히 등장 빈도수가 매우 적으므로 일종의 희귀 단어가 됩니다. 즉, Word2Vec에서는 오타가 섞인 단어는 임베딩이 제대로 되지 않지만 FastText는 이에 대해서도 일정 수준의 성능을 보입니다. 예를 들어 단어 apple과 오타로 p를 한 번 더 입력한 appple의 경우에는 실제로 많은 개수의 동일한 n-gram을 가질 것입니다. 4. 실습으로 비교하는 Word2Vec Vs. FastText 간단한 실습을 통해 Word2Vec와 FastText의 차이를 비교해 보도록 하겠습니다. 단, 사용하는 코드는 Word2Vec를 실습하기 위해 사용했던 이전 챕터의 동일한 코드를 사용합니다. 1) Word2Vec 우선, 이전 Word2Vec의 실습( https://wikidocs.net/50739 )의 전처리 코드와 Word2Vec 학습 코드를 그대로 수행했음을 가정하겠습니다. 입력 단어에 대해서 유사한 단어를 찾아내는 코드에 이번에는 electrofishing이라는 단어를 넣어보겠습니다. model.wv.most_similar("electrofishing") 해당 코드는 정상 작동하지 않고 에러를 발생시킵니다. KeyError: "word 'electrofishing' not in vocabulary" 에러 메시지는 단어 집합(Vocabulary)에 electrofishing이 존재하지 않는다고 합니다. 이처럼 Word2Vec는 학습 데이터에 존재하지 않는 단어. 즉, 모르는 단어에 대해서는 임베딩 벡터가 존재하지 않기 때문에 단어의 유사도를 계산할 수 없습니다. 2) FastText 이번에는 전처리 코드는 그대로 사용하고 Word2Vec 학습 코드만 FastText 학습 코드로 변경하여 실행해 봅시다. from gensim.models import FastText model = FastText(result, size=100, window=5, min_count=5, workers=4, sg=1) electrofishing에 대해서 유사 단어를 찾아보도록 하겠습니다. model.wv.most_similar("electrofishing") [('electrolux', 0.7934642434120178), ('electrolyte', 0.78279709815979), ('electro', 0.779127836227417), ('electric', 0.7753111720085144), ('airbus', 0.7648627758026123), ('fukushima', 0.7612422704696655), ('electrochemical', 0.7611693143844604), ('gastric', 0.7483425140380859), ('electroshock', 0.7477173805236816), ('overfishing', 0.7435552477836609)] Word2Vec는 학습하지 않은 단어에 대해서 유사한 단어를 찾아내지 못했지만, FastText는 유사한 단어를 계산해서 출력하고 있음을 볼 수 있습니다. 5. 한국어에서의 FastText 한국어의 경우에도 OOV 문제를 해결하기 위해 FastText를 적용하고자 하는 시도들이 있었습니다. (1) 음절 단위 예를 들어서 음절 단위의 임베딩의 경우에 n=3일 때 ‘자연어 처리’라는 단어에 대해 n-gram을 만들어보면 다음과 같습니다. <자연, 자연어, 연어처, 어처리, 처리> (2) 자모 단위 이제 더 나아가 자모 단위(초성, 중성, 종성 단위)로 임베딩하는 시도 또한 있었습니다. 음절 단위가 아니라, 자모 단위로 가게 되면 오타나 노이즈 측면에서 더 강한 임베딩을 기대해 볼 수 있습니다. 예를 들어 ‘자연어 처리’라는 단어에 대해서 초성, 중성, 종성을 분리하고, 만약, 종성이 존재하지 않는다면 ‘_’라는 토큰을 사용한다고 가정한다면 ‘자연어 처리’라는 단어는 아래와 같이 분리가 가능합니다. 분리된 결과 : ㅈ ㅏ _ ㅇ ㅕ ㄴ ㅇ ㅓ _ ㅊ ㅓ _ ㄹ ㅣ _ 그리고 분리된 결과에 대해서 n=3일 때, n-gram을 적용하여, 임베딩을 한다면 다음과 같습니다. < ㅈ ㅏ, ㅈ ㅏ _, ㅏ _ ㅇ, ... 중략> 이어서 자모 단위 FastText를 실습해해봅시다. 09-07 자모 단위 한국어 FastText 학습하기 죄송합니다. 해당 자료는 위키독스 웹 사이트에서는 비공개 처리되어 구현 코드와 코드에 대한 상세한 설명은 유료 E-book을 구매하시면 확인할 수 있습니다. 09-08 사전 훈련된 워드 임베딩(Pre-trained Word Embedding) 이번에는 케라스의 임베딩 층(embedding layer) 과 사전 훈련된 워드 임베딩(pre-trained word embedding) 을 가져와서 사용하는 것을 비교해 봅니다. 자연어 처리를 하려고 할 때 갖고 있는 훈련 데이터의 단어들을 임베딩 층(embedding layer)을 구현하여 임베딩 벡터로 학습하는 경우가 있습니다. 케라스에서는 이를 Embedding()이라는 도구를 사용하여 구현합니다. 위키피디아 등과 같은 방대한 코퍼스를 가지고 Word2vec, FastText, GloVe 등을 통해서 미리 훈련된 임베딩 벡터를 불러오는 방법을 사용하는 경우도 있습니다. 이는 현재 갖고 있는 훈련 데이터를 임베딩 층으로 처음부터 학습을 하는 방법과는 대조됩니다. 1. 케라스 임베딩 층(Keras Embedding layer) 케라스는 훈련 데이터의 단어들에 대해 워드 임베딩을 수행하는 도구 Embedding()을 제공합니다. Embedding()은 인공 신경망 구조 관점에서 임베딩 층(embedding layer)을 구현합니다. 1) 임베딩 층은 룩업 테이블이다. 임베딩 층의 입력으로 사용하기 위해서 입력 시퀀스의 각 단어들은 모두 정수 인코딩이 되어있어야 합니다. 어떤 단어 → 단어에 부여된 고유한 정숫값 → 임베딩 층 통과 → 밀집 벡터 임베딩 층은 입력 정수에 대해 밀집 벡터(dense vector)로 매핑하고 이 밀집 벡터는 인공 신경망의 학습 과정에서 가중치가 학습되는 것과 같은 방식으로 훈련됩니다. 훈련 과정에서 단어는 모델이 풀고자 하는 작업에 맞는 값으로 업데이트됩니다. 그리고 이 밀집 벡터를 임베딩 벡터라고 부릅니다. 정수를 밀집 벡터 또는 임베딩 벡터로 매핑한다는 것은 어떤 의미일까요? 특정 단어와 매핑되는 정수를 인덱스로 가지는 테이블로부터 임베딩 벡터 값을 가져오는 룩업 테이블이라고 볼 수 있습니다. 그리고 이 테이블은 단어 집합의 크기만큼의 행을 가지므로 모든 단어는 고유한 임베딩 벡터를 가집니다. 위의 그림은 단어 great이 정수 인코딩 된 후 테이블로부터 해당 인덱스에 위치한 임베딩 벡터를 꺼내오는 모습을 보여줍니다. 위의 그림에서는 임베딩 벡터의 차원이 4로 설정돼 있습니다. 그리고 단어 great은 정수 인코딩 과정에서 1,918의 정수로 인코딩이 되었고 그에 따라 단어 집합의 크기만큼의 행을 가지는 테이블에서 인덱스 1,918번에 위치한 행을 단어 great의 임베딩 벡터로 사용합니다. 이 임베딩 벡터는 모델의 입력이 되고, 역전파 과정에서 단어 great의 임베딩 벡터 값이 학습됩니다. 룩업 테이블의 개념을 이론적으로 우선 접하고, 처음 케라스를 배울 때 어떤 분들은 임베딩 층의 입력이 원-핫 벡터가 아니어도 동작한다는 점에 헷갈려 합니다. 앞서 NNLM이나 Word2Vec을 설명할 때 룩업 테이블을 언급하면서 입력을 원-핫 벡터로 가정하고 설명드렸기 때문인데, 케라스는 단어를 정수 인덱스로 바꾸고 원-핫 벡터로 변환 후 임베딩 층의 입력으로 사용하는 것이 아니라, 단어를 정수 인코딩까지만 진행 후 임베딩 층의 입력으로 사용하여 룩업 테이블 결과인 임베딩 벡터를 리턴합니다. 케라스의 임베딩 층 구현 코드를 봅시다. vocab_size = 20000 output_dim = 128 input_length = 500 v = Embedding(vocab_size, output_dim, input_length=input_length) 임베딩 층은 다음과 같은 세 개의 인자를 받습니다. vocab_size = 텍스트 데이터의 전체 단어 집합의 크기입니다. output_dim = 워드 임베딩 후의 임베딩 벡터의 차원입니다. input_length = 입력 시퀀스의 길이입니다. 만약 갖고 있는 각 샘플의 길이가 500개이라면 이 값은 500입니다. Embedding()은 (number of samples, input_length)인 2D 정수 텐서를 입력받습니다. 이때 각 sample은 정수 인코딩이 된 결과로 정수 시퀀스입니다. Embedding()은 워드 임베딩 작업을 수행하고 (number of samples, input_length, embedding word dimentionality)인 3D 실수 텐서를 리턴합니다. 케라스의 임베딩 층(embedding layer)을 사용하는 실습을 진행해 보겠습니다. 2) 임베딩 층 사용하기 문장의 긍, 부정을 판단하는 감성 분류 모델을 만들어봅시다. 문장과 레이블 데이터를 만들었습니다. 긍정인 문장은 레이블 1, 부정인 문장은 레이블이 0입니다. import numpy as np from tensorflow.keras.preprocessing.text import Tokenizer from tensorflow.keras.preprocessing.sequence import pad_sequences sentences = ['nice great best amazing', 'stop lies', 'pitiful nerd', 'excellent work', 'supreme quality', 'bad', 'highly respectable'] y_train = [1, 0, 0, 1, 1, 0, 1] 케라스의 토크 나이저를 사용하여 단어 집합을 만들고 그 크기를 확인합니다. tokenizer = Tokenizer() tokenizer.fit_on_texts(sentences) vocab_size = len(tokenizer.word_index) + 1 # 패딩을 고려하여 +1 print('단어 집합 :',vocab_size) 단어 집합 : 16 각 문장에 대해서 정수 인코딩을 수행합니다. X_encoded = tokenizer.texts_to_sequences(sentences) print('정수 인코딩 결과 :',X_encoded) 정수 인코딩 결과 : [[1, 2, 3, 4], [5, 6], [7, 8], [9, 10], [11, 12], [13], [14, 15]] 가장 길이가 긴 문장의 길이를 구합니다. max_len = max(len(l) for l in X_encoded) print('최대 길이 :',max_len) 최대 길이 : 4 최대 길이로 모든 샘플에 대해서 패딩을 진행합니다. X_train = pad_sequences(X_encoded, maxlen=max_len, padding='post') y_train = np.array(y_train) print('패딩 결과 :') print(X_train) 패딩 결과 : [[ 1 2 3 4] [ 5 6 0 0] [ 7 8 0 0] [ 9 10 0 0] [11 12 0 0] [13 0 0 0] [14 15 0 0]] 훈련 데이터에 대한 전처리가 끝났습니다. 전형적인 이진 분류 모델을 설계합니다. 출력층에 1개의 뉴런을 배치하고 활성화 함수로는 시그모이드 함수를, 그리고 손실 함수로 binary_crossentropy를 사용합니다. 그 후 100 에포크 학습합니다. from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Embedding, Flatten embedding_dim = 4 model = Sequential() model.add(Embedding(vocab_size, embedding_dim, input_length=max_len)) model.add(Flatten()) model.add(Dense(1, activation='sigmoid')) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['acc']) model.fit(X_train, y_train, epochs=100, verbose=2) 학습 과정에서 현재 각 단어들의 임베딩 벡터들의 값은 출력층의 가중치와 함께 학습됩니다. 2. 사전 훈련된 워드 임베딩(Pre-Trained Word Embedding) 사용하기 케라스의 Embedding()을 사용하여 처음부터 임베딩 벡터 값을 학습하기도 하지만, 때로는 이미 훈련돼 있는 워드 임베딩을 가져와서 이를 임베딩 벡터로 사용하기도 합니다. 훈련 데이터가 적은 상황이라면 케라스의 Embedding()으로 해당 문제를 풀기에 최적화된 임베딩 벡터 값을 얻는 것이 쉽지 않습니다. 이 경우 해당 문제에 특화된 것은 아니지만 보다 많은 훈련 데이터로 이미 Word2Vec이나 GloVe 등으로 학습돼 있는 임베딩 벡터들을 사용하는 것이 성능의 개선을 가져올 수 있습니다. 사전 훈련된 GloVe와 Word2Vec 임베딩을 사용해서 모델을 훈련시키는 실습을 진행해 봅시다. GloVe 다운로드 링크 : http://nlp.stanford.edu/data/glove.6B.zip Word2Vec 다운로드 링크 : https://drive.google.com/file/d/0B7XkCwpI5KDYNlNUTTlSS21pQmM 훈련 데이터는 앞서 사용했던 데이터에 동일한 전처리까지 진행된 상태라고 가정하겠습니다. print(X_train) [[ 1 2 3 4] [ 5 6 0 0] [ 7 8 0 0] [ 9 10 0 0] [11 12 0 0] [13 0 0 0] [14 15 0 0]] print(y_train) [1, 0, 0, 1, 1, 0, 1] 1) 사전 훈련된 GloVe 사용하기 glove.6B.zip를 다운로드하고 압축을 풀면 다수의 파일이 존재하는데 여기서는 glove.6B.100d.txt 파일을 사용합니다. from urllib.request import urlretrieve, urlopen import gzip import zipfile urlretrieve("http://nlp.stanford.edu/data/glove.6B.zip", filename="glove.6B.zip") zf = zipfile.ZipFile('glove.6B.zip') zf.extractall() zf.close() glove.6B.100d.txt에 있는 모든 임베딩 벡터들을 불러옵니다. 파이썬의 자료구조 딕셔너리(dictionary)를 사용하며, 로드한 임베딩 벡터의 개수를 확인합니다. embedding_dict = dict() f = open('glove.6B.100d.txt', encoding="utf8") for line in f: word_vector = line.split() word = word_vector[0] # 100개의 값을 가지는 array로 변환 word_vector_arr = np.asarray(word_vector[1:], dtype='float32') embedding_dict[word] = word_vector_arr f.close() print('%s 개의 Embedding vector가 있습니다.' % len(embedding_dict)) 400000개의 Embedding vector가 있습니다. 총 40만 개의 임베딩 벡터가 존재합니다. 임의의 단어 'respectable'의 임베딩 벡터 값과 크기를 출력해 봅니다. print(embedding_dict['respectable']) print('벡터의 차원 수 :',len(embedding_dict['respectable'])) [-0.049773 0.19903 0.10585 ... 중략 ... -0.032502 0.38025 ] 벡터의 차원 수 : 100 벡터 값이 출력되며 벡터의 차원 수는 100입니다. 풀고자 하는 문제의 단어 집합 크기의 행과 100개의 열을 가지는 행렬 생성합니다. 이 행렬의 값은 전부 0으로 채웁니다. 이 행렬에 사전 훈련된 임베딩 값을 넣어줄 것입니다. embedding_matrix = np.zeros((vocab_size, 100)) print('임베딩 행렬의 크기(shape) :',np.shape(embedding_matrix) 임베딩 행렬의 크기(shape) : (16, 100) 기존 데이터의 각 단어와 매핑된 정숫값을 확인해 봅시다. print(tokenizer.word_index.items()) dict_items([('nice', 1), ('great', 2), ('best', 3), ('amazing', 4), ('stop', 5), ('lies', 6), ('pitiful', 7), ('nerd', 8), ('excellent', 9), ('work', 10), ('supreme', 11), ('quality', 12), ('bad', 13), ('highly', 14), ('respectable', 15)]) 단어 'great'의 매핑된 정수는 2입니다. print('단어 great의 매핑된 정수 :',tokenizer.word_index['great'] 단어 great의 매핑된 정수 : 2 사전 훈련된 GloVe에서 'great'의 벡터 값을 확인합니다. print(embedding_dict['great']) [-0.013786 0.38216 0.53236 0.15261 -0.29694 -0.20558 .. 중략 ... -0.69183 -1.0426 0.28855 0.63056 ] 단어 집합의 모든 단어에 대해서 사전 훈련된 GloVe의 임베딩 벡터들을 매핑 한 후 'great'의 벡터 값이 의도한 인덱스의 위치에 삽입되었는지 확인해 보겠습니다. for word, index in tokenizer.word_index.items(): # 단어와 매핑되는 사전 훈련된 임베딩 벡터 값 vector_value = embedding_dict.get(word) if vector_value is not None: embedding_matrix[index] = vector_value embedding_matrix의 인덱스 2에서의 값을 확인합니다. embedding_matrix[2] array([-0.013786 , 0.38216001, 0.53236002, 0.15261 , -0.29694 , ... 중략 ... -0.39346001, -0.69182998, -1.04260004, 0.28854999, 0.63055998]) 이전에 확인한 사전에 훈련된 GloVe에서의 'great'의 벡터 값과 일치합니다. 이제 Embedding layer에 embedding_matrix를 초깃값으로 설정합니다. 현재 실습에서 사전 훈련된 워드 임베딩을 100차원의 값인 것으로 사용하고 있기 때문에 임베딩 층의 output_dim의 인자 값으로 100을 주어야 합니다. 그리고 사전 훈련된 워드 임베딩을 그대로 사용할 경우 추가 훈련을 하지 않는다는 의미에서 trainable의 인자 값을 False로 선택할 수 있습니다. from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Embedding, Flatten output_dim = 100 model = Sequential() e = Embedding(vocab_size, output_dim, weights=[embedding_matrix], input_length=max_len, trainable=False) model.add(e) model.add(Flatten()) model.add(Dense(1, activation='sigmoid')) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['acc']) model.fit(X_train, y_train, epochs=100, verbose=2) 사전 훈련된 GloVe 임베딩에 대한 예제는 아래의 케라스 블로그 링크에도 기재되어 있습니다. 링크 : https://blog.keras.io/using-pre-trained-word-embeddings-in-a-keras-model.html 2) 사전 훈련된 Word2Vec 사용하기 구글의 사전 훈련된 Word2Vec 모델을 로드하여 word2vec_model에 저장 후 크기를 확인합니다. import gensim urlretrieve("https://s3.amazonaws.com/dl4j-distribution/GoogleNews-vectors-negative300.bin.gz", \ filename="GoogleNews-vectors-negative300.bin.gz") word2vec_model = gensim.models.KeyedVectors.load_word2vec_format('GoogleNews-vectors-negative300.bin.gz', binary=True) print('모델의 크기(shape) :',word2vec_model.vectors.shape) # 모델의 크기 확인 모델의 크기(shape) : (3000000, 300) 300의 차원을 가진 Word2Vec 벡터가 3,000,000개 있습니다. 모든 값이 0으로 채워진 임베딩 행렬을 만들어줍니다. 풀고자 하는 문제의 단어 집합 크기의 행과 300개의 열을 가지는 행렬 생성합니다. 이 행렬의 값은 전부 0으로 채웁니다. 이 행렬에 사전 훈련된 임베딩 값을 넣어줄 것입니다. embedding_matrix = np.zeros((vocab_size, 300)) print('임베딩 행렬의 크기(shape) :',np.shape(embedding_matrix) 임베딩 행렬의 크기(shape) : (16, 300) word2vec_model에서 특정 단어를 입력하면 해당 단어의 임베딩 벡터를 리턴 받을 텐데, 만약 word2vec_model에 특정 단어의 임베딩 벡터가 없다면 None을 리턴하도록 하는 함수 get_vector()를 구현합니다. def get_vector(word): if word in word2vec_model: return word2vec_model[word] else: return None 단어 집합으로부터 단어를 1개씩 호출하여 word2vec_model에 해당 단어의 임베딩 벡터 값이 존재하는지 확인합니다. 만약 None이 아니라면 존재한다는 의미이므로 임베딩 행렬에 해당 단어의 인덱스 위치의 행에 임베딩 벡터의 값을 저장합니다. for word, index in tokenizer.word_index.items(): # 단어와 매핑되는 사전 훈련된 임베딩 벡터 값 vector_value = get_vector(word) if vector_value is not None: embedding_matrix[index] = vector_value 현재 풀고자 하는 문제의 16개의 단어와 매핑되는 임베딩 행렬이 완성됩니다. 제대로 매핑이 됐는지 확인해 볼까요? 기존에 word2vec_model에 저장되어 있던 단어 'nice'의 임베딩 벡터 값을 확인해 봅시다. print(word2vec_model['nice']) [ 0.15820312 0.10595703 -0.18945312 0.38671875 0.08349609 -0.26757812 0.08349609 0.11328125 -0.10400391 0.17871094 -0.12353516 -0.22265625 ... 중략 ... -0.16894531 -0.08642578 -0.08544922 0.18945312 -0.14648438 0.13476562 -0.04077148 0.03271484 0.08935547 -0.26757812 0.00836182 -0.21386719] 단어 'nice'의 매핑된 정수를 확인합니다. print('단어 nice의 매핑된 정수 :', tokenizer.word_index['nice']) 단어 nice의 매핑된 정수 : 1 1의 값을 가지므로 embedding_matirx의 1번 인덱스에는 단어 'nice'의 임베딩 벡터 값이 있어야 합니다. print(embedding_matrix[1]) [ 0.15820312 0.10595703 -0.18945312 0.38671875 0.08349609 -0.26757812 0.08349609 0.11328125 -0.10400391 0.17871094 -0.12353516 -0.22265625 ... 중략 ... -0.16894531 -0.08642578 -0.08544922 0.18945312 -0.14648438 0.13476562 -0.04077148 0.03271484 0.08935547 -0.26757812 0.00836182 -0.21386719] 값이 word2vec_model에서 확인했던 것과 동일한 것을 확인할 수 있습니다. 단어 집합에 있는 다른 단어들에 대해서도 확인해 보세요. 이제 Embedding에 사전 훈련된 embedding_matrix를 입력으로 넣어주고 모델을 학습시켜보겠습니다. from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Embedding, Flatten, Input model = Sequential() model.add(Input(shape=(max_len,), dtype='int32')) e = Embedding(vocab_size, 300, weights=[embedding_matrix], input_length=max_len, trainable=False) model.add(e) model.add(Flatten()) model.add(Dense(1, activation='sigmoid')) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['acc']) model.fit(X_train, y_train, epochs=100, verbose=2) 사전 훈련된 워드 임베딩을 이용한 텍스트 분류는 'NLP를 이용한 합성곱 신경망' 챕터의 의도 분류 실습( https://wikidocs.net/86083 )을 참고하세요. 09-09 엘모(Embeddings from Language Model, ELMo) 논문 링크 : https://aclweb.org/anthology/N18-1202 ELMo(Embeddings from Language Model)는 2018년에 제안된 새로운 워드 임베딩 방법론입니다. ELMo라는 이름은 세서미 스트리트라는 미국 인형극의 캐릭터 이름이기도 한데, 뒤에서 배우게 되는 BERT나 최근 마이크로소프트가 사용한 Big Bird라는 NLP 모델 또한 ELMo에 이어 세서미 스트리트의 캐릭터의 이름을 사용했습니다. ELMo는 Embeddings from Language Model의 약자입니다. 해석하면 '언어 모델로 하는 임베딩'입니다. ELMo의 가장 큰 특징은 사전 훈련된 언어 모델(Pre-trained language model)을 사용한다는 점입니다. 이는 ELMo의 이름에 LM이 들어간 이유입니다. 현재 텐서 플로 2.0에서는 TF-Hub의 ELMo를 사용할 수 없습니다. 사용하려면 텐서 플로 버전을 1버전으로 낮추어야 합니다. Colab에서 실습하시는 것을 권장 드립니다. Colab에서는 손쉽게 텐서 플로 버전을 1버전으로 설정할 수 있습니다. 아래 실습 내용을 참고하세요. 1. ELMo(Embeddings from Language Model) Bank라는 단어를 생각해 봅시다. Bank Account(은행 계좌)와 River Bank(강둑)에서의 Bank는 전혀 다른 의미를 가지는데, Word2Vec이나 GloVe 등으로 표현된 임베딩 벡터들은 이를 제대로 반영하지 못한다는 단점이 있습니다. 예를 들어서 Word2Vec이나 GloVe 등의 임베딩 방법론으로 Bank란 단어를 [0.2 0.8 -1.2]라는 임베딩 벡터로 임베딩하였다고 하면, 이 단어는 Bank Account(은행 계좌)와 River Bank(강둑)에서의 Bank는 전혀 다른 의미임에도 불구하고 두 가지 상황 모두에서 [0.2 0.8 -1.2]의 벡터가 사용됩니다. 같은 표기의 단어라도 문맥에 따라서 다르게 워드 임베딩을 할 수 있으면 자연어 처리의 성능을 올릴 수 있을 것입니다. 워드 임베딩 시 문맥을 고려해서 임베딩을 하겠다는 아이디어가 문맥을 반영한 워드 임베딩(Contextualized Word Embedding)입니다. 2. biLM(Bidirectional Language Model)의 사전 훈련 다음 단어를 예측하는 작업인 언어 모델링을 상기해 봅시다. 아래의 그림은 은닉층이 2개인 일반적인 단방향 RNN 언어 모델의 언어 모델링을 보여줍니다. RNN 언어 모델은 문장으로부터 단어 단위로 입력을 받는데, RNN 내부의 은닉 상태 t 는 시점(time step)이 지날수록 점점 업데이트돼갑니다. 이는 결과적으로 RNN의 t 의 값이 문장의 문맥 정보를 점차적으로 반영한다고 말할 수 있습니다. 그런데 ELMo는 위의 그림의 순방향 RNN뿐만 아니라, 위의 그림과는 반대 방향으로 문장을 스캔하는 역방향 RNN 또한 활용합니다. ELMo는 양쪽 방향의 언어 모델을 둘 다 학습하여 활용한다고 하여 이 언어 모델을 biLM(Bidirectional Language Model)이라고 합니다. ELMo에서 말하는 biLM은 기본적으로 다층 구조(Multi-layer)를 전제로 합니다. 은닉층이 최소 2개 이상이라는 의미입니다. 아래의 그림은 은닉층이 2개인 순방향 언어 모델과 역방향 언어 모델의 모습을 보여줍니다. 이때 biLM의 각 시점의 입력이 되는 단어 벡터는 이번 챕터에서 설명한 임베딩 층(embedding layer)을 사용해서 얻은 것이 아니라 합성곱 신경망을 이용한 문자 임베딩(character embedding)을 통해 얻은 단어 벡터입니다. 문자 임베딩에 대한 설명은 'NLP를 위한 합성곱 신경망' 챕터에서 다루는 내용으로 여기서는 임베딩층, Word2Vec 등 외에 단어 벡터를 얻는 또 다른 방식도 있다고만 알아둡시다. 문자 임베딩은 마치 서브 단어(subword)의 정보를 참고하는 것처럼 문맥과 상관없이 dog란 단어와 doggy란 단어의 연관성을 찾아낼 수 있습니다. 또한 이 방법은 OOV에도 견고한다는 장점이 있습니다. 주의할 점은 앞서 설명한 양방향 RNN과 ELMo에서의 biLM은 다릅니다. 양방향 RNN은 순방향 RNN의 은닉 상태와 역방향의 RNN의 은닉 상태를 연결(concatenate) 하여 다음층의 입력으로 사용합니다. 반면, biLM의 순방향 언어 모델과 역방향 언어 모델이라는 두 개의 언어 모델을 별개의 모델로 보고 학습합니다. 3. biLM의 활용 biLM이 언어 모델링을 통해 학습된 후 ELMo가 사전 훈련된 biLM을 통해 입력 문장으로부터 단어를 임베딩하기 위한 과정을 보겠습니다. 이 예제에서는 play란 단어가 임베딩이 되고 있다는 가정 하에 ELMo를 설명합니다. play라는 단어를 임베딩 하기 위해서 ELMo는 위의 점선의 사각형 내부의 각 층의 결괏값을 재료로 사용합니다. 다시 말해 해당 시점(time step)의 BiLM의 각 층의 출력값을 가져옵니다. 그리고 순방향 언어 모델과 역방향 언어 모델의 각 층의 출력값을 연결(concatenate) 하고 추가 작업을 진행합니다. 여기서 각 층의 출력값이란 첫 번째는 임베딩 층을 말하며, 나머지 층은 각 층의 은닉 상태를 말합니다. ELMo의 직관적인 아이디어는 각 층의 출력값이 가진 정보는 전부 서로 다른 종류의 정보를 갖고 있을 것이므로, 이들을 모두 활용한다는 점에 있습니다. 아래는 ELMo가 임베딩 벡터를 얻는 과정을 보여줍니다. 1) 각 층의 출력값을 연결(concatenate) 한다. 2) 각 층의 출력값 별로 가중치를 준다. 이 가중치를 여기서는 1 s, 3 라고 합시다. 3) 각 층의 출력값을 모두 더한다. 2) 번과 3) 번의 단계를 요약하여 가중합(Weighted Sum)을 한다고 할 수 있습니다. 4) 벡터의 크기를 결정하는 스칼라 매개변수를 곱한다. 이 스칼라 매개변수를 여기서는이라고 합시다. 이렇게 완성된 벡터를 ELMo 표현(representation)이라고 합니다. 지금까지는 ELMo 표현을 얻기 위한 과정이고 이제 ELMo를 입력으로 사용하고 수행하고 싶은 텍스트 분류, 질의응답 시스템 등의 자연어 처리 작업이 있을 것입니다. 예를 들어 텍스트 분류 작업을 하고 싶다고 가정합시다. 그렇다면 ELMo 표현을 어떻게 텍스트 분류 작업에 사용할 수 있을까요? ELMo 표현을 기존의 임베딩 벡터와 함께 사용할 수 있습니다. 우선 텍스트 분류 작업을 위해서 GloVe와 같은 기존의 방법론을 사용한 임베딩 벡터를 준비했다고 합시다. 이때, GloVe를 사용한 임베딩 벡터만 텍스트 분류 작업에 사용하는 것이 아니라 이렇게 준비된 ELMo 표현을 GloVe 임베딩 벡터와 연결(concatenate) 해서 입력으로 사용할 수 있습니다. 그리고 이때 biLM의 가중치는 고정시키고, 위에서 사용한 1 s, 3 γ 는 훈련 과정에서 학습됩니다. 위의 그림은 ELMo 표현이 기존의 GloVe 등과 같은 임베딩 벡터와 함께 NLP 태스크의 입력이 되는 것을 보여줍니다. 4. ELMo 표현을 사용해서 스팸 메일 분류하기 이번 예제의 실습은 Colab에서 수행한다고 가정합니다. 우선 시작 전에 텐서 플로 버전을 1버전으로 설정하겠습니다. %tensorflow_version 1.x 텐서 플로 허브로부터 다양한 사전 훈련된 모델(Pre-tained Model)들을 사용할 수 있습니다. 여기서는 사전 훈련된 모델로부터 ELMo 표현을 사용해 보는 정도로 예제를 진행해 보겠습니다. 시작 전에 텐서 플로 허브를 인스톨해야 합니다. 윈도의 명령 프롬프트나 UNIX의 터미널에서 아래의 명령을 수행합니다. pip install tensorflow-hub 설치가 끝났다면 이제 텐서 플로 허브를 임포트 할 수 있습니다. 필요한 도구들을 임포트 합니다. import tensorflow_hub as hub import tensorflow as tf from keras import backend as K import urllib.request import pandas as pd import numpy as np 텐서 플로 허브로부터 ELMo를 다운로드하겠습니다. elmo = hub.Module("https://tfhub.dev/google/elmo/1", trainable=True) # 텐서 플로 허브로부터 ELMo를 다운로드 sess = tf.Session() K.set_session(sess) sess.run(tf.global_variables_initializer()) sess.run(tf.tables_initializer()) 기본적으로 필요한 것들을 임포트 하였습니다. 이제 데이터를 불러오고, 5개만 출력해 보겠습니다. 파일 원본 출처 : https://www.kaggle.com/uciml/sms-spam-collection-dataset 스팸 메일 분류하기 데이터를 다운로드하겠습니다. urllib.request.urlretrieve("https://raw.githubusercontent.com/mohitgupta-omg/Kaggle-SMS-Spam-Collection-Dataset-/master/spam.csv", filename="spam.csv") data = pd.read_csv('spam.csv', encoding='latin-1') data[:5] 여기서 필요한 건 v2 열과 v1열입니다. v1열은 숫자 레이블로 바꿔야 할 필요가 있습니다. 이를 각각 X_data와 y_data로 저장하겠습니다. data['v1'] = data['v1'].replace(['ham','spam'],[0,1]) y_data = list(data['v1']) X_data = list(data['v2']) v2열을 X_data에 저장합니다. v1 열에 있는 ham과 spam 레이블을 각각 숫자 0과 1로 바꾸고 y_data에 저장합니다. 정상적으로 저장되었는지 이를 각각 5개만 출력해 보겠습니다. X_data[:5] ['Go until jurong point, crazy.. Available only in bugis n great world la e buffet... Cine there got amore wat...', 'Ok lar... Joking wif u oni...', "Free entry in 2 a wkly comp to win FA Cup final tkts 21st May 2005. Text FA to 87121 to receive entry question(std txt rate) T&C's apply 08452810075over18's", 'U dun say so early hor... U c already then say...', "Nah I don't think he goes to usf, he lives around here though"] print(y_data[:5]) [0, 0, 1, 0, 0] 훈련 데이터와 테스트 데이터를 8:2 비율로 분할해 보겠습니다. 그런데 그전에 이를 위해 전체 데이터 개수의 80%와 20%는 각각 몇 개인지 확인합니다. print(len(X_data)) n_of_train = int(len(X_data) * 0.8) n_of_test = int(len(X_data) - n_of_train) print(n_of_train) print(n_of_test) 5572 4457 1115 전체 데이터는 5,572개이며 8:2로 비율 하면 각각 4,457과 1,115가 됩니다. 이를 각각 훈련 데이터와 테스트 데이터의 양으로 하여 데이터를 분할하겠습니다. X_train = np.asarray(X_data[:n_of_train]) #X_data 데이터 중에서 앞의 4457개의 데이터만 저장 y_train = np.asarray(y_data[:n_of_train]) #y_data 데이터 중에서 앞의 4457개의 데이터만 저장 X_test = np.asarray(X_data[n_of_train:]) #X_data 데이터 중에서 뒤의 1115개의 데이터만 저장 y_test = np.asarray(y_data[n_of_train:]) #y_data 데이터 중에서 뒤의 1115개의 데이터만 저장 이제 훈련을 위한 데이터 준비는 끝났습니다. 이제 ELMo와 설계한 모델을 연결하는 작업들을 진행해 보겠습니다. ELMo는 텐서 플로 허브로부터 가져온 것이기 때문에 케라스에서 사용하기 위해서는 케라스에서 사용할 수 있도록 변환해 주는 작업들이 필요합니다. def ELMoEmbedding(x): return elmo(tf.squeeze(tf.cast(x, tf.string)), as_dict=True, signature="default")["default"] # 데이터의 이동이 케라스 → 텐서 플로 → 케라스가 되도록 하는 함수 이제 모델을 설계합니다. from keras.models import Model from keras.layers import Dense, Lambda, Input input_text = Input(shape=(1, ), dtype=tf.string) embedding_layer = Lambda(ELMoEmbedding, output_shape=(1024, ))(input_text) hidden_layer = Dense(256, activation='relu')(embedding_layer) output_layer = Dense(1, activation='sigmoid')(hidden_layer) model = Model(inputs=[input_text], outputs=output_layer) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) 모델은 ELMo를 이용한 임베딩 층을 거쳐서 256개의 뉴런이 있는 은닉층을 거친 후 마지막 1개의 뉴런을 통해 이진 분류를 수행합니다. 이진 분류를 위한 마지막 뉴런의 활성화 함수는 시그모이드 함수이며, 모델의 손실 함수는 binary_crossentropy입니다. history = model.fit(X_train, y_train, epochs=1, batch_size=60) Epoch 1/1 4457/4457 [==============================] - 1508s 338ms/step - loss: 0.1129 - acc: 0.9619 훈련 데이터에서는 정확도 96%를 얻었습니다. 이제 테스트 데이터에 대해서 평가해 보겠습니다. print("\n 테스트 정확도: %.4f" % (model.evaluate(X_test, y_test)[1])) 1115/1115 [==============================] - 381s 342ms/step 테스트 정확도: 0.9803 1번의 에포크에서 테스트 데이터 정확도 98%를 얻어냅니다. 09-10 임베딩 벡터의 시각화(Embedding Visualization) 구글은 임베딩 프로젝터(embedding projector)라는 데이터 시각화 도구를 지원합니다. 학습한 임베딩 벡터들을 시각화해봅시다. 임베딩 프로젝터 논문 : https://arxiv.org/pdf/1611.05469v1.pdf 1. 워드 임베딩 모델로부터 2개의 tsv 파일 생성하기 학습한 임베딩 벡터들을 시각화해보겠습니다. 시각화를 위해서는 이미 모델을 학습하고, 파일로 저장돼 있어야 합니다. 모델이 저장돼 있다면 아래 커맨드를 통해 시각화에 필요한 파일들을 생성할 수 있습니다. !python -m gensim.scripts.word2vec2tensor --input 모델 이름 --output 모델 이름 여기서는 편의를 위해 이전 챕터에서 학습하고 저장하는 실습까지 진행했던 영어 Word2Vec 모델인 'eng_w2v'를 재사용합니다. eng_w2v라는 Word2Vec 모델이 이미 존재한다는 가정 하에 주피터 노트북에서 아래 커맨드를 수행합니다. !python -m gensim.scripts.word2vec2tensor --input eng_w2v --output eng_w2v 커맨드를 수행하면 주피터 노트북이 시작되는 경로에 기존에 있던 eng_w2v 외에도 두 개의 파일이 생깁니다. 새로 생긴 eng_w2v_metadata.tsv와 eng_w2v_tensor.tsv 이 두 개 파일이 임베딩 벡터 시각화를 위해 사용할 파일입니다. 만약 eng_w2v 모델 파일이 아니라 다른 모델 파일 이름으로 실습을 진행하고 있다면, '모델 이름_ metadata.tsv'와 '모델 이름_ tensor.tsv'라는 파일이 생성됩니다. 2. 임베딩 프로젝터를 사용하여 시각화하기 구글의 임베딩 프로젝터를 사용해서 워드 임베딩 모델을 시각화해보겠습니다. 아래의 링크에 접속합니다. 링크 : https://projector.tensorflow.org/ 사이트에 접속해서 좌측 상단을 보면 Load라는 버튼이 있습니다. Load라는 버튼을 누르면 아래와 같은 창이 뜨는데 총 두 개의 Choose file 버튼이 있습니다. 위에 있는 Choose file 버튼을 누르고 eng_w2v_tensor.tsv 파일을 업로드하고, 아래에 있는 Choose file 버튼을 누르고 eng_w2v_metadata.tsv 파일을 업로드합니다. 두 파일을 업로드하면 임베딩 프로젝터에 학습했던 워드 임베딩 모델이 시각화됩니다. 그 후에는 임베딩 프로젝터의 다양한 기능을 사용할 수 있습니다. 예를 들어 임베딩 프로젝터는 복잡한 데이터를 차원을 축소하여 시각화할 수 있도록 도와주는 PCA, t-SNE 등을 제공합니다. 위의 그림은 'man'이라는 단어를 선택하고, 코사인 유사도를 기준으로 가장 유사한 상위 10개 벡터들을 표시해 봤습니다. 09-11 문서 벡터를 이용한 추천 시스템(Recommendation System using Document Embedding) 문서들을 고정된 길이의 벡터로 변환한다면 벡터 간 비교로 문서들을 서로 비교할 수 있습니다. 각 문서를 문서 벡터로 변환하는 방법은 이미 구현된 패키지인 Doc2Vec이나 Sent2Vec 등을 사용하여 학습하는 방법도 존재하지만, 단어 벡터를 얻은 뒤 문서에 존재하는 단어 벡터들의 평균을 문서 벡터로 간주할 수 있습니다. 이번에는 문서 내 각 단어들을 Word2Vec을 통해 단어 벡터로 변환하고, 이들의 평균으로 문서 벡터를 얻어 선호하는 도서와 유사한 도서를 찾아주는 도서 추천 시스템을 만들어보겠습니다. 1. 데이터 로드 이번 실습에서 사용할 데이터는 책의 이미지와 책의 줄거리를 크롤링 한 데이터로 아래의 링크에서 다운로드할 수 있습니다. 데이터 다운로드 링크 : https://drive.google.com/file/d/15Q7DZ7xrJsI2Hji-WbkU9j1mwnODBd5A/view? usp=sharing # 현재 코드가 gensim 3.6.0 버전에서 동작합니다. import urllib.request import pandas as pd import numpy as np import matplotlib.pyplot as plt import requests import re from PIL import Image from io import BytesIO from nltk.tokenize import RegexpTokenizer import nltk from gensim.models import Word2Vec from gensim.models import KeyedVectors from nltk.corpus import stopwords from sklearn.metrics.pairwise import cosine_similarity 데이터를 데이터 프레임으로 로드하고 전체 문서의 수를 출력해 봅시다. urllib.request.urlretrieve("https://raw.githubusercontent.com/ukairia777/tensorflow-nlp-tutorial/main/09.%20Word%20Embedding/dataset/data.csv", filename="data.csv") df = pd.read_csv("data.csv") print('전체 문서의 수 :',len(df)) 전체 문서의 수 : 2382 상위 5개의 행만 출력해 봅시다. df[:5] 불필요한 열들이 존재하는데, 여기서는 줄거리에 해당하는 열인 'Desc 열'이 중요합니다. 해당 열에 있는 데이터에 대해서 Word2Vec을 학습하기 위해 전처리를 진행합니다. 해당 열에 대해서 전처리를 수행하고 'cleaned'라는 열에 저장해 봅시다. def _removeNonAscii(s): return "".join(i for i in s if ord(i)<128) def make_lower_case(text): return text.lower() def remove_stop_words(text): text = text.split() stops = set(stopwords.words("english")) text = [w for w in text if not w in stops] text = " ".join(text) return text def remove_html(text): html_pattern = re.compile('<.*?>') return html_pattern.sub(r'', text) def remove_punctuation(text): tokenizer = RegexpTokenizer(r'[a-zA-Z]+') text = tokenizer.tokenize(text) text = " ".join(text) return text df['cleaned'] = df['Desc'].apply(_removeNonAscii) df['cleaned'] = df.cleaned.apply(make_lower_case) df['cleaned'] = df.cleaned.apply(remove_stop_words) df['cleaned'] = df.cleaned.apply(remove_punctuation) df['cleaned'] = df.cleaned.apply(remove_html) 상위 5개의 행만 출력합니다. df['cleaned'][:5] 0 know power shifting west east north south pres... 1 following success accidental billionaires mone... 2 tap power social software networks build busin... 3 william j bernstein american financial theoris... 4 amazing book joined steve jobs many akio morit... Name: cleaned, dtype: object 전처리 과정에서 빈 값이 생긴 행이 있을 수 있습니다. 빈 값이 생긴 행이 있다면, nan 값으로 변환 후에 해당 행을 제거합니다. df['cleaned'].replace('', np.nan, inplace=True) df = df[df['cleaned'].notna()] print('전체 문서의 수 :',len(df)) 전체 문서의 수 : 2381 전체 문서의 수가 1개 줄어들었습니다. 토큰화를 수행하여 corpus라는 리스트에 저장합니다. 해당 리스트 corpus를 통해 Word2Vec을 훈련할 것입니다. corpus = [] for words in df['cleaned']: corpus.append(words.split()) 2. 사전 훈련된 워드 임베딩 사용하기 Word2Vec을 처음부터 학습할 수도 있겠지만, 데이터가 충분하지 않은 상황에서 사전 훈련된 워드 임베딩을 단어 벡터의 초깃값으로 사용하여 성능을 높일 수 있습니다. 여기서는 사전 훈련된 Word2Vec을 로드하고 초기 단어 벡터 값으로 사용합니다. urllib.request.urlretrieve("https://s3.amazonaws.com/dl4j-distribution/GoogleNews-vectors-negative300.bin.gz", \ filename="GoogleNews-vectors-negative300.bin.gz") word2vec_model = Word2Vec(size = 300, window=5, min_count = 2, workers = -1) word2vec_model.build_vocab(corpus) word2vec_model.intersect_word2vec_format('GoogleNews-vectors-negative300.bin.gz', lockf=1.0, binary=True) word2vec_model.train(corpus, total_examples = word2vec_model.corpus_count, epochs = 15) 3. 단어 벡터의 평균 구하기 각 문서에 존재하는 단어들의 벡터 값의 평균을 구하여 해당 문서의 벡터 값을 연산해 봅시다. def get_document_vectors(document_list): document_embedding_list = [] # 각 문서에 대해서 for line in document_list: doc2vec = None count = 0 for word in line.split(): if word in word2vec_model.wv.vocab: count += 1 # 해당 문서에 있는 모든 단어들의 벡터 값을 더한다. if doc2vec is None: doc2vec = word2vec_model[word] else: doc2vec = doc2vec + word2vec_model[word] if doc2vec is not None: # 단어 벡터를 모두 더한 벡터의 값을 문서 길이로 나눠준다. doc2vec = doc2vec / count document_embedding_list.append(doc2vec) # 각 문서에 대한 문서 벡터 리스트를 리턴 return document_embedding_list document_embedding_list = get_document_vectors(df['cleaned']) print('문서 벡터의 수 :',len(document_embedding_list)) 문서 벡터의 수 : 2381 4. 추천 시스템 구현하기 각 문서 벡터 간의 코사인 유사도를 구합니다. cosine_similarities = cosine_similarity(document_embedding_list, document_embedding_list) print('코사인 유사도 매트릭스의 크기 :',cosine_similarities.shape) 코사인 유사도 매트릭스의 크기 : (2381, 2381) 선택한 책에 대해서 코사인 유사도를 이용하여 가장 줄거리가 유사한 5개의 책을 찾아내는 함수를 만듭니다. def recommendations(title): books = df[['title', 'image_link']] # 책의 제목을 입력하면 해당 제목의 인덱스를 리턴 받아 idx에 저장. indices = pd.Series(df.index, index = df['title']).drop_duplicates() idx = indices[title] # 입력된 책과 줄거리(document embedding)가 유사한 책 5개 선정. sim_scores = list(enumerate(cosine_similarities[idx])) sim_scores = sorted(sim_scores, key = lambda x: x[1], reverse = True) sim_scores = sim_scores[1:6] # 가장 유사한 책 5권의 인덱스 book_indices = [i[0] for i in sim_scores] # 전체 데이터 프레임에서 해당 인덱스의 행만 추출. 5개의 행을 가진다. recommend = books.iloc[book_indices].reset_index(drop=True) fig = plt.figure(figsize=(20, 30)) # 데이터 프레임으로부터 순차적으로 이미지를 출력 for index, row in recommend.iterrows(): response = requests.get(row['image_link']) img = Image.open(BytesIO(response.content)) fig.add_subplot(1, 5, index + 1) plt.imshow(img) plt.title(row['title']) 좋아하는 책 제목을 입력으로 넣으면 해당 책의 문서 벡터(줄거리 벡터)와 유사한 문서 벡터 값을 가진 책들을 추천해 줍니다. 책 제목과 표지를 출력합니다. recommendations("The Da Vinci Code") 다빈치 코드는 작가 댄 브라운의 작품입니다. 추천되는 작품들 또한 5개 중 3개가 댄 브라운의 작품들이 추천됨을 확인할 수 있습니다. 이번에는 아가사 크리스티의 애크로이드 살인사건과 유사한 도서를 추천받아 봅시다. recommendations("The Murder of Roger Ackroyd") 애크로이드 살인사건은 미스터리 스릴러 소설인데 이와 유사한 소설들이 추천되는 것을 확인할 수 있습니다. 09-12 문서 임베딩 : 워드 임베딩의 평균(Average Word Embedding) 앞서 특정 문장 내의 단어들의 임베딩 벡터들의 평균이 그 문장의 벡터가 될 수 있음을 설명했습니다. 이번에는 임베딩이 잘 된 상황에서는 단어 벡터들의 평균만으로 텍스트 분류를 수행할 수 있음을 보이고, 워드 임베딩의 중요성을 이해해 보겠습니다. 영화 사이트 IMDB 영화 리뷰 데이터는 리뷰 텍스트에 리뷰가 긍정인 경우 1을, 부정인 경우 0으로 레이블링 한 데이터로 25,000개의 훈련 데이터와 테스트 데이터 25,000개로 구성된 데이터입니다. 케라스를 통해서 이 데이터 셋을 바로 다운로드할 수 있습니다. 이 데이터에 대한 상세 설명은 뒤의 RNN을 이용한 텍스트 분류 챕터에서 IMDB 리뷰 데이터를 다룰 때 설명합니다. 여기서는 데이터나 코드에 대한 설명보다는 단어 벡터의 평균으로 얻을 수 있는 성능에 주목해 주세요. 1. 데이터 로드와 전처리 import numpy as np from tensorflow.keras.datasets import imdb from tensorflow.keras.preprocessing.sequence import pad_sequences 케라스에서는 imdb.data_load()를 통해서 IMDB 리뷰 데이터를 다운로드할 수 있는데, 데이터를 로드할 때 파라미터로 num_words를 사용하면 이 데이터에서 등장 빈도 순위로 몇 번째에 해당하는 단어까지를 사용할 것인지를 의미합니다. 만약 vocab_size를 20,000으로 지정할 경우 등장 빈도 순위가 20,000등이 넘는 단어들은 데이터를 로드할 때 전부 제거 후 로드합니다. vocab_size = 20000 (X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=vocab_size) print('훈련용 리뷰 개수 :',len(X_train)) print('테스트용 리뷰 개수 :',len(X_test)) 훈련용 리뷰 개수 : 25000 테스트용 리뷰 개수 : 25000 이 데이터는 이미 정수 인코딩까지의 전처리가 진행돼 있습니다. 그래서 단어 집합을 만들고, 각 단어를 정수로 인코딩하는 과정을 할 필요가 없습니다. 첫 번째 리뷰와 첫 번째 리뷰의 레이블을 출력해 봅시다. print('훈련 데이터의 첫 번째 샘플 :',X_train[0]) print('훈련 데이터의 첫 번째 샘플의 레이블 :'y_train[0]) 훈련 데이터의 첫 번째 샘플 : [1, 14, 22, 16, 43, 530, 973, 1622, 1385, 65, 458, 4468, 66, 3941, 4, 173, 36, 256, 5, 25, 100, 43, 838, 112, 50, 670, 2, 9, 35, 480, 284, 5, 150, 4, 172, 112, 167, 2, 336, 385, 39, 4, 172, 4536, 1111, 17, 546, 38, 13, 447, 4, 192, 50, 16, 6, 147, 2025, 19, 14, 22, 4, 1920, 4613, 469, 4, 22, 71, 87, 12, 16, 43, 530, 38, 76, 15, 13, 1247, 4, 22, 17, 515, 17, 12, 16, 626, 18, 19193, 5, 62, 386, 12, 8, 316, 8, 106, 5, 4, 2223, 5244, 16, 480, 66, 3785, 33, 4, 130, 12, 16, 38, 619, 5, 25, 124, 51, 36, 135, 48, 25, 1415, 33, 6, 22, 12, 215, 28, 77, 52, 5, 14, 407, 16, 82, 10311, 8, 4, 107, 117, 5952, 15, 256, 4, 2, 7, 3766, 5, 723, 36, 71, 43, 530, 476, 26, 400, 317, 46, 7, 4, 12118, 1029, 13, 104, 88, 4, 381, 15, 297, 98, 32, 2071, 56, 26, 141, 6, 194, 7486, 18, 4, 226, 22, 21, 134, 476, 26, 480, 5, 144, 30, 5535, 18, 51, 36, 28, 224, 92, 25, 104, 4, 226, 65, 16, 38, 1334, 88, 12, 16, 283, 5, 16, 4472, 113, 103, 32, 15, 16, 5345, 19, 178, 32] 훈련 데이터의 첫 번째 샘플의 레이블 : 1 정수 1이 출력되는데 이는 첫 번째 리뷰가 긍정 리뷰임을 의미합니다. 각 리뷰의 평균 길이를 계산해 봅시다. print('훈련용 리뷰의 평 규 길이: {}'.format(np.mean(list(map(len, X_train)), dtype=int))) print('테스트용 리뷰의 평균 길이: {}'.format(np.mean(list(map(len, X_test)), dtype=int))) 훈련용 리뷰의 평 규 길이: 238 테스트용 리뷰의 평균 길이: 230 훈련용 리뷰와 테스트용 리뷰의 평균 길이가 각각 238, 230입니다. 평균보다는 큰 수치인 400으로 패딩 합니다. max_len = 400 X_train = pad_sequences(X_train, maxlen=max_len) X_test = pad_sequences(X_test, maxlen=max_len) print('X_train의 크기(shape) :', X_train.shape) print('X_test의 크기(shape) :', X_test.shape) X_train shape : (25000, 400) X_test shape : (25000, 400) 2. 모델 설계하기 모델의 입력으로 사용하기 위한 모든 전처리를 마쳤습니다. 임베딩 벡터를 평균으로 사용하는 모델을 설계해 봅시다. GlobalAveragePooling1D()은 입력으로 들어오는 모든 벡터들의 평균을 구하는 역할을 합니다. Embedding() 다음에 GlobalAveragePooling1D()을 추가하면 해당 문장의 모든 단어 벡터들의 평균 벡터를 구합니다. 이진 분류를 수행해야 하므로 그 후에는 시그모이드 함수를 활성화 함수로 사용하는 뉴런 1개를 배치합니다. 훈련 데이터의 20%를 검증 데이터로 사용하고 총 10 에포크 학습합니다. from tensorflow.keras.models import Sequential, load_model from tensorflow.keras.layers import Dense, Embedding, GlobalAveragePooling1D from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint embedding_dim = 64 model = Sequential() model.add(Embedding(vocab_size, embedding_dim)) # 모든 단어 벡터의 평균을 구한다. model.add(GlobalAveragePooling1D()) model.add(Dense(1, activation='sigmoid')) es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=4) mc = ModelCheckpoint('embedding_average_model.h5', monitor='val_acc', mode='max', verbose=1, save_best_only=True) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['acc']) model.fit(X_train, y_train, batch_size=32, epochs=10, callbacks=[es, mc], validation_split=0.2) 학습이 끝난 후에 테스트 데이터에 대해서 평가합니다. loaded_model = load_model('embedding_average_model.h5') print("\n 테스트 정확도: %.4f" % (loaded_model.evaluate(X_test, y_test)[1])) 테스트 정확도: 0.8876 별다른 신경망을 추가하지 않고 단어 벡터의 평균만으로도 88.76%라는 준수한 정확도를 얻어냅니다. 09-13 Doc2Vec으로 공시 사업보고서 유사도 계산하기 Word2Vec은 단어를 임베딩하는 워드 임베딩 알고리즘이었습니다. Doc2Vec은 Word2Vec을 변형하여 문서의 임베딩을 얻을 수 있도록 한 알고리즘입니다. 논문 제목과 논문의 링크는 아래와 같습니다. 논문 제목 : Distributed Representations of Sentences and Documents 논문 링크 : https://arxiv.org/abs/1405.4053 Word2Vec과 마찬가지로 파이썬 머신 러닝 패키지인 Gensim을 통해서 쉽게 사용할 수 있습니다. 이번 실습에서는 저자가 수집해놓은 전자공시시스템(Dart)에 올라와 있는 각 회사의 사업보고서를 Doc2Vec을 통해서 학습시키고, 특정 회사와 사업 보고서가 유사한 회사들을 찾아보겠습니다. 1. 공시 사업 보고서 로드 및 전처리 해당 실습은 형태소 분석기 Mecab의 원활한 설치를 위해서 구글의 Colab에서 진행했다고 가정합니다. 여러분들의 컴퓨터에 Mecab을 설치하였거나, 다른 형태소 분석기를 사용한다면 Colab에서 하지 않더라도 상관없습니다. # dart.csv 파일 다운로드 !wget --load-cookies /tmp/cookies.txt "https://docs.google.com/uc? export=download&confirm=$(wget --quiet --save-cookies /tmp/cookies.txt --keep-session-cookies --no-check-certificate 'https://docs.google.com/uc?export=download&id=1XS0UlE8gNNTRjnL6e64sMacOhtVERIqL' -O- | sed -rn 's/.*confirm=([0-9A-Za-z_]+).*/\1\n/p')&id=1XS0UlE8gNNTRjnL6e64sMacOhtVERIqL" -O dart.csv && rm -rf /tmp/cookies.txt # 형태소 분석기 Mecab 설치 !pip install konlpy !pip install mecab-python !bash <(curl -s https://raw.githubusercontent.com/konlpy/konlpy/master/scripts/mecab.sh) import pandas as pd from konlpy.tag import Mecab from gensim.models.doc2vec import TaggedDocument from tqdm import tqdm dart.csv 파일을 데이터 프레임으로 로드합니다. 그리고 결측값을 가진 샘플을 제거해 줍니다. df = pd.read_csv('/content/dart.csv', sep=',') df = df.dropna() df 총 2,295개의 행과 4개의 열로 구성돼 있습니다. 첫 번째 열은 종목 번호에 해당하는 code 열, 두 번째 열은 해당 종목이 KOSPI 인지 KOSDAQ 인지를 알려주는 market 열, 세 번째 열은 회사명에 해당하는 name 열, 그리고 네 번째 business 열은 우리가 학습할 사업 보고서에 해당됩니다. 이제 business 열에 대해서 형태소 분석을 수행해 봅시다. 이와 동시에 Doc2Vec 학습을 위해서 필요한<NAME>으로 데이터의<NAME>을 변환합니다. Doc2Vec 학습을 위해서는 해당 문서의 '제목'과 단어 토큰 화가 된 상태의 해당 문서의 '본문' 두 가지가 필요합니다. TaggedDocument의 tags에 해당 문서의 '제목'을, 그리고 words에 해당 문서의 '본문'에 해당하는 단어 토큰화 결과를 저장하고, 이 결과를 원소로 하는 파이썬 리스트인 tagged_corpus_list를 만듭니다. mecab = Mecab() tagged_corpus_list = [] for index, row in tqdm(df.iterrows(), total=len(df)): text = row['business'] tag = row['name'] tagged_corpus_list.append(TaggedDocument(tags=[tag], words=mecab.morphs(text))) print('문서의 수 :', len(tagged_corpus_list)) 문서의 수 : 2295 첫 번째 문서의 전처리 결과를 확인해 봅시다. tagged_corpus_list[0] TaggedDocument(words=['II', '.', '사업', '의', '내용', '1', '.', '사업', '의', '개요', '가', '.', '일반', '적', '인', '사항', '기업', '회계', '기준', '서', '제', '1110', '호', '"', '연결', '재무제표', '"', '의', '의하', '여', '2018', '년', '12', '월', '17', '일', '에', '설립', '한', '동화', '크립톤', '기업가', '정신', '제일', '호', '창업', '벤처', '전문', '사모', '투자', '합자회사', '를', '종속', '회사', '에', '편입', '하', '였', '습니다', ... 중략 ... '대기', '관리', '권', '역', '의', '대기', '환경', '개선', '에', '관한', '특별법', '을', '준', '수', '하', '고', '있', '습니다', '.'], tags=['동화약품']) TaggedDocument 안 words에는 토큰화된 사업 보고서, tags에는 해당 문서의 제목이 저장돼 있습니다. 2. Doc2Vec 학습 및 테스트 이제 모델을 학습합니다. 사업 보고서가 꽤 긴 문서인데다 토큰화 외에 불용어 제거 등 별도 추가 전처리를 진행하지 않았기 때문에 저자가 Colab에서 수행했을 때, 소요 시간이 최소 1시간 이상 걸렸습니다. from gensim.models import doc2vec model = doc2vec.Doc2Vec(vector_size=300, alpha=0.025, min_alpha=0.025, workers=8, window=8) # Vocabulary 빌드 model.build_vocab(tagged_corpus_list) print(f"Tag Size: {len(model.docvecs.doctags.keys())}", end=' / ') # Doc2Vec 학습 model.train(tagged_corpus_list, total_examples=model.corpus_count, epochs=50) # 모델 저장 model.save('dart.doc2vec') 코드를 다 수행하고 나면 3개의 파일이 생깁니다. dart.doc2vec dart.doc2vec.trainables.syn1neg.npy dart.doc2vec.wv.vectors.npy 이제 모델을 테스트해 봅시다. 회사 동화약품과 사업 보고서가 유사한 회사들은 어디일까요? similar_doc = model.docvecs.most_similar('동화약품') print(similar_doc) [('종근당', 0.5310906171798706), ('삼일제약', 0.5263979434967041), ('일양 약품', 0.5260423421859741), ('영진약품', 0.5254894495010376), ('제일약품', 0.5089458227157593), ('유한양행', 0.5015101432800293), ('국제약품', 0.4985279440879822), ('삼아제약', 0.49677950143814087), ('동아에스티', 0.49451446533203125), ('대웅제약', 0.48559868335723877)] 이 외에 다른 테스트에서도 관련 업종의 회사들이 나오는 것을 확인할 수 있었습니다. similar_doc = model.docvecs.most_similar('하이트진로') print(similar_doc) [('하이트진로홀딩스', 0.8621307611465454), ('무학', 0.5214779376983643), ('보해양조', 0.5100635290145874), ('국순당', 0.48447638750076294), ('롯데칠성', 0.4617755115032196), ('금비', 0.4156178832054138), ('삼양 패키징', 0.40965551137924194), ('삼광글라스', 0.40689679980278015), ('경방', 0.40154141187667847), ('오뚝이', 0.3958606719970703)] similar_doc = model.docvecs.most_similar('LG이노텍') print(similar_doc) [('LG전자', 0.533338725566864), ('LG', 0.523799479007721), ('삼성전기', 0.45796477794647217), ('LG디스플레이', 0.4485859274864197), ('서울반도체', 0.42762115597724915), ('루멘스', 0.42333459854125977), ('삼성SDI', 0.4111291170120239), ('큐엠씨', 0.409035325050354), ('서울바이오 시스', 0.4087420105934143), ('삼성공조', 0.4040142595767975)] similar_doc = model.docvecs.most_similar('메리츠화재') print(similar_doc) [('메리츠금융 지주', 0.7080470323562622), ('한화손해보험', 0.69782555103302), ('롯데손해보험', 0.6945951581001282), ('DB손해보험', 0.6699072122573853), ('한화생명', 0.665973961353302), ('흥국화재', 0.6471891403198242), ('현대해상', 0.6267702579498291), ('코리안리', 0.5982924699783325), ('삼성화재', 0.5873793959617615), ('동양생명', 0.5722818970680237)] similar_doc = model.docvecs.most_similar('카카오') print(similar_doc) [('네오위즈', 0.5055375099182129), ('NAVER', 0.4846588373184204), ('네오위즈 홀딩스', 0.47819197177886963), ('퓨처스트림네트웍스', 0.4654642939567566), ('신풍제약 우', 0.46335992217063904), ('LG생활건강 우', 0.4604458212852478), ('금호석유우', 0.4568769931793213), ('컴투스', 0.4565160274505615), ('코리아써키트 2우 B', 0.45594915747642517), ('세방 우', 0.4553225636482239)] 09-14 실전! 한국어 위키피디아로 Word2Vec 학습하기 아래의 실습은 구글의 Colab을 사용한다고 가정하고 작성되었습니다. 다른 환경에서 실습하셔도 상관은 없지만, 형태소 분석기 Mecab은 다른 방법으로 설치하셔야 합니다. 1. 위키피디아로부터 데이터 다운로드 및 통합 위키피디아로부터 데이터를 파싱 하기 위한 파이썬 패키지인 wikiextractor를 설치합니다. pip install wikiextractor 위키피디아 데이터를 다운로드 한 후에 전처리에서 사용할 형태소 분석기인 Mecab을 설치합니다. # Colab에 Mecab 설치 !git clone https://github.com/SOMJANG/Mecab-ko-for-Google-Colab.git %cd Mecab-ko-for-Google-Colab !bash install_mecab-ko_on_colab190912.sh 위키피디아 덤프(위키피디아 데이터)를 다운로드합니다. !wget https://dumps.wikimedia.org/kowiki/latest/kowiki-latest-pages-articles.xml.bz2 위키익스트랙터를 사용하여 위키피디아 덤프를 파싱 합니다. !python -m wikiextractor.WikiExtractor kowiki-latest-pages-articles.xml.bz2 현재 경로에 있는 디렉터리와 파일들의 리스트를 받아옵니다. %ls images/ LICENSE install_mecab-ko_on_colab190912.sh README.md install_mecab-ko_on_colab_light_210108.sh text/ kowiki-latest-pages-articles.xml.bz2 text라는 디렉터리 안에는 또 어떤 디렉터리들이 있는지 파이썬을 사용하여 확인해 봅시다. import os import re os.listdir('text') ['AG', 'AI', 'AH', 'AC', 'AE', 'AB', 'AA', 'AD', 'AF'] AA라는 디렉터리의 파일들을 확인해 봅시다. %ls text/AA wiki_00 wiki_12 wiki_24 wiki_36 wiki_48 wiki_60 wiki_72 wiki_84 wiki_96 wiki_01 wiki_13 wiki_25 wiki_37 wiki_49 wiki_61 wiki_73 wiki_85 wiki_97 wiki_02 wiki_14 wiki_26 wiki_38 wiki_50 wiki_62 wiki_74 wiki_86 wiki_98 wiki_03 wiki_15 wiki_27 wiki_39 wiki_51 wiki_63 wiki_75 wiki_87 wiki_99 wiki_04 wiki_16 wiki_28 wiki_40 wiki_52 wiki_64 wiki_76 wiki_88 wiki_05 wiki_17 wiki_29 wiki_41 wiki_53 wiki_65 wiki_77 wiki_89 wiki_06 wiki_18 wiki_30 wiki_42 wiki_54 wiki_66 wiki_78 wiki_90 wiki_07 wiki_19 wiki_31 wiki_43 wiki_55 wiki_67 wiki_79 wiki_91 wiki_08 wiki_20 wiki_32 wiki_44 wiki_56 wiki_68 wiki_80 wiki_92 wiki_09 wiki_21 wiki_33 wiki_45 wiki_57 wiki_69 wiki_81 wiki_93 wiki_10 wiki_22 wiki_34 wiki_46 wiki_58 wiki_70 wiki_82 wiki_94 wiki_11 wiki_23 wiki_35 wiki_47 wiki_59 wiki_71 wiki_83 wiki_95 텍스트 파일로 변환된 위키피디아 한국어 덤프는 총 6개의 디렉터리로 구성돼 있습니다. AA ~ AF의 디렉터리로 각 디렉터리 내에는 'wiki_00 ~ wiki_약 90내외의 숫자'의 파일들이 들어있습니다. 다시 말해 각 디렉터리에는 약 90여 개의 파일들이 들어있습니다. 각 파일들을 열어보면 이와 같은 구성이 반복되고 있습니다. <doc id="문서 번호" url="실제 위키피디아 문서 주소" title="문서 제목"> 내용 </doc> 예를 들어서 AA 디렉터리의 wiki_00 파일을 읽어보면, 지미 카터에 대한 내용이 나옵니다. <doc id="5" url="https://ko.wikipedia.org/wiki?curid=5" title="지미 카터"> 지미 카터 제임스 얼 "지미" 카터 주니어(, 1924년 10월 1일 ~ )는 민주당 출신 미국 39번째 대통령(1977년 ~ 1981년)이다. 지미 카터는 조지아 주 섬터 카운티 플레인스 마을에서 태어났다. 조지아 공과대학교를 졸업하였다. 그 후 해군에 들어가 전함·원자력·잠수함의 승무원으로 일하였다. 1953년 미국 해군 대 위로 예편하였고 이후 땅콩·면화 등을 가꿔 많은 돈을 벌었다. ... 이하 중략... </doc> 이제 이 6개 AA ~ AF 디렉터리 안의 wiki 숫자 형태의 수많은 파일들을 하나로 통합하는 과정을 진행해야 합니다. AA ~ AF 디렉터리 안의 모든 파일들의 경로를 파이썬의 리스트 형태로 저장합니다. def list_wiki(dirname): filepaths = [] filenames = os.listdir(dirname) for filename in filenames: filepath = os.path.join(dirname, filename) if os.path.isdir(filepath): # 재귀 함수 filepaths.extend(list_wiki(filepath)) else: find = re.findall(r"wiki_[0-9][0-9]", filepath) if 0 < len(find): filepaths.append(filepath) return sorted(filepaths) filepaths = list_wiki('text') 총 파일의 개수를 확인해 봅시다. len(filepaths) 850 총 파일의 개수는 850개입니다. 이제 output_file.txt라는 파일에 850개의 파일을 전부 하나로 합칩니다. with open("output_file.txt", "w") as outfile: for filename in filepaths: with open(filename) as infile: contents = infile.read() outfile.write(contents) 파일을 읽고 10줄만 출력해 보겠습니다. f = open('output_file.txt', encoding="utf8") i = 0 while True: line = f.readline() if line != '\n': i = i+1 print("%d 번째 줄 :"%i + line) if i==10: break f.close() 1번째 줄 :<doc id="5" url="https://ko.wikipedia.org/wiki? curid=5" title="지미 카터"> 2번째 줄 :지미 카터 3번째 줄 :제임스 얼 카터 주니어(, 1924년 10월 1일 ~ )는 민주당 출신 미국 39대 대통령 (1977년 ~ 1981년)이다. 4번째 줄 :생애. 5번째 줄 :어린 시절. 6번째 줄 :지미 카터는 조지아주 섬터 카운티 플레인스 마을에서 태어났다. 7번째 줄 :조지아 공과대학교를 졸업하였다. 그 후 해군에 들어가 전함·원자력·잠수함의 승무원으로 일하였다. 1953년 미국 해군 대위로 예편하였고 이후 땅콩·면화 등을 가꿔 많은 돈을 벌었다. 그의 별명이 "땅콩 농부" (Peanut Farmer)로 알려졌다. 8번째 줄 :정계 입문. 9번째 줄 :1962년 조지아 주<NAME> 의원 선거에서 낙선하나 그 선거가 부정선거였음을 입증하게 되어 당선되고, 1966년 조지아 주지사 선거에 낙선하지만, 1970년 조지아 주지사를 역임했다. 대통령이 되기 전 조지아주<NAME> 의원을 두 번 연임했으며, 1971년부터 1975년까지 조지아 지사로 근무했다. 조지아 주지사로 지내면서, 미국에 사는 흑인 등용 법을 내세웠다. 10번째 줄 :대통령 재임. 2. 형태소 분석 from tqdm import tqdm from konlpy.tag import Mecab 형태소 분석기 Mecab을 사용하여 토큰화를 진행해 보겠습니다. mecab = Mecab() 우선 output_file에는 총 몇 줄이 있는지 확인합니다. f = open('output_file.txt', encoding="utf8") lines = f.read().splitlines() print(len(lines)) 9718793 9,718,793개의 줄이 존재합니다. 상위 10개만 출력해 봅시다. lines[:10] ['<doc id="5" url="https://ko.wikipedia.org/wiki? curid=5" title="지미 카터">', '지미 카터', '', '제임스 얼 카터 주니어(, 1924년 10월 1일 ~ )는 민주당 출신 미국 39대 대통령 (1977년 ~ 1981년)이다.', '생애.', '어린 시절.', '지미 카터는 조지아주 섬터 카운티 플레인스 마을에서 태어났다.', '조지아 공과대학교를 졸업하였다. 그 후 해군에 들어가 전함·원자력·잠수함의 승무원으로 일하였다. 1953년 미국 해군 대위로 예편하였고 이후 땅콩·면화 등을 가꿔 많은 돈을 벌었다. 그의 별명이 "땅콩 농부" (Peanut Farmer)로 알려졌다.', '정계 입문.', '1962년 조지아 주<NAME> 의원 선거에서 낙선하나 그 선거가 부정선거였음을 입증하게 되어 당선되고, 1966년 조지아 주지사 선거에 낙선하지만, 1970년 조지아 주지사를 역임했다. 대통령이 되기 전 조지아주<NAME> 의원을 두 번 연임했으며, 1971년부터 1975년까지 조지아 지사로 근무했다. 조지아 주지사로 지내면서, 미국에 사는 흑인 등용 법을 내세웠다.'] 두 번째 줄을 보면 아무런 단어도 들어있지 않은 ''와 같은 줄도 존재합니다. 해당 문자열은 형태소 분석에서 제외하도록 하고 형태소 분석을 수행해 봅시다. result = [] for line in tqdm(lines): # 빈 문자열이 아닌 경우에만 수행 if line: result.append(mecab.morphs(line)) 100%|██████████| 9718793/9718793 [15:27<00:00, 10478.61it/s] 빈 문자열은 제외하고 형태소 분석을 진행했습니다. 이제 몇 개의 줄. 즉, 몇 개의 문장이 존재하는지 확인해 봅시다. len(result) 6559314 6,559,314개로 문장의 수가 줄었습니다. 3. Word2Vec 학습 형태소 분석을 통해서 토큰 화가 진행된 상태이므로 Word2Vec을 학습합니다. from gensim.models import Word2Vec model = Word2Vec(result, size=100, window=5, min_count=5, workers=4, sg=0) model_result1 = model.wv.most_similar("대한민국") print(model_result1) [('한국', 0.7382678389549255), ('미국', 0.6731516122817993), ('일본', 0.6541135907173157), ('부산', 0.5798133611679077), ('홍콩', 0.5752249360084534), ('서울', 0.5541036128997803), ('오스트레일리아', 0.5531408786773682), ('태국', 0.548468828201294), ('경상남도', 0.5462549924850464), ('제주특별자치도', 0.5385439395904541)] model_result2 = model.wv.most_similar("어벤저스") print(model_result2) [('스파이더맨', 0.80271977186203), ('트랜스포머', 0.773989200592041), ('아이언맨', 0.7648921012878418), ('스타트렉', 0.7645636796951294), ('어벤저스', 0.7626765966415405), ('엑스맨', 0.7586475610733032), ('《》,', 0.7560415267944336), ('트와일라잇', 0.7518032789230347), ('퍼니셔', 0.7391209602355957), ('테일즈', 0.7386105060577393)] model_result3 = model.wv.most_similar("반도체") print(model_result3) [('집적회로', 0.7714468836784363), ('연료전지', 0.7699108719825745), ('전자', 0.7606919407844543), ('웨이퍼', 0.745188295841217), ('실리콘', 0.743209958076477), ('트랜지스터', 0.7398351430892944), ('PCB', 0.7275883555412292), ('TSMC', 0.7156406044960022), ('가속기', 0.6962155699729919), ('광전자', 0.6957612037658691)] 10. RNN을 이용한 텍스트 분류(Text Classification) 텍스트 분류(Text Classification)는 텍스트를 입력으로 받아 텍스트가 어떤 종류의 범주에 속하는지를 구분하는 작업을 말합니다. 가령, 스팸 메일 분류를 한다고 한다면, 스팸 메일 분류는 일반 메일과 스팸 메일이라는 두 개의 범주를 정해놓고 입력받은 메일 본문을 두 개의 메일 종류 중 하나로 분류하는 작업이 될 것입니다. 텍스트 분류에서 분류해야 할 범주가 두 가지라면 이진 분류(Binary Classification)라고 하며, 세 가지 이상이라면 다중 클래스 분류(Multi-Class Classification)라고 합니다. 일반 메일과 스팸 메일 두 개의 범주를 가진 스팸 메일 분류는 이진 분류에 해당됩니다. 스팸 메일 분류 외에도 영화 리뷰와 같은 텍스트를 입력받아서 이 리뷰가 긍정 리뷰인지 부정 리뷰인지를 분류하는 '감성 분석', 입력받은 텍스트로부터 사용자의 의도를 질문, 명령, 거절 등과 같은 의도를 분류하는 '의도 분석' 과 같은 분류 문제들이 있습니다. 이번 챕터에서는 RNN 계열의 신경망 바닐라 RNN, LSTM, GRU를 사용하여 텍스트 분류를 수행해 보고, 딥 러닝 코드에 대한 이해도를 높입니다. 10-01 케라스를 이용한 텍스트 분류 개요(Text Classification using Keras) 이번 챕터에서는 인공 신경망을 이용하여 텍스트 분류를 수행합니다. 1. 훈련 데이터에 대한 이해 앞으로 진행하는 텍스트 분류 실습은 지도 학습(Supervised Learning)에 속합니다. 지도 학습의 훈련 데이터는 레이블이라는 이름의 미리 정답이 적혀있는 데이터로 구성되어 있습니다. 비유하면, 기계는 정답이 적혀져 있는 문제지를 열심히 공부하고, 향후에 정답이 없는 문제에 대해서도 정답을 예측해서 대답하게 되는 메커니즘입니다. 예를 들어 스팸 메일 분류기의 훈련 데이터 같은 경우에는 메일의 내용과 해당 메일이 정상 메일인지, 스팸 메일인지 적혀있는 레이블로 구성돼 있습니다. 아래와 같은<NAME>의 메일 샘플이 약 20,000개 있다고 가정해 봅시다. 텍스트(메일의 내용) 레이블(스팸 여부) 당신에게 드리는 마지막 혜택! ... 스팸 메일 내일 뵐 수 있을지 확인 부탁... 정상 메일 쉿! 혼자 보세요... 스팸 메일 언제까지 답장 가능할... 정상 메일 ... ... (광고) 멋있어질 수 있는... 스팸 메일 20,000개의 메일 샘플을 가진 이 데이터는 메일의 내용을 담고 있는 텍스트 데이터와 이 데이터가 스팸 메일인지 아닌지가 적혀있는 레이블. 두 가지 열로 이루어져 있습니다. 기계가 이 20,000개의 메일 샘플 데이터를 학습했다고 해봅시다. 만약 데이터에 문제가 없고, 모델 또한 잘 설계돼 있다면 학습이 다 된 이 모델은 훈련 데이터에 존재하지 않았던 어떤 메일 텍스트가 주어지더라도 정확한 레이블을 예측하게 됩니다. 2. 훈련 데이터와 테스트 데이터 위에서는 20,000개의 메일 샘플을 전부 훈련에 사용한다고 했지만 사실 갖고 있는 전체 데이터를 전부 훈련에 사용하는 것보다는 테스트용은 일부 남겨놓는 것으로 바람직합니다. 예를 들어 20,000개의 샘플 중 18,000개의 샘플은 훈련용으로 사용하고, 2,000개의 샘플은 테스트용으로 보류한 채 훈련 과정에서는 사용하지 않을 수 있습니다. 그 후 훈련이 끝나면, 보류해두었던 2,000개의 테스트용 샘플로 모델에게 레이블은 보여주지 않고, 모델에게 레이블을 맞춰보라고 요구한 뒤, 채점을 통해 정확도(accuracy)를 계산할 수 있습니다. 이번 챕터에서는 갖고 있는 데이터 중 분류 대상인 텍스트 데이터의 열을 X, 레이블 데이터의 열을 y라고 명명합니다. 그리고 이를 훈련 데이터(X_train, y_train)와 테스트 데이터(X_test, y_test)로 분리합니다. 모델은 X_train과 y_train을 학습하고, X_test에 대해서 레이블을 예측하게 됩니다. 그리고 모델이 예측한 레이블과 y_test를 비교해서 정확도를 계산합니다. 3. 단어에 대한 정수 부여 케라스의 Embedding()은 단어 각각에 대해 정수로 변환된 입력에 대해서 임베딩 작업을 수행합니다. 단어 각각에 숫자 매핑, 정수를 부여하는 방법으로는 정수 인코딩 챕터에서와 같이 단어를 빈도수 순대로 정렬하고 순차적으로 정수를 부여하는 방법이 있습니다. 로이터 뉴스 분류하기와 IMDB 리뷰 감성 분류하기 실습에서도 이 방법을 사용하였으며, 해당 실습에서 사용할 데이터들은 이미 이 작업이 끝난 상태입니다. 등장 빈도 순으로 단어를 정렬하여 정수를 부여하였을 때의 장점은 등장 빈도수가 적은 단어의 제거입니다. 예를 들어서 25,000개의 단어가 있다고 가정하고, 해당 단어를 등장 빈도수 순가 높은 순서로 1부터 25,000까지 정수를 부여했다고 해보겠습니다. 이렇게 되면 등장 빈도 순으로 등수가 부여된 것과 다름없으므로 전처리 작업에서 1,000보다 큰 정수로 매핑된 단어들을 제거한다면 등장 빈도 상위 1,000개의 단어만 남길 수 있습니다. 4. RNN으로 분류하기 model.add(SimpleRNN(hidden_units, input_shape=(timesteps, input_dim))) RNN 코드의 인자는 다음과 같습니다. hidden_units = RNN의 출력의 크기 = 은닉 상태의 크기. timesteps = 시점의 수 = 각 문서에서의 단어 수. input_dim = 입력의 크기 = 임베딩 벡터의 차원. 5. RNN의 다-대-일(Many-to-One) 문제 텍스트 분류는 RNN의 다 대 일(many-to-one) 문제에 속합니다. 즉, 텍스트 분류는 모든 시점(time step)에 대해서 입력을 받지만 최종 시점의 RNN 셀 만이 은닉 상태를 출력하고, 이것이 출력층으로 가서 활성화 함수를 통해 정답을 고르는 문제가 됩니다. 이때 두 개의 선택지 중에서 정답를 고르는 이진 분류(Binary Classification) 문제라고 하며, 세 개 이상의 선택지 중에서 정답을 고르는 다중 클래스 분류(Multi-Class Classification) 문제라고 합니다. 이 두 문제에서는 각각 문제에 맞는 활성화 함수와 손실 함수를 사용해야 합니다. 이진 분류의 문제의 경우 출력층의 활성화 함수로 시그모이드 함수를, 손실 함수로 binary_crossentropy를 사용합니다. 반면, 다중 클래스 문제라면 출력층의 활성화 함수로 소프트맥스 함수를, 손실 함수로 categorical_crossentropy를 사용합니다. 또한, 다중 클래스 분류 문제의 경우에는 클래스가 N 개라면 출력층에 해당되는 밀집층(dense layer)의 크기는 N으로 합니다. 다르게 표현하면 출력층 뉴런의 수는 N 개입니다. 이번 챕터에서 스팸 메일 분류하기나 감성 분류하기 실습들이 이진 분류 문제에 해당되며, 로이터 뉴스 분류하기 문제가 다중 클래스 분류 문제에 해당됩니다. 10-02 스팸 메일 분류하기(Spam Detection) 캐글에서 제공하는 스팸 메일 데이터를 학습시켜 스팸 메일 분류기를 구현해 보겠습니다. 1. 스팸 메일 데이터에 대한 이해 다운로드 링크 : https://www.kaggle.com/uciml/sms-spam-collection-dataset import numpy as np import pandas as pd import matplotlib.pyplot as plt import urllib.request from sklearn.model_selection import train_test_split from tensorflow.keras.preprocessing.text import Tokenizer from tensorflow.keras.preprocessing.sequence import pad_sequences 다운로드한 spam.csv 파일을 데이터 프레임으로 로드하고 총 샘플의 수를 확인해 봅시다. urllib.request.urlretrieve("https://raw.githubusercontent.com/ukairia777/tensorflow-nlp-tutorial/main/10.%20RNN%20Text%20Classification/dataset/spam.csv", filename="spam.csv") data = pd.read_csv('spam.csv', encoding='latin1') print('총 샘플의 수 :',len(data)) 총 샘플의 수 : 5572 총 5,572개의 샘플이 존재합니다. 상위 5개의 샘플만 출력해 봅시다. data[:5] 스팸 메일 데이터 중에서 5개의 행만 출력해 보았습니다. 이 데이터에는 총 5개의 열이 있는데, 여기서 Unnamed라는 이름의 3개의 열은 텍스트 분류를 할 때 불필요한 열입니다. v1열은 해당 메일이 스팸인지 아닌지를 나타내는 레이블에 해당되는 열입니다. ham은 정상 메일을 의미하고, spam은 스팸 메일을 의미합니다. v2열은 메일의 본문을 담고 있습니다. 레이블과 메일 내용이 담긴 v1 열과 v2열만 필요하므로, Unnamed: 2, Unnamed: 3, Unnamed: 4 열은 삭제합니다. 또한, v1 열에 있는 ham과 spam 레이블을 각각 숫자 0과 1로 바꾸겠습니다. 다시 data에서 5개의 행만 출력해 보겠습니다. del data['Unnamed: 2'] del data['Unnamed: 3'] del data['Unnamed: 4'] data['v1'] = data['v1'].replace(['ham','spam'],[0,1]) data[:5] 불필요한 열이 제거되고 v1 열의 값이 숫자로 변환된 것을 확인할 수 있습니다. 해당 데이터 프레임의 정보를 확인해 보겠습니다. data.info() <class 'pandas.core.frame.DataFrame'> RangeIndex: 5572 entries, 0 to 5571 Data columns (total 2 columns): v1 5572 non-null int64 v2 5572 non-null object dtypes: int64(1), object(1) memory usage: 87.1+ KB v1열은 정수형, v2열은 문자열 데이터를 갖고 있습니다. Null 값을 가진 샘플이 있는지 isnull().values.any()로 확인합니다. print('결측값 여부 :',data.isnull().values.any()) 결측값 여부 : False False는 별도의 Null 값은 없음을 의미합니다. 초기 데이터에 'Unnamed: 2', 'Unnamed: 3', 'Unnamed: 4'열에는 NaN이 있었는데 해당 상태에서 수행하는 isnull().values.any()는 True를 리턴합니다. Null 값이 없다면 데이터에 중복이 있는지 확인해 보겠습니다. print('v2 열의 유니크한 값 :',data['v2'].nunique()) v2 열의 유니크한 값 : 5169 총 5,572개의 샘플이 존재하는데 v2열에서 중복을 제거한 샘플의 개수가 5,169개라는 것은 403개의 중복 샘플이 존재한다는 의미입니다. 중복 샘플을 제거하고 전체 샘플 수를 확인합니다. # v2 열에서 중복인 내용이 있다면 중복 제거 data.drop_duplicates(subset=['v2'], inplace=True) print('총 샘플의 수 :',len(data)) 총 샘플의 수 : 5169 총 샘플의 수가 5,572개에서 5,169개로 줄었습니다. 레이블 값의 분포를 시각화합니다. data['v1'].value_counts().plot(kind='bar') 레이블이 대부분 0에 편중되어 있는데, 이는 스팸 메일 데이터의 대부분의 메일이 정상 메일임을 의미합니다. 정확한 수치를 파악해 보겠습니다. print('정상 메일과 스팸 메일의 개수') print(data.groupby('v1').size().reset_index(name='count')) 정상 메일과 스팸 메일의 개수 v1 count 0 0 4516 1 1 653 레이블 0은 총 4,516개가 존재하고 1은 653개가 존재합니다. 이를 %로 환산합니다. print(f'정상 메일의 비율 = {round(data["v1"].value_counts()[0]/len(data) * 100,3)}%') print(f'스팸 메일의 비율 = {round(data["v1"].value_counts()[1]/len(data) * 100,3)}%') 정상 메일의 비율 = 87.367% 스팸 메일의 비율 = 12.633% v2 열과 v1열을 X 데이터와 y 데이터라는 X_data, y_data로 저장합니다. X_data = data['v2'] y_data = data['v1'] print('메일 본문의 개수: {}'.format(len(X_data))) print('레이블의 개수: {}'.format(len(y_data))) 메일 본문의 개수: 5169 레이블의 개수: 5169 훈련 데이터와 테스트 데이터를 분리합니다. 주의할 점은 현재 레이블이 굉장히 불균형합니다. 다시 말해 정상 메일 샘플(87%, 4516개)에 비해서 스팸 메일 샘플(12%, 653개)이 굉장히 적습니다. 만약, 훈련 데이터와 테스트 데이터를 분리하는 과정에서 우연히 대부분의 스팸 메일 샘플이 테스트 데이터에 포함되고 훈련 데이터에는 대부분 정상 메일 샘플만 포함되게 된다면 어떻게 될까요? 학습 과정에서 모델은 스팸 메일 샘플을 거의 관측하지 못해서 모델의 성능이 저하될 것입니다. 이렇게 레이블이 불균형한 경우에는 데이터를 나눌 때에도 훈련 데이터와 테스트 데이터에 각 레이블의 분포가 고르게 분포되도록 하는 것이 중요할 수 있습니다. 사이킷 런의 train_test_split에 stratify의 인자로서 레이블 데이터를 기재하면 훈련 데이터와 테스트 데이터를 분리할 때 레이블의 분포가 고르게 분포하도록 합니다. test_size에 0.2를 기재하여 훈련 데이터와 테스트 데이터를 8:2 비율로 분리합니다. X_train, X_test, y_train, y_test = train_test_split(X_data, y_data, test_size=0.2, random_state=0, stratify=y_data) 훈련 데이터와 테스트 데이터가 분리되었습니다. 레이블이 고르게 분포되었는지 확인합니다. print('--------훈련 데이터의 비율-----------') print(f'정상 메일 = {round(y_train.value_counts()[0]/len(y_train) * 100,3)}%') print(f'스팸 메일 = {round(y_train.value_counts()[1]/len(y_train) * 100,3)}%') --------훈련 데이터의 비율----------- 정상 메일 = 87.376% 스팸 메일 = 12.624% print('--------테스트 데이터의 비율-----------') print(f'정상 메일 = {round(y_test.value_counts()[0]/len(y_test) * 100,3)}%') print(f'스팸 메일 = {round(y_test.value_counts()[1]/len(y_test) * 100,3)}%') --------테스트 데이터의 비율----------- 정상 메일 = 87.331% 스팸 메일 = 12.669% 훈련 데이터와 테스트 데이터 모두 정상 메일은 87%, 스팸 메일은 12%가 존재합니다. 케라스 토크 나이저를 통해 훈련 데이터에 대해서 토큰화와 정수 인코딩 과정을 수행합니다. X_train_encoded에는 X_train의 각 단어들이 매핑되는 정수로 인코딩되어 저장됩니다. 5개의 메일만 출력해서 확인해 보겠습니다. tokenizer = Tokenizer() tokenizer.fit_on_texts(X_train) X_train_encoded = tokenizer.texts_to_sequences(X_train) print(X_train_encoded[:5]) [[102, 1, 210, 230, 3, 17, 39], [1, 59, 8, 427, 17, 5, 137, 2, 2326], [157, 180, 12, 13, 98, 93, 47, 9, 40, 3485, 247, 8, 7, 87, 6, 80, 1312, 5, 3486, 7, 2327, 11, 660, 306, 20, 25, 467, 708, 1028, 203, 129, 193, 800, 2328, 23, 1, 144, 71, 2, 111, 78, 43, 2, 130, 11, 800, 186, 122, 1512], [1, 1154, 13, 104, 292], [222, 622, 857, 540, 623, 22, 23, 83, 10, 47, 6, 257, 32, 6, 26, 64, 936, 407]] 각 메일이 정수 인코딩이 되었습니다. 각 정수가 어떤 단어에 부여되었는지 확인해 봅시다. word_to_index = tokenizer.word_index print(word_to_index) {'i': 1, 'to': 2, 'you': 3, 'a': 4, 'the': 5, 'u': 6, 'and': 7, 'in': 8, 'is': 9, 'me': 10, 'my': 11, 'for': 12, 'your': 13, 'it': 14, 'of': 15, 'have': 16, 'on': 17, 'call': 18, 'that': 19, 'are': 20, '2': 21, 'now': 22, 'so': 23, 'but': 24, 'not': 25, 'can': 26, 'or': 27, "i'm": 28, 'get': 29, 'at': 30, 'do': 31, 'if': 32, 'be': 33, 'will': 34, 'just': 35, 'with': 36, 'we': 37, 'no': 38, 'this': 39, 'ur': 40, 'up': 41, '4': 42, 'how': 43, 'gt': 44, 'lt': 45, 'go': 46, 'when': 47, 'from': 48, 'what': 49, 'ok': 50, 'out': 51, 'know': 52, - 이하 생략} 무수히 많은 단어가 출력되므로 출력 결과는 중간에 생략했습니다. 위에서 부여된 각 정수는 각 단어의 빈도수가 높을수록 낮은 정수가 부여됩니다. 다시 말해, 단어 i는 현재 전체 훈련 데이터에서 빈도수가 가장 높은 단어입니다. 각 단어에 대한 등장 빈도수는 tokenizer.word_counts.items()를 출력해서 확인할 수 있습니다. 이를 응용하여 빈도수가 낮은 단어들이 훈련 데이터에서 얼마큼의 비중을 차지하는지 확인해 볼 수 있습니다. 등장 빈도수가 1회 밖에 되지 않는 단어들이 전체 단어 집합에서 얼마큼의 비율을 차지하며, 전체 훈련 데이터에서 등장 빈도로 얼마큼의 비율을 차지하는지 확인해 보겠습니다. threshold = 2 total_cnt = len(word_to_index) # 단어의 수 rare_cnt = 0 # 등장 빈도수가 threshold보다 작은 단어의 개수를 카운트 total_freq = 0 # 훈련 데이터의 전체 단어 빈도수 총합 rare_freq = 0 # 등장 빈도수가 threshold보다 작은 단어의 등장 빈도수의 총합 # 단어와 빈도수의 쌍(pair)을 key와 value로 받는다. for key, value in tokenizer.word_counts.items(): total_freq = total_freq + value # 단어의 등장 빈도수가 threshold보다 작으면 if(value < threshold): rare_cnt = rare_cnt + 1 rare_freq = rare_freq + value print('등장 빈도가 %s 번 이하인 희귀 단어의 수: %s'%(threshold - 1, rare_cnt)) print("단어 집합(vocabulary)에서 희귀 단어의 비율:", (rare_cnt / total_cnt)*100) print("전체 등장 빈도에서 희귀 단어 등장 빈도 비율:", (rare_freq / total_freq)*100) 등장 빈도가 1번 이하인 희귀 단어의 수: 4337 단어 집합(vocabulary)에서 희귀 단어의 비율: 55.45326684567191 전체 등장 빈도에서 희귀 단어 등장 빈도 비율: 6.65745644331875 등장 빈도가 threshold 값인 2회 미만. 즉, 1회 밖에 되지 않는 단어들은 단어 집합에서 무려 절반 이상을 차지합니다. 하지만, 실제로 훈련 데이터에서 등장 빈도로 차지하는 비중은 상대적으로 적은 수치인 6%밖에 되지 않습니다. 만약, 이러한 분석을 통해 등장 빈도가 지나치게 낮은 단어들은 자연어 처리에서 제외하고 싶다면 케라스 토크 나이저 선언 시에 단어 집합의 크기를 제한할 수 있습니다. 가령, 아래의 코드로 등장 빈도가 1회인 단어들을 제외할 수 있을 겁니다. tokenizer = Tokenizer(num_words = total_cnt - rare_cnt + 1) 하지만 이번 실습에서는 별도로 단어 집합의 크기를 제한하진 않겠습니다. 단어 집합의 크기를 vocab_size에 저장하겠습니다. 패딩을 위한 토큰인 0번 단어를 고려하며 +1을 해서 저장합니다. vocab_size = len(word_to_index) + 1 print('단어 집합의 크기: {}'.format((vocab_size))) 단어 집합의 크기: 7822 단어 집합의 크기는 7,822입니다. 전체 데이터에서 가장 길이가 긴 메일과 전체 메일 데이터의 길이 분포를 확인합니다. print('메일의 최대 길이 : %d' % max(len(sample) for sample in X_train_encoded)) print('메일의 평균 길이 : %f' % (sum(map(len, X_train_encoded))/len(X_train_encoded))) plt.hist([len(sample) for sample in X_data], bins=50) plt.xlabel('length of samples') plt.ylabel('number of samples') plt.show() 메일의 최대 길이 : 189 메일의 평균 길이 : 15.754534 가장 긴 메일의 길이는 189이며, 전체 데이터의 길이 분포는 대체적으로 약 50이하의 길이를 가집니다. max_len = 189 X_train_padded = pad_sequences(X_train_encoded, maxlen = max_len) print("훈련 데이터의 크기(shape):", X_train_padded.shape) maxlen에는 가장 긴 메일의 길이였던 189이라는 숫자를 넣었습니다. 이는 4,135개의 X_train_encoded의 길이를 전부 189로 바꿉니다. 189보다 길이가 짧은 메일 샘플은 전부 숫자 0이 패딩 되어 189의 길이를 가집니다. 훈련 데이터의 크기(shape): (4135, 189) X_train_encoded 데이터는 4,135 × 189의 크기를 갖게 됩니다. 모델을 설계해 보겠습니다. 2. RNN으로 스팸 메일 분류하기 하이퍼 파라미터인 임베딩 벡터의 차원은 32, 은닉 상태의 크기는 32입니다. 모델은 다 대 일 구조의 RNN을 사용합니다. 해당 모델은 마지막 시점에서 두 개의 선택지 중 하나를 예측하는 이진 분류 문제를 수행하는 모델입니다. 이진 분류 문제의 경우, 출력층에 로지스틱 회귀를 사용해야 하므로 활성화 함수로는 시그모이드 함수를 사용하고, 손실 함수로 크로스 엔트로피 함수를 사용하여 4번의 에포크를 수행합니다. 하이퍼 파라미터인 배치 크기는 64이며, validation_split=0.2를 사용하여 훈련 데이터의 20%를 검증 데이터로 분리해서 사용하고, 검증 데이터를 통해서 훈련이 적절히 되고 있는지 확인합니다. 검증 데이터는 기계가 훈련 데이터에 과적합되고 있지는 않은지 확인하기 위한 용도로 사용됩니다. from tensorflow.keras.layers import SimpleRNN, Embedding, Dense from tensorflow.keras.models import Sequential embedding_dim = 32 hidden_units = 32 model = Sequential() model.add(Embedding(vocab_size, embedding_dim)) model.add(SimpleRNN(hidden_units)) model.add(Dense(1, activation='sigmoid')) model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc']) history = model.fit(X_train_padded, y_train, epochs=4, batch_size=64, validation_split=0.2) 테스트 데이터에 대해서 정확도를 확인해 보겠습니다. X_test_encoded = tokenizer.texts_to_sequences(X_test) X_test_padded = pad_sequences(X_test_encoded, maxlen = max_len) print("\n 테스트 정확도: %.4f" % (model.evaluate(X_test_padded, y_test)[1])) 1034/1034 [==============================] - 0s 166us/step 테스트 정확도: 0.9821 정확도가 98%가 나왔습니다. 이번 실습에서는 훈련 데이터와 검증 데이터에 대해서 같이 정확도를 확인하면서 훈련하였으므로, 이를 비교하여 그래프로 시각화해보겠습니다. epochs = range(1, len(history.history['acc']) + 1) plt.plot(epochs, history.history['loss']) plt.plot(epochs, history.history['val_loss']) plt.title('model loss') plt.ylabel('loss') plt.xlabel('epoch') plt.legend(['train', 'val'], loc='upper left') plt.show() 이번 실습 데이터는 데이터의 양이 적어 과적합이 빠르게 시작되므로, 검증 데이터에 대한 오차가 증가하기 시작하는 시점의 바로 직전인 에포크 3~4 정도가 적당합니다. 이 데이터는 에포크 5를 넘어가기 시작하면 검증 데이터의 오차가 증가하는 경향이 있습니다. 10-03 로이터 뉴스 분류하기(Reuters News Classification) 케라스에서 제공하는 로이터 뉴스 데이터를 LSTM을 이용하여 텍스트 분류를 진행해 보겠습니다. 로이터 뉴스 기사 데이터는 총 11,258개의 뉴스 기사가 46개의 뉴스 카테고리로 분류되는 뉴스 기사 데이터입니다. 1. 로이터 뉴스 데이터에 대한 이해 import numpy as np import seaborn as sns import matplotlib.pyplot as plt from tensorflow.keras.datasets import reuters 케라스 데이터 셋으로부터 로이터 뉴스 기사 데이터를 로드하고, 뉴스 기사 데이터를 훈련용과 테스트용으로 나누겠습니다. reuters.load_data()에서 num_words는 이 데이터에서 등장 빈도 순위로 몇 번째에 해당하는 단어까지만 사용할 것인지 조절합니다. 예를 들어서 100이란 값을 넣으면, 등장 빈도 순위로 상위 1~100 등에 해당하는 단어만 사용하게 됩니다. 모든 단어를 사용하고자 한다면 None으로 설정합니다. 아직 무슨 의미인지 이해가 어려운 분들을 위해서 아래에서 출력 결과를 보여드리면서 다시 설명하겠습니다. test_split은 전체 뉴스 기사 데이터 중 테스트용 뉴스 기사로 몇 퍼센트를 사용할 것인지를 의미합니다. 이번 실습에서는 전체 뉴스 기사 중 20%를 테스트용 뉴스 기사로 사용할 것이므로 0.2로 설정했습니다. 훈련용 뉴스 기사와 테스트용 뉴스 기사가 8:2로 정상적으로 분리되어 로드되는지 확인해 봅시다. (X_train, y_train), (X_test, y_test) = reuters.load_data(num_words=None, test_split=0.2) print('훈련용 뉴스 기사 : {}'.format(len(X_train))) print('테스트용 뉴스 기사 : {}'.format(len(X_test))) num_classes = len(set(y_train)) print('카테고리 : {}'.format(num_classes)) 훈련용 뉴스 기사 : 8982 테스트용 뉴스 기사 : 2246 카테고리 : 46 훈련용 뉴스 기사는 8,982개, 테스트용 뉴스 기사는 2,246개, 카테고리는 46개인 것을 확인할 수 있습니다. 훈련용 뉴스 기사 데이터의 구성을 확인하기 위해 첫 번째 뉴스 기사를 출력해 보았습니다. print('첫 번째 훈련용 뉴스 기사 :',X_train[0]) print('첫 번째 훈련용 뉴스 기사의 레이블 :',y_train[0]) 첫 번째 훈련용 뉴스 기사 : [1, 27595, 28842, 8, 43, 10, 447, 5, 25, 207, 270, 5, 3095, 111, 16, 369, 186, 90, 67, 7, 89, 5, 19, 102, 6, 19, 124, 15, 90, 67, 84, 22, 482, 26, 7, 48, 4, 49, 8, 864, 39, 209, 154, 6, 151, 6, 83, 11, 15, 22, 155, 11, 15, 7, 48, 9, 4579, 1005, 504, 6, 258, 6, 272, 11, 15, 22, 134, 44, 11, 15, 16, 8, 197, 1245, 90, 67, 52, 29, 209, 30, 32, 132, 6, 109, 15, 17, 12] 첫 번째 훈련용 뉴스 기사의 레이블 : 3 위와 같이 훈련용 뉴스 기사 데이터인 X_train 중 첫 번째 뉴스 기사인 X_train[0]에는 정수의 나열이 저장되어 있습니다. 텍스트가 아니라서 의아할 수 있는데, 현재 이 데이터는 토큰화과 정수 인코딩(각 단어를 정수로 변환)이 끝난 상태입니다. 이 데이터는 단어들이 몇 번 등장하는지의 빈도수에 따라서 정수를 부여했습니다. 1이라는 숫자는 이 단어가 이 데이터에서 등장 빈도가 1등이라는 뜻입니다. 27,595라는 숫자는 이 단어가 데이터에서 27,595번째로 빈도수가 높은 단어라는 뜻입니다. 즉, 실제로는 빈도가 굉장히 낮은 단어입니다. 앞서 num_words에다가 None을 부여했는데, 만약 num_words에 1,000을 넣었다면 빈도수 순위가 1,000 이하의 단어만 가져온다는 의미이므로 데이터에서 1,000을 넘는 정수는 나오지 않습니다. 뉴스 기사들의 레이블들을 의미하는 y_train에서 첫 번째 뉴스 기사의 레이블인 y_train[0]에는 3이라는 값이 들어있습니다. 이 숫자는 첫 번째 훈련용 뉴스 기사가 46개의 카테고리 중 3에 해당하는 카테고리임을 의미합니다. 방금 확인한 X_train[0]과 y_train[0]은 8,982개의 훈련용 뉴스 기사 중 첫 번째 뉴스 기사의 본문과 레이블만 확인한 것입니다. 이번에는 8,982개의 훈련용 뉴스 기사의 길이가 대체적으로 어떤 크기를 가지는지 확인해 보겠습니다. print('뉴스 기사의 최대 길이 :{}'.format(max(len(sample) for sample in X_train))) print('뉴스 기사의 평균 길이 :{}'.format(sum(map(len, X_train))/len(X_train))) plt.hist([len(sample) for sample in X_train], bins=50) plt.xlabel('length of samples') plt.ylabel('number of samples') plt.show() 뉴스 기사의 최대 길이 : 2376 뉴스 기사의 평균 길이 : 145.5398574927633 대체적으로 대부분의 뉴스가 100~200 사이의 길이를 가집니다. 각 뉴스의 레이블 값의 분포를 보겠습니다. fig, axe = plt.subplots(ncols=1) fig.set_size_inches(12,5) sns.countplot(y_train) 3, 4가 가장 많은 레이블을 차지하는 것을 확인할 수 있습니다. 각 레이블에 대한 정확한 개수를 알아보겠습니다. unique_elements, counts_elements = np.unique(y_train, return_counts=True) print("각 레이블에 대한 빈도수:") print(np.asarray((unique_elements, counts_elements))) 각 레이블에 대한 빈도수: [[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45] [ 55 432 74 3159 1949 17 48 16 139 101 124 390 49 172 26 20 444 39 66 549 269 100 15 41 62 92 24 15 48 19 45 39 32 11 50 10 49 19 19 24 36 30 13 21 12 18]] 3번 레이블은 총 3,159개가 존재하고 4번 레이블은 총 1,949개가 존재하는 것을 확인할 수 있습니다. X_train에 들어있는 숫자들이 각자 어떤 단어들을 나타내고 있는지 확인해 보겠습니다. reuters.get_word_index는 각 단어와 그 단어에 부여된 인덱스를 리턴합니다. word_to_index = reuters.get_word_index() print(word_to_index) {'mdbl': 10996, 'fawc': 16260, 'degussa': 12089, 'woods': 8803, 'hanging': 13796, 'localized': 20672, 'sation': 20673, 'chanthaburi': 20675, 'refunding': 10997, 'hermann': 8804, 'passsengers': 20676, 'stipulate': 20677, 'heublein': 8352, 'screaming': 20713, 'tcby': 16261, 'four': 185, 'grains': 1642, 'broiler': 20680, 'wooden': 12090, 'wednesday': 1220, 'highveld': 13797, 'duffour': 7593, '0053': 20681, 'elections': 3914, '270': 2563, '271': 3551, '272': 5113, '273': 3552, '274': 3400, 'rudman': 7975, '276': 3401, '277': 3478, '278': 3632, '279': 4309, 'dormancy': 9381, - 이하 중략 -} 많은 단어가 출력되므로 출력 결과는 중략했습니다. 이번에는 정수로부터 단어를 알 수 있도록 해보겠습니다. word_to_index에서 key와 value를 반대로 저장한 index_to_word를 만듭니다. 주의할 점은 reuters.get_word_index()에 저장된 값에 +3을 해야 실제 매핑되는 정수입니다. 이것은 로이터 뉴스 데이터 셋에서 정한 규칙입니다. index_to_word = {} for key, value in word_to_index.items(): index_to_word[value+3] = key index_to_word[ ]에다가 인덱스를 입력하면 단어를 확인할 수 있습니다. +3을 했으므로 빈도수 1등에 해당하는 단어를 알고 싶다면 숫자 4를 넣어야 합니다. 보통 불용어로 분류되는 the가 이 데이터에서도 어김없이 등장 빈도수로 1위를 차지했습니다. print('빈도수 상위 1번 단어 : {}'.format(index_to_word[4])) 빈도수 상위 1번 단어 : the 이번에는 임의로 빈도수 128등 단어를 알아봅시다. print('빈도수 상위 128등 단어 : {}'.format(index_to_word[131])) 빈도수 상위 128등 단어 : tax index_to_word에서 숫자 0은 패딩을 의미하는 토큰인 pad, 숫자 1은 문장의 시작을 의미하는 sos, 숫자 2는 OOV를 위한 토큰인 unk라는 특별 토큰에 매핑되어야 합니다. 이를 반영하여 index_to_word를 완성해 줍니다. 이 또한 로이터 뉴스 데이터 셋에서 정한 규칙이므로 납득하고 넘어갑시다. index_to_word를 이용해서 첫 번째 훈련용 뉴스 기사인 X_train[0]가 어떤 단어들로 구성되어 있는지를 복원해 보겠습니다. X_train[0]에 있는 모든 단어들을 하나씩 불러와서 index_to_word의 입력으로 넣고 그 결과를 연결하면 됩니다. for index, token in enumerate(("<pad>", "<sos>", "<unk>")): index_to_word[index] = token print(' '.join([index_to_word[index] for index in X_train[0]])) <sos> mcgrath rentcorp said as a result of its december acquisition of space co it expects earnings per share in 1987 of 1 15 to 1 30 dlrs per share up from 70 cts in 1986 the company said pretax net should rise to nine to 10 mln dlrs from six mln dlrs in 1986 and rental operation revenues to 19 to 22 mln dlrs from 12 5 mln dlrs it said cash flow per share this year should be 2 50 to three dlrs reuter 3 위 결과는 복원된 결과를 보여줍니다. 물론 정수 인코딩을 수행하기 전 어느 정도 전처리가 된 상태라서 제대로 된 문장이 나오지는 않습니다. 로이터 뉴스 데이터가 어떤 구성을 갖고 있는지에 대해서 알아보았습니다. 텍스트 분류를 수행해 보겠습니다. 2. LSTM으로 로이터 뉴스 분류하기 학습에서는 등장 빈도 순위 상위 1,000개의 단어들만 사용하겠습니다. 훈련용 뉴스 기사 데이터과 테스트용 뉴스 기사 데이터에 있는 각각의 뉴스의 길이는 서로 다르므로 모든 뉴스 기사의 길이를 100으로 패딩 해줍니다. 이후 훈련용, 테스트용 뉴스 기사 데이터의 레이블에 원-핫 인코딩을 합니다. from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, LSTM, Embedding from tensorflow.keras.preprocessing.sequence import pad_sequences from tensorflow.keras.utils import to_categorical from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint from tensorflow.keras.models import load_model vocab_size = 1000 max_len = 100 (X_train, y_train), (X_test, y_test) = reuters.load_data(num_words=vocab_size, test_split=0.2) X_train = pad_sequences(X_train, maxlen=max_len) X_test = pad_sequences(X_test, maxlen=max_len) y_train = to_categorical(y_train) y_test = to_categorical(y_test) 하이퍼 파라미터인 임베딩 벡터의 차원은 128, 은닉 상태의 크기는 128입니다. 단어 집합의 크기는 앞서 1,000으로 정했습니다. 모델은 다 대 일 구조의 LSTM을 사용합니다. 해당 모델은 마지막 시점에서 46개의 선택지 중 하나의 선택지를 예측하는 다중 클래스 분류 문제를 수행하는 모델입니다. 다중 클래스 분류 문제의 경우, 출력층에 소프트맥스 회귀를 사용해야 하므로 활성화 함수로는 소프트맥스 함수를 사용하고, 손실 함수로 크로스 엔트로피 함수를 사용합니다. 하이퍼 파라미터인 배치 크기는 128이며, 30 에포크를 수행합니다. EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=4)는 검증 데이터 손실(val_loss)이 증가하면, 과적합 징후므로 검증 데이터 손실이 4회 증가하면 정해진 에포크에 도달하지 못하여도 학습을 조기 종료(Early Stopping) 합니다. ModelCheckpoint를 사용하여 검증 데이터의 정확도(val_acc)가 이전보다 좋아질 경우에만 모델을 저장합니다. validation_data로는 X_test와 y_test를 사용합니다. val_loss가 줄어들다가 증가하는 상황이 오면 과적합으로 판단하기 위함입니다. embedding_dim = 128 hidden_units = 128 num_classes = 46 model = Sequential() model.add(Embedding(vocab_size, embedding_dim)) model.add(LSTM(hidden_units)) model.add(Dense(num_classes, activation='softmax')) es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=4) mc = ModelCheckpoint('best_model.h5', monitor='val_acc', mode='max', verbose=1, save_best_only=True) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc']) history = model.fit(X_train, y_train, batch_size=128, epochs=30, callbacks=[es, mc], validation_data=(X_test, y_test)) 저자의 경우 21 에포크에서 훈련이 조기 종료되었습니다. 훈련이 다 되었다면 테스트 데이터에 대해서 정확도를 측정할 차례입니다. 훈련 과정에서 검증 데이터가 가장 높았을 때 저장된 모델인 'best_model.h5'를 로드하고, 성능을 평가합니다. loaded_model = load_model('best_model.h5') print("\n 테스트 정확도: %.4f" % (loaded_model.evaluate(X_test, y_test)[1])) 2246/2246 [==============================] - 1s 656us/sample - loss: 1.2355 - acc: 0.7124 테스트 정확도: 0.7124 테스트 데이터에 대한 정확도는 71.24%입니다. 케라스의 model.fit()에서 validation_data는 실제 기계가 데이터를 훈련하지는 않고 에포크마다 정확도와 loss를 출력하여 과적합을 판단하기 위한 용도로만 사용됩니다. 그래서 validation_data에서 이미 X_test, y_test를 사용했지만 기계는 이 데이터로 학습한 적이 없습니다. 모델이 학습하지 않은 데이터인 X_test, y_test를 테스트 데이터로서 성능 평가 용도로 model.evaluate()에서도 사용했습니다. 이번 모델은 검증 데이터와 테스트 데이터가 동일한 셈입니다. 사실 데이터가 충분하다면, 검증 데이터와 테스트 데이터는 다르게 사용하는 것이 바람직합니다. 앞서 스팸 메일 분류하기 실습에서는 validation_data 대신 validation_split=0.2를 사용하여 검증 데이터와 테스트 데이터를 다른 데이터를 사용하였음을 상기합시다. 에포크마다 변화하는 훈련 데이터와 검증 데이터(테스트 데이터)의 손실을 시각화해보겠습니다. epochs = range(1, len(history.history['acc']) + 1) plt.plot(epochs, history.history['loss']) plt.plot(epochs, history.history['val_loss']) plt.title('model loss') plt.ylabel('loss') plt.xlabel('epoch') plt.legend(['train', 'test'], loc='upper left') plt.show() 전체적으로는 검증 데이터의 손실이 줄어드는 경향이 있지만 뒤로 갈수록 점차 검증 데이터의 손실이 증가하려고 하는 경향이 보입니다. 이는 과적 합의 신호일 수 있습니다. 10-04 IMDB 리뷰 감성 분류하기(IMDB Movie Review Sentiment Analysis) 감성 분류를 연습하기 위해 자주 사용하는 영어 데이터로 영화 사이트 IMDB의 리뷰 데이터가 있습니다. 이 데이터는 리뷰에 대한 텍스트와 해당 리뷰가 긍정인 경우 1을 부정인 경우 0으로 표시한 레이블로 구성된 데이터입니다. 스탠퍼드 대학교에서 2011년에 낸 논문에서 이 데이터를 소개하였으며, 당시 논문에서는 이 데이터를 훈련 데이터와 테스트 데이터를 50:50대 비율로 분할하여 88.89%의 정확도를 얻었다고 소개하고 있습니다. 논문 링크 : http://ai.stanford.edu/~amaas/papers/wvSent_acl2011.pdf 케라스에서는 해당 IMDB 영화 리뷰 데이터를 imdb.load_data() 함수를 통해 바로 다운로드할 수 있도록 지원하고 있습니다. 해당 데이터를 학습하여 감성 분류를 수행하는 모델을 만들어보겠습니다. 1. IMDB 리뷰 데이터에 대한 이해 import numpy as np import matplotlib.pyplot as plt from tensorflow.keras.datasets import imdb 케라스 데이터 셋으로부터 imdb.data_load()를 통해 영화 리뷰 데이터를 로드합니다. IMDB 리뷰 데이터는 앞서 배운 로이터 뉴스 데이터에서 훈련 데이터와 테스트 데이터를 우리가 직접 비율을 조절했던 것과는 달리 이미 훈련 데이터와 테스트 데이터를 50:50 비율로 구분해서 제공합니다. 로이터 뉴스 데이터에서 사용했던 test_split과 같은 데이터의 비율을 조절하는 인자는 imdb.load_data에서는 지원하지 않습니다. imdb.data_load()의 인자로 num_words를 사용하면 이 데이터에서 등장 빈도 순위로 몇 등까지의 단어를 사용할 것인지를 의미합니다. 예를 들어서 10,000을 넣으면, 등장 빈도 순위가 1~10,000에 해당하는 단어만 사용하게 됩니다. 즉, 단어 집합의 크기는 10,000이 됩니다. 지금은 별도로 제한하지 않겠습니다. 훈련용 리뷰의 개수, 테스트용 리뷰의 개수, 카테고리의 수를 출력합니다. (X_train, y_train), (X_test, y_test) = imdb.load_data() print('훈련용 리뷰 개수 : {}'.format(len(X_train))) print('테스트용 리뷰 개수 : {}'.format(len(X_test))) num_classes = len(set(y_train)) print('카테고리 : {}'.format(num_classes)) 훈련용 리뷰 개수 : 25000 테스트용 리뷰 개수 : 25000 카테고리 : 2 훈련용 리뷰는 25,000개, 테스트용 리뷰는 25,000개, 카테고리는 2개입니다. 훈련 데이터가 어떻게 구성되어 있는지를 확인하기 위해 첫 번째 훈련용 리뷰와 레이블을 출력합니다. print('첫 번째 훈련용 리뷰 :',X_train[0]) print('첫 번째 훈련용 리뷰의 레이블 :',y_train[0]) 첫 번째 훈련용 리뷰 : [1, 14, 22, 16, 43, 530, 973, 1622, 1385, 65, 458, 4468, 66, 3941, 4, 173, 36, 256, 5, 25, 100, 43, 838, 112, 50, 670, 22665, 9, 35, 480, 284, 5, 150, 4, 172, 112, 167, 21631, 336, 385, 39, 4, 172, 4536, 1111, 17, 546, 38, 13, 447, 4, 192, 50, 16, 6, 147, 2025, 19, 14, 22, 4, 1920, 4613, 469, 4, 22, 71, 87, 12, 16, 43, 530, 38, 76, 15, 13, 1247, 4, 22, 17, 515, 17, 12, 16, 626, 18, 19193, 5, 62, 386, 12, 8, 316, 8, 106, 5, 4, 2223, 5244, 16, 480, 66, 3785, 33, 4, 130, 12, 16, 38, 619, 5, 25, 124, 51, 36, 135, 48, 25, 1415, 33, 6, 22, 12, 215, 28, 77, 52, 5, 14, 407, 16, 82, 10311, 8, 4, 107, 117, 5952, 15, 256, 4, 31050, 7, 3766, 5, 723, 36, 71, 43, 530, 476, 26, 400, 317, 46, 7, 4, 12118, 1029, 13, 104, 88, 4, 381, 15, 297, 98, 32, 2071, 56, 26, 141, 6, 194, 7486, 18, 4, 226, 22, 21, 134, 476, 26, 480, 5, 144, 30, 5535, 18, 51, 36, 28, 224, 92, 25, 104, 4, 226, 65, 16, 38, 1334, 88, 12, 16, 283, 5, 16, 4472, 113, 103, 32, 15, 16, 5345, 19, 178, 32] 첫 번째 훈련용 리뷰의 레이블 : 1 리뷰 본문에 해당하는 X_train[0]에는 숫자들이 들어있습니다. 이 데이터는 토큰화와 정수 인코딩이라는 텍스트 전처리가 끝난 상태입니다. IMDB 리뷰 데이터는 전체 데이터에서 각 단어들의 등장 빈도에 따라서 인덱스를 부여했습니다. 숫자가 낮을수록 이 데이터에서 등장 빈도 순위가 높습니다. 위에서 단어 집합의 크기를 제한하지 않았기 때문에 22,665와 같은 큰 숫자도 보입니다. 첫 번째 훈련용 리뷰의 레이블에 해당하는 y_train[0]의 값은 1입니다. 이 문제의 경우 감성 정보로서 0 또는 1의 값을 가지는데 긍정은 1의 값을 가집니다. 25,000개의 훈련용 리뷰의 각 길이는 전부 다른데, 리뷰의 길이 분포를 그래프로 시각화해보겠습니다. reviews_length = [len(review) for review in X_train] print('리뷰의 최대 길이 : {}'.format(np.max(reviews_length))) print('리뷰의 평균 길이 : {}'.format(np.mean(reviews_length))) plt.subplot(1,2,1) plt.boxplot(reviews_length) plt.subplot(1,2,2) plt.hist(reviews_length, bins=50) plt.show() 리뷰의 최대 길이 : 2494 리뷰의 평균 길이 : 238.71364 대체적으로 1,000이하의 길이를 가지며, 특히 100~500길이를 가진 데이터가 많은 것을 확인할 수 있습니다. 반면, 가장 긴 길이를 가진 데이터는 길이가 2,000이 넘는 것도 확인할 수 있습니다. 레이블의 분포를 확인해 보겠습니다. unique_elements, counts_elements = np.unique(y_train, return_counts=True) print("각 레이블에 대한 빈도수:") print(np.asarray((unique_elements, counts_elements))) 각 레이블에 대한 빈도수: [[ 0 1] [12500 12500]] 25,000개의 리뷰가 존재하는데 두 레이블 0과 1은 각각 12,500개로 균등한 분포를 가지고 있습니다. X_train에 들어있는 숫자들이 각각 어떤 단어들을 나타내고 있는지 확인해 보겠습니다. imdb.get_word_index()에 각 단어와 매핑되는 정수가 저장돼 있습니다. 주의할 점은 imdb.get_word_index()에 저장된 값에 +3을 해야 실제 매핑되는 정수입니다. 이것은 IMDB 리뷰 데이터 셋에서 정한 규칙입니다. word_to_index = imdb.get_word_index() index_to_word = {} for key, value in word_to_index.items(): index_to_word[value+3] = key index_to_word에 인덱스를 집어넣으면 전처리 전에 어떤 단어였는지 확인할 수 있습니다. IMDB 리뷰 데이터 셋에서는 0, 1, 2, 3은 특별 토큰으로 취급하고 있습니다. 그래서 정수 4부터가 실제 IMDB 리뷰 데이터 셋에서 빈도수가 가장 높은 실제 영단어입니다. print('빈도수 상위 1등 단어 : {}'.format(index_to_word[4])) 빈도수 상위 1등 단어 : the print('빈도수 상위 3938등 단어 : {}'.format(index_to_word[3941])) 빈도수 상위 3938등 단어 : suited 이 데이터에서 빈도가 가장 높은 단어는 the이고, 빈도가 3938번째로 높은 단어는 suited입니다. for index, token in enumerate(("<pad>", "<sos>", "<unk>")): index_to_word[index] = token print(' '.join([index_to_word[index] for index in X_train[0]])) 첫 번째 훈련용 리뷰의 X_train[0]의 각 단어가 정수로 바뀌기 전에 어떤 단어들이었는지 확인해 보겠습니다. <sos> this film was just brilliant casting location scenery story direction everyone's really suited the part they played and you could just imagine being there robert <unk> is an amazing actor and now the same being director <unk> father came from the same scottish island as myself so i loved the fact there was a real connection with this film the witty remarks throughout the film were great it was just brilliant so much that i bought the film as soon as it was released for <unk> and would recommend it to everyone to watch and the fly fishing was amazing really cried at the end it was so sad and you know what they say if you cry at a film it must have been good and this definitely was also <unk> to the two little boy's that played the <unk> of norman and paul they were just brilliant children are often left out of the <unk> list i think because the stars that play them all grown up are such a big profile for the whole film but these children are amazing and should be praised for what they have done don't you think the whole story was so lovely because it was true and was someone's life after all that was shared with us all 2. GRU로 IMDB 리뷰 감성 분류하기 단어 집합의 크기를 10,000으로 제한하고, 리뷰 최대 길이는 500으로 제한하여 패딩을 진행합니다. import re from tensorflow.keras.datasets import imdb from tensorflow.keras.preprocessing.sequence import pad_sequences from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, GRU, Embedding from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint from tensorflow.keras.models import load_model vocab_size = 10000 max_len = 500 (X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=vocab_size) X_train = pad_sequences(X_train, maxlen=max_len) X_test = pad_sequences(X_test, maxlen=max_len) 하이퍼 파라미터인 임베딩 벡터의 차원은 100, 은닉 상태의 크기는 128입니다. 모델은 다 대 일 구조의 GRU를 사용합니다. 해당 모델은 마지막 시점에서 두 개의 선택지 중 하나를 예측하는 이진 분류 문제를 수행하는 모델입니다. 이진 분류 문제의 경우, 출력층에 로지스틱 회귀를 사용해야 하므로 활성화 함수로는 시그모이드 함수를 사용하고, 손실 함수로 크로스 엔트로피 함수를 사용합니다. 하이퍼 파라미터인 배치 크기는 64이며, 15 에포크를 수행합니다. EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=4)는 검증 데이터 손실(val_loss)이 증가하면, 과적합 징후므로 검증 데이터 손실이 4회 증가하면 정해진 에포크가 도달하지 못하였더라도 학습을 조기 종료(Early Stopping) 한다는 의미입니다. ModelCheckpoint를 사용하여 검증 데이터의 정확도(val_acc)가 이전보다 좋아질 경우에만 모델을 저장합니다. validation_split=0.2를 사용하여 훈련 데이터의 20%를 검증 데이터로 분리해서 사용하고, 검증 데이터를 통해서 훈련이 적절히 되고 있는지 확인합니다. 검증 데이터는 기계가 훈련 데이터에 과적합되고 있지는 않은지 확인하기 위한 용도로 사용됩니다. embedding_dim = 100 hidden_units = 128 model = Sequential() model.add(Embedding(vocab_size, embedding_dim)) model.add(GRU(hidden_units)) model.add(Dense(1, activation='sigmoid')) es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=4) mc = ModelCheckpoint('GRU_model.h5', monitor='val_acc', mode='max', verbose=1, save_best_only=True) model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc']) history = model.fit(X_train, y_train, epochs=15, callbacks=[es, mc], batch_size=64, validation_split=0.2) 저자의 경우, 조기 종료 조건에 따라서 에포크 9에서 조기 종료되었습니다. 훈련이 다 되었다면 테스트 데이터에 대해서 정확도를 평가할 차례입니다. 훈련 과정에서 검증 데이터의 정확도가 가장 높았을 때 저장된 모델인 'GRU_model.h5'를 로드합니다. loaded_model = load_model('GRU_model.h5') print("\n 테스트 정확도: %.4f" % (loaded_model.evaluate(X_test, y_test)[1])) 25000/25000 [==============================] - 61s 2ms/sample - loss: 0.3440 - acc: 0.8893 테스트 정확도: 0.8893 테스트 데이터에 대해서 정확도 88.93%를 얻습니다. 임의의 문장에 대해서 리뷰의 긍, 부정을 예측하고자 합니다. 이를 위해서는 모델에 넣기 전에 임의의 문장에 대해서 전처리를 해주어야 합니다. sentiment_predict은 입력된 문장에 대해서 기본적인 전처리와 정수 인코딩, 패딩을 한 후에 모델의 입력으로 사용하여 예측값을 리턴하는 함수입니다. def sentiment_predict(new_sentence): # 알파벳과 숫자를 제외하고 모두 제거 및 알파벳 소문자화 new_sentence = re.sub('[^0-9a-zA-Z ]', '', new_sentence).lower() encoded = [] # 띄어쓰기 단위 토큰화 후 정수 인코딩 for word in new_sentence.split(): try : # 단어 집합의 크기를 10,000으로 제한. if word_to_index[word] <= 10000: encoded.append(word_to_index[word]+3) else: # 10,000 이상의 숫자는 <unk> 토큰으로 변환. encoded.append(2) # 단어 집합에 없는 단어는 <unk> 토큰으로 변환. except KeyError: encoded.append(2) pad_sequence = pad_sequences([encoded], maxlen=max_len) score = float(loaded_model.predict(pad_sequence)) # 예측 if(score > 0.5): print("{:.2f}% 확률로 긍정 리뷰입니다.".format(score * 100)) else: print("{:.2f}% 확률로 부정 리뷰입니다.".format((1 - score) * 100)) IMDB 사이트에 접속해서 영화 블랙 팬서의 1점 리뷰를 가져왔습니다. 부정으로 예측하는지 테스트해 보겠습니다. test_input = "This movie was just way too overrated. The fighting was not professional and in slow motion. I was expecting more from a 200 million budget movie. The little sister of T.Challa was just trying too hard to be funny. The story was really dumb as well. Don't watch this movie if you are going because others say its great unless you are a Black Panther fan or Marvels fan." sentiment_predict(test_input) 97.43% 확률로 부정 리뷰입니다. IMDB 사이트에 접속해서 영화 어벤저스의 10점 리뷰를 가져왔습니다. 긍정으로 예측하는지 테스트해 보겠습니다. test_input = " I was lucky enough to be included in the group to see the advanced screening in Melbourne on the 15th of April, 2012. And, firstly, I need to say a big thank-you to Disney and Marvel Studios. \ Now, the film... how can I even begin to explain how I feel about this film? It is, as the title of this review says a 'comic book triumph'. I went into the film with very, very high expectations and I was not disappointed. \ Seeing Joss Whedon's direction and envisioning of the film come to life on the big screen is perfect. The script is amazingly detailed and laced with sharp wit a humor. The special effects are literally mind-blowing and the action scenes are both hard-hitting and beautifully choreographed." sentiment_predict(test_input) 98.95% 확률로 긍정 리뷰입니다. 10-05 나이브 베이즈 분류기(Naive Bayes Classifier) 텍스트 분류를 위해 전통적으로 사용되는 분류기로 나이브 베이즈 분류기가 있습니다. 나이브 베이즈 분류기는 인공 신경망 알고리즘에는 속하지 않지만, 머신 러닝의 주요 알고리즘으로 분류에 있어 준수한 성능을 보여주는 것으로 알려져 있습니다. 1) 베이즈의 정리(Bayes' theorem)를 이용한 분류 메커니즘 나이브 베이즈 분류기를 이해하기 위해서는 우선 베이즈의 정리(Bayes' theorem)를 이해할 필요가 있습니다. 베이즈 정리는 조건부 확률을 계산하는 방법 중 하나입니다. ( ) 가 A가 일어날 확률, ( ) 가 B가 일어날 확률, ( | ) 가 A가 일어나고 나서 B가 일어날 확률, ( | ) 가 B가 일어나고 나서 A가 일어날 확률이라고 해봅시다. 이때 ( | ) 를 쉽게 구할 수 있는 상황이라면, 아래와 같은 식을 통해 ( | ) 를 구할 수 있습니다. ( | ) P ( | ) ( ) ( ) 나이브 베이즈 분류기는 이러한 베이즈 정리를 이용하여 텍스트 분류를 수행합니다. 예를 들어서 나이브 베이즈 분류기를 통해서 스팸 메일 필터를 만들어본다고 합시다. 입력 텍스트(메일의 본문)이 주어졌을 때, 입력 텍스트가 정상 메일인지 스팸 메일인지 구분하기 위한 확률을 이와 같이 표현할 수 있습니다. P(정상 메일 | 입력 텍스트) = 입력 텍스트가 있을 때 정상 메일일 확률 P(스팸 메일 | 입력 텍스트) = 입력 텍스트가 있을 때 스팸 메일일 확률 이를 베이즈의 정리에 따라서 식을 표현하면 이와 같습니다. P(정상 메일 | 입력 텍스트) = (P(입력 텍스트 | 정상 메일) × P(정상 메일)) / P(입력 텍스트) P(스팸 메일 | 입력 텍스트) = (P(입력 텍스트 | 스팸 메일) × P(스팸 메일)) / P(입력 텍스트) 입력 텍스트가 주어졌을 때, P(정상 메일 | 입력 텍스트)가 P(스팸 메일 | 입력 텍스트)보다 크다면 정상 메일이라고 볼 수 있으며, 그 반대라면 스팸 메일이라고 볼 수 있습니다. 그런데 두 확률 모두 식을 보면 P(입력 텍스트)를 분모로 하고 있음을 알 수 있습니다. 그렇기 때문에 분모를 양쪽에서 제거하여 식을 간소화합니다. P(정상 메일 | 입력 텍스트) = P(입력 텍스트 | 정상 메일) × P(정상 메일) P(스팸 메일 | 입력 텍스트) = P(입력 텍스트 | 스팸 메일) × P(스팸 메일) 입력 텍스트는 메일의 본문을 의미한다고 언급했습니다. 그런데 메일의 본문을 어떻게 나이브 베이즈 분류기의 입력으로 사용할 수 있을까요? 메일의 본문을 단어 토큰화하여 이 단어들을 나이브 베이즈의 분류기의 입력으로 사용합니다. 만약 메일의 본문에 있는 단어가 3개라고 가정해 보겠습니다. 기본적으로 나이브 베이즈 분류기는 모든 단어가 독립적이라고 가정합니다. 메일의 본문에 있는 단어 3개를 1 w, 3 라고 표현한다면 결국 나이브 베이즈 분류기의 정상 메일일 확률과 스팸 메일일 확률을 구하는 식은 아래와 같습니다. P(정상 메일 | 입력 텍스트) = P( 1 | 정상 메일) × P( 2 | 정상 메일) × P( 3 | 정상 메일) × P(정상 메일) P(스팸 메일 | 입력 텍스트) = P( 1 | 스팸 메일) × P( 2 | 스팸 메일) × P( 3 | 스팸 메일) × P(스팸 메일) 식을 보고 눈치채신 분들도 있겠지만, 나이브 베이즈 분류기에서 토큰화 이전의 단어의 순서는 중요하지 않습니다. 즉, BoW와 같이 단어의 순서를 무시하고 오직 빈도수만을 고려합니다. 이제 실제 단어들로 이루어진 예제를 통해서 확률을 구해보겠습니다. 2) 스팸 메일 분류기(Spam Detection) 앞서 배운 나이브 베이즈 분류식을 가지고, 입력 텍스트로부터 해당 텍스트가 정상 메일인지 스팸 메일인지를 구분하는 작업을 해보겠습니다. 아래와 같은 훈련 데이터가 있다고 가정하겠습니다. 메일로부터 토큰화 및 정제된 단어들 분류 1 me free lottery 스팸 메일 2 free get free you 스팸 메일 3 you free scholarship 정상 메일 4 free to contact me 정상 메일 5 you won award 정상 메일 6 you ticket lottery 스팸 메일 이때 you free lottery라는 입력 텍스트에 대해서 정상 메일일 확률과 스팸 메일일 확률 각각을 구해보겠습니다. P(정상 메일 | 입력 텍스트) = P(you | 정상 메일) × P(free | 정상 메일) × P(lottery | 정상 메일) × P(정상 메일) P(스팸 메일 | 입력 텍스트) = P(you | 스팸 메일) × P(free | 스팸 메일) × P(lottery | 스팸 메일) × P(스팸 메일) P(정상 메일) = P(스팸 메일) = 총 메일 6개 중 3개 = 0.5 위 예제에서는 P(정상 메일)과 P(스팸 메일)의 값은 같으므로, 두 식에서 두 개의 확률은 생략이 가능합니다. P(정상 메일 | 입력 텍스트) = P(you | 정상 메일) × P(free | 정상 메일) × P(lottery | 정상 메일) P(스팸 메일 | 입력 텍스트) = P(you | 스팸 메일) × P(free | 스팸 메일) × P(lottery | 스팸 메일) P(you | 정상 메일)을 구하는 방법은 정상 메일에 등장한 모든 단어의 빈도 수의 총합을 분모로 하고, 정상 메일에서 you가 총 등장한 빈도의 수를 분자로 하는 것입니다. 이 경우에는 2/10 = 0.2가 됩니다. 이와 같은 원리로 식을 전개하면 이와 같습니다. P(정상 메일 | 입력 텍스트) = 2/10 × 2/10 × 0/10 = 0 P(스팸 메일 | 입력 텍스트) = 2/10 × 3/10 × 2/10 = 0.012 결과적으로 P(정상 메일 | 입력 텍스트) < P(스팸 메일 | 입력 텍스트)이므로 입력 텍스트 you free lottery는 스팸 메일로 분류됩니다. 그런데 예제를 보니 이상한 점이 보입니다. 물론, 직관적으로 보기에도 you, free, lottery라는 단어가 스팸 메일에서 빈도수가 더 높기 때문에 스팸 메일인 확률이 더 높은 것은 확실합니다. 그러나 입력 텍스트에 대해서 단, 하나의 단어라도 훈련 텍스트에 없었다면 확률 전체가 0이 되는 것은 지나친 일반화입니다. 이 경우에는 정상 메일에 lottery가 단 한 번도 등장하지 않았고, 그 이유로 정상 메일일 확률 자체가 0%가 되어버렸습니다. 이를 방지하기 위해서 나이브 베이즈 분류기에서는 각 단어에 대한 확률의 분모, 분자에 전부 숫자를 더해서 분자가 0이 되는 것을 방지하는 라플라스 스무딩을 사용하기도 합니다. 3) 뉴스그룹 데이터 분류하기(Classification of 20 News Group with Naive Bayes Classifier) 사이킷 런에서는 Twenty Newsgroups이라고 불리는 20개의 다른 주제를 가진 18,846개의 뉴스그룹 데이터를 제공합니다. (토픽 모델링의 LSA 챕터에서 사용했던 데이터와 동일한 데이터.) 해당 데이터는 이미 훈련 데이터(11,314개)와 테스트 데이터(7,532개)를 미리 분류해놓았기 때문에 별도로 훈련 데이터와 테스트 데이터를 분류할 필요는 없습니다. 훈련 데이터로 훈련을 해서 모델을 만들고, 테스트 데이터를 예측했을 때의 정확도를 확인해 보겠습니다. (1) 뉴스그룹 데이터에 대한 이해 해당 데이터는 총 6개의 속성을 갖고 있는데, 그중에서 우리가 사용할 것은 해당 데이터의 본문을 갖고 있는 'data' 속성과 해당 데이터가 어떤 카테고리에 속하는지 0부터 19까지의 라벨이 붙어있는 'target' 속성이 되겠습니다. 그럼 코드를 보면서 데이터의 구성을 더 구체적으로 알아보도록 하겠습니다. 우선 훈련 데이터를 다운로드해 보겠습니다. from sklearn.datasets import fetch_20newsgroups newsdata=fetch_20newsgroups(subset='train') print(newsdata.keys()) 위의 코드 부분에 subset 부분에 'all'을 넣으면 18,846개의 전체 데이터 다운로드할 수 있으며, 'train'을 넣으면 훈련 데이터를, 'test'를 넣으면 테스트 데이터를 다운로드할 수 있습니다. newsdata.keys()를 출력하여 해당 데이터가 어떤 속성으로 구성돼 있는지 출력해 보았습니다. dict_keys(['data', 'filenames', 'target_names', 'target', 'DESCR', 'description']) 해당 데이터는 data, filenames, target_names, target, DESCR, description이라는 6개 속성의 데이터를 갖고 있습니다. print (len(newsdata.data), len(newsdata.filenames), len(newsdata.target_names), len(newsdata.target)) 훈련용 샘플의 개수를 확인해 보겠습니다. 11314 11314 20 11314 훈련용 샘플은 총 11,314개로 구성되어 있습니다. newsdata.target_names는 이 데이터의 20개의 카테고리의 이름을 담고 있습니다. 어떤 카테고리들로 구성되어 있는지 확인해 보겠습니다. print(newsdata.target_names) ['alt.atheism', 'comp.graphics', 'comp.os.ms-windows.misc', 'comp.sys.ibm.pc.hardware', 'comp.sys.mac.hardware', 'comp.windows.x', 'misc.forsale', 'rec.autos', 'rec.motorcycles', 'rec.sport.baseball', 'rec.sport.hockey', 'sci.crypt', 'sci.electronics', 'sci.med', 'sci.space', 'soc.religion.christian', 'talk.politics.guns', 'talk.politics.mideast', 'talk.politics.misc', 'talk.religion.misc'] target에는 총 0부터 19까지의 숫자가 들어가 있는데 첫 번째 샘플의 경우에는 몇 번 카테고리인지 확인해 보겠습니다. print(newsdata.target[0]) 첫 번째 샘플은 카테고리 7번에 속한다고 라벨이 붙어있습니다. print(newsdata.target_names[7]) rec.autos 7번 카테고리의 카테고리 제목은 rec.autos입니다. 즉, 첫 번째 샘플은 rec.autos 카테고리에 속합니다. 그렇다면 첫 번째 샘플이 어떤 내용을 갖고 있는지 확인해 보겠습니다. print(newsdata.data[0]) From: lerxst@wam.umd.edu (where's my thing) Subject: WHAT car is this!? Nntp-Posting-Host: rac3.wam.umd.edu Organization: University of Maryland, College Park Lines: 15 I was wondering if anyone out there could enlighten me on this car I saw the other day. It was a 2-door sports car, looked to be from the late 60s/ early 70s. It was called a Bricklin. The doors were really small. In addition, the front bumper was separate from the rest of the body. This is all I know. If anyone can tellme a model name, engine specs, years of production, where this car is made, history, or whatever info you have on this funky looking car, please e-mail. Thanks, - IL ---- brought to you by your neighborhood Lerxst ---- 메일의 내용을 보니 스포츠카에 대한 글로 보입니다. 즉, 이 스포츠카에 대한 글은 총 0부터 19까지의 카테고리 중 7번 레이블에 속하는 글이고, 7번은 rec.autos 카테고리를 의미한다는 것을 알 수 있습니다. (2) 나이브 베이즈 분류 이제 다운로드한 훈련 데이터에 대한 전처리를 진행해 보겠습니다. 사용할 데이터는 newsdata.data와 그에 대한 카테고리 레이블이 되어있는 newsdata.target이라고 언급한 바 있습니다. 여기서 전처리를 해야 하는 데이터는 newsdata.data입니다. 위에서 봤듯이 해당 데이터는 토큰 화가 전혀 되어있지 않습니다. 나이브 베이즈 분류를 위해서는 데이터를 BoW로 만들어줄 필요가 있습니다. 여기서는 입력한 텍스트를 자동으로 BoW로 만드는 CountVectorizer를 사용합니다. (BoW 챕터 및 DTM 챕터 참고) from sklearn.feature_extraction.text import CountVectorizer from sklearn.feature_extraction.text import TfidfTransformer from sklearn.naive_bayes import MultinomialNB # 다항분포 나이브 베이즈 모델 from sklearn.metrics import accuracy_score #정확도 계산 dtmvector = CountVectorizer() X_train_dtm = dtmvector.fit_transform(newsdata.data) print(X_train_dtm.shape) (11314, 130107) 이제 자동으로 DTM이 완성되었습니다. 11,314는 훈련용 샘플의 개수이고 DTM 관점에서는 문서의 수가 되겠습니다. 130,107은 전체 훈련 데이터에 등장한 단어의 수를 의미합니다. 물론, DTM을 그대로 나이브 베이즈 분류기에 사용할 수도 있겠지만 DTM 행렬 대신 TF-IDF 가중치를 적용한 TF-IDF 행렬을 입력으로 텍스트 분류를 수행하면, 성능의 개선을 얻을 수도 있습니다. (DTM 챕터 참고) 주의할 점은 TF-IDF 행렬이 항상 DTM으로 수행했을 때보다 성능이 뛰어나지는 않습니다. 사이킷런은 TF-IDF를 자동 계산해 주는 TfidVectorizer 클래스를 제공하므로 이를 사용해 보겠습니다. tfidf_transformer = TfidfTransformer() tfidfv = tfidf_transformer.fit_transform(X_train_dtm) print(tfidfv.shape) (11314, 130107) 이제 TF-IDF 행렬이 만들어졌습니다. 이제 본격적으로 나이브 베이즈 분류를 수행해 보겠습니다. 사이킷런은 나이브 베이즈 모델을 지원하므로, 이를 그대로 갖고 와서 사용하겠습니다. mod = MultinomialNB() mod.fit(tfidfv, newsdata.target) 모델의 입력으로 TF-IDF 행렬과 11,314개의 훈련 데이터에 대한 레이블이 적혀있는 newsdata.target이 들어갑니다. 이는 앞서 배운 분류 예제들을 상기해 보면, 각각 X_train과 y_train에 해당되는 데이터들입니다. MultinomialNB(alpha=1.0, class_prior=None, fit_prior=True) 여기서 alpha=1.0은 라플라스 스무딩이 적용되었음을 의미합니다. newsdata_test = fetch_20newsgroups(subset='test', shuffle=True) #테스트 데이터 갖고 오기 X_test_dtm = dtmvector.transform(newsdata_test.data) #테스트 데이터를 DTM으로 변환 tfidfv_test = tfidf_transformer.transform(X_test_dtm) #DTM을 TF-IDF 행렬로 변환 predicted = mod.predict(tfidfv_test) #테스트 데이터에 대한 예측 print("정확도:", accuracy_score(newsdata_test.target, predicted)) #예측값과 실제 값 비교 정확도: 0.7738980350504514 77%의 정확도를 얻었습니다. 여기서는 하지 않았지만, 잠재 의미 분석 챕터에서 진행했던 전처리를 모두 진행하고 다시 나이브 베이즈 분류기를 돌려보세요. 80% 이상의 정확도를 얻을 수 있습니다. 10-06 네이버 영화 리뷰 감성 분류하기(Naver Movie Review Sentiment Analysis) 이번에 사용할 데이터는 네이버 영화 리뷰 데이터입니다. 총 200,000개 리뷰로 구성된 데이터로 영화 리뷰에 대한 텍스트와 해당 리뷰가 긍정인 경우 1, 부정인 경우 0을 표시한 레이블로 구성돼 있습니다. 해당 데이터를 다운로드해 감성 분류를 수행하는 모델을 만들어보겠습니다. 1. 네이버 영화 리뷰 데이터에 대한 이해와 전처리 데이터 다운로드 링크 : https://github.com/e9t/nsmc/ import pickle import pandas as pd import numpy as np import matplotlib.pyplot as plt import re import urllib.request from konlpy.tag import Okt from tqdm import tqdm from tensorflow.keras.preprocessing.text import Tokenizer from tensorflow.keras.preprocessing.sequence import pad_sequences 1) 데이터 로드하기 위 링크로부터 훈련 데이터에 해당하는 ratings_train.txt와 테스트 데이터에 해당하는 ratings_test.txt를 다운로드합니다. urllib.request.urlretrieve("https://raw.githubusercontent.com/e9t/nsmc/master/ratings_train.txt", filename="ratings_train.txt") urllib.request.urlretrieve("https://raw.githubusercontent.com/e9t/nsmc/master/ratings_test.txt", filename="ratings_test.txt") pandas를 이용하여 훈련 데이터는 train_data에 테스트 데이터는 test_data에 저장합니다. train_data = pd.read_table('ratings_train.txt') test_data = pd.read_table('ratings_test.txt') train_data에 존재하는 영화 리뷰의 개수를 확인해 봅시다. print('훈련용 리뷰 개수 :',len(train_data)) # 훈련용 리뷰 개수 출력 훈련용 리뷰 개수 : 150000 train_data는 총 150,000개의 리뷰가 존재합니다. 상위 5개의 샘플을 출력해 봅시다. train_data[:5] # 상위 5개 출력 해당 데이터는 id, document, label 총 3개의 열로 구성돼 있습니다. id는 감성 분류를 수행하는 데 도움이 되지 않으므로 앞으로 무시합니다. 결국 이 모델은 리뷰 내용을 담고 있는 document와 해당 리뷰가 긍정(1), 부정(0)인지를 나타내는 label 두 개의 열을 학습하는 모델이 되어야 합니다. 또한 단지 상위 5개의 샘플만 출력해 보았지만 한국어 데이터와 영어 데이터의 차이를 확인할 수 있습니다. 예를 들어, 인덱스 2번 샘플은 띄어쓰기를 하지 않아도 글을 쉽게 이해할 수 있는 한국어의 특성으로 인해 띄어쓰기가 되어있지 않습니다. test_data의 리뷰 개수와 상위 5개의 샘플을 확인해 봅시다. print('테스트용 리뷰 개수 :',len(test_data)) # 테스트용 리뷰 개수 출력 테스트용 리뷰 개수 : 50000 test_data는 총 50,000개의 영화 리뷰가 존재합니다. 상위 5개의 샘플을 출력해 봅시다. test_data[:5] test_data도 train_data와 동일한<NAME>으로 id, document, label 3개의 열로 구성돼 있습니다. 2) 데이터 정제하기 train_data의 데이터 중복 유무를 확인합니다. # document 열과 label 열의 중복을 제외한 값의 개수 train_data['document'].nunique(), train_data['label'].nunique() (146182, 2) 총 150,000개의 샘플이 존재하는데 document 열에서 중복을 제거한 샘플의 개수가 146,182개라는 것은 약 4,000개의 중복 샘플이 존재한다는 의미입니다. label 열은 0 또는 1의 두 가지 값만을 가지므로 2가 출력됩니다. 중복 샘플을 제거합니다. # document 열의 중복 제거 train_data.drop_duplicates(subset=['document'], inplace=True) 중복 샘플을 제거하였습니다. 중복이 제거되었는지 전체 샘플 수를 확인합니다. print('총 샘플의 수 :',len(train_data)) 총 샘플의 수 : 146183 중복 샘플이 제거되었습니다. train_data에서 해당 리뷰의 긍, 부정 유무가 기재되어 있는 레이블(label) 값의 분포를 보겠습니다. train_data['label'].value_counts().plot(kind = 'bar') 앞서 확인하였듯이 약 146,000개의 영화 리뷰 샘플이 존재하는데 그래프 상으로 긍정과 부정 둘 다 약 72,000개의 샘플이 존재하여 레이블의 분포가 균일한 것처럼 보입니다. 정확하게 몇 개인지 확인해 봅시다. print(train_data.groupby('label').size().reset_index(name = 'count')) label count 0 0 73342 1 1 72841 레이블이 0인 리뷰가 근소하게 많습니다. 리뷰 중에 Null 값을 가진 샘플이 있는지 확인합니다. print(train_data.isnull().values.any()) True True가 나왔다면 데이터 중에 Null 값을 가진 샘플이 존재한다는 의미입니다. 어떤 열에 존재하는지 확인해 봅시다. print(train_data.isnull().sum()) id 0 document 1 label 0 dtype: int64 리뷰가 적혀있는 document 열에서 Null 값을 가진 샘플이 총 1개가 존재한다고 합니다. 그렇다면 document 열에서 Null 값이 존재한다는 것을 조건으로 Null 값을 가진 샘플이 어느 인덱스의 위치에 존재하는지 한 번 출력해 봅시다. train_data.loc[train_data.document.isnull()] 출력 결과는 위와 같습니다. Null 값을 가진 샘플을 제거하겠습니다. train_data = train_data.dropna(how = 'any') # Null 값이 존재하는 행 제거 print(train_data.isnull().values.any()) # Null 값이 존재하는지 확인 False Null 값을 가진 샘플이 제거되었습니다. 다시 샘플의 개수를 출력하여 1개의 샘플이 제거되었는지 확인해 봅시다. print(len(train_data)) 146182 데이터의 전처리를 수행해 보겠습니다. 위의 train_data와 test_data에서 온점(.)이나? 와 같은 각종 특수문자가 사용된 것을 확인했습니다. train_data로부터 한글만 남기고 제거하기 위해서 정규 표현식을 사용해 보겠습니다. 우선 영어를 예시로 정규 표현식을 설명해 보겠습니다. 영어의 알파벳들을 나타내는 정규 표현식은 [a-zA-Z]입니다. 이 정규 표현식은 영어의 소문자와 대문자들을 모두 포함하고 있는 정규 표현식으로 이를 응용하면 영어에 속하지 않는 구두점이나 특수문자를 제거할 수 있습니다. 예를 들어 알파벳과 공백을 제외하고 모두 제거하는 전처리를 수행하는 예제는 다음과 같습니다. #알파벳과 공백을 제외하고 모두 제거 eng_text = 'do!!! you expect... people~ to~ read~ the FAQ, etc. and actually accept hard~! atheism?@@' print(re.sub(r'[^a-zA-Z ]', '', eng_text)) 'do you expect people to read the FAQ etc and actually accept hard atheism' 위와 같은 원리를 한국어 데이터에 적용하고 싶다면, 우선 한글을 범위 지정할 수 있는 정규 표현식을 찾아내면 되겠습니다. 우선 자음과 모음에 대한 범위를 지정해 보겠습니다. 일반적으로 자음의 범위는 ㄱ ~ ㅎ, 모음의 범위는 ㅏ ~ ㅣ와 같이 지정할 수 있습니다. 해당 범위 내에 어떤 자음과 모음이 속하는지 알고 싶다면 아래의 링크를 참고하시기 바랍니다. 링크 : https://www.unicode.org/charts/PDF/U3130.pdf ㄱ ~ ㅎ: 3131 ~ 314E ㅏ ~ ㅣ: 314F ~ 3163 완성형 한글의 범위는 가 ~ 힣과 같이 사용합니다. 해당 범위 내에 포함된 음절들은 아래의 링크에서 확인할 수 있습니다. 링크 : https://www.unicode.org/charts/PDF/UAC00.pdf 위 범위 지정을 모두 반영하여 train_data에 한글과 공백을 제외하고 모두 제거하는 정규 표현식을 수행해 봅시다. # 한글과 공백을 제외하고 모두 제거 train_data['document'] = train_data['document'].str.replace("[^ㄱ-ㅎㅏ-ㅣ가-힣 ]","") train_data[:5] 상위 5개의 샘플을 다시 출력해 보았는데, 정규 표현식을 수행하자 기존의 공백. 즉, 띄어쓰기는 유지되면서 온점과 같은 구두점 등은 제거되었습니다. 사실 네이버 영화 리뷰는 한글이 아니더라도 영어, 숫자, 특수문자로도 리뷰를 업로드할 수 있습니다. 다시 말해 기존에 한글이 없는 리뷰였다면 더 이상 아무런 값도 없는 빈(empty) 값이 되었을 것입니다. train_data에 공백(whitespace)만 있거나 빈 값을 가진 행이 있다면 Null 값으로 변경하도록 하고, Null 값이 존재하는지 확인해 보겠습니다. train_data['document'] = train_data['document'].str.replace('^ +', "") # white space 데이터를 empty value로 변경 train_data['document'].replace('', np.nan, inplace=True) print(train_data.isnull().sum()) id 0 document 789 label 0 dtype: int64 Null 값이 789개나 새로 생겼습니다. Null 값이 있는 행을 5개만 출력해 볼까요? train_data.loc[train_data.document.isnull()][:5] Null 샘플들은 레이블이 긍정일 수도 있고, 부정일 수도 있습니다. 아무런 의미도 없는 데이터므로 제거해 줍니다. train_data = train_data.dropna(how = 'any') print(len(train_data)) 145393 샘플 개수가 또다시 줄어서 145,393개가 남았습니다. 테스트 데이터에 앞서 진행한 전처리 과정을 동일하게 진행합니다. test_data.drop_duplicates(subset = ['document'], inplace=True) # document 열에서 중복인 내용이 있다면 중복 제거 test_data['document'] = test_data['document'].str.replace("[^ㄱ-ㅎㅏ-ㅣ가-힣 ]","") # 정규 표현식 수행 test_data['document'] = test_data['document'].str.replace('^ +', "") # 공백은 empty 값으로 변경 test_data['document'].replace('', np.nan, inplace=True) # 공백은 Null 값으로 변경 test_data = test_data.dropna(how='any') # Null 값 제거 print('전처리 후 테스트용 샘플의 개수 :',len(test_data)) 전처리 후 테스트용 샘플의 개수 : 48852 3) 토큰화 토큰화를 진행해 봅시다. 토큰화 과정에서 불용어를 제거하겠습니다. 불용어는 정의하기 나름인데, 한국어의 조사, 접속사 등의 보편적인 불용어를 사용할 수도 있겠지만 결국 풀고자 하는 문제의 데이터를 지속 검토하면서 계속해서 추가하는 경우 또한 많습니다. 실제 현업인 상황이라면 일반적으로 아래의 불용어보다 더 많은 불용어를 사용할 수 있습니다. stopwords = ['의','가','이','은','들','는','좀','잘','그냥','과','도','를','으로','자','에','와','한','하다'] 여기서는 위 정도로만 불용어를 정의하고, 토큰화를 위한 형태소 분석기는 KoNLPy의 Okt를 사용합니다. Okt를 복습해 봅시다. okt = Okt() okt.morphs('와 이런 것도 영화라고 차라리 뮤직비디오를 만드는 게 나을 뻔', stem = True) ['오다', '이렇다', '것', '도', '영화', '라고', '차라리', '뮤직비디오', '를', '만들다', '게', '나다', '뻔'] Okt는 위와 같이 KoNLPy에서 제공하는 형태소 분석기입니다. 한국어을 토큰화할 때는 영어처럼 띄어쓰기 기준으로 토큰화를 하는 것이 아니라, 주로 형태소 분석기를 사용한다고 언급한 바 있습니다. stem = True를 사용하면 일정 수준의 정규화를 수행해 주는데, 예를 들어 위의 예제의 결과를 보면 '이런'이 '이렇다'로 변환되었고 '만드는'이 '만들다'로 변환된 것을 알 수 있습니다. train_data에 형태소 분석기를 사용하여 토큰화를 하면서 불용어를 제거하여 X_train에 저장합니다. X_train = [] for sentence in tqdm(train_data['document']): tokenized_sentence = okt.morphs(sentence, stem=True) # 토큰화 stopwords_removed_sentence = [word for word in tokenized_sentence if not word in stopwords] # 불용어 제거 X_train.append(stopwords_removed_sentence) 상위 3개의 샘플만 출력하여 결과를 확인해 봅시다. print(X_train[:3]) [['아', '더빙', '진짜', '짜증 나다', '목소리'], ['흠', '포스터', '보고', '초등학생', '영화', '줄', '오버', '연기', '조차', '가볍다', '않다'], ['너', '무재', '밓었', '다그', '래서', '보다', '추천', '다']] 형태소 토큰 화가 진행된 것을 볼 수 있습니다. 테스트 데이터에 대해서도 동일하게 토큰화를 해줍니다. X_test = [] for sentence in tqdm(test_data['document']): tokenized_sentence = okt.morphs(sentence, stem=True) # 토큰화 stopwords_removed_sentence = [word for word in tokenized_sentence if not word in stopwords] # 불용어 제거 X_test.append(stopwords_removed_sentence) 지금까지 훈련 데이터와 테스트 데이터에 대해서 텍스트 전처리를 진행해 보았습니다. 4) 정수 인코딩 기계가 텍스트를 숫자로 처리할 수 있도록 훈련 데이터와 테스트 데이터에 정수 인코딩을 수행해야 합니다. 우선, 훈련 데이터에 대해서 단어 집합(vocaburary)을 만들어봅시다. tokenizer = Tokenizer() tokenizer.fit_on_texts(X_train) 단어 집합이 생성되는 동시에 각 단어에 고유한 정수가 부여되었습니다. 이는 tokenizer.word_index를 출력하여 확인 가능합니다. print(tokenizer.word_index) {'영화': 1, '보다': 2, '을': 3, '없다': 4, '이다': 5, '있다': 6, '좋다': 7, ... 중략 ... '디케이드': 43751, '수간': 43752} 단어가 43,000개가 넘게 존재합니다. 각 정수는 전체 훈련 데이터에서 등장 빈도수가 높은 순서대로 부여되었기 때문에, 높은 정수가 부여된 단어들은 등장 빈도수가 매우 낮다는 것을 의미합니다. 여기서는 빈도수가 낮은 단어들은 자연어 처리에서 배제하고자 합니다. 등장 빈도수가 3회 미만인 단어들이 이 데이터에서 얼마큼의 비중을 차지하는지 확인해 봅시다. threshold = 3 total_cnt = len(tokenizer.word_index) # 단어의 수 rare_cnt = 0 # 등장 빈도수가 threshold보다 작은 단어의 개수를 카운트 total_freq = 0 # 훈련 데이터의 전체 단어 빈도수 총합 rare_freq = 0 # 등장 빈도수가 threshold보다 작은 단어의 등장 빈도수의 총합 # 단어와 빈도수의 쌍(pair)을 key와 value로 받는다. for key, value in tokenizer.word_counts.items(): total_freq = total_freq + value # 단어의 등장 빈도수가 threshold보다 작으면 if(value < threshold): rare_cnt = rare_cnt + 1 rare_freq = rare_freq + value print('단어 집합(vocabulary)의 크기 :',total_cnt) print('등장 빈도가 %s 번 이하인 희귀 단어의 수: %s'%(threshold - 1, rare_cnt)) print("단어 집합에서 희귀 단어의 비율:", (rare_cnt / total_cnt)*100) print("전체 등장 빈도에서 희귀 단어 등장 빈도 비율:", (rare_freq / total_freq)*100) 단어 집합(vocabulary)의 크기 : 43752 등장 빈도가 2번 이하인 희귀 단어의 수: 24337 단어 집합에서 희귀 단어의 비율: 55.62488571950996 전체 등장 빈도에서 희귀 단어 등장 빈도 비율: 1.8715872104872904 등장 빈도가 threshold 값인 3회 미만. 즉, 2회 이하인 단어들은 단어 집합에서 무려 절반 이상을 차지합니다. 하지만, 실제로 훈련 데이터에서 등장 빈도로 차지하는 비중은 상대적으로 매우 적은 수치인 1.87%밖에 되지 않습니다. 아무래도 등장 빈도가 2회 이하인 단어들은 자연어 처리에서 별로 중요하지 않을 듯합니다. 그래서 이 단어들은 정수 인코딩 과정에서 배제시키겠습니다. 등장 빈도수가 2이하인 단어들의 수를 제외한 단어의 개수를 단어 집합의 최대 크기로 제한하겠습니다. # 전체 단어 개수 중 빈도수 2이하인 단어는 제거. # 0번 패딩 토큰을 고려하여 + 1 vocab_size = total_cnt - rare_cnt + 1 print('단어 집합의 크기 :',vocab_size) 단어 집합의 크기 : 19416 단어 집합의 크기는 19,416개입니다. 이를 케라스 토크 나이저의 인자로 넘겨주고 텍스트 시퀀스를 정수 시퀀스로 변환합니다. tokenizer = Tokenizer(vocab_size) tokenizer.fit_on_texts(X_train) X_train = tokenizer.texts_to_sequences(X_train) X_test = tokenizer.texts_to_sequences(X_test) 정수 인코딩이 진행되었는지 확인하고자 X_train에 대해서 상위 3개의 샘플만 출력합니다. print(X_train[:3]) [[50, 454, 16, 260, 659], [933, 457, 41, 602, 1, 214, 1449, 24, 961, 675, 19], [386, 2444, 2315, 5671, 2, 222, 9]] 각 샘플 내의 단어들은 각 단어에 대한 정수로 변환된 것을 확인할 수 있습니다. 단어의 개수는 19,416개로 제한되었으므로 0번 단어 ~ 19,415번 단어까지만 사용 중입니다. 0번 단어는 패딩을 위한 토큰임을 상기합시다. train_data에서 y_train과 y_test를 별도로 저장해 줍니다. y_train = np.array(train_data['label']) y_test = np.array(test_data['label']) 5) 빈 샘플(empty samples) 제거 전체 데이터에서 빈도수가 낮은 단어가 삭제되었다는 것은 빈도수가 낮은 단어만으로 구성되었던 샘플들은 빈(empty) 샘플이 되었다는 것을 의미합니다. 빈 샘플들은 어떤 레이블이 붙어있던 의미가 없으므로 빈 샘플들을 제거해 주는 작업을 하겠습니다. 각 샘플들의 길이를 확인해서 길이가 0인 샘플들의 인덱스를 받아오겠습니다. drop_train = [index for index, sentence in enumerate(X_train) if len(sentence) < 1] drop_train에는 X_train으로부터 얻은 빈 샘플들의 인덱스가 저장됩니다. 앞서 훈련 데이터(X_train, y_train)의 샘플 개수는 145,791개임을 확인했었습니다. 그렇다면 빈 샘플들을 제거한 후의 샘플 개수는 몇 개일까요? # 빈 샘플들을 제거 X_train = np.delete(X_train, drop_train, axis=0) y_train = np.delete(y_train, drop_train, axis=0) print(len(X_train)) print(len(y_train)) 145162 145162 145,162개로 샘플의 수가 줄어든 것을 확인할 수 있습니다. 6) 패딩 서로 다른 길이의 샘플들의 길이를 동일하게 맞춰주는 패딩 작업을 진행해 보겠습니다. 전체 데이터에서 가장 길이가 긴 리뷰와 전체 데이터의 길이 분포를 알아보겠습니다. print('리뷰의 최대 길이 :',max(len(review) for review in X_train)) print('리뷰의 평균 길이 :',sum(map(len, X_train))/len(X_train)) plt.hist([len(review) for review in X_train], bins=50) plt.xlabel('length of samples') plt.ylabel('number of samples') plt.show() 리뷰의 최대 길이 : 69 리뷰의 평균 길이 : 10.812485361182679 가장 긴 리뷰의 길이는 69이며, 그래프를 봤을 때 전체 데이터의 길이 분포는 대체적으로 약 11내외의 길이를 가지는 것을 볼 수 있습니다. 모델이 처리할 수 있도록 X_train과 X_test의 모든 샘플의 길이를 특정 길이로 동일하게 맞춰줄 필요가 있습니다. 특정 길이 변수를 max_len으로 정합니다. 대부분의 리뷰가 내용이 잘리지 않도록 할 수 있는 최적의 max_len의 값은 몇일까요? 전체 샘플 중 길이가 max_len 이하인 샘플의 비율이 몇 % 인지 확인하는 함수를 만듭니다. def below_threshold_len(max_len, nested_list): count = 0 for sentence in nested_list: if(len(sentence) <= max_len): count = count + 1 print('전체 샘플 중 길이가 %s 이하인 샘플의 비율: %s'%(max_len, (count / len(nested_list))*100)) 위의 분포 그래프를 봤을 때, max_len = 30이 적당할 것 같습니다. 이 값이 얼마나 많은 리뷰 길이를 커버하는지 확인해 봅시다. max_len = 30 below_threshold_len(max_len, X_train) 전체 샘플 중 길이가 30 이하인 샘플의 비율: 94.31944999380003 전체 훈련 데이터 중 약 94%의 리뷰가 30이하의 길이를 가지는 것을 확인했습니다. 모든 샘플의 길이를 30으로 맞추겠습니다. X_train = pad_sequences(X_train, maxlen=max_len) X_test = pad_sequences(X_test, maxlen=max_len) 2. LSTM으로 네이버 영화 리뷰 감성 분류하기 하이퍼 파라미터인 임베딩 벡터의 차원은 100, 은닉 상태의 크기는 128입니다. 모델은 다 대 일 구조의 LSTM을 사용합니다. 해당 모델은 마지막 시점에서 두 개의 선택지 중 하나를 예측하는 이진 분류 문제를 수행하는 모델입니다. 이진 분류 문제의 경우, 출력층에 로지스틱 회귀를 사용해야 하므로 활성화 함수로는 시그모이드 함수를 사용하고, 손실 함수로 크로스 엔트로피 함수를 사용합니다. 하이퍼 파라미터인 배치 크기는 64이며, 15 에포크를 수행합니다. EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=4)는 검증 데이터 손실(val_loss)이 증가하면, 과적합 징후므로 검증 데이터 손실이 4회 증가하면 정해진 에포크가 도달하지 못하였더라도 학습을 조기 종료(Early Stopping) 한다는 의미입니다. ModelCheckpoint를 사용하여 검증 데이터의 정확도(val_acc)가 이전보다 좋아질 경우에만 모델을 저장합니다. validation_split=0.2를 사용하여 훈련 데이터의 20%를 검증 데이터로 분리해서 사용하고, 검증 데이터를 통해서 훈련이 적절히 되고 있는지 확인합니다. 검증 데이터는 기계가 훈련 데이터에 과적합되고 있지는 않은지 확인하기 위한 용도로 사용됩니다. from tensorflow.keras.layers import Embedding, Dense, LSTM from tensorflow.keras.models import Sequential from tensorflow.keras.models import load_model from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint embedding_dim = 100 hidden_units = 128 model = Sequential() model.add(Embedding(vocab_size, embedding_dim)) model.add(LSTM(hidden_units)) model.add(Dense(1, activation='sigmoid')) es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=4) mc = ModelCheckpoint('best_model.h5', monitor='val_acc', mode='max', verbose=1, save_best_only=True) model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc']) history = model.fit(X_train, y_train, epochs=15, callbacks=[es, mc], batch_size=64, validation_split=0.2) 저자의 경우 조기 종료 조건에 따라서 9 에포크에서 훈련이 멈췄습니다. 훈련이 다 되었다면 테스트 데이터에 대해서 정확도를 측정할 차례입니다. 훈련 과정에서 검증 데이터의 정확도가 가장 높았을 때 저장된 모델인 'best_model.h5'를 로드합니다. loaded_model = load_model('best_model.h5') print("\n 테스트 정확도: %.4f" % (loaded_model.evaluate(X_test, y_test)[1])) 테스트 정확도: 0.8544 테스트 데이터에서 85.44%의 정확도를 얻습니다. 위 코드는 뒤에서 이어질 네이버 쇼핑 리뷰 분류 실습과 한국어 스팀 리뷰 감성 분류 실습에서도 거의 동일하게 사용될 코드입니다. 모델과 마찬가지로 토크 나이저도 다음과 같이 파일로 저장 후 다시 로드할 수 있습니다. with open('tokenizer.pickle', 'wb') as handle: pickle.dump(tokenizer, handle) with open('tokenizer.pickle', 'rb') as handle: tokenizer = pickle.load(handle) 3. 리뷰 예측해 보기 임의의 리뷰에 대해서 예측하는 함수를 만들어보겠습니다. 기본적으로 현재 학습한 model에 새로운 입력에 대해서 예측값을 얻는 것은 model.predict()를 사용합니다. 그리고 model.fit()을 할 때와 마찬가지로 새로운 입력에 대해서도 동일한 전처리를 수행 후에 model.predict()의 입력으로 사용해야 합니다. def sentiment_predict(new_sentence): new_sentence = re.sub(r'[^ㄱ-ㅎㅏ-ㅣ가-힣 ]','', new_sentence) new_sentence = okt.morphs(new_sentence, stem=True) # 토큰화 new_sentence = [word for word in new_sentence if not word in stopwords] # 불용어 제거 encoded = tokenizer.texts_to_sequences([new_sentence]) # 정수 인코딩 pad_new = pad_sequences(encoded, maxlen = max_len) # 패딩 score = float(loaded_model.predict(pad_new)) # 예측 if(score > 0.5): print("{:.2f}% 확률로 긍정 리뷰입니다.\n".format(score * 100)) else: print("{:.2f}% 확률로 부정 리뷰입니다.\n".format((1 - score) * 100)) sentiment_predict('이 영화 개꿀 잼 ㅋㅋㅋ') 97.76% 확률로 긍정 리뷰입니다. sentiment_predict('이 영화 핵노잼 ㅠㅠ') 98.55% 확률로 부정 리뷰입니다. sentiment_predict('이딴 게 영화냐 ㅉㅉ') 99.91% 확률로 부정 리뷰입니다. sentiment_predict('감독 뭐 하는 놈이냐?') 98.21% 확률로 부정 리뷰입니다. sentiment_predict('와 개쩐다 정말 세계관 최강자들의 영화다') 80.77% 확률로 긍정 리뷰입니다. 참고하세요! ㄱ-ㅎ와 ㅏ-ㅣ 사이에 어떤 글자들이 포함돼 있는지는 아래의 링크에서 확인할 수 있습니다. https://www.unicode.org/charts/PDF/U3130.pdf 가-힣 사이에 어떤 글자들이 포함돼 있는지는 아래의 링크에서 확인할 수 있습니다. https://www.unicode.org/charts/PDF/UAC00.pdf 10-07 네이버 쇼핑 리뷰 감성 분류하기(Naver Shopping Review Sentiment Analysis) 1. Colab에 Mecab 설치 여기서는 형태소 분석기 Mecab을 사용합니다. 저자의 경우 Mecab을 편하게 사용하기 위해서 구글의 Colab을 사용하였습니다. 참고로 Colab에서 실습하는 경우가 아니라면 아래의 방법으로 Mecab이 설치되지 않습니다. 이 경우 해당 환경에 맞게 Mecab을 설치하시거나 다른 형태소 분석기를 사용하시기 바랍니다. # Colab에 Mecab 설치 !pip install konlpy !pip install mecab-python !bash <(curl -s https://raw.githubusercontent.com/konlpy/konlpy/master/scripts/mecab.sh) 2. 네이버 쇼핑 리뷰 데이터에 대한 이해와 전처리 다운로드 링크 : https://github.com/bab2min/corpus/tree/master/sentiment import re import pandas as pd import numpy as np import matplotlib.pyplot as plt import urllib.request from collections import Counter from konlpy.tag import Mecab from sklearn.model_selection import train_test_split from tensorflow.keras.preprocessing.text import Tokenizer from tensorflow.keras.preprocessing.sequence import pad_sequences 1) 데이터 로드하기 위의 링크로부터 전체 데이터에 해당하는 ratings_total.txt를 다운로드합니다. urllib.request.urlretrieve("https://raw.githubusercontent.com/bab2min/corpus/master/sentiment/naver_shopping.txt", filename="ratings_total.txt") 해당 데이터에는 열제목이 별도로 없습니다. 그래서 임의로 두 개의 열제목인 'ratings'와 'reviews'를 추가해 주겠습니다. total_data = pd.read_table('ratings_total.txt', names=['ratings', 'reviews']) print('전체 리뷰 개수 :',len(total_data)) # 전체 리뷰 개수 출력 전체 리뷰 개수 : 200000 총 20만 개의 샘플이 존재합니다. 상위 5개의 샘플만 출력해 봅시다. total_data[:5] 2) 훈련 데이터와 테스트 데이터 분리하기 현재 갖고 있는 데이터는 레이블을 별도로 갖고 있지 않습니다. 평점이 4, 5인 리뷰에는 레이블 1을, 평점이 1, 2인 리뷰에는 레이블 0을 부여합니다. 부여된 레이블은 새로 생성한 label이라는 열에 저장합니다. total_data['label'] = np.select([total_data.ratings > 3], [1], default=0) total_data[:5] 각 열에 대해서 중복을 제외한 샘플의 수를 카운트합니다. total_data['ratings'].nunique(), total_data['reviews'].nunique(), total_data['label'].nunique() (4, 199908, 2) ratings 열의 경우 1, 2, 4, 5라는 네 가지 값을 가지고 있습니다. reviews 열에서 중복을 제외한 경우 199,908개입니다. 현재 20만 개의 리뷰가 존재하므로 이는 현재 갖고 있는 데이터에 중복인 샘플들이 있다는 의미입니다. 중복인 샘플들을 제거해 줍니다. total_data.drop_duplicates(subset=['reviews'], inplace=True) # reviews 열에서 중복인 내용이 있다면 중복 제거 print('총 샘플의 수 :',len(total_data)) 총 샘플의 수 : 199908 NULL 값 유무를 확인합니다. print(total_data.isnull().values.any()) False 훈련 데이터와 테스트 데이터를 3:1 비율로 분리합니다. train_data, test_data = train_test_split(total_data, test_size = 0.25, random_state = 42) print('훈련용 리뷰의 개수 :', len(train_data)) print('테스트용 리뷰의 개수 :', len(test_data)) 훈련용 리뷰의 개수 : 149931 테스트용 리뷰의 개수 : 49977 훈련용 리뷰의 경우 약 14만 9,900개. 테스트용 리뷰의 경우 약 4만 9,900개가 존재합니다. 3) 레이블의 분포 확인 훈련 데이터의 레이블의 분포를 확인해 봅시다. train_data['label'].value_counts().plot(kind = 'bar') print(train_data.groupby('label').size().reset_index(name = 'count')) label count 0 0 74918 1 1 75013 두 레이블 모두 약 7만 5천 개로 50:50 비율을 가지고 있습니다. 4) 데이터 정제하기 정규 표현식을 사용하여 한글을 제외하고 모두 제거해 줍니다. 또한 혹시 이 과정에서 빈 샘플이 생기지는 않는지 확인합니다. # 한글과 공백을 제외하고 모두 제거 train_data['reviews'] = train_data['reviews'].str.replace("[^ㄱ-ㅎㅏ-ㅣ가-힣 ]","") train_data['reviews'].replace('', np.nan, inplace=True) print(train_data.isnull().sum()) ratings 0 reviews 0 label 0 dtype: int64 테스트 데이터에 대해서도 같은 과정을 거칩니다. test_data.drop_duplicates(subset = ['reviews'], inplace=True) # 중복 제거 test_data['reviews'] = test_data['reviews'].str.replace("[^ㄱ-ㅎㅏ-ㅣ가-힣 ]","") # 정규 표현식 수행 test_data['reviews'].replace('', np.nan, inplace=True) # 공백은 Null 값으로 변경 test_data = test_data.dropna(how='any') # Null 값 제거 print('전처리 후 테스트용 샘플의 개수 :',len(test_data)) 전처리 후 테스트용 샘플의 개수 : 49977 5) 토큰화 형태소 분석기 Mecab을 사용하여 토큰화 작업을 수행합니다. 다음은 임의의 문장에 대해서 테스트한 토큰화 결과입니다. mecab = Mecab() print(mecab.morphs('와 이런 것도 상품이라고 차라리 내가 만드는 게 나을 뻔')) ['와', '이런', '것', '도', '상품', '이', '라고', '차라리', '내', '가', '만드', '는', '게', '나을', '뻔'] 불용어를 지정하여 필요 없는 토큰들은 제거하도록 합니다. stopwords = ['도', '는', '다', '의', '가', '이', '은', '한', '에', '하', '고', '을', '를', '인', '듯', '과', '와', '네', '들', '듯', '지', '임', '게'] 훈련 데이터와 테스트 데이터에 대해서 동일한 과정을 거칩니다. train_data['tokenized'] = train_data['reviews'].apply(mecab.morphs) train_data['tokenized'] = train_data['tokenized'].apply(lambda x: [item for item in x if item not in stopwords]) test_data['tokenized'] = test_data['reviews'].apply(mecab.morphs) test_data['tokenized'] = test_data['tokenized'].apply(lambda x: [item for item in x if item not in stopwords]) 6) 단어와 길이 분포 확인하기 긍정 리뷰에는 주로 어떤 단어들이 많이 등장하고, 부정 리뷰에는 주로 어떤 단어들이 등장하는지 두 가지 경우에 대해서 각 단어의 빈도수를 계산해 보겠습니다. 각 레이블에 따라서 별도로 단어들의 리스트를 저장해 줍니다. negative_words = np.hstack(train_data[train_data.label == 0]['tokenized'].values) positive_words = np.hstack(train_data[train_data.label == 1]['tokenized'].values) Counter()를 사용하여 각 단어에 대한 빈도수를 카운트합니다. 우선 부정 리뷰에 대해서 빈도수가 높은 상위 20개 단어들을 출력합니다. negative_word_count = Counter(negative_words) print(negative_word_count.most_common(20)) [('네요', 31799), ('는데', 20295), ('안', 19718), ('어요', 14849), ('있', 13200), ('너무', 13058), ('했', 11783), ('좋', 9812), ('배송', 9677), ('같', 8997), ('구매', 8876), ('어', 8869), ('거', 8854), ('없', 8670), ('아요', 8642), ('습니다', 8436), ('그냥', 8355), ('되', 8345), ('잘', 8029), ('안', 7984)] '네요', '는데', '안', '안', '너무', '없' 등과 같은 단어들이 부정 리뷰에서 주로 등장합니다. 긍정 리뷰에 대해서도 출력해 봅시다. positive_word_count = Counter(positive_words) print(positive_word_count.most_common(20)) [('좋', 39488), ('아요', 21184), ('네요', 19895), ('어요', 18686), ('잘', 18602), ('구매', 16171), ('습니다', 13320), ('있', 12391), ('배송', 12275), ('는데', 11670), ('했', 9818), ('합니다', 9801), ('먹', 9635), ('재', 9273), ('너무', 8397), ('같', 7868), ('만족', 7261), ('거', 6482), ('어', 6294), ('쓰', 6292)] '좋', '아요', '네요', '잘', '너무', '만족' 등과 같은 단어들이 주로 많이 등장합니다. 두 가지 경우에 대해서 각각 길이 분포를 확인해 봅시다. fig,(ax1, ax2) = plt.subplots(1,2, figsize=(10,5)) text_len = train_data[train_data['label']==1]['tokenized'].map(lambda x: len(x)) ax1.hist(text_len, color='red') ax1.set_title('Positive Reviews') ax1.set_xlabel('length of samples') ax1.set_ylabel('number of samples') print('긍정 리뷰의 평균 길이 :', np.mean(text_len)) text_len = train_data[train_data['label']==0]['tokenized'].map(lambda x: len(x)) ax2.hist(text_len, color='blue') ax2.set_title('Negative Reviews') fig.suptitle('Words in texts') ax2.set_xlabel('length of samples') ax2.set_ylabel('number of samples') print('부정 리뷰의 평균 길이 :', np.mean(text_len)) plt.show() 긍정 리뷰의 평균 길이 : 13.587751456414221 부정 리뷰의 평균 길이 : 17.02953896259911 긍정 리뷰보다는 부정 리뷰가 좀 더 길게 작성된 경향이 있는 것 같습니다. X_train = train_data['tokenized'].values y_train = train_data['label'].values X_test= test_data['tokenized'].values y_test = test_data['label'].values 7) 정수 인코딩 기계가 텍스트를 숫자로 처리할 수 있도록 훈련 데이터와 테스트 데이터에 정수 인코딩을 수행해야 합니다. 훈련 데이터에 대해서 단어 집합(vocaburary)을 만들어봅시다. tokenizer = Tokenizer() tokenizer.fit_on_texts(X_train) 단어 집합이 생성되는 동시에 각 단어에 고유한 정수가 부여되었습니다. 이는 tokenizer.word_index를 출력하여 확인 가능합니다. 등장 횟수가 1회인 단어들은 자연어 처리에서 배제하고자 합니다. 이 단어들이 이 데이터에서 얼마큼의 비중을 차지하는지 확인해 봅시다. threshold = 2 total_cnt = len(tokenizer.word_index) # 단어의 수 rare_cnt = 0 # 등장 빈도수가 threshold보다 작은 단어의 개수를 카운트 total_freq = 0 # 훈련 데이터의 전체 단어 빈도수 총합 rare_freq = 0 # 등장 빈도수가 threshold보다 작은 단어의 등장 빈도수의 총합 # 단어와 빈도수의 쌍(pair)을 key와 value로 받는다. for key, value in tokenizer.word_counts.items(): total_freq = total_freq + value # 단어의 등장 빈도수가 threshold보다 작으면 if(value < threshold): rare_cnt = rare_cnt + 1 rare_freq = rare_freq + value print('단어 집합(vocabulary)의 크기 :',total_cnt) print('등장 빈도가 %s 번 이하인 희귀 단어의 수: %s'%(threshold - 1, rare_cnt)) print("단어 집합에서 희귀 단어의 비율:", (rare_cnt / total_cnt)*100) print("전체 등장 빈도에서 희귀 단어 등장 빈도 비율:", (rare_freq / total_freq)*100) 단어 집합(vocabulary)의 크기 : 39997 등장 빈도가 1번 이하인 희귀 단어의 수: 18212 단어 집합에서 희귀 단어의 비율: 45.53341500612546 전체 등장 빈도에서 희귀 단어 등장 빈도 비율: 0.7935245745567578 단어가 약 40,000개가 존재합니다. 등장 빈도가 threshold 값인 2회 미만. 즉, 1회인 단어들은 단어 집합에서 약 45%를 차지합니다. 하지만, 실제로 훈련 데이터에서 등장 빈도로 차지하는 비중은 매우 적은 수치인 약 0.8%밖에 되지 않습니다. 아무래도 등장 빈도가 1회인 단어들은 자연어 처리에서 중요하지 않을 것으로 저자는 판단했습니다. 이 단어들은 정수 인코딩 과정에서 배제시키겠습니다. 등장 빈도수가 1인 단어들의 수를 제외한 단어의 개수를 단어 집합의 최대 크기로 제한합니다. # 전체 단어 개수 중 빈도수 2이하인 단어 개수는 제거. # 0번 패딩 토큰과 1번 OOV 토큰을 고려하여 +2 vocab_size = total_cnt - rare_cnt + 2 print('단어 집합의 크기 :',vocab_size) 단어 집합의 크기 : 21787 단어 집합의 크기는 21,787개입니다. 이를 토크 나이저의 인자로 넘겨주고, 텍스트 시퀀스를 정수 시퀀스로 변환합니다. 정수 인코딩 과정에서 이보다 큰 숫자가 부여된 단어들은 OOV로 변환하겠습니다. tokenizer = Tokenizer(vocab_size, oov_token = 'OOV') tokenizer.fit_on_texts(X_train) X_train = tokenizer.texts_to_sequences(X_train) X_test = tokenizer.texts_to_sequences(X_test) X_train과 X_test에 대해서 상위 3개의 샘플만 출력합니다. print(X_train[:3]) [[67, 2060, 299, 14260, 263, 73, 6, 236, 168, 137, 805, 2951, 625, 2, 77, 62, 207, 40, 1343, 155, 3, 6], [482, 409, 52, 8530, 2561, 2517, 339, 2918, 250, 2357, 38, 473, 2], [46, 24, 825, 105, 35, 2372, 160, 7, 10, 8061, 4, 1319, 29, 140, 322, 41, 59, 160, 140, 7, 1916, 2, 113, 162, 1379, 323, 119, 136]] print(X_test[:3]) [[14, 704, 767, 116, 186, 252, 12], [339, 3904, 62, 3816, 1651], [11, 69, 2, 49, 164, 3, 27, 15, 6, 513, 289, 17, 92, 110, 564, 59, 7, 2]] 8) 패딩 서로 다른 길이의 샘플들의 길이를 동일하게 맞춰주는 패딩 작업을 진행해 보겠습니다. 전체 데이터에서 가장 길이가 긴 리뷰와 전체 데이터의 길이 분포를 알아보겠습니다. print('리뷰의 최대 길이 :',max(len(review) for review in X_train)) print('리뷰의 평균 길이 :',sum(map(len, X_train))/len(X_train)) plt.hist([len(review) for review in X_train], bins=50) plt.xlabel('length of samples') plt.ylabel('number of samples') plt.show() 리뷰의 최대 길이 : 85 리뷰의 평균 길이 : 15.307554808545264 리뷰의 최대 길이는 85, 평균 길이는 약 15입니다. 그래프로 봤을 때, 전체적으로는 60이하의 길이를 가지는 것으로 보입니다. def below_threshold_len(max_len, nested_list): count = 0 for sentence in nested_list: if(len(sentence) <= max_len): count = count + 1 print('전체 샘플 중 길이가 %s 이하인 샘플의 비율: %s'%(max_len, (count / len(nested_list))*100)) 최대 길이가 85이므로 만약 80으로 패딩 할 경우, 몇 개의 샘플들을 온전히 보전할 수 있는지 확인해 봅시다. max_len = 80 below_threshold_len(max_len, X_train) 전체 샘플 중 길이가 80 이하인 샘플의 비율: 99.99933302652553 훈련용 리뷰의 99.99%가 80이하의 길이를 가집니다. 훈련용 리뷰를 길이 80으로 패딩 하겠습니다. X_train = pad_sequences(X_train, maxlen=max_len) X_test = pad_sequences(X_test, maxlen=max_len) 3. GRU로 네이버 쇼핑 리뷰 감성 분류하기 하이퍼 파라미터인 임베딩 벡터의 차원은 100, 은닉 상태의 크기는 128입니다. 모델은 다 대 일 구조의 LSTM를 사용합니다. 해당 모델은 마지막 시점에서 두 개의 선택지 중 하나를 예측하는 이진 분류 문제를 수행하는 모델입니다. 이진 분류 문제의 경우, 출력층에 로지스틱 회귀를 사용해야 하므로 활성화 함수로는 시그모이드 함수를 사용하고, 손실 함수로 크로스 엔트로피 함수를 사용합니다. 하이퍼 파라미터인 배치 크기는 64이며, 15 에포크를 수행합니다. EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=4)는 검증 데이터 손실(val_loss)이 증가하면, 과적합 징후므로 검증 데이터 손실이 4회 증가하면 정해진 에포크가 도달하지 못하였더라도 학습을 조기 종료(Early Stopping) 한다는 의미입니다. ModelCheckpoint를 사용하여 검증 데이터의 정확도(val_acc)가 이전보다 좋아질 경우에만 모델을 저장합니다. validation_split=0.2를 사용하여 훈련 데이터의 20%를 검증 데이터로 분리해서 사용하고, 검증 데이터를 통해서 훈련이 적절히 되고 있는지 확인합니다. 검증 데이터는 기계가 훈련 데이터에 과적합되고 있지는 않은지 확인하기 위한 용도로 사용됩니다. from tensorflow.keras.layers import Embedding, Dense, GRU from tensorflow.keras.models import Sequential from tensorflow.keras.models import load_model from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint embedding_dim = 100 hidden_units = 128 model = Sequential() model.add(Embedding(vocab_size, embedding_dim)) model.add(GRU(hidden_units)) model.add(Dense(1, activation='sigmoid')) es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=4) mc = ModelCheckpoint('best_model.h5', monitor='val_acc', mode='max', verbose=1, save_best_only=True) model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc']) history = model.fit(X_train, y_train, epochs=15, callbacks=[es, mc], batch_size=64, validation_split=0.2) 저자의 경우 에포크 10에서 조기 종료가 발생했습니다. loaded_model = load_model('best_model.h5') print("\n 테스트 정확도: %.4f" % (loaded_model.evaluate(X_test, y_test)[1])) 1562/1562 [==============================] - 5s 3ms/step - loss: 0.2108 - acc: 0.9237 테스트 정확도: 0.9237 4. 리뷰 예측해 보기 임의의 문장에 대한 예측을 위해서는 학습하기 전 전처리를 동일하게 적용해 줍니다. 전처리의 순서는 정규 표현식을 통한 한국어 외 문자 제거, 토큰화, 불용어 제거, 정수 인코딩, 패딩 순입니다. def sentiment_predict(new_sentence): new_sentence = re.sub(r'[^ㄱ-ㅎㅏ-ㅣ가-힣 ]','', new_sentence) new_sentence = mecab.morphs(new_sentence) new_sentence = [word for word in new_sentence if not word in stopwords] encoded = tokenizer.texts_to_sequences([new_sentence]) pad_new = pad_sequences(encoded, maxlen = max_len) score = float(loaded_model.predict(pad_new)) if(score > 0.5): print("{:.2f}% 확률로 긍정 리뷰입니다.".format(score * 100)) else: print("{:.2f}% 확률로 부정 리뷰입니다.".format((1 - score) * 100)) sentiment_predict('이 상품 진짜 좋아요... 저는 강추합니다. 대박') 98.88% 확률로 긍정 리뷰입니다. sentiment_predict('진짜 배송도 늦고 개짜증 나네요. 뭐 이런 걸 상품이라고 만듦?') 99.31% 확률로 부정 리뷰입니다. sentiment_predict('판매자님... 너무 최고예요.. 대박나삼') 98.36% 확률로 긍정 리뷰입니다. sentiment_predict('ㅁㄴㅇㄻㄴㅇㄻㄴㅇ리뷰쓰기도 귀찮아') 91.69% 확률로 부정 리뷰입니다. 10-08 BiLSTM으로 한국어 스팀 리뷰 감성 분류하기 게임 플랫폼 스팀에 등록된 한국어 리뷰에 대해서 감성 분석을 진행해 보겠습니다. 이 데이터는 긍정인 리뷰에는 레이블 1이, 부정인 리뷰에는 레이블 0이 부여돼 있습니다. 앞서 진행했던 감성 분류 문제들과 마찬가지로 이진 분류 문제를 풉니다. 1. BiLSTM을 텍스트 분류에 사용하기 양방향 LSTM은 두 개의 독립적인 LSTM 아키텍처를 함께 사용하는 구조입니다. 위 그림에서 주황색 LSTM 셀은 순차적으로 입력을 받습니다. 자연어 처리라고 한다면, 마치 사람처럼 문장을 왼쪽 단어부터 순차적으로 읽는 셈입니다. 양방향 LSTM은 뒤의 문맥까지 고려하기 위해서 문장을 오른쪽에서 반대로 읽는 역방향의 LSTM 셀(위 그림에서 초록색)을 함께 사용합니다. 이 두 가지 정보를 고려하여 출력층에서 예측 시에 두 가지 정보를 모두 사용합니다. 위 그림은 다 대다(many-to-many) 문제를 푸는 경우의 양방향 LSTM을 보여주고 있습니다. 그런데 양방향 LSTM을 다 대 일(many-to-one) 문제인 텍스트 분류 문제에 사용한다고 하면, 한 가지 의문이 생깁니다. 일반적으로 순방향 LSTM은 마지막 시점의 은닉 상태를 출력층으로 보내서 텍스트 분류를 수행합니다. 그렇다면 역방향 LSTM도 순방향과 같은 시점의 은닉 상태를 사용하면 될까요? 위 그림과 같이 텍스트 분류를 진행하는 경우, 역방향 LSTM은 4 만 본 상태입니다. 이 경우 역방향 LSTM이 텍스트 분류를 위한 유용한 정보를 갖고 있다고 기대하기 어렵습니다. 그래서 케라스에서는 양방향 LSTM을 사용하면서 return_sequences=False를 택할 경우에는 위의 그림과 같이 동작하고 있습니다. 순방향 LSTM의 경우에는 마지막 시점의 은닉 상태를 반환하고, 역방향 LSTM의 경우에는 첫 번째 시점의 은닉 상태를 반환합니다. 위 구조를 통해서 양방향 LSTM으로 텍스트 분류를 수행할 수 있습니다. 2. Colab에 Mecab 설치 여기서는 형태소 분석기 Mecab을 사용합니다. 저자의 경우 Mecab을 편하게 사용하기 위해서 구글의 Colab을 사용하였습니다. 참고로 Colab에서 실습하는 경우가 아니라면 아래의 방법으로 Mecab이 설치되지 않습니다. 이 경우 해당 환경에 맞게 Mecab을 설치하시거나 다른 형태소 분석기를 사용하시기 바랍니다. # Colab에 Mecab 설치 !git clone https://github.com/SOMJANG/Mecab-ko-for-Google-Colab.git %cd Mecab-ko-for-Google-Colab !bash install_mecab-ko_on_colab190912.sh 3. 스팀 리뷰 데이터에 대한 이해와 전처리 다운로드 링크 : https://github.com/bab2min/corpus/tree/master/sentiment import pandas as pd import numpy as np import matplotlib.pyplot as plt import urllib.request from collections import Counter from konlpy.tag import Mecab from sklearn.model_selection import train_test_split from tensorflow.keras.preprocessing.text import Tokenizer from tensorflow.keras.preprocessing.sequence import pad_sequences 1) 데이터 로드하기 urllib.request.urlretrieve("https://raw.githubusercontent.com/bab2min/corpus/master/sentiment/steam.txt", filename="steam.txt") 해당 데이터에는 열제목이 별도로 없습니다. 그래서 임의로 두 개의 열제목인 'label'과 'reviews'를 추가해 주겠습니다. total_data = pd.read_table('steam.txt', names=['label', 'reviews']) print('전체 리뷰 개수 :',len(total_data)) # 전체 리뷰 개수 출력 전체 리뷰 개수 : 100000 총 10만 개의 샘플이 존재합니다. 상위 5개의 샘플만 출력해 봅시다. total_data[:5] 각 열에 대해서 중복을 제외한 샘플의 수를 카운트합니다. total_data['reviews'].nunique(), total_data['label'].nunique() (99892, 2) reviews 열에서 중복을 제외한 경우 99,892개입니다. 현재 10만 개의 리뷰가 존재하므로 이는 현재 갖고 있는 데이터에 중복인 샘플들이 있다는 의미입니다. 중복인 샘플들을 제거해 줍니다. total_data.drop_duplicates(subset=['reviews'], inplace=True) # reviews 열에서 중복인 내용이 있다면 중복 제거 print('총 샘플의 수 :',len(total_data)) 총 샘플의 수 : 99892 NULL 값 유무를 확인합니다. print(total_data.isnull().values.any()) False 2) 훈련 데이터와 테스트 데이터 분리하기 훈련 데이터와 테스트 데이터를 3:1 비율로 분리합니다. train_data, test_data = train_test_split(total_data, test_size = 0.25, random_state = 42) print('훈련용 리뷰의 개수 :', len(train_data)) print('테스트용 리뷰의 개수 :', len(test_data)) 훈련용 리뷰의 개수 : 74919 테스트용 리뷰의 개수 : 24973 훈련용 리뷰의 경우 약 7만 5,000개. 테스트용 리뷰의 경우 약 2만 5,000개가 존재합니다. 3) 레이블의 분포 확인 훈련 데이터의 레이블의 분포를 확인해 봅시다. train_data['label'].value_counts().plot(kind = 'bar') print(train_data.groupby('label').size().reset_index(name = 'count')) label count 0 0 37376 1 1 37543 두 레이블 모두 약 3만 7천 개로 50:50 비율을 가지고 있습니다. 4) 데이터 정제하기 정규 표현식을 사용하여 한글을 제외하고 모두 제거해 줍니다. 또한 혹시 이 과정에서 빈 샘플이 생기지는 않는지 확인합니다. # 한글과 공백을 제외하고 모두 제거 train_data['reviews'] = train_data['reviews'].str.replace("[^ㄱ-ㅎㅏ-ㅣ가-힣 ]","") train_data['reviews'].replace('', np.nan, inplace=True) print(train_data.isnull().sum()) label 0 reviews 0 dtype: int64 테스트 데이터에 대해서도 같은 과정을 거칩니다. test_data.drop_duplicates(subset = ['reviews'], inplace=True) # 중복 제거 test_data['reviews'] = test_data['reviews'].str.replace("[^ㄱ-ㅎㅏ-ㅣ가-힣 ]","") # 정규 표현식 수행 test_data['reviews'].replace('', np.nan, inplace=True) # 공백은 Null 값으로 변경 test_data = test_data.dropna(how='any') # Null 값 제거 print('전처리 후 테스트용 샘플의 개수 :',len(test_data)) 불용어를 정의해 줍니다. stopwords = ['도', '는', '다', '의', '가', '이', '은', '한', '에', '하', '고', '을', '를', '인', '듯', '과', '와', '네', '들', '듯', '지', '임', '게', '만', '게임', '게임', '되', '음', '면'] 5) 토큰화 형태소 분석기 Mecab을 사용하여 토큰화 작업을 수행합니다. mecab = Mecab() train_data['tokenized'] = train_data['reviews'].apply(mecab.morphs) train_data['tokenized'] = train_data['tokenized'].apply(lambda x: [item for item in x if item not in stopwords]) test_data['tokenized'] = test_data['reviews'].apply(mecab.morphs) test_data['tokenized'] = test_data['tokenized'].apply(lambda x: [item for item in x if item not in stopwords]) 6) 단어와 길이 분포 확인하기 긍정 리뷰에는 주로 어떤 단어들이 많이 등장하고, 부정 리뷰에는 주로 어떤 단어들이 등장하는지 두 가지 경우에 대해서 각 단어의 빈도수를 계산해 보겠습니다. 각 레이블에 따라서 별도로 단어들의 리스트를 저장해 줍니다. negative_words = np.hstack(train_data[train_data.label == 0]['tokenized'].values) positive_words = np.hstack(train_data[train_data.label == 1]['tokenized'].values) Counter()를 사용하여 각 단어에 대한 빈도수를 카운트합니다. 우선 부정 리뷰에 대해서 빈도수가 높은 상위 20개 단어들을 출력합니다. negative_word_count = Counter(negative_words) print(negative_word_count.most_common(20)) [('안', 8129), ('없', 7141), ('는데', 5786), ('있', 5692), ('같', 4247), ('로', 4083), ('할', 3920), ('거', 3902), ('나', 3805), ('해', 3653), ('너무', 3522), ('으로', 3351), ('기', 3348), ('했', 3265), ('어', 3143), ('보', 2987), ('습니다', 2962), ('것', 2935), ('지만', 2911), ('좋', 2899)] 긍정 리뷰에 대해서도 동일하게 출력해 봅시다. positive_word_count = Counter(positive_words) print(positive_word_count.most_common(20)) [('있', 9987), ('좋', 6542), ('습니다', 5179), ('재밌', 4997), ('할', 4838), ('지만', 4809), ('해', 4354), ('없', 4145), ('보', 3907), ('으로', 3900), ('로', 3879), ('수', 3835), ('는데', 3825), ('기', 3592), ('안', 3368), ('것', 3362), ('같', 3356), ('네요', 3189), ('어', 3112), ('나', 3055)] 두 가지 경우에 대해서 각각 길이 분포를 확인해 봅시다. fig,(ax1, ax2) = plt.subplots(1,2, figsize=(10,5)) text_len = train_data[train_data['label']==1]['tokenized'].map(lambda x: len(x)) ax1.hist(text_len, color='red') ax1.set_title('Positive Reviews') ax1.set_xlabel('length of samples') ax1.set_ylabel('number of samples') print('긍정 리뷰의 평균 길이 :', np.mean(text_len)) text_len = train_data[train_data['label']==0]['tokenized'].map(lambda x: len(x)) ax2.hist(text_len, color='blue') ax2.set_title('Negative Reviews') fig.suptitle('Words in texts') ax2.set_xlabel('length of samples') ax2.set_ylabel('number of samples') print('부정 리뷰의 평균 길이 :', np.mean(text_len)) plt.show() 긍정 리뷰의 평균 길이 : 14.948459100231734 부정 리뷰의 평균 길이 : 15.284193065068493 유의미한 차이가 있는 것 같지는 않습니다. X_train = train_data['tokenized'].values y_train = train_data['label'].values X_test= test_data['tokenized'].values y_test = test_data['label'].values 7) 정수 인코딩 기계가 텍스트를 숫자로 처리할 수 있도록 훈련 데이터와 테스트 데이터에 정수 인코딩을 수행해야 합니다. 우선, 훈련 데이터에 대해서 단어 집합(vocaburary)을 만들어봅시다. tokenizer = Tokenizer() tokenizer.fit_on_texts(X_train) 단어 집합이 생성되는 동시에 각 단어에 고유한 정수가 부여되었습니다. 이는 tokenizer.word_index를 출력하여 확인 가능합니다. 등장 횟수가 1회인 단어들은 자연어 처리에서 배제하고자 합니다. 이 단어들이 이 데이터에서 얼마큼의 비중을 차지하는지 확인해 봅시다. threshold = 2 total_cnt = len(tokenizer.word_index) # 단어의 수 rare_cnt = 0 # 등장 빈도수가 threshold보다 작은 단어의 개수를 카운트 total_freq = 0 # 훈련 데이터의 전체 단어 빈도수 총합 rare_freq = 0 # 등장 빈도수가 threshold보다 작은 단어의 등장 빈도수의 총합 # 단어와 빈도수의 쌍(pair)을 key와 value로 받는다. for key, value in tokenizer.word_counts.items(): total_freq = total_freq + value # 단어의 등장 빈도수가 threshold보다 작으면 if(value < threshold): rare_cnt = rare_cnt + 1 rare_freq = rare_freq + value print('단어 집합(vocabulary)의 크기 :',total_cnt) print('등장 빈도가 %s 번 이하인 희귀 단어의 수: %s'%(threshold - 1, rare_cnt)) print("단어 집합에서 희귀 단어의 비율:", (rare_cnt / total_cnt)*100) print("전체 등장 빈도에서 희귀 단어 등장 빈도 비율:", (rare_freq / total_freq)*100) 단어 집합(vocabulary)의 크기 : 32817 등장 빈도가 1번 이하인 희귀 단어의 수: 13878 단어 집합에서 희귀 단어의 비율: 42.28905750068562 전체 등장 빈도에서 희귀 단어 등장 빈도 비율: 1.2254607619437832 단어가 약 32,000개가 존재합니다. 등장 빈도가 threshold 값인 2회 미만. 즉, 1회인 단어들은 단어 집합에서 약 42%를 차지합니다. 하지만, 실제로 훈련 데이터에서 등장 빈도로 차지하는 비중은 매우 적은 수치인 약 1.2%밖에 되지 않습니다. 아무래도 등장 빈도가 1회인 단어들은 자연어 처리에서 별로 중요하지 않을 듯합니다. 그래서 이 단어들은 정수 인코딩 과정에서 배제시키겠습니다. 등장 빈도수가 1인 단어들의 수를 제외한 단어의 개수를 단어 집합의 최대 크기로 제한하겠습니다. # 전체 단어 개수 중 빈도수 2이하인 단어 개수는 제거. # 0번 패딩 토큰과 1번 OOV 토큰을 고려하여 +2 vocab_size = total_cnt - rare_cnt + 2 print('단어 집합의 크기 :',vocab_size) 단어 집합의 크기 : 18941 단어 집합의 크기는 18,941개입니다. 이를 토크 나이저의 인자로 넘겨주면, 토크 나이저는 텍스트 시퀀스를 숫자 시퀀스로 변환합니다. 이러한 정수 인코딩 과정에서 이보다 큰 숫자가 부여된 단어들은 OOV로 변환하겠습니다. tokenizer = Tokenizer(vocab_size, oov_token = 'OOV') tokenizer.fit_on_texts(X_train) X_train = tokenizer.texts_to_sequences(X_train) X_test = tokenizer.texts_to_sequences(X_test) 정수 인코딩이 진행되었는지 확인하고자 X_train과 X_test에 대해서 상위 3개의 샘플만 출력합니다. print(X_train[:3]) [[495, 7, 35, 87, 149, 2429, 599, 26, 8, 70, 47, 235, 111, 38, 44, 52], [161, 300, 18, 20, 63, 3582, 985, 6, 56], [7, 17, 1476, 4]] print(X_test[:3]) [[728, 34, 16, 431, 52, 106, 132, 99, 6461, 453], [4527, 687, 835, 712, 792, 108, 4, 1779, 95, 370, 3518, 81, 558, 1904, 4189, 262, 169, 61, 25, 363, 35, 87, 974, 19, 6294, 6422], [1792, 806, 685, 49, 23, 349]] 8) 패딩 서로 다른 길이의 샘플들의 길이를 동일하게 맞춰주는 패딩 작업을 진행해 보겠습니다. 전체 데이터에서 가장 길이가 긴 리뷰와 전체 데이터의 길이 분포를 알아보겠습니다. print('리뷰의 최대 길이 :',max(len(review) for review in X_train)) print('리뷰의 평균 길이 :',sum(map(len, X_train))/len(X_train)) plt.hist([len(review) for review in X_train], bins=50) plt.xlabel('length of samples') plt.ylabel('number of samples') plt.show() 리뷰의 최대 길이 : 64 리뷰의 평균 길이 : 15.115951894712957 리뷰의 최대 길이는 64, 평균 길이는 약 15입니다. 그래프로 봤을 때, 전체적으로는 60이하의 길이를 가지는 것으로 보입니다. def below_threshold_len(max_len, nested_list): count = 0 for sentence in nested_list: if(len(sentence) <= max_len): count = count + 1 print('전체 샘플 중 길이가 %s 이하인 샘플의 비율: %s'%(max_len, (count / len(nested_list))*100)) 최대 길이가 64이므로 만약 60으로 패딩 할 경우, 몇 개의 샘플들을 온전히 보전할 수 있는지 확인합니다. max_len = 60 below_threshold_len(max_len, X_train) 전체 샘플 중 길이가 60 이하인 샘플의 비율: 99.99599567532935 훈련용 리뷰의 99.99%가 60이하의 길이를 가집니다. 훈련용 리뷰를 길이 60으로 패딩 하겠습니다. X_train = pad_sequences(X_train, maxlen=max_len) X_test = pad_sequences(X_test, maxlen=max_len) 4. BiLSTM으로 스팀 리뷰 감성 분류하기 하이퍼 파라미터, EarlyStopping과 ModelCheckpoint와 같은 모델에 대한 상세 코드는 네이버 영화 리뷰 분류와 네이버 쇼핑 리뷰 분류 때와 크게 다르지 않습니다. 하지만 이번에는 양방향 LSTM을 사용했다는 점에서 앞선 실습들과 차이를 보입니다. LSTM이 Bidirectional( ) 안에 기재되었다는 사실에 주목합시다. import re from tensorflow.keras.layers import Embedding, Dense, LSTM, Bidirectional from tensorflow.keras.models import Sequential from tensorflow.keras.models import load_model from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint embedding_dim = 100 hidden_units = 128 model = Sequential() model.add(Embedding(vocab_size, embedding_dim)) model.add(Bidirectional(LSTM(hidden_units))) # Bidirectional LSTM을 사용 model.add(Dense(1, activation='sigmoid')) es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=4) mc = ModelCheckpoint('best_model.h5', monitor='val_acc', mode='max', verbose=1, save_best_only=True) model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc']) history = model.fit(X_train, y_train, epochs=15, callbacks=[es, mc], batch_size=256, validation_split=0.2) 저자의 경우 에포크 7에서 조기 종료가 발생했습니다. loaded_model = load_model('best_model.h5') print("테스트 정확도: %.4f" % (loaded_model.evaluate(X_test, y_test)[1])) 781/781 [==============================] - 3s 4ms/step - loss: 0.4534 - acc: 0.7893 테스트 정확도: 0.7893 5. 리뷰 예측해 보기 임의의 문장에 대한 예측을 위해서는 학습하기 전 전처리를 동일하게 적용해 줍니다. def sentiment_predict(new_sentence): new_sentence = re.sub(r'[^ㄱ-ㅎㅏ-ㅣ가-힣 ]','', new_sentence) new_sentence = mecab.morphs(new_sentence) # 토큰화 new_sentence = [word for word in new_sentence if not word in stopwords] # 불용어 제거 encoded = tokenizer.texts_to_sequences([new_sentence]) # 정수 인코딩 pad_new = pad_sequences(encoded, maxlen = max_len) # 패딩 score = float(loaded_model.predict(pad_new)) # 예측 if(score > 0.5): print("{:.2f}% 확률로 긍정 리뷰입니다.".format(score * 100)) else: print("{:.2f}% 확률로 부정 리뷰입니다.".format((1 - score) * 100)) sentiment_predict('노잼 .. 완전 재미없음 ㅉㅉ') 93.66% 확률로 부정 리뷰입니다. sentiment_predict('조금 어렵지만 재밌음ㅋㅋ') 97.43% 확률로 긍정 리뷰입니다. sentiment_predict('캐릭터가 예뻐서 좋아요') 92.49% 확률로 긍정 리뷰입니다. 11. NLP를 위한 합성곱 신경망(Convolution Neural Network) 합성곱 신경망은 주로 이미지 처리. 즉, 비전 분야에서 사용되는 알고리즘이지만 이를 응용해서 자연어 처리에 사용하기 위한 시도들이 있었습니다. 이번 챕터에서는 비전 분야에서 사용되는 합성곱 신경망의 동작 방식에 대해서 이해하고, 이 개념을 확장하여 자연어 처리를 위한 1D 합성곱 신경망을 이해합니다. 그리고 앞서 RNN으로 텍스트 분류를 수행했던 데이터들을 가지고 합성곱 신경망을 통해서 분류 문제를 풀어봅니다. 추가적으로 합성곱 신경망을 이용하여 문자 임베딩(Character Embedding)을 얻는 방법에 대해서 설명합니다. 11-01 합성곱 신경망(Convolution Neural Network) 합성곱 신경망(Convolutional Neural Network)은 이미지 처리에 탁월한 성능을 보이는 신경망입니다. 하지만 합성곱 신경망으로 텍스트 처리를 하기 위한 시도들이 있었고, 이번 챕터는 합성곱 신경망으로 어떻게 텍스트를 처리하는지에 대해서 설명하기 위해 편성한 챕터입니다. 하지만 합성곱 신경망을 좀 더 정확하게 이해하기 위해 합성곱 신경망의 주요 목적인 이미지 처리에서의 합성곱 신경망부터 먼저 설명하겠습니다. 합성곱 신경망은 크게 합성곱층과(Convolution layer)와 풀링층(Pooling layer)으로 구성됩니다. 아래의 그림은 합성곱 신경망의 일반적인 예를 보여줍니다. (http://cs231n.github.io/convolutional-networks) 위 그림에서 CONV는 합성곱 연산을 의미하고, 합성곱 연산의 결과가 활성화 함수 ReLU를 지납니다. 이 두 과정을 합성곱층이라고 합니다. 그 후에 POOL이라는 구간을 지나는데 이는 풀링 연산을 의미하며 풀링층이라고 합니다. 이제부터 합성곱 연산과 풀링 연산의 의미에 대해서 학습해 봅시다. 1. 합성곱 신경망의 대두 합성곱 신경망은 이미지 처리에 탁월한 성능을 보이는 신경망입니다. 이미지 처리를 하기 위해서 앞서 배운 다층 퍼셉트론을 사용할 수는 있지만 한계가 있었습니다. 예를 들어, 알파벳 손글씨를 분류하는 어떤 문제가 있다고 해봅시다. 아래의 그림은 알파벳 Y를 비교적 정자로 쓴 손글씨와 다소 휘갈겨 쓴 손글씨 두 개를 2차원 텐서인 행렬로 표현한 것입니다. 사람이 보기에는 두 그림 모두 알파벳 Y로 손쉽게 판단이 가능하지만, 기계가 보기에는 각 픽셀마다 가진 값이 대부분 상이하므로 사실상 다른 값을 가진 입력입니다. 그런데 이미지라는 것은 위와 같이 같은 대상이라도 휘어지거나, 이동되었거나, 방향이 뒤틀렸거나 등 다양한 변형이 존재합니다. 다층 퍼셉트론은 몇 가지 픽셀만 값이 달라져도 민감하게 예측에 영향을 받는다는 단점이 있습니다. 좀 더 구체적으로 보겠습니다. 위 손글씨를 다층 퍼셉트론으로 분류한다고 하면, 이미지를 1차원 텐서인 벡터로 변환하고 다층 퍼셉트론의 입력층으로 사용해야 합니다. 두 번째 손글씨를 다층 퍼셉트론으로 분류하기 위해서 벡터로 바꾸면 다음과 같습니다. 1차원으로 변환된 결과는 사람이 보기에도 이게 원래 어떤 이미지였는지 알아보기가 어렵습니다. 이는 기계도 마찬가지입니다. 위와 같이 결과는 변환 전에 가지고 있던 공간적인 구조(spatial structure) 정보가 유실된 상태입니다. 여기서 공간적인 구조 정보라는 것은 거리가 가까운 어떤 픽셀들끼리는 어떤 연관이 있고, 어떤 픽셀들끼리는 값이 비슷하거나 등을 포함하고 있습니다. 결국 이미지의 공간적인 구조 정보를 보존하면서 학습할 수 있는 방법이 필요해졌고, 이를 위해 합성곱 신경망을 사용합니다. 2. 채널(Channel) 이미지 처리의 기본적인 용어인 채널에 대해서 간단히 정의하겠습니다. 기계는 글자나 이미지보다 숫자. 다시 말해, 텐서를 더 잘 처리할 수 있습니다. 이미지는 (높이, 너비, 채널)이라는 3차원 텐서입니다. 여기서 높이는 이미지의 세로 방향 픽셀 수, 너비는 이미지의 가로 방향 픽셀 수, 채널은 색 성분을 의미합니다. 흑백 이미지는 채널 수가 1이며, 각 픽셀은 0부터 255 사이의 값을 가집니다. 아래는 28 × 28 픽셀의 손글씨 데이터를 보여줍니다. 위 손글씨 데이터는 흑백 이미지므로 채널 수가 1임을 고려하면 (28 × 28 × 1)의 크기를 가지는 3차원 텐서입니다. 그렇다면 흑백이 아니라 우리가 통상적으로 접하게 되는 컬러 이미지는 어떨까요? 컬러 이미지는 적색(Red), 녹색(Green), 청색(Blue) 채널 수가 3개입니다. 하나의 픽셀은 세 가지 색깔, 삼원색의 조합으로 이루어집니다. 만약, 높이가 28, 너비가 28인 컬러 이미지가 있다면 이 이미지의 텐서는 (28 × 28 × 3)의 크기를 가지는 3차원 텐서입니다. 채널은 때로는 깊이(depth)라고도 합니다. 이 경우 이미지는 (높이, 너비, 깊이)라는 3차원 텐서로 표현된다고 말할 수 있을 겁니다. 3. 합성곱 연산(Convolution operation) 합성곱층은 합성곱 연산을 통해서 이미지의 특징을 추출하는 역할을 합니다. 우선, 합성곱 연산에 대해서 이해해 봅시다. 합성 곱은 영어로 컨볼루션이라고도 불리는데, 커널(kernel) 또는 필터(filter)라는 × 크기의 행렬로 높이 너비 높이 ( e g t ) 너비 ( i t 크기의 이미지를 처음부터 끝까지 겹치며 훑으면서 × 크기의 겹쳐지는 부분의 각 이미지와 커널의 원소의 값을 곱해서 모두 더한 값을 출력으로 하는 것을 말합니다. 이때, 이미지의 가장 왼쪽 위부터 가장 오른쪽 아래까지 순차적으로 훑습니다. 커널(kernel)은 일반적으로 3 × 3 또는 5 × 5를 사용합니다. 예를 통해 이해해 봅시다. 아래는 × 크기의 커널로 ×의 이미지 행렬에 합성곱 연산을 수행하는 과정을 보여줍니다. 한 번의 연산을 1 스텝(step)이라고 하였을 때, 합성곱 연산의 네 번째 스텝까지 이미지와 식으로 표현해 봤습니다. 1. 첫 번째 스텝 (1×1) + (2×0) + (3×1) + (2×1) + (1×0) + (0×1) + (3×0) + (0×1) + (1×0) = 6 2. 두 번째 스텝 (2×1) + (3×0) + (4×1) + (1×1) + (0×0) + (1×1) + (0×0) + (1×1) + (1×0) = 9 3. 세 번째 스텝 (3×1) + (4×0) + (5×1) + (0×1) + (1×0) + (2×1) + (1×0) + (1×1) + (0×0) = 11 4. 네 번째 스텝 (2×1) + (1×0) + (0×1) + (3×1) + (0×0) + (1×1) + (1×0) + (4×1) + (1×0) = 10 위 연산을 총 9번의 스텝까지 마쳤다고 가정하였을 때, 최종 결과는 아래와 같습니다. 위와 같이 입력으로부터 커널을 사용하여 합성곱 연산을 통해 나온 결과를 특성 맵(feature map)이라고 합니다. 위의 예제에서는 커널의 크기가 3 × 3이었지만, 커널의 크기는 사용자가 정할 수 있습니다. 또한 커널의 이동 범위가 위의 예제에서는 한 칸이었지만, 이 또한 사용자가 정할 수 있습니다. 이러한 이동 범위를 스트라이드(stride)라고 합니다. 아래의 예제는 스트라이드가 2일 경우에 5 × 5 이미지에 합성곱 연산을 수행하는 3 × 3 커널의 움직임을 보여줍니다. 최종적으로 2 × 2의 크기의 특성 맵을 얻습니다. 4. 패딩(Padding) 위의 예에서 5 × 5 이미지에 3 × 3의 커널로 합성곱 연산을 하였을 때, 스트라이드가 1일 경우에는 3 × 3의 특성 맵을 얻었습니다. 이와 같이 합성곱 연산의 결과로 얻은 특성 맵은 입력보다 크기가 작아진다는 특징이 있습니다. 만약, 합성곱 층을 여러 개 쌓았다면 최종적으로 얻은 특성 맵은 초기 입력보다 매우 작아진 상태가 돼버립니다. 합성곱 연산 이후에도 특성 맵의 크기가 입력의 크기와 동일하게 유지되도록 하고 싶다면 패딩(padding)을 사용하면 됩니다. 패딩은 (합성곱 연산을 하기 전에) 입력의 가장자리에 지정된 개수의 폭만큼 행과 열을 추가해 주는 것을 말합니다. 좀 더 쉽게 설명하면 지정된 개수의 폭만큼 테두리를 추가합니다. 주로 값을 0으로 채우는 제로 패딩(zero padding)을 사용합니다. 위의 그림은 5 × 5 이미지에 1폭짜리 제로 패딩을 사용하여 위, 아래에 하나의 행을 좌, 우에 하나의 열을 추가한 모습을 보여줍니다. 커널은 주로 3 × 3 또는 5 × 5를 사용한다고 언급한 바 있습니다. 만약 스트라이드가 1이라고 하였을 때, 3 × 3 크기의 커널을 사용한다면 1폭짜리 제로 패딩을 사용하고, 5 × 5 크기의 커널을 사용한다면 2폭짜리 제로 패딩을 사용하면 입력과 특성 맵의 크기를 보존할 수 있습니다. 예를 들어 5 × 5 크기의 이미지에 1폭짜리 제로 패딩을 하면 7 × 7 이미지가 되는데, 여기에 3 × 3의 커널을 사용하여 1 스트라이드로 합성 곱을 한 후의 특성 맵은 기존의 입력 이미지의 크기와 같은 5 × 5가 됩니다. 5. 가중치와 편향 합성곱 신경망에서의 가중치와 편향을 이해하기 위해서 우선 다층 퍼셉트론을 복습해 보겠습니다. 1. 합성곱 신경망의 가중치 다층 퍼셉트론으로 3 × 3 이미지를 처리한다고 가정해 보겠습니다. 우선 이미지를 1차원 텐서인 벡터로 만들면, 3 × 3 = 9가 되므로 입력층은 9개의 뉴런을 가집니다. 그리고 4개의 뉴런을 가지는 은닉층을 추가한다고 해보겠습니다. 이는 아래의 그림과 같습니다. 위에서 각 연결선은 가중치를 의미하므로, 위의 그림에서는 9 × 4 = 36개의 가중치를 가집니다. 비교를 위해 합성곱 신경망으로 3 × 3 이미지를 처리한다고 해보겠습니다. 2 × 2 커널을 사용하고, 스트라이드는 1로 합니다. (*는 합성곱 연산을 의미합니다.) 사실 합성곱 신경망에서 가중치는 커널 행렬의 원소들입니다. 이를 인공 신경망의 형태로 표현한다면 다음과 같이 표현할 수 있습니다. 최종적으로 특성 맵을 얻기 위해서는 동일한 커널로 이미지 전체를 훑으며 합성곱 연산을 진행합니다. 결국 이미지 전체를 훑으면서 사용되는 가중치는 0 w, 2 w 4개뿐입니다. 그리고 각 합성곱 연산마다 이미지의 모든 픽셀을 사용하는 것이 아니라, 커널과 매핑되는 픽셀만을 입력으로 사용하는 것을 볼 수 있습니다. 결국 합성곱 신경망은 다층 퍼셉트론을 사용할 때보다 훨씬 적은 수의 가중치를 사용하며 공간적 구조 정보를 보존한다는 특징이 있습니다. 다층 퍼셉트론의 은닉층에서는 가중치 연산 후에 비선형성을 추가하기 위해서 활성화 함수를 통과시켰습니다. 합성곱 신경망의 은닉층에서도 마찬가지입니다. 합성곱 연산을 통해 얻은 특성 맵은 다층 퍼셉트론 때와 마찬가지로 비선형성 추가를 위해서 활성화 함수를 지나게 됩니다. 이때 렐루 함수나 렐루 함수의 변형들이 주로 사용됩니다. 이와 같이 합성곱 연산을 통해서 특성 맵을 얻고, 활성화 함수를 지나는 연산을 하는 합성곱 신경망의 층을 합성곱 신경망에서는 합성곱 층(convolution layer)이라고 합니다. 2. 합성곱 신경망의 편향 합성곱 신경망에도 편향(bias)를 당연히 추가할 수 있습니다. 만약, 편향을 사용한다면 커널을 적용한 뒤에 더해집니다. 편향은 하나의 값만 존재하며, 커널이 적용된 결과의 모든 원소에 더해집니다. 6. 특성 맵의 크기 계산 방법 입력의 크기와 커널의 크기, 그리고 스트라이드의 값만 알면 합성곱 연산의 결과인 특성 맵의 크기를 계산할 수 있습니다. h : 입력의 높이 w : 입력의 너비 h : 커널의 높이 w : 커널의 너비 : 스트라이드 h : 특성 맵의 높이 w : 특성 맵의 너비 이에 따라 특성 맵의 높이와 너비는 다음과 같습니다. h f o r ( h K S 1 ) w f o r ( w K S 1 ) 여기서 l o 함수는 소수점 발생 시 소수점 이하를 버리는 역할을 합니다. 예를 들어 위의 첫 번째 예제의 경우 5 × 5 크기의 이미지에 3 × 3 커널을 사용하고 스트라이드 1로 합성곱 연산을 했습니다. 이 경우 특성 맵의 크기는 (5 - 3 + 1 ) × (5 - 3 + 1) = 3 × 3임을 알 수 있습니다. 이는 또한 총 9번의 스텝이 필요함을 의미하기도 합니다. 패딩의 폭을 라고 하고, 패딩까지 고려한 식은 다음과 같습니다. h f o r ( h K + P + ) w f o r ( w K + P + ) 7. 다수의 채널을 가질 경우의 합성곱 연산(3차원 텐서의 합성곱 연산) 지금까지는 채널(channel) 또는 깊이(depth)를 고려하지 않고, 2차원 텐서를 가정하고 설명했습니다. 하지만 실제로 합성곱 연산의 입력은 '다수의 채널을 가진' 이미지 또는 이전 연산의 결과로 나온 특성 맵일 수 있습니다. 만약, 다수의 채널을 가진 입력 데이터를 가지고 합성곱 연산을 한다고 하면 커널의 채널 수도 입력의 채널 수만큼 존재해야 합니다. 다시 말해 입력 데이터의 채널 수와 커널의 채널 수는 같아야 합니다. 채널 수가 같으므로 합성곱 연산을 채널마다 수행합니다. 그리고 그 결과를 모두 더하여 최종 특성 맵을 얻습니다. 위 그림은 3개의 채널을 가진 입력 데이터와 3개의 채널을 가진 커널의 합성곱 연산을 보여줍니다. 커널의 각 채널끼리의 크기는 같아야 합니다. 각 채널 간 합성곱 연산을 마치고, 그 결과를 모두 더해서 하나의 채널을 가지는 특성 맵을 만듭니다. 주의할 점은 위의 연산에서 사용되는 커널은 3개의 커널이 아니라 3개의 채널을 가진 1개의 커널이라는 점입니다. 위 그림은 높이 3, 너비 3, 채널 3의 입력이 높이 2, 너비 2, 채널 3의 커널과 합성곱 연산을 하여 높이 2, 너비 2, 채널 1의 특성 맵을 얻는다는 의미입니다. 합성곱 연산의 결과로 얻은 특성 맵의 채널 차원은 RGB 채널 등과 같은 컬러의 의미를 담고 있지는 않습니다. 이 연산에서 각 차원을 변수로 두고 좀 더 일반화시켜보겠습니다. 8. 3차원 텐서의 합성곱 연산 일반화를 위해 사용하는 각 변수가 의미하는 바는 다음과 같습니다. h : 입력의 높이 w : 입력의 너비 h : 커널의 높이 w : 커널의 너비 h : 특성 맵의 높이 w : 특성 맵의 너비 i : 입력 데이터의 채널 다음은 3차원 텐서의 합성곱 연산을 보여줍니다. 높이 h , 너비 w , 채널 i 의 입력 데이터는 동일한 채널 수 i 를 가지는 높이 h , 너비 w 의 커널과 합성곱 연산을 하여 높이 h , 너비 w , 채널 1의 특성 맵을 얻습니다. 그런데 하나의 입력에 여러 개의 커널을 사용하는 합성곱 연산을 할 수도 있습니다. 합성곱 연산에서 다수의 커널을 사용할 경우, 특성 맵의 크기가 어떻게 바뀌는지 봅시다. 다음은 o 를 합성곱 연산에 사용하는 커널의 수라고 하였을 때의 합성곱 연산 과정을 보여줍니다. 합성곱 연산에서 다수의 커널을 사용할 경우, 사용한 커널 수는 합성곱 연산의 결과로 나오는 특성 맵의 채널 수가 됩니다. 이를 이해했다면 커널의 크기와 입력 데이터의 채널 수 i 와 특성 맵(출력 데이터)의 채널 수 o 가 주어졌을 때, 가중치 매개변수의 총개수를 구할 수 있습니다. 가중치는 커널의 원소들이므로 하나의 커널의 하나의 채널은 i K 개의 매개변수를 가지고 있습니다. 그런데 합성곱 연산을 하려면 커널은 입력 데이터의 채널 수와 동일한 채널 수를 가져야 합니다. 이에 따라 하나의 커널이 가지는 매개변수의 수는 i K × i 입니다. 그런데 이러한 커널이 총 o 개가 있어야 하므로 가중치 매개변수의 총 수는 다음과 같습니다. 가중치 매개변수의 총 수 : i K × i C 9. 풀링(Pooling) 일반적으로 합성곱 층(합성곱 연산 + 활성화 함수) 다음에는 풀링 층을 추가하는 것이 일반적입니다. 풀링 층에서는 특성 맵을 다운 샘플링하여 특성 맵의 크기를 줄이는 풀링 연산이 이루어집니다. 풀링 연산에는 일반적으로 최대 풀링(max pooling)과 평균 풀링(average pooling)이 사용됩니다. 우선 최대 풀링을 통해서 풀링 연산을 이해해 봅시다. 풀링 연산에서도 합성곱 연산과 마찬가지로 커널과 스트라이드의 개념을 가집니다. 위의 그림은 스트라이드가 2일 때, 2 × 2 크기 커널로 맥스 풀링 연산을 했을 때 특성 맵이 절반의 크기로 다운 샘플링되는 것을 보여줍니다. 맥스 풀링은 커널과 겹치는 영역 안에서 최댓값을 추출하는 방식으로 다운 샘플링합니다. 다른 풀링 기법인 평균 풀링은 최댓값을 추출하는 것이 아니라 평균값을 추출하는 연산이 됩니다. 풀링 연산은 커널과 스트라이드 개념이 존재한다는 점에서 합성곱 연산과 유사하지만, 합성곱 연산과의 차이점은 학습해야 할 가중치가 없으며 연산 후에 채널 수가 변하지 않는다는 점입니다. 11-02 자연어 처리를 위한 1D CNN(1D Convolutional Neural Networks) 합성곱 신경망을 자연어 처리에서 사용하기 위한 1D CNN을 이해해 보겠습니다. 1. 2D 합성곱(2D Convolutions) 앞서 합성곱 신경망을 설명하며 합성곱 연산을 다음과 같이 정의했습니다. 합성곱 연산이란 커널(kernel) 또는 필터(filter)라는 n × m 크기의 행렬로 높이(height) × 너비(width) 크기의 이미지를 처음부터 끝까지 겹치며 훑으면서 n × m 크기의 겹쳐지는 부분의 각 이미지와 커널의 원소의 값을 곱해서 모두 더한 값을 출력으로 하는 것을 말합니다. 이때, 이미지의 가장 왼쪽 위부터 가장 오른쪽 아래까지 순차적으로 훑습니다. 위와 같은 이미지 처리에서의 합성곱 연산을 2D 합성곱 연산이라고 부릅니다. 2. 1D 합성곱(1D Convolutions) 자연어 처리에 사용되는 1D 합성곱 연산을 정리해 봅시다. LSTM을 이용한 여러 실습을 상기해 보면, 각 문장은 임베딩 층(embedding layer)을 지나서 각 단어가 임베딩 벡터가 된 상태로 LSTM의 입력이 되었습니다. 이는 1D 합성곱 연산에서도 마찬가지입니다. 1D 합성곱 연산에서도 입력이 되는 것은 각 단어가 벡터로 변환된 문장 행렬로 LSTM과 입력을 받는 형태는 동일합니다. 'wait for the video and don't rent it'이라는 문장이 있을 때, 이 문장이 토큰화, 패딩, 임베딩 층(Embedding layer)을 거친다면 다음과 같은 문장 형태의 행렬로 변환될 것입니다. 아래 그림에서 은 문장의 길이,는 임베딩 벡터의 차원입니다. 그리고 이 행렬이 만약 LSTM의 입력으로 주어진다면, LSTM은 첫 번째 시점에는 첫 번째 행을 입력으로 받고, 두 번째 시점에는 두 번째 행을 입력으로 받으며 순차적으로 단어를 처리합니다. 그렇다면 1D 합성곱 연산의 경우에는 저 행렬을 어떻게 처리할까요? 1D 합성곱 연산에서 커널의 너비는 문장 행렬에서의 임베딩 벡터의 차원과 동일하게 설정됩니다. 그렇기 때문에 1D 합성곱 연산에서는 커널의 높이만으로 해당 커널의 크기라고 간주합니다. 가령, 커널의 크기가 2인 경우에는 아래의 그림과 같이 높이가 2, 너비가 임베딩 벡터의 차원인 커널이 사용됩니다. 커널의 너비가 임베딩 벡터의 차원이라는 의미는 커널이 2D 합성곱 연산 때와는 달리 너비 방향으로는 더 이상 움직일 곳이 없다는 것을 의미합니다. 그래서 1D 합성곱 연산에서는 커널이 문장 행렬의 높이 방향으로만 움직이게 되어있습니다. 쉽게 설명하면, 위 그림에서 커널은 2D 합성곱 연산 때와는 달리 오른쪽으로는 움직일 공간이 없으므로, 아래쪽으로만 이동해야 합니다. 한 번의 연산을 1 스텝(step)이라고 하였을 때, 합성곱 연산의 네 번째 스텝까지 표현한 이미지는 다음과 같습니다. 크기가 2인 커널은 처음에는 'wait for'에 대해서 합성곱 연산을 하고, 두 번째 스텝에는 'for the'에 대해서 연산을, 세 번째 스텝에는 'the video'에 대해서 연산을, 네 번째 스텝에서는 'video and'에 대해서 연산을 하게 됩니다. 이렇게 여덟 번째 스텝까지 반복하였을 때, 결과적으로는 우측의 8차원 벡터를 1D 합성곱 연산의 결과로서 얻게 될 것입니다. 그런데 커널의 크기가 꼭 2일 필요가 있을까요? 2D 합성곱 연산에서 커널의 크기가 3 × 3 또는 5 × 5 또는 등등의 여러 크기의 커널을 자유자재로 사용할 수 있었듯이, 1D 합성곱 연산에서도 커널의 크기는 사용자가 변경할 수 있습니다. 가령, 커널의 크기를 3으로 한다면, 네 번째 스텝에서의 연산은 아래의 그림과 같을 것입니다. 커널의 크기가 달라진다는 것은 어떤 의미가 있을까요? CNN에서의 커널은 신경망 관점에서는 가중치 행렬이므로 커널의 크기에 따라 학습하게 되는 파라미터의 수는 달라집니다. 1D 합성곱 연산과 자연어 처리 관점에서는 커널의 크기에 따라서 참고하는 단어의 묶음의 크기가 달라집니다. 이는 참고하는 n-gram이 달라진다고 볼 수 있습니다. 커널의 크기가 2라면 각 연산의 스텝에서 참고하는 것은 bigram입니다. 커널의 크기가 3이라면 각 연산의 스텝에서 참고하는 것은 trigram입니다. 3. 맥스 풀링(Max-pooling) 이미지 처리에서의 CNN에서 그랬듯이, 일반적으로 1D 합성곱 연산을 사용하는 1D CNN에서도 합성곱 층(합성곱 연산 + 활성화 함수) 다음에는 풀링 층을 추가하게 됩니다. 그중 대표적으로 사용되는 것이 맥스 풀링(Max-pooling)입니다. 맥스 풀링은 각 합성곱 연산으로부터 얻은 결과 벡터에서 가장 큰 값을 가진 스칼라 값을 빼내는 연산입니다. 아래의 그림은 크기가 2인 커널과 크기가 3인 커널 두 개의 커널로부터 각각 결과 벡터를 얻고, 각 벡터에서 가장 큰 값을 꺼내오는 맥스 풀링 연산을 보여줍니다. 4. 신경망 설계하기 지금까지 배운 개념들을 가지고 텍스트 분류를 위한 CNN을 설계해 봅시다. 우선, 설계하고자 하는 신경망은 이진 분류를 위한 신경망입니다. 단, 시그모이드 함수가 아니라 소프트맥스 함수를 사용할 것이므로 출력층에서 뉴런의 개수가 2인 신경망을 설계합니다. 커널은 크기가 4인 커널 2개, 3인 커널 2개, 2인 커널 2개를 사용합니다. 문장의 길이가 9인 경우, 합성곱 연산을 한 후에는 각각 6차원 벡터 2개, 7차원 벡터 2개, 8차원 벡터 2개를 얻습니다. 벡터가 6개므로 맥스 풀링을 한 후에는 6개의 스칼라 값을 얻는데, 일반적으로 이렇게 얻은 스칼라 값들은 전부 연결(concatenate) 하여 하나의 벡터로 만들어줍니다. 이렇게 얻은 벡터는 1D CNN을 통해서 문장으로부터 얻은 벡터입니다. 이를 뉴런이 2개인 출력층에 완전 연결시키므로서(Dense layer를 사용) 텍스트 분류를 수행합니다. 5. 케라스(Keras)로 CNN 구현하기 케라스로 1D 합성곱 층을 추가하는 코드는 다음과 같습니다. from tensorflow.keras.layers import Conv1D, GlobalMaxPooling1D model = Sequential() model.add(Conv1D(num_filters, kernel_size, padding='valid', activation='relu')) 각 인자에 대한 설명은 다음과 같습니다. num_filters = 커널의 개수. kernel_size = 커널의 크기. padding = 패딩 방법. - valid : 패딩 없음. 제로 패딩 없이 유효한(valid) 값만을 사용한다는 의미에서 valid. - same : 합성곱 연산 후에 출력이 입력과 동일한 차원을 가지도록 왼쪽과 오른쪽(또는 위, 아래)에 제로 패딩을 추가. activation = 활성화 함수. 만약 위에서 설명한 맥스 풀링을 추가하고자 한다면 다음과 같이 코드를 작성할 수 있습니다. model = Sequential() model.add(Conv1D(num_filters, kernel_size, padding='valid', activation='relu')) model.add(GlobalMaxPooling1D()) 11-03 1D CNN으로 IMDB 리뷰 분류하기 1D CNN을 이용하여 IMDB 리뷰를 분류해 보겠습니다. 이전에 다룬 데이터이므로 데이터에 대한 설명은 생략합니다. 1. 데이터에 대한 전처리 from tensorflow.keras import datasets from tensorflow.keras.preprocessing.sequence import pad_sequences 최대 10,000개의 단어만을 허용하여 데이터를 로드합니다. vocab_size = 10000 (X_train, y_train), (X_test, y_test) = datasets.imdb.load_data(num_words=vocab_size) X_train을 상위 5개만 출력해 봅시다. print(X_train[:5]) [list([1, 14, 22, 16, 43, 530, 973, 1622, ... 중략 ... 32]) list([1, 194, 1153, 194, 8255, 78, ... 중략 ... 95]) list([1, 14, 47, 8, 30, 31, ... 중략 ... 113]) list([1, 4, 2, 2, 33, 2804, ... 중략 ... 2574]) list([1, 249, 1323, 7, 61, 113, ... 중략 ... 113])] 각 샘플의 길이가 긴 관계로 출력 시 중간 내용은 중략하였습니다. 각 샘플은 이미 정수 인코딩까지 전처리가 된 상태입니다. 하지만 각 샘플들의 길이는 서로 다르죠? 패딩을 진행하여 모든 샘플들의 길이를 200으로 맞춥니다. max_len = 200 X_train = pad_sequences(X_train, maxlen=max_len) X_test = pad_sequences(X_test, maxlen=max_len) 패딩이 되었는지 크기(shape)를 확인해 봅시다. print('X_train의 크기(shape) :',X_train.shape) print('X_test의 크기(shape) :',X_test.shape) X_train의 크기(shape) : (25000, 200) X_test의 크기(shape) : (25000, 200) 훈련 데이터, 테스트 데이터 각 25,000 샘플이 전부 길이 200을 가지는 것을 확인할 수 있습니다. y_train도 출력해 봅시다. print(y_train[:5]) [1 0 0 1 0] 1과 0으로 구성된 것을 확인하였습니다. 이진 분류를 수행할 것이므로 레이블에는 더 이상 전처리를 할 것이 없습니다. 2. 1D CNN으로 IMDB 리뷰 분류하기 IMDB 리뷰 분류를 위한 1D CNN 모델을 설계해 봅시다. 하이퍼 파라미터인 임베딩 벡터의 차원은 256, 드롭아웃 비율은 0.3, 커널의 크기는 3이며 해당 커널은 총 256개 사용합니다. 합성곱 층과 맥스 풀링 연산 후 전결합층(Fully Connected Layer)을 은닉층을 추가로 사용했는데, 은닉층의 뉴런 수는 128입니다. 해당 모델은 마지막 시점에서 두 개의 선택지 중 하나를 예측하는 이진 분류 문제를 수행하는 모델입니다. 이진 분류 문제의 경우, 출력층에 로지스틱 회귀를 사용해야 하므로 활성화 함수로는 시그모이드 함수를 사용하고, 손실 함수로 크로스 엔트로피 함수를 사용합니다. 20 에포크를 수행합니다. EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=3)는 검증 데이터 손실(val_loss)이 증가하면, 과적합 징후므로 검증 데이터 손실이 3회 증가하면 정해진 에포크가 도달하지 못하였더라도 학습을 조기 종료(Early Stopping) 한다는 의미입니다. ModelCheckpoint를 사용하여 검증 데이터의 정확도(val_acc)가 이전보다 좋아질 경우에만 모델을 저장합니다. validation_data로는 X_test와 y_test를 사용합니다. val_loss가 줄어들다가 증가하는 상황이 오면 과적합으로 판단하기 위함입니다. from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Embedding, Dropout, Conv1D, GlobalMaxPooling1D, Dense from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint from tensorflow.keras.models import load_model embedding_dim = 256 # 임베딩 벡터의 차원 dropout_ratio = 0.3 # 드롭아웃 비율 num_filters = 256 # 커널의 수 kernel_size = 3 # 커널의 크기 hidden_units = 128 # 뉴런의 수 model = Sequential() model.add(Embedding(vocab_size, embedding_dim)) model.add(Dropout(dropout_ratio)) model.add(Conv1D(num_filters, kernel_size, padding='valid', activation='relu')) model.add(GlobalMaxPooling1D()) model.add(Dense(hidden_units, activation='relu')) model.add(Dropout(dropout_ratio)) model.add(Dense(1, activation='sigmoid')) es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=3) mc = ModelCheckpoint('best_model.h5', monitor='val_acc', mode='max', verbose=1, save_best_only=True) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['acc']) history = model.fit(X_train, y_train, epochs=20, validation_data=(X_test, y_test), callbacks=[es, mc]) 저자의 경우 에포크 4에서 조기 종료되었습니다. 저장된 모델을 로드하여 테스트 정확도를 확인합니다. loaded_model = load_model('best_model.h5') print("\n 테스트 정확도: %.4f" % (loaded_model.evaluate(X_test, y_test)[1])) 25000/25000 [==============================] - 3s 3ms/step - loss: 0.5373 - acc: 0.8873 테스트 정확도: 0.8873 테스트 데이터에서 88.73%의 정확도를 얻습니다. 11-04 1D CNN으로 스팸 메일 분류하기 1D CNN을 이용하여 스팸 메일을 분류해 보겠습니다. 이전에 다룬 데이터이므로 데이터에 대한 설명은 생략합니다. 1. 데이터에 대한 전처리 모든 전처리는 11-2. RNN을 이용한 텍스트 분류 챕터의 스팸 메일 분류하기(Spam Detection)( https://wikidocs.net/22894 )와 동일하게 수행하였다고 가정합니다. 2. 1D CNN으로 스팸 메일 분류하기 하이퍼 파라미터인 임베딩 벡터의 차원은 32, 드롭아웃 비율은 0.3, 커널의 크기는 5이며 해당 커널은 총 32개 사용합니다. 합성곱 층과 맥스 풀링 연산 후 출력층으로 연결됩니다. 해당 모델은 마지막 시점에서 두 개의 선택지 중 하나를 예측하는 이진 분류 문제를 수행하는 모델입니다. 이진 분류 문제의 경우, 출력층에 로지스틱 회귀를 사용해야 하므로 활성화 함수로는 시그모이드 함수를 사용하고, 손실 함수로 크로스 엔트로피 함수를 사용합니다. 하이퍼 파라미터인 배치 크기는 64이며, 10 에포크를 수행합니다. EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=3)는 검증 데이터 손실(val_loss)이 증가하면, 과적합 징후므로 검증 데이터 손실이 3회 증가하면 정해진 에포크가 도달하지 못하였더라도 학습을 조기 종료(Early Stopping) 한다는 의미입니다. ModelCheckpoint를 사용하여 검증 데이터의 정확도(val_acc)가 이전보다 좋아질 경우에만 모델을 저장합니다. validation_split=0.2를 사용하여 훈련 데이터의 20%를 검증 데이터로 분리해서 사용하고, 검증 데이터를 통해서 훈련이 적절히 되고 있는지 확인합니다. 검증 데이터는 기계가 훈련 데이터에 과적합되고 있지는 않은지 확인하기 위한 용도로 사용됩니다. from tensorflow.keras.layers import Dense, Conv1D, GlobalMaxPooling1D, Embedding, Dropout, MaxPooling1D from tensorflow.keras.models import Sequential from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint embedding_dim = 32 dropout_ratio = 0.3 num_filters = 32 kernel_size = 5 model = Sequential() model.add(Embedding(vocab_size, embedding_dim)) model.add(Dropout(dropout_ratio)) model.add(Conv1D(num_filters, kernel_size, padding='valid', activation='relu')) model.add(GlobalMaxPooling1D()) model.add(Dropout(dropout_ratio)) model.add(Dense(1, activation='sigmoid')) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['acc']) es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=3) mc = ModelCheckpoint('best_model.h5', monitor = 'val_acc', mode='max', verbose=1, save_best_only=True) history = model.fit(X_train_padded, y_train, epochs=10, batch_size=64, validation_split=0.2, callbacks=[es, mc]) 테스트 데이터에 대해서 정확도를 확인해 보겠습니다. X_test_encoded = tokenizer.texts_to_sequences(X_test) X_test_padded = pad_sequences(X_test_encoded, maxlen = max_len) print("\n 테스트 정확도: %.4f" % (model.evaluate(X_test_padded, y_test)[1])) 테스트 정확도: 0.9797 11-05 Multi-Kernel 1D CNN으로 네이버 영화 리뷰 분류하기 다양한 크기의 커널들을 혼합하여 네이버 영화 리뷰를 분류해 보겠습니다. 1. 네이버 영화 데이터 수집 & 전처리 모든 전처리는 RNN을 이용한 텍스트 분류 챕터의 네이버 영화 리뷰 분류하기( https://wikidocs.net/44249 )와 동일하게 수행하였다고 가정합니다. 2. Multi-Kernel 1D CNN으로 네이버 영화 리뷰 분류하기 케라스에서 다수의 커널을 사용할 경우에는 Funtional API를 사용하여 구현합니다. 우선 필요한 도구들을 임포트 합니다. 하이퍼 파라미터인 임베딩 벡터의 차원은 128, 드롭아웃 비율은 0.5와 0.8 두 가지를 사용합니다. 각 커널의 개수는 128개를 사용하고, 전결합층(Fully Connected Layer)을 은닉층을 추가로 사용했는데, 은닉층의 뉴런 수는 128입니다. from tensorflow.keras.models import Sequential, Model from tensorflow.keras.layers import Embedding, Dropout, Conv1D, GlobalMaxPooling1D, Dense, Input, Flatten, Concatenate from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint from tensorflow.keras.models import load_model embedding_dim = 128 dropout_ratio = (0.5, 0.8) num_filters = 128 hidden_units = 128 입력 층과 임베딩 층을 정의합니다. 임베딩 층 이후에는 드롭아웃의 인자 값이 0.5. 즉, 50% 드롭아웃을 해주었습니다. model_input = Input(shape = (max_len,)) z = Embedding(vocab_size, embedding_dim, input_length = max_len, name="embedding")(model_input) z = Dropout(dropout_ratio[0])(z) 3, 4, 5의 크기를 가지는 커널을 각각 128개 사용합니다. 그리고 이들을 맥스 풀링 합니다. conv_blocks = [] for sz in [3, 4, 5]: conv = Conv1D(filters = num_filters, kernel_size = sz, padding = "valid", activation = "relu", strides = 1)(z) conv = GlobalMaxPooling1D()(conv) conv_blocks.append(conv) 각 맥스 풀링 한 결과를 연결(concatenate) 합니다. 그리고 이를 전결합층(Fully Connected Layer)을 사용한 은닉층으로 전달합니다. 해당 모델은 마지막 시점에서 두 개의 선택지 중 하나를 예측하는 이진 분류 문제를 수행하는 모델입니다. 이진 분류 문제의 경우, 출력층에 로지스틱 회귀를 사용해야 하므로 활성화 함수로는 시그모이드 함수를 사용하고, 손실 함수로 크로스 엔트로피 함수를 사용합니다. 하이퍼 파라미터인 배치 크기는 64이며, 10 에포크를 수행합니다. EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=4)는 검증 데이터 손실(val_loss)이 증가하면, 과적합 징후므로 검증 데이터 손실이 4회 증가하면 정해진 에포크가 도달하지 못하였더라도 학습을 조기 종료(Early Stopping) 한다는 의미입니다. ModelCheckpoint를 사용하여 검증 데이터의 정확도(val_acc)가 이전보다 좋아질 경우에만 모델을 저장합니다. validation_split=0.2를 사용하여 훈련 데이터의 20%를 검증 데이터로 분리해서 사용하고, 검증 데이터를 통해서 훈련이 적절히 되고 있는지 확인합니다. 검증 데이터는 기계가 훈련 데이터에 과적합되고 있지는 않은지 확인하기 위한 용도로 사용됩니다. z = Concatenate()(conv_blocks) if len(conv_blocks) > 1 else conv_blocks[0] z = Dropout(dropout_ratio[1])(z) z = Dense(hidden_units, activation="relu")(z) model_output = Dense(1, activation="sigmoid")(z) model = Model(model_input, model_output) model.compile(loss="binary_crossentropy", optimizer="adam", metrics=["acc"]) es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=4) mc = ModelCheckpoint('CNN_model.h5', monitor='val_acc', mode='max', verbose=1, save_best_only=True) model.fit(X_train, y_train, batch_size=64, epochs=10, validation_split=0.2, verbose=2, callbacks=[es, mc]) 학습 후 저장한 모델을 로드하여 테스트 데이터에 대해서 평가합니다. loaded_model = load_model('CNN_model.h5') print("\n 테스트 정확도: %.4f" % (loaded_model.evaluate(X_test, y_test)[1])) 테스트 정확도: 0.8430 84%의 정확도를 얻었습니다. 3. 리뷰 예측해 보기 RNN을 이용한 텍스트 분류 챕터의 네이버 영화 리뷰 분류하기 실습( https://wikidocs.net/44249 )에서 사용한 동일한 예측 함수 sentiment_predict를 사용했습니다. sentiment_predict('이 영화 개꿀 잼 ㅋㅋㅋ') 93.73% 확률로 긍정 리뷰입니다. sentiment_predict('이 영화 핵노잼 ㅠㅠ') 97.03% 확률로 부정 리뷰입니다. sentiment_predict('이딴 게 영화냐 ㅉㅉ') 97.18% 확률로 부정 리뷰입니다. sentiment_predict('감독 뭐 하는 놈이냐?') 82.89% 확률로 부정 리뷰입니다. sentiment_predict('와 개쩐다 정말 세계관 최강자들의 영화다') 85.93% 확률로 긍정 리뷰입니다. 11-06 사전 훈련된 워드 임베딩을 이용한 의도 분류(Intent Classification using Pre-trained Word Embedding) 의도 분류(Intent Classification)는 개체명 인식(Named Entity Recognition)과 더불어 챗봇(Chatbot)의 중요 모듈로서 사용될 수 있습니다. 사전 훈련된 워드 임베딩(Pre-traiend word embedding)을 입력으로 의도 분류를 수행해 봅시다. 의도 분류 실습은 결국 텍스트 분류입니다. 1. 데이터 로드와 전처리 import os import pandas as pd import numpy as np import matplotlib.pyplot as plt import urllib.request from sklearn import preprocessing from tensorflow.keras.preprocessing.text import Tokenizer from tensorflow.keras.preprocessing.sequence import pad_sequences from tensorflow.keras.utils import to_categorical from sklearn.metrics import classification_report 깃허브로부터 의도 데이터를 다운로드하여 데이터 프레임에 로드합니다. urllib.request.urlretrieve("https://raw.githubusercontent.com/ukairia777/tensorflow-nlp-tutorial/main/11.% 201D%20CNN%20Text%20Classification/dataset/intent_train_data.csv", filename="intent_train_data.csv") urllib.request.urlretrieve("https://raw.githubusercontent.com/ukairia777/tensorflow-nlp-tutorial/main/11.% 201D%20CNN%20Text%20Classification/dataset/intent_test_data.csv", filename="intent_test_data.csv") train_data = pd.read_csv('intent_train_data.csv') test_data = pd.read_csv('intent_test_data.csv') 훈련 데이터를 로드한 데이터 프레임을 출력해 봅시다. train_data 테스트 데이터를 로드한 데이터 프레임을 출력해 봅시다. test_data 훈련 데이터와 테스트 데이터 그리고 레이블을 리스트로 저장하고 샘플 수를 출력해 봅시다. intent_train = train_data['intent'].tolist() label_train = train_data['label'].tolist() intent_test = test_data['intent'].tolist() label_test = test_data['label'].tolist() print('훈련용 문장의 수 :', len(intent_train)) print('훈련용 레이블의 수 :', len(label_train)) print('테스트용 문장의 수 :', len(intent_test)) print('테스트용 레이블의 수 :', len(label_test)) 훈련용 문장의 수 : 11784 훈련용 레이블의 수 : 11784 테스트용 문장의 수 : 600 테스트용 레이블의 수 : 600 훈련 데이터의 상위 5개 샘플과 레이블을 출력해 봅시다. print(intent_train[:5]) print(label_train[:5]) ['add another song to the cita rom ntica playlist', 'add clem burke in my playlist pre party r b jams', 'add live from aragon ballroom to trapeo', 'add unite and win to my night out', 'add track to my digster future hits'] ['AddToPlaylist', 'AddToPlaylist', 'AddToPlaylist', 'AddToPlaylist', 'AddToPlaylist'] 첫 번째 샘플을 보면 'add another song to the cita rom ntica playlist'라는 문장의 레이블은 'AddToPlaylist'입니다. 이 문장의 의도는 이 곡을 플레이리스트에 추가해 줘라는 의도입니다. 그 외에도 어떤 종류의 범주가 있는지 보려면 정확하게 인덱스를 2000씩 +하면서 출력해 보면 됩니다. print(intent_train[2000:2002]) print(label_train[2000:2002]) ['please book reservations for 3 people at a restaurant in alderwood manor', 'book a table in mt for 3 for now at a pub that serves south indian'] ['BookRestaurant', 'BookRestaurant'] print(intent_train[4000:4002]) print(label_train[4000:4002]) ['what will the weather be like on feb 8 , 2034 in cedar mountain wilderness', "tell me the forecast in the same area here on robert e lee 's birthday"] ['GetWeather', 'GetWeather'] print(intent_train[6000:6002]) print(label_train[6000:6002]) ['rate the current album one points', 'i give a zero rating for this essay'] ['RateBook', 'RateBook'] print(intent_train[8000:8002]) print(label_train[8000:8002]) ["i'm trying to find the show chant ii", 'find spirit of the bush'] ['SearchCreativeWork', 'SearchCreativeWork'] print(intent_train[10000:10002]) print(label_train[10000:10002]) ['when is blood and ice cream trilogie playing at the nearest movie theatre \\?', 'show movie schedules'] ['SearchScreeningEvent', 'SearchScreeningEvent'] 이를 통해 눈치채셨겠지만, 사실 이 데이터는 일정한 순서로 배치돼 있습니다. 그래서 뒤에서는 이 데이터를 랜덤으로 섞어주는 작업을 해줍니다. 훈련 데이터에 존재하는 레이블의 분포를 그래프로 시각화하여 보겠습니다. train_data['label'].value_counts().plot(kind = 'bar') 훈련 데이터에는 6개의 카테고리가 존재합니다. AddToPlaylist, BookRestaurant, GetWeather , RateBook , SearchCreativeWork, SearchScreeningEvent 각각의 데이터는 약 2,000개씩 존재합니다. label_train과 label_test에 존재하는 6개의 카테고리들을 고유한 정수로 인코딩 해봅시다. 이런 경우에는 사이킷런(sklearn)의 preprocessing.LabelEncoder()가 유용합니다. label_idx에는 어떤 레이블이 어떤 정수에 매핑되었는지 저장돼 있습니다. # 레이블 인코딩. 레이블에 고유한 정수를 부여 idx_encode = preprocessing.LabelEncoder() idx_encode.fit(label_train) label_train = idx_encode.transform(label_train) # 주어진 고유한 정수로 변환 label_test = idx_encode.transform(label_test) # 고유한 정수로 변환 label_idx = dict(zip(list(idx_encode.classes_), idx_encode.transform(list(idx_encode.classes_)))) print('레이블과 정수의 매핑 관계 :',label_idx) 레이블과 정수의 매핑 관계 : {'AddToPlaylist': 0, 'BookRestaurant': 1, 'GetWeather': 2, 'RateBook': 3, 'SearchCreativeWork': 4, 'SearchScreeningEvent': 5} 훈련 데이터의 레이블과 테스트 데이터의 레이블 데이터를 상위 5개씩만 출력해 봅시다. print(intent_train[:5]) print(label_train[:5]) ['add another song to the cita rom ntica playlist', 'add clem burke in my playlist pre party r b jams', 'add live from aragon ballroom to trapeo', 'add unite and win to my night out', 'add track to my digster future hits'] [0 0 0 0 0] print(intent_test[:5]) print(label_test[:5]) ["i 'd like to have this track onto my classical relaxations playlist", 'add the album to my flow espa ol playlist', 'add digging now to my young at heart playlist', 'add this song by too poetic to my piano ballads playlist', 'add this album to old school death metal'] [0 0 0 0 0] 이전에 'AddToPlaylist'라는 문자열로 저장돼 있었던 레이블이 정수 0으로 변환되었습니다. 의도 문장에 대해서도 정수 인코딩을 진행해 봅시다. 우선 의도 문장에 대해서 토큰화를 수행하고 단어 집합(vocabulary)을 만듭니다. 이어서 정수 인코딩을 수행하여 텍스트 시퀀스를 정수 시퀀스로 변환합니다. tokenizer = Tokenizer() tokenizer.fit_on_texts(intent_train) sequences = tokenizer.texts_to_sequences(intent_train) sequences[:5] # 상위 5개 샘플 출력 [[11, 191, 61, 4, 1, 4013, 1141, 1572, 15], [11, 2624, 1573, 3, 14, 15, 939, 82, 256, 188, 548], [11, 187, 42, 2625, 4014, 4, 1968], [11, 2626, 22, 2627, 4, 14, 192, 27], [11, 92, 4, 14, 651, 520, 195]] 단어 집합의 크기를 확인해 보겠습니다. word_index = tokenizer.word_index vocab_size = len(word_index) + 1 print('단어 집합(Vocabulary)의 크기 :',vocab_size) 단어 집합(Vocabulary)의 크기 : 9870 패딩을 위해서 훈련 데이터의 길이 분포를 확인해 보겠습니다. print('문장의 최대 길이 :',max(len(l) for l in sequences)) print('문장의 평균 길이 :',sum(map(len, sequences))/len(sequences)) plt.hist([len(s) for s in sequences], bins=50) plt.xlabel('length of samples') plt.ylabel('number of samples') plt.show() 문장의 최대 길이 : 35 문장의 평균 길이 : 9.364392396469789 문장의 최대 길이는 35이므로, 최대 길이 35로 모든 훈련 데이터를 패딩 하겠습니다. 레이블의 경우에는 다중 클래스 분류를 수행하기 위해서 원-핫 인코딩을 수행합니다. max_len = 35 intent_train = pad_sequences(sequences, maxlen = max_len) label_train = to_categorical(np.asarray(label_train)) print('훈련 데이터의 크기(shape):', intent_train.shape) print('훈련 데이터 레이블의 크기(shape):', label_train.shape) 훈련 데이터의 크기(shape) : (11784, 35) 훈련 데이터 레이블의 크기(shape) : (11784, 6) print('훈련 데이터의 첫 번째 샘플 :',intent_train[0]) print('훈련 데이터의 첫 번째 샘플의 레이블 :',label_train[0]) 첫 번째 샘플 : [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 11 191 61 4 1 4013 1141 1572 15] 첫 번째 샘플의 레이블 : [1. 0. 0. 0. 0. 0.] 훈련 데이터로부터 검증 데이터를 분리하겠습니다. 앞서 언급했듯이 훈련 데이터가 일정한 순서로 배치돼 있으므로 훈련 데이터에서 앞의 10%나 중간 10%나 뒤의 10%를 검증 데이터로 분리했다가는 운이 나쁘면 특정 레이블의 데이터들만을 분리할 수도 있습니다. 가령, 검증 데이터에 0번 레이블의 데이터만 있다면 제대로 된 검증이 안 될 것입니다. 그래서 검증 데이터로 분리하기 전에 훈련 데이터의 순서를 랜덤으로 섞어주겠습니다. 이를 위해 순서가 뒤죽박죽의 정수 시퀀스를 만들어줍니다. indices = np.arange(intent_train.shape[0]) np.random.shuffle(indices) print('랜덤 시퀀스 :',indices) 랜덤 시퀀스 : [1147 9504 9615 ... 4685 227 8774] 이 정수의 순서를 각 샘플의 순서가 되도록 훈련 데이터를 섞어줍니다. intent_train = intent_train[indices] label_train = label_train[indices] 검증 데이터는 훈련 데이터 중 10%만을 사용합니다. 훈련 데이터의 개수에 0.1을 곱하면 몇일까요? n_of_val = int(0.1 * intent_train.shape[0]) print('검증 데이터의 개수 :',n_of_val) 검증 데이터의 개수 : 1178 1,178이네요. 검증 데이터는 1,178개만 사용하도록 훈련 데이터에서 분리해 줍니다. X_train = intent_train[:-n_of_val] y_train = label_train[:-n_of_val] X_val = intent_train[-n_of_val:] y_val = label_train[-n_of_val:] X_test = intent_test y_test = label_test print('훈련 데이터의 크기(shape):', X_train.shape) print('검증 데이터의 크기(shape):', X_val.shape) print('훈련 데이터 레이블의 크기(shape):', y_train.shape) print('검증 데이터 레이블의 크기(shape):', y_val.shape) print('테스트 데이터의 개수 :', len(X_test)) print('테스트 데이터 레이블의 개수 :', len(y_test)) 훈련 데이터의 크기(shape): (10606, 35) 검증 데이터의 크기(shape): (1178, 35) 훈련 데이터 레이블의 크기(shape): (10606, 6) 검증 데이터 레이블의 크기(shape): (1178, 6) 테스트 데이터의 개수 : 600 테스트 데이터 레이블의 개수 : 600 2. 사전 훈련된 워드 임베딩 사용하기 스탠퍼드 대학교에서 제공하는 사전 훈련된 GloVe 임베딩을 사용합니다. !wget http://nlp.stanford.edu/data/glove.6B.zip !unzip glove*.zip 아래 코드의 상세 내용은 사전 훈련된 워드 임베딩 실습을 참고하세요. 임베딩 벡터를 로드합니다. embedding_dict = dict() f = open(os.path.join('glove.6B.100d.txt'), encoding='utf-8') for line in f: word_vector = line.split() word = word_vector[0] word_vector_arr = np.asarray(word_vector[1:], dtype='float32') # 100개의 값을 가지는 array로 변환 embedding_dict[word] = word_vector_arr f.close() print('%s 개의 Embedding vector가 있습니다.' % len(embedding_dict)) 400000개의 Embedding vector가 있습니다. 총 40만 개의 임베딩 벡터가 존재합니다. 임의로 사전 훈련된 임베딩에서 단어 'respectable' 임베딩 벡터 값과 벡터의 차원을 출력합니다. print(embedding_dict['respectable']) print(len(embedding_dict['respectable'])) [-0.049773 0.19903 0.10585 0.1391 -0.32395 0.44053 0.3947 -0.22805 -0.25793 0.49768 0.15384 -0.08831 0.0782 -0.8299 -0.037788 0.16772 -0.45197 -0.17085 0.74756 0.98256 0.81872 0.28507 0.16178 -0.48626 -0.006265 -0.92469 -0.30625 -0.067318 -0.046762 -0.76291 -0.0025264 -0.018795 0.12882 -0.52457 0.3586 0.43119 -0.89477 -0.057421 -0.53724 0.25587 0.55195 0.44698 -0.24252 0.29946 0.25776 -0.8717 0.68426 -0.05688 -0.1848 -0.59352 -0.11227 -0.57692 -0.013593 0.18488 -0.32507 -0.90171 0.17672 0.075601 0.54896 -0.21488 -0.54018 -0.45882 -0.79536 0.26331 0.18879 -0.16363 0.3975 0.1099 0.1164 -0.083499 0.50159 0.35802 0.25677 0.088546 0.42108 0.28674 -0.71285 -0.82915 0.15297 -0.82712 0.022112 1.067 -0.31776 0.1211 -0.069755 -0.61327 0.27308 -0.42638 -0.085084 -0.17694 -0.0090944 0.1109 0.62543 -0.23682 -0.44928 -0.3667 -0.21616 -0.19187 -0.032502 0.38025 ] 100 임베딩 벡터의 차원은 100차원입니다. 이번 실습에서 사용할 임베딩 테이블을 구축해야 합니다. 사전 훈련된 임베딩의 벡터의 차원이 100이므로 임베딩 테이블의 열도 100차원이어야 합니다. vocab_size를 행의 크기로, 열의 크기는 100인 테이블을 만듭니다. embedding_dim = 100 embedding_matrix = np.zeros((vocab_size, embedding_dim)) print('임베딩 테이블의 크기(shape) :',np.shape(embedding_matrix)) 임베딩 테이블의 크기(shape) : (9870, 100) 훈련 데이터에 있는 단어와 사전 훈련된 워드 임베딩 벡터의 값을 매핑하여 임베딩 테이블에 저장합니다. for word, i in word_index.items(): embedding_vector = embedding_dict.get(word) if embedding_vector is not None: embedding_matrix[i] = embedding_vector 3. 1D CNN을 이용한 의도 분류 모델은 네이버 영화 리뷰 분류하기에서 사용했던 Multi-Kernel 1D CNN 구조를 하이퍼 파라미터를 바꿔서 사용합니다. from tensorflow.keras.models import Model from tensorflow.keras.layers import Embedding, Dropout, Conv1D, GlobalMaxPooling1D, Dense, Input, Flatten, Concatenate kernel_sizes = [2, 3, 5] num_filters = 512 dropout_ratio = 0.5 model_input = Input(shape=(max_len,)) output = Embedding(vocab_size, embedding_dim, weights=[embedding_matrix], input_length=max_len, trainable=False)(model_input) conv_blocks = [] for size in kernel_sizes: conv = Conv1D(filters=num_filters, kernel_size=size, padding="valid", activation="relu", strides=1)(output) conv = GlobalMaxPooling1D()(conv) conv_blocks.append(conv) output = Concatenate()(conv_blocks) if len(conv_blocks) > 1 else conv_blocks[0] output = Dropout(dropout_ratio)(output) model_output = Dense(len(label_idx), activation='softmax')(output) model = Model(model_input, model_output) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc']) model.summary() 앞서 분리해두었던 검증 데이터로 성능을 점검하면서 훈련을 시작합니다. history = model.fit(X_train, y_train, batch_size=64, epochs=10, validation_data=(X_val, y_val)) 훈련 데이터에서 99%, 검증 데이터에서 98%의 정확도를 얻었습니다. 정확도와 loss의 변화를 그래프로 시각화해봅시다. epochs = range(1, len(history.history['acc']) + 1) plt.plot(epochs, history.history['acc']) plt.plot(epochs, history.history['val_acc']) plt.title('model accuracy') plt.ylabel('accuracy') plt.xlabel('epochs') plt.legend(['train', 'test'], loc='lower right') plt.show() epochs = range(1, len(history.history['loss']) + 1) plt.plot(epochs, history.history['loss']) plt.plot(epochs, history.history['val_loss']) plt.title('model loss') plt.ylabel('loss') plt.xlabel('epochs') plt.legend(['train', 'test'], loc='upper right') plt.show() 테스트 데이터에 대해서 평가해 봅시다. X_test = tokenizer.texts_to_sequences(X_test) X_test = pad_sequences(X_test, maxlen=max_len) y_predicted = model.predict(X_test) y_predicted = y_predicted.argmax(axis=-1) # 예측을 정수 시퀀스로 변환 print('정확도(Accuracy) : ', sum(y_predicted == y_test) / len(y_test)) 정확도(Accuracy) : 0.99 99%의 정확도를 얻었습니다. 11-07 문자 임베딩(Character Embedding) 워드 임베딩과는 다른 방법으로 단어의 벡터 표현 방법을 얻는 문자 임베딩(Character Embedding)에 대해서 알아보겠습니다. 'understand'라는 단어는 '이해하다'라는 뜻을 가진 영단어입니다. 그런데 여기에 mis-를 앞에 붙여주게 되면, 'misunderstand'라는 '오해하다'라는 뜻의 다른 의미의 영단어가 됩니다. 비슷한 예시를 들어보겠습니다. 'underestimate'라는 단어는 '과소평가하다'라는 단어입니다. 그렇다면 'misunderestimate'는 무슨 뜻일까요? 사실 이 단어는 실존하는 단어가 아님에도 이 단어의 뜻을 추측할 수 있습니다. 영어권 언어에서 mis-라는 접두사는 '잘못 판단하는'이라는 의미의 'mistaken'의 의미를 담고 있으므로 '과소평가하다'라는 단어 앞에 mis-라는 접두사가 붙었다면 'misunderestimate'는 '잘못 과소평가하다'라는 추측이 가능합니다. 문자 임베딩은 사람의 이러한 이해 능력을 흉내 내는 알고리즘입니다. 여기서는 CNN과 RNN을 이용한 두 가지 방법을 제시합니다. 1. 1D CNN을 이용한 문자 임베딩 1D CNN은 전체 시퀀스 입력 안의 더 작은 시퀀스에 집중하여 정보를 얻어내는 동작을 하는 알고리즘입니다. FastText가 문자의 N-gram의 조합을 이용하여 OOV 문제를 해결하였듯이, 1D CNN을 문자 임베딩에 사용할 경우에는 문자의 N-gram으로부터 정보를 얻어내게 됩니다. 앞서 학습했던 1D CNN을 이용한 텍스트 분류를 이해했다면 문자 임베딩을 이해하는 것은 매우 간단합니다. 기본적으로 단어를 문자 단위로 쪼개고 나서 입력으로 사용하는 것 외에는 달라진 것이 없습니다. 위의 그림은 임의의 단어 'have'에 대해서 1D CNN을 통해서 단어 표현 벡터를 얻는 과정을 보여줍니다. 우선, 단어 'have'를 'h', 'a', 'v', 'e'와 같이 문자 단위로 분리합니다. 그리고 임베딩 층(Embedding layer)을 이용한 임베딩을 단어에 대해서 하는 것이 아니라 문자에 대해서 하게 됩니다. 다시 말해 문자를 임베딩합니다. (문장의 길이를 맞추기 위해 패딩을 했던 지난 실습 예시들과 마찬가지로 여기서도 패딩은 가능합니다.) 그 후 1D CNN을 적용하게 되는데, 위의 그림은 커널의 사이즈가 4인 커널 2개, 3인 커널 2개, 2인 커널 2개를 사용할 때를 보여줍니다. 벡터가 6개므로 맥스 풀링을 한 후에는 6개의 스칼라 값을 얻는데, 이렇게 얻은 스칼라 값들은 전부 연결(concatenate) 하여 하나의 벡터로 만들어줍니다. 최종적으로 이렇게 얻은 벡터를 단어 'have'의 벡터로 사용합니다. 그림에서는 문자 레벨 표현(Character-level representation)이라고 기재된 벡터에 해당됩니다. 이렇게 단어 벡터를 얻을 경우, 어떤 단어이든 기본적으로 문자 레벨로 쪼개므로 기존 워드 임베딩의 접근에서 OOV라고 하더라도 벡터를 얻을 수 있습니다. 가령, 'docker'라는 영단어가 훈련 데이터에 없었으나 테스트 데이터에 존재하는 단어였다고 해봅시다. Word2Vec이나 GloVe의 경우에는 OOV 문제가 발생하게 되겠지만, 1D CNN을 이용하는 경우에는 'd', 'o', 'c', 'k', 'e', 'r'로 전부 분리되어 각 문자로 임베딩이 되고나서 1D CNN을 거친 후에 'docker'의 벡터를 얻게 됩니다. 2. BiLSTM을 이용한 문자 임베딩 문자 임베딩을 얻는 또 다른 방법으로는 BiLSTM을 이용한 방법이 있습니다. 1D CNN 때와 마찬가지로 기본적으로 단어를 문자로 쪼갠 후, 임베딩 층을 사용하여 문자 임베딩을 입력으로 사용하는 것은 같습니다. 이번 챕터도 BiLSTM을 이용한 텍스트 분류를 이해했다면 쉽습니다. BiLSTM의 다 대 일(many-to-one) 구조를 이해하기 어렵다면 BiLSTM을 이용한 한국어 스팀 리뷰 감성 분류하기 실습을 참고하시기 바랍니다. 위 그림은 임의의 단어 'have'에 대해서 BiLSTM을 통해서 단어 표현 벡터를 얻는 과정을 보여줍니다. 우선, 단어 'have'를 'h', 'a', 'v', 'e'와 같이 문자 단위로 분리합니다. 그리고 임베딩 층(Embedding layer)을 이용한 임베딩을 단어에 대해서 하는 것이 아니라 문자에 대해서 하게 됩니다. 다시 말해 문자를 임베딩합니다. 그러고 나서 순방향 LSTM은 단어 순방향으로 순차적으로 문자 임베딩 벡터를 읽습니다. 반면, 역방향 LSTM은 단어의 역방향으로 순차적으로 문자 임베딩 벡터를 읽습니다. 그리고 순방향 LSTM의 마지막 시점의 은닉 상태와 역방향 LSTM의 첫 번째 시점의 은닉 상태를 연결(concatenate) 합니다. 최종적으로 이렇게 얻은 벡터를 단어 'have'의 벡터로 사용합니다. 그림에서는 문자 레벨 표현(Character-level representation)이라고 기재된 벡터에 해당됩니다. 문자 임베딩을 워드 임베딩의 대체재로서 쓰거나, 문자 임베딩을 워드 임베딩과 연결(concatenate) 하여 신경망의 입력으로 사용하기도 합니다. 12. 태깅 작업(Tagging Task) 자연어 처리 분야에서 각 단어가 어떤 유형에 속해있는지를 알아내는 태깅 작업에 대해서 배웁니다. 이러한 단어 태깅 작업의 대표적인 예시 두 가지로 각 단어의 유형이 사람, 장소, 단체 등 어떤 유형인지를 알아내는 개체명 인식(Named Entity Recognition) 과 각 단어의 품사가 명사, 동사, 형용사 인지를 알아내는 품사 태깅(Part-of-Speech Tagging) 이 있습니다. 이번 챕터에서는 RNN의 다 대다(many-to-many) 구조를 사용하여 인공 신경망 기반의 개체명 인식 기와 품사 태거를 만드는 미니 프로젝트를 수행해 보겠습니다. 12-01 케라스를 이용한 태깅 작업 개요(Tagging Task using Keras) 이번 챕터에서는 케라스(Keras)로 인공 신경망을 이용하여 태깅 작업을 하는 모델을 만듭니다. 개체명 인식 기와 품사 태거를 만드는 데, 이러한 두 작업의 공통점은 RNN의 다-대-다(Many-to-Many) 작업이면서 또한 앞, 뒤 시점의 입력을 모두 참고하는 양방향 RNN(Bidirectional RNN)을 사용한다는 점입니다. 전체적으로 실습의 진행 방향을 정리해 보겠습니다. 정확한 이해를 위해 텍스트 분류 개요 챕터와 비교하며 같이 읽기를 권합니다. 1. 훈련 데이터에 대한 이해 태깅 작업은 앞서 배운 텍스트 분류 작업과 동일하게 지도 학습(Supervised Learning)에 속합니다. 이 챕터에서는 태깅을 해야 하는 단어 데이터를 X, 레이블에 해당되는 태깅 정보 데이터는 y라고 이름을 붙였습니다. X에 대한 훈련 데이터는 X_train, 테스트 데이터는 X_test라고 명명하고 y에 대한 훈련 데이터는 y_train, 테스트 데이터는 y_test라고 명명합니다. 이번 챕터에서 X와 y 데이터의 쌍(pair)은 병렬 구조를 가진다는 특징을 가집니다. X와 y의 각 데이터의 길이는 같습니다. 예를 들어 개체명 인식 데이터의 상위 4개 샘플만 출력해 본다고 가정해 보겠습니다. 데이터는 다음과 같은 구조를 가질 수 있습니다. # X_train y_train 길이 0 ['EU', 'rejects', 'German', 'call', 'to', 'boycott', 'British', 'lamb'] ['B-ORG', 'O', 'B-MISC', 'O', 'O', 'O', 'B-MISC', 'O'] 8 1 ['peter', 'blackburn'] ['B-PER', 'I-PER'] 2 2 ['brussels', '1996-08-22' ] ['B-LOC', 'O'] 2 3 ['The', 'European', 'Commission'] ['O', 'B-ORG', 'I-ORG'] 3 가령, X_train[3]의 'The'와 y_train[3]의 'O'는 하나의 쌍(pair)입니다. 또한, X_train[3]의 'European'과 y_train[3]의 'B-ORG'는 쌍의 관계를 가지며, X_train[3]의 'Commision'과 y_train[3]의 'I-ORG'는 쌍의 관계를 가집니다. 이렇게 병렬 관계를 가지는 토큰 화가 이루어진 데이터는 정수 인코딩 과정을 거친 후, 모든 데이터의 길이를 동일하게 맞춰주기 위한 패딩(Padding) 작업을 거친 후에 딥 러닝 모델의 입력으로 사용됩니다. 2. 시퀀스 레이블링(Sequence Labeling) 위와 같이 입력 시퀀스 X = [ 1 x, 3 , ..., n ]에 대하여 레이블 시퀀스 y = [ 1 y, 3 , ..., n ]를 각각 부여하는 작업을 시퀀스 레이블링 작업(Sequence Labeling Task)이라고 합니다. 태깅 작업은 대표적인 시퀀스 레이블링 작업입니다. 3. 양방향 LSTM(Bidirectional LSTM) model.add(Bidirectional(LSTM(hidden_units, return_sequences=True))) 이번 챕터에는 양방향 LSTM을 사용합니다. 이전 시점의 단어 정보뿐만 아니라, 다음 시점의 단어 정보도 참고하기 위함입니다. 양방향은 기존의 단방향 LSTM()을 Bidirectional() 안에 넣으면 됩니다. LSTM의 인자 값은 단방향 LSTM을 사용할 때와 동일합니다. 인자 값을 하나를 줄 경우에는 이는 은닉 상태의 차원을 의미하며, 위 코드 상으로는 hidden_units로 기재되었습니다. 4. RNN의 다-대-다(Many-to-Many) 문제 RNN의 은닉층은 모든 시점에 대해서 은닉 상태의 값을 출력할 수도, 마지막 시점에 대해서만 은닉 상태의 값을 출력할 수도 있습니다. 인자로 return_sequences=True를 넣을 것인지, 넣지 않을 것인지로(넣지 않으면 기본값은 False이므로 return_sequences=False로 인식.) 설정할 수 있는데 태깅 작업의 경우에는 다 대다(many-to-many) 문제로 return_sequences=True를 설정하여 출력층에 모든 은닉 상태의 값을 보냅니다. RNN이 어떻게 설계되는지 확인해 보겠습니다. 예를 들어 위에서 설명한 데이터 중 첫 번째 데이터에 해당되는 X_train[0]를 가지고 4번의 시점(time steps)까지 RNN을 진행하였을 때의 그림은 다음과 같습니다. 이번 실습에서는 양방향 RNN을 사용할 것이므로 아래의 그림과 같습니다. 12-02 양방향 LSTM를 이용한 품사 태깅(Part-of-speech Tagging using Bi-LSTM) 품사 태깅에 대해서는 이미 텍스트 전처리 챕터에서 토큰화와 함께 언급한 바 있습니다. 그 당시에는 NLTK와 KoNLPy를 이용해서 품사 태깅을 수행하였지만, 여기서는 직접 양방향 LSTM을 이용한 품사 태깅을 수행하는 모델을 만들어봅니다. 1. 품사 태깅 데이터에 대한 이해와 전처리 양방향 LSTM을 이용해서 품사 태깅을 하는 모델을 만들어보겠습니다. import nltk import numpy as np import matplotlib.pyplot as plt from tensorflow.keras.preprocessing.text import Tokenizer from tensorflow.keras.preprocessing.sequence import pad_sequences from tensorflow.keras.utils import to_categorical from sklearn.model_selection import train_test_split NLTK를 이용하면 영어 코퍼스에 토큰화와 품사 태깅 전처리를 진행한 문장 데이터를 받아올 수 있습니다. 해당 데이터를 훈련시켜 품사 태깅을 수행하는 모델을 만들어보겠습니다. 전체 문장 샘플의 개수를 확인합니다. # 토큰화에 품사 태깅이 된 데이터 받아오기 tagged_sentences = nltk.corpus.treebank.tagged_sents() print("품사 태깅이 된 문장 개수: ", len(tagged_sentences)) 품사 태깅이 된 문장 개수: 3914 첫 번째 샘플만 출력해 보겠습니다. print(tagged_sentences[0]) [('Pierre', 'NNP'), ('Vinken', 'NNP'), (',', ','), ('61', 'CD'), ('years', 'NNS'), ('old', 'JJ'), (',', ','), ('will', 'MD'), ('join', 'VB'), ('the', 'DT'), ('board', 'NN'), ('as', 'IN'), ('a', 'DT'), ('nonexecutive', 'JJ'), ('director', 'NN'), ('Nov.', 'NNP'), ('29', 'CD'), ('.', '.')] 품사 태깅 전처리가 수행된 첫 번째 문장이 출력된 것을 볼 수 있습니다. 이러한 문장 샘플이 총 3,914개가 있습니다. 그런데 훈련을 시키려면 훈련 데이터에서 단어에 해당되는 부분과 품사 태깅 정보에 해당되는 부분을 분리시켜야 합니다. 즉, [('Pierre', 'NNP'), ('Vinken', 'NNP')]와 같은 문장 샘플이 있다면 Pierre과 Vinken을 같이 저장하고, NNP와 NNP를 같이 저장할 필요가 있습니다. 이런 경우 파이썬 함수 중에서 zip() 함수가 유용한 역할을 합니다. zip() 함수는 동일한 개수를 가지는 시퀀스 자료형에서 동일한 순서에 등장하는 원소들끼리 묶어주는 역할을 합니다. sentences, pos_tags = [], [] for tagged_sentence in tagged_sentences: # 3,914개의 문장 샘플을 1개씩 불러온다. sentence, tag_info = zip(*tagged_sentence) # 각 샘플에서 단어들은 sentence에 품사 태깅 정보들은 tag_info에 저장한다. sentences.append(list(sentence)) # 각 샘플에서 단어 정보만 저장한다. pos_tags.append(list(tag_info)) # 각 샘플에서 품사 태깅 정보만 저장한다. 각 문장 샘플에 대해서 단어는 sentences에 태깅 정보는 pos_tags에 저장하였습니다. 첫 번째 문장 샘플을 출력해 보겠습니다. print(sentences[0]) print(pos_tags[0]) ['Pierre' 'Vinken' ',' '61' 'years' 'old' ',' 'will' 'join' 'the' 'board' 'as' 'a' 'nonexecutive' 'director' 'Nov.' '29' '.'] ['NNP' 'NNP' ',' 'CD' 'NNS' 'JJ' ',' 'MD' 'VB' 'DT' 'NN' 'IN' 'DT' 'JJ' 'NN' 'NNP' 'CD' '.'] 첫 번째 샘플에 대해서 단어에 대해서 sentences[0]에, 품사에 대해서만 pos_tags[0]에 저장된 것을 볼 수 있습니다. 뒤에서 보겠지만, sentences는 예측을 위한 X에 해당되며 pos_tags는 예측 대상인 y에 해당됩니다. 임의로 8번 인덱스 샘플에 대해서도 확인해 보겠습니다. print(sentences[8]) print(pos_tags[8]) ['We', "'re", 'talking', 'about', 'years', 'ago', 'before', 'anyone', 'heard', 'of', 'asbestos', 'having', 'any', 'questionable', 'properties', '.'] ['PRP', 'VBP', 'VBG', 'IN', 'NNS', 'IN', 'IN', 'NN', 'VBD', 'IN', 'NN', 'VBG', 'DT', 'JJ', 'NNS', '.'] 단어에 대해서만 sentences[8]에, 또한 품사에 대해서만 pos_tags[8]에 저장된 것을 확인할 수 있습니다. 또한 첫 번째 샘플과 길이가 다른 것을 볼 수 있습니다. 사실 3,914개의 문장 샘플의 길이는 전부 제각각입니다. 전체 데이터의 길이 분포를 확인해 봅시다. print('샘플의 최대 길이 : %d' % max(len(l) for l in sentences)) print('샘플의 평균 길이 : %f' % (sum(map(len, sentences))/len(sentences))) plt.hist([len(s) for s in sentences], bins=50) plt.xlabel('length of samples') plt.ylabel('number of samples') plt.show() 샘플의 최대 길이 : 271 샘플의 평균 길이 : 25.722024 위의 그래프는 대부분의 샘플의 길이가 150 이내며 대부분 0~50의 길이를 가지는 것을 보여줍니다. 이제 케라스 토크 나이저를 통해서 정수 인코딩을 진행합니다. 우선 케라스 토크 나이저를 다음과 같이 함수로 구현합니다. def tokenize(samples): tokenizer = Tokenizer() tokenizer.fit_on_texts(samples) return tokenizer 문장 데이터에 대해서는 src_tokenizer를, 레이블에 해당되는 품사 태깅 정보에 대해서는 tar_tokenizer를 사용합니다. src_tokenizer = tokenize(sentences) tar_tokenizer = tokenize(pos_tags) 단어 집합과 품사 태깅 정보 집합의 크기를 확인해 보겠습니다. vocab_size = len(src_tokenizer.word_index) + 1 tag_size = len(tar_tokenizer.word_index) + 1 print('단어 집합의 크기 : {}'.format(vocab_size)) print('태깅 정보 집합의 크기 : {}'.format(tag_size)) 단어 집합의 크기 : 11388 태깅 정보 집합의 크기 : 47 정수 인코딩을 수행합니다. X_train = src_tokenizer.texts_to_sequences(sentences) y_train = tar_tokenizer.texts_to_sequences(pos_tags) 문장 데이터에 대해서 정수 인코딩이 수행된 결과는 X_train, 품사 태깅 데이터에 대해서 정수 인코딩이 수행된 결과는 y_train에 저장되었습니다. 정수 인코딩이 되었는지 확인을 위해 임의로 2번 인덱스 샘플을 출력해 보겠습니다. print(X_train[:2]) print(y_train[:2]) [[5601, 3746, 1, 2024, 86, 331, 1, 46, 2405, 2, 131, 27, 6, 2025, 332, 459, 2026, 3], [31, 3746, 20, 177, 4, 5602, 2915, 1, 2, 2916, 637, 147, 3]] [[3, 3, 8, 10, 6, 7, 8, 21, 13, 4, 1, 2, 4, 7, 1, 3, 10, 9], [3, 3, 17, 1, 2, 3, 3, 8, 4, 3, 19, 1, 9]] 앞서 본 그래프에 따르면, 대부분의 샘플은 길이가 150 이내입니다. X에 해당되는 데이터 X_train의 샘플들과 y에 해당되는 데이터 y_train 샘플들의 모든 길이를 임의로 150 정도로 맞추어 보겠습니다. 케라스의 pad_sequences()를 사용합니다. max_len = 150 X_train = pad_sequences(X_train, padding='post', maxlen=max_len) y_train = pad_sequences(y_train, padding='post', maxlen=max_len) 모든 샘플의 길이가 150이 되었습니다. 훈련 데이터와 테스트 데이터를 8:2의 비율로 분리합니다. X_train, X_test, y_train, y_test = train_test_split(X_train, y_train, test_size=.2, random_state=777) 각 데이터에 대한 크기(shape)를 확인해 보겠습니다. print('훈련 샘플 문장의 크기 : {}'.format(X_train.shape)) print('훈련 샘플 레이블의 크기 : {}'.format(y_train.shape)) print('테스트 샘플 문장의 크기 : {}'.format(X_test.shape)) print('테스트 샘플 레이블의 크기 : {}'.format(y_test.shape)) 훈련 샘플 문장의 크기 : (3131, 150) 훈련 샘플 레이블의 크기 : (3131, 150) 테스트 샘플 문장의 크기 : (783, 150) 테스트 샘플 레이블의 크기 : (783, 150) 2. 양방향 LSTM(Bi-directional LSTM)으로 POS Tagger 만들기 임베딩 벡터의 차원과 LSTM의 은닉 상태의 차원은 128로 지정했습니다. 다대다 문제이므로 LSTM의 return_sequences의 값은 True로 지정하였으며, 양방향 사용을 위해 LSTM을 Bidirectional()로 감싸주었습니다. validation_data로는 테스트 데이터를 기재하여 학습 중간에 테스트 데이터의 정확도를 확인하였습니다. 레이블에 대해서 원-핫 인코딩을 하고 손실 함수를 categorical_crossentropy를 사용할 수도 있겠지만, 만약 레이블에 원-핫 인코딩을 하지 않고 학습을 진행하고자 한다면 손실 함수를 categorical_crossentropy 대신 sparse_categorical_crossentropy를 선택합니다. 여기서는 후자의 방법을 택합니다. from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, LSTM, InputLayer, Bidirectional, TimeDistributed, Embedding from tensorflow.keras.optimizers import Adam embedding_dim = 128 hidden_units = 128 model = Sequential() model.add(Embedding(vocab_size, embedding_dim, mask_zero=True)) model.add(Bidirectional(LSTM(hidden_units, return_sequences=True))) model.add(TimeDistributed(Dense(tag_size, activation=('softmax')))) model.compile(loss='sparse_categorical_crossentropy', optimizer=Adam(0.001), metrics=['accuracy']) model.fit(X_train, y_train, batch_size=128, epochs=7, validation_data=(X_test, y_test)) 총 7번의 에포크를 마치고 나서 테스트 데이터에 대한 정확도를 측정합니다. print("\n 테스트 정확도: %.4f" % (model.evaluate(X_test, y_test)[1])) 25/25 [==============================] - 0s 6ms/step - loss: 0.0720 - accuracy: 0.9016 테스트 정확도: 0.9016 실제로 맞추고 있는지를 특정 테스트 샘플(10번 인덱스)을 통해 확인해 보겠습니다. 정수로부터 단어와 품사 태깅 정보를 리턴하는 index_to_word와 index_to_tag를 만들고 이를 이용하여 실제 값과 예측값을 출력합니다. index_to_word = src_tokenizer.index_word index_to_tag = tar_tokenizer.index_word i = 10 # 확인하고 싶은 테스트용 샘플의 인덱스. y_predicted = model.predict(np.array([X_test[i]])) # 입력한 테스트용 샘플에 대해서 예측값 y를 리턴 y_predicted = np.argmax(y_predicted, axis=-1) # 확률 벡터를 정수 레이블로 변환. print("{:15}|{:5}|{}".format("단어", "실제 값", "예측값")) print(35 * "-") for word, tag, pred in zip(X_test[i], y_test[i], y_predicted[0]): if word != 0: # PAD 값은 제외함. print("{:17}: {:7} {}".format(index_to_word[word], index_to_tag[tag].upper(), index_to_tag[pred].upper())) 단어 |실제 값 |예측값 ----------------------------------- in : IN IN addition : NN NN , : , , buick : NNP NNP is : VBZ VBZ a : DT DT relatively : RB RB respected : VBN VBN nameplate : NN NN among : IN IN american : NNP NNP express : NNP NNP card : NN NN holders : NNS NNS , : , , says : VBZ VBZ 0 : -NONE- -NONE- *t*-1 : -NONE- -NONE- an : DT DT american : NNP NNP express : NNP NNP spokeswoman : NN NN . : . . 12-03 개체명 인식(Named Entity Recognition) 코퍼스로부터 각 개체(entity)의 유형을 인식하는 개체명 인식(Named Entity Recognition)에 대해서 학습합니다. 개체명 인식을 사용하면 코퍼스로부터 어떤 단어가 사람, 장소, 조직 등을 의미하는 단어인지를 찾을 수 있습니다. 1. 개체명 인식(Named Entity Recognition)이란? 개체명 인식(Named Entity Recognition)이란 말 그대로 이름을 가진 개체(named entity)를 인식하겠다는 것을 의미합니다. 좀 더 쉽게 설명하면, 어떤 이름을 의미하는 단어를 보고는 그 단어가 어떤 유형인지를 인식하는 것을 말합니다. 예를 들어 유정이는 2018년에 골드만삭스에 입사했다.라는 문장이 있을 때, 사람(person), 조직(organization), 시간(time)에 대해 개체명 인식을 수행하는 모델이라면 다음과 같은 결과를 보여줍니다. 유정 - 사람 2018년 - 시간 골드만삭스 - 조직 2. NLTK를 이용한 개체명 인식(Named Entity Recognition using NTLK) NLTK에서는 개체명 인식기(NER chunker)를 지원하고 있으므로, 별도 개체명 인식기를 구현할 필요 없이 NLTK를 사용해서 개체명 인식을 수행할 수 있습니다. 만약 아래의 실습에서 nltk.download('maxent_ne_chunker'), nltk.download('words') 등의 설치를 요구하는 에러 문구가 뜬다면, 지시하는 대로 설치하면 됩니다. from nltk import word_tokenize, pos_tag, ne_chunk sentence = "James is working at Disney in London" # 토큰화 후 품사 태깅 tokenized_sentence = pos_tag(word_tokenize(sentence)) print(tokenized_sentence) [('James', 'NNP'), ('is', 'VBZ'), ('working', 'VBG'), ('at', 'IN'), ('Disney', 'NNP'), ('in', 'IN'), ('London', 'NNP')] # 개체명 인식 ner_sentence = ne_chunk(tokenized_sentence) print(ner_sentence) (S (PERSON James/NNP) is/VBZ working/VBG at/IN (ORGANIZATION Disney/NNP) in/IN (GPE London/NNP)) ne_chunk는 개체명을 태깅 하기 위해서 앞서 품사 태깅(pos_tag)이 수행되어야 합니다. 위의 결과에서 James는 PERSON(사람), Disney는 조직(ORGANIZATION), London은 위치(GPE)라고 정상적으로 개체명 인식이 수행된 것을 볼 수 있습니다. 이어서 인공 신경망을 이용하여 개체명 인식 모델을 만들어보겠습니다. 12-04 개체명 인식의 BIO 표현 이해하기 개체명 인식은 챗봇 등에서 필요한 주요 전처리 작업이면서 그 자체로도 까다로운 작업입니다. 도메인 또는 목적에 특화 되도록 개체명 인식을 정확하게 하는 방법 중 하나는 기존에 공개된 개체명 인식기를 사용하는 것이 아니라, 직접 목적에 맞는 데이터를 준비하여 모델을 만드는 것입니다. 양방향 LSTM을 이용해서 개체명 인식기를 만들어봅니다. 1. BIO 표현 개체명 인식에서 코퍼스로부터 개체명을 인식하기 위한 방법으로는 여러 방법이 있지만, 여기서는 가장 보편적인 방법 중 하나인 BIO 태깅 방법을 소개합니다. B는 Begin의 약자로 개체명이 시작되는 부분, I는 Inside의 약자로 개체 명의 내부 부분을 의미하며, O는 Outside의 약자로 개체명이 아닌 부분을 의미합니다. 예를 들어 영화에 대한 코퍼스 중에서 영화 제목에 대한 개체명을 뽑아내고 싶다고 가정합시다. 해 B 리 I 포 I 터 I 보 O 러 O 가 O 자 O 다음과 같이 영화 제목에 대해서만 개체명을 인식하는데, 영화 제목이 시작되는 글자인 '해'에서는 B가 사용되었고, 그리고 영화 제목이 끝나는 순간까지 I가 사용됩니다. 그리고 영화 제목이 아닌 부분에 대해서만 O가 사용됩니다. 이처럼 B와 I는 개체명을 위해 사용되고, O는 개체명이 아니라는 의미를 갖게 됩니다. 물론 개체명 인식이라는 것은 보통 한 종류의 개체에 대해서만 언급하는 것이 아니라 여러 종류의 개체가 있을 수 있습니다. 예를 들어 영화에 대한 대화에서는 영화 제목에 대한 개체명과 극장에 대한 개체명이 있을 수 있습니다. 이 경우 각 개체가 어떤 종류인지도 함께 태깅이 될 것입니다. 해 B-movie 리 I-movie 포 I-movie 터 I-movie 보 O 러 O 메 B-theater 가 I-theater 박 I-theater 스 I-theater 가 O 자 O 2. 개체명 인식 데이터 이해하기 실습을 통해 양방향 LSTM을 이용한 개체명 인식에 대해서 더 자세히 알아보겠습니다. CONLL2003은 개체명 인식을 위한 전통적인 영어 데이터 셋입니다. 여기서 다룰 데이터의 앞 부분을 일부 보겠습니다. EU NNP B-NP B-ORG rejects VBZ B-VP O German JJ B-NP B-MISC call NN I-NP O to TO B-VP O boycott VB I-VP O British JJ B-NP B-MISC lamb NN I-NP O . . O O Peter NNP B-NP B-PER Blackburn NNP I-NP I-PER 데이터의<NAME>은 [단어] [품사 태깅] [청크 태깅] [개체명 태깅]의<NAME>으로 되어있습니다. 품사 태깅이 의미하는 바는 아래 링크에서 자세하게 확인할 수 있는데, 예를 들어서 EU 옆에 붙어있는 NNP는 고유 명사 단수형을 의미하며, rejects 옆에 있는 VBZ는 3인칭 단수 동사 현재형을 의미합니다. 링크 : https://www.ling.upenn.edu/courses/Fall_2003/ling001/penn_treebank_pos.html 개체명 태깅의 경우에는 LOC는 location, ORG는 organization, PER은 person, MISC는 miscellaneous를 의미합니다. 해당 데이터는 BIO 표현 방법을 사용하고 있기 때문에, 개체 명의 시작 부분이면서 Organization을 의미하는 EU에는 B-ORG라는 개체명 태깅이 붙습니다. 다만, EU 그 자체로 개체명 하나이기 때문에 거기서 개체명 인식은 종료되면서 뒤에 I가 별도로 붙는 단어가 나오지는 않았습니다. 이에 EU 뒤에 나오는 call은 개체명이 아니기 때문에 O가 태깅이 됩니다. 또 하나 기억해 두어야 할 것은 9번째 줄인. . O O 다음에 11번째 줄 Peter가 나오는 부분 사이에서 10번째 줄은 공란으로 되어 있는데, 이는 9번째 줄에서 문장이 끝나고 11번째 줄에서 새로운 문장이 시작됨을 의미합니다. 그다음 문장이 시작되는 11번째 줄에서는 개체명이 하나의 단어로 끝나지 않았을 때, 어떻게 다음 단어로 개체명 인식이 이어지는지를 보여줍니다. Peter는 개체명이 시작되면서 person에 해당되기 때문에 B-PER이라는 개체명 태깅이 붙습니다. 그리고 아직 개체명에 대한 인식은 끝나지 않았기 때문에 뒤에 붙는 Blackburn에서는 I가 나오면서 I-PER이 개체명 태깅으로 붙게 됩니다. 즉, Peter Blackburn이 person에 속하는 하나의 개체명입니다. 3. 데이터 전처리하기 import re import numpy as np import matplotlib.pyplot as plt import urllib.request from tensorflow.keras.preprocessing.text import Tokenizer from tensorflow.keras.preprocessing.sequence import pad_sequences from tensorflow.keras.utils import to_categorical from sklearn.model_selection import train_test_split 위에서 설명한 개체명 인식 데이터를 읽어 전처리를 수행합니다. urllib.request.urlretrieve("https://raw.githubusercontent.com/ukairia777/tensorflow-nlp-tutorial/main/12.%20RNN%20Sequence%20Labeling/dataset/train.txt", filename="train.txt") f = open('train.txt', 'r') tagged_sentences = [] sentence = [] for line in f: if len(line)==0 or line.startswith('-DOCSTART') or line[0]=="\n": if len(sentence) > 0: tagged_sentences.append(sentence) sentence = [] continue splits = line.split(' ') # 공백을 기준으로 속성을 구분한다. splits[-1] = re.sub(r'\n', '', splits[-1]) # 줄바꿈 표시 \n을 제거한다. word = splits[0].lower() # 단어들은 소문자로 바꿔서 저장한다. sentence.append([word, splits[-1]]) # 단어와 개체명 태깅만 기록한다. 전체 샘플 개수를 확인해 보겠습니다. print("전체 샘플 개수: ", len(tagged_sentences)) 전체 샘플 개수 : 14041 이 중 첫 번째 샘플만 출력해 보겠습니다. print('첫 번째 샘플 :',tagged_sentences[0]) 첫 번째 샘플 : [['eu', 'B-ORG'], ['rejects', 'O'], ['german', 'B-MISC'], ['call', 'O'], ['to', 'O'], ['boycott', 'O'], ['british', 'B-MISC'], ['lamb', 'O'], ['.', 'O']] 위와 같은 샘플이 총 14,041개가 있습니다. 훈련을 시키려면 훈련 데이터에서 단어에 해당되는 부분과 개체명 태깅 정보에 해당되는 부분을 분리시켜야 합니다. 즉, [('eu', 'B-ORG'), ('rejects', 'O')]와 같은 문장 샘플이 있다면 eu와 rejects는 같이 저장하고, B-ORG와 O를 같이 저장할 필요가 있습니다. 이 경우 파이썬 함수 중에서 zip() 함수가 유용한 역할을 합니다. zip() 함수는 동일한 개수를 가지는 시퀀스 자료형에서 각 순서에 등장하는 원소들끼리 묶어주는 역할을 합니다. sentences, ner_tags = [], [] for tagged_sentence in tagged_sentences: # 14,041개의 문장 샘플을 1개씩 불러온다. sentence, tag_info = zip(*tagged_sentence) # 각 샘플에서 단어들은 sentence에 개체명 태깅 정보들은 tag_info에 저장. sentences.append(list(sentence)) # 각 샘플에서 단어 정보만 저장한다. ner_tags.append(list(tag_info)) # 각 샘플에서 개체명 태깅 정보만 저장한다. 각 문장 샘플에 대해서 단어는 sentences에 태깅 정보는 ner_tags에 저장하였습니다. 임의로 첫 번째 샘플을 출력해 보겠습니다. print('첫 번째 샘플의 문장 :',sentences[0]) print('첫 번째 샘플의 레이블 :',ner_tags[0]) 첫 번째 샘플의 문장 : ['eu', 'rejects', 'german', 'call', 'to', 'boycott', 'british', 'lamb', '.'] 첫 번째 샘플의 레이블 : ['B-ORG', 'O', 'B-MISC', 'O', 'O', 'O', 'B-MISC', 'O', 'O'] 첫 번째 샘플에 대해서 단어에 대해서만 sentences[0]에 저장되었으며 개체명에 대해서만 ner_tags[0]에 저장된 것을 볼 수 있습니다. 뒤에서 보겠지만, sentences는 예측을 위한 X에 해당되며 ner_tags는 예측 대상인 y에 해당됩니다. 다른 샘플들도 확인하기 위해 임의로 12번 인덱스 샘플에 대해서도 확인해 보겠습니다. print(sentences[12]) print(ner_tags[12]) ['only', 'france', 'and', 'britain', 'backed', 'fischler', "'s", 'proposal', '.'] ['O', 'B-LOC', 'O', 'B-LOC', 'O', 'B-PER', 'O', 'O', 'O'] 단어에 대해서만 sentences[12]에, 또한 개체명에 대해서만 ner_tags[12]에 저장되었습니다. 또한 첫 번째 샘플과 길이가 다른 것을 볼 수 있습니다. 사실 14,041개의 문장 샘플의 길이는 전부 제각각입니다. 전체 데이터의 길이 분포를 확인해 봅시다. print('샘플의 최대 길이 : %d' % max(len(sentence) for sentence in sentences)) print('샘플의 평균 길이 : %f' % (sum(map(len, sentences))/len(sentences))) plt.hist([len(sentence) for sentence in sentences], bins=50) plt.xlabel('length of samples') plt.ylabel('number of samples') plt.show() 샘플의 최대 길이 : 113 샘플의 평균 길이 : 14.501887 위의 그래프는 샘플들의 길이가 대체적으로 0~40의 길이를 가지며, 특히 0~20의 길이를 가진 샘플이 상당한 비율을 차지하는 것을 보여줍니다. 길이가 가장 긴 샘플의 길이는 113입니다. 케라스 토크 나이저를 통해서 정수 인코딩을 진행합니다. 이번에는 문장 데이터에 있는 모든 단어를 사용하지 않고 높은 빈도수를 가진 상위 약 4,000개의 단어만을 사용합니다. vocab_size = 4000 src_tokenizer = Tokenizer(num_words=vocab_size, oov_token='OOV') src_tokenizer.fit_on_texts(sentences) tar_tokenizer = Tokenizer() tar_tokenizer.fit_on_texts(ner_tags) 문장 데이터에 대해서는 src_tokenizer를, 레이블에 해당되는 개체명 태깅 정보에 대해서는 tar_tokenizer를 사용합니다. tag_size = len(tar_tokenizer.word_index) + 1 print('단어 집합의 크기 : {}'.format(vocab_size)) print('개체명 태깅 정보 집합의 크기 : {}'.format(tag_size)) 단어 집합의 크기 : 4000 개체명 태깅 정보 집합의 크기 : 10 정수 인코딩을 수행합니다. X_train = src_tokenizer.texts_to_sequences(sentences) y_train = tar_tokenizer.texts_to_sequences(ner_tags) 문장 데이터에 대해서 정수 인코딩이 수행된 결과는 X_train, 개체명 태깅 데이터에 대해서 정수 인코딩이 수행된 결과는 y_train에 저장되었습니다. 정수 인코딩이 되었는지 확인을 위해 임의로 첫 번째 샘플을 출력해 보겠습니다. print('첫 번째 샘플의 문장 :',X_train[0]) print('첫 번째 샘플의 레이블 :',y_train[0]) 첫 번째 샘플의 문장 : [989, 1, 205, 629, 7, 3939, 216, 1, 3] 첫 번째 샘플의 레이블 : [4, 1, 7, 1, 1, 1, 7, 1, 1] 현재 문장 데이터에 대해서는 일부 단어가 'OOV'로 대체된 상황입니다. 이를 확인하기 위해 디코딩 작업을 진행해 봅시다. 이를 위해 정수로부터 단어로 변환하는 index_to_word를 만듭니다. index_to_word = src_tokenizer.index_word index_to_ner = tar_tokenizer.index_word 정수 인코딩 된 첫 번째 문장을 다시 디코딩 해보겠습니다. decoded = [] for index in X_train[0] : # 첫 번째 샘플 안의 각 정수로 변환된 단어에 대해서 decoded.append(index_to_word[index]) # 단어로 변환 print('기존 문장 : {}'.format(sentences[0])) print('빈도수가 낮은 단어가 OOV 처리된 문장 : {}'.format(decoded)) 기존 문장 : ['eu', 'rejects', 'german', 'call', 'to', 'boycott', 'british', 'lamb', '.'] 빈도수가 낮은 단어가 OOV 처리된 문장 : ['eu', 'OOV', 'german', 'call', 'to', 'boycott', 'british', 'OOV', '.'] 일부 단어가 'OOV'로 대체되었습니다. 앞서 본 그래프에 따르면, 대부분의 샘플은 길이가 70 이내입니다. X에 해당되는 데이터 X_train의 샘플들과 y에 해당되는 데이터 y_train 샘플들의 모든 길이를 임의로 70 정도로 맞추어 보겠습니다. 패딩을 진행합니다. max_len = 70 X_train = pad_sequences(X_train, padding='post', maxlen=max_len) y_train = pad_sequences(y_train, padding='post', maxlen=max_len) 모든 샘플의 길이가 70이 되었습니다. 훈련 데이터와 테스트 데이터를 8:2의 비율로 분리합니다. X_train, X_test, y_train, y_test = train_test_split(X_train, y_train, test_size=.2, random_state=777) 레이블에 해당하는 태깅 정보에 대해서 원-핫 인코딩을 수행합니다. y_train = to_categorical(y_train, num_classes=tag_size) y_test = to_categorical(y_test, num_classes=tag_size) 각 데이터에 대한 크기(shape)를 확인해 보겠습니다. print('훈련 샘플 문장의 크기 : {}'.format(X_train.shape)) print('훈련 샘플 레이블의 크기 : {}'.format(y_train.shape)) print('테스트 샘플 문장의 크기 : {}'.format(X_test.shape)) print('테스트 샘플 레이블의 크기 : {}'.format(y_test.shape)) 훈련 샘플 문장의 크기 : (11232, 70) 훈련 샘플 레이블의 크기 : (11232, 70, 10) 테스트 샘플 문장의 크기 : (2809, 70) 테스트 샘플 레이블의 크기 : (2809, 70, 10) 4. 양방향 LSTM(Bi-directional LSTM)으로 개체명 인식기 만들기 하이퍼 파라미터인 임베딩 벡터의 차원은 128, 은닉 상태의 크기는 128입니다. 모델은 다 대다 구조의 LSTM을 사용합니다. 이 경우 LSTM의 return_sequences의 인자 값은 True로 주어야만 합니다. 이번 실습과 같이 각 데이터의 길이가 달라서 패딩을 하느라 숫자 0이 많아질 경우에는 Embedding()에 mask_zero=True를 설정하여 숫자 0은 연산에서 제외한다는 옵션을 줄 수 있습니다. 출력층에 TimeDistributed()를 사용했는데, TimeDistributed()는 LSTM을 다 대다 구조로 사용하여 LSTM의 모든 시점에 대해서 출력층을 사용할 필요가 있을 때 사용합니다. 해당 모델은 모든 시점에 대해서 개체명 레이블 개수만큼의 선택지 중 하나를 예측하는 다중 클래스 분류 문제를 수행하는 모델입니다. 다중 클래스 분류 문제의 경우, 출력층에 소프트맥스 회귀를 사용해야 하므로 활성화 함수로는 소프트맥스 함수를 사용하고, 손실 함수로 크로스 엔트로피 함수를 사용합니다. 하이퍼 파라미터인 배치 크기는 128이며, 8 에포크를 수행합니다. validation_data로 테스트 데이터를 선택하여 학습하는 동안 테스트 데이터에 대한 정확도를 확인합니다. from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Embedding, LSTM, Bidirectional, TimeDistributed from tensorflow.keras.optimizers import Adam embedding_dim = 128 hidden_units = 128 model = Sequential() model.add(Embedding(input_dim=vocab_size, output_dim=embedding_dim, input_length=max_len, mask_zero=True)) model.add(Bidirectional(LSTM(hidden_units, return_sequences=True))) model.add(TimeDistributed(Dense(tag_size, activation='softmax'))) model.compile(loss='categorical_crossentropy', optimizer=Adam(0.001), metrics=['accuracy']) model.fit(X_train, y_train, batch_size=128, epochs=8, validation_data=(X_test, y_test)) 학습이 종료되었다면 테스트 데이터에 대한 정확도를 측정합니다. print("\n 테스트 정확도: %.4f" % (model.evaluate(X_test, y_test)[1])) 2809/2809 [==============================] - 9s 3ms/step 테스트 정확도: 0.9573 실제로 맞추고 있는지를 임의의 테스트 샘플로부터(인덱스 10번) 직접 실제 값과 비교해 보겠습니다. index_to_word와 index_to_ner를 사용하여 테스트 데이터에 대한 예측값과 실제 값을 비교 출력합니다. i = 10 # 확인하고 싶은 테스트용 샘플의 인덱스. # 입력한 테스트용 샘플에 대해서 예측 y를 리턴 y_predicted = model.predict(np.array([X_test[i]])) # 확률 벡터를 정수 레이블로 변경. y_predicted = np.argmax(y_predicted, axis=-1) # 원-핫 벡터를 정수 인코딩으로 변경. labels = np.argmax(y_test[i], -1) print("{:15}|{:5}|{}".format("단어", "실제 값", "예측값")) print(35 * "-") for word, tag, pred in zip(X_test[i], labels, y_predicted[0]): if word != 0: # PAD 값은 제외함. print("{:17}: {:7} {}".format(index_to_word[word], index_to_ner[tag].upper(), index_to_ner[pred].upper())) 단어 |실제 값 |예측값 ----------------------------------- sarah : B-PER B-PER brady : I-PER I-PER , : O O whose : O O republican : B-MISC B-MISC husband : O O was : O O OOV : O O OOV : O O in : O O an : O O OOV : O O attempt : O O on : O O president : O O ronald : B-PER B-PER reagan : I-PER I-PER , : O O took : O O centre : O O stage : O O at : O O the : O O democratic : B-MISC B-MISC national : I-MISC I-MISC convention : I-MISC I-MISC on : O O monday : O O night : O O to : O O OOV : O O president : O O bill : B-PER B-PER clinton : I-PER I-PER 's : O O gun : O O control : O O efforts : O O . : O O 정확도를 계산하고, 테스트용 샘플에 대해서 예측한 개체 명도 출력해 보았습니다. 사실 이번에 사용한 정확도 측정 방법이 그다지 적절하지는 않았는데, 대부분의 단어가 개체명이 아니라는 'O'가 태깅 된 상황에서 정확도가 수많은 'O'로 인해 결정되고 있기 때문입니다. 이를 해결하기 위해서 다음 실습에서 F1-score를 도입해 보겠습니다. 12-05 BiLSTM을 이용한 개체명 인식(Named Entity Recognition, NER) 양방향 LSTM을 이용하여 개체명 인식기를 만든 후에 F1-score를 사용하여 모델을 평가합니다. 1. 개체명 인식 데이터에 대한 이해와 전처리 앞서 사용한 데이터와는 다른 데이터를 사용하여 개체명 인식을 수행해 보겠습니다. 데이터는 아래의 링크에서 다운로드합니다. 링크 : https://www.kaggle.com/abhinavwalia95/entity-annotated-corpus import pandas as pd import numpy as np import matplotlib.pyplot as plt import urllib.request from tensorflow.keras.preprocessing.text import Tokenizer from tensorflow.keras.preprocessing.sequence import pad_sequences from sklearn.model_selection import train_test_split from tensorflow.keras.utils import to_categorical urllib.request.urlretrieve("https://raw.githubusercontent.com/ukairia777/tensorflow-nlp-tutorial/main/12.%20Sequence%20Labeling/dataset/ner_dataset.csv", filename="ner_dataset.csv") data = pd.read_csv("ner_dataset.csv", encoding="latin1") data[:5] 데이터의<NAME>을 이해해 봅시다. 첫 번째 열 'Sentence :#'은 다음과 같은 패턴을 가지고 있습니다. Sentence: 1이 등장하고 Null 값이 이어지다가 다시 Sentence: 2가 등장하고 다시 Null 값이 이어지다가 Sentence: 3이 등장하고 다시 Null 값이 이어지다가를 반복합니다. 사실 이는 하나의 문장을 여러 행으로 나눠놓은 것입니다. 숫자 값을 t라고 합시다. 첫 번째 Sentence: t부터 Null 값이 나오다가 Sentence: t+1이 나오기 전까지의 모든 행은 기존에 하나의 문장이었습니다. t 번째 문장을 단어 토큰화 후 각 행으로 나눠놓은 데이터이기 때문입니다. 뒤에서 Pandas의 fillna를 통해 하나로 묶는 작업을 해줍니다. print('데이터프레임 행의 개수 : {}'.format(len(data))) 데이터프레임 행의 개수 : 1048575 현재 data의 행의 개수는 1,048,575개입니다. 하지만 뒤에서 문장 1개를 다수의 행들로 나누어 놓은 것을 다시 1개의 행으로 병합하는 작업을 해야 하기 때문에 최종 샘플의 개수는 이보다 줄어들게 됩니다. 결측값 유무를 살펴봅시다. print('데이터에 Null 값이 있는지 유무 : ' + str(data.isnull().values.any())) 데이터에 Null 값이 있는지 유무 : True Sentence #열에 Null 값들이 존재하고 있어 isnull().values.any()를 수행하였을 때 True가 나옵니다. isnull().sum()을 수행하면 각 열마다의 Null 값의 개수를 보여줍니다. print('어떤 열에 Null 값이 있는지 출력') print('==============================') data.isnull().sum() 어떤 열에 Null 값이 있는지 출력 ============================== Sentence # 1000616 Word 0 POS 0 Tag 0 dtype: int64 다른 열은 0개인데 오직 Sentences #열에서만 1,000,616개가 나온 것을 볼 수 있습니다. 전체 데이터에서 중복을 허용하지 않고 유일한 값의 개수를 셀 수 있게 해주는 nunique()를 사용해 봅시다. print('sentence # 열의 중복을 제거한 값의 개수 : {}'.format(data['Sentence #'].nunique())) print('Word 열의 중복을 제거한 값의 개수 : {}'.format(data.Word.nunique())) print('Tag 열의 중복을 제거한 값의 개수 : {}'.format(data.Tag.nunique())) sentence # 열의 중복을 제거한 값의 개수 : 47959 Word 열의 중복을 제거한 값의 개수 : 35178 Tag 열의 중복을 제거한 값의 개수 : 17 이 데이터에는 47,959개의 문장이 있으며 문장들은 35,178개의 단어를 가지고 17개 종류의 개체명 태깅을 가집니다. 17개의 개체명 태깅이 전체 데이터에서 몇 개가 있는지, 개체명 태깅 개수의 분포를 확인해 보도록 하겠습니다. print('Tag 열의 각각의 값의 개수 카운트') print('================================') print(data.groupby('Tag').size().reset_index(name='count')) Tag 열의 각각의 값의 개수 카운트 ================================ Tag count 0 B-art 402 1 B-eve 308 2 B-geo 37644 3 B-gpe 15870 4 B-nat 201 5 B-org 20143 6 B-per 16990 7 B-tim 20333 8 I-art 297 9 I-eve 253 10 I-geo 7414 11 I-gpe 198 12 I-nat 51 13 I-org 16784 14 I-per 17251 15 I-tim 6528 16 O 887908 BIO 표현 방법에서 아무런 태깅도 의미하지 않는 O가 가장 887,908개로 가장 많은 개수를 차지함을 볼 수 있습니다. 데이터를 원하는 형태로 가공해 보겠습니다. 우선 Null 값을 제거합니다. Pandas의 fillna(method='ffill')는 Null 값을 가진 행의 바로 앞의 행의 값으로 Null 값을 채우는 작업을 수행합니다. t 번째 문장에 속하면서 Null 값을 가진 샘플들은 전부 첫 번째 열에 Sentence: t의 값이 들어갑니다. 이번에는 뒤의 5개의 샘플을 출력해서 정상적으로 수행되었는지 확인해 봅시다. data = data.fillna(method="ffill") print(data.tail()) Sentence # Word POS Tag 1048570 Sentence: 47959 they PRP O 1048571 Sentence: 47959 responded VBD O 1048572 Sentence: 47959 to TO O 1048573 Sentence: 47959 the DT O 1048574 Sentence: 47959 attack NN O 뒤의 5개 샘플의 첫 번째 열이 Sentence: 47959로 채워졌습니다. 이는 47,959번째 문장임을 의미하며, Null 값을 가진 행들의 바로 앞 행의 Sentence # 열의 값이 Sentence: 47959이었음을 의미합니다. 전체 데이터에 Null 값이 존재하는지 확인해 봅시다. print('데이터에 Null 값이 있는지 유무 : ' + str(data.isnull().values.any())) 데이터에 Null 값이 있는지 유무 : False 없는 것으로 나옵니다. 모든 단어를 소문자화하여 단어의 개수를 줄여보겠습니다. data['Word'] = data['Word'].str.lower() print('Word 열의 중복을 제거한 값의 개수 : {}'.format(data.Word.nunique())) Word 열의 중복을 제거한 값의 개수 : 31817 정상적으로 소문자 화가 되었는지 앞의 샘플 5개만 출력해 보겠습니다. print(data[:5]) Sentence # Word POS Tag 0 Sentence: 1 thousands NNS O 1 Sentence: 1 of IN O 2 Sentence: 1 demonstrators NNS O 3 Sentence: 1 have VBP O 4 Sentence: 1 marched VBN O 하나의 문장에 등장한 단어와 개체명 태깅 정보끼리 쌍(pair)으로 묶는 작업을 수행합니다. func = lambda temp: [(w, t) for w, t in zip(temp["Word"].values.tolist(), temp["Tag"].values.tolist())] tagged_sentences=[t for t in data.groupby("Sentence #").apply(func)] print("전체 샘플 개수: {}".format(len(tagged_sentences))) 전체 샘플 개수: 47959 1,000,616개의 행의 개수가 각 문장당 하나의 샘플로 묶이면서 47,959개의 샘플이 되었습니다. 정상적으로 수행되었는지 첫 번째 샘플을 출력해 봅시다. print(tagged_sentences[0]) # 첫 번째 샘플 출력 [('thousands', 'O'), ('of', 'O'), ('demonstrators', 'O'), ('have', 'O'), ('marched', 'O'), ('through', 'O'), ('london', 'B-geo'), ('to', 'O'), ('protest', 'O'), ('the', 'O'), ('war', 'O'), ('in', 'O'), ('iraq', 'B-geo'), ('and', 'O'), ('demand', 'O'), ('the', 'O'), ('withdrawal', 'O'), ('of', 'O'), ('british', 'B-gpe'), ('troops', 'O'), ('from', 'O'), ('that', 'O'), ('country', 'O'), ('.', 'O')] 전처리가 수행된 첫 번째 샘플이 출력됩니다. 이러한 샘플이 총 47,959개가 있습니다. 그런데 훈련을 시키려면 훈련 데이터에서 단어에 해당되는 부분과 개체명 태깅 정보에 해당되는 부분을 분리시켜야 합니다. 즉, [('thousands', 'O'), ('of', 'O')]와 같은 문장 샘플이 있다면 thousands와 of는 같이 저장하고, O와 O를 같이 저장할 필요가 있습니다. 동일한 개수를 가지는 시퀀스 자료형에서 각 순서에 등장하는 원소들끼리 묶어주는 역할을 하는 zip()을 사용하여 단어와 개체명 태깅 정보를 분리해 봅시다. sentences, ner_tags = [], [] for tagged_sentence in tagged_sentences: # 47,959개의 문장 샘플을 1개씩 불러온다. # 각 샘플에서 단어들은 sentence에 개체명 태깅 정보들은 tag_info에 저장. sentence, tag_info = zip(*tagged_sentence) sentences.append(list(sentence)) # 각 샘플에서 단어 정보만 저장한다. ner_tags.append(list(tag_info)) # 각 샘플에서 개체명 태깅 정보만 저장한다. 각 문장 샘플에서 단어는 sentences에 태깅 정보는 ner_tags에 저장하였습니다. 임의로 첫 번째 문장 샘플을 출력해 보겠습니다. print(sentences[0]) print(ner_tags[0]) ['thousands', 'of', 'demonstrators', 'have', 'marched', 'through', 'london', 'to', 'protest', 'the', 'war', 'in', 'iraq', 'and', 'demand', 'the', 'withdrawal', 'of', 'british', 'troops', 'from', 'that', 'country', '.'] ['O', 'O', 'O', 'O', 'O', 'O', 'B-geo', 'O', 'O', 'O', 'O', 'O', 'B-geo', 'O', 'O', 'O', 'O', 'O', 'B-gpe', 'O', 'O', 'O', 'O', 'O'] 첫 번째 샘플에 대해서 단어에 대해서만 sentences[0]에, 또한 개체명에 대해서만 ner_tags[0]에 저장된 것을 볼 수 있습니다. 뒤에서 보겠지만, sentences는 예측을 위한 X에 해당되며 ner_tags는 예측 대상인 y에 해당됩니다. 다른 샘플들에 대해서도 처리가 되었는지 확인하기 위해 임의로 98번 인덱스의 샘플에 대해서도 확인해 보겠습니다. print(sentences[98]) print(ner_tags[98]) ['she', 'had', 'once', 'received', 'a', 'kidney', 'transplant', '.'] ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'] 단어에 대해서만 sentences[98]에, 또한 개체명에 대해서만 ner_tags[98]에 저장된 것을 확인할 수 있습니다. 또한 첫 번째 샘플과 길이가 다릅니다. 47,959개의 문장 샘플의 길이는 서로 다를 수 있습니다. 전체 데이터의 길이 분포를 확인해 봅시다. print('샘플의 최대 길이 : %d' % max(len(l) for l in sentences)) print('샘플의 평균 길이 : %f' % (sum(map(len, sentences))/len(sentences))) plt.hist([len(s) for s in sentences], bins=50) plt.xlabel('length of samples') plt.ylabel('number of samples') plt.show() 샘플의 최대 길이 : 104 샘플의 평균 길이 : 21.863987989741236 위의 그래프는 샘플들의 길이가 대체적으로 0~40의 길이를 가지는 것을 보여줍니다. 길이가 가장 긴 샘플의 길이는 104입니다. 케라스 토크 나이저를 통해서 정수 인코딩을 진행합니다. 이번에는 문장 데이터에 있는 모든 단어를 사용하겠습니다. # 모든 단어를 사용하며 인덱스 1에는 단어 'OOV'를 할당. src_tokenizer = Tokenizer(oov_token='OOV') # 태깅 정보들은 내부적으로 대문자를<NAME> 채 저장 tar_tokenizer = Tokenizer(lower=False) src_tokenizer.fit_on_texts(sentences) tar_tokenizer.fit_on_texts(ner_tags) 문장 데이터에 대해서는 src_tokenizer를, 레이블에 해당되는 개체명 태깅 정보에 대해서는 tar_tokenizer를 사용합니다. vocab_size = len(src_tokenizer.word_index) + 1 tag_size = len(tar_tokenizer.word_index) + 1 print('단어 집합의 크기 : {}'.format(vocab_size)) print('개체명 태깅 정보 집합의 크기 : {}'.format(tag_size)) 단어 집합의 크기 : 31819 개체명 태깅 정보 집합의 크기 : 18 앞서 src_tokenizer를 만들 때 Tokenizer의 인자로 oov_token='OOV'를 선택했습니다. 인덱스 1에 단어 'OOV'가 할당됩니다. print('단어 OOV의 인덱스 : {}'.format(src_tokenizer.word_index['OOV'])) 단어 OOV의 인덱스 : 1 정수 인코딩을 수행합니다. X_data = src_tokenizer.texts_to_sequences(sentences) y_data = tar_tokenizer.texts_to_sequences(ner_tags) 문장 데이터에 대해서 정수 인코딩이 수행된 결과는 X_data, 개체명 태깅 데이터에 대해서 정수 인코딩이 수행된 결과는 y_data에 저장되었습니다. 정수 인코딩이 되었는지 확인을 위해 임의로 첫 번째 샘플을 출력해 보겠습니다. print(X_data[0]) print(y_data[0]) [254, 6, 967, 16, 1795, 238, 468, 7, 523, 2, 129, 5, 61, 9, 571, 2, 833, 6, 186, 90, 22, 15, 56, 3] [1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 8, 1, 1, 1, 1, 1] 모델 훈련 후 결과 확인을 위해 인덱스로부터 단어를 리턴하는 index_to_word와 인덱스로부터 개체명 태깅 정보를 리턴하는 index_to_ner를 만듭니다. 인덱스 0은 'PAD'란 단어를 할당해둡니다. index_to_ner은 개수가 적으니 출력해 봅시다. word_to_index = src_tokenizer.word_index index_to_word = src_tokenizer.index_word ner_to_index = tar_tokenizer.word_index index_to_ner = tar_tokenizer.index_word index_to_ner[0] = 'PAD' print(index_to_ner) {1: 'O', 2: 'B-geo', 3: 'B-tim', 4: 'B-org', 5: 'I-per', 6: 'B-per', 7: 'I-org', 8: 'B-gpe', 9: 'I-geo', 10: 'I-tim', 11: 'B-art', 12: 'B-eve', 13: 'I-art', 14: 'I-eve', 15: 'B-nat', 16: 'I-gpe', 17: 'I-nat', 0: 'PAD'} index_to_word를 통해 첫 번째 샘플의 정수 시퀀스를 텍스트 시퀀스로 변환하는 디코딩 작업을 해보겠습니다. decoded = [] for index in X_data[0] : # 첫 번째 샘플 안의 인덱스들에 대해서 decoded.append(index_to_word[index]) # 다시 단어로 변환 print('기존의 문장 : {}'.format(sentences[0])) print('디코딩 문장 : {}'.format(decoded)) 기존의 문장 : ['thousands', 'of', 'demonstrators', 'have', 'marched', 'through', 'london', 'to', 'protest', 'the', 'war', 'in', 'iraq', 'and', 'demand', 'the', 'withdrawal', 'of', 'british', 'troops', 'from', 'that', 'country', '.'] 디코딩 문장 : ['thousands', 'of', 'demonstrators', 'have', 'marched', 'through', 'london', 'to', 'protest', 'the', 'war', 'in', 'iraq', 'and', 'demand', 'the', 'withdrawal', 'of', 'british', 'troops', 'from', 'that', 'country', '.'] X 데이터와 y 데이터가 구성되었습니다. 패딩 작업을 진행해 봅시다. 앞서 확인하였듯이 대부분의 데이터의 길이는 40~60에 분포돼 있습니다. 그러므로 가장 긴 샘플의 길이인 104가 아니라 70 정도로 max_len을 정해보겠습니다. max_len = 70 X_data = pad_sequences(X_data, padding='post', maxlen=max_len) y_data = pad_sequences(y_data, padding='post', maxlen=max_len) 모든 샘플의 길이가 70이 되었습니다. 훈련 데이터와 테스트 데이터를 8:2의 비율로 분리합니다. X_train, X_test, y_train_int, y_test_int = train_test_split(X_data, y_data, test_size=.2, random_state=777) 레이블에 해당하는 태깅 정보에 대해서 원-핫 인코딩을 수행합니다. y_train = to_categorical(y_train_int, num_classes=tag_size) y_test = to_categorical(y_test_int, num_classes=tag_size) 각 데이터 크기를 확인해 보겠습니다. print('훈련 샘플 문장의 크기 : {}'.format(X_train.shape)) print('훈련 샘플 레이블(정수 인코딩)의 크기 : {}'.format(y_train_int.shape)) print('훈련 샘플 레이블(원-핫 인코딩)의 크기 : {}'.format(y_train.shape)) print('테스트 샘플 문장의 크기 : {}'.format(X_test.shape)) print('테스트 샘플 레이블(정수 인코딩)의 크기 : {}'.format(y_test_int.shape)) print('테스트 샘플 레이블(원-핫 인코딩)의 크기 : {}'.format(y_test.shape)) 훈련 샘플 문장의 크기 : (38367, 70) 훈련 샘플 레이블(정수 인코딩)의 크기 : (38367, 70) 훈련 샘플 레이블(원-핫 인코딩)의 크기 : (38367, 70, 18) 테스트 샘플 문장의 크기 : (9592, 70) 테스트 샘플 레이블(정수 인코딩)의 크기 : (9592, 70) 테스트 샘플 레이블(원-핫 인코딩)의 크기 : (9592, 70, 18) 2. 양방향 LSTM을 이용한 개체명 인식 하이퍼 파라미터인 임베딩 벡터의 차원은 128, 은닉 상태의 크기는 256입니다. 모델은 다 대다 구조의 양방향 LSTM을 사용합니다. 이 경우 LSTM의 return_sequences의 인자 값은 True로 주어야만 합니다. 이번 실습과 같이 각 데이터의 길이가 달라서 패딩을 하느라 숫자 0이 많아질 경우에는 Embedding()에 mask_zero=True를 설정하여 숫자 0은 연산에서 제외한다는 옵션을 줄 수 있습니다. 출력층에 TimeDistributed()를 사용했는데, TimeDistributed()는 LSTM을 다 대다 구조로 사용하여 LSTM의 모든 시점에 대해서 출력층을 사용할 필요가 있을 때 사용합니다. 해당 모델은 모든 시점에 대해서 개체명 레이블 개수만큼의 선택지 중 하나를 예측하는 다중 클래스 분류 문제를 수행하는 모델입니다. 다중 클래스 분류 문제의 경우, 출력층에 소프트맥스 회귀를 사용해야 하므로 활성화 함수로는 소프트맥스 함수를 사용하고, 손실 함수로 크로스 엔트로피 함수를 사용합니다. 하이퍼 파라미터인 배치 크기는 128이며, 6 에포크를 수행합니다. validation_split=0.1을 사용하여 훈련 데이터의 10%를 검증 데이터로 분리해서 사용하고, 검증 데이터를 통해서 훈련이 적절히 되고 있는지 확인합니다. 검증 데이터는 기계가 훈련 데이터에 과적합되고 있지는 않은지 확인하기 위한 용도로 사용됩니다. from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, LSTM, InputLayer, Bidirectional, TimeDistributed, Embedding from tensorflow.keras.optimizers import Adam embedding_dim = 128 hidden_units = 256 model = Sequential() model.add(Embedding(vocab_size, embedding_dim, mask_zero=True)) model.add(Bidirectional(LSTM(hidden_units, return_sequences=True))) model.add(TimeDistributed(Dense(tag_size, activation=('softmax')))) model.compile(loss='categorical_crossentropy', optimizer=Adam(0.001), metrics=['accuracy']) history = model.fit(X_train, y_train, batch_size=128, epochs=6, validation_split=0.1) 검증 데이터에 대해서 약 95%의 정확도를 얻습니다. 테스트 데이터의 임의의 인덱스 13번 샘플에 대해서 실제 값과 예측값을 비교해 봅시다. i = 13 # 확인하고 싶은 테스트용 샘플의 인덱스. y_predicted = model.predict(np.array([X_test[i]])) # 입력한 테스트용 샘플에 대해서 예측 y를 리턴 y_predicted = np.argmax(y_predicted, axis=-1) # 확률 벡터를 정수 인코딩으로 변경함. labels = np.argmax(y_test[i], -1) # 원-핫 인코딩을 다시 정수 인코딩으로 변경함. print("{:15}|{:5}|{}".format("단어", "실제 값", "예측값")) print(35 * "-") for word, tag, pred in zip(X_test[i], labels, y_predicted[0]): if word != 0: # PAD 값은 제외함. print("{:17}: {:7} {}".format(index_to_word[word], index_to_ner[tag], index_to_ner[pred])) 단어 |실제 값 |예측값 ----------------------------------- the : O O statement : O O came : O O as : O O u.n. : B-org B-org secretary-general: I-org I-org kofi : B-per B-per annan : I-per I-per met : O O with : O O officials : O O in : O O amman : B-geo B-geo to : O O discuss : O O wednesday : B-tim B-tim 's : O O attacks : O O . : O O 정확하게 예측했습니다. F1-score라는 성능 평가 방법에 대해서 이해하고, 테스트 데이터에 대해서 성능을 측정해 봅시다. 3. F1-score 개체명 인식에서는 그 어떤 개체도 아니라는 의미의 'O'라는 태깅이 존재합니다. 그런데 이런 정보는 보통 대다수의 레이블을 차지하기 때문에 기존에 사용했던 정확도(accuracy)를 평가 방법으로 사용하는 것이 적절하지 않을 수 있습니다. 예를 들어 모델이 단 1개의 개체도 맞추지 못하고 전부 'O'로 예상했을 경우를 봅시다. 실제 값은 위에서 출력했던 값을 실제 값으로 재사용하겠습니다. 아래 코드에서는 labels라는 변수에 저장하였습니다. 그리고 개체를 하나도 맞추지 못했다는 가정하에 전부 'O'로만 채워진 예측값 predicted를 생성합니다. labels = ['B-PER', 'I-PER', 'O', 'O', 'B-MISC', 'O','O','O','O','O','O','O','O','O','O','B-PER','I-PER','O','O','O','O','O','O','B-MISC','I-MISC','I-MISC','O','O','O','O','O','O','B-PER','I-PER','O','O','O','O','O'] predicted = ['O'] * len(labels) print('예측값 :',predicted) 예측값 : ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'] 실제로는 PER, MISC, PER, MISC, PER이라는 총 5개의 개체가 존재함에도 불구하고 예측값인 predicted는 단 1개의 개체도 맞추지 못한 상황을 시뮬레이션하는 것입니다. 이에 대한 정확도를 계산해 봅시다. hit = 0 # 정답 개수 for tag, pred in zip(labels, predicted): if tag == pred: hit +=1 # 정답인 경우에만 +1 accuracy = hit/len(labels) # 정답 개수를 총개수로 나눈다. print("정확도: {:.1%}".format(accuracy)) 정확도: 74.4% 실제 값에서도 대부분의 값이 'O'이기 때문에 그 어떤 개체도 찾지 못하였음에도 74%의 정확도를 얻습니다. 이는 정확도가 뻥튀기되어 모델의 성능을 오해할 수 있다는 문제가 있습니다. 그래서 여기서는 위와 같은 상황에서 더 적절한 평가 방법을 도입하고자 합니다. 파이썬 패키지 seqeval를 설치합니다. pip install seqeval 앞서 머신 러닝 훑어보기 챕터에서 정밀도(precision)과 재현율(recall)을 언급한 바 있습니다. 개체명 인식 모델의 성능 측정을 위해 정밀도와 재현율 개념을 사용해 보겠습니다. 이를 개체명 인식 문제에 맞도록 해석해 보면 다음과 같습니다. 재현율 정밀도 특정 개체라고 예측한 경우 중에서 실제 특정 개체로 판명되어 예측이 일치한 비율 정밀도 T T + P 특정 개체라고 예측한 경우 중에서 실제 특정 개체로 판명되어 예측이 일치한 비율 재현율 전체 특정 개체 중에서 실제 특정 개체라고 정답을 맞힌 비율 재현율 T T + N 전체 특정 개체 중에서 실제 특정 개체라고 정답을 맞힌 비율 정밀도와 재현율로부터 조화 평균(harmonic mean)을 구한 것을 f1-score라고 합니다. 정밀도 재현율 정밀도 재현율 1 s o e 2 정밀도 × 재현율 정밀도 + 재현율 predicted의 성능을 평가하기 위해서 정밀도, 재현율, f1-score를 계산해 보도록 하겠습니다. from seqeval.metrics import classification_report print(classification_report([labels], [predicted])) precision recall f1-score support MISC 0.00 0.00 0.00 2 PER 0.00 0.00 0.00 3 micro avg 0.00 0.00 0.00 5 macro avg 0.00 0.00 0.00 5 weighted avg 0.00 0.00 0.00 5 이러한 측정 방법을 사용하면 PER과 MISC 두 특정 개체 중에서 실제 predicted가 맞춘 것은 단 1개도 없는 것을 확인할 수 있습니다. 이번에는 어느 정도는 정답을 맞혔다고 가정하고 예측값인 predicted를 수정하여 정밀도, 재현율, f1-score를 확인해 봅시다. labels = ['B-PER', 'I-PER', 'O', 'O', 'B-MISC', 'O','O','O','O','O','O','O','O','O','O','B-PER','I-PER','O','O','O','O','O','O','B-MISC','I-MISC','I-MISC','O','O','O','O','O','O','B-PER','I-PER','O','O','O','O','O'] predicted = ['B-PER', 'I-PER', 'O', 'O', 'B-MISC', 'O','O','O','O','O','O','O','O','O','O','B-PER','I-PER','O','O','O','O','O','O','O','O','O','O','O','O','O','O','O','O','O','O','O','O','O','O'] print(classification_report([labels], [predicted])) precision recall f1-score support MISC 1.00 0.50 0.67 2 PER 1.00 0.67 0.80 3 micro avg 1.00 0.60 0.75 5 macro avg 1.00 0.58 0.73 5 weighted avg 1.00 0.60 0.75 5 특정 개체로 예측한 경우에 대해서는 모두 제대로 예측을 하였으므로 정밀도는 1이 나옵니다. 하지만 재현율에서는 MISC는 실제로는 4개임에도 2개만을 맞추었으므로 0.5, PER은 실제로는 3개임에도 2개만을 맞추었으므로 0.67이 나온 것을 볼 수 있습니다. 4. F1-score로 성능 측정하기 F1-score를 계산하기 위해서 개체명 태깅의 확률 벡터 또는 원-핫 벡터로부터 태깅 정보 시퀀스로 변환하는 함수인 sequences_to_tag를 만듭니다. 해당 함수를 통해 모델의 예측값인 y_predicted와 실제 값에 해당하는 y_test를 태깅 정보 시퀀스로 변환합니다. 그리고 두 개를 비교하여 f1-score를 계산합니다. from seqeval.metrics import f1_score, classification_report def sequences_to_tag(sequences): result = [] # 전체 시퀀스로부터 시퀀스를 하나씩 꺼낸다. for sequence in sequences: word_sequence = [] # 시퀀스로부터 확률 벡터 또는 원-핫 벡터를 하나씩 꺼낸다. for pred in sequence: # 정수로 변환. 예를 들어 pred가 [0, 0, 1, 0 ,0] 라면 1의 인덱스인 2를 리턴한다. pred_index = np.argmax(pred) # index_to_ner을 사용하여 정수를 태깅 정보로 변환. 'PAD'는 'O'로 변경. word_sequence.append(index_to_ner[pred_index].replace("PAD", "O")) result.append(word_sequence) return result y_predicted = model.predict([X_test]) pred_tags = sequences_to_tag(y_predicted) test_tags = sequences_to_tag(y_test) print("F1-score: {:.1%}".format(f1_score(test_tags, pred_tags))) print(classification_report(test_tags, pred_tags)) F1-score: 78.5% precision recall f1-score support art 0.11 0.02 0.03 63 eve 0.28 0.29 0.29 52 geo 0.84 0.84 0.84 7620 gpe 0.96 0.94 0.95 3145 nat 0.46 0.30 0.36 37 org 0.57 0.58 0.57 4033 per 0.73 0.70 0.71 3545 tim 0.84 0.85 0.84 4067 micro avg 0.79 0.78 0.78 22562 macro avg 0.60 0.56 0.57 22562 weighted avg 0.79 0.78 0.78 22562 이어서 CRF 층을 추가하여 성능을 높여봅시다. 12-06 BiLSTM-CRF를 이용한 개체명 인식 이번 실습은 아래의 실습은 이미 실행한 상태라고 가정합니다. 이전 실습 링크 : https://wikidocs.net/147219 이번에는 기존의 양방향 LSTM 모델에 CRF(Conditional Random Field)라는 새로운 층을 추가하여 보다 모델을 개선한 양방향 LSTM + CRF 모델을 사용하여 개체명 인식(Named Entity Recognition)을 수행합니다. 논문 링크 : https://arxiv.org/pdf/1508.01991v1.pdf 논문 링크 : https://arxiv.org/pdf/1603.01360.pdf 1. CRF(Conditional Random Field) CRF는 Conditional Random Field의 약자로 양방향 LSTM을 위해 탄생한 모델이 아니라 이전에 독자적으로 존재해왔던 모델입니다. 이를 양방향 LSTM 모델 위에 하나의 층으로 추가하여, 양방향 LSTM + CRF 모델이 탄생하였습니다. 여기서는 CRF의 수식적 이해가 아니라 양방향 LSTM + CRF 모델의 직관에 대해서 이해합니다. CRF 층의 역할을 이해하기 위해서 간단한 개체명 인식 작업의 예를 들어보겠습니다. 사람(Person), 조직(Organization) 두 가지만을 태깅 하는 간단한 태깅 작업에 BIO 표현을 사용한다면 여기서 사용하는 태깅의 종류는 아래의 5가지입니다. B-Per, I-Per, B-Org, I-Org, O 아래의 그림은 위의 태깅을 수행하는 기존의 양방향 LSTM 개체명 인식 모델의 예를 보여줍니다. 위 모델은 각 단어를 벡터로 입력받고, 모델의 출력층에서 활성화 함수를 통해 개체명을 예측합니다. 사실 입력 단어들과 실제 개체명이 무엇인지 모르는 상황이므로 이 모델이 정확하게 개체명을 예측했는지는 위 그림만으로는 알 수 없습니다. 또 다른 예를 보겠습니다. 위 모델은 명확히 틀린 예측을 포함하고 있습니다. 입력 단어들과 실제 값의 여부와 상관없이 이 사실을 알 수 있습니다. BIO 표현에 따르면 우선, 첫 번째 단어의 레이블에서 I가 등장할 수 없습니다. 또한 I-Per은 반드시 B-Per 뒤에서만 등장할 수 있습니다. 그뿐만 아니라, I-Org도 마찬가지로 B-Org 뒤에서만 등장할 수 있는데 위 모델은 이런 BIO 표현 방법의 제약사항들을 모두 위반하고 있습니다. 여기서 양방향 LSTM 위에 CRF 층을 추가하여 얻을 수 있는 이점을 언급하겠습니다. CRF 층을 추가하면 모델은 예측 개체명, 다시 말해 레이블 사이의 의존성을 고려할 수 있습니다. 아래의 그림은 양방향 LSTM + CRF 모델을 보여줍니다. 앞서봤듯이, 기존에 CRF 층이 존재하지 않았던 양방향 LSTM 모델은 활성화 함수를 지난 시점에서 개체명을 결정했지만, CRF 층을 추가한 모델에서는 활성화 함수의 결과들이 CRF 층의 입력으로 전달됩니다. 예를 들어 o d에 대한 양방향 LSTM 셀과 활성화 함수를 지난 출력값 [0.7, 0.12, 0.08, 0.04, 0.06]은 CRF 층의 입력이 됩니다. 마찬가지로 모든 단어에 대한 활성화 함수를 지난 출력값은 CRF 층의 입력이 되고, CRF 층은 레이블 시퀀스에 대해서 가장 높은 점수를 가지는 시퀀스를 예측합니다. 이러한 구조에서 CRF 층은 점차적으로 훈련 데이터로부터 아래와 같은 제약사항 등을 학습하게 됩니다. 문장의 첫 번째 단어에서는 I가 나오지 않습니다. O-I 패턴은 나오지 않습니다. B-I-I 패턴에서 개체명은 일관성을 유지합니다. 예를 들어 B-Per 다음에 I-Org는 나오지 않습니다. 요약하면 양방향 LSTM은 입력 단어에 대한 양방향 문맥을 반영하며, CRF는 출력 레이블에 대한 양방향 문맥을 반영합니다. 2. CRF 층 설치하기 CRF 층을 손쉽게 사용하기 위한 keras-crf를 설치합니다. pip install keras-crf 깃허브 링크 : https://github.com/luozhouyang/keras-crf 3. BiLSTM-CRF를 이용한 개체명 인식 이전과 동일한 데이터에 대해서 모델을 학습해 봅시다. 마지막 층에 CRF 층을 추가하기 위하여 함수형 API를 사용합니다. 하이퍼 파라미터인 임베딩 벡터의 차원은 128, 은닉 상태의 크기는 64입니다. 모델은 다 대다 구조의 양방향 LSTM을 사용합니다. 이 경우 LSTM의 return_sequences의 인자 값은 True로 주어야만 합니다. 출력층에 TimeDistributed()를 사용했는데, TimeDistributed()는 LSTM을 다 대다 구조로 사용하여 LSTM의 모든 시점에 대해서 출력층을 사용할 필요가 있을 때 사용합니다. 해당 모델은 모든 시점에 대해서 개체명 레이블 개수만큼의 선택지 중 하나를 예측하는 다중 클래스 분류 문제를 수행하는 모델입니다. 여기서는 최종 출력층이 CRF 층으로 CRF 층에 분류해야 하는 선택지 개수를 의미하는 tag_size를 전달해 줍니다. import tensorflow as tf from tensorflow.keras import Model from tensorflow.keras.layers import Dense, LSTM, Input, Bidirectional, TimeDistributed, Embedding, Dropout from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint from keras_crf import CRFModel from seqeval.metrics import f1_score, classification_report embedding_dim = 128 hidden_units = 64 dropout_ratio = 0.3 sequence_input = Input(shape=(max_len,),dtype=tf.int32, name='sequence_input') model_embedding = Embedding(input_dim=vocab_size, output_dim=embedding_dim, input_length=max_len)(sequence_input) model_bilstm = Bidirectional(LSTM(units=hidden_units, return_sequences=True))(model_embedding) model_dropout = TimeDistributed(Dropout(dropout_ratio))(model_bilstm) model_dense = TimeDistributed(Dense(tag_size, activation='relu'))(model_dropout) base = Model(inputs=sequence_input, outputs=model_dense) model = CRFModel(base, tag_size) model.compile(optimizer=tf.keras.optimizers.Adam(0.001), metrics='accuracy') 하이퍼 파라미터인 배치 크기는 128이며, 15 에포크를 수행합니다. validation_split=0.1을 사용하여 훈련 데이터의 10%를 검증 데이터로 분리해서 사용하고, 검증 데이터를 통해서 훈련이 적절히 되고 있는지 확인합니다. 검증 데이터는 기계가 훈련 데이터에 과적합되고 있지는 않은지 확인하기 위한 용도로 사용됩니다. 조기 종료를 사용하기 위해서 콜백을 정의합니다. keras-crf가 원-핫 인코딩 된 레이블은 지원하지 않으므로 y_train이 아니라 y_train_int를 사용함을 주의합니다. es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=4) mc = ModelCheckpoint('bilstm_crf/cp.ckpt', monitor='val_decode_sequence_accuracy', mode='max', verbose=1, save_best_only=True, save_weights_only=True) history = model.fit(X_train, y_train_int, batch_size=128, epochs=15, validation_split=0.1, callbacks=[mc, es]) 조기 종료로 학습이 끝났다면 검증 데이터에 대해서 정확도가 가장 높았을 당시를 저장해둔 가중치를 불러온 후, 임의로 선정한 테스트 데이터의 13번 인덱스의 샘플에 대해서 예측해 봅시다. model.load_weights('bilstm_crf/cp.ckpt') i = 13 # 확인하고 싶은 테스트용 샘플의 인덱스. y_predicted = model.predict(np.array([X_test[i]]))[0] # 입력한 테스트용 샘플에 대해서 예측 y를 리턴 labels = np.argmax(y_test[i], -1) # 원-핫 인코딩을 다시 정수 인코딩으로 변경. print("{:15}|{:5}|{}".format("단어", "실제 값", "예측값")) print(35 * "-") for word, tag, pred in zip(X_test[i], labels, y_predicted[0]): if word != 0: # PAD 값은 제외함. print("{:17}: {:7} {}".format(index_to_word[word], index_to_ner[tag], index_to_ner[pred])) 단어 |실제 값 |예측값 ----------------------------------- the : O O statement : O O came : O O as : O O u.n. : B-org B-org secretary-general: I-org I-org kofi : B-per B-per annan : I-per I-per met : O O with : O O officials : O O in : O O amman : B-geo B-geo to : O O discuss : O O wednesday : B-tim B-tim 's : O O attacks : O O . : O O 정확하게 잘 예측한 것 같습니다. 테스트 데이터에 대해서 성능을 측정해 봅시다. 테스트 데이터에 대한 예측 시퀀스인 y_predicted를 얻습니다. y_predicted = model.predict(X_test)[0] 상위 2개만 출력해 봅시다. print(y_predicted[:2]) [[ 1 3 10 1 2 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [ 1 1 1 1 1 1 3 1 1 1 1 1 1 1 2 9 9 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]] 예측값으로 확률 벡터가 아니라 정수 시퀀스가 출력됩니다. 이 경우 이전 실습에서 사용했던 함수인 sequences_to_tag를 사용할 수 없으므로 함수를 수정해야 합니다. 확률 벡터가 아닌 정수 시퀀스를 입력으로 받아서 태깅 정보 시퀀스를 리턴하는 함수로 sequences_to_tag_for_crf를 만듭니다. 해당 함수를 사용하여 예측값과 레이블에 해당하는 y_test를 태깅 정보 시퀀스로 변환하여 F1-score를 계산합니다. def sequences_to_tag_for_crf(sequences): result = [] # 전체 시퀀스로부터 시퀀스를 하나씩 꺼낸다. for sequence in sequences: word_sequence = [] # 시퀀스로부터 예측 정수 레이블을 하나씩 꺼낸다. for pred_index in sequence: # index_to_ner을 사용하여 정수를 태깅 정보로 변환. 'PAD'는 'O'로 변경. word_sequence.append(index_to_ner[pred_index].replace("PAD", "O")) result.append(word_sequence) return result pred_tags = sequences_to_tag_for_crf(y_predicted) test_tags = sequences_to_tag(y_test) print("F1-score: {:.1%}".format(f1_score(test_tags, pred_tags))) print(classification_report(test_tags, pred_tags)) F1-score: 79.1% precision recall f1-score support art 0.00 0.00 0.00 63 eve 0.91 0.19 0.32 52 geo 0.82 0.85 0.83 7620 gpe 0.95 0.93 0.94 3145 nat 0.00 0.00 0.00 37 org 0.62 0.57 0.60 4033 per 0.76 0.70 0.73 3545 tim 0.87 0.83 0.85 4067 micro avg 0.80 0.78 0.79 22562 macro avg 0.62 0.51 0.53 22562 weighted avg 0.80 0.78 0.79 22562 12-07 문자 임베딩(Character Embedding) 활용하기 이번 실습은 아래의 실습을 이미 실행한 상태라고 가정합니다. 이전 실습 링크 : https://wikidocs.net/147234 개체명 인식기의 성능을 올리기 위한 방법으로 문자 임베딩을 워드 임베딩과 함께 입력으로 사용하는 방법이 있습니다. 워드 임베딩에 문자 임베딩을 연결(concatenate) 하여 성능을 높여봅시다. 1. 문자 임베딩(Char Embedding)을 위한 전처리 문자 임베딩을 위해서 하고자 하는 전처리는 문자 단위 정수 인코딩입니다. 가령 단어 'book'이 있고, b가 21번 o가 7번, k가 11번이라고 한다면 단어 'book'을 [21 7 7 11]로 인코딩합니다. 만약 단어 1개가 아니라 단 어구 내지는 문장이라면 어떻게 될까요? 'good book'이란 문장이 있고, g가 12번, d가 17번이라고 한다면 이 문장을 문자 단위 정수 인코딩 후에는 다음과 같은 결과를 얻을 수 있습니다. 'good book의 정수 인코딩 결과' [[12 7 7 17] [21 7 7 11]] 이 각 문자와 매핑된 정수를 각각 임베딩 층(Embedding layer)을 거치도록 하여, 문자 단위 임베딩을 얻게 됩니다. 향후 임베딩 층을 통과시키기 위해 문자에 대한 정수 인코딩을 진행해 봅시다. 우선 전체 데이터의 모든 단어를 문자 레벨로 분해하여, 문자 집합을 만듭니다. # char_vocab 만들기 words = list(set(data["Word"].values)) chars = set([w_i for w in words for w_i in w]) chars = sorted(list(chars)) print('문자 집합 :',chars) 문자 집합 : ['!', '"', '#', '$', '%', '&', "'", '(', ')', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '?', '@', '[', ']', '_', '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '~', '\x85', '\x91', '\x92', '\x93', '\x94', '\x96', '\x97', '\xa0', '°', 'é', 'ë', 'ö', 'ü'] 이렇게 얻은 문자 집합으로부터 문자를 정수로 변환할 수 있는 딕셔너리인 char_to_index와 반대로 정수로부터 문자를 얻을 수 있는 딕셔너리인 index_to_char를 만듭니다. char_to_index = {c: i + 2 for i, c in enumerate(chars)} char_to_index["OOV"] = 1 char_to_index["PAD"] = 0 index_to_char = {} for key, value in char_to_index.items(): index_to_char[value] = key 단어를 표현하는 문자 시퀀스의 최대 길이는 15로 제한 후 패딩 합니다. max_len_char = 15 # 문자 시퀀스에 대한 패딩 하는 함수 def padding_char_indice(char_indice, max_len_char): return pad_sequences( char_indice, maxlen=max_len_char, padding='post', value = 0) # 각 단어를 문자 시퀀스로 변환 후 패딩 진행 def integer_coding(sentences): char_data = [] for ts in sentences: word_indice = [word_to_index[t] for t in ts] char_indice = [[char_to_index[char] for char in t] for t in ts] char_indice = padding_char_indice(char_indice, max_len_char) for chars_of_token in char_indice: if len(chars_of_token) > max_len_char: continue char_data.append(char_indice) return char_data # 문자 단위 정수 인코딩 결과 X_char_data = integer_coding(sentences) 동일한 문장에 대해서 단어 단위 정수 인코딩과 문자 단위 정수 인코딩의 차이를 확인해 봅시다. 첫 번째 샘플은 다음과 같습니다. # 정수 인코딩 이전의 기존 문장 print('기존 문장 :',sentences[0]) 기존 문장 : ['thousands', 'of', 'demonstrators', 'have', 'marched', 'through', 'london', 'to', 'protest', 'the', 'war', 'in', 'iraq', 'and', 'demand', 'the', 'withdrawal', 'of', 'british', 'troops', 'from', 'that', 'country', '.'] 위문장을 정수 인코딩 및 패딩 한 결과는 다음과 같습니다. # 단어 단위 정수 인코딩 + 패딩 print('단어 단위 정수 인코딩 :') print(X_data[0]) 단어 단위 정수 인코딩 : [ 254 6 967 16 1795 238 468 7 523 2 129 5 61 9 571 2 833 6 186 90 22 15 56 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] 254는 기존의 thousands, 6은 기존의 of에 해당됩니다. 해당 샘플을 문자 단위 정수 인코딩한 결과는 다음과 같습니다. # 문자 단위 정수 인코딩 print('문자 단위 정수 인코딩 :') print(X_char_data[0]) 문자 단위 정수 인코딩 : [[53 41 48 54 52 34 47 37 52 0 0 0 0 0 0] [48 39 0 0 0 0 0 0 0 0 0 0 0 0 0] [37 38 46 48 47 52 53 51 34 53 48 51 52 0 0] [41 34 55 38 0 0 0 0 0 0 0 0 0 0 0] [46 34 51 36 41 38 37 0 0 0 0 0 0 0 0] [53 41 51 48 54 40 41 0 0 0 0 0 0 0 0] [45 48 47 37 48 47 0 0 0 0 0 0 0 0 0] [53 48 0 0 0 0 0 0 0 0 0 0 0 0 0] [49 51 48 53 38 52 53 0 0 0 0 0 0 0 0] [53 41 38 0 0 0 0 0 0 0 0 0 0 0 0] [56 34 51 0 0 0 0 0 0 0 0 0 0 0 0] [42 47 0 0 0 0 0 0 0 0 0 0 0 0 0] [42 51 34 50 0 0 0 0 0 0 0 0 0 0 0] [34 47 37 0 0 0 0 0 0 0 0 0 0 0 0] [37 38 46 34 47 37 0 0 0 0 0 0 0 0 0] [53 41 38 0 0 0 0 0 0 0 0 0 0 0 0] [56 42 53 41 37 51 34 56 34 45 0 0 0 0 0] [48 39 0 0 0 0 0 0 0 0 0 0 0 0 0] [35 51 42 53 42 52 41 0 0 0 0 0 0 0 0] [53 51 48 48 49 52 0 0 0 0 0 0 0 0 0] [39 51 48 46 0 0 0 0 0 0 0 0 0 0 0] [53 41 34 53 0 0 0 0 0 0 0 0 0 0 0] [36 48 54 47 53 51 58 0 0 0 0 0 0 0 0] [14 0 0 0 0 0 0 0 0 0 0 0 0 0 0]] 위 출력 결과에서 각 행은 각 단어를 의미합니다. 가령, thousands는 첫 번째 행 [53 41 48 54 52 34 47 37 52 0 0 0 0 0 0]에 해당됩니다. 단어의 최대 길이를 15(max_len_char)로 제한하였으므로, 길이가 15보다 짧은 단어는 뒤에 0으로 패딩 됩니다. 53은 t, 41은 h, 48은 o, 54는 u에 각각 해당됩니다. X_data는 뒤에 0으로 패딩 되어 길이가 70인 것에 비해 X_char_data는 현재 0번 단어는 무시되어 길이가 70이 아닙니다. 다시 말해 위 출력 결과에서 행의 개수가 70이 아닌 상태입니다. 길이 70으로 맞춰주기 위해서 문장 길이 방향으로도 패딩을 해줍니다. X_char_data = pad_sequences(X_char_data, maxlen=max_len, padding='post', value = 0) 단어 단위 정수 인코딩 결과는 이미 X_train, y_train, X_test, y_test로 훈련 데이터와 테스트 데이터가 분리된 상태입니다. 문자 단위 정수 인코딩 결과에 대해서도 마찬가지로 X_char_train, X_char_test로 나누어줍니다. X_char_train, X_char_test, _, _ = train_test_split(X_char_data, y_data, test_size=.2, random_state=777) X_char_train = np.array(X_char_train) X_char_test = np.array(X_char_test) 첫 번째 훈련 데이터를 출력해 봅시다. print(X_train[0]) [ 150 928 361 17 2624 9 4131 3567 9 8 2893 1250 880 107 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] 첫 번째 훈련 샘플의 첫 번째 단어인 150번은 원래 어떤 단어였을까요? print(index_to_word[150]) soldiers soldiers라는 단어였습니다. 그렇다면 X_char_train의 첫 번째 훈련 샘플의 첫 번째 단어의 문자 정수 인코딩 결과로부터 soldiers라는 단어와 일치하는지 확인해 보겠습니다. print(' '.join([index_to_char[index] for index in X_char_train[0][0]])) s o l d i e r s PAD PAD PAD PAD PAD PAD PAD 각 데이터와 레이블의 크기를 확인해 봅시다. print('훈련 샘플 문장의 크기 : {}'.format(X_train.shape)) print('훈련 샘플 레이블의 크기 : {}'.format(y_train.shape)) print('훈련 샘플 char 데이터의 크기 : {}'.format(X_char_train.shape)) print('테스트 샘플 문장의 크기 : {}'.format(X_test.shape)) print('테스트 샘플 레이블의 크기 : {}'.format(y_test.shape)) 훈련 샘플 문장의 크기 : (38367, 70) 훈련 샘플 레이블의 크기 : (38367, 70, 18) 훈련 샘플 char 데이터의 크기 : (38367, 70, 15) 테스트 샘플 문장의 크기 : (9592, 70) 테스트 샘플 레이블의 크기 : (9592, 70, 18) 2. BiLSTM-CNN을 이용한 개체명 인식 우선 문자 임베딩이 활용되는 과정을 보겠습니다. 하나의 단어는 문자 단위로 토큰화되었고, 토큰화된 각 문자는 위의 전처리를 통해 정수로 매핑된 상태입니다. 정수로 매핑된 각 문자는 임베딩 층을 통과하면 64차원의 벡터가 됩니다. 이후 1D 합성곱 층의 입력으로 사용되는데, 1D 합성곱 층의 커널의 크기는 3이며 해당 커널은 총 30개 사용합니다. 1D 합성곱 층의 결과로 하나의 단어에 대한 단어 벡터를 얻습니다. 해당 단어 벡터는 일반적으로 워드 임베딩이라고 부르던 과정을 통해 얻은 단어의 임베딩 벡터와 연결(concatenate) 됩니다. 이를 양방향 LSTM의 입력으로 사용하게 되는데, 이후에는 이전 실습들과 같습니다. LSTM의 은닉 상태의 크기는 256입니다. 모델은 다 대다 구조의 양방향 LSTM을 사용합니다. 이 경우 LSTM의 return_sequences의 인자 값은 True로 주어야만 합니다. 출력층에 TimeDistributed()를 사용하여 LSTM의 모든 시점에 대해서 출력층을 사용합니다. import tensorflow as tf from tensorflow.keras.layers import Embedding, Input, TimeDistributed, Dropout, concatenate, Bidirectional, LSTM, Conv1D, Dense, MaxPooling1D, Flatten from tensorflow.keras import Model from tensorflow.keras.initializers import RandomUniform from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint from tensorflow.keras.models import load_model from seqeval.metrics import f1_score, classification_report from keras_crf import CRFModel embedding_dim = 128 char_embedding_dim = 64 dropout_ratio = 0.5 hidden_units = 256 num_filters = 30 kernel_size = 3 # 단어 임베딩 word_ids = Input(shape=(None,),dtype='int32', name='words_input') word_embeddings = Embedding(input_dim=vocab_size, output_dim=embedding_dim)(word_ids) # char 임베딩 char_ids = Input(shape=(None, max_len_char,), name='char_input') embed_char_out = TimeDistributed(Embedding(len(char_to_index), char_embedding_dim, embeddings_initializer=RandomUniform(minval=-0.5, maxval=0.5)), name='char_embedding')(char_ids) dropout = Dropout(dropout_ratio)(embed_char_out) # char 임베딩에 대해서는 Conv1D 수행 conv1d_out = TimeDistributed(Conv1D(kernel_size=kernel_size, filters=num_filters, padding='same', activation='tanh', strides=1))(dropout) maxpool_out = TimeDistributed(MaxPooling1D(max_len_char))(conv1d_out) char_embeddings = TimeDistributed(Flatten())(maxpool_out) char_embeddings = Dropout(dropout_ratio)(char_embeddings) # char 임베딩을 Conv1D 수행한 뒤에 단어 임베딩과 연결 output = concatenate([word_embeddings, char_embeddings]) # 연결한 벡터를 가지고 문장의 길이만큼 LSTM을 수행 output = Bidirectional(LSTM(hidden_units, return_sequences=True, dropout=dropout_ratio))(output) # 출력층 output = TimeDistributed(Dense(tag_size, activation='softmax'))(output) model = Model(inputs=[word_ids, char_ids], outputs=[output]) model.compile(loss='categorical_crossentropy', optimizer='nadam', metrics=['acc']) 조기 종료를 조건으로 콜백을 정의합니다. 이전 실습과 동일한 조건으로 배치 크기는 128로 하고, 15 에포크를 학습합니다. 훈련 데이터의 10%를 검증 데이터로 사용합니다. es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=4) mc = ModelCheckpoint('bilstm_cnn.h5', monitor='val_acc', mode='max', verbose=1, save_best_only=True) history = model.fit([X_train, X_char_train], y_train, batch_size=128, epochs=15, validation_split=0.1, verbose=1, callbacks=[es, mc]) 조기 종료로 학습이 끝났다면 검증 데이터에 대해서 정확도가 가장 높았을 당시를 저장해둔 가중치를 불러옵니다. 해당 모델에 대해서 테스트 데이터의 13번 인덱스의 샘플에 대해서 예측해 봅시다. model = load_model('bilstm_cnn.h5') i = 13 # 확인하고 싶은 테스트용 샘플의 인덱스. # 입력한 테스트용 샘플에 대해서 예측 y를 리턴 y_predicted = model.predict([np.array([X_test[i]]), np.array([X_char_test[i]])]) y_predicted = np.argmax(y_predicted, axis=-1) # 확률 벡터를 정수 인코딩으로 변경. labels = np.argmax(y_test[i], -1) # 원-핫 인코딩을 정수 인코딩으로 변경. print("{:15}|{:5}|{}".format("단어", "실제 값", "예측값")) print(35 * "-") for word, tag, pred in zip(X_test[i], labels, y_predicted[0]): if word != 0: # PAD 값은 제외함. print("{:17}: {:7} {}".format(index_to_word[word], index_to_ner[tag], index_to_ner[pred])) 단어 |실제 값 |예측값 ----------------------------------- the : O O statement : O O came : O O as : O O u.n. : B-org B-org secretary-general: I-org I-org kofi : B-per B-per annan : I-per I-per met : O O with : O O officials : O O in : O O amman : B-geo B-geo to : O O discuss : O O wednesday : B-tim B-tim 's : O O attacks : O O . : O O 정확하게 잘 예측한 것 같습니다. 테스트 데이터에 대해서 성능을 측정해 봅시다. 테스트 데이터에 대한 예측 시퀀스인 y_predicted를 얻습니다. 그리고 예측값과 실제 값에 대한 태깅 정보 시퀀스를 얻은 후 F1-score를 계산합니다. y_predicted = model.predict([X_test, X_char_test]) pred_tags = sequences_to_tag(y_predicted) test_tags = sequences_to_tag(y_test) print("F1-score: {:.1%}".format(f1_score(test_tags, pred_tags))) print(classification_report(test_tags, pred_tags)) F1-score: 79.0% precision recall f1-score support art 0.00 0.00 0.00 63 eve 1.00 0.08 0.14 52 geo 0.81 0.86 0.84 7620 gpe 0.95 0.94 0.94 3145 nat 0.00 0.00 0.00 37 org 0.59 0.56 0.57 4033 per 0.73 0.72 0.73 3545 tim 0.87 0.84 0.85 4067 micro avg 0.79 0.79 0.79 22562 macro avg 0.62 0.50 0.51 22562 weighted avg 0.79 0.79 0.79 22562 3. BiLSTM-CNN-CRF 저자의 경우 '양방향 LSTM에 CRF 층을 추가적으로 사용한 모델' 또는 '양방향 LSTM에 문자 임베딩을 사용한 모델' 이렇게 두 가지 모델이 '양방향 LSTM만을 사용한 모델'보다는 성능이 더 좋은 것을 확인했습니다. 그렇다면 두 가지 모두를 활용해 보는 것은 어떨까요? 이번에는 문자 임베딩을 사용한 위 모델에 CRF 층까지 추가적으로 사용해 보겠습니다. embedding_dim = 128 char_embedding_dim = 64 dropout_ratio = 0.5 hidden_units = 256 num_filters = 30 kernel_size = 3 # 단어 임베딩 word_ids = Input(shape=(None,),dtype='int32', name='words_input') word_embeddings = Embedding(input_dim=vocab_size, output_dim=embedding_dim)(word_ids) # char 임베딩 char_ids = Input(shape=(None, max_len_char,), name='char_input') embed_char_out = TimeDistributed(Embedding(len(char_to_index), char_embedding_dim, embeddings_initializer=RandomUniform(minval=-0.5, maxval=0.5)), name='char_embedding')(char_ids) dropout = Dropout(dropout_ratio)(embed_char_out) # char 임베딩에 대해서는 Conv1D 수행 conv1d_out = TimeDistributed(Conv1D(kernel_size=kernel_size, filters=num_filters, padding='same',activation='tanh', strides=1))(dropout) maxpool_out=TimeDistributed(MaxPooling1D(max_len_char))(conv1d_out) char_embeddings = TimeDistributed(Flatten())(maxpool_out) char_embeddings = Dropout(dropout_ratio)(char_embeddings) # char 임베딩을 Conv1D 수행한 뒤에 단어 임베딩과 연결 output = concatenate([word_embeddings, char_embeddings]) # 연결한 벡터를 가지고 문장의 길이만큼 LSTM을 수행 output = Bidirectional(LSTM(hidden_units, return_sequences=True, dropout=dropout_ratio))(output) # 출력층 output = TimeDistributed(Dense(tag_size, activation='relu'))(output) base = Model(inputs=[word_ids, char_ids], outputs=[output]) model = CRFModel(base, tag_size) model.compile(optimizer=tf.keras.optimizers.Adam(0.001), metrics='accuracy') es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=4) mc = ModelCheckpoint('bilstm_cnn_crf/cp.ckpt', monitor='val_decode_sequence_accuracy', mode='max', verbose=1, save_best_only=True, save_weights_only=True) CRF 층은 원-핫 인코딩 된 레이블은 지원하지 않으므로 y_train이 아니라 y_train_int를 사용함을 주의합니다. history = model.fit([X_train, X_char_train], y_train_int, batch_size=128, epochs=15, validation_split=0.1, callbacks=[mc, es]) 조기 종료로 학습이 끝났다면 검증 데이터에 대해서 정확도가 가장 높았을 당시를 저장해둔 가중치를 불러온 후, 테스트 데이터의 13번 인덱스의 샘플에 대해서 예측해 봅시다. model.load_weights('bilstm_cnn_crf/cp.ckpt') i = 13 # 확인하고 싶은 테스트용 샘플의 인덱스. # 입력한 테스트용 샘플에 대해서 예측 y를 리턴 y_predicted = model.predict([np.array([X_test[i]]), np.array([X_char_test[i]])])[0] labels = np.argmax(y_test[i], -1) # 원-핫 벡터를 정수 인코딩으로 변경. print("{:15}|{:5}|{}".format("단어", "실제 값", "예측값")) print(35 * "-") for word, tag, pred in zip(X_test[i], labels, y_predicted[0]): if word != 0: # PAD 값은 제외함. print("{:17}: {:7} {}".format(index_to_word[word], index_to_ner[tag], index_to_ner[pred])) 단어 |실제 값 |예측값 ----------------------------------- the : O O statement : O O came : O O as : O O u.n. : B-org B-org secretary-general: I-org I-org kofi : B-per B-per annan : I-per I-per met : O O with : O O officials : O O in : O O amman : B-geo B-geo to : O O discuss : O O wednesday : B-tim B-tim 's : O O attacks : O O . : O O 정확하게 잘 예측한 것 같습니다. 테스트 데이터에 대해서 성능을 측정해 봅시다. 테스트 데이터에 대한 예측 시퀀스인 y_predicted를 얻습니다. 예측값과 실제 값에 대한 태깅 정보 시퀀스를 얻은 후 F1-score를 계산합니다. y_predicted = model.predict([X_test, X_char_test])[0] pred_tags = sequences_to_tag_for_crf(y_predicted) test_tags = sequences_to_tag(y_test) print("F1-score: {:.1%}".format(f1_score(test_tags, pred_tags))) print(classification_report(test_tags, pred_tags)) F1-score: 81.0% precision recall f1-score support art 0.25 0.06 0.10 63 eve 0.61 0.27 0.37 52 geo 0.85 0.84 0.84 7620 gpe 0.94 0.94 0.94 3145 nat 0.33 0.05 0.09 37 org 0.66 0.60 0.63 4033 per 0.76 0.77 0.77 3545 tim 0.89 0.85 0.87 4067 micro avg 0.82 0.80 0.81 22562 macro avg 0.66 0.55 0.58 22562 weighted avg 0.82 0.80 0.81 22562 4. BiLSTM-BiLSTM-CRF 문자 임베딩이 활용되는 과정을 보겠습니다. 하나의 단어는 문자 단위로 토큰화되었고, 토큰화된 각 문자는 위의 전처리를 통해 정수로 매핑된 상태입니다. 정수로 매핑된 각 문자는 임베딩 층을 통과하면 64차원의 벡터가 됩니다. 이후 양방향 LSTM 입력으로 사용되는데, 이때 사용되는 LSTM의 은닉 상태의 크기는 64입니다. 해당 LSTM은 다 대 일(many-to-one) 구조로 순방향 LSTM의 은닉 상태와 역방향 LSTM의 은닉 상태가 연결(concatenate) 된 값이 양방향 LSTM의 출력입니다. 해당 출력을 하나의 단어에 대한 단어 벡터로 간주합니다. 해당 단어 벡터는 일반적으로 워드 임베딩이라고 부르던 과정을 통해 얻은 단어의 임베딩 벡터와 연결(concatenate) 됩니다. 이를 개체명 인식을 위한 양방향 LSTM의 입력으로 사용하게 되는데, 이후에는 이전 실습들과 같습니다. CRF 층은 원-핫 인코딩 된 레이블은 지원하지 않으므로 y_train_int를 사용합니다. embedding_dim = 128 char_embedding_dim = 64 dropout_ratio = 0.3 hidden_units = 64 # 단어 임베딩 word_ids = Input(batch_shape=(None, None), dtype='int32', name='word_input') word_embeddings = Embedding(input_dim=vocab_size, output_dim=embedding_dim, name='word_embedding')(word_ids) # char 임베딩 char_ids = Input(batch_shape=(None, None, None), dtype='int32', name='char_input') char_embeddings = Embedding(input_dim=(len(char_to_index)), output_dim=char_embedding_dim, embeddings_initializer=RandomUniform(minval=-0.5, maxval=0.5), name='char_embedding')(char_ids) # char 임베딩을 BiLSTM을 통과시켜 단어 벡터를 얻고 단어 임베딩과 연결 char_embeddings = TimeDistributed(Bidirectional(LSTM(hidden_units)))(char_embeddings) output = concatenate([word_embeddings, char_embeddings]) # 연결한 벡터를 가지고 문장의 길이만큼 LSTM을 수행 output = Dropout(dropout_ratio)(output) output = Bidirectional(LSTM(units=hidden_units, return_sequences=True))(output) # 출력층 output = TimeDistributed(Dense(tag_size, activation='relu'))(output) base = Model(inputs=[word_ids, char_ids], outputs=[output]) model = CRFModel(base, tag_size) model.compile(optimizer=tf.keras.optimizers.Adam(0.001), metrics='accuracy') es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=4) mc = ModelCheckpoint('bilstm_bilstm_crf/cp.ckpt', monitor='val_decode_sequence_accuracy', mode='max', verbose=1, save_best_only=True, save_weights_only=True) history = model.fit([X_train, X_char_train], y_train_int, batch_size=128, epochs=15, validation_split=0.1, callbacks=[mc, es]) 조기 종료로 학습이 끝났다면 검증 데이터에 대해서 정확도가 가장 높았을 당시를 저장해둔 가중치를 불러온 후, 테스트 데이터의 13번 인덱스의 샘플에 대해서 예측합니다. model.load_weights('bilstm_bilstm_crf/cp.ckpt') i = 13 # 확인하고 싶은 테스트용 샘플의 인덱스. # 입력한 테스트용 샘플에 대해서 예측 y를 리턴 y_predicted = model.predict([np.array([X_test[i]]), np.array([X_char_test[i]])])[0] labels = np.argmax(y_test[i], -1) # 원-핫 벡터를 정수 인코딩으로 변경. print("{:15}|{:5}|{}".format("단어", "실제 값", "예측값")) print(35 * "-") for word, tag, pred in zip(X_test[i], labels, y_predicted[0]): if word != 0: # PAD 값은 제외함. print("{:17}: {:7} {}".format(index_to_word[word], index_to_ner[tag], index_to_ner[pred])) 단어 |실제 값 |예측값 ----------------------------------- the : O O statement : O O came : O O as : O O u.n. : B-org B-org secretary-general: I-org I-org kofi : B-per B-per annan : I-per I-per met : O O with : O O officials : O O in : O O amman : B-geo B-geo to : O O discuss : O O wednesday : B-tim B-tim 's : O O attacks : O O . : O O 정확하게 잘 예측한 것 같습니다. 테스트 데이터에 대해서 성능을 측정해 봅시다. 테스트 데이터에 대한 예측 시퀀스인 y_predicted를 얻습니다. 예측값과 실제 값에 대한 태깅 정보 시퀀스를 얻은 후 F1-score를 계산합니다. y_predicted = model.predict([X_test, X_char_test])[0] pred_tags = sequences_to_tag_for_crf(y_predicted) test_tags = sequences_to_tag(y_test) print("F1-score: {:.1%}".format(f1_score(test_tags, pred_tags))) print(classification_report(test_tags, pred_tags)) F1-score: 80.9% precision recall f1-score support art 0.29 0.03 0.06 63 eve 1.00 0.04 0.07 52 geo 0.83 0.86 0.85 7620 gpe 0.95 0.94 0.95 3145 nat 0.35 0.16 0.22 37 org 0.67 0.58 0.62 4033 per 0.79 0.74 0.77 3545 tim 0.88 0.84 0.86 4067 micro avg 0.83 0.79 0.81 22562 macro avg 0.72 0.52 0.55 22562 weighted avg 0.82 0.79 0.80 22562 99) ===텐서 플로 1버전 코드 (구 버전)=== 이하 실습은 텐서 플로 1버전 실습으로 과거 버전 자료입니다. 12-01 양방향 LSTM을 이용한 개체명 인식(Named Entity Recognition using Bi-LSTM) 이번 챕터에서는 개체명 인식 데이터에 대한 전처리를 진행하고, 양방향 LSTM을 이용하여 개체명 인식기를 만듭니다. 그리고 F1-Score를 사용하여 모델을 평가합니다. 1. 실습을 진행하기 전에 이번에 사용할 CRF layer는 현재 텐서 플로 1.14.0버전과 케라스 2.2.4에서 원활하게 동작합니다. 그러므로 우선 버전을 맞춰줍시다. 로컬 환경의 버전은 건드리지 않기 위해 구글 Colab에서의 실습을 권장합니다. !pip uninstall keras-nightly !pip uninstall -y tensorflow !pip install tensorflow==1.14.0 !pip install keras==2.2.4 !pip install tensorflow-gpu==1.14.0 !pip install h5py==2.10.0 CRF를 사용하기 위해 keras_contrib를 설치해야 합니다. 아래의 명령을 수행하여 설치합니다. !pip install git+https://www.github.com/keras-team/keras-contrib.git 2. 개체명 인식 데이터에 대한 이해와 전처리 이번에는 양방향 LSTM과 CRF를 함께 사용하여 앞서 사용한 데이터 외에 다른 데이터를 사용하여 개체명 인식을 수행해 보도록 하겠습니다. 데이터는 아래의 링크에서 다운로드 가능합니다. 링크 : https://www.kaggle.com/abhinavwalia95/entity-annotated-corpus import pandas as pd import numpy as np %matplotlib inline import matplotlib.pyplot as plt from tensorflow.keras.preprocessing.text import Tokenizer from tensorflow.keras.preprocessing.sequence import pad_sequences from sklearn.model_selection import train_test_split from tensorflow.keras.utils import to_categorical data = pd.read_csv("ner_dataset.csv 파일의 경로", encoding="latin1") data[:5] 이번에 사용할 데이터는 앞서 사용한 데이터랑 양식이 조금 다릅니다. 첫 번째 열은 다음과 같은 패턴을 가지고 있습니다. Sentence: 1 있고, Null 값이 이어지다가 다시 Sentence: 2가 나오고 다시 Null 값이 이어지다가 Sentence: 3이 나오고 다시 Null 값이 이어지다가를 반복합니다. 그런데 사실 이는 하나의 문장을 여러 행으로 나눠놓은 것입니다. 숫자 값을 t라고 합시다. 첫 번째 Sentence: t부터 Null 값이 나오다가 Sentence: t+1이 나오기 전까지의 모든 데이터는 원래 하나의 행. 즉, 하나의 샘플이어야 합니다. t 번째 문장을 각 단어마다 각 하나의 행으로 나눠놓은 데이터이기 때문입니다. 이는 뒤에서 Pandas의 fillna를 통해 하나로 묶는 작업을 해줍니다. print('데이터프레임 행의 개수 : {}'.format(len(data))) 데이터프레임 행의 개수 : 1048575 현재 data의 행의 개수는 1,048,575개입니다. 하지만 뒤에서 기존에 문장 1개였던 행들을 1개의 행으로 병합하는 작업을 해야 하기 때문에 최종 샘플의 개수는 이보다 줄어들게 됩니다. 우선, 데이터를 좀 더 살펴봅시다. print('데이터에 Null 값이 있는지 유무 : ' + str(data.isnull().values.any())) 데이터에 Null 값이 있는지 유무 : True Sentence #열에 Null 값들이 존재하고 있으므로, isnull().values.any()를 수행하였을 때 True가 나옵니다. print('어떤 열에 Null 값이 있는지 출력') print('==============================') data.isnull().sum() 어떤 열에 Null 값이 있는지 출력 ============================== Sentence # 1000616 Word 0 POS 0 Tag 0 dtype: int64 isnull().sum()을 수행하면 각 열마다의 Null 값의 개수를 보여줍니다. 다른 열은 0개인데 오직 Sentences #열에서만 1,000,616개가 나온 것을 볼 수 있습니다. 전체 데이터에서 중복을 허용하지 않고, 유일한 값의 개수를 셀 수 있게 해주는 nunique()를 사용해 봅시다. print('sentence # 열의 중복을 제거한 값의 개수 : {}'.format(data['Sentence #'].nunique())) print('Word 열의 중복을 제거한 값의 개수 : {}'.format(data.Word.nunique())) print('Tag 열의 중복을 제거한 값의 개수 : {}'.format(data.Tag.nunique())) sentence # 열의 중복을 제거한 값의 개수 : 47959 Word 열의 중복을 제거한 값의 개수 : 35178 Tag 열의 중복을 제거한 값의 개수 : 17 이 데이터에는 47,959개의 문장이 있으며 문장들은 35,178개의 단어를 가지고 17개 종류의 개체명 태깅을 가집니다. 17개의 개체명 태깅이 전체 데이터에서 몇 개가 있는지, 개체명 태깅 개수의 분포를 확인해 보도록 하겠습니다. print('Tag 열의 각각의 값의 개수 카운트') print('================================') print(data.groupby('Tag').size().reset_index(name='count')) Tag 열의 각각의 값의 개수 카운트 ================================ Tag count 0 B-art 402 1 B-eve 308 2 B-geo 37644 3 B-gpe 15870 4 B-nat 201 5 B-org 20143 6 B-per 16990 7 B-tim 20333 8 I-art 297 9 I-eve 253 10 I-geo 7414 11 I-gpe 198 12 I-nat 51 13 I-org 16784 14 I-per 17251 15 I-tim 6528 16 O 887908 BIO 표현 방법에서 아무런 태깅도 의미하지 않는 O가 가장 887,908개로 가장 많은 개수를 차지함을 볼 수 있습니다. 이제 데이터를 원하는 형태로 가공해 보겠습니다. 우선 Null 값을 제거합니다. data = data.fillna(method="ffill") Pandas의 (method='ffill')는 Null 값을 가진 행의 바로 앞의 행의 값으로 Null 값을 채우는 작업을 수행합니다. 이렇게 하면 t 번째 문장에 속하면서 Null 값을 가진 샘플들은 전부 첫 번째 열에 Sentence: t의 값이 들어갑니다. 이번에는 뒤의 5개의 샘플을 출력해서 정상적으로 수행되었는지 확인해 봅시다. print(data.tail()) Sentence # Word POS Tag 1048570 Sentence: 47959 they PRP O 1048571 Sentence: 47959 responded VBD O 1048572 Sentence: 47959 to TO O 1048573 Sentence: 47959 the DT O 1048574 Sentence: 47959 attack NN O 뒤의 5개 샘플의 첫 번째 열이 Sentence: 47959로 채워졌습니다. 이는 47,959번째 문장임을 의미하며, Null 값을 가진 행들의 바로 앞 행의 Sentence # 열의 값이 Sentence: 47959이었음을 의미합니다. 전체 데이터에 Null 값이 존재하는지 확인해 봅시다. print('데이터에 Null 값이 있는지 유무 : ' + str(data.isnull().values.any())) 데이터에 Null 값이 있는지 유무 : False 없는 것으로 나옵니다. 모든 단어를 소문자화하여 단어의 개수를 줄여보겠습니다. data['Word'] = data['Word'].str.lower() print('Word 열의 중복을 제거한 값의 개수 : {}'.format(data.Word.nunique())) Word 열의 중복을 제거한 값의 개수 : 31817 정상적으로 소문자 화가 되었는지 앞의 샘플 5개만 출력해 보겠습니다. print(data[:5]) Sentence # Word POS Tag 0 Sentence: 1 thousands NNS O 1 Sentence: 1 of IN O 2 Sentence: 1 demonstrators NNS O 3 Sentence: 1 have VBP O 4 Sentence: 1 marched VBN O 이제 하나의 문장에 등장한 단어와 개체명 태깅 정보끼리 쌍(pair)으로 묶는 작업을 수행합니다. func = lambda temp: [(w, t) for w, t in zip(temp["Word"].values.tolist(), temp["Tag"].values.tolist())] tagged_sentences=[t for t in data.groupby("Sentence #").apply(func)] print("전체 샘플 개수: {}".format(len(tagged_sentences))) 전체 샘플 개수: 47959 1,000,616개의 행의 개수가 각 문장당 하나의 샘플로 묶이면서 47,959개의 샘플로 변환된 것을 확인할 수 있습니다. 정상적으로 수행이 되었는지 첫 번째 샘플에 대해서 출력을 해봅시다. print(tagged_sentences[0]) # 첫 번째 샘플 출력 [('thousands', 'O'), ('of', 'O'), ('demonstrators', 'O'), ('have', 'O'), ('marched', 'O'), ('through', 'O'), ('london', 'B-geo'), ('to', 'O'), ('protest', 'O'), ('the', 'O'), ('war', 'O'), ('in', 'O'), ('iraq', 'B-geo'), ('and', 'O'), ('demand', 'O'), ('the', 'O'), ('withdrawal', 'O'), ('of', 'O'), ('british', 'B-gpe'), ('troops', 'O'), ('from', 'O'), ('that', 'O'), ('country', 'O'), ('.', 'O')] 전처리가 수행된 첫 번째 샘플이 출력된 것을 볼 수 있습니다. 이러한 샘플이 총 47,959개가 있습니다. 그런데 훈련을 시키려면 훈련 데이터에서 단어에 해당되는 부분과 개체명 태깅 정보에 해당되는 부분을 분리시켜야 합니다. 즉, [('thousands', 'O'), ('of', 'O')]와 같은 문장 샘플이 있다면 thousands와 of는 같이 저장하고, O와 O를 같이 저장할 필요가 있습니다. 이런 경우 파이썬 함수 중에서 zip() 함수가 유용한 역할을 합니다. zip() 함수는 동일한 개수를 가지는 시퀀스 자료형에서 각 순서에 등장하는 원소들끼리 묶어주는 역할을 합니다. (2챕터의 데이터의 분리 챕터 참고) sentences, ner_tags = [], [] for tagged_sentence in tagged_sentences: # 47,959개의 문장 샘플을 1개씩 불러온다. sentence, tag_info = zip(*tagged_sentence) # 각 샘플에서 단어들은 sentence에 개체명 태깅 정보들은 tag_info에 저장. sentences.append(list(sentence)) # 각 샘플에서 단어 정보만 저장한다. ner_tags.append(list(tag_info)) # 각 샘플에서 개체명 태깅 정보만 저장한다. 각 문장 샘플에 대해서 단어는 sentences에 태깅 정보는 ner_tags에 저장하였습니다. 임의로 첫 번째 문장 샘플을 출력해 보겠습니다. print(sentences[0]) print(ner_tags[0]) ['thousands', 'of', 'demonstrators', 'have', 'marched', 'through', 'london', 'to', 'protest', 'the', 'war', 'in', 'iraq', 'and', 'demand', 'the', 'withdrawal', 'of', 'british', 'troops', 'from', 'that', 'country', '.'] ['O', 'O', 'O', 'O', 'O', 'O', 'B-geo', 'O', 'O', 'O', 'O', 'O', 'B-geo', 'O', 'O', 'O', 'O', 'O', 'B-gpe', 'O', 'O', 'O', 'O', 'O'] 첫 번째 샘플에 대해서 단어에 대해서만 sentences[0]에, 또한 개체명에 대해서만 ner_tags[0]에 저장된 것을 볼 수 있습니다. 뒤에서 보겠지만, sentences는 예측을 위한 X에 해당되며 ner_tags는 예측 대상인 y에 해당됩니다. 다른 샘플들에 대해서도 처리가 되었는지 확인하기 위해 임의로 99번째 샘플에 대해서도 확인해 보겠습니다. print(sentences[98]) print(ner_tags[98]) ['she', 'had', 'once', 'received', 'a', 'kidney', 'transplant', '.'] ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'] 단어에 대해서만 sentences[98]에, 또한 개체명에 대해서만 ner_tags[98]에 저장된 것을 확인할 수 있습니다. 또한 첫 번째 샘플과 길이가 다른 것을 볼 수 있습니다. 사실 47,959개의 문장 샘플의 길이는 전부 제각각입니다. 전체 데이터의 길이 분포를 확인해 봅시다. print('샘플의 최대 길이 : %d' % max(len(l) for l in sentences)) print('샘플의 평균 길이 : %f' % (sum(map(len, sentences))/len(sentences))) plt.hist([len(s) for s in sentences], bins=50) plt.xlabel('length of samples') plt.ylabel('number of samples') plt.show() 샘플의 최대 길이 : 104 샘플의 평균 길이 : 21.863987989741236 위의 그래프는 샘플들의 길이가 대체적으로 0~40의 길이를 가지는 것을 보여줍니다. 길이가 가장 긴 샘플의 길이는 104입니다. 이제 케라스 토크 나이저를 통해서 정수 인코딩을 진행합니다. 이번에는 문장 데이터에 있는 모든 단어를 사용하겠습니다. src_tokenizer = Tokenizer(oov_token='OOV') # 모든 단어를 사용하지만 인덱스 1에는 단어 'OOV'를 할당한다. src_tokenizer.fit_on_texts(sentences) tar_tokenizer = Tokenizer(lower=False) # 태깅 정보들은 내부적으로 대문자를<NAME> 채로 저장 tar_tokenizer.fit_on_texts(ner_tags) 문장 데이터에 대해서는 src_tokenizer를, 레이블에 해당되는 개체명 태깅 정보에 대해서는 tar_tokenizer를 사용합니다. vocab_size = len(src_tokenizer.word_index) + 1 tag_size = len(tar_tokenizer.word_index) + 1 print('단어 집합의 크기 : {}'.format(vocab_size)) print('개체명 태깅 정보 집합의 크기 : {}'.format(tag_size)) 단어 집합의 크기 : 31819 개체명 태깅 정보 집합의 크기 : 18 앞서 src_tokenizer를 만들 때 Tokenizer의 인자로 oov_token='OOV'를 선택했습니다. 이렇게 하면 인덱스 1에 단어 'OOV'가 할당됩니다. print('단어 OOV의 인덱스 : {}'.format(src_tokenizer.word_index['OOV'])) 단어 OOV의 인덱스 : 1 이제 정수 인코딩을 수행합니다. X_data = src_tokenizer.texts_to_sequences(sentences) y_data = tar_tokenizer.texts_to_sequences(ner_tags) 이제 문장 데이터에 대해서 정수 인코딩이 수행된 결과는 X_data, 개체명 태깅 데이터에 대해서 정수 인코딩이 수행된 결과는 y_data에 저장되었습니다. 정수 인코딩이 되었는지 확인을 위해 임의로 첫 번째 샘플을 출력해 보겠습니다. print(X_data[0]) print(y_data[0]) [254, 6, 967, 16, 1795, 238, 468, 7, 523, 2, 129, 5, 61, 9, 571, 2, 833, 6, 186, 90, 22, 15, 56, 3] [1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 8, 1, 1, 1, 1, 1] 모델 훈련 후 결과 확인을 위해 인덱스로부터 단어를 리턴하는 index_to_word를 만듭니다. 그와 동시에 뒤에서 사용할 index_to_ner도 만듭니다. 이때, 인덱스 0은 'PAD'란 단어를 할당해두겠습니다. index_to_ner은 개수가 적으니 출력까지 해봅시다. word_to_index = src_tokenizer.word_index index_to_word = src_tokenizer.index_word ner_to_index = tar_tokenizer.word_index index_to_ner = tar_tokenizer.index_word index_to_ner[0] = 'PAD' print(index_to_ner) {1: 'O', 2: 'B-geo', 3: 'B-tim', 4: 'B-org', 5: 'I-per', 6: 'B-per', 7: 'I-org', 8: 'B-gpe', 9: 'I-geo', 10: 'I-tim', 11: 'B-art', 12: 'B-eve', 13: 'I-art', 14: 'I-eve', 15: 'B-nat', 16: 'I-gpe', 17: 'I-nat', 0: 'PAD'} index_to_word를 만들었으니 시험 삼아 첫 번째 샘플에 대해서 다시 디코딩(정수에서 다시 텍스트 데이터로 변환) 작업을 해보겠습니다. decoded = [] for index in X_data[0] : # 첫 번째 샘플 안의 인덱스들에 대해서 decoded.append(index_to_word[index]) # 다시 단어로 변환 print('기존의 문장 : {}'.format(sentences[0])) print('디코딩 문장 : {}'.format(decoded)) 기존의 문장 : ['thousands', 'of', 'demonstrators', 'have', 'marched', 'through', 'london', 'to', 'protest', 'the', 'war', 'in', 'iraq', 'and', 'demand', 'the', 'withdrawal', 'of', 'british', 'troops', 'from', 'that', 'country', '.'] 디코딩 문장 : ['thousands', 'of', 'demonstrators', 'have', 'marched', 'through', 'london', 'to', 'protest', 'the', 'war', 'in', 'iraq', 'and', 'demand', 'the', 'withdrawal', 'of', 'british', 'troops', 'from', 'that', 'country', '.'] 이제 X 데이터와 y 데이터가 구성되었습니다. 이제 패딩 작업을 진행해 봅시다. 앞서 확인하였듯이 대부분의 데이터의 길이는 40~60에 분포돼 있습니다. 그러므로 가장 긴 샘플의 길이인 104가 아니라 70 정도로 max_len을 정해보겠습니다. max_len = 70 # 모든 샘플들의 길이를 맞출 때 뒤의 공간에 숫자 0으로 채움. X_data = pad_sequences(X_data, padding='post', maxlen=max_len) y_data = pad_sequences(y_data, padding='post', maxlen=max_len) 모든 샘플의 길이가 70이 되었습니다. 이제 훈련 데이터와 테스트 데이터를 8:2의 비율로 분리합니다. X_train, X_test, y_train, y_test = train_test_split(X_data, y_data, test_size=.2, random_state=777) 레이블에 해당하는 태깅 정보에 대해서 원-핫 인코딩을 수행합니다. y_train = to_categorical(y_train, num_classes=tag_size) y_test = to_categorical(y_test, num_classes=tag_size) 이제 각 데이터 크기를 확인해 보겠습니다. print('훈련 샘플 문장의 크기 : {}'.format(X_train.shape)) print('훈련 샘플 레이블의 크기 : {}'.format(y_train.shape)) print('테스트 샘플 문장의 크기 : {}'.format(X_test.shape)) print('테스트 샘플 레이블의 크기 : {}'.format(y_test.shape)) 훈련 샘플 문장의 크기 : (38367, 70) 훈련 샘플 레이블의 크기 : (38367, 70, 18) 테스트 샘플 문장의 크기 : (9592, 70) 테스트 샘플 레이블의 크기 : (9592, 70, 18) 3. F1-Score 시퀀스 레이블링 모델을 평가할 때는 한 가지 주의할 점이 있습니다. 이런 모델의 경우에는 보통 큰 의미를 갖지 않는 레이블 정보가 존재합니다. 예를 들어 개체명 인식에서는 그 어떤 개체도 아니라는 의미의 'O'라는 태깅이 존재합니다. 그런데 이런 정보는 보통 대다수의 레이블을 차지하기 때문에 기존에 사용했던 정확도 평가 방법을 사용하는 것이 적절하지 않을 수 있습니다. 예를 들어 모델이 단 1개의 개체도 맞추지 못하고 전부 'O'로 예상했을 경우를 봅시다. 우선 실제 값은 바로 위에서 출력했던 값을 실제 값으로 재사용하겠습니다. 아래 코드에서는 true라는 변수에 저장하였습니다. 그리고 개체를 하나도 맞추지 못했다는 가정하에 전부 'O'로만 채워진 예측값 predicted를 생성합니다. true=['B-PER', 'I-PER', 'O', 'O', 'B-MISC', 'O','O','O','O','O','O','O','O','O','O','B-PER','I-PER','O','O','O','O','O','O','B-MISC','I-MISC','I-MISC','O','O','O','O','O','O','B-PER','I-PER','O','O','O','O','O'] # 실제 값 predicted=['O'] * len(true) #실제 값의 길이만큼 전부 'O'로 채워진 리스트 생성. 예측값으로 사용. print(predicted) ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'] 실제로는 PER, MISC, PER, MISC, PER이라는 총 5개의 개체가 존재함에도 불구하고 예측값인 predicted는 단 1개의 개체도 맞추지 못한 상황을 시뮬레이션하는 것입니다. 이제 이에 대한 정확도를 계산해 봅시다. hit = 0 # 정답 개수 for t, p in zip(true, predicted): if t == p: hit +=1 # 정답인 경우에만 +1 accuracy = hit/len(true) # 정답 개수를 총개수로 나눈다. print("정확도: {:.1%}".format(accuracy)) 정확도: 74.4% 실제 값에서도 대부분의 값이 'O'이기 때문에 그 어떤 개체도 찾지 못하였음에도 74%의 정확도를 얻습니다. 이는 정확도가 뻥튀기되어 모델의 성능을 오해할 수 있다는 문제가 있습니다. 그래서 여기서는 위와 같은 상황에서 더 적절한 평가 방법을 도입하고자 합니다. 윈도의 명령 프롬프트나 UNIX의 터미널에서 아래의 명령을 수행하여 파이썬 패키지 seqeval를 설치합니다. !pip install seqeval 앞서 머신 러닝 훑어보기 챕터에서 정밀도(precision)과 재현율(recall)을 배운 바 있습니다. 개체명 인식 모델의 성능 측정을 위해 정밀도와 재현율 개념을 사용해 보겠습니다. 이를 개체명 인식 문제에 맞도록 해석해 보면 다음과 같습니다. 정밀도 특정 개체라고 예측한 경우 중에서 실제 특정 개체로 판명되어 예측이 일치한 비율 정밀도 T T + P 특정 개체라고 예측한 경우 중에서 실제 특정 개체로 판명되어 예측이 일치한 비율 재현율 전체 특정 개체 중에서 실제 특정 개체라고 정답을 맞힌 비율 재현율 T T + N 전체 특정 개체 중에서 실제 특정 개체라고 정답을 맞힌 비율 정밀도와 재현율로부터 조화 평균(harmonic mean)을 구한 것을 f1-score라고 합니다. 정밀도 재현율 정밀도 재현율 1 s o e 2 정밀도 × 재현율 정밀도 + 재현율 predicted의 성능을 평가하기 위해서 정밀도, 재현율, f1-score를 계산해 보도록 하겠습니다. from seqeval.metrics import classification_report print(classification_report([true], [predicted])) precision recall f1-score support MISC 0.00 0.00 0.00 2 PER 0.00 0.00 0.00 3 micro avg 0.00 0.00 0.00 5 macro avg 0.00 0.00 0.00 5 weighted avg 0.00 0.00 0.00 5 이러한 측정 방법을 사용하면 PER과 MISC 두 특정 개체 중에서 실제 predicted가 맞춘 것은 단 1개도 없는 것을 확인할 수 있습니다. 이번에는 어느 정도는 정답을 맞혔다고 가정하고 예측값인 predicted를 수정하여 정밀도, 재현율, f1-score를 확인해 봅시다. true=['B-PER', 'I-PER', 'O', 'O', 'B-MISC', 'O','O','O','O','O','O','O','O','O','O','B-PER','I-PER','O','O','O','O','O','O','B-MISC','I-MISC','I-MISC','O','O','O','O','O','O','B-PER','I-PER','O','O','O','O','O'] predicted=['B-PER', 'I-PER', 'O', 'O', 'B-MISC', 'O','O','O','O','O','O','O','O','O','O','B-PER','I-PER','O','O','O','O','O','O','O','O','O','O','O','O','O','O','O','O','O','O','O','O','O','O'] print(classification_report([true], [predicted])) precision recall f1-score support MISC 1.00 0.50 0.67 2 PER 1.00 0.67 0.80 3 micro avg 1.00 0.60 0.75 5 macro avg 1.00 0.58 0.73 5 weighted avg 1.00 0.60 0.75 5 특정 개체로 예측한 경우에 대해서는 모두 제대로 예측을 하였으므로 정밀도는 1이 나옵니다. 하지만 재현율에서는 MISC는 실제로는 4개임에도 2개만을 맞추었으므로 0.5, PER은 실제로는 3개임에도 2개만을 맞추었으므로 0.67이 나온 것을 볼 수 있습니다. 4. F1-score를 측정하는 콜백 클래스 from keras.callbacks import Callback from seqeval.metrics import f1_score, classification_report 모델을 학습하는 과정에서 검증 데이터에 대한 F1-score를 출력하기 위해 다음과 같은 클래스를 구현합니다. 이렇게 클래스를 구현해두면 모델을 검증 데이터를 통해 검증하는 과정에서 F1-score를 지속적으로 확인할 수 있습니다. 그리고 F1-score가 가장 높아질 때마다 모델을 저장합니다. class F1score(Callback): def __init__(self, value = 0.0, use_char=True): super(F1score, self).__init__() self.value = value self.use_char = use_char def sequences_to_tags(self, sequences): # 예측값을 index_to_ner를 사용하여 태깅 정보로 변경하는 함수. result = [] for sequence in sequences: # 전체 시퀀스로부터 시퀀스를 하나씩 꺼낸다. tag = [] for pred in sequence: # 시퀀스로부터 예측값을 하나씩 꺼낸다. pred_index = np.argmax(pred) # 예를 들어 [0, 0, 1, 0 ,0] 라면 1의 인덱스인 2를 리턴한다. tag.append(index_to_ner[pred_index].replace("PAD", "O")) # 'PAD'는 'O'로 변경 result.append(tag) return result # 에포크가 끝날 때마다 실행되는 함수 def on_epoch_end(self, epoch, logs={}): # char Embedding을 사용하는 경우 if self.use_char: X_test = self.validation_data[0] X_char_test = self.validation_data[1] y_test = self.validation_data[2] y_predicted = self.model.predict([X_test, X_char_test]) else: X_test = self.validation_data[0] y_test = self.validation_data[1] y_predicted = self.model.predict([X_test]) pred_tags = self.sequences_to_tags(y_predicted) test_tags = self.sequences_to_tags(y_test) score = f1_score(pred_tags, test_tags) print(' - f1: {:04.2f}'.format(score * 100)) print(classification_report(test_tags, pred_tags)) # F1-score가 지금까지 중 가장 높은 경우 if score > self.value: print('f1_score improved from %f to %f, saving model to best_model.h5'%(self.value, score)) self.model.save('best_model.h5') self.value = score else: print('f1_score did not improve from %f'%(self.value)) 5. BiLSTM을 이용한 개체 명인 식기 from keras.models import Sequential from keras.layers import Dense, LSTM, InputLayer, Bidirectional, TimeDistributed, Embedding from keras.optimizers import Adam from keras.models import load_model model = Sequential() model.add(Embedding(vocab_size, 128, input_length=max_len, mask_zero=True)) model.add(Bidirectional(LSTM(256, return_sequences=True))) model.add(TimeDistributed(Dense(tag_size, activation=('softmax')))) model.compile(loss='categorical_crossentropy', optimizer=Adam(0.001), metrics=['accuracy']) history = model.fit(X_train, y_train, batch_size=32, epochs=10, validation_split=0.1, callbacks=[F1score(use_char=False)]) bilstm_model = load_model('best_model.h5') i=13 # 확인하고 싶은 테스트용 샘플의 인덱스. y_predicted = bilstm_model.predict(np.array([X_test[i]])) # 입력한 테스트용 샘플에 대해서 예측 y를 리턴 y_predicted = np.argmax(y_predicted, axis=-1) # 원-핫 인코딩을 다시 정수 인코딩으로 변경함. true = np.argmax(y_test[i], -1) # 원-핫 인코딩을 다시 정수 인코딩으로 변경함. print("{:15}|{:5}|{}".format("단어", "실제 값", "예측값")) print(35 * "-") for w, t, pred in zip(X_test[i], true, y_predicted[0]): if w != 0: # PAD 값은 제외함. print("{:17}: {:7} {}".format(index_to_word[w], index_to_ner[t], index_to_ner[pred])) 단어 |실제 값 |예측값 ----------------------------------- the : O O statement : O O came : O O as : O O u.n. : B-org B-org secretary-general: I-org I-org kofi : B-per B-per annan : I-per I-per met : O O with : O O officials : O O in : O O amman : B-geo B-geo to : O O discuss : O O wednesday : B-tim B-tim 's : O O attacks : O O . : O O f1score = F1score() y_predicted = bilstm_model.predict([X_test]) pred_tags = f1score.sequences_to_tags(y_predicted) test_tags = f1score.sequences_to_tags(y_test) print(classification_report(test_tags, pred_tags)) precision recall f1-score support art 0.00 0.00 0.00 63 eve 0.64 0.31 0.42 52 geo 0.82 0.82 0.82 7620 gpe 0.95 0.94 0.95 3145 nat 1.00 0.08 0.15 37 org 0.57 0.56 0.57 4033 per 0.70 0.75 0.72 3545 tim 0.76 0.83 0.79 4067 micro avg 0.76 0.78 0.77 22562 macro avg 0.68 0.54 0.55 22562 weighted avg 0.76 0.78 0.77 22562 print("F1-score: {:.1%}".format(f1_score(test_tags, pred_tags))) F1-score: 76.9% 12-02 양방향 LSTM과 CRF(Bidirectional LSTM + CRF) 이번 챕터는 아래의 챕터를 이미 실행한 상태라고 가정합니다. 이전 챕터 링크 : https://wikidocs.net/97519 이번 챕터에서는 기존의 양방향 LSTM 모델에 CRF(Conditional Random Field)라는 새로운 층을 추가하여 보다 모델을 개선한 양방향 LSTM + CRF 모델을 사용하여 개체명 인식(Named Entity Recognition)을 수행합니다. 논문 링크 : https://arxiv.org/pdf/1508.01991v1.pdf 논문 링크 : https://arxiv.org/pdf/1603.01360.pdf 이번 챕터는 텐서 플로와 케라스 버전이 다른 실습과는 다른 버전에서 동작하므로 구글의 Colab을 사용하기를 권장합니다. 1. CRF(Conditional Random Field) CRF는 Conditional Random Field의 약자로 양방향 LSTM을 위해 탄생한 모델이 아니라 이전에 독자적으로 존재해왔던 모델입니다. 이를 양방향 LSTM 모델 위에 하나의 층으로 추가하여, 양방향 LSTM + CRF 모델이 탄생하였습니다. 여기서는 CRF의 수식적 이해가 아니라 양방향 LSTM + CRF 모델의 직관에 대해서 이해합니다. CRF 층의 역할을 이해하기 위해서 간단한 개체명 인식 작업의 예를 들어보겠습니다. 사람(Person), 조직(Organization) 두 가지만을 태깅 하는 간단한 태깅 작업에 BIO 표현을 사용한다면 여기서 사용하는 태깅의 종류는 아래의 5가지입니다. B-Per, I-Per, B-Org, I-Org, O 아래의 그림은 위의 태깅을 수행하는 기존의 양방향 LSTM 개체명 인식 모델의 예를 보여줍니다. 위 모델은 각 단어를 벡터로 입력받고, 모델의 출력층에서 활성화 함수를 통해 개체명을 예측합니다. 사실 입력 단어들과 실제 개체명이 무엇인지 모르는 상황이므로 이 모델이 정확하게 개체명을 예측했는지는 위 그림만으로는 알 수 없습니다. 또 다른 예를 보겠습니다. 위 모델은 명확히 틀린 예측을 포함하고 있습니다. 입력 단어들과 실제 값의 여부와 상관없이 이 사실을 알 수 있습니다. BIO 표현에 따르면 우선, 첫 번째 단어의 레이블에서 I가 등장할 수 없습니다. 또한 I-Per은 반드시 B-Per 뒤에서만 등장할 수 있습니다. 뿐만 아니라, I-Org도 마찬가지로 B-Org 뒤에서만 등장할 수 있는데 위 모델은 이런 BIO 표현 방법의 제약사항들을 모두 위반하고 있습니다. 여기서 양방향 LSTM 위에 CRF 층을 추가하여 얻을 수 있는 이점을 언급하겠습니다. CRF 층을 추가하면 모델은 예측 개체명, 다시 말해 레이블 사이의 의존성을 고려할 수 있습니다. 아래의 그림은 양방향 LSTM + CRF 모델을 보여줍니다. 앞서봤듯이, 기존에 CRF 층이 존재하지 않았던 양방향 LSTM 모델은 활성화 함수를 지난 시점에서 개체명을 결정했지만, CRF 층을 추가한 모델에서는 활성화 함수의 결과들이 CRF 층의 입력으로 전달됩니다. 예를 들어 o d에 대한 BiLSTM 셀과 활성화 함수를 지난 출력값 [0.7, 0.12, 0.08, 0.04, 0.06]은 CRF 층의 입력이 됩니다. 마찬가지로 모든 단어에 대한 활성화 함수를 지난 출력값은 CRF 층의 입력이 되고, CRF 층은 레이블 시퀀스에 대해서 가장 높은 점수를 가지는 시퀀스를 예측합니다. 이러한 구조에서 CRF 층은 점차적으로 훈련 데이터로부터 아래와 같은 제약사항 등을 학습하게 됩니다. 문장의 첫 번째 단어에서는 I가 나오지 않습니다. O-I 패턴은 나오지 않습니다. B-I-I 패턴에서 개체명은 일관성을 유지합니다. 예를 들어 B-Per 다음에 I-Org는 나오지 않습니다. 요약하면 양방향 LSTM은 입력 단어에 대한 양방향 문맥을 반영하며, CRF는 출력 레이블에 대한 양방향 문맥을 반영합니다. 2. 실습을 진행하기 전에 CRF layer는 현재 텐서 플로 1.14.0버전과 케라스 2.2.4에서 가장 원활하게 동작합니다. 텐서 플로와 케라스 버전을 높이면 CRF layer가 동작하지 않거나, mask_zero=True가 되지 않는 등의 문제가 발생합니다. 그러므로 우선 버전을 맞춰줍시다. 로컬 환경의 버전은 건드리지 않기 위해 구글 Colab에서의 실습을 권장합니다. !pip install tensorflow==1.14.0 !pip install keras==2.2.4 !pip install tensorflow-gpu==1.14.0 CRF를 사용하기 위해 keras_contrib를 설치해야 합니다. 아래의 명령을 수행하여 설치합니다. !pip install git+https://www.github.com/keras-team/keras-contrib.git 3. 개체명 인식 데이터에 대한 이해와 전처리 데이터 셋 로드와 전처리는 5) 양방향 LSTM을 이용한 개체명 인식에서 진행한 것과 동일하게 진행되었다고 가정합니다. 링크 : https://wikidocs.net/97519 print('훈련 샘플 문장의 크기 : {}'.format(X_train.shape)) print('훈련 샘플 레이블의 크기 : {}'.format(y_train.shape)) print('테스트 샘플 문장의 크기 : {}'.format(X_test.shape)) print('테스트 샘플 레이블의 크기 : {}'.format(y_test.shape)) 훈련 샘플 문장의 크기 : (38367, 70) 훈련 샘플 레이블의 크기 : (38367, 70, 18) 테스트 샘플 문장의 크기 : (9592, 70) 테스트 샘플 레이블의 크기 : (9592, 70, 18) 4. F1-score를 측정하는 콜백 클래스 아래 링크에서 사용된 콜백 클래스를 동일하게 구현하였다고 가정합니다. 링크 : https://wikidocs.net/97519 class F1score(Callback): ... 중략 ... 5. 양방향 LSTM + CRF를 이용한 개체명 인식 from keras.models import Sequential from keras.layers import LSTM, Embedding, Dense, TimeDistributed, Dropout, Bidirectional from keras.models import load_model from keras_contrib.layers import CRF from keras_contrib.losses import crf_loss from keras_contrib.metrics import crf_viterbi_accuracy 위와 같이 필요한 도구들을 임포트 합니다. model = Sequential() model.add(Embedding(input_dim=vocab_size, output_dim=64, input_length=max_len, mask_zero=True)) model.add(Bidirectional(LSTM(128, return_sequences=True))) model.add(TimeDistributed(Dense(50, activation="relu"))) crf = CRF(tag_size) model.add(crf) 모델에 양방향 LSTM을 사용하고, 모델의 출력층에 CRF 층을 배치하였습니다. 모델을 훈련합니다. model.compile(optimizer="adam", loss=crf.loss_function, metrics=[crf.accuracy]) history = model.fit(X_train, y_train, batch_size = 32, epochs = 10, validation_split = 0.1, verbose = 1, callbacks=[F1score(use_char=False)]) bilstm_crf_model = load_model('best_model.h5', custom_objects={'CRF':CRF, 'crf_loss':crf_loss, 'crf_viterbi_accuracy':crf_viterbi_accuracy}) i=13 # 확인하고 싶은 테스트용 샘플의 인덱스. y_predicted = bilstm_crf_model.predict(np.array([X_test[i]])) # 입력한 테스트용 샘플에 대해서 예측 y를 리턴 y_predicted = np.argmax(y_predicted, axis=-1) # 원-핫 인코딩을 다시 정수 인코딩으로 변경함. true = np.argmax(y_test[i], -1) # 원-핫 인코딩을 다시 정수 인코딩으로 변경함. print("{:15}|{:5}|{}".format("단어", "실제 값", "예측값")) print(35 * "-") for w, t, pred in zip(X_test[i], true, y_predicted[0]): if w != 0: # PAD 값은 제외함. print("{:17}: {:7} {}".format(index_to_word[w], index_to_ner[t], index_to_ner[pred])) 단어 |실제 값 |예측값 ----------------------------------- the : O O statement : O O came : O O as : O O u.n. : B-org B-org secretary-general: I-org I-org kofi : B-per B-per annan : I-per I-per met : O O with : O O officials : O O in : O O amman : B-geo B-geo to : O O discuss : O O wednesday : B-tim B-tim 's : O O attacks : O O . : O O 6. 실제 모델에 대해서 f1 score 구하기 이제 앞서 구현한 모델에 대해서 위에서 배운 f1-score를 적용해 봅시다. 이를 위해서는 모델이 리턴하는 예측값은 숫자로 구성돼 있으므로, 이를 먼저 태깅이 나열되어 있는 리스트로 치환하는 작업이 필요합니다. 이를 위해서 sequences_to_tag 함수를 사용합니다. f1score = F1score(use_char=False) y_predicted = bilstm_crf_model.predict([X_test]) pred_tags = f1score.sequences_to_tags(y_predicted) test_tags = f1score.sequences_to_tags(y_test) print(classification_report(test_tags, pred_tags)) precision recall f1-score support art 0.00 0.00 0.00 63 eve 0.82 0.27 0.41 52 geo 0.82 0.87 0.85 7620 gpe 0.97 0.93 0.95 3145 nat 1.00 0.19 0.32 37 org 0.71 0.56 0.63 4033 per 0.79 0.75 0.77 3545 tim 0.89 0.85 0.87 4067 micro avg 0.83 0.80 0.81 22562 macro avg 0.75 0.55 0.60 22562 weighted avg 0.83 0.80 0.81 22562 print("F1-score: {:.1%}".format(f1_score(test_tags, pred_tags))) F1-score: 81.4% 7. 새로운 입력에 대해서 예측하기 이제 임의로 만든 새로운 문장에 대해서 앞서 만든 개체명 인식 모델을 수행해 보겠습니다. new_sentence='Mr. Heo said South Korea has become a worldwide leader'.lower().split() 저자가 임의로 만든 문장을 띄어쓰기 수준의 토큰화 상태로 new_sentence에 저장하였습니다. 이제 이를 정수 인코딩합니다. new_encoded=[] for w in new_sentence: try: new_encoded.append(word_to_index.get(w, 1)) except KeyError: new_encoded.append(word_to_index['OOV']) # 모델이 모르는 단어에 대해서는 'OOV'의 인덱스인 1로 인코딩 print(new_encoded) [38, 1, 18, 117, 243, 12, 762, 8, 1154, 130] 정수 인코딩 과정에서 Heo의 경우 OOV로 치환되었습니다. new_padded = pad_sequences([new_encoded], padding="post", value=0, maxlen=max_len) 임의로 만든 문장을 max_len의 길이로 패딩 해줍니다. 이제 예측을 시작해 볼까요? p = bilstm_crf_model.predict(np.array([new_padded[0]])) p = np.argmax(p, axis=-1) print("{:15}||{}".format("단어", "예측값")) print(30 * "=") for w, pred in zip(new_sentence, p[0]): print("{:15}: {:5}".format(w, index_to_ner[pred])) 단어 ||예측값 ============================== mr. : B-per heo : I-per said : O south : B-geo korea : I-geo has : O become : O a : O worldwide : O leader : O https://github.com/floydhub/named-entity-recognition-template/blob/master/ner.ipynb 12-03 양방향 LSTM과 문자 임베딩(Char embedding) 이번 챕터는 아래의 챕터를 이미 실행한 상태라고 가정합니다. 이전 챕터 링크 : https://wikidocs.net/97519 개체명 인식기의 성능을 올리기 위한 방법으로 12챕터에서 배운 문자 임베딩을 워드 임베딩과 함께 입력으로 사용하는 방법이 있습니다. 워드 임베딩에 문자 임베딩을 연결(concatenate) 하여 성능을 높여봅시다. 1. 문자 임베딩(Char Embedding)을 위한 전처리 문자 임베딩을 위해서 하고자 하는 전처리는 문자 단위 정수 인코딩입니다. 가령 단어 'book'이 있고, b가 21번 o가 7번, k가 11번이라고 한다면 단어 'book'을 [21 7 7 11]로 인코딩하는 것입니다. 만약 단어 1개가 아니라 단어구나 문장이라면 어떨까요? 'good book'이란 문장이 있고, g가 12번, d가 17번이라고 한다면 이 문장을 문자 단위 정수 인코딩한다면 다음과 같은 결과를 얻을 수 있습니다. 'good book의 정수 인코딩 결과' [[12 7 7 17] [21 7 7 11]] 이 각 정수를 각각 임베딩 층(Embedding layer)를 거치도록 하여, 문자 단위 임베딩을 얻게 됩니다. 임베딩 층은 모델을 설계할 때 추가하게 되므로, 여기서는 정수 인코딩까지만 진행합니다. 우선 전체 데이터의 모든 단어를 문자 레벨로 분해하여, 문자 집합을 만듭니다. # char_vocab 만들기 words = list(set(data["Word"].values)) chars = set([w_i for w in words for w_i in w]) chars = sorted(list(chars)) print(chars) ['!', '"', '#', '$', '%', '&', "'", '(', ')', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '?', '@', '[', ']', '_', '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '~', '\x85', '\x91', '\x92', '\x93', '\x94', '\x96', '\x97', '\xa0', '°', 'é', 'ë', 'ö', 'ü'] 이렇게 얻은 문자 집합으로부터 문자를 정수로 변환할 수 있는 딕셔너리인 char_to_index와 반대로 정수로부터 문자를 얻을 수 있는 딕셔너리인 index_to_char를 만듭니다. char_to_index = {c: i + 2 for i, c in enumerate(chars)} char_to_index["OOV"] = 1 char_to_index["PAD"] = 0 index_to_char = {} for key, value in char_to_index.items(): index_to_char[value] = key max_len_char = 15 def padding_char_indice(char_indice, max_len_char): return pad_sequences( char_indice, maxlen=max_len_char, padding='post', value = 0) def integer_coding(sentences): char_data = [] for ts in sentences: word_indice = [word_to_index[t] for t in ts] char_indice = [[char_to_index[char] for char in t] for t in ts] char_indice = padding_char_indice(char_indice, max_len_char) for chars_of_token in char_indice: if len(chars_of_token) > max_len_char: continue char_data.append(char_indice) return char_data X_char_data = integer_coding(sentences) 동일한 문장에 대해서 단어 단위 정수 인코딩과 문자 단위 정수 인코딩의 차이를 확인해 봅시다. 첫 번째 샘플은 다음과 같습니다. # 정수 인코딩 이전의 기존 문장 print(sentences[0]) ['thousands', 'of', 'demonstrators', 'have', 'marched', 'through', 'london', 'to', 'protest', 'the', 'war', 'in', 'iraq', 'and', 'demand', 'the', 'withdrawal', 'of', 'british', 'troops', 'from', 'that', 'country', '.'] 이 샘플을 정수 인코딩하고, 다른 샘플들과 길이를 동일하게 하기 위해 패딩 한 결과는 다음과 같습니다. # 단어 단위 정수 인코딩 + 패딩 print(X_data[0]) [ 254 6 967 16 1795 238 468 7 523 2 129 5 61 9 571 2 833 6 186 90 22 15 56 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] 254번 단어는 thousands, 6번 단어는 of에 해당됩니다. 해당 샘플을 문자 단위 정수 인코딩한 결과는 다음과 같습니다. # 문자 단위 정수 인코딩 print(X_char_data[0]) [[53 41 48 54 52 34 47 37 52 0 0 0 0 0 0] [48 39 0 0 0 0 0 0 0 0 0 0 0 0 0] [37 38 46 48 47 52 53 51 34 53 48 51 52 0 0] [41 34 55 38 0 0 0 0 0 0 0 0 0 0 0] [46 34 51 36 41 38 37 0 0 0 0 0 0 0 0] [53 41 51 48 54 40 41 0 0 0 0 0 0 0 0] [45 48 47 37 48 47 0 0 0 0 0 0 0 0 0] [53 48 0 0 0 0 0 0 0 0 0 0 0 0 0] [49 51 48 53 38 52 53 0 0 0 0 0 0 0 0] [53 41 38 0 0 0 0 0 0 0 0 0 0 0 0] [56 34 51 0 0 0 0 0 0 0 0 0 0 0 0] [42 47 0 0 0 0 0 0 0 0 0 0 0 0 0] [42 51 34 50 0 0 0 0 0 0 0 0 0 0 0] [34 47 37 0 0 0 0 0 0 0 0 0 0 0 0] [37 38 46 34 47 37 0 0 0 0 0 0 0 0 0] [53 41 38 0 0 0 0 0 0 0 0 0 0 0 0] [56 42 53 41 37 51 34 56 34 45 0 0 0 0 0] [48 39 0 0 0 0 0 0 0 0 0 0 0 0 0] [35 51 42 53 42 52 41 0 0 0 0 0 0 0 0] [53 51 48 48 49 52 0 0 0 0 0 0 0 0 0] [39 51 48 46 0 0 0 0 0 0 0 0 0 0 0] [53 41 34 53 0 0 0 0 0 0 0 0 0 0 0] [36 48 54 47 53 51 58 0 0 0 0 0 0 0 0] [14 0 0 0 0 0 0 0 0 0 0 0 0 0 0]] 위 출력 결과에서 각 행은 각 단어를 의미합니다. 가령, thousands는 첫 번째 행 [53 41 48 54 52 34 47 37 52 0 0 0 0 0 0]에 해당됩니다. 단어의 최대 길이를 15(max_len_char)로 제한하였으므로, 길이가 15보다 짧은 단어는 뒤에 0으로 패딩 됩니다. 53은 t, 41은 h, 48은 o, 54는 u에 각각 해당됩니다. X_data는 뒤에 0으로 패딩 되어 길이가 70인 것에 비해, X_char_data는 0번 단어는 무시되어 길이가 70이 아닙니다. 즉, 위 출력 결과에서 행의 개수가 70이 아닌 상태입니다. 이를 위해 문장 길이 방향으로도 패딩을 해줍니다. X_char_data = pad_sequences(X_char_data, maxlen=max_len, padding='post', value = 0) 이미 단어 단위 정수 인코딩 결과는 X_train, y_train, X_test, y_test로 훈련 데이터와 테스트 데이터가 분리된 상태입니다. 문자 단위 정수 인코딩 결과에 대해서도 마찬가지로 X_char_train, X_char_test로 나누어줍니다. X_char_train, X_char_test, _, _ = train_test_split(X_char_data, y_data, test_size=.2, random_state=777) X_char_train = np.array(X_char_train) X_char_test = np.array(X_char_test) print(X_train[0]) [ 150 928 361 17 2624 9 4131 3567 9 8 2893 1250 880 107 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] print(index_to_word[150]) soldiers print(' '.join([index_to_char[index] for index in X_char_train[0][0]])) s o l d i e r s PAD PAD PAD PAD PAD PAD PAD print('훈련 샘플 문장의 크기 : {}'.format(X_train.shape)) print('훈련 샘플 레이블의 크기 : {}'.format(y_train.shape)) print('훈련 샘플 char 데이터의 크기 : {}'.format(X_char_train.shape)) print('테스트 샘플 문장의 크기 : {}'.format(X_test.shape)) print('테스트 샘플 레이블의 크기 : {}'.format(y_test.shape)) 훈련 샘플 문장의 크기 : (38367, 70) 훈련 샘플 레이블의 크기 : (38367, 70, 18) 훈련 샘플 char 데이터의 크기 : (38367, 70, 15) 테스트 샘플 문장의 크기 : (9592, 70) 테스트 샘플 레이블의 크기 : (9592, 70, 18) 2. BiLSTM-CNN 위에서 전처리한 문자 단위 정수 인코딩 입력을 1D CNN의 입력으로 사용하여 문자 임베딩을 얻고, 워드 임베딩과 연결(concatenate) 하여 양방향 LSTM의 입력으로 사용해 봅시다. from keras.layers import Embedding, TimeDistributed, Dropout, concatenate, Bidirectional, LSTM, Conv1D, Dense, MaxPooling1D, Flatten from keras import Input, Model from keras.initializers import RandomUniform from keras.models import load_model # 워드 임베딩 word_ids = Input(shape=(None,),dtype='int32',name='words_input') word_embeddings = Embedding(input_dim = vocab_size, output_dim = 64)(word_ids) # char 임베딩 char_ids = Input(shape=(None, max_len_char,),name='char_input') embed_char_out = TimeDistributed(Embedding(len(char_to_index), 30, embeddings_initializer=RandomUniform(minval=-0.5, maxval=0.5)), name='char_embedding')(char_ids) dropout = Dropout(0.5)(embed_char_out) # char 임베딩에 대해서는 Conv1D 수행 conv1d_out= TimeDistributed(Conv1D(kernel_size=3, filters=30, padding='same',activation='tanh', strides=1))(dropout) maxpool_out=TimeDistributed(MaxPooling1D(max_len_char))(conv1d_out) char_embeddings = TimeDistributed(Flatten())(maxpool_out) char_embeddings = Dropout(0.5)(char_embeddings) # char 임베딩을 Conv1D 수행한 뒤에 워드 임베딩과 연결 output = concatenate([word_embeddings, char_embeddings]) # 연결한 벡터를 가지고 문장의 길이만큼 LSTM을 수행 output = Bidirectional(LSTM(50, return_sequences=True, dropout=0.50, recurrent_dropout=0.25))(output) # 출력층 output = TimeDistributed(Dense(tag_size, activation='softmax'))(output) model = Model(inputs=[word_ids, char_ids], outputs=[output]) model.compile(loss='categorical_crossentropy', optimizer='nadam', metrics=['acc']) callbacks으로 F1score를 넣어줄 때, 문자 임베딩을 사용하고 있으므로 use_char를 True로 해주어야 합니다. history = model.fit([X_train, X_char_train], y_train, batch_size = 32, epochs = 10, validation_split = 0.1, verbose = 1, callbacks=[F1score(use_char=True)]) 학습이 끝났다면 모델을 로드하여 테스트 데이터에 대해서 F1 score를 측정해 봅시다. bilstm_cnn_model = load_model('best_model.h5') f1score = F1score(use_char=True) y_predicted = bilstm_cnn_model.predict([X_test, X_char_test]) pred_tags = f1score.sequences_to_tags(y_predicted) test_tags = f1score.sequences_to_tags(y_test) print(classification_report(test_tags, pred_tags)) precision recall f1-score support art 0.27 0.14 0.19 63 eve 0.46 0.35 0.40 52 geo 0.82 0.86 0.84 7620 gpe 0.96 0.95 0.95 3145 nat 0.55 0.46 0.50 37 org 0.62 0.59 0.60 4033 per 0.73 0.71 0.72 3545 tim 0.87 0.84 0.86 4067 micro avg 0.80 0.79 0.80 22562 macro avg 0.66 0.61 0.63 22562 weighted avg 0.80 0.79 0.79 22562 print("F1-score: {:.1%}".format(f1_score(test_tags, pred_tags))) F1-score: 79.5% 3. BiLSTM-CNN-CRF 이번에는 문자 임베딩을 사용한 위의 모델에 CRF 층을 추가적으로 사용해 보겠습니다. from keras_contrib.layers import CRF from keras_contrib.losses import crf_loss from keras_contrib.metrics import crf_viterbi_accuracy # 워드 임베딩 word_ids = Input(shape=(None,),dtype='int32',name='words_input') word_embeddings = Embedding(input_dim = vocab_size, output_dim = 64)(word_ids) # char 임베딩 char_ids = Input(shape=(None, max_len_char,),name='char_input') embed_char_out = TimeDistributed(Embedding(len(char_to_index), 30, embeddings_initializer=RandomUniform(minval=-0.5, maxval=0.5)), name='char_embedding')(char_ids) dropout = Dropout(0.5)(embed_char_out) # char 임베딩에 대해서는 Conv1D 수행 conv1d_out= TimeDistributed(Conv1D(kernel_size=3, filters=30, padding='same',activation='tanh', strides=1))(dropout) maxpool_out=TimeDistributed(MaxPooling1D(max_len_char))(conv1d_out) char_embeddings = TimeDistributed(Flatten())(maxpool_out) char_embeddings = Dropout(0.5)(char_embeddings) # char 임베딩을 Conv1D 수행한 뒤에 워드 임베딩과 연결 output = concatenate([word_embeddings, char_embeddings]) # 연결한 벡터를 가지고 문장의 길이만큼 LSTM을 수행 output = Bidirectional(LSTM(50, return_sequences=True, dropout=0.50, recurrent_dropout=0.25))(output) # 출력층에 CRF 층을 추가 (위의 모델과 이 부분이 다릅니다.) output = TimeDistributed(Dense(50, activation='relu'))(output) crf = CRF(tag_size) output = crf(output) model = Model(inputs=[words_input, character_input], outputs=[output]) model.compile(optimizer="adam", loss=crf.loss_function, metrics=[crf.accuracy]) history = model.fit([X_train, X_char_train], y_train, batch_size = 32, epochs = 15, validation_split = 0.1, verbose = 1, callbacks=[F1score(use_char=True)]) bilstm_cnn_crf_model = load_model('best_model.h5', custom_objects={'CRF':CRF, 'crf_loss':crf_loss, 'crf_viterbi_accuracy':crf_viterbi_accuracy}) f1score = F1score(use_char=True) y_predicted = bilstm_cnn_crf_model.predict([X_test, X_char_test]) pred_tags = f1score.sequences_to_tags(y_predicted) test_tags = f1score.sequences_to_tags(y_test) print(classification_report(test_tags, pred_tags)) precision recall f1-score support per 0.80 0.76 0.78 3545 gpe 0.96 0.94 0.95 3145 geo 0.85 0.86 0.86 7620 tim 0.88 0.87 0.87 4067 org 0.66 0.60 0.63 4033 art 0.00 0.00 0.00 63 eve 0.61 0.27 0.37 52 nat 0.68 0.51 0.58 37 micro avg 0.83 0.81 0.82 22562 macro avg 0.83 0.81 0.82 22562 print("F1-score: {:.1%}".format(f1_score(test_tags, pred_tags))) F1-score: 81.9% 4. BiLSTM-BiLSTM-CRF 문자 임베딩은 1D CNN이 아니라 양방향 LSTM을 통해서도 얻을 수 있습니다. 양방향 LSTM을 이용해 얻은 문자 임베딩을 워드 임베딩과 연결(concatenate) 하여 양방향 LSTM의 입력으로 사용하고, 마지막으로 CRF 층을 추가하여 모델을 만듭니다. # 워드 임베딩 word_ids = Input(batch_shape=(None, None), dtype='int32', name='word_input') word_embeddings = Embedding(input_dim=vocab_size, output_dim=64, mask_zero=True, name='word_embedding')(word_ids) # char 임베딩 char_ids = Input(batch_shape=(None, None, None), dtype='int32', name='char_input') char_embeddings = Embedding(input_dim=(len(char_to_index)), output_dim=30, mask_zero=True, embeddings_initializer=RandomUniform(minval=-0.5, maxval=0.5), name='char_embedding')(char_ids) char_embeddings = TimeDistributed(Bidirectional(LSTM(64)))(char_embeddings) # char 임베딩을 워드 임베딩과 연결 word_embeddings = concatenate([word_embeddings, char_embeddings]) word_embeddings = Dropout(0.3)(word_embeddings) z = Bidirectional(LSTM(units=64, return_sequences=True))(word_embeddings) z = Dense(tag_size, activation='tanh')(z) crf = CRF(tag_size) output = crf(z) model = Model(inputs=[word_ids, char_ids], outputs=[output]) model.compile(optimizer="adam", loss=crf.loss_function, metrics=[crf.accuracy]) history = model.fit([X_train, X_char_train], y_train, batch_size = 32, epochs = 15, validation_split = 0.1, verbose = 1, callbacks=[F1score(use_char=True)]) bilstm_bilstm_crf_model = load_model('best_model.h5', custom_objects={'CRF':CRF, 'crf_loss':crf_loss, 'crf_viterbi_accuracy':crf_viterbi_accuracy}) f1score = F1score(use_char=True) y_predicted = bilstm_bilstm_crf_model.predict([X_test, X_char_test]) pred_tags = f1score.sequences_to_tags(y_predicted) test_tags = f1score.sequences_to_tags(y_test) print(classification_report(test_tags, pred_tags)) precision recall f1-score support art 0.25 0.02 0.03 63 eve 0.45 0.29 0.35 52 geo 0.85 0.87 0.86 7620 gpe 0.96 0.95 0.95 3145 nat 0.55 0.16 0.25 37 org 0.73 0.57 0.64 4033 per 0.78 0.78 0.78 3545 tim 0.89 0.86 0.87 4067 micro avg 0.84 0.81 0.82 22562 macro avg 0.68 0.56 0.59 22562 weighted avg 0.84 0.81 0.82 22562 print("F1-score: {:.1%}".format(f1_score(test_tags, pred_tags))) F1-score: 82.4% 13. Part 2. 심화 과정 난이도를 고려하여 책을 두 파트로 나눴습니다. 1챕터부터 13챕터를 기본 과정, 14챕터부터 끝까지를 심화 과정으로 합니다. 13. 서브 워드 토크 나이저(Subword Tokenizer) 기계에게 아무리 많은 단어를 학습시켜도, 세상의 모든 단어를 알려줄 수는 없는 노릇입니다. 만약, 기계가 모르는 단어가 등장하면 그 단어를 단어 집합에 없는 단어란 의미에서 OOV(Out-Of-Vocabulary) 또는 UNK(Unknown Token)라고 표현합니다. 기계가 문제를 풀 때, 모르는 단어가 등장하면 (사람도 마찬가지지만) 주어진 문제를 푸는 것이 까다로워집니다. 이와 같이 모르는 단어로 인해 문제를 푸는 것이 까다로워지는 상황을 OOV 문제라고 합니다. 서브 워드 분리(Subword segmenation) 작업은 하나의 단어는 더 작은 단위의 의미 있는 여러 서브 워드들(Ex) birthplace = birth + place)의 조합으로 구성된 경우가 많기 때문에, 하나의 단어를 여러 서브 워드로 분리해서 단어를 인코딩 및 임베딩하겠다는 의도를 가진 전처리 작업입니다. 이를 통해 OOV나 희귀 단어, 신조어와 같은 문제를 완화시킬 수 있습니다. 실제로 언어의 특성에 따라 영어권 언어나 한국어는 서브 워드 분리를 시도했을 때 어느 정도 의미 있는 단위로 나누는 것이 가능합니다. 이 책에서는 이런 작업을 하는 토크 나이저를 서브 워드 토크 나이저라고 명명하겠습니다. 이번 챕터에서는 서브 워드 토크 나이저의 주요 알고리즘인 바이트 페어 인코딩과 실제 실무에서 사용하는 서브 워드 토크 나이저 구현체인 SentencePiece와 Huggingface의 Tokenizers에 대해서 소개합니다. 13-01 바이트 페어 인코딩(Byte Pair Encoding, BPE) 기계에게 아무리 많은 단어를 학습시켜도 세상의 모든 단어를 알려줄 수는 없는 노릇입니다. 만약 기계가 모르는 단어가 등장하면 그 단어를 단어 집합에 없는 단어란 의미에서 해당 토큰을 UNK(Unknown Token)라고 표현합니다. 기계가 문제를 풀 때 모르는 단어가 등장하면 (사람도 마찬가지지만) 주어진 문제를 푸는 것이 까다로워집니다. 이와 같이 모르는 단어로 인해 문제를 푸는 것이 까다로워지는 상황을 OOV(Out-Of-Vocabulary) 문제라고 합니다. 서브 워드 분리(Subword segmenation) 작업은 하나의 단어는 더 작은 단위의 의미 있는 여러 서브 워드들(Ex) birthplace = birth + place)의 조합으로 구성된 경우가 많기 때문에, 하나의 단어를 여러 서브 워드로 분리해서 단어를 인코딩 및 임베딩하겠다는 의도를 가진 전처리 작업입니다. 이를 통해 OOV나 희귀 단어, 신조어와 같은 문제를 완화시킬 수 있습니다. 실제로 언어의 특성으로 인해 영어나 한국어는 서브 워드 분리를 시도했을 때 어느 정도 의미 있는 단위로 나누는 것이 가능합니다. 이 책에서는 이런 작업을 하는 토크 나이저를 서브 워드 토크 나이저라고 명명합니다. 여기서는 OOV(Out-Of-Vocabulary) 문제를 완화하는 대표적인 서브 워드 분리 알고리즘인 BPE(Byte Pair Encoding) 알고리즘을 소개합니다. 1. BPE(Byte Pair Encoding) BPE(Byte pair encoding) 알고리즘은 1994년에 제안된 데이터 압축 알고리즘입니다. 하지만 후에 자연어 처리의 서브 워드 분리 알고리즘으로 응용되었는데 이에 대해서는 뒤에 언급하도록 하고, 우선 기존의 BPE의 작동 방법에 대해서 이해해 보겠습니다. 아래와 같은 문자열이 주어졌을 때 BPE을 수행한다고 해봅시다. aaabdaaabac BPE은 기본적으로 연속적으로 가장 많이 등장한 글자의 쌍을 찾아서 하나의 글자로 병합하는 방식을 수행합니다. 태생이 압축 알고리즘인 만큼, 여기서는 글자 대신 바이트(byte)라는 표현을 사용하겠습니다. 예를 들어 위의 문자열 중 가장 자주 등장하고 있는 바이트의 쌍(byte pair)은 'aa'입니다. 이 'aa'라는 바이트의 쌍을 하나의 바이트인 'Z'로 치환해 보겠습니다. ZabdZabac Z=aa 위 문자열 중에서 가장 많이 등장하고 있는 바이트의 쌍은 'ab'입니다. 이 'ab'를 'Y'로 치환해 봅시다. ZYdZYac Y=ab Z=aa 가장 많이 등장하고 있는 바이트의 쌍은 'ZY'입니다. 이를 'X'로 치환해 봅시다. XdXac X=ZY Y=ab Z=aa 더 이상 병합할 바이트의 쌍은 없으므로 BPE는 위의 결과를 최종 결과로 하여 종료됩니다. 2. 자연어 처리에서의 BPE(Byte Pair Encoding) 논문 : https://arxiv.org/pdf/1508.07909.pdf 자연어 처리에서의 BPE는 서브 워드 분리(subword segmentation) 알고리즘입니다. 기존에 있던 단어를 분리한다는 의미입니다. BPE을 요약하면, 글자(charcter) 단위에서 점차적으로 단어 집합(vocabulary)을 만들어 내는 Bottom up 방식의 접근을 사용합니다. 우선 훈련 데이터에 있는 단어들을 모든 글자(chracters) 또는 유니코드(unicode) 단위로 단어 집합(vocabulary)를 만들고, 가장 많이 등장하는 유니그램을 하나의 유니그램으로 통합합니다. BPE을 자연어 처리에 사용한다고 제안한 논문(Sennrich et al. (2016))에서 이미 BPE의 코드를 공개하였기 때문에, 바로 파이썬 실습이 가능합니다. 코드 실습을 진행하기 전에 육안으로 확인할 수 있는 간단한 예를 들어보겠습니다. 1) 기존의 접근 어떤 훈련 데이터로부터 각 단어들의 빈도수를 카운트했다고 해보겠습니다. 그리고 각 단어와 각 단어의 빈도수가 기록돼 있는 해당 결과는 임의로 딕셔너리(dictionary)란 이름을 붙였습니다. # dictionary # 훈련 데이터에 있는 단어와 등장 빈도수 low : 5, lower : 2, newest : 6, widest : 3 이 훈련 데이터에는 'low'란 단어가 5회 등장하였고, 'lower'란 단어는 2회 등장하였으며, 'newest'란 단어는 6회, 'widest'란 단어는 3회 등장하였다는 의미입니다. 그렇다면 딕셔너리로부터 이 훈련 데이터의 단어 집합(vocabulary)을 얻는 것은 간단합니다. # vocabulary low, lower, newest, widest 단어 집합은 중복을 배제한 단어들의 집합을 의미하므로 기존에 배운 단어 집합의 정의라면, 이 훈련 데이터의 단어 집합에는 'low', 'lower', 'newest', 'widest'라는 4개의 단어가 존재합니다. 그리고 이 경우 테스트 과정에서 'lowest'란 단어가 등장한다면 기계는 이 단어를 학습한 적이 없으므로 해당 단어에 대해서 제대로 대응하지 못하는 OOV 문제가 발생합니다. 그렇다면 BPE를 적용한다면 어떨까요? 2) BPE 알고리즘을 사용한 경우 위의 딕셔너리에 BPE를 적용해 봅시다. 우선 딕셔너리의 모든 단어들을 글자(chracter) 단위로 분리합니다. 이 경우 딕셔너리는 아래와 같습니다. 이제부터 딕셔너리는 자신 또한 업데이트되며 앞으로 단어 집합을 업데이트하기 위해 지속적으로 참고되는 참고 자료의 역할을 합니다. # dictionary l o w : 5, l o w e r : 2, n e w e s t : 6, w i d e s t : 3 딕셔너리를 참고로 한 초기 단어 집합(vocabulary)을 아래와 같습니다. 간단히 말해 초기 구성은 글자 단위로 분리된 상태입니다. # vocabulary l, o, w, e, r, n, s, t, i, d BPE의 특징은 알고리즘의 동작을 몇 회 반복(iteration) 할 것인지를 사용자가 정한다는 점입니다. 여기서는 총 10회를 수행한다고 가정합니다. 다시 말해 가장 빈도수가 높은 유니그램의 쌍을 하나의 유니그램으로 통합하는 과정을 총 10회 반복합니다. 위의 딕셔너리에 따르면 빈도수가 현재 가장 높은 유니그램의 쌍은 (e, s)입니다. 1회 - 딕셔너리를 참고로 하였을 때 빈도수가 9로 가장 높은 (e, s)의 쌍을 es로 통합합니다. # dictionary update! l o w : 5, l o w e r : 2, n e w es t : 6, w i d es t : 3 # vocabulary update! l, o, w, e, r, n, s, t, i, d, es 2회 - 빈도수가 9로 가장 높은 (es, t)의 쌍을 est로 통합합니다. # dictionary update! l o w : 5, l o w e r : 2, n e w est : 6, w i d est : 3 # vocabulary update! l, o, w, e, r, n, s, t, i, d, es, est 3회 - 빈도수가 7로 가장 높은 (l, o)의 쌍을 lo로 통합합니다. # dictionary update! lo w : 5, lo w e r : 2, n e w est : 6, w i d est : 3 # vocabulary update! l, o, w, e, r, n, s, t, i, d, es, est, lo 이와 같은 방식으로 총 10회 반복하였을 때 얻은 딕셔너리와 단어 집합은 아래와 같습니다. # dictionary update! low : 5, low e r : 2, newest : 6, widest : 3 # vocabulary update! l, o, w, e, r, n, s, t, i, d, es, est, lo, low, ne, new, newest, wi, wid, widest 이 경우 테스트 과정에서 'lowest'란 단어가 등장한다면, 기존에는 OOV에 해당되는 단어가 되었겠지만 BPE 알고리즘을 사용한 위의 단어 집합에서는 더 이상 'lowest'는 OOV가 아닙니다. 기계는 우선 'lowest'를 전부 글자 단위로 분할합니다. 즉, 'l, o, w, e, s, t'가 됩니다. 그리고 기계는 위의 단어 집합을 참고로 하여 'low'와 'est'를 찾아냅니다. 즉, 'lowest'를 기계는 'low'와 'est' 두 단어로 인코딩합니다. 그리고 이 두 단어는 둘 다 단어 집합에 있는 단어이므로 OOV가 아닙니다. 이 동작 과정을 그림으로 표현한다면 다음과 같습니다. 실제 코드를 통해 구현해 봅시다. 3) 코드 실습하기 아래 코드는 원 논문에서 공개한 코드를 참고로 하여 수정한 코드입니다. 우선 필요한 도구들을 임포트 합니다. import re, collections from IPython.display import display, Markdown, Latex BPE을 몇 회 수행할 것인지를 정합니다. 여기서는 10회로 정했습니다. num_merges = 10 BPE에 사용할 단어가 low, lower, newest, widest 일 때, BPE의 입력으로 사용하는 실제 단어 집합은 아래와 같습니다. </w>는 단어의 맨 끝에 붙이는 특수 문자이며, 각 단어는 글자(character) 단위로 분리합니다. dictionary = {'l o w </w>' : 5, 'l o w e r </w>' : 2, 'n e w e s t </w>':6, 'w i d e s t </w>':3 } BPE의 코드는 아래와 같습니다. 알고리즘은 위에서 설명했던 것과 동일하게 가장 빈도수가 높은 유니그램의 쌍을 하나의 유니그램으로 통합하는 과정으로 num_merges 회 반복합니다. def get_stats(dictionary): # 유니그램의 pair들의 빈도수를 카운트 pairs = collections.defaultdict(int) for word, freq in dictionary.items(): symbols = word.split() for i in range(len(symbols)-1): pairs[symbols[i],symbols[i+1]] += freq print('현재 pair들의 빈도수 :', dict(pairs)) return pairs def merge_dictionary(pair, v_in): v_out = {} bigram = re.escape(' '.join(pair)) p = re.compile(r'(?<!\S)' + bigram + r'(?!\S)') for word in v_in: w_out = p.sub(''.join(pair), word) v_out[w_out] = v_in[word] return v_out bpe_codes = {} bpe_codes_reverse = {} for i in range(num_merges): display(Markdown("### Iteration {}".format(i + 1))) pairs = get_stats(dictionary) best = max(pairs, key=pairs.get) dictionary = merge_dictionary(best, dictionary) bpe_codes[best] = i bpe_codes_reverse[best[0] + best[1]] = best print("new merge: {}".format(best)) print("dictionary: {}".format(dictionary)) 이를 실행하면 출력 결과는 아래와 같으며 이는 글자들의 통합 과정을 보여주고 있습니다. Iteration 1 현재 pair들의 빈도수 : {('l', 'o'): 7, ('o', 'w'): 7, ('w', '</w>'): 5, ('w', 'e'): 8, ('e', 'r'): 2, ('r', '</w>'): 2, ('n', 'e'): 6, ('e', 'w'): 6, ('e', 's'): 9, ('s', 't'): 9, ('t', '</w>'): 9, ('w', 'i'): 3, ('i', 'd'): 3, ('d', 'e'): 3} new merge: ('e', 's') dictionary: {'l o w </w>': 5, 'l o w e r </w>': 2, 'n e w es t </w>': 6, 'w i d es t </w>': 3} Iteration 2 현재 pair들의 빈도수 : {('l', 'o'): 7, ('o', 'w'): 7, ('w', '</w>'): 5, ('w', 'e'): 2, ('e', 'r'): 2, ('r', '</w>'): 2, ('n', 'e'): 6, ('e', 'w'): 6, ('w', 'es'): 6, ('es', 't'): 9, ('t', '</w>'): 9, ('w', 'i'): 3, ('i', 'd'): 3, ('d', 'es'): 3} new merge: ('es', 't') dictionary: {'l o w </w>': 5, 'l o w e r </w>': 2, 'n e w est </w>': 6, 'w i d est </w>': 3} Iteration 3 현재 pair들의 빈도수 : {('l', 'o'): 7, ('o', 'w'): 7, ('w', '</w>'): 5, ('w', 'e'): 2, ('e', 'r'): 2, ('r', '</w>'): 2, ('n', 'e'): 6, ('e', 'w'): 6, ('w', 'est'): 6, ('est', '</w>'): 9, ('w', 'i'): 3, ('i', 'd'): 3, ('d', 'est'): 3} new merge: ('est', '</w>') dictionary: {'l o w </w>': 5, 'l o w e r </w>': 2, 'n e w est</w>': 6, 'w i d est</w>': 3} Iteration 4 현재 pair들의 빈도수 : {('l', 'o'): 7, ('o', 'w'): 7, ('w', '</w>'): 5, ('w', 'e'): 2, ('e', 'r'): 2, ('r', '</w>'): 2, ('n', 'e'): 6, ('e', 'w'): 6, ('w', 'est</w>'): 6, ('w', 'i'): 3, ('i', 'd'): 3, ('d', 'est</w>'): 3} new merge: ('l', 'o') dictionary: {'lo w </w>': 5, 'lo w e r </w>': 2, 'n e w est</w>': 6, 'w i d est</w>': 3} Iteration 5 현재 pair들의 빈도수 : {('lo', 'w'): 7, ('w', '</w>'): 5, ('w', 'e'): 2, ('e', 'r'): 2, ('r', '</w>'): 2, ('n', 'e'): 6, ('e', 'w'): 6, ('w', 'est</w>'): 6, ('w', 'i'): 3, ('i', 'd'): 3, ('d', 'est</w>'): 3} new merge: ('lo', 'w') dictionary: {'low </w>': 5, 'low e r </w>': 2, 'n e w est</w>': 6, 'w i d est</w>': 3} Iteration 6 현재 pair들의 빈도수 : {('low', '</w>'): 5, ('low', 'e'): 2, ('e', 'r'): 2, ('r', '</w>'): 2, ('n', 'e'): 6, ('e', 'w'): 6, ('w', 'est</w>'): 6, ('w', 'i'): 3, ('i', 'd'): 3, ('d', 'est</w>'): 3} new merge: ('n', 'e') dictionary: {'low </w>': 5, 'low e r </w>': 2, 'ne w est</w>': 6, 'w i d est</w>': 3} Iteration 7 현재 pair들의 빈도수 : {('low', '</w>'): 5, ('low', 'e'): 2, ('e', 'r'): 2, ('r', '</w>'): 2, ('ne', 'w'): 6, ('w', 'est</w>'): 6, ('w', 'i'): 3, ('i', 'd'): 3, ('d', 'est</w>'): 3} new merge: ('ne', 'w') dictionary: {'low </w>': 5, 'low e r </w>': 2, 'new est</w>': 6, 'w i d est</w>': 3} Iteration 8 현재 pair들의 빈도수 : {('low', '</w>'): 5, ('low', 'e'): 2, ('e', 'r'): 2, ('r', '</w>'): 2, ('new', 'est</w>'): 6, ('w', 'i'): 3, ('i', 'd'): 3, ('d', 'est</w>'): 3} new merge: ('new', 'est</w>') dictionary: {'low </w>': 5, 'low e r </w>': 2, 'newest</w>': 6, 'w i d est</w>': 3} Iteration 9 현재 pair들의 빈도수 : {('low', '</w>'): 5, ('low', 'e'): 2, ('e', 'r'): 2, ('r', '</w>'): 2, ('w', 'i'): 3, ('i', 'd'): 3, ('d', 'est</w>'): 3} new merge: ('low', '</w>') dictionary: {'low</w>': 5, 'low e r </w>': 2, 'newest</w>': 6, 'w i d est</w>': 3} Iteration 10 현재 pair들의 빈도수 : {('low', 'e'): 2, ('e', 'r'): 2, ('r', '</w>'): 2, ('w', 'i'): 3, ('i', 'd'): 3, ('d', 'est</w>'): 3} new merge: ('w', 'i') dictionary: {'low</w>': 5, 'low e r </w>': 2, 'newest</w>': 6, 'wi d est</w>': 3} e와 s의 쌍은 초기 단어 집합에서 총 9회 등장했습니다. 그렇기 때문에 es로 통합됩니다. 그다음으로는 es와 t의 쌍을, 그다음으로는 est와 </w>의 쌍을 통합시킵니다. 빈도수가 가장 높은 순서대로 통합하는 이 과정을 총 num_merges 회 반복한 것입니다. bpe_codes를 출력하면 merge 했던 기록이 출력됩니다. print(bpe_codes) {('e', 's'): 0, ('es', 't'): 1, ('est', '</w>'): 2, ('l', 'o'): 3, ('lo', 'w'): 4, ('n', 'e'): 5, ('ne', 'w'): 6, ('new', 'est</w>'): 7, ('low', '</w>'): 8, ('w', 'i'): 9} 이 기록은 새로운 단어가 등장하였을 때, 현재 가지고 있는 서브 워드 단어 집합에 의거하여 분리하는 일에 참고할 수 있습니다. 4) OOV에 대처하기 def get_pairs(word): """Return set of symbol pairs in a word. Word is represented as a tuple of symbols (symbols being variable-length strings). """ pairs = set() prev_char = word[0] for char in word[1:]: pairs.add((prev_char, char)) prev_char = char return pairs def encode(orig): """Encode word based on list of BPE merge operations, which are applied consecutively""" word = tuple(orig) + ('</w>',) display(Markdown("__word split into characters:__ <tt>{}</tt>".format(word))) pairs = get_pairs(word) if not pairs: return orig iteration = 0 while True: iteration += 1 display(Markdown("__Iteration {}:__".format(iteration))) print("bigrams in the word: {}".format(pairs)) bigram = min(pairs, key = lambda pair: bpe_codes.get(pair, float('inf'))) print("candidate for merging: {}".format(bigram)) if bigram not in bpe_codes: display(Markdown("__Candidate not in BPE merges, algorithm stops.__")) break first, second = bigram new_word = [] i = 0 while i < len(word): try: j = word.index(first, i) new_word.extend(word[i:j]) i = j except: new_word.extend(word[i:]) break if word[i] == first and i < len(word)-1 and word[i+1] == second: new_word.append(first+second) i += 2 else: new_word.append(word[i]) i += 1 new_word = tuple(new_word) word = new_word print("word after merging: {}".format(word)) if len(word) == 1: break else: pairs = get_pairs(word) # 특별 토큰인 </w>는 출력하지 않는다. if word[-1] == '</w>': word = word[:-1] elif word[-1].endswith('</w>'): word = word[:-1] + (word[-1].replace('</w>',''),) return word 단어 'loki'가 들어오면 BPE 알고리즘 해당 단어를 어떻게 분리할까요? encode("loki") word split into characters: ('l', 'o', 'k', 'i', '') Iteration 1: bigrams in the word: {('i', '</w>'), ('o', 'k'), ('l', 'o'), ('k', 'i')} candidate for merging: ('l', 'o') word after merging: ('lo', 'k', 'i', '</w>') Iteration 2: bigrams in the word: {('i', '</w>'), ('k', 'i'), ('lo', 'k')} candidate for merging: ('i', '</w>') Candidate not in BPE merges, algorithm stops. ('lo', 'k', 'i') 현재 서브 워드 단어 집합에는 'lo'가 존재하므로, 'lo'는 유지하고 'k'와 'i'는 분리시킵니다. 단어 'lowest'에 대해서도 수행해 봅시다. encode("lowest") word split into characters: ('l', 'o', 'w', 'e', 's', 't', '') Iteration 1: bigrams in the word: {('e', 's'), ('s', 't'), ('t', '</w>'), ('o', 'w'), ('w', 'e'), ('l', 'o')} candidate for merging: ('e', 's') word after merging: ('l', 'o', 'w', 'es', 't', '</w>') Iteration 2: bigrams in the word: {('w', 'es'), ('es', 't'), ('t', '</w>'), ('o', 'w'), ('l', 'o')} candidate for merging: ('es', 't') word after merging: ('l', 'o', 'w', 'est', '</w>') Iteration 3: bigrams in the word: {('o', 'w'), ('l', 'o'), ('est', '</w>'), ('w', 'est')} candidate for merging: ('est', '</w>') word after merging: ('l', 'o', 'w', 'est</w>') Iteration 4: bigrams in the word: {('o', 'w'), ('l', 'o'), ('w', 'est</w>')} candidate for merging: ('l', 'o') word after merging: ('lo', 'w', 'est</w>') Iteration 5: bigrams in the word: {('lo', 'w'), ('w', 'est</w>')} candidate for merging: ('lo', 'w') word after merging: ('low', 'est</w>') Iteration 6: bigrams in the word: {('low', 'est</w>')} candidate for merging: ('low', 'est</w>') Candidate not in BPE merges, algorithm stops. ('low', 'est') 현재 서브 워드 단어 집합에 'low'와 'est'가 존재하므로, 'low'와 'est'를 분리시킵니다. 단어 'lowing'에 대해서도 수행해 봅시다. encode("lowing") word split into characters: ('l', 'o', 'w', 'i', 'n', 'g', '') Iteration 1: bigrams in the word: {('n', 'g'), ('w', 'i'), ('g', '</w>'), ('i', 'n'), ('o', 'w'), ('l', 'o')} candidate for merging: ('l', 'o') word after merging: ('lo', 'w', 'i', 'n', 'g', '</w>') Iteration 2: bigrams in the word: {('lo', 'w'), ('n', 'g'), ('w', 'i'), ('g', '</w>'), ('i', 'n')} candidate for merging: ('lo', 'w') word after merging: ('low', 'i', 'n', 'g', '</w>') Iteration 3: bigrams in the word: {('n', 'g'), ('g', '</w>'), ('i', 'n'), ('low', 'i')} candidate for merging: ('n', 'g') Candidate not in BPE merges, algorithm stops. ('low', 'i', 'n', 'g') 현재 서브 워드 단어 집합에 'low'가 존재하지만, 'i', 'n', 'g'의 바이 그램 조합으로 이루어진 서브 워드는 존재하지 않으므로 'i', 'n', 'g'로 전부 분리합니다. 훈련된 데이터 중에서 어떤 서브 워드도 존재하지 않는 'highing'은 어떨까요? encode("highing") word split into characters: ('h', 'i', 'g', 'h', 'i', 'n', 'g', '') Iteration 1: bigrams in the word: {('n', 'g'), ('g', 'h'), ('h', 'i'), ('g', '</w>'), ('i', 'n'), ('i', 'g')} candidate for merging: ('n', 'g') Candidate not in BPE merges, algorithm stops. ('h', 'i', 'g', 'h', 'i', 'n', 'g') 모든 알파벳이 분리됩니다. BPE 외에도 BPE를 참고하여 만들어진 Wordpiece Tokenizer나 Unigram Language Model Tokenizer와 같은 서브 워드 분리 알고리즘이 존재합니다. 이 두 알고리즘에 대해서는 간략히 이런 것들이 존재한다 정도로만 언급하고 넘어가겠습니다. 3. WordPiece Tokenizer 논문 : https://static.googleusercontent.com/media/research.google.com/ko//pubs/archive/37842.pdf 구글이 위 WordPiece Tokenizer를 변형하여 번역기에 사용했다는 논문 : https://arxiv.org/pdf/1609.08144.pdf WordPiece Tokenizer은 BPE의 변형 알고리즘입니다. 해당 알고리즘은 BPE가 빈도수에 기반하여 가장 많이 등장한 쌍을 병합하는 것과는 달리, 병합되었을 때 코퍼스의 우도(Likelihood)를 가장 높이는 쌍을 병합합니다. 2016년의 위 논문에서 구글은 구글 번역기에서 WordPiece Tokenizer가 수행된 결과에 대해서 기술하였습니다. 수행하기 이전의 문장: Jet makers feud over seat width with big orders at stake WordPiece Tokenizer를 수행한 결과(wordpieces): _J et _makers _fe ud _over _seat _width _with _big _orders _at _stake Jet는 J와 et로 나누어졌으며, feud는 fe와 ud로 나누어진 것을 볼 수 있습니다. WordPiece Tokenizer는 모든 단어의 맨 앞에 _를 붙이고, 단어는 서브 워드(subword)로 통계에 기반하여 띄어쓰기로 분리합니다. 여기서 언더바 _는 문장 복원을 위한 장치입니다. 예컨대, WordPiece Tokenizer의 결과로 나온 문장을 보면, Jet → _J et와 같이 기존에 없던 띄어쓰기가 추가되어 서브 워드(subwords)들을 구분하는 구분자 역할을 하고 있습니다. 그렇다면 기존에 있던 띄어쓰기와 구분자 역할의 띄어쓰기는 어떻게 구별할까요? 이 역할을 수행하는 것이 단어들 앞에 붙은 언더바 _입니다. WordPiece Tokenizer이 수행된 결과로부터 다시 수행 전의 결과로 돌리는 방법은 현재 있는 모든 띄어쓰기를 전부 제거하고, 언더바를 띄어쓰기로 바꾸면 됩니다. 이 알고리즘은 유명 딥 러닝 모델 BERT를 훈련하기 위해서 사용되기도 하였습니다. 4. Unigram Language Model Tokenizer 논문 : https://arxiv.org/pdf/1804.10959.pdf 유니그램 언어 모델 토크 나이저는 각각의 서브 워드들에 대해서 손실(loss)을 계산합니다. 여기서 서브 단어의 손실이라는 것은 해당 서브 워드가 단어 집합에서 제거되었을 경우, 코퍼스의 우도(Likelihood)가 감소하는 정도를 말합니다. 이렇게 측정된 서브 워드들을 손실의 정도로 정렬하여, 최악의 영향을 주는 10~20%의 토큰을 제거합니다. 이를 원하는 단어 집합의 크기에 도달할 때까지 반복합니다. 지금까지 서브 워드 토크나이징 알고리즘들에 대해서 정리해 보았습니다. 이어서 이를 실무에서 사용하기 위한 패키지인 센텐스 피스(SentencePiece)나 토크 나이 저스(tokenizers)의 사용법에 대해서 학습합니다. 13-02 센텐스 피스(SentencePiece) 앞서 서브 워드 토큰화를 위한 BPE(Byte Pair Encoding) 알고리즘과 그 외 BPE의 변형 알고리즘에 대해서 간단히 언급했습니다. BPE를 포함하여 기타 서브 워드 토크나이징 알고리즘들을 내장한 센텐스 피스(SentencePiece)는 일반적으로 실무에서 선택할 수 있는 최선의 선택 중 하나입니다. 1. 센텐스 피스(SentencePiece) 논문 : https://arxiv.org/pdf/1808.06226.pdf 센텐스 피스 깃허브 : https://github.com/google/sentencepiece 내부 단어 분리를 위한 유용한 패키지로 구글의 센텐스 피스(Sentencepiece)가 있습니다. 구글은 BPE 알고리즘과 Unigram Language Model Tokenizer를 구현한 센텐스 피스를 깃허브에 공개하였습니다. 내부 단어 분리 알고리즘을 사용하기 위해서, 데이터에 단어 토큰화를 먼저 진행한 상태여야 한다면 이 단어 분리 알고리즘을 모든 언어에 사용하는 것은 쉽지 않습니다. 영어와 달리 한국어와 같은 언어는 단어 토큰화부터가 쉽지 않기 때문입니다. 그런데, 이런 사전 토큰화 작업(pretokenization) 없이 전처리를 하지 않은 데이터(raw data)에 바로 단어 분리 토크 나이저를 사용할 수 있다면, 이 토크 나이저는 그 어떤 언어에도 적용할 수 있는 토크 나이저가 될 것입니다. 센텐스 피스는 이 이점을 살려서 구현되었습니다. 센텐스 피스는 사전 토큰화 작업 없이 단어 분리 토큰화를 수행하므로 언어에 종속되지 않습니다. pip install sentencepiece 2. IMDB 리뷰 토큰화하기 import sentencepiece as spm import pandas as pd import urllib.request import csv IMDB 리뷰 데이터를 다운로드하고 이를 데이터 프레임에 저장합니다. urllib.request.urlretrieve("https://raw.githubusercontent.com/LawrenceDuan/IMDb-Review-Analysis/master/IMDb_Reviews.csv", filename="IMDb_Reviews.csv") train_df = pd.read_csv('IMDb_Reviews.csv') train_df['review'] 0 My family and I normally do not watch local mo... 1 Believe it or not, this was at one time the wo... 2 After some internet surfing, I found the "Home... 3 One of the most unheralded great works of anim... 4 It was the Sixties, and anyone with long hair ... ... 49995 the people who came up with this are SICK AND ... 49996 The script is so so laughable... this in turn,... 49997 "So there's this bride, you see, and she gets ... 49998 Your mind will not be satisfied by this no—bud... 49999 The chaser's war on everything is a weekly sho... Name: review, Length: 50000, dtype: object print('리뷰 개수 :',len(train_df)) # 리뷰 개수 출력 리뷰 개수 : 50000 총 5만 개의 샘플이 존재합니다. 센텐스 피스의 입력으로 사용하기 위해서 데이터 프레임을 txt 파일로 저장합니다. with open('imdb_review.txt', 'w', encoding='utf8') as f: f.write('\n'.join(train_df['review'])) 센텐스 피스로 단어 집합과 각 단어에 고유한 정수를 부여해 보겠습니다. spm.SentencePieceTrainer.Train('--input=imdb_review.txt --model_prefix=imdb --vocab_size=5000 --model_type=bpe --max_sentence_length=9999') 각 인자가 의미하는 바는 다음과 같습니다. input : 학습시킬 파일 model_prefix : 만들어질 모델 이름 vocab_size : 단어 집합의 크기 model_type : 사용할 모델 (unigram(default), bpe, char, word) max_sentence_length: 문장의 최대 길이 pad_id, pad_piece: pad token id, 값 unk_id, unk_piece: unknown token id, 값 bos_id, bos_piece: begin of sentence token id, 값 eos_id, eos_piece: end of sequence token id, 값 user_defined_symbols: 사용자 정의 토큰 vocab 생성이 완료되면 imdb.model, imdb.vocab 파일 두 개가 생성됩니다. vocab 파일에서 학습된 서브 워드들을 확인할 수 있습니다. 단어 집합의 크기를 확인하기 위해 vocab 파일을 데이터 프레임에 저장해 봅시다. vocab_list = pd.read_csv('imdb.vocab', sep='\t', header=None, quoting=csv.QUOTE_NONE) vocab_list.sample(10) 위에서 vocab_size의 인자를 통해 단어 집합의 크기를 5,000개로 제한하였으므로 단어 집합의 크기는 5,000개입니다. len(vocab_list) 5000 model 파일을 로드하여 단어 시퀀스를 정수 시퀀스로 바꾸는 인코딩 작업이나 반대로 변환하는 디코딩 작업을 할 수 있습니다. sp = spm.SentencePieceProcessor() vocab_file = "imdb.model" sp.load(vocab_file) True 아래의 두 가지 도구를 테스트해 보겠습니다. encode_as_pieces : 문장을 입력하면 서브 워드 시퀀스로 변환합니다. encode_as_ids : 문장을 입력하면 정수 시퀀스로 변환합니다. lines = [ "I didn't at all think of it this way.", "I have waited a long time for someone to film" ] for line in lines: print(line) print(sp.encode_as_pieces(line)) print(sp.encode_as_ids(line)) print() I didn't at all think of it this way. ['▁ I', '▁ didn', "'", 't', '▁ at', '▁ all', '▁ think', '▁ of', '▁ it', '▁ this', '▁ way', '.'] [41, 623, 4950, 4926, 138, 169, 378, 30, 58, 73, 413, 4945] I have waited a long time for someone to film ['▁ I', '▁ have', '▁ wa', 'ited', '▁ a', '▁ long', '▁ time', '▁ for', '▁ someone', '▁ to', '▁ film'] [41, 141, 1364, 1120, 4, 666, 285, 92, 1078, 33, 91] GetPieceSize() : 단어 집합의 크기를 확인합니다. sp.GetPieceSize() 5000 idToPiece : 정수로부터 매핑되는 서브 워드로 변환합니다. sp.IdToPiece(430) ▁ character PieceToId : 서브 워드로부터 매핑되는 정수로 변환합니다. sp.PieceToId('▁ character') 430 DecodeIds : 정수 시퀀스로부터 문장으로 변환합니다. sp.DecodeIds([41, 141, 1364, 1120, 4, 666, 285, 92, 1078, 33, 91]) DecodePieces : 서브 워드 시퀀스로부터 문장으로 변환합니다. I have waited a long time for someone to film sp.DecodePieces(['▁ I', '▁ have', '▁ wa', 'ited', '▁ a', '▁ long', '▁ time', '▁ for', '▁ someone', '▁ to', '▁ film']) encode : 문장으로부터 인자 값에 따라서 정수 시퀀스 또는 서브 워드 시퀀스로 변환 가능합니다. I have waited a long time for someone to film print(sp.encode('I have waited a long time for someone to film', out_type=str)) print(sp.encode('I have waited a long time for someone to film', out_type=int)) ['▁ I', '▁ have', '▁ wa', 'ited', '▁ a', '▁ long', '▁ time', '▁ for', '▁ someone', '▁ to', '▁ film'] [41, 141, 1364, 1120, 4, 666, 285, 92, 1078, 33, 91] 3. 네이버 영화 리뷰 토큰화하기 네이버 영화 리뷰 데이터에 대해서 위의 IMDB 리뷰 데이터와 동일한 과정을 진행해 보겠습니다. import pandas as pd import sentencepiece as spm import urllib.request import csv 네이버 영화 리뷰 데이터를 다운로드하여 데이터 프레임에 저장합니다. urllib.request.urlretrieve("https://raw.githubusercontent.com/e9t/nsmc/master/ratings.txt", filename="ratings.txt") naver_df = pd.read_table('ratings.txt') naver_df[:5] 총 20만 개의 샘플이 존재합니다. print('리뷰 개수 :',len(naver_df)) # 리뷰 개수 출력 리뷰 개수 : 200000 네이버 영화 리뷰 데이터의 경우 Null 값이 존재하므로 이를 제거한 후에 수행합니다. print(naver_df.isnull().values.any()) True naver_df = naver_df.dropna(how = 'any') # Null 값이 존재하는 행 제거 print(naver_df.isnull().values.any()) # Null 값이 존재하는지 확인 False print('리뷰 개수 :',len(naver_df)) # 리뷰 개수 출력 리뷰 개수 : 199992 최종적으로 199,992개의 샘플을 naver_review.txt 파일에 저장한 후에 센텐스 피스를 통해 단어 집합을 생성합니다. with open('naver_review.txt', 'w', encoding='utf8') as f: f.write('\n'.join(naver_df['document'])) spm.SentencePieceTrainer.Train('--input=naver_review.txt --model_prefix=naver --vocab_size=5000 --model_type=bpe --max_sentence_length=9999') vocab 생성이 완료되면 naver.model, naver.vocab 파일 두 개가 생성됩니다. .vocab에서 학습된 subwords를 확인할 수 있습니다. vocab_list = pd.read_csv('naver.vocab', sep='\t', header=None, quoting=csv.QUOTE_NONE) vocab_list[:10] vocab_list.sample(10) Vocabulary에는 unknown, 문장의 시작, 문장의 끝을 의미하는 special token이 0, 1, 2에 사용되었습니다. len(vocab_list) 5000 설정한 대로 5000개의 서브 워드가 단어 집합에 존재합니다. sp = spm.SentencePieceProcessor() vocab_file = "naver.model" sp.load(vocab_file) True lines = [ "뭐 이딴 것도 영화냐.", "진짜 최고의 영화입니다 ㅋㅋ", ] for line in lines: print(line) print(sp.encode_as_pieces(line)) print(sp.encode_as_ids(line)) print() 뭐 이딴 것도 영화냐. ['▁뭐', '▁이딴', '▁것도', '▁영화냐', '.'] [132, 966, 1296, 2590, 3276] 진짜 최고의 영화입니다 ㅋㅋ ['▁진짜', '▁최고의', '▁영화입니다', '▁ᄏᄏ'] [54, 200, 821, 85] GetPieceSize() : 단어 집합의 크기를 확인합니다. sp.GetPieceSize() 5000 idToPiece : 정수로부터 매핑되는 서브 워드로 변환합니다. sp.IdToPiece(4) '영화' PieceToId : 서브 워드로부터 매핑되는 정수로 변환합니다. sp.PieceToId('영화') DecodeIds : 정수 시퀀스로부터 문장으로 변환합니다. sp.DecodeIds([54, 200, 821, 85]) 진짜 최고의 영화입니다 ᄏᄏ DecodePieces : 서브 워드 시퀀스로부터 문장으로 변환합니다. sp.DecodePieces(['▁진짜', '▁최고의', '▁영화입니다', '▁ᄏᄏ']) 진짜 최고의 영화입니다 ᄏᄏ encode : 문장으로부터 인자 값에 따라서 정수 시퀀스 또는 서브 워드 시퀀스로 변환 가능합니다. print(sp.encode('진짜 최고의 영화입니다 ㅋㅋ', out_type=str)) print(sp.encode('진짜 최고의 영화입니다 ㅋㅋ', out_type=int)) ['▁진짜', '▁최고의', '▁영화입니다', '▁ᄏᄏ'] [54, 200, 821, 85] 13-03 서브 워드 텍스트 인코더(SubwordTextEncoder) SubwordTextEncoder는 텐서 플로를 통해 사용할 수 있는 서브 워드 토크 나이저입니다. BPE와 유사한 알고리즘인 Wordpiece Model을 채택하였으며, 패키지를 통해 쉽게 단어들을 서브 워드들로 분리할 수 있습니다. SubwordTextEncoder를 통해서 IMDB 영화 리뷰 데이터와 네이버 영화 리뷰 데이터에 대해서 토큰화 작업을 수행해 봅시다. Tensorflow 2.3+ 버전에서는 tfds.features.text 대신 tfds.deprecated.text라고 작성해야 합니다. 1. IMDB 리뷰 토큰화하기 import pandas as pd import urllib.request import tensorflow_datasets as tfds 다운로드한 데이터를 데이터 프레임에 저장합니다. urllib.request.urlretrieve("https://raw.githubusercontent.com/LawrenceDuan/IMDb-Review-Analysis/master/IMDb_Reviews.csv", filename="IMDb_Reviews.csv") train_df = pd.read_csv('IMDb_Reviews.csv') 데이터 프레임에서 'review'에 해당하는 열이 토큰화를 수행해야 할 데이터입니다. train_df['review'] 0 My family and I normally do not watch local mo... 1 Believe it or not, this was at one time the wo... 2 After some internet surfing, I found the "Home... 3 One of the most unheralded great works of anim... 4 It was the Sixties, and anyone with long hair ... ... 49995 the people who came up with this are SICK AND ... 49996 The script is so so laughable... this in turn,... 49997 "So there's this bride, you see, and she gets ... 49998 Your mind will not be satisfied by this no—bud... 49999 The chaser's war on everything is a weekly sho... Name: review, Length: 50000, dtype: object tfds.features.text.SubwordTextEncoder.build_from_corpus의 인자로 토큰화할 데이터를 넣어줍니다. 이 작업을 통해서 서브 워드들로 이루어진 단어 집합(Vocabulary)를 생성하고, 각 서브 워드에 고유한 정수를 부여합니다. tokenizer = tfds.features.text.SubwordTextEncoder.build_from_corpus( train_df['review'], target_vocab_size=2**13) .subwords를 통해서 토큰화된 서브 워드들을 확인할 수 있습니다. 100개만 출력해 봅시다. print(tokenizer.subwords[:100]) ['the_', ', ', '. ', 'a_', 'and_', 'of_', 'to_', 's_', 'is_', 'br', 'in_', 'I_', 'that_', 'this_', 'it_', ' /><', ' />', 'was_', 'The_', 't_', 'as_', 'with_', 'for_', '.<', 'on_', 'but_', 'movie_', 'are_', ' (', 'have_', 'his_', 'film_', 'not_', 'be_', 'you_', 'ing_', ' "', 'ed_', 'it', 'd_', 'an_', 'at_', 'by_', 'he_', 'one_', 'who_', 'from_', 'y_', 'or_', 'e_', 'like_', 'all_', '" ', 'they_', 'so_', 'just_', 'has_', ') ', 'about_', 'her_', 'out_', 'This_', 'some_', 'movie', 'ly_', 'film', 'very_', 'more_', 'It_', 'what_', 'would_', 'when_', 'if_', 'good_', 'up_', 'which_', 'their_', 'only_', 'even_', 'my_', 'really_', 'had_', 'can_', 'no_', 'were_', 'see_', '? ', 'she_', 'than_', '! ', 'there_', 'been_', 'get_', 'into_', 'will_', ' - ', 'much_', 'n_', 'because_', 'ing'] 임의로 선택한 20번 인덱스의 샘플을 출력해 보고, 정수 인코딩을 수행한 결과와 비교해 보겠습니다. print(train_df['review'][20]) Pretty bad PRC cheapie which I rarely bother to watch over again, and it's no wonder -- it's slow and creaky and dull as a butter knife. Mad doctor George Zucco is at it again, turning a dimwitted farmhand in overalls (Glenn Strange) into a wolf-man. Unfortunately, the makeup is virtually non-existent, consisting only of a beard and dimestore fangs for the most part. If it were not for Zucco and Strange's presence, along with the cute Anne Nagel, this would be completely unwatchable. Strange, who would go on to play Frankenstein's monster for Unuiversal in two years, does a Lenny impression from "Of Mice and Men", it seems.<br /><br />*1/2 (of Four) encode()를 통해서 입력한 데이터에 대해서 정수 인코딩을 수행한 결과를 얻을 수 있습니다. print('Tokenized sample question: {}'.format(tokenizer.encode(train_df['review'][20]))) Tokenized sample question: [1590, 4162, 132, 7107, 1892, 2983, 578, 76, 12, 4632, 3422, 7, 160, 175, 372, 2, 5, 39, 8051, 8, 84, 2652, 497, 39, 8051, 8, 1374, 5, 3461, 2012, 48, 5, 2263, 21, 4, 2992, 127, 4729, 711, 3, 1391, 8044, 3557, 1277, 8102, 2154, 5681, 9, 42, 15, 372, 2, 3773, 4, 3502, 2308, 467, 4890, 1503, 11, 3347, 1419, 8127, 29, 5539, 98, 6099, 58, 94, 4, 1388, 4230, 8057, 213, 3, 1966, 2, 1, 6700, 8044, 9, 7069, 716, 8057, 6600, 2, 4102, 36, 78, 6, 4, 1865, 40, 5, 3502, 1043, 1645, 8044, 1000, 1813, 23, 1, 105, 1128, 3, 156, 15, 85, 33, 23, 8102, 2154, 5681, 5, 6099, 8051, 8, 7271, 1055, 2, 534, 22, 1, 3046, 5214, 810, 634, 8120, 2, 14, 71, 34, 436, 3311, 5447, 783, 3, 6099, 2, 46, 71, 193, 25, 7, 428, 2274, 2260, 6487, 8051, 8, 2149, 23, 1138, 4117, 6023, 163, 11, 148, 735, 2, 164, 4, 5277, 921, 3395, 1262, 37, 639, 1349, 349, 5, 2460, 328, 15, 5349, 8127, 24, 10, 16, 10, 17, 8054, 8061, 8059, 8062, 29, 6, 6607, 8126, 8053] 임의로 선택한 짧은 문장에 대해서 정수 인코딩 결과를 확인하고, 이를 다시역으로 디코딩 해보겠습니다. 디코딩 할 때는 인코딩할 때 encode()를 사용한 것과 유사하게 decode()를 통해서 할 수 있습니다. # train_df에 존재하는 문장 중 일부를 발췌 sample_string = "It's mind-blowing to me that this film was even made." # 인코딩한 결과를 tokenized_string에 저장 tokenized_string = tokenizer.encode(sample_string) print ('정수 인코딩 후의 문장 : {}'.format(tokenized_string)) # 이를 다시 디코딩 original_string = tokenizer.decode(tokenized_string) print ('기존 문장 : {}'.format(original_string)) 정수 인코딩 후의 문장 : [137, 8051, 8, 910, 8057, 2169, 36, 7, 103, 13, 14, 32, 18, 79, 681, 8058] 기존 문장 : It's mind-blowing to me that this film was even made. .vocab_size를 통해 단어 집합의 크기를 확인할 수 있습니다. print('단어 집합의 크기(Vocab size) :', tokenizer.vocab_size) 단어 집합의 크기(Vocab size) : 8268 현재 단어 집합의 크기는 8,268개입니다. 디코딩 결과를 병렬적으로 나열하여 각 단어와 매핑된 정수를 확인해 봅시다. for ts in tokenized_string: print ('{} ----> {}'.format(ts, tokenizer.decode([ts]))) 137 ----> It 8051 ----> ' 8 ----> s 910 ----> mind 8057 ----> - 2169 ----> blow 36 ----> ing 7 ----> to 103 ----> me 13 ----> that 14 ----> this 32 ----> film 18 ----> was 79 ----> even 681 ----> made 8058 ----> . 이번에는 기존 예제 문장 중 even이라는 단어에 임의로 xyz라는 3개의 글자를 추가해 봤습니다. 현재 토크 나이저가 even이라는 단어를 이미 하나의 서브 워드로 인식하고 있는 상황에서 나머지 xyz를 어떻게 분리하는지를 확인하기 위함입니다. # 앞서 실습한 문장에 even 뒤에 임의로 xyz 추가 sample_string = "It's mind-blowing to me that this film was evenxyz made." # 인코딩한 결과를 tokenized_string에 저장 tokenized_string = tokenizer.encode(sample_string) print ('정수 인코딩 후의 문장 : {}'.format(tokenized_string)) # 이를 다시 디코딩 original_string = tokenizer.decode(tokenized_string) print ('기존 문장 : {}'.format(original_string)) 정수 인코딩 후의 문장 [137, 8051, 8, 910, 8057, 2169, 36, 7, 103, 13, 14, 32, 18, 7974, 8132, 8133, 997, 681, 8058] 기존 문장: It's mind-blowing to me that this film was evenxyz made. for ts in tokenized_string: print ('{} ----> {}'.format(ts, tokenizer.decode([ts]))) 137 ----> It 8051 ----> ' 8 ----> s 910 ----> mind 8057 ----> - 2169 ----> blow 36 ----> ing 7 ----> to 103 ----> me 13 ----> that 14 ----> this 32 ----> film 18 ----> was 7974 ----> even 8132 ----> x 8133 ----> y 997 ----> z 681 ----> made 8058 ----> . evenxyz에서 even을 독립적으로 분리하고 xyz는 훈련 데이터에서 하나의 단어로서 등장한 적이 없으므로 각각 전부 분리됩니다. 2. 네이버 영화 리뷰 토큰화하기 네이버 영화 리뷰에 대해서도 위에서 IMDB 영화 리뷰에 대해서 수행한 동일한 작업을 진행해 봅시다. import pandas as pd import urllib.request import tensorflow_datasets as tfds 다운로드한 데이터를 데이터 프레임에 저장합니다. urllib.request.urlretrieve("https://raw.githubusercontent.com/e9t/nsmc/master/ratings_train.txt", filename="ratings_train.txt") train_data = pd.read_table('ratings_train.txt') 이 데이터에는 Null 값이 존재하므로 이를 제거해 줍니다. print(train_data.isnull().sum()) id 0 document 5 label 0 dtype: int64 train_data = train_data.dropna(how = 'any') # Null 값이 존재하는 행 제거 print(train_data.isnull().values.any()) # Null 값이 존재하는지 확인 tfds.features.text.SubwordTextEncoder.build_from_corpus의 인자로 네이버 영화 리뷰 데이터를 넣어서, 서브 워드들로 이루어진 단어 집합(Vocabulary)를 생성하고, 각 서브 워드에 고유한 정수를 부여합니다. tokenizer = tfds.features.text.SubwordTextEncoder.build_from_corpus( train_data['document'], target_vocab_size=2**13) 토큰화된 100개의 서브 워드들을 출력해 봅시다. print(tokenizer.subwords[:100]) ['. ', '..', '영화', '이_', '...', '의_', '는_', '도_', '다', ', ', '을_', '고_', '은_', '가_', '에_', '.. ', '한_', '너무_', '정말_', '를_', '고', '게_', '영화_', '지', '... ', '진짜_', '이', '다_', '요', '만_', '? ', '과_', '나', '가', '서_', '지_', '로_', '으로_', '아', '어', '....', '음', '한', '수_', '와_', '도', '네', '그냥_', '나_', '더_', '왜_', '이런_', '면_', '기', '하고_', '보고_', '하는_', '서', '좀_', '리', '자', '스', '안', '! ', '에서_', '영화를_', '미', 'ㅋㅋ', '네요', '시', '주', '라', '는', '오', '없는_', '에', '해', '사', '!!', '영화는_', '마', '잘_', '수', '영화가_', '만', '본_', '로', '그_', '지만_', '대', '은', '비', '의', '일', '개', '있는_', '없다', '함', '구', '하'] encode()를 통해 임의로 선택한 20번 인덱스의 샘플을 출력해 보고, 정수 인코딩을 수행한 결과와 비교해 보겠습니다. print(train_data['document'][20]) 나름 심오한 뜻도 있는 듯. 그냥 학생이 선생과 놀아나는 영화는 절대 아님 print('Tokenized sample question: {}'.format(tokenizer.encode(train_data['document'][20]))) Tokenized sample question: [669, 4700, 17, 1749, 8, 96, 131, 1, 48, 2239, 4, 7466, 32, 1274, 2655, 7, 80, 749, 1254] 21번 인덱스 샘플에 대해서 정수 인코딩 결과를 확인하고, 이를 다시역으로 디코딩 해보겠습니다. 디코딩 할 때는 인코딩할 때 encode()를 사용한 것과 유사하게 decode()를 통해서 할 수 있습니다. sample_string = train_data['document'][21] # 인코딩한 결과를 tokenized_string에 저장 tokenized_string = tokenizer.encode(sample_string) print ('정수 인코딩 후의 문장 : {}'.format(tokenized_string)) # 이를 다시 디코딩 original_string = tokenizer.decode(tokenized_string) print ('기존 문장 : {}'.format(original_string)) 정수 인코딩 후의 문장 : [570, 892, 36, 584, 159, 7091, 201] 기존 문장 : 보면서 웃지 않는 건 불가능하다 for ts in tokenized_string: print ('{} ----> {}'.format(ts, tokenizer.decode([ts]))) 570 ----> 보면서 892 ----> 웃 36 ----> 지 584 ----> 않는 159 ----> 건 7091 ----> 불가능 201 ----> 하다 13-04 허깅 페이스 토크 나이저(Huggingface Tokenizer) 자연어 처리 스타트업 허깅 페이스가 개발한 패키지 tokenizers는 자주 등장하는 서브 워드들을 하나의 토큰으로 취급하는 다양한 서브 워드 토크 나이저를 제공합니다. 이번 실습에서는 이 중에서 WordPiece Tokenizer를 실습해 보겠습니다. 실습을 위해 우선 tokenizers를 설치합니다. pip install tokenizers 1. BERT의 워드 피스 토크 나이저(BertWordPieceTokenizer) 구글이 공개한 딥 러닝 모델 BERT에는 WordPiece Tokenizer가 사용되었습니다. 허깅 페이스는 해당 토크 나이저를 직접 구현하여 tokenizers라는 패키지를 통해 버트 워드 피스 토크 나이저(BertWordPieceTokenizer)를 제공합니다. 여기서는 네이버 영화 리뷰 데이터를 해당 토크 나이저에 학습시키고, 이로부터 서브 워드의 단어 집합(Vocabulary)을 얻습니다. 그리고 임의의 문장에 대해서 학습된 토크 나이저를 사용하여 토큰화를 진행합니다. 우선 네이버 영화 리뷰 데이터를 로드합니다. import pandas as pd import urllib.request from tokenizers import BertWordPieceTokenizer urllib.request.urlretrieve("https://raw.githubusercontent.com/e9t/nsmc/master/ratings.txt", filename="ratings.txt") 센텐스 피스(SentencePiece) 실습에서 진행했던 전처리와 동일한 과정을 진행합니다. ratings.txt라는 파일을 데이터 프레임으로 로드한 후, 결측값을 제거하고, 실질적인 리뷰 데이터인 document 열에 대해서 naver_review.txt라는 파일로 저장합니다. naver_df = pd.read_table('ratings.txt') naver_df = naver_df.dropna(how='any') with open('naver_review.txt', 'w', encoding='utf8') as f: f.write('\n'.join(naver_df['document'])) 버트 워드 피스 토크 나이저를 설정합니다. tokenizer = BertWordPieceTokenizer(lowercase=False, trip_accents=False) 각 인자가 의미하는 바는 다음과 같습니다. lowercase : 대소문자를 구분 여부. True일 경우 구분하지 않음. strip_accents : True일 경우 악센트 제거. ex) é → e, ô → o 네이버 영화 리뷰 데이터를 학습하여 단어 집합을 얻어봅시다. data_file = 'naver_review.txt' vocab_size = 30000 limit_alphabet = 6000 min_frequency = 5 tokenizer.train(files=data_file, vocab_size=vocab_size, limit_alphabet=limit_alphabet, min_frequency=min_frequency) 각 인자가 의미하는 바는 다음과 같습니다. files : 단어 집합을 얻기 위해 학습할 데이터 vocab_size : 단어 집합의 크기 limit_alphabet : 병합 전의 초기 토큰의 허용 개수. min_frequency : 최소 해당 횟수만큼 등장한 쌍(pair)의 경우에만 병합 대상이 된다. 학습이 다 되었다면 vocab을 저장합니다. 경로를 지정해 주어야 하는데 여기서는 현재 경로에 저장하겠습니다. # vocab 저장 tokenizer.save_model('./') vocab을 데이터 프레임으로 로드합니다. # vocab 로드 df = pd.read_fwf('vocab.txt', header=None) df 총 30,000개의 단어가 존재합니다. 이는 단어 집합의 크기를 30,000으로 지정하였기 때문입니다. 실제 토큰화를 수행해 봅시다. encoded = tokenizer.encode('아 배고픈데 짜장면 먹고 싶다') print('토큰화 결과 :',encoded.tokens) print('정수 인코딩 :',encoded.ids) print('디코딩 :',tokenizer.decode(encoded.ids)) 토큰화 결과 : ['아', '배고', '##픈', '##데', '짜장면', '##먹고', '##싶다'] 정수 인코딩 : [2111, 20629, 3979, 3244, 24682, 7871, 7379] 디코딩 : 아 배고픈데 짜장면 먹고 싶다 .ids는 실질적인 딥 러닝 모델의 입력으로 사용되는 정수 인코딩 결과를 출력합니다. tokens는 해당 토크 나이저가 어떻게 토큰화를 진행했는지를 보여줍니다. decode()는 정수 시퀀스를 문자열로 복원합니다. encoded = tokenizer.encode('커피 한 잔의 여유를 즐기다') print('토큰화 결과 :',encoded.tokens) print('정수 인코딩 :',encoded.ids) print('디코딩 :',tokenizer.decode(encoded.ids)) 토큰화 결과 : ['커피', '한 잔', '##의', '여유', '##를', '즐기', '##다'] 정수 인코딩 : [12825, 25641, 3435, 12696, 3419, 10784, 3260] 디코딩 : 커피 한 잔의 여유를 즐기다 2. 기타 토크 나이저 이 외 ByteLevelBPETokenizer, CharBPETokenizer, SentencePieceBPETokenizer 등이 존재하며 선택에 따라서 사용할 수 있습니다. BertWordPieceTokenizer : BERT에서 사용된 워드 피스 토크 나이저(WordPiece Tokenizer) CharBPETokenizer : 오리지널 BPE ByteLevelBPETokenizer : BPE의 바이트 레벨 버전 SentencePieceBPETokenizer : 앞서 본 패키지 센텐스 피스(SentencePiece)와 호환되는 BPE 구현체 from tokenizers import ByteLevelBPETokenizer, CharBPETokenizer, SentencePieceBPETokenizer tokenizer = SentencePieceBPETokenizer() tokenizer.train('naver_review.txt', vocab_size=10000, min_frequency=5) encoded = tokenizer.encode("이 영화는 정말 재미있습니다.") print(encoded.tokens) ['▁이', '▁영화는', '▁정말', '▁재미있', '습니다.'] 14. RNN을 이용한 인코더-디코더 앞서 RNN의 다 대 일(many-to-one) 구조로 텍스트 분류를 풀 수 있었고, 다 대다(many-to-many) 구조로는 개체명 인식이나 품사 태깅과 같은 문제를 풀 수 있었습니다. 이번에 살펴볼 RNN의 구조는 앞에서 살펴본 구조와는 다소 차이가 있는데, 하나의 RNN을 인코더. 또 다른 하나의 RNN을 디코더라는 모듈로 명명하고 두 개의 RNN을 연결해서 사용하는 인코더-디코더 구조입니다. 이러한 인코더-디코더 구조는 주로 입력 문장과 출력 문장의 길이가 다를 경우에 사용하는데, 대표적인 분야가 번역기나 텍스트 요약과 같은 경우가 있습니다. 영어 문장을 한국어 문장으로 번역한다고 하였을 때, 입력 문장인 영어 문장과 번역된 결과인 한국어 문장의 길이는 똑같을 필요가 없습니다. 텍스트 요약의 경우에는 출력 문장이 요약된 문장이므로 입력 문장보다는 당연히 길이가 짧을 것입니다. 이번 챕터에서는 RNN의 인코더와 디코더가 각각 어떤 방식으로 동작하여 입력 문장으로부터 출력 문장을 연산해 내는지 번역기 구현 프로젝트를 통해서 학습합니다. 그리고 번역이라는 섬세한 자연어 처리 태스크를 기계적으로 평가할 수 있는 방법인 BLEU(Bilingual Evaluation Understudy Score)라는 평가 방법에 대해서 설명합니다. 14-01 시퀀스-투-시퀀스(Sequence-to-Sequence, seq2seq) 이번 실습은 케라스 함수형 API에 대한 이해가 필요합니다. 함수형 API(functional API, https://wikidocs.net/38861 )에 대해서 우선 숙지 후 실습을 진행해 주세요. 시퀀스-투-시퀀스(Sequence-to-Sequence, seq2seq)는 입력된 시퀀스로부터 다른 도메인의 시퀀스를 출력하는 다양한 분야에서 사용되는 모델입니다. 예를 들어 챗봇(Chatbot)과 기계 번역(Machine Translation)이 그러한 대표적인 예인데, 입력 시퀀스와 출력 시퀀스를 각각 질문과 대답으로 구성하면 챗봇으로 만들 수 있고, 입력 시퀀스와 출력 시퀀스를 각각 입력 문장과 번역 문장으로 만들면 번역기로 만들 수 있습니다. 그 외에도 내용 요약(Text Summarization), STT(Speech to Text) 등에서 쓰일 수 있습니다. 여기서는 기계 번역을 예제로 시퀀스-투-시퀀스를 설명합니다. 줄여서 seq2seq이라는 이름으로 명명하겠습니다. 1. 시퀀스-투-시퀀스(Sequence-to-Sequence) seq2seq는 번역기에서 대표적으로 사용되는 모델입니다. 앞으로의 설명 방식은 내부가 보이지 않는 커다란 블랙박스에서 점차적으로 확대해가는 방식으로 설명합니다. 여기서 설명하는 내용의 대부분은 RNN 챕터에서 언급한 내용들로 단지 RNN을 어떻게 조립했느냐에 따라서 seq2seq라는 구조가 만들어집니다. 위의 그림은 seq2seq 모델로 만들어진 번역기가 'I am a student'라는 영어 문장을 입력받아서, 'je suis étudiant'라는 프랑스 문장을 출력하는 모습을 보여줍니다. 그렇다면, seq2seq 모델 내부의 모습은 어떻게 구성되었을까요? seq2seq는 크게 인코더와 디코더라는 두 개의 모듈로 구성됩니다. 인코더는 입력 문장의 모든 단어들을 순차적으로 입력받은 뒤에 마지막에 이 모든 단어 정보들을 압축해서 하나의 벡터로 만드는데, 이를 컨텍스트 벡터(context vector)라고 합니다. 입력 문장의 정보가 하나의 컨텍스트 벡터로 모두 압축되면 인코더는 컨텍스트 벡터를 디코더로 전송합니다. 디코더는 컨텍스트 벡터를 받아서 번역된 단어를 한 개씩 순차적으로 출력합니다. 컨텍스트 벡터에 대해서는 뒤에서 다시 언급하겠습니다. 위의 그림에서는 컨텍스트 벡터를 4의 사이즈로 표현하였지만, 실제 현업에서 사용되는 seq2seq 모델에서는 보통 수백 이상의 차원을 갖고 있습니다. 인코더와 디코더의 내부를 좀 더 확대해 보겠습니다. 인코더 아키텍처와 디코더 아키텍처의 내부는 사실 두 개의 RNN 아키텍처입니다. 입력 문장을 받는 RNN 셀을 인코더라고 하고, 출력 문장을 출력하는 RNN 셀을 디코더라고 합니다. 여기서는 인코더의 RNN 셀을 주황색으로, 디코더의 RNN 셀을 초록색으로 표현합니다. 물론, 성능 문제로 인해 실제로는 바닐라 RNN이 아니라 LSTM 셀 또는 GRU 셀들로 구성됩니다. 우선 인코더를 자세히 보면, 입력 문장은 단어 토큰화를 통해서 단어 단위로 쪼개지고 단어 토큰 각각은 RNN 셀의 각 시점의 입력이 됩니다. 인코더 RNN 셀은 모든 단어를 입력받은 뒤에 인코더 RNN 셀의 마지막 시점의 은닉 상태를 디코더 RNN 셀로 넘겨주는데 이를 컨텍스트 벡터라고 합니다. 컨텍스트 벡터는 디코더 RNN 셀의 첫 번째 은닉 상태에 사용됩니다. 디코더는 기본적으로 RNNLM(RNN Language Model)입니다. RNNLM의 개념을 기억하고 있다면 좀 더 이해하기 쉽습니다. 디코더는 초기 입력으로 문장의 시작을 의미하는 심벌 <sos>가 들어갑니다. 디코더는 <sos>가 입력되면, 다음에 등장할 확률이 높은 단어를 예측합니다. 첫 번째 시점(time step)의 디코더 RNN 셀은 다음에 등장할 단어로 je를 예측하였습니다. 첫 번째 시점의 디코더 RNN 셀은 예측된 단어 je를 다음 시점의 RNN 셀의 입력으로 입력합니다. 그리고 두 번째 시점의 디코더 RNN 셀은 입력된 단어 je로부터 다시 다음에 올 단어인 suis를 예측하고, 또다시 이것을 다음 시점의 RNN 셀의 입력으로 보냅니다. 디코더는 이런 식으로 기본적으로 다음에 올 단어를 예측하고, 그 예측한 단어를 다음 시점의 RNN 셀의 입력으로 넣는 행위를 반복합니다. 이 행위는 문장의 끝을 의미하는 심벌인 <eos>가 다음 단어로 예측될 때까지 반복됩니다. 지금 설명하는 것은 테스트 과정 동안의 이야기입니다. seq2seq는 훈련 과정과 테스트 과정(또는 실제 번역기를 사람이 쓸 때)의 작동 방식이 조금 다릅니다. 훈련 과정에서는 디코더에게 인코더가 보낸 컨텍스트 벡터와 실제 정답인 상황인 <sos> je suis étudiant를 입력받았을 때, je suis étudiant <eos>가 나와야 된다고 정답을 알려주면서 훈련합니다. 이에 대해서는 뒤에 교사 강요(teacher forcing)를 설명하면서 재 언급하겠습니다. 반면 테스트 과정에서는 앞서 설명한 과정과 같이 디코더는 오직 컨텍스트 벡터와 <sos>만을 입력으로 받은 후에 다음에 올 단어를 예측하고, 그 단어를 다음 시점의 RNN 셀의 입력으로 넣는 행위를 반복합니다. 즉, 앞서 설명한 과정과 위의 그림은 테스트 과정에 해당됩니다. 이번에는 입, 출력에 쓰이는 단어 토큰들이 있는 부분을 좀 더 확대해 보겠습니다. 기계는 텍스트보다 숫자를 잘 처리합니다. 자연어 처리에서 텍스트를 벡터로 바꾸는 방법으로 주로 워드 임베딩이 사용된다고 설명한 바 있습니다. 즉, seq2seq에서 사용되는 모든 단어들은 임베딩 벡터로 변환 후 입력으로 사용됩니다. 위 그림은 모든 단어에 대해서 임베딩 과정을 거치게 하는 단계인 임베딩 층(embedding layer)의 모습을 보여줍니다. 예를 들어 I, am, a, student라는 단어들에 대한 임베딩 벡터는 위와 같은 모습을 가집니다. 여기서는 그림으로 표현하고자 사이즈를 4로 하였지만, 보통 실제 임베딩 벡터는 수백 개의 차원을 가질 수 있습니다. RNN 셀에 대해서 확대해 보겠습니다. 이전에 설명하였지만, 하나의 RNN 셀은 각각의 시점(time step)마다 두 개의 입력을 받습니다. 현재 시점(time step)을 t라고 할 때, RNN 셀은 t-1에서의 은닉 상태와 t에서의 입력 벡터를 입력으로 받고, t에서의 은닉 상태를 만듭니다. 이때 t에서의 은닉 상태는 바로 위에 또 다른 은닉층이나 출력층이 존재할 경우에는 위의 층으로 보내거나, 필요 없으면 값을 무시할 수 있습니다. 그리고 RNN 셀은 다음 시점에 해당하는 t+1의 RNN 셀의 입력으로 현재 t에서의 은닉 상태를 입력으로 보냅니다. RNN 챕터에서도 언급했지만, 이런 구조에서 현재 시점 t에서의 은닉 상태는 과거 시점의 동일한 RNN 셀에서의 모든 은닉 상태의 값들의 영향을 누적해서 받아온 값이라고 할 수 있습니다. 그렇기 때문에 앞서 언급했던 컨텍스트 벡터는 사실 인코더에서의 마지막 RNN 셀의 은닉 상태 값을 말하는 것이며, 이는 입력 문장의 모든 단어 토큰들의 정보를 요약해서 담고 있다고 할 수 있습니다. 디코더는 인코더의 마지막 RNN 셀의 은닉 상태인 컨텍스트 벡터를 첫 번째 은닉 상태의 값으로 사용합니다. 디코더의 첫 번째 RNN 셀은 이 첫 번째 은닉 상태의 값과, 현재 t에서의 입력값인 <sos>로부터, 다음에 등장할 단어를 예측합니다. 그리고 이 예측된 단어는 다음 시점인 t+1 RNN에서의 입력값이 되고, 이 t+1에서의 RNN 또한 이 입력값과 t에서의 은닉 상태로부터 t+1에서의 출력 벡터. 즉, 또다시 다음에 등장할 단어를 예측하게 될 것입니다. 디코더가 다음에 등장할 단어를 예측하는 부분을 확대해 보겠습니다. 출력 단어로 나올 수 있는 단어들은 다양한 단어들이 있습니다. seq2seq 모델은 선택될 수 있는 모든 단어들로부터 하나의 단어를 골라서 예측해야 합니다. 이를 예측하기 위해서 쓸 수 있는 함수로는 뭐가 있을까요? 바로 소프트맥스 함수입니다. 디코더에서 각 시점(time step)의 RNN 셀에서 출력 벡터가 나오면, 해당 벡터는 소프트맥스 함수를 통해 출력 시퀀스의 각 단어별 확률 값을 반환하고, 디코더는 출력 단어를 결정합니다. 지금까지 가장 기본적인 seq2seq에 대해서 배워보았습니다. 사실 seq2seq는 어떻게 구현하느냐에 따라서 충분히 더 복잡해질 수 있습니다. 컨텍스트 벡터를 디코더의 초기 은닉 상태로만 사용할 수도 있고, 거기서 더 나아가 컨텍스트 벡터를 디코더가 단어를 예측하는 매 시점마다 하나의 입력으로 사용할 수도 있으며 거기서 더 나아가면 어텐션 메커니즘이라는 방법을 통해 지금 알고 있는 컨텍스트 벡터보다 더욱 문맥을 반영할 수 있는 컨텍스트 벡터를 구하여 매 시점마다 하나의 입력으로 사용할 수도 있습니다. 어텐션 메커니즘에 대해서는 다음 챕터에서 배웁니다. 2. 문자 레벨 기계 번역기(Character-Level Neural Machine Translation) 구현하기 seq2seq를 이용해서 기계 번역기를 만들어보겠습니다. 시작하기에 앞서 참고하면 좋은 게시물을 소개합니다. 인터넷에 케라스로 seq2seq를 구현하는 많은 유사 예제들이 나와있지만 대부분은 케라스 개발자 프랑수아 숄레의 블로그의 유명 게시물인 'sequence-to-sequence 10분 만에 이해하기'가 원본입니다. 이번 실습 또한 해당 게시물의 예제에 많이 영향받았습니다. 해당 게시물 링크 : https://blog.keras.io/a-ten-minute-introduction-to-sequence-to-sequence-learning-in-keras.html 실제 성능이 좋은 기계 번역기를 구현하려면 정말 방대한 데이터가 필요하므로 여기서는 방금 배운 seq2seq를 실습해 보는 수준에서 아주 간단한 기계 번역기를 구축해 보겠습니다. 기계 번역기를 훈련시키기 위해서는 훈련 데이터로 병렬 코퍼스(parallel corpus)가 필요합니다. 병렬 코퍼스란, 두 개 이상의 언어가 병렬적으로 구성된 코퍼스를 의미합니다. 다운로드 링크 : http://www.manythings.org/anki 이번 실습에서는 프랑스-영어 병렬 코퍼스인 fra-eng.zip 파일을 사용할 겁니다. 위의 링크에서 해당 파일을 다운로드하시면 됩니다. 해당 파일의 압축을 풀면 fra.txt라는 파일이 있는데 이 파일이 이번 실습에서 사용할 파일입니다. 1) 병렬 코퍼스 데이터에 대한 이해와 전처리 우선 병렬 코퍼스 데이터에 대한 이해를 해보겠습니다. 병렬 데이터라고 하면 앞서 수행한 태깅 작업의 데이터를 생각할 수 있지만, 앞서 수행한 태깅 작업의 병렬 데이터와 seq2seq가 사용하는 병렬 데이터는 성격이 조금 다릅니다. 태깅 작업의 병렬 데이터는 쌍이 되는 모든 데이터가 길이가 같았지만 여기서는 쌍이 된다고 해서 길이가 같지 않습니다. 실제 번역기를 생각해 보면 구글 번역기에 '나는 학생이다.'라는 토큰의 개수가 2인 문장을 넣었을 때 'I am a student.'라는 토큰의 개수가 4인 문장이 나오는 것과 같은 이치입니다. seq2seq는 기본적으로 입력 시퀀스와 출력 시퀀스의 길이가 다를 수 있다고 가정합니다. 지금은 기계 번역기가 예제지만 seq2seq의 또 다른 유명한 예제 중 하나인 챗봇을 만든다고 가정해 보면, 대답의 길이가 질문의 길이와 항상 똑같아야 한다고 하면 그 또한 이상합니다. Watch me. Regardez-moi ! 여기서 사용할 fra.txt 데이터는 위와 같이 왼쪽의 영어 문장과 오른쪽의 프랑스어 문장 사이에 탭으로 구분되는 구조가 하나의 샘플입니다. 그리고 이와 같은<NAME>의 약 16만 개의 병렬 문장 샘플을 포함하고 있습니다. 해당 데이터를 읽고 전처리를 진행해 보겠습니다. 앞으로의 코드에서 src는 source의 줄임말로 입력 문장을 나타내며, tar는 target의 줄임말로 번역하고자 하는 문장을 나타냅니다. import os import shutil import zipfile import pandas as pd import tensorflow as tf import urllib3 from tensorflow.keras.preprocessing.sequence import pad_sequences from tensorflow.keras.utils import to_categorical import requests headers = { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36' } def download_zip(url, output_path): response = requests.get(url, headers=headers, stream=True) if response.status_code == 200: with open(output_path, 'wb') as f: for chunk in response.iter_content(chunk_size=8192): f.write(chunk) print(f"ZIP file downloaded to {output_path}") else: print(f"Failed to download. HTTP Response Code: {response.status_code}") url = "http://www.manythings.org/anki/fra-eng.zip" output_path = "fra-eng.zip" download_zip(url, output_path) path = os.getcwd() zipfilename = os.path.join(path, output_path) with zipfile.ZipFile(zipfilename, 'r') as zip_ref: zip_ref.extractall(path) lines = pd.read_csv('fra.txt', names=['src', 'tar', 'lic'], sep='\t') del lines['lic'] print('전체 샘플의 개수 :',len(lines)) 전체 샘플의 개수 : 191954 전체 샘플의 개수는 총약 19만 2천 개입니다. lines = lines.loc[:, 'src':'tar'] lines = lines[0:60000] # 6만 개만 저장 lines.sample(10) 해당 데이터는 약 19만 2천 개의 병렬 문장 샘플로 구성되어 있지만 여기서는 간단히 60,000개의 샘플만 가지고 기계 번역기를 구축해 보도록 하겠습니다. 우선 전체 데이터 중 60,000개의 샘플만 저장하고 현재 데이터가 어떤 구성이 되었는지 확인해 보겠습니다. 위의 테이블은 랜덤으로 선택된 10개의 샘플을 보여줍니다. 번역 문장에 해당되는 프랑스어 데이터는 앞서 배웠듯이 시작을 의미하는 심벌 <sos>과 종료를 의미하는 심벌 <eos>을 넣어주어야 합니다. 여기서는 <sos>와 <eos> 대신 \t를 시작 심벌, \n을 종료 심벌로 간주하여 추가하고 다시 데이터를 출력해 보겠습니다. lines.tar = lines.tar.apply(lambda x : '\t '+ x + ' \n') lines.sample(10) 랜덤으로 10개의 샘플을 선택하여 출력하였습니다. 프랑스어 데이터에서 시작 심벌과 종료 심벌이 추가된 것을 볼 수 있습니다. 문자 집합을 생성해 보겠습니다. 단어 집합이 아니라 문자 집합이라고 하는 이유는 토큰 단위가 단어가 아니라 문자이기 때문입니다. # 문자 집합 구축 src_vocab = set() for line in lines.src: # 1줄씩 읽음 for char in line: # 1개의 문자씩 읽음 src_vocab.add(char) tar_vocab = set() for line in lines.tar: for char in line: tar_vocab.add(char) 문자 집합의 크기를 보겠습니다. src_vocab_size = len(src_vocab)+1 tar_vocab_size = len(tar_vocab)+1 print('source 문장의 char 집합 :',src_vocab_size) print('target 문장의 char 집합 :',tar_vocab_size) source 문장의 char 집합 : 79 target 문장의 char 집합 : 105 영어와 프랑스어는 각각 79개와 105개의 문자가 존재합니다. 이 중에서 인덱스를 임의로 부여하여 일부만 출력해 봅시다. 현 상태에서 인덱스를 사용하려고 하면 에러가 납니다. 하지만 정렬하여 순서를 정해준 뒤에 인덱스를 사용하여 출력해 주면 됩니다. src_vocab = sorted(list(src_vocab)) tar_vocab = sorted(list(tar_vocab)) print(src_vocab[45:75]) print(tar_vocab[45:75]) ['W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'] ['T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w'] 문자 집합에 문자 단위로 저장된 것을 확인할 수 있습니다. 각 문자에 인덱스를 부여하겠습니다. src_to_index = dict([(word, i+1) for i, word in enumerate(src_vocab)]) tar_to_index = dict([(word, i+1) for i, word in enumerate(tar_vocab)]) print(src_to_index) print(tar_to_index) {' ': 1, '!': 2, '"': 3, '$': 4, '%': 5, ... 중략 ... 'x': 73, 'y': 74, 'z': 75, 'é': 76, '’': 77, '€': 78} {'\t': 1, '\n': 2, ' ': 3, '!': 4, '"': 5, ... 중략 ... 'û': 98, 'œ': 99, 'С': 100, '\u2009': 101, '‘': 102, '’': 103, '\u202f': 104} 인덱스가 부여된 문자 집합으로부터 갖고 있는 훈련 데이터에 정수 인코딩을 수행합니다. 우선 인코더의 입력이 될 영어 문장 샘플에 대해서 정수 인코딩을 수행해 보고, 5개의 샘플을 출력해 봅시다. encoder_input = [] # 1개의 문장 for line in lines.src: encoded_line = [] # 각 줄에서 1개의 char for char in line: # 각 char을 정수로 변환 encoded_line.append(src_to_index[char]) encoder_input.append(encoded_line) print('source 문장의 정수 인코딩 :',encoder_input[:5]) source 문장의 정수 인코딩 : [[30, 64, 10], [30, 64, 10], [30, 64, 10], [31, 58, 10], [31, 58, 10]] 정수 인코딩이 수행된 것을 볼 수 있습니다. 디코더의 입력이 될 프랑스어 데이터에 대해서 정수 인코딩을 수행해 보겠습니다. decoder_input = [] for line in lines.tar: encoded_line = [] for char in line: encoded_line.append(tar_to_index[char]) decoder_input.append(encoded_line) print('target 문장의 정수 인코딩 :',decoder_input[:5]) target 문장의 정수 인코딩 : [[1, 3, 48, 53, 3, 4, 3, 2], [1, 3, 39, 53, 70, 55, 60, 57, 14, 3, 2], [1, 3, 28, 67, 73, 59, 57, 3, 4, 3, 2], [1, 3, 45, 53, 64, 73, 72, 3, 4, 3, 2], [1, 3, 45, 53, 64, 73, 72, 14, 3, 2]] 정상적으로 정수 인코딩이 수행된 것을 볼 수 있습니다. 아직 정수 인코딩을 수행해야 할 데이터가 하나 더 남았습니다. 디코더의 예측값과 비교하기 위한 실제 값이 필요합니다. 그런데 이 실제 값에는 시작 심벌에 해당되는 <sos>가 있을 필요가 없습니다. 이해가 되지 않는다면 이전 페이지의 그림으로 돌아가 Dense와 Softmax 위에 있는 단어들을 다시 보시기 바랍니다. 그래서 이번에는 정수 인코딩 과정에서 <sos>를 제거합니다. 즉, 모든 프랑스어 문장의 맨 앞에 붙어있는 '\t'를 제거하도록 합니다. decoder_target = [] for line in lines.tar: timestep = 0 encoded_line = [] for char in line: if timestep > 0: encoded_line.append(tar_to_index[char]) timestep = timestep + 1 decoder_target.append(encoded_line) print('target 문장 레이블의 정수 인코딩 :',decoder_target[:5]) target 문장 레이블의 정수 인코딩 : [[3, 48, 53, 3, 4, 3, 2], [3, 39, 53, 70, 55, 60, 57, 14, 3, 2], [3, 28, 67, 73, 59, 57, 3, 4, 3, 2], [3, 45, 53, 64, 73, 72, 3, 4, 3, 2], [3, 45, 53, 64, 73, 72, 14, 3, 2]] 앞서 먼저 만들었던 디코더의 입력값에 해당되는 decoder_input 데이터와 비교하면 decoder_input에서는 모든 문장의 앞에 붙어있던 숫자 1이 decoder_target에서는 제거된 것을 볼 수 있습니다. '\t'가 인덱스가 1이므로 정상적으로 제거된 것입니다. 모든 데이터에 대해서 정수 인덱스로 변경하였으니 패딩 작업을 수행합니다. 패딩을 위해서 영어 문장과 프랑스어 문장 각각에 대해서 가장 길이가 긴 샘플의 길이를 확인합니다. max_src_len = max([len(line) for line in lines.src]) max_tar_len = max([len(line) for line in lines.tar]) print('source 문장의 최대 길이 :',max_src_len) print('target 문장의 최대 길이 :',max_tar_len) source 문장의 최대 길이 : 23 target 문장의 최대 길이 : 76 각각 23와 76의 길이를 가집니다. 이번 병렬 데이터는 영어와 프랑스어의 길이는 하나의 쌍이라고 하더라도 전부 다르므로 패딩을 할 때도 이 두 개의 데이터의 길이를 전부 동일하게 맞춰줄 필요는 없습니다. 영어 데이터는 영어 샘플들끼리, 프랑스어는 프랑스어 샘플들끼리 길이를 맞추어서 패딩 하면 됩니다. 여기서는 가장 긴 샘플의 길이에 맞춰서 영어 데이터의 샘플은 전부 길이가 23이 되도록 패딩하고, 프랑스어 데이터의 샘플은 전부 길이가 76이 되도록 패딩 합니다. encoder_input = pad_sequences(encoder_input, maxlen=max_src_len, padding='post') decoder_input = pad_sequences(decoder_input, maxlen=max_tar_len, padding='post') decoder_target = pad_sequences(decoder_target, maxlen=max_tar_len, padding='post') 모든 값에 대해서 원-핫 인코딩을 수행합니다. 문자 단위 번역기므로 워드 임베딩은 별도로 사용되지 않으며, 예측값과의 오차 측정에 사용되는 실제 값뿐만 아니라 입력값도 원-핫 벡터를 사용하겠습니다. encoder_input = to_categorical(encoder_input) decoder_input = to_categorical(decoder_input) decoder_target = to_categorical(decoder_target) 데이터에 대한 전처리가 모두 끝났습니다. 본격적으로 seq2seq 모델을 설계해 보겠습니다. 2) 교사 강요(Teacher forcing) 모델을 설계하기 전에 혹시 의아한 점은 없으신가요? 현재 시점의 디코더 셀의 입력은 오직 이전 디코더 셀의 출력을 입력으로 받는다고 설명하였는데 decoder_input이 왜 필요할까요? 훈련 과정에서는 이전 시점의 디코더 셀의 출력을 현재 시점의 디코더 셀의 입력으로 넣어주지 않고, 이전 시점의 실제 값을 현재 시점의 디코더 셀의 입력값으로 하는 방법을 사용할 겁니다. 그 이유는 이전 시점의 디코더 셀의 예측이 틀렸는데 이를 현재 시점의 디코더 셀의 입력으로 사용하면 현재 시점의 디코더 셀의 예측도 잘못될 가능성이 높고 이는 연쇄 작용으로 디코더 전체의 예측을 어렵게 합니다. 이런 상황이 반복되면 훈련 시간이 느려집니다. 만약 이 상황을 원하지 않는다면 이전 시점의 디코더 셀의 예측값 대신 실제 값을 현재 시점의 디코더 셀의 입력으로 사용하는 방법을 사용할 수 있습니다. 이와 같이 RNN의 모든 시점에 대해서 이전 시점의 예측값 대신 실제 값을 입력으로 주는 방법을 교사 강요라고 합니다. 3) seq2seq 기계 번역기 훈련시키기 seq2seq 모델을 설계하고 교사 강요를 사용하여 훈련시켜보도록 하겠습니다. from tensorflow.keras.layers import Input, LSTM, Embedding, Dense from tensorflow.keras.models import Model import numpy as np encoder_inputs = Input(shape=(None, src_vocab_size)) encoder_lstm = LSTM(units=256, return_state=True) # encoder_outputs은 여기서는 불필요 encoder_outputs, state_h, state_c = encoder_lstm(encoder_inputs) # LSTM은 바닐라 RNN 과는 달리 상태가 두 개. 은닉 상태와 셀 상태. encoder_states = [state_h, state_c] 인코더를 주목해 보면 functional API를 사용한다는 것 외에는 앞서 다른 실습에서 본 LSTM 설계와 크게 다르지는 않습니다. 우선 LSTM의 은닉 상태 크기는 256으로 선택하였습니다. 인코더의 내부 상태를 디코더로 넘겨주어야 하기 때문에 return_state=True로 설정합니다. 인코더에 입력을 넣으면 내부 상태를 리턴합니다. LSTM에서 state_h, state_c를 리턴 받는데, 이는 각각 LSTM을 설명할 때 언급하였던 배운 은닉 상태와 셀 상태에 해당됩니다. 앞서 이론을 설명할 때는 셀 상태는 설명에서 생략하고 은닉 상태만 언급하였으나 사실 LSTM은 은닉 상태와 셀 상태라는 두 가지 상태를 가진다는 사실을 기억해야 합니다. 갑자기 어려워진 게 아닙니다. 단지 은닉 상태만 전달하는 게 아니라 은닉 상태와 셀 상태 두 가지를 전달한다고 생각하면 됩니다. 이 두 가지 상태를 encoder_states에 저장합니다. encoder_states를 디코더에 전달함으로써 이 두 가지 상태 모두를 디코더로 전달합니다. 이것이 앞서 배운 컨텍스트 벡터입니다. decoder_inputs = Input(shape=(None, tar_vocab_size)) decoder_lstm = LSTM(units=256, return_sequences=True, return_state=True) # 디코더에게 인코더의 은닉 상태, 셀 상태를 전달. decoder_outputs, _, _= decoder_lstm(decoder_inputs, initial_state=encoder_states) decoder_softmax_layer = Dense(tar_vocab_size, activation='softmax') decoder_outputs = decoder_softmax_layer(decoder_outputs) model = Model([encoder_inputs, decoder_inputs], decoder_outputs) model.compile(optimizer="rmsprop", loss="categorical_crossentropy") 디코더는 인코더의 마지막 은닉 상태를 초기 은닉 상태로 사용합니다. 위에서 initial_state의 인자 값으로 encoder_states를 주는 코드가 이에 해당됩니다. 또한 동일하게 디코더의 은닉 상태 크기도 256으로 주었습니다. 디코더도 은닉 상태, 셀 상태를 리턴하기는 하지만 훈련 과정에서는 사용하지 않습니다. 그 후 출력층에 프랑스어의 단어 집합의 크기만큼 뉴런을 배치한 후 소프트맥스 함수를 사용하여 실제 값과의 오차를 구합니다. model.fit(x=[encoder_input, decoder_input], y=decoder_target, batch_size=64, epochs=40, validation_split=0.2) 입력으로는 인코더 입력과 디코더 입력이 들어가고, 디코더의 실제 값인 decoder_target도 필요합니다. 배치 크기는 64로 하였으며 총 40 에포크를 학습합니다. 위에서 설정한 은닉 상태의 크기와 에포크 수는 실제로는 훈련 데이터에 과적합 상태를 불러옵니다. 중간부터 검증 데이터에 대한 오차인 val_loss의 값이 올라가는데, 사실 이번 실습에서는 주어진 데이터의 양과 태스크의 특성으로 인해 훈련 과정에서 훈련 데이터의 정확도와 과적합 방지라는 두 마리 토끼를 동시에 잡기에는 쉽지 않습니다. 여기서는 우선 seq2seq의 메커니즘과 짧은 문장과 긴 문장에 대한 성능 차이에 대한 확인을 중점으로 두고 훈련 데이터에 과적합 된 상태로 동작 단계로 넘어갑니다. 4) seq2seq 기계 번역기 동작시키기 앞서 seq2seq는 훈련할 때와 동작할 때의 방식이 다르다고 언급한 바 있습니다. 이번에는 입력한 문장에 대해서 기계 번역을 하도록 모델을 조정하고 동작시켜보도록 하겠습니다. 전체적인 번역 동작 단계를 정리하면 아래와 같습니다. 1. 번역하고자 하는 입력 문장이 인코더에 들어가서 은닉 상태와 셀 상태를 얻습니다. 2. 상태와 <SOS>에 해당하는 \t를 디코더로 보냅니다. 3. 디코더가 <EOS>에 해당하는 \n이 나올 때까지 다음 문자를 예측하는 행동을 반복합니다. encoder_model = Model(inputs=encoder_inputs, outputs=encoder_states) 우선 인코더를 정의합니다. encoder_inputs와 encoder_states는 훈련 과정에서 이미 정의한 것들을 재사용하는 것입니다. 디코더를 설계해 보겠습니다. # 이전 시점의 상태들을 저장하는 텐서 decoder_state_input_h = Input(shape=(256, )) decoder_state_input_c = Input(shape=(256, )) decoder_states_inputs = [decoder_state_input_h, decoder_state_input_c] # 문장의 다음 단어를 예측하기 위해서 초기 상태(initial_state)를 이전 시점의 상태로 사용. # 뒤의 함수 decode_sequence()에 동작을 구현 예정 decoder_outputs, state_h, state_c = decoder_lstm(decoder_inputs, initial_state=decoder_states_inputs) # 훈련 과정에서와 달리 LSTM의 리턴하는 은닉 상태와 셀 상태를 버리지 않음. decoder_states = [state_h, state_c] decoder_outputs = decoder_softmax_layer(decoder_outputs) decoder_model = Model(inputs=[decoder_inputs] + decoder_states_inputs, outputs=[decoder_outputs] + decoder_states) index_to_src = dict((i, char) for char, i in src_to_index.items()) index_to_tar = dict((i, char) for char, i in tar_to_index.items()) 단어로부터 인덱스를 얻는 것이 아니라 인덱스로부터 단어를 얻을 수 있는 index_to_src와 index_to_tar를 만들었습니다. def decode_sequence(input_seq): # 입력으로부터 인코더의 상태를 얻음 states_value = encoder_model.predict(input_seq) # <SOS>에 해당하는 원-핫 벡터 생성 target_seq = np.zeros((1, 1, tar_vocab_size)) target_seq[0, 0, tar_to_index['\t']] = 1. stop_condition = False decoded_sentence = "" # stop_condition이 True가 될 때까지 루프 반복 while not stop_condition: # 이점 시점의 상태 states_value를 현시점의 초기 상태로 사용 output_tokens, h, c = decoder_model.predict([target_seq] + states_value) # 예측 결과를 문자로 변환 sampled_token_index = np.argmax(output_tokens[0, -1, :]) sampled_char = index_to_tar[sampled_token_index] # 현재 시점의 예측 문자를 예측 문장에 추가 decoded_sentence += sampled_char # <eos>에 도달하거나 최대 길이를 넘으면 중단. if (sampled_char == '\n' or len(decoded_sentence) > max_tar_len): stop_condition = True # 현재 시점의 예측 결과를 다음 시점의 입력으로 사용하기 위해 저장 target_seq = np.zeros((1, 1, tar_vocab_size)) target_seq[0, 0, sampled_token_index] = 1. # 현재 시점의 상태를 다음 시점의 상태로 사용하기 위해 저장 states_value = [h, c] return decoded_sentence for seq_index in [3,50,100,300,1001]: # 입력 문장의 인덱스 input_seq = encoder_input[seq_index:seq_index+1] decoded_sentence = decode_sequence(input_seq) print(35 * "-") print('입력 문장:', lines.src[seq_index]) print('정답 문장:', lines.tar[seq_index][2:len(lines.tar[seq_index])-1]) # '\t'와 '\n'을 빼고 출력 print('번역 문장:', decoded_sentence[1:len(decoded_sentence)-1]) # '\n'을 빼고 출력 ----------------------------------- 입력 문장: Hi. 정답 문장: Salut ! 번역 문장: Salut. ----------------------------------- 입력 문장: I see. 정답 문장: Aha. 번역 문장: Je change. ----------------------------------- 입력 문장: Hug me. 정답 문장: Serrez-moi dans vos bras ! 번역 문장: Serre-moi dans vos patents ! ----------------------------------- 입력 문장: Help me. 정답 문장: Aidez-moi. 번역 문장: Aidez-moi. ----------------------------------- 입력 문장: I beg you. 정답 문장: Je vous en prie. 번역 문장: Je vous en prie. 지금까지 문자 단위의 seq2seq를 구현하였습니다. 다음 실습에서는 이번 실습에서 배운 내용을 바탕으로 문자 단위에서 단어 단위로 확장해서 기계 번역기를 구현해 보겠습니다. 14-02 Word-Level 번역기 만들기(Neural Machine Translation (seq2seq) Tutorial) seq2seq를 이용해서 기계 번역기를 만들어보겠습니다. 시작하기에 앞서 참고하면 좋은 게시물을 소개합니다. 인터넷에 케라스로 seq2seq를 구현하는 많은 유사 예제들이 나와있지만 대부분은 케라스 개발자 프랑수아 숄레의 블로그의 유명 게시물인 'sequence-to-sequence 10분 만에 이해하기'가 원본입니다. 이번 실습 또한 해당 게시물의 예제에 많이 영향받았습니다. 링크 : https://blog.keras.io/a-ten-minute-introduction-to-sequence-to-sequence-learning-in-keras.html 1. 데이터 로드 및 전처리 실제 성능이 좋은 기계 번역기를 구현하려면 방대한 데이터가 필요하므로 여기서는 seq2seq를 간단히 실습해 보는 수준의 간단한 기계 번역기를 구현해 보겠습니다. 기계 번역기를 훈련시키기 위해서는 훈련 데이터로 병렬 코퍼스(parallel corpus)가 필요합니다. 병렬 코퍼스란, 두 개 이상의 언어가 병렬적으로 구성된 코퍼스를 의미합니다. 링크 : http://www.manythings.org/anki 이번 실습에서는 프랑스어-영어 병렬 코퍼스인 fra-eng.zip 파일을 사용합니다. 위의 링크에서 해당 파일을 다운로드한 후 압축을 풀면 fra.txt라는 파일을 얻을 수 있는데 해당 파일을 이 실습에서 사용합니다. 병렬 코퍼스 데이터에 대해서 이해해 봅시다. 병렬 데이터라고 하면 앞서 수행한 태깅 작업 챕터의 개체명 인식과 같은 데이터를 생각할 수 있지만, 앞서 수행한 태깅 작업의 병렬 데이터와 seq2seq가 사용하는 병렬 데이터는 성격이 다릅니다. 태깅 작업의 병렬 데이터는 쌍이 되는 데이터와 레이블이 길이가 동일하였으나 여기서는 쌍이 된다고 해서 반드시 길이가 같지는 않습니다. 실제 번역기를 생각해 보면 구글 번역기에 '나는 학생이다.'라는 토큰의 개수가 2인 문장을 넣었을 때 'I am a student.'라는 토큰의 개수가 4인 문장이 나오는 것과 같은 이치입니다. seq2seq는 기본적으로 입력 시퀀스와 출력 시퀀스의 길이가 다를 수 있다고 가정합니다. 지금 구현 예제는 기계 번역기이지만 seq2seq로 구현할 수 있는 또 다른 예제인 챗봇을 만든다고 가정해 보면, 대답의 길이가 질문의 길이와 항상 똑같아야 한다고 하면 그 또한 이상합니다. 여기서 사용할 fra.txt 데이터는 아래와 같이 왼쪽의 영어 문장과 오른쪽의 프랑스어 문장 사이에 탭으로 구분되는<NAME>이 하나의 샘플입니다. Watch me. Regardez-moi ! 데이터는 위와 동일한<NAME>의 약 19만 개의 병렬 문장 샘플을 포함하고 있습니다. 데이터를 읽고 전처리를 진행해 보겠습니다. 앞으로의 코드에서 src는 source의 줄임말로 입력 문장을 나타내며, tar는 target의 줄임말로 번역하고자 하는 문장을 나타냅니다. import os import re import shutil import zipfile import numpy as np import pandas as pd import tensorflow as tf import unicodedata import urllib3 from tensorflow.keras.layers import Embedding, GRU, Dense from tensorflow.keras.preprocessing.sequence import pad_sequences from tensorflow.keras.preprocessing.text import Tokenizer fra-eng.zip 파일을 다운로드하고 압축을 풀겠습니다. import requests headers = { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36' } def download_zip(url, output_path): response = requests.get(url, headers=headers, stream=True) if response.status_code == 200: with open(output_path, 'wb') as f: for chunk in response.iter_content(chunk_size=8192): f.write(chunk) print(f"ZIP file downloaded to {output_path}") else: print(f"Failed to download. HTTP Response Code: {response.status_code}") url = "http://www.manythings.org/anki/fra-eng.zip" output_path = "fra-eng.zip" download_zip(url, output_path) path = os.getcwd() zipfilename = os.path.join(path, output_path) with zipfile.ZipFile(zipfilename, 'r') as zip_ref: zip_ref.extractall(path) 이번 실습에서는 약 19만 개의 데이터 중 33,000개의 샘플만을 사용할 예정입니다. num_samples = 33000 전처리 함수들을 구현합니다. 구두점 등을 제거하거나 단어와 구분해 주기 위한 전처리입니다. def to_ascii(s): # 프랑스어 악센트(accent) 삭제 # 예시 : 'déjà diné' -> deja dine return ''.join(c for c in unicodedata.normalize('NFD', s) if unicodedata.category(c) != 'Mn') def preprocess_sentence(sent): # 악센트 제거 함수 호출 sent = to_ascii(sent.lower()) # 단어와 구두점 사이에 공백 추가. # ex) "I am a student." => "I am a student ." sent = re.sub(r"([?.!,¿])", r" \1", sent) # (a-z, A-Z, ".", "?", "!", ",") 이들을 제외하고는 전부 공백으로 변환. sent = re.sub(r"[^a-zA-Z!.?]+", r" ", sent) # 다수 개의 공백을 하나의 공백으로 치환 sent = re.sub(r"\s+", " ", sent) return sent 구현한 전처리 함수들을 임의의 문장을 입력으로 테스트해 봅시다. # 전처리 테스트 en_sent = u"Have you had dinner?" fr_sent = u"Avez-vous déjà diné?" print('전처리 전 영어 문장 :', en_sent) print('전처리 후 영어 문장 :',preprocess_sentence(en_sent)) print('전처리 전 프랑스어 문장 :', fr_sent) print('전처리 후 프랑스어 문장 :', preprocess_sentence(fr_sent)) 전처리 전 영어 문장 : Have you had dinner? 전처리 후 영어 문장 : have you had dinner ? 전처리 전 프랑스어 문장 : Avez-vous déjà diné? 전처리 후 프랑스어 문장 : avez vous deja dine ? 전체 데이터에서 33,000개의 샘플에 대해서 전처리를 수행합니다. 또한 훈련 과정에서 교사 강요(Teacher Forcing)을 사용할 예정이므로, 훈련 시 사용할 디코더의 입력 시퀀스와 실제 값. 즉, 레이블에 해당되는 출력 시퀀스를 따로 분리하여 저장합니다. 입력 시퀀스에는 시작을 의미하는 토큰인 <sos>를 추가하고, 출력 시퀀스에는 종료를 의미하는 토큰인 <eos>를 추가합니다. def load_preprocessed_data(): encoder_input, decoder_input, decoder_target = [], [], [] with open("fra.txt", "r") as lines: for i, line in enumerate(lines): # source 데이터와 target 데이터 분리 src_line, tar_line, _ = line.strip().split('\t') # source 데이터 전처리 src_line = [w for w in preprocess_sentence(src_line).split()] # target 데이터 전처리 tar_line = preprocess_sentence(tar_line) tar_line_in = [w for w in ("<sos> " + tar_line).split()] tar_line_out = [w for w in (tar_line + " <eos>").split()] encoder_input.append(src_line) decoder_input.append(tar_line_in) decoder_target.append(tar_line_out) if i == num_samples - 1: break return encoder_input, decoder_input, decoder_target 이렇게 얻은 3개의 데이터 셋 인코더의 입력, 디코더의 입력, 디코더의 레이블을 상위 5개 샘플만 출력해 봅시다. sents_en_in, sents_fra_in, sents_fra_out = load_preprocessed_data() print('인코더의 입력 :',sents_en_in[:5]) print('디코더의 입력 :',sents_fra_in[:5]) print('디코더의 레이블 :',sents_fra_out[:5]) 인코더의 입력 : [['go', '.'], ['go', '.'], ['go', '.'], ['hi', '.'], ['hi', '.']] 디코더의 입력 : [['<sos>', 'va', '!'], ['<sos>', 'marche', '.'], ['<sos>', 'bouge', '!'], ['<sos>', 'salut', '!'], ['<sos>', 'salut', '.']] 디코더의 레이블 : [['va', '!', '<eos>'], ['marche', '.', '<eos>'], ['bouge', '!', '<eos>'], ['salut', '!', '<eos>'], ['salut', '.', '<eos>']] 모델을 설계하기 전 의아한 점이 있을 수 있습니다. 현재 시점의 디코더 셀의 입력은 오직 이전 디코더 셀의 출력을 입력으로 받는다고 설명하였는데 디코더의 입력에 해당하는 데이터인 sents_fra_in이 왜 필요할까요? 훈련 과정에서는 이전 시점의 디코더 셀의 출력을 현재 시점의 디코더 셀의 입력으로 넣어주지 않고, 이전 시점의 실제 값을 현재 시점의 디코더 셀의 입력값으로 하는 방법을 사용할 겁니다. 그 이유는 이전 시점의 디코더 셀의 예측이 틀렸는데 이를 현재 시점의 디코더 셀의 입력으로 사용하면 현재 시점의 디코더 셀의 예측도 잘못될 가능성이 높고 이는 연쇄 작용으로 디코더 전체의 예측을 어렵게 합니다. 이런 상황이 반복되면 훈련 시간이 느려집니다. 만약 이 상황을 원하지 않는다면 이전 시점의 디코더 셀의 예측값 대신 실제 값을 현재 시점의 디코더 셀의 입력으로 사용하는 방법을 사용할 수 있습니다. 이와 같이 RNN의 모든 시점에 대해서 이전 시점의 예측값 대신 실제 값을 입력으로 주는 방법을 교사 강요라고 합니다. 케라스 토크 나이저를 통해 단어 집합을 생성, 정수 인코딩을 진행 후 이어서 패딩을 진행합니다. tokenizer_en = Tokenizer(filters="", lower=False) tokenizer_en.fit_on_texts(sents_en_in) encoder_input = tokenizer_en.texts_to_sequences(sents_en_in) encoder_input = pad_sequences(encoder_input, padding="post") tokenizer_fra = Tokenizer(filters="", lower=False) tokenizer_fra.fit_on_texts(sents_fra_in) tokenizer_fra.fit_on_texts(sents_fra_out) decoder_input = tokenizer_fra.texts_to_sequences(sents_fra_in) decoder_input = pad_sequences(decoder_input, padding="post") decoder_target = tokenizer_fra.texts_to_sequences(sents_fra_out) decoder_target = pad_sequences(decoder_target, padding="post") 데이터의 크기(shape)를 확인합니다. print('인코더의 입력의 크기(shape) :',encoder_input.shape) print('디코더의 입력의 크기(shape) :',decoder_input.shape) print('디코더의 레이블의 크기(shape) :',decoder_target.shape) 인코더의 입력의 크기(shape) : (33000, 8) 디코더의 입력의 크기(shape) : (33000, 16) 디코더의 레이블의 크기(shape) : (33000, 16) 샘플은 총 33,000개 존재하며 영어 문장의 길이는 8, 프랑스어 문장의 길이는 16입니다. 단어 집합의 크기를 정의합니다. src_vocab_size = len(tokenizer_en.word_index) + 1 tar_vocab_size = len(tokenizer_fra.word_index) + 1 print("영어 단어 집합의 크기 : {:d}, 프랑스어 단어 집합의 크기 : {:d}".format(src_vocab_size, tar_vocab_size)) 영어 단어 집합의 크기 : 4647, 프랑스어 단어 집합의 크기 : 8022 단어 집합의 크기는 각각 4,647개와 8,022개입니다. 단어로부터 정수를 얻는 딕셔너리와 정수로부터 단어를 얻는 딕셔너리를 각각 만들어줍니다. 이들은 훈련을 마치고 예측값과 실제 값을 비교하는 단계에서 사용됩니다. src_to_index = tokenizer_en.word_index index_to_src = tokenizer_en.index_word tar_to_index = tokenizer_fra.word_index index_to_tar = tokenizer_fra.index_word 테스트 데이터를 분리하기 전 데이터를 섞어줍니다. 이를 위해서 순서가 섞인 정수 시퀀스 리스트를 만듭니다. indices = np.arange(encoder_input.shape[0]) np.random.shuffle(indices) print('랜덤 시퀀스 :',indices) 랜덤 시퀀스 : [16412 5374 8832 ... 5652 24040 10002] 이를 데이터 셋의 순서로 지정해 주면 샘플들이 기존 순서와 다른 순서로 섞이게 됩니다. encoder_input = encoder_input[indices] decoder_input = decoder_input[indices] decoder_target = decoder_target[indices] 임의로 30,997번째 샘플을 출력해 봅시다. 이때 decoder_input과 decoder_target은 데이터의 구조상으로 앞에 붙은 <sos> 토큰과 뒤에 붙은 <eos>을 제외하면 동일한 정수 시퀀스를 가져야 합니다. encoder_input[30997] array([ 5, 7, 638, 1, 0, 0, 0, 0], dtype=int32) decoder_input[30997] array([ 2, 18, 5, 16, 173, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], dtype=int32) decoder_target[30997] array([ 18, 5, 16, 173, 1, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], dtype=int32) 저자의 경우 18, 5, 16, 173, 1이라는 동일 시퀀스를 확인했습니다. 이제 훈련 데이터의 10%를 테스트 데이터로 분리하겠습니다. n_of_val = int(33000*0.1) print('검증 데이터의 개수 :',n_of_val) 검증 데이터의 개수 : 3300 33,000개의 10%에 해당되는 3,300개의 데이터를 테스트 데이터로 사용합니다. encoder_input_train = encoder_input[:-n_of_val] decoder_input_train = decoder_input[:-n_of_val] decoder_target_train = decoder_target[:-n_of_val] encoder_input_test = encoder_input[-n_of_val:] decoder_input_test = decoder_input[-n_of_val:] decoder_target_test = decoder_target[-n_of_val:] 훈련 데이터와 테스트 데이터의 크기(shape)를 출력해 봅시다. print('훈련 source 데이터의 크기 :',encoder_input_train.shape) print('훈련 target 데이터의 크기 :',decoder_input_train.shape) print('훈련 target 레이블의 크기 :',decoder_target_train.shape) print('테스트 source 데이터의 크기 :',encoder_input_test.shape) print('테스트 target 데이터의 크기 :',decoder_input_test.shape) print('테스트 target 레이블의 크기 :',decoder_target_test.shape) 훈련 source 데이터의 크기 : (29700, 8) 훈련 target 데이터의 크기 : (29700, 16) 훈련 target 레이블의 크기 : (29700, 16) 테스트 source 데이터의 크기 : (3300, 8) 테스트 target 데이터의 크기 : (3300, 16) 테스트 target 레이블의 크기 : (3300, 16) 훈련 데이터의 샘플은 29,700개, 테스트 데이터의 샘플은 3,300개가 존재합니다. 이제 모델을 설계합니다. 2. 기계 번역기 만들기 from tensorflow.keras.layers import Input, LSTM, Embedding, Dense, Masking from tensorflow.keras.models import Model 임베딩 벡터의 차원과 LSTM의 은닉 상태의 크기를 64로 사용합니다. embedding_dim = 64 hidden_units = 64 인코더를 설계합니다. 인코더를 주목해 보면 함수형 API(functional API)를 사용한다는 것 외에는 앞서 다른 실습에서 본 LSTM 설계와 크게 다르지는 않습니다. Masking은 패딩 토큰인 숫자 0의 경우에는 연산을 제외하는 역할을 수행합니다. 인코더의 내부 상태를 디코더로 넘겨주어야 하기 때문에 return_state=True로 설정합니다. 인코더에 입력을 넣으면 내부 상태를 리턴합니다. LSTM에서 state_h, state_c를 리턴 받는데, 이는 각각 RNN 챕터에서 LSTM을 처음 설명할 때 언급하였던 은닉 상태와 셀 상태에 해당됩니다. 이 두 가지 상태를 encoder_states에 저장합니다. encoder_states를 디코더에 전달함으로써 이 두 가지 상태 모두를 디코더로 전달할 예정입니다. 이것이 앞서 배운 컨텍스트 벡터입니다. # 인코더 encoder_inputs = Input(shape=(None,)) enc_emb = Embedding(src_vocab_size, embedding_dim)(encoder_inputs) # 임베딩 층 enc_masking = Masking(mask_value=0.0)(enc_emb) # 패딩 0은 연산에서 제외 encoder_lstm = LSTM(hidden_units, return_state=True) # 상태 값 리턴을 위해 return_state는 True encoder_outputs, state_h, state_c = encoder_lstm(enc_masking) # 은닉 상태와 셀 상태를 리턴 encoder_states = [state_h, state_c] # 인코더의 은닉 상태와 셀 상태를 저장 디코더는 인코더의 마지막 은닉 상태로부터 초기 은닉 상태를 얻습니다. initial_state의 인자 값으로 encoder_states를 주는 코드가 이에 해당됩니다. 디코더도 은닉 상태, 셀 상태를 리턴하기는 하지만 훈련 과정에서는 사용하지 않습니다. seq2seq의 디코더는 기본적으로 각 시점마다 다중 클래스 분류 문제를 풀고 있습니다. 매 시점마다 프랑스어 단어 집합의 크기(tar_vocab_size)의 선택지에서 단어를 1개 선택하여 이를 이번 시점에서 예측한 단어로 택합니다. 다중 클래스 분류 문제이므로 출력층으로 소프트맥스 함수와 손실 함수를 크로스 엔트로피 함수를 사용합니다. categorical_crossentropy를 사용하려면 레이블은 원-핫 인코딩이 된 상태여야 합니다. 그런데 현재 decoder_outputs의 경우에는 원-핫 인코딩을 하지 않은 상태입니다. 원-핫 인코딩을 하지 않은 상태로 정수 레이블에 대해서 다중 클래스 분류 문제를 풀고자 하는 경우에는 categorical_crossentropy가 아니라 sparse_categorical_crossentropy를 사용하면 됩니다. # 디코더 decoder_inputs = Input(shape=(None,)) dec_emb_layer = Embedding(tar_vocab_size, hidden_units) # 임베딩 층 dec_emb = dec_emb_layer(decoder_inputs) # 패딩 0은 연산에서 제외 dec_masking = Masking(mask_value=0.0)(dec_emb) # 상태 값 리턴을 위해 return_state는 True, 모든 시점에 대해서 단어를 예측하기 위해 return_sequences는 True decoder_lstm = LSTM(hidden_units, return_sequences=True, return_state=True) # 인코더의 은닉 상태를 초기 은닉 상태(initial_state)로 사용 decoder_outputs, _, _ = decoder_lstm(dec_masking, initial_state=encoder_states) # 모든 시점의 결과에 대해서 소프트맥스 함수를 사용한 출력층을 통해 단어 예측 decoder_dense = Dense(tar_vocab_size, activation='softmax') decoder_outputs = decoder_dense(decoder_outputs) # 모델의 입력과 출력을 정의. model = Model([encoder_inputs, decoder_inputs], decoder_outputs) model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['acc']) 모델을 훈련합니다. 128개의 배치 크기로 총 50 에포크 학습합니다. 테스트 데이터를 검증 데이터로 사용하여 훈련이 제대로 되고 있는지 모니터링하겠습니다. model.fit(x=[encoder_input_train, decoder_input_train], y=decoder_target_train, \ validation_data=([encoder_input_test, decoder_input_test], decoder_target_test), batch_size=128, epochs=50) 저자의 경우 최종 에포크에서 훈련 데이터는 92%의 정확도를, 테스트 데이터에서는 86%의 정확도를 얻었습니다. 3. seq2seq 기계 번역기 동작시키기 seq2seq는 훈련 과정(교사 강요)과 테스트 과정에서의 동작 방식이 다릅니다. 그래서 테스트 과정을 위해 모델을 다시 설계해 주어야 합니다. 특히 디코더를 수정해야 합니다. 이번에는 번역 단계를 위해 모델을 수정하고 동작시켜보겠습니다. 전체적인 번역 단계를 정리하면 아래와 같습니다. 번역하고자 하는 입력 문장이 인코더로 입력되어 인코더의 마지막 시점의 은닉 상태와 셀 상태를 얻습니다. 인코더의 은닉 상태와 셀 상태, 그리고 토큰 <sos>를 디코더로 보냅니다. 디코더가 토큰 <eos>가 나올 때까지 다음 단어를 예측하는 행동을 반복합니다. 인코더의 입, 출력으로 사용하는 encoder_inputs와 encoder_states는 훈련 과정에서 이미 정의한 것들을 재사용합니다. 이렇게 되면 훈련 단계에 encoder_inputs와 encoder_states 사이에 있는 모든 층까지 전부 불러오게 되므로 결과적으로 훈련 단계에서 사용한 인코더를 그대로 재사용하게 됩니다. 이어서 디코더를 설계합니다. 테스트 단계에서는 디코더를 매 시점 별로 컨트롤할 예정으로, 이를 위해서 이전 시점의 상태를 저장할 텐서인 decoder_state_input_h, decoder_state_input_c를 정의합니다. 매 시점 별로 디코더를 컨트롤하는 함수는 뒤에서 정의할 decode_sequence()로 해당 함수를 자세히 살펴봐야 합니다. # 인코더 encoder_model = Model(encoder_inputs, encoder_states) # 디코더 설계 시작 # 이전 시점의 상태를 보관할 텐서 decoder_state_input_h = Input(shape=(hidden_units,)) decoder_state_input_c = Input(shape=(hidden_units,)) decoder_states_inputs = [decoder_state_input_h, decoder_state_input_c] # 훈련 때 사용했던 임베딩 층을 재사용 dec_emb2 = dec_emb_layer(decoder_inputs) # 다음 단어 예측을 위해 이전 시점의 상태를 현시점의 초기 상태로 사용 decoder_outputs2, state_h2, state_c2 = decoder_lstm(dec_emb2, initial_state=decoder_states_inputs) decoder_states2 = [state_h2, state_c2] # 모든 시점에 대해서 단어 예측 decoder_outputs2 = decoder_dense(decoder_outputs2) # 수정된 디코더 decoder_model = Model( [decoder_inputs] + decoder_states_inputs, [decoder_outputs2] + decoder_states2) 테스트 단계에서의 동작을 위한 decode_sequence 함수를 구현합니다. 입력 문장이 들어오면 인코더는 마지막 시점까지 전개하여 마지막 시점의 은닉 상태와 셀 상태를 리턴합니다. 이 두 개의 값을 states_value에 저장합니다. 그리고 디코더의 초기 입력으로 <SOS>를 준비합니다. 이를 target_seq에 저장합니다. 이 두 가지 입력을 가지고 while 문안으로 진입하여 이 두 가지를 디코더의 입력으로 사용합니다. 이제 디코더는 현재 시점에 대해서 예측을 하게 되는데, 현재 시점의 예측 벡터가 output_tokens, 현재 시점의 은닉 상태가 h, 현재 시점의 셀 상태가 c입니다. 예측 벡터로부터 현재 시점의 예측 단어인 target_seq를 얻고, h와 c 이 두 개의 값은 states_value에 저장합니다. 그리고 while 문의 다음 루프. 즉, 두 번째 시점의 디코더의 입력으로 다시 target_seq와 states_value를 사용합니다. 이를 현재 시점의 예측 단어로 <eos>를 예측하거나 번역 문장의 길이가 50이 넘는 순간까지 반복합니다. 각 시점마다 번역된 다어는 decoded_sentence에 누적하여 저장하였다가 최종 번역 시퀀스로 리턴합니다. def decode_sequence(input_seq): # 입력으로부터 인코더의 마지막 시점의 상태(은닉 상태, 셀 상태)를 얻음 states_value = encoder_model.predict(input_seq) # <SOS>에 해당하는 정수 생성 target_seq = np.zeros((1,1)) target_seq[0, 0] = tar_to_index['<sos>'] stop_condition = False decoded_sentence = '' # stop_condition이 True가 될 때까지 루프 반복 # 구현의 간소화를 위해서 이 함수는 배치 크기를 1로 가정합니다. while not stop_condition: # 이점 시점의 상태 states_value를 현시점의 초기 상태로 사용 output_tokens, h, c = decoder_model.predict([target_seq] + states_value) # 예측 결과를 단어로 변환 sampled_token_index = np.argmax(output_tokens[0, -1, :]) sampled_char = index_to_tar[sampled_token_index] # 현재 시점의 예측 단어를 예측 문장에 추가 decoded_sentence += ' '+sampled_char # <eos>에 도달하거나 정해진 길이를 넘으면 중단. if (sampled_char == '<eos>' or len(decoded_sentence) > 50): stop_condition = True # 현재 시점의 예측 결과를 다음 시점의 입력으로 사용하기 위해 저장 target_seq = np.zeros((1,1)) target_seq[0, 0] = sampled_token_index # 현재 시점의 상태를 다음 시점의 상태로 사용하기 위해 저장 states_value = [h, c] return decoded_sentence 결과 확인을 위한 함수를 만듭니다. seq_to_src 함수는 영어 문장에 해당하는 정수 시퀀스를 입력받으면 정수로부터 영어 단어를 리턴하는 index_to_src를 통해 영어 문장으로 변환합니다. seq_to_tar은 프랑스어에 해당하는 정수 시퀀스를 입력받으면 정수로부터 프랑스어 단어를 리턴하는 index_to_tar을 통해 프랑스어 문장으로 변환합니다. # 원문의 정수 시퀀스를 텍스트 시퀀스로 변환 def seq_to_src(input_seq): sentence = '' for encoded_word in input_seq: if(encoded_word != 0): sentence = sentence + index_to_src[encoded_word] + ' ' return sentence # 번역문의 정수 시퀀스를 텍스트 시퀀스로 변환 def seq_to_tar(input_seq): sentence = '' for encoded_word in input_seq: if(encoded_word != 0 and encoded_word != tar_to_index['<sos>'] and encoded_word != tar_to_index['<eos>']): sentence = sentence + index_to_tar[encoded_word] + ' ' return sentence 훈련 데이터에 대해서 임의로 선택한 인덱스의 샘플의 결과를 출력해 봅시다. for seq_index in [3, 50, 100, 300, 1001]: input_seq = encoder_input_train[seq_index: seq_index + 1] decoded_sentence = decode_sequence(input_seq) print("입력 문장 :",seq_to_src(encoder_input_train[seq_index])) print("정답 문장 :",seq_to_tar(decoder_input_train[seq_index])) print("번역 문장 :",decoded_sentence[1:-5]) print("-"*50) 입력 문장 : when does it end ? 정답 문장 : quand est ce que ca finit ? 번역 문장 : quand est ce que ca marche ? -------------------------------------------------- 입력 문장 : it s sand . 정답 문장 : c est du sable . 번역 문장 : c est de l eau . -------------------------------------------------- 입력 문장 : i didn t go . 정답 문장 : je n y suis pas allee . 번역 문장 : je ne suis pas encore . -------------------------------------------------- 입력 문장 : it was a mistake . 정답 문장 : ce fut une erreur . 번역 문장 : il s agit d une blague . -------------------------------------------------- 입력 문장 : it boggles my mind . 정답 문장 : ca me laisse perplexe . 번역 문장 : ca m en femme . -------------------------------------------------- 테스트 데이터에 대해서 임의로 선택한 인덱스의 샘플의 결과를 출력해 봅시다. for seq_index in [3, 50, 100, 300, 1001]: input_seq = encoder_input_test[seq_index: seq_index + 1] decoded_sentence = decode_sequence(input_seq) print("입력 문장 :",seq_to_src(encoder_input_test[seq_index])) print("정답 문장 :",seq_to_tar(decoder_input_test[seq_index])) print("번역 문장 :",decoded_sentence[1:-5]) print("-"*50) 입력 문장 : we are busy men . 정답 문장 : nous sommes des hommes occupes . 번역 문장 : nous sommes tres vieux . -------------------------------------------------- 입력 문장 : it was very ugly . 정답 문장 : ce n etait vraiment pas beau a voir . 번역 문장 : c etait tres fort . -------------------------------------------------- 입력 문장 : tom looks shocked . 정답 문장 : tom a l air choque . 번역 문장 : tom a l air bien . -------------------------------------------------- 입력 문장 : cross the street . 정답 문장 : traversez la rue . 번역 문장 : la ? -------------------------------------------------- 입력 문장 : you nearly died . 정답 문장 : tu es presque mort . 번역 문장 : tu es presque mort . -------------------------------------------------- 14-03 BLEU Score(Bilingual Evaluation Understudy Score) 앞서 언어 모델(Language Model)의 성능 측정을 위한 평가 방법으로 펄 플렉서티(perplexity, PPL)를 소개한 바 있습니다. 기계 번역기에도 PPL을 평가에 사용할 수는 있지만, PPL은 번역의 성능을 직접적으로 반영하는 수치라 보기엔 어렵습니다. 자연어 처리에서는 그 외에도 수많은 평가 방법들이 존재하는데, 기계 번역의 성능이 얼마나 뛰어난가를 측정하기 위해 사용되는 대표적인 방법인 BLEU(Bilingual Evaluation Understudy) 대해서 학습해 보겠습니다. 앞으로 진행되는 설명은 논문 BLEU: a Method for Automatic Evaluation of Machine Translation를 참고로 하여 작성되었습니다. import numpy as np from collections import Counter from nltk import ngrams 1. BLEU(Bilingual Evaluation Understudy) BLEU는 기계 번역 결과와 사람이 직접 번역한 결과가 얼마나 유사한지 비교하여 번역에 대한 성능을 측정하는 방법입니다. 측정 기준은 n-gram에 기반합니다. n-gram의 정의는 언어 모델 챕터를 참고하시기 바랍니다. BLEU는 완벽한 방법이라고는 할 수는 없지만 몇 가지 이점을 가집니다. 언어에 구애받지 않고 사용할 수 있으며, 계산 속도가 빠릅니다. BLEU는 PPL 과는 달리 높을수록 성능이 더 좋음을 의미합니다. BLEU를 이해하기 위해 기계 번역 성능 평가를 위한 몇 가지 직관적인 방법을 먼저 제시하고, 문제점을 보완해나가는 방식으로 설명합니다. 1) 단어 개수 카운트로 측정하기(Unigram Precision) 한국어-영어 번역기의 성능을 측정한다고 가정해 봅시다. 두 개의 기계 번역기가 존재하고 두 기계 번역기에 같은 한국어 문장을 입력하여 번역된 영어 문장의 성능을 측정하고자 합니다. 번역된 문장을 각각 Candidate1, 2라고 해봅시다. 이 문장의 성능을 평가하기 위해서는 정답으로 비교되는 문장이 있어야 합니다. 세 명의 사람에게 한국어를 보고 영작해 보라고 하여 세 개의 번역 문장을 만들어냈습니다. 이 세 문장을 각각 Reference1, 2, 3라고 해봅시다. Example 1 Candidate1 : It is a guide to action which ensures that the military always obeys the commands of the party. Candidate2 : It is to insure the troops forever hearing the activity guidebook that party direct. Reference1 : It is a guide to action that ensures that the military will forever heed Party commands. Reference2 : It is the guiding principle which guarantees the military forces always being under the command of the Party. Reference3 : It is the practical guide for the army always to heed the directions of the party. 편의상 Candidate를 Ca로, Reference를 Ref로 축약하여 부르겠습니다. Ca 1, 2를 Ref 1, 2, 3과 비교하여 성능을 측정하고자 합니다. 가장 직관적인 성능 평가 방법은 Ref 1, 2, 3 중 어느 한 문장이라도 등장한 단어의 개수를 Ca에서 세는 것입니다. 그리고 그 후에 Ca의 모든 단어의 카운트의 합. 즉, Ca에서의 총 단어의 수으로 나눠줍니다. 이러한 측정 방법을 유니그램 정밀도(Unigram Precision)라고 합니다. 이를 식으로 표현하면 다음과 같습니다. 들 중에서 존재하는의 단어의 수 의총 단어 수 Unigram Precision = Ref들 중에서 존재하는 Ca의 단어의 수 Ca의 총 단어 수 the number of Ca words(unigrams) which occur in any Ref the total number of words in the Ca Ca1의 단어들은 얼추 훑어만 봐도 Ref1, Ref2, Ref3에서 전반적으로 등장하는 반면, Ca2는 그렇지 않습니다. 이는 Ca1이 Ca2보다 더 좋은 번역 문장임을 의미합니다. 예를 들어 Ca1의 It is a guide to action은 Ref1에서, which는 Ref2에서, ensures that the militrary는 Ref1에서, always는 Ref2와 Ref3에서, commands는 Ref1에서, of the party는 Ref2에서 등장하였습니다. (대소문자 구분은 없다고 합시다.) Ca1에 있는 단어 중 Ref1, Ref2, Ref3 어디에도 등장하지 않은 단어는 obeys뿐입니다. 반면, Ca2는 Ca1과 비교하여 상대적으로 Ref1, 2, 3에 등장한 단어들이 적습니다. 위의 계산 방법에 따르면 Ca1과 Ca2의 유니그램 정밀도는 각각 아래와 같습니다. Ca1 Unigram Precision = 17 18 Ca2 Unigram Precision = 14 이제부터는 단어라는 표현보다는 유니그램이라는 용어로 설명하겠습니다. 지금까지 설명한 유니그램 정밀도는 나름 의미 있는 측정 방법으로 보이지만 사실 허술한 점이 있습니다. 아래와 같은 새로운 예가 있다고 해봅시다. 2) 중복을 제거하여 보정하기(Modified Unigram Precision) Example 2 Candidate : the the the the the the the Reference1 : the cat is on the mat Reference2 : there is a cat on the mat 위의 Ca는 the만 7개가 등장한 터무니없는 번역입니다. 하지만 이 번역은 앞서 배운 유니그램 정밀도에 따르면 7 1 이라는 최고의 성능 평가를 받게 됩니다. 이에 유니그램 정밀도를 다소 보정할 필요를 느낍니다. 이를 보정하기 위해서는 정밀도의 분자를 계산하기 위해 Ref와 매칭하며 카운트하는 과정에서 Ca의 유니그램이 이미 Ref에서 매칭된 적이 있었는지를 고려해야 합니다. 들과를 고려한 새로운 카운트 방법이 필요 의총 유니 그램 수 Unigram Precision = Ref 들과 Ca를 고려한 새로운 카운트 방법이 필요! Ca의 총 유니그램 수 정밀도의 분자를 계산하기 위한 각 유니그램의 카운트는 다음과 같이 수정합시다. 우선, 유니그램이 하나의 Ref에서 최대 몇 번 등장했는지를 카운트합니다. 이 값을 maximum reference count를 줄인 의미에서 Max_Ref_Count라고 부르겠습니다. Max_Ref_Count가 기존의 단순 카운트한 값보다 작은 경우에는 이 값을 최종 카운트 값으로 대체합니다. 정밀도의 분자 계산을 위한 새로운 카운트 방식을 식으로 표현하면 다음과 같습니다. o n c i = m n ( o n , M x R f C u t ) 위의 카운트를 사용하여 분자를 계산한 정밀도를 보정된 유니그램 정밀도(Modified Unigram Precision)라고 합니다. 의각유니그램에대해을수행한값의총합 의총 유니 그램 수 Modified Unigram Precision = Ca의 각 유니그램에 대해 o n c i 을 수행한 값의 총합 Ca의 총 유니그램 수 분모의 경우에는 이전과 동일하게 Ca의 모든 유니그램에 대해서 각각 o n 하고 모두 합한 값을 사용합니다. 보정된 유니그램 정밀도를 예제를 통해 이해해 봅시다. Example 2를 볼까요? the의 경우에는 Ref1에서 총 두 번 등장하였으므로, the의 카운트는 2로 보정됩니다. Ca의 기존 유니그램 정밀도는 7 1 이었으나 보정된 유니그램 정밀도는 7 와 같이 변경됩니다. 다른 예로 Example 1에서의 Ca1의 보정된 유니그램 정밀도를 계산해 보면 보정되기 이전과 동일하게 17 18 이지만 결과를 얻는 과정은 다릅니다. Ca1에서 the는 3번 등장하지만, Re2와 Ref3에서 the가 4번 등장하므로 3이 4보다 작으므로 the는 3으로 카운트됩니다. the 외에 Ca1의 모든 유니그램은 전부 1개씩 등장하므로 보정 전과 동일하게 카운트하면 됩니다. 결과적으로 보정 이전의 정밀도와 동일하게 17 18 의 값을 가집니다. 3) 보정된 유니그램 정밀도 (Modified Unigram Precision) 구현하기 보정된 유니그램 정밀도를 파이썬 함수로 구현해 보겠습니다. 보정된 유니그램 정밀도를 구현하기 위해서는 유니그램을 카운트하는 o n 함수와 o n c i 함수 두 가지 함수를 구현해야 합니다. 분모를 구하기 위해서 o n 함수를 사용하고, 분자를 구하기 위해서 o n c i 함수를 사용하면 보정된 유니그램 정밀도를 구할 수 있습니다. 우선 유니그램을 단순히 o n 하는 함수를 simple_count라는 이름의 아래 함수로 구현합니다. # 토큰화된 문장(tokens)에서 n-gram을 카운트 def simple_count(tokens, n): return Counter(ngrams(tokens, n)) 위 함수는 토큰화된 문장을 입력받아서 문장 내의 n-gram의 개수를 카운트하는 함수입니다. 구하고자 하는 것은 유니그램 정밀도이므로 카운트하고자 하는 n-gram의 단위를 결정하는 simple_count 함수의 두 번째 인자인 n의 값을 1로 하여 함수를 실행하면 됩니다. Example 1의 Ca1를 가져와 함수가 어떤 결과를 출력하는지 확인해 봅시다. candidate = "It is a guide to action which ensures that the military always obeys the commands of the party." tokens = candidate.split() # 토큰화 result = simple_count(tokens, 1) # n = 1은 유니그램 print('유니그램 카운트 :',result) 유니그램 카운트 : Counter({('the',): 3, ('It',): 1, ('is',): 1, ('a',): 1, ('guide',): 1, ('to',): 1, ('action',): 1, ('which',): 1, ('ensures',): 1, ('that',): 1, ('military',): 1, ('always',): 1, ('obeys',): 1, ('commands',): 1, ('of',): 1, ('party.',): 1}) 위의 출력 결과는 모든 유니그램을 카운트한 결과를 보여줍니다. 대부분의 유니그램이 1개씩 카운트되었으나 유니그램 the는 문장에서 3번 등장하였으므로 유일하게 3의 값을 가집니다. 이번에는 Example 2의 Ca를 가지고 함수를 수행해 봅시다. candidate = 'the the the the the the the' tokens = candidate.split() # 토큰화 result = simple_count(tokens, 1) # n = 1은 유니그램 print('유니그램 카운트 :',result) 유니그램 카운트 : Counter({('the',): 7}) simple_count 함수는 단순 카운트를 수행하므로 the에 대해서 7이라는 카운트 값을 리턴합니다. o n에 대한 함수를 구현하였으니 이번에는 o n c i 을 아래의 count_clip 이름을 가진 함수로 구현해 보겠습니다. def count_clip(candidate, reference_list, n): # Ca 문장에서 n-gram 카운트 ca_cnt = simple_count(candidate, n) max_ref_cnt_dict = dict() for ref in reference_list: # Ref 문장에서 n-gram 카운트 ref_cnt = simple_count(ref, n) # 각 Ref 문장에 대해서 비교하여 n-gram의 최대 등장 횟수를 계산. for n_gram in ref_cnt: if n_gram in max_ref_cnt_dict: max_ref_cnt_dict[n_gram] = max(ref_cnt[n_gram], max_ref_cnt_dict[n_gram]) else: max_ref_cnt_dict[n_gram] = ref_cnt[n_gram] return { # count_clip = min(count, max_ref_count) n_gram: min(ca_cnt.get(n_gram, 0), max_ref_cnt_dict.get(n_gram, 0)) for n_gram in ca_cnt } count_clip 함수는 candidate 문장과 reference 문장들, 그리고 카운트 단위가 되는 n-gram에서의 n의 값 이 세 가지를 인자로 입력받아서 o n c i 을 수행합니다. 여기서는 유니그램 정밀도를 구현하고 있으므로 역시나 n=1로 하여 함수를 실행하면 됩니다. 또한 count_clip 함수 내부에는 기존에 구현했던 simple_count 함수가 사용된 것을 확인할 수 있습니다. o n c i 을 구하기 위해서는 a _ e _ o n 값과 비교하기 위해 o n 값이 필요하기 때문입니다. Example 2를 통해 함수가 정상 작동되는지 확인해 봅시다. candidate = 'the the the the the the the' references = [ 'the cat is on the mat', 'there is a cat on the mat' ] result = count_clip(candidate.split(),list(map(lambda ref: ref.split(), references)),1) print('보정된 유니그램 카운트 :',result) 보정된 유니그램 카운트 : {('the',): 2} 동일한 예제 문장에 대해서 위의 simple_count 함수는 the가 7개로 카운트되었던 것과는 달리 이번에는 2개로 카운트되었습니다. 위의 두 함수를 사용하여 예제 문장에 대해서 보정된 정밀도를 연산하는 함수를 modified_precision란 이름의 함수로 구현해 봅시다. def modified_precision(candidate, reference_list, n): clip_cnt = count_clip(candidate, reference_list, n) total_clip_cnt = sum(clip_cnt.values()) # 분자 cnt = simple_count(candidate, n) total_cnt = sum(cnt.values()) # 분모 # 분모가 0이 되는 것을 방지 if total_cnt == 0: total_cnt = 1 # 분자 : count_clip의 합, 분모 : 단순 count의 합 ==> 보정된 정밀도 return (total_clip_cnt / total_cnt) result = modified_precision(candidate.split(), list(map(lambda ref: ref.split(), references)), n=1) print('보정된 유니그램 정밀도 :',result) 보정된 유니그램 정밀도 : 0.2857142857142857 소수 값이 나오는데 이는 7 의 값을 의미합니다. 이는 앞서 육안으로 계산했던 Example 2에서 Ca의 보정된 정밀도와 동일합니다. 지금까지 보정된 유니그램 정밀도에 대해서 설명하고, 직접 구현까지 해보았습니다. 이제부터 설명에서 언급하는 '정밀도'는 기본적으로 보정된 정밀도(Modified Precision)라고 가정합니다. 정밀도를 보정함으로써 Ca에서 발생하는 단어 중복에 대한 문제점은 해결되었습니다. 하지만 유니그램 정밀도가 가지는 본질적인 문제점이 있기에 유니그램을 넘어 바이 그램, 트라이 그램 등과 같이 n-gram으로 확장해야 합니다. 문제점이 무엇인지 이해하고, 어떻게 n-gram으로 확장하는지 학습해 봅시다. 4) 순서를 고려하기 위해서 n-gram으로 확장하기 BoW 표현과 유사하게, 유니그램 정밀도와 같이 각 단어의 빈도수로 접근하는 방법은 결국 단어의 순서를 고려하지 않는다는 특징이 있습니다. Example 1에 Ca3이라는 새로운 문장을 추가해 보고 기존의 Ca1과 비교해 봅시다. Example 1 Candidate1 : It is a guide to action which ensures that the military always obeys the commands of the party. Candidate2 : It is to insure the troops forever hearing the activity guidebook that party direct. Candidate3 : the that military a is It guide ensures which to commands the of action obeys always party the. Reference1 : It is a guide to action that ensures that the military will forever heed Party commands. Reference2 : It is the guiding principle which guarantees the military forces always being under the command of the Party. Reference3 : It is the practical guide for the army always to heed the directions of the party. Ca3은 사실 Ca1에서 모든 유니그램의 순서를 랜덤으로 섞은 실제 영어 문법에 맞지 않은 문장입니다. 하지만 Ref 1, 2, 3과 비교하여 유니그램 정밀도를 적용하면 Ca1과 Ca3의 두 정밀도는 동일합니다. 유니그램 정밀도는 유니그램의 순서를 전혀 고려하지 않기 때문입니다. 이를 위한 대안으로 개별적인 유니그램/단어로서 카운트하는 유니그램 정밀도에서 다음에 등장한 단어까지 함께 고려하여 카운트하도록 유니그램 외에도 Bigram, Trigram, 4-gram 단위 등으로 계산한 정밀도. 즉, n-gram을 이용한 정밀도를 도입하고자 합니다. 이들 각각은 카운트 단위를 2개, 3개, 4개로 보느냐의 차이로 2-gram Precision, 3-gram Precision, 4-gram Precision이라고 하기도 합니다. 어떤 의미인지 바이 그램(Bigram) 단위로 카운트하여 Example 1, 2의 바이 그램 정밀도(Bigram Precision)를 계산해 보겠습니다. 우선 좀 더 쉬운 Example 2부터 볼까요? Example 2 Candidate1 : the the the the the the the Candidate2 : the cat the cat on the mat Reference1 : the cat is on the mat Reference2 : there is a cat on the mat 이해를 돕고자 Example 2에 Ca2를 새로 추가했습니다. Ca2 바이 그램의 o n 와 o n c i 은 아래와 같습니다. 바이 그램 the cat cat the cat on on the the mat SUM o n 2 1 1 1 1 6 o n c i 1 0 1 1 1 4 결과적으로 Ca2의 바이 그램 정밀도는 6 가 됩니다. 반면, 당연하게도 Ca1의 바이 그램 정밀도는 0입니다. Example 1은 어떨까요? Example 1에서 Ca1의 바이 그램 정밀도는 10 17 이며, Ca2의 바이 그램 정밀도는 13 입니다. Ca1에서 단어의 순서를 뒤섞은 Ca3의 바이 그램 정밀도는 독자분들의 숙제로 남깁니다. 보정된 정밀도를 식으로 정의해 보겠습니다. n 에서 은 n-gram에서의 을 의미한다고 하였을 때, 앞서 배운 보정된 유니그램 정밀도의 식을 상기해 봅시다. 1 ∑ n g a ∈ a d d t C u t l p ( n g a) u i r m C n i a e C u t ( n g a) 이를 n-gram으로 일반화하면 아래와 같습니다. n ∑ - r m C n i a e C u t l p ( - r m ) n g a ∈ a d d t C u t ( - r m ) 유니그램 정밀도에서는 이 1이므로 1 로 표현하였으나, 일반화된 식에서는 n 으로 표현한 것을 볼 수 있습니다. 여기서는 보정된 바이 그램 정밀도 2 , 보정된 트라이 그램 정밀도 3 등에 대한 파이썬 실습은 생략합니다. 사실 n 을 계산하기 위한 함수를 별도로 다시 구현할 필요는 없는데, 앞서 구현한 함수 simple_count, count_clip, modified_precision은 모두 n-gram의 n을 함수의 인자로 받으므로, n을 1대신 다른 값을 넣어서 실습해 보면 바이 그램, 트라이 그램 등에 대해서도 보정된 정밀도를 구할 수 있습니다. n-gram 정밀도 식을 이해하였다면 BLEU의 최종 식까지 다 왔습니다. BLEU는 보정된 정밀도 1 p, . , n 를 모두 조합하여 사용합니다. 이를 모두 조합한 BLEU의 식은 아래와 같습니다. L U e p ( n 1 w log p) n : 각 gram의 보정된 정밀도입니다. : n-gram에서의 최대 숫자입니다. 보통은 4의 값을 가집니다. 이 4라는 것은 1 p, 3 p를 사용한다는 것을 의미합니다. n : 각 gram의 보정된 정밀도에 서로 다른 가중치를 줄 수 있습니다. 이 가중치의 합은 1로 합니다. 예를 들어 이 4라고 하였을 때, 1 p, 3 p에 대해서 동일한 가중치를 주고자 한다면 모두 0.25를 적용할 수 있습니다. BLEU의 최종식에 거의 다 도달했습니다. 즉, 여전히 위의 BLEU 식에도 문제점이 존재합니다. 5) 짧은 문장 길이에 대한 페널티(Brevity Penalty) n-gram으로 단어의 순서를 고려한다고 하더라도 여전히 남아있는 문제가 있는데, 바로 Ca의 길이에 BLEU의 점수가 과한 영향을 받을 수 있다는 점입니다. 기존 Example 1에 다음의 Ca를 추가한다고 해보겠습니다. Example 1 Candidate4 : it is 이 문장은 유니그램 정밀도나 바이 그램 정밀도가 각각 2 1로 두 정밀도 모두 1이라는 높은 정밀도를 얻습니다. 이과같이 제대로 된 번역이 아님에도 문장의 길이가 짧다는 이유로 높은 점수를 받는 것은 이상합니다. 그래서 Ca가 Ref보다 문장의 길이가 짧은 경우에는 점수에 페널티를 줄 필요가 있습니다. 이를 브레 버티 페널티(Brevity Penalty)라고 합니다. (직역하면 짧음 페널티) 이에 대해서 배우기 전에, 만약 반대로 Ca의 길이가 Ref보다 긴 경우에도 문제가 생길 수 있는지 보겠습니다. Example 3 Candidate 1: I always invariably perpetually do. Candidate 2: I always do. Reference 1: I always do. Reference 2: I invariably do. Reference 3: I perpetually do. Example 3에서 Ca1은 가장 많은 단어를 사용했지만 Ca2보다 좋지 못한 번역입니다. 다시 말해 Ref의 단어를 가장 많이 사용한 것이 꼭 좋은 번역이라는 의미는 아닙니다. 그런데 다행히도 위와 같이 Ca의 길이가 불필요하게 Ref보다 긴 경우에는 BLEU 수식에서 정밀도를 n-gram으로 확장하여 바이 그램, 트라이 그램 정밀도 등을 모두 계산에 사용하고 있는 것만으로도 이미 페널티를 받고 있습니다. 즉, 브레 버티 페널티를 설계할 때, 이 경우까지 고려할 필요는 없습니다. 다시 Ref보다 Ca의 길이가 짧을 경우에 페널티를 주는 브레 버티 페널티의 이야기로 돌아보겠습니다. 브레 버티 페널티는 앞서 배운 BLEU의 식에 곱하는 방식으로 사용합니다. 브레 버티 페널티를 줄여서 P 라고 하였을 때, 최종 BLEU의 식은 아래와 같습니다. L U B × x ( n 1 w log p) 위의 수식은 페널티를 줄 필요가 없는 경우에는 P 의 값이 1이어야 함을 의미합니다. 이를 반영한 P 의 수식은 아래와 같습니다. P { if c r ( − / ) if c r : Candidate의 길이 : Candidate와 가장 길이 차이가 작은 Reference의 길이 Ref가 1개라면 Ca와 Ref의 두 문장의 길이만을 가지고 계산하면 되겠지만 여기서는 Ref가 여러 개일 때를 가정하고 있으므로 은 모든 Ref들 중에서 Ca와 가장 길이 차이가 작은 Ref의 길이로 합니다. 을 구하는 코드는 아래와 같습니다. # Ca 길이와 가장 근접한 Ref의 길이를 리턴하는 함수 def closest_ref_length(candidate, reference_list): ca_len = len(candidate) # ca 길이 ref_lens = (len(ref) for ref in reference_list) # Ref들의 길이 # 길이 차이를 최소화하는 Ref를 찾아서 Ref의 길이를 리턴 closest_ref_len = min(ref_lens, key=lambda ref_len: (abs(ref_len - ca_len), ref_len)) return closest_ref_len 만약 Ca와 길이가 정확히 동일한 Ref가 있다면 길이 차이가 0인 최고 수준의 매치(best match length)입니다. 또한 만약 서로 다른 길이의 Ref이지만 Ca와 길이 차이가 동일한 경우에는 더 작은 길이의 Ref를 택합니다. 예를 들어 Ca가 길이가 10인데, Ref 1, 2가 각각 9와 11이라면 길이 차이는 동일하게 1밖에 나지 않지만 9를 택합니다. closest_ref_length 함수를 통해 을 구했다면, P 를 구하는 함수 brevity_penalty를 구현해 봅시다. def brevity_penalty(candidate, reference_list): ca_len = len(candidate) ref_len = closest_ref_length(candidate, reference_list) if ca_len > ref_len: return 1 # candidate가 비어있다면 BP = 0 → BLEU = 0.0 elif ca_len == 0 : return 0 else: return np.exp(1 - ref_len/ca_len) 위 함수는 앞서 배운 P 의 수식처럼 가 보다 클 경우에는 1을 리턴하고, 그 외의 경우에는 1 r c 를 리턴합니다. 최종적으로 BLEU 점수를 계산하는 함수 bleu_score를 구현해 봅시다. def bleu_score(candidate, reference_list, weights=[0.25, 0.25, 0.25, 0.25]): bp = brevity_penalty(candidate, reference_list) # 브레 버티 페널티, BP p_n = [modified_precision(candidate, reference_list, n=n) for n, _ in enumerate(weights, start=1)] # p1, p2, p3, ..., pn score = np.sum([w_i * np.log(p_i) if p_i != 0 else 0 for w_i, p_i in zip(weights, p_n)]) return bp * np.exp(score) 위의 bleu_score 함수는 기본적으로는 이 4에 각 gram에 대한 가중치는 동일하게 0.25라 주어진다고 가정합니다. 또한 함수 내에서는 P 를 구하고 bp에, 1 p, . , n 를 구하여 p_n에 저장하도록 구현돼 있습니다. 그리고 앞서 배운 BLEU의 식에 따라 추가 연산하여 최종 계산한 값을 리턴합니다. 위 함수가 동작하기 위해서는 앞서 구현한 simple_count, count_clip, modified_precision, brevity_penalty 4개의 함수 또한 모두 구현돼 있어야 합니다. 지금까지 구현한 BLEU 코드로 계산된 점수와 NLTK 패키지에 이미 구현돼 있는 BLEU 코드로 계산된 점수를 비교해 봅시다. 2. NLTK를 사용한 BLEU 측정하기 파이썬에서는 NLTK 패키지를 사용하여 BLEU를 계산할 수 있습니다. import nltk.translate.bleu_score as bleu candidate = 'It is a guide to action which ensures that the military always obeys the commands of the party' references = [ 'It is a guide to action that ensures that the military will forever heed Party commands', 'It is the guiding principle which guarantees the military forces always being under the command of the Party', 'It is the practical guide for the army always to heed the directions of the party' ] print('실습 코드의 BLEU :',bleu_score(candidate.split(),list(map(lambda ref: ref.split(), references)))) print('패키지 NLTK의 BLEU :',bleu.sentence_bleu(list(map(lambda ref: ref.split(), references)),candidate.split())) 실습 코드의 BLEU : 0.5045666840058485 패키지 NLTK의 BLEU : 0.5045666840058485 15. 어텐션 메커니즘 (Attention Mechanism) 이번 챕터에서는 신경망들의 성능을 높이기 위한 메커니즘이자, 이제는 AI 분야에서 대세 모듈로서 사용되고 있는 트랜스포머의 기반이 되는 어텐션 메커니즘에 대해서 학습합니다. 15-01 어텐션 메커니즘 (Attention Mechanism) 앞서 배운 seq2seq 모델은 인코더에서 입력 시퀀스를 컨텍스트 벡터라는 하나의 고정된 크기의 벡터 표현으로 압축하고, 디코더는 이 컨텍스트 벡터를 통해서 출력 시퀀스를 만들어냈습니다. 하지만 이러한 RNN에 기반한 seq2seq 모델에는 크게 두 가지 문제가 있습니다. 첫째, 하나의 고정된 크기의 벡터에 모든 정보를 압축하려고 하니까 정보 손실이 발생합니다. 둘째, RNN의 고질적인 문제인 기울기 소실(vanishing gradient) 문제가 존재합니다. 결국 이는 기계 번역 분야에서 입력 문장이 길면 번역 품질이 떨어지는 현상으로 나타났습니다. 이를 위한 대안으로 입력 시퀀스가 길어지면 출력 시퀀스의 정확도가 떨어지는 것을 보정해 주기 위한 등장한 기법인 어텐션(attention)을 소개합니다. 1. 어텐션(Attention)의 아이디어 어텐션의 기본 아이디어는 디코더에서 출력 단어를 예측하는 매 시점(time step)마다, 인코더에서의 전체 입력 문장을 다시 한번 참고한다는 점입니다. 단, 전체 입력 문장을 전부 다 동일한 비율로 참고하는 것이 아니라, 해당 시점에서 예측해야 할 단어와 연관이 있는 입력 단어 부분을 좀 더 집중(attention) 해서 보게 됩니다. 2. 어텐션 함수(Attention Function) 어텐션 메커니즘을 언급하기 전에 컴퓨터공학의 많은 분야에서 사용되는 Key-Value로 구성되는 자료형에 대해서 잠깐 언급하겠습니다. 가령, 이 책의 주 언어로 사용되는 파이썬에도 Key-Value로 구성되는 자료형인 딕셔너리(Dict) 자료형이 존재합니다. 파이썬의 딕셔너리 자료형은 키(Key)와 값(Value)이라는 두 개의 쌍으로 구성되는데, 키를 통해서 매핑된 값을 찾아낼 수 있다는 특징을 갖고 있습니다. # 파이썬의 딕셔너리 자료형을 선언 # 키(Key) : 값(value)의<NAME>으로 키와 값의 쌍(Pair)을 선언한다. dict = {"2017" : "Transformer", "2018" : "BERT"} 위의 자료형에서 2017은 키에 해당되며, Transformer는 2017의 키와 매핑되는 값에 해당됩니다. 그와 마찬가지로 2018은 키에 해당되며, BERT는 2018이라는 키와 매핑되는 값에 해당됩니다. print(dict["2017"]) #2017이라는 키에 해당되는 값을 출력 Transformer print(dict["2018"]) #2018이라는 키에 해당되는 값을 출력 BERT Key-Value 자료형에 대한 이해를 가지고 어텐션 함수에 대해서 설명해 보겠습니다. 어텐션을 함수로 표현하면 주로 다음과 같이 표현됩니다. Attention(Q, K, V) = Attention Value 어텐션 함수는 주어진 '쿼리(Query)'에 대해서 모든 '키(Key)'와의 유사도를 각각 구합니다. 그리고 구해낸 이 유사도를 키와 매핑되어있는 각각의 '값(Value)'에 반영해 줍니다. 그리고 유사도가 반영된 '값(Value)'을 모두 더해서 리턴합니다. 여기서는 이를 어텐션 값(Attention Value)이라고 하겠습니다. 지금부터 배우게 되는 seq2seq + 어텐션 모델에서 Q, K, V에 해당되는 각각의 Query, Keys, Values는 각각 다음과 같습니다. Q = Query : t 시점의 디코더 셀에서의 은닉 상태 K = Keys : 모든 시점의 인코더 셀의 은닉 상태들 V = Values : 모든 시점의 인코더 셀의 은닉 상태들 간단한 어텐션 예제를 통해 어텐션을 이해해 보겠습니다. 3. 닷-프로덕트 어텐션(Dot-Product Attention) 어텐션은 다양한 종류가 있는데 그중에서도 가장 수식적으로 이해하기 쉽게 수식을 적용한 닷-프로덕트 어텐션(Dot-Product Attention)을 통해 어텐션을 이해해 봅시다. seq2seq에서 사용되는 어텐션 중에서 닷-프로덕트 어텐션과 다른 어텐션의 차이는 주로 중간 수식의 차이로 메커니즘 자체는 거의 유사합니다. 위 그림은 디코더의 세 번째 LSTM 셀에서 출력 단어를 예측할 때, 어텐션 메커니즘을 사용하는 모습을 보여줍니다. 디코더의 첫 번째, 두 번째 LSTM 셀은 이미 어텐션 메커니즘을 통해 je와 suis를 예측하는 과정을 거쳤다고 가정합니다. 어텐션 메커니즘에 대해 상세히 설명하기 전에 위의 그림을 통해 전체적인 개요만 이해해 보겠습니다. 디코더의 세 번째 LSTM 셀은 출력 단어를 예측하기 위해서 인코더의 모든 입력 단어들의 정보를 다시 한번 참고하고자 합니다. 중간 과정에 대한 설명은 현재는 생략하고 여기서 주목할 것은 인코더의 소프트맥스 함수입니다. 소프트맥스 함수를 통해 나온 결괏값은 I, am, a, student 단어 각각이 출력 단어를 예측할 때 얼마나 도움이 되는지의 정도를 수치화한 값입니다. 위의 그림에서는 빨간 직사각형의 크기로 소프트맥스 함수의 결괏값의 크기를 표현했습니다. 직사각형의 크기가 클수록 도움이 되는 정도의 크기가 큽니다. 각 입력 단어가 디코더의 예측에 도움이 되는 정도가 수치화하여 측정되면 이를 하나의 정보로 담아서 디코더로 전송됩니다. 위의 그림에서는 초록색 삼각형이 이에 해당됩니다. 결과적으로, 디코더는 출력 단어를 더 정확하게 예측할 확률이 높아집니다. 좀 더 상세히 알아보겠습니다. 1) 어텐션 스코어(Attention Score)를 구한다. 인코더의 시점(time step)을 각각 1, 2, ... N이라고 하였을 때 인코더의 은닉 상태(hidden state)를 각각 1 h, ... N 라고 합시다. 디코더의 현재 시점(time step) t에서의 디코더의 은닉 상태(hidden state)를 t 라고 합시다. 또한 여기서는 인코더의 은닉 상태와 디코더의 은닉 상태의 차원이 같다고 가정합니다. 위의 그림의 경우에는 인코더의 은닉 상태와 디코더의 은닉 상태가 동일하게 차원이 4입니다. 어텐션 메커니즘의 첫걸음인 어텐션 스코어(Attention score)에 대해서 배우기 전에, 이전 챕터 배웠던 디코더의 현재 시점 t에서 필요한 입력값을 다시 상기해 보겠습니다. 시점 t에서 출력 단어를 예측하기 위해서 디코더의 셀은 두 개의 입력값을 필요로 하는데, 바로 이전 시점인 t-1의 은닉 상태와 이전 시점 t-1에 나온 출력 단어입니다. 그런데 어텐션 메커니즘에서는 출력 단어 예측에 또 다른 값을 필요로 하는데 바로 어텐션 값(Attention Value)이라는 새로운 값입니다. t 번째 단어를 예측하기 위한 어텐션 값을 t 이라고 정의하겠습니다. 어텐션 값이라는 새로운 개념이 등장한 만큼, 어텐션 값이 현재 시점 t에서의 출력 예측에 구체적으로 어떻게 반영되는지는 뒤에서 설명하겠습니다. 지금부터 배우는 모든 과정은 t 를 구하기 위한 여정입니다. 그리고 그 여정의 첫걸음은 바로 어텐션 스코어(Attention Score)를 구하는 일입니다. 어텐션 스코어란 현재 디코더의 시점 t에서 단어를 예측하기 위해, 인코더의 모든 은닉 상태 각각이 디코더의 현시점의 은닉 상태 t 와 얼마나 유사한지를 판단하는 스코어 값입니다. 닷-프로덕트 어텐션에서는 이 스코어 값을 구하기 위해 t 를 전치(transpose) 하고 각 은닉 상태와 내적(dot product)을 수행합니다. 즉, 모든 어텐션 스코어 값은 스칼라입니다. 예를 들어 t 과 인코더의 i 번째 은닉 상태의 어텐션 스코어의 계산 방법은 아래와 같습니다. 어텐션 스코어 함수를 정의해 보면 다음과 같습니다. c r ( t h) s T i t 와 인코더의 모든 은닉 상태의 어텐션 스코어의 모음 값을 t 라고 정의하겠습니다. t 의 수식은 다음과 같습니다. t [ t h, . , t h ] 2) 소프트맥스(softmax) 함수를 통해 어텐션 분포(Attention Distribution)를 구한다. t 에 소프트맥스 함수를 적용하여, 모든 값을 합하면 1이 되는 확률 분포를 얻어냅니다. 이를 어텐션 분포(Attention Distribution)라고 하며, 각각의 값은 어텐션 가중치(Attention Weight)라고 합니다. 예를 들어 소프트맥스 함수를 적용하여 얻은 출력값인 I, am, a, student의 어텐션 가중치를 각각 0.1, 0.4, 0.1, 0.4라고 합시다. 이들의 합은 1입니다. 위의 그림은 각 인코더의 은닉 상태에서의 어텐션 가중치의 크기를 직사각형의 크기를 통해 시각화하였습니다. 즉, 어텐션 가중치가 클수록 직사각형이 큽니다. 디코더의 시점 t에서의 어텐션 가중치의 모음 값인 어텐션 분포를 t 이라고 할 때, t 을 식으로 정의하면 다음과 같습니다. t s f m x ( t ) 3) 각 인코더의 어텐션 가중치와 은닉 상태를 가중 합하여 어텐션 값(Attention Value)을 구한다. 이제 지금까지 준비해온 정보들을 하나로 합치는 단계입니다. 어텐션의 최종 결괏값을 얻기 위해서 각 인코더의 은닉 상태와 어텐션 가중치 값들을 곱하고, 최종적으로 모두 더합니다. 요약하면 가중합(Weighted Sum)을 진행합니다. 아래는 어텐션의 최종 결과. 즉, 어텐션 함수의 출력값인 어텐션 값(Attention Value) t 에 대한 식을 보여줍니다. t ∑ = N i h 이러한 어텐션 값 t 은 종종 인코더의 문맥을 포함하고 있다고 하여, 컨텍스트 벡터(context vector)라고도 불립니다. 앞서 배운 가장 기본적인 seq2seq에서는 인코더의 마지막 은닉 상태를 컨텍스트 벡터라고 부르는 것과 대조됩니다. 4) 어텐션 값과 디코더의 t 시점의 은닉 상태를 연결한다.(Concatenate) 어텐션 함수의 최종 값인 어텐션 값 t 을 구했습니다. 사실 어텐션 값이 구해지면 어텐션 메커니즘은 t s 와 결합(concatenate) 하여 하나의 벡터로 만드는 작업을 수행합니다. 이를 t 라고 정의해 보겠습니다. 그리고 이 t y 예측 연산의 입력으로 사용함으로써 인코더로부터 얻은 정보를 활용하여 ^ 를 좀 더 잘 예측할 수 있게 됩니다. 이것이 어텐션 메커니즘의 핵심입니다. 5) 출력층 연산의 입력이 되는 ~를 계산합니다. 논문에서는 t 를 바로 출력층으로 보내기 전에 신경망 연산을 한 번 더 추가하였습니다. 가중치 행렬과 곱한 후에 하이퍼볼릭탄젠트 함수를 지나도록 하여 출력층 연산을 위한 새로운 벡터인 ~를 얻습니다. 어텐션 메커니즘을 사용하지 않는 seq2seq에서는 출력층의 입력이 t 시점의 은닉 상태인 t 였던 반면, 어텐션 메커니즘에서는 출력층의 입력이 ~ 가 되는 셈입니다. 식으로 표현하면 다음과 같습니다. c 는 학습 가능한 가중치 행렬, c 는 편향입니다. 그림에서 편향은 생략했습니다. ~ = tanh ( c [ t s ] b) 6) ~를 출력층의 입력으로 사용합니다. ~를 출력층의 입력으로 사용하여 예측 벡터를 얻습니다. ^ = Softmax ( y ~ + y ) 4. 다양한 종류의 어텐션(Attention) 앞서 seq2seq + 어텐션(attention) 모델에 쓰일 수 있는 다양한 어텐션 종류가 있지만, 닷-프로덕트 어텐션과 다른 어텐션들의 차이는 중간 수식의 차이라고 언급한 바 있습니다. 여기서 말하는 중간 수식은 어텐션 스코어 함수를 말합니다. 위에서 배운 어텐션이 닷-프로덕트 어텐션인 이유는 어텐션 스코어를 구하는 방법이 내적이었기 때문입니다. 어텐션 스코어를 구하는 방법은 여러 가지가 제시되어 있으며, 현재 제시된 여러 종류의 어텐션 스코어 함수는 다음과 같습니다. 이름 스코어 함수 Defined by o s o e ( t h) s T i Luong et al. (2015) c l d o s o e ( t h) s T i Vaswani et al. (2017) e e a s o e ( t h) s T a i // 단, a 는 학습 가능한 가중치 행렬 Luong et al. (2015) o c t c r ( t h) W T t n ( b [ t h ] ) s o e ( t h) W T t n ( b t W h) Bahdanau et al. (2015) o a i n b s α = o t a ( a t ) // t 산출 시에 t 만 사용하는 방법. Luong et al. (2015) 위에서 t 는 Query, i 는 Keys, a W는 학습 가능한 가중치 행렬입니다. 이름이 dot이라고 붙여진 스코어 함수가 이번에 배운 닷 프로덕트 어텐션입니다. 이 어텐션은 제안한 사람의 이름을 따서 루 옹(Luong) 어텐션이라고도 합니다. 제안한 이들의 이름은 위 테이블에서 Defined By에 적혀져 있습니다. concat이라는 이름의 어텐션은 만든 사람의 이름을 따서 바다나 우(Bahdanau) 어텐션이라고도 부르며 뒤에서 설명합니다. 지금까지 seq2seq에서 성능을 향상시켜주기 위한 기법인 어텐션에 대해서 알아봤습니다. 어텐션은 처음에는 RNN 기반의 seq2seq의 성능을 보정하기 위한 목적으로 소개되었지만, 현재에 이르러서는 어텐션 스스로가 기존의 seq2seq를 대체하는 방법이 되어가고 있습니다. 이에 대해서는 다음 챕터인 트랜스포머(Transformer) 챕터에서 더 자세히 배워보겠습니다. 15-02 바다나 우 어텐션(Bahdanau Attention) 앞서 어텐션 메커니즘의 목적과 어텐션 메커니즘의 일종인 닷 프로덕트 어텐션(루 옹 어텐션)의 전체적인 개요를 살펴보고, 마지막에 표를 통해 그 외에도 다양한 어텐션 메커니즘이 존재한다고 소개하였습니다. 이번에는 닷 프로덕트 어텐션보다는 조금 더 복잡하게 설계된 바다나 우 어텐션 메커니즘을 이해해 봅시다. 1. 바다나 우 어텐션 함수(Bahdanau Attention Function) 어텐션 메커니즘을 함수 Attention()으로 정의하였을 때, 바다나 우 어텐션 함수의 입, 출력은 다음과 같의 정의할 수 있습니다. Attention(Q, K, V) = Attention Value t = 어텐션 메커니즘이 수행되는 디코더 셀의 현재 시점을 의미. Q = Query : t-1 시점의 디코더 셀에서의 은닉 상태 K = Keys : 모든 시점의 인코더 셀의 은닉 상태들 V = Values : 모든 시점의 인코더 셀의 은닉 상태들 여기서는 어텐션 함수의 Query가 디코더 셀의 t 시점의 은닉 상태가 아니라 t-1 시점의 은닉 상태임을 주목합시다. 2. 바다나 우 어텐션(Bahdanau Attention) 바다나 우 어텐션의 연산 순서를 이해해 봅시다. 1) 어텐션 스코어(Attention Score)를 구한다. 인코더의 시점(time step)을 각각 1, 2, ... N이라고 하였을 때 인코더의 은닉 상태(hidden state)를 각각 1 h, ... N 라고 합시다. 디코더의 현재 시점(time step) t에서의 디코더의 은닉 상태(hidden state)를 t 라고 합시다. 또한 여기서는 인코더의 은닉 상태와 디코더의 은닉 상태의 차원이 같다고 가정합니다. 위의 그림의 경우에는 인코더의 은닉 상태와 디코더의 은닉 상태가 동일하게 차원이 4입니다. 앞서 루 옹 어텐션에서는 Query로 디코더의 t 시점의 은닉 상태를 사용한 것과는 달리 이번에는 t-1 시점의 은닉 상태 t 1 를 사용합니다. 바다나 우 어텐션의 어텐션 스코어 함수. 즉, t 1 과 인코더의 i 번째 은닉 상태의 어텐션 스코어 계산 방법은 아래와 같습니다. c r ( t 1 h) W T t n ( b t 1 W h) 단, a W, c 는 학습 가능한 가중치 행렬입니다. t 1 h, 2 h, 4 의 어텐션 스코어를 각각 구해야 하므로 병렬 연산을 위해 1 h, 3 h를 하나의 행렬로 두겠습니다. 수식은 다음과 같이 변경됩니다. c r ( t 1 H ) W T t n ( b t 1 W H ) 그림을 통해 이해해 봅시다. 우선 b t 1 W H 를 각각 구하면 다음과 같습니다. 이들을 더한 후, 하이퍼볼릭탄젠트 함수를 지나도록 합니다. 지금까지 진행된 연산의 수식은 다음과 같습니다. a h ( b t 1 W H ) 이제 a 와 곱하여 t 1 h, 2 h, 4 의 유사도가 기록된 어텐션 스코어 벡터 t 를 얻습니다. t W T t n ( b t 1 W H ) 2) 소프트맥스(softmax) 함수를 통해 어텐션 분포(Attention Distribution)를 구한다. t 에 소프트맥스 함수를 적용하여, 모든 값을 합하면 1이 되는 확률 분포를 얻어냅니다. 이를 어텐션 분포(Attention Distribution)라고 하며, 각각의 값은 어텐션 가중치(Attention Weight)라고 합니다. 3) 각 인코더의 어텐션 가중치와 은닉 상태를 가중 합하여 어텐션 값(Attention Value)을 구한다. 지금까지 준비해온 정보들을 하나로 합치는 단계입니다. 어텐션의 최종 결괏값을 얻기 위해서 각 인코더의 은닉 상태와 어텐션 가중치 값들을 곱하고, 최종적으로 모두 더합니다. 요약하면 가중합(Weighted Sum)을 한다고 말할 수도 있겠습니다. 이 벡터는 인코더의 문맥을 포함하고 있다고 하여, 컨텍스트 벡터(context vector)라고 부릅니다. 4) 컨텍스트 벡터로부터 t 를 구합니다. 기존의 LSTM이 t 를 구할 때를 아래 그림을 통해 상기해 봅시다. 기존의 LSTM은 이전 시점의 셀로부터 전달받은 은닉 상태 t 1 와 현재 시점의 입력 t 를 가지고 연산하였습니다. 아래의 LSTM은 seq2seq의 디코더이며 현재 시점의 입력 t 는 임베딩된 단어 벡터입니다. 그렇다면 어텐션 메커니즘에서는 어떨까요? 아래의 그림은 바다나 우 어텐션 메커니즘에서는 컨텍스트 벡터와 현재 시점의 입력인 단어의 임베딩 벡터를 연결(concatenate) 하고, 현재 시점의 새로운 입력으로 사용하는 모습을 보여줍니다. 그리고 이전 시점의 셀로부터 전달받은 은닉 상태 t 1 와 현재 시점의 새로운 입력으로부터 t 를 구합니다. 기존의 LSTM이 임베딩된 단어 벡터를 입력으로 하는 것에서 컨텍스트 벡터와 임베딩된 단어 벡터를 연결(concatenate) 하여 입력으로 사용하는 것이 달라졌습니다. 이후에는 어텐션 메커니즘을 사용하지 않는 경우와 동일합니다. t 는 출력층으로 전달되어 현재 시점의 예측값을 구하게 됩니다. 15-03 양방향 LSTM과 어텐션 메커니즘(BiLSTM with Attention mechanism) 단뱡항 LSTM으로 텍스트 분류를 수행할 수도 있지만 때로는 양방향 LSTM을 사용하는 것이 더 강력합니다. 여기에 추가적으로 어텐션 메커니즘을 사용할 수도 있습니다. 양방향 LSTM과 어텐션 메커니즘으로 IMDB 리뷰 감성 분류하기를 수행해 봅시다. 1. IMDB 리뷰 데이터 전처리하기 from tensorflow.keras.datasets import imdb from tensorflow.keras.utils import to_categorical from tensorflow.keras.preprocessing.sequence import pad_sequences IMDB 리뷰 데이터는 앞서 텍스트 분류하기 챕터에서 다룬 바 있으므로 데이터에 대한 상세 설명은 생략합니다. 최대 단어 개수를 10,000으로 제한하고 훈련 데이터와 테스트 데이터를 받아옵니다. vocab_size = 10000 (X_train, y_train), (X_test, y_test) = imdb.load_data(num_words = vocab_size) 훈련 데이터와 이에 대한 레이블이 각각 X_train, y_train에 테스트 데이터와 이에 대한 레이블이 각각 X_test, y_test에 저장되었습니다. IMDB 리뷰 데이터는 이미 정수 인코딩이 된 상태므로 남은 전처리는 패딩뿐입니다. 리뷰의 최대 길이와 평균 길이를 확인해 봅시다. print('리뷰의 최대 길이 : {}'.format(max(len(l) for l in X_train))) print('리뷰의 평균 길이 : {}'.format(sum(map(len, X_train))/len(X_train))) 리뷰의 최대 길이 : 2494 리뷰의 평균 길이 : 238.71364 리뷰의 최대 길이는 2,494이며 리뷰의 평균 길이는 약 238로 확인됩니다. 평균 길이보다는 조금 크게 데이터를 패딩 하겠습니다. max_len = 500 X_train = pad_sequences(X_train, maxlen=max_len) X_test = pad_sequences(X_test, maxlen=max_len) 훈련용 리뷰와 테스트용 리뷰의 길이가 둘 다 500이 되었습니다. 2. 바다나 우 어텐션(Bahdanau Attention) 여기서 사용할 어텐션은 바다나 우 어텐션(Bahdanau attention)입니다. 이를 이해하기 위해 앞서 배운 가장 쉬운 어텐션이었던 닷 프로덕트 어텐션과 어텐션 스코어 함수의 정의를 상기해 봅시다. 어텐션 스코어 함수란 주어진 query와 모든 key에 대해서 유사도를 측정하는 함수를 말합니다. 그리고 닷 프로덕트 어텐션에서는 query와 key의 유사도를 구하는 방법이 내적(dot product)이었습니다. 다음은 닷 프로덕트 어텐션의 어텐션 스코어 함수를 보여줍니다. c r ( u r , k y ) q e y k y 바다나 우 어텐션은 아래와 같은 어텐션 스코어 함수를 사용합니다. c r ( u r , k y ) V t n ( 1 e + 2 u r) 이 어텐션 스코어 함수를 사용하여 어텐션 메커니즘을 구현하면 됩니다. 그런데 텍스트 분류에서 어텐션 메커니즘을 사용하는 이유는 무엇일까요? RNN의 마지막 은닉 상태는 예측을 위해 사용됩니다. 그런데 이 RNN의 마지막 은닉 상태는 몇 가지 유용한 정보들을 손실한 상태입니다. 그래서 RNN이 time step을 지나며 손실했던 정보들을 다시 참고하고자 합니다. 이는 다시 말해 RNN의 모든 은닉 상태들을 다시 한번 참고하겠다는 것입니다. 그리고 이를 위해서 어텐션 메커니즘을 사용합니다. import tensorflow as tf class BahdanauAttention(tf.keras.Model): def __init__(self, units): super(BahdanauAttention, self).__init__() self.W1 = Dense(units) self.W2 = Dense(units) self.V = Dense(1) def call(self, values, query): # 단, key와 value는 같음 # query shape == (batch_size, hidden size) # hidden_with_time_axis shape == (batch_size, 1, hidden size) # score 계산을 위해 뒤에서 할 덧셈을 위해서 차원을 변경해줍니다. hidden_with_time_axis = tf.expand_dims(query, 1) # score shape == (batch_size, max_length, 1) # we get 1 at the last axis because we are applying score to self.V # the shape of the tensor before applying self.V is (batch_size, max_length, units) score = self.V(tf.nn.tanh( self.W1(values) + self.W2(hidden_with_time_axis))) # attention_weights shape == (batch_size, max_length, 1) attention_weights = tf.nn.softmax(score, axis=1) # context_vector shape after sum == (batch_size, hidden_size) context_vector = attention_weights * values context_vector = tf.reduce_sum(context_vector, axis=1) return context_vector, attention_weights 3. 양방향 LSTM + 어텐션 메커니즘(BiLSTM with Attention Mechanism) from tensorflow.keras.layers import Dense, Embedding, Bidirectional, LSTM, Concatenate, Dropout from tensorflow.keras import Input, Model from tensorflow.keras import optimizers import os 이제 모델을 설계해 보겠습니다. 여기서는 케라스의 함수형 API를 사용합니다. 우선 입력층과 임베딩층을 설계합니다. sequence_input = Input(shape=(max_len,), dtype='int32') embedded_sequences = Embedding(vocab_size, 128, input_length=max_len, mask_zero = True)(sequence_input) 10,000개의 단어들을 128차원의 벡터로 임베딩하도록 설계하였습니다. 이제 양방향 LSTM을 설계합니다. 단, 여기서는 양방향 LSTM을 두 층을 사용하겠습니다. 우선, 첫 번째 층입니다. 두 번째 층을 위에 쌓을 예정이므로 return_sequences를 True로 해주어야 합니다. lstm = Bidirectional(LSTM(64, dropout=0.5, return_sequences = True))(embedded_sequences) 두 번째 층을 설계합니다. 상태를 리턴 받아야 하므로 return_state를 True로 해주어야 합니다. lstm, forward_h, forward_c, backward_h, backward_c = Bidirectional \ (LSTM(64, dropout=0.5, return_sequences=True, return_state=True))(lstm) 각 상태의 크기(shape)를 출력해 보겠습니다. print(lstm.shape, forward_h.shape, forward_c.shape, backward_h.shape, backward_c.shape) (None, 500, 128) (None, 64) (None, 64) (None, 64) (None, 64) 순방향 LSTM의 은닉 상태와 셀상태를 forward_h, forward_c에 저장하고, 역방향 LSTM의 은닉 상태와 셀 상태를 backward_h, backward_c에 저장합니다. 각 은닉 상태나 셀 상태의 경우에는 128차원을 가지는데, lstm의 경우에는 (500 × 128)의 크기를 가집니다. foward 방향과 backward 방향이 연결된 hidden state 벡터가 모든 시점에 대해서 존재함을 의미합니다. 양방향 LSTM을 사용할 경우에는 순방향 LSTM과 역방향 LSTM 각각 은닉 상태와 셀 상태를 가지므로, 양방향 LSTM의 은닉 상태와 셀 상태를 사용하려면 두 방향의 LSTM의 상태들을 연결(concatenate) 해주면 됩니다. state_h = Concatenate()([forward_h, backward_h]) # 은닉 상태 state_c = Concatenate()([forward_c, backward_c]) # 셀 상태 어텐션 메커니즘에서는 은닉 상태를 사용합니다. 이를 입력으로 컨텍스트 벡터(context vector)를 얻습니다. attention = BahdanauAttention(64) # 가중치 크기 정의 context_vector, attention_weights = attention(lstm, state_h) 컨텍스트 벡터를 밀집층(dense layer)에 통과시키고, 이진 분류이므로 최종 출력층에 1개의 뉴런을 배치하고, 활성화 함수로 시그모이드 함수를 사용합니다. dense1 = Dense(20, activation="relu")(context_vector) dropout = Dropout(0.5)(dense1) output = Dense(1, activation="sigmoid")(dropout) model = Model(inputs=sequence_input, outputs=output) 옵티마이저로 아담 옵티마이저 사용하고, 모델을 컴파일합니다. model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) 시그모이드 함수를 사용하므로 손실 함수로 binary_crossentropy를 사용하였습니다. 이제 모델을 훈련하겠습니다. history = model.fit(X_train, y_train, epochs = 3, batch_size = 256, validation_data=(X_test, y_test), verbose=1) 검증 데이터로 테스트 데이터를 사용하여 에포크가 끝날 때마다 테스트 데이터에 대한 정확도를 출력하도록 하였습니다. Train on 25000 samples, validate on 25000 samples Epoch 1/3 25000/25000 [==============================] - 566s 23ms/sample - loss: 0.4941 - accuracy: 0.7570 - val_loss: 0.3110 - val_accuracy: 0.8721 Epoch 2/3 25000/25000 [==============================] - 541s 22ms/sample - loss: 0.2530 - accuracy: 0.9074 - val_loss: 0.2852 - val_accuracy: 0.8835 Epoch 3/3 25000/25000 [==============================] - 543s 22ms/sample - loss: 0.1901 - accuracy: 0.9352 - val_loss: 0.3375 - val_accuracy: 0.8793 print("\n 테스트 정확도: %.4f" % (model.evaluate(X_test, y_test)[1])) 25000/25000 [============================] - 183s 7ms/sample - loss: 0.1901 - acc: 0.8793 테스트 정확도: 0.8793 87.93%의 정확도를 얻습니다. 16. 트랜스포머(Transformer) 이번 트랜스포머 챕터에서는 seq2seq의 단점을 개선하면서도 여전히 인코더-디코더 구조를 유지하고 있는 트랜스포머 모델을 통해 챗봇을 구현해 보도록 하겠습니다. 16-01 트랜스포머(Transformer) 이번 챕터는 앞서 설명한 어텐션 메커니즘 챕터에 대한 사전 이해가 필요합니다. 트랜스포머(Transformer)는 2017년 구글이 발표한 논문인 "Attention is all you need"에서 나온 모델로 기존의 seq2seq의 구조인 인코더-디코더를 따르면서도, 논문의 이름처럼 어텐션(Attention) 만으로 구현한 모델입니다. 이 모델은 RNN을 사용하지 않고, 인코더-디코더 구조를 설계하였음에도 번역 성능에서도 RNN보다 우수한 성능을 보여주었습니다. 당장 구현에 관심이 없다면 코드 부분만 스킵 해서 이론만 읽으셔도 됩니다. 트랜스포머 전체 코드는 아래의 링크에 공유합니다. 깃허브 링크 : https://github.com/ukairia777/tensorflow-transformer import numpy as np import matplotlib.pyplot as plt import tensorflow as tf 1. 기존의 seq2seq 모델의 한계 트랜스포머에 대해서 배우기 전에 기존의 seq2seq를 상기해 봅시다. 기존의 seq2seq 모델은 인코더-디코더 구조로 구성돼 있었습니다. 여기서 인코더는 입력 시퀀스를 하나의 벡터 표현으로 압축하고, 디코더는 이 벡터 표현을 통해서 출력 시퀀스를 만들어냈습니다. 하지만 이러한 구조는 인코더가 입력 시퀀스를 하나의 벡터로 압축하는 과정에서 입력 시퀀스의 정보가 일부 손실된다는 단점이 있었고, 이를 보정하기 위해 어텐션이 사용되었습니다. 그런데 어텐션을 RNN의 보정을 위한 용도로서 사용하는 것이 아니라 어텐션만으로 인코더와 디코더를 만들어보면 어떨까요? 2. 트랜스포머(Transformer)의 주요 하이퍼 파라미터 시작에 앞서 트랜스포머의 하이퍼 파라미터를 정의합니다. 각 하이퍼 파라미터의 의미에 대해서는 뒤에서 설명하기로 하고, 여기서는 트랜스포머에는 이러한 하이퍼 파라미터가 존재한다는 정도로만 이해해 보겠습니다. 아래에서 정의하는 수치는 트랜스포머를 제안한 논문에서 사용한 수치로 하이퍼 파라미터는 사용자가 모델 설계 시 임의로 변경할 수 있는 값들입니다. m d l 512 트랜스포머의 인코더와 디코더에서의 정해진 입력과 출력의 크기를 의미합니다. 임베딩 벡터의 차원 또한 m d l 이며, 각 인코더와 디코더가 다음 층의 인코더와 디코더로 값을 보낼 때에도 이 차원을 유지합니다. 논문에서는 512입니다. num_layers 6 트랜스포머에서 하나의 인코더와 디코더를 층으로 생각하였을 때, 트랜스포머 모델에서 인코더와 디코더가 총 몇 층으로 구성되었는지를 의미합니다. 논문에서는 인코더와 디코더를 각각 총 6개 쌓았습니다. num_heads 8 트랜스포머에서는 어텐션을 사용할 때, 한 번 하는 것보다 여러 개로 분할해서 병렬로 어텐션을 수행하고 결괏값을 다시 하나로 합치는 방식을 택했습니다. 이때 이 병렬의 개수를 의미합니다. f = 2048 트랜스포머 내부에는 피드 포워드 신경망이 존재하며 해당 신경망의 은닉층의 크기를 의미합니다. 피드 포워드 신경망의 입력층과 출력층의 크기는 m d l 입니다. 3. 트랜스포머(Transformer) 트랜스포머는 RNN을 사용하지 않지만 기존의 seq2seq처럼 인코더에서 입력 시퀀스를 입력받고, 디코더에서 출력 시퀀스를 출력하는 인코더-디코더 구조를 유지하고 있습니다. 이전 seq2seq 구조에서는 인코더와 디코더에서 각각 하나의 RNN이 t 개의 시점(time step)을 가지는 구조였다면 이번에는 인코더와 디코더라는 단위가 N 개로 구성되는 구조입니다. 트랜스포머를 제안한 논문에서는 인코더와 디코더의 개수를 각각 6개 사용하였습니다. 위의 그림은 인코더와 디코더가 6개씩 존재하는 트랜스포머의 구조를 보여줍니다. 이 책에서는 인코더와 디코더가 각각 여러 개 쌓여있다는 의미를 사용할 때는 알파벳 s를 뒤에 붙여 encoders, decoders라고 표현하겠습니다. 위의 그림은 인코더로부터 정보를 전달받아 디코더가 출력 결과를 만들어내는 트랜스포머 구조를 보여줍니다. 디코더는 마치 기존의 seq2seq 구조처럼 시작 심벌 <sos>를 입력으로 받아 종료 심벌 <eos>가 나올 때까지 연산을 진행합니다. 이는 RNN은 사용되지 않지만 여전히 인코더-디코더의 구조는 유지되고 있음을 보여줍니다. 트랜스포머의 내부 구조를 조금씩 확대해가는 방식으로 트랜스포머를 이해해 봅시다. 우선 인코더와 디코더의 구조를 이해하기 전에 트랜스포머의 입력에 대해서 이해해 보겠습니다. 트랜스포머의 인코더와 디코더는 단순히 각 단어의 임베딩 벡터들을 입력받는 것이 아니라 임베딩 벡터에서 조정된 값을 입력받는데 이에 대해서 알아보기 위해 입력 부분을 확대해 보겠습니다. 4. 포지셔널 인코딩(Positional Encoding) 트랜스포머의 내부를 이해하기 전 우선 트랜스포머의 입력에 대해서 알아보겠습니다. RNN이 자연어 처리에서 유용했던 이유는 단어의 위치에 따라 단어를 순차적으로 입력받아서 처리하는 RNN의 특성으로 인해 각 단어의 위치 정보(position information)를 가질 수 있다는 점에 있었습니다. 하지만 트랜스포머는 단어 입력을 순차적으로 받는 방식이 아니므로 단어의 위치 정보를 다른 방식으로 알려줄 필요가 있습니다. 트랜스포머는 단어의 위치 정보를 얻기 위해서 각 단어의 임베딩 벡터에 위치 정보들을 더하여 모델의 입력으로 사용하는데, 이를 포지셔널 인코딩(positional encoding)이라고 합니다. 위의 그림은 입력으로 사용되는 임베딩 벡터들이 트랜스포머의 입력으로 사용되기 전에 포지셔널 인코딩의 값이 더해지는 것을 보여줍니다. 임베딩 벡터가 인코더의 입력으로 사용되기 전 포지셔널 인코딩 값이 더해지는 과정을 시각화하면 아래와 같습니다. 포지셔널 인코딩 값들은 어떤 값이기에 위치 정보를 반영해 줄 수 있는 것일까요? 트랜스포머는 위치 정보를 가진 값을 만들기 위해서 아래의 두 개의 함수를 사용합니다. E ( o , 2 ) s n ( o / 10000 i d o e) E ( o , 2 + ) c s ( o / 10000 i d o e) 사인 함수와 코사인 함수의 그래프를 상기해 보면 요동치는 값의 형태를 생각해 볼 수 있는데, 트랜스포머는 사인 함수와 코사인 함수의 값을 임베딩 벡터에 더해주므로서 단어의 순서 정보를 더하여 줍니다. 그런데 위의 두 함수에는 o, , m d l 등의 생소한 변수들이 있습니다. 위의 함수를 이해하기 위해서는 위에서 본 임베딩 벡터와 포지셔널 인코딩의 덧셈은 사실 임베딩 벡터가 모여 만들어진 문장 행렬과 포지셔널 인코딩 행렬의 덧셈 연산을 통해 이루어진다는 점을 이해해야 합니다. o는 입력 문장에서의 임베딩 벡터의 위치를 나타내며,는 임베딩 벡터 내의 차원의 인덱스를 의미합니다. 위의 식에 따르면 임베딩 벡터 내의 각 차원의 인덱스가 짝수인 경우에는 사인 함수의 값을 사용하고 홀수인 경우에는 코사인 함수의 값을 사용합니다. 위의 수식에서 ( o , 2 ) 일 때는 사인 함수를 사용하고, ( o , 2 + ) 일 때는 코사인 함수를 사용하고 있음을 주목합시다. 또한 위의 식에서 m d l 은 트랜스포머의 모든 층의 출력 차원을 의미하는 트랜스포머의 하이퍼 파라미터입니다. 앞으로 보게 될 트랜스포머의 각종 구조에서 m d l 의 값이 계속해서 등장하는 이유입니다. 임베딩 벡터 또한 m d l 의 차원을 가지는데 위의 그림에서는 마치 4로 표현되었지만 실제 논문에서는 512의 값을 가집니다. 위와 같은 포지셔널 인코딩 방법을 사용하면 순서 정보가 보존되는데, 예를 들어 각 임베딩 벡터에 포지셔널 인코딩의 값을 더하면 같은 단어라고 하더라도 문장 내의 위치에 따라서 트랜스포머의 입력으로 들어가는 임베딩 벡터의 값이 달라집니다. 이에 따라 트랜스포머의 입력은 순서 정보가 고려된 임베딩 벡터가 됩니다. 이를 코드로 구현하면 아래와 같습니다. class PositionalEncoding(tf.keras.layers.Layer): def __init__(self, position, d_model): super(PositionalEncoding, self).__init__() self.pos_encoding = self.positional_encoding(position, d_model) def get_angles(self, position, i, d_model): angles = 1 / tf.pow(10000, (2 * (i // 2)) / tf.cast(d_model, tf.float32)) return position * angles def positional_encoding(self, position, d_model): angle_rads = self.get_angles( position=tf.range(position, dtype=tf.float32)[:, tf.newaxis], i=tf.range(d_model, dtype=tf.float32)[tf.newaxis, :], d_model=d_model) # 배열의 짝수 인덱스(2i)에는 사인 함수 적용 sines = tf.math.sin(angle_rads[:, 0::2]) # 배열의 홀수 인덱스(2i+1)에는 코사인 함수 적용 cosines = tf.math.cos(angle_rads[:, 1::2]) angle_rads = np.zeros(angle_rads.shape) angle_rads[:, 0::2] = sines angle_rads[:, 1::2] = cosines pos_encoding = tf.constant(angle_rads) pos_encoding = pos_encoding[tf.newaxis, ...] print(pos_encoding.shape) return tf.cast(pos_encoding, tf.float32) def call(self, inputs): return inputs + self.pos_encoding[:, :tf.shape(inputs)[1], :] 50 × 128의 크기를 가지는 포지셔널 인코딩 행렬을 시각화하여 어떤 형태를 가지는지 확인해 봅시다. 이는 입력 문장의 단어가 50개이면서, 각 단어가 128차원의 임베딩 벡터를 가질 때 사용할 수 있는 행렬입니다. # 문장의 길이 50, 임베딩 벡터의 차원 128 sample_pos_encoding = PositionalEncoding(50, 128) plt.pcolormesh(sample_pos_encoding.pos_encoding.numpy()[0], cmap='RdBu') plt.xlabel('Depth') plt.xlim((0, 128)) plt.ylabel('Position') plt.colorbar() plt.show() (1, 50, 128) 5. 어텐션(Attention) 트랜스포머에서 사용되는 세 가지의 어텐션에 대해서 간단히 정리해 봅시다. 지금은 큰 그림을 이해하는 것에만 집중합니다. 첫 번째 그림인 셀프 어텐션은 인코더에서 이루어지지만, 두 번째 그림인 셀프 어텐션과 세 번째 그림인 인코더-디코더 어텐션은 디코더에서 이루어집니다. 셀프 어텐션은 본질적으로 Query, Key, Value가 동일한 경우를 말합니다. 반면, 세 번째 그림 인코더-디코더 어텐션에서는 Query가 디코더의 벡터인 반면에 Key와 Value가 인코더의 벡터이므로 셀프 어텐션이라고 부르지 않습니다. 주의할 점은 여기서 Query, Key 등이 같다는 것은 벡터의 값이 같다는 것이 아니라 벡터의 출처가 같다는 의미입니다. 정리하면 다음과 같습니다. 인코더의 셀프 어텐션 : Query = Key = Value 디코더의 마스크 드 셀프 어텐션 : Query = Key = Value 디코더의 인코더-디코더 어텐션 : Query : 디코더 벡터 / Key = Value : 인코더 벡터 위 그림은 트랜스포머의 아키텍처에서 세 가지 어텐션이 각각 어디에서 이루어지는지를 보여줍니다. 세 개의 어텐션에 추가적으로 '멀티 헤드'라는 이름이 붙어있습니다. 뒤에서 설명하겠지만 트랜스포머가 어텐션을 병렬적으로 수행하는 방법을 의미합니다. 6. 인코더(Encoder) 인코더의 구조에 대해서 알아보겠습니다. 트랜스포머는 하이퍼 파라미터인 num_layers 개수의 인코더 층을 쌓습니다. 논문에서는 총 6개의 인코더 층을 사용하였습니다. 인코더를 하나의 층이라는 개념으로 생각한다면, 하나의 인코더 층은 크게 총 2개의 서브층(sublayer)으로 나누어집니다. 셀프 어텐션과 피드 포워드 신경망입니다. 위의 그림에서는 멀티 헤드 셀프 어텐션과 포지션 와이즈 피드 포워드 신경망이라고 적혀있지만, 멀티 헤드 셀프 어텐션은 셀프 어텐션을 병렬적으로 사용하였다는 의미고, 포지션 와이즈 피드 포워드 신경망은 우리가 알고 있는 일반적인 피드 포워드 신경망입니다. 우선 셀프 어텐션에 대해서 알아봅시다. 7. 인코더의 셀프 어텐션 트랜스포머에서는 셀프 어텐션이라는 어텐션 기법이 등장하는데 앞서 배웠던 어텐션 함수에 대해서 복습하고, 셀프 어텐션이 앞서 배웠던 어텐션과 무엇이 다른지 이해해 보겠습니다. 1) 셀프 어텐션의 의미와 이점 어텐션 함수는 주어진 '쿼리(Query)'에 대해서 모든 '키(Key)'와의 유사도를 각각 구합니다. 그리고 구해낸 이 유사도를 가중치로 하여 키와 매핑되어있는 각각의 '값(Value)'에 반영해 줍니다. 그리고 유사도가 반영된 '값(Value)'을 모두 가중 합하여 리턴합니다. 여기까지는 앞서 배운 어텐션의 개념입니다. 그런데 어텐션 중에서는 셀프 어텐션(self-attention)이라는 것이 있습니다. 어텐션을 자기 자신에게 수행한다는 의미입니다. 앞서 배운 seq2seq에서 어텐션을 사용할 경우의 Q, K, V의 정의를 다시 생각해 봅시다. Q = Query : t 시점의 디코더 셀에서의 은닉 상태 K = Keys : 모든 시점의 인코더 셀의 은닉 상태들 V = Values : 모든 시점의 인코더 셀의 은닉 상태들 사실 t 시점이라는 것은 계속 변화하면서 반복적으로 쿼리를 수행하므로 결국 전체 시점에 대해서 일반화를 할 수도 있습니다. Q = Querys : 모든 시점의 디코더 셀에서의 은닉 상태들 K = Keys : 모든 시점의 인코더 셀의 은닉 상태들 V = Values : 모든 시점의 인코더 셀의 은닉 상태들 이처럼 기존에는 디코더 셀의 은닉 상태가 Q이고 인코더 셀의 은닉 상태가 K라는 점에서 Q와 K가 서로 다른 값을 가지고 있었습니다. 그런데 셀프 어텐션에서는 Q, K, V가 전부 동일합니다. 트랜스포머의 셀프 어텐션에서의 Q, K, V는 아래와 같습니다. Q : 입력 문장의 모든 단어 벡터들 K : 입력 문장의 모든 단어 벡터들 V : 입력 문장의 모든 단어 벡터들 셀프 어텐션에 대한 구체적인 사항을 배우기 전에 셀프 어텐션을 통해 얻을 수 있는 대표적인 효과에 대해서 이해해 봅시다. 위의 그림은 트랜스포머에 대한 구글 AI 블로그 포스트에서 가져왔습니다. 위의 예시 문장을 번역하면 '그 동물은 길을 건너지 않았다. 왜냐하면 그것은 너무 피곤하였기 때문이다.'라는 의미가 됩니다. 그런데 여기서 그것(it)에 해당하는 것은 과연 길(street)일까요? 동물(animal)일까요? 우리는 피곤한 주체가 동물이라는 것을 아주 쉽게 알 수 있지만 기계는 그렇지 않습니다. 하지만 셀프 어텐션은 입력 문장 내의 단어들끼리 유사도를 구함으로써 그것(it)이 동물(animal)과 연관되었을 확률이 높다는 것을 찾아냅니다. 트랜스포머에서의 셀프 어텐션의 동작 메커니즘을 알아봅시다. 2) Q, K, V 벡터 얻기 앞서 셀프 어텐션은 입력 문장의 단어 벡터들을 가지고 수행한다고 하였는데, 사실 셀프 어텐션은 인코더의 초기 입력인 m d l 의 차원을 가지는 단어 벡터들을 사용하여 셀프 어텐션을 수행하는 것이 아니라 우선 각 단어 벡터들로부터 Q 벡터, K 벡터, V 벡터를 얻는 작업을 거칩니다. 이때 이 Q 벡터, K 벡터, V 벡터들은 초기 입력인 m d l 의 차원을 가지는 단어 벡터들보다 더 작은 차원을 가지는데, 논문에서는 m d l =512의 차원을 가졌던 각 단어 벡터들을 64의 차원을 가지는 Q 벡터, K 벡터, V 벡터로 변환하였습니다. 64라는 값은 트랜스포머의 또 다른 하이퍼 파라미터인 num_heads 로 인해 결정되는데, 트랜스포머는 m d l num_heads 로 나눈 값을 각 Q 벡터, K 벡터, V 벡터의 차원으로 결정합니다. 논문에서는 num_heads 를 8로 하였습니다. 그림을 통해 이해해 봅시다. 예를 들어 여기서 사용하고 있는 예문 중 student라는 단어 벡터를 Q, K, V의 벡터로 변환하는 과정을 보겠습니다. 기존의 벡터로부터 더 작은 벡터는 가중치 행렬을 곱함으로써 완성됩니다. 각 가중치 행렬은 m d l ( m d l /num_heads ) 의 크기를 가집니다. 이 가중치 행렬은 훈련 과정에서 학습됩니다. 즉, 논문과 같이 m d l =512이고 num_heads =8라면, 각 벡터에 3개의 서로 다른 가중치 행렬을 곱하고 64의 크기를 가지는 Q, K, V 벡터를 얻어냅니다. 위의 그림은 단어 벡터 중 student 벡터로부터 Q, K, V 벡터를 얻어내는 모습을 보여줍니다. 모든 단어 벡터에 위와 같은 과정을 거치면 I, am, a, student는 각각의 Q, K, V 벡터를 얻습니다. 3) 스케일드 닷-프로덕트 어텐션(Scaled dot-product Attention) Q, K, V 벡터를 얻었다면 지금부터는 기존에 배운 어텐션 메커니즘과 동일합니다. 각 Q 벡터는 모든 K 벡터에 대해서 어텐션 스코어를 구하고, 어텐션 분포를 구한 뒤에 이를 사용하여 모든 V 벡터를 가중 합하여 어텐션 값 또는 컨텍스트 벡터를 구하게 됩니다. 그리고 이를 모든 Q 벡터에 대해서 반복합니다. 그런데 앞서 어텐션 챕터에서 어텐션 함수의 종류는 다양하다고 언급한 바 있습니다. 트랜스포머에서는 어텐션 챕터에 사용했던 내적만을 사용하는 어텐션 함수 c r ( , ) q k 가 아니라 여기에 특정 값으로 나눠준 어텐션 함수인 c r ( , ) q k n 를 사용합니다. 이러한 함수를 사용하는 어텐션을 어텐션 챕터에서 배운 닷-프로덕트 어텐션(dot-product attention)에서 값을 스케일링하는 것을 추가하였다고 하여 스케일드 닷-프로덕트 어텐션(Scaled dot-product Attention)이라고 합니다. 그림을 통해 이해해 봅시다. 우선 단어 I에 대한 Q 벡터를 기준으로 설명해 보겠습니다. 지금부터 설명하는 과정은 am에 대한 Q 벡터, a에 대한 Q 벡터, student에 대한 Q 벡터에 대해서도 모두 동일한 과정을 거칩니다. 위의 그림은 단어 I에 대한 Q 벡터가 모든 K 벡터에 대해서 어텐션 스코어를 구하는 것을 보여줍니다. 위의 128과 32는 저자가 임의로 가정한 수치로 신경 쓰지 않아도 좋습니다. 위의 그림에서 어텐션 스코어는 각각 단어 I가 단어 I, am, a, student와 얼마나 연관되어 있는지를 보여주는 수치입니다. 트랜스포머에서는 두 벡터의 내적 값을 스케일링하는 값으로 K 벡터의 차원을 나타내는 k 에 루트를 씌운 k 사용하는 것을 택했습니다. 앞서 언급하였듯이 논문에서 k d o e /num_heads 라는 식에 따라서 64의 값을 가지므로 k 는 8의 값을 가집니다. 이제 어텐션 스코어에 소프트맥스 함수를 사용하여 어텐션 분포(Attention Distribution)을 구하고, 각 V 벡터와 가중 합하여 어텐션 값(Attention Value)을 구합니다. 이를 단어 I에 대한 어텐션 값 또는 단어 I에 대한 컨텍스트 벡터(context vector)라고도 할 수 있습니다. am에 대한 Q 벡터, a에 대 Q 벡터, student에 대한 Q 벡터에 대해서도 모두 동일한 과정을 반복하여 각각에 대한 어텐션 값을 구합니다. 그런데 한 가지 의문이 남습니다. 굳이 이렇게 각 Q 벡터마다 일일이 따로 연산할 필요가 있을까요? 4) 행렬 연산으로 일괄 처리하기 사실 각 단어에 대한 Q, K, V 벡터를 구하고 스케일드 닷-프로덕트 어텐션을 수행하였던 위의 과정들은 벡터 연산이 아니라 행렬 연산을 사용하면 일괄 계산이 가능합니다. 지금까지 벡터 연산으로 설명하였던 이유는 이해를 돕기 위한 과정이고, 실제로는 행렬 연산으로 구현됩니다. 위의 과정을 벡터가 아닌 행렬 연산으로 이해해 봅시다. 우선, 각 단어 벡터마다 일일이 가중치 행렬을 곱하는 것이 아니라 문장 행렬에 가중치 행렬을 곱하여 Q 행렬, K 행렬, V 행렬을 구합니다. 행렬 연산을 통해 어텐션 스코어는 어떻게 구할 수 있을까요? 여기서 Q 행렬을 K 행렬을 전치한 행렬과 곱해준다고 해봅시다. 이렇게 되면 각각의 단어의 Q 벡터와 K 벡터의 내적이 각 행렬의 원소가 되는 행렬이 결과로 나옵니다. 다시 말해 위의 그림의 결과 행렬의 값에 전체적으로 k 를 나누어주면 이는 각 행과 열이 어텐션 스코어 값을 가지는 행렬이 됩니다. 예를 들어 I 행과 student 열의 값은 I의 Q 벡터와 student의 K 벡터의 어텐션 스코어 값입니다. 위 행렬을 어텐션 스코어 행렬이라 합시다. 어텐션 스코어 행렬을 구하였다면 남은 것은 어텐션 분포를 구하고, 이를 사용하여 모든 단어에 대한 어텐션 값을 구하는 일입니다. 이는 간단하게 어텐션 스코어 행렬에 소프트맥스 함수를 사용하고, V 행렬을 곱하는 것으로 해결됩니다. 이렇게 되면 각 단어의 어텐션 값을 모두 가지는 어텐션 값 행렬이 결과로 나옵니다. 위의 그림은 행렬 연산을 통해 모든 값이 일괄 계산되는 과정을 식으로 보여줍니다. 해당 식은 실제 트랜스포머 논문에 기재된 아래의 수식과 정확하게 일치하는 식입니다. t e t o ( , , ) s f m x ( K d) 위의 행렬 연산에 사용된 행렬의 크기를 모두 정리해 봅시다. 우선 입력 문장의 길이를 seq_len이라고 해봅시다. 그렇다면 문장 행렬의 크기는 ( seq_len d o e) 입니다. 여기에 3개의 가중치 행렬을 곱해서 Q, K, V 행렬을 만들어야 합니다. 우선 행렬의 크기를 정의하기 위해 행렬의 각 행에 해당되는 Q 벡터와 K 벡터의 차원을 k 라고 하고, V 벡터의 차원을 v 라고 해봅시다. 그렇다면 Q 행렬과 K 행렬의 크기는 ( seq_len d) 이며, V 행렬의 크기는 ( seq_len d) 가 되어야 합니다. 그렇다면 문장 행렬과 Q, K, V 행렬의 크기로부터 가중치 행렬의 크기 추정이 가능합니다. Q W는 ( m d l d) 의 크기를 가지며, V ( m d l d) 의 크기를 가집니다. 단, 논문에서는 k d의 차원은 m d l /num_heads 와 같습니다. 즉, m d l /num_heads d = v 입니다. 결과적으로 o t a ( K d) 식을 적용하여 나오는 어텐션 값 행렬의 크기는 ( seq_len d) 이 됩니다. 코드로 작성하면 아래와 같습니다. 5) 스케일드 닷-프로덕트 어텐션 구현하기 def scaled_dot_product_attention(query, key, value, mask): # query 크기 : (batch_size, num_heads, query의 문장 길이, d_model/num_heads) # key 크기 : (batch_size, num_heads, key의 문장 길이, d_model/num_heads) # value 크기 : (batch_size, num_heads, value의 문장 길이, d_model/num_heads) # padding_mask : (batch_size, 1, 1, key의 문장 길이) # Q와 K의 곱. 어텐션 스코어 행렬. matmul_qk = tf.matmul(query, key, transpose_b=True) # 스케일링 # dk의 루트 값으로 나눠준다. depth = tf.cast(tf.shape(key)[-1], tf.float32) logits = matmul_qk / tf.math.sqrt(depth) # 마스킹. 어텐션 스코어 행렬의 마스킹 할 위치에 매우 작은 음수 값을 넣는다. # 매우 작은 값이므로 소프트맥스 함수를 지나면 행렬의 해당 위치의 값은 0이 된다. if mask is not None: logits += (mask * -1e9) # 소프트맥스 함수는 마지막 차원인 key의 문장 길이 방향으로 수행된다. # attention weight : (batch_size, num_heads, query의 문장 길이, key의 문장 길이) attention_weights = tf.nn.softmax(logits, axis=-1) # output : (batch_size, num_heads, query의 문장 길이, d_model/num_heads) output = tf.matmul(attention_weights, value) return output, attention_weights Q 행렬과 K 행렬을 전치한 행렬을 곱하고, 소프트맥스 함수를 사용하여 어텐션 분포 행렬을 얻은 뒤에 V 행렬과 곱합니다. 코드에서 mask가 사용되는 if 문은 아직 배우지 않은 내용으로 지금은 무시합니다. scaled_dot_product_attention 함수가 정상 작동하는지 테스트를 해보겠습니다. 우선 temp_q, temp_k, temp_v라는 임의의 Query, Key, Value 행렬을 만들고, 이를 scaled_dot_product_attention 함수에 입력으로 넣어 함수가 리턴하는 값을 출력해 보겠습니다. # 임의의 Query, Key, Value인 Q, K, V 행렬 생성 np.set_printoptions(suppress=True) temp_k = tf.constant([[10,0,0], [0,10,0], [0,0,10], [0,0,10]], dtype=tf.float32) # (4, 3) temp_v = tf.constant([[ 1,0], [ 10,0], [ 100,5], [1000,6]], dtype=tf.float32) # (4, 2) temp_q = tf.constant([[0, 10, 0]], dtype=tf.float32) # (1, 3) 여기서 주목할 점은 Query에 해당하는 temp_q의 값 [0, 10, 0]은 Key에 해당하는 temp_k의 두 번째 값 [0, 10, 0]과 일치한다는 점입니다. 그렇다면 어텐션 분포와 어텐션 값은 과연 어떤 값이 나올까요? # 함수 실행 temp_out, temp_attn = scaled_dot_product_attention(temp_q, temp_k, temp_v, None) print(temp_attn) # 어텐션 분포(어텐션 가중치의 나열) print(temp_out) # 어텐션 값 tf.Tensor([[0. 1. 0. 0.]], shape=(1, 4), dtype=float32) tf.Tensor([[10. 0.]], shape=(1, 2), dtype=float32) Query는 4개의 Key 값 중 두 번째 값과 일치하므로 어텐션 분포는 [0, 1, 0, 0]의 값을 가지며 결과적으로 Value의 두 번째 값인 [10, 0]이 출력되는 것을 확인할 수 있습니다. 이번에는 Query의 값만 다른 값으로 바꿔보고 함수를 실행해 봅시다. 이번에 사용할 Query 값 [0, 0, 10]은 Key의 세 번째 값과, 네 번째 값 두 개의 값 모두와 일치하는 값입니다. temp_q = tf.constant([[0, 0, 10]], dtype=tf.float32) temp_out, temp_attn = scaled_dot_product_attention(temp_q, temp_k, temp_v, None) print(temp_attn) # 어텐션 분포(어텐션 가중치의 나열) print(temp_out) # 어텐션 값 tf.Tensor([[0. 0. 0.5 0.5]], shape=(1, 4), dtype=float32) tf.Tensor([[550. 5.5]], shape=(1, 2), dtype=float32) Query의 값은 Key의 세 번째 값과 네 번째 값 두 개의 값과 모두 유사하다는 의미에서 어텐션 분포는 [0, 0, 0.5, 0.5]의 값을 가집니다. 결과적으로 나오는 값 [550, 5.5]는 Value의 세 번째 값 [100, 5]에 0.5를 곱한 값과 네 번째 값 [1000, 6]에 0.5를 곱한 값의 원소별 합입니다. 이번에는 하나가 아닌 3개의 Query의 값을 함수의 입력으로 사용해 보겠습니다. temp_q = tf.constant([[0, 0, 10], [0, 10, 0], [10, 10, 0]], dtype=tf.float32) # (3, 3) temp_out, temp_attn = scaled_dot_product_attention(temp_q, temp_k, temp_v, None) print(temp_attn) # 어텐션 분포(어텐션 가중치의 나열) print(temp_out) # 어텐션 값 tf.Tensor( [[0. 0. 0.5 0.5] [0. 1. 0. 0. ] [0.5 0.5 0. 0. ]], shape=(3, 4), dtype=float32) tf.Tensor( [[550. 5.5] [ 10. 0. ] [ 5.5 0. ]], shape=(3, 2), dtype=float32) 6) 멀티 헤드 어텐션(Multi-head Attention) 앞서 배운 어텐션에서는 m d l 의 차원을 가진 단어 벡터를 num_heads 로 나눈 차원을 가지는 Q, K, V 벡터로 바꾸고 어텐션을 수행하였습니다. 논문 기준으로는 512의 차원의 각 단어 벡터를 8로 나누어 64차원의 Q, K, V 벡터로 바꾸어서 어텐션을 수행한 셈인데, 이제 num_heads 의 의미와 왜 m d l 의 차원을 가진 단어 벡터를 가지고 어텐션을 하지 않고 차원을 축소시킨 벡터로 어텐션을 수행하였는지 이해해 보겠습니다. 트랜스포머 연구진은 한 번의 어텐션을 하는 것보다 여러 번의 어텐션을 병렬로 사용하는 것이 더 효과적이라고 판단하였습니다. 그래서 m d l 의 차원을 num_heads 개로 나누어 m d l /num_heads 의 차원을 가지는 Q, K, V에 대해서 num_heads 개의 병렬 어텐션을 수행합니다. 논문에서는 하이퍼 파라미터인 num_heads 의 값을 8로 지정하였고, 8개의 병렬 어텐션이 이루어지게 됩니다. 다시 말해 위에서 설명한 어텐션이 8개로 병렬로 이루어지게 되는데, 이때 각각의 어텐션 값 행렬을 어텐션 헤드라고 부릅니다. 이때 가중치 행렬 Q W, V 의 값은 8개의 어텐션 헤드마다 전부 다릅니다. 병렬 어텐션으로 얻을 수 있는 효과는 무엇일까요? 그리스 로마신화에는 머리가 여러 개인 괴물 히드라나 케로베로스가 나옵니다. 이 괴물들의 특징은 머리가 여러 개이기 때문에 여러 시점에서 상대방을 볼 수 있다는 겁니다. 이렇게 되면 시각에서 놓치는 게 별로 없을 테니까 이런 괴물들에게 기습을 하는 것이 굉장히 힘이 들 겁니다. 멀티 헤드 어텐션도 똑같습니다. 어텐션을 병렬로 수행하여 다른 시각으로 정보들을 수집하겠다는 겁니다. 예를 들어보겠습니다. 앞서 사용한 예문 '그 동물은 길을 건너지 않았다. 왜냐하면 그것은 너무 피곤하였기 때문이다.'를 상기해 봅시다. 단어 그것(it)이 쿼리였다고 해봅시다. 즉, it에 대한 Q 벡터로부터 다른 단어와의 연관도를 구하였을 때 첫 번째 어텐션 헤드는 '그것(it)'과 '동물(animal)'의 연관도를 높게 본다면, 두 번째 어텐션 헤드는 '그것(it)'과 '피곤하였기 때문이다(tired)'의 연관도를 높게 볼 수 있습니다. 각 어텐션 헤드는 전부 다른 시각에서 보고 있기 때문입니다. 병렬 어텐션을 모두 수행하였다면 모든 어텐션 헤드를 연결(concatenate) 합니다. 모두 연결된 어텐션 헤드 행렬의 크기는 ( seq_len d o e) 가 됩니다. 지금까지 그림에서는 책의 지면 상의 한계로 4차원을 m d l =512로 표현하고, 2차원을 v =64로 표현해왔기 때문에 위의 그림의 행렬의 크기에 혼동의 있을 수 있으나 8개의 어텐션 헤드의 연결(concatenate) 과정의 이해를 위해 이번 행렬만 예외로 위와 같이 m d l 의 크기를 v 의 8배인 16차원으로 표현하였습니다. 아래의 그림에서는 다시 m d l 를 4차원으로 표현합니다. 어텐션 헤드를 모두 연결한 행렬은 또 다른 가중치 행렬 o 을 곱하게 되는데, 이렇게 나온 결과 행렬이 멀티-헤드 어텐션의 최종 결과물입니다. 위의 그림은 어텐션 헤드를 모두 연결한 행렬이 가중치 행렬 o 과 곱해지는 과정을 보여줍니다. 이때 결과물인 멀티-헤드 어텐션 행렬은 인코더의 입력이었던 문장 행렬의 ( seq_len d o e) 크기와 동일합니다. 다시 말해 인코더의 첫 번째 서브층인 멀티-헤드 어텐션 단계를 끝마쳤을 때, 인코더의 입력으로 들어왔던 행렬의 크기가 아직 유지되고 있음을 기억해둡시다. 첫 번째 서브층인 멀티-헤드 어텐션과 두 번째 서브층인 포지션 와이즈 피드 포워드 신경망을 지나면서 인코더의 입력으로 들어올 때의 행렬의 크기는 계속 유지되어야 합니다. 트랜스포머는 동일한 구조의 인코더를 쌓은 구조입니다. 논문 기준으로는 인코더가 총 6개입니다. 인코더에서의 입력의 크기가 출력에서도 동일 크기로 계속 유지되어야만 다음 인코더에서도 다시 입력이 될 수 있습니다. 7) 멀티 헤드 어텐션(Multi-head Attention) 구현하기 멀티 헤드 어텐션에서는 크게 두 종류의 가중치 행렬이 나왔습니다. Q, K, V 행렬을 만들기 위한 가중치 행렬인 WQ, WK, WV 행렬과 바로 어텐션 헤드들을 연결(concatenation) 후에 곱해주는 WO 행렬입니다. 가중치 행렬을 곱하는 것을 구현 상에서는 입력을 전결합층. 즉, 밀집층(Dense layer)을 지나게 하여 구현합니다. 케라스 코드 상으로 지금까지 사용해왔던 Dense()에 해당됩니다. Dense(units) 멀티 헤드 어텐션의 구현은 크게 다섯 가지 파트로 구성됩니다. WQ, WK, WV에 해당하는 d_model 크기의 밀집층(Dense layer)을 지나게 한다. 지정된 헤드 수(num_heads) 만큼 나눈다(split). 스케일드 닷 프로덕트 어텐션. 나눠졌던 헤드들을 연결(concatenatetion) 한다. WO에 해당하는 밀집층을 지나게 한다. 이론으로 설명할 때보다 심플하게 구성되었는데 결국 근본적으로 동일한 내용입니다. class MultiHeadAttention(tf.keras.layers.Layer): def __init__(self, d_model, num_heads, name="multi_head_attention"): super(MultiHeadAttention, self).__init__(name=name) self.num_heads = num_heads self.d_model = d_model assert d_model % self.num_heads == 0 # d_model을 num_heads로 나눈 값. # 논문 기준 : 64 self.depth = d_model // self.num_heads # WQ, WK, WV에 해당하는 밀집층 정의 self.query_dense = tf.keras.layers.Dense(units=d_model) self.key_dense = tf.keras.layers.Dense(units=d_model) self.value_dense = tf.keras.layers.Dense(units=d_model) # WO에 해당하는 밀집층 정의 self.dense = tf.keras.layers.Dense(units=d_model) # num_heads 개수만큼 q, k, v를 split 하는 함수 def split_heads(self, inputs, batch_size): inputs = tf.reshape( inputs, shape=(batch_size, -1, self.num_heads, self.depth)) return tf.transpose(inputs, perm=[0, 2, 1, 3]) def call(self, inputs): query, key, value, mask = inputs['query'], inputs['key'], inputs[ 'value'], inputs['mask'] batch_size = tf.shape(query)[0] # 1. WQ, WK, WV에 해당하는 밀집층 지나기 # q : (batch_size, query의 문장 길이, d_model) # k : (batch_size, key의 문장 길이, d_model) # v : (batch_size, value의 문장 길이, d_model) # 참고) 인코더(k, v)-디코더(q) 어텐션에서는 query 길이와 key, value의 길이는 다를 수 있다. query = self.query_dense(query) key = self.key_dense(key) value = self.value_dense(value) # 2. 헤드 나누기 # q : (batch_size, num_heads, query의 문장 길이, d_model/num_heads) # k : (batch_size, num_heads, key의 문장 길이, d_model/num_heads) # v : (batch_size, num_heads, value의 문장 길이, d_model/num_heads) query = self.split_heads(query, batch_size) key = self.split_heads(key, batch_size) value = self.split_heads(value, batch_size) # 3. 스케일드 닷 프로덕트 어텐션. 앞서 구현한 함수 사용. # (batch_size, num_heads, query의 문장 길이, d_model/num_heads) scaled_attention, _ = scaled_dot_product_attention(query, key, value, mask) # (batch_size, query의 문장 길이, num_heads, d_model/num_heads) scaled_attention = tf.transpose(scaled_attention, perm=[0, 2, 1, 3]) # 4. 헤드 연결(concatenate) 하기 # (batch_size, query의 문장 길이, d_model) concat_attention = tf.reshape(scaled_attention, (batch_size, -1, self.d_model)) # 5. WO에 해당하는 밀집층 지나기 # (batch_size, query의 문장 길이, d_model) outputs = self.dense(concat_attention) return outputs 멀티 헤드 어텐션 함수를 구현해 보았습니다. 한 가지만 더 설명하고, 두 번째 서브층에 대한 설명으로 넘어가 봅시다. 8) 패딩 마스크(Padding Mask) 아직 설명하지 않은 내용이 있습니다. 앞서 구현한 스케일드 닷 프로덕트 어텐션 함수 내부를 보면 mask라는 값을 인자로 받아서, 이 mask 값에다가 -1e9라는 아주 작은 음수 값을 곱한 후 어텐션 스코어 행렬에 더해주고 있습니다. 이 연산의 정체는 무엇일까요? def scaled_dot_product_attention(query, key, value, mask): ... 중략 ... logits += (mask * -1e9) # 어텐션 스코어 행렬인 logits에 mask*-1e9 값을 더해주고 있다. ... 중략 ... 이는 입력 문장에 <PAD> 토큰이 있을 경우 어텐션에서 사실상 제외하기 위한 연산입니다. 예를 들어 <PAD>가 포함된 입력 문장의 셀프 어텐션의 예제를 봅시다. 이에 대해서 어텐션을 수행하고 어텐션 스코어 행렬을 얻는 과정은 다음과 같습니다. 그런데 사실 단어 <PAD>의 경우에는 실질적인 의미를 가진 단어가 아닙니다. 그래서 트랜스포머에서는 Key의 경우에 <PAD> 토큰이 존재한다면 이에 대해서는 유사도를 구하지 않도록 마스킹(Masking)을 해주기로 했습니다. 여기서 마스킹이란 어텐션에서 제외하기 위해 값을 가린다는 의미입니다. 어텐션 스코어 행렬에서 행에 해당하는 문장은 Query이고, 열에 해당하는 문장은 Key입니다. 그리고 Key에 <PAD>가 있는 경우에는 해당 열 전체를 마스킹을 해줍니다. 마스킹을 하는 방법은 어텐션 스코어 행렬의 마스킹 위치에 매우 작은 음수 값을 넣어주는 것입니다. 여기서 매우 작은 음수 값이라는 것은 -1,000,000,000과 같은 -무한대에 가까운 수라는 의미입니다. 현재 어텐션 스코어 함수는 소프트맥스 함수를 지나지 않은 상태입니다. 앞서 배운 연산 순서라면 어텐션 스코어 함수는 소프트맥스 함수를 지나고, 그 후 Value 행렬과 곱해지게 됩니다. 그런데 현재 마스킹 위치에 매우 작은 음수 값이 들어가 있으므로 어텐션 스코어 행렬이 소프트맥스 함수를 지난 후에는 해당 위치의 값은 0이 되어 단어 간 유사도를 구하는 일에 <PAD> 토큰이 반영되지 않게 됩니다. 위 그림은 소프트맥스 함수를 지난 후를 가정하고 있습니다. 소프트맥스 함수를 지나면 각 행의 어텐션 가중치의 총합은 1이 되는데, 단어 <PAD>의 경우에는 0이 되어 어떤 유의미한 값을 가지고 있지 않습니다. 패딩 마스크를 구현하는 방법은 입력된 정수 시퀀스에서 패딩 토큰의 인덱스인지, 아닌지를 판별하는 함수를 구현하는 것입니다. 아래의 함수는 정수 시퀀스에서 0인 경우에는 1로 변환하고, 그렇지 않은 경우에는 0으로 변환하는 함수입니다. def create_padding_mask(x): mask = tf.cast(tf.math.equal(x, 0), tf.float32) # (batch_size, 1, 1, key의 문장 길이) return mask[:, tf.newaxis, tf.newaxis, :] 임의의 정수 시퀀스 입력을 넣어서 어떻게 변환되는지 보겠습니다. print(create_padding_mask(tf.constant([[1, 21, 777, 0, 0]]))) tf.Tensor([[[[0. 0. 0. 1. 1.]]]], shape=(1, 1, 1, 5), dtype=float32) 위 벡터를 통해서 1의 값을 가진 위치의 열을 어텐션 스코어 행렬에서 마스킹 하는 용도로 사용할 수 있습니다. 위 벡터를 스케일드 닷 프로덕트 어텐션의 인자로 전달하면, 스케일드 닷 프로덕트 어텐션에서는 위 벡터에다가 매우 작은 음수 값인 -1e9를 곱하고, 이를 행렬에 더해주어 해당 열을 전부 마스킹 합니다. 첫 번째 서브층인 멀티 헤드 어텐션을 구현해 보았습니다. 앞서 인코더는 두 개의 서브 서브층(sublayer)으로 나누어진다고 언급한 적이 있는데, 두 번째 서브층인 포지션-와이즈 피드 포워드 신경망에 대해서 알아보겠습니다. 8. 포지션-와이즈 피드 포워드 신경망(Position-wise FFNN) 지금은 인코더를 설명하고 있지만, 포지션 와이즈 FFNN은 인코더와 디코더에서 공통적으로 가지고 있는 서브층입니다. 포지션-와이즈 FFNN는 쉽게 말하면 완전 연결 FFNN(Fully-connected FFNN)이라고 해석할 수 있습니다. 앞서 인공 신경망은 결국 벡터와 행렬 연산으로 표현될 수 있음을 배웠습니다. 아래는 포지션 와이즈 FFNN의 수식을 보여줍니다. F N ( ) M X ( , W + 1 ) 2 b 식을 그림으로 표현하면 아래와 같습니다. 여기서는 앞서 멀티 헤드 어텐션의 결과로 나온 ( seq_len d o e) 의 크기를 가지는 행렬을 말합니다. 가중치 행렬 1 ( m d l d f ) 의 크기를 가지고, 가중치 행렬 2 ( f , d o e) 의 크기를 가집니다. 논문에서 은닉층의 크기인 f는 앞서 하이퍼 파라미터를 정의할 때 언급했듯이 2,048의 크기를 가집니다. 여기서 매개변수 1 b, 2 b는 하나의 인코더 층 내에서는 다른 문장, 다른 단어들마다 정확하게 동일하게 사용됩니다. 하지만 인코더 층마다는 다른 값을 가집니다. 위의 그림에서 좌측은 인코더의 입력을 벡터 단위로 봤을 때, 각 벡터들이 멀티 헤드 어텐션 층이라는 인코더 내 첫 번째 서브 층을 지나 FFNN을 통과하는 것을 보여줍니다. 이는 두 번째 서브층인 Position-wise FFNN을 의미합니다. 물론, 실제로는 그림의 우측과 같이 행렬로 연산되는데, 두 번째 서브층을 지난 인코더의 최종 출력은 여전히 인코더의 입력의 크기였던 ( seq_len d o e) 의 크기가 보존되고 있습니다. 하나의 인코더 층을 지난 이 행렬은 다음 인코더 층으로 전달되고, 다음 층에서도 동일한 인코더 연산이 반복됩니다. 이를 구현하면 다음과 같습니다. # 다음의 코드는 인코더와 디코더 내부에서 사용할 예정입니다. outputs = tf.keras.layers.Dense(units=dff, activation='relu')(attention) outputs = tf.keras.layers.Dense(units=d_model)(outputs) 9. 잔차 연결(Residual connection)과 층 정규화(Layer Normalization) 인코더의 두 개의 서브층에 대해서 이해하였다면 인코더에 대한 설명은 거의 끝났습니다! 트랜스포머에서는 이러한 두 개의 서브층을 가진 인코더에 추가적으로 사용하는 기법이 있는데, 바로 Add & Norm입니다. 더 정확히는 잔차 연결(residual connection)과 층 정규화(layer normalization)를 의미합니다. 위의 그림은 앞서 Position-wise FFNN를 설명할 때 사용한 앞선 그림에서 화살표와 Add & Norm(잔차 연결과 정규화 과정)을 추가한 그림입니다. 추가된 화살표들은 서브층 이전의 입력에서 시작되어 서브층의 출력 부분을 향하고 있는 것에 주목합시다. 추가된 화살표가 어떤 의미를 갖고 있는지는 잔차 연결과 층 정규화를 배우고 나면 이해할 수 있습니다. 1) 잔차 연결(Residual connection) 잔차 연결(residual connection)의 의미를 이해하기 위해서 어떤 함수 ( ) 에 대한 이야기를 해보겠습니다. 위 그림은 입력 와에 대한 어떤 함수 ( ) 의 값을 더한 함수 ( ) 의 구조를 보여줍니다. 어떤 함수 ( ) 가 트랜스포머에서는 서브층에 해당됩니다. 다시 말해 잔차 연결은 서브층의 입력과 출력을 더하는 것을 말합니다. 앞서 언급했듯이 트랜스포머에서 서브층의 입력과 출력은 동일한 차원을 갖고 있으므로, 서브층의 입력과 서브층의 출력은 덧셈 연산을 할 수 있습니다. 이것이 바로 위의 인코더 그림에서 각 화살표가 서브층의 입력에서 출력으로 향하도록 그려졌던 이유입니다. 잔차 연결은 컴퓨터 비전 분야에서 주로 사용되는 모델의 학습을 돕는 기법입니다. 이를 식으로 표현하면 + u l y r ( ) 입니다. 가령, 서브층이 멀티 헤드 어텐션이었다면 잔차 연결 연산은 다음과 같습니다. ( ) x M l i h a A t n i n ( ) 위 그림은 멀티 헤드 어텐션의 입력과 멀티 헤드 어텐션의 결과가 더해지는 과정을 보여줍니다. 관련 논문 : https://arxiv.org/pdf/1512.03385.pdf 2) 층 정규화(Layer Normalization) 잔차 연결을 거친 결과는 이어서 층 정규화 과정을 거치게 됩니다. 잔차 연결의 입력을, 잔차 연결과 층 정규화 두 가지 연산을 모두 수행한 후의 결과 행렬을 N 이라고 하였을 때, 잔차 연결 후 층 정규화 연산을 수식으로 표현하자면 다음과 같습니다. N L y r o m ( + u l y r ( ) ) 층 정규화를 하는 과정에 대해서 이해해 봅시다. 층 정규화는 텐서의 마지막 차원에 대해서 평균과 분산을 구하고, 이를 가지고 어떤 수식을 통해 값을 정규화하여 학습을 돕습니다. 여기서 텐서의 마지막 차원이란 것은 트랜스포머에서는 m d l 차원을 의미합니다. 아래 그림은 m d l 차원의 방향을 화살표로 표현하였습니다. 층 정규화를 위해서 우선, 화살표 방향으로 각각 평균과 분산 2 을 구합니다. 각 화살표 방향의 벡터를 i 라고 명명해 봅시다. 층 정규화를 수행한 후에는 벡터 i l i 라는 벡터로 정규화가 됩니다. n = a e N r ( i ) 층 정규화의 수식을 알아봅시다. 여기서는 층 정규화를 두 가지 과정으로 나누어서 설명하겠습니다. 첫 번째는 평균과 분산을 통한 정규화, 두 번째는 감마와 베타를 도입하는 것입니다. 우선, 평균과 분산을 통해 벡터 i 를 정규화 해줍니다. i 는 벡터인 반면, 평균 i 과 분산 i 은 스칼라입니다. 벡터 i 의 각 차원을라고 하였을 때, i k 는 다음의 수식과 같이 정규화 할 수 있습니다. 다시 말해 벡터 i 의 각 차원의 값이 다음과 같이 정규화 되는 것입니다. ^ , = i k μ σ 2 ϵ (입실론)은 분모가 0이 되는 것을 방지하는 값입니다. 이제 (감마)와 (베타)라는 벡터를 준비합니다. 단, 이들의 초깃값은 각각 1과 0입니다. 와를 도입한 층 정규화의 최종 수식은 다음과 같으며 와는 학습 가능한 파라미터입니다. n = x i β L y r o m ( i ) 관련 논문 : https://arxiv.org/pdf/1607.06450.pdf 케라스에서는 층 정규화를 위한 LayerNormalization()를 제공하고 있으므로 이를 가져와 사용합니다. 10. 인코더 구현하기 지금까지 배운 내용을 바탕으로 인코더를 구현한 코드는 다음과 같습니다. 인코더의 입력으로 들어가는 문장에는 패딩이 있을 수 있으므로, 어텐션 시 패딩 토큰을 제외하도록 패딩 마스크를 사용합니다. 이는 MultiHeadAttention 함수의 mask의 인자 값으로 padding_mask가 사용되는 이유입니다. 인코더는 총 두 개의 서브층으로 이루어지는데, 멀티 헤드 어텐션과 피드 포워드 신경망입니다. 각 서브층 이후에는 드롭아웃, 잔차 연결과 층 정규화가 수행됩니다. def encoder_layer(dff, d_model, num_heads, dropout, name="encoder_layer"): inputs = tf.keras.Input(shape=(None, d_model), name="inputs") # 인코더는 패딩 마스크 사용 padding_mask = tf.keras.Input(shape=(1, 1, None), name="padding_mask") # 멀티-헤드 어텐션 (첫 번째 서브층 / 셀프 어텐션) attention = MultiHeadAttention( d_model, num_heads, name="attention")({ 'query': inputs, 'key': inputs, 'value': inputs, # Q = K = V 'mask': padding_mask # 패딩 마스크 사용 }) # 드롭아웃 + 잔차 연결과 층 정규화 attention = tf.keras.layers.Dropout(rate=dropout)(attention) attention = tf.keras.layers.LayerNormalization( epsilon=1e-6)(inputs + attention) # 포지션 와이즈 피드 포워드 신경망 (두 번째 서브층) outputs = tf.keras.layers.Dense(units=dff, activation='relu')(attention) outputs = tf.keras.layers.Dense(units=d_model)(outputs) # 드롭아웃 + 잔차 연결과 층 정규화 outputs = tf.keras.layers.Dropout(rate=dropout)(outputs) outputs = tf.keras.layers.LayerNormalization( epsilon=1e-6)(attention + outputs) return tf.keras.Model( inputs=[inputs, padding_mask], outputs=outputs, name=name) 위 코드는 하나의 인코더 블록. 즉, 하나의 인코더 층을 구현하는 코드입니다. 실제로 트랜스포머는 num_layers 개수만큼의 인코더 층을 사용하므로 이를 여러 번 쌓는 코드를 별도 구현해 줄 필요가 있습니다. 11. 인코더 쌓기 지금까지 인코더 층의 내부 아키텍처에 대해서 이해해 보았습니다. 이러한 인코더 층을 num_layers 개만큼 쌓고, 마지막 인코더 층에서 얻는 (seq_len, d_model) 크기의 행렬을 디코더로 보내주므로서 트랜스포머 인코더의 인코딩 연산이 끝나게 됩니다. 아래의 코드는 인코더 층을 num_layers 개만큼 쌓는 코드입니다. def encoder(vocab_size, num_layers, dff, d_model, num_heads, dropout, name="encoder"): inputs = tf.keras.Input(shape=(None,), name="inputs") # 인코더는 패딩 마스크 사용 padding_mask = tf.keras.Input(shape=(1, 1, None), name="padding_mask") # 포지셔널 인코딩 + 드롭아웃 embeddings = tf.keras.layers.Embedding(vocab_size, d_model)(inputs) embeddings *= tf.math.sqrt(tf.cast(d_model, tf.float32)) embeddings = PositionalEncoding(vocab_size, d_model)(embeddings) outputs = tf.keras.layers.Dropout(rate=dropout)(embeddings) # 인코더를 num_layers 개 쌓기 for i in range(num_layers): outputs = encoder_layer(dff=dff, d_model=d_model, num_heads=num_heads, dropout=dropout, name="encoder_layer_{}".format(i), )([outputs, padding_mask]) return tf.keras.Model( inputs=[inputs, padding_mask], outputs=outputs, name=name) 12. 인코더에서 디코더로(From Encoder To Decoder) 지금까지 인코더에 대해서 정리해 보았습니다. 이렇게 구현된 인코더는 총 num_layers 만큼의 층 연산을 순차적으로 한 후에 마지막 층의 인코더의 출력을 디코더에게 전달합니다. 인코더 연산이 끝났으면 디코더 연산이 시작되어 디코더 또한 num_layers 만큼의 연산을 하는데, 이때마다 인코더가 보낸 출력을 각 디코더 층 연산에 사용합니다. 디코더에 대해서 이해해 봅시다. 13. 디코더의 첫 번째 서브층 : 셀프 어텐션과 룩-어헤드 마스크 위 그림과 같이 디코더도 인코더와 동일하게 임베딩 층과 포지셔널 인코딩을 거친 후의 문장 행렬이 입력됩니다. 트랜스포머 또한 seq2seq와 마찬가지로 교사 강요(Teacher Forcing)을 사용하여 훈련되므로 학습 과정에서 디코더는 번역할 문장에 해당되는 <sos> je suis étudiant의 문장 행렬을 한 번에 입력받습니다. 그리고 디코더는 이 문장 행렬로부터 각 시점의 단어를 예측하도록 훈련됩니다. 여기서 문제가 있습니다. seq2seq의 디코더에 사용되는 RNN 계열의 신경망은 입력 단어를 매 시점마다 순차적으로 입력받으므로 다음 단어 예측에 현재 시점을 포함한 이전 시점에 입력된 단어들만 참고할 수 있습니다. 반면, 트랜스포머는 문장 행렬로 입력을 한 번에 받으므로 현재 시점의 단어를 예측하고자 할 때, 입력 문장 행렬로부터 미래 시점의 단어까지도 참고할 수 있는 현상이 발생합니다. 가령, suis를 예측해야 하는 시점이라고 해봅시다. RNN 계열의 seq2seq의 디코더라면 현재까지 디코더에 입력된 단어는 <sos>와 je뿐일 것입니다. 반면, 트랜스포머는 이미 문장 행렬로 <sos> je suis étudiant를 입력받았습니다. 이를 위해 트랜스포머의 디코더에서는 현재 시점의 예측에서 현재 시점보다 미래에 있는 단어들을 참고하지 못하도록 룩-어헤드 마스크(look-ahead mask)를 도입했습니다. 직역하면 '미리 보기에 대한 마스크'입니다. 룩-어헤드 마스크(look-ahead mask)는 디코더의 첫 번째 서브층에서 이루어집니다. 디코더의 첫 번째 서브층인 멀티 헤드 셀프 어텐션 층은 인코더의 첫 번째 서브층인 멀티 헤드 셀프 어텐션 층과 동일한 연산을 수행합니다. 오직 다른 점은 어텐션 스코어 행렬에서 마스킹을 적용한다는 점만 다릅니다. 우선 다음과 같이 셀프 어텐션을 통해 어텐션 스코어 행렬을 얻습니다. 이제 자기 자신보다 미래에 있는 단어들은 참고하지 못하도록 다음과 같이 마스킹 합니다. 마스킹 된 후의 어텐션 스코어 행렬의 각 행을 보면 자기 자신과 그 이전 단어들만을 참고할 수 있음을 볼 수 있습니다. 그 외에는 근본적으로 셀프 어텐션이라는 점과, 멀티 헤드 어텐션을 수행한다는 점에서 인코더의 첫 번째 서브층과 같습니다. 룩-어헤드 마스크의 구현에 대해 알아봅시다. 룩-어헤드 마스크는 패딩 마스크와 마찬가지로 앞서 구현한 스케일드 닷 프로덕트 어텐션 함수에 mask라는 인자로 전달됩니다. 패딩 마스킹을 써야 하는 경우에는 스케일드 닷 프로덕트 어텐션 함수에 패딩 마스크를 전달하고, 룩-어헤드 마스킹을 써야 하는 경우에는 스케일드 닷 프로덕트 어텐션 함수에 룩-어헤드 마스크를 전달합니다. # 스케일드 닷 프로덕트 어텐션 함수를 다시 복습해 봅시다. def scaled_dot_product_attention(query, key, value, mask): ... 중략 ... logits += (mask * -1e9) # 어텐션 스코어 행렬인 logits에 mask*-1e9 값을 더해주고 있다. ... 중략 ... 트랜스포머에는 총 세 가지 어텐션이 존재하며, 모두 멀티 헤드 어텐션을 수행하고, 멀티 헤드 어텐션 함수 내부에서 스케일드 닷 프로덕트 어텐션 함수를 호출하는데 각 어텐션 시 함수에 전달하는 마스킹은 다음과 같습니다. 인코더의 셀프 어텐션 : 패딩 마스크를 전달 디코더의 첫 번째 서브층인 마스크 드 셀프 어텐션 : 룩-어헤드 마스크를 전달 <-- 지금 설명하고 있음. 디코더의 두 번째 서브층인 인코더-디코더 어텐션 : 패딩 마스크를 전달 이때 룩-어헤드 마스크를 한다고 해서 패딩 마스크가 불필요한 것이 아니므로 룩-어헤드 마스크는 패딩 마스크를 포함하도록 구현합니다. 룩-어헤드 마스크를 구현하는 방법은 패딩 마스크 때와 마찬가지로 마스킹을 하고자 하는 위치에는 1을, 마스킹을 하지 않는 위치에는 0을 리턴하도록 합니다. # 디코더의 첫 번째 서브층(sublayer)에서 미래 토큰을 Mask 하는 함수 def create_look_ahead_mask(x): seq_len = tf.shape(x)[1] look_ahead_mask = 1 - tf.linalg.band_part(tf.ones((seq_len, seq_len)), -1, 0) padding_mask = create_padding_mask(x) # 패딩 마스크도 포함 return tf.maximum(look_ahead_mask, padding_mask) 임의의 정수 시퀀스 입력을 넣어서 결과를 봅시다. 패딩 마스크를 테스트하기 위해 세 번째 위치에 정수 0을 넣었습니다. print(create_look_ahead_mask(tf.constant([[1, 2, 0, 4, 5]]))) tf.Tensor( [[[[0. 1. 1. 1. 1.] [0. 0. 1. 1. 1.] [0. 0. 1. 1. 1.] [0. 0. 1. 0. 1.] [0. 0. 1. 0. 0.]]]], shape=(1, 1, 5, 5), dtype=float32) 룩-어헤드 마스크이므로 삼각형 모양의 마스킹이 형성되면서 패딩 마스크가 포함돼 있는 세 번째 열이 마스킹 됩니다. 14. 디코더의 두 번째 서브층 : 인코더-디코더 어텐션 디코더의 두 번째 서브층에 대해서 이해해 봅시다. 디코더의 두 번째 서브층은 멀티 헤드 어텐션을 수행한다는 점에서는 이전의 어텐션들(인코더와 디코더의 첫 번째 서브층)과는 공통점이 있으나 이번에는 셀프 어텐션이 아닙니다. 셀프 어텐션은 Query, Key, Value가 같은 경우를 말하는데, 인코더-디코더 어텐션은 Query가 디코더인 행렬인 반면, Key와 Value는 인코더 행렬이기 때문입니다. 다시 한번 각 서브층에서의 Q, K, V의 관계를 정리해 봅시다. 인코더의 첫 번째 서브층 : Query = Key = Value 디코더의 첫 번째 서브층 : Query = Key = Value 디코더의 두 번째 서브층 : Query : 디코더 행렬 / Key = Value : 인코더 행렬 디코더의 두 번째 서브층을 확대해 보면, 다음과 같이 인코더로부터 두 개의 화살표가 그려져 있습니다. 두 개의 화살표는 각각 Key와 Value를 의미하며 이는 인코더의 마지막 층에서 온 행렬로부터 얻습니다. 반면 Query는 디코더의 첫 번째 서브층의 결과 행렬로부터 얻는다는 점이 다릅니다. Query가 디코더 행렬, Key가 인코더 행렬일 때, 어텐션 스코어 행렬을 구하는 과정은 다음과 같습니다. 그 외에 멀티 헤드 어텐션을 수행하는 과정은 다른 어텐션들과 같습니다. 15. 디코더 구현하기 디코더는 총 세 개의 서브층으로 구성됩니다. 첫 번째와 두 번째 서브층 모두 멀티 헤드 어텐션이지만, 첫 번째 서브층은 mask의 인자 값으로 look_ahead_mask가 들어가는 반면, 두 번째 서브층은 mask의 인자 값으로 padding_mask가 들어가는 것을 확인할 수 있습니다. 이는 첫 번째 서브층은 마스크 드 셀프 어텐션을 수행하기 때문입니다. 세 개의 서브층 모두 서브층 연산 후에는 드롭아웃, 잔차 연결, 층 정규화가 수행되는 것을 확인할 수 있습니다. def decoder_layer(dff, d_model, num_heads, dropout, name="decoder_layer"): inputs = tf.keras.Input(shape=(None, d_model), name="inputs") enc_outputs = tf.keras.Input(shape=(None, d_model), name="encoder_outputs") # 룩 어헤드 마스크(첫 번째 서브층) look_ahead_mask = tf.keras.Input( shape=(1, None, None), name="look_ahead_mask") # 패딩 마스크(두 번째 서브층) padding_mask = tf.keras.Input(shape=(1, 1, None), name='padding_mask') # 멀티-헤드 어텐션 (첫 번째 서브층 / 마스크 드 셀프 어텐션) attention1 = MultiHeadAttention( d_model, num_heads, name="attention_1")(inputs={ 'query': inputs, 'key': inputs, 'value': inputs, # Q = K = V 'mask': look_ahead_mask # 룩 어헤드 마스크 }) # 잔차 연결과 층 정규화 attention1 = tf.keras.layers.LayerNormalization( epsilon=1e-6)(attention1 + inputs) # 멀티-헤드 어텐션 (두 번째 서브층 / 디코더-인코더 어텐션) attention2 = MultiHeadAttention( d_model, num_heads, name="attention_2")(inputs={ 'query': attention1, 'key': enc_outputs, 'value': enc_outputs, # Q != K = V 'mask': padding_mask # 패딩 마스크 }) # 드롭아웃 + 잔차 연결과 층 정규화 attention2 = tf.keras.layers.Dropout(rate=dropout)(attention2) attention2 = tf.keras.layers.LayerNormalization( epsilon=1e-6)(attention2 + attention1) # 포지션 와이즈 피드 포워드 신경망 (세 번째 서브층) outputs = tf.keras.layers.Dense(units=dff, activation='relu')(attention2) outputs = tf.keras.layers.Dense(units=d_model)(outputs) # 드롭아웃 + 잔차 연결과 층 정규화 outputs = tf.keras.layers.Dropout(rate=dropout)(outputs) outputs = tf.keras.layers.LayerNormalization( epsilon=1e-6)(outputs + attention2) return tf.keras.Model( inputs=[inputs, enc_outputs, look_ahead_mask, padding_mask], outputs=outputs, name=name) 인코더와 마찬가지로 디코더도 num_layers 개만큼 쌓는 코드가 필요합니다. 16. 디코더 쌓기 포지셔널 인코딩 후 디코더 층을 num_layers의 개수만큼 쌓는 코드입니다. def decoder(vocab_size, num_layers, dff, d_model, num_heads, dropout, name='decoder'): inputs = tf.keras.Input(shape=(None,), name='inputs') enc_outputs = tf.keras.Input(shape=(None, d_model), name='encoder_outputs') # 디코더는 룩 어헤드 마스크(첫 번째 서브층)와 패딩 마스크(두 번째 서브층) 둘 다 사용. look_ahead_mask = tf.keras.Input( shape=(1, None, None), name='look_ahead_mask') padding_mask = tf.keras.Input(shape=(1, 1, None), name='padding_mask') # 포지셔널 인코딩 + 드롭아웃 embeddings = tf.keras.layers.Embedding(vocab_size, d_model)(inputs) embeddings *= tf.math.sqrt(tf.cast(d_model, tf.float32)) embeddings = PositionalEncoding(vocab_size, d_model)(embeddings) outputs = tf.keras.layers.Dropout(rate=dropout)(embeddings) # 디코더를 num_layers 개 쌓기 for i in range(num_layers): outputs = decoder_layer(dff=dff, d_model=d_model, num_heads=num_heads, dropout=dropout, name='decoder_layer_{}'.format(i), )(inputs=[outputs, enc_outputs, look_ahead_mask, padding_mask]) return tf.keras.Model( inputs=[inputs, enc_outputs, look_ahead_mask, padding_mask], outputs=outputs, name=name) 17. 트랜스포머 구현하기 지금까지 구현한 인코더와 디코더 함수를 조합하여 트랜스포머를 조립할 차례입니다. 인코더의 출력은 디코더에서 인코더-디코더 어텐션에서 사용되기 위해 디코더로 전달해 줍니다. 그리고 디코더의 끝단에는 다중 클래스 분류 문제를 풀 수 있도록, vocab_size 만큼의 뉴런을 가지는 출력층을 추가해 줍니다. def transformer(vocab_size, num_layers, dff, d_model, num_heads, dropout, name="transformer"): # 인코더의 입력 inputs = tf.keras.Input(shape=(None,), name="inputs") # 디코더의 입력 dec_inputs = tf.keras.Input(shape=(None,), name="dec_inputs") # 인코더의 패딩 마스크 enc_padding_mask = tf.keras.layers.Lambda( create_padding_mask, output_shape=(1, 1, None), name='enc_padding_mask')(inputs) # 디코더의 룩 어헤드 마스크(첫 번째 서브층) look_ahead_mask = tf.keras.layers.Lambda( create_look_ahead_mask, output_shape=(1, None, None), name='look_ahead_mask')(dec_inputs) # 디코더의 패딩 마스크(두 번째 서브층) dec_padding_mask = tf.keras.layers.Lambda( create_padding_mask, output_shape=(1, 1, None), name='dec_padding_mask')(inputs) # 인코더의 출력은 enc_outputs. 디코더로 전달된다. enc_outputs = encoder(vocab_size=vocab_size, num_layers=num_layers, dff=dff, d_model=d_model, num_heads=num_heads, dropout=dropout, )(inputs=[inputs, enc_padding_mask]) # 인코더의 입력은 입력 문장과 패딩 마스크 # 디코더의 출력은 dec_outputs. 출력층으로 전달된다. dec_outputs = decoder(vocab_size=vocab_size, num_layers=num_layers, dff=dff, d_model=d_model, num_heads=num_heads, dropout=dropout, )(inputs=[dec_inputs, enc_outputs, look_ahead_mask, dec_padding_mask]) # 다음 단어 예측을 위한 출력층 outputs = tf.keras.layers.Dense(units=vocab_size, name="outputs")(dec_outputs) return tf.keras.Model(inputs=[inputs, dec_inputs], outputs=outputs, name=name) 18. 트랜스포머 하이 퍼 파라미터 정하기 트랜스포머의 하이퍼 파라미터를 임의로 정하고 모델을 만들어봅시다. 현재 훈련 데이터가 존재하는 것은 아니지만, 단어 집합의 크기는 임의로 9,000으로 정합니다. 단어 집합의 크기로부터 룩업 테이블을 수행할 임베딩 테이블과 포지셔널 인코딩 행렬의 행의 크기를 결정할 수 있습니다. 논문에서 제시한 것과는 다르게 하이퍼 파라미터를 정해보겠습니다. 인코더와 디코더의 층의 개수 num_layers 는 4개, 인코더와 디코더의 포지션 와이즈 피드 포워드 신경망의 은닉층 f 은 128, 인코더와 디코더의 입, 출력의 차원 m d l 은 128, 멀티-헤드 어텐션에서 병렬적으로 사용할 헤드의 수 num_heads 는 4로 정했습니다. 128/4의 값인 32가 v 의 값이 되겠습니다. small_transformer = transformer( vocab_size = 9000, num_layers = 4, dff = 512, d_model = 128, num_heads = 4, dropout = 0.3, name="small_transformer") tf.keras.utils.plot_model( small_transformer, to_file='small_transformer.png', show_shapes=True) 19. 손실 함수 정의하기 다중 클래스 분류 문제를 풀 예정이므로 크로스 엔트로피 함수를 손실 함수로 정의합니다. def loss_function(y_true, y_pred): y_true = tf.reshape(y_true, shape=(-1, MAX_LENGTH - 1)) loss = tf.keras.losses.SparseCategoricalCrossentropy( from_logits=True, reduction='none')(y_true, y_pred) mask = tf.cast(tf.not_equal(y_true, 0), tf.float32) loss = tf.multiply(loss, mask) return tf.reduce_mean(loss) 20. 학습률 학습률 스케줄러(Learning rate Scheduler)는 미리 학습 일정을 정해두고 그 일정에 따라 학습률이 조정되는 방법입니다. 트랜스포머의 경우 사용자가 정한 단계까지는 학습률을 증가시켰다가 단계에 이르면 학습률을 점차적으로 떨어트리는 방식을 사용합니다. 좀 더 구체적으로 봅시다. step_num(단계)이란 옵티마이저가 매개변수를 업데이트하는 한 번의 진행 횟수를 의미합니다. 트랜스포머에서는 warmup_steps이라는 변수를 정하고 step_num이 warmup_steps보다 작을 경우는 학습률을 선형적으로 증가시키고, step_num이 warmup_steps에 도달하게 되면 학습률을 step_num의 역 제곱근에 따라서 감소시킵니다. 이를 식으로 표현하면 아래와 같습니다. warmup_steps의 값으로는 4,000을 사용하였습니다. r t = m d l 0.5 m n ( step_num 0.5 step_num class CustomSchedule(tf.keras.optimizers.schedules.LearningRateSchedule): def __init__(self, d_model, warmup_steps=4000): super(CustomSchedule, self).__init__() self.d_model = d_model self.d_model = tf.cast(self.d_model, tf.float32) self.warmup_steps = warmup_steps def __call__(self, step): step = tf.cast(step, tf.float32) arg1 = tf.math.rsqrt(step) arg2 = step * (self.warmup_steps**-1.5) return tf.math.rsqrt(self.d_model) * tf.math.minimum(arg1, arg2) 학습률의 변화를 시각화해봅시다. sample_learning_rate = CustomSchedule(d_model=128) plt.plot(sample_learning_rate(tf.range(200000, dtype=tf.float32))) plt.ylabel("Learning Rate") plt.xlabel("Train Step") Text(0.5, 0, 'Train Step') 여기서 구현한 트랜스포머 모델을 바탕으로 다음 실습에서 한국어 챗봇을 만들어보겠습니다. 논문에서는 언급되지 않은 트랜스포머의 구현 이야기가 궁금하시다면 아래 링크를 참고하세요. 링크 : https://tunz.kr/post/4 16-02 트랜스포머를 이용한 한국어 챗봇(Transformer Chatbot Tutorial) 앞서 구현한 트랜스포머 코드를 사용하여 일상 대화 챗봇을 구현합니다. 이번 실습은 바로 이전의 트랜스포머 실습 코드를 모두 실행하였다고 가정하므로 이전 트랜스포머 실습을 진행 후에 이어서 진행해야 합니다. 트랜스포머 챗봇 전체 코드는 아래의 링크에 공유합니다. 깃허브 링크 : https://github.com/ukairia777/tensorflow-transformer 1. 데이터 로드하기 import pandas as pd import numpy as np import matplotlib.pyplot as plt import re import urllib.request import time import tensorflow_datasets as tfds import tensorflow as tf 챗봇 데이터를 로드하여 상위 5개의 샘플을 출력해 봅시다. urllib.request.urlretrieve("https://raw.githubusercontent.com/songys/Chatbot_data/master/ChatbotData.csv", filename="ChatBotData.csv") train_data = pd.read_csv('ChatBotData.csv') train_data.head() 이 데이터는 질문(Q)과 대답(A)의 쌍으로 이루어진 데이터입니다. print('챗봇 샘플의 개수 :', len(train_data)) 챗봇 샘플의 개수 : 11823 총 샘플의 개수는 11,823개입니다. 불필요한 Null 값이 있는지 확인해 봅시다. print(train_data.isnull().sum()) Q 0 A 0 label 0 dtype: int64 Null 값은 별도로 존재하지 않습니다. 이번 실습에서는 토큰화를 위해 형태소 분석기를 사용하지 않고, 다른 방법인 학습 기반의 토크 나이저를 사용할 것입니다. 그래서 원 데이터에서 ?, ., !와 같은 구두점을 미리 처리해두어야 하는데, 구두점들을 단순히 제거할 수도 있겠지만, 여기서는 구두점 앞에 공백. 즉, 띄어쓰기를 추가하여 다른 문자들과 구분하겠습니다. 가령, '12시 땡!'이라는 문장이 있다면 '12시 땡 !'으로 땡과! 사이에 공백을 추가합니다. 이는 정규 표현식을 사용하여 가능합니다. 이 전처리는 질문 데이터와 답변 데이터 모두에 적용해 줍니다. questions = [] for sentence in train_data['Q']: # 구두점에 대해서 띄어쓰기 # ex) 12시 땡! -> 12시 땡! sentence = re.sub(r"([?.!,])", r" \1 ", sentence) sentence = sentence.strip() questions.append(sentence) answers = [] for sentence in train_data['A']: # 구두점에 대해서 띄어쓰기 # ex) 12시 땡! -> 12시 땡! sentence = re.sub(r"([?.!,])", r" \1 ", sentence) sentence = sentence.strip() answers.append(sentence) 질문과 대답에 대해서 상위 5개만 출력하여 구두점들이 띄어쓰기를 통해 분리되었는지 확인해 봅시다. print(questions[:5]) print(answers[:5]) ['12시 땡 !', '1지망 학교 떨어졌어', '3박 4일 놀러 가고 싶다', '3박 4일 정도 놀러 가고 싶다', 'PPL 심하네'] ['하루가 또 가네요 .', '위로해 드립니다 .', '여행은 언제나 좋죠 .', '여행은 언제나 좋죠 .', '눈살이 찌푸려지죠 .'] '하루가 또 가네요 .'와 같이 구두점 앞에 띄어쓰기가 추가되어 분리된 것을 확인할 수 있습니다. 2. 단어 집합 생성 앞서 서브 워드 토크 나이저 챕터에서 배웠던 서브 워드 텍스트 인코더를 사용해 봅시다. 자주 사용되는 서브 워드 단위로 토큰을 분리하는 토크 나이저로 학습 데이터로부터 학습하여 서브 워드로 구성된 단어 집합을 생성합니다. # 서브 워드 텍스트 인코더를 사용하여 질문, 답변 데이터로부터 단어 집합(Vocabulary) 생성 tokenizer = tfds.deprecated.text.SubwordTextEncoder.build_from_corpus( questions + answers, target_vocab_size=2**13) 단어 집합이 생성되었습니다. 그런데 seq2seq 챕터에서 배웠던 것처럼 인코더-디코더 모델 계열에는 디코더의 입력으로 사용할 시작을 의미하는 시작 토큰 SOS와 종료 토큰 EOS 또한 존재합니다. 해당 토큰들도 단어 집합에 포함시킬 필요가 있으므로 이 두 토큰에 정수를 부여해 줍니다. # 시작 토큰과 종료 토큰에 대한 정수 부여. START_TOKEN, END_TOKEN = [tokenizer.vocab_size], [tokenizer.vocab_size + 1] # 시작 토큰과 종료 토큰을 고려하여 단어 집합의 크기를 + 2 VOCAB_SIZE = tokenizer.vocab_size + 2 시작 토큰과 종료 토큰을 추가해 주었으나 단어 집합의 크기도 +2를 해줍니다. 시작 토큰의 번호와 종료 토큰의 번호, 그리고 단어 집합의 크기를 출력해 봅시다. print('시작 토큰 번호 :',START_TOKEN) print('종료 토큰 번호 :',END_TOKEN) print('단어 집합의 크기 :',VOCAB_SIZE) 시작 토큰 번호 : [8178] 종료 토큰 번호 : [8179] 단어 집합의 크기 : 8180 패딩에 사용될 0번 토큰부터 마지막 토큰인 8,179번 토큰까지의 개수를 카운트하면 단어 집합의 크기는 8,180개입니다. 3. 정수 인코딩과 패딩 단어 집합을 생성한 후에는 서브 워드 텍스트 인코더의 토크 나이저로 정수 인코딩을 진행할 수 있습니다. 이는 토크 나이저의. encode()를 사용하여 가능합니다. 우선 임의로 선택한 20번 질문 샘플. 즉, questions[20]을 가지고 정수 인코딩을 진행해 봅시다. # 서브 워드 텍스트 인코더 토크 나이저의. encode()를 사용하여 텍스트 시퀀스를 정수 시퀀스로 변환. print('임의의 질문 샘플을 정수 인코딩 : {}'.format(tokenizer.encode(questions[20]))) 임의의 질문 샘플을 정수 인코딩 : [5766, 611, 3509, 141, 685, 3747, 849] 임의의 질문 문장이 정수 시퀀스로 변환되었습니다. 반대로 정수 인코딩 된 결과는 다시 decode()를 사용하여 기존의 텍스트 시퀀스로 복원할 수 있습니다. 20번 질문 샘플을 가지고 정수 인코딩하고, 다시 이를 디코딩 하는 과정은 다음과 같습니다. # 서브 워드 텍스트 인코더 토크 나이저의. encode()와. decode() 테스트해 보기 # 임의의 입력 문장을 sample_string에 저장 sample_string = questions[20] # encode() : 텍스트 시퀀스 --> 정수 시퀀스 tokenized_string = tokenizer.encode(sample_string) print ('정수 인코딩 후의 문장 {}'.format(tokenized_string)) # decode() : 정수 시퀀스 --> 텍스트 시퀀스 original_string = tokenizer.decode(tokenized_string) print ('기존 문장: {}'.format(original_string)) 정수 인코딩 후의 문장 [5766, 611, 3509, 141, 685, 3747, 849] 기존 문장: 가스비 비싼데 감기 걸리겠어 정수 인코딩 된 문장을. decode()을 하면 자동으로 서브 워드들까지 다시 붙여서 기존 단어로 복원해 줍니다. 가령, 정수 인코딩 문장을 보면 정수가 7개인데 기존 문장의 띄어쓰기 단위인 어절은 4개밖에 존재하지 않습니다. 이는 '가스비'나 '비싼데'라는 한 어절이 정수 인코딩 후에는 두 개 이상의 정수일 수 있다는 겁니다. 각 정수가 어떤 서브 워드로 매핑되는지 출력해 봅시다. # 각 정수는 각 단어와 어떻게 mapping 되는지 병렬로 출력 # 서브 워드 텍스트 인코더는 의미 있는 단위의 서브 워드로 토크나이징한다. 띄어쓰기 단위 X 형태소 분석 단위 X for ts in tokenized_string: print ('{} ----> {}'.format(ts, tokenizer.decode([ts]))) 5766 ----> 가스 611 ----> 비 3509 ----> 비싼 141 ----> 데 685 ----> 감기 3747 ----> 걸리 849 ----> 겠어 샘플 1개를 가지고 정수 인코딩과 디코딩을 수행해 보았습니다. 이번에는 전체 데이터에 대해서 정수 인코딩과 패딩을 진행합니다. 이를 위한 함수로 tokenize_and_filter()를 만듭니다. 여기서는 임의로 패딩의 길이는 40으로 정했습니다. # 최대 길이를 40으로 정의 MAX_LENGTH = 40 # 토큰화 / 정수 인코딩 / 시작 토큰과 종료 토큰 추가 / 패딩 def tokenize_and_filter(inputs, outputs): tokenized_inputs, tokenized_outputs = [], [] for (sentence1, sentence2) in zip(inputs, outputs): # encode(토큰화 + 정수 인코딩), 시작 토큰과 종료 토큰 추가 sentence1 = START_TOKEN + tokenizer.encode(sentence1) + END_TOKEN sentence2 = START_TOKEN + tokenizer.encode(sentence2) + END_TOKEN tokenized_inputs.append(sentence1) tokenized_outputs.append(sentence2) # 패딩 tokenized_inputs = tf.keras.preprocessing.sequence.pad_sequences( tokenized_inputs, maxlen=MAX_LENGTH, padding='post') tokenized_outputs = tf.keras.preprocessing.sequence.pad_sequences( tokenized_outputs, maxlen=MAX_LENGTH, padding='post') return tokenized_inputs, tokenized_outputs questions, answers = tokenize_and_filter(questions, answers) 정수 인코딩과 패딩이 진행된 후의 데이터의 크기를 확인해 봅시다. print('질문 데이터의 크기(shape) :', questions.shape) print('답변 데이터의 크기(shape) :', answers.shape) 질문 데이터의 크기(shape) : (11823, 40) 답변 데이터의 크기(shape) : (11823, 40) 질문과 답변 데이터의 모든 문장이 모두 길이 40으로 변환되었습니다. 임의로 0번 샘플을 출력해 봅시다. # 0번 샘플을 임의로 출력 print(questions[0]) print(answers[0]) [8178 7915 4207 3060 41 8179 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [8178 3844 74 7894 1 8179 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] 길이 40을 맞추기 위해 뒤에 0이 패딩 된 것을 확인할 수 있습니다. 4. 인코더와 디코더의 입력, 그리고 레이블 만들기. tf.data.Dataset을 사용하여 데이터를 배치 단위로 불러올 수 있습니다. # 텐서 플로 dataset을 이용하여 셔플(shuffle)을 수행하되, 배치 크기로 데이터를 묶는다. # 또한 이 과정에서 교사 강요(teacher forcing)을 사용하기 위해서 디코더의 입력과 실제 값 시퀀스를 구성한다. BATCH_SIZE = 64 BUFFER_SIZE = 20000 # 디코더의 실제 값 시퀀스에서는 시작 토큰을 제거해야 한다. dataset = tf.data.Dataset.from_tensor_slices(( { 'inputs': questions, 'dec_inputs': answers[:, :-1] # 디코더의 입력. 마지막 패딩 토큰이 제거된다. }, { 'outputs': answers[:, 1:] # 맨 처음 토큰이 제거된다. 다시 말해 시작 토큰이 제거된다. }, )) dataset = dataset.cache() dataset = dataset.shuffle(BUFFER_SIZE) dataset = dataset.batch(BATCH_SIZE) dataset = dataset.prefetch(tf.data.experimental.AUTOTUNE) # 임의의 샘플에 대해서 [:, :-1]과 [:, 1:]이 어떤 의미를 가지는지 테스트해 본다. print(answers[0]) # 기존 샘플 print(answers[:1][:, :-1]) # 마지막 패딩 토큰 제거하면서 길이가 39가 된다. print(answers[:1][:, 1:]) # 맨 처음 토큰이 제거된다. 다시 말해 시작 토큰이 제거된다. 길이는 역시 39가 된다. [8178 3844 74 7894 1 8179 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [[8178 3844 74 7894 1 8179 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]] [[3844 74 7894 1 8179 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]] 5. 트랜스포머 만들기 이제 트랜스포머를 만들어봅시다. 하이퍼 파라미터를 조정하여 실제 논문의 트랜스포머보다는 작은 모델을 만듭니다. 여기서 선택한 주요 하이퍼 파라미터의 값은 다음과 같습니다. m d l = 256 num_layers = 2 num_heads = 8 f = 512 tf.keras.backend.clear_session() # 하이퍼 파라미터 D_MODEL = 256 NUM_LAYERS = 2 NUM_HEADS = 8 DFF = 512 DROPOUT = 0.1 model = transformer( vocab_size=VOCAB_SIZE, num_layers=NUM_LAYERS, dff=DFF, d_model=D_MODEL, num_heads=NUM_HEADS, dropout=DROPOUT) 학습률과 옵티마이저를 정의하고 모델을 컴파일합니다. learning_rate = CustomSchedule(D_MODEL) optimizer = tf.keras.optimizers.Adam( learning_rate, beta_1=0.9, beta_2=0.98, epsilon=1e-9) def accuracy(y_true, y_pred): # 레이블의 크기는 (batch_size, MAX_LENGTH - 1) y_true = tf.reshape(y_true, shape=(-1, MAX_LENGTH - 1)) return tf.keras.metrics.sparse_categorical_accuracy(y_true, y_pred) model.compile(optimizer=optimizer, loss=loss_function, metrics=[accuracy]) 총 50회 모델을 학습합니다. EPOCHS = 50 model.fit(dataset, epochs=EPOCHS) 6. 챗봇 평가하기. 챗봇을 평가하기 위한 세 개의 함수를 구현합니다. predict 함수에서 evaluate 함수를 호출하고 evaluate 함수에서 preprocess_sentence 함수를 호출하는 구조입니다. 사용자의 입력이 파이썬의 문자열로 입력되면 preprocess_sentence 함수에서 문자열에 대한 전처리를 수행합니다. 해당 전처리는 학습 전 질문 데이터와 답변 데이터에서 했던 전처리와 동일한 전처리입니다. 전처리가 진행된 문자열에 대해서 evaluate 함수는 트랜스포머 모델에 전처리가 진행된 사용자의 입력을 전달하고, 디코더를 통해 계속해서 현재 시점의 예측. 다시 말해 챗봇의 대답에 해당하는 단어를 순차적으로 예측합니다. 여기서 예측된 단어들은 문자열이 아니라 정수인 상태이므로 evaluate 함수가 리턴하는 것은 결과적으로 정수 시퀀스입니다. predict 함수는 evaluate 함수로부터 전달받은 챗봇의 대답에 해당하는 정수 시퀀스를 문자열로 다시 디코딩을 하고 사용자에게 챗봇의 대답을 출력합니다. def preprocess_sentence(sentence): # 단어와 구두점 사이에 공백 추가. # ex) 12시 땡! -> 12시 땡! sentence = re.sub(r"([?.!,])", r" \1 ", sentence) sentence = sentence.strip() return sentence def evaluate(sentence): # 입력 문장에 대한 전처리 sentence = preprocess_sentence(sentence) # 입력 문장에 시작 토큰과 종료 토큰을 추가 sentence = tf.expand_dims( START_TOKEN + tokenizer.encode(sentence) + END_TOKEN, axis=0) output = tf.expand_dims(START_TOKEN, 0) # 디코더의 예측 시작 for i in range(MAX_LENGTH): predictions = model(inputs=[sentence, output], training=False) # 현재 시점의 예측 단어를 받아온다. predictions = predictions[:, -1:, :] predicted_id = tf.cast(tf.argmax(predictions, axis=-1), tf.int32) # 만약 현재 시점의 예측 단어가 종료 토큰이라면 예측을 중단 if tf.equal(predicted_id, END_TOKEN[0]): break # 현재 시점의 예측 단어를 output(출력)에 연결한다. # output은 for 문의 다음 루프에서 디코더의 입력이 된다. output = tf.concat([output, predicted_id], axis=-1) # 단어 예측이 모두 끝났다면 output을 리턴. return tf.squeeze(output, axis=0) def predict(sentence): prediction = evaluate(sentence) # prediction == 디코더가 리턴 한 챗봇의 대답에 해당하는 정수 시퀀스 # tokenizer.decode()를 통해 정수 시퀀스를 문자열로 디코딩. predicted_sentence = tokenizer.decode( [i for i in prediction if i < tokenizer.vocab_size]) print('Input: {}'.format(sentence)) print('Output: {}'.format(predicted_sentence)) return predicted_sentence 학습된 트랜스포머에 임의로 생각나는 말들을 적어보았습니다. output = predict("영화 볼래?") Input: 영화 볼래? Output: 최신 영화가 좋을 것 같아요. output = predict("고민이 있어") Input: 고민이 있어 Output: 생각을 종이에 끄젹여여 보는 게 도움이 될 수도 있어요. output = predict("너무 화가 나") Input: 너무 화가 나 Output: 그럴수록 당신이 힘들 거예요. output = predict("카페 갈래?") Input: 카페 갈래? Output: 카페 가서 차 마셔도 돼요. output = predict("게임하고 싶다") Input: 게임하고 싶다 Output: 저도요! output = predict("게임하자") Input: 게임하자 Output: 게임하세요! 간단한 대화인만큼 그럭저럭 괜찮은 답변을 합니다. 데이터가 더 많다면, 더 다양한 대답을 할 수 있는 챗봇을 만들 수 있습니다. 16-03 셀프 어텐션을 이용한 텍스트 분류(Multi-head Self Attention for Text Classification) 트랜스포머는 RNN 계열의 seq2seq를 대체하기 위해서 등장했습니다. 그리고 트랜스포머의 인코더는 RNN 인코더를, 트랜스포머의 디코더는 RNN 디코더를 대체할 수 있었습니다. 트랜스포머의 인코더는 셀프 어텐션이라는 메커니즘을 통해 문장을 이해합니다. RNN과 그 동작 방식은 다르지만, RNN이 텍스트 분류나 개체명 인식과 같은 다양한 자연어 처리 태스크에 쓰일 수 있다면 트랜스포머의 인코더 또한 가능할 것입니다. 실제로 트랜스포머의 인코더는 다양한 분야의 자연어 처리 태스크에서 사용될 수 있었고, 이 아이디어는 후에 배우게 될 BERT라는 모델로 이어지게 됩니다. 이번 챕터에서는 트랜스포머의 인코더를 사용하여 텍스트 분류를 수행합니다. 1. 멀티 헤드 어텐션 우선 트랜스포머의 인코더의 첫 번째 서브층인 멀티 헤드 어텐션층을 클래스로 구현합니다. import tensorflow as tf class MultiHeadAttention(tf.keras.layers.Layer): def __init__(self, embedding_dim, num_heads=8): super(MultiHeadAttention, self).__init__() self.embedding_dim = embedding_dim # d_model self.num_heads = num_heads assert embedding_dim % self.num_heads == 0 self.projection_dim = embedding_dim // num_heads self.query_dense = tf.keras.layers.Dense(embedding_dim) self.key_dense = tf.keras.layers.Dense(embedding_dim) self.value_dense = tf.keras.layers.Dense(embedding_dim) self.dense = tf.keras.layers.Dense(embedding_dim) def scaled_dot_product_attention(self, query, key, value): matmul_qk = tf.matmul(query, key, transpose_b=True) depth = tf.cast(tf.shape(key)[-1], tf.float32) logits = matmul_qk / tf.math.sqrt(depth) attention_weights = tf.nn.softmax(logits, axis=-1) output = tf.matmul(attention_weights, value) return output, attention_weights def split_heads(self, x, batch_size): x = tf.reshape(x, (batch_size, -1, self.num_heads, self.projection_dim)) return tf.transpose(x, perm=[0, 2, 1, 3]) def call(self, inputs): # x.shape = [batch_size, seq_len, embedding_dim] batch_size = tf.shape(inputs)[0] # (batch_size, seq_len, embedding_dim) query = self.query_dense(inputs) key = self.key_dense(inputs) value = self.value_dense(inputs) # (batch_size, num_heads, seq_len, projection_dim) query = self.split_heads(query, batch_size) key = self.split_heads(key, batch_size) value = self.split_heads(value, batch_size) scaled_attention, _ = self.scaled_dot_product_attention(query, key, value) # (batch_size, seq_len, num_heads, projection_dim) scaled_attention = tf.transpose(scaled_attention, perm=[0, 2, 1, 3]) # (batch_size, seq_len, embedding_dim) concat_attention = tf.reshape(scaled_attention, (batch_size, -1, self.embedding_dim)) outputs = self.dense(concat_attention) return outputs 2. 인코더 설계하기 멀티 헤드 어텐션에 두 번째 서브층인 포지션 와이즈 피드 포워드 신경망을 추가하여 인코더 클래스를 설계합니다. class TransformerBlock(tf.keras.layers.Layer): def __init__(self, embedding_dim, num_heads, dff, rate=0.1): super(TransformerBlock, self).__init__() self.att = MultiHeadAttention(embedding_dim, num_heads) self.ffn = tf.keras.Sequential( [tf.keras.layers.Dense(dff, activation="relu"), tf.keras.layers.Dense(embedding_dim),] ) self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6) self.layernorm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6) self.dropout1 = tf.keras.layers.Dropout(rate) self.dropout2 = tf.keras.layers.Dropout(rate) def call(self, inputs, training): attn_output = self.att(inputs) # 첫 번째 서브층 : 멀티 헤드 어텐션 attn_output = self.dropout1(attn_output, training=training) out1 = self.layernorm1(inputs + attn_output) # Add & Norm ffn_output = self.ffn(out1) # 두 번째 서브층 : 포지션 와이즈 피드 포워드 신경망 ffn_output = self.dropout2(ffn_output, training=training) return self.layernorm2(out1 + ffn_output) # Add & Norm 3. 포지션 임베딩 앞서 트랜스포머를 설명할 때는 포지셔널 인코딩을 사용하였지만, 이번에는 위치 정보 자체를 학습을 하도록 하는 포지션 임베딩이라는 방법을 사용합니다. 이는 뒤에서 배우게 될 BERT에서 사용하는 방법이기도 합니다. 포지션 임베딩은 임베딩 층(Embedding layer)를 사용하되, 위치 벡터를 학습하도록 하므로 임베딩 층의 첫 번째 인자로 단어 집합의 크기가 아니라 문장의 최대 길이를 넣어줍니다. class TokenAndPositionEmbedding(tf.keras.layers.Layer): def __init__(self, max_len, vocab_size, embedding_dim): super(TokenAndPositionEmbedding, self).__init__() self.token_emb = tf.keras.layers.Embedding(vocab_size, embedding_dim) self.pos_emb = tf.keras.layers.Embedding(max_len, embedding_dim) def call(self, x): max_len = tf.shape(x)[-1] positions = tf.range(start=0, limit=max_len, delta=1) positions = self.pos_emb(positions) x = self.token_emb(x) return x + positions 4. 데이터 로드 및 전처리 vocab_size = 20000 # 빈도수 상위 2만 개의 단어만 사용 max_len = 200 # 문장의 최대 길이 (X_train, y_train), (X_test, y_test) = tf.keras.datasets.imdb.load_data(num_words=vocab_size) print('훈련용 리뷰 개수 : {}'.format(len(X_train))) print('테스트용 리뷰 개수 : {}'.format(len(X_test))) 훈련용 리뷰 개수 : 25000 테스트용 리뷰 개수 : 25000 X_train = tf.keras.preprocessing.sequence.pad_sequences(X_train, maxlen=max_len) X_test = tf.keras.preprocessing.sequence.pad_sequences(X_test, maxlen=max_len) 5. 트랜스포머를 이용한 IMDB 리뷰 분류 embedding_dim = 32 # 각 단어의 임베딩 벡터의 차원 num_heads = 2 # 어텐션 헤드의 수 dff = 32 # 포지션 와이즈 피드 포워드 신경망의 은닉층의 크기 inputs = tf.keras.layers.Input(shape=(max_len,)) embedding_layer = TokenAndPositionEmbedding(max_len, vocab_size, embedding_dim) x = embedding_layer(inputs) transformer_block = TransformerBlock(embedding_dim, num_heads, dff) x = transformer_block(x) x = tf.keras.layers.GlobalAveragePooling1D()(x) x = tf.keras.layers.Dropout(0.1)(x) x = tf.keras.layers.Dense(20, activation="relu")(x) x = tf.keras.layers.Dropout(0.1)(x) outputs = tf.keras.layers.Dense(2, activation="softmax")(x) model = tf.keras.Model(inputs=inputs, outputs=outputs) model.compile("adam", "sparse_categorical_crossentropy", metrics=["accuracy"]) history = model.fit(X_train, y_train, batch_size=32, epochs=2, validation_data=(X_test, y_test)) print("테스트 정확도: %.4f" % (model.evaluate(X_test, y_test)[1])) 테스트 정확도: 0.8695 17. BERT(Bidirectional Encoder Representations from Transformers) 트랜스포머(transformer)의 등장 이후, 다양한 자연어 처리 태스크에서 사용되었던 RNN 계열의 신경망인 LSTM, GRU는 트랜스포머로 대체되어가는 추세입니다. 이에 따라 다양한 트랜스포머 계열의 BERT, GPT, T5 등 다양한 사전 훈련된 언어 모델들이 계속해서 등장하고 있습니다. 여기서는 가장 유명한 사전 훈련된 언어 모델 중 하나인 BERT에 대해서 소개합니다. 이번 챕터에서 소개하는 BERT의 기본 개념을 이해하고, ALBERT, RoBERTa, ELECTRA와 같은 BERT의 파생 모델을 공부하는 방식으로 트랜스포머 계열 언어 모델에 대한 공부를 이어나가시기 바랍니다. ALBERT : A Lite BERT for Self-supervised Learning of Language Representations RoBERTa : A Robustly Optimized BERT Pretraining Approach ELECTRA : Efficiently Learning an Encoder that Classifies Token Replacements Accurately 17-01 NLP에서의 사전 훈련(Pre-training) 2018년 딥 러닝 연구원 세바스찬 루더는 사전 훈련된 언어 모델의 약진을 보며 다음과 같은 말을 했습니다. "사전 훈련된 단어 임베딩이 모든 NLP 실무자의 도구 상자에서 사전 훈련된 언어 모델로 대체되는 것은 시간문제이다." BERT(Bidirectional Encoder Representations from Transformers)와 같은 트랜스포머 계열의 모델들이 자연어 처리를 지배했던 19년과 20년을 회고하면 이 말은 이미 현실이 되었습니다. BERT를 배우기에 앞서 워드 임베딩에서부터 ELMo, 그리고 트랜스포머에 이르기까지 자연어 처리가 발전되어온 흐름을 정리해 봅시다. 1. 사전 훈련된 워드 임베딩 앞서 Word2Vec, FastText, GloVe와 같은 워드 임베딩 방법론들을 설명했습니다. 어떤 태스크를 수행할 때, 임베딩을 사용하는 방법으로는 크게 두 가지가 있습니다. 임베딩 층(Embedding layer)을 랜덤 초기화하여 처음부터 학습하는 방법. 그리고 방대한 데이터로 Word2Vec 등과 같은 임베딩 알고리즘으로 사전에 학습된 임베딩 벡터들을 가져와 사용하는 방법입니다. 만약, 태스크에 사용하기 위한 데이터가 적다면, 사전 훈련된 임베딩을 사용하면 성능 향상을 기대해 볼 수 있었습니다. 그런데 이 두 가지 방법 모두 하나의 단어가 하나의 벡터 값으로 매핑되므로, 문맥을 고려하지 못하여 다의어나 동음이의어를 구분하지 못하는 문제점이 있습니다. 한국어에는 '사과'라는 단어가 존재하는데 이 '사과'는 용서를 빈다는 의미로도 쓰이지만, 먹는 과일의 의미로도 사용됩니다. 그러나 임베딩 벡터는 '사과'라는 벡터에 하나의 벡터 값을 매핑하므로 이 두 가지 의미를 구분할 수 없었습니다. 이 한계는 사전 훈련된 언어 모델을 사용함으로써 극복할 수 있었으며 아래에서 언급할 ELMo나 BERT 등이 이러한 문제의 해결책입니다. 2. 사전 훈련된 언어 모델 2015년 구글은 'Semi-supervised Sequence Learning'라는 논문에서 LSTM 언어 모델을 학습하고 나서 이렇게 학습한 LSTM을 텍스트 분류에 추가 학습하는 방법을 보였습니다. 이 방법은 우선 LSTM 언어 모델을 학습합니다. 언어 모델은 주어진 텍스트로부터 이전 단어들로부터 다음 단어를 예측하도록 학습하므로 기본적으로 별도의 레이블이 부착되지 않은 텍스트 데이터로도 학습 가능합니다. 사전 훈련된 워드 임베딩과 마찬가지로 사전 훈련된 언어 모델의 강점은 학습 전 사람이 별도 레이블을 지정해 줄 필요가 없다는 점입니다. 그리고 이렇게 레이블이 없는 데이터로 학습된 LSTM과 가중치가 랜덤으로 초기화된 LSTM 두 가지를 두고, 텍스트 분류와 같은 문제를 학습하여 사전 훈련된 언어 모델을 사용한 전자의 경우가 더 좋은 성능을 얻을 수 있다는 가능성을 보였습니다. 방대한 텍스트로 LSTM 언어 모델을 학습해두고, 언어 모델을 다른 태스크에서 높은 성능을 얻기 위해 사용하는 방법으로 이전에 설명한 ELMo와 같은 아이디어도 존재합니다. ELMo는 순방향 언어 모델과 역방향 언어 모델을 각각 따로 학습시킨 후에, 이렇게 사전 학습된 언어 모델로부터 임베딩 값을 얻는다는 아이디어였습니다. 이러한 임베딩은 문맥에 따라서 임베딩 벡터 값이 달라지므로, 기존 워드 임베딩인 Word2Vec이나 GloVe 등이 다의어를 구분할 수 없었던 문제점을 해결할 수 있었습니다. 이어 언어 모델은 RNN 계열의 신경망에서 탈피하기 시작합니다. 트랜스포머가 번역기와 같은 인코더-디코더 구조에서 LSTM을 뛰어넘는 좋은 성능을 얻자, LSTM이 아닌 트랜스포머로 사전 훈련된 언어 모델을 학습하는 시도가 등장했습니다. 위의 그림에서 Trm은 트랜스포머(Transformer)의 약자입니다. 트랜스포머의 디코더는 LSTM 언어 모델처럼 순차적으로 이전 단어들로부터 다음 단어를 예측합니다. Open AI는 트랜스포머 디코더로 총 12개의 층을 쌓은 후에 방대한 텍스트 데이터를 학습시킨 언어 모델 GPT-1을 만들었습니다. Open AI는 GPT-1에 여러 다양한 태스크를 위해 추가 학습을 진행하였을 때, 다양한 태스크에서 높은 성능을 얻을 수 있음을 입증했습니다. NLP의 주요 트렌드는 사전 훈련된 언어 모델을 만들고 이를 특정 태스크에 추가 학습시켜 해당 태스크에서 높은 성능을 얻는 것으로 접어들었고, 언어 모델의 학습 방법에 변화를 주는 모델들이 등장했습니다. 위의 좌측 그림에 있는 단방향 언어 모델은 지금까지 배운 전형적인 언어 모델입니다. 시작 토큰 <SOS>가 들어가면, 다음 단어 I를 예측하고 그리고 그다음 단어 am을 예측합니다. 반면, 우측에 있는 양방향 언어 모델은 지금까지 본 적 없던 형태의 언어 모델입니다. 실제로 이렇게 구현하는 경우는 거의 없는데 그 이유가 무엇일까요? 가령, 양방향 LSTM을 이용해서 우측과 같은 언어 모델을 만들었다고 해봅시다. 초록색 LSTM 셀은 순방향 언어 모델로 <sos>를 입력받아 I를 예측하고, 그 후에 am을 예측합니다. 그런데 am을 예측할 때, 출력층은 주황색 LSTM 셀인 역방향 언어 모델의 정보도 함께 받고 있습니다. 그런데 am을 예측하는 시점에서 역방향 언어 모델이 이미 관측한 단어는 a, am, I 이렇게 3개의 단어입니다. 이미 예측해야 하는 단어를 역방향 언어 모델을 통해 미리 관측한 셈이므로 언어 모델은 일반적으로 양방향으로 구현하지 않습니다. 하지만 언어의 문맥이라는 것은 실제로는 양방향입니다. 텍스트 분류나 개체명 인식 등에서 양방향 LSTM을 사용하여 모델을 구현해서 좋은 성능을 얻을 수 있었던 것을 상기해 봅시다. 하지만 이전 단어들로부터 다음 단어를 예측하는 언어 모델의 특성으로 인해 위의 그림과 같은 양방향 언어 모델을 사용할 수 없으므로, 그 대안으로 ELMo에서는 순방향과 역방향이라는 두 개의 단방향 언어 모델을 따로 준비하여 학습하는 방법을 사용했던 것입니다. 이와 같이 기존 언어 모델로는 양방향 구조를 도입할 수 없으므로, 양방향 구조를 도입하기 위해서 2018년에는 새로운 구조의 언어 모델이 탄생했는데 바로 마스크 드 언어 모델입니다. 3. 마스크 드 언어 모델(Masked Language Model) 마스크 드 언어 모델은 입력 텍스트의 단어 집합의 15%의 단어를 랜덤으로 마스킹(Masking) 합니다. 여기서 마스킹이란 원래의 단어가 무엇이었는지 모르게 한다는 뜻입니다. 그리고 인공 신경망에게 이렇게 마스킹 된 단어들을(Masked words) 예측하도록 합니다. 문장 중간에 구멍을 뚫어놓고, 구멍에 들어갈 단어들을 예측하게 하는 식입니다. 우리가 영어 시험을 볼 때 종종 마주하는 빈칸 채우기 문제에 비유할 수 있습니다. 예를 들어 '나는 [MASK]에 가서 그곳에서 빵과 [MASK]를 샀다'를 주고 [MASK]에 들어갈 단어를 맞추게 합니다. 이 언어 모델에 대해서는 이번 챕터의 주제인 BERT를 설명하며 더 자세히 알아보겠습니다. 17-02 버트(Bidirectional Encoder Representations from Transformers, BERT) 트랜스포머 챕터에 대한 사전 이해가 필요합니다. BERT(Bidirectional Encoder Representations from Transformers)는 2018년에 구글이 공개한 사전 훈련된 모델입니다. BERT라는 이름은 세서미 스트리트라는 미국 인형극의 캐릭터 이름이기도 한데, 앞서 소개한 임베딩 방법론인 ELMo와 마찬가지로 세서미 스트리트의 캐릭터 이름을 따온 것이기도 합니다. BERT는 2018년에 공개되어 등장과 동시에 수많은 NLP 태스크에서 최고 성능을 보여주면서 명실공히 NLP의 한 획을 그은 모델로 평가받고 있습니다. 이번 챕터에서는 BERT의 구조에 대해 이해하고, 이어서 BERT를 실습해 보겠습니다. 간단한 BERT 실습을 위해 아래와 같이 transformers라는 패키지를 설치하겠습니다. pip install transformers 1. BERT의 개요 BERT는 이전 챕터에서 배웠던 트랜스포머를 이용하여 구현되었으며, 위키피디아(25억 단어)와 BooksCorpus(8억 단어)와 같은 레이블이 없는 텍스트 데이터로 사전 훈련된 언어 모델입니다. BERT가 높은 성능을 얻을 수 있었던 것은, 레이블이 없는 방대한 데이터로 사전 훈련된 모델을 가지고, 레이블이 있는 다른 작업(Task)에서 추가 훈련과 함께 하이퍼 파라미터를 재조정하여 이 모델을 사용하면 성능이 높게 나오는 기존의 사례들을 참고하였기 때문입니다. 다른 작업에 대해서 파라미터 재조정을 위한 추가 훈련 과정을 파인 튜닝(Fine-tuning)이라고 합니다. 위의 그림은 BERT의 파인 튜닝 사례를 보여줍니다. 우리가 하고 싶은 태스크가 스팸 메일 분류라고 하였을 때, 이미 위키피디아 등으로 사전 학습된 BERT 위에 분류를 위한 신경망을 한 층 추가합니다. 이 경우, 비유하자면 BERT가 언어 모델 사전 학습 과정에서 얻은 지식을 활용할 수 있으므로 스팸 메일 분류에서 보다 더 좋은 성능을 얻을 수 있습니다. 이전에 언급한 ELMo나 OpenAI GPT-1 등이 이러한 파인 튜닝 사례의 대표적인 예입니다. 2. BERT의 크기 BERT의 기본 구조는 트랜스포머의 인코더를 쌓아 올린 구조입니다. Base 버전에서는 총 12개를 쌓았으며, Large 버전에서는 총 24개를 쌓았습니다. 그 외에도 Large 버전은 Base 버전보다 d_model의 크기나 셀프 어텐션 헤드(Self Attention Heads)의 수가 더 큽니다. 트랜스포머 인코더 층의 수를 L, d_model의 크기를 D, 셀프 어텐션 헤드의 수를 A라고 하였을 때 각각의 크기는 다음과 같습니다. BERT-Base : L=12, D=768, A=12 : 110M 개의 파라미터 BERT-Large : L=24, D=1024, A=16 : 340M 개의 파라미터 초기 트랜스포머 모델(https://wikidocs.net/31379)이 L=6, D=512, A=8이었다는 것과 비교하면 Base 또한 초기 트랜스포머보다는 큰 네트워크임을 알 수 있습니다. 여기서 BERT-base는 BERT보다 앞서 등장한 Open AI GPT-1과 하이퍼 파라미터가 동일한데, 이는 BERT 연구진이 직접적으로 GPT-1과 성능을 비교하기 위해서 GPT-1과 동등한 크기로 BERT-Base를 설계하였기 때문입니다. 반면, BERT-Large는 BERT의 최대 성능을 보여주기 위해 만들어진 모델입니다. BERT가 세운 기록들은 대부분 BERT-Large를 통해 이루어졌습니다. 이 글에서는 앞으로 편의를 위해 BERT-BASE를 기준으로 설명합니다. 3. BERT의 문맥을 반영한 임베딩(Contextual Embedding) BERT는 ELMo나 GPT-1과 마찬가지로 문맥을 반영한 임베딩(Contextual Embedding)을 사용하고 있습니다. BERT의 입력은 앞서 배운 딥 러닝 모델들과 마찬가지로 임베딩 층(Embedding layer)를 지난 임베딩 벡터들입니다. d_model을 768로 정의하였으므로, 모든 단어들은 768차원의 임베딩 벡터가 되어 BERT의 입력으로 사용됩니다. BERT는 내부적인 연산을 거친 후, 동일하게 각 단어에 대해서 768차원의 벡터를 출력합니다. 위의 그림에서는 BERT가 각 768차원의 [CLS], I, love, you라는 4개의 벡터를 입력받아서(입력 임베딩) 동일하게 768차원의 4개의 벡터를 출력하는 모습(출력 임베딩)을 보여줍니다. BERT의 연산을 거친 후의 출력 임베딩은 문장의 문맥을 모두 참고한 문맥을 반영한 임베딩이 됩니다. 위의 좌측 그림에서 [CLS]라는 벡터는 BERT의 초기 입력으로 사용되었을 입력 임베딩 당시에는 단순히 임베딩 층(embedding layer)를 지난 임베딩 벡터였지만, BERT를 지나고 나서는 [CLS], I, love, you라는 모든 단어 벡터들을 모두 참고한 후에 문맥 정보를 가진 벡터가 됩니다. 위의 좌측 그림에서는 모든 단어를 참고하고 있다는 것을 점선의 화살표로 표현하였습니다. 이는 [CLS]라는 단어 벡터뿐만 아니라 다른 벡터들도 전부 마찬가지입니다. 가령, 우측의 그림에서 출력 임베딩 단계의 love를 보면 BERT의 입력이었던 모든 단어들인 [CLS], I, love, you를 참고하고 있습니다. 하나의 단어가 모든 단어를 참고하는 연산은 사실 BERT의 12개의 층에서 전부 이루어지는 연산입니다. 그리고 이를 12개의 층을 지난 후에 최종적으로 출력 임베딩을 얻게 되는 것입니다. 가령, 위의 그림은 BERT의 첫 번째 층에 입력된 각 단어가 모든 단어를 참고한 후에 출력되는 과정을 화살표로 표현하였습니다. BERT의 첫 번째 층의 출력 임베딩은 BERT의 두 번째 층에서는 입력 임베딩이 됩니다. 그렇다면 BERT는 어떻게 모든 단어들을 참고하여 문맥을 반영한 출력 임베딩을 얻게 되는 것일까요? 사실 이에 대한 해답을 여러분은 이미 알고 있는데, 바로 '셀프 어텐션'입니다. BERT는 기본적으로 트랜스포머 인코더를 12번 쌓은 것이므로 내부적으로 각 층마다 멀티 헤드 셀프 어텐션과 포지션 와이즈 피드 포워드 신경망을 수행하고 있습니다. 4. BERT의 서브 워드 토크 나이저 : WordPiece BERT는 단어보다 더 작은 단위로 쪼개는 서브 워드 토크 나이저를 사용합니다. BERT가 사용한 토크 나이저는 WordPiece 토크 나이저로 서브 워드 토크 나이저 챕터에서 공부한 바이트 페어 인코딩(Byte Pair Encoding, BPE)의 유사 알고리즘입니다. 동작 방식은 BPE와 조금 다르지만, 글자로부터 서브 워드들을 병합해가는 방식으로 최종 단어 집합(Vocabulary)을 만드는 것은 BPE와 유사합니다. 서브 워드 토크 나이저는 기본적으로 자주 등장하는 단어는 그대로 단어 집합에 추가하지만, 자주 등장하지 않는 단어의 경우에는 더 작은 단위인 서브 워드로 분리되어 서브 워드들이 단어 집합에 추가된다는 아이디어를 갖고 있습니다. 이렇게 단어 집합이 만들어지고 나면, 이 단어 집합을 기반으로 토큰화를 수행합니다. 이는 대표적인 서브 워드 토크 나이저 패키지인 SentencePiece 실습을 통해 이해한 내용입니다. BERT의 서브 워드 토크 나이저도 이와 마찬가지로 동작합니다. BERT에서 토큰화를 수행하는 방식은 다음과 같습니다. 준비물 : 이미 훈련 데이터로부터 만들어진 단어 집합 1. 토큰이 단어 집합에 존재한다. => 해당 토큰을 분리하지 않는다. 2. 토큰이 단어 집합에 존재하지 않는다. => 해당 토큰을 서브 워드로 분리한다. => 해당 토큰의 첫 번째 서브 워드를 제외한 나머지 서브 워드들은 앞에 "##"를 붙인 것을 토큰으로 한다. 예를 들어 embeddings이라는 단어가 입력으로 들어왔을 때, BERT의 단어 집합에 해당 단어가 존재하지 않았다고 해봅시다. 만약, 서브 워드 토크 나이저가 아닌 토크 나이저라면 여기서 OOV 문제가 발생합니다. 하지만 서브 워드 토크 나이저의 경우에는 해당 단어가 단어 집합에 존재하지 않았다고 해서, 서브 워드 또한 존재하지 않는다는 의미는 아니므로 해당 단어를 더 쪼개려고 시도합니다. 만약, BERT의 단어 집합에 em, ##bed, ##ding, #s라는 서브 워드들이 존재한다면, embeddings는 em, ##bed, ##ding, #s로 분리됩니다. 여기서 ##은 이 서브 워드들은 단어의 중간부터 등장하는 서브 워드라는 것을 알려주기 위해 단어 집합 생성 시 표시해둔 기호입니다. 이런 표시가 있어야만 em, ##bed, ##ding, #s를 다시 손쉽게 embeddings로 복원할 수 있을 것입니다. 실습을 통해서 이해해 봅시다. transformers라는 패키지를 사용하여 BERT 토크 나이저를 사용할 수 있습니다. import pandas as pd from transformers import BertTokenizer tokenizer = BertTokenizer.from_pretrained("bert-base-uncased") # Bert-base의 토크 나이저 'Here is the sentence I want embeddings for.'라는 문장을 BERT의 토크 나이저가 어떻게 토큰화하는지 봅시다. result = tokenizer.tokenize('Here is the sentence I want embeddings for.') print(result) ['here', 'is', 'the', 'sentence', 'i', 'want', 'em', '##bed', '##ding', '##s', 'for', '.'] embeddings라는 단어는 단어 집합에 존재하지 않으므로 em, ##bed, ##ding, #s로 분리됩니다. 실제로 BERT의 단어 집합에 특정 단어가 있는지 조회하려면. vocab[]을 통해서 가능합니다. 우선 단어 'here'을 조회해 봅시다. print(tokenizer.vocab['here']) 2182 정수 2182가 출력됩니다. 이는 단어 here이 정수 인코딩을 위해서 단어 집합 내부적으로 2182라는 정수로 매핑되어 있다는 의미입니다. 단어 embeddings를 조회해 봅시다. print(tokenizer.vocab['embeddings']) KeyError: 'embeddings' 해당 단어가 존재하지 않는다는 의미에서 KeyError가 발생합니다. 반면, 단어 em, ##bed, ##ing, ##s는 모두 단어 집합에 존재합니다. print(tokenizer.vocab['em']) 7861 print(tokenizer.vocab['##bed']) 8270 print(tokenizer.vocab['##ding']) 4667 print(tokenizer.vocab['##s']) 2015 이번에는 BERT의 단어 집합 전체를 불러와서 살펴보겠습니다. BERT의 단어 집합을 vocabulary.txt에 저장합니다. # BERT의 단어 집합을 vocabulary.txt에 저장 with open('vocabulary.txt', 'w') as f: for token in tokenizer.vocab.keys(): f.write(token + '\n') vocabulary.txt 파일을 직접 열어서 살펴볼 수도 있겠지만, 데이터 프레임 형태로 저장해서 확인할 수도 있습니다. df = pd.read_fwf('vocabulary.txt', header=None) df print('단어 집합의 크기 :',len(df)) 단어 집합의 크기 : 30522 BERT의 단어 집합의 크기는 30,522입니다. 데이터 프레임의 인덱스가 해당 단어와 매핑된 정수이므로 정수로부터 매핑된 단어를 확인할 수 있습니다. 가령, 4667번 단어는 ##ding입니다. df.loc[4667].values[0] ##ding 참고로 BERT에서 사용되는 특별 토큰들과 그와 매핑되는 정수는 다음과 같습니다. [PAD] - 0 [UNK] - 100 [CLS] - 101 [SEP] - 102 [MASK] - 103 임의로 102번 토큰만 출력해 봅시다. df.loc[102].values[0] [SEP] 이 특별 토큰들이 어떤 의미를 가지는지에 대해서는 뒤에서 언급하겠습니다. 5. 포지션 임베딩(Position Embedding) 트랜스포머에서는 포지셔널 인코딩(Positional Encoding)이라는 방법을 통해서 단어의 위치 정보를 표현했습니다. 포지셔널 인코딩은 사인 함수와 코사인 함수를 사용하여 위치에 따라 다른 값을 가지는 행렬을 만들어 이를 단어 벡터들과 더하는 방법입니다. BERT에서는 이와 유사하지만, 위치 정보를 사인 함수와 코사인 함수로 만드는 것이 아닌 학습을 통해서 얻는 포지션 임베딩(Position Embedding)이라는 방법을 사용합니다. 위의 그림은 포지션 임베딩을 사용하는 방법을 보여줍니다. 우선, 위의 그림에서 WordPiece Embedding은 우리가 이미 알고 있는 단어 임베딩으로 실질적인 입력입니다. 그리고 이 입력에 포지션 임베딩을 통해서 위치 정보를 더해주어야 합니다. 포지션 임베딩의 아이디어는 굉장히 간단한데, 위치 정보를 위한 임베딩 층(Embedding layer)을 하나 더 사용합니다. 가령, 문장의 길이가 4라면 4개의 포지션 임베딩 벡터를 학습시킵니다. 그리고 BERT의 입력마다 다음과 같이 포지션 임베딩 벡터를 더해주는 것입니다. 첫 번째 단어의 임베딩 벡터 + 0번 포지션 임베딩 벡터 두 번째 단어의 임베딩 벡터 + 1번 포지션 임베딩 벡터 세 번째 단어의 임베딩 벡터 + 2번 포지션 임베딩 벡터 네 번째 단어의 임베딩 벡터 + 3번 포지션 임베딩 벡터 실제 BERT에서는 문장의 최대 길이를 512로 하고 있으므로, 총 512개의 포지션 임베딩 벡터가 학습됩니다. 결론적으로 현재 설명한 내용을 기준으로는 BERT에서는 총 두 개의 임베딩 층이 사용됩니다. 단어 집합의 크기가 30,522개인 단어 벡터를 위한 임베딩 층과 문장의 최대 길이가 512이므로 512개의 포지션 벡터를 위한 임베딩 층입니다. 사실 BERT는 세그먼트 임베딩(Segment Embedding)이라는 1개의 임베딩 층을 더 사용합니다. 이에 대해서는 뒤에 언급합니다. 6. BERT의 사전 훈련(Pre-training) 위의 그림은 BERT의 논문에 첨부된 그림으로 ELMo와 GPT-1, 그리고 BERT의 구조적인 차이를 보여줍니다. 가장 우측 그림의 ELMo는 정방향 LSTM과 역방향 LSTM을 각각 훈련시키는 방식으로 양방향 언어 모델을 만들었습니다. 가운데 그림의 GPT-1은 트랜스포머의 디코더를 이전 단어들로부터 다음 단어를 예측하는 방식으로 단방향 언어 모델을 만들었습니다. Trm은 트랜스포머를 의미합니다. 단방향(→)으로 설계된 Open AI GPT와 달리 가장 좌측 그림의 BERT는 화살표가 양방향으로 뻗어나가는 모습을 보여줍니다. 이는 마스크 드 언어 모델(Masked Language Model)을 통해 양방향성을 얻었기 때문입니다. BERT의 사전 훈련 방법은 크게 두 가지로 나뉩니다. 첫 번째는 마스크 드 언어 모델이고, 두 번째는 다음 문장 예측(Next sentence prediction, NSP)입니다. 논문에 따르면 BERT는 BookCorpus(8억 단어)와 위키피디아(25억 단어)로 학습되었습니다. 1) 마스크 드 언어 모델(Masked Language Model, MLM) BERT는 사전 훈련을 위해서 인공 신경망의 입력으로 들어가는 입력 텍스트의 15%의 단어를 랜덤으로 마스킹(Masking) 합니다. 그리고 인공 신경망에게 이 가려진 단어들을(Masked words) 예측하도록 합니다. 중간에 단어들에 구멍을 뚫어놓고, 구멍에 들어갈 단어들을 예측하게 하는 식입니다. 예를 들어 '나는 [MASK]에 가서 그곳에서 빵과 [MASK]를 샀다'를 주고 '슈퍼'와 '우유'를 맞추게 합니다. 더 정확히는 전부 [MASK]로 변경하지는 않고, 랜덤으로 선택된 15%의 단어들은 다시 다음과 같은 비율로 규칙이 적용됩니다. 80%의 단어들은 [MASK]로 변경한다. Ex) The man went to the store → The man went to the [MASK] 10%의 단어들은 랜덤으로 단어가 변경된다. Ex) The man went to the store → The man went to the dog 10%의 단어들은 동일하게 둔다. Ex) The man went to the store → The man went to the store 이렇게 하는 이유는 [MASK]만 사용할 경우에는 [MASK] 토큰이 파인 튜닝 단계에서는 나타나지 않으므로 사전 학습 단계와 파인 튜닝 단계에서의 불일치가 발생하는 문제가 있습니다. 이 문제를 완화하기 위해서 랜덤으로 선택된 15%의 단어들의 모든 토큰을 [MASK]로 사용하지 않습니다. 이를 전체 단어 관점에서 그래프를 통해 정리하면 다음과 같습니다. 전체 단어의 85%는 마스크 드 언어 모델의 학습에 사용되지 않습니다. 마스크 드 언어 모델의 학습에 사용되는 단어는 전체 단어의 15%입니다. 학습에 사용되는 12%는 [MASK]로 변경 후에 원래 단어를 예측합니다. 1.5%는 랜덤으로 단어가 변경된 후에 원래 단어를 예측합니다. 1.5%는 단어가 변경되지는 않았지만, BERT는 이 단어가 변경된 단어인지 원래 단어가 맞는지는 알 수 없습니다. 이 경우에도 BERT는 원래 단어가 무엇인지를 예측하도록 합니다. 예시를 통해 이해해 봅시다. 'My dog is cute. he likes playing'이라는 문장에 대해서 마스크 드 언어 모델을 학습하고자 합니다. 약간의 전처리와 BERT의 서브 워드 토크 나이저에 의해 이 문장은 ['my', 'dog', 'is' 'cute', 'he', 'likes', 'play', '##ing']로 토큰 화가 되어 BERT의 입력으로 사용됩니다. 그리고 언어 모델 학습을 위해서 다음과 같이 데이터가 변경되었다고 가정해 봅시다. 'dog' 토큰은 [MASK]로 변경되었습니다. 위 그림은 'dog' 토큰이 [MASK]로 변경되어서 BERT 모델이 원래 단어를 맞추려고 하는 모습을 보여줍니다. 여기서 출력층에 있는 다른 위치의 벡터들은 예측과 학습에 사용되지 않고, 오직 'dog' 위치의 출력층의 벡터만이 사용됩니다. 구체적으로는 BERT의 손실 함수에서 다른 위치에서의 예측은 무시합니다. 출력층에서는 예측을 위해 단어 집합의 크기만큼의 밀집층(Dense layer)에 소프트맥스 함수가 사용된 1개의 층을 사용하여 원래 단어가 무엇인지를 맞추게 됩니다. 그런데 만약 'dog'만 변경된 것이 아니라 다음과 같이 데이터 셋이 변경되었다면 어떨까요? 이번에는 세 가지 유형 모두에 대해서 가정해 봅시다. 'dog' 토큰은 [MASK]로 변경되었습니다. 'he'는 랜덤 단어 'king'으로 변경되었습니다. 'play'는 변경되진 않았지만 예측에 사용됩니다. BERT는 랜덤 단어 'king'으로 변경된 토큰에 대해서도 원래 단어가 무엇인지, 변경되지 않은 단어 'play'에 대해서도 원래 단어가 무엇인지를 예측해야 합니다. 'play'는 변경되지 않았지만 BERT 입장에서는 이것이 변경된 단어인지 아닌지 모르므로 마찬가지로 원래 단어를 예측해야 합니다. BERT는 마스크 드 언어 모델 외에도 다음 문장 예측이라는 또 다른 태스크를 학습합니다. 2) 다음 문장 예측(Next Sentence Prediction, NSP) BERT는 두 개의 문장을 준 후에 이 문장이 이어지는 문장인지 아닌지를 맞추는 방식으로 훈련시킵니다. 이를 위해서 50:50 비율로 실제 이어지는 두 개의 문장과 랜덤으로 이어붙인 두 개의 문장을 주고 훈련시킵니다. 이를 각각 Sentence A와 Sentence B라고 하였을 때, 다음의 예는 문장의 연속성을 확인한 경우와 그렇지 않은 경우를 보여줍니다. 이어지는 문장의 경우 Sentence A : The man went to the store. Sentence B : He bought a gallon of milk. Label = IsNextSentence 이어지는 문장이 아닌 경우 경우 Sentence A : The man went to the store. Sentence B : dogs are so cute. Label = NotNextSentence BERT의 입력으로 넣을 때에는 [SEP]라는 특별 토큰을 사용해서 문장을 구분합니다. 첫 번째 문장의 끝에 [SEP] 토큰을 넣고, 두 번째 문장이 끝나면 역시 [SEP] 토큰을 붙여줍니다. 그리고 이 두 문장이 실제 이어지는 문장인지 아닌지를 [CLS] 토큰의 위치의 출력층에서 이진 분류 문제를 풀도록 합니다. [CLS] 토큰은 BERT가 분류 문제를 풀기 위해 추가된 특별 토큰입니다. 그리고 위의 그림에서 나타난 것과 같이 마스크 드 언어 모델과 다음 문장 예측은 따로 학습하는 것이 아닌 loss를 합하여 학습이 동시에 이루어집니다. BERT가 언어 모델 외에도 다음 문장 예측이라는 태스크를 학습하는 이유는 BERT가 풀고자 하는 태스크 중에서는 QA(Question Answering)나 NLI(Natural Language Inference)와 같이 두 문장의 관계를 이해하는 것이 중요한 태스크들이 있기 때문입니다. 7. 세그먼트 임베딩(Segment Embedding) 앞서 언급했듯이 BERT는 QA 등과 같은 두 개의 문장 입력이 필요한 태스크를 풀기도 합니다. 문장 구분을 위해서 BERT는 세그먼트 임베딩이라는 또 다른 임베딩 층(Embedding layer)을 사용합니다. 첫 번째 문장에는 Sentence 0 임베딩, 두 번째 문장에는 Sentence 1 임베딩을 더해주는 방식이며 임베딩 벡터는 두 개만 사용됩니다. 결론적으로 BERT는 총 3개의 임베딩 층이 사용됩니다. WordPiece Embedding : 실질적인 입력이 되는 워드 임베딩. 임베딩 벡터의 종류는 단어 집합의 크기로 30,522개. Position Embedding : 위치 정보를 학습하기 위한 임베딩. 임베딩 벡터의 종류는 문장의 최대 길이인 512개. Segment Embedding : 두 개의 문장을 구분하기 위한 임베딩. 임베딩 벡터의 종류는 문장의 최대 개수인 2개. 주의할 점은 많은 문헌에서 BERT가 문장 중간의 [SEP] 토큰과 두 종류의 세그먼트 임베딩을 통해서 두 개의 문장을 구분하여 입력받을 수 있다고 설명하고 있지만, 여기서 BERT에 두 개의 문장이 들어간다는 표현에서의 문장이라는 것은 실제 우리가 알고 있는 문장의 단위는 아닙니다. 예를 들어 QA 문제를 푸는 경우에는 [SEP]와 세그먼트 임베딩을 기준으로 구분되는 [질문(Question), 본문(Paragraph)] 두 종류의 텍스트를 입력받지만, Paragraph 1개는 실제로는 다수의 문장으로 구성될 수 있습니다. 다시 말해 [SEP]와 세그먼트 임베딩으로 구분되는 BERT의 입력에서의 두 개의 문장은 실제로는 두 종류의 텍스트, 두 개의 문서일 수 있습니다. BERT가 두 개의 문장을 입력받을 필요가 없는 경우도 있습니다. 예를 들어 네이버 영화 리뷰 분류나 IMDB 리뷰 분류와 같은 감성 분류 태스크에서는 한 개의 문서에 대해서만 분류를 하는 것이므로, 이 경우에는 BERT의 전체 입력에 Sentence 0 임베딩만을 더해줍니다. 아래에서 설명할 1)과 2) 파인 튜닝 유형이 그 예라고 할 수 있겠습니다. 8. BERT를 파인 튜닝(Fine-tuning) 하기 이번에는 사전 학습된 BERT에 우리가 풀고자 하는 태스크의 데이터를 추가로 학습 시켜서 테스트하는 단계인 파인 튜닝 단계에 대해서 알아보겠습니다. 실질적으로 태스크에 BERT를 사용하는 단계에 해당됩니다. 1) 하나의 텍스트에 대한 텍스트 분류 유형(Single Text Classification) BERT를 사용하는 첫 번째 유형은 하나의 문서에 대한 텍스트 분류 유형입니다. 이 유형은 영화 리뷰 감성 분류, 로이터 뉴스 분류 등과 같이 입력된 문서에 대해서 분류를 하는 유형으로 문서의 시작에 [CLS]라는 토큰을 입력합니다. 앞서 사전 훈련 단계에서 다음 문장 예측을 설명할 때, [CLS] 토큰은 BERT가 분류 문제를 풀기 위한 특별 토큰이라고 언급한 바 있습니다. 이는 BERT를 실질적으로 사용하는 단계인 파인 튜닝 단계에서도 마찬가지입니다. 텍스트 분류 문제를 풀기 위해서 [CLS] 토큰의 위치의 출력층에서 밀집층(Dense layer) 또는 같은 이름으로는 완전 연결층(fully-connected layer)이라고 불리는 층들을 추가하여 분류에 대한 예측을 하게 됩니다. 2) 하나의 텍스트에 대한 태깅 작업(Tagging) BERT를 사용하는 두 번째 유형은 태깅 작업입니다. 앞서 RNN 계열의 신경망들을 이용해서 풀었던 태스크입니다. 대표적으로 문장의 각 단어에 품사를 태깅 하는 품사 태깅 작업과 개체를 태깅 하는 개체명 인식 작업이 있습니다. 출력층에서는 입력 텍스트의 각 토큰의 위치에 밀집층을 사용하여 분류에 대한 예측을 하게 됩니다. 3) 텍스트의 쌍에 대한 분류 또는 회귀 문제(Text Pair Classification or Regression) BERT는 텍스트의 쌍을 입력으로 받는 태스크도 풀 수 있습니다. 텍스트의 쌍을 입력으로 받는 대표적인 태스크로 자연어 추론(Natural language inference)이 있습니다. 자연어 추론 문제란, 두 문장이 주어졌을 때, 하나의 문장이 다른 문장과 논리적으로 어떤 관계에 있는지를 분류하는 것입니다. 유형으로는 모순 관계(contradiction), 함의 관계(entailment), 중립 관계(neutral)가 있습니다. 텍스트의 쌍을 입력받는 이러한 태스크의 경우에는 입력 텍스트가 1개가 아니므로, 텍스트 사이에 [SEP] 토큰을 집어넣고, Sentence 0 임베딩과 Sentence 1 임베딩이라는 두 종류의 세그먼트 임베딩을 모두 사용하여 문서를 구분합니다. 4) 질의응답(Question Answering) 텍스트의 쌍을 입력으로 받는 또 다른 태스크로 QA(Question Answering)가 있습니다. BERT로 QA를 풀기 위해서 질문과 본문이라는 두 개의 텍스트의 쌍을 입력합니다. 이 태스크의 대표적인 데이터 셋으로 SQuAD(Stanford Question Answering Dataset) v1.1이 있습니다. 이 데이터 셋을 푸는 방법은 질문과 본문을 입력받으면, 본문의 일부분을 추출해서 질문에 답변하는 것입니다. 실제로 이 데이터 셋은 영어로 되어있지만 한국어로 예시를 들어보겠습니다. "강우가 떨어지도록 영향을 주는 것은?"라는 질문이 주어지고, "기상학에서 강우는 대기 수증기가 응결되어 중력의 영향을 받고 떨어지는 것을 의미합니다. 강우의 주요 형태는 이슬비, 비, 진눈깨비, 눈, 싸락눈 및 우박이 있습니다."라는 본문이 주어졌다고 해보겠습니다 이 경우, 정답은 "중력"이 되어야 합니다. 9. 그 외 기타 훈련 데이터는 위키피디아(25억 단어)와 BooksCorpus(8억 단어) ≈ 33억 단어 WordPiece 토크 나이저로 토큰화를 수행 후 15% 비율에 대해서 마스크 드 언어 모델 학습 두 문장 Sentence A와 B의 합한 길이. 즉, 최대 입력의 길이는 512로 제한 100만 step 훈련 ≈ (총합 33억 단어 코퍼스에 대해 40 에포크 학습) 옵티마이저 : 아담(Adam) 학습률(learning rate) : 10 4 가중치 감소(Weight Decay) : L2 정규화로 0.01 적용 드롭아웃 : 모든 레이어에 대해서 0.1 적용 활성화 함수 : relu 함수가 아닌 gelu 함수 배치 크기(Batch size) : 256 10. 어텐션 마스크(Attention Mask) BERT를 실제로 실습하게 되면 어텐션 마스크라는 시퀀스 입력이 추가로 필요합니다. 어텐션 마스크는 BERT가 어텐션 연산을 할 때, 불필요하게 패딩 토큰에 대해서 어텐션을 하지 않도록 실제 단어와 패딩 토큰을 구분할 수 있도록 알려주는 입력입니다. 이 값은 0과 1 두 가지 값을 가지는데, 숫자 1은 해당 토큰은 실제 단어이므로 마스킹을 하지 않는다라는 의미이고, 숫자 0은 해당 토큰은 패딩 토큰이므로 마스킹을 한다는 의미입니다. 위의 그림과 같이 실제 단어의 위치에는 1, 패딩 토큰의 위치에는 0의 값을 가지는 시퀀스를 만들어 BERT의 또 다른 입력으로 사용하면 됩니다. 다음 챕터에서 BERT를 이용하여 실제로 이진 분류, 다중 클래스 분류, 개체명 인식, QA(Question Answering)을 풀며 BERT에 대한 파인 튜닝 방법을 이해해 봅시다. 17-03 구글 BERT의 마스크 드 언어 모델(Masked Language Model) 실습 모든 BERT 실습은 Colab에서 진행한다고 가정합니다. 사전 학습된 한국어 BERT를 이용하여 마스크 드 언어 모델을 실습해 봅시다. 이번 실습을 위해서만이 아니라 앞으로 사전 학습된 BERT를 사용할 때는 transformers라는 패키지를 자주 사용하게 됩니다. 실습 환경에 transformers 패키지를 설치해둡시다. pip install transformers 1. 마스크 드 언어 모델과 토크 나이저 transformers 패키지를 사용하여 모델과 토크 나이저를 로드합니다. BERT는 이미 누군가가 학습해둔 모델을 사용하는 것이므로 우리가 사용하는 모델과 토크 나이저는 항상 매핑 관계여야 합니다. 예를 들어서 A라는 이름의 BERT를 사용하는데, B라는 이름의 BERT의 토크 나이저를 사용하면 모델은 텍스트를 제대로 이해할 수 없습니다. A라는 BERT의 토크 나이저는 '사과'라는 단어를 36번으로 정수 인코딩하는 반면에, B라는 BERT의 토크 나이저는 '사과'라는 단어를 42번으로 정수 인코딩하는 등 단어와 매핑되는 정수 정보 자체가 다르기 때문입니다. from transformers import TFBertForMaskedLM from transformers import AutoTokenizer TFBertForMaskedLM.from_pretrained('BERT 모델 이름')을 넣으면 [MASK]라고 되어있는 단어를 맞추기 위한 마스크 드 언어 모델링을 위한 구조로 BERT를 로드합니다. 다시 말해서 BERT를 마스크 드 언어 모델 형태로 로드합니다. AutoTokenizer.from_pretrained('모델 이름')을 넣으면 해당 모델이 학습되었을 당시에 사용되었던 토크 나이저를 로드합니다. model = TFBertForMaskedLM.from_pretrained('bert-large-uncased') tokenizer = AutoTokenizer.from_pretrained("bert-large-uncased") 2. BERT의 입력 ''Soccer is a really fun [MASK]'라는 임의의 문장이 있다고 해봅시다. 이를 마스크 드 언어 모델의 입력으로 넣으면, 마스크 드 언어 모델은 [MASK]의 위치에 해당하는 단어를 예측합니다. 마스크 드 언어 모델의 예측 결과를 보기 위해서 bert-large-uncased의 토크 나이저를 사용하여 해당 문장을 정수 인코딩 해봅시다. inputs = tokenizer('Soccer is a really fun [MASK].', return_tensors='tf') 토크 나이저로 변환된 결과에서 input_ids를 통해 정수 인코딩 결과를 확인할 수 있습니다. print(inputs['input_ids']) tf.Tensor([[ 101 4715 2003 1037 2428 4569 103 1012 102]], shape=(1, 9), dtype=int32) 토크 나이저로 변환된 결과에서 token_type_ids를 통해서 문장을 구분하는 세그먼트 인코딩 결과를 확인할 수 있습니다. print(inputs['token_type_ids']) tf.Tensor([[0 0 0 0 0 0 0 0 0]], shape=(1, 9), dtype=int32) 현재의 입력은 문장이 두 개가 아니라 한 개이므로 여기서는 문장 길이만큼의 0 시퀀스를 얻습니다. 만약 문장이 두 개였다면 두 번째 문장이 시작되는 구간부터는 1의 시퀀스가 나오게 되지만, 여기서는 해당되지 않습니다. 토크 나이저로 변환된 결과에서 attention_mask를 통해서 실제 단어와 패딩 토큰을 구분하는 용도인 어텐션 마스크를 확인할 수 있습니다. print(inputs['attention_mask']) tf.Tensor([[1 1 1 1 1 1 1 1 1]], shape=(1, 9), dtype=int32) 현재의 입력에서는 패딩이 없으므로 여기서는 문장 길이만큼의 1 시퀀스를 얻습니다. 만약 뒤에 패딩이 있었다면 패딩이 시작되는 구간부터는 0의 시퀀스가 나오게 되지만, 여기서는 해당되지 않습니다. 좀 더 다양한 패턴의 입력은 뒤의 텍스트 분류, 개체명 인식, 질의응답 실습에서 이어서 보겠습니다. 3. [MASK] 토큰 예측하기 FillMaskPipeline은 모델과 토크 나이저를 지정하면 손쉽게 마스크 드 언어 모델의 예측 결과를 정리해서 보여줍니다. FillMaskPipeline에 우선 앞서 불러온 모델과 토크 나이저를 지정해 줍니다. from transformers import FillMaskPipeline pip = FillMaskPipeline(model=model, tokenizer=tokenizer) 이제 입력 문장으로부터 [MASK]의 위치에 들어갈 수 있는 상위 5개의 후보 단어들을 출력해 봅시다. pip('Soccer is a really fun [MASK].') [{'score': 0.762112021446228, 'sequence': 'soccer is a really fun sport.', 'token': 4368, 'token_str': 'sport'}, {'score': 0.2034197747707367, 'sequence': 'soccer is a really fun game.', 'token': 2208, 'token_str': 'game'}, {'score': 0.012208552099764347, 'sequence': 'soccer is a really fun thing.', 'token': 2518, 'token_str': 'thing'}, {'score': 0.0018630230333656073, 'sequence': 'soccer is a really fun activity.', 'token': 4023, 'token_str': 'activity'}, {'score': 0.001335485139861703, 'sequence': 'soccer is a really fun field.', 'token': 2492, 'token_str': 'field'}] pip('The Avengers is a really fun [MASK].') [{'score': 0.2562903165817261, 'sequence': 'the avengers is a really fun show.', 'token': 2265, 'token_str': 'show'}, {'score': 0.1728411316871643, 'sequence': 'the avengers is a really fun movie.', 'token': 3185, 'token_str': 'movie'}, {'score': 0.11107689887285233, 'sequence': 'the avengers is a really fun story.', 'token': 2466, 'token_str': 'story'}, {'score': 0.07248972356319427, 'sequence': 'the avengers is a really fun series.', 'token': 2186, 'token_str': 'series'}, {'score': 0.07046619802713394, 'sequence': 'the avengers is a really fun film.', 'token': 2143, 'token_str': 'film'}] pip('I went to [MASK] this morning.') [{'score': 0.35730746388435364, 'sequence': 'i went to work this morning.', 'token': 2147, 'token_str': 'work'}, {'score': 0.23304426670074463, 'sequence': 'i went to bed this morning.', 'token': 2793, 'token_str': 'bed'}, {'score': 0.12845049798488617, 'sequence': 'i went to school this morning.', 'token': 2082, 'token_str': 'school'}, {'score': 0.062305748462677, 'sequence': 'i went to sleep this morning.', 'token': 3637, 'token_str': 'sleep'}, {'score': 0.04695260152220726, 'sequence': 'i went to class this morning.', 'token': 2465, 'token_str': 'class'}] 17-04 한국어 BERT의 마스크 드 언어 모델(Masked Language Model) 실습 모든 BERT 실습은 Colab에서 진행한다고 가정합니다. 사전 학습된 한국어 BERT를 이용하여 마스크 드 언어 모델을 실습해 봅시다. 이번 실습을 위해서만이 아니라 앞으로 사전 학습된 BERT를 사용할 때는 transformers라는 패키지를 자주 사용하게 됩니다. 실습 환경에 transformers 패키지를 설치해둡시다. pip install transformers 1. 마스크 드 언어 모델과 토크 나이저 transformers 패키지를 사용하여 모델과 토크 나이저를 로드합니다. BERT는 이미 누군가가 학습해둔 모델을 사용하는 것이므로 우리가 사용하는 모델과 토크 나이저는 항상 매핑 관계여야 합니다. 예를 들어서 A라는 이름의 BERT를 사용하는데, B라는 이름의 BERT의 토크 나이저를 사용하면 모델은 텍스트를 제대로 이해할 수 없습니다. A라는 BERT의 토크 나이저는 '사과'라는 단어를 36번으로 정수 인코딩하는 반면에, B라는 BERT의 토크 나이저는 '사과'라는 단어를 42번으로 정수 인코딩하는 등 단어와 매핑되는 정수 정보 자체가 다르기 때문입니다. klue/bert-base는 대표적인 한국어 BERT입니다. klue/bert-base의 마스크 드 언어 모델과 klue/bert-base의 토크 나이저를 로드해 봅시다. from transformers import TFBertForMaskedLM from transformers import AutoTokenizer TFBertForMaskedLM.from_pretrained('BERT 모델 이름')을 넣으면 [MASK]라고 되어있는 단어를 맞추기 위한 마스크 드 언어 모델링을 위한 구조로 BERT를 로드합니다. 다시 말해서 BERT를 마스크 드 언어 모델 형태로 로드합니다. from_pt=True는 해당 모델이 기존에는 텐서 플로가 아니라 파이 토치로 학습된 모델이었지만 이를 텐서 플로에서 사용하겠다는 의미입니다. AutoTokenizer.from_pretrained('모델 이름')을 넣으면 해당 모델이 학습되었을 당시에 사용되었던 토크 나이저를 로드합니다. model = TFBertForMaskedLM.from_pretrained('klue/bert-base', from_pt=True) tokenizer = AutoTokenizer.from_pretrained("klue/bert-base") 2. BERT의 입력 '축구는 정말 재미있는 [MASK]다'라는 임의의 문장이 있다고 해봅시다. 이를 마스크 드 언어 모델의 입력으로 넣으면, 마스크 드 언어 모델은 [MASK]의 위치에 해당하는 단어를 예측합니다. 마스크 드 언어 모델의 예측 결과를 보기 위해서 klue/bert-base의 토크 나이저를 사용하여 해당 문장을 정수 인코딩 해봅시다. inputs = tokenizer('축구는 정말 재미있는 [MASK]다.', return_tensors='tf') 토크 나이저로 변환된 결과에서 input_ids를 통해 정수 인코딩 결과를 확인할 수 있습니다. print(inputs['input_ids']) tf.Tensor([[ 2 4713 2259 3944 6001 2259 4 809 18 3]], shape=(1, 10), dtype=int32) 토크 나이저로 변환된 결과에서 token_type_ids를 통해서 문장을 구분하는 세그먼트 인코딩 결과를 확인할 수 있습니다. print(inputs['token_type_ids']) tf.Tensor([[0 0 0 0 0 0 0 0 0 0]], shape=(1, 10), dtype=int32) 현재의 입력은 문장이 두 개가 아니라 한 개이므로 여기서는 문장 길이만큼의 0 시퀀스를 얻습니다. 만약 문장이 두 개였다면 두 번째 문장이 시작되는 구간부터는 1의 시퀀스가 나오게 되지만, 여기서는 해당되지 않습니다. 토크 나이저로 변환된 결과에서 attention_mask를 통해서 실제 단어와 패딩 토큰을 구분하는 용도인 어텐션 마스크를 확인할 수 있습니다. print(inputs['attention_mask']) tf.Tensor([[1 1 1 1 1 1 1 1 1 1]], shape=(1, 10), dtype=int32) 현재의 입력에서는 패딩이 없으므로 여기서는 문장 길이만큼의 1 시퀀스를 얻습니다. 만약 뒤에 패딩이 있었다면 패딩이 시작되는 구간부터는 0의 시퀀스가 나오게 되지만, 여기서는 해당되지 않습니다. 좀 더 다양한 패턴의 입력은 뒤의 텍스트 분류, 개체명 인식, 질의응답 실습에서 이어서 보겠습니다. 3. [MASK] 토큰 예측하기 FillMaskPipeline은 모델과 토크 나이저를 지정하면 손쉽게 마스크 드 언어 모델의 예측 결과를 정리해서 보여줍니다. FillMaskPipeline에 우선 앞서 불러온 모델과 토크 나이저를 지정해 줍니다. from transformers import FillMaskPipeline pip = FillMaskPipeline(model=model, tokenizer=tokenizer) 이제 입력 문장으로부터 [MASK]의 위치에 들어갈 수 있는 상위 5개의 후보 단어들을 출력해 봅시다. pip('축구는 정말 재미있는 [MASK]다.') [{'score': 0.8963505625724792, 'sequence': '축구는 정말 재미있는 스포츠 다.', 'token': 4559, 'token_str': '스포츠'}, {'score': 0.02595764957368374, 'sequence': '축구는 정말 재미있는 거 다.', 'token': 568, 'token_str': '거'}, {'score': 0.010033931583166122, 'sequence': '축구는 정말 재미있는 경기 다.', 'token': 3682, 'token_str': '경기'}, {'score': 0.007924391888082027, 'sequence': '축구는 정말 재미있는 축구 다.', 'token': 4713, 'token_str': '축구'}, {'score': 0.00784421805292368, 'sequence': '축구는 정말 재미있는 놀이 다.', 'token': 5845, 'token_str': '놀이'}] pip('어벤저스는 정말 재미있는 [MASK]다.') [{'score': 0.8382411599159241, 'sequence': '어벤저스는 정말 재미있는 영화 다.', 'token': 3771, 'token_str': '영화'}, {'score': 0.028275618329644203, 'sequence': '어벤저스는 정말 재미있는 거 다.', 'token': 568, 'token_str': '거'}, {'score': 0.017189407721161842, 'sequence': '어벤저스는 정말 재미있는 드라마 다.', 'token': 4665, 'token_str': '드라마'}, {'score': 0.014989694580435753, 'sequence': '어벤저스는 정말 재미있는 이야기 다.', 'token': 3758, 'token_str': '이야기'}, {'score': 0.009382619522511959, 'sequence': '어벤저스는 정말 재미있는 장소 다.', 'token': 4938, 'token_str': '장소'}] pip('나는 오늘 아침에 [MASK]에 출근을 했다.') [{'score': 0.08012567460536957, 'sequence': '나는 오늘 아침에 회사에 출근을 했다.', 'token': 3769, 'token_str': '회사'}, {'score': 0.06124098226428032, 'sequence': '나는 오늘 아침에 에 출근을 했다.', 'token': 1, 'token_str': '[UNK]'}, {'score': 0.017486684024333954, 'sequence': '나는 오늘 아침에 공장에 출근을 했다.', 'token': 4345, 'token_str': '공장'}, {'score': 0.016131816431879997, 'sequence': '나는 오늘 아침에 사무실에 출근을 했다.', 'token': 5841, 'token_str': '사무실'}, {'score': 0.015360789373517036, 'sequence': '나는 오늘 아침에 서울에 출근을 했다.', 'token': 3671, 'token_str': '서울'}] 17-05 구글 BERT의 다음 문장 예측(Next Sentence Prediction) 모든 BERT 실습은 Colab에서 진행한다고 가정합니다. 사전 학습된 한국어 BERT를 이용하여 다음 문장 예측을 실습해 봅시다. 이번 실습을 위해서만이 아니라 앞으로 사전 학습된 BERT를 사용할 때는 transformers라는 패키지를 자주 사용하게 됩니다. 실습 환경에 transformers 패키지를 설치해둡시다. pip install transformers 1. 다음 문장 예측 모델과 토크 나이저 transformers 패키지를 사용하여 모델과 토크 나이저를 로드합니다. BERT는 이미 누군가가 학습해둔 모델을 사용하는 것이므로 우리가 사용하는 모델과 토크 나이저는 항상 매핑 관계여야 합니다. import tensorflow as tf from transformers import TFBertForNextSentencePrediction from transformers import AutoTokenizer TFBertForNextSentencePrediction.from_pretrained('BERT 모델 이름')을 넣으면 두 개의 문장이 이어지는 문장 관계인지를 판단하는 BERT 구조를 로드합니다. AutoTokenizer.from_pretrained('모델 이름')을 넣으면 해당 모델이 학습되었을 당시에 사용되었던 토크 나이저를 로드합니다. model = TFBertForNextSentencePrediction.from_pretrained('bert-base-uncased') tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased') 2. BERT의 입력 다음 문장 예측을 위해 문맥 상으로 실제로 이어지는 두 개의 문장을 준비합니다. prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced." next_sentence = "pizza is eaten with the use of a knife and fork. In casual settings, however, it is cut into wedges to be eaten while held in the hand." 앞서 준비한 bert-base-uncased의 토크 나이저를 사용하여 두 개의 문장을 정수 인코딩 해봅시다. encoding = tokenizer(prompt, next_sentence, return_tensors='tf') 토크 나이저로 변환된 결과에서 input_ids를 통해 정수 인코딩 결과를 확인할 수 있습니다. print(encoding['input_ids']) <tf.Tensor: shape=(1, 58), dtype=int32, numpy= array([[ 101, 1999, 3304, 1010, 10733, 2366, 1999, 5337, 10906, 1010, 2107, 2004, 2012, 1037, 4825, 1010, 2003, 3591, 4895, 14540, 6610, 2094, 1012, 102, 10733, 2003, 8828, 2007, 1996, 2224, 1997, 1037, 5442, 1998, 9292, 1012, 1999, 10017, 10906, 1010, 2174, 1010, 2009, 2003, 3013, 2046, 17632, 2015, 2000, 2022, 8828, 2096, 2218, 1999, 1996, 2192, 1012, 102]], dtype=int32)> 여기서 주의할 점은 여기서 101과 102는 특별 토큰이라는 점입니다. 실제로 해당 토크 나이저의 [CLS] 토큰과 [SEP] 토큰의 번호를 출력해 봅시다. print(tokenizer.cls_token, ':', tokenizer.cls_token_id) print(tokenizer.sep_token, ':' , tokenizer.sep_token_id) [CLS] : 101 [SEP] : 102 위의 정수 인코딩 결과를 다시 디코딩 해보면 현재 입력의 구성을 확인할 수 있습니다. print(tokenizer.decode(encoding['input_ids'][0])) [CLS] in italy, pizza served in formal settings, such as at a restaurant, is presented unsliced. [SEP] pizza is eaten with the use of a knife and fork. in casual settings, however, it is cut into wedges to be eaten while held in the hand. [SEP] BERT에서 두 개의 문장이 입력으로 들어갈 경우에는 맨 앞에는 [CLS] 토큰이 존재하고, 첫 번째 문장이 끝나면 [SEP] 토큰, 그리고 두 번째 문장이 종료되었을 때 다시 추가적으로 [SEP] 토큰이 추가됩니다. 토크 나이저로 변환된 결과에서 token_type_ids를 통해서 문장을 구분하는 세그먼트 인코딩 결과를 확인할 수 있습니다. print(encoding['token_type_ids']) tf.Tensor( [[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1]], shape=(1, 58), dtype=int32) 0이 연속적으로 등장하다가 어느 순간부터 1이 연속적으로 등장하는데, 이는 [CLS] 토큰의 위치부터 첫 번째 문장이 끝나고 나서 등장한 [SEP] 토큰까지의 위치에는 0이 등장하고, 다음 두 번째 문장부터는 1이 등장하는 것입니다. token_type_ids에서는 0과 1로 두 개의 문장을 구분하고 있습니다. 3. 다음 문장 예측하기 이제 TFBertForNextSentencePrediction를 통해서 다음 문장을 예측해 봅시다. 모델에 입력을 넣으면, 해당 모델은 소프트맥스 함수를 지나기 전의 값인 logits을 리턴합니다. 해당 값을 소프트맥스 함수를 통과시킨 후에 각 레이블에 대한 확률 값을 출력해 봅시다. logits = model(encoding['input_ids'], token_type_ids=encoding['token_type_ids'])[0] softmax = tf.keras.layers.Softmax() probs = softmax(logits) print(probs) tf.Tensor([[9.9999714e-01 2.8381858e-06]], shape=(1, 2), dtype=float32) 0번 인덱스에 대한 확률 값이 1번 인덱스에 대한 확률 값보다 훨씬 큽니다. 실질적으로 모델이 예측한 레이블은 0이라는 뜻입니다. 이제 두 개의 값 중 더 큰 값을 모델의 예측값으로 판단하도록 더 큰 확률 값을 가진 인덱스를 리턴하도록 합니다. print('최종 예측 레이블 :', tf.math.argmax(probs, axis=-1).numpy()) 최종 예측 레이블 : [0] 최종 예측 레이블은 0입니다. 이는 BERT가 다음 문장 예측을 학습했을 당시에 실질적으로 이어지는 두 개의 문장의 레이블은 0. 이어지지 않는 두 개의 문장의 경우에는 레이블을 1로 두고서 이진 분류로 학습을 하였기 때문입니다. 이번에는 이어지지 않는 두 개의 문장으로 테스트해 봅시다. 전체적인 과정은 이전과 같습니다. # 상관없는 두 개의 문장 prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced." next_sentence = "The sky is blue due to the shorter wavelength of blue light." encoding = tokenizer(prompt, next_sentence, return_tensors='tf') logits = model(encoding['input_ids'], token_type_ids=encoding['token_type_ids'])[0] softmax = tf.keras.layers.Softmax() probs = softmax(logits) print('최종 예측 레이블 :', tf.math.argmax(probs, axis=-1).numpy()) 최종 예측 레이블 : [1] 17-06 한국어 BERT의 다음 문장 예측(Next Sentence Prediction) 모든 BERT 실습은 Colab에서 진행한다고 가정합니다. 사전 학습된 한국어 BERT를 이용하여 다음 문장 예측을 실습해 봅시다. 이번 실습을 위해서만이 아니라 앞으로 사전 학습된 BERT를 사용할 때는 transformers라는 패키지를 자주 사용하게 됩니다. 실습 환경에 transformers 패키지를 설치해둡시다. pip install transformers 1. 다음 문장 예측 모델과 토크 나이저 transformers 패키지를 사용하여 모델과 토크 나이저를 로드합니다. BERT는 이미 누군가가 학습해둔 모델을 사용하는 것이므로 우리가 사용하는 모델과 토크 나이저는 항상 매핑 관계여야 합니다. import tensorflow as tf from transformers import TFBertForNextSentencePrediction from transformers import AutoTokenizer TFBertForNextSentencePrediction.from_pretrained('BERT 모델 이름')을 넣으면 두 개의 문장이 이어지는 문장 관계인지를 판단하는 BERT 구조를 로드합니다. AutoTokenizer.from_pretrained('모델 이름')을 넣으면 해당 모델이 학습되었을 당시에 사용되었던 토크 나이저를 로드합니다. model = TFBertForNextSentencePrediction.from_pretrained('klue/bert-base', from_pt=True) tokenizer = AutoTokenizer.from_pretrained("klue/bert-base") 2. 다음 문장 예측하기 이제 TFBertForNextSentencePrediction를 통해서 다음 문장을 예측해 봅시다. 모델에 입력을 넣으면, 해당 모델은 소프트맥스 함수를 지나기 전의 값인 logits을 리턴합니다. 해당 값을 소프트맥스 함수를 통과시킨 후 두 개의 값 중 더 큰 값을 모델의 예측값으로 판단하도록 더 큰 확률 값을 가진 인덱스를 리턴하도록 합니다. # 이어지는 두 개의 문장 prompt = "2002년 월드컵 축구 대회는 일본과 공동으로 개최되었던 세계적인 큰 잔치입니다." next_sentence = "여행을 가보니 한국의 2002년 월드컵 축구 대회의 준비는 완벽했습니다." encoding = tokenizer(prompt, next_sentence, return_tensors='tf') logits = model(encoding['input_ids'], token_type_ids=encoding['token_type_ids'])[0] softmax = tf.keras.layers.Softmax() probs = softmax(logits) print('최종 예측 레이블 :', tf.math.argmax(probs, axis=-1).numpy()) 최종 예측 레이블 : [0] 최종 예측 레이블은 0입니다. 이는 BERT가 다음 문장 예측을 학습했을 당시에 실질적으로 이어지는 두 개의 문장의 레이블은 0. 이어지지 않는 두 개의 문장의 경우에는 레이블을 1로 두고서 이진 분류로 학습을 하였기 때문입니다. 이번에는 이어지지 않는 두 개의 문장으로 테스트해 봅시다. # 상관없는 두 개의 문장 prompt = "2002년 월드컵 축구 대회는 일본과 공동으로 개최되었던 세계적인 큰 잔치입니다." next_sentence = "극장 가서 로맨스 영화를 보고 싶어요" encoding = tokenizer(prompt, next_sentence, return_tensors='tf') logits = model(encoding['input_ids'], token_type_ids=encoding['token_type_ids'])[0] softmax = tf.keras.layers.Softmax() probs = softmax(logits) print('최종 예측 레이블 :', tf.math.argmax(probs, axis=-1).numpy()) 최종 예측 레이블 : [1] 17-07 센텐스 버트(Sentence BERT, SBERT) BERT로부터 문장 임베딩을 얻을 수 있는 센텐스 버트(Sentence BERT, SBERT)에 대해서 다룹니다. 1. BERT의 문장 임베딩 BERT로부터 문장 벡터를 얻는 방법은 여러 가지 방법이 존재하지만 여기서는 총 세 가지에 대해서 언급하겠습니다. 만약 사전 학습된 BERT에 'I love you'라는 문장이 입력된다고 하였을 때, 이 문장에 대한 벡터를 얻는 첫 번째 방법은 [CLS] 토큰의 출력 벡터를 문장 벡터로 간주하는 것입니다. 앞서 BERT로 텍스트 분류 문제를 풀 때, [CLS] 토큰의 출력 벡터를 출력층의 입력으로 사용했던 점을 상기해 봅시다. 이는 [CLS] 토큰이 입력된 문장에 대한 총체적 표현이라고 간주하고 있기 때문입니다. 다시 말해 [CLS] 토큰 자체를 입력 문장의 벡터로 간주할 수 있습니다. 문장 벡터를 얻는 두 번째 방법은 [CLS] 토큰만을 사용하는 것이 아니라 BERT의 모든 출력 벡터들을 평균 내는 것입니다. 앞서 9챕터에서 단어 벡터들의 평균을 문장 벡터로 간주할 수 있다고 설명한 바 있습니다. 이는 BERT에서도 적용되는데, BERT의 각 단어에 대한 출력 벡터들에 대해서 평균을 내고 이를 문장 벡터로 볼 수 있습니다. 위 그림에서는 출력 벡터들의 평균을 'pooling'이라고 표현했습니다. 이를 평균 풀링(mean pooling)을 하였다고 표현하기도 합니다. 그런데 풀링에는 평균 풀링만 있는 것이 아니라 11챕터의 합성곱 신경망을 다룰 때 설명했던 맥스 풀링(max pooling) 또한 존재합니다. 세 번째 방법은 BERT의 각 단어의 출력 벡터들에 대해서 평균 풀링 대신 맥스 풀링을 진행한 벡터를 얻는 것입니다. 정리하면 사전 학습된 BERT로부터 문장 벡터를 얻는 방법은 다음과 같이 세 가지가 있습니다. BERT의 [CLS] 토큰의 출력 벡터를 문장 벡터로 간주한다. BERT의 모든 단어의 출력 벡터에 대해서 평균 풀링을 수행한 벡터를 문장 벡터로 간주한다. BERT의 모든 단어의 출력 벡터에 대해서 맥스 풀링을 수행한 벡터를 문장 벡터로 간주한다. 이때 평균 풀링을 하느냐와 맥스 풀링을 하느냐에 따라서 해당 문장 벡터가 가지는 의미는 다소 다른데, 평균 풀링을 얻은 문장 벡터의 경우에는 모든 단어의 의미를 반영하는 쪽에 가깝다면, 맥스 풀링을 얻은 문장 벡터의 경우에는 중요한 단어의 의미를 반영하는 쪽에 가깝습니다. 2. SBERT(센텐스 버트, Sentence-BERT) SBERT는 기본적으로 BERT의 문장 임베딩의 성능을 우수하게 개선한 모델입니다. SBERT는 위에서 언급한 BERT의 문장 임베딩을 응용하여 BERT를 파인 튜닝합니다. SBERT가 어떤 식으로 학습되는지 정리해 봅시다. 1) 문장 쌍 분류 태스크로 파인 튜닝 SBERT를 학습하는 첫 번째 방법은 문장 쌍 분류 태스크. 대표적으로는 NLI(Natural Language Inferencing) 문제를 푸는 것입니다. 다음 챕터에서 한국어 버전의 NLI 데이터인 KorNLI 문제를 BERT로 풀어볼 예정입니다. NLI는 두 개의 문장이 주어지면 수반(entailment) 관계인지, 모순(contradiction) 관계인지, 중립(neutral) 관계인지를 맞추는 문제입니다. 다음은 NLI 데이터의 예시입니다. 문장 A 문장 B 레이블 A lady sits on a bench that is against a shopping mall. A person sits on the seat. Entailment A lady sits on a bench that is against a shopping mall. A woman is sitting against a building. Entailment A lady sits on a bench that is against a shopping mall. Nobody is sitting on the bench. Contradiction Two women are embracing while holding to go packages. The sisters are hugging goodbye while holding to go packages after just eating lunch. Neutral SBERT는 NLI 데이터를 학습하기 위해 다음과 같은 구조를 가집니다. 우선 문장 A와 문장 B 각각을 BERT의 입력으로 넣고, 앞서 BERT의 문장 임베딩을 얻기 위한 방식이라고 언급했던 평균 풀링 또는 맥스 풀링을 통해서 각각에 대한 문장 임베딩 벡터를 얻습니다. 여기서는 이를 각각 u와 v라고 합시다. 그러고 나서 u 벡터와 v 벡터의 차이 벡터를 구합니다. 이 벡터는 수식으로 표현하면 |u-v|입니다. 그리고 이 세 가지 벡터를 연결(concatenation) 합니다. 세미콜론(;)을 연결 기호로 한다면 연결된 벡터의 수식은 다음과 같습니다. = ( ; ; u v) 만약 BERT의 문장 임베딩 벡터의 차원이 이라면 세 개의 벡터를 연결한 벡터의 차원은 n 이 됩니다. 그리고 이 벡터를 출력층으로 보내 다중 클래스 분류 문제를 풀도록 합니다. 다시 말해 분류하고자 하는 클래스의 개수가 라면, 가중치 행렬 n k 의 크기를 가지는 행렬 y 을 곱한 후에 소프트맥스 함수를 통과시킨다고도 볼 수 있습니다. 식으로 표현하면 다음과 같습니다. = o t a ( y) 이제 실제 값에 해당하는 레이블로부터 오차를 줄이는 방식으로 학습시킵니다. 2) 문장 쌍 회귀 태스크로 파인 튜닝 SBERT를 학습하는 두 번째 방법은 문장 쌍으로 회귀 문제를 푸는 것으로 대표적으로 STS(Semantic Textual Similarity) 문제를 푸는 경우입니다. STS란 두 개의 문장으로부터 의미적 유사성을 구하는 문제를 말합니다. 다음은 STS 데이터의 예시입니다. 여기서 레이블은 두 문장의 유사도로 범위 값은 0~5입니다. 문장 A 문장 B 레이블 A plane is taking off. An air plane is taking off. 5.00 A man is playing a large flute. A man is playing a flute. 3.80 A man is spreading shreded cheese on a pizza. A man is spreading shredded cheese on an uncoo... 3.80 Three men are playing chess. Two men are playing chess. 2.60 A man is playing the cello. A man seated is playing the cello. 4.25 참고) 한국어 버전의 STS 데이터 셋인 KorSTS 데이터 셋도 있으므로 아래 링크를 참고하세요. 링크 : https://github.com/kakaobrain/KorNLUDatasets SBERT는 STS 데이터를 학습하기 위해 다음과 같은 구조를 가집니다. 문장 A와 문장 B 각각을 BERT의 입력으로 넣고, 평균 풀링 또는 맥스 풀링을 통해서 각각에 대한 문장 임베딩 벡터를 얻습니다. 이를 각각 u와 v라고 하였을 때 이 두 벡터의 코사인 유사도를 구합니다. 그리고 해당 유사도와 레이블 유사도와의 평균 제곱 오차(Mean Squared Error, MSE)를 최소화하는 방식으로 학습합니다. 코사인 유사도의 값의 범위는 -1과 1사이므로 위 데이터와 같이 레이블 스코어의 범위가 0~5점이라면 학습 전 해당 레이블들의 값들을 5로 나누어 값의 범위를 줄인 후 학습할 수 있습니다. 선택에 따라서 1) 문장 쌍 분류 태스크로만 파인 튜닝 할 수도 있고, 2) 문장 쌍 회귀 태스크로만 파인 튜닝 할 수도 있으며 1)을 학습한 후에 2)를 학습하는 전략을 세울 수도 있습니다. 뒤에서 파인 튜닝된 SBERT를 이용하여 한국어 챗봇을 구현하는 실습을 진행해 보겠습니다. 18. 실전! BERT 실습하기 이전 챕터에서 배웠던 BERT의 이론적 지식을 바탕으로 BERT로 풀 수 있는 다양한 문제들을 풀어봅시다. 기본적으로 transformers 패키지를 사용하여 트랜스포머 계열들의 모델을 사용하는 방법은 이번 챕터에서 배우게 될 BERT의 사용법과 크게 다르지 않습니다. 이번 챕터에서 학습한 내용을 바탕으로 Huggingface의 transformers 공식 문서 링크를 참고한다면, 풀고자 하는 문제에 맞는 최고 성능의 모델들을 손쉽게 사용할 수 있습니다. Huggingface의 공식 문서 링크 : https://huggingface.co/docs/transformers/index 이번 18챕터의 모든 실습은 구글의 Colab에서 진행한다고 가정합니다. 다른 챕터와 마찬가지로 18챕터의 모든 실습 코드들은 저자의 깃허브에 업로드돼 있으니 참고하세요. 18챕터는 특히 저자의 깃허브를 함께 참고하면서 학습하시는 것을 권장 드립니다. e-book에서 지면의 한계상 설명하지 못했던 여러 변형 버전의 코드들도 저자의 깃허브에는 추가돼 있으므로 반드시 참고하여 실습하시기 바랍니다. 저자의 깃허브 : https://github.com/ukairia777/tensorflow-nlp-tutorial 18-01 코랩(Colab)에서 TPU 사용하기 지금까지는 GPU 사용만으로도 모델을 학습하는데 큰 무리가 없었지만, BERT의 경우 지금까지 사용한 모델보다 무거운 편입니다. 다시 말해 학습 속도가 상대적으로 느린 편입니다. 이번 챕터에서는 Colab에서 GPU보다 더 빠른 TPU도 사용해 보겠습니다. 1. 코랩(Colab)에서 TPU를 선택 Colab에서 GPU를 사용하기 위해서 런타임 유형 변경에서 GPU를 선택하였듯이 TPU를 사용하기 위해서는 TPU를 선택합니다. Colab에서 런타임 > 런타임 유형 변경 > 하드웨어 가속기에서 'TPU' 선택 GPU를 사용할 때는 런타임 유형 변경에서 GPU를 선택하는 것만으로 GPU를 사용할 수 있었지만, TPU의 경우에는 런타임 유형 변경에서 TPU를 선택한다고 바로 사용할 수 있는 것이 아닙니다. 아래에서 안내할 추가적인 코드 설정을 해주지 않으시면 실제로는 TPU를 사용하지 않으므로 아래의 코드 설정을 반드시 해주세요. 2. TPU 초기화 딥 러닝 모델을 정의하기 전에 아래의 설정을 미리 해주어야 하므로 아래의 코드는 초반부에 실행해 줍니다. import tensorflow as tf import os resolver = tf.distribute.cluster_resolver.TPUClusterResolver(tpu='grpc://' + os.environ['COLAB_TPU_ADDR']) tf.config.experimental_connect_to_cluster(resolver) tf.tpu.experimental.initialize_tpu_system(resolver) 3. TPU Strategy 세팅 tf.distribute.Strategy는 훈련을 여러 GPU 또는 여러 장비, 여러 TPU로 나누어 처리하기 위한 텐서 플로 API입니다. 이 API를 사용하면 기존의 모델이나 훈련 코드를 분산처리를 할 수 있습니다. TPU 사용을 위해서도 Strategy를 세팅해 줍니다. strategy = tf.distribute.TPUStrategy(resolver) 4. 딥 러닝 모델의 컴파일 딥 러닝 모델을 컴파일을 할 때도 추가적인 코드가 필요합니다. 모델의 컴파일은 strategy.scope 내에서 이루어져야 합니다. 이는 모델의 층을 쌓는 create_model()와 같은 함수를 만들어 strategy.scope 내에서 해당 함수를 호출하여 모델을 컴파일하는 방식으로 할 수 있습니다. 예시를 들어봅시다. 다음과 같이 모델의 층을 쌓는 create_model()라는 함수를 만듭니다. def create_model(): return tf.keras.Sequential( [tf.keras.layers.Conv2D(256, 3, activation='relu', input_shape=(28, 28, 1)), tf.keras.layers.Conv2D(256, 3, activation='relu'), tf.keras.layers.Flatten(), tf.keras.layers.Dense(256, activation='relu'), tf.keras.layers.Dense(128, activation='relu'), tf.keras.layers.Dense(10)]) with strategy.scope(): 다음에 들여 쓰기를 하고, create_model() 함수를 호출하고 모델을 컴파일합니다. 다시 말해 strategy.scope 내에서 모델을 컴파일합니다. with strategy.scope(): model = create_model() model.compile(optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=['sparse_categorical_accuracy']) 이 모델을 fit() 하게 되면 해당 모델은 TPU를 사용하며 학습하게 됩니다! 앞으로 Colab에서 TPU를 사용하여 BERT 모델을 파인 튜닝 할 때에도 위 과정과 동일한 과정을 거칩니다. 위의 1~3번까지의 코드를 실행하고, BERT와 커스텀 레이어에 대한 모델의 컴파일을 strategy.scope 내에서 진행합니다. 5. GPU 실습 코드로 되돌리기 이번 챕터에서 TPU로 실습을 진행한 코드들을 GPU 환경에서 실습하고 싶다면, 위에서 모델의 층을 쌓고, 컴파일하는 코드를 제외한 TPU 진행만을 위한 코드들을 전부 제거해 주면 됩니다. 18-02 transformers의 모델 클래스 불러오기 transformers 라이브러리에서는 각종 태스크에 맞게 BERT 위에 출력층을 추가한 모델 클래스 구현체를 제공하고 있습니다. 아래의 구현체를 사용하면 사용자가 별도의 출력층을 설계할 필요 없이 태스크에 맞게 모델을 로드하여 사용할 수 있습니다. 이 책에서는 모델 구조의 이해를 위해 모든 실습에서 출력층을 직접 설계하여 실습을 진행하지만, 이미 모델의 구조를 이해한 상황에서는 아래와 같이 이미 출력층이 설계된 모델들을 사용하는 것이 훨씬 코드 작성이 간편합니다. 저자의 깃허브에서 파일명에 'model_from_transformers'가 들어간 파일들이 아래의 구현체들을 사용한 실습 파일입니다. 1. 다 대 일 유형 다 대 일(many-to-one) 유형은 텍스트 분류에 주로 사용되는 모델입니다. '18-4. TFBertForSequenceClassification' 실습에서는 아래의 모델을 사용해 봅니다. from transformers import TFBertForSequenceClassification model = TFBertForSequenceClassification.from_pretrained("모델 이름", num_labels=분류할 레이블의 개수) 2. 다 대다 유형 다 대다(many-to-one) 유형은 다수의 입력에 대해서 다수의 출력이 필요할 때 사용하는 모델입니다. '18-6. 개체명 인식'이 해당 모델을 사용하는 대표적인 예시입니다. from transformers import TFBertForTokenClassification model = TFBertForTokenClassification.from_pretrained("모델 이름", num_labels=분류할 레이블의 개수) 3. 질의응답 유형 질의응답(Question Answering) 문제를 풀기 위해 사용하는 모델로 '18-7. 기계 독해' 실습이 해당 모델을 사용할 수 있는 대표적인 예시입니다. from transformers import TFBertForQuestionAnswering model = TFBertForQuestionAnswering.from_pretrained('모델 이름') 18-03 KoBERT를 이용한 네이버 영화 리뷰 분류하기 죄송합니다. 해당 자료는 위키독스 웹 사이트에서는 비공개 처리되어 구현 코드와 코드에 대한 상세한 설명은 유료 E-book을 구매하시면 확인할 수 있습니다. 한국어 BERT를 이용하여 네이버 영화 리뷰 분류에서 테스트 데이터에서 90%에 가까운 성능을 얻는 실습입니다. 18-04 TFBertForSequenceClassification 죄송합니다. 해당 자료는 위키독스 웹 사이트에서는 비공개 처리되어 구현 코드와 코드에 대한 상세한 설명은 유료 E-book을 구매하시면 확인할 수 있습니다. 18-05 KoBERT를 이용한 KorNLI 풀어보기 (다중 클래스 분류) 죄송합니다. 해당 자료는 위키독스 웹 사이트에서는 비공개 처리되어 구현 코드와 코드에 대한 상세한 설명은 유료 E-book을 구매하시면 확인할 수 있습니다. 18-06 KoBERT를 이용한 개체명 인식(Named Entity Recognition) 한국어 BERT를 이용하여 개체명 인식을 학습하는 실습입니다. 죄송합니다. 해당 자료는 위키독스 웹 사이트에서는 비공개 처리되어 구현 코드와 코드에 대한 상세한 설명은 유료 E-book을 구매하시면 확인할 수 있습니다. 18-07 KoBERT를 이용한 기계 독해(Machine Reading Comprehension) KorQuad 1.0 데이터를 학습하여 사용자의 질문으로부터 본문으로부터 정답을 찾아 대답하는 모델을 구현합니다. 현업에서는 기계 독해를 통해 챗봇을 구현하기도 합니다. 죄송합니다. 해당 자료는 위키독스 웹 사이트에서는 비공개 처리되어 구현 코드와 코드에 대한 상세한 설명은 유료 E-book을 구매하시면 확인할 수 있습니다. 결과 예시 본문 : [CLS] " 내각과 장관들이 소외되고 대통령 비서실의 권한이 너무 크다 ", " 행보가 비서 본연의 역할을 벗어난다 "라는 의견이 제기되었다. 대표적인 예가 10차 개헌안 발표이다. 원로 헌법학자인 허영 경희대 석좌교수는 정부의 헌법 개정안 준비 과정에 대해 " 청와대 비서실이 아닌 국무회의 중심으로 이뤄졌어야 했다 "라고 지적했다.'국무회의의 심의를 거쳐야 한다'( 제89조 )는 헌법 규정에 충실하지 않았다는 것이다. 그러면서 " 법무부 장관을 제쳐놓고 민정수석이 개정안을 설명하는 게 이해가 안 된다 "라고 지적했다. 민정수석은 국회의원에 대해 책임지는 법무부 장관도 아니고, 국민에 대해 책임지는 사람도 아니기 때문에 정당성이 없고, 단지 대통령의 신임이 있을 뿐이라는 것이다. 또한 국무총리 선출 방식에 대한 기자의 질문에 " 문 대통령도 취임 전에 국무총리에게 실질적 권한을 주겠다고 했지만 그러지 못하고 있다. 대통령 비서실장만도 못한 권한을 행사하고 있다. "라고 답변했다. 질문 : 국무회의의 심의를 거쳐야 한다는 헌법 제 몇 조의 내용인가? 정답 : 제89조 예측 : 제89조 ---------------------------------------- 본문 : [CLS] " 내각과 장관들이 소외되고 대통령 비서실의 권한이 너무 크다 ", " 행보가 비서 본연의 역할을 벗어난다 "라는 의견이 제기되었다. 대표적인 예가 10차 개헌안 발표이다. 원로 헌법학자인 허영 경희대 석좌교수는 정부의 헌법 개정안 준비 과정에 대해 " 청와대 비서실이 아닌 국무회의 중심으로 이뤄졌어야 했다 "라고 지적했다.'국무회의의 심의를 거쳐야 한다'( 제89조 )는 헌법 규정에 충실하지 않았다는 것이다. 그러면서 " 법무부 장관을 제쳐놓고 민정수석이 개정안을 설명하는 게 이해가 안 된다 "라고 지적했다. 민정수석은 국회의원에 대해 책임지는 법무부 장관도 아니고, 국민에 대해 책임지는 사람도 아니기 때문에 정당성이 없고, 단지 대통령의 신임이 있을 뿐이라는 것이다. 또한 국무총리 선출 방식에 대한 기자의 질문에 " 문 대통령도 취임 전에 국무총리에게 실질적 권한을 주겠다고 했지만 그러지 못하고 있다. 대통령 비서실장만도 못한 권한을 행사하고 있다. "라고 답변했다. 질문 : 법무부 장관을 제쳐놓고 민정수석이 개정안을 설명하는 게 이해가 안 된다고 지적한 경희대 석좌교수 이름은? 정답 : 허영 예측 : 허영 ---------------------------------------- 본문 : [CLS] 알렉산더 메이그스 헤이그 2세 ( 영어 : Alexander Meigs Haig, Jr., 1924년 12월 2일 ~ 2010년 2월 20일 )는 미국의 국무 장관을 지낸 미국의 군인, 관료 및 정치인이다. 로널드 레이건 대통령 밑에서 국무장관을 지냈으며, 리처드 닉슨과 제럴드 포드 대통령 밑에서 백악관 비서실장을 지냈다. 또한 그는 미국 군대에서 2번째로 높은 직위인 미국 육군 부참모 총장과 나토 및 미국 군대의 유럽연합군 최고사령관이었다. 한국 전쟁 시절 더글러스 맥아더 유엔군 사령관의 참모로 직접 참전하였으며, 로널드 레이건 정부 출범 당시 초대 국무장관직을 맡아 1980년대 대한민국과 미국의 관계를 조율해 왔다. 저서로 회고록 《 경고 : 현실주의, 레이건과 외교 정책 》 ( 1984년 발간 ) 이 있다. 질문 : 미국 군대 내 두 번째로 높은 직위는 무엇인가? 정답 : 미국 육군 부참모 총장 예측 : 육군 부참모 총장 ---------------------------------------- 본문 : [CLS] 알렉산더 메이그스 헤이그 2세 ( 영어 : Alexander Meigs Haig, Jr., 1924년 12월 2일 ~ 2010년 2월 20일 )는 미국의 국무 장관을 지낸 미국의 군인, 관료 및 정치인이다. 로널드 레이건 대통령 밑에서 국무장관을 지냈으며, 리처드 닉슨과 제럴드 포드 대통령 밑에서 백악관 비서실장을 지냈다. 또한 그는 미국 군대에서 2번째로 높은 직위인 미국 육군 부참모 총장과 나토 및 미국 군대의 유럽연합군 최고사령관이었다. 한국 전쟁 시절 더글러스 맥아더 유엔군 사령관의 참모로 직접 참전하였으며, 로널드 레이건 정부 출범 당시 초대 국무장관직을 맡아 1980년대 대한민국과 미국의 관계를 조율해 왔다. 저서로 회고록 《 경고 : 현실주의, 레이건과 외교 정책 》 ( 1984년 발간 ) 이 있다. 질문 : 로널드 레이건 정부 출범 당시 알렉산더 헤이그는 어떤 직책을 맡았는가? 정답 : 초대 국무장관직 예측 : 국무장관직 ---------------------------------------- 본문 : [CLS] 알렉산더 메이그스 헤이그 2세 ( 영어 : Alexander Meigs Haig, Jr., 1924년 12월 2일 ~ 2010년 2월 20일 )는 미국의 국무 장관을 지낸 미국의 군인, 관료 및 정치인이다. 로널드 레이건 대통령 밑에서 국무장관을 지냈으며, 리처드 닉슨과 제럴드 포드 대통령 밑에서 백악관 비서실장을 지냈다. 또한 그는 미국 군대에서 2번째로 높은 직위인 미국 육군 부참모 총장과 나토 및 미국 군대의 유럽연합군 최고사령관이었다. 한국 전쟁 시절 더글러스 맥아더 유엔군 사령관의 참모로 직접 참전하였으며, 로널드 레이건 정부 출범 당시 초대 국무장관직을 맡아 1980년대 대한민국과 미국의 관계를 조율해 왔다. 저서로 회고록 《 경고 : 현실주의, 레이건과 외교 정책 》 ( 1984년 발간 ) 이 있다. 질문 : 알렉산더 헤이그는 어느 대통령의 밑에서 국무장관을 지냈는가? 정답 : 로널드 레이건 대통령 예측 : 로널드 레이건 ---------------------------------------- 본문 : [CLS] 알렉산더 메이그스 헤이그 2세 ( 영어 : Alexander Meigs Haig, Jr., 1924년 12월 2일 ~ 2010년 2월 20일 )는 미국의 국무 장관을 지낸 미국의 군인, 관료 및 정치인이다. 로널드 레이건 대통령 밑에서 국무장관을 지냈으며, 리처드 닉슨과 제럴드 포드 대통령 밑에서 백악관 비서실장을 지냈다. 또한 그는 미국 군대에서 2번째로 높은 직위인 미국 육군 부참모 총장과 나토 및 미국 군대의 유럽연합군 최고사령관이었다. 한국 전쟁 시절 더글러스 맥아더 유엔군 사령관의 참모로 직접 참전하였으며, 로널드 레이건 정부 출범 당시 초대 국무장관직을 맡아 1980년대 대한민국과 미국의 관계를 조율해 왔다. 저서로 회고록 《 경고 : 현실주의, 레이건과 외교 정책 》 ( 1984년 발간 ) 이 있다. 질문 : 로널드 레이건 대통령 밑에서 일한 국무 장관은 누구인가? 정답 : 알렉산더 메이그스 헤이그 2세 예측 : 알렉산더 메이그스 헤이그 2세 ---------------------------------------- 18-08 BERT의 문장 임베딩(SBERT)을 이용한 한국어 챗봇 SBERT를 이용하여 문장 임베딩을 얻을 수 있는 패키지인 sentence_transformers를 사용하여 쉽고 간단하게 한국어 챗봇을 구현해 봅시다. 실습에 앞서 sentence_transformers를 설치합니다. pip install sentence_transformers 트랜스포머를 이용한 한국어 챗봇 실습에서 사용했던 데이터를 그대로 사용합니다. import numpy as np import pandas as pd from numpy import dot from numpy.linalg import norm import urllib.request from sentence_transformers import SentenceTransformer urllib.request.urlretrieve("https://raw.githubusercontent.com/songys/Chatbot_data/master/ChatbotData.csv", filename="ChatBotData.csv") train_data = pd.read_csv('ChatBotData.csv') train_data.head() 문장 임베딩을 얻기 위해서 사전 훈련된 BERT를 로드합니다. 여기서는 한국어도 포함되어 학습된 다국어 모델을 로드합니다. model = SentenceTransformer('sentence-transformers/xlm-r-100langs-bert-base-nli-stsb-mean-tokens') 모델의 이름은 'xlm-r-100langs-bert-base-nli-stsb-mean-tokens'인데 이름이 의미하는 바는 100가지 언어를 지원(한국어 포함) 하는 다국어 BERT BASE 모델로 SNLI 데이터를 학습 후 STS-B 데이터로 학습되었으며, 문장 표현을 얻기 위해서는 평균 풀링(mean-tokens)을 사용했다는 의미입니다. 다시 말해서 NLI 데이터를 학습 후에 STS 데이터로 추가 파인 튜닝한 모델이라는 의미입니다. SentenceTransformer로 로드할 수 있는 다양한 모델에 대한 리스트는 아래의 링크에서 확인 가능합니다. 해당 링크에 한국어 버전의 모델들 또한 공개되어 있으니 방문해 보세요. 링크 : https://huggingface.co/models? library=sentence-transformers 데이터에서 모든 질문열. 즉, train_data['Q']에 대해서 문장 임베딩 값을 구한 후 embedding이라는 새로운 열에 저장합니다. train_data['embedding'] = train_data.apply(lambda row: model.encode(row.Q), axis = 1) 두 개의 벡터로부터 코사인 유사도를 구하는 함수 cos_sim를 정의합니다. def cos_sim(A, B): return dot(A, B)/(norm(A)*norm(B)) return_answer 함수는 임의의 질문이 들어오면 해당 질문의 문장 임베딩 값과 챗봇 데이터의 임베딩 열. 즉, train_data['embedding']에 저장해둔 모든 질문 샘플들의 문장 임베딩 값들을 전부 비교하여 코사인 유사도 값이 가장 높은 질문 샘플을 찾아냅니다. 그리고 해당 질문 샘플과 짝이 되는 답변 샘플을 리턴합니다. def return_answer(question) embedding = model.encode(question) train_data['score'] = train_data.apply(lambda x: cos_sim(x['embedding'], embedding), axis=1) return train_data.loc[train_data['score'].idxmax()]['A'] 이제 챗봇을 테스트해 봅시다. return_answer('결혼하고 싶어') 좋은 사람이랑 결혼할 수 있을 거예요. return_answer('나랑 커피 먹을래?') 카페인이 필요한 시간인가 봐요. return_answer('반가워') 저도 반가워요. return_answer('사랑해') 상대방에게 전해보세요. return_answer('너는 누구니?') 저는 위 로봇입니다. return_answer('너무 짜증 나') 짜증 날 땐 짜장면 return_answer('화가 납니다') 화를 참는 연습을 해보세요. return_answer('나랑 놀자') 지금 그러고 있어요. return_answer('나랑 게임하자') 같이 놀아요. return_answer('출근하기 싫어') 씻고 푹 쉬세요. return_answer('여행 가고 싶다') 이김에 떠나보세요. return_answer('너 말 잘한다') 그런 사람이 있으면 저 좀 소개해 주세요. 짧은 질문들이지만 대부분의 질문에서 그럴듯한 답변을 하는 모습을 확인할 수 있었습니다. 18-09 Faiss와 SBERT를 이용한 시맨틱 검색기(Semantic Search) 시맨틱 검색(Semantic search)은 기존의 키워드 매칭이 아닌 문장의 의미에 초점을 맞춘 정보 검색 시스템을 말합니다. 여기서는 SBERT와 FAISS를 사용하여 간단한 검색 엔진을 구현해 봅시다. Faiss는 벡터화된 데이터를 인덱싱하고 데이터에 대한 효율적인 검색을 수행하기 위해 Facebook AI에서 구축한 C ++ 기반 라이브러리입니다. 우선 필요한 라이브러리를 설치합니다. CPU 환경에서 진행하신다면 faiss-gpu가 아니라 faiss-cpu를 설치하시기 바랍니다 !pip install faiss-gpu !pip install -U sentence-transformers 1. 데이터 로드 import numpy as np import os import pandas as pd import urllib.request import faiss import time from sentence_transformers import SentenceTransformer 여기서는 약 100만 개의 뉴스 기사 제목 데이터를 사용합니다. 데이터를 로드하여 리스트 형태로 변환하겠습니다. urllib.request.urlretrieve("https://raw.githubusercontent.com/ukairia777/tensorflow-nlp-tutorial/main/19.%20TopiC%20Modeling%20(LDA% 2C%20BERT-Based)/dataset/abcnews-date-text.csv", filename="abcnews-date-text.csv") df = pd.read_csv("abcnews-date-text.csv") data = df.headline_text.to_list() 상위 5개의 샘플을 출력해 봅시다. # 상위 5개의 샘플 출력 data[:5] ['aba decides against community broadcasting licence', 'act fire witnesses must be aware of defamation', 'a g calls for infrastructure protection summit', 'air nz staff in aust strike for pay rise', 'air nz strike to affect australian travellers'] 샘플 수를 확인해 보면 약 108만 개가 존재합니다. print('총 샘플의 개수 :', len(data)) 총 샘플의 개수 : 1082168 2. SBERT 임베딩 모든 샘플에 대해서 SBERT로 임베딩을 진행합니다. model = SentenceTransformer('distilbert-base-nli-mean-tokens') encoded_data = model.encode(data) print('임베딩 된 벡터 수 :', len(encoded_data)) 임베딩 된 벡터 수 : 1082168 3. 인덱스 정의 및 데이터 추가 인덱스를 정의하고 여기에 데이터를 추가합니다. index = faiss.IndexIDMap(faiss.IndexFlatIP(768)) index.add_with_ids(encoded_data, np.array(range(0, len(data)))) faiss.write_index(index, 'abc_news') 4. 검색 및 시간 측정 실제 검색을 진행해 보고 시간을 측정해 봅시다. 여기서는 주어진 쿼리에 대해서 유사도가 높은 상위 5개의 샘플을 추출하겠습니다. def search(query): t = time.time() query_vector = model.encode([query]) k = 5 top_k = index.search(query_vector, k) print('total time: {}'.format(time.time() - t)) return [data[_id] for _id in top_k[1].tolist()[0]] query = str(input()) results = search(query) print('results :') for result in results: print('\t', result) 'Underwater Forest Discovered'라는 임의의 문장을 입력해 보겠습니다. Underwater Forest Discovered total time: 1.069244384765625 results : underwater loop thriving underwater antarctic garden discovered baton goes underwater in wa underwater footage shows inside doomed costa underwater uluru found off wa coast 약 108만 개의 문서에 대해서 시맨틱 검색을 수행하였음에도 약 1초 내외의 시간밖에 걸리지 않았습니다. 19. 토픽 모델링(Topic Modeling) 토픽(Topic)은 한국어로는 주제라고 합니다. 토픽 모델링(Topic Modeling)이란 기계 학습 및 자연어 처리 분야에서 토픽이라는 문서 집합의 추상적인 주제를 발견하기 위한 통계적 모델 중 하나로, 텍스트 본문의 숨겨진 의미 구조를 발견하기 위해 사용되는 텍스트 마이닝 기법입니다. 19-01 잠재 의미 분석(Latent Semantic Analysis, LSA) LSA는 정확히는 토픽 모델링을 위해 최적화된 알고리즘은 아니지만, 토픽 모델링이라는 분야에 아이디어를 제공한 알고리즘이라고 볼 수 있습니다. 이에 토픽 모델링 알고리즘인 LDA에 앞서 배워보도록 하겠습니다. 뒤에서 배우게 되는 LDA는 LSA의 단점을 개선하여 탄생한 알고리즘으로 토픽 모델링에 보다 적합한 알고리즘입니다. BoW에 기반한 DTM이나 TF-IDF는 기본적으로 단어의 빈도 수를 이용한 수치화 방법이기 때문에 단어의 의미를 고려하지 못한다는 단점이 있었습니다. (이를 토픽 모델링 관점에서는 단어의 토픽을 고려하지 못한다고도 합니다.) 이를 위한 대안으로 DTM의 잠재된(Latent) 의미를 이끌어내는 방법으로 잠재 의미 분석(Latent Semantic Analysis, LSA)이라는 방법이 있습니다. 잠재 의미 분석(Latent Semantic Indexing, LSI)이라고 부르기도 합니다. 이하 LSA라고 명명하겠습니다. 이 방법을 이해하기 위해서는 선형대수학의 특이 값 분해(Singular Value Decomposition, SVD)를 이해할 필요가 있습니다. 이하 이를 SVD라고 명명하겠습니다. 이 실습에서는 SVD를 수행하는 구체적인 선형대수학에 대해서는 설명하지 않고, SVD가 갖고 있는 의미를 이해하는 것에 초점을 맞춥니다. 1. 특이 값 분해(Singular Value Decomposition, SVD) 시작하기 앞서, 여기서의 특이 값 분해(Singular Value Decomposition, SVD)는 실수 벡터 공간에 한정하여 내용을 설명함을 명시합니다. SVD란 A가 m × n 행렬일 때, 다음과 같이 3개의 행렬의 곱으로 분해(decomposition) 하는 것을 말합니다. = Σ T 여기서 각 3개의 행렬은 다음과 같은 조건을 만족합니다. 직교행렬 : × 직교행렬 ( A = ( Σ) T ) 직교행렬 : × 직교행렬 ( T = ( T) T ) 직사각 대각행렬 : × 직사각 대각행렬 여기서 직교행렬(orthogonal matrix)이란 자신과 자신의 전치 행렬(transposed matrix)의 곱 또는 이를 반대로 곱한 결과가 단위행렬(identity matrix)이 되는 행렬을 말합니다. 또한 대각행렬(diagonal matrix)이란 주대각선을 제외한 곳의 원소가 모두 0인 행렬을 의미합니다. 이때 SVD로 나온 대각 행렬의 대각 원소의 값을 행렬 A의 특이 값(singular value)라고 합니다. 많은 용어가 한꺼번에 나와서 복잡해 보이는데 차근, 차근 용어를 정리해 보도록 하겠습니다. 1) 전치 행렬(Transposed Matrix) 전치 행렬(transposed matrix)은 원래의 행렬에서 행과 열을 바꾼 행렬입니다. 즉, 주대각선을 축으로 반사 대칭을 하여 얻는 행렬입니다. 기호는 기존 행렬 표현의 우측 위에를 붙입니다. 예를 들어서 기존의 행렬을이라고 한다면, 전치 행렬은 T 와 같이 표현합니다. = [ 2 4 6 ] M = [ 3 5 4 6 ] 2) 단위행렬(Identity Matrix) 단위행렬(identity matrix)은 주대각선의 원소가 모두 1이며 나머지 원소는 모두 0인 정사각 행렬을 말합니다. 보통 줄여서 대문자로 표현하기도 하는데, 2 × 2 단위행렬과 3 × 3 단위행렬을 표현해 보면 다음과 같습니다. = [ 0 1 ] I [ 0 0 1 0 0 1 ] 3) 역행렬(Inverse Matrix) 단위행렬(identity matrix)를 이해했다면 역행렬(inverse matrix)을 정의할 수 있습니다. 만약 행렬 와 어떤 행렬을 곱했을 때, 결과로서 단위행렬이 나온다면 이때의 어떤 행렬을 의 역행렬이라고 하며, −라고 표현합니다. × − = [ 2 3 5 6 8 9 ] [ ? ] [ 0 0 1 0 0 1 ] 4) 직교 행렬(Orthogonal matrix) 다시 직교 행렬(orthogonal matrix)의 정의로 돌아가서, 실수 × 행렬에 대해서 × T I 를 만족하면서 T A I 을 만족하는 행렬 를 직교 행렬이라고 합니다. 그런데 역행렬의 정의를 다시 생각해 보면, 결국 직교 행렬은 − = T 를 만족합니다. 5) 대각 행렬(Diagonal matrix) 대각행렬(diagonal matrix)은 주대각선을 제외한 곳의 원소가 모두 0인 행렬을 말합니다. 아래의 그림에서는 주대각선의 원소를 라고 표현하고 있습니다. 만약 대각 행렬 Σ가 3 × 3 행렬이라면, 다음과 같은 모양을 가집니다. = [ 0 0 a 0 0 a ] 여기까진 정사각 행렬이기 때문에 직관적으로 이해가 쉽습니다. 그런데 정사각 행렬이 아니라 직사각 행렬이 될 경우를 잘 보아야 헷갈리지 않습니다. 만약 행의 크기가 열의 크기보다 크다면 다음과 같은 모양을 가집니다. 즉, m × n 행렬일 때, m > n인 경우입니다. = [ 0 0 a 0 0 a 0 0 ] 반면 n > m인 경우에는 다음과 같은 모양을 가집니다. = [ 0 0 0 a 0 0 0 a 0 ] 여기까지는 일반적인 대각 행렬에 대한 정의입니다. SVD를 통해 나온 대각 행렬 Σ는 추가적인 성질을 가지는데, 대각 행렬 Σ의 주대 각원소를 행렬 A의 특이 값(singular value)라고 하며, 이르려고 표현한다고 하였을 때 특이 값 은 내림차순으로 정렬되어 있다는 특징을 가집니다. 아래의 그림은 특이 값 12.4, 9.5, 1.3이 내림차순으로 정렬돼 있는 모습을 보여줍니다. = [ 12.4 0 0 9.5 0 0 1.3 ] 2. 절단된 SVD(Truncated SVD) 위에서 설명한 SVD를 풀 SVD(full SVD)라고 합니다. 하지만 LSA의 경우 풀 SVD에서 나온 3개의 행렬에서 일부 벡터들을 삭제시킨 절단된 SVD(truncated SVD)를 사용하게 됩니다. 그림을 통해 이해해 보도록 하겠습니다. 절단된 SVD는 대각 행렬 Σ의 대각 원소의 값 중에서 상위 값 t 개만 남게 됩니다. 절단된 SVD를 수행하면 값의 손실이 일어나므로 기존의 행렬 A를 복구할 수 없습니다. 또한, U 행렬과 V 행렬의 t 열까지만 남깁니다. 여기서 t는 우리가 찾고자 하는 토픽의 수를 반영한 하이퍼 파라미터 값입니다. 하이퍼 파라미터란 사용자가 직접 값을 선택하며 성능에 영향을 주는 매개변수를 말합니다. t를 선택하는 것은 쉽지 않은 일입니다. t를 크게 잡으면 기존의 행렬 A로부터 다양한 의미를 가져갈 수 있지만, t를 작게 잡아야만 노이즈를 제거할 수 있기 때문입니다. 이렇게 일부 벡터들을 삭제하는 것을 데이터의 차원을 줄인다고도 말하는데, 데이터의 차원을 줄이게 되면 당연히 풀 SVD를 하였을 때보다 직관적으로 계산 비용이 낮아지는 효과를 얻을 수 있습니다. 하지만 계산 비용이 낮아지는 것 외에도 상대적으로 중요하지 않은 정보를 삭제하는 효과를 갖고 있는데, 이는 영상 처리 분야에서는 노이즈를 제거한다는 의미를 갖고 자연어 처리 분야에서는 설명력이 낮은 정보를 삭제하고 설명력이 높은 정보를 남긴다는 의미를 갖고 있습니다. 즉, 다시 말하면 기존의 행렬에서는 드러나지 않았던 심층적인 의미를 확인할 수 있게 해줍니다. 3. 잠재 의미 분석(Latent Semantic Analysis, LSA) 기존의 DTM이나 DTM에 단어의 중요도에 따른 가중치를 주었던 TF-IDF 행렬은 단어의 의미를 전혀 고려하지 못한다는 단점을 갖고 있었습니다. LSA는 기본적으로 DTM이나 TF-IDF 행렬에 절단된 SVD(truncated SVD)를 사용하여 차원을 축소시키고, 단어들의 잠재적인 의미를 끌어낸다는 아이디어를 갖고 있습니다. 실습을 통해서 이해해 보겠습니다. 과일이 길고 노란 먹고 바나나 사과 싶은 저는 좋아요 문서 1 0 0 0 1 0 1 1 0 문서 2 0 0 0 1 1 0 1 0 문서 3 0 1 1 0 2 0 0 0 문서 4 1 0 0 0 0 0 0 1 1) Full SVD import numpy as np 위와 같은 DTM을 실제로 파이썬을 통해서 만들면 다음과 같습니다. A = np.array([[0,0,0,1,0,1,1,0,0],[0,0,0,1,1,0,1,0,0],[0,1,1,0,2,0,0,0,0],[1,0,0,0,0,0,0,1,1]]) print('DTM의 크기(shape) :', np.shape(A)) DTM의 크기(shape) : (4, 9) 4 × 9의 크기를 가지는 DTM이 생성되었습니다. 이에 대해서 풀 SVD(full SVD)를 수행해 보겠습니다. 단, 여기서는 대각 행렬의 변수명을 Σ가 아니라 S를 사용합니다. 또한 V의 전치 행렬을 VT라고 하겠습니다. 소수점의 길이가 너무 길게 출력하면 보기 힘들어서 두 번째 자리까지만 출력하기 위해서. round(2)를 사용합니다. U, s, VT = np.linalg.svd(A, full_matrices = True) print('행렬 U :') print(U.round(2)) print('행렬 U의 크기(shape) :',np.shape(U)) 행렬 U : [[-0.24 0.75 0. -0.62] [-0.51 0.44 -0. 0.74] [-0.83 -0.49 -0. -0.27] [-0. -0. 1. 0. ]] 행렬 U의 크기(shape) : (4, 4) 4 × 4의 크기를 가지는 직교 행렬 U가 생성되었습니다. 이제 대각 행렬 S를 확인해 봅시다. print('특이 값 벡터 :') print(s.round(2)) print('특이 값 벡터의 크기(shape) :',np.shape(s)) 특이 값 벡터 : [2.69 2.05 1.73 0.77] 특이 값 벡터의 크기(shape) : (4, ) Numpy의 linalg.svd()는 특이 값 분해의 결과로 대각 행렬이 아니라 특이 값의 리스트를 반환합니다. 그러므로 앞서 본 수식의<NAME>으로 보려면 이를 다시 대각 행렬로 바꾸어 주어야 합니다. 우선 특이 값을 s에 저장하고 대각 행렬 크기의 행렬을 생성한 후에 그 행렬에 특이 값을 삽입해도 록 하겠습니다. # 대각 행렬의 크기인 4 x 9의 임의의 행렬 생성 S = np.zeros((4, 9)) # 특이 값을 대각행렬에 삽입 S[:4, :4] = np.diag(s) print('대각 행렬 S :') print(S.round(2)) print('대각 행렬의 크기(shape) :') print(np.shape(S)) 대각 행렬 S : [[2.69 0. 0. 0. 0. 0. 0. 0. 0. ] [0. 2.05 0. 0. 0. 0. 0. 0. 0. ] [0. 0. 1.73 0. 0. 0. 0. 0. 0. ] [0. 0. 0. 0.77 0. 0. 0. 0. 0. ]] 대각 행렬의 크기(shape) : (4, 9) 4 × 9의 크기를 가지는 대각 행렬 S가 생성되었습니다. 2.69 > 2.05 > 1.73 > 0.77 순으로 값이 내림차순을 보이는 것을 확인할 수 있습니다. print('직교행렬 VT :') print(VT.round(2)) print('직교 행렬 VT의 크기(shape) :') print(np.shape(VT)) 직교행렬 VT : [[-0. -0.31 -0.31 -0.28 -0.8 -0.09 -0.28 -0. -0. ] [ 0. -0.24 -0.24 0.58 -0.26 0.37 0.58 -0. -0. ] [ 0.58 -0. 0. 0. -0. 0. -0. 0.58 0.58] [ 0. -0.35 -0.35 0.16 0.25 -0.8 0.16 -0. -0. ] [-0. -0.78 -0.01 -0.2 0.4 0.4 -0.2 0. 0. ] [-0.29 0.31 -0.78 -0.24 0.23 0.23 0.01 0.14 0.14] [-0.29 -0.1 0.26 -0.59 -0.08 -0.08 0.66 0.14 0.14] [-0.5 -0.06 0.15 0.24 -0.05 -0.05 -0.19 0.75 -0.25] [-0.5 -0.06 0.15 0.24 -0.05 -0.05 -0.19 -0.25 0.75]] 직교 행렬 VT의 크기(shape) : (9, 9) 9 × 9의 크기를 가지는 직교 행렬 VT(V의 전치 행렬)가 생성되었습니다. 즉, U × S × VT를 하면 기존의 행렬 A가 나와야 합니다. Numpy의 allclose()는 2개의 행렬이 동일하면 True를 리턴합니다. 이를 사용하여 정말로 기존의 행렬 A와 동일한지 확인해 보겠습니다. np.allclose(A, np.dot(np.dot(U, S), VT).round(2)) True 2) 절단된 SVD(Truncated SVD) 지금까지 수행한 것은 풀 SVD(Full SVD)입니다. 이제 t를 정하고, 절단된 SVD(Truncated SVD)를 수행해 보도록 합시다. 여기서는 t=2로 하겠습니다. 우선 대각 행렬 S 내의 특이 값 중에서 상위 2개만 남기고 제거해 보도록 하겠습니다. # 특이 값 상위 2개만 보존 S = S[:2, :2] print('대각 행렬 S :') print(S.round(2)) [[2.69 0. ] [0. 2.05]] 상위 2개의 값만 남기고 나머지는 모두 제거된 것을 볼 수 있습니다. 이제 직교 행렬 U에 대해서도 2개의 열만 남기고 제거합니다. U = U[:,:2] print('행렬 U :') print(U.round(2)) 행렬 U : [[-0.24 0.75] [-0.51 0.44] [-0.83 -0.49] [-0. -0. ]] 2개의 열만 남기고 모두 제거가 된 것을 볼 수 있습니다. 이제 행렬 V의 전치 행렬인 VT에 대해서 2개의 행만 남기고 제거합니다. 이는 V 관점에서는 2개의 열만 남기고 제거한 것이 됩니다. VT = VT[:2, :] print('직교행렬 VT :') print(VT.round(2)) 직교행렬 VT : [[-0. -0.31 -0.31 -0.28 -0.8 -0.09 -0.28 -0. -0. ] [ 0. -0.24 -0.24 0.58 -0.26 0.37 0.58 -0. -0. ]] 이제 축소된 행렬 U, S, VT에 대해서 다시 U × S × VT 연산을 하면 기존의 A와는 다른 결과가 나오게 됩니다. 값이 손실되었기 때문에 이 세 개의 행렬로는 이제 기존의 A 행렬을 복구할 수 없습니다. U × S × VT 연산을 해서 나오는 값을 A_prime이라 하고 기존의 행렬 A와 값을 비교해 보도록 하겠습니다. A_prime = np.dot(np.dot(U, S), VT) print(A) print(A_prime.round(2)) [[0 0 0 1 0 1 1 0 0] [0 0 0 1 1 0 1 0 0] [0 1 1 0 2 0 0 0 0] [1 0 0 0 0 0 0 1 1]] [[ 0. -0.17 -0.17 1.08 0.12 0.62 1.08 -0. -0. ] [ 0. 0.2 0.2 0.91 0.86 0.45 0.91 0. 0. ] [ 0. 0.93 0.93 0.03 2.05 -0.17 0.03 0. 0. ] [ 0. 0. 0. 0. 0. 0. 0. 0. 0. ]] 대체적으로 기존에 0인 값들은 0에 가가운 값이 나오고, 1인 값들은 1에 가까운 값이 나오는 것을 볼 수 있습니다. 또한 값이 제대로 복구되지 않은 구간도 존재해 보입니다. 이제 이렇게 차원이 축소된 U, S, VT의 크기가 어떤 의미를 가지고 있는지 알아봅시다. 축소된 U는 4 × 2의 크기를 가지는데, 이는 잘 생각해 보면 문서의 개수 × 토픽의 수 t의 크기입니다. 단어의 개수인 9는 유지되지 않는데 문서의 개수인 4의 크기가 유지되었으니 4개의 문서 각각을 2개의 값으로 표현하고 있습니다. 즉, U의 각 행은 잠재 의미를 표현하기 위한 수치화된 각각의 문서 벡터라고 볼 수 있습니다. 축소된 VT는 2 × 9의 크기를 가지는데, 이는 잘 생각해 보면 토픽의 수 t × 단어의 개수의 크기입니다. VT의 각 열은 잠재 의미를 표현하기 위해 수치화된 각각의 단어 벡터라고 볼 수 있습니다. 이 문서 벡터들과 단어 벡터들을 통해 다른 문서의 유사도, 다른 단어의 유사도, 단어(쿼리)로부터 문서의 유사도를 구하는 것들이 가능해집니다. 4. 실습을 통한 이해 사이킷런에서는 Twenty Newsgroups이라고 불리는 20개의 다른 주제를 가진 뉴스그룹 데이터를 제공합니다. 앞서 언급했듯이 LSA가 토픽 모델링에 최적화된 알고리즘은 아니지만, 토픽 모델링이라는 분야의 시초가 되는 알고리즘입니다. 여기서는 LSA를 사용해서 문서의 수를 원하는 토픽의 수로 압축한 뒤에 각 토픽당 가장 중요한 단어 5개를 출력하는 실습으로 토픽 모델링을 수행합니다. 뉴스그룹 데이터는 뉴스 데이터가 아닙니다. 1) 뉴스그룹 데이터에 대한 이해 import pandas as pd from sklearn.datasets import fetch_20newsgroups import nltk from nltk.corpus import stopwords from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.decomposition import TruncatedSVD dataset = fetch_20newsgroups(shuffle=True, random_state=1, remove=('headers', 'footers', 'quotes')) documents = dataset.data print('샘플의 수 :',len(documents)) 샘플의 수 : 11314 훈련에 사용할 뉴스그룹 데이터는 총 11,314개입니다. 이 중 첫 번째 훈련용 샘플을 출력해 보겠습니다. documents[1] "\n\n\n\n\n\n\nYeah, do you expect people to read the FAQ, etc. and actually accept hard\natheism? No, you need a little leap of faith, Jimmy. Your logic runs out\nof steam!\n\n\n\n\n\n\n\nJim,\n\nSorry I can't pity you, Jim. And I'm sorry that you have these feelings of\ndenial about the faith you need to get by. Oh well, just pretend that it will\nall end happily ever after anyway. Maybe if you start a new newsgroup,\nalt.atheist.hard, you won't be bummin' so much?\n\n\n\n\n\n\nBye-Bye, Big Jim. Don't forget your Flintstone's Chewables! :) \n--\nBake Timmons, III" 뉴스그룹 데이터에는 특수문자가 포함된 다수의 영어 문장으로 구성돼 있습니다. 이런<NAME>의 샘플이 총 11,314개 존재합니다. 사이킷런이 제공하는 뉴스그룹 데이터에서 target_name에는 본래 이 뉴스그룹 데이터가 어떤 20개의 카테고리를 갖고 있었는지가 저장돼 있습니다. 이를 출력해 보겠습니다. print(dataset.target_names) ['alt.atheism', 'comp.graphics', 'comp.os.ms-windows.misc', 'comp.sys.ibm.pc.hardware', 'comp.sys.mac.hardware', 'comp.windows.x', 'misc.forsale', 'rec.autos', 'rec.motorcycles', 'rec.sport.baseball', 'rec.sport.hockey', 'sci.crypt', 'sci.electronics', 'sci.med', 'sci.space', 'soc.religion.christian', 'talk.politics.guns', 'talk.politics.mideast', 'talk.politics.misc', 'talk.religion.misc'] 2) 텍스트 전처리 시작하기 앞서, 텍스트 데이터에 대해서 가능한 한 정제 과정을 거쳐야만 합니다. 기본적인 아이디어는 알파벳을 제외한 구두점, 숫자, 특수 문자를 제거하는 것입니다. 이는 텍스트 전처리 챕터에서 정제 기법으로 배웠던 정규 표현식을 통해서 해결할 수 있습니다. 또한 짧은 단어는 유용한 정보를 담고 있지 않다고 가정하고, 길이가 짧은 단어도 제거합니다. 그리고 마지막으로 모든 알파벳을 소문자로 바꿔서 단어의 개수를 줄이는 작업을 합니다. news_df = pd.DataFrame({'document':documents}) # 특수 문자 제거 news_df['clean_doc'] = news_df['document'].str.replace("[^a-zA-Z]", " ") # 길이가 3이하인 단어는 제거 (길이가 짧은 단어 제거) news_df['clean_doc'] = news_df['clean_doc'].apply(lambda x: ' '.join([w for w in x.split() if len(w)>3])) # 전체 단어에 대한 소문자 변환 news_df['clean_doc'] = news_df['clean_doc'].apply(lambda x: x.lower()) 데이터의 정제가 끝났습니다. 다시 첫 번째 훈련용 뉴스그룹 샘플만 출력하여 정제 전, 후에 어떤 차이가 있는지 확인해 보겠습니다. news_df['clean_doc'][1] 'yeah expect people read actually accept hard atheism need little leap faith jimmy your logic runs steam sorry pity sorry that have these feelings denial about faith need well just pretend that will happily ever after anyway maybe start newsgroup atheist hard bummin much forget your flintstone chewables bake timmons' 우선 특수문자가 제거되었으며, if나 you와 같은 길이가 3이하인 단어가 제거된 것을 확인할 수 있습니다. 그뿐만 아니라 대문자가 전부 소문자로 바뀌었습니다. 이제 뉴스그룹 데이터에서 불용어를 제거합니다. 불용어를 제거하기 위해서 토큰화를 우선 수행합니다. 토큰화와 불용어 제거를 순차적으로 진행합니다. # NLTK로부터 불용어를 받아온다. stop_words = stopwords.words('english') tokenized_doc = news_df['clean_doc'].apply(lambda x: x.split()) # 토큰화 tokenized_doc = tokenized_doc.apply(lambda x: [item for item in x if item not in stop_words]) # 불용어를 제거합니다. 다시 첫 번째 훈련용 뉴스그룹 샘플을 출력합니다. print(tokenized_doc[1]) ['yeah', 'expect', 'people', 'read', 'actually', 'accept', 'hard', 'atheism', 'need', 'little', 'leap', 'faith', 'jimmy', 'logic', 'runs', 'steam', 'sorry', 'pity', 'sorry', 'feelings', 'denial', 'faith', 'need', 'well', 'pretend', 'happily', 'ever', 'anyway', 'maybe', 'start', 'newsgroup', 'atheist', 'hard', 'bummin', 'much', 'forget', 'flintstone', 'chewables', 'bake', 'timmons'] 기존에 있었던 불용어에 속하던 your, about, just, that, will, after 단어들이 사라졌을 뿐만 아니라, 토큰 화가 수행된 것을 확인할 수 있습니다. 3) TF-IDF 행렬 만들기 불용어 제거를 위해 토큰화 작업을 수행하였지만, TfidfVectorizer(TF-IDF 실습 참고)는 기본적으로 토큰 화가 되어있지 않은 텍스트 데이터를 입력으로 사용합니다. 그렇기 때문에 TfidfVectorizer를 사용해서 TF-IDF 행렬을 만들기 위해서 다시 토큰화 작업을 역으로 취소하는 작업을 수행해 보도록 하겠습니다. 이를 역 토큰 화(Detokenization)라고 합니다. # 역 토큰 화 (토큰화 작업을 역으로 되돌림) detokenized_doc = [] for i in range(len(news_df)): t = ' '.join(tokenized_doc[i]) detokenized_doc.append(t) news_df['clean_doc'] = detokenized_doc 역 토큰 화가 제대로 되었는지 다시 첫 번째 훈련용 뉴스그룹 샘플을 출력하여 확인해 보겠습니다. news_df['clean_doc'][1] 'yeah expect people read actually accept hard atheism need little leap faith jimmy logic runs steam sorry pity sorry feelings denial faith need well pretend happily ever anyway maybe start newsgroup atheist hard bummin much forget flintstone chewables bake timmons' 정상적으로 불용어가 제거된 상태에서 역 토큰 화가 수행되었음을 확인할 수 있습니다. 이제 사이킷런의 TfidfVectorizer를 통해 단어 1,000개에 대한 TF-IDF 행렬을 만들 것입니다. 물론 텍스트 데이터에 있는 모든 단어를 가지고 행렬을 만들 수는 있겠지만, 여기서는 1,000개의 단어로 제한하도록 하겠습니다. vectorizer = TfidfVectorizer(stop_words='english', max_features= 1000, # 상위 1,000개의 단어를 보존 max_df = 0.5, smooth_idf=True) X = vectorizer.fit_transform(news_df['clean_doc']) # TF-IDF 행렬의 크기 확인 print('TF-IDF 행렬의 크기 :',X.shape) TF-IDF 행렬의 크기 : (11314, 1000) 11,314 × 1,000의 크기를 가진 TF-IDF 행렬이 생성되었음을 확인할 수 있습니다. 4) 토픽 모델링(Topic Modeling) 이제 TF-IDF 행렬을 다수의 행렬로 분해해 보도록 하겠습니다. 여기서는 사이킷런의 절단된 SVD(Truncated SVD)를 사용합니다. 절단된 SVD를 사용하면 차원을 축소할 수 있습니다. 원래 기존 뉴스그룹 데이터가 20개의 카테고리를 갖고 있었기 때문에, 20개의 토픽을 가졌다고 가정하고 토픽 모델링을 시도해 보겠습니다. 토픽의 숫자는 n_components의 파라미터로 지정이 가능합니다. svd_model = TruncatedSVD(n_components=20, algorithm='randomized', n_iter=100, random_state=122) svd_model.fit(X) len(svd_model.components_) 20 여기서 svd_model.componets_는 앞서 배운 LSA에서 VT에 해당됩니다. np.shape(svd_model.components_) (20, 1000) 정확하게 토픽의 수 t × 단어의 수의 크기를 가지는 것을 볼 수 있습니다. terms = vectorizer.get_feature_names() # 단어 집합. 1,000개의 단어가 저장됨. def get_topics(components, feature_names, n=5): for idx, topic in enumerate(components): print("Topic %d:" % (idx+1), [(feature_names[i], topic[i].round(5)) for i in topic.argsort()[:-n - 1:-1]]) get_topics(svd_model.components_,terms) 각 20개의 행의 각 1,000개의 열 중 가장 값이 큰 5개의 값을 찾아서 단어로 출력합니다. Topic 1: [('like', 0.2138), ('know', 0.20031), ('people', 0.19334), ('think', 0.17802), ('good', 0.15105)] Topic 2: [('thanks', 0.32918), ('windows', 0.29093), ('card', 0.18016), ('drive', 0.1739), ('mail', 0.15131)] Topic 3: [('game', 0.37159), ('team', 0.32533), ('year', 0.28205), ('games', 0.25416), ('season', 0.18464)] Topic 4: [('drive', 0.52823), ('scsi', 0.20043), ('disk', 0.15518), ('hard', 0.15511), ('card', 0.14049)] Topic 5: [('windows', 0.40544), ('file', 0.25619), ('window', 0.1806), ('files', 0.16196), ('program', 0.14009)] Topic 6: [('government', 0.16085), ('chip', 0.16071), ('mail', 0.15626), ('space', 0.15047), ('information', 0.13582)] Topic 7: [('like', 0.67121), ('bike', 0.14274), ('know', 0.11189), ('chip', 0.11043), ('sounds', 0.10389)] Topic 8: [('card', 0.44948), ('sale', 0.21639), ('video', 0.21318), ('offer', 0.14896), ('monitor', 0.1487)] Topic 9: [('know', 0.44869), ('card', 0.35699), ('chip', 0.17169), ('video', 0.15289), ('government', 0.15069)] Topic 10: [('good', 0.41575), ('know', 0.23137), ('time', 0.18933), ('bike', 0.11317), ('jesus', 0.09421)] Topic 11: [('think', 0.7832), ('chip', 0.10776), ('good', 0.10613), ('thanks', 0.08985), ('clipper', 0.07882)] Topic 12: [('thanks', 0.37279), ('right', 0.21787), ('problem', 0.2172), ('good', 0.21405), ('bike', 0.2116)] Topic 13: [('good', 0.36691), ('people', 0.33814), ('windows', 0.28286), ('know', 0.25238), ('file', 0.18193)] Topic 14: [('space', 0.39894), ('think', 0.23279), ('know', 0.17956), ('nasa', 0.15218), ('problem', 0.12924)] Topic 15: [('space', 0.3092), ('good', 0.30207), ('card', 0.21615), ('people', 0.20208), ('time', 0.15716)] Topic 16: [('people', 0.46951), ('problem', 0.20879), ('window', 0.16), ('time', 0.13873), ('game', 0.13616)] Topic 17: [('time', 0.3419), ('bike', 0.26896), ('right', 0.26208), ('windows', 0.19632), ('file', 0.19145)] Topic 18: [('time', 0.60079), ('problem', 0.15209), ('file', 0.13856), ('think', 0.13025), ('israel', 0.10728)] Topic 19: [('file', 0.4489), ('need', 0.25951), ('card', 0.1876), ('files', 0.17632), ('problem', 0.1491)] Topic 20: [('problem', 0.32797), ('file', 0.26268), ('thanks', 0.23414), ('used', 0.19339), ('space', 0.13861)] 5. LSA의 장단점(Pros and Cons of LSA) 정리해 보면 LSA는 쉽고 빠르게 구현이 가능할 뿐만 아니라 단어의 잠재적인 의미를 이끌어낼 수 있어 문서의 유사도 계산 등에서 좋은 성능을 보여준다는 장점을 갖고 있습니다. 하지만 SVD의 특성상 이미 계산된 LSA에 새로운 데이터를 추가하여 계산하려고 하면 보통 처음부터 다시 계산해야 합니다. 즉, 새로운 정보에 대해 업데이트가 어렵습니다. 이는 최근 LSA 대신 Word2Vec 등 단어의 의미를 벡터화할 수 있는 또 다른 방법론인 인공 신경망 기반의 방법론이 각광받는 이유이기도 합니다. 19-02 잠재 디리클레 할당(Latent Dirichlet Allocation, LDA) 토픽 모델링은 문서의 집합에서 토픽을 찾아내는 프로세스를 말합니다. 이는 검색 엔진, 고객 민원 시스템 등과 같이 문서의 주제를 알아내는 일이 중요한 곳에서 사용됩니다. 잠재 디리클레 할당(Latent Dirichlet Allocation, LDA)은 토픽 모델링의 대표적인 알고리즘입니다. 줄여서 LDA라고 합니다. LDA는 문서들은 토픽들의 혼합으로 구성돼 있으며, 토픽들은 확률 분포에 기반하여 단어들을 생성한다고 가정합니다. 데이터가 주어지면, LDA는 문서가 생성되던 과정을 역추적합니다. 참고 링크 : https://lettier.com/projects/lda-topic-modeling/ 위의 사이트는 코드 작성 없이 입력한 문서들로부터 DTM을 만들고 LDA를 수행한 결과를 보여주는 웹 사이트입니다. 1. 잠재 디리클레 할당(Latent Dirichlet Allocation, LDA) 개요 우선 LDA의 내부 메커니즘에 대해서 이해하기 전에, LDA를 일종의 블랙박스로 보고 LDA에 문서 집합을 입력하면, 어떤 결과를 보여주는지 간소화된 예를 들어 보겠습니다. 아래와 같은 3개의 문서가 있다고 합시다. 지금의 예제는 간단해서 눈으로도 토픽 모델링을 할 수 있을 것 같지만, 실제 수십만 개 이상의 문서가 있는 경우는 직접 토픽을 찾아내는 것이 어렵기 때문에 LDA의 도움이 필요합니다. 문서 1 : 저는 사과랑 바나나를 먹어요 문서 2 : 우리는 귀여운 강아지가 좋아요 문서 3 : 저의 깜찍하고 귀여운 강아지가 바나나를 먹어요 LDA를 수행할 때 문서 집합에서 토픽이 몇 개가 존재할지 가정하는 것은 사용자가 해야 할 일입니다. 여기서는 LDA에 2개의 토픽을 찾으라고 요청하겠습니다. 토픽의 개수를 의미하는 변수를 k라고 하였을 때, k를 2로 한다는 의미입니다. k의 값을 잘못 선택하면 원치 않는 이상한 결과가 나올 수 있습니다. 이렇게 모델의 성능에 영향을 주는 사용자가 직접 선택하는 매개변수를 머신 러닝 용어로 하이퍼 파라미터라고 합니다. 이러한 하이퍼 파라미터의 선택은 여러 실험을 통해 얻은 값일 수도 있고, 우선 시도해 보는 값일 수도 있습니다. LDA가 위의 세 문서로부터 2개의 토픽을 찾은 결과는 아래와 같습니다. 여기서는 LDA 입력 전에 주어와 불필요한 조사 등을 제거하는 전처리 과정은 거쳤다고 가정합니다. 즉, 전처리 과정을 거친 DTM이 LDA의 입력이 되었다고 가정합니다. LDA는 각 문서의 토픽 분포와 각 토픽 내의 단어 분포를 추정합니다. <각 문서의 토픽 분포> 문서 1 : 토픽 A 100% 문서 2 : 토픽 B 100% 문서 3 : 토픽 B 60%, 토픽 A 40% <각 토픽의 단어 분포> 토픽 A : 사과 20%, 바나나 40%, 먹어요 40%, 귀여운 0%, 강아지 0%, 깜찍하고 0%, 좋아요 0% 토픽 B : 사과 0%, 바나나 0%, 먹어요 0%, 귀여운 33%, 강아지 33%, 깜찍하고 16%, 좋아요 16% LDA는 토픽의 제목을 정해주지 않지만, 이 시점에서 알고리즘의 사용자는 위 결과로부터 두 토픽이 각각 과일에 대한 토픽과 강아지에 대한 토픽이라고 판단해 볼 수 있습니다. 이제 LDA에 대해서 알아봅시다. 실제로 LDA는 아래의 설명 보다 훨씬 더 복잡하지만, 여기서는 수학적인 수식은 배제하고 개념적 이해에 초점을 둡니다. 2. LDA의 가정 LDA는 문서의 집합으로부터 어떤 토픽이 존재하는지를 알아내기 위한 알고리즘입니다. LDA는 앞서 배운 빈도수 기반의 표현 방법인 BoW의 행렬 DTM 또는 TF-IDF 행렬을 입력으로 하는데, 이로부터 알 수 있는 사실은 LDA는 단어의 순서는 신경 쓰지 않겠다는 겁니다. LDA는 문서들로부터 토픽을 뽑아내기 위해서 이러한 가정을 염두에 두고 있습니다. 모든 문서 하나, 하나가 작성될 때 그 문서의 작성자는 이러한 생각을 했습니다. '나는 이 문서를 작성하기 위해서 이런 주제들을 넣을 거고, 이런 주제들을 위해서는 이런 단어들을 넣을 거야.' 조금 더 구체적으로 알아보겠습니다. 각각의 문서는 다음과 같은 과정을 거쳐서 작성되었다고 가정합니다. 1) 문서에 사용할 단어의 개수 N을 정합니다. - Ex) 5개의 단어를 정하였습니다. 2) 문서에 사용할 토픽의 혼합을 확률 분포에 기반하여 결정합니다. - Ex) 위 예제와 같이 토픽이 2개라고 하였을 때 강아지 토픽을 60%, 과일 토픽을 40%와 같이 선택할 수 있습니다. 3) 문서에 사용할 각 단어를 (아래와 같이) 정합니다. 3-1) 토픽 분포에서 토픽 T를 확률적으로 고릅니다. - Ex) 60% 확률로 강아지 토픽을 선택하고, 40% 확률로 과일 토픽을 선택할 수 있습니다. 3-2) 선택한 토픽 T에서 단어의 출현 확률 분포에 기반해 문서에 사용할 단어를 고릅니다. - Ex) 강아지 토픽을 선택하였다면, 33% 확률로 강아지란 단어를 선택할 수 있습니다. 이제 3)을 반복하면서 문서를 완성합니다. 이러한 과정을 통해 문서가 작성되었다는 가정 하에 LDA는 토픽을 뽑아내기 위하여 위 과정을 역으로 추적하는 역공학(reverse engneering)을 수행합니다. 3. LDA의 수행하기 이제 LDA의 수행 과정을 정리해 보겠습니다. 1) 사용자는 알고리즘에게 토픽의 개수 k를 알려줍니다. 앞서 말하였듯이 LDA에게 토픽의 개수를 알려주는 역할은 사용자의 역할입니다. LDA는 토픽의 개수 k를 입력받으면, k 개의 토픽이 M 개의 전체 문서에 걸쳐 분포되어 있다고 가정합니다. 2) 모든 단어를 k 개 중 하나의 토픽에 할당합니다. 이제 LDA는 모든 문서의 모든 단어에 대해서 k 개 중 하나의 토픽을 랜덤으로 할당합니다. 이 작업이 끝나면 각 문서는 토픽을 가지며, 토픽은 단어 분포를 가지는 상태입니다. 물론 랜덤으로 할당하였기 때문에 사실 이 결과는 전부 틀린 상태입니다. 만약 한 단어가 한 문서에서 2회 이상 등장하였다면, 각 단어는 서로 다른 토픽에 할당되었을 수도 있습니다. 3) 이제 모든 문서의 모든 단어에 대해서 아래의 사항을 반복 진행합니다. (iterative) 3-1) 어떤 문서의 각 단어 w는 자신은 잘못된 토픽에 할당돼 있지만, 다른 단어들은 전부 올바른 토픽에 할당돼 있는 상태라고 가정합니다. 이에 따라 단어 w는 아래의 두 가지 기준에 따라서 토픽이 재할당됩니다. - p(topic t | document d) : 문서 d의 단어들 중 토픽 t에 해당하는 단어들의 비율 - p(word w | topic t) : 각 토픽들 t에서 해당 단어 w의 분포 이를 반복하면, 모든 할당이 완료된 수렴 상태가 됩니다. 두 가지 기준이 어떤 의미인지 예를 들어보겠습니다. 설명의 편의를 위해서 두 개의 문서라는 새로운 예를 사용합니다. 위의 그림은 두 개의 문서 doc1과 doc2를 보여줍니다. 여기서는 doc1의 세 번째 단어 apple의 토픽을 결정하고자 합니다. 우선 첫 번째로 사용하는 기준은 문서 doc1의 단어들이 어떤 토픽에 해당하는지를 봅니다. doc1의 모든 단어들은 토픽 A와 토픽 B에 50 대 50의 비율로 할당돼 있으므로, 이 기준에 따르면 단어 apple은 토픽 A 또는 토픽 B 둘 중 어디에도 속할 가능성이 있습니다. 두 번째 기준은 단어 apple이 전체 문서에서 어떤 토픽에 할당돼 있는지를 봅니다. 이 기준에 따르면 단어 apple은 토픽 B에 할당될 가능성이 높습니다. 이러한 두 가지 기준을 참고하여 LDA는 doc1의 apple을 어떤 토픽에 할당할지 결정합니다. 4. 잠재 디리클레 할당과 잠재 의미 분석의 차이 LSA : DTM을 차원 축소하여 축소 차원에서 근접 단어들을 토픽으로 묶는다. LDA : 단어가 특정 토픽에 존재할 확률과 문서에 특정 토픽이 존재할 확률을 결합 확률로 추정하여 토픽을 추출한다. 5. 실습을 통한 이해 이제 LDA를 실습을 통해 직접 진행해 보도록 하겠습니다. LSA 실습에서는 사이킷런(sklearn)을 사용하였지만, 이번에는 gensim을 사용하므로 앞 실습과 실습 과정이 확연히 다릅니다. 사이킷런을 통해 LDA를 진행하는 실습은 아래의 링크에 작성하였습니다. 아래의 링크에서는 LSA 실습의 실습과 진행 과정이 거의 유사하니 참고하시기 바랍니다. 사이킷런으로 LDA 실습 : https://wikidocs.net/40710 1) 정수 인코딩과 단어 집합 만들기 바로 이전 실습인 LSA 실습에서 사용하였던 Twenty Newsgroups이라고 불리는 20개의 다른 주제를 가진 뉴스 데이터를 다시 사용합니다. 전처리 과정은 이전 실습과 중복되므로 생략합니다. 동일한 전처리 과정을 거친 후에 tokenized_doc으로 저장한 상태라고 합시다. 훈련용 뉴스를 5개만 출력해 보겠습니다. tokenized_doc[:5] 0 [well, sure, about, story, seem, biased, what,... 1 [yeah, expect, people, read, actually, accept,... 2 [although, realize, that, principle, your, str... 3 [notwithstanding, legitimate, fuss, about, thi... 4 [well, will, have, change, scoring, playoff, p... Name: clean_doc, dtype: object 이제 각 단어에 정수 인코딩을 하는 동시에, 각 뉴스에서의 단어의 빈도수를 기록해 보겠습니다. 여기서는 각 단어를 (word_id, word_frequency)의 형태로 바꾸고자 합니다. word_id는 단어가 정수 인코딩된 값이고, word_frequency는 해당 뉴스에서의 해당 단어의 빈도수를 의미합니다. 이는 gensim의 corpora.Dictionary()를 사용하여 손쉽게 구할 수 있습니다. 전체 뉴스에 대해서 정수 인코딩을 수행하고, 두 번째 뉴스를 출력해 봅시다. from gensim import corpora dictionary = corpora.Dictionary(tokenized_doc) corpus = [dictionary.doc2bow(text) for text in tokenized_doc] print(corpus[1]) # 수행된 결과에서 두 번째 뉴스 출력. 첫 번째 문서의 인덱스는 0 [(52, 1), (55, 1), (56, 1), (57, 1), (58, 1), (59, 1), (60, 1), (61, 1), (62, 1), (63, 1), (64, 1), (65, 1), (66, 2), (67, 1), (68, 1), (69, 1), (70, 1), (71, 2), (72, 1), (73, 1), (74, 1), (75, 1), (76, 1), (77, 1), (78, 2), (79, 1), (80, 1), (81, 1), (82, 1), (83, 1), (84, 1), (85, 2), (86, 1), (87, 1), (88, 1), (89, 1)] 두 번째 뉴스의 출력 결과를 봅시다. 위의 출력 결과 중에서 (66, 2)는 정수 인코딩이 66으로 할당된 단어가 두 번째 뉴스에서는 두 번 등장하였음을 의미합니다. 66이라는 값을 가지는 단어가 정수 인코딩이 되기 전에는 어떤 단어였는지 확인하여 봅시다. 이는 dictionary[]에 기존 단어가 무엇인지 알고자 하는 정숫값을 입력하여 확인할 수 있습니다. print(dictionary[66]) faith 기존에는 단어 'faith'이었음을 알 수 있습니다. 총 학습된 단어의 개수를 확인해 보겠습니다. 이는 dictionary의 길이를 확인하면 됩니다. len(dictionary) 65284 총 65,284개의 단어가 학습되었습니다. 이제 LDA 모델을 훈련시켜보겠습니다. 2) LDA 모델 훈련시키기 기존의 뉴스 데이터가 총 20개의 카테고리를 가지고 있었으므로 토픽의 개수를 20으로 하여 LDA 모델을 학습시켜보도록 하겠습니다. import gensim NUM_TOPICS = 20 # 20개의 토픽, k=20 ldamodel = gensim.models.ldamodel.LdaModel(corpus, num_topics = NUM_TOPICS, id2word=dictionary, passes=15) topics = ldamodel.print_topics(num_words=4) for topic in topics: print(topic) (0, '0.015*"drive" + 0.014*"thanks" + 0.012*"card" + 0.012*"system"') (1, '0.009*"back" + 0.009*"like" + 0.009*"time" + 0.008*"went"') (2, '0.012*"colorado" + 0.010*"david" + 0.006*"decenso" + 0.005*"tyre"') (3, '0.020*"number" + 0.018*"wire" + 0.013*"bits" + 0.013*"filename"') (4, '0.038*"space" + 0.013*"nasa" + 0.011*"research" + 0.010*"medical"') (5, '0.014*"price" + 0.010*"sale" + 0.009*"good" + 0.008*"shipping"') (6, '0.012*"available" + 0.009*"file" + 0.009*"information" + 0.008*"version"') (7, '0.021*"would" + 0.013*"think" + 0.012*"people" + 0.011*"like"') (8, '0.035*"window" + 0.021*"display" + 0.017*"widget" + 0.013*"application"') (9, '0.012*"people" + 0.010*"jesus" + 0.007*"armenian" + 0.007*"israel"') (10, '0.008*"government" + 0.007*"system" + 0.006*"public" + 0.006*"encryption"') (11, '0.013*"germany" + 0.008*"sweden" + 0.008*"switzerland" + 0.007*"gaza"') (12, '0.020*"game" + 0.018*"team" + 0.015*"games" + 0.013*"play"') (13, '0.024*"apple" + 0.014*"water" + 0.013*"ground" + 0.011*"cable"') (14, '0.011*"evidence" + 0.010*"believe" + 0.010*"truth" + 0.010*"church"') (15, '0.016*"president" + 0.010*"states" + 0.007*"united" + 0.007*"year"') (16, '0.047*"file" + 0.035*"output" + 0.033*"entry" + 0.021*"program"') (17, '0.008*"dept" + 0.008*"devils" + 0.007*"caps" + 0.007*"john"') (18, '0.011*"year" + 0.009*"last" + 0.007*"first" + 0.006*"runs"') (19, '0.013*"outlets" + 0.013*"norton" + 0.012*"quantum" + 0.008*"neck"') 각 단어 앞에 붙은 수치는 단어의 해당 토픽에 대한 기여도를 보여줍니다. 또한 맨 앞에 있는 토픽 번호는 0부터 시작하므로 총 20개의 토픽은 0부터 19까지의 번호가 할당돼 있습니다. passes는 알고리즘의 동작 횟수를 말하는데, 알고리즘이 결정하는 토픽의 값이 적절히 수렴할 수 있도록 충분히 적당한 횟수를 정해주면 됩니다. 여기서는 총 15회를 수행하였습니다. 여기서는 num_words=4로 총 4개의 단어만 출력하도록 하였습니다. 만약 10개의 단어를 출력하고 싶다면 아래의 코드를 수행하면 됩니다. print(ldamodel.print_topics()) 3) LDA 시각화하기 LDA 시각화를 위해서는 pyLDAvis의 설치가 필요합니다. 윈도의 명령 프롬프트나 MAC/UNIX의 터미널에서 아래의 명령을 수행하여 pyLDAvis를 설치하시기 바랍니다. pip install pyLDAvis 설치가 완료되었다면 LDA 시각화 실습을 진행합니다. import pyLDAvis.gensim_models pyLDAvis.enable_notebook() vis = pyLDAvis.gensim_models.prepare(ldamodel, corpus, dictionary) pyLDAvis.display(vis) 좌측의 원들은 각각의 20개의 토픽을 나타냅니다. 각 원과의 거리는 각 토픽들이 서로 얼마나 다른지를 보여줍니다. 만약 두 개의 원이 겹친다면, 이 두 개의 토픽은 유사한 토픽이라는 의미입니다. 위의 그림에서는 10번 토픽을 클릭하였고, 이에 따라 우측에는 10번 토픽에 대한 정보가 나타납니다. 한 가지 주의할 점은 LDA 모델의 출력 결과에서는 토픽 번호가 0부터 할당되어 0~19의 숫자가 사용된 것과는 달리 위의 LDA 시각화에서는 토픽의 번호가 1부터 시작하므로 각 토픽 번호는 이제 +1이 된 값인 1~20까지의 값을 가집니다. 4) 문서 별 토픽 분포 보기 위에서 토픽 별 단어 분포는 확인하였으나, 아직 문서 별 토픽 분포에 대해서는 확인하지 못하였습니다. 우선 문서 별 토픽 분포를 확인하는 방법을 보겠습니다. 각 문서의 토픽 분포는 이미 훈련된 LDA 모델인 ldamodel[]에 전체 데이터가 정수 인코딩 된 결과를 넣은 후에 확인이 가능합니다. 여기서는 책의 지면의 한계로 상위 5개의 문서에 대해서만 토픽 분포를 확인해 보겠습니다. for i, topic_list in enumerate(ldamodel[corpus]): if i==5: break print(i,'번째 문서의 topic 비율은',topic_list) 0 번째 문서의 topic 비율은 [(7, 0.3050222), (9, 0.5070568), (11, 0.1319604), (18, 0.042834017)] 1 번째 문서의 topic 비율은 [(0, 0.031606797), (7, 0.7529218), (13, 0.02924682), (14, 0.12861845), (17, 0.037851967)] 2 번째 문서의 topic 비율은 [(7, 0.52241164), (9, 0.36602455), (16, 0.09760969)] 3 번째 문서의 topic 비율은 [(1, 0.16926806), (5, 0.04912094), (6, 0.04034211), (7, 0.11710636), (10, 0.5854137), (15, 0.02776434)] 4 번째 문서의 topic 비율은 [(7, 0.42152268), (12, 0.21917087), (17, 0.32781804)] 위의 출력 결과에서 (숫자, 확률)은 각각 토픽 번호와 해당 토픽이 해당 문서에서 차지하는 분포도를 의미합니다. 예를 들어 0번째 문서의 토픽 비율에서 (7, 0.3050222)은 7번 토픽이 30%의 분포도를 가지는 것을 의미합니다. 위의 코드를 응용하여 좀 더 깔끔한 형태인 데이터 프레임<NAME>으로 출력해 보겠습니다. def make_topictable_per_doc(ldamodel, corpus): topic_table = pd.DataFrame() # 몇 번째 문서인지를 의미하는 문서 번호와 해당 문서의 토픽 비중을 한 줄씩 꺼내온다. for i, topic_list in enumerate(ldamodel[corpus]): doc = topic_list[0] if ldamodel.per_word_topics else topic_list doc = sorted(doc, key=lambda x: (x[1]), reverse=True) # 각 문서에 대해서 비중이 높은 토픽순으로 토픽을 정렬한다. # EX) 정렬 전 0번 문서 : (2번 토픽, 48.5%), (8번 토픽, 25%), (10번 토픽, 5%), (12번 토픽, 21.5%), # Ex) 정렬 후 0번 문서 : (2번 토픽, 48.5%), (8번 토픽, 25%), (12번 토픽, 21.5%), (10번 토픽, 5%) # 48 > 25 > 21 > 5 순으로 정렬이 된 것. # 모든 문서에 대해서 각각 아래를 수행 for j, (topic_num, prop_topic) in enumerate(doc): # 몇 번 토픽인지 와 비중을 나눠서 저장한다. if j == 0: # 정렬을 한 상태이므로 가장 앞에 있는 것이 가장 비중이 높은 토픽 topic_table = topic_table.append(pd.Series([int(topic_num), round(prop_topic, 4), topic_list]), ignore_index=True) # 가장 비중이 높은 토픽과, 가장 비중이 높은 토픽의 비중과, 전체 토픽의 비중을 저장한다. else: break return(topic_table) topictable = make_topictable_per_doc(ldamodel, corpus) topictable = topictable.reset_index() # 문서 번호을 의미하는 열(column)로 사용하기 위해서 인덱스 열을 하나 더 만든다. topictable.columns = ['문서 번호', '가장 비중이 높은 토픽', '가장 높은 토픽의 비중', '각 토픽의 비중'] topictable[:10] 19-03 사이킷런의 잠재 디리클레 할당(LDA) 실습 앞서 gensim을 통해서 LDA를 수행하고, 시각화를 진행해 보았습니다. 이번에는 LSA 실습에서처럼 사이킷런을 사용하여 LDA를 수행하여 보겠습니다. 사이킷런을 사용하므로 전반적인 과정은 LSA 실습과 유사합니다. 1. 실습을 통한 이해 1) 뉴스 기사 제목 데이터에 대한 이해 약 15년 동안 발행되었던 뉴스 기사 제목을 모아놓은 영어 데이터를 아래 링크에서 다운로드할 수 있습니다. 링크 : https://www.kaggle.com/therohk/million-headlines import pandas as pd import urllib.request import nltk from nltk.corpus import stopwords from nltk.stem import WordNetLemmatizer from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.decomposition import LatentDirichletAllocation urllib.request.urlretrieve("https://raw.githubusercontent.com/ukairia777/tensorflow-nlp-tutorial/main/19.%20TopiC%20Modeling%20(LDA% 2C%20BERT-Based)/dataset/abcnews-date-text.csv") data = pd.read_csv('abcnews-date-text.csv', error_bad_lines=False) print('뉴스 제목 개수 :',len(data)) 뉴스 제목 개수 : 1082168 해당 데이터는 약 100만 개의 샘플을 갖고 있습니다. 상위 5개의 샘플만 출력해 봅시다. print(data.head(5)) publish_date headline_text 0 20030219 aba decides against community broadcasting lic... 1 20030219 act fire witnesses must be aware of defamation 2 20030219 a g calls for infrastructure protection summit 3 20030219 air nz staff in aust strike for pay rise 4 20030219 air nz strike to affect australian travellers 이 데이터는 publish_data와 headline_text라는 두 개의 열을 갖고 있습니다. 각각 뉴스가 나온 날짜와 뉴스 기사 제목을 의미합니다. 필요한 데이터는 이 중에서 headline_text 열. 즉, 뉴스 기사 제목이므로 이 부분만 별도로 저장합니다. text = data[['headline_text']] text.head(5) headline_text 0 aba decides against community broadcasting lic... 1 act fire witnesses must be aware of defamation 2 a g calls for infrastructure protection summit 3 air nz staff in aust strike for pay rise 4 air nz strike to affect australian travellers 정상적으로 headline_text 열만 추출된 것을 확인할 수 있습니다. 2) 텍스트 전처리 이번 실습에서는 불용어 제거, 표제어 추출, 길이가 짧은 단어 제거라는 세 가지 전처리 기법을 사용합니다. text['headline_text'] = text.apply(lambda row: nltk.word_tokenize(row['headline_text']), axis=1) NLTK의 word_tokenize를 통해 단어 토큰화를 수행합니다. print(text.head(5)) headline_text 0 [aba, decides, against, community, broadcastin... 1 [act, fire, witnesses, must, be, aware, of, de... 2 [a, g, calls, for, infrastructure, protection,... 3 [air, nz, staff, in, aust, strike, for, pay, r... 4 [air, nz, strike, to, affect, australian, trav... 상위 5개의 샘플만 출력하여 단어 토큰화 결과를 확인합니다. 이제 불용어를 제거합니다. stop_words = stopwords.words('english') text['headline_text'] = text['headline_text'].apply(lambda x: [word for word in x if word not in (stop_words)]) 여기서는 NLTK가 제공하는 영어 불용어를 통해서 text 데이터로부터 불용어를 제거해 보도록 하겠습니다. print(text.head(5)) headline_text 0 [aba, decides, community, broadcasting, licence] 1 [act, fire, witnesses, must, aware, defamation] 2 [g, calls, infrastructure, protection, summit] 3 [air, nz, staff, aust, strike, pay, rise] 4 [air, nz, strike, affect, australian, travellers] 상위 5개의 샘플에 대해서 불용어를 제거하기 전과 후의 데이터만 비교해도 확실히 몇 가지 단어들이 사라진 것이 보입니다. against, be, of, a, in, to 등의 단어가 제거되었습니다. 이제 표제어 추출을 수행합니다. 표제어 추출로 3인칭 단수 표현을 1인칭으로 바꾸고, 과거 현재형 동사를 현재형으로 바꿉니다. text['headline_text'] = text['headline_text'].apply(lambda x: [WordNetLemmatizer().lemmatize(word, pos='v') for word in x]) print(text.head(5)) headline_text 0 [aba, decide, community, broadcast, licence] 1 [act, fire, witness, must, aware, defamation] 2 [g, call, infrastructure, protection, summit] 3 [air, nz, staff, aust, strike, pay, rise] 4 [air, nz, strike, affect, australian, travellers] 표제어 추출이 된 것을 확인할 수 있습니다. 이제 길이가 3이하인 단어에 대해서 제거하는 작업을 수행합니다. tokenized_doc = text['headline_text'].apply(lambda x: [word for word in x if len(word) > 3]) print(tokenized_doc[:5]) 0 [decide, community, broadcast, licence] 1 [fire, witness, must, aware, defamation] 2 [call, infrastructure, protection, summit] 3 [staff, aust, strike, rise] 4 [strike, affect, australian, travellers] 길이가 3이하인 단어들에 대해서 제거가 된 것을 볼 수 있습니다. 이제 TF-IDF 행렬을 만들어보겠습니다. 3) TF-IDF 행렬 만들기 TF-IDF 실습에서 배운 TfidfVectorizer는 기본적으로 토큰 화가 되어있지 않은 텍스트 데이터를 입력으로 사용합니다. 이를 사용하기 위해 다시 토큰화 작업을 역으로 취소하는 역 토큰 화(Detokenization) 작업을 수행해 보겠습니다. # 역 토큰 화 (토큰화 작업을 되돌림) detokenized_doc = [] for i in range(len(text)): t = ' '.join(tokenized_doc[i]) detokenized_doc.append(t) # 다시 text['headline_text']에 재저장 text['headline_text'] = detokenized_doc 역 토큰 화가 되었는지 text['headline_text']의 5개의 샘플을 출력해 보겠습니다. text['headline_text'][:5] 0 decide community broadcast licence 1 fire witness must aware defamation 2 call infrastructure protection summit 3 staff aust strike rise 4 strike affect australian travellers Name: headline_text, dtype: object 정상적으로 역 토큰 화가 수행되었음을 확인할 수 있습니다. 이제 사이킷런의 TfidfVectorizer를 TF-IDF 행렬을 만들 것입니다. 텍스트 데이터에 있는 모든 단어를 가지고 행렬을 만들 수도 있겠지만, 여기서는 간단히 1,000개의 단어로 제한하겠습니다. # 상위 1,000개의 단어를 보존 vectorizer = TfidfVectorizer(stop_words='english', max_features= 1000) X = vectorizer.fit_transform(text['headline_text']) # TF-IDF 행렬의 크기 확인 print('TF-IDF 행렬의 크기 :',X.shape) TF-IDF 행렬의 크기 : (1082168, 1000) 1,082,168 × 1,000의 크기를 가진 가진 TF-IDF 행렬이 생겼습니다. 이제 이에 LDA를 수행합니다. 4) 토픽 모델링 lda_model = LatentDirichletAllocation(n_components=10, learning_method='online',random_state=777, max_iter=1) lda_top = lda_model.fit_transform(X) print(lda_model.components_) print(lda_model.components_.shape) [[1.00001533e-01 1.00001269e-01 1.00004179e-01 ... 1.00006124e-01 1.00003111e-01 1.00003064e-01] [1.00001199e-01 1.13513398e+03 3.50170830e+03 ... 1.00009349e-01 1.00001896e-01 1.00002937e-01] [1.00001811e-01 1.00001151e-01 1.00003566e-01 ... 1.00002693e-01 1.00002061e-01 7.53381835e+02] ... [1.00001065e-01 1.00001689e-01 1.00003278e-01 ... 1.00006721e-01 1.00004902e-01 1.00004759e-01] [1.00002401e-01 1.00000732e-01 1.00002989e-01 ... 1.00003517e-01 1.00001428e-01 1.00005266e-01] [1.00003427e-01 1.00002313e-01 1.00007340e-01 ... 1.00003732e-01 1.00001207e-01 1.00005153e-01]] (10, 1000) # 단어 집합. 1,000개의 단어가 저장됨. terms = vectorizer.get_feature_names() def get_topics(components, feature_names, n=5): for idx, topic in enumerate(components): print("Topic %d:" % (idx+1), [(feature_names[i], topic[i].round(2)) for i in topic.argsort()[:-n - 1:-1]]) get_topics(lda_model.components_,terms) Topic 1: [('government', 8725.19), ('sydney', 8393.29), ('queensland', 7720.12), ('change', 5874.27), ('home', 5674.38)] Topic 2: [('australia', 13691.08), ('australian', 11088.95), ('melbourne', 7528.43), ('world', 6707.7), ('south', 6677.03)] Topic 3: [('death', 5935.06), ('interview', 5924.98), ('kill', 5851.6), ('jail', 4632.85), ('life', 4275.27)] Topic 4: [('house', 6113.49), ('2016', 5488.19), ('state', 4923.41), ('brisbane', 4857.21), ('tasmania', 4610.97)] Topic 5: [('court', 7542.74), ('attack', 6959.64), ('open', 5663.0), ('face', 5193.63), ('warn', 5115.01)] Topic 6: [('market', 5545.86), ('rural', 5502.89), ('plan', 4828.71), ('indigenous', 4223.4), ('power', 3968.26)] Topic 7: [('charge', 8428.8), ('election', 7561.63), ('adelaide', 6758.36), ('make', 5658.99), ('test', 5062.69)] Topic 8: [('police', 12092.44), ('crash', 5281.14), ('drug', 4290.87), ('beat', 3257.58), ('rise', 2934.92)] Topic 9: [('fund', 4693.03), ('labor', 4047.69), ('national', 4038.68), ('council', 4006.62), ('claim', 3604.75)] Topic 10: [('trump', 11966.41), ('perth', 6456.53), ('report', 5611.33), ('school', 5465.06), ('woman', 5456.76)] 19-04 BERT를 이용한 키워드 추출 : 키 버트(KeyBERT) 키 버트 실습을 위해서는 우선 SBERT를 위한 패키지인 sentence_transformers를 설치해야 합니다. !pip install sentence_transformers 1. 기본 KeyBERT import numpy as np import itertools from sklearn.feature_extraction.text import CountVectorizer from sklearn.metrics.pairwise import cosine_similarity from sentence_transformers import SentenceTransformer 이 튜토리얼에서는 지도 학습에 대한 영어 문서를 사용합니다. 여러분들이 이미 친숙한 주제에 대한 문서이므로 키워드 추출이 잘 되고 있는지 여러분들이 직관적으로 판단하기에 좋은 예시일 것입니다. doc = """ Supervised learning is the machine learning task of learning a function that maps an input to an output based on example input-output pairs.[1] It infers a function from labeled training data consisting of a set of training examples.[2] In supervised learning, each example is a pair consisting of an input object (typically a vector) and a desired output value (also called the supervisory signal). A supervised learning algorithm analyzes the training data and produces an inferred function, which can be used for mapping new examples. An optimal scenario will allow for the algorithm to correctly determine the class labels for unseen instances. This requires the learning algorithm to generalize from the training data to unseen situations in a 'reasonable' way (see inductive bias). """ 여기서는 사이킷런의 CountVectorizer를 사용하여 단어를 추출합니다. CountVectorizer를 사용하는 이유는 n_gram_range의 인자를 사용하면 쉽게 n-gram을 추출할 수 있기 때문입니다. 예를 들어, (3, 3)로 설정하면 결과 후보는 3개의 단어를 한 묶음으로 간주하는 trigram을 추출합니다. # 3개의 단어 묶음인 단 어구 추출 n_gram_range = (3, 3) stop_words = "english" count = CountVectorizer(ngram_range=n_gram_range, stop_words=stop_words).fit([doc]) candidates = count.get_feature_names_out() print('trigram 개수 :',len(candidates)) print('trigram 다섯 개만 출력 :',candidates[:5]) trigram 개수 : 72 trigram 다섯 개만 출력 : ['algorithm analyzes training' 'algorithm correctly determine' 'algorithm generalize training' 'allow algorithm correctly' 'analyzes training data'] 다음으로 이제 문서와 문서로부터 추출한 키워드들을 SBERT를 통해서 수치화할 차례입니다. model = SentenceTransformer('distilbert-base-nli-mean-tokens') doc_embedding = model.encode([doc]) candidate_embeddings = model.encode(candidates) 이제 문서와 가장 유사한 키워드들을 추출합니다. 여기서는 문서와 가장 유사한 키워드들은 문서를 대표하기 위한 좋은 키워드라고 가정합니다. 상위 5개의 키워드를 출력합니다. top_n = 5 distances = cosine_similarity(doc_embedding, candidate_embeddings) keywords = [candidates[index] for index in distances.argsort()[0][-top_n:]] print(keywords) ['algorithm analyzes training', 'learning algorithm generalize', 'learning machine learning', 'learning algorithm analyzes', 'algorithm generalize training'] 5개의 키워드가 출력되는데, 이들의 의미가 좀 비슷해 보입니다. 비슷한 의미의 키워드들이 리턴되는 데는 이유가 있습니다. 당연히 이 키워드들이 문서를 가장 잘 나타내고 있기 때문입니다. 만약, 지금 출력한 것보다는 좀 더 다양한 의미의 키워드들이 출력된다면 이들을 그룹으로 본다는 관점에서는 해당 키워드들이 문서를 잘 나타낼 가능성이 적을 수도 있습니다. 따라서 키워드들을 다양하게 출력하고 싶다면 키워드 선정의 정확성과 키워드들의 다양성 사이의 미묘한 균형이 필요합니다. 여기서는 다양한 키워드들을 얻기 위해서 두 가지 알고리즘을 사용합니다. Max Sum Similarity Maximal Marginal Relevance 2. Max Sum Similarity 데이터 쌍 사이의 최대 합 거리는 데이터 쌍 간의 거리가 최대화되는 데이터 쌍으로 정의됩니다. 여기서의 의도는 후보 간의 유사성을 최소화하면서 문서와의 후보 유사성을 극대화하고자 하는 것입니다. def max_sum_sim(doc_embedding, candidate_embeddings, words, top_n, nr_candidates): # 문서와 각 키워드들 간의 유사도 distances = cosine_similarity(doc_embedding, candidate_embeddings) # 각 키워드들 간의 유사도 distances_candidates = cosine_similarity(candidate_embeddings, candidate_embeddings) # 코사인 유사도에 기반하여 키워드들 중 상위 top_n 개의 단어를 pick. words_idx = list(distances.argsort()[0][-nr_candidates:]) words_vals = [candidates[index] for index in words_idx] distances_candidates = distances_candidates[np.ix_(words_idx, words_idx)] # 각 키워드들 중에서 가장 덜 유사한 키워드들 간의 조합을 계산 min_sim = np.inf candidate = None for combination in itertools.combinations(range(len(words_idx)), top_n): sim = sum([distances_candidates[i][j] for i in combination for j in combination if i != j]) if sim < min_sim: candidate = combination min_sim = sim return [words_vals[idx] for idx in candidate] 이를 위해 상위 10개의 키워드를 선택하고 이 10개 중에서 서로 가장 유사성이 낮은 5개를 선택합니다. 낮은 nr_candidates를 설정하면 결과는 출력된 키워드 5개는 기존의 코사인 유사도만 사용한 것과 매우 유사한 것으로 보입니다. max_sum_sim(doc_embedding, candidate_embeddings, candidates, top_n=5, nr_candidates=10) ['requires learning algorithm', 'signal supervised learning', 'learning function maps', 'algorithm analyzes training', 'learning machine learning'] 그러나 상대적으로 높은 nr_candidates는 더 다양한 키워드 5개를 만듭니다. max_sum_sim(doc_embedding, candidate_embeddings, candidates, top_n=5, nr_candidates=20) ['set training examples', 'generalize training data', 'requires learning algorithm', 'supervised learning algorithm', 'learning machine learning'] 3. Maximal Marginal Relevance 결과를 다양화하는 마지막 방법은 MMR(Maximal Marginal Relevance)입니다. MMR은 텍스트 요약 작업에서 중복을 최소화하고 결과의 다양성을 극대화하기 위해 노력합니다. 참고할 수 있는 자료로 EmbedRank(https://arxiv.org/pdf/1801.04470.pdf)라는 키워드 추출 알고리즘은 키워드/키 프레이즈를 다양화하는 데 사용할 수 있는 MMR을 구현했습니다. 먼저 문서와 가장 유사한 키워드/키 프레이즈를 선택합니다. 그런 다음 문서와 유사하고 이미 선택된 키워드/키 프레이즈와 유사하지 않은 새로운 후보를 반복적으로 선택합니다. def mmr(doc_embedding, candidate_embeddings, words, top_n, diversity): # 문서와 각 키워드들 간의 유사도가 적혀있는 리스트 word_doc_similarity = cosine_similarity(candidate_embeddings, doc_embedding) # 각 키워드들 간의 유사도 word_similarity = cosine_similarity(candidate_embeddings) # 문서와 가장 높은 유사도를 가진 키워드의 인덱스를 추출. # 만약, 2번 문서가 가장 유사도가 높았다면 # keywords_idx = [2] keywords_idx = [np.argmax(word_doc_similarity)] # 가장 높은 유사도를 가진 키워드의 인덱스를 제외한 문서의 인덱스들 # 만약, 2번 문서가 가장 유사도가 높았다면 # ==> candidates_idx = [0, 1, 3, 4, 5, 6, 7, 8, 9, 10 ... 중략 ...] candidates_idx = [i for i in range(len(words)) if i != keywords_idx[0]] # 최고의 키워드는 이미 추출했으므로 top_n-1 번만큼 아래를 반복. # ex) top_n = 5라면, 아래의 loop는 4번 반복됨. for _ in range(top_n - 1): candidate_similarities = word_doc_similarity[candidates_idx, :] target_similarities = np.max(word_similarity[candidates_idx][:, keywords_idx], axis=1) # MMR을 계산 mmr = (1-diversity) * candidate_similarities - diversity * target_similarities.reshape(-1, 1) mmr_idx = candidates_idx[np.argmax(mmr)] # keywords & candidates를 업데이트 keywords_idx.append(mmr_idx) candidates_idx.remove(mmr_idx) return [words[idx] for idx in keywords_idx] 만약 상대적으로 낮은 diversity 값을 설정한다면, 결과는 기존의 코사인 유사도만 사용한 것과 매우 유사한 것으로 보입니다. mmr(doc_embedding, candidate_embeddings, candidates, top_n=5, diversity=0.2) ['algorithm generalize training', 'supervised learning algorithm', 'learning machine learning', 'learning algorithm analyzes', 'learning algorithm generalize'] 그러나 상대적으로 높은 diversity 값은 다양한 키워드 5개를 만들어냅니다. mmr(doc_embedding, candidate_embeddings, candidates, top_n=5, diversity=0.7) ['algorithm generalize training', 'labels unseen instances', 'new examples optimal', 'determine class labels', 'supervised learning algorithm'] 19-05 한국어 키 버트(Korean KeyBERT)를 이용한 키워드 추출 죄송합니다. 해당 자료는 위키독스 웹 사이트에서는 비공개 처리되어 구현 코드와 코드에 대한 상세한 설명은 유료 E-book을 구매하시면 확인할 수 있습니다. 19-06 BERT 기반 복합 토픽 모델(Combined Topic Models, CTM) 이번 챕터에서는 전통적인 빈도수 기반 문서 벡터화 방식인 Bag of Words와 사전 훈련된 언어 모델의 문서 임베딩 방식인 SBERT를 결합하여 사용하는 복합 토픽 모델(Combined Topic Models, CTM)에 대해서 실습해 봅시다. 실습을 위해 문맥을 반영한 토픽 모델 라이브러리인 contextualized-topic-models와 LDA 시각화 라이브러리인 pyldavis를 설치합니다. pip install contextualized-topic-models==2.2.0 pip install pyldavis 1. 문맥을 반영한 토픽 모델(Contextualized Topic Models) 시작에 앞서 문맥을 반영한 토픽 모델(Contextualized Topic Models)의 개념을 소개해 봅시다. 문맥을 반영한 토픽 모델(Contextualized Topic Models)은 문맥을 반영한 BERT의 문서 임베딩의 표현력과 기존 토픽 모델의 비지도 학습 능력을 결합하여 문서에서 주제를 가져오는 토픽 모델을 말합니다. 그리고 여기서 소개할 복합 토픽 모델(Combined Topic Models, CTM)은 문맥을 반영한 토픽 모델의 일종입니다. 2. 데이터 로드하기 학습을 위한 데이터로 하나의 라인(line)에 하나의 문서로 구성된 파일이 필요한데요. 우선, 여러분들의 데이터가 없다면 여기서 준비한 영문 위키피디아 파일로 실습을 해봅시다. # 데이터 다운로드 !wget https://raw.githubusercontent.com/vinid/data/master/dbpedia_sample_abstract_20k_unprep.txt 상위 3개의 라인만 출력해 봅시다. !head -n 3 dbpedia_sample_abstract_20k_unprep.txt The Mid-Peninsula Highway is a proposed freeway across the Niagara Peninsula in the Canadian province of Ontario. Although plans for a highway connecting Hamilton to Fort Erie south of the Niagara Escarpment have surfaced for decades, it was not until The Niagara Frontier International Gateway Study was published by the Ministry Monte Zucker (died March 15, 2007) was an American photographer. He specialized in wedding photography, entering it as a profession in 1947. In the 1970s he operated a studio in Silver Spring, Maryland. Later he lived in Florida. He was Brides Magazine's Wedding Photographer of the Year for 1990 and Henry Howard, 13th Earl of Suffolk, 6th Earl of Berkshire (8 August 1779 – 10 August 1779) was a British peer, the son of Henry Howard, 12th Earl of Suffolk. His father died on 7 March 1779, leaving behind his pregnant widow. The Earldom of Suffolk became dormant until she 실제 파일에는 줄바꿈이 없으나 위 출력 결과에서는 임의로 보기 편하도록 라인 별로 줄바꿈을 하였습니다. 파일명을 변수에 저장해둡시다. text_file = "dbpedia_sample_abstract_20k_unprep.txt" 3. 전처리 from contextualized_topic_models.models.ctm import CombinedTM from contextualized_topic_models.utils.data_preparation import TopicModelDataPreparation from contextualized_topic_models.utils.preprocessing import WhiteSpacePreprocessing import nltk Bag of Words 기반의 접근에서는 전처리 챕터에서 학습했던 정규화(Normalization) 과정이 굉장히 중요합니다. 다시 말해 특수 문자가 붙어서 동일한 단어가 다른 단어로 인식되지 않도록 특수 문자를 제거해 주고, 불용어를 제거하여 불필요한 단어들을 제거한 후에 빈도수가 높은 단어들을 사용하는 것이 좋습니다. 여기서는 NLTK에서 제공하는 영어 불용어들을 제거하고, 단어와 붙어있는 특수 문자를 제거하며, 영단어의 소문자화를 진행합니다. nltk.download('stopwords') documents = [line.strip() for line in open(text_file, encoding="utf-8").readlines()] sp = WhiteSpacePreprocessing(documents, stopwords_language='english') preprocessed_documents, unpreprocessed_corpus, vocab = sp.preprocess() 전처리 전, 후의 문서를 상위 2개를 출력하여 비교해 봅시다. # 전처리 전 문서 unpreprocessed_corpus[:2] ['The Mid-Peninsula Highway is a proposed freeway across the Niagara Peninsula in the Canadian province of Ontario. Although plans for a highway connecting Hamilton to Fort Erie south of the Niagara Escarpment have surfaced for decades, it was not until The Niagara Frontier International Gateway Study was published by the Ministry', "Monte Zucker (died March 15, 2007) was an American photographer. He specialized in wedding photography, entering it as a profession in 1947. In the 1970s he operated a studio in Silver Spring, Maryland. Later he lived in Florida. He was Brides Magazine's Wedding Photographer of the Year for 1990 and"] # normalization 전처리 후 문서 preprocessed_documents[:2] ['mid peninsula highway proposed across peninsula canadian province ontario although highway connecting hamilton fort south international study published ministry', 'died march american photographer specialized photography operated studio silver spring maryland later lived florida magazine photographer year'] 전체 단어 집합의 크기를 출력해 봅시다. # 전체 단어 집합의 크기 print('bag of words에 사용될 단어 집합의 크기 :',len(vocab)) bag of words에 사용될 단어 집합의 크기 : 2000 전체 단어 집합의 크기는 2,000입니다. WhiteSpacePreprocessing()의 vocabulary_size 인자의 기본값이 2000이 기 때문입니다. 전처리 되지 않은 문서는 문맥을 반영한 SBERT의 문서 임베딩을 얻기 위한 입력으로 사용할 것이기 때문에 제거해서는 안 됩니다. 전처리 전 문서와 전처리 후 문서를 TopicModelDataPreparation 객체에 넘겨줍니다. 이 객체는 bag of words와 문맥을 반영한 문서의 BERT 임베딩을 얻습니다. 여기서 사용할 pretrained BERT는 paraphrase-distilroberta-base-v1입니다. tp = TopicModelDataPreparation("paraphrase-distilroberta-base-v1") training_dataset = tp.fit(text_for_contextual=unpreprocessed_corpus, text_for_bow=preprocessed_documents) 이제 tp.vocab을 하면 단어 집합을 얻을 수 있는데, 이는 앞에서 vocab에 저장된 단어 집합과 동일합니다. len(tp.vocab) 2000 4. Combined TM 학습하기 이제 토픽 모델을 학습합니다. 여기서는 하이퍼 파라미터에 해당하는 토픽의 개수(n_components)로는 50개를 선정합니다. ctm = CombinedTM(bow_size=len(tp.vocab), contextual_size=768, n_components=50, num_epochs=20) ctm.fit(training_dataset) Epoch: [20/20] Seen Samples: [400000/400000] Train Loss: 135.494220703125 Time: 0:00:05.428048: : 20it [01:49, 5.47s/it] 5. 결과 출력 학습 후에는 토픽 모델이 선정한 토픽들을 보려면 get_topic_lists라는 메서드를 사용합니다. 해당 메서드에는 각 토픽마다 몇 개의 단어를 보고 싶은지에 해당하는 파라미터를 넣어 즐 수 있습니다. 여기서는 5개를 선택했습니다. 아래의 토픽들은 위키피디아(일반적인 주제)으로부터 얻은 토픽을 보여줍니다. 우리는 영어 문서로 학습하였으므로 각 토픽에 해당하는 단어들도 영어 단어들입니다. ctm.get_topic_lists(5) [['mi', 'kilometres', 'village', 'north', 'municipality'], ['national', 'house', 'built', 'historic', 'county'], ['used', 'defined', 'mathematics', 'number', 'typically'], ['film', 'directed', 'best', 'films', 'produced'], ['united', 'states', 'company', 'air', 'international'], ['species', 'family', 'found', 'native', 'genus'], ['composer', 'january', 'painter', 'studied', 'son'], ['station', 'line', 'located', 'railway', 'street'], ['church', 'roman', 'century', 'ancient', 'catholic'], ['county', 'school', 'high', 'state', 'located'], ['published', 'book', 'work', 'books', 'writer'], ['held', 'season', 'tournament', 'cup', 'championship'], ['made', 'born', 'english', 'first', 'played'], ['built', 'house', 'story', 'building', 'style'], ['war', 'world', 'series', 'television', 'first'], ['government', 'political', 'party', 'council', 'act'], ['american', 'new', 'york', 'known', 'born'], ['school', 'high', 'college', 'located', 'secondary'], ['published', 'written', 'book', 'fictional', 'novel'], ['area', 'river', 'located', 'park', 'lake'], ['born', 'summer', 'world', 'olympics', 'competed'], ['de', 'french', 'son', 'king', 'daughter'], ['university', 'served', 'american', 'law', 'born'], ['film', 'directed', 'written', 'drama', 'produced'], ['university', 'research', 'professor', 'india', 'institute'], ['war', 'class', 'royal', 'navy', 'army'], ['music', 'band', 'rock', 'singer', 'best'], ['born', 'played', 'former', 'professional', 'american'], ['album', 'band', 'released', 'rock', 'music'], ['used', 'use', 'system', 'software', 'model'], ['radio', 'company', 'station', 'broadcasting', 'owned'], ['played', 'born', 'football', 'former', 'league'], ['world', 'held', 'women', 'championships', 'place'], ['family', 'found', 'species', 'plant', 'mm'], ['member', 'party', 'politician', 'election', 'parliament'], ['island', 'point', 'antarctic', 'land', 'expedition'], ['states', 'united', 'county', 'list', 'national'], ['district', 'also', 'population', 'iran', 'persian'], ['enzyme', 'gene', 'belongs', 'chemical', 'humans'], ['region', 'area', 'province', 'municipality', 'part'], ['team', 'season', 'football', 'division', 'university'], ['released', 'album', 'band', 'studio', 'recorded'], ['city', 'town', 'england', 'located', 'miles'], ['mi', 'west', 'south', 'km', 'village'], ['mi', 'west', 'south', 'east', 'km'], ['league', 'club', 'football', 'team', 'season'], ['series', 'game', 'television', 'show', 'video'], ['line', 'station', 'railway', 'chinese', 'near'], ['company', 'based', 'founded', 'business', 'research'], ['politician', 'member', 'john', 'served', 'became']] 6. 시각화 토픽들을 시각화하기 위해서는 PyLDAvis를 사용합니다. lda_vis_data = ctm.get_ldavis_data_format(tp.vocab, training_dataset, n_samples=10) Sampling: [10/10]: : 10it [00:52, 5.25s/it] import pyLDAvis as vis lda_vis_data = ctm.get_ldavis_data_format(tp.vocab, training_dataset, n_samples=10) ctm_pd = vis.prepare(**lda_vis_data) vis.display(ctm_pd) 7. 예측 import numpy as np 임의의 문서를 가져와서 어떤 토픽이 할당되었는지 확인할 수 있습니다. 예를 들어, 반도(peninsula)에 대한 주제를 담고 있는 첫 번째 전처리 된 문서의 토픽을 예측해 봅시다. topics_predictions = ctm.get_thetas(training_dataset, n_samples=5) # get all the topic predictions Sampling: [5/5]: : 5it [00:23, 4.74s/it] # 전처리 문서의 첫 번째 문서 print(preprocessed_documents[0]) mid peninsula highway proposed across peninsula canadian province ontario although highway connecting hamilton fort south international study published ministry 첫 번째 문서에 대한 토픽을 추출해 봅시다. ctm.get_topic_lists(5)[topic_number] ['located', 'river', 'north', 'state', 'km'] 8. 모델 저장 및 로드하기 현재 경로에 모델을 저장합니다. ctm.save(models_dir="./") 현재 ctm이라는 변수에 할당된 모델을 삭제합니다. del ctm 저장한 모델을 로드합니다. ctm = CombinedTM(bow_size=len(tp.vocab), contextual_size=768, num_epochs=100, n_components=50) ctm.load("/content/contextualized_topic_model_nc_50_tpm_0.0_tpv_0.98_hs_prodLDA_ac_(100, 100)_do_softplus_lr_0.2_mo_0.002_rp_0.99", epoch=19) ctm.get_topic_lists(5) [['politician', 'member', 'born', 'party', 'served'], ['mi', 'county', 'km', 'south', 'east'], ['church', 'century', 'roman', 'greek', 'latin'], ['team', 'season', 'home', 'football', 'games'], ['album', 'released', 'band', 'first', 'music'], ['school', 'university', 'college', 'education', 'public'], ['university', 'professor', 'author', 'research', 'work'], ['party', 'member', 'election', 'council', 'elections'], ['located', 'river', 'north', 'state', 'km'], ['mi', 'village', 'approximately', 'km', 'south'], ['mi', 'west', 'approximately', 'east', 'kilometres'], ['school', 'high', 'county', 'district', 'located'], ['built', 'house', 'story', 'style', 'building'], ['station', 'radio', 'licensed', 'fm', 'owned'], ['war', 'air', 'royal', 'navy', 'army'], ['american', 'born', 'former', 'football', 'college'], ['state', 'city', 'area', 'county', 'located'], ['station', 'railway', 'city', 'line', 'airport'], ['published', 'game', 'book', 'first', 'released'], ['family', 'genus', 'brown', 'species', 'found'], ['season', 'league', 'club', 'football', 'team'], ['american', 'team', 'season', 'football', 'played'], ['war', 'world', 'ii', 'cross', 'summer'], ['son', 'de', 'king', 'french', 'daughter'], ['series', 'produced', 'television', 'film', 'directed'], ['united', 'states', 'county', 'national', 'park'], ['railway', 'bridge', 'river', 'island', 'station'], ['written', 'film', 'novel', 'directed', 'published'], ['born', 'played', 'made', 'english', 'first'], ['film', 'directed', 'produced', 'best', 'stars'], ['born', 'world', 'competed', 'silver', 'summer'], ['island', 'mountain', 'islands', 'range', 'land'], ['held', 'world', 'championship', 'tournament', 'cup'], ['system', 'data', 'systems', 'computer', 'software'], ['organization', 'established', 'education', 'research', 'international'], ['either', 'used', 'term', 'space', 'using'], ['album', 'released', 'band', 'rock', 'music'], ['family', 'species', 'found', 'mm', 'native'], ['government', 'established', 'political', 'responsible', 'act'], ['company', 'based', 'founded', 'group', 'business'], ['american', 'known', 'born', 'best', 'york'], ['village', 'town', 'england', 'parish', 'civil'], ['states', 'united', 'state', 'served', 'member'], ['also', 'district', 'population', 'persian', 'iran'], ['painter', 'studied', 'artist', 'work', 'composer'], ['television', 'radio', 'show', 'series', 'music'], ['played', 'professional', 'born', 'league', 'player'], ['often', 'chemical', 'different', 'means', 'associated'], ['game', 'series', 'car', 'held', 'racing'], ['region', 'municipality', 'area', 'province', 'located']] 19-07 BERT 기반 한국어 복합 토픽 모델(Korean CTM) 이번 챕터에서는 전통적인 빈도수 기반 문서 벡터화 방식인 Bag of Words와 사전 훈련된 언어 모델의 문서 임베딩 방식인 SBERT를 결합하여 사용하는 복합 토픽 모델(Combined Topic Models, CTM)에 대해서 실습해 봅시다. 실습을 위해 문맥을 반영한 토픽 모델 라이브러리인 contextualized-topic-models와 LDA 시각화 라이브러리인 pyldavis, 그리고 형태소 분석기 Mecab을 설치합니다. pip install contextualized-topic-models==2.2.0 pip install pyldavis # Colab에 Mecab 설치 !git clone https://github.com/SOMJANG/Mecab-ko-for-Google-Colab.git %cd Mecab-ko-for-Google-Colab !bash install_mecab-ko_on_colab190912.sh 1. 문맥을 반영한 토픽 모델(Contextualized Topic Models) 시작에 앞서 문맥을 반영한 토픽 모델(Contextualized Topic Models)의 개념을 소개해 봅시다. 문맥을 반영한 토픽 모델(Contextualized Topic Models)은 문맥을 반영한 BERT의 문서 임베딩의 표현력과 기존 토픽 모델의 비지도 학습 능력을 결합하여 문서에서 주제를 가져오는 토픽 모델을 말합니다. 그리고 여기서 소개할 복합 토픽 모델(Combined Topic Models, CTM)은 문맥을 반영한 토픽 모델의 일종입니다. 2. 한국어에 적용하기 복합 토픽 모델을 한국어에 적용하기 위해서는 추가적인 코드 수정이 필요합니다. 우선 CTM은 내부적으로 사이킷런의 CountVectorizer를 사용하고 있으나, CountVectorizer는 단순히 띄어쓰기 토큰화를 수행하므로 한국어에는 적절하지 않습니다. 이에 형태소 분석기 Mecab을 사용하였으며, SBERT도 한국어에 대한 문서 임베딩 값을 얻을 수 있어야 하므로 SBERT의 임베딩 또한 한국어를 포함한 다국어 BERT로 변경하였습니다. 상세 코드는 github에 공개하였으며 여기서는 결과만<NAME>겠습니다. 별도의 불용어 처리는 해주지 않았으므로 좀 더 섬세한 결과를 얻고 싶다면 불용어도 추가해 보시기 바랍니다. 깃허브 링크 : https://github.com/ukairia777/bert-topic-models ctm.get_topics(5) defaultdict(list, {0: ['된다는', '인원', '충분', '고통', '분명'], 1: ['제작', '발표회', '스퀘어', '압구정', '족보'], 2: ['대통령', '유용', '불법행위', '갤러리', '재단'], 3: ['공시', '투데이', '머니', '리얼타임', '취득'], 4: ['아이템', '컬러', '재킷', '소재', '다운'], 5: ['수수료', '편의점', '인출', '현금', '서비스'], 6: ['도어', '기관사', '출입문', '스크린', '전동차'], 7: ['제작', '남자', '사랑', '압구정', '김영광'], 8: ['마포구', '케이스', '취하', '엔터', '강남구'], 9: ['환자', '수술', '권역', '응급', '외상'], 10: ['패션', '디자이너', '디자인', '2017', '위크'], 11: ['에서', '어요', '지만', '소설', '사람'], 12: ['캔디', '그램', '전현무', '장근석', '고성희'], 13: ['방송', '가이드라인', '지상파', '사업자', '유료'], 14: ['자유', '된다는', '크기', '고양', '평창'], 15: ['기권', '장관', '회고록', '남북', '안보'], 16: ['뉴스', '여의도', '코리아', '회견', '선언'], 17: ['네이버', '이사회', '의장', '한성숙', '선임'], 18: ['디자이너', '패션', '디자인', '신진', '2017'], 19: ['는 다는', '따로', '2008', '된다는', '통해서'], 20: ['습니다', '범인', '경찰', '경찰관', '사제'], 21: ['서울', '법원', '판결', '가정', '지법'], 22: ['가계', '부채', '경제', '건전', '으로'], 23: ['으로', '에서', '투자', '일자', '센서스'], 24: ['대본', '연기', '도깨비', '드라마', '모습'], 25: ['습니다', '으로', '때문', '공제', '는데요'], 26: ['국회', '병우', '국감', '운영', '수석'], 27: ['기온', '아침', '동해', '구름', '기상청'], 28: ['중구', '포토', '동아닷컴', '을지로', '열린'], 29: ['뉴시스', '영상', '공감', '언론', '제보'], 30: ['테스트', '성능', '20', '테슬라', '소프트웨어'], 31: ['84', '지상', '가구', '면적', '블록'], 32: ['공개', '박해진', '화보', '메이크업', '촬영'], 33: ['으로', '에서', '기업', '한다', '경제'], 34: ['지검', '소환', '문체', '기소', '검찰'], 35: ['그룹', '이스', '데뷔', '음원', '차트'], 36: ['배우', '영화', '차태현', '사랑', '제작'], 37: ['에게', '커플', '사람', '나리', '정원'], 38: ['대표', '개헌', '탈당', '공화국', '지대'], 39: ['부터', '행사', '이벤트', '여행', '체험'], 40: ['모여', '세월', '2008', '바퀴', '상인'], 41: ['원대', '매물', '주체', '거래량', '으로'], 42: ['교육', '청소년', '마당', '진로', '대회'], 43: ['뉴시스', '영상', '공감', '언론', '사진'], 44: ['편입', '경력', '기업', '채용', '한전'], 45: ['트럼프', '토론', '대선', '공화', '후보'], 46: ['영상', '뉴시스', '언론', '공감', '제보'], 47: ['화성', '미국', '착륙', '위협', '방어'], 48: ['원유', '유가', '뉴욕', '오른', '연방'], 49: ['지역', '사업', '지원', '복지', '시흥']}) 위에서 출력한 토픽 번호는 pyLDAvis에서 할당한 토픽 번호와 일치하지 않으므로 주의합시다. 가령, 48번 토픽이었던 ['원유', '유가', '뉴욕', '오른', '연방']가 아래의 PyLDAvis에서는 24번 토픽이 되었습니다. 19-08 버토픽(BERTopic) SBERT를 이용한 토픽 모델인 BERTopic은 별도 논문은 나오지 않은 모델이지만, github에서 2k 이상의 스타를 받았을 만큼 굉장히 주목받고 있는 토픽 모델입니다. 개발자는 BERTopic이 LDA를 대체할 수 있을 만큼의 기술이라고 확신을 얻었다고 주장합니다. 여기서는 BERT 기반의 토픽 모델링 구현체인 BERTopic의 간단한 사용 방법에 대해서 다룹니다. !pip install bertopic[visualization] 1. BERTopic BERTopic은 BERT embeddings과 클래스 기반(class-based) TF-IDF를 활용하여 주제 설명에서 중요한 단어를 유지하면서도 쉽게 해석할 수 있는 조밀한 클러스터를 만드는 토픽 모델링 기술입니다. BERTopic 알고리즘은 크게 세 가지 과정을 거칩니다. 1) 텍스트 데이터를 SBERT로 임베딩합니다. SBERT를 사용하여 문서를 임베딩합니다. 이때, BERTopic은 기본적으로 아래의 BERT들을 사용합니다. "paraphrase-MiniLM-L6-v2" : 영어 데이터로 학습된 SBERT "paraphrase-multilingual-MiniLM-L12-v2" : 50개 이상의 언어로 학습된 다국어 SBERT 2) 문서를 군집화합니다. UMAP을 사용하여 임베딩의 차원을 줄이고 HDBSCAN 기술을 사용하여 차원 축소된 임베딩을 클러스터링하고 의미적으로 유사한 문서 클러스터를 생성합니다. 3) 토픽 표현을 생성 마지막 단계는 클래스 기반 TF-IDF로 토픽을 추출합니다. 2. 데이터 로드 from bertopic import BERTopic from sklearn.datasets import fetch_20newsgroups 사이킷런에서 제공하는 유명 데이터 셋인 20뉴스 그룹 데이터를 로드하고 상위 5개의 샘플을 출력해 봅시다. docs = fetch_20newsgroups(subset='all', remove=('headers', 'footers', 'quotes'))['data'] docs[:5] 지면의 한계로 여기서는 별도로 보여드리진 않았습니다. 현재 docs는 문자열의 리스트입니다. 전체 샘플의 개수를 출력해 봅시다. print('총 문서의 수 :', len(docs)) 총 문서의 수 : 18846 총 문서의 수는 18,846개입니다. 3. 토픽 모델링 BERTopic의 모델 객체를 만들고, fit_transform 메서드에 문자열들의 리스트를 입력으로 넣으면 토픽 모델링을 수행합니다. model = BERTopic() topics, probabilities = model.fit_transform(docs) print('각 문서의 토픽 번호 리스트 :',len(topics)) print('첫 번째 문서의 토픽 번호 :', topics[0]) 각 문서의 토픽 번호 리스트 : 18846 첫 번째 문서의 토픽 번호 : 0 get_topic_info() 메서드를 사용하여 토픽의 개수, 토픽의 크기, 각 토픽에 할당된 단어들을 일부 볼 수 있습니다. model.get_topic_info() Count 열의 값을 모두 합하면 총 문서의 수입니다. model.get_topic_info()['Count'].sum() 18846 위의 출력에서 Topic -1이 가장 큰 것으로 보입니다. -1은 토픽이 할당되지 않은 모든 이상치 문서(outliers)들을 나타냅니다. 현재 0번 토픽부터 210번 토픽까지 있는데, 임의로 5번 토픽에 대해서 단어들을 출력해 봅시다. get_topic() 메서드의 입력으로 보고자 하는 토픽의 번호를 넣어줍니다. model.get_topic(5) [('drive', 0.036501379524217024), ('scsi', 0.027358077330910547), ('drives', 0.0229861502896249), ('ide', 0.019274207233754368), ('disk', 0.01808211458113983), ('controller', 0.016803056719952875), ('hard', 0.013004806725656367), ('scsi2', 0.012107882273732159), ('bios', 0.009949766797753059), ('scsi1', 0.009350150086818809)] 4. 토픽 시각화 BERTopic을 사용하면 LDAvis와 매우 유사한 방식으로 생성된 토픽을 시각화할 수 있습니다. 시각화를 통해 생성된 토픽에 대해 더 많은 통찰력을 얻을 수 있습니다. 우선 visualize_topics() 메서드로 시각화를 진행해 봅시다. model.visualize_topics() 5. 단어 시각화 Visualization_barchart() 메서드는 c-TF-IDF 점수에서 막대 차트를 만들어 각 토픽에 대해 선택된 단어들을 표시합니다. 각 토픽에 대해서 선택된 단어들을 비교할 수 있습니다. 6. 토픽 유사도 시각화 각 토픽들이 서로 얼마나 유사한지 시각화할 수도 있습니다. visualize_heatmap() 메서드를 사용하여 히트맵을 시각화합니다. 해당 히트맵의 원하는 위치에 마우스를 갖다 대면 실질적인 유사도 값을 확인할 수 있습니다. model.visualize_heatmap() 7. 토픽의 수 정하기 때때로 너무 많은 토픽이 생성되거나 너무 적은 토픽이 생성될 수 있습니다. 토픽의 수를 직접 정하고 싶다면 몇 가지 방법이 존재합니다. 첫 번째 방법은 모델 객체 생성 시에 nr_topics 값으로 원하는 토픽 수를 입력하여 원하는 토픽의 수를 설정할 수 있습니다. BERTopic은 유사한 토픽들을 찾아 하나의 토픽으로 병합합니다. 다음은 20개의 토픽으로 토픽의 수를 축소한 후 시각화하는 모습을 보여줍니다. model = BERTopic(nr_topics=20) topics, probabilities = model.fit_transform(docs) model.visualize_topics() 또 다른 방법은 모델이 자동으로 토픽의 수를 줄이도록 설정하는 것입니다. 이 옵션을 사용하려면 모델 객체 생성 시에 "nr_topics"의 값을 "auto"로 설정하면 됩니다. model = BERTopic(nr_topics="auto") topics, probabilities = model.fit_transform(docs) model.get_topic_info() 토픽의 개수를 지정하지 않았을 때는 0번 토픽부터 210번 토픽까지 총 211개의 토픽이 존재하였으나, 자동으로 토픽의 수가 줄어들도록 설정하자 토픽의 수가 0번부터 143번까지 총 144개로 줄어든 것을 확인할 수 있습니다. 8. 임의의 문서에 대한 예측 학습된 토픽 모델에 어떤 임의의 문서를 입력하여 해당 문서의 주요 토픽이 무엇인지를 예측하고 싶다면 transform()이라는 메서드를 사용합니다. 학습에 사용했던 첫 번째 문서를 입력으로 하여 해당 문서의 주요 토픽 번호를 출력해 봅시다. new_doc = docs[0] print(new_doc) I am sure some bashers of Pens fans are pretty confused about the lack of any kind of posts about the recent Pens massacre of the Devils. Actually, I am bit puzzled too and a bit relieved. However, I am going to put an end to non-PIttsburghers' relief with a bit of praise for the Pens. Man, they are killing those Devils worse than I thought. Jagr just showed you why he is much better than his regular season stats. He is also a lot fo fun to watch in the playoffs. Bowman should let JAgr have a lot of fun in the next couple of games since the Pens are going to beat the pulp out of Jersey anyway. I was very disappointed not to see the Islanders lose the final regular season game. PENS RULE!!! topics, probs = model.transform([new_doc]) print('예측한 토픽 번호 :', topics) 예측한 토픽 번호 : [0] 9. 모델 저장과 로드 save()와 load() 메서드를 사용하여 모델을 저장하고 로드할 수 있습니다. model.save("my_topics_model") BerTopic_model = BERTopic.load("my_topics_model") 19-09 한국어 버토픽(Korean BERTopic) SBERT를 이용한 토픽 모델인 BERTopic은 github에서 2k 이상의 스타를 받았을 만큼 굉장히 주목받고 있는 토픽 모델입니다. 개발자는 BERTopic이 LDA를 대체할 수 있을 만큼의 기술이라고 확신을 얻었다고 주장합니다. 여기서는 BERT 기반의 토픽 모델링 구현체인 BERTopic의 간단한 사용 방법에 대해서 다룹니다. !pip install bertopic[visualization] # Colab에 Mecab 설치 !git clone https://github.com/SOMJANG/Mecab-ko-for-Google-Colab.git %cd Mecab-ko-for-Google-Colab !bash install_mecab-ko_on_colab190912.sh 1. BERTopic BERTopic은 BERT embeddings과 클래스 기반(class-based) TF-IDF를 활용하여 주제 설명에서 중요한 단어를 유지하면서도 쉽게 해석할 수 있는 조밀한 클러스터를 만드는 토픽 모델링 기술입니다. BERTopic 알고리즘은 크게 세 가지 과정을 거칩니다. 1) 텍스트 데이터를 SBERT로 임베딩합니다. 이때, 이번 실습에서는 한국어 데이터를 사용하므로 SBERT로 한국어 BERT나 한국어가 포함된 다국어 BERT를 사용해야 합니다. 2) 문서를 군집화합니다. UMAP을 사용하여 임베딩의 차원을 줄이고 HDBSCAN 기술을 사용하여 차원 축소된 임베딩을 클러스터링하고 의미적으로 유사한 문서 클러스터를 생성합니다. 3) 토픽 표현을 생성 마지막 단계는 클래스 기반 TF-IDF로 토픽을 추출합니다. 이때 사이킷런의 CountVectorizer를 사용하는데, CountVectorizer는 별도 토크 나이저를 지정해 주지 않으면 띄어쓰기 단위 토큰화를 수행합니다. 하지만, 한국어에서 띄어쓰기 단위 토큰화는 지양되므로 이번 실습에서는 형태소 분석기 Mecab을 사용합니다. 2. 한국어에 적용하기 복합 토픽 모델을 한국어에 적용하기 위해서는 추가적인 코드 수정이 필요합니다. 우선 BERTopic은 내부적으로 사이킷런의 CountVectorizer를 사용하고 있으나, CountVectorizer는 단순히 띄어쓰기 토큰화를 수행하므로 한국어에는 적절하지 않습니다. 이에 형태소 분석기 Mecab을 사용하였으며, SBERT도 한국어에 대한 문서 임베딩 값을 얻을 수 있어야 하므로 SBERT의 임베딩 또한 한국어를 포함한 다국어 BERT로 변경하였습니다. 상세 코드는 github에 공개하였으며 여기서는 결과만<NAME>겠습니다. 별도의 불용어 처리는 해주지 않았으므로 좀 더 섬세한 결과를 얻고 싶다면 불용어도 추가해 보시기 바랍니다. 깃허브 링크 : https://github.com/ukairia777/KoBERTopic 20. 텍스트 요약(Text Summarization) 텍스트 요약은 상대적으로 큰 원문을 핵심 내용만 간추려서 상대적으로 작은 요약문으로 변환하는 것을 말합니다. 뒤에서 좀 더 자세히 설명하겠지만, 텍스트 요약은 주로 추출적 요약과 추상적 요약으로 나눕니다. 추상적 요약은 출처에 따라서는 생성 요약이라고 표현하기도 합니다. 이 책에서는 LSTM을 이용하여 seq2seq를 구현하여 생성 요약(추상적 요약)과 텍스트 랭크라는 머신 러닝 알고리즘을 사용하여 추출적 요약을 하는 두 가지 예시에 대해서 다룹니다. 좀 더 고도화된 추출적 요약과 생성 요약을 하는 방법으로는 BERT로 추출적 요약으로 구현하는 방법과, GPT-2나 BART 또는 T5로 생성 요약을 구현하는 방법이 존재합니다. 이 책이 집필될 당시에는 아쉽게도 쓸만한 공개된 한국어 요약 데이터가 공개되지 않았던 시점이라서 고도화된 방법에 대해서는 다루지 못하였지만, 추후 이 책의 2판이 나오게 된다면 한국어 데이터로 BERT와 GPT-2를 이용한 고도화된 예시를 업데이트할 수 있기를 기대합니다. 20-01 어텐션을 이용한 텍스트 요약(Text Summarization with Attention mechanism) 텍스트 요약은 상대적으로 큰 원문을 핵심 내용만 간추려서 상대적으로 작은 요약문으로 변환하는 것을 말합니다. 읽는 사람이 시간을 단축해서 내용을 빠르게 이해할 수 있다는 점에서 글을 많이 쓰는 사람들에게는 꼭 필요한 능력 중 하나인 것 같습니다. 그런데 만약 기계가 이를 자동으로 해줄 수만 있다면 얼마나 좋을까요? 이번 실습에서는 그중 한 가지 방법인 seq2seq를 구현해 보겠습니다. 그리고 어텐션 메커니즘(attention mechanism)을 적용해 봅시다. 이번 챕터는 시퀀스-투-시퀀스(Sequences-to-Sequence, seq2seq) 챕터를 선행하시는 것이 좋습니다. 모델을 설계하는 코드가 거의 동일합니다. 1. 텍스트 요약(Text Summarization) 텍스트 요약은 크게 추출적 요약(extractive summarization)과 추상적 요약(abstractive summarization)으로 나뉩니다. 1) 추출적 요약(extractive summarization) 추출적 요약은 원문에서 중요한 핵심 문장 또는 단 어구를 몇 개 뽑아서 이들로 구성된 요약문을 만드는 방법입니다. 그렇기 때문에 추출적 요약의 결과로 나온 요약문의 문장이나 단 어구들은 전부 원문에 있는 문장들입니다. 추출적 요약의 대표적인 알고리즘으로 머신 러닝 알고리즘인 텍스트 랭크(TextRank)가 있는데, 아래의 링크에서 텍스트 랭크로 구현된 세 줄 요약기를 시험해 볼 수 있습니다. 링크 : https://summariz3.herokuapp.com/ 위 링크로 이동하여 인터넷 뉴스나 가지고 있는 글을을 복사 + 붙여넣기하여 결과를 살펴보세요. 세 개의 문장은 전부 원문에 존재하던 문장들입니다. 이 방법의 단점이라면, 이미 존재하는 문장이나 단어 구로만 구성하므로 모델의 언어 표현 능력이 제한된다는 점입니다. 그렇다면 마치 사람처럼 원문에 없던 단어나 문장을 사용하면서 핵심만 간추려서 표현하는 요약 방법은 없을까요? 2) 추상적 요약(abstractive summarization) 추상적 요약은 원문에 없던 문장이라도 핵심 문맥을 반영한 새로운 문장을 생성해서 원문을 요약하는 방법입니다. 마치 사람이 요약하는 것 같은 방식인데, 당연히 추출적 요약보다는 난도가 높습니다. 이 방법은 주로 인공 신경망을 사용하며 대표적인 모델로 seq2seq가 있습니다. 이 방법의 단점이라면 seq2seq와 같은 인공 신경망들은 기본적으로 지도 학습이라는 점입니다. 다시 말해 추상적 요약을 인공 신경망으로 훈련하기 위해서는 '원문' 그뿐만 아니라 '실제 요약문'이라는 레이블 데이터가 있어야 합니다. 그렇기 때문에 데이터를 구성하는 것 자체가 하나의 부담입니다. 이번 챕터에서는 이미 공개된 데이터를 사용해서 추상적 요약을 실습해 보겠습니다. 2. 아마존 리뷰 데이터에 대한 이해 이번 챕터에서 사용할 데이터는 아마존 리뷰 데이터입니다. 아래의 링크에서 데이터를 다운로드합니다. 링크 : https://www.kaggle.com/snap/amazon-fine-food-reviews 우선 실습에 필요한 도구들을 임포트 합니다. import numpy as np import pandas as pd import re import matplotlib.pyplot as plt from nltk.corpus import stopwords from bs4 import BeautifulSoup from tensorflow.keras.preprocessing.text import Tokenizer from tensorflow.keras.preprocessing.sequence import pad_sequences import urllib.request np.random.seed(seed=0) 1) 데이터 로드하기 Reviews.csv 파일을 불러와 데이터 프레임에 저장하겠습니다. 이 데이터는 실제로는 약 56만 개의 샘플을 가지고 있습니다. 하지만 여기서는 간단히 10만 개의 샘플만 사용하겠습니다. 이는 pd.read_csv의 nrows의 인자로 10만이라는 숫자를 적어주면 됩니다. # Reviews.csv 파일을 data라는 이름의 데이터 프레임에 저장. 단, 10만 개의 행(rows)으로 제한. data = pd.read_csv("Reviews.csv 파일의 경로", nrows = 100000) print('전체 리뷰 개수 :',(len(data))) 전체 리뷰 개수 : 100000 전체 리뷰 개수가 10만 개인 것을 확인했습니다. 5개의 샘플만 출력해 봅시다. data.head() 지면의 한계로 생략 5개의 샘플을 출력해 보면 'Id', 'ProductId', 'UserId', 'ProfileName', 'HelpfulnessNumerator', 'HelpfulnessDenominator', 'Score', 'Time', 'Summary', 'Text'이라는 10개의 열이 존재함을 알 수 있습니다. 그런데 사실 이 중 필요한 열은 'Text'열과 'Summary'열뿐입니다. Text 열과 Summary 열만을 분리하고, 다른 열들은 데이터에서 제외해서 재저장합니다. 그리고 5개의 샘플을 출력합니다. data = data[['Text','Summary']] data.head() Text 열과 Summary 열만 저장된 것을 확인할 수 있습니다. Text 열이 원문이고, Summary 열이 Text 열에 대한 요약입니다. 다시 말해 모델은 Text(원문)으로부터 Summary(요약)을 예측하도록 훈련됩니다. 랜덤으로 샘플 몇 가지를 더 출력해 봅시다. # 랜덤으로 10개의 샘플 출력 data.sample(10) 여기서는 data.sample(10)를 한 번만 실행했지만 지속적으로 몇 차례 더 실행하면서 샘플의 구조를 확인해 보세요. 원문은 꽤 긴 반면에, Summary에는 3~4개의 단어만으로 구성된 경우도 많아 보입니다. 2) 데이터 정제하기 데이터에 중복 샘플이 있는지 확인해 보겠습니다. print('Text 열에서 중복을 배제한 유일한 샘플의 수 :', data['Text'].nunique()) print('Summary 열에서 중복을 배제한 유일한 샘플의 수 :', data['Summary'].nunique()) Text 열에서 중복을 배제한 유일한 샘플의 수 : 88426 Summary 열에서 중복을 배제한 유일한 샘플의 수 : 72348 전체 데이터는 10만 개의 샘플이 존재하지만, 실제로는 꽤 많은 원문이 중복되어 중복을 배제한 유일한 원문의 개수는 88,426개입니다. 중복 샘플이 무려 약 1,200개나 있다는 의미지요. Summary는 중복이 더 많지만, 원문은 다르더라도 짧은 문장인 요약은 내용이 겹칠 수 있음을 가정하고 일단 두겠습니다. Summary의 길이 분포는 뒤에서 확인하겠습니다. # text 열에서 중복인 내용이 있다면 중복 제거 data.drop_duplicates(subset=['Text'], inplace=True) print("전체 샘플 수 :", len(data)) 전체 샘플 수 : 88426 중복을 제거하여 88,426개의 샘플만 존재합니다. 이제 Null 샘플이 존재하는지 확인해 봅시다. print(data.isnull().sum()) Text 0 Summary 1 dtype: int64 Summary에서 1개의 Null 샘플이 남아있습니다. 이를 제거해 줍니다. # Null 값을 가진 샘플 제거 data.dropna(axis=0, inplace=True) print('전체 샘플 수 :',(len(data))) 전체 샘플 수 : 88425 이제 남은 샘플 수는 88,425개입니다. 지금까지는 불필요한 샘플의 수를 줄이기 위한 정제 과정이었습니다. 이제 샘플 내부를 전처리해야 합니다. 단어 정규화와 불용어 제거를 위해 각각의 참고 자료가 필요합니다. 동일한 의미를 가졌지만 스펠링이 다른 단어들을 정규화하기 위한 사전을 만듭니다. 이 사전은 아래의 링크를 참고하여 만들어진 사전입니다. 링크 : https://stackoverflow.com/questions/19790188/expanding-english-language-contractions-in-python # 전처리 함수 내 사용 contractions = {"'cause": 'because', "I'd": 'I would', "I'd've": 'I would have', "I'll": 'I will', "I'll've": 'I will have', "I'm": 'I am', "I've": 'I have', "ain't": 'is not', "aren't": 'are not', "can't": 'cannot', "could've": 'could have', "couldn't": 'could not', "didn't": 'did not', "doesn't": 'does not', "don't": 'do not', "hadn't": 'had not', "hasn't": 'has not', "haven't": 'have not', "he'd": 'he would', "he'll": 'he will', "he's": 'he is', "here's": 'here is', "how'd": 'how did', "how'd'y": 'how do you', "how'll": 'how will', "how's": 'how is', "i'd": 'i would', "i'd've": 'i would have', "i'll": 'i will', "i'll've": 'i will have', "i'm": 'i am', "i've": 'i have', "isn't": 'is not', "it'd": 'it would', "it'd've": 'it would have', "it'll": 'it will', "it'll've": 'it will have', "it's": 'it is', "let's": 'let us', "ma'am": 'madam', "mayn't": 'may not', "might've": 'might have', "mightn't": 'might not', "mightn't've": 'might not have', "must've": 'must have', "mustn't": 'must not', "mustn't've": 'must not have', "needn't": 'need not', "needn't've": 'need not have', "o'clock": 'of the clock', "oughtn't": 'ought not', "oughtn't've": 'ought not have', "sha'n't": 'shall not', "shan't": 'shall not', "shan't've": 'shall not have', "she'd": 'she would', "she'd've": 'she would have', "she'll": 'she will', "she'll've": 'she will have', "she's": 'she is', "should've": 'should have', "shouldn't": 'should not', "shouldn't've": 'should not have', "so's": 'so as', "so've": 'so have', "that'd": 'that would', "that'd've": 'that would have', "that's": 'that is', "there'd": 'there would', "there'd've": 'there would have', "there's": 'there is', "they'd": 'they would', "they'd've": 'they would have', "they'll": 'they will', "they'll've": 'they will have', "they're": 'they are', "they've": 'they have', "this's": 'this is', "to've": 'to have', "wasn't": 'was not', "we'd": 'we would', "we'd've": 'we would have', "we'll": 'we will', "we'll've": 'we will have', "we're": 'we are', "we've": 'we have', "weren't": 'were not', "what'll": 'what will', "what'll've": 'what will have', "what're": 'what are', "what's": 'what is', "what've": 'what have', "when's": 'when is', "when've": 'when have', "where'd": 'where did', "where's": 'where is', "where've": 'where have', "who'll": 'who will', "who'll've": 'who will have', "who's": 'who is', "who've": 'who have', "why's": 'why is', "why've": 'why have', "will've": 'will have', "won't": 'will not', "won't've": 'will not have', "would've": 'would have', "wouldn't": 'would not', "wouldn't've": 'would not have', "y'all": 'you all', "y'all'd": 'you all would', "y'all'd've": 'you all would have', "y'all're": 'you all are', "y'all've": 'you all have', "you'd": 'you would', "you'd've": 'you would have', "you'll": 'you will', "you'll've": 'you will have', "you're": 'you are', "you've": 'you have'} NLTK의 불용어를 저장하고 개수를 확인해 봅시다. # NLTK의 불용어 stop_words = set(stopwords.words('english')) print('불용어 개수 :', len(stop_words)) print(stop_words) 불용어 개수 : 179 {'this', "doesn't", 'until', 'as', ... 중략 ... ,'whom', 'here', 'ma', "it's", 'am', 'your'} 전처리 함수를 설계합니다. # 전처리 함수 def preprocess_sentence(sentence, remove_stopwords = True): sentence = sentence.lower() # 텍스트 소문자화 sentence = BeautifulSoup(sentence, "lxml").text # <br />, <a href = ...> 등의 html 태그 제거 sentence = re.sub(r'\([^)]*\)', '', sentence) # 괄호로 닫힌 문자열 제거 Ex) my husband (and myself) for => my husband for sentence = re.sub('"','', sentence) # 쌍따옴표 " 제거 sentence = ' '.join([contractions[t] if t in contractions else t for t in sentence.split(" ")]) # 약어 정규화 sentence = re.sub(r"'s\b","",sentence) # 소유격 제거. Ex) roland's -> roland sentence = re.sub("[^a-zA-Z]", " ", sentence) # 영어 외 문자(숫자, 특수문자 등) 공백으로 변환 sentence = re.sub('[m]{2, }', 'mm', sentence) # m이 3개 이상이면 2개로 변경. Ex) ummmmmmm yeah -> umm yeah # 불용어 제거 (Text) if remove_stopwords: tokens = ' '.join(word for word in sentence.split() if not word in stop_words if len(word) > 1) # 불용어 미 제거 (Summary) else: tokens = ' '.join(word for word in sentence.split() if len(word) > 1) return tokens 함수 내부의 각 줄에 주석을 달았으므로 자세한 설명은 생략하겠습니다. 여기서는 Text 열에서는 불용어를 제거하고, Summary 열에서는 불용어를 제거하지 않기로 결정했습니다. Summary를 입력으로 할 때는 두 번째 인자를 0으로 줘서 불용어를 제거하지 않는 버전을 실행하겠습니다. 임의의 Text 문장과 Summary 문장을 만들어 전처리 함수를 통한 전처리 후의 결과를 확인해 보겠습니다. temp_text = 'Everything I bought was great, infact I ordered twice and the third ordered was<br />for my mother and father.' temp_summary = 'Great way to start (or finish) the day!!!' print(preprocess_sentence(temp_text)) print(preprocess_sentence(temp_summary, 0)) everything bought great infact ordered twice third ordered wasfor mother father great way to start the day 우선 Text 열에 대해서 전처리를 수행하겠습니다. 전처리 후에는 5개의 전처리 된 샘플을 출력합니다. # Text 열 전처리 clean_text = [] for s in data['Text']: clean_text.append(preprocess_sentence(s)) clean_text[:5] ['bought several vitality canned dog food products found good quality product looks like stew processed meat smells better labrador finicky appreciates product better', 'product arrived labeled jumbo salted peanuts peanuts actually small sized unsalted sure error vendor intended represent product jumbo', 'confection around centuries light pillowy citrus gelatin nuts case filberts cut tiny squares liberally coated powdered sugar tiny mouthful heaven chewy flavorful highly recommend yummy treat familiar story lewis lion witch wardrobe treat seduces edmund selling brother sisters witch', 'looking secret ingredient robitussin believe found got addition root beer extract ordered made cherry soda flavor medicinal', 'great taffy great price wide assortment yummy taffy delivery quick taffy lover deal'] 이제 Summary 열에 대해서 전처리를 수행하겠습니다. 전처리 후에는 5개의 전처리 된 샘플을 출력합니다. # Summary 열 전처리 clean_summary = [] for s in data['Summary']: clean_summary.append(preprocess_sentence(s, 0)) clean_summary[:5] ['good quality dog food', 'not as advertised', 'delight says it all', 'cough medicine', 'great taffy'] 전처리 후의 결과를 다시 데이터 프레임에 저장합니다. data['Text'] = clean_text data['Summary'] = clean_summary 혹시 전처리 과정에서 빈 값이 생겼다면 Null 값으로 변경한 후에 Null 값을 가진 샘플이 생겼는지 확인합니다. # 길이가 공백인 샘플은 NULL 값으로 변환 data.replace('', np.nan, inplace=True) print(data.isnull().sum()) Text 0 Summary 70 dtype: int64 Summary 열에서 70개의 샘플이 Null 값을 가집니다. 이 샘플들을 제거해 주고, 전체 샘플 수를 확인합니다. data.dropna(axis = 0, inplace = True) print('전체 샘플 수 :',(len(data))) 전체 샘플 수 : 88355 이제 Text 열과 Summary 열에 대해서 길이 분포를 확인해 보겠습니다. # 길이 분포 출력 text_len = [len(s.split()) for s in data['Text']] summary_len = [len(s.split()) for s in data['Summary']] print('텍스트의 최소 길이 : {}'.format(np.min(text_len))) print('텍스트의 최대 길이 : {}'.format(np.max(text_len))) print('텍스트의 평균 길이 : {}'.format(np.mean(text_len))) print('요약의 최소 길이 : {}'.format(np.min(summary_len))) print('요약의 최대 길이 : {}'.format(np.max(summary_len))) print('요약의 평균 길이 : {}'.format(np.mean(summary_len))) plt.subplot(1,2,1) plt.boxplot(summary_len) plt.title('Summary') plt.subplot(1,2,2) plt.boxplot(text_len) plt.title('Text') plt.tight_layout() plt.show() plt.title('Summary') plt.hist(summary_len, bins=40) plt.xlabel('length of samples') plt.ylabel('number of samples') plt.show() plt.title('Text') plt.hist(text_len, bins=40) plt.xlabel('length of samples') plt.ylabel('number of samples') plt.show() 텍스트의 최소 길이 : 2 텍스트의 최대 길이 : 1235 텍스트의 평균 길이 : 38.792428272310566 요약의 최소 길이 : 1 요약의 최대 길이 : 28 요약의 평균 길이 : 4.010729443721352 원문 텍스트는 대체적으로 100이하의 길이를 가집니다. 또한, 평균 길이는 38입니다. 요약의 경우에는 대체적으로 15이하의 길이를 가지며 평균 길이는 4입니다. 여기서 패딩의 길이를 정하겠습니다. 평균 길이보다는 크게 잡아 각각 50과 8로 결정합니다. text_max_len = 50 summary_max_len = 8 50과 8이라는 이 두 길이가 얼마나 많은 샘플들의 길이보다 큰지 확인해 보겠습니다. def below_threshold_len(max_len, nested_list): cnt = 0 for s in nested_list: if(len(s.split()) <= max_len): cnt = cnt + 1 print('전체 샘플 중 길이가 %s 이하인 샘플의 비율: %s'%(max_len, (cnt / len(nested_list)))) 우선 Text 열에 대해서 확인해 봅시다. below_threshold_len(text_max_len, data['Text']) 전체 샘플 중 길이가 50 이하인 샘플의 비율: 0.7745119121724859 Text 열은 길이가 50 이하인 비율이 77%입니다. 약 23%의 샘플이 길이 50보다 큽니다. Summary 열에 대해서 확인해 봅시다. below_threshold_len(summary_max_len, data['Summary']) 전체 샘플 중 길이가 8 이하인 샘플의 비율: 0.9424593967517402 Summary 열은 길이가 8 이하인 경우가 94%입니다. 여기서는 정해준 최대 길이보다 큰 샘플들은 제거하겠습니다. data = data[data['Text'].apply(lambda x: len(x.split()) <= text_max_len)] data = data[data['Summary'].apply(lambda x: len(x.split()) <= summary_max_len)] print('전체 샘플 수 :',(len(data))) 전체 샘플 수 : 65818 이제 샘플 수가 65,818개로 줄었습니다. 정제 작업이 완료된 상위 샘플 5개를 출력해 봅시다. data.head() seq2seq 훈련을 위해서는 디코더의 입력과 레이블에 시작 토큰과 종료 토큰을 추가할 필요가 있습니다. 시작 토큰은 'sostoken', 종료 토큰은 'eostoken'이라 명명하고 앞, 뒤로 추가하겠습니다. # 요약 데이터에는 시작 토큰과 종료 토큰을 추가한다. data['decoder_input'] = data['Summary'].apply(lambda x : 'sostoken '+ x) data['decoder_target'] = data['Summary'].apply(lambda x : x + ' eostoken') data.head() 인코더의 입력, 디코더의 입력과 레이블을 각각 저장해 줍니다. encoder_input = np.array(data['Text']) decoder_input = np.array(data['decoder_input']) decoder_target = np.array(data['decoder_target']) 3) 데이터의 분리 훈련 데이터와 테스트 데이터를 분리해 봅시다. 우선, 순서가 섞인 정수 시퀀스를 만들어줍니다. indices = np.arange(encoder_input.shape[0]) np.random.shuffle(indices) print(indices) [29546 43316 24839 ... 45891 42613 43567] 이 정수 시퀀스 순서를 데이터의 샘플 순서로 정의해 주면 샘플의 순서는 섞이게 됩니다. encoder_input = encoder_input[indices] decoder_input = decoder_input[indices] decoder_target = decoder_target[indices] 이제 섞인 데이터를 8:2의 비율로 훈련 데이터와 테스트 데이터로 분리해 주겠습니다. n_of_val = int(len(encoder_input)*0.2) print('테스트 데이터의 수 :',n_of_val) 테스트 데이터의 수 : 13163 테스트 데이터는 전체 데이터에서 20%에 해당하는 13,163개를 사용하겠습니다. encoder_input_train = encoder_input[:-n_of_val] decoder_input_train = decoder_input[:-n_of_val] decoder_target_train = decoder_target[:-n_of_val] encoder_input_test = encoder_input[-n_of_val:] decoder_input_test = decoder_input[-n_of_val:] decoder_target_test = decoder_target[-n_of_val:] print('훈련 데이터의 개수 :', len(encoder_input_train)) print('훈련 레이블의 개수 :',len(decoder_input_train)) print('테스트 데이터의 개수 :',len(encoder_input_test)) print('테스트 레이블의 개수 :',len(decoder_input_test)) 훈련 데이터의 개수 : 52655 훈련 레이블의 개수 : 52655 테스트 데이터의 개수 : 13163 테스트 레이블의 개수 : 13163 4) 정수 인코딩 이제 기계가 텍스트를 숫자로 처리할 수 있도록 훈련 데이터와 테스트 데이터에 정수 인코딩을 수행해야 합니다. 훈련 데이터에 대해서 단어 집합(vocaburary)을 만들어봅시다. 우선, 원문에 해당되는 encoder_input_train에 대해서 수행합니다. src_tokenizer = Tokenizer() src_tokenizer.fit_on_texts(encoder_input_train) 이제 단어 집합이 생성되는 동시에 각 단어에 고유한 정수가 부여되었습니다. 이는 src_tokenizer.word_index에 저장돼 있습니다. 여기서는 빈도수가 낮은 단어들은 자연어 처리에서 배제하고자 합니다. 등장 빈도수가 7회 미만인 단어들이 이 데이터에서 얼마큼의 비중을 차지하는지 확인해 봅시다. threshold = 7 total_cnt = len(src_tokenizer.word_index) # 단어의 수 rare_cnt = 0 # 등장 빈도수가 threshold보다 작은 단어의 개수를 카운트 total_freq = 0 # 훈련 데이터의 전체 단어 빈도수 총합 rare_freq = 0 # 등장 빈도수가 threshold보다 작은 단어의 등장 빈도수의 총합 # 단어와 빈도수의 쌍(pair)을 key와 value로 받는다. for key, value in src_tokenizer.word_counts.items(): total_freq = total_freq + value # 단어의 등장 빈도수가 threshold보다 작으면 if(value < threshold): rare_cnt = rare_cnt + 1 rare_freq = rare_freq + value print('단어 집합(vocabulary)의 크기 :',total_cnt) print('등장 빈도가 %s 번 이하인 희귀 단어의 수: %s'%(threshold - 1, rare_cnt)) print('단어 집합에서 희귀 단어를 제외할 경우의 단어 집합의 크기 %s'%(total_cnt - rare_cnt)) print("단어 집합에서 희귀 단어의 비율:", (rare_cnt / total_cnt)*100) print("전체 등장 빈도에서 희귀 단어 등장 빈도 비율:", (rare_freq / total_freq)*100) 단어 집합(vocabulary)의 크기 : 32031 등장 빈도가 6번 이하인 희귀 단어의 수: 23779 단어 집합에서 희귀 단어를 제외할 경우의 단어 집합의 크기 8252 단어 집합에서 희귀 단어의 비율: 74.23745746308263 전체 등장 빈도에서 희귀 단어 등장 빈도 비율: 3.393443023084609 등장 빈도가 threshold 값인 7회 미만. 즉, 6회 이하인 단어들은 단어 집합에서 무려 70% 이상을 차지합니다. 하지만, 실제로 훈련 데이터에서 등장 빈도로 차지하는 비중은 상대적으로 적은 수치인 3.39%밖에 되지 않습니다. 여기서는 등장 빈도가 6회 이하인 단어들은 정수 인코딩 과정에서 배제시키고자 합니다. 위에서 이를 제외한 단어 집합의 크기를 8,233으로 계산했는데, 저자는 깔끔한 값을 선호하여 이와 비슷한 값으로 단어 집합의 크기를 8000으로 제한하겠습니다. src_vocab = 8000 src_tokenizer = Tokenizer(num_words = src_vocab) src_tokenizer.fit_on_texts(encoder_input_train) # 텍스트 시퀀스를 정수 시퀀스로 변환 encoder_input_train = src_tokenizer.texts_to_sequences(encoder_input_train) encoder_input_test = src_tokenizer.texts_to_sequences(encoder_input_test) 정수 인코딩이 정상 진행되었는지 훈련 데이터에 대해서 3개의 샘플을 출력해 봅시다. print(encoder_input_train[:3]) [[1882, 805, 844, 1855, 1120, 72, 131, 203, 1120, 83, 3896, 1, 1013, 844, 757, 167, 601, 350, 519, 435, 2482, 626, 72, 302, 1120, 132, 4281, 1007, 102, 449, 3450, 1, 75, 90, 343, 2307, 1188, 114, 1639, 166, 431, 1333, 1847, 70], [53, 4, 15, 901, 355, 37, 784, 97, 9, 8, 217, 441, 129, 101], [40, 1261, 473, 3, 909, 39, 3249, 2978, 221, 24, 37, 287, 2719, 6125, 56, 1371, 83, 390, 378]] 이제 레이블에 해당하는 요약 데이터에 대해서도 수행하겠습니다. tar_tokenizer = Tokenizer() tar_tokenizer.fit_on_texts(decoder_input_train) 이제 단어 집합이 생성되는 동시에 각 단어에 고유한 정수가 부여되었습니다. 이는 tar_tokenizer.word_index에 저장돼 있습니다. 등장 빈도수가 6회 미만인 단어들이 이 데이터에서 얼마큼의 비중을 차지하는지 확인해 봅시다. threshold = 6 total_cnt = len(tar_tokenizer.word_index) # 단어의 수 rare_cnt = 0 # 등장 빈도수가 threshold보다 작은 단어의 개수를 카운트 total_freq = 0 # 훈련 데이터의 전체 단어 빈도수 총합 rare_freq = 0 # 등장 빈도수가 threshold보다 작은 단어의 등장 빈도수의 총합 # 단어와 빈도수의 쌍(pair)을 key와 value로 받는다. for key, value in tar_tokenizer.word_counts.items(): total_freq = total_freq + value # 단어의 등장 빈도수가 threshold보다 작으면 if(value < threshold): rare_cnt = rare_cnt + 1 rare_freq = rare_freq + value print('단어 집합(vocabulary)의 크기 :',total_cnt) print('등장 빈도가 %s 번 이하인 희귀 단어의 수: %s'%(threshold - 1, rare_cnt)) print('단어 집합에서 희귀 단어를 제외할 경우의 단어 집합의 크기 %s'%(total_cnt - rare_cnt)) print("단어 집합에서 희귀 단어의 비율:", (rare_cnt / total_cnt)*100) print("전체 등장 빈도에서 희귀 단어 등장 빈도 비율:", (rare_freq / total_freq)*100) 단어 집합(vocabulary)의 크기 : 10510 등장 빈도가 5번 이하인 희귀 단어의 수: 8128 단어 집합에서 희귀 단어를 제외할 경우의 단어 집합의 크기 2382 단어 집합에서 희귀 단어의 비율: 77.33587059942911 전체 등장 빈도에서 희귀 단어 등장 빈도 비율: 5.896286343062141 등장 빈도가 5회 이하인 단어들은 단어 집합에서 약 77%를 차지합니다. 하지만, 실제로 훈련 데이터에서 등장 빈도로 차지하는 비중은 상대적으로 매우 적은 수치인 5.89%밖에 되지 않습니다. 이 단어들은 정수 인코딩 과정에서 배제시키겠습니다. tar_vocab = 2000 tar_tokenizer = Tokenizer(num_words = tar_vocab) tar_tokenizer.fit_on_texts(decoder_input_train) tar_tokenizer.fit_on_texts(decoder_target_train) # 텍스트 시퀀스를 정수 시퀀스로 변환 decoder_input_train = tar_tokenizer.texts_to_sequences(decoder_input_train) decoder_target_train = tar_tokenizer.texts_to_sequences(decoder_target_train) decoder_input_test = tar_tokenizer.texts_to_sequences(decoder_input_test) decoder_target_test = tar_tokenizer.texts_to_sequences(decoder_target_test) 정수 인코딩이 정상 진행되었는지 훈련 데이터에 대해서 5개의 샘플을 출력해 봅시다. print(decoder_input_train[:5]) [[1, 687], [1, 53, 21, 182, 1162, 240], [1, 6, 480, 113, 278, 181], [1, 15, 108, 215], [1, 54, 178, 21]] print(decoder_target_train[:5]) [[687, 2], [53, 21, 182, 1162, 240, 2], [6, 480, 113, 278, 181, 2], [15, 108, 215, 2], [54, 178, 21, 2]] 5) 빈 샘플(empty samples) 제거 전체 데이터에서 빈도수가 낮은 단어가 삭제되었다는 것은 빈도수가 낮은 단어만으로 구성되었던 샘플들은 이제 빈(empty) 샘플이 되었다는 것을 의미합니다. 이 현상은 길이가 상대적으로 길었던 원문(Text)의 경우에는 문제가 별로 없겠지만, 애초에 평균 길이가 4밖에 되지 않았던 요약문(Summary)의 경우에는 이 현상이 굉장히 두드러졌을 가능성이 높습니다. 요약문에서 길이가 0이 된 샘플들의 인덱스를 받아옵시다. 주의할 점은 요약문인 decoder_input에는 sostoken 또는 decoder_target에는 eostoken이 추가된 상태이고, 이 두 토큰은 모든 샘플에서 등장하므로 빈도수가 샘플 수와 동일하여 단어 집합 제한에도 삭제되지 않습니다. 그래서 이제 길이가 0이 된 요약문의 실질적 길이는 1입니다. decoder_input에는 sostoken, decoder_target에는 eostoken만 남았을 것이기 때문입니다. drop_train = [index for index, sentence in enumerate(decoder_input_train) if len(sentence) == 1] drop_test = [index for index, sentence in enumerate(decoder_input_test) if len(sentence) == 1] 훈련 데이터와 테스트 데이터에 대해서 요약문의 길이가 1인 경우의 인덱스를 각각 drop_train과 drop_test에 저장하였습니다. 이 샘플들을 모두 삭제하고자 합니다. 삭제할 개수는 각각 몇 개일까요? print('삭제할 훈련 데이터의 개수 :',len(drop_train)) print('삭제할 테스트 데이터의 개수 :',len(drop_test)) 삭제할 훈련 데이터의 개수 : 1235 삭제할 테스트 데이터의 개수 : 337 삭제 후의 개수는 다음과 같습니다. encoder_input_train = np.delete(encoder_input_train, drop_train, axis=0) decoder_input_train = np.delete(decoder_input_train, drop_train, axis=0) decoder_target_train = np.delete(decoder_target_train, drop_train, axis=0) encoder_input_test = np.delete(encoder_input_test, drop_test, axis=0) decoder_input_test = np.delete(decoder_input_test, drop_test, axis=0) decoder_target_test = np.delete(decoder_target_test, drop_test, axis=0) print('훈련 데이터의 개수 :', len(encoder_input_train)) print('훈련 레이블의 개수 :',len(decoder_input_train)) print('테스트 데이터의 개수 :',len(encoder_input_test)) print('테스트 레이블의 개수 :',len(decoder_input_test)) 훈련 데이터의 개수 : 51420 훈련 레이블의 개수 : 51420 테스트 데이터의 개수 : 12826 테스트 레이블의 개수 : 12826 6) 패딩 하기 앞서 계산해둔 최대 길이로 맞추어 훈련 데이터와 테스트 데이터에 대해서 패딩 작업을 수행합니다. encoder_input_train = pad_sequences(encoder_input_train, maxlen = text_max_len, padding='post') encoder_input_test = pad_sequences(encoder_input_test, maxlen = text_max_len, padding='post') decoder_input_train = pad_sequences(decoder_input_train, maxlen = summary_max_len, padding='post') decoder_target_train = pad_sequences(decoder_target_train, maxlen = summary_max_len, padding='post') decoder_input_test = pad_sequences(decoder_input_test, maxlen = summary_max_len, padding='post') decoder_target_test = pad_sequences(decoder_target_test, maxlen = summary_max_len, padding='post') 3. seq2seq + attention으로 요약 모델 설계 및 훈련시키기 우선 필요한 도구들을 임포트 합니다. from tensorflow.keras.layers import Input, LSTM, Embedding, Dense, Concatenate from tensorflow.keras.models import Model from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint 인코더를 설계해 보겠습니다. 인코더는 LSTM 층을 3개 쌓습니다. embedding_dim = 128 hidden_size = 256 # 인코더 encoder_inputs = Input(shape=(text_max_len,)) # 인코더의 임베딩 층 enc_emb = Embedding(src_vocab, embedding_dim)(encoder_inputs) # 인코더의 LSTM 1 encoder_lstm1 = LSTM(hidden_size, return_sequences=True, return_state=True , dropout = 0.4, recurrent_dropout = 0.4) encoder_output1, state_h1, state_c1 = encoder_lstm1(enc_emb) # 인코더의 LSTM 2 encoder_lstm2 = LSTM(hidden_size, return_sequences=True, return_state=True, dropout=0.4, recurrent_dropout=0.4) encoder_output2, state_h2, state_c2 = encoder_lstm2(encoder_output1) # 인코더의 LSTM 3 encoder_lstm3 = LSTM(hidden_size, return_state=True, return_sequences=True, dropout=0.4, recurrent_dropout=0.4) encoder_outputs, state_h, state_c= encoder_lstm3(encoder_output2) 디코더를 설계해 보겠습니다. 단, 출력층은 제외하고 설계하겠습니다. 디코더의 설계는 인코더와 사실상 동일하지만 초기 상태(initial_state)를 인코더의 상태로 주어야 하는 것에 주의합시다. # 디코더 decoder_inputs = Input(shape=(None,)) # 디코더의 임베딩 층 dec_emb_layer = Embedding(tar_vocab, embedding_dim) dec_emb = dec_emb_layer(decoder_inputs) # 디코더의 LSTM decoder_lstm = LSTM(hidden_size, return_sequences = True, return_state = True, dropout = 0.4, recurrent_dropout=0.2) decoder_outputs, _, _ = decoder_lstm(dec_emb, initial_state = [state_h, state_c]) 이제 디코더의 출력층을 설계합니다. # 디코더의 출력층 decoder_softmax_layer = Dense(tar_vocab, activation = 'softmax') decoder_softmax_outputs = decoder_softmax_layer(decoder_outputs) # 모델 정의 model = Model([encoder_inputs, decoder_inputs], decoder_softmax_outputs) model.summary() model.summary() 결과는 지면의 한계로 여기에 올리지 않겠습니다. 총 3,633,104개의 매개변수를 가진 seq2seq 모델이 설계됩니다. 지금까지의 모델 설계는 앞서 seq2seq 챕터에서 배웠던 내용과 동일합니다. 그런데 이번 챕터에서는 어텐션 메커니즘을 사용할 예정이므로 위에서 설계한 출력층을 사용하지 않고, 어텐션 메커니즘이 결합된 새로운 출력층을 설계해 보겠습니다. 어텐션 함수를 직접 작성하지 않고 이미 저자의 깃허브에 작성된 어텐션을 사용할 것이므로 아래의 코드를 통해 attention.py 파일을 다운로드하고, AttentionLayer를 임포트 합니다. (바다나 우 어텐션입니다.) urllib.request.urlretrieve("https://raw.githubusercontent.com/ukairia777/tensorflow-nlp-tutorial/main/20.%20Text%20Summarization%20with%20Attention/attention.py", filename="attention.py") from attention import AttentionLayer 어텐션 메커니즘을 이용해 디코더의 출력층을 새롭게 설계합니다. # 어텐션 층(어텐션 함수) attn_layer = AttentionLayer(name='attention_layer') attn_out, attn_states = attn_layer([encoder_outputs, decoder_outputs]) # 어텐션의 결과와 디코더의 hidden state들을 연결 decoder_concat_input = Concatenate(axis = -1, name='concat_layer')([decoder_outputs, attn_out]) # 디코더의 출력층 decoder_softmax_layer = Dense(tar_vocab, activation='softmax') decoder_softmax_outputs = decoder_softmax_layer(decoder_concat_input) # 모델 정의 model = Model([encoder_inputs, decoder_inputs], decoder_softmax_outputs) model.summary() 총 4,276,432개의 파라미터를 가진 모델이 설계됩니다. 이제 모델을 컴파일합니다. model.compile(optimizer='rmsprop', loss='sparse_categorical_crossentropy') 조기 종료 조건을 설정하고 모델을 학습시킵니다. es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience = 2) history = model.fit(x = [encoder_input_train, decoder_input_train], y = decoder_target_train, \ validation_data = ([encoder_input_test, decoder_input_test], decoder_target_test), batch_size = 256, callbacks=[es], epochs = 50) Train on 51420 samples, validate on 12826 samples Epoch 1/50 51404/51404 [==============================] - 79s 2ms/sample - loss: 3.0293 - val_loss: 2.7390 ... 중략 ... Epoch 26/50 51404/51404 [==============================] - 67s 1ms/sample - loss: 1.7364 - val_loss: 2.0805 Epoch 00026: early stopping 학습 과정 하면서 기록된 훈련 데이터의 손실과 테스트 데이터의 손실 히스토리를 시각화하여 출력합니다 plt.plot(history.history['loss'], label='train') plt.plot(history.history['val_loss'], label='test') plt.legend() plt.show() 테스트 데이터의 손실이 지속적으로 줄어들다가 어느 순간부터 정체하게 됩니다. 4. seq2seq + attention으로 요약 모델 테스트하기 테스트를 위해 필요한 3개의 사전을 만듭니다. src_index_to_word = src_tokenizer.index_word # 원문 단어 집합에서 정수 -> 단어를 얻음 tar_word_to_index = tar_tokenizer.word_index # 요약 단어 집합에서 단어 -> 정수를 얻음 tar_index_to_word = tar_tokenizer.index_word # 요약 단어 집합에서 정수 -> 단어를 얻음 seq2seq는 훈련 단계와 테스트 단계의 동작이 다르므로 테스트 단계의 모델을 별도로 다시 설계해 줄 필요가 있습니다. 다시 새로운 seq2seq 모델을 만들겠습니다. 우선 인코더를 정의합니다. # 인코더 설계 encoder_model = Model(inputs=encoder_inputs, outputs=[encoder_outputs, state_h, state_c]) 이제 테스트 단계의 디코더를 설계합니다. # 이전 시점의 상태들을 저장하는 텐서 decoder_state_input_h = Input(shape=(hidden_size,)) decoder_state_input_c = Input(shape=(hidden_size,)) dec_emb2 = dec_emb_layer(decoder_inputs) # 문장의 다음 단어를 예측하기 위해서 초기 상태(initial_state)를 이전 시점의 상태로 사용. 이는 뒤의 함수 decode_sequence()에 구현 # 훈련 과정에서와 달리 LSTM의 리턴하는 은닉 상태와 셀 상태인 state_h와 state_c를 버리지 않음. decoder_outputs2, state_h2, state_c2 = decoder_lstm(dec_emb2, initial_state=[decoder_state_input_h, decoder_state_input_c]) # 어텐션 함수 decoder_hidden_state_input = Input(shape=(text_max_len, hidden_size)) attn_out_inf, attn_states_inf = attn_layer([decoder_hidden_state_input, decoder_outputs2]) decoder_inf_concat = Concatenate(axis=-1, name='concat')([decoder_outputs2, attn_out_inf]) # 디코더의 출력층 decoder_outputs2 = decoder_softmax_layer(decoder_inf_concat) # 최종 디코더 모델 decoder_model = Model( [decoder_inputs] + [decoder_hidden_state_input, decoder_state_input_h, decoder_state_input_c], [decoder_outputs2] + [state_h2, state_c2]) 테스트 단계를 위한 모델이 완성되었습니다. 테스트를 위해 사용되는 함수 decode_sequence를 설계합니다. def decode_sequence(input_seq): # 입력으로부터 인코더의 상태를 얻음 e_out, e_h, e_c = encoder_model.predict(input_seq) # <SOS>에 해당하는 토큰 생성 target_seq = np.zeros((1,1)) target_seq[0, 0] = tar_word_to_index['sostoken'] stop_condition = False decoded_sentence = '' while not stop_condition: # stop_condition이 True가 될 때까지 루프 반복 output_tokens, h, c = decoder_model.predict([target_seq] + [e_out, e_h, e_c]) sampled_token_index = np.argmax(output_tokens[0, -1, :]) sampled_token = tar_index_to_word[sampled_token_index] if(sampled_token!='eostoken'): decoded_sentence += ' '+sampled_token # <eos>에 도달하거나 최대 길이를 넘으면 중단. if (sampled_token == 'eostoken' or len(decoded_sentence.split()) >= (summary_max_len-1)): stop_condition = True # 길이가 1인 타깃 시퀀스를 업데이트 target_seq = np.zeros((1,1)) target_seq[0, 0] = sampled_token_index # 상태를 업데이트합니다. e_h, e_c = h, c return decoded_sentence 테스트 단계에서 원문과 실제 요약문, 예측 요약문을 비교하기 위해 정수 시퀀스를 텍스트 시퀀스로 만드는 함수를 설계합니다. # 원문의 정수 시퀀스를 텍스트 시퀀스로 변환 def seq2text(input_seq): sentence='' for i in input_seq: if(i!=0): sentence = sentence + src_index_to_word[i]+' ' return sentence # 요약문의 정수 시퀀스를 텍스트 시퀀스로 변환 def seq2summary(input_seq): sentence='' for i in input_seq: if((i!=0 and i!=tar_word_to_index['sostoken']) and i!=tar_word_to_index['eostoken']): sentence = sentence + tar_index_to_word[i] + ' ' return sentence 테스트 샘플 중 500번부터 1000번까지 테스트해 봅시다. for i in range(500, 1000): print("원문 : ",seq2text(encoder_input_test[i])) print("실제 요약문 :",seq2summary(decoder_input_test[i])) print("예측 요약문 :",decode_sequence(encoder_input_test[i].reshape(1, text_max_len))) print("\n") 출력되는 결과가 너무 많으므로 그중 몇 가지만 보겠습니다. 원문 : great product husband eat kind price could little lower even like jerky eater 실제 요약문 : best jerky there is 예측 요약문: great jerky 원문 : perfect stress free afternoon aroma tea makes house smell great drink grade honey bliss 실제 요약문 : relax cup of tea 예측 요약문: great tea 원문 : dog loves stuff ground sprinkled dry food gobbles additives fillers carbs also use treat best price amazon quick delivery 실제 요약문 : great 예측 요약문: great dog food 원문 : got bbq popchips amazon promotion price came taste good wish less salty would certainly purchase came less salty version 실제 요약문 : tasty but wish it was less salty 예측 요약문 : not the best 원문 : product arrived broken pieces flavor good actually threw garbage disappointing 실제 요약문 : very disappointed 예측 요약문: not as described 원문 : buying quaker oats granola bars nature valley chewy bars better tasting make great snack go chocolate peanuts raisins get better 실제 요약문 : my new granola bar 예측 요약문: great snack 원문 : yuck worst chocolate ever save money brand find another even taste taste like chocolate threw rest away 실제 요약문 : horrible chocolate 예측 요약문 : awful 원문 : kit great rd kit made easy follow instructions new making wines really good kit learn product quite tasty good tropical fruit wine purchased store get idea would making like better store bought one 실제 요약문 : the kit is great 예측 요약문 : great for cooking 원문 : son particularly picky eater occasionally gets fussy matter mood great meal option fall back always eat also pouch sturdy makes good travel meal option little expensive worth every penny 실제 요약문 : my son loves these 예측 요약문 : great for baby food 원문 : labeled green tea touch pomegranate raspberry essence might rated higher however name pomegranate raspberry therefore expected vary flavors overall taste mild except greater sweetness tea second ingredient chamomile distinctive presence find flavor unpleasant nothing would make reach one teas 실제 요약문 : the flavor was not what expected 예측 요약문 : not for me 원문 : delighted food looks nice smells really great smaller size kibble old dog teeth comes ziplock pouch importantly though old dog getting little suddenly gotten since starting chow also noticed terrible daily gone fair time switched wet food harmony foods may also factor extremely happy food continue buy 실제 요약문 : highly recommend this 예측 요약문 : my dog loves this 실제 요약문과 완전히 똑같지 않으면서 원문의 맥락을 잘 잡아서 예측된 요약문들이 존재하는 것을 확인할 수 있습니다. 사실 여러분이 기대하는 수준의 생성 요약을 하는 것은 쉽지 않습니다. 그럼에도 꽤 뛰어난 성능의 생성 요약을 하고 싶다면 이렇게 직접 seq2seq를 구현하여 처음부터 학습하는 것보다는 사전 학습된 트랜스포머의 디코더를 장착한 GPT-2나 BART, T5와 같은 모델을 사용하는 것이 좋습니다. 이 책에서는 BART와 T-5까지는 다루지 않지만, 향후 작성될 22챕터에서 GPT-2를 이용한 문장 생성에 대해서 다룰 예정입니다. GPT-2에 대한 설명은 아직 집필되지 않지만, GPT-2에 대한 실습 코드는 이미 저자의 깃허브에 업로드가 되어 있으니 참고하시기 바랍니다. 20-02 문장 임베딩 기반 텍스트 랭크(TextRank Based on Sentence Embedding) 앞서 추상적 요약(abstractive summarization)을 통한 텍스트 요약을 수행해 보았습니다. 이번 실습에서는 텍스트 랭크(TextRank) 알고리즘으로 사용하여 또 다른 텍스트 요약 방법인 추출적 요약을 진행해 보겠습니다. 1. 텍스트 랭크(TextRank) 텍스트 랭크 알고리즘에 대해서 이해하기 위해서, 텍스트 랭크 알고리즘의 기반이 된 페이지랭크 알고리즘에 대해서 간단히 이해해 보겠습니다. 페이지랭크 알고리즘은 검색 엔진에서 웹 페이지의 순위를 정하기 위해 사용되던 알고리즘입니다. 텍스트 랭크 알고리즘은 페이지랭크를 기반으로 한 텍스트 요약 알고리즘입니다. 텍스트 랭크에서 그래프의 노드들은 문장들이며, 각 간선의 가중치는 문장들 간의 유사도를 의미합니다. 텍스트 랭크에 대한 상세 설명은 하지 않겠습니다. 2. 사전 훈련된 임베딩(Pre-trained Embedding) 이번 실습에서는 사전 훈련된 임베딩을 사용합니다. 워드 임베딩 방법으로는 여러 가지가 있겠지만, 대표적으로 사용할 수 있는 임베딩 방법인 GloVe, FastText, Word2Vec의 사전 훈련된 임베딩 사용 방법은 다음과 같습니다. 각 임베딩을 다운로드하기 위해서는 어느 정도 시간이 소요되므로 실습을 위해서는 우선 GloVe만을 다운로드하는 것을 권합니다. import numpy as np import gensim from urllib.request import urlretrieve, urlopen import gzip import zipfile 1. 사전 훈련된 GloVe 다운로드 (실습에서 사용) urlretrieve("http://nlp.stanford.edu/data/glove.6B.zip", filename="glove.6B.zip") zf = zipfile.ZipFile('glove.6B.zip') zf.extractall() zf.close() glove_dict = dict() f = open('glove.6B.100d.txt', encoding="utf8") # 100차원의 GloVe 벡터를 사용 for line in f: word_vector = line.split() word = word_vector[0] word_vector_arr = np.asarray(word_vector[1:], dtype='float32') # 100개의 값을 가지는 array로 변환 glove_dict[word] = word_vector_arr f.close() 만약 단어 'cat'에 대한 임베딩 벡터를 얻고 싶다면 다음과 같이 얻을 수 있습니다. glove_dict['cat'] 2. 사전 훈련된 FastText 다운로드 !pip install fasttext # 300차원의 FastText 벡터 사용 import fasttext.util fasttext.util.download_model('en', if_exists='ignore') ft = fasttext.load_model('cc.en.300.bin') 만약 단어 'cat'에 대한 임베딩 벡터를 얻고 싶다면 다음과 같이 얻을 수 있습니다. ft.get_word_vector('cat') 3. 사전 훈련된 Word2Vec 다운로드 # 300차원의 Word2Vec 벡터 사용 urlretrieve("https://s3.amazonaws.com/dl4j-distribution/GoogleNews-vectors-negative300.bin.gz", \ filename="GoogleNews-vectors-negative300.bin.gz") word2vec_model = gensim.models.KeyedVectors.load_word2vec_format('GoogleNews-vectors-negative300.bin.gz', binary=True) 만약 단어 'cat'에 대한 임베딩 벡터를 얻고 싶다면 다음과 같이 얻을 수 있습니다. word2vec_model['cat'] 3. 문장 임베딩(Sentence Embedding) 여러분이 어떤 다수의 문장을 가지고 있다고 해봅시다. 그리고 이 문장들을 서로 비교하고 싶습니다. 만약, 문장들을 각 문장을 표현하는 고정된 길이의 벡터로 변환한다면 벡터 간 비교로 문장을 비교할 수 있을 것입니다. 각 문장을 문장 벡터로 변환하는 방법은 여러 가지 방법이 존재하지만, 여기서는 가장 간단한 방법 한 가지를 소개하고자 합니다. 문장 벡터를 얻는 가장 간단한 방법은 문장에 존재하는 단어 벡터들의 평균을 구하는 것입니다. 이번 챕터에서는 앞에서 소개한 방법으로 다운로드한 사전 훈련된 임베딩을 사용합니다. 예를 들어 사전 훈련된 GloVe로부터 문장 벡터는 다음과 같이 얻을 수 있습니다. 현재 glove_dict에는 100차원의 GloVe 벡터들이 저장돼 있습니다. OOV 문제. 즉, glove_dict에 존재하지 않는 단어가 문장에 존재할 경우 해당 단어의 임베딩값으로 사용할 100차원의 영벡터도 만들어둡니다. embedding_dim = 100 zero_vector = np.zeros(embedding_dim) 아래 함수는 문장의 각 단어를 사전 훈련된 GloVe 벡터로 변환하면서, OOV 문제가 발생할 경우에는 해당 단어를 영벡터로 변환합니다. 그리고 이렇게 모인 단어 벡터들의 평균을 구하여 반환합니다. # 단어 벡터의 평균으로부터 문장 벡터를 얻는다. def calculate_sentence_vector(sentence): return sum([glove_dict.get(word, zero_vector) for word in sentence])/len(sentence) 만약 I am a student라는 문장 벡터의 값을 얻고 싶다면 해당 문장을 calculate_sentence_vector 함수의 입력으로 사용하면 됩니다. 이렇게 반환된 벡터 값의 크기는 100차원이 될 것입니다. 여기서는 책의 지면의 한계로 값을 확인하진 않겠습니다. eng_sent = ['I', 'am', 'a', 'student'] sentence_vector = calculate_sentence_vector(eng_sent) print(len(sentence_vector)) 100 현재 사용하고 있는 사전 훈련된 GloVe는 영어에 대해서 학습된 임베딩입니다. 그래서 한국어를 넣으면 당연히 모든 단어에 대해서 OOV 문제가 발생합니다. 즉, 모든 단어가 영벡터이므로 평균을 구해도 영벡터가 반환됩니다. 실제로 값을 확인해 봅시다. kor_sent = ['전', '좋은', '학생', '입니다'] sentence_vector = calculate_sentence_vector(kor_sent) print(sentence_vector) [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] 4. 텍스트 랭크를 이용한 텍스트 요약 여기서는 앞서 사전 훈련된 GloVe를 다운로드하였다는 가정 하에 진행합니다. import numpy as np import re import pandas as pd import matplotlib.pyplot as plt from nltk.tokenize import sent_tokenize, word_tokenize from nltk.corpus import stopwords from urllib.request import urlretrieve import zipfile from sklearn.metrics.pairwise import cosine_similarity import networkx as nx NLTK에서 제공하는 불용어를 받아옵니다. stop_words = stopwords.words('english') 텍스트 요약에 사용할 테니스 관련 기사를 다운로드하고, 데이터 프레임에 저장합니다. urlretrieve("https://raw.githubusercontent.com/prateekjoshi565/textrank_text_summarization/master/tennis_articles_v4.csv", filename="tennis_articles_v4.csv") data = pd.read_csv("tennis_articles_v4.csv") data.head() 총 3개의 열이 존재하지만 여기서 사용할 열은 기사 본문에 해당하는 article_text입니다. 해당 article_text 열만 사용하기로 하고, 해당 기사를 문장 토큰화한 결과를 저장한 sentences라는 열을 새로 만듭니다. data = data[['article_text']] data['sentences'] = data['article_text'].apply(sent_tokenize) data 토큰화와 전처리를 위한 함수들을 정의합니다. # 토큰화 함수 def tokenization(sentences): return [word_tokenize(sentence) for sentence in sentences] # 전처리 함수 def preprocess_sentence(sentence): # 영어를 제외한 숫자, 특수 문자 등은 전부 제거. 모든 알파벳은 소문자화 sentence = [re.sub(r'[^a-zA-z\s]', '', word).lower() for word in sentence] # 불용어가 아니면서 단어가 실제로 존재해야 한다. return [word for word in sentence if word not in stop_words and word] # 위 전처리 함수를 모든 문장에 대해서 수행. 이 함수를 호출하면 모든 행에 대해서 수행. def preprocess_sentences(sentences): return [preprocess_sentence(sentence) for sentence in sentences] 문장 토큰화를 진행한 'sentences'열에 대해서 단어 토큰화와 전처리를 적용한 'tokenized_sentences' 열을 새로 만듭니다. data['tokenized_sentences'] = data['sentences'].apply(tokenization) data['tokenized_sentences'] = data['tokenized_sentences'].apply(preprocess_sentences) data 현재 사용할 GloVe 벡터의 차원은 100입니다. 100차원의 영벡터를 만듭니다. embedding_dim = 100 zero_vector = np.zeros(embedding_dim) 단어 벡터의 평균을 구하는 함수를 정의합니다. 단, 문장 길이가 0일 경우에는 100차원의 영벡터를 리턴합니다. 현재 불용어를 제거하였기 때문에 문장의 모든 단어가 불용어인 경우에는 길이가 0인 문장이 생길 수 있기 때문입니다. # 단어 벡터의 평균으로부터 문장 벡터를 얻는다. def calculate_sentence_vector(sentence): if len(sentence) != 0: return sum([glove_dict.get(word, zero_vector) for word in sentence])/len(sentence) else: return zero_vector 이를 모든 행에 대해서 수행하기 위해서 모든 문장에 대해서 수행하는 함수를 정의합니다. # 각 문장에 대해서 문장 벡터를 반환 def sentences_to_vectors(sentences): return [calculate_sentence_vector(sentence) for sentence in sentences] 모든 문장에 대해서 문장 벡터를 만듭니다. data['SentenceEmbedding'] = data['tokenized_sentences'].apply(sentences_to_vectors) data[['SentenceEmbedding']] 문장 벡터들 간의 코사인 유사도를 구한 유사도 행렬을 만듭니다. 이 유사도 행렬의 크기는 (문장 개수 × 문장 개수)입니다. def similarity_matrix(sentence_embedding): sim_mat = np.zeros([len(sentence_embedding), len(sentence_embedding)]) for i in range(len(sentence_embedding)): for j in range(len(sentence_embedding)): sim_mat[i][j] = cosine_similarity(sentence_embedding[i].reshape(1, embedding_dim), sentence_embedding[j].reshape(1, embedding_dim))[0,0] return sim_mat 이 결과를 저장한 'SimMatrix'열을 만듭니다. data['SimMatrix'] = data['SentenceEmbedding'].apply(similarity_matrix) data['SimMatrix'] 두 번째 샘플을 기준으로 지금까지 만든 열들의 크기를 확인해 봅시다. print('두 번째 샘플의 문장 개수 :',len(data['tokenized_sentences'][1])) print('두 번째 샘플의 문장 벡터가 모인 문장 행렬의 크기(shape) :',np.shape(data['SentenceEmbedding'][1])) print('두 번째 샘플의 유사도 행렬의 크기(shape) :',data['SimMatrix'][1].shape) 두 번째 샘플의 문장 개수 : 12 두 번째 샘플의 문장 벡터가 모인 문장 행렬의 크기(shape) : (12, 100) 두 번째 샘플의 유사도 행렬의 크기(shape) : (12, 12) 두 번째 샘플의 경우에는 총 문장이 12개가 존재합니다. 그래서 문장 벡터 또한 12개가 존재하며, 각 문장 벡터는 100의 크기를 가집니다. 유사도 행렬은 각 문장 벡터들의 유사도가 기록된 유사도 행렬이므로 (문장 개수 × 문장 개수)의 크기를 가집니다. 주어진 유사도 행렬로부터 그래프를 그려봅시다. def draw_graphs(sim_matrix): nx_graph = nx.from_numpy_array(sim_matrix) plt.figure(figsize=(10, 10)) pos = nx.spring_layout(nx_graph) nx.draw(nx_graph, with_labels=True, font_weight='bold') nx.draw_networkx_edge_labels(nx_graph, pos, font_color='red') plt.show() 두 번째 샘플의 유사도 행렬로부터 그린 그래프는 다음과 같습니다. draw_graphs(data['SimMatrix'][1]) 문장 개수가 12개였으므로 총 12개의 노드가 존재합니다. 이러한 그래프를 페이지랭크 알고리즘의 입력으로 사용하여 각 문장의 점수를 구합니다. 이렇게 'score'라는 열을 만듭니다. def calculate_score(sim_matrix): nx_graph = nx.from_numpy_array(sim_matrix) scores = nx.pagerank(nx_graph) return scores data['score'] = data['SimMatrix'].apply(calculate_score) data[['SimMatrix', 'score']] 두 번째 샘플의 각 문장의 점수를 출력해 봅시다. 총 12개 문장에 대해서 점수가 기록돼 있습니다. data['score'][1] {0: 0.08315094474060455, 1: 0.08498611405296501, 2: 0.08555019786198463, 3: 0.08383717299575927, 4: 0.0813794030791188, 5: 0.08439285067975581, 6: 0.08507725735628792, 7: 0.08092839280412682, 8: 0.07454046000848007, 9: 0.08535836572027003, 10: 0.0849824249168908, 11: 0.08581641578375629} 이제 이 점수가 가장 높은 문장들을 상위 n 개 선택하여 이 문서의 요약문으로 삼을 것입니다. 점수가 가장 높은 상위 3개의 문장을 선택하는 함수를 만듭니다. 점수에 따라서 정렬 후에 상위 3개 문장만을 반환합니다. def ranked_sentences(sentences, scores, n=3): top_scores = sorted(((scores[i],s) for i, s in enumerate(sentences)), reverse=True) top_n_sentences = [sentence for score, sentence in top_scores[:n]] return " ".join(top_n_sentences) 이 함수를 사용하여 'summary'라는 열을 만듭니다. data['summary'] = data.apply(lambda x: ranked_sentences(x.sentences, x.score), axis=1) 모든 문서에 대해서 원문과 요약문을 출력해 볼까요? for i in range(0, len(data)): print(i+1, '번 문서') print('원문 :',data.loc[i].article_text) print('') print('요약 :',data.loc[i].summary) print('') 1 번 문서 원문 : Maria Sharapova has basically no friends as tennis players on the WTA Tour. The Russian player has no problems in openly speaking about it and in a recent interview she said: 'I don't really hide any feelings too much. I think everyone knows this is my job here. When I'm on the courts or when I'm on the court playing, I'm a competitor and I want to beat every single person whether they're in the locker room or across the net.So I'm not the one to strike up a conversation about the weather and know that in the next few minutes I have to go and try to win a tennis match. I'm a pretty competitive girl. I say my hellos, but I'm not sending any players flowers as well. Uhm, I'm not really friendly or close to many players. I have not a lot of friends away from the courts.' When she said she is not really close to a lot of players, is that something strategic that she is doing? Is it different on the men's tour than the women's tour? 'No, not at all. I think just because you're in the same sport doesn't mean that you have to be friends with everyone just because you're categorized, you're a tennis player, so you're going to get along with tennis players. I think every person has different interests. I have friends that have completely different jobs and interests, and I've met them in very different parts of my life. I think everyone just thinks because we're tennis players we should be the greatest of friends. But ultimately tennis is just a very small part of what we do. There are so many other things that we're interested in, that we do.' 요약 : I think just because you're in the same sport doesn't mean that you have to be friends with everyone just because you're categorized, you're a tennis player, so you're going to get along with tennis players. When I'm on the courts or when I'm on the court playing, I'm a competitor and I want to beat every single person whether they're in the locker room or across the net.So I'm not the one to strike up a conversation about the weather and know that in the next few minutes I have to go and try to win a tennis match. I think everyone just thinks because we're tennis players we should be the greatest of friends. 2 번 문서 원문 : BASEL, Switzerland (AP), Roger Federer advanced to the 14th Swiss Indoors final of his career by beating seventh-seeded Daniil Medvedev 6-1, 6-4 on Saturday. Seeking a ninth title at his hometown event, and a 99th overall, Federer will play 93th-ranked Marius Copil on Sunday. Federer dominated the 20th-ranked Medvedev and had his first match-point chance to break serve again at 5-1. He then dropped his serve to love, and let another match point slip in Medvedev's next service game by netting a backhand. He clinched on his fourth chance when Medvedev netted from the baseline. Copil upset expectations of a Federer final against Alexander Zverev in a 6-3, 6-7 (6), 6-4 win over the fifth-ranked German in the earlier semifinal. The Romanian aims for a first title after arriving at Basel without a career win over a top-10 opponent. Copil has two after also beating No. 6 Marin Cilic in the second round. Copil fired 26 aces past Zverev and never dropped serve, clinching after 2 1/2 hours with a forehand volley winner to break Zverev for the second time in the semifinal. He came through two rounds of qualifying last weekend to reach the Basel main draw, including beating Zverev's older brother, Mischa. Federer had an easier time than in his only previous match against Medvedev, a three-setter at Shanghai two weeks ago. 요약 : Federer had an easier time than in his only previous match against Medvedev, a three-setter at Shanghai two weeks ago. Federer dominated the 20th-ranked Medvedev and had his first match-point chance to break serve again at 5-1. Copil fired 26 aces past Zverev and never dropped serve, clinching after 2 1/2 hours with a forehand volley winner to break Zverev for the second time in the semifinal. 3 번 문서 원문 : Roger Federer has revealed that organisers of the re-launched and condensed Davis Cup gave him three days to decide if he would commit to the controversial competition. Speaking at the Swiss Indoors tournament where he will play in Sundays final against Romanian qualifier Marius Copil, the world number three said that given the impossibly short time frame to make a decision, he opted out of any commitment. "They only left me three days to decide", Federer said. "I didn't to have time to consult with all the people I had to consult. "I could not make a decision in that time, so I told them to do what they wanted." The 20-time Grand Slam champion has voiced doubts about the wisdom of the one-week format to be introduced by organisers Kosmos, who have promised the International Tennis Federation up to $3 billion in prize money over the next quarter-century. The competition is set to feature 18 countries in the November 18-24 finals in Madrid next year, and will replace the classic home-and-away ties played four times per year for decades. Kosmos is headed by Barcelona footballer Gerard Pique, who is hoping fellow Spaniard Rafael Nadal will play in the upcoming event. Novak Djokovic has said he will give precedence to the ATP's intended re-launch of the defunct World Team Cup in January 2020, at various Australian venues. Major players feel that a big event in late November combined with one in January before the Australian Open will mean too much tennis and too little rest. Federer said earlier this month in Shanghai in that his chances of playing the Davis Cup were all but non-existent. "I highly doubt it, of course. We will see what happens," he said. "I do not think this was designed for me, anyhow. This was designed for the future generation of players." Argentina and Britain received wild cards to the new-look event, and will compete along with the four 2018 semi-finalists and the 12 teams who win qualifying rounds next February. "I don't like being under that kind of pressure," Federer said of the deadline Kosmos handed him. 요약 : Major players feel that a big event in late November combined with one in January before the Australian Open will mean too much tennis and too little rest. Speaking at the Swiss Indoors tournament where he will play in Sundays final against Romanian qualifier Marius Copil, the world number three said that given the impossibly short time frame to make a decision, he opted out of any commitment. "They only left me three days to decide", Federer said. 4 번 문서 원문 : Kei Nishikori will try to end his long losing streak in ATP finals and Kevin Anderson will go for his second title of the year at the Erste Bank Open on Sunday. The fifth-seeded Nishikori reached his third final of 2018 after beating Mikhail Kukushkin of Kazakhstan 6-4, 6-3 in the semifinals. A winner of 11 ATP events, Nishikori hasn't triumphed since winning in Memphis in February 2016. He has lost eight straight finals since. The second-seeded Anderson defeated Fernando Verdasco 6-3, 3-6, 6-4. Anderson has a shot at a fifth career title and second of the year after winning in New York in February. Nishikori leads Anderson 4-2 on career matchups, but the South African won their only previous meeting this year. With a victory on Sunday, Anderson will qualify for the ATP Finals. Currently in ninth place, Nishikori with a win could move to within 125 points of the cut for the eight-man event in London next month. Nishikori held serve throughout against Kukushkin, who came through qualifying. He used his first break point to close out the first set before going up 3-0 in the second and wrapping up the win on his first match point. Against Verdasco, Anderson hit nine of his 19 aces in the opening set. The Spaniard broke Anderson twice in the second but didn't get another chance on the South African's serve in the final set. 요약 : Kei Nishikori will try to end his long losing streak in ATP finals and Kevin Anderson will go for his second title of the year at the Erste Bank Open on Sunday. The Spaniard broke Anderson twice in the second but didn't get another chance on the South African's serve in the final set. He has lost eight straight finals since. 5 번 문서 원문 : Federer, 37, first broke through on tour over two decades ago and he has since gone on to enjoy a glittering career. The 20-time Grand Slam winner is chasing his 99th ATP title at the Swiss Indoors this week and he faces Jan-Lennard Struff in the second round on Thursday (6pm BST). Davenport enjoyed most of her success in the late 1990s and her third and final major tournament win came at the 2000 Australian Open. But she claims the mentality of professional tennis players slowly began to change after the new millennium. "It seems pretty friendly right now," said Davenport. "I think there is a really nice environment and a great atmosphere, especially between some of the veteran players helping some of the younger players out. "It's a very pleasant atmosphere, I'd have to say, around the locker rooms. "I felt like the best weeks that I had to get to know players when I was playing were the Fed Cup weeks or the Olympic weeks, not necessarily during the tournaments. "And even though maybe we had smaller teams, I still think we kept to ourselves quite a bit. "Not always, but I really feel like in the mid-2000 years there was a huge shift of the attitudes of the top players and being more friendly and being more giving, and a lot of that had to do with players like Roger coming up. "I just felt like it really kind of changed where people were a little bit, definitely in the 90s, a lot more quiet, into themselves, and then it started to become better." Meanwhile, Federer is hoping he can improve his service game as he hunts his ninth Swiss Indoors title this week. "I didn't serve very well [against first-round opponent Filip Kranjovic," Federer said. "I think I was misfiring the corners, I was not hitting the lines enough. "Clearly you make your life more difficult, but still I was up 6-2, 3-1, break points, so things could have ended very quickly today, even though I didn't have the best serve percentage stats. "But maybe that's exactly what caught up to me eventually. It's just getting used to it. This is where the first rounds can be tricky." 요약 : "Not always, but I really feel like in the mid-2000 years there was a huge shift of the attitudes of the top players and being more friendly and being more giving, and a lot of that had to do with players like Roger coming up. "I felt like the best weeks that I had to get to know players when I was playing were the Fed Cup weeks or the Olympic weeks, not necessarily during the tournaments. "Clearly you make your life more difficult, but still I was up 6-2, 3-1, break points, so things could have ended very quickly today, even though I didn't have the best serve percentage stats. 6 번 문서 원문 : Nadal has not played tennis since he was forced to retire from the US Open semi-finals against Juan Martin Del Porto with a knee injury. The world No 1 has been forced to miss Spain's Davis Cup clash with France and the Asian hard court season. But with the ATP World Tour Finals due to begin next month, Nadal is ready to prove his fitness before the season-ending event at the 02 Arena. Nadal flew to Paris on Friday and footage from the Paris Masters official Twitter account shows the Spaniard smiling as he strides onto court for practice. The Paris Masters draw has been made and Nadal will start his campaign on Tuesday or Wednesday against either Fernando Verdasco or Jeremy Chardy. Nadal could then play defending champion Jack Sock in the third round before a potential quarter-final with either Borna Coric or Dominic Thiem. Nadal's appearance in Paris is a big boost to the tournament organisers who could see Roger Federer withdraw. Federer is in action at the Swiss Indoors in Basel and if he reaches the final, he could pull out of Paris in a bid to stay fresh for London. But as it stands, Federer is in the draw and is scheduled to face either former world No 3 Milos Raonic or Jo-Wilfried Tsonga in the second round. Federer's projected route to the Paris final could also lead to matches against Kevin Anderson and Novak Djokovic. Djokovic could play Marco Cecchinato in the second round. British No 1 Kyle Edmund is the 12th seed in Paris and will get underway in round two against either Karen Khachanov or Filip Krajinovic. 요약 : Nadal's appearance in Paris is a big boost to the tournament organisers who could see Roger Federer withdraw. Federer's projected route to the Paris final could also lead to matches against Kevin Anderson and Novak Djokovic. But as it stands, Federer is in the draw and is scheduled to face either former world No 3 Milos Raonic or Jo-Wilfried Tsonga in the second round. 7 번 문서 원문 : Tennis giveth, and tennis taketh away. The end of the season is finally in sight, and with so many players defending, or losing, huge chunks of points in Singapore, Zhuhai and London, podcast co-hosts Nina Pantic and Irina Falconi discuss the art of defending points (02:14). It's no secret that Jack Sock has struggled on the singles court this year (his record is 7-19). He could lose 1,400 points in the next few weeks, but instead of focusing on the negative, it can all be about perspective (06:28). Let's also not forget his two Grand Slam doubles triumphs this season. Two players, Stefanos Tsitsipas and Kyle Edmund, won their first career ATP titles last week (13:26). It's a big deal because you never forget your first. Irina looks back at her WTA title win in Bogota in 2016, and tells an unforgettable story about her semifinal drama (14:04). In Singapore, one of the biggest storylines (aside from the matches, of course) has been the on-court coaching debate. Nina and Irina give their opinions on what coaching should look like in the future, on both tours (18:55). 요약 : Let's also not forget his two Grand Slam doubles triumphs this season. The end of the season is finally in sight, and with so many players defending, or losing, huge chunks of points in Singapore, Zhuhai and London, podcast co-hosts Nina Pantic and Irina Falconi discuss the art of defending points (02:14). In Singapore, one of the biggest storylines (aside from the matches, of course) has been the on-court coaching debate. 8 번 문서 원문 : Federer won the Swiss Indoors last week by beating Romanian qualifier Marius Copil in the final. The 37-year-old claimed his 99th ATP title and is hunting the century in the French capital this week. Federer has been handed a difficult draw where could could come across Kevin Anderson, Novak Djokovic and Rafael Nadal in the latter rounds. But first the 20-time Grand Slam winner wants to train on the Paris Masters court this afternoon before deciding whether to appear for his opening match against either Milos Raonic or Jo-Wilfried Tsonga. "On Monday, I am free and will look how I feel," Federer said after winning the Swiss Indoors. "On Tuesday I will fly to Paris and train in the afternoon to be ready for my first match on Wednesday night. "I felt good all week and better every day. "We also had the impression that at this stage it might be better to play matches than to train. "And as long as I fear no injury, I play." Federer's success in Basel last week was the ninth time he has won his hometown tournament. And he was delighted to be watched on by all of his family and friends as he purchased 60 tickets for the final for those dearest to him. "My children, my parents, my sister and my team are all there," Federer added. "It is always very emotional for me to thank my team. And sometimes it tilts with the emotions, sometimes I just stumble. "It means the world to me. It makes me incredibly happy to win my home tournament and make people happy here. "I do not know if it's maybe my last title, so today I try a lot more to absorb that and enjoy the moments much more consciously. "Maybe I should celebrate as if it were my last title. "There are very touching moments: seeing the ball children, the standing ovations, all the familiar faces in the audience. Because it was not always easy in the last weeks." 요약 : "We also had the impression that at this stage it might be better to play matches than to train. "Maybe I should celebrate as if it were my last title. "On Monday, I am free and will look how I feel," Federer said after winning the Swiss Indoors. 21. 질의응답(Question Answering, QA) 이번 챕터에서는 페이스북에서 공개한 Babi QA 셋을 메모리 네트워크를 통해 풀어봅시다. 21-01 메모리 네트워크(Memory Network, MemN)를 이용한 QA 이번 챕터에서는 메모리 네트워크에 대해서 학습하고, 이를 통해 페이스북이 공개한 QA 데이터 셋을 풀어봅시다. 질의응답(Question Answering)의 다른 풀이법이 궁금하시면 18챕터의 KoBERT를 이용한 기계 독해 챕터를 참고하세요. 1. Babi 데이터 셋 babi Project의 데이터 셋은 기본적으로 다음과 같은<NAME>을 갖고 있습니다. ID text ID text ID text ID question[tab] answer[tab] supporting_fact ID. ... ID는 각 문장의 번호고요. 스토리가 시작될 때는 1번으로 시작합니다. 텍스트로 예를 들어볼게요. 우선 4개의 문장으로 구성된 스토리가 있다고 해봅시다. 1 Sandra travelled to the kitchen. 2 Sandra travelled to the hallway. 3 Mary went to the bathroom. 4 Sandra moved to the garden. 이제 위에 있는 4개의 문장으로 구성된 스토리를 기반으로 질문과 정답이 나옵니다. Sandra는 어디 있나요? Where is Sandra? 스토리에 있는 문장들을 보면 네 번째 문장에서 우리는 Sandra가 garden에 갔다는 사실을 알 수 있습니다. 레이블에 해당되는 Garden은 질문 다음 tab 뒤에 등장합니다. 5 Where is Sandra? Garden 4 Garden 옆에 숫자 4는 Supporting fact라고 해서 실제 정답이 주어진 스토리에서 몇 번 id 문장에 있었는지를 알려줍니다. 근데 이걸 알면 학습이 너무 쉽겠죠? 그래서 실제로는 인공지능의 훈련이 단계에서는 Supporting fact는 웬만하면 학습하지 않는 것이 원칙입니다. 저희도 Supporting fact는 학습하지 않을 예정입니다. 지금은 스토리, 질문, 답이라는 세 가지를 하나로 묶은 걸 본 것입니다. 실제로는 스토리와 질문이 굉장히 많겠죠? 그래서 실제 데이터 셋은 다음과 같이 구성됩니다. 1 Mary moved to the bathroom. 2 John went to the hallway. 3 Where is Mary? bathroom 1 4 Daniel went back to the hallway. 5 Sandra moved to the garden. 6 Where is Daniel? hallway 4 7 John moved to the office. 8 Sandra journeyed to the bathroom. 9 Where is Daniel? hallway 4 10 Mary moved to the hallway. 11 Daniel travelled to the office. 12 Where is Daniel? office 11 13 John went back to the garden. 14 John moved to the bedroom. 15 Where is Sandra? bathroom 8 1 Sandra travelled to the office. 2 Sandra went to the bathroom. 3 Where is Sandra? bathroom 2 여기서 주의할 점은 첫 번째 스토리는 무려 ID가 15번까지 이어졌는데, 중간에 질문은 3번, 6번, 9번, 11번, 15번으로 다섯 번이나 나왔다는 점입니다. 질문이 한 번 나왔다고 해서 스토리가 끝나는 게 아니에요. 스토리는 계속 이어지고 질문도 계속 이어집니다. 두 번째 스토리가 시작되자 15번 다음에는 다시 ID가 1번부터 시작되고 있네요. 2. 메모리 네트워크 구조 위 그림은 메모리 네트워크 구조를 간단히 표현한 그림입니다. 그림의 가장 상단을 보면 두 개의 입력이 들어옵니다. 각각 스토리 문장과 질문 문장입니다. 이 두 문장은 각각의 임베딩 과정을 거쳐야 합니다. 이제 그림의 우측 상단에 있는 초록색 박스와 하늘색 박스를 주목해 주세요. 스토리 문장은 Embedding C를 통해서 임베딩이 되고, 질문 문장은 Embedding B를 통해서 임베딩이 됩니다. 여기서 임베딩이란 문장 내 각 단어가 임베딩이 되어 각 단어가 임베딩 벡터로 변환된 문장을 얻는다는 의미입니다. 임베딩이 된 두 개의 문장은 내적(dot product)을 통해 각 단어 간 유사도를 구하고, 이렇게 구해진 유사도는 소프트맥스 함수를 지나서 Embedding A로 임베딩이 된 스토리 문장에 더해집니다. 현재 위 그림에서 '덧셈'이라고 적혀있는 부분까지 연산이 진행된 상태입니다. (Embedding A, B, C는 각각 별 개의 임베딩 층(Embedding layer)입니다.) 그런데 지금까지 설명한 연산을 표현을 조금 바꿔서 다시 설명해 보겠습니다. 스토리 문장을 Value와 Key라고 하고, 질문 문장을 Query라고 해보겠습니다. Query는 Key와 유사도를 구하고, 소프트맥스 함수를 통해 값을 정규화하여 Value에 더해서 이 유사도 값을 반영해 줍니다. 어디서 많이 들어본 설명 아닌가요? 결국 지금까지의 연산 과정은 어텐션 메커니즘의 의도를 갖고 있습니다. 지금까지 설명한 위 그림에서 '덧셈'이라고 적혀있는 부분까지의 연산은 어텐션 메커니즘을 통해서 질문 문장과의 유사도를 반영한 스토리 문장 표현을 얻기 위한 여정이었습니다. 이 스토리 문장 표현을 질문 문장을 임베딩한 질문 표현과 연결(concatenate) 해줍니다. 그리고 이 표현을 LSTM과 밀집층(dense layer)의 입력으로 사용하여 정답을 예측합니다. 3. Babi 데이터 셋 전처리하기 Babi 데이터 셋 전처리를 위해 필요한 도구들을 임포트 합니다. from tensorflow.keras.utils import get_file from tensorflow.keras.preprocessing.sequence import pad_sequences from tensorflow.keras.utils import to_categorical import numpy as np import tarfile from nltk import FreqDist from functools import reduce import os import re import matplotlib.pyplot as plt 케라스의 get_file을 통해 데이터 셋을 다운로드합니다. path = get_file('babi-tasks-v1-2.tar.gz', origin='https://s3.amazonaws.com/text-datasets/' 'babi_tasks_1-20_v1-2.tar.gz') 압축을 풀고 훈련 데이터와 테스트 데이터를 각각 얻습니다. with tarfile.open(path) as tar: tar.extractall() tar.close() DATA_DIR = 'tasks_1-20_v1-2/en-10k' TRAIN_FILE = os.path.join(DATA_DIR, "qa1_single-supporting-fact_train.txt") TEST_FILE = os.path.join(DATA_DIR, "qa1_single-supporting-fact_test.txt") 훈련 데이터로부터 상위 20개의 라인(line)만 읽고 출력해 보겠습니다. i = 0 lines = open(TRAIN_FILE , "rb") for line in lines: line = line.decode("utf-8").strip() # lno, text = line.split(" ", 1) # ID와 TEXT 분리 i = i + 1 print(line) if i == 20: break 1 Mary moved to the bathroom. 2 John went to the hallway. 3 Where is Mary? bathroom 1 4 Daniel went back to the hallway. 5 Sandra moved to the garden. 6 Where is Daniel? hallway 4 7 John moved to the office. 8 Sandra journeyed to the bathroom. 9 Where is Daniel? hallway 4 10 Mary moved to the hallway. 11 Daniel travelled to the office. 12 Where is Daniel? office 11 13 John went back to the garden. 14 John moved to the bedroom. 15 Where is Sandra? bathroom 8 1 Sandra travelled to the office. 2 Sandra went to the bathroom. 3 Where is Sandra? bathroom 2 4 Mary went to the bedroom. 5 Daniel moved to the hallway. 숫자 1부터 15까지 한 개의 스토리입니다. 그 중간중간에 질문이 나오고 있습니다. 3번, 6번, 9번, 12번, 15번 라인이 각 스토리 중간에 이어지는 질문에 해당되지요. 그리고 그 각각의 질문 옆에는 질문에 해당되는 정답이 적혀져 있고, 그 정답 옆에 나오는 번호는 해당 정답이 몇 번 번호의 라인에 있었는지를 알려줍니다. 그리고 숫자 1이 다시 나오면 이제부터는 다시 별개의 스토리가 시작됨을 의미합니다. 이렇게 복잡한 형태의 텍스트를 기계에게 바로 학습시키는 것은 조금 까다롭습니다. 그렇기 때문에 전처리를 거쳐서 스토리, 질문, 답변을 전부 별도로 저장해두겠습니다. def read_data(dir): stories, questions, answers = [], [], [] # 각각 스토리, 질문, 답변을 저장할 예정 story_temp = [] # 현재 시점의 스토리 임시 저장 lines = open(dir, "rb") for line in lines: line = line.decode("utf-8") # b' 제거 line = line.strip() # '\n' 제거 idx, text = line.split(" ", 1) # 맨 앞에 있는 id number 분리 # 여기까지는 모든 줄에 적용되는 전처리 if int(idx) == 1: story_temp = [] if "\t" in text: # 현재 읽는 줄이 질문 (tab) 답변 (tab)인 경우 question, answer, _ = text.split("\t") # 질문과 답변을 각각 저장 stories.append([x for x in story_temp if x]) # 지금까지의 누적 스토리를 스토리에 저장 questions.append(question) answers.append(answer) else: # 현재 읽는 줄이 스토리 인 경우 story_temp.append(text) # 임시 저장 lines.close() return stories, questions, answers train_data = read_data(TRAIN_FILE) test_data = read_data(TEST_FILE) train_stories, train_questions, train_answers = read_data(TRAIN_FILE) test_stories, test_questions, test_answers = read_data(TEST_FILE) print('훈련용 스토리의 개수 :', len(train_stories)) print('훈련용 질문의 개수 :',len(train_questions)) print('훈련용 답변의 개수 :',len(train_answers)) print('테스트용 스토리의 개수 :',len(test_stories)) print('테스트용 질문의 개수 :',len(test_questions)) print('테스트용 답변의 개수 :',len(test_answers)) 훈련용 스토리의 개수 : 10000 훈련용 질문의 개수 : 10000 훈련용 답변의 개수 : 10000 테스트용 스토리의 개수 : 1000 테스트용 질문의 개수 : 1000 테스트용 답변의 개수 : 1000 임의로 3,576번째 스토리를 출력해 봅시다. train_stories[3576] ['John went back to the garden.', 'Mary went to the kitchen.', 'Sandra went back to the bedroom.', 'John travelled to the bedroom.'] 임의로 3,576번째 질문을 출력해 봅시다. train_questions[3576] 'Where is John? ' '존은 어디야'라는 질문이네요. 위의 스토리에 따르면 존은 bedroom에 있습니다. 3,576번째 답변을 출력해 볼까요? train_answers[3576] 'bedroom' bedroom이 출력됩니다. def tokenize(sent): return [ x.strip() for x in re.split('(\W+)', sent) if x and x.strip()] def preprocess_data(train_data, test_data): counter = FreqDist() # 두 문장의 story를 하나의 문장으로 통합하는 함수 flatten = lambda data: reduce(lambda x, y: x + y, data) # 각 샘플의 길이를 저장하는 리스트 story_len = [] question_len = [] for stories, questions, answers in [train_data, test_data]: for story in stories: stories = tokenize(flatten(story)) # 스토리의 문장들을 펼친 후 토큰화 story_len.append(len(stories)) # 각 story의 길이 저장 for word in stories: # 단어 집합에 단어 추가 counter[word] += 1 for question in questions: question = tokenize(question) question_len.append(len(question)) for word in question: counter[word] += 1 for answer in answers: answer = tokenize(answer) for word in answer: counter[word] += 1 # 단어 집합 생성 word2idx = {word : (idx + 1) for idx, (word, _) in enumerate(counter.most_common())} idx2word = {idx : word for word, idx in word2idx.items()} # 가장 긴 샘플의 길이 story_max_len = np.max(story_len) question_max_len = np.max(question_len) return word2idx, idx2word, story_max_len, question_max_len word2idx, idx2word, story_max_len, question_max_len = preprocess_data(train_data, test_data) print(word2idx) {'to': 1, 'the': 2, '.': 3, 'went': 4, 'Sandra': 5, 'John': 6, 'Daniel': 7, 'Mary': 8, 'travelled': 9, 'journeyed': 10, 'back': 11, 'bathroom': 12, 'garden': 13, 'hallway': 14, 'moved': 15, 'office': 16, 'kitchen': 17, 'bedroom': 18, 'Where': 19, 'is': 20, '?': 21} vocab_size = len(word2idx) + 1 print('스토리의 최대 길이 :',story_max_len) print('질문의 최대 길이 :',question_max_len) 스토리의 최대 길이 : 68 질문의 최대 길이 : 4 def vectorize(data, word2idx, story_maxlen, question_maxlen): Xs, Xq, Y = [], [], [] flatten = lambda data: reduce(lambda x, y: x + y, data) stories, questions, answers = data for story, question, answer in zip(stories, questions, answers): xs = [word2idx[w] for w in tokenize(flatten(story))] xq = [word2idx[w] for w in tokenize(question)] Xs.append(xs) Xq.append(xq) Y.append(word2idx[answer]) # 스토리와 질문은 각각의 최대 길이로 패딩 # 정답은 원-핫 인코딩 return pad_sequences(Xs, maxlen=story_maxlen),\ pad_sequences(Xq, maxlen=question_maxlen),\ to_categorical(Y, num_classes=len(word2idx) + 1) Xstrain, Xqtrain, Ytrain = vectorize(train_data, word2idx, story_max_len, question_max_len) Xstest, Xqtest, Ytest = vectorize(test_data, word2idx, story_max_len, question_max_len) print(Xstrain.shape, Xqtrain.shape, Ytrain.shape, Xstest.shape, Xqtest.shape, Ytest.shape) (10000, 68) (10000, 4) (10000, 22) (1000, 68) (1000, 4) (1000, 22) 4. 메모리 네트워크로 QA 태스크 풀기 from tensorflow.keras.models import Sequential, Model from tensorflow.keras.layers import Embedding from tensorflow.keras.layers import Permute, dot, add, concatenate from tensorflow.keras.layers import LSTM, Dense, Dropout, Input, Activation # 에포크 횟수 train_epochs = 120 # 배치 크기 batch_size = 32 # 임베딩 크기 embed_size = 50 # LSTM의 크기 lstm_size = 64 # 과적합 방지 기법인 드롭아웃 적용 비율 dropout_rate = 0.30 # 플레이스 홀더. 입력을 담는 변수 input_sequence = Input((story_max_len,)) question = Input((question_max_len,)) print('Stories :', input_sequence) print('Question:', question) Stories : Tensor("input_1:0", shape=(None, 68), dtype=float32) Question: Tensor("input_2:0", shape=(None, 4), dtype=float32) # 스토리를 위한 첫 번째 임베딩. 그림에서의 Embedding A input_encoder_m = Sequential() input_encoder_m.add(Embedding(input_dim=vocab_size, output_dim=embed_size)) input_encoder_m.add(Dropout(dropout_rate)) # 결과 : (samples, story_max_len, embedding_dim) / 샘플의 수, 문장의 최대 길이, 임베딩 벡터의 차원 # 스토리를 위한 두 번째 임베딩. 그림에서의 Embedding C # 임베딩 벡터의 차원을 question_max_len(질문의 최대 길이)로 한다. input_encoder_c = Sequential() input_encoder_c.add(Embedding(input_dim=vocab_size, output_dim=question_max_len)) input_encoder_c.add(Dropout(dropout_rate)) # 결과 : (samples, story_max_len, question_max_len) / 샘플의 수, 문장의 최대 길이, 질문의 최대 길이(임베딩 벡터의 차원) # 질문을 위한 임베딩. 그림에서의 Embedding B question_encoder = Sequential() question_encoder.add(Embedding(input_dim=vocab_size, output_dim=embed_size, input_length=question_max_len)) question_encoder.add(Dropout(dropout_rate)) # 결과 : (samples, question_max_len, embedding_dim) / 샘플의 수, 질문의 최대 길이, 임베딩 벡터의 차원 # 실질적인 임베딩 과정 input_encoded_m = input_encoder_m(input_sequence) input_encoded_c = input_encoder_c(input_sequence) question_encoded = question_encoder(question) print('Input encoded m', input_encoded_m) print('Input encoded c', input_encoded_c) print('Question encoded', question_encoded) # 스토리 단어들과 질문 단어들 간의 유사도를 구하는 과정 # 유사도는 내적을 사용한다. match = dot([input_encoded_m, question_encoded], axes=-1, normalize=False) match = Activation('softmax')(match) print('Match shape', match) # 결과 : (samples, story_maxlen, question_max_len) / 샘플의 수, 문장의 최대 길이, 질문의 최대 길이 response = add([match, input_encoded_c]) # (samples, story_max_len, question_max_len) response = Permute((2, 1))(response) # (samples, question_max_len, story_max_len) print('Response shape', response) # 질문 벡터와 답변 벡터를 연결 answer = concatenate([response, question_encoded]) print('Answer shape', answer) answer = LSTM(lstm_size)(answer) answer = Dropout(dropout_rate)(answer) answer = Dense(vocab_size)(answer) answer = Activation('softmax')(answer) Match shape Tensor("activation/Identity:0", shape=(None, 68, 4), dtype=float32) Response shape Tensor("permute/Identity:0", shape=(None, 4, 68), dtype=float32) Answer shape Tensor("concatenate/Identity:0", shape=(None, 4, 118), dtype=float32) Match shape Tensor("activation/Identity:0", shape=(None, 68, 4), dtype=float32) Response shape Tensor("permute/Identity:0", shape=(None, 4, 68), dtype=float32) Answer shape Tensor("concatenate/Identity:0", shape=(None, 4, 118), dtype=float32) model = Model([input_sequence, question], answer) model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['acc']) print(model.summary()) history = model.fit([Xstrain, Xqtrain], Ytrain, batch_size, train_epochs, validation_data=([Xstest, Xqtest], Ytest)) model.save('model.h5') print("\n 테스트 정확도: %.4f" % (model.evaluate([Xstest, Xqtest], Ytest)[1])) 테스트 정확도: 0.9620 plt.subplot(211) plt.title("Accuracy") plt.plot(history.history["acc"], color="g", label="train") plt.plot(history.history["val_acc"], color="b", label="validation") plt.legend(loc="best") plt.subplot(212) plt.title("Loss") plt.plot(history.history["loss"], color="g", label="train") plt.plot(history.history["val_loss"], color="b", label="validation") plt.legend(loc="best") plt.tight_layout() plt.show() ytest = np.argmax(Ytest, axis=1) Ytest_ = model.predict([Xstest, Xqtest]) ytest_ = np.argmax(Ytest_, axis=1) 21-02 MemN으로 한국어 QA 해보기 이번 챕터에서는 한국어 Babi 데이터 셋에 대해서 이전 챕터에서 구현한 메모리 네트워크를 테스트해 보겠습니다. 질의응답(Question Answering)의 다른 풀이법이 궁금하시면 18챕터의 KoBERT를 이용한 기계 독해 챕터를 참고하세요. 1. 커스터마이즈드 KoNLPy 사용하기 영어권 언어는 띄어쓰기만 해도 단어들이 잘 분리되지만, 한국어는 그렇지 않다고 앞에서 몇 차례 언급했었습니다. 한국어 데이터를 사용하여 모델을 구현하는 것만큼 이번에는 형태소 분석기를 사용해서 단어 토큰화를 해보겠습니다. 그런데 형태소 분석기를 사용할 때, 이런 상황에 봉착한다면 어떻게 해야 할까요? 형태소 분석 입력 : '은경이는 사무실로 갔습니다.' 형태소 분석 결과 : ['은', '경이', '는', '사무실', '로', '갔습니다', '.'] 사실 위문장에서 '은경이'는 사람 이름이므로 제대로 된 결과를 얻기 위해서는 '은', '경이'와 같이 글자가 분리되는 것이 아니라 '은경이' 또는 최소한 '은경'이라는 단어 토큰을 얻어야만 합니다. 이런 경우에는 형태소 분석기에 사용자 사전을 추가해 줄 수 있습니다. '은경이'는 하나의 단어이기 때문에 분리하지 말라고 형태소 분석기에 알려주는 것입니다. 사용자 사전을 추가하는 방법은 형태소 분석기마다 다른데, 생각보다 복잡한 경우들이 많습니다. 이번 실습에서는 Customized Konlpy라는 사용자 사전 추가가 매우 쉬운 패키지를 사용합니다. 프롬프트에서 아래의 커맨드를 통해 형태소 분석기를 설치합니다. pip install customized_konlpy 이제 customized_konlpy에서 제공하는 형태소 분석기 Twitter를 사용하여 앞서 소개했던 예문을 단어 토큰화해봅시다. from ckonlpy.tag import Twitter twitter = Twitter() twitter.morphs('은경이는 사무실로 갔습니다.') ['은', '경이', '는', '사무실', '로', '갔습니다', '.'] 앞서 소개한 예시와 마찬가지로 '은경이'라는 단어가 '은', '경이'와 같이 분리됩니다. 이때, 형태소 분석기 Twitter에 add_dictionary('단어', '품사')와 같은<NAME>으로 사전 추가를 해줄 수 있습니다. twitter.add_dictionary('은경이', 'Noun') 제대로 반영되었는지 동일한 예문을 다시 형태소 분석해 봅시다. twitter.morphs('은경이는 사무실로 갔습니다.') ['은경이', '는', '사무실', '로', '갔습니다', '.'] 이제는 '은경이'라는 단어가 제대로 하나의 토큰으로 인식되는 것을 확인할 수 있습니다. 2. 한국어 Babi 데이터 셋 로드와 전처리 한국어 Babi 데이터 셋은 저자가 영어 데이터 셋을 참고하여 만들었으며, 아래의 링크에서 다운로드할 수 있습니다. 훈련 데이터 : https://bit.ly/31SqtHy 테스트 데이터 : https://bit.ly/3f7rH5g 우선 필요한 도구들을 임포트 합니다. from ckonlpy.tag import Twitter from tensorflow.keras.utils import get_file from tensorflow.keras.preprocessing.sequence import pad_sequences from tensorflow.keras.utils import to_categorical import numpy as np from nltk import FreqDist from functools import reduce import os import re import matplotlib.pyplot as plt 다운로드한 데이터를 로드합니다. TRAIN_FILE = os.path.join("qa1_single-supporting-fact_train_kor.txt") TEST_FILE = os.path.join("qa1_single-supporting-fact_test_kor.txt") 훈련 데이터로부터 상위 20개의 문장을 출력합니다. i = 0 lines = open(TRAIN_FILE , "rb") for line in lines: line = line.decode("utf-8").strip() i = i + 1 print(line) if i == 20: break 1 필웅이는 화장실로 갔습니다. 2 은경이는 복도로 이동했습니다. 3 필웅이는 어디야? 화장실 1 4 수종이는 복도로 복귀했습니다. 5 경임이는 정원으로 갔습니다. 6 수종이는 어디야? 복도 4 7 은경이는 사무실로 갔습니다. 8 경임이는 화장실로 뛰어갔습니다. 9 수종이는 어디야? 복도 4 10 필웅이는 복도로 갔습니다. 11 수종이는 사무실로 가버렸습니다. 12 수종이는 어디야? 사무실 11 13 은경이는 정원으로 복귀했습니다. 14 은경이는 침실로 갔습니다. 15 경임이는 어디야? 화장실 8 1 경임이는 사무실로 가버렸습니다. 2 경임이는 화장실로 이동했습니다. 3 경임이는 어디야? 화장실 2 4 필웅이는 침실로 이동했습니다. 5 수종이는 복도로 갔습니다. 영어 Babi 데이터 셋과<NAME>이 같은 것을 확인할 수 있습니다. read_data() 함수를 사용하여 훈련 데이터와 테스트 데이터를 로드합니다. def read_data(dir): // 영어 데이터 셋에 사용했던 이전 실습의 read_data() 함수와 동일한 함수입니다. read_data() 함수는 영어 데이터 셋을 사용한 이전 실습에서 사용했던 함수와 동일합니다. train_data = read_data(TRAIN_FILE) test_data = read_data(TEST_FILE) 훈련 데이터와 테스트 데이터가 로드되었습니다. 데이터의 구성을 확인하기 위해서 스토리, 질문, 답변을 각각 분리해서 로드해 봅시다. train_stories, train_questions, train_answers = read_data(TRAIN_FILE) test_stories, test_questions, test_answers = read_data(TEST_FILE) print('훈련용 스토리의 개수 :', len(train_stories)) print('훈련용 질문의 개수 :',len(train_questions)) print('훈련용 답변의 개수 :',len(train_answers)) print('테스트용 스토리의 개수 :',len(test_stories)) print('테스트용 질문의 개수 :',len(test_questions)) print('테스트용 답변의 개수 :',len(test_answers)) 훈련용 스토리의 개수 : 10000 훈련용 질문의 개수 : 10000 훈련용 답변의 개수 : 10000 테스트용 스토리의 개수 : 1000 테스트용 질문의 개수 : 1000 테스트용 답변의 개수 : 1000 임의로 3573번째 스토리, 질문, 답변을 출력해 보겠습니다. train_stories[3572] ['은경이는 부엌으로 가버렸습니다.', '필웅이는 사무실로 가버렸습니다.', '수종이는 복도로 뛰어갔습니다.', '은경이는 사무실로 복귀했습니다.', '경임이는 사무실로 이동했습니다.', '경임이는 침실로 갔습니다.'] train_questions[3572] 은경이는 어디야? train_answers[3572] 사무실 이제 토큰화 함수를 정의하고, 이로부터 Vocabulary를 생성하는 함수를 만들어봅시다. 아래의 함수는 이전 챕터에서 영어 데이터 셋에 사용했던 토큰화 함수와 동일합니다. 현재는 한국어이므로 아래의 토큰화 함수를 그대로 사용하는 것은 바람직하지는 않지만, 임시로 사용해 보겠습니다. 어절 단위로 했을 때 어떤 단어들이 있는지 출력해 보기 위함입니다. def tokenize(sent): return [ x.strip() for x in re.split('(\W+)?', sent) if x.strip()] 이제 Vocabulary를 만드는 함수를 정의합니다. def preprocess_data(train_data, test_data): // 영어 데이터 셋에 사용했던 이전 챕터의 preprocess_data 함수와 동일한 함수입니다. 해당 함수로부터 word2idx, idx2word, story_max_len, question_max_len를 리턴 받겠습니다. word2idx, idx2word, story_max_len, question_max_len = preprocess_data(train_data, test_data) word2idx를 출력해 봅시다. print(word2idx) {'.': 1, '경임이는': 2, '은경이는': 3, '수종이는': 4, '필웅이는': 5, '이동했습니다': 6, '가버렸습니다': 7, '뛰어갔습니다': 8, '복귀했습니다': 9, '갔습니다': 10, '화장실로': 11, '정원으로': 12, '복도로': 13, '어디야': 14, '?': 15, '부엌으로': 16, '사무실로': 17, '침실로': 18, '화장실': 19, '정원': 20, '사무실': 21, '침실': 22, '복도': 23, '부엌': 24} 띄어쓰기 단위, 다시 말해 어절 단위로 했을 때 나오는 총 토큰의 수는 24개입니다. 19번 토큰부터 24번 토큰까지를 봤을 때 장소에 해당되는 명사들은 '화장실', '정원', '사무실', '침실', '복도', '부엌'이 있는 것 같습니다. 그렇다면, 11번 토큰부터 19번 토큰 사이에 등장하는 '화장실로', '정원으로', '복도로', '부엌으로', '사무실로', '침실로'로 분리된 토큰들은 형태소 분석을 하였을 때 전부 '화장실', '정원', '사무실', '침실', '복도', '부엌'으로 분리되어야 합니다. 사람의 이름은 2번 토큰부터 5번 토큰을 참고하였을 때, '경임이는', '은경이는', '수종이는', '필웅이는' 이렇게 4개의 토큰이 존재하는 것 같습니다. 그렇다면 적어도 형태소 분석기를 하였을 때 사람의 이름이 제대로 분리되는 것을 목표로 해야 합니다. 만약, '은경이는'을 형태소 분석하였을 때 '은', '경이', '는'과 같이 사람의 이름이 분리돼서는 안 됩니다. 이제 여기서 해야 할 일은 형태소 분석기를 실제로 사용해서 우리가 원하는 결과가 정상적으로 출력되는지 확인하고, 그렇지 않다면 이에 대한 조치를 취해주는 것입니다. 형태소 분석기 Twitter()를 사용해 봅시다. twitter = Twitter() 경우의 수를 조합하여 사람 이름, 장소, 동사가 최소한 한 번씩 등장하도록 다음의 여섯 문장을 만들어보았습니다. 사람 이름은 4개, 동사가 5개, 장소가 6개로 장소의 개수가 제일 많기 때문에 총 여섯 문장이 나왔습니다. 각각 형태소 분석하여 우리가 의도하는 대로 결과가 나오는지 확인해 보았습니다. print(twitter.morphs('은경이는 화장실로 이동했습니다.')) print(twitter.morphs('경임이는 정원으로 가버렸습니다.')) print(twitter.morphs('수종이는 복도로 뛰어갔습니다.')) print(twitter.morphs('필웅이는 부엌으로 복귀했습니다.')) print(twitter.morphs('수종이는 사무실로 갔습니다.')) print(twitter.morphs('은경이는 침실로 갔습니다.')) ['은', '경이', '는', '화장실', '로', '이동', '했습니다', '.'] ['경', '임', '이', '는', '정원', '으로', '가버렸습니다', '.'] ['수종', '이', '는', '복도', '로', '뛰어갔습니다', '.'] ['필웅이', '는', '부엌', '으로', '복귀', '했습니다', '.'] ['수종', '이', '는', '사무실', '로', '갔습니다', '.'] ['은', '경이', '는', '침실', '로', '갔습니다', '.'] 화장실, 정원, 복도, 부엌, 사무실, 침실은 의도한 대로 모두 조사 '로'와 분리되어 제대로 된 명사의 형태를 갖춥니다. 문제는 사람의 이름을 유지하지 못하고 분리되는 경우인데, '필웅이'를 제외하고 모두 '--이' 형태로 분리할 수 있도록 사전을 추가해 주겠습니다. twitter.add_dictionary('은경이', 'Noun') twitter.add_dictionary('경임이', 'Noun') twitter.add_dictionary('수종이', 'Noun') 사전 추가 후에는 이름이 제대로 분리되는 것을 확인할 수 있습니다. print(twitter.morphs('은경이는 화장실로 이동했습니다.')) print(twitter.morphs('경임이는 정원으로 가버렸습니다.')) print(twitter.morphs('수종이는 복도로 뛰어갔습니다.')) print(twitter.morphs('필웅이는 부엌으로 복귀했습니다.')) print(twitter.morphs('수종이는 사무실로 갔습니다.')) print(twitter.morphs('은경이는 침실로 갔습니다.')) ['은경이', '는', '화장실', '로', '이동', '했습니다', '.'] ['경임이', '는', '정원', '으로', '가버렸습니다', '.'] ['수종이', '는', '복도', '로', '뛰어갔습니다', '.'] ['필웅이', '는', '부엌', '으로', '복귀', '했습니다', '.'] ['수종이', '는', '사무실', '로', '갔습니다', '.'] ['은경이', '는', '침실', '로', '갔습니다', '.'] 이제 이를 새로운 토큰화 함수로 정의합니다. def tokenize(sent): return twitter.morphs(sent) word2idx, idx2word, story_max_len, question_max_len를 리턴 받겠습니다. 형태소 분석기를 토큰화 함수를 변경하였기 때문에 이전보다는 시간이 좀 더 소요됩니다. word2idx, idx2word, story_max_len, question_max_len = preprocess_data(train_data, test_data) 새로 생성된 word2idx를 출력해 봅시다. print(word2idx) {'는': 1, '.': 2, '로': 3, '했습니다': 4, '으로': 5, '경임이': 6, '은경이': 7, '수종이': 8, '필웅이': 9, '이동': 10, '가버렸습니다': 11, '뛰어갔습니다': 12, '복귀': 13, '화장실': 14, '정원': 15, '복도': 16, '갔습니다': 17, '사무실': 18, '부엌': 19, '침실': 20, '어디': 21, '야': 22, '?': 23} 단어 집합의 크기를 정의합니다. vocab_size = len(word2idx) + 1 print(vocab_size) 24 스토리와 질문의 최대 길이를 출력해 봅시다. print('스토리의 최대 길이 :',story_max_len) print('질문의 최대 길이 :',question_max_len) 스토리의 최대 길이 : 70 질문의 최대 길이 : 5 def vectorize(data, word2idx, story_maxlen, question_maxlen): // 영어 데이터 셋에 사용했던 이전 챕터의 vectorize 함수와 동일한 함수입니다. Xstrain, Xqtrain, Ytrain = vectorize(train_data, word2idx, story_max_len, question_max_len) Xstest, Xqtest, Ytest = vectorize(test_data, word2idx, story_max_len, question_max_len) print(Xstrain.shape, Xqtrain.shape, Ytrain.shape, Xstest.shape, Xqtest.shape, Ytest.shape) (10000, 70) (10000, 5) (10000, 24) (1000, 70) (1000, 5) (1000, 24) 3. 메모리 네트워크로 QA 태스크 풀기 from tensorflow.keras.models import Sequential, Model from tensorflow.keras.layers import Embedding from tensorflow.keras.layers import Permute, dot, add, concatenate from tensorflow.keras.layers import LSTM, Dense, Dropout, Input, Activation # 에포크 횟수 train_epochs = 120 # 배치 크기 batch_size = 32 # 임베딩 크기 embed_size = 50 # LSTM의 크기 lstm_size = 64 # 과적합 방지 기법인 드롭아웃 적용 비율 dropout_rate = 0.30 # 플레이스 홀더. 입력을 담는 변수 input_sequence = Input((story_max_len,)) question = Input((question_max_len,)) print('Stories :', input_sequence) print('Question:', question) Stories : Tensor("input_1:0", shape=(None, 70), dtype=float32) Question: Tensor("input_2:0", shape=(None, 5), dtype=float32) # 스토리를 위한 첫 번째 임베딩. 그림에서의 Embedding A input_encoder_m = Sequential() input_encoder_m.add(Embedding(input_dim=vocab_size, output_dim=embed_size)) input_encoder_m.add(Dropout(dropout_rate)) # 결과 : (samples, story_max_len, embedding_dim) / 샘플의 수, 문장의 최대 길이, 임베딩 벡터의 차원 # 스토리를 위한 두 번째 임베딩. 그림에서의 Embedding C # 임베딩 벡터의 차원을 question_max_len(질문의 최대 길이)로 한다. input_encoder_c = Sequential() input_encoder_c.add(Embedding(input_dim=vocab_size, output_dim=question_max_len)) input_encoder_c.add(Dropout(dropout_rate)) # 결과 : (samples, story_max_len, question_max_len) / 샘플의 수, 문장의 최대 길이, 질문의 최대 길이(임베딩 벡터의 차원) # 질문을 위한 임베딩. 그림에서의 Embedding B question_encoder = Sequential() question_encoder.add(Embedding(input_dim=vocab_size, output_dim=embed_size, input_length=question_max_len)) question_encoder.add(Dropout(dropout_rate)) # 결과 : (samples, question_max_len, embedding_dim) / 샘플의 수, 질문의 최대 길이, 임베딩 벡터의 차원 # 실질적인 임베딩 과정 input_encoded_m = input_encoder_m(input_sequence) input_encoded_c = input_encoder_c(input_sequence) question_encoded = question_encoder(question) print('Input encoded m', input_encoded_m) print('Input encoded c', input_encoded_c) print('Question encoded', question_encoded) Input encoded m Tensor("sequential/Identity:0", shape=(None, 70, 50), dtype=float32) Input encoded c Tensor("sequential_1/Identity:0", shape=(None, 70, 5), dtype=float32) Question encoded Tensor("sequential_2/Identity:0", shape=(None, 5, 50), dtype=float32) # 스토리 단어들과 질문 단어들 간의 유사도를 구하는 과정 # 유사도는 내적을 사용한다. match = dot([input_encoded_m, question_encoded], axes=-1, normalize=False) match = Activation('softmax')(match) print('Match shape', match) # 결과 : (samples, story_maxlen, question_max_len) / 샘플의 수, 문장의 최대 길이, 질문의 최대 길이 response = add([match, input_encoded_c]) # (samples, story_max_len, question_max_len) response = Permute((2, 1))(response) # (samples, question_max_len, story_max_len) print('Response shape', response) answer = concatenate([response, question_encoded]) print('Answer shape', answer) answer = LSTM(lstm_size)(answer) answer = Dropout(dropout_rate)(answer) answer = Dense(vocab_size)(answer) answer = Activation('softmax')(answer) Match shape Tensor("activation/Identity:0", shape=(None, 70, 5), dtype=float32) Response shape Tensor("permute/Identity:0", shape=(None, 5, 70), dtype=float32) Answer shape Tensor("concatenate/Identity:0", shape=(None, 5, 120), dtype=float32) model = Model([input_sequence, question], answer) model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['acc']) history = model.fit([Xstrain, Xqtrain], Ytrain, batch_size, train_epochs, validation_data=([Xstest, Xqtest], Ytest)) model.save('model.h5') Epoch 1/120 313/313 [==============================] - 4s 13ms/step - loss: 1.8982 - acc: 0.1693 - val_loss: 1.7868 - val_acc: 0.2470 ... 중략 ... Epoch 120/120 313/313 [==============================] - 3s 10ms/step - loss: 0.0397 - acc: 0.9883 - val_loss: 0.5235 - val_acc: 0.9060 plt.subplot(211) plt.title("Accuracy") plt.plot(history.history["acc"], color="g", label="train") plt.plot(history.history["val_acc"], color="b", label="validation") plt.legend(loc="best") plt.subplot(212) plt.title("Loss") plt.plot(history.history["loss"], color="g", label="train") plt.plot(history.history["val_loss"], color="b", label="validation") plt.legend(loc="best") plt.tight_layout() plt.show() ytest = np.argmax(Ytest, axis=1) Ytest_ = model.predict([Xstest, Xqtest]) ytest_ = np.argmax(Ytest_, axis=1) NUM_DISPLAY = 30 print("{:18}|{:5}|{}".format("질문", "실제 값", "예측값")) print(39 * "-") for i in range(NUM_DISPLAY): question = " ".join([idx2word[x] for x in Xqtest[i].tolist()]) label = idx2word[ytest[i]] prediction = idx2word[ytest_[i]] print("{:20}: {:7} {}".format(question, label, prediction)) 질문 |실제 값 |예측값 --------------------------------------- 은경이는 어디 야? : 복도 복도 필웅이 는 어디 야? : 화장실 화장실 경임이는 어디 야? : 부엌 부엌 경임이는 어디 야? : 복도 복도 경임이는 어디 야? : 부엌 부엌 경임이는 어디 야? : 복도 복도 경임이는 어디 야? : 정원 정원 수종이는 어디 야? : 복도 복도 경임이는 어디 야? : 사무실 복도 수종이는 어디 야? : 사무실 복도 필웅이 는 어디 야? : 부엌 부엌 필웅이 는 어디 야? : 정원 정원 수종이는 어디 야? : 사무실 사무실 필웅이 는 어디 야? : 침실 침실 필웅이 는 어디 야? : 침실 침실 은경이는 어디 야? : 부엌 부엌 은경이는 어디 야? : 정원 정원 은경이는 어디 야? : 부엌 부엌 수종이는 어디 야? : 사무실 부엌 은경이는 어디 야? : 부엌 정원 필웅이 는 어디 야? : 복도 복도 은경이는 어디 야? : 사무실 사무실 은경이는 어디 야? : 사무실 사무실 경임이는 어디 야? : 복도 사무실 수종이는 어디 야? : 침실 침실 경임이는 어디 야? : 침실 침실 필웅이 는 어디 야? : 침실 침실 수종이는 어디 야? : 부엌 부엌 수종이는 어디 야? : 부엌 부엌 수종이는 어디 야? : 부엌 복도 22. GPT(Generative Pre-trained Transformer) 아직 작성 중인 챕터입니다. 해당 페이지는 현재 E-book을 구매하셔도 없으니 참고하시기 바랍니다. 추후 공개 시 기존 E-book 구매자분들에게만 메일로 별도 제공될 예정입니다. 실습 코드는 이미 완성되어 깃허브(github)에 업로드 되어 있습니다. 22-01 지피티(Generative Pre-trained Transformer, GPT) 현재 작성 완료되었으나 검수 중입니다. 해당 페이지는 현재 E-book을 구매하셔도 없으니 참고하시기 바랍니다. 단, 추후 공개 시 이론과 실습에 대한 설명을 기존 E-book 구매자분들에게만 메일로 별도 제공될 예정입니다. 실습 코드는 이미 완성되어 깃허브(github)에 업로드 되어 있습니다. 22-02 KoGPT를 이용한 문장 생성 현재 작성 완료되었으나 검수 중입니다. 해당 페이지는 현재 E-book을 구매하셔도 없으니 참고하시기 바랍니다. 단, 추후 공개 시 이론과 실습에 대한 설명을 기존 E-book 구매자분들에게만 메일로 별도 제공될 예정입니다. 실습 코드는 이미 완성되어 깃허브(github)에 업로드 되어 있습니다. 모든 GPT 실습은 Colab에서 진행한다고 가정하고 설명합니다. 사전 학습된 한국어 GPT-2를 이용하여 다음 문장 예측을 실습해 봅시다. 이번 실습을 위해서만이 아니라 앞으로 사전 학습된 GPT를 사용할 때는 transformers라는 패키지를 자주 사용하게 됩니다. 실습 환경에 transformers 패키지를 설치해둡시다. pip install transformers 1. KoGPT-2로 문장 생성하기 transformers 패키지를 사용하여 모델과 토크 나이저를 로드합니다. BERT와 마찬가지로 GPT는 이미 누군가가 학습해둔 모델을 사용하는 것이므로 우리가 사용하는 모델과 토크 나이저는 항상 매핑 관계여야 합니다. import numpy as np import random import tensorflow as tf from transformers import AutoTokenizer from transformers import TFGPT2LMHeadModel TFGPT2LMHeadModel.from_pretrained('GPT 모델 이름')을 넣으면 두 개의 문장이 이어지는 문장 관계인지를 판단하는 GPT 구조를 로드합니다. AutoTokenizer.from_pretrained('모델 이름')을 넣으면 해당 모델이 학습되었을 당시에 사용되었던 토크 나이저를 로드합니다. model = TFGPT2LMHeadModel.from_pretrained('skt/kogpt2-base-v2', from_pt=True) tokenizer = AutoTokenizer.from_pretrained('skt/kogpt2-base-v2') GPT가 생성할 문장의 방향성을 알려주기 위해서 시작 문자열을 정해줍니다. 여기서는 '근육이 커지기 위해서는'이라는 문자열을 주고 GPT에게 이어서 문장을 생성해 보라고 해봅시다. sent = '근육이 커지기 위해서는' GPT의 입력으로는 정수 인코딩 된 결과가 입력되어야 하므로 tokenizer.encode()를 통해서 '근육이 커지기 위해서는'이라는 문자열을 정수 시퀀스로 변환해 줍니다. input_ids = tokenizer.encode(sent) input_ids = tf.convert_to_tensor([input_ids]) print(input_ids) tf.Tensor([[33245 10114 12748 11357]], shape=(1, 4), dtype=int32) 33245 10114 12748 11357라는 5개의 정수 시퀀스를 얻습니다. 해당 정수 시퀀스를 GPT의 입력으로 사용하여 GPT가 이어서 문장을 생성하도록 해봅시다. 주어진 문장으로부터 이어서 문장을 생성하도록 하는 것은 model.generate()를 사용합니다. output = model.generate(input_ids, max_length=128, repetition_penalty=2.0, use_cache=True) output_ids = output.numpy().tolist()[0] print(output_ids) [33245, 10114, 12748, 11357, 23879, 39306, 9684, 7884, 10211, 15177, 26421, 387, 17339, 7889, 9908, 15768, 6903, 15386, 8146, 12923, 9228, 18651, 42600, 9564, 17764, 9033, 9199, 14441, 7335, 8704, 12557, 32030, 9510, 18595, 9025, 10571, 25741, 10599, 13229, 9508, 7965, 8425, 33102, 9122, 21240, 9801, 32106, 13579, 12442, 13235, 19430, 8022, 12972, 9566, 11178, 9554, 24873, 7198, 9391, 12486, 8711, 9346, 7071, 36736, 9693, 12006, 9038, 10279, 36122, 9960, 8405, 10826, 18988, 25998, 9292, 7671, 9465, 7489, 9277, 10137, 9677, 9248, 9912, 12834, 11488, 13417, 7407, 8428, 8137, 9430, 14222, 11356, 10061, 9885, 19265, 9377, 20305, 7991, 9178, 9648, 9133, 10021, 10138, 30315, 21833, 9362, 9301, 9685, 11584, 9447, 42129, 10124, 7532, 17932, 47123, 37544, 9355, 15632, 9124, 10536, 13530, 12204, 9184, 36152, 9673, 9788, 9029, 11764] 기존의 33245 10114 12748 11357라는 5개의 정수 시퀀스 뒤에도 여러 정수들이 추가로 생성된 것을 볼 수 있습니다. 정수들이 단순히 나열된 것만으로는 GPT가 실제로 어떤 문장을 생성했는지 알기 어려우니 해당 정수 시퀀스를 한국어로 변환해 봅시다. 이 과정은 tokenizer.decode()를 사용하여 가능합니다. tokenizer.decode(output_ids) '근육이 커지기 위해서는 무엇보다 규칙적인 생활습관이 중요하다. 특히, 아침식사는 단백질과 비타민이 풍부한 과일과 채소를 많이 섭취하는 것이 좋다. 또한 하루 30분 이상 충분한 수면을 취하는 것도 도움이 된다. 아침 식사를 거르지 않고 규칙적으로 운동을 하면 혈액순환에 도움을 줄 뿐만 아니라 신진대사를 촉진해 체내 노폐물을 배출하고 혈압을 낮춰준다. 운동은 하루에 10분 정도만 하는 게 좋으며 운동 후에는 반드시 스트레칭을 통해 근육량을 늘리고 유연성을 높여야 한다. 운동 후 바로 잠자리에 드는 것은 피해야 하며 특히 아침에 일어나면 몸이 피곤해지기 때문에 무리하게 움직이면 오히려 역효과가 날 수도 있다. 운동을' '근육이 커지기 위해서는'라는 문자열에 이어서 그 뒤에 근육이 커지기 위한이라는 문맥에 맞는듯한 글들을 생성합니다. 물론 GPT가 생성한 문장들은 문맥상 그럴듯해 보이지만 실제 사실 여부와는 다를 수 있으니 이 점은 늘 주의해야 합니다. 2. Numpy로 Top 5 뽑기 GPT는 기본적으로 이전 단어들로부터 다음 단어를 예측하는 언어 모델(Language Model)입니다. 위의 실습에서 확인한 바와 같이 '근육이 커지기 위해서는'이라는 입력을 넣었을 때 GPT는 다음 단어로 '무엇보다'라는 단어를 예측했었는데요. 실제로는 수많은 후보의 다음 단어들이 있었지만, 그중 가장 확률이 높은 단어. 즉, Top 1의 단어인 '무엇보다'를 예측한 것입니다. 그렇다면 다음 단어로 또 어떤 후보들이 있었는지 Top 5의 단어들을 뽑아봅시다. model()에다가 '근육이 커지기 위해서는'의 정수 인코딩 된 결과를 입력으로 넣은 후 가장 확률이 높은 Top 5의 단어들을 뽑아냅니다. output = model(input_ids) top5 = tf.math.top_k(output.logits[0, -1], k=5) 그 후 Top 5의 단어를 한국어로 변환하여 출력해 봅시다. tokenizer.convert_ids_to_tokens(top5.indices.numpy()) ['▁무엇보다', '▁우선', '▁반드시', '▁피부', '▁무엇보다도'] '무엇보다'라는 단어 외에도 '우선', '반드시', '피부', '무엇보다도'라는 4개의 단어가 높은 확률로 선택될 수 있었음을 보여줍니다. 3. Numpy Top 5로 문장 생성하기 앞서 문장을 생성했을 당시에는 각 시점(time step)마다 가장 확률이 높은 단어를 예측했지만, 이번에는 매 시점마다 Top 5개의 단어들 중에서 랜덤으로 선택하는 방식을 택하여 문장을 생성해 봅시다. sent = '근육이 커지기 위해서는' input_ids = tokenizer.encode(sent) while len(input_ids) < 50: output = model(np.array([input_ids])) # Top 5의 단어들을 추출 top5 = tf.math.top_k(output.logits[0, -1], k=5) # Top 5의 단어들 중 랜덤으로 다음 단어로 선택. token_id = random.choice(top5.indices.numpy()) input_ids.append(token_id) tokenizer.decode(input_ids) '근육이 커지기 위해서는 무엇보다 균형 있는 식사량이 필요하다. 또, 규칙적인 운동을 통한 영양소 섭취와 규칙적인 운동 등을 통해서 체지방을 줄여나가는 게 중요하다. 최소 한 달에 1회 이상 운동을 하고 체중이 감소하면 그 효과를 확인할 수는 있지만, 그 효과가 반감되는' 22-03 KoGPT-2 텍스트 생성을 이용한 한국어 챗봇 현재 작성 완료되었으나 검수 중입니다. 해당 페이지는 현재 E-book을 구매하셔도 없으니 참고하시기 바랍니다. 단, 추후 공개 시 이론과 실습에 대한 설명을 기존 E-book 구매자분들에게만 메일로 별도 제공될 예정입니다. 실습 코드는 이미 완성되어 깃허브(github)에 업로드 되어 있습니다. 22-04 KoGPT-2를 이용한 네이버 영화 리뷰 분류 현재 작성 완료되었으나 검수 중입니다. 해당 페이지는 현재 E-book을 구매하셔도 없으니 참고하시기 바랍니다. 단, 추후 공개 시 이론과 실습에 대한 설명을 기존 E-book 구매자분들에게만 메일로 별도 제공될 예정입니다. 실습 코드는 이미 완성되어 깃허브(github)에 업로드 되어 있습니다. 22-05 KoGPT-2를 이용한 KorNLI 분류 현재 작성 완료되었으나 검수 중입니다. 해당 페이지는 현재 E-book을 구매하셔도 없으니 참고하시기 바랍니다. 단, 추후 공개 시 이론과 실습에 대한 설명을 기존 E-book 구매자분들에게만 메일로 별도 제공될 예정입니다. 실습 코드는 이미 완성되어 깃허브(github)에 업로드 되어 있습니다. 23. 교육 문의 안녕하세요. 저자<NAME>입니다. 이 책에 작성된 교육 주제와 관련된 과외 또는 교육을 진행하고 있습니다. 파이썬 텍스트 분석, 딥 러닝 자연어 처리, PLM 등과 관련된 교육으로 기업 교육 및 대학교, 대학원 특강 등을 진행하고 있으며 상세 문의 및 커리큘럼은 <EMAIL>으로 부담 없이 편하게 연락 주시면 답변드리겠습니다. 감사합니다.<|endoftext|>

전문분야 텍스트 ### 제목: 왕초보를 위한 Python: 쉽게 풀어 쓴 기초 문법과 실습 ### 본문: 프로그래밍을 한 번도 해본 적이 없는 분들을 위해, 파이썬을 통해 처음으로 프로그래밍을 시작하도록 도와드립니다. 목차 0 머리말 1 파이썬 시작하기 2 제어 구조 3 함수 4 데이터 타입 5 모듈 6 파일 7 객체지향 8 예외 9 테스팅과 성능 A 부록 궁금한 점은 댓글을 남겨 주시고, 챗봇에게도 물어보세요. 파이썬 알려주는 봇 2(GPT-3.5 Turbo) 0. 머리말 예제 코드 예제 코드는 깃허브(Github)에 있습니다. https://github.com/ychoi-kr/wikidocs-chobo-python 2020년 제가 파이썬을 처음 접하고 이 책을 쓰기 시작한 지 20년이 되었습니다. 여러 가지 프로그래밍 언어를 배우고 사용하던 중 파이썬을 알게 되면서 그 강력함과 간결함에 매료되었고, 특히 교육용 언어로서의 가능성에 주목했습니다. 제가 초등학교 때 BASIC 언어로 컴퓨터 프로그래밍을 처음 배웠던 것처럼, 초등학생도 배울 수 있는 프로그래밍 언어 교재를 써 보자고 생각한 것이 바로 지금 보고 계신 '왕초보를 위한 파이썬'의 시작입니다. 처음에 파이썬 2.1 버전을 가지고 글을 써서 개인 홈페이지에 올리기 시작했고, 이듬해 같은 제목의 책을 출간하기도 했습니다. 나중에 위키독스로 이사를 와서 파이썬 2.7 버전을 기준으로 설명을 바꿨습니다. 파이썬 2.7은 파이썬 2의 마지막 버전이면서 파이썬 3의 구문을 지원하므로, 당시로서는 파이썬을 통해 프로그래밍 언어를 처음 배우는 사람을 위한 교재로서 최선의 선택이었습니다. 그래서 이 책에서는 그동안 파이썬 2.7을 기준으로 하되 파이썬 3의 설명도 덧붙이는 방식으로 설명했습니다. 최근 몇 년 사이 데이터 분석과 인공 지능 붐과 함께 파이썬에 대한 관심이 크게 늘었고, 어린이나 IT 분야와 직접 관련 없는 일반인을 대상으로 하는 코딩 교육의 필요성에 대한 인식도 확산되었습니다. 그 때문인지, 지금도 이 책을 읽는 분이 여전히 많이 계신 것 같습니다. 지금은 파이썬 3.8도 나와 있고, 아직 파이썬 2가 들어 있는 시스템이 있기는 하지만 프로그래밍 교육 관점에서는 파이썬 2를 크게 신경 쓰지 않아도 될 것 같습니다. 그래서, 좀 늦었지만 파이썬 3를 기준으로 설명하되 파이썬 2도 언급하는<NAME>으로 고쳐나가려고 합니다. 이전에도 파이썬 3를 다뤘으므로 내용이 크게 바뀌지는 않을 것 같습니다. 내용을 수정하는 동안에는 두 가지 방식의 설명이 섞여 불편하시더라도 너그럽게 양해 부탁드립니다. 용어 변경 및 설명 수정 널리 쓰이는 용어로 변경했습니다. 목록 → 리스트 사전 → 딕셔너리 또한, 설명과 예제를 쉽게 유지하면서도 좀 더 정확한 표현을 사용하려고 합니다. 연습 문제 추가 새로운 연습 문제를 추가했습니다.(주요 변경 이력 참조) 유튜브 영상 업로드 제 유튜브 채널(http://youtube.com/c/sk8erchoi)에 영상을 새로 올렸습니다. 각 페이지에 관련 영상을 링크했고, 파이썬 재생 목록에서도 보실 수 있습니다. 저자의 다른 책 이 책 외에도 제가 집필·번역한 책이 있으니 관심을 가져주시면 고맙겠습니다. 위키독스 책: https://wikidocs.net/profile/info/book/4 집필/번역한 책(yes24 리스트): http://list.yes24.com/bloglist/listList.aspx?blogid=sk8erchoi&listseqno=10608554 2013년 2013년 현재 Python 프로그래밍 언어는 2.X 버전과 3.X 버전이 함께 사용되고 있으며, 앞으로는 3.X 버전이 주로 쓰이게 될 것입니다. Python 프로그래밍 언어를 처음 접하는 분에게는 Python 3을 배우기를 권하고 싶습니다. 지금 보고 계시는 '왕초보를 위한 Python 2.7'은 Python 2를 기준으로 작성된 것입니다. 아직 학교나 회사에서는 Python 2.X 버전을 사용하는 경우도 많을 것이기 때문에, 필요한 분들을 위해 위키독스를 통해 공개하고 있습니다. 주소는 아래와 같습니다. http://wikidocs.net/book/2 이 글을 전자책으로 읽고 계시는 분이라면 위키독스에서 구매하셨으리라 생각합니다. 부족한 책을 구입해 주셔서 고맙습니다. 혹시 이 책을 주변 분들에게<NAME>고 싶은 마음이 드신다면, 파일을 직접 복사해 주시기보다는 전자책을 구입할 수 있는 주소를 알려주시기 바랍니다. 저자에게도 도움이 되고, 좋은 온라인 북을 무료로 읽을 수 있는 위키독스의 운영을 도와주실 수 있습니다. 2013년 여름, 여러분보다 한 걸음 앞서갔을 뿐인 왕초보 최용 올림 0.1 주요 변경 이력 2023. 8. 연습 문제: 직선거리 계산 추가 2023. 6. 연습 문제: 끝말잇기 (1), (2), (3) 추가 2023. 5. 연습 문제: 원주율 구하기 추가 연습 문제: 한자 성어 추가 2023. 4. 메서드 상속과 재정의 추가 연습 문제: 내일의 날짜 구하기(2) 추가 2023. 3. 연습 문제: 자릿수를 구하는 함수 만들기 추가 연습 문제: 음성 인식 일본어 퀴즈 개선 추가 2023. 2. for-else와 while-else 추가 연습 문제: 나이에 따른 세대 구분 (1), (2) 추가 연습 문제: 밴드 이름 짓기 (1), (2) 추가 2022. 11. 시저(카이사르) 암호 만들기 추가 본문과 그림을 전자책 PDF 포맷에 최적화 전자책 가격 인상(3000원 → 4000원) 2022. 10. 파이썬 설치와 실행에 마이크로소프트 스토어 소개 추가 파이썬 인터프리터에 ‘파이썬 실행 파일 경로 확인’ 추가 string과 random 모듈을 이용해 비밀번호 생성 추가 2022. 9. and/or 연산자 추가 match-case 문 추가 (Python 3.10 대응) 2022. 8. 7.5. 특별한 메서드들 수정(__cmp__ 삭제, __lt__ 추가) 퀴즈: 사칙 연산 추가 2022. 5. 일회용 스크립트를 재사용 가능하게 바꾸기 추가 놀이공원 연습 문제 (1), (2), (3) 추가 2022. 3. 연습 문제: 단위 기호 추가 2022. 2. 연습 문제: 프랙털 (Rule 90) 추가 예제 깃허브 저장소 주소 변경: https://github.com/ychoi-kr/wikidocs-chobo-python 2021. 7. 응용 예제: 음성 인식을 활용한 일본어 퀴즈 추가 2021. 6. 1장의 절 순서 변경 강의 영상 주소 QR 코드 이미지 추가 프로그램 실행 시간 측정하기 추가 일러스트 추가(Zdenek Sasek) 2021. 5. 영어 퀴즈 연습 문제 추가 2021. 4. 파일 크기 계산 연습 문제 추가 윈도 CMD에서 파이썬 활용 팁 추가 부록으로 이동 함수의 재귀 본문과 연습 문제 연습 문제: 여러 대의 컴퓨터에 연산을 분배하기 파이썬으로 PDF 파일 합치기 matplotlib으로 하트 그리기 모듈 사용법 알아내기 연습 문제 추가 숫자 읽기(아라비아 숫자에 해당하는 한글을 출력) 연습 문제 추가 조건문 함수 딕셔너리 테스팅 세트를 별도 페이지로 분리 주사위 눈의 합 연습 문제 추가 2021. 3. 애국가 연습 문제 추가 정신 질환 연습 문제 추가 회문 판별 함수 만들기 연습 문제 추가 직각삼각형의 빗변 길이 구하기 연습 문제 추가 함수 정의하기 연습 문제 추가 진법 변환과 비트 연산 추가 진법 변환 연습 문제 추가 소수 구하기 연습 문제를 2장에서 4장으로 이동 2021. 2. 내일의 날짜 구하기 연습 문제 추가 코드를 보고 실행 결과 맞히기 연습 문제 추가 소수 구하기 연습 문제의 두 번째 풀이 추가 calendar와 tkinter 연습 문제 추가 비밀 메시지 연습 문제 추가 2021. 1. 복리 이자를 재귀적으로 계산하는 함수 연습 문제 추가 단리 이자 계산, 복리 이자 계산 연습 문제 추가 줄기와 잎 그림 연습 문제 추가 2020. 12. 각 자리 숫자의 합을 구하는 함수(리스트를 이용) 연습 문제 추가 테스팅 추가 입력받은 숫자만큼 반복하기(for) 연습 문제 추가 제곱표(for) 연습 문제 추가 파이썬으로 PDF 파일 합치기 추가 2020. 11. 예제 깃허브 저장소 생성 양수만 덧셈하기 연습 문제 추가 입력받은 숫자만큼 반복하기(while) 연습 문제 추가 제곱 연습 문제 추가 2020. 10. 화학 실험실 연습 문제 추가 2020. 9. 소수 구하기 연습 문제 추가 2020. 7. 윤년 판별하기 연습 문제 추가 제곱표 연습 문제 추가 각 자리 숫자의 합을 구하는 재귀 함수 연습 문제 추가 얌체공 연습 문제 추가 2011. 위키독스로 이전 2003. 10. 카페24로 이전 2001. 강좌 시작(네띠앙) 옛날 모습 2004. 3. 28.(카페24) 2002. 2. 1.(네띠앙) 1. 파이썬 시작하기 이 강좌는 프로그래밍을 처음 하는 분들을 위해서 파이썬을 통해 프로그래밍의 기초를 차근차근 익힐 수 있도록 진행하려고 합니다. 우리 함께 파이썬 탐험을 떠나 볼까요~ 이 장에서 배우는 것: 파이썬 맛보기 변수 리스트(list) 인터프리터와 컴파일러 파이썬 설치 파이썬 인터프리터 1.1 파이썬 맛보기 강의 영상: https://youtu.be/ymSAvh-hntA/ 프로그래밍은 재미있습니다. 진짜로 재미있습니다. 그 재미를 알려면 프로그래밍을 직접 해봐야 하는데, 사실 프로그래밍을 시작하는 것이 쉽지가 않습니다. 그래서 여러분과 함께 배우기 쉬운 파이썬이라는 언어를 함께 공부해 보려고 합니다. 프로그래밍이 뭐냐고요? 사람이 컴퓨터에게 일을 시키려면 컴퓨터가 알아듣는 말로 일을 시켜야만 한답니다. 컴퓨터가 알아듣는 말로 그런 소프트웨어를 만드는 것이 바로 프로그래밍입니다. 그리고 컴퓨터가 알아듣는 말을 프로그래밍 언어라고 하지요. 우리가 앞으로 배울 파이썬 언어는, 배우기 쉬우면서도 프로그램을 빨리 개발할 수 있고, 기능도 뛰어나답니다. 웹브라우저에서 파이썬을 사용하기 파이썬을 설치하지 않고도 사용해 볼 수 있습니다. 파이썬 공식 홈페이지의 첫 화면에 있는 노란색 Launch Interactive Shell 아이콘을 클릭해 보세요. 아래 그림과 같은 파이썬 셸이 뜰 거예요. 파이썬 공식 홈페이지: http://python.org 또는, 파이썬 튜터(http://pythontutor.com/)나 ideone(https://ideone.com/) 같은 웹사이트에서도 파이썬 코드를 작성하고 실행해 볼 수 있어요! (파이썬 튜터는 2장의 while 문을 설명하는 영상에서 소개) 덧셈 그럼 뭐부터 해볼까요? 쓱싹쓱싹(손 비비는 소리)… 더하기 빼기가 좋겠군요. >>> 1 + 2 위와 같이 쓰고 Enter 키를 눌러보세요. 답이 나옵니까? 무지 쉽군요. 뺄셈 그럼 빼기도 해볼까요? >>> 50 - 4 46 역시 생각대로 잘 되는군요. 윈도 첨 배울 때보다도 훨씬 쉽답니다. 하하하. 컴퓨터 켜고 끄는 법보다 더 쉽지 않습니까??? 곱셈 곱하기 나누기까지만 하고 오늘은 쉴까요? 원래 첫 수업은 가볍게 시작하는 거니까요. 그럼 이번엔 좀 더 어려운 숫자를 이용해서 곱셈을 시켜 봅시다. >>> 12345678 * 3 37037034 곱하기도 성공! 알고 계시겠지만 컴퓨터에서는 *가 곱하기를 뜻한답니다. 나누기는요? 나눗셈 그렇습니다. /가 나누기지요. 이 정도는 기본이지요? 그럼 나눗셈도 해볼까요? (나눗셈은 파이썬 3와 파이썬 2의 결과가 달라요) Python 3: >>> 5000 / 3 1666.6666666666667 >>> 5000 // 3 1666 Python 2: >>> 5000 / 3 1666 나머지 또, 나머지를 구할 땐 %라는 연산자를 쓰면 됩니다. 예를 들어서, 50을 8로 나눈 나머지를 구해 볼까요? >>> 50 % 8 50 8 6 2 , 그러니까 50을 8로 나눈 몫은 6이고 나머지는 2니까 50 % 8의 결과는 2가 됩니다. 훌륭하군요. 나눗셈도 멋지게 해치우는 우리의 파이썬! 몫과 나머지를 한 번에 구하기 다음과 같이 divmod() 함수를 써서 몫과 나머지를 한 번에 계산할 수도 있답니다. >>> divmod(50, 8) (6, 2) 함수(function)는 이와 같이 여러 단계의 계산을 미리 정해둔 것으로 생각할 수 있습니다. 3장에서 함수를 직접 만드는 법을 알아봅니다. 그럼 오늘의 수업은 이만 줄이고 친구 만나러 가볼까요? tip 챗 GPT를 에뮬레이터로 사용할 수도 있습니다! ⟪생성 AI 활용기⟫의 ⟨챗 GPT를 에뮬레이터로 활용⟩ 페이지를 참고하세요. 1.1.1 퀴즈: 사칙 연산 생각해 볼 만한 문제가 있어서 소개합니다. 수학에서 다음을 계산한 결과는 얼마일까요? ÷ ( + ) 그렇다면, 파이썬 셸에서 다음 식을 계산한 결과는 얼마가 나올까요? 실행해 보기 전에 미리 답을 예상해 보세요. 8 // 2 * (2 + 2) 생각한 대로 답이 나왔나요? 참고 [깨 Talk] 전 세계 페이스북, 유튜브를 뜨겁게 달군 논란 _ 8÷2(2+2) = ? 1.1.2 연습 문제: 직선거리 계산 문제 미국 뉴욕의 맨해튼(Manhattan)은 바둑판처럼 구획되어 있어 스트리트와 애비뉴가 직교합니다. 아래 구글 지도에서 한식당에서 병원까지의 거리는 550미터, 병원에서 햄버거 가게까지의 거리는 600미터입니다. 한식당과 햄버거 가게 사이의 직선거리를 파이썬 셸을 사용해 계산해 보겠습니다. 중학교에서 배우는 수학 지식을 활용해서 이 문제를 풀 수 있습니다. 직각삼각형의 두 직각변,를 각각 한 변으로 하는 정사각형 면적의 합은 빗변(hypotenuse)를 한 변으로 하는 정사각형의 면적과 같습니다. 이를 ‘피타고라스 정리’라고 합니다. (위키백과) 2 b = 2 와의 길이를 알면의 길이를 구할 수 있습니다. = 2 b 이때 루트 값(양의 제곱근)을 계산해야 하는데, 파이썬에서는 다음과 같이 math 모듈의 sqrt 함수를 이용하면 됩니다.(모듈에 관해서는 5장에서 배웁니다.) >>> import math >>> math.sqrt(______________) 한식당과 햄버거 가게 사이의 직선거리를 구하려면 빈칸에 어떤 코드가 들어가야 할까요? 풀이 답을 아시는 분은 댓글에 써주세요. 참고로, 지도에서 직선거리를 측정해 보면 약 814미터가 나옵니다. tip 이 문제에서 구한 직선거리를 유클리드 거리(Euclidean distance)라고도 합니다. 그런데 직접 걸어가려면 건물을 뚫고 갈 수 없으니 길을 따라 550 + 600 = 1150미터를 이동해야겠죠? 이를 맨해튼 거리(Manhattan distance)라고 부릅니다. 1.2 변수 이번 시간에 갖고 놀 것은 변수(variable)입니다. 변수가 무슨 뜻일까요? 9시 뉴스에 가끔 등장하는 걸 들어보신 분이라면 대충 짐작이 가실 테지요. 수학에서도 나오고요. 플밍에서의 변수도 그와 비슷한 뜻을 갖고 있답니다. 정숫값을 가리키는 변수 자, 제 책상에는 시계, 라이터, 칫솔, 펜, 일주일째 물 마실 때 쓰고 있는 종이컵 등이 있습니다. 제 시계가 얼마일까요? 5천 원? 아닙니다. 힌트… 제 시계는 결혼 예물이랍니다. 그냥, 제 시계 값은 10만 원이라고 하겠습니다. 그럼 제 시계를 사고 싶은 사람이 있다고 합시다. 제 시계 값은 얼마일까요? 예, 그렇죠. 부르는 게 값입니다. 제가 백만 원 달라고 하면 백만 원짜리 시계가 되는 거지요. 하하~. 시계 하나가 10만 원도 되고 백만 원도 되는 겁니다. 그럼 시계 값을 프로그램으로 표현해 볼까요? >>> watch = 100000 제 시계가 십만 원이라는 것을 이렇게 써 보았습니다. 그럼, 라이터도 같은 방법으로 표현해 볼까요? >>> lighter = 300 라이터는 길에서 도우미한테 받은 건데 300원이라고 해봤습니다. 변수를 이용해 숫자를 계산하기 그럼, 저한테서 시계와 라이터를 사려면 얼마를 주셔야 할까요? 시계를 사려면 십만 원이 아니라 백만 원을 주셔야 한답니다. 그럼 시계 값을 올려야겠죠? >>> watch = 1000000 아까 십만 원이던 시계가 이젠 백만 원이 되었군요. 그럼 합이 얼마인가요? 손가락 꼽으면서 계산하는 분 계시죠? 하하. 그걸 컴퓨터한테 시켜 봅시다. >>> watch + lighter 1000300 오우, 역시 머리 잘 돌아가는 컴퓨터가 순식간에 계산을 해줬습니다. 이렇게 변수에는 값을 여러 번 넣을 수 있습니다. 변수의 값을 계산해 같은 변수에 다시 대입하기 시계를 중고로 팔아서 게임기를 사려고 합니다. 백만 원짜리 시계를 15% 할인한 가격은 얼마일까요? >>> 1000000 * 0.85 850000.0 (물론 1000000 - 1000000 * 0.15라든지 1000000 * (1 - 0.15)로 계산해도 되겠지만, 여기서는 위의 방법으로 설명할게요.) 마찬가지로, 어떤 변수가 가리키는 값을 15% 할인하는 것을 다음과 같은 코드로 나타낼 수 있을 것입니다. >>> price = 5000 >>> price = price * 0.85 >>> price 4250.0 위에서 변수 = 변수 * 값<NAME>의 문장은 변수 *= 값으로 줄여서 표현할 수도 있습니다. >>> price = 5000 >>> price *= 0.85 >>> price 4250.0 문자열을 가리키는 변수 변수에는 숫자 말고 글자도 넣을 수 있답니다. >>> a = 'pig' 요렇게 쓰면 a라는 변수에 'pig'라는 문자열(글자 여러 개)을 넣으라는 뜻입니다. 그러니까 a는 'pig'와 같다는 것이지요. 여기서 'pig'에 따옴표가 둘러져 있는 것을 주의해서 보셔야 합니다. 따옴표가 없으면 pig라는 변수로 착각을 하거든요. "pig는 문자열이다"라는 뜻으로 따옴표가 쓰이는 것입니다. 이번엔 b라는 변수에 'dad'라는 문자열을 넣어봅시다. >>> b = 'dad' 정말 쉽죠? 그럼 이번에 문자열끼리 이어 붙여 볼까요? >>> a + b pigdad 아까 시계랑 라이터 값을 더할 때랑 같은 방법을 썼더니 문자열들이 합쳐지지요? 재미있지 않습니까? 재미없으시다고요? 그렇다면 좀 더 재미있는 것을 해봅시다. >>> a + ' ' + b pig dad 여기선 a라는 변수와 ' '(공백 문자 한 개)와 b라는 변수를 붙여서 'pig dad'라는 문자열을 만들어 준 것이지요. 이해되시지요? 오늘의 강좌는 여기까지입니다. 1.2.1 연습 문제: 파일 크기 계산 문제 파일을 다운로드할 때의 평균 속도(average rate)를 이라 하고, 다운로드하는 데 걸린 시간(time)을라고 할 때, 다운로드한 파일의 용량은 ×로 계산할 수 있습니다. 다운로드 속도가 초당 800kB이고 다운로드하는 데 걸린 시간이 110초라고 할 때, 다운로드한 파일의 크기는 몇 MB일까요? 단, MB 1000 kB 로 계산합니다. ch01/download.txt 1.3 리스트(list) 강의 영상: https://youtu.be/-BA3lbvggCM 안녕하세요~ 여러분~ 오늘도 여러분과 함께 파이썬 놀이하러 왔습니다. 오늘이 제가 이 강좌를 시작한 지 이틀째 되는 날입니다. 작심삼일이 되지 않도록 저에게 힘을 주세요. 저도 엊그제까지만 해도 파이썬에 대해 아무것도 몰랐답니다. 무식하면 용감하다고 저도 공부해 가면서 용감하게 글을 쓰고 있습니다. ^^; 오늘은 저희 가족 이야기를 해보겠습니다. 저희 식구는 네 명이었습니다. 어머니, 아버지, 저, 동생. 대장은 어머니, 그다음이 아버지입니다. 그러니까 저는 넘버 쓰리였던 것이었습니다… 으흐흐… 파이썬에서는 저희 가족을 이렇게 표현할 수 있답니다. >>> family = ['mother', 'father', 'gentleman', 'sexy lady'] 저희 가족에는 아버지, 어머니, 저, 동생이 있다는 것을 리스트(list)로 표현한 것이지요. 이해가 갑니까? 옵니까? 예, 그냥 동생이라고 했는데 실은 여동생입니다. 침 닦으십쇼. --# len() 그럼, 컴퓨터한테 저희 가족이 몇 명인지 물어보겠습니다. >>> len(family) len() 함수는 리스트에 원소(element)가 몇 개 들어 있는지 보여줍니다. 저희 가족을 family라는 리스트로 표현했으니까 4라고 대답을 하는 겁니다. 리스트는 말 그대로 여러 개의 자료를 묶은 것입니다. 위에서 보신 것처럼 대괄호([ ])랑 콤마(,)를 써서 표현하면 됩니다. 그럼 저희 가족 중에 넘버 쓰리가 누구인지 물어볼까요? 아래와 같이 입력하고 Enter를 살짝 눌러주세요. >>> family[3] 답이 뭐라고 나오죠? 당근 'gentleman'이라고 나오겠죠? 그러나! 이상하게도 파이썬은 다른 대답을 합니다. 어떤 결과가 나오는지 직접 확인해 보세요. ... 확인해 보셨나요? 왜 그런 답이 나왔을까요? 그 이유는 리스트의 첫 번째 자리를 차고앉은 'mother'가 1번이 아니라 0번이기 때문입니다. 왜 1이 아니라 0일까요? 그건 저도 잘 모릅니다.--; 파이썬 말고 다른 프로그래밍 언어에서도 여러 개를 묶어두었을 땐 번호를 0번부터 붙여주더군요. 그렇다면 저는 몇 번일까요? 'mother'가 0이고, 'father'가 1이니까 저는 2겠군요. 맞는지 확인을 해봐야죠? >>> family[2] 'gentleman' 제가 넘버 투가 되어버린 감격스러운 순간입니다!!! 기뻐해 주십시오, 여러분~. 하지만 그 기쁨도 잠시, 저의 머리가 5400rpm으로 회전하기 시작했습니다(rpm은 1분에 몇 바퀴를 도는지 나타내는 단위로, 컴퓨터의 하드 디스크 회전속도가 보통 5400rpm 또는 7200rpm입니다). 저는 넘버 투에 만족할 놈이 아니기 때문입니다. 머리를 한참 굴리던 저는 넘버 0이 될 수 있는 방법을 찾아내었습니다. 무슨 방법이냐고요? 독립입니다. 대한독립만세~ remove() 우선 가족에서 제 이름을 뺍니다. >>> family.remove('gentleman') remove는 뭔가를 제거한다는 뜻을 갖고 있죠. 위의 문장은 family에서 'gentleman'이라는 놈을 없애라는 말입니다. 그럼 제가 확실히 없어졌는지 확인해 보겠습니다. >>> family ['mother', 'father', 'sexy lady'] 예, 제가 확실히 제거되었군요. 이제 새로운 세대를 구성할 차례입니다. 새로운 리스트는 family 말고 다른 이름을 지어주면 좋을 것 같습니다. 여러분이 새로운 이름으로 하나 만들어주세요. 1.4 인터프리터와 컴파일러 컴퓨터가 알아듣는 말 엄청난 양의 정보들을 잘도 주무르는 이 컴퓨터란 녀석은 대체 어떻게 작동하는 걸까요? 컴퓨터는 전기가 통하는지 안 통하는지의 딱 두 가지 정보를 가지고 정보를 처리한답니다. 우리가 저녁이 되면 전깃불을 켜고, 잠잘 땐 끄는 것과 마찬가지입니다. 저는 불을 켜고도 잘 자지만요.^^ 이렇게 간단한 정보를 갖고 무엇을 할 수 있을까 싶지만, 스위치가 두 개 있으면 네 가지 정보를 표현할 수 있다는 걸 생각해 보세요. 큰 방 불 켜고, 작은방 불 꺼. 큰 방 불 켜고, 작은방도 불 켜. 큰 방 불 끄고, 작은방 불 켜. 큰 방 불 끄고, 작은방도 불 꺼. 스위치가 10개 있으면 몇 가지 정보를 표현할 수 있을까요? 스위치가 두 개 있으면 2의 제곱인 4 가지 정보를 표현할 수 있었고요, 스위치가 10개 있으면 2의 10 제곱, 그러니까 1024가지 정보를 표현할 수 있답니다. 컴퓨터에선 불이 켜지고 꺼진 것을 1과 0으로 나타내고요, 스위치 하나에 해당하는 것을 비트(bit)라고 말하지요. 컴퓨터에 일을 시키려면 컴퓨터가 알아들을 수 있는 말로 지시(instruction)를 내려야 합니다. 이럴 때 쓰이는 프로그래밍 언어를 저급 언어(low-level language)라고 합니다. 저급 언어로는 기계어와 어셈블리어가 있습니다. 그런데 사람이 1과 0으로 프로그래밍하는 것이 가능할까요? “컴퓨터야, 10111101한 다음에 01001011 하고, 만약에 10011010이면 10101100 하고 그렇지 않으면 11010011 해다오, 알았지??” 얼마나 짜증 나겠습니까? 그런 어려움이 있기 때문에 사람이 프로그램 작성을 쉽게 할 수 있도록 요즘 많이 쓰는 C/C++, 파이썬, 자바 같은 고급 언어(high-level language)가 생겨났답니다. 인터프리터와 컴파일러 그런데 이런 고급 언어로 프로그램을 짠 다음엔 컴퓨터가 알아들을 수 있게 번역을 해 줄 필요가 있겠죠? 그렇게 번역을 하는 방법에도 두 종류가 있답니다. (예, 압니다. 저도 종류 많은 거 딱 질색입니다…^^;) 한마디 할 때마다 동시통역해 주는 방식을 인터프리터(interpret) 방식이라고 하고, 말하는 것을 처음부터 끝까지 듣고 나서 한꺼번에 바꿔주는 것을 컴파일(compile) 방식이라고 합니다. 우리가 배우는 파이썬은 어떤 방식일까요? 파이썬은 우리의 명령을 한 줄씩 해석해서 일을 하는 인터프리터 방식입니다. 사람이 파이썬 언어로 작성한 프로그램을 컴퓨터에 번역해 주는 파이썬 셸이 바로 인터프리터(interpreter)랍니다. 인터프리터와 컴파일러를 설명한 애니메이션(우리말 자막 있음): https://youtu.be/Dx2tSsd3aFc 1.5 파이썬 설치와 실행 파이썬이라는 언어를 좀 더 갖고 놀아보고 싶은 마음이 드셨나요? 저는 ‘공부’한다는 말보다는 ‘논다’는 것이 더 마음에 드는군요. 재미있으니까요. 파이썬 설치 파이썬을 본격적으로 배우기에 앞서, 컴퓨터에 파이썬을 설치하겠습니다. 이 책에는 컴퓨터의 파일을 다루는 실습도 있으므로 파이썬을 설치할 것을 권장하지만, 설치하기 곤란한 분은 넘어가셔도 됩니다. 아래에서 소개하는 대표적인 파이썬 배포판 중 하나를 선택해 설치하시면 됩니다. 일반적인 설치 python.org의 다운로드 페이지에서 파이썬 설치 프로그램을 내려받으실 수 있습니다. 최신 버전(2023년 1월 7일 현재 3.11.1)을 다운로드해 주세요. 파일을 받으셨으면 인스톨러를 실행해 ‘Install Now’ 버튼을 눌러 설치해 주세요. 파이썬 설치<NAME>상: https://youtu.be/mk8lP7WLQ9E 과학, 수학, 데이터 분석 목적의 배포판 설치 과학 계산용으로 널리 사용되는 파이썬 패키지들을 쉽게 관리할 수 있는 배포판도 있습니다. 그중 대표적인 것이 아나콘다(Anaconda)입니다. 이 책으로 파이썬 문법을 익힌 후 데이터 분석 및 머신러닝을 하려는 분은 처음부터 아나콘다를 설치해서 실습하셔도 됩니다. 아나콘다 설치<NAME>상: https://youtu.be/CNGBwFcmBZM tip Q: 다른 파이썬 책에서 3.7 버전으로 실습하라는데, 파이썬을<NAME>고 새로 설치해야 하나요? A: 파이썬 기본 문법을 배울 때는 더 높은 버전으로 실습해도 문제가 없습니다. 예를 들어, 파이썬 3.7을 기준으로 작성한 코드를 파이썬 3.9에서도 실행할 수 있습니다. 그런데 여러 가지 파이썬 패키지를 추가로 설치해서 사용하다 보면 파이썬 버전을 맞춰야 할 때가 있습니다. 그럴 때 파이썬 가상 환경(venv 또는 conda env)을 활용하면 가상 환경마다 파이썬 버전을 다르게 할 수 있어 편리합니다. 아나콘다 설치<NAME>상의 가상 환경 설명(https://youtu.be/CNGBwFcmBZM? t=494)을 참고하세요. 마이크로소프트 스토어 윈도 운영체제에 포함된 ‘마이크로소프트 스토어(Microsoft Store)’에서 ‘Python’을 검색해 설치할 수도 있습니다. 맥 또는 리눅스 환경 맥이나 리눅스를 쓰시는 분들은 파이썬이 이미 설치되어 있을 수도 있습니다. 터미널에서 python 또는 python3이라고 쳐보세요. Mac% python Python 2.7.10 (default, Feb 7 2017, 00:08:15) [GCC 4.2.1 Compatible Apple LLVM 8.0.0 (clang-800.0.34)] on darwin Type "help", "copyright", "credits" or "license" for more information. >>> 그런데 시스템에 기본으로 설치된 파이썬 버전이 2.7.X인 경우, 이 책에서는 파이썬 3를 기준으로 설명하므로 간혹 실행 결과가 다르게 나올 수 있습니다. 특별한 이유가 없다면 파이썬 3.8 이상을 설치하는 것이 좋습니다. 맥 OS에 파이썬 3 설치 (1) 제가 새로 산 맥북(2022년형, M2)에 파이썬이 설치돼 있는지 보려고 터미널에서 명령을 실행했더니 아래와 같은 메시지와 함께 팝업 창이 떴습니다. yong@MacBookPro ~ % python --version zsh: command not found: python yong@MacBookPro ~ % python3 --version xcode-select: note: no developer tools were found at '/Applications/Xcode.app', requesting install. Choose an option in the dialog to download the command line developer tools. 팝업 창의 ‘설치’ 버튼을 누르고 잠시 기다렸더니 파이썬이 설치됐습니다. yong@MacBookPro ~ % python3 --version Python 3.9.6 yong@MacBookPro ~ % python3 Python 3.9.6 (default, Oct 18 2022, 12:41:40) [Clang 14.0.0 (clang-1400.0.29.202)] on darwin Type "help", "copyright", "credits" or "license" for more information. >>> 맥 OS에 설치 (2) 다른 방법으로, https://www.python.org/downloads/macos/에서 맥용 인스톨러를 다운로드해서 설치해도 됩니다. 맥에는 인텔 CPU가 들어간 것도 있고 애플 실리콘(M1, M2)이 들어간 것도 있는데, 파이썬 최신 버전을 설치할 때는 어느 CPU를 사용하는지에 관계없이 macOS 64-bit universal2 installer를 사용해 설치하면 됩니다. 2020년 11월 ~ 2022년 5월 사이에 나온 파이썬 배포판의 맥용 인스톨러는 CPU 별로 따로 되어 있습니다. 그중에서 하나를 설치하고 싶다면, 바탕 화면 왼쪽 위의 사과 모양 아이콘을 누르고 ‘이 Mac에 관하여’를 누른 뒤 칩을 확인합니다. 칩이 Apple M1 또는 Apple M2로 표시될 때는 macOS 64-bit universal2 installer를 다운로드합니다. 인텔 칩일 때는 macOS 64-bit Intel installer를 다운로드합니다. 라즈베리 파이에서 파이썬 사용 다음 문서를 참고하세요. https://wikidocs.net/3168 파이썬 셸 실행하기 그럼 파이썬을 실행해 볼까요? 윈도의 시작 메뉴에서 파이썬을 실행해 주세요. 예를 들어 윈도 11에 Python 3.10(64비트)을 설치한 경우, 윈도 버튼 → 모든 앱 → Python 3.10 → Python 3.10 (64-bit)을 선택합니다. 다음과 같이 파이썬 셸이 실행됩니다. 여러분은 앞으로 이것을 이용해서 프로그래밍을 하게 될 겁니다. 1.6 파이썬 인터프리터 인터프리터를 대화식으로 사용하기 지금까지 우리가 사용했던, 인터프리터에 명령을 한 줄씩 입력하면 인터프리터가 그때그때 답을 돌려주는 방법을 두고 “대화식으로 인터프리터를 사용한다”라고 합니다. 당연한 말이지만 대화식은 아주 쉽고 간단한 사용방법입니다. 우리도 파이썬에 대해 아무것도 모르는 상태에서 당장 인터프리터를 계산기처럼 쓰기 시작할 수 있었지요. 대화식 사용방법은 그냥 쉽기만 한 것이 아니라, 파이썬의 문법을 배우고 연습해 보거나, 복잡한 프로그램을 작성하기 위해 작은 부분을 테스트할 때도 아주 편리하답니다. 인터프리터로 프로그램 파일을 실행하기 대화식 사용방법이 여러모로 편리하기는 하지만, 실제로 프로그램을 작성할 때는 역시 프로그램을 파일 형태로 만들어 두었다가 사용해야겠죠? 파이썬에서는 프로그램 파일을 어떻게 만드는 걸까요? 파이썬에 포함된 IDLE 또는 여러분이 즐겨 쓰는 텍스트 편집기(메모장 같은 프로그램)에서 다음 코드를 작성해 보세요. 파이썬 3: print('직각삼각형 그리기\n') leg = int(input('변의 길이: ')) for i in range(leg): print('* ' * (i + 1)) area = (leg ** 2) / 2 print('넓이:', area) 파이썬 2: print('Right triangle\n') leg = int(raw_input('leg: ')) for i in range(leg): print('* ' * (i + 1)) area = (leg ** 2) / 2.0 print('area:', area) 처음 보는 것들이 많지만 나중에 배울 것들이니 겁먹지 마시고 그냥 똑같이 쓰시면 됩니다. 주의하실 점은, 반드시 들여 쓰기를 지켜주셔야 한다는 것입니다. 들여 쓰기를 하실 땐 공백 네 칸씩 들여 쓰기 하시면 됩니다. 이것을 triangle.py라는 이름으로 저장해 주세요. 파이썬 코드 파일에는 py라는 확장자가 붙습니다. 저장 위치는 \wikidocs-chobo-python\ch01이라고 가정하고 설명합니다. 코드 작성과 실행까지 IDLE에서 할 수도 있고, 텍스트 편집기에서 작성한 후 윈도 명령 프롬프트에서 실행할 수도 있어요. tip Tip: 텍스트 편집기에 공백을 표시하기 텍스트 편집기 중에는 탭과 스페이스를 기호로 나타내는 기능이 있는 것도 있습니다. Notepad++를 예로 들면, 그림과 같이 보기→기호 보기→공백과 탭 표시 메뉴를 선택하면 됩니다. IDLE에서 실행 위 예제 코드를 IDLE에서 작성하고 실행하는 영상입니다. (파이썬 3.8) https://youtu.be/P4xAx4HFahU 윈도 명령 프롬프트에서 실행 명령 프롬프트 창 열기 먼저 명령 프롬프트를 띄워보세요. 다음 두 가지 방법 중 편한 방법으로 하시면 됩니다. 윈도 메뉴에서 Windows 시스템 - 명령 프롬프트를 선택 + R을 누르고 실행 창에서 cmd 입력 윈도 버전에 따라 조금씩 다르기는 하지만 아래 그림과 비슷한 창이 뜰 거예요. 명령어 인터페이스가 사용하기 번거롭기는 해도 좀 더 자세한 조작을 하기에 적합하지요. 다른 언어로 프로그램을 작성할 때도 종종 쓰이니까 이번 기회에 익혀두자고요. 명령 프롬프트를 실행하면 사용자의 홈 폴더에서 시작합니다. 지금 제 컴퓨터에서는 C:\Users\yong이 현재 경로입니다. 파이썬 실행 파일 경로 확인 파이썬 실행 파일이 어디에 있는지는 where(윈도)나 which(리눅스, 맥) 명령을 써서 확인할 수 있습니다. 윈도에서: C:\Users\yong>where python C:\Users\yong\AppData\Local\Programs\Python\Python310\python.exe C:\Users\yong\AppData\Local\Microsoft\WindowsApps\python.exe tip where 명령은 현재 폴더 및 PATH 환경 변수에 등록된 경로에서 파일을 찾습니다. 따라서 파이썬 설치 시 PATH 등록 옵션을 선택하지 않은 경우, where의 결과에 나타나지 않을 수 있습니다. 리눅스에서: (base) yong@thinkpad:~$ which python /home/yong/anaconda3/bin/python 파이썬 설치 경로로 이동 파이썬이 설치된 곳으로 이동해 보겠습니다. 다음과 같이 cd 명령을 사용합니다. cd Appdata\Local\Programs\Python dir cd Python310 현재 경로는 C:\Users\yong\AppData\Local\Programs\Python\Python310입니다. 이곳에 파이썬 실행 파일이 있을 것입니다. dir python* 파이썬으로 스크립트 실행 파이썬이 설치된 폴더를 잘 찾아오셨으면 아래와 같이 명령을 내려주세요. python \wikidocs-chobo-python\ch01\triangle.py 이 명령은 '파이썬아, \wikidocs-chobo-python\ch01 폴더에 있는 triangle.py를 실행하자꾸나'라는 뜻이랍니다. 그러면 파이썬 인터프리터가 이 프로그램 전체를 번역하면서 실행시켜 줄 거예요. 직각삼각형 그리기 변의 길이: 4 * * * * * * * * * 넓이: 8.0 만약 여기에서 그냥 python이라고만 입력하면 어디서 많이 본 것이 나타날 겁니다. 바로 대화식 인터프리터죠. 프로그램 파일의 실행이 잘 안되는 분은 예제와 자신이 직접 짠 프로그램을 잘 비교해서 잘못된 부분이 있는지 잘 찾아보세요. 연습할 때 실수하는 부분이 많을수록 공부에 더 많은 도움이 된답니다. 자, 이렇게 해서 인터프리터를 사용해서 프로그램 파일을 실행시키는 방법도 알아보았습니다. 마지막으로 알려 드릴 것은, 이 파일을 그냥 더블클릭해도 실행된다는 사실… 하지만 더블 클릭이 항상 편한 방법이 아니라는 것은 금방 알게 되실 거예요. 그럼 좋은 꿈 꾸세요~. 점프 투 파이썬 - 사용자 입력과 출력도 읽어보세요 거북이 Python 터틀 그래픽스를 사용해 여러 가지 도형 그리기: https://youtu.be/ZEV3pGTdlxw 1.6.1 연습 문제: 제곱 문제 사용자에게 정수를 입력받아, 그 수의 제곱을 계산해 출력하는 파이썬 스크립트를 작성하세요. 예 1 입력: 출력: 예 2 입력: 출력: 25 코드: ch01/square.py 2. 제어 구조 프로그래밍의 핵심적인 요소인 분기와 반복을 파이썬에서는 어떻게 사용하는지 살펴볼게요. 이 장에서 배우는 것: while을 사용하는 반복문 조건문(if-elif-else) for를 사용하는 반복문 2.1 while을 사용하는 반복문 강의 영상 https://youtu.be/j_NPpCNsfIM 오늘은 한석봉 이야기를 해보겠습니다. 큰 뜻을 품고 어머니를 떠나 숫자 공부를 하던 석봉은 어머니가 너무 그리워 집을 찾아갔지요. 돌아온 석봉을 본 어머니는 말씀하셨습니다. "나는 떡을 썰 테니, 너는 글을 쓰거라." 불을 끈 어머니는 떡을 썰기 시작합니다. 어머니는 내일 아침에 아들에게 떡국을 끓여주려고 기다란 떡을 써셨던 것 같습니다. 그동안에 석봉은 지금까지 연마한 실력을 총동원하여 1부터 10까지 숫자를 씁니다. 1, 2, 3, … 이 상황을 파이썬으로 만들려면 어떻게 하는 것이 좋을까요? 지금까지 배웠던 것만 가지고 해볼까요? >>> print(1) >>> print(2) >>> print(3) >>> 좀 귀찮기는 해도 쓸만하지요? 그런데, 어머니께서 1부터 100까지 써보라고 하십니다. 아, 막막합니다. 어느 세월에 다 씁니까. 100까지 쓰면 아침이 밝아오겠군요. 이럴 땐 다른 방법을 찾아야겠지요? 오늘 그 비밀을 알려 드리려고 합니다. 바로 while이라는 녀석입니다. while 문 1, 2, 3, …, 98, 99, 100 1부터 100까지는 저런 모양이 될 텐데요, 가만 보면 다음에 나오는 숫자는 앞의 숫자보다 1이 더 큽니다. 다시 말하면 앞의 숫자에 1을 더하면 다음 숫자가 나온다는 것이지요. 그러니까 계속 앞의 숫자에 1을 더해나가다가 100까지 쓰고 그만두면 되는 겁니다. 다음을 잘 보세요. >>> num = 1 >>> while num <= 100: ... print(num) ... num = num + 1 ... 우리가 쓸 숫자를 num이라고 했고, 여기에 1을 넣어주었습니다. 이해가 잘 안되시는 분은 변수 강좌를 다시 한번 보세요. 그다음에 while이라는 것이 나오죠? while은 우리말로 '…하는 동안에'라는 뜻을 갖고 있죠? 여기서는 'num이 100보다 작거나 같은 동안에'라는 뜻으로 쓴 것입니다. 아직 알쏭달쏭하시죠? 일단 다음 문장으로 넘어가 보도록 하겠습니다. print(num) # 처음 네 칸을 띄어 써주세요 num이라는 변수에 들어있는 수를 화면에 뿌려달라는 것입니다. 지금까지의 강좌 내용을 이해하셨다면 이해하실 겁니다. 지금 num에는 1이 들어있으니 당근 1을 찍어주겠지요. while 블록 내부에 있다는 표시로 공백 네 칸을 써서 들여쓰기 해주세요. 그다음 문장을 봅시다. 변숫값 증가 num = num + 1 # 위 줄과 들여 쓰기를 맞춰주세요 이번엔 진짜로 이상한 것이 나왔습니다. num이 1이라면 1 = 1 + 1이 된다는 얼토당토않은 소리군요. 그런데 프로그래밍에서 = 표시는 '같다'라는 뜻 말고 다른 뜻을 갖고 있습니다. 제 시계가 백만 원이라는 것을 어떻게 표현했지요? 그렇죠, watch = 1000000입니다. 이것은 watch라는 변수에 1000000이라는 값을 넣어주라는 뜻이었습니다. 조금 전에 num = num + 1이라고 쓴 것은 num이라는 변수가 가진 값에 1을 더해서 다시 num에게 넣어주라는 의미입니다. 그래도 이해가 안 되신다면 다른 걸 보여드리도록 하지요. >>> a = 3 >>> b = a + 2 위의 문장을 보세요. b의 값이 얼마가 되었을까요? 이제 이해가 가시겠죠? tip num = num + 1 대신 num += 1로 써도 똑같은 일을 한답니다. while 문 수행 과정 자, 설명을 드리다 보니 이야기가 잠시 딴 데로 샜습니다. 보시기 편하도록 앞의 while 문 예제를 다시 한번 써볼게요. >>> num = 1 >>> while num <= 100: ... print(num) ... num = num + 1 ... while은 어떤 조건이 만족되는 동안 그 아래에 쓴 문장들을 반복하는 기능을 갖고 있습니다. 여기서는 num이 100이 될 때까지 print(num)과 num = num + 1을 반복하는 것이지요. 제가 반복을 해보겠습니다. 처음엔 num 값이 1이니까 100보다 작습니다. 그렇다면 그다음 문장을 수행해야겠지요? print(num)이니까 화면에 1을 찍고 num = num + 1 해서 num은 2가 됩니다. 그러고는 다시 위의 while로 돌아가지요. 그러면 num 값이 2이므로 print(num)이 2를 찍고 num = num + 1 해서 num은 3이 됩니다. 그다음엔 num 값이 3이므로 print(num)이 3을 찍고 num = num + 1 해서 num은 4가 됩니다. 그다음엔 num 값이 4이므로 print(num)이 4를 찍고 num = num + 1 해서 num은 5가 됩니다. 헉헉 헉… 그다음엔, … 헉헉 헉… 그렇게 하다 보면 언젠가는 num 값이 99까지 올라갑니다. 이번에도 100보다는 작으니까 또 99 찍고, num은 드디어 100 되지요. 이제 또다시 while 문으로 갑니다. while 다음에 뭐라고 쓰여있죠? num <= 100: 그렇습니다. num이 100보다 작거나 같을 때 조건을 만족하는 겁니다. 그러면 하던 일을 계속해야겠죠? print(num) 하면 화면에 100을 찍고 num = num + 1 해서 num에는 101이 들어갑니다. 그다음에 while을 만나면 이번엔 num이 100보다 크니까 그다음의 문장을 수행하지 않고 끝이 나고야 맙니다. 썰렁~. 우리는 머리를 약간 굴리고 프로그램 네 줄만 치면 1부터 100까지가 아니라 백만, 천만, 억까지도 숫자를 쓸 수 있는 것입니다. 놀랍지 않습니까, 여러분? 믿기지 않으신다고요? 그럼 한 번 따라 해 보실까요? while 문 실습 먼저 파이썬 프로그램을 띄우고, 처음 두 문장을 쳐보세요. while 문 마지막에 콜론(:)이 꼭 들어가야 하니 빼먹지 마시고요. >>> num = 1 >>> while num <= 100: ... 둘째 줄까지 치면 다음 줄에 점 세 개가 자동으로 나타납니다. while 문은 여러 줄로 구성되기 때문에 다음 줄을 계속 입력하라는 뜻으로 나타나는 것이지요. 그럼 다음 줄을 입력하겠습니다. 점 세 개 뒤에 바로 쓰지 마시고 공백 키 네 번, 또는 Tab 키를 한 번 눌러서 간격을 띄운 다음에 명령을 입력하세요. 파이썬에서는 여러 줄로 이루어진 명령을 입력할 때 둘째 줄부터는 반드시 들여 쓰기를 해줘야 하니까요. ... print(num) ... num = num + 1 ... 그렇게 셋째, 넷째 줄까지 치고 ... 이 나오면 Enter를 한 번 더 눌러주세요. 그러면 더 이상 입력할 것이 없다는 것으로 알고 while 문이 끝나게 됩니다. 제대로 따라 하셨다면 순식간에 1부터 100까지 화면에 나타날 겁니다. 그리하여 석봉은 100까지 숫자를 쓰고 그리운 어머니 품에서 편안히 잠들 수 있게 되었다는 말씀. 2.1.1 연습 문제: 입력받은 숫자만큼 반복하기(while) 문제 input()으로 사용자로부터 정수를 한 개 입력받아, 그 숫자를 숫자 크기만큼 반복해서 출력하는 파이썬 스크립트를 작성하세요. 이때 출력 앞에 공백을 한 칸 주어서, 입력과 출력이 구분되게 합니다. 단, while 문을 사용하세요. 예 1 입력: 출력: 3 3 3 예 2 입력: 출력: 5 5 5 5 5 코드: ch02/repeat_while.py 2.1.2 연습 문제: 제곱표(while) 문제 정수를 한 개 입력받아, 1부터 입력받은 수까지 각각에 대해 제곱을 구해 프린트하는 프로그램을 작성해 보세요. 단, while 문을 사용하세요. 1 예 1 입력: 출력: 1 1 2 4 3 9 예 2 입력: 출력: 1 1 2 4 3 9 4 16 5 25 코드: ch02/square_table.py C 프로그래밍: 현대적 접근에 소개된 내용으로 문제를 만들어 봤어요. ↩ 2.1.3 연습 문제: 얌체공 문제 고무공을 100 미터 높이에서 떨어뜨리는데, 이 공은 땅에 닿을 때마다 원래 높이의 3/5 만큼 튀어 오릅니다. 공이 열 번 튈 동안, 그때마다 공의 높이를 계산합니다. 1 1 60.0 2 36.0 3 21.599999999999998 4 12.959999999999999 5 7.775999999999999 6 4.6655999999999995 7 2.7993599999999996 8 1.6796159999999998 9 1.0077695999999998 10 0.6046617599999998 round() 함수를 사용해서, 다음과 같이 소수점 아래 네 자리까지 출력해 보세요. 1 60.0 2 36.0 3 21.6 4 12.96 5 7.776 6 4.6656 7 2.7994 8 1.6796 9 1.0078 10 0.6047 tip round()는 다음과 같이 반올림을 해주는 함수입니다. >>> round(1.23456, 2) # 1.23456을 소수점 둘째 자리로(셋째 자리에서) 반올림 1.23 >>> round(1.23456, 3) # 1.23456을 소수점 셋째 자리로(넷째 자리에서) 반올림 1.235 참고로, round(2.675, 2)를 수행하면 결과가 2.68이 아닌 2.67로 나오는데, 이것은 버그가 아니라 부동소수점(floating point) 연산의 한계입니다. >>> round(2.675, 2) 2.67 이 문제의 해답은 아래 주소에 있습니다. 코드: ch02/ball.py 답을 보지 말고 직접 풀어 보는 것이 좋겠죠! (파이썬 2를 사용하시는 분은 해답 코드에서 3/5를 3.0/5.0으로 바꿔서 해 보세요) 제가 번역한 <실용 파이썬 프로그래밍>에 실린 문제가 재미있어서 가져온 것입니다. ↩ 2.1.4 연습 문제: 코드를 보고 실행 결과 맞히기 문제 다음 코드 1을 읽고, 실행 결과를 알아맞혀 보세요. number = 358 rem = rev = 0 while number >= 1: rem = number % 10 rev = rev * 10 + rem number = number // 10 print(rev) 풀이 직접 실행해서 예상한 결과가 나왔는지 확인해 보세요. 코드: http://bit.ly/3peNrR2 풀이 영상: https://youtu.be/OAxEFA44jU4 edx.org의 Linux Basics: The Command Line Interface에 나오는 연습 문제의 C 언어 코드를 파이썬으로 옮긴 것입니다. ↩ 2.2 조건문(if-elif-else) 지금까지 저와 함께 파이썬을 알아가면서 어떤 생각이 드셨나요? 너무 쉽다는 분도 계실 테고, 이런 것들 배워서 어디에 써먹는 건지 궁금한 분도 계실 것 같네요. 이 강의는 프로그래밍을 전혀 모르는 분을 위해 최대한 쉽게 쓰려고 했기 때문에 다른 언어를 접해보신 분에게는 지루할 것 같네요. 그런 분이라면 아마 여기까지 읽기 전에 다른 사이트를 찾아가셨겠죠? 또, 파이썬을 배워서 어디에 써먹느냐고 하신다면… 프로그램 만드는 데 쓰지요. 웹사이트를 구축하는 데도 씁니다. 지금 배우는 것과 같은 하찮은 것들이 모여서 엄청난 프로그램도 만들어 내는 것이지요. 조그만 레고 블록들이 모여서 큰 모형을 이루는 것과 같습니다. 차근차근 공부해가다 보면 점점 더 복잡한 프로그램을 만드실 수 있을 거예요. 그럼 또 새로운 것을 배워 볼까요? 이번엔 if 문입니다. If는 '만약 …이면'이라는 뜻이지요? 파이썬에서도 같은 의미로 사용됩니다. "달면 삼키고 쓰면 뱉는다."라는 속담이 있지요. 그것을 파이썬에서는 쓰는 것과 비슷하게 써보겠습니다. 만약 달다면: 삼킨다. 그렇지 않으면: 뱉는다. 이번엔 영어를 조금 섞어서 써볼까요? if 달다면: 삼킨다. else: 뱉는다. 위에 든 예들은 설명을 위해서 써 본 것인데, 그대로 작성하면 파이썬이 이해를 못 합니다. 파이썬의 if와 else 그럼 이번엔 실습을 해보겠습니다. 아래의 두 수 a와 b 중에 어느 쪽이 더 클까요? >>> a = 1234 * 4 >>> b = 13456 / 2 if 문을 사용해서 a가 크면 'a'를 출력하고 b가 크면 'b'를 출력하도록 프로그램을 작성해 볼까요? 한번 따라서 쳐보세요. >>> if a > b: # 만약 a가 b보다 크면 ... print('a') # 'a'를 출력한다. ... else: # 그렇지 않으면 ... print('b') # 'b'를 출력한다. ... # 이후에 있는 것들은 주석(설명)이므로 입력하지 않아도 됩니다. a > b라고 쓴 것은 ‘a가 b보다 큰가?’를 나타냅니다. 어렵지 않죠? elif 조건을 여러 개 주는 것도 가능합니다. 이번엔 c와 d를 비교해 보겠습니다. >>> c = 15 * 5 >>> d = 15 + 15 + 15 + 15 + 15 >>> if c > d: ... print('c is greater than d') ... elif c == d: ... print('c is equal to d') ... elif c < d: ... print('c is less than d') ... else: ... print('I don\'t know') ... c is equal to d 이렇게 elif라는 것을 사용하면 여러 개의 조건을 검사해서 그중에서 맘에 드는 것을 고를 수 있답니다. == 연산자 여기서 새로운 것이 또 있는데, 바로 ==(등호 두 개)입니다. ==는 지금까지 알고 있던 =(등호 한 개)와는 쓰임새가 다르니 혼동하지 않도록 주의하세요. c == d라고 쓰면 'c와 d의 값이 같은가?'를 나타냅니다. 지금처럼 두 값을 비교할 때 사용하지요. 지금까지 등호 하나를 써서 c = d라고 쓴 것은 d의 값을 c에 넣으라는 뜻이었고요. >>> watch = 1000000 기억나시죠? 이제 그 둘을 구별하실 수 있겠죠? if 문 입력<NAME>상 https://youtu.be/pspPgQJ6CFE 나머지 계산을 이용하는 if 문 어떤 수를 다른 수로 나눈 나머지가 0이면 ‘나누어떨어진다’라고 합니다. 예를 들어, 48을 4로 나눈 나머지는 0이므로, 48은 4로 나누어떨어집니다. >>> 48 % 4 어떤 수 a가 다른 수 b로 나누어떨어지는지를 파이썬의 if 문으로 다음과 같이 평가할 수 있습니다. >>> a = 48 >>> b = 4 >>> if a % b == 0: ... print(f'{a}는 {b}로 나누어떨어집니다.') ... elif a % b != 0: ... print(f'{a}는 {b}로 나누어떨어지지 않습니다.') ... 48는 4로 나누어떨어집니다. 위의 예에서 elif a % b != 0: 대신 else:라고 해도 결과는 같겠죠? 조건에 따라 반복문 중단하기 어릴 때는 큰 수를 잘 이해하지 못하죠? 하나부터 열까지밖에 모르는 아이처럼, 10보다 큰 숫자가 들어오면 멈추는 반복문을 작성해 볼까요? # filename: ten.py max = 10 while True: num = int(input()) if num > max: print(num, 'is too big!') break 이와 같이 반복문에서 break를 사용하면 빠져나올 수 있답니다. 입력: 6 12 출력: 12 is too big! 오늘의 강의는 여기까지입니다. 강의는 이해가 된다고 해서 그냥 훑어보지 마시고 꼭 예제를 따라서 쳐보시기 바랍니다. 그리고 그것과 비슷한 프로그램을 스스로 만들어 보세요. '백타가 불여일작'이라는 말도 있거든요. 백 번 따라 해보는 것보다 한 번 직접 만들어 보는 것이 낫다 끝… 2.2.1 연습 문제: 숫자 읽기(1~3) 문제 input()을 사용해 사용자로부터 입력받은 숫자를 한글로 출력하는 프로그램을 작성하세요. 단, 사용자는 1 이상 3 이하의 정수 중 하나를 입력한다고 가정합니다. 예 1 입력: 출력: 예 2 입력: 출력: 답 코드: ch02/korean_1_to_3.py 2.2.2 연습 문제: 나이에 따른 세대 구분 (1) 문제 input()으로 사용자의 나이를 입력받은 후, 다음 표의 어느 세대에 속하는지 출력하세요. 입출력 문구는 자유롭게 지으면 됩니다. 출생 연도 세대 1 ~1924 가장 위대한 세대(The Greatest Generation) 1925~1945 침묵 세대(The Silent Generation) 1946~1964 베이비붐 세대(baby boomer) 1965~1980 X세대(Generation X) 1981~1996 밀레니얼(millennial) 1997~ Z세대(Generation Z) $ python3 generations1.py What year were you born? 1945 You're the Silent Generation. $ python3 generations1.py What year were you born? 1946 You're a baby boomer. $ python3 generations1.py What year were you born? 1964 You're a baby boomer. $ python3 generations1.py What year were you born? 1965 You're a Gen X. 코드: ch02/generations1.py 〈 American Generations Fast Facts 〉, CNN ↩ 2.2.3 연습 문제: 단위 기호 길이, 부피, 무게나 금액을 표기할 때 1000을 ‘k’로 표기하곤 합니다. 예를 들어, 3000m는 3km로 표기하는 것이 일반적입니다. 다음은 입력받은 숫자가 1000보다 크면 1자리부터 100자리까지의 숫자를 생략하고 ‘k’를 붙여주는 파이썬 코드입니다. 파일명은 affix.py로 하겠습니다. 1 num = int(input()) 2 result = str(num) 3 4 if num >= 1000: 5 result = str(num // 1000) + 'k' 6 elif num >= 0: 7 pass 8 9 print(result) 10 코드 설명: 1번째 줄: 입력받은 문자열을 정수(int)로 바꿨습니다. 나중에 숫자끼리 비교할 때 쓰려고 그렇게 한 것입니다. 2번째 줄: if 문의 계산 결과를 담을 변수를 result라는 이름으로 만들었습니다. 4~5번째 줄: 숫자가 1000 이상인지 검사해서 결괏값(result)을 만듭니다. 1~100자리 숫자를 생략하려고 정수의 나눗셈(//)을 이용했습니다. 6~7번째 줄: 숫자가 (1000보다 작고) 0 이상이면 아무 일도 하지 않습니다(pass). 9번째 줄: result를 출력합니다. 실행 명령 프롬프트나 터미널에서 python affix.pyEnter를 입력하고, 1000Enter를 입력하면 1k가 출력됩니다. >python affix.py 1000 1k 문제 1. 백만 이상의 숫자를 입력받았을 때 1~10만 자리 숫자를 생략하고 ‘M’을 붙여서 출력하게 코드를 수정해 보세요. >python affix.py 1000000 1M 2. 성공했다면, 그 이상도 구현해 보세요(10의 승수 단위 참조). >python affix.py 1000000000 1G ... 풀이 ch02/affix.py 2.2.4 연습 문제: 양수만 덧셈하기 문제 input()으로 사용자로부터 입력받은 정수를 계속 더해나가다가, 음수가 입력되면 중단하고 그전까지 계산한 값을 출력하는 파이썬 스크립트를 작성하세요. 입력: 2 -1 출력: 예 2 입력: 50 60 70 -100 출력: 180 코드: ch02/sum_positive.py 2.2.5 연습 문제: 윤년 판별하기 문제 윤년은 역법을 실제 태양년에 맞추기 위해 여분의 하루 또는 월을 끼우는 해입니다. 현재 사용하는 그레고리력의 윤년 규칙은 다음과 같습니다. 서력기원 연수가 4로 나누어떨어지는 해는 윤년으로 한다. (1988년, 1992년, 1996년, 2004년, 2008년, 2012년, 2016년, 2020년, 2024년, 2028년, 2032년, 2036년, 2040년, 2044년 ...) 서력기원 연수가 4, 100으로 나누어떨어지는 해는 평년으로 한다. (1900년, 2100년, 2200년, 2300년, 2500년...) 서력기원 연수가 4, 100, 400으로 나누어떨어지는 해는 윤년으로 둔다. (2000년, 2400년...) 출처: 위키백과 이 규칙을 나타내는 흐름도를 그려보았습니다. 1 이 규칙에 따라, 연도를 나타내는 정수를 입력으로 받아서 윤년인지 아닌지 출력하는 프로그램을 작성해 보세요. 코드: ch02/leap_year.py 코드: 제가 풀이한<NAME>상을 유튜브에 올려 두었으니 참고하세요. https://youtu.be/PZlyWHAvDCQ 참고 제가 푼 것보다 좀 더 나은 풀이를 보내주신 독자가 있어서 테스팅에서 소개했습니다. 파이썬에는 주어진 해가 윤년인지 판별하는 함수가 있으므로 우리가 직접 구현하지 않아도 됩니다. 모듈 사용법 알아내기 연습 문제를 통해 알아봅니다. Flowgorithm을 사용해서 그렸습니다. Flowgorithm에 대해 더 알고 싶은 분은 《흐름대로 프로그래밍하는 Flowgorithm 》을 참고하세요. ↩ 2.2.6 and/or 연산자 이번에는 조건문에서 많이 쓰이는 and와 or 연산자를 알아볼게요. if 문에 and/or를 사용 if 문에 and, or를 사용할 수 있습니다. 예를 들어 보겠습니다. 다음과 같이 문자열 s가 있다고 할 때, >>> s = 'banana' 다음과 같이 중첩된 if 문은, >>> if 'a' in s: ... if 'b' in 'banana': ... print('banana에는 a도 있고 b도 있어요!') ... banana에는 a도 있고 b도 있어요! and를 써서 다음과 같이 바꿀 수 있습니다. >>> if 'a' in s and 'b' in s: ... print('banana에는 a도 있고 b도 있어요!') ... banana에는 a도 있고 b도 있어요! 중첩되었던 if 문을 if 한 번으로 줄였습니다. 여기서 퀴즈! and 대신 or를 써서, ‘banana에는 a 또는 c가 있어요!’라고 출력하는 문장을 만들어 보세요. if 문 없이 and/or만 사용 사실, and와 or는 반드시 if 문에 들어가야만 하는 것은 아니고, 다음과 같이 and 또는 or를 단독으로 사용해도 된답니다. >>> 'a' in s True >>> 'b' in s True >>> 'c' in s False 이러한 True/False 값을 불(bool)이라고 하는데, 불값을 변수에 넣을 수도 있습니다. >>> a_in_s = 'a' in s >>> a_in_s True and/or 연산 순서 파이썬에서는 and/or의 왼쪽 항을 먼저 평가(계산) 하고, 오른쪽 항은 필요할 때만 평가합니다(대부분의 고급 언어에서 이렇게 합니다). 예를 들어볼게요. a와 b 값이 다음과 같을 때, >>> a = 3 >>> b = 0 b 값이 0이므로 b를 분모로 하여 나눗셈을 하면 다음과 같이 ZeroDivisionError가 발생합니다. >>> a / b Traceback (most recent call last): File "<stdin>", line 1, in <module> ZeroDivisionError: division by zero 그런데 이 나눗셈 계산을 아래처럼 and의 오른쪽 항에 넣으면 오류가 생기지 않습니다. >>> (a * b) > 0 and (a / b) > 0 False 파이썬이 ‘왼쪽 항을 평가해 보니, 오른쪽 항은 평가할 필요가 없겠구나’ 하고 넘어가 버린 것이죠. 위문장의 순서를 바꿔서 나눗셈을 먼저 시켜보면 ZeroDivisionError가 발생하는 것을 볼 수 있습니다. >>> (a / b) > 0 and (a * b) > 0 Traceback (most recent call last): File "<stdin>", line 1, in <module> ZeroDivisionError: division by zero 2.2.7 연습 문제: 나이에 따른 세대 구분 (2) 문제 미국과 달리, 우리나라에서는 보통 1955~1963년생을 ‘베이비붐 세대’로 봅니다. 1 사용자가 한국인인지에 따라 세대를 구분할 수 있게 프로그램을 고쳐 보세요. (문제를 단순화하기 위해, 산업화 세대와 386 세대 2는 고려하지 않습니다. 그리고 사용자는 미국인 또는 한국인이라고 가정합니다.) $ python3 generations2.py What year were you born? 1954 Are you Korean?(y/n) y You're the Silent Generation. $ python3 generations2.py What year were you born? 1954 Are you Korean?(y/n) n You're a baby boomer. $ python3 generations2.py What year were you born? 1955 You're a baby boomer. $ python3 generations2.py What year were you born? 1963 You're a baby boomer. $ python3 generations2.py What year were you born? 1964 Are you Korean?(y/n) n You're a baby boomer. $ python3 generations2.py What year were you born? 1964 Are you Korean?(y/n) y You're a Gen X. tip 문자열의 lower() 메서드는 영문 대문자를 소문자로 바꾼 값을 돌려줍니다. >>> 'Yes'.lower() 'yes' 문자열 뒤에 [0]을 붙이면 문자열의 첫 번째 글자를 얻을 수 있습니다. >>> 'Yes'.lower()[0] 'y' 풀이 저도 문제 만들고 풀면서 좀 헷갈렸는데요, 조건을 따지기 복잡할 땐 아래와 같이 표를 먼저 만들고 나서 조건 논리(conditional logic)를 세우면 좋습니다. 저는 코드를 이렇게 작성했습니다. 코드: ch02/generations2.py 침묵 세대와 베이비붐 세대를 판정하는 코드에 국적을 묻는 부분을 추가했습니다. 베이비붐 세대 확인 코드를 설명드리면, ① 1963년생까지는 미국인과 한국인 모두 베이비붐 세대이므로 국적을 묻지 않아도 되고, ② 1964년생이면서 ③ 미국인일 경우(한국인이 아닐 경우) ④ 베이비붐 세대입니다. elif y <= 1963 or ( # ① y <= 1964 and # ② input("Are you Korean?(y/n) ").lower()[0] != 'y' # ③ ): gen = 'a baby boomer' # ④ 참고로 파이썬에서 A or B 형태의 조건을 평가할 때는, A를 먼저 평가해서 A가 참이면 B를 평가하지 않습니다. 왜냐하면 A가 참이면, B가 참인지 아닌지에 관계없이 결과가 참이므로, B를 평가할 필요가 없기 때문입니다. 그리고 ③에서 != 대신 ==를 사용하려면 미국인이냐고 물으면 됩니다. 사실 이렇게 헷갈리는 조건문을 만들면 버그가 생기기 쉽고 디버깅도 어려워서 추천하는 방식은 아니지만, 때로는 불가피하게 복잡한 조건을 따져야 할 때도 있으므로 그러한 연습을 할 수 있게 출제한 것입니다. 출생 연도를 먼저 묻고 국적은 필요할 때만 물어보게 하려다 보니 복잡해졌는데, 저처럼 하지 않고 국적을 먼저 묻고 나서 출생 연도를 물으면 조건문이 단순해져서 이해하기 쉬울 거예요. 〈당사자도 헷갈리는 베이비붐 세대 기준…생물학에 사회·역사 혼합 때문〉, 브라보 마이 라이프 ↩ 〈산업화세대→베이비부머→X세대→밀레니얼세대→Z세대…세대별로 성장 배경과 소비 패턴·가치관이 모두 다르죠~〉, 생글생글 ↩ 2.3 for를 사용하는 반복문 강의 영상: https://youtu.be/TdFn4dnERHk 이번엔 for 문에 대해서 알아볼 차례입니다. 파이썬에서 for 문의 쓰임새는 다른 언어와 차이가 있다고 하네요. 저도 그걸 모르고 한참 글을 쓰다 보니 뭔가 이상하다는 것을 발견했습니다. ^^; for 문은 우리가 전에 배웠던 리스트와 같은 시퀀스(sequence)를 이용해서 원하는 명령을 반복할 때 쓰입니다. 시퀀스에 대해서는 나중에 자세하게 알려드리기로 하고, 전에 배웠던 리스트를 다시 한번 볼까요? >>> family = ['mother', 'father', 'gentleman', 'sexy lady'] 저희 가족이 이랬었는데 기억나시지요? 그냥 따라 치지 마시고 여러분의 가족을 나타내는 리스트를 만들어 보세요. for 문 다음은 for 문을 이용해서 저희 가족들의 이름과 문자열 길이를 출력하는 프로그램입니다. >>> for x in family: # family의 각 항목 x에 대하여: ... print(x, len(x)) # x와 x의 길이를 출력하라. ... 답은 아래와 같이 나오게 되지요. mother 6 father 6 gentleman 9 sexy lady 9 in family for x:라고 쓰면 안 되냐고요? 안 되네요. --; 문법이 그런 거니까 그대로 써주시면 됩니다. range() 이번엔 range()라는 것을 배워보도록 하지요. range는 범위라는 뜻인데 여기서는 어떤 정수를 인자로 주면 그 범위 안의 정수들을 만들어줍니다. 말은 좀 어렵지만 별거 아니랍니다. >>> list(range(2, 7)) # 파이썬 3 >>> range(2, 7) # 파이썬 2 이렇게 쳐 보세요. 어떤 답이 나오나요? [2, 3, 4, 5, 6] 예, 2 이상 7 미만인 숫자로 리스트를 만들어 주었군요. 위에서 설명한 말이 이해되시죠? 그런데, for를 설명하다가 갑자기 웬 range()가 나오는 걸까요? 그렇습니다. for 문에 range()를 사용할 수 있습니다. >>> a = [4, 5, 6, 7] >>> for i in a: ... print(i) ... 위의 리스트를 사용한 예제와 아래의 range()를 사용한 예제는 출력이 같습니다. >>> for i in range(4, 8): ... print(i) ... 답이 어떻게 나올까요? 따라서 치시기 전에 먼저 생각을 해보세요. 그리 어렵지 않죠? 프로그래밍은 아무리 쉬운 것도 직접 해보지 않으면 자기 것으로 만들기 힘들답니다. 또, 생각 없이 책만 보고 따라 한다고 해서 빨리 늘지도 않습니다. 배우는 과정을 즐기면서 차근차근 연습하다 보면 실력이 늘게 된답니다. 거북이 Python 터틀 그래픽스와 반복문을 함께 사용하기 https://youtu.be/WHRrp-t3a64 2.3.1 연습 문제: 입력받은 숫자만큼 반복하기(for) 문제 2.1.1 연습 문제와 같이, 사용자로부터 input()으로 정수를 한 개 입력받아, 그 숫자를 숫자 크기만큼 반복해서 출력하는 파이썬 스크립트를 작성하세요. 이때 출력 앞에 공백을 한 칸 주어서, 입력과 출력이 구분되게 합니다. 단, 이번에는 for 문을 사용하세요. 예 1 입력: 출력: 3 3 3 예 2 입력: 출력: 5 5 5 5 5 코드: ch02/repeat_for.py 2.3.2 연습 문제: 제곱표(for) 문제 연습 문제 2.2와 같이, 정수를 한 개 입력받아 1부터 입력받은 수까지 각각에 대해 제곱을 구해 프린트하는 프로그램을 작성해 보세요. 단, 이번에는 for 문을 사용하세요. 예 1 입력: 출력: 1 1 2 4 3 9 예 2 입력: 출력: 1 1 2 4 3 9 4 16 5 25 코드: ch02/square_table_for.py 2.3.3 연습 문제: 화학 실험실 문제 1 대학교의 화학자들은 상처를 매우 빠르게 치료하는 약물을 제조하는 새로운 과정을 개발했다. 제조 과정은 매우 길고 화학 약품을 매번 모니터링해야 하므로 몇 시간씩 걸린다! 학생들은 졸거나 딴짓을 하므로 이 일을 믿고 맡길 수가 없다. 그러므로 약물의 제조를 모니터링하는 자동 장치를 프로그래밍해야 한다. 장치는 15초마다 온도를 측정해 프로그램에 제공한다. 프로그램은 먼저 최소와 최대의 안전 온도를 나타내는 두 개의 정수를 읽는다. 그다음에, 장치가 제공하는 온도(정수)를 계속 읽는다. 화학 반응이 완료되면 장치는 끝을 알리는 -999를 보낸다. 기록된 온도가 올바른 범위에 있을 경우(최솟값 또는 최댓값과 같아도 된다) Nothing to report를 표시해야 한다. 하지만 온도가 위험 수준에 도달하면 Alert!를 표시하고 온도 측정을 중단한다(장치가 온도값을 계속 보내더라도). 예 1 입력: 10 20 15 10 20 0 15 -999 출력: Nothing to report Nothing to report Nothing to report Alert! 예 2 입력: 0 100 15 50 75 -999 출력: Nothing to report Nothing to report Nothing to report tip split() 메서드를 사용해 문자열을 분할한 리스트를 얻을 수 있습니다. >>> '0 100'.split() ['0', '100'] 다음과 같이 split()으로 얻은 결과를 바로 변수에 할당할 수 있습니다. >>> freezing_point, boiling_point = '0 100'.split() >>> freezing_point '0' >>> boiling_point '100' input()으로 문자열을 입력받을 때에도, 문자열을 분할했을 때 리스트 원소가 몇 개가 될지 미리 정해져 있다면 위와 같은 방법으로 변수에 할당할 수 있습니다. 원소 개수를 미리 알 수 없다면 for 문을 이용하세요. 저는 온도를 여러 번 측정한 값이 한 번에 입력되는 것이 아니라, 아래 그림처럼 측정할 때마다 따로 들어온다고 가정하고 풀었습니다. 코드: ch02/chemical_lab.py 아래 주소의 풀이도 참고하세요. https://pybo.kr/pybo/question/detail/80/ edX의 C Programming: Language Foundations 코스에 나온 문제입니다. ↩ 2.4 match-case 문 파이썬을 배우기 전에 다른 프로그래밍 언어를 배운 적이 있다면 switch-case 문법을 접하셨을 텐데요, 파이썬에는 그러한 구문이 없다가 파이썬 3.10에 match-case 구문이 추가됐습니다. match-case는 switch-case와 비슷하기도 하지만 좀 더 강력한 기능이 있습니다. 홀수, 짝수 판별 우선 간단한 예부터 들어볼게요. 다음 코드는 1부터 10까지의 정수에 대해, 각각이 홀수인지 짝수인지를 출력합니다. for n in range(1, 11): match n % 2: case 0: print(f"{n} is even.") case 1: print(f"{n} is odd.") n을 2로 나눈 나머지가 0이면 짝수(even number), 1이면 홀수(odd number)라고 출력하는 것이죠. 결과: $ python odd_even.py 1 is odd. 2 is even. 3 is odd. 4 is even. 5 is odd. 6 is even. 7 is odd. 8 is even. 9 is odd. 10 is even. 여기까지만 보면 switch-case와 별반 다를 것이 없다고 생각하실 수 있는데요, 여기서 끝이 아닙니다. match-case 문을 잘 활용하면 상당히 간결하게 코딩할 수 있답니다. 피즈 버즈 match-case를 이용해 피즈 버즈(FizzBuzz) 문제를 풀어보겠습니다. 피즈 버즈가 무엇인지 모르시는 분은 아래 링크한 글을 잠시 보고 오시기 바랍니다. if-else 문으로 직접 풀어보시면 더 좋습니다. https://wikidocs.net/168132 그럼, match-case를 이용한 피즈 버즈 풀이 코드를 소개합니다. for n in range(1, 101): match (n % 3, n % 5): case (0, 0): print("FizzBuzz") case (0, _): print("Fizz") case (_, 0): print("Buzz") case _: print(n) 여기서 match (n % 3, n % 5)라는 구문을 보실 수 있는데, 소괄호로 둘러싸인 부분은 4장에서 배울 튜플입니다. 튜플에 관해서는 나중에 배우기로 하고, 일단은 괄호 안에 n % 3과 n % 5라는 두 개의 식이 있고, 그 아래의 case에서 각각을 평가한다고 생각하시면 됩니다. case (0, 0):은 “n을 3으로 나눈 나머지도 0이고, 5로 나눈 나머지도 0인 경우”를 가리킵니다. 따라서 ‘FizzBuzz’를 출력합니다. case 문에서 밑줄(_)은 아무 값이나 상관없다는 뜻입니다. 즉 case (0, _):은 “n을 3으로 나눈 나머지가 0인 경우”입니다. 따라서 ‘Fizz’를 출력합니다. 마찬가지로 case (_, 0):는 n을 5로 나누어떨어지는 경우이고, ‘Buzz’를 출력합니다. case _:는 그 밖의 모든 경우입니다. 3으로도, 5로도 나누어떨어지지 않는 숫자들이 이에 해당합니다. 위 코드를 실행한 결과는 다음과 같습니다. $ python fizzbuzz.py 2 Fizz Buzz Fizz 8 Fizz Buzz 11 (이하 생략) 참고 《만들면서 배우는 러스트 프로그래밍》에서 Rust의 match-case 문을 사용한 FizzBuzz 예제를 참고했습니다. 2.5 for-else와 while-else 조건문에 else를 쓸 수 있다는 건 앞에서 살펴봤는데요, 파이썬에서는 반복문에도 else를 쓸 수 있답니다. for-else 다음 for 문에서는 리스트의 원소를 차례대로 출력하고 나서, 모두 출력했다는 메시지를 출력합니다. >>> for x in [1, 2, 3, 4]: ... print(x) ... else: ... print("리스트의 원소를 모두 출력했어요") ... 2 4 리스트의 원소를 모두 출력했어요 위의 코드만 보면, 마지막 출력을 굳이 else 블록에 넣지 않고 반복문 바깥에 두어도 될 것 같죠? 하지만 아래처럼 break가 등장하면 얘기가 달라집니다. >>> for x in [1, 2, 3, 4]: ... if x % 3: ... print(x) # x가 3의 배수가 아니면 출력 ... else: ... break # x가 3의 배수이면 반복문에서 빠져나감 ... else: ... print("리스트의 원소를 모두 출력했어요") ... 2 여기서는 반복문을 break 했는데, 그럴 때는 else 블록이 실행되지 않습니다. while-else while 문도 마찬가지입니다. while 문이 break될 경우에는 else 블록이 실행되지 않습니다. >>> countdown = 5 >>> while countdown > 0: ... print(countdown) ... countdown -= 1 ... if input() == '중단': ... break ... else: ... print('발사!') ... 4 중단 3. 함수 비슷비슷한 코드를 반복해서 작성하기 귀찮으신가요? 함수를 이용하면 반복적인 코드를 줄이면서, 코드를 사용하기 좋게 정리할 수 있어요. 이 장에서 배우는 것: 함수 반환 문 지역변수, 전역변수 람다 3.1 함수 지금까지는 코드를 한 줄, 한 줄 입력해서 결과를 보긴 했지만, 컴퓨터에게 일을 시키는 건지, 우리가 일을 하는 건지 헷갈릴 정도로 귀찮으셨을 거예요. 오늘 배우실 함수를 아시고 나면 프로그래밍이 좀 더 즐거워지지 않을까 싶네요. 그럼 시작해 볼까요? [1, 2, 3, 4, 5]라는 리스트가 있다고 해볼게요. 이 리스트에는 원소가 몇 개 있을까요? 예, 5개입니다. 이번엔 [3, 4, 62, 27, 83, 956, 26, 58, 3, 78, 168, 64, 78]이라는 리스트가 있다고 칩시다. 에구구… 원소가 너무 많으니까 a_list라는 이름을 붙여놓도록 하죠. >>> a_list = [3, 4, 62, 27, 83, 956, 26, 58, 3, 78, 168, 64, 78] 이 리스트엔 원소가 몇 개 있을까요? 여기서 공부를 열심히 하셨던 분은 뭔가 생각이 나실 법도 한데… len()이라는 것, 기억나세요? 아하, len()은 리스트에 들어있는 원소 개수, 그러니까 리스트의 크기를 알려주죠. 이 len()이 바로 '함수'였던 것이랍니다. 아래의 예처럼 len() 함수를 쓰면 아무 리스트나 쉽게 크기를 알아볼 수 있죠. >>> len([1, 2, 3, 4, 5]) >>> len(a_list) 13 만약 len() 함수가 없었다면, 우리는 리스트의 크기를 알고 싶을 때마다 복잡한 프로그램을 작성해야 했을지도 몰라요. 함수가 있기 때문에 우리는 프로그래밍을 좀 더 쉽게 할 수가 있는 것이지요. 함수는 len()처럼 처음부터 파이썬에서 제공해 주는 것도 있고, 우리가 필요로 하는 것을 직접 만들어 쓸 수도 있답니다. 또는 다른 누군가가 만든 함수를 얻어서 쓸 수도 있겠지요. 저는 처음에 함수라는 것을 배울 때 매우 어렵게 생각해서 애를 먹었는데, 사실은 이렇게 프로그래밍을 도와주는 고마운 존재라는 것을 나중에야 알게 되었답니다. 그렇다면 이번엔 함수를 직접 만들어 보면 어떨까요? 지난 강좌에서 리스트에 들어있는 원소를 차례대로 출력했던 것 기억나시죠? 그것과 같은 기능을 하는 함수를 한번 만들어보도록 하지요. 같이 따라 해보세요. >>> def print_list(a): # 지금부터 print_list 함수를 만들겠다는 뜻 ... for i in a: ... print(i) ... 방금 우리는 print_list()라는 함수를 만들었습니다. 간단하지요? 첫째 줄은 함수의 이름을 지어주는 부분이고요, 괄호 안의 a는 매개변수라고 합니다. 함수를 사용할 때는 print_list([1, 2])와 같은 형태로 쓰면 된다는 것을 나타내지요. 이때 [1, 2]라는 리스트를 함수에 넣어주면 함수 내부에서는 a = [1, 2]라고 생각하고 일을 하게 되고요. 둘째 줄부터는 어제 해본 것과 똑같죠. a라는 리스트의 원소를 차례대로 출력하는 명령입니다. 우리가 만든 함수가 제대로 동작을 하는지 테스트를 해봅시다. 아까 만들어 둔 a_list에 들어있는 원소들을 찍어볼까요? >>> print_list(a_list) 함수를 제대로 만드셨다면 리스트에 들어있는 원소들이 주르륵 나열됩니다. 어떻습니까? 제법 쓸만하죠? 방금 만들어 본 함수에서는 매개변수를 받아서 일을 했었죠? 하지만 아래처럼 매개변수가 없는 함수도 만들 수 있답니다. >>> def boy(): ... print('I am a boy.') ... print('You are a girl.') ... 자, 이번엔 여러분이 직접 만들어볼 차례입니다. a와 b 가운데 a가 크면 'a > b'라고 표시하고, b가 크면 'a < b', 두 숫자가 같으면 'a == b'라고 표시하는 함수를 만들어 보세요. 이 함수는 매개변수 두 개를 필요로 합니다. 함수를 만들 때 괄호 안에 (x, y)와 같은<NAME>으로 해주면 되겠죠? 답 다 가르쳐 드렸네요.^^ 거북이 정사각형을 그리는 함수, 정삼각형을 그리는 함수: https://youtu.be/C6n_b7M7eFI 다각형을 그리는 함수: https://youtu.be/h5bUrCQyom4 3.1.1 연습 문제: 자릿수를 구하는 함수 만들기 example.com처럼 우리가 보통 ‘홈페이지 주소’라고 부르는 URL이 IP 주소로 변환된다는 것을 알고 계시나요? 주소를 192.0.2.10과 같이 나타내는 IPv4에서는 2564개의 주소를 만들 수 있다고 해요. >>> 256 ** 4 4294967296 그러니까⋯ 이게 몇 개냐면⋯ >>> len(str(_)) # 방금 구한 답(_)을 문자열(str)로 바꾼 것의 길이(len) 10 10자리 수이니까 4 뒤에 0이 9개 붙었다고 하면, 43억 개 정도 되네요. 참고 2564는 232와 같습니다. >>> 256 ** 4 == (2 ** 8) ** 4 == 2 ** 32 True 요즘은 인터넷에 접속하는 기기가 너무 많다 보니 주소가 얼마 남지 않아서, 아주아주아주 많은 주소를 만들 수 있는 IPv6로 바꿔 가고 있다고 합니다. IPv6 주소는 2001:0db8:85a3:0000:0000:8a2e:0370:7334처럼 생겼고 2128개의 주소를 만들 수 있습니다. >>> 2 ** 128 340282366920938463463374607431768211456 >>> len(str(_)) 39 39자리 숫자네요. 전 세계 인구를 80억 명이라고 가정하면, >>> 2 ** 128 / 8000_000_000 4.253529586511731e+28 1인당 4양(穰) 개씩 쓸 수 있다는 계산이 나옵니다.1 문제 양(陽)의 정수를 입력받아, 그 수가 몇 자리 숫자인지 출력하는 함수 numOfDigits()를 만들어 보세요. >>> numOfDigits(12345) >>> numOfDigits(1234567890) 10 풀이 코드: ch03/numdigits.py 큰 숫자를 읽는 법은 https://ko.wikipedia.org/wiki/큰_수의_이름에 나오는 표의 ‘이만체진’ 열을 참고하세요. ↩ 3.1.2 연습 문제: 구구단 짜잔~! 반갑습니다. 여러분~. 제 강좌를 찾아주셔서 정말 기뻐요. 게시판에 올리시는 글을 보는 것이 낙이랍니다. 전 요즘 학교 시험공부랑 과제물, 회사일로 조금 바쁘답니다(마음만 바쁘지 TV 보고, 잠 잘 자고, 딴짓도 많이 한답니다^^;). 오늘은 구구단을 준비했습니다. 구구단은 어느 언어든 프로그래밍 배울 때 빠지지 않는 약방의 감초입니다. 저는 초등학교 2학년 때 그네 타면서 구구단을 외웠던 기억이 나는데, 지금은 몇 학년 때 배우는지 궁금하군요. 저는 왠지 8단이 어렵더군요. 어머니는 뭐가 어렵냐고 하셨지만… 그래서 산수 시간에 곱셈 문제를 풀 때는 가능하면 덧셈으로 바꿔서 풀곤 했지요. 문제 다음 예와 같이 구구단을 2단부터 9단까지 계산해서 출력하는 프로그램을 짜보세요. 지금까지 배운 내용만 제대로 이해하시면 충분히 하실 수 있답니다. 출력: 2 * 1 = 2 2 * 2 = 4 … 9 * 9 = 81 힌트 음, 힘드십니까… 모르겠다고 하는 분이 정상입니다… 할 수 있다고 하는 분은 아마 예전에 비슷한 것을 배웠거나 머리가 좋은 분일 거예요. 그럼 정상인을 위해서 힌트를 드리겠습니다. 사실 힌트랄 건 없고요, 전체를 한 번에 만들기 힘들면 조금씩 나눠서 해보시라는 겁니다. 우선 2단만 똑같이 만들어보세요. 이 강좌는 더 이상 보지 마시고 지금까지 배웠던 것을 참고해서 만들어 보세요. 풀이 한번 해보셨나요? 해보신 분은 제가 짠 것과 비교해 보세요. 2 곱하기 1을 출력 우선 2 곱하기 1부터 출력해 보겠습니다. 단수를 변수 m으로, 곱하는 수를 n으로 하겠습니다. >>> m = 2 >>> n = 1 >>> print(m, '*', n, '=', m*n) 2 * 1 = 2 print() 함수에는 변수 m, 문자열 '*', 변수 n, 문자열 '=', 그다음에 m*n이라는 식을 쉼표로 구분해 차례로 넣어줬습니다. print() 함수의 인자가 너무 많아 타자 치기도 번거롭고 눈에 잘 들어오지 않으므로 다음과 같이 f-문자열을 사용하는 것이 낫겠네요. f-문자열은 파이썬 3.6 이상에서 사용할 수 있습니다. >>> print(f'{m} * {n} = {m*n}') 2 * 1 = 2 2단을 출력 다음은 구구단의 2단을 출력하는 코드입니다. >>> m = 2 >>> for n in range(1, 10): ... print(f'{m} * {n} = {m*n:2d}') ... 2 * 1 = 2 2 * 2 = 4 2 * 3 = 6 2 * 4 = 8 2 * 5 = 10 2 * 6 = 12 2 * 7 = 14 2 * 8 = 16 2 * 9 = 18 변수 m 값은 아까처럼 숫자 2로 했지만, 변수 n은 for 문과 range() 함수를 이용해 값을 증가시켜가면서 2단을 출력하게 했습니다. print 문에서는 m과 n을 곱한 결과의 자릿수를 맞추려고 f-문자열의 세 번째 중괄호에 2d를 지정했습니다. 한 단을 계산하는 함수 이번엔 한 단을 계산하는 함수를 만들어 보려고 합니다. 함수의 인자로 2를 넣으면 2단을 출력하고, 5를 넣으면 5단을 출력하는 거죠. >>> def multi(m): ... for n in range(1, 10): ... print(f'{m} * {n} = {m*n:2d}') 아까 거랑 거의 비슷한데 코드를 전부 함수에 집어넣었죠? 그래도 훨씬 폼 납니다. 한번 돌려보세요. 3단 나와라 뚝딱! >>> multi(3) 3 * 1 = 3 3 * 2 = 6 3 * 3 = 9 3 * 4 = 12 3 * 5 = 15 3 * 6 = 18 3 * 7 = 21 3 * 8 = 24 3 * 9 = 27 결과를 확인해 보셨나요? 쓸 만하죠? 구구단 전체 이제 처음 문제도 풀 수 있을 것 같지 않나요? 위에서 만든 함수를 이용해 2단부터 9단까지 출력하면 되겠죠? 잘 되셨나요? 축하합니다. 사실 지금과 같은 경우에 굳이 함수를 만들 필요는 없었지요. 함수를 이용하지 않고 반복문 안에 또 반복문을 집어넣어도 된답니다. 함수에 대해 복습도 할 겸 이해하기 쉽도록 만든 것이지요. 반복문을 중첩하는 방법은 직접 해 보시면 좋겠습니다. 제가 코드를 보여드리지 않아도 잘 하시리라고 생각합니다. 그럼 모두 즐거운 하루 보내시고요, 저는 다음 이 시간에… 코드 코드: ch03/multiplication_table.py Flowgorithm으로 작성한 구구단 흐름도: https://wikidocs.net/167057 3.2 반환(return) 문 여러분, 함수가 무엇일까요? 지금까지 머리 아프게 함수를 공부했는데 또 무슨 소리냐고요? 물론 함수에 대해 계속 배워왔지만, 결정적으로 빠진 내용이 하나 있습니다. 사실은 우리가 초등학교 때부터 배워왔던 것이기도 합니다. 과연 그것이 무엇일까요? 이 그림 낯익으시죠? 함수에 x를 집어넣으면 함수가 주물럭주물럭 계산해서 y라는 값을 돌려주는 그림입니다. 함수에 값을 넣으면 함수는 계산된 값을 돌려준다. 이것이 바로 함수의 핵심이지요. 프로그래밍에서도 마찬가지입니다. 지금까지 우리가 만든 함수들은 일은 열심히 하지만 돌려주는 것은 없었지요. 그렇다면 이젠 일도 하고 결과를 돌려주기도 하는 함수를 만들어 봐야겠죠? >>> def f1(x): ... a = 3 ... b = 5 ... y = a * x + b ... return y # y 값을 반환한다 ... >>> c = f1(10) # c = 35 >>> print(c) 35 위의 그림과 같은 역할을 하는 함수 f1()을 만들어봤습니다. 값을 돌려주기 위해 return이라는 것이 쓰였지요? 이렇게 만들어진 함수에 10이라는 인자를 넣어주면 함수는 35라는 값을 돌려줍니다. 따라서, 그 값을 다시 c라는 변수에 넣을 수도 있는 거죠. 만약, 함수를 정의할 때 return y 대신에 print(y)라고 썼다면 어떻게 될까요? >>> def f2(x): ... a = 3 ... b = 5 ... y = a * x + b ... print(y) # y 값을 출력한다 ... >>> d = f2(10) # d = ? 35 >>> print(d) None d = f2(10)이라고 하면 f2() 함수가 실행되어 35가 화면에 나타나지만 d에게 값을 반환하지는 않죠. 그래서 d를 프린트해 보면 아무 값이 없다는 뜻으로 None이 출력됩니다. 어떠세요? 이제 함수가 값을 반환하는 것에 대해서 이해가 되시나요? 그렇다면 값을 반환하는 함수를 직접 만들어 보실 차례입니다. 삼각형의 넓이를 구하는 함수를 만들어보세요. 함수의 인자로는 삼각형의 밑변과 높이가 주어지고, 반환(return) 값은 삼각형의 넓이가 되는 겁니다. 간단하겠죠? 문제를 풀어보신 분께는 신기한 것을 하나 알려드리겠습니다. 아직 안 풀어보셨으면 빨리해보세요. 다 풀어보셨죠? 그럼, 알려드리도록 하겠습니다. 참과 거짓 1 더하기 1은 2 맞죠? '참', '거짓'으로 대답해 보세요. '참'이라고 대답하셨나요? 그럼 파이썬은 이 질문에 어떻게 대답할까요? >>> 1 + 1 == 2 True 참이라고 답을 하네요. >>> 1 + 1 == 3 False 이건 거짓이라고 하고요. 다음의 if 문을 보세요. 1 + 1이 2가 맞으면 'yes'라고 대답하고, 그렇지 않으면 'no'라고 대답하겠죠? >>> if 1 + 1 == 2: ... print('yes') ... else: ... print('no') ... yes 방금 알려드린 것과 함께 생각해 보면 1 + 1 == 2라는 식이 True(참)이면 yes를, False(거짓)이면 no를 프린트한다는 걸 알 수 있습니다. 우리가 함수를 만들 때 이런 성질을 활용하면 도움이 되겠죠? 쉬운 덧셈 문제를 내는 함수를 만들어 보겠습니다. >>> def quiz(): ... ans = input('1 + 2 = ') ... return 1 + 2 == int(ans) ... input()이라는 함수는 사용자로부터 문자열 입력을 받는데 쓰이고요, int() 함수는 문자열을 정수로 바꿔줍니다. 예제에서는 input() 함수가 1 + 2 =이라는 문자열을 출력한 다음 사용자로부터 문자열을 입력받아 그 값을 ans라는 변수에 넣어줬습니다. 셋째 줄에서는 1 + 2의 값과 int(ans)의 값이 같은지를 나타내는 True나 False로 반환하겠죠? 답을 맞히면 True를 돌려주고, 틀리면 False를 돌려주는 것이죠. 이해가 되시는지요? 위에서 만든 퀴즈를 다음과 같이 풀어볼 수 있습니다. >>> quiz() 1 + 2 = 3 True >>> quiz() 1 + 2 = 4 False 한번 테스트해 보세요. 재미있죠? 우리가 배워온 것들이 점점 그럴듯하게 모양을 갖춰가는 것 같네요. 오늘은 여기까지~ 수고하셨습니다~ 3.2.1 연습 문제: 숫자 읽기 함수(1~10) 문제 매개변수로 받은 정수를 한국어로 표기한 문자열을 반환하는 함수 korean_number()를 정의하세요. 단, 매개변수는 1 이상 10 이하의 정수라고 가정합니다. >>> korean_number(1) '일' >>> korean_number(3) '삼' >>> korean_number(10) '십' 코드: ch03/korean_1_to_10.py 3.2.2 연습 문제: 함수 정의하기 문제 문제 1 다음 triple() 함수를 완성하세요. >>> def triple(x): ... ██████ █ █ █ ... >>> triple(2) >>> triple('x') 'xxx' 문제 2 오늘의 날짜 객체를 구하는 코드는 다음과 같습니다. (코드를 이해하지 못해도 이 문제를 풀 수 있습니다.) >>> from datetime import datetime >>> today = datetime.today() >>> today datetime.datetime(2021, 3, 21, 15, 46, 1, 94942) 위 코드의 today에서 연도를 구하는 방법은 다음과 같습니다. >>> today.year 2021 태어난 해를 네 자리 숫자로 입력하면 한국 나이를 반환하는 함수 korean_age()를 작성하세요. 코드: ch03/define_functions.py 3.2.3 연습 문제: 이자(단리) 계산 직장인 A 씨는 1년 동안 열심히 일해서 연말에 성과급으로 천만 원을 받았습니다. 연이율 3.875%(단리)인 고정금리 상품에 예금하려고 합니다. 5년 동안 넣어두면 이자가 얼마 붙는지 계산해 보겠습니다. 첫해에 원금 10,000,000원에 대한 이자 10,000,000 * 0.03875 = 387500원이 붙습니다. 둘째 해에 원금 10,000,000원에 대한 이자 387500원이 붙습니다. 마찬가지로 셋째, 넷째, 다섯째 해에도 해마다 같은 금액의 이자가 붙습니다. 만기가 되어 받을 수 있는 이자는 다음과 같습니다. >>> 10000000 * 0.03875 * 5 1937500.0 원금과 이자를 합한 총액, 즉 원리금은 다음과 같습니다. >>> 10000000 + 10000000 * 0.03875 * 5 11937500.0 소수점 이하는 필요 없지만 지금은 그대로 둘게요. 원금(Principal), 이율(rate), 기간(time)이 주어졌을 때, 이자(Interest)를 구하는 공식은 다음과 같습니다. = r 그리고 원리금(Amount)을 구하는 공식은 다음과 같습니다. = ( + t ) 문제 문제 1 원금(p), 단리 이율(r), 기간(t)이 주어졌을 때 이자를 구하는 함수 simple_interest()를 작성하세요. 예 1 >>> simple_interest(10000000, 0.03875, 5) 1937500.0 예 2 >>> simple_interest(1100000, 0.05, 5/12) 22916.666666666668 문제 2 원금(p), 단리 이율(r), 기간(t)이 주어졌을 때 원리금을 계산하는 함수 simple_interest_amount()를 작성하세요. 예 1 >>> simple_interest_amount(10000000, 0.03875, 5) 11937500.0 예 2 >>> simple_interest_amount(1100000, 0.05, 5/12) 1122916.6666666665 코드: ch03/simpleInterest.py 구글 스프레드시트 참고 Simple Interest Calculator A = P(1 + rt), CaculatorSoup Business Math (Olivier), LibreTexts 3.2.4 연습 문제: 복리 계산 이번에는 복리(複利, compound interest)를 계산해 볼게요. 예를 들어 1,500,000원을 3개월 동안 넣어두면 연 4.3%의 이자를 주는 상품이 있다고 할 때, 만기가 될 때마다 받는 이자와 원금을 합한 금액을 재예치하여 6년간 운용했을 때 받는 총액을 계산해 보겠습니다. >>> r = 0.043 >>> n = 4 위의 r은 연이율을 나타내는 변수고, n은 1년 동안에 복리가 몇 번 적용되는지는 나타내는 변수입니다. 3개월이 4번 지나야 1년이 되는데, 이때 4가 바로 n 변숫값이 됩니다. 이렇게 하는 이유는 실제 계산을 해보면 이해할 수 있습니다. 우선 첫해만 계산해 볼게요. >>> 1500000 * (1 + r / n) # 처음 3개월 1516125.0 >>> _ * (1 + r / n) # 그다음 3개월 1532423.34375 >>> _ * (1 + r / n) # 그다음 3개월 1548896.8946953125 >>> _ * (1 + r / n) # 그다음 3개월 1565547.5363132872 이렇게 해서 처음 1년 동안의 원리금을 계산했습니다. 2년 차도 계산해 볼까요? >>> _ * (1 + r / n) 1582377.1723286551 >>> _ * (1 + r / n) 1599387.7269311883 >>> _ * (1 + r / n) 1616581.1449956987 >>> _ * (1 + r / n) 1633959.3923044025 같은 방식으로 6년 치를 계산하면, >>> _ * (1 + r / n) 1938836.8221341053 최종적으로 위 금액이 나옵니다. 한번 해보세요. 엄청 귀찮습니다. 소수점 이하가 길어서 보기 불편하지만 지금은 그대로 둘게요. 이 계산을 쉽게 하려면 다음과 같은 복리 계산 공식을 이용하면 됩니다. ′ P ( + n ) t ′ : 원리금 : 원금 : 연이율 : 기간 : 복리 횟수 앞에서 손수 계산했던 것을 이번에는 공식에 대입해 풀어보겠습니다. 변수명은 모두 소문자로 할게요. >>> p = 1500000 >>> r = 0.043 >>> t = 6 >>> n = 4 >>> p * (1 + r / n) ** (n * t) 1938836.8221341055 문제 복리 예금의 원금(p), 연이율(r), 기간(t), 복리 횟수(n)에 대한 원리금을 계산하는 함수 compound_interest_amount()를 작성하세요. 예 1 6년간 매 분기 이자를 주는 경우(t=6, n=4) >>> compound_interest_amount(1500000, 0.043, 6, 4) 1938836.8221341055 예 2 6년간 2년마다 이자를 주는 경우(t=6, n=1/2) >>> compound_interest_amount(1500000, 0.043, 6, 1/2) 1921236.0840000005 코드: ch03/compoundInterest.py 구글 스프레드시트 참고 https://en.wikipedia.org/wiki/Compound_interest 3.3 지역변수, 전역변수 여러분 안녕하세요~. 오늘(이 장을 처음 쓴 날)은 제가 중간시험 보는 날이랍니다. 시스템 프로그래밍이랑, 선형대수 과목이고요, 시스템 분석 설계 과제물도 내야 합니다. 시스템 프로그래밍은 컴퓨터의 CPU 구조랑, 어셈블리 언어, 어셈블리 언어를 해석해서 컴퓨터가 알 수 있게 기계어로 바꿔주는 어셈블러의 작동원리, 운영체제도 포함된 과목입니다. 한마디로 우리가 사용하는 프로그램과 컴퓨터 장치 사이에서 일하는 것이 시스템 프로그램이라고 할 수 있지요. 선형대수는 수학의 행렬, 벡터 같은 것에 대해 자세히 나오는데, 컴퓨터 그래픽을 구현할 때도 이런 것을 사용하더군요. 다른 여러 분야에도 응용이 되겠죠. 시스템 분석 설계는 건물을 짓기 전에 먼저 설계를 하는 것처럼 프로그램을 짤 때 전체적인 설계를 하는 것입니다. 보통 프로그래머가 되려면 자바, C, 비주얼 베이직 같은 프로그래밍 언어만 배우면 되는 것으로 생각을 하기 쉬운데, 사실 프로그래밍 언어는 한 부분에 불과하답니다. 그래서 좋은 프로그래머가 되기 위해선 많은 교육과 경험이 필요하지요. 제 강좌를 보고 계신 여러분 중에 프로그래머가 되고 싶은 분이 있다면 학교 공부(특히 영어, 수학)도 열심히 하시고, 주위의 선배들, 관련 홈페이지나 월간지를 통해서 정보를 얻는다면 도움이 되실 거예요. 오늘도 함수에 관한 이야기랍니다. 제목엔 변수라고 나와있지만요. 먼저 예제를 보실까요? 학교 다닐 때, 저희 학교 짱은 영구였습니다. 제가 전학 가기 전까지는… >>> jjang = '09' 제가 가서 바로 짱 먹었지요. 흐흐흐… >>> jjang = 'pig dad' 애들한테 물어보면 누가 최고라고 할까요? 당근… >>> jjang 'pig dad' 그런데 자기네 반에서 최고라고 깝죽거리는 녀석이 있었으니, 바로 땡칠이라는 친구였답니다. 반이라는 함수를 만들어 보죠. >>> def ban(): ... jjang = '07' ... print('jjang =', jjang) ... >>> ban() jjang = 07 그러나… 땡칠이도 제 앞에선 깨갱~이랍니다. 울 학교 짱은 변함없이 저걸랑요… >>> jjang 'pig dad' ban() 함수 안에서 jjang = '07'이라고 하면 jjang 이란 변수를 새로 만드는 거고요, 기존의 jjang에는 영향을 미치지 않습니다. 그리고, ban 함수가 끝날 땐 그 함수 내에서 만들었던 변수들은 모두 없어지는 거죠. 이와 같이 함수 안에서 만들어진 변수를 지역변수라고 하고, 함수 밖에서 만들어진 변수를 전역변수라고 합니다. 지역변수는 함수가 호출되면 만들어져서, 함수의 실행이 끝날 때 함께 없어지는 반면, 전역변수는 함수와는 관계없이 항상 꿋꿋이 지구를 지킨답니다. 그래서 영어로 전역변수를 global이라는 말로 표현하지요… 지역변수를 함수 밖에서 한번 불러볼까요? >>> def d_is_10(): ... d = 10 # 지역변수 ... print('d 값은 ', d, '입니다') ... >>> d_is_10() d 값은 10입니다 >>> d Traceback (most recent call last): File "<stdin>", line 1, in ? NameError: name 'd' is not defined d를 불러봐도 'd라는 이름이 없다'라는 에러 메시지만 뜨지요? d_is_10() 함수가 실행되는 동안은 d가 있었는데, 함수의 실행이 끝난 다음에 함께 사라져버렸기 때문입니다. 반대로, 전역변수는 함수 안에서도 얼마든지 사용할 수 있답니다. >>> x = 10 # 전역변수 >>> def printx(): ... print(x) ... >>> printx() 10 그렇다면 지역변수 대신 전역 변수만 쓰는 것이 편하겠다고요? 글쎄요… 전역변수는 프로그램이 복잡해질수록 골칫거리가 된답니다. 다른 엉뚱한 함수 때문에 변수의 값이 바뀌어버리는 수가 종종 있거든요. 그래서 필요에 따라 지역변수와 전역변수를 골라 쓰는 것이 좋답니다. 그리고, 함수 안에서 전역변수를 만드는 방법도 있답니다. 어떤 변수를 전역변수(global)로 사용하겠다고 명시해 주는 것이죠. >>> def e_is_10(): ... global e # 전역변수 ... e = 10 ... print('e 값은 ', e, '입니다') ... >>> e_is_10() e 값은 10입니다 >>> e 10 여기서는 e_is_10() 함수가 실행되면서 e라는 전역변수가 만들어지고, 이 변수는 함수의 실행이 끝난 다음에도 없어지지 않습니다. 저는 그만 시험 보러 가야겠네요. 즐거운 주말 보내세요~. 3.5 람다(lambda) 오늘은 람다<NAME>과 그것을 이용하는 여러 가지 함수들에 대해서 알아보겠습니다. 당장 완벽하게 소화하실 필요는 없을 것 같고요, 가벼운 마음으로 이런 것이 있다는 정도만 아셔도 되지 않을까 합니다. 람다<NAME>은 인공지능 분야나 AutoCAD라는 설계 프로그램에서 쓰이는 Lisp 언어에서 물려받았다고 하는데요, 함수를 딱 한 줄만으로 만들게 해주는 훌륭한 녀석입니다. 사용할 때는 아래와 같이 써주면 되지요. lambda 매개변수 : 표현식 다음은 두 수를 더하는 함수입니다. >>> def hap(x, y): ... return x + y ... >>> hap(10, 20) 30 이것을 람다<NAME>으로는 어떻게 표현할까요? >>> (lambda x, y: x + y)(10, 20) 30 너무나 간단하죠? 함수가 이름조차도 없습니다. '그냥 10 + 20이라고 하면 되지'라고 말씀하시면 미워잉~. 몇 가지 함수를 더 배워보면서 람다가 어떻게 이용되는지 알아보도록 하죠. map() 먼저 map 함수를 볼까요? map(함수, 리스트) 이 함수는 함수와 리스트를 인자로 받습니다. 그렇죠? 그리고, 리스트로부터 원소를 하나씩 꺼내서 함수를 적용시킨 다음, 그 결과를 새로운 리스트에 담아준답니다. 말이 좀 복잡하죠? 그럴 때 예제를 보는 게 최고죠. >>> map(lambda x: x ** 2, range(5)) # 파이썬 2 [0, 1, 4, 9, 16] >>> list(map(lambda x: x ** 2, range(5))) # 파이썬 2 및 파이썬 3 [0, 1, 4, 9, 16] 위의 map 함수가 매개변수로 받은 함수는 lambda x: x ** 2구요, 리스트로는 range(5)를 받았습니다. range 함수는 알고 계시죠? range(5)라고 써주면 [0, 1, 2, 3, 4]라는 리스트를 돌려줍니다. 그리고 x ** 2라는 것은 x 값을 제곱하라는 연산자죠. map 함수는 리스트에서 원소를 하나씩 꺼내서 함수를 적용시킨 결과를 새로운 리스트에 담아주니까, 위의 예제는 0을 제곱하고, 1을 제곱하고, 2, 3, 4를 제곱한 것을 새로운 리스트에 넣어주는 것입니다. 위의 예제를 람다가 아닌 보통의 함수로 구현하면 어떻게 될까요? reduce() 이번엔 reduce 함수를 살펴봅시다. reduce(함수, 시퀀스) 형식은 위와 같고요, 시퀀스(문자열, 리스트, 튜플)의 원소들을 누적적으로(?) 함수에 적용시킨답니다. 말이 진짜 어렵군요. 예제를 살펴보도록 하겠습니다. >>> from functools import reduce # 파이썬 3에서는 써주셔야 해요 >>> reduce(lambda x, y: x + y, [0, 1, 2, 3, 4]) 10 위의 예제는 먼저 0과 1을 더하고, 그 결과에 2를 더하고, 거기다가 3을 더하고, 또 4를 더한 값을 돌려줍니다. 한마디로 전부 다 더하라는 겁니다. 생각보다 쉽죠? 하… 하… 하… 의기양양하게 '예'라고 대답하신 분들을 위해 짜증 나는 예제를 권해드리죠~. >>> reduce(lambda x, y: y + x, 'abcde') 'edcba' 전 원래 뭐 하나를 배우면 꼭 엽기적인 실험을 해본답니다. 더 짜증 나라고 설명 안 해드릴랍니다~ filter() 그다음은 filter를 살펴볼 차례입니다. 필터가 뭐죠? 정수기에서 물을 걸러주는 것이 필터죠? 에어컨의 바람 들어가는 곳에도 필터가 달려있고요. filter(함수, 리스트) 파이썬의 필터는 이렇게 생겼는데요, 리스트에 들어있는 원소들을 함수에 적용시켜서 결과가 참인 값들로 새로운 리스트를 만들어줍니다. 다음은 0부터 9까지의 리스트 중에서 5보다 작은 것만 돌려주는 예제입니다. >>> filter(lambda x: x < 5, range(10)) # 파이썬 2 [0, 1, 2, 3, 4] >>> list(filter(lambda x: x < 5, range(10))) # 파이썬 2 및 파이썬 3 [0, 1, 2, 3, 4] lambda x: x<5라고 쓰니까 왠지 수학 책에서 본 듯한 느낌이 들지 않습니까? 수학자들이 파이썬을 좋아한다던데… 위의 예제가 어떻게 돌아가는지는 척 보면 아시겠죠? 0부터 9까지의 리스트에서 숫자를 하나씩 꺼냅니다. 그 숫자를 x라 하고, x < 5 가 '참'이면 살려줍니다. 살아남은 것들은 새로운 리스트에 넣어줍니다. 끝. 자, 이번엔 홀수만 돌려주는 filter를 만들어 보도록 합시다. 먼저 홀수가 뭔지 생각해 볼까요? 짝수는 2로 나누어떨어지는 수이고, 홀수는 2로 나누어떨어지지 않는 수입니다. 짝수를 2로 나눈 나머지는 0이고, 홀수를 2로 나누면 나머지가 1이죠. 또, 나머지를 구할 땐 %라는 연산자를 쓰면 됩니다. 예를 들어서, 50을 8로 나누면 몫은 6이고 나머지는 2니까 50 % 8은 2가 되는 거지요. 이제 홀수를 돌려주는 필터를 만들어 보겠습니다. >>> filter(lambda x: x % 2, range(10)) # 파이썬 2 [1, 3, 5, 7, 9] >>> list(filter(lambda x: x % 2, range(10))) # 파이썬 2 및 파이썬 3 [1, 3, 5, 7, 9] 지난 시간에 '참'은 1이고 '거짓'은 0이라고 했죠? 위의 filter 함수를 실행시키면, 0을 2로 나눈 나머지는 0이니까 람다 함수의 결괏값은 0이고, 0은 '거짓'이니까 버려집니다. 1을 2로 나눈 나머지는 1이니까 람다 함수의 결괏값은 1이고, 1은 '참'이니까 통과하지요. 이런 식으로 수행하면서 홀수만 돌려주게 되는 거지요. 휴~ 이번 강좌는 설명하기 힘들어서 쓰면서 한참 애먹었네요. 잘 이해되지 않는 부분이 있으면 댓글 달아주세요. 그럼 안녕~ 3.5.1 연습 문제: 놀이공원 (1) 둘리와 도우너, 마이콜이 놀이공원에 갔습니다. 놀이 기구 중에는 탑승자의 키를 제한하는 것이 있네요. 문제 놀이 기구의 이름과 키 제한을 나타낸 문자열을 입력받아서, 놀이 기구의 이름, 탑승 가능한 키의 하한(下限)과 상한(上限)을 각 행에 출력합니다. 코드는 다음과 같이 작성하며, ch03 폴더 아래에 파일명을 ridereader.py로 저장합니다. def read(text): # 이곳에 코드를 작성하세요. return ridename, cmmin, cmmax if __name__ == "__main__": ridename, cmmin, cmmax = read(input()) print("이름:", ridename) print("하한:", cmmin) print("상한:", cmmax) 입출력 예 1 입력: 와일드 윙: 110cm 이상 출력: 이름: 와일드 윙 하한: 110 상한: None 예 2 입력: 툼 오브 호러: - 출력: 이름: 툼 오브 호러 하한: None 상한: None 예 3 입력: 플라이벤처: 140cm~195cm 출력: 이름: 플라이벤처 하한: 140 상한: 195 tip 문자열의 split 메서드를 써서, 구분자(delimiter)를 기준으로 문자열을 분할할 수 있습니다. 다음 예에서는 콜론(:)을 구분자로 삼았습니다. >>> hms = "13:48:03" >>> hms.split(':') ['13', '48', '03'] str.strip으로 문자열 앞뒤의 공백을 제거할 수 있습니다. >>> str.strip(" I am a boy. ") 'I am a boy.' 그리고 replace() 메서드를 이용해 문자열 일부를 다른 문자열로 바꾼 문자열을 얻을 수 있습니다. >>> 'Python'.replace('P', 'J') 'Jython' ch03/ridereader_nolambda.py (for 문을 사용) ch03/ridereader.py (람다를 사용) 4. 데이터 타입 파이썬의 여러 가지 데이터 타입(data type)을 알아봅니다. 이 장에서 배우는 것: 자료형 문자열(str)과 리스트(list) 튜플(tuple) 딕셔너리(dict) 세트(set) 4.1 자료형 여러분 이진수에 대해서 알고 계시지요? 아마 중학교 때 배웠던 것 같네요. 아직 배우지 않은 분은 그런 것이 있다는 것만 알고 계시고요. 컴퓨터에서는 이진수가 중요합니다. 왜냐하면 컴퓨터 내부에서는 모든 정보를 이진수로 처리하기 때문이죠. 예를 들어서 65라는 숫자를 컴퓨터 내부에서는 이진수 01000001로 처리합니다. 우리가 65 + 30이라고 명령을 내리면 컴퓨터는 그것들을 모두 이진수로 바꿔서 계산을 한 다음에 그 결과를 다시 우리가 쓰는 십진수로 바꿔주는 거죠. 컴퓨터는 숫자뿐만 아니라 문자라든지, 제아무리 복잡한 정보도 모두 2진수로 처리한답니다. 컴퓨터에서 영어를 사용하기 위해서는 알파벳 한 자 한 자마다 숫자로 번호를 매겨서 처리를 하지요. 알파벳에 번호를 붙이는 규칙 중에서 널리 쓰이는 것으로 ASCII(아스키)라는 규약이 있습니다. 아스키에서는 알파벳 A를 숫자 65로 표현하는데요, 어차피 숫자 65는 다시 이진수로 바꿔서 처리하겠죠? 그렇다면 여기서 이상한 점이 생깁니다. 이진수 01000001이 있는데 컴퓨터는 이것이 숫자 65인지, 아니면 문자 A 인지 어떻게 알 수 있을까요? 너무 어렵게 생각하실 건 없답니다. 숫자인지 문자인지 표시를 해주면 되는 거죠. 사람이 해주든지, 컴퓨터가 알아서 하든지 말입니다. 그렇게 표시를 해주는 것이 바로 자료형이라고 할 수 있습니다. 지금까지 우리가 자료형에 대해서 잘 몰라도 프로그램을 짤 수 있었던 것은 우리가 자료를 만들 때마다 파이썬에서 자동으로 자료형을 정해주었기 때문인데요, 다른 프로그래밍 언어에서는 프로그래머가 직접 정해주어야 하는 경우도 있습니다. 그리고 프로그래밍 언어마다 제공해 주는 자료형에 차이가 있지요. type() 함수를 사용하면 자료형을 쉽게 확인할 수 있습니다. >>> type(6) # 정수 <type 'int'> >>> type('A') # 문자열 <type 'str'> 그렇다면 파이썬에는 어떤 자료형이 있는지 살펴볼까요? 파이썬의 자료형은 크게 숫자(numbers), 시퀀스(sequence), 매핑(mapping) 등으로 나눌 수 있습니다. 숫자 숫자를 나타내는 자료형으로는 정수(int), 부동소수점수(float), 복소수(complex)가 있습니다. int int는 정수(integer)를 나타냅니다. >>> type(100000000) # 정수 <class 'int'> 정수가 너무 길어서 읽기 힘들면 밑줄을 넣어도 돼요.(파이썬 3.6 이상) >>> 100_000_000 # 세 자리마다 100000000 >>> 1_0000_0000 # 네 자리마다 100000000 float float는 원래 부동소수점수(floating-point number)를 가리키는데, 지금은 단순히 소수점 이하를 표현할 수 있는 수라고 생각하셔도 좋습니다. >>> type(2.8) # 부동소수점수 <type 'float'> 1장에서 봤듯이, int끼리 연산한 결과가 float로 나오기도 해요. >>> 5 / 3 1.6666666666666667 complex 그리고 고등학교에서 배우는 복소수를 complex로 나타냅니다. >>> type(3+4j) # 복소수 <type 'complex'> 프로그래밍 언어에 복소수라는 자료형이 있는 것은 파이썬에서 처음 봤네요. 제곱하면 -1이 되는 수를 ‘허수(imaginary number)’라고 하죠. 2 − 파이썬에서는 허수를 j로 나타냅니다. >>> (1j) ** 2 (-1+0j) 고등학생 이상 언니들을 위해 한 가지 예를 보여드리면, 복소수의 거듭제곱 ( + ) 10 을 손으로 계산하는 과정은 이렇게 됩니다.1 ( + ) = + i i = i ( + ) 10 { ( + ) } = ( i ) = 5 i = 32 ( 2 ) i 32 파이썬에서는 이렇게 할 수 있어요. >>> (1 + 1j) ** 10 32j 시퀀스 문자열(str), 리스트(list), 튜플(tuple), 사용자 정의 클래스가 시퀀스에 속합니다. >>> type("Love your Enemies, for they tell you your Faults.") <class 'str'> >>> type(['love', 'enemy', 'fault']) <class 'list'> >>> type(('love', 'enemy', 'fault')) <class 'tuple'> for 문에서 사용할 수 있는 것들이 바로 시퀀스입니다. 문자열이 시퀀스에 속하네요. 여러 개의 문자를 한 줄로 세워뒀으니 그럴 법도 하겠죠? 튜플과 사용자 정의 클래스에 대해서는 뒤에서 설명드리지요. 매핑 딕셔너리(dict)는 키(key)와 값(value)의 짝으로 이뤄집니다. 이런 것을 매핑이라고 합니다. >>> type({'one': 1, 'two': 2, 'three': 3}) <class 'dict'> 참, 거짓을 표현하는 불(bool)도 있습니다. >>> type(False) <class 'bool'> >>> type(3 >= 1) <class 'bool'> >>> type(True == 'True') <class 'bool'> 세트 집합을 표현하는 세트(set)도 있습니다. >>> fruits = {'apple', 'banana', 'orange'} 세트는 원소의 순서가 유지되지 않고 중복 원소를 갖지 않는 ‘집합’으로서의 특징이 있으며, 집합 연산을 사용할 수 있습니다. 강좌가 횟수를 거듭할수록 머리가 복잡해지네요. 제가 혼자 공부했으면 흐지부지할 때가 된 거지요. 그러나 여러분이 지켜보고 계신 한 포기는 없습니다. 제가 바로 이런 점을 노리고 혼자 공부하지 않고 굳이 강좌를 올리는 것입니다. 흐흐흐... 그러니 여러분도 힘내세요. 우리 함께 파이썬 정복하는 그날까지~ 김동식, ⟪알기 쉽게 풀어쓴 기초 공학수학⟫, 2022, 생능출판 ↩ 4.2 문자열과 리스트 문자열과 리스트를 좀 더 자세히 알아봅시다. 문자열 문자열에서는 요런 식으로 한 글자마다 번호를 매긴답니다. 문자열을 만들어서 이것저것 시켜보세요. >>> x = 'banana' >>> x[0] # 0번 글자는? 'b' >>> x[2:4] # 2번부터 4번 앞(3번)까지는? 'na' >>> x[:3] # 처음부터 3번 앞(2번)까지는? 'ban' >>> x[3:] # 3번부터 끝까지는? 'ana' 이렇게 문자열의 각 글자 위치(인덱스)를 이용해서 문자열을 써는 방법을 슬라이싱(slicing)이라고 합니다. 이에 관해서는 ‘슬라이싱’에서 좀 더 알아볼게요. 그런데 banana를 nanana로 바꿀 수는 있을까요? >>> x[0] = 'n' 위와 같이 하면… 될까요? 안 됩니다. 아래처럼 TypeError라는 오류가 나죠. Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'str' object does not support item assignment 이렇듯, 문자열에 들어있는 글자는 바꿀 수가 없답니다. 아래처럼 할 수는 있지만, >>> x = 'n' + x[1:] >>> x 'nanana' 이건 문자열 x의 'b'를 'n'으로 바꾼 것이 아니라, 'n'과 'anana'를 합친 새로운 문자열 'nanana'에 x라는 이름을 붙인 것입니다. 문자열에 어떤 글자가 몇 번째 자리에 있는지 알고 싶을 때는 find()를 사용하면 됩니다. >>> s = "hello Python!" >>> s.find('P') 'P'가 6번 인덱스에 있다는 것을 알았으니, 다음과 같이 슬라이싱해서 다른 변수로 저장할 수도 있겠죠? >>> s[0:6] 'hello ' >>> h = s[0:6] >>> h 'hello ' 위의 h 변수의 끝에는 공백이 포함되었는데, 다음과 같이 슬라이싱을 하거나 rstrip()으로 제거할 수 있습니다. >>> h[0:5] 'hello' >>> h.rstrip() 'hello' 또는 다음과 같이 주어진 문자열을 분할한 리스트를 생성하는 split()을 이용해 첫 번째 단어를 알아내는 방법도 있습니다. >>> s.split() ['hello', 'Python!'] >>> s.split()[0] 'hello' 리스트 이번엔 리스트를 살펴보도록 하겠습니다. 원소를 추가하는 것부터 해볼까요? >>> prime = [3, 7, 11] # 3, 7, 11을 원소로 갖는 리스트 prime을 만듦 >>> prime.append(5) # prime에 원소 5를 추가 >>> prime [3, 7, 11, 5] sort 함수를 사용하면 정렬을 간단하게 할 수 있고요. >>> prime.sort() # prime을 원소 크기 순으로 정렬 >>> prime [3, 5, 7, 11] 아차, 2를 빠뜨렸네요. 맨 앞(0번)에 2를 삽입(insert) 하겠습니다. >>> prime.insert(0, 2) >>> prime [2, 3, 5, 7, 11] 원소를 삭제하는 것도 되지요. 4번 원소를 삭제해 보겠습니다. >>> del prime[4] # prime의 4번 원소를 삭제 >>> prime [2, 3, 5, 7] 원소를 삭제할 때 pop()을 사용할 수도 있습니다. pop()은 리스트에서 삭제한 원소를 반환(return) 하므로 변수로 받아서 나중에 사용할 수도 있죠. >>> a = prime.pop() # 삭제한 원소를 a 변수로 받음 >>> prime [2, 3, 5] >>> a 다음과 같이 리스트의 원소에 새로운 값을 지정할 수도 있습니다. >>> prime[0] = 1 >>> prime [1, 3, 5] 리스트에 리스트를 집어넣을 수도 있지요. 피자가게에서 주문할 음식 리스트를 볼까요? >>> orders = ['potato', ['pizza', 'Coke', 'salad'], 'hamburger'] >>> orders[1] ['pizza', 'Coke', 'salad'] >>> orders[1][2] 'salad' 마찬가지로 리스트를 사용해서 간단히 행렬을 표현할 수도 있습니다. 행렬은 아마 고등학교 때 배우죠? >>> matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] 문자열을 리스트로 바꾸기 지금까지 문자열과 리스트를 따로따로 알아봤는데요, 이번엔 둘 다 갖고 놀아봅시다. 문자열을 리스트로 바꿔보도록 하죠. >>> characters = [] >>> sentence = 'Be happy!' >>> for char in sentence: ... characters.append(char) ... >>> print(characters) ['B', 'e', ' ', 'h', 'a', 'p', 'p', 'y', '!'] 처음에 characters라는, 비어있는 리스트를 만들었습니다. 그리고, sentence라는 변수를 만들어서 Be happy!라는 문자열을 가리키도록 했지요. 전에 for 문을 배울 때에는 리스트를 이용해서 이터레이션을 수행하였는데, 이번에는 문자열을 이용해 보았습니다. 여기선 sentence가 가리키는 Be happy!의 글자 하나하나에 대해서 어떤 일을 수행하게 되죠. 첫 번째 글자인 B를 characters라는 리스트의 첫 번째 원소로 넣고, 두 번째 글자인 e를 characters의 두 번째 원소로 넣는 식입니다. 사실은 아래처럼 문자열을 바로 리스트로 변환해도 같은 결과를 얻을 수 있답니다. >>> list('Be happy!') ['B', 'e', ' ', 'h', 'a', 'p', 'p', 'y', '!'] 숫자를 문자열로 바꾸기 정수(int) 123을 가리키는 my_int 변수가 있다고 합시다. >>> my_int = 123 >>> type(my_int) <class 'int'> 문자열 '123'을 얻고 싶다면 다음과 같이 할 수 있습니다. >>> str(my_int) '123' 위 출력 결과를 보시면 작은따옴표가 붙어 있습니다. 타입을 확인해 보면 더 정확히 알 수 있죠. >>> type(str(my_int)) <class 'str'> 이렇게 얻은 문자열을 다음과 같이 변수에 할당하는 것도 가능합니다. >>> my_str = str(my_int) 엄밀히 말하자면 '숫자를 문자열로 바꾼' 것이라기보다는, '숫자 값을 가지고 새로운 문자열을 얻었다'라고 표현하는 것이 맞겠죠. 문자열을 숫자로 바꾸기 역으로, 숫자를 나타낸 문자열에서 숫자를 얻어낼 수도 있습니다. >>> int('123') 123 >>> float('123') 123.0 리스트 원소들의 합 구하기 1부터 10까지의 정수를 원소로 갖는 리스트 one_to_ten이 있습니다. >>> one_to_ten = list(range(1, 11)) >>> one_to_ten [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 1부터 10까지를 더한 값은 얼마일까요? for 문을 사용해서 계산할 수도 있겠지만, sum()을 이용하면 손쉽게 구할 수 있답니다. >>> sum(one_to_ten) 55 성적표 오늘의 종합 편! 우리 반 성적표를 만들어 봅시다! 학생 이름에 국, 영, 수 성적을 넣어주고, >>> chulsu = [90, 85, 70] >>> younghee = [88, 79, 92] >>> yong = [100, 100, 100] # 바로 접니다.. >>> minsu = [90, 60, 70] 우리 반 학생들을 전부 students 리스트에 넣어줍니다. >>> students = [chulsu, younghee, yong, minsu] 학생들의 성적이 어떤지 불러내볼까요? >>> for scores in students: ... print(scores) ... [90, 85, 70] [88, 79, 92] [100, 100, 100] [90, 60, 70] 개인의 성적을 더해서 총점, 평균도 내 보세요. >>> for scores in students: ... total = 0 ... for s in scores: ... total = total + s ... average = total / 3 ... print(scores, total, average) ... [90, 85, 70] 245 81.66666666666667 [88, 79, 92] 259 86.33333333333333 [100, 100, 100] 300 100.0 [90, 60, 70] 220 73.33333333333333 위에서는 총점을 구하기 위해 total이라는 변수를 사용해서 숫자를 누적시키는 방법을 써보았습니다. 그럼, 오늘 강좌 끝~. 4.2.1 슬라이싱 파이썬 프로그래밍에서 슬라이싱(slicing, 썰기) 기법이 아주 많이 쓰이니까 다시 한번 알아봅시다. 문자열 슬라이싱 아래와 같이 문자열 인덱스를 이용해 문자열의 일부를 복사할 수 있습니다. >>> p = 'Python' >>> p[0:2] 'Py' 슬라이싱할 첫 인덱스가 0일 때는 아래처럼 콜론(:) 앞의 0을 생략할 수도 있습니다. >>> p[:2] 'Py' 문자열 일부를 슬라이싱해서 다른 문자열과 붙일 수 있습니다. >>> h = 'Hello world!' >>> h[:6] + p + '!' 'Hello Python!' 음수 인덱스를 사용해 문자열의 뒷부분을 복사할 수도 있습니다. >>> h[-1:] '!' >>> h[:6] + p + h[-1:] 'Hello Python!' tip replace() 메서드를 써서 특정 단어를 다른 단어로 바꿀 수도 있어요. >>> h.replace('world', 'Python') 'Hello Python!' 다음과 같이 콤마의 앞뒤 숫자를 모두 생략하면 문자열 전부를 복사할 수 있습니다. >>> p[:] 'Python' 역순으로 복사하는 것도 가능합니다. >>> p[::-1] 'nohtyP' 리스트 슬라이싱 리스트로도 슬라이싱할 수 있어요. 위에서 설명한 것과 원리는 같습니다. 인덱스가 0부터 시작한다는 점에 유의하세요. >>> N = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] >>> N[0] # 0번(첫 번째) 원소 >>> N[0:5] # 0번부터 5번 앞(4번)까지 [1, 2, 3, 4, 5] >>> N[:5] # 처음부터 5번 앞까지 [1, 2, 3, 4, 5] >>> N[5:] # 5번부터 끝까지 [6, 7, 8, 9, 10] >>> N[-3:] # 뒤에서 3번째부터 끝까지 [8, 9, 10] >>> N[::-1] # 역순으로 [10, 9, 8, 7, 6, 5, 4, 3, 2, 1] 문자열의 리스트도 만들어서 실험해 보세요. >>> fruit = ['apple', 'banana', 'cherry', 'mango', 'orange'] >>> fruit[0:2] ['apple', 'banana'] >>> fruit[2] 'cherry' >>> fruit[2:] ['cherry', 'mango', 'orange'] 4.2.2 연습 문제: 회문 판별 함수 만들기 문제 거꾸로 배열해도 같은 단어 혹은 문장이 되는 것을 회문(palindrome)이라고 합니다. 다음은 회문의 예입니다. Anna Civic Kayak Level ... 문제 1 주어진 단어가 회문인지 판별하는 함수 palindrome()을 작성하세요. 단, 문자열 입력은 모두 소문자로 이뤄지며 공백을 포함하지 않는다고 가정합니다. >>> palindrome('anna') True >>> palindrome('banana') False 문제 2 대문자와 소문자가 섞여 있더라도 회문으로 판정하도록 함수를 개선하세요. >>> palindrome('Anna') True 문제 3 공백이 섞여 있더라도 회문으로 판정하도록 함수를 개선하세요. >>> palindrome('My gym') True tip 문자열의 lower() 메서드를 이용해 소문자만으로 이루어진 문자열을 얻을 수 있습니다. >>> 'Python'.lower() 'python' 그리고 replace() 메서드를 이용해 문자열 일부를 다른 문자열로 바꾼 문자열을 얻을 수 있습니다. >>> 'Python'.replace('P', 'J') 'Jython' 《흐름대로 프로그래밍하는 Flowgorithm 》에서 회문 판별 함수의 흐름도를 볼 수 있습니다. 다음은 파이썬으로 간단하게 작성한 코드입니다. 위의 흐름도와 어떤 차이가 있는지 비교해 보고, 코드를 개선할 수 있는지 생각해 봅시다. ch04/palindrome.py 4.2.3 연습 문제: 각 자리 숫자의 합을 구하는 함수(리스트를 이용) 문제 정수 num을 매개변수로 받아 각 자리 숫자(digit)의 합을 계산하는 sumOfDigits() 함수를 작성하세요. 단, 나눗셈을 이용하지 말고 리스트를 사용해서 풀어보세요. 예 1 입력: 643 출력(6 + 4 + 3 = 13): 13 예 2 입력: 47253 출력: 21 힌트 정수의 나눗셈과 나머지 구하는 법: 1.2 숫자 계산을 보세요. 사용자 입력을 받는 방법: 1.5. 명령 해석기를 보세요. 코드: ch04/sumOfDigits_non-recursive_list.py 4.2.4 연습 문제: 줄기와 잎 그림 중학교 1학년 수학 시간에 배우는 줄기와 잎 그림을 파이썬으로 만들어볼게요. 배운 지 오래돼서 기억이 나지 않거나 아직 배우지 않았더라도 걱정하지 않으셔도 됩니다. 칸 아카데미의 줄기와 잎 그림 수업을 들어보면 금방 이해하실 거예요. 문제 농구팀에 속한 12명의 득점을 다음과 같이 score 리스트로 나타냈습니다. >>> score = [0, 0, 2, 4, 7, 7, 9] >>> score += [11, 11, 13, 18] >>> score += [20] >>> score [0, 0, 2, 4, 7, 7, 9, 11, 11, 13, 18, 20] 다음과 같이 stem_leaf 리스트를 만들어 선수들의 득점을 줄기와 잎 그림<NAME>으로 저장하려고 합니다. >>> stem_leaf = [[], [], []] 문제 1 stem_leaf에 데이터를 채우는 프로그램을 작성하세요. 데이터가 채워진 결과는 다음과 같습니다. >>> stem_leaf [[0, 0, 2, 4, 7, 7, 9], [1, 1, 3, 8], [0]] >>> stem_leaf[0] [0, 0, 2, 4, 7, 7, 9] >>> stem_leaf[1] [1, 1, 3, 8] >>> stem_leaf[2] [0] 문제 2 stem_leaf를 다음과 같은 형태로 프린트하는 프로그램을 작성하세요. 0: [0, 0, 2, 4, 7, 7, 9] 1: [1, 1, 3, 8] 2: [0] 코드: ch04/stem_leaf.py 4.2.5 연습 문제: 각 자리 숫자의 합을 구하는 함수(map()을 이용) 문제 정수 num을 매개변수로 받아 각 자리 숫자(digit)의 합을 계산하는 sumOfDigits() 함수를 작성하세요. 단, 나눗셈을 이용하지 말고, 리스트와 map() 함수를 이용해 풀어보세요. 예 1 입력: 47253 출력: 21 예 2 입력: 643 출력: 13 코드: ch04/sumOfDigits_non-recursive_map.py 4.2.6 연습 문제: 소수 구하기 문제 소수(素數, prime number)는 1 과 그 자체만을 인수(factor)로 갖는 수입니다 1. 또는 “1보다 큰 자연수 중 1과 자기 자신만을 약수로 가지는 수”라고 설명하기도 합니다 2. 다음은 소수입니다. 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, ... 소수를 구하는 방법은 다음과 같습니다. 찾고자 하는 범위의 자연수를 나열한다. 2부터 시작하여, 2의 배수를 지워나간다. 다음 소수의 배수를 모두<NAME>다. 다음은 파이썬 셸에서 수작업으로 10 이하의 소수를 구하는 예입니다. >>> L = list(range(2, 11)) # 찾고자 하는 범위의 자연수를 나열 >>> L [2, 3, 4, 5, 6, 7, 8, 9, 10] >>> L.remove(4); L.remove(6); L.remove(8); L.remove(10) # 2의 배수를 지움 >>> L.remove(9) # 3의 배수를 지움 >>> L # 결과 [2, 3, 5, 7] 이와 같은 방식으로 찾고자 하는 범위(예: 30 이하)의 소수를 구하는 것이 문제입니다. 수작업으로 하지 말고 반복문을 사용하세요. 예 1 입력: 10 출력: [2, 3, 5, 7] 예 2 입력: 20 출력: [2, 3, 5, 7, 11, 13, 17, 19] 예 3 입력: 30 출력: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29] 첫 번째 풀이 처음에는 리스트의 remove() 메서드를 이용해 간단하게 풀고, 그 과정을 유튜브<NAME>상으로 올려두었습니다. https://youtu.be/KChXYFu2rYo 그런데 이 방법이 이해하기는 쉽지만 몇 가지 문제점이 있다는 것을 나중에 발견했습니다. 리스트를 가지고 for 루프를 수행하는 도중에 리스트의 원소를 삭제하는 바람에 모든 원소를 제대로 검사하지 않는다는 것이었습니다. 위의<NAME>상은 그 문제를 알지 못하고 찍은 것입니다. 그 문제를 해결하기 위해, 다음과 같이 리스트를 복사해서 사용하도록 수정했습니다. L2 = L[:] 아래 주소의 코드는 위의 변경사항이 반영된 것입니다. ch04/prime.py 그런데 이 코드에는 또 다른 문제점이 있습니다. 2의 배수를 모두 검사하고 나서 3의 배수를 검사할 때는 숫자 2는 확인할 필요가 없는데, 그 점을 미처 생각지 못하고 모두 검사하게 되어 있어 비효율적입니다. 두 번째 풀이 첫 번째 풀이의 문제점들을 해결한 코드를 새로 작성했습니다. for 루프 대신 while 루프를 사용해서 첫 번째 문제점을 해결했고, while 루프의 조건식을 이용해 불필요한 검사를 하지 않게 해 효율을 높였습니다. ch04/prime2.py 전보다 나아지긴 했지만, 다른 책에 실린 코드와 비교해 보니 복잡하면서 비효율적인 부분이 여전히 남아 있는 것 같습니다. 독자분들의 풀이 독자분들께서 제안해 주신 풀이입니다. 고맙습니다! 김 님의 풀이(if 절을 추가): ch04/prime_kim.py fateindestiny.dev 님의 풀이(filter를 활용): ch04/prime_fate.py aaaa 님의 풀이: ch04/prime_aaaa.py 프로그램 실행 시간 비교 여러 방법으로 구현한 코드의 성능을 프로그램 실행 시간 측정하기에서 비교합니다. 더 읽을거리 위키독스에 소수 구하기를 다룬 책들이 있습니다. 풀이 방법을 비교해 보세요. 김중운, 파이썬 계단 밟기 이연홍, 코딩으로 수학하기 Kyoungwon, 중학 수학 코딩의 정석 칸 아카데미, Prime Numbers ↩ https://ko.wikipedia.org/wiki/소수_(수론) ↩ 4.2.7 연습 문제: 진법 변환 나눗셈을 이용해 십진수를 이진수로 변환하는 방법은 다음과 같습니다. 십진수를 2로 나눈 몫을 구하고 그 수를 다시 2로 나누는 일을 몫이 0이 될 때까지 반복하고, 각 단계에서 구한 나머지를 거꾸로 쓰면 이진수가 됩니다. 예를 들어, 십진수 13에 해당하는 이진수를 구하는 과정을 아래와 같이 나타낼 수 있습니다(몫과 나머지를 한 번에 구하기 참조). >>> divmod(13, 2) # 13을 2로 나눈 몫은 6, 나머지는 1 (6, 1) >>> divmod(6, 2) # 6을 2로 나눈 몫은 3, 나머지는 0 (3, 0) >>> divmod(3, 2) # 3을 2로 나눈 몫은 1, 나머지도 1 (1, 1) >>> divmod(1, 2) # 1을 2로 나눈 몫은 0, 나머지는 1 (0, 1) 위의 각 단계에서 구한 나머지 1, 0, 1, 1을 역순으로 쓴 1101이 십진수 13에 해당하는 이진수입니다. 파이썬의 bin() 함수를 이용하면 위와 같이 번거로운 계산을 직접 하지 않고도 이진수를 쉽게 구할 수 있죠. >>> bin(13) '0b1101' 0b는 뒤의 숫자가 이진수임을 나타냅니다. 문제 십진수를 입력받아 그 숫자에 해당하는 이진수의 각 자리를 리스트로 출력하는 프로그램을 작성하세요. (순서에 유의) 예 1 입력: 13 출력: [1, 1, 0, 1] 예 2 입력: 87 출력: [1, 0, 1, 0, 1, 1, 1] 코드: ch04/dec2bin.py 4.3 튜플(tuple) 안녕하세요! 오늘 날씨가 아주 좋네요. 출근하지 말고 어디 놀러 가고 싶더라고요. 강좌를 쓰는 것이 시간이 많이 걸리고 가끔 머리 아프긴 해도 너무 재미있네요. 그래서 요즘은 틈만 나면 여기에 매달려있답니다. 오늘은 튜플이라는 자료형이 어떤 쓸모가 있는지 알아보도록 하죠. 영어의 tuple을 '튜플' 혹은 '터플'이라고 읽습니다. 리스트와 비슷한 자료형이라는 정도만 알고 시작해 봅시다. 다른 언어를 공부해 보신 분은 두 변수의 값을 서로 바꾸어 본 적이 있으실 텐데요, 보통 다음과 같은 방법을 사용합니다. >>> a = 10 >>> b = 20 >>> temp = a # a 값을 temp에 저장 (temp = 10) >>> a = b # b 값을 a에 저장 (a = 20) >>> b = temp # temp 값을 b에 저장 (b = 10) >>> print(a, b) 20 10 이렇게 두 변숫값을 맞바꾸기 위해선 또 다른 변수 temp가 필요합니다. 좀 번거롭죠? 변수가 많을수록 더 귀찮아질 테고요. 그런데 파이썬에선 이런 일을 간단하게 할 수 있는 기막힌 방법이 있습니다. >>> c = 10 >>> d = 20 >>> c, d = d, c >>> print(c, d) 20 10 너무 간단하지요? 저는 이것을 보고 웃어버렸습니다. 헬 헬 헬... 세 번째 줄에서 등호 왼쪽은 c, d라는 변수가 담긴 튜플이구요, 오른쪽은 d와 c의 값이 담긴 튜플입니다. 그래서 d의 값은 c로 들어가고, c의 값은 d로 들어갑니다. 이런 일들이 차례차례 일어나는 것이 아니고, 동시에 처리된다는군요. 이번엔 함수에서 튜플이 요긴하게 쓰이는 것을 보여드리지요. 아래의 함수는 인자(매개변수)를 주는 대로 받아먹는 함수입니다. >>> def magu_print(x, y, *rest): # 마구 찍어 함수 ... print(x, y, rest) ... >>> magu_print(1, 2, 3, 5, 6, 7, 9, 10) 1 2 (3, 5, 6, 7, 9, 10) 위 함수는 인자를 두 개 이상만 주면 나머진 다 알아서 처리한답니다. 함수를 정의할 때 인자에 별표를 붙여두면 그 이후에 들어오는 것은 모두 튜플에 집어넣는 것이죠. 위에선 (3, 5, 6, 7, 9, 10)가 하나의 튜플로 묶였습니다. 꽤 쓸만할 것 같죠? 다른 언어로 이런 함수를 만들려면 고생 꽤나 해야 할 거예요. 인자를 두 개, 세 개 넣어서도 실험해 보세요. 튜플의 좋은 점들을 구경했으니 이제 문법을 살펴봅시다. >>> t = ('a', 'b', 'c') 튜플을 만들 때는 위와 같이 괄호를 써도 되고 안 써도 됩니다. 다만, 원소가 없는 튜플을 만들 때는 괄호를 꼭 써주세요. >>> empty = () 원소를 하나만 가진 튜플을 만들 땐 원소 뒤에 콤마(,)를 꼭 찍어주시고요. >>> one = 5, >>> one (5, ) 그리고 튜플은 리스트와 달리 원소 값을 직접 바꿀 수 없기 때문에, 문자열에서 했던 것처럼 오려 붙이는 방법을 써야 한다는 것을 알아두세요. >>> p = (1,2,3) >>> q = p[:1] + (5, ) + p[2:] >>> q (1, 5, 3) >>> r = p[:1], 5, p[2:] >>> r ((1, ), 5, (3, )) 튜플을 리스트로, 리스트를 튜플로 쉽게 바꿀 수도 있답니다. >>> p = (1, 2, 3) >>> q = list(p) # 튜플 p로 리스트 q를 만듦 >>> q [1, 2, 3] >>> r = tuple(q) # 리스트 q로 튜플 r을 만듦 >>> r (1, 2, 3) 그럼, 여러분 안녕~. 4.3.1 연습 문제: 내일의 날짜 구하기(1) 문제 1 사용자로부터 날짜를 나타내는 세 개의 숫자를 입력받습니다. 첫 번째 숫자는 연도를 나타내는 네 자리 숫자이고, 두 번째 숫자는 월을, 세 번째 숫자는 일을 나타냅니다. 입력받은 날짜를 mm/dd/yyyy<NAME>으로 출력합니다. 월을 두 자리 숫자(01, 02, 03, ..., 12)로, 일을 두 자리 숫자(01, 02, 03, ..., 31)로, 연도를 네 자리 숫자로 나타냅니다. 입력받은 날짜의 다음 날에 해당하는 날짜도 같은<NAME>으로 출력합니다. 단, 윤년은 무시합니다(2월은 항상 28일까지 있다고 가정합니다). 예 1 입력: 2018 10 2 출력: 10/02/2018 10/03/2018 예 2 입력: 2018 10 31 출력: 10/31/2018 11/01/2018 예 3 입력: 2018 11 30 출력: 11/30/2018 12/01/2018 예 4 입력: 2018 12 31 출력: 12/31/2018 01/01/2019 코드: ch04/tomorrow.py edx.org의 C Programming: Advanced Data Types 강좌에 나온 연습 문제입니다. ↩ 4.4 딕셔너리(dict) 오늘 제가 여러분과 함께 공부할 것은 딕셔너리 자료형이에요. 사전을 한 번도 못 보신 분은 안 계시죠? dictionary n. pl. dictionaries A reference book containing an alphabetical list of words, … python n. Any of various nonvenomous snakes of the family Pythonidae, … 딕셔너리 자료형으로 꼭 국어사전이나 백과사전 같은 것을 만들어야 하는 건 아니지만, 기억하기 쉽도록 영어 사전을 만들어 보겠습니다. 위의 자료들을 우리가 지금까지 배운 자료형을 사용해서 저장하려면 어떤 것이 좋을까요? 저장해뒀다가 dictionary라고 치면 'A reference book 주절주절…'하고 나오고, python이라고 하면 또 '구시렁구시렁…' 하도록 말이죠. 리스트? 튜플? 물론 그런 것들을 사용해도 만들 수는 있겠지만 결국 우리가 배울 딕셔너리 자료형과 비슷한 구조를 만들게 될 듯싶네요. 딕셔너리 자료형은 아래와 같이 사용할 수 있습니다. >>> dic = {} # dic이라는 이름으로 비어있는 딕셔너리를 만든다. >>> dic['dictionary'] = '1. A reference book containing an ...' >>> dic['python'] = 'Any of various nonvenomous snakes of the ...' >>> dic['dictionary'] # dic아, 'dictionary'가 뭐니? '1. A reference book containing an ...' 처음에 dic이라는 사전을 하나 만들고, 둘째, 셋째 줄에서는 dic에다가 자료를 좀 집어넣었지요. 그리고, 마지막 줄에선 dictionary의 뜻이 뭔지 조회를 해봤습니다. 영어가 너무 많아서 겁이 나십니까? --; 프로그래머가 영어 겁내서 쓰나요. 앞으로 공부를 하면 할수록 영어의 중요성을 느끼시게 될 겁니다. 그래도 영어에 약하신 분을 위해 포켓용 사전을 만들어 볼까요? >>> smalldic = {'dictionary': 'reference', 'python': 'snake'} >>> smalldic['python'] # 포켓용 사전아, 'python'이 뭐니?? 'snake' >>> smalldic {'dictionary': 'reference', 'python': 'snake'} 좀 더 깔끔해졌죠? 유심히 보시면 아까와는 조금 다른 방법으로 딕셔너리를 만들었다는 것도 아실 수 있겠지요? 이와 같이 딕셔너리 자료형은 키(key)와 값(value)의 쌍으로 이루어진답니다. 아래의 표를 참고하세요. 키값 dictionary 주절주절... python 구시렁구시렁... zoo 동물원 문자열, 리스트, 튜플은 숫자로 된 인덱스를 이용해 값을 조회하는데, 딕셔너리는 키를 이용한다는 것이 큰 차이점이죠. 또, 딕셔너리 자료형은 해싱(hashing) 기법을 이용하기 때문에 자료가 순서대로 저장되지 않는다고 하네요. 해싱 기법이 무엇일까요? 선생님이 학생들의 시험지를 보니 만득이가 빵점을 받았다고 합시다. 그래서 만득이를 찾아서 혼내주려고 하는데, "1번, 네가 만득이니?" "아니요." "2번, 네가 만득이니?" "아니오." "3번, 네가 만득이니?" "아니오." "40번, 네가 만득이니?" "아니오." 이렇게 만득이를 찾으려면 좀 오래 걸리겠죠? 하지만, 선생님이 "만득이 나와!"라고 하시면 바로 찾을 수 있지 않겠습니까? 이 방법이 바로 해싱 기법과 비슷하다고 생각하시면 됩니다. 자료를 아주 빨리 찾을 수 있는 방법이지요. 딕셔너리 자료형을 만들고, 원소를 추가하는 방법은 위에서 보신 대로이고요, 원소를 삭제할 땐 이렇게 하시면 됩니다. >>> del smalldic['dictionary'] 삭제가 잘 되었는지 한번 확인해 보세요. 이번에는 family라는 딕셔너리를 만들어 볼게요. >>> family = {'mom': 'Kim', 'dad': 'Choi', 'baby': 'Choi'} >>> family {'mom': 'Kim', 'dad': 'Choi', 'baby': 'Choi'} family의 키들을 얻으려면 딕셔너리 이름 뒤에. keys()를 쓰면 됩니다. >>> family.keys() dict_keys(['mom', 'dad', 'baby']) family의 값들을 얻으려면 딕셔너리 이름 뒤에. values()를 쓰면 됩니다. >>> family.values() dict_values(['Kim', 'Choi', 'Choi']) family의 원소(키/값 쌍)들을 얻으려면 이름 뒤에. items()를 쓰면 됩니다. >>> family.items() dict_items([('mom', 'Kim'), ('dad', 'Choi'), ('baby', 'Choi')]) 딕셔너리에 어떤 키가 있는지 없는지는 in을 써서 알아볼 수 있습니다. 있으면 True, 없으면 False라고 대답해 주죠. >>> 'dad' in family True >>> 'sister' in family False 이런 것들을 외우려고 애쓰실 필요는 없습니다. 필요할 때마다 사용방법을 찾아서 쓰면 되는 거지요. 그럼 모두 즐거운 하루 보내세요~. 4.4.1 연습 문제: 숫자 읽기(0~9) 문제 매개변수로 입력받은 정수에 해당하는 한글 문자열을 반환하는 함수 korean_number()를 if 문을 사용하지 말고 작성하세요. 단, 사용자는 0 이상 9 이하의 정수 중 하나를 입력한다고 가정합니다. >>> korean_number(3) '삼' >>> korean_number(6) '육' >>> korean_number(9) '구' 코드: ch04/korean_0_to_9.py 4.4.2 연습 문제: 한자 성어 문제 다음 표의 한자 성어와 뜻을 모두 출력하는 파이썬 프로그램을 작성하세요. 1 한자 성어 뜻 江湖之(강호지락) 자연을 벗 삼아 누리는 즐거움 欲速不達(욕속부달) 빨리하고자 하면 이루지 못함 積小成大(적소성대) 작은 것을 쌓아 큰 것을 이룸 勤儉節約(근검절약) 부지런하고 알뜰하게 재물을 아낌 經世濟民(경세제민) 세상을 다스리고 백성을 구제함 塞翁之馬(새옹지마) 인생의 길흉화복은 변화가 많아서 예측하기가 어려움 好事多魔(호사다마) 좋은 일에는 흔히 방해되는 일이 많음 桑田碧海(상전벽해) 세상일의 변천이 심함 自業自得(자업자득) 자기가 저지른 일의 결과를 자기가 받음 因果應報(인과응보) 원인과 결과가 상응하여 보답한다 愚公移山(우공이산) 어떤 일이든 끊임없이 노력하면 반드시 이루어짐 실행 결과: Enter를 누르세요... 江湖之(강호지락) 자연을 벗 삼아 누리는 즐거움 Enter를 누르세요... 欲速不達(욕속부달) 빨리하고자 하면 이루지 못함 Enter를 누르세요... 積小成大(적소성대) 작은 것을 쌓아 큰 것을 이룸 (이하 생략) 풀이 코드: ch04/hanja_idioms.py 출처: 서울사이버대학교 ‘한자성어와 퍼즐’ 수업 ↩ 4.4.3 연습 문제: 정신 질환 문제 다음 txt는 정신질환의 명칭을 한국어와 영어 용어로 나열한 것입니다.1 txt = '''신경 발달장애 Neurodevelopmental Disorders 조현병 스펙트럼 및 기타 정신병적 장애 Schizophrenia Spectrum and Other Psychotic Disorders 양극성 및 관련 장애 Bipolar and Related Disorders 우울장애 Depressive Disorders 불안장애 Anxiety Disorder 강박 및 관련 장애 ObsessiveCompulsive and Related Disorders 외상 및 스트레스 관련 장애 Traumaand StressorRelated Disorders 해리장애 Dissociative Disorders 신체증상 및 관련 장애 Somatic Symptom and Related Disorders 급식 및 섭식장애 Feeding and Eating Disorders 배설장애 Elimination Disorders 수면각성 장애 SleepWake Disorders 성 기능부전 Sexual Dysfunctions 성별 불쾌감 Gender Dysphoria 파괴적, 충동조절 및 품행 장애 Disruptive, ImpulseControl, and Conduct Disorders 물질 관련 및 중독 장애 SubstanceRelated and Addictive Disorders 신경인지 장애 Neurocognitive Disorders 성격장애 Personality Disorders 변태성욕장애 Paraphilic Disorders 기타 정신질환 Other Mental Disorders''' txt를 읽어 한국어와 영어 명칭을 각각 키와 값으로 갖는 딕셔너리를 생성하는 코드를 작성하세요. 결과 {'신경 발달장애': 'Neurodevelopmental Disorders', '조현병 스펙트럼 및 기타 정신병적 장애': 'Schizophrenia Spectrum and Other Psychotic Disorders', '양극성 및 관련 장애': 'Bipolar and Related Disorders', '우울장애': 'Depressive Disorders', '불안장애': 'Anxiety Disorder', '강박 및 관련 장애': 'ObsessiveCompulsive and Related Disorders', '외상 및 스트레스 관련 장애': 'Traumaand StressorRelated Disorders', '해리장애': 'Dissociative Disorders', '신체증상 및 관련 장애': 'Somatic Symptom and Related Disorders', '급식 및 섭식장애': 'Feeding and Eating Disorders', '배설장애': 'Elimination Disorders', '수면각성 장애': 'SleepWake Disorders', '성 기능부전': 'Sexual Dysfunctions', '성별 불쾌감': 'Gender Dysphoria', '파괴적, 충동조절 및 품행 장애': 'Disruptive, ImpulseControl, and Conduct Disorders', '물질 관련 및 중독 장애': 'SubstanceRelated and Addictive Disorders', '신경인지 장애': 'Neurocognitive Disorders', '성격장애': 'Personality Disorders', '변태성욕장애': 'Paraphilic Disorders', '기타 정신질환': 'Other Mental Disorders'} tip ord()와 chr() ord() 함수는 문자에 해당하는 코드값을 알려줍니다. >>> ord('A') 65 >>> ord('Z') 90 >>> ord('a') 97 >>> ord('z') 122 >>> ord('0') 48 >>> ord('9') 57 역으로, chr() 함수에 코드값을 입력으로 넣으면 그에 해당하는 문자를 얻습니다. >>> chr(65) 'A' 한글에 대해서도 두 함수를 사용할 수 있습니다. >>> ord('가') 44032 >>> chr(55197) '힝' tip split()과 splitlines() split()은 공백을 기준으로 문자열을 분리한 것들을 리스트에 넣어 반환합니다. >>> 'hello world'.split() ['hello', 'world'] 여러 행으로 이뤄진 문자열을 분리하려면 \n을 구분자로 지정합니다. >>> love = '''L is for the way you look at me ... O is for the only one I see ... V is very, very extraordinary ... E is even more than anyone that you adore can''' >>> love.split('\n') ['L is for the way you look at me', 'O is for the only one I see', 'V is very, very extraordinary', 'E is even more than anyone that you adore can'] 위와 같이 줄바꿈을 기준으로 문자열을 분할할 때는 splitlines()를 써도 됩니다. 코드: ch04/mental_disorders.py APA 저/권준수,<NAME>, 남궁기, 박원명 역, ⟪정신질환의 진단 및 통계 편람⟫, 학지사, 2015 ↩ 4.4.4 연습 문제: 프랙털 0과 1로 이뤄진 문자열 한 행이 있을 때, 정해진 규칙에 따라 그다음 행을 생성하는 문제입니다. 다음과 같이 이어진 세 숫자 조합에 따라 다음에 올 숫자가 정해집니다. 현재 패턴 111 110 101 100 011 010 001 000 가운데 자리에 새로 올 숫자 0 1 0 1 1 0 1 0 예를 들어, 첫 행이 000010000이면 그다음 행은 000101000이 됩니다. 000010000 000101000 다음은 한 행에 61개의 숫자가 있는 예입니다. 첫 번째 행은 가운데 숫자가 1, 나머지는 모두 0입니다. 두 번째 행부터는 규칙에 따라 생성합니다. 0000000000000000000000000000001000000000000000000000000000000 0000000000000000000000000000010100000000000000000000000000000 0000000000000000000000000000100010000000000000000000000000000 0000000000000000000000000001010101000000000000000000000000000 0000000000000000000000000010000000100000000000000000000000000 0000000000000000000000000101000001010000000000000000000000000 0000000000000000000000001000100010001000000000000000000000000 0000000000000000000000010101010101010100000000000000000000000 0000000000000000000000100000000000000010000000000000000000000 0000000000000000000001010000000000000101000000000000000000000 0000000000000000000010001000000000001000100000000000000000000 0000000000000000000101010100000000010101010000000000000000000 0000000000000000001000000010000000100000001000000000000000000 0000000000000000010100000101000001010000010100000000000000000 0000000000000000100010001000100010001000100010000000000000000 0000000000000001010101010101010101010101010101000000000000000 0000000000000010000000000000000000000000000000100000000000000 0000000000000101000000000000000000000000000001010000000000000 0000000000001000100000000000000000000000000010001000000000000 0000000000010101010000000000000000000000000101010100000000000 0000000000100000001000000000000000000000001000000010000000000 0000000001010000010100000000000000000000010100000101000000000 0000000010001000100010000000000000000000100010001000100000000 0000000101010101010101000000000000000001010101010101010000000 0000001000000000000000100000000000000010000000000000001000000 0000010100000000000001010000000000000101000000000000010100000 0000100010000000000010001000000000001000100000000000100010000 0001010101000000000101010100000000010101010000000001010101000 0010000000100000001000000010000000100000001000000010000000100 0101000001010000010100000101000001010000010100000101000001010 코드: ch04/rule90.py 참고 Rule 90 《 Nature of Code 》 4.5 세트(set) 이번에는 ‘집합’을 표현하는 세트(set)를 좀 더 알아보겠습니다. 과일을 나타내는 fruits 세트를 만들어보겠습니다냠~ >>> fruits = {'apple', 'banana', 'orange'} 사과, 바나나, 오렌지를 원소로 갖는 fruits 세트를 만들었습니다. 이와 같이 세트는 중괄호({, })를 사용합니다. 아차, 맛있는 망고를 빠뜨렸네요. add()로 추가할게요. >>> fruits.add('mango') >>> fruits {'orange', 'apple', 'mango', 'banana'} 이번에는 회사 이름을 나타내는 집합을 만들어볼까요? >>> companies = set() 회사 이름이 떠오르지 않아서 일단 set()로 빈 세트를 만들었습니다. 아, 생각났어요. >>> companies = {'apple', 'microsoft', 'google'} 이제 fruits와 companies 세트를 만들었습니다. 타입을 확인해 볼까요? >>> type(fruits) <class 'set'> >>> type(companies) <class 'set'> 세트를 이용해 아래와 같이 집합 연산을 사용할 수 있습니다. >>> fruits & companies # 교집합 {'apple'} >>> fruits | companies # 합집합 {'apple', 'mango', 'microsoft', 'orange', 'google', 'banana'} 아래와 같이 여러 세트를 리스트에 담은 뒤 set의 메서드를 쓸 수도 있습니다. >>> list_of_sets = [fruits, companies] >>> set.intersection(*list_of_sets) # 교집합 {'apple'} >>> set.union(*list_of_sets) # 합집합 {'google', 'apple', 'banana', 'mango', 'microsoft', 'orange'} apple은 fruits에도 속하고 companies에도 속하는데, 위 합집합의 결과에 한 번만 나오는 것을 볼 수 있습니다. 이와 같이 세트는 중복 원소를 갖지 않습니다. 또, 원소의 순서가 유지되지 않는 특징도 있습니다. >>> alphabet = list('google') >>> alphabet ['g', 'o', 'o', 'g', 'l', 'e'] >>> set(alphabet) {'e', 'o', 'g', 'l'} 아 참, 집합끼리 뺄셈도 할 수 있어요! >>> S1 = {1, 2, 3, 4, 5, 6, 7} >>> S2 = {3, 6, 9} >>> S1 - S2 {1, 2, 4, 5, 7} 4.5.1 연습 문제: 주사위 눈의 합 다음 그림은 주사위 두 개를 던져서 나오는 경우의 수를 모두 나열한 것입니다. (그림 출처: https://cs50.harvard.edu/ai/2020/notes/2/) 두 주사위 눈의 합은 다음과 같습니다. (그림 출처: https://cs50.harvard.edu/ai/2020/notes/2/) 문제 주사위 두 개가 있습니다. 한 개는 평범한 주사위인데, 다른 한 개의 각 면에는 2에서 13까지의 소수가 적혀 있습니다. 아래 코드는 두 주사위의 눈을 튜플 dice1과 dice2로 나타냅니다. dice1 = (1, 2, 3, 4, 5, 6) dice2 = (2, 3, 5, 7, 11, 13) 두 주사위를 던졌을 때 눈의 합으로 나올 수 있는 숫자를 모두 출력하세요. 단, 같은 숫자는 한 번만 출력합니다. 코드: ch04/sum_dice.py 4.5.2 연습 문제: 끝말잇기 (1) 끝말잇기를 하는 프로그램을 작성하세요. 컴퓨터와 플레이어는 자기 턴(turn, 차례)이 되면 이전에 상대방이 말한 단어의 끝 글자로 시작하는 단어를 말해야 하며, 이전에 썼던 단어는 말할 수 없습니다. 1. 컴퓨터가 먼저 ‘기차’를 출력합니다. 2. 사용자의 입력을 받습니다. 사용자가 올바로 입력했으면 다음으로 진행하고, 단어를 잘못 입력하거나 ‘졌어’라고 입력하면 컴퓨터가 이기고 끝냅니다. 3. 컴퓨터는 다음의 단어 중 하나를 골라 출력합니다. 마땅한 것이 없으면 사용자가 이기고 끝냅니다. 게맛살, 구멍, 글라이더, 기차, 대롱, 더치페이, 롱다리, 리본, 멍게, 박쥐, 보닛, 빨대, 살구, 양심, 이빨, 이자, 자율, 주기, 쥐구멍, 차박, 트라이앵글 4. 2~3을 반복 ※ 두음 법칙은 무시합니다. 예 1 턴 입출력 컴퓨터 <시작>끝말잇기를 하자. 내가 먼저 말할게. 기차 플레이어 자동차 컴퓨터 글자가 안 이어져. 내가 이겼다!<끝> 예 2 턴 입출력 컴퓨터 <시작>끝말잇기를 하자. 내가 먼저 말할게. 기차 플레이어 차 박 컴퓨터 박쥐 플레이어 쥐구멍 컴퓨터 멍게 플레이어 게시판 컴퓨터 모르겠다. 내가 졌어.<끝> 예 3 턴 입출력 컴퓨터 <시작>끝말잇기를 하자. 내가 먼저 말할게. 기차 플레이어 차주 컴퓨터 주기 플레이어 기차 컴퓨터 아까 했던 말이야. 내가 이겼어!<끝> 예 4 턴 입출력 컴퓨터 <시작>끝말잇기를 하자. 내가 먼저 말할게. 기차 플레이어 차량 컴퓨터 모르겠다. 내가 졌어.<끝> 풀이 코드: ch04/wordgame.py 5. 모듈 다른 사람이 만들어놓은 모듈(module)을 잘 활용하면 쉽고 빠르게 프로그램을 개발할 수 있어요! 이 장에서 배우는 것: 모듈이란 모듈 가져오기 여러 가지 모듈 5.1 모듈이란 자료구조 부분이 드디어 끝났죠? 좀 지루하셨을 수도 있지만, 컴퓨터에 있어서 자료구조의 중요성은 절대적이라고 할 만큼 크답니다. 작게는 CPU 내의 기억장소에서부터, 크게는 파일, 데이터베이스, 전체 시스템에까지 두루 적용된다고 하니까 틈틈이 공부해두시면 좋겠네요. 우리가 지금까지는 혼자서 변수, 함수를 만들어 쓰면서 자급자족하는 방법을 배웠다고 한다면, 이제부터는 남이 만들어 놓은 부품을 가져다가 사용하는 방법을 배울 차례입니다. 우리가 복잡한 프로그램을 작성하기 위해서 필요한 모든 과정을 직접 만들어야 한다면 어떤 모습이 될까요? 전체적인 모습에서부터 작은 기능 하나하나까지 모두 구상해서, 만들고, 오류를 수정해서 한곳에 모아두면 또 오류가 생기고… 더구나, 또 다른 프로그래머는 나와 비슷한 기능을 하는 프로그램을 만들면서 똑같은 시행착오를 답습할 테고요. 그래서, 이런 문제를 해결하기 위해 대부분의 프로그래밍 언어에서는 모듈이라는 개념을 사용합니다. 모듈은 프로그램의 꾸러미라고 생각하시면 되지요. 할머니 댁 집 수리를 해야 해서 여러 가지 공구를 들고 간다고 상상해 봅시다. 손에 다 들고 가기는 불편하니 공구통에 넣는 게 좋겠죠? math 모듈 수학적인 계산 기능이 필요하다면 math라는 모듈을 불러와서 사용하시면 됩니다. >>> import math # math 모듈을 가져와라 제곱근(square root)을 구해볼까요? >>> math.sqrt(2) # 2의 제곱근 1.4142135623730951 >>> math.sqrt(3) # 3의 제곱근 1.7320508075688772 >>> math.sqrt(4) # 4의 제곱근 2.0 원주율도 알아보겠습니다. >>> math.pi # math 모듈의 변수 pi의 값은? 3.1415926535897931 위에서는 math 모듈 내에 정의되어 있는 pi 변수를 사용했습니다. pi는 원주율을 뜻하지요. calendar 모듈 이번에는 달력을 불러볼까요? 딱 두 줄만 치면 됩니다. >>> import calendar >>> calendar.prmonth(2013, 7) July 2013 Mo Tu We Th Fr Sa Su 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 훌륭하죠? tkinter 모듈 이번에는 더욱 훌륭한 것을 보여드리지요. >>> from tkinter import * >>> widget = Label(None, text='I love Python!') >>> widget.pack() 이렇게 파이썬에서는 좋은 기능들을 모듈로 묶어서 자체적으로 제공해 준답니다. 파이썬뿐만이 아니라 대부분의 언어에서 이런 식으로 프로그래밍을 편리하게 할 수 있도록 지원해 주지요. 모듈을 잘 들여다보면 배울 것이 많을 것 같군요. 내일 또 만나요~. 5.2 모듈 가져오기(import) 어떤 프로그래머께서 이렇게 말씀하셨습니다. 단기간에 뛰어난 프로그래머가 되려고 하면 절대 성공할 수 없느니라. 오늘은 모듈을 어떻게 불러오는지 알아보도록 하죠. 어제 해보셔서 대충은 알고 계시겠지만 import를 사용하면 모듈을 불러올 수 있습니다. import는 '수입하다', '가져오다'라는 뜻을 갖고 있고요, 컴퓨터에서는 다른 프로그램으로부터 데이터를 갖고 오는 것을 뜻하지요. 파이썬에서 임포트를 하는 방법 두 가지를 알아보겠습니다. 첫 번째 방법: import 모듈 두 번째 방법: from 모듈 import 이름 첫 번째 방법은 모듈 전체를 가져오고요, 두 번째 방법은 모듈 내에서 필요한 것만 콕 찍어서 가져오는 방법이죠. 공구통에 비유하면 다음 그림과 같이 표현할 수 있어요. 두 방법을 비교해 볼까요? 어제 소개해 드린 tkinter(티 케이 인터) 모듈을 두 가지 방법으로 임포트 해 보겠습니다. >>> import tkinter >>> tkinter.widget = tkinter.Label(None, text='I love Python!') >>> tkinter.widget.pack() 첫 번째 방법으로 모듈을 불러오면 모듈 내의 변수를 사용하기 위해서는 모듈. 변수의<NAME>으로 써주어야 합니다. 매번 써주려면 좀 번거롭겠죠? >>> from tkinter import * >>> widget = Label(None, text='I love Python!') >>> widget.pack() 두 번째 방법은 모듈 내의 이름을 콕 찍어서 가져오는 방법인데, 위에서는 tkinter에 있는 것을 전부(*) 가져왔습니다. 이렇게 하면 좀 더 편리하군요. 하지만 마냥 좋기만 한 방법은 아니랍니다. 아래의 예에서는 문자열이었던 Label이 임포트 문 실행 후 tkinter의 Label로 바뀌어 버린 것을 볼 수 있습니다. >>> Label = 'This is a Label' >>> from tkinter import * >>> Label <class 'tkinter.Label'> 이런 특성을 이해하고 상황에 맞게 사용하시면 됩니다. 지금까지 모듈을 불러오는 방법을 알아봤는데요, 불러온 모듈이 필요 없을 땐 어떻게 할까요? 필요 없는 모듈은 요렇게 지워주면 됩니다. del 모듈 꼭 그렇게 해줄 필요가 있을까 싶지만, 프로그램을 짜다 보면 이런저런 일이 생기니까 알아두자고요. 한 번 임포트 한 모듈을 다시 불러와야 할 때는 아래와 같이 다시 로드(reload) 할 수 있답니다. from importlib import reload reload(모듈) 5.2.1 연습 문제: 모듈 사용법 알아내기 calendar 모듈을 좀 더 살펴보겠습니다. 문제 1. calendar 모듈을 임포트 하는 문장을 완성하세요. >>> ____ calendar calendar 모듈에 무엇이 있는지 살펴보세요. >>> dir(calendar) ['Calendar', 'EPOCH', 'FRIDAY', 'February', 'HTMLCalendar', 'IllegalMonthError', 'IllegalWeekdayError', 'January', 'LocaleHTMLCalendar', 'LocaleTextCalendar', 'MONDAY', 'SATURDAY', 'SUNDAY', 'THURSDAY', 'TUESDAY', 'TextCalendar', 'WEDNESDAY', '_EPOCH_ORD', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_colwidth', '_locale', '_localized_day', '_localized_month', '_monthlen', '_nextmonth', '_prevmonth', '_spacing', 'c', 'calendar', 'datetime', 'day_abbr', 'day_name', 'different_locale', 'error', 'firstweekday', 'format', 'formatstring', 'isleap', 'leapdays', 'main', 'mdays', 'month', 'month_abbr', 'month_name', 'monthcalendar', 'monthrange', 'prcal', 'prmonth', 'prweek', 'repeat', 'setfirstweekday', 'sys', 'timegm', 'week', 'weekday', 'weekheader'] 이와 같이 모듈은 수많은 공구가 들어 있는 '공구통'이라고 생각할 수 있습니다. 문제 2. calendar 모듈에 leap이라는 문자열을 포함하는 이름은 어떤 것이 있는지 찾아보세요. 1 >>> [x for x in dir(calendar) if 'leap' in x] [____, ____] 문제 3. 주어진 해가 윤년인지 아닌지 판별하는 함수의 사용법을 확인해 보세요. >>> help(____) Help on function ____ in module calendar: ____(year) Return True for leap years, False for non-leap years. 문제 4. 이 함수를 사용해서 2077년이 윤년인지 아닌지 확인해 보세요. >>> ____ False 코드: ch05/using_modules.ipynb 이 구문은 list comprehension이라는 것으로, 'comprehension'은 '컴프리 헨 션', '내포', '함축', '조건 제시' 등 여러 이름으로 부릅니다. ↩ 5.2.2 연습 문제: 직각삼각형의 빗변 길이 구하기 문제 피타고라스 정리에 따라, 직각삼각형의 두 직각변 와의 길이를 알면 빗변의 길이를 구할 수 있습니다. = 2 b 문제 1 = , = 일 때 가 얼마인지 파이썬 셸에서 구하세요. 문제 2 두 직각변( , )의 길이를 입력으로 받아 빗변( )의 길이를 구하는 함수 hypotenuse()를 작성하세요. 출력은 소수점 셋째 자리에서 반올림합니다. >>> hypotenuse(3, 4) 5.0 >>> hypotenuse(10, 20) 22.36 ch05/hypotenuse.txt ch05/right_triangle.py 참고 피타고라스 정리 - 칸 아카데미 5.2.3 연습 문제: calendar와 tkinter 문제 1. calendar 다음은 2021년 2월의 달력을 변수 m으로 저장하고 화면에 출력하는 코드입니다. 빈칸을 채우세요. import calendar c = calendar.TextCalendar() m = c. ███████████(2021, 2) print(m) 결과: February 2021 Mo Tu We Th Fr Sa Su 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 힌트 >>> help(c) 2. tkinter 다음은 tkinter를 활용해 그림과 같은 창을 띄우는 코드입니다. 빈칸을 채우세요. import tkinter as tk s = "Life is short\nUse Python" root = tk.Tk() t = tk.Text(root, height=█, width=██) t.insert(tk.END, █) t.pack() tk.mainloop() 결과: 3. calendar와 tkinter 그림과 같이 2021년 3월의 달력을 표시하는 창을 띄우는 코드를 작성하세요. 결과: ch05/month2str.py ch05/life_is_short.py ch05/tk_calendar.py 5.2.4 연습 문제: 놀이공원 (2) 둘리, 도우너, 마이콜이 놀이공원에서 함께 놀이 기구를 타려고 합니다. 그런데 세 명의 키가 달라서, 각자 탈 수 있는 기구가 다릅니다. 문제 이 문제를 풀기 전에 놀이공원 (1) 문제를 먼저 풀어야 합니다. 다음은 놀이 기구의 목록입니다. 사용자가 키(신장)를 입력하면, 탈 수 있는 놀이 기구 목록을 출력하는 프로그램을 작성하세요. 와일드 윙: 110cm 이상 드림 보트: 120cm 이상 자이언트 루프: 120cm 이상 툼 오브 호러: - 플라이벤처: 140cm~195cm 회전목마: 100cm 이상 매직 붕붕카: 110cm~140cm 코드는 다음과 같이 작성하며, ch05 폴더에 park.py라는 파일명으로 저장합니다. import sys sys.path.append("../ch03") import # 이곳에 코드를 작성하세요. rides = # 이곳에 코드를 작성하세요. def allowedrides(height): assert type(height) == int result = [] # 이곳에 코드를 작성하세요. return result if __name__ == "__main__": height = int(input()) # 이곳에 코드를 작성하세요. 입출력 예 예 1 둘리의 키를 입력합니다. 120 출력: 와일드 윙 드림 보트 자이언트 루프 툼 오브 호러 회전목마 매직 붕붕카 예 2 도우너의 키를 입력합니다. 110 출력: 와일드 윙 툼 오브 호러 회전목마 매직 붕붕카 예 3 마이콜의 키를 입력합니다. 179 출력: 와일드 윙 드림 보트 자이언트 루프 툼 오브 호러 플라이벤처 회전목마 ch05/park.py 5.2.5 연습 문제: 놀이공원 (3) 문제 이 문제를 풀기 전에 놀이공원 (1)과 놀이공원 (2) 문제를 먼저 풀어야 합니다. 놀이 기구 중에서 둘리, 도우너, 마이콜이 모두 탈 수 있는 것을 출력합니다. 입출력 예 입력: 120 110 179 출력: 와일드 윙 툼 오브 호러 회전목마 ch05/together.py 5.3여러 가지 모듈 이번 시간도 계속해서 모듈에 대해 알아볼까요? 파이썬에서 기본적으로 제공하는 수많은 모듈 중에서 자주 쓰이는 것들을 이번 시간에 살짝 소개해 드리려고 합니다. sys 처음으로 알려드릴 것은 sys 모듈입니다. 요놈은 파이썬 인터프리터를 제어할 수 있는 방법을 제공하지요. 파이썬 인터프리터를 띄워주세요. 인터프리터가 우리의 명령을 기다린다는 뜻으로 >>>를 표시하고 있죠? 도스와 마찬가지로 이것도 프롬프트라고 합니다. sys 모듈을 사용하면 이 프롬프트를 바꿀 수가 있지요. >>> import sys >>> sys.ps1 # 현재의 프롬프트는? '>>> ' >>> sys.ps1 = '^^; ' # 요걸로 바꿔! ^^; print('hello') hello ^^; 5 * 3 15 ^^; 재미있지요? 이번엔 인터프리터를 끝내볼까요? ^^; sys.exit() os 그다음에는 os 모듈을 보겠습니다. 이것은 운영체제(OS : Operating System)를 제어할 수가 있지요. 파이썬을 새로 실행하고, 현재 경로를 알아볼게요. Python 3.8.5 (tags/v3.8.5:580fbb0, Jul 20 2020, 15:43:08) [MSC v.1926 32 bit (Intel)] on win32 Type "help", "copyright", "credits" or "license" for more information. >>> import os >>> os.getcwd() 'C:\\Users\\Yong Choi\\AppData\\Local\\Programs\\Python\\Python38-32' os 모듈의 getcwd()는 현재 작업 디렉터리를 알려줍니다. 구해라(get)! 무엇을? 현재 작업 디렉터리(current working directory)를~ 이곳에 어떤 파일들이 있는지 알아볼까요? 이곳에 어떤 파일들이 있는지 알아볼까요? >>> os.listdir() ['DLLs', 'Doc', 'img_read.py', 'include', 'Lib', 'libs', 'LICENSE.txt', 'NEWS.txt', 'python.exe', 'python3.dll', 'python38.dll', 'pythonw.exe', 'Scripts', 'tcl', 'Tools', 'vcruntime140.dll'] 이 중에서 libs 디렉터리로 이동해 보겠습니다. >>> os.chdir('libs') >>> os.getcwd() 'C:\\Users\\Yong Choi\\AppData\\Local\\Programs\\Python\\Python38-32\\libs' 현재 작업 디렉터리가 바뀌었죠? 파일 목록도 보겠습니다. >>> os.listdir() ['python3.lib', 'python38.lib', '_tkinter.lib'] 상위 디렉터리는 ..으로 나타냅니다. >>> os.chdir('..') >>> os.getcwd() 'C:\\Users\\Yong Choi\\AppData\\Local\\Programs\\Python\\Python38-32' re 정규 표현식(regular expression)을 이용해 문자열을 다룰 수 있는 re 모듈도 있어요. 다음 예제에서 두 번째 줄의 괄호 안에 쓴 것이 정규 표현식인데요, 마침표(.)는 문자 아무거나 한 개를 뜻하고, 별표(*)는 0개 이상의 문자를 뜻합니다. 그래서 현재 디렉터리에서 p 다음에 n이 나오는 이름을 갖고 있는 파일들을 모두 찾아주게 되지요. 실행한 결과를 잘 보시면 이해가 되실 거예요. >>> import re, glob >>> p = re.compile('.*p.*n.*') >>> for i in glob.glob('*'): ... m = p.match(i) ... if m: ... print(m.group()) ... pycon.ico python.exe pythonw.exe w9xpopen.exe 이런 것들 외에 처음에 모듈에 대해 설명드릴 때 보여드린 math나 tkinter도 자주 쓰실 법하네요. 지금까지 몇 가지 예를 보여드렸는데 모듈들이 참 쓸만하죠? 파이썬에서 제공하는 모듈을 잘 활용하면 좋은 프로그램을 쉽게 만들 수 있을 것 같네요. 하지만 수많은 모듈의 사용법을 모두 머리에 집어넣으실 필요는 없겠죠? 작성하실 프로그램에서 어떤 기능을 필요로 하는가에 따라 어떤 모듈을 사용할 것인지 결정한 다음, 사용설명서를 보면서 모듈의 사용법을 익혀서 프로그래밍하시면 됩니다. 모듈의 사용설명서로는 파이썬과 함께 기본적으로 설치되는 'Python Library Reference(파이썬 라이브러리 레퍼런스)'라는 것도 있고, 책이나 인터넷을 통해 자료를 찾아볼 수도 있지요. webbrowser 끝으로 재미있는 모듈을 하나 더 소개해 드릴게요. 한번 따라 해보세요. 그럼 전 이만… 휘리릭~ >>> import webbrowser >>> url='http://www.python.org/' >>> webbrowser.open(url) True >>> 5.3.1 랜덤(random) 모듈 이번에는 파이썬에서의 랜덤(random)에 대해 가볍게 정리해 볼까 합니다. 우선 랜덤이 무엇인지부터 살펴볼까요? 주사위를 던지는 상황을 생각해 봅시다. 주사위의 각 면에는 1개에서 6개까지의 눈이 새겨져 있어서, 주사위를 던질 때마다 그중 하나의 숫자가 선택됩니다. 주사위를 직접 던져보기 전에는 다음번에 어떤 숫자가 나올지 알 수가 없죠. 그런데 주사위를 600번 정도 던져보면 각 숫자가 대략 100번 정도는 나오기는 합니다. 이런 것이 바로 난수(random number)입니다. 난수의 예가 될 만한 것으로 주사위 외에 또 어떤 것들이 있을까요? 복권 추첨, 음악 재생 순서 섞기... 그럼 파이썬으로 난수를 만들어봅시다. >>> import random >>> random.random() 0.90389642027948769 random 모듈의 random() 함수를 호출했더니 복잡한 숫자를 돌려주네요. random() 함수는 0 이상 1 미만의 숫자 중에서 아무 숫자나 하나 뽑아서 돌려주는 일을 한답니다. 주사위처럼 1에서 6까지의 정수 중 하나를 무작위로 얻으려면 어떻게 해야 할까요? 이럴 때 편리하게 쓸 수 있는 randrange()라는 함수가 있습니다. >>> random.randrange(1,7) >>> random.randrange(1,7) 여기에서 randrange(1,6)이 아니라 randrange(1,7)이라고 썼다는 점에 주의하세요. "1 이상 7 미만의 난수"라고 생각하시면 이해가 쉽습니다. 내장함 수인 range()를 되새겨보는 것도 좋겠군요. >>> range(1,7) [1, 2, 3, 4, 5, 6] shuffle()이라는 재미있는 함수도 있군요. 시퀀스를 뒤죽박죽으로 섞어놓는 함수입니다. >>> abc = ['a', 'b', 'c', 'd', 'e'] >>> random.shuffle(abc) >>> abc ['a', 'd', 'e', 'b', 'c'] >>> random.shuffle(abc) >>> abc ['e', 'd', 'a', 'c', 'b'] 아무 원소나 하나 뽑아주는 choice() 함수도 있네요. >>> abc ['e', 'd', 'a', 'c', 'b'] >>> random.choice(abc) 'a' >>> random.choice(abc) 'd' >>> menu = '쫄면', '육개장', '비빔밥' >>> random.choice(menu) '쫄면' 참과 거짓 중에 하나를 뽑고 싶다면, 뭐.. 까짓것... 이렇게 해주죠... >>> random.choice([True, False]) True >>> random.choice([True, False]) False 5.3.2 연습 문제: 밴드 이름 짓기 (1) 문제 색깔 이름과 음식 이름을 더하면 밴드 이름 같다고 합니다.1 색이름과 음식 이름을 무작위로 뽑아서 밴드 이름을 지어주는 프로그램을 만들어 보세요. $ python bandname1.py 검은 콰삭칩 $ python bandname1.py 화이트 곰보빵 $ python bandname1.py 파란 주꾸미 $ python bandname1.py 청색 커피 $ python bandname1.py 파란 옹심이 코드: ch05/bandname1.py 지금 입고 있는 하의 색과 마지막으로 먹은 음식 이름을 더하면 밴드 이름 같다 ↩ 5.3.3 string과 random 모듈을 이용해 비밀번호 생성 여러 인터넷 사이트와 앱을 이용하다 보면 비밀번호(password)를 만들고 입력할 일이 많죠. 여러분은 비밀번호를 어떻게 관리하시나요? 비밀번호를 통일하면 관리하기 편하겠지만, 공격자가 한 곳의 비밀번호만 알아내면 다른 곳의 비밀번호도 모두 알게 되므로, 사이트마다 다른 패스워드를 쓰는 것이 좋습니다. 또, 사이트마다 비밀번호가 다르더라도 일정한 규칙에 따라 만들어져 있으면 공격자가 유추할 가능성이 있고요. 다행히 요즘에는 비밀번호를 만들고 기억해 주는 기능이 웹 브라우저와 스마트폰에 있어서 비밀번호 관리가<NAME> 수월해졌습니다. 이번에는 파이썬으로 비밀번호를 만들어보려고 합니다. string 모듈 먼저 재료를 준비하겠습니다. 일반적으로 비밀번호는 영문자와 숫자, 특수문자를 섞어서 만들죠. 영문자부터 해볼게요. "ABCD..."를 하나하나 타자해도 되겠지만, string 모듈을 이용하겠습니다. string 모듈을 임포트 해주세요. >>> import string string.ascii_uppercase에는 대문자 A부터 Z까지가 있습니다. >>> string.ascii_uppercase 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 마찬가지로 string.ascii_lowercase에는 영문 소문자가 있습니다. >>> string.ascii_lowercase 'abcdefghijklmnopqrstuvwxyz' 참, 소문자와 대문자를 모두 갖고 있는 string.ascii_letters도 있어요. >>> string.ascii_letters 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' 이번에는 숫자를 준비합시다. string.digits를 쓰면 됩니다. >>> string.digits '0123456789' 영문자와 숫자를 한데 모아 alphanumeric 변수를 만들겠습니다. >>> alphanumeric = string.ascii_letters + string.digits >>> alphanumeric 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789' 몇 글자인지 세어볼까요? >>> len(alphanumeric) 62 소문자 엘(l)과 대문자 아이(I)가 비슷하게 생겨서 헷갈리니까 그 두 개는 빼는 게 좋겠어요. 그리고 숫자 0과 대문자 오(O)도 헷갈릴 수 있으니 빼고요. 이럴 때 세트를 쓰면 좋겠네요. >>> list(set(alphanumeric) - set('lIO0')) ['L', 'k', 'g', 'j', 'T', '5', 'Z', 'a', 'M', 'w', 'D', 'P', 'n', 'f', 'x', 'd', 'q', 'K', 'J', 'X', '4', 'b', 'F', 'Y', 'A', 'v', 'r', 'i', 'o', '7', 'y', 'S', '1', 'u', 'W', 'V', 'R', 'G', 'h', 'c', 'N', 'U', '2', '6', 'C', 'B', 'e', 'p', 's', 'z', 'H', '9', 't', '8', 'E', 'm', '3', 'Q'] 특수문자는 밑줄만 쓰는 걸로 할까요? >>> chars = list(set(alphanumeric) - set('lIO0')) + ['_'] 비밀번호를 만들 때 쓰고 싶은 글자 59개로 이뤄진 chars라는 이름의 리스트가 준비됐습니다. >>> len(chars) 59 문자열 섞기 재료를 준비했으니 비밀번호를 만들어 보겠습니다. 글자를 무작위로 고르려면 앞에서 배운 random 모듈을 쓰면 되겠죠? >>> import random 아무 글자나 하나 뽑아볼게요. >>> random.choice(chars) 'Y' 또 뽑아볼게요. >>> random.choice(chars) 'Q' >>> random.choice(chars) 'V' >>> random.choice(chars) 'x' 이런 식으로 반복해서 비밀번호를 만들면 되겠군요. >>> pw = str() >>> for i in range(16): ... pw += random.choice(chars) ... >>> pw 'yTjFDnEaLvE8S2uo' 16자로 된 비밀번호를 만들어봤습니다. 그런데 밑줄은 들어있지 않네요. 그도 그럴 것이, 무작위로 뽑으면 각 글자가 1/59 확률로 나올 테니 밑줄이 나오기 힘들 것 같네요. 영문자, 숫자, 특수문자를 모두 넣어야 한다는 규칙이 있다면 좀 더 머리를 써야 할 것 같습니다. 똑똑한 여러분이 한번 도전해 보세요. 저는 곧 치킨 배달이 와서 이만…. P.S. 저는 이렇게 만들어봤습니다. ch05/gen_password.py 5.3.4 시저(카이사르) 암호 만들기 로마의 율리우스 카이사르가 사용했다고 해서 ‘카이사르 암호’ 또는 ‘시저 암호’로 알려진 것을 파이썬으로 만들어보겠습니다. 시저 암호의 원리 카이사르 암호에서는 알파벳의 각 글자를 다른 글자로 바꾸는 표를 만듭니다. 다음 표의 위 줄은 소문자를 a부터 알파벳순으로 늘어놓은 것이고, 아래 줄은 대문자 중 네 번째 글자인 D부터 시작해서 알파벳 순서로 늘어놓은 것입니다. 아래 줄의 Z 다음에는 다시 A가 옵니다. 암호화하고 싶은 문장의 각 글자에 대해, 표의 위 줄에 있는 글자를 아래 줄에 있는 글자로 바꾸면 암호문이 만들어집니다. 편의상 평문은 소문자로, 암호문은 대문자로 표시하겠습니다. 평문(‘절대로 브루투스를 신뢰하지 마라’라는 뜻): traue nie dem brutus 암호문: WUDXH QLH GHP EUXWXV 메시지를 보내는 사람과 받는 사람만 이 규칙을 알고 있으면, 전령이 메시지를 전달하는 도중에 적이 가로채더라도 뜻을 알기 어렵겠죠? 똑똑한 여러분이라면 금세 알아챌지도 모르겠네요. 암호표는 다음과 같이 두 개의 원판으로 나타낼 수도 있습니다. 안쪽 원판을 돌려서 암호 규칙을 바꿀 수 있겠죠? 파이썬으로 시저 암호 구현 먼저 암호표의 위 줄(바깥쪽 원판)을 만들기 위해 a부터 z까지의 영문 소문자 알파벳을 차례대로 늘어놓습니다. 직접 타자해도 되지만 string 모듈을 이용하겠습니다. >>> import string >>> string.ascii_lowercase 'abcdefghijklmnopqrstuvwxyz' 이번에는 암호표의 아래 줄(안쪽 원판)에 해당하는 영문 대문자 D~Z, A~C입니다. >>> string.ascii_uppercase[3:] + string.ascii_uppercase[:3] 'DEFGHIJKLMNOPQRSTUVWXYZABC' 위 줄과 아래 줄에 해당하는 문자열들을 준비했으니, 각 글자를 대응시키는 암호표에 해당하는 것을 만들어보겠습니다. 반복문을 써서 직접 만드는 방법도 있지만, 파이썬에서는 str 객체의 maketrans() 메서드를 이용해 쉽고 빠르게 구현할 수 있습니다. (‘메서드’에 관해서는 7장에서 다룹니다. 지금은 그냥 함수와 비슷한 것이라고 생각하면 됩니다.) >>> tt = str.maketrans(string.ascii_lowercase, string.ascii_uppercase[3:] + string.ascii_uppercase[:3]) str.maketrans()의 결과로 반환되는 딕셔너리에 tt라는 이름을 붙였습니다. 이제, 암호화하고 싶은 문자열을 translate() 메서드를 써서 암호화합니다. 이때 앞에서 만든 tt를 인자로 줍니다. >>> 'traue nie dem brutus'.translate(tt) 'WUDXH QLH GHP EUXWXV' 참 쉽죠?! 참고 루돌프 키펜한 지음 / 이일우 옮김, 《암호의 해석》 5.3.5. 연습 문제: 끝말잇기 (2) 끝말잇기를 하는 프로그램을 작성하세요. 규칙은 끝말잇기 (1)과 같되, 두음 법칙을 적용합니다. 예 1~3은 끝말잇기 (1)에서와 같고, 예 4는 다릅니다. 예 1 턴 입출력 컴퓨터 <시작>끝말잇기를 하자. 내가 먼저 말할게. 기차 플레이어 자동차 컴퓨터 글자가 안 이어져. 내가 이겼다!<끝> 예 2 턴 입출력 컴퓨터 <시작>끝말잇기를 하자. 내가 먼저 말할게. 기차 플레이어 차 박 컴퓨터 박쥐 플레이어 쥐구멍 컴퓨터 멍게 플레이어 게시판 컴퓨터 모르겠다. 내가 졌어.<끝> 예 3 턴 입출력 컴퓨터 <시작>끝말잇기를 하자. 내가 먼저 말할게. 기차 플레이어 차주 컴퓨터 주기 플레이어 기차 컴퓨터 아까 했던 말이야. 내가 이겼어!<끝> 예 4 턴 입출력 컴퓨터 <시작>끝말잇기를 하자. 내가 먼저 말할게. 기차 플레이어 차량 컴퓨터 양심 플레이어 심술 컴퓨터 모르겠다. 내가 졌어.<끝> 풀이 코드: ch05/wordgame2.py 5.3.6 연습 문제: 내일의 날짜 구하기(2) 문제 내일의 날짜 구하기(1) 문제를 datetime 모듈을 활용해서 풀어 보세요. strftime()과 strptime timedelta 코드: ch05/tomorrow2.py 5.3.7 연습 문제: 원주율 구하기 원(circle)의 지름(diameter)에 대한 둘레(circumference)의 비를 ‘원주율’이라고 하죠. 원이 크든 작든, 모든 원에 대해 원주율은 약 3.14⋯로 일정합니다. 그래서 수학에서 [파이]라는 상수로 표시합니다. 앞에서도 봤듯이, 파이썬의 math 모듈에는 원주율 값이 들어 있어서 우리가 힘들게 계산할 필요가 없어요. >>> import math >>> math.pi 3.141592653589793 굳이 하지 않아도 되지만, 직접 구해보는 것도 재미있겠네요. 원주율을 구하는 원리 원주율을 계산하는 방법은 여러 가지가 있다고 하네요. 여기서는 무작위로 점을 찍어서 개수를 세는 방식으로 해보려고 합니다. 거북이로 원과 정사각형 그리기 잠시 후에 수학 공식을 설명하려고 하는데, 그림이 있으면 이해가 잘 될 듯해서 거북이(터틀 그래픽스)의 도움을 받아 그림을 그려 보겠습니다. from turtle import * shape('turtle') # 원의 반지름 r = 100 # r 만큼 이동해서 그리기 준비 up(); forward(r); down(); left(90) # 반지름이 r인 원 그리기 circle(r) # 한 변의 길이가 r의 두 배인 정사각형 그리기 # 한 번에 2r씩 직진해도 되지만 아래처럼 해도 되겠죠? forward(r); left(90); forward(r) # 오른쪽 아래 forward(r); left(90); forward(r) # 오른쪽 위 forward(r); left(90); forward(r) # 왼쪽 위 forward(r); left(90); forward(r) # 왼쪽 아래 거북이에게 여러 가지 그림을 그려달라고 시키는 방법을 아래<NAME>상에 소개했으니 궁금하신 분은 참고하세요. https://youtu.be/ZEV3pGTdlxw 몬테카를로 방법으로 원주율을 구하는 원리 다시 원주율 구하는 법 이야기로 돌아갈게요. 그 이름 때문에 왠지 어려운 느낌이 들지만, ‘몬테 카를로’는 그냥 동네 이름입니다. 우리나라로 치면 강원도 정선과 비슷한 곳입니다. 몬테카를로 방법으로 원주율을 구하는 원리를 이해하려면, 먼저 두 가지 수학 공식을 알아야 합니다. 정사각형의 넓이는 한 변의 길이를 제곱한 값과 같다.(넓이 정사각형 변 이 사 형 변 ) 원 넓이는 반지름을 제곱한 값에 원주율을 곱한 것과 같다.(넓이원 이 = r) 정사각형의 한 변 길이가 원의 지름(반지름의 두 배, 즉 r )과 같다면, 위의 첫 번째 공식을 다음과 같이 나타낼 수 있겠죠? 넓이 정사각형 이 사 형 ( r ) = r 그래서 원 넓이를 정사각형 넓이로 나눠보면 다음과 같이 됩니다. 넓이원 넓이 정사각형 이 넓 정 각 = r 4 2 π 그래서 원주율은 넓이원 넓이 정사각형 = 넓 원 이 사 형 이 됩니다. 그렇다면 원 넓이와 정사각형 넓이를 알면 원주율을 알 수 있겠군요! 정사각형 넓이는 구하기 쉬운데, 원 넓이를 어떻게 구하죠? 반지름 제곱에 원주율을 곱하⋯ 아, 이게 아니지⋯. -_-;ㅋ 이때 ‘까짓것 대충 찍자!’라는 방법이 바로 몬테카를로 방법입니다. 어떻게 하냐면요, 정사각형 안의 아무 데나 점을 마구 찍은 다음에, 그 점이 원에 들어가는지 아닌지를 따져보는 거예요. 그래서 원 안에 있는 점의 개수가 전체에서 얼마나 되는지 비율을 구하면, 정확하지는 않아도 비슷하게나마 원주율을 구할 수 있다는 겁니다. 원주율 원안에 들어간 점의 개수 한 변의 길이 가원의 지름과 같은 정사각형 안의 점의 개수 주 ≈ 원 안에 들어간 점의 개수 한 변의 길이가 원의 지름과 같은 정사각형 안의 점의 개수 정말로 원주율의 근삿값을 구할 수 있는지는, 한번 코딩해서 확인해 보도록 하죠. random 모듈을 이용해 원주율 구하기 사각형 안에 점을 찍는 방법부터 알아봐야겠네요. 사각형 안에 점찍기 random 모듈을 이용해서, 거북이에게 사각형 안의 아무 곳에나 가서 점을 찍으라고 시켜 보겠습니다. # 자취를 남기지 않기 penup() from random import randrange def draw_random_dot(): point = randrange(-r, r), randrange(-r, r) goto(point) dot() # 점찍기 draw_random_dot() draw_random_dot() draw_random_dot() ... 점이 몇 개인지 직접 세어 볼까요? 점이 총 8개고(한 개는 거북이에 가려짐) 그중에 6개가 원 안에 있네요. 앞에서 만든 원주율 구하는 식에 넣어 보면 × 8 이 되죠. 파이썬으로 계산하면, >>> 4 * (6 / 8) 3.0 원주율은 약 3이 됩니다! 점이 원 안에 있는지 판별하기 점을 더 많이 찍어서 실험하면 원주율을 더 정확하게 구할 수 있을 것 같은데, 점을 새기가 힘들어질 것 같군요. 그래서 원 안에 있는 점의 개수를 세는 일을 파이썬에게 시켜보려고 합니다. 원 안에 들어간 점이 몇 개인지 알려면, 점이 원 안에 있는지 원 밖에 있는지를 구분할 수 있어야겠죠. 그래서 수학 지식이 또 필요합니다. ‘원 중심과 점 사이의 거리가 원의 반지름보다 작거나 같으면 점이 원 안에 있다’라고 정하기로 하죠. 원 중심이 ( , ) 에 있고 점 가 ( , ) 에 있다고 하면, 원 중심과 점 사이의 거리는 다음과 같이 구할 수 있어요. = 2 b 이것을 이용해서, 점의 x, y 좌표와 반지름 r을 입력하면 그 점이 원의 안에 있는지 아닌지를 알려주는 함수를 만들어 볼게요. import math def in_circle(x, y, r): return math.sqrt(x ** 2 + y ** 2) <= r 그리고 앞에서 만든 점찍기 함수를 고쳐보겠습니다. def draw_random_dot(): x, y = randrange(-r, r), randrange(-r, r) goto(x, y) if in_circle(x, y, r): color('red') # 원 안에 있으면 빨간색 점 else: color('blue') # 원 밖에 있으면 파란색 점 dot() 그림을<NAME>고 처음부터 다시 그려 볼게요. # 재설정 reset() # r 만큼 이동해서 그리기 준비 up(); forward(r); down(); left(90) # 반지름이 r인 원 그리기 circle(r) # 한 변의 길이가 r의 두 배인 정사각형 그리기 for i in range(4): forward(r); left(90); forward(r) # 자취를 남기지 않기 penup() # 점 30개 찍기 for i in range(30): draw_random_dot() # 거북이 숨기기 hideturtle() 문제 점이 원 안에 있는지 검사하는 건 해결했으니, 이제 변수를 만들어서 점이 원 안에 있으면 변숫값을 증가시키라고 하면 되겠네요. 그 부분은 여러분이 직접 코딩해서 완성해 주세요. 풀이 ch05/montecarlo.py 참고 https://ko.wikipedia.org/wiki/원주율 https://en.wikipedia.org/wiki/Pi Estimating π using the Monte Carlo Method tip 몬테카를로 방법의 유래 몬테 카를로(Monte-Carlo)는 도시국가인 모나코 북부에 있는 지역으로서 카지노, 도박으로 유명한 곳이기도 하다. 수학에서 확률이론의 탄생이 원래 도박에서 비롯되었는데, 과거 도박 도시의 대명사였던 몬테카를로 역시 지금은 확률론과 밀접한 관계가 있는 과학적 방법론을 지칭하기도 한다. 오늘날 다양한 과학기술 분야의 컴퓨터 시뮬레이션, 예측 등에 빈번히 쓰이는 몬테카를로 방법이 적용된 매우 유명한 역사적 사례로서, 미국의 원자폭탄 개발 계획인 맨해튼 프로젝트를 들 수 있다. 바로 몬테카를로 방법이라는 이름이 처음 쓰이게 된 계기이기도 하다. 즉 폴란드 출신의 수학자 스태니슬로 울람(Stanisław Marcin Ulam, 1909-1984)은 컴퓨터의 아버지로 잘 알려진 폰 노이만(Johann Ludwig von Neumann, 1903-1957) 등과 함께 맨해튼 프로젝트에 참여하였다. 예전부터 노이만의 동료였던 울람은 극비의 코드명에 적합하도록 새로운 수학적 방법론을 도박의 도시 이름을 따서 몬테카를로 방법이라 명명하였고, 이 방법은 중성자가 원자핵과 충돌하는 과정을 이해하고 묘사하는 데에 결정적 역할을 하였다. -<NAME>, 〈몬테 카를로 방법과 인공지능〉, ⟪사이언스 타임스⟫ 6. 파일 파이썬으로 파일을 다루는 법을 알아봅니다. 이 장에서 배우는 것: 텍스트 파일 한 줄씩 다루기 파일을 입맛대로(pickle, glob, os.path) 응용 예제: 음성 인식을 활용한 일본어 퀴즈 6.1 텍스트 파일 이번 시간에는 파일을 다루는 방법을 알아보겠습니다. 파일명을 바꾼다거나, 파일을 복사하고,<NAME>는 일들은 지난 시간에 살펴본 os 모듈이나, shutil이라는 모듈을 사용하면 되죠. 지금 배울 것은 그런 것이 아니라 파일의 내용을 읽고, 쓰는 방법입니다. 파일을 다룰 수 있게 되면 프로그램과 데이터를 따로 관리할 수 있지요. 만약 주소록 프로그램을 만든다면 연락처를 담은 데이터 파일을 따로 만들어두었다가, 새 친구가 생길 때마다 그 데이터 파일에 연락처를 추가해 주면 되겠죠? 먼저 메모장으로 텍스트 파일 하나를 만들어봅시다. Programming is fun. Very fun! You have to do it yourself... 각자 파이썬 스크립트를 저장하기 위한 폴더를 만들어두셨을 거예요. 거기에다가 Python_for_Fun.txt와 같은 이름으로 저장해 주세요. 그러고 나서 아래 예제를 따라 해보세요. 폴더와 파일의 이름은 각자 지으신 대로 써주시고요. >>> f = open('C:\\python_newbie\\Python_for_Fun.txt') >>> f.read() 'Programming is fun.\nVery fun!\n\nYou have to do it yourself.' 파일을 열어서 f라는 이름을 붙여주고 다시 그것을 읽었죠? 여러분도 잘 읽어지나요? 그런데, 좀 이상한 것이 있죠? 아까 파일을 작성할 때 줄을 바꿔가면서 썼던 것이 모두 한 줄에 나옵니다. 쓴 적이 없는 글자도 끼어 있고요. 잘 보면 줄을 바꾼 곳마다 '\n'이 들어있다는 것을 알 수 있지요. '\n'은 다음과 같이 문자열을 출력할 때 '줄 바꿈'을 의미한답니다. >>> print('야호~ 호야~') 야호~ 호야~ 우리가 메모장에서 텍스트 파일을 작성할 때에도 줄을 바꿀 때마다 이런 개행 문자가 포함되었던 것이지요. 위에서는 f.read() 함수가 돌려준 문자열을 그대로 보았기 때문에 우리가 개행 문자도 볼 수 있었던 것이고, 이 문자열을 print 하면 정상적으로 줄 넘김이 된 상태로 보입니다. >>> buffer = f.read() >>> print(buffer) Programming is fun. Very fun! You have to do it yourself... 이번엔 파일에 글을 써볼까요? >>> letter = open('C:\\python_newbie\\letter.txt', 'w') # 새 파일 열기 >>> letter.write('Dear Father,') # 아버님 전 상서 >>> letter.close() # 닫기 이번엔 파일명 뒤에 'w'라고 써주었죠? 아까 파일의 데이터를 읽기만 했을 때와는 달리, 파일에 데이터를 쓰려고 할 때는 미리 '파일에 데이터를 쓰겠다'라는 사실을 알려줄 필요가 있기 때문입니다. 그다음에 몇 자 적어주고 나서 파일을 닫았습니다. 이제 해당 폴더를 보시면 letter.txt 파일이 있고요, 그걸 메모장으로 열어보시면 파이썬으로 써준 글자가 고스란히 적혀있을 거예요. 훌륭하죠? 만약, 파일에 데이터를 쓴 다음에 close()로 닫아주지 않았으면 메모장으로 봐도 아무 글자도 없을 거예요. 그러니 꼬옥~ 닫아주셔야 해요~. 예리하신 분들은 그전의 예제에서 파일을 읽었을 때는 왜 안 닫았는지 궁금해하시겠죠? 닫아주면 좋답니다.^^ 하지만 우리가 잊어버리더라도 파일이 더 이상 필요 없으면 파이썬이 알아서 닫아준다고 하네요. 참 편하죠? 혹시 letter.txt가 아니라 python.txt 파일에다가 'Dear Father'라고 쓰신 분 계시나요? 분명히 계실 것 같은데… 원래 들어있던 내용이 다 날아갔죠? 시키는 대로 안 하니까 그렇죠. 히히히 하지만, 전 시키는 대로만 하는 사람은 싫어합니다. 잘 하셨어요. 파일에 데이터가 원래 들어있을 때 'w' 모드로 파일을 열면 원래 있던 데이터가 없어져 버린답니다. 파일에 들어있는 데이터를<NAME>지 않고 내용을 추가하려면 'a+' 모드를 지정해 줘야 하죠. >>> letter = open('C:\\python_newbie\\letter.txt', 'a+') >>> letter.write('\n\nHow are you?') >>> letter.close() 이제 letter를 다시 열어보시면 제대로 되어있을 거예요. 오늘 배운 것은 간단하면서도 아주 쓸모 있답니다. 이것을 가지고 무엇을 할 수 있을지 한번 생각해 보세요. 6.2한 줄씩 다루기 지난 시간에 이어 오늘도 텍스트 파일을 괴롭혀 보겠습니다. 오늘은 한 줄씩 난도질을… --+ 파이썬이 설치된 디렉터리에 있는 LICENSE.txt 파일을 열어보겠습니다. >>> import os >>> os.getcwd() 'C:\\Users\\Yong Choi\\AppData\\Local\\Programs\\Python\\Python38-32' >>> os.listdir() ['DLLs', 'Doc', 'img_read.py', 'include', 'Lib', 'libs', 'LICENSE.txt', 'NEWS.txt', 'python.exe', 'python3.dll', 'python38.dll', 'pythonw.exe', 'Scripts', 'tcl', 'Tools', 'vcruntime140.dll'] >>> f = open('LICENSE.txt') 파일을 처음부터 끝까지 읽을 땐 read()를 썼죠? 한 줄씩 읽을 때는 readline()을 사용하면 됩니다. 첫 줄을 읽어볼게요. >>> f.readline() 'A. HISTORY OF THE SOFTWARE\n' 다음 줄도 읽어볼까요? >>> f.readline() '==========================\n' 간단하죠? 별것 아닙니다. 파일 내용을 처음부터 한 글자씩 주르륵~ 읽어나가다가 '\n'이 나타나면 한 줄이 끝난 줄 알고 딱 멈춰 서게 되는 겁니다. 다음과 같이 반복 문과 readline()을 함께 사용해 텍스트를 원하는 줄 수만큼만 읽어들일 수 있답니다. >>> for x in range(5): ... f.readline() ... '\n' 'Python was created in the early 1990s by Guido van Rossum at Stichting\n' 'Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands\n' "as a successor of a language called ABC. Guido remains Python's\n" 'principal author, although it includes many contributions from others.\n' 파일을 한 줄씩 읽어 화면에 출력하기를 다섯 번 되풀이했지요. 이번엔 똑같이 다섯 줄을 읽기는 하지만 조금 다르게 하는 방법을 보여드리겠습니다. >>> f = open('LICENSE.txt') >>> lines = f.readlines() >>> lines[:2] ['A. HISTORY OF THE SOFTWARE\n', '==========================\n'] 여기서는 'readline'에 's' 자가 붙은 readlines()를 사용했습니다. readlines()로 파일을 읽으면 한 줄, 한 줄이 각각 리스트의 원소로 들어갑니다. 위에서는 파일 전체가 lines라는 리스트에 쏙 담겼습니다. 그런 다음엔 lines에 들어있는 것들을 입맛대로 꺼낼 수 있습니다. 이 방법을 쓰면 아주 쉽게 원하는 줄을 읽어들일 수 있겠죠? 26번째 줄부터 40번째 줄까지를 읽어볼까요? >>> for l in lines[26:41]: ... print(l, end='') ... Release Derived Year Owner GPL- from compatible? (1) 0.9.0 thru 1.2 1991-1995 CWI yes 1.3 thru 1.5.2 1.2 1995-1999 CNRI yes 1.6 1.5.2 2000 CNRI no 2.0 1.6 2000 BeOpen.com no 1.6.1 1.6 2001 CNRI yes (2) 2.1 2.0+1.6.1 2001 PSF no 2.0.1 2.0+1.6.1 2001 PSF yes 2.1.1 2.1+2.0.1 2001 PSF yes 2.1.2 2.1.1 2002 PSF yes 2.1.3 2.1.2 2002 PSF yes 2.2 and above 2.1.1 2001-now PSF yes >>> 왜 26:40이 아니라 26:41이라고 하는지 아리송하신 분은 문자열과 리스트 강좌를 복습하셔야겠네요. 오늘의 하이라이트! 끝에서 열 줄을 읽어봅시다. 대체 어떻게 해야 할까요? 파이썬 튜토리얼을 살펴보시면 직접 알아내실 수도 있는데… 힌트라도 드릴까요? 리스트에서 맨 마지막 원소의 인덱스는 -1이랍니다. 그게 무슨 말이지… 한번 도전해 보세요. 성공하신 분은 다음과 같은 결과를 볼 수 있을 거예요~ Parts of this software are based on the Tcl/Tk software copyrighted by the Regents of the University of California, Sun Microsystems, Inc., and other parties. The original license terms of the Tcl/Tk software distribution is included in the file docs/license.tcltk. Parts of this software are based on the HTML Library software copyrighted by Sun Microsystems, Inc. The original license terms of the HTML Library software distribution is included in the file docs/license.html_lib. 6.2.1 연습 문제: 밴드 이름 짓기 (2) 문제 색이름과 음식 이름을 담은 텍스트 파일을 읽어서 밴드 이름을 지어 주는 프로그램을 만들어 보세요. 텍스트 파일을 만들려면 아래 링크를 오른쪽 클릭하고 [다른 이름으로 링크 저장]을 선택합니다. 텍스트 파일과 파이썬 파일을 같은 폴더에 두세요. 색이름 1: color.txt (https://raw.githubusercontent.com/ychoi-kr/wikidocs-chobo-python/master/ch06/color.txt) 음식 이름 2: food.txt (https://raw.githubusercontent.com/ychoi-kr/wikidocs-chobo-python/master/ch06/food.txt) $ python bandname2.py 아이보리 떡국 $ python bandname2.py 미드나이트 블루 빙수 $ python bandname2.py 미디엄터콰이즈 깍두기 $ python bandname2.py 플럼 머스터드 $ python bandname2.py 라이트 그레이 디저트 $ python bandname2.py 씨쉘 계란덮밥 코드: ch06/bandname2.py https://supervitamin.tistory.com/76 ↩ https://ko.wiktionary.org/wiki/분류:한국어_음식 ↩ 6.2.2 연습 문제: 비밀 메시지 제2차 세계대전이 한창이던 1943년 미국 로스앤젤레스의 집배원은 엽서 한 장을 집어 들었습니다. 보낸이는 일본의 전쟁 포로수용소에 수감돼 있던 미군 프랭크 조넬리스, 받는 이는 페더럴 빌딩 회사 1619호의 F.B.Iers 씨로 적혀 있었습니다. 회사도 사람도 실제로 존재하지 않았지만, 해당 주소의 619호에는 연방수사국(FBI) 사무실이 있었습니다. (그림 출처: http://informatik.rostfrank.de/info/lex09/lex0903.html) 엽서의 내용은 다음과 같습니다. August 29, 1943 Dear Iers: After surrender, health improved fifty percent. Better food etc. Americans lost confidence in Philippines. Am comfortable in Nippon. Mother: Invest 30%, salary, in business. Love (signed) Frank G. Jonelis "항복 후, 건강이 50% 나아졌다. 좋은 음식 등. 미국인은 필리핀에서 자신감을 잃었다. 일본에서 편안하다. 어머니: 30% 투자, 봉급, 사업에. 사랑해" 문장이 약간 어색하긴 했지만 별다른 내용이 없어 보였습니다. 그렇지만 연방수사국에서는 여기에 다른 메시지가 숨겨져 있을지 모른다고 생각해 여러 가지 방법으로 단어를 배열해 보다가, 각 줄의 첫 두 단어를 문장 부호 없이 조합하면 다음의 문장을 만들 수 있다는 것을 알아냈습니다.(마지막 단어 생략) AFTER SURRENDER FIFTY PERCENT AMERICANS LOST IN PHILIPPINES IN NIPPON 30% "항복한 후 필리핀에서 50% 일본에서 30%의 미군을 잃었다" 문제 텍스트 편집기를 사용해 위의 엽서 내용을 postcard.txt 파일에 저장합니다. 1. 파일 읽기 postcard.txt 파일을 읽어 화면에 출력하세요. 2. 본문 추려내기 엽서 내용은 머리말, 본문, 꼬리말 형태로 되어 있고 그 사이는 한 줄씩 띄어져 있습니다. 본문 내용만 화면에 출력하세요. 출력 After surrender, health improved fifty percent. Better food etc. Americans lost confidence in Philippines. Am comfortable in Nippon. Mother: Invest 30%, salary, in business. Love 3. 문장부호 제거 본문에서 마침표(.), 쉼표(,), 콜론(:)을 제거해 출력하세요. 출력 After surrender health improved fifty percent Better food etc Americans lost confidence in Philippines Am comfortable in Nippon Mother Invest 30% salary in business Love 4. 대문자로 변환 3번의 출력 결과를 모두 대문자로 나타내세요. 출력 AFTER SURRENDER HEALTH IMPROVED FIFTY PERCENT BETTER FOOD ETC AMERICANS LOST CONFIDENCE IN PHILIPPINES AM COMFORTABLE IN NIPPON MOTHER INVEST 30% SALARY IN BUSINESS LOVE 5. 비밀 메시지 출력 4번의 결과에서 각 행의 처음 두 단어만 추려서 출력하세요. AFTER SURRENDER FIFTY PERCENT AMERICANS LOST IN PHILIPPINES IN NIPPON 30% SALARY 엽서 내용: ch06/postcard.txt 파이썬 코드: ch06/secret_message.py 참고 루돌프 키펜한 지음 / 이일우 옮김, 《암호의 해석》 6.2.2. 연습 문제: 끝말잇기 (3) 끝말잇기를 하는 프로그램을 작성하세요. 컴퓨터와 사용자는 텍스트 파일에 있는 단어를 사용해야 합니다. 다음 주소의 파일을 다운로드해서 사용하세요. 1 https://raw.githubusercontent.com/ychoi-kr/wikidocs-chobo-python/master/ch06/korean_words.txt 그 밖의 규칙은 끝말잇기 (2)와 같습니다. 풀이 코드: ch06/wordgame3.py ⟪ Frequency lists by Neri ⟫ 블로그의 The 2000 Most Frequently Used Korean Nouns를 구글 스프레드시트로 가공한 뒤 수작업으로 손질하고 단어도 좀 더 추가했습니다. ↩ 6.2.3 연습 문제: 영어 퀴즈 문제 ko_en.txt 파일에는 우리말과 영어 문장이 탭으로 구분되어 있습니다.(예문 출처: https://youtu.be/5AGUHrzYzgw) 이 파일을 이용해 영어 퀴즈를 내는 프로그램을 작성하세요. 화면에 우리말로 된 문장을 출력한 다음, 사용자에게 영어 문장을 입력받고, 사용자가 답을 맞혔는지 화면에 표시합니다. 예: Write the following sentence in English. 그녀는 작가가 아니다. your answer: She is not a writer. result: Correct! ---------------------------------------------------------------------- Write the following sentence in English. 그들은 교실에 있다. your answer: They are in the classroom. result: Correct! ---------------------------------------------------------------------- Write the following sentence in English. 너는 집에 있다. your answer: I am home. result: Not correct! right answer:You are home. 코드: ch06/english_quiz.py 6.3 파일을 입맛대로(pickle, glob, os.path) 파일을 입맛대로 요리할 수 있도록 여러 가지 비법을 전수해 드리지요. pickle 먼저 조금 복잡한 자료를 파일에 쓰고 읽는 방법부터 알아봅시다. 이럴 때는 pickle 이란 모듈을 사용합니다. 피자 먹을 때 나오는 피클과 이름이 같네요.^^ 예제로는 회원의 ID와 비밀번호를 파일에 저장하는 것을 생각해 보았습니다. 실제로 서비스를 만든다면 암호화해서 저장해야겠지만, 여기서는 평문(plain text)으로 저장할게요. >>> users = {'kim':'3kid9', 'sun80':'393948', 'ljm':'py90390'} >>> f = open('users', 'wb') >>> import pickle >>> pickle.dump(users, f) >>> f.close() 처음에 ID와 비밀번호를 users라는 딕셔너리에 담았습니다. 그리고 users라는 파일을 새로 열어서 f라는 이름을 붙였고요. 이때 open() 함수의 두 번째 인자인 wb는 일반 텍스트가 아닌 바이트(byte)<NAME>으로 쓰겠다(write)는 뜻입니다. 그다음에는 pickle 모듈의 dump()를 사용했습니다. 공사장에 흙을 실어 나르는 덤프트럭이 뒤쪽 짐칸을 들어 올려서 흙을 와르르 쏟아내는 것처럼, dump는 users라는 리스트를 파일 f에 기록합니다. 파이썬이 실행되는 경로에 users 파일이 만들어진 것을 볼 수 있을 거예요. 윈도 탐색기에서 확인해도 되지만, 아래와 같이 파이썬 셸에서 os.path.exists()로 확인할 수도 있어요. >>> import os >>> os.path.exists('users') True 이제 이 파일 내용을 파이썬에서 읽어들여 볼까요? >>> f = open('users', 'rb') >>> a = pickle.load(f) >>> print(a) {'sun80': '393948', 'kim': '3kid9', 'ljm': 'py90390'} 사실 방금 보여드린 것은 그리 복잡할 것도 없지만, pickle 모듈은 파이썬에서 만들어지는 것은 뭐든지 다 파일에 적을 수 있다고 합니다. 피클은 이쯤 해두고, 전에 잠깐 구경했던 glob 모듈을 알아보도록 하죠. glob glob는 파일들의 리스트를 뽑을 때 사용하는데, 파일의 경로명을 이용해서 입맛대로 요리할 수 있답니다. >>> from glob import glob >>> glob('*.exe') # 현재 디렉터리의. exe 파일 ['python.exe', 'pythonw.exe'] >>> glob('*.txt') # 현재 디렉터리의. txt 파일 ['LICENSE.txt', 'NEWS.txt'] 위의 glob() 함수는 인자로 받은 패턴과 이름이 일치하는 모든 파일과 디렉터리의 리스트를 반환합니다. 패턴을 그냥 *라고 주면 모든 파일과 디렉터리를 볼 수 있어요. 현재 경로가 아닌 다른 경로에 대해서도 조회할 수 있습니다. >>> glob(r'C:\U*') # C:\에서 이름이 U로 시작하는 디렉터리나 파일을 찾기 ['C:\\Users', 'C:\\usr'] 위에서는 r로 시작하는 원시(raw) 문자열을 사용한 것에 유의하세요. os.path 다음은 glob과 함께 os.path 모듈을 사용한 예제입니다. from glob import glob from os.path import isdir for x in glob('*'): if isdir(x): # 디렉터리인가? print(x, '<DIR>') else: print(x) 어떤 일을 하는 코드인지 짐작이 가시는지요? glob('*')을 사용해 얻은 리스트의 원소 x를 하나씩 출력하되, 그것이 디렉터리이면 <DIR>이라는 문자열을 뒤에 붙여서 출력하게 했답니다. 실행 결과는 다음과 같습니다. DLLs <DIR> Doc <DIR> img_read.py include <DIR> Lib <DIR> libs <DIR> LICENSE.txt NEWS.txt python.exe python3.dll python38.dll pythonw.exe Scripts <DIR> tcl <DIR> Tools <DIR> vcruntime140.dll 6.3.1 연습 문제: 애국가 문제 korean_national_anthem_1.txt 파일에는 애국가 1절 가사가 있습니다. 동해 물과 백두산이 마르고 닳도록 하느님이 보우하사 우리나라 만세. 무궁화 삼천리 화려 강산 대한 사람, 대한으로 길이 보전하세. 마찬가지로 4절까지의 가사가 텍스트 파일에 나뉘어 저장되어 있습니다. korean_national_anthem_2.txt korean_national_anthem_3.txt korean_national_anthem_4.txt 이 파일들을 읽어 out.txt 파일에 다음과 같이 저장하는 파이썬 스크립트를 작성하세요. korean_national_anthem_1.txt ---------------------------- 동해 물과 백두산이 마르고 닳도록 하느님이 보우하사 우리나라 만세. 무궁화 삼천리 화려 강산 대한 사람, 대한으로 길이 보전하세. korean_national_anthem_2.txt ---------------------------- 남산 위에 저 소나무, 철갑을 두른 듯 바람서리 불변함은 우리 기상일세. 무궁화 삼천리 화려 강산 대한 사람, 대한으로 길이 보전하세. korean_national_anthem_3.txt ---------------------------- 가을 하늘 공활한데 높고 구름 없이 밝은 달은 우리 가슴 일편단심일세. 무궁화 삼천리 화려 강산 대한 사람, 대한으로 길이 보전하세. korean_national_anthem_4.txt ---------------------------- 이 기상과 이 맘으로 충성을 다하여 괴로우나 즐거우나 나라 사랑하세. 무궁화 삼천리 화려 강산 대한 사람, 대한으로 길이 보전하세. 코드: ch06/text_file_merge.py 6.4 응용 예제: 음성 인식을 활용한 일본어 퀴즈 요즘 일본어 공부를 다시 시작했습니다. 옛날에 잠깐 배운 적이 있지만 너무 오래돼서 히라가나도 잊어버렸어요. ㅠ 그래서 일본어 공부를 도와주는 프로그램을 파이썬으로 만들어 보려고 합니다. 구현하려는 기능은 단순합니다. 화면에 일본어로 출력된 단어를 읽으면, 마이크로 소리를 받아서 맞게 읽었는지 알려주는 것이죠. 음성(speech)을 텍스트(text)로 바꿔주는 기능을 구현할 수 있다면 영어 퀴즈 연습 문제와도 크게 다르지 않습니다. 파이썬으로 음성을 텍스트로 바꾸는 방법을 검색해 보니 SpeechRecognition이라는 패키지가 있네요. 이것을 설치하고 간단히 테스트해 보겠습니다. 준비 아나콘다 가상환경 생성 저는 아나콘다 가상 환경을 만들어서 작업했습니다. 아나콘다 프롬프트에서 다음 명령을 실행합니다. conda create -n japanese_study Python=3.8 conda activate japanese_study SpeechRecognition 설치 pip로 SpeechRecognition 패키지를 설치합니다. pip install SpeechRecognition PyAudio 설치 SpeechRecognition에서 마이크를 사용하려면 PyAudio도 필요합니다. Windows에는 다음 명령으로 설치합니다. pip install pipwin pipwin install pyaudio macOS에는 다음 명령으로 설치합니다. FLAC도 함께 설치합니다. xcode-select --install brew remove portaudio brew install portaudio brew install flac pip install pyaudio 마이크 테스트 파이썬 셸을 실행하고, 앞에서 설치한 패키지들이 잘 작동하는지 확인합니다. >>> import speech_recognition as sr >>> sr.__version__ '3.7.1' >>> r = sr.Recognizer() >>> mic = sr.Microphone() 영어: >>> with mic as source: ... audio = r.listen(source) ... >>> r.recognize_google(audio) 'hello how are you' 영어가 잘 인식된다면 한국어와 일본어도 별문제 없이 잘될 거예요. 한국어: >>> with mic as source: ... audio = r.listen(source) ... >>> r.recognize_google(audio, language="ko-KR") '아 아 마이크 테스트 하나 둘 셋' 일본어: >>> with mic as source: ... audio = r.listen(source) ... >>> r.recognize_google(audio, language="ja") 'おはようございます' 프로그램 작성 여기까지 잘 되는 것을 확인했으니 이제 프로그램을 작성해 보겠습니다. 데이터 파일 데이터 파일은 와세다 대학교 일본어 기초 수업 영상을 참고해서 제가 직접 작성했습니다. 처음에는 히라가나와 영어 발음만 넣었는데, 나중에 테스트하다 보니 음성인식 결과는 주로 한자로 나오는 것을 알게 되었습니다. 그래서 히라가나, 한자어, 영어 발음의 데이터 형태가 되었습니다. 파일: ch06/japanese_word.csv 파이썬 코드 코드는 다음과 같습니다. 코드: ch06/japanese_quiz.py import random import time import speech_recognition as sr f = open('japanese_words.csv', encoding='utf-8') lines = f.readlines() random.shuffle(lines) r = sr.Recognizer() mic = sr.Microphone() for line in lines: hiragana, kanji, pronunciation = line.split(',') correct = None # 틀리면 맞힐 때까지 같은 단어를 반복 while not correct: if correct is None: print('Read this word!:') else: print('Let\'s try again:') print(hiragana) # 답을 생각하느라 머뭇거리고 있으면 음성 인식이 종료되어 버려서 # 엔터 키 입력 후부터 인식하게 하려고 넣었습니다. input('Press Enter when you ready and then read it ...') with mic as source: audio = r.listen(source) a = r.recognize_google(audio, language='ja') print('Your answer:', a) if kanji == a: correct = True print('You\'re right!') else: correct = False print(hiragana, 'is pronounced', pronunciation) print('-' * 20) time.sleep(2) 실행 결과: (japanese_study) C:\wikidocs-chobo-python\ch06>python japanese_quiz.py Read this word!: さかな Press Enter when you ready and then read it ... Your answer: たかな さかな is pronounced sakana Let's try again: さかな Press Enter when you ready and then read it ... Your answer: 魚 You're right! -------------------- Read this word!: あさ Press Enter when you ready and then read it ... Your answer: 羽田 あさ is pronounced asa Let's try again: あさ Press Enter when you ready and then read it ... Your answer: 羽田 あさ is pronounced asa Let's try again: あさ Press Enter when you ready and then read it ... Your answer: 朝 You're right! -------------------- Read this word!: かお Press Enter when you ready and then read it ... Process finished with exit code -1 테스트 영상: https://youtu.be/AqWlbhSk7A8 참고 다음 문서를 참고했습니다. https://realpython.com/python-speech-recognition/ https://stackoverflow.com/a/59048571/1558946 7. 객체지향 객체지향(Object-Oriented) 프로그래밍을 파이썬에서는 어떻게 할 수 있는지 알아봅시다. 이 장에서 배우는 것: 클래스와 인스턴스 변수와 메서드 상속 객체 속의 객체 특별한 메서드들 7.1. 클래스(class)와 인스턴스 객체지향 개념이 나타나기 이전의 프로그래밍 방법에서는 프로그램이 어떤 일을 하고 나서, 그다음엔 어떤 일을 하고, 또 그다음엔 뭘 하라는 식으로 컴퓨터가 해야 할 일을 알려주기에 바빴습니다. 그런데 객체지향 프로그래밍(Object-Oriented Programming)에서는 프로그램을 작성할 대상이 되는 실제 세계의 사물(객체)을 그대로 표현하고, 그것들이 어떻게 움직이는지 정해주고 나서야 비로소 그 객체들에게 일을 시킵니다. 객체지향 프로그래밍을 잘 사용하면 보다 좋은 프로그램을 빨리 만들 수 있고, 나중에 수정하기도 편해진다고 합니다. 프로그래밍 언어들이 모두 객체지향적인 것은 아니지만, 요즘에 널리 사용되는 언어 중에는 객체지향을 지원하는 것이 많습니다. 파이썬은 꼭 객체지향적으로 작성하지 않아도 됩니다. 다시 말씀드려서, 앞으로의 강좌를 보지 않으셔도 간단한 프로그램을 작성하는 데 문제가 없다는 것이죠. 하지만 객체지향에 대해 이해하시고 나면 파이썬으로 윈도 프로그래밍을 하거나, 복잡한 프로그램을 작성하는 데 많은 도움이 된답니다. 또, 다른 프로그래밍 언어를 이해하기도 수월해지지요. 그럼 함께 시작해 볼까요? 클래스? 인스턴스? ‘김연아’는 실제로 존재하죠? 네, 여러분이 생각하시는 그 김연아 맞아요. ㅎㅎ ‘김동성’도 실제로 존재하죠? 두 사람 다 실제로 존재하는 사람입니다. 두 사람의 공통점은 무엇일까요? 여러 가지를 들 수 있겠지만 둘 다 ‘스케이터’라는 공통점을 갖고 있지요. ‘스케이터’라는 단 하나의 사람이나 물건이 실제로 존재할까요? 그렇지는 않습니다. 하지만 우리는 ‘스케이트 타는 사람’을 ‘스케이터’라고 부릅니다. 이런 것을 일컫는 말이 클래스(class)입니다. 우리말로 옮기기는 쉽지 않지만 ‘부류’라는 의미로 생각하시면 좋을 것 같아요. 다른 예를 들어볼까요? ‘사과’는 클래스이고요, ‘내가 엊저녁에 먹은 사과 다섯 개 중에 두 번째 것’이라고 콕 찍어서 말해주면 실체(instance)로 봐줄 만합니다. ‘좋은 집’은 실체일까요? 어느 한 집만을 콕 찍어서 ‘좋은 집’이라고 하기는 힘들 것 같군요. 그럼 ‘우리 집’은 실체일까요? 그건 실체라고 해도 될 것 같네요. 단, 집을 여러 채 가진 사람이 ‘우리 집’이라고 말할 때는 정확히 어느 집을 가리키는 것인지 알 수 없겠죠. 프로그램 작성을 위해 클래스를 설계하다 보면 이런 애매한 문제를 만날 때도 있지요. 파이썬의 클래스 이제 파이썬으로 부류와 실체를 표현해 보겠습니다. >>> class Singer: # 가수를 정의하겠느니라… ... def sing(self): # 노래하기 메서드 ... return "Lalala~" ... >>> taeji = Singer() # 태지를 만들어라! >>> taeji.sing() # 노래 한 곡 부탁해요~ 'Lalala~' 클래스를 만들 때는 위와 같이 class 클래스 이름:<NAME>으로 시작해서 그다음부터 그 클래스의 성질이나 행동을 정의해 주면 됩니다. 둘째 줄에는 함수가 정의되어 있죠? 이와 같이 클래스 내부에 정의된 함수를 메서드(method)라고 부릅니다. 여기서 sing 메서드는 Singer라는 클래스가 하는 행동을 정의하고 있죠. Singer 클래스를 만든 다음에는 taeji라는 객체를 만들었습니다. 인스턴스명 = 클래스()와 같이 만들면 되죠. 그다음엔 그렇게 만들어진 taeji에게 노래를 시켜봤습니다. Singer 클래스에 sing 메서드를 정의해 줬기 때문에 Singer 클래스에 속한 taeji 객체도 sing 메서드를 사용할 수 있지요. 다시 말해서 가수는 노래할 수 있으니까 태지라는 가수도 역시 노래를 할 수 있는 것입니다. 이와 같이 어떤 객체의 메서드를 사용할 때는 객체. 메서드<NAME>으로 해주시면 됩니다. 이번엔 같은 방법으로 리키 마틴 객체를 만들어서 노래를 청해보세요. >>> ricky = Singer() >>> ricky.sing() 'Lalala~' 다른 클래스들도 한 번씩 만들어보시기 바랍니다. 7.2. 변수와 메서드 지난 시간에 클래스와 객체가 무엇인지 잠깐 살펴보았죠? 실제 세계에 존재하는 실체(instance)를 객체(object)라고 하고, 객체들의 공통점을 간추려서 개념적으로 나타낸 것이 클래스(class)라고 했습니다. 어떤 클래스를 만들려면 그 객체가 갖는 성질과 그 객체가 하는 행동을 정의해 주면 된다고도 했고요. 디아블로2 게임의 아마존이라는 캐릭터를 클래스로 표현해 볼까요? class Amazon: strength = 20 dexterity = 25 vitality = 20 energy = 15 def attack(self): return 'Jab!!!' 아마존 클래스가 갖고 있는 힘, 기술, 체력, 에너지라는 네 가지 성질은 변수로 나타내었고요, '공격'하는 행동은 메서드로 나타내었습니다. IDLE(Python GUI)에서 File - New Window 메뉴를 선택하여 새 창을 띄우고 위의 코드를 작성하여 diablo2.py라는 파일로 저장해 주세요. F5 키를 눌러 모듈을 실행한 다음, Shell 창으로 되돌아가서 diablo2 모듈을 임포트 한 다음, Amazon 클래스의 객체를 만들어 봅시다. >>> import diablo2 >>> jane = diablo2.Amazon() >>> mary = diablo2.Amazon() 두 명의 여전사가 탄생했습니다. 짜잔~ jane과 mary는 둘 다 Amazon으로서 필요한 자질을 모두 갖추고 있겠죠? 그렇다면 jane의 힘도, 공격하는 행동도 Amazon 클래스에서 정의한 그대로이겠고요. >>> jane.strength 20 >>> jane.attack() 'Jab!!!' 이렇게 객체는 클래스에서 정의해 준 변수와 메서드를 그대로 갖게 됩니다. 별로 어렵지 않죠? 여기서 주의해서 보실 것은 메서드를 정의할 때와 사용할 때는 차이가 있다는 점입니다. Amazon 클래스에서 메서드를 정의할 때는 def attack(self):와 같이 self라는 인자를 받았는데, jane 객체의 메서드를 호출할 때는 그냥 attack()이라고 했지요? tip IDLE에서 Run Module 안 될 때 해결 방법 https://yong-it.blog spot.com/2018/10/python-idle.html self self라는 것은 바로 그 클래스의 객체를 가리키는데, jane과 mary가 똑같은 attack 메서드를 가지기 때문에 서로 구별하기 위해서 사용한 것입니다. 한마디로, 메서드를 정의할 때는 항상 self라는 인자를 써준다고 생각하시면 되겠네요. self를 어떻게 사용하는지 좀 더 살펴보기 위해 Amazon 클래스에 메서드를 추가해 봅시다. def exercise(self): self.strength += 2 self.dexterity += 3 self.vitality += 1 이 메서드는 훈련을 하면 힘, 기술, 체력이 올라가는 것을 표현했지요. diablo2.py 파일의 Amazon 클래스에 이 메서드를 추가하고 저장해 주시기 바랍니다. 저장하셨으면 F5 키를 다시 한번 눌러서 diablo2 모듈을 다시 실행하고, 임포트도 해준 다음에, 새로운 객체를 만들어서 훈련을 시켜보세요. >>> import diablo2 >>> eve = diablo2.Amazon() >>> eve.exercise() >>> eve.strength 22 힘(strength)이 세졌네요. 훈련한 보람이 있지요? 7.3. 상속 지난 두 강좌를 통해 객체 지향에 대해 소개해 드렸는데, 여러분은 어떻게 느끼셨는지요. 개념적으로는 이해가 될 듯도 한데, 실제로 프로그램을 작성할 때는 어떻게 적용해야 할지 난감해 하시는 분이 많지 않을까 하는 생각도 드는군요. 사실 객체지향의 개념을 제대로 이해하고 활용하기까지는 시간이 좀 걸린답니다. 그러니까 너무 걱정하지 마시고 천천히, 여러 번 반복해서 공부하시기 바랍니다. 아무리 좋은 개념도 갑자기 많이 공부하면 오히려 헷갈리기 쉽지요. 그러니 제가 설명드리는 것부터 프로그램에 적용시켜 보면서 차근차근 공부하셨으면 합니다. 오늘 알아볼 내용은 객체지향 프로그래밍의 핵심적인 개념 가운데 하나인 상속(inheritance)입니다. 상속이란 어떤 클래스가 다른 클래스의 성질을 물려받는 것을 말하지요. 어떤 클래스를 만들 때 처음부터 모든 것을 새로 만들 필요 없이, 핵심적인 성질을 갖고 있는 다른 클래스로부터 상속을 받아서 조금만 손을 보면 쓸만한 클래스를 만들 수 있답니다. 예제를 보실까요? class Person: # 눈 두 개, 코 하나, 입 하나... eyes = 2 nose = 1 mouth = 1 ears = 2 arms = 2 legs = 2 # 먹고 자고 이야기하고... def eat(self): print('얌냠...') def sleep(self): print('쿨쿨...') def talk(self): print('주절주절...') 위의 Person이라는 클래스는 보통 사람을 나타낸 클래스입니다. 눈, 코, 입, 팔다리가 다 있고, 먹고, 자고 이야기도 하지요. 이번에는 학생이라는 클래스를 만들어 봅시다. 학생도 사람이니까 사람이 갖는 여러 성질이나 행동은 모두 갖고 있을 것이고, 거기에 학생만의 특징을 좀 더 갖도록 하면 되겠지요? 하지만, 사람 클래스도 한참 걸려서 입력했는데, 또다시 학생 클래스의 눈, 코, 입부터 시작해서 모든 것을 새로 만들어주려면 너무 귀찮겠네요. 바로 이럴 때 다음과 같이 상속을 이용하면 손쉽게 학생 클래스를 만들 수 있답니다. class Student(Person): # Person 클래스를 상속받음 def study(self): print('열공열공...') 위의 Student 클래스는 Person 클래스를 상속받았습니다. 우리가 Student 클래스를 눈, 코, 입부터 하나하나 다시 만들어 주지 않더라도 Person의 성질들을 모두 물려받아서 갖게 된 것이죠. 우리는 여기에 study라는 메서드만 하나 더 써주어서 우아하게 마무리를 했습니다. 굳이 상속을 받지 말고 스크립트를 복사해서 붙이면 되지 않느냐고요? 물론 그렇게 해도 가능합니다. 하지만 나중에 사람과 학생 클래스에 '옷 색깔'이라든지, '싸우다' 같은 것들을 추가하고 싶어진다면, 그때마다 사람 클래스와 학생 클래스를 각각 수정해야 되겠지요. 사람과 학생의 관계를 위와 같이 그림으로 표현할 수도 있습니다. 사각형은 각각의 클래스를 나타내고, 그 안에 클래스의 이름과 변수, 메서드를 적어주었습니다. 화살표는 '상속 관계'를 나타내고, 그 방향은 하위 클래스로부터 상위 클래스를 향합니다. 이 화살표를 따라가면서 'is a'라고 읽으면 두 클래스의 관계를 쉽게 파악할 수 있지요. "A Student is a Person.(학생은 사람이다)"이 되는군요. 클래스들의 관계를 이렇게 그림으로 그리면 클래스를 설계하거나 분석할 때 이해하기 쉽답니다. 그럼, 과연 Student 클래스가 Person 클래스의 모든 성질을 똑같이 갖고 있는 것인지도 확인해 보도록 하죠. 먼저 위의 예제들을 파일로 저장해서 import 하시거나, 그냥 인터프리터에서 입력하신 다음에 아래와 같이 테스트를 해보세요. >>> lee = Person() >>> lee.mouth >>> lee.talk() 주절주절... >>> kim = Student() >>> kim.mouth >>> kim.talk() 주절주절... Person 클래스의 객체인 lee와 Student 클래스의 객체 kim이 하는 짓들이 똑같지요? Person 클래스로부터 상속받았기 때문에 그렇다는 것을 아실 수 있겠죠? 그러나, 상속받은 것으로 끝이 아니지요… Student는 공부라는 비장의 카드도 갖고 있지 않았겠습니까? >>> kim.study() 열공열공... 역시 kim은 학생답게 공부도 열심히 하는군요… 7.3.1 메서드 상속과 재정의 이번에는 동물을 나타내는 클래스들을 만들어 볼게요. 코드: ch07/animal.py class 동물: def 울어(self): print('...') class 고양잇과(동물): pass class 호랑이(고양잇과): def 울어(self): print('어흥') class 고양이(고양잇과): def 울어(self): print('야옹') 이 클래스들의 상속 관계를 그림으로 나타내면 이렇습니다. animal.py 모듈이 있는 곳에서 파이썬 셸을 열어서 임포트 합니다. >>> import animal 나비라는 이름의 고양이를 만듭니다. (새로운 고양이 인스턴스를 만들므로 괄호를 붙여야 합니다.) >>> 나비 = animal. 고양이() 나비는 야옹 하고 울어요. >>> 나비. 울어() 야옹 이번에는 호돌이라는 호랑이를 만들어 볼까요? >>> 호돌이 = animal. 호랑이() >>> 호돌이. 울어() 어흥 수호랑이라는 이름의 호랑이도 만들어 보세요. isinstance() 위에서 만든 나비는 고양이 클래스의 인스턴스이고, 호돌이와 수호랑은 호랑이 클래스의 인스턴스입니다. 파이썬의 내장 함수인 isinstance()를 사용하면, 객체가 특정 클래스의 인스턴스인지 확인할 수 있어요. (이때는 인스턴스를 새로 만드는 것이 아니므로 animal. 고양이 뒤에 괄호를 붙이지 않습니다.) >>> isinstance(나비, animal. 고양이) True >>> isinstance(나비, animal. 호랑이) False 그런데 고양이는 고양잇과를 상속한 클래스이고, 고양잇과는 동물 클래스를 상속한 클래스였죠? 따라서 나비는 고양이 클래스의 인스턴스인 동시에, 고양잇과 클래스와 동물 클래스의 인스턴스입니다. >>> isinstance(나비, animal. 고양잇과) True >>> isinstance(나비, animal. 동물) True issubclass() A라는 클래스가 B라는 클래스의 하위 클래스(subclass)인지, 즉 A가 B를 상속했는지 알려면 issubclass()라는 내장 함수를 쓰면 됩니다. 앞에서 만든 고양이 클래스가 고양잇과와 동물 클래스의 하위 클래스인지 확인해 볼까요? >>> issubclass(animal. 고양이, animal. 고양잇과) True >>> issubclass(animal. 고양이, animal. 동물) True 울어() 메서드의 상속과 재정의 앞에서 동물 클래스에는 울어()라는 메서드가 있었는데, 고양잇과 클래스에는 메서드를 따로 만들지 않고 그냥 넘어갔었죠(pass). 보비라는 퓨마가 있다고 합니다. 퓨마 클래스가 따로 없으니 고양잇과 클래스의 인스턴스로 만들어 줄게요. >>> 보비 = animal. 고양잇과() 고양잇과 클래스에는 울어() 메서드를 정의하지 않았는데, 보비는 울 수 있을까요? >>> 보비. 울어() ... 고양잇과가 동물을 상속했으므로 울어() 메서드를 따로 만들어 주지 않았음에도 ... 이 출력되는 걸 볼 수 있습니다. 그런데 고양이와 호랑이에서는 동물의 울어()를 그대로 쓰지 않고 새로 정의해서 각기 다른 울음소리를 냈었죠? 이와 같이 메서드를 재정의(override) 할 수도 있습니다. 7.4. 객체 속의 객체 코끼리를 냉장고에 넣는 방법을 아시나요? 아마 모르시는 분이 없겠죠? 제가 아는 유머는 온 국민이 다 알고 계시니까요. 1번, 냉장고 문을 연다. 2번, 코끼리를 넣는다. 3번, 냉장고 문을 닫는다. ^^; 이걸로 프로그램을 한번 짜볼까요? class Fridge: def __init__(self): self.isOpened = False self.foods = [] def open(self): self.isOpened = True print('냉장고 문을 열었어요...') def put(self, thing): if self.isOpened: self.foods.append(thing) print('냉장고 속에 음식이 들어갔네...') else: print('냉장고 문이 닫혀있어서 못 넣겠어요...') def close(self): self.isOpened = False print('냉장고 문을 닫았어요...') class Food: pass 위와 같이 냉장고와 음식 클래스를 갖고 있는 fridge.py 모듈을 만들어보았습니다. 냉장고 클래스에는 문이 열려있는지를 나타내는 isOpened라는 변수와 냉장고 안에 들어있는 음식들의 리스트인 foods가 있습니다. 또, 냉장고 문을 열고, 음식을 집어넣고, 문을 닫는 메서드도 각각 갖고 있지요. 음식에 대해서는 별로 쓸 말이 없더군요. 쓸 것이 없을 때는 pass라고만 써주면 된다고 해서 그렇게 했습니다. 속이 빈 음식 클래스를 만든 거지요. 이제 인터프리터를 띄워서 냉장고에다가 코끼리를 집어넣어 봅시다. >>> import fridge >>> f = fridge.Fridge() >>> apple = fridge.Food() >>> elephant = fridge.Food() 먼저 냉장고 클래스의 객체로 f라는 것을 만들고 음식 클래스의 객체는 apple과 elephant를 만들었습니다. >>> f.open() 냉장고 문을 열었어요... >>> f.put(apple) 냉장고 속에 음식이 들어갔네... 냉장고 문을 열고, 일단 준비운동으로 냉장고에 사과를 넣어봤는데 잘 들어갔지요? 그럼 코끼리도 넣어볼까요? >>> f.put(elephant) 냉장고 속에 음식이 들어갔네... 코끼리도 쏙 들어갔습니다~ 냉장고 속에 사과랑 코끼리가 잘 들어갔는지 확인해 볼까요? 냉장고 f의 foods 리스트에 뭐가 들어있는지 봅시다. >>> f.foods [<fridge.Food instance at 007924AC>, <fridge.Food instance at 0079153C>] Food 클래스의 인스턴스(instance, 실체) 두 개가 들어있다고 나오는군요. 실체나 객체나 비슷한 말이겠죠? 자, 냉장고 객체는 foods라는 리스트를 갖고 있고요, foods 리스트는 음식 클래스의 사과와 코끼리 객체를 갖고 있습니다. 결국 냉장고 객체는 다른 객체들을 갖고 있다고도 할 수 있겠죠? 오늘 보신 것처럼 객체는 또 다른 객체를 포함할 수도 있답니다. 객체지향 프로그래밍에서는 이런 것을 composition(합성, 복합)이라고 하고요, 'has-a' 관계라고도 합니다. "f는 elephant를 갖고 있다(f has an elephant)." 말 되죠? 별로 어렵지는 않지만 잘 써먹을 수 있는 개념이니까 익혀두세요. 이렇게 해서 오늘의 임무인 객체 속에 객체 집어넣기는 훌륭하게 완수했군요. 참고로 'has-a' 관계를 나타낸 그림을 보여드리면서 마치도록 하겠습니다. Fridge 클래스의 객체는 Food 클래스의 객체(elephant 등…)를 여러 개(*) 가질 수 있다는 것을 연결선 위아래에 *와 elephant라고 써줘서 나타낸 것이지요. 7.5. 특별한 메서드들 이제 메서드에 대해서는 다들 알고 계시겠죠? 메서드라는 것은 우리가 클래스를 만들면서 그 안에 만들어 넣은 함수를 말하지요? 만들어진 메서드를 사용하려면 객체. 메서드()와 같은<NAME>으로 호출을 해주었고요. 오늘은 그런 일반적인 메서드들과는 조금 다른 특별한 메서드들에 대해 함께 알아보려고 합니다. __init__ 메서드 (초기화) # bookstore.py class Book: def setData(self, title, price, author): self.title = title self.price = price self.author = author def printData(self): print('제목 : ', self.title) print('가격 : ', self.price) print('저자 : ', self.author) def __init__(self): print('책 객체를 새로 만들었어요~') 예제로 Book(책) 클래스를 갖는 bookstore(책방) 모듈을 만들어 보았습니다. 책 클래스의 메서드로는 책 제목, 가격, 저자와 같은 자료들을 입력할 때 사용할 setData()와 이런 자료들을 출력해 주는 printData()를 만들어 주었지요. 그리고 __init__이라는 메서드도 있지요? 이것이 바로 파이썬에서 특별하게 약속된 메서드 가운데 하나로, 초기화(initialize) 메서드라고도 합니다. 어떤 클래스의 객체가 만들어질 때 자동으로 호출되어서 그 객체가 갖게 될 여러 가지 성질을 정해주는 일을 하지요. 그럼 책 클래스의 객체를 하나 만들어볼까요? >>> import bookstore >>> b = bookstore.Book() 책 객체를 새로 만들었어요~ Book() 해서 Book 객체를 만들자마자 초기화 메서드가 실행되었군요. 나머지 setData와 printData 메서드들은 다음과 같이 사용하시면 됩니다. >>> b.setData('누가 내 치즈를 먹었을까', '300원', '미키') >>> b.printData() 제목 : 누가 내 치즈를 먹었을까 가격 : 300원 저자 : 미키 이제 초기화 메서드가 뭔지 대충 감을 잡으셨으면 __init__ 메서드를 사용해서 실제로 객체를 초기화시켜보겠습니다. __init__ 메서드를 아래와 같이 수정해 보세요. def __init__(self, title, price, author): self.setData(title, price, author) print('책 객체를 새로 만들었어요~') 객체를 생성시킬 때 제목, 가격, 저자를 인자로 받아서, setData 메서드에게 넘겨주도록 했죠? 물론 초기화 메서드에서 직접 변수를 다뤄도 상관없지만 setData 메서드를 미리 만들어뒀으니까 이용을 한 것입니다. 이제부터 책 객체를 만들 때는 다음과 같이 세 개의 인자를 넘겨줘야 합니다. >>> from importlib import reload >>> reload(bookstore) >>> b2 = bookstore.Book('내가 먹었지', '200원', '미니') 책 객체를 새로 만들었어요~ 그런대로 쓸 만하죠? 값이 잘 들어갔는지도 확인해 보세요. 참고로 말씀드리면, 초기화 메서드와 같은 것을 다른 객체지향 언어에서는 생성자(constructor)라고 부른답니다. __del__ 메서드 (소멸자) __init__ 메서드와 반대로 객체가 없어질 때 호출되는 메서드도 있습니다. 이런 것을 소멸자(destructor)라고 하는데, 파이썬에서는 __del__ 메서드가 소멸자의 역할을 맡고 있죠. 객체가 없어지는 수도 있냐고요? 뭐하려고 없애냐고요? del 문을 사용해 보세요. 당장 없어집니다. 또, 만들어 둔 객체가 더 이상 필요 없어지면 파이썬이 알아서 처리해 주기도 하고요. 그건 직접 __del__ 메서드를 만들어서 테스트해 보시면 잘 아실 수 있겠죠? 그냥 다른 메서드와 똑같이 작성하시면 됩니다. 어떤 객체가 없어지기 전에 뭔가 처리를 필요로 한다면 소멸자가 유용하게 쓰이겠지요? __repr__ 메서드 (프린팅) 이번엔 printData와 같은 메서드를 호출하는 대신, 파이썬의 기본 문인 print 문을 사용해서 책 제목을 찍어보도록 하겠습니다. 이런 일을 가능하게 해주는 것은 바로 __repr__ 메서드이지요. 책 클래스에 아래와 같이 __repr__ 메서드를 추가해 주세요. def __repr__(self): return self.title 별다른 것은 없고요, return 문을 사용했다는 것만 눈여겨보시면 됩니다. __repr__ 메서드는 '문자열'을 'return' 한다고 생각하시면 되겠죠? 그럼 책방 모듈을 재적재하고 새 책을 만들어서 테스트해 보세요. >>> b3 = bookstore.Book('나도 좀 줘', '100원', '쥐벼룩') 책 객체를 새로 만들었어요~ >>> print(b3) 나도 좀 줘 __add__ 메서드 (덧셈) 이제 책방은 문을 닫고 세모, 네모, 동그라미 같은 도형을 만들어볼까요? # shape.py class Shape: area = 0 def __add__(self, other): return self.area + other.area 학교에서 도형에 대해 배울 때는 늘 넓이에 대해 생각을 하지요? 여기서는 두 도형의 넓이를 더하는 __add__ 메서드를 만들어보았습니다. 두 개의 객체 self와 other를 인자로 받아서 그 둘의 넓이를 더한 값을 돌려주는 일을 하도록 했지요. >>> a = shape.Shape() >>> a.area = 20 >>> b = shape.Shape() >>> b.area = 10 >>> a + b 30 도형 a와 b를 덧셈 연산자(+)로 더했더니 두 도형의 넓이가 더해졌죠? 마치 보통의 두 숫자를 더하는 것처럼 간단하게 말입니다. 이와 같이 특별한 메서드를 사용해서 연산자가 하는 일을 정의하는 것을 연산자 중복(overload)이라고 부른답니다. 연산자 중복을 이용하면 사용자가 직접 만든 클래스의 객체에 대해서도 연산자를 쓸 수 있게 되지요. 마치 파이썬 자체에서 제공하는 자료형처럼 말입니다. 아직도 사태의 심각성을 이해하지 못하고 "a + b가 뭐 어쨌길래? 원래 그냥 더하면 되는 거잖아~"라고 하시는 분들! -- Shape 클래스에 __add__ 메서드를 넣지 말고 객체 두 개를 만든 다음에 더해보세요. 지나가던 뱀이 웃습니다…--; 그리고 벌서 눈치채신 분도 있겠지만, 덧셈 연산자 대신 __add__ 메서드를 직접 호출해도 그 결과는 똑같답니다. >>> a.__add__(b) 30 그럼 도형 객체 간에 뺄셈도 할 수 있도록 __sub__ 메서드도 만들어보세요~. __lt__ 메서드 (비교) 이제 연산자 중복에 대해 어느 정도 감이 잡히시죠? 파이썬에서 제공하는 연산자 중복 메서드는 이외에도 많기 때문에 모두 살펴보기는 힘들겠네요. 마지막으로 두 개의 객체를 비교하는 비교 연산자(<, >, ==)를 쓸 수 있도록 해주는 메서드를 살펴보면서 이 부분을 정리하겠습니다. 일단 Shape 클래스에 아래와 같이 __lt__ 메서드를 추가해 주세요(‘less than’을 의미). def __lt__(self, other): return self.area < other.area 간단히 두 객체 self와 other의 area를 비교한 결과를 돌려주도록 했는데요, 이제 두 숫자를 비교하듯 두 객체를 부등호로 비교할 수 있습니다. shape 모듈을 재적재하고 새로운 객체들을 만들어서 각각 area 값을 정해 준 다음, 두 객체를 비교해 보겠습니다. >>> import shape >>> c = shape.Shape() >>> c.area = 30 >>> d = shape.Shape() >>> d.area = 20 >>> c > d True >>> if c > d: print('c가 더 넓어요~') ... c가 더 넓어요~ 비교가 잘 되나요? 오늘 강좌는 좀 길어졌군요. 아까도 말씀드렸지만 연산자 중복 메서드는 오늘 보여드린 것 말고도 많이 있으니 다른 자료도 찾아보시기 바랍니다. 그럼… I'll be back … ^^ 8. 예외 예외(exception)란 무엇이며 어떻게 다뤄야 할지 알아봅니다. 이 장에서 배우는 것: 예외 처리(try-except) 8.1 예외 처리(try, except) 프로그래밍 언어를 배울 때에는 직접 따라 해보고, 만들어보는 것이 중요합니다. 여러분도 지금까지 함께 공부하면서 연습을 많이 해보셨겠죠? 그렇다면 아래와 같은 메시지도 많이 보셨을 것 같네요. >>> print 방가~ File "<stdin>", line 1 print 방가~ ^ SyntaxError: invalid syntax 위에선 '방가~'라는 문자열을 출력하려고 했는데, 뭔가 문제가 생긴 것 같죠? 메시지가 난해한 것 같은데… 무슨 뜻인지 해독을 해볼까요? File "<stdin>", line 1 파일의 1번째 줄에서 print 방가~ ^ ^로 표시된 부분에 SyntaxError: invalid syntax 잘못된 구문으로 인해 오류가 발생했음 한마디로 문법이 틀렸다는 얘기군요. 여기서이라는 건 표준 입력(standard input), 즉 키보드를 통해 입력되는 것을 뜻합니다. 대화식으로 작성하지 않고 파일로 작성해서 실행시켰다면 그 파일의 이름이 나왔겠지요. 이렇게 파이썬은 프로그램 실행 중에 문제가 생기면, 어디가 어떻게 잘못됐는지 판단해서 우리에게 알려줍니다. 그러면 우리는 그 부분을 수정해서 잘 작동하도록 하면 되지요. 그런데, 프로그램을 짜다 보면 평소에는 잘 돌아가다가 가끔씩 문제가 생기는 경우도 있답니다. 다음의 예제가 바로 그런 경우인데요, 두 수를 곱하고 나눠서 더하는 함수입니다. >>> def f(a, b): ... return (a * b) + (a / b) ... >>> f(4,2) 10 아직은 별다른 문제가 없어 보이죠? 하지만 두 번째 인자로 0을 넘겨주면 난리가 납니다. >>> f(3,0) Traceback (most recent call last): File "<stdin>", line 1, in ? File "<stdin>", line 2, in f ZeroDivisionError: integer division or modulo by zero 정수를 0으로 나누는 오류가 발생했다고 하는군요. 원래 숫자를 0으로 나눌 수가 없죠? 그렇다면 이 함수는 손을 좀 봐야겠네요. >>> def f(a, b): ... if a and b: # a와 b가 둘 다 0이 아닐 때 ... return (a * b) + (a / b) ... elif a: # 그렇지 않고 a만 0이 아닐 때 ... return '불능' ... else: # 둘 다 0일 때 ... return '부정' ... 이제 좀 그럴 듯하네요. >>> f(3, 0) '불능' >>> f(0, 0) '부정' OX 퀴즈!! 이제 이 함수는 더 이상 오류가 생길 일이 없겠죠? 그렇다고요? 과연 그럴까요… f(300000, 500000)를 한번 실행시켜보세요. 계산 결과가 잘 나올 수도 있지만, >>> f(300000, 500000) 150000000000.6 파이썬 버전이 낮을 경우 아래와 같이 오류가 발생하기도 합니다. >>> f(300000, 500000) Traceback (most recent call last): File "<stdin>", line 1, in ? File "<stdin>", line 3, in f OverflowError: integer multiplication 인자로 받은 두 수의 곱이 정수형으로 처리하기에는 너무 큰 값이라서 오류가 발생했군요. 음… 또 이런 건…? >>> f(이십, 오) Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name '이십' is not defined 쩝… 프로그램을 작성하다 보면 오류가 발생할 수 있는 경우는 끝도 없습니다. 우리가 이런 오류를 모두 예상해서 프로그램을 작성한다는 것은 정말로 '삽질'이라고 밖에 할 수 없겠네요. 앞의 예에서 불능과 부정을 정해준 것은 나쁘지 않다고 하더라도, 다른 두 경우까지 각각 처리해 주는 건 시간 낭비이겠죠? 다행히 파이썬에선 이런 문제를 쉽게 해결하는 방법이 있습니다. 위와 같이 프로그래머의 의도와 동떨어진 상황이 발생하는 것을 예외(exception)라고 해서, 예외가 발생하면 어떤 조치를 취할 것인지 정해주는 것이죠. 그럼 예외를 처리할 수 있도록 함수를 수정해 보도록 하지요. >>> def f(a, b): ... try: ... if a and b: ... return (a * b) + (a / b) ... elif a: ... return '불능' ... else: ... return '부정' ... except: ... return '똑바로 살아라' 보시는 것처럼 방법은 간단합니다. 기본적인 문장들을 try 밑에 넣어주고, 예외가 발생했을 때 처리할 부분은 except 밑에 넣어주면 됩니다. 일단 시도(try) 해 보다가 문제가 생기면(except) 처리해 주는 것이죠. 예외는 오류(error)보다 더 넓은 개념이긴 하지만 지금은 비슷하게 생각하셔도 되고요, C++과 Java에서도 비슷하게 사용된답니다. 위의 예제는 예외가 무엇인지 설명하기 위해 간단히 작성한 것이니 참고만 하시기 바랍니다. 예외가 발생하지 않도록 막는 것이 능사가 아니라, 필요한 곳에서 적절한 예외를 발생시킬 수 있도록 궁리를 많이 해야 합니다. tip 여기서는 매개변수의 타입이 예상한 것과 달라서 발생하는 예외를 try-except로 처리하는 예로 들었지만, assert 문을 이용해서 매개변수의 타입을 미리 확인할 수도 있어요. 더 읽을거리 예외에 대해 더 알고 싶다면 《실용 파이썬 프로그래밍》의 ‘오류 검사’ 절을 읽어보세요. 8.2 연습 문제: 음성 인식 일본어 퀴즈 개선 문제 6장에서 응용 예제로 소개 드린 음성 인식을 활용한 일본어 퀴즈를 풀다 보니, 프로그램이 말을 잘 알아듣지 못하고 speech_recognition.UnknownValueError라는 오류를 낼 때가 있네요. 다음 단어를 이어서 공부하고 싶은데 프로그램이 멈춰버리니 좀 불편합니다. 오류가 날 경우 그 단어는 통과하고 다음 단어를 공부하도록 고쳐보세요. 풀이 저는 이렇게 했어요. 코드: ch08/japanese_quiz2.py 저는 except ⋯ as ⋯ 구문을 썼는데, 어려울까 봐 앞에서는 소개하지 않았어요. 궁금하신 분은 ⟪실용 파이썬 프로그래밍⟫ 3.3절을 읽어보세요. 9. 테스팅과 성능 코드에 오류가 없는지 테스트하는 법과, 코드를 실행하는 데 걸리는 시간을 측정하는 방법을 알아봅니다. 이 장에서 배우는 것: 테스팅 프로그램 실행 시간 측정하기 9.1 테스팅 오늘은 크리스마스입니다. 메리 크리스마스~ 독자께서 윤년 판별하기 연습 문제를 푼 것을 봐달라고 메일로 보내주셔서 한번 살펴보려고 합니다. 저는 if 문을 중첩해서 풀었었는데, 이 코드는 중첩 없이 평평하게 되어 있어서 보기가 좋네요. 시각적으로 보기 좋은 코드가 실제로도 좋을 가능성이 높습니다. 그렇지만 코드를 눈으로만 봐서는 결과가 제대로 나올지 확신하기 힘들므로, 실제 숫자를 넣어서 테스트해 보고, 그다음에는 파이썬 유닛 테스트(unittest) 모듈을 사용해 테스트를 자동화하려고 합니다. 주어진 연도가 윤년인지 아닌지를 반환하는 함수 우선 테스트하기 편하게 코드를 약간 바꿔볼게요. 원래는 input() 함수로 입력을 받아서 print() 문으로 결과를 출력하게 되어 있었는데, is_leap_year() 함수로 만들었습니다. 이 함수는 year 매개변수가 윤년에 해당하면 True를, 그렇지 않으면 False를 반환합니다. # 파일명: LeapYear.py def is_leap_year(year): if year % 4 != 0: return False elif year % 100 != 0: return True elif year % 400 != 0: return False else: return True IDLE에서 위와 같이 작성해 LeapYear.py로 저장하고 F5 키를 눌러 실행합니다. >>> = RESTART: C:\Users\ychoi\OneDrive\문서\GitHub\wikidocs-chobo-python\ch09\LeapYear.py LeapYear.py가 다시 시작되었다는 메시지가 떴습니다. 즉, is_leap_year() 함수가 정의되었겠죠? 괄호 없이 함수 이름만 넣어서 확인해 보겠습니다. >>> is_leap_year <function is_leap_year at 0x000002007E874DC0> 네, is_leap_year라는 함수가 메모리 주소 0x000002007E874DC0에 있다고 합니다. 메모리 주소는 집 주소와 비슷합니다. 여러분이 온라인 쇼핑에서 주문한 물건을 배송받으려면 집 주소를 알려줘야 하는 것처럼, 컴퓨터 메모리에 저장해둔 함수를 사용하려면 메모리 주소가 필요한 것이죠. 하지만 우리는 메모리 주소를 몰라도 됩니다. 그럼 is_leap_year() 함수를 사용해 보겠습니다. 올해는 2020년이니까 2020을 넣어보죠. >>> is_leap_year(2020) True 2020년은 윤년이므로 True가 나왔습니다. 이번에는 2077로 테스트해 봅시다. 2077년은 평년이므로 False가 나와야겠죠? >>> is_leap_year(2077) False 네, 좋습니다. 주어진 연도가 윤년인지의 여부를 반환하는 is_leap_year() 함수를 작성하고 수작업으로 간단히 테스트해 보았습니다. 유닛 테스트 작성과 실행 이제, 위에서 수작업으로 수행했던 테스트 과정을 자동화하는 코드를 작성해 보겠습니다. 파이썬 언어에 기본으로 포함된 unittest 모듈을 이용할 거고요, 실제 코드와 테스트 코드를 같은 파일에 넣어도 되겠지만 그렇게 하지 않고 test_LeapYear라는 이름의 파일을 따로 작성하겠습니다. # 파일명: test_LeapYear.py 1 import LeapYear 2 import unittest 3 4 class TestLeapYear(unittest.TestCase): 5 def test_2020(self): 6 r = LeapYear.is_leap_year(2020) 7 self.assertEqual(r, True) 8 9 if __name__ == '__main__': 10 unittest.main() 11 코드 설명: 1행: 위에서 작성한 LeapYear 모듈을 임포트 2행: unittest 모듈을 임포트 4~7행: LeapYear 모듈을 테스트하는 TestLeapYear 클래스 정의 5~7행: is_leap_year() 함수를 테스트하는 메서드 6행: is_leap_year(2020)을 실행한 결과를 r이라는 이름으로 저장합니다. r의 값은 2020년이 윤년인지 아닌지 나타내는 불린 값(True 또는 False)이 됩니다. 7행: 'r 값이 True 여야 올바른 결과이다'라는 의도를 코드로 표현한 것입니다. 9~10행: test_LeapYear를 실행하면 테스트를 실행 IDLE에서 위와 같은 테스트 코드를 작성해 test_LeapYear.py로 저장한 다음, F5 키를 눌러 실행하면 IDLE Shell 창에 다음과 같은 결과가 나옵니다. >>> = RESTART: C:\Users\ychoi\OneDrive\문서\GitHub\wikidocs-chobo-python\ch09\test_LeapYear.py ---------------------------------------------------------------------- Ran 1 test in 0.011s OK 테스트를 한 개 수행했고, 모든 테스트를 수행한 결과가 좋다는 뜻으로 OK라고 출력되었습니다. 테스트 추가 2020년에 대해서 테스트를 작성해 봤으니, 2077년에 대해서도 테스트해 보겠습니다. 앞에서 작성한 TestLeapYear 클래스에 test_2077() 메서드를 추가합니다. # 파일명: test_LeapYear.py (앞 부분 생략) 8 9 def test_2077(self): 10 r = LeapYear.is_leap_year(2077) 11 self.assertEqual(r, False) 12 13 if __name__ == '__main__': 14 unittest.main() 이 메서드를 앞에서 작성한 test_2020() 메서드와 비교해 보면 한 가지 다른 점이 있습니다. 찾으셨나요? 맞습니다. 11행의 두 번째 인자가 False로 되어 있죠. 2077년은 윤년이 아니기 때문에, is_leap_year(2077)의 실행 결과는 False 여야 한다는 것을 이렇게 나타냈습니다. 그럼, 테스트를 다시 실행해 보겠습니다. >>> = RESTART: C:\Users\ychoi\OneDrive\문서\GitHub\wikidocs-chobo-python\ch09\test_LeapYear.py .. ---------------------------------------------------------------------- Ran 2 tests in 0.012s OK 이번에는 테스트 두 개가 실행되었고, 둘 다 통과해서 OK가 나왔습니다. 모든 분기를 테스트했나? 지금까지 LeapYear.py 코드를 테스트해 봤습니다. 그런데 테스트가 이것으로 충분할까요, 아니면 테스트를 좀 더 해봐야 할까요? 우리는 코드를 갖고 있으므로, if 문을 사용한 분기가 어떤 구조인지 알고 있습니다. 경우의 수가 네 가지 있는데, 각각 한 번씩은 테스트해 보는 것이 좋을 것 같습니다. 그렇다면 앞에서 테스트한 분기는 어느 것이고, 테스트하지 않은 분기는 어느 것일까요? 테스트 대상인 LeapYear.py 코드를 다시 보면서 생각해 보겠습니다. # 파일명: LeapYear.py def is_leap_year(year): if year % 4 != 0: # (1) 2077 return False elif year % 100 != 0: # (2) 2020 return True elif year % 400 != 0: # (3) ? return False else: # (4) ? return True 위 코드에서 (1) '연도를 4로 나누어떨어지지 않으면 윤년이 아니다'라는 논리를 작성했는데, 이를 테스트 코드에서는 2077을 가지고 테스트했었죠? 다음으로, (2) '연도를 4로 나누어떨어지되 100으로 나누어떨어지지 않으면 윤년이다'라는 논리를 2020으로 테스트했습니다. (3) 번과 (4) 번 논리는 테스트하지 않았는데, 이것들이 올바로 작성되었는지도 추가로 테스트할 필요가 있겠네요. 숙제 그러면 (3) 번과 (4) 번을 테스트하려면 몇 년을 가지고 테스트해야 할까요? 400년 주기가 중요하므로 2000년과 1900년을 살펴보면 될 것 같습니다. 한번 작성해 보세요. 잘 작성했다면 결과가 다음과 같이 나올 거예요. = RESTART: C:\Users\ychoi\OneDrive\문서\GitHub\wikidocs-chobo-python\ch09\test_LeapYear.py .... ---------------------------------------------------------------------- Ran 4 tests in 0.013s OK 더 읽을거리 실용 파이썬 프로그래밍 - 8.1 테스팅: https://wikidocs.net/84431 9.1.1 연습 문제: 숫자 읽기(0~100) 문제 0 이상 100 이하의 정수를 매개변수로 입력받아 그 숫자에 해당하는 한글 문자열을 반환하는 함수 korean_number()를 포함하는 korean_0_to_100.py를 작성하세요. 아래 테스트(test_korean_number.py)를 이용하되, 테스트 코드를 추가해도 됩니다. from korean_0_to_100 import korean_number import unittest class TestKoreanNumber(unittest.TestCase): def test_0(self): self.assertEqual(korean_number(0), '영') def test_1(self): self.assertEqual(korean_number(1), '일') def test_2(self): self.assertEqual(korean_number(2), '이') if __name__ == '__main__': unittest.main() ch09/test_korean_number.py ch09/korean_0_to_100.py 영상 https://youtu.be/m2q1uR7GsXU 9.2 프로그램 실행 시간 측정하기 같은 목적으로 작성한 프로그램이라 하더라도, 그 논리를 어떻게 작성했는지에 따라 계산이 오래 걸리기도 하고, 상대적으로 일찍 끝나기도 합니다. 그렇다면, 프로그램을 실행하는 데 걸리는 시간을 어떻게 측정할 수 있을까요? 시계를 보면서 프로그램의 시작 시각과 종료 시각을 확인해서 걸린 시간을 계산하면 될까요? time.process_time() 이렇게 프로그램을 실행하는 데 실제로 걸린 시간(벽시계에 비유해 wall time이라고 합니다)을 알고 싶을 때도 있겠지만, 컴퓨터의 처리 시간(process time)을 계산하는 것이 나을 때도 있습니다. 파이썬 프로그램의 처리 시간을 알고 싶을 때 time 모듈의 process_time으로 시간을 측정할 수 있습니다. wall time과 process time 인형에 눈을 붙이는 아르바이트를 한다고 합시다. 인형 한 개의 눈을 붙이는 데 10초가 걸린다면, 쉬지 않고 일정한 속도로 일할 경우 1분에 인형 여섯 개의 눈을 붙일 수 있고 한 시간에는 360개를 할 수 있겠죠. 그런데 한 시간 일할 때마다 십 분씩 쉬어야 하므로 한 시간에 인형 300개의 눈을 붙일 수 있습니다. 두 사람이 인형 1200개의 눈을 붙인다면, 한 사람이 600개씩 작업하면 됩니다. 이때, 경과 시간(wall time 또는 elapsed time)은 1시간 50분(50분 작업 + 10분 휴식 + 50분 작업)입니다. 처리 시간(process time 또는 CPU time)은 50분 * 4 = 200분 = 3시간 20분입니다. 4장 소수 구하기 연습 문제의 첫 번째 풀이(prime.py)의 실행 시간을 측정하려면 다음과 같이 할 수 있습니다. 윈도 명령 프롬프트의 작업 디렉터리를 ch09에서 ch04로 바꾼 뒤 파이썬 인터프리터를 실행했습니다. wikidocs-chobo-python\ch09> cd .. wikidocs-chobo-python> cd ch04 wikidocs-chobo-python\ch04> python Python 3.9.4 (tags/v3.9.4:1f2e308, Apr 6 2021, 13:40:21) [MSC v.1928 64 bit (AMD64)] on win32 Type "help", "copyright", "credits" or "license" for more information. >>> import prime >>> from time import process_time >>> start = process_time() >>> prime.prime(2 ** 8) # 256 이하의 소수 [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251] >>> end = process_time() >>> end - start 0.03125 >>> exit() wikidocs-chobo-python\ch09> 처리 시간(end - start)이 0.03125초 걸렸다고 나왔습니다. sys.path.append() 이번에는 두 번째 풀이(prime2.py)의 실행 시간을 구해보겠습니다. 위에서는 윈도 명령 프롬프트에서 직접 ch04 폴더로 이동해서 파이썬을 실행했지만, 아래와 같이 ch09에서 파이썬을 실행해 sys.path.append()로 ch04를 패키지 경로에 추가하고 모듈을 임포트 할 수도 있습니다. wikidocs-chobo-python\ch04> wikidocs-chobo-python\ch04> cd ../ch09 wikidocs-chobo-python\ch09> python Python 3.9.4 (tags/v3.9.4:1f2e308, Apr 6 2021, 13:40:21) [MSC v.1928 64 bit (AMD64)] on win32 Type "help", "copyright", "credits" or "license" for more information. >>> import sys >>> sys.path.append('../ch04') >>> import prime2 >>> from time import process_time >>> start = process_time() >>> prime2.prime(2 ** 8) [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251] >>> end = process_time() >>> end - start 0.0 >>> 이번에는 처리 시간이 0.0으로, 같은 문제를 푸는 데 시간이 훨씬 적게 걸렸습니다. importlib.import_module() 그 밖에 독자분들이 알려주신 풀이도 있어서 이름이 prime으로 시작하는 파일이 여러 개 있습니다. 이 파일들의 실행 시간을 모두 비교하는 프로그램을 작성했는데, 모듈명을 제가 직접 지정하지 않고 glob을 이용해 알아낸 후 반복문으로 하나씩 실행했습니다. 이때 모듈명을 나타내는 문자열을 가지고 임포트 하기 위해 importlib의 import_module() 함수를 사용했습니다. 그리고 프로그램의 성능을 더 잘 비교하기 위해 N을 아까보다 더 큰 수로 지정했습니다. [코드: ch09/prime_process_time.py] import sys import os import importlib from glob import glob from time import process_time N = 2 ** 12 # 4096 # N = 2 ** 13 # 8192 # 현재 장은 9장인데 소수 구하기 코드는 4장에 있어, 패키지 경로를 추가하고 작업 디렉터리도 변경 sys.path.append('../ch04') os.chdir('../ch04') for pth in glob('prime*'): # prime으로 시작하는 파일명 각각에 대해... name = os.path.splitext(pth)[0] # 모듈명(파일명에서 확장자 앞까지) 구하기 print(f'\nRunning {pth} ...') mod = importlib.import_module(name) # 모듈 임포트 # 실행 시간 측정 start = process_time() mod.prime(N) end = process_time() print('elapsed:', end - start) 실행 결과(N = 2 ** 12일 때) wikidocs-chobo-python\ch09>prime_process_time.py Running prime.py ... [2, 3, 5, (생략), 4079, 4091, 4093] elapsed: 57.15625 Running prime2.py ... [2, 3, 5, (생략), 4079, 4091, 4093] elapsed: 0.0 Running prime_aaaa.py ... Prime Number List Of 4096 [2, 3, 5, (생략), 4079, 4091, 4093] elapsed: 0.015625 Running prime_fate.py ... [2, 3, 5, (생략), 4079, 4091, 4093] elapsed: 0.015625 Running prime_kim.py ... [2, 3, 5, (생략), 4079, 4091, 4093] elapsed: 0.671875 실행 결과(N = 2 ** 13일 때) 다음은 N 값을 2 ** 13으로 바꿔서 실행해 본 결과입니다. wikidocs-chobo-python\ch09>prime_process_time.py Running prime.py ... [2, 3, 5, (생략), 8171, 8179, 8191] elapsed: 444.125 Running prime2.py ... [2, 3, 5, (생략), 8171, 8179, 8191] elapsed: 0.015625 Running prime_aaaa.py ... Prime Number List Of 8192 [2, 3, 5, (생략), 8171, 8179, 8191] elapsed: 0.09375 Running prime_fate.py ... [2, 3, 5, (생략), 8171, 8179, 8191] elapsed: 0.046875 Running prime_kim.py ... [2, 3, 5, (생략), 8171, 8179, 8191] elapsed: 4.078125 A. 부록 여기까지 읽으신 여러분은 이제 '왕초보'는 아니고 '초보'입니다!? 독자 여러분이 특히 어려워하셨던 문제 몇 개는 파이썬에 익숙해진 후에 풀면 좋을 것 같아서 이곳으로 옮겼습니다. 그 외에 파이썬 기초 문법은 아니지만 익혀두면 유용한 것들을 모았습니다. 함수의 재귀 스케줄링 알고리듬 진법 변환과 비트 연산 파이썬으로 PDF 파일 합치기 맷플롯립으로 하트 그리기 윈도에서 파이썬 활용 팁 A.1 함수의 재귀 이번에 배울 것은 새로운 파이썬 문법은 아니고요, 프로그램을 짜는 테크닉 중의 한 가지인데 조금 머리가 아플 수도 있는 내용이랍니다. 하지만 최대한 쉽게 알려드릴 테니까 너무 걱정 마시고 함께 알아보도록 해요. (3장에 있던 것을 부록으로 옮겼습니다.) 함수가 자기 자신을 호출하는 ‘재귀(recursion)’ 혹은 ‘순환’입니다. 갑자기 어려운 것을 배우면 머리가 많이 아프실 테니까 먼저 준비운동을 하는 것이 좋겠군요. 다음의 예제를 봐주세요. 먼저 주어진 두 수를 합하는 함수를 만들어보겠습니다. >>> def hap(a, b): ... print(a + b) ... 제대로 만들었는지 확인을 해보세요. 이 함수를 어떻게 쓰는지 아시겠죠? 확인해 보셨으면 두 수를 곱하는 함수도 만들어보세요. >>> def gop(a, b): ... print(a * b) ... 그럼 이번엔 두 수를 합해보고 곱해보고, 두 가지 일을 다하는 함수도 만들어 보겠습니다. >>> def hap_gop(a, b): ... hap(a, b) ... gop(a, b) ... 이 함수는 자기에게 맡겨진 일을 직접 수행하지 않고 다른 함수들에게 시켜버리죠? 다시 말하면, 이 함수는 hap() 함수와 gop() 함수를 호출했다고 할 수 있습니다. 한번 테스트해 보세요. 재미있으신가요? 이젠 본론으로 들어가겠습니다. def countdown(n): if n == 0: print("Blastoff!") else: print(n) countdown(n-1) 출처: How to Think Like a Computer Scientist 이 함수는 무슨 일을 하는 함수일까요? 함수 이름을 보면 추측을 할 수도 있는데… 잘 모르시겠나요? 그렇다면 몇 줄 안되니까 직접 쳐보시지요. 제대로 만들었으면 아래와 같이 사용해 보시고요. >>> countdown(3) 2 Blastoff! 이 함수는 매개변수로 받은 수부터 카운트다운을 하다가 0까지 오면 꽝! 하는 일을 한답니다. '그런 거라면 for 문이나 while 문과 똑같잖아'하고 생각하는 분도 계시겠지만 코드를 가만히 보시면 차이점을 발견하실 거예요. 이 함수는 if, else 구조로서 n이 0인지 아닌지 따라서 다른 일을 하도록 되어 있습니다. 이 if 문에서 검사하는 n은 첫째 줄에서 함수를 정의할 때 매개변수로 정해준 n과 같은 녀석입니다. 그러니까 매개변수에 3을 넣어서 함수를 호출하면, 즉 countdown(3)이라고 쓰면 함수 본체의 n 값으로 3이 들어가는 것이지요. n 값으로 3이 들어오면 함수 내부에서는 어떤 일이 벌어질까요? 먼저 if n == 0:에서 n 값이 0과 같은지 비교합니다. n이 3이므로 n의 값과 0은 같지 않습니다. 그러면 else: 이후의 명령을 수행하겠지요. 다음 줄에 있는 print(n)은 n 값을 출력하라는 명령이니까 화면에 3을 출력해 줍니다. 그다음엔 countdown(n-1)이라고 되어있지요. countdown이라는 함수를 호출하면서 n-1 값을 매개변수로 넣어주라는 뜻입니다. 결국 countdown(2)와 같이 함수를 호출하게 되지요. 그런데 여기서 뭔가 이상하다는 것을 눈치채셨을 겁니다. countdown이라는 함수에서 countdown을 호출한다? 예, 그것이 바로 오늘의 주인공, 재귀적 호출입니다. 함수가 자기 자신을 호출하는 것이죠. 머리가 복잡해지기 시작하신다면 생각을 잠시 덮으시고 countdown(2)라고 호출하면 어떤 일이 일어날지부터 함께 따져보죠. 먼저 if 문에서 n 값이 0과 같은지 검사를 합니다. 검사 결과가 거짓이므로 else: 이후의 명령을 수행하겠죠. print(n)에서 n 값인 2를 화면에 출력해 주고 그다음 줄에서 countdown(1)을 호출합니다. 오호~. 뭔가 감이 잡히시나요? 처음에 countdown 함수를 호출하면서 매개변수 값으로 3을 넣어줬는데 함수가 자기 자신을 호출하면서 매개변수가 점점 작아지죠? 그렇다면 countdown(1)은 다시 countdown(0)을 호출하게 되는 것이 틀림없습니다. 그러면 countdown(0)에서는 무슨 일을 할까요? n == 0이면 print("Blastoff!") 하라고 되어있으니 화면에 그렇게 출력해 줍니다. '뻥이야~!' 그렇게 해서 countdown 함수가 끝이 납니다. 지금까지 본 것이 모두 countdown(3)을 호출했을 때 일어나는 일들입니다. 이 일들을 하는 동안 countdown 함수는 네 번이나 호출되었지요. countdown(3), countdown(2), countdown(1), countdown(0). 맞나요? 어떠세요? 이해할 만한가요? 좀 어렵긴 하지만 알고 나면 꽤 재미가 있지요. 사실 이 예제에서는 for 문을 이용해도 얼마든지 할 수 있는 일을 예로 들었지만 어떤 경우에는 재귀적 호출을 잘 사용하면 복잡한 프로그램을 아주 쉽게 만들 수도 있답니다. 하지만, 함수를 여러 번 호출해서 일을 처리하기 때문에 사람이 편한 만큼 컴퓨터에게는 힘이 더 드는 방법이기도 하답니다. 이 내용은 지금 꼭 이해하지 못해도 상관없습니다. 프로그래밍 공부를 계속하시다 보면 다시 배우게 될 테니까요. 예전에 배운 내용을 확실히 몰라서 이 내용을 이해하지 못하셨다면 복습을 좀 더 하신 후에 다시 보시는 것이 좋겠네요. A.1.1 연습 문제: 각 자리 숫자의 합을 구하는 재귀 함수 문제 1 어떤 수(number)의 각 자리 숫자(digit)의 합을 계산하는 sumOfDigits()라는 재귀 함수를 작성하자. 입력한 수를 읽어 sumOfDigits() 함수를 호출하며, 이 함수는 합산할 숫자가 남지 않을 때까지 자신을 호출해, 최종적인 합을 사용자에게 표시한다. sumOfDigits()는 다음과 같은 원리로 작동한다.(주의: 실제 코드가 아님) sumOfDigits(6452) = 2 + sumOfDigits(645) sumOfDigits(645) = 5 + sumOfDigits(64) ... sumOfDigits(6) = 6 예 1 입력: 47253 출력: 21 예 2 입력: 643 출력: 13 풀이 아래 코드는 문제에서 요구한 대로 재귀 함수를 정의했습니다. 코드: ch10/sumOfDigits_recursive.py 흐름도 다음 코드는 재귀적이지 않은 함수를 정의해서 풀었습니다. ch10/sumOfDigits_non-recursive_div-mod.py edX.org의 C Programming: Modular Programming and Memory Management에 실린 문제입니다. ↩ A.1.2 연습 문제: 복리를 계산하는 재귀 함수 복리 계산 문제를 재귀적으로 풀어봅시다. 문제 문제 1 문제를 단순화하기 위해 복리 계산 공식을 조금 바꿔 볼게요. 원래 공식에는 복리 횟수가 있는데, 복리 횟수가 1이라고 가정하면 공식을 다음과 같이 간단히 나타낼 수 있습니다. ′ P ( + ) P : 원금 ′ : 원리금 : 이율 : 기간 그런데 이번 문제는 위 공식을 그대로 사용하지 말고 재귀적으로 풀어야 합니다. 결괏값의 소수점 이하는 그대로 두시면 됩니다. 예 1 연이율 5.8%인 연 복리 상품에 360만 원을 2년간 예치했을 때 만기 수령액: >>> compound_interest_amount_withoutN(3600000, 0.058, 2) 4029710.4000000004 예 2 천만 원을 연이율 5% 월복리 예금에 1년 넣었을 때 만기 수령액: >>> 0.05 / 12 0.004166666666666667 >>> compound_interest_amount_withoutN(10000000, _, 12) 10511618.978817329 문제 2 (심화) 위 문제를 풀었다면 아래 공식으로도 풀어보세요. ′ P ( + n ) t : 원금 ′ : 원리금 : 이율 : 복리 횟수 : 기간 이 문제를 풀 수 있다면 엄청 잘 하시는 것으로 인정! 아, 재귀적으로 풀었을 때만요. 예 1 >>> compound_interest_amount(1500000, 0.043, 6, 4) 1938836.8221341053 예 2 >>> compound_interest_amount(1500000, 0.043, 6, 1/2) 1921236.0840000005 예 3 함수를 만들었다면 마지막 인자로 1을 전달해서 1번 문제도 풀 수 있어요. >>> compound_interest_amount(3600000, 0.058, 2, 1) 4029710.4000000004 풀이 코드: ch10/compoundInterest_recursive.py 구글 스프레드시트 흐름도 참고 복리 계산법, 탱스타 예적금 단리 복리 차이점 알아보기, 치 킨 요정의 경제 공부방 A.2 연습 문제: 여러 대의 컴퓨터에 연산을 분배하기 4장에 있던 연습 문제인데 좀 어려워서 뒤로 옮겼습니다. 한번 풀어보세요. 문제 컴퓨터가 몇 대 있고 연산해야 할 프로그램도 몇 개 있습니다. 프로그램들을 컴퓨터에 가장 적절하게 분배하는 프로그램을 작성하세요. 예) 컴퓨터는 2대가 있고, 프로그램의 수행 시간은 각 3분, 5분, 2분이라면, 컴퓨터 하나는 3분, 2분짜리 프로그램을 수행하고 다른 컴퓨터는 5분짜리 프로그램을 수행하면 됩니다. 입력 computer : 2 program : 3, 5, 2 출력 computer1 : 5 computer2 : 3, 2 어떠세요? 좀 어렵죠? 저도 이 문제를 보고 문제가 무슨 뜻인지 몰라서 한참 헤맸답니다. 그러나 총명하신 여러분은 금방 이해하셨으리라 생각합니다. 이제 문제를 풀어볼 텐데요, 아래의 해설을 보시기 전에 문제를 다른 곳에 옮겨놓고 잠시 생각을 해보시기 바랍니다. 가능하면 직접 풀어보는 것이 좋으니까요. 컴퓨터 여러 대가 프로그램을 나눠서 수행한다면, 각각의 컴퓨터에게 같은 양의 일을 줘서 같이 끝내는 것이 좋겠죠? 예에서는 총 10분 동안 할 일을 컴퓨터 두 대에게 나눠주는 거니까 각각 5분씩일을 시키면 되는 거고요. 만약, 수행할 프로그램 중에 평균보다 더 오래 걸리는 것이 있다면, 그러니까 프로그램이 7분, 3분 두 개가 주어지면 어떻게 나눠주는 것이 좋을까요? 할 수 없이 한 대는 7분 동안, 다른 한 대는 3분 동안 일을 해야겠죠? 7분짜리를 5분, 2분으로 쪼개서 넘겨주라고요? 시로~. 해법 문제를 두 가지 방법으로 풀어 보았습니다. 첫 번째 방법은 sol1() 함수, 두 번째 방법은 sol2() 함수로 구현했습니다. 먼저 두 함수에 공통으로 들어간 코드를 설명드릴게요. 공통적인 부분 함수 입출력<NAME> 예제에서는 단순하게 리스트와 변수를 입력받고, 리스트를 출력하도록 처리했습니다. 그렇게 하는 것이 간편하고 문제에 집중하는 데 도움이 되는 것 같아서요. 입력: 첫 번째 매개변수: 리스트(예: [3,5,2]) 두 번째 매개변수: 정수(예: 2) 출력: 리스트(예: [[5], [3, 2]]) 초기화 두 함수의 첫 부분에는 다음 코드가 공통으로 들어갑니다. _inlist = copy.deepcopy(inlist) outlist = [] sumout = [] for x in range(coms): outlist.append([]) sumout.append(0) 첫째 줄에서는 매개변수로 받은 inlist를 _inlist로 깊은 복사를 했습니다. outlist가 바로 컴퓨터들의 리스트이고, sumout은 컴퓨터마다 수행할 프로그램의 수행 시간 합계를 갖는 리스트입니다. coms는 함수의 매개변수로 받은 컴퓨터 대수입니다. coms 값이 3이라면 위의 for 문을 수행한 후에 outlist는 [[], [], []]와 같이 되고, sumout은 [0, 0, 0]이 됩니다. 나중에 함수가 모두 실행되고 나면 outlist에는 결괏값이 [[22], [15, 3, 2], [13, 6]]와 같이 담기고, 그때 sumout은 [22, 20, 19]와 같이 되어있도록 할 생각이지요. 해법 1 문제 해결을 위한 첫 번째 해법의 논리는 다음과 같습니다. 프로그램들을 전부 수행하는 데 걸리는 총 수행 시간을 구한다. 총 수행 시간을 컴퓨터 대수로 나누어 각각의 컴퓨터의 평균 수행 시간을 구한다. 만약 평균 수행 시간보다 더 오래 걸리는 프로그램이 있으면: 그냥 컴퓨터에게 준다. 평균 수행 시간보다 짧게 걸리는 것들은: 평균 수행 시간만큼 모아서 컴퓨터에게 준다. 코드는 다음과 같습니다. def sol1(inlist, coms): ... # 프로그램들을 전부 수행하는 데 걸리는 총 수행 시간을 구한다. total_time = sum(_inlist) # 총 수행 시간을 컴퓨터 대수로 나눠 각 컴퓨터의 평균 수행 시간을 구한다. avg_time = total_time / coms for j in range(coms): # 평균 수행 시간보다 오래 걸리는 프로그램이 있으면 그냥 컴퓨터에게 준다. if True in [k >= avg_time for k in _inlist]: for m in _inlist: if m >= avg_time: outlist[j].append(m) _inlist.remove(m) sumout[j] += m break # 평균 수행 시간보다 짧게 걸리는 것들은 모아서 컴퓨터에게 준다. else: for n in range(len(_inlist)): if _inlist[n] == 0: continue v = _inlist[n] outlist[j].append(v) _inlist[n] = 0 sumout[j] += v if sumout[j] >= avg_time: break return outlist 처음에는 이런 식으로 문제를 풀었는데, 나중에 다시 보니까 복잡하면서도 비효율적이라는 생각이 들더군요. 해법 2 그래서 몇 날 며칠을 고민하다 보니 기발한 아이디어가 떠올랐습니다. 새로운 해결 방법의 핵심은 '가장 가벼운 바구니에 빵을 담는다'라는 것입니다. '컴퓨터'와 '수행할 프로그램' 대신 '바구니'와 '빵'이라고 생각한 것이죠. 그렇게 되면, 컴퓨터에게 프로그램을 분배하는 것은 바구니에 빵을 하나씩 담는 것과 흡사하지요. 바구니를 준비한다. 바구니에 담을 빵들을 크기순으로 정렬한다. 빵을 모두 바구니에 담을 때까지: 가장 가벼운 바구니에 가장 큰 빵을 담는다. 결과를 돌려준다. 이 논리를 프로그램으로 구현한 것이 아래의 예제입니다. 대화식으로 작업하는 것보다 텍스트 에디터를 사용해서 프로그램 파일로 작성하는 것이 좋겠죠? def sol2(inlist, coms): ... _inlist.sort(reverse=True) # 수행할 작업을 빵(bread)에, 컴퓨터를 바구니(basket)에 비유 for bread in _inlist: lowbasket = sumout.index(min(sumout)) # 가장 가벼운 바구니에 outlist[lowbasket].append(bread) # 빵을 담는다 sumout[lowbasket] += bread return outlist 정말 간단하죠? 예전에 소개해 드렸던 풀이를 보셨던 분이라면 놀라실 거예요. 저 스스로도 감탄했거든요. 프로그램을 전체적으로 보면 sol2()라는 함수를 하나 정의해두고, 뒤에 가서 그 함수를 호출하는 형태입니다. 그리고, sol2() 함수는 inlist와 coms라는 두 개의 매개변수를 받아서, outlist를 결과로 돌려줍니다. 이제 함수의 내부를 살펴봅시다. "바구니에 담을 빵들을 크기순으로 정렬한다." _inlist.sort(reverse=True) _inlist를 sort() 메서드를 써서 정렬하되, reverse 옵션에 True를 지정함으로써 정렬이 역순(내림차순)으로 이루어지게 합니다. 1 다음과 같이 두 줄로 쓴 것과 같은 결과를 얻을 수 있습니다. _inlist.sort() _inlist.reverse() 이제 각각의 빵을 바구니로 분배하겠습니다. for bread in _inlist: lowbasket = sumout.index(min(sumout)) # 가장 가벼운 바구니에 outlist[lowbasket].append(bread) # 빵을 담는다 sumout[lowbasket] += bread 가장 가벼운 바구니를 구하기 위해 min(sumout)을 했고, 그 바구니의 인덱스를 구해서 lowbasket이라고 했습니다. 각각의 바구니는 outlist와 sumout에서 같은 인덱스를 쓴다는 점을 이용하기 위해서이지요. 예를 들어서, 만약 outlist 전체가 [[22], [15], [13, 6]]인 상태라면 sumout은 [22, 15, 19]가 되어있을 테고요, 현재 가장 가벼운 바구니는 15가 들어있는 바구니입니다. >>> outlist = [[22], [15], [13, 6]] >>> sumout = [22, 15, 19] >>> min(sumout) 15 이것의 인덱스를 알아보면 1이라는 걸 알 수 있지요. >>> sumout.index(15) 이제 구해진 인덱스를 lowbasket이라고 하고, outlist와 sumout에서 인덱스 1인 바구니는 다음과 같습니다. >>> outlist[1] [15] >>> sumout[1] 15 이런 방법으로 두 리스트에서 같은 바구니를 가리키는 부분을 찾아서 바구니에 빵을 담을 때, 그 바구니가 얼마나 찼는지도 함께 체크해두는 겁니다. _inlist의 모든 원소에 대해 이 일을 반복했으면, 즉 모든 빵을 바구니에 나눠 담았으면, 구해진 outlist를 함수의 결괏값으로 돌려줍니다. return outlist 끝이에요~. 이제 프로그램을 한번 돌려보세요. 아주 잘~ 될 거예요~ 2 보충 설명 아래는<NAME>님께서 설명해 주신 내용입니다. 이것은 프로세스 스케줄링 방식 중에 LPT(Longest Processing Time) 스케줄링에 해당합니다. 가장 긴 시간을 요하는 Job부터 차례대로 가장 적은 업무를 맡은 Line에 배분하는 방식이지요~ 실제로 이 방식의 경우 100% 최적해를 찾는다고 말할 수는 없지만, 이 방식을 사용하면 Parallel Line(컴퓨터가 2대)에서 최적해 보다 33% 이상 나쁘지 않고, Line의 수가 증가할수록 최적해에 가까운 결괏값을 도출하게 된답니다! Line의 수가 많아지고 Job의 수가 많아질수록 최적해를 구하기 위하여 고려해야 하는 결과의 가짓수가 매우 많아지기 때문에, 이런 단순 스케줄링의 경우에 사용하기 매우 경제적인 방법이죠! 다음은 예시입니다~! Jobs 1 2 3 4 5 6 7 8 9 10 11 Pt 9 9 8 8 7 7 6 6 5 5 5 Pt: Processing time, # of Machines = 5 최적해: Hour 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Line 1 [ Job 1 ] [ Job 8 ] Line 2 [ Job 2 ] [ Job 7 ] Line 3 [ Job 3 ] [ Job 6 ] Line 4 [ Job 4 ] [ Job 5 ] Line 5 [ Job 9 ] [ Job 10 ] [ Job 11 ] LPT: Hour 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 Line 1 [ Job 1 ] [ Job 10 ] [ Job 11 ] Line 2 [ Job 2 ] [ Job 9 ] Line 3 [ Job 3 ] [ Job 8 ] Line 4 [ Job 4 ] [ Job 7 ] Line 5 [ Job 5 ] [ Job 6 ] 코드 ch10/prg2com.py Lilly 님께서 알려주셨습니다. ↩ 해법 2도 완벽한 해결책은 아닙니다. 예를 들어, prg2com([7,8,9,10,11], 2)의 이상적인 결과는 [[11,10], [9,8,7]]이지만, 위에서 작성한 프로그램을 수행하면 [[11, 8, 7], [10, 9]]라는 결과를 얻습니다. kds079 님께서 알려주셨습니다. ↩ A.3 진법 변환과 비트 연산 파이썬으로 진법 변환과 비트 연산(bitwise operation)을 하는 방법을 알아보려고 합니다. 조금 어려울 수도 있고 꼭 필요하지 않을 수도 있으니, 관심 있는 분만 보시면 됩니다. 진법 변환 이진수 파이썬에서 이진수(binary)는 0b를 앞에 붙여 나타냅니다. >>> 0b0 # 이진수 0은 십진수 0 >>> 0b1 # 이진수 1은 십진수 1 >>> 0b10 # 이진수 10은 십진수 2 >>> 0b11 # 이진수 11은 십진수 3 십진수를 이진수로 나타내고 싶다면 bin() 함수를 사용하면 됩니다. >>> bin(0) # 십진수 0은 이진수 0 '0b0' >>> bin(1) # 십진수 0은 이진수 1 '0b1' >>> bin(2) # 십진수 2는 이진수 10 '0b10' >>> bin(3) # 십진수 3은 이진수 11 '0b11' 8진수와 16진수 비슷한 방법으로 십진수를 8진수와 16진수로도 변환할 수 있습니다. 하나씩 설명해 드리지 않아도 아실 것 같으니, 반복문으로 한꺼번에 보여드릴게요. >>> for i in range(20): ... print(i, bin(i), oct(i), hex(i)) # 십진수, 이진수, 8진수, 16진수를 출력 ... 0 0b0 0o0 0x0 1 0b1 0o1 0x1 2 0b10 0o2 0x2 3 0b11 0o3 0x3 4 0b100 0o4 0x4 5 0b101 0o5 0x5 6 0b110 0o6 0x6 7 0b111 0o7 0x7 8 0b1000 0o10 0x8 9 0b1001 0o11 0x9 10 0b1010 0o12 0xa 11 0b1011 0o13 0xb 12 0b1100 0o14 0xc 13 0b1101 0o15 0xd 14 0b1110 0o16 0xe 15 0b1111 0o17 0xf 16 0b10000 0o20 0x10 17 0b10001 0o21 0x11 18 0b10010 0o22 0x12 19 0b10011 0o23 0x13 불값의 논리 연산 비트 연산을 알아보기 전에 몸풀기로 불(bool) 값의 논리 연산부터 알아볼게요. 불은 참(True)과 거짓(False)의 두 값만 있는 자료형입니다. 먼저 and 연산입니다. 왼쪽과 오른쪽 모두 True 여야 결과도 True가 됩니다. >>> True and True True >>> True and False False >>> False and True False >>> False and False False 다음과 같이 진리표로도 나타내면 이해하기 쉽습니다. and True False True True False False False False 다음으로 or 연산자입니다. 둘 중 하나라도 True 이면 결과는 True가 됩니다. 둘 다 False 일 때만 결과가 False가 됩니다. >>> True or True True >>> True or False True >>> False or True True >>> False or False False 진리표로 나타내면 다음과 같습니다. or True False True True True False True False and와 or 연산자는 두 개의 항(피연산자)을 갖는다는 뜻으로 '이항(二項, binary)'로 분류합니다. 이번에는 not 연산자를 알아볼게요. not True는 False, not False는 True입니다. >>> not True False >>> not False True not 연산자는 '단항(單項, unary) 연산자'입니다. 불과 정수의 관계 다음으로 파이썬에서 불값과 정숫값의 관계를 알아보겠습니다. 파이썬에서 True는 숫자 1과 같습니다. >>> True == 1 # 등호가 두 개임에 유의(할당 연산이 아니라 비교) True 그리고 False는 숫자 0과 같습니다. >>> False == 0 True 비트 연산 &는 비트 AND 연산자로, 앞에서 살펴본 and와 비슷합니다. 그리고 |는 비트 OR 연산자로, or와 비슷합니다. 한자리 이진수의 비트 연산 우선 아주 작은 수부터 계산해 볼게요. 이진수 1(0b1)과 이진수 0(0b0)입니다. 비트 AND 연산 먼저 비트 AND(&) 연산입니다. >>> bin(0b1 & 0b1) '0b1' >>> bin(0b1 & 0b0) '0b0' >>> bin(0b0 & 0b1) '0b0' >>> bin(0b0 & 0b0) '0b0' 비트 OR 연산 다음은 비트 OR(|) 연산입니다. >>> bin(0b1 | 0b1) '0b1' >>> bin(0b1 | 0b0) '0b1' >>> bin(0b0 | 0b1) '0b1' >>> bin(0b0 | 0b0) '0b0' 비트 NOT 연산 비트 NOT(~) 연산도 해볼까요? >>> bin(~0b1) '-0b10' 결과가 음수로 나왔네요. ~ 연산 결과는 원래 수에 마이너스 기호를 붙인 뒤 1을 뺀 값과 같습니다. >>> bin(~0b0) '-0b1' >>> bin(-0b0 - 0b1) '-0b1' 위에서 두 연산의 결과가 같은 것을 확인할 수 있습니다. XOR 연산 XOR(배타적 OR, exclusive OR)이라는 연산(^)도 있습니다. 두 값이 모두 1이거나 모두 0이면 결과가 0이고, 두 값 중 하나는 1이고 다른 하나가 0이면 결과가 1이 됩니다. >>> bin(0b1 ^ 0b1) '0b0' >>> bin(0b1 ^ 0b0) '0b1' >>> bin(0b0 ^ 0b1) '0b1' >>> bin(0b0 ^ 0b0) '0b0' 그 외의 비트 연산자는 뒤에서 알아볼게요. 네 자리 이진수의 비트 연산 한자리의 비트 연산자를 이해했으면 네 자리 이진수로 비트 연산을 해 보겠습니다. 우선 & 연산입니다. >>> bin(0b1111 & 0b1100) '0b1100' >>> bin(0b1010 & 0b1100) '0b1000' 비트 연산은 한자리씩 따로따로 계산을 합니다. 위의 결과를 잘 살펴보세요. 다음은 | 연산입니다. >>> bin(0b1111 | 0b1100) '0b1111' >>> bin(0b1010 | 0b1100) '0b1110' ~ 연산도 해 보겠습니다. >>> bin(~0b1100) '-0b1101' >>> bin(~0b1001) '-0b1010' ^ 연산은 어떻게 될지 궁금하군요. >>> bin(0b1111 ^ 0b1100) '0b11' >>> bin(0b1010 ^ 0b1100) '0b110' 시프트 연산 이번에는 시프트(shift) 연산을 알아보겠습니다. 먼저 왼쪽 시프트(<<)입니다. >>> bin(0b1 << 1) '0b10' >>> bin(0b1 << 2) '0b100' >>> bin(0b1 << 3) '0b1000' 위에서 1이 점점 왼쪽으로 이동하는 것을 볼 수 있습니다. 다음은 오른쪽 시프트(>>)입니다. >>> bin(0b1010 >> 1) '0b101' 1이 오른쪽으로 한자리씩 밀린 것을 볼 수 있습니다. 더 많이 시프트 하면 어떻게 될까요? >>> bin(0b1010 >> 2) '0b10' >>> bin(0b1010 >> 3) '0b1' >>> bin(0b1010 >> 4) '0b0' 점점 밀려서 결국 0이 되었네요. 십진수의 비트 연산 그런데 비트 연산을 이진수에만 할 수 있는 것은 아니랍니다. 앞에서 이진수로 했던 계산을 십진수로 다시 해봐도 결과가 같은 것을 볼 수 있습니다. >>> 0b1111 15 >>> 0b1100 12 >>> >>> 15 & 12 12 >>> bin(12) '0b1100' 그도 그럴 것이, 겉으로 보기에 이진수로 나타내든 십진수로 나타내든, 컴퓨터는 이진수를 가지고 계산하고 있을 테니까요. A.4 파이썬으로 PDF 파일 합치기 PDF 문서를 태블릿으로 읽을 때가 많은데, PDF 파일 여러 개를 하나로 합치고 싶을 때가 종종 있더라고요. 파이썬을 이용해 간단히 처리할 수 있습니다. PyPDF2 설치 이 장에서 소개하는 예제를 실행하려면 PyPDF2 패키지라는 패키지가 필요합니다. 명령 프롬프트나 리눅스 셸에서 pip install PyPDF2 명령으로 설치해 주세요. PDF 파일 준비 예제를 실행하려면 병합할 대상이 되는 PDF 파일이 필요합니다. 갖고 계신 PDF 파일을 복사해서 mybook_01.pdf, mybook_02.pdf, mybook_03.pdf, mybook_04.pdf라는 이름으로 준비해 주세요. 첫 번째 버전 그럼 가장 단순한 버전의 코드를 보여드릴게요. from PyPDF2 import PdfFileMerger pdfs = ['mybook_01.pdf', 'mybook_02.pdf', 'mybook_03.pdf', 'mybook_04.pdf'] merger = PdfFileMerger() for pdf in pdfs: merger.append(pdf) merger.write("mybook.pdf") merger.close() 위 코드를 실행하면 파이썬이 실행되는 디렉터리에 있는 네 개의 PDF 파일 mybook_01.pdf, mybook_02.pdf, mybook_03.pdf, mybook_04.pdf가 순서대로 합쳐진 mybook.pdf라는 파일이 만들어집니다. 두 번째 버전 그런데 합치고 싶은 파일이 꼭 네 개만 있으라는 법은 없죠. 그래서 앞에서 배운 glob 모듈을 사용해서 파일명이 mybook으로 시작하는 모든 PDF 파일을 합치도록 개선해 보았습니다. from glob import glob from PyPDF2 import PdfFileMerger BOOK = 'mybook' merger = PdfFileMerger() for f in glob('*' + BOOK + '*.pdf'): merger.append(f) merger.write(BOOK + ".pdf") merger.close() 이제 처음보다는 좀 더 쓸만한 스크립트가 되었습니다. 하지만 계속 쓰다 보니 몇 가지 불편한 점이 더 있더라고요. 스크립트가 있는 폴더와 같은 곳에 있는 파일만 합칠 수 있기 때문에 다른 파일들을 합치려면 스크립트를 복사해야 하고, 파일명도 스크립트에 들어있다 보니 그때그때 수정해야 합니다. 병합된 파일의 이름을 원본과 같은 이름으로 지을 경우, 스크립트를 두 번 이상 실행하면 처음 실행할 때 병합된 파일이 두 번째 실행 때 입력으로 들어가는 문제점도 있었고요. 세 번째 버전 그래서 이번에는 병합할 대상 파일이 있는 디렉터리와 책 제목을 스크립트를 실행할 때 인자로 받을 수 있게 바꿔봤습니다. 제가 현재 실제로 사용하는 스크립트입니다. import argparse from glob import glob import os from PyPDF2 import PdfFileMerger def main(book_title, directory=".", sub_dir='merged'): merger = PdfFileMerger() for f in glob(f"{directory}/{book_title}*.pdf"): merger.append(f) os.chdir(directory) if not os.path.isdir(sub_dir): os.mkdir(sub_dir) merger.write(f"{directory}/{sub_dir}/{bookname}.pdf") merger.close() if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument("-d", "--directory", help="directory where files to be merged live") parser.add_argument("bookname") args = parser.parse_args() directory = args.directory bookname = args.bookname main(args.bookname, args.directory) 인자를 입력받는 기능을 위해 파이썬에서 기본으로 제공하는 argparse 모듈을 이용했습니다. 이 스크립트(pdf_merge.py)를 아무 인자 없이 실행하면 다음과 같이 사용법과 오류 메시지가 출력됩니다. >python pdf_merge.py usage: pdf_merge.py [-h] [-d DIRECTORY] bookname pdf_merge.py: error: the following arguments are required: bookname 이 스크립트의 사용법은 다음과 같습니다. python pdf_merge.py -d <디렉터리> <책 이름> 사용 예 이 스크립트를 실제로 사용한 예를 보여드릴게요. 다음 그림의 윈도 탐색기에는 합치고자 하는 원본 PDF 파일들이 보입니다. 다음 그림과 같이 명령 프롬프트에서 pdf_merge.py를 실행합니다. 실행 결과, 원본 PDF 파일들을 병합한 파일이 merged 디렉터리에 만들어졌습니다. 개선할 점 이 스크립트는 제가 혼자 사용하는 것이라 도움말도 친절하지 않고 기능도 만들다 말았습니다. 출력할 디렉터리 명은 main() 함수의 sub_dir 인자에 merged라고 지정했는데, 이것을 바꾸고 싶다면 argparse를 이용해 인자를 추가해서 main 함수에 넘겨줄 수도 있겠죠. 처음에 그렇게 할 생각이었는데, 별로 필요하지 않아서 완성하지 않았습니다. 여러분이 사용하다가 불편한 점이 있으면 직접 수정해 보세요. A.5 matplotlib으로 하트 그리기 matplotlib 패키지 matplotlib은 플롯(그래프)을 그릴 때 많이 쓰이는 파이썬 라이브러리입니다. matplotlib 프로젝트의 홈페이지 주소는 다음과 같습니다. matplotlib 페이지 http://sourceforge.net/projects/matplotlib/ 파이썬 셸에서 다음 명령을 실행해 보세요. from pylab import * ModuleNotFoundError: No module named 'pylab'이라는 오류 메시지가 나온다면 파이썬 셸에서 빠져나와서 pip install matplotlib 명령(아나콘다 환경에서는 conda install matplotlib)으로 matplotlib을 설치합니다. 하트 그리기 하트를 그려볼게요~ 1 from pylab import * 2 x = linspace(-1.6, 1.6, 10000) 3 f = lambda x: (sqrt(cos(x)) * cos(200 * x) + sqrt(abs(x)) - 0.7) * \ 4 pow((4 - x * x), 0.01) 5 plot(x, list(map(f, x))) 6 show() 실행하면 예쁜 하트가 그려집니다. 코드 설명 2행: linspace()는 주어진 숫자 범위 내에서 동일한 간격으로 떨어진 숫자들을 쉽게 만들어줍니다. >>> import pylab >>> pylab.linspace(5, 7, 20) array([ 5. , 5.10526316, 5.21052632, 5.31578947, 5.42105263, 5.52631579, 5.63157895, 5.73684211, 5.84210526, 5.94736842, 6.05263158, 6.15789474, 6.26315789, 6.36842105, 6.47368421, 6.57894737, 6.68421053, 6.78947368, 6.89473684, 7. ]) 3~4행: 람다 함수를 만들어서 f라는 이름을 붙여주었습니다. 함수 내용이 너무 길어서 역슬래시를 사용해서 두 줄에 나누어 썼습니다. lambda와 map에 대해서는 3.5. 람다의 설명을 참고하세요. pow()는 제곱을 구하는 내장(built-in) 함수입니다. >>> pow(2, 3) sqrt()는 제곱근을, cos()는 코사인을 구하는 함수로, pylab에서 임포트 했습니다. 5행: plot()은 플롯을 만들어주고, 6행: show()를 하면 화면에 보입니다. matplotlib의 사용법을 익히면 다양한 형태의 플롯을 그릴 수 있고, 제목이나 x축, y 축의 라벨을 붙이는 것도 손쉽게 할 수 있답니다. Python 활용: 이미지 처리와 데이터 분석 https://www.slideshare.net/sk8erchoi/anaconda-50854172 A.6 윈도 CMD에서 파이썬 활용 팁 윈도 운영체제의 명령 프롬프트(CMD)에서 파이썬을 편리하게 활용하는 팁을 소개합니다. 파이썬 런처(Python Launcher) 명령행에서 파이썬 스크립트를 호출하는 한 가지 방법은 파이썬 인터프리터 경로와 파이썬 스크립트 파일명을 입력하는 것입니다. 예를 들어 파이썬이 C:\Users\ychoi\AppData\Local\Programs\Python\Python39\에 설치됐다면, 다음과 같이 복잡한 명령을 실행합니다(맨 앞의 >는 윈도 프롬프트 문자열을 뜻하는 것이므로 입력하지 않습니다). > C:\Users\ychoi\AppData\Local\Programs\Python\Python39\python.exe hello.py 위의 방법은 아무래도 번거로운데요, python.org에서 윈도용 파이썬을 다운로드해 설치했다면 함께 설치된 파이썬 런처(Python Launcher)를 이용해 다음과 같이 간편하게 실행할 수 있습니다. > py hello.py 또는 간단히 스크립트 경로만 입력해 실행할 수도 있고요. > hello.py 또한 파이썬 런처에는 파이썬 스크립트의 첫 번째 행에 지정된 파이썬 인터프리터를 찾아 실행해 주는 기능도 있습니다. #!/usr/bin/python3 스크립트의 첫 행이 위와 같이 되어 있다면, 시스템에 설치된 파이썬 3 인터프리터를 사용해 스크립트를 실행해 줍니다. tip 윈도 명령 프롬프트에서 파이썬 스크립트 실행 시 인자가 제대로 전달되지 않을 때 해결 방법 설정 > 앱 > 기본 앱 > 파일 유형별 기본값 선택에서. py를 선택합니다. 앞으로. py 파일을 열 때 사용할 방법을 선택하세요 창에서 이 PC에서 다른 앱 찾기를 선택하고 C:\Windows\py.exe를 지정합니다. 그래도 해결되지 않는다면 윈도 레지스트리를 수정하는 방법을 시도할 수 있습니다. Path 환경 변수 명령행에서 파이썬 스크립트를 실행할 때는 스크립트가 있는 디렉터리(폴더)로 이동해서 실행하거나, 경로를 지정해야 합니다. 스크립트가 있는 디렉터리로 이동해 실행하는 예(C:\GitHub\ychoi\utils에 txt_merge.py 파일이 있다고 가정): C:\Users\ychoi>cd ..\.. C:\>cd GitHub\ychoi\utils C:\GitHub\ychoi\utils>txt_merge.py 경로를 지정해 실행하는 예: C:\Users\ychoi>\GitHub\ychoi\utils\txt_merge.py 위와 같이 디렉터리를 찾아가거나 경로를 입력하기 번거롭다면, 스크립트가 있는 곳을 PATH 환경 변수에 등록해두면 스크립트 파일명만으로 실행할 수 있어 편리합니다. 방법은 다음과 같습니다. + r 키를 누르고 sysdm.cpl 입력 후 확인 버튼을 클릭 시스템 속성 창의 고급 탭에서 환경 변수 버튼을 클릭 사용자 변수에서 Path를 선택하고 편집 버튼을 클릭 환경 변수 편집 창의 새로 만들기 버튼을 클릭하고 스크립트가 있는 디렉터리를 입력하고 확인 버튼을 클릭 이제 명령 프롬프트 창을 닫고 새로운 명령 프롬프트 창을 열면 어느 위치에서나 (Path에 등록된 경로의) 스크립트를 실행할 수 있습니다. C:\Users\ychoi>txt_merge.py PATHEXT 환경 변수 파이썬 스크립트를 확장자(.py) 없이 호출하고 싶다면 시스템 PATHEXT 환경 변수에. PY를 등록합니다. (기존 환경 변수의 맨 뒤에 ;를 붙이고. PY를 입력합니다.) 이제 명령 프롬프트 창을 닫고 새로운 창을 열면 다음과 같이 확장자 없이 스크립트를 실행할 수 있습니다. >txt_merge A.7 일회용 스크립트를 재사용 가능하게 바꾸기 우리는 귀찮은 작업을 편하게 처리하려고, 또는 수작업을 하다가 실수를 하지 않으려고 스크립트를 작성하죠. 그런데 가끔은 딱 한 번만 쓰고 말 생각으로, 또는 단 한 가지 용도로 스크립트를 작성하기도 합니다. 아래 스크립트가 그 예입니다. 파일명: wikidocs_toc_chobopython.py 1 import urllib.request 2 from bs4 import BeautifulSoup 3 4 5 url = 'https://wikidocs.net/book/2' 6 with urllib.request.urlopen(url) as f: 7 html = f.read().decode('utf-8') 8 9 soup = BeautifulSoup(html, 'html.parser') 10 titles = soup.select('.list-group-item > span') 11 for title in titles[1:]: 12 s = title.select('span')[0].text.strip() 13 print(s) 이 스크립트를 실행하면 위키독스의 《왕초보를 위한 파이썬》(https://wikidocs.net/book/2) 목차가 다음과 같이 출력됩니다. $ python3 wikidocs_toc_chobopython.py 0 머리말 0.1 주요 변경 이력 1 파이썬 시작하기 1.1 파이썬 맛보기 1.2 변수 1.2.1 연습 문제: 파일 크기 계산 ... A.4 파이썬으로 PDF 파일 합치기 A.5 matplotlib으로 하트 그리기 A.6 윈도 CMD에서 파이썬 활용 팁 Bye~ 이 스크립트를 작성할 때만 해도 이 책 외에 다른 책의 목차를 출력할 일이 없을 것으로 생각했는데, 나중에 그럴 필요가 생겼다면 어쩌면 좋을까요? 예를 들어, 《 SQLite3로 가볍게 배우는 데이터베이스》(https://wikidocs.net/book/1530)의 목차를 출력하고 싶다면요? 가장 쉬운 방법은 스크립트를 복사해서 새로운 파일(예: wikidocs_toc_sqlite3.py)을 만든 뒤, 새로 만든 스크립트의 5번째 줄을 다음과 같이 수정하는 것이겠죠. url = 'https://wikidocs.net/book/1530' 이 스크립트를 실행하면 다음 결과가 출력됩니다. $ python3 wikidocs_toc_sqlite3.py A01 도입 A02 실습 환경 갖추기 A03 데이터베이스와 테이블 만들기 A04 추가, 삭제, 갱신, 조회 (1) ... B03 실전 예제 - 전기차 충전소 데이터 정제 B04 실전 예제 - 새의 GPS 데이터 가공(1) B05 실전 예제 - 새의 GPS 데이터 가공(2) 현재 코드 현재 코드는 다음 링크에서 확인할 수 있습니다. wikidocs_toc_chobopython.py wikidocs_toc_sqlite3.py 스크립트의 사용성을 개선하는 과정 그런데 또 다른 책의 목차를 알고 싶어지면, 그때는 어떻게 해야 할까요? 기능이 거의 비슷하지만 똑같지는 않은 스크립트가 필요해지면, 새로운 스크립트를 작성해야만 할까요? 이런 일을 다음에 또 해야 한다면, 하루에도 여러 번 해야 한다면, 그때마다 스크립트를 수정해서 저장한 다음 실행하는 것조차 귀찮은 일이 되어버립니다. 그렇다면, 단 한 가지 일만 처리하는 스크립트 여러 개를 작성하는 것보다, 스크립트 하나로 여러 가지 일을 처리할 수 있게, 즉 ‘재사용’이 가능하게, 이전에 만들어둔 스크립트를 손질하는 것이 좋을 수도 있습니다. 이럴 때 스크립 트을 어떻게 바꿔 나가는 것이 좋을지를 단계별로 소개하려고 합니다. 모든 단계를 끝내야 하는 것이 아니라, 한 단계를 마칠 때마다 바로 사용할 수 있으면서도 이전보다는 조금씩 더 편리해질 것입니다. 여기서 소개하는 순서나 방법이 반드시 옳다기보다는, 이런 식으로도 할 수 있다는 예시로 이해해 주시면 되겠습니다. 실행 가능하게 만들기 대상을 인자로 받기 명령을 인자로 받기 기능 추가 도움말 추가 A.7.1 실행 가능하게 만들기 목표 터미널(또는 명령 프롬프트)에 python3 wikidocs_toc_chobopython.py를 타자하는 대신 스크립트 파일명인 wikidocs_toc_chobopython.py만 타자해서 실행하게 만드는 것이 이번 단계의 목표입니다. 스크립트를 한 번 실행할 때마다 타자할 글자 수를 7~8 글자 줄이는 효과가 있죠. 절차 스크립트에 실행 권한(execute permission)을 부여합니다. 예: $ cmod +x wikidocs_toc_chobopython.py 첫 번째 줄에 다음 행을 추가합니다. 이런 것을 ‘시뱅(shebang)’이라고 부릅니다. #!/usr/bin/python3 커밋 로그 d454ebe 현재 코드 wikidocs_toc_chobopython.py wikidocs_toc_sqlite3.py 스크립트 사용 예 이제 터미널에서 python 또는 python3를 없이, 스크립트 파일명만 타자해서 스크립트를 실행할 수 있습니다. $ wikidocs_toc_chobopython.py 0. 머리말 0.1 주요 변경 이력 1. 파이썬 시작하기 1.1 파이썬 맛보기 ... $ wikidocs_toc_sqlite3.py A01 도입 A02 실습 환경 갖추기 A03 데이터베이스와 테이블 만들기 A04 추가, 삭제, 갱신, 조회 (1) ... A.7.2 대상을 인자로 받기 목표 지금은 책의 URL이 하드 코딩되어 있어서, 다른 책의 목차를 출력하고 싶으면 그때마다 스크립트를 열어서 수정해야 하는 불편이 있습니다. 스크립트를 실행할 때 책 번호(예: 왕초보를 위한 파이썬의 URL https://wikidocs.net/book/2에서 책 번호는 2)를 인자로 받을 수 있게 함으로써, 스크립트를 매번 수정하지 않고도 다른 책의 목차를 얻을 수 있게 바꾸는 것이 이번 단계의 목표입니다. 절차 파이썬에서 명령행의 인자를 알아내는 가장 원초적(?)인 방법은 sys 모듈의 argv를 사용하는 것입니다. 스크립트의 앞부분에 다음 문장을 추가합니다. import sys 하드코딩했던 것을 인잣값을 전달받도록 수정합니다. url = 'https://wikidocs.net/book/' + sys.argv[1] 이제 새로운 책의 목차를 얻을 때마다 스크립트를 수정하거나 책마다 스크립트를 따로 만들 필요가 없어졌습니다. 스크립트 이름은 wikidocs_toc_chobopython.py에서 wikidocs_toc.py로 바꾸는 것이 좋겠습니다. 그리고 wikidocs_toc_sqlite3.py는 이제 필요 없으므로 삭제합니다. 커밋 로그 376573d 현재 코드 두 개였던 스크립트가 하나로 줄었습니다. wikidocs_toc.py 스크립트 사용 예 $ wikidocs_toc.py 6038 강좌 소개 0. 탐색 0.1 탐색 문제 정의 0.2 탐색 문제 풀기 0.3 무정보(uninformed) 탐색 - 깊이 우선(depth-first), 너비 우선(breadth-first) 0.3.1 DFS와 BFS의 장단점 ... A.7.3 명령을 인자로 받기 책의 목차를 얻어오는 스크립트를 만들어서 잘 쓰고 있었는데, 이번에는 본문 내용을 가져올 일이 생겼습니다. 본문만을 처리하는 스크립트를 따로 만들지 않고, 기존 스크립트에 기능을 추가하고 싶습니다. 이 기능은 (1) 명령을 인자로 받기와 (2) 새로운 명령을 추가하기의 두 단계로 구현합니다. 목표 명령을 받는 인자를 추가합니다. 절차 인자: 첫 번째 인자: 명령(toc) 두 번째 인자: 책 번호 파일명을 wikidocs_toc.py에서 wikidocs.py로 바꿉니다. 커밋 로그 8c72b45 현재 코드 wikidocs.py 스크립트 사용 예 $ wikidocs.py toc 2 0. 머리말 0.1 주요 변경 이력 1. 파이썬 시작하기 ... A.7.4 기능 추가 목표 본문 내용을 출력하는 기능을 추가합니다. 절차 책 내용을 받아오는 명령을 추가합니다. 인자: 첫 번째 인자: 명령(toc 또는 content) 두 번째 인자: 책 번호 또는 페이지 번호 커밋 로그 2dff0a4 현재 코드 wikidocs.py 스크립트 사용 예 $ wikidocs.py content 43 프로그래밍은 재미있습니다. 진짜로 재미있습니다. 그 재미를 알려면 프로그래밍을 직접 해봐야 하는데, 사실 프로그래밍을 시작하는 것이 쉽지가 않습니다. 그래서 여러분과 함께 배우기 쉬운 파이썬이라는 언어를 함께 공부해 보려고 합니다. ... A.7.5 도움말 추가 스크립트에 도움말(help) 기능이 있으면 다른 사람이 활용하는 데 도움이 됩니다. 스크립트를 만든 본인도 시간이 흐르면 사용법이 잘 생각나지 않아서 코드를 들여다보게 되니, 자신에게도 도움이 됩니다. 목표 스크립트 사용법을 알려주는 help 옵션을 추가합니다. 절차 도움말을 작성합니다. 도움말을 출력하는 명령을 추가합니다. 예에서는 sys.argv를 사용했지만, argparse를 사용해도 좋습니다. 커밋 로그 4a53548 현재 코드 wikidocs.py 스크립트 사용 예 $ wikidocs.py Number of arguments is not matched Try "python wikidocs.py help". $ wikidocs.py help Usage: python wikidocs.py <command> [content id] Description: Available commands are toc, content and help. Content id should be a number. Examples: python wikidocs.py toc 2 python wikidocs.py content 43 Bye~ 끝까지 완주하신 여러분 축하합니다! 그리고 읽어주셔서 고맙습니다. 느끼신 점을 댓글로 남겨주시면 좋겠습니다. 파이썬을 좀 더 알고 싶다면 제가 번역한 《실용 파이썬 프로그래밍》도 한번 읽어보세요.<|endoftext|>

전문분야 텍스트 ### 제목: PyTorch로 시작하는 딥 러닝 입문 ### 본문: 이 책은 딥 러닝 프레임워크 PyTorch를 사용하여 딥 러닝에 입문하는 것을 목표로 합니다. 이 책은 파이썬은 어느 정도 할 줄 안다고 가정합니다. 이 이상의 심화 내용(트랜스포머와 언어 모델)을 원하시는 분은 아래의 책을 참고하시기 바랍니다. 동일 저자의 자연어 처리 학습 자료 딥 러닝을 이용한 자연어 처리 입문 : https://wikidocs.net/book/2155 감사합니다. 00. 책과 저자 소개하기 안녕하세요. 이 책은 8년 차 자연어 처리 엔지니어들이 입문자들을 위해 제작하고 있는 딥 러닝 입문 학습 자료입니다. 비전공자분들도 자연어 처리를 쉽게 입문할 수 있는 자료를 만들기 위해 노력하고 있습니다. 가급적 질문에 답변드리려고 합니다만 실수로 놓치기도 하고, 성의 없는 질문, 삐딱한 말투 등은 답변드리지 않을 수 있습니다. 학생이신 분들의 과제, 논문을 위한 코드 대행은 해드리지 않고 있으니 문의하지 말아주세요. E-mail : <EMAIL> (저자 이메일) <NAME>(대기업 NLP 엔지니어) - IT 대기업에서 자연어 처리 엔지니어로 재직하고 있습니다. BERT, BART, T5와 같은 PLM, 그리고 LLM을 튜닝하며 현실의 다양한 문제를 푸는 것에 관심이 많습니다. <NAME>(인공지능 엔지니어 / 강사 / 겸임 교수) : - 삼성에서 인공지능 연구원을 시작으로 커리어를 시작하여 현재는 AI 겸임 교수 및 컨설턴트로 활동하고 있습니다. 연세대학교, 인천대학교, 서울예술대학교, 서울과학종합대학원, 경희대학교, 이화여자대학교 등 다수의 학교와 기업에서 인공지능 강의 및 멘토링을 진행한 적이 있습니다. 과외 및 교육 문의는 이메일로 부탁드립니다. 감사합니다. 딥 러닝 프레임워크로는 Pytorch를 사용합니다. 기본적으로 구글 Colab에서 실습을 하는 것을 가정합니다. 컴퓨터, 기계, 모델을 같은 의미로 사용합니다. 학습(learning)과 훈련(training) 이 같은 의미로 사용합니다. 비용 함수(cost function), 손실 함수(loss function)는 같은 의미로 사용합니다. References : 위키독스 : 딥 러닝을 이용한 자연어 처리 입문 (동일 저자) 파이 토치 공식 튜토리얼 01. [기초 ✔] - 딥 러닝을 시작하기 전에 이번 챕터에서는 실습 환경 및 기본적으로 필요한 파이썬 라이브러리들에 대해서 소개하며 딥 러닝 실습을 준비합니다. 01-01 코랩(Colab)과 아나콘다 머신 러닝 실습을 하기 위해서는 많은 패키지가 필요합니다. 이를 일일이 설치하는 것보다는 필요한 패키지들을 모아놓은 파이썬 배포판 '아나콘다'를 설치하는 것을 권장합니다. 아나콘다는 Numpy, Pandas, Jupyter Notebook, IPython, scikit-learn, matplotlib, seaborn, nltk 등 이 책에서 사용할 대부분의 패키지를 전부 포함하고 있습니다. 여기서는 윈도 환경을 기준으로 두고 아나콘다를 설치하는 방법과 인터넷을 통해 편하게 사용할 수 있는 파이썬 실습 환경인 구글의 코랩(Colab)을 소개합니다. GPU 실습을 위해서 아나콘다와 코랩 둘 중에서는 가급적이면 코랩에서 실습하시기를 권합니다. 1. 아나콘다(Anaconda) 설치 링크 : https://www.anaconda.com/distribution/ 위 사이트 링크로 이동하여 사이트 하단으로 이동하면 (저자가 이 책을 작성할 당시 기준) 좌측에 파이썬 3.7 버전과 우측에 파이썬 2.7 버전의 아나콘다 설치 파일이 있습니다. 여기서는 파이썬 3.7 버전 64 비트를 설치합니다. 설치 파일을 실행한 후에 다른 윈도 프로그램을 설치하는 것과 마찬가지로 Next >를 누르면서 설치를 완료하면 됩니다. 아나콘다를 설치하면 머신 러닝을 위한 기본적인 파이썬 패키지들은 자동으로 설치가 됩니다. 다만 텐서 플로, 케라스, 젠심, 코엔엘파이와 같은 패키지들은 별도 설치가 필요한데 이에 대해서는 뒤에서 추가적으로 설명하겠습니다. 아나콘다를 다 설치했다면 아나콘다 프롬프트를 오픈하겠습니다. 아나콘다 프롬프트를 열었다면 아나콘다 프롬프트에 아래의 커맨드를 입력하여 아나콘다 파이썬 패키지를 전부 최신 버전으로 업데이트합니다. > conda update -n base conda > conda update --all 이 책이 작성되었을 당시에는 파이썬 3.7 버전이 최신 버전이었지만, 독자분들이 파이썬을 설치하기 위해서 아나콘다 페이지에 접속하였을 때는 3.7보다 더욱 최신 버전으로 업데이트가 되었을 수 있습니다. 이 경우 무작정 파이썬 최신 버전을 설치하는 것은 좋은 방법이 아닙니다. 일반적으로 아래의 링크에서 파이썬 버전과 호환되는 텐서 플로 버전에 대한 안내가 나와있으니 반드시 설치 전 확인이 필요합니다. 링크 : https://www.tensorflow.org/install/pip? hl=ko 예를 들어 위 페이지에서 'Python 3.9 지원에는 Tensorflow 2.5 이상이 필요합니다.'라고 기재돼 있다면, 파이썬 3.9를 설치하였을 때는 반드시 Tensorflow는 2.5 이상을 설치해야만 합니다. 2. 구글의 코랩(Colab) 텐서 플로는 기본적으로 64비트 플랫폼만을 지원하므로 32비트 환경에서는 딥 러닝 실습 환경을 구축하기에는 많은 애로 사항이 있습니다. 또는 개인의 컴퓨터 사양이나 다른 이유로 아나콘다나 여러 패키지 설치가 어려운 경우도 있을 것입니다. 이런 경우에는 인터넷만 된다면 바로 파이썬을 실습할 수 있는 구글의 코랩(Colab)이 있습니다. 구글의 Colab은 뒤에서 설명하게 될 '주피터 노트북'과 매우 유사한 실습 환경을 제공합니다. Colab 주소 : https://colab.research.google.com/ 구글의 Colab에 접속하는 방법은 위의 URL을 통해서 접속하거나, 구글(http://www.google.co.kr/)에서 Colab이라고 검색해서 접속할 수 있습니다. 1) 파이썬 실습하기 Colab 사용 시에는 구글 계정이 필요하므로 구글 아이디가 없으신 분들은 먼저 회원가입 후 로그인부터 해주세요. 로그인 후 좌측 상단에서 파일 > 새 노트를 클릭합니다. 조금만 기다리면 파이썬을 실습할 수 있는 실습 환경 창이 뜨게 됩니다. 이때 위 그림과 같이 Colab에서 코드를 작성하는 부분의 단위를 '셀'이라고 합니다. 그림에서 보이는 좌측 상단의 '+ 코드' 버튼을 클릭하여 새로운 셀을 추가할 수 있으며, 셀에서 코드를 작성하고 Shift + Enter 키를 눌러서 코드를 실행할 수 있습니다. 셀에 3 + 5라는 코드를 작성하고, Shift + Enter를 누르면 8이라는 결과가 나오게 됩니다. 좌측에 [1]은 해당 코드가 몇 번째로 실행되었는지를 의미합니다. 셀을 추가해 보면서 다른 파이썬 코드도 추가적으로 작성해 보세요. 2) 무료로 GPU 사용하기 딥 러닝에서는 CPU보다는 GPU를 사용합니다. Colab에서 실습할 때의 장점은 GPU를 무료로 사용할 수 있다는 점입니다. GPU가 장착된 컴퓨터가 없는 딥 러닝 입문자들은 향후 이 책의 실습을 진행할 때 Colab에서 GPU를 사용하면서 딥 러닝을 공부하는 것을 강하게 권장 드립니다. GPU를 사용하지 않고 실습을 진행하면 딥 러닝 모델을 학습하는 시간이 지나치게 소요될 수 있습니다. Colab에서 GPU를 사용하는 방법은 새 노트에 진입했을 때 상단에서 런타임 > 런타임 유형 변경을 클릭합니다. 노트 설정의 하드웨어 가속기 > GPU를 선택 후 저장을 누릅니다. 이후 실습을 진행합니다. 3) 파일 업로드 구글의 Colab에서 데이터를 업로드하여 해당 데이터로 실습을 하고자 한다면, 좌측 상단에서 폴더 모양의 버튼을 클릭합니다. 그 후 위 방향의 화살표(↑)가 그려진 버튼을 클릭하여 파일을 업로드할 수 있습니다. 위 그림에서 숫자 1번 버튼과 숫자 2번 버튼이 각각 이에 해당합니다. 예를 들어 test.txt 파일을 업로드한다고 해봅시다. 업로드 후에는 파일 목록에 test.txt 파일이 보입니다. 01-02 NLTK와 KoNLPy 설치하기 코랩에서 실습을 진행하시는 분들은 신경 쓰지 않으셔도 됩니다. 하지만 자신만의 환경에서 실습을 진행하려고 하시는 분들은 NLTK와 KoNLPy 설치에 어려움을 겪는 경우가 많아서 준비한 챕터입니다. 1. NLTK와 NLTK Data 설치 엔엘티케이(NLTK)는 자연어 처리를 위한 파이썬 패키지입니다. 아나콘다를 설치하였다면 NLTK는 기본적으로 설치가 되어 있습니다. 아나콘다를 설치하지 않았다면 아래의 커맨드로 NLTK를 별도 설치할 수 있습니다. > pip install nltk > ipython ... In [1]: import nltk In [2]: nltk.__version__ Out[2]: '3.4.5' NLTK의 기능을 제대로 사용하기 위해서는 NLTK Data라는 여러 데이터를 추가적으로 설치해야 합니다. 이를 위해서는 파이썬 코드 내에서 import nltk 이후에 nltk.download()라는 코드를 수행하여 설치합니다. In [3]: nltk.download() 해당 코드를 실행 후에 NLTK 실습에 필요한 각종 패키지와 코퍼스를 다운로드할 수 있습니다. 이를 통칭하여 NLTK Data라고 하겠습니다. 만약, NLTK 실습을 수행하던 도중에 에러가 발생한다면 아래의 2번과 3번 가이드를 참고하시기 바랍니다. 2. NLTK Data가 설치되지 않은 경우 NLTK는 각 실습마다 필요한 NLTK Data가 있습니다. 만약 해당 실습에 필요한 NLTK Data가 설치되지 않은 경우에는 코드 실행 시에 아래와 같은 경고문이 나타납니다. LookupError: ********************************************************************** Resource treebank not found. Please use the NLTK Downloader to obtain the resource: >>> import nltk >>> nltk.download('treebank') ********************************************************************** 위의 경우에는 NLTK Data 중에서 'treebank'라는 리소스가 설치되지 않았을 경우입니다. 이 경우 위의 안내처럼 주피터 노트북 또는 iPython 쉘 안에서 동일하게 코드를 수행하면 됩니다. In [1]: import nltk In [2]: nltk.download('treebank') 3. NLTK Data 설치 시 에러가 발생할 경우 링크 : https://github.com/nltk/nltk_data 설치 시 에러가 발생한다면, 수동 설치를 진행하여 정해진 경로에 위치시켜야 합니다. 수동 설치를 진행할 수 있는 경로는 nltk_data의 깃허브 주소와 nltk_data 공식 사이트 두 곳이 있습니다. 우선 nltk_data의 깃허브 사이트의 링크는 위와 같습니다. 위 링크의 packages 디렉터리에서 필요한 nltk_data 파일들을 모두 다운로드할 수 있습니다. 예를 들어서 토큰화 작업을 위해 'punkt' 파일이 필요하다면, nltk_data/packages/tokenizer 경로에서 punkt.zip 파일을 다운로드하면 됩니다. 이렇게 필요한 파일들을 다운로드한 후, 각 O/S 별 정해진 경로에 위치시킵니다. 각 O/S 별 정해진 경로는 다음과 같습니다. 윈도 : C:/nltk_data 또는 D:/nltk_data UNIX : /usr/local/share/nltk_data/ 또는 /usr/share/nltk_data 가장 간단한 방법으로는 packages 디렉터리 전체를 다운로드해 경로에 위치시키는 방법도 있습니다. 링크 : http://www.nltk.org/nltk_data/ 수동 설치를 진행할 수 있는 사이트로 nltk_data 공식 사이트도 있습니다. 토큰화 작업이 필요한 상황이라고 다시 가정합시다. 그렇다면 위 링크로 이동해 CTRL + F를 눌러 'tokenizer'를 검색하고, 검색에 나오는 106. Punkt Tokenizer Models [ download | source ] 해당 줄을 찾은 뒤, download 버튼을 누르면 됩니다. 그러면 punkt.zip 파일을 다운로드할 수 있습니다. 다운로드 후 위치시켜야 하는 알맞은 경로는 위에서 언급한 경로와 동일합니다. 4. KoNLPy 설치 코엔엘파이(KoNLPy)는 한국어 자연어 처리를 위한 형태소 분석기 패키지입니다. 프롬프트에서 아래 커맨드로 설치합니다. > pip install konlpy > ipython ... In [1]: import konlpy In [2]: konlpy.__version__ Out[2]: '0.5.1' 5. 윈도에서 KoNLPy 에러가 발생하는 경우 윈도에서 KoNLPy를 설치하거나 실행 시 JDK 관련 오류나 JPype 오류에 부딪히는 경우가 있습니다. 이는 KoNLPy가 JAVA로 구성되어 있기 때문인데 오류 해결을 위해서는 JDK 1.7 이상의 버전과 JPype가 설치되어 있어야 합니다. 1) JDK 설치 우선 JDK를 1.7 버전 이상으로 설치해야 합니다. 설치 주소 : https://www.oracle.com/technetwork/java/javase/downloads/index.html 설치한 후에는 JDK가 설치된 경로를 찾아야 합니다. 예를 들어 저자의 경우에는 jdk가 아래의 경로에 설치되어 있습니다. 경로 : C:\Program Files\Java\jdk-11.0.1 11.0.1과 같이 버전에 대한 숫자는 어떤 버전을 설치했느냐에 따라 다를 수 있습니다. 2) JDK 환경 변수 설치 경로를 찾았다면 해당 경로를 복사합니다. 해당 경로를 윈도 환경 변수에 추가해야 하기 때문입니다. 윈도 10기준) 제어판 > 시스템 및 보안 > 시스템 > 고급 시스템 설정 > 고급 > 환경 변수 새로 만들기(N)...를 누르고 JAVA_HOME이라는 환경 변수를 만듭니다. 환경 변수의 값은 앞서 찾았던 jdk 설치 경로입니다. 이제 KoNLPy를 사용하기 위한 JDK 설정을 마쳤습니다. 3) JPype 설치 이제 JAVA와 Python을 연결해 주는 역할을 하는 JPype를 설치해야 합니다. 설치 주소 : https://github.com/jpype-project/jpype/releases 해당 링크에서 Assets라고 기재된 곳에서 적절한 버전을 설치해야 하는데 cp27은 파이썬 2.7, cp36은 파이썬 3.6을 의미합니다. 저자가 책을 집필할 당시에는 파이썬 3.6을 사용하고 있었으므로 cp36이라고 적힌 JPype를 설치했습니다. 또 사용하는 윈도 O/S가 32비트인지, 64비트인지에 따라서 설치 JPype가 다른데, 윈도 32비트를 사용하고 있다면 win32를, 윈도 64비트를 사용하고 있다면 win_amd64를 설치해야 합니다. 예를 들어 파이썬 3.6, 윈도 64비트를 사용 중이라면 JPype1-0.6.3-cp36-cp36m-win_amd64.whl를 다운로드합니다. 프롬프트에서 해당 파일의 경로로 이동하여 아래 커맨드를 통해 설치합니다. > pip install JPype1-0.6.3-cp36-cp36m-win_amd64.whl 이제 JPype의 설치가 완료되었다면, KoNLPy를 사용할 준비가 되었습니다. 참고 : KoNLPy 수행 시 자바 오류는, 파이썬 bit와 자바 bit가 다른 경우도 발생하는 것 같습니다. 가장 확실한 해결 방법은 설치된 자바를 전부<NAME>고 최신 버전(JRE, JDK)으로 새로 깔면 대부분 해결됩니다. 01-03 판다스(Pandas) and 넘파이(Numpy) and 맷플롭립(Matplotlib) 데이터 분석을 위한 필수 패키지 삼대장이 있습니다. 바로 Pandas와 Numpy 그리고 Matplotlib입니다. 세 개의 패키지 모두 아나콘다를 설치했다면 추가 설치 없이 사용할 수 있습니다. 이 세 개의 패키지를 간단히 실습해 봅시다. 1. 판다스(Pandas) 판다스(Pandas)는 파이썬 데이터 처리를 위한 라이브러리입니다. 파이썬을 이용한 데이터 분석과 같은 작업에서 필수 라이브러리로 알려져 있습니다. 참고할 수 있는 Pandas 링크는 다음과 같습니다. 링크 : http://pandas.pydata.org/pandas-docs/stable/ 아나콘다를 설치하지 않았다면 아래의 커맨드로 Pandas를 별도 설치할 수 있습니다. pip install pandas > ipython ... In [1]: import pandas as pd In [2]: pd.__version__ Out[2]: '0.25.1' Pandas의 경우 pd라는 명칭으로 임포트 하는 것이 관례입니다. import pandas as pd Pandas는 총 세 가지의 데이터 구조를 사용합니다. 시리즈(Series) 데이터 프레임(DataFrame) 패널(Panel) 이 중 데이터 프레임이 가장 많이 사용되며 여기서는 시리즈와 데이터 프레임에 대해서 다룹니다. 1) 시리즈(Series) 시리즈 클래스는 1차원 배열의 값(values)에 각 값에 대응되는 인덱스(index)를 부여할 수 있는 구조를 갖고 있습니다. sr = pd.Series([17000, 18000, 1000, 5000], index=["피자", "치킨", "콜라", "맥주"]) print('시리즈 출력 :') print('-'*15) print(sr) 시리즈 출력 : --------------- 피자 17000 치킨 18000 콜라 1000 맥주 5000 dtype: int64 값(values)과 인덱스(index)를 출력합니다. print('시리즈의 값 : {}'.format(sr.values)) print('시리즈의 인덱스 : {}'.format(sr.index)) 시리즈의 값 : [17000 18000 1000 5000] 시리즈의 인덱스 : Index(['피자', '치킨', '콜라', '맥주'], dtype='object') 2) 데이터 프레임(DataFrame) 데이터 프레임은 2차원 리스트를 매개변수로 전달합니다. 2차원이므로 행방향 인덱스(index)와 열 방향 인덱스(column)가 존재합니다. 다시 말해 행과 열을 가지는 자료구조입니다. 시리즈가 인덱스(index)와 값(values)으로 구성된다면, 데이터 프레임은 열(columns)까지 추가되어 열(columns), 인덱스(index), 값(values)으로 구성됩니다. 이 세 개의 구성 요소로부터 데이터 프레임을 생성해 봅시다. values = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] index = ['one', 'two', 'three'] columns = ['A', 'B', 'C'] df = pd.DataFrame(values, index=index, columns=columns) print('데이터 프레임 출력 :') print('-'*18) print(df) 데이터 프레임 출력 : ------------------ A B C one 1 2 3 two 4 5 6 three 7 8 9 생성된 데이터 프레임으로부터 인덱스(index), 값(values), 열(columns)을 각각 출력해 보겠습니다. print('데이터 프레임의 인덱스 : {}'.format(df.index)) print('데이터 프레임의 열이름: {}'.format(df.columns)) print('데이터 프레임의 값 :') print('-'*18) print(df.values) 데이터 프레임의 인덱스 : Index(['one', 'two', 'three'], dtype='object') 데이터 프레임의 열이름: Index(['A', 'B', 'C'], dtype='object') 데이터 프레임의 값 : ------------------ [[1 2 3] [4 5 6] [7 8 9]] 3) 데이터 프레임의 생성 데이터 프레임은 리스트(List), 시리즈(Series), 딕셔너리(dict), Numpy의 ndarrays, 또 다른 데이터 프레임으로부터 생성할 수 있습니다. 여기서는 리스트와 딕셔너리를 사용하여 데이터 프레임을 생성해 보겠습니다. 우선 이중 리스트로 생성하는 경우입니다. # 리스트로 생성하기 data = [ ['1000', 'Steve', 90.72], ['1001', 'James', 78.09], ['1002', 'Doyeon', 98.43], ['1003', 'Jane', 64.19], ['1004', 'Pilwoong', 81.30], ['1005', 'Tony', 99.14], ] df = pd.DataFrame(data) print(df) 0 1 2 0 1000 Steve 90.72 1 1001 James 78.09 2 1002 Doyeon 98.43 3 1003 Jane 64.19 4 1004 Pilwoong 81.30 5 1005 Tony 99.14 생성된 데이터 프레임에 열(columns)을 지정해 줄 수 있습니다. 열이름을 지정하고 출력해 봅시다. df = pd.DataFrame(data, columns=['학번', '이름', '점수']) print(df) 학번 이름 점수 0 1000 Steve 90.72 1 1001 James 78.09 2 1002 Doyeon 98.43 3 1003 Jane 64.19 4 1004 Pilwoong 81.30 5 1005 Tony 99.14 파이썬 자료구조 중 하나인 딕셔너리(dictionary)를 통해 데이터 프레임을 생성해 보겠습니다. # 딕셔너리로 생성하기 data = { '학번' : ['1000', '1001', '1002', '1003', '1004', '1005'], '이름' : [ 'Steve', 'James', 'Doyeon', 'Jane', 'Pilwoong', 'Tony'], '점수': [90.72, 78.09, 98.43, 64.19, 81.30, 99.14] } df = pd.DataFrame(data) print(df) 학번 이름 점수 0 1000 Steve 90.72 1 1001 James 78.09 2 1002 Doyeon 98.43 3 1003 Jane 64.19 4 1004 Pilwoong 81.30 5 1005 Tony 99.14 4) 데이터 프레임 조회하기 아래의 명령어는 데이터 프레임에서 원하는 구간만 확인하기 위한 명령어로서 유용하게 사용됩니다. df.head(n) - 앞 부분을 n 개만 보기 df.tail(n) - 뒷부분을 n 개만 보기 df['열 이름'] - 해당되는 열을 확인 위에서 사용한 데이터 프레임을 그대로 사용하여 실습해 봅시다. # 앞 부분을 3개만 보기 print(df.head(3)) 학번 이름 점수 0 1000 Steve 90.72 1 1001 James 78.09 2 1002 Doyeon 98.43 # 뒷부분을 3개만 보기 print(df.tail(3)) 학번 이름 점수 3 1003 Jane 64.19 4 1004 Pilwoong 81.30 5 1005 Tony 99.14 # '학번'에 해당되는 열을 보기 print(df['학번']) 0 1000 1 1001 2 1002 3 1003 4 1004 5 1005 Name: 학번, dtype: object 5) 외부 데이터 읽기 Pandas는 CSV, 텍스트, Excel, SQL, HTML, JSON 등 다양한 데이터 파일을 읽고 데이터 프레임을 생성할 수 있습니다. 예를 들어 csv 파일을 읽을 때는 pandas.read_csv()를 통해 읽을 수 있습니다. 다음과 같은 example.csv 파일이 있다고 합시다. df = pd.read_csv('example.csv') print(df) student id name score 0 1000 Steve 90.72 1 1001 James 78.09 2 1002 Doyeon 98.43 3 1003 Jane 64.19 4 1004 Pilwoong 81.30 5 1005 Tony 99.14 이 경우 인덱스가 자동으로 부여됩니다. 인덱스를 출력해 보겠습니다. print(df.index) RangeIndex(start=0, stop=6, step=1) 2. 넘파이(Numpy) 넘파이(Numpy)는 수치 데이터를 다루는 파이썬 패키지입니다. Numpy의 핵심이라고 불리는 다차원 행렬 자료구조인 ndarray를 통해 벡터 및 행렬을 사용하는 선형 대수 계산에서 주로 사용됩니다. Numpy는 편의성뿐만 아니라, 속도 면에서도 순수 파이썬에 비해 압도적으로 빠르다는 장점이 있습니다. 아나콘다를 설치하지 않았다면 아래의 커맨드로 Numpy를 별도 설치할 수 있습니다. pip install numpy > ipython ... In [1]: import numpy as np In [2]: np.__version__ Out[2]: '1.16.5' Numpy의 경우 np라는 명칭으로 임포트 하는 것이 관례입니다. import numpy as np 1) np.array() Numpy의 핵심은 ndarray입니다. np.array()는 리스트, 튜플, 배열로부터 ndarray를 생성합니다. 파이썬 자료구조 중 하나인 리스트를 가지고 1차원 배열을 생성해 보겠습니다. # 1차원 배열 vec = np.array([1, 2, 3, 4, 5]) print(vec) [1 2 3 4 5] 2차원 배열을 만들어보겠습니다. 주의할 점은 array() 안에 하나의 리스트만 들어가므로 리스트의 리스트를 넣어야 합니다. # 2차원 배열 mat = np.array([[10, 20, 30], [ 60, 70, 80]]) print(mat) [[10 20 30] [60 70 80]] 두 배열의 타입을 확인해 봅시다. print('vec의 타입 :',type(vec)) print('mat의 타입 :',type(mat)) vec의 타입 : <class 'numpy.ndarray'> mat의 타입 : <class 'numpy.ndarray'> 동일하게 타입이 numpy.ndarray라고 나오게 됩니다. Numpy 배열에는 축의 개수(ndim)와 크기(shape)라는 개념이 존재하는데, 배열의 크기를 정확히 숙지하는 것은 딥 러닝에서 매우 중요합니다. 축의 개수와 크기가 어떤 의미를 가지는지에 대해서는 머신 러닝 챕터에서 벡터와 행렬 연산을 설명할 때 언급하겠습니다. print('vec의 축의 개수 :',vec.ndim) # 축의 개수 출력 print('vec의 크기(shape) :',vec.shape) # 크기 출력 vec의 축의 개수 : 1 vec의 크기(shape) : (5, ) print('mat의 축의 개수 :',mat.ndim) # 축의 개수 출력 print('mat의 크기(shape) :',mat.shape) # 크기 출력 mat의 축의 개수 : 2 mat의 크기(shape) : (2, 3) 2) ndarray의 초기화 위에서는 리스트를 가지고 ndarray를 생성했지만 ndarray를 만드는 다양한 다른 방법이 존재합니다. 이 외에도 다양한 방법이 존재하므로 필요에 따라서 다양한 배열을 생성할 수 있습니다. np.zeros()는 배열의 모든 원소에 0을 삽입합니다. # 모든 값이 0인 2x3 배열 생성. zero_mat = np.zeros((2,3)) print(zero_mat) [[0. 0. 0.] [0. 0. 0.]] np.ones()는 배열의 모든 원소에 1을 삽입합니다. # 모든 값이 1인 2x3 배열 생성. one_mat = np.ones((2,3)) print(one_mat) [[1. 1. 1.] [1. 1. 1.]] np.full()은 배열에 사용자가 지정한 값을 삽입합니다. # 모든 값이 특정 상수인 배열 생성. 이 경우 7. same_value_mat = np.full((2,2), 7) print(same_value_mat) [[7 7] [7 7]] np.eye()는 대각선으로는 1이고 나머지는 0인 2차원 배열을 생성합니다. # 대각선 값이 1이고 나머지 값이 0인 2차원 배열을 생성. eye_mat = np.eye(3) print(eye_mat) [[1. 0. 0.] [0. 1. 0.]] [0. 0. 1.]] np.random.random()은 임의의 값을 가지는 배열을 생성합니다. # 임의의 값으로 채워진 배열 생성 random_mat = np.random.random((2,2)) # 임의의 값으로 채워진 배열 생성 print(random_mat) [[0.3111881 0.72996102] [0.65667734 0.40758328]] 이 외에도 Numpy에는 배열을 만드는 다양한 방법이 존재하므로 필요한 방법을 사용하여 배열을 생성할 수 있습니다. 3) np.arange() np.arange(n)은 0부터 n-1까지의 값을 가지는 배열을 생성합니다. # 0부터 9까지 range_vec = np.arange(10) print(range_vec) [0 1 2 3 4 5 6 7 8 9] np.arange(i, j, k)는 i부터 j-1까지 k씩 증가하는 배열을 생성합니다. # 1부터 9까지 +2씩 적용되는 범위 n = 2 range_n_step_vec = np.arange(1, 10, n) print(range_n_step_vec) [1 3 5 7 9] 4) np.reshape() np.reshape()은 내부 데이터는 변경하지 않으면서 배열의 구조를 바꿉니다. 0부터 29까지의 숫자를 생성하는 arange(30)을 수행한 후, 원소의 개수가 30개이므로 5행 6열의 행렬로 변경해 봅시다. reshape_mat = np.array(np.arange(30)).reshape((5,6)) print(reshape_mat) [[ 0 1 2 3 4 5] [ 6 7 8 9 10 11] [12 13 14 15 16 17] [18 19 20 21 22 23] [24 25 26 27 28 29]] 5) Numpy 슬라이싱 ndarray를 통해 만든 다차원 배열은 파이썬의 자료구조인 리스트처럼 슬라이싱(slicing) 기능을 지원합니다. 슬라이싱 기능을 사용하여 특정 행이나 열들의 원소들을 접근할 수 있습니다. mat = np.array([[1, 2, 3], [4, 5, 6]]) print(mat) [[1 2 3] [4 5 6]] # 첫 번째 행 출력 slicing_mat = mat[0, :] print(slicing_mat) [1 2 3] # 두 번째 열 출력 slicing_mat = mat[:, 1] print(slicing_mat) [2 5] 6) Numpy 정수 인덱싱(integer indexing) 슬라이싱을 사용하면 배열로부터 부분 배열을 추출할 수 있지만, 연속적이지 않은 원소로 배열을 만들 경우에는 슬라이싱으로는 만들 수 없습니다. 예를 들어서 2행 2열의 원소와 5행 5열의 원소를 뽑아서 하나의 배열로 만들고자 하는 경우가 그렇습니다. 이런 경우에는 인덱싱을 사용하여 배열을 구성할 수 있습니다. 인덱싱은 원하는 위치의 원소들을 뽑을 수 있습니다. mat = np.array([[1, 2], [4, 5], [7, 8]]) print(mat) [[1 2] [4 5] [7 8]] 특정 위치의 원소만을 가져와봅시다. # 1행 0열의 원소 # => 0부터 카운트하므로 두 번째 행 첫 번째 열의 원소. print(mat[1, 0]) 특정 위치의 원소 두 개를 가져와 새로운 배열을 만들어봅시다. # mat[[2행, 1행],[0열, 1열]] # 각 행과 열의 쌍을 매칭하면 2행 0열, 1행 1열의 두 개의 원소. indexing_mat = mat[[2, 1],[0, 1]] print(indexing_mat) [7 5] 7) Numpy 연산 Numpy를 사용하면 배열 간 연산을 손쉽게 수행할 수 있습니다. 덧셈, 뺄셈, 곱셈, 나눗셈을 위해서는 연산자 +, -, *, /를 사용할 수 있으며 또는 np.add(), np.subtract(), np.multiply(), np.divide()를 사용할 수도 있습니다. x = np.array([1,2,3]) y = np.array([4,5,6]) # result = np.add(x, y)와 동일. result = x + y print(result) [5 7 9] # result = np.subtract(x, y)와 동일. result = x - y print(result) [-3 -3 -3] # result = np.multiply(result, x)와 동일. result = result * x print(result) [-3 -6 -9] # result = np.divide(result, x)와 동일. result = result / x print(result) [-3. -3. -3.] 위에서 *를 통해 수행한 것은 요소별 곱입니다. Numpy에서 벡터와 행렬곱 또는 행렬 곱을 위해서는 dot()을 사용해야 합니다. mat1 = np.array([[1,2],[3,4]]) mat2 = np.array([[5,6],[7,8]]) mat3 = np.dot(mat1, mat2) print(mat3) [[19 22] [43 50]] 3. 맷플롯립(Matplotlib) 맷플롯립(Matplotlib)은 데이터를 차트(chart)나 플롯(plot)으로 시각화하는 패키지입니다. 데이터 분석에서 Matplotlib은 데이터 분석 이전에 데이터 이해를 위한 시각화나, 데이터 분석 후에 결과를 시각화하기 위해서 사용됩니다. 아나콘다를 설치하지 않았다면 아래의 커맨드로 Matplotlib를 별도 설치할 수 있습니다. pip install matplotlib > ipython ... In [1]: import matplotlib as mpl In [2]: mpl.__version__ Out[2]: '2.2.3' Matplotlib을 다 설치하였다면 Matplotlib의 주요 모듈인 pyplot를 관례상 plt라는 명칭으로 임포트 해봅시다. import matplotlib.pyplot as plt 1) 라인 플롯 그리기 plot()은 라인 플롯을 그리는 기능을 수행합니다. plot()에 x축과 y 축의 값을 기재하고 그림을 표시하는 show()를 통해서 시각화해봅시다. 그래프에는 title('제목')을 사용하여 제목을 지정할 수 있습니다. 여기서는 그래프에 'test'라는 제목을 넣어봅시다. 주피터 노트북에서는 show()를 사용하지 않더라도 그래프가 자동으로 렌더링 되므로 그래프가 시각화가 되지만 다른 개발 환경에서 사용할 때를 가정하여 show()를 코드에 삽입하였습니다. plt.title('test') plt.plot([1,2,3,4],[2,4,8,6]) plt.show() 2) 축 레이블 삽입하기 x축과 y 축 각각에 축이름을 삽입하고 싶다면 xlabel('넣고 싶은 축이름')과 ylabel('넣고 싶은 축이름')을 사용합니다. 위의 그래프에 hours와 score라는 축이름을 각각 추가해 봅시다. plt.title('test') plt.plot([1,2,3,4],[2,4,8,6]) plt.xlabel('hours') plt.ylabel('score') plt.show() 3) 라인 추가와 범례 삽입하기 다수의 plot()을 하나의 그래프에 나타낼 수 있습니다. 여러 개의 라인 플롯을 동시에 사용할 경우에는 각 선이 어떤 데이터를 나타내는지를 보여주기 위해 범례(legend)를 사용할 수 있습니다. plt.title('students') plt.plot([1,2,3,4],[2,4,8,6]) plt.plot([1.5,2.5,3.5,4.5],[3,5,8,10]) # 라인 새로 추가 plt.xlabel('hours') plt.ylabel('score') plt.legend(['A student', 'B student']) # 범례 삽입 plt.show() 좀 더 다양한 형태의 그래프를 그리는 실습은 딥 러닝 챕터의 인공 신경망 훑어보기 실습에서 확인할 수 있습니다. 01-04 머신 러닝 워크플로(Machine Learning Workflow) 이번 챕터에서는 데이터 사이언스(Data Science) 또는 머신 러닝(Machine Learning) 과정에서 거치는 전반적인 과정에 대해서 알아보겠습니다. 이 책의 제목은 딥 러닝(Deep Learning)을 이용한 자연어 처리이지만, 딥 러닝 또한 머신 러닝의 한 갈래로 딥 러닝 워크플로 또한 머신 러닝 워크플로우로 간주할 수 있습니다. 1. 머신 러닝 워크플로(Machine Learning Workflow) 데이터를 수집하고 머신 러닝을 하는 과정을 크게 6가지로 나누면, 아래의 그림과 같습니다. 1) 수집(Acquisition) 머신 러닝을 하기 위해서는 기계에 학습시켜야 할 데이터가 필요합니다. 자연어 처리의 경우, 자연어 데이터를 말뭉치 또는 코퍼스(corpus)라고 부르는데 코퍼스의 의미를 풀이하면, 조사나 연구 목적에 의해서 특정 도메인으로부터 수집된 텍스트 집합을 말합니다. 텍스트 데이터의 파일<NAME>은 txt 파일, csv 파일, xml 파일 등 다양하며 그 출처도 음성 데이터, 웹 수집기를 통해 수집된 데이터, 영화 리뷰 등 다양합니다. 2) 점검 및 탐색(Inspection and exploration) 데이터가 수집되었다면, 이제 데이터를 점검하고 탐색하는 단계입니다. 여기서는 데이터의 구조, 노이즈 데이터, 머신 러닝 적용을 위해서 데이터를 어떻게 정제해야 하는지 등을 파악해야 합니다. 이 단계를 탐색적 데이터 분석(Exploratory Data Analysis, EDA) 단계라고도 하는데 이는 독립 변수, 종속 변수, 변수 유형, 변수의 데이터 타입 등을 점검하며 데이터의 특징과 내재하는 구조적 관계를 알아내는 과정을 의미합니다. 이 과정에서 시각화와 간단한 통계 테스트를 진행하기도 합니다. 3) 전처리 및 정제(Preprocessing and Cleaning) 데이터에 대한 파악이 끝났다면, 머신 러닝 워크플로에서 가장 까다로운 작업 중 하나인 데이터 전처리 과정에 들어갑니다. 이 단계는 많은 단계를 포함하고 있는데, 가령 자연어 처리라면 토큰화, 정제, 정규화, 불용어 제거 등의 단계를 포함합니다. 빠르고 정확한 데이터 전처리를 하기 위해서는 사용하고 있는 툴(이 책에서는 파이썬)에 대한 다양한 라이브러리에 대한 지식이 필요합니다. 정말 까다로운 전처리의 경우에는 전처리 과정에서 머신 러닝이 사용되기도 합니다. 4) 모델링 및 훈련(Modeling and Training) 데이터 전처리가 끝났다면, 머신 러닝에 대한 코드를 작성하는 단계인 모델링 단계에 들어갑니다. 적절한 머신 러닝 알고리즘을 선택하여 모델링이 끝났다면, 전처리가 완료된 데이터를 머신 러닝 알고리즘을 통해 기계에게 학습(training) 시킵니다. 이를 훈련이라고도 하는데, 이 두 용어를 혼용해서 사용합니다. 기계가 데이터에 대한 학습을 마치고 나서 훈련이 제대로 되었다면 그 후에 기계는 우리가 원하는 태스크(task)인 기계 번역, 음성 인식, 텍스트 분류 등의 자연어 처리 작업을 수행할 수 있게 됩니다. 여기서 주의해야 할 점은 대부분의 경우에서 모든 데이터를 기계에게 학습시켜서는 안 된다는 점입니다. 뒤의 실습에서 보게 되겠지만 데이터 중 일부는 테스트용으로 남겨두고 훈련용 데이터만 훈련에 사용해야 합니다. 그래야만 기계가 학습을 하고 나서, 테스트용 데이터를 통해서 현재 성능이 얼마나 되는지를 측정할 수 있으며 과 적합(overfitting) 상황을 막을 수 있습니다. 사실 최선은 훈련용, 테스트용으로 두 가지만 나누는 것보다는 훈련용, 검증용, 테스트용. 데이터를 이렇게 세 가지로 나누고 훈련용 데이터만 훈련에 사용하는 것입니다. 검증용과 테스트용의 차이는 무엇일까요? 수능 시험에 비유하자면 훈련용은 학습지, 검증용은 모의고사, 테스트용은 수능 시험이라고 볼 수 있습니다. 학습지를 풀고 수능 시험을 볼 수도 있겠지만, 모의고사를 풀며 부족한 부분이 무엇인지 검증하고 보완하는 단계를 하나 더 놓는 방법도 있겠지요. 사실 현업의 경우라면 검증용 데이터는 거의 필수적입니다. 검증용 데이터는 현재 모델의 성능. 즉, 기계가 훈련용 데이터로 얼마나 제대로 학습이 되었는지를 판단하는 용으로 사용되며 검증용 데이터를 사용하여 모델의 성능을 개선하는 데 사용됩니다. 테스트용 데이터는 모델의 최종 성능을 평가하는 데이터로 모델의 성능을 개선하는 일에 사용되는 것이 아니라, 모델의 성능을 수치화하여 평가하기 위해 사용됩니다. 쉽게 말해 시험에 비유하면 채점하는 단계입니다. 이 책에서는 실습 상황에 따라서 훈련용, 검증용, 테스트용 세 가지를 모두 사용하거나 때로는 훈련용, 테스트용 두 가지만 사용하기도 합니다. 하지만 현업에서 최선은 검증용 데이터 또한 사용하는 것임을 기억해둡시다. 5) 평가(Evaluation) 미리 언급하였는데, 기계가 다 학습이 되었다면 테스트용 데이터로 성능을 평가하게 됩니다. 평가 방법은 기계가 예측한 데이터가 테스트용 데이터의 실제 정답과 얼마나 가까운지를 측정합니다. 6) 배포(Deployment) 평가 단계에서 기계가 성공적으로 훈련이 된 것으로 판단된다면 완성된 모델이 배포되는 단계가 됩니다. 다만, 여기서 완성된 모델에 대한 전체적인 피드백으로 인해 모델을 업데이트해야 하는 상황이 온다면 수집 단계로 돌아갈 수 있습니다. 01-05 데이터의 분리(Splitting Data) 머신 러닝 모델을 학습시키고 평가하기 위해서는 데이터를 적절하게 분리하는 작업이 필요합니다. 이 책에서는 대부분의 경우에서 지도 학습(Supervised Learning)을 다루는데, 이번에는 지도 학습을 위한 데이터 분리 작업에 대해서 배웁니다. import pandas as pd import numpy as np from sklearn.model_selection import train_test_split 1. 지도 학습(Supervised Learning) 지도 학습의 훈련 데이터는 문제지를 연상케 합니다. 지도 학습의 훈련 데이터는 정답이 무엇인지 맞춰 하는 '문제'에 해당되는 데이터와 레이블이라고 부르는 '정답'이 적혀있는 데이터로 구성되어 있습니다. 쉽게 비유하면, 기계는 정답이 적혀져 있는 문제지를 문제와 정답을 함께 보면서 열심히 공부하고, 향후에 정답이 없는 문제에 대해서도 정답을 잘 예측해야 합니다. 예를 들어 스팸 메일 분류기를 위한 데이터 같은 경우에는 메일의 본문과 해당 메일이 정상 메일인지, 스팸 메일인지 적혀있는 레이블로 구성돼 있습니다. 예를 들어 아래와 같은<NAME>의 데이터가 약 20,000개 있다고 가정해 보겠습니다. 이 데이터는 두 개의 열로 구성되는데, 바로 메일의 본문에 해당되는 첫 번째 열과 해당 메일이 정상 메일인지 스팸 메일인지가 적혀있는 정답에 해당되는 두 번째 열입니다. 그리고 이러한 데이터 배열이 총 20,000개의 행을 가집니다. 텍스트(메일의 내용) 레이블(스팸 여부) 당신에게 드리는 마지막 혜택! ... 스팸 메일 내일 뵐 수 있을지 확인 부탁... 정상 메일 ... ... (광고) 멋있어질 수 있는... 스팸 메일 기계를 지도하는 선생님의 입장이 되어보겠습니다. 기계를 훈련시키기 위해서 데이터를 총 4개로 나눕니다. 우선 메일의 내용이 담긴 첫 번째 열을 X에 저장합니다. 그리고 메일이 스팸인지 정상인지 정답이 적혀있는 두 번째 열을 y에 저장합니다. 이제 문제지에 해당되는 20,000개의 X와 정답지에 해당되는 20,000개의 y가 생겼습니다. 그리고 이제 이 X와 y에 대해서 일부 데이터를 또다시 분리합니다. 이는 문제지를 다 공부하고 나서 실력을 평가하기 위해서 시험(test) 용으로 일부로 일부 문제와 해당 문제의 정답지를 분리해놓는 것입니다. 여기서는 2,000개를 분리한다고 가정하겠습니다. 이때 분리 시에는 여전히 X와 y의 매핑 관계를 유지해야 합니다. 어떤 X(문제)에 대한 어떤 y(정답)인지 바로 찾을 수 있어야 합니다. 이렇게 되면 학습용에 해당되는 18,000개의 X, y의 쌍과 시험용에 해당되는 2000개의 X, y의 쌍이 생깁니다 이 책에서는 이 유형의 데이터들에게 일반적으로 다음과 같은 변수명을 부여합니다. <훈련 데이터> X_train : 문제지 데이터 y_train : 문제지에 대한 정답 데이터. <테스트 데이터> X_test : 시험지 데이터. y_test : 시험지에 대한 정답 데이터. 기계는 이제부터 X_train과 y_train에 대해서 학습을 합니다. 기계는 학습 상태에서는 정답지인 y_train을 볼 수 있기 때문에 18,000개의 문제지 X_train과 y_train을 함께 보면서 어떤 메일 내용일 때 정상 메일인지 스팸 메일인지를 열심히 규칙을 도출해나가면서 정리해나갑니다. 그리고 학습을 다 한 기계에게 y_test는 보여주지 않고, X_test에 대해서 정답을 예측하게 합니다. 그리고 기계가 예측한 답과 실제 정답인 y_test를 비교하면서 기계가 정답을 얼마나 맞췄는지를 평가합니다. 이 수치가 기계의 정확도(Accuracy)가 됩니다. 2. X와 y 분리하기 1) zip 함수를 이용하여 분리하기 zip() 함수는 동일한 개수를 가지는 시퀀스 자료형에서 각 순서에 등장하는 원소들끼리 묶어주는 역할을 합니다. 리스트의 리스트 구성에서 zip 함수는 X와 y를 분리하는데 유용합니다. 우선 zip 함수가 어떤 역할을 하는지 확인해 보도록 하겠습니다. X, y = zip(['a', 1], ['b', 2], ['c', 3]) print('X 데이터 :',X) print('y 데이터 :',y) X 데이터 : ('a', 'b', 'c') y 데이터 : (1, 2, 3) 각 데이터에서 첫 번째로 등장한 원소들끼리 묶이고, 두 번째로 등장한 원소들끼리 묶인 것을 볼 수 있습니다. # 리스트의 리스트 또는 행렬 또는 뒤에서 배울 개념인 2D 텐서. sequences = [['a', 1], ['b', 2], ['c', 3]] X, y = zip(*sequences) print('X 데이터 :',X) print('y 데이터 :',y) X 데이터 : ('a', 'b', 'c') y 데이터 : (1, 2, 3) 각 데이터에서 첫 번째로 등장한 원소들끼리 묶이고, 두 번째로 등장한 원소들끼리 묶인 것을 볼 수 있습니다. 이를 각각 X 데이터와 y 데이터로 사용할 수 있습니다. 2) 데이터 프레임을 이용하여 분리하기 values = [['당신에게 드리는 마지막 혜택!', 1], ['내일 뵐 수 있을지 확인 부탁드...', 0], ['도연 씨. 잘 지내시죠? 오랜 만입...', 0], ['(광고) AI로 주가를 예측할 수 있다!', 1]] columns = ['메일 본문', '스팸 메일 유무'] df = pd.DataFrame(values, columns=columns) df 데이터 프레임은 열의 이름으로 각 열에 접근이 가능하므로, 이를 이용하면 손쉽게 X 데이터와 y 데이터를 분리할 수 있습니다. X = df['메일 본문'] y = df['스팸 메일 유무'] X와 y 데이터를 출력해 보겠습니다. print('X 데이터 :',X.to_list()) print('y 데이터 :',y.to_list()) X 데이터 : ['당신에게 드리는 마지막 혜택!', '내일 뵐 수 있을지 확인 부탁드...', '도연 씨. 잘 지내시죠? 오랜 만입...', '(광고) AI로 주가를 예측할 수 있다!'] y 데이터 : [1, 0, 0, 1] 3) Numpy를 이용하여 분리하기 임의의 데이터를 만들어서 Numpy의 슬라이싱(slicing)을 사용하여 데이터를 분리해 봅시다. np_array = np.arange(0,16).reshape((4,4)) print('전체 데이터 :') print(np_array) 전체 데이터 : [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11] [12 13 14 15]] 마지막 열을 제외하고 X 데이터에 저장합니다. 마지막 열만을 y 데이터에 저장합니다. X = np_array[:, :3] y = np_array[:,3] print('X 데이터 :') print(X) print('y 데이터 :',y) X 데이터 : [[ 0 1 2] [ 4 5 6] [ 8 9 10] [12 13 14]] y 데이터 : [ 3 7 11 15] 3. 테스트 데이터 분리하기 이번에는 이미 X와 y가 분리된 데이터에 대해서 테스트 데이터를 분리하는 과정에 대해서 알아보겠습니다. 1) 사이킷 런을 이용하여 분리하기 사이킷런은 학습용 테스트와 테스트용 데이터를 쉽게 분리할 수 있게 해주는 train_test_split()를 지원합니다. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size= 0.2, random_state=1234) 각 인자는 다음을 의미합니다. train_size와 test_size는 둘 중 하나만 기재해도 됩니다. X : 독립 변수 데이터. (배열이나 데이터 프레임) y : 종속 변수 데이터. 레이블 데이터. test_size : 테스트용 데이터 개수를 지정한다. 1보다 작은 실수를 기재할 경우, 비율을 나타낸다. train_size : 학습용 데이터의 개수를 지정한다. 1보다 작은 실수를 기재할 경우, 비율을 나타낸다. random_state : 난수 시드 예를 들어보겠습니다. 임의로 X 데이터와 y 데이터를 생성했습니다. # 임의로 X와 y 데이터를 생성 X, y = np.arange(10).reshape((5, 2)), range(5) print('X 전체 데이터 :') print(X) print('y 전체 데이터 :') print(list(y)) X 전체 데이터 : [[0 1] [2 3] [4 5] [6 7] [8 9]] y 전체 데이터 : [0, 1, 2, 3, 4] 여기서는 7:3의 비율로 데이터를 분리합니다. train_test_split()은 기본적으로 데이터의 순서를 섞고 나서 훈련 데이터와 테스트 데이터를 분리합니다. 만약, random_state의 값을 특정 숫자로 기재해 준 뒤에 다음에도 동일한 숫자로 기재해 주면 항상 동일한 훈련 데이터와 테스트 데이터를 얻을 수 있습니다. 하지만 값을 변경하면 다른 순서로 섞인 채 분리되므로 이전과 다른 훈련 데이터와 테스트 데이터를 얻습니다. 실습을 통해서 이해해 봅시다. random_state 값을 임의로 1234로 지정했습니다. # 7:3의 비율로 훈련 데이터와 테스트 데이터 분리 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234) 70%의 비율로 분리된 X의 훈련 데이터와 30%의 비율로 분리된 X의 테스트 데이터입니다. print('X 훈련 데이터 :') print(X_train) print('X 테스트 데이터 :') print(X_test) X 훈련 데이터 : [[2 3] [4 5] [6 7]] X 테스트 데이터 : [[8 9] [0 1]] 70%의 비율로 분리된 y의 훈련 데이터와 30%의 비율로 분리된 y의 테스트 데이터입니다. print('y 훈련 데이터 :') print(y_train) print('y 테스트 데이터 :') print(y_test) y 훈련 데이터 : [1, 2, 3] y 테스트 데이터 : [4, 0] 출력 결과를 보면 데이터를 어느 중간 부분에서 앞과 뒤로 자른 것이 아니라 앞에 있던 샘플이 뒤로 가기도 하고, 데이터의 순서가 전반적으로 섞이면서 분리된 것을 확인할 수 있습니다. random_state의 의미를 이해하기 위해서 이번에는 random_state의 값을 임의로 다른 값인 1을 주고 다시 분리해 보겠습니다. 그리고 y 데이터를 출력해 봅시다. # random_state의 값을 변경 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1) print('y 훈련 데이터 :') print(y_train) print('y 테스트 데이터 :') print(y_test) y 훈련 데이터 : [4, 0, 3] y 테스트 데이터 : [2, 1] random_state 값이 1234일 때와 전혀 다른 y 데이터가 출력됩니다. 데이터가 다른 순서로 섞였다는 의미입니다. 이번에는 다시 random_state의 값을 1234로 주고 다시 y 데이터를 출력해 봅시다. # random_state을 이전의 값이었던 1234로 변경 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234) print('y 훈련 데이터 :') print(y_train) print('y 테스트 데이터 :') print(y_test) y 훈련 데이터 : [1, 2, 3] y 테스트 데이터 : [4, 0] 이전과 동일한 y 데이터가 출력됩니다. random_state의 값을 고정해두면 실행할 때마다 항상 동일한 순서로 데이터를 섞으므로, 동일한 코드를 다음에 재현하고자 할 때 사용할 수 있습니다. 2) 수동으로 분리하기 데이터를 분리하는 방법 중 하나는 수동으로 분리하는 것입니다. 우선 임의로 X 데이터와 y 데이터를 만들어보겠습니다. # 실습을 위해 임의로 X와 y가 이미 분리된 데이터를 생성 X, y = np.arange(0,24).reshape((12,2)), range(12) print('X 전체 데이터 :') print(X) print('y 전체 데이터 :') print(list(y)) X 전체 데이터 : [[ 0 1] [ 2 3] [ 4 5] [ 6 7] [ 8 9] [10 11] [12 13] [14 15] [16 17] [18 19] [20 21] [22 23]] y 전체 데이터 : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] 훈련 데이터의 개수와 테스트 데이터의 개수를 정해보겠습니다. num_of_train은 훈련 데이터의 개수를 의미하며, num_of_test는 테스트 데이터의 개수를 의미합니다. num_of_train = int(len(X) * 0.8) # 데이터의 전체 길이의 80%에 해당하는 길이값을 구한다. num_of_test = int(len(X) - num_of_train) # 전체 길이에서 80%에 해당하는 길이를 뺀다. print('훈련 데이터의 크기 :',num_of_train) print('테스트 데이터의 크기 :',num_of_test) 훈련 데이터의 크기 : 9 테스트 데이터의 크기 : 3 아직 훈련 데이터와 테스트 데이터를 나눈 것이 아니라 이 두 개의 개수를 몇 개로 할지 정하기만 한 상태입니다. 여기서 num_of_test를 len(X) * 0.2로 계산해서는 안 됩니다. 데이터에 누락이 발생할 수 있습니다. 예를 들어서 전체 데이터의 개수가 4,518이라고 가정했을 때 4,518의 80%의 값은 3,614.4로 소수점을 내리면 3,614가 됩니다. 또한 4,518의 20%의 값은 903.6으로 소수점을 내리면 903이 됩니다. 그리고 3,614 + 903 = 4517이므로 데이터 1개가 누락이 됩니다. 그러므로 어느 한 쪽을 먼저 계산하고 그 값만큼 제외하는 방식으로 계산해야 합니다. X_test = X[num_of_train:] # 전체 데이터 중에서 20%만큼 뒤의 데이터 저장 y_test = y[num_of_train:] # 전체 데이터 중에서 20%만큼 뒤의 데이터 저장 X_train = X[:num_of_train] # 전체 데이터 중에서 80%만큼 앞의 데이터 저장 y_train = y[:num_of_train] # 전체 데이터 중에서 80%만큼 앞의 데이터 저장 데이터를 나눌 때는 num_of_train와 같이 하나의 변수만 사용하면 데이터의 누락을 방지할 수 있습니다. 앞에서 구한 데이터의 개수만큼 훈련 데이터와 테스트 데이터를 분할합니다. 그리고 테스트 데이터를 출력하여 정상적으로 분리되었는지 확인합니다. print('X 테스트 데이터 :') print(X_test) print('y 테스트 데이터 :') print(list(y_test)) X 테스트 데이터 : [[18 19] [20 21] [22 23]] y 테스트 데이터 : [9, 10, 11] 각 길이가 3인 것을 확인했습니다. train_test_split()과 다른 점은 데이터가 섞이지 않은 채 어느 지점에서 데이터를 앞과 뒤로 분리했다는 점입니다. 만약, 수동으로 분리하게 된다면 데이터를 분리하기 전에 수동으로 데이터를 섞는 과정이 필요할 수 있습니다. 실제로 뒤에서 이러한 실습들을 진행합니다. 02. [기초 ✔] - 파이 토치 기초(PyTorch Basic) 2챕터에서는 파이 토치에 대한 기초를 정리합니다. 02-01 파이 토치 패키지의 기본 구성 아래의 내용은 파이 토치 패키지의 전반적인 구성을 보여줍니다. 1. torch 메인 네임스페이스입니다. 텐서 등의 다양한 수학 함수가 포함돼 있으며 Numpy와 유사한 구조를 가집니다. 2. torch.autograd 자동 미분을 위한 함수들이 포함돼 있습니다. 자동 미분의 on/off를 제어하는 콘텍스트 매니저(enable_grad/no_grad)나 자체 미분 가능 함수를 정의할 때 사용하는 기반 클래스인 'Function' 등이 포함돼 있습니다. 3. torch.nn 신경망을 구축하기 위한 다양한 데이터 구조나 레이어 등이 정의돼 있습니다. 예를 들어 RNN, LSTM과 같은 레이어, ReLU와 같은 활성화 함수, MSELoss와 같은 손실 함수들이 있습니다. 4. torch.optim 확률적 경사 하강법(Stochastic Gradient Descent, SGD)를 중심으로 한 파라미터 최적화 알고리즘이 구현돼 있습니다. 5. torch.utils.data SGD의 반복 연산을 실행할 때 사용하는 미니 배치용 유틸리티 함수가 포함돼 있습니다. 6. torch.onnx ONNX(Open Neural Network Exchange)의 포맷으로 모델을 익스포트(export)할 때 사용합니다. ONNX는 서로 다른 딥 러닝 프레임워크 간에 모델을 공유할 때 사용하는 포맷입니다. 02-02 텐서 조작하기(Tensor Manipulation) 1 이번 챕터에서 배울 내용에 대해서 리뷰해 보겠습니다. 벡터, 행렬, 텐서의 개념에 대해서 이해하고, Numpy와 파이 토치로 벡터, 행렬, 텐서를 다루는 방법에 대해서 이해합니다. 벡터, 행렬 그리고 텐서(Vector, Matrix and Tensor) 딥 러닝을 위한 가장 기본적인 수학적 지식인 벡터, 행렬, 텐서에 대해서 알아봅니다. 넘파이 훑어보기(Numpy Review) 파이 토치는 파이썬 패키지 넘파이(Numpy)와 유사합니다. 따라서 넘파이에 대해서 간단히 살펴보겠습니다. 파이 토치 텐서 선언하기(PyTorch Tensor Allocation) 넘파이로 실습을 해봤습니다. 이제 파이 토치 텐서 선언 방법에 대해서 알아봅니다. 행렬 곱셈(Maxtrix Multiplication) 행렬 연산에 대해서 이해합니다. 다른 오퍼레이션들(Other Basic Ops) 다른 기본적인 오퍼레이션들에 대해서 이해해 봅니다. 1. 벡터, 행렬 그리고 텐서(Vector, Matrix and Tensor) 1) 벡터, 행렬, 텐서 그림으로 이해하기 딥 러닝을 하게 되면 다루게 되는 가장 기본적인 단위는 벡터, 행렬, 텐서입니다. 차원이 없는 값을 스칼라(위의 그림에는 없음), 1차원으로 구성된 값을 우리는 벡터라고 합니다. 2차원으로 구성된 값을 행렬(Matrix)라고 합니다. 그리고 3차원이 되면 우리는 텐서(Tensor)라고 부릅니다. 사실 우리는 3차원의 세상에 살고 있으므로, 4차원 이상부터는 머리로 생각하기는 어렵습니다. 4차원은 3차원의 텐서를 위로 쌓아 올린 모습으로 상상해 보겠습니다. 5차원은 그 4차원을 다시 옆으로 확장한 모습으로 생각해 봅시다. 6차원은 5차원을 뒤로 확장한 모습으로 볼 수 있습니다. 데이터 사이언스 분야 한정으로 3차원 이상의 텐서는 그냥 다차원 행렬 또는 배열로 간주할 수 있습니다. 또한 주로 3차원 이상을 텐서라고 하긴 하지만, 1차원 벡터나 2차원인 행렬도 텐서라고 표현하기도 합니다. 같은 표현입니다. 벡터 = 1차원 텐서, 2차원 행렬 = 2차원 텐서. 그리고 3차원 텐서, 4차원 텐서, 5차원 텐서 등... 2) PyTorch Tensor Shape Convention 사실 딥 러닝을 할 때 다루고 있는 행렬 또는 텐서의 크기를 고려하는 것은 항상 중요합니다. 여기서는 앞으로 행렬과 텐서의 크기를 표현할 때 다음과 같은 방법으로 표기합니다. 앞으로 다루게 될 텐서 중 가장 전형적인 2차원 텐서를 예로 들어볼까요? * 2D Tensor(Typical Simple Setting) |t| = (Batch size, dim) 위의 경우는 2차원 텐서의 크기 |t|를 (batch size × dimension)으로 표현하였을 경우입니다. 조금 쉽게 말하면, 아래의 그림과 같이 행렬에서 행의 크기가 batch size, 열의 크기가 dim이라는 의미입니다. 훈련 데이터 하나의 크기를 256이라고 해봅시다. [3, 1, 2, 5, ...] 이런 숫자들의 나열이 256의 길이로 있다고 상상하면 됩니다. 다시 말해 훈련 데이터 하나 = 벡터의 차원은 256입니다. 만약 이런 훈련 데이터의 개수가 3000개라고 한다면, 현재 전체 훈련 데이터의 크기는 3,000 × 256입니다. 행렬이니까 2D 텐서네요. 3,000개를 1개씩 꺼내서 처리하는 것도 가능하지만 컴퓨터는 훈련 데이터를 하나씩 처리하는 것보다 보통 덩어리로 처리합니다. 3,000개에서 64개씩 꺼내서 처리한다고 한다면 이때 batch size를 64라고 합니다. 그렇다면 컴퓨터가 한 번에 처리하는 2D 텐서의 크기는 (batch size × dim) = 64 × 256입니다. * 3D Tensor(Typical Computer Vision) - 비전 분야에서의 3차원 텐서 |t| = (batch size, width, height) 일반적으로 자연어 처리보다 비전 분야(이미지, 영상 처리)를 하시게 된다면 좀 더 복잡한 텐서를 다루게 됩니다. 이미지라는 것은 가로, 세로라는 것이 존재합니다. 그리고 여러 장의 이미지, 그러니까 batch size로 구성하게 되면 아래와 같이 3차원의 텐서가 됩니다. 위의 그림은 세로는 batch size, 가로는 너비(width), 그리고 안쪽으로는 높이(height)가 되는 것을 보여줍니다. * 3D Tensor(Typical Natural Language Processing) - NLP 분야에서의 3차원 텐서 |t| = (batch size, length, dim) 자연어 처리는 보통 (batch size, 문장 길이, 단어 벡터의 차원)이라는 3차원 텐서를 사용합니다. * NLP 분야의 3D 텐서 예제로 이해하기 - 옮긴이 아래와 같이 4개의 문장으로 구성된 전체 훈련 데이터가 있습니다. [[나는 사과를 좋아해], [나는 바나나를 좋아해], [나는 사과를 싫어해], [나는 바나나를 싫어해]] 컴퓨터는 아직 이 상태로는 '나는 사과를 좋아해'가 단어가 1개인지 3개인지 이해하지 못합니다. 우선 컴퓨터의 입력으로 사용하기 위해서는 단어별로 나눠주어야 합니다. [['나는', '사과를', '좋아해'], ['나는', '바나나를', '좋아해'], ['나는', '사과를', '싫어해'], ['나는', '바나나를', '싫어해']] 이제 훈련 데이터의 크기는 4 × 3의 크기를 가지는 2D 텐서입니다. 컴퓨터는 텍스트보다는 숫자를 더 잘 처리할 수 있습 니데. 이제 각 단어를 벡터로 만들 겁니다. 아래와 같이 단어를 3차원의 벡터로 변환했다고 하겠습니다. '나는' = [0.1, 0.2, 0.9] '사과를' = [0.3, 0.5, 0.1] '바나나를' = [0.3, 0.5, 0.2] '좋아해' = [0.7, 0.6, 0.5] '싫어해' = [0.5, 0.6, 0.7] 위 기준을 따라서 훈련 데이터를 재구성하면 아래와 같습니다. [[[0.1, 0.2, 0.9], [0.3, 0.5, 0.1], [0.7, 0.6, 0.5]], [[0.1, 0.2, 0.9], [0.3, 0.5, 0.2], [0.7, 0.6, 0.5]], [[0.1, 0.2, 0.9], [0.3, 0.5, 0.1], [0.5, 0.6, 0.7]], [[0.1, 0.2, 0.9], [0.3, 0.5, 0.2], [0.5, 0.6, 0.7]]] 이제 훈련 데이터는 4 × 3 × 3의 크기를 가지는 3D 텐서입니다. 이제 batch size를 2로 해보겠습니다. 첫 번째 배치 #1 [[[0.1, 0.2, 0.9], [0.3, 0.5, 0.1], [0.7, 0.6, 0.5]], [[0.1, 0.2, 0.9], [0.3, 0.5, 0.2], [0.7, 0.6, 0.5]]] 두 번째 배치 #2 [[[0.1, 0.2, 0.9], [0.3, 0.5, 0.1], [0.5, 0.6, 0.7]], [[0.1, 0.2, 0.9], [0.3, 0.5, 0.2], [0.5, 0.6, 0.7]]] 컴퓨터는 배치 단위로 가져가서 연산을 수행합니다. 그리고 현재 각 배치의 텐서의 크기는 (2 × 3 × 3)입니다. 이는 (batch size, 문장 길이, 단어 벡터의 차원)의 크기입니다. 2. 넘파이로 텐서 만들기(벡터와 행렬 만들기) PyTorch로 텐서를 만들어보기 전에 우선 Numpy로 텐서를 만들어보겠습니다. 우선 numpy를 임포트 합니다. import numpy as np Numpy로 텐서를 만드는 방법은 간단한데 [숫자, 숫자, 숫자]와 같은<NAME>으로 만들고 이를 np.array()로 감싸주면 됩니다. 1) 1D with Numpy Numpy로 1차원 텐서인 벡터를 만들어보겠습니다. t = np.array([0., 1., 2., 3., 4., 5., 6.]) # 파이썬으로 설명하면 List를 생성해서 np.array로 1차원 array로 변환함. print(t) [0. 1. 2. 3. 4. 5. 6.] 이제 1차원 텐서인 벡터의 차원과 크기를 출력해 보겠습니다. print('Rank of t: ', t.ndim) print('Shape of t: ', t.shape) Rank of t: 1 Shape of t: (7, ) .ndim은 몇 차원인지를 출력합니다. 1차원은 벡터, 2차원은 행렬, 3차원은 3차원 텐서였습니다. 현재는 벡터이므로 1차원이 출력됩니다. .shape는 크기를 출력합니다. (7, )는 (1, 7)을 의미합니다. 다시 말해 (1 × 7)의 크기를 가지는 벡터입니다. 옮긴이 주 : 텐서의 크기(shape)를 표현할 때는 ,(콤마)를 쓰기도 하고 ×(곱하기)를 쓰기도 합니다. 예를 들어 2행 3열의 2D 텐서를 표현할 때 (2, 3)라고 하기도 하고 (2 × 3)이라고 하기도 합니다. (5, )의<NAME>은 (1 × 5)를 의미합니다. 1-1) Numpy 기초 이해하기 이제 Numpy에서 각 벡터의 원소에 접근하는 방법을 알아보겠습니다. Numpy에서 인덱스는 0부터 시작합니다. print('t[0] t[1] t[-1] = ', t[0], t[1], t[-1]) # 인덱스를 통한 원소 접근 t[0] t[1] t[-1] = 0.0 1.0 6.0 위의 결과는 0번 인덱스를 가진 원소인 0.0, 1번 인덱스를 가진 원소인 1.0, -1번 인덱스를 가진 원소인 6.0이 출력되는 것을 보여줍니다. -1번 인덱스는 맨 뒤에서부터 시작하는 인덱스입니다. 범위 지정으로 원소를 불러올 수도 있습니다. 이를 슬라이싱(Slicing)이라고 합니다. 사용 방법은 [시작 번호 : 끝 번호]를 통해 사용합니다. 주의할 점은 슬라이싱은 [시작 번호 : 끝 번호]라고 했을 때, 끝 번호에 해당하는 것은 포함하지 않습니다. print('t[2:5] t[4:-1] = ', t[2:5], t[4:-1]) # [시작 번호 : 끝 번호]로 범위 지정을 통해 가져온다. t[2:5] t[4:-1] = [2. 3. 4.] [4. 5.] 위의 슬라이싱의 결과를 보겠습니다. [2:5]라고 한다면 2번 인덱스부터 4번 인덱스까지의 결과를 가져온다는 의미입니다. [4:-1]은 4번 인덱스부터 끝에서 첫 번째 것까지의 결과를 가져온다는 의미입니다. 시작 번호 또는 끝 번호를 생략해서 슬라이싱을 하기도 합니다. [시작 번호:끝 번호]에서 시작 번호를 생략하면 처음부터 끝 번호까지 뽑아냅니다, 반면에 [시작 번호:끝 번호]에서 끝 번호를 생략하면 시작 번호부터 끝까지 뽑아냅니다. print('t[:2] t[3:] = ', t[:2], t[3:]) # 시작 번호를 생략한 경우와 끝 번호를 생략한 경우 t[:2] t[3:] = [0. 1.] [3. 4. 5. 6.] 2) 2D with Numpy Numpy로 2차원 행렬을 만들어보겠습니다. t = np.array([[1., 2., 3.], [4., 5., 6.], [7., 8., 9.], [10., 11., 12.]]) print(t) [[ 1. 2. 3.] [ 4. 5. 6.] [ 7. 8. 9.] [10. 11. 12.]] print('Rank of t: ', t.ndim) print('Shape of t: ', t.shape) Rank of t: 2 Shape of t: (4, 3) .ndim은 몇 차원인지를 출력합니다. 1차원은 벡터, 2차원은 행렬, 3차원은 3차원 텐서였습니다. 현재는 행렬이므로 2차원이 출력됩니다. .shape는 크기를 출력합니다. (4, 3)입니다. 다른 표현으로는 (4 × 3)입니다. 이는 행렬이 4행 3열임을 의미합니다. Numpy로도 3차원 텐서도 만들 수는 있지만 이 시점에서 Numpy와 PyTorch를 비교하기 위해 PyTorch로 실습을 넘어갑니다. 3. 파이 토치 텐서 선언하기(PyTorch Tensor Allocation) 파이 토치는 Numpy와 매우 유사합니다. 하지만 더 낫습니다(better). 우선 torch를 임포트 합니다. import torch Numpy를 사용하여 진행했던 실습을 파이 토치로 똑같이 해봅시다. 1) 1D with PyTorch 파이 토치로 1차원 텐서인 벡터를 만들어봅시다. t = torch.FloatTensor([0., 1., 2., 3., 4., 5., 6.]) print(t) dim()을 사용하면 현재 텐서의 차원을 보여줍니다. shape나 size()를 사용하면 크기를 확인할 수 있습니다. print(t.dim()) # rank. 즉, 차원 print(t.shape) # shape print(t.size()) # shape torch.Size([7]) torch.Size([7]) 현재 1차원 텐서이며, 원소는 7개입니다. 인덱스로 접근하는 것과 슬라이싱을 해봅시다. 방법은 Numpy 실습과 같습니다. print(t[0], t[1], t[-1]) # 인덱스로 접근 print(t[2:5], t[4:-1]) # 슬라이싱 print(t[:2], t[3:]) # 슬라이싱 tensor(0.) tensor(1.) tensor(6.) tensor([2., 3., 4.]) tensor([4., 5.]) tensor([0., 1.]) tensor([3., 4., 5., 6.]) 2) 2D with PyTorch 파이 토치로 2차원 텐서인 행렬을 만들어봅시다. t = torch.FloatTensor([[1., 2., 3.], [4., 5., 6.], [7., 8., 9.], [10., 11., 12.] ]) print(t) tensor([[ 1., 2., 3.], [ 4., 5., 6.], [ 7., 8., 9.], [10., 11., 12.]]) dim()을 사용하면 현재 텐서의 차원을 보여줍니다. size()를 사용하면 크기를 확인할 수 있습니다. print(t.dim()) # rank. 즉, 차원 print(t.size()) # shape torch.Size([4, 3]) 현재 텐서의 차원은 2차원이며, (4, 3)의 크기를 가집니다. 슬라이싱을 해봅시다. print(t[:, 1]) # 첫 번째 차원을 전체 선택한 상황에서 두 번째 차원의 첫 번째 것만 가져온다. print(t[:, 1].size()) # ↑ 위의 경우의 크기 tensor([ 2., 5., 8., 11.]) torch.Size([4]) 위의 결과는 첫 번째 차원을 전체 선택하고, 그 상황에서 두 번째 차원의 1번 인덱스 값만을 가져온 경우를 보여줍니다. 다시 말해 텐서에서 두 번째 열에 있는 모든 값을 가져온 상황입니다. 그리고 이렇게 값을 가져온 경우의 크기는 4입니다. (1차원 벡터) print(t[:, :-1]) # 첫 번째 차원을 전체 선택한 상황에서 두 번째 차원에서는 맨 마지막에서 첫 번째를 제외하고 다 가져온다. tensor([[ 1., 2.], [ 4., 5.], [ 7., 8.], [10., 11.]]) 위의 결과는 첫 번째 차원을 전체 선택한 상황에서 두 번째 차원에서는 맨 마지막에서 첫 번째를 제외하고 다 가져오는 경우입니다. 3) 브로드캐스팅(Broadcasting) 두 행렬 A, B가 있다고 해봅시다. 행렬의 덧셈과 뺄셈에 대해 알고 계신다면, 이 덧셈과 뺄셈을 할 때에는 두 행렬 A, B의 크기가 같아야 한다는 것을 알고 계실 겁니다. 그리고 두 행렬이 곱셈을 할 때에는 A의 마지막 차원과 B의 첫 번째 차원이 일치해야 합니다. 물론, 이런 규칙들이 있지만 딥 러닝을 하게 되면 불가피하게 크기가 다른 행렬 또는 텐서에 대해서 사칙 연산을 수행할 필요가 있는 경우가 생깁니다. 이를 위해 파이 토치에서는 자동으로 크기를 맞춰서 연산을 수행하게 만드는 브로드캐스팅이라는 기능을 제공합니다. 우선 같은 크기일 때 연산을 하는 경우를 보겠습니다. m1 = torch.FloatTensor([[3, 3]]) m2 = torch.FloatTensor([[2, 2]]) print(m1 + m2) tensor([[5., 5.]]) 여기서 m1, 과 m2의 크기는 둘 다 (1, 2)입니다. 그래서 문제없이 덧셈 연산이 가능합니다. 이번에는 크기가 다른 텐서들 간의 연산을 보겠습니다. 아래는 벡터와 스칼라가 덧셈 연산을 수행하는 것을 보여줍니다. 물론, 수학적으로는 원래 연산이 안 되는 게 맞지만 파이 토치에서는 브로드캐스팅을 통해 이를 연산합니다. # Vector + scalar m1 = torch.FloatTensor([[1, 2]]) m2 = torch.FloatTensor([3]) # [3] -> [3, 3] print(m1 + m2) tensor([[4., 5.]]) 원래 m1의 크기는 (1, 2)이며 m2의 크기는 (1, )입니다. 그런데 파이 토치는 m2의 크기를 (1, 2)로 변경하여 연산을 수행합니다. 이번에는 벡터 간 연산에서 브로드캐스팅이 적용되는 경우를 보겠습니다. # 2 x 1 Vector + 1 x 2 Vector m1 = torch.FloatTensor([[1, 2]]) m2 = torch.FloatTensor([[3], [4]]) print(m1 + m2) tensor([4., 5.], [5., 6.]]) m1의 크기는 (1, 2) m2의 크기는 (2, 1)였습니다. 이 두 벡터는 원래 수학적으로는 덧셈을 수행할 수 없습니다. 그러나 파이 토치는 두 벡터의 크기를 (2, 2)로 변경하여 덧셈을 수행합니다. # 브로드캐스팅 과정에서 실제로 두 텐서가 어떻게 변경되는지 보겠습니다. [1, 2] ==> [[1, 2], [1, 2]] [3] [4] ==> [[3, 3], [4, 4]] 브로드캐스팅은 편리하지만, 자동으로 실행되는 기능이므로 사용자 입장에서 굉장히 주의해서 사용해야 합니다. 예를 들어 A 텐서와 B 텐서가 있을 때, 사용자는 이 두 텐서의 크기가 같다고 착각하고 덧셈 연산을 수행했다고 가정해 보겠습니다. 하지만 실제로 이 두 텐서의 크기는 달랐고 브로드캐스팅이 수행되어 덧셈 연산이 수행되었습니다. 만약, 두 텐서의 크기가 다르다고 에러를 발생시킨다면 사용자는 이 연산이 잘못되었음을 바로 알 수 있지만 브로드캐스팅은 자동으로 수행되므로 사용자는 나중에 원하는 결과가 나오지 않았더라도 어디서 문제가 발생했는지 찾기가 굉장히 어려울 수 있습니다. 4) 자주 사용되는 기능들 1) 행렬 곱셈과 곱셈의 차이(Matrix Multiplication Vs. Multiplication) 행렬로 곱셈을 하는 방법은 크게 두 가지가 있습니다. 바로 행렬 곱셈(.matmul)과 원소 별 곱셈(.mul)입니다. 파이 토치 텐서의 행렬 곱셈을 보겠습니다. 이는 matmul()을 통해 수행합니다. m1 = torch.FloatTensor([[1, 2], [3, 4]]) m2 = torch.FloatTensor([[1], [2]]) print('Shape of Matrix 1: ', m1.shape) # 2 x 2 print('Shape of Matrix 2: ', m2.shape) # 2 x 1 print(m1.matmul(m2)) # 2 x 1 Shape of Matrix 1: torch.Size([2, 2]) Shape of Matrix 2: torch.Size([2, 1]) tensor([[ 5.], [11.]]) 위의 결과는 2 x 2 행렬과 2 x 1 행렬(벡터)의 행렬 곱셈의 결과를 보여줍니다. 행렬 곱셈이 아니라 element-wise 곱셈이라는 것이 존재합니다. 이는 동일한 크기의 행렬이 동일한 위치에 있는 원소끼리 곱하는 것을 말합니다. 아래는 서로 다른 크기의 행렬이 브로드캐스팅이 된 후에 element-wise 곱셈이 수행되는 것을 보여줍니다. 이는 * 또는 mul()을 통해 수행합니다. m1 = torch.FloatTensor([[1, 2], [3, 4]]) m2 = torch.FloatTensor([[1], [2]]) print('Shape of Matrix 1: ', m1.shape) # 2 x 2 print('Shape of Matrix 2: ', m2.shape) # 2 x 1 print(m1 * m2) # 2 x 2 print(m1.mul(m2)) Shape of Matrix 1: torch.Size([2, 2]) Shape of Matrix 2: torch.Size([2, 1]) tensor([[1., 2.], [6., 8.]]) tensor([[1., 2.], [6., 8.]]) m1 행렬의 크기는 (2, 2)이었습니다. m2 행렬의 크기는 (2, 1)였습니다. 이때 element-wise 곱셈을 수행하면, 두 행렬의 크기는 브로드캐스팅이 된 후에 곱셈이 수행됩니다. 더 정확히는 여기서 m2의 크기가 변환됩니다. # 브로드캐스팅 과정에서 m2 텐서가 어떻게 변경되는지 보겠습니다. [1] [2] ==> [[1, 1], [2, 2]] 2) 평균(Mean) 평균을 구하는 방법도 제공하고 있습니다. 이는 Numpy에서의 사용법과 매우 유사합니다. 우선 1차원인 벡터를 선언하여. mean()을 사용하여 원소의 평균을 구합니다. t = torch.FloatTensor([1, 2]) print(t.mean()) tensor(1.5000) 1과 2의 평균인 1.5가 나옵니다. 이번에는 2차원인 행렬을 선언하여. mean()을 사용해 봅시다. 우선 2차원 행렬을 선언합니다. t = torch.FloatTensor([[1, 2], [3, 4]]) print(t) tensor([[1., 2.], [3., 4.]]) 2차원 행렬이 선언되었습니다. 이제. mean()을 사용합니다. print(t.mean()) tensor(2.5000) 4개의 원소의 평균인 2.5가 나왔습니다. 이번에는 dim. 즉, 차원(dimension)을 인자로 주는 경우를 보겠습니다. print(t.mean(dim=0)) tensor([2., 3.]) dim=0이라는 것은 첫 번째 차원을 의미합니다. 행렬에서 첫 번째 차원은 '행'을 의미합니다. 그리고 인자로 dim을 준다면 해당 차원을 제거한다는 의미가 됩니다. 다시 말해 행렬에서 '열'만을 남기겠다는 의미가 됩니다. 기존 행렬의 크기는 (2, 2)였지만 이를 수행하면 열의 차원만 보존되면서 (1, 2)가 됩니다. 이는 (2, )와 같으며 벡터입니다. 열의 차원을 보존하면서 평균을 구하면 아래와 같이 연산합니다. # 실제 연산 과정 t.mean(dim=0)은 입력에서 첫 번째 차원을 제거한다. [[1., 2.], [3., 4.]] 1과 3의 평균을 구하고, 2와 4의 평균을 구한다. 결과 ==> [2., 3.] 이번에는 인자로 dim=1을 주겠습니다. 이번에는 두 번째 차원을 제거합니다. 즉, 열이 제거된 텐서가 되어야 합니다. print(t.mean(dim=1)) tensor([1.5000, 3.5000]) 열의 차원이 제거되어야 하므로 (2, 2)의 크기에서 (2, 1)의 크기가 됩니다. 이번에는 1과 2의 평균을 구하고 3과 4의 평균을 구하게 됩니다. 그렇다면 결과는 아래와 같습니다. # 실제 연산 결과는 (2 × 1) [1. 5] [3. 5] 하지만 (2 × 1)은 결국 1차원이므로 (1 × 2)와 같이 표현되면서 위와 같이 [1.5, 3.5]로 출력됩니다. 이번에는 dim=-1을 주는 경우를 보겠습니다. 이는 마지막 차원을 제거한다는 의미이고, 결국 열의 차원을 제거한다는 의미와 같습니다. 그러므로 위와 출력 결과가 같습니다. print(t.mean(dim=-1)) tensor([1.5000, 3.5000]) 3) 덧셈(Sum) 덧셈(Sum)은 평균(Mean)과 연산 방법이나 인자가 의미하는 바는 정확히 동일합니다. 다만, 평균이 아니라 덧셈을 할 뿐입니다. t = torch.FloatTensor([[1, 2], [3, 4]]) print(t) tensor([[1., 2.], [3., 4.]]) print(t.sum()) # 단순히 원소 전체의 덧셈을 수행 print(t.sum(dim=0)) # 행을 제거 print(t.sum(dim=1)) # 열을 제거 print(t.sum(dim=-1)) # 열을 제거 tensor(10.) tensor([4., 6.]) tensor([3., 7.]) tensor([3., 7.]) 4) 최대(Max)와 아 그 맥스(ArgMax) 최대(Max)는 원소의 최댓값을 리턴하고, 아 그 맥스(ArgMax)는 최댓값을 가진 인덱스를 리턴합니다. (2, 2) 크기의 행렬을 선언하고 Max를 사용해 봅시다. t = torch.FloatTensor([[1, 2], [3, 4]]) print(t) tensor([[1., 2.], [3., 4.]]) 우선 (2, 2) 행렬을 선언하였습니다. 이제. max()를 사용합니다. print(t.max()) # Returns one value: max tensor(4.) 원소 중 최댓값인 4를 리턴합니다. 이번에는 인자로 dim=0을 주겠습니다. 첫 번째 차원을 제거한다는 의미입니다. print(t.max(dim=0)) # Returns two values: max and argmax (tensor([3., 4.]), tensor([1, 1])) 행의 차원을 제거한다는 의미이므로 (1, 2) 텐서를 만듭니다. 결과는 [3, 4]입니다. 그런데 [1, 1]이라는 값도 함께 리턴되었습니다. max에 dim 인자를 주면 argmax도 함께 리턴하는 특징 때문입니다. 첫 번째 열에서 3의 인덱스는 1이었습니다. 두 번째 열에서 4의 인덱스는 1이었습니다. 그러므로 [1, 1]이 리턴됩니다. 어떤 의미인지는 아래 설명해 봤습니다. # [1, 1]가 무슨 의미인지 봅시다. 기존 행렬을 다시 상기해 봅시다. [[1, 2], [3, 4]] 첫 번째 열에서 0번 인덱스는 1, 1번 인덱스는 3입니다. 두 번째 열에서 0번 인덱스는 2, 1번 인덱스는 4입니다. 다시 말해 3과 4의 인덱스는 [1, 1]입니다. 만약 두 개를 함께 리턴 받는 것이 아니라 max 또는 argmax만 리턴 받고 싶다면 다음과 같이 리턴 값에도 인덱스를 부여하면 됩니다. 0번 인덱스를 사용하면 max 값만 받아올 수 있고, 1번 인덱스를 사용하면 argmax 값만 받아올 수 있습니다. print('Max: ', t.max(dim=0)[0]) print('Argmax: ', t.max(dim=0)[1]) Max: tensor([3., 4.]) Argmax: tensor([1, 1]) 이번에는 dim=1로 인자를 주었을 때와 dim=-1로 인자를 주었을 때를 보겠습니다. print(t.max(dim=1)) print(t.max(dim=-1)) (tensor([2., 4.]), tensor([1, 1])) (tensor([2., 4.]), tensor([1, 1])) 데이터 사이언스 분야 한정으로 3차원 이상의 텐서는 그냥 다차원 행렬 또는 배열로 간주할 수 있습니다. 또한 주로 3차원 이상을 텐서라고 하긴 하지만, 1차원 벡터나 2차원인 행렬도 텐서라고 표현하기도 합니다. 같은 표현입니다. 벡터 = 1차원 텐서, 2차원 행렬 = 2차원 텐서, 그리고 3차원 텐서, 4차원 텐서, 5차원 텐서 등... 훈련 데이터 하나의 크기를 256이라고 해봅시다. [3, 1, 2, 5, ...] 이런 숫자들의 나열이 256의 길이로 있다고 상상하면 됩니다. 다시 말해 훈련 데이터 하나 = 벡터의 차원은 256입니다. 만약 이런 훈련 데이터의 개수가 3000개라고 한다면, 현재 전체 훈련 데이터의 크기는 3,000 × 256입니다. 행렬이니까 2D 텐서네요. 3,000개를 1개씩 꺼내서 처리하는 것도 가능하지만 컴퓨터는 훈련 데이터를 하나씩 처리하는 것보다 보통 덩어리로 처리합니다. 3,000개에서 64개씩 꺼내서 처리한다고 한다면 이때 batch size를 64라고 합니다. 그렇다면 컴퓨터가 한 번에 처리하는 2D 텐서의 크기는 (batch size × dim) = 64 × 256입니다. 텐서의 크기(shape)를 표현할 때는 ,(콤마)를 쓰기도 하고 ×(곱하기)를 쓰기도 합니다. 예를 들어 2행 3열의 2D 텐서를 표현할 때 (2, 3)라고 하기도 하고 (2 × 3)이라고 하기도 합니다. (5, )의<NAME>은 (1 × 5)를 의미합니다. 훈련 데이터의 개수가 굉장히 많을 때, 컴퓨터가 한 번에 들고 가서 처리할 양을 배치 크기(batch size)라고 합니다. 슬라이싱에 대한 다른 예제 : https://wikidocs.net/13 Pytorch 텐서에 대한 다양한 예제 : https://datascienceschool.net/view-notebook/4f3606fd839f4320a4120a56eec1e228/ 02-03 텐서 조작하기(Tensor Manipulation) 2 이어서 텐서를 조작하는 방법을 알아보겠습니다. 4) 뷰(View) - 원소의 수를 유지하면서 텐서의 크기 변경. 매우 중요! 파이 토치 텐서의 뷰(View)는 넘파이에서의 리쉐이프(Reshape)와 같은 역할을 합니다. Reshape라는 이름에서 알 수 있듯이, 텐서의 크기(Shape)를 변경해 주는 역할을 합니다. 실습을 위해 우선 임의로 다음과 같이 3차원 텐서를 만듭니다. t = np.array([[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]]) ft = torch.FloatTensor(t) ft라는 이름의 3차원 텐서를 만들었습니다. 크기(shape)를 확인해 보겠습니다. print(ft.shape) torch.Size([2, 2, 3]) 현재 위 텐서의 크기는 (2, 2, 3)입니다. 이 ft라는 텐서의 크기를 기억해 주세요. 이 텐서를 가지고 두 번의 실습을 할 겁니다. 4-1) 3차원 텐서에서 2차원 텐서로 변경 이제 ft 텐서를 view를 사용하여 크기(shape)를 2차원 텐서로 변경해 봅시다. print(ft.view([-1, 3])) # ft라는 텐서를 (?, 3)의 크기로 변경 print(ft.view([-1, 3]).shape) tensor([[ 0., 1., 2.], [ 3., 4., 5.], [ 6., 7., 8.], [ 9., 10., 11.]]) torch.Size([4, 3]) view([-1, 3])이 가지는 의미는 이와 같습니다. -1은 첫 번째 차원은 사용자가 잘 모르겠으니 파이 토치에 맡기겠다는 의미이고, 3은 두 번째 차원의 길이는 3을 가지도록 하라는 의미입니다. 다시 말해 현재 3차원 텐서를 2차원 텐서로 변경하되 (?, 3)의 크기로 변경하라는 의미입니다. 결과적으로 (4, 3)의 크기를 가지는 텐서를 얻었습니다. 내부적으로 크기 변환은 다음과 같이 이루어졌습니다. (2, 2, 3) -> (2 × 2, 3) -> (4, 3) 규칙을 정리해 봅시다. view는 기본적으로 변경 전과 변경 후의 텐서 안의 원소의 개수가 유지되어야 합니다. 파이 토치의 view는 사이즈가 -1로 설정되면 다른 차원으로부터 해당 값을 유추합니다. 변경 전 텐서의 원소의 수는 (2 × 2 × 3) = 12개였습니다. 그리고 변경 후 텐서의 원소의 개수 또한 (4 × 3) = 12개였습니다. 4-2) 3차원 텐서의 크기 변경 이번에는 3차원 텐서에서 3차원 텐서로 차원은 유지하되, 크기(shape)를 바꾸는 작업을 해보겠습니다. view로 텐서의 크기를 변경하더라도 원소의 수는 유지되어야 한다고 언급한 바 있습니다. 그렇다면 (2 × 2 × 3) 텐서를 (? × 1 × 3) 텐서로 변경하라고 하면?는 몇 차원인가요? (2 × 2 × 3) = (? × 1 × 3) = 12를 만족해야 하므로?는 4가 됩니다. 이를 실습으로 확인해 봅시다. print(ft.view([-1, 1, 3])) print(ft.view([-1, 1, 3]).shape) tensor([[[ 0., 1., 2.]], [[ 3., 4., 5.]], [[ 6., 7., 8.]], [[ 9., 10., 11.]]]) torch.Size([4, 1, 3]) 5) 스퀴즈(Squeeze) - 1인 차원을 제거한다. 스퀴즈는 차원이 1인 경우에는 해당 차원을 제거합니다. 실습을 위해 임의로 (3 × 1)의 크기를 가지는 2차원 텐서를 만들겠습니다. ft = torch.FloatTensor([[0], [1], [2]]) print(ft) print(ft.shape) tensor([[0.], [1.], [2.]]) torch.Size([3, 1]) 해당 텐서는 (3 × 1)의 크기를 가집니다. 두 번째 차원이 1이므로 squeeze를 사용하면 (3, )의 크기를 가지는 텐서로 변경됩니다. print(ft.squeeze()) print(ft.squeeze().shape) tensor([0., 1., 2.]) torch.Size([3]) 위의 결과는 1이었던 두 번째 차원이 제거되면서 (3, )의 크기를 가지는 텐서로 변경되어 1차원 벡터가 된 것을 보여줍니다. 6) 언스 퀴즈(Unsqueeze) - 특정 위치에 1인 차원을 추가한다. 언스 퀴즈는 스퀴즈와 정반대입니다. 특정 위치에 1인 차원을 추가할 수 있습니다. 실습을 위해 임의로 (3, )의 크기를 가지는 1인 차원 텐서를 만들겠습니다. ft = torch.Tensor([0, 1, 2]) print(ft.shape) torch.Size([3]) 현재는 차원이 1개인 1차원 벡터입니다. 여기에 첫 번째 차원에 1인 차원을 추가해 보겠습니다. 첫 번째 차원의 인덱스를 의미하는 숫자 0을 인자로 넣으면 첫 번째 차원에 1인 차원이 추가됩니다. print(ft.unsqueeze(0)) # 인덱스가 0부터 시작하므로 0은 첫 번째 차원을 의미한다. print(ft.unsqueeze(0).shape) tensor([[0., 1., 2.]]) torch.Size([1, 3]) 위 결과는 (3, )의 크기를 가졌던 1차원 벡터가 (1, 3)의 2차원 텐서로 변경된 것을 보여줍니다. 방금 한 연산을 앞서 배운 view로도 구현 가능합니다. 2차원으로 바꾸고 싶으면서 첫 번째 차원은 1이기를 원한다면 view에서 (1, -1)을 인자로 사용하면 됩니다. print(ft.view(1, -1)) print(ft.view(1, -1).shape) tensor([[0., 1., 2.]]) torch.Size([1, 3]) 위의 결과는 unsqueeze와 view가 동일한 결과를 만든 것을 보여줍니다. 이번에는 unsqueeze의 인자로 1을 넣어보겠습니다. 인덱스는 0부터 시작하므로 이는 두 번째 차원에 1을 추가하겠다는 것을 의미합니다. 현재 크기는 (3, )이었으므로 두 번째 차원에 1인 차원을 추가하면 (3, 1)의 크기를 가지게 됩니다. 실습을 진행해 보겠습니다. print(ft.unsqueeze(1)) print(ft.unsqueeze(1).shape) tensor([[0.], [1.], [2.]]) torch.Size([3, 1]) 이번에는 unsqueeze의 인자로 -1을 넣어보겠습니다. -1은 인덱스 상으로 마지막 차원을 의미합니다. 현재 크기는 (3, )이었으므로 마지막 차원에 1인 차원을 추가하면 (3, 1)의 크기를 가지게 됩니다. 다시 말해 현재 텐서의 경우에는 1을 넣은 경우와 -1을 넣은 경우가 결과가 동일합니다. 실습을 진행해 보겠습니다. print(ft.unsqueeze(-1)) print(ft.unsqueeze(-1).shape) tensor([[0.], [1.], [2.]]) torch.Size([3, 1]) 맨 뒤에 1인 차원이 추가되면서 1차원 벡터가 (3, 1)의 크기를 가지는 2차원 텐서로 변경되었습니다. view(), squeeze(), unsqueeze()는 텐서의 원소 수를 그대로 유지하면서 모양과 차원을 조절합니다. 7) 타입 캐스팅(Type Casting) 텐서에는 자료형이라는 것이 있습니다. 각 데이터형 별로 정의돼 있는데, 예를 들어 32비트의 부동 소수점은 torch.FloatTensor를, 64비트의 부호 있는 정수는 torch.LongTensor를 사용합니다. GPU 연산을 위한 자료형도 있습니다. 예를 들어 torch.cuda.FloatTensor가 그 예입니다. 그리고 이 자료형을 변환하는 것을 타입 캐스팅이라고 합니다. 우선 실습을 위해 long 타입의 lt라는 텐서를 선언합니다. lt = torch.LongTensor([1, 2, 3, 4]) print(lt) 텐서에다가. float()를 붙이면 바로 float형으로 타입이 변경됩니다. print(lt.float()) tensor([1., 2., 3., 4.]) 이번에는 Byte 타입의 bt라는 텐서를 만들어보겠습니다. bt = torch.ByteTensor([True, False, False, True]) print(bt) tensor([1, 0, 0, 1], dtype=torch.uint8) 여기에. long()이라고 하면 long 타입의 텐서로 변경되고. float()이라고 하면 float 타입의 텐서로 변경됩니다. print(bt.long()) print(bt.float()) tensor([1, 0, 0, 1]) tensor([1., 0., 0., 1.]) 8) 연결하기(concatenate) 이번에는 두 텐서를 연결하는 방법에 대해서 알아보겠습니다. 우선 (2 × 2) 크기의 텐서를 두 개 만듭니다. x = torch.FloatTensor([[1, 2], [3, 4]]) y = torch.FloatTensor([[5, 6], [7, 8]]) 이제 두 텐서를 torch.cat([ ])를 통해 연결해 보겠습니다. 그런데 연결 방법은 한 가지만 있는 것이 아닙니다. torch.cat은 어느 차원을 늘릴 것인지를 인자로 줄 수 있습니다. 예를 들어 dim=0은 첫 번째 차원을 늘리라는 의미를 담고 있습니다. print(torch.cat([x, y], dim=0)) tensor([[1., 2.], [3., 4.], [5., 6.], [7., 8.]]) dim=0을 인자로 했더니 두 개의 (2 × 2) 텐서가 (4 × 2) 텐서가 된 것을 볼 수 있습니다. 이번에는 dim=1을 인자로 주겠습니다. print(torch.cat([x, y], dim=1)) tensor([[1., 2., 5., 6.], [3., 4., 7., 8.]]) dim=1을 인자로 했더니 두 개의 (2 × 2) 텐서가 (2 × 4) 텐서가 된 것을 볼 수 있습니다. 딥 러닝에서는 주로 모델의 입력 또는 중간 연산에서 두 개의 텐서를 연결하는 경우가 많습니다. 두 텐서를 연결해서 입력으로 사용하는 것은 두 가지의 정보를 모두 사용한다는 의미를 가지고 있습니다. 9) 스태킹(Stacking) 연결(concatenate)을 하는 또 다른 방법으로 스태킹(Stacking)이 있습니다. 스태킹은 영어로 쌓는다는 의미입니다. 때로는 연결을 하는 것보다 스태킹이 더 편리할 때가 있는데, 이는 스태킹이 많은 연산을 포함하고 있기 때문입니다. 실습을 위해 크기가 (2, )로 모두 동일한 3개의 벡터를 만듭니다. x = torch.FloatTensor([1, 4]) y = torch.FloatTensor([2, 5]) z = torch.FloatTensor([3, 6]) 이제 torch.stack을 통해서 3개의 벡터를 모두 스택킹해보겠습니다. print(torch.stack([x, y, z])) tensor([[1., 4.], [2., 5.], [3., 6.]]) 위 결과는 3개의 벡터가 순차적으로 쌓여 (3 × 2) 텐서가 된 것을 보여줍니다. 스태킹은 사실 많은 연산을 한 번에 축약하고 있습니다. 예를 들어 위 작업은 아래의 코드와 동일한 작업입니다. print(torch.cat([x.unsqueeze(0), y.unsqueeze(0), z.unsqueeze(0)], dim=0)) x, y, z는 기존에는 전부 (2, )의 크기를 가졌습니다. 그런데. unsqueeze(0)을 함으로써 3개의 벡터는 전부 (1, 2)의 크기의 2차원 텐서로 변경됩니다. 여기에 연결(concatenate)를 의미하는 cat을 사용하면 (3 x 2) 텐서가 됩니다. tensor([[1., 4.], [2., 5.], [3., 6.]]) 위에서는 torch.stack([x, y, z])라는 한 번의 커맨드로 수행했지만, 연결(concatenate)로 이를 구현하려고 했더니 꽤 복잡해졌습니다. 스태킹에 추가적으로 dim을 인자로 줄 수도 있습니다. 이번에는 dim=일인자를 주겠습니다. 이는 두 번째 차원이 증가하도록 쌓으라는 의미로 해석할 수 있습니다. print(torch.stack([x, y, z], dim=1)) tensor([[1., 2., 3.], [4., 5., 6.]]) 위의 결과는 두 번째 차원이 증가하도록 스태킹이 된 결과를 보여줍니다. 결과적으로 (2 × 3) 텐서가 됩니다. 10) ones_like와 zeros_like - 0으로 채워진 텐서와 1로 채워진 텐서 실습을 위해 (2 × 3) 텐서를 만듭니다. x = torch.FloatTensor([[0, 1, 2], [2, 1, 0]]) print(x) tensor([[0., 1., 2.], [2., 1., 0.]]) 위 텐서에 ones_like를 하면 동일한 크기(shape) 지만 1으로만 값이 채워진 텐서를 생성합니다. print(torch.ones_like(x)) # 입력 텐서와 크기를 동일하게 하면서 값을 1로 채우기 tensor([[1., 1., 1.], [1., 1., 1.]]) 위 텐서에 zeros_like를 하면 동일한 크기(shape) 지만 0으로만 값이 채워진 텐서를 생성합니다. print(torch.zeros_like(x)) # 입력 텐서와 크기를 동일하게 하면서 값을 0으로 채우기 tensor([[0., 0., 0.], [0., 0., 0.]]) 11) In-place Operation (덮어쓰기 연산) 실습을 위해 (2 × 2) 텐서를 만들고 x에 저장합니다. x = torch.FloatTensor([[1, 2], [3, 4]]) 곱하기 연산을 한 값과 기존의 값을 출력해 보겠습니다. print(x.mul(2.)) # 곱하기 2를 수행한 결과를 출력 print(x) # 기존의 값 출력 tensor([[2., 4.], [6., 8.]]) tensor([[1., 2.], [3., 4.]]) 첫 번째 출력은 곱하기 2가 수행된 결과를 보여주고, 두 번째 출력은 기존의 값이 그대로 출력된 것을 확인할 수 있습니다. 곱하기 2를 수행했지만 이를 x에다가 다시 저장하지 않았으니, 곱하기 연산을 하더라도 기존의 값 x는 변하지 않는 것이 당연합니다. 그런데 연산 뒤에 _를 붙이면 기존의 값을 덮어쓰기 합니다. print(x.mul_(2.)) # 곱하기 2를 수행한 결과를 변수 x에 값을 저장하면서 결과를 출력 print(x) # 기존의 값 출력 tensor([[2., 4.], [6., 8.]]) tensor([[2., 4.], [6., 8.]]) 이번에는 x의 값이 덮어쓰기 되어 2 곱하기 연산이 된 결과가 출력됩니다. 02-04 파이썬 클래스(class) 대부분의 파이 토치의 구현체들을 보면 기본적으로 클래스(Class)라는 개념을 애용하고 있습니다. 이번 챕터에서는 점프 투 파이썬의 클래스 챕터를 인용하였습니다. 링크 : https://wikidocs.net/28 1. 함수(function)과 클래스(Class)의 차이 우선 함수와 클래스의 차이를 이해하기 위해서 덧셈을 지속적으로 수행할 수 있는 도구를 함수와 클래스로 각각 만들어보겠습니다. 1. 함수(function)로 덧셈기 구현하기 우선 add 함수를 파이썬으로 구현해 보겠습니다. result라는 전역 변수를 선언합니다. result = 0 그리고 add라는 함수를 구현합니다. add라는 함수에서는 기존의 result에 함수의 인자로 온 숫자를 더하고 리턴합니다. def add(num): global result result += num return result 함수를 두 번 실행시키는데 처음에는 3을 넣고, 두 번째에는 4를 넣습니다. print(add(3)) print(add(4)) 7 처음에는 result가 0이었다가 3이 더해지면서 3이 출력되고, 추가로 4를 입력하면 result의 값이 이미 앞서 3으로 갱신되었기 때문에 3+4의 결과로 7이 리턴됩니다. 2. 함수(function)로 두 개의 덧셈기 구현하기 이번에는 독립적인 두 개의 덧셈기를 만들어보고 싶습니다. 비유하면, 책상에 두 개의 계산기를 두고 서로 다른 연산을 하고 싶습니다. 첫 번째 계산기로는 3+7을 하고 있고, 두 번째 계산기로는 3+10을 하고 싶은 것입니다. 이 두 계산기는 서로 다른 계산기이므로 독립적이어야 합니다. 이를 함수로 구현하려면, 하나의 함수는 1개의 덧셈기만을 의미하므로 이 경우에는 두 개의 함수를 독립적으로 만들어야 합니다. result1 = 0 result2 = 0 def add1(num): global result1 result1 += num return result1 def add2(num): global result2 result2 += num return result2 print(add1(3)) print(add1(4)) print(add2(3)) print(add2(7)) 7 10 서로의 값에 영향을 주지 않고 서로 다른 연산을 하고 있음을 볼 수 있습니다. 그렇다면 이런 두 개의 덧셈기를 클래스로 만들면 어떻게 될까요? 3. 클래스(class)로 덧셈기 구현하기 이번에는 클래스로 구현해 보겠습니다. class Calculator: def __init__(self): # 객체 생성 시 호출될 때 실행되는 초기화 함수. 이를 생성자라고 한다. self.result = 0 def add(self, num): # 객체 생성 후 사용할 수 있는 함수. self.result += num return self.result 클래스는 마치 붕어빵 틀과 같아서 클래스를 생성한 후에는 이걸로 객체라는 것을 만들 수 있습니다. cal1이라는 객체를 만들겠습니다. 이는 붕어빵 틀로 하나의 붕어빵을 만드는 것에 비유됩니다. cal1 = Calculator() 객체의 생성 방법은 객체의 이름을 정한 뒤에 '=클래스 이름()'으로 객체를 생성합니다. 클래스가 붕어빵 틀과 같다는 이유는 하나의 클래스를 만든 후에는 여러 개의 객체를 만드는 것이 가능하기 때문입니다. 또 하나의 객체 cal2도 생성해 보겠습니다. cal2 = Calculator() 두 개의 객체를 생성하였습니다. 이제 두 개의 객체에 대해서 동시에 독립적인 덧셈 연산을 해보겠습니다. print(cal1.add(3)) print(cal1.add(4)) print(cal2.add(3)) print(cal2.add(7)) 7 10 두 개의 객체는 독립적으로 연산되고 있음을 알 수 있습니다. 앞에서는 이렇게 독립적인 두 개의 덧셈기를 함수로 구현하려고 했다면 함수를 두 개 만들어야 했지만, 클래스라는 것을 하나 선언하고, 이 클래스를 통해 별도의 객체를 생성하자 코드가 훨씬 간결해졌습니다. 03. [ML 입문 ✏] - 머신 러닝 입문하기(Machine Learning Basics) 4챕터에서는 선형 회귀에 대해서 학습합니다. 03-01 선형 회귀(Linear Regression) 이번 챕터에서는 선형 회귀 이론에 대해서 이해하고, 파이 토치(PyTorch)를 이용하여 선형 회귀 모델을 만들어보겠습니다. 데이터에 대한 이해(Data Definition) 학습할 데이터에 대해서 알아봅니다. 가설(Hypothesis) 수립 가설을 수립하는 방법에 대해서 알아봅니다. 손실 계산하기(Compute loss) 학습 데이터를 이용해서 연속적으로 모델을 개선하는데 이때 손실(loss)를 이용합니다. 경사 하강법(Gradient Descent) 학습을 위한 핵심 알고리즘인 경사 하강법(Gradient Descent)에 대해서 이해합니다. 1. 데이터에 대한 이해(Data Definition) 이번 챕터에서 선형 회귀를 위해 사용할 예제는 공부한 시간과 점수에 대한 상관관계입니다. 1. 훈련 데이터 셋과 테스트 데이터 셋 어떤 학생이 1시간 공부를 했더니 2점, 다른 학생이 2시간 공부를 했더니 4점, 또 다른 학생이 3시간을 공부했더니 6점을 맞았습니다. 그렇다면, 내가 4시간을 공부한다면 몇 점을 맞을 수 있을까요? 이 질문에 대답하기 위해서 1시간, 2시간, 3시간을 공부했을 때 각각 2점, 4점, 6점이 나왔다는 앞서 나온 정보를 이용해야 합니다. 이때 예측을 위해 사용하는 데이터를 훈련 데이터 셋(training dataset)이라고 합니다. 학습이 끝난 후, 이 모델이 얼마나 잘 작동하는지 판별하는 데이터 셋을 테스트 데이터 셋(test dataset)이라고 합니다. 2. 훈련 데이터 셋의 구성 앞서 텐서에 대해서 배웠는데, 모델을 학습시키기 위한 데이터는 파이 토치의 텐서의 형태(torch.tensor)를 가지고 있어야 합니다. 그리고 입력과 출력을 각기 다른 텐서에 저장할 필요가 있습니다. 이때 보편적으로 입력은 x, 출력은 y를 사용하여 표기합니다. 여기서 x_train은 공부한 시간, y_train은 그에 매핑되는 점수를 의미합니다. x_train = torch.FloatTensor([[1], [2], [3]]) y_train = torch.FloatTensor([[2], [4], [6]]) 이제 모델의 가설을 세워보겠습니다. 2. 가설(Hypothesis) 수립 머신 러닝에서 식을 세울 때 이 식을 가설(Hypothesis)라고 합니다. 보통 머신 러닝에서 가설은 임의로 추측해서 세워보는 식일 수도 있고, 경험적으로 알고 있는 식일 수도 있습니다. 그리고 맞는 가설이 아니라고 판단되면 계속 수정해나가게 되는 식이기도 합니다. 선형 회귀의 가설은 이미 널리 알려져 있으므로 고민할 필요가 없습니다. 선형 회귀란 학습 데이터와 가장 잘 맞는 하나의 직선을 찾는 일입니다. 이때 선형 회귀의 가설(직선의 방정식)은 아래와 같은<NAME>을 가집니다. = x b 가설의 를 따서 대신 다음과 같이 식을 표현하기도 합니다. ( ) W + 이때 와 곱해지는 를 가중치(Weight)라고 하며,를 편향(bias)이라고 합니다. 와는 중학교 수학 과정인 직선의 방정식에서 기울기와 y 절편에 해당됩니다. 직선의 방정식 링크 : https://mathbang.net/443 3. 비용 함수(Cost function)에 대한 이해 앞으로 딥 러닝을 학습하면서 인터넷에서 이런 용어들을 본다면, 전부 같은 용어로 생각하면 되겠습니다. 비용 함수(cost function) = 손실 함수(loss function) = 오차 함수(error function) = 목적 함수(objective function) 특히 비용 함수와 손실 함수란 용어는 기억해두는 것이 좋습니다. 비용 함수에 대해서 이해하기 위해서 여기서만 잠깐 새로운 예제를 사용해 보겠습니다. 어떤 4개의 훈련 데이터가 있고, 이를 2차원 그래프에 4개의 점으로 표현한 상태라고 하겠습니다. 지금 목표는 4개의 점을 가장 잘 표현하는 직선을 그리는 일입니다. 임의로 3개의 직선을 그려보겠습니다. 위의 그림은 서로 다른 와의 값에 따라서 천차만별로 그려진 3개의 직선의 모습을 보여줍니다. 이 3개의 직선 중에서 4개의 점을 가장 잘 반영한 직선은 어떤 직선인가요? 검은색 직선이라고 말하는 사람도 있을 것이고, 잘 모르겠다고 말하는 사람도 있을 것입니다. 검은색 직선이라고 말하는 사람은 검은색 직선이 가장 4개의 점에 가깝게 지나가는 느낌을 받고 있기 때문입니다. 하지만 수학에서 느낌이라는 표현을 사용하는 것은 아무런 의미도 없습니다. 어떤 직선이 가장 적절한 직선인지를 수학적인 근거를 대서 표현할 수 있어야 합니다. 그래서 오차(error)라는 개념을 도입하겠습니다. 위 그림은 임의로 그려진 주황색 선에 대해서 각 실제 값(4개의 점)과 직선의 예측값(동일한 값에서의 직선의 값)에 대한 값의 차이를 빨간색 화살표 ↕로 표현한 것입니다. 각 실제 값과 각 예측값과의 차이고, 이를 각 실제 값에서의 오차라고 말할 수 있습니다. 이 직선의 예측값들과 실제 값들과의 총 오차(total error)는 어떻게 구할까요? 직관적으로 생각하기에 모든 오차를 다 더하면 될 것 같습니다. 각 오차를 전부 더해봅시다. 위 주황색 직선의 식은 = 13 +이며, 각 오차는 다음과 같습니다. hours( ) 2 3 4 5 실제 값 25 50 42 61 예측값 27 40 53 66 오차 -2 10 -9 -5 각 오차를 계산해 봤습니다. 그런데 수식적으로 단순히 '오차 = 실제 값 - 예측값'으로 정의하면 오차 값이 음수가 나오는 경우가 생깁니다. 예를 들어 위의 표에서만 봐도 오차가 음수인 경우가 3번이나 됩니다. 이 경우, 오차를 모두 더하면 덧셈 과정에서 오차 값이 +가 되었다가 -되었다가 하므로 제대로 된 오차의 크기를 측정할 수 없습니다. 그래서 오차를 그냥 전부 더하는 것이 아니라, 각 오차들을 제곱해 준 뒤에 전부 더하겠습니다. 이를 수식으로 표현하면 아래와 같습니다. 단, 여기서 은 갖고 있는 데이터의 개수를 의미합니다. i 1 [ ( ) H ( ( ) ) ] = ( 2 ) + 10 + ( 9 ) + ( 5 ) = 210 이때 데이터의 개수인으로 나누면, 오차의 제곱합에 대한 평균을 구할 수 있는데 이를 평균 제곱 오차(Mean Squared Error, MSE)라고 합니다. 수식은 아래와 같습니다. n i 1 [ ( ) H ( ( ) ) ] = 210 4 52.5 이를 실제로 계산하면 52.5가 됩니다. 이는 = 13 +의 예측값과 실제 값의 평균 제곱 오차의 값이 52.5임을 의미합니다. 평균 제곱 오차는 이번 회귀 문제에서 적절한 와를 찾기 위해서 최적화된 식입니다. 그 이유는 평균 제곱 오차의 값을 최솟값으로 만드는 와를 찾아내는 것이 가장 훈련 데이터를 잘 반영한 직선을 찾아내는 일이기 때문입니다. 평균 제곱 오차를 와에 의한 비용 함수(Cost function)로 재정의해 보면 다음과 같습니다. o t ( , ) 1 ∑ = n [ ( ) H ( ( ) ) ] 다시 정리하겠습니다. o t ( , ) 를 최소가 되게 만드는 와를 구하면 훈련 데이터를 가장 잘 나타내는 직선을 구할 수 있습니다. 4. 옵티마이저 - 경사 하강법(Gradient Descent) 이제 앞서 정의한 비용 함수(Cost Function)의 값을 최소로 하는 와를 찾는 방법에 대해서 배울 차례입니다. 이때 사용되는 것이 옵티마이저(Optimizer) 알고리즘입니다. 최적화 알고리즘이라고도 부릅니다. 그리고 이 옵티마이저 알고리즘을 통해 적절한 와를 찾아내는 과정을 머신 러닝에서 학습(training)이라고 부릅니다. 여기서는 가장 기본적인 옵티마이저 알고리즘인 경사 하강법(Gradient Descent)에 대해서 배웁니다. 이번 설명에서 편향 는 고려하지 않겠습니다. 즉, 가 0이라고 가정한 = x 와 같은 식을 기준으로 설명합니다. 가중치 가 직선의 방정식에서는 기울기였음을 기억합시다. 이제를 기울기라고 명명하고 설명합니다. 위의 그림에서 주황색선은 기울기 가 20일 때, 초록색선은 기울기 가 1일 때를 보여줍니다. 다시 말하면 각각 = 20 , =에 해당되는 직선입니다. ↕는 각 점에서의 실제 값과 두 직선의 예측값과의 오차를 보여줍니다. 이는 앞서 예측에 사용했던 = 13 + 직선보다 확연히 큰 오차 값들입니다. 즉, 기울기가 지나치게 크면 실제 값과 예측값의 오차가 커지고, 기울기가 지나치게 작아도 실제 값과 예측값의 오차가 커집니다. 사실 또한 마찬가지인데 가 지나치게 크거나 작으면 오차가 커집니다. 설명의 편의를 위해 편향 가 없이 단순히 가중치 만을 사용한 ( ) W라는 가설을 가지고, 경사 하강법을 설명하겠습니다. 비용 함수의 값 o t ( ) 는 cost라고 줄여서 표현해 보겠습니다. 이에 따라와 cost의 관계를 그래프로 표현하면 다음과 같습니다. 기울기 가 무한대로 커지면 커질수록 cost의 값 또한 무한대로 커지고, 반대로 기울기 가 무한대로 작아져도 cost의 값은 무한대로 커집니다. 위의 그래프에서 cost가 가장 작을 때는 맨 아래의 볼록한 부분입니다. 기계가 해야 할 일은 cost가 가장 최솟값을 가지게 하는 를 찾는 일이므로, 맨 아래의 볼록한 부분의의 값을 찾아야 합니다. 기계는 임의의 초깃값 값을 정한 뒤에, 맨 아래의 볼록한 부분을 향해 점차의 값을 수정해나갑니다. 위의 그림은 값이 점차 수정되는 과정을 보여줍니다. 그리고 이를 가능하게 하는 것이 경사 하강법(Gradient Descent)입니다. 이를 이해하기 위해서는 고등학교 수학 과정인 미분을 이해해야 합니다. 경사 하강법은 미분을 배우게 되면 가장 처음 배우게 되는 개념인 한 점에서의 순간 변화율 또는 접선에서의 기울기의 개념을 사용합니다. 위의 그림에서 초록색 선은 가 임의의 값을 가지게 되는 네 가지의 경우에 대해서, 그래프 상으로 접선의 기울기를 보여줍니다. 주목할 것은 맨 아래의 볼록한 부분으로 갈수록 접선의 기울기가 점차 작아진다는 점입니다. 그리고 맨 아래의 볼록한 부분에서는 결국 접선의 기울기가 0이 됩니다. 그래프 상으로는 초록색 화살표가 수평이 되는 지점입니다. 즉, cost가 최소화가 되는 지점은 접선의 기울기가 0이 되는 지점이며, 또한 미분 값이 0이 되는 지점입니다. 경사 하강법의 아이디어는 비용 함수(Cost function)를 미분하여 현재에서의 접선의 기울기를 구하고, 접선의 기울기가 낮은 방향으로의 값을 변경하는 작업을 반복하는 것에 있습니다. 이 반복 작업에는 현재에 접선의 기울기를 구해 특정 숫자 α를 곱한 값을 빼서 새로운 로 사용하는 식이 사용됩니다. 기울기 울 = c s ( ) W 기울기가 음수일 때와 양수일 때 어떻게 값이 조정되는지 보겠습니다. 기울기가 음수일 때 :의 값이 증가 음수 기울기 양수 기울기 := − × ( 수 울 ) W α ( 수 울 ) 기울기가 음수 면의 값이 증가하는데 이는 결과적으로 접선의 기울기가 0인 방향으로의 값이 조정됩니다. 만약, 접선의 기울기가 양수라면 위의 수식은 아래와 같이 표현할 수 있습니다. 기울기가 양수일 때 :의 값이 감소 양수 기울기 := − × ( 수 울 ) 기울기가 양수면의 값이 감소하게 되는데 이는 결과적으로 기울기가 0인 방향으로의 값이 조정됩니다. 즉, 아래의 수식은 접선의 기울기가 음수거나, 양수일 때 모두 접선의 기울기가 0인 방향으로의 값을 조정합니다. := − ∂ W o t ( ) 그렇다면 여기서 학습률(learning rate)이라고 말하는 는 어떤 의미를 가질까요? 학습률 은의 값을 변경할 때, 얼마나 크게 변경할지를 결정합니다. 또는 를 그래프의 한 점으로 보고 접선의 기울기가 0일 때까지 경사를 따라 내려간다는 관점에서는 얼마나 큰 폭으로 이동할지를 결정합니다. 직관적으로 생각하기에 학습률의 값을 무작정 크게 하면 접선의 기울기가 최소값이 되는 를 빠르게 찾을 수 있을 것 같지만 그렇지 않습니다. 위의 그림은 학습률 가 지나치게 높은 값을 가질 때, 접선의 기울기가 0이 되는 를 찾아가는 것이 아니라 o t 의 값이 발산하는 상황을 보여줍니다. 반대로 학습률 가 지나치게 낮은 값을 가지면 학습 속도가 느려지므로 적당한 의 값을 찾아내는 것도 중요합니다. 지금까지는 는 배제시키고 최적의 를 찾아내는 것에만 초점을 맞추어 경사 하강법의 원리에 대해서 배웠는데, 실제 경사 하강법은 와에 대해서 동시에 경사 하강법을 수행하면서 최적의 와의 값을 찾아갑니다. 가설, 비용 함수, 옵티마이저는 머신 러닝 분야에서 사용되는 포괄적 개념입니다. 풀고자 하는 각 문제에 따라 가설, 비용 함수, 옵티마이저는 전부 다를 수 있으며 선형 회귀에 가장 적합한 비용 함수는 평균 제곱 오차, 옵티마이저는 경사 하강법입니다. 이제 가설, 비용 함수, 옵티마이저에 대해서 학습하였으니 파이 토치로 구현해 보겠습니다. 4. 파이 토치로 선형 회귀 구현하기 우선 실습을 위해 파이 토치의 도구들을 임포트 하는 기본 세팅을 진행합니다. 1. 기본 세팅 import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim # 현재 실습하고 있는 파이썬 코드를 재실행해도 다음에도 같은 결과가 나오도록 랜덤 시드(random seed)를 줍니다. torch.manual_seed(1) 실습을 위한 기본적인 세팅이 끝났습니다. 이제 훈련 데이터인 x_train과 y_train을 선언합니다. 2. 변수 선언 x_train = torch.FloatTensor([[1], [2], [3]]) y_train = torch.FloatTensor([[2], [4], [6]]) x_train과 x_train의 크기(shape)를 출력해 보겠습니다. print(x_train) print(x_train.shape) tensor([[1.], [2.], [3.]]) torch.Size([3, 1]) x_train의 값이 출력되고, x_train의 크기가 (3 × 1) 임을 알 수 있습니다. y_train과 y_train의 크기(shape)를 출력해 보겠습니다. print(y_train) print(y_train.shape) tensor([[2.], [4.], [6.]]) torch.Size([3, 1]) y_train의 값이 출력되고, y_train의 크기가 (3 × 1) 임을 알 수 있습니다. 3. 가중치와 편향의 초기화 선형 회귀란 학습 데이터와 가장 잘 맞는 하나의 직선을 찾는 일입니다. 그리고 가장 잘 맞는 직선을 정의하는 것은 바로 와입니다. 선형 회귀의 목표는 가장 잘 맞는 직선을 정의하는 와의 값을 찾는 것입니다. 우선 가중치 W를 0으로 초기화하고, 이 값을 출력해 보겠습니다. # 가중치 W를 0으로 초기화하고 학습을 통해 값이 변경되는 변수임을 명시함. W = torch.zeros(1, requires_grad=True) # 가중치 W를 출력 print(W) tensor([0.], requires_grad=True) 가중치 W가 0으로 초기화되어있으므로 0이 출력된 것을 확인할 수 있습니다. 위에서 requires_grad=True가 인자로 주어진 것을 확인할 수 있습니다. 이는 이 변수는 학습을 통해 계속 값이 변경되는 변수임을 의미합니다. 마찬가지로 편향 도 0으로 초기화하고, 학습을 통해 값이 변경되는 변수임을 명시합니다. b = torch.zeros(1, requires_grad=True) print(b) tensor([0.], requires_grad=True) 현재 가중치 와 둘 다 0이므로 현 직선의 방정식은 다음과 같습니다. = × + 지금 상태에 선에 어떤 값이 들어가도 가설은 0을 예측하게 됩니다. 즉, 아직 적절한 와의 값이 아닙니다. 4. 가설 세우기 파이 토치 코드 상으로 직선의 방정식에 해당되는 가설을 선언합니다. ( ) W + hypothesis = x_train * W + b print(hypothesis) 5. 비용 함수 선언하기 파이 토치 코드 상으로 선형 회귀의 비용 함수에 해당되는 평균 제곱 오차를 선언합니다. o t ( , ) 1 ∑ = n [ ( ) H ( ( ) ) ] # 앞서 배운 torch.mean으로 평균을 구한다. cost = torch.mean((hypothesis - y_train) ** 2) print(cost) tensor(18.6667, grad_fn=<MeanBackward1>) 6. 경사 하강법 구현하기 이제 경사 하강법을 구현합니다. 아래의 'SGD'는 경사 하강법의 일종입니다. lr은 학습률(learning rate)를 의미합니다. 학습 대상인 W와 b가 SGD의 입력이 됩니다. optimizer = optim.SGD([W, b], lr=0.01) optimizer.zero_grad()를 실행함으로써 미분을 통해 얻은 기울기를 0으로 초기화합니다. 기울기를 초기화해야만 새로운 가중치 편향에 대해서 새로운 기울기를 구할 수 있습니다. 그다음 cost.backward() 함수를 호출하면 가중치 W와 편향 b에 대한 기울기가 계산됩니다. 그다음 경사 하강법 최적화 함수 opimizer의. step() 함수를 호출하여 인수로 들어갔던 W와 b에서 리턴되는 변수들의 기울기에 학습률(learining rate) 0.01을 곱하여 빼줌으로써 업데이트합니다. # gradient를 0으로 초기화 optimizer.zero_grad() # 비용 함수를 미분하여 gradient 계산 cost.backward() # W와 b를 업데이트 optimizer.step() requires_grad=True와 backward()에 대한 정리는 자동 미분(Autograd) 챕터에 별도 정리하였습니다. 7. 전체 코드 # 데이터 x_train = torch.FloatTensor([[1], [2], [3]]) y_train = torch.FloatTensor([[2], [4], [6]]) # 모델 초기화 W = torch.zeros(1, requires_grad=True) b = torch.zeros(1, requires_grad=True) # optimizer 설정 optimizer = optim.SGD([W, b], lr=0.01) nb_epochs = 1999 # 원하는 만큼 경사 하강법을 반복 for epoch in range(nb_epochs + 1): # H(x) 계산 hypothesis = x_train * W + b # cost 계산 cost = torch.mean((hypothesis - y_train) ** 2) # cost로 H(x) 개선 optimizer.zero_grad() cost.backward() optimizer.step() # 100번마다 로그 출력 if epoch % 100 == 0: print('Epoch {:4d}/{} W: {:.3f}, b: {:.3f} Cost: {:.6f}'.format( epoch, nb_epochs, W.item(), b.item(), cost.item() )) 결과적으로 훈련 과정에서 와는 훈련 데이터와 잘 맞는 직선을 표현하기 위한 적절한 값으로 변화해갑니다. Epoch 0/2000 W: 0.187, b: 0.080 Cost: 18.666666 Epoch 100/2000 W: 1.746, b: 0.578 Cost: 0.048171 Epoch 200/2000 W: 1.800, b: 0.454 Cost: 0.029767 Epoch 300/2000 W: 1.843, b: 0.357 Cost: 0.018394 Epoch 400/2000 W: 1.876, b: 0.281 Cost: 0.011366 Epoch 500/2000 W: 1.903, b: 0.221 Cost: 0.007024 Epoch 600/2000 W: 1.924, b: 0.174 Cost: 0.004340 Epoch 700/2000 W: 1.940, b: 0.136 Cost: 0.002682 Epoch 800/2000 W: 1.953, b: 0.107 Cost: 0.001657 Epoch 900/2000 W: 1.963, b: 0.084 Cost: 0.001024 Epoch 1000/2000 W: 1.971, b: 0.066 Cost: 0.000633 Epoch 1100/2000 W: 1.977, b: 0.052 Cost: 0.000391 Epoch 1200/2000 W: 1.982, b: 0.041 Cost: 0.000242 Epoch 1300/2000 W: 1.986, b: 0.032 Cost: 0.000149 Epoch 1400/2000 W: 1.989, b: 0.025 Cost: 0.000092 Epoch 1500/2000 W: 1.991, b: 0.020 Cost: 0.000057 Epoch 1600/2000 W: 1.993, b: 0.016 Cost: 0.000035 Epoch 1700/2000 W: 1.995, b: 0.012 Cost: 0.000022 Epoch 1800/2000 W: 1.996, b: 0.010 Cost: 0.000013 Epoch 1900/2000 W: 1.997, b: 0.008 Cost: 0.000008 Epoch 2000/2000 W: 1.997, b: 0.006 Cost: 0.000005 에포크(Epoch)는 전체 훈련 데이터가 학습에 한 번 사용된 주기를 말합니다. 이번 실습의 경우 2,000번을 수행했습니다. 최종 훈련 결과를 보면 최적의 기울기는 2에 가깝고,는 0에 가까운 것을 볼 수 있습니다. 현재 훈련 데이터가 x_train은 [[1], [2], [3]]이고 y_train은 [[2], [4], [6]]인 것을 감안하면 실제 정답은 가 2이고, 가 0인 ( ) 2이므로 거의 정답을 찾은 셈입니다. 5. optimizer.zero_grad()가 필요한 이유 파이 토치는 미분을 통해 얻은 기울기를 이전에 계산된 기울기 값에 누적시키는 특징이 있습니다. 예를 들어봅시다. import torch w = torch.tensor(2.0, requires_grad=True) nb_epochs = 20 for epoch in range(nb_epochs + 1): z = 2*w z.backward() print('수식을 w로 미분한 값 : {}'.format(w.grad)) 수식을 w로 미분한 값 : 2.0 수식을 w로 미분한 값 : 4.0 수식을 w로 미분한 값 : 6.0 수식을 w로 미분한 값 : 8.0 수식을 w로 미분한 값 : 10.0 수식을 w로 미분한 값 : 12.0 수식을 w로 미분한 값 : 14.0 수식을 w로 미분한 값 : 16.0 수식을 w로 미분한 값 : 18.0 수식을 w로 미분한 값 : 20.0 수식을 w로 미분한 값 : 22.0 수식을 w로 미분한 값 : 24.0 수식을 w로 미분한 값 : 26.0 수식을 w로 미분한 값 : 28.0 수식을 w로 미분한 값 : 30.0 수식을 w로 미분한 값 : 32.0 수식을 w로 미분한 값 : 34.0 수식을 w로 미분한 값 : 36.0 수식을 w로 미분한 값 : 38.0 수식을 w로 미분한 값 : 40.0 수식을 w로 미분한 값 : 42.0 계속해서 미분 값인 2가 누적되는 것을 볼 수 있습니다. 그렇기 때문에 optimizer.zero_grad()를 통해 미분 값을 계속 0으로 초기화시켜줘야 합니다. 6. torch.manual_seed()를 하는 이유 torch.manual_seed()를 사용한 프로그램의 결과는 다른 컴퓨터에서 실행시켜도 동일한 결과를 얻을 수 있습니다. 그 이유는 torch.manual_seed()는 난수 발생 순서와 값을 동일하게 보장해 준다는 특징 때문입니다. 우선 랜덤 시드가 3일 때 두 번 난수를 발생시켜보고, 다른 랜덤 시드를 사용한 후에 다시 랜덤 시드를 3을 사용한다면 난수 발생 값이 동일하게 나오는지 보겠습니다. import torch torch.manual_seed(3) print('랜덤 시드가 3일 때') for i in range(1,3): print(torch.rand(1)) 랜덤 시드가 3일 때 tensor([0.0043]) tensor([0.1056]) 랜덤 시드가 3일 때 두 개의 난수를 발생시켰더니 0.0043과 0.1056이 나옵니다. 이제 랜덤 시드 값을 바꿔봅시다. torch.manual_seed(5) print('랜덤 시드가 5일 때') for i in range(1,3): print(torch.rand(1)) 랜덤 시드가 5일 때 tensor([0.8303]) tensor([0.1261]) 0.8303과 0.1261이 나옵니다. 이제 다시 랜덤 시드 값을 3으로 돌려보겠습니다. 이렇게 하면 프로그램을 다시 처음부터 실행한 것처럼 난수 발생 순서가 초기화됩니다. torch.manual_seed(3) print('랜덤 시드가 다시 3일 때') for i in range(1,3): print(torch.rand(1)) 랜덤 시드가 다시 3일 때 tensor([0.0043]) tensor([0.1056]) 다시 동일하게 0.0043과 0.1056이 나옵니다. 텐서에는 requires_grad라는 속성이 있습니다. 이것을 True로 설정하면 자동 미분 기능이 적용됩니다. 선형 회귀부터 신경망과 같은 복잡한 구조에서 파라미터들이 모두 이 기능이 적용됩니다. requires_grad = True가 적용된 텐서에 연산을 하면, 계산 그래프가 생성되며 backward 함수를 호출하면 그래프로부터 자동으로 미분이 계산됩니다. 03-02 자동 미분(Autograd) 경사 하강법 코드를 보고 있으면 requires_grad=True, backward() 등이 나옵니다. 이는 파이 토치에서 제공하고 있는 자동 미분(Autograd) 기능을 수행하고 있는 것입니다. 파이 토치의 학습 과정을 보다 더 잘 이해하기 위해서 자동 미분에 대해서 이해해 봅시다. 1. 경사 하강법 리뷰 경사 하강법을 간단히 복습해 보겠습니다. 경사 하강법은 비용 함수를 미분하여 이 함수의 기울기(gradient)를 구해서 비용이 최소화되는 방향을 찾아내는 알고리즘이었습니다. 비용 함수를 손실 함수, 오차 함수라고도 부르므로 비용이 최소화되는 방향이라는 표현 대신 손실이 최소화되는 방향 또는 오차를 최소화되는 방향이라고도 설명할 수 있습니다. 모델이 복잡해질수록 경사 하강법을 넘파이 등으로 직접 코딩하는 것은 까다로운 일입니다. 파이 토치에서는 이런 수고를 하지 않도록 자동 미분(Autograd)을 지원합니다. 자동 미분을 사용하면 미분 계산을 자동화하여 경사 하강법을 손쉽게 사용할 수 있게 해줍니다. 2. 자동 미분(Autograd) 실습하기 자동 미분에 대해서 실습을 통해 이해해 봅시다. 임의로 w +라는 식을 세워보고,에 대해 미분해 보겠습니다. import torch 값이 2인 임의의 스칼라 텐서 w를 선언합니다. 이때 required_grad를 True로 설정합니다. 이는 이 텐서에 대한 기울기를 저장하겠다는 의미입니다. 뒤에서 보겠지만, 이렇게 하면 w.grad에 w에 대한 미분 값이 저장됩니다. w = torch.tensor(2.0, requires_grad=True) 이제 수식을 정의합니다. y = w**2 z = 2*y + 5 이제 해당 수식을 w에 대해서 미분해야 합니다. .backward()를 호출하면 해당 수식의 w에 대한 기울기를 계산합니다. z.backward() 이제 w.grad를 출력하면 w가 속한 수식을 w로 미분한 값이 저장된 것을 확인할 수 있습니다. print('수식을 w로 미분한 값 : {}'.format(w.grad)) 수식을 w로 미분한 값 : 8.0 참고 자료 : https://tutorials.pytorch.kr/beginner/blitz/autograd_tutorial.html? highlight=autograd 자동 미분에 대한 유튜브 영상 : https://www.youtube.com/watch? v=E0R9Xf_GyUc 03-03 다중 선형 회귀(Multivariable Linear regression) 앞서 배운 가 1개인 선형 회귀를 단순 선형 회귀(Simple Linear Regression)이라고 합니다. 이번 챕터에서는 다수의 로부터 를 예측하는 다중 선형 회귀(Multivariable Linear Regression)에 대해서 이해합니다. 1. 데이터에 대한 이해(Data Definition) 다음과 같은 훈련 데이터가 있습니다. 앞서 배운 단순 선형 회귀와 다른 점은 독립 변수의 개수가 이제 1개가 아닌 3개라는 점입니다. 3개의 퀴즈 점수로부터 최종 점수를 예측하는 모델을 만들어보겠습니다. 독립 변수의 개수가 3개므로 이를 수식으로 표현하면 아래와 같습니다. ( ) w x + 2 2 w x + 2. 파이 토치로 구현하기 우선 필요한 도구들을 임포트하고 랜덤 시드를 고정합니다. import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim torch.manual_seed(1) 이제 훈련 데이터를 선언해 보겠습니다. ( ) w x + 2 2 w x + 위의 식을 보면 이번에는 단순 선형 회귀와 다르게의 개수가 3개입니다. 그러니까를 3개 선언합니다. # 훈련 데이터 x1_train = torch.FloatTensor([[73], [93], [89], [96], [73]]) x2_train = torch.FloatTensor([[80], [88], [91], [98], [66]]) x3_train = torch.FloatTensor([[75], [93], [90], [100], [70]]) y_train = torch.FloatTensor([[152], [185], [180], [196], [142]]) 이제 가중치 와 편향 를 선언합니다. 가중치 도 3개 선언해 주어야 합니다. # 가중치 w와 편향 b 초기화 w1 = torch.zeros(1, requires_grad=True) w2 = torch.zeros(1, requires_grad=True) w3 = torch.zeros(1, requires_grad=True) b = torch.zeros(1, requires_grad=True) 이제 가설, 비용 함수, 옵티마이저를 선언한 후에 경사 하강법을 1,000회 반복합니다. # optimizer 설정 optimizer = optim.SGD([w1, w2, w3, b], lr=1e-5) nb_epochs = 1000 for epoch in range(nb_epochs + 1): # H(x) 계산 hypothesis = x1_train * w1 + x2_train * w2 + x3_train * w3 + b # cost 계산 cost = torch.mean((hypothesis - y_train) ** 2) # cost로 H(x) 개선 optimizer.zero_grad() cost.backward() optimizer.step() # 100번마다 로그 출력 if epoch % 100 == 0: print('Epoch {:4d}/{} w1: {:.3f} w2: {:.3f} w3: {:.3f} b: {:.3f} Cost: {:.6f}'.format( epoch, nb_epochs, w1.item(), w2.item(), w3.item(), b.item(), cost.item() )) 위의 경우 가설을 선언하는 부분인 hypothesis = x1_train * w1 + x2_train * w2 + x3_train * w3 + b에서도 x_train의 개수만큼 w와 곱해주도록 작성해 준 것을 확인할 수 있습니다. 3. 벡터와 행렬 연산으로 바꾸기 위의 코드를 개선할 수 있는 부분이 있습니다. 이번에는 의 개수가 3개였으니까 x1_train, x2_train, x3_train와 w1, w2, w3를 일일이 선언해 주었습니다. 그런데의 개수가 1,000개라고 가정해 봅시다. 위와 같은 방식을 고수할 경우 x_train1 ~ x_train1000을 전부 선언하고, w1 ~ w1000을 전부 선언해야 합니다. 다시 말해 와 변수 선언만 총합 2,000개를 해야 합니다. 또한 가설을 선언하는 부분에서도 마찬가지로 x_train과 w의 곱셈이 이루어지는 항을 1,000개를 작성해야 합니다. 이는 굉장히 비효율적입니다. 이를 해결하기 위해 행렬 곱셈 연산(또는 벡터의 내적)을 사용합니다. 행렬의 곱셈 과정에서 이루어지는 벡터 연산을 벡터의 내적(Dot Product)이라고 합니다. 위의 그림은 행렬 곱셈 연산 과정에서 벡터의 내적으로 1 × 7 + 2 × 9 + 3 × 11 = 58이 되는 과정을 보여줍니다. 이 행렬 연산이 어떻게 현재 배우고 있는 가설과 상관이 있다는 걸까요? 바로 가설을 벡터와 행렬 연산으로 표현할 수 있기 때문입니다. 1. 벡터 연산으로 이해하기 ( ) w x + 2 2 w x 위 식은 아래와 같이 두 벡터의 내적으로 표현할 수 있습니다. 두 벡터를 각각 와로 표현한다면, 가설은 다음과 같습니다. ( ) X x 의 개수가 3개였음에도 이제는 와라는 두 개의 변수로 표현된 것을 볼 수 있습니다. 2. 행렬 연산으로 이해하기 훈련 데이터를 살펴보고, 벡터와 행렬 연산을 통해 가설 ( ) 를 표현해 보겠습니다. 전체 훈련 데이터의 개수를 셀 수 있는 1개의 단위를 샘플(sample)이라고 합니다. 현재 샘플의 수는 총 5개입니다. 각 샘플에서 를 결정하게 하는 각각의 독립 변수를 특성(feature)이라고 합니다. 현재 특성은 3개입니다. 이는 독립 변수 들의 수가 (샘플의 수 × 특성의 수) = 15개임을 의미합니다. 독립 변수 들을 (샘플의 수 × 특성의 수)의 크기를 가지는 하나의 행렬로 표현해 봅시다. 그리고 이 행렬을라고 하겠습니다. ( 11 x 12 x 13 x 21 x 22 x 23 x 31 x 32 x 33 x 41 x 42 x 43 x 51 x 52 x 53 ) 그리고 여기에 가중치 1 w, 3 을 원소로 하는 벡터를 라 하고 이를 곱해보겠습니다. ( 11 x 12 x 13 x 21 x 22 x 23 x 31 x 32 x 33 x 41 x 42 x 43 x 51 x 52 x 53 ) ( 1 2 3 ) = ( 11 1 x 12 2 x 13 3 x 21 1 x 22 2 x 23 3 x 31 1 x 32 2 x 33 3 x 41 1 x 42 2 x 43 3 x 51 1 x 52 2 x 53 3 ) 위의 식은 결과적으로 다음과 같습니다. ( ) X 이 가설에 각 샘플에 더해지는 편향 를 추가해 봅시다. 샘플 수만큼의 차원을 가지는 편향 벡터를 만들어 더합니다. ( 11 x 12 x 13 x 21 x 22 x 23 x 31 x 32 x 33 x 41 x 42 x 43 x 51 x 52 x 53 ) ( 1 2 3 ) ( b b) = ( 11 1 x 12 2 x 13 3 b 21 1 x 22 2 x 23 3 b 31 1 x 32 2 x 33 3 b 41 1 x 42 2 x 43 3 b 51 1 x 52 2 x 53 3 b 위의 식은 결과적으로 다음과 같습니다. ( ) X + 결과적으로 전체 훈련 데이터의 가설 연산을 3개의 변수만으로 표현하였습니다. 이와 같이 벡터와 행렬 연산은 식을 간단하게 해줄 뿐만 아니라 다수의 샘플의 병렬 연산이므로 속도의 이점을 가집니다. 이를 참고로 파이 토치로 구현해 봅시다. 4. 행렬 연산을 고려하여 파이 토치로 구현하기 이번에는 행렬 연산을 고려하여 파이 토치로 재구현해보겠습니다. 이번에는 훈련 데이터 또한 행렬로 선언해야 합니다. x_train = torch.FloatTensor([[73, 80, 75], [93, 88, 93], [89, 91, 80], [96, 98, 100], [73, 66, 70]]) y_train = torch.FloatTensor([[152], [185], [180], [196], [142]]) 이전에 x_train을 3개나 구현했던 것과 다르게 이번에는 x_train 하나에 모든 샘플을 전부 선언하였습니다. 다시 말해 (5 x 3) 행렬을 선언한 것입니다. x_train과 y_train의 크기(shape)를 출력해 보겠습니다. print(x_train.shape) print(y_train.shape) torch.Size([5, 3]) torch.Size([5, 1]) 각각 (5 × 3) 행렬과 (5 × 1) 행렬(또는 벡터)의 크기를 가집니다. 이제 가중치 와 편향 를 선언합니다. # 가중치와 편향 선언 W = torch.zeros((3, 1), requires_grad=True) b = torch.zeros(1, requires_grad=True) 여기서 주목할 점은 가중치의 크기가 (3 × 1) 벡터라는 점입니다. 행렬의 곱셈이 성립되려면 곱셈의 좌측에 있는 행렬의 열의 크기와 우측에 있는 행렬의 행의 크기가 일치해야 합니다. 현재 X_train의 행렬의 크기는 (5 × 3)이며, 벡터의 크기는 (3 × 1)이므로 두 행렬과 벡터는 행렬곱이 가능합니다. 행렬곱으로 가설을 선언하면 아래와 같습니다. hypothesis = x_train.matmul(W) + b 가설을 행렬곱으로 간단히 정의하였습니다. 이는 앞서 x_train과 w의 곱셈이 이루어지는 각 항을 전부 기재하여 가설을 선언했던 것과 대비됩니다. 이 경우, 사용자가 독립 변수의 수를 후에 추가적으로 늘리거나 줄이더라도 위의 가설 선언 코드를 수정할 필요가 없습니다. 이제 해야 할 일은 비용 함수와 옵티마이저를 정의하고, 정해진 에포크만큼 훈련을 진행하는 일입니다. 이를 반영한 전체 코드는 다음과 같습니다. x_train = torch.FloatTensor([[73, 80, 75], [93, 88, 93], [89, 91, 80], [96, 98, 100], [73, 66, 70]]) y_train = torch.FloatTensor([[152], [185], [180], [196], [142]]) # 모델 초기화 W = torch.zeros((3, 1), requires_grad=True) b = torch.zeros(1, requires_grad=True) # optimizer 설정 optimizer = optim.SGD([W, b], lr=1e-5) nb_epochs = 20 for epoch in range(nb_epochs + 1): # H(x) 계산 # 편향 b는 브로드 캐스팅 되어 각 샘플에 더해집니다. hypothesis = x_train.matmul(W) + b # cost 계산 cost = torch.mean((hypothesis - y_train) ** 2) # cost로 H(x) 개선 optimizer.zero_grad() cost.backward() optimizer.step() print('Epoch {:4d}/{} hypothesis: {} Cost: {:.6f}'.format( epoch, nb_epochs, hypothesis.squeeze().detach(), cost.item() )) 03-04 nn.Module로 구현하는 선형 회귀 이전 챕터까지는 선형 회귀를 좀 더 직접적으로 이해하기 위해 가설, 비용 함수를 직접 정의해서 선형 회귀 모델을 구현했습니다. 이번에는 파이 토치에서 이미 구현돼 제공되고 있는 함수들을 불러오는 것으로 더 쉽게 선형 회귀 모델을 구현해 보겠습니다. 예를 들어 파이 토치에서는 선형 회귀 모델이 nn.Linear()라는 함수로, 또 평균 제곱오차가 nn.functional.mse_loss()라는 함수로 구현돼 있습니다. 아래는 이번 실습에서 사용할 두 함수의 사용 예제를 간단히 보여줍니다. import torch.nn as nn model = nn.Linear(input_dim, output_dim) import torch.nn.functional as F cost = F.mse_loss(prediction, y_train) 1. 단순 선형 회귀 구현하기 우선 필요한 도구들을 임포트 합니다. import torch import torch.nn as nn import torch.nn.functional as F torch.manual_seed(1) 이제 데이터를 선언합니다. 아래 데이터는 = x 를 가정된 상태에서 만들어진 데이터로 우리는 이미 정답이 W=2, b=0임을 알고 있는 사태입니다. 모델이 이 두 W와 b의 값을 제대로 찾아내도록 하는 것이 목표입니다. # 데이터 x_train = torch.FloatTensor([[1], [2], [3]]) y_train = torch.FloatTensor([[2], [4], [6]]) 데이터를 정의하였으니 이제 선형 회귀 모델을 구현할 차례입니다. nn.Linear()는 입력의 차원, 출력의 차원을 인수로 받습니다. # 모델을 선언 및 초기화. 단순 선형 회귀이므로 input_dim=1, output_dim=1. model = nn.Linear(1,1) 위 torch.nn.Linear 인자로 1, 1을 사용하였습니다. 하나의 입력에 대해서 하나의 출력을 가지므로, 입력 차원과 출력 차원 모두 1을 인수로 사용하였습니다. model에는 가중치 W와 편향 b가 저장돼 있습니다. 이 값은 model.parameters()라는 함수를 사용하여 불러올 수 있는데, 한 번 출력해 보겠습니다. print(list(model.parameters())) [Parameter containing: tensor([[0.5153]], requires_grad=True), Parameter containing: tensor([-0.4414], requires_grad=True)] 2개의 값이 출력되는데 첫 번째 값이 W고, 두 번째 값이 b에 해당됩니다. 두 값 모두 현재는 랜덤 초기화가 되어 있습니다. 그리고 두 값 모두 학습의 대상이므로 requires_grad=True가 되어 있는 것을 볼 수 있습니다. 이제 옵티마이저를 정의합니다. model.parameters()를 사용하여 W와 b를 전달합니다. 학습률(learning rate)은 0.01로 정합니다. # optimizer 설정. 경사 하강법 SGD를 사용하고 learning rate를 의미하는 lr은 0.01 optimizer = torch.optim.SGD(model.parameters(), lr=0.01) # 전체 훈련 데이터에 대해 경사 하강법을 2,000회 반복 nb_epochs = 2000 for epoch in range(nb_epochs+1): # H(x) 계산 prediction = model(x_train) # cost 계산 cost = F.mse_loss(prediction, y_train) # <== 파이 토치에서 제공하는 평균 제곱 오차 함수 # cost로 H(x) 개선하는 부분 # gradient를 0으로 초기화 optimizer.zero_grad() # 비용 함수를 미분하여 gradient 계산 cost.backward() # backward 연산 # W와 b를 업데이트 optimizer.step() if epoch % 100 == 0: # 100번마다 로그 출력 print('Epoch {:4d}/{} Cost: {:.6f}'.format( epoch, nb_epochs, cost.item() )) Epoch 0/2000 Cost: 13.103540 ... 중략 ... Epoch 2000/2000 Cost: 0.000000 학습이 완료되었습니다. Cost의 값이 매우 작습니다. W와 b의 값도 최적화가 되었는지 확인해 봅시다.에 임의의 값 4를 넣어 모델이 예측하는의 값을 확인해 보겠습니다. # 임의의 입력 4를 선언 new_var = torch.FloatTensor([[4.0]]) # 입력한 값 4에 대해서 예측값 y를 리턴 받아서 pred_y에 저장 pred_y = model(new_var) # forward 연산 # y = 2x이므로 입력이 4라면 y가 8에 가까운 값이 나와야 제대로 학습이 된 것 print("훈련 후 입력이 4일 때의 예측값 :", pred_y) 훈련 후 입력이 4일 때의 예측값 : tensor([[7.9989]], grad_fn=<AddmmBackward>) 사실 이 문제의 정답은 = x 가 정답이므로 y 값이 8에 가까우면 W와 b의 값이 어느 정도 최적화가 된 것으로 볼 수 있습니다. 실제로 예측된 y 값은 7.9989로 8에 매우 가깝습니다. 이제 학습 후의 W와 b의 값을 출력해 보겠습니다. print(list(model.parameters())) [Parameter containing: tensor([[1.9994]], requires_grad=True), Parameter containing: tensor([0.0014], requires_grad=True)] W의 값이 2에 가깝고, b의 값이 0에 가까운 것을 볼 수 있습니다. ( ) 식에 입력 로부터 예측된 를 얻는 것을 forward 연산이라고 합니다. 학습 전, prediction = model(x_train)은 x_train으로부터 예측값을 리턴하므로 forward 연산입니다. 학습 후, pred_y = model(new_var)는 임의의 값 new_var로부터 예측값을 리턴하므로 forward 연산입니다. 학습 과정에서 비용 함수를 미분하여 기울기를 구하는 것을 backward 연산이라고 합니다. cost.backward()는 비용 함수로부터 기울기를 구하라는 의미이며 backward 연산입니다. 2. 다중 선형 회귀 구현하기 이제 nn.Linear()와 nn.functional.mse_loss()로 다중 선형 회귀를 구현해 봅시다. 사실 코드 자체는 달라지는 건 거의 없는데, nn.Linear()의 인자 값과 학습률(learning rate)만 조절해 주었습니다. import torch import torch.nn as nn import torch.nn.functional as F torch.manual_seed(1) 이제 데이터를 선언해 줍니다. 여기서는 3개의로부터 하나의 를 예측하는 문제입니다. 즉, 가설 수식은 ( ) w x + 2 2 w x +입니다. # 데이터 x_train = torch.FloatTensor([[73, 80, 75], [93, 88, 93], [89, 91, 90], [96, 98, 100], [73, 66, 70]]) y_train = torch.FloatTensor([[152], [185], [180], [196], [142]]) 데이터를 정의하였으니 이제 선형 회귀 모델을 구현할 차례입니다. nn.Linear()는 입력의 차원, 출력의 차원을 인수로 받습니다. # 모델을 선언 및 초기화. 다중 선형 회귀이므로 input_dim=3, output_dim=1. model = nn.Linear(3,1) 위 torch.nn.Linear 인자로 3, 1을 사용하였습니다. 3개의 입력 x에 대해서 하나의 출력 y을 가지므로, 입력 차원은 3, 출력 차원은 1을 인수로 사용하였습니다. model에는 3개의 가중치 w와 편향 b가 저장돼 있습니다. 이 값은 model.parameters()라는 함수를 사용하여 불러올 수 있는데, 한 번 출력해 보겠습니다. print(list(model.parameters())) [Parameter containing: tensor([[ 0.2975, -0.2548, -0.1119]], requires_grad=True), Parameter containing: tensor([0.2710], requires_grad=True)] 첫 번째 출력되는 것이 3개의 w고, 두 번째 출력되는 것이 b에 해당됩니다. 두 값 모두 현재는 랜덤 초기화가 되어 있습니다. 그리고 두 출력 결과 모두 학습의 대상이므로 requires_grad=True가 되어 있는 것을 볼 수 있습니다. 이제 옵티마이저를 정의합니다. model.parameters()를 사용하여 3개의 w와 b를 전달합니다. 학습률(learning rate)은 0.00001로 정합니다. 파이썬 코드로는 1e-5로도 표기합니다. 0.01로 하지 않는 이유는 기울기가 발산하기 때문입니다. 궁금하다면 해보시기 바랍니다. 위의 그림은 앞서 배웠던 내용으로, 학습률(learning rate)이 모델의 필요한 크기보다 높을 때, 기울기가 발산하는 현상을 보여줍니다. optimizer = torch.optim.SGD(model.parameters(), lr=1e-5) 이하 코드는 단순 선형 회귀를 구현했을 때와 동일합니다. nb_epochs = 2000 for epoch in range(nb_epochs+1): # H(x) 계산 prediction = model(x_train) # model(x_train)은 model.forward(x_train)와 동일함. # cost 계산 cost = F.mse_loss(prediction, y_train) # <== 파이 토치에서 제공하는 평균 제곱 오차 함수 # cost로 H(x) 개선하는 부분 # gradient를 0으로 초기화 optimizer.zero_grad() # 비용 함수를 미분하여 gradient 계산 cost.backward() # W와 b를 업데이트 optimizer.step() if epoch % 100 == 0: # 100번마다 로그 출력 print('Epoch {:4d}/{} Cost: {:.6f}'.format( epoch, nb_epochs, cost.item() )) Epoch 0/2000 Cost: 31667.597656 ... 중략 ... Epoch 2000/2000 Cost: 0.199777 학습이 완료되었습니다. Cost의 값이 매우 작습니다. 3개의 w와 b의 값도 최적화가 되었는지 확인해 봅시다.에 임의의 입력 [73, 80, 75]를 넣어 모델이 예측하는의 값을 확인해 보겠습니다. # 임의의 입력 [73, 80, 75]를 선언 new_var = torch.FloatTensor([[73, 80, 75]]) # 입력한 값 [73, 80, 75]에 대해서 예측값 y를 리턴 받아서 pred_y에 저장 pred_y = model(new_var) print("훈련 후 입력이 73, 80, 75일 때의 예측값 :", pred_y) 훈련 후 입력이 73, 80, 75일 때의 예측값 : tensor([[151.2305]], grad_fn=<AddmmBackward>) 사실 3개의 값 73, 80, 75는 훈련 데이터로 사용되었던 값입니다. 당시 y의 값은 152였는데, 현재 예측값이 151이 나온 것으로 보아 어느 정도는 3개의 w와 b의 값이 최적화된 것으로 보입니다. 이제 학습 후의 3개의 w와 b의 값을 출력해 보겠습니다. print(list(model.parameters())) [Parameter containing: tensor([[0.9778, 0.4539, 0.5768]], requires_grad=True), Parameter containing: tensor([0.2802], requires_grad=True)] https://tutorials.pytorch.kr/beginner/pytorch_with_examples.html#tensorflow-static-graph https://www.geeksforgeeks.org/linear-regression-using-pytorch/ https://www.yceffort.kr/2019/02/19/pytorch-02-linear-regression/ 03-05 클래스로 파이 토치 모델 구현하기 파이 토치의 대부분의 구현체들은 대부분 모델을 생성할 때 클래스(Class)를 사용하고 있습니다. 앞서 배운 선형 회귀를 클래스로 구현해 보겠습니다. 앞서 구현한 코드와 다른 점은 오직 클래스로 모델을 구현했다는 점입니다. 1. 모델을 클래스로 구현하기 앞서 단순 선형 회귀 모델은 다음과 같이 구현했었습니다. # 모델을 선언 및 초기화. 단순 선형 회귀이므로 input_dim=1, output_dim=1. model = nn.Linear(1,1) 이를 클래스로 구현하면 다음과 같습니다. class LinearRegressionModel(nn.Module): # torch.nn.Module을 상속받는 파이썬 클래스 def __init__(self): # super().__init__() self.linear = nn.Linear(1, 1) # 단순 선형 회귀이므로 input_dim=1, output_dim=1. def forward(self, x): return self.linear(x) model = LinearRegressionModel() 위와 같은 클래스를 사용한 모델 구현<NAME>은 대부분의 파이 토치 구현체에서 사용하고 있는 방식으로 반드시 숙지할 필요가 있습니다. 클래스(class) 형태의 모델은 nn.Module 을 상속받습니다. 그리고 __init__()에서 모델의 구조와 동작을 정의하는 생성자를 정의합니다. 이는 파이썬에서 객체가 갖는 속성값을 초기화하는 역할로, 객체가 생성될 때 자동으로 호출됩니다. super() 함수를 부르면 여기서 만든 클래스는 nn.Module 클래스의 속성들을 가지고 초기화됩니다. foward() 함수는 모델이 학습 데이터를 입력받아서 forward 연산을 진행시키는 함수입니다. 이 forward() 함수는 model 객체를 데이터와 함께 호출하면 자동으로 실행이 됩니다. 예를 들어 model 이란 이름의 객체를 생성 후, model(입력 데이터)와 같은<NAME>으로 객체를 호출하면 자동으로 forward 연산이 수행됩니다. ( ) 식에 입력 로부터 예측된 를 얻는 것을 forward 연산이라고 합니다. 앞서 다중 선형 회귀 모델은 다음과 같이 구현했었습니다. # 모델을 선언 및 초기화. 다중 선형 회귀이므로 input_dim=3, output_dim=1. model = nn.Linear(3,1) 이를 클래스로 구현하면 다음과 같습니다. class MultivariateLinearRegressionModel(nn.Module): def __init__(self): super().__init__() self.linear = nn.Linear(3, 1) # 다중 선형 회귀이므로 input_dim=3, output_dim=1. def forward(self, x): return self.linear(x) model = MultivariateLinearRegressionModel() 2. 단순 선형 회귀 클래스로 구현하기 이제 모델을 클래스로 구현한 코드를 보겠습니다. 달라진 점은 모델을 클래스로 구현했다는 점뿐입니다. 다른 코드는 전부 동일합니다. import torch import torch.nn as nn import torch.nn.functional as F torch.manual_seed(1) # 데이터 x_train = torch.FloatTensor([[1], [2], [3]]) y_train = torch.FloatTensor([[2], [4], [6]]) class LinearRegressionModel(nn.Module): def __init__(self): super().__init__() self.linear = nn.Linear(1, 1) def forward(self, x): return self.linear(x) model = LinearRegressionModel() # optimizer 설정. 경사 하강법 SGD를 사용하고 learning rate를 의미하는 lr은 0.01 optimizer = torch.optim.SGD(model.parameters(), lr=0.01) # 전체 훈련 데이터에 대해 경사 하강법을 2,000회 반복 nb_epochs = 2000 for epoch in range(nb_epochs+1): # H(x) 계산 prediction = model(x_train) # cost 계산 cost = F.mse_loss(prediction, y_train) # <== 파이 토치에서 제공하는 평균 제곱 오차 함수 # cost로 H(x) 개선하는 부분 # gradient를 0으로 초기화 optimizer.zero_grad() # 비용 함수를 미분하여 gradient 계산 cost.backward() # backward 연산 # W와 b를 업데이트 optimizer.step() if epoch % 100 == 0: # 100번마다 로그 출력 print('Epoch {:4d}/{} Cost: {:.6f}'.format( epoch, nb_epochs, cost.item() )) 3. 다중 선형 회귀 클래스로 구현하기 이제 모델을 클래스로 구현한 코드를 보겠습니다. 달라진 점은 모델을 클래스로 구현했다는 점뿐입니다. 다른 코드는 전부 동일합니다. import torch import torch.nn as nn import torch.nn.functional as F torch.manual_seed(1) # 데이터 x_train = torch.FloatTensor([[73, 80, 75], [93, 88, 93], [89, 91, 90], [96, 98, 100], [73, 66, 70]]) y_train = torch.FloatTensor([[152], [185], [180], [196], [142]]) class MultivariateLinearRegressionModel(nn.Module): def __init__(self): super().__init__() self.linear = nn.Linear(3, 1) # 다중 선형 회귀이므로 input_dim=3, output_dim=1. def forward(self, x): return self.linear(x) model = MultivariateLinearRegressionModel() optimizer = torch.optim.SGD(model.parameters(), lr=1e-5) nb_epochs = 2000 for epoch in range(nb_epochs+1): # H(x) 계산 prediction = model(x_train) # model(x_train)은 model.forward(x_train)와 동일함. # cost 계산 cost = F.mse_loss(prediction, y_train) # <== 파이 토치에서 제공하는 평균 제곱 오차 함수 # cost로 H(x) 개선하는 부분 # gradient를 0으로 초기화 optimizer.zero_grad() # 비용 함수를 미분하여 gradient 계산 cost.backward() # W와 b를 업데이트 optimizer.step() if epoch % 100 == 0: # 100번마다 로그 출력 print('Epoch {:4d}/{} Cost: {:.6f}'.format( epoch, nb_epochs, cost.item() )) 03-06 미니 배치와 데이터 로드(Mini Batch and Data Load) 이번 챕터에서 배우는 내용은 선형 회귀에 한정되는 내용은 아닙니다. 이번 챕터에서는 데이터를 로드하는 방법과 미니 배치 경사 하강법(Minibatch Gradient Descent)에 대해서 학습합니다. 1. 미니 배치와 배치 크기(Mini Batch and Batch Size) 앞서 배운 다중 선형 회귀에서 사용했던 데이터를 상기해 봅시다. x_train = torch.FloatTensor([[73, 80, 75], [93, 88, 93], [89, 91, 90], [96, 98, 100], [73, 66, 70]]) y_train = torch.FloatTensor([[152], [185], [180], [196], [142]]) 위 데이터의 샘플의 개수는 5개입니다. 전체 데이터를 하나의 행렬로 선언하여 전체 데이터에 대해서 경사 하강법을 수행하여 학습할 수 있습니다. 그런데 위 데이터는 현업에서 다루게 되는 방대한 양의 데이터에 비하면 굉장히 적은 양입니다. 만약, 데이터가 수십만 개 이상이라면 전체 데이터에 대해서 경사 하강법을 수행하는 것은 매우 느릴 뿐만 아니라 많은 계산량이 필요합니다. 정말 어쩌면 메모리의 한계로 계산이 불가능한 경우도 있을 수 있습니다. 그렇기 때문에 전체 데이터를 더 작은 단위로 나누어서 해당 단위로 학습하는 개념이 나오게 되었습니다. 이 단위를 미니 배치(Mini Batch)라고 합니다. 위의 그림은 전체 데이터를 미니 배치 단위로 나누는 것을 보여줍니다. 미니 배치 학습을 하게 되면 미니 배치만큼만 가져가서 미니 배치에 대한 대한 비용(cost)를 계산하고, 경사 하강법을 수행합니다. 그리고 다음 미니 배치를 가져가서 경사 하강법을 수행하고 마지막 미니 배치까지 이를 반복합니다. 이렇게 전체 데이터에 대한 학습이 1회 끝나면 1 에포크(Epoch)가 끝나게 됩니다. 에포크(Epoch)는 전체 훈련 데이터가 학습에 한 번 사용된 주기를 말한다고 언급한 바 있습니다. 미니 배치 학습에서는 미니 배치의 개수만큼 경사 하강법을 수행해야 전체 데이터가 한 번 전부 사용되어 1 에포크(Epoch)가 됩니다. 미니 배치의 개수는 결국 미니 배치의 크기를 몇으로 하느냐에 따라서 달라지는데 미니 배치의 크기를 배치 크기(batch size)라고 합니다. 전체 데이터에 대해서 한 번에 경사 하강법을 수행하는 방법을 '배치 경사 하강법'이라고 부릅니다. 반면, 미니 배치 단위로 경사 하강법을 수행하는 방법을 '미니 배치 경사 하강법'이라고 부릅니다. 배치 경사 하강법은 경사 하강법을 할 때, 전체 데이터를 사용하므로 가중치 값이 최적값에 수렴하는 과정이 매우 안정적이지만, 계산량이 너무 많이 듭니다. 미니 배치 경사 하강법은 경사 하강법을 할 때, 전체 데이터의 일부만을 보고 수행하므로 최적값으로 수렴하는 과정에서 값이 조금 헤매기도 하지만 훈련 속도가 빠릅니다. 배치 크기는 보통 2의 제곱수를 사용합니다. ex) 2, 4, 8, 16, 32, 64... 그 이유는 CPU와 GPU의 메모리가 2의 배수이므로 배치 크기가 2의 제곱수일 경우에 데이터 송수신의 효율을 높일 수 있다고 합니다. 2. 이터레이션(Iteration) 미니 배치와 배치 크기의 정의에 대해서 이해하였다면 이터레이션(iteration)을 정의할 수 있습니다. 위의 그림은 에포크와 배치 크기와 이터레이션의 관계를 보여줍니다. 위의 그림의 예제를 통해 설명해 보겠습니다. 이터레이션은 한 번의 에포크 내에서 이루어지는 매개변수인 가중치 와의 업데이트 횟수입니다. 전체 데이터가 2,000일 때 배치 크기를 200으로 한다면 이터레이션의 수는 총 10개입니다. 이는 한 번의 에포크 당 매개변수 업데이트가 10번 이루어짐을 의미합니다. 이제 미니 배치 학습을 할 수 있도록 도와주는 파이 토치의 도구들을 알아봅시다. 3. 데이터 로드하기(Data Load) 파이 토치에서는 데이터를 좀 더 쉽게 다룰 수 있도록 유용한 도구로서 데이터 셋(Dataset)과 데이터 로더(DataLoader)를 제공합니다. 이를 사용하면 미니 배치 학습, 데이터 셔플(shuffle), 병렬 처리까지 간단히 수행할 수 있습니다. 기본적인 사용 방법은 Dataset을 정의하고, 이를 DataLoader에 전달하는 것입니다. Dataset을 커스텀 하여 만들 수도 있지만 여기서는 텐서를 입력받아 Dataset의 형태로 변환해 주는 TensorDataset을 사용해 보겠습니다. 실습을 위해 기본적으로 필요한 파이 토치의 도구들을 임포트 합니다. import torch import torch.nn as nn import torch.nn.functional as F TensorDataset과 DataLoader를 임포트 합니다. from torch.utils.data import TensorDataset # 텐서 데이터 셋 from torch.utils.data import DataLoader # 데이터 로더 TensorDataset은 기본적으로 텐서를 입력으로 받습니다. 텐서 형태로 데이터를 정의합니다. x_train = torch.FloatTensor([[73, 80, 75], [93, 88, 93], [89, 91, 90], [96, 98, 100], [73, 66, 70]]) y_train = torch.FloatTensor([[152], [185], [180], [196], [142]]) 이제 이를 TensorDataset의 입력으로 사용하고 dataset으로 저장합니다. dataset = TensorDataset(x_train, y_train) 파이 토치의 데이터 셋을 만들었다면 데이터 로더를 사용 가능합니다. 데이터 로더는 기본적으로 2개의 인자를 입력받는다. 하나는 데이터 셋, 미니 배치의 크기입니다. 이때 미니 배치의 크기는 통상적으로 2의 배수를 사용합니다. (ex) 64, 128, 256...) 그리고 추가적으로 많이 사용되는 인자로 shuffle이 있습니다. shuffle=True를 선택하면 Epoch마다 데이터 셋을 섞어서 데이터가 학습되는 순서를 바꿉니다. 사람도 같은 문제지를 계속 풀면 어느 순간 문제의 순서에 익숙해질 수 있습니다. 예를 들어 어떤 문제지의 12번 문제를 풀면서, '13번 문제가 뭔지는 기억은 안 나지만 어제 풀었던 기억으로 정답은 5번이었던 것 같은데' 하면서 문제 자체보단 순서에 익숙해질 수 있다는 것입니다. 그럴 때 문제지를 풀 때마다 문제 순서를 랜덤으로 바꾸면 도움이 될 겁니다. 마찬가지로 모델이 데이터 셋의 순서에 익숙해지는 것을 방지하여 학습할 때는 이 옵션을 True를 주는 것을 권장합니다. dataloader = DataLoader(dataset, batch_size=2, shuffle=True) 이제 모델과 옵티마이저를 설계합니다. model = nn.Linear(3,1) optimizer = torch.optim.SGD(model.parameters(), lr=1e-5) 이제 훈련을 진행합니다. 아래 코드에서는 batch_idx와 samples를 주석 처리했는데 어떤 식으로 훈련되고 있는지 궁금하다면 주석 처리를 해제하고 훈련시켜보시기 바랍니다. nb_epochs = 20 for epoch in range(nb_epochs + 1): for batch_idx, samples in enumerate(dataloader): # print(batch_idx) # print(samples) x_train, y_train = samples # H(x) 계산 prediction = model(x_train) # cost 계산 cost = F.mse_loss(prediction, y_train) # cost로 H(x) 계산 optimizer.zero_grad() cost.backward() optimizer.step() print('Epoch {:4d}/{} Batch {}/{} Cost: {:.6f}'.format( epoch, nb_epochs, batch_idx+1, len(dataloader), cost.item() )) Epoch 0/20 Batch 1/3 Cost: 26085.919922 Epoch 0/20 Batch 2/3 Cost: 3660.022949 Epoch 0/20 Batch 3/3 Cost: 2922.390869 ... 중략 ... Epoch 20/20 Batch 1/3 Cost: 6.315856 Epoch 20/20 Batch 2/3 Cost: 13.519956 Epoch 20/20 Batch 3/3 Cost: 4.262849 Cost의 값이 점차 작아집니다. (사실 아직 에포크를 더 늘려서 훈련하면 Cost의 값이 더 작아질 여지가 있습니다. 에포크를 늘려서도 훈련해 보세요.) 이제 모델의 입력으로 임의의 값을 넣어 예측값을 확인합니다. # 임의의 입력 [73, 80, 75]를 선언 new_var = torch.FloatTensor([[73, 80, 75]]) # 입력한 값 [73, 80, 75]에 대해서 예측값 y를 리턴 받아서 pred_y에 저장 pred_y = model(new_var) print("훈련 후 입력이 73, 80, 75일 때의 예측값 :", pred_y) 훈련 후 입력이 73, 80, 75일 때의 예측값 : tensor([[154.3850]], grad_fn=<AddmmBackward>) 배치 크기 이야기 : https://hongdoki.github.io/2017/10/07/optimization-difficulty-and-generlization-performance-as-batch-size-increases.html 클래스로 파이 토치 모델 구현하는 것과 데이터 로드에 대한 설명 : https://www.youtube.com/watch? v=KXiDzNai9tI 03-07 커스텀 데이터 셋(Custom Dataset) 앞 내용을 잠깐 복습해 봅시다. 파이 토치에서는 데이터 셋을 좀 더 쉽게 다룰 수 있도록 유용한 도구로서 torch.utils.data.Dataset과 torch.utils.data.DataLoader를 제공합니다. 이를 사용하면 미니 배치 학습, 데이터 셔플(shuffle), 병렬 처리까지 간단히 수행할 수 있습니다. 기본적인 사용 방법은 Dataset을 정의하고, 이를 DataLoader에 전달하는 것입니다. 1. 커스텀 데이터 셋(Custom Dataset) 그런데 torch.utils.data.Dataset을 상속받아 직접 커스텀 데이터 셋(Custom Dataset)을 만드는 경우도 있습니다. torch.utils.data.Dataset은 파이 토치에서 데이터 셋을 제공하는 추상 클래스입니다. Dataset을 상속받아 다음 메서드들을 오버라이드 하여 커스텀 데이터 셋을 만들어보겠습니다. 커스텀 데이터 셋을 만들 때, 일단 가장 기본적인 뼈대는 아래와 같습니다. 여기서 필요한 기본적인 define은 3개입니다. class CustomDataset(torch.utils.data.Dataset): def __init__(self): def __len__(self): def __getitem__(self, idx): 이를 좀 더 자세히 봅시다. class CustomDataset(torch.utils.data.Dataset): def __init__(self): 데이터 셋의 전처리를 해주는 부분 def __len__(self): 데이터 셋의 길이. 즉, 총 샘플의 수를 적어주는 부분 def __getitem__(self, idx): 데이터 셋에서 특정 1개의 샘플을 가져오는 함수 len(dataset)을 했을 때 데이터 셋의 크기를 리턴할 len dataset[i]을 했을 때 i 번째 샘플을 가져오도록 하는 인덱싱을 위한 get_item 2. 커스텀 데이터 셋(Custom Dataset)으로 선형 회귀 구현하기 import torch import torch.nn.functional as F from torch.utils.data import Dataset from torch.utils.data import DataLoader # Dataset 상속 class CustomDataset(Dataset): def __init__(self): self.x_data = [[73, 80, 75], [93, 88, 93], [89, 91, 90], [96, 98, 100], [73, 66, 70]] self.y_data = [[152], [185], [180], [196], [142]] # 총 데이터의 개수를 리턴 def __len__(self): return len(self.x_data) # 인덱스를 입력받아 그에 매핑되는 입출력 데이터를 파이 토치의 Tensor 형태로 리턴 def __getitem__(self, idx): x = torch.FloatTensor(self.x_data[idx]) y = torch.FloatTensor(self.y_data[idx]) return x, y dataset = CustomDataset() dataloader = DataLoader(dataset, batch_size=2, shuffle=True) model = torch.nn.Linear(3,1) optimizer = torch.optim.SGD(model.parameters(), lr=1e-5) nb_epochs = 20 for epoch in range(nb_epochs + 1): for batch_idx, samples in enumerate(dataloader): # print(batch_idx) # print(samples) x_train, y_train = samples # H(x) 계산 prediction = model(x_train) # cost 계산 cost = F.mse_loss(prediction, y_train) # cost로 H(x) 계산 optimizer.zero_grad() cost.backward() optimizer.step() print('Epoch {:4d}/{} Batch {}/{} Cost: {:.6f}'.format( epoch, nb_epochs, batch_idx+1, len(dataloader), cost.item() )) Epoch 0/20 Batch 1/3 Cost: 29410.156250 Epoch 0/20 Batch 2/3 Cost: 7150.685059 Epoch 0/20 Batch 3/3 Cost: 3482.803467 ... 중략 ... Epoch 20/20 Batch 1/3 Cost: 0.350531 Epoch 20/20 Batch 2/3 Cost: 0.653316 Epoch 20/20 Batch 3/3 Cost: 0.010318 # 임의의 입력 [73, 80, 75]를 선언 new_var = torch.FloatTensor([[73, 80, 75]]) # 입력한 값 [73, 80, 75]에 대해서 예측값 y를 리턴 받아서 pred_y에 저장 pred_y = model(new_var) print("훈련 후 입력이 73, 80, 75일 때의 예측값 :", pred_y) 훈련 후 입력이 73, 80, 75일 때의 예측값 : tensor([[151.2319]], grad_fn=<AddmmBackward>) 03-08 벡터와 행렬 연산 복습하기 앞서 독립 변수 가 2개 이상인 다중 선형 회귀를 배웠습니다. 이후에 배우게 될 실습인 소프트맥스 회귀에서는 종속 변수의 종류도 3개 이상이 되면서 더욱 복잡해집니다. 그리고 이러한 식들이 겹겹이 누적되면 인공 신경망의 개념이 됩니다. 우리는 각 변수들의 연산을 벡터와 행렬 연산으로 이해할 수 있어야 합니다. 다시 말해 사용자가 데이터와 변수의 개수로부터 행렬의 크기, 더 나아가 텐서의 크기를 산정할 수 있어야 합니다. 앞서 텐서 조작하기 실습을 통해서 벡터와 행렬에 대해서 언급한 바 있습니다. 여기서 기본적인 벡터와 행렬 연산에 대해서 다시 복습해 보겠습니다. 1. 벡터와 행렬과 텐서 벡터는 크기와 방향을 가진 양입니다. 숫자가 나열된 형상이며 파이썬에서는 1차원 배열 또는 리스트로 표현합니다. 반면, 행렬은 행과 열을 가지는 2차원 형상을 가진 구조입니다. 파이썬에서는 2차원 배열로 표현합니다. 가로줄을 행(row)라고 하며, 세로줄을 열(column)이라고 합니다. 3차원부터는 주로 텐서라고 부릅니다. 텐서는 파이썬에서는 3차원 이상의 배열로 표현합니다. 2. 텐서(Tensor) 인공 신경망은 복잡한 모델 내의 연산을 주로 행렬 연산을 통해 해결합니다. 그런데 여기서 말하는 행렬 연산이란 단순히 2차원 배열을 통한 행렬 연산만을 의미하는 것이 아닙니다. 머신 러닝의 입, 출력이 복잡해지면 3차원 텐서에 대한 이해가 필수로 요구됩니다. 예를 들어 인공 신경망 모델 중 하나인 RNN에서는 3차원 텐서에 대한 개념 이해 없이는 이해하기가 쉽지 않습니다. Numpy를 사용하여 텐서를 설명해 보겠습니다. import numpy as np 1) 0차원 텐서(스칼라) 스칼라는 하나의 실숫값으로 이루어진 데이터를 말합니다. 이를 0차원 텐서라고 합니다. 차원을 영어로 Dimension이라고 하므로 0D 텐서라고도 합니다. d = np.array(5) print('텐서의 차원 :',d.ndim) print('텐서의 크기(shape) :',d.shape) 텐서의 차원 : 0 텐서의 크기(shape) : () Numpy의 ndim을 출력했을 때 나오는 값에 주목합시다. ndim을 출력했을 때 나오는 값을 우리는 축(axis)의 개수 또는 텐서의 차원이라고 부릅니다. 반드시 이 두 용어를 기억해둡시다. 2) 1차원 텐서(벡터) 숫자를 배열한 것을 벡터라고 합니다. 벡터는 1차원 텐서입니다. 주의할 점은 벡터에서도 차원이라는 용어를 쓰는데, 벡터의 차원과 텐서의 차원은 다른 개념이라는 점입니다. 아래의 예제는 4차원 벡터이지만, 1차원 텐서입니다. 1D 텐서라고도 합니다. d = np.array([1, 2, 3, 4]) print('텐서의 차원 :',d.ndim) print('텐서의 크기(shape) :',d.shape) 텐서의 차원 : 1 텐서의 크기(shape) : (4, ) 벡터의 차원과 텐서의 차원의 정의로 인해 혼동할 수 있는데 벡터에서의 차원은 하나의 축에 놓인 원소의 개수를 의미하는 것이고, 텐서에서의 차원은 축의 개수를 의미합니다. 3) 2차원 텐서(행렬) 행과 열이 존재하는 벡터의 배열. 즉, 행렬(matrix)을 2차원 텐서라고 합니다. 2D 텐서라고도 합니다. # 3행 4열의 행렬 d = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]) print('텐서의 차원 :',d.ndim) print('텐서의 크기(shape) :',d.shape) 텐서의 차원 : 2 텐서의 크기(shape) : (3, 4) 텐서의 크기(shape)에 대해서도 정리합시다. 텐서의 크기란, 각 축을 따라서 얼마나 많은 차원이 있는지를 나타낸 값입니다. 텐서의 크기를 바로 머릿속으로 떠올릴 수 있으면 모델 설계 시에 유용합니다. 처음에는 어려울 수도 있는데, 순차적으로 확장해나가며 생각하는 것도 방법입니다. 위의 경우 3개의 커다란 데이터가 있는데 그 각각의 커다란 데이터는 작은 데이터 4개로 이루어졌다고 생각할 수 있습니다. 4) 3차원 텐서(다차원 배열) 행렬 또는 2차원 텐서를 단위로 한 번 더 배열하면 3차원 텐서라고 부릅니다. 3D 텐서라고도 합니다. 사실 위에서 언급한 0차원 ~ 2차원 텐서는 각각 스칼라, 벡터, 행렬이라고 해도 무방하므로 3차원 이상의 텐서부터 본격적으로 텐서라고 부릅니다. 데이터 사이언스 분야 한정으로 주로 3차원 이상의 배열을 텐서라고 부른다고 이해해도 좋습니다. 3D 텐서는 적어도 여기서는 3차원 배열로 이해하면 되겠습니다. 이 3차원 텐서의 구조를 이해하지 않으면, 복잡한 인공 신경망의 입, 출력값을 이해하는 것이 쉽지 않습니다. 개념 자체는 어렵지 않지만 반드시 알아야 하는 개념입니다. d = np.array([ [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [10, 11, 12, 13, 14]], [[15, 16, 17, 18, 19], [19, 20, 21, 22, 23], [23, 24, 25, 26, 27]] ]) print('텐서의 차원 :',d.ndim) print('텐서의 크기(shape) :',d.shape) 텐서의 차원 : 3 텐서의 크기(shape) : (2, 3, 5) 자연어 처리에서 특히 자주 보게 되는 것이 이 3D 텐서입니다. 3D 텐서는 시퀀스 데이터(sequence data)를 표현할 때 자주 사용되기 때문입니다. 여기서 시퀀스 데이터는 주로 단어의 시퀀스를 의미하며, 시퀀스는 주로 문장이나 문서, 뉴스 기사 등의 텍스트가 될 수 있습니다. 이 경우 3D 텐서는 (samples, timesteps, word_dim)이 됩니다. 또는 일괄로 처리하기 위해 데이터를 묶는 단위인 배치의 개념에 대해서 뒤에서 배울 텐데 (batch_size, timesteps, word_dim)이라고도 볼 수 있습니다. samples 또는 batch_size는 샘플의 개수, timesteps는 시퀀스의 길이, word_dim은 단어를 표현하는 벡터의 차원을 의미합니다. 더 상세한 설명은 RNN 챕터에서 배우게 되겠지만 자연어 처리에서 왜 3D 텐서의 개념이 사용되는지 간단한 예를 들어봅시다. 다음과 같은 3개의 훈련 데이터가 있다고 해봅시다. 문서 1 : I like NLP 문서 2 : I like DL 문서 3 : DL is AI 이를 인공 신경망의 모델의 입력으로 사용하기 위해서는 각 단어를 벡터 화해야 합니다. 단어를 벡터화하는 방법으로는 원-핫 인코딩이나 워드 임베딩이라는 방법이 대표적입니다. 워드 임베딩은 아직 배우지 않았으므로 원-핫 인코딩으로 각 단어를 벡터화해보겠습니다. 단어 One-hot vector I [1 0 0 0 0 0] like [0 1 0 0 0 0] NLP [0 0 1 0 0 0] DL [0 0 0 1 0 0] is [0 0 0 0 1 0] AI [0 0 0 0 0 1] 훈련 데이터의 단어들을 모두 원-핫 벡터로 바꿔서 인공 신경망의 입력으로 한꺼번에 사용한다고 하면 다음과 같습니다. 이렇게 훈련 데이터를 다수 묶어 입력으로 사용하는 것을 딥 러닝에서는 배치(Batch)라고 합니다. [[[1, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0]], [[1, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0]], [[0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 1]]] 이는 (3, 3, 6)의 크기를 가지는 3D 텐서입니다. 5) 그 이상의 텐서 3차원 텐서를 배열로 합치면 4차원 텐서가 됩니다. 4차원 텐서를 배열로 합치면 5차원 텐서가 됩니다. 이렇게 텐서는 다차원 배열로서 계속해서 확장될 수 있습니다. 위의 그림은 각 텐서를 도형으로 시각화한 모습을 보여줍니다. 6) PyTorch에서의 텐서 2챕터의 '텐서 조작하기' 실습을 참고하세요. 3. 벡터와 행렬의 연산 벡터와 행렬의 기본적인 연산에 대해서 알아보겠습니다. import numpy as np 1) 벡터와 행렬의 덧셈과 뺄셈 같은 크기의 두 개의 벡터나 행렬은 덧셈과 뺄셈을 할 수 있습니다. 이 경우 같은 위치의 원소끼리 연산하면 됩니다. 이러한 연산을 요소별(element-wise) 연산이라고 합니다. 다음과 같이 A와 B라는 두 개의 벡터가 있다고 해봅시다. = [ 4 ] B [ 2 ] 이때 두 벡터 A와 B의 덧셈과 뺄셈은 아래와 같습니다. + = [ 4 ] [ 2 ] [ 6 ] − = [ 4 ] [ 2 ] [ 2 ] Numpy를 이용하여 이를 구현할 수 있습니다. A = np.array([8, 4, 5]) B = np.array([1, 2, 3]) print('도 벡터의 합 :',A+B) print('도 벡터의 차 :',A-B) 두 행렬의 합 : [9 6 8] 두 행렬의 차 : [7 2 2] 행렬도 마찬가지입니다. A와 B라는 두 개의 행렬이 있다고 하였을 때, 두 행렬 A와 B의 덧셈과 뺄셈은 아래와 같습니다. = [ 10 20 30 40 50 60 70 80 ] B [ 6 7 8 2 3 4 ] + = [ 10 20 30 40 50 60 70 80 ] [ 6 7 8 2 3 4 ] [ 15 26 37 48 51 62 73 84 ] − = [ 10 20 30 40 50 60 70 80 ] [ 6 7 8 2 3 4 ] [ 14 23 32 49 58 67 76 ] Numpy를 이용하여 이를 구현할 수 있습니다. A = np.array([[10, 20, 30, 40], [50, 60, 70, 80]]) B = np.array([[5, 6, 7, 8],[1, 2, 3, 4]]) print('도 행렬의 합 :') print(A + B) print('도 행렬의 차 :') print(A - B) 두 행렬의 합 : [[15 26 37 48] [51 62 73 84]] 두 행렬의 차 : [[ 5 14 23 32] [49 58 67 76]] 2) 벡터의 내적과 행렬의 곱셈 벡터의 점곱(dot product) 또는 내적(inner product)에 대해 알아봅시다. 벡터의 내적은 연산을 점(dot)으로 표현하여 ⋅ 와 같이 표현하기도 합니다. 내적이 성립하기 위해서는 두 벡터의 차원이 같아야 하며, 두 벡터 중 앞의 벡터가 행벡터(가로 방향 벡터)이고 뒤의 벡터가 열벡터(세로 방향 벡터) 여야 합니다. 아래는 두 벡터의 차원이 같고 곱셈의 대상이 각각 행벡터이고 열벡터일 때 내적이 이루어지는 모습을 보여줍니다. 벡터의 내적의 결과는 스칼라가 된다는 특징이 있습니다. 스칼라 ⋅ = [ 2 3 ] [ 5 ] 1 4 2 5 3 6 32 (스칼라) Numpy를 이용하여 이를 구현할 수 있습니다. A = np.array([1, 2, 3]) B = np.array([4, 5, 6]) print('도 벡터의 내적 :',np.dot(A, B)) 두 벡터의 내적 : 32 행렬의 곱셈을 이해하기 위해서는 벡터의 내적을 이해해야 합니다. 행렬의 곱셈은 왼쪽 행렬의 행벡터(가로 방향 벡터)와 오른쪽 행렬의 열벡터(세로 방향 벡터)의 내적(대응하는 원소들의 곱의 합)이 결과 행렬의 원소가 되는 것으로 이루어집니다. 다음과 같이 A와 B라는 두 개의 행렬이 있다고 하였을 때, 두 행렬 A와 B의 행렬의 곱셈은 아래와 같습니다. = [ 3 4 ] B [ 7 8 ] B [ 3 4 ] [ 7 8 ] [ × + × 1 7 3 8 × + × 2 7 4 8 ] [ 23 31 34 46 ] Numpy를 이용하여 이를 구현할 수 있습니다. A = np.array([[1, 3],[2, 4]]) B = np.array([[5, 7],[6, 8]]) print('도 행렬의 행렬곱 :') print(np.matmul(A, B)) 두 행렬의 행렬곱 : [[23 31] [34 46]] 행렬의 곱셈은 딥 러닝을 이해하기 위해 필수적인 개념이므로 반드시 숙지해야 합니다. 행렬 곱셈에서의 주요한 두 가지 조건 또한 반드시 기억해둡시다. 두 행렬의 곱 A × B이 성립되기 위해서는 행렬 A의 열의 개수와 행렬 B의 행의 개수는 같아야 한다. 두 행렬의 곱 A × B의 결과로 나온 행렬 AB의 크기는 A의 행의 개수와 B의 열의 개수를 가진다. 벡터와 행렬의 곱 또는 행렬과 벡터의 곱 또한 행렬의 곱셈과 동일한 원리로 이루어집니다. 4. 다중 선형 회귀 행렬 연산으로 이해하기 독립 변수가 2개 이상일 때, 1개의 종속 변수를 예측하는 문제를 행렬의 연산으로 표현한다면 어떻게 될까요? 다중 선형 회귀나 다중 로지스틱 회귀가 이러한 연산의 예인데, 여기서는 다중 선형 회귀를 통해 예를 들어보겠습니다. 다음은 독립 변수 가 n 개인 다중 선형 회귀 수식입니다. = 1 1 w x + 3 3. . w x + 이는 입력 벡터 [ 1. . n ] 와 가중치 벡터 [ 1. . w ] 의 내적으로 표현할 수 있습니다. = [ 1 x x ⋅ ⋅ x ] [ 1 2 3 ⋅ w ] b x w + 2 2 x w + 또는 가중치 벡터 [ 1. . w ] 와 입력 벡터 [ 1. . n ] 의 내적으로 표현할 수도 있습니다. = [ 1 w w ⋅ ⋅ w ] [ 1 2 3 ⋅ x ] b x w + 2 2 x w 샘플의 개수가 많을 경우에는 행렬의 곱셈으로 표현이 가능합니다. 다음은 집의 크기, 방의 수, 층의 수, 집이 얼마나 오래되었는지와 집의 가격이 기록된 부동산 데이터라고 가정합시다. 해당 데이터를 학습하여 새로운 집의 정보가 들어왔을 때, 집의 가격을 예측하는 모델을 구현한다고 해봅시다. size( e t)( 1 ) number of bedrooms( 2 ) number of floors( 3 ) age of home( 4 ) price($1000)(y) 1800 2 1 10 207 1200 4 2 20 176 1700 3 2 15 213 1500 5 1 10 234 1100 2 2 10 155 위 데이터에 대해서 입력 행렬 와 가중치 벡터의 곱으로 표현하면 다음과 같습니다. [ 11 x 12 x 13 x 14 21 x 22 x 23 x 24 31 x 32 x 33 x 34 41 x 42 x 43 x 44 51 x 52 x 53 x 54 ] [ 1 2 3 4 ] [ 11 1 x 12 2 x 13 3 x 14 4 21 1 x 22 2 x 23 3 x 24 4 31 1 x 32 2 x 33 3 x 34 4 41 1 x 42 2 x 43 3 x 44 4 51 1 x 52 2 x 53 3 x 54 4 여기에 편향 벡터를 더 해주면 위 데이터에 대한 전체 가설 수식 ( ) 를 표현할 수 있습니다. [ 11 1 x 12 2 x 13 3 x 14 4 21 1 x 22 2 x 23 3 x 24 4 31 1 x 32 2 x 33 3 x 34 4 41 1 x 42 2 x 43 3 x 44 4 51 1 x 52 2 x 53 3 x 54 4 ] [ b b ] [ 1 2 3 4 5 ] ( ) X + 위의 수식에서 입력 행렬 는 5행 4열의 크기를 가집니다. 출력 벡터를 라고 하였을 때는 5행 1열의 크기를 가집니다. 여기서 곱셈이 성립하기 위해서 가중치 벡터의 크기는 4행 1열을 가져야 함을 추론할 수 있습니다. 만약 가중치 벡터를 앞에 두고 입력 행렬을 뒤에 두고 행렬 연산을 한다면 이는 아래와 같습니다. [ 1 w w w ] [ 11 x 21 x 31 x 41 x 51 12 x 22 x 32 x 42 x 52 13 x 23 x 33 x 43 x 53 14 x 24 x 34 x 44 x 54 ] [ b b b b ] [ 1 수학적 관례로 아래와 같이 수식으로 표현할 때는 주로 가중치 가 입력의 앞에 오는 편입니다. ( ) W + 인공 신경망도 본질적으로 위와 같은 행렬 연산입니다. 5. 샘플(Sample)과 특성(Feature) 훈련 데이터의 입력 행렬을라고 하였을 때 샘플(Sample)과 특성(Feature)의 정의는 다음과 같습니다. 머신 러닝에서는 데이터를 셀 수 있는 단위로 구분할 때, 각각을 샘플이라고 부르며, 종속 변수를 예측하기 위한 각각의 독립 변수를 특성이라고 부릅니다. 6. 가중치와 편향 행렬의 크기 결정 앞서 언급하였던 행렬 곱셈의 두 가지 주요한 조건을 기억해둡시다. 두 행렬의 곱 J × K이 성립되기 위해서는 행렬 J의 열의 개수와 행렬 K의 행의 개수는 같아야 한다. 두 행렬의 곱 J × K의 결과로 나온 행렬 JK의 크기는 J의 행의 개수와 K의 열의 개수를 가진다. 이로부터 입력과 출력의 행렬의 크기로부터 가중치 행렬 W와 편향 행렬 B의 크기를 찾아낼 수 있습니다. 독립 변수 행렬을 X, 종속 변수 행렬을 Y라고 하였을 때, 이때 행렬 X를 입력 행렬(Input Matrix), Y를 출력 행렬(Output Matrix)이라고 합시다. 이제 입력 행렬의 크기와 출력 행렬의 크기로부터 W 행렬과 B 행렬의 크기를 추론해 봅시다. 행렬의 덧셈에 해당되는 B 행렬은 Y 행렬의 크기에 영향을 주지 않습니다. 그러므로 B 행렬의 크기는 Y 행렬의 크기와 같습니다. 행렬의 곱셈이 성립되려면 행렬의 곱셈에서 앞에 있는 행렬의 열의 크기와 뒤에 있는 행렬의 행의 크기는 같아야 합니다. 그러므로 입력 행렬 X로부터 W 행렬의 행의 크기가 결정됩니다. 두 행렬의 곱의 결과로서 나온 행렬의 열의 크기는 행렬의 곱셈에서 뒤에 있는 행렬의 열의 크기와 동일합니다. 그러므로 출력 행렬 Y로부터 W 행렬의 열의 크기가 결정됩니다. 입력 행렬과 출력 행렬의 크기로부터 가중치 행렬과 편향 행렬의 크기를 추정할 수 있다면, 딥 러닝 모델을 구현하였을 때 해당 모델에 존재하는 총 매개변수의 개수를 계산하기 쉽습니다. 어떤 딥 러닝 모델의 총 매개변수의 개수는 해당 모델에 존재하는 가중치 행렬과 편향 행렬의 모든 원소의 수이기 때문입니다. 04. [ML 입문 ✏] - 로지스틱 회귀(Logistic Regression) 이번 챕터에서는 이진 분류를 수행하는 로지스틱 회귀에 대해서 알아보겠습니다. 04-01 로지스틱 회귀(Logistic Regression) 일상 속 풀고자 하는 많은 문제 중에서는 두 개의 선택지 중에서 정답을 고르는 문제가 많습니다. 예를 들어 시험을 봤는데 이 시험 점수가 합격인지 불합격인지가 궁금할 수도 있고, 어떤 메일을 받았을 때 이게 정상 메일인지 스팸 메일인지를 분류하는 문제도 그렇습니다. 이렇게 둘 중 하나를 결정하는 문제를 이진 분류(Binary Classification)라고 합니다. 그리고 이진 분류를 풀기 위한 대표적인 알고리즘으로 로지스틱 회귀(Logistic Regression)가 있습니다. 로지스틱 회귀는 알고리즘의 이름은 회귀이지만 실제로는 분류(Classification) 작업에 사용할 수 있습니다. 1. 이진 분류(Binary Classification) 학생들이 시험 성적에 따라서 합격, 불합격이 기재된 데이터가 있다고 가정해 봅시다. 시험 성적이라면, 합불 결과는입니다. 이 시험의 커트라인은 공개되지 않았는데 이 데이터로부터 특정 점수를 얻었을 때의 합격, 불합격 여부를 판정하는 모델을 만들고자 합시다. score( ) result( ) 45 불합격 50 불합격 55 불합격 60 합격 65 합격 70 합격 위의 데이터에서 합격을 1, 불합격을 0이라고 하였을 때 그래프를 그려보면 아래와 같습니다. 이러한 점들을 표현하는 그래프는 알파벳의 S자 형태로 표현됩니다. 이러한 와의 관계를 표현하기 위해서는 x b 와 같은 직선 함수가 아니라 S자 형태로 표현할 수 있는 함수가 필요합니다. 이런 문제에 직선을 사용할 경우 분류 작업이 잘 동작하지 않습니다. 그래서 이번 로지스틱 회귀의 가설은 선형 회귀 때의 ( ) W + 가 아니라, 위와 같이 S자 모양의 그래프를 만들 수 있는 어떤 특정 함수를 추가적으로 사용하여 ( ) f ( x b ) 의 가설을 사용할 겁니다. 그리고 위와 같이 S자 모양의 그래프를 그릴 수 있는 어떤 함수 가 이미 널리 알려져 있습니다. 바로 시그모이드 함수입니다. 2. 시그모이드 함수(Sigmoid function) 위와 같이 S자 형태로 그래프를 그려주는 시그모이드 함수의 방정식은 아래와 같습니다. ( ) s g o d ( x b ) 1 + − ( x b ) σ ( x b ) 선형 회귀에서는 최적의 와를 찾는 것이 목표였습니다. 여기서도 마찬가지입니다. 선형 회귀에서는 가 직선의 기울기, 가 y 절편을 의미했습니다. 그렇다면 여기에서는 와 가 함수의 그래프에 어떤 영향을 주는지 직접 그래프를 그려서 알아보겠습니다. 파이썬에서는 그래프를 그릴 수 있는 도구로서 Matplotlib을 사용할 수 있습니다. 우선 Matplotlib과 Numpy를 임포트 합니다. %matplotlib inline import numpy as np # 넘파이 사용 import matplotlib.pyplot as plt # 맷플롯립사용 Numpy를 사용하여 시그모이드 함수를 정의합니다. def sigmoid(x): # 시그모이드 함수 정의 return 1/(1+np.exp(-x)) 1. W가 1이고 b가 0인 그래프 가장 먼저 가 1이고, 가 0인 그래프를 그려봅시다. x = np.arange(-5.0, 5.0, 0.1) y = sigmoid(x) plt.plot(x, y, 'g') plt.plot([0,0],[1.0,0.0], ':') # 가운데 점선 추가 plt.title('Sigmoid Function') plt.show() 위의 그래프를 통해시그모이드 함수는 출력값을 0과 1사이의 값으로 조정하여 반환함을 알 수 있습니다. 가 0일 때 0.5의 값을 가집니다. 가 매우 커지면 1에 수렴합니다. 반면, 가 매우 작아지면 0에 수렴합니다. 2. W 값의 변화에 따른 경사도의 변화 이제 의 값을 변화시키고 이에 따른 그래프를 확인해 보겠습니다. x = np.arange(-5.0, 5.0, 0.1) y1 = sigmoid(0.5*x) y2 = sigmoid(x) y3 = sigmoid(2*x) plt.plot(x, y1, 'r', linestyle='--') # W의 값이 0.5일 때 plt.plot(x, y2, 'g') # W의 값이 1일 때 plt.plot(x, y3, 'b', linestyle='--') # W의 값이 2일 때 plt.plot([0,0],[1.0,0.0], ':') # 가운데 점선 추가 plt.title('Sigmoid Function') plt.show() 위의 그래프는 의 값이 0.5일 때 빨간색 선,의 값이 1일 때는 초록색선, 의 값이 2일 때 파란색 선이 나오도록 하였습니다. 자세히 보면의 값에 따라 그래프의 경사도가 변하는 것을 볼 수 있습니다. 앞서 선형 회귀에서 가중치는 직선의 기울기를 의미했지만, 여기서는 그래프의 경사도를 결정합니다.의 값이 커지면 경사가 커지고의 값이 작아지면 경사가 작아집니다. 3. b 값의 변화에 따른 좌, 우 이동 이제 의 값에 따라서 그래프가 어떻게 변하는지 확인해 보겠습니다. x = np.arange(-5.0, 5.0, 0.1) y1 = sigmoid(x+0.5) y2 = sigmoid(x+1) y3 = sigmoid(x+1.5) plt.plot(x, y1, 'r', linestyle='--') # x + 0.5 plt.plot(x, y2, 'g') # x + 1 plt.plot(x, y3, 'b', linestyle='--') # x + 1.5 plt.plot([0,0],[1.0,0.0], ':') # 가운데 점선 추가 plt.title('Sigmoid Function') plt.show() 위의 그래프는 의 값에 따라서 그래프가 좌, 우로 이동하는 것을 보여줍니다. 4. 시그모이드 함수를 이용한 분류 시그모이드 함수는 입력값이 한없이 커지면 1에 수렴하고, 입력값이 한없이 작아지면 0에 수렴합니다. 시그모이드 함수의 출력값은 0과 1 사이의 값을 가지는데 이 특성을 이용하여 분류 작업에 사용할 수 있습니다. 예를 들어 임곗값을 0.5라고 정해보겠습니다. 출력값이 0.5 이상이면 1(True), 0.5이하면 0(False)으로 판단하도록 할 수 있습니다. 이를 확률이라고 생각하면 해당 레이블에 속할 확률이 50%가 넘으면 해당 레이블로 판단하고, 해당 레이블에 속할 확률이 50%보다 낮으면 아니라고 판단하는 것으로 볼 수 있습니다. 3. 비용 함수(Cost function) 이제 로지스틱 회귀의 가설이 ( ) s g o d ( x b ) 인 것은 알았습니다. 이제 최적의 와를 찾을 수 있는 비용 함수(cost function)를 정의해야 합니다. 그런데 혹시 앞서 선형 회귀에서 배운 비용 함수인 평균 제곱 오차(Mean Square Error, MSE)를 로지스틱 회귀의 비용 함수로 그냥 사용하면 안 될까요? 다음은 선형 회귀에서 사용했던 평균 제곱 오차의 수식입니다. o t ( , ) 1 ∑ = n [ ( ) H ( ( ) ) ] 위의 비용 함수 수식에서 가설은 이제 ( ) W + 가 아니라 ( ) s g o d ( x b ) 입니다. 그리고 이 비용 함수를 미분하면 선형 회귀 때와 달리 다음의 그림과 유사한 심한 비볼록(non-convex) 형태의 그래프가 나옵니다. 위와 같은 그래프에 경사 하강법을 사용할 경우의 문제점은 경사 하강법이 오차가 최솟값이 되는 구간에 도착했다고 판단한 그 구간이 실제 오차가 완전히 최솟값이 되는 구간이 아닐 수 있다는 점입니다. 사람이 등산 후에 산을 내려올 때도, 가파른 경사를 내려오다가 넓은 평지가 나오면 순간적으로 다 내려왔다고 착각할 수 있습니다. 하지만 실제로는 그곳이 다 내려온 것이 아니라 잠깐 평지가 나왔을 뿐이라면 길을 더 찾아서 더 내려가야 할 겁니다. 모델도 마찬가지로 실제 오차가 최소가 되는 구간을 찾을 수 있도록 도와주어야 합니다. 만약, 실제 최소가 되는 구간을 잘못 판단하면 최적의 가중치 가 아닌 다른 값을 택해 모델의 성능이 더 오르지 않습니다. 이를 전체 함수에 걸쳐 최솟값인 글로벌 미니멈(Global Minimum)이 아닌 특정 구역에서의 최솟값인 로컬 미니멈(Local Minimum)에 도달했다고 합니다. 이는 cost가 최소가 되는 가중치를 찾는다는 비용 함수의 목적에 맞지 않습니다. 시그모이드 함수의 특징은 함수의 출력값이 0과 1사이의 값이라는 점입니다. 즉, 실제 값이 1일 때 예측값이 0에 가까워지면 오차가 커져야 하며, 실제 값이 0일 때, 예측값이 1에 가까워지면 오차가 커져야 합니다. 그리고 이를 충족하는 함수가 바로 로그 함수입니다. 다음은 = 0.5 에 대칭하는 두 개의 로그 함수 그래프입니다. 실제 값이 1일 때의 그래프를 주황색 선으로 표현하였으며, 실제 값이 0일 때의 그래프를 초록색 선으로 표현하였습니다. 실제 값이 1이라고 해봅시다. 이 경우, 예측값인 ( ) 의 값이 1이면 오차가 0이므로 당연히 cost는 0이 됩니다. 반면, ( ) 가 0으로 수렴하면 cost는 무한대로 발산합니다. 실제 값이 0인 경우는 그 반대로 이해하면 됩니다. 이 두 개의 로그 함수를 식으로 표현하면 다음과 같습니다. if = → cost ( ( ) y ) − log ( ( ) ) if = → cost ( ( ) y ) − log ( − ( ) )의 실제 값이 1일 때 l g ( ) 그래프를 사용하고의 실제 값이 0일 때 l g ( − ( ) ) 그래프를 사용해야 합니다. 이는 다음과 같이 하나의 식으로 통합할 수 있습니다. cost ( ( ) y ) − [ l g ( ) ( − ) o ( − ( ) ) ] 왜 위 식이 두 개의 식을 통합한 식이라고 볼 수 있을까요? 실제 값 가 1이라고 하면 덧셈 기호를 기준으로 우측의 항이 없어집니다. 반대로 실제 값 가 0이라고 하면 덧셈 기호를 기준으로 좌측의 항이 없어집니다. 선형 회귀에서는 모든 오차의 평균을 구해 평균 제곱 오차를 사용했었습니다. 마찬가지로 여기에서도 모든 오차의 평균을 구합니다. o t ( ) − n i 1 [ ( ) o H ( ( ) ) ( − ( ) ) o ( − ( ( ) ) ) ] 정리하면, 위 비용 함수는 실제 값 와 예측값 ( ) 의 차이가 커지면 cost가 커지고, 실제 값 와 예측값 ( ) 의 차이가 작아지면 cost는 작아집니다. 이제 위 비용 함수에 대해서 경사 하강법을 수행하면서 최적의 가중치를 찾아갑니다. := − ∂ W o t ( ) 4. 파이 토치로 로지스틱 회귀 구현하기 이제 파이 토치로 로지스틱 회귀 중에서도 다수의 로 부터 를 예측하는 다중 로지스틱 회귀를 구현해 봅시다. 우선 필요한 도구들을 임포트 합니다. import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim torch.manual_seed(1) x_train과 y_train을 텐서로 선언합니다. x_data = [[1, 2], [2, 3], [3, 1], [4, 3], [5, 3], [6, 2]] y_data = [[0], [0], [0], [1], [1], [1]] x_train = torch.FloatTensor(x_data) y_train = torch.FloatTensor(y_data) 앞서 훈련 데이터를 행렬로 선언하고, 행렬 연산으로 가설을 세우는 방법을 배웠습니다. 여기서도 마찬가지로 행렬 연산을 사용하여 가설식을 세울 겁니다. x_train과 y_train의 크기를 확인해 봅시다. print(x_train.shape) print(y_train.shape) torch.Size([6, 2]) torch.Size([6, 1]) 현재 x_train은 6 × 2의 크기(shape)를 가지는 행렬이며, y_train은 6 × 1의 크기를 가지는 벡터입니다. x_train을라고 하고, 이와 곱해지는 가중치 벡터를 라고 하였을 때, W 가 성립되기 위해서는 벡터의 크기는 2 × 1이어야 합니다. 이제 W와 b를 선언합니다. W = torch.zeros((2, 1), requires_grad=True) # 크기는 2 x 1 b = torch.zeros(1, requires_grad=True) 이제 가설식을 세워보겠습니다. 파이 토치에서는 x 를 구현하기 위해서 torch.exp(x)를 사용합니다. 이에 따라 행렬 연산을 사용한 가설식은 다음과 같습니다. hypothesis = 1 / (1 + torch.exp(-(x_train.matmul(W) + b))) 앞서 W와 b는 torch.zeros를 통해 전부 0으로 초기화된 상태입니다. 이 상태에서 예측값을 출력해 봅시다. print(hypothesis) # 예측값인 H(x) 출력 tensor([[0.5000], [0.5000], [0.5000], [0.5000], [0.5000], [0.5000]], grad_fn=<MulBackward>) 실제 값 y_train과 크기가 동일한 6 × 1의 크기를 가지는 예측값 벡터가 나오는데 모든 값이 0.5입니다. 사실 가설식을 좀 더 간단하게도 구현할 수 있습니다. 이미 파이 토치에서는 시그모이드 함수를 이미 구현하여 제공하고 있기 때문입니다. 다음은 torch.sigmoid를 사용하여 좀 더 간단히 구현한 가설식입니다. hypothesis = torch.sigmoid(x_train.matmul(W) + b) 앞서 구현한 식과 본질적으로 동일한 식입니다. 마찬가지로 W와 b가 0으로 초기화된 상태에서 예측값을 출력해 봅시다. print(hypothesis) tensor([[0.5000], [0.5000], [0.5000], [0.5000], [0.5000], [0.5000]], grad_fn=<SigmoidBackward>) 앞선 결과와 동일하게 y_train과 크기가 동일한 6 × 1의 크기를 가지는 예측값 벡터가 나오는데 모든 값이 0.5입니다. 이제 아래의 비용 함숫값. 즉, 현재 예측값과 실제 값 사이의 cost를 구해보겠습니다. o t ( ) − n i 1 [ ( ) o H ( ( ) ) ( − ( ) ) o ( − ( ( ) ) ) ] 우선, 현재 예측값과 실제 값을 출력해 보겠습니다. print(hypothesis) print(y_train) tensor([[0.5000], [0.5000], [0.5000], [0.5000], [0.5000], [0.5000]], grad_fn=<SigmoidBackward>) tensor([[0.], [0.], [0.], [1.], [1.], [1.]]) 현재 총 6개의 원소가 존재하지만 하나의 샘플. 즉, 하나의 원소에 대해서만 오차를 구하는 식을 작성해 보겠습니다. -(y_train[0] * torch.log(hypothesis[0]) + (1 - y_train[0]) * torch.log(1 - hypothesis[0])) tensor([0.6931], grad_fn=<NegBackward>) 이제 모든 원소에 대해서 오차를 구해보겠습니다. losses = -(y_train * torch.log(hypothesis) + (1 - y_train) * torch.log(1 - hypothesis)) print(losses) tensor([[0.6931], [0.6931], [0.6931], [0.6931], [0.6931], [0.6931]], grad_fn=<NegBackward>) 그리고 이 전체 오차에 대한 평균을 구합니다. cost = losses.mean() print(cost) tensor(0.6931, grad_fn=<MeanBackward1>) 결과적으로 얻은 cost는 0.6931입니다. 지금까지 비용 함수의 값을 직접 구현하였는데, 사실 파이 토치에서는 로지스틱 회귀의 비용 함수를 이미 구현해서 제공하고 있습니다. 사용 방법은 torch.nn.functional as F와 같이 임포트 한 후에 F.binary_cross_entropy(예측값, 실제 값)과 같이 사용하면 됩니다. F.binary_cross_entropy(hypothesis, y_train) tensor(0.6931, grad_fn=<BinaryCrossEntropyBackward>) 동일하게 cost가 0.6931이 출력되는 것을 볼 수 있습니다. 모델의 훈련 과정까지 추가한 전체 코드는 아래와 같습니다. x_data = [[1, 2], [2, 3], [3, 1], [4, 3], [5, 3], [6, 2]] y_data = [[0], [0], [0], [1], [1], [1]] x_train = torch.FloatTensor(x_data) y_train = torch.FloatTensor(y_data) # 모델 초기화 W = torch.zeros((2, 1), requires_grad=True) b = torch.zeros(1, requires_grad=True) # optimizer 설정 optimizer = optim.SGD([W, b], lr=1) nb_epochs = 1000 for epoch in range(nb_epochs + 1): # Cost 계산 hypothesis = torch.sigmoid(x_train.matmul(W) + b) cost = -(y_train * torch.log(hypothesis) + (1 - y_train) * torch.log(1 - hypothesis)).mean() # cost로 H(x) 개선 optimizer.zero_grad() cost.backward() optimizer.step() # 100번마다 로그 출력 if epoch % 100 == 0: print('Epoch {:4d}/{} Cost: {:.6f}'.format( epoch, nb_epochs, cost.item() )) Epoch 0/1000 Cost: 0.693147 ... 중략 ... Epoch 1000/1000 Cost: 0.019852 학습이 끝났습니다. 이제 훈련했던 훈련 데이터를 그대로 입력으로 사용했을 때, 제대로 예측하는지 확인해 보겠습니다. 현재 W와 b는 훈련 후의 값을 가지고 있습니다. 현재 W와 b를 가지고 예측값을 출력해 보겠습니다. hypothesis = torch.sigmoid(x_train.matmul(W) + b) print(hypothesis) tensor([[2.7648e-04], [3.1608e-02], [3.8977e-02], [9.5622e-01], [9.9823e-01], [9.9969e-01]], grad_fn=<SigmoidBackward>) 현재 위 값들은 0과 1 사이의 값을 가지고 있습니다. 이제 0.5를 넘으면 True, 넘지 않으면 False로 값을 정하여 출력해 보겠습니다. prediction = hypothesis >= torch.FloatTensor([0.5]) print(prediction) tensor([[False], [False], [False], [ True], [ True], [ True]]) 실제 값은 [[0], [0], [0], [1], [1], [1]]이므로, 이는 결과적으로 False, False, False, True, True, True와 동일합니다. 즉, 기존의 실제 값과 동일하게 예측한 것을 볼 수 있습니다. 훈련이 된 후의 W와 b의 값을 출력해 보겠습니다. print(W) print(b) tensor([[3.2530], [1.5179]], requires_grad=True) tensor([-14.4819], requires_grad=True) 04-02 nn.Module로 구현하는 로지스틱 회귀 잠깐만 복습을 해보면 선형 회귀 모델의 가설식은 ( ) W + 이었습니다. 그리고 이 가설식을 구현하기 위해서 파이 토치의 nn.Linear()를 사용했습니다. 그리고 로지스틱 회귀의 가설식은 ( ) s g o d ( x b ) 입니다. 파이 토치에서는 nn.Sigmoid()를 통해서 시그모이드 함수를 구현하므로 결과적으로 nn.Linear()의 결과를 nn.Sigmoid()를 거치게 하면 로지스틱 회귀의 가설식이 됩니다. 파이 토치를 통해 이를 구현해 봅시다. 1. 파이 토치의 nn.Linear와 nn.Sigmoid로 로지스틱 회귀 구현하기 우선 구현을 위해 필요한 파이 토치의 도구들을 임포트 합니다. import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim torch.manual_seed(1) 훈련 데이터를 텐서로 선언합니다. x_data = [[1, 2], [2, 3], [3, 1], [4, 3], [5, 3], [6, 2]] y_data = [[0], [0], [0], [1], [1], [1]] x_train = torch.FloatTensor(x_data) y_train = torch.FloatTensor(y_data) nn.Sequential()은 nn.Module 층을 차례로 쌓을 수 있도록 합니다. 뒤에서 이를 이용해서 인공 신경망을 구현하게 되므로 기억하고 있으면 좋습니다. 조금 쉽게 말해서 nn.Sequential()은 x b 와 같은 수식과 시그모이드 함수 등과 같은 여러 함수들을 연결해 주는 역할을 합니다. 이를 이용해서 로지스틱 회귀를 구현해 봅시다. model = nn.Sequential( nn.Linear(2, 1), # input_dim = 2, output_dim = 1 nn.Sigmoid() # 출력은 시그모이드 함수를 거친다 ) 현재 W와 b는 랜덤 초기화가 된 상태입니다. 훈련 데이터를 넣어 예측값을 확인해 봅시다. model(x_train) tensor([[0.4020], [0.4147], [0.6556], [0.5948], [0.6788], [0.8061]], grad_fn=<SigmoidBackward>) 6 × 1 크기의 예측값 텐서가 출력됩니다. 그러나 현재 W와 b는 임의의 값을 가지므로 현재의 예측은 의미가 없습니다. 이제 경사 하강법을 사용하여 훈련해 보겠습니다. 총 100번의 에포크를 수행합니다. # optimizer 설정 optimizer = optim.SGD(model.parameters(), lr=1) nb_epochs = 1000 for epoch in range(nb_epochs + 1): # H(x) 계산 hypothesis = model(x_train) # cost 계산 cost = F.binary_cross_entropy(hypothesis, y_train) # cost로 H(x) 개선 optimizer.zero_grad() cost.backward() optimizer.step() # 20번마다 로그 출력 if epoch % 10 == 0: prediction = hypothesis >= torch.FloatTensor([0.5]) # 예측값이 0.5를 넘으면 True로 간주 correct_prediction = prediction.float() == y_train # 실제 값과 일치하는 경우만 True로 간주 accuracy = correct_prediction.sum().item() / len(correct_prediction) # 정확도를 계산 print('Epoch {:4d}/{} Cost: {:.6f} Accuracy {:2.2f}%'.format( # 각 에포크마다 정확도를 출력 epoch, nb_epochs, cost.item(), accuracy * 100, )) 각 에포크마다 정확도를 계산하여 정확도도 출력해 보겠습니다. Epoch 0/1000 Cost: 0.539713 Accuracy 83.33% ... 중략 ... Epoch 1000/1000 Cost: 0.019843 Accuracy 100.00% 중간부터 정확도는 100%가 나오기 시작합니다. 기존의 훈련 데이터를 입력하여 예측값을 확인해 보겠습니다. model(x_train) tensor([[0.0240], [0.1476], [0.2739], [0.7967], [0.9491], [0.9836]], grad_fn=<SigmoidBackward>) 0.5를 넘으면 True, 그보다 낮으면 False로 간주합니다. 실제 값은 [[0], [0], [0], [1], [1], [1]]입니다. 이는 False, False, False, True, True, True에 해당되므로 전부 실제 값과 일치하도록 예측한 것을 확인할 수 있습니다. 훈련 후의 W와 b의 값을 출력해 보겠습니다. print(list(model.parameters())) [Parameter containing: tensor([[3.2534, 1.5181]], requires_grad=True), Parameter containing: tensor([-14.4839], requires_grad=True)] 출력값이 앞 챕터에서 nn.Module을 사용하지 않고 로지스틱 회귀를 구현한 실습에서 얻었던 W와 b와 거의 일치합니다. 2. 인공 신경망으로 표현되는 로지스틱 회귀. 사실 로지스틱 회귀는 인공 신경망으로 간주할 수 있습니다. 위의 인공 신경망 그림에서 각 화살표는 입력과 곱해지는 가중치 또는 편향입니다. 각 입력에 대해서 검은색 화살표는 가중치, 회색 화살표는 편향이 곱해집니다. 각 입력 는 각 입력의 가중치 와 곱해지고, 편향 는 상수 1과 곱해지는 것으로 표현되었습니다. 그리고 출력하기 전에 시그모이드 함수를 지나게 됩니다. 결과적으로 위의 인공 신경망은 다음과 같은 다중 로지스틱 회귀를 표현하고 있습니다. ( ) s g o d ( 1 1 x w + ) 뒤에서 인공 신경망을 배우면서 언급하겠지만, 시그모이드 함수는 인공 신경망의 은닉층에서는 거의 사용되지 않습니다. 로지스틱 회귀와 소프트맥스 회귀 : https://hyeonnii.tistory.com/239 04-03 클래스로 파이 토치 모델 구현하기 파이 토치의 대부분의 구현체들은 대부분 모델을 생성할 때 클래스(Class)를 사용하고 있습니다. 앞서 배운 로지스틱 회귀를 클래스로 구현해 보겠습니다. 앞서 구현한 코드와 다른 점은 오직 클래스로 모델을 구현했다는 점입니다. 1. 모델을 클래스로 구현하기 앞서 로지스틱 회귀 모델은 다음과 같이 구현했었습니다. model = nn.Sequential( nn.Linear(2, 1), # input_dim = 2, output_dim = 1 nn.Sigmoid() # 출력은 시그모이드 함수를 거친다 ) 이를 클래스로 구현하면 다음과 같습니다. class BinaryClassifier(nn.Module): def __init__(self): super().__init__() self.linear = nn.Linear(2, 1) self.sigmoid = nn.Sigmoid() def forward(self, x): return self.sigmoid(self.linear(x)) 위와 같은 클래스를 사용한 모델 구현<NAME>은 대부분의 파이 토치 구현체에서 사용하고 있는 방식으로 반드시 숙지할 필요가 있습니다. 클래스(class) 형태의 모델은 nn.Module 을 상속받습니다. 그리고 __init__()에서 모델의 구조와 동적을 정의하는 생성자를 정의합니다. 이는 파이썬에서 객체가 갖는 속성값을 초기화하는 역할로, 객체가 생성될 때 자동으로 호출됩니다. super() 함수를 부르면 여기서 만든 클래스는 nn.Module 클래스의 속성들을 가지고 초기화됩니다. foward() 함수는 모델이 학습 데이터를 입력받아서 forward 연산을 진행시키는 함수입니다. 이 forward() 함수는 model 객체를 데이터와 함께 호출하면 자동으로 실행이 됩니다. 예를 들어 model 이란 이름의 객체를 생성 후, model(입력 데이터)와 같은<NAME>으로 객체를 호출하면 자동으로 forward 연산이 수행됩니다. ( ) 식에 입력 로부터 예측된 를 얻는 것을 forward 연산이라고 합니다. 2. 로지스틱 회귀 클래스로 구현하기 이제 모델을 클래스로 구현한 코드를 보겠습니다. 달라진 점은 모델을 클래스로 구현했다는 점뿐입니다. 다른 코드는 전부 동일합니다. import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim torch.manual_seed(1) x_data = [[1, 2], [2, 3], [3, 1], [4, 3], [5, 3], [6, 2]] y_data = [[0], [0], [0], [1], [1], [1]] x_train = torch.FloatTensor(x_data) y_train = torch.FloatTensor(y_data) class BinaryClassifier(nn.Module): def __init__(self): super().__init__() self.linear = nn.Linear(2, 1) self.sigmoid = nn.Sigmoid() def forward(self, x): return self.sigmoid(self.linear(x)) model = BinaryClassifier() # optimizer 설정 optimizer = optim.SGD(model.parameters(), lr=1) nb_epochs = 1000 for epoch in range(nb_epochs + 1): # H(x) 계산 hypothesis = model(x_train) # cost 계산 cost = F.binary_cross_entropy(hypothesis, y_train) # cost로 H(x) 개선 optimizer.zero_grad() cost.backward() optimizer.step() # 20번마다 로그 출력 if epoch % 10 == 0: prediction = hypothesis >= torch.FloatTensor([0.5]) # 예측값이 0.5를 넘으면 True로 간주 correct_prediction = prediction.float() == y_train # 실제 값과 일치하는 경우만 True로 간주 accuracy = correct_prediction.sum().item() / len(correct_prediction) # 정확도를 계산 print('Epoch {:4d}/{} Cost: {:.6f} Accuracy {:2.2f}%'.format( # 각 에포크마다 정확도를 출력 epoch, nb_epochs, cost.item(), accuracy * 100, )) 05. [ML 입문 ✏] - 소프트맥스 회귀(Softmax Regression) 이번 챕터에서는 3개 이상의 선택지로부터 1개를 선택하는 문제인 다중 클래스 분류(Multi-Class classification)를 풀기 위한 소프트맥스 회귀에 대해서 학습합니다. 05-01 원-핫 인코딩(One-Hot Encoding) 이번 챕터에서는 범주형 데이터를 처리할 때 레이블을 표현하는 방법인 원-핫 인코딩에 대해서 배워봅시다. 1. 원-핫 인코딩(One-hot encoding)이란? 원-핫 인코딩은 선택해야 하는 선택지의 개수만큼의 차원을 가지면서, 각 선택지의 인덱스에 해당하는 원소에는 1, 나머지 원소는 0의 값을 가지도록 하는 표현 방법입니다. 예를 들어 강아지, 고양이, 냉장고라는 3개의 선택지가 있다고 해보겠습니다. 원-핫 인코딩을 하기 위해서는 우선 각 선택지에 순차적으로 정수 인덱스를 부여합니다. 임의로 강아지는 0번 인덱스, 고양이는 1번 인덱스, 냉장고는 2번 인덱스를 부여하였다고 해봅시다. 이때 각 선택지에 대해서 원-핫 인코딩이 된 벡터는 다음과 같습니다. 강아지 = [1, 0, 0] 고양이 = [0, 1, 0] 냉장고 = [0, 0, 1] 총 선택지는 3개였으므로 위 벡터들은 전부 3차원의 벡터가 되었습니다. 그리고 각 선택지의 벡터들을 보면 해당 선택지의 인덱스에만 1의 값을 가지고, 나머지 원소들은 0의 값을 가집니다. 예를 들어 고양이는 1번 인덱스였으므로 원-핫 인코딩으로 얻은 벡터에서 1번 인덱스만 1의 값을 가지는 것을 볼 수 있습니다. 이와 같이 원-핫 인코딩으로 표현된 벡터를 원-핫 벡터(one-hot vector)라고 합니다. 2. 원-핫 벡터의 무작위성 꼭 실제 값을 원-핫 벡터로 표현해야만 다중 클래스 분류 문제를 풀 수 있는 것은 아니지만, 대부분의 다중 클래스 분류 문제가 각 클래스 간의 관계가 균등하다는 점에서 원-핫 벡터는 이러한 점을 표현할 수 있는 적절한 표현 방법입니다. 다수의 클래스를 분류하는 문제에서는 이진 분류처럼 2개의 숫자 레이블이 아니라 클래스의 개수만큼 숫자 레이블이 필요합니다. 이때 직관적으로 생각해 볼 수 있는 레이블링 방법은 분류해야 할 클래스 전체에 정수 인코딩을 하는 겁니다. 예를 들어서 분류해야 할 레이블이 {red, green, blue}와 같이 3개라면 각각 0, 1, 2로 레이블을 합니다. 또는 분류해야 할 클래스가 4개고 인덱스를 숫자 1부터 시작하고 싶다고 하면 {baby, child, adolescent, adult}라면 1, 2, 3, 4로 레이블을 해볼 수 있습니다. 그런데 일반적인 다중 클래스 분류 문제에서 레이블링 방법으로는 위와 같은 정수 인코딩이 아니라 원-핫 인코딩을 사용하는 것이 보다 클래스의 성질을 잘 표현하였다고 할 수 있습니다. 그 이유를 알아봅시다. Banana, Tomato, Apple라는 3개의 클래스가 존재하는 문제가 있다고 해봅시다. 레이블은 정수 인코딩을 사용하여 각각 1, 2, 3을 부여하였습니다. 손실 함수로 선형 회귀 챕터에서 배운 평균 제곱 오차 MSE를 사용하면 정수 인코딩이 어떤 오해를 불러일으킬 수 있는지 확인할 수 있습니다. 아래의 식은 앞서 선형 회귀에서 배웠던 MSE를 다시 그대로 가져온 것입니다. ^ 는 예측값을 의미합니다. o s f n t o = n i ( i y ^ ) 직관적인 오차 크기 비교를 위해 평균을 구하는 수식은 제외하고 제곱 오차로만 판단해 봅시다. 실제 값이 Tomato 일 때 예측값이 Banana이었다면 제곱 오차는 다음과 같습니다. ( − ) = 실제 값이 Apple 일 때 예측값이 Banana이었다면 제곱 오차는 다음과 같습니다. ( − ) = 즉, Banana과 Tomato 사이의 오차보다 Banana과 Apple의 오차가 더 큽니다. 이는 기계에게 Banana가 Apple보다는 Tomato에 더 가깝다는 정보를 주는 것과 다름없습니다. 더 많은 클래스에 대해서 정수 인코딩을 수행했다고 해봅시다. {Banana :1, Tomato :2, Apple :3, Strawberry :4, ... Water melon :10} 이 정수 인코딩은 Banana가 Water melon보다는 Tomato에 더 가깝다는 의미를 담고 있습니다. 이는 사용자가 부여하고자 했던 정보가 아닙니다. 이러한 정수 인코딩의 순서 정보가 도움이 되는 분류 문제도 물론 있습니다. 바로 각 클래스가 순서의 의미를 갖고 있어서 회귀를 통해서 분류 문제를 풀 수 있는 경우입니다. 예를 들어 {baby, child, adolescent, adult}나 {1층, 2층, 3층, 4층}이나 {10대, 20대, 30대, 40대}와 같은 경우가 이에 해당됩니다. 하지만 일반적인 분류 문제에서는 각 클래스는 순서의 의미를 갖고 있지 않으므로 각 클래스 간의 오차는 균등한 것이 옳습니다. 정수 인코딩과 달리 원-핫 인코딩은 분류 문제 모든 클래스 간의 관계를 균등하게 분배합니다. 아래는 세 개의 카테고리에 대해서 원-핫 인코딩을 통해서 레이블을 인코딩했을 때 각 클래스 간의 제곱 오차가 균등함을 보여줍니다. ( ( , , ) ( , , ) ) = ( − ) + ( − ) + ( − ) = ( ( , , ) ( , , ) ) = ( − ) + ( − ) + ( − ) = 다르게 표현하면 모든 클래스에 대해서 원-핫 인코딩을 통해 얻은 원-핫 벡터들은 모든 쌍에 대해서 유클리드 거리를 구해도 전부 유클리드 거리가 동일합니다. 원-핫 벡터는 이처럼 각 클래스의 표현 방법이 무작위성을 가진다는 점을 표현할 수 있습니다. 뒤에서 다시 언급되겠지만 이러한 원-핫 벡터의 관계의 무작위성은 때로는 단어의 유사성을 구할 수 없다는 단점으로 언급되기도 합니다. 05-02 소프트맥스 회귀(Softmax Regression) 이해하기 앞서 로지스틱 회귀를 통해 2개의 선택지 중에서 1개를 고르는 이진 분류(Binary Classification)를 풀어봤습니다. 이번 챕터에서는 소프트맥스 회귀를 통해 3개 이상의 선택지 중에서 1개를 고르는 다중 클래스 분류(Multi-Class Classification)를 실습해 봅시다. 1. 다중 클래스 분류(Multi-class Classification) 이진 분류가 두 개의 답 중 하나를 고르는 문제였다면, 세 개 이상의 답 중 하나를 고르는 문제를 다중 클래스 분류(Multi-class Classification)라고 합니다. 아래의 문제는 꽃받침 길이, 꽃받침 넓이, 꽃잎 길이, 꽃잎 넓이라는 4개의 특성(feature)로부터 setosa, versicolor, virginica라는 3개의 붓꽃 품종 중 어떤 품종인지를 예측하는 문제로 전형적인 다중 클래스 분류 문제입니다. SepalLengthCm( 1 ) SepalWidthCm( 2 ) PetalLengthCm( 3 ) PetalWidthCm( 4 ) Species(y) 5.1 3.5 1.4 0.2 setosa 4.9 3.0 1.4 0.2 setosa 5.8 2.6 4.0 1.2 versicolor 6.7 3.0 5.2 2.3 virginica 5.6 2.8 4.9 2.0 virginica 위 붓꽃 품종 분류하기 문제를 어떻게 풀지 고민하기 위해 앞서 배운 로지스틱 회귀의 이진 분류를 복습해 보겠습니다. 이번 챕터의 설명에서 입력은, 가중치는, 편향은, 출력은 ^ 로 각 변수는 벡터 또는 행렬로 가정합니다. ^ 은 예측값이라는 의미를 가지고 있으므로 가설식에서 ( ) 대신 사용되기도 합니다. 1. 로지스틱 회귀 로지스틱 회귀에서 시그모이드 함수는 예측값을 0과 1 사이의 값으로 만듭니다. 예를 들어 스팸 메일 분류기를 로지스틱 회귀로 구현하였을 때, 출력이 0.75이라면 이는 이메일이 스팸일 확률이 75%라는 의미가 됩니다. 반대로, 스팸 메일이 아닐 확률은 25%가 됩니다. 이 두 확률의 총합은 1입니다. 가설 : ( ) s g o d ( X B ) 2. 소프트맥스 회귀 소프트맥스 회귀는 확률의 총합이 1이 되는 이 아이디어를 다중 클래스 분류 문제에 적용합니다. 소프트맥스 회귀는 각 클래스. 즉, 각 선택지마다 소수 확률을 할당합니다. 이때 총 확률의 합은 1이 되어야 합니다. 이렇게 되면 각 선택지가 정답일 확률로 표현됩니다. 결국 소프트맥스 회귀는 선택지의 개수만큼의 차원을 가지는 벡터를 만들고, 해당 벡터가 벡터의 모든 원소의 합이 1이 되도록 원소들의 값을 변환시키는 어떤 함수를 지나게 만들어야 합니다. 위의 그림은 붓꽃 품종 분류하기 문제 등과 같이 선택지의 개수가 3개일 때, 3차원 벡터가 어떤 함수?를 지나 원소의 총합이 1이 되도록 원소들의 값이 변환되는 모습을 보여줍니다. 뒤에서 배우겠지만, 이 함수를 소프트맥스(softmax) 함수라고 합니다. 가설 : ( ) s f m x ( X B ) 2. 소프트맥스 함수(Softmax function) 소프트맥스 함수는 분류해야 하는 정답지(클래스)의 총개수를 k라고 할 때, k 차원의 벡터를 입력받아 각 클래스에 대한 확률을 추정합니다. 우선 수식에 대해 설명하고, 그 후에는 그림으로 이해해 보겠습니다. 1) 소프트맥스 함수의 이해 k 차원의 벡터에서 i 번째 원소를 i , i 번째 클래스가 정답일 확률을 i 로 나타낸다고 하였을 때 소프트맥스 함수는 i 를 다음과 같이 정의합니다. i e i j 1 e j f r i 1 2. . 위에서 풀어야 하는 문제에 소프트맥스 함수를 차근차근 적용해 봅시다. 위에서 풀어야 하는 문제의 경우 k=3이므로 3차원 벡터 = [ 1 z z ] 의 입력을 받으면 소프트맥스 함수는 아래와 같은 출력을 리턴합니다. 예측값 o t a ( ) [ z ∑ = 3 z e 2 j 1 e j e 3 j 1 e j ] [ 1 p, 3 ] p, 2 p 각각은 1번 클래스가 정답일 확률, 2번 클래스가 정답일 확률, 3번 클래스가 정답일 확률을 나타내며 각각 0과 1사이의 값으로 총합은 1이 됩니다. 여기서 분류하고자 하는 3개의 클래스는 virginica, setosa, versicolor이므로 이는 결국 주어진 입력이 virginica 일 확률, setosa 일 확률, versicolor 일 확률을 나타내는 값을 의미합니다. 여기서는 i가 1일 때는 virginica 일 확률을 나타내고, 2일 때는 setosa 일 확률, 3일 때는 versicolor 일 확률이라고 지정하였다고 합시다. 이 지정 순서는 문제를 풀고자 하는 사람의 무작위 선택입니다. 이에 따라 식을 문제에 맞게 다시 쓰면 아래와 같습니다. o t a ( ) [ z ∑ = 3 z e 2 j 1 e j e 3 j 1 e j ] [ 1 p, 3 ] 다소 복잡해 보이지만 어려운 개념이 아닙니다. 분류하고자 하는 클래스가 k 개일 때, k 차원의 벡터를 입력받아서 모든 벡터 원소의 값을 0과 1사이의 값으로 값을 변경하여 다시 k 차원의 벡터를 리턴한다는 내용을 식으로 기재하였을 뿐입니다. 방금 배운 개념을 그림을 통해 다시 설명하면서 더 깊이 들어가 보겠습니다. 2) 그림을 통한 이해 위의 그림에 점차 살을 붙여봅시다. 여기서는 샘플 데이터를 1개씩 입력으로 받아 처리한다고 가정해 봅시다. 즉, 배치 크기가 1입니다. 위의 그림에는 두 가지 질문이 있습니다. 첫 번째 질문은 소프트맥스 함수의 입력에 대한 질문입니다. 하나의 샘플 데이터는 4개의 독립 변수를 가지는데 이는 모델이 4차원 벡터를 입력으로 받음을 의미합니다. 그런데 소프트맥스의 함수의 입력으로 사용되는 벡터는 벡터의 차원이 분류하고자 하는 클래스의 개수가 되어야 하므로 어떤 가중치 연산을 통해 3차원 벡터로 변환되어야 합니다. 위의 그림에서는 소프트맥스 함수의 입력으로 사용되는 3차원 벡터를 로 표현하였습니다. 샘플 데이터 벡터를 소프트맥스 함수의 입력 벡터로 차원을 축소하는 방법은 간단합니다. 소프트맥스 함수의 입력 벡터의 차원 수만큼 결괏값의 나오도록 가중치 곱을 진행합니다. 위의 그림에서 화살표는 총 (4 × 3 = 12) 12개이며 전부 다른 가중치를 가지고, 학습 과정에서 점차적으로 오차를 최소화하는 가중치로 값이 변경됩니다. 두 번째 질문은 오차 계산 방법에 대한 질문입니다. 소프트맥스 함수의 출력은 분류하고자 하는 클래스의 개수만큼 차원을 가지는 벡터로 각 원소는 0과 1사이의 값을 가집니다. 이 각각은 특정 클래스가 정답일 확률을 나타냅니다. 여기서는 첫 번째 원소인 1 은 virginica가 정답일 확률, 두 번째 원소인 2 는 setosa가 정답일 확률, 세 번째 원소인 3 은 versicolor가 정답일 확률로 고려하고자 합니다. 그렇다면 이 예측값과 비교를 할 수 있는 실제 값의 표현 방법이 있어야 합니다. 소프트맥스 회귀에서는 실제 값을 원-핫 벡터로 표현합니다. 위의 그림은 소프트맥스 함수의 출력 벡터의 첫 번째 원소 1 가 virginica가 정답일 확률, 두 번째 원소 2 가 setosa가 정답일 확률, 세 번째 원소 3 가 versicolor가 정답일 확률을 의미한다고 하였을 때, 각 실제 값의 정수 인코딩은 1, 2, 3이 되고 이에 원-핫 인코딩을 수행하여 실제 값을 원-핫 벡터로 수치화한 것을 보여줍니다. 예를 들어 현재 풀고 있는 샘플 데이터의 실제 값이 setosa라면 setosa의 원-핫 벡터는 [0 1 0]입니다. 이 경우, 예측값과 실제 값의 오차가 0이 되는 경우는 소프트맥스 함수의 결과가 [0 1 0]이 되는 경우입니다. 이 두 벡터의 오차를 계산하기 위해서 소프트맥스 회귀는 비용 함수로 크로스 엔트로피 함수를 사용하는데, 이는 뒤에서 비용 함수를 설명하는 부분에서 다시 언급하겠습니다. 이제 앞서 배운 선형 회귀나 로지스틱 회귀와 마찬가지로 오차로부터 가중치를 업데이트합니다. 더 정확히는 선형 회귀나 로지스틱 회귀와 마찬가지로 편향 또한 업데이트의 대상이 되는 매개 변수입니다. 소프트맥스 회귀를 벡터와 행렬 연산으로 이해해 봅시다. 입력을 특성(feature)의 수만큼의 차원을 가진 입력 벡터라고 하고, 가중치 행렬을, 편향을라고 하였을 때, 소프트맥스 회귀에서 예측값을 구하는 과정을 벡터와 행렬 연산으로 표현하면 아래와 같습니다. 여기서는 특성의 수이며는 클래스의 개수에 해당됩니다. 3. 붓꽃 품종 분류하기 행렬 연산으로 이해하기 위의 붓꽃 품종 분류 문제의 가설식을 행렬 연산으로 표현해 보겠습니다. 우선 위의 예제의 데이터는 전체 샘플의 개수가 5개, 특성이 4개이므로 5 × 4 행렬로 정의합니다. = ( 5.1 3.5 1.4 0.2 4.9 3.0 1.4 0.2 5.8 2.6 4.0 1.2 6.7 3.0 5.2 2.3 5.6 2.8 4.9 2.0 ) 편의를 위해 각 행렬의 원소 위치를 반영한 변수로 표현하겠습니다. = ( 11 x 12 x 13 x 14 x 21 x 22 x 23 x 24 x 31 x 32 x 33 x 34 x 41 x 42 x 43 x 44 x 51 x 52 x 53 x 54 ) 이번 문제는 선택지가 총 3개인 문제이므로 가설의 예측값으로 얻는 행렬 ^ 의 열의 개수는 3개여야 합니다. 그리고 각 행은 행렬의 각 행의 예측값이므로 행의 크기는 동일해야 합니다. 결과적으로 행렬 ^ 의 크기는 5 × 3입니다. ^ ( 11 y 12 y 13 y 21 y 22 y 23 y 31 y 32 y 33 y 41 y 42 y 43 y 51 y 52 y 53 ) 크기 5 × 3의 행렬 ^ 는 크기 5 × 4 입력 행렬과 가중치 행렬의 곱으로 얻어지는 행렬이므로 가중치 행렬의 크기는 추정을 통해 4 × 3의 크기를 가진 행렬임을 알 수 있습니다. = ( 11 w 12 w 13 w 21 w 22 w 23 w 31 w 32 w 33 w 41 w 42 w 43 ) 편향 행렬 는 예측값 행렬 ^ 와 크기가 동일해야 하므로 5 × 3의 크기를 가집니다. = ( 1 b b b b b b b b b b b b b b) 결과적으로 가설식은 다음과 같습니다. ^ s f m x ( W B ) ( 11 y 12 y 13 y 21 y 22 y 23 y 31 y 32 y 33 y 41 y 42 y 43 y 51 y 52 y 53 ) s f m x ( ( 11 x 12 x 13 x 14 x 21 x 22 x 23 x 24 x 31 x 32 x 33 x 34 x 41 x 42 x 43 x 44 x 51 x 52 x 53 x 54 ) ( 11 w 12 w 13 w 21 w 22 w 23 w 31 w 32 w 33 w 41 w 42 w 43 4. 비용 함수(Cost function) 소프트맥스 회귀에서는 비용 함수로 크로스 엔트로피 함수를 사용합니다. 여기서는 소프트맥스 회귀에서의 크로스 엔트로피 함수뿐만 아니라, 다양한 표기 방법에 대해서 이해해 보겠습니다. 1) 크로스 엔트로피 함수 아래에서는 실제 값을 나타내며,는 클래스의 개수로 정의합니다. j 는 실제 값 원-핫 벡터의 번째 인덱스를 의미하며, j 는 샘플 데이터가 번째 클래스일 확률을 나타냅니다. 표기에 따라서 ^로 표현하기도 합니다. o t ( ) − j 1 y l g ( j ) 이 함수가 왜 비용 함수로 적합한지 알아보겠습니다. 가 실제 값 원-핫 벡터에서 1을 가진 원소의 인덱스라고 한다면, c 1 y 가를 정확하게 예측한 경우가 됩니다. 이를 식에 대입해 보면 1 o ( ) 0 이 되기 때문에, 결과적으로 ^ y 를 정확하게 예측한 경우의 크로스 엔트로피 함수의 값은 0이 됩니다. 즉, ∑ = k j l g ( j ) 이 값을 최소화하는 방향으로 학습해야 합니다. 이제 이를 개의 전체 데이터에 대한 평균을 구한다고 하면 최종 비용 함수는 다음과 같습니다. o t ( ) − n i 1 ∑ = k j ( ) l g ( j ( ) ) 2) 이진 분류에서의 크로스 엔트로피 함수 로지스틱 회귀에서 배운 크로스 엔트로피 함수식과 달라 보이지만, 본질적으로는 동일한 함수식입니다. 로지스틱 회귀의 크로스 엔트로피 함수식으로부터 소프트맥스 회귀의 크로스 엔트로피 함수식을 도출해 봅시다. o t ( ) − ( l g ( ) ( − ) l g ( − ( ) ) ) 위의 식은 앞서 로지스틱 회귀에서 배웠던 크로스 엔트로피의 함수식을 보여줍니다. 위의 식에서 를 1 1 y y로 치환하고 ( ) p, − ( ) p로 치환해 봅시다. 결과적으로 아래의 식을 얻을 수 있습니다. ( 1 l g ( 1 ) y l g ( 2 ) ) 이 식은 아래와 같이 표현할 수 있습니다. ( i 1 y l g p) 소프트맥스 회귀에서는 k의 값이 고정된 값이 아니므로 2를 k로 변경합니다. ( i 1 y l g p) 위의 식은 결과적으로 소프트맥스 회귀의 식과 동일합니다. 역으로 소프트맥스 회귀에서 로지스틱 회귀의 크로스 엔트로피 함수식을 얻는 것은 k를 2로 하고, 1 y를 각각 와 −로 치환하고, 1 p를 각각 ( ) 1 H ( ) 로 치환하면 됩니다. 정리하면 소프트맥스 함수의 최종 비용 함수에서 가 2라고 가정하면 결국 로지스틱 회귀의 비용 함수와 같습니다. o t ( ) − n i 1 ∑ = k j ( ) l g ( j ( ) ) − n i 1 [ ( ) o ( ( ) ) ( 유튜브 강의(한국어 자막 키고 보세요) : https://www.youtube.com/watch? v=LLux1SW--oM https://blog-st.tistory.com/entry/Softmax-Classification-with-Pytorch? category=678300 05-03 소프트맥스 회귀의 비용 함수 구현하기 이번 챕터에서는 소프트맥스 회귀의 비용 함수를 구현해 봅시다. 앞으로의 모든 실습은 아래의 코드가 이미 진행되었다고 가정합니다. import torch import torch.nn.functional as F torch.manual_seed(1) 1. 파이 토치로 소프트맥스의 비용 함수 구현하기 (로우-레벨) 소프트맥스 회귀를 구현함에 있어 우선 소프트맥스 함수의 비용 함수를 로우-레벨로 구현해 봅시다. 3개의 원소를 가진 벡터 텐서를 정의하고, 이 텐서를 통해 소프트맥스 함수를 이해해 보겠습니다. z = torch.FloatTensor([1, 2, 3]) 이 텐서를 소프트맥스 함수의 입력으로 사용하고, 그 결과를 확인해 보겠습니다. hypothesis = F.softmax(z, dim=0) print(hypothesis) tensor([0.0900, 0.2447, 0.6652]) 3개의 원소의 값이 0과 1사이의 값을 가지는 벡터로 변환된 것을 볼 수 있습니다. 이 원소들의 값의 합이 1인지 확인해 보겠습니다. hypothesis.sum() tensor(1.) 총 원소의 값의 합은 1입니다. 이번에는 비용 함수를 직접 구현해 보겠습니다. 우선 임의의 3 × 5 행렬의 크기를 가진 텐서를 만듭니다. z = torch.rand(3, 5, requires_grad=True) 이제 이 텐서에 대해서 소프트맥스 함수를 적용합니다. 단, 각 샘플에 대해서 소프트맥스 함수를 적용하여야 하므로 두 번째 차원에 대해서 소프트맥스 함수를 적용한다는 의미에서 dim=1을 써줍니다. hypothesis = F.softmax(z, dim=1) print(hypothesis) tensor([[0.2645, 0.1639, 0.1855, 0.2585, 0.1277], [0.2430, 0.1624, 0.2322, 0.1930, 0.1694], [0.2226, 0.1986, 0.2326, 0.1594, 0.1868]], grad_fn=<SoftmaxBackward>) 이제 각 행의 원소들의 합은 1이 되는 텐서로 변환되었습니다. 소프트맥스 함수의 출력값은 결국 예측값입니다. 즉, 위 텐서는 3개의 샘플에 대해서 5개의 클래스 중 어떤 클래스가 정답인지를 예측한 결과입니다. 이제 각 샘플에 대해서 임의의 레이블을 만듭니다. y = torch.randint(5, (3, )).long() print(y) tensor([0, 2, 1]) 이제 각 레이블에 대해서 원-핫 인코딩을 수행합니다. # 모든 원소가 0의 값을 가진 3 × 5 텐서 생성 y_one_hot = torch.zeros_like(hypothesis) y_one_hot.scatter_(1, y.unsqueeze(1), 1) tensor([[1., 0., 0., 0., 0.], [0., 0., 1., 0., 0.], [0., 1., 0., 0., 0.]]) 위의 연산에서 어떻게 원-핫 인코딩이 수행되었는지 보겠습니다. 우선, torch.zeros_like(hypothesis)를 통해 모든 원소가 0의 값을 가진 3 × 5 텐서를 만듭니다. 그리고 이 텐서는 y_one_hot에 저장이 된 상태입니다. 두 번째 줄을 해석해 봅시다. y.unsqueeze(1)를 하면 (3, )의 크기를 가졌던 y 텐서는 (3 × 1) 텐서가 됩니다. 즉, 다시 말해서 y.unsqueeze(1)의 결과는 아래와 같습니다. print(y.unsqueeze(1)) tensor([[0], [2], [1]]) 그리고 scatter의 첫 번째 인자로 dim=1에 대해서 수행하라고 알려주고, 세 번째 인자에 숫자 1을 넣어주므로서 두 번째 인자인 y_unsqeeze(1)이 알려주는 위치에 숫자 1을 넣도록 합니다. 앞서 텐서 조작하기 2챕터에서 연산 뒤에 _를 붙이면 In-place Operation (덮어쓰기 연산) 임을 배운 바 있습니다. 이에 따라서 y_one_hot의 최종 결과는 결국 아래와 같습니다. print(y_one_hot) tensor([[1., 0., 0., 0., 0.], [0., 0., 1., 0., 0.], [0., 1., 0., 0., 0.]]) 이제 비용 함수 연산을 위한 재료들을 전부 손질했습니다. 소프트맥스 회귀의 비용 함수는 다음과 같았습니다. o t ( ) − n i 1 ∑ = k j ( ) l g ( j ( ) ) 마이너스 부호를 뒤로 빼면 다음 식과도 동일합니다. o t ( ) 1 ∑ = n j 1 y ( ) × ( l g ( j ( ) ) ) 이를 코드로 구현하면 아래와 같습니다. j 1 은 sum(dim=1)으로 구현하고, n i 1 은 mean()으로 구현합니다. cost = (y_one_hot * -torch.log(hypothesis)).sum(dim=1).mean() print(cost) tensor(1.4689, grad_fn=<MeanBackward1>) 2. 파이 토치로 소프트맥스의 비용 함수 구현하기 (하이-레벨) 이제 소프트맥스의 비용 함수를 좀 더 하이-레벨로 구현하는 방법에 대해서 알아봅시다. 1. F.softmax() + torch.log() = F.log_softmax() 앞서 소프트맥스 함수의 결과에 로그를 씌울 때는 다음과 같이 소프트맥스 함수의 출력값을 로그 함수의 입력으로 사용했습니다. # Low level torch.log(F.softmax(z, dim=1)) tensor([[-1.3301, -1.8084, -1.6846, -1.3530, -2.0584], [-1.4147, -1.8174, -1.4602, -1.6450, -1.7758], [-1.5025, -1.6165, -1.4586, -1.8360, -1.6776]], grad_fn=<LogBackward>) 그런데 파이 토치에서는 두 개의 함수를 결합한 F.log_softmax()라는 도구를 제공합니다. # High level F.log_softmax(z, dim=1) tensor([[-1.3301, -1.8084, -1.6846, -1.3530, -2.0584], [-1.4147, -1.8174, -1.4602, -1.6450, -1.7758], [-1.5025, -1.6165, -1.4586, -1.8360, -1.6776]], grad_fn=<LogSoftmaxBackward>) 두 출력 결과가 동일한 것을 볼 수 있습니다. 이제 비용 함수를 보겠습니다. 2. F.log_softmax() + F.nll_loss() = F.cross_entropy() 앞서 로우-레벨로 구현한 비용 함수는 다음과 같았습니다. # Low level # 첫 번째 수식 (y_one_hot * -torch.log(F.softmax(z, dim=1))).sum(dim=1).mean() tensor(1.4689, grad_fn=<MeanBackward1>) 그런데 위의 수식에서 torch.log(F.softmax(z, dim=1))를 방금 배운 F.log_softmax()로 대체할 수 있습니다. # 두 번째 수식 (y_one_hot * - F.log_softmax(z, dim=1)).sum(dim=1).mean() tensor(1.4689, grad_fn=<MeanBackward0>) 이를 더 간단하게 하면 다음과 같습니다. F.nll_loss()를 사용할 때는 원-핫 벡터를 넣을 필요 없이 바로 실제 값을 인자로 사용합니다. # High level # 세 번째 수식 F.nll_loss(F.log_softmax(z, dim=1), y) tensor(1.4689, grad_fn=<NllLossBackward>) 여기서 nll 이란 Negative Log Likelihood의 약자입니다. 위에서 nll_loss는 F.log_softmax()를 수행한 후에 남은 수식들을 수행합니다. 이를 더 간단하게 하면 다음과 같이 사용할 수 있습니다. F.cross_entropy()는 F.log_softmax()와 F.nll_loss()를 포함하고 있습니다. # 네 번째 수식 F.cross_entropy(z, y) tensor(1.4689, grad_fn=<NllLossBackward>) F.cross_entropy는 비용 함수에 소프트맥스 함수까지 포함하고 있음을 기억하고 있어야 구현 시 혼동하지 않습니다. 05-04 소프트맥스 회귀 구현하기 이번 챕터에서는 소프트맥스 회귀를 로우-레벨과 F.cross_entropy를 사용해서 구현해 보겠습니다. 앞으로의 모든 실습은 아래의 과정이 이미 진행되었다고 가정합니다. 필요한 도구들을 임포트 합니다. import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim torch.manual_seed(1) 훈련 데이터와 레이블을 텐서로 선언합니다. x_train = [[1, 2, 1, 1], [2, 1, 3, 2], [3, 1, 3, 4], [4, 1, 5, 5], [1, 7, 5, 5], [1, 2, 5, 6], [1, 6, 6, 6], [1, 7, 7, 7]] y_train = [2, 2, 2, 1, 1, 1, 0, 0] x_train = torch.FloatTensor(x_train) y_train = torch.LongTensor(y_train) x_train의 각 샘플은 4개의 특성을 가지고 있으며, 총 8개의 샘플이 존재합니다. y_train은 각 샘플에 대한 레이블인데, 여기서는 0, 1, 2의 값을 가지는 것으로 보아 총 3개의 클래스가 존재합니다. 1. 소프트맥스 회귀 구현하기(로우-레벨) 이제 x_train의 크기와 y_train의 크기를 확인합니다. print(x_train.shape) print(y_train.shape) torch.Size([8, 4]) torch.Size([8]) x_train의 크기는 8 × 4이며, y_train의 크기는 8 × 1입니다. 그런데 최종 사용할 레이블은 y_train에서 원-핫 인코딩을 한 결과이어야 합니다. 클래스의 개수는 3개이므로 y_train에 원-핫 인코딩한 결과는 8 × 3의 개수를 가져야 합니다. y_one_hot = torch.zeros(8, 3) y_one_hot.scatter_(1, y_train.unsqueeze(1), 1) print(y_one_hot.shape) torch.Size([8, 3]) y_train에서 원-핫 인코딩을 한 결과인 y_one_hot의 크기는 8 × 3입니다. 즉, W 행렬의 크기는 4 × 3이어야 합니다. W와 b를 선언하고, 옵티마이저로는 경사 하강법을 사용합니다. 그리고 학습률은 0.1로 설정합니다. # 모델 초기화 W = torch.zeros((4, 3), requires_grad=True) b = torch.zeros((1, 3), requires_grad=True) # optimizer 설정 optimizer = optim.SGD([W, b], lr=0.1) F.softmax()와 torch.log()를 사용하여 가설과 비용 함수를 정의하고, 총 1,000번의 에포크를 수행합니다. nb_epochs = 1000 for epoch in range(nb_epochs + 1): # 가설 hypothesis = F.softmax(x_train.matmul(W) + b, dim=1) # 비용 함수 cost = (y_one_hot * -torch.log(hypothesis)).sum(dim=1).mean() # cost로 H(x) 개선 optimizer.zero_grad() cost.backward() optimizer.step() # 100번마다 로그 출력 if epoch % 100 == 0: print('Epoch {:4d}/{} Cost: {:.6f}'.format( epoch, nb_epochs, cost.item() )) 2. 소프트맥스 회귀 구현하기(하이-레벨) 이제는 F.cross_entropy()를 사용하여 비용 함수를 구현해 보겠습니다. 주의할 점은 F.cross_entropy()는 그 자체로 소프트맥스 함수를 포함하고 있으므로 가설에서는 소프트맥스 함수를 사용할 필요가 없습니다. 위와 동일한 x_train과 y_train을 사용합니다. # 모델 초기화 W = torch.zeros((4, 3), requires_grad=True) b = torch.zeros((1, 3), requires_grad=True) # optimizer 설정 optimizer = optim.SGD([W, b], lr=0.1) nb_epochs = 1000 for epoch in range(nb_epochs + 1): # Cost 계산 z = x_train.matmul(W) + b cost = F.cross_entropy(z, y_train) # cost로 H(x) 개선 optimizer.zero_grad() cost.backward() optimizer.step() # 100번마다 로그 출력 if epoch % 100 == 0: print('Epoch {:4d}/{} Cost: {:.6f}'.format( epoch, nb_epochs, cost.item() )) 3. 소프트맥스 회귀 nn.Module로 구현하기 이번에는 nn.Module로 소프트맥스 회귀를 구현해 봅시다. 선형 회귀에서 구현에 사용했던 nn.Linear()를 사용합니다. output_dim이 1이었던 선형 회귀 때와 달리 output_dim은 이제 클래스의 개수여야 합니다. # 모델을 선언 및 초기화. 4개의 특성을 가지고 3개의 클래스로 분류. input_dim=4, output_dim=3. model = nn.Linear(4, 3) 아래에서 F.cross_entropy()를 사용할 것이므로 따로 소프트맥스 함수를 가설에 정의하지 않습니다. # optimizer 설정 optimizer = optim.SGD(model.parameters(), lr=0.1) nb_epochs = 1000 for epoch in range(nb_epochs + 1): # H(x) 계산 prediction = model(x_train) # cost 계산 cost = F.cross_entropy(prediction, y_train) # cost로 H(x) 개선 optimizer.zero_grad() cost.backward() optimizer.step() # 20번마다 로그 출력 if epoch % 100 == 0: print('Epoch {:4d}/{} Cost: {:.6f}'.format( epoch, nb_epochs, cost.item() )) 4. 소프트맥스 회귀 클래스로 구현하기 이제 소프트맥스 회귀를 nn.Module을 상속받은 클래스로 구현해 봅시다. class SoftmaxClassifierModel(nn.Module): def __init__(self): super().__init__() self.linear = nn.Linear(4, 3) # Output이 3! def forward(self, x): return self.linear(x) model = SoftmaxClassifierModel() # optimizer 설정 optimizer = optim.SGD(model.parameters(), lr=0.1) nb_epochs = 1000 for epoch in range(nb_epochs + 1): # H(x) 계산 prediction = model(x_train) # cost 계산 cost = F.cross_entropy(prediction, y_train) # cost로 H(x) 개선 optimizer.zero_grad() cost.backward() optimizer.step() # 20번마다 로그 출력 if epoch % 100 == 0: print('Epoch {:4d}/{} Cost: {:.6f}'.format( epoch, nb_epochs, cost.item() )) 소프트맥스 회귀의 레이블은 왜 원-핫 인코딩으로 사용하지 않는가? https://stackoverflow.com/questions/55549843/pytorch-doesnt-support-one-hot-vector 05-05 소프트맥스 회귀로 MNIST 데이터 분류하기 이번 챕터에서는 MNIST 데이터에 대해서 이해하고, 파이 토치(PyTorch)로 소프트맥스 회귀를 구현하여 MNIST 데이터를 분류하는 실습을 진행해 봅시다. MNIST 데이터는 아래의 링크에 공개돼 있습니다. 링크 : http://yann.lecun.com/exdb/mnist 1. MNIST 데이터 이해하기 MNIST는 숫자 0부터 9까지의 이미지로 구성된 손글씨 데이터 셋입니다. 이 데이터는 과거에 우체국에서 편지의 우편 번호를 인식하기 위해서 만들어진 훈련 데이터입니다. 총 60,000개의 훈련 데이터와 레이블, 총 10,000개의 테스트 데이터와 레이블로 구성돼 있습니다. 레이블은 0부터 9까지 총 10개입니다. 이 예제는 머신 러닝을 처음 배울 때 접하게 되는 가장 기본적인 예제이기도 합니다. MNIST 문제는 손글씨로 적힌 숫자 이미지가 들어오면, 그 이미지가 무슨 숫자인지 맞추는 문제입니다. 예를 들어 숫자 5의 이미지가 입력으로 들어오면 이게 숫자 5다!라는 것을 맞춰야 합니다. 이 문제는 사람에게는 굉장히 간단하지만 기계에게는 그렇지가 않습니다. 우선 MNIST 문제를 더 자세히 보겠습니다. 각각의 이미지는 아래와 같이 28 픽셀 × 28 픽셀의 이미지입니다. 이 문제를 풀기 위해 여기서는 28 픽셀 × 28 픽셀 = 784 픽셀이므로, 각 이미지를 총 784의 원소를 가진 벡터로 만들어줄 겁니다. 이렇게 되면 총 784개의 특성을 가진 샘플이 되는데, 이는 앞서 우리가 풀었던 그 어떤 문제들보다 특성이 굉장히 많은 샘플입니다. 784차원의 벡터로 만드는 코드를 미리 보기로 보면 아래와 같습니다. for X, Y in data_loader: # 입력 이미지를 [batch_size × 784]의 크기로 reshape # 레이블은 원-핫 인코딩 X = X.view(-1, 28*28) 위의 코드에서 X는 for 문에서 호출될 때는 (배치 크기 × 1 × 28 × 28)의 크기를 가지지만, view를 통해서 (배치 크기 × 784)의 크기로 변환됩니다. 2. 토치 비전(torchvision) 소개하기 본격적인 실습에 들어가기에 앞서 토치 비전(torchvision)이라는 도구를 설명하겠습니다. torchvision은 유명한 데이터 셋들, 이미 구현돼 있는 유명한 모델들, 일반적인 이미지 전처리 도구들을 포함하고 있는 패키지입니다. 아래의 링크는 torchvision에 어떤 데이터 셋들(datasets)과 모델들(models) 그리고 어떤 전처리 방법들(transforms)을 제공하고 있는지 보여줍니다. 링크 : https://pytorch.org/docs/stable/torchvision/index.html 자연어 처리를 위해서는 토치 텍스트(torchtext)라는 패키지가 있습니다. 3. 분류기 구현을 위한 사전 설정 우선 필요한 도구들을 임포트 합니다. import torch import torchvision.datasets as dsets import torchvision.transforms as transforms from torch.utils.data import DataLoader import torch.nn as nn import matplotlib.pyplot as plt import random 현재 환경에서 GPU 연산이 가능하다면 GPU 연산을 하고, 그렇지 않다면 CPU 연산을 하도록 합니다. USE_CUDA = torch.cuda.is_available() # GPU를 사용 가능하면 True, 아니라면 False를 리턴 device = torch.device("cuda" if USE_CUDA else "cpu") # GPU 사용 가능하면 사용하고 아니면 CPU 사용 print("다음 기기로 학습합니다:", device) 구글의 Colab에서 '런타임 > 런타임 유형 변경 > 하드웨어 가속기 > GPU'를 선택하면 USE_CUDA의 값이 True가 되면서 '다음 기기로 학습합니다: cuda'라는 출력이 나옵니다. 즉, GPU로 연산하겠다는 의미입니다. 반면에 '하드웨어 가속기 > None'을 선택하면 USE_CUDA의 값이 False가 되면서 '다음 기기로 학습합니다: cpu'라는 출력이 나옵니다. 즉, CPU로 연산하겠다는 의미입니다. 위의 방법은 앞으로 자주 쓰이게 되므로 기억해둡시다. 랜덤 시드를 고정합니다. # for reproducibility random.seed(777) torch.manual_seed(777) if device == 'cuda': torch.cuda.manual_seed_all(777) 하이퍼 파라미터를 변수로 둡니다. # hyperparameters training_epochs = 15 batch_size = 100 4. MNIST 분류기 구현하기 torchvision.datasets.dsets.MNIST를 사용하여 MNIST 데이터 셋을 불러올 수 있습니다. # MNIST dataset mnist_train = dsets.MNIST(root='MNIST_data/', train=True, transform=transforms.ToTensor(), download=True) mnist_test = dsets.MNIST(root='MNIST_data/', train=False, transform=transforms.ToTensor(), download=True) 첫 번째 인자 root는 MNIST 데이터를 다운로드할 경로입니다. 두 번째 인자 train은 인자로 True를 주면, MNIST의 훈련 데이터를 리턴 받으며 False를 주면 테스트 데이터를 리턴 받습니다. 세 번째 인자 transform은 현재 데이터를 파이 토치 텐서로 변환해 줍니다. 네 번째 인자 download는 해당 경로에 MNIST 데이터가 없다면 다운로드하겠다는 의미입니다. 이렇게 데이터를 다운로드했다면 앞서 미니 배치와 데이터 로드 챕터에서 학습했던 데이터 로더(DataLoader)를 사용합니다. # dataset loader data_loader = DataLoader(dataset=mnist_train, batch_size=batch_size, # 배치 크기는 100 shuffle=True, drop_last=True) 이때 DataLoader에는 4개의 인자가 있습니다. 첫 번째 인자인 dataset은 로드할 대상을 의미하며, 두 번째 인자인 batch_size는 배치 크기, shuffle은 매 에포크마다 미니 배치를 셔플 할 것인지의 여부, drop_last는 마지막 배치를 버릴 것인지를 의미합니다. drop_last를 하는 이유를 이해하기 위해서 1,000개의 데이터가 있다고 했을 때, 배치 크기가 128이라고 해봅시다. 1,000을 128로 나누면 총 7개가 나오고 나머지로 104개가 남습니다. 이때 104개를 마지막 배치로 한다고 하였을 때 128개를 충족하지 못하였으므로 104개를 그냥 버릴 수도 있습니다. 이때 마지막 배치를 버리려면 drop_last=True를 해주면 됩니다. 이는 다른 미니 배치보다 개수가 적은 마지막 배치를 경사 하강법에 사용하여 마지막 배치가 상대적으로 과대평가되는 현상을 막아줍니다. 이제 모델을 설계합니다. input_dim은 784이고, output_dim은 10입니다. # MNIST data image of shape 28 * 28 = 784 linear = nn.Linear(784, 10, bias=True).to(device) to() 함수는 연산을 어디서 수행할지를 정합니다. to() 함수는 모델의 매개변수를 지정한 장치의 메모리로 보냅니다. CPU를 사용할 경우에는 필요가 없지만, GPU를 사용하려면 to('cuda')를 해 줄 필요가 있습니다. 아무것도 지정하지 않은 경우에는 CPU 연산이라고 보면 됩니다. bias는 편향 b를 사용할 것인지를 나타냅니다. 기본값은 True이므로 굳이 할 필요는 없지만 명시적으로 True를 해주었습니다. 이제 비용 함수와 옵티마이저를 정의합니다. # 비용 함수와 옵티마이저 정의 criterion = nn.CrossEntropyLoss().to(device) # 내부적으로 소프트맥스 함수를 포함하고 있음. optimizer = torch.optim.SGD(linear.parameters(), lr=0.1) 앞서 소프트맥스 회귀를 배울 때는 torch.nn.functional.cross_entropy()를 사용하였으나 여기서는 torch.nn.CrossEntropyLoss()을 사용하고 있습니다. 둘 다 파이 토치에서 제공하는 크로스 엔트로피 함수로 둘 다 소프트맥스 함수를 포함하고 있습니다. for epoch in range(training_epochs): # 앞서 training_epochs의 값은 15로 지정함. avg_cost = 0 total_batch = len(data_loader) for X, Y in data_loader: # 배치 크기가 100이므로 아래의 연산에서 X는 (100, 784)의 텐서가 된다. X = X.view(-1, 28 * 28).to(device) # 레이블은 원-핫 인코딩이 된 상태가 아니라 0 ~ 9의 정수. Y = Y.to(device) optimizer.zero_grad() hypothesis = linear(X) cost = criterion(hypothesis, Y) cost.backward() optimizer.step() avg_cost += cost / total_batch print('Epoch:', '% 04d' % (epoch + 1), 'cost =', '{:.9f}'.format(avg_cost)) print('Learning finished') Epoch: 0001 cost = 0.535468459 Epoch: 0002 cost = 0.359274209 Epoch: 0003 cost = 0.331187516 Epoch: 0004 cost = 0.316578060 Epoch: 0005 cost = 0.307158142 Epoch: 0006 cost = 0.300180763 Epoch: 0007 cost = 0.295130193 Epoch: 0008 cost = 0.290851474 Epoch: 0009 cost = 0.287417054 Epoch: 0010 cost = 0.284379572 Epoch: 0011 cost = 0.281825274 Epoch: 0012 cost = 0.279800713 Epoch: 0013 cost = 0.277808994 Epoch: 0014 cost = 0.276154339 Epoch: 0015 cost = 0.274440885 Learning finished # 테스트 데이터를 사용하여 모델을 테스트한다. with torch.no_grad(): # torch.no_grad()를 하면 gradient 계산을 수행하지 않는다. X_test = mnist_test.test_data.view(-1, 28 * 28).float().to(device) Y_test = mnist_test.test_labels.to(device) prediction = linear(X_test) correct_prediction = torch.argmax(prediction, 1) == Y_test accuracy = correct_prediction.float().mean() print('Accuracy:', accuracy.item()) # MNIST 테스트 데이터에서 무작위로 하나를 뽑아서 예측을 해본다 r = random.randint(0, len(mnist_test) - 1) X_single_data = mnist_test.test_data[r:r + 1].view(-1, 28 * 28).float().to(device) Y_single_data = mnist_test.test_labels[r:r + 1].to(device) print('Label: ', Y_single_data.item()) single_prediction = linear(X_single_data) print('Prediction: ', torch.argmax(single_prediction, 1).item()) plt.imshow(mnist_test.test_data[r:r + 1].view(28, 28), cmap='Greys', interpolation='nearest') plt.show() 참고 자료 : https://excelsior-cjh.tistory.com/180 torch.nn.functional과 torch.nn의 차이 : https://discuss.pytorch.org/t/what-is-the-difference-between-torch-nn-and-torch-nn-functional/33597 06. [DL 입문 ] - 인공 신경망(Aritificial Neural Network) 이번 챕터에서는 인공 신경망에 대한 전반적인 개념을 이해합니다. 06-01 머신 러닝 용어 이해하기 이번 챕터에서는 머신 러닝의 특징들에 대해서 배웁니다. 딥 러닝 또한 머신 러닝에 속하므로, 아래의 머신 러닝의 특징들은 모두 딥 러닝의 특징이기도 합니다. 1. 머신 러닝 모델의 평가 실제 모델을 평가하기 위해서 데이터를 훈련용, 검증용, 테스트용 이렇게 세 가지로 분리하는 것이 일반적입니다. 다만, 이 책의 목적은 개념 학습이므로 일부 실습에서는 별도로 세 가지로 분리하지 않고 훈련용, 테스트용으로만 분리해서 사용합니다. 그렇다면 훈련용, 테스트용 두 가지로만 나눠서 테스트 데이터로 한 번만 테스트하면 더 편할 텐데 굳이 왜 검증용 데이터를 만들어 놓는 것일까요? 검증용 데이터는 모델의 성능을 평가하기 위한 용도가 아니라, 모델의 성능을 조정하기 위한 용도입니다. 더 정확히는 과적합이 되고 있는지 판단하거나 하이퍼 파라미터의 조정을 위한 용도입니다. 하이퍼 파라미터(초 매개변수)란 값에 따라서 모델의 성능에 영향을 주는 매개변수들을 말합니다. 반면, 가중치와 편향과 같은 학습을 통해 바뀌어가는 변수를 이 책에서는 매개변수라고 부릅니다. 이 두 값 하이퍼 파라미터와 매개변수의 가장 큰 차이는 하이퍼 파라미터는 보통 사용자가 직접 정해줄 수 있는 변수라는 점입니다. 선형 회귀 챕터에서 배우게 되는 경사 하강법에서 학습률(learning rate)이 이에 해당되며 딥 러닝에서는 은닉층의 수, 뉴런의 수, 드롭아웃 비율 등이 이에 해당됩니다. 반면 매개변수는 사용자가 결정해 주는 값이 아니라 모델이 학습하는 과정에서 얻어지는 값입니다. 정리하면 하이퍼 파라미터는 사람이 정하는 변수인 반면, 매개변수는 기계가 훈련을 통해서 바꾸는 변수라고 할 수 있으며 이 책에서는 이와 같은 기준으로 변수의 이름을 명명합니다. 훈련용 데이터로 훈련을 모두 시킨 모델은 검증용 데이터를 사용하여 정확도를 검증하며 하이퍼 파라미터를 튜닝(tuning) 합니다. 또한 이 모델의 매개변수는 검증용 데이터로 정확도가 검증되는 과정에서 점차 검증용 데이터에 점점 맞추어져 가기 시작합니다. 하이퍼 파라미터 튜닝이 끝났다면, 이제 검증용 데이터로 모델을 평가하는 것은 적합하지 않습니다. 이제 모델은 검증용 데이터에 대해서도 일정 부분 최적화가 되어있기 때문입니다. 모델에 대한 평가는 모델이 아직까지 보지 못한 데이터로 하는 것이 가장 바람직합니다. 검증이 끝났다면 테스트 데이터를 가지고 모델의 진짜 성능을 평가합니다. 비유하자면 훈련 데이터는 문제지, 검증 데이터는 모의고사, 테스트 데이터는 실력을 최종적으로 평가하는 수능 시험이라고 볼 수 있습니다. 만약, 검증 데이터와 테스트 데이터를 나눌 만큼 데이터가 충분하지 않다면 k-폴드 교차 검증이라는 또 다른 방법을 사용하기도 합니다. 2. 분류(Classification)와 회귀(Regression) 전부라고는 할 수 없지만, 머신 러닝의 많은 문제는 분류 또는 회귀 문제에 속합니다. 이 책에서는 앞서 머신 러닝 기법 중 선형 회귀(Lineare Regression)과 로지스틱 회귀(Logistic Rgression)를 다루는데 선형 회귀를 통해 회귀 문제에 대해서 학습하고, 로지스틱 회귀를 통해 (이름은 회귀이지만) 분류 문제를 학습합니다. 분류는 또한 이진 분류(Binary Classification)과 다중 클래스 분류(Multi-Class Classification)로 나뉩니다. 엄밀히는 다중 레이블 분류(Multi-lable Classification)라는 또 다른 문제가 존재하지만, 이 책에서는 이진 분류와 다중 클래스 분류만 다룹니다. 1) 이진 분류 문제(Binary Classification) 이진 분류는 주어진 입력에 대해서 둘 중 하나의 답을 정하는 문제입니다. 시험 성적에 대해서 합격, 불합격인지 판단하고 메일로부터 정상 메일, 스팸 메일인지를 판단하는 문제 등이 이에 속합니다. 2) 다중 클래스 분류(Multi-class Classification) 다중 클래스 분류는 주어진 입력에 대해서 세 개 이상의 정해진 선택지 중에서 답을 정하는 문제입니다. 예를 들어 서점 아르바이트를 하는데 과학, 영어, IT, 학습지, 만화라는 레이블이 각각 붙여져 있는 5개의 책장이 있다고 합시다. 새 책이 입고되면, 이 책은 다섯 개의 책장 중에서 분야에 맞는 적절한 책장에 책을 넣어야 합니다. 이때의 다섯 개의 선택지를 주로 카테고리 또는 범주 또는 클래스라고 하며, 주어진 입력으로부터 정해진 클래스 중 하나로 판단하는 것을 다중 클래스 분류 문제라고 합니다. 3) 회귀 문제(Regression) 회귀 문제는 분류 문제처럼 0 또는 1이나 과학 책장, IT 책장 등과 같이 분리된(비연속적인) 답이 결과가 아니라 연속된 값을 결과로 가집니다. 예를 들어 시험 성적을 예측하는데 5시간 공부하였을 때 80점, 5시간 1분 공부하였을 때는 80.5점, 7시간 공부하였을 때는 90점 등이 나오는 것과 같은 문제가 있습니다. 그 외에도 시계열 데이터를 이용한 주가 예측, 생산량 예측,<NAME> 예측 등이 이에 속합니다. 3. 지도 학습(Supervised Learning)과 비지도 학습(Unsupervised Learning) 머신 러닝은 크게 지도 학습, 비지도 학습, 강화 학습으로 나눕니다. 하지만 강화 학습은 이 책의 범위를 벗어나므로 설명하지 않습니다. 또한 이 책은 주로 지도 학습에 대해서 다룹니다. 1) 지도 학습 지도 학습이란 레이블(Label)이라는 정답과 함께 학습하는 것을 말합니다. 이는 앞서 2챕터의 데이터의 분리 챕터에서 상세히 설명한 바 있습니다. 레이블이라는 말 외에도, 실제 값 등으로 부르기도 하는데 이 책에서는 이 용어들을 상황에 따라서 바꿔서 사용합니다. 이때 기계는 예측값과 실제 값의 차이인 오차를 줄이는 방식으로 학습을 하게 되는데 예측값은 ^ 과같이 표현하기도 합니다. 2) 비지도 학습 비지도 학습은 기본적으로 목적 데이터(또는 레이블)이 없는 학습 방법입니다. 대표적으로 군집(clustering)이나 차원 축소와 같은 학습 방법들을 비지도 학습이라고 합니다. 3) 강화 학습 강화 학습은 이 책에서는 다루지 않는 내용입니다. 강화 학습은 어떤 환경 내에서 정의된 에이전트가 현재의 상태를 인식하여, 선택 가능한 행동들 중 보상을 최대화하는 행동 혹은 행동 순서를 선택하는 방법입니다. (출처 : 위키 백과) 4. 샘플(Sample)과 특성(Feature) 많은 머신 러닝 문제가 1개 이상의 독립 변수를 가지고 종속 변수를 예측하는 문제입니다. 많은 머신 러닝 모델들, 특히 인공 신경망 모델은 독립 변수, 종속 변수, 가중치, 편향 등을 행렬 연산을 통해 연산하는 경우가 많습니다. 그래서 앞으로 인공 신경망을 배우게 되면 훈련 데이터를 행렬로 표현하는 경우를 많이 보게 될 겁니다. 독립 변수의 행렬을 X라고 하였을 때, 독립 변수의 개수가 n 개고 데이터의 개수가 m인 행렬 X는 다음과 같습니다. 이때 머신 러닝에서는 하나의 데이터, 하나의 행을 샘플(Sample)이라고 부릅니다. (데이터베이스에서는 레코드라고 부르는 단위입니다.) 종속 변수를 예측하기 위한 각각의 독립 변수를 특성(Feature)이라고 부릅니다. 5. 혼동 행렬(Confusion Matrix) 머신 러닝에서는 맞춘 문제 수를 전체 문제 수로 나눈 값을 정확도(Accuracy)라고 합니다. 하지만 정확도는 맞춘 결과와 다른 결과에 대한 세부적인 내용을 알려주지는 않습니다. 이를 위해서 사용하는 것이 혼동 행렬(Confusion Matrix)입니다. 예를 들어 양성(Positive)과 음성(Negative)을 구분하는 이진 분류가 있다고 하였을 때 혼동 행렬은 다음과 같습니다. 각 열은 예측값을 나타내며, 각 행은 실제 값을 나타냅니다. - 참 거짓 참 TP FN 거짓 FP TN 이를 각각 TP(True Positive), TN(True Negative), FP(False Postivie), FN(False Negative)라고 하는데 True는 정답을 맞힌 경우고 False는 정답을 맞히지 못한 경우입니다. 그리고 Positive와 Negative는 각각 제시했던 정답입니다. 즉, TP는 양성(Postive)이라고 대답하였고 실제로 양성이라서 정답을 맞힌 경우입니다. TN은 음성(Negative)이라고 대답하였는데 실제로 음성이라서 정답을 맞힌 경우입니다. 그럼 FP는 양성이라고 대답하였는데, 음성이라서 정답을 틀린 경우이며 FN은 음성이라고 대답하였는데 양성이라서 정답을 틀린 경우가 됩니다. 그리고 이 개념을 사용하면 또 새로운 개념인 정밀도(Precision)과 재현율(Recall)이 됩니다. 1) 정밀도(Precision) 정밀도은 양성이라고 대답한 전체 케이스에 대한 TP의 비율입니다. 즉, 정밀도를 수식으로 표현하면 다음과 같습니다. 정밀도 밀 = P P F 2) 재현율(Recall) 재현율은 실제 값이 양성인 데이터의 전체 개수에 대해서 TP의 비율입니다. 즉, 양성인 데이터 중에서 얼마나 양성인지를 예측(재현) 했는지를 나타냅니다. 재현율 현 = P P F 6. 과 적합(Overfitting)과 과소 적합(Underfitting) 학생의 입장이 되어 같은 문제지를 과하게 많이 풀어서 문제 번호만 봐도 정답을 맞힐 수 있게 되었다고 가정합시다. 그런데 다른 문제지나 시험을 보면 점수가 안 좋다면 그게 의미가 있을까요? 머신 러닝에서 과 적합(Overfitting)이란 훈련 데이터를 과하게 학습한 경우를 말합니다. 훈련 데이터는 실제로 존재하는 많은 데이터의 일부에 불과합니다. 그런데 기계가 훈련 데이터에 대해서만 과하게 학습하면 테스트 데이터나 실제 서비스에서의 데이터에 대해서는 정확도가 좋지 않은 현상이 발생합니다. 예를 들어 강아지 사진과 고양이 사진을 구분하는 기계가 있을 때, 검은색 강아지 사진 훈련 데이터를 과하게 학습하면 기계는 나중에 가서는 흰색 강아지나, 갈색 강아지를 보고도 강아지가 아니라고 판단하게 됩니다. 이는 훈련 데이터에 대해서 지나친 일반화를 한 상황입니다. 과적합 상황에서는 훈련 데이터에 대해서는 오차가 낮지만, 테스트 데이터에 대해서는 오차가 높아지는 상황이 발생합니다. 아래의 그래프는 과적합 상황에서 발생할 수 있는 훈련 횟수에 따른 훈련 데이터의 오차와 테스트 데이터의 오차의 변화를 보여줍니다. X 축의 에포크(epoch)는 전체 훈련 데이터에 대한 훈련 횟수를 의미합니다. 위의 그래프는 에포크가 3~4를 넘어가게 되면 과적합이 발생합니다. 위의 그래프는 테스트 데이터에 대한 오차가 점차 증가하는 양상을 보여줍니다. 반대로 말하면 훈련 데이터에 대한 정확도는 높지만, 테스트 데이터는 정확도가 낮은 상황이라고 말할 수도 있습니다. 즉, 테스트 데이터의 오차가 증가하기 전이나, 정확도가 감소하기 전에 훈련을 멈추는 것이 바람직합니다. 과적합 방지를 위해 테스트 데이터의 성능이 낮아지기 전에 훈련을 멈추는 것이 바람직하다고 했는데, 테스트 데이터의 성능이 올라갈 여지가 있음에도 훈련을 덜 한 상태를 반대로 과소 적합(Underfitting)이라고 합니다. 과소 적합은 훈련 자체가 부족한 상태이므로 과대 적합과는 달리 훈련 데이터에 대해서도 보통 정확도가 낮다는 특징이 있습니다. 이러한 두 가지 현상을 과적합과 과소 적합이라고 부르는 이유는 머신 러닝에서 학습 또는 훈련이라고 하는 과정을 적합(fitting)이라고도 부를 수 있기 때문입니다. 모델이 주어진 데이터에 대해서 적합해져가는 과정이기 때문입니다. 딥 러닝을 할 때는 과적합을 막을 수 있는 드롭아웃(Dropout), 조기 종료(Early Stopping)과 같은 몇 가지 방법이 존재하는데 이는 인공 신경망 챕터에서 소개합니다. 06-02 퍼셉트론(Perceptron) 인공 신경망은 수많은 머신 러닝 방법 중 하나입니다. 하지만 최근 인공 신경망을 복잡하게 쌓아 올린 딥 러닝이 다른 머신 러닝 방법들을 뛰어넘는 성능을 보여주는 사례가 늘면서, 전통적인 머신 러닝과 딥 러닝을 구분해서 이해해야 한다는 목소리가 커지고 있습니다. 딥 러닝을 이해하기 위해서는 우선 인공 신경망에 대한 이해가 필요한데, 이번 챕터에서는 초기의 인공 신경망인 퍼셉트론(Perceptron)에 대해서 이해합니다. 1. 퍼셉트론(Perceptron) 퍼셉트론(Perceptron)은 프랑크 로젠블라트(Frank Rosenblatt)가 1957년에 제안한 초기 형태의 인공 신경망으로 다수의 입력으로부터 하나의 결과를 내보내는 알고리즘입니다. 퍼셉트론은 실제 뇌를 구성하는 신경 세포 뉴런의 동작과 유사한데, 신경 세포 뉴런의 그림을 먼저 보도록 하겠습니다. 뉴런은 가지돌기에서 신호를 받아들이고, 이 신호가 일정치 이상의 크기를 가지면 축삭돌기를 통해서 신호를 전달합니다. 이제 다수의 입력을 받는 퍼셉트론의 그림을 보겠습니다. 신경 세포 뉴런의 입력 신호와 출력 신호가 퍼셉트론에서 각각 입력값과 출력값에 해당됩니다.는 입력값을 의미하며,는 가중치(Weight),는 출력값입니다. 그림 안의 원은 인공 뉴런에 해당됩니다. 실제 신경 세포 뉴런에서의 신호를 전달하는 축삭돌기의 역할을 퍼셉트론에서는 가중치가 대신합니다. 각각의 인공 뉴런에서 보내진 입력값 는 각각의 가중치 와 함께 종착지인 인공 뉴런에 전달되고 있습니다. 각각의 입력값에는 각각의 가중치가 존재하는데, 이때 가중치의 값이 크면 클수록 해당 입력 값이 중요하다는 것을 의미합니다. 각 입력값이 가중치와 곱해져서 인공 뉴런에 보내지고, 각 입력값과 그에 해당되는 가중치의 곱의 전체 합이 임계치(threshold)를 넘으면 종착지에 있는 인공 뉴런은 출력 신호로서 1을 출력하고, 그렇지 않을 경우에는 0을 출력합니다. 이러한 함수를 계단 함수(Step function)라고 하며, 아래는 그래프는 계단 함수의 하나의 예를 보여줍니다. 이때 계단 함수에 사용된 이 임계치 값을 수식으로 표현할 때는 보통 세타(Θ)로 표현합니다. 이를 식으로 표현하면 다음과 같습니다. f i W x ≥ → = i ∑ n i i < → = 단, 위의 식에서 임계치를 좌변으로 넘기고 편향 (bias)로 표현할 수도 있습니다. 편향 또한 퍼셉트론의 입력으로 사용됩니다. 보통 그림으로 표현할 때는 입력값이 1로 고정되고 편향 가 곱해지는 변수로 표현됩니다. f i W x + ≥ → = i ∑ n i i b 0 y 0 이 책을 포함한 많은 인공 신경망 자료에서 편의상 편향 가 그림이나 수식에서 생략돼서 표현되기도 하지만 실제로는 편향 또한 딥 러닝이 최적의 값을 찾아야 할 변수 중 하나입니다. 다음 챕터에서 배우겠지만 이렇게 뉴런에서 출력값을 변경시키는 함수를 활성화 함수(Activation Function)라고 합니다. 초기 인공 신경망 모델인 퍼셉트론은 활성화 함수로 계단 함수를 사용하였지만, 그 뒤에 등장한 여러 가지 발전된 신경망들은 계단 함수 외에도 여러 다양한 활성화 함수를 사용하기 시작했습니다. 사실 앞서 배운 시그모이드 함수나 소프트맥스 함수 또한 활성화 함수 중 하나입니다. 퍼셉트론을 배우기 전에 로지스틱 회귀를 먼저 배운 이유도 여기에 있습니다. 퍼셉트론의 활성화 함수는 계단 함수이지만 여기서 활성화 함수를 시그모이드 함수로 변경하면 방금 배운 퍼셉트론은 곧 이진 분류를 수행하는 로지스틱 회귀와 동일함을 알 수 있습니다. 다시 말하면 로지스틱 회귀 모델이 인공 신경망에서는 하나의 인공 뉴런으로 볼 수 있습니다. 로지스틱 회귀를 수행하는 인공 뉴런과 위에서 배운 퍼셉트론의 차이는 오직 활성화 함수의 차이입니다. 인공 뉴런 : 활성화 함수 ( i W x + ) 위의 퍼셉트론(인공 뉴런 종류 중 하나) : 계단 함수 ( i W x + ) 2. 단층 퍼셉트론(Single-Layer Perceptron) 위에서 배운 퍼셉트론을 단층 퍼셉트론이라고 합니다. 퍼셉트론은 단층 퍼셉트론과 다층 퍼셉트론으로 나누어지는데, 단층 퍼셉트론은 값을 보내는 단계과 값을 받아서 출력하는 두 단계로만 이루어집니다. 이때 이 각 단계를 보통 층(layer)라고 부르며, 이 두 개의 층을 입력층(input layer)과 출력층(output layer)이라고 합니다. 단층 퍼셉트론의 한계를 개선하기 위해 향후에 나온 다층 퍼셉트론을 배우게 되면 단층과 다층 이 두 퍼셉트론이 어떤 차이를 가지는지 쉽게 이해할 수 있습니다. 단층 퍼셉트론이 어떤 일을 할 수 있으며 한계는 무엇인지 학습해 보겠습니다. 단층 퍼셉트론을 이용하면 AND, NAND, OR 게이트를 쉽게 구현할 수 있습니다. 게이트 연산에 쓰이는 것은 두 개의 입력값과 하나의 출력값입니다. 예를 들어 AND 게이트의 경우에는 두 개의 입력 값이 모두 1인 경우에만 출력값이 1이 나오는 구조를 갖고 있습니다. 단층 퍼셉트론의 식을 통해 AND 게이트를 만족하는 두 개의 가중치와 편향 값에는 뭐가 있을까요? 각각 1 w,라고 한다면 [0.5, 0.5, -0.7], [0.5, 0.5, -0.8] 또는 [1.0, 1.0, -1.0] 등 이 외에도 다양한 가중치와 편향의 조합이 나올 수 있습니다. 이해를 돕기 위해서 AND 게이트를 위한 매개변수 값을 가진 단층 퍼셉트론의 식을 파이썬 코드로 간단하게 구현해 봅시다. def AND_gate(x1, x2): w1=0.5 w2=0.5 b=-0.7 result = x1*w1 + x2*w2 + b if result <= 0: return 0 else: return 1 위의 함수에 AND 게이트의 입력값을 모두 넣어보면 오직 두 개의 입력값이 1인 경우에만 1을 출력합니다. AND_gate(0, 0), AND_gate(0, 1), AND_gate(1, 0), AND_gate(1, 1) (0, 0, 0, 1) 그렇다면 두 개의 입력값이 1인 경우에만 출력값이 0, 나머지 입력값의 쌍(pair)에 대해서는 모두 출력값이 1이 나오는 NAND 게이트는 어떨까요? 앞서 언급했던 AND 게이트를 충족하는 가중치와 편향 값인 [0.5, 0.5, -0.7]에 -를 붙여서 [-0.5, -0.5, +0.7]을 단층 퍼셉트론의 식에 넣어보면 NAND 게이트를 충족합니다. 파이썬 코드를 통해서 이를 확인해 봅시다. def NAND_gate(x1, x2): w1=-0.5 w2=-0.5 b=0.7 result = x1*w1 + x2*w2 + b if result <= 0: return 0 else: return 1 단지 같은 코드에 함수 이름과 가중치와 편향만 바꿨을 뿐입니다. 퍼셉트론의 구조는 같기 때문입니다. NAND_gate(0, 0), NAND_gate(0, 1), NAND_gate(1, 0), NAND_gate(1, 1) (1, 1, 1, 0) NAND 게이트를 구현한 파이썬 코드에 입력값을 넣자, 두 개의 입력값이 1인 경우에만 0이 나오는 것을 확인할 수 있습니다. 퍼셉트론으로 NAND 게이트를 구현한 것입니다. [-0.5, -0.5, -0.7] 외에도 퍼셉트론이 NAND 게이트의 동작을 하도록 하는 다양한 가중치와 편향의 값들이 있을 것입니다. 두 개의 입력이 모두 0인 경우에 출력값이 0이고 나머지 경우에는 모두 출력값이 1인 OR 게이트 또한 적절한 가중치 값과 편향 값만 찾으면 단층 퍼셉트론의 식으로 구현할 수 있습니다. 예를 들어 각각 가중치와 편향에 대해서 [0.6, 0.6, -0.5]를 선택하면 OR 게이트를 충족합니다. def OR_gate(x1, x2): w1=0.6 w2=0.6 b=-0.5 result = x1*w1 + x2*w2 + b if result <= 0: return 0 else: return 1 OR_gate(0, 0), OR_gate(0, 1), OR_gate(1, 0), OR_gate(1, 1) (0, 1, 1, 1) 물론, 이 외에도 이를 충족하는 다양한 가중치와 편향의 값이 있습니다. 이처럼 단층 퍼셉트론은 AND 게이트, NAND 게이트, OR 게이트 또한 구현할 수 있습니다. 하지만 단층 퍼셉트론으로 구현이 불가능한 게이트가 있는데 바로 XOR 게이트입니다. XOR 게이트는 입력값 두 개가 서로 다른 값을 갖고 있을 때에만 출력값이 1이 되고, 입력값 두 개가 서로 같은 값을 가지면 출력값이 0이 되는 게이트입니다. 위의 파이썬 코드에 아무리 수많은 가중치와 편향을 넣어봐도 XOR 게이트를 구현하는 것은 불가능합니다. 그 이유는 단층 퍼셉트론은 직선 하나로 두 영역을 나눌 수 있는 문제에 대해서만 구현이 가능하기 때문입니다. 예를 들어 AND 게이트에 대한 단층 퍼셉트론을 시각화해보면 다음과 같습니다. 그림에서는 출력값 0을 하얀색 원, 1을 검은색 원으로 표현했습니다. AND 게이트를 충족하려면 하얀색 원과 검은색 원을 직선으로 나누게 됩니다. 마찬가지로 NAND 게이트나 OR 게이트에 대해서도 시각화를 했을 때 직선으로 나누는 것이 가능합니다. 그렇다면 XOR 게이트는 어떨까요? XOR 게이트는 입력값 두 개가 서로 다른 값을 갖고 있을 때에만 출력값이 1이 되고, 입력값 두 개가 서로 같은 값을 가지면 출력값이 0이 되는 게이트입니다. XOR 게이트를 시각화해보면 다음과 같습니다. 하얀색 원과 검은색 원을 직선 하나로 나누는 것은 불가능합니다. 즉, 단층 퍼셉트론으로는 XOR 게이트를 구현하는 것이 불가능합니다. 이를 단층 퍼셉트론은 선형 영역에 대해서만 분리가 가능하다고 말합니다. 사실 XOR 게이트는 직선이 아닌 곡선. 비선형 영역으로 분리하면 구현이 가능합니다. 위의 그림은 곡선을 사용한다면 하얀색 원과 검은색 원을 나눌 수 있음을 보여줍니다. 이제 XOR 게이트를 만들 수 있는 다층 퍼셉트론에 대해서 알아보도록 하겠습니다. 3. 다층 퍼셉트론(MultiLayer Perceptron, MLP) XOR 게이트는 기존의 AND, NAND, OR 게이트를 조합하면 만들 수 있습니다. 퍼셉트론 관점에서 말하면, 층을 더 쌓으면 만들 수 있습니다. 다층 퍼셉트론과 단층 퍼셉트론의 차이는 단층 퍼셉트론은 입력층과 출력층만 존재하지만, 다층 퍼셉트론은 중간에 층을 더 추가하였다는 점입니다. 이렇게 입력층과 출력층 사이에 존재하는 층을 은닉층(hidden layer)이라고 합니다. 즉, 다층 퍼셉트론은 중간에 은닉층이 존재한다는 점이 단층 퍼셉트론과 다릅니다. 다층 퍼셉트론은 줄여서 MLP라고도 부릅니다. 위의 그림은 AND, NAND, OR 게이트를 조합하여 XOR 게이트를 구현한 다층 퍼셉트론의 예입니다. (실제 구현은 숙제로 남겨두겠습니다. 힌트를 드리자면 위의 단층 퍼셉트론에서 사용한 함수들을 그대로 사용하면 됩니다.) XOR 예제에서는 은닉층 1개만으로 문제를 해결할 수 있었지만, 다층 퍼셉트론은 본래 은닉층이 1개 이상인 퍼셉트론을 말합니다. 즉, XOR 문제보다 더욱 복잡한 문제를 해결하기 위해서 다층 퍼셉트론은 중간에 수많은 은닉층을 더 추가할 수 있습니다. 은닉층의 개수는 2개일 수도 있고, 수십 개일 수도 있고 사용자가 설정하기 나름입니다. 아래는 더 어려운 문제를 풀기 위해서 은닉층이 하나 더 추가되고(이 경우에는 은닉층이 2개), 뉴런의 개수를 늘린 다층 퍼셉트론의 모습을 보여줍니다. 위와 같이 은닉층이 2개 이상인 신경망을 심층 신경망(Deep Neural Network, DNN)이라고 합니다. 심층 신경망은 다층 퍼셉트론만 이야기하는 것이 아니라, 여러 변형된 다양한 신경망들도 은닉층이 2개 이상이 되면 심층 신경망이라고 합니다. 지금까지는 OR, AND, XOR 게이트 등. 퍼셉트론이 가야 할 정답을 참고로 퍼셉트론이 정답을 출력할 때까지 가중치를 바꿔보면서 맞는 가중치를 찾았습니다. 즉, 가중치를 수동으로 찾았습니다. 하지만 이제는 기계가 가중치를 스스로 찾아내도록 자동화시켜야 하는데, 이것이 머신 러닝에서 말하는 학습(training) 단계에 해당됩니다. 앞서 선형 회귀와 로지스틱 회귀에서 보았듯이 손실 함수(Loss function)와 옵티마이저(Optimizer)를 사용합니다. 그리고 만약 학습을 시키는 인공 신경망이 심층 신경망일 경우에는 이를 심층 신경망을 학습시킨다고 하여, 딥 러닝(Deep Learning)이라고 합니다. 다층 퍼셉트론 : http://www.aistudy.com/neural/multilayer_perceptron.htm 06-03 XOR 문제 - 단층 퍼셉트론 구현하기 이번 챕터에서는 파이 토치를 사용해서 단층 퍼셉트론을 구현하여 XOR 문제를 풀어보는 것을 시도해 보겠습니다. 1. 파이 토치로 단층 퍼셉트론 구현하기 우선 필요한 도구를 임포트하고, GPU 연산이 가능할 경우에는 GPU 연산을 할 수 있도록 설정해 줍니다. import torch device = 'cuda' if torch.cuda.is_available() else 'cpu' torch.manual_seed(777) if device == 'cuda': torch.cuda.manual_seed_all(777) 이제 XOR 문제에 해당되는 입력과 출력을 정의합니다. X = torch.FloatTensor([[0, 0], [0, 1], [1, 0], [1, 1]]).to(device) Y = torch.FloatTensor([[0], [1], [1], [0]]).to(device) 이제 1개의 뉴런을 가지는 단층 퍼셉트론을 구현해 봅시다. 단층 퍼셉트론이 처음 소개되었을 때는 계단 함수였지만, 우리는 이미 또 다른 활성화 함수인 시그모이드 함수를 알고 있으므로 시그모이드 함수를 사용해 보겠습니다. linear = nn.Linear(2, 1, bias=True) sigmoid = nn.Sigmoid() model = nn.Sequential(linear, sigmoid).to(device) 0 또는 1을 예측하는 이진 분류 문제이므로 비용 함수로는 크로스 엔트로피 함수를 사용합니다. nn.BCELoss()는 이진 분류에서 사용하는 크로스 엔트로피 함수입니다. # 비용 함수와 옵티마이저 정의 criterion = torch.nn.BCELoss().to(device) optimizer = torch.optim.SGD(model.parameters(), lr=1) #10,001번의 에포크 수행. 0번 에포크부터 10,000번 에포크까지. for step in range(10001): optimizer.zero_grad() hypothesis = model(X) # 비용 함수 cost = criterion(hypothesis, Y) cost.backward() optimizer.step() if step % 100 == 0: # 100번째 에포크마다 비용 출력 print(step, cost.item()) 이제 비용이 줄어드는 과정을 보겠습니다. 0 0.7273974418640137 100 0.6931476593017578 200 0.6931471824645996 ... 중략 ... 10000 0.6931471824645996 200번 에포크에 비용이 0.6931471824645996가 출력된 이후에는 10,000번 에포크가 되는 순간까지 더 이상 비용이 줄어들지 않습니다. 이는 단층 퍼셉트론은 XOR 문제를 풀 수 없기 때문입니다. 2. 학습된 단층 퍼셉트론의 예측값 확인하기 총 10,001회 학습한 단층 퍼셉트론의 예측값도 확인해 보겠습니다. with torch.no_grad(): hypothesis = model(X) predicted = (hypothesis > 0.5).float() accuracy = (predicted == Y).float().mean() print('모델의 출력값(Hypothesis): ', hypothesis.detach().cpu().numpy()) print('모델의 예측값(Predicted): ', predicted.detach().cpu().numpy()) print('실 제값(Y): ', Y.cpu().numpy()) print('정확도(Accuracy): ', accuracy.item()) 모델의 출력값(Hypothesis): [[0.5] [0.5] [0.5] [0.5]] 모델의 예측값(Predicted): [[0.] [0.] [0.] [0.]] 실제 값(Y): [[0.] [1.] [1.] [0.]] 정확도(Accuracy): 0.5 실제 값은 0, 1, 1, 0임에도 예측값은 0, 0, 0, 0으로 문제를 풀지 못하는 모습을 보여줍니다. 06-04 역전파(BackPropagation) 인공 신경망이 순전파 과정을 진행하여 예측값과 실제 값의 오차를 계산하였을 때 어떻게 역전파 과정에서 경사 하강법을 사용하여 가중치를 업데이트하는지 직접 계산을 통해 이해해 봅시다. 1. 인공 신경망의 이해(Neural Network Overview) 우선 예제를 위해 사용될 인공 신경망을 소개합니다. 역전파의 이해를 위해서 여기서 사용할 인공 신경망은 입력층, 은닉층, 출력층 이렇게 3개의 층을 가집니다. 또한 해당 인공 신경망은 두 개의 입력과, 두 개의 은닉층 뉴런, 두 개의 출력층 뉴런을 사용합니다. 은닉층과 출력층의 모든 뉴런은 활성화 함수로 시그모이드 함수를 사용합니다. 위의 그림은 여기서 사용할 인공 신경망의 모습을 보여줍니다. 은닉층과 출력층의 모든 뉴런에서 변수 가 존재하는데 여기서 변수는 이전층의 모든 입력이 각각의 가중치와 곱해진 값들이 모두 더해진 가중합을 의미합니다. 이 값은 뉴런에서 아직 시그모이드 함수를 거치지 않은 상태입니다. 즉, 활성화 함수의 입력을 의미합니다. 우측의 |를 지나서 존재하는 변수 또는 는 가 시그모이드 함수를 지난 후의 값으로 각 뉴런의 출력값을 의미합니다. 이번 역전파 예제에서는 인공 신경망에 존재하는 모든 가중치에 대해서 역전파를 통해 업데이트하는 것을 목표로 합니다. 해당 인공 신경망은 편향 는 고려하지 않습니다. 2. 순전파(Forward Propagation) 주어진 값이 위의 그림과 같을 때 순전파를 진행해 봅시다. 위의 그림에서 소수점 앞의 0은 생략하였습니다. 예를 들어. 25는 0.25를 의미합니다. 파란색 숫자는 입력값을 의미하며, 빨간색 숫자는 각 가중치의 값을 의미합니다. 앞으로 진행하는 계산의 결괏값은 소수점 아래 여덟 번째 자리까지 반올림하여 표기합니다. 각 입력은 입력층에서 은닉층 방향으로 향하면서 각 입력에 해당하는 가중치와 곱해지고, 결과적으로 가중 합으로 계산되어 은닉층 뉴런의 시그모이드 함수의 입력값이 됩니다. 1 z는 시그모이드 함수의 입력으로 사용되는 각각의 값에 해당됩니다. 1 W x + 2 2 0.3 0.1 0.25 0.2 0.08 2 W x + 4 2 0.4 0.1 0.35 0.2 0.11 1 z는 각각의 은닉층 뉴런에서 시그모이드 함수를 지나게 되는데 시그모이드 함수가 리턴하는 결괏값은 은닉층 뉴런의 최종 출력값입니다. 식에서는 각각 1 h에 해당되며, 아래의 결과와 같습니다. 1 s g o d ( 1 ) 0.51998934 2 s g o d ( 2 ) 0.52747230 1 h 이 두 값은 다시 출력층의 뉴런으로 향하게 되는데 이때 다시 각각의 값에 해당되는 가중치와 곱해지고, 다시 가중 합 되어 출력층 뉴런의 시그모이드 함수의 입력값이 됩니다. 식에서는 각각 3 z에 해당됩니다. 3 W h + 6 2 0.45 h + 0.4 h = 0.44498412 4 W h + 8 2 0.7 h + 0.6 h = 0.68047592 3 z 이 출력층 뉴런에서 시그모이드 함수를 지난 값은 이 인공 신경망이 최종적으로 계산한 출력값입니다. 실제 값을 예측하기 위한 값으로서 예측값이라고도 부릅니다. 1 s g o d ( 3 ) 0.60944600 2 s g o d ( 4 ) 0.66384491 이제 해야 할 일은 예측값과 실제 값의 오차를 계산하기 위한 오차 함수를 선택하는 것입니다. 오차(Error)를 계산하기 위한 손실 함수(Loss function)로는 평균 제곱 오차 MSE를 사용합니다. 식에서는 실제 값을 target이라고 표현하였으며, 순전파를 통해 나온 예측값을 output으로 표현하였습니다. 그리고 각 오차를 모두 더하면 전체 오차 t t l 가 됩니다. o = 2 ( a g t 1 o t u o) = 0.02193381 o = 2 ( a g t 2 o t u o) = 0.00203809 t t l E 1 E 2 0.02397190 3. 역전파 1단계(BackPropagation Step 1) 순전파가 입력층에서 출력층으로 향한다면 역전파는 반대로 출력층에서 입력층 방향으로 계산하면서 가중치를 업데이트해갑니다. 출력층 바로 이전의 은닉층을 N 층이라고 하였을 때, 출력층과 N 층 사이의 가중치를 업데이트하는 단계를 역전파 1단계, 그리고 N 층과 N 층의 이전층 사이의 가중치를 업데이트하는 단계를 역전파 2단계라고 해봅시다. 역전파 1단계에서 업데이트해야 할 가중치는 5 W, 7 W 총 4개입니다. 원리 자체는 동일하므로 우선 5 에 대해서 먼저 업데이트를 진행해 보겠습니다. 경사 하강법을 수행하려면 가중치 5 를 업데이트하기 위해서 E o a ∂ 5 를 계산해야 합니다. E o a ∂ 5 를 계산하기 위해 미분의 연쇄 법칙(Chain rule)에 따라서 이와 같이 풀어쓸 수 있습니다. E o a ∂ 5 ∂ t t l o × o ∂ 3 ∂ 3 W 위의 식에서 우변의 세 개의 각 항에 대해서 순서대로 계산해 봅시다. 우선 첫 번째 항에 대해서 계산해 보겠습니다. 미분을 진행하기 전에 t t l 의 값을 상기해 봅시다. t t l 은 앞서 순전파를 진행하고 계산했던 전체 오차 값입니다. 식은 다음과 같습니다. t t l 1 ( a g t 1 o t u o) + 2 ( a g t 2 o t u o) 이에 E o a ∂ 1 는 다음과 같습니다. E o a ∂ 1 2 1 ( a g t 1 o t u o) − × ( 1 ) 0 E o a ∂ 1 − ( a g t 1 o t u o) − ( 0.4 0.60944600 ) 0.20944600 이제 두 번째 항을 주목해 봅시다. 1 이라는 값은 시그모이드 함수의 출력값입니다. 그런데 시그모이드 함수의 미분은 ( ) ( − ( ) ) 입니다. 앞으로의 계산 과정에서도 계속해서 시그모이드 함수를 미분해야 하는 상황이 생기므로 기억해둡시다. 이에 따라서 두 번째 항의 미분 결과는 다음과 같습니다. (시그모이드 함수 미분 참고 링크 : https://en.wikipedia.org/wiki/Logistic_function#Derivative) o ∂ 3 o × ( − 1 ) 0.60944600 ( − 0.60944600 ) 0.23802157 마지막으로 세 번째 항은 1 의 값과 동일합니다. z ∂ 5 h = 0.51998934 우변의 모든 항을 계산하였습니다. 이제 이 값을 모두 곱해주면 됩니다. E o a ∂ 5 0.20944600 0.23802157 0.51998934 0.02592286 이제 앞서 배웠던 경사 하강법을 통해 가중치를 업데이트할 때가 왔습니다! 하이퍼 파라미터에 해당되는 학습률(learning rate)는 0.5라고 가정합니다. 5 = 5 α E o a ∂ 5 0.45 0.5 0.02592286 0.43703857 이와 같은 원리로 6 , W + W + 을 계산할 수 있습니다. E o a ∂ 6 ∂ t t l o × o ∂ 3 ∂ 3 W → 6 = 0.38685205 E o a ∂ 7 ∂ t t l o × o ∂ 4 ∂ 4 W → 7 = 0.69629578 E o a ∂ 8 ∂ t t l o × o ∂ 4 ∂ 4 W → 8 = 0.59624247 4. 역전파 2단계(BackPropagation Step 2) 1단계를 완료하였다면 이제 입력층 방향으로 이동하며 다시 계산을 이어갑니다. 위의 그림에서 빨간색 화살표는 순전파의 정반대 방향인 역전파의 방향을 보여줍니다. 현재 인공 신경망은 은닉층이 1개밖에 없으므로 이번 단계가 마지막 단계입니다. 하지만 은닉층이 더 많은 경우라면 입력층 방향으로 한 단계씩 계속해서 계산해가야 합니다. 이번 단계에서 계산할 가중치는 1 W, 3 W입니다. 원리 자체는 동일하므로 우선 1 에 대해서 먼저 업데이트를 진행해 보겠습니다. 경사 하강법을 수행하려면 가중치 1 를 업데이트하기 위해서 E o a ∂ 1 를 계산해야 합니다. E o a ∂ 1 를 계산하기 위해 미분의 연쇄 법칙(Chain rule)에 따라서 이와 같이 풀어쓸 수 있습니다. E o a ∂ 1 ∂ t t l h × h ∂ 1 ∂ 1 W 위의 식에서 우변의 첫 번째 항인 E o a ∂ 1 는 다음과 같이 다시 식을 풀어서 쓸 수 있습니다. E o a ∂ 1 ∂ o ∂ 1 ∂ o ∂ 1 위의 식의 우변의 두 항을 각각 구해봅시다. 우선 첫 번째 항 E 1 h에 대해서 항을 분해 및 계산해 보겠습니다. E 1 h = E 1 z × z ∂ 1 ∂ o ∂ 1 ∂ 1 z × z ∂ 1 − ( a g t 1 o t u o) o × ( − 1 ) W = 0.20944600 0.23802157 0.45 0.02243370 이와 같은 원리로 E 2 h 또한 구합니다. E 2 h = E 2 z × z ∂ 1 ∂ o ∂ 2 ∂ 2 z × z ∂ 1 0.00997311 E o a ∂ 1 0.02243370 0.00997311 0.03240681 이제 E o a ∂ 1 를 구하기 위해서 필요한 첫 번째 항을 구했습니다. 나머지 두 항에 대해서 구해보도록 하겠습니다. h ∂ 1 h × ( − 1 ) 0.51998934 ( − 0.51998934 ) 0.24960043 z ∂ 1 x = 0.1 즉, E o a ∂ 1 는 다음과 같습니다. E o a ∂ 1 0.03240681 0.24960043 0.1 0.00080888 이제 앞서 배웠던 경사 하강법을 통해 가중치를 업데이트할 수 있습니다. 1 = 1 α E o a ∂ 1 0.1 0.5 0.00080888 0.29959556 이와 같은 원리로 2 , W + W + 을 계산할 수 있습니다. E o a ∂ 2 ∂ t t l h × h ∂ 1 ∂ 1 W → 2 = 0.24919112 E o a ∂ 3 ∂ t t l h × h ∂ 2 ∂ 2 W → 3 = 0.39964496 E o a ∂ 4 ∂ t t l h × h ∂ 2 ∂ 2 W → 4 = 0.34928991 5. 결과 확인 업데이트된 가중치에 대해서 다시 한번 순전파를 진행하여 오차가 감소하였는지 확인해 보겠습니다. 1 W x + 2 2 0.29959556 0.1 0.24919112 0.2 0.07979778 2 W x + 4 2 0.39964496 0.1 0.34928991 0.2 0.10982248 1 s g o d ( 1 ) 0.51993887 2 s g o d ( 2 ) 0.52742806 3 W h + 6 2 0.43703857 h + 0.38685205 h = 0.43126996 4 W h + 8 2 0.69629578 h + 0.59624247 h = 0.67650625 1 s g o d ( 3 ) 0.60617688 2 s g o d ( 4 ) 0.66295848 o = 2 ( a g t 1 o t u o) = 0.02125445 o = 2 ( a g t 2 o t u o) = 0.00198189 t t l E 1 E 2 0.02323634 기존의 전체 오차 t t l 가 0.02397190였으므로 1번의 역전파로 오차가 감소한 것을 확인할 수 있습니다. 인공 신경망의 학습은 오차를 최소화하는 가중치를 찾는 목적으로 순전파와 역전파를 반복하는 것을 말합니다. https://medium.com/@14prakash/back-propagation-is-very-simple-who-made-it-complicated-97b794c97e5c https://www.youtube.com/watch? v=ZMgax46Rd3g 06-05 XOR 문제 - 다층 퍼셉트론 구현하기 이번 챕터에서는 파이 토치를 사용해서 다층 퍼셉트론을 구현하여 XOR 문제를 풀어보는 것을 시도해 보겠습니다. 1. 파이 토치로 다층 퍼셉트론 구현하기 import torch import torch.nn as nn GPU 연산이 가능하다면 GPU 연산을 하도록 하고, 랜덤 시드를 고정해 줍니다. device = 'cuda' if torch.cuda.is_available() else 'cpu' # for reproducibility torch.manual_seed(777) if device == 'cuda': torch.cuda.manual_seed_all(777) XOR 문제를 풀기 위한 입력과 출력을 정의해 줍니다. X = torch.FloatTensor([[0, 0], [0, 1], [1, 0], [1, 1]]).to(device) Y = torch.FloatTensor([[0], [1], [1], [0]]).to(device) 이제 다층 퍼셉트론을 설계합니다. 아래는 입력층, 은닉층 1, 은닉층 2, 은닉층 3, 출력층을 가지는 은닉층이 3개인 인공 신경망입니다. model = nn.Sequential( nn.Linear(2, 10, bias=True), # input_layer = 2, hidden_layer1 = 10 nn.Sigmoid(), nn.Linear(10, 10, bias=True), # hidden_layer1 = 10, hidden_layer2 = 10 nn.Sigmoid(), nn.Linear(10, 10, bias=True), # hidden_layer2 = 10, hidden_layer3 = 10 nn.Sigmoid(), nn.Linear(10, 1, bias=True), # hidden_layer3 = 10, output_layer = 1 nn.Sigmoid() ).to(device) 위 인공 신경망을 그림으로 표현하면 아래와 같습니다. 이제 비용 함수와 옵타마이저를 선언합니다. nn.BCELoss()는 이진 분류에서 사용하는 크로스 엔트로피 함수입니다. criterion = torch.nn.BCELoss().to(device) optimizer = torch.optim.SGD(model.parameters(), lr=1) # modified learning rate from 0.1 to 1 총 10,001번의 에포크를 수행합니다. 각 에포크마다 역전파가 수행된다고 보면 되겠습니다. for epoch in range(10001): optimizer.zero_grad() # forward 연산 hypothesis = model(X) # 비용 함수 cost = criterion(hypothesis, Y) cost.backward() optimizer.step() # 100의 배수에 해당되는 에포크마다 비용을 출력 if epoch % 100 == 0: print(epoch, cost.item()) 비용이 최소화되는 방향으로 가중치와 편향이 업데이트됩니다. 아래는 100배수의 에포크마다 비용이 줄어드는 과정을 보여줍니다. 0 0.6948983669281006 100 0.693155825138092 200 0.6931535601615906 ... 중략 ... 5400 0.009766248054802418 2. 학습된 다층 퍼셉트론의 예측값 확인하기 이제 모델이 XOR 문제를 풀 수 있는지 테스트해봅시다. with torch.no_grad(): hypothesis = model(X) predicted = (hypothesis > 0.5).float() accuracy = (predicted == Y).float().mean() print('모델의 출력값(Hypothesis): ', hypothesis.detach().cpu().numpy()) print('모델의 예측값(Predicted): ', predicted.detach().cpu().numpy()) print('실 제값(Y): ', Y.cpu().numpy()) print('정확도(Accuracy): ', accuracy.item()) 모델의 출력값(Hypothesis): [[1.1169249e-04] [9.9982882e-01] [9.9984229e-01] [1.8529959e-04]] 모델의 예측값(Predicted): [[0.] [1.] [1.] [0.]] 실제 값(Y): [[0.] [1.] [1.] [0.]] 정확도(Accuracy): 1.0 실제 값은 0, 1, 1, 0이며 예측값은 0, 1, 1, 0으로 문제를 해결하는 모습을 보여줍니다. 인공 신경망 그림 그리기 : http://alexlenail.me/NN-SVG/index.html 06-06 비선형 활성화 함수(Activation function) 비선형 활성화 함수(Activation function)는 입력을 받아 수학적 변환을 수행하고 출력을 생성하는 함수입니다. 앞서 배운 시그모이드 함수나 소프트맥스 함수는 대표적인 활성화 함수 중 하나입니다. 이번 챕터에서는 인공 신경망의 은닉층에서 왜 활성화 함수로 시그모이드(sigmoid) 함수를 사용하는 것을 왜 지양해야 하는지와 은닉층에서 주로 사용되는 함수인 렐루(ReLU) 함수를 소개하고 그 외의 다른 활성화 함수들에 대해서도 소개합니다. 이번 챕터에서는 그래프를 직접 그리면서 이해해 보겠습니다. 우선 아래의 도구들을 모두 임포트 했다고 가정합니다. import numpy as np # 넘파이 사용 import matplotlib.pyplot as plt # 맷플롯립 사용 1. 활성화 함수의 특징 - 비선형 함수(Nonlinear function) 활성화 함수의 특징은 선형 함수가 아닌 비선형 함수여야 한다는 점입니다. 선형 함수란 출력이 입력의 상수배만큼 변하는 함수를 선형함수라고 합니다. 예를 들어 ( ) W +라는 함수가 있을 때, W와 b는 상수입니다. 이 식은 그래프를 그리면 직선이 그려집니다. 반대로 비선형 함수는 직선 1개로는 그릴 수 없는 함수를 말합니다. 인공 신경망의 능력을 높이기 위해서는 은닉층을 계속해서 추가해야 합니다. 그런데 만약 활성화 함수로 선형 함수를 사용하게 되면 은닉층을 쌓을 수가 없습니다. 예를 들어 활성화 함수로 선형 함수를 선택하고, 층을 계속 쌓는다고 가정해 보겠습니다. 활성화 함수는 ( ) W라고 가정합니다. 여기다가 은닉층을 두 개 추가한다고 하면 출력층을 포함해서 ( ) f ( ( ( ) ) ) 가 됩니다. 이를 식으로 표현하면 × × ×입니다. 그런데 이는 잘 생각해 보면의 세 제곱값을 라고 정의해버리면 ( ) k 와 같이 다시 표현이 가능합니다. 즉, 선형 함수로는 은닉층을 여러 번 추가하더라도 1회 추가한 것과 차이를 줄 수 없습니다. 선형 함수를 사용한 은닉층을 1회 추가한 것과 연속으로 추가한 것이 차이가 없다는 뜻이지, 선형 함수를 사용한 층이 아무 의미가 없다는 뜻이 아닙니다. 학습 가능한 가중치가 새로 생긴다는 점에서 분명히 의미가 있습니다. 이와 같이 선형 함수를 사용한 층을 활성화 함수를 사용하는 은닉층과 구분하기 위해서 선형층(linear layer)이나 투사층(projection layer) 등의 다른 표현을 사용하여 표현하기도 합니다. 활성화 함수를 사용하는 일반적인 은닉층을 선형층과 대비되는 표현을 사용하면 비선형층(nonlinear layer)입니다. 2. 시그모이드 함수(Sigmoid function)와 기울기 소실 시그모이드 함수를 사용한 어떤 인공 신경망이 있다고 가정해 보겠습니다. 위 인공 신경망의 학습 과정은 다음과 같습니다. 우선 인공 신경망은 입력에 대해서 순전파(forward propagation) 연산을 하고, 그리고 순전파 연산을 통해 나온 예측값과 실제 값의 오차를 손실 함수(loss function)을 통해 계산하고, 그리고 이 손실(loss)을 미분을 통해서 기울기(gradient)를 구하고, 이를 통해 역전파(back propagation)를 수행합니다. 그리고 시그모이드 함수의 문제점은 미분을 해서 기울기(gradient)를 구할 때 발생합니다. # 시그모이드 함수 그래프를 그리는 코드 def sigmoid(x): return 1/(1+np.exp(-x)) x = np.arange(-5.0, 5.0, 0.1) y = sigmoid(x) plt.plot(x, y) plt.plot([0,0],[1.0,0.0], ':') # 가운데 점선 추가 plt.title('Sigmoid Function') plt.show() 위의 그래프는 시그모이드 함수의 그래프를 보여줍니다. 위 그래프를 시그모이드 함수의 출력값이 0 또는 1에 가까워지면, 그래프의 기울기가 완만해지는 모습을 볼 수 있습니다. 기울기가 완만해지는 구간을 주황색, 그렇지 않은 구간을 초록색으로 칠해보겠습니다. 주황색 부분은 기울기를 계산하면 0에 가까운 아주 작은 값이 나오게 됩니다. 그런데 역전파 과정에서 0에 가까운 아주 작은 기울기가 곱해지게 되면, 앞단에는 기울기가 잘 전달되지 않게 됩니다. 이러한 현상을 기울기 소실(Vanishing Gradient) 문제라고 합니다. 시그모이드 함수를 사용하는 은닉층의 개수가 다수가 될 경우에는 0에 가까운 기울기가 계속 곱해지면 앞단에서는 거의 기울기를 전파 받을 수 없게 됩니다. 다시 말해 매개변수 가 업데이트되지 않아 학습이 되지를 않습니다. 위의 그림은 은닉층이 깊은 신경망에서 기울기 소실 문제로 인해 출력층과 가까운 은닉층에서는 기울기가 잘 전파되지만, 앞단으로 갈수록 기울기가 제대로 전파되지 않는 모습을 보여줍니다. 결론적으로 시그모이드 함수를 은닉층에서 사용하는 것은 지양됩니다. 3. 하이퍼볼릭탄젠트 함수(Hyperbolic tangent function) 하이퍼볼릭탄젠트 함수(tanh)는 입력값을 -1과 1사이의 값으로 변환합니다. 그래프를 그려보겠습니다. x = np.arange(-5.0, 5.0, 0.1) # -5.0부터 5.0까지 0.1 간격 생성 y = np.tanh(x) plt.plot(x, y) plt.plot([0,0],[1.0, -1.0], ':') plt.axhline(y=0, color='orange', linestyle='--') plt.title('Tanh Function') plt.show() 하이퍼볼릭탄젠트 함수도 -1과 1에 가까운 출력값을 출력할 때, 시그모이드 함수와 같은 문제가 발생합니다. 그러나 하이퍼볼릭탄젠트 함수의 경우에는 시그모이드 함수와는 달리 0을 중심으로 하고 있는데, 이 때문에 시그모이드 함수와 비교하면 반환값의 변화 폭이 더 큽니다. 그래서 시그모이드 함수보다는 기울기 소실 증상이 적은 편입니다. 그래서 은닉층에서 시그모이드 함수보다는 많이 사용됩니다. 4. 렐루 함수(ReLU) 인공 신경망에서 가장 최고의 인기를 얻고 있는 함수입니다. 수식은 ( ) m x ( , ) 로 아주 간단합니다. def relu(x): return np.maximum(0, x) x = np.arange(-5.0, 5.0, 0.1) y = relu(x) plt.plot(x, y) plt.plot([0,0],[5.0,0.0], ':') plt.title('Relu Function') plt.show() 렐루 함수는 음수를 입력하면 0을 출력하고, 양수를 입력하면 입력값을 그대로 반환합니다. 렐루 함수는 특정 양수 값에 수렴하지 않으므로 깊은 신경망에서 시그모이드 함수보다 훨씬 더 잘 작동합니다. 뿐만 아니라, 렐루 함수는 시그모이드 함수와 하이퍼볼릭탄젠트 함수와 같이 어떤 연산이 필요한 것이 아니라 단순 임계값이므로 연산 속도도 빠릅니다. 하지만 여전히 문제점이 존재하는데, 입력값이 음수 면 기울기도 0이 됩니다. 그리고 이 뉴런은 다시 회생하는 것이 매우 어렵습니다. 이 문제를 죽은 렐루(dying ReLU)라고 합니다. 5. 리키 렐루(Leaky ReLU) 죽은 렐루를 보완하기 위해 ReLU의 변형 함수들이 등장하기 시작했습니다. 변형 함수는 여러 개가 있지만 여기서는 Leaky ReLU에 대해서만 소개합니다. Leaky ReLU는 입력값이 음수일 경우에 0이 아니라 0.001과 같은 매우 작은 수를 반환하도록 되어있습니다. 수식은 ( ) m x ( x x ) 로 아주 간단합니다. a는 하이퍼 파라미터로 Leaky('새는') 정도를 결정하며 일반적으로는 0.01의 값을 가집니다. 여기서 말하는 '새는 정도'라는 것은 입력값의 음수일 때의 기울기를 비유하고 있습니다. a = 0.1 def leaky_relu(x): return np.maximum(a*x, x) x = np.arange(-5.0, 5.0, 0.1) y = leaky_relu(x) plt.plot(x, y) plt.plot([0,0],[5.0,0.0], ':') plt.title('Leaky ReLU Function') plt.show() 위의 그래프에서는 새는 모습을 확실히 보여주기 위해 a를 0.1로 잡았습니다. 위와 같이 입력값이 음수라도 기울기가 0이 되지 않으면 ReLU는 죽지 않습니다. 6. 소프트맥스 함수(Softamx function) 은닉층에서 ReLU(또는 ReLU 변형) 함수들을 사용하는 것이 일반적이지만 그렇다고 해서 앞서 배운 시그모이드 함수나 소프트맥스 함수가 사용되지 않는다는 의미는 아닙니다. 분류 문제를 로지스틱 회귀와 소프트맥스 회귀를 출력층에 적용하여 사용합니다. x = np.arange(-5.0, 5.0, 0.1) # -5.0부터 5.0까지 0.1 간격 생성 y = np.exp(x) / np.sum(np.exp(x)) plt.plot(x, y) plt.title('Softmax Function') plt.show() 소프트맥스 함수는 시그모이드 함수처럼 출력층의 뉴런에서 주로 사용되는데, 시그모이드 함수가 두 가지 선택지 중 하나를 고르는 이진 분류 (Binary Classification) 문제에 사용된다면 세 가지 이상의 (상호 배타적인) 선택지 중 하나를 고르는 다중 클래스 분류(MultiClass Classification) 문제에 주로 사용됩니다. 7. 출력층의 활성화 함수와 오차 함수의 관계 은닉층의 활성화 함수로는 ReLU 또는 Leaky ReLU와 같은 ReLU의 변형을 사용하라고 정리해 봤습니다. 그렇다면 출력층은 어떨까요? 각 문제에 따른 출력층의 활성화 함수와 비용 함수의 관계를 정리해 보면 다음과 같습니다. 이 외에도 다중 레이블 분류도 있지만 여기서는 다루지 않겠습니다. 문제 활성화 함수 비용 함수 이진 분류 시그모이드 nn.BCELoss() 다중 클래스 분류 소프트맥스 nn.CrossEntropyLoss() 회귀 없음 MSE 주의할 점은 nn.CrossEntropyLoss()는 소프트맥스 함수를 이미 포함하고 있습니다. 참고 자료 : https://excelsior-cjh.tistory.com/177 시그모이드 함수의 또 다른 문제점은 원점 중심이 아니라는 점입니다(Not zero-centered). 따라서, 평균이 0이 아니라 0.5이며, 시그모이드 함수는 항상 양수를 출력하기 때문에 출력의 가중치 합이 입력의 가중치 합보다 커질 가능성이 높습니다. 이것을 편향 이동(bias shift)이라 하며, 이러한 이유로 각 레이어를 지날 때마다 분산이 계속 커져 가장 높은 레이어에서는 활성화 함수의 출력이 0이나 1로 수렴하게 되어 기울기 소실 문제가 일어날 수 있습니다. 하이퍼볼릭탄젠트 함수는 원점 중심(zero-centered)이기 때문에, 시그모이드와 달리 편향<NAME> 일어나지 않습니다. 하지만, 하이퍼볼릭탄젠트 함수 또한 입력의 절댓값이 클 경우 -1이나 1로 수렴하게 되는데 시그모이드 함수와 마찬가지로 이때 기울기가 완만해지므로 역시나 기울기 소실 문제가 일어날 수 있습니다. 스탠퍼드 대학교의 딥 러닝 강의 cs231n에서는 ReLU를 먼저 시도해 보고, 그다음으로 LeakyReLU나 ELU 같은 ReLU의 변형들을 시도해 보며, sigmoid는 사용하지 말라고 권장합니다. 06-07 다층 퍼셉트론으로 손글씨 분류하기 이번 챕터에서는 다층 퍼셉트론을 구현하고, 딥 러닝을 통해서 숫자 필기 데이터를 분류해 봅시다. MNIST 데이터랑 다른 데이터입니다. 1. 숫자 필기 데이터 소개 숫자 필기 데이터는 사이킷런 패키지에서 제공하는 분류용 예제 데이터입니다. 0부터 9까지의 숫자를 손으로 쓴 이미지 데이터로 load_digits() 명령으로 로드할 수 있습니다. 각 이미지는 0부터 15까지의 명암을 가지는 8 × 8 = 64 픽셀 해상도의 흑백 이미지입니다. 그리고 해당 이미지가 1,797개가 있습니다. load_digits()를 통해 이미지 데이터를 로드할 수 있습니다. 로드한 전체 데이터를 digits에 저장합니다. %matplotlib inline import matplotlib.pyplot as plt # 시각화를 위한 맷플롯립 from sklearn.datasets import load_digits digits = load_digits() # 1,979개의 이미지 데이터 로드 첫 번째 샘플을 출력해 보겠습니다. .images[인덱스]를 사용하면 해당 인덱스의 이미지를 행렬로서 출력할 수 있습니다. print(digits.images[0]) [[ 0. 0. 5. 13. 9. 1. 0. 0.] [ 0. 0. 13. 15. 10. 15. 5. 0.] [ 0. 3. 15. 2. 0. 11. 8. 0.] [ 0. 4. 12. 0. 0. 8. 8. 0.] [ 0. 5. 8. 0. 0. 9. 8. 0.] [ 0. 4. 11. 0. 1. 12. 7. 0.] [ 0. 2. 14. 5. 10. 12. 0. 0.] [ 0. 0. 6. 13. 10. 0. 0. 0.]] 첫 번째 샘플이 8 × 8 행렬로 출력된 것을 볼 수 있습니다. 0을 흰색 도화지, 0보다 큰 숫자들을 검은색 점이라고 상상해 보면 숫자 0의 실루엣처럼 보입니다. 실제로 레이블도 숫자 0인지 첫 번째 샘플의 레이블을 확인해 봅시다. print(digits.target[0]) 첫 번째 샘플의 레이블은 0인 것을 확인할 수 있습니다. 이런 샘플이 몇 개 있는지 확인해 봅시다. print('전체 샘플의 수 : {}'.format(len(digits.images))) 전체 샘플의 수 : 1797 전체 샘플의 개수는 1,797개입니다. 전체 샘플 중에서 상위 5개의 샘플만 시각화해봅시다. images_and_labels = list(zip(digits.images, digits.target)) for index, (image, label) in enumerate(images_and_labels[:5]): # 5개의 샘플만 출력 plt.subplot(2, 5, index + 1) plt.axis('off') plt.imshow(image, cmap=plt.cm.gray_r, interpolation='nearest') plt.title('sample: %i' % label) 상위 5개의 샘플을 시각화해봤는데, 순서대로 숫자 0, 1, 2, 3, 4의 손글씨인 것처럼 보입니다. 상위 5개 샘플의 레이블을 확인해 보겠습니다. for i in range(5): print(i,'번 인덱스 샘플의 레이블 : ',digits.target[i]) 0 번 인덱스 샘플의 레이블 : 0 1 번 인덱스 샘플의 레이블 : 1 2 번 인덱스 샘플의 레이블 : 2 3 번 인덱스 샘플의 레이블 : 3 4 번 인덱스 샘플의 레이블 : 4 이제 훈련 데이터와 레이블을 각각 X, Y에 저장해 봅시다. digits.images는 모든 샘플을 8 × 8 행렬로 저장하고 있습니다. 더 나은 방법은 digts.data를 사용하는 것입니다. 이는 8 × 8 행렬을 전부 64차원의 벡터로 변환해서 저장한 상태입니다. digits.data를 이용해서 첫 번째 샘플을 출력해 보겠습니다. print(digits.data[0]) [ 0. 0. 5. 13. 9. 1. 0. 0. 0. 0. 13. 15. 10. 15. 5. 0. 0. 3. 15. 2. 0. 11. 8. 0. 0. 4. 12. 0. 0. 8. 8. 0. 0. 5. 8. 0. 0. 9. 8. 0. 0. 4. 11. 0. 1. 12. 7. 0. 0. 2. 14. 5. 10. 12. 0. 0. 0. 0. 6. 13. 10. 0. 0. 0.] 8 × 8 행렬이 아니라 64차원의 벡터로 저장된 것을 볼 수 있습니다. 이를 X로 저장하고, 레이블을 Y에 저장합니다. X = digits.data # 이미지. 즉, 특성 행렬 Y = digits.target # 각 이미지에 대한 레이블 2. 다층 퍼셉트론 분류기 만들기 import torch import torch.nn as nn from torch import optim model = nn.Sequential( nn.Linear(64, 32), # input_layer = 64, hidden_layer1 = 32 nn.ReLU(), nn.Linear(32, 16), # hidden_layer2 = 32, hidden_layer3 = 16 nn.ReLU(), nn.Linear(16, 10) # hidden_layer3 = 16, output_layer = 10 ) X = torch.tensor(X, dtype=torch.float32) Y = torch.tensor(Y, dtype=torch.int64) loss_fn = nn.CrossEntropyLoss() # 이 비용 함수는 소프트맥스 함수를 포함하고 있음. optimizer = optim.Adam(model.parameters()) losses = [] for epoch in range(100): optimizer.zero_grad() y_pred = model(X) # forwar 연산 loss = loss_fn(y_pred, Y) loss.backward() optimizer.step() if epoch % 10 == 0: print('Epoch {:4d}/{} Cost: {:.6f}'.format( epoch, 100, loss.item() )) losses.append(loss.item()) Epoch 0/100 Cost: 2.380815 Epoch 10/100 Cost: 2.059323 ... 중략 ... Epoch 90/100 Cost: 0.205398 plt.plot(losses) 06-08 다층 퍼셉트론으로 MNIST 분류하기 앞서 소프트맥스 회귀로 MNIST 데이터를 분류하는 실습을 해봤습니다. 소프트맥스 회귀 또한 인공 신경망이라고 볼 수 있는데, 입력층과 출력층만 존재하므로 소프트맥스 함수를 활성화 함수로 사용한 '단층 퍼셉트론'이라고 할 수 있습니다. 이번 챕터에서는 은닉층을 추가로 넣어 다층 퍼셉트론을 구현하고, 딥 러닝을 통해서 MNIST 데이터를 분류해 봅시다. MNIST 데이터에 대한 설명 : https://wikidocs.net/60324 1. 데이터 로드하기 import numpy as np import matplotlib.pyplot as plt % matplotlib inline from sklearn.datasets import fetch_openml mnist = fetch_openml('mnist_784', version=1, cache=True, as_frame=False) mnist.data[0] array([ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 3., 18., 18., 18., 126., 136., 175., 26., 166., 255., 247., 127., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 30., 36., 94., 154., 170., 253., 253., 253., 253., 253., 225., 172., 253., 242., 195., 64., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 49., 238., 253., 253., 253., 253., 253., 253., 253., 253., 251., 93., 82., 82., 56., 39., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 18., 219., 253., 253., 253., 253., 253., 198., 182., 247., 241., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 80., 156., 107., 253., 253., 205., 11., 0., 43., 154., 0., 0., 0., 0., 0., ... 중략 ... 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]) mnist.target[0] '5' mnist.target = mnist.target.astype(np.int8) X = mnist.data / 255 # 0-255값을 [0,1] 구간으로 정규화 y = mnist.target X[0] array([0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , ... 중략 ... 0. , 0. , 0.01176471, 0.07058824, 0.07058824, 0.07058824, 0.49411765, 0.53333333, 0.68627451, 0.10196078, 0.65098039, 1. , 0.96862745, 0.49803922, 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0.11764706, 0.14117647, 0.36862745, 0.60392157, 0.66666667, 0.99215686, 0.99215686, 0.99215686, 0.99215686, 0.99215686, 0.88235294, 0.6745098 , 0.99215686, 0.94901961, 0.76470588, 0.25098039, 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0.19215686, 0.93333333, 0.99215686, 0.99215686, 0.99215686, 0.99215686, 0.99215686, 0.99215686, 0.99215686, 0.99215686, 0.98431373, 0.36470588, 0.32156863, 0.32156863, 0.21960784, 0.15294118, 0. , ... 중략 ... 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. ]) y[0] plt.imshow(X[0].reshape(28, 28), cmap='gray') print("이 이미지 데이터의 레이블은 {:.0f}이다".format(y[0])) 2. 훈련 데이터와 테스트 데이터의 분리 import torch from torch.utils.data import TensorDataset, DataLoader from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=1/7, random_state=0) X_train = torch.Tensor(X_train) X_test = torch.Tensor(X_test) y_train = torch.LongTensor(y_train) y_test = torch.LongTensor(y_test) ds_train = TensorDataset(X_train, y_train) ds_test = TensorDataset(X_test, y_test) loader_train = DataLoader(ds_train, batch_size=64, shuffle=True) loader_test = DataLoader(ds_test, batch_size=64, shuffle=False) 3. 다층 퍼셉트론 from torch import nn model = nn.Sequential() model.add_module('fc1', nn.Linear(28*28*1, 100)) model.add_module('relu1', nn.ReLU()) model.add_module('fc2', nn.Linear(100, 100)) model.add_module('relu2', nn.ReLU()) model.add_module('fc3', nn.Linear(100, 10)) print(model) Sequential( (fc1): Linear(in_features=784, out_features=100, bias=True) (relu1): ReLU() (fc2): Linear(in_features=100, out_features=100, bias=True) (relu2): ReLU() (fc3): Linear(in_features=100, out_features=10, bias=True) ) from torch import optim # 오차 함수 선택 loss_fn = nn.CrossEntropyLoss() # 가중치를 학습하기 위한 최적화 기법 선택 optimizer = optim.Adam(model.parameters(), lr=0.01) def train(epoch): model.train() # 신경망을 학습 모드로 전환 # 데이터 로더에서 미니 배치를 하나씩 꺼내 학습을 수행 for data, targets in loader_train: optimizer.zero_grad() # 경사를 0으로 초기화 outputs = model(data) # 데이터를 입력하고 출력을 계산 loss = loss_fn(outputs, targets) # 출력과 훈련 데이터 정답 간의 오차를 계산 loss.backward() # 오차를 역전파 계산 optimizer.step() # 역전파 계산한 값으로 가중치를 수정 print("epoch{}완료\n".format(epoch)) def test(): model.eval() # 신경망을 추론 모드로 전환 correct = 0 # 데이터 로더에서 미니 배치를 하나씩 꺼내 추론을 수행 with torch.no_grad(): # 추론 과정에는 미분이 필요 없음 for data, targets in loader_test: outputs = model(data) # 데이터를 입력하고 출력을 계산 # 추론 계산 _, predicted = torch.max(outputs.data, 1) # 확률이 가장 높은 레이블이 무엇인지 계산 correct += predicted.eq(targets.data.view_as(predicted)).sum() # 정답과 일치한 경우 정답 카운트를 증가 # 정확도 출력 data_num = len(loader_test.dataset) # 데이터 총건수 print(' 테스트 데이터에서 예측 정확도: {}/{} ({:.0f}%)\n'.format(correct, data_num, 100. * correct / data_num)) test() 테스트 데이터에서 예측 정확도: 862/10000 (9%) for epoch in range(3): train(epoch) test() epoch0완료 epoch1완료 epoch2완료 테스트 데이터에서 예측 정확도: 9570/10000 (96%) index = 2018 model.eval() # 신경망을 추론 모드로 전환 data = X_test[index] output = model(data) # 데이터를 입력하고 출력을 계산 _, predicted = torch.max(output.data, 0) # 확률이 가장 높은 레이블이 무엇인지 계산 print("예측 결과 : {}".format(predicted)) X_test_show = (X_test[index]).numpy() plt.imshow(X_test_show.reshape(28, 28), cmap='gray') print("이 이미지 데이터의 정답 레이블은 {:.0f}입니다".format(y_test[index])) 06-09 과 적합(Overfitting)을 막는 방법들 학습 데이터에 모델이 과적합되는 현상은 모델의 성능을 떨어트리는 주요 이슈입니다. 모델이 과적합되면 훈련 데이터에 대한 정확도는 높을지라도, 새로운 데이터. 즉, 검증 데이터나 테스트 데이터에 대해서는 제대로 동작하지 않습니다. 이는 모델이 학습 데이터를 불필요할 정도로 과하게 암기하여 훈련 데이터에 포함된 노이즈까지 학습한 상태라고 해석할 수 있습니다. 이번 챕터에서는 모델의 과적합을 막을 수 있는 여러 가지 방법에 대해서 논의합니다. 특히 이 책은 딥 러닝을 다루고 있으므로, 인공 신경망의 과적합을 막는 방법에 초점을 둡니다. 1. 데이터의 양을 늘리기 모델은 데이터의 양이 적을 경우, 해당 데이터의 특정 패턴이나 노이즈까지 쉽게 암기하기 되므로 과적합 현상이 발생할 확률이 늘어납니다. 그렇기 때문에 데이터의 양을 늘릴수록 모델은 데이터의 일반적인 패턴을 학습하여 과적합을 방지할 수 있습니다. 만약, 데이터의 양이 적을 경우에는 의도적으로 기존의 데이터를 조금씩 변형하고 추가하여 데이터의 양을 늘리기도 하는데 이를 데이터 증식 또는 증강(Data Augmentation)이라고 합니다. 이미지의 경우에는 데이터 증식이 많이 사용되는데 이미지를 돌리거나 노이즈를 추가하고, 일부분을 수정하는 등으로 데이터를 증식시킵니다. 2. 모델의 복잡도 줄이기 인공 신경망의 복잡도는 은닉층(hidden layer)의 수나 매개변수의 수 등으로 결정됩니다. 과적합 현상이 포착되었을 때, 인공 신경망 모델에 대해서 할 수 있는 한 가지 조치는 인공 신경망의 복잡도를 줄이는 것입니다. 예를 들어보겠습니다. 다음과 같이 클래스를 사용하여 구현한 인공 신경망이 있다고 가정해 봅시다. class Architecture1(nn.Module): def __init__(self, input_size, hidden_size, num_classes): super(Architecture1, self).__init__() self.fc1 = nn.Linear(input_size, hidden_size) self.relu = nn.ReLU() self.fc2 = nn.Linear(hidden_size, hidden_size) self.relu = nnReLU() self.fc3 = nn.Linear(hidden_size, num_classes) def forward(self, x): out = self.fc1(x) out = self.relu(out) out = self.fc2(out) out = self.relu(out) out = self.fc3(out) return out 위 인공 신경망은 3개의 선형 레이어(Linear)를 가지고 있습니다. 위 인공 신경망이 입력 데이터에 과적합 현상을 보인다면, 다음과 같이 인공 신경망의 복잡도를 줄일 수 있습니다. class Architecture1(nn.Module): def __init__(self, input_size, hidden_size, num_classes): super(Architecture1, self).__init__() self.fc1 = nn.Linear(input_size, hidden_size) self.relu = nn.ReLU() self.fc2 = nn.Linear(hidden_size, num_classes) def forward(self, x): out = self.fc1(x) out = self.relu(out) out = self.fc2(out) return out 위 인공 신경망은 2개의 선형 레이어(Linear)를 가지고 있습니다. 인공 신경망에서는 모델에 있는 매개변수들의 수를 모델의 수용력(capacity)이라고 하기도 합니다. 3. 가중치 규제(Regularization) 적용하기 복잡한 모델이 간단한 모델보다 과적합될 가능성이 높습니다. 그리고 간단한 모델은 적은 수의 매개변수를 가진 모델을 말합니다. 복잡한 모델을 좀 더 간단하게 하는 방법으로 가중치 규제(Regularizaiton)가 있습니다. L1 규제 : 가중치 w들의 절댓값 합계를 비용 함수에 추가합니다. L1 노름이라고도 합니다. L2 규제 : 모든 가중치 w들의 제곱합을 비용 함수에 추가합니다. L2 노름이라고도 합니다. L1 규제는 기존의 비용 함수에 모든 가중치에 대해서 ∣ ∣ 를 더 한 값을 비용 함수로 하고, L2 규제는 기존의 비용 함수에 모든 가중치에 대해서 2 w를 더 한 값을 비용 함수로 합니다.는 규제의 강도를 정하는 하이퍼 파라미터입니다. 가 크다면 모델이 훈련 데이터에 대해서 적합한 매개 변수를 찾는 것보다 규제를 위해 추가된 항들을 작게 유지하는 것을 우선한다는 의미가 됩니다. 이 두 식 모두 비용 함수를 최소화하기 위해서는 가중치 w들의 값이 작아져야 한다는 특징이 있습니다. L1 규제로 예를 들어봅시다. L1 규제를 사용하면 비용 함수가 최소가 되게 하는 가중치와 편향을 찾는 동시에 가중치들의 절댓값의 합도 최소가 되어야 합니다. 이렇게 되면, 가중치 w의 값들은 0 또는 0에 가까이 작아져야 하므로 어떤 특성들은 모델을 만들 때 거의 사용되지 않게 됩니다. 예를 들어 ( ) w x + 2 2 w x + 4 4 라는 수식이 있다고 해봅시다. 여기에 L1 규제를 사용하였더니, 3 의 값이 0이 되었다고 해봅시다. 이는 3 특성은 사실 모델의 결과에 별 영향을 주지 못하는 특성임을 의미합니다. L2 규제는 L1 규제와는 달리 가중치들의 제곱을 최소화하므로 w의 값이 완전히 0이 되기보다는 0에 가까워지기는 경향을 띕니다. L1 규제는 어떤 특성들이 모델에 영향을 주고 있는지를 정확히 판단하고자 할 때 유용합니다. 만약, 이런 판단이 필요 없다면 경험적으로는 L2 규제가 더 잘 동작하므로 L2 규제를 더 권장합니다. 인공 신경망에서 L2 규제는 가중치 감쇠(weight decay)라고도 부릅니다. 파이 토치에서는 옵티마이저의 weight_decay 매개변수를 설정함으로써 L2 규제를 적용합니다. weight_decay 매개변수의 기본값은 0입니다. weight_decay 매개변수에 다른 값을 설정할 수도 있습니다. model = Architecture1(10, 20, 2) optimizer = torch.optim.Adam(model.parameters(), lr=1e-4, weight_decay=1e-5) 책에 따라서는 Regularization를 정규화로 번역하기도 하지만, 이는 정규화(Normalization)와 혼동될 수 있으므로 규제 또는 정형화라는 번역이 바람직한 것 같습니다. 정규화에 대한 설명은 링크 : http://blog.naver.com/angryking/221330145300를 참고. 인공 신경망에서 정규화(Normalization)라는 용어가 쓰이는 기법으로는 또 배치 정규화, 층 정규화 등이 있습니다. 4. 드롭아웃(Dropout) 드롭아웃은 학습 과정에서 신경망의 일부를 사용하지 않는 방법입니다. 예를 들어 드롭아웃의 비율을 0.5로 한다면 학습 과정마다 랜덤으로 절반의 뉴런을 사용하지 않고, 절반의 뉴런만을 사용합니다. 드롭아웃은 신경망 학습 시에만 사용하고, 예측 시에는 사용하지 않는 것이 일반적입니다. 학습 시에 인공 신경망이 특정 뉴런 또는 특정 조합에 너무 의존적이게 되는 것을 방지해 주고, 매번 랜덤 선택으로 뉴런들을 사용하지 않으므로 서로 다른 신경망들을 앙상블 하여 사용하는 것 같은 효과를 내어 과적합을 방지합니다. 가중치 규제 참고 링크 : https://bskyvision.com/193 06-10 기울기 소실(Gradient Vanishing)과 폭주(Exploding) 깊은 인공 신경망을 학습하다 보면 역전파 과정에서 입력층으로 갈수록 기울기(Gradient)가 점차적으로 작아지는 현상이 발생할 수 있습니다. 입력층에 가까운 층들에서 가중치들이 업데이트가 제대로 되지 않으면 결국 최적의 모델을 찾을 수 없게 됩니다. 이를 기울기 소실(Gradient Vanishing)이라고 합니다. 반대의 경우도 있습니다. 기울기가 점차 커지더니 가중치들이 비정상적으로 큰 값이 되면서 결국 발산되기도 합니다. 이를 기울기 폭주(Gradient Exploding)이라고 하며, 뒤에서 배울 순환 신경망(Recurrent Neural Network, RNN)에서 발생할 수 있습니다. 이번 챕터에서는 기울기 소실 또는 기울기 폭주를 막는 방법들에 대해서 다룹니다. 1. ReLU와 ReLU의 변형들 앞에서 배운 내용을 간단히 복습해 봅시다. 시그모이드 함수를 사용하면 입력의 절댓값이 클 경우에 시그모이드 함수의 출력값이 0 또는 1에 수렴하면서 기울기가 0에 가까워집니다. 그래서 역전파 과정에서 전파 시킬 기울기가 점차 사라져서 입력층 방향으로 갈수록 제대로 역전파가 되지 않는 기울기 소실 문제가 발생할 수 있습니다. 기울기 소실을 완화하는 가장 간단한 방법은 은닉층의 활성화 함수로 시그모이드나 하이퍼볼릭탄젠트 함수 대신에 ReLU나 ReLU의 변형 함수와 같은 Leaky ReLU를 사용하는 것입니다. 은닉층에서는 시그모이드 함수를 사용하지 마세요. Leaky ReLU를 사용하면 모든 입력값에 대해서 기울기가 0에 수렴하지 않아 죽은 ReLU 문제를 해결합니다. 은닉층에서는 ReLU나 Leaky ReLU와 같은 ReLU 함수의 변형들을 사용하세요. 2. 가중치 초기화(Weight initialization) 같은 모델을 훈련시키더라도 가중치가 초기에 어떤 값을 가졌느냐에 따라서 모델의 훈련 결과가 달라지기도 합니다. 다시 말해 가중치 초기화만 적절히 해줘도 기울기 소실 문제과 같은 문제를 완화시킬 수 있습니다. 1. 세이비어 초기화(Xavier Initialization) 논문 : http://proceedings.mlr.press/v9/glorot10a/glorot10a.pdf 2010년 세이비어 글로럿과 요슈아 벤 지 오는 가중치 초기화가 모델에 미치는 영향을 분석하여 새로운 초기화 방법을 제안했습니다. 이 초기화 방법은 제안한 사람의 이름을 따서 세이비어(Xavier Initialization) 초기화 또는 글로럿 초기화(Glorot Initialization)라고 합니다. 이 방법은 균등 분포(Uniform Distribution) 또는 정규 분포(Normal distribution)로 초기화할 때 두 가지 경우로 나뉘며, 이전 층의 뉴런 개수와 다음 층의 뉴런 개수를 가지고 식을 세웁니다. 이전 층의 뉴런의 개수를 i, 다음 층의 뉴런의 개수를 o t 이라고 해봅시다. 글로럿과 벤 지 오의 논문에서는 균등 분포를 사용하여 가중치를 초기화할 경우 다음과 같은 균등 분포 범위를 사용하라고 합니다. ∼ n f r ( 6 i + o t + n n n u) 다시 말해 n n n u 를 이라고 하였을 때, m + 사이의 균등 분포를 의미합니다. 정규 분포로 초기화할 경우에는 평균이 0이고, 표준 편차 σ가 다음을 만족하도록 합니다. = n n n u 세이비어 초기화는 여러 층의 기울기 분산 사이에 균형을 맞춰서 특정 층이 너무 주목을 받거나 다른 층이 뒤처지는 것을 막습니다. 그런데 세이비어 초기화는 시그모이드 함수나 하이퍼볼릭 탄젠트 함수와 같은 S자 형태인 활성화 함수와 함께 사용할 경우에는 좋은 성능을 보이지만, ReLU와 함께 사용할 경우에는 성능이 좋지 않습니다. ReLU 함수 또는 ReLU의 변형 함수들을 활성화 함수로 사용할 경우에는 다른 초기화 방법을 사용하는 것이 좋은데, 이를 He 초기화(He initialization)라고 합니다. 2. He 초기화(He initialization) 논문 : https://www.cv-foundation.org/openaccess/content_iccv_2015/papers/He_Delving_Deep_into_ICCV_2015_paper.pdf He 초기화(He initialization)는 세이비어 초기화와 유사하게 정규 분포와 균등 분포 두 가지 경우로 나뉩니다. 다만, He 초기화는 세이비어 초기화와 다르게 다음 층의 뉴런의 수를 반영하지 않습니다. 전과 같이 이전 층의 뉴런의 개수를 i이라고 해봅시다. He 초기화는 균등 분포로 초기화할 경우에는 다음과 같은 균등 분포 범위를 가지도록 합니다. ∼ n f r ( 6 i , + n n ) 정규 분포로 초기화할 경우에는 표준 편차 σ가 다음을 만족하도록 합니다. = n n 시그모이드 함수나 하이퍼볼릭탄젠트 함수를 사용할 경우에는 세이비어 초기화 방법이 효율적입니다. ReLU 계열 함수를 사용할 경우에는 He 초기화 방법이 효율적입니다. ReLU + He 초기화 방법이 좀 더 보편적입니다. 3. 배치 정규화(Batch Normalization) ReLU 계열의 함수와 He 초기화를 사용하는 것만으로도 어느 정도 기울기 소실과 폭주를 완화시킬 수 있지만, 이 두 방법을 사용하더라도 훈련 중에 언제든 다시 발생할 수 있습니다. 기울기 소실이나 폭주를 예방하는 또 다른 방법은 배치 정규화(Batch Normalization)입니다. 배치 정규화는 인공 신경망의 각 층에 들어가는 입력을 평균과 분산으로 정규화하여 학습을 효율적으로 만듭니다. 1. 내부 공변량 변화(Internal Covariate Shift) 배치 정규화를 이해하기 위해서는 내부 공변량 변화(Internal Covariate Shift)를 이해할 필요가 있습니다. 내부 공변량 변화란 학습 과정에서 층 별로 입력 데이터 분포가 달라지는 현상을 말합니다. 이전 층들의 학습에 의해 이전 층의 가중치 값이 바뀌게 되면, 현재 층에 전달되는 입력 데이터의 분포가 현재 층이 학습했던 시점의 분포와 차이가 발생합니다. 배치 정규화를 제안한 논문에서는 기울기 소실/폭주 등의 딥 러닝 모델의 불안전성이 층마다 입력의 분포가 달라지기 때문이라고 주장합니다. 공변량 변화는 훈련 데이터의 분포와 테스트 데이터의 분포가 다른 경우를 의미합니다. 내부 공변량 변화는 신경망 층 사이에서 발생하는 입력 데이터의 분포 변화를 의미합니다. 2. 배치 정규화(Batch Normalization) 배치 정규화(Batch Normalization)는 표현 그대로 한 번에 들어오는 배치 단위로 정규화하는 것을 말합니다. 배치 정규화는 각 층에서 활성화 함수를 통과하기 전에 수행됩니다. 배치 정규화를 요약하면 다음과 같습니다. 입력에 대해 평균을 0으로 만들고, 정규화를 합니다. 그리고 정규화 된 데이터에 대해서 스케일과 시프트를 수행합니다. 이때 두 개의 매개변수 γ와 β를 사용하는데, γ는 스케일을 위해 사용하고, β는 시프트를 하는 것에 사용하며 다음 레이어에 일정한 범위의 값들만 전달되게 합니다. 배치 정규화의 수식은 다음과 같습니다. 아래에서 N 은 배치 정규화를 의미합니다. Input : 미니 배치 = { ( ) x ( ) . . x ( ) } Output : ( ) B γ β ( ( ) ) 미니 배치에 대한 평균 B 1 ∑ = m ( ) # 미니 배치에 대한 평균 미니 배치에 대한 분산 B ← m i 1 ( ( ) μ) # 미니 배치에 대한 분산 정규화 ^ ( ) x ( ) μ σ 2 ε # 정규화 스케일 조정과 시프트 ( ) γ ^ ( ) β B γ β ( ( ) ) # 스케일 조정과 시프트 은 미니 배치에 있는 샘플의 수 B 는 미니 배치에 대한 평균. B 는 미니 배치에 대한 표준편차. ^ ( ) 은 평균이 0이고 정규화 된 입력 데이터. 은 분모가 0이 되는 것을 막는 작은 수. 보편적으로 10 5는 정규화 된 데이터에 대한 스케일 매개변수로 학습 대상 는 정규화 된 데이터에 대한 시프트 매개변수로 학습 대상 ( ) 는 스케일과 시프트를 통해 조정한 N 의 최종 결과 배치 정규화는 학습 시 배치 단위의 평균과 분산들을 차례대로 받아 이동 평균과 이동 분산을 저장해놓았다가 테스트할 때는 해당 배치의 평균과 분산을 구하지 않고 구해놓았던 평균과 분산으로 정규화를 합니다. 배치 정규화를 사용하면 시그모이드 함수나 하이퍼볼릭탄젠트 함수를 사용하더라도 기울기 소실 문제가 크게 개선됩니다. 가중치 초기화에 훨씬 덜 민감해집니다. 훨씬 큰 학습률을 사용할 수 있어 학습 속도를 개선합니다. 미니 배치마다 평균과 표준편차를 계산하므로 훈련 데이터에 일종의 잡음을 넣는 부수 효과로 과적합을 방지하는 효과도 냅니다. 하지만 부수적 효과이므로 드롭아웃과 함께 사용하는 것이 좋습니다. 배치 정규화는 모델을 복잡하게 하며, 추가 계산을 하는 것이므로 테스트 데이터에 대한 예측 시에 실행 시간이 느려집니다. 그래서 서비스 속도를 고려하는 관점에서는 배치 정규화가 꼭 필요한지 고민이 필요합니다. 배치 정규화의 효과는 굉장하지만 내부 공변량 변화 때문은 아니라는 논문도 있습니다. : https://arxiv.org/pdf/1805.11604.pdf 3) 배치 정규화의 한계 배치 정규화는 뛰어난 방법이지만 몇 가지 한계가 존재합니다. 1. 미니 배치 크기에 의존적이다. 배치 정규화는 너무 작은 배치 크기에서는 잘 동작하지 않을 수 있습니다. 단적으로 배치 크기를 1로 하게 되면 분산은 0이 됩니다. 작은 미니 배치에서는 배치 정규화의 효과가 극단적으로 작용되어 훈련에 악영향을 줄 수 있습니다. 배치 정규화를 적용할 때는 작은 미니 배치보다는 크기가 어느 정도 되는 미니 배치에서 하는 것이 좋습니다. 이처럼 배치 정규화는 배치 크기에 의존적인 면이 있습니다. 2. RNN에 적용하기 어렵다. 뒤에서 배우겠지만, RNN은 각 시점(time step)마다 다른 통계치를 가집니다. 이는 RNN에 배치 정규화를 적용하는 것을 어렵게 만듭니다. RNN에서 배치 정규화를 적용하기 위한 몇 가지 논문이 제시되어 있지만, 여기서는 이를 소개하는 대신 배치 크기에도 의존적이지 않으며, RNN에도 적용하는 것이 수월한 층 정규화(layer normalization)라는 방법을 소개하고자 합니다. 5. 층 정규화(Layer Normalization) 층 정규화를 이해하기에 앞서 배치 정규화를 시각화해보겠습니다. 다음은 이 3이고, 특성의 수가 4일 때의 배치 정규화를 보여줍니다. 미니 배치란 동일한 특성(feature) 개수들을 가진 다수의 샘플들을 의미함을 상기합시다. 반면, 층 정규화는 다음과 같습니다. 가중치 초기화 참고 자료 : http://nlp.jbnu.ac.kr/AI2019/slides/ch05-1.pdf https://reniew.github.io/13/ https://calcifer1009-dev.tistory.com/11 배치 정규화 인터넷 강의(한국어 자막) : https://www.youtube.com/watch?v=tNIpEZLv_eg https://www.youtube.com/watch? v=em6dfRxYkYU https://www.youtube.com/watch? v=nUUqwaxLnWs 배치 정규화 참고 자료 : https://light-tree.tistory.com/139 https://sacko.tistory.com/44? category=632408 http://funmv2013.blog spot.com/2016/09/batch-normalization.html https://excelsior-cjh.tistory.com/178 https://www.youtube.com/watch?v=HCEr5f-LfVE&list=PLQ28Nx3M4JrhkqBVIXg-i5_CVVoS1UzAv&index=17 07. [DL 입문 ] - 순환 신경망(Recurrent Neural Network) 이번 챕터에서는 RNN(순환 신경망)에 대해서 이해하고, RNN의 장기 의존성 문제를 보완한 LSTM, 그리고 RNN과 LSTM을 이용하여 각종 딥 러닝 실습을 진행해 보겠습니다. 07-01 순환 신경망(Recurrent Neural Network, RNN) RNN(Recurrent Neural Network)은 시퀀스(Sequence) 모델입니다. 입력과 출력을 시퀀스 단위로 처리하는 모델입니다. 번역기를 생각해 보면 입력은 번역하고자 하는 문장. 즉, 단어 시퀀스입니다. 출력에 해당되는 번역된 문장 또한 단어 시퀀스입니다. 이러한 시퀀스들을 처리하기 위해 고안된 모델들을 시퀀스 모델이라고 합니다. 그중에서도 RNN은 딥 러닝에 있어 가장 기본적인 시퀀스 모델입니다. 용어는 비슷하지만 순환 신경망과 재귀 신경망(Recursive Neural Network)은 전혀 다른 개념입니다. 1. 순환 신경망(Recurrent Neural Network, RNN) 앞서 배운 신경망들은 전부 은닉층에서 활성화 함수를 지난 값은 오직 출력층 방향으로만 향했습니다. 이와 같은 신경망들을 피드 포워드 신경망(Feed Forward Neural Network)이라고 합니다. 그런데 그렇지 않은 신경망들이 있습니다. RNN(Recurrent Neural Network) 또한 그중 하나입니다. RNN은 은닉층의 노드에서 활성화 함수를 통해 나온 결괏값을 출력층 방향으로도 보내면서, 다시 은닉층 노드의 다음 계산의 입력으로 보내는 특징을 갖고 있습니다. 이를 그림으로 표현하면 위와 같습니다.는 입력층의 입력 벡터,는 출력층의 출력 벡터입니다. 실제로는 편향 도 입력으로 존재할 수 있지만 앞으로의 그림에서는 생략합니다. RNN에서 은닉층에서 활성화 함수를 통해 결과를 내보내는 역할을 하는 노드를 셀(cell)이라고 합니다. 이 셀은 이전의 값을 기억하려고 하는 일종의 메모리 역할을 수행하므로 이를 메모리 셀 또는 RNN 셀이라고 표현합니다. 은닉층의 메모리 셀은 각각의 시점(time step)에서 바로 이전 시점에서의 은닉층의 메모리 셀에서 나온 값을 자신의 입력으로 사용하는 재귀적 활동을 하고 있습니다. 앞으로는 현재 시점을 변수 t로 표현하겠습니다. 이는 현재 시점 t에서의 메모리 셀 이 갖고 있는 값은 과거의 메모리 셀들의 값에 영향을 받은 것임을 의미합니다. 그렇다면 메모리 셀 이 갖고 있는 이 값은 뭐라고 부를까요? 메모리 셀 이 출력층 방향으로 또는 다음 시점 t+1의 자신에게 보내는 값을 은닉 상태(hidden state)라고 합니다. 다시 말해 t 시점의 메모리 셀은 t-1 시점의 메모리 셀 이 보낸 은닉 상태 값을 t 시점의 은닉 상태 계산을 위한 입력값으로 사용합니다. RNN을 표현할 때는 일반적으로 위의 그림에서 좌측과 같이 화살표로 사이클을 그려서 재귀 형태로 표현하기도 하지만, 우측과 같이 사이클을 그리는 화살표 대신 여러 시점으로 펼쳐서 표현하기도 합니다. 두 그림은 동일한 그림으로 단지 사이클을 그리는 화살표를 사용하여 표현하였느냐, 시점의 흐름에 따라서 표현하였느냐의 차이일 뿐 둘 다 동일한 RNN을 표현하고 있습니다. 피드 포워드 신경망에서는 뉴런이라는 단위를 사용했지만, RNN에서는 뉴런이라는 단위보다는 입력층과 출력층에서는 각각 입력 벡터와 출력 벡터, 은닉층에서는 은닉 상태라는 표현을 주로 사용합니다. 그래서 사실 위의 그림에서 회색과 초록색으로 표현한 각 네모들은 기본적으로 벡터 단위를 가정하고 있습니다. 피드 포워드 신경망과의 차이를 비교하기 위해서 RNN을 뉴런 단위로 시각화해보겠습니다. 위의 그림은 입력 벡터의 차원이 4, 은닉 상태의 크기가 2, 출력층의 출력 벡터의 차원이 2인 RNN이 시점이 2일 때의 모습을 보여줍니다. 다시 말해 뉴런 단위로 해석하면 입력층의 뉴런 수는 4, 은닉층의 뉴런 수는 2, 출력층의 뉴런 수는 2입니다. RNN은 입력과 출력의 길이를 다르게 설계할 수 있으므로 다양한 용도로 사용할 수 있습니다. 위 그림은 입력과 출력의 길이에 따라서 달라지는 RNN의 다양한 형태를 보여줍니다. 위 구조가 자연어 처리에서 어떻게 사용될 수 있는지 예를 들어봅시다. RNN 셀의 각 시점 별 입, 출력의 단위는 사용자가 정의하기 나름이지만 가장 보편적인 단위는 '단어 벡터'입니다. 예를 들어 하나의 입력에 대해서 여러 개의 출력(one-to-many)의 모델은 하나의 이미지 입력에 대해서 사진의 제목을 출력하는 이미지 캡셔닝(Image Captioning) 작업에 사용할 수 있습니다. 사진의 제목은 단어들의 나열이므로 시퀀스 출력입니다. 또한 단어 시퀀스에 대해서 하나의 출력(many-to-one)을 하는 모델은 입력 문서가 긍정적인지 부정적인지를 판별하는 감성 분류(sentiment classification), 또는 메일이 정상 메일인지 스팸 메일인지 판별하는 스팸 메일 분류(spam detection)에 사용할 수 있습니다. 위 그림은 RNN으로 스팸 메일을 분류할 때의 아키텍처를 보여줍니다. 다 대다(many-to-many)의 모델의 경우에는 입력 문장으로부터 대답 문장을 출력하는 챗봇과 입력 문장으로부터 번역된 문장을 출력하는 번역기, 개체명 인식이나 품사 태깅과 같은 작업이 속합니다. 위 그림은 개체명 인식을 수행할 때의 RNN 아키텍처를 보여줍니다. 이제 RNN에 대한 수식을 정의해 보겠습니다. 현재 시점 t에서의 은닉 상태 값을 t 라고 정의하겠습니다. 은닉층의 메모리 셀은 t 를 계산하기 위해서 총 두 개의 가중치를 갖게 됩니다. 하나는 입력층에서 입력값을 위한 가중치 x 이고, 하나는 이전 시점 t-1의 은닉 상태 값인 t 1 을 위한 가중치 h 입니다. 이를 식으로 표현하면 다음과 같습니다. 은닉층 : t t n ( x t W h − + ) 출력층 : t f ( y t b ) 단,는 비선형 활성화 함수 중 하나. RNN의 은닉층 연산을 벡터와 행렬 연산으로 이해할 수 있습니다. 자연어 처리에서 RNN의 입력 t 는 대부분의 경우에서 단어 벡터로 간주할 수 있는데, 단어 벡터의 차원을라고 하고, 은닉 상태의 크기를 h 라고 하였을 때 각 벡터와 행렬의 크기는 다음과 같습니다. t ( × ) x ( h d ) h ( h D) t 1 ( h 1 ) : ( h 1 ) 배치 크기가 1이고, 와 h 두 값 모두를 4로 가정하였을 때, RNN의 은닉층 연산을 그림으로 표현하면 아래와 같습니다. 이때 t 를 계산하기 위한 활성화 함수로는 주로 하이퍼볼릭탄젠트 함수(tanh)가 사용되지만, ReLU로 바꿔 사용하는 시도도 있습니다. 위의 식에서 각각의 가중치 x W, y 의 값은 모든 시점에서 값을 동일하게 공유합니다. 만약, 은닉층이 2개 이상일 경우에는 은닉층 2개의 가중치는 서로 다릅니다. 출력층은 결과값인 t 를 계산하기 위한 활성화 함수로는 상황에 따라 다를 텐데, 예를 들어서 이진 분류를 해야 하는 경우라면 시그모이드 함수를 사용할 수 있고 다양한 카테고리 중에서 선택해야 하는 문제라면 소프트맥스 함수를 사용하게 될 것입니다. 2. 파이썬으로 RNN 구현하기 직접 Numpy로 RNN 층을 구현해 보겠습니다. 앞서 메모리 셀에서 은닉 상태를 계산하는 식을 다음과 같이 정의하였습니다. t t n ( x t W h − + ) 실제 구현에 앞서 간단히 의사 코드(pseudocode)를 작성해 보겠습니다. # 아래의 코드는 의사 코드(pseudocode)로 실제 동작하는 코드가 아님. hidden_state_t = 0 # 초기 은닉 상태를 0(벡터)로 초기화 for input_t in input_length: # 각 시점마다 입력을 받는다. output_t = tanh(input_t, hidden_state_t) # 각 시점에 대해서 입력과 은닉 상태를 가지고 연산 hidden_state_t = output_t # 계산 결과는 현재 시점의 은닉 상태가 된다. 우선 t 시점의 은닉 상태를 hidden_state_t라는 변수로 선언하였고, 입력 데이터의 길이를 input_length로 선언하였습니다. 이 경우, 입력 데이터의 길이는 곧 총 시점의 수(timesteps)가 됩니다. 그리고 t 시점의 입력값을 input_t로 선언하였습니다. 각 메모리 셀은 각 시점마다 input_t와 hidden_sate_t(이전 상태의 은닉 상태)를 입력으로 활성화 함수인 하이퍼볼릭탄젠트 함수를 통해 현시점의 hidden_state_t를 계산합니다. 의사 코드를 통해 간단히 개념 정립을 해보았습니다. 이제 RNN 층을 실제 동작되는 코드로 구현해 보겠습니다. 아래의 코드는 이해를 돕기 위해 (timesteps, input_size) 크기의 2D 텐서를 입력으로 받았다고 가정하였으나, 실제로 파이 토치에서는 (batch_size, timesteps, input_size)의 크기의 3D 텐서를 입력으로 받는 것을 기억합시다. import numpy as np timesteps = 10 # 시점의 수. NLP에서는 보통 문장의 길이가 된다. input_size = 4 # 입력의 차원. NLP에서는 보통 단어 벡터의 차원이 된다. hidden_size = 8 # 은닉 상태의 크기. 메모리 셀의 용량이다. inputs = np.random.random((timesteps, input_size)) # 입력에 해당되는 2D 텐서 hidden_state_t = np.zeros((hidden_size,)) # 초기 은닉 상태는 0(벡터)로 초기화 # 은닉 상태의 크기 hidden_size로 은닉 상태를 만듦. 우선 시점, 입력의 차원, 은닉 상태의 크기, 그리고 초기 은닉 상태를 정의하였습니다. 현재 초기 은닉 상태는 0의 값을 가지는 벡터로 초기화가 된 상태입니다. 초기 은닉 상태를 출력해 보겠습니다. print(hidden_state_t) # 8의 크기를 가지는 은닉 상태. 현재는 초기 은닉 상태로 모든 차원이 0의 값을 가짐. [0. 0. 0. 0. 0. 0. 0. 0.] 은닉 상태의 크기를 8로 정의하였으므로 8의 차원을 가지는 0의 값으로 구성된 벡터가 출력됩니다. 이제 가중치와 편향을 정의합니다. Wx = np.random.random((hidden_size, input_size)) # (8, 4) 크기의 2D 텐서 생성. 입력에 대한 가중치. Wh = np.random.random((hidden_size, hidden_size)) # (8, 8) 크기의 2D 텐서 생성. 은닉 상태에 대한 가중치. b = np.random.random((hidden_size,)) # (8, ) 크기의 1D 텐서 생성. 이 값은 편향(bias). 가중치와 편향을 각 크기에 맞게 정의하였습니다. 가중치와 편향의 크기를 출력해 보겠습니다. print(np.shape(Wx)) print(np.shape(Wh)) print(np.shape(b)) (8, 4) (8, 8) (8, ) 각 가중치와 편향의 크기는 다음과 같습니다. Wx는 (은닉 상태의 크기 × 입력의 차원), Wh는 (은닉 상태의 크기 × 은닉 상태의 크기), b는 (은닉 상태의 크기)의 크기를 가집니다. 이제 모든 시점의 은닉 상태를 출력한다고 가정하고, RNN 층을 동작시켜봅시다. total_hidden_states = [] # 메모리 셀 동작 for input_t in inputs: # 각 시점에 따라서 입력값이 입력됨. output_t = np.tanh(np.dot(Wx, input_t) + np.dot(Wh, hidden_state_t) + b) # Wx * Xt + Wh * Ht-1 + b(bias) total_hidden_states.append(list(output_t)) # 각 시점의 은닉 상태의 값을 계속해서 축적 print(np.shape(total_hidden_states)) # 각 시점 t 별 메모리 셀의 출력의 크기는 (timestep, output_dim) hidden_state_t = output_t total_hidden_states = np.stack(total_hidden_states, axis = 0) # 출력 시 값을 깔끔하게 해준다. print(total_hidden_states) # (timesteps, output_dim)의 크기. 이 경우 (10, 8)의 크기를 가지는 메모리 셀의 2D 텐서를 출력. (1, 8) (2, 8) (3, 8) (4, 8) (5, 8) (6, 8) (7, 8) (8, 8) (9, 8) (10, 8) [[0.85575076 0.71627213 0.87703694 0.83938496 0.81045543 0.86482715 0.76387233 0.60007514] [0.99982366 0.99985897 0.99928638 0.99989791 0.99998252 0.99977656 0.99997677 0.9998397 ] [0.99997583 0.99996057 0.99972541 0.99997993 0.99998684 0.99954936 0.99997638 0.99993143] [0.99997782 0.99996494 0.99966651 0.99997989 0.99999115 0.99980087 0.99999107 0.9999622 ] [0.99997231 0.99996091 0.99976218 0.99998483 0.9999955 0.99989239 0.99999339 0.99997324] [0.99997082 0.99998754 0.99962158 0.99996278 0.99999331 0.99978731 0.99998831 0.99993414] [0.99997427 0.99998367 0.99978331 0.99998173 0.99999579 0.99983689 0.99999058 0.99995531] [0.99992591 0.99996115 0.99941212 0.99991593 0.999986 0.99966571 0.99995842 0.99987795] [0.99997139 0.99997192 0.99960794 0.99996751 0.99998795 0.9996674 0.99998177 0.99993016] [0.99997659 0.99998915 0.99985392 0.99998726 0.99999773 0.99988295 0.99999316 0.99996326]] 3. 파이 토치의 nn.RNN() 파이 토치에서는 nn.RNN()을 통해서 RNN 셀을 구현합니다. 실습을 통해 이해해 봅시다. 우선 필요한 파이 토치의 도구들을 임포트 합니다. import torch import torch.nn as nn 이제 입력의 크기와 은닉 상태의 크기를 정의합니다. 은닉 상태의 크기는 대표적인 RNN의 하이퍼 파라미터입니다. 여기서 입력의 크기는 매 시점마다 들어가는 입력의 크기를 의미합니다. input_size = 5 # 입력의 크기 hidden_size = 8 # 은닉 상태의 크기 이제 입력 텐서를 정의합니다. 입력 텐서는 (배치 크기 × 시점의 수 × 매 시점마다 들어가는 입력)의 크기를 가집니다. 여기서는 배치 크기는 1, 10번의 시점 동안 5차원의 입력 벡터가 들어가도록 텐서를 정의합니다. # (batch_size, time_steps, input_size) inputs = torch.Tensor(1, 10, 5) 이제 nn.RNN()을 사용하여 RNN의 셀을 만듭니다. 인자로 입력의 크기, 은닉 상태의 크기를 정의해 주고, batch_first=True를 통해서 입력 텐서의 첫 번째 차원이 배치 크기임을 알려줍니다. cell = nn.RNN(input_size, hidden_size, batch_first=True) 입력 텐서를 RNN 셀에 입력하여 출력을 확인해 봅시다. outputs, _status = cell(inputs) RNN 셀은 두 개의 입력을 리턴하는데, 첫 번째 리턴 값은 모든 시점(timesteps)의 은닉 상태들이며, 두 번째 리턴 값은 마지막 시점(timestep)의 은닉 상태입니다. 우선 첫 번째 리턴 값에 대해서 크기를 확인해 봅시다. print(outputs.shape) # 모든 time-step의 hidden_state torch.Size([1, 10, 8]) 첫 번째 리턴 값의 은닉 상태들은 (1, 10, 8)의 크기를 가집니다. 이는 10번의 시점 동안 8차원의 은닉 상태가 출력되었다는 의미입니다. 두 번째 리턴 값. 다시 말해 마지막 시점의 은닉 상태의 크기를 확인해 보겠습니다. print(_status.shape) # 최종 time-step의 hidden_state torch.Size([1, 1, 8]) 마지막 시점의 은닉 상태는 (1, 1, 8)의 크기를 가집니다. 4. 깊은 순환 신경망(Deep Recurrent Neural Network) 앞서 RNN도 다수의 은닉층을 가질 수 있다고 언급한 바 있습니다. 위의 그림은 순환 신경망에서 은닉층이 1개 더 추가되어 은닉층이 2개인 깊은(deep) 순환 신경망의 모습을 보여줍니다. 위의 코드에서 첫 번째 은닉층은 다음 은닉층에 모든 시점에 대해서 은닉 상태 값을 다음 은닉층으로 보내주고 있습니다. 깊은 순환 신경망을 파이 토치로 구현할 때는 nn.RNN()의 인자인 num_layers에 값을 전달하여 층을 쌓습니다. 층이 2개인 깊은 순환 신경망의 경우, 앞서 실습했던 임의의 입력에 대해서 출력이 어떻게 달라지는지 확인해 봅시다. # (batch_size, time_steps, input_size) inputs = torch.Tensor(1, 10, 5) cell = nn.RNN(input_size = 5, hidden_size = 8, num_layers = 2, batch_first=True) print(outputs.shape) # 모든 time-step의 hidden_state torch.Size([1, 10, 8]) 첫 번째 리턴 값의 크기는 층이 1개였던 RNN 셀 때와 달라지지 않았습니다. 여기서는 마지막 층의 모든 시점의 은닉 상태들입니다. print(_status.shape) # (층의 개수, 배치 크기, 은닉 상태의 크기) torch.Size([2, 1, 8]) 두 번째 리턴 값의 크기는 층이 1개였던 RNN 셀 때와 달라졌는데, 여기서 크기는 (층의 개수, 배치 크기, 은닉 상태의 크기)에 해당됩니다. 5. 양방향 순환 신경망(Bidirectional Recurrent Neural Network) 양방향 순환 신경망은 시점 t에서의 출력값을 예측할 때 이전 시점의 데이터뿐만 아니라, 이후 데이터로도 예측할 수 있다는 아이디어에 기반합니다. 영어 빈칸 채우기 문제에 비유하여 보겠습니다. Exercise is very effective at [ ] belly fat. 1) reducing 2) increasing 3) multiplying '운동은 복부 지방을 [ ] 효과적이다'라는 영어 문장이고, 정답은 reducing(줄이는 것)입니다. 그런데 위의 영어 빈칸 채우기 문제를 잘 생각해 보면 정답을 찾기 위해서는 이전에 나온 단어들만으로는 부족합니다. 목적어인 belly fat(복부 지방)를 모르는 상태라면 정답을 결정하기가 어렵습니다. 즉, RNN이 과거 시점(time step)의 데이터들을 참고해서, 찾고자 하는 정답을 예측하지만 실제 문제에서는 과거 시점의 데이터만 고려하는 것이 아니라 향후 시점의 데이터에 힌트가 있는 경우도 많습니다. 그래서 이전 시점의 데이터뿐만 아니라, 이후 시점의 데이터도 힌트로 활용하기 위해서 고안된 것이 양방향 RNN입니다. 양방향 RNN은 하나의 출력값을 예측하기 위해 기본적으로 두 개의 메모리 셀을 사용합니다. 첫 번째 메모리 셀은 앞에서 배운 것처럼 앞 시점의 은닉 상태(Forward States)를 전달받아 현재의 은닉 상태를 계산합니다. 위의 그림에서는 주황색 메모리 셀에 해당됩니다. 두 번째 메모리 셀은 앞에서 배운 것과는 다릅니다. 앞 시점의 은닉 상태가 아니라 뒤 시점의 은닉 상태(Backward States)를 전달받아 현재의 은닉 상태를 계산합니다. 위의 그림에서는 초록색 메모리 셀에 해당됩니다. 그리고 이 두 개의 값 모두가 출력층에서 출력값을 예측하기 위해 사용됩니다. 물론, 양방향 RNN도 다수의 은닉층을 가질 수 있습니다. 아래의 그림은 양방향 순환 신경망에서 은닉층이 1개 더 추가되어 은닉층이 2개인 깊은(deep) 양방향 순환 신경망의 모습을 보여줍니다. 다른 인공 신경망 모델들도 마찬가지이지만, 은닉층을 무조건 추가한다고 해서 모델의 성능이 좋아지는 것은 아닙니다. 은닉층을 추가하면, 학습할 수 있는 양이 많아지지만 또한 반대로 훈련 데이터 또한 그만큼 많이 필요합니다. 양방향 순환 신경망을 파이 토치로 구현할 때는 nn.RNN()의 인자인 bidirectional에 값을 True로 전달하면 됩니다. 이번에는 층이 2개인 깊은 순환 신경망이면서 양방향인 경우, 앞서 실습했던 임의의 입력에 대해서 출력이 어떻게 달라지는지 확인해 봅시다. # (batch_size, time_steps, input_size) inputs = torch.Tensor(1, 10, 5) cell = nn.RNN(input_size = 5, hidden_size = 8, num_layers = 2, batch_first=True, bidirectional = True) outputs, _status = cell(inputs) print(outputs.shape) # (배치 크기, 시퀀스 길이, 은닉 상태의 크기 x 2) torch.Size([1, 10, 16]) 첫 번째 리턴 값의 크기는 단뱡 RNN 셀 때보다 은닉 상태의 크기의 값이 두 배가 되었습니다. 여기서는 (배치 크기, 시퀀스 길이, 은닉 상태의 크기 x 2)의 크기를 가집니다. 이는 양방향의 은닉 상태 값들이 연결(concatenate) 되었기 때문입니다. print(_status.shape) # (층의 개수 x 2, 배치 크기, 은닉 상태의 크기) torch.Size([4, 1, 8]) 두 번째 리턴 값의 크기는 (층의 개수 x 2, 배치 크기, 은닉 상태의 크기)를 가집니다. 이는 정방향 기준으로는 마지막 시점에 해당되면서, 역방향 기준에서는 첫 번째 시점에 해당되는 시점의 출력값을 층의 개수만큼 쌓아 올린 결과값입니다. 07-02 장단기 메모리(Long Short-Term Memory, LSTM) 바닐라 아이스크림이 가장 기본적인 맛을 가진 아이스크림인 것처럼, 앞서 배운 RNN을 가장 단순한 형태의 RNN이라고 하여 바닐라 RNN(Vanilla RNN)이라고 합니다. (케 라스에서는 SimpleRNN) 바닐라 RNN 이후 바닐라 RNN의 한계를 극복하기 위한 다양한 RNN의 변형이 나왔습니다. 이번 챕터에서 배우게 될 LSTM도 그중 하나입니다. 앞으로의 설명에서 LSTM과 비교하여 RNN을 언급하는 것은 전부 바닐라 RNN을 말합니다. 1. 바닐라 RNN의 한계 앞 챕터에서 바닐라 RNN은 출력 결과가 이전의 계산 결과에 의존한다는 것을 언급한 바 있습니다. 하지만 바닐라 RNN은 비교적 짧은 시퀀스(sequence)에 대해서만 효과를 보이는 단점이 있습니다. 바닐라 RNN의 시점(time step)이 길어질수록 앞의 정보가 뒤로 충분히 전달되지 못하는 현상이 발생합니다. 위의 그림은 첫 번째 입력값인 1 의 정보량을 짙은 남색으로 표현했을 때, 색이 점차 얕아지는 것으로 시점이 지날수록 1 의 정보량이 손실되어가는 과정을 표현하였습니다. 뒤로 갈수록 1 의 정보량은 손실되고, 시점이 충분히 긴 상황에서는 1 의 전체 정보에 대한 영향력은 거의 의미가 없을 수도 있습니다. 어쩌면 가장 중요한 정보가 시점의 앞 쪽에 위치할 수도 있습니다. RNN으로 만든 언어 모델이 다음 단어를 예측하는 과정을 생각해 봅시다. 예를 들어 ''모스크바에 여행을 왔는데 건물도 예쁘고 먹을 것도 맛있었어. 그런데 글쎄 직장 상사한테 전화가 왔어. 어디냐고 묻더라고 그래서 나는 말했지. 저 여행 왔는데요. 여기 ___'' 다음 단어를 예측하기 위해서는 장소 정보가 필요합니다. 그런데 장소 정보에 해당되는 단어인 '모스크바'는 앞에 위치하고 있고, RNN이 충분한 기억력을 가지고 있지 못한다면 다음 단어를 엉뚱하게 예측합니다. 이를 장기 의존성 문제(the problem of Long-Term Dependencies)라고 합니다. 2. 바닐라 RNN 내부 열어보기 LSTM에 대해서 이해해 보기 전에 바닐라 RNN의 뚜껑을 열어보겠습니다. 위의 그림은 바닐라 RNN의 내부 구조를 보여줍니다. 이 책에서는 RNN 계열의 인공 신경망의 그림에서는 편향 를 생략합니다. 위의 그림에 편향 를 그린다면 t 옆에 tanh로 향하는 또 하나의 입력선을 그리면 됩니다. t t n ( x t W h − + ) 바닐라 RNN은 t h −이라는 두 개의 입력이 각각의 가중치와 곱해져서 메모리 셀의 입력이 됩니다. 그리고 이를 하이퍼볼릭탄젠트 함수의 입력으로 사용하고 이 값은 은닉층의 출력인 은닉 상태가 됩니다. 3. LSTM(Long Short-Term Memory) 위의 그림은 LSTM의 전체적인 내부의 모습을 보여줍니다. 전통적인 RNN의 이러한 단점을 보완한 RNN의 일종을 장단기 메모리(Long Short-Term Memory)라고 하며, 줄여서 LSTM이라고 합니다. LSTM은 은닉층의 메모리 셀에 입력 게이트, 망각 게이트, 출력 게이트를 추가하여 불필요한 기억을<NAME>고, 기억해야 할 것들을 정합니다. 요약하면 LSTM은 은닉 상태(hidden state)를 계산하는 식이 전통적인 RNN보다 조금 더 복잡해졌으며 셀 상태(cell state)라는 값을 추가하였습니다. 위의 그림에서는 t 시점의 셀 상태를 t 로 표현하고 있습니다. LSTM은 RNN과 비교하여 긴 시퀀스의 입력을 처리하는데 탁월한 성능을 보입니다. 셀 상태는 위의 그림에서 왼쪽에서 오른쪽으로 가는 굵은 선입니다. 셀 상태 또한 이전에 배운 은닉 상태처럼 이전 시점의 셀 상태가 다음 시점의 셀 상태를 구하기 위한 입력으로서 사용됩니다. 은닉 상태 값과 셀 상태 값을 구하기 위해서 새로 추가된 3개의 게이트를 사용합니다. 각 게이트는 삭제 게이트, 입력 게이트, 출력 게이트라고 부르며 이 3개의 게이트에는 공통적으로 시그모이드 함수가 존재합니다. 시그모이드 함수를 지나면 0과 1사이의 값이 나오게 되는데 이 값들을 가지고 게이트를 조절합니다. 아래의 내용을 먼저 이해하고 각 게이트에 대해서 알아보도록 하겠습니다. 이하 식에서 σ는 시그모이드 함수를 의미합니다. 이하 식에서 tanh는 하이퍼볼릭탄젠트 함수를 의미합니다. x, x, x, x는 t 와 함께 각 게이트에서 사용되는 4개의 가중치입니다. h, h, h, h는 t 1 와 함께 각 게이트에서 사용되는 4개의 가중치입니다. i b, f b는 각 게이트에서 사용되는 4개의 편향입니다. (1) 입력 게이트 t σ ( x x + h h − + i ) t t n ( x x + h h − + g ) 입력 게이트는 현재 정보를 기억하기 위한 게이트입니다. 우선 현재 시점 t의 값과 입력 게이트로 이어지는 가중치 x를 곱한 값과 이전 시점 t-1의 은닉 상태가 입력 게이트로 이어지는 가중치 h를 곱한 값을 더하여 시그모이드 함수를 지납니다. 이를 t 라고 합니다. 그리고 현재 시점 t의 값과 입력 게이트로 이어지는 가중치 x를 곱한 값과 이전 시점 t-1의 은닉 상태가 입력 게이트로 이어지는 가중치 h를 곱한 값을 더하여 하이퍼볼릭탄젠트 함수를 지납니다. 이를 t 라고 합니다. 시그모이드 함수를 지나 0과 1 사이의 값과 하이퍼볼릭탄젠트 함수를 지나 -1과 1사이의 값 두 개가 나오게 됩니다. 이 두 개의 값을 가지고 이번에 선택된 기억할 정보의 양을 정하는데, 구체적으로 어떻게 결정하는지는 아래에서 배우게 될 셀 상태 수식을 보면 됩니다. (2) 삭제 게이트 t σ ( x x + h h − + f ) 삭제 게이트는 기억을 삭제하기 위한 게이트입니다. 현재 시점 t의 값과 이전 시점 t-1의 은닉 상태가 시그모이드 함수를 지나게 됩니다. 시그모이드 함수를 지나면 0과 1 사이의 값이 나오게 되는데, 이 값이 곧 삭제 과정을 거친 정보의 양입니다. 0에 가까울수록 정보가 많이 삭제된 것이고 1에 가까울수록 정보를 온전히 기억한 것입니다. 이를 가지고 셀 상태를 구하게 되는데, 구체적으로는 아래의 셀 상태 수식을 보면 됩니다. (3) 셀 상태(장기 상태) t f ∘ t 1 i ∘ t 셀 상태 t 를 LSTM에서는 장기 상태라고 부르기도 합니다. 그렇다면 셀 상태를 구하는 방법을 알아보겠습니다. 삭제 게이트에서 일부 기억을 잃은 상태입니다. 입력 게이트에서 구한 t g 이 두 개의 값에 대해서 원소별 곱(entrywise product)을 진행합니다. 다시 말해 같은 크기의 두 행렬이 있을 때 같은 위치의 성분끼리 곱하는 것을 말합니다. 여기서는 식으로 ∘로 표현합니다. 이것이 이번에 선택된 기억할 값입니다. 입력 게이트에서 선택된 기억을 삭제 게이트의 결괏값과 더합니다. 이 값을 현재 시점 t의 셀 상태라고 하며, 이 값은 다음 t+1 시점의 LSTM 셀로 넘겨집니다. 삭제 게이트와 입력 게이트의 영향력을 이해해 봅시다. 만약 삭제 게이트의 출력값인 t 가 0이 된다면, 이전 시점의 셀 상태 값인 t 1 은 현재 시점의 셀 상태 값을 결정하기 위한 영향력이 0이 되면서, 오직 입력 게이트의 결과만이 현재 시점의 셀 상태 값 t 을 결정할 수 있습니다. 이는 삭제 게이트가 완전히 닫히고 입력 게이트를 연 상태를 의미합니다. 반대로 입력 게이트의 t 값을 0이라고 한다면, 현재 시점의 셀 상태 값 t 는 오직 이전 시점의 셀 상태 값 t 1 의 값에만 의존합니다. 이는 입력 게이트를 완전히 닫고 삭제 게이트만을 연 상태를 의미합니다. 결과적으로 삭제 게이트는 이전 시점의 입력을 얼마나 반영할지를 의미하고, 입력 게이트는 현재 시점의 입력을 얼마나 반영할지를 결정합니다. (4) 출력 게이트와 은닉 상태(단기 상태) t σ ( x x + h h − + o ) t o ∘ a h ( t ) 출력 게이트는 현재 시점 t의 값과 이전 시점 t-1의 은닉 상태가 시그모이드 함수를 지난 값입니다. 해당 값은 현재 시점 t의 은닉 상태를 결정하는 일에 쓰이게 됩니다. 은닉 상태를 단기 상태라고 하기도 합니다. 은닉 상태는 장기 상태의 값이 하이퍼볼릭탄젠트 함수를 지나 -1과 1사이의 값입니다. 해당 값은 출력 게이트의 값과 연산되면서, 값이 걸러지는 효과가 발생합니다. 단기 상태의 값은 또한 출력층으로도 향합니다. 4. 파이 토치의 nn.LSTM() 파이 토치에서 LSTM 셀을 사용하는 방법은 매우 간단합니다. 기존에 RNN 셀을 사용하려고 했을 때는 다음과 같이 사용했었습니다. nn.RNN(input_dim, hidden_size, batch_fisrt=True) LSTM 셀은 이와 유사하게 다음과 같이 사용합니다. nn.LSTM(input_dim, hidden_size, batch_fisrt=True) 참고 자료 : http://colah.github.io/posts/2015-08-Understanding-LSTMs/ https://www.quora.com/In-LSTM-how-do-you-figure-out-what-size-the-weights-are-supposed-to-be 07-03 게이트 순환 유닛(Gated Recurrent Unit, GRU) GRU(Gated Recurrent Unit)는 2014년 뉴욕대학교 조경현 교수님이 집필한 논문에서 제안되었습니다. GRU는 LSTM의 장기 의존성 문제에 대한 해결책을 유지하면서, 은닉 상태를 업데이트하는 계산을 줄였습니다. 다시 말해서, GRU는 성능은 LSTM과 유사하면서 복잡했던 LSTM의 구조를 간단화 시켰습니다. 1. GRU(Gated Recurrent Unit) LSTM에서는 출력, 입력, 삭제 게이트라는 3개의 게이트가 존재했습니다. 반면, GRU에서는 업데이트 게이트와 리셋 게이트 두 가지 게이트만이 존재합니다. GRU는 LSTM보다 학습 속도가 빠르다고 알려져 있지만 여러 평가에서 GRU는 LSTM과 비슷한 성능을 보인다고 알려져 있습니다. t σ ( x x + h h − + r ) t σ ( x x + h h − + z ) t t n ( h ( t h − ) W g t b) t ( − t ) g + t h − GRU와 LSTM 중 어떤 것이 모델의 성능 면에서 더 낫다고 단정 지어 말할 수 없으며, 기존에 LSTM을 사용하면서 최적의 하이퍼 파라미터를 찾아낸 상황이라면 굳이 GRU로 바꿔서 사용할 필요는 없습니다. 경험적으로 데이터양이 적을 때는 매개 변수의 양이 적은 GRU가 조금 더 낫고, 데이터양이 더 많으면 LSTM이 더 낫다고도 합니다. GRU보다 LSTM에 대한 연구나 사용량이 더 많은데, 이는 LSTM이 더 먼저 나온 구조이기 때문입니다. 2. 파이 토치의 nn.GRU() 파이 토치에서 GRU 셀을 사용하는 방법은 매우 간단합니다. 기존에 RNN 셀을 사용하려고 했을 때는 다음과 같이 사용했었습니다. nn.RNN(input_dim, hidden_size, batch_fisrt=True) GRU 셀은 이와 유사하게 다음과 같이 사용합니다. nn.GRU(input_dim, hidden_size, batch_fisrt=True) 07-04 문자 단위 RNN(Char RNN) 이번 챕터에서는 모든 시점의 입력에 대해서 모든 시점에 대해서 출력을 하는 다대다 RNN을 구현해 봅시다. 다대다 RNN은 대표적으로 품사 태깅, 개체명 인식 등에서 사용됩니다. 1. 문자 단위 RNN(Char RNN) RNN의 입출력의 단위가 단어 레벨(word-level)이 아니라 문자 레벨(character-level)로 하여 RNN을 구현한다면, 이를 문자 단위 RNN이라고 합니다. RNN 구조 자체가 달라진 것은 아니고, 입, 출력의 단위가 문자로 바뀌었을 뿐입니다. 문자 단위 RNN을 다대다 구조로 구현해 봅시다. 우선 필요한 도구들을 임포트 합니다. import torch import torch.nn as nn import torch.optim as optim import numpy as np 1. 훈련 데이터 전처리하기 여기서는 문자 시퀀스 apple을 입력받으면 pple!를 출력하는 RNN을 구현해 볼 겁니다. 이렇게 구현하는 어떤 의미가 있지는 않습니다. 그저 RNN의 동작을 이해하기 위한 목적입니다. 입력 데이터와 레이블 데이터에 대해서 문자 집합(voabulary)을 만듭니다. 여기서 문자 집합은 중복을 제거한 문자들의 집합입니다. input_str = 'apple' label_str = 'pple!' char_vocab = sorted(list(set(input_str+label_str))) vocab_size = len(char_vocab) print ('문자 집합의 크기 : {}'.format(vocab_size)) 문자 집합의 크기 : 5 현재 문자 집합에는 총 5개의 문자가 있습니다. !, a, e, l, p입니다. 이제 하이퍼 파라미터를 정의해 줍니다. 이때 입력은 원-핫 벡터를 사용할 것이므로 입력의 크기는 문자 집합의 크기여야만 합니다. input_size = vocab_size # 입력의 크기는 문자 집합의 크기 hidden_size = 5 output_size = 5 learning_rate = 0.1 이제 문자 집합에 고유한 정수를 부여합니다. char_to_index = dict((c, i) for i, c in enumerate(char_vocab)) # 문자에 고유한 정수 인덱스 부여 print(char_to_index) {'!': 0, 'a': 1, 'e': 2, 'l': 3, 'p': 4} !은 0, a는 1, e는 2, l은 3, p는 4가 부여되었습니다. 나중에 예측 결과를 다시 문자 시퀀스로 보기 위해서 반대로 정수로부터 문자를 얻을 수 있는 index_to_char을 만듭니다. index_to_char={} for key, value in char_to_index.items(): index_to_char[value] = key print(index_to_char) {0: '!', 1: 'a', 2: 'e', 3: 'l', 4: 'p'} 이제 입력 데이터와 레이블 데이터의 각 문자들을 정수로 매핑합니다. x_data = [char_to_index[c] for c in input_str] y_data = [char_to_index[c] for c in label_str] print(x_data) print(y_data) [1, 4, 4, 3, 2] # a, p, p, l, e에 해당됩니다. [4, 4, 3, 2, 0] # p, p, l, e, !에 해당됩니다. 파이 토치의 nn.RNN()은 기본적으로 3차원 텐서를 입력받습니다. 그렇기 때문에 배치 차원을 추가해 줍니다. # 배치 차원 추가 # 텐서 연산인 unsqueeze(0)를 통해 해결할 수도 있었음. x_data = [x_data] y_data = [y_data] print(x_data) print(y_data) [[1, 4, 4, 3, 2]] [[4, 4, 3, 2, 0]] 입력 시퀀스의 각 문자들을 원-핫 벡터로 바꿔줍니다. x_one_hot = [np.eye(vocab_size)[x] for x in x_data] print(x_one_hot) [array([[0., 1., 0., 0., 0.], [0., 0., 0., 0., 1.], [0., 0., 0., 0., 1.], [0., 0., 0., 1., 0.], [0., 0., 1., 0., 0.]])] 입력 데이터와 레이블 데이터를 텐서로 바꿔줍니다. X = torch.FloatTensor(x_one_hot) Y = torch.LongTensor(y_data) 이제 각 텐서의 크기를 확인해 봅시다. print('훈련 데이터의 크기 : {}'.format(X.shape)) print('레이블의 크기 : {}'.format(Y.shape)) 훈련 데이터의 크기 : torch.Size([1, 5, 5]) 레이블의 크기 : torch.Size([1, 5]) 2. 모델 구현하기 이제 RNN 모델을 구현해 봅시다. 아래에서 fc는 완전 연결층(fully-connected layer)을 의미하며 출력층으로 사용됩니다. class Net(torch.nn.Module): def __init__(self, input_size, hidden_size, output_size): super(Net, self).__init__() self.rnn = torch.nn.RNN(input_size, hidden_size, batch_first=True) # RNN 셀 구현 self.fc = torch.nn.Linear(hidden_size, output_size, bias=True) # 출력층 구현 def forward(self, x): # 구현한 RNN 셀과 출력층을 연결 x, _status = self.rnn(x) x = self.fc(x) return x 클래스로 정의한 모델을 net에 저장합니다. net = Net(input_size, hidden_size, output_size) 이제 입력된 모델에 입력을 넣어서 출력의 크기를 확인해 봅시다. outputs = net(X) print(outputs.shape) # 3차원 텐서 torch.Size([1, 5, 5]) (1, 5, 5)의 크기를 가지는데 각각 배치 차원, 시점(timesteps), 출력의 크기입니다. 나중에 정확도를 측정할 때는 이를 모두 펼쳐서 계산하게 되는데, 이때는 view를 사용하여 배치 차원과 시점 차원을 하나로 만듭니다. print(outputs.view(-1, input_size).shape) # 2차원 텐서로 변환 torch.Size([5, 5]) 차원이 (5, 5)가 된 것을 볼 수 있습니다. 이제 레이블 데이터의 크기를 다시 복습 봅시다. print(Y.shape) print(Y.view(-1).shape) torch.Size([1, 5]) torch.Size([5]) 레이블 데이터는 (1, 5)의 크기를 가지는데, 마찬가지로 나중에 정확도를 측정할 때는 이걸 펼쳐서 계산할 예정입니다. 이 경우 (5)의 크기를 가지게 됩니다. 이제 옵티마이저와 손실 함수를 정의합니다. criterion = torch.nn.CrossEntropyLoss() optimizer = optim.Adam(net.parameters(), learning_rate) 총 100번의 에포크를 학습합니다. for i in range(100): optimizer.zero_grad() outputs = net(X) loss = criterion(outputs.view(-1, input_size), Y.view(-1)) # view를 하는 이유는 Batch 차원 제거를 위해 loss.backward() # 기울기 계산 optimizer.step() # 아까 optimizer 선언 시 넣어둔 파라미터 업데이트 # 아래 세 줄은 모델이 실제 어떻게 예측했는지를 확인하기 위한 코드. result = outputs.data.numpy().argmax(axis=2) # 최종 예측값인 각 time-step 별 5차원 벡터에 대해서 가장 높은 값의 인덱스를 선택 result_str = ''.join([index_to_char[c] for c in np.squeeze(result)]) print(i, "loss: ", loss.item(), "prediction: ", result, "true Y: ", y_data, "prediction str: ", result_str) 0 loss: 1.3871121406555176 prediction: [[4 4 0 4 0]] true Y: [[4, 4, 3, 2, 0]] prediction str: pp! p! ... 중략 ... 99 loss: 0.0003285939747001976 prediction: [[4 4 3 2 0]] true Y: [[4, 4, 3, 2, 0]] prediction str: pple! 07-05 문자 단위 RNN(Char RNN) - 더 많은 데이터 이번 챕터에서는 더 많은 데이터 문자 단위 RNN을 구현합니다. 1. 문자 단위 RNN(Char RNN) 우선 필요한 도구들을 임포트 합니다. import torch import torch.nn as nn import torch.optim as optim 다음과 같이 임의의 샘플을 만듭니다. 1. 훈련 데이터 전처리하기 sentence = ("if you want to build a ship, don't drum up people together to " "collect wood and don't assign them tasks and work, but rather " "teach them to long for the endless immensity of the sea.") 문자 집합을 생성하고, 각 문자에 고유한 정수를 부여합니다. char_set = list(set(sentence)) # 중복을 제거한 문자 집합 생성 char_dic = {c: i for i, c in enumerate(char_set)} # 각 문자에 정수 인코딩 print(char_dic) # 공백도 여기서는 하나의 원소 {'k': 0, 'o': 1, 'r': 2, 'a': 3, 'f': 4, 'b': 5, 'g': 6, 'w': 7, ',': 8, ' ': 9, 'h': 10, 'l': 11, "'": 12, 'e': 13, '.': 14, 'd': 15, 's': 16, 'y': 17, 'u': 18, 't': 19, 'n': 20, 'i': 21, 'm': 22, 'c': 23, 'p': 24} 각 문자에 정수가 부여되었으며, 총 25개의 문자가 존재합니다. 문자 집합의 크기를 확인해 봅시다. dic_size = len(char_dic) print('문자 집합의 크기 : {}'.format(dic_size)) 문자 집합의 크기 : 25 문자 집합의 크기는 25이며, 입력을 원-핫 벡터로 사용할 것이므로 이는 매 시점마다 들어갈 입력의 크기이기도 합니다. 이제 하이퍼 파라미터를 설정합니다. hidden_size(은닉 상태의 크기)를 입력의 크기와 동일하게 줬는데, 이는 사용자의 선택으로 다른 값을 줘도 무방합니다. 그리고 sequence_length라는 변수를 선언했는데, 우리가 앞서 만든 샘플을 10개 단위로 끊어서 샘플을 만들 예정이기 때문입니다. 이는 뒤에서 더 자세히 보겠습니다. # 하이퍼 파라미터 설정 hidden_size = dic_size sequence_length = 10 # 임의 숫자 지정 learning_rate = 0.1 다음은 임의로 지정한 sequence_length 값인 10의 단위로 샘플들을 잘라서 데이터를 만드는 모습을 보여줍니다. # 데이터 구성 x_data = [] y_data = [] for i in range(0, len(sentence) - sequence_length): x_str = sentence[i:i + sequence_length] y_str = sentence[i + 1: i + sequence_length + 1] print(i, x_str, '->', y_str) x_data.append([char_dic[c] for c in x_str]) # x str to index y_data.append([char_dic[c] for c in y_str]) # y str to index 0 if you wan -> f you want 1 f you want -> you want 2 you want -> you want t 3 you want t -> ou want to 4 ou want to -> u want to ... 중략 ... 165 ity of the -> ty of the 166 ty of the -> y of the s 167 y of the s -> of the se 168 of the se -> of the sea 169 of the sea -> f the sea. 총 170개의 샘플이 생성되었습니다. 그리고 각 샘플의 각 문자들은 고유한 정수로 인코딩이 된 상태입니다. 첫 번째 샘플의 입력 데이터와 레이블 데이터를 출력해 봅시다. print(x_data[0]) print(y_data[0]) [21, 4, 9, 17, 1, 18, 9, 7, 3, 20] # if you wan에 해당됨. [4, 9, 17, 1, 18, 9, 7, 3, 20, 19] # f you want에 해당됨. 한 칸씩 시프트 된 시퀀스가 정상적으로 출력되는 것을 볼 수 있습니다. 이제 입력 시퀀스에 대해서 원-핫 인코딩을 수행하고, 입력 데이터와 레이블 데이터를 텐서로 변환합니다. x_one_hot = [np.eye(dic_size)[x] for x in x_data] # x 데이터는 원-핫 인코딩 X = torch.FloatTensor(x_one_hot) Y = torch.LongTensor(y_data) 이제 훈련 데이터와 레이블 데이터의 크기를 확인해 봅시다. print('훈련 데이터의 크기 : {}'.format(X.shape)) print('레이블의 크기 : {}'.format(Y.shape)) 훈련 데이터의 크기 : torch.Size([170, 10, 25]) 레이블의 크기 : torch.Size([170, 10]) 원-핫 인코딩 된 결과를 보기 위해서 첫 번째 샘플만 출력해 봅시다. print(X[0]) tensor([ [0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], # i [0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], # f [0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], # 공백 [0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], # y [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0.], # o [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], # y [0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], # 공백 [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.], # w [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0.], # a [0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]]) # n 레이블 데이터의 첫 번째 샘플도 출력해 봅시다. print(Y[0]) tensor([ 1, 2, 5, 21, 14, 2, 16, 19, 9, 12]) 위 레이블 시퀀스는 f you want에 해당됩니다. 이제 모델을 설계합니다. 2. 모델 구현하기 모델은 앞서 실습한 문자 단위 RNN 챕터와 거의 동일합니다. 다만 이번에는 은닉층을 두 개 쌓을 겁니다. class Net(torch.nn.Module): def __init__(self, input_dim, hidden_dim, layers): # 현재 hidden_size는 dic_size와 같음. super(Net, self).__init__() self.rnn = torch.nn.RNN(input_dim, hidden_dim, num_layers=layers, batch_first=True) self.fc = torch.nn.Linear(hidden_dim, hidden_dim, bias=True) def forward(self, x): x, _status = self.rnn(x) x = self.fc(x) return x net = Net(dic_size, hidden_size, 2) # 이번에는 층을 두 개 쌓습니다. nn.RNN() 안에 num_layers라는 인자를 사용합니다. 이는 은닉층을 몇 개 쌓을 것인지를 의미합니다. 모델 선언 시 layers라는 인자에 2를 전달하여 은닉층을 두 개 쌓습니다. 비용 함수와 옵티마이저를 선언합니다. criterion = torch.nn.CrossEntropyLoss() optimizer = optim.Adam(net.parameters(), learning_rate) 이제 모델에 입력을 넣어서 출력의 크기를 확인해 봅시다. outputs = net(X) print(outputs.shape) # 3차원 텐서 torch.Size([170, 10, 25]) (170, 10, 25)의 크기를 가지는데 각각 배치 차원, 시점(timesteps), 출력의 크기입니다. 나중에 정확도를 측정할 때는 이를 모두 펼쳐서 계산하게 되는데, 이때는 view를 사용하여 배치 차원과 시점 차원을 하나로 만듭니다. print(outputs.view(-1, dic_size).shape) # 2차원 텐서로 변환. torch.Size([1700, 25]) 차원이 (1700, 25)가 된 것을 볼 수 있습니다. 이제 레이블 데이터의 크기를 다시 복습 봅시다. print(Y.shape) print(Y.view(-1).shape) torch.Size([170, 10]) torch.Size([1700]) 레이블 데이터는 (170, 10)의 크기를 가지는데, 마찬가지로 나중에 정확도를 측정할 때는 이걸 펼쳐서 계산할 예정입니다. 이 경우 (1700)의 크기를 가지게 됩니다. 이제 옵티마이저와 손실 함수를 정의합니다. for i in range(100): optimizer.zero_grad() outputs = net(X) # (170, 10, 25) 크기를 가진 텐서를 매 에포크마다 모델의 입력으로 사용 loss = criterion(outputs.view(-1, dic_size), Y.view(-1)) loss.backward() optimizer.step() # results의 텐서 크기는 (170, 10) results = outputs.argmax(dim=2) predict_str = "" for j, result in enumerate(results): if j == 0: # 처음에는 예측 결과를 전부 가져오지만 predict_str += ''.join([char_set[t] for t in result]) else: # 그다음에는 마지막 글자만 반복 추가 predict_str += char_set[result[-1]] print(predict_str) hahhahrrhhhahaahahhhhahhahhhhhhhhhahhahhhhhhhahrahhahhhahhhhaahhhrhahhahahhahhhhhhhhaahhhhhhhahhhhahhhhahhhrhhhhhhahhhahahhhhaahahhahhhhaahahhahahhhahhhhhhahhahahhhhhhhahhhhahhhaa ... 중략 ... p you want to build a ship, don't drum up people together to collect wood and don't assign them tasks and work, but rather teach them to long for the endless immensity of the sea. 처음에는 이상한 예측을 하지만 마지막 에포크에서는 꽤 정확한 문자을 생성하는 것을 볼 수 있습니다. 08. [DL 입문 ] - 합성곱 신경망(Convolutional Neural Network) 이번 챕터에서는 주로 이미지, 비전 분야에서 사용되는 (하지만 자연어 처리에서도 일부 사용되는) 합성곱 신경망(Convolutional Neural Network)에 대해서 배웁니다. 08-01 합성곱과 풀링(Convolution and Pooling) 합성곱 신경망(Convolutional Neural Network)은 이미지 처리에 탁월한 성능을 보이는 신경망입니다. 이번 챕터에서는 합성곱 신경망에 대해서 학습합니다. 합성곱 신경망은 크게 합성곱층과(Convolution layer)와 풀링층(Pooling layer)으로 구성됩니다. 아래의 그림은 합성곱 신경망의 일반적인 예를 보여줍니다. (http://cs231n.github.io/convolutional-networks) 위의 그림에서 CONV는 합성곱 연산을 의미하고, 합성곱 연산의 결과가 활성화 함수 ReLU를 지납니다. 이 두 과정을 합성곱층이라고 합니다. 그 후에 POOL이라는 구간을 지나는데 이는 풀링 연산을 의미하며 풀링층이라고 합니다. 이번 챕터에서는 합성곱 연산과 풀링 연산의 의미에 대해서 학습합니다. 1. 합성곱 신경망의 대두 합성곱 신경망은 이미지 처리에 탁월한 성능을 보이는 신경망입니다. 이미지 처리를 하기 위해서 앞서 배운 다층 퍼셉트론을 사용할 수는 있지만 한계가 있었습니다. 예를 들어, 알파벳 손글씨를 분류하는 어떤 문제가 있다고 해봅시다. 아래의 그림은 알파벳 Y를 비교적 정자로 쓴 손글씨와 다소 휘갈겨 쓴 손글씨 두 개를 2차원 텐서인 행렬로 표현한 것입니다. 사람이 보기에는 두 그림 모두 알파벳 Y로 손쉽게 판단이 가능하지만, 기계가 보기에는 각 픽셀마다 가진 값이 거의 상이하므로 완전히 다른 값을 가진 입력입니다. 그런데 이미지라는 것은 위와 같이 같은 대상이라도 휘어지거나, 이동되었거나, 방향이 뒤틀렸거나 등 다양한 변형이 존재합니다. 다층 퍼셉트론은 몇 가지 픽셀만 값이 달라져도 민감하게 예측에 영향을 받는다는 단점이 있습니다. 좀 더 구체적으로 보겠습니다. 위 손글씨를 다층 퍼셉트론으로 분류한다고 하면, 이미지를 1차원 텐서인 벡터로 변환하고 다층 퍼셉트론의 입력층으로 사용해야 합니다. 두 번째 손글씨를 다층 퍼셉트론으로 분류하기 위해서 벡터로 바꾸면 다음과 같습니다. 1차원으로 변환된 결과는 사람이 보기에도 이게 원래 어떤 이미지였는지 알아보기가 어렵습니다. 이는 기계도 마찬가지입니다. 위와 같이 결과는 변환 전에 가지고 있던 공간적인 구조(spatial structure) 정보가 유실된 상태입니다. 여기서 공간적인 구조 정보라는 것은 거리가 가까운 어떤 픽셀들끼리는 어떤 연관이 있고, 어떤 픽셀들끼리는 값이 비슷하거나 등을 포함하고 있습니다. 결국 이미지의 공간적인 구조 정보를 보존하면서 학습할 수 있는 방법이 필요해졌고, 이를 위해 사용하는 것이 합성곱 신경망입니다. 2. 채널(Channel) 이미지 처리의 기본적인 용어인 채널에 대해서 간단히 정의하겠습니다. 기계는 글자나 이미지보다 숫자. 다시 말해, 텐서를 더 잘 처리할 수 있습니다. 이미지는 (높이, 너비, 채널)이라는 3차원 텐서입니다. 여기서 높이는 이미지의 세로 방향 픽셀 수, 너비는 이미지의 가로 방향 픽셀 수, 채널은 색 성분을 의미합니다. 흑백 이미지는 채널 수가 1이며, 각 픽셀은 0부터 255 사이의 값을 가집니다. 아래는 28 × 28 픽셀의 손글씨 데이터를 보여줍니다. 위 손글씨 데이터는 흑백 이미지므로 채널 수가 1임을 고려하면 (28 × 28 × 1)의 크기를 가지는 3차원 텐서입니다. 그렇다면 흑백이 아니라 우리가 통상적으로 접하게 되는 컬러 이미지는 어떨까요? 컬러 이미지는 적색(Red), 녹색(Green), 청색(Blue) 채널 수가 3개입니다. 하나의 픽셀은 세 가지 색깔, 삼원색의 조합으로 이루어집니다. 만약, 높이가 28, 너비가 28인 컬러 이미지가 있다면 이 이미지의 텐서는 (28 × 28 × 3)의 크기를 가지는 3차원 텐서입니다. 채널은 때로는 깊이(depth)라고도 합니다. 이 경우 이미지는 (높이, 너비, 깊이)라는 3차원 텐서로 표현된다고 말할 수 있을 겁니다. 3. 합성곱 연산(Convolution operation) 합성곱층은 합성곱 연산을 통해서 이미지의 특징을 추출하는 역할을 합니다. 우선, 합성곱 연산에 대해서 이해해 봅시다. 합성 곱은 영어로 컨볼루션이라고도 불리는데, 커널(kernel) 또는 필터(filter)라는 × 크기의 행렬로 높이 너비 이 ( e g t ) 너 ( i t) 크기의 이미지를 처음부터 끝까지 겹치며 훑으면서 × 크기의 겹쳐지는 부분의 각 이미지와 커널의 원소의 값을 곱해서 모두 더한 값을 출력으로 하는 것을 말합니다. 이때, 이미지의 가장 왼쪽 위부터 가장 오른쪽까지 순차적으로 훑습니다. 커널(kernel)은 일반적으로 3 × 3 또는 5 × 5를 사용합니다. 예를 통해 이해해 봅시다. 아래는 × 크기의 커널로 ×의 이미지 행렬에 합성곱 연산을 수행하는 과정을 보여줍니다. 한 번의 연산을 1 스텝(step)이라고 하였을 때, 합성곱 연산의 네 번째 스텝까지 이미지와 식으로 표현해 봤습니다. 1. 첫 번째 스텝 (1×1) + (2×0) + (3×1) + (2×1) + (1×0) + (0×1) + (3×0) + (0×1) + (1×0) = 6 2. 두 번째 스텝 (2×1) + (3×0) + (4×1) + (1×1) + (0×0) + (1×1) + (0×0) + (1×1) + (1×0) = 9 3. 세 번째 스텝 (3×1) + (4×0) + (5×1) + (0×1) + (1×0) + (2×1) + (1×0) + (1×1) + (0×0) = 11 4. 네 번째 스텝 (2×1) + (1×0) + (0×1) + (3×1) + (0×0) + (1×1) + (1×0) + (4×1) + (1×0) = 10 위 연산을 총 9번의 스텝까지 마쳤다고 가정하였을 때, 최종 결과는 아래와 같습니다. 위와 같이 입력으로부터 커널을 사용하여 합성곱 연산을 통해 나온 결과를 특성 맵(feature map)이라고 합니다. 위의 예제에서는 커널의 크기가 3 × 3이었지만, 커널의 크기는 사용자가 정할 수 있습니다. 또한 커널의 이동 범위가 위의 예제에서는 한 칸이었지만, 이 또한 사용자가 정할 수 있습니다. 이러한 이동 범위를 스트라이드(stride)라고 합니다. 아래의 예제는 스트라이드가 2일 경우에 5 × 5 이미지에 합성곱 연산을 수행하는 3 × 3 커널의 움직임을 보여줍니다. 최종적으로 2 × 2의 크기의 특성 맵을 얻습니다. 4. 패딩(Padding) 위의 예에서 5 × 5 이미지에 3 × 3의 커널로 합성곱 연산을 하였을 때, 스트라이드가 1일 경우에는 3 × 3의 특성 맵을 얻었습니다. 이와 같이 합성곱 연산의 결과로 얻은 특성 맵은 입력보다 크기가 작아진다는 특징이 있습니다. 만약, 합성곱 층을 여러 개 쌓았다면 최종적으로 얻은 특성 맵은 초기 입력보다 매우 작아진 상태가 돼버립니다. 합성곱 연산 이후에도 특성 맵의 크기가 입력의 크기와 동일하게 유지되도록 하고 싶다면 패딩(padding)을 사용하면 됩니다. 패딩은 (합성곱 연산을 하기 전에) 입력의 가장자리에 지정된 개수의 폭만큼 행과 열을 추가해 주는 것을 말합니다. 좀 더 쉽게 설명하면 지정된 개수의 폭만큼 테두리를 추가합니다. 주로 값을 0으로 채우는 제로 패딩(zero padding)을 사용합니다. 위의 그림은 5 × 5 이미지에 1폭짜리 제로 패딩을 사용하여 위, 아래에 하나의 행을 좌, 우에 하나의 열을 추가한 모습을 보여줍니다. 커널은 주로 3 × 3 또는 5 × 5를 사용한다고 언급한 바 있습니다. 만약 스트라이드가 1이라고 하였을 때, 3 × 3 크기의 커널을 사용한다면 1폭짜리 제로 패딩을 사용하고, 5 × 5 크기의 커널을 사용한다면 2폭짜리 제로 패딩을 사용하면 입력과 특성 맵의 크기를 보존할 수 있습니다. 예를 들어 5 × 5 크기의 이미지에 1폭짜리 제로 패딩을 하면 7 × 7 이미지가 되는데, 여기에 3 × 3의 커널을 사용하여 1 스트라이드로 합성 곱을 한 후의 특성 맵은 기존의 입력 이미지의 크기와 같은 5 × 5가 됩니다. 5. 가중치와 편향 합성곱 신경망에서의 가중치와 편향을 이해하기 위해서 우선 다층 퍼셉트론을 복습해 보겠습니다. 1. 합성곱 신경망의 가중치 다층 퍼셉트론으로 3 × 3 이미지를 처리한다고 가정해 보겠습니다. 우선 이미지를 1차원 텐서인 벡터로 만들면, 3 × 3 = 9가 되므로 입력층은 9개의 뉴런을 가집니다. 그리고 4개의 뉴런을 가지는 은닉층을 추가한다고 해보겠습니다. 이는 아래의 그림과 같습니다. 위에서 각 연결선은 가중치를 의미하므로, 위의 그림에서는 9 × 4 = 36개의 가중치를 가집니다. 이제 비교를 위해 합성곱 신경망으로 3 × 3 이미지를 처리한다고 해보겠습니다. 2 × 2 커널을 사용하고, 스트라이드는 1로 합니다. (*는 합성곱 연산을 의미합니다.) 사실 합성곱 신경망에서 가중치는 커널 행렬의 원소들입니다. 이를 인공 신경망의 형태로 표현한다면 다음과 같이 표현할 수 있습니다. 최종적으로 특성 맵을 얻기 위해서는 동일한 커널로 이미지 전체를 훑으며 합성곱 연산을 진행합니다. 결국 이미지 전체를 훑으면서 사용되는 가중치는 0 w, 2 w 4개뿐입니다. 그리고 각 합성곱 연산마다 이미지의 모든 픽셀을 사용하는 것이 아니라, 커널과 매핑되는 픽셀만을 입력으로 사용하는 것을 볼 수 있습니다. 결국 합성곱 신경망은 다층 퍼셉트론을 사용할 때보다 훨씬 적은 수의 가중치를 사용하며 공간적 구조 정보를 보존한다는 특징이 있습니다. 다층 퍼셉트론의 은닉층에서는 가중치 연산 후에 비선형성을 추가하기 위해서 활성화 함수를 통과시켰습니다. 합성곱 신경망의 은닉층에서도 마찬가지입니다. 합성곱 연산을 통해 얻은 특성 맵은 다층 퍼셉트론 때와 마찬가지로 비선형성 추가를 위해서 활성화 함수를 지나게 됩니다. 이때 렐루 함수나 렐루 함수의 변형들이 주로 사용됩니다. 은닉층에서 렐루 함수가 주로 사용되는 이유는 앞서 활성화 함수 챕터에서 다뤘습니다. 이와 같이 합성곱 연산을 통해서 특성 맵을 얻고, 활성화 함수를 지나는 연산을 하는 합성곱 신경망의 은닉층을 합성곱 신경망에서는 합성곱 층(convolution layer)이라고 합니다. 2. 합성곱 신경망의 편향 합성곱 신경망에도 편향(bias)를 당연히 추가할 수 있습니다. 만약, 편향을 사용한다면 커널을 적용한 뒤에 더해집니다. 편향은 하나의 값만 존재하며, 커널이 적용된 결과의 모든 원소에 더해집니다. 6. 특성 맵의 크기 계산 방법 입력의 크기와 커널의 크기, 그리고 스트라이드의 값만 알면 합성곱 연산의 결과인 특성 맵의 크기를 계산할 수 있습니다. h : 입력의 높이 w : 입력의 너비 h : 커널의 높이 w : 커널의 너비 : 스트라이드 h : 특성 맵의 높이 w : 특성 맵의 너비 이에 따라 특성 맵의 높이와 너비는 다음과 같습니다. h f o r ( h K S 1 ) w f o r ( w K S 1 ) 여기서 l o 함수는 소수점 발생 시 소수점 이하를 버리는 역할을 합니다. 예를 들어 위의 첫 번째 예제의 경우 5 × 5 크기의 이미지에 3 × 3 커널을 사용하고 스트라이드 1로 합성곱 연산을 했습니다. 이 경우 특성 맵의 크기는 (5 - 3 + 1 ) × (5 - 3 + 1) = 3 × 3임을 알 수 있습니다. 이는 또한 총 9번의 스텝이 필요함을 의미하기도 합니다. 패딩의 폭을 라고 하고, 패딩까지 고려한 식은 다음과 같습니다. h f o r ( h K + P + ) w f o r ( w K + P + ) 7. 다수의 채널을 가질 경우의 합성곱 연산(3차원 텐서의 합성곱 연산) 지금까지는 채널(channel) 또는 깊이(depth)를 고려하지 않고, 2차원 텐서를 가정하고 설명했습니다. 하지만 실제로 합성곱 연산의 입력은 '다수의 채널을 가진' 이미지 또는 이전 연산의 결과로 나온 특성 맵일 수 있습니다. 만약, 다수의 채널을 가진 입력 데이터를 가지고 합성곱 연산을 한다고 하면 커널의 채널 수도 입력의 채널 수만큼 존재해야 합니다. 다시 말해 입력 데이터의 채널 수와 커널의 채널 수는 같아야 합니다. 채널 수가 같으므로 합성곱 연산을 채널마다 수행합니다. 그리고 그 결과를 모두 더하여 최종 특성 맵을 얻습니다. 위 그림은 3개의 채널을 가진 입력 데이터와 3개의 채널을 가진 커널의 합성곱 연산을 보여줍니다. 커널의 각 채널끼리의 크기는 같아야 합니다. 각 채널 간 합성곱 연산을 마치고, 그 결과를 모두 더해서 하나의 채널을 가지는 특성 맵을 만듭니다. 주의할 점은 위의 연산에서 사용되는 커널은 3개의 커널이 아니라 3개의 채널을 가진 1개의 커널이라는 점입니다. 위 그림은 높이 3, 너비 3, 채널 3의 입력이 높이 2, 너비 2, 채널 3의 커널과 합성곱 연산을 하여 높이 2, 너비 2, 채널 1의 특성 맵을 얻는다는 의미입니다. 합성곱 연산의 결과로 얻은 특성 맵의 채널 차원은 RGB 채널 등과 같은 컬러의 의미를 담고 있지는 않습니다. 이제 이 연산에서 각 차원을 변수로 두고 좀 더 일반화시켜보겠습니다. 8. 3차원 텐서의 합성곱 연산 일반화를 위해 사용하는 각 변수가 의미하는 바는 다음과 같습니다. h : 입력의 높이 w : 입력의 너비 h : 커널의 높이 w : 커널의 너비 h : 특성 맵의 높이 w : 특성 맵의 너비 i : 입력 데이터의 채널 다음은 3차원 텐서의 합성곱 연산을 보여줍니다. 높이 h , 너비 w , 채널 i 의 입력 데이터는 동일한 채널 수 i 를 가지는 높이 h , 너비 w 의 커널과 합성곱 연산을 하여 높이 h , 너비 w , 채널 1의 특성 맵을 얻습니다. 그런데 하나의 입력에 여러 개의 커널을 사용하는 합성곱 연산을 할 수도 있습니다. 합성곱 연산에서 다수의 커널을 사용할 경우, 특성 맵의 크기가 어떻게 바뀌는지 봅시다. 다음은 o 를 합성곱 연산에 사용하는 커널의 수라고 하였을 때의 합성곱 연산 과정을 보여줍니다. 합성곱 연산에서 다수의 커널을 사용할 경우, 사용한 커널 수는 합성곱 연산의 결과로 나오는 특성 맵의 채널 수가 됩니다. 이를 이해했다면 커널의 크기와 입력 데이터의 채널 수 i 와 특성 맵(출력 데이터)의 채널 수 o 가 주어졌을 때, 가중치 매개변수의 총개수를 구할 수 있습니다. 가중치는 커널의 원소들이므로 하나의 커널의 하나의 채널은 i K 개의 매개변수를 가지고 있습니다. 그런데 합성곱 연산을 하려면 커널은 입력 데이터의 채널 수와 동일한 채널 수를 가져야 합니다. 이에 따라 하나의 커널이 가지는 매개변수의 수는 i K × i 입니다. 그런데 이러한 커널이 총 o 개가 있어야 하므로 가중치 매개변수의 총 수는 다음과 같습니다. 가중치 매개변수의 총 수 : i K × i C 9. 풀링(Pooling) 일반적으로 합성곱 층(합성곱 연산 + 활성화 함수) 다음에는 풀링 층을 추가하는 것이 일반적입니다. 풀링 층에서는 특성 맵을 다운 샘플링하여 특성 맵의 크기를 줄이는 풀링 연산이 이루어집니다. 풀링 연산에는 일반적으로 최대 풀링(max pooling)과 평균 풀링(average pooling)이 사용됩니다. 우선 최대 풀링을 통해서 풀링 연산을 이해해 봅시다. 풀링 연산에서도 합성곱 연산과 마찬가지로 커널과 스트라이드의 개념을 가집니다. 위의 그림은 스트라이드가 2일 때, 2 x 2 크기 커널로 맥스 풀링 연산을 했을 때 특성 맵이 절반의 크기로 다운 샘플링되는 것을 보여줍니다. 맥스 풀링은 커널과 겹치는 영역 안에서 최댓값을 추출하는 방식으로 다운 샘플링합니다. 다른 풀링 기법인 평균 풀링은 최댓값을 추출하는 것이 아니라 평균값을 추출하는 연산이 됩니다. 풀링 연산은 커널과 스트라이드 개념이 존재한다는 점에서 합성곱 연산과 유사하지만, 합성곱 연산과의 차이점은 학습해야 할 가중치가 없으며 연산 후에 채널 수가 변하지 않는다는 점입니다. http://taewan.kim/post/cnn/ https://ujjwalkarn.me/2016/08/11/intuitive-explanation-convnets/ https://excelsior-cjh.tistory.com/152 https://buomsoo-kim.github.io/keras/2018/04/28/Easy-deep-learning-with-Keras-7.md/ https://becominghuman.ai/not-just-introduction-to-convolutional-neural-networks-part-1-56a36b938592 https://brohrer.github.io/how_convolutional_neural_networks_work.html https://ujjwalkarn.me/2016/08/11/intuitive-explanation-convnets/ https://www.kdnuggets.com/2018/04/derivation-convolutional-neural-network-fully-connected-step-by-step.html https://www.slideshare.net/leeseungeun/cnn-vgg-72164295 08-02 CNN으로 MNIST 분류하기 이번 챕터에서는 CNN으로 MNIST를 분류해 보겠습니다. 1. 모델 이해하기 우리가 만들 모델의 아키텍처를 이해해 봅시다. 합성곱 신경망은 출처에 따라서 합성곱 층을 부르는 단위가 조금 다릅니다. 1. 첫 번째 표기 방법 합성곱(nn.Cov2d) + 활성화 함수(nn.ReLU)를 하나의 합성곱 층으로 보고, 맥스 풀링(nn.MaxPoold2d)은 풀링 층으로 별도로 명명합니다. 2. 두 번째 표기 방법 합성곱(nn.Conv2d) + 활성화 함수(nn.ReLU) + 맥스 풀링(nn.MaxPoold2d)을 하나의 합성곱 층으로 봅니다. 다시 말해 풀링도 하나의 층으로 보느냐, 안 보느냐의 문제인데 누가 옳고 틀리냐의 문제는 아니므로, 이번 챕터에서는 편의를 위해 맥스 풀링까지도 포함해서 하나의 합성곱 층으로 판단하고 정리해 보겠습니다. 다시 말해 두 번째 표기 방법을 택하겠습니다. 모델의 아키텍처는 총 3개의 층으로 구성됩니다. # 1번 레이어 : 합성곱층(Convolutional layer) 합성곱(in_channel = 1, out_channel = 32, kernel_size=3, stride=1, padding=1) + 활성화 함수 ReLU 맥스 풀링(kernel_size=2, stride=2)) # 2번 레이어 : 합성곱층(Convolutional layer) 합성곱(in_channel = 32, out_channel = 64, kernel_size=3, stride=1, padding=1) + 활성화 함수 ReLU 맥스 풀링(kernel_size=2, stride=2)) # 3번 레이어 : 전결합층(Fully-Connected layer) 특성 맵을 펼친다. # batch_size × 7 × 7 × 64 → batch_size × 3136 전결합층(뉴런 10개) + 활성화 함수 Softmax 이를 직접 구현해 보며 이해해 봅시다. 2. 모델 구현하기 위의 3개의 층을 직접 구현해 보겠습니다. 1. 필요한 도구 임포트와 입력의 정의 필요한 도구들을 임포트 합니다. import torch import torch.nn as nn 임의의 텐서를 만듭니다. 텐서의 크기는 1 × 1 × 28 × 28입니다. # 배치 크기 × 채널 × 높이(height) × 너비(widht)의 크기의 텐서를 선언 inputs = torch.Tensor(1, 1, 28, 28) print('텐서의 크기 : {}'.format(inputs.shape)) 텐서의 크기 : torch.Size([1, 1, 28, 28]) 2. 합성곱층과 풀링 선언하기 이제 첫 번째 합성곱 층을 구현해 봅시다. 1채널 짜리를 입력받아서 32채널을 뽑아내는데 커널 사이즈는 3이고 패딩은 1입니다. conv1 = nn.Conv2d(1, 32, 3, padding=1) print(conv1) Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) 이제 두 번째 합성곱 층을 구현해 봅시다. 32채널 짜리를 입력받아서 64채널을 뽑아내는데 커널 사이즈는 3이고 패딩은 1입니다. conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1) print(conv2) Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) 이제 맥스 풀링을 구현해 봅시다. 정수 하나를 인자로 넣으면 커널 사이즈와 스트라이드가 둘 다 해당 값으로 지정됩니다. pool = nn.MaxPool2d(2) print(pool) MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False) 3. 구현체를 연결하여 모델 만들기 지금까지는 선언만 한 것이고 아직 이들을 연결시키지는 않았습니다. 이들을 연결시켜서 모델을 완성시켜보겠습니다. 우선 입력을 첫 번째 합성곱층을 통과시키고 합성곱층을 통과시킨 후의 텐서의 크기를 보겠습니다. out = conv1(inputs) print(out.shape) torch.Size([1, 32, 28, 28]) 32채널의 28너비 28높이의 텐서가 되었습니다. 32가 나온 이유는 conv1의 out_channel로 32를 지정해 주었기 때문입니다. 또한, 28너비 28높이가 된 이유는 패딩을 1폭으로 하고 3 × 3 커널을 사용하면 크기가 보존되기 때문입니다. 이제 이를 맥스 풀링을 통과시키고 맥스 풀링을 통과한 후의 텐서의 크기를 보겠습니다. out = pool(out) print(out.shape) torch.Size([1, 32, 14, 14]) 32채널의 14너비 14높이의 텐서가 되었습니다. 이제 이를 다시 두 번째 합성곱층에 통과시키고 통과한 후의 텐서의 크기를 보겠습니다. out = conv2(out) print(out.shape) torch.Size([1, 64, 14, 14]) 64채널의 14너비 14높이의 텐서가 되었습니다. 64가 나온 이유는 conv2의 out_channel로 64를 지정해 주었기 때문입니다. 또한, 14너비 14높이가 된 이유는 패딩을 1폭으로 하고 3 × 3 커널을 사용하면 크기가 보존되기 때문입니다. 이제 이를 맥스 풀링을 통과시키고 맥스 풀링을 통과한 후의 텐서의 크기를 보겠습니다. 이제 이를 맥스 풀링을 통과시키고 맥스 풀링을 통과한 후의 텐서의 크기를 보겠습니다. out = pool(out) print(out.shape) torch.Size([1, 64, 7, 7]) 이제 이 텐서를 펼치는 작업을 할 겁니다. 그런데 펼치기에 앞서 텐서의 n 번째 차원을 접근하게 해주는. size(n)에 대해서 배워보겠습니다. 현재 out의 크기는 1 × 64 × 7 × 7입니다. out의 첫 번째 차원이 몇인지 출력해 보겠습니다. out.size(0) out의 첫 번째 차원은 1입니다. 두 번째 차원이 몇인지 출력해 보겠습니다. out.size(1) 64 out의 두 번째 차원은 64입니다. 세 번째 차원이 몇인지 출력해 보겠습니다. out.size(2) 마찬가지로 out의 네 번째 차원을 출력해 보겠습니다. out.size(3) 이제 이를 가지고. view()를 사용하여 텐서를 펼치는 작업을 해보겠습니다. # 첫 번째 차원인 배치 차원은 그대로 두고 나머지는 펼쳐라 out = out.view(out.size(0), -1) print(out.shape) torch.Size([1, 3136]) 배치 차원을 제외하고 모두 하나의 차원으로 통합된 것을 볼 수 있습니다. 이제 이에 대해서 전결합층(Fully-Connteced layer)를 통과시켜보겠습니다. 출력층으로 10개의 뉴런을 배치하여 10개 차원의 텐서로 변환합니다. fc = nn.Linear(3136, 10) # input_dim = 3,136, output_dim = 10 out = fc(out) print(out.shape) torch.Size([1, 10]) 3. CNN으로 MNIST 분류하기 우선 필요한 도구들을 임포트 합니다. import torch import torchvision.datasets as dsets import torchvision.transforms as transforms import torch.nn.init 만약 GPU를 사용 가능하다면 device 값이 cuda가 되고, 아니라면 cpu가 됩니다. device = 'cuda' if torch.cuda.is_available() else 'cpu' # 랜덤 시드 고정 torch.manual_seed(777) # GPU 사용 가능일 경우 랜덤 시드 고정 if device == 'cuda': torch.cuda.manual_seed_all(777) 학습에 사용할 파라미터를 설정합니다. learning_rate = 0.001 training_epochs = 15 batch_size = 100 데이터 로더를 사용하여 데이터를 다루기 위해서 데이터 셋을 정의해 줍니다. mnist_train = dsets.MNIST(root='MNIST_data/', # 다운로드 경로 지정 train=True, # True를 지정하면 훈련 데이터로 다운로드 transform=transforms.ToTensor(), # 텐서로 변환 download=True) mnist_test = dsets.MNIST(root='MNIST_data/', # 다운로드 경로 지정 train=False, # False를 지정하면 테스트 데이터로 다운로드 transform=transforms.ToTensor(), # 텐서로 변환 download=True) 데이터 로더를 사용하여 배치 크기를 지정해 줍니다. 만약 데이터 셋과 데이터 로더가 기억이 안 난다면 '미니 배치와 데이터 로드' 챕터를 꼭 복습하세요. data_loader = torch.utils.data.DataLoader(dataset=mnist_train, batch_size=batch_size, shuffle=True, drop_last=True) 이제 클래스로 모델을 설계합니다. class CNN(torch.nn.Module): def __init__(self): super(CNN, self).__init__() # 첫 번째 층 # ImgIn shape=(?, 28, 28, 1) # Conv -> (?, 28, 28, 32) # Pool -> (?, 14, 14, 32) self.layer1 = torch.nn.Sequential( torch.nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1), torch.nn.ReLU(), torch.nn.MaxPool2d(kernel_size=2, stride=2)) # 두 번째 층 # ImgIn shape=(?, 14, 14, 32) # Conv ->(?, 14, 14, 64) # Pool ->(?, 7, 7, 64) self.layer2 = torch.nn.Sequential( torch.nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1), torch.nn.ReLU(), torch.nn.MaxPool2d(kernel_size=2, stride=2)) # 전결합층 7x7x64 inputs -> 10 outputs self.fc = torch.nn.Linear(7 * 7 * 64, 10, bias=True) # 전결합층 한정으로 가중치 초기화 torch.nn.init.xavier_uniform_(self.fc.weight) def forward(self, x): out = self.layer1(x) out = self.layer2(out) out = out.view(out.size(0), -1) # 전결합층을 위해서 Flatten out = self.fc(out) return out 모델을 정의합니다. # CNN 모델 정의 model = CNN().to(device) 비용 함수와 옵티마이저를 정의합니다. criterion = torch.nn.CrossEntropyLoss().to(device) # 비용 함수에 소프트맥스 함수 포함돼 있음. optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) 총 배치의 수를 출력해 보겠습니다. total_batch = len(data_loader) print('총 배치의 수 : {}'.format(total_batch)) 총 배치의 수 : 600 총 배치의 수는 600입니다. 그런데 배치 크기를 100으로 했으므로 결국 훈련 데이터는 총 60,000개란 의미입니다. 이제 모델을 훈련시켜보겠습니다. (시간이 꽤 오래 걸립니다.) for epoch in range(training_epochs): avg_cost = 0 for X, Y in data_loader: # 미니 배치 단위로 꺼내온다. X는 미니 배치, Y 느 ㄴ레이블. # image is already size of (28x28), no reshape # label is not one-hot encoded X = X.to(device) Y = Y.to(device) optimizer.zero_grad() hypothesis = model(X) cost = criterion(hypothesis, Y) cost.backward() optimizer.step() avg_cost += cost / total_batch print('[Epoch: {:>4}] cost = {:>.9}'.format(epoch + 1, avg_cost)) [Epoch: 1] cost = 0.224006683 [Epoch: 2] cost = 0.062186949 [Epoch: 3] cost = 0.0449030139 [Epoch: 4] cost = 0.0355709828 [Epoch: 5] cost = 0.0290450025 [Epoch: 6] cost = 0.0248527844 [Epoch: 7] cost = 0.0207189098 [Epoch: 8] cost = 0.0181982815 [Epoch: 9] cost = 0.0153046707 [Epoch: 10] cost = 0.0124179339 [Epoch: 11] cost = 0.0105423154 [Epoch: 12] cost = 0.00991860125 [Epoch: 13] cost = 0.00894770492 [Epoch: 14] cost = 0.0071221008 [Epoch: 15] cost = 0.00588585297 이제 테스트를 해보겠습니다. # 학습을 진행하지 않을 것이므로 torch.no_grad() with torch.no_grad(): X_test = mnist_test.test_data.view(len(mnist_test), 1, 28, 28).float().to(device) Y_test = mnist_test.test_labels.to(device) prediction = model(X_test) correct_prediction = torch.argmax(prediction, 1) == Y_test accuracy = correct_prediction.float().mean() print('Accuracy:', accuracy.item()) Accuracy: 0.9883000254631042 98%의 정확도를 얻습니다. 다음 챕터에서는 층을 더 쌓아보겠습니다. https://www.yceffort.kr/2019/01/29/pytorch-3-convolutional-neural-network/ 08-03 깊은 CNN으로 MNIST 분류하기 이번 챕터에서는 앞서 배운 CNN에 층을 더 추가하여 MNIST를 분류해 보겠습니다. 1. 모델 이해하기 우리가 만들 모델의 아키텍처를 이해해 봅시다. 모델의 아키텍처는 총 5개의 층으로 구성됩니다. 앞서 배운 챕터에서 1번 레이어와 2번 레이어는 동일하되, 새로운 합성곱층과 전결합층을 추가했습니다. # 1번 레이어 : 합성곱층(Convolutional layer) 합성곱(in_channel = 1, out_channel = 32, kernel_size=3, stride=1, padding=1) + 활성화 함수 ReLU 맥스 풀링(kernel_size=2, stride=2)) # 2번 레이어 : 합성곱층(Convolutional layer) 합성곱(in_channel = 32, out_channel = 64, kernel_size=3, stride=1, padding=1) + 활성화 함수 ReLU 맥스 풀링(kernel_size=2, stride=2)) # 3번 레이어 : 합성곱층(Convolutional layer) 합성곱(in_channel = 64, out_channel = 128, kernel_size=3, stride=1, padding=1) + 활성화 함수 ReLU 맥스 풀링(kernel_size=2, stride=2, padding=1)) # 4번 레이어 : 전결합층(Fully-Connected layer) 특성 맵을 펼친다. # batch_size × 4 × 4 × 128 → batch_size × 2048 전결합층(뉴런 625개) + 활성화 함수 ReLU # 5번 레이어 : 전결합층(Fully-Connected layer) 전결합층(뉴런 10개) + 활성화 함수 Softmax 2. 깊은 CNN으로 MNIST 분류하기 사실 이번 챕터의 코드는 이전 챕터에서 층이 조금 더 추가되는 것 말고는 동일합니다. import torch import torchvision.datasets as dsets import torchvision.transforms as transforms import torch.nn.init 만약 GPU를 사용 가능하다면 device 값이 cuda가 되고, 아니라면 cpu가 됩니다. device = 'cuda' if torch.cuda.is_available() else 'cpu' # 랜덤 시드 고정 torch.manual_seed(777) # GPU 사용 가능일 경우 랜덤 시드 고정 if device == 'cuda': torch.cuda.manual_seed_all(777) 학습에 사용할 파라미터를 설정합니다. learning_rate = 0.001 training_epochs = 15 batch_size = 100 데이터 로더를 사용하여 데이터를 다루기 위해서 데이터 셋을 정의해 줍니다. mnist_train = dsets.MNIST(root='MNIST_data/', # 다운로드 경로 지정 train=True, # True를 지정하면 훈련 데이터로 다운로드 transform=transforms.ToTensor(), # 텐서로 변환 download=True) mnist_test = dsets.MNIST(root='MNIST_data/', # 다운로드 경로 지정 train=False, # False를 지정하면 테스트 데이터로 다운로드 transform=transforms.ToTensor(), # 텐서로 변환 download=True) 데이터 로더를 사용하여 배치 크기를 지정해 줍니다. 만약 데이터 셋과 데이터 로더가 기억이 안 난다면 '미니 배치와 데이터 로드' 챕터를 꼭 복습하세요. data_loader = torch.utils.data.DataLoader(dataset=mnist_train, batch_size=batch_size, shuffle=True, drop_last=True) 이제 클래스로 모델을 설계합니다. class CNN(torch.nn.Module): def __init__(self): super(CNN, self).__init__() self.keep_prob = 0.5 # L1 ImgIn shape=(?, 28, 28, 1) # Conv -> (?, 28, 28, 32) # Pool -> (?, 14, 14, 32) self.layer1 = torch.nn.Sequential( torch.nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1), torch.nn.ReLU(), torch.nn.MaxPool2d(kernel_size=2, stride=2)) # L2 ImgIn shape=(?, 14, 14, 32) # Conv ->(?, 14, 14, 64) # Pool ->(?, 7, 7, 64) self.layer2 = torch.nn.Sequential( torch.nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1), torch.nn.ReLU(), torch.nn.MaxPool2d(kernel_size=2, stride=2)) # L3 ImgIn shape=(?, 7, 7, 64) # Conv ->(?, 7, 7, 128) # Pool ->(?, 4, 4, 128) self.layer3 = torch.nn.Sequential( torch.nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1), torch.nn.ReLU(), torch.nn.MaxPool2d(kernel_size=2, stride=2, padding=1)) # L4 FC 4x4x128 inputs -> 625 outputs self.fc1 = torch.nn.Linear(4 * 4 * 128, 625, bias=True) torch.nn.init.xavier_uniform_(self.fc1.weight) self.layer4 = torch.nn.Sequential( self.fc1, torch.nn.ReLU(), torch.nn.Dropout(p=1 - self.keep_prob)) # L5 Final FC 625 inputs -> 10 outputs self.fc2 = torch.nn.Linear(625, 10, bias=True) torch.nn.init.xavier_uniform_(self.fc2.weight) def forward(self, x): out = self.layer1(x) out = self.layer2(out) out = self.layer3(out) out = out.view(out.size(0), -1) # Flatten them for FC out = self.layer4(out) out = self.fc2(out) return out 모델을 정의합니다. # CNN 모델 정의 model = CNN().to(device) 비용 함수와 옵티마이저를 정의합니다. criterion = torch.nn.CrossEntropyLoss().to(device) # 비용 함수에 소프트맥스 함수 포함돼 있음. optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) 총 배치의 수를 출력해 보겠습니다. total_batch = len(data_loader) print('총 배치의 수 : {}'.format(total_batch)) 총 배치의 수 : 600 총 배치의 수는 600입니다. 그런데 배치 크기를 100으로 했으므로 결국 훈련 데이터는 총 60,000개란 의미입니다. 이제 모델을 훈련시켜보겠습니다. (시간이 꽤 오래 걸립니다.) for epoch in range(training_epochs): avg_cost = 0 for X, Y in data_loader: # 미니 배치 단위로 꺼내온다. X는 미니 배치, Y 느 ㄴ레이블. # image is already size of (28x28), no reshape # label is not one-hot encoded X = X.to(device) Y = Y.to(device) optimizer.zero_grad() hypothesis = model(X) cost = criterion(hypothesis, Y) cost.backward() optimizer.step() avg_cost += cost / total_batch print('[Epoch: {:>4}] cost = {:>.9}'.format(epoch + 1, avg_cost)) [Epoch: 1] cost = 0.17012253403663635 ... 중략 ... [Epoch: 15] cost = 0.007885557599365711 이제 테스트를 해보겠습니다. # 학습을 진행하지 않을 것이므로 torch.no_grad() with torch.no_grad(): X_test = mnist_test.test_data.view(len(mnist_test), 1, 28, 28).float().to(device) Y_test = mnist_test.test_labels.to(device) prediction = model(X_test) correct_prediction = torch.argmax(prediction, 1) == Y_test accuracy = correct_prediction.float().mean() print('Accuracy:', accuracy.item()) Accuracy: 0.9763999581336975 층을 더 깊게 쌓았는데 오히려 정확도가 줄어드는 것을 볼 수 있습니다. 결국 층을 깊게 쌓는 것도 중요하지만, 꼭 깊게 쌓는 것이 정확도를 올려주지는 않으며 효율적으로 쌓는 것도 중요하다는 의미입니다. 09. [NLP 입문 ] - 자연어 처리 기초(NLP Basics) 이번 챕터에서는 자연어 처리의 전처리 과정을 이해합니다. 03-01 토큰화(Tokenization) 자연어 처리에서 크롤링 등으로 얻어낸 코퍼스 데이터가 필요에 맞게 전처리되지 않은 상태라면, 해당 데이터를 사용하고자 하는 용도에 맞게 토큰화(tokenization) & 정제(cleaning) & 정규화(normalization) 하는 일을 하게 됩니다. 이번에는 그중에서도 토큰화에 대해서 학습합니다. 주어진 코퍼스(corpus)에서 토큰(token)이라 불리는 단위로 나누는 작업을 토큰화(tokenization)라고 합니다. 토큰의 단위가 상황에 따라 다르지만, 보통 의미 있는 단위로 토큰을 정의합니다. 여기서는 토큰화에 대한 발생할 수 있는 여러 가지 상황에 대해서 언급하여 토큰화에 대한 개념을 이해합니다. 이어서 NLTK, KoNLPY를 통해 실습을 진행하며 토큰화를 수행합니다. 1. 단어 토큰화(Word Tokenization) 토큰의 기준을 단어(word)로 하는 경우, 단어 토큰화(word tokenization)라고 합니다. 다만, 여기서 단어(word)는 단어 단위 외에도 단 어구, 의미를 갖는 문자열로도 간주되기도 합니다. 예를 들어보겠습니다. 아래의 입력으로부터 구두점(punctuation)과 같은 문자는 제외하는 간단한 단어 토큰화 작업을 해봅시다. 구두점이란 마침표(.), 콤마(,), 물음표(?), 세미콜론(;), 느낌표(!) 등과 같은 기호를 말합니다. 입력: Time is an illusion. Lunchtime double so! 이러한 입력으로부터 구두점을 제외한 토큰화 작업의 결과는 다음과 같습니다. 출력 : "Time", "is", "an", "illustion", "Lunchtime", "double", "so" 이 예제에서 토큰화 작업은 굉장히 간단합니다. 구두점을<NAME> 뒤에 띄어쓰기(whitespace)를 기준으로 잘라냈습니다. 하지만 이 예제는 토큰화의 가장 기초적인 예제를 보여준 것에 불과합니다. 보통 토큰화 작업은 단순히 구두점이나 특수문자를 전부 제거하는 정제(cleaning) 작업을 수행하는 것만으로 해결되지 않습니다. 구두점이나 특수문자를 전부 제거하면 토큰이 의미를 잃어버리는 경우가 발생하기도 합니다. 심지어 띄어쓰기 단위로 자르면 사실상 단어 토큰이 구분되는 영어와 달리, 한국어는 띄어쓰기만으로는 단어 토큰을 구분하기 어렵습니다. 그 이유는 뒤에서 언급하겠습니다. 2. 토큰화 중 생기는 선택의 순간 토큰화를 하다 보면, 예상하지 못한 경우가 있어서 토큰화의 기준을 생각해 봐야 하는 경우가 발생합니다. 물론, 이러한 선택은 해당 데이터를 가지고 어떤 용도로 사용할 것인지에 따라서 그 용도에 영향이 없는 기준으로 정하면 됩니다. 예를 들어 영어권 언어에서 아포스트로피를(')가 들어가 있는 단어는 어떻게 토큰으로 분류해야 하는지에 대한 선택의 문제를 보여드리겠습니다. 다음과 같은 문장이 있다고 해봅시다. Don't be fooled by the dark sounding name, Mr. Jone's Orphanage is as cheery as cheery goes for a pastry shop. 아포스트로피가 들어간 상황에서 Don't와 Jone's는 어떻게 토큰화할 수 있을까요? 다양한 선택지가 있습니다. Don't Don t Dont Do n't Jone's Jone s Jone Jones 이 중 사용자가 원하는 결과가 나오도록 토큰화 도구를 직접 설계할 수도 있겠지만, 기존에 공개된 도구들을 사용하였을 때의 결과가 사용자의 목적과 일치한다면 해당 도구를 사용할 수도 있을 것입니다. NLTK는 영어 코퍼스를 토큰화하기 위한 도구들을 제공합니다. 그중 word_tokenize와 WordPunctTokenizer를 사용해서 아포스트로피를 어떻게 처리하는지 확인해 보겠습니다. from nltk.tokenize import word_tokenize from nltk.tokenize import WordPunctTokenizer from tensorflow.keras.preprocessing.text import text_to_word_sequence 우선 word_tokenize를 사용해 봅시다. print('단어 토큰화 1 :',word_tokenize("Don't be fooled by the dark sounding name, Mr. Jone's Orphanage is as cheery as cheery goes for a pastry shop.")) 단어 토큰화 1 : ['Do', "n't", 'be', 'fooled', 'by', 'the', 'dark', 'sounding', 'name', ',', 'Mr.', 'Jone', "'s", 'Orphanage', 'is', 'as', 'cheery', 'as', 'cheery', 'goes', 'for', 'a', 'pastry', 'shop', '.'] word_tokenize는 Don't를 Do와 n't로 분리하였으며, 반면 Jone's는 Jone과 's로 분리한 것을 확인할 수 있습니다. 그렇다면, wordPunctTokenizer는 아포스트로피가 들어간 코퍼스를 어떻게 처리할까요? print('단어 토큰화 2 :',WordPunctTokenizer().tokenize("Don't be fooled by the dark sounding name, Mr. Jone's Orphanage is as cheery as cheery goes for a pastry shop.")) ['Don', "'", 't', 'be', 'fooled', 'by', 'the', 'dark', 'sounding', 'name', ',', 'Mr', '.', 'Jone', "'", 's', 'Orphanage', 'is', 'as', 'cheery', 'as', 'cheery', 'goes', 'for', 'a', 'pastry', 'shop', '.'] WordPunctTokenizer는 구두점을 별도로 분류하는 특징을 갖고 있기 때문에, 앞서 확인했던 word_tokenize와는 달리 Don't를 Don과 '와 t로 분리하였으며, 이와 마찬가지로 Jone's를 Jone과 '와 s로 분리한 것을 확인할 수 있습니다. 케라스 또한 토큰화 도구로서 text_to_word_sequence를 지원합니다. print('단어 토큰화 3 :',text_to_word_sequence("Don't be fooled by the dark sounding name, Mr. Jone's Orphanage is as cheery as cheery goes for a pastry shop.")) 단어 토큰화 3 : ["don't", 'be', 'fooled', 'by', 'the', 'dark', 'sounding', 'name', 'mr', "jone's", 'orphanage', 'is', 'as', 'cheery', 'as', 'cheery', 'goes', 'for', 'a', 'pastry', 'shop'] 케라스의 text_to_word_sequence는 기본적으로 모든 알파벳을 소문자로 바꾸면서 마침표나 콤마, 느낌표 등의 구두점을 제거합니다. 하지만 don't나 jone's와 같은 경우 아포스트로피는 보존하는 것을 볼 수 있습니다. 3. 토큰화에서 고려해야 할 사항 토큰화 작업을 단순하게 코퍼스에서 구두점을 제외하고 공백 기준으로 잘라내는 작업이라고 간주할 수는 없습니다. 이러한 일은 보다 섬세한 알고리즘이 필요한데 그 이유를 정리해 봅니다. 1) 구두점이나 특수 문자를 단순 제외해서는 안 된다. 갖고 있는 코퍼스에서 단어들을 걸러낼 때, 구두점이나 특수 문자를 단순히 제외하는 것은 옳지 않습니다. 코퍼스에 대한 정제 작업을 진행하다 보면, 구두점조차도 하나의 토큰으로 분류하기도 합니다. 가장 기본적인 예를 들어보자면, 마침표(.)와 같은 경우는 문장의 경계를 알 수 있는데 도움이 되므로 단어를 뽑아낼 때, 마침표(.)를 제외하지 않을 수 있습니다. 또 다른 예로 단어 자체에 구두점을 갖고 있는 경우도 있는데, m.p.h나 Ph.D나 AT&T 같은 경우가 있습니다. 또 특수 문자의 달러나 슬래시(/)로 예를 들어보면, $45.55와 같은 가격을 의미하기도 하고, 01/02/06은 날짜를 의미하기도 합니다. 보통 이런 경우 45.55를 하나로 취급하고 45와 55로 따로 분류하고 싶지는 않을 수 있습니다. 숫자 사이에 콤마(,)가 들어가는 경우도 있습니다. 보통 수치를 표현할 때는 123,456,789와 같이 세 자리 단위로 컴마가 있습니다. 2) 줄임말과 단어 내에 띄어쓰기가 있는 경우. 토큰화 작업에서 종종 영어권 언어의 아포스트로피(')는 압축된 단어를 다시 펼치는 역할을 하기도 합니다. 예를 들어 what're는 what are의 줄임말이며, we're는 we are의 줄임말입니다. 위의 예에서 re를 접어(clitic)이라고 합니다. 즉, 단어가 줄임말로 쓰일 때 생기는 형태를 말합니다. 가령 I am을 줄인 I'm이 있을 때, m을 접어라고 합니다. New York이라는 단어나 rock 'n' roll이라는 단어를 봅시다. 이 단어들은 하나의 단어이지만 중간에 띄어쓰기가 존재합니다. 사용 용도에 따라서, 하나의 단어 사이에 띄어쓰기가 있는 경우에도 하나의 토큰으로 봐야 하는 경우도 있을 수 있으므로, 토큰화 작업은 저러한 단어를 하나로 인식할 수 있는 능력도 가져야 합니다. 3) 표준 토큰화 예제 이해를 돕기 위해 표준으로 쓰이고 있는 토큰화 방법 중 하나인 Penn Treebank Tokenization의 규칙에 대해서 소개하고, 토큰화의 결과를 확인해 보겠습니다. 규칙 1. 하이픈으로 구성된 단어는 하나로<NAME>다. 규칙 2. doesn't와 같이 아포스트로피로 '접어'가 함께하는 단어는 분리해 준다. 해당 표준에 아래의 문장을 입력으로 넣어봅니다. "Starting a home-based restaurant may be an ideal. it doesn't have a food chain or restaurant of their own." from nltk.tokenize import TreebankWordTokenizer tokenizer = TreebankWordTokenizer() text = "Starting a home-based restaurant may be an ideal. it doesn't have a food chain or restaurant of their own." print('트리 뱅크 워드 토크 나이저 :',tokenizer.tokenize(text)) 트리 뱅크 워드 토크 나이저 : ['Starting', 'a', 'home-based', 'restaurant', 'may', 'be', 'an', 'ideal.', 'it', 'does', "n't", 'have', 'a', 'food', 'chain', 'or', 'restaurant', 'of', 'their', 'own', '.'] 결과를 보면, 각각 규칙 1과 규칙 2에 따라서 home-based는 하나의 토큰으로 취급하고 있으며, dosen't의 경우 does와 n't는 분리되었음을 볼 수 있습니다. 4. 문장 토큰화(Sentence Tokenization) 이번에는 토큰의 단위가 문장(sentence)일 경우를 논의해 보겠습니다. 이 작업은 갖고 있는 코퍼스 내에서 문장 단위로 구분하는 작업으로 때로는 문장 분류(sentence segmentation)라고도 부릅니다. 보통 갖고 있는 코퍼스가 정제되지 않은 상태라면, 코퍼스는 문장 단위로 구분되어 있지 않아서 이를 사용하고자 하는 용도에 맞게 문장 토큰 화가 필요할 수 있습니다. 어떻게 주어진 코퍼스로부터 문장 단위로 분류할 수 있을까요? 직관적으로 생각해 봤을 때는? 나 마침표(.)나! 기준으로 문장을 잘라내면 되지 않을까라고 생각할 수 있지만, 꼭 그렇지만은 않습니다. !나?는 문장의 구분을 위한 꽤 명확한 구분자(boundary) 역할을 하지만 마침표는 그렇지 않기 때문입니다. 마침표는 문장의 끝이 아니더라도 등장할 수 있습니다. EX1) IP 192.168.56.31 서버에 들어가서 로그 파일 저장해서 aaa@gmail.com로 결과 좀 보내줘. 그 후 점심 먹으러 가자. EX2) Since I'm actively looking for Ph.D. students, I get the same question a dozen times every year. 예를 들어 위의 예제에 마침표를 기준으로 문장 토큰화를 적용해 본다면 어떨까요? 첫 번째 예제에서는 보내줘.에서 그리고 두 번째 예제에서는 year.에서 처음으로 문장이 끝난 것으로 인식하는 것이 제대로 문장의 끝을 예측했다고 볼 수 있습니다. 하지만 단순히 마침표(.)로 문장을 구분 짓는다고 가정하면, 문장의 끝이 나오기 전에 이미 마침표가 여러 번 등장하여 예상한 결과가 나오지 않게 됩니다. 사용하는 코퍼스가 어떤 국적의 언어인지, 또는 해당 코퍼스 내에서 특수문자들이 어떻게 사용되고 있는지에 따라서 직접 규칙들을 정의해 볼 수 있겠습니다. 100% 정확도를 얻는 일은 쉬운 일이 아닌데, 갖고 있는 코퍼스 데이터에 오타나, 문장의 구성이 엉망이라면 정해놓은 규칙이 소용이 없을 수 있기 때문입니다. NLTK에서는 영어 문장의 토큰화를 수행하는 sent_tokenize를 지원하고 있습니다. NLTK를 통해 문장 토큰화를 실습해 보겠습니다. from nltk.tokenize import sent_tokenize text = "His barber kept his word. But keeping such a huge secret to himself was driving him crazy. Finally, the barber went up a mountain and almost to the edge of a cliff. He dug a hole in the midst of some reeds. He looked about, to make sure no one was near." print('문장 토큰화 1 :',sent_tokenize(text)) 문장 토큰화 1 : ['His barber kept his word.', 'But keeping such a huge secret to himself was driving him crazy.', 'Finally, the barber went up a mountain and almost to the edge of a cliff.', 'He dug a hole in the midst of some reeds.', 'He looked about, to make sure no one was near.'] 위 코드는 text에 저장된 여러 개의 문장들로부터 문장을 구분하는 코드입니다. 출력 결과를 보면 성공적으로 모든 문장을 구분해 내었음을 볼 수 있습니다. 그렇다면 이번에는 문장 중간에 마침표가 다수 등장하는 경우에 대해서도 실습해 보겠습니다. text = "I am actively looking for Ph.D. students. and you are a Ph.D student." print('문장 토큰화 2 :',sent_tokenize(text)) 문장 토큰화 2 : ['I am actively looking for Ph.D. students.', 'and you are a Ph.D student.'] NLTK는 단순히 마침표를 구분자로 하여 문장을 구분하지 않았기 때문에, Ph.D.를 문장 내의 단어로 인식하여 성공적으로 인식하는 것을 볼 수 있습니다. 한국어에 대한 문장 토큰화 도구 또한 존재합니다. 한국어의 경우에는 박상길 님이 개발한 KSS(Korean Sentence Splitter)를 추천합니다. 다음과 같이 KSS를 설치합니다. pip install kss KSS를 통해서 문장 토큰화를 진행해 보겠습니다. import kss text = '딥 러닝 자연어 처리가 재미있기는 합니다. 그런데 문제는 영어보다 한국어로 할 때 너무 어렵습니다. 이제 해보면 알걸요?' print('한국어 문장 토큰화 :',kss.split_sentences(text)) 한국어 문장 토큰화 : ['딥 러닝 자연어 처리가 재미있기는 합니다.', '그런데 문제는 영어보다 한국어로 할 때 너무 어렵습니다.', '이제 해보면 알걸요?'] 출력 결과는 정상적으로 모든 문장이 분리된 결과를 보여줍니다. 5. 한국어에서의 토큰화의 어려움. 영어는 New York과 같은 합성어나 he's 와 같이 줄임말에 대한 예외 처리만 한다면, 띄어쓰기(whitespace)를 기준으로 하는 띄어쓰기 토큰화를 수행해도 단어 토큰 화가 잘 작동합니다. 거의 대부분의 경우에서 단어 단위로 띄어쓰기가 이루어지기 때문에 띄어쓰기 토큰화와 단어 토큰 화가 거의 같기 때문입니다. 하지만 한국어는 영어와는 달리 띄어쓰기만으로는 토큰화를 하기에 부족합니다. 한국어의 경우에는 띄어쓰기 단위가 되는 단위를 '어절'이라고 하는데 어절 토큰화는 한국어 NLP에서 지양되고 있습니다. 어절 토큰화와 단어 토큰화는 같지 않기 때문입니다. 그 근본적인 이유는 한국어가 영어와는 다른 형태를 가지는 언어인 교착어라는 점에서 기인합니다. 교착어란 조사, 어미 등을 붙여서 말을 만드는 언어를 말합니다. 1) 교착어의 특성 예를 들어봅시다. 영어와는 달리 한국어에는 조사라는 것이 존재합니다. 예를 들어 한국어에 그(he/him)라는 주어나 목적어가 들어간 문장이 있다고 합시다. 이 경우, 그라는 단어 하나에도 '그가', '그에게', '그를', '그와', '그는'과 같이 다양한 조사가 '그'라는 글자 뒤에 띄어쓰기 없이 바로 붙게 됩니다. 자연어 처리를 하다 보면 같은 단어임에도 서로 다른 조사가 붙어서 다른 단어로 인식이 되면 자연어 처리가 힘들고 번거로워지는 경우가 많습니다. 대부분의 한국어 NLP에서 조사는 분리해 줄 필요가 있습니다. 띄어쓰기 단위가 영어처럼 독립적인 단어라면 띄어쓰기 단위로 토큰화를 하면 되겠지만 한국어는 어절이 독립적인 단어로 구성되는 것이 아니라 조사 등의 무언가가 붙어있는 경우가 많아서 이를 전부 분리해 줘야 한다는 의미입니다. 한국어 토큰화에서는 형태소(morpheme) 란 개념을 반드시 이해해야 합니다. 형태소(morpheme)란 뜻을 가진 가장 작은 말의 단위를 말합니다. 이 형태소에는 두 가지 형태소가 있는데 자립 형태소와 의존 형태소입니다. 자립 형태소 : 접사, 어미, 조사와 상관없이 자립하여 사용할 수 있는 형태소. 그 자체로 단어가 된다. 체언(명사, 대명사, 수사), 수식언(관형사, 부사), 감탄사 등이 있다. 의존 형태소 : 다른 형태소와 결합하여 사용되는 형태소. 접사, 어미, 조사, 어간을 말한다. 예를 들어 다음과 같은 문장이 있다고 합시다. 문장 : 에디가 책을 읽었다 이 문장을 띄어쓰기 단위 토큰화를 수행한다면 다음과 같은 결과를 얻습니다. ['에디가', '책을', '읽었다'] 하지만 이를 형태소 단위로 분해하면 다음과 같습니다. 자립 형태소 : 에디, 책 의존 형태소 : -가, -을, 읽-, -었, -다 '에디'라는 사람 이름과 '책'이라는 명사를 얻어낼 수 있습니다. 이를 통해 유추할 수 있는 것은 한국어에서 영어에서의 단어 토큰화와 유사한 형태를 얻으려면 어절 토큰 화가 아니라 형태소 토큰화를 수행해야 한다는 겁니다. 2) 한국어는 띄어쓰기가 영어보다 잘 지켜지지 않는다. 사용하는 한국어 코퍼스가 뉴스 기사와 같이 띄어쓰기를 철저하게 지키려고 노력하는 글이라면 좋겠지만, 많은 경우에 띄어쓰기가 틀렸거나 지켜지지 않는 코퍼스가 많습니다. 한국어는 영어권 언어와 비교하여 띄어쓰기가 어렵고 잘 지켜지지 않는 경향이 있습니다. 그 이유는 여러 견해가 있으나, 가장 기본적인 견해는 한국어의 경우 띄어쓰기가 지켜지지 않아도 글을 쉽게 이해할 수 있는 언어라는 점입니다. 띄어쓰기가 없던 한국어에 띄어쓰기가 보편화된 것도 근대(1933년, 한글맞춤법통일안)의 일입니다. 띄어쓰기를 전혀 하지 않은 한국어와 영어 두 가지 경우를 봅시다. EX1) 제가 이렇게 띄어쓰기를 전혀 하지 않고 글을 썼다고 하더라도 글을 이해할 수 있습니다. EX2) Tobeornottobethatisthequestion 영어의 경우에는 띄어쓰기를 하지 않으면 손쉽게 알아보기 어려운 문장들이 생깁니다. 이는 한국어(모아쓰기 방식)와 영어(풀어쓰기 방식)라는 언어적 특성의 차이에 기인합니다. 이 책에서는 모아쓰기와 풀어쓰기에 대한 설명은 하지 않겠습니다. 다만, 결론적으로 한국어는 수많은 코퍼스에서 띄어쓰기가 무시되는 경우가 많아 자연어 처리가 어려워졌다는 것입니다. 6. 품사 태깅(Part-of-speech tagging) 단어는 표기는 같지만 품사에 따라서 단어의 의미가 달라지기도 합니다. 예를 들어서 영어 단어 'fly'는 동사로는 '날다'라는 의미를 갖지만, 명사로는 '파리'라는 의미를 갖고 있습니다. 한국어도 마찬가지입니다. '못'이라는 단어는 명사로서는 망치를 사용해서 목재 따위를 고정하는 물건을 의미합니다. 하지만 부사로서의 '못'은 '먹는다', '달린다'와 같은 동작 동사를 할 수 없다는 의미로 쓰입니다. 결국 단어의 의미를 제대로 파악하기 위해서는 해당 단어가 어떤 품사로 쓰였는지 보는 것이 주요 지표가 될 수도 있습니다. 그에 따라 단어 토큰화 과정에서 각 단어가 어떤 품사로 쓰였는지를 구분해놓기도 하는데, 이 작업을 품사 태깅(part-of-speech tagging)이라고 합니다. NLTK와 KoNLPy를 통해 품사 태깅 실습을 진행합니다. 7. NLTK와 KoNLPy를 이용한 영어, 한국어 토큰화 실습 NLTK에서는 Penn Treebank POS Tags라는 기준을 사용하여 품사를 태깅 합니다. from nltk.tokenize import word_tokenize from nltk.tag import pos_tag text = "I am actively looking for Ph.D. students. and you are a Ph.D. student." tokenized_sentence = word_tokenize(text) print('단어 토큰화 :',tokenized_sentence) print('품사 태깅 :',pos_tag(tokenized_sentence)) 단어 토큰화 : ['I', 'am', 'actively', 'looking', 'for', 'Ph.D.', 'students', '.', 'and', 'you', 'are', 'a', 'Ph.D.', 'student', '.'] 품사 태깅 : [('I', 'PRP'), ('am', 'VBP'), ('actively', 'RB'), ('looking', 'VBG'), ('for', 'IN'), ('Ph.D.', 'NNP'), ('students', 'NNS'), ('.', '.'), ('and', 'CC'), ('you', 'PRP'), ('are', 'VBP'), ('a', 'DT'), ('Ph.D.', 'NNP'), ('student', 'NN'), ('.', '.')] 영어 문장에 대해서 토큰화를 수행한 결과를 입력으로 품사 태깅을 수행하였습니다. Penn Treebank POG Tags에서 PRP는 인칭 대명사, VBP는 동사, RB는 부사, VBG는 현재 부사, IN은 전치사, NNP는 고유 명사, NNS는 복수형 명사, CC는 접속사, DT는 관사를 의미합니다. 한국어 자연어 처리를 위해서는 KoNLPy(코엔엘파이)라는 파이썬 패키지를 사용할 수 있습니다. 코엔엘파이를 통해서 사용할 수 있는 형태소 분석기로 Okt(Open Korea Text), 메캅(Mecab), 코모란(Komoran), 한 나눔(Hannanum), 꼬꼬마(Kkma)가 있습니다. 한국어 NLP에서 형태소 분석기를 사용하여 단어 토큰화. 더 정확히는 형태소 토큰화(morpheme tokenization)를 수행해 보겠습니다. 여기서는 Okt와 꼬꼬마 두 개의 형태소 분석기를 사용하여 토큰화를 수행하겠습니다. from konlpy.tag import Okt from konlpy.tag import Kkma okt = Okt() kkma = Kkma() print('OKT 형태소 분석 :',okt.morphs("열심히 코딩한 당신, 연휴에는 여행을 가봐요")) print('OKT 품사 태깅 :',okt.pos("열심히 코딩한 당신, 연휴에는 여행을 가봐요")) print('OKT 명사 추출 :',okt.nouns("열심히 코딩한 당신, 연휴에는 여행을 가봐요")) OKT 형태소 분석 : ['열심히', '코딩', '한', '당신', ',', '연휴', '에는', '여행', '을', '가봐요'] OKT 품사 태깅 : [('열심히', 'Adverb'), ('코딩', 'Noun'), ('한', 'Josa'), ('당신', 'Noun'), (',', 'Punctuation'), ('연휴', 'Noun'), ('에는', 'Josa'), ('여행', 'Noun'), ('을', 'Josa'), ('가봐요', 'Verb')] OKT 명사 추출 : ['코딩', '당신', '연휴', '여행'] 위의 예제는 Okt 형태소 분석기로 토큰화를 시도해 본 예제입니다. 각각의 메서드는 아래와 같은 기능을 갖고 있습니다. 1) morphs : 형태소 추출 2) pos : 품사 태깅(Part-of-speech tagging) 3) nouns : 명사 추출 앞서 언급한 코엔엘파이의 형태소 분석기들은 공통적으로 이 메서드들을 제공하고 있습니다. 위 예제에서 형태소 추출과 품사 태깅 메서드의 결과를 보면 조사를 기본적으로 분리하고 있음을 확인할 수 있습니다. 한국어 NLP에서 전처리에 형태소 분석기를 사용하는 것은 굉장히 유용합니다. 이번에는 꼬꼬마 형태소 분석기를 사용하여 같은 문장에 대해서 토큰화를 진행해 봅시다. print('꼬꼬마 형태소 분석 :',kkma.morphs("열심히 코딩한 당신, 연휴에는 여행을 가봐요")) print('꼬꼬마 품사 태깅 :',kkma.pos("열심히 코딩한 당신, 연휴에는 여행을 가봐요")) print('꼬꼬마 명사 추출 :',kkma.nouns("열심히 코딩한 당신, 연휴에는 여행을 가봐요")) 꼬꼬마 형태소 분석 : ['열심히', '코딩', '하', 'ㄴ', '당신', ',', '연휴', '에', '는', '여행', '을', '가보', '아요'] 꼬꼬마 품사 태깅 : [('열심히', 'MAG'), ('코딩', 'NNG'), ('하', 'XSV'), ('ㄴ', 'ETD'), ('당신', 'NP'), (',', 'SP'), ('연휴', 'NNG'), ('에', 'JKM'), ('는', 'JX'), ('여행', 'NNG'), ('을', 'JKO'), ('가보', 'VV'), ('아요', 'EFN')] 꼬꼬마 명사 추출 : ['코딩', '당신', '연휴', '여행'] 앞서 사용한 Okt 형태소 분석기와 결과가 다른 것을 볼 수 있습니다. 각 형태소 분석기는 성능과 결과가 다르게 나오기 때문에, 형태소 분석기의 선택은 사용하고자 하는 필요 용도에 어떤 형태소 분석기가 가장 적절한지를 판단하고 사용하면 됩니다. 예를 들어서 속도를 중시한다면 메캅을 사용할 수 있습니다. 03-02 텍스트 데이터의 정제와 정규화 코퍼스에서 용도에 맞게 토큰을 분류하는 작업을 토큰화(tokenization)라고 하며, 토큰화 작업 전, 후에는 텍스트 데이터를 용도에 맞게 정제(cleaning) 및 정규화(normalization) 하는 일이 항상 함께합니다. 정제 및 정규화의 목적은 각각 다음과 같습니다. 정제(cleaning) : 갖고 있는 코퍼스로부터 노이즈 데이터를 제거한다. 정규화(normalization) : 표현 방법이 다른 단어들을 통합시켜서 같은 단어로 만들어준다. 정제 작업은 토큰화 작업에 방해가 되는 부분들을 배제시키고 토큰화 작업을 수행하기 위해서 토큰화 작업보다 앞서 이루어지기도 하지만, 토큰화 작업 이후에도 여전히 남아있는 노이즈들을 제거하기 위해 지속적으로 이루어지기도 합니다. 사실 완벽한 정제 작업은 어려운 편이라서, 대부분의 경우 이 정도면 됐다.라는 일종의 합의점을 찾기도 합니다. 1. 규칙에 기반한 표기가 다른 단어들의 통합 필요에 따라 직접 코딩을 통해 정의할 수 있는 정규화 규칙의 예로서 같은 의미를 갖고 있음에도, 표기가 다른 단어들을 하나의 단어로 정규화하는 방법을 사용할 수 있습니다. 가령, USA와 US는 같은 의미를 가지므로 하나의 단어로 정규화해볼 수 있습니다. uh-huh와 uhhuh는 형태는 다르지만 여전히 같은 의미를 갖고 있습니다. 이러한 정규화를 거치게 되면, US를 찾아도 USA도 함께 찾을 수 있을 것입니다. 뒤에서 표기가 다른 단어들을 통합하는 방법인 어간 추출(stemming)과 표제어 추출(lemmatizaiton)에 대해서 더 자세히 알아봅니다. 2. 대, 소문자 통합 영어권 언어에서 대, 소문자를 통합하는 것은 단어의 개수를 줄일 수 있는 또 다른 정규화 방법입니다. 영어권 언어에서 대문자는 문장의 맨 앞 등과 같은 특정 상황에서만 쓰이고, 대부분의 글은 소문자로 작성되기 때문에 대, 소문자 통합 작업은 대부분 대문자를 소문자로 변환하는 소문자 변환작업으로 이루어지게 됩니다. 소문자 변환이 왜 유용한지 예를 들어보도록 하겠습니다. 가령, Automobile이라는 단어가 문장의 첫 단어였기 때문에 A가 대문자였다고 생각해 봅시다. 여기에 소문자 변환을 사용하면, automobile을 찾는 질의(query)의 결과로서 Automobile도 찾을 수 있게 됩니다. 검색 엔진에서 사용자가 페라리 차량에 관심이 있어서 페라리를 검색해 본다고 합시다. 엄밀히 말해서 사실 사용자가 검색을 통해 찾고자 하는 결과는 a Ferrari car라고 봐야 합니다. 하지만 검색 엔진은 소문자 변환을 적용했을 것이기 때문에 ferrari만 쳐도 원하는 결과를 얻을 수 있을 것입니다. 물론 대문자와 소문자를 무작정 통합해서는 안 됩니다. 대문자와 소문자가 구분되어야 하는 경우도 있습니다. 가령 미국을 뜻하는 단어 US와 우리를 뜻하는 us는 구분되어야 합니다. 또 회사 이름(General Motors)나, 사람 이름(Bush) 등은 대문자로 유지되는 것이 옳습니다. 모든 토큰을 소문자로 만드는 것이 문제를 가져온다면, 또 다른 대안은 일부만 소문자로 변환시키는 방법도 있습니다. 가령, 이런 규칙은 어떨까요? 문장의 맨 앞에서 나오는 단어의 대문자만 소문자로 바꾸고, 다른 단어들은 전부 대문자인 상태로 놔두는 것입니다. 이러한 작업은 더 많은 변수를 사용해서 소문자 변환을 언제 사용할지 결정하는 머신 러닝 시퀀스 모델로 더 정확하게 진행시킬 수 있습니다. 하지만 만약 올바른 대문자 단어를 얻고 싶은 상황에서 훈련에 사용하는 코퍼스가 사용자들이 단어의 대문자, 소문자의 올바른 사용 방법과 상관없이 소문자를 사용하는 사람들로부터 나온 데이터라면 이러한 방법 또한 그다지 도움이 되지 않을 수 있습니다. 결국에는 예외 사항을 크게 고려하지 않고, 모든 코퍼스를 소문자로 바꾸는 것이 종종 더 실용적인 해결책이 되기도 합니다. 3. 불필요한 단어의 제거 정제 작업에서 제거해야 하는 노이즈 데이터(noise data)는 자연어가 아니면서 아무 의미도 갖지 않는 글자들(특수 문자 등)을 의미하기도 하지만, 분석하고자 하는 목적에 맞지 않는 불필요 단어들을 노이즈 데이터라고 하기도 합니다. 불필요 단어들을 제거하는 방법으로는 불용어 제거와 등장 빈도가 적은 단어, 길이가 짧은 단어들을 제거하는 방법이 있습니다. 불용어 제거는 불용어 챕터에서 더욱 자세히 다루기로 하고, 여기서는 등장 빈도가 적은 단어와 길이가 짧은 단어를 제거하는 경우에 대해서 간략히 설명하겠습니다. (1) 등장 빈도가 적은 단어 때로는 텍스트 데이터에서 너무 적게 등장해서 자연어 처리에 도움이 되지 않는 단어들이 존재합니다. 예를 들어 입력된 메일이 정상 메일인지 스팸 메일인지를 분류하는 스팸 메일 분류기를 설계한다고 가정해 보겠습니다. 총 100,000개의 메일을 가지고 정상 메일에서는 어떤 단어들이 주로 등장하고, 스팸 메일에서는 어떤 단어들이 주로 등장하는지를 가지고 설계하고자 합니다. 그런데 이때 100,000개의 메일 데이터에서 총합 5번 밖에 등장하지 않은 단어가 있다면 이 단어는 직관적으로 분류에 거의 도움이 되지 않을 것임을 알 수 있습니다. (2) 길이가 짧은 단어 영어권 언어에서는 길이가 짧은 단어를 삭제하는 것만으로도 어느 정도 자연어 처리에서 크게 의미가 없는 단어들을 제거하는 효과를 볼 수 있다고 알려져 있습니다. 즉, 영어권 언어에서 길이가 짧은 단어들은 대부분 불용어에 해당됩니다. 사실 길이가 짧은 단어를 제거하는 2차 이유는 길이를 조건으로 텍스트를 삭제하면서 단어가 아닌 구두점들까지도 한꺼번에 제거하기 위함도 있습니다. 하지만 한국어에서는 길이가 짧은 단어라고 삭제하는 이런 방법이 크게 유효하지 않을 수 있는데 그 이유에 대해서 정리해 보도록 하겠습니다. 단정적으로 말할 수는 없지만, 영어 단어의 평균 길이는 6~7 정도이며, 한국어 단어의 평균 길이는 2~3 정도로 추정되고 있습니다. 두 나라의 단어 평균 길이가 몇 인지에 대해서는 확실히 말하기 어렵지만 그럼에도 확실한 사실은 영어 단어의 길이가 한국어 단어의 길이보다는 평균적으로 길다는 점입니다. 이는 영어 단어와 한국어 단어에서 각 한 글자가 가진 의미의 크기가 다르다는 점에서 기인합니다. 한국어 단어는 한자어가 많고, 한 글자만으로도 이미 의미를 가진 경우가 많습니다. 예를 들어 '학교'라는 한국어 단어를 생각해 보면, 배울 학(學)과 학교 교(校)로 글자 하나, 하나가 이미 함축적인 의미를 갖고 있어 두 글자만으로 학교라는 단어를 표현합니다. 하지만 영어의 경우에는 학교라는 글자를 표현하기 위해서는 s, c, h, o, o, l이라는 총 6개의 글자가 필요합니다. 다른 예로는 전설 속 동물인 용()을 표현하기 위해서는 한국어로는 한 글자 면 충분하지만, 영어에서는 d, r, a, g, o, n이라는 총 6개의 글자가 필요합니다. 이러한 특성으로 인해 영어는 길이가 2~3 이하인 단어를 제거하는 것만으로도 크게 의미를 갖지 못하는 단어를 줄이는 효과를 갖고 있습니다. 예를 들어 갖고 있는 텍스트 데이터에서 길이가 1인 단어를 제거하는 코드를 수행하면 대부분의 자연어 처리에서 의미를 갖지 못하는 단어인 관사 'a'와 주어로 쓰이는 'I'가 제거됩니다. 마찬가지로 길이가 2인 단어를 제거한다고 하면 it, at, to, on, in, by 등과 같은 대부분 불용어에 해당되는 단어들이 제거됩니다. 필요에 따라서는 길이가 3인 단어도 제거할 수 있지만, 이 경우 fox, dog, car 등 길이가 3인 명사들이 제거되기 시작하므로 사용하고자 하는 데이터에서 해당 방법을 사용해도 되는지에 대한 고민이 필요합니다. import re text = "I was wondering if anyone out there could enlighten me on this car." # 길이가 1~2인 단어들을 정규 표현식을 이용하여 삭제 shortword = re.compile(r'\W*\b\w{1,2}\b') print(shortword.sub('', text)) was wondering anyone out there could enlighten this car. 4. 정규 표현식(Regular Expression) 얻어낸 코퍼스에서 노이즈 데이터의 특징을 잡아낼 수 있다면, 정규 표현식을 통해서 이를 제거할 수 있는 경우가 많습니다. 가령, HTML 문서로부터 가져온 코퍼스라면 문서 여기저기에 HTML 태그가 있습니다. 뉴스 기사를 크롤링 했다면, 기사마다 게재 시간이 적혀져 있을 수 있습니다. 정규 표현식은 이러한 코퍼스 내에 계속해서 등장하는 글자들을 규칙에 기반하여 한 번에 제거하는 방식으로서 매우 유용합니다. 이 책에서도 전처리를 위해 정규 표현식을 앞으로 종종 사용하게 될 겁니다. 예를 들어 위에서 길이가 짧은 단어를 제거할 때도, 정규 표현식이 유용하게 사용되었습니다. 정규 표현식에 대한 자세한 내용은 뒤에서 좀 더 상세하게 다룹니다. 03-03 불용어(Stopwords) 갖고 있는 데이터에서 유의미한 단어 토큰만을 선별하기 위해서는 큰 의미가 없는 단어 토큰을 제거하는 작업이 필요합니다. 여기서 큰 의미가 없다는 것은 자주 등장하지만 분석을 하는 것에 있어서는 큰 도움이 되지 않는 단어들을 말합니다. 예를 들면, I, my, me, over, 조사, 접미사 같은 단어들은 문장에서는 자주 등장하지만 실제 의미 분석을 하는 데는 거의 기여하는 바가 없는 경우가 있습니다. 이러한 단어들을 불용어(stopword)라고 하며, NLTK에서는 위와 같은 100여 개 이상의 영어 단어들을 불용어로 패키지 내에서 미리 정의하고 있습니다. 물론 불용어는 개발자가 직접 정의할 수도 있습니다. 이번에는 영어 문장에서 NLTK가 정의한 영어 불용어를 제거하는 실습을 하고, 한국어 문장에서 직접 정의한 불용어를 제거해 보겠습니다. NLTK 실습에서는 1챕터에서 언급했듯이 NLTK Data가 필요합니다. 만약, 데이터가 없다는 에러가 발생 시에는 nltk.download(필요한 데이터)라는 커맨드를 통해 다운로드할 수 있습니다. from nltk.corpus import stopwords from nltk.tokenize import word_tokenize from konlpy.tag import Okt 1. NLTK에서 불용어 확인하기 stop_words_list = stopwords.words('english') print('불용어 개수 :', len(stop_words_list)) print('불용어 10개 출력 :',stop_words_list[:10]) 불용어 개수 : 179 불용어 10개 출력 : ['i', 'me', 'my', 'myself', 'we', 'our', 'ours', 'ourselves', 'you', "you're"] stopwords.words("english")는 NLTK가 정의한 영어 불용어 리스트를 리턴합니다. 출력 결과가 100개 이상이기 때문에 여기서는 간단히 10개만 확인해 보았습니다. 'i', 'me', 'my'와 같은 단어들을 NLTK에서 불용어로 정의하고 있음을 확인할 수 있습니다. 2. NLTK를 통해서 불용어 제거하기 example = "Family is not an important thing. It's everything." stop_words = set(stopwords.words('english')) word_tokens = word_tokenize(example) result = [] for word in word_tokens: if word not in stop_words: result.append(word) print('불용어 제거 전 :',word_tokens) print('불용어 제거 후 :',result) 불용어 제거 전 : ['Family', 'is', 'not', 'an', 'important', 'thing', '.', 'It', "'s", 'everything', '.'] 불용어 제거 후 : ['Family', 'important', 'thing', '.', 'It', "'s", 'everything', '.'] 위 코드는 "Family is not an important thing. It's everything."라는 임의의 문장을 정의하고, NLTK의 word_tokenize를 통해서 단어 토큰화를 수행합니다. 그리고 단어 토큰화 결과로부터 NLTK가 정의하고 있는 불용어를 제외한 결과를 출력하고 있습니다. 결과적으로 'is', 'not', 'an'과 같은 단어들이 문장에서 제거되었음을 볼 수 있습니다. 3. 한국어에서 불용어 제거하기 한국어에서 불용어를 제거하는 방법으로는 간단하게는 토큰화 후에 조사, 접속사 등을 제거하는 방법이 있습니다. 하지만 불용어를 제거하려고 하다 보면 조사나 접속사와 같은 단어들뿐만 아니라 명사, 형용사와 같은 단어들 중에서 불용어로서 제거하고 싶은 단어들이 생기기도 합니다. 결국에는 사용자가 직접 불용어 사전을 만들게 되는 경우가 많습니다. 이번에는 직접 불용어를 정의해 보고, 주어진 문장으로부터 사용자가 정의한 불용어 사전으로부터 불용어를 제거해 보겠습니다. 아래의 불용어는 임의 선정한 것으로 실제 의미 있는 선정 기준이 아닙니다. okt = Okt() example = "고기를 아무렇게나 구우려고 하면 안 돼. 고기라고 다 같은 게 아니거든. 예컨대 삼겹살을 구울 때는 중요한 게 있지." stop_words = "를 아무렇게나 구 우려 고 안 돼 같은 게 구울 때는" stop_words = set(stop_words.split(' ')) word_tokens = okt.morphs(example) result = [word for word in word_tokens if not word in stop_words] print('불용어 제거 전 :',word_tokens) print('불용어 제거 후 :',result) 불용어 제거 전 : ['고기', '를', '아무렇게나', '구', '우려', '고', '하면', '안', '돼', '.', '고기', '라고', '다', '같은', '게', '아니거든', '.', '예컨대', '삼겹살', '을', '구울', '때', '는', '중요한', '게', '있지', '.'] 불용어 제거 후 : ['고기', '하면', '.', '고기', '라고', '다', '아니거든', '.', '예컨대', '삼겹살', '을', '중요한', '있지', '.'] 아래의 링크는 보편적으로 선택할 수 있는 한국어 불용어 리스트를 보여줍니다. 하지만 여전히 절대적인 기준은 아닙니다. 링크 : https://www.ranks.nl/stopwords/korean 불용어가 많은 경우에는 코드 내에서 직접 정의하지 않고 txt 파일이나 csv 파일로 정리해놓고 이를 불러와서 사용하기도 합니다. 03-04 정규 표현식 텍스트 전처리에서 정규 표현식은 아주 유용한 도구입니다. 이번에는 파이썬에서 지원하고 있는 정규 표현식 모듈 re의 사용 방법과 NLTK를 통한 정규 표현식을 이용한 토큰화에 대해서 알아봅니다. 1. 정규 표현식 문법과 모듈 함수 파이썬에서는 정규 표현식 모듈 re을 지원하므로, 이를 이용하면 특정 규칙이 있는 텍스트 데이터를 빠르게 정제할 수 있습니다. 정규 표현식을 위해 사용되는 특수 문자와 모듈 함수에 대해서 표를 통해 정리해 보겠습니다. 표만으로는 이해하기 어렵습니다. 표 아래의 실습과 표를 병행하여 이해하시는 것이 좋습니다. 1) 정규 표현식 문법 정규 표현식을 위해 사용되는 문법 중 특수 문자들은 아래와 같습니다. 특수 문자 설명 . 한 개의 임의의 문자를 나타냅니다. (줄바꿈 문자인 \n는 제외) ? 앞의 문자가 존재할 수도 있고, 존재하지 않을 수도 있습니다. (문자가 0개 또는 1개) * 앞의 문자가 무한개로 존재할 수도 있고, 존재하지 않을 수도 있습니다. (문자가 0개 이상) + 앞의 문자가 최소 한 개 이상 존재합니다. (문자가 1개 이상) ^ 뒤의 문자열로 문자열이 시작됩니다. $ 앞의 문자열로 문자열이 끝납니다. {숫자} 숫자만큼 반복합니다. {숫자 1, 숫자 2} 숫자 1 이상 숫자 2 이하만큼 반복합니다. ?, *, +를 이것으로 대체할 수 있습니다. {숫자,} 숫자 이상만큼 반복합니다. [ ] 대괄호 안의 문자들 중 한 개의 문자와 매치합니다. [amk]라고 한다면 a 또는 m 또는 k 중 하나라도 존재하면 매치를 의미합니다. [a-z]와 같이 범위를 지정할 수도 있습니다. [a-zA-Z]는 알파벳 전체를 의미하는 범위이며, 문자열에 알파벳이 존재하면 매치를 의미합니다. [^문자] 해당 문자를 제외한 문자를 매치합니다. l AlB와 같이 쓰이며 A 또는 B의 의미를 가집니다. 정규 표현식 문법에는 역 슬래쉬(\)를 이용하여 자주 쓰이는 문자 규칙들이 있습니다. 문자 규칙 설명 \\\ 역 슬래쉬 문자 자체를 의미합니다 \\d 모든 숫자를 의미합니다. [0-9]와 의미가 동일합니다. \\D 숫자를 제외한 모든 문자를 의미합니다. [^0-9]와 의미가 동일합니다. \\s 공백을 의미합니다. [ \t\n\r\f\v]와 의미가 동일합니다. \\S 공백을 제외한 문자를 의미합니다. [^ \t\n\r\f\v]와 의미가 동일합니다. \\w 문자 또는 숫자를 의미합니다. [a-zA-Z0-9]와 의미가 동일합니다. \\W 문자 또는 숫자가 아닌 문자를 의미합니다. [^a-zA-Z0-9]와 의미가 동일합니다. 2) 정규 표현식 모듈 함수 정규 표현식 모듈에서 지원하는 함수는 이와 같습니다. 모듈 함수 설명 re.compile() 정규 표현식을 컴파일하는 함수입니다. 다시 말해, 파이썬에게 전해주는 역할을 합니다. 찾고자 하는 패턴이 빈번한 경우에는 미리 컴파일해놓고 사용하면 속도와 편 의성면에서 유리합니다. re.search() 문자열 전체에 대해서 정규 표현식과 매치되는지를 검색합니다. re.match() 문자열의 처음이 정규 표현식과 매치되는지를 검색합니다. re.split() 정규 표현식을 기준으로 문자열을 분리하여 리스트로 리턴합니다. re.findall() 문자열에서 정규 표현식과 매치되는 모든 경우의 문자열을 찾아서 리스트로 리턴합니다. 만약, 매치되는 문자열이 없다면 빈 리스트가 리턴됩니다. re.finditer() 문자열에서 정규 표현식과 매치되는 모든 경우의 문자열에 대한 이터 레이터 객체를 리턴합니다. re.sub() 문자열에서 정규 표현식과 일치하는 부분에 대해서 다른 문자열로 대체합니다. 앞으로 진행될 실습에서는 re.compile()에 정규 표현식을 컴파일하고, re.search()를 통해서 해당 정규 표현식이 입력 텍스트와 매치되는지를 확인하면서 각 정규 표현식에 대해서 이해해 보겠습니다. re.search()는 매치된다면 Match Object를 리턴하고 매치되지 않으면 아무런 값도 출력되지 않습니다. 2. 정규 표현식 실습 앞서 표로 봤던 정규 표현식을 예시를 통해 이해해 보겠습니다. import re 1) . 기호 .은 한 개의 임의의 문자를 나타냅니다. 예를 들어서 정규 표현식이 a.c라고 합시다. a와 c 사이에는 어떤 1개의 문자라도 올 수 있습니다. akc, azc, avc, a5c, a! c와 같은 형태는 모두 a.c의 정규 표현식과 매치됩니다. r = re.compile("a.c") r.search("kkk") # 아무런 결과도 출력되지 않는다. r.search("abc") <_sre.SRE_Match object; span=(0, 3), match='abc'> .은 어떤 문자로도 인식될 수 있기 때문에 abc라는 문자열은 a.c라는 정규 표현식 패턴으로 매치됩니다. 2) ?기호 ?는?앞의 문자가 존재할 수도 있고 존재하지 않을 수도 있는 경우를 나타냅니다. 예를 들어서 정규 표현식이 ab? c라고 합시다. 이 경우 이 정규 표현식에서의 b는 있다고 취급할 수도 있고, 없다고 취급할 수도 있습니다. 즉, abc와 ac 모두 매치할 수 있습니다. r = re.compile("ab? c") r.search("abbc") # 아무런 결과도 출력되지 않는다. r.search("abc") <_sre.SRE_Match object; span=(0, 3), match='abc'> b가 있는 것으로 판단하여 abc를 매치했습니다. r.search("ac") <_sre.SRE_Match object; span=(0, 2), match='ac'> b가 없는 것으로 판단하여 ac를 매치했습니다. 3) *기호 *은 바로 앞의 문자가 0개 이상일 경우를 나타냅니다. 앞의 문자는 존재하지 않을 수도 있으며, 또는 여러 개일 수도 있습니다. 정규 표현식이 ab*c라면 ac, abc, abbc, abbbc 등과 매치할 수 있으며 b의 개수는 무수히 많을 수 있습니다. r = re.compile("ab*c") r.search("a") # 아무런 결과도 출력되지 않는다. r.search("ac") <_sre.SRE_Match object; span=(0, 2), match='ac'> r.search("abc") <_sre.SRE_Match object; span=(0, 3), match='abc'> r.search("abbbbc") <_sre.SRE_Match object; span=(0, 6), match='abbbbc'> 4) +기호 +는 *와 유사합니다. 다른 점은 앞의 문자가 최소 1개 이상이어야 합니다. 정규 표현식이 ab+c라고 한다면 ac는 매치되지 않습니다. 하지만 abc, abbc, abbbc 등과 매치할 수 있으며 b의 개수는 무수히 많을 수 있습니다. r = re.compile("ab+c") r.search("ac") # 아무런 결과도 출력되지 않는다. r.search("abc") <_sre.SRE_Match object; span=(0, 3), match='abc'> r.search("abbbbc") <_sre.SRE_Match object; span=(0, 6), match='abbbbc'> 5) ^기호 ^는 시작되는 문자열을 지정합니다. 정규 표현식이 ^ab라면 문자열 ab로 시작되는 경우 매치합니다. r = re.compile("^ab") # 아무런 결과도 출력되지 않는다. r.search("bbc") r.search("zab") r.search("abz") <re.Match object; span=(0, 2), match='ab'> 6) {숫자} 기호 문자에 해당 기호를 붙이면, 해당 문자를 숫자만큼 반복한 것을 나타냅니다. 예를 들어서 정규 표현식이 ab{2}c라면 a와 c 사이에 b가 존재하면서 b가 2개인 문자열에 대해서 매치합니다. r = re.compile("ab{2}c") # 아무런 결과도 출력되지 않는다. r.search("ac") r.search("abc") r.search("abbbbbc") r.search("abbc") <_sre.SRE_Match object; span=(0, 4), match='abbc'> 7) {숫자 1, 숫자 2} 기호 문자에 해당 기호를 붙이면, 해당 문자를 숫자 1 이상 숫자 2 이하만큼 반복합니다. 예를 들어서 정규 표현식이 ab{2,8}c라면 a와 c 사이에 b가 존재하면서 b는 2개 이상 8개 이하인 문자열에 대해서 매치합니다. r = re.compile("ab{2,8}c") # 아무런 결과도 출력되지 않는다. r.search("ac") r.search("abc") r.search("abbbbbbbbbc") r.search("abbc") <_sre.SRE_Match object; span=(0, 4), match='abbc'> r.search("abbbbbbbbc") <_sre.SRE_Match object; span=(0, 10), match='abbbbbbbbc'> 8) {숫자,} 기호 문자에 해당 기호를 붙이면 해당 문자를 숫자 이상만큼 반복합니다. 예를 들어서 정규 표현식이 a{2, }bc라면 뒤에 bc가 붙으면서 a의 개수가 2개 이상인 경우인 문자열과 매치합니다. 또한 만약 {0, }을 쓴다면 *와 동일한 의미가 되며, {1, }을 쓴다면 +와 동일한 의미가 됩니다. r = re.compile("a{2, }bc") # 아무런 결과도 출력되지 않는다. r.search("bc") r.search("aa") r.search("aabc") <_sre.SRE_Match object; span=(0, 4), match='aabc'> r.search("aaaaaaaabc") <_sre.SRE_Match object; span=(0, 10), match='aaaaaaaabc'> 9) [ ] 기호 [ ] 안에 문자들을 넣으면 그 문자들 중 한 개의 문자와 매치라는 의미를 가집니다. 예를 들어서 정규 표현식이 [abc] 라면, a 또는 b 또는 c가 들어가 있는 문자열과 매치됩니다. 범위를 지정하는 것도 가능합니다. [a-zA-Z]는 알파벳 전부를 의미하며, [0-9]는 숫자 전부를 의미합니다. r = re.compile("[abc]") # [abc]는 [a-c]와 같다. r.search("zzz") # 아무런 결과도 출력되지 않는다. r.search("a") <_sre.SRE_Match object; span=(0, 1), match='a'> r.search("aaaaaaa") <_sre.SRE_Match object; span=(0, 1), match='a'> r.search("baac") <_sre.SRE_Match object; span=(0, 1), match='b'> 이번에는 알파벳 소문자에 대해서 범위 지정하여 정규 표현식을 만들어보고 문자열과 매치해 보겠습니다. r = re.compile("[a-z]") # 아무런 결과도 출력되지 않는다. r.search("AAA") r.search("111") r.search("aBC") <_sre.SRE_Match object; span=(0, 1), match='a'> 10) [^문자] 기호 [^문자]는 ^기호 뒤에 붙은 문자들을 제외한 모든 문자를 매치하는 역할을 합니다. 예를 들어서 [^abc]라는 정규 표현식이 있다면, a 또는 b 또는 c가 들어간 문자열을 제외한 모든 문자열을 매치합니다. r = re.compile("[^abc]") # 아무런 결과도 출력되지 않는다. r.search("a") r.search("ab") r.search("b") r.search("d") <_sre.SRE_Match object; span=(0, 1), match='d'> r.search("1") <_sre.SRE_Match object; span=(0, 1), match='1'> 3. 정규 표현식 모듈 함수 예제 앞서 re.compile()과 re.search()를 사용해 보았습니다. 다른 정규 표현식 모듈 함수에 대해서 실습을 진행해 보겠습니다. (1) re.match() 와 re.search()의 차이 search()가 정규 표현식 전체에 대해서 문자열이 매치하는지를 본다면, match()는 문자열의 첫 부분부터 정규 표현식과 매치하는지를 확인합니다. 문자열 중간에 찾을 패턴이 있더라도 match 함수는 문자열의 시작에서 패턴이 일치하지 않으면 찾지 않습니다. r = re.compile("ab.") r.match("kkkabc") # 아무런 결과도 출력되지 않는다. r.search("kkkabc") <_sre.SRE_Match object; span=(3, 6), match='abc'> r.match("abckkk") <_sre.SRE_Match object; span=(0, 3), match='abc'> 위 경우 정규 표현식이 ab. 이기 때문에, ab 다음에는 어떤 한 글자가 존재할 수 있다는 패턴을 의미합니다. search 모듈 함수에 kkkabc라는 문자열을 넣어 매치되는지 확인한다면 abc라는 문자열에서 매치되어 Match object를 리턴합니다. 하지만 match 모듈 함수의 경우 앞 부분이 ab. 와 매치되지 않기 때문에, 아무런 결과도 출력되지 않습니다. 하지만 반대로 abckkk로 매치를 시도해 보면, 시작 부분에서 패턴과 매치되었기 때문에 정상적으로 Match object를 리턴합니다. (2) re.split() split() 함수는 입력된 정규 표현식을 기준으로 문자열들을 분리하여 리스트로 리턴합니다. 토큰화에 유용하게 쓰일 수 있습니다. 공백을 기준으로 문자열 분리를 수행하고 결과로서 리스트를 리턴해봅시다. # 공백 기준 분리 text = "사과 딸기 수박 멜론 바나나" re.split(" ", text) ['사과', '딸기', '수박', '멜론', '바나나'] 이와 유사하게 줄바꿈이나 다른 정규 표현식을 기준으로 텍스트를 분리할 수도 있습니다. # 줄바꿈 기준 분리 text = """사과 딸기 수박 멜론 바나나""" re.split("\n", text) ['사과', '딸기', '수박', '멜론', '바나나'] # '+'를 기준으로 분리 text = "사과+딸기+수박+멜론+바나나" re.split("\+", text) ['사과', '딸기', '수박', '멜론', '바나나'] (3) re.findall() findall() 함수는 정규 표현식과 매치되는 모든 문자열들을 리스트로 리턴합니다. 단, 매치되는 문자열이 없다면 빈 리스트를 리턴합니다. 임의의 텍스트에 정규 표현식으로 숫자를 의미하는 규칙으로 findall()을 수행하면 전체 텍스트로부터 숫자만 찾아내서 리스트로 리턴합니다. text = """이름 : 김철수 전화번호 : 010 - 1234 - 1234 나이 : 30 성별 : 남""" re.findall("\d+", text) ['010', '1234', '1234', '30'] 하지만 만약 입력 텍스트에 숫자가 없다면 빈 리스트를 리턴하게 됩니다. re.findall("\d+", "문자열입니다.") [] (4) re.sub() sub() 함수는 정규 표현식 패턴과 일치하는 문자열을 찾아 다른 문자열로 대체할 수 있습니다. 아래와 같은 정제 작업에 많이 사용되는데, 영어 문장에 각주 등과 같은 이유로 특수 문자가 섞여있는 경우에 특수 문자를 제거하고 싶다면 알파벳 외의 문자는 공백으로 처리하는 등의 용도로 쓸 수 있습니다. text = "Regular expression : A regular expression, regex or regexp[1] (sometimes called a rational expression)[2][3] is, in theoretical computer science and formal language theory, a sequence of characters that define a search pattern." preprocessed_text = re.sub('[^a-zA-Z]', ' ', text) print(preprocessed_text) 'Regular expression A regular expression regex or regexp sometimes called a rational expression is in theoretical computer science and formal language theory a sequence of characters that define a search pattern ' 4. 정규 표현식 텍스트 전처리 예제 다음과 같은 임의의 텍스트가 있다고 해봅시다. 테이블<NAME>의 데이터를 텍스트에 저장하였습니다. text = """100 John PROF 101 James STUD 102 Mac STUD""" \s+는 공백을 찾아내는 정규 표현식입니다. 뒤에 붙는 +는 최소 1개 이상의 패턴을 찾아낸다는 의미입니다. s는 공백을 의미하기 때문에 최소 1개 이상의 공백인 패턴을 찾아냅니다. split은 주어진 정규 표현식을 기준으로 분리하므로 결과는 아래와 같습니다. re.split('\s+', text) ['100', 'John', 'PROF', '101', 'James', 'STUD', '102', 'Mac', 'STUD'] 공백을 기준으로 값이 구분되었습니다. 해당 입력으로부터 숫자만을 뽑아온다고 해봅시다. 여기서 \d는 숫자에 해당되는 정규 표현식입니다. +를 붙이면 최소 1개 이상의 숫자에 해당하는 값을 의미합니다. findall()은 해당 표현식에 일치하는 값을 찾아냅니다. re.findall('\d+',text) ['100', '101', '102] 이번에는 텍스트로부터 대문자인 행의 값만 가져와봅시다. 이 경우 정규 표현식에 대문자를 기준으로 매치시키면 됩니다. 하지만 정규 표현식에 대문자라는 기준만을 넣을 경우에는 문자열을 가져오는 것이 아니라 모든 대문자 각각을 갖고 오게 됩니다. re.findall('[A-Z]',text) ['J', 'P', 'R', 'O', 'F', 'J', 'S', 'T', 'U', 'D', 'M', 'S', 'T', 'U', 'D'] 대문자가 연속적으로 네 번 등장하는 경우라는 조건을 추가해 봅시다. re.findall('[A-Z]{4}',text) ['PROF', 'STUD', 'STUD'] 대문자로 구성된 문자열들을 가져옵니다. 이름의 경우에는 대문자와 소문자가 섞여있는 상황입니다. 이름에 대한 행의 값을 갖고 오고 싶다면 처음에 대문자가 등장한 후에 소문자가 여러 번 등장하는 경우에 매치하게 합니다. re.findall('[A-Z][a-z]+',text) ['John', 'James', 'Mac'] 5. 정규 표현식을 이용한 토큰화 NLTK에서는 정규 표현식을 사용해서 단어 토큰화를 수행하는 RegexpTokenizer를 지원합니다. RegexpTokenizer()에서 괄호 안에 하나의 토큰으로 규정하기를 원하는 정규 표현식을 넣어서 토큰화를 수행합니다. tokenizer1에 사용한 \w+는 문자 또는 숫자가 1개 이상인 경우를 의미합니다. tokenizer2에서는 공백을 기준으로 토큰화하도록 했습니다. gaps=true는 해당 정규 표현식을 토큰으로 나누기 위한 기준으로 사용한다는 의미입니다. 만약 gaps=True라는 부분을 기재하지 않는다면, 토큰화의 결과는 공백들만 나오게 됩니다. tokenizer2의 결과는 위의 tokenizer1의 결과와는 달리 아포스트로피나 온점을 제외하지 않고 토큰 화가 수행된 것을 확인할 수 있습니다. from nltk.tokenize import RegexpTokenizer text = "Don't be fooled by the dark sounding name, Mr. Jone's Orphanage is as cheery as cheery goes for a pastry shop" tokenizer1 = RegexpTokenizer("[\w]+") tokenizer2 = RegexpTokenizer("\s+", gaps=True) print(tokenizer1.tokenize(text)) print(tokenizer2.tokenize(text)) ['Don', 't', 'be', 'fooled', 'by', 'the', 'dark', 'sounding', 'name', 'Mr', 'Jone', 's', 'Orphanage', 'is', 'as', 'cheery', 'as', 'cheery', 'goes', 'for', 'a', 'pastry', 'shop'] ["Don't", 'be', 'fooled', 'by', 'the', 'dark', 'sounding', 'name,', 'Mr.', "Jone's", 'Orphanage', 'is', 'as', 'cheery', 'as', 'cheery', 'goes', 'for', 'a', 'pastry', 'shop'] 03-05 딥 러닝을 위한 자연어 처리 전처리 실습 자연어 처리는 일반적으로 토큰화, 단어 집합 생성, 정수 인코딩, 패딩, 벡터화의 과정을 거칩니다. 이번 챕터에서는 이러한 전반적인 과정에 대해서 이해합니다. 1. 토큰화(Tokenization) 주어진 텍스트를 단어 또는 문자 단위로 자르는 것을 토큰화라고 합니다. 예를 들어 주어진 문장이 다음과 같다고 해봅시다. 영어의 경우 토큰화를 사용하는 도구로서 대표적으로 spaCy와 NLTK가 있습니다. 물론, 파이썬 기본 함수인 split으로 토큰화를 할 수도 있습니다. 우선 영어에 대해서 토큰화 실습을 해봅시다. en_text = "A Dog Run back corner near spare bedrooms" 1. spaCy 사용하기 import spacy spacy_en = spacy.load('en') def tokenize(en_text): return [tok.text for tok in spacy_en.tokenizer(en_text)] print(tokenize(en_text)) ['A', 'Dog', 'Run', 'back', 'corner', 'near', 'spare', 'bedrooms'] 2. NLTK 사용하기 !pip install nltk import nltk nltk.download('punkt') from nltk.tokenize import word_tokenize print(word_tokenize(en_text)) ['A', 'Dog', 'Run', 'back', 'corner', 'near', 'spare', 'bedrooms'] 3. 띄어쓰기로 토큰화 print(en_text.split()) ['A', 'Dog', 'Run', 'back', 'corner', 'near', 'spare', 'bedrooms'] 사실 영어의 경우에는 띄어쓰기 단위로 토큰화를 해도 단어들 간 구분이 꽤나 명확하기 때문에, 토큰화 작업이 수월합니다. 하지만 한국어의 경우에는 토큰화 작업이 훨씬 까다롭습니다. 그 이유는 한국어는 조사, 접사 등으로 인해 단순 띄어쓰기 단위로 나누면 같은 단어가 다른 단어로 인식되어서 단어 집합(vocabulary)의 크기가 불필요하게 커지기 때문입니다. 단어 집합(vocabuary)이란 중복을 제거한 텍스트의 총 단어의 집합(set)을 의미합니다. 예를 들어 단어 '사과'가 많이 들어간 어떤 문장에 띄어쓰기 토큰화를 한다면 '사과가', '사과를', '사과의', '사과와', '사과는'과 같은 식으로 같은 단어임에도 조사가 붙어서 다른 단어로 인식될 수 있습니다. 예를 통해 구체적으로 이해해 봅시다. 4. 한국어 띄어쓰기 토큰화 kor_text = "사과의 놀라운 효능이라는 글을 봤어. 그래서 오늘 사과를 먹으려고 했는데 사과가 썩어서 슈퍼에 가서 사과랑 오렌지 사 왔어" print(kor_text.split()) ['사과의', '놀라운', '효능이라는', '글을', '봤어.', '그래서', '오늘', '사과를', '먹으려고', '했는데', '사과가', '썩어서', '슈퍼에', '가서', '사과랑', '오렌지', '사 왔어'] 위의 예제에서는 '사과'란 단어가 총 4번 등장했는데 모두 '의', '를', '가', '랑' 등이 붙어있어 이를 제거해 주지 않으면 기계는 전부 다른 단어로 인식하게 됩니다. 5. 형태소 토큰화 위와 같은 상황을 방지하기 위해서 한국어는 보편적으로 '형태소 분석기'로 토큰화를 합니다. 여기서는 형태소 분석기 중에서 mecab을 사용해 보겠습니다. 아래의 커맨드로 colab에서 mecab을 설치합니다. !pip install konlpy !pip install mecab-python !bash <(curl -s https://raw.githubusercontent.com/konlpy/konlpy/master/scripts/mecab.sh) from konlpy.tag import Mecab tokenizer = Mecab() print(tokenizer.morphs(kor_text)) ['사과', '의', '놀라운', '효능', '이', '라는', '글', '을', '봤', '어', '.', '그래서', '오늘', '사과', '를', '먹', '으려고', '했', '는데', '사과', '가', '썩', '어서', '슈퍼', '에', '가', '서', '사과', '랑', '오렌지', '사', '왔', '어'] 앞선 예와 다르게 '의', '를', '가', '랑' 등이 전부 분리되어 기계는 '사과'라는 단어를 하나의 단어로 처리할 수 있습니다. 지금까지는 단어 또는 형태소 단위로 토큰화를 했지만 이보다도 더 작은 단위인 문자 단위로 토큰화를 수행하는 경우도 있습니다. 6. 문자 토큰화 print(list(en_text)) ['A', ' ', 'D', 'o', 'g', ' ', 'R', 'u', 'n', ' ', 'b', 'a', 'c', 'k', ' ', 'c', 'o', 'r', 'n', 'e', 'r', ' ', 'n', 'e', 'a', 'r', ' ', 's', 'p', 'a', 'r', 'e', ' ', 'b', 'e', 'd', 'r', 'o', 'o', 'm', 's'] 간단히 토큰화에 대해서 알아봤습니다. 이제부터는 좀 더 많은 데이터를 가지고 실습해 보겠습니다. 2. 단어 집합(Vocabulary) 생성 단어 집합(vocabuary)이란 중복을 제거한 텍스트의 총 단어의 집합(set)을 의미합니다. 우선, 실습을 위해서 깃허브에서 '네이버 영화 리뷰 분류하기' 데이터를 다운로드하겠습니다. 네이버 영화 리뷰 데이터는 총 20만 개의 영화 리뷰를 긍정 1, 부정 0으로 레이블링한 데이터입니다. import urllib.request import pandas as pd from konlpy.tag import Mecab from nltk import FreqDist import numpy as np import matplotlib.pyplot as plt urllib.request.urlretrieve("https://raw.githubusercontent.com/e9t/nsmc/master/ratings.txt", filename="ratings.txt") data = pd.read_table('ratings.txt') # 데이터 프레임에 저장 data[:10] print('전체 샘플의 수 : {}'.format(len(data))) 전체 샘플의 수 : 200000 sample_data = data[:100] # 임의로 100개만 저장 정규 표현식을 통해서 데이터를 정제합니다. sample_data['document'] = sample_data['document'].str.replace("[^ㄱ-ㅎㅏ-ㅣ가-힣 ]","") # 한글과 공백을 제외하고 모두 제거 sample_data[:10] 토큰화를 수행해 보겠습니다. 토큰화 과정에서 불용어를 제거하기 위해 불용어를 우선 정의합니다. # 불용어 정의 stopwords=['의','가','이','은','들','는','좀','잘','그냥','과','도','를','으로','자','에','와','한','하다'] 형태소 분석기는 mecab을 사용합니다. tokenizer = Mecab() tokenized=[] for sentence in sample_data['document']: temp = tokenizer.morphs(sentence) # 토큰화 temp = [word for word in temp if not word in stopwords] # 불용어 제거 tokenized.append(temp) print(tokenized[:10]) [['어릴', '때', '보', '고', '지금', '다시', '봐도', '재밌', '어요', 'ㅋㅋ'], ['디자인', '을', '배우', '학생', '외국', '디자이너', '그', '일군', '전통', '을', '통해', '발전', '해', '문화', '산업', '부러웠', '는데', '사실', '우리', '나라', '에서', '그', '어려운', '시절', '끝', '까지', '열정', '을', '지킨', '노라노', '같', '전통', '있', '어', '저', '같', '사람', '꿈', '을', '꾸', '고', '이뤄나갈', '수', '있', '다는', '것', '감사', '합니다'], ['폴리스', '스토리', '시리즈', '부터', '뉴', '까지', '버릴', '께', '하나', '없', '음', '최고'], ['연기', '진짜', '개', '쩔', '구나', '지루', '할 거', '라고', '생각', '했', '는데', '몰입', '해서', '봤', '다', '그래', '이런', '게', '진짜', '영화', '지'], ['안개', '자욱', '밤하늘', '떠', '있', '초승달', '같', '영화'], ['사랑', '을', '해', '본', '사람', '라면', '처음', '부터', '끝', '까지', '웃', '을', '수', '있', '영화'], ['완전', '감동', '입니다', '다시', '봐도', '감동'], ['개', '전쟁', '나오', '나요', '나오', '면', '빠', '로', '보', '고', '싶', '음'], ['굿'], ['바보', '아니', '라', '병', '쉰', '인', '듯']] 이제 단어 집합을 만들어봅시다. NLTK에서는 빈도수 계산 도구인 FreqDist()를 지원합니다. vocab = FreqDist(np.hstack(tokenized)) print('단어 집합의 크기 : {}'.format(len(vocab))) 단어 집합의 크기 : 663 단어를 키(key)로, 단어에 대한 빈도수가 값(value)으로 저장돼 있습니다. vocab에 단어를 입력하면 빈도수를 리턴합니다. vocab['재밌'] 10 '재밌'이란 단어가 총 10번 등장하였습니다. most_common()는 상위 빈도수를 가진 주어진 수의 단어만을 리턴합니다. 이를 사용하여 등장 빈도수가 높은 단어들을 원하는 개수만큼만 얻을 수 있습니다. 등장 빈도수 상위 500개의 단어만 단어 집합으로 저장해 봅시다. vocab_size = 500 # 상위 vocab_size 개의 단어만 보존 vocab = vocab.most_common(vocab_size) print('단어 집합의 크기 : {}'.format(len(vocab))) 단어 집합의 크기 : 500 단어 집합의 크기가 500으로 줄어든 것을 확인할 수 있습니다. 3. 각 단어에 고유한 정수 부여 enumerate()는 순서가 있는 자료형(list, set, tuple, dictionary, string)을 입력으로 받아 인덱스를 순차적으로 함께 리턴한다는 특징이 있습니다. 인덱스 0과 1은 다른 용도로 남겨두고 나머지 단어들은 2부터 501까지 순차적으로 인덱스를 부여해 봅시다. word_to_index = {word[0] : index + 2 for index, word in enumerate(vocab)} word_to_index['pad'] = 1 word_to_index['unk'] = 0 이제 기존의 훈련 데이터에서 각 단어를 고유한 정수로 부여하는 작업을 진행해 보겠습니다. encoded = [] for line in tokenized: #입력 데이터에서 1줄씩 문장을 읽음 temp = [] for w in line: #각 줄에서 1개씩 글자를 읽음 try: temp.append(word_to_index[w]) # 글자를 해당되는 정수로 변환 except KeyError: # 단어 집합에 없는 단어일 경우 unk로 대체된다. temp.append(word_to_index['unk']) # unk의 인덱스로 변환 encoded.append(temp) print(encoded[:10]) [[78, 27, 9, 4, 50, 41, 79, 16, 28, 29], [188, 5, 80, 189, 190, 191, 42, 192, 114, 5, 193, 194, 21, 115, 195, 196, 13, 51, 81, 116, 30, 42, 197, 117, 118, 31, 198, 5, 199, 200, 17, 114, 7, 82, 52, 17, 43, 201, 5, 202, 4, 203, 14, 7, 83, 32, 204, 84], [205, 119, 206, 53, 207, 31, 208, 209, 54, 10, 25, 11], [44, 33, 120, 210, 211, 212, 213, 68, 45, 34, 13, 214, 121, 15, 2, 215, 69, 8, 33, 3, 35], [216, 217, 218, 219, 7, 220, 17, 3], [122, 5, 21, 36, 43, 123, 124, 53, 118, 31, 85, 5, 14, 7, 3], [125, 37, 221, 41, 79, 37], [120, 222, 55, 223, 55, 86, 224, 46, 9, 4, 47, 25], [56], [225, 87, 88, 226, 227, 57, 89]] 4. 길이가 다른 문장들을 모두 동일한 길이로 바꿔주는 패딩(padding) 이제 길이가 다른 리뷰들을 모두 동일한 길이로 바꿔주는 패딩 작업을 진행해 보겠습니다. 앞서 단어 집합에 패딩을 위한 토큰인 'pad'를 추가했었습니다. 패딩 작업은 정해준 길이로 모든 샘플들의 길이를 맞춰주되, 길이가 정해준 길이보다 짧은 샘플들에는 'pad' 토큰을 추가하여 길이를 맞춰주는 작업입니다. max_len = max(len(l) for l in encoded) print('리뷰의 최대 길이 : %d' % max_len) print('리뷰의 최소 길이 : %d' % min(len(l) for l in encoded)) print('리뷰의 평균 길이 : %f' % (sum(map(len, encoded))/len(encoded))) plt.hist([len(s) for s in encoded], bins=50) plt.xlabel('length of sample') plt.ylabel('number of sample') plt.show() 가장 길이가 긴 리뷰의 길이는 63입니다. 모든 리뷰의 길이를 63으로 통일시켜주겠습니다. for line in encoded: if len(line) < max_len: # 현재 샘플이 정해준 길이보다 짧으면 line += [word_to_index['pad']] * (max_len - len(line)) # 나머지는 전부 'pad' 토큰으로 채운다. print('리뷰의 최대 길이 : %d' % max(len(l) for l in encoded)) print('리뷰의 최소 길이 : %d' % min(len(l) for l in encoded)) print('리뷰의 평균 길이 : %f' % (sum(map(len, encoded))/len(encoded))) 리뷰의 최대 길이 : 63 리뷰의 최소 길이 : 63 리뷰의 평균 길이 : 63.000000 지면의 한계로 인해 상위 3개의 샘플들만 출력해 보겠습니다. print(encoded[:3]) [[78, 27, 9, 4, 50, 41, 79, 16, 28, 29, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [188, 5, 80, 189, 190, 191, 42, 192, 114, 5, 193, 194, 21, 115, 195, 196, 13, 51, 81, 116, 30, 42, 197, 117, 118, 31, 198, 5, 199, 200, 17, 114, 7, 82, 52, 17, 43, 201, 5, 202, 4, 203, 14, 7, 83, 32, 204, 84, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [205, 119, 206, 53, 207, 31, 208, 209, 54, 10, 25, 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] 이제 단어들을 고유한 정수로 매핑하였으니, 각 정수를 고유한 단어 벡터로 바꾸는 작업이 필요합니다. 단어 벡터를 얻는 방법은 크게 원-핫 인코딩과 워드 임베딩이 있는데, 주로 워드 임베딩이 사용됩니다. 원-핫 인코딩과 워드 임베딩에 대해서는 9챕터에서 다룹니다. 03-07 한국어 전처리 패키지(Text Preprocessing Tools for Korean Text) 유용한 한국어 전처리 패키지를 정리해 봅시다. 앞서 소개한 형태소와 문장 토크나이징 도구들인 KoNLPy와 KSS(Korean Sentence Splitter)와 함께 유용하게 사용할 수 있는 패키지들입니다. 1. PyKoSpacing pip install git+https://github.com/haven-jeon/PyKoSpacing.git 전희 원님이 개발한 PyKoSpacing은 띄어쓰기가 되어있지 않은 문장을 띄어쓰기를 한 문장으로 변환해 주는 패키지입니다. PyKoSpacing은 대용량 코퍼스를 학습하여 만들어진 띄어쓰기 딥 러닝 모델로 준수한 성능을 가지고 있습니다. sent = '김철수는 극중 두 인격의 사나이 이광수 역을 맡았다. 철수는 한국 유일의 태권도 전승자를 가리는 결전의 날을 앞두고 10년간 함께 훈련한 사형인 유연재(김광수 분)를 찾으러 속세로 내려온 인물이다.' 임의의 문장을 임의로 띄어쓰기가 없는 문장으로 만들었습니다. new_sent = sent.replace(" ", '') # 띄어쓰기가 없는 문장 임의로 만들기 print(new_sent) 김철수는극중두인격의사나이이광수역을맡았다.철수는한국유일의태권도전승자를가리는결전의날을앞두고10년간함께훈련한사형인유연재(김광수분)를찾으러속세로내려온인물이다. 이를 PyKoSpacing의 입력으로 사용하여 원 문장과 비교해 봅시다. from pykospacing import Spacing spacing = Spacing() kospacing_sent = spacing(new_sent) print(sent) print(kospacing_sent) 김철수는 극중 두 인격의 사나이 이광수 역을 맡았다. 철수는 한국 유일의 태권도 전승자를 가리는 결전의 날을 앞두고 10년간 함께 훈련한 사형인 유연재(김광수 분)를 찾으러 속세로 내려온 인물이다. 김철수는 극중 두 인격의 사나이 이광수 역을 맡았다. 철수는 한국 유일의 태권도 전승자를 가리는 결전의 날을 앞두고 10년간 함께 훈련한 사형인 유연재(김광수 분)를 찾으러 속세로 내려온 인물이다. 정확하게 결과가 일치합니다. 2. Py-Hanspell pip install git+https://github.com/ssut/py-hanspell.git Py-Hanspell은 네이버 한글 맞춤법 검사기를 바탕으로 만들어진 패키지입니다. from hanspell import spell_checker sent = "맞춤법 틀리면 왜 안돼? 쓰고 싶은 대로 쓰면 되지 " spelled_sent = spell_checker.check(sent) hanspell_sent = spelled_sent.checked print(hanspell_sent) 맞춤법 틀리면 왜 안돼? 쓰고 싶은 대로 쓰면 되지 이 패키지는 띄어쓰기 또한 보정합니다. PyKoSpacing에 사용한 예제를 그대로 사용해 봅시다. spelled_sent = spell_checker.check(new_sent) hanspell_sent = spelled_sent.checked print(hanspell_sent) print(kospacing_sent) # 앞서 사용한 kospacing 패키지에서 얻은 결과 김철수는 극 중 두 인격의 사나이 이광수 역을 맡았다. 철수는 한국 유일의 태권도 전승자를 가리는 결전의 날을 앞두고 10년간 함께 훈련한 사형인 유연제(김광수 분)를 찾으러 속세로 내려온 인물이다. 김철수는 극중 두 인격의 사나이 이광수 역을 맡았다. 철수는 한국 유일의 태권도 전승자를 가리는 결전의 날을 앞두고 10년간 함께 훈련한 사형인 유연재(김광수 분)를 찾으러 속세로 내려온 인물이다. PyKoSpacing과 결과가 거의 비슷하지만 조금 다릅니다. 3. SOYNLP를 이용한 단어 토큰화 soynlp는 품사 태깅, 단어 토큰화 등을 지원하는 단어 토크 나이저입니다. 비지도 학습으로 단어 토큰화를 한다는 특징을 갖고 있으며, 데이터에 자주 등장하는 단어들을 단어로 분석합니다. soynlp 단어 토크 나이저는 내부적으로 단어 점수 표로 동작합니다. 이 점수는 응집 확률(cohesion probability)과 브랜칭 엔트로피(branching entropy)를 활용합니다. pip install soynlp 1. 신조어 문제 soynlp를 소개하기 전에 기존의 형태소 분석기가 가진 문제는 무엇이었는지, SOYNLP가 어떤 점에서 유용한지 정리해 봅시다. 기존의 형태소 분석기는 신조어나 형태소 분석기에 등록되지 않은 단어 같은 경우에는 제대로 구분하지 못하는 단점이 있었습니다. from konlpy.tag import Okt tokenizer = Okt() print(tokenizer.morphs('에이비식스<NAME> 1월 최애돌 기부 요정')) ['에이', '비식스', '이대', '휘', '1월', '최애', '돌', '기부', '요정'] 에이비 식스는 아이돌의 이름이고,<NAME>는 에이비 식스의 멤버이며, 최애돌은 최고로 애정 하는 캐릭터라는 뜻이지만 위의 형태소 분석 결과에서는 전부 분리된 결과를 보여줍니다. 그렇다면 텍스트 데이터에서 특정 문자 시퀀스가 함께 자주 등장하는 빈도가 높고, 앞뒤로 조사 또는 완전히 다른 단어가 등장하는 것을 고려해서 해당 문자 시퀀스를 형태소라고 판단하는 단어 토크 나이저라면 어떨까요? 예를 들어 에이비 식스라는 문자열이 자주 연결되어 등장한다면 한 단어라고 판단하고, 또한 에이비 식스라는 단어 앞, 뒤에 '최고', '가수', '실력'과 같은 독립된 다른 단어들이 계속해서 등장한다면 에이비 식스를 한 단어로 파악하는 식이지요. 그리고 이런 아이디어를 가진 단어 토크 나이저가 soynlp입니다. 2. 학습하기 soynlp는 기본적으로 학습에 기반한 토크 나이저이므로 학습에 필요한 한국어 문서를 다운로드합니다. import urllib.request from soynlp import DoublespaceLineCorpus from soynlp.word import WordExtractor urllib.request.urlretrieve("https://raw.githubusercontent.com/lovit/soynlp/master/tutorials/2016-10-20.txt", filename="2016-10-20.txt") 훈련 데이터를 다수의 문서로 분리합니다. # 훈련 데이터를 다수의 문서로 분리 corpus = DoublespaceLineCorpus("2016-10-20.txt") len(corpus) 30091 총 3만 91개의 문서가 존재합니다. 상위 3개의 문서만 출력해 봅시다. 지면의 한계로 중략하였습니다. i = 0 for document in corpus: if len(document) > 0: print(document) i = i+1 if i == 3: break 19 1990 52 1 22 오패산 터널 총격전 용의자 검거 서울 연합뉴스 경찰 관계자들이 19일 오후 서울 강북구 오패산 터널 인근에서 사제 총기를 발사해 경찰을 살해한 용의자 성모 씨를 검거하고 있다 ... 중략 ... 숲에서 발견됐고 일부는 성씨가 소지한 가방 안에 있었다 테헤란 연합뉴스 강훈상 특파원 이용 승객수 기준 세계 최대 공항인 아랍에미리트 두바이 국제공항은 19일 현지시간 이 공항을 이륙하는 모든 항공기의 탑승객은 삼성전자의 갤럭시노트7을 휴대하면 안 된다고 밝혔다 ... 중략 ... 이런 조치는 두바이 국제공항뿐 아니라 신공항인 두바이 월드센터에도 적용된다 배터리 폭발 문제로 회수된 갤럭시노트7 연합뉴스 자료 사진 정상 출력되는 것을 확인하였습니다. soynlp는 학습 기반의 단어 토크 나이저이므로 기존의 KoNLPy에서 제공하는 형태소 분석기들과는 달리 학습 과정을 거쳐야 합니다. 이는 전체 코퍼스로부터 응집 확률과 브랜칭 엔트로피 단어 점수표를 만드는 과정입니다. WordExtractor.extract()를 통해서 전체 코퍼스에 대해 단어 점수표를 계산합니다. word_extractor = WordExtractor() word_extractor.train(corpus) word_score_table = word_extractor.extract() training was done. used memory 5.186 Gb all cohesion probabilities was computed. # words = 223348 all branching entropies was computed # words = 361598 all accessor variety was computed # words = 361598 학습이 완료되었습니다. 3. SOYNLP의 응집 확률(cohesion probability) 응집 확률은 내부 문자열(substring)이 얼마나 응집하여 자주 등장하는지를 판단하는 척도입니다. 응집 확률은 문자열을 문자 단위로 분리하여 내부 문자열을 만드는 과정에서 왼쪽부터 순서대로 문자를 추가하면서 각 문자열이 주어졌을 때 그다음 문자가 나올 확률을 계산하여 누적 곱을 한 값입니다. 이 값이 높을수록 전체 코퍼스에서 이 문자열 시퀀스는 하나의 단어로 등장할 가능성이 높습니다. 수식은 아래와 같습니다. '반포 한강공원에'라는 7의 길이를 가진 문자 시퀀스에 대해서 각 내부 문자열의 스코어를 구하는 과정은 아래와 같습니다. 실습을 통해 직접 응집 확률을 계산해 보겠습니다. '반포한'의 응집 확률을 계산해 봅시다. word_score_table["반포한"].cohesion_forward 0.08838002913645132 그렇다면 '반포 한강'의 응집 확률은 '반포한'의 응집 확률보다 높을까요? word_score_table["반포 한강"].cohesion_forward 0.19841268168224552 '반포 한강'은 '반포한'보다 응집 확률이 높습니다. 그렇다면 '반포한강공'은 어떨까요? word_score_table["반포한강공"].cohesion_forward 0.2972877884078849 역시나 '반포 한강'보다 응집 확률이 높습니다. '반포 한강공원'은 어떨까요? word_score_table["반포 한강공원"].cohesion_forward 0.37891487632839754 '반포한강공'보다 응집 확률이 높습니다. 여기다가 조사 '에'를 붙인 '반포 한강공원에'는 어떨까요? word_score_table["반포 한강공원에"].cohesion_forward 0.33492963377557666 오히려 '반포 한강공원'보다 응집도가 낮아집니다. 결국 결합 도는 '반포 한강공원'일 때가 가장 높았습니다. 응집도를 통해 판단하기에 하나의 단어로 판단하기에 가장 적합한 문자열은 '반포 한강공원'이라고 볼 수 있겠습니다. 4. SOYNLP의 브랜칭 엔트로피(branching entropy) Branching Entropy는 확률 분포의 엔트로피 값을 사용합니다. 이는 주어진 문자열에서 얼마나 다음 문자가 등장할 수 있는지를 판단하는 척도입니다. 퀴즈를 하나 내보겠습니다. 제가 어떤 단어를 생각 중인데, 한 문자씩 말해드릴 테니까 매번 다음 문자를 맞추는 것이 퀴즈입니다. 첫 번째 문자는 '디'입니다. 다음에 등장할 문자를 맞춰보세요. 솔직히 가늠이 잘 안 가지요? '디'로 시작하는 단어가 얼마나 많은데요. 정답은 '스'입니다. 이제 '디스'까지 나왔네요. '디스 '다음 문자는 뭘까요? '디스카운트'라는 단어가 있으니까 '카'일까? 아니면 '디스코드'라는 단어가 있으니까 '코'인가? 생각해 보니 '디스코'가 정답일 수도 있겠네요. 그러면 '코'인가? '디스아너드'라는 게임이 있으니까 '아'? 이 단어들을 생각하신 분들은 전부 틀렸습니다. 정답은 '플'이었습니다. '디스플'까지 왔습니다. 다음 문자 맞춰보세요. 이제 좀 명백해집니다. 정답은 '레'입니다. '디스플레이' 다음에는 어떤 문자일까요? 정답은 '이'입니다. 제가 생각한 단어는 '디스플레이'였습니다. 브랜칭 엔트로피를 주어진 문자 시퀀스에서 다음 문자 예측을 위해 헷갈리는 정도로 비유해 봅시다. 브랜칭 엔트로피의 값은 하나의 완성된 단어에 가까워질수록 문맥으로 인해 점점 정확히 예측할 수 있게 되면서 점점 줄어드는 양상을 보입니다. word_score_table["디스"].right_branching_entropy 1.6371694761537934 word_score_table["디스플"].right_branching_entropy -0.0 '디스' 다음에는 다양한 문자가 올 수 있으니까 1.63이라는 값을 가지는 반면, '디스플'이라는 문자열 다음에는 다음 문자로 '레'가 오는 것이 너무나 명백하기 때문에 0이란 값을 가집니다. word_score_table["디스플레이"].right_branching_entropy -0.0 word_score_table["디스플레이"].right_branching_entropy 3.1400392861792916 갑자기 값이 증가합니다. 그 이유는 문자 시퀀스 '디스플레이'라는 문자 시퀀스 다음에는 조사나 다른 단어와 같은 다양한 경우가 있을 수 있기 때문입니다. 이는 하나의 단어가 끝나면 그 경계 부분부터 다시 브랜칭 엔트로피 값이 증가하게 됨을 의미합니다. 그리고 이 값으로 단어를 판단하는 것이 가능하겠죠? 5. SOYNLP의 L tokenizer 한국어는 띄어쓰기 단위로 나눈 어절 토큰은 주로 L 토큰 + R 토큰의<NAME>을 가질 때가 많습니다. 예를 들어서 '공원에'는 '공원 +에'로 나눌 수 있겠지요. 또는 '공부하는'은 '공부 + 하는'으로 나눌 수도 있을 것입니다. L 토크 나이저는 L 토큰 + R 토큰으로 나누되, 분리 기준을 점수가 가장 높은 L 토큰을 찾아내는 원리를 가지고 있습니다. from soynlp.tokenizer import LTokenizer scores = {word:score.cohesion_forward for word, score in word_score_table.items()} l_tokenizer = LTokenizer(scores=scores) l_tokenizer.tokenize("국제사회와 우리의 노력들로 범죄를 척결하자", flatten=False) [('국제사회', '와'), ('우리', '의'), ('노력', '들로'), ('범죄', '를'), ('척결', '하자')] 6. 최대 점수 토크 나이저 최대 점수 토크 나이저는 띄어쓰기가 되지 않는 문장에서 점수가 높은 글자 시퀀스를 순차적으로 찾아내는 토크 나이저입니다. 띄어쓰기가 되어 있지 않은 문장을 넣어서 점수를 통해 토큰화된 결과를 보겠습니다. from soynlp.tokenizer import MaxScoreTokenizer maxscore_tokenizer = MaxScoreTokenizer(scores=scores) maxscore_tokenizer.tokenize("국제사회와 우리의 노력들로 범죄를 척결하자") ['국제사회', '와', '우리', '의', '노력', '들로', '범죄', '를', '척결', '하자'] 4. SOYNLP를 이용한 반복되는 문자 정제 SNS나 채팅 데이터와 같은 한국어 데이터의 경우에는 ㅋㅋ, ㅎㅎ 등의 이모티콘의 경우 불필요하게 연속되는 경우가 많은데 ㅋㅋ, ㅋㅋㅋ, ㅋㅋㅋㅋ와 같은 경우를 모두 서로 다른 단어로 처리하는 것은 불필요합니다. 이에 반복되는 것은 하나로 정규화시켜줍니다. from soynlp.normalizer import * print(emoticon_normalize('앜ㅋㅋㅋㅋ이영화존잼쓰ㅠㅠㅠㅠㅠ', num_repeats=2)) print(emoticon_normalize('앜ㅋㅋㅋㅋㅋㅋㅋㅋㅋ이영화존잼쓰ㅠㅠㅠㅠ', num_repeats=2)) print(emoticon_normalize('앜ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ이영화존잼쓰ㅠㅠㅠㅠㅠㅠ', num_repeats=2)) print(emoticon_normalize('앜ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ이영화존잼쓰ㅠㅠㅠㅠㅠㅠㅠㅠ', num_repeats=2)) 아ㅋㅋ영화존잼쓰ㅠㅠ 아ㅋㅋ영화존잼쓰ㅠㅠ 아ㅋㅋ영화존잼쓰ㅠㅠ 아ㅋㅋ영화존잼쓰ㅠㅠ 의미 없게 반복되는 것은 비단 이모티콘에 한정되지 않습니다. print(repeat_normalize('와하하하하하하하하하핫', num_repeats=2)) print(repeat_normalize('와하하 하하 하하 핫', num_repeats=2)) print(repeat_normalize('와하하 하하 핫', num_repeats=2)) 와하하 핫 와하하 핫 와하하 핫 5. Customized KoNLPy 영어권 언어는 띄어쓰기만 해도 단어들이 잘 분리되지만, 한국어는 그렇지 않다고 앞에서 몇 차례 언급했었습니다. 한국어 데이터를 사용하여 모델을 구현하는 것만큼 이번에는 형태소 분석기를 사용해서 단어 토큰화를 해보겠습니다. 그런데 형태소 분석기를 사용할 때, 이런 상황에 봉착한다면 어떻게 해야 할까요? 형태소 분석 입력 : '은경이는 사무실로 갔습니다.' 형태소 분석 결과 : ['은', '경이', '는', '사무실', '로', '갔습니다', '.'] 사실 위문장에서 '은경이'는 사람 이름이므로 제대로 된 결과를 얻기 위해서는 '은', '경이'와 같이 글자가 분리되는 것이 아니라 '은경이' 또는 최소한 '은경'이라는 단어 토큰을 얻어야만 합니다. 이런 경우에는 형태소 분석기에 사용자 사전을 추가해 줄 수 있습니다. '은경이'는 하나의 단어이기 때문에 분리하지 말라고 형태소 분석기에 알려주는 것입니다. 사용자 사전을 추가하는 방법은 형태소 분석기마다 다른데, 생각보다 복잡한 경우들이 많습니다. 이번 실습에서는 Customized Konlpy라는 사용자 사전 추가가 매우 쉬운 패키지를 사용합니다. pip install customized_konlpy customized_konlpy에서 제공하는 형태소 분석기 Twitter를 사용하여 앞서 소개했던 예문을 단어 토큰화해봅시다. from ckonlpy.tag import Twitter twitter = Twitter() twitter.morphs('은경이는 사무실로 갔습니다.') ['은', '경이', '는', '사무실', '로', '갔습니다', '.'] 앞서 소개한 예시와 마찬가지로 '은경이'라는 단어가 '은', '경이'와 같이 분리됩니다. 이때, 형태소 분석기 Twitter에 add_dictionary('단어', '품사')와 같은<NAME>으로 사전 추가를 해줄 수 있습니다. twitter.add_dictionary('은경이', 'Noun') 제대로 반영되었는지 동일한 예문을 다시 형태소 분석해 봅시다. twitter.morphs('은경이는 사무실로 갔습니다.') ['은경이', '는', '사무실', '로', '갔습니다', '.'] '은경이'라는 단어가 제대로 하나의 토큰으로 인식되는 것을 확인할 수 있습니다. 10. [NLP 입문 ] - 언어 모델(Language Model)이란? 이번 챕터에서는 자연어 처리 입문을 위해 필요한 개념인 언어 모델, BoW, TF-IDF, 그리고 벡터의 유사도에 대해서 다룹니다. 10-01 언어 모델(Language Model)이란? 언어 모델(Language Model, LM)은 언어라는 현상을 모델링하고 자 단어 시퀀스(문장)에 확률을 할당(assign) 하는 모델입니다. 언어 모델을 만드는 방법은 크게는 통계를 이용한 방법과 인공 신경망을 이용한 방법으로 구분할 수 있습니다. 최근에는 통계를 이용한 방법보다는 인공 신경망을 이용한 방법이 더 좋은 성능을 보여주고 있습니다. 최근 핫한 자연어 처리의 기술인 GPT나 BERT 또한 인공 신경망 언어 모델의 개념을 사용하여 만들어졌습니다. 이번 챕터에서는 언어 모델의 개념과 언어 모델의 전통적 접근 방식인 통계적 언어 모델에 대해서 배웁니다. 1. 언어 모델(Language Model) 언어 모델은 단어 시퀀스에 확률을 할당(assign) 하는 일을 하는 모델입니다. 이를 조금 풀어서 쓰면, 언어 모델은 가장 자연스러운 단어 시퀀스를 찾아내는 모델입니다. 단어 시퀀스에 확률을 할당하게 하기 위해서 가장 보편적으로 사용되는 방법은 언어 모델이 이전 단어들이 주어졌을 때 다음 단어를 예측하도록 하는 것입니다. 다른 유형의 언어 모델로는 주어진 양쪽의 단어들로부터 가운데 비어있는 단어를 예측하는 언어 모델이 있습니다. 이는 문장의 가운데에 있는 단어를 비워놓고 양쪽의 문맥을 통해서 빈칸의 단어인지 맞추는 고등학교 수험 시험의 빈칸 추론 문제와 비슷합니다. 이 유형의 언어 모델은 BERT 챕터에서 다루게 될 예정이고, 그때까지는 이전 단어들로부터 다음 단어를 예측하는 방식에만 집중합니다. 언어 모델에 -ing를 붙인 언어 모델링(Language Modeling)은 주어진 단어들로부터 아직 모르는 단어를 예측하는 작업을 말합니다. 즉, 언어 모델이 이전 단어들로부터 다음 단어를 예측하는 일은 언어 모델링입니다. 자연어 처리로 유명한 스탠퍼드 대학교에서는 언어 모델을 문법(grammar)이라고 비유하기도 합니다. 언어 모델이 단어들의 조합이 얼마나 적절한지, 또는 해당 문장이 얼마나 적합한지를 알려주는 일을 하는 것이 마치 문법이 하는 일 같기 때문입니다. 2. 단어 시퀀스의 확률 할당 자연어 처리에서 단어 시퀀스에 확률을 할당하는 일이 왜 필요할까요? 예를 들어보겠습니다. 여기서 대문자 P는 확률을 의미합니다. a. 기계 번역(Machine Translation): P(나는 버스를 탔다) > P(나는 버스를 태운다) : 언어 모델은 두 문장을 비교하여 좌측의 문장의 확률이 더 높다고 판단합니다. b. 오타 교정(Spell Correction) 선생님이 교실로 부리나케 P(달려갔다) > P(잘려갔다) : 언어 모델은 두 문장을 비교하여 좌측의 문장의 확률이 더 높다고 판단합니다. c. 음성 인식(Speech Recognition) P(나는 메롱을 먹는다) < P(나는 멜론을 먹는다) : 언어 모델은 두 문장을 비교하여 우측의 문장의 확률이 더 높다고 판단합니다. 언어 모델은 위와 같이 확률을 통해 보다 적절한 문장을 판단합니다. 3. 주어진 이전 단어들로부터 다음 단어 예측하기 언어 모델은 단어 시퀀스에 확률을 할당하는 모델입니다. 그리고 단어 시퀀스에 확률을 할당하기 위해서 가장 보편적으로 사용하는 방법은 이전 단어들이 주어졌을 때, 다음 단어를 예측하도록 하는 것입니다. 이를 조건부 확률로 표현해 보겠습니다. A. 단어 시퀀스의 확률 하나의 단어를, 단어 시퀀스를 대문자라고 한다면, 개의 단어가 등장하는 단어 시퀀스의 확률은 다음과 같습니다. ( ) P ( 1 w, 3 w, 5. . w) B. 다음 단어 등장 확률 다음 단어 등장 확률을 식으로 표현해 보겠습니다. -1개의 단어가 나열된 상태에서 번째 단어의 확률은 다음과 같습니다. ( n w, . , n 1 ) |의 기호는 조건부 확률(conditional probability)을 의미합니다. 예를 들어 다섯 번째 단어의 확률은 아래와 같습니다. ( 5 w, 2 w, 4 ) 전체 단어 시퀀스의 확률은 모든 단어가 예측되고 나서야 알 수 있으므로 단어 시퀀스의 확률은 다음과 같습니다. ( ) P ( 1 w, 3 w, 5. . n ) ∏ = n ( i w, . , 4. 언어 모델의 간단한 직관 비행기를 타려고 공항에 갔는데 지각을 하는 바람에 비행기를 [?]라는 문장이 있습니다. '비행기를' 다음에 어떤 단어가 오게 될지 사람은 쉽게 '놓쳤다'라고 예상할 수 있습니다. 우리 지식에 기반하여 나올 수 있는 여러 단어들을 후보에 놓고 놓쳤다는 단어가 나올 확률이 가장 높다고 판단하였기 때문입니다. 그렇다면 기계에게 위문장을 주고, '비행기를' 다음에 나올 단어를 예측해 보라고 한다면 과연 어떻게 최대한 정확히 예측할 수 있을까요? 기계도 비슷합니다. 앞에 어떤 단어들이 나왔는지 고려하여 후보가 될 수 있는 여러 단어들에 대해서 확률을 예측해 보고 가장 높은 확률을 가진 단어를 선택합니다. 앞에 어떤 단어들이 나왔는지 고려하여 후보가 될 수 있는 여러 단어들에 대해서 등장 확률을 추정하고 가장 높은 확률을 가진 단어를 선택합니다. 5. 검색 엔진에서의 언어 모델의 예 검색 엔진이 입력된 단어들의 나열에 대해서 다음 단어를 예측하는 언어 모델을 사용하고 있습니다. 10-02 통계적 언어 모델(Statistical Language Model, SLM) 언어 모델의 전통적인 접근 방법인 통계적 언어 모델을 소개합니다. 통계적 언어 모델이 통계적인 접근 방법으로 어떻게 언어를 모델링 하는지 배워보겠습니다. 통계적 언어 모델(Statistical Language Model)은 줄여서 SLM이라고 합니다. 1. 조건부 확률 조건부 확률은 두 확률 ( ) P ( ) 에 대해서 아래와 같은 관계를 갖습니다. ( | ) P ( , ) P ( ) ( , ) P ( ) ( | ) 더 많은 확률에 대해서 일반화해봅시다. 4개의 확률이 조건부 확률의 관계를 가질 때, 아래와 같이 표현할 수 있습니다. ( , , , ) P ( ) ( | ) ( | , ) ( | , , ) 이를 조건부 확률의 연쇄 법칙(chain rule)이라고 합니다. 이제는 4개가 아닌 개에 대해서 일반화를 해봅시다. ( 1 x, 3. x) P ( 1 ) ( 2 x) ( 3 x, 2 ) . P ( n x 조건부 확률에 대한 정의를 통해 문장의 확률을 구해보겠습니다. 2. 문장에 대한 확률 문장 'An adorable little boy is spreading smiles'의 확률 ( An adorable little boy is spreading smiles ) 를 식으로 표현해 봅시다. 각 단어는 문맥이라는 관계로 인해 이전 단어의 영향을 받아 나온 단어입니다. 그리고 모든 단어로부터 하나의 문장이 완성됩니다. 그렇기 때문에 문장의 확률을 구하고자 조건부 확률을 사용하겠습니다. 앞서 언급한 조건부 확률의 일반화 식을 문장의 확률 관점에서 다시 적어보면 문장의 확률은 각 단어들이 이전 단어가 주어졌을 때 다음 단어로 등장할 확률의 곱으로 구성됩니다. ( 1 w, 3 w, 5. . n ) ∏ = n ( n w, . , n 1 ) 위의 문장에 해당 식을 적용해 보면 다음과 같습니다. ( An adorable little boy is spreading smiles ) P ( An ) P ( adorable|An ) P ( little|An adorable ) P ( boy|An adorable little ) P ( is|An adorable little boy ) P ( spreading|An adorable little boy is ) P ( smiles|An adorable little boy is spreading ) 문장의 확률을 구하기 위해서 각 단어에 대한 예측 확률들을 곱합니다. 3. 카운트 기반의 접근 문장의 확률을 구하기 위해서 다음 단어에 대한 예측 확률을 모두 곱한다는 것은 알았습니다. 그렇다면 SLM은 이전 단어로부터 다음 단어에 대한 확률은 어떻게 구할까요? 정답은 카운트에 기반하여 확률을 계산합니다. An adorable little boy가 나왔을 때, is가 나올 확률인 ( is|An adorable little boy ) 를 구해봅시다. (is|An adorable little boy ) count(An adorable little boy is ) count(An adorable little boy ) 그 확률은 위와 같습니다. 예를 들어 기계가 학습한 코퍼스 데이터에서 An adorable little boy가 100번 등장했는데 그다음에 is가 등장한 경우는 30번이라고 합시다. 이 경우 ( is|An adorable little boy ) 는 30%입니다. 4. 카운트 기반 접근의 한계 - 희소 문제(Sparsity Problem) 언어 모델은 실생활에서 사용되는 언어의 확률 분포를 근사 모델링 합니다. 실제로 정확하게 알아볼 방법은 없겠지만 현실에서도 An adorable little boy가 나왔을 때 is가 나올 확률이라는 것이 존재합니다. 이를 실제 자연어의 확률 분포, 현실에서의 확률 분포라고 명칭 합시다. 기계에게 많은 코퍼스를 훈련시켜서 언어 모델을 통해 현실에서의 확률 분포를 근사하는 것이 언어 모델의 목표입니다. 그런데 카운트 기반으로 접근하려고 한다면 갖고 있는 코퍼스(corpus). 즉, 다시 말해 기계가 훈련하는 데이터는 정말 방대한 양이 필요합니다. (is|An adorable little boy ) count(An adorable little boy is ) count(An adorable little boy ) 예를 들어 위와 같이 (is|An adorable little boy ) 를 구하는 경우에서 기계가 훈련한 코퍼스에 An adorable little boy is라는 단어 시퀀스가 없었다면 이 단어 시퀀스에 대한 확률은 0이 됩니다. 또는 An adorable little boy라는 단어 시퀀스가 없었다면 분모가 0이 되어 확률은 정의되지 않습니다. 그렇다면 코퍼스에 단어 시퀀스가 없다고 해서 이 확률을 0 또는 정의되지 않는 확률이라고 하는 것이 정확한 모델링 방법일까요? 아닙니다. 현실에선 An adorable little boy is라는 단어 시퀀스가 존재하고 또 문법에도 적합하므로 정답일 가능성 또한 높습니다. 이와 같이 충분한 데이터를 관측하지 못하여 언어를 정확히 모델링 하지 못하는 문제를 희소 문제(sparsity problem)라고 합니다. 위 문제를 완화하는 방법으로 바로 이어서 배우게 되는 n-gram 언어 모델이나 이 책에서 다루지는 않지만 스무딩이나 백오프와 같은 여러 가지 일반화(generalization) 기법이 존재합니다. 하지만 희소 문제에 대한 근본적인 해결책은 되지 못하였습니다. 결국 이러한 한계로 인해 언어 모델의 트렌드는 통계적 언어 모델에서 인공 신경망 언어 모델로 넘어가게 됩니다. 10-03 N-gram 언어 모델(N-gram Language Model) n-gram 언어 모델은 여전히 카운트에 기반한 통계적 접근을 사용하고 있으므로 SLM의 일종입니다. 다만, 앞서 배운 언어 모델과는 달리 이전에 등장한 모든 단어를 고려하는 것이 아니라 일부 단어만 고려하는 접근 방법을 사용합니다. 그리고 이때 일부 단어를 몇 개 보느냐를 결정하는데 이것이 n-gram에서의 n이 가지는 의미입니다. 1. 코퍼스에서 카운트하지 못하는 경우의 감소. SLM의 한계는 훈련 코퍼스에 확률을 계산하고 싶은 문장이나 단어가 없을 수 있다는 점입니다. 그리고 확률을 계산하고 싶은 문장이 길어질수록 갖고 있는 코퍼스에서 그 문장이 존재하지 않을 가능성이 높습니다. 다시 말하면 카운트할 수 없을 가능성이 높습니다. 그런데 다음과 같이 참고하는 단어들을 줄이면 카운트를 할 수 있을 가능성을 높일 수 있습니다. ( is|An adorable little boy ) P ( is|boy ) 가령, An adorable little boy가 나왔을 때 is가 나올 확률을 그냥 boy가 나왔을 때 is가 나올 확률로 생각해 보는 건 어떨까요? 갖고 있는 코퍼스에 An adorable little boy is가 있을 가능성보다는 boy is라는 더 짧은 단어 시퀀스가 존재할 가능성이 더 높습니다. 조금 지나친 일반화로 느껴진다면 아래와 같이 little boy가 나왔을 때 is가 나올 확률로 생각하는 것도 대안입니다. ( is|An adorable little boy ) P ( is|little boy ) 즉, 앞에서는 An adorable little boy가 나왔을 때 is가 나올 확률을 구하기 위해서는 An adorable little boy가 나온 횟수와 An adorable little boy is가 나온 횟수를 카운트해야만 했지만, 이제는 단어의 확률을 구하고자 기준 단어의 앞 단어를 전부 포함해서 카운트하는 것이 아니라, 앞 단어 중 임의의 개수만 포함해서 카운트하여 근사하자는 것입니다. 이렇게 하면 갖고 있는 코퍼스에서 해당 단어의 시퀀스를 카운트할 확률이 높아집니다. 2. N-gram 이때 임의의 개수를 정하기 위한 기준을 위해 사용하는 것이 n-gram입니다. n-gram은 n 개의 연속적인 단어 나열을 의미합니다. 갖고 있는 코퍼스에서 n 개의 단어 뭉치 단위로 끊어서 이를 하나의 토큰으로 간주합니다. 예를 들어서 문장 An adorable little boy is spreading smiles이 있을 때, 각 n에 대해서 n-gram을 전부 구해보면 다음과 같습니다. unigrams : an, adorable, little, boy, is, spreading, smiles bigrams : an adorable, adorable little, little boy, boy is, is spreading, spreading smiles trigrams : an adorable little, adorable little boy, little boy is, boy is spreading, is spreading smiles 4-grams : an adorable little boy, adorable little boy is, little boy is spreading, boy is spreading smiles n-gram을 사용할 때는 n이 1일 때는 유니그램(unigram), 2일 때는 바이 그램(bigram), 3일 때는 트라이 그램(trigram)이라고 명명하고 n이 4 이상일 때는 gram 앞에 그대로 숫자를 붙여서 명명합니다. 출처에 따라서는 유니그램, 바이 그램, 트라이 그램 또한 각각 1-gram, 2-gram, 3-gram이라고 하기도 합니다. n-gram을 이용한 언어 모델을 설계해 보겠습니다. n-gram을 통한 언어 모델에서는 다음에 나올 단어의 예측은 오직 n-1개의 단어에만 의존합니다. 예를 들어 'An adorable little boy is spreading' 다음에 나올 단어를 예측하고 싶다고 할 때, n=4라고 한 4-gram을 이용한 언어 모델을 사용한다고 합시다. 이 경우, spreading 다음에 올 단어를 예측하는 것은 n-1에 해당되는 앞의 3개의 단어만을 고려합니다. ( |boy is spreading ) count(boy is spreading w ) count(boy is spreading) 만약 갖고 있는 코퍼스에서 boy is spreading가 1,000번 등장했다고 합시다. 그리고 boy is spreading insults가 500번 등장했으며, boy is spreading smiles가 200번 등장했다고 합시다. 그렇게 되면 boy is spreading 다음에 insults가 등장할 확률은 50%이며, smiles가 등장할 확률은 20%입니다. 확률적 선택에 따라 우리는 insults가 더 맞는다고 판단하게 됩니다. ( insults|boy is spreading ) 0.500 ( smiles|boy is spreading ) 0.200 3. N-gram Language Model의 한계 앞서 4-gram을 통한 언어 모델의 동작 방식을 확인했습니다. 그런데 조금 의문이 남습니다. 앞서 본 4-gram 언어 모델은 주어진 문장에서 앞에 있던 단어인 '작고 사랑스러운(an adorable little)'이라는 수식어를 제거하고, 반영하지 않았습니다. 그런데 '작고 사랑스러운' 수식어까지 모두 고려하여 작고 사랑하는 소년이 하는 행동에 대해 다음 단어를 예측하는 언어 모델이었다면 과연 '작고 사랑스러운 소년이' '모욕을 퍼트렸다'라는 부정적인 내용이 '웃음 지었다'라는 긍정적인 내용 대신 선택되었을까요? 물론 코퍼스 데이터를 어떻게 가정하느냐의 나름이고, 전혀 말이 안 되는 문장은 아니지만 여기서 지적하고 싶은 것은 n-gram은 앞의 단어 몇 개만 보다 보니 의도하고 싶은 대로 문장을 끝맺음하지 못하는 경우가 생긴다는 점입니다. 문장을 읽다 보면 앞 부분과 뒷부분의 문맥이 전혀 연결 안 되는 경우도 생길 수 있습니다. 결론만 말하자면, 전체 문장을 고려한 언어 모델보다는 정확도가 떨어질 수밖에 없습니다. 이를 토대로 n-gram 모델에 대한 한계점을 정리해 보겠습니다. (1) 희소 문제(Sparsity Problem) 문장에 존재하는 앞에 나온 단어를 모두 보는 것보다 일부 단어만을 보는 것으로 현실적으로 코퍼스에서 카운트할 수 있는 확률을 높일 수는 있었지만, n-gram 언어 모델도 여전히 n-gram에 대한 희소 문제가 존재합니다. (2) n을 선택하는 것은 trade-off 문제. 앞에서 몇 개의 단어를 볼지 n을 정하는 것은 trade-off가 존재합니다. 임의의 개수인 n을 1보다는 2로 선택하는 것은 거의 대부분의 경우에서 언어 모델의 성능을 높일 수 있습니다. 가령, spreading만 보는 것보다는 is spreading을 보고 다음 단어를 예측하는 것이 더 정확하기 때문입니다. 이 경우 훈련 데이터가 적절한 데이터였다면 언어 모델이 적어도 spreading 다음에 동사를 고르지 않을 것입니다. n을 크게 선택하면 실제 훈련 코퍼스에서 해당 n-gram을 카운트할 수 있는 확률은 적어지므로 희소 문제는 점점 심각해집니다. 또한 n이 커질수록 모델 사이즈가 커진다는 문제점도 있습니다. 기본적으로 코퍼스의 모든 n-gram에 대해서 카운트를 해야 하기 때문입니다. n을 작게 선택하면 훈련 코퍼스에서 카운트는 잘 되겠지만 근사의 정확도는 현실의 확률분포와 멀어집니다. 그렇기 때문에 적절한 n을 선택해야 합니다. 앞서 언급한 trade-off 문제로 인해 정확도를 높이려면 n은 최대 5를 넘게 잡아서는 안 된다고 권장되고 있습니다. n이 성능에 영향을 주는 것을 확인할 수 있는 유명한 예제 하나를 보겠습니다. 스탠퍼드 대학교의 공유 자료에 따르면, 월스트리트 저널에서 3,800만 개의 단어 토큰에 대하여 n-gram 언어 모델을 학습하고, 1,500만 개의 테스트 데이터에 대해서 테스트를 했을 때 다음과 같은 성능이 나왔다고 합니다. 뒤에서 배우겠지만, 펄 플렉서티(perplexity)는 수치가 낮을수록 더 좋은 성능을 나타냅니다. Unigram Bigram Trigram Perplexity 962 170 109 위의 결과는 n을 1에서 2, 2에서 3으로 올릴 때마다 성능이 올라가는 것을 보여줍니다. 4. 적용 분야(Domain)에 맞는 코퍼스의 수집 어떤 분야인지, 어떤 애플리케이션인지에 따라서 특정 단어들의 확률 분포는 당연히 다릅니다. 가령, 마케팅 분야에서는 마케팅 단어가 빈번하게 등장할 것이고, 의료 분야에서는 의료 관련 단어가 당연히 빈번하게 등장합니다. 이 경우 언어 모델에 사용하는 코퍼스를 해당 도메인의 코퍼스를 사용한다면 당연히 언어 모델이 제대로 된 언어 생성을 할 가능성이 높아집니다. 때로는 이를 언어 모델의 약점이라고 하는 경우도 있는데, 훈련에 사용된 도메인 코퍼스가 무엇이냐에 따라서 성능이 비약적으로 달라지기 때문입니다. 5. 인공 신경망을 이용한 언어 모델(Neural Network Based Language Model) 여기서는 다루지 않겠지만, N-gram Language Model의 한계점을 극복하기 위해 분모, 분자에 숫자를 더해서 카운트했을 때 0이 되는 것을 방지하는 등의 여러 일반화(generalization) 방법들이 존재합니다. 하지만 그럼에도 본질적으로 n-gram 언어 모델에 대한 취약점을 완전히 해결하지는 못하였고, 이를 위한 대안으로 N-gram Language Model보다 대체적으로 성능이 우수한 인공 신경망을 이용한 언어 모델이 많이 사용되고 있습니다. 10-04 한국어에서의 언어 모델(Language Model for Korean Sentences) 영어나 기타 언어에 비해서 한국어는 언어 모델로 다음 단어를 예측하기가 훨씬 까다롭습니다. 1. 한국어는 어순이 중요하지 않다. 한국어에서는 어순이 중요하지 않습니다. 그래서 이전 단어가 주어졌을 때, 다음 단어가 나타날 확률을 구해야 하는데 어순이 중요하지 않다는 것은 다음 단어로 어떤 단어든 등장할 수 있다는 의미입니다. 예를 들어보겠습니다. 1. 나는 운동을 합니다 체육관에서. 2. 나는 체육관에서 운동을 합니다. 3. 체육관에서 운동을 합니다. 4. 나는 운동을 체육관에서 합니다. 4개의 문장은 전부 의미가 통하는 것을 볼 수 있습니다. 심지어 '나는'이라는 주어를 생략해도 말이 돼버립니다. 이렇게 단어 순서를 뒤죽박죽으로 바꾸어놔도 한국어는 의미가 전달되기 때문에 확률에 기반한 언어 모델이 제대로 다음 단어를 예측하기가 어렵습니다. 2. 한국어는 교착어이다. 한국어는 교착어입니다. 이는 한국어에서의 언어 모델 작동을 어렵게 만듭니다. 띄어쓰기 단위인 어절 단위로 토큰화를 할 경우에는 문장에서 발생 가능한 단어의 수가 굉장히 늘어납니다. 대표적인 예로 교착어인 한국어에는 조사가 있습니다. 영어는 기본적으로 조사가 없습니다. 하지만 한국어에는 어떤 행동을 하는 동사의 주어나 목적어를 위해서 조사라는 것이 있습니다. 가령 '그녀'라는 단어 하나만 해도 그녀가, 그녀를, 그녀의, 그녀와, 그녀로, 그녀께서, 그녀처럼 등과 같이 다양한 경우가 존재합니다. 그렇기 때문에, 한국어에서는 토큰화를 통해 접사나 조사 등을 분리하는 것은 중요한 작업이 되기도 합니다. 3. 한국어는 띄어쓰기가 제대로 지켜지지 않는다. 한국어는 띄어쓰기를 제대로 하지 않아도 의미가 전달되며, 띄어쓰기 규칙 또한 상대적으로 까다로운 언어이기 때문에 자연어 처리를 하는 것에 있어서 한국어 코퍼스는 띄어쓰기가 제대로 지켜지지 않는 경우가 많습니다. 토큰이 제대로 분리되지 않는 채 훈련 데이터로 사용된다면 언어 모델은 제대로 동작하지 않습니다. 10-05 펄 플렉서티(Perplexity, PPL) 두 개의 모델 A, B가 있을 때 이 모델의 성능은 어떻게 비교할 수 있을까요? 두 개의 모델을 오타 교정, 기계 번역 등의 평가에 투입해 볼 수 있겠습니다. 그리고 두 모델이 해당 업무의 성능을 누가 더 잘했는지를 비교하면 되겠습니다. 그런데 두 모델의 성능을 비교하고자, 일일이 모델들에 대해서 실제 작업을 시켜보고 정확도를 비교하는 작업은 공수가 너무 많이 드는 작업입니다. 만약 비교해야 하는 모델이 두 개가 아니라 그 이상의 수라면 시간은 비교해야 하는 모델의 수만큼 배로 늘어날 수도 있습니다. 이러한 평가보다는 어쩌면 조금은 부정확할 수는 있어도 테스트 데이터에 대해서 빠르게 식으로 계산되는 더 간단한 평가 방법이 있습니다. 바로 모델 내에서 자신의 성능을 수치화하여 결과를 내놓는 펄 플렉서티(perplexity)입니다. 1. 언어 모델의 평가 방법(Evaluation metric) : PPL 펄 플렉서티(perplexity)는 언어 모델을 평가하기 위한 평가 지표입니다. 보통 줄여서 PPL이라고 표현합니다. 왜 perplexity라는 용어를 사용했을까요? 영어에서 'perplexed'는 '헷갈리는'과 유사한 의미를 가집니다. 그러니까 여기서 PPL은 '헷갈리는 정도'로 이해합시다. PPL를 처음 배울 때 다소 낯설게 느껴질 수 있는 점이 있다면, PPL은 수치가 높으면 좋은 성능을 의미하는 것이 아니라, '낮을수록' 언어 모델의 성능이 좋다는 것을 의미한다는 점입니다. PPL은 문장의 길이로 정규화된 문장 확률의 역수입니다. 문장의 길이가 이라고 하였을 때의 PPL은 다음과 같습니다. P ( ) P ( 1 w, 3. . w) 1 = P ( 1 w, 3. . N 문장의 확률에 체인 룰(chain rule)을 적용하면 아래와 같습니다. P ( ) 1 ( 1 w, 3. . w) = ∏ = N ( i w, 2 여기에 n-gram을 적용해 볼 수도 있습니다. 예를 들어 bigram 언어 모델의 경우에는 식이 아래와 같습니다. P ( ) 1 i 1 P ( i w − ) 2. 분기 계수(Branching factor) PPL은 선택할 수 있는 가능한 경우의 수를 의미하는 분기 계수(branching factor)입니다. PPL은 이 언어 모델이 특정 시점에서 평균적으로 몇 개의 선택지를 가지고 고민하고 있는지를 의미합니다. 가령, 언어 모델에 어떤 테스트 데이터을 주고 측정했더니 PPL이 10이 나왔다고 해봅시다. 그렇다면 해당 언어 모델은 테스트 데이터에 대해서 다음 단어를 예측하는 모든 시점(time step)마다 평균 10개의 단어를 가지고 어떤 것이 정답인지 고민하고 있다고 볼 수 있습니다. 같은 테스트 데이터에 대해서 두 언어 모델의 PPL을 각각 계산 후에 PPL의 값을 비교하면, 두 언어 모델 중 PPL이 더 낮은 언어 모델의 성능이 더 좋다고 볼 수 있습니다. P ( ) P ( 1 w, 3. . w) 1 = ( 10 ) 1 = 10 1 10 단, 평가 방법에 있어서 주의할 점은 PPL의 값이 낮다는 것은 테스트 데이터 상에서 높은 정확도를 보인다는 것이지, 사람이 직접 느끼기에 좋은 언어 모델이라는 것을 반드시 의미하진 않는다는 점입니다. 또한 언어 모델의 PPL은 테스트 데이터에 의존하므로 두 개 이상의 언어 모델을 비교할 때는 정량적으로 양이 많고, 또한 도메인에 알맞은 동일한 테스트 데이터를 사용해야 신뢰도가 높다는 것입니다. 3. 기존 언어 모델 Vs. 인공 신경망을 이용한 언어 모델. 페이스북 AI 연구팀은 앞서 배운 n-gram 언어 모델과 이후 배우게 될 딥 러닝을 이용한 언어 모델에 대해서 PPL로 성능 테스트를 한 표를 공개한 바 있습니다. 링크 : https://engineering.fb.com/2016/10/25/ml-applications/building-an-efficient-neural-language-model-over-a-billion-words/ 표에서 맨 위의 줄의 언어 모델이 n-gram을 이용한 언어 모델이며 PPL이 67.6으로 측정되었습니다. 5-gram을 사용하였으며, 5-gram 앞에 Interpolated Kneser-Ney라는 이름이 붙었는데 이 책에서는 별도 설명을 생략하겠다고 했던 일반화(generalization) 방법이 사용된 모델입니다. 반면, 그 아래의 모델들은 인공 신경망을 이용한 언어 모델들로 페이스북 AI 연구팀이 자신들의 언어 모델을 다른 언어 모델과 비교하고자 하는 목적으로 기록하였습니다. 아직 RNN과 LSTM 등이 무엇인지 배우지는 않았지만, 인공 신경망을 이용한 언어 모델들은 대부분 n-gram을 이용한 언어 모델보다 더 좋은 성능 평가를 받았음을 확인할 수 있습니다. 11. [NLP 입문 ] - 텍스트의 유사도(Text similarity) 자연어 처리에서 텍스트를 표현하는 방법으로는 여러 가지 방법이 있습니다. 이번 챕터에서는 그중 정보 검색과 텍스트 마이닝 분야에서 주로 사용되는 카운트 기반의 텍스트 표현 방법인 DTM(Document Term Matrix)과 TF-IDF(Term Frequency-Inverse Document Frequency)에 대해서 다룹니다. 텍스트를 위와 같은 방식으로 수치화를 하고 나면, 통계적인 접근 방법을 통해 여러 문서로 이루어진 텍스트 데이터가 있을 때 어떤 단어가 특정 문서 내에서 얼마나 중요한 것인지를 나타내거나, 문서의 핵심어 추출, 검색 엔진에서 검색 결과의 순위 결정, 문서들 간의 유사도를 구하는 등의 용도로 사용할 수 있습니다. 11-01 단어의 표현 방법 여기서는 카운트 기반의 단어 표현 방법 외에도 다양한 단어의 표현 방법에는 어떤 것이 있으며, 앞으로 이 책에서는 어떤 순서로 단어 표현 방법을 학습하게 될 것인지에 대해서 먼저 설명합니다. 1. 단어의 표현 방법 단어의 표현 방법은 크게 국소 표현(Local Representation) 방법과 분산 표현(Distributed Representation) 방법으로 나뉩니다. 국소 표현 방법은 해당 단어 그 자체만 보고, 특정 값을 매핑하여 단어를 표현하는 방법이며, 분산 표현 방법은 그 단어를 표현하고자 주변을 참고하여 단어를 표현하는 방법입니다. 예를 들어 puppy(강아지), cute(귀여운), lovely(사랑스러운)라는 단어가 있을 때 각 단어에 1번, 2번, 3번 등과 같은 숫자를 매핑(mapping) 하여 부여한다면 이는 국소 표현 방법에 해당됩니다. 반면, 분산 표현 방법의 예를 하나 들어보면 해당 단어를 표현하기 위해 주변 단어를 참고합니다. puppy(강아지)라는 단어 근처에는 주로 cute(귀여운), lovely(사랑스러운)이라는 단어가 자주 등장하므로, puppy라는 단어는 cute, lovely 한 느낌이 다로 단어를 정의합니다. 이렇게 되면 이 두 방법의 차이는 국소 표현 방법은 단어의 의미, 뉘앙스를 표현할 수 없지만, 분산 표현 방법은 단어의 뉘앙스를 표현할 수 있게 됩니다. 또한 비슷한 의미로 국소 표현 방법(Local Representation)을 이산 표현(Discrete Representation)이라고도 하며, 분산 표현(Distributed Representation)을 연속 표현(Continuous Represnetation)이라고도 합니다. 추가 의견으로 구글의 연구원 토마스 미코 로브(Tomas Mikolov)는 2016년에 한 발표에서 잠재 의미 분석(LSA)이나 잠재 디리클레 할당(LDA)과 같은 방법들은 단어의 의미를 표현할 수 있다는 점에서 연속 표현(Continuous Represnetation)이지만, 엄밀히 말해서 다른 접근의 방법론을 사용하고 있는 워드투벡터(Word2vec)와 같은 분산 표현(Distributed Representation)은 아닌 것으로 분류하여 연속 표현을 분산 표현을 포괄하고 있는 더 큰 개념으로 설명하기도 했습니다. 2. 단어 표현의 카테고리화 이 책에서는 아래와 같은 기준으로 단어 표현을 카테고리화하여 작성되었습니다. 이번 챕터의 Bag of Words는 국소 표현에(Local Representation)에 속하며, 단어의 빈도수를 카운트(Count) 하여 단어를 수치화하는 단어 표현 방법입니다. 이 챕터에서는 BoW와 그의 확장인 DTM(또는 TDM)에 대해서 학습하고, 이러한 빈도수 기반 단어 표현에 단어의 중요도에 따른 가중치를 줄 수 있는 TF-IDF에 대해서 학습합니다. 워드 임베딩 챕터에서는 연속 표현(Continuous Representation)에 속하면서, 예측(prediction)을 기반으로 단어의 뉘앙스를 표현하는 워드투벡터(Word2Vec)와 그의 확장인 패스트 텍스트(FastText)를 학습하고, 예측과 카운트라는 두 가지 방법이 모두 사용된 글로브(GloVe)에 대해서 학습합니다. 11-02백 오브 워즈(Bag of Words) 방법 단어의 등장 순서를 고려하지 않는 빈도수 기반의 단어 표현 방법인 Bag of Words에 대해서 학습합니다. 1. Bag of Words란? Bag of Words란 단어들의 순서는 전혀 고려하지 않고, 단어들의 출현 빈도(frequency)에만 집중하는 텍스트 데이터의 수치화 표현 방법입니다. Bag of Words를 직역하면 단어들의 가방이라는 의미입니다. 단어들이 들어있는 가방을 상상해 봅시다. 갖고 있는 어떤 텍스트 문서에 있는 단어들을 가방에다가 전부 넣습니다. 그 후에는 이 가방을 흔들어 단어들을 섞습니다. 만약, 해당 문서 내에서 특정 단어가 N 번 등장했다면, 이 가방에는 그 특정 단어가 N 개 있게 됩니다. 또한 가방을 흔들어서 단어를 섞었기 때문에 더 이상 단어의 순서는 중요하지 않습니다. BoW를 만드는 과정을 이렇게 두 가지 과정으로 생각해 보겠습니다. (1) 각 단어에 고유한 정수 인덱스를 부여합니다. # 단어 집합 생성. (2) 각 인덱스의 위치에 단어 토큰의 등장 횟수를 기록한 벡터를 만듭니다. 한국어 예제를 통해서 BoW에 대해서 이해해 보도록 하겠습니다. 문서 1 : 정부가 발표하는 물가 상승률과 소비자가 느끼는 물가 상승률은 다르다. 문서 1에 대해서 BoW를 만들어보겠습니다. 아래의 함수는 입력된 문서에 대해서 단어 집합(vocaburary)을 만들어 각 단어에 정수 인덱스를 할당하고, BoW를 만듭니다. from konlpy.tag import Okt okt = Okt() def build_bag_of_words(document): # 온점 제거 및 형태소 분석 document = document.replace('.', '') tokenized_document = okt.morphs(document) word_to_index = {} bow = [] for word in tokenized_document: if word not in word_to_index.keys(): word_to_index[word] = len(word_to_index) # BoW에 전부 기본값 1을 넣는다. bow.insert(len(word_to_index) - 1, 1) else: # 재등장하는 단어의 인덱스 index = word_to_index.get(word) # 재등장한 단어는 해당하는 인덱스의 위치에 1을 더한다. bow[index] = bow[index] + 1 return word_to_index, bow 해당 함수에 문서 1을 입력으로 넣어봅시다. doc1 = "정부가 발표하는 물가 상승률과 소비자가 느끼는 물가 상승률은 다르다." vocab, bow = build_bag_of_words(doc1) print('vocabulary :', vocab) print('bag of words vector :', bow) vocabulary : {'정부': 0, '가': 1, '발표': 2, '하는': 3, '물가 상승률': 4, '과': 5, '소비자': 6, '느끼는': 7, '은': 8, '다르다': 9} bag of words vector : [1, 2, 1, 1, 2, 1, 1, 1, 1, 1] 문서 1에 각 단어에 대해서 인덱스를 부여한 결과는 첫 번째 출력 결과입니다. 문서 1의 BoW는 두 번째 출력 결과입니다. 두 번째 출력 결과를 보면, 인덱스 4에 해당하는 물가 상승률은 두 번 언급되었기 때문에 인덱스 4에 해당하는 값이 2입니다. 인덱스는 0부터 시작됨에 주의합니다. 다시 말해 물가 상승률은 BoW에서 다섯 번째 값입니다. 만약, 한국어에서 불용어에 해당되는 조사들 또한 제거한다면 더 정제된 BoW를 만들 수도 있습니다. 2. Bag of Words의 다른 예제들 문서 2 : 소비자는 주로 소비하는 상품을 기준으로 물가 상승률을 느낀다. 위의 함수에 임의의 문서 2를 입력으로 하여 결과를 확인해 봅시다. doc2 = '소비자는 주로 소비하는 상품을 기준으로 물가 상승률을 느낀다.' vocab, bow = build_bag_of_words(doc2) print('vocabulary :', vocab) print('bag of words vector :', bow) vocabulary : {'소비자': 0, '는': 1, '주로': 2, '소비': 3, '하는': 4, '상품': 5, '을': 6, '기준': 7, '으로': 8, '물가 상승률': 9, '느낀다': 10} bag of words vector : [1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1] 문서 1과 문서 2를 합쳐서 문서 3이라고 명명하고, BoW를 만들 수도 있습니다. 문서 3: 정부가 발표하는 물가 상승률과 소비자가 느끼는 물가 상승률은 다르다. 소비자는 주로 소비하는 상품을 기준으로 물가 상승률을 느낀다. doc3 = doc1 + ' ' + doc2 vocab, bow = build_bag_of_words(doc3) print('vocabulary :', vocab) print('bag of words vector :', bow) vocabulary : {'정부': 0, '가': 1, '발표': 2, '하는': 3, '물가 상승률': 4, '과': 5, '소비자': 6, '느끼는': 7, '은': 8, '다르다': 9, '는': 10, '주로': 11, '소비': 12, '상품': 13, '을': 14, '기준': 15, '으로': 16, '느낀다': 17} bag of words vector : [1, 2, 1, 2, 3, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1] 문서 3의 단어 집합은 문서 1과 문서 2의 단어들을 모두 포함하고 있는 것들을 볼 수 있습니다. BoW는 종종 여러 문서의 단어 집합을 합친 뒤에, 해당 단어 집합에 대한 각 문서의 BoW를 구하기도 합니다. 가령, 문서 3에 대한 단어 집합을 기준으로 문서 1, 문서 2의 BoW를 만든다고 한다면 결과는 아래와 같습니다. 문서 3 단어 집합에 대한 문서 1 BoW : [1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0] 문서 3 단어 집합에 대한 문서 2 BoW : [0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 2, 1, 1, 1] 문서 3 단어 집합에서 물가 상승률이라는 단어는 인덱스가 4에 해당됩니다. 물가 상승률이라는 단어는 문서 1에서는 2회 등장하며, 문서 2에서는 1회 등장하였기 때문에 두 BoW의 인덱스 4의 값은 각각 2와 1이 되는 것을 볼 수 있습니다. BoW는 각 단어가 등장한 횟수를 수치화하는 텍스트 표현 방법이므로 주로 어떤 단어가 얼마나 등장했는지를 기준으로 문서가 어떤 성격의 문서인지를 판단하는 작업에 쓰입니다. 즉, 분류 문제나 여러 문서 간의 유사도를 구하는 문제에 주로 쓰입니다. 가령, '달리기', '체력', '근력'과 같은 단어가 자주 등장하면 해당 문서를 체육 관련 문서로 분류할 수 있을 것이며, '미분', '방정식', '부등식'과 같은 단어가 자주 등장한다면 수학 관련 문서로 분류할 수 있습니다. 3. CountVectorizer 클래스로 BoW 만들기 사이킷 런에서는 단어의 빈도를 Count 하여 Vector로 만드는 CountVectorizer 클래스를 지원합니다. 이를 이용하면 영어에 대해서는 손쉽게 BoW를 만들 수 있습니다. CountVectorizer로 간단하고 빠르게 BoW를 만드는 실습을 진행해 보도록 하겠습니다. from sklearn.feature_extraction.text import CountVectorizer corpus = ['you know I want your love. because I love you.'] vector = CountVectorizer() # 코퍼스로부터 각 단어의 빈도수를 기록 print('bag of words vector :', vector.fit_transform(corpus).toarray()) # 각 단어의 인덱스가 어떻게 부여되었는지를 출력 print('vocabulary :',vector.vocabulary_) bag of words vector : [[1 1 2 1 2 1]] vocabulary : {'you': 4, 'know': 1, 'want': 3, 'your': 5, 'love': 2, 'because': 0} 예제 문장에서 you와 love는 두 번씩 언급되었으므로 각각 인덱스 2와 인덱스 4에서 2의 값을 가지며, 그 외의 값에서는 1의 값을 가지는 것을 볼 수 있습니다. 또한 알파벳 I는 BoW를 만드는 과정에서 사라졌는데, 이는 CountVectorizer가 기본적으로 길이가 2 이상인 문자에 대해서만 토큰으로 인식하기 때문입니다. 정제(Cleaning) 챕터에서 언급했듯이, 영어에서는 길이가 짧은 문자를 제거하는 것 또한 전처리 작업으로 고려되기도 합니다. 주의할 것은 CountVectorizer는 단지 띄어쓰기만을 기준으로 단어를 자르는 낮은 수준의 토큰화를 진행하고 BoW를 만든다는 점입니다. 이는 영어의 경우 띄어쓰기만으로 토큰 화가 수행되기 때문에 문제가 없지만 한국어에 CountVectorizer를 적용하면, 조사 등의 이유로 제대로 BoW가 만들어지지 않음을 의미합니다. 예를 들어, 앞서 BoW를 만드는데 사용했던 '정부가 발표하는 물가 상승률과 소비자가 느끼는 물가 상승률은 다르다.'라는 문장을 CountVectorizer를 사용하여 BoW로 만들 경우, CountVectorizer는 '물가 상승률'이라는 단어를 인식하지 못합니다. CountVectorizer는 띄어쓰기를 기준으로 분리한 뒤에 '물가 상승률과'와 '물가 상승률은'으로 조사를 포함해서 하나의 단어로 판단하기 때문에 서로 다른 두 단어로 인식합니다. 그리고 '물가 상승률과'와 '물가 상승률은'이 각자 다른 인덱스에서 1이라는 빈도의 값을 갖게 됩니다. 4. 불용어를 제거한 BoW 만들기 앞서 불용어는 자연어 처리에서 별로 의미를 갖지 않는 단어들이라고 언급한 바 있습니다. BoW를 사용한다는 것은 그 문서에서 각 단어가 얼마나 자주 등장했는지를 보겠다는 것입니다. 그리고 각 단어에 대한 빈도수를 수치화하겠다는 것은 결국 텍스트 내에서 어떤 단어들이 중요한지를 보고 싶다는 의미를 함축하고 있습니다. 그렇다면 BoW를 만들 때 불용어를 제거하는 일은 자연어 처리의 정확도를 높이기 위해서 선택할 수 있는 전처리 기법입니다. 영어의 BoW를 만들기 위해 사용하는 CountVectorizer는 불용어를 지정하면, 불용어는 제외하고 BoW를 만들 수 있도록 불용어 제거 기능을 지원하고 있습니다. from sklearn.feature_extraction.text import CountVectorizer from nltk.corpus import stopwords (1) 사용자가 직접 정의한 불용어 사용 text = ["Family is not an important thing. It's everything."] vect = CountVectorizer(stop_words=["the", "a", "an", "is", "not"]) print('bag of words vector :',vect.fit_transform(text).toarray()) print('vocabulary :',vect.vocabulary_) bag of words vector : [[1 1 1 1 1]] vocabulary : {'family': 1, 'important': 2, 'thing': 4, 'it': 3, 'everything': 0} (2) CountVectorizer에서 제공하는 자체 불용어 사용 text = ["Family is not an important thing. It's everything."] vect = CountVectorizer(stop_words="english") print('bag of words vector :',vect.fit_transform(text).toarray()) print('vocabulary :',vect.vocabulary_) bag of words vector : [[1 1 1]] vocabulary : {'family': 0, 'important': 1, 'thing': 2} (3) NLTK에서 지원하는 불용어 사용 text = ["Family is not an important thing. It's everything."] stop_words = stopwords.words("english") vect = CountVectorizer(stop_words=stop_words) print('bag of words vector :',vect.fit_transform(text).toarray()) print('vocabulary :',vect.vocabulary_) bag of words vector : [[1 1 1 1]] vocabulary : {'family': 1, 'important': 2, 'thing': 3, 'everything': 0} 11-03 문서의 벡터화: 문서 단어 행렬(Document-Term Matrix, DTM) 서로 다른 문서들의 BoW들을 결합한 표현 방법인 문서 단어 행렬(Document-Term Matrix, DTM) 표현 방법을 배워보겠습니다. 이하 DTM이라고 명명합니다. 행과 열을 반대로 선택하면 TDM이라고 부르기도 합니다. 이렇게 하면 서로 다른 문서들을 비교할 수 있게 됩니다. 1. 문서 단어 행렬(Document-Term Matrix, DTM)의 표기법 문서 단어 행렬(Document-Term Matrix, DTM)이란 다수의 문서에서 등장하는 각 단어들의 빈도를 행렬로 표현한 것을 말합니다. 쉽게 생각하면 각 문서에 대한 BoW를 하나의 행렬로 만든 것으로 생각할 수 있으며, BoW와 다른 표현 방법이 아니라 BoW 표현을 다수의 문서에 대해서 행렬로 표현하고 부르는 용어입니다. 예를 들어서 이렇게 4개의 문서가 있다고 합시다. 문서 1 : 먹고 싶은 사과 문서 2 : 먹고 싶은 바나나 문서 3 : 길고 노란 바나나 바나나 문서 4 : 저는 과일이 좋아요 띄어쓰기 단위 토큰화를 수행한다고 가정하고, 문서 단어 행렬로 표현하면 다음과 같습니다. 과일이 길고 노란 먹고 바나나 사과 싶은 저는 좋아요 문서 1 0 0 0 1 0 1 1 0 0 문서 2 0 0 0 1 1 0 1 0 0 문서 3 0 1 1 0 2 0 0 0 0 문서 4 1 0 0 0 0 0 0 1 1 각 문서에서 등장한 단어의 빈도를 행렬의 값으로 표기합니다. 문서 단어 행렬은 문서들을 서로 비교할 수 있도록 수치화할 수 있다는 점에서 의의를 갖습니다. 만약 필요에 따라서는 형태소 분석기로 단어 토큰화를 수행하고, 불용어에 해당되는 조사들 또한 제거하여 더 정제된 DTM을 만들 수도 있을 것입니다. 2. 문서 단어 행렬(Document-Term Matrix)의 한계 DTM은 매우 간단하고 구현하기도 쉽지만, 본질적으로 가지는 몇 가지 한계들이 있습니다. 1) 희소 표현(Sparse representation) 원-핫 벡터는 단어 집합의 크기가 벡터의 차원이 되고 대부분의 값이 0이 되는 벡터입니다. 원-핫 벡터는 공간적 낭비와 계산 리소스를 증가시킬 수 있다는 점에서 단점을 가집니다. DTM도 마찬가지입니다. DTM에서의 각 행을 문서 벡터라고 해봅시다. 각 문서 벡터의 차원은 원-핫 벡터와 마찬가지로 전체 단어 집합의 크기를 가집니다. 만약 가지고 있는 전체 코퍼스가 방대한 데이터라면 문서 벡터의 차원은 수만 이상의 차원을 가질 수도 있습니다. 또한 많은 문서 벡터가 대부분의 값이 0을 가질 수도 있습니다. 당장 위에서 예로 들었던 문서 단어 행렬의 모든 행이 0이 아닌 값보다 0의 값이 더 많은 것을 볼 수 있습니다. 원-핫 벡터나 DTM과 같은 대부분의 값이 0인 표현을 희소 벡터(sparse vector) 또는 희소 행렬(sparse matrix)라고 부르는데, 희소 벡터는 많은 양의 저장 공간과 높은 계산 복잡도를 요구합니다. 이러한 이유로 전처리를 통해 단어 집합의 크기를 줄이는 일은 BoW 표현을 사용하는 모델에서 중요할 수 있습니다. 앞서 배운 텍스트 전처리 방법을 사용하여 구두점, 빈도수가 낮은 단어, 불용어를 제거하고, 어간이나 표제어 추출을 통해 단어를 정규화하여 단어 집합의 크기를 줄일 수 있습니다. 2) 단순 빈도 수 기반 접근 여러 문서에 등장하는 모든 단어에 대해서 빈도 표기를 하는 이런 방법은 때로는 한계를 가지기도 합니다. 예를 들어 영어에 대해서 DTM을 만들었을 때, 불용어인 the는 어떤 문서이든 자주 등장할 수밖에 없습니다. 그런데 유사한 문서인지 비교하고 싶은 문서 1, 문서 2, 문서 3에서 동일하게 the가 빈도수가 높다고 해서 이 문서들이 유사한 문서라고 판단해서는 안 됩니다. 각 문서에는 중요한 단어와 불필요한 단어들이 혼재되어 있습니다. 앞서 불용어(stopwords)와 같은 단어들은 빈도수가 높더라도 자연어 처리에 있어 의미를 갖지 못하는 단어라고 언급한 바 있습니다. 그렇다면 DTM에 불용어와 중요한 단어에 대해서 가중치를 줄 수 있는 방법은 없을까요? 이러한 아이디어를 적용한 TF-IDF를 이어서 학습해 봅시다. 사이킷런의 CountVectorizer를 사용하여 DTM을 만드는 실습 또한 TF-IDF를 설명하면서 진행하겠습니다. 11-04 TF-IDF(Term Frequency-Inverse Document Frequency) 이번에는 DTM 내에 있는 각 단어에 대한 중요도를 계산할 수 있는 TF-IDF 가중치에 대해서 알아보겠습니다. TF-IDF를 사용하면, 기존의 DTM을 사용하는 것보다 보다 많은 정보를 고려하여 문서들을 비교할 수 있습니다. TF-IDF가 DTM보다 항상 좋은 성능을 보장하는 것은 아니지만, 많은 경우에서 DTM보다 더 좋은 성능을 얻을 수 있습니다. 1. TF-IDF(단어 빈도-역 문서 빈도, Term Frequency-Inverse Document Frequency) TF-IDF(Term Frequency-Inverse Document Frequency)는 단어의 빈도와 역 문서 빈도(문서의 빈도에 특정 식을 취함)를 사용하여 DTM 내의 각 단어들마다 중요한 정도를 가중치로 주는 방법입니다. 우선 DTM을 만든 후, TF-IDF 가중치를 부여합니다. TF-IDF는 주로 문서의 유사도를 구하는 작업, 검색 시스템에서 검색 결과의 중요도를 정하는 작업, 문서 내에서 특정 단어의 중요도를 구하는 작업 등에 쓰일 수 있습니다. TF-IDF는 TF와 IDF를 곱한 값을 의미하는 데 이를 식으로 표현해 보겠습니다. 문서를 d, 단어를 t, 문서의 총개수를 n이라고 표현할 때 TF, DF, IDF는 각각 다음과 같이 정의할 수 있습니다. (1) tf(d, t) : 특정 문서 d에서의 특정 단어 t의 등장 횟수. 생소한 글자 때문에 어려워 보일 수 있지만, 잘 생각해 보면 TF는 이미 앞에서 구한 적이 있습니다. TF는 앞에서 배운 DTM의 예제에서 각 단어들이 가진 값들입니다. DTM이 각 문서에서의 각 단어의 등장 빈도를 나타내는 값이었기 때문입니다. (2) df(t) : 특정 단어 t가 등장한 문서의 수. 여기서 특정 단어가 각 문서, 또는 문서들에서 몇 번 등장했는지는 관심 가지지 않으며 오직 특정 단어 t가 등장한 문서의 수에만 관심을 가집니다. 앞서 배운 DTM에서 바나나는 문서 2와 문서 3에서 등장했습니다. 이 경우, 바나나의 df는 2입니다. 문서 3에서 바나나가 두 번 등장했지만, 그것은 중요한 게 아닙니다. 심지어 바나나란 단어가 문서 2에서 100번 등장했고, 문서 3에서 200번 등장했다고 하더라도 바나나의 df는 2가 됩니다. (3) idf(t) : df(t)에 반비례하는 수. d ( ) l g ( 1 d ( ) ) IDF라는 이름을 보고 DF의 역수가 아닐까 생각했다면, IDF는 DF의 역수를 취하고 싶은 것이 맞습니다. 그런데 log와 분모에 1을 더해주는 식에 의아하실 수 있습니다. log를 사용하지 않았을 때, IDF를 DF의 역수( d ( ) 라는 식)로 사용한다면 총 문서의 수 n이 커질수록, IDF의 값은 기하급수적으로 커지게 됩니다. 그렇기 때문에 log를 사용합니다. 왜 log가 필요한지 n=1,000,000일 때의 예를 들어봅시다. log의 밑은 10을 사용한다고 가정하였을 때 결과는 아래와 같습니다. d ( ) l g ( / f ( ) ) = , 000 000 단어 d ( ) d ( , ) word1 1 6 word2 100 4 word3 1,000 3 word4 10,000 2 word5 100,000 1 word6 1,000,000 0 그렇다면 log를 사용하지 않으면 idf의 값이 어떻게 커지는지 보겠습니다. d ( ) n d ( ) = , 000 000 단어 d ( ) d ( ) word1 1 1,000,000 word2 100 10,000 word3 1,000 1,000 word4 10,000 100 word5 100,000 10 word6 1,000,000 1 또 다른 직관적인 설명은 불용어 등과 같이 자주 쓰이는 단어들은 비교적 자주 쓰이지 않는 단어들보다 최소 수십 배 자주 등장합니다. 그런데 비교적 자주 쓰이지 않는 단어들조차 희귀 단어들과 비교하면 또 최소 수백 배는 더 자주 등장하는 편입니다. 이 때문에 log를 씌워주지 않으면, 희귀 단어들에 엄청난 가중치가 부여될 수 있습니다. 로그를 씌우면 이런 격차를 줄이는 효과가 있습니다. log 안의 식에서 분모에 1을 더해주는 이유는 첫 번째 이유로는 특정 단어가 전체 문서에서 등장하지 않을 경우에 분모가 0이 되는 상황을 방지하기 위함입니다. TF-IDF는 모든 문서에서 자주 등장하는 단어는 중요도가 낮다고 판단하며, 특정 문서에서만 자주 등장하는 단어는 중요도가 높다고 판단합니다. TF-IDF 값이 낮으면 중요도가 낮은 것이며, TF-IDF 값이 크면 중요도가 큰 것입니다. 즉, the나 a와 같이 불용어의 경우에는 모든 문서에 자주 등장하기 마련이기 때문에 자연스럽게 불용어의 TF-IDF의 값은 다른 단어의 TF-IDF에 비해서 낮아지게 됩니다. 과일이 길고 노란 먹고 바나나 사과 싶은 저는 좋아요 문서 1 0 0 0 1 0 1 1 0 0 문서 2 0 0 0 1 1 0 1 0 0 문서 3 0 1 1 0 2 0 0 0 0 문서 4 1 0 0 0 0 0 0 1 1 앞서 DTM을 설명하기 위해 들었던 위의 예제를 가지고 TF-IDF에 대해 이해해 보겠습니다. 우선 TF는 앞서 사용한 DTM을 그대로 사용하면, 그것이 각 문서에서의 각 단어의 TF가 됩니다. 이제 구해야 할 것은 TF와 곱해야 할 값인 IDF입니다. 로그는 자연 로그를 사용하도록 하겠습니다. 자연 로그는 로그의 밑을 자연 상수 e(e=2.718281...)를 사용하는 로그를 말합니다. IDF 계산을 위해 사용하는 로그의 밑은 TF-IDF를 사용하는 사용자가 임의로 정할 수 있는데, 여기서 로그는 마치 기존의 값에 곱하여 값의 크기를 조절하는 상수의 역할을 합니다. 각종 프로그래밍 언어에서 패키지로 지원하는 TF-IDF의 로그는 대부분 자연 로그를 사용합니다. 여기서도 자연 로그를 사용하겠습니다. 자연 로그는 보통 log라고 표현하지 않고, ln이라고 표현합니다. 단어 IDF(역 문서 빈도) 과일이 ln(4/(1+1)) = 0.693147 길고 ln(4/(1+1)) = 0.693147 노란 ln(4/(1+1)) = 0.693147 먹고 ln(4/(2+1)) = 0.287682 바나나 ln(4/(2+1)) = 0.287682 사과 ln(4/(1+1)) = 0.693147 싶은 ln(4/(2+1)) = 0.287682 저는 ln(4/(1+1)) = 0.693147 좋아요 ln(4/(1+1)) = 0.693147 문서의 총 수는 4이기 때문에 ln 안에서 분자는 늘 4로 동일합니다. 분모의 경우에는 각 단어가 등장한 문서의 수(DF)를 의미하는데, 예를 들어서 '먹고'의 경우에는 총 2개의 문서(문서 1, 문서 2)에 등장했기 때문에 2라는 값을 가집니다. 각 단어에 대해서 IDF의 값을 비교해 보면 문서 1개에만 등장한 단어와 문서 2개에만 등장한 단어는 값의 차이를 보입니다. IDF는 여러 문서에서 등장한 단어의 가중치를 낮추는 역할을 하기 때문입니다. TF-IDF를 계산해 보겠습니다. 각 단어의 TF는 DTM에서의 각 단어의 값과 같으므로, 앞서 사용한 DTM에서 단어 별로 위의 IDF 값을 곱해주면 TF-IDF 값을 얻습니다. 과일이 길고 노란 먹고 바나나 사과 싶은 저는 좋아요 문서 1 0 0 0 0.287682 0 0.693147 0.287682 0 0 문서 2 0 0 0 0.287682 0.287682 0 0.287682 0 0 문서 3 0 0.693147 0.693147 0 0.575364 0 0 0 0 문서 4 0.693147 0 0 0 0 0 0 0.693147 0.693147 사실 예제 문서가 굉장히 간단하기 때문에 계산은 매우 쉽습니다. 문서 3에서의 바나나만 TF 값이 2이므로 IDF에 2를 곱해주고, 나머진 TF 값이 1이므로 그대로 IDF 값을 가져오면 됩니다. 문서 2에서의 바나나의 TF-IDF 가중치와 문서 3에서의 바나나의 TF-IDF 가중치가 다른 것을 볼 수 있습니다. 수식적으로 말하면, TF가 각각 1과 2로 달랐기 때문인데 TF-IDF에서의 관점에서 보자면 TF-IDF는 특정 문서에서 자주 등장하는 단어는 그 문서 내에서 중요한 단어로 판단하기 때문입니다. 문서 2에서는 바나나를 한 번 언급했지만, 문서 3에서는 바나나를 두 번 언급했기 때문에 문서 3에서의 바나나를 더욱 중요한 단어라고 판단하는 것입니다. 2. 파이썬으로 TF-IDF 직접 구현하기 위의 계산 과정을 파이썬으로 직접 구현해 보겠습니다. 앞의 설명에서 사용한 4개의 문서를 docs에 저장합니다. import pandas as pd # 데이터 프레임 사용을 위해 from math import log # IDF 계산을 위해 docs = [ '먹고 싶은 사과', '먹고 싶은 바나나', '길고 노란 바나나 바나나', '저는 과일이 좋아요' ] vocab = list(set(w for doc in docs for w in doc.split())) vocab.sort() TF, IDF, 그리고 TF-IDF 값을 구하는 함수를 구현합니다. # 총 문서의 수 N = len(docs) def tf(t, d): return d.count(t) def idf(t): df = 0 for doc in docs: df += t in doc return log(N/(df+1)) def tfidf(t, d): return tf(t, d)* idf(t) TF를 구해보겠습니다. 다시 말해 DTM을 데이터 프레임에 저장하여 출력해 보겠습니다. result = [] # 각 문서에 대해서 아래 연산을 반복 for i in range(N): result.append([]) d = docs[i] for j in range(len(vocab)): t = vocab[j] result[-1].append(tf(t, d)) tf_ = pd.DataFrame(result, columns = vocab) 정상적으로 DTM이 출력되었습니다. 각 단어에 대한 IDF 값을 구해봅시다. result = [] for j in range(len(vocab)): t = vocab[j] result.append(idf(t)) idf_ = pd.DataFrame(result, index=vocab, columns=["IDF"]) idf_ 위에서 수기로 구한 IDF 값들과 정확히 일치합니다. TF-IDF 행렬을 출력해 봅시다. result = [] for i in range(N): result.append([]) d = docs[i] for j in range(len(vocab)): t = vocab[j] result[-1].append(tfidf(t, d)) tfidf_ = pd.DataFrame(result, columns = vocab) tfidf_ TF-IDF의 가장 기본적인 식에 대해서 학습하고 실제로 구현하는 실습을 진행해 보았습니다. 사실 실제 TF-IDF 구현을 제공하고 있는 많은 머신 러닝 패키지들은 패키지마다 식이 조금씩 상이하지만, 위에서 배운 식과는 다른 조정된 식을 사용합니다. 그 이유는 위의 기본적인 식을 바탕으로 한 구현에는 몇 가지 문제점이 존재하기 때문입니다. 만약 전체 문서의 수 이 4인데, f ( ) 의 값이 3인 경우에는 어떤 일이 벌어질까요? f ( ) 에 1이 더해지면서 log 항의 분자와 분모의 값이 같아지게 됩니다. 이는 o의 진수 값이 1이 되면서 d ( , ) 의 값이 0이 됨을 의미합니다. 식으로 표현하면 d ( , ) l g ( / ( f ( ) 1 ) ) 0 입니다. IDF의 값이 0이라면 더 이상 가중치의 역할을 수행하지 못합니다. 아래에서 실습할 사이킷런의 TF-IDF 구현체 또한 위의 식에서 조정된 식을 사용하고 있습니다. 3. 사이킷런을 이용한 DTM과 TF-IDF 실습 사이킷런을 통해 DTM과 TF-IDF를 만들어보겠습니다. BoW를 설명하며 배운 CountVectorizer를 사용하면 DTM을 만들 수 있습니다. from sklearn.feature_extraction.text import CountVectorizer corpus = [ 'you know I want your love', 'I like you', 'what should I do ', ] vector = CountVectorizer() # 코퍼스로부터 각 단어의 빈도수를 기록 print(vector.fit_transform(corpus).toarray()) # 각 단어와 매핑된 인덱스 출력 print(vector.vocabulary_) [[0 1 0 1 0 1 0 1 1] [0 0 1 0 0 0 0 1 0] [1 0 0 0 1 0 1 0 0]] {'you': 7, 'know': 1, 'want': 5, 'your': 8, 'love': 3, 'like': 2, 'what': 6, 'should': 4, 'do': 0} DTM이 완성되었습니다. DTM에서 각 단어의 인덱스가 어떻게 부여되었는지를 확인하기 위해, 인덱스를 확인해 보았습니다. 첫 번째 열의 경우에는 0의 인덱스를 가진 do입니다. do는 세 번째 문서에만 등장했기 때문에, 세 번째 행에서만 1의 값을 가집니다. 두 번째 열의 경우에는 1의 인덱스를 가진 know입니다. know는 첫 번째 문서에만 등장했으므로 첫 번째 행에서만 1의 값을 가집니다. 사이킷런은 TF-IDF를 자동 계산해 주는 TfidfVectorizer를 제공합니다. 사이킷런의 TF-IDF는 위에서 배웠던 보편적인 TF-IDF 기본 식에서 조정된 식을 사용합니다. 요약하자면, IDF의 로그 항의 분자에 1을 더해주며, 로그항에 1을 더해주고, TF-IDF에 L2 정규화라는 방법으로 값을 조정하는 등의 차이로 TF-IDF가 가진 의도는 여전히 그대로 갖고 있습니다. from sklearn.feature_extraction.text import TfidfVectorizer corpus = [ 'you know I want your love', 'I like you', 'what should I do ', ] tfidfv = TfidfVectorizer().fit(corpus) print(tfidfv.transform(corpus).toarray()) print(tfidfv.vocabulary_) [[0. 0.46735098 0. 0.46735098 0. 0.46735098 0. 0.35543247 0.46735098] [0. 0. 0.79596054 0. 0. 0. 0. 0.60534851 0. ] [0.57735027 0. 0. 0. 0.57735027 0. 0.57735027 0. 0. ]] {'you': 7, 'know': 1, 'want': 5, 'your': 8, 'love': 3, 'like': 2, 'what': 6, 'should': 4, 'do': 0} BoW, DTM, TF-IDF에 대해서 전부 학습했습니다. 문서들 간의 유사도를 구하기 위한 재료 손질하는 방법을 배운 셈입니다. 다음 챕터에서 유사도를 구하는 방법과 이를 이용한 실습을 진행해 보겠습니다. 사이킷런의 TF-IDF의 수식을 이해하고 싶은 분들을 위해서 위키독스 웹 사이트에 댓글로 설명해놨습니다. 궁금하신 분들은 참고하세요. 11-05 코사인 유사도를 이용한 추천 시스템 BoW에 기반한 단어 표현 방법인 DTM, TF-IDF, 또는 뒤에서 배우게 될 Word2Vec 등과 같이 단어를 수치화할 수 있는 방법을 이해했다면 이러한 표현 방법에 대해서 코사인 유사도를 이용하여 문서의 유사도를 구하는 게 가능합니다. 1. 코사인 유사도(Cosine Similarity) 코사인 유사도는 두 벡터 간의 코사인 각도를 이용하여 구할 수 있는 두 벡터의 유사도를 의미합니다. 두 벡터의 방향이 완전히 동일한 경우에는 1의 값을 가지며, 90°의 각을 이루면 0, 180°로 반대의 방향을 가지면 -1의 값을 갖게 됩니다. 즉, 결국 코사인 유사도는 -1 이상 1 이하의 값을 가지며 값이 1에 가까울수록 유사도가 높다고 판단할 수 있습니다. 이를 직관적으로 이해하면 두 벡터가 가리키는 방향이 얼마나 유사한가를 의미합니다. 두 벡터 A, B에 대해서 코사인 유사도는 식으로 표현하면 다음과 같습니다. i i a i y c s ( ) A B | | | B | ∑ = n i B ∑ = n ( i ) × i 1 ( 문서 단어 행렬이나 TF-IDF 행렬을 통해서 문서의 유사도를 구하는 경우에는 문서 단어 행렬이나 TF-IDF 행렬이 각각의 특징 벡터 A, B가 됩니다. 예시를 통해 문서 단어 행렬에 대해서 코사인 유사도를 구해봅시다. 문서 1 : 저는 사과 좋아요 문서 2 : 저는 바나나 좋아요 문서 3 : 저는 바나나 좋아요 저는 바나나 좋아요 띄어쓰기 기준 토큰화를 진행했다고 가정하고, 위의 세 문서에 대해서 문서 단어 행렬을 만들면 이와 같습니다. 바나나 사과 저는 좋아요 문서 1 0 1 1 1 문서 2 1 0 1 1 문서 3 2 0 2 2 Numpy를 사용해서 코사인 유사도를 계산하는 함수를 구현하고 각 문서 벡터 간의 코사인 유사도를 계산해 보겠습니다. import numpy as np from numpy import dot from numpy.linalg import norm def cos_sim(A, B): return dot(A, B)/(norm(A)*norm(B)) doc1 = np.array([0,1,1,1]) doc2 = np.array([1,0,1,1]) doc3 = np.array([2,0,2,2]) print('문서 1과 문서 2의 유사도 :',cos_sim(doc1, doc2)) print('문서 1과 문서 3의 유사도 :',cos_sim(doc1, doc3)) print('문서 2와 문서 3의 유사도 :',cos_sim(doc2, doc3)) 문서 1과 문서 2의 유사도 : 0.67 문서 1과 문서 3의 유사도 : 0.67 문서 2과 문서 3의 유사도 : 1.00 눈여겨볼 만한 점은 문서 1과 문서 2의 코사인 유사도와 문서 1과 문서 3의 코사인 유사도가 같다는 점과 문서 2와 문서 3의 코사인 유사도가 1이 나온다는 것입니다. 앞서 1은 두 벡터의 방향이 완전히 동일한 경우에 1이 나오며, 코사인 유사도 관점에서는 유사도의 값이 최대임을 의미한다고 언급한 바 있습니다. 문서 3은 문서 2에서 단지 모든 단어의 빈도수가 1씩 증가했을 뿐입니다. 다시 말해 한 문서 내의 모든 단어의 빈도수가 동일하게 증가하는 경우에는 기존의 문서와 코사인 유사도의 값이 1이라는 것입니다. 이것이 시사하는 점은 무엇일까요? 예를 들어보겠습니다. 문서 A와 B가 동일한 주제의 문서. 문서 C는 다른 주제의 문서라고 해봅시다. 그리고 문서 A와 문서 C의 문서의 길이는 거의 차이가 나지 않지만, 문서 B의 경우 문서 A의 길이보다 두 배의 길이를 가진다고 가정하겠습니다. 이런 경우 유클리드 거리로 유사도를 연산하면 문서 A가 문서 B보다 문서 C와 유사도가 더 높게 나오는 상황이 발생할 수 있습니다. 이는 유사도 연산에 문서의 길이가 영향을 받았기 때문인데, 이런 경우 코사인 유사도가 해결책이 될 수 있습니다. 코사인 유사도는 유사도를 구할 때 벡터의 방향(패턴)에 초점을 두므로 코사인 유사도는 문서의 길이가 다른 상황에서 비교적 공정한 비교를 할 수 있도록 도와줍니다. 2. 유사도를 이용한 추천 시스템 구현하기 캐글에서 사용되었던 영화 데이터 셋을 가지고 영화 추천 시스템을 만들어보겠습니다. TF-IDF와 코사인 유사도만으로 영화의 줄거리에 기반해서 영화를 추천하는 추천 시스템을 만들 수 있습니다. 다운로드 링크 : https://www.kaggle.com/rounakbanik/the-movies-dataset 원본 파일은 위 링크에서 movies_metadata.csv 파일을 다운로드하면 됩니다. 해당 데이터는 총 24개의 열을 가진 45,466개의 샘플로 구성된 영화 정보 데이터입니다. import pandas as pd from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.metrics.pairwise import cosine_similarity data = pd.read_csv('movies_metadata.csv', low_memory=False) data.head(2) 다운로드한 훈련 데이터에서 상위 2개의 샘플만 출력하여 데이터의<NAME>을 확인합니다. ... original_title overview ... title video vote_average vote_count 0 ... Toy Story Led by Woody, Andy's toys live happily in his ... 중략 ... ... Toy Story False 7.7 5415.0 1 ... Jumanji When siblings Judy and Peter discover an encha ... 중략 ... ... Jumanji False 6.9 2413.0 훈련 데이터는 총 24개의 열을 갖고 있으나 책의 지면의 한계로 일부 생략합니다. 여기서 코사인 유사도에 사용할 데이터는 영화 제목에 해당하는 title 열과 줄거리에 해당하는 overview 열입니다. 좋아하는 영화를 입력하면, 해당 영화의 줄거리와 유사한 줄거리의 영화를 찾아서 추천하는 시스템을 만들 것입니다. # 상위 2만 개의 샘플을 data에 저장 data = data.head(20000) 만약 훈련 데이터의 양을 줄이고 학습을 진행하고자 한다면 위와 같이 데이터를 줄여서 재저장할 수 있습니다. 여기서는 상위 20,000개의 샘플만 사용하겠습니다. TF-IDF를 연산할 때 데이터에 Null 값이 들어있으면 에러가 발생합니다. TF-IDF의 대상이 되는 data의 overview 열에 결측값에 해당하는 Null 값이 있는지 확인합니다. # overview 열에 존재하는 모든 결측값을 전부 카운트하여 출력 print('overview 열의 결측값의 수:',data['overview'].isnull().sum()) overview 열의 결측값의 수: 135 135개의 Null 값이 있다고 합니다. 이 경우 결측값을 가진 행을 제거하는 pandas의 dropna()나 결측값이 있던 행에 특정 값으로 채워 넣는 pandas의 fillna()를 사용할 수 있습니다. 괄호 안에 Null 대신 넣고자 하는 값을 넣으면 되는데, 여기서는 빈 값(empty value)으로 대체하였습니다. # 결측값을 빈 값으로 대체 data['overview'] = data['overview'].fillna('') Null 값을 빈 값으로 대체하였습니다. overview 열에 대해서 TF-IDF 행렬을 구한 후 행렬의 크기를 출력해 봅시다. tfidf = TfidfVectorizer(stop_words='english') tfidf_matrix = tfidf.fit_transform(data['overview']) print('TF-IDF 행렬의 크기(shape) :',tfidf_matrix.shape) TF-IDF 행렬의 크기(shape) : (20000, 47487) TF-IDF 행렬의 크기는 20,000의 행을 가지고 47,847의 열을 가지는 행렬입니다. 다시 말해 20,000개의 영화를 표현하기 위해서 총 47,487개의 단어가 사용되었음을 의미합니다. 또는 47,847차원의 문서 벡터가 20,000개가 존재한다고도 표현할 수 있을 겁니다. 이제 20,000개의 문서 벡터에 대해서 상호 간의 코사인 유사도를 구합니다. cosine_sim = cosine_similarity(tfidf_matrix, tfidf_matrix) print('코사인 유사도 연산 결과 :',cosine_sim.shape) 코사인 유사도 연산 결과 : (20000, 20000) 코사인 유사도 연산 결과로는 20,000행 20,000열의 행렬을 얻습니다. 이는 20,000개의 각 문서 벡터(영화 줄거리 벡터)와 자기 자신을 포함한 20,000개의 문서 벡터 간의 유사도가 기록된 행렬입니다. 모든 20,000개 영화의 상호 유사도가 기록돼 있습니다. 이제 기존 데이터 프레임으로부터 영화의 타이틀을 key, 영화의 인덱스를 value로 하는 딕셔너리 title_to_index를 만들어둡니다. title_to_index = dict(zip(data['title'], data.index)) # 영화 제목 Father of the Bride Part II의 인덱스를 리턴 idx = title_to_index['Father of the Bride Part II'] print(idx) 선택한 영화의 제목을 입력하면 코사인 유사도를 통해 가장 overview가 유사한 10개의 영화를 찾아내는 함수를 만듭니다. def get_recommendations(title, cosine_sim=cosine_sim): # 선택한 영화의 타이틀로부터 해당 영화의 인덱스를 받아온다. idx = title_to_index[title] # 해당 영화와 모든 영화와의 유사도를 가져온다. sim_scores = list(enumerate(cosine_sim[idx])) # 유사도에 따라 영화들을 정렬한다. sim_scores = sorted(sim_scores, key=lambda x: x[1], reverse=True) # 가장 유사한 10개의 영화를 받아온다. sim_scores = sim_scores[1:11] # 가장 유사한 10개의 영화의 인덱스를 얻는다. movie_indices = [idx[0] for idx in sim_scores] # 가장 유사한 10개의 영화의 제목을 리턴한다. return data['title'].iloc[movie_indices] 영화 다크 나이트 라이즈와 overview가 유사한 영화들을 찾아보겠습니다. get_recommendations('The Dark Knight Rises') 12481 The Dark Knight 150 Batman Forever 1328 Batman Returns 15511 Batman: Under the Red Hood 585 Batman 9230 Batman Beyond: Return of the Joker 18035 Batman: Year One 19792 Batman: The Dark Knight Returns, Part 1 3095 Batman: Mask of the Phantasm 10122 Batman Begins Name: title, dtype: object 가장 유사한 영화가 출력되는데, 영화 다크 나이트가 첫 번째고, 그 외에도 전부 배트맨 영화를 찾아낸 것을 확인할 수 있습니다. 11-06 단어와 문서의 유사도를 구하는 다양한 방법 문서의 유사도를 구하기 위한 방법으로는 코사인 유사도 외에도 여러 가지 방법들이 있습니다. 여기서는 문서의 유사도를 구할 수 있는 다른 방법들을 학습합니다. 1. 유클리드 거리(Euclidean distance) 유클리드 거리(euclidean distance)는 문서의 유사도를 구할 때 자카르 유사도나 코사인 유사도만큼, 유용한 방법은 아닙니다. 하지만 여러 가지 방법을 이해하고, 시도해 보는 것 자체만으로 다른 개념들을 이해할 때 도움이 되므로 의미가 있습니다. 다차원 공간에서 두 개의 점 와 가 각각 = ( 1 p, 3. . p) q ( 1 q, 3. . q) 의 좌표를 가질 때 두 점 사이의 거리를 계산하는 유클리드 거리 공식은 다음과 같습니다. ( 1 p) + ( 2 p) + . . + ( n p) = i 1 ( i p) 다차원 공간이라고 가정하면, 처음 보는 입장에서는 식이 너무 복잡해 보입니다. 좀 더 쉽게 이해하기 위해서 2차원 공간이라고 가정하고 두 점 사이의 거리를 좌표 평면 상에서 시각화해보겠습니다. 2차원 좌표 평면 상에서 두 점 와 사이의 직선거리를 구하는 문제입니다. 위의 경우에는 직각 삼각형으로 표현이 가능하므로, 중학교 수학 과정인 피타고라스의 정리를 통해 와 사이의 거리를 계산할 수 있습니다. 즉, 2차원 좌표 평면에서 두 점 사이의 유클리드 거리 공식은 피타고라스의 정리를 통해 두 점 사이의 거리를 구하는 것과 동일합니다. 다시 원점으로 돌아가서 여러 문서에 대해서 유사도를 구하고자 유클리드 거리 공식을 사용한다는 것은, 앞서 본 2차원을 단어의 총개수만큼의 차원으로 확장하는 것과 같습니다. 예를 들어 아래와 같은 DTM이 있다고 합시다. 바나나 사과 저는 좋아요 문서 1 2 3 0 1 문서 2 1 2 3 1 문서 3 2 1 2 2 단어의 개수가 4개이므로, 이는 4차원 공간에 문서 1, 문서 2, 문서 3을 배치하는 것과 같습니다. 이때 다음과 같은 문서 Q에 대해서 문서 1, 문서 2, 문서 3 중 가장 유사한 문서를 찾아내고자 합니다. 바나나 사과 저는 좋아요 문서 Q 1 1 0 1 이때 유클리드 거리를 통해 유사도를 구하려고 한다면, 문서 Q 또한 다른 문서들처럼 4차원 공간에 배치시켰다는 관점에서 4차원 공간에서의 각각의 문서들과의 유클리드 거리를 구하면 됩니다. 이를 파이썬 코드로 구현해 보겠습니다. import numpy as np def dist(x, y): return np.sqrt(np.sum((x-y)**2)) doc1 = np.array((2,3,0,1)) doc2 = np.array((1,2,3,1)) doc3 = np.array((2,1,2,2)) docQ = np.array((1,1,0,1)) print('문서 1과 문서 Q의 거리 :',dist(doc1, docQ)) print('문서 2과 문서 Q의 거리 :',dist(doc2, docQ)) print('문서 3과 문서 Q의 거리 :',dist(doc3, docQ)) 문서 1과 문서 Q의 거리 : 2.23606797749979 문서 2과 문서 Q의 거리 : 3.1622776601683795 문서 3과 문서 Q의 거리 : 2.449489742783178 유클리드 거리의 값이 가장 작다는 것은 문서 간 거리가 가장 가깝다는 것을 의미합니다. 즉, 문서 1이 문서 Q와 가장 유사하다고 볼 수 있습니다. 2. 자카르 유사도(Jaccard similarity) A와 B 두 개의 집합이 있다고 합시다. 이때 교집합은 두 개의 집합에서 공통으로 가지고 있는 원소들의 집합을 말합니다. 즉, 합집합에서 교집합의 비율을 구한다면 두 집합 A와 B의 유사도를 구할 수 있다는 것이 자카르 유사도(jaccard similarity)의 아이디어입니다. 자카르 유사도는 0과 1사이의 값을 가지며, 만약 두 집합이 동일하다면 1의 값을 가지고, 두 집합의 공통 원소가 없다면 0의 값을 갖습니다. 자카르 유사도를 구하는 함수를 라고 하였을 때, 자카르 유사도 함수는 아래와 같습니다. ( , ) | ∩ | A B = A B | | | | | ∩ | 두 개의 비교할 문서를 각각 o 1 d c라고 했을 때 o 1 d c의 문서의 유사도를 구하기 위한 자카르 유사도는 이와 같습니다. ( o 1 d c) d c ∩ o 2 o 1 d c 두 문서 o 1 d c 사이의 자카르 유사도 ( o 1 d c) 는 두 집합의 교집합 크기를 두 집합의 합집합 크기로 나눈 값으로 정의됩니다. 간단한 예를 통해서 이해해 보겠습니다. doc1 = "apple banana everyone like likey watch card holder" doc2 = "apple banana coupon passport love you" # 토큰화 tokenized_doc1 = doc1.split() tokenized_doc2 = doc2.split() print('문서 1 :',tokenized_doc1) print('문서 2 :',tokenized_doc2) 문서 1 : ['apple', 'banana', 'everyone', 'like', 'likey', 'watch', 'card', 'holder'] 문서 2 : ['apple', 'banana', 'coupon', 'passport', 'love', 'you'] 문서 1과 문서 2의 합집합을 구해보겠습니다. union = set(tokenized_doc1).union(set(tokenized_doc2)) print('문서 1과 문서 2의 합집합 :',union) 문서 1과 문서 2의 합집합 : {'you', 'passport', 'watch', 'card', 'love', 'everyone', 'apple', 'likey', 'like', 'banana', 'holder', 'coupon'} 문서 1과 문서 2의 합집합의 단어의 총개수는 12개입니다. 이제 문서 1과 문서 2의 교집합을 구해보겠습니다. 문서 1과 문서 2에서 둘 다 등장한 단어를 찾으면 됩니다. intersection = set(tokenized_doc1).intersection(set(tokenized_doc2)) print('문서 1과 문서 2의 교집합 :',intersection) 문서 1과 문서 2의 교집합 : {'apple', 'banana'} 문서 1과 문서 2에서 둘 다 등장한 단어는 banana와 apple 총 2개입니다. 이제 교집합의 크기를 합집합의 크기로 나누면 자카르 유사도가 계산됩니다. print('자카르 유사도 :',len(intersection)/len(union)) 자카르 유사도 : 0.16666666666666666 12. [NLP 기본 ] - 텍스트 임베딩(Embedding): 신경망 기반의 표현 방법 이번 챕터에서는 자연어 처리에서 필수적으로 사용되는 단어의 표현 방법인 원-핫 인코딩(One-hot encoding)과 워드 임베딩(Word Embedding). 그리고 문서를 벡터화하는 방법에 대해서 학습합니다. 12-01 NLP에서의 원-핫 인코딩(One-hot encoding) 컴퓨터 또는 기계는 문자보다는 숫자를 더 잘 처리할 수 있습니다. 이를 위해 자연어 처리에서는 문자를 숫자로 바꾸는 여러 가지 기법들이 있습니다. 원-핫 인코딩(One-hot encoding)은 그 많은 기법 중에서 단어를 표현하는 가장 기본적인 표현 방법이며, 머신 러닝, 딥 러닝을 하기 위해서는 반드시 배워야 하는 표현 방법입니다. 원-핫 인코딩에 대해서 배우기에 앞서 단어 집합(vocabulary)에 대해서 정의해 보도록 하겠습니다. 어떤 분들은 사전(vocabulary)이라고도 부르지만, 저는 집합이라는 표현이 보다 명확하다고 생각하여 앞으로 단어 집합이라고 부르겠습니다. 단어 집합은 앞으로 자연어 처리에서 계속 나오는 개념이기 때문에 여기서 이해하고 가야 합니다. 단어 집합은 서로 다른 단어들의 집합입니다. 여기서 혼동이 없도록 서로 다른 단어라는 정의에 대해서 좀 더 주목할 필요가 있습니다. 단어 집합(vocabulary)에서는 기본적으로 book과 books와 같이 단어의 변형 형태도 다른 단어로 간주합니다. 이 책에서는 앞으로 단어 집합에 있는 단어들을 가지고, 문자를 숫자(더 구체적으로는 벡터)로 바꾸는 원-핫 인코딩을 포함한 여러 방법에 대해서 배우게 됩니다. 원-핫 인코딩을 위해서 먼저 해야 할 일은 단어 집합을 만드는 일입니다. 텍스트의 모든 단어를 중복을 허용하지 않고 모아놓으면 이를 단어 집합이라고 합니다. 그리고 이 단어 집합에 고유한 숫자를 부여하는 정수 인코딩을 진행합니다. 텍스트에 단어가 총 5,000개가 존재한다면, 단어 집합의 크기는 5,000입니다. 5,000개의 단어가 있는 이 단어 집합의 단어들마다 1번부터 5,000번까지 인덱스를 부여한다고 해보겠습니다. 가령, book은 150번, dog는 171번, love는 192번, books는 212번과 같이 부여할 수 있습니다. 이제 각 단어에 고유한 정수 인덱스를 부여하였다고 합시다. 이 숫자로 바뀐 단어들을 벡터로 다루고 싶다면 어떻게 하면 될까요? 1. 원-핫 인코딩(One-hot encoding)이란? 원-핫 인코딩은 단어 집합의 크기를 벡터의 차원으로 하고, 표현하고 싶은 단어의 인덱스에 1의 값을 부여하고, 다른 인덱스에는 0을 부여하는 단어의 벡터 표현 방식입니다. 이렇게 표현된 벡터를 원-핫 벡터(One-hot vector)라고 합니다. 원-핫 인코딩을 두 가지 과정으로 정리해 보겠습니다. (1) 각 단어에 고유한 인덱스를 부여합니다. (정수 인코딩) (2) 표현하고 싶은 단어의 인덱스의 위치에 1을 부여하고, 다른 단어의 인덱스의 위치에는 0을 부여합니다. 이해를 돕기 위해서 한국어 문장을 예제로 원-핫 벡터를 만들어보겠습니다. 우선, 한국어 자연어 처리를 위해 코엔엘파이 패키지를 설치합니다. pip install konlpy 문장 : 나는 자연어 처리를 배운다 위문장에 대해서 원-핫 인코딩을 진행하는 코드는 아래와 같습니다. from konlpy.tag import Okt okt = Okt() token = okt.morphs("나는 자연어 처리를 배운다") print(token) ['나', '는', '자연어', '처리', '를', '배운다'] 코엔엘파이의 Okt 형태소 분석기를 통해서 우선 문장에 대해서 토큰화를 수행하였습니다. word2index = {} for voca in token: if voca not in word2index.keys(): word2index[voca] = len(word2index) print(word2index) {'나': 0, '는': 1, '자연어': 2, '처리': 3, '를': 4, '배운다': 5} 각 토큰에 대해서 고유한 인덱스(index)를 부여하였습니다. 지금은 문장이 짧기 때문에 각 단어의 빈도수를 고려하지 않지만, 빈도수 순대로 단어를 정렬하여 고유한 인덱스를 부여하는 작업이 사용되기도 합니다. (정수 인코딩 챕터 참고) def one_hot_encoding(word, word2index): one_hot_vector = [0]*(len(word2index)) index = word2index[word] one_hot_vector[index] = 1 return one_hot_vector 토큰을 입력하면 해당 토큰에 대한 원-핫 벡터를 만들어내는 함수를 만들었습니다. one_hot_encoding("자연어",word2index) [0, 0, 1, 0, 0, 0] 해당 함수에 '자연어'라는 토큰을 입력으로 넣어봤더니 [0, 0, 1, 0, 0, 0]라는 벡터가 나왔습니다. 자연어는 단어 집합에서 인덱스가 2이므로, 자연어를 표현하는 원-핫 벡터는 인덱스 2의 값이 1이며, 나머지 값은 0인 벡터가 나옵니다. 2. 원-핫 인코딩(One-hot encoding)의 한계 이러한 표현 방식은 단어의 개수가 늘어날수록, 벡터를 저장하기 위해 필요한 공간이 계속 늘어난다는 단점이 있습니다. 다른 말로는 벡터의 차원이 계속 늘어난다고도 표현합니다. 원 핫 벡터는 단어 집합의 크기가 곧 벡터의 차원 수가 됩니다. 가령, 단어가 1,000개인 코퍼스를 가지고 원 핫 벡터를 만들면, 모든 단어 각각은 모두 1,000개의 차원을 가진 벡터가 됩니다. 다시 말해 모든 단어 각각은 하나의 값만 1을 가지고, 999개의 값은 0의 값을 가지는 벡터가 되는데 이는 저장 공간 측면에서는 매우 비효율적인 표현 방법입니다. 또한 원-핫 벡터는 단어의 유사도를 표현하지 못한다는 단점이 있습니다. 예를 들어서 늑대, 호랑이, 강아지, 고양이라는 4개의 단어에 대해서 원-핫 인코딩을 해서 각각, [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]이라는 원-핫 벡터를 부여받았다고 합시다. 이때 원-핫 벡터로는 강아지와 늑대가 유사하고, 호랑이와 고양이가 유사하다는 것을 표현할 수가 없습니다. 좀 더 극단적으로는 강아지, 개, 냉장고라는 단어가 있을 때 강아지라는 단어가 개와 냉장고라는 단어 중 어떤 단어와 더 유사한지도 알 수 없습니다. 단어 간 유사성을 알 수 없다는 단점은 검색 시스템 등에서 심각한 문제입니다. 가령, 여행을 가려고 웹 검색창에 '삿포로 숙소'라는 단어를 검색한다고 합시다. 제대로 된 검색 시스템이라면, '삿포로 숙소'라는 검색어에 대해서 '삿포로 게스트 하우스', '삿포로 료칸', '삿포로 호텔'과 같은 유사 단어에 대한 결과도 함께 보여줄 수 있어야 합니다. 하지만 단어 간 유사성을 계산할 수 없다면, '게스트 하우스'와 '료칸'과 '호텔'이라는 연관 검색어를 보여줄 수 없습니다. 12-02 워드 임베딩(Word Embedding) 워드 임베딩(Word Embedding)은 단어를 벡터로 표현하는 것을 말합니다. 워드 임베딩은 단어를 밀집 표현으로 변환하는 방법을 말합니다. 이번 챕터에서는 희소 표현, 밀집 표현, 그리고 워드 임베딩에 대한 개념을 이해합니다. 1. 희소 표현(Sparse Representation) 앞서 원-핫 인코딩을 통해서 나온 원-핫 벡터들은 표현하고자 하는 단어의 인덱스의 값만 1이고, 나머지 인덱스에는 전부 0으로 표현되는 벡터 표현 방법이었습니다. 이렇게 벡터 또는 행렬(matrix)의 값이 대부분이 0으로 표현되는 방법을 희소 표현(sparse representation)이라고 합니다. 그러니까 원-핫 벡터는 희소 벡터(sparse vector)입니다. 이러한 희소 벡터의 문제점은 단어의 개수가 늘어나면 벡터의 차원이 한없이 커진다는 점입니다. 원-핫 벡터로 표현할 때는 갖고 있는 코퍼스에 단어가 10,000개였다면 벡터의 차원은 10,000이어야만 했습니다. 심지어 그중에서 단어의 인덱스에 해당되는 부분만 1이고 나머지는 0의 값을 가져야만 했습니다. 단어 집합이 클수록 고차원의 벡터가 됩니다. 예를 들어 단어가 10,000개 있고 강아지란 단어의 인덱스는 5였다면 원 핫 벡터는 이렇게 표현되어야 했습니다. Ex) 강아지 = [ 0 0 0 0 0 1 0 0 0 0 0 0 ... 중략 ... 0] # 이때 1 뒤의 0의 수는 9994개. 이러한 벡터 표현은 공간적 낭비를 불러일으킵니다. 원-핫 벡터의 문제점은 단어 벡터 간 유사도를 표현할 수 없다는 점도 있습니다. 예를 들어보겠습니다. dog, cat, computer, netbook, book 이러한 단어가 5개에 대해서 원-핫 인코딩을 한다고 해봅시다. 우선 이 단어들에 0, 1, 2, 3, 4라는 고유한 정수를 부여합다. 그러고 나서 단어의 개수가 5개이므로 벡터의 차원으로 5로 하고 부여된 각 고유한 정수를 인덱스로 하여 해당 인덱스에는 1, 나머지는 0의 값을 채워 넣습니다. 이를 코드로 표현하면 아래와 같습니다. import torch # 원-핫 벡터 생성 dog = torch.FloatTensor([1, 0, 0, 0, 0]) cat = torch.FloatTensor([0, 1, 0, 0, 0]) computer = torch.FloatTensor([0, 0, 1, 0, 0]) netbook = torch.FloatTensor([0, 0, 0, 1, 0]) book = torch.FloatTensor([0, 0, 0, 0, 1]) 이러한 원-핫 벡터 간 코사인 유사도를 구해보겠습니다. print(torch.cosine_similarity(dog, cat, dim=0)) print(torch.cosine_similarity(cat, computer, dim=0)) print(torch.cosine_similarity(computer, netbook, dim=0)) print(torch.cosine_similarity(netbook, book, dim=0)) tensor(0.) tensor(0.) tensor(0.) tensor(0.) 사람이 생각하기에 강아지와 고양이라는 단어의 유사도는 고양이와 컴퓨터라는 단어의 유사도보다 높을 것이며, 컴퓨터와 넷북이라는 단어의 유사도는 넷북과 책이라는 단어의 유사도보다 높을 것 같지만 어떤 단어들을 선택해서 코사인 유사도를 구해도 유사도는 전부 동일합니다. 단어 간 의미적 유사도를 반영할 수 없다는 것은 자연어 처리에서 치명적입니다. 2. 밀집 표현(Dense Representation) 이러한 희소 표현과 반대되는 표현이 있으니, 이를 밀집 표현(dense representation)이라고 합니다. 밀집 표현은 벡터의 차원을 단어 집합의 크기로 상정하지 않습니다. 사용자가 설정한 값으로 모든 단어의 벡터 표현의 차원을 맞춥니다. 또한, 이 과정에서 더 이상 0과 1만 가진 값이 아니라 실숫값을 가지게 됩니다. 다시 희소 표현의 예를 가져와봅시다. Ex) 강아지 = [ 0 0 0 0 1 0 0 0 0 0 0 0 ... 중략 ... 0] # 이때 1 뒤의 0의 수는 9995개. 차원은 10,000 예를 들어 10,000개의 단어가 있을 때 강아지란 단어를 표현하기 위해서는 위와 같은 표현을 사용했습니다. 하지만 밀집 표현을 사용하고, 사용자가 밀집 표현의 차원을 128로 설정한다면, 모든 단어의 벡터 표현의 차원은 128로 바뀌면서 모든 값이 실수가 됩니다. Ex) 강아지 = [0.2 1.8 1.1 -2.1 1.1 2.8 ... 중략 ...] # 이 벡터의 차원은 128 이 경우 벡터의 차원이 조밀해졌다고 하여 밀집 벡터(dense vector)라고 합니다. 3. 워드 임베딩(Word Embedding) 단어를 밀집 벡터(dense vector)의 형태로 표현하는 방법을 워드 임베딩(word embedding)이라고 합니다. 그리고 이 밀집 벡터를 워드 임베딩 과정을 통해 나온 결과라고 하여 임베딩 벡터(embedding vector)라고도 합니다. 워드 임베딩 방법론으로는 LSA, Word2Vec, FastText, Glove 등이 있습니다. 파이 토치에서 제공하는 도구인 nn.embedding()는 앞서 언급한 방법들을 사용하지는 않지만, 단어를 랜덤 한 값을 가지는 밀집 벡터로 변환한 뒤에, 인공 신경망의 가중치를 학습하는 것과 같은 방식으로 단어 벡터를 학습하는 방법을 사용합니다. 아래의 표는 앞서 배운 원-핫 벡터와 지금 배우고 있는 임베딩 벡터의 차이를 보여줍니다. - 원-핫 벡터 임베딩 벡터 차원 고차원(단어 집합의 크기) 저차원 다른 표현 희소 벡터의 일종 밀집 벡터의 일종 표현 방법 수동 훈련 데이터로부터 학습함 값의 타입 1과 0 실수 12-03 워드투벡터(Word2Vec) 앞서 원-핫 인코딩 챕터에서 원-핫 벡터는 단어 간 유사도를 계산할 수 없다는 단점이 있음을 언급한 적이 있습니다. 그래서 단어 간 유사도를 반영할 수 있도록 단어의 의미를 벡터화할 수 있는 방법이 필요합니다. 그리고 이를 위해서 사용되는 대표적인 방법이 워드투벡터(Word2Vec)입니다. Word2Vec의 개념을 설명하기에 앞서, Word2Vec가 어떤 일을 할 수 있는지 먼저 확인해 보겠습니다. http://w.elnn.kr/search/ 위 사이트는 한국어 단어에 대해서 벡터 연산을 해볼 수 있는 사이트입니다. 위 사이트에서는 단어들(실제로는 Word2Vec 벡터)로 더하기, 빼기 연산을 할 수 있습니다. 예를 들어 아래의 식에서 좌변을 집어넣으면, 우변의 답들이 나옵니다. 고양이 + 애교 = 강아지 한국 - 서울 + 도쿄 = 일본 박찬호 - 야구 + 축구 = 호나우두 신기하게도 단어가 가지고 있는 어떤 의미들을 가지고 연산을 하고 있는 것처럼 보입니다. 이런 연산이 가능한 이유는 각 단어 벡터가 단어 간 유사도를 반영한 값을 가지고 있기 때문입니다. 어떻게 이런 일이 가능한 것일까요? 1. 희소 표현(Sparse Representation) 앞서 원-핫 인코딩을 통해서 나온 원-핫 벡터들은 표현하고자 하는 단어의 인덱스의 값만 1이고, 나머지 인덱스에는 전부 0으로 표현되는 벡터 표현 방법이었습니다. 이렇게 벡터 또는 행렬(matrix)의 값이 대부분이 0으로 표현되는 방법을 희소 표현(sparse representation)이라고 합니다. 그러니까 원-핫 벡터는 희소 벡터(sparse vector)입니다. 하지만 이러한 표현 방법은 각 단어 간 유사성을 표현할 수 없다는 단점이 있었고, 이를 위한 대안으로 단어의 '의미'를 다차원 공간에 벡터화하는 방법을 찾게 되는데, 이러한 표현 방법을 분산 표현(distributed representation)이라고 합니다. 그리고 이렇게 분산 표현을 이용하여 단어의 유사도를 벡터화하는 작업은 워드 임베딩(embedding) 작업에 속하기 때문에 이렇게 표현된 벡터 또한 임베딩 벡터(embedding vector)라고 하며, 저차원을 가지므로 바로 앞의 챕터에서 배운 밀집 벡터(dense vector)에도 속합니다. 2. 분산 표현(Distributed Representation) 분산 표현(distributed representation) 방법은 기본적으로 분포 가설(distributional hypothesis)이라는 가정 하에 만들어진 표현 방법입니다. 이 가정은 '비슷한 위치에서 등장하는 단어들은 비슷한 의미를 가진다'라는 가정입니다. 강아지란 단어는 귀엽다, 예쁘다, 애교 등의 단어가 주로 함께 등장하는데 분포 가설에 따라서 저런 내용을 가진 텍스트를 벡터화한다면 저 단어들은 의미적으로 가까운 단어가 됩니다. 분산 표현은 분포 가설을 이용하여 단어들의 셋을 학습하고, 벡터에 단어의 의미를 여러 차원에 분산하여 표현합니다. 이렇게 표현된 벡터들은 원-핫 벡터처럼 벡터의 차원이 단어 집합(vocabulary)의 크기일 필요가 없으므로, 벡터의 차원이 상대적으로 저차원으로 줄어듭니다. 예를 들어 단어가 10,000개 있고 인덱스가 1부터 시작한다고 하였을 때 강아지란 단어의 인덱스는 5였다면 강아지란 단어를 표현하는 원-핫 벡터는 다음과 같았습니다. Ex) 강아지 = [ 0 0 0 0 1 0 0 0 0 0 0 0 ... 중략 ... 0] 1이란 값 뒤에는 0이 9,995개가 있는 벡터가 됩니다. 하지만 Word2Vec로 임베딩 된 벡터는 굳이 벡터의 차원이 단어 집합의 크기가 될 필요가 없습니다. 강아지란 단어를 표현하기 위해 사용자가 설정한 차원을 가지는 벡터가 되면서 각 차원은 실수형의 값을 가집니다. Ex) 강아지 = [0.2 0.3 0.5 0.7 0.2 ... 중략 ... 0.2] 요약하면 희소 표현이 고차원에 각 차원이 분리된 표현 방법이었다면, 분산 표현은 저차원에 단어의 의미를 여러 차원에다가 분산하여 표현합니다. 이런 표현 방법을 사용하면 단어 간 유사도를 계산할 수 있습니다. 이를 위한 학습 방법으로는 NNLM, RNNLM 등이 있으나 요즘에는 해당 방법들의 속도를 대폭 개선한 Word2Vec가 많이 쓰이고 있습니다. 3. CBOW(Continuous Bag of Words) Word2Vec에는 CBOW(Continuous Bag of Words)와 Skip-Gram 두 가지 방식이 있습니다. CBOW는 주변에 있는 단어들을 가지고, 중간에 있는 단어들을 예측하는 방법입니다. 반대로, Skip-Gram은 중간에 있는 단어로 주변 단어들을 예측하는 방법입니다. 메커니즘 자체는 거의 동일하기 때문에 CBOW를 이해한다면 Skip-Gram도 손쉽게 이해 가능합니다. 우선 CBOW에 대해서 알아보도록 하겠습니다. 이해를 위해 매우 간소화된 형태의 CBOW로 설명합니다. 예문 : "The fat cat sat on the mat" 예를 들어서 갖고 있는 코퍼스에 위와 같은 문장이 있다고 합시다. 가운데 단어를 예측하는 것이 CBOW라고 했습니다. {"The", "fat", "cat", "on", "the", "mat"}으로부터 sat을 예측하는 것은 CBOW가 하는 일입니다. 이때 예측해야 하는 단어 sat을 중심 단어(center word)라고 하고, 예측에 사용되는 단어들을 주변 단어(context word)라고 합니다. 중심 단어를 예측하기 위해서 앞, 뒤로 몇 개의 단어를 볼지를 결정했다면 이 범위를 윈도(window)라고 합니다. 예를 들어서 윈도 크기가 2이고, 예측하고자 하는 중심 단어가 sat이라고 한다면 앞의 두 단어인 fat와 cat, 그리고 뒤의 두 단어인 on, the를 참고합니다. 윈도 크기가 n이라고 한다면, 실제 중심 단어를 예측하기 위해 참고하려고 하는 주변 단어의 개수는 2n이 될 것입니다. 윈도 크기를 정했다면, 윈도를 계속 움직여서 주변 단어와 중심 단어 선택을 바꿔가며 학습을 위한 데이터 셋을 만들 수 있는데, 이 방법을 슬라이딩 윈도(sliding window)라고 합니다. 위 그림에서 좌측의 중심 단어와 주변 단어의 변화는 윈도 크기가 2일 때, 슬라이딩 윈도가 어떤 식으로 이루어지면서 데이터 셋을 만드는지 보여줍니다. 또한 Word2Vec에서 입력은 모두 원-핫 벡터가 되어야 하는데, 우측 그림은 중심 단어와 주변 단어를 어떻게 선택했을 때에 따라서 각각 어떤 원-핫 벡터가 되는지를 보여줍니다. 위 그림은 결국 CBOW를 위한 전체 데이터 셋을 보여주는 것입니다. CBOW의 인공 신경망을 간단히 도식화하면 위와 같습니다. 입력층(Input layer)의 입력으로서 앞, 뒤로 사용자가 정한 윈도 크기 범위 안에 있는 주변 단어들의 원-핫 벡터가 들어가게 되고, 출력층(Output layer)에서 예측하고자 하는 중간 단어의 원-핫 벡터가 필요합니다. 뒤에서 설명하겠지만, Word2Vec의 학습을 위해서 이 중간 단어의 원-핫 벡터가 필요합니다. 또한 위 그림에서 알 수 있는 사실은, Word2Vec은 딥 러닝 모델(Deep Learning Model)은 아니라는 점입니다. 보통 딥 러닝이라 함은, 입력층과 출력층 사이의 은닉층의 개수가 충분히 쌓인 신경망을 학습할 때를 말하는데 Word2Vec는 입력층과 출력층 사이에 하나의 은닉층만이 존재합니다. 이렇게 은닉층(hidden Layer)이 1개인 경우에는 일반적으로 심층 신경망(Deep Neural Network)이 아니라 얕은 신경망(Shallow Neural Network)이라고 부릅니다. 또한 Word2Vec의 은닉층은 일반적인 은닉층과는 달리 활성화 함수가 존재하지 않으며 룩업 테이블이라는 연산을 담당하는 층으로 일반적인 은닉층과 구분하기 위해 투사층(projection layer)이라고 부르기도 합니다. CBOW의 인공 신경망을 좀 더 확대하여, 동작 메커니즘에 대해서 상세하게 알아보도록 하겠습니다. 이 그림에서 주목해야 할 것은 두 가지입니다. 하나는 투사층의 크기가 M이라는 점입니다. CBOW에서 투사층의 크기 M은 임베딩하고 난 벡터의 차원이 됩니다. 다시 말해, 위의 그림에서 투사층의 크기는 M=5이기 때문에 CBOW를 수행하고 나서 얻는 각 단어의 임베딩 벡터의 차원은 5가 될 것입니다. 두 번째는 입력층과 투사층 사이의 가중치 W는 V × M 행렬이며, 투사층에서 출력층 사이의 가중치 W'는 M × V 행렬이라는 점입니다. 여기서 V는 단어 집합의 크기를 의미합니다. 즉, 위의 그림처럼 원-핫 벡터의 차원이 7이고, M은 5라면 가중치 W는 7 × 5 행렬이고, W'는 5 × 7 행렬이 될 것입니다. 주의할 점은 이 두 행렬은 동일한 행렬을 전치(transpose) 한 것이 아니라, 서로 다른 행렬이라는 점입니다. 인공 신경망의 훈련 전에 이 가중치 행렬 W와 W'는 대게 굉장히 작은 랜덤 값을 가지게 됩니다. CBOW는 주변 단어로 중심 단어를 더 정확히 맞추기 위해 계속해서 이 W와 W'를 학습해가는 구조입니다. 입력으로 들어오는 주변 단어의 원-핫 벡터와 가중치 W 행렬의 곱이 어떻게 이루어지는지 보겠습니다. 위 그림에서는 각 주변 단어의 원-핫 벡터를 로 표기하였습니다. 입력 벡터는 원-핫 벡터입니다. i 번째 인덱스에 1이라는 값을 가지고 그 외의 0의 값을 가지는 입력 벡터와 가중치 W 행렬의 곱은 사실 W 행렬의 i번째 행을 그대로 읽어오는 것과(lookup) 동일합니다. 그래서 이 작업을 룩업 테이블(lookup table)이라고 부릅니다. 앞서 CBOW의 목적은 W와 W'를 잘 훈련시키는 것이라고 언급한 적이 있는데, 사실 그 이유가 여기서 lookup 해온 W의 각 행벡터가 사실 Word2Vec을 수행한 후의 각 단어의 M 차원의 크기를 갖는 임베딩 벡터들이기 때문입니다. 이렇게 각 주변 단어의 원-핫 벡터에 대해서 가중치 W가 곱해서 생긴 결과 벡터들은 투사층에서 만나 이 벡터들의 평균인 벡터를 구하게 됩니다. 만약 윈도 크기가 2라면, 입력 벡터의 총개수는 2n이므로 중간 단어를 예측하기 위해서는 총 4개가 입력 벡터로 사용됩니다. 그렇기 때문에 평균을 구할 때는 4개의 결과 벡터에 대해서 평균을 구하게 됩니다. 투사층에서 벡터의 평균을 구하는 부분은 CBOW가 Skip-Gram과 다른 차이점이기도 합니다. 뒤에서 보게 되겠지만, Skip-Gram은 입력이 중심 단어 하나이기 때문에 투사층에서 벡터의 평균을 구하지 않습니다. 이렇게 구해진 평균 벡터는 두 번째 가중치 행렬 W'와 곱해집니다. 곱셈의 결과로는 원-핫 벡터들과 차원이 V로 동일한 벡터가 나옵니다. 만약 입력 벡터의 차원이 7이었다면 여기서 나오는 벡터도 마찬가지입니다. 이 벡터에 CBOW는 소프트맥스(softmax) 함수를 취하는데, 소프트맥스 함수로 인한 출력값은 0과 1사이의 실수로, 각 원소의 총합은 1이 되는 상태로 바뀝니다. 이렇게 나온 벡터를 스코어 벡터(score vector)라고 합니다. 스코어 벡터의 각 차원 안에서의 값이 의미하는 것은 아래와 같습니다. 스코어 벡터의 j 번째 인덱스가 가진 0과 1사이의 값은 j 번째 단어가 중심 단어일 확률을 나타냅니다. 그리고 이 스코어 벡터는 우리가 실제로 값을 알고 있는 벡터인 중심 단어 원-핫 벡터의 값에 가까워져야 합니다. 스코어 벡터를 ^ 라고 하겠습니다. 중심 단어를로 했을 때, 이 두 벡터 값의 오차를 줄이기 위해 CBOW는 손실 함수(loss function)로 cross-entropy 함수를 사용합니다. cross-entropy 함수에 실제 중심 단어인 원-핫 벡터와 스코어 벡터를 입력값으로 넣고, 이를 식으로 표현하면 위와 같습니다. 그런데 y가 원-핫 벡터라는 점을 고려하면, 이 식은 위와 같이 간소화시킬 수 있습니다. 이 식이 왜 loss function으로 적합한지 알아보겠습니다. c를 중심 단어에서 1을 가진 차원의 값의 인덱스라고 한다면,는 ^ y 를 정확하게 예측한 경우가 됩니다. 이를 식에 대입해 보면 -1 log(1) = 0이 되기 때문에, 결과적으로 ^ y 를 정확하게 예측한 경우의 cross-entropy의 값은 0이 됩니다. 즉, 이 값을 최소화하는 방향으로 학습해야 합니다. 이제 역전파(Back Propagation)를 수행하면 W와 W'가 학습이 되는데, 학습이 다 되었다면 M 차원의 크기를 갖는 W의 행이나 W'의 열로부터 어떤 것을 임베딩 벡터로 사용할지를 결정하면 됩니다. 때로는 W와 W'의 평균치를 가지고 임베딩 벡터를 선택하기도 합니다. 4. Skip-gram Skip-gram은 CBOW를 이해했다면, 메커니즘 자체는 동일하기 때문에 쉽게 이해할 수 있습니다. 앞서 CBOW에서는 주변 단어를 통해 중심 단어를 예측했다면, Skip-gram은 중심 단어에서 주변 단어를 예측하려고 합니다. 앞서 언급한 동일한 예문에 대해서 인공 신경망을 도식화해보면 위와 같습니다. 이제 중심 단어에 대해서 주변 단어를 예측하기 때문에, 투사층에서 벡터들의 평균을 구하는 과정은 없습니다. 여러 논문에서 성능 비교를 진행했을 때, 전반적으로 Skip-gram이 CBOW보다 성능이 좋다고 알려져 있습니다. 5. 네거티브 샘플링(Negative Sampling) 대체적으로 Word2Vec를 사용한다고 하면 SGNS(Skip-Gram with Negative Sampling)을 사용합니다. Skip-gram을 사용하는데, 네거티브 샘플링(Negative Sampling)이란 방법까지 추가로 사용한다는 겁니다. Skip-gram을 전제로 네거티브 샘플링에 대해서 알아봅시다. 위에서 배운 Word2Vec 모델에는 한 가지 문제점이 있습니다. 바로 속도입니다. Word2Vec의 마지막 단계를 주목해 봅시다. 출력층에 있는 소프트맥스 함수는 단어 집합 크기의 벡터 내의 모든 값을 0과 1사이의 값이면서 모두 더하면 1이 되도록 바꾸는 작업을 수행합니다. 그리고 이에 대한 오차를 구하고 모든 단어에 대한 임베딩을 조정합니다. 그 단어가 중심 단어나 주변 단어와 전혀 상관없는 단어라도 마찬가지입니다. 그런데 만약 단어 집합의 크기가 수백만에 달한다면 이 작업은 굉장히 무거운 작업입니다. 여기서 중요한 건 Word2Vec이 모든 단어 집합에 대해서 소프트맥스 함수를 수행하고, 역전파를 수행하므로 주변 단어와 상관없는 모든 단어까지의 워드 임베딩 조정 작업을 수행한다는 겁니다. 만약 마지막 단계에서 '강아지'와 '고양이'와 같은 단어에 집중하고 있다면, Word2Vec은 사실 '돈가스'나 '컴퓨터'와 같은 연관 관계가 없는 수많은 단어의 임베딩을 조정할 필요가 없습니다. 이를 조금 더 효율적으로 할 수 있는 방법이 없을까요? 전체 단어 집합이 아니라 일부 단어 집합에 대해서만 고려하면 안 될까요? 이렇게 일부 단어 집합을 만들어봅시다. '강아지', '고양이', '애교'와 같은 주변 단어들을 가져옵니다. 그리고 여기에 '돈가스', '컴퓨터', '회의실'과 같은 랜덤으로 선택된 주변 단어가 아닌 상관없는 단어들을 일부만 갖고 옵니다. 이렇게 전체 단어 집합보다 훨씬 작은 단어 집합을 만들어놓고 마지막 단계를 이진 분류 문제로 바꿔버리는 겁니다. 즉, Word2Vec은 주변 단어들을 긍정(positive)으로 두고 랜덤으로 샘플링 된 단어들을 부정(negative)으로 둔 다음에 이진 분류 문제를 수행합니다. 이는 기존의 다중 클래스 분류 문제를 이진 분류 문제로 바꾸면서도 연산량에 있어서 훨씬 효율적입니다. 다음 챕터에서 영어와 한국어 훈련 데이터에 대해서 Word2Vec 모델을 훈련시키는 실습을 진행해 보겠습니다. 12-04 영어/한국어 Word2Vec 학습시키기 gensim 패키지에서 제공하는 이미 구현된 Word2Vec을 사용하여 영어와 한국어 데이터를 학습합니다. 1. 영어 Word2Vec 만들기 파이썬의 gensim 패키지에는 Word2Vec을 지원하고 있어, gensim 패키지를 이용하면 손쉽게 단어를 임베딩 벡터로 변환시킬 수 있습니다. 영어로 된 코퍼스를 다운로드해 전처리를 수행하고, 전처리한 데이터를 바탕으로 Word2Vec 작업을 진행하겠습니다. import re import urllib.request import zipfile from lxml import etree from nltk.tokenize import word_tokenize, sent_tokenize 1) 훈련 데이터 이해하기 훈련 데이터를 다운로드합니다. # 데이터 다운로드 urllib.request.urlretrieve("https://raw.githubusercontent.com/ukairia777/tensorflow-nlp-tutorial/main/09.%20Word%20Embedding/dataset/ted_en-20160408.xml", filename="ted_en-20160408.xml") 훈련 데이터 파일은 xml 문법으로 작성되어 있어 자연어를 얻기 위해서는 전처리가 필요합니다. 얻고자 하는 실질적 데이터는 영어 문장으로 만 구성된 내용을 담고 있는 <content>와 </content> 사이의 내용입니다. 전처리 작업을 통해 xml 문법들은 제거하고, 해당 데이터만 가져와야 합니다. 뿐만 아니라, <content>와 </content> 사이의 내용 중에는 (Laughter)나 (Applause)와 같은 배경음을 나타내는 단어도 등장하는데 이 또한 제거해야 합니다. <file id="1"> <head> <url>http://www.ted.com/talks/knut_haanaes_two_reasons_companies_fail_and_how_to_avoid_them</url> <pagesize>72832</pagesize> ... xml 문법 중략 ... <content> Here are two reasons companies fail: they only do more of the same, or they only do what's new. To me the real, real solution to quality growth is figuring out the balance between two activities: ... content 내용 중략 ... To me, the irony about the Facit story is hearing about the Facit engineers, who had bought cheap, small electronic calculators in Japan that they used to double-check their calculators. (Laughter) ... content 내용 중략 ... (Applause) </content> </file> <file id="2"> <head> <url>http://www.ted.com/talks/lisa_nip_how_humans_could_evolve_to_survive_in_space<url> ... 이하 중략 ... 2) 훈련 데이터 전처리하기 위 데이터를 위한 전처리 코드는 아래와 같습니다. targetXML = open('ted_en-20160408.xml', 'r', encoding='UTF8') target_text = etree.parse(targetXML) # xml 파일로부터 <content>와 </content> 사이의 내용만 가져온다. parse_text = '\n'.join(target_text.xpath('//content/text()')) # 정규 표현식의 sub 모듈을 통해 content 중간에 등장하는 (Audio), (Laughter) 등의 배경음 부분을 제거. # 해당 코드는 괄호로 구성된 내용을 제거. content_text = re.sub(r'\([^)]*\)', '', parse_text) # 입력 코퍼스에 대해서 NLTK를 이용하여 문장 토큰화를 수행. sent_text = sent_tokenize(content_text) # 각 문장에 대해서 구두점을 제거하고, 대문자를 소문자로 변환. normalized_text = [] for string in sent_text: tokens = re.sub(r"[^a-z0-9]+", " ", string.lower()) normalized_text.append(tokens) # 각 문장에 대해서 NLTK를 이용하여 단어 토큰화를 수행. result = [word_tokenize(sentence) for sentence in normalized_text] print('총 샘플의 개수 : {}'.format(len(result))) 총 샘플의 개수 : 273424 총 샘플의 개수는 약 27만 3천 개입니다. # 샘플 3개만 출력 for line in result[:3]: print(line) ['here', 'are', 'two', 'reasons', 'companies', 'fail', 'they', 'only', 'do', 'more', 'of', 'the', 'same', 'or', 'they', 'only', 'do', 'what', 's', 'new'] ['to', 'me', 'the', 'real', 'real', 'solution', 'to', 'quality', 'growth', 'is', 'figuring', 'out', 'the', 'balance', 'between', 'two', 'activities', 'exploration', 'and', 'exploitation'] ['both', 'are', 'necessary', 'but', 'it', 'can', 'be', 'too', 'much', 'of', 'a', 'good', 'thing'] 상위 3개 문장만 출력해 보았는데 토큰 화가 수행되었음을 볼 수 있습니다. Word2Vec 모델에 텍스트 데이터를 훈련시킵니다. 3) Word2Vec 훈련시키기 from gensim.models import Word2Vec from gensim.models import KeyedVectors model = Word2Vec(sentences=result, vector_size=100, window=5, min_count=5, workers=4, sg=0) Word2Vec의 하이퍼 파라미터 값은 다음과 같습니다. vector_size = 워드 벡터의 특징 값. 즉, 임베딩 된 벡터의 차원. window = 컨텍스트 윈도 크기 min_count = 단어 최소 빈도 수 제한 (빈도가 적은 단어들은 학습하지 않는다.) workers = 학습을 위한 프로세스 수 sg = 0은 CBOW, 1은 Skip-gram. Word2Vec에 대해서 학습을 진행하였습니다. Word2Vec는 입력한 단어에 대해서 가장 유사한 단어들을 출력하는 model.wv.most_similar을 지원합니다. man과 가장 유사한 단어들은 어떤 단어들일까요? model_result = model.wv.most_similar("man") print(model_result) [('woman', 0.842622697353363), ('guy', 0.8178728818893433), ('boy', 0.7774451375007629), ('lady', 0.7767927646636963), ('girl', 0.7583760023117065), ('gentleman', 0.7437191009521484), ('soldier', 0.7413754463195801), ('poet', 0.7060446739196777), ('kid', 0.6925194263458252), ('friend', 0.6572611331939697)] man과 유사한 단어로 woman, guy, boy, lady, girl, gentleman, soldier, kid 등을 출력하는 것을 볼 수 있습니다. Word2Vec를 통해 단어의 유사도를 계산할 수 있게 되었습니다. 4) Word2Vec 모델 저장하고 로드하기 공들여 학습한 모델을 언제든 나중에 다시 사용할 수 있도록 컴퓨터 파일로 저장하고 다시 로드해 보겠습니다. 이 모델을 가지고 향후 시각화를 진행할 예정이므로 꼭 저장해 주세요. model.wv.save_word2vec_format('eng_w2v') # 모델 저장 loaded_model = KeyedVectors.load_word2vec_format("eng_w2v") # 모델 로드 로드한 모델에 대해서 다시 man과 유사한 단어를 출력해 보겠습니다. model_result = loaded_model.most_similar("man") print(model_result) [('woman', 0.842622697353363), ('guy', 0.8178728818893433), ('boy', 0.7774451375007629), ('lady', 0.7767927646636963), ('girl', 0.7583760023117065), ('gentleman', 0.7437191009521484), ('soldier', 0.7413754463195801), ('poet', 0.7060446739196777), ('kid', 0.6925194263458252), ('friend', 0.6572611331939697)] 2. 한국어 Word2Vec 만들기(네이버 영화 리뷰) 네이버 영화 리뷰 데이터로 한국어 Word2Vec을 만들어봅시다. import pandas as pd import matplotlib.pyplot as plt import urllib.request from gensim.models.word2vec import Word2Vec from konlpy.tag import Okt 네이버 영화 리뷰 데이터를 다운로드합니다. urllib.request.urlretrieve("https://raw.githubusercontent.com/e9t/nsmc/master/ratings.txt", filename="ratings.txt") 네이버 영화 리뷰 데이터를 데이터 프레임으로 로드하고 상위 5개의 행을 출력해 봅시다. train_data = pd.read_table('ratings.txt') train_data[:5] # 상위 5개 출력 총 리뷰 개수를 확인해 보겠습니다. print(len(train_data)) # 리뷰 개수 출력 200000 총 20만 개의 샘플이 존재하는데, 결측값 유무를 확인합니다. # NULL 값 존재 유무 print(train_data.isnull().values.any()) True 결측값이 존재하므로 결측값이 존재하는 행을 제거합니다. train_data = train_data.dropna(how = 'any') # Null 값이 존재하는 행 제거 print(train_data.isnull().values.any()) # Null 값이 존재하는지 확인 False 결측값이 삭제된 후의 리뷰 개수를 확인합니다. print(len(train_data)) # 리뷰 개수 출력 199992 총 199,992개의 리뷰가 존재합니다. 정규 표현식을 통해 한글이 아닌 경우 제거하는 전처리를 진행합니다. # 정규 표현식을 통한 한글 외 문자 제거 train_data['document'] = train_data['document'].str.replace("[^ㄱ-ㅎㅏ-ㅣ가-힣 ]","") train_data[:5] # 상위 5개 출력 학습 시에 사용하고 싶지 않은 단어들인 불용어를 제거하겠습니다. 형태소 분석기 Okt를 사용하여 각 문장에 대해서 일종의 단어 내지는 형태소 단위로 나누는 토큰화를 수행합니다. 다소 시간이 소요될 수 있습니다. # 불용어 정의 stopwords = ['의','가','이','은','들','는','좀','잘','그냥','과','도','를','으로','자','에','와','한','하다'] # 형태소 분석기 OKT를 사용한 토큰화 작업 (다소 시간 소요) okt = Okt() tokenized_data = [] for sentence in tqdm(train_data['document']): tokenized_sentence = okt.morphs(sentence, stem=True) # 토큰화 stopwords_removed_sentence = [word for word in tokenized_sentence if not word in stopwords] # 불용어 제거 tokenized_data.append(stopwords_removed_sentence) 토큰 화가 된 상태에서는 각 리뷰의 길이 분포 또한 확인이 가능합니다. # 리뷰 길이 분포 확인 print('리뷰의 최대 길이 :',max(len(review) for review in tokenized_data)) print('리뷰의 평균 길이 :',sum(map(len, tokenized_data))/len(tokenized_data)) plt.hist([len(review) for review in tokenized_data], bins=50) plt.xlabel('length of samples') plt.ylabel('number of samples') plt.show() 리뷰의 최대 길이 : 72 리뷰의 평균 길이 : 10.716703668146726 Word2Vec으로 토큰화된 네이버 영화 리뷰 데이터를 학습합니다. from gensim.models import Word2Vec model = Word2Vec(sentences = tokenized_data, vector_size = 100, window = 5, min_count = 5, workers = 4, sg = 0) 학습이 다 되었다면 Word2Vec 임베딩 행렬의 크기를 확인합니다. # 완성된 임베딩 매트릭스의 크기 확인 model.wv.vectors.shape (16477, 100) 총 16,477개의 단어가 존재하며 각 단어는 100차원으로 구성돼 있습니다. '최민식'과 유사한 단어들을 뽑아봅시다. print(model.wv.most_similar("최민식")) [('한석규', 0.8789200782775879), ('안성기', 0.8757420778274536), ('김수현', 0.855679452419281), ('이민호', 0.854516863822937), ('김명민', 0.8525030612945557), ('최민수', 0.8492398262023926), ('이성재', 0.8478372097015381), ('윤제문', 0.8470626473426819), ('김창완', 0.8456774950027466), ('이주승', 0.8442063927650452)] '히어로'와 유사한 단어들을 뽑아봅시다. print(model.wv.most_similar("히어로")) [('슬래셔', 0.8747539520263672), ('누아르', 0.8666149377822876), ('무협', 0.8423701524734497), ('호러', 0.8372749090194702), ('물의', 0.8365858793258667), ('무비', 0.8260530233383179), ('물', 0.8197994232177734), ('홍콩', 0.8120777606964111), ('블록버스터', 0.8021541833877563), ('블랙', 0.7880141139030457)] 3. 사전 훈련된 Word2Vec 임베딩(Pre-trained Word2Vec embedding) 소개 자연어 처리 작업을 할 때, 케라스의 Embedding()를 사용하여 갖고 있는 훈련 데이터로부터 처음부터 임베딩 벡터를 훈련시키기도 하지만, 위키피디아 등의 방대한 데이터로 사전에 훈련된 워드 임베딩(pre-trained word embedding vector)를 가지고 와서 해당 벡터들의 값을 원하는 작업에 사용할 수도 있습니다. 예를 들어서 감성 분류 작업을 하는데 훈련 데이터의 양이 부족한 상황이라면, 다른 방대한 데이터를 Word2Vec이나 GloVe 등으로 사전에 학습시켜놓은 임베딩 벡터들을 가지고 와서 모델의 입력으로 사용하는 것이 때로는 더 좋은 성능을 얻을 수 있습니다. 사전 훈련된 워드 임베딩을 가져와서 간단히 단어들의 유사도를 구해보는 실습을 해보겠습니다. 실제로 모델에 적용해 보는 실습은 향후에 진행합니다. 구글이 제공하는 사전 훈련된(미리 학습돼 있는) Word2Vec 모델을 사용하는 방법에 대해서 알아보겠습니다. 구글은 사전 훈련된 3백만 개의 Word2Vec 단어 벡터들을 제공합니다. 각 임베딩 벡터의 차원은 300입니다. gensim을 통해서 이 모델을 불러오는 건 매우 간단합니다. 이 모델을 다운로드하고 파일 경로를 기재하면 됩니다. 모델 다운로드 경로 : https://drive.google.com/file/d/0B7XkCwpI5KDYNlNUTTlSS21pQmM/edit 압축 파일의 용량은 약 1.5GB이지만, 파일의 압축을 풀면 약 3.3GB의 파일이 나옵니다. import gensim import urllib.request # 구글의 사전 훈련된 Word2Vec 모델을 로드. urllib.request.urlretrieve("https://s3.amazonaws.com/dl4j-distribution/GoogleNews-vectors-negative300.bin.gz", \ filename="GoogleNews-vectors-negative300.bin.gz") word2vec_model = gensim.models.KeyedVectors.load_word2vec_format('GoogleNews-vectors-negative300.bin.gz', binary=True) 모델의 크기(shape)를 확인해 봅시다. print(word2vec_model.vectors.shape) (3000000, 300) 모델의 크기는 3,000,000 x 300입니다. 즉, 3백만 개의 단어와 각 단어의 차원은 300입니다. 파일의 크기가 3기가가 넘는 이유를 계산해 보면 아래와 같습니다. 3 million words * 300 features * 4bytes/feature = ~3.35GB 사전 훈련된 임베딩을 사용하여 두 단어의 유사도를 계산해 봅시다. print(word2vec_model.similarity('this', 'is')) print(word2vec_model.similarity('post', 'book')) 0.407970363878 0.0572043891977 단어 'book'의 벡터를 출력해 봅시다. print(word2vec_model['book']) [ 0.11279297 -0.02612305 -0.04492188 0.06982422 0.140625 0.03039551 -0.04370117 0.24511719 0.08740234 -0.05053711 0.23144531 -0.07470703 ... 300개의 값이 출력되는 관계로 중략 ... 0.03637695 -0.16796875 -0.01483154 0.09667969 -0.05761719 -0.00515747] 참고 : Word2vec 모델은 자연어 처리에서 단어를 밀집 벡터로 만들어주는 단어 임베딩 방법론이지만 최근에 들어서는 자연어 처리를 넘어서 추천 시스템에도 사용되고 있는 모델입니다. 적당하게 데이터를 나열해 주면 Word2vec은 위치가 근접한 데이터를 유사도가 높은 벡터를 만들어준다는 점에서 착안된 아이디어입니다. 관심 있는 분들은 구글에 'item2vec'을 검색해 보세요. 12-05 임베딩 벡터의 시각화(Embedding Visualization) 구글은 임베딩 프로젝터(embedding projector)라는 데이터 시각화 도구를 지원합니다. 이번 챕터에서는 임베딩 프로젝터를 사용하여 학습한 임베딩 벡터들을 시각화해보겠습니다. 임베딩 프로젝터 논문 : https://arxiv.org/pdf/1611.05469v1.pdf 1. 워드 임베딩 모델로부터 2개의 tsv 파일 생성하기 이번 실습에서는 학습한 임베딩 벡터들을 시각화해보겠습니다. 꼭 Word2Vec 등으로 학습해야 하는 방법이 정해져있지는 없고, GloVe 등 다른 방법으로 훈련되어 있어도 상관없습니다. 시각화를 위해서는 이미 모델을 학습하고, 파일로 저장돼 있어야 합니다. 모델이 저장돼 있다면 아래 커맨드를 통해 시각화에 필요한 파일들을 생성할 수 있습니다. !python -m gensim.scripts.word2vec2tensor --input 모델 이름 --output 모델 이름 여기서는 편의를 위해 이전 챕터에서 학습하고 저장하는 실습까지 진행했던 영어 Word2Vec 모델인 'eng_w2v'를 재사용합니다. eng_w2v라는 Word2Vec 모델이 이미 존재한다는 가정 하에 주피터 노트북에서 아래 커맨드를 수행합니다. !python -m gensim.scripts.word2vec2tensor --input eng_w2v --output eng_w2v 커맨드를 수행하면 주피터 노트북이 시작되는 경로에 기존에 있던 eng_w2v 외에도 두 개의 파일이 생깁니다. 새로 생긴 eng_w2v_metadata.tsv와 eng_w2v_tensor.tsv 이 두 개 파일이 임베딩 벡터 시각화를 위해 사용할 파일입니다. 만약 eng_w2v 모델 파일이 아니라 다른 모델 파일 이름으로 실습을 진행하고 있다면, '모델 이름_ metadata.tsv'와 '모델 이름_ tensor.tsv'라는 파일이 생성된다고 이해하면 되겠습니다. 2. 임베딩 프로젝터를 사용하여 시각화하기 이제 구글의 임베딩 프로젝터를 사용해서 워드 임베딩 모델을 시각화해보겠습니다. 아래의 링크에 접속합니다. 링크 : https://projector.tensorflow.org/ 사이트에 접속해서 좌측 상단을 보면 Load라는 버튼이 있습니다. Load라는 버튼을 누르면 아래와 같은 창이 뜨는데 총 두 개의 Choose file 버튼이 있습니다. 위에 있는 Choose file 버튼을 누르고 eng_w2v_tensor.tsv 파일을 업로드하고, 아래에 있는 Choose file 버튼을 누르고 eng_w2v_metadata.tsv 파일을 업로드합니다. 두 파일을 업로드하면 임베딩 프로젝터에 학습했던 워드 임베딩 모델이 시각화됩니다. 그 후에는 임베딩 프로젝터의 다양한 기능을 사용할 수 있습니다. 예를 들어 임베딩 프로젝터는 복잡한 데이터를 차원을 축소하여 시각화할 수 있도록 도와주는 PCA, t-SNE 등을 제공합니다. 여기서는 자세한 기능에 대한 설명은 생략하겠습니다. 위의 그림은 'man'이라는 단어를 선택하고, 코사인 유사도를 기준으로 가장 유사한 상위 10개 벡터들을 표시해 봤습니다. 12-06 스탠퍼드 대학교의 글로브(GloVe) 글로브(Global Vectors for Word Representation, GloVe)는 카운트 기반과 예측 기반을 모두 사용하는 방법론으로 2014년에 미국 스탠퍼드 대학에서 개발한 단어 임베딩 방법론입니다. 앞서 학습하였던 기존의 카운트 기반의 LSA(Latent Semantic Analysis)와 예측 기반의 Word2Vec의 단점을 지적하며 이를 보완한다는 목적으로 나왔고, 실제로도 Word2Vec 만큼 뛰어난 성능을 보여줍니다. 현재까지의 연구에 따르면 단정적으로 Word2Vec와 GloVe 중에서 어떤 것이 더 뛰어나다고 말할 수는 없고, 이 두 가지 전부를 사용해 보고 성능이 더 좋은 것을 사용하는 것이 바람직합니다. 1. 기존 방법론에 대한 비판 LSA는 각 단어의 빈도수를 카운트 한 행렬이라는 전체적인 통계 정보를 입력으로 받아 차원을 축소(Truncated SVD) 하여 잠재된 의미를 끌어내는 방법론입니다. 반면, Word2Vec는 실제 값과 예측값에 대한 오차를 손실 함수를 통해 줄여나가며 학습하는 예측 기반의 방법론이었습니다. 서로 다른 방법을 사용하는 이 두 방법론은 각각 장, 단점이 있습니다. LSA는 카운트 기반으로 코퍼스의 전체적인 통계 정보를 고려하기는 하지만, 왕:남자 = 여왕:? (정답은 여자)와 같은 단어 의미의 유추 작업(Analogy task)에는 성능이 떨어집니다. Word2Vec는 예측 기반으로 단어 간 유추 작업에는 LSA보다 뛰어나지만, 임베딩 벡터가 윈도 크기 내에서만 주변 단어를 고려하기 때문에 코퍼스의 전체적인 통계 정보를 반영하지 못합니다. GloVe는 이러한 기존 방법론들의 각각의 한계를 지적하며, LSA의 메커니즘이었던 카운트 기반의 방법과 Word2Vec의 메커니즘이었던 예측 기반의 방법론 두 가지를 모두 사용합니다. 2. 윈도 기반 동시 등장 행렬(Window based Co-occurrence Matrix) 단어의 동시 등장 행렬은 행과 열을 전체 단어 집합의 단어들로 구성하고, i 단어의 윈도 크기(Window Size) 내에서 k 단어가 등장한 횟수를 i 행 k 열에 기재한 행렬을 말합니다. 예제를 보면 어렵지 않습니다. 아래와 같은 텍스트가 있다고 해봅시다. Ex) I like deep learning I like NLP I enjoy flying 윈도 크기가 N 일 때는 좌, 우에 존재하는 N 개의 단어만 참고하게 됩니다. 윈도 크기가 1일 때, 위의 텍스트를 가지고 구성한 동시 등장 행렬은 다음과 같습니다. 카운트 I like enjoy deep learning NLP flying I 0 2 1 0 0 0 0 like 2 0 0 1 0 1 0 enjoy 1 0 0 0 0 0 1 deep 0 1 0 0 1 0 0 learning 0 0 0 1 0 0 0 NLP 0 1 0 0 0 0 0 flying 0 0 1 0 0 0 0 위 행렬은 행렬을 전치(Transpose) 해도 동일한 행렬이 된다는 특징이 있습니다. 그 이유는 i 단어의 윈도 크기 내에서 k 단어가 등장한 빈도는 반대로 k 단어의 윈도 크기 내에서 i 단어가 등장한 빈도와 동일하기 때문입니다. 위의 테이블은 스탠퍼드 대학교의 자연어 처리 강의를 참고하였습니다. 링크 : http://web.stanford.edu/class/cs224n/slides/cs224n-2019-lecture02-wordvecs2.pdf 3. 동시 등장 확률(Co-occurrence Probability) 이제 동시 등장 행렬에 대해서 이해했으니, 동시 등장 확률에 대해서 이해해 봅시다. 아래의 표는 어떤 동시 등장 행렬을 가지고 정리한 동시 등장 확률(Co-occurrence Probability)을 보여줍니다. 그렇다면, 동시 등장 확률이란 무엇일까요? 동시 등장 확률 ( | i ) 는 동시 등장 행렬로부터 특정 단어 i의 전체 등장 횟수를 카운트하고, 특정 단어 i가 등장했을 때 어떤 단어 k가 등장한 횟수를 카운트하여 계산한 조건부 확률입니다. ( | i ) 에서 i를 중심 단어(Center Word), k를 주변 단어(Context Word)라고 했을 때, 위에서 배운 동시 등장 행렬에서 중심 단어 i의 행의 모든 값을 더한 값을 분모로 하고 i 행 k 열의 값을 분자로 한 값이라고 볼 수 있겠습니다. 다음은 GloVe의 제안 논문에서 가져온 동시 등장 확률을 표로 정리한 하나의 예입니다. 동시 등장 확률과 크기 관계 비(ratio) | k=solid | k=gas | k=water | k=fasion | ------|------|------|------| P(k l ice) | 0.00019 | 0.000066 | 0.003 | 0.000017 | P(k l steam) | 0.000022 | 0.00078 | 0.0022 | 0.000018 | P(k l ice) / P(k l steam) | 8.9 | 0.085 | 1.36 | 0.96 | 위의 표를 통해 알 수 있는 사실은 ice가 등장했을 때 solid가 등장할 확률 0.00019은 steam이 등장했을 때 solid가 등장할 확률인 0.000022보다 약 8.9배 크다는 겁니다. 그도 그럴 것이 solid는 '단단한'이라는 의미를 가졌으니까 '증기'라는 의미를 가지는 steam보다는 당연히 '얼음'이라는 의미를 가지는 ice라는 단어와 더 자주 등장할 겁니다. 수식적으로 다시 정리하여 언급하면 k가 solid 일 때, P(solid l ice) / P(solid l steam)를 계산한 값은 8.9가 나옵니다. 이 값은 1보다는 매우 큰 값입니다. 왜냐면 P(solid | ice)의 값은 크고, P(solid | steam)의 값은 작기 때문입니다. 그런데 k를 solid가 아니라 gas로 바꾸면 얘기는 완전히 달라집니다. gas는 ice보다는 steam과 더 자주 등장하므로, P(gas l ice) / P(gas l steam)를 계산한 값은 1보다 훨씬 작은 값인 0.085가 나옵니다. 반면, k가 water인 경우에는 solid와 steam 두 단어 모두와 동시 등장하는 경우가 많으므로 1에 가까운 값이 나오고, k가 fasion인 경우에는 solid와 steam 두 단어 모두와 동시 등장하는 경우가 적으므로 1에 가까운 값이 나옵니다. 보기 쉽도록 조금 단순화해서 표현한 표는 다음과 같습니다. 동시 등장 확률과 크기 관계 비(ratio) k=solid k=gas k=water k=fasion P(k l ice) 큰 값 작은 값 큰 값 작은 값 P(k l steam) 작은 값 큰 값 큰 값 작은 값 P(k l ice) / P(k l steam) 큰 값 작은 값 1에 가까움 1에 가까움 이제 동시 등장 행렬과 동시 등장 확률의 이해를 바탕으로 손실 함수를 설계해 보겠습니다. 4. 손실 함수(Loss function) 우선 손실 함수를 설명하기 전에 각 용어를 정리해 보겠습니다. : 동시 등장 행렬(Co-occurrence Matrix) i : 중심 단어 i가 등장했을 때 윈도 내 주변 단어 j가 등장하는 횟수 i ∑ X j : 동시 등장 행렬에서 i 행의 값을 모두 더한 값 i : ( | i ) X k i : 중심 단어 i가 등장했을 때 윈도 내 주변 단어 k가 등장할 확률 Ex) P(solid l ice) = 단어 ice가 등장했을 때 단어 solid가 등장할 확률 i P k P k P k 로 나눠준 값 Ex) P(solid l ice) / P(solid l steam) = 8.9 i : 중심 단어 i의 임베딩 벡터 k : 주변 단어 k의 임베딩 벡터 GloVe의 아이디어를 한 줄로 요약하면 '임베딩 된 중심 단어와 주변 단어 벡터의 내적이 전체 코퍼스에서의 동시 등장 확률이 되도록 만드는 것'입니다. 즉, 이를 만족하도록 임베딩 벡터를 만드는 것이 목표입니다. 이를 식으로 표현하면 다음과 같습니다. o p o u t ( i w ~ ) P ( | i ) P k 뒤에서 보게 되겠지만, 더 정확히는 GloVe는 아래와 같은 관계를 가지도록 임베딩 벡터를 설계합니다. o p o u t ( i w ~ ) l g P ( | i ) l g P k 임베딩 벡터들을 만들기 위한 손실 함수를 처음부터 차근차근 설계해 보겠습니다. 가장 중요한 것은 단어 간의 관계를 잘 표현하는 함수여야 한다는 겁니다. 이를 위해 앞서 배운 개념인 i / j를 식에 사용합니다. GloVe의 연구진들은 벡터 i w, k를 가지고 어떤 함수를 수행하면, i / j 가 나온다는 초기 식으로부터 전개를 시작합니다. ( i w , w ~ ) P k j 아직 이 함수 가 어떤 식을 가지고 있는지는 정해진 게 없습니다. 위의 목적에 맞게 근사할 수 있는 함수식은 무수히 많겠으나 최적의 식에 다가가기 위해서 차근, 차근 디테일을 추가해 보겠습니다. 함수는 두 단어 사이의 동시 등장 확률의 크기 관계 비(ratio) 정보를 벡터 공간에 인코딩하는 것이 목적입니다. 이를 위해 GloVe 연구진들은 i w라는 두 벡터의 차이를 함수의 입력으로 사용하는 것을 제안합니다. ( i w , w ~ ) P k j 그런데 우변은 스칼라 값이고 좌변은 벡터 값입니다. 이를 성립하기 해주기 위해서 함수의 두 입력에 내적(Dot product)을 수행합니다. ( ( i w) w ~ ) P k j 정리하면, 선형 공간(Linear space)에서 단어의 의미 관계를 표현하기 위해 뺄셈과 내적을 택했습니다. 여기서 함수 가 만족해야 할 필수 조건이 있습니다. 중심 단어 와 주변 단어 ~ 라는 선택 기준은 실제로는 무작위 선택이므로 이 둘의 관계는 자유롭게 교환될 수 있도록 해야 합니다. 이것이 성립되게 하기 위해서 GloVe 연구진은 함수 가 실수의 덥셈과 양수의 곱셈에 대해서 준동형(Homomorphism)을 만족하도록 합니다. 생소한 용어라서 말이 어려워 보이는데, 정리하면 와에 대해서 함수 가 ( + ) F ( ) ( ) 와 같도록 만족시켜야 한다는 의미입니다. 식으로 나타내면 아래와 같습니다. ( + ) F ( ) ( ) ∀, b R 이제 이 준동<NAME>을 현재 전개하던 GloVe 식에 적용할 수 있도록 조금씩 바꿔볼 겁니다. 전개하던 GloVe 식에 따르면, 함수는 결괏값으로 스칼라 값( i P k )이 나와야 합니다. 준동<NAME>에서 와 가 각각 벡터 값이라면 함수의 결괏값으로는 스칼라 값이 나올 수 없지만, 와 가 각각 사실 두 벡터의 내적 값이라고 하면 결괏값으로 스칼라 값이 나올 수 있습니다. 그러므로 위의 준동<NAME>을 아래와 같이 바꿔보겠습니다. 여기서 1 v , v , v는 각각 벡터 값입니다. 아래의 는 벡터를 의미합니다. ( 1 v + 3 v) F ( 1 v) ( 3 v) ∀ 1 v , v , v ∈ 그런데 앞서 작성한 GloVe 식에서는 i w라는 두 벡터의 차이를 함수의 입력으로 받았습니다. GloVe 식에 바로 적용을 위해 준동형 식을 이를 뺄셈에 대한 준동<NAME>으로 변경합니다. 그렇게 되면 곱셈도 나눗셈으로 바뀝니다. ( 1 v − 3 v) F ( 1 v) ( 3 v) ∀ 1 v , v , v ∈ 이제 이 준동형 식을 GloVe 식에 적용해 보겠습니다. 우선, 함수의 우변은 다음과 같이 바뀌어야 합니다. ( ( i w) w ~ ) F ( i w ~ ) ( j w ~ ) 그런데 이전의 식에 따르면 우변은 본래 i P k 였으므로, 결과적으로 다음과 같습니다. i P k F ( i w ~ ) ( j w ~ ) ( i w ~ ) P k X k i 좌변을 풀어쓰면 다음과 같습니다. ( i w ~ − w T k) F ( i w ~ ) ( j w ~ ) 이는 뺄셈에 대한 준동<NAME>의 형태와 정확히 일치합니다. 이제 이를 만족하는 함수를 찾아야 할 때입니다. 그리고 이를 정확하게 만족시키는 함수가 있는데 바로<NAME> 함수(Exponential function)입니다.를<NAME> 함수 x라고 해봅시다. x ( i w ~ − w T k) e p ( i w ~ ) x ( j w ~ ) x ( i w ~ ) P k X k i 위의 두 번째 식으로부터 다음과 같은 식을 얻을 수 있습니다. i w ~ l g P k l g ( i X) l g X k l g X 그런데 여기서 상기해야 할 것은 앞서 언급했듯이, 사실 i w ~ 는 두 값의 위치를 서로 바꾸어도 식이 성립해야 합니다. i의 정의를 생각해 보면 k 와도 같습니다. 그런데 이게 성립되려면 위의 식에서 o X 항이 걸림돌입니다. 이 부분만 없다면 이를 성립시킬 수 있습니다. 그래서 GloVe 연구팀은 이 o X 항을 i 에 대한 편향 i 라는 상수항으로 대체하기로 합니다. 같은 이유로 k에 대한 편향 k를 추가합니다. i w ~ b + k = o X k 이 식이 손실 함수의 핵심이 되는 식입니다. 우변의 값과의 차이를 최소화는 방향으로 좌변의 4개의 항은 학습을 통해 값이 바뀌는 변수들이 됩니다. 즉, 손실 함수는 다음과 같이 일반화될 수 있습니다. o s f n t o = m n 1 ( m w ~ b + n − o X n ) 여기서는 단어 집합의 크기를 의미합니다. 그런데 아직 최적의 손실 함수라기에는 부족합니다. GloVe 연구진은 o X k 에서 i 값이 0이 될 수 있음을 지적합니다. 대안 중 하나는 o X k 항을 o ( + i) 로 변경하는 것입니다. 하지만 이렇게 해도 여전히 해결되지 않는 문제가 있습니다. 바로 동시 등장 행렬 는 마치 DTM처럼 희소 행렬(Sparse Matrix) 일 가능성이 다분하다는 점입니다. 동시 등장 행렬에는 많은 값이 0이거나, 동시 등장 빈도가 적어서 많은 값이 작은 수치를 가지는 경우가 많습니다. 앞서 빈도수를 가지고 가중치를 주는 고민을 하는 TF-IDF나 LSA와 같은 몇 가지 방법들을 본 적이 있습니다. GloVe의 연구진은 동시 등장 행렬에서 동시 등장 빈도의 값 i 이 굉장히 낮은 경우에는 정보에 거의 도움이 되지 않는다고 판단합니다. 그래서 이에 대한 가중치를 주는 고민을 하게 되는데 GloVe 연구팀이 선택한 것은 바로 i의 값에 영향을 받는 가중치 함수(Weighting function) ( i) 를 손실 함수에 도입하는 것입니다. GloVe에 도입되는 ( i) 의 그래프를 보겠습니다. i의 값이 작으면 상대적으로 함수의 값은 작도록 하고, 값이 크면 함수의 값은 상대적으로 크도록 합니다. 하지만 i 가 지나치게 높다고 해서 지나친 가중치를 주지 않기 위해서 또한 함수의 최댓값이 정해져 있습니다. (최댓값은 1) 예를 들어 'It is'와 같은 불용어의 동시 등장 빈도수가 높다고 해서 지나친 가중을 받아서는 안 됩니다. 이 함수의 값을 손실 함수에 곱해주면 가중치의 역할을 할 수 있습니다. 이 함수 ( ) 의 식은 다음과 같이 정의됩니다. ( ) m n ( , ( / m x ) / ) 최종적으로 다음과 같은 일반화된 손실 함수를 얻어낼 수 있습니다. o s f n t o = m n 1 f ( m) ( m w ~ b + n − o X n 이제 GloVe 패키지를 설치 및 실습하고 훈련 결과를 확인해 보겠습니다. 5. GloVe 훈련시키기 실습을 위해 프롬프트에서 아래 커맨드로 GloVe 패키지를 설치합니다. pip install glove_python GloVe의 입력이 되는 훈련 데이터는 '영어와 한국어 Word2Vec 학습하기' 챕터에서 사용한 영어 데이터를 재사용합니다. 모든 동일한 전처리를 마치고 이전과 동일하게 result에 결과가 저장되어 있다고 가정합니다. from glove import Corpus, Glove corpus = Corpus() corpus.fit(result, window=5) # 훈련 데이터로부터 GloVe에서 사용할 동시 등장 행렬 생성 glove = Glove(no_components=100, learning_rate=0.05) glove.fit(corpus.matrix, epochs=20, no_threads=4, verbose=True) glove.add_dictionary(corpus.dictionary) # 학습에 이용할 스레드의 개수는 4로 설정, 에포크는 20. 이제 학습이 완료되었습니다. glove.most_similar()는 입력 단어의 가장 유사한 단어들의 리스트를 리턴합니다. model_result1=glove.most_similar("man") print(model_result1) [('woman', 0.9621753707315267), ('guy', 0.8860281455579162), ('girl', 0.8609057388487154), ('kid', 0.8383640509911114)] model_result2=glove.most_similar("boy") print(model_result2) [('girl', 0.9436601252235809), ('kid', 0.8400949618225224), ('woman', 0.8397250531245034), ('man', 0.8303093585541573)] model_result3=glove.most_similar("university") print(model_result3) [('harvard', 0.8690162017225468), ('cambridge', 0.8373272000675909), ('mit', 0.8288055170365777), ('stanford', 0.8212712738131419)] model_result4=glove.most_similar("water") print(model_result4) [('air', 0.838286550826724), ('clean', 0.8326093688298345), ('fresh', 0.8232884971285377), ('electricity', 0.8097066570385377)] model_result5=glove.most_similar("physics") print(model_result5) [('chemistry', 0.8379143027061764), ('biology', 0.827856517644139), ('economics', 0.775563255616767), ('finance', 0.7736692309034663)] model_result6=glove.most_similar("muscle") print(model_result6) [('skeletal', 0.7977490484723809), ('tissue', 0.7714119298512192), ('nerve', 0.7477850181231441), ('stem', 0.7222964725687838)] model_result7=glove.most_similar("clean") print(model_result7) [('water', 0.8264213732980569), ('fresh', 0.7850091074483321), ('wind', 0.7711854196846724), ('heat', 0.7646505765422197)] 사전 훈련된 GloVe를 사용하는 방법은 다음 챕터에서 다룹니다. 참고 자료 https://towardsdatascience.com/light-on-math-ml-intuitive-guide-to-understanding-glove-embeddings-b13b4f19c010 12-07 내부 단어를 고려하는 패스트 텍스트(FastText) 단어를 벡터로 만드는 또 다른 방법으로는 페이스북에서 개발한 FastText가 있습니다. Word2Vec 이후에 나온 것이기 때문에, 메커니즘 자체는 Word2Vec의 확장이라고 볼 수 있습니다. Word2Vec와 FastText와의 가장 큰 차이점이라면 Word2Vec는 단어를 쪼개질 수 없는 단위로 생각한다면, FastText는 하나의 단어 안에도 여러 단어들이 존재하는 것으로 간주합니다. 내부 단어. 즉, 서브 워드(subword)를 고려하여 학습합니다. 1. 내부 단어(subword)의 학습 FastText에서는 각 단어는 글자 단위 n-gram의 구성으로 취급합니다. n을 몇으로 결정하는지에 따라서 단어들이 얼마나 분리되는지 결정됩니다. 예를 들어서 n을 3으로 잡은 트라이 그램(tri-gram)의 경우, apple은 app, ppl, ple로 분리하고 이들을 벡터로 만듭니다. 더 정확히는 시작과 끝을 의미하는 <, >를 도입하여 아래의 5개 내부 단어(subword) 토큰을 벡터로 만듭니다. # n = 3인 경우 <ap, app, ppl, ple, le> 그리고 여기에 추가적으로 하나를 더 벡터화하는데, 기존 단어에 <, 와 >를 붙인 토큰입니다. # 특별 토큰 <apple> 다시 말해 n = 3인 경우, FastText는 단어 apple에 대해서 다음의 6개의 토큰을 벡터화하는 것입니다. # n = 3인 경우 <ap, app, ppl, ple, le>, <apple> 그런데 실제 사용할 때는 n의 최솟값과 최댓값으로 범위를 설정할 수 있는데, 기본값으로는 각각 3과 6으로 설정돼 있습니다. 다시 말해 최솟값 = 3, 최댓값 = 6인 경우라면, 단어 apple에 대해서 FastText는 아래 내부 단어들을 벡터화합니다. # n = 3 ~ 6인 경우 <ap, app, ppl, ppl, le>, <app, appl, pple, ple>, <appl, pple>, ..., <apple> 여기서 내부 단어들을 벡터화한다는 의미는 저 단어들에 대해서 Word2Vec을 수행한다는 의미입니다. 위와 같이 내부 단어들의 벡터 값을 얻었다면, 단어 apple의 벡터 값은 저 위 벡터 값들의 총합으로 구성합니다. apple = <ap + app + ppl + ppl + le> + <app + appl + pple + ple> + <appl + pple> + , ..., +<apple> 그리고 이런 방법은 Word2Vec에서는 얻을 수 없었던 강점을 가집니다. 2. 모르는 단어(Out Of Vocabulary, OOV)에 대한 대응 FastText의 인공 신경망을 학습한 후에는 데이터 셋의 모든 단어의 각 n-gram에 대해서 워드 임베딩이 됩니다. 이렇게 되면 장점은 데이터 셋만 충분한다면 위와 같은 내부 단어(Subword)를 통해 모르는 단어(Out Of Vocabulary, OOV)에 대해서도 다른 단어와의 유사도를 계산할 수 있다는 점입니다. 가령, FastText에서 birthplace(출생지)란 단어를 학습하지 않은 상태라고 해봅시다. 하지만 다른 단어에서 birth와 place라는 내부 단어가 있었다면, FastText는 birthplace의 벡터를 얻을 수 있습니다. 이는 모르는 단어에 제대로 대처할 수 없는 Word2Vec, GloVe와는 다른 점입니다. 3. 단어 집합 내 빈도 수가 적었던 단어(Rare Word)에 대한 대응 Word2Vec의 경우에는 등장 빈도 수가 적은 단어(rare word)에 대해서는 임베딩의 정확도가 높지 않다는 단점이 있었습니다. 참고할 수 있는 경우의 수가 적다 보니 정확하게 임베딩이 되지 않는 경우입니다. 하지만 FastText의 경우, 만약 단어가 희귀 단어라도, 그 단어의 n-gram이 다른 단어의 n-gram과 겹치는 경우라면, Word2Vec과 비교하여 비교적 높은 임베딩 벡터 값을 얻습니다. FastText가 노이즈가 많은 코퍼스에서 강점을 가진 것 또한 이와 같은 이유입니다. 모든 훈련 코퍼스에 오타(Typo)나 맞춤법이 틀린 단어가 없으면 이상적이겠지만, 실제 많은 비정형 데이터에는 오타가 섞여있습니다. 그리고 오타가 섞인 단어는 당연히 등장 빈도수가 매우 적으므로 일종의 희귀 단어가 됩니다. 즉, Word2Vec에서는 오타가 섞인 단어는 임베딩이 제대로 되지 않지만 FastText는 이에 대해서도 일정 수준의 성능을 보입니다. 예를 들어 단어 apple과 오타로 p를 한 번 더 입력한 appple의 경우에는 실제로 많은 개수의 동일한 n-gram을 가질 것입니다. 4. 실습으로 비교하는 Word2Vec Vs. FastText 간단한 실습을 통해 Word2Vec와 FastText의 차이를 비교해 보도록 하겠습니다. 단, 사용하는 코드는 Word2Vec를 실습하기 위해 사용했던 이전 챕터의 동일한 코드를 사용합니다. 1) Word2Vec 우선, 이전 Word2Vec의 실습( https://wikidocs.net/50739 )의 전처리 코드와 Word2Vec 학습 코드를 그대로 수행했음을 가정하겠습니다. 입력 단어에 대해서 유사한 단어를 찾아내는 코드에 이번에는 electrofishing이라는 단어를 넣어보겠습니다. model.wv.most_similar("electrofishing") 해당 코드는 정상 작동하지 않고 에러를 발생시킵니다. KeyError: "word 'electrofishing' not in vocabulary" 에러 메시지는 단어 집합(Vocabulary)에 electrofishing이 존재하지 않는다고 합니다. 이처럼 Word2Vec는 학습 데이터에 존재하지 않는 단어. 즉, 모르는 단어에 대해서는 임베딩 벡터가 존재하지 않기 때문에 단어의 유사도를 계산할 수 없습니다. 2) FastText 이번에는 전처리 코드는 그대로 사용하고 Word2Vec 학습 코드만 FastText 학습 코드로 변경하여 실행해 봅시다. from gensim.models import FastText model = FastText(result, size=100, window=5, min_count=5, workers=4, sg=1) electrofishing에 대해서 유사 단어를 찾아보도록 하겠습니다. model.wv.most_similar("electrofishing") [('electrolux', 0.7934642434120178), ('electrolyte', 0.78279709815979), ('electro', 0.779127836227417), ('electric', 0.7753111720085144), ('airbus', 0.7648627758026123), ('fukushima', 0.7612422704696655), ('electrochemical', 0.7611693143844604), ('gastric', 0.7483425140380859), ('electroshock', 0.7477173805236816), ('overfishing', 0.7435552477836609)] Word2Vec는 학습하지 않은 단어에 대해서 유사한 단어를 찾아내지 못했지만, FastText는 유사한 단어를 계산해서 출력하고 있음을 볼 수 있습니다. 5. 한국어에서의 FastText 한국어의 경우에도 OOV 문제를 해결하기 위해 FastText를 적용하고자 하는 시도들이 있었습니다. (1) 음절 단위 예를 들어서 음절 단위의 임베딩의 경우에 n=3일 때 ‘자연어 처리’라는 단어에 대해 n-gram을 만들어보면 다음과 같습니다. <자연, 자연어, 연어처, 어처리, 처리> (2) 자모 단위 이제 더 나아가 자모 단위(초성, 중성, 종성 단위)로 임베딩하는 시도 또한 있었습니다. 음절 단위가 아니라, 자모 단위로 가게 되면 오타나 노이즈 측면에서 더 강한 임베딩을 기대해 볼 수 있습니다. 예를 들어 ‘자연어 처리’라는 단어에 대해서 초성, 중성, 종성을 분리하고, 만약, 종성이 존재하지 않는다면 ‘_’라는 토큰을 사용한다고 가정한다면 ‘자연어 처리’라는 단어는 아래와 같이 분리가 가능합니다. 분리된 결과 : ㅈ ㅏ _ ㅇ ㅕ ㄴ ㅇ ㅓ _ ㅊ ㅓ _ ㄹ ㅣ _ 그리고 분리된 결과에 대해서 n=3일 때, n-gram을 적용하여, 임베딩을 한다면 다음과 같습니다. < ㅈ ㅏ, ㅈ ㅏ _, ㅏ _ ㅇ, ... 중략> 이어서 자모 단위 FastText를 실습해해봅시다. 12-08 자모 단위 한국어 FastText 학습하기 죄송합니다. 해당 자료는 위키독스 웹 사이트에서는 비공개 처리되어 구현 코드와 코드에 대한 상세한 설명은 유료 E-book을 구매하시면 확인할 수 있습니다. 12-09 파이 토치(PyTorch)의 nn.Embedding() 파이 토치에서는 임베딩 벡터를 사용하는 방법이 크게 두 가지가 있습니다. 바로 임베딩 층(embedding layer)을 만들어 훈련 데이터로부터 처음부터 임베딩 벡터를 학습하는 방법과 미리 사전에 훈련된 임베딩 벡터(pre-trained word embedding)들을 가져와 사용하는 방법입니다. 이번 챕터에서는 전자에 해당되는 방법에 대해서 배웁니다. 파이 토치에서는 이를 nn.Embedding()를 사용하여 구현합니다. 이와 대조되는 방법인 사전에 훈련된 임베딩 벡터(pre-trained word embedding)를 사용하는 방법은 다음 챕터에서 다룹니다. 1. 임베딩 층은 룩업 테이블이다. 임베딩 층의 입력으로 사용하기 위해서 입력 시퀀스의 각 단어들은 모두 정수 인코딩이 되어있어야 합니다. 어떤 단어 → 단어에 부여된 고유한 정숫값 → 임베딩 층 통과 → 밀집 벡터 임베딩 층은 입력 정수에 대해 밀집 벡터(dense vector)로 매핑하고 이 밀집 벡터는 인공 신경망의 학습 과정에서 가중치가 학습되는 것과 같은 방식으로 훈련됩니다. 훈련 과정에서 단어는 모델이 풀고자 하는 작업에 맞는 값으로 업데이트됩니다. 그리고 이 밀집 벡터를 임베딩 벡터라고 부릅니다. 정수를 밀집 벡터 또는 임베딩 벡터로 매핑한다는 것은 어떤 의미일까요? 특정 단어와 매핑되는 정수를 인덱스로 가지는 테이블로부터 임베딩 벡터 값을 가져오는 룩업 테이블이라고 볼 수 있습니다. 그리고 이 테이블은 단어 집합의 크기만큼의 행을 가지므로 모든 단어는 고유한 임베딩 벡터를 가집니다. 위의 그림은 단어 great이 정수 인코딩 된 후 테이블로부터 해당 인덱스에 위치한 임베딩 벡터를 꺼내오는 모습을 보여줍니다. 위의 그림에서는 임베딩 벡터의 차원이 4로 설정돼 있습니다. 그리고 단어 great은 정수 인코딩 과정에서 1,918의 정수로 인코딩이 되었고 그에 따라 단어 집합의 크기만큼의 행을 가지는 테이블에서 인덱스 1,918번에 위치한 행을 단어 great의 임베딩 벡터로 사용합니다. 이 임베딩 벡터는 모델의 입력이 되고, 역전파 과정에서 단어 great의 임베딩 벡터 값이 학습됩니다. 룩업 테이블의 개념을 이론적으로 우선 접하고, 처음 파이 토치를 배울 때 어떤 분들은 임베딩 층의 입력이 원-핫 벡터가 아니어도 동작한다는 점에 헷갈려 합니다. 파이 토치는 단어를 정수 인덱스로 바꾸고 원-핫 벡터로 한 번 더 바꾸고 나서 임베딩 층의 입력으로 사용하는 것이 아니라, 단어를 정수 인덱스로만 바꾼 채로 임베딩 층의 입력으로 사용해도 룩업 테이블 된 결과인 임베딩 벡터를 리턴합니다. 룩업 테이블 과정을 nn.Embedding()을 사용하지 않고 구현해 보면서 이해해 보겠습니다. 우선 임의의 문장으로부터 단어 집합을 만들고 각 단어에 정수를 부여합니다. train_data = 'you need to know how to code' # 중복을 제거한 단어들의 집합인 단어 집합 생성. word_set = set(train_data.split()) # 단어 집합의 각 단어에 고유한 정수 매핑. vocab = {word: i+2 for i, word in enumerate(word_set)} vocab['<unk>'] = 0 vocab['<pad>'] = 1 print(vocab) {'code': 2, 'you': 3, 'know': 4, 'to': 5, 'need': 6, 'how': 7, '<unk>': 0, '<pad>': 1} 이제 단어 집합의 크기를 행으로 가지는 임베딩 테이블을 구현합니다. 단, 여기서 임베딩 벡터의 차원은 3으로 정했습니다. # 단어 집합의 크기만큼의 행을 가지는 테이블 생성. embedding_table = torch.FloatTensor([ [ 0.0, 0.0, 0.0], [ 0.0, 0.0, 0.0], [ 0.2, 0.9, 0.3], [ 0.1, 0.5, 0.7], [ 0.2, 0.1, 0.8], [ 0.4, 0.1, 0.1], [ 0.1, 0.8, 0.9], [ 0.6, 0.1, 0.1]]) 이제 임의의 문장 'you need to run'에 대해서 룩업 테이블을 통해 임베딩 벡터들을 가져와보겠습니다. sample = 'you need to run'.split() idxes = [] # 각 단어를 정수로 변환 for word in sample: try: idxes.append(vocab[word]) # 단어 집합에 없는 단어일 경우 <unk>로 대체된다. except KeyError: idxes.append(vocab['<unk>']) idxes = torch.LongTensor(idxes) # 각 정수를 인덱스로 임베딩 테이블에서 값을 가져온다. lookup_result = embedding_table[idxes, :] print(lookup_result) tensor([[0.1000, 0.5000, 0.7000], [0.1000, 0.8000, 0.9000], [0.4000, 0.1000, 0.1000], [0.0000, 0.0000, 0.0000]]) 2. 임베딩 층 사용하기 이제 nn.Embedding()으로 사용할 경우를 봅시다. 우선 전처리는 동일한 과정을 거칩니다. train_data = 'you need to know how to code' # 중복을 제거한 단어들의 집합인 단어 집합 생성. word_set = set(train_data.split()) # 단어 집합의 각 단어에 고유한 정수 매핑. vocab = {tkn: i+2 for i, tkn in enumerate(word_set)} vocab['<unk>'] = 0 vocab['<pad>'] = 1 이제 nn.Embedding()을 사용하여 학습 가능한 임베딩 테이블을 만듭니다. import torch.nn as nn embedding_layer = nn.Embedding(num_embeddings=len(vocab), embedding_dim=3, padding_idx=1) nn.Embedding은 크게 두 가지 인자를 받는데 각각 num_embeddings과 embedding_dim입니다. num_embeddings : 임베딩을 할 단어들의 개수. 다시 말해 단어 집합의 크기입니다. embedding_dim : 임베딩 할 벡터의 차원입니다. 사용자가 정해주는 하이퍼 파라미터입니다. padding_idx : 선택적으로 사용하는 인자입니다. 패딩을 위한 토큰의 인덱스를 알려줍니다. print(embedding_layer.weight) Parameter containing: tensor([[-0.1778, -1.9974, -1.2478], [ 0.0000, 0.0000, 0.0000], [ 1.0921, 0.0416, -0.7896], [ 0.0960, -0.6029, 0.3721], [ 0.2780, -0.4300, -1.9770], [ 0.0727, 0.5782, -3.2617], [-0.0173, -0.7092, 0.9121], [-0.4817, -1.1222, 2.2774]], requires_grad=True) 앞선 예제와 마찬가지로 단어 집합의 크기의 행을 가지는 임베딩 테이블이 생성되었습니다. 12-10 사전 훈련된 워드 임베딩(Pre-trained Word Embedding) 임베딩 벡터를 얻기 위해서 파이 토치의 nn.Embedding()을 사용하기도 하지만, 때로는 이미 훈련돼 있는 워드 임베딩을 불러서 이를 임베딩 벡터로 사용하기도 합니다. 훈련 데이터가 부족한 상황이라면 모델에 파이 토치의 nn.Embedding()을 사용하는 것보다 다른 텍스트 데이터로 사전 훈련되어 있는 임베딩 벡터를 불러오는 것이 나은 선택일 수 있습니다. 훈련 데이터가 적다면 파이 토치의 nn.Embedding()으로 해당 문제에 충분히 특화된 임베딩 벡터를 만들어내는 것이 쉽지 않습니다. 이 경우, 해당 문제에 특화된 것은 아니지만 보다 일반적이고 보다 많은 훈련 데이터로 이미 Word2Vec이나 GloVe 등으로 학습돼 있는 임베딩 벡터들을 사용하는 것이 성능의 개선을 가져올 수 있습니다. !pip install gensim 1. 사전 훈련된 임베딩을 사용하지 않는 경우 import numpy as np from collections import Counter import gensim 문장의 긍, 부정을 판단하는 감성 분류 모델을 만들어봅시다. 문장과 레이블 데이터를 만들었습니다. 긍정인 문장은 레이블 1, 부정인 문장은 레이블이 0입니다. sentences = ['nice great best amazing', 'stop lies', 'pitiful nerd', 'excellent work', 'supreme quality', 'bad', 'highly respectable'] y_train = [1, 0, 0, 1, 1, 0, 1] 각 샘플에 대해서 단어 토큰화를 수행합니다. tokenized_sentences = [sent.split() for sent in sentences] print('단어 토큰화된 결과 :', tokenized_sentences) 단어 토큰화된 결과 : [['nice', 'great', 'best', 'amazing'], ['stop', 'lies'], ['pitiful', 'nerd'], ['excellent', 'work'], ['supreme', 'quality'], ['bad'], ['highly', 'respectable']] 토큰화된 결과를 바탕으로 단어 집합을 만들어봅시다. 우선 Counter() 모듈을 이용하여 각 단어의 등장 빈도수를 기록합니다. word_list = [] for sent in tokenized_sentences: for word in sent: word_list.append(word) word_counts = Counter(word_list) print('총 단어 수 :', len(word_counts)) 총 단어 수 : 15 현재 존재하는 총 단어의 수는 15개입니다. 이 단어들을 등장 빈도가 높은 순서부터 정렬합니다. # 등장 빈도순으로 정렬 vocab = sorted(word_counts, key=word_counts.get, reverse=True) print(vocab) ['nice', 'great', 'best', 'amazing', 'stop', 'lies', 'pitiful', 'nerd', 'excellent', 'work', 'supreme', 'quality', 'bad', 'highly', 'respectable'] nice가 등장 빈도수로 가장 높은 단어이고, 그다음은 great, 그다음은 best로 등장 빈도가 높은 순서대로 단어가 정렬된 상태입니다. 이제 이로부터 단어 집합을 완성해 봅시다. 0번은 패딩 토큰을 위한 용도로 사용하고, 1번은 단어 집합에 없는 단어가 등장하는 OOV(Out-Of-Vocabulary) 문제가 발생하면 사용하는 용도로 각각 할당합니다. word_to_index = {} word_to_index['<PAD>'] = 0 word_to_index['<UNK>'] = 1 for index, word in enumerate(vocab) : word_to_index[word] = index + 2 vocab_size = len(word_to_index) print('패딩 토큰, UNK 토큰을 고려한 단어 집합의 크기 :', vocab_size) 패딩 토큰, UNK 토큰을 고려한 단어 집합의 크기 : 17 단어 집합의 크기는 17입니다. 출력 결과는 다음과 같습니다. print(word_to_index) {'<PAD>': 0, '<UNK>': 1, 'nice': 2, 'great': 3, 'best': 4, 'amazing': 5, 'stop': 6, 'lies': 7, 'pitiful': 8, 'nerd': 9, 'excellent': 10, 'work': 11, 'supreme': 12, 'quality': 13, 'bad': 14, 'highly': 15, 'respectable': 16} 단어 집합을 이용하여 정수 인코딩을 진행합니다. 단어 집합에 없는 단어가 등장할 경우에는 정수 1이 할당되지만 이번 실습에서는 학습 데이터에 단어 집합에 없는 단어가 존재하지 않으므로 해당되지 않습니다. def texts_to_sequences(tokenized_X_data, word_to_index): encoded_X_data = [] for sent in tokenized_X_data: index_sequences = [] for word in sent: try: index_sequences.append(word_to_index[word]) except KeyError: index_sequences.append(word_to_index['<UNK>']) encoded_X_data.append(index_sequences) return encoded_X_data X_encoded = texts_to_sequences(tokenized_sentences, word_to_index) print(X_encoded) [[2, 3, 4, 5], [6, 7], [8, 9], [10, 11], [12, 13], [14], [15, 16]] 현재 데이터의 최대 길이를 측정하고, 해당 길이로 패딩을 진행합니다. max_len = max(len(l) for l in X_encoded) print('최대 길이 :',max_len) 최대 길이 : 4 def pad_sequences(sentences, max_len): features = np.zeros((len(sentences), max_len), dtype=int) for index, sentence in enumerate(sentences): if len(sentence) != 0: features[index, :len(sentence)] = np.array(sentence)[:max_len] return features X_train = pad_sequences(X_encoded, max_len=max_len) y_train = np.array(y_train) print('패딩 결과 :') print(X_train) 패딩 결과 : [[ 2 3 4 5] [ 6 7 0 0] [ 8 9 0 0] [10 11 0 0] [12 13 0 0] [14 0 0 0] [15 16 0 0]] 모든 데이터의 길이가 4로 변환된 것을 확인하였습니다. 이제 nn.Embedding()를 이용하여 모델을 설계합니다. import torch import torch.nn as nn from torch.optim import Adam from torch.utils.data import DataLoader, TensorDataset class SimpleModel(nn.Module): def __init__(self, vocab_size, embedding_dim): super(SimpleModel, self).__init__() self.embedding = nn.Embedding(vocab_size, embedding_dim) self.flatten = nn.Flatten() self.fc = nn.Linear(embedding_dim * max_len, 1) self.sigmoid = nn.Sigmoid() def forward(self, x): # embedded.shape == (배치 크기, 문장의 길이, 임베딩 벡터의 차원) embedded = self.embedding(x) # flattend.shape == (배치 크기, 문장의 길이 × 임베딩 벡터의 차원) flattened = self.flatten(embedded) # output.shape == (배치 크기, 1) output = self.fc(flattened) return self.sigmoid(output) 모델 객체를 선언합니다. 임베딩 벡터의 크기는 100으로 정했습니다. device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') embedding_dim = 100 simple_model = SimpleModel(vocab_size, embedding_dim).to(device) 출력층에 로지스틱 회귀를 이용한 이진 분류 문제를 푸는 모델이므로 손실 함수로는 바이너리 크로스 엔트로피 함수에 해당하는 nn.BCELoss()를 사용합니다. criterion = nn.BCELoss() optimizer = Adam(simple_model.parameters()) 데이터를 배치 크기 2로 설정한 데이터 로더로 변환합니다. train_dataset = TensorDataset(torch.tensor(X_train, dtype=torch.long), torch.tensor(y_train, dtype=torch.float32)) train_dataloader = DataLoader(train_dataset, batch_size=2) 데이터가 7개였으므로 배치 크기 2로 묶으면 총 묶음은 4개(2개, 2개, 2개, 1개)가 됩니다. print(len(train_dataloader)) 총 10번 학습합니다. for epoch in range(10): for inputs, targets in train_dataloader: # inputs.shape == (배치 크기, 문장 길이) # targets.shape == (배치 크기) inputs, targets = inputs.to(device), targets.to(device) optimizer.zero_grad() # outputs.shape == (배치 크기) outputs = simple_model(inputs).view(-1) loss = criterion(outputs, targets) loss.backward() optimizer.step() print(f"Epoch {epoch+1}, Loss: {loss.item()}") Epoch 1, Loss: 0.46478426456451416 Epoch 2, Loss: 0.4502693712711334 Epoch 3, Loss: 0.40378859639167786 Epoch 4, Loss: 0.3481767177581787 Epoch 5, Loss: 0.2946138083934784 Epoch 6, Loss: 0.24818778038024902 Epoch 7, Loss: 0.21027232706546783 Epoch 8, Loss: 0.18025405704975128 Epoch 9, Loss: 0.15673018991947174 Epoch 10, Loss: 0.13819283246994019 2. 사전 훈련된 임베딩을 사용하는 경우 구글에서 사전 학습시킨 Word2Vec 모델을 사용하여 문제를 풀어봅시다. 우선 구글에서 사전 학습시킨 Word2Vec 모델을 다운로드합니다. !wget --load-cookies /tmp/cookies.txt "https://docs.google.com/uc? export=download&confirm=$(wget --quiet --save-cookies /tmp/cookies.txt --keep-session-cookies --no-check-certificate 'https://docs.google.com/uc?export=download&id=1Av37IVBQAAntSe1X3MOAl5gvowQzd2_j' -O- | sed -rn 's/.*confirm=([0-9A-Za-z_]+).*/\1\n/p')&id=1Av37IVBQAAntSe1X3MOAl5gvowQzd2_j" -O GoogleNews-vectors-negative300.bin.gz && rm -rf /tmp/cookies.txt 머신 러닝 라이브러리 gensim을 이용하여 해당 모델을 다운로드합니다. # 구글의 사전 훈련된 Word2vec 모델을 로드합니다. word2vec_model = gensim.models.KeyedVectors.load_word2vec_format('GoogleNews-vectors-negative300.bin.gz', binary=True) 위 모델은 각 벡터가 300차원으로 구성돼 있습니다. 풀고자 하는 문제의 단어 집합 크기의 행과 300개의 열을 가지는 행렬 생성합니다. 이 행렬의 값은 전부 0으로 채웁니다. 이 행렬에 사전 훈련된 임베딩 값을 넣어줄 것입니다. embedding_matrix = np.zeros((vocab_size, 300)) print('임베딩 행렬의 크기 :', embedding_matrix.shape) 임베딩 행렬의 크기 : (17, 300) word2vec_model에서 특정 단어를 입력하면 해당 단어의 임베딩 벡터를 리턴 받을 텐데, 만약 word2vec_model에 특정 단어의 임베딩 벡터가 없다면 None을 리턴하도록 하는 함수 get_vector()를 구현합니다. def get_vector(word): if word in word2vec_model: return word2vec_model[word] else: return None 단어 집합으로부터 단어를 1개씩 호출하여 word2vec_model에 해당 단어의 임베딩 벡터 값이 존재하는지 확인합니다. 만약 None이 아니라면 존재한다는 의미이므로 임베딩 행렬에 해당 단어의 인덱스 위치의 행에 임베딩 벡터의 값을 저장합니다. # <PAD>를 위한 0번과 <UNK>를 위한 1번은 실제 단어가 아니므로 매핑에서 제외 for word, i in word_to_index.items(): if i > 2: temp = get_vector(word) if temp is not None: embedding_matrix[i] = temp 현재 풀고자 하는 문제의 17개의 단어와 매핑되는 임베딩 행렬이 완성됩니다. 0번 단어는 패딩을 위한 용도이므로 사전 훈련된 임베딩 벡터 값이 불필요합니다. 이에 따라 초깃값인 0벡터로 초기화가 되어 있습니다. embedding_matrix의 0번 위치의 벡터를 출력해 봅시다. # <PAD>나 <UNK>의 경우는 사전 훈련된 임베딩이 들어가지 않아서 0벡터임 print(embedding_matrix[0]) [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] 0이 300개 채워진 벡터임을 확인하였습니다. 이제 다른 단어들도 제대로 매핑이 됐는지 확인해 볼까요? 기존의 단어 집합에서 단어 'great'가 정수로 몇 번인지 확인합니다. word_to_index['great'] 3번 임을 확인했습니다. 이에 따라서 사전 훈련된 word2vec_model에서의 'great' 벡터와 현재 사전 훈련된 임베딩 벡터가 매핑된 embedding_matrix의 3번 벡터가 동일한지 확인합니다. # word2vec_model에서 'great'의 임베딩 벡터 # embedding_matrix[3]이 일치하는지 체크 np.all(word2vec_model['great'] == embedding_matrix[3]) True 동일한 것을 확인하였습니다. 이는 현재 3번 위치에 단어 'great' 벡터가 정상적으로 할당되었음을 의미합니다. 이제 사전 훈련된 임베딩을 이용한 모델을 구현합니다. class PretrainedEmbeddingModel(nn.Module): def __init__(self, vocab_size, embedding_dim): super(PretrainedEmbeddingModel, self).__init__() self.embedding = nn.Embedding(vocab_size, embedding_dim) self.embedding.weight = nn.Parameter(torch.tensor(embedding_matrix, dtype=torch.float32)) self.embedding.weight.requires_grad = True self.flatten = nn.Flatten() self.fc = nn.Linear(embedding_dim * max_len, 1) self.sigmoid = nn.Sigmoid() def forward(self, x): embedded = self.embedding(x) flattened = self.flatten(embedded) output = self.fc(flattened) return self.sigmoid(output) 모델 객체를 선언합니다. 이때 임베딩 벡터의 크기는 embedding_matrix에서 이미 정해진 임베딩 벡터의 차원인 300으로 해야만 합니다. pretraiend_embedding_model = PretrainedEmbeddingModel(vocab_size, 300).to(device) 출력층에 로지스틱 회귀를 이용한 이진 분류 문제를 푸는 모델이므로 손실 함수로는 바이너리 크로스 엔트로피 함수에 해당하는 nn.BCELoss()를 사용합니다. criterion = nn.BCELoss() optimizer = Adam(pretraiend_embedding_model.parameters()) 데이터를 배치 크기 2로 설정한 데이터 로더로 변환합니다. train_dataset = TensorDataset(torch.tensor(X_train, dtype=torch.long), torch.tensor(y_train, dtype=torch.float32)) train_dataloader = DataLoader(train_dataset, batch_size=2) 데이터가 7개였으므로 배치 크기 2로 묶으면 총 묶음은 4개(2개, 2개, 2개, 1개)가 됩니다. print(len(train_dataloader)) 총 10번 학습합니다. for epoch in range(10): for inputs, targets in train_dataloader: # inputs.shape == (배치 크기, 문장 길이) # targets.shape == (배치 크기) inputs, targets = inputs.to(device), targets.to(device) optimizer.zero_grad() # outputs.shape == (배치 크기) outputs = pretraiend_embedding_model(inputs).view(-1) loss = criterion(outputs, targets) loss.backward() optimizer.step() print(f"Epoch {epoch+1}, Loss: {loss.item()}") Epoch 1, Loss: 0.6623443365097046 Epoch 2, Loss: 0.6018906235694885 Epoch 3, Loss: 0.5419147610664368 Epoch 4, Loss: 0.4856065809726715 Epoch 5, Loss: 0.43379512429237366 Epoch 6, Loss: 0.38664519786834717 Epoch 7, Loss: 0.3440646231174469 Epoch 8, Loss: 0.3058430850505829 Epoch 9, Loss: 0.2717098295688629 Epoch 10, Loss: 0.24136123061180115 사전 훈련된 임베딩을 이용하여 기존 모델 대비 더 높은 성능을 얻는 예시는 '13-03 사전 훈련된 임베딩을 이용한 성능 상승시키기(https://wikidocs.net/217099)' 실습을 참고하시기 바랍니다. 12-11 엘모(Embeddings from Language Model, ELMo) 논문 링크 : https://aclweb.org/anthology/N18-1202 ELMo(Embeddings from Language Model)는 2018년에 제안된 새로운 워드 임베딩 방법론입니다. ELMo라는 이름은 세서미 스트리트라는 미국 인형극의 캐릭터 이름이기도 한데, 뒤에서 배우게 되는 BERT나 최근 마이크로소프트가 사용한 Big Bird라는 NLP 모델 또한 ELMo에 이어 세서미 스트리트의 캐릭터의 이름을 사용했습니다. ELMo는 Embeddings from Language Model의 약자입니다. 해석하면 '언어 모델로 하는 임베딩'입니다. ELMo의 가장 큰 특징은 사전 훈련된 언어 모델(Pre-trained language model)을 사용한다는 점입니다. 이는 ELMo의 이름에 LM이 들어간 이유입니다. 1. ELMo(Embeddings from Language Model) Bank라는 단어를 생각해 봅시다. Bank Account(은행 계좌)와 River Bank(강둑)에서의 Bank는 전혀 다른 의미를 가지는데, Word2Vec이나 GloVe 등으로 표현된 임베딩 벡터들은 이를 제대로 반영하지 못한다는 단점이 있습니다. 예를 들어서 Word2Vec이나 GloVe 등의 임베딩 방법론으로 Bank란 단어를 [0.2 0.8 -1.2]라는 임베딩 벡터로 임베딩하였다고 하면, 이 단어는 Bank Account(은행 계좌)와 River Bank(강둑)에서의 Bank는 전혀 다른 의미임에도 불구하고 두 가지 상황 모두에서 [0.2 0.8 -1.2]의 벡터가 사용됩니다. 같은 표기의 단어라도 문맥에 따라서 다르게 워드 임베딩을 할 수 있으면 자연어 처리의 성능을 올릴 수 있을 것입니다. 워드 임베딩 시 문맥을 고려해서 임베딩을 하겠다는 아이디어가 문맥을 반영한 워드 임베딩(Contextualized Word Embedding)입니다. 2. biLM(Bidirectional Language Model)의 사전 훈련 다음 단어를 예측하는 작업인 언어 모델링을 상기해 봅시다. 아래의 그림은 은닉층이 2개인 일반적인 단방향 RNN 언어 모델의 언어 모델링을 보여줍니다. RNN 언어 모델은 문장으로부터 단어 단위로 입력을 받는데, RNN 내부의 은닉 상태 t 는 시점(time step)이 지날수록 점점 업데이트돼갑니다. 이는 결과적으로 RNN의 t 의 값이 문장의 문맥 정보를 점차적으로 반영한다고 말할 수 있습니다. 그런데 ELMo는 위의 그림의 순방향 RNN뿐만 아니라, 위의 그림과는 반대 방향으로 문장을 스캔하는 역방향 RNN 또한 활용합니다. ELMo는 양쪽 방향의 언어 모델을 둘 다 학습하여 활용한다고 하여 이 언어 모델을 biLM(Bidirectional Language Model)이라고 합니다. ELMo에서 말하는 biLM은 기본적으로 다층 구조(Multi-layer)를 전제로 합니다. 은닉층이 최소 2개 이상이라는 의미입니다. 아래의 그림은 은닉층이 2개인 순방향 언어 모델과 역방향 언어 모델의 모습을 보여줍니다. 이때 biLM의 각 시점의 입력이 되는 단어 벡터는 이번 챕터에서 설명한 임베딩 층(embedding layer)을 사용해서 얻은 것이 아니라 합성곱 신경망을 이용한 문자 임베딩(character embedding)을 통해 얻은 단어 벡터입니다. 문자 임베딩에 대한 설명은 'NLP를 위한 합성곱 신경망' 챕터에서 다루는 내용으로 여기서는 임베딩층, Word2Vec 등 외에 단어 벡터를 얻는 또 다른 방식도 있다고만 알아둡시다. 문자 임베딩은 마치 서브 단어(subword)의 정보를 참고하는 것처럼 문맥과 상관없이 dog란 단어와 doggy란 단어의 연관성을 찾아낼 수 있습니다. 또한 이 방법은 OOV에도 견고한다는 장점이 있습니다. 주의할 점은 앞서 설명한 양방향 RNN과 ELMo에서의 biLM은 다릅니다. 양방향 RNN은 순방향 RNN의 은닉 상태와 역방향의 RNN의 은닉 상태를 연결(concatenate) 하여 다음층의 입력으로 사용합니다. 반면, biLM의 순방향 언어 모델과 역방향 언어 모델이라는 두 개의 언어 모델을 별개의 모델로 보고 학습합니다. 3. biLM의 활용 biLM이 언어 모델링을 통해 학습된 후 ELMo가 사전 훈련된 biLM을 통해 입력 문장으로부터 단어를 임베딩하기 위한 과정을 보겠습니다. 이 예제에서는 play란 단어가 임베딩이 되고 있다는 가정 하에 ELMo를 설명합니다. play라는 단어를 임베딩 하기 위해서 ELMo는 위의 점선의 사각형 내부의 각 층의 결괏값을 재료로 사용합니다. 다시 말해 해당 시점(time step)의 BiLM의 각 층의 출력값을 가져옵니다. 그리고 순방향 언어 모델과 역방향 언어 모델의 각 층의 출력값을 연결(concatenate) 하고 추가 작업을 진행합니다. 여기서 각 층의 출력값이란 첫 번째는 임베딩 층을 말하며, 나머지 층은 각 층의 은닉 상태를 말합니다. ELMo의 직관적인 아이디어는 각 층의 출력값이 가진 정보는 전부 서로 다른 종류의 정보를 갖고 있을 것이므로, 이들을 모두 활용한다는 점에 있습니다. 아래는 ELMo가 임베딩 벡터를 얻는 과정을 보여줍니다. 1) 각 층의 출력값을 연결(concatenate) 한다. 2) 각 층의 출력값 별로 가중치를 준다. 이 가중치를 여기서는 1 s, 3 라고 합시다. 3) 각 층의 출력값을 모두 더한다. 2) 번과 3) 번의 단계를 요약하여 가중합(Weighted Sum)을 한다고 할 수 있습니다. 4) 벡터의 크기를 결정하는 스칼라 매개변수를 곱한다. 이 스칼라 매개변수를 여기서는이라고 합시다. 이렇게 완성된 벡터를 ELMo 표현(representation)이라고 합니다. 지금까지는 ELMo 표현을 얻기 위한 과정이고 이제 ELMo를 입력으로 사용하고 수행하고 싶은 텍스트 분류, 질의응답 시스템 등의 자연어 처리 작업이 있을 것입니다. 예를 들어 텍스트 분류 작업을 하고 싶다고 가정합시다. 그렇다면 ELMo 표현을 어떻게 텍스트 분류 작업에 사용할 수 있을까요? ELMo 표현을 기존의 임베딩 벡터와 함께 사용할 수 있습니다. 우선 텍스트 분류 작업을 위해서 GloVe와 같은 기존의 방법론을 사용한 임베딩 벡터를 준비했다고 합시다. 이때, GloVe를 사용한 임베딩 벡터만 텍스트 분류 작업에 사용하는 것이 아니라 이렇게 준비된 ELMo 표현을 GloVe 임베딩 벡터와 연결(concatenate) 해서 입력으로 사용할 수 있습니다. 그리고 이때 biLM의 가중치는 고정시키고, 위에서 사용한 1 s, 3 γ 는 훈련 과정에서 학습됩니다. 위의 그림은 ELMo 표현이 기존의 GloVe 등과 같은 임베딩 벡터와 함께 NLP 태스크의 입력이 되는 것을 보여줍니다. 12-12 문서 벡터를 이용한 추천 시스템(Recommendation System using Document Embedding) 문서들을 고정된 길이의 벡터로 변환한다면 벡터 간 비교로 문서들을 서로 비교할 수 있습니다. 각 문서를 문서 벡터로 변환하는 방법은 이미 구현된 패키지인 Doc2Vec이나 Sent2Vec 등을 사용하여 학습하는 방법도 존재하지만, 단어 벡터를 얻은 뒤 문서에 존재하는 단어 벡터들의 평균을 문서 벡터로 간주할 수 있습니다. 이번에는 문서 내 각 단어들을 Word2Vec을 통해 단어 벡터로 변환하고, 이들의 평균으로 문서 벡터를 얻어 선호하는 도서와 유사한 도서를 찾아주는 도서 추천 시스템을 만들어보겠습니다. 1. 데이터 로드 이번 실습에서 사용할 데이터는 책의 이미지와 책의 줄거리를 크롤링 한 데이터로 아래의 링크에서 다운로드할 수 있습니다. 데이터 다운로드 링크 : https://drive.google.com/file/d/15Q7DZ7xrJsI2Hji-WbkU9j1mwnODBd5A/view?usp=sharing # 현재 코드가 gensim 3.6.0 버전에서 동작합니다. import urllib.request import pandas as pd import numpy as np import matplotlib.pyplot as plt import requests import re from PIL import Image from io import BytesIO from nltk.tokenize import RegexpTokenizer import nltk from gensim.models import Word2Vec from gensim.models import KeyedVectors from nltk.corpus import stopwords from sklearn.metrics.pairwise import cosine_similarity 데이터를 데이터 프레임으로 로드하고 전체 문서의 수를 출력해 봅시다. urllib.request.urlretrieve("https://raw.githubusercontent.com/ukairia777/tensorflow-nlp-tutorial/main/09.%20Word%20Embedding/dataset/data.csv", filename="data.csv") df = pd.read_csv("data.csv") print('전체 문서의 수 :',len(df)) 전체 문서의 수 : 2382 상위 5개의 행만 출력해 봅시다. df[:5] 불필요한 열들이 존재하는데, 여기서는 줄거리에 해당하는 열인 'Desc 열'이 중요합니다. 해당 열에 있는 데이터에 대해서 Word2Vec을 학습하기 위해 전처리를 진행합니다. 해당 열에 대해서 전처리를 수행하고 'cleaned'라는 열에 저장해 봅시다. def _removeNonAscii(s): return "".join(i for i in s if ord(i)<128) def make_lower_case(text): return text.lower() def remove_stop_words(text): text = text.split() stops = set(stopwords.words("english")) text = [w for w in text if not w in stops] text = " ".join(text) return text def remove_html(text): html_pattern = re.compile('<.*?>') return html_pattern.sub(r'', text) def remove_punctuation(text): tokenizer = RegexpTokenizer(r'[a-zA-Z]+') text = tokenizer.tokenize(text) text = " ".join(text) return text df['cleaned'] = df['Desc'].apply(_removeNonAscii) df['cleaned'] = df.cleaned.apply(make_lower_case) df['cleaned'] = df.cleaned.apply(remove_stop_words) df['cleaned'] = df.cleaned.apply(remove_punctuation) df['cleaned'] = df.cleaned.apply(remove_html) 상위 5개의 행만 출력합니다. df['cleaned'][:5] 0 know power shifting west east north south pres... 1 following success accidental billionaires mone... 2 tap power social software networks build busin... 3 william j bernstein american financial theoris... 4 amazing book joined steve jobs many akio morit... Name: cleaned, dtype: object 전처리 과정에서 빈 값이 생긴 행이 있을 수 있습니다. 빈 값이 생긴 행이 있다면, nan 값으로 변환 후에 해당 행을 제거합니다. df['cleaned'].replace('', np.nan, inplace=True) df = df[df['cleaned'].notna()] print('전체 문서의 수 :',len(df)) 전체 문서의 수 : 2381 전체 문서의 수가 1개 줄어들었습니다. 토큰화를 수행하여 corpus라는 리스트에 저장합니다. 해당 리스트 corpus를 통해 Word2Vec을 훈련할 것입니다. corpus = [] for words in df['cleaned']: corpus.append(words.split()) 2. 사전 훈련된 워드 임베딩 사용하기 Word2Vec을 처음부터 학습할 수도 있겠지만, 데이터가 충분하지 않은 상황에서 사전 훈련된 워드 임베딩을 단어 벡터의 초깃값으로 사용하여 성능을 높일 수 있습니다. 여기서는 사전 훈련된 Word2Vec을 로드하고 초기 단어 벡터 값으로 사용합니다. urllib.request.urlretrieve("https://s3.amazonaws.com/dl4j-distribution/GoogleNews-vectors-negative300.bin.gz", \ filename="GoogleNews-vectors-negative300.bin.gz") word2vec_model = Word2Vec(size = 300, window=5, min_count = 2, workers = -1) word2vec_model.build_vocab(corpus) word2vec_model.intersect_word2vec_format('GoogleNews-vectors-negative300.bin.gz', lockf=1.0, binary=True) word2vec_model.train(corpus, total_examples = word2vec_model.corpus_count, epochs = 15) 3. 단어 벡터의 평균 구하기 각 문서에 존재하는 단어들의 벡터 값의 평균을 구하여 해당 문서의 벡터 값을 연산해 봅시다. def get_document_vectors(document_list): document_embedding_list = [] # 각 문서에 대해서 for line in document_list: doc2vec = None count = 0 for word in line.split(): if word in word2vec_model.wv.vocab: count += 1 # 해당 문서에 있는 모든 단어들의 벡터 값을 더한다. if doc2vec is None: doc2vec = word2vec_model[word] else: doc2vec = doc2vec + word2vec_model[word] if doc2vec is not None: # 단어 벡터를 모두 더한 벡터의 값을 문서 길이로 나눠준다. doc2vec = doc2vec / count document_embedding_list.append(doc2vec) # 각 문서에 대한 문서 벡터 리스트를 리턴 return document_embedding_list document_embedding_list = get_document_vectors(df['cleaned']) print('문서 벡터의 수 :',len(document_embedding_list)) 문서 벡터의 수 : 2381 4. 추천 시스템 구현하기 각 문서 벡터 간의 코사인 유사도를 구합니다. cosine_similarities = cosine_similarity(document_embedding_list, document_embedding_list) print('코사인 유사도 매트릭스의 크기 :',cosine_similarities.shape) 코사인 유사도 매트릭스의 크기 : (2381, 2381) 선택한 책에 대해서 코사인 유사도를 이용하여 가장 줄거리가 유사한 5개의 책을 찾아내는 함수를 만듭니다. def recommendations(title): books = df[['title', 'image_link']] # 책의 제목을 입력하면 해당 제목의 인덱스를 리턴 받아 idx에 저장. indices = pd.Series(df.index, index = df['title']).drop_duplicates() idx = indices[title] # 입력된 책과 줄거리(document embedding)가 유사한 책 5개 선정. sim_scores = list(enumerate(cosine_similarities[idx])) sim_scores = sorted(sim_scores, key = lambda x: x[1], reverse = True) sim_scores = sim_scores[1:6] # 가장 유사한 책 5권의 인덱스 book_indices = [i[0] for i in sim_scores] # 전체 데이터 프레임에서 해당 인덱스의 행만 추출. 5개의 행을 가진다. recommend = books.iloc[book_indices].reset_index(drop=True) fig = plt.figure(figsize=(20, 30)) # 데이터 프레임으로부터 순차적으로 이미지를 출력 for index, row in recommend.iterrows(): response = requests.get(row['image_link']) img = Image.open(BytesIO(response.content)) fig.add_subplot(1, 5, index + 1) plt.imshow(img) plt.title(row['title']) 좋아하는 책 제목을 입력으로 넣으면 해당 책의 문서 벡터(줄거리 벡터)와 유사한 문서 벡터 값을 가진 책들을 추천해 줍니다. 책 제목과 표지를 출력합니다. recommendations("The Da Vinci Code") 다빈치 코드는 작가 댄 브라운의 작품입니다. 추천되는 작품들 또한 5개 중 3개가 댄 브라운의 작품들이 추천됨을 확인할 수 있습니다. 이번에는 아가사 크리스티의 애크로이드 살인사건과 유사한 도서를 추천받아 봅시다. recommendations("The Murder of Roger Ackroyd") 애크로이드 살인사건은 미스터리 스릴러 소설인데 이와 유사한 소설들이 추천되는 것을 확인할 수 있습니다. 12-13 Doc2Vec으로 공시 사업보고서 유사도 계산하기 Word2Vec은 단어를 임베딩하는 워드 임베딩 알고리즘이었습니다. Doc2Vec은 Word2Vec을 변형하여 문서의 임베딩을 얻을 수 있도록 한 알고리즘입니다. 논문 제목과 논문의 링크는 아래와 같습니다. 논문 제목 : Distributed Representations of Sentences and Documents 논문 링크 : https://arxiv.org/abs/1405.4053 Word2Vec과 마찬가지로 파이썬 머신 러닝 패키지인 Gensim을 통해서 쉽게 사용할 수 있습니다. 이번 실습에서는 저자가 수집해놓은 전자공시시스템(Dart)에 올라와 있는 각 회사의 사업보고서를 Doc2Vec을 통해서 학습시키고, 특정 회사와 사업 보고서가 유사한 회사들을 찾아보겠습니다. 1. 공시 사업 보고서 로드 및 전처리 해당 실습은 형태소 분석기 Mecab의 원활한 설치를 위해서 구글의 Colab에서 진행했다고 가정합니다. 여러분들의 컴퓨터에 Mecab을 설치하였거나, 다른 형태소 분석기를 사용한다면 Colab에서 하지 않더라도 상관없습니다. # dart.csv 파일 다운로드 !wget --load-cookies /tmp/cookies.txt "https://docs.google.com/uc? export=download&confirm=$(wget --quiet --save-cookies /tmp/cookies.txt --keep-session-cookies --no-check-certificate 'https://docs.google.com/uc?export=download&id=1XS0UlE8gNNTRjnL6e64sMacOhtVERIqL' -O- | sed -rn 's/.*confirm=([0-9A-Za-z_]+).*/\1\n/p')&id=1XS0UlE8gNNTRjnL6e64sMacOhtVERIqL" -O dart.csv && rm -rf /tmp/cookies.txt # 형태소 분석기 Mecab 설치 !pip install konlpy !pip install mecab-python !bash <(curl -s https://raw.githubusercontent.com/konlpy/konlpy/master/scripts/mecab.sh) import pandas as pd from konlpy.tag import Mecab from gensim.models.doc2vec import TaggedDocument from tqdm import tqdm dart.csv 파일을 데이터 프레임으로 로드합니다. 그리고 결측값을 가진 샘플을 제거해 줍니다. df = pd.read_csv('/content/dart.csv', sep=',') df = df.dropna() df 총 2,295개의 행과 4개의 열로 구성돼 있습니다. 첫 번째 열은 종목 번호에 해당하는 code 열, 두 번째 열은 해당 종목이 KOSPI 인지 KOSDAQ 인지를 알려주는 market 열, 세 번째 열은 회사명에 해당하는 name 열, 그리고 네 번째 business 열은 우리가 학습할 사업 보고서에 해당됩니다. 이제 business 열에 대해서 형태소 분석을 수행해 봅시다. 이와 동시에 Doc2Vec 학습을 위해서 필요한<NAME>으로 데이터의<NAME>을 변환합니다. Doc2Vec 학습을 위해서는 해당 문서의 '제목'과 단어 토큰 화가 된 상태의 해당 문서의 '본문' 두 가지가 필요합니다. TaggedDocument의 tags에 해당 문서의 '제목'을, 그리고 words에 해당 문서의 '본문'에 해당하는 단어 토큰화 결과를 저장하고, 이 결과를 원소로 하는 파이썬 리스트인 tagged_corpus_list를 만듭니다. mecab = Mecab() tagged_corpus_list = [] for index, row in tqdm(df.iterrows(), total=len(df)): text = row['business'] tag = row['name'] tagged_corpus_list.append(TaggedDocument(tags=[tag], words=mecab.morphs(text))) print('문서의 수 :', len(tagged_corpus_list)) 문서의 수 : 2295 첫 번째 문서의 전처리 결과를 확인해 봅시다. tagged_corpus_list[0] TaggedDocument(words=['II', '.', '사업', '의', '내용', '1', '.', '사업', '의', '개요', '가', '.', '일반', '적', '인', '사항', '기업', '회계', '기준', '서', '제', '1110', '호', '"', '연결', '재무제표', '"', '의', '의하', '여', '2018', '년', '12', '월', '17', '일', '에', '설립', '한', '동화', '크립톤', '기업가', '정신', '제일', '호', '창업', '벤처', '전문', '사모', '투자', '합자회사', '를', '종속', '회사', '에', '편입', '하', '였', '습니다', ... 중략 ... '대기', '관리', '권', '역', '의', '대기', '환경', '개선', '에', '관한', '특별법', '을', '준', '수', '하', '고', '있', '습니다', '.'], tags=['동화약품']) TaggedDocument 안 words에는 토큰화된 사업 보고서, tags에는 해당 문서의 제목이 저장돼 있습니다. 2. Doc2Vec 학습 및 테스트 이제 모델을 학습합니다. 사업 보고서가 꽤 긴 문서인데다 토큰화 외에 불용어 제거 등 별도 추가 전처리를 진행하지 않았기 때문에 저자가 Colab에서 수행했을 때, 소요 시간이 최소 1시간 이상 걸렸습니다. from gensim.models import doc2vec model = doc2vec.Doc2Vec(vector_size=300, alpha=0.025, min_alpha=0.025, workers=8, window=8) # Vocabulary 빌드 model.build_vocab(tagged_corpus_list) print(f"Tag Size: {len(model.docvecs.doctags.keys())}", end=' / ') # Doc2Vec 학습 model.train(tagged_corpus_list, total_examples=model.corpus_count, epochs=50) # 모델 저장 model.save('dart.doc2vec') 코드를 다 수행하고 나면 3개의 파일이 생깁니다. dart.doc2vec dart.doc2vec.trainables.syn1neg.npy dart.doc2vec.wv.vectors.npy 이제 모델을 테스트해 봅시다. 회사 동화약품과 사업 보고서가 유사한 회사들은 어디일까요? similar_doc = model.docvecs.most_similar('동화약품') print(similar_doc) [('종근당', 0.5310906171798706), ('삼일제약', 0.5263979434967041), ('일양 약품', 0.5260423421859741), ('영진약품', 0.5254894495010376), ('제일약품', 0.5089458227157593), ('유한양행', 0.5015101432800293), ('국제약품', 0.4985279440879822), ('삼아제약', 0.49677950143814087), ('동아에스티', 0.49451446533203125), ('대웅제약', 0.48559868335723877)] 이 외에 다른 테스트에서도 관련 업종의 회사들이 나오는 것을 확인할 수 있었습니다. similar_doc = model.docvecs.most_similar('하이트진로') print(similar_doc) [('하이트진로홀딩스', 0.8621307611465454), ('무학', 0.5214779376983643), ('보해양조', 0.5100635290145874), ('국순당', 0.48447638750076294), ('롯데칠성', 0.4617755115032196), ('금비', 0.4156178832054138), ('삼양 패키징', 0.40965551137924194), ('삼광글라스', 0.40689679980278015), ('경방', 0.40154141187667847), ('오뚝이', 0.3958606719970703)] similar_doc = model.docvecs.most_similar('LG이노텍') print(similar_doc) [('LG전자', 0.533338725566864), ('LG', 0.523799479007721), ('삼성전기', 0.45796477794647217), ('LG디스플레이', 0.4485859274864197), ('서울반도체', 0.42762115597724915), ('루멘스', 0.42333459854125977), ('삼성SDI', 0.4111291170120239), ('큐엠씨', 0.409035325050354), ('서울바이오 시스', 0.4087420105934143), ('삼성공조', 0.4040142595767975)] similar_doc = model.docvecs.most_similar('메리츠화재') print(similar_doc) [('메리츠금융 지주', 0.7080470323562622), ('한화손해보험', 0.69782555103302), ('롯데손해보험', 0.6945951581001282), ('DB손해보험', 0.6699072122573853), ('한화생명', 0.665973961353302), ('흥국화재', 0.6471891403198242), ('현대해상', 0.6267702579498291), ('코리안리', 0.5982924699783325), ('삼성화재', 0.5873793959617615), ('동양생명', 0.5722818970680237)] similar_doc = model.docvecs.most_similar('카카오') print(similar_doc) [('네오위즈', 0.5055375099182129), ('NAVER', 0.4846588373184204), ('네오위즈 홀딩스', 0.47819197177886963), ('퓨처스트림네트웍스', 0.4654642939567566), ('신풍제약 우', 0.46335992217063904), ('LG생활건강 우', 0.4604458212852478), ('금호석유우', 0.4568769931793213), ('컴투스', 0.4565160274505615), ('코리아써키트 2우 B', 0.45594915747642517), ('세방 우', 0.4553225636482239)] 12-14 실전! 한국어 위키피디아로 Word2Vec 학습하기 아래의 실습은 구글의 Colab을 사용한다고 가정하고 작성되었습니다. 다른 환경에서 실습하셔도 상관은 없지만, 형태소 분석기 Mecab은 다른 방법으로 설치하셔야 합니다. 1. 위키피디아로부터 데이터 다운로드 및 통합 위키피디아로부터 데이터를 파싱 하기 위한 파이썬 패키지인 wikiextractor를 설치합니다. pip install wikiextractor 위키피디아 데이터를 다운로드 한 후에 전처리에서 사용할 형태소 분석기인 Mecab을 설치합니다. # Colab에 Mecab 설치 !git clone https://github.com/SOMJANG/Mecab-ko-for-Google-Colab.git %cd Mecab-ko-for-Google-Colab !bash install_mecab-ko_on_colab190912.sh 위키피디아 덤프(위키피디아 데이터)를 다운로드합니다. !wget https://dumps.wikimedia.org/kowiki/latest/kowiki-latest-pages-articles.xml.bz2 위키익스트랙터를 사용하여 위키피디아 덤프를 파싱 합니다. !python -m wikiextractor.WikiExtractor kowiki-latest-pages-articles.xml.bz2 현재 경로에 있는 디렉터리와 파일들의 리스트를 받아옵니다. %ls images/ LICENSE install_mecab-ko_on_colab190912.sh README.md install_mecab-ko_on_colab_light_210108.sh text/ kowiki-latest-pages-articles.xml.bz2 text라는 디렉터리 안에는 또 어떤 디렉터리들이 있는지 파이썬을 사용하여 확인해 봅시다. import os import re os.listdir('text') ['AG', 'AI', 'AH', 'AC', 'AE', 'AB', 'AA', 'AD', 'AF'] AA라는 디렉터리의 파일들을 확인해 봅시다. %ls text/AA wiki_00 wiki_12 wiki_24 wiki_36 wiki_48 wiki_60 wiki_72 wiki_84 wiki_96 wiki_01 wiki_13 wiki_25 wiki_37 wiki_49 wiki_61 wiki_73 wiki_85 wiki_97 wiki_02 wiki_14 wiki_26 wiki_38 wiki_50 wiki_62 wiki_74 wiki_86 wiki_98 wiki_03 wiki_15 wiki_27 wiki_39 wiki_51 wiki_63 wiki_75 wiki_87 wiki_99 wiki_04 wiki_16 wiki_28 wiki_40 wiki_52 wiki_64 wiki_76 wiki_88 wiki_05 wiki_17 wiki_29 wiki_41 wiki_53 wiki_65 wiki_77 wiki_89 wiki_06 wiki_18 wiki_30 wiki_42 wiki_54 wiki_66 wiki_78 wiki_90 wiki_07 wiki_19 wiki_31 wiki_43 wiki_55 wiki_67 wiki_79 wiki_91 wiki_08 wiki_20 wiki_32 wiki_44 wiki_56 wiki_68 wiki_80 wiki_92 wiki_09 wiki_21 wiki_33 wiki_45 wiki_57 wiki_69 wiki_81 wiki_93 wiki_10 wiki_22 wiki_34 wiki_46 wiki_58 wiki_70 wiki_82 wiki_94 wiki_11 wiki_23 wiki_35 wiki_47 wiki_59 wiki_71 wiki_83 wiki_95 텍스트 파일로 변환된 위키피디아 한국어 덤프는 총 6개의 디렉터리로 구성돼 있습니다. AA ~ AF의 디렉터리로 각 디렉터리 내에는 'wiki_00 ~ wiki_약 90내외의 숫자'의 파일들이 들어있습니다. 다시 말해 각 디렉터리에는 약 90여 개의 파일들이 들어있습니다. 각 파일들을 열어보면 이와 같은 구성이 반복되고 있습니다. <doc id="문서 번호" url="실제 위키피디아 문서 주소" title="문서 제목"> 내용 </doc> 예를 들어서 AA 디렉터리의 wiki_00 파일을 읽어보면, 지미 카터에 대한 내용이 나옵니다. <doc id="5" url="https://ko.wikipedia.org/wiki?curid=5" title="지미 카터"> 지미 카터 제임스 얼 "지미" 카터 주니어(, 1924년 10월 1일 ~ )는 민주당 출신 미국 39번째 대통령(1977년 ~ 1981년)이다. 지미 카터는 조지아 주 섬터 카운티 플레인스 마을에서 태어났다. 조지아 공과대학교를 졸업하였다. 그 후 해군에 들어가 전함·원자력·잠수함의 승무원으로 일하였다. 1953년 미국 해군 대 위로 예편하였고 이후 땅콩·면화 등을 가꿔 많은 돈을 벌었다. ... 이하 중략... </doc> 이제 이 6개 AA ~ AF 디렉터리 안의 wiki 숫자 형태의 수많은 파일들을 하나로 통합하는 과정을 진행해야 합니다. AA ~ AF 디렉터리 안의 모든 파일들의 경로를 파이썬의 리스트 형태로 저장합니다. def list_wiki(dirname): filepaths = [] filenames = os.listdir(dirname) for filename in filenames: filepath = os.path.join(dirname, filename) if os.path.isdir(filepath): # 재귀 함수 filepaths.extend(list_wiki(filepath)) else: find = re.findall(r"wiki_[0-9][0-9]", filepath) if 0 < len(find): filepaths.append(filepath) return sorted(filepaths) filepaths = list_wiki('text') 총 파일의 개수를 확인해 봅시다. len(filepaths) 850 총 파일의 개수는 850개입니다. 이제 output_file.txt라는 파일에 850개의 파일을 전부 하나로 합칩니다. with open("output_file.txt", "w") as outfile: for filename in filepaths: with open(filename) as infile: contents = infile.read() outfile.write(contents) 파일을 읽고 10줄만 출력해 보겠습니다. f = open('output_file.txt', encoding="utf8") i = 0 while True: line = f.readline() if line != '\n': i = i+1 print("%d 번째 줄 :"%i + line) if i==10: break f.close() 1번째 줄 :<doc id="5" url="https://ko.wikipedia.org/wiki? curid=5" title="지미 카터"> 2번째 줄 :지미 카터 3번째 줄 :제임스 얼 카터 주니어(, 1924년 10월 1일 ~ )는 민주당 출신 미국 39대 대통령 (1977년 ~ 1981년)이다. 4번째 줄 :생애. 5번째 줄 :어린 시절. 6번째 줄 :지미 카터는 조지아주 섬터 카운티 플레인스 마을에서 태어났다. 7번째 줄 :조지아 공과대학교를 졸업하였다. 그 후 해군에 들어가 전함·원자력·잠수함의 승무원으로 일하였다. 1953년 미국 해군 대위로 예편하였고 이후 땅콩·면화 등을 가꿔 많은 돈을 벌었다. 그의 별명이 "땅콩 농부" (Peanut Farmer)로 알려졌다. 8번째 줄 :정계 입문. 9번째 줄 :1962년 조지아 주<NAME> 의원 선거에서 낙선하나 그 선거가 부정선거였음을 입증하게 되어 당선되고, 1966년 조지아 주지사 선거에 낙선하지만, 1970년 조지아 주지사를 역임했다. 대통령이 되기 전 조지아주<NAME> 의원을 두 번 연임했으며, 1971년부터 1975년까지 조지아 지사로 근무했다. 조지아 주지사로 지내면서, 미국에 사는 흑인 등용 법을 내세웠다. 10번째 줄 :대통령 재임. 2. 형태소 분석 from tqdm import tqdm from konlpy.tag import Mecab 형태소 분석기 Mecab을 사용하여 토큰화를 진행해 보겠습니다. mecab = Mecab() 우선 output_file에는 총 몇 줄이 있는지 확인합니다. f = open('output_file.txt', encoding="utf8") lines = f.read().splitlines() print(len(lines)) 9718793 9,718,793개의 줄이 존재합니다. 상위 10개만 출력해 봅시다. lines[:10] ['<doc id="5" url="https://ko.wikipedia.org/wiki? curid=5" title="지미 카터">', '지미 카터', '', '제임스 얼 카터 주니어(, 1924년 10월 1일 ~ )는 민주당 출신 미국 39대 대통령 (1977년 ~ 1981년)이다.', '생애.', '어린 시절.', '지미 카터는 조지아주 섬터 카운티 플레인스 마을에서 태어났다.', '조지아 공과대학교를 졸업하였다. 그 후 해군에 들어가 전함·원자력·잠수함의 승무원으로 일하였다. 1953년 미국 해군 대위로 예편하였고 이후 땅콩·면화 등을 가꿔 많은 돈을 벌었다. 그의 별명이 "땅콩 농부" (Peanut Farmer)로 알려졌다.', '정계 입문.', '1962년 조지아 주<NAME> 의원 선거에서 낙선하나 그 선거가 부정선거였음을 입증하게 되어 당선되고, 1966년 조지아 주지사 선거에 낙선하지만, 1970년 조지아 주지사를 역임했다. 대통령이 되기 전 조지아주<NAME> 의원을 두 번 연임했으며, 1971년부터 1975년까지 조지아 지사로 근무했다. 조지아 주지사로 지내면서, 미국에 사는 흑인 등용 법을 내세웠다.'] 두 번째 줄을 보면 아무런 단어도 들어있지 않은 ''와 같은 줄도 존재합니다. 해당 문자열은 형태소 분석에서 제외하도록 하고 형태소 분석을 수행해 봅시다. result = [] for line in tqdm(lines): # 빈 문자열이 아닌 경우에만 수행 if line: result.append(mecab.morphs(line)) 100%|██████████| 9718793/9718793 [15:27<00:00, 10478.61it/s] 빈 문자열은 제외하고 형태소 분석을 진행했습니다. 이제 몇 개의 줄. 즉, 몇 개의 문장이 존재하는지 확인해 봅시다. len(result) 6559314 6,559,314개로 문장의 수가 줄었습니다. 3. Word2Vec 학습 형태소 분석을 통해서 토큰 화가 진행된 상태이므로 Word2Vec을 학습합니다. from gensim.models import Word2Vec model = Word2Vec(result, size=100, window=5, min_count=5, workers=4, sg=0) model_result1 = model.wv.most_similar("대한민국") print(model_result1) [('한국', 0.7382678389549255), ('미국', 0.6731516122817993), ('일본', 0.6541135907173157), ('부산', 0.5798133611679077), ('홍콩', 0.5752249360084534), ('서울', 0.5541036128997803), ('오스트레일리아', 0.5531408786773682), ('태국', 0.548468828201294), ('경상남도', 0.5462549924850464), ('제주특별자치도', 0.5385439395904541)] model_result2 = model.wv.most_similar("어벤저스") print(model_result2) [('스파이더맨', 0.80271977186203), ('트랜스포머', 0.773989200592041), ('아이언맨', 0.7648921012878418), ('스타트렉', 0.7645636796951294), ('어벤저스', 0.7626765966415405), ('엑스맨', 0.7586475610733032), ('《》,', 0.7560415267944336), ('트와일라잇', 0.7518032789230347), ('퍼니셔', 0.7391209602355957), ('테일즈', 0.7386105060577393)] model_result3 = model.wv.most_similar("반도체") print(model_result3) [('집적회로', 0.7714468836784363), ('연료전지', 0.7699108719825745), ('전자', 0.7606919407844543), ('웨이퍼', 0.745188295841217), ('실리콘', 0.743209958076477), ('트랜지스터', 0.7398351430892944), ('PCB', 0.7275883555412292), ('TSMC', 0.7156406044960022), ('가속기', 0.6962155699729919), ('광전자', 0.6957612037658691)] 12-15 단어 단위 RNN - 임베딩 사용 이번 챕터에서는 이전의 RNN 챕터에서 문자 단위 RNN을 구현했던 것과는 달리 RNN의 입력 단위를 단어 단위로 사용합니다. 그리고 단어 단위를 사용함에 따라서 Pytorch에서 제공하는 임베딩 층(embedding layer)를 사용하겠습니다. 1. 훈련 데이터 전처리하기 우선 실습을 위해 필요한 도구들을 임포트 합니다. import torch import torch.nn as nn import torch.optim as optim 실습을 위해 임의의 문장을 만듭니다. sentence = "Repeat is the best medicine for memory".split() 우리가 만들 RNN은 'Repeat is the best medicine for'을 입력받으면 'is the best medicine for memory'를 출력하는 RNN입니다. 위의 임의의 문장으로부터 단어장(vocabulary)을 만듭니다. vocab = list(set(sentence)) print(vocab) ['best', 'memory', 'the', 'is', 'for', 'medicine', 'Repeat'] 이제 단어장의 단어에 고유한 정수 인덱스를 부여합니다. 그리고 그와 동시에 모르는 단어를 의미하는 UNK 토큰도 추가하겠습니다. word2index = {tkn: i for i, tkn in enumerate(vocab, 1)} # 단어에 고유한 정수 부여 word2index['<unk>']=0 print(word2index) {'best': 1, 'memory': 2, 'the': 3, 'is': 4, 'for': 5, 'medicine': 6, 'Repeat': 7, '<unk>': 0} 이제 word2index가 우리가 사용할 최종 단어장인 셈입니다. word2index에 단어를 입력하면 매핑되는 정수를 리턴합니다. print(word2index['memory']) 단어 'memory'와 매핑되는 정수는 2입니다. 예측 단계에서 예측한 문장을 확인하기 위해 idx2word도 만듭니다. # 수치화된 데이터를 단어로 바꾸기 위한 사전 index2word = {v: k for k, v in word2index.items()} print(index2word) {1: 'best', 2: 'memory', 3: 'the', 4: 'is', 5: 'for', 6: 'medicine', 7: 'Repeat', 0: '<unk>'} idx2word는 정수로부터 단어를 리턴하는 역할을 합니다. 정수 2를 넣어봅시다. print(index2word[2]) memory 정수 2와 매핑되는 단어는 memory인 것을 확인할 수 있습니다. 이제 데이터의 각 단어를 정수로 인코딩하는 동시에, 입력 데이터와 레이블 데이터를 만드는 build_data라는 함수를 만들어보겠습니다. def build_data(sentence, word2index): encoded = [word2index[token] for token in sentence] # 각 문자를 정수로 변환. input_seq, label_seq = encoded[:-1], encoded[1:] # 입력 시퀀스와 레이블 시퀀스를 분리 input_seq = torch.LongTensor(input_seq).unsqueeze(0) # 배치 차원 추가 label_seq = torch.LongTensor(label_seq).unsqueeze(0) # 배치 차원 추가 return input_seq, label_seq 만들어진 함수로부터 입력 데이터와 레이블 데이터를 얻습니다. X, Y = build_data(sentence, word2index) 입력 데이터와 레이블 데이터가 정상적으로 생성되었는지 출력해 봅시다. print(X) print(Y) tensor([[7, 4, 3, 1, 6, 5]]) # Repeat is the best medicine for을 의미 tensor([[4, 3, 1, 6, 5, 2]]) # is the best medicine for memory을 의미 2. 모델 구현하기 이제 모델을 설계합니다. 이전 모델들과 달라진 점은 임베딩 층을 추가했다는 점입니다. 파이 토치에서는 nn.Embedding()을 사용해서 임베딩 층을 구현합니다. 임베딩층은 크게 두 가지 인자를 받는데 첫 번째 인자는 단어장의 크기이며, 두 번째 인자는 임베딩 벡터의 차원입니다. class Net(nn.Module): def __init__(self, vocab_size, input_size, hidden_size, batch_first=True): super(Net, self).__init__() self.embedding_layer = nn.Embedding(num_embeddings=vocab_size, # 워드 임베딩 embedding_dim=input_size) self.rnn_layer = nn.RNN(input_size, hidden_size, # 입력 차원, 은닉 상태의 크기 정의 batch_first=batch_first) self.linear = nn.Linear(hidden_size, vocab_size) # 출력은 원-핫 벡터의 크기를 가져야 함. 또는 단어 집합의 크기만큼 가져야 함. def forward(self, x): # 1. 임베딩 층 # 크기 변화: (배치 크기, 시퀀스 길이) => (배치 크기, 시퀀스 길이, 임베딩 차원) output = self.embedding_layer(x) # 2. RNN 층 # 크기 변화: (배치 크기, 시퀀스 길이, 임베딩 차원) # => output (배치 크기, 시퀀스 길이, 은닉층 크기), hidden (1, 배치 크기, 은닉층 크기) output, hidden = self.rnn_layer(output) # 3. 최종 출력층 # 크기 변화: (배치 크기, 시퀀스 길이, 은닉층 크기) => (배치 크기, 시퀀스 길이, 단어장 크기) output = self.linear(output) # 4. view를 통해서 배치 차원 제거 # 크기 변화: (배치 크기, 시퀀스 길이, 단어장 크기) => (배치 크기*시퀀스 길이, 단어장 크기) return output.view(-1, output.size(2)) 이제 모델을 위해 하이퍼 파라미터를 설정합니다. # 하이퍼 파라미터 vocab_size = len(word2index) # 단어장의 크기는 임베딩 층, 최종 출력층에 사용된다. <unk> 토큰을 크기에 포함한다. input_size = 5 # 임베딩 된 차원의 크기 및 RNN 층 입력 차원의 크기 hidden_size = 20 # RNN의 은닉층 크기 모델을 생성합니다. # 모델 생성 model = Net(vocab_size, input_size, hidden_size, batch_first=True) # 손실 함수 정의 loss_function = nn.CrossEntropyLoss() # 소프트맥스 함수 포함이며 실제 값은 원-핫 인코딩 안 해도 됨. # 옵티마이저 정의 optimizer = optim.Adam(params=model.parameters()) 모델에 입력을 넣어서 출력을 확인해 봅시다. # 임의로 예측해 보기. 가중치는 전부 랜덤 초기화된 상태이다. output = model(X) print(output) tensor([[ 0.1198, 0.0473, 0.1735, 0.6194, 0.2807, -0.2106, 0.0770, -0.4386], [ 0.0374, -0.0778, 0.2033, 0.3874, -0.0493, -0.0961, 0.0201, -0.4601], [ 0.0167, -0.0092, 0.0669, 0.2091, -0.0390, -0.0250, 0.1512, -0.2769], [-0.0784, -0.0491, 0.1702, 0.2962, 0.0476, -0.1790, -0.3025, -0.2063], [ 0.1245, 0.1390, 0.2189, 0.3938, 0.2040, -0.1574, -0.2011, -0.1248], [ 0.1940, 0.0897, 0.3987, 0.3072, 0.2123, -0.0825, 0.1198, -0.2285]], grad_fn=<ViewBackward>) 모델이 어떤 예측값을 내놓기는 하지만 현재 가중치는 랜덤 초기화되어 있어 의미 있는 예측값은 아닙니다. 예측값의 크기를 확인해 봅시다. print(output.shape) torch.Size([6, 8]) 예측값의 크기는 (6, 8)입니다. 이는 각각 (시퀀스의 길이, 은닉층의 크기)에 해당됩니다. 모델은 훈련시키기 전에 예측을 제대로 하고 있는지 예측된 정수 시퀀스를 다시 단어 시퀀스로 바꾸는 decode 함수를 만듭니다. # 수치화된 데이터를 단어로 전환하는 함수 decode = lambda y: [index2word.get(x) for x in y] 약 200 에포크 학습합니다. # 훈련 시작 for step in range(201): # 경사 초기화 optimizer.zero_grad() # 순방향 전파 output = model(X) # 손실 값 계산 loss = loss_function(output, Y.view(-1)) # 역방향 전파 loss.backward() # 매개변수 업데이트 optimizer.step() # 기록 if step % 40 == 0: print("[{:02d}/201] {:.4f} ".format(step+1, loss)) pred = output.softmax(-1).argmax(-1).tolist() print(" ".join(["Repeat"] + decode(pred))) print() [01/201] 2.0184 Repeat the the the the medicine best [41/201] 1.3917 Repeat is the best medicine for memory [81/201] 0.7013 Repeat is the best medicine for memory [121/201] 0.2992 Repeat is the best medicine for memory [161/201] 0.1552 Repeat is the best medicine for memory [201/201] 0.0964 Repeat is the best medicine for memory 13. [NLP 기본 ] RNN과 CNN을 이용한 텍스트 분류 이번 챕터에서는 다대일 RNN과 CNN을 이용하여 텍스트 분류를 해보겠습니다. 13-01 RNN을 이용한 텍스트 분류(Text classification using PyTorch) 이번 챕터에서는 파이 토치(PyTorch)로 인공 신경망을 이용한 텍스트 분류를 실습합니다. 실습에 앞서 딥 러닝을 이용해서 텍스트 분류가 수행될 때, 어떤 작업과 구성으로 진행되는지 간단히 미리 정리해 보겠습니다. 1. 훈련 데이터에 대한 이해 앞으로 배우게 될 텍스트 분류 작업은 지도 학습(Supervised Learning)에 속합니다. 지도 학습의 훈련 데이터는 레이블이라는 이름의 미리 정답이 적혀있는 데이터로 구성되어 있습니다. 쉽게 비유하면, 기계는 정답이 적혀져 있는 문제지를 열심히 공부하고, 향후에 정답이 없는 문제에 대해서도 정답을 예측해서 대답하게 되는 메커니즘입니다. 예를 들어 스팸 메일 분류기의 훈련 데이터 같은 경우에는 메일의 내용과 해당 메일이 정상 메일인지, 스팸 메일인지 적혀있는 레이블로 구성돼 있습니다. 아래와 같은<NAME>의 메일 샘플이 약 20,000개 있다고 가정해 봅시다. 텍스트(메일의 내용) 레이블(스팸 여부) 당신에게 드리는 마지막 혜택! ... 스팸 메일 내일 뵐 수 있을지 확인 부탁... 정상 메일 쉿! 혼자 보세요... 스팸 메일 언제까지 답장 가능할... 정상 메일 ... ... (광고) 멋있어질 수 있는... 스팸 메일 20,000개의 메일 샘플을 가진 이 데이터는 메일의 내용을 담고 있는 텍스트 데이터와 이 데이터가 스팸 메일인지 아닌지가 적혀있는 레이블. 두 가지 열로 이루어져 있습니다. 기계는 이 20,000개의 메일 샘플 데이터를 학습하게 되는데, 만약 데이터가 깔끔하고 모델 또한 잘 설계돼 있다면 학습이 다 된 이 모델은 훈련 데이터에서는 없었던 어떤 메일 텍스트가 주어졌을 때 레이블을 예측하게 됩니다. 2. 훈련 데이터와 테스트 데이터 위에서는 20,000개의 메일 샘플을 전부 훈련에 사용한다고 했지만 사실 갖고 있는 전체 데이터를 전부 훈련에 사용하는 것보다는 테스트용으로 일부는 남겨놓는 것으로 바람직합니다. 예를 들어서 20,000개의 샘플 중에서 18,000개의 샘플은 훈련용으로 사용하고, 2,000개의 샘플은 테스트용으로 보류한 채 훈련을 시킬 때는 사용하지 않을 수 있습니다. 그러고 나서 18,000개의 샘플로 모델이 훈련이 다 되면, 이제 보류해두었던 2,000개의 테스트용 샘플에서 레이블은 보여주지 않고 모델에게 맞춰보라고 요구한 뒤, 정확도를 확인해 볼 수 있습니다. 2,000개의 샘플에도 레이블이 있으므로 모델이 실제로 정답을 얼마나 맞추는지 정답률을 계산하게 됩니다. 뒤에 나오게 될 예제에서는 갖고 있는 데이터에서 분류하고자 하는 텍스트 데이터의 열을 X, 레이블 데이터의 열을 y라고 명명합니다. 그리고 이를 훈련 데이터(X_train, y_train)와 테스트 데이터(X_test, y_test)로 분리합니다. 모델은 X_train과 y_train을 학습하고, X_test에 대해서 레이블을 예측하게 됩니다. 그리고 모델이 예측한 레이블과 y_test를 비교해서 정답률을 계산하게 됩니다. 3. 단어에 대한 인덱스 부여 앞서 워드 임베딩 챕터에서 단어를 밀집 벡터(dense vector)로 바꾸는 워드 임베딩에 대해서 배운 바 있습니다. 8챕터와 9챕터에서 설명하였지만, 파이 토치(PyTorch)의 nn.Embedding()은 단어 각각에 대해 정수가 매핑된 입력에 대해서 임베딩 작업을 수행할 수 있게 해줍니다. 단어 각각에 숫자 매핑, 인덱스를 부여하는 방법으로는 정수 인코딩 챕터에서와 같이 단어를 빈도수 순대로 정렬하고 순차적으로 인덱스를 부여하는 방법이 있습니다. 로이터 뉴스 분류하기와 IMDB 리뷰 감성 분류하기 챕터에서도 이 방법을 사용하였으며, 해당 챕터에서 사용할 데이터들은 이미 이 작업이 끝난 상태입니다. 등장 빈도 순대로 단어를 정렬하여 인덱스를 부여하였을 때의 장점은 등장 빈도수가 적은 단어의 제거입니다. 예를 들어서 25,000개의 단어가 있다고 가정하고, 해당 단어를 등장 빈도수 순가 높은 순서로 1부터 25,000까지 인덱스를 부여했다고 해보겠습니다. 이렇게 되면 등장 빈도수 순대로 등수가 부여된 것과 다름없기 때문에 전처리 작업에서 1,000을 넘는 인덱스를 가진 단어들을 제거시켜버리면 등장 빈도수 상위 1,000개의 단어만 남길 수 있습니다. 4. RNN으로 분류하기 # 실제 RNN 은닉층을 추가하는 코드. nn.RNN(input_size, hidden_size, batch_first=True) 텍스트 분류 관점에서 앞서 배운 RNN 코드의 timesteps와 input_dim, 그리고 hidden_size를 해석해 보면 다음과 같습니다. (위의 코드에서는 바닐라 RNN을 사용했지만, RNN의 변형인 LSTM이나 GRU도 아래의 사항은 동일합니다.) hidden_size = 출력의 크기(output_dim). timesteps = 시점의 수 = 각 문서에서의 단어 수. input_size = 입력의 크기 = 각 단어의 벡터 표현의 차원 수. 5. RNN의 다-대-일(Many-to-One) 문제 텍스트 분류는 RNN의 다-대-일(Many-to-One) 문제에 속합니다. 즉, 텍스트 분류는 모든 시점(time step)에 대해서 입력을 받지만 최종 시점의 RNN 셀 만이 은닉 상태를 출력하고, 이것이 출력층으로 가서 활성화 함수를 통해 정답을 고르는 문제가 됩니다. 이때 두 개의 선택지 중에서 정답를 고르는 이진 분류(Binary Classification) 문제라고 하며, 세 개 이상의 선택지 중에서 정답을 고르는 다중 클래스 분류(Multi-Class Classification) 문제라고 합니다. 이 두 문제에서는 각각 문제에 맞는 다른 활성화 함수와 손실 함수를 사용할 것입니다. 이진 분류의 문제의 경우 출력층의 활성화 함수로 시그모이드 함수를, 다중 클래스 문제라면 출력층의 활성화 함수로 소프트맥스 함수를 사용합니다. 또한, 다중 클래스 분류 문제의 경우에는 클래스가 N 개라면 출력층에 해당되는 밀집층(dense layer)의 크기는 N으로 합니다. 즉, 출력층의 뉴런의 수는 N 개입니다. (하지만 소프트맥스 함수로 이진 분류를 할 수도 있습니다. 출력층에 뉴런을 2개로 배치하면 됩니다.) 13-02 LSTM을 이용한 네이버 영화 리뷰 분류 이번에 사용할 데이터는 네이버 영화 리뷰 데이터입니다. 총 200,000개 리뷰로 구성된 데이터로 영화 리뷰에 대한 텍스트와 해당 리뷰가 긍정인 경우 1, 부정인 경우 0을 표시한 레이블로 구성돼 있습니다. 해당 데이터를 다운로드해 감성 분류를 수행하는 모델을 만들어보겠습니다. 1. 네이버 영화 리뷰 데이터에 대한 이해와 전처리 데이터 다운로드 링크 : https://github.com/e9t/nsmc/ import pickle import pandas as pd import numpy as np import matplotlib.pyplot as plt import re import urllib.request from konlpy.tag import Mecab from tqdm import tqdm from sklearn.model_selection import train_test_split from collections import Counter 1) 데이터 로드하기 위 링크로부터 훈련 데이터에 해당하는 ratings_train.txt와 테스트 데이터에 해당하는 ratings_test.txt를 다운로드합니다. urllib.request.urlretrieve("https://raw.githubusercontent.com/e9t/nsmc/master/ratings_train.txt", filename="ratings_train.txt") urllib.request.urlretrieve("https://raw.githubusercontent.com/e9t/nsmc/master/ratings_test.txt", filename="ratings_test.txt") pandas를 이용하여 훈련 데이터는 train_data에 테스트 데이터는 test_data에 저장합니다. train_data = pd.read_table('ratings_train.txt') test_data = pd.read_table('ratings_test.txt') train_data에 존재하는 영화 리뷰의 개수를 확인해 봅시다. print('훈련용 리뷰 개수 :',len(train_data)) # 훈련용 리뷰 개수 출력 훈련용 리뷰 개수 : 150000 train_data는 총 150,000개의 리뷰가 존재합니다. 상위 5개의 샘플을 출력해 봅시다. train_data[:5] # 상위 5개 출력 해당 데이터는 id, document, label 총 3개의 열로 구성돼 있습니다. id는 감성 분류를 수행하는 데 도움이 되지 않으므로 앞으로 무시합니다. 결국 이 모델은 리뷰 내용을 담고 있는 document와 해당 리뷰가 긍정(1), 부정(0)인지를 나타내는 label 두 개의 열을 학습하는 모델이 되어야 합니다. 또한 단지 상위 5개의 샘플만 출력해 보았지만 한국어 데이터와 영어 데이터의 차이를 확인할 수 있습니다. 예를 들어, 인덱스 2번 샘플은 띄어쓰기를 하지 않아도 글을 쉽게 이해할 수 있는 한국어의 특성으로 인해 띄어쓰기가 되어있지 않습니다. test_data의 리뷰 개수와 상위 5개의 샘플을 확인해 봅시다. print('테스트용 리뷰 개수 :',len(test_data)) # 테스트용 리뷰 개수 출력 테스트용 리뷰 개수 : 50000 test_data는 총 50,000개의 영화 리뷰가 존재합니다. 상위 5개의 샘플을 출력해 봅시다. test_data[:5] test_data도 train_data와 동일한<NAME>으로 id, document, label 3개의 열로 구성돼 있습니다. 2) 데이터 정제하기 train_data의 데이터 중복 유무를 확인합니다. # document 열과 label 열의 중복을 제외한 값의 개수 train_data['document'].nunique(), train_data['label'].nunique() (146182, 2) 총 150,000개의 샘플이 존재하는데 document 열에서 중복을 제거한 샘플의 개수가 146,182개라는 것은 약 4,000개의 중복 샘플이 존재한다는 의미입니다. label 열은 0 또는 1의 두 가지 값만을 가지므로 2가 출력됩니다. 중복 샘플을 제거합니다. # document 열의 중복 제거 train_data.drop_duplicates(subset=['document'], inplace=True) 중복 샘플을 제거하였습니다. 중복이 제거되었는지 전체 샘플 수를 확인합니다. print('총 샘플의 수 :',len(train_data)) 총 샘플의 수 : 146183 중복 샘플이 제거되었습니다. train_data에서 해당 리뷰의 긍, 부정 유무가 기재되어 있는 레이블(label) 값의 분포를 보겠습니다. train_data['label'].value_counts().plot(kind = 'bar') 앞서 확인하였듯이 약 146,000개의 영화 리뷰 샘플이 존재하는데 그래프 상으로 긍정과 부정 둘 다 약 72,000개의 샘플이 존재하여 레이블의 분포가 균일한 것처럼 보입니다. 정확하게 몇 개인지 확인해 봅시다. print(train_data.groupby('label').size().reset_index(name = 'count')) label count 0 0 73342 1 1 72841 레이블이 0인 리뷰가 근소하게 많습니다. 리뷰 중에 Null 값을 가진 샘플이 있는지 확인합니다. print(train_data.isnull().values.any()) True True가 나왔다면 데이터 중에 Null 값을 가진 샘플이 존재한다는 의미입니다. 어떤 열에 존재하는지 확인해 봅시다. print(train_data.isnull().sum()) id 0 document 1 label 0 dtype: int64 리뷰가 적혀있는 document 열에서 Null 값을 가진 샘플이 총 1개가 존재한다고 합니다. 그렇다면 document 열에서 Null 값이 존재한다는 것을 조건으로 Null 값을 가진 샘플이 어느 인덱스의 위치에 존재하는지 한 번 출력해 봅시다. train_data.loc[train_data.document.isnull()] 출력 결과는 위와 같습니다. Null 값을 가진 샘플을 제거하겠습니다. train_data = train_data.dropna(how = 'any') # Null 값이 존재하는 행 제거 print(train_data.isnull().values.any()) # Null 값이 존재하는지 확인 False Null 값을 가진 샘플이 제거되었습니다. 다시 샘플의 개수를 출력하여 1개의 샘플이 제거되었는지 확인해 봅시다. print(len(train_data)) 146182 데이터의 전처리를 수행해 보겠습니다. 위의 train_data와 test_data에서 온점(.)이나? 와 같은 각종 특수문자가 사용된 것을 확인했습니다. train_data로부터 한글만 남기고 제거하기 위해서 정규 표현식을 사용해 보겠습니다. 우선 영어를 예시로 정규 표현식을 설명해 보겠습니다. 영어의 알파벳들을 나타내는 정규 표현식은 [a-zA-Z]입니다. 이 정규 표현식은 영어의 소문자와 대문자들을 모두 포함하고 있는 정규 표현식으로 이를 응용하면 영어에 속하지 않는 구두점이나 특수문자를 제거할 수 있습니다. 예를 들어 알파벳과 공백을 제외하고 모두 제거하는 전처리를 수행하는 예제는 다음과 같습니다. #알파벳과 공백을 제외하고 모두 제거 eng_text = 'do!!! you expect... people~ to~ read~ the FAQ, etc. and actually accept hard~! atheism?@@' print(re.sub(r'[^a-zA-Z ]', '', eng_text)) 'do you expect people to read the FAQ etc and actually accept hard atheism' 위와 같은 원리를 한국어 데이터에 적용하고 싶다면, 우선 한글을 범위 지정할 수 있는 정규 표현식을 찾아내면 되겠습니다. 우선 자음과 모음에 대한 범위를 지정해 보겠습니다. 일반적으로 자음의 범위는 ㄱ ~ ㅎ, 모음의 범위는 ㅏ ~ ㅣ와 같이 지정할 수 있습니다. 해당 범위 내에 어떤 자음과 모음이 속하는지 알고 싶다면 아래의 링크를 참고하시기 바랍니다. 링크 : https://www.unicode.org/charts/PDF/U3130.pdf ㄱ ~ ㅎ: 3131 ~ 314E ㅏ ~ ㅣ: 314F ~ 3163 완성형 한글의 범위는 가 ~ 힣과 같이 사용합니다. 해당 범위 내에 포함된 음절들은 아래의 링크에서 확인할 수 있습니다. 링크 : https://www.unicode.org/charts/PDF/UAC00.pdf 위 범위 지정을 모두 반영하여 train_data에 한글과 공백을 제외하고 모두 제거하는 정규 표현식을 수행해 봅시다. # 한글과 공백을 제외하고 모두 제거 train_data['document'] = train_data['document'].str.replace("[^ㄱ-ㅎㅏ-ㅣ가-힣 ]","") train_data[:5] 상위 5개의 샘플을 다시 출력해 보았는데, 정규 표현식을 수행하자 기존의 공백. 즉, 띄어쓰기는 유지되면서 온점과 같은 구두점 등은 제거되었습니다. 사실 네이버 영화 리뷰는 한글이 아니더라도 영어, 숫자, 특수문자로도 리뷰를 업로드할 수 있습니다. 다시 말해 기존에 한글이 없는 리뷰였다면 더 이상 아무런 값도 없는 빈(empty) 값이 되었을 것입니다. train_data에 공백(whitespace)만 있거나 빈 값을 가진 행이 있다면 Null 값으로 변경하도록 하고, Null 값이 존재하는지 확인해 보겠습니다. train_data['document'] = train_data['document'].str.replace('^ +', "") # white space 데이터를 empty value로 변경 train_data['document'].replace('', np.nan, inplace=True) print(train_data.isnull().sum()) id 0 document 789 label 0 dtype: int64 Null 값이 789개나 새로 생겼습니다. Null 값이 있는 행을 5개만 출력해 볼까요? train_data.loc[train_data.document.isnull()][:5] Null 샘플들은 레이블이 긍정일 수도 있고, 부정일 수도 있습니다. 아무런 의미도 없는 데이터므로 제거해 줍니다. train_data = train_data.dropna(how = 'any') print(len(train_data)) 145393 샘플 개수가 또다시 줄어서 145,393개가 남았습니다. 테스트 데이터에 앞서 진행한 전처리 과정을 동일하게 진행합니다. test_data.drop_duplicates(subset = ['document'], inplace=True) # document 열에서 중복인 내용이 있다면 중복 제거 test_data['document'] = test_data['document'].str.replace("[^ㄱ-ㅎㅏ-ㅣ가-힣 ]","") # 정규 표현식 수행 test_data['document'] = test_data['document'].str.replace('^ +', "") # 공백은 empty 값으로 변경 test_data['document'].replace('', np.nan, inplace=True) # 공백은 Null 값으로 변경 test_data = test_data.dropna(how='any') # Null 값 제거 print('전처리 후 테스트용 샘플의 개수 :',len(test_data)) 전처리 후 테스트용 샘플의 개수 : 48852 3) 토큰화 토큰화를 진행해 봅시다. 토큰화 과정에서 불용어를 제거하겠습니다. 불용어는 정의하기 나름인데, 한국어의 조사, 접속사 등의 보편적인 불용어를 사용할 수도 있겠지만 결국 풀고자 하는 문제의 데이터를 지속 검토하면서 계속해서 추가하는 경우 또한 많습니다. 실제 현업인 상황이라면 일반적으로 아래의 불용어보다 더 많은 불용어를 사용할 수 있습니다. stopwords = ['도', '는', '다', '의', '가', '이', '은', '한', '에', '하', '고', '을', '를', '인', '듯', '과', '와', '네', '들', '듯', '지', '임', '게'] 여기서는 위 정도로만 불용어를 정의하고, 토큰화를 위한 형태소 분석기는 KoNLPy의 Mecab을 사용합니다. Mecab을 복습해 봅시다. mecab = Mecab() mecab.morphs('와 이런 것도 영화라고 차라리 뮤직비디오를 만드는 게 나을 뻔') ['와', '이런', '것', '도', '영화', '라고', '차라리', '뮤직', '비디오', '를', '만드', '는', '게', '나을', '뻔' 한국어을 토큰화할 때는 영어처럼 띄어쓰기 기준으로 토큰화를 하는 것이 아니라, 주로 형태소 분석기를 사용한다고 언급한 바 있습니다. train_data에 형태소 분석기를 사용하여 토큰화를 하면서 불용어를 제거하여 X_train에 저장합니다. X_train = [] for sentence in tqdm(train_data['document']): tokenized_sentence = mecab.morphs(sentence) # 토큰화 stopwords_removed_sentence = [word for word in tokenized_sentence if not word in stopwords] # 불용어 제거 X_train.append(stopwords_removed_sentence) 상위 3개의 샘플만 출력하여 결과를 확인해 봅시다. print(X_train[:3]) [['아', '더', '빙', '진짜', '짜증', '나', '네요', '목소리'], ['흠', '포스터', '보고', '초등학생', '영화', '줄', '오버', '연기', '조차', '가볍', '안', '구나'], ['너무', '재', '밓었다그래서보는것을추천한다']] 토큰 화가 진행된 것을 볼 수 있습니다. 테스트 데이터에 대해서도 동일하게 토큰화를 해줍니다. X_test = [] for sentence in tqdm(test_data['document']): tokenized_sentence = okt.morphs(sentence, stem=True) # 토큰화 stopwords_removed_sentence = [word for word in tokenized_sentence if not word in stopwords] # 불용어 제거 X_test.append(stopwords_removed_sentence) 지금까지 훈련 데이터와 테스트 데이터에 대해서 텍스트 전처리를 진행해 보았습니다. 이제 학습 데이터와 검증 데이터, 그리고 테스트 데이터를 준비해 보겠습니다. 4) 학습 데이터, 검증 데이터, 테스트 데이터 이미 학습 데이터와 테스트 데이터는 준비되었지만 학습하는 동안의 성능 평가를 진행할 검증 데이터가 추가로 필요합니다. 데이터 프레임의 레이블 열을 별도로 분리하여 y_train과 y_test로 저장해 줍니다. 이제 학습 데이터는 X_train, y_train에 저장되고, 테스트 데이터는 X_test, y_test에 저장이 될 것입니다. 학습 데이터 중에서 20%를 분할하여 추가로 검증 데이터를 만들어줍니다. 머신 러닝 문제를 풀 때, 데이터의 분리는 주로 사이킷런에서 제공하는 train_test_split을 사용해 진행합니다. test_size에 비율을 넣어주면 기존 데이터에 대해서 해당 비율만큼 일부 데이터를 분할하여 반환합니다. 랜덤으로 분할하는 과정에서 레이블 불균형이 발생하지 않도록, 레이블의 균형 비율을 유지하면서 분할하고 싶다면 분할 시 기존 데이터의 y 데이터를 stratify의 값으로 사용하면 됩니다. y_train = np.array(train_data['label']) y_test = np.array(test_data['label']) X_train, X_valid, y_train, y_valid = train_test_split(X_train, y_train, test_size=0.2, random_state=0, stratify=y_train) 실제로 비율이 잘 유지되면서 분할되었는지 확인해 봅시다. print('--------학습 데이터의 비율-----------') print(f'부정 리뷰 = {round(np.sum(y_train==0)/len(y_train) * 100,3)}%') print(f'긍정 리뷰 = {round(np.count_nonzero(y_train)/len(y_train) * 100,3)}%') print('--------검증 데이터의 비율-----------') print(f'부정 리뷰 = {round(np.sum(y_valid==0)/len(y_valid) * 100,3)}%') print(f'긍정 리뷰 = {round(np.count_nonzero(y_valid)/len(y_valid) * 100,3)}%') print('--------테스트 데이터의 비율-----------') print(f'부정 리뷰 = {round(np.sum(y_test==0)/len(y_test) * 100,3)}%') print(f'긍정 리뷰 = {round(np.count_nonzero(y_test)/len(y_test) * 100,3)}%') --------학습 데이터의 비율----------- 부정 리뷰 = 50.238% 긍정 리뷰 = 49.762% --------검증 데이터의 비율----------- 부정 리뷰 = 50.239% 긍정 리뷰 = 49.761% --------테스트 데이터의 비율----------- 부정 리뷰 = 49.808% 긍정 리뷰 = 50.192% 분할 후에도 학습 데이터와 검증 데이터의 레이블 비율이 동일한 것을 확인할 수 있습니다. 5) 단어 집합 만들기 word_list = [] for sent in X_train: for word in sent: word_list.append(word) word_counts = Counter(word_list) print('총 단어 수 :', len(word_counts)) 총 단어 수 : 45296 print('훈련 데이터에서의 단어 영화의 등장 횟수 :', word_counts['영화']) print('훈련 데이터에서의 단어 공감의 등장 횟수 :', word_counts['공감']) 훈련 데이터에서의 단어 영화의 등장 횟수 : 45791 훈련 데이터에서의 단어 공감의 등장 횟수 : 756 vocab = sorted(word_counts, key=word_counts.get, reverse=True) print('등장 빈도수 상위 10개 단어') print(vocab[:10]) 등장 빈도수 상위 10개 단어 ['영화', '보', '있', '없', '좋', '나', '었', '만', '는데', '너무'] threshold = 3 total_cnt = len(word_counts) # 단어의 수 rare_cnt = 0 # 등장 빈도수가 threshold보다 작은 단어의 개수를 카운트 total_freq = 0 # 훈련 데이터의 전체 단어 빈도수 총합 rare_freq = 0 # 등장 빈도수가 threshold보다 작은 단어의 등장 빈도수의 총합 # 단어와 빈도수의 쌍(pair)을 key와 value로 받는다. for key, value in word_counts.items(): total_freq = total_freq + value # 단어의 등장 빈도수가 threshold보다 작으면 if(value < threshold): rare_cnt = rare_cnt + 1 rare_freq = rare_freq + value print('단어 집합(vocabulary)의 크기 :',total_cnt) print('등장 빈도가 %s 번 이하인 희귀 단어의 수: %s'%(threshold - 1, rare_cnt)) print("단어 집합에서 희귀 단어의 비율:", (rare_cnt / total_cnt)*100) print("전체 등장 빈도에서 희귀 단어 등장 빈도 비율:", (rare_freq / total_freq)*100) 단어 집합(vocabulary)의 크기 : 45296 등장 빈도가 2번 이하인 희귀 단어의 수: 26105 단어 집합에서 희귀 단어의 비율: 57.63202048746025 전체 등장 빈도에서 희귀 단어 등장 빈도 비율: 2.2769635638286716 # 전체 단어 개수 중 빈도수 2이하인 단어는 제거. vocab_size = total_cnt - rare_cnt vocab = vocab[:vocab_size] print('단어 집합의 크기 :', len(vocab)) 단어 집합의 크기 : 19191 word_to_index = {} word_to_index['<PAD>'] = 0 word_to_index['<UNK>'] = 1 for index, word in enumerate(vocab) : word_to_index[word] = index + 2 vocab_size = len(word_to_index) print('패딩 토큰과 UNK 토큰을 고려한 단어 집합의 크기 :', vocab_size) 패딩 토큰과 UNK 토큰을 고려한 단어 집합의 크기 : 19193 print('단어 <PAD>와 매핑되는 정수 :', word_to_index['<PAD>']) print('단어 <UNK>와 매핑되는 정수 :', word_to_index['<UNK>']) print('단어 영화와 매핑되는 정수 :', word_to_index['영화']) 단어 <PAD>와 매핑되는 정수 : 0 단어 <UNK>와 매핑되는 정수 : 1 단어 영화와 매핑되는 정수 : 2 6) 정수 인코딩 def texts_to_sequences(tokenized_X_data, word_to_index): encoded_X_data = [] for sent in tokenized_X_data: index_sequences = [] for word in sent: try: index_sequences.append(word_to_index[word]) except KeyError: index_sequences.append(word_to_index['<UNK>']) encoded_X_data.append(index_sequences) return encoded_X_data encoded_X_train = texts_to_sequences(X_train, word_to_index) encoded_X_valid = texts_to_sequences(X_valid, word_to_index) encoded_X_test = texts_to_sequences(X_test, word_to_index) # 상위 샘플 2개 출력 for sent in encoded_X_train[:2]: print(sent) [924, 1866, 128, 7, 80, 48, 34] [2415, 3138, 4, 2095, 422, 87, 5768, 19, 307] index_to_word = {} for key, value in word_to_index.items(): index_to_word[value] = key decoded_sample = [index_to_word[word] for word in encoded_X_train[0]] print('기존의 첫 번째 샘플 :', X_train[0]) print('복원된 첫 번째 샘플 :', decoded_sample) 기존의 첫 번째 샘플 : ['이야', '어쩜', '이렇게', '나', '지루', '할', '수'] 복원된 첫 번째 샘플 : ['이야', '어쩜', '이렇게', '나', '지루', '할', '수'] 7) 패딩 print('리뷰의 최대 길이 :',max(len(review) for review in encoded_X_train)) print('리뷰의 평균 길이 :',sum(map(len, encoded_X_train))/len(encoded_X_train)) plt.hist([len(review) for review in encoded_X_train], bins=50) plt.xlabel('length of samples') plt.ylabel('number of samples') plt.show() 리뷰의 최대 길이 : 74 리뷰의 평균 길이 : 12.296731261928917 그림 def below_threshold_len(max_len, nested_list): count = 0 for sentence in nested_list: if(len(sentence) <= max_len): count = count + 1 print('전체 샘플 중 길이가 %s 이하인 샘플의 비율: %s'%(max_len, (count / len(nested_list))*100)) max_len = 30 below_threshold_len(max_len, X_train) 전체 샘플 중 길이가 30 이하인 샘플의 비율: 92.49703389101914 def pad_sequences(sentences, max_len): features = np.zeros((len(sentences), max_len), dtype=int) for index, sentence in enumerate(sentences): if len(sentence) != 0: features[index, :len(sentence)] = np.array(sentence)[:max_len] return features padded_X_train = pad_sequences(encoded_X_train, max_len=max_len) padded_X_valid = pad_sequences(encoded_X_valid, max_len=max_len) padded_X_test = pad_sequences(encoded_X_test, max_len=max_len) print('훈련 데이터의 크기 :', padded_X_train.shape) print('검증 데이터의 크기 :', padded_X_valid.shape) print('테스트 데이터의 크기 :', padded_X_test.shape) 훈련 데이터의 크기 : (116314, 30) 검증 데이터의 크기 : (29079, 30) 테스트 데이터의 크기 : (48852, 30) print('첫 번째 샘플의 길이 :', len(padded_X_train[0])) print('첫 번째 샘플 :', padded_X_train[0]) 첫 번째 샘플의 길이 : 30 첫 번째 샘플 : [ 924 1866 128 7 80 48 34 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] 2. LSTM을 이용한 네이버 영화 리뷰 분류 모델 이제 딥 러닝 프레임워크 PyTorch를 이용하여 LSTM 모델을 구현해 봅시다. import torch import torch.nn as nn import torch.nn.functional as F 현재 실습 환경에서 GPU를 사용 가능한지 확인합니다. USE_CUDA = torch.cuda.is_available() device = torch.device("cuda" if USE_CUDA else "cpu") print("cpu와 cuda 중 다음 기기로 학습함:", device) cpu와 cuda 중 다음 기기로 학습함: cuda 저자의 경우 Colab에서 GPU를 선택하여 실습을 진행하여 cuda라는 출력 결과를 확인했습니다. 레이블 데이터를 파이 토치의 텐서 타입으로 변환합니다. 이후 훈련 데이터의 상위 5개의 레이블을 출력해 보았습니다. train_label_tensor = torch.tensor(np.array(y_train)) valid_label_tensor = torch.tensor(np.array(y_valid)) test_label_tensor = torch.tensor(np.array(y_test)) print(train_label_tensor[:5]) tensor([1, 1, 0, 0, 0]) 이제 LSTM 모델을 클래스로 구현해 봅시다. 각 층을 지날 때마다 각 층의 출력의 크기를 이해하는 것이 중요합니다. 예를 들어 입력은 (배치 크기, 문장 길이)의 크기를 가지는 텐서입니다. 임베딩 층을 지나고 나면 각 단어가 임베딩 벡터로 변환되면서 (배치 크기, 문장 길이, 임베딩 벡터의 차원)으로 텐서의 크기가 변환됩니다. 이후 LSTM의 마지막 시점의 은닉 상태(hidden state) 값을 출력층과 연결시키는 작업을 해주어야 합니다. 이때 LSTM이 출력층으로 보는 결괏값의 차원은 (배치 크기, 은닉 상태의 차원)을 가져야 합니다. 마지막 시점의 은닉 상태의 값만 전달하므로 은닉 상태는 모든 시점(문장 길이) 만큼 존재하는 것이 아니라 단 하나만 있습니다. 출력층은 지난 결과는 소프트맥스 회귀를 수행하므로 (배치 크기, 분류하고자 하는 카테고리의 수)의 차원을 가지게 됩니다. 그 후 각 데이터를 배치 단위로 데이터 묶음을 꺼낼 수 있는 데이터 로더로 전달합니다. 정리하면 다음과 같습니다. 아직 모델을 만들지는 않았지만, 단어 벡터의 차원을 100, 배치 크기를 32, 문장 길이를 500(패딩 후), LSTM의 은닉 상태의 차원을 128로 한다고 가정해 보겠습니다. - 단어 벡터의 차원 = 100 - 문장 길이 = 500 - 배치 크기 = 32 - 데이터 개수 = 2만 - LSTM의 은닉층의 크기 = 128 - 분류하고자 하는 카테고리 개수 = 2개 위의 정보들을 고려하였을 때 모델 내부에서 데이터의 변화는 다음과 같습니다. (32, 500) => 입력 데이터의 형태 => 임베딩 층 통과 후 => (32, 500, 100) => LSTM 통과 후 => (32, 128) => Softmax 출력층 통과 후 => (32, 2) class TextClassifier(nn.Module): def __init__(self, vocab_size, embedding_dim, hidden_dim, output_dim): super(TextClassifier, self).__init__() self.embedding = nn.Embedding(vocab_size, embedding_dim) self.lstm = nn.LSTM(embedding_dim, hidden_dim, batch_first=True) self.fc = nn.Linear(hidden_dim, output_dim) def forward(self, x): # x: (batch_size, seq_length) embedded = self.embedding(x) # (batch_size, seq_length, embedding_dim) # LSTM은 (hidden state, cell state)의 튜플을 반환합니다 lstm_out, (hidden, cell) = self.lstm(embedded) # lstm_out: (batch_size, seq_length, hidden_dim), hidden: (1, batch_size, hidden_dim) last_hidden = hidden.squeeze(0) # (batch_size, hidden_dim) logits = self.fc(last_hidden) # (batch_size, output_dim) return logits 훈련 데이터, 검증 데이터, 테스트 데이터에 대해서 파이 토치 텐서로 변환하고 배치 단위 연산을 위해 데이터 로더로 변환합니다. encoded_train = torch.tensor(padded_X_train).to(torch.int64) train_dataset = torch.utils.data.TensorDataset(encoded_train, train_label_tensor) train_dataloader = torch.utils.data.DataLoader(train_dataset, shuffle=True, batch_size=32) encoded_test = torch.tensor(padded_X_test).to(torch.int64) test_dataset = torch.utils.data.TensorDataset(encoded_test, test_label_tensor) test_dataloader = torch.utils.data.DataLoader(test_dataset, shuffle=True, batch_size=1) encoded_valid = torch.tensor(padded_X_valid).to(torch.int64) valid_dataset = torch.utils.data.TensorDataset(encoded_valid, valid_label_tensor) valid_dataloader = torch.utils.data.DataLoader(valid_dataset, shuffle=True, batch_size=1) 훈련 데이터의 샘플 개수가 116,314개였으므로 배치 크기를 32로 할 경우에는 116,324/32=3,635 다시 말해 32개씩 묶인 데이터 묶음이 3,635개가 생깁니다. 그리고 학습 시에는 32개씩 데이터가 들어가게 될 것입니다. total_batch = len(train_dataloader) print('총 배치의 수 : {}'.format(total_batch)) 총 배치의 수 : 3635 모델 객체를 선언합니다. embedding_dim = 100 hidden_dim = 128 output_dim = 2 learning_rate = 0.01 num_epochs = 10 model = TextClassifier(vocab_size, embedding_dim, hidden_dim, output_dim) model.to(device) 임베딩 벡터의 차원은 128, 출력층의 크기(분류해야 할 카테고리의 개수)는 2로 정했습니다. 이렇게 사용자가 정해주는 값이면서 모델의 결과에 영향을 미치는 값들을 하이퍼 파라미터라고 합니다. 소프트맥스 회귀를 통해 분류 문제를 진행하므로 손실 함수는 nn.CrossEntropyLoss()를 사용합니다. 파이 토치로 자연어 처리를 하게 되면 가장 많이 사용하게 되는 손실 함수입니다. 하이퍼 파라미터 중 하나인 학습률(learning rate)는 0.001로 정했습니다. criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=0.001) 3. 평가 코드 작성 이후 평가를 진행하기 위해서 모델의 정확도를 측정하는 함수 calculate_accuracy()를 작성합니다. def calculate_accuracy(logits, labels): # _, predicted = torch.max(logits, 1) predicted = torch.argmax(logits, dim=1) correct = (predicted == labels).sum().item() total = labels.size(0) accuracy = correct / total return accuracy 검증 데이터와 테스트 데이터에 대한 성능을 측정하기 위한 함수 evaluate()를 작성합니다. 아래의 함수에서 model.eval()과 with torch.no_grad()를 짚어봅시다. 이 두 개는 모델 평가를 수행할 때 중요한 역할을 합니다. 각각의 의미는 다음과 같습니다. model.eval(): 모델을 평가 모드로 설정합니다. 이렇게 하면 모델 내부의 모든 레이어에 대해 평가 모드가 활성화됩니다. 일부 레이어, 예를 들어 드롭아웃이나 배치 정규화는 학습과 평가 시 다르게 동작하기 때문에 이 설정이 중요합니다. 평가 모드가 설정되지 않으면, 이러한 레이어의 동작이 올바르지 않을 수 있으며, 이로 인해 평가 결과가 제대로 나오지 않을 수 있습니다. with torch.no_grad(): 이 문장은 자동 미분 엔진에서 그래디 언트 계산을 비활성화합니다. 평가 중에는 기울기를 계산할 필요가 없으므로, 이렇게 설정하면 메모리를 절약하고 속도를 높일 수 있습니다. 만약 이 설정이 적용되지 않으면, 평가 과정에서 그래디 언트가 계산되고 메모리를 차지하게 됩니다. 그러나 평가 결과 자체에는 직접적인 영향을 주지 않습니다. 따라서 model.eval()은 평가 시 반드시 사용해야 하며, 그렇지 않으면 평가 결과가 올바르게 나오지 않을 수 있습니다. with torch.no_grad():는 필수는 아니지만, 메모리와 속도 측면에서 권장됩니다. def evaluate(model, valid_dataloader, criterion, device): val_loss = 0 val_correct = 0 val_total = 0 model.eval() with torch.no_grad(): # 데이터 로더로부터 배치 크기만큼의 데이터를 연속으로 로드 for batch_X, batch_y in valid_dataloader: batch_X, batch_y = batch_X.to(device), batch_y.to(device) # 모델의 예측값 logits = model(batch_X) # 손실을 계산 loss = criterion(logits, batch_y) # 정확도와 손실을 계산함 val_loss += loss.item() val_correct += calculate_accuracy(logits, batch_y) * batch_y.size(0) val_total += batch_y.size(0) val_accuracy = val_correct / val_total val_loss /= len(valid_dataloader) return val_loss, val_accuracy 4. 학습 num_epochs = 5 # Training loop best_val_loss = float('inf') # Training loop for epoch in range(num_epochs): # Training train_loss = 0 train_correct = 0 train_total = 0 model.train() for batch_X, batch_y in train_dataloader: # Forward pass batch_X, batch_y = batch_X.to(device), batch_y.to(device) # batch_X.shape == (batch_size, max_len) logits = model(batch_X) # Compute loss loss = criterion(logits, batch_y) # Backward pass and optimization optimizer.zero_grad() loss.backward() optimizer.step() # Calculate training accuracy and loss train_loss += loss.item() train_correct += calculate_accuracy(logits, batch_y) * batch_y.size(0) train_total += batch_y.size(0) train_accuracy = train_correct / train_total train_loss /= len(train_dataloader) # Validation val_loss, val_accuracy = evaluate(model, valid_dataloader, criterion, device) print(f'Epoch {epoch+1}/{num_epochs}:') print(f'Train Loss: {train_loss:.4f}, Train Accuracy: {train_accuracy:.4f}') print(f'Validation Loss: {val_loss:.4f}, Validation Accuracy: {val_accuracy:.4f}') # 검증 손실이 최소일 때 체크포인트 저장 if val_loss < best_val_loss: print(f'Validation loss improved from {best_val_loss:.4f} to {val_loss:.4f}. 체크포인트를 저장합니다.') best_val_loss = val_loss torch.save(model.state_dict(), 'best_model_checkpoint.pth') 5. 모델 로드 및 평가 # 모델 로드 model.load_state_dict(torch.load('best_model_checkpoint.pth')) # 모델을 device에 올립니다. model.to(device) # 검증 데이터에 대한 정확도와 손실 계산 val_loss, val_accuracy = evaluate(model, valid_dataloader, criterion, device) print(f'Best model validation loss: {val_loss:.4f}') print(f'Best model validation accuracy: {val_accuracy:.4f}') Best model validation loss: 0.3392 Best model validation accuracy: 0.8490 # 테스트 데이터에 대한 정확도와 손실 계산 test_loss, test_accuracy = evaluate(model, test_dataloader, criterion, device) print(f'Best model test loss: {test_loss:.4f}') print(f'Best model test accuracy: {test_accuracy:.4f}') Best model test loss: 0.3435 Best model test accuracy: 0.8492 6. 모델 테스트 index_to_tag = {0 : '부정', 1 : '긍정'} def predict(text, model, word_to_index, index_to_tag): # Set the model to evaluation mode model.eval() # Tokenize the input text tokens = mecab.morphs(text) # 토큰화 tokens = [word for word in tokens if not word in stopwords] # 불용어 제거 token_indices = [word_to_index.get(token, 1) for token in tokens] # Convert tokens to tensor input_tensor = torch.tensor([token_indices], dtype=torch.long).to(device) # (1, seq_length) # Pass the input tensor through the model with torch.no_grad(): logits = model(input_tensor) # (1, output_dim) # Get the predicted class index predicted_index = torch.argmax(logits, dim=1) # Convert the predicted index to its corresponding tag predicted_tag = index_to_tag[predicted_index.item()] return predicted_tag test_input = "이 영화 개꿀 잼 ㅋㅋㅋ" predict(test_input, model, word_to_index, index_to_tag) 긍정 test_input = "이딴 게 영화냐 ㅉㅉ" predict(test_input, model, word_to_index, index_to_tag) 부정 test_input = "감독 뭐 하는 놈이냐?" predict(test_input, model, word_to_index, index_to_tag) 부정 test_input = "와 개쩐다 정말 세계관 최강자들의 영화다" predict(test_input, model, word_to_index, index_to_tag) 긍정 13-03 GRU를 이용한 IMDB 리뷰 분류하기 1D CNN을 이용하여 IMDB 영화 리뷰 데이터를 분류해 보겠습니다. 1. 데이터 로드 및 단어 토큰화 import pandas as pd import numpy as np import matplotlib.pyplot as plt import nltk import torch import urllib.request from tqdm import tqdm from collections import Counter from nltk.tokenize import word_tokenize from sklearn.model_selection import train_test_split nltk.download('punkt') urllib.request.urlretrieve("https://raw.githubusercontent.com/ukairia777/pytorch-nlp-tutorial/main/10.%20RNN%20Text%20Classification/dataset/IMDB%20Dataset.csv", filename="IMDB Dataset.csv") 영화 리뷰 데이터인 IMDB 리뷰 데이터를 로드합니다. df = pd.read_csv('IMDB Dataset.csv') df 데이터의 개수는 총 5만 개입니다. 데이터에 결측값이 있는지 확인할 수 있는 방법 중 하나는 데이터 프레임의 정보를 확인할 수 있는 info()를 사용하는 것입니다. df.info() <class 'pandas.core.frame.DataFrame'> RangeIndex: 50000 entries, 0 to 49999 Data columns (total 2 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 review 50000 non-null object 1 sentiment 50000 non-null object dtypes: object(2) memory usage: 781.4+ KB review 열과 sentiment 열 모두 non-null(결측값이 아닌) 데이터가 5만 개로 확인되므로 결측값은 없습니다. 결측값을 확인할 수 있는 또 다른 방법인. isnull().values.any()를 사용하여 결측값 여부를 확인합니다. print('결측값 여부 :',df.isnull().values.any()) 결측값 여부 : False False가 출력된다면 결측값은 없다는 의미입니다. 레이블이 균등한지 Bar Chart를 통해 확인합니다. df['sentiment'].value_counts().plot(kind='bar') 레이블의 실제 개수를 확인해 봅시다. print('레이블 개수') print(df.groupby('sentiment').size().reset_index(name='count')) 레이블 개수 sentiment count 0 negative 25000 1 positive 25000 두 레이블의 개수는 동일합니다. 레이블이 현재 'positive'와 'negative'로 구성돼 있으므로 각각 1, 0으로 변환하고 정상 변환되었는지 확인하기 위해서 상위 5개의 행을 출력합니다. df['sentiment'] = df['sentiment'].replace(['positive','negative'],[1, 0]) df.head() 긍정 레이블은 1, 부정 레이블은 0으로 변환된 것을 확인하였습니다. 'review' 열은 X_data, 레이블에 해당하는 'sentiment' 열은 y_data에 저장 후 정상 변환 되었는지 확인하기 위해서 다시 한번 개수를 출력합니다. X_data = df['review'] y_data = df['sentiment'] print('영화 리뷰의 개수: {}'.format(len(X_data))) print('레이블의 개수: {}'.format(len(y_data))) 영화 리뷰의 개수: 50000 레이블의 개수: 50000 훈련 데이터와 검증 데이터, 테스트 데이터로 데이터를 나눕니다. 우선 훈련 데이터와 테스트 데이터를 5:5 비율로 나누고, 훈련 데이터를 다시 8:2 비율로 훈련 데이터와 검증 데이터로 나눕니다. sklearn의 train_test_split은 데이터를 나눌 때 굉장히 많이 사용하는 도구이므로 꼭 기억해둡시다. 데이터를 나눌 때 레이블의 비율을 유지하고 싶다면 레이블 데이터를 stratify에 명시해 줄 수 있습니다. X_train, X_test, y_train, y_test = train_test_split(X_data, y_data, test_size=0.5, random_state=0, stratify=y_data) X_train, X_valid, y_train, y_valid = train_test_split(X_train, y_train, test_size=.2, random_state=0, stratify=y_train) print('--------훈련 데이터의 비율-----------') print(f'부정 리뷰 = {round(y_train.value_counts()[0]/len(y_train) * 100,3)}%') print(f'긍정 리뷰 = {round(y_train.value_counts()[1]/len(y_train) * 100,3)}%') print('--------검증 데이터의 비율-----------') print(f'부정 리뷰 = {round(y_valid.value_counts()[0]/len(y_valid) * 100,3)}%') print(f'긍정 리뷰 = {round(y_valid.value_counts()[1]/len(y_valid) * 100,3)}%') print('--------테스트 데이터의 비율-----------') print(f'부정 리뷰 = {round(y_test.value_counts()[0]/len(y_test) * 100,3)}%') print(f'긍정 리뷰 = {round(y_test.value_counts()[1]/len(y_test) * 100,3)}%') --------훈련 데이터의 비율----------- 부정 리뷰 = 50.0% 긍정 리뷰 = 50.0% --------검증 데이터의 비율----------- 부정 리뷰 = 50.0% 긍정 리뷰 = 50.0% --------테스트 데이터의 비율----------- 부정 리뷰 = 50.0% 긍정 리뷰 = 50.0% 훈련 데이터, 검증 데이터, 테스트 데이터 세 개의 데이터 모두 긍정 레이블과 부정 레이블 모두 50:50으로 레이블이 균등하게 유지된 채 분할된 것을 확인할 수 있습니다. 훈련 데이터, 검증 데이터, 테스트 데이터에 대해서 토큰화를 진행해 봅시다. 토큰화를 위해 토큰화 함수 tokenize()를 구현하였습니다. 토큰화 진행 시에 선택적으로 소문자화를 진행하고 싶다면 소문자화도 진행할 수 있습니다. 파이썬 문자열에. lower()를 사용하면 해당 문자열을 소문자로 바꿔줍니다. 해당 함수로 훈련 데이터, 검증 데이터, 테스트 데이터에 대해서 모두 토큰화를 진행합니다. def tokenize(sentences): tokenized_sentences = [] for sent in tqdm(sentences): tokenized_sent = word_tokenize(sent) tokenized_sent = [word.lower() for word in tokenized_sent] tokenized_sentences.append(tokenized_sent) return tokenized_sentences tokenized_X_train = tokenize(X_train) tokenized_X_valid = tokenize(X_valid) tokenized_X_test = tokenize(X_test) 토큰 화가 진행된 후의 훈련 데이터의 상위 2개 샘플을 출력해봅시다. # 상위 샘플 2개 출력 for sent in tokenized_X_train[:2]: print(sent) ['have', 'you', 'ever', ',', 'or', 'do', 'you', 'have', ',', 'a', 'pet', 'who', "'s", 'been', 'with', 'you', 'through', 'thick', 'and', 'thin', ',', 'who', 'you', "'d", 'be', 'lost', 'without', ',', 'and', 'who', 'you', 'love', 'no', 'matter', 'what', '?', 'betcha', 'never', 'thought', 'they', 'feel', 'the', 'same', 'way', 'about', 'you', '!', '<', 'br', '/', '>', '<', 'br', '/', '>', 'wonderful', ... 중략 ...] ['i', 'hate', 'football', '!', '!', 'i', 'hate', 'football', 'fans', '!', 'i', 'hate', 'cars', '!', 'but', 'this', 'film', 'was', 'the', 'funniest', 'thing', 'i', 'have', 'seen', 'in', 'quite', 'some', 'time', '.', '<', 'br', '/', '>', '<', 'br', '/', '>', 'i', 'was', 'given', 'the', 'great', 'opportunity', 'to', 'see', 'this', 'film', 'at', 'the', 'weekend', ',', 'and', 'all', 'i', 'have', 'to', 'say', 'is', 'i', ... 중략 ...] 정상적으로 토큰화된 것을 확인하였습니다. 결과가 너무 길어 책의 지면에서는 중략했습니다. 2. Vocab 만들기 이제 토큰화된 훈련 데이터로부터 정수 인코딩을 진행하기 위한 단어 집합(Vocabulary)을 만들어봅시다. Counter 모듈을 사용하면 현재 갖고 있는 데이터에 존재하는 단어 종류의 총개수와 각 단어에 대해서 등장 빈도를 카운트할 수 있습니다. word_list = [] for sent in tokenized_X_train: for word in sent: word_list.append(word) word_counts = Counter(word_list) print('총 단어 수 :', len(word_counts)) 총 단어 수 : 100586 Counter 모듈을 통해 확인한 훈련 데이터에 존재하는 총 단어 수는 100,586개입니다. 이 100,586는 단어들의 집합(set)에서의 단어의 개수를 의미하므로 훈련 데이터에 존재하는 총 단어의 종류의 개수입니다. 또한, 현재 word_counts에는 각 단어의 등장 빈도수가 기록돼 있습니다. 영단어 'the'와 'love'의 등장 빈도수를 확인해 봅시다. print('훈련 데이터에서의 단어 the의 등장 횟수 :', word_counts['the']) print('훈련 데이터에서의 단어 love의 등장 횟수 :', word_counts['love']) 훈련 데이터에서의 단어 the의 등장 횟수 : 265697 훈련 데이터에서의 단어 love의 등장 횟수 : 4984 word_counts에는 단어와 각 단어의 등장 빈도수가 기록돼 있습니다. 그리고 이 정보가 총 100,586개 존재합니다. 단어의 등장 빈도수가 높은 순서대로 정렬하여 vocab이라는 변수에 저장한 후 빈도수가 가장 높은 상위 10개의 단어를 출력합니다. vocab = sorted(word_counts, key=word_counts.get, reverse=True) print('등장 빈도수 상위 10개 단어') print(vocab[:10]) 등장 빈도수 상위 10개 단어 ['the', ',', '.', 'a', 'and', 'of', 'to', 'is', '/', '>'] 여기서는 빈도수가 낮은 단어들은 자연어 처리에서 배제하고자 합니다. 등장 빈도수가 3회 미만인 단어들이 이 데이터에서 얼마큼의 비중을 차지하는지 확인해 봅시다. threshold = 3 total_cnt = len(word_counts) # 단어의 수 rare_cnt = 0 # 등장 빈도수가 threshold보다 작은 단어의 개수를 카운트 total_freq = 0 # 훈련 데이터의 전체 단어 빈도수 총합 rare_freq = 0 # 등장 빈도수가 threshold보다 작은 단어의 등장 빈도수의 총합 # 단어와 빈도수의 쌍(pair)을 key와 value로 받는다. for key, value in word_counts.items(): total_freq = total_freq + value # 단어의 등장 빈도수가 threshold보다 작으면 if(value < threshold): rare_cnt = rare_cnt + 1 rare_freq = rare_freq + value print('단어 집합(vocabulary)의 크기 :',total_cnt) print('등장 빈도가 %s 번 이하인 희귀 단어의 수: %s'%(threshold - 1, rare_cnt)) print("단어 집합에서 희귀 단어의 비율:", (rare_cnt / total_cnt)*100) print("전체 등장 빈도에서 희귀 단어 등장 빈도 비율:", (rare_freq / total_freq)*100) 단어 집합(vocabulary)의 크기 : 100586 등장 빈도가 2번 이하인 희귀 단어의 수: 61877 단어 집합에서 희귀 단어의 비율: 61.51651323245779 전체 등장 빈도에서 희귀 단어 등장 빈도 비율: 1.3294254426463437 등장 빈도가 threshold 값인 3회 미만. 즉, 2회 이하인 단어들은 단어 집합에서 무려 절반 이상을 차지합니다. 하지만, 실제로 훈련 데이터에서 등장 빈도로 차지하는 비중은 상대적으로 매우 적은 수치인 1.32%밖에 되지 않습니다. 아무래도 등장 빈도가 2회 이하인 단어들은 자연어 처리에서 별로 중요하지 않을 듯합니다. 그래서 이 단어들은 정수 인코딩 과정에서 배제시키겠습니다. 등장 빈도수가 2이하인 단어들의 수를 제외한 단어의 개수를 단어 집합의 최대 크기로 제한하겠습니다. # 전체 단어 개수 중 빈도수 2이하인 단어는 제거. vocab_size = total_cnt - rare_cnt vocab = vocab[:vocab_size] print('단어 집합의 크기 :', len(vocab)) 단어 집합의 크기 : 38709 등장 빈도수가 2번 이하인 단어를 제거하자 단어 집합의 크기가 100,586개에서 38,709개로 줄었습니다. 아직 각 단어에 고유한 정수를 부여하는 작업을 진행하지는 않았습니다. 해당 작업을 진행하기에 앞서 정수 0과 정수 1에는 특별한 용도의 단어를 부여하고자 합니다. 정수 0은 패딩을 위해서 사용하는 패딩 토큰인 <PAD>를 할당하고, 정수 1은 OOV(Out-Of-Vocabulary) 문제 발생 시에 모르는 단어에 정수 1을 할당하는 용도인 <UNK>를 할당합니다. word_to_index = {} word_to_index['<PAD>'] = 0 word_to_index['<UNK>'] = 1 for index, word in enumerate(vocab) : word_to_index[word] = index + 2 vocab_size = len(word_to_index) print('패딩 토큰과 UNK 토큰을 고려한 단어 집합의 크기 :', vocab_size) 패딩 토큰과 UNK 토큰을 고려한 단어 집합의 크기 : 38711 3. 정수 인코딩 최종 단어 집합(Vocabulary)인 word_to_index를 이용하여 정수 인코딩을 진행해 봅시다. 이를 위한 함수인 texts_to_sequences()를 구현합니다. 해당 함수는 주어진 데이터에서 각 단어를 word_to_index에 매핑된 정수로 변환합니다. 이때 word_to_index에 존재하지 않는 단어가 등장한 경우에는 정수 1을 부여합니다. def texts_to_sequences(tokenized_X_data, word_to_index): encoded_X_data = [] for sent in tokenized_X_data: index_sequences = [] for word in sent: try: index_sequences.append(word_to_index[word]) except KeyError: index_sequences.append(word_to_index['<UNK>']) encoded_X_data.append(index_sequences) return encoded_X_data encoded_X_train = texts_to_sequences(tokenized_X_train, word_to_index) encoded_X_valid = texts_to_sequences(tokenized_X_valid, word_to_index) encoded_X_test = texts_to_sequences(tokenized_X_test, word_to_index) 정수 인코딩이 진행된 학습 데이터의 상위 2개 샘플을 출력해 봅시다. # 상위 샘플 2개 출력 for sent in encoded_X_train[:2]: print(sent) [38, 29, 140, 3, 52, 54, 29, 38, 3, 5, 3406, 47, 19, 95, 22, 29, 161, 4059, 6, 1741, 3, 47, 29, 293, 39, 469, 218, 3, 6, 47, 29, 134, 71, 532, 61, 59, 25184, 130, 214, 44, 249, 2, 189, 114, 58, 29, 41, 12, 13, 10, 11, 12, 13, 10, 11, 384, 3, 384, 253, 26, 4, 57, 29, 38, 5, 2280, 1587, 23, 1477, 3, 17, 9, 5775, 8, 111, 29, 1440, 71, 532, 141, 677, 4, 16, 343, 8, 126, 17, 24, 43, 2, 75, 63, 16, 20 ... 중략 ...] [16, 735, 2344, 41, 41, 16, 735, 2344, 467, 41, 16, 735, 1903, 41, 25, 17, 26, 20, 2, 1588, 165, 16, 38, 128, 15, 198, 62, 75, 4, 12, 13, 10, 11, 12, 13, 10, 11, 16, 20, 360, 2, 100, 1359, 8, 77, 17, 26, 42, 2, 2394, 3, 6, 43, 16, 38, 8, 147, 9, 16, 1445, 2395, 16, 3268, 3, 6, 63, 9, 14, 184, 8, 39, 1320, 15, 2, 2382, 6, 9728, 4, 520, 3, 17, 9, 40, 2344, 26, 29, 97, 354, 8, 77, 3, 109, 604, 41, 12, 13, 10, 11 ... 중략 ...] 정수 인코딩 된 결과를 역으로 복원해 보기 위해서 각 단어에 정수가 매핑된 word_to_index를 반대로 만든 index_to_word를 구현해 보고 첫 번째 샘플에 대해서 복원해 봅시다. index_to_word = {} for key, value in word_to_index.items(): index_to_word[value] = key decoded_sample = [index_to_word[word] for word in encoded_X_train[0]] print('기존의 첫 번째 샘플 :', tokenized_X_train[0]) print('복원된 첫 번째 샘플 :', decoded_sample) 기존의 첫 번째 샘플 : ['have', 'you', 'ever', ',', 'or', 'do', ... 중략 ... 'heart-swelling', 'feeling', '.', 'i', 'give', 'this', '9/10', '.', 'to', 'be', 'compared', 'to', '(', 'and', 'even', 'rated', 'better', 'than', ')', 'cats', 'and', 'dogs', 'and', 'babe', '.'] 복원된 첫 번째 샘플 : ['have', 'you', 'ever', ',', 'or', 'do', ... 중략 ... '<UNK>', 'feeling', '.', 'i', 'give', 'this', '9/10', '.', 'to', 'be', 'compared', 'to', '(', 'and', 'even', 'rated', 'better', 'than', ')', 'cats', 'and', 'dogs', 'and', 'babe', '.'] 내용이 너무 길어서 중략했습니다. 기존의 첫 번째 샘플과는 달리 정수 인코딩 후 다시역으로 복원한 첫 번째 샘플은 중간에 <UNK>이 있는 것을 확인할 수 있습니다. 4. 패딩 서로 다른 길이의 데이터들을 동일한 길이로 일치시켜주는 패딩 작업을 진행해 봅시다. 이를 위해서 훈련 데이터의 최대 길이, 평균 길이, 그리고 데이터의 길이 분포를 확인합니다. print('리뷰의 최대 길이 :',max(len(review) for review in encoded_X_train)) print('리뷰의 평균 길이 :',sum(map(len, encoded_X_train))/len(encoded_X_train)) plt.hist([len(review) for review in encoded_X_train], bins=50) plt.xlabel('length of samples') plt.ylabel('number of samples') plt.show() 리뷰의 최대 길이 : 2818 리뷰의 평균 길이 : 279.1958 가장 긴 샘플의 길이는 2,818이며, 그래프를 봤을 때 전체 데이터의 길이 분포는 대체적으로 약 1,000내외의 길이를 가지는 것을 볼 수 있습니다. 모델이 처리할 수 있도록 encoded_X_train과 encoded_X_test의 모든 샘플의 길이를 특정 길이로 동일하게 맞춰줄 필요가 있습니다. 특정 길이 변수를 max_len으로 정합니다. 대부분의 리뷰가 내용이 잘리지 않도록 할 수 있는 최적의 max_len의 값은 몇일까요? 전체 샘플 중 길이가 max_len 이하인 샘플의 비율이 몇 % 인지 확인하는 함수를 만듭니다. def below_threshold_len(max_len, nested_list): count = 0 for sentence in nested_list: if(len(sentence) <= max_len): count = count + 1 print('전체 샘플 중 길이가 %s 이하인 샘플의 비율: %s'%(max_len, (count / len(nested_list))*100)) 최대 길이 2,818로 모든 샘플을 패딩 하는 것은 조금 과한 처사일 것입니다. 500으로 할 경우 몇 개의 샘플을 손상시키지 않는지 확인해 봅시다. max_len = 500 below_threshold_len(max_len, encoded_X_train) 전체 샘플 중 길이가 500 이하인 샘플의 비율: 87.795 500으로 패딩 할 경우 약 88%의 샘플은 그대로 보존됩니다. 더 많은 샘플을 보존하기 위해서는 500보다 더 큰 길이로 패딩 할 수도 있겠지만, 여기서는 500으로 진행해 보겠습니다. 이를 위해 패딩을 해주는 함수 pad_sequences()를 구현합니다. 해당 함수는 최대 길이를 정하면 해당 길이보다 긴 데이터는 뒷부분을 잘라서 해당 길이로 맞추고, 해당 길이보다 짧은 데이터는 뒤에 0을 채워서 해당 길이의 데이터로 변환합니다. 결과적으로 길이 500으로 패딩을 하면 모든 데이터의 길이는 500이 됩니다. def pad_sequences(sentences, max_len): features = np.zeros((len(sentences), max_len), dtype=int) for index, sentence in enumerate(sentences): if len(sentence) != 0: features[index, :len(sentence)] = np.array(sentence)[:max_len] return features padded_X_train = pad_sequences(encoded_X_train, max_len=max_len) padded_X_valid = pad_sequences(encoded_X_valid, max_len=max_len) padded_X_test = pad_sequences(encoded_X_test, max_len=max_len) print('훈련 데이터의 크기 :', padded_X_train.shape) print('검증 데이터의 크기 :', padded_X_valid.shape) print('테스트 데이터의 크기 :', padded_X_test.shape) 훈련 데이터의 크기 : (20000, 500) 검증 데이터의 크기 : (5000, 500) 테스트 데이터의 크기 : (25000, 500) 5. 모델링 이제 딥 러닝 프레임워크 PyTorch를 이용하여 GRU 모델을 구현해 봅시다. import torch import torch.nn as nn import torch.nn.functional as F 현재 실습 환경에서 GPU를 사용 가능한지 확인합니다. USE_CUDA = torch.cuda.is_available() device = torch.device("cuda" if USE_CUDA else "cpu") print("cpu와 cuda 중 다음 기기로 학습함:", device) cpu와 cuda 중 다음 기기로 학습함: cuda 저자의 경우 Colab에서 GPU를 선택하여 실습을 진행하여 cuda라는 출력 결과를 확인했습니다. 레이블 데이터를 파이 토치의 텐서 타입으로 변환합니다. 이후 훈련 데이터의 상위 5개의 레이블을 출력해 보았습니다. train_label_tensor = torch.tensor(np.array(y_train)) valid_label_tensor = torch.tensor(np.array(y_valid)) test_label_tensor = torch.tensor(np.array(y_test)) print(train_label_tensor[:5]) tensor([1, 1, 0, 0, 0]) GRU 모델을 클래스로 구현해 봅시다. 각 층을 지날 때마다 각 층의 출력의 크기를 이해하는 것이 중요합니다. 예를 들어 입력은 (배치 크기, 문장 길이)의 크기를 가지는 텐서입니다. 임베딩 층을 지나고 나면 각 단어가 임베딩 벡터로 변환되면서 (배치 크기, 문장 길이, 임베딩 벡터의 차원)으로 텐서의 크기가 변환됩니다. 이후 GRU의 마지막 시점의 은닉 상태(hidden state) 값을 출력층과 연결시키는 작업을 해주어야 합니다. 이때 GRU가 출력층으로 보는 결괏값의 차원은 (배치 크기, 은닉 상태의 차원)을 가져야 합니다. 마지막 시점의 은닉 상태의 값만 전달하므로 은닉 상태는 모든 시점(문장 길이) 만큼 존재하는 것이 아니라 단 하나만 있습니다. 출력층은 지난 결과는 소프트맥스 회귀를 수행하므로 (배치 크기, 분류하고자 하는 카테고리의 수)의 차원을 가지게 됩니다. 그 후 각 데이터를 배치 단위로 데이터 묶음을 꺼낼 수 있는 데이터 로더로 전달합니다. 정리하면 다음과 같습니다. 아직 모델을 만들지는 않았지만, 단어 벡터의 차원을 100, 배치 크기를 32, 문장 길이를 500(패딩 후), GRU의 은닉 상태의 차원을 128로 한다고 가정해 보겠습니다. - 단어 벡터의 차원 = 100 - 문장 길이 = 500 - 배치 크기 = 32 - 데이터 개수 = 2만 - GRU의 은닉층의 크기 = 128 - 분류하고자 하는 카테고리 개수 = 2개 위의 정보들을 고려하였을 때 모델 내부에서 데이터의 변화는 다음과 같습니다. (32, 500) => 입력 데이터의 형태 => 임베딩 층 통과 후 => (32, 500, 100) => GRU 통과 후 => (32, 128) => Softmax 출력층 통과 후 => (32, 2) class TextClassifier(nn.Module): def __init__(self, vocab_size, embedding_dim, hidden_dim, output_dim): super(TextClassifier, self).__init__() self.embedding = nn.Embedding(vocab_size, embedding_dim) self.gru = nn.GRU(embedding_dim, hidden_dim, batch_first=True) self.fc = nn.Linear(hidden_dim, output_dim) # output_dim = 분류하고자 하는 카테고리의 개수 def forward(self, x): # x: (batch_size, seq_length) == (32, 500) embedded = self.embedding(x) # (batch_size, seq_length, embedding_dim) == (32, 500, 100) == (데이터의 개수, 문장 길이, 단어 벡터의 차원) gru_out, hidden = self.gru(embedded) # gru_out: (batch_size, seq_length, hidden_dim), hidden: (1, batch_size, hidden_dim) last_hidden = hidden.squeeze(0) # (batch_size, hidden_dim) logits = self.fc(last_hidden) # (batch_size, output_dim) return logits 훈련 데이터, 검증 데이터, 테스트 데이터에 대해서 파이 토치 텐서로 변환하고 배치 단위 연산을 위해 데이터 로더로 변환합니다. encoded_train = torch.tensor(padded_X_train).to(torch.int64) train_dataset = torch.utils.data.TensorDataset(encoded_train, train_label_tensor) train_dataloader = torch.utils.data.DataLoader(train_dataset, shuffle=True, batch_size=32) encoded_test = torch.tensor(padded_X_test).to(torch.int64) test_dataset = torch.utils.data.TensorDataset(encoded_test, test_label_tensor) test_dataloader = torch.utils.data.DataLoader(test_dataset, shuffle=True, batch_size=1) encoded_valid = torch.tensor(padded_X_valid).to(torch.int64) valid_dataset = torch.utils.data.TensorDataset(encoded_valid, valid_label_tensor) valid_dataloader = torch.utils.data.DataLoader(valid_dataset, shuffle=True, batch_size=1) 훈련 데이터의 샘플 개수가 20,000개였으므로 배치 크기를 32로 할 경우에는 20000/32=625 다시 말해 32개씩 묶인 데이터 묶음이 625개가 생깁니다. 그리고 학습 시에는 32개씩 데이터가 들어가게 될 것입니다. total_batch = len(train_dataloader) print('총 배치의 수 : {}'.format(total_batch)) 총 배치의 수 : 625 모델 객체를 선언합니다. embedding_dim = 100 hidden_dim = 128 output_dim = 2 learning_rate = 0.01 num_epochs = 10 model = TextClassifier(vocab_size, embedding_dim, hidden_dim, output_dim) model.to(device) 임베딩 벡터의 차원은 128, 출력층의 크기(분류해야 할 카테고리의 개수)는 2로 정했습니다. 이렇게 사용자가 정해주는 값이면서 모델의 결과에 영향을 미치는 값들을 하이퍼 파라미터라고 합니다. 소프트맥스 회귀를 통해 분류 문제를 진행하므로 손실 함수는 nn.CrossEntropyLoss()를 사용합니다. 파이 토치로 자연어 처리를 하게 되면 가장 많이 사용하게 되는 손실 함수입니다. 하이퍼 파라미터 중 하나인 학습률(learning rate)는 0.001로 정했습니다. criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=0.001) 6. 평가 코드 작성 이후 평가를 진행하기 위해서 모델의 정확도를 측정하는 함수 calculate_accuracy()를 작성합니다. def calculate_accuracy(logits, labels): # _, predicted = torch.max(logits, 1) predicted = torch.argmax(logits, dim=1) correct = (predicted == labels).sum().item() total = labels.size(0) accuracy = correct / total return accuracy 검증 데이터와 테스트 데이터에 대한 성능을 측정하기 위한 함수 evaluate()를 작성합니다. 아래의 함수에서 model.eval()과 with torch.no_grad()를 짚어봅시다. 이 두 개는 모델 평가를 수행할 때 중요한 역할을 합니다. 각각의 의미는 다음과 같습니다. model.eval(): 모델을 평가 모드로 설정합니다. 이렇게 하면 모델 내부의 모든 레이어에 대해 평가 모드가 활성화됩니다. 일부 레이어, 예를 들어 드롭아웃이나 배치 정규화는 학습과 평가 시 다르게 동작하기 때문에 이 설정이 중요합니다. 평가 모드가 설정되지 않으면, 이러한 레이어의 동작이 올바르지 않을 수 있으며, 이로 인해 평가 결과가 제대로 나오지 않을 수 있습니다. with torch.no_grad(): 이 문장은 자동 미분 엔진에서 그래디 언트 계산을 비활성화합니다. 평가 중에는 기울기를 계산할 필요가 없으므로, 이렇게 설정하면 메모리를 절약하고 속도를 높일 수 있습니다. 만약 이 설정이 적용되지 않으면, 평가 과정에서 그래디 언트가 계산되고 메모리를 차지하게 됩니다. 그러나 평가 결과 자체에는 직접적인 영향을 주지 않습니다. 따라서 model.eval()은 평가 시 반드시 사용해야 하며, 그렇지 않으면 평가 결과가 올바르게 나오지 않을 수 있습니다. with torch.no_grad():는 필수는 아니지만, 메모리와 속도 측면에서 권장됩니다. def evaluate(model, valid_dataloader, criterion, device): val_loss = 0 val_correct = 0 val_total = 0 model.eval() with torch.no_grad(): # 데이터 로더로부터 배치 크기만큼의 데이터를 연속으로 로드 for batch_X, batch_y in valid_dataloader: batch_X, batch_y = batch_X.to(device), batch_y.to(device) # 모델의 예측값 logits = model(batch_X) # 손실을 계산 loss = criterion(logits, batch_y) # 정확도와 손실을 계산함 val_loss += loss.item() val_correct += calculate_accuracy(logits, batch_y) * batch_y.size(0) val_total += batch_y.size(0) val_accuracy = val_correct / val_total val_loss /= len(valid_dataloader) return val_loss, val_accuracy 7. 학습 num_epochs = 5 # Training loop best_val_loss = float('inf') # Training loop for epoch in range(num_epochs): # Training train_loss = 0 train_correct = 0 train_total = 0 model.train() for batch_X, batch_y in train_dataloader: # Forward pass batch_X, batch_y = batch_X.to(device), batch_y.to(device) # batch_X.shape == (batch_size, max_len) logits = model(batch_X) # Compute loss loss = criterion(logits, batch_y) # Backward pass and optimization optimizer.zero_grad() loss.backward() optimizer.step() # Calculate training accuracy and loss train_loss += loss.item() train_correct += calculate_accuracy(logits, batch_y) * batch_y.size(0) train_total += batch_y.size(0) train_accuracy = train_correct / train_total train_loss /= len(train_dataloader) # Validation val_loss, val_accuracy = evaluate(model, valid_dataloader, criterion, device) print(f'Epoch {epoch+1}/{num_epochs}:') print(f'Train Loss: {train_loss:.4f}, Train Accuracy: {train_accuracy:.4f}') print(f'Validation Loss: {val_loss:.4f}, Validation Accuracy: {val_accuracy:.4f}') # 검증 손실이 최소일 때 체크포인트 저장 if val_loss < best_val_loss: print(f'Validation loss improved from {best_val_loss:.4f} to {val_loss:.4f}. 체크포인트를 저장합니다.') best_val_loss = val_loss torch.save(model.state_dict(), 'best_model_checkpoint.pth') 8. 모델 로드 및 평가 # 모델 로드 model.load_state_dict(torch.load('best_model_checkpoint.pth')) # 모델을 device에 올립니다. model.to(device) # 검증 데이터에 대한 정확도와 손실 계산 val_loss, val_accuracy = evaluate(model, valid_dataloader, criterion, device) print(f'Best model validation loss: {val_loss:.4f}') print(f'Best model validation accuracy: {val_accuracy:.4f}') Best model validation loss: 0.3153 Best model validation accuracy: 0.8678 # 테스트 데이터에 대한 정확도와 손실 계산 test_loss, test_accuracy = evaluate(model, test_dataloader, criterion, device) print(f'Best model test loss: {test_loss:.4f}') print(f'Best model test accuracy: {test_accuracy:.4f}') Best model test loss: 0.3245 Best model test accuracy: 0.8641 9. 모델 테스트 index_to_tag = {0 : '부정', 1 : '긍정'} def predict(text, model, word_to_index, index_to_tag): # 모델 평가 모드 model.eval() # 토큰화 및 정수 인코딩. OOV 문제 발생 시 <UNK> 토큰에 해당하는 인덱스 1 할당 tokens = word_tokenize(text) token_indices = [word_to_index.get(token.lower(), 1) for token in tokens] # 리스트를 텐서로 변경 input_tensor = torch.tensor([token_indices], dtype=torch.long).to(device) # (1, seq_length) # 모델의 예측 with torch.no_grad(): logits = model(input_tensor) # (1, output_dim) # 레이블 인덱스 예측 _, predicted_index = torch.max(logits, dim=1) # (1, ) # 인덱스와 매칭되는 카테고리 문자열로 변경 predicted_tag = index_to_tag[predicted_index.item()] return predicted_tag test_input = "This movie was just way too overrated. The fighting was not professional and in slow motion. I was expecting more from a 200 million budget movie. The little sister of T.Challa was just trying too hard to be funny. The story was really dumb as well. Don't watch this movie if you are going because others say its great unless you are a Black Panther fan or Marvels fan." predict(test_input, model, word_to_index, index_to_tag) 부정 test_input = " I was lucky enough to be included in the group to see the advanced screening in Melbourne on the 15th of April, 2012. And, firstly, I need to say a big thank-you to Disney and Marvel Studios. Now, the film... how can I even begin to explain how I feel about this film? It is, as the title of this review says a 'comic book triumph'. I went into the film with very, very high expectations and I was not disappointed. Seeing Joss Whedon's direction and envisioning of the film come to life on the big screen is perfect. The script is amazingly detailed and laced with sharp wit a humor. The special effects are literally mind-blowing and the action scenes are both hard-hitting and beautifully choreographed." predict(test_input, model, word_to_index, index_to_tag) 긍정 13-04 자연어 처리를 위한 1D CNN(1D Convolutional Neural Networks) 합성곱 신경망을 자연어 처리에서 사용하기 위한 1D CNN을 이해해 보겠습니다. 1. 2D 합성곱(2D Convolutions) 앞서 합성곱 신경망을 설명하며 합성곱 연산을 다음과 같이 정의했습니다. 합성곱 연산이란 커널(kernel) 또는 필터(filter)라는 n × m 크기의 행렬로 높이(height) × 너비(width) 크기의 이미지를 처음부터 끝까지 겹치며 훑으면서 n × m 크기의 겹쳐지는 부분의 각 이미지와 커널의 원소의 값을 곱해서 모두 더한 값을 출력으로 하는 것을 말합니다. 이때, 이미지의 가장 왼쪽 위부터 가장 오른쪽 아래까지 순차적으로 훑습니다. 위와 같은 이미지 처리에서의 합성곱 연산을 2D 합성곱 연산이라고 부릅니다. 2. 1D 합성곱(1D Convolutions) 자연어 처리에 사용되는 1D 합성곱 연산을 정리해 봅시다. LSTM을 이용한 여러 실습을 상기해 보면, 각 문장은 임베딩 층(embedding layer)을 지나서 각 단어가 임베딩 벡터가 된 상태로 LSTM의 입력이 되었습니다. 이는 1D 합성곱 연산에서도 마찬가지입니다. 1D 합성곱 연산에서도 입력이 되는 것은 각 단어가 벡터로 변환된 문장 행렬로 LSTM과 입력을 받는 형태는 동일합니다. 'wait for the video and don't rent it'이라는 문장이 있을 때, 이 문장이 토큰화, 패딩, 임베딩 층(Embedding layer)을 거친다면 다음과 같은 문장 형태의 행렬로 변환될 것입니다. 아래 그림에서 은 문장의 길이,는 임베딩 벡터의 차원입니다. 그리고 이 행렬이 만약 LSTM의 입력으로 주어진다면, LSTM은 첫 번째 시점에는 첫 번째 행을 입력으로 받고, 두 번째 시점에는 두 번째 행을 입력으로 받으며 순차적으로 단어를 처리합니다. 그렇다면 1D 합성곱 연산의 경우에는 저 행렬을 어떻게 처리할까요? 1D 합성곱 연산에서 커널의 너비는 문장 행렬에서의 임베딩 벡터의 차원과 동일하게 설정됩니다. 그렇기 때문에 1D 합성곱 연산에서는 커널의 높이만으로 해당 커널의 크기라고 간주합니다. 가령, 커널의 크기가 2인 경우에는 아래의 그림과 같이 높이가 2, 너비가 임베딩 벡터의 차원인 커널이 사용됩니다. 커널의 너비가 임베딩 벡터의 차원이라는 의미는 커널이 2D 합성곱 연산 때와는 달리 너비 방향으로는 더 이상 움직일 곳이 없다는 것을 의미합니다. 그래서 1D 합성곱 연산에서는 커널이 문장 행렬의 높이 방향으로만 움직이게 되어있습니다. 쉽게 설명하면, 위 그림에서 커널은 2D 합성곱 연산 때와는 달리 오른쪽으로는 움직일 공간이 없으므로, 아래쪽으로만 이동해야 합니다. 한 번의 연산을 1 스텝(step)이라고 하였을 때, 합성곱 연산의 네 번째 스텝까지 표현한 이미지는 다음과 같습니다. 크기가 2인 커널은 처음에는 'wait for'에 대해서 합성곱 연산을 하고, 두 번째 스텝에는 'for the'에 대해서 연산을, 세 번째 스텝에는 'the video'에 대해서 연산을, 네 번째 스텝에서는 'video and'에 대해서 연산을 하게 됩니다. 이렇게 여덟 번째 스텝까지 반복하였을 때, 결과적으로는 우측의 8차원 벡터를 1D 합성곱 연산의 결과로서 얻게 될 것입니다. 그런데 커널의 크기가 꼭 2일 필요가 있을까요? 2D 합성곱 연산에서 커널의 크기가 3 × 3 또는 5 × 5 또는 등등의 여러 크기의 커널을 자유자재로 사용할 수 있었듯이, 1D 합성곱 연산에서도 커널의 크기는 사용자가 변경할 수 있습니다. 가령, 커널의 크기를 3으로 한다면, 네 번째 스텝에서의 연산은 아래의 그림과 같을 것입니다. 커널의 크기가 달라진다는 것은 어떤 의미가 있을까요? CNN에서의 커널은 신경망 관점에서는 가중치 행렬이므로 커널의 크기에 따라 학습하게 되는 파라미터의 수는 달라집니다. 1D 합성곱 연산과 자연어 처리 관점에서는 커널의 크기에 따라서 참고하는 단어의 묶음의 크기가 달라집니다. 이는 참고하는 n-gram이 달라진다고 볼 수 있습니다. 커널의 크기가 2라면 각 연산의 스텝에서 참고하는 것은 bigram입니다. 커널의 크기가 3이라면 각 연산의 스텝에서 참고하는 것은 trigram입니다. 3. 맥스 풀링(Max-pooling) 이미지 처리에서의 CNN에서 그랬듯이, 일반적으로 1D 합성곱 연산을 사용하는 1D CNN에서도 합성곱 층(합성곱 연산 + 활성화 함수) 다음에는 풀링 층을 추가하게 됩니다. 그중 대표적으로 사용되는 것이 맥스 풀링(Max-pooling)입니다. 맥스 풀링은 각 합성곱 연산으로부터 얻은 결과 벡터에서 가장 큰 값을 가진 스칼라 값을 빼내는 연산입니다. 아래의 그림은 크기가 2인 커널과 크기가 3인 커널 두 개의 커널로부터 각각 결과 벡터를 얻고, 각 벡터에서 가장 큰 값을 꺼내오는 맥스 풀링 연산을 보여줍니다. 4. 신경망 설계하기 지금까지 배운 개념들을 가지고 텍스트 분류를 위한 CNN을 설계해 봅시다. 우선, 설계하고자 하는 신경망은 이진 분류를 위한 신경망입니다. 단, 시그모이드 함수가 아니라 소프트맥스 함수를 사용할 것이므로 출력층에서 뉴런의 개수가 2인 신경망을 설계합니다. 커널은 크기가 4인 커널 2개, 3인 커널 2개, 2인 커널 2개를 사용합니다. 문장의 길이가 9인 경우, 합성곱 연산을 한 후에는 각각 6차원 벡터 2개, 7차원 벡터 2개, 8차원 벡터 2개를 얻습니다. 벡터가 6개므로 맥스 풀링을 한 후에는 6개의 스칼라 값을 얻는데, 일반적으로 이렇게 얻은 스칼라 값들은 전부 연결(concatenate) 하여 하나의 벡터로 만들어줍니다. 이렇게 얻은 벡터는 1D CNN을 통해서 문장으로부터 얻은 벡터입니다. 이를 뉴런이 2개인 출력층에 완전 연결시키므로서(nn.Linear()를 사용) 텍스트 분류를 수행합니다. 13-05 1D CNN을 이용한 IMDB 리뷰 분류 1D CNN을 이용하여 IMDB 영화 리뷰 데이터를 분류해 보겠습니다. 1. 데이터 로드 및 단어 토큰화 import pandas as pd import numpy as np import matplotlib.pyplot as plt import nltk import torch import urllib.request from tqdm import tqdm from collections import Counter from nltk.tokenize import word_tokenize from sklearn.model_selection import train_test_split nltk.download('punkt') urllib.request.urlretrieve("https://raw.githubusercontent.com/ukairia777/pytorch-nlp-tutorial/main/10.%20RNN%20Text%20Classification/dataset/IMDB%20Dataset.csv", filename="IMDB Dataset.csv") 영화 리뷰 데이터인 IMDB 리뷰 데이터를 로드합니다. df = pd.read_csv('IMDB Dataset.csv') df 데이터의 개수는 총 5만 개입니다. 데이터에 결측값이 있는지 확인할 수 있는 방법 중 하나는 데이터 프레임의 정보를 확인할 수 있는 info()를 사용하는 것입니다. df.info() <class 'pandas.core.frame.DataFrame'> RangeIndex: 50000 entries, 0 to 49999 Data columns (total 2 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 review 50000 non-null object 1 sentiment 50000 non-null object dtypes: object(2) memory usage: 781.4+ KB review 열과 sentiment 열 모두 non-null(결측값이 아닌) 데이터가 5만 개로 확인되므로 결측값은 없습니다. 결측값을 확인할 수 있는 또 다른 방법인. isnull().values.any()를 사용하여 결측값 여부를 확인합니다. print('결측값 여부 :',df.isnull().values.any()) 결측값 여부 : False False가 출력된다면 결측값은 없다는 의미입니다. 레이블이 균등한지 Bar Chart를 통해 확인합니다. df['sentiment'].value_counts().plot(kind='bar') 레이블의 실제 개수를 확인해 봅시다. print('레이블 개수') print(df.groupby('sentiment').size().reset_index(name='count')) 레이블 개수 sentiment count 0 negative 25000 1 positive 25000 두 레이블의 개수는 동일합니다. 레이블이 현재 'positive'와 'negative'로 구성돼 있으므로 각각 1, 0으로 변환하고 정상 변환되었는지 확인하기 위해서 상위 5개의 행을 출력합니다. df['sentiment'] = df['sentiment'].replace(['positive','negative'],[1, 0]) df.head() 긍정 레이블은 1, 부정 레이블은 0으로 변환된 것을 확인하였습니다. 'review' 열은 X_data, 레이블에 해당하는 'sentiment' 열은 y_data에 저장 후 정상 변환 되었는지 확인하기 위해서 다시 한번 개수를 출력합니다. X_data = df['review'] y_data = df['sentiment'] print('영화 리뷰의 개수: {}'.format(len(X_data))) print('레이블의 개수: {}'.format(len(y_data))) 영화 리뷰의 개수: 50000 레이블의 개수: 50000 훈련 데이터와 검증 데이터, 테스트 데이터로 데이터를 나눕니다. 우선 훈련 데이터와 테스트 데이터를 5:5 비율로 나누고, 훈련 데이터를 다시 8:2 비율로 훈련 데이터와 검증 데이터로 나눕니다. sklearn의 train_test_split은 데이터를 나눌 때 굉장히 많이 사용하는 도구이므로 꼭 기억해둡시다. 데이터를 나눌 때 레이블의 비율을 유지하고 싶다면 레이블 데이터를 stratify에 명시해 줄 수 있습니다. X_train, X_test, y_train, y_test = train_test_split(X_data, y_data, test_size=0.5, random_state=0, stratify=y_data) X_train, X_valid, y_train, y_valid = train_test_split(X_train, y_train, test_size=.2, random_state=0, stratify=y_train) print('--------훈련 데이터의 비율-----------') print(f'부정 리뷰 = {round(y_train.value_counts()[0]/len(y_train) * 100,3)}%') print(f'긍정 리뷰 = {round(y_train.value_counts()[1]/len(y_train) * 100,3)}%') print('--------검증 데이터의 비율-----------') print(f'부정 리뷰 = {round(y_valid.value_counts()[0]/len(y_valid) * 100,3)}%') print(f'긍정 리뷰 = {round(y_valid.value_counts()[1]/len(y_valid) * 100,3)}%') print('--------테스트 데이터의 비율-----------') print(f'부정 리뷰 = {round(y_test.value_counts()[0]/len(y_test) * 100,3)}%') print(f'긍정 리뷰 = {round(y_test.value_counts()[1]/len(y_test) * 100,3)}%') --------훈련 데이터의 비율----------- 부정 리뷰 = 50.0% 긍정 리뷰 = 50.0% --------검증 데이터의 비율----------- 부정 리뷰 = 50.0% 긍정 리뷰 = 50.0% --------테스트 데이터의 비율----------- 부정 리뷰 = 50.0% 긍정 리뷰 = 50.0% 훈련 데이터, 검증 데이터, 테스트 데이터 세 개의 데이터 모두 긍정 레이블과 부정 레이블 모두 50:50으로 레이블이 균등하게 유지된 채 분할된 것을 확인할 수 있습니다. 훈련 데이터, 검증 데이터, 테스트 데이터에 대해서 토큰화를 진행해 봅시다. 토큰화를 위해 토큰화 함수 tokenize()를 구현하였습니다. 토큰화 진행 시에 선택적으로 소문자화를 진행하고 싶다면 소문자화도 진행할 수 있습니다. 파이썬 문자열에. lower()를 사용하면 해당 문자열을 소문자로 바꿔줍니다. 해당 함수로 훈련 데이터, 검증 데이터, 테스트 데이터에 대해서 모두 토큰화를 진행합니다. def tokenize(sentences): tokenized_sentences = [] for sent in tqdm(sentences): tokenized_sent = word_tokenize(sent) tokenized_sent = [word.lower() for word in tokenized_sent] tokenized_sentences.append(tokenized_sent) return tokenized_sentences tokenized_X_train = tokenize(X_train) tokenized_X_valid = tokenize(X_valid) tokenized_X_test = tokenize(X_test) 토큰 화가 진행된 후의 훈련 데이터의 상위 2개 샘플을 출력해봅시다. # 상위 샘플 2개 출력 for sent in tokenized_X_train[:2]: print(sent) ['have', 'you', 'ever', ',', 'or', 'do', 'you', 'have', ',', 'a', 'pet', 'who', "'s", 'been', 'with', 'you', 'through', 'thick', 'and', 'thin', ',', 'who', 'you', "'d", 'be', 'lost', 'without', ',', 'and', 'who', 'you', 'love', 'no', 'matter', 'what', '?', 'betcha', 'never', 'thought', 'they', 'feel', 'the', 'same', 'way', 'about', 'you', '!', '<', 'br', '/', '>', '<', 'br', '/', '>', 'wonderful', ... 중략 ...] ['i', 'hate', 'football', '!', '!', 'i', 'hate', 'football', 'fans', '!', 'i', 'hate', 'cars', '!', 'but', 'this', 'film', 'was', 'the', 'funniest', 'thing', 'i', 'have', 'seen', 'in', 'quite', 'some', 'time', '.', '<', 'br', '/', '>', '<', 'br', '/', '>', 'i', 'was', 'given', 'the', 'great', 'opportunity', 'to', 'see', 'this', 'film', 'at', 'the', 'weekend', ',', 'and', 'all', 'i', 'have', 'to', 'say', 'is', 'i', ... 중략 ...] 정상적으로 토큰화된 것을 확인하였습니다. 결과가 너무 길어 책의 지면에서는 중략했습니다. 2. Vocab 만들기 이제 토큰화된 훈련 데이터로부터 정수 인코딩을 진행하기 위한 단어 집합(Vocabulary)을 만들어봅시다. Counter 모듈을 사용하면 현재 갖고 있는 데이터에 존재하는 단어 종류의 총개수와 각 단어에 대해서 등장 빈도를 카운트할 수 있습니다. word_list = [] for sent in tokenized_X_train: for word in sent: word_list.append(word) word_counts = Counter(word_list) print('총 단어 수 :', len(word_counts)) 총 단어 수 : 100586 Counter 모듈을 통해 확인한 훈련 데이터에 존재하는 총 단어 수는 100,586개입니다. 이 100,586는 단어들의 집합(set)에서의 단어의 개수를 의미하므로 훈련 데이터에 존재하는 총 단어의 종류의 개수입니다. 또한, 현재 word_counts에는 각 단어의 등장 빈도수가 기록돼 있습니다. 영단어 'the'와 'love'의 등장 빈도수를 확인해 봅시다. print('훈련 데이터에서의 단어 the의 등장 횟수 :', word_counts['the']) print('훈련 데이터에서의 단어 love의 등장 횟수 :', word_counts['love']) 훈련 데이터에서의 단어 the의 등장 횟수 : 265697 훈련 데이터에서의 단어 love의 등장 횟수 : 4984 word_counts에는 단어와 각 단어의 등장 빈도수가 기록돼 있습니다. 그리고 이 정보가 총 100,586개 존재합니다. 단어의 등장 빈도수가 높은 순서대로 정렬하여 vocab이라는 변수에 저장한 후 빈도수가 가장 높은 상위 10개의 단어를 출력합니다. vocab = sorted(word_counts, key=word_counts.get, reverse=True) print('등장 빈도수 상위 10개 단어') print(vocab[:10]) 등장 빈도수 상위 10개 단어 ['the', ',', '.', 'a', 'and', 'of', 'to', 'is', '/', '>'] 여기서는 빈도수가 낮은 단어들은 자연어 처리에서 배제하고자 합니다. 등장 빈도수가 3회 미만인 단어들이 이 데이터에서 얼마큼의 비중을 차지하는지 확인해 봅시다. threshold = 3 total_cnt = len(word_counts) # 단어의 수 rare_cnt = 0 # 등장 빈도수가 threshold보다 작은 단어의 개수를 카운트 total_freq = 0 # 훈련 데이터의 전체 단어 빈도수 총합 rare_freq = 0 # 등장 빈도수가 threshold보다 작은 단어의 등장 빈도수의 총합 # 단어와 빈도수의 쌍(pair)을 key와 value로 받는다. for key, value in word_counts.items(): total_freq = total_freq + value # 단어의 등장 빈도수가 threshold보다 작으면 if(value < threshold): rare_cnt = rare_cnt + 1 rare_freq = rare_freq + value print('단어 집합(vocabulary)의 크기 :',total_cnt) print('등장 빈도가 %s 번 이하인 희귀 단어의 수: %s'%(threshold - 1, rare_cnt)) print("단어 집합에서 희귀 단어의 비율:", (rare_cnt / total_cnt)*100) print("전체 등장 빈도에서 희귀 단어 등장 빈도 비율:", (rare_freq / total_freq)*100) 단어 집합(vocabulary)의 크기 : 100586 등장 빈도가 2번 이하인 희귀 단어의 수: 61877 단어 집합에서 희귀 단어의 비율: 61.51651323245779 전체 등장 빈도에서 희귀 단어 등장 빈도 비율: 1.3294254426463437 등장 빈도가 threshold 값인 3회 미만. 즉, 2회 이하인 단어들은 단어 집합에서 무려 절반 이상을 차지합니다. 하지만, 실제로 훈련 데이터에서 등장 빈도로 차지하는 비중은 상대적으로 매우 적은 수치인 1.32%밖에 되지 않습니다. 아무래도 등장 빈도가 2회 이하인 단어들은 자연어 처리에서 별로 중요하지 않을 듯합니다. 그래서 이 단어들은 정수 인코딩 과정에서 배제시키겠습니다. 등장 빈도수가 2이하인 단어들의 수를 제외한 단어의 개수를 단어 집합의 최대 크기로 제한하겠습니다. # 전체 단어 개수 중 빈도수 2이하인 단어는 제거. vocab_size = total_cnt - rare_cnt vocab = vocab[:vocab_size] print('단어 집합의 크기 :', len(vocab)) 단어 집합의 크기 : 38709 등장 빈도수가 2번 이하인 단어를 제거하자 단어 집합의 크기가 100,586개에서 38,709개로 줄었습니다. 아직 각 단어에 고유한 정수를 부여하는 작업을 진행하지는 않았습니다. 해당 작업을 진행하기에 앞서 정수 0과 정수 1에는 특별한 용도의 단어를 부여하고자 합니다. 정수 0은 패딩을 위해서 사용하는 패딩 토큰인 <PAD>를 할당하고, 정수 1은 OOV(Out-Of-Vocabulary) 문제 발생 시에 모르는 단어에 정수 1을 할당하는 용도인 <UNK>를 할당합니다. word_to_index = {} word_to_index['<PAD>'] = 0 word_to_index['<UNK>'] = 1 for index, word in enumerate(vocab) : word_to_index[word] = index + 2 vocab_size = len(word_to_index) print('패딩 토큰과 UNK 토큰을 고려한 단어 집합의 크기 :', vocab_size) 패딩 토큰과 UNK 토큰을 고려한 단어 집합의 크기 : 38711 3. 정수 인코딩 최종 단어 집합(Vocabulary)인 word_to_index를 이용하여 정수 인코딩을 진행해 봅시다. 이를 위한 함수인 texts_to_sequences()를 구현합니다. 해당 함수는 주어진 데이터에서 각 단어를 word_to_index에 매핑된 정수로 변환합니다. 이때 word_to_index에 존재하지 않는 단어가 등장한 경우에는 정수 1을 부여합니다. def texts_to_sequences(tokenized_X_data, word_to_index): encoded_X_data = [] for sent in tokenized_X_data: index_sequences = [] for word in sent: try: index_sequences.append(word_to_index[word]) except KeyError: index_sequences.append(word_to_index['<UNK>']) encoded_X_data.append(index_sequences) return encoded_X_data encoded_X_train = texts_to_sequences(tokenized_X_train, word_to_index) encoded_X_valid = texts_to_sequences(tokenized_X_valid, word_to_index) encoded_X_test = texts_to_sequences(tokenized_X_test, word_to_index) 정수 인코딩이 진행된 학습 데이터의 상위 2개 샘플을 출력해 봅시다. # 상위 샘플 2개 출력 for sent in encoded_X_train[:2]: print(sent) [38, 29, 140, 3, 52, 54, 29, 38, 3, 5, 3406, 47, 19, 95, 22, 29, 161, 4059, 6, 1741, 3, 47, 29, 293, 39, 469, 218, 3, 6, 47, 29, 134, 71, 532, 61, 59, 25184, 130, 214, 44, 249, 2, 189, 114, 58, 29, 41, 12, 13, 10, 11, 12, 13, 10, 11, 384, 3, 384, 253, 26, 4, 57, 29, 38, 5, 2280, 1587, 23, 1477, 3, 17, 9, 5775, 8, 111, 29, 1440, 71, 532, 141, 677, 4, 16, 343, 8, 126, 17, 24, 43, 2, 75, 63, 16, 20 ... 중략 ...] [16, 735, 2344, 41, 41, 16, 735, 2344, 467, 41, 16, 735, 1903, 41, 25, 17, 26, 20, 2, 1588, 165, 16, 38, 128, 15, 198, 62, 75, 4, 12, 13, 10, 11, 12, 13, 10, 11, 16, 20, 360, 2, 100, 1359, 8, 77, 17, 26, 42, 2, 2394, 3, 6, 43, 16, 38, 8, 147, 9, 16, 1445, 2395, 16, 3268, 3, 6, 63, 9, 14, 184, 8, 39, 1320, 15, 2, 2382, 6, 9728, 4, 520, 3, 17, 9, 40, 2344, 26, 29, 97, 354, 8, 77, 3, 109, 604, 41, 12, 13, 10, 11 ... 중략 ...] 정수 인코딩 된 결과를 역으로 복원해 보기 위해서 각 단어에 정수가 매핑된 word_to_index를 반대로 만든 index_to_word를 구현해 보고 첫 번째 샘플에 대해서 복원해 봅시다. index_to_word = {} for key, value in word_to_index.items(): index_to_word[value] = key decoded_sample = [index_to_word[word] for word in encoded_X_train[0]] print('기존의 첫 번째 샘플 :', tokenized_X_train[0]) print('복원된 첫 번째 샘플 :', decoded_sample) 기존의 첫 번째 샘플 : ['have', 'you', 'ever', ',', 'or', 'do', ... 중략 ... 'heart-swelling', 'feeling', '.', 'i', 'give', 'this', '9/10', '.', 'to', 'be', 'compared', 'to', '(', 'and', 'even', 'rated', 'better', 'than', ')', 'cats', 'and', 'dogs', 'and', 'babe', '.'] 복원된 첫 번째 샘플 : ['have', 'you', 'ever', ',', 'or', 'do', ... 중략 ... '<UNK>', 'feeling', '.', 'i', 'give', 'this', '9/10', '.', 'to', 'be', 'compared', 'to', '(', 'and', 'even', 'rated', 'better', 'than', ')', 'cats', 'and', 'dogs', 'and', 'babe', '.'] 내용이 너무 길어서 중략했습니다. 기존의 첫 번째 샘플과는 달리 정수 인코딩 후 다시역으로 복원한 첫 번째 샘플은 중간에 <UNK>이 있는 것을 확인할 수 있습니다. 4. 패딩 서로 다른 길이의 데이터들을 동일한 길이로 일치시켜주는 패딩 작업을 진행해 봅시다. 이를 위해서 훈련 데이터의 최대 길이, 평균 길이, 그리고 데이터의 길이 분포를 확인합니다. print('리뷰의 최대 길이 :',max(len(review) for review in encoded_X_train)) print('리뷰의 평균 길이 :',sum(map(len, encoded_X_train))/len(encoded_X_train)) plt.hist([len(review) for review in encoded_X_train], bins=50) plt.xlabel('length of samples') plt.ylabel('number of samples') plt.show() 리뷰의 최대 길이 : 2818 리뷰의 평균 길이 : 279.1958 가장 긴 샘플의 길이는 2,818이며, 그래프를 봤을 때 전체 데이터의 길이 분포는 대체적으로 약 1,000내외의 길이를 가지는 것을 볼 수 있습니다. 모델이 처리할 수 있도록 encoded_X_train과 encoded_X_test의 모든 샘플의 길이를 특정 길이로 동일하게 맞춰줄 필요가 있습니다. 특정 길이 변수를 max_len으로 정합니다. 대부분의 리뷰가 내용이 잘리지 않도록 할 수 있는 최적의 max_len의 값은 몇일까요? 전체 샘플 중 길이가 max_len 이하인 샘플의 비율이 몇 % 인지 확인하는 함수를 만듭니다. def below_threshold_len(max_len, nested_list): count = 0 for sentence in nested_list: if(len(sentence) <= max_len): count = count + 1 print('전체 샘플 중 길이가 %s 이하인 샘플의 비율: %s'%(max_len, (count / len(nested_list))*100)) 최대 길이 2,818로 모든 샘플을 패딩 하는 것은 조금 과한 처사일 것입니다. 500으로 할 경우 몇 개의 샘플을 손상시키지 않는지 확인해 봅시다. max_len = 500 below_threshold_len(max_len, encoded_X_train) 전체 샘플 중 길이가 500 이하인 샘플의 비율: 87.795 500으로 패딩 할 경우 약 88%의 샘플은 그대로 보존됩니다. 더 많은 샘플을 보존하기 위해서는 500보다 더 큰 길이로 패딩 할 수도 있겠지만, 여기서는 500으로 진행해 보겠습니다. 이를 위해 패딩을 해주는 함수 pad_sequences()를 구현합니다. 해당 함수는 최대 길이를 정하면 해당 길이보다 긴 데이터는 뒷부분을 잘라서 해당 길이로 맞추고, 해당 길이보다 짧은 데이터는 뒤에 0을 채워서 해당 길이의 데이터로 변환합니다. 결과적으로 길이 500으로 패딩을 하면 모든 데이터의 길이는 500이 됩니다. def pad_sequences(sentences, max_len): features = np.zeros((len(sentences), max_len), dtype=int) for index, sentence in enumerate(sentences): if len(sentence) != 0: features[index, :len(sentence)] = np.array(sentence)[:max_len] return features padded_X_train = pad_sequences(encoded_X_train, max_len=max_len) padded_X_valid = pad_sequences(encoded_X_valid, max_len=max_len) padded_X_test = pad_sequences(encoded_X_test, max_len=max_len) print('훈련 데이터의 크기 :', padded_X_train.shape) print('검증 데이터의 크기 :', padded_X_valid.shape) print('테스트 데이터의 크기 :', padded_X_test.shape) 훈련 데이터의 크기 : (20000, 500) 검증 데이터의 크기 : (5000, 500) 테스트 데이터의 크기 : (25000, 500) 5. 모델링 이제 딥 러닝 프레임워크 PyTorch를 이용하여 1D CNN 모델을 구현해 봅시다. import torch import torch.nn as nn import torch.nn.functional as F 현재 실습 환경에서 GPU를 사용 가능한지 확인합니다. USE_CUDA = torch.cuda.is_available() device = torch.device("cuda" if USE_CUDA else "cpu") print("cpu와 cuda 중 다음 기기로 학습함:", device) cpu와 cuda 중 다음 기기로 학습함: cuda 저자의 경우 Colab에서 GPU를 선택하여 실습을 진행하여 cuda라는 출력 결과를 확인했습니다. 레이블 데이터를 파이 토치의 텐서 타입으로 변환합니다. 이후 훈련 데이터의 상위 5개의 레이블을 출력해 보았습니다. train_label_tensor = torch.tensor(np.array(y_train)) valid_label_tensor = torch.tensor(np.array(y_valid)) test_label_tensor = torch.tensor(np.array(y_test)) print(train_label_tensor[:5]) tensor([1, 1, 0, 0, 0]) 아래는 합성곱 신경망의 동작 과정을 보여줍니다. # input.shape == (배치 크기, 임베딩 벡터의 차원, 문장 길이) input = torch.randn(32, 16, 50) # 선언 시 nn.Conv1d(임베딩 벡터의 차원, 커널의 개수, 커널 사이즈) m = nn.Conv1d(16, 33, 3, stride=1) # output.shape == (배치 크기, 커널의 개수, 컨볼루션 연산 결과 벡터) output = m(input) print(output.shape) torch.Size([32, 33, 48]) CNN 모델을 클래스로 구현해 봅시다. class CNN(torch.nn.Module): def __init__(self, vocab_size, num_labels): super(CNN, self).__init__() # 오직 하나의 종류의 필터만 사용함. self.num_filter_sizes = 1 # 윈도 5짜리 1개만 사용 self.num_filters = 256 self.word_embed = torch.nn.Embedding(num_embeddings=vocab_size, embedding_dim=128, padding_idx=0) # 윈도 5짜리 1개만 사용 self.conv1 = torch.nn.Conv1d(128, self.num_filters, 5, stride=1) self.dropout = torch.nn.Dropout(0.5) self.fc1 = torch.nn.Linear(1 * self.num_filters, num_labels, bias=True) def forward(self, inputs): # word_embed(inputs).shape == (배치 크기, 문장 길이, 임베딩 벡터의 차원) # word_embed(inputs).permute(0, 2, 1).shape == (배치 크기, 임베딩 벡터의 차원, 문장 길이) embedded = self.word_embed(inputs).permute(0, 2, 1) # max를 이용한 maxpooling # conv1(embedded).shape == (배치 크기, 커널 개수, 컨볼루션 연산 결과) == ex) 32, 256, 496 # conv1(embedded).permute(0, 2, 1).shape == (배치 크기, 컨볼루션 연산 결과, 커널 개수) # conv1(embedded).permute(0, 2, 1).max(1)[0]).shape == (배치 크기, 커널 개수) x = F.relu(self.conv1(embedded).permute(0, 2, 1).max(1)[0]) # y_pred.shape == (배치 크기, 분류할 카테고리의 수) y_pred = self.fc1(self.dropout(x)) return y_pred 훈련 데이터, 검증 데이터, 테스트 데이터에 대해서 파이 토치 텐서로 변환하고 배치 단위 연산을 위해 데이터 로더로 변환합니다. encoded_train = torch.tensor(padded_X_train).to(torch.int64) train_dataset = torch.utils.data.TensorDataset(encoded_train, train_label_tensor) train_dataloader = torch.utils.data.DataLoader(train_dataset, shuffle=True, batch_size=32) encoded_test = torch.tensor(padded_X_test).to(torch.int64) test_dataset = torch.utils.data.TensorDataset(encoded_test, test_label_tensor) test_dataloader = torch.utils.data.DataLoader(test_dataset, shuffle=True, batch_size=1) encoded_valid = torch.tensor(padded_X_valid).to(torch.int64) valid_dataset = torch.utils.data.TensorDataset(encoded_valid, valid_label_tensor) valid_dataloader = torch.utils.data.DataLoader(valid_dataset, shuffle=True, batch_size=1) 훈련 데이터의 샘플 개수가 20,000개였으므로 배치 크기를 32로 할 경우에는 20000/32=625 다시 말해 32개씩 묶인 데이터 묶음이 625개가 생깁니다. 그리고 학습 시에는 32개씩 데이터가 들어가게 될 것입니다. total_batch = len(train_dataloader) print('총 배치의 수 : {}'.format(total_batch)) 총 배치의 수 : 625 모델 객체를 선언합니다. model = CNN(vocab_size, num_labels = len(set(y_train))) model.to(device) 임베딩 벡터의 차원은 128, 출력층의 크기(분류해야 할 카테고리의 개수)는 2로 정했습니다. 이렇게 사용자가 정해주는 값이면서 모델의 결과에 영향을 미치는 값들을 하이퍼 파라미터라고 합니다. 소프트맥스 회귀를 통해 분류 문제를 진행하므로 손실 함수는 nn.CrossEntropyLoss()를 사용합니다. 파이 토치로 자연어 처리를 하게 되면 가장 많이 사용하게 되는 손실 함수입니다. 하이퍼 파라미터 중 하나인 학습률(learning rate)는 0.001로 정했습니다. criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=0.001) 6. 평가 코드 작성 이후 평가를 진행하기 위해서 모델의 정확도를 측정하는 함수 calculate_accuracy()를 작성합니다. def calculate_accuracy(logits, labels): # _, predicted = torch.max(logits, 1) predicted = torch.argmax(logits, dim=1) correct = (predicted == labels).sum().item() total = labels.size(0) accuracy = correct / total return accuracy 검증 데이터와 테스트 데이터에 대한 성능을 측정하기 위한 함수 evaluate()를 작성합니다. 아래의 함수에서 model.eval()과 with torch.no_grad()를 짚어봅시다. 이 두 개는 모델 평가를 수행할 때 중요한 역할을 합니다. 각각의 의미는 다음과 같습니다. model.eval(): 모델을 평가 모드로 설정합니다. 이렇게 하면 모델 내부의 모든 레이어에 대해 평가 모드가 활성화됩니다. 일부 레이어, 예를 들어 드롭아웃이나 배치 정규화는 학습과 평가 시 다르게 동작하기 때문에 이 설정이 중요합니다. 평가 모드가 설정되지 않으면, 이러한 레이어의 동작이 올바르지 않을 수 있으며, 이로 인해 평가 결과가 제대로 나오지 않을 수 있습니다. with torch.no_grad(): 이 문장은 자동 미분 엔진에서 그래디 언트 계산을 비활성화합니다. 평가 중에는 기울기를 계산할 필요가 없으므로, 이렇게 설정하면 메모리를 절약하고 속도를 높일 수 있습니다. 만약 이 설정이 적용되지 않으면, 평가 과정에서 그래디 언트가 계산되고 메모리를 차지하게 됩니다. 그러나 평가 결과 자체에는 직접적인 영향을 주지 않습니다. 따라서 model.eval()은 평가 시 반드시 사용해야 하며, 그렇지 않으면 평가 결과가 올바르게 나오지 않을 수 있습니다. with torch.no_grad():는 필수는 아니지만, 메모리와 속도 측면에서 권장됩니다. def evaluate(model, valid_dataloader, criterion, device): val_loss = 0 val_correct = 0 val_total = 0 model.eval() with torch.no_grad(): # 데이터 로더로부터 배치 크기만큼의 데이터를 연속으로 로드 for batch_X, batch_y in valid_dataloader: batch_X, batch_y = batch_X.to(device), batch_y.to(device) # 모델의 예측값 logits = model(batch_X) # 손실을 계산 loss = criterion(logits, batch_y) # 정확도와 손실을 계산함 val_loss += loss.item() val_correct += calculate_accuracy(logits, batch_y) * batch_y.size(0) val_total += batch_y.size(0) val_accuracy = val_correct / val_total val_loss /= len(valid_dataloader) return val_loss, val_accuracy 7. 학습 num_epochs = 5 # Training loop best_val_loss = float('inf') # Training loop for epoch in range(num_epochs): # Training train_loss = 0 train_correct = 0 train_total = 0 model.train() for batch_X, batch_y in train_dataloader: # Forward pass batch_X, batch_y = batch_X.to(device), batch_y.to(device) # batch_X.shape == (batch_size, max_len) logits = model(batch_X) # Compute loss loss = criterion(logits, batch_y) # Backward pass and optimization optimizer.zero_grad() loss.backward() optimizer.step() # Calculate training accuracy and loss train_loss += loss.item() train_correct += calculate_accuracy(logits, batch_y) * batch_y.size(0) train_total += batch_y.size(0) train_accuracy = train_correct / train_total train_loss /= len(train_dataloader) # Validation val_loss, val_accuracy = evaluate(model, valid_dataloader, criterion, device) print(f'Epoch {epoch+1}/{num_epochs}:') print(f'Train Loss: {train_loss:.4f}, Train Accuracy: {train_accuracy:.4f}') print(f'Validation Loss: {val_loss:.4f}, Validation Accuracy: {val_accuracy:.4f}') # 검증 손실이 최소일 때 체크포인트 저장 if val_loss < best_val_loss: print(f'Validation loss improved from {best_val_loss:.4f} to {val_loss:.4f}. 체크포인트를 저장합니다.') best_val_loss = val_loss torch.save(model.state_dict(), 'best_model_checkpoint.pth') 8. 모델 로드 및 평가 학습 과정에서 검증 손실이 최소 일 때 체크포인트를 저장해두었습니다. 해당 체크포인트를 베스트 모델로 판단하고 해당 체크포인트를 로드하여 모델 성능을 평가합니다. # 모델 로드 model.load_state_dict(torch.load('best_model_checkpoint.pth')) # 모델을 device에 올립니다. model.to(device) # 검증 데이터에 대한 정확도와 손실 계산 val_loss, val_accuracy = evaluate(model, valid_dataloader, criterion, device) print(f'Best model validation loss: {val_loss:.4f}') print(f'Best model validation accuracy: {val_accuracy:.4f}') Best model validation loss: 0.2951 Best model validation accuracy: 0.8816 검증 데이터에서의 평가 시 정확도는 88.16%, 손실은 0.2951입니다. # 테스트 데이터에 대한 정확도와 손실 계산 test_loss, test_accuracy = evaluate(model, test_dataloader, criterion, device) print(f'Best model test loss: {test_loss:.4f}') print(f'Best model test accuracy: {test_accuracy:.4f}') Best model test loss: 0.3060 Best model test accuracy: 0.8728 테스트 데이터에서의 평가 시 정확도는 87.28%, 손실은 0.3060입니다. 다음의 13-03 실습에서 이 정확도와 손실을 좀 더 높여보는 실습을 진행할 예정입니다. 9. 모델 테스트 이제 임의의 입력으로부터 모델의 성능을 예측해 보는 테스트 함수 predict() 함수를 작성하고, 해당 함수에 전처리가 되어 있지 않은 영화 리뷰 텍스트를 입력으로 넣어서 모델의 예측을 얻어봅시다. index_to_tag = {0 : '부정', 1 : '긍정'} def predict(text, model, word_to_index, index_to_tag): # 모델 평가 모드 model.eval() # 토큰화 및 정수 인코딩. OOV 문제 발생 시 <UNK> 토큰에 해당하는 인덱스 1 할당 tokens = word_tokenize(text) token_indices = [word_to_index.get(token.lower(), 1) for token in tokens] # 리스트를 텐서로 변경 input_tensor = torch.tensor([token_indices], dtype=torch.long).to(device) # (1, seq_length) # 모델의 예측 with torch.no_grad(): logits = model(input_tensor) # (1, output_dim) # 레이블 인덱스 예측 _, predicted_index = torch.max(logits, dim=1) # (1, ) # 인덱스와 매칭되는 카테고리 문자열로 변경 predicted_tag = index_to_tag[predicted_index.item()] return predicted_tag 부정적인 영화 리뷰를 넣어 모델이 부정이라고 잘 예측하는지 테스트합니다. test_input = "This movie was just way too overrated. The fighting was not professional and in slow motion. I was expecting more from a 200 million budget movie. The little sister of T.Challa was just trying too hard to be funny. The story was really dumb as well. Don't watch this movie if you are going because others say its great unless you are a Black Panther fan or Marvels fan." predict(test_input, model, word_to_index, index_to_tag) 부정 긍정적인 영화 리뷰를 넣어 모델이 부정이라고 잘 예측하는지 테스트합니다. test_input = " I was lucky enough to be included in the group to see the advanced screening in Melbourne on the 15th of April, 2012. And, firstly, I need to say a big thank-you to Disney and Marvel Studios. Now, the film... how can I even begin to explain how I feel about this film? It is, as the title of this review says a 'comic book triumph'. I went into the film with very, very high expectations and I was not disappointed. Seeing Joss Whedon's direction and envisioning of the film come to life on the big screen is perfect. The script is amazingly detailed and laced with sharp wit a humor. The special effects are literally mind-blowing and the action scenes are both hard-hitting and beautifully choreographed." predict(test_input, model, word_to_index, index_to_tag) 긍정 13-06 사전 훈련된 임베딩을 이용한 성능 상승시키기 이전 실습인 '12-04 1D CNN을 이용하여 IMDB 영화 리뷰 분류' 실습에 사전 훈련된 임베딩을 이용하는 코드를 추가하여 좀 더 높은 성능을 얻어보겠습니다. 1. 데이터 로드 및 단어 토큰화 ~ 4. 패딩 12-04와 모든 과정이 동일한 과정을 진행합니다. 5. 사전 훈련된 임베딩 사전 훈련된 임베딩을 사용하기 위해서는 머신 러닝 라이브러리 gensim의 설치가 필요합니다. !pip install gensim 구글이 이미 학습해놓은 사전 훈련된 워드 임베딩을 다운로드합니다. !wget --load-cookies /tmp/cookies.txt "https://docs.google.com/uc? export=download&confirm=$(wget --quiet --save-cookies /tmp/cookies.txt --keep-session-cookies --no-check-certificate 'https://docs.google.com/uc?export=download&id=1Av37IVBQAAntSe1X3MOAl5gvowQzd2_j' -O- | sed -rn 's/.*confirm=([0-9A-Za-z_]+).*/\1\n/p')&id=1Av37IVBQAAntSe1X3MOAl5gvowQzd2_j" -O GoogleNews-vectors-negative300.bin.gz && rm -rf /tmp/cookies.txt 구글의 사전 훈련된 Word2vec 모델을 gensim을 통해 로드합니다. word2vec_model = gensim.models.KeyedVectors.load_word2vec_format('GoogleNews-vectors-negative300.bin.gz', binary=True) 구글의 사전 훈련된 임베딩은 학습되었을 당시 각 단어가 300차원으로 학습된 상태입니다. 우리는 우리가 만든 vocab_size 만큼의 행을 가지고, 300차원의 열을 가지는 행렬을 만듭니다. embedding_matrix = np.zeros((vocab_size, 300)) 그 후 사전 훈련된 임베딩을 우리가 만든 embedding_matrix에 매핑합니다. 예를 들어 우리가 앞서 만든 토크 나이저 기준으로 36번이 단어 '사과'라면, embedding_matrix의 36번 행에 구글에서 만든 사전 훈련된 임베딩 벡터의 값이 '사과'인 벡터를 매핑합니다. def get_vector(word): if word in word2vec_model: return word2vec_model[word] else: return None # <PAD>를 위한 0번과 <UNK>를 위한 1번은 실제 단어가 아니므로 매핑에서 제외 for word, i in word_to_index.items(): if i > 2: temp = get_vector(word) if temp is not None: embedding_matrix[i] = temp 0번 임베딩 벡터를 출력해 봅시다. # <PAD>나 <UNK>의 경우는 사전 훈련된 임베딩이 들어가지 않아서 0벡터임 embedding_matrix[0] array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]) 원소의 값이 전부 0인 0벡터임을 확인할 수 있습니다. 현재 단어 집합에서 'apple'은 몇 번 정수로 매핑되어 있는지 확인해 봅시다. word_to_index['apple'] 8053 구글의 사전 훈련된 Word2Vec에서의 'apple'의 임베딩 벡터 값(word2vec_model['apple'])과 현재 임베딩 행렬의 8053번의 벡터가 일치하는지 확인합니다. 이는 사전 훈련된 임베딩 벡터의 값이 우리의 임베딩 행렬에 정확하게 매핑되었는지를 확인하기 위함입니다. # word2vec_model에서 'apple'의 임베딩 벡터 # embedding_matrix[8053]이 일치하는지 체크 np.all(word2vec_model['apple'] == embedding_matrix[8053]) True 6. 모델링 위의 사전 훈련된 임베딩을 이용하여 모델을 만들어봅시다. 필요한 도구들을 임포트 합니다. import torch import torch.nn as nn import torch.nn.functional as F GPU를 사용 가능한 환경인지 확인합니다. USE_CUDA = torch.cuda.is_available() device = torch.device("cuda" if USE_CUDA else "cpu") print("cpu와 cuda 중 다음 기기로 학습함:", device) cpu와 cuda 중 다음 기기로 학습함: cuda 저자의 경우 Colab에서 GPU를 선택 후 실습하고 있어 'cuda'라고 출력되었으며 GPU가 사용 가능함을 의미합니다. 사전 훈련된 임베딩을 사용하는 CNN 모델의 클래스는 다음과 같습니다. 워드 임베딩 층에 위에서 사전 훈련된 임베딩으로 만들어놓은 임베딩 행렬인 embedding_matrix를 매핑하고 있는 코드에 주목합시다. class CNN(torch.nn.Module): def __init__(self, vocab_size, num_labels): super(CNN, self).__init__() # 오직 하나의 종류의 필터만 사용함. self.num_filter_sizes = 1 # 윈도 5짜리 1개만 사용 self.num_filters = 256 # 주석 처리된 코드는 기존의 임베딩 층을 사용할 경우 # self.word_embed = nn.Embedding(num_embeddings=vocab_size, embedding_dim=128, padding_idx=0) self.word_embed = nn.Embedding(num_embeddings=vocab_size, embedding_dim=300) self.word_embed.weight = nn.Parameter(torch.tensor(embedding_matrix, dtype=torch.float32)) self.word_embed.weight.requires_grad = True # 윈도 5짜리 1개만 사용 self.conv1 = torch.nn.Conv1d(300, self.num_filters, 5, stride=1) self.dropout = torch.nn.Dropout(0.5) self.fc1 = torch.nn.Linear(1 * self.num_filters, num_labels, bias=True) def forward(self, inputs): # word_embed(inputs).shape == (배치 크기, 문장 길이, 임베딩 벡터의 차원) # word_embed(inputs).permute(0, 2, 1).shape == (배치 크기, 임베딩 벡터의 차원, 문장 길이) embedded = self.word_embed(inputs).permute(0, 2, 1) # max를 이용한 maxpooling # conv1(embedded).shape == (배치 크기, 커널 개수, 컨볼루션 연산 결과) == ex) 32, 256, 496 # conv1(embedded).permute(0, 2, 1).shape == (배치 크기, 컨볼루션 연산 결과, 커널 개수) # conv1(embedded).permute(0, 2, 1).max(1)[0]).shape == (배치 크기, 커널 개수) x = F.relu(self.conv1(embedded).permute(0, 2, 1).max(1)[0]) # y_pred.shape == (배치 크기, 분류할 카테고리의 수) y_pred = self.fc1(self.dropout(x)) return y_pred 훈련 데이터, 검증 데이터, 테스트 데이터에 대해서 파이 토치 텐서로 변환하고 배치 단위 연산을 위해 데이터 로더로 변환합니다. 이 아래의 모든 코드는 13-02와 동일합니다. encoded_train = torch.tensor(padded_X_train).to(torch.int64) train_dataset = torch.utils.data.TensorDataset(encoded_train, train_label_tensor) train_dataloader = torch.utils.data.DataLoader(train_dataset, shuffle=True, batch_size=32) encoded_test = torch.tensor(padded_X_test).to(torch.int64) test_dataset = torch.utils.data.TensorDataset(encoded_test, test_label_tensor) test_dataloader = torch.utils.data.DataLoader(test_dataset, shuffle=True, batch_size=1) encoded_valid = torch.tensor(padded_X_valid).to(torch.int64) valid_dataset = torch.utils.data.TensorDataset(encoded_valid, valid_label_tensor) valid_dataloader = torch.utils.data.DataLoader(valid_dataset, shuffle=True, batch_size=1) 훈련 데이터의 샘플 개수가 20,000개였으므로 배치 크기를 32로 할 경우에는 20000/32=625 다시 말해 32개씩 묶인 데이터 묶음이 625개가 생깁니다. 그리고 학습 시에는 32개씩 데이터가 들어가게 될 것입니다. total_batch = len(train_dataloader) print('총 배치의 수 : {}'.format(total_batch)) 총 배치의 수 : 625 모델 객체를 선언합니다. model = CNN(vocab_size, num_labels = len(set(y_train))) model.to(device) 임베딩 벡터의 차원은 300, 출력층의 크기(분류해야 할 카테고리의 개수)는 2로 정했습니다. 이렇게 사용자가 정해주는 값이면서 모델의 결과에 영향을 미치는 값들을 하이퍼 파라미터라고 합니다. 소프트맥스 회귀를 통해 분류 문제를 진행하므로 손실 함수는 nn.CrossEntropyLoss()를 사용합니다. 파이 토치로 자연어 처리를 하게 되면 가장 많이 사용하게 되는 손실 함수입니다. 하이퍼 파라미터 중 하나인 학습률(learning rate)는 0.001로 정했습니다. criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=0.001) 7. 평가 코드 작성 이후 평가를 진행하기 위해서 모델의 정확도를 측정하는 함수 calculate_accuracy()를 작성합니다. def calculate_accuracy(logits, labels): # _, predicted = torch.max(logits, 1) predicted = torch.argmax(logits, dim=1) correct = (predicted == labels).sum().item() total = labels.size(0) accuracy = correct / total return accuracy 검증 데이터와 테스트 데이터에 대한 성능을 측정하기 위한 함수 evaluate()를 작성합니다. 아래의 함수에서 model.eval()과 with torch.no_grad()를 짚어봅시다. 이 두 개는 모델 평가를 수행할 때 중요한 역할을 합니다. 각각의 의미는 다음과 같습니다. model.eval(): 모델을 평가 모드로 설정합니다. 이렇게 하면 모델 내부의 모든 레이어에 대해 평가 모드가 활성화됩니다. 일부 레이어, 예를 들어 드롭아웃이나 배치 정규화는 학습과 평가 시 다르게 동작하기 때문에 이 설정이 중요합니다. 평가 모드가 설정되지 않으면, 이러한 레이어의 동작이 올바르지 않을 수 있으며, 이로 인해 평가 결과가 제대로 나오지 않을 수 있습니다. with torch.no_grad(): 이 문장은 자동 미분 엔진에서 그래디 언트 계산을 비활성화합니다. 평가 중에는 기울기를 계산할 필요가 없으므로, 이렇게 설정하면 메모리를 절약하고 속도를 높일 수 있습니다. 만약 이 설정이 적용되지 않으면, 평가 과정에서 그래디 언트가 계산되고 메모리를 차지하게 됩니다. 그러나 평가 결과 자체에는 직접적인 영향을 주지 않습니다. 따라서 model.eval()은 평가 시 반드시 사용해야 하며, 그렇지 않으면 평가 결과가 올바르게 나오지 않을 수 있습니다. with torch.no_grad():는 필수는 아니지만, 메모리와 속도 측면에서 권장됩니다. def evaluate(model, valid_dataloader, criterion, device): val_loss = 0 val_correct = 0 val_total = 0 model.eval() with torch.no_grad(): # 데이터 로더로부터 배치 크기만큼의 데이터를 연속으로 로드 for batch_X, batch_y in valid_dataloader: batch_X, batch_y = batch_X.to(device), batch_y.to(device) # 모델의 예측값 logits = model(batch_X) # 손실을 계산 loss = criterion(logits, batch_y) # 정확도와 손실을 계산함 val_loss += loss.item() val_correct += calculate_accuracy(logits, batch_y) * batch_y.size(0) val_total += batch_y.size(0) val_accuracy = val_correct / val_total val_loss /= len(valid_dataloader) return val_loss, val_accuracy 8. 학습 num_epochs = 5 # Training loop best_val_loss = float('inf') # Training loop for epoch in range(num_epochs): # Training train_loss = 0 train_correct = 0 train_total = 0 model.train() for batch_X, batch_y in train_dataloader: # Forward pass batch_X, batch_y = batch_X.to(device), batch_y.to(device) # batch_X.shape == (batch_size, max_len) logits = model(batch_X) # Compute loss loss = criterion(logits, batch_y) # Backward pass and optimization optimizer.zero_grad() loss.backward() optimizer.step() # Calculate training accuracy and loss train_loss += loss.item() train_correct += calculate_accuracy(logits, batch_y) * batch_y.size(0) train_total += batch_y.size(0) train_accuracy = train_correct / train_total train_loss /= len(train_dataloader) # Validation val_loss, val_accuracy = evaluate(model, valid_dataloader, criterion, device) print(f'Epoch {epoch+1}/{num_epochs}:') print(f'Train Loss: {train_loss:.4f}, Train Accuracy: {train_accuracy:.4f}') print(f'Validation Loss: {val_loss:.4f}, Validation Accuracy: {val_accuracy:.4f}') # 검증 손실이 최소일 때 체크포인트 저장 if val_loss < best_val_loss: print(f'Validation loss improved from {best_val_loss:.4f} to {val_loss:.4f}. 체크포인트를 저장합니다.') best_val_loss = val_loss torch.save(model.state_dict(), 'best_model_checkpoint.pth') 9. 모델 로드 및 평가 # 모델 로드 model.load_state_dict(torch.load('best_model_checkpoint.pth')) # 모델을 device에 올립니다. model.to(device) 검증 데이터와 테스트 데이터에 대한 정확도와 손실을 계산합니다. 전반적으로 13-02보다 더 높은 성능을 얻는 것을 확인할 수 있습니다. # 검증 데이터에 대한 정확도와 손실 계산 val_loss, val_accuracy = evaluate(model, valid_dataloader, criterion, device) print(f'Best model validation loss: {val_loss:.4f}') print(f'Best model validation accuracy: {val_accuracy:.4f}') Best model validation loss: 0.2523 Best model validation accuracy: 0.8996 # 테스트 데이터에 대한 정확도와 손실 계산 test_loss, test_accuracy = evaluate(model, test_dataloader, criterion, device) print(f'Best model test loss: {test_loss:.4f}') print(f'Best model test accuracy: {test_accuracy:.4f}') Best model test loss: 0.2503 Best model test accuracy: 0.8983 10. 모델 테스트 index_to_tag = {0 : '부정', 1 : '긍정'} def predict(text, model, word_to_index, index_to_tag): # 모델 평가 모드 model.eval() # 토큰화 및 정수 인코딩. OOV 문제 발생 시 <UNK> 토큰에 해당하는 인덱스 1 할당 tokens = word_tokenize(text) token_indices = [word_to_index.get(token.lower(), 1) for token in tokens] # 리스트를 텐서로 변경 input_tensor = torch.tensor([token_indices], dtype=torch.long).to(device) # (1, seq_length) # 모델의 예측 with torch.no_grad(): logits = model(input_tensor) # (1, output_dim) # 레이블 인덱스 예측 _, predicted_index = torch.max(logits, dim=1) # (1, ) # 인덱스와 매칭되는 카테고리 문자열로 변경 predicted_tag = index_to_tag[predicted_index.item()] return predicted_tag test_input = "This movie was just way too overrated. The fighting was not professional and in slow motion. I was expecting more from a 200 million budget movie. The little sister of T.Challa was just trying too hard to be funny. The story was really dumb as well. Don't watch this movie if you are going because others say its great unless you are a Black Panther fan or Marvels fan." predict(test_input, model, word_to_index, index_to_tag) 부정 test_input = " I was lucky enough to be included in the group to see the advanced screening in Melbourne on the 15th of April, 2012. And, firstly, I need to say a big thank-you to Disney and Marvel Studios. Now, the film... how can I even begin to explain how I feel about this film? It is, as the title of this review says a 'comic book triumph'. I went into the film with very, very high expectations and I was not disappointed. Seeing Joss Whedon's direction and envisioning of the film come to life on the big screen is perfect. The script is amazingly detailed and laced with sharp wit a humor. The special effects are literally mind-blowing and the action scenes are both hard-hitting and beautifully choreographed." predict(test_input, model, word_to_index, index_to_tag) 긍정 14. [NLP 기본 ] 시퀀스 레이블링(Sequence Labeling) 이번 챕터에서는 다대다 RNN을 이용한 시퀀스 레이블링(Sequence Labeling)에 대해서 학습합니다. 14-01 시퀀스 레이블링(Sequence Labeling) 이번 챕터에서는 파이 토치(PyTorch)로 인공 신경망을 이용하여 태깅 작업을 하는 모델을 만듭니다. 개체명 인식 기와 품사 태거를 만드는 데, 이러한 두 작업의 공통점은 RNN의 다-대-다(Many-to-Many) 작업이면서 또한 앞, 뒤 시점의 입력을 모두 참고하는 양방향 RNN(Bidirectional RNN)을 사용한다는 점입니다. 실습 챕터를 진행하기 전에 전체적으로 실습이 어떻게 진행되는지 정리해 보도록 하겠습니다. 텍스트 분류 개요 챕터와 겹치는 부분에 대해서는 요약하여 설명하므로, 이해가 되지 않는 부분이 있다면 해당 챕터를 참고 바랍니다. 1. 훈련 데이터에 대한 이해 태깅 작업은 앞서 배운 텍스트 분류 작업과 동일하게 지도 학습(Supervised Learning)에 속합니다. 이 챕터에서는 태깅을 해야 하는 단어 데이터를 X, 레이블에 해당되는 태깅 정보 데이터는 y라고 이름을 붙였습니다. X에 대한 훈련 데이터는 X_train, 테스트 데이터는 X_test라고 명명하고 y에 대한 훈련 데이터는 y_train, 테스트 데이터는 y_test라고 명명합니다. 이번 챕터에서 X와 y 데이터의 쌍(pair)은 병렬 구조를 가진다는 특징을 가집니다. X와 y의 각 샘플의 길이는 같습니다. 예를 들어 품사 태깅 작업을 한다고 가정해 보겠습니다. 그리고 X_train와 y_train의 데이터 중 4개의 샘플만 확인해 본다고 가정해 보겠습니다. 이때 데이터는 다음과 같은 구조를 가집니다. X_train y_train 길이 0 ['EU', 'rejects', 'German', 'call', 'to', 'boycott', 'British', 'lamb'] ['B-ORG', 'O', 'B-MISC', 'O', 'O', 'O', 'B-MISC', 'O'] 1 ['peter', 'blackburn'] ['B-PER', 'I-PER'] 2 ['brussels', '1996-08-22' ] ['B-LOC', 'O'] 3 ['The', 'European', 'Commission'] ['O', 'B-ORG', 'I-ORG'] 가령, X_train[3]의 'The'와 y_train[3]의 'O'는 하나의 쌍(pair)입니다. 또한, X_train[3]의 'European'과 y_train[3]의 'B-ORG'는 쌍의 관계를 가지며, X_train[3]의 'Commision'과 y_train[3]의 'I-ORG'는 쌍의 관계를 가집니다. 이렇게 병렬 관계를 가지는 각 데이터는 정수 인코딩 과정을 거친 후, 모든 데이터의 길이를 동일하게 맞춰주기 위한 패딩(Padding) 작업을 거칩니다. 2. 시퀀스 레이블링(Sequence Labeling) 위와 같이 입력 시퀀스 X = [ 1 x, 3 , ..., n ]에 대하여 레이블 시퀀스 y = [ 1 y, 3 , ..., n ]를 각각 부여하는 작업을 시퀀스 레이블링 작업(Sequence Labeling Task)이라고 합니다. 태깅 작업은 대표적인 시퀀스 레이블링 작업입니다. 3. 양방향 RNN(Bidirectional RNN) nn.RNN(input_size = input_size, hidden_size = hidden_size, num_layers = 1, batch_first=True, bidirectional = True) 이번 챕터에서도 바닐라 RNN이 아니라 성능이 개선된 RNN인 LSTM이나 GRU 등을 사용합니다. 텍스트 분류 챕터에서는 단방향 RNN을 사용하였지만, 이번 챕터에서는 양방향 RNN을 사용합니다. 이전 시점의 단어 정보뿐만 아니라, 다음 시점의 단어 정보도 참고하기 위함입니다. 양방향은 기존의 단방향 nn.RNN()에서 bidirectional 인자의 값으로 True를 넣으면 됩니다. 4. RNN의 다-대-다(Many-to-Many) 문제 이제 RNN이 어떻게 설계되는지 확인해 보도록 하겠습니다. 예를 들어 위에서 설명한 데이터 중 첫 번째 데이터에 해당되는 X_train[0]를 가지고 4번의 시점(time steps)까지 RNN을 진행하였을 때의 그림은 다음과 같습니다. 하지만 이번 실습에서는 양방향 RNN을 사용할 것이므로 아래의 그림과 같습니다. 14-02 개체명 인식 이해하기 코퍼스로부터 각 개체(entity)의 유형을 인식하는 개체명 인식(Named Entity Recognition)에 대해서 학습합니다. 개체명 인식을 사용하면 코퍼스로부터 어떤 단어가 사람, 장소, 조직 등을 의미하는 단어인지를 찾을 수 있습니다. 1. 개체명 인식(Named Entity Recognition)이란? 개체명 인식(Named Entity Recognition)이란 말 그대로 이름을 가진 개체(named entity)를 인식하겠다는 것을 의미합니다. 좀 더 쉽게 설명하면, 어떤 이름을 의미하는 단어를 보고는 그 단어가 어떤 유형인지를 인식하는 것을 말합니다. 예를 들어 유정이는 2018년에 골드만삭스에 입사했다.라는 문장이 있을 때, 사람(person), 조직(organization), 시간(time)에 대해 개체명 인식을 수행하는 모델이라면 다음과 같은 결과를 보여줍니다. 유정 - 사람 2018년 - 시간 골드만삭스 - 조직 2. NLTK를 이용한 개체명 인식(Named Entity Recognition using NTLK) NLTK에서는 개체명 인식기(NER chunker)를 지원하고 있으므로, 별도 개체명 인식기를 구현할 필요 없이 NLTK를 사용해서 개체명 인식을 수행할 수 있습니다. 만약 아래의 실습에서 nltk.download('maxent_ne_chunker'), nltk.download('words') 등의 설치를 요구하는 에러 문구가 뜬다면, 지시하는 대로 설치하면 됩니다. from nltk import word_tokenize, pos_tag, ne_chunk sentence = "James is working at Disney in London" # 토큰화 후 품사 태깅 tokenized_sentence = pos_tag(word_tokenize(sentence)) print(tokenized_sentence) [('James', 'NNP'), ('is', 'VBZ'), ('working', 'VBG'), ('at', 'IN'), ('Disney', 'NNP'), ('in', 'IN'), ('London', 'NNP')] # 개체명 인식 ner_sentence = ne_chunk(tokenized_sentence) print(ner_sentence) (S (PERSON James/NNP) is/VBZ working/VBG at/IN (ORGANIZATION Disney/NNP) in/IN (GPE London/NNP)) ne_chunk는 개체명을 태깅 하기 위해서 앞서 품사 태깅(pos_tag)이 수행되어야 합니다. 위의 결과에서 James는 PERSON(사람), Disney는 조직(ORGANIZATION), London은 위치(GPE)라고 정상적으로 개체명 인식이 수행된 것을 볼 수 있습니다. 뒤의 실습에서 인공 신경망을 이용하여 개체명 인식 모델을 만들어보겠습니다. 14-03 양방향 LSTM을 이용한 개체 명인식 PyTorch의 양방향 LSTM(Bidirectional LSTM)을 이용하여 개체명 인식 모델을 구현해 보겠습니다. 1. 데이터 로드 및 단어 토큰화 import urllib.request import numpy as np from tqdm import tqdm import re from collections import Counter import matplotlib.pyplot as plt from sklearn.model_selection import train_test_split NLTK를 이용하면 영어 코퍼스에 토큰화와 품사 태깅 전처리를 진행한 문장 데이터를 받아올 수 있습니다. 해당 데이터를 훈련시켜 품사 태깅을 수행하는 모델을 만들어보겠습니다. 저자의 깃허브로부터 데이터를 다운로드합니다. urllib.request.urlretrieve("https://raw.githubusercontent.com/ukairia777/tensorflow-nlp-tutorial/main/12.%20RNN%20Sequence%20Labeling/dataset/train.txt", filename="train.txt") 전처리 후 전체 문장 샘플의 개수를 확인합니다. f = open('train.txt', 'r') tagged_sentences = [] sentence = [] for line in f: if len(line)==0 or line.startswith('-DOCSTART') or line[0]=="\n": if len(sentence) > 0: tagged_sentences.append(sentence) sentence = [] continue splits = line.split(' ') # 공백을 기준으로 속성을 구분한다. splits[-1] = re.sub(r'\n', '', splits[-1]) # 줄바꿈 표시 \n을 제거한다. word = splits[0].lower() # 단어들은 소문자로 바꿔서 저장한다. sentence.append([word, splits[-1]]) # 단어와 개체명 태깅만 기록한다. print("전체 샘플 개수: ", len(tagged_sentences)) # 전체 샘플의 개수 출력 전체 샘플 개수: 14041 첫 번째 샘플만 출력해 보겠습니다. print(tagged_sentences[0]) # 첫 번째 샘플 출력 [['eu', 'B-ORG'], ['rejects', 'O'], ['german', 'B-MISC'], ['call', 'O'], ['to', 'O'], ['boycott', 'O'], ['british', 'B-MISC'], ['lamb', 'O'], ['.', 'O']] 각 문장 샘플에 대해서 단어는 sentences에 태깅 정보는 pos_tags에 저장하고 첫 번째 문장 샘플을 출력해 보겠습니다. sentences, ner_tags = [], [] for tagged_sentence in tagged_sentences: # 14,041개의 문장 샘플을 1개씩 불러온다. sentence, tag_info = zip(*tagged_sentence) # 각 샘플에서 단어들은 sentence에 개체명 태깅 정보들은 tag_info에 저장. sentences.append(list(sentence)) # 각 샘플에서 단어 정보만 저장한다. ner_tags.append(list(tag_info)) # 각 샘플에서 개체명 태깅 정보만 저장한다. print(sentences[0]) print(ner_tags[0]) ['eu', 'rejects', 'german', 'call', 'to', 'boycott', 'british', 'lamb', '.'] ['B-ORG', 'O', 'B-MISC', 'O', 'O', 'O', 'B-MISC', 'O', 'O'] 첫 번째 샘플에 대해서 단어에 대해서 sentences[0]에, 품사에 대해서만 pos_tags[0]에 저장된 것을 볼 수 있습니다. 뒤에서 보겠지만, sentences는 예측을 위한 X에 해당되며 pos_tags는 예측 대상인 y에 해당됩니다. 임의로 12번 인덱스 샘플에 대해서도 확인해 보겠습니다. print(sentences[12]) print(ner_tags[12]) ['only', 'france', 'and', 'britain', 'backed', 'fischler', "'s", 'proposal', '.'] ['O', 'B-LOC', 'O', 'B-LOC', 'O', 'B-PER', 'O', 'O', 'O'] 단어에 대해서만 sentences[12]에, 또한 품사에 대해서만 pos_tags[12]에 저장된 것을 확인할 수 있습니다. 또한 첫 번째 샘플과 길이가 다른 것을 볼 수 있습니다. 이제 훈련 데이터와 테스트 데이터를 분리해 봅시다. X_train, X_test, y_train, y_test = train_test_split(sentences, ner_tags, test_size=.2, random_state=777) 학습이 진행되는 동안 성능을 확인하기 위한 검증 데이터 또한 분리합니다. X_train, X_valid, y_train, y_valid = train_test_split(X_train, y_train, test_size=.2, random_state=777) 학습 데이터, 검증 데이터, 테스트 데이터의 개수는 다음과 같습니다. print('훈련 데이터의 개수 :', len(X_train)) print('검증 데이터의 개수 :', len(X_valid)) print('테스트 데이터의 개수 :', len(X_test)) print('훈련 데이터 레이블의 개수 :', len(X_train)) print('검증 데이터 레이블의 개수 :', len(X_valid)) print('테스트 데이터 레이블의 개수 :', len(X_test)) 훈련 데이터의 개수 : 8985 검증 데이터의 개수 : 2247 테스트 데이터의 개수 : 2809 훈련 데이터 레이블의 개수 : 8985 검증 데이터 레이블의 개수 : 2247 테스트 데이터 레이블의 개수 : 2809 학습 데이터의 상위 2개 샘플만 출력해 봅시다. 현재 데이터는 단어 토큰 화가 된 상태입니다. # 상위 샘플 2개 출력 for sent in X_train[:2]: print(sent) ['young', 'boys', '9', '1', '0', '8', '6', '19', '3'] ['hentgen', '(', '17-7', ')', 'surrendered', 'just', 'three', 'doubles', 'and', 'a', 'pair', 'of', 'singles', 'in', 'tossing', 'his', 'major-league', 'leading', 'ninth', 'complete', 'game', '.'] 2. Vocab 만들기 단어 집합을 만들어봅시다. 각 단어의 등장 빈도를 카운트해 주는 Counter를 사용하여 각 단어별 빈도수를 기록합니다. 이렇게 기록된 단어의 총 종류를 출력하여 총 단어 수를 확인해 봅시다. word_list = [] for sent in X_train: for word in sent: word_list.append(word) word_counts = Counter(word_list) print('총 단어 수 :', len(word_counts)) 총 단어 수 : 16742 단어 수는 16,742개입니다. 임의로 영단어 the와 love의 등장 횟수를 확인해 보겠습니다. print('훈련 데이터에서의 단어 the의 등장 횟수 :', word_counts['the']) print('훈련 데이터에서의 단어 love의 등장 횟수 :', word_counts['love']) 훈련 데이터에서의 단어 the의 등장 횟수 : 5410 훈련 데이터에서의 단어 love의 등장 횟수 : 7 영단어 the의 등장 횟수는 5,410회이며, 영단어 love의 등장 횟수는 7회입니다. word_counts를 정렬하고 등장 빈도 상위 10개 단어를 출력해 봅시다. vocab = sorted(word_counts, key=word_counts.get, reverse=True) print('등장 빈도수 상위 10개 단어') print(vocab[:10]) 등장 빈도수 상위 10개 단어 ['the', ',', '.', 'of', 'in', 'to', 'a', ')', '(', 'and'] 이제 단어 집합을 만들기 위해서 패딩을 위한 토큰, 그리고 OOV 문제(Out-Of-Vocabulary) 발생 시에 사용하는 UNK 토큰을 위한 정수 0과 1을 각각 단어 집합에 할당합니다. word_to_index = {} word_to_index['<PAD>'] = 0 word_to_index['<UNK>'] = 1 for index, word in enumerate(vocab) : word_to_index[word] = index + 2 vocab_size = len(word_to_index) print('패딩 토큰과 UNK 토큰을 고려한 단어 집합의 크기 :', vocab_size) 패딩 토큰과 UNK 토큰을 고려한 단어 집합의 크기 : 16744 print('단어 <PAD>와 매핑되는 정수 :', word_to_index['<PAD>']) print('단어 <UNK>와 매핑되는 정수 :', word_to_index['<UNK>']) print('단어 the와 매핑되는 정수 :', word_to_index['the']) 단어 <PAD>와 매핑되는 정수 : 0 단어 <UNK>와 매핑되는 정수 : 1 단어 the와 매핑되는 정수 : 2 3. 정수 인코딩 텍스트를 정수로 변환해 주는 함수를 만듭니다. 해당 함수는 OOV 문제가 발생할 경우 해당 단어는 토큰과 매핑되는 정수인 1로 변환합니다. def texts_to_sequences(tokenized_X_data, word_to_index): encoded_X_data = [] for sent in tokenized_X_data: index_sequences = [] for word in sent: try: index_sequences.append(word_to_index[word]) except KeyError: index_sequences.append(word_to_index['<UNK>']) encoded_X_data.append(index_sequences) return encoded_X_data 훈련 데이터, 검증 데이터, 테스트 데이터에 대해서 정수 인코딩을 진행합니다. encoded_X_train = texts_to_sequences(X_train, word_to_index) encoded_X_valid = texts_to_sequences(X_valid, word_to_index) encoded_X_test = texts_to_sequences(X_test, word_to_index) 정수 인코딩 된 상위 샘플 2개만 출력해 봅시다. # 상위 샘플 2개 출력 for sent in encoded_X_train[:2]: print(sent) [1260, 3215, 117, 17, 21, 123, 56, 539, 23] [5456, 10, 8229, 9, 8230, 186, 84, 1815, 11, 8, 1073, 5, 421, 6, 8231, 35, 2043, 291, 790, 957, 267, 4] 정수로부터 단어로 변환하는 word_to_index의 key와 value를 반대로 저장하여 index_to_word를 만들고, 정수 인코딩 된 첫 번째 샘플을 복원해 봅시다. index_to_word = {} for key, value in word_to_index.items(): index_to_word[value] = key decoded_sample = [index_to_word[word] for word in encoded_X_train[0]] print('기존의 첫 번째 샘플 :', X_train[0]) print('복원된 첫 번째 샘플 :', decoded_sample) 기존의 첫 번째 샘플 : ['young', 'boys', '9', '1', '0', '8', '6', '19', '3'] 복원된 첫 번째 샘플 : ['young', 'boys', '9', '1', '0', '8', '6', '19', '3'] 이제 레이블에 대해서도 정수 인코딩을 진행해야 합니다. 레이블에 존재하는 모든 단어들의 집합을 구해봅시다. # y_train으로부터 존재하는 모든 태그들의 집합 구하기 flatten_tags = [tag for sent in y_train for tag in sent] tag_vocab = list(set(flatten_tags)) print('태그 집합 :', tag_vocab) print('태그 집합의 크기 :', len(tag_vocab)) 태그 집합 : ['B-PER', 'I-MISC', 'B-ORG', 'I-PER', 'B-LOC', 'I-LOC', 'I-ORG', 'O', 'B-MISC'] 태그 집합의 크기 : 9 레이블의 각 단어에 정수를 부여하여 단어 집합(Vocabulary)를 만듭니다. tag_to_index = {} tag_to_index['<PAD>'] = 0 for index, word in enumerate(tag_vocab) : tag_to_index[word] = index + 1 tag_vocab_size = len(tag_to_index) # print('패딩 토큰까지 포함된 태그 집합의 크기 :', tag_vocab_size) print('태그 집합 :', tag_to_index) 태그 집합 : {'<PAD>': 0, 'B-PER': 1, 'I-MISC': 2, 'B-ORG': 3, 'I-PER': 4, 'B-LOC': 5, 'I-LOC': 6, 'I-ORG': 7, 'O': 8, 'B-MISC': 9} many-to-many 문제의 경우에는 레이블도 시퀀스 데이터가 되므로 각 레이블을 정수 시퀀스로 변환해 줍니다. 다시 말해 레이블에 대해서 정수 인코딩을 진행합니다. 이를 위해 tag_to_index를 이용하여 레이블의 각 단어를 정수로 변환하는 함수인 encoding_label() 함수를 구현합니다. def encoding_label(sequence, tag_to_index): label_sequence = [] for seq in sequence: label_sequence.append([tag_to_index[tag] for tag in seq]) return label_sequence 상위 2개의 샘플에 대해서 정수 인코딩 된 결과를 출력해 봅시다. print('X 데이터 상위 2개') print(encoded_X_train[:2]) print('-' * 50) print('y 데이터 상위 2개') print(encoded_y_train[:2]) print('-' * 50) print('첫 번째 샘플과 레이블의 길이') print(len(encoded_X_train[0])) print(len(encoded_y_train[0])) X 데이터 상위 2개 [[1260, 3215, 117, 17, 21, 123, 56, 539, 23], [5456, 10, 8229, 9, 8230, 186, 84, 1815, 11, 8, 1073, 5, 421, 6, 8231, 35, 2043, 291, 790, 957, 267, 4]] -------------------------------------------------- y 데이터 상위 2개 [[3, 7, 8, 8, 8, 8, 8, 8, 8], [1, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8]] -------------------------------------------------- 첫 번째 샘플과 레이블의 길이 9 4. 패딩 데이터의 길이를 동일하게 맞춰주는 작업인 패딩을 위해서는 각 데이터의 길이 분포를 확인할 필요가 있습니다. print('샘플의 최대 길이 : %d' % max(len(l) for l in encoded_X_train)) print('샘플의 평균 길이 : %f' % (sum(map(len, encoded_X_train))/len(encoded_X_train))) plt.hist([len(s) for s in encoded_X_train], bins=50) plt.xlabel('length of samples') plt.ylabel('number of samples') plt.show() 샘플의 최대 길이 : 78 샘플의 평균 길이 : 14.518420 가장 긴 샘플의 길이는 78이며, 그래프를 봤을 때 전체 데이터의 길이 분포는 대체적으로 약 50내외의 길이를 가지는 것을 볼 수 있습니다. 모델이 처리할 수 있도록 encoded_X_train과 encoded_X_test의 모든 샘플의 길이를 특정 길이로 동일하게 맞춰줄 필요가 있습니다. 특정 길이 변수를 max_len으로 정합니다. 대부분의 리뷰가 내용이 잘리지 않도록 할 수 있는 최적의 max_len의 값은 몇일까요? 전체 샘플 중 길이가 max_len 이하인 샘플의 비율이 몇 % 인지 확인하는 함수를 만듭니다. def below_threshold_len(max_len, nested_list): count = 0 for sentence in nested_list: if(len(sentence) <= max_len): count = count + 1 print('전체 샘플 중 길이가 %s 이하인 샘플의 비율: %s'%(max_len, (count / len(nested_list))*100)) 사실 최대 길이가 78이므로 78로 패딩 해도 됩니다. 여기서는 80 정도로 패딩 해보겠습니다. max_len = 80 below_threshold_len(max_len, encoded_X_train) 전체 샘플 중 길이가 80 이하인 샘플의 비율: 100.0 모든 데이터의 길이를 80으로 패딩 해보겠습니다. max_len을 인자로 입력받아서 max_len보다 짧은 데이터의 경우에는 뒤에 0을 추가하는 함수인 pad_sequences()를 구현합니다. def pad_sequences(sentences, max_len): features = np.zeros((len(sentences), max_len), dtype=int) for index, sentence in enumerate(sentences): if len(sentence) != 0: features[index, :len(sentence)] = np.array(sentence)[:max_len] return features 함수 pad_sequences()로 훈련 데이터, 검증 데이터, 테스트 데이터를 패딩 합니다. 이때 개체명 인식과 같은 Many-to-Many 문제를 푸는 경우에는 레이블도 패딩 해주어야 합니다. 패딩 후에 모든 데이터 길이가 80으로 패딩 되었는지 확인합니다. padded_X_train = pad_sequences(encoded_X_train, max_len=max_len) padded_X_valid = pad_sequences(encoded_X_valid, max_len=max_len) padded_X_test = pad_sequences(encoded_X_test, max_len=max_len) padded_y_train = pad_sequences(encoded_y_train, max_len=max_len) padded_y_valid = pad_sequences(encoded_y_valid, max_len=max_len) padded_y_test = pad_sequences(encoded_y_test, max_len=max_len) print('훈련 데이터의 크기 :', padded_X_train.shape) print('검증 데이터의 크기 :', padded_X_valid.shape) print('테스트 데이터의 크기 :', padded_X_test.shape) print('-' * 30) print('훈련 데이터의 레이블 :', padded_y_train.shape) print('검증 데이터의 레이블 :', padded_y_valid.shape) print('테스트 데이터의 레이블 :', padded_y_test.shape) 훈련 데이터의 크기 : (8985, 80) 검증 데이터의 크기 : (2247, 80) 테스트 데이터의 크기 : (2809, 80) ------------------------------ 훈련 데이터의 레이블 : (8985, 80) 검증 데이터의 레이블 : (2247, 80) 테스트 데이터의 레이블 : (2809, 80) 패딩 후의 데이터를 확인해 보겠습니다. print('훈련 데이터의 상위 샘플 2개') print(padded_X_train[:2]) print('-' * 5 + '레이블' + '-' * 5) print(padded_y_train[:2]) 훈련 데이터의 상위 샘플 2개 [[1260 3215 117 17 21 123 56 539 23 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [5456 10 8229 9 8230 186 84 1815 11 8 1073 5 421 6 8231 35 2043 291 790 957 267 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]] -----레이블----- [[3 7 8 8 8 8 8 8 8 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [1 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]] 5. 모델링 이제 모델을 구현해 봅시다. import torch import torch.nn as nn import torch.optim as optim import torch.nn.functional as F GPU를 사용 가능한 환경인지 확인합니다. USE_CUDA = torch.cuda.is_available() device = torch.device("cuda" if USE_CUDA else "cpu") print("cpu와 cuda 중 다음 기기로 학습함:", device) cpu와 cuda 중 다음 기기로 학습함: cuda cuda라고 출력된다면 GPU를 활용 가능한 환경입니다. 만약, Colab에서 실습 중이고 cuda가 출력되지 않는다면 Colab 화면 상단에서 런타임 > 런타임 유형 변경 > 하드웨어 가속기 > GPU 장비 선택를 이용하여 GPU 장비를 선택하신 후에 실습하시기 바랍니다. 이제 개체명 인식 모델을 만들어봅시다. 만약, 단방향 GRU를 모델로 사용할 경우 코드는 아래와 같습니다. class NERTagger(nn.Module): def __init__(self, vocab_size, embedding_dim, hidden_dim, output_dim): super(NERTagger, self).__init__() self.embedding = nn.Embedding(vocab_size, embedding_dim) self.gru = nn.GRU(embedding_dim, hidden_dim, batch_first=True) self.fc = nn.Linear(hidden_dim, output_dim) def forward(self, x): # x: (batch_size, seq_length) embedded = self.embedding(x) # (batch_size, seq_length, embedding_dim) gru_out, _ = self.gru(embedded) # (batch_size, seq_length, hidden_dim) logits = self.fc(gru_out) # (batch_size, seq_length, output_dim) return logits 하지만 위의 GRU를 양방향 LSTM(Bidirectional LSTM) 2층짜리로 변경하려면 다음과 같이 수정하면 됩니다. class NERTagger(nn.Module): def __init__(self, vocab_size, embedding_dim, hidden_dim, output_dim, num_layers=2): super(NERTagger, self).__init__() self.embedding = nn.Embedding(vocab_size, embedding_dim) self.lstm = nn.LSTM(embedding_dim, hidden_dim, num_layers=num_layers, batch_first=True, bidirectional=True) self.fc = nn.Linear(hidden_dim*2, output_dim) def forward(self, x): # x: (batch_size, seq_length) embedded = self.embedding(x) # (batch_size, seq_length, embedding_dim) lstm_out, _ = self.lstm(embedded) # (batch_size, seq_length, hidden_dim*2) logits = self.fc(lstm_out) # (batch_size, seq_length, output_dim) return logits 위에서 작성한 GRU 코드와 양방향 LSTM 코드의 차이점을 봅시다. nn.GRU를 nn.LSTM으로 변경했습니다. num_layers 매개변수를 추가하고 이를 nn.LSTM 생성자에 전달했습니다. 기본값은 2입니다. bidirectional=True를 추가하여 양방향 LSTM을 사용하도록 설정했습니다. nn.Linear의 입력 차원을 hidden_dim*2로 변경하여 양방향 LSTM의 출력을 처리하도록 했습니다. 사용할 데이터를 파이 토치의 텐서로 변환하고, 배치 단위 처리를 위해 데이터 로더로 변환합니다. X_train_tensor = torch.tensor(padded_X_train, dtype=torch.long) y_train_tensor = torch.tensor(padded_y_train, dtype=torch.long) X_valid_tensor = torch.tensor(padded_X_valid, dtype=torch.long) y_valid_tensor = torch.tensor(padded_y_valid, dtype=torch.long) X_test_tensor = torch.tensor(padded_X_test, dtype=torch.long) y_test_tensor = torch.tensor(padded_y_test, dtype=torch.long) train_dataset = torch.utils.data.TensorDataset(X_train_tensor, y_train_tensor) train_dataloader = torch.utils.data.DataLoader(train_dataset, shuffle=True, batch_size=32) valid_dataset = torch.utils.data.TensorDataset(X_valid_tensor, y_valid_tensor) valid_dataloader = torch.utils.data.DataLoader(valid_dataset, shuffle=False, batch_size=32) test_dataset = torch.utils.data.TensorDataset(X_test_tensor, y_test_tensor) test_dataloader = torch.utils.data.DataLoader(test_dataset, shuffle=False, batch_size=32) 이제 위에서 선언한 NERTagger 클래스로부터 모델 객체를 만들어봅시다. 현재 단어 집합의 크기는 다음과 같습니다. print('단어 집합의 크기:', vocab_size) 단어 집합의 크기: 16744 모델 객체를 선언하기 위한 하이퍼 파라미터 값은 다음과 같습니다. 임베딩 벡터의 차원은 100, LSTM의 은닉 상태의 차원은 256, 출력층의 차원은 tag_vocab_size이며 앞에서 확인한 바와 같이 10이며, 학습률(learning rate)는 0.01, 학습 횟수에 해당하는 에포크는 10, LSTM의 은닉층 수는 2로 지정했습니다. embedding_dim = 100 hidden_dim = 256 output_dim = tag_vocab_size learning_rate = 0.01 num_epochs = 10 num_layers = 2 이로부터 모델 객체를 선언합니다. # Model, loss, optimizer model = NERTagger(vocab_size, embedding_dim, hidden_dim, output_dim, num_layers) model.to(device) 앞으로 많이 사용하게 될 비용함수인 nn.CrossEntropyLoss에서는 ignore_index를 통해서 특정 인덱스에 대한 loss를 구하지 않을 수 있습니다. ignore_index=0을 사용하면 패딩 위치에 대해서는 loss를 구하지 않습니다. criterion = nn.CrossEntropyLoss(ignore_index=0) optimizer = optim.Adam(model.parameters(), lr=learning_rate) 6. 평가 코드 작성 학습하는 동안 학습 데이터와 검증 데이터에 대한 정확도와 loss를 구할 것이므로 학습하기 전에 평가 코드를 작성해야만 합니다. 우선 모델의 예측값과 실제 값으로부터 정확도를 구하는 함수인 calculate_accuracy()를 작성합니다. 해당 함수에서 고려해야 할 점은 패딩 토큰이 있는 부분에 대해서는 계산을 하지 않는다는 점입니다. def calculate_accuracy(logits, labels, ignore_index=0): # 예측 레이블을 구합니다. predicted = torch.argmax(logits, dim=1) # 패딩 토큰은 무시합니다. mask = (labels != ignore_index) # 정답을 맞힌 경우를 집계합니다. correct = (predicted == labels).masked_select(mask).sum().item() total = mask.sum().item() accuracy = correct / total return accuracy 검증 데이터의 데이터 로더로부터 모델의 성능을 측정하는 evaluate() 함수를 구현합니다. evaluate() 함수 내부에서는 위에서 작성한 calculate_accuracy()를 호출하여 사용하고 있습니다. def evaluate(model, valid_dataloader, criterion, device): val_loss = 0 val_correct = 0 val_total = 0 model.eval() with torch.no_grad(): for batch_X, batch_y in valid_dataloader: batch_X, batch_y = batch_X.to(device), batch_y.to(device) # Forward pass logits = model(batch_X) # Compute loss loss = criterion(logits.view(-1, output_dim), batch_y.view(-1)) # Calculate validation accuracy and loss val_loss += loss.item() val_correct += calculate_accuracy(logits.view(-1, output_dim), batch_y.view(-1)) * batch_y.size(0) val_total += batch_y.size(0) val_accuracy = val_correct / val_total val_loss /= len(valid_dataloader) return val_loss, val_accuracy 7. 모델 학습하기 # Training loop best_val_loss = float('inf') for epoch in range(num_epochs): # Training train_loss = 0 train_correct = 0 train_total = 0 model.train() for batch_X, batch_y in train_dataloader: # Forward pass batch_X, batch_y = batch_X.to(device), batch_y.to(device) logits = model(batch_X) # Compute loss loss = criterion(logits.view(-1, output_dim), batch_y.view(-1)) # Backward pass and optimization optimizer.zero_grad() loss.backward() optimizer.step() # Calculate training accuracy and loss train_loss += loss.item() train_correct += calculate_accuracy(logits.view(-1, output_dim), batch_y.view(-1)) * batch_y.size(0) train_total += batch_y.size(0) train_accuracy = train_correct / train_total train_loss /= len(train_dataloader) # Validation val_loss, val_accuracy = evaluate(model, valid_dataloader, criterion, device) print(f'Epoch {epoch+1}/{num_epochs}:') print(f'Train Loss: {train_loss:.4f}, Train Accuracy: {train_accuracy:.4f}') print(f'Validation Loss: {val_loss:.4f}, Validation Accuracy: {val_accuracy:.4f}') # 검증 손실이 최소일 때 체크포인트 저장 if val_loss < best_val_loss: print(f'Validation loss improved from {best_val_loss:.4f} to {val_loss:.4f}. 체크포인트를 저장합니다.') best_val_loss = val_loss torch.save(model.state_dict(), 'best_model_checkpoint.pth') 8. 모델 로드 및 평가 위에서 저장해둔 Best 모델을 로드하여 정상 로드되었는지 확인하기 위해서 검증 데이터에 대한 정확도와 손실을 출력하고, 테스트 데이터에 대해서도 평가를 진행합니다. # 모델 로드 model.load_state_dict(torch.load('best_model_checkpoint.pth')) # 모델을 device에 올립니다. model.to(device) # 검증 데이터에 대한 정확도(accuracy)와 손실(loss) 계산 val_loss, val_accuracy = evaluate(model, valid_dataloader, criterion, device) print(f'Best model validation loss: {val_loss:.4f}') print(f'Best model validation accuracy: {val_accuracy:.4f}') Best model validation loss: 0.1606 Best model validation accuracy: 0.9560 테스트 데이터에 대해서도 정확도와 손실을 계산합니다. # 테스트 데이터에 대한 정확도와 손실 계산 test_loss, test_accuracy = evaluate(model, test_dataloader, criterion, device) print(f'Best model test loss: {test_loss:.4f}') print(f'Best model test accuracy: {test_accuracy:.4f}') Best model test loss: 0.1609 Best model test accuracy: 0.9566 9. 인퍼런스 및 테스트 모델을 서비스에 적용하게 되면 전처리가 전혀 되어있지 않은 임의의 텍스트 입력에 대해서 동작해야 할 것입니다. 임의의 텍스트 입력에 대해서 예측 레이블을 리턴하는 함수를 만들어봅시다. index_to_tag = {} for key, value in tag_to_index.items(): index_to_tag[value] = key def predict_labels(text, model, word_to_ix, index_to_tag, max_len=150): # 단어 토큰화 tokens = text.split() # 정수 인코딩 token_indices = [word_to_ix.get(token, 1) for token in tokens] # 패딩 token_indices_padded = np.zeros(max_len, dtype=int) token_indices_padded[:len(token_indices)] = token_indices[:max_len] # 텐서로 변환 input_tensor = torch.tensor(token_indices_padded, dtype=torch.long).unsqueeze(0).to(device) # 모델의 입력으로 사용하고 예측값 리턴 model.eval() with torch.no_grad(): logits = model(input_tensor) # 가장 값이 높은 인덱스를 예측값으로 선택 predicted_indices = torch.argmax(logits, dim=-1).squeeze(0).tolist() # 패딩 토큰 제거 predicted_indices_no_pad = predicted_indices[:len(tokens)] # 패딩 토큰을 제외하고 정수 시퀀스를 예측 시퀀스로 변환 predicted_tags = [index_to_tag[index] for index in predicted_indices_no_pad] return predicted_tags 학습에 사용되지 않은 테스트 데이터의 첫 번째 샘플을 이용해 봅시다. 현재 이 데이터는 이미 단어 토큰 화가 된 상태라서 단어 토큰화 이전 상태로 되돌려 전처리가 전혀 되어있지 않은 입력을 가정하고 함수에 입력으로 사용하겠습니다. print(X_test[0]) ['feyenoord', 'rotterdam', 'suffered', 'an', 'early', 'shock', 'when', 'they', 'went', '1-0', 'down', 'after', 'four', 'minutes', 'against', 'de', 'graafschap', 'doetinchem', '.'] 토큰화 이전 상태로 돌린 후는 다음과 같습니다. sample = ' '.join(X_test[0]) print(sample) feyenoord rotterdam suffered an early shock when they went 1-0 down after four minutes against de graafschap doetinchem . 실제 레이블과 예측값을 비교해 봅시다. predicted_tags = predict_labels(sample, model, word_to_index, index_to_tag) print('예측 :', predicted_tags) print('실 제값 :', y_test[0]) 예측 : ['B-ORG', 'I-ORG', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'B-ORG', 'I-ORG', 'I-ORG', 'O'] 실제 값 : ['B-ORG', 'I-ORG', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'B-ORG', 'I-ORG', 'O'] 15. [NLP 고급 ] 서브 워드 토크 나이저(Subword Tokenizer) 기계에게 아무리 많은 단어를 학습시켜도, 세상의 모든 단어를 알려줄 수는 없는 노릇입니다. 만약, 기계가 모르는 단어가 등장하면 그 단어를 단어 집합에 없는 단어란 의미에서 OOV(Out-Of-Vocabulary) 또는 UNK(Unknown Token)라고 표현합니다. 기계가 문제를 풀 때, 모르는 단어가 등장하면 (사람도 마찬가지지만) 주어진 문제를 푸는 것이 까다로워집니다. 이와 같이 모르는 단어로 인해 문제를 푸는 것이 까다로워지는 상황을 OOV 문제라고 합니다. 서브 워드 분리(Subword segmenation) 작업은 하나의 단어는 더 작은 단위의 의미 있는 여러 서브 워드들(Ex) birthplace = birth + place)의 조합으로 구성된 경우가 많기 때문에, 하나의 단어를 여러 서브 워드로 분리해서 단어를 인코딩 및 임베딩하겠다는 의도를 가진 전처리 작업입니다. 이를 통해 OOV나 희귀 단어, 신조어와 같은 문제를 완화시킬 수 있습니다. 실제로 언어의 특성에 따라 영어권 언어나 한국어는 서브 워드 분리를 시도했을 때 어느 정도 의미 있는 단위로 나누는 것이 가능합니다. 이 책에서는 이런 작업을 하는 토크 나이저를 서브 워드 토크 나이저라고 명명하겠습니다. 이번 챕터에서는 서브 워드 토크 나이저의 주요 알고리즘인 바이트 페어 인코딩과 실제 실무에서 사용하는 서브 워드 토크 나이저 구현체인 SentencePiece와 Huggingface의 Tokenizers에 대해서 소개합니다. 15-01 바이트 페어 인코딩(Byte Pair Encoding, BPE) 기계에게 아무리 많은 단어를 학습시켜도 세상의 모든 단어를 알려줄 수는 없는 노릇입니다. 만약 기계가 모르는 단어가 등장하면 그 단어를 단어 집합에 없는 단어란 의미에서 해당 토큰을 UNK(Unknown Token)라고 표현합니다. 기계가 문제를 풀 때 모르는 단어가 등장하면 (사람도 마찬가지지만) 주어진 문제를 푸는 것이 까다로워집니다. 이와 같이 모르는 단어로 인해 문제를 푸는 것이 까다로워지는 상황을 OOV(Out-Of-Vocabulary) 문제라고 합니다. 서브 워드 분리(Subword segmenation) 작업은 하나의 단어는 더 작은 단위의 의미 있는 여러 서브 워드들(Ex) birthplace = birth + place)의 조합으로 구성된 경우가 많기 때문에, 하나의 단어를 여러 서브 워드로 분리해서 단어를 인코딩 및 임베딩하겠다는 의도를 가진 전처리 작업입니다. 이를 통해 OOV나 희귀 단어, 신조어와 같은 문제를 완화시킬 수 있습니다. 실제로 언어의 특성으로 인해 영어나 한국어는 서브 워드 분리를 시도했을 때 어느 정도 의미 있는 단위로 나누는 것이 가능합니다. 이 책에서는 이런 작업을 하는 토크 나이저를 서브 워드 토크 나이저라고 명명합니다. 여기서는 OOV(Out-Of-Vocabulary) 문제를 완화하는 대표적인 서브 워드 분리 알고리즘인 BPE(Byte Pair Encoding) 알고리즘을 소개합니다. 1. BPE(Byte Pair Encoding) BPE(Byte pair encoding) 알고리즘은 1994년에 제안된 데이터 압축 알고리즘입니다. 하지만 후에 자연어 처리의 서브 워드 분리 알고리즘으로 응용되었는데 이에 대해서는 뒤에 언급하도록 하고, 우선 기존의 BPE의 작동 방법에 대해서 이해해 보겠습니다. 아래와 같은 문자열이 주어졌을 때 BPE을 수행한다고 해봅시다. aaabdaaabac BPE은 기본적으로 연속적으로 가장 많이 등장한 글자의 쌍을 찾아서 하나의 글자로 병합하는 방식을 수행합니다. 태생이 압축 알고리즘인 만큼, 여기서는 글자 대신 바이트(byte)라는 표현을 사용하겠습니다. 예를 들어 위의 문자열 중 가장 자주 등장하고 있는 바이트의 쌍(byte pair)은 'aa'입니다. 이 'aa'라는 바이트의 쌍을 하나의 바이트인 'Z'로 치환해 보겠습니다. ZabdZabac Z=aa 위 문자열 중에서 가장 많이 등장하고 있는 바이트의 쌍은 'ab'입니다. 이 'ab'를 'Y'로 치환해 봅시다. ZYdZYac Y=ab Z=aa 가장 많이 등장하고 있는 바이트의 쌍은 'ZY'입니다. 이를 'X'로 치환해 봅시다. XdXac X=ZY Y=ab Z=aa 더 이상 병합할 바이트의 쌍은 없으므로 BPE는 위의 결과를 최종 결과로 하여 종료됩니다. 2. 자연어 처리에서의 BPE(Byte Pair Encoding) 논문 : https://arxiv.org/pdf/1508.07909.pdf 자연어 처리에서의 BPE는 서브 워드 분리(subword segmentation) 알고리즘입니다. 기존에 있던 단어를 분리한다는 의미입니다. BPE을 요약하면, 글자(charcter) 단위에서 점차적으로 단어 집합(vocabulary)을 만들어 내는 Bottom up 방식의 접근을 사용합니다. 우선 훈련 데이터에 있는 단어들을 모든 글자(chracters) 또는 유니코드(unicode) 단위로 단어 집합(vocabulary)를 만들고, 가장 많이 등장하는 유니그램을 하나의 유니그램으로 통합합니다. BPE을 자연어 처리에 사용한다고 제안한 논문(Sennrich et al. (2016))에서 이미 BPE의 코드를 공개하였기 때문에, 바로 파이썬 실습이 가능합니다. 코드 실습을 진행하기 전에 육안으로 확인할 수 있는 간단한 예를 들어보겠습니다. 1) 기존의 접근 어떤 훈련 데이터로부터 각 단어들의 빈도수를 카운트했다고 해보겠습니다. 그리고 각 단어와 각 단어의 빈도수가 기록돼 있는 해당 결과는 임의로 딕셔너리(dictionary)란 이름을 붙였습니다. # dictionary # 훈련 데이터에 있는 단어와 등장 빈도수 low : 5, lower : 2, newest : 6, widest : 3 이 훈련 데이터에는 'low'란 단어가 5회 등장하였고, 'lower'란 단어는 2회 등장하였으며, 'newest'란 단어는 6회, 'widest'란 단어는 3회 등장하였다는 의미입니다. 그렇다면 딕셔너리로부터 이 훈련 데이터의 단어 집합(vocabulary)을 얻는 것은 간단합니다. # vocabulary low, lower, newest, widest 단어 집합은 중복을 배제한 단어들의 집합을 의미하므로 기존에 배운 단어 집합의 정의라면, 이 훈련 데이터의 단어 집합에는 'low', 'lower', 'newest', 'widest'라는 4개의 단어가 존재합니다. 그리고 이 경우 테스트 과정에서 'lowest'란 단어가 등장한다면 기계는 이 단어를 학습한 적이 없으므로 해당 단어에 대해서 제대로 대응하지 못하는 OOV 문제가 발생합니다. 그렇다면 BPE를 적용한다면 어떨까요? 2) BPE 알고리즘을 사용한 경우 위의 딕셔너리에 BPE를 적용해 봅시다. 우선 딕셔너리의 모든 단어들을 글자(chracter) 단위로 분리합니다. 이 경우 딕셔너리는 아래와 같습니다. 이제부터 딕셔너리는 자신 또한 업데이트되며 앞으로 단어 집합을 업데이트하기 위해 지속적으로 참고되는 참고 자료의 역할을 합니다. # dictionary l o w : 5, l o w e r : 2, n e w e s t : 6, w i d e s t : 3 딕셔너리를 참고로 한 초기 단어 집합(vocabulary)을 아래와 같습니다. 간단히 말해 초기 구성은 글자 단위로 분리된 상태입니다. # vocabulary l, o, w, e, r, n, s, t, i, d BPE의 특징은 알고리즘의 동작을 몇 회 반복(iteration) 할 것인지를 사용자가 정한다는 점입니다. 여기서는 총 10회를 수행한다고 가정합니다. 다시 말해 가장 빈도수가 높은 유니그램의 쌍을 하나의 유니그램으로 통합하는 과정을 총 10회 반복합니다. 위의 딕셔너리에 따르면 빈도수가 현재 가장 높은 유니그램의 쌍은 (e, s)입니다. 1회 - 딕셔너리를 참고로 하였을 때 빈도수가 9로 가장 높은 (e, s)의 쌍을 es로 통합합니다. # dictionary update! l o w : 5, l o w e r : 2, n e w es t : 6, w i d es t : 3 # vocabulary update! l, o, w, e, r, n, s, t, i, d, es 2회 - 빈도수가 9로 가장 높은 (es, t)의 쌍을 est로 통합합니다. # dictionary update! l o w : 5, l o w e r : 2, n e w est : 6, w i d est : 3 # vocabulary update! l, o, w, e, r, n, s, t, i, d, es, est 3회 - 빈도수가 7로 가장 높은 (l, o)의 쌍을 lo로 통합합니다. # dictionary update! lo w : 5, lo w e r : 2, n e w est : 6, w i d est : 3 # vocabulary update! l, o, w, e, r, n, s, t, i, d, es, est, lo 이와 같은 방식으로 총 10회 반복하였을 때 얻은 딕셔너리와 단어 집합은 아래와 같습니다. # dictionary update! low : 5, low e r : 2, newest : 6, widest : 3 # vocabulary update! l, o, w, e, r, n, s, t, i, d, es, est, lo, low, ne, new, newest, wi, wid, widest 이 경우 테스트 과정에서 'lowest'란 단어가 등장한다면, 기존에는 OOV에 해당되는 단어가 되었겠지만 BPE 알고리즘을 사용한 위의 단어 집합에서는 더 이상 'lowest'는 OOV가 아닙니다. 기계는 우선 'lowest'를 전부 글자 단위로 분할합니다. 즉, 'l, o, w, e, s, t'가 됩니다. 그리고 기계는 위의 단어 집합을 참고로 하여 'low'와 'est'를 찾아냅니다. 즉, 'lowest'를 기계는 'low'와 'est' 두 단어로 인코딩합니다. 그리고 이 두 단어는 둘 다 단어 집합에 있는 단어이므로 OOV가 아닙니다. 이 동작 과정을 그림으로 표현한다면 다음과 같습니다. 실제 코드를 통해 구현해 봅시다. 3) 코드 실습하기 아래 코드는 원 논문에서 공개한 코드를 참고로 하여 수정한 코드입니다. 우선 필요한 도구들을 임포트 합니다. import re, collections from IPython.display import display, Markdown, Latex BPE을 몇 회 수행할 것인지를 정합니다. 여기서는 10회로 정했습니다. num_merges = 10 BPE에 사용할 단어가 low, lower, newest, widest 일 때, BPE의 입력으로 사용하는 실제 단어 집합은 아래와 같습니다. </w>는 단어의 맨 끝에 붙이는 특수 문자이며, 각 단어는 글자(character) 단위로 분리합니다. dictionary = {'l o w </w>' : 5, 'l o w e r </w>' : 2, 'n e w e s t </w>':6, 'w i d e s t </w>':3 } BPE의 코드는 아래와 같습니다. 알고리즘은 위에서 설명했던 것과 동일하게 가장 빈도수가 높은 유니그램의 쌍을 하나의 유니그램으로 통합하는 과정으로 num_merges 회 반복합니다. def get_stats(dictionary): # 유니그램의 pair들의 빈도수를 카운트 pairs = collections.defaultdict(int) for word, freq in dictionary.items(): symbols = word.split() for i in range(len(symbols)-1): pairs[symbols[i],symbols[i+1]] += freq print('현재 pair들의 빈도수 :', dict(pairs)) return pairs def merge_dictionary(pair, v_in): v_out = {} bigram = re.escape(' '.join(pair)) p = re.compile(r'(?<!\S)' + bigram + r'(?!\S)') for word in v_in: w_out = p.sub(''.join(pair), word) v_out[w_out] = v_in[word] return v_out bpe_codes = {} bpe_codes_reverse = {} for i in range(num_merges): display(Markdown("### Iteration {}".format(i + 1))) pairs = get_stats(dictionary) best = max(pairs, key=pairs.get) dictionary = merge_dictionary(best, dictionary) bpe_codes[best] = i bpe_codes_reverse[best[0] + best[1]] = best print("new merge: {}".format(best)) print("dictionary: {}".format(dictionary)) 이를 실행하면 출력 결과는 아래와 같으며 이는 글자들의 통합 과정을 보여주고 있습니다. Iteration 1 현재 pair들의 빈도수 : {('l', 'o'): 7, ('o', 'w'): 7, ('w', '</w>'): 5, ('w', 'e'): 8, ('e', 'r'): 2, ('r', '</w>'): 2, ('n', 'e'): 6, ('e', 'w'): 6, ('e', 's'): 9, ('s', 't'): 9, ('t', '</w>'): 9, ('w', 'i'): 3, ('i', 'd'): 3, ('d', 'e'): 3} new merge: ('e', 's') dictionary: {'l o w </w>': 5, 'l o w e r </w>': 2, 'n e w es t </w>': 6, 'w i d es t </w>': 3} Iteration 2 현재 pair들의 빈도수 : {('l', 'o'): 7, ('o', 'w'): 7, ('w', '</w>'): 5, ('w', 'e'): 2, ('e', 'r'): 2, ('r', '</w>'): 2, ('n', 'e'): 6, ('e', 'w'): 6, ('w', 'es'): 6, ('es', 't'): 9, ('t', '</w>'): 9, ('w', 'i'): 3, ('i', 'd'): 3, ('d', 'es'): 3} new merge: ('es', 't') dictionary: {'l o w </w>': 5, 'l o w e r </w>': 2, 'n e w est </w>': 6, 'w i d est </w>': 3} Iteration 3 현재 pair들의 빈도수 : {('l', 'o'): 7, ('o', 'w'): 7, ('w', '</w>'): 5, ('w', 'e'): 2, ('e', 'r'): 2, ('r', '</w>'): 2, ('n', 'e'): 6, ('e', 'w'): 6, ('w', 'est'): 6, ('est', '</w>'): 9, ('w', 'i'): 3, ('i', 'd'): 3, ('d', 'est'): 3} new merge: ('est', '</w>') dictionary: {'l o w </w>': 5, 'l o w e r </w>': 2, 'n e w est</w>': 6, 'w i d est</w>': 3} Iteration 4 현재 pair들의 빈도수 : {('l', 'o'): 7, ('o', 'w'): 7, ('w', '</w>'): 5, ('w', 'e'): 2, ('e', 'r'): 2, ('r', '</w>'): 2, ('n', 'e'): 6, ('e', 'w'): 6, ('w', 'est</w>'): 6, ('w', 'i'): 3, ('i', 'd'): 3, ('d', 'est</w>'): 3} new merge: ('l', 'o') dictionary: {'lo w </w>': 5, 'lo w e r </w>': 2, 'n e w est</w>': 6, 'w i d est</w>': 3} Iteration 5 현재 pair들의 빈도수 : {('lo', 'w'): 7, ('w', '</w>'): 5, ('w', 'e'): 2, ('e', 'r'): 2, ('r', '</w>'): 2, ('n', 'e'): 6, ('e', 'w'): 6, ('w', 'est</w>'): 6, ('w', 'i'): 3, ('i', 'd'): 3, ('d', 'est</w>'): 3} new merge: ('lo', 'w') dictionary: {'low </w>': 5, 'low e r </w>': 2, 'n e w est</w>': 6, 'w i d est</w>': 3} Iteration 6 현재 pair들의 빈도수 : {('low', '</w>'): 5, ('low', 'e'): 2, ('e', 'r'): 2, ('r', '</w>'): 2, ('n', 'e'): 6, ('e', 'w'): 6, ('w', 'est</w>'): 6, ('w', 'i'): 3, ('i', 'd'): 3, ('d', 'est</w>'): 3} new merge: ('n', 'e') dictionary: {'low </w>': 5, 'low e r </w>': 2, 'ne w est</w>': 6, 'w i d est</w>': 3} Iteration 7 현재 pair들의 빈도수 : {('low', '</w>'): 5, ('low', 'e'): 2, ('e', 'r'): 2, ('r', '</w>'): 2, ('ne', 'w'): 6, ('w', 'est</w>'): 6, ('w', 'i'): 3, ('i', 'd'): 3, ('d', 'est</w>'): 3} new merge: ('ne', 'w') dictionary: {'low </w>': 5, 'low e r </w>': 2, 'new est</w>': 6, 'w i d est</w>': 3} Iteration 8 현재 pair들의 빈도수 : {('low', '</w>'): 5, ('low', 'e'): 2, ('e', 'r'): 2, ('r', '</w>'): 2, ('new', 'est</w>'): 6, ('w', 'i'): 3, ('i', 'd'): 3, ('d', 'est</w>'): 3} new merge: ('new', 'est</w>') dictionary: {'low </w>': 5, 'low e r </w>': 2, 'newest</w>': 6, 'w i d est</w>': 3} Iteration 9 현재 pair들의 빈도수 : {('low', '</w>'): 5, ('low', 'e'): 2, ('e', 'r'): 2, ('r', '</w>'): 2, ('w', 'i'): 3, ('i', 'd'): 3, ('d', 'est</w>'): 3} new merge: ('low', '</w>') dictionary: {'low</w>': 5, 'low e r </w>': 2, 'newest</w>': 6, 'w i d est</w>': 3} Iteration 10 현재 pair들의 빈도수 : {('low', 'e'): 2, ('e', 'r'): 2, ('r', '</w>'): 2, ('w', 'i'): 3, ('i', 'd'): 3, ('d', 'est</w>'): 3} new merge: ('w', 'i') dictionary: {'low</w>': 5, 'low e r </w>': 2, 'newest</w>': 6, 'wi d est</w>': 3} e와 s의 쌍은 초기 단어 집합에서 총 9회 등장했습니다. 그렇기 때문에 es로 통합됩니다. 그다음으로는 es와 t의 쌍을, 그다음으로는 est와 </w>의 쌍을 통합시킵니다. 빈도수가 가장 높은 순서대로 통합하는 이 과정을 총 num_merges 회 반복한 것입니다. bpe_codes를 출력하면 merge 했던 기록이 출력됩니다. print(bpe_codes) {('e', 's'): 0, ('es', 't'): 1, ('est', '</w>'): 2, ('l', 'o'): 3, ('lo', 'w'): 4, ('n', 'e'): 5, ('ne', 'w'): 6, ('new', 'est</w>'): 7, ('low', '</w>'): 8, ('w', 'i'): 9} 이 기록은 새로운 단어가 등장하였을 때, 현재 가지고 있는 서브 워드 단어 집합에 의거하여 분리하는 일에 참고할 수 있습니다. 4) OOV에 대처하기 def get_pairs(word): """Return set of symbol pairs in a word. Word is represented as a tuple of symbols (symbols being variable-length strings). """ pairs = set() prev_char = word[0] for char in word[1:]: pairs.add((prev_char, char)) prev_char = char return pairs def encode(orig): """Encode word based on list of BPE merge operations, which are applied consecutively""" word = tuple(orig) + ('</w>',) display(Markdown("__word split into characters:__ <tt>{}</tt>".format(word))) pairs = get_pairs(word) if not pairs: return orig iteration = 0 while True: iteration += 1 display(Markdown("__Iteration {}:__".format(iteration))) print("bigrams in the word: {}".format(pairs)) bigram = min(pairs, key = lambda pair: bpe_codes.get(pair, float('inf'))) print("candidate for merging: {}".format(bigram)) if bigram not in bpe_codes: display(Markdown("__Candidate not in BPE merges, algorithm stops.__")) break first, second = bigram new_word = [] i = 0 while i < len(word): try: j = word.index(first, i) new_word.extend(word[i:j]) i = j except: new_word.extend(word[i:]) break if word[i] == first and i < len(word)-1 and word[i+1] == second: new_word.append(first+second) i += 2 else: new_word.append(word[i]) i += 1 new_word = tuple(new_word) word = new_word print("word after merging: {}".format(word)) if len(word) == 1: break else: pairs = get_pairs(word) # 특별 토큰인 </w>는 출력하지 않는다. if word[-1] == '</w>': word = word[:-1] elif word[-1].endswith('</w>'): word = word[:-1] + (word[-1].replace('</w>',''),) return word 단어 'loki'가 들어오면 BPE 알고리즘 해당 단어를 어떻게 분리할까요? encode("loki") word split into characters: ('l', 'o', 'k', 'i', '') Iteration 1: bigrams in the word: {('i', '</w>'), ('o', 'k'), ('l', 'o'), ('k', 'i')} candidate for merging: ('l', 'o') word after merging: ('lo', 'k', 'i', '</w>') Iteration 2: bigrams in the word: {('i', '</w>'), ('k', 'i'), ('lo', 'k')} candidate for merging: ('i', '</w>') Candidate not in BPE merges, algorithm stops. ('lo', 'k', 'i') 현재 서브 워드 단어 집합에는 'lo'가 존재하므로, 'lo'는 유지하고 'k'와 'i'는 분리시킵니다. 단어 'lowest'에 대해서도 수행해 봅시다. encode("lowest") word split into characters: ('l', 'o', 'w', 'e', 's', 't', '') Iteration 1: bigrams in the word: {('e', 's'), ('s', 't'), ('t', '</w>'), ('o', 'w'), ('w', 'e'), ('l', 'o')} candidate for merging: ('e', 's') word after merging: ('l', 'o', 'w', 'es', 't', '</w>') Iteration 2: bigrams in the word: {('w', 'es'), ('es', 't'), ('t', '</w>'), ('o', 'w'), ('l', 'o')} candidate for merging: ('es', 't') word after merging: ('l', 'o', 'w', 'est', '</w>') Iteration 3: bigrams in the word: {('o', 'w'), ('l', 'o'), ('est', '</w>'), ('w', 'est')} candidate for merging: ('est', '</w>') word after merging: ('l', 'o', 'w', 'est</w>') Iteration 4: bigrams in the word: {('o', 'w'), ('l', 'o'), ('w', 'est</w>')} candidate for merging: ('l', 'o') word after merging: ('lo', 'w', 'est</w>') Iteration 5: bigrams in the word: {('lo', 'w'), ('w', 'est</w>')} candidate for merging: ('lo', 'w') word after merging: ('low', 'est</w>') Iteration 6: bigrams in the word: {('low', 'est</w>')} candidate for merging: ('low', 'est</w>') Candidate not in BPE merges, algorithm stops. ('low', 'est') 현재 서브 워드 단어 집합에 'low'와 'est'가 존재하므로, 'low'와 'est'를 분리시킵니다. 단어 'lowing'에 대해서도 수행해 봅시다. encode("lowing") word split into characters: ('l', 'o', 'w', 'i', 'n', 'g', '') Iteration 1: bigrams in the word: {('n', 'g'), ('w', 'i'), ('g', '</w>'), ('i', 'n'), ('o', 'w'), ('l', 'o')} candidate for merging: ('l', 'o') word after merging: ('lo', 'w', 'i', 'n', 'g', '</w>') Iteration 2: bigrams in the word: {('lo', 'w'), ('n', 'g'), ('w', 'i'), ('g', '</w>'), ('i', 'n')} candidate for merging: ('lo', 'w') word after merging: ('low', 'i', 'n', 'g', '</w>') Iteration 3: bigrams in the word: {('n', 'g'), ('g', '</w>'), ('i', 'n'), ('low', 'i')} candidate for merging: ('n', 'g') Candidate not in BPE merges, algorithm stops. ('low', 'i', 'n', 'g') 현재 서브 워드 단어 집합에 'low'가 존재하지만, 'i', 'n', 'g'의 바이 그램 조합으로 이루어진 서브 워드는 존재하지 않으므로 'i', 'n', 'g'로 전부 분리합니다. 훈련된 데이터 중에서 어떤 서브 워드도 존재하지 않는 'highing'은 어떨까요? encode("highing") word split into characters: ('h', 'i', 'g', 'h', 'i', 'n', 'g', '') Iteration 1: bigrams in the word: {('n', 'g'), ('g', 'h'), ('h', 'i'), ('g', '</w>'), ('i', 'n'), ('i', 'g')} candidate for merging: ('n', 'g') Candidate not in BPE merges, algorithm stops. ('h', 'i', 'g', 'h', 'i', 'n', 'g') 모든 알파벳이 분리됩니다. BPE 외에도 BPE를 참고하여 만들어진 Wordpiece Tokenizer나 Unigram Language Model Tokenizer와 같은 서브 워드 분리 알고리즘이 존재합니다. 이 두 알고리즘에 대해서는 간략히 이런 것들이 존재한다 정도로만 언급하고 넘어가겠습니다. 3. WordPiece Tokenizer 논문 : https://static.googleusercontent.com/media/research.google.com/ko//pubs/archive/37842.pdf 구글이 위 WordPiece Tokenizer를 변형하여 번역기에 사용했다는 논문 : https://arxiv.org/pdf/1609.08144.pdf WordPiece Tokenizer은 BPE의 변형 알고리즘입니다. 해당 알고리즘은 BPE가 빈도수에 기반하여 가장 많이 등장한 쌍을 병합하는 것과는 달리, 병합되었을 때 코퍼스의 우도(Likelihood)를 가장 높이는 쌍을 병합합니다. 2016년의 위 논문에서 구글은 구글 번역기에서 WordPiece Tokenizer가 수행된 결과에 대해서 기술하였습니다. 수행하기 이전의 문장: Jet makers feud over seat width with big orders at stake WordPiece Tokenizer를 수행한 결과(wordpieces): _J et _makers _fe ud _over _seat _width _with _big _orders _at _stake Jet는 J와 et로 나누어졌으며, feud는 fe와 ud로 나누어진 것을 볼 수 있습니다. WordPiece Tokenizer는 모든 단어의 맨 앞에 _를 붙이고, 단어는 서브 워드(subword)로 통계에 기반하여 띄어쓰기로 분리합니다. 여기서 언더바 _는 문장 복원을 위한 장치입니다. 예컨대, WordPiece Tokenizer의 결과로 나온 문장을 보면, Jet → _J et와 같이 기존에 없던 띄어쓰기가 추가되어 서브 워드(subwords)들을 구분하는 구분자 역할을 하고 있습니다. 그렇다면 기존에 있던 띄어쓰기와 구분자 역할의 띄어쓰기는 어떻게 구별할까요? 이 역할을 수행하는 것이 단어들 앞에 붙은 언더바 _입니다. WordPiece Tokenizer이 수행된 결과로부터 다시 수행 전의 결과로 돌리는 방법은 현재 있는 모든 띄어쓰기를 전부 제거하고, 언더바를 띄어쓰기로 바꾸면 됩니다. 이 알고리즘은 유명 딥 러닝 모델 BERT를 훈련하기 위해서 사용되기도 하였습니다. 4. Unigram Language Model Tokenizer 논문 : https://arxiv.org/pdf/1804.10959.pdf 유니그램 언어 모델 토크 나이저는 각각의 서브 워드들에 대해서 손실(loss)을 계산합니다. 여기서 서브 단어의 손실이라는 것은 해당 서브 워드가 단어 집합에서 제거되었을 경우, 코퍼스의 우도(Likelihood)가 감소하는 정도를 말합니다. 이렇게 측정된 서브 워드들을 손실의 정도로 정렬하여, 최악의 영향을 주는 10~20%의 토큰을 제거합니다. 이를 원하는 단어 집합의 크기에 도달할 때까지 반복합니다. 지금까지 서브 워드 토크나이징 알고리즘들에 대해서 정리해 보았습니다. 이어서 이를 실무에서 사용하기 위한 패키지인 센텐스 피스(SentencePiece)나 토크 나이 저스(tokenizers)의 사용법에 대해서 학습합니다. 15-02 센텐스 피스(SentencePiece) 앞서 서브 워드 토큰화를 위한 BPE(Byte Pair Encoding) 알고리즘과 그 외 BPE의 변형 알고리즘에 대해서 간단히 언급했습니다. BPE를 포함하여 기타 서브 워드 토크나이징 알고리즘들을 내장한 센텐스 피스(SentencePiece)는 일반적으로 실무에서 선택할 수 있는 최선의 선택 중 하나입니다. 1. 센텐스 피스(SentencePiece) 논문 : https://arxiv.org/pdf/1808.06226.pdf 센텐스 피스 깃허브 : https://github.com/google/sentencepiece 내부 단어 분리를 위한 유용한 패키지로 구글의 센텐스 피스(Sentencepiece)가 있습니다. 구글은 BPE 알고리즘과 Unigram Language Model Tokenizer를 구현한 센텐스 피스를 깃허브에 공개하였습니다. 내부 단어 분리 알고리즘을 사용하기 위해서, 데이터에 단어 토큰화를 먼저 진행한 상태여야 한다면 이 단어 분리 알고리즘을 모든 언어에 사용하는 것은 쉽지 않습니다. 영어와 달리 한국어와 같은 언어는 단어 토큰화부터가 쉽지 않기 때문입니다. 그런데, 이런 사전 토큰화 작업(pretokenization) 없이 전처리를 하지 않은 데이터(raw data)에 바로 단어 분리 토크 나이저를 사용할 수 있다면, 이 토크 나이저는 그 어떤 언어에도 적용할 수 있는 토크 나이저가 될 것입니다. 센텐스 피스는 이 이점을 살려서 구현되었습니다. 센텐스 피스는 사전 토큰화 작업 없이 단어 분리 토큰화를 수행하므로 언어에 종속되지 않습니다. pip install sentencepiece 2. IMDB 리뷰 토큰화하기 import sentencepiece as spm import pandas as pd import urllib.request import csv IMDB 리뷰 데이터를 다운로드하고 이를 데이터 프레임에 저장합니다. urllib.request.urlretrieve("https://raw.githubusercontent.com/LawrenceDuan/IMDb-Review-Analysis/master/IMDb_Reviews.csv", filename="IMDb_Reviews.csv") train_df = pd.read_csv('IMDb_Reviews.csv') train_df['review'] 0 My family and I normally do not watch local mo... 1 Believe it or not, this was at one time the wo... 2 After some internet surfing, I found the "Home... 3 One of the most unheralded great works of anim... 4 It was the Sixties, and anyone with long hair ... ... 49995 the people who came up with this are SICK AND ... 49996 The script is so so laughable... this in turn,... 49997 "So there's this bride, you see, and she gets ... 49998 Your mind will not be satisfied by this no—bud... 49999 The chaser's war on everything is a weekly sho... Name: review, Length: 50000, dtype: object print('리뷰 개수 :',len(train_df)) # 리뷰 개수 출력 리뷰 개수 : 50000 총 5만 개의 샘플이 존재합니다. 센텐스 피스의 입력으로 사용하기 위해서 데이터 프레임을 txt 파일로 저장합니다. with open('imdb_review.txt', 'w', encoding='utf8') as f: f.write('\n'.join(train_df['review'])) 센텐스 피스로 단어 집합과 각 단어에 고유한 정수를 부여해 보겠습니다. spm.SentencePieceTrainer.Train('--input=imdb_review.txt --model_prefix=imdb --vocab_size=5000 --model_type=bpe --max_sentence_length=9999') 각 인자가 의미하는 바는 다음과 같습니다. input : 학습시킬 파일 model_prefix : 만들어질 모델 이름 vocab_size : 단어 집합의 크기 model_type : 사용할 모델 (unigram(default), bpe, char, word) max_sentence_length: 문장의 최대 길이 pad_id, pad_piece: pad token id, 값 unk_id, unk_piece: unknown token id, 값 bos_id, bos_piece: begin of sentence token id, 값 eos_id, eos_piece: end of sequence token id, 값 user_defined_symbols: 사용자 정의 토큰 vocab 생성이 완료되면 imdb.model, imdb.vocab 파일 두 개가 생성됩니다. vocab 파일에서 학습된 서브 워드들을 확인할 수 있습니다. 단어 집합의 크기를 확인하기 위해 vocab 파일을 데이터 프레임에 저장해 봅시다. vocab_list = pd.read_csv('imdb.vocab', sep='\t', header=None, quoting=csv.QUOTE_NONE) vocab_list.sample(10) 위에서 vocab_size의 인자를 통해 단어 집합의 크기를 5,000개로 제한하였으므로 단어 집합의 크기는 5,000개입니다. len(vocab_list) 5000 model 파일을 로드하여 단어 시퀀스를 정수 시퀀스로 바꾸는 인코딩 작업이나 반대로 변환하는 디코딩 작업을 할 수 있습니다. sp = spm.SentencePieceProcessor() vocab_file = "imdb.model" sp.load(vocab_file) True 아래의 두 가지 도구를 테스트해 보겠습니다. encode_as_pieces : 문장을 입력하면 서브 워드 시퀀스로 변환합니다. encode_as_ids : 문장을 입력하면 정수 시퀀스로 변환합니다. lines = [ "I didn't at all think of it this way.", "I have waited a long time for someone to film" ] for line in lines: print(line) print(sp.encode_as_pieces(line)) print(sp.encode_as_ids(line)) print() I didn't at all think of it this way. ['▁ I', '▁ didn', "'", 't', '▁ at', '▁ all', '▁ think', '▁ of', '▁ it', '▁ this', '▁ way', '.'] [41, 623, 4950, 4926, 138, 169, 378, 30, 58, 73, 413, 4945] I have waited a long time for someone to film ['▁ I', '▁ have', '▁ wa', 'ited', '▁ a', '▁ long', '▁ time', '▁ for', '▁ someone', '▁ to', '▁ film'] [41, 141, 1364, 1120, 4, 666, 285, 92, 1078, 33, 91] GetPieceSize() : 단어 집합의 크기를 확인합니다. sp.GetPieceSize() 5000 idToPiece : 정수로부터 매핑되는 서브 워드로 변환합니다. sp.IdToPiece(430) ▁ character PieceToId : 서브 워드로부터 매핑되는 정수로 변환합니다. sp.PieceToId('▁ character') 430 DecodeIds : 정수 시퀀스로부터 문장으로 변환합니다. sp.DecodeIds([41, 141, 1364, 1120, 4, 666, 285, 92, 1078, 33, 91]) DecodePieces : 서브 워드 시퀀스로부터 문장으로 변환합니다. I have waited a long time for someone to film sp.DecodePieces(['▁ I', '▁ have', '▁ wa', 'ited', '▁ a', '▁ long', '▁ time', '▁ for', '▁ someone', '▁ to', '▁ film']) encode : 문장으로부터 인자 값에 따라서 정수 시퀀스 또는 서브 워드 시퀀스로 변환 가능합니다. I have waited a long time for someone to film print(sp.encode('I have waited a long time for someone to film', out_type=str)) print(sp.encode('I have waited a long time for someone to film', out_type=int)) ['▁ I', '▁ have', '▁ wa', 'ited', '▁ a', '▁ long', '▁ time', '▁ for', '▁ someone', '▁ to', '▁ film'] [41, 141, 1364, 1120, 4, 666, 285, 92, 1078, 33, 91] 3. 네이버 영화 리뷰 토큰화하기 네이버 영화 리뷰 데이터에 대해서 위의 IMDB 리뷰 데이터와 동일한 과정을 진행해 보겠습니다. import pandas as pd import sentencepiece as spm import urllib.request import csv 네이버 영화 리뷰 데이터를 다운로드하여 데이터 프레임에 저장합니다. urllib.request.urlretrieve("https://raw.githubusercontent.com/e9t/nsmc/master/ratings.txt", filename="ratings.txt") naver_df = pd.read_table('ratings.txt') naver_df[:5] 총 20만 개의 샘플이 존재합니다. print('리뷰 개수 :',len(naver_df)) # 리뷰 개수 출력 리뷰 개수 : 200000 네이버 영화 리뷰 데이터의 경우 Null 값이 존재하므로 이를 제거한 후에 수행합니다. print(naver_df.isnull().values.any()) True naver_df = naver_df.dropna(how = 'any') # Null 값이 존재하는 행 제거 print(naver_df.isnull().values.any()) # Null 값이 존재하는지 확인 False print('리뷰 개수 :',len(naver_df)) # 리뷰 개수 출력 리뷰 개수 : 199992 최종적으로 199,992개의 샘플을 naver_review.txt 파일에 저장한 후에 센텐스 피스를 통해 단어 집합을 생성합니다. with open('naver_review.txt', 'w', encoding='utf8') as f: f.write('\n'.join(naver_df['document'])) spm.SentencePieceTrainer.Train('--input=naver_review.txt --model_prefix=naver --vocab_size=5000 --model_type=bpe --max_sentence_length=9999') vocab 생성이 완료되면 naver.model, naver.vocab 파일 두 개가 생성됩니다. .vocab에서 학습된 subwords를 확인할 수 있습니다. vocab_list = pd.read_csv('naver.vocab', sep='\t', header=None, quoting=csv.QUOTE_NONE) vocab_list[:10] vocab_list.sample(10) Vocabulary에는 unknown, 문장의 시작, 문장의 끝을 의미하는 special token이 0, 1, 2에 사용되었습니다. len(vocab_list) 5000 설정한 대로 5000개의 서브 워드가 단어 집합에 존재합니다. sp = spm.SentencePieceProcessor() vocab_file = "naver.model" sp.load(vocab_file) True lines = [ "뭐 이딴 것도 영화냐.", "진짜 최고의 영화입니다 ㅋㅋ", ] for line in lines: print(line) print(sp.encode_as_pieces(line)) print(sp.encode_as_ids(line)) print() 뭐 이딴 것도 영화냐. ['▁뭐', '▁이딴', '▁것도', '▁영화냐', '.'] [132, 966, 1296, 2590, 3276] 진짜 최고의 영화입니다 ㅋㅋ ['▁진짜', '▁최고의', '▁영화입니다', '▁ᄏᄏ'] [54, 200, 821, 85] GetPieceSize() : 단어 집합의 크기를 확인합니다. sp.GetPieceSize() 5000 idToPiece : 정수로부터 매핑되는 서브 워드로 변환합니다. sp.IdToPiece(4) '영화' PieceToId : 서브 워드로부터 매핑되는 정수로 변환합니다. sp.PieceToId('영화') DecodeIds : 정수 시퀀스로부터 문장으로 변환합니다. sp.DecodeIds([54, 200, 821, 85]) 진짜 최고의 영화입니다 ᄏᄏ DecodePieces : 서브 워드 시퀀스로부터 문장으로 변환합니다. sp.DecodePieces(['▁진짜', '▁최고의', '▁영화입니다', '▁ᄏᄏ']) 진짜 최고의 영화입니다 ᄏᄏ encode : 문장으로부터 인자 값에 따라서 정수 시퀀스 또는 서브 워드 시퀀스로 변환 가능합니다. print(sp.encode('진짜 최고의 영화입니다 ㅋㅋ', out_type=str)) print(sp.encode('진짜 최고의 영화입니다 ㅋㅋ', out_type=int)) ['▁진짜', '▁최고의', '▁영화입니다', '▁ᄏᄏ'] [54, 200, 821, 85] 15-03 허깅 페이스 토크 나이저(Huggingface Tokenizer) *자연어 처리 스타트업 허깅 페이스가 개발한 패키지 tokenizers는 자주 등장하는 서브 워드들을 하나의 토큰으로 취급하는 다양한 서브 워드 토크 나이저를 제공합니다. 이번 실습에서는 이 중에서 WordPiece Tokenizer를 실습해 보겠습니다. 실습을 위해 우선 tokenizers를 설치합니다. pip install tokenizers 1. BERT의 워드 피스 토크 나이저(BertWordPieceTokenizer) 구글이 공개한 딥 러닝 모델 BERT에는 WordPiece Tokenizer가 사용되었습니다. 허깅 페이스는 해당 토크 나이저를 직접 구현하여 tokenizers라는 패키지를 통해 버트 워드 피스 토크 나이저(BertWordPieceTokenizer)를 제공합니다. 여기서는 네이버 영화 리뷰 데이터를 해당 토크 나이저에 학습시키고, 이로부터 서브 워드의 단어 집합(Vocabulary)을 얻습니다. 그리고 임의의 문장에 대해서 학습된 토크 나이저를 사용하여 토큰화를 진행합니다. 우선 네이버 영화 리뷰 데이터를 로드합니다. import pandas as pd import urllib.request from tokenizers import BertWordPieceTokenizer urllib.request.urlretrieve("https://raw.githubusercontent.com/e9t/nsmc/master/ratings.txt", filename="ratings.txt") 센텐스 피스(SentencePiece) 실습에서 진행했던 전처리와 동일한 과정을 진행합니다. ratings.txt라는 파일을 데이터 프레임으로 로드한 후, 결측값을 제거하고, 실질적인 리뷰 데이터인 document 열에 대해서 naverreview.txt라는 파일로 저장합니다. naverdf = pd.readtable('ratings.txt') naverdf = naverdf.dropna(how='any') with open('naverreview.txt', 'w', encoding='utf8') as f: f.write('\n'.join(naverdf['document'])) 버트 워드 피스 토크 나이저를 설정합니다. tokenizer = BertWordPieceTokenizer(lowercase=False, tripaccents=False) 각 인자가 의미하는 바는 다음과 같습니다. lowercase : 대소문자를 구분 여부. True일 경우 구분하지 않음. stripaccents : True일 경우 악센트 제거. ex) é → e, ô → o 네이버 영화 리뷰 데이터를 학습하여 단어 집합을 얻어봅시다. datafile = 'naverreview.txt' vocabsize = 30000 limitalphabet = 6000 minfrequency = 5 tokenizer.train(files=datafile, vocabsize=vocabsize, limitalphabet=limitalphabet, minfrequency=minfrequency) 각 인자가 의미하는 바는 다음과 같습니다. files : 단어 집합을 얻기 위해 학습할 데이터 vocabsize : 단어 집합의 크기 limitalphabet : 병합 전의 초기 토큰의 허용 개수. minfrequency : 최소 해당 횟수만큼 등장한 쌍(pair)의 경우에만 병합 대상이 된다. 학습이 다 되었다면 vocab을 저장합니다. 경로를 지정해 주어야 하는데 여기서는 현재 경로에 저장하겠습니다. # vocab 저장 tokenizer.savemodel('./') vocab을 데이터 프레임으로 로드합니다. # vocab 로드 df = pd.readfwf('vocab.txt', header=None) df 총 30,000개의 단어가 존재합니다. 이는 단어 집합의 크기를 30,000으로 지정하였기 때문입니다. 실제 토큰화를 수행해 봅시다. encoded = tokenizer.encode('아 배고픈데 짜장면 먹고 싶다') print('토큰화 결과 :',encoded.tokens) print('정수 인코딩 :',encoded.ids) print('디코딩 :',tokenizer.decode(encoded.ids)) 토큰화 결과 : ['아', '배고', '##픈', '##데', '짜장면', '##먹고', '##싶다'] 정수 인코딩 : [2111, 20629, 3979, 3244, 24682, 7871, 7379] 디코딩 : 아 배고픈데 짜장면 먹고 싶다 .ids는 실질적인 딥 러닝 모델의 입력으로 사용되는 정수 인코딩 결과를 출력합니다. tokens는 해당 토크 나이저가 어떻게 토큰화를 진행했는지를 보여줍니다. decode()는 정수 시퀀스를 문자열로 복원합니다. encoded = tokenizer.encode('커피 한 잔의 여유를 즐기다') print('토큰화 결과 :',encoded.tokens) print('정수 인코딩 :',encoded.ids) print('디코딩 :',tokenizer.decode(encoded.ids)) 토큰화 결과 : ['커피', '한 잔', '##의', '여유', '##를', '즐기', '##다'] 정수 인코딩 : [12825, 25641, 3435, 12696, 3419, 10784, 3260] 디코딩 : 커피 한 잔의 여유를 즐기다 2. 기타 토크 나이저 이 외 ByteLevelBPETokenizer, CharBPETokenizer, SentencePieceBPETokenizer 등이 존재하며 선택에 따라서 사용할 수 있습니다. BertWordPieceTokenizer : BERT에서 사용된 워드 피스 토크 나이저(WordPiece Tokenizer) CharBPETokenizer : 오리지널 BPE ByteLevelBPETokenizer : BPE의 바이트 레벨 버전 SentencePieceBPETokenizer : 앞서 본 패키지 센텐스 피스(SentencePiece)와 호환되는 BPE 구현체 from tokenizers import ByteLevelBPETokenizer, CharBPETokenizer, SentencePieceBPETokenizer tokenizer = SentencePieceBPETokenizer() tokenizer.train('naverreview.txt', vocabsize=10000, minfrequency=5) encoded = tokenizer.encode("이 영화는 정말 재미있습니다.") print(encoded.tokens) python ['▁이', '▁영화는', '▁정말', '▁재미있', '습니다.']* 16. [NLP 고급 ] 시퀀스 투 시퀀스(Sequence-to-Sequence, seq2seq) 이번 챕터에서는 두 개의 RNN 아키텍처를 사용해서 만드는 시퀀스 투 시퀀스 구조에 대해서 이해합니다. 16-01 시퀀스 투 시퀀스(Sequence-to-Sequence, seq2seq) 시퀀스-투-시퀀스(Sequence-to-Sequence)는 입력된 시퀀스로부터 다른 도메인의 시퀀스를 출력하는 다양한 분야에서 사용되는 모델입니다. 예를 들어 챗봇(Chatbot)과 기계 번역(Machine Translation)이 그러한 대표적인 예인데, 입력 시퀀스와 출력 시퀀스를 각각 질문과 대답으로 구성하면 챗봇으로 만들 수 있고, 입력 시퀀스와 출력 시퀀스를 각각 입력 문장과 번역 문장으로 만들면 번역기로 만들 수 있습니다. 그 외에도 내용 요약(Text Summarization), STT(Speech to Text) 등에서 쓰일 수 있습니다. 이번 챕터에서는 기계 번역을 예제로 시퀀스-투-시퀀스를 설명합니다. 앞으로는 줄여서 seq2seq이라는 이름으로 설명하겠습니다. seq2seq에 대한 구조를 이해하고, 파이 토치(PyTorch)를 통해 직접 구현해 봅시다. 1. 모델의 개요(Overview) seq2seq는 번역기에서 대표적으로 사용되는 모델입니다. 앞으로의 설명 방식은 내부가 보이지 않는 커다란 블랙박스에서 점차적으로 확대해가는 방식으로 설명합니다. 참고로 여기서 설명하는 내용의 대부분은 RNN 챕터에서 언급한 내용들입니다. 단지 이것을 가지고 어떻게 조립했느냐에 따라서 seq2seq라는 구조가 만들어집니다. 위의 그림은 seq2seq 모델로 만들어진 번역기가 'I am a student'라는 영어 문장을 입력받아서, 'je suis étudiant'라는 프랑스 문장을 출력하는 모습을 보여줍니다. 그렇다면, seq2seq 모델 내부의 모습은 어떻게 구성되었을까요? seq2seq는 크게 두 개로 구성된 아키텍처로 구성되는데, 바로 인코더와 디코더입니다. 인코더는 입력 문장의 모든 단어들을 순차적으로 입력받은 뒤에 마지막에 이 모든 단어 정보들을 압축해서 하나의 벡터로 만드는데, 이를 컨텍스트 벡터(context vector)라고 합니다. 컨텍스트란 한국어로는 '문맥'입니다. 입력 문장의 정보가 하나의 컨텍스트 벡터로 모두 압축되면 인코더는 컨텍스트 벡터를 디코더로 전송합니다. 디코더는 컨텍스트 벡터를 받아서 번역된 단어를 한 개씩 순차적으로 출력합니다. 위의 그림에서는 컨텍스트 벡터를 4의 사이즈로 표현하였지만, 실제 현업에서 사용되는 seq2seq 모델에서는 보통 수백 이상의 차원을 갖고 있습니다. 이제 인코더와 디코더의 내부를 좀 더 확대해 보겠습니다. 2. seq2seq의 동작 과정 인코더 아키텍처와 디코더 아키텍처의 내부는 사실 두 개의 RNN 아키텍처입니다. 입력 문장을 받는 RNN 셀을 인코더라고 하고, 출력 문장을 출력하는 RNN 셀을 디코더라고 합니다. 이번 챕터에서는 인코더의 RNN 셀을 주황색으로, 디코더의 RNN 셀을 초록색으로 표현합니다. 물론, 성능 문제로 인해 실제로는 바닐라 RNN이 아니라 LSTM 셀 또는 GRU 셀들로 구성됩니다. 우선 인코더를 자세히 보면, 입력 문장은 단어 토큰화를 통해서 단어 단위로 쪼개지고 단어 토큰 각각은 RNN 셀의 각 시점의 입력이 됩니다. 인코더 RNN 셀은 모든 단어를 입력받은 뒤에 인코더 RNN 셀의 마지막 시점의 은닉 상태를 디코더 RNN 셀로 넘겨주는데 이를 컨텍스트 벡터라고 합니다. 컨텍스트 벡터는 디코더 RNN 셀의 첫 번째 은닉 상태로 사용됩니다. 1. 테스트 단계 디코더는 초기 입력으로 문장의 시작을 의미하는 심벌 <sos>가 들어갑니다. 디코더는 <sos>가 입력되면, 다음에 등장할 확률이 높은 단어를 예측합니다. 첫 번째 시점(time step)의 디코더 RNN 셀은 다음에 등장할 단어로 je를 예측하였습니다. 첫 번째 시점의 디코더 RNN 셀은 예측된 단어 je를 다음 시점의 RNN 셀의 입력으로 입력합니다. 그리고 두 번째 시점의 디코더 RNN 셀은 입력된 단어 je로부터 다시 다음에 올 단어인 suis를 예측하고, 또다시 이것을 다음 시점의 RNN 셀의 입력으로 보냅니다. 디코더는 이런 식으로 기본적으로 다음에 올 단어를 예측하고, 그 예측한 단어를 다음 시점의 RNN 셀의 입력으로 넣는 행위를 반복합니다. 이 행위는 문장의 끝을 의미하는 심벌인 <eos>가 다음 단어로 예측될 때까지 반복됩니다. 지금 설명하는 것은 테스트 과정 동안의 이야기입니다. 2. 훈련 단계와 교사 강요 seq2seq는 훈련 과정과 테스트 과정(또는 실제 번역기를 사람이 쓸 때)의 작동 방식이 조금 다릅니다. 훈련 과정에서는 디코더에게 인코더가 보낸 컨텍스트 벡터와 실제 정답인 상황인 <sos> je suis étudiant를 입력받았을 때, je suis étudiant <eos>가 나와야 된다고 정답을 알려주면서 훈련합니다. 이를 교사 강요(teacher forcing)라고 합니다. 반면 테스트 과정에서는 앞서 설명한 과정과 같이 디코더는 오직 컨텍스트 벡터와 <go>만을 입력으로 받은 후에 다음에 올 단어를 예측하고, 그 단어를 다음 시점의 RNN 셀의 입력으로 넣는 행위를 반복합니다. 3. 임베딩 층(Embedding layer) - 이미 배운 내용 기계는 텍스트보다 숫자를 잘 처리합니다. 그리고 자연어 처리에서 텍스트를 벡터로 바꾸는 방법으로 워드 임베딩(9챕터 참고)이 사용된다고 설명한 바 있습니다. 즉, seq2seq에서 사용되는 모든 단어들은 워드 임베딩을 통해 임베딩 벡터로서 표현된 임베딩 벡터입니다. 위 그림은 모든 단어에 대해서 임베딩 과정을 거치게 하는 단계인 임베딩 층(embedding layer)의 모습을 보여줍니다. 예를 들어 I, am, a, student라는 단어들에 대한 임베딩 벡터는 위와 같은 모습을 가집니다. 여기서는 그림으로 표현하고자 사이즈를 4로 하였지만, 보통 실제 임베딩 벡터는 수백 개의 차원을 가질 수 있습니다. 이제 RNN 셀에 대해서 확대해 보겠습니다. 4. RNN 셀 - 이미 배운 내용 이미 RNN에 대해서 배운 적이 있지만, 다시 복습을 해보겠습니다. 하나의 RNN 셀은 각 시점(time step)마다 두 개의 입력을 받습니다. 현재 시점(time step)을 t라고 할 때, RNN 셀은 t-1에서의 은닉 상태와 t에서의 입력 벡터를 입력으로 받고, t에서의 은닉 상태를 만듭니다. 이때 t에서의 은닉 상태는 바로 위에 또 다른 은닉층이나 출력층이 존재할 경우에는 위의 층으로 보내거나, 필요 없으면 값을 무시할 수 있습니다. 그리고 RNN 셀은 다음 시점에 해당하는 t+1의 RNN 셀의 입력으로 현재 t에서의 은닉 상태를 입력으로 보냅니다. RNN 챕터에서도 언급했지만, 이런 구조에서 현재 시점 t에서의 은닉 상태는 과거 시점의 동일한 RNN 셀에서의 모든 은닉 상태의 값들의 영향을 누적해서 받아온 값이라고 할 수 있습니다. 그렇기 때문에 앞서 우리가 언급했던 컨텍스트 벡터는 사실 인코더에서의 마지막 RNN 셀의 은닉 상태 값을 말하는 것이며, 이는 입력 문장의 모든 단어 토큰들의 정보를 요약해서 담고 있다고 할 수 있습니다. 5. 디코더 디코더는 인코더의 마지막 RNN 셀의 은닉 상태인 컨텍스트 벡터를 첫 번째 은닉 상태의 값으로 사용합니다. 디코더의 첫 번째 RNN 셀은 이 첫 번째 은닉 상태의 값과, 현재 t에서의 입력값인 <sos>로부터, 다음에 등장할 단어를 예측합니다. 그리고 이 예측된 단어는 다음 시점인 t+1 RNN에서의 입력값이 되고, 이 t+1에서의 RNN 또한 이 입력값과 t에서의 은닉 상태로부터 t+1에서의 출력 벡터. 즉, 또다시 다음에 등장할 단어를 예측하게 될 것입니다. 이제 디코더가 다음에 등장할 단어를 예측하는 부분을 확대해 보도록 하겠습니다. 출력 단어로 나올 수 있는 단어들은 다양한 단어들이 있습니다. seq2seq 모델은 선택될 수 있는 모든 단어들로부터 하나의 단어를 골라서 예측해야 합니다. 이를 예측하기 위해서 쓸 수 있는 함수로는 뭐가 있을까요? 바로 소프트맥스 함수입니다. 디코더에서 각 시점(time step)의 RNN 셀에서 출력 벡터가 나오면, 해당 벡터는 소프트맥스 함수를 통해 출력 시퀀스의 각 단어별 확률 값을 반환하고, 디코더는 출력 단어를 결정합니다. 3. 다양한 변형들 가장 기본적인 seq2seq에 대해서 배워보았습니다. 사실 seq2seq는 어떻게 구현하느냐에 따라서 충분히 더 복잡해질 수 있습니다. 컨텍스트 벡터를 디코더의 초기 은닉 상태로만 사용할 수도 있고, 거기서 더 나아가 컨텍스트 벡터를 디코더가 단어를 예측하는 매 시점마다 하나의 입력으로 사용할 수도 있으며 거기서 더 나아가면 어텐션 메커니즘이라는 방법을 통해 지금 알고 있는 컨텍스트 벡터보다 더욱 문맥을 반영할 수 있는 컨텍스트 벡터를 구하여 매 시점마다 하나의 입력으로 사용할 수도 있습니다. 어텐션 메커니즘에 대해서는 다음 챕터에서 배웁니다. 16-02 Seq2Seq를 이용한 번역기 구현하기 seq2seq를 이용해서 기계 번역기를 만들어보겠습니다. 실제 서비스에 사용되는 번역기는 뒤의 챕터에서 배우게 될 어텐션 메커니즘을 사용해야 하고, 최소 수백만 개의 데이터가 필요합니다. 하지만 그럼에도 번역기를 만드는 간단한 토이 프로젝트를 사용해서 seq2seq 구조와 인코더와 디코더의 역할을 이해할 수 있습니다. 1. 데이터 로드 및 전처리 실제 성능이 좋은 기계 번역기를 구현하려면 방대한 데이터가 필요하므로 여기서는 seq2seq를 간단히 실습해 보는 수준의 간단한 기계 번역기를 구현해 보겠습니다. 기계 번역기를 훈련시키기 위해서는 훈련 데이터로 병렬 코퍼스(parallel corpus)가 필요합니다. 병렬 코퍼스란, 두 개 이상의 언어가 병렬적으로 구성된 코퍼스를 의미합니다. 링크 : http://www.manythings.org/anki 이번 실습에서는 프랑스어-영어 병렬 코퍼스인 fra-eng.zip 파일을 사용합니다. 위의 링크에서 해당 파일을 다운로드한 후 압축을 풀면 fra.txt라는 파일을 얻을 수 있는데 해당 파일을 이 실습에서 사용합니다. 병렬 코퍼스 데이터에 대해서 이해해 봅시다. 병렬 데이터라고 하면 앞서 수행한 태깅 작업 챕터의 개체명 인식과 같은 데이터를 생각할 수 있지만, 앞서 수행한 태깅 작업의 병렬 데이터와 seq2seq가 사용하는 병렬 데이터는 성격이 다릅니다. 태깅 작업의 병렬 데이터는 쌍이 되는 데이터와 레이블이 길이가 동일하였으나 여기서는 쌍이 된다고 해서 반드시 길이가 같지는 않습니다. 실제 번역기를 생각해 보면 구글 번역기에 '나는 학생이다.'라는 토큰의 개수가 2인 문장을 넣었을 때 'I am a student.'라는 토큰의 개수가 4인 문장이 나오는 것과 같은 이치입니다. seq2seq는 기본적으로 입력 시퀀스와 출력 시퀀스의 길이가 다를 수 있다고 가정합니다. 지금 구현 예제는 기계 번역기이지만 seq2seq로 구현할 수 있는 또 다른 예제인 챗봇을 만든다고 가정해 보면, 대답의 길이가 질문의 길이와 항상 똑같아야 한다고 하면 그 또한 이상합니다. 여기서 사용할 fra.txt 데이터는 아래와 같이 왼쪽의 영어 문장과 오른쪽의 프랑스어 문장 사이에 탭으로 구분되는<NAME>이 하나의 샘플입니다. Watch me. Regardez-moi ! 데이터는 위와 동일한<NAME>의 약 19만 개의 병렬 문장 샘플을 포함하고 있습니다. 데이터를 읽고 전처리를 진행해 보겠습니다. 앞으로의 코드에서 src는 source의 줄임말로 입력 문장을 나타내며, tar는 target의 줄임말로 번역하고자 하는 문장을 나타냅니다. import re import os import unicodedata import urllib3 import zipfile import shutil import numpy as np import pandas as pd import torch from collections import Counter from tqdm import tqdm from torch.utils.data import DataLoader, TensorDataset 이번 실습에서는 약 19만 개의 데이터 중 33,000개의 샘플만을 사용할 예정입니다. num_samples = 33000 fra-eng.zip 파일을 다운로드하고 압축을 풀겠습니다. !wget -c http://www.manythings.org/anki/fra-eng.zip && unzip -o fra-eng.zip 전처리 함수들을 구현합니다. 구두점 등을 제거하거나 단어와 구분해 주기 위한 전처리입니다. def unicode_to_ascii(s): # 프랑스어 악센트(accent) 삭제 # 예시 : 'déjà diné' -> deja dine return ''.join(c for c in unicodedata.normalize('NFD', s) if unicodedata.category(c) != 'Mn') def preprocess_sentence(sent): # 악센트 삭제 함수 호출 sent = unicode_to_ascii(sent.lower()) # 단어와 구두점 사이에 공백을 만듭니다. # Ex) "he is a boy." => "he is a boy ." sent = re.sub(r"([?.!,¿])", r" \1", sent) # (a-z, A-Z, ".", "?", "!", ",") 이들을 제외하고는 전부 공백으로 변환합니다. sent = re.sub(r"[^a-zA-Z!.?]+", r" ", sent) # 다수 개의 공백을 하나의 공백으로 치환 sent = re.sub(r"\s+", " ", sent) return sent def load_preprocessed_data(): encoder_input, decoder_input, decoder_target = [], [], [] with open("fra.txt", "r") as lines: for i, line in enumerate(lines): # source 데이터와 target 데이터 분리 src_line, tar_line, _ = line.strip().split('\t') # source 데이터 전처리 src_line = [w for w in preprocess_sentence(src_line).split()] # target 데이터 전처리 tar_line = preprocess_sentence(tar_line) tar_line_in = [w for w in ("<sos> " + tar_line).split()] tar_line_out = [w for w in (tar_line + " <eos>").split()] encoder_input.append(src_line) decoder_input.append(tar_line_in) decoder_target.append(tar_line_out) if i == num_samples - 1: break return encoder_input, decoder_input, decoder_target 구현한 전처리 함수들을 임의의 문장을 입력으로 테스트해 봅시다. # 전처리 테스트 en_sent = u"Have you had dinner?" fr_sent = u"Avez-vous déjà diné?" print('전처리 전 영어 문장 :', en_sent) print('전처리 후 영어 문장 :',preprocess_sentence(en_sent)) print('전처리 전 프랑스어 문장 :', fr_sent) print('전처리 후 프랑스어 문장 :', preprocess_sentence(fr_sent)) 전처리 전 영어 문장 : Have you had dinner? 전처리 후 영어 문장 : have you had dinner ? 전처리 전 프랑스어 문장 : Avez-vous déjà diné? 전처리 후 프랑스어 문장 : avez vous deja dine ? sents_en_in, sents_fra_in, sents_fra_out = load_preprocessed_data() 전체 데이터에서 33,000개의 샘플에 대해서 전처리를 수행합니다. 또한 훈련 과정에서 교사 강요(Teacher Forcing)을 사용할 예정이므로, 훈련 시 사용할 디코더의 입력 시퀀스와 실제 값. 즉, 레이블에 해당되는 출력 시퀀스를 따로 분리하여 저장합니다. 입력 시퀀스에는 시작을 의미하는 토큰인 를 추가하고, 출력 시퀀스에는 종료를 의미하는 토큰인 를 추가합니다. 이렇게 얻은 3개의 데이터 셋 인코더의 입력, 디코더의 입력, 디코더의 레이블을 상위 5개 샘플만 출력해 봅시다. sents_en_in, sents_fra_in, sents_fra_out = load_preprocessed_data() print('인코더의 입력 :',sents_en_in[:5]) print('디코더의 입력 :',sents_fra_in[:5]) print('디코더의 레이블 :',sents_fra_out[:5]) 인코더의 입력 : [['go', '.'], ['go', '.'], ['go', '.'], ['hi', '.'], ['hi', '.']] 디코더의 입력 : [['<sos>', 'va', '!'], ['<sos>', 'marche', '.'], ['<sos>', 'bouge', '!'], ['<sos>', 'salut', '!'], ['<sos>', 'salut', '.']] 디코더의 레이블 : [['va', '!', '<eos>'], ['marche', '.', '<eos>'], ['bouge', '!', '<eos>'], ['salut', '!', '<eos>'], ['salut', '.', '<eos>']] 모델을 설계하기 전 의아한 점이 있을 수 있습니다. 현재 시점의 디코더 셀의 입력은 오직 이전 디코더 셀의 출력을 입력으로 받는다고 설명하였는데 디코더의 입력에 해당하는 데이터인 sents_fra_in이 왜 필요할까요? 훈련 과정에서는 이전 시점의 디코더 셀의 출력을 현재 시점의 디코더 셀의 입력으로 넣어주지 않고, 이전 시점의 실제 값을 현재 시점의 디코더 셀의 입력값으로 하는 방법을 사용할 겁니다. 그 이유는 이전 시점의 디코더 셀의 예측이 틀렸는데 이를 현재 시점의 디코더 셀의 입력으로 사용하면 현재 시점의 디코더 셀의 예측도 잘못될 가능성이 높고 이는 연쇄 작용으로 디코더 전체의 예측을 어렵게 합니다. 이런 상황이 반복되면 훈련 시간이 느려집니다. 만약 이 상황을 원하지 않는다면 이전 시점의 디코더 셀의 예측값 대신 실제 값을 현재 시점의 디코더 셀의 입력으로 사용하는 방법을 사용할 수 있습니다. 이와 같이 RNN의 모든 시점에 대해서 이전 시점의 예측값 대신 실제 값을 입력으로 주는 방법을 교사 강요라고 합니다. 단어로부터 정수를 얻는 딕셔너리. 즉, 단어 집합(Vocabulary)을 만들어봅시다. 이를 위한 함수로 build_vocab()을 구현합니다. build_vocab은 입력된 데이터로부터 단어의 등장 빈도순으로 정렬 후에 등장 빈도가 높은 순서일수록 낮은 정수를 부여합니다. 이때, 패딩 토큰을 위한 <PAD> 토큰은 0번, OOV에 대응하기 위한 <UNK> 토큰은 1번에 할당합니다. 이렇게 되면 빈도수가 가장 높은 단어는 정수가 2번, 빈도수가 두 번째로 많은 단어는 정수 3번이 할당됩니다. def build_vocab(sents): word_list = [] for sent in sents: for word in sent: word_list.append(word) # 각 단어별 등장 빈도를 계산하여 등장 빈도가 높은 순서로 정렬 word_counts = Counter(word_list) vocab = sorted(word_counts, key=word_counts.get, reverse=True) word_to_index = {} word_to_index['<PAD>'] = 0 word_to_index['<UNK>'] = 1 # 등장 빈도가 높은 단어일수록 낮은 정수를 부여 for index, word in enumerate(vocab) : word_to_index[word] = index + 2 return word_to_index 영어를 위한 단어 집합 src_vocab과 프랑스어를 이용한 단어 집합 tar_vocab를 만들어봅시다. 구현 방식에 따라서는 하나의 단어 집합으로 만들어도 상관없으며 이는 선택의 차이입니다. src_vocab = build_vocab(sents_en_in) tar_vocab = build_vocab(sents_fra_in + sents_fra_out) src_vocab_size = len(src_vocab) tar_vocab_size = len(tar_vocab) print("영어 단어 집합의 크기 : {:d}, 프랑스어 단어 집합의 크기 : {:d}".format(src_vocab_size, tar_vocab_size)) 영어 단어 집합의 크기 : 4517, 프랑스어 단어 집합의 크기 : 7908 정수로부터 단어를 얻는 딕셔너리를 각각 만들어줍니다. 이들은 훈련을 마치고 예측값과 실제 값을 비교하는 단계에서 사용됩니다. index_to_src = {v: k for k, v in src_vocab.items()} index_to_tar = {v: k for k, v in tar_vocab.items()} def texts_to_sequences(sents, word_to_index): encoded_X_data = [] for sent in tqdm(sents): index_sequences = [] for word in sent: try: index_sequences.append(word_to_index[word]) except KeyError: index_sequences.append(word_to_index['<UNK>']) encoded_X_data.append(index_sequences) return encoded_X_data encoder_input = texts_to_sequences(sents_en_in, src_vocab) decoder_input = texts_to_sequences(sents_fra_in, tar_vocab) decoder_target = texts_to_sequences(sents_fra_out, tar_vocab) # 상위 5개의 샘플에 대해서 정수 인코딩 전, 후 문장 출력 # 인코더 입력이므로 <sos>나 <eos>가 없음 for i, (item1, item2) in zip(range(5), zip(sents_en_in, encoder_input)): print(f"Index: {i}, 정수 인코딩 전: {item1}, 정수 인코딩 후: {item2}") Index: 0, 정수 인코딩 전: ['go', '.'], 정수 인코딩 후: [28, 2] Index: 1, 정수 인코딩 전: ['go', '.'], 정수 인코딩 후: [28, 2] Index: 2, 정수 인코딩 전: ['go', '.'], 정수 인코딩 후: [28, 2] Index: 3, 정수 인코딩 전: ['go', '.'], 정수 인코딩 후: [28, 2] Index: 4, 정수 인코딩 전: ['hi', '.'], 정수 인코딩 후: [746, 2] def pad_sequences(sentences, max_len=None): # 최대 길이 값이 주어지지 않을 경우 데이터 내 최대 길이로 패딩 if max_len is None: max_len = max([len(sentence) for sentence in sentences]) features = np.zeros((len(sentences), max_len), dtype=int) for index, sentence in enumerate(sentences): if len(sentence) != 0: features[index, :len(sentence)] = np.array(sentence)[:max_len] return features encoder_input = pad_sequences(encoder_input) decoder_input = pad_sequences(decoder_input) decoder_target = pad_sequences(decoder_target) 데이터의 크기(shape)를 확인합니다. print('인코더의 입력의 크기(shape) :',encoder_input.shape) print('디코더의 입력의 크기(shape) :',decoder_input.shape) print('디코더의 레이블의 크기(shape) :',decoder_target.shape) 인코더의 입력의 크기(shape) : (33000, 7) 디코더의 입력의 크기(shape) : (33000, 16) 디코더의 레이블의 크기(shape) : (33000, 16) 테스트 데이터를 분리하기 전 데이터를 섞어줍니다. 이를 위해서 순서가 섞인 정수 시퀀스 리스트를 만듭니다. indices = np.arange(encoder_input.shape[0]) np.random.shuffle(indices) print('랜덤 시퀀스 :',indices) 랜덤 시퀀스 : [29443 12274 30297 ... 24517 9984 32323] 이를 데이터 셋의 순서로 지정해 주면 샘플들이 기존 순서와 다른 순서로 섞이게 됩니다. encoder_input = encoder_input[indices] decoder_input = decoder_input[indices] decoder_target = decoder_target[indices] 임의로 30,997번째 샘플을 출력해 봅시다. 이때 decoder_input과 decoder_target은 데이터의 구조상으로 앞에 붙은 <sos> 토큰과 뒤에 붙은 <eos>을 제외하면 동일한 시퀀스를 가져야 합니다. print([index_to_src[word] for word in encoder_input[30997]]) print([index_to_tar[word] for word in decoder_input[30997]]) print([index_to_tar[word] for word in decoder_target[30997]]) ['give', 'me', 'the', 'phone', '.', '<PAD>', '<PAD>'] ['<sos>', 'donne', 'moi', 'le', 'telephone', '.', '<PAD>', '<PAD>', '<PAD>', '<PAD>', '<PAD>', '<PAD>', '<PAD>', '<PAD>', '<PAD>', '<PAD>'] ['donne', 'moi', 'le', 'telephone', '.', '<eos>', '<PAD>', '<PAD>', '<PAD>', '<PAD>', '<PAD>', '<PAD>', '<PAD>', '<PAD>', '<PAD>', '<PAD>'] 33,000개의 10%에 해당되는 3,300개의 데이터를 테스트 데이터로 사용합니다. n_of_val = int(33000*0.1) print('검증 데이터의 개수 :',n_of_val) 검증 데이터의 개수 : 3300 encoder_input_train = encoder_input[:-n_of_val] decoder_input_train = decoder_input[:-n_of_val] decoder_target_train = decoder_target[:-n_of_val] encoder_input_test = encoder_input[-n_of_val:] decoder_input_test = decoder_input[-n_of_val:] decoder_target_test = decoder_target[-n_of_val:] array([ 74, 4, 438, 5, 0, 0, 0]) array([ 3, 80, 19, 2172, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) array([ 80, 19, 2172, 7, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) 훈련 데이터와 테스트 데이터의 크기(shape)를 출력해 봅시다. print('훈련 source 데이터의 크기 :',encoder_input_train.shape) print('훈련 target 데이터의 크기 :',decoder_input_train.shape) print('훈련 target 레이블의 크기 :',decoder_target_train.shape) print('테스트 source 데이터의 크기 :',encoder_input_test.shape) print('테스트 target 데이터의 크기 :',decoder_input_test.shape) print('테스트 target 레이블의 크기 :',decoder_target_test.shape) 훈련 source 데이터의 크기 : (29700, 7) 훈련 target 데이터의 크기 : (29700, 16) 훈련 target 레이블의 크기 : (29700, 16) 테스트 source 데이터의 크기 : (3300, 7) 테스트 target 데이터의 크기 : (3300, 16) 테스트 target 레이블의 크기 : (3300, 16) 2. 기계 번역기 만들기 import torch import torch.nn as nn import torch.optim as optim embedding_dim = 256 hidden_units = 256 class Encoder(nn.Module): def __init__(self, src_vocab_size, embedding_dim, hidden_units): super(Encoder, self).__init__() self.embedding = nn.Embedding(src_vocab_size, embedding_dim, padding_idx=0) self.lstm = nn.LSTM(embedding_dim, hidden_units, batch_first=True) def forward(self, x): # x.shape == (batch_size, seq_len, embedding_dim) x = self.embedding(x) # hidden.shape == (1, batch_size, hidden_units), cell.shape == (1, batch_size, hidden_units) _, (hidden, cell) = self.lstm(x) # 인코더의 출력은 hidden state, cell state return hidden, cell class Decoder(nn.Module): def __init__(self, tar_vocab_size, embedding_dim, hidden_units): super(Decoder, self).__init__() self.embedding = nn.Embedding(tar_vocab_size, embedding_dim, padding_idx=0) self.lstm = nn.LSTM(embedding_dim, hidden_units, batch_first=True) self.fc = nn.Linear(hidden_units, tar_vocab_size) def forward(self, x, hidden, cell): # x.shape == (batch_size, seq_len, embedding_dim) x = self.embedding(x) # 디코더의 LSTM으로 인코더의 hidden state, cell state를 전달. # output.shape == (batch_size, seq_len, hidden_units) # hidden.shape == (1, batch_size, hidden_units) # cell.shape == (1, batch_size, hidden_units) output, (hidden, cell) = self.lstm(x, (hidden, cell)) # output.shape: (batch_size, seq_len, tar_vocab_size) output = self.fc(output) # 디코더의 출력은 예측값, hidden state, cell state return output, hidden, cell class Seq2Seq(nn.Module): def __init__(self, encoder, decoder): super(Seq2Seq, self).__init__() self.encoder = encoder self.decoder = decoder def forward(self, src, trg): hidden, cell = self.encoder(src) # 훈련 중에는 디코더의 출력 중 오직 output만 사용한다. output, _, _ = self.decoder(trg, hidden, cell) return output encoder = Encoder(src_vocab_size, embedding_dim, hidden_units) decoder = Decoder(tar_vocab_size, embedding_dim, hidden_units) model = Seq2Seq(encoder, decoder) loss_function = nn.CrossEntropyLoss(ignore_index=0) optimizer = optim.Adam(model.parameters()) 모델의 구조를 출력해 봅시다. print(model) Seq2Seq( (encoder): Encoder( (embedding): Embedding(4517, 256, padding_idx=0) (lstm): LSTM(256, 256, batch_first=True) ) (decoder): Decoder( (embedding): Embedding(7908, 256, padding_idx=0) (lstm): LSTM(256, 256, batch_first=True) (fc): Linear(in_features=256, out_features=7908, bias=True) ) ) 임베딩 벡터의 차원과 LSTM의 은닉 상태의 크기를 256로 사용합니다. 디코더는 인코더의 마지막 은닉 상태로부터 초기 은닉 상태를 얻습니다. 디코더도 은닉 상태, 셀 상태를 리턴하기는 하지만 훈련 과정에서는 사용하지 않습니다. seq2seq의 디코더는 기본적으로 각 시점마다 다중 클래스 분류 문제를 풀고 있습니다. 매 시점마다 프랑스어 단어 집합의 크기(tar_vocab_size)의 선택지에서 단어를 1개 선택하여 이를 이번 시점에서 예측한 단어로 택합니다. 다중 클래스 분류 문제이므로 손실 함수를 크로스 엔트로피 함수를 사용합니다. def evaluation(model, dataloader, loss_function, device): model.eval() total_loss = 0.0 total_correct = 0 total_count = 0 with torch.no_grad(): for encoder_inputs, decoder_inputs, decoder_targets in dataloader: encoder_inputs = encoder_inputs.to(device) decoder_inputs = decoder_inputs.to(device) decoder_targets = decoder_targets.to(device) # 순방향 전파 # outputs.shape == (batch_size, seq_len, tar_vocab_size) outputs = model(encoder_inputs, decoder_inputs) # 손실 계산 # outputs.view(-1, outputs.size(-1))의 shape는 (batch_size * seq_len, tar_vocab_size) # decoder_targets.view(-1)의 shape는 (batch_size * seq_len) loss = loss_function(outputs.view(-1, outputs.size(-1)), decoder_targets.view(-1)) total_loss += loss.item() # 정확도 계산 (패딩 토큰 제외) mask = decoder_targets != 0 total_correct += ((outputs.argmax(dim=-1) == decoder_targets) * mask).sum().item() total_count += mask.sum().item() return total_loss / len(dataloader), total_correct / total_count encoder_input_train_tensor = torch.tensor(encoder_input_train, dtype=torch.long) decoder_input_train_tensor = torch.tensor(decoder_input_train, dtype=torch.long) decoder_target_train_tensor = torch.tensor(decoder_target_train, dtype=torch.long) encoder_input_test_tensor = torch.tensor(encoder_input_test, dtype=torch.long) decoder_input_test_tensor = torch.tensor(decoder_input_test, dtype=torch.long) decoder_target_test_tensor = torch.tensor(decoder_target_test, dtype=torch.long) # 데이터 셋 및 데이터 로더 생성 batch_size = 128 train_dataset = TensorDataset(encoder_input_train_tensor, decoder_input_train_tensor, decoder_target_train_tensor) train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True) valid_dataset = TensorDataset(encoder_input_test_tensor, decoder_input_test_tensor, decoder_target_test_tensor) valid_dataloader = DataLoader(valid_dataset, batch_size=batch_size, shuffle=False) # 학습 설정 num_epochs = 30 device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model.to(device) 모델을 훈련합니다. 128개의 배치 크기(128개씩 데이터를 병렬로 학습)로 총 50 에포크 학습합니다. 검증 데이터로 훈련이 제대로 되고 있는지 모니터링하겠습니다. # Training loop best_val_loss = float('inf') for epoch in range(num_epochs): # 훈련 모드 model.train() for encoder_inputs, decoder_inputs, decoder_targets in train_dataloader: encoder_inputs = encoder_inputs.to(device) decoder_inputs = decoder_inputs.to(device) decoder_targets = decoder_targets.to(device) # 기울기 초기화 optimizer.zero_grad() # 순방향 전파 # outputs.shape == (batch_size, seq_len, tar_vocab_size) outputs = model(encoder_inputs, decoder_inputs) # 손실 계산 및 역방향 전파 # outputs.view(-1, outputs.size(-1))의 shape는 (batch_size * seq_len, tar_vocab_size) # decoder_targets.view(-1)의 shape는 (batch_size * seq_len) loss = loss_function(outputs.view(-1, outputs.size(-1)), decoder_targets.view(-1)) loss.backward() # 가중치 업데이트 optimizer.step() train_loss, train_acc = evaluation(model, train_dataloader, loss_function, device) valid_loss, valid_acc = evaluation(model, valid_dataloader, loss_function, device) print(f'Epoch: {epoch+1}/{num_epochs} | Train Loss: {train_loss:.4f} | Train Acc: {train_acc:.4f} | Valid Loss: {valid_loss:.4f} | Valid Acc: {valid_acc:.4f}') # 검증 손실이 최소일 때 체크포인트 저장 if valid_loss < best_val_loss: print(f'Validation loss improved from {best_val_loss:.4f} to {valid_loss:.4f}. 체크포인트를 저장합니다.') best_val_loss = valid_loss torch.save(model.state_dict(), 'best_model_checkpoint.pth') 저자의 학습 기록은 다음과 같습니다. Epoch: 1/30 | Train Loss: 2.9014 | Train Acc: 0.5312 | Valid Loss: 3.0343 | Valid Acc: 0.5257 Validation loss improved from inf to 3.0343. 체크포인트를 저장합니다. Epoch: 2/30 | Train Loss: 2.2466 | Train Acc: 0.6030 | Valid Loss: 2.5037 | Valid Acc: 0.5886 Validation loss improved from 3.0343 to 2.5037. 체크포인트를 저장합니다. Epoch: 3/30 | Train Loss: 1.8302 | Train Acc: 0.6487 | Valid Loss: 2.2069 | Valid Acc: 0.6181 Validation loss improved from 2.5037 to 2.2069. 체크포인트를 저장합니다. Epoch: 4/30 | Train Loss: 1.5223 | Train Acc: 0.6869 | Valid Loss: 2.0138 | Valid Acc: 0.6424 Validation loss improved from 2.2069 to 2.0138. 체크포인트를 저장합니다. Epoch: 5/30 | Train Loss: 1.2775 | Train Acc: 0.7241 | Valid Loss: 1.8763 | Valid Acc: 0.6582 Validation loss improved from 2.0138 to 1.8763. 체크포인트를 저장합니다. Epoch: 6/30 | Train Loss: 1.0680 | Train Acc: 0.7643 | Valid Loss: 1.7626 | Valid Acc: 0.6766 Validation loss improved from 1.8763 to 1.7626. 체크포인트를 저장합니다. Epoch: 7/30 | Train Loss: 0.8900 | Train Acc: 0.7895 | Valid Loss: 1.6930 | Valid Acc: 0.6852 Validation loss improved from 1.7626 to 1.6930. 체크포인트를 저장합니다. Epoch: 8/30 | Train Loss: 0.7457 | Train Acc: 0.8253 | Valid Loss: 1.6228 | Valid Acc: 0.6969 Validation loss improved from 1.6930 to 1.6228. 체크포인트를 저장합니다. Epoch: 9/30 | Train Loss: 0.6195 | Train Acc: 0.8557 | Valid Loss: 1.5719 | Valid Acc: 0.7071 Validation loss improved from 1.6228 to 1.5719. 체크포인트를 저장합니다. Epoch: 10/30 | Train Loss: 0.5193 | Train Acc: 0.8748 | Valid Loss: 1.5415 | Valid Acc: 0.7120 Validation loss improved from 1.5719 to 1.5415. 체크포인트를 저장합니다. Epoch: 11/30 | Train Loss: 0.4450 | Train Acc: 0.8905 | Valid Loss: 1.5235 | Valid Acc: 0.7165 Validation loss improved from 1.5415 to 1.5235. 체크포인트를 저장합니다. Epoch: 12/30 | Train Loss: 0.3804 | Train Acc: 0.9010 | Valid Loss: 1.5223 | Valid Acc: 0.7142 Validation loss improved from 1.5235 to 1.5223. 체크포인트를 저장합니다. Epoch: 13/30 | Train Loss: 0.3334 | Train Acc: 0.9090 | Valid Loss: 1.5129 | Valid Acc: 0.7180 Validation loss improved from 1.5223 to 1.5129. 체크포인트를 저장합니다. Epoch: 14/30 | Train Loss: 0.2965 | Train Acc: 0.9146 | Valid Loss: 1.5222 | Valid Acc: 0.7213 ... 중략 ... 이후 validation_loss는 계속 증가 검증 데이터 손실이 가장 최소일 때의 모델을 로드하고 다시 재평가해 봅시다. # 모델 로드 model.load_state_dict(torch.load('best_model_checkpoint.pth')) # 모델을 device에 올립니다. model.to(device) # 검증 데이터에 대한 정확도와 손실 계산 val_loss, val_accuracy = evaluation(model, valid_dataloader, loss_function, device) print(f'Best model validation loss: {val_loss:.4f}') print(f'Best model validation accuracy: {val_accuracy:.4f}') Best model validation loss: 1.5129 Best model validation accuracy: 0.7180 로드 후 재평가를 진행하였더니, 저장할 당시와 검증 데이터의 손실과 정확도가 동일하므로 저장 및 로드가 원활히 되었습니다. <sos>와 <eos> 토큰의 정수는 각각 3과 4입니다. print(tar_vocab['<sos>']) print(tar_vocab['<eos>']) 4 3. seq2seq 기계 번역기 동작시키기 seq2seq는 훈련 과정(교사 강요)과 테스트 과정에서의 동작 방식이 다릅니다. 그래서 테스트 과정을 위해 모델을 다시 설계해 주어야 합니다. 특히 디코더를 수정해야 합니다. 이번에는 번역 단계를 위해 모델을 수정하고 동작시켜보겠습니다. 전체적인 번역 단계를 정리하면 아래와 같습니다. 1) 번역하고자 하는 입력 문장이 인코더로 입력되어 인코더의 마지막 시점의 은닉 상태와 셀 상태를 얻습니다. 2) 인코더의 은닉 상태와 셀 상태, 그리고 토큰 <sos>를 디코더로 보냅니다. 3) 디코더가 토큰 <eos>가 나올 때까지 다음 단어를 예측하는 행동을 반복합니다. index_to_src = {v: k for k, v in src_vocab.items()} index_to_tar = {v: k for k, v in tar_vocab.items()} # 원문의 정수 시퀀스를 텍스트 시퀀스로 변환 def seq_to_src(input_seq): sentence = '' for encoded_word in input_seq: if(encoded_word != 0): sentence = sentence + index_to_src[encoded_word] + ' ' return sentence # 번역문의 정수 시퀀스를 텍스트 시퀀스로 변환 def seq_to_tar(input_seq): sentence = '' for encoded_word in input_seq: if(encoded_word != 0 and encoded_word != tar_vocab['<sos>'] and encoded_word != tar_vocab['<eos>']): sentence = sentence + index_to_tar[encoded_word] + ' ' return sentence print(encoder_input_test[25]) print(decoder_input_test[25]) print(decoder_target_test[25]) array([ 4, 22, 931, 2, 0, 0, 0]) array([ 3, 19, 36, 2007, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) array([ 19, 36, 2007, 2, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) decode_sequence() 함수를 봅시다. 테스트 단계에서는 디코더를 매 시점 별로 컨트롤하게 됩니다. 각 시점을 for 문을 통해서 컨트롤하게 되며, 현재 시점의 예측은 다음 시점의 입력으로 사용됩니다. 여기서 사용될 변수는 decoder_input입니다. def decode_sequence(input_seq, model, src_vocab_size, tar_vocab_size, max_output_len, int_to_src_token, int_to_tar_token): encoder_inputs = torch.tensor(input_seq, dtype=torch.long).unsqueeze(0).to(device) # 인코더의 초기 상태 설정 hidden, cell = model.encoder(encoder_inputs) # 시작 토큰 <sos>을 디코더의 첫 입력으로 설정 # unsqueeze(0)는 배치 차원을 추가하기 위함. decoder_input = torch.tensor([3], dtype=torch.long).unsqueeze(0).to(device) decoded_tokens = [] # for 문을 도는 것 == 디코더의 각 시점 for _ in range(max_output_len): output, hidden, cell = model.decoder(decoder_input, hidden, cell) # 소프트맥스 회귀를 수행. 예측 단어의 인덱스 output_token = output.argmax(dim=-1).item() # 종료 토큰 <eos> if output_token == 4: break # 각 시점의 단어(정수)는 decoded_tokens에 누적하였다가 최종 번역 시퀀스로 리턴합니다. decoded_tokens.append(output_token) # 현재 시점의 예측. 다음 시점의 입력으로 사용된다. decoder_input = torch.tensor([output_token], dtype=torch.long).unsqueeze(0).to(device) return ' '.join(int_to_tar_token[token] for token in decoded_tokens) 결과 확인을 위한 함수를 만듭니다. seq_to_src 함수는 영어 문장에 해당하는 정수 시퀀스를 입력받으면 정수로부터 영어 단어를 리턴하는 index_to_src를 통해 영어 문장으로 변환합니다. seq_to_tar은 프랑스어에 해당하는 정수 시퀀스를 입력받으면 정수로부터 프랑스어 단어를 리턴하는 index_to_tar을 통해 프랑스어 문장으로 변환합니다. 훈련 데이터에 대해서 임의로 선택한 인덱스의 샘플의 결과를 출력해 봅시다. for seq_index in [3, 50, 100, 300, 1001]: input_seq = encoder_input_train[seq_index] translated_text = decode_sequence(input_seq, model, src_vocab_size, tar_vocab_size, 20, index_to_src, index_to_tar) print("입력 문장 :",seq_to_src(encoder_input_train[seq_index])) print("정답 문장 :",seq_to_tar(decoder_input_train[seq_index])) print("번역 문장 :",translated_text) print("-"*50) 입력 문장 : you re fortunate . 정답 문장 : tu es chanceux . 번역 문장 : tu es chanceuse . -------------------------------------------------- 입력 문장 : run for it ! 정답 문장 : taillez vous ! 번역 문장 : sauvez vous ! -------------------------------------------------- 입력 문장 : pass me the water . 정답 문장 : passe moi l eau . 번역 문장 : passe moi l eau . -------------------------------------------------- 입력 문장 : i couldn t fight . 정답 문장 : je ne pourrais pas me battre . 번역 문장 : je ne pourrais pas me battre . -------------------------------------------------- 입력 문장 : get real ! 정답 문장 : sois realiste ! 번역 문장 : sois realiste ! -------------------------------------------------- 테스트 데이터에 대해서 임의로 선택한 인덱스의 샘플의 결과를 출력해 봅시다. for seq_index in [3, 50, 100, 300, 1001]: input_seq = encoder_input_test[seq_index] translated_text = decode_sequence(input_seq, model, src_vocab_size, tar_vocab_size, 20, index_to_src, index_to_tar) print("입력 문장 :",seq_to_src(encoder_input_test[seq_index])) print("정답 문장 :",seq_to_tar(decoder_input_test[seq_index])) print("번역 문장 :",translated_text) print("-"*50) 입력 문장 : you re good . 정답 문장 : tu es bonne . 번역 문장 : vous etes bon . -------------------------------------------------- 입력 문장 : you cheated . 정답 문장 : tu as triche . 번역 문장 : vous avez triche . -------------------------------------------------- 입력 문장 : put it there . 정답 문장 : mettez le la . 번역 문장 : mets le la . -------------------------------------------------- 입력 문장 : get your gear . 정답 문장 : allez chercher votre materiel ! 번역 문장 : va chercher tes affaires ! -------------------------------------------------- 입력 문장 : i m a stutterer . 정답 문장 : je suis begue . 번역 문장 : je suis un coureur . -------------------------------------------------- 번역기를 통해서 입력 문장과 정답 문장 번역 문장의 실제 내용을 확인해 보았습니다. 입력 문장 (영어) : you re good . 번역 문장 (한국어) : 너 정말 잘하네. 정답 문장 (프랑스어) : tu es bonne . 번역 문장 (한국어) : 너 정말 잘하네. 번역 문장 (프랑스어) : vous etes bon . 번역 문장 (한국어) : 당신은 좋습니다. --- 입력 문장 (영어) : you cheated . 번역 문장 (한국어) : 너 속였어. 정답 문장 (프랑스어) : tu as triche . 번역 문장 (한국어) : 너 속였어. 번역 문장 (프랑스어) : vous avez triche . 번역 문장 (한국어) : 당신은 속였어. --- 입력 문장 (영어) : put it there . 번역 문장 (한국어) : 거기에 놓으세요. 정답 문장 (프랑스어) : mettez le la . 번역 문장 (한국어) : 거기에 놓으세요. 번역 문장 (프랑스어) : mets le la . 번역 문장 (한국어) : 거기에 놓아. --- 입력 문장 (영어) : get your gear . 번역 문장 (한국어) : 네 물건 가져와. 정답 문장 (프랑스어) : allez chercher votre materiel ! 번역 문장 (한국어) : 네 물건 가져와! 번역 문장 (프랑스어) : va chercher tes affaires ! 번역 문장 (한국어) : 네 물건 가져와! --- 입력 문장 (영어) : i m a stutterer . 번역 문장 (한국어) : 나는 말더듬이야. 정답 문장 (프랑스어) : je suis begue . 번역 문장 (한국어) : 나는 말더듬이야. 번역 문장 (프랑스어) : je suis un coureur . 번역 문장 (한국어) : 나는 달리기 선수입니다. 15-03에서 이 번역기를 좀 더 개선한 버전을 구현합니다. 16-03 BLEU Score(Bilingual Evaluation Understudy Score) 앞서 언어 모델(Language Model)의 성능 측정을 위한 평가 방법으로 펄 플렉서티(perplexity, PPL)를 소개한 바 있습니다. 기계 번역기에도 PPL을 평가에 사용할 수는 있지만, PPL은 번역의 성능을 직접적으로 반영하는 수치라 보기엔 어렵습니다. 자연어 처리에서는 그 외에도 수많은 평가 방법들이 존재하는데, 기계 번역의 성능이 얼마나 뛰어난가를 측정하기 위해 사용되는 대표적인 방법인 BLEU(Bilingual Evaluation Understudy) 대해서 학습해 보겠습니다. 앞으로 진행되는 설명은 논문 BLEU: a Method for Automatic Evaluation of Machine Translation를 참고로 하여 작성되었습니다. import numpy as np from collections import Counter from nltk import ngrams 1. BLEU(Bilingual Evaluation Understudy) BLEU는 기계 번역 결과와 사람이 직접 번역한 결과가 얼마나 유사한지 비교하여 번역에 대한 성능을 측정하는 방법입니다. 측정 기준은 n-gram에 기반합니다. n-gram의 정의는 언어 모델 챕터를 참고하시기 바랍니다. BLEU는 완벽한 방법이라고는 할 수는 없지만 몇 가지 이점을 가집니다. 언어에 구애받지 않고 사용할 수 있으며, 계산 속도가 빠릅니다. BLEU는 PPL 과는 달리 높을수록 성능이 더 좋음을 의미합니다. BLEU를 이해하기 위해 기계 번역 성능 평가를 위한 몇 가지 직관적인 방법을 먼저 제시하고, 문제점을 보완해나가는 방식으로 설명합니다. 1) 단어 개수 카운트로 측정하기(Unigram Precision) 한국어-영어 번역기의 성능을 측정한다고 가정해 봅시다. 두 개의 기계 번역기가 존재하고 두 기계 번역기에 같은 한국어 문장을 입력하여 번역된 영어 문장의 성능을 측정하고자 합니다. 번역된 문장을 각각 Candidate1, 2라고 해봅시다. 이 문장의 성능을 평가하기 위해서는 정답으로 비교되는 문장이 있어야 합니다. 세 명의 사람에게 한국어를 보고 영작해 보라고 하여 세 개의 번역 문장을 만들어냈습니다. 이 세 문장을 각각 Reference1, 2, 3라고 해봅시다. Example 1 Candidate1 : It is a guide to action which ensures that the military always obeys the commands of the party. Candidate2 : It is to insure the troops forever hearing the activity guidebook that party direct. Reference1 : It is a guide to action that ensures that the military will forever heed Party commands. Reference2 : It is the guiding principle which guarantees the military forces always being under the command of the Party. Reference3 : It is the practical guide for the army always to heed the directions of the party. 편의상 Candidate를 Ca로, Reference를 Ref로 축약하여 부르겠습니다. Ca 1, 2를 Ref 1, 2, 3과 비교하여 성능을 측정하고자 합니다. 가장 직관적인 성능 평가 방법은 Ref 1, 2, 3 중 어느 한 문장이라도 등장한 단어의 개수를 Ca에서 세는 것입니다. 그리고 그 후에 Ca의 모든 단어의 카운트의 합. 즉, Ca에서의 총 단어의 수으로 나눠줍니다. 이러한 측정 방법을 유니그램 정밀도(Unigram Precision)라고 합니다. 이를 식으로 표현하면 다음과 같습니다. 들 중에서 존재하는의 단어의 수 의총 단어 수 Unigram Precision = Ref들 중에서 존재하는 Ca의 단어의 수 Ca의 총 단어 수 the number of Ca words(unigrams) which occur in any Ref the total number of words in the Ca Ca1의 단어들은 얼추 훑어만 봐도 Ref1, Ref2, Ref3에서 전반적으로 등장하는 반면, Ca2는 그렇지 않습니다. 이는 Ca1이 Ca2보다 더 좋은 번역 문장임을 의미합니다. 예를 들어 Ca1의 It is a guide to action은 Ref1에서, which는 Ref2에서, ensures that the militrary는 Ref1에서, always는 Ref2와 Ref3에서, commands는 Ref1에서, of the party는 Ref2에서 등장하였습니다. (대소문자 구분은 없다고 합시다.) Ca1에 있는 단어 중 Ref1, Ref2, Ref3 어디에도 등장하지 않은 단어는 obeys뿐입니다. 반면, Ca2는 Ca1과 비교하여 상대적으로 Ref1, 2, 3에 등장한 단어들이 적습니다. 위의 계산 방법에 따르면 Ca1과 Ca2의 유니그램 정밀도는 각각 아래와 같습니다. Ca1 Unigram Precision = 17 18 Ca2 Unigram Precision = 14 이제부터는 단어라는 표현보다는 유니그램이라는 용어로 설명하겠습니다. 지금까지 설명한 유니그램 정밀도는 나름 의미 있는 측정 방법으로 보이지만 사실 허술한 점이 있습니다. 아래와 같은 새로운 예가 있다고 해봅시다. 2) 중복을 제거하여 보정하기(Modified Unigram Precision) Example 2 Candidate : the the the the the the the Reference1 : the cat is on the mat Reference2 : there is a cat on the mat 위의 Ca는 the만 7개가 등장한 터무니없는 번역입니다. 하지만 이 번역은 앞서 배운 유니그램 정밀도에 따르면 7 1 이라는 최고의 성능 평가를 받게 됩니다. 이에 유니그램 정밀도를 다소 보정할 필요를 느낍니다. 이를 보정하기 위해서는 정밀도의 분자를 계산하기 위해 Ref와 매칭하며 카운트하는 과정에서 Ca의 유니그램이 이미 Ref에서 매칭된 적이 있었는지를 고려해야 합니다. 들과를 고려한 새로운 카운트 방법이 필요 의총 유니 그램 수 Unigram Precision = Ref 들과 Ca를 고려한 새로운 카운트 방법이 필요! Ca의 총 유니그램 수 정밀도의 분자를 계산하기 위한 각 유니그램의 카운트는 다음과 같이 수정합시다. 우선, 유니그램이 하나의 Ref에서 최대 몇 번 등장했는지를 카운트합니다. 이 값을 maximum reference count를 줄인 의미에서 Max_Ref_Count라고 부르겠습니다. Max_Ref_Count가 기존의 단순 카운트한 값보다 작은 경우에는 이 값을 최종 카운트 값으로 대체합니다. 정밀도의 분자 계산을 위한 새로운 카운트 방식을 식으로 표현하면 다음과 같습니다. o n c i = m n ( o n , M x R f C u t ) 위의 카운트를 사용하여 분자를 계산한 정밀도를 보정된 유니그램 정밀도(Modified Unigram Precision)라고 합니다. 의각유니그램에대해을수행한값의총합 의총 유니 그램 수 Modified Unigram Precision = Ca의 각 유니그램에 대해 o n c i 을 수행한 값의 총합 Ca의 총 유니그램 수 분모의 경우에는 이전과 동일하게 Ca의 모든 유니그램에 대해서 각각 o n 하고 모두 합한 값을 사용합니다. 보정된 유니그램 정밀도를 예제를 통해 이해해 봅시다. Example 2를 볼까요? the의 경우에는 Ref1에서 총 두 번 등장하였으므로, the의 카운트는 2로 보정됩니다. Ca의 기존 유니그램 정밀도는 7 1 이었으나 보정된 유니그램 정밀도는 7 와 같이 변경됩니다. 다른 예로 Example 1에서의 Ca1의 보정된 유니그램 정밀도를 계산해 보면 보정되기 이전과 동일하게 17 18 이지만 결과를 얻는 과정은 다릅니다. Ca1에서 the는 3번 등장하지만, Re2와 Ref3에서 the가 4번 등장하므로 3이 4보다 작으므로 the는 3으로 카운트됩니다. the 외에 Ca1의 모든 유니그램은 전부 1개씩 등장하므로 보정 전과 동일하게 카운트하면 됩니다. 결과적으로 보정 이전의 정밀도와 동일하게 17 18 의 값을 가집니다. 3) 보정된 유니그램 정밀도 (Modified Unigram Precision) 구현하기 보정된 유니그램 정밀도를 파이썬 함수로 구현해 보겠습니다. 보정된 유니그램 정밀도를 구현하기 위해서는 유니그램을 카운트하는 o n 함수와 o n c i 함수 두 가지 함수를 구현해야 합니다. 분모를 구하기 위해서 o n 함수를 사용하고, 분자를 구하기 위해서 o n c i 함수를 사용하면 보정된 유니그램 정밀도를 구할 수 있습니다. 우선 유니그램을 단순히 o n 하는 함수를 simple_count라는 이름의 아래 함수로 구현합니다. # 토큰화된 문장(tokens)에서 n-gram을 카운트 def simple_count(tokens, n): return Counter(ngrams(tokens, n)) 위 함수는 토큰화된 문장을 입력받아서 문장 내의 n-gram의 개수를 카운트하는 함수입니다. 구하고자 하는 것은 유니그램 정밀도이므로 카운트하고자 하는 n-gram의 단위를 결정하는 simple_count 함수의 두 번째 인자인 n의 값을 1로 하여 함수를 실행하면 됩니다. Example 1의 Ca1를 가져와 함수가 어떤 결과를 출력하는지 확인해 봅시다. candidate = "It is a guide to action which ensures that the military always obeys the commands of the party." tokens = candidate.split() # 토큰화 result = simple_count(tokens, 1) # n = 1은 유니그램 print('유니그램 카운트 :',result) 유니그램 카운트 : Counter({('the',): 3, ('It',): 1, ('is',): 1, ('a',): 1, ('guide',): 1, ('to',): 1, ('action',): 1, ('which',): 1, ('ensures',): 1, ('that',): 1, ('military',): 1, ('always',): 1, ('obeys',): 1, ('commands',): 1, ('of',): 1, ('party.',): 1}) 위의 출력 결과는 모든 유니그램을 카운트한 결과를 보여줍니다. 대부분의 유니그램이 1개씩 카운트되었으나 유니그램 the는 문장에서 3번 등장하였으므로 유일하게 3의 값을 가집니다. 이번에는 Example 2의 Ca를 가지고 함수를 수행해 봅시다. candidate = 'the the the the the the the' tokens = candidate.split() # 토큰화 result = simple_count(tokens, 1) # n = 1은 유니그램 print('유니그램 카운트 :',result) 유니그램 카운트 : Counter({('the',): 7}) simple_count 함수는 단순 카운트를 수행하므로 the에 대해서 7이라는 카운트 값을 리턴합니다. o n에 대한 함수를 구현하였으니 이번에는 o n c i 을 아래의 count_clip 이름을 가진 함수로 구현해 보겠습니다. def count_clip(candidate, reference_list, n): # Ca 문장에서 n-gram 카운트 ca_cnt = simple_count(candidate, n) max_ref_cnt_dict = dict() for ref in reference_list: # Ref 문장에서 n-gram 카운트 ref_cnt = simple_count(ref, n) # 각 Ref 문장에 대해서 비교하여 n-gram의 최대 등장 횟수를 계산. for n_gram in ref_cnt: if n_gram in max_ref_cnt_dict: max_ref_cnt_dict[n_gram] = max(ref_cnt[n_gram], max_ref_cnt_dict[n_gram]) else: max_ref_cnt_dict[n_gram] = ref_cnt[n_gram] return { # count_clip = min(count, max_ref_count) n_gram: min(ca_cnt.get(n_gram, 0), max_ref_cnt_dict.get(n_gram, 0)) for n_gram in ca_cnt } count_clip 함수는 candidate 문장과 reference 문장들, 그리고 카운트 단위가 되는 n-gram에서의 n의 값 이 세 가지를 인자로 입력받아서 o n c i 을 수행합니다. 여기서는 유니그램 정밀도를 구현하고 있으므로 역시나 n=1로 하여 함수를 실행하면 됩니다. 또한 count_clip 함수 내부에는 기존에 구현했던 simple_count 함수가 사용된 것을 확인할 수 있습니다. o n c i 을 구하기 위해서는 a _ e _ o n 값과 비교하기 위해 o n 값이 필요하기 때문입니다. Example 2를 통해 함수가 정상 작동되는지 확인해 봅시다. candidate = 'the the the the the the the' references = [ 'the cat is on the mat', 'there is a cat on the mat' ] result = count_clip(candidate.split(),list(map(lambda ref: ref.split(), references)),1) print('보정된 유니그램 카운트 :',result) 보정된 유니그램 카운트 : {('the',): 2} 동일한 예제 문장에 대해서 위의 simple_count 함수는 the가 7개로 카운트되었던 것과는 달리 이번에는 2개로 카운트되었습니다. 위의 두 함수를 사용하여 예제 문장에 대해서 보정된 정밀도를 연산하는 함수를 modified_precision란 이름의 함수로 구현해 봅시다. def modified_precision(candidate, reference_list, n): clip_cnt = count_clip(candidate, reference_list, n) total_clip_cnt = sum(clip_cnt.values()) # 분자 cnt = simple_count(candidate, n) total_cnt = sum(cnt.values()) # 분모 # 분모가 0이 되는 것을 방지 if total_cnt == 0: total_cnt = 1 # 분자 : count_clip의 합, 분모 : 단순 count의 합 ==> 보정된 정밀도 return (total_clip_cnt / total_cnt) result = modified_precision(candidate.split(), list(map(lambda ref: ref.split(), references)), n=1) print('보정된 유니그램 정밀도 :',result) 보정된 유니그램 정밀도 : 0.2857142857142857 소수 값이 나오는데 이는 7 의 값을 의미합니다. 이는 앞서 육안으로 계산했던 Example 2에서 Ca의 보정된 정밀도와 동일합니다. 지금까지 보정된 유니그램 정밀도에 대해서 설명하고, 직접 구현까지 해보았습니다. 이제부터 설명에서 언급하는 '정밀도'는 기본적으로 보정된 정밀도(Modified Precision)라고 가정합니다. 정밀도를 보정함으로써 Ca에서 발생하는 단어 중복에 대한 문제점은 해결되었습니다. 하지만 유니그램 정밀도가 가지는 본질적인 문제점이 있기에 유니그램을 넘어 바이 그램, 트라이 그램 등과 같이 n-gram으로 확장해야 합니다. 문제점이 무엇인지 이해하고, 어떻게 n-gram으로 확장하는지 학습해 봅시다. 4) 순서를 고려하기 위해서 n-gram으로 확장하기 BoW 표현과 유사하게, 유니그램 정밀도와 같이 각 단어의 빈도수로 접근하는 방법은 결국 단어의 순서를 고려하지 않는다는 특징이 있습니다. Example 1에 Ca3이라는 새로운 문장을 추가해 보고 기존의 Ca1과 비교해 봅시다. Example 1 Candidate1 : It is a guide to action which ensures that the military always obeys the commands of the party. Candidate2 : It is to insure the troops forever hearing the activity guidebook that party direct. Candidate3 : the that military a is It guide ensures which to commands the of action obeys always party the. Reference1 : It is a guide to action that ensures that the military will forever heed Party commands. Reference2 : It is the guiding principle which guarantees the military forces always being under the command of the Party. Reference3 : It is the practical guide for the army always to heed the directions of the party. Ca3은 사실 Ca1에서 모든 유니그램의 순서를 랜덤으로 섞은 실제 영어 문법에 맞지 않은 문장입니다. 하지만 Ref 1, 2, 3과 비교하여 유니그램 정밀도를 적용하면 Ca1과 Ca3의 두 정밀도는 동일합니다. 유니그램 정밀도는 유니그램의 순서를 전혀 고려하지 않기 때문입니다. 이를 위한 대안으로 개별적인 유니그램/단어로서 카운트하는 유니그램 정밀도에서 다음에 등장한 단어까지 함께 고려하여 카운트하도록 유니그램 외에도 Bigram, Trigram, 4-gram 단위 등으로 계산한 정밀도. 즉, n-gram을 이용한 정밀도를 도입하고자 합니다. 이들 각각은 카운트 단위를 2개, 3개, 4개로 보느냐의 차이로 2-gram Precision, 3-gram Precision, 4-gram Precision이라고 하기도 합니다. 어떤 의미인지 바이 그램(Bigram) 단위로 카운트하여 Example 1, 2의 바이 그램 정밀도(Bigram Precision)를 계산해 보겠습니다. 우선 좀 더 쉬운 Example 2부터 볼까요? Example 2 Candidate1 : the the the the the the the Candidate2 : the cat the cat on the mat Reference1 : the cat is on the mat Reference2 : there is a cat on the mat 이해를 돕고자 Example 2에 Ca2를 새로 추가했습니다. Ca2 바이 그램의 o n 와 o n c i 은 아래와 같습니다. 바이 그램 the cat cat the cat on on the the mat SUM o n 2 1 1 1 1 6 o n c i 1 0 1 1 1 4 결과적으로 Ca2의 바이 그램 정밀도는 6 가 됩니다. 반면, 당연하게도 Ca1의 바이 그램 정밀도는 0입니다. Example 1은 어떨까요? Example 1에서 Ca1의 바이 그램 정밀도는 10 17 이며, Ca2의 바이 그램 정밀도는 13 입니다. Ca1에서 단어의 순서를 뒤섞은 Ca3의 바이 그램 정밀도는 독자분들의 숙제로 남깁니다. 보정된 정밀도를 식으로 정의해 보겠습니다. n 에서 은 n-gram에서의 을 의미한다고 하였을 때, 앞서 배운 보정된 유니그램 정밀도의 식을 상기해 봅시다. 1 ∑ n g a ∈ a d d t C u t l p ( n g a) u i r m C n i a e C u t ( n g a) 이를 n-gram으로 일반화하면 아래와 같습니다. n ∑ - r m C n i a e C u t l p ( - r m ) n g a ∈ a d d t C u t ( - r m ) 유니그램 정밀도에서는 이 1이므로 1 로 표현하였으나, 일반화된 식에서는 n 으로 표현한 것을 볼 수 있습니다. 여기서는 보정된 바이 그램 정밀도 2 , 보정된 트라이 그램 정밀도 3 등에 대한 파이썬 실습은 생략합니다. 사실 n 을 계산하기 위한 함수를 별도로 다시 구현할 필요는 없는데, 앞서 구현한 함수 simple_count, count_clip, modified_precision은 모두 n-gram의 n을 함수의 인자로 받으므로, n을 1대신 다른 값을 넣어서 실습해 보면 바이 그램, 트라이 그램 등에 대해서도 보정된 정밀도를 구할 수 있습니다. n-gram 정밀도 식을 이해하였다면 BLEU의 최종 식까지 다 왔습니다. BLEU는 보정된 정밀도 1 p, . , n 를 모두 조합하여 사용합니다. 이를 모두 조합한 BLEU의 식은 아래와 같습니다. L U e p ( n 1 w log p) n : 각 gram의 보정된 정밀도입니다. : n-gram에서의 최대 숫자입니다. 보통은 4의 값을 가집니다. 이 4라는 것은 1 p, 3 p를 사용한다는 것을 의미합니다. n : 각 gram의 보정된 정밀도에 서로 다른 가중치를 줄 수 있습니다. 이 가중치의 합은 1로 합니다. 예를 들어 이 4라고 하였을 때, 1 p, 3 p에 대해서 동일한 가중치를 주고자 한다면 모두 0.25를 적용할 수 있습니다. BLEU의 최종식에 거의 다 도달했습니다. 즉, 여전히 위의 BLEU 식에도 문제점이 존재합니다. 5) 짧은 문장 길이에 대한 페널티(Brevity Penalty) n-gram으로 단어의 순서를 고려한다고 하더라도 여전히 남아있는 문제가 있는데, 바로 Ca의 길이에 BLEU의 점수가 과한 영향을 받을 수 있다는 점입니다. 기존 Example 1에 다음의 Ca를 추가한다고 해보겠습니다. Example 1 Candidate4 : it is 이 문장은 유니그램 정밀도나 바이 그램 정밀도가 각각 2 1로 두 정밀도 모두 1이라는 높은 정밀도를 얻습니다. 이과같이 제대로 된 번역이 아님에도 문장의 길이가 짧다는 이유로 높은 점수를 받는 것은 이상합니다. 그래서 Ca가 Ref보다 문장의 길이가 짧은 경우에는 점수에 페널티를 줄 필요가 있습니다. 이를 브레 버티 페널티(Brevity Penalty)라고 합니다. (직역하면 짧음 페널티) 이에 대해서 배우기 전에, 만약 반대로 Ca의 길이가 Ref보다 긴 경우에도 문제가 생길 수 있는지 보겠습니다. Example 3 Candidate 1: I always invariably perpetually do. Candidate 2: I always do. Reference 1: I always do. Reference 2: I invariably do. Reference 3: I perpetually do. Example 3에서 Ca1은 가장 많은 단어를 사용했지만 Ca2보다 좋지 못한 번역입니다. 다시 말해 Ref의 단어를 가장 많이 사용한 것이 꼭 좋은 번역이라는 의미는 아닙니다. 그런데 다행히도 위와 같이 Ca의 길이가 불필요하게 Ref보다 긴 경우에는 BLEU 수식에서 정밀도를 n-gram으로 확장하여 바이 그램, 트라이 그램 정밀도 등을 모두 계산에 사용하고 있는 것만으로도 이미 페널티를 받고 있습니다. 즉, 브레 버티 페널티를 설계할 때, 이 경우까지 고려할 필요는 없습니다. 다시 Ref보다 Ca의 길이가 짧을 경우에 페널티를 주는 브레 버티 페널티의 이야기로 돌아보겠습니다. 브레 버티 페널티는 앞서 배운 BLEU의 식에 곱하는 방식으로 사용합니다. 브레 버티 페널티를 줄여서 P 라고 하였을 때, 최종 BLEU의 식은 아래와 같습니다. L U B × x ( n 1 w log p) 위의 수식은 페널티를 줄 필요가 없는 경우에는 P 의 값이 1이어야 함을 의미합니다. 이를 반영한 P 의 수식은 아래와 같습니다. P { if c r ( − / ) if c r : Candidate의 길이 : Candidate와 가장 길이 차이가 작은 Reference의 길이 Ref가 1개라면 Ca와 Ref의 두 문장의 길이만을 가지고 계산하면 되겠지만 여기서는 Ref가 여러 개일 때를 가정하고 있으므로 은 모든 Ref들 중에서 Ca와 가장 길이 차이가 작은 Ref의 길이로 합니다. 을 구하는 코드는 아래와 같습니다. # Ca 길이와 가장 근접한 Ref의 길이를 리턴하는 함수 def closest_ref_length(candidate, reference_list): ca_len = len(candidate) # ca 길이 ref_lens = (len(ref) for ref in reference_list) # Ref들의 길이 # 길이 차이를 최소화하는 Ref를 찾아서 Ref의 길이를 리턴 closest_ref_len = min(ref_lens, key=lambda ref_len: (abs(ref_len - ca_len), ref_len)) return closest_ref_len 만약 Ca와 길이가 정확히 동일한 Ref가 있다면 길이 차이가 0인 최고 수준의 매치(best match length)입니다. 또한 만약 서로 다른 길이의 Ref이지만 Ca와 길이 차이가 동일한 경우에는 더 작은 길이의 Ref를 택합니다. 예를 들어 Ca가 길이가 10인데, Ref 1, 2가 각각 9와 11이라면 길이 차이는 동일하게 1밖에 나지 않지만 9를 택합니다. closest_ref_length 함수를 통해 을 구했다면, P 를 구하는 함수 brevity_penalty를 구현해 봅시다. def brevity_penalty(candidate, reference_list): ca_len = len(candidate) ref_len = closest_ref_length(candidate, reference_list) if ca_len > ref_len: return 1 # candidate가 비어있다면 BP = 0 → BLEU = 0.0 elif ca_len == 0 : return 0 else: return np.exp(1 - ref_len/ca_len) 위 함수는 앞서 배운 P 의 수식처럼 가 보다 클 경우에는 1을 리턴하고, 그 외의 경우에는 1 r c 를 리턴합니다. 최종적으로 BLEU 점수를 계산하는 함수 bleu_score를 구현해 봅시다. def bleu_score(candidate, reference_list, weights=[0.25, 0.25, 0.25, 0.25]): bp = brevity_penalty(candidate, reference_list) # 브레 버티 페널티, BP p_n = [modified_precision(candidate, reference_list, n=n) for n, _ in enumerate(weights, start=1)] # p1, p2, p3, ..., pn score = np.sum([w_i * np.log(p_i) if p_i != 0 else 0 for w_i, p_i in zip(weights, p_n)]) return bp * np.exp(score) 위의 bleu_score 함수는 기본적으로는 이 4에 각 gram에 대한 가중치는 동일하게 0.25라 주어진다고 가정합니다. 또한 함수 내에서는 P 를 구하고 bp에, 1 p, . , n 를 구하여 p_n에 저장하도록 구현돼 있습니다. 그리고 앞서 배운 BLEU의 식에 따라 추가 연산하여 최종 계산한 값을 리턴합니다. 위 함수가 동작하기 위해서는 앞서 구현한 simple_count, count_clip, modified_precision, brevity_penalty 4개의 함수 또한 모두 구현돼 있어야 합니다. 지금까지 구현한 BLEU 코드로 계산된 점수와 NLTK 패키지에 이미 구현돼 있는 BLEU 코드로 계산된 점수를 비교해 봅시다. 2. NLTK를 사용한 BLEU 측정하기 파이썬에서는 NLTK 패키지를 사용하여 BLEU를 계산할 수 있습니다. import nltk.translate.bleu_score as bleu candidate = 'It is a guide to action which ensures that the military always obeys the commands of the party' references = [ 'It is a guide to action that ensures that the military will forever heed Party commands', 'It is the guiding principle which guarantees the military forces always being under the command of the Party', 'It is the practical guide for the army always to heed the directions of the party' ] print('실습 코드의 BLEU :',bleu_score(candidate.split(),list(map(lambda ref: ref.split(), references)))) print('패키지 NLTK의 BLEU :',bleu.sentence_bleu(list(map(lambda ref: ref.split(), references)),candidate.split())) 실습 코드의 BLEU : 0.5045666840058485 패키지 NLTK의 BLEU : 0.5045666840058485 17. [NLP 고급 ] - 어텐션 메커니즘 이번 챕터에서는 신경망들의 성능을 높이기 위한 메커니즘이자, 이제는 AI 분야에서 대세 모듈로서 사용되고 있는 트랜스포머의 기반이 되는 어텐션 메커니즘에 대해서 학습합니다. 17-01 어텐션 메커니즘 (Attention Mechanism) 앞서 배운 seq2seq 모델은 인코더에서 입력 시퀀스를 컨텍스트 벡터라는 하나의 고정된 크기의 벡터 표현으로 압축하고, 디코더는 이 컨텍스트 벡터를 통해서 출력 시퀀스를 만들어냈습니다. 하지만 이러한 RNN에 기반한 seq2seq 모델에는 크게 두 가지 문제가 있습니다. 첫째, 하나의 고정된 크기의 벡터에 모든 정보를 압축하려고 하니까 정보 손실이 발생합니다. 둘째, RNN의 고질적인 문제인 기울기 소실(vanishing gradient) 문제가 존재합니다. 결국 이는 기계 번역 분야에서 입력 문장이 길면 번역 품질이 떨어지는 현상으로 나타났습니다. 이를 위한 대안으로 입력 시퀀스가 길어지면 출력 시퀀스의 정확도가 떨어지는 것을 보정해 주기 위한 등장한 기법인 어텐션(attention)을 소개합니다. 1. 어텐션(Attention)의 아이디어 어텐션의 기본 아이디어는 디코더에서 출력 단어를 예측하는 매 시점(time step)마다, 인코더에서의 전체 입력 문장을 다시 한번 참고한다는 점입니다. 단, 전체 입력 문장을 전부 다 동일한 비율로 참고하는 것이 아니라, 해당 시점에서 예측해야 할 단어와 연관이 있는 입력 단어 부분을 좀 더 집중(attention) 해서 보게 됩니다. 2. 어텐션 함수(Attention Function) 어텐션 메커니즘을 언급하기 전에 컴퓨터공학의 많은 분야에서 사용되는 Key-Value로 구성되는 자료형에 대해서 잠깐 언급하겠습니다. 가령, 이 책의 주 언어로 사용되는 파이썬에도 Key-Value로 구성되는 자료형인 딕셔너리(Dict) 자료형이 존재합니다. 파이썬의 딕셔너리 자료형은 키(Key)와 값(Value)이라는 두 개의 쌍으로 구성되는데, 키를 통해서 매핑된 값을 찾아낼 수 있다는 특징을 갖고 있습니다. # 파이썬의 딕셔너리 자료형을 선언 # 키(Key) : 값(value)의<NAME>으로 키와 값의 쌍(Pair)을 선언한다. dict = {"2017" : "Transformer", "2018" : "BERT"} 위의 자료형에서 2017은 키에 해당되며, Transformer는 2017의 키와 매핑되는 값에 해당됩니다. 그와 마찬가지로 2018은 키에 해당되며, BERT는 2018이라는 키와 매핑되는 값에 해당됩니다. print(dict["2017"]) #2017이라는 키에 해당되는 값을 출력 Transformer print(dict["2018"]) #2018이라는 키에 해당되는 값을 출력 BERT Key-Value 자료형에 대한 이해를 가지고 어텐션 함수에 대해서 설명해 보겠습니다. 어텐션을 함수로 표현하면 주로 다음과 같이 표현됩니다. Attention(Q, K, V) = Attention Value 어텐션 함수는 주어진 '쿼리(Query)'에 대해서 모든 '키(Key)'와의 유사도를 각각 구합니다. 그리고 구해낸 이 유사도를 키와 매핑되어있는 각각의 '값(Value)'에 반영해 줍니다. 그리고 유사도가 반영된 '값(Value)'을 모두 더해서 리턴합니다. 여기서는 이를 어텐션 값(Attention Value)이라고 하겠습니다. 지금부터 배우게 되는 seq2seq + 어텐션 모델에서 Q, K, V에 해당되는 각각의 Query, Keys, Values는 각각 다음과 같습니다. Q = Query : t 시점의 디코더 셀에서의 은닉 상태 K = Keys : 모든 시점의 인코더 셀의 은닉 상태들 V = Values : 모든 시점의 인코더 셀의 은닉 상태들 간단한 어텐션 예제를 통해 어텐션을 이해해 보겠습니다. 3. 닷-프로덕트 어텐션(Dot-Product Attention) 어텐션은 다양한 종류가 있는데 그중에서도 가장 수식적으로 이해하기 쉽게 수식을 적용한 닷-프로덕트 어텐션(Dot-Product Attention)을 통해 어텐션을 이해해 봅시다. seq2seq에서 사용되는 어텐션 중에서 닷-프로덕트 어텐션과 다른 어텐션의 차이는 주로 중간 수식의 차이로 메커니즘 자체는 거의 유사합니다. 위 그림은 디코더의 세 번째 LSTM 셀에서 출력 단어를 예측할 때, 어텐션 메커니즘을 사용하는 모습을 보여줍니다. 디코더의 첫 번째, 두 번째 LSTM 셀은 이미 어텐션 메커니즘을 통해 je와 suis를 예측하는 과정을 거쳤다고 가정합니다. 어텐션 메커니즘에 대해 상세히 설명하기 전에 위의 그림을 통해 전체적인 개요만 이해해 보겠습니다. 디코더의 세 번째 LSTM 셀은 출력 단어를 예측하기 위해서 인코더의 모든 입력 단어들의 정보를 다시 한번 참고하고자 합니다. 중간 과정에 대한 설명은 현재는 생략하고 여기서 주목할 것은 인코더의 소프트맥스 함수입니다. 소프트맥스 함수를 통해 나온 결괏값은 I, am, a, student 단어 각각이 출력 단어를 예측할 때 얼마나 도움이 되는지의 정도를 수치화한 값입니다. 위의 그림에서는 빨간 직사각형의 크기로 소프트맥스 함수의 결괏값의 크기를 표현했습니다. 직사각형의 크기가 클수록 도움이 되는 정도의 크기가 큽니다. 각 입력 단어가 디코더의 예측에 도움이 되는 정도가 수치화하여 측정되면 이를 하나의 정보로 담아서 디코더로 전송됩니다. 위의 그림에서는 초록색 삼각형이 이에 해당됩니다. 결과적으로, 디코더는 출력 단어를 더 정확하게 예측할 확률이 높아집니다. 좀 더 상세히 알아보겠습니다. 1) 어텐션 스코어(Attention Score)를 구한다. 인코더의 시점(time step)을 각각 1, 2, ... N이라고 하였을 때 인코더의 은닉 상태(hidden state)를 각각 1 h, ... N 라고 합시다. 디코더의 현재 시점(time step) t에서의 디코더의 은닉 상태(hidden state)를 t 라고 합시다. 또한 여기서는 인코더의 은닉 상태와 디코더의 은닉 상태의 차원이 같다고 가정합니다. 위의 그림의 경우에는 인코더의 은닉 상태와 디코더의 은닉 상태가 동일하게 차원이 4입니다. 어텐션 메커니즘의 첫걸음인 어텐션 스코어(Attention score)에 대해서 배우기 전에, 이전 챕터 배웠던 디코더의 현재 시점 t에서 필요한 입력값을 다시 상기해 보겠습니다. 시점 t에서 출력 단어를 예측하기 위해서 디코더의 셀은 두 개의 입력값을 필요로 하는데, 바로 이전 시점인 t-1의 은닉 상태와 이전 시점 t-1에 나온 출력 단어입니다. 그런데 어텐션 메커니즘에서는 출력 단어 예측에 또 다른 값을 필요로 하는데 바로 어텐션 값(Attention Value)이라는 새로운 값입니다. t 번째 단어를 예측하기 위한 어텐션 값을 t 이라고 정의하겠습니다. 어텐션 값이라는 새로운 개념이 등장한 만큼, 어텐션 값이 현재 시점 t에서의 출력 예측에 구체적으로 어떻게 반영되는지는 뒤에서 설명하겠습니다. 지금부터 배우는 모든 과정은 t 를 구하기 위한 여정입니다. 그리고 그 여정의 첫걸음은 바로 어텐션 스코어(Attention Score)를 구하는 일입니다. 어텐션 스코어란 현재 디코더의 시점 t에서 단어를 예측하기 위해, 인코더의 모든 은닉 상태 각각이 디코더의 현시점의 은닉 상태 t 와 얼마나 유사한지를 판단하는 스코어 값입니다. 닷-프로덕트 어텐션에서는 이 스코어 값을 구하기 위해 t 를 전치(transpose) 하고 각 은닉 상태와 내적(dot product)을 수행합니다. 즉, 모든 어텐션 스코어 값은 스칼라입니다. 예를 들어 t 과 인코더의 i 번째 은닉 상태의 어텐션 스코어의 계산 방법은 아래와 같습니다. 어텐션 스코어 함수를 정의해 보면 다음과 같습니다. c r ( t h) s T i t 와 인코더의 모든 은닉 상태의 어텐션 스코어의 모음 값을 t 라고 정의하겠습니다. t 의 수식은 다음과 같습니다. t [ t h, . , t h ] 2) 소프트맥스(softmax) 함수를 통해 어텐션 분포(Attention Distribution)를 구한다. t 에 소프트맥스 함수를 적용하여, 모든 값을 합하면 1이 되는 확률 분포를 얻어냅니다. 이를 어텐션 분포(Attention Distribution)라고 하며, 각각의 값은 어텐션 가중치(Attention Weight)라고 합니다. 예를 들어 소프트맥스 함수를 적용하여 얻은 출력값인 I, am, a, student의 어텐션 가중치를 각각 0.1, 0.4, 0.1, 0.4라고 합시다. 이들의 합은 1입니다. 위의 그림은 각 인코더의 은닉 상태에서의 어텐션 가중치의 크기를 직사각형의 크기를 통해 시각화하였습니다. 즉, 어텐션 가중치가 클수록 직사각형이 큽니다. 디코더의 시점 t에서의 어텐션 가중치의 모음 값인 어텐션 분포를 t 이라고 할 때, t 을 식으로 정의하면 다음과 같습니다. t s f m x ( t ) 3) 각 인코더의 어텐션 가중치와 은닉 상태를 가중 합하여 어텐션 값(Attention Value)을 구한다. 이제 지금까지 준비해온 정보들을 하나로 합치는 단계입니다. 어텐션의 최종 결괏값을 얻기 위해서 각 인코더의 은닉 상태와 어텐션 가중치 값들을 곱하고, 최종적으로 모두 더합니다. 요약하면 가중합(Weighted Sum)을 진행합니다. 아래는 어텐션의 최종 결과. 즉, 어텐션 함수의 출력값인 어텐션 값(Attention Value) t 에 대한 식을 보여줍니다. t ∑ = N i h 이러한 어텐션 값 t 은 종종 인코더의 문맥을 포함하고 있다고 하여, 컨텍스트 벡터(context vector)라고도 불립니다. 앞서 배운 가장 기본적인 seq2seq에서는 인코더의 마지막 은닉 상태를 컨텍스트 벡터라고 부르는 것과 대조됩니다. 4) 어텐션 값과 디코더의 t 시점의 은닉 상태를 연결한다.(Concatenate) 어텐션 함수의 최종 값인 어텐션 값 t 을 구했습니다. 사실 어텐션 값이 구해지면 어텐션 메커니즘은 t s 와 결합(concatenate) 하여 하나의 벡터로 만드는 작업을 수행합니다. 이를 t 라고 정의해 보겠습니다. 그리고 이 t y 예측 연산의 입력으로 사용함으로써 인코더로부터 얻은 정보를 활용하여 ^ 를 좀 더 잘 예측할 수 있게 됩니다. 이것이 어텐션 메커니즘의 핵심입니다. 5) 출력층 연산의 입력이 되는 ~를 계산합니다. 논문에서는 t 를 바로 출력층으로 보내기 전에 신경망 연산을 한 번 더 추가하였습니다. 가중치 행렬과 곱한 후에 하이퍼볼릭탄젠트 함수를 지나도록 하여 출력층 연산을 위한 새로운 벡터인 ~를 얻습니다. 어텐션 메커니즘을 사용하지 않는 seq2seq에서는 출력층의 입력이 t 시점의 은닉 상태인 t 였던 반면, 어텐션 메커니즘에서는 출력층의 입력이 ~ 가 되는 셈입니다. 식으로 표현하면 다음과 같습니다. c 는 학습 가능한 가중치 행렬, c 는 편향입니다. 그림에서 편향은 생략했습니다. ~ = tanh ( c [ t s ] b) 6) ~를 출력층의 입력으로 사용합니다. ~를 출력층의 입력으로 사용하여 예측 벡터를 얻습니다. ^ = Softmax ( y ~ + y ) 4. 다양한 종류의 어텐션(Attention) 앞서 seq2seq + 어텐션(attention) 모델에 쓰일 수 있는 다양한 어텐션 종류가 있지만, 닷-프로덕트 어텐션과 다른 어텐션들의 차이는 중간 수식의 차이라고 언급한 바 있습니다. 여기서 말하는 중간 수식은 어텐션 스코어 함수를 말합니다. 위에서 배운 어텐션이 닷-프로덕트 어텐션인 이유는 어텐션 스코어를 구하는 방법이 내적이었기 때문입니다. 어텐션 스코어를 구하는 방법은 여러 가지가 제시되어 있으며, 현재 제시된 여러 종류의 어텐션 스코어 함수는 다음과 같습니다. 이름 스코어 함수 Defined by o s o e ( t h) s T i Luong et al. (2015) c l d o s o e ( t h) s T i Vaswani et al. (2017) e e a s o e ( t h) s T a i // 단, a 는 학습 가능한 가중치 행렬 Luong et al. (2015) o c t c r ( t h) W T t n ( b [ t h ] ) s o e ( t h) W T t n ( b t W h) Bahdanau et al. (2015) o a i n b s α = o t a ( a t ) // t 산출 시에 t 만 사용하는 방법. Luong et al. (2015) 위에서 t 는 Query, i 는 Keys, a W는 학습 가능한 가중치 행렬입니다. 이름이 dot이라고 붙여진 스코어 함수가 이번에 배운 닷 프로덕트 어텐션입니다. 이 어텐션은 제안한 사람의 이름을 따서 루 옹(Luong) 어텐션이라고도 합니다. 제안한 이들의 이름은 위 테이블에서 Defined By에 적혀져 있습니다. concat이라는 이름의 어텐션은 만든 사람의 이름을 따서 바다나 우(Bahdanau) 어텐션이라고도 부르며 뒤에서 설명합니다. 지금까지 seq2seq에서 성능을 향상시켜주기 위한 기법인 어텐션에 대해서 알아봤습니다. 어텐션은 처음에는 RNN 기반의 seq2seq의 성능을 보정하기 위한 목적으로 소개되었지만, 현재에 이르러서는 어텐션 스스로가 기존의 seq2seq를 대체하는 방법이 되어가고 있습니다. 이에 대해서는 다음 챕터인 트랜스포머(Transformer) 챕터에서 더 자세히 배워보겠습니다. 17-02 바다나 우 어텐션(Bahdanau Attention) 앞서 어텐션 메커니즘의 목적과 어텐션 메커니즘의 일종인 닷 프로덕트 어텐션(루 옹 어텐션)의 전체적인 개요를 살펴보고, 마지막에 표를 통해 그 외에도 다양한 어텐션 메커니즘이 존재한다고 소개하였습니다. 이번에는 닷 프로덕트 어텐션보다는 조금 더 복잡하게 설계된 바다나 우 어텐션 메커니즘을 이해해 봅시다. 1. 바다나 우 어텐션 함수(Bahdanau Attention Function) 어텐션 메커니즘을 함수 Attention()으로 정의하였을 때, 바다나 우 어텐션 함수의 입, 출력은 다음과 같의 정의할 수 있습니다. Attention(Q, K, V) = Attention Value t = 어텐션 메커니즘이 수행되는 디코더 셀의 현재 시점을 의미. Q = Query : t-1 시점의 디코더 셀에서의 은닉 상태 K = Keys : 모든 시점의 인코더 셀의 은닉 상태들 V = Values : 모든 시점의 인코더 셀의 은닉 상태들 여기서는 어텐션 함수의 Query가 디코더 셀의 t 시점의 은닉 상태가 아니라 t-1 시점의 은닉 상태임을 주목합시다. 2. 바다나 우 어텐션(Bahdanau Attention) 바다나 우 어텐션의 연산 순서를 이해해 봅시다. 1) 어텐션 스코어(Attention Score)를 구한다. 인코더의 시점(time step)을 각각 1, 2, ... N이라고 하였을 때 인코더의 은닉 상태(hidden state)를 각각 1 h, ... N 라고 합시다. 디코더의 현재 시점(time step) t에서의 디코더의 은닉 상태(hidden state)를 t 라고 합시다. 또한 여기서는 인코더의 은닉 상태와 디코더의 은닉 상태의 차원이 같다고 가정합니다. 위의 그림의 경우에는 인코더의 은닉 상태와 디코더의 은닉 상태가 동일하게 차원이 4입니다. 앞서 루 옹 어텐션에서는 Query로 디코더의 t 시점의 은닉 상태를 사용한 것과는 달리 이번에는 t-1 시점의 은닉 상태 t 1 를 사용합니다. 바다나 우 어텐션의 어텐션 스코어 함수. 즉, t 1 과 인코더의 i 번째 은닉 상태의 어텐션 스코어 계산 방법은 아래와 같습니다. c r ( t 1 h) W T t n ( b t 1 W h) 단, a W, c 는 학습 가능한 가중치 행렬입니다. t 1 h, 2 h, 4 의 어텐션 스코어를 각각 구해야 하므로 병렬 연산을 위해 1 h, 3 h를 하나의 행렬로 두겠습니다. 수식은 다음과 같이 변경됩니다. c r ( t 1 H ) W T t n ( b t 1 W H ) 그림을 통해 이해해 봅시다. 우선 b t 1 W H 를 각각 구하면 다음과 같습니다. 이들을 더한 후, 하이퍼볼릭탄젠트 함수를 지나도록 합니다. 지금까지 진행된 연산의 수식은 다음과 같습니다. a h ( b t 1 W H ) 이제 a 와 곱하여 t 1 h, 2 h, 4 의 유사도가 기록된 어텐션 스코어 벡터 t 를 얻습니다. t W T t n ( b t 1 W H ) 2) 소프트맥스(softmax) 함수를 통해 어텐션 분포(Attention Distribution)를 구한다. t 에 소프트맥스 함수를 적용하여, 모든 값을 합하면 1이 되는 확률 분포를 얻어냅니다. 이를 어텐션 분포(Attention Distribution)라고 하며, 각각의 값은 어텐션 가중치(Attention Weight)라고 합니다. 3) 각 인코더의 어텐션 가중치와 은닉 상태를 가중 합하여 어텐션 값(Attention Value)을 구한다. 지금까지 준비해온 정보들을 하나로 합치는 단계입니다. 어텐션의 최종 결괏값을 얻기 위해서 각 인코더의 은닉 상태와 어텐션 가중치 값들을 곱하고, 최종적으로 모두 더합니다. 요약하면 가중합(Weighted Sum)을 한다고 말할 수도 있겠습니다. 이 벡터는 인코더의 문맥을 포함하고 있다고 하여, 컨텍스트 벡터(context vector)라고 부릅니다. 4) 컨텍스트 벡터로부터 t 를 구합니다. 기존의 LSTM이 t 를 구할 때를 아래 그림을 통해 상기해 봅시다. 기존의 LSTM은 이전 시점의 셀로부터 전달받은 은닉 상태 t 1 와 현재 시점의 입력 t 를 가지고 연산하였습니다. 아래의 LSTM은 seq2seq의 디코더이며 현재 시점의 입력 t 는 임베딩된 단어 벡터입니다. 그렇다면 어텐션 메커니즘에서는 어떨까요? 아래의 그림은 바다나 우 어텐션 메커니즘에서는 컨텍스트 벡터와 현재 시점의 입력인 단어의 임베딩 벡터를 연결(concatenate) 하고, 현재 시점의 새로운 입력으로 사용하는 모습을 보여줍니다. 그리고 이전 시점의 셀로부터 전달받은 은닉 상태 t 1 와 현재 시점의 새로운 입력으로부터 t 를 구합니다. 기존의 LSTM이 임베딩된 단어 벡터를 입력으로 하는 것에서 컨텍스트 벡터와 임베딩된 단어 벡터를 연결(concatenate) 하여 입력으로 사용하는 것이 달라졌습니다. 이후에는 어텐션 메커니즘을 사용하지 않는 경우와 동일합니다. t 는 출력층으로 전달되어 현재 시점의 예측값을 구하게 됩니다. 17-03 어텐션 메커니즘을 이용한 번역기 구현 이번에는 15-02 실습에서 만든 Seq2Seq를 이용한 번역기에 어텐션 메커니즘을 추가하여 번역기를 만들어보겠습니다. 1. 데이터 로드 및 전처리 이 과정은 15-02에서 진행한 1. 데이터 로드 및 전처리 코드와 모든 과정이 동일합니다. 2. 기계 번역기 만들기 15-02와 달라진 것은 모델 클래스 코드와 decode_sequence 함수의 코드가 다릅니다. 임베딩 벡터의 차원은 256, 은닉 상태의 차원 또한 256으로 지정합니다. import torch import torch.nn as nn import torch.optim as optim embedding_dim = 256 hidden_units = 256 인코더 클래스를 보면 구조 자체는 15-02에서 구현한 Seq2Seq와 동일합니다. 임베딩 층(Embedding layer)과 LSMT 층으로 구성되며 입력 문장은 임베딩 층을 통해 각 단어가 임베딩되고, 인코더의 LSTM을 통과합니다. class Encoder(nn.Module): def __init__(self, src_vocab_size, embedding_dim, hidden_units): super(Encoder, self).__init__() self.embedding = nn.Embedding(src_vocab_size, embedding_dim, padding_idx=0) self.lstm = nn.LSTM(embedding_dim, hidden_units, batch_first=True) def forward(self, x): # x.shape == (batch_size, seq_len, embedding_dim) x = self.embedding(x) # hidden.shape == (1, batch_size, hidden_units), cell.shape == (1, batch_size, hidden_units) outputs, (hidden, cell) = self.lstm(x) return outputs, hidden, cell 디코더 클래스를 보면 15-02와는 완전히 달라졌습니다. 이는 어텐션 메커니즘 자체가 디코더 단에서 시작되기 때문인데, 컨텍스트 벡터를 얻기 위한 연산 과정 자체는 15-01에서 설명한 순서대로 진행됩니다. 우선 디코더의 은닉 상태와 인코더의 모든 시점의 은닉 상태 간의 내적(dot product)를 통해서 어텐션 스코어(attention_scores)를 구합니다. 그 후 어텐션 스코어를 소프트맥스(softmax) 함수를 통과시켜 어텐션 가중치(attention_weights)를 얻습니다. 어텐션 가중치는 어텐션 메커니즘에서 Value에 해당하는 인코더의 모든 시점의 은닉 상태와 다시 각각 곱해지고 이를 모두 더하여 컨텍스트 벡터(context_vector)를 얻습니다. 이 컨텍스트 벡터를 사용하는 방법은 어텐션 메커니즘을 구현하기 나름인데, 아래의 코드에서는 15-02에서의 설명과 같이 임베딩 벡터(아래에서는 변수 x)와 연결되어 입력으로 사용합니다. class Decoder(nn.Module): def __init__(self, tar_vocab_size, embedding_dim, hidden_units): super(Decoder, self).__init__() self.embedding = nn.Embedding(tar_vocab_size, embedding_dim, padding_idx=0) self.lstm = nn.LSTM(embedding_dim + hidden_units, hidden_units, batch_first=True) self.fc = nn.Linear(hidden_units, tar_vocab_size) self.softmax = nn.Softmax(dim=2) def forward(self, x, encoder_outputs, hidden, cell): x = self.embedding(x) # Dot product attention # attention_scores.shape: (batch_size, source_seq_len, 1) attention_scores = torch.bmm(encoder_outputs, hidden.transpose(0, 1).transpose(1, 2)) # attention_weights.shape: (batch_size, source_seq_len, 1) attention_weights = self.softmax(attention_scores) # context_vector.shape: (batch_size, 1, hidden_units) context_vector = torch.bmm(attention_weights.transpose(1, 2), encoder_outputs) # Repeat context_vector to match seq_len # context_vector_repeated.shape: (batch_size, target_seq_len, hidden_units) seq_len = x.shape[1] context_vector_repeated = context_vector.repeat(1, seq_len, 1) # Concatenate context vector and embedded input # x.shape: (batch_size, target_seq_len, embedding_dim + hidden_units) x = torch.cat((x, context_vector_repeated), dim=2) # output.shape: (batch_size, target_seq_len, hidden_units) # hidden.shape: (1, batch_size, hidden_units) # cell.shape: (1, batch_size, hidden_units) output, (hidden, cell) = self.lstm(x, (hidden, cell)) # output.shape: (batch_size, target_seq_len, tar_vocab_size) output = self.fc(output) return output, hidden, cell 아래의 Seq2Seq 클래스는 구조 자체는 15-02에서 구현한 Seq2Seq와 동일합니다. 인코더와 디코더를 연결하여 Seq2Seq 모델을 완성합니다. 결국 어텐션 메커니즘 자체가 정의되는 것은 디코더 클래스 내부의 코드입니다. class Seq2Seq(nn.Module): def __init__(self, encoder, decoder): super(Seq2Seq, self).__init__() self.encoder = encoder self.decoder = decoder def forward(self, src, trg): encoder_outputs, hidden, cell = self.encoder(src) output, _, _ = self.decoder(trg, encoder_outputs, hidden, cell) return output encoder = Encoder(src_vocab_size, embedding_dim, hidden_units) decoder = Decoder(tar_vocab_size, embedding_dim, hidden_units) model = Seq2Seq(encoder, decoder) loss_function = nn.CrossEntropyLoss(ignore_index=0) optimizer = optim.Adam(model.parameters()) 디코더는 인코더의 마지막 은닉 상태로부터 초기 은닉 상태를 얻습니다. 디코더도 은닉 상태, 셀 상태를 리턴하기는 하지만 훈련 과정에서는 사용하지 않습니다. seq2seq의 디코더는 기본적으로 각 시점마다 다중 클래스 분류 문제를 풀고 있습니다. 매 시점마다 프랑스어 단어 집합의 크기(tar_vocab_size)의 선택지에서 단어를 1개 선택하여 이를 이번 시점에서 예측한 단어로 택합니다. 다중 클래스 분류 문제이므로 손실 함수를 크로스 엔트로피 함수를 사용합니다. 평가 함수를 작성합니다. 해당 함수는 15-02에서 사용한 evaluation()와 동일합니다. def evaluation(model, dataloader, loss_function, device): model.eval() total_loss = 0.0 total_correct = 0 total_count = 0 with torch.no_grad(): for encoder_inputs, decoder_inputs, decoder_targets in dataloader: encoder_inputs = encoder_inputs.to(device) decoder_inputs = decoder_inputs.to(device) decoder_targets = decoder_targets.to(device) # 순방향 전파 # outputs.shape == (batch_size, seq_len, tar_vocab_size) outputs = model(encoder_inputs, decoder_inputs) # 손실 계산 # outputs.view(-1, outputs.size(-1))의 shape는 (batch_size * seq_len, tar_vocab_size) # decoder_targets.view(-1)의 shape는 (batch_size * seq_len) loss = loss_function(outputs.view(-1, outputs.size(-1)), decoder_targets.view(-1)) total_loss += loss.item() # 정확도 계산 (패딩 토큰 제외) mask = decoder_targets != 0 total_correct += ((outputs.argmax(dim=-1) == decoder_targets) * mask).sum().item() total_count += mask.sum().item() return total_loss / len(dataloader), total_correct / total_count 각각의 데이터를 파이 토치 텐서로 변환하고 배치 크기 128로 데이터 로더로 변환합니다. 그 후 학습 에포크를 30으로 설정합니다. 아래의 코드 역시 15-02와 동일합니다. encoder_input_train_tensor = torch.tensor(encoder_input_train, dtype=torch.long) decoder_input_train_tensor = torch.tensor(decoder_input_train, dtype=torch.long) decoder_target_train_tensor = torch.tensor(decoder_target_train, dtype=torch.long) encoder_input_test_tensor = torch.tensor(encoder_input_test, dtype=torch.long) decoder_input_test_tensor = torch.tensor(decoder_input_test, dtype=torch.long) decoder_target_test_tensor = torch.tensor(decoder_target_test, dtype=torch.long) # 데이터 셋 및 데이터 로더 생성 batch_size = 128 train_dataset = TensorDataset(encoder_input_train_tensor, decoder_input_train_tensor, decoder_target_train_tensor) train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True) valid_dataset = TensorDataset(encoder_input_test_tensor, decoder_input_test_tensor, decoder_target_test_tensor) valid_dataloader = DataLoader(valid_dataset, batch_size=batch_size, shuffle=False) # 학습 설정 num_epochs = 30 device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model.to(device) 모델을 훈련합니다. 128개의 배치 크기(128개씩 데이터를 병렬로 학습)로 총 50 에포크 학습합니다. 검증 데이터로 훈련이 제대로 되고 있는지 모니터링하겠습니다. 아래의 코드 또한 15-02와 동일합니다. # Training loop best_val_loss = float('inf') for epoch in range(num_epochs): # 훈련 모드 model.train() for encoder_inputs, decoder_inputs, decoder_targets in train_dataloader: encoder_inputs = encoder_inputs.to(device) decoder_inputs = decoder_inputs.to(device) decoder_targets = decoder_targets.to(device) # 기울기 초기화 optimizer.zero_grad() # 순방향 전파 # outputs.shape == (batch_size, seq_len, tar_vocab_size) outputs = model(encoder_inputs, decoder_inputs) # 손실 계산 및 역방향 전파 # outputs.view(-1, outputs.size(-1))의 shape는 (batch_size * seq_len, tar_vocab_size) # decoder_targets.view(-1)의 shape는 (batch_size * seq_len) loss = loss_function(outputs.view(-1, outputs.size(-1)), decoder_targets.view(-1)) loss.backward() # 가중치 업데이트 optimizer.step() train_loss, train_acc = evaluation(model, train_dataloader, loss_function, device) valid_loss, valid_acc = evaluation(model, valid_dataloader, loss_function, device) print(f'Epoch: {epoch+1}/{num_epochs} | Train Loss: {train_loss:.4f} | Train Acc: {train_acc:.4f} | Valid Loss: {valid_loss:.4f} | Valid Acc: {valid_acc:.4f}') # 검증 손실이 최소일 때 체크포인트 저장 if valid_loss < best_val_loss: print(f'Validation loss improved from {best_val_loss:.4f} to {valid_loss:.4f}. 체크포인트를 저장합니다.') best_val_loss = valid_loss torch.save(model.state_dict(), 'best_model_checkpoint.pth') 저자의 학습 기록은 다음과 같습니다. Epoch: 1/30 | Train Loss: 2.9015 | Train Acc: 0.5423 | Valid Loss: 3.0118 | Valid Acc: 0.5413 Validation loss improved from inf to 3.0118. 체크포인트를 저장합니다. Epoch: 2/30 | Train Loss: 2.1927 | Train Acc: 0.6178 | Valid Loss: 2.4254 | Valid Acc: 0.6028 Validation loss improved from 3.0118 to 2.4254. 체크포인트를 저장합니다. Epoch: 3/30 | Train Loss: 1.7281 | Train Acc: 0.6661 | Valid Loss: 2.0946 | Valid Acc: 0.6399 Validation loss improved from 2.4254 to 2.0946. 체크포인트를 저장합니다. Epoch: 4/30 | Train Loss: 1.3687 | Train Acc: 0.7195 | Valid Loss: 1.8610 | Valid Acc: 0.6683 Validation loss improved from 2.0946 to 1.8610. 체크포인트를 저장합니다. Epoch: 5/30 | Train Loss: 1.0871 | Train Acc: 0.7652 | Valid Loss: 1.6995 | Valid Acc: 0.6886 Validation loss improved from 1.8610 to 1.6995. 체크포인트를 저장합니다. Epoch: 6/30 | Train Loss: 0.8613 | Train Acc: 0.8050 | Valid Loss: 1.5855 | Valid Acc: 0.7022 Validation loss improved from 1.6995 to 1.5855. 체크포인트를 저장합니다. Epoch: 7/30 | Train Loss: 0.6870 | Train Acc: 0.8404 | Valid Loss: 1.5009 | Valid Acc: 0.7157 Validation loss improved from 1.5855 to 1.5009. 체크포인트를 저장합니다. Epoch: 8/30 | Train Loss: 0.5525 | Train Acc: 0.8674 | Valid Loss: 1.4467 | Valid Acc: 0.7218 Validation loss improved from 1.5009 to 1.4467. 체크포인트를 저장합니다. Epoch: 9/30 | Train Loss: 0.4515 | Train Acc: 0.8874 | Valid Loss: 1.4147 | Valid Acc: 0.7243 Validation loss improved from 1.4467 to 1.4147. 체크포인트를 저장합니다. Epoch: 10/30 | Train Loss: 0.3790 | Train Acc: 0.8997 | Valid Loss: 1.3990 | Valid Acc: 0.7287 Validation loss improved from 1.4147 to 1.3990. 체크포인트를 저장합니다. Epoch: 11/30 | Train Loss: 0.3285 | Train Acc: 0.9086 | Valid Loss: 1.3973 | Valid Acc: 0.7334 Validation loss improved from 1.3990 to 1.3973. 체크포인트를 저장합니다. 이는 15-02에서 확인한 기록과 비교하면 검증 데이터의 손실이 좀 더 작으며 검증 데이터의 정확도는 더 큰 것을 알 수 있습니다. 검증 데이터 손실이 가장 최소일 때의 모델을 로드하고 다시 재평가해 봅시다. # 모델 로드 model.load_state_dict(torch.load('best_model_checkpoint.pth')) # 모델을 device에 올립니다. model.to(device) # 검증 데이터에 대한 정확도와 손실 계산 val_loss, val_accuracy = evaluation(model, valid_dataloader, loss_function, device) print(f'Best model validation loss: {val_loss:.4f}') print(f'Best model validation accuracy: {val_accuracy:.4f}') Best model validation loss: 1.3973 Best model validation accuracy: 0.7334 로드 후 재평가를 진행하였더니, 저장할 당시와 검증 데이터의 손실과 정확도가 동일하므로 저장 및 로드가 원활히 되었습니다. <sos>와 <eos> 토큰의 정수는 각각 3과 4입니다. print(tar_vocab['<sos>']) print(tar_vocab['<eos>']) 4 3. seq2seq 기계 번역기 동작시키기 seq2seq는 훈련 과정(교사 강요)과 테스트 과정에서의 동작 방식이 다릅니다. 그래서 테스트 과정을 위해 모델을 다시 설계해 주어야 합니다. 특히 디코더를 수정해야 합니다. 이번에는 번역 단계를 위해 모델을 수정하고 동작시켜보겠습니다. 전체적인 번역 단계를 정리하면 아래와 같습니다. 1) 번역하고자 하는 입력 문장이 인코더로 입력되어 인코더의 마지막 시점의 은닉 상태와 셀 상태를 얻습니다. 2) 인코더의 은닉 상태와 셀 상태, 그리고 토큰 <sos>를 디코더로 보냅니다. 3) 디코더가 토큰 <eos>가 나올 때까지 다음 단어를 예측하는 행동을 반복합니다. 결과 확인을 위한 함수를 만듭니다. seq_to_src 함수는 영어 문장에 해당하는 정수 시퀀스를 입력받으면 정수로부터 영어 단어를 리턴하는 index_to_src를 통해 영어 문장으로 변환합니다. seq_to_tar은 프랑스어에 해당하는 정수 시퀀스를 입력받으면 정수로부터 프랑스어 단어를 리턴하는 index_to_tar을 통해 프랑스어 문장으로 변환합니다. index_to_src = {v: k for k, v in src_vocab.items()} index_to_tar = {v: k for k, v in tar_vocab.items()} # 원문의 정수 시퀀스를 텍스트 시퀀스로 변환 def seq_to_src(input_seq): sentence = '' for encoded_word in input_seq: if(encoded_word != 0): sentence = sentence + index_to_src[encoded_word] + ' ' return sentence # 번역문의 정수 시퀀스를 텍스트 시퀀스로 변환 def seq_to_tar(input_seq): sentence = '' for encoded_word in input_seq: if(encoded_word != 0 and encoded_word != tar_vocab['<sos>'] and encoded_word != tar_vocab['<eos>']): sentence = sentence + index_to_tar[encoded_word] + ' ' return sentence 25번 샘플의 정수 인코딩이 진행된 인코더 입력, 디코더 입력, 그리고 디코더의 레이블을 출력해 봅시다. print(encoder_input_test[25]) print(decoder_input_test[25]) print(decoder_target_test[25]) array([ 3, 267, 1748, 2, 0, 0, 0]) array([ 3, 12, 15, 188, 53, 1889, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0]) array([ 12, 15, 188, 53, 1889, 2, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0]) decode_sequence() 함수를 봅시다. 테스트 단계에서는 디코더를 매 시점 별로 컨트롤하게 됩니다. 각 시점을 for 문을 통해서 컨트롤하게 되며, 현재 시점의 예측은 다음 시점의 입력으로 사용됩니다. 여기서 사용될 변수는 decoder_input입니다. def decode_sequence(input_seq, model, src_vocab_size, tar_vocab_size, max_output_len, int_to_src_token, int_to_tar_token): encoder_inputs = torch.tensor(input_seq, dtype=torch.long).unsqueeze(0).to(device) # 인코더의 초기 상태 설정 encoder_outputs, hidden, cell = model.encoder(encoder_inputs) # 시작 토큰 <sos>을 디코더의 첫 입력으로 설정 # unsqueeze(0)는 배치 차원을 추가하기 위함. decoder_input = torch.tensor([3], dtype=torch.long).unsqueeze(0).to(device) decoded_tokens = [] # for 문을 도는 것 == 디코더의 각 시점 for _ in range(max_output_len): output, hidden, cell = model.decoder(decoder_input, encoder_outputs, hidden, cell) # 소프트맥스 회귀를 수행. 예측 단어의 인덱스 output_token = output.argmax(dim=-1).item() # 종료 토큰 <eos> if output_token == 4: break # 각 시점의 단어(정수)는 decoded_tokens에 누적하였다가 최종 번역 시퀀스로 리턴합니다. decoded_tokens.append(output_token) # 현재 시점의 예측. 다음 시점의 입력으로 사용된다. decoder_input = torch.tensor([output_token], dtype=torch.long).unsqueeze(0).to(device) return ' '.join(int_to_tar_token[token] for token in decoded_tokens) 훈련 데이터에 대해서 임의로 선택한 인덱스의 샘플의 결과를 출력해 봅시다. for seq_index in [3, 50, 100, 300, 1001]: input_seq = encoder_input_train[seq_index] translated_text = decode_sequence(input_seq, model, src_vocab_size, tar_vocab_size, 20, index_to_src, index_to_tar) print("입력 문장 :",seq_to_src(encoder_input_train[seq_index])) print("정답 문장 :",seq_to_tar(decoder_input_train[seq_index])) print("번역 문장 :",translated_text) print("-"*50) 입력 문장 : let s keep it . 정답 문장 : gardons cela comme ca . 번역 문장 : gardons le . -------------------------------------------------- 입력 문장 : how was the trip ? 정답 문장 : comment fut votre voyage ? 번역 문장 : comment etait le voyage ? -------------------------------------------------- 입력 문장 : is it dangerous ? 정답 문장 : est ce dangereux ? 번역 문장 : est ce dangereux ? -------------------------------------------------- 입력 문장 : am i seeing things ? 정답 문장 : ai je des visions ? 번역 문장 : ai je des visions ? -------------------------------------------------- 입력 문장 : this is a bomb . 정답 문장 : c est une bombe . 번역 문장 : c est une bombe . -------------------------------------------------- 테스트 데이터에 대해서 임의로 선택한 인덱스의 샘플의 결과를 출력해 봅시다. for seq_index in [3, 50, 100, 300, 1001]: input_seq = encoder_input_test[seq_index] translated_text = decode_sequence(input_seq, model, src_vocab_size, tar_vocab_size, 20, index_to_src, index_to_tar) print("입력 문장 :",seq_to_src(encoder_input_test[seq_index])) print("정답 문장 :",seq_to_tar(decoder_input_test[seq_index])) print("번역 문장 :",translated_text) print("-"*50) 입력 문장 : that s no good . 정답 문장 : ce n est pas bon . 번역 문장 : ce n est pas bon . -------------------------------------------------- 입력 문장 : i want you back . 정답 문장 : je veux que vous soyez revenue . 번역 문장 : je veux que vous soyez revenues . -------------------------------------------------- 입력 문장 : nobody was home . 정답 문장 : personne n etait chez moi . 번역 문장 : personne n etait chez nous . -------------------------------------------------- 입력 문장 : it s raining here . 정답 문장 : il pleut ici . 번역 문장 : il pleut ici . -------------------------------------------------- 입력 문장 : look out ! 정답 문장 : soyez prudente ! 번역 문장 : attention ! --------------------------------------------------<|endoftext|>

전문분야 텍스트 ### 제목: Machine Learning 강의노트 ### 본문: Andrew Ng 교수님 Coursera 강의 내용 정리 노트입니다. 본래 개인적으로 정리하는 것이 목적 어서 강의 내용을 모두 포함하지는 않으며, 강의에 없는 내용이라도 필요한 설명은 보충하고 있습니다. 영어강의가 익숙하지 않으신 분들께서 국문 보조교재로 참고하실 수 있을 것 같아서 공개하였습니다. Tensorflow로 딥러닝 시스템 구현을 원하시는 분은 Sung Kim 교수님 "모두를 위한 딥러닝" 강의를 참고하셔도 좋습니다. 이 강의를 본 노트에 추가하는 계획은 중단되었습니다. 대신, PyTorch로 구현하는 방법을 업데이트하고 있습니다. (2020년 3월 현재) 내용 상 오류/피드백 또는 질문은 댓글로 부탁드립니다. #머신러닝 #기계학습 #machinelearning #machine_learning #Python #TensorFlow 01. Introduction What is Machine Learning? Examples Formal Definition Example: Playing Checkers Supervised Learning Regression Classification Unsupervised Learning Clustering Non-clustering Further Reading What is Machine Learning? 전통적으로 programming이라고 하면, "A 조건에서는 B 명령을 수행하고, C 조건에서는 D 명령을 수행하라"라고 사람이 구체적으로 규칙을 정해주는 과정이었다. 그러나 이러한 explicit programming에는 한계가 있다. 예를 들어 스팸 메일을 거르는 필터를 만든다고 하자. 제목에 "광고"라는 문구가 버젓이 걸려있는 경우는 많지 않다. 스팸 필터에 걸리지 않으려고 의도적으로 오타를 내거나 특수문자를 이용하기도 한다. 이런 경우들을 일일이 걸러내자면 너무 많은 규칙을 정해야 한다. 또한, 자율주행 차량을 개발하는 경우를 생각해 보자. 운전 중에는 수많은 돌발 상황이 발생하므로 예상할 수 없을 정도로 많은 변칙에 대비하여야 한다. 이와 같이 기존의 explicit programming으로 해결할 수 없는 문제들을 해결하기 위해 machine learning, 즉 기계가 스스로 어떤 패턴을 '학습'하도록 하는 접근법이 등장하였다. 최근 각광받고 있긴 하지만 machine learning 자체는 굉장히 오래된 개념이다. Arthur Samuel은 1959년에 machine learning을 다음과 같이 정의하였다. Field of study that gives computers the ability to learn without being explicitly programmed. 요컨대 머신러닝이란, 프로그래머가 직접 수많은 규칙을 미리 정해주는 대신 프로그램 자체가 데이터를 통해 스스로 학습하도록 하는 방법이다. AI 연구가 진행됨에 따라 machine learning 기법도 비약적으로 발전하였고, 이제는 전자제품의 주요한 기능으로 새롭게 받아들여지고 있다. Examples Database mining: large datasets from growth of automation/web Applications can't program by hand Self-customizing programs Understanding human learning (brain, real AI) Formal Definition Arthur Samuel의 정의는 다소 오래되었고, 추상적인 측면이 있어 Tom Mitchell이 좀 더 구체적으로 정의하였다. A computer program is said to learn from experience E with respect to some class of tasks T and performance measure P, if its performance at tasks in T, as measured by P, improves with experience E. Example: Playing Checkers E = the experience of playing many games of checkers T = the task of playing checkers. P = the probability that the program will win the next game. 일반적으로, machine learning 문제는 두 가지 범주로 구분된다: supervised learning과 unsupervised learning이 그것이다. Supervised Learning Supervised learning 이란, 특정 input에 대해 "정답 (label)" output이 있는 데이터 셋이 주어지는 경우를 말한다. 프로그램은 이 정보로부터 input과 output의 관계를 유추하게 된다. 대다수의 machine learning 문제는 이 형태를 띤다. Supervised learning의 세부 분류로는 "regression"과 "classification"이 있다. Regression Regression의 output은 continuous 값을 갖는다. 즉, 주어진 input 변수를 ouput 변수에 대응시키는 어떤 연속함수를 찾는 과정이 바로 regression이다. 집의 넓이에 해당하는 적절한 집값을 추정하는 문제가 그 한 예이다. 이때 input은 집의 넓이이며, output은 집값이다. 사전에 집의 넓이와 그 집의 가격을 조사해서 그 정보를 사용하므로 supervised learning이고 output에 해당하는 집값은 continuous 값을 가지므로 이는 regression 문제이다. 자세한 내용은 linear regression section에서 다루도록 하겠다. Classification 반면, classification 문제의 output은 discrete 값을 갖는다. 즉, classification의 목적은 주어진 input 변수가 어느 discrete category에 속하는지 찾아내는 것이다. 예를 들면, 종양이 악성인지 양성인지 진단하는 문제가 있다. 이번에도 사전에 종양의 크기와 그 종양의 진단 결과 (악성/양성) 정보를 이용하므로 supervised learning이지만, output에 해당하는 진단 결과가 악성/양성으로 discrete category이므로 classification 문제이다. 그런데 이렇게 종양 크기만으로 진단을 내리기에는 부족할 수 있다. 같은 크기의 종양이라도 나이가 많으면 더 위험할 수 있다. 따라서 종양 크기뿐만 아니라 환자의 나이 역시 input으로 활용하여 보다 복합적인 판단을 내릴 수도 있다. 이 외에도 clump thickness, uniformity of cell size, uniformity of cell shape 등 여러 가지 요소를 고려하여 악성/양성 여부를 결정하도록 할 수도 있다. Unsupervised Learning Unsupervised learning은 "정답 (label)" output을 제공하는 데이터 셋이 없는 문제이다. 따라서 prediction result에 대한 feedback이 없다. 다시 말해, 잘못된 prediction 을 하더라도 교정해 줄 "선생님"이 없다. 이 경우에는 가지고 있는 데이터의 변수들 간의 관계에 기반한 clustering으로 어떤 구조를 도출해낸다. Clustering 미국 경제에 관한 논문 1000개를 가져다가 자동으로 이 논문들을 비슷한 것끼리 묶을 수 있다. 예를 들면 word frequency, sentence length, page count 등의 정보를 이용한다. Non-clustering eg. Cocktail party problem Further Reading Quora: "What is the difference between supervised and unsupervised learning algorithms?" 02. Linear Regression Linear regression은 어떤 input에 대한 실숫값의 output을 예측하는 문제이다. 이 장에서는 "집값 추정" 예시를 통하여 cost function 개념과 gradient descent 학습법을 다룬다. 1) Univariate Linear Regression Model Representation The Hypothesis Function Cost function Intuition I Intuition II Model Representation 개똥이는 집을 사려고 한다. 그렇다면 개똥이는 살고자 하는 동네에서 자기가 살고 싶은 크기와 비슷한 집들은 얼마나 비싼지 이리저리 물어보러 다닐 것이다. 만약에 말똥이가 사는 1500제곱피트 짜리 집이 24만 불이고 소똥이가 사는 1000제곱피트 짜리 집이 20만 불이라면 개똥이가 사고자 하는 1250제곱피트 집은 그 중간인 22만 불 정도가 적당하다고 생각할 것이다. 이런 식으로 개똥이가 원하는 넓이의 집의 적정 가격을 추정하기 위해 사전에 몇 군데 집의 넓이와 그 가격 정보를 수집했다. Target set of housing price size[feet ] ( ) price [1000 ] ( ) 2104 460 1416 232 1534 315 852 178 ⋮ 이 경우, 사전에 수집한 집값 정보라는 "정답"이 존재하므로 "supervised learning"에 해당하며, 추정하고자 하는 값이 실수값이므로 regression problem이다. 여기에 집의 넓이와 가격 사이에 선형의 관계가 존재한다고 가정하면 linear regression이 되는 것이다. 수집한 집 넓이와 집값을 좌표평면에 나타내어 보았다. 수집한 데이터는 아래 그래프 상의 파란 x 점들이다. 이 점들을 가장 '잘 나타내는' 직선인 녹색 선을 구한다. 이 선을 어떻게 구하는지는 차차 알아볼 것이다. 일단 이 직선을 구하면 내가 관심 있는 1250 제곱피트 짜리 집에 해당하는 지점을 녹색 선에서 찾고, 그에 해당하는 가격을 y 축에서 찾아내어 22만 불이 적정 가격이라고 쉽게 결론 내릴 수 있다. Linear regression은 바로 주어진 데이터를 나타내는 최적의 직선을 찾아냄으로써 input (x)와 output (y) 사이의 관계를 도출해 내는 과정이다. 이 과정을 수학적으로 나타내기 위해 notation을 정리해 보자. : # training examples 's: "input" varilable, or features 's: "output" variable, or "target" variable ( , ) : one training example ( ( ) y ( ) ) i -th training example The Hypothesis Function Hypothesis 란, input (feature)과 output (target)의 관계를 나타내는 함수이다. Output 값이 나오게 하는 '진짜' 변수들과 그 변수와 output 사이의 관계식을 정의하는 '진짜' 관계식을 찾아내는 것은 불가능하다. 가령 집값을 결정하는 요인만 하더라도, 단순히 집의 평수뿐만 아니라 방이 몇 개인지, 얼마나 오래된 집인지, 역세권인지, 학군이 좋은지, 주변에 편의시설이 얼마나 있는지, 나아가 국제 유가 전망과 주식 시장 분위기, 차기 대권 주자들의 행보, 대마초 합법화 논란, 새로운 소행성 발견 등등 전혀 관련 없어 보이는 요인들이 직간접적으로 집값에 영향을 미칠 수가 있다. 우리는 이렇게 어마어마한 변수들을 모두 고려하고 그 변수들 간의 복잡한 방정식을 찾는 대신 "주로 이러이러한 변수들이 output에 영향을 미칠 거야"라고 추정하고 "이러이러한 함수로 변수들과 output의 관계를 얼추 나타내볼 수 있을 거야"라고 일종의 가설을 세우기 때문에 hypothesis라고 부르기 시작한 것으로 여겨진다. Hypothesis는 어떤 함수의 형태든 취할 수 있지만 다음과 같은 선형 (linear) 함수를 자주 사용한다. θ ( ) θ + 1 이 때의 는 실숫값을 취하는 1차원 랜덤 변수이다. 이와 같이 한 가지 feature를 이용한 linear regression을 "univariate linear regression"이라고 부르기도 한다. 이 방정식이 '직선' 형태를 띤다는 점에 주목하자. 이제부터 θ ( ) θ 과 1 값을 지정하여 output ^ 값을 구해보려고 한다. 다시 말해, 주어진 input data( )를 output data ( )에 대응시키는 함수 θ 를 만들어 보도록 한다. 예를 들어, 아래와 같은 training data가 있다고 하자. input output 0 4 1 7 2 7 3 8 우선은 아무 숫자나 넣어보자. 가령 0 2 θ = . 이때의 hypothesis function은 θ ( ) 2 2 가 된다. Input에 1을 대입하면 ^ 4 가 되며 주어진 '정답'인 =에서 3만큼 빗나간 것이 된다. 우리의 목표는 여러 가지 0 θ 을 시도하여 x-y 평면 상에서 주어진 데이터 좌표들에 가장 잘 맞는 (fit), 혹은 그 점들을 가장 잘 대표하는 직선을 찾아내는 것이다. Cost function Hypothesis θ ( ) θ + 1 h ( ) 를 간략히 ( ) 로 표기하기도 한다. 이때의 i 들은 parameter라고 한다. 우리의 선형 hypothesis에서는 parameter에 어떤 값이 들어가느냐에 따라 ( ) y 절편과 기울기가 달라진다. 그렇다면 최적의 i 를 어떻게 찾을 것인가? 예. 주어진 데이터에 가장 잘 '맞는' 직선을 선택하려면 일정한 기준이 있어야 한다. 우리의 hypothesis function의 정확도를 측정하기 위해 cost function을 이용할 것이다. ( 0 θ) 1 m i 1 ( ^ ( ) y ( ) ) = 2 ∑ = m ( θ ( ( ) ) y ( ) ) Training example들이 parameter 추정에 이용된다. 상식적으로 θ ( ) y 와 비슷해지는 0 θ 을 고르는 것이 좋을 것이다. 조금 더 수학적으로 표현하자면, error h ( ) y 가 최솟값을 갖는 것이 좋을 것이다. 그런데 이 error 값은 양수 값일 수도 있고 음수 값일 수도 있기 때문에 error 값의 합을 바로 구하는 것은 적합하지 않다. 대신, 이들의 제곱 값의 합을 구하여 그 합이 최소가 되는 parameter를 찾는 방법이 일반적이다. 이를 LSE (least squared error) criterion이라고 한다. 이 cost funciton 은 mean-squared-error (MSE)이다. 즉, ( error )의 평균이 cost 값이 된다. 여기서 error란, 추정한 값 ( ^ )과 실제 값의 차이를 말한다. 다만, 평균이라면 data 개 수인으로 나누어야 하는데 m 으로 나누었다는 점이 다르다. 이때의 2는 계산상의 편의를 위한 것으로 나중에 약분되는 것을 확인하게 될 것이다. 어차피 우리는 cost 값을 최소화하는 를 찾는 것이 목적이고, 그러한 는 cost를 어떤 양의 상수로 나누든 어차피 마찬가지이므로 보다 간단한 계산을 위해 2로 미리 나누어주는 방식이 자주 이용된다. Intuition I 우선, 직관적으로 접근하기 위해 hypothesis를 단순화해보자. 0 0 으로 설정하면 hypothesis는 원점을 지나는 직선이 된다. Training data 도 단순한 걸 사용하자. ( , ) ( , ) ( , ) 1 1 인 경우, θ ( ) x 가 된다. 이 모델은 주어진 데이터에 완벽하게 맞아떨어지므로 이때의 ( 1 ) 는 0이 된다. 이제 오른쪽의 ( ) 그래프로 이동하여 ( , ) 에 점을 찍는다. 한편, 1 0.5 인 경우, ( 1 ) 0.58 이다. 따라서 ( ) 그래프의 ( 0.5 0.58 ) 에 점을 찍는다. 이와 같이 여러 1 값에 대하여 ( 1 ) 을 구해 그래프를 그려나가다 보면 포물선 형태가 되며, 이 포물선이 최솟값(0)을 갖도록 하는 parameter ( 1 1 ) 이 최적의 값이다. Intuition II 이제 다시 0 항이 존재하는 univariate linear regression 일반형을 생각해 보자. 이때에도 비슷한 방법으로 ( ) 그래프를 완성할 수 있다. 다만, 이번에는 변수가 2개이므로 0 θ에 따라 크기가 변하는 3차원 그래프가 될 것이다. 이때의 크기를 색상으로 표현하여 2차원 평면에 나타내면 오른쪽 그림과 같은 등고선 모양이 된다. 우리는 이 cost function ( ) 가 최솟값을 갖도록 하는 parameter를 구하고 싶다. 이를 자동으로 구하는 방법은 다음 장에서 다룬다. a. Pytorch Example Data generation Linear Regression with Numpy Converting to Tensor Tensor Loading Data, Devices, and CUDA Creating Parameters References Data generation = + x import numpy as np # Data Generation np.random.seed(42) x = np.random.rand(100, 1) y = 1 + 2 * x + .1 * np.random.randn(100, 1) # Shuffles the indices idx = np.arange(100) np.random.shuffle(idx) # Uses first 80 random indices for train train_idx = idx[:80] # Uses the remaining indices for validation val_idx = idx[80:] # Generates train and validation sets x_train, y_train = x[train_idx], y[train_idx] x_val, y_val = x[val_idx], y[val_idx] # Plot fig, ax = plt.subplots() ax.scatter(x_train, y_train, color='C0', label='train', alpha=0.5) ax.scatter(x_val, y_val, color = 'C1', label='validation', alpha=0.5) ax.legend() ax.grid(True) fig.show() Linear Regression with Numpy np.random.seed(42) a = np.random.randn(1) b = np.random.randn(1) print(a, b) # Sets learning rate lr = 1e-1 # Defines number of epochs n_epochs = 1000 for epoch in range(n_epochs): # Computes our model's predicted output yhat = a + b * x_train # How wrong is our model? That's the error! error = (y_train - yhat) # It is a regression, so it computes mean squared error (MSE) loss = (error ** 2).mean() # Computes gradients for both "a" and "b" parameters a_grad = -2 * error.mean() b_grad = -2 * (x_train * error).mean() # Updates parameters using gradients and the learning rate a = a - lr * a_grad b = b - lr * b_grad print(a, b) # Sanity Check: do we get the same results as our gradient descent? from sklearn.linear_model import LinearRegression linr = LinearRegression() linr.fit(x_train, y_train) print(linr.intercept_, linr.coef_[0]) Converting to Tensor Tensor PyTorch 텐서는 numpy array와 사실상 다를 게 없다. Numpy array와의 가장 큰 차이점은 CPU와 GPU에서 모두 동작할 수 있다는 점이다. Loading Data, Devices, and CUDA Numpy array를 PyTorch tensor로 변환: from_numpy 은 CPU tensor를 return GPU를 사용하고 싶으면 to() (cuda or cuda:0) GPU 쓸 수 있는지 판별: cuda.is_available() import torch device = 'cuda' if torch.cuda.is_available() else 'cpu' x_train_tensor = torch.from_numpy(x_train).float().to(device) y_train_tensor = torch.from_numpy(y_train).float().to(device) 다시 numpy array로 변환: numpy 그러나 numpy는 GPU tensor를 직접 다룰 수 없기 때문에 먼저 `cpu()' x_train_numpy = x_train_tensor.cpu().numpy() Creating Parameters Data 용 tensor (방금 만든 것) 와 parameter/weight 용 tensor는 어떻게 다른가? 후자는 gradient 계산을 해서 값을 update 할 수 있어야 한다. 그러므로 requires_grad=True argument가 사용된다. 주의할 점은, 먼저 device로 보내고 requires_grad_() method를 사용해야 한다는 것이다. Bad example a = torch.randn(1, requires_grad=True, dtype=torch.float).to(device) b = torch.randn(1, requires_grad=True, dtype=torch.float).to(device) print(a, b) Working example a = torch.randn(1, dtype=torch.float).to(device) b = torch.randn(1, dtype=torch.float).to(device) # and THEN set them as requiring gradients... a.requires_grad_() b.requires_grad_() print(a, b) tensor를 만들면서 동시에 device에 할당하는 것이 가장 좋다. Good example a = torch.randn(1, requires_grad=True, dtype=torch.float, device=device) b = torch.randn(1, requires_grad=True, dtype=torch.float, device=device) References Understanding PyTorch with an example: a step-by-step tutorial A comprehensive overview of PyTorch b. TensorFlow Example Recap Lab Build Graph Run/Update the Graph Using Placeholder Predict 아래 예시는 Sung Kim 님의 강의를 참고하였습니다 Recap 이번에는 시험공부한 시간(x)로부터 시험 성적(y)을 예측하는 예시를 알아보겠다. 다른 학생들의 공부 시간과 성적으로부터 먼저 학습을 해야 한다. 이와 같은 데이터를 training data라고 한다. x(hours) y(score) 10 90 9 80 3 50 2 30 그렇다면 7시간 공부한 학생이 몇 점을 받을 것으로 예상할 수 있을까? 직관적으로 65점 정도 받을 것으로 예측할 것이다. 모델을 만든다는 것을 가설(hypothesis)을 세운다고 표현하기도 한다. 이때의 hypothesis가 선형이면 linear hypothesis이다. ( ) w + 우리는 주어진 학습 데이터에 최적화된 직선의 기울기와 y-절편을 구하려는 것이다. 가령 ( ) 0.5 + , ( ) x h ( ) 0.1 10 등의 hypothesis가 있다고 할 때, 그중 가장 적절한 것이 무엇인가를 구하는 문제이다. 얼마나 '적절한' 가설인가를 양적으로 판단하는 기준이 바로 cost function (loss function)이다. 일반적으로 squared-error를 사용한다. ( ( ) y ) 주어진 training data set의 모든 example에 대한 평균을 구한 것이 우리의 cost function이 된다. cost 1 ∑ = m ( ( ( ) ) y ( ) ) 이때 은 example 개수이며 ( ) 는 i 번째 example이다. cost function은 w 와 b에 대한 함수이며, cost를 가장 작게 만드는 w와 b를 찾고자 한다. min , cost ( , ) Lab Tensorflow를 통해 linear regression을 구현해 보자 Build Graph 우선 graph를 생성한다. 단순화하여 다음과 같은 training data가 있다고 하자. x y 1 1 2 2 3 3 #X and y data (w=1, b=0) x_train = [1,2,3] y_train = [1,2,3] 우리가 찾고 싶은 값은 model paramter 와이다. 이들을 Variable로 생성한다. w = tf.Variable(tf.random_normal([1]), name = 'weight') b = tf.Variable(tf.random_normal([1]), name = 'bias') 이제 hypothesis와 cost function을 정의한다. # Hypothesis Xw+b hypothesis = x_train*w+b # Cost function cost = tf.reduce_mean( tf.square(hypothesis - y_train)) 정의한 cost function을 최소화하는 방법으로 gradient-descent를 사용할 것이다. 이에 관해서는 나중에 자세히 다룰 것이니 지금은 마법(?)이라고 생각하자. # Minimize cost (Gradient descent) optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01) train = optimizer.minimize(cost) 이와 같이 train이라는 node를 만드는 것으로 완성된다. 이 node는 cost node에 연결되고, cost node는 hypothesis와 y_train에, 그리고 hypothesis는 x_train, w, b에 연결되는 구조이다. Run/Update the Graph Graph를 생성하였으면 이제 이 그래프를 '실행'시킬 것이다. 즉, 최적의 model paramter w와 b를 찾는 과정을 진행할 것이다. 먼저 세션을 생성한다. # Launch the graph in a session sess = tf.Session() 그리고 그래프의 Variable들을 초기화한다. sess.run(tf.global_variables_initializer()) # for w and b 'Variables' 이제 준비가 다 되었다. 준비된 그래프 train를 실행한다. 학습이 잘 되고 있는지 확인하기 위해 중간중간 cost와 paramter들(w, b)을 확인하는 것이 좋다. 아래 예시에서는 50회 iteration마다 출력하도록 하였다. for step in range(2001): sess.run(train) if step %50 == 0: print(step, sess.run(cost), sess.run(w), sess.run(b)) 출력된 결과를 보면 w와 b가 각각 1과 0에 점차 수렴해가는 것을 확인할 수 있다. 즉, 우리가 예상한 대로 학습이 잘 이루어지고 있다. Using Placeholder 한편, 애초에 x_train 과 y_train 데이터 값을 고정하는 대신 placeholder로 지정하여 나중에 data를 집어넣을 수도 있다. # Now we can use X and y in place of x_train and y_train # Placeholders for a tensor taht will be always fed using feed_dict X = tf.placeholder(tf.float32, shape=[None]) y = tf.placeholder(tf.float32, shape=[None]) 이러한 방식으로 그래프를 만드는 과정에서는 구체적인 데이터 값을 넣어주지 않고 실제 실행시키는 단계에서 데이터를 입력할 수 있는 것이다. 이후 코드의 x_train, y_train 변수를 X, y로 변경하는 것을 잊지 말자. 이제 그래프 실행 단계에서 feed_dict를 이용하여 데이터 값을 넣어준다. # Fit the line for step in range(2001): cost_val, w_val, b_val, _ = \ sess.run([cost, w, b, train], feed_dict = {X:[1,2,3], y:[1,2,3]}) if step %50 == 0: print(step, cost_val, w_val, b_val) Predict 이렇게 학습된 그래프를 이용해 새로운 입력값에 대한 출력값을 추정하도록 하겠다. 가령 X=5인 경우, print(sess.run(hypothesis, feed_dict ={X:[5]})) 예상되는 y 값은 5로, 매우 근접하게 추정이 되었다. 여러 개 입력을 동시에 넣을 수도 있다. print(sess.run(hypothesis, feed_dict ={X:[1.5, 3.5]})) 2) Parameter Learning (Gradient Descent) Gradient Descent Gradient Descent Algorithm Intuition Gradient Descent for Linear Regression Algorithm Batch Gradient Descent Further Reading Gradient Descent 지금까지 hypothesis function을 정의하고 주어진 데이터에 얼마나 잘 맞는지 cost function을 통해 측정하는 방법을 알아보았다. 이제부터 hypothesis function의 최적의 parameter를 찾는 방법을 공부하도록 한다. Gradient descent는 cost function을 최소화하기 위해 이용할 수 있는 방법 중 하나이며, cost function 말고도 각종 optimization에 이용되는 일반적인 방법이다. 가령, 어떤 함수 ( 0 θ) 가 있을 때, 그 함수의 최솟값과 그때의 parameter 0 θ 을 찾고자 한다. min 0 θ J ( 0 θ) Gradient descent은 기본적으로 다음과 같은 전략을 취한다. Gradient Descent Outline start with some 0 θ (say 0 0 θ = ) Keep changing 0 θ to reduce ( 0 θ) until we hopefully end up at minimum Gradient Descent Algorithm Gradient descent algorithm은 다음과 같이 진행된다. repeat until convergence{ θ := j α ∂ j ( 0 θ) for = , = } := | "assignment" operator | learning rate | feature index number, should be updated simultaneously 주의해야 할 점은 parameter들을 한 번에 업데이트해야 한다는 점이다. 만약 0 을 먼저 업데이트하여 hypothesis가 바뀌고, 그 hypothesis에 숫자를 대입해 1 을 구하면 예상치 못한 문제가 발생할 수 있다. Intuition repeat until convergence{ θ := j α ∂ j ( 0 θ) for = , = } 상수 >는 learning rate이라고 한다. 이 크기가 클수록 한 번에 더 많이 움직이게 되는 것이다. 편미분항 ∂ j ( 0 θ) 는 다음에 이동할 방향과 크기를 결정한다. 기울기의 반대 방향으로 움직이는데, 기울기가 클수록 더 많이 움직인다. 다음 예시를 통해 편미분항이 양수이면 왼쪽으로, 음수이면 오른쪽으로 움직여 최솟값에 서서히 가까워지는 것을 확인할 수 있다. 만약 learning rate 가 너무 작으면 수렴하는 데에 오래 걸리는 문제가 생기고, 너무 크면 최솟값에 이르지 못해 수렴하지 못하거나 심지어 발산하는 문제가 발생할 수 있다. 그러므로 적절한 learning rate을 고르는 것이 중요하다. Gradient descent가 local optima (slope=0)에 이르면 편미분항이 0이 되므로 더 이상 업데이트되지 않는다. 대부분의 경우 최적값에 수렴할수록 편미분 항의 크기가 작아져서 조금씩 업데이트되기 때문에 값을 수동으로 조절하지 않아도 된다. Gradient Descent for Linear Regression 이제 gradient descent를 linear regression에 적용해 보자. Linear regression에서 정의한 cost function을 ( 0 θ) 에 대입하기만 하면 된다. ∂ j ( 0 θ) ∂ θ [ 2 ∑ = m ( θ ( ( ) ) y ( ) ) ] ∂ θ [ 2 ∑ = m ( 0 θ x ( ) y ( ) ) ] Algorithm 이를 pseudo-code로 나타내면 다음과 같다. 이때 은 training set size이고, ( ) y ( ) 는 training set의 데이터이다. 여기서 각 j 가 각각 따로 떨어져 0 θ의 업데이트 식이 따로 정의된 것에 주목하자. 또한 1 을 구할 때에는 ( ) 가 곱해진다는 점이 다르다는 점에 주의하자. 이 항은 편미분에서 나온 것이다. 처음에는 임의로 설정한 parameter에서 출발하여 iteration이 거듭될수록 점점 정확한 hypothesis가 되는 것이다. 또한, Linear regression cost function은 convex이므로 항상 global optima에 수렴한다. Batch Gradient Descent "Batch": Gradient descent의 매 단계에서 모든 training example을 사용한다. Further Reading Youtube Video "Lienar Regression (2): Gradient descent" a. Pytorch example Graident-Descent Impementing with Numpy Pytorch: Autograd Optimizer Loss References Graident-Descent Impementing with Numpy np.random.seed(42) a = np.random.randn(1) b = np.random.randn(1) print(a, b) # Sets learning rate lr = 1e-1 # Defines number of epochs n_epochs = 1000 for epoch in range(n_epochs): # Computes our model's predicted output yhat = a + b * x_train # How wrong is our model? That's the error! error = (y_train - yhat) # It is a regression, so it computes mean squared error (MSE) loss = (error ** 2).mean() # Computes gradients for both "a" and "b" parameters a_grad = -2 * error.mean() b_grad = -2 * (x_train * error).mean() # Updates parameters using gradients and the learning rate a = a - lr * a_grad b = b - lr * b_grad print(a, b) # Sanity Check: do we get the same results as our gradient descent? from sklearn.linear_model import LinearRegression linr = LinearRegression() linr.fit(x_train, y_train) print(linr.intercept_, linr.coef_[0]) Pytorch: Autograd Autograd는 자동으로 미분을 구해주는 패키지이다. 모든 gradient를 구하려면 backward() method를 사용한다. Gradient 계산의 출발점은 loss이다. 여기서부터 parameter에 대한 편미분을 구한다. 그러므로, loss.backward() 와 같이 해당 변수로부터 backward() method를 invoke 한다. Gradient의 값을 확인하고 싶으면 tensor의 grad attribute를 보면 된다. Gradient는 accumulate 되므로, parameter 업데이트에 gradient를 사용하고 나면 항상 0으로 만들어야 한다. 이때 zero_() method가 사용된다. tip In PyTorch, every method that ends with an underscore (_) makes changes in-place, meaning, they will modify the underlying variable. PyTorch의 dynamic computation graph와 혼동되지 않고 일반 Python 연산을 tensor에 수행할 수 있도록 torch.no_grad()를 사용한다. lr = 1e-1 n_epochs = 1000 for epoch in range(n_epochs): yhat = a + b * x_train_tensor error = y_train_tensor - yhat loss = (error ** 2).mean() with torch.no_grad(): a -= lr * a.grad b -= lr * b.grad a.grad.zero_() b.grad.zero_() Optimizer 지금까지는 직접 parameter를 업데이트했다. 두 개뿐이라 할 만했지만 만약 parameter 개수가 아주 많다면 어떻게 할 것인가? Pytorch의 SGD나 Adam과 같은 optimizer를 써서 쉽게 해결할 수 있다. Optimzer는 update할 parameter와 learning rate 및 여러 다른 hyper-parameter를 받아 step() method를 통해 업데이트한다. Gradient를 0으로 만드는 것도 optimizer의 zero_grad() method 가 해결해 준다. import torch.optim as optim optimizer = optim.SGD([a, b], lr=lr) for epoch in range(n_epochs): yhat = a + b * x_train_tensor error = y_train_tensor - yhat loss = (error ** 2).mean() loss.backward() optimizer.step() optimizer.zero_grad() print(a, b) Loss 이번엔 loss 계산에 대해 생각해 보자. Pytorch는 여러 가지 loss function 을 제공한다. 지금은 regrssion 문제를 풀고 있으므로 mean-squared error (MSE) loss 가 적절하다. tip Notice that nn.MSELoss actually creates a loss function for us — it is NOT the loss function itself. Moreover, you can specify a reduction method to be applied, that is, how do you want to aggregate the results for individual points — you can average them (reduction=’mean’) or simply sum them up (reduction=’sum’). import torch.nn as nn loss_fn = nn.MSELoss(reduction='mean') optimizer = optim.SGD([a, b], lr=lr) for epoch in range(n_epochs): yhat = a + b * x_train_tensor loss = loss_fn(y_train_tensor, yhat) loss.backward() optimizer.step() optimizer.zero_grad() References Understanding PyTorch with an example: a step-by-step tutorial A comprehensive overview of PyTorch b. TensorFlow example Recap Gradient descent algorithm Lab Plotting Cost Function against a Model Parameter Implementing Gradient Descent Setting Manual Gradient 아래 예시는 Sung Kim 님의 강의를 참고하였습니다 Recap 우선, bias term을 없애고 hypothesis를 다음과 같이 단순하게 정의해 보자. ( ) w 그러면 cost function은 다음과 같이 표현된다. cost 1 ∑ = m ( ( ( ) ) y ( ) ) = m i 1 ( x ( ) y ( ) ) 다음과 같은 단순한 training data를 생각해 보자. x(hours) y(score) 1 1 2 2 3 3 이 경우, = 이면 cost( )는 얼마일까? 이때에는 모든 항의 error term이 0이므로 이를 제곱해서 평균을 내더라도 그대로 0이 된다. = , 인 경우에 대해서도 구해보자. = : 3 ( ( × − ) + ( × − ) + ( × − ) ) 0 = : 3 ( ( × − ) + ( × − ) + ( × − ) ) 4.67 = : 3 ( ( × − ) + ( × − ) + ( × − ) ) 4.67 이와 같이에 대한 함수를 그려보면 포물선 형태가 될 것이다. 우리의 목표는 이 함숫값이 최소가 되는 점을 찾아내는 것이다. min , cost ( , ) 이 예시에서는 쉽게 해당하는 점을 찾을 수 있겠지만, 좀 더 일반적인 cost function 에까지 확장하기 위해 gradient descent algorithm을 이용하겠다. 직역하자면 '경사를 따라 내려가는' 알고리즘이다. Gradient descent algorithm Minimize cost function Used in many minimization problems For a given cost function, cost(w, b), it will find , to minimize cost It can be applied to more general functions: cost(w1, w2, ...) 가령 높은 곳에서 시작해서 가장 낮은 곳으로 이동하고자 하자. 바로 주변을 둘러봐서 가장 경사가 급한 방향으로 한 발자국 간다. 그리고 바로 그 지점에서 다시 주변을 둘러봐서 가장 경사가 급한 방향으로 다시 한 발자국 간다. 이를 반복하다 보면 가장 낮은 곳으로 이동할 수 있게 된다. Gradient descent는 이러한 원리를 이용한 알고리즘이다. How it works 아무 데서나 시작한다. Keep chaning w and b a little bit to reduce cost(w, b) -- Each time chaning the paramters, select the gradient which reduces cost(w, b) as much as possible Repeat until converge to a local minimum 시작점을 어디로 잡느냐에 따라 어느 local minimum에 수렴하느냐가 정해진다. -- Cost function이 convex 이면 항상 global minimum에 수렴한다. Formal Definition cost 1 ∑ = m ( x ( ) y ( ) ) w는 어떻게 업데이트하는가? learning rate에 cost function을 w에 대하여 미분한 값, 즉 기울기를 곱한 값을 빼는 것이다. := − ∂ w o t ( ) w α ∂ 1 m i 1 ( x ( ) y ( ) ) = − 1 m i 1 2 ( x ( ) y ( ) ) ( ) w α m i 1 ( x ( ) y ( ) ) ( ) 아무 w에서 시작하더라도 이를 반복해서 실행하다 보면 최적의 가 구해지게 되는 것이다. Lab Plotting Cost Function against a Model Parameter 우선 model parameter에 따라 cost function을 그려보겠다. 필요한 모듈을 import 한다. 그래프를 그리기 위해 pyplot도 import 한다. import tensorflow as tf import matplotlib.pyplot as plt 쉬운 예시를 위해 간단한 training data를 이용하도록 하겠다. X = [1, 2, 3] y = [1, 2, 3] 변수 w를 placeholder로 정의하고 hypothesis와 cost function을 정의한다. w = tf.placeholder(tf.float32) # Hypothesis for linear model X*w hypothesis = X*w # Cost/loss function cost = tf.reduce_mean(tf.square(hypothesis - y)) 이제 생성한 그래프를 실행해 본다. # Launch the graph in a session sess = tf.Session() # Initialize global variables in the graph sess.run(tf.global_variables_initializer()) # Variables for plotting cost function w_val = [] cost_val = [] for i in range(-30, 50): feed_w = i *0.1 curr_cost, curr_w = sess.run( [cost, w], feed_dict={w: feed_w}) w_val.append(curr_w) cost_val.append(curr_cost) 이제 이 결과를 그래프로 나타내어보자. # Show the cost function plt.plot(w_val, cost_val) plt.xlabel('w') plt.ylabel('cost') plt.show() Implementing Gradient Descent 이제 본격적으로 Tensorflow를 통해 gradient descent를 구현해 보자. 이번에도 같은 training data를 이용할 것이다. x_data = [1, 2, 3] y_data = [1, 2, 3] X = tf.placeholder(tf.float32) y = tf.placeholder(tf.float32) 이번에는 model parameter가 Tensorflow가 update할 변수이므로 Variable로 선언한다. w = tf.Variable(tf.random_normal([1]), name='weight') # Minimize: Gradient descent using derivative: # w-= learning_rate * deriavative learning_rate = 0.1 gradient = tf.reduce_mean( ( w*X -y)* X) descent = w - learning_rate *gradient update = w.assign(descent) # Launch the graph in a session sess = tf.Session() # Initialize global variables in the graph sess.run(tf.global_variables_initializer()) for step in range(21): sess.run(update, feed_dict = {X:x_data, y:y_data}) print(step, sess.run(cost, feed_dict={X:x_data, y:y_data}), sess.run(w)) 혹은 Tensorflow에 이미 정의된 gradient descent optimizer를 사용해도 된다. # Minimize: Gradient descent magic # No need to find derivative optimizer = tf.train.GradientDescentOptimizer(learning_rate = 0.1) train = optimizer.minimize(cost) # Launch the graph in a session sess = tf.Session() # Initialize global variables in the graph sess.run(tf.global_variables_initializer()) for step in range(21): sess.run(train, feed_dict = {X:x_data, y:y_data}) print(step, sess.run(w)) Setting Manual Gradient 자유자재로 gradient function을 수정하고 싶다면 다음과 같은 방법을 이용한다. # Manual gradient gradient = tf.reduce_mean( (w*X - y) * X) *2 # Cost function cost = tf.reduce_mean(tf.square( hypothesis - y)) optimizer = tf.train.GradientDescentOptimizer(learning_rate= 0.1) # Get gradients gvs = optimizer.compute_gradients(cost) # Apply gradients apply_gradients = optimizer.apply_gradients(gvs) # Launch the graph in a session sess = tf.Session() sess.run(tf.global_variables_initializer()) for step in range(100): sess.run(apply_gradients, feed_dict = {X:x_data, y:y_data}) print( step, sess.run([gradient, w, gvs], feed_dict = {X:x_data, y:y_data})) 3) Multivariate Linear Regression Multiple features Cost Function Gradient Descent for Multiple Variables Matrix Notation tip Ng 교수님은 여러 개 intdependent variable로 하나의 dependent variable을 예측하는 문제를 multivariate linear regression이라고 불렀지만 통계학 쪽에서는 multiple (linear) regression이라고 부르고 multivariate regression 은 다른 문제를 의미하는 것 같습니다. 혹시 보충 설명해 주실 수 있는 분은 아래 댓글이나 피드백을 통해서 알려주시면 감사하겠습니다. Multiple features 지금까지는 하나의 변수를 이용한 univariate regression에 대하여 알아보았다. 그러나 실제 상황에서는 하나의 변수만으로 예측하기 어려운 경우가 많다. 이번 장에서는 여러 개의 변수를 이용한 multivariate linear regression을 알아보도록 하자. 다시 집값 추정 문제를 생각해 보자. 개똥이는 원래 집의 넓이만을 고려했다. 그런데 부동산 업자 말똥이가 평수 외의 요소들도 고려하면 더 정교하게 추정할 수 있을 거라고 조언했다. 그래서 이번에는 집의 넓이( 1 ) 뿐만 아니라 방의 개수( 2 ), 층수( 3 ), 그리고 건물의 연령( 4 )을 고려해서 집값( )를 추정해 보기로 했다. Notation = x ( ) : the number of features ( = ) : the number of training examples ( = 47 ) ( ) : input (features) of -th training example ( ( ) [ 1416 3 2 40 ] ∈ 4 ) j ( ) : value of feature in -th training example ( 3 ( ) 2 ) 이제 hypothesis function을 multivariate 꼴로 다시 정의해 보자. 변수가 하나일 때에는 θ ( ) θ + 1였으나 h ( ) θ + 1 1 θ x + . + n n 가령, 주어진 집값 추정 문제에서 hypothesis가 θ ( ) 80 0.1 1 0.01 2 3 3 2 4 와 같이 나타내고 직관적으로 해석해 보자. 0 80 은 기본 집값이라고 생각할 수 있고, 1 0.1 은 제곱미터당 가격, 2 0.01 은 층당 가격 등으로 볼 수 있다. Matrix multiplication을 통해 hypothesis function을 간략하게 나타낼 수도 있다. 편의상 0 ( ) 1 ( ∈, . , ) 로 정의하고 와 가 모두 + 차원이 되도록 맞추겠다. θ ( ) [ 0 1. θ ] [ 0 1 x ] θ x 이것은 한 개 training example에 대한 hypothesis function의 vectorization이다. 각 training example을 row-vector로 하여 matrix에 다음과 같이 '쌓는다'. = [ 0 ( ) 1 ( ) 0 ( ) 1 ( ) 0 ( ) 1 ( ) ] θ [ 0 1 ] 그러면 hypothesis를 × column vector로 계산할 수 있다. θ ( ) X Cost Function Parameter vector ∈ n 1 에 대하여 cost function은 다음과 같이 나타내어진다. ( ) 1 m i 1 ( θ ( ( ) ) y ( ) ) Vectorize 하여 표현하면, ( ) 1 m ( θ y ) ( θ y ) 이때의 는 모든 ( ) 값을 포함하는 벡터이다. Gradient Descent for Multiple Variables 지금까지 다룬 내용을 요약해 보자. Hypothesis θ ( ) θ x θ x + 1 1. . θ x where 0 1 Parameters = [ 0 θ, . , n ] ∈ n 1 Cost function ( ) J ( 0 θ, . , n ) 1 m i 1 ( θ ( ( ) ) y ( ) ) Gradient descent는 변수가 하나일 때와 기본적으로 같은 꼴이지만 개 feature에 대하여 반복한다는 점이 다를 뿐이다. n 1 인 경우, 다음과 같이 update 하였다. Repeat until convergence{ θ := 0 α ∂ 0 ( 0 θ) θ − 1 ∑ = m ( θ ( ( ) ) y ( ) ) θ := 1 α ∂ 1 ( 0 θ) θ − 1 ∑ = m ( θ ( ( ) ) y ( ) ) ( ) } simultaneously update 0 θ 이제 ≥ 인 경우에 대하여 적어 보자. Repeat until convergence{ θ := j α ∂ j ( 0. . θ) θ − 1 ∑ = m ( θ ( ( ) ) y ( ) ) j ( ) } simultaneously update for every = , . , 이를 각 parameter 별로 풀어쓰면, Repeat until convergence{ θ := 0 α m i 1 ( θ ( ( ) ) y ( ) ) 0 ( ) θ := 1 α m i 1 ( θ ( ( ) ) y ( ) ) 1 ( ) . . θ := n α m i 1 ( θ ( ( ) ) y ( ) ) n ( ) } simultaneously update for every = , . , Matrix Notation The gradient descent rule can be expressed as: := − ∇ ( ) where J ( ) is a column vector of the form: J ( ) [ J ( ) θ ∂ ( ) θ ⋮ J ( ) θ ] The j-th component of the gradient is the summation of the product of two terms J ( ) θ = m i 1 ( θ ( ( ) ) y ( ) ) x ( ) 1 ∑ = m j ( ) ( θ ( ( ) ) y ( ) ) Sometimes, the summation of the product of two terms can be expressed as the product of two vectors. Here, j ( ) , for = , . , represents the elements of the j-th column, j of the training set . The other term ( θ ( ( ) ) y ( ) ) is the vector of the deviations between the predictions θ ( ( ) ) and the true values ( ) . Re-writing J ( ) θ , we have: J ( ) θ = m j T ( θ y) J ( ) 1 X ( θ y) Finally, the matrix notation (vectorized) of the gradient descent rule is: := − m T ( θ y) a. Pytorch Example Model Nested Models Sequential Models Training Step References Model 지금까지 line을 fit 하는 법에 대해 다루었다. 이제부터는 prediction에 관해 다루어 보자. PyTorch에서 model은 Module 클래스로부터 상속된 클래스로 만든다. 가장 기본적으로 두 개 method를 구현해야 한다. __init__(self): model을 구성할 부분들을 정의한다. 우리의 경우, a 와 b 2개의 paramter이다. forward(self, x): 실제 계산을 행하는 부분으로 주어진 x에 대한 prediction을 output으로 낸다. tip forward(x) method를 직접 호출하지 않는다. model(x)와 같이 전체 model을 호출한다. class ManualLinearRegressor(nn.Module): def __init__(self): super().__init__() self.a = nn.Parameter(torch.rand(1, requires_grad=True, dtype=torch.float)) self.b = nn.Parameter(torch.rand(1, requires_grad=True, dtype=torch.float)) def foward(self, x): return self.a + self.b*x model은 data와 같은 device에 있어야 한다. 또한, model에는 train() method가 있는데, 이는 training을 직접 하지는 않는다. 대신 model을 training mode로 설정하는 역할을 한다. 가령, Dropout이 있는 경우 training과 evaluation 이 각각 다른 behavior를 보이기 때문에 이를 설정하는 것이 중요하다. model = ManualLinearRegressor().to(device) print(model.state_dict()) loss_fn = nn.MSELoss(reduction='mean') optimizer = optim.SGD(model.parameters(), lr=lr) for epoch in range(n_epochs): model.train() yhat = model(x_train_tensor) loss = loss_fn(yhat, y_train_tensor) loss.backward() optimizer.step() optimizer.zero_grad() Nested Models 수동으로 linear regression parameter를 생성하는 대신 PyTorch의 Linear model을 만들어 nested model을 생성해 보자. class LayerLinearRegressor(nn.Module): def __init__(self): super().__init__() self.linear = nn.Linear(in_features=1, out_features=1) def forward(self, x): return self.linear(x) Sequential Models Sequaltial model 을 이용하면 class를 생성할 필요조차 없다. model=nn.Sequential(nn.Linear(in_features=1, out_features=1)).to(device) Training Step 지금까지 optimizer, loss function, model 을 정의했다. loop를 조금 더 일반화할 수 있는 방법이 있을까? def make_train_step(model, loss_fn, optimizer): def train_step(x, y): # Sets model to train mode model.train() # Make predictions yhat = model(x) # Compute loss loss = loss_fn(yhat, y) # Compute gradients loss.backward() # Update parameters and zero gradients optimizer.step() optimizer.zero_grad() # Return the loss return loss.item() return train_step model=nn.Sequential(nn.Linear(in_features=1, out_features=1)).to(device) loss_fn = nn.MSELoss(reduction='mean') optimizer = optim.SGD(model.parameters(), lr=lr) train_step=make_train_step(model, loss_fn, optimizer) losses = [] for epoch in range(n_epochs): loss = train_step(x_train_tensor, y_train_tensor) losses.append(loss) References Understanding PyTorch with an example: a step-by-step tutorial A comprehensive overview of PyTorch 4) Gradient Descent in Practice Feature Scaling Mean normalization Learning Rate Debugging Gradient Descent Automatic Convergence Test Feature Scaling 모든 feature가 비슷한 범위에 있으면 gradient descent가 더 빠르게 수렴하는 데에 도움이 된다. More generally, get every features into approximately same range. eg. 1 x ≤, 3 x ≤ 아주 똑같은 범위일 필요는 없다. 대략 비슷한 정도면 충분. Mean normalization Replace i with i μ to make features have approximately zero mean (Do not apply to 0 1 ) Learning Rate ( ) 는 매 iteration마다 감소해야 한다. Example automatic convergence test: Declare convergence if ( ) decreases by less than in one iteration eg. = 10 3 Gradient descent 가 제대로 작동을 안 한다면, 값을 줄이자. 충분히 작은 값을 사용했다면, ( ) 는 매 iteration마다 감소하는 것이 수학적으로 증명되어 있다. 그러나 값이 너무 작으면 gradient descent 가 수렴하는 데에 오래 걸릴 수 있다는 문제가 있다. Andrew Ng는 값을 3씩 곱하거나 나누며 조절하는 것을 추천하였다. Debugging Gradient Descent Make a plot with number of iterations on the x-axis. Now plot the cost function, ( ) over the number of iterations of gradient descent. If ( ) ever increases, then you probably need to decrease . Automatic Convergence Test Declare convergence if ( ) decreases by less than E in one iteration, where E is some small value such as 10 3 . However in practice it's difficult to choose this threshold value. a. Pytorch Example: Dataset Dataset DataLoader Random Split References Dataset Pytorch에서 dataset은 Datset class에서 상속된다. 일종의 tuple 들의 list로 생각할 수 있고, 각 tuple은 하나의 data point (features label) 쌍으로 볼 수 있다. from torch.utils.data import Dataset, TensorDataset 기본적으로 구현해야 할 method들은 __init__(self): list of tuple을 구성하기 위한 argument를 받는다. CSV file의 이름, 두 tensor (하나는 feature, 하나는 label), 등등 __getitem__(self, index): dataset이 index되어 list처럼 동작하도록 (dataset[i]) 한다. 요청된 data point의 Tuple (features, label)을 return 해야 한다. pre-loaded dataset or tensor의 해당하는 slice를 return 하거나 on demand로 return 한다. __len__(self): 전체 dataset의 size를 return 한다. tip __init__에서 전체 데이터 셋을 불러오지 않아도 된다. dataset이 크다면 한 번에 읽어들이는 것은 memory 효율이 떨어진다. 이 경우, on demand로 __getitem__을 호출할 때마다 부르는 편을 추천한다. class CustomDataset(Dataset): def __init__(self, x_tensor, y_tensor): self.x = x_tensor self.y = y_tensor def __getitem__(self, index): return (self.x[index], self.y[index]) def __len__(self): return len(self.x) x_train_tensor = torch.from_numpy(x_train).float() y_train_tensor = torch.from_numpy(y_train).float() train_data = CustomDataset(x_train_tensor, y_train_tensor) print(train_data[0]) 이때 training tensor를 device로 보내지 않은 점에 유의하자. training data 전체를 GPU tensor로 읽어서 소중한 그래픽 카드 RAM의 자리를 과도하게 차지하는 것을 방지하기 위해서이다. 한편, Dataset이 tensor 몇 개에 불과하다면 새 class를 선언하는 과정 없이 TensorDataset class를 사용하는 편이 더 간단하다. train_data = TensorDataset(x_train_tensor, y_train_tensor) print(train_data[0]) DataLoader 지금까지는 전체 training data를 매 training step마다 이용했다. 즉, batch gradient descent였다. 작은 dataset으로는 괜찮지만 dataset이 커지면 mini-batch gradient descent를 사용해야 한다. Pytorch DataLoader class를 사용하면 dataset slice를 자동으로 만들 수 있다. from torch.utils.data import DataLoader train_loader = DataLoader(dataset=train_data, batch_size=16, shuffle=True) Sample mini-batch 하나를 얻으려면 아래 command를 사용하면 된다. next(iter(train_loader)) for epoch in range(n_epochs): for x_batch, y_batch in train_loader: x_batch = x_batch.to(device) y_batch = y_batch.to(device) loss = train_step(x_batch, y_batch) losses.append(loss) 한 번에 한 mini-batch만 device로 보낸다. 이번에는 같은 과정을 validation data에 split을 이용해 적용해 보자. Random Split Pytorch의 random_split() method는 training-validation split을 용이하게 만든다. 전체 dataset에 적용해야 함을 기억하자. from torch.utils.data.dataset import random_split x_tensor = torch.from_numpy(x).float() y_tensor = torch.from_numpy(y).float() dataset = TensorDataset(x_tensor, y_tensor) train_dataset, val_dataset = random_split(dataset, [80,20]) train_loader = DataLoader(dataset=train_dataset, batch_size=16) val_loader = DataLoader(dataset=val_dataset, batch_size=20) References Understanding PyTorch with an example: a step-by-step tutorial A comprehensive overview of PyTorch 5) Features and Polynomial Regression New Feature Polynomial Regression 몇 가지 feature 와 hypothesis function 개선 방법을 알아보자. New Feature 여러 개 feature를 하나로 합쳐서 새로운 feature로 이용할 수 있다. 가령, 개똥이가 집값을 추정할 때 집의 frontage와 depth를 feature로 이용했다고 하자. 이 두 feature보다는 그 둘을 곱한 값, 즉 집의 넓이 역시 집값을 추정하는 데에 도움이 되는 feature이다. 이렇게 새로운 featre 1 를 기존의 feature들의 곱의 형태로 정의할 수도 있다. θ ( ) θ + 1 ( frontage ) θ × ( depth ) 1 ( area ) ( frontage ) ( depth ) Polynomial Regression Hypothesis function이 반드시 linear (직선)이어야 하는 것은 아니다. 데이터에 잘 fit 하는 형태로 나타내면 된다. 예를 들면 2차 함수나 3차 함수 곡선, 또는 제곱근 함수 등의 형태를 이용할 수 있다. 가령, hypothesis function이 θ ( ) θ + 1 1 일 때, 1 에 연관된 feature를 추가하여 2차 함수 꼴로 만들 수 있다. θ ( ) θ + 1 1 θ x 2 그런데 2차 함수 포물선은 최고점을 찍고 감소하는 형태이다. 다시 말해, 집의 크기가 일정 수준 이상으로 커지면 집이 클수록 집값이 감소하는 기이한 모델이 된다. 이는 우리의 집값 추정 데이터와 잘 맞지 않을 것이다. 이번에는 3차 함수를 고려해 보자. θ ( ) θ + 1 1 θ x 3 θ x 3 이렇게 3차 함수 꼴로 나타내었을 때, 새로운 feature 2 x 가 추가된 것으로 이해할 수 있다. 2 x 2 x = 1. 비슷한 방식으로 제곱근 형태의 feature도 만들 수 있다. θ ( ) θ + 1 1 θ x 주의할 점은, 이렇게 feature를 만들면 feature scaling이 더욱 중요해진다는 점이다. 예를 들어, 1 의 원래 범위가 1~1000이라면, 1의 범위는 1~1000000이 되고, 1의 범위는 1~1000000000이 되어버린다. a. Pytorch Example: Evaluation Evaluation References Evaluation 이제 validation loss를 계산할 차례이다. 다음 사항을 고려하자. torch.no_grad(): 우리의 작은 model에서는 차이를 만들지 않지만, validation inner loop를 이 context manager로 감싸서 gradient calculation을 방지하는 것이 좋다. eval(): model을 evaluation mode로 설정한다. for epoch in range(n_epochs): for x_batch, y_batch in train_loader: x_batch = x_batch.to(device) y_batch = y_batch.to(device) loss = train_step(x_batch, y_batch) losses.append(loss) with torch.no_grad(): for x_val, y_val in val_loader: x_val = x_val.to(device) y_val = y_val.to(device) model.eval() yhat = model(x_val) val_loss = loss_fn(yhat, y_val) val_losses.append(val_loss.item()) References Understanding PyTorch with an example: a step-by-step tutorial A comprehensive overview of PyTorch 6) Computing Parameters Analytically Normal Equation Intuition Normal Equation Noninvertibility Further Reading Normal Equation Model parameter의 analytical solution을 직접 찾는 방법이다. Gradient-descent 가 여러 번 iteration을 돌아야 하는 것과 대조적으로 한 번에 최적의 해를 찾는다는 특징이 있다. Intuition 1D case ( ∈ ) Feature 가 1개인 경우, ( ) 는 2차 방정식의 꼴이 된다. 따라서에 대하여 미분한 결과가 0이 되도록 설정하여 풀면 된다. Multiple feature case ∈ n 1 여러 개 feature를 이용하는 경우에도 같은 방식으로 접근할 수 있다. 다만 변수가 여러 개이므로 이번에는 각 j 에 대하여 편 미분하여 푼다. Example: = m examples ( ( ) y ( ) ) . . ( ( ) y ( ) ) n features Feature scaling 이 굳이 필요하지 않다. Gradient-descent Normal Equation △ Need to choose ▽ No need to choose ▽ Need many iterations △ No need to iterate △ Works well when is large ▽ Slow if very large ( n) ( 3 ) to calculate ( T) 1 eg. Use gd if ≥ 10 000 Normal Equation Noninvertibility What if T non-invertible? (singular/ degenerate) Common reasons Redundant features (linearly dependent) eg. 1 ( i e n ) ( e t ) , 1 ( i e n ) ( ) ==> Remove one Too many features (eg ≤ ) ==> Delete some features or use regularization Further Reading Proofs are available at these links for those who are interested: https://en.wikipedia.org/wiki/Linear_least_squares_(mathematics) http://eli.thegreenplace.net/2014/derivation-of-the-normal-equation-for-linear-regression 03. Logistic Regression Classification Binary Classification Linear Regression for Classification? Classification Linear regression 이 주어진 feature에 따라 continous 한 target 값을 추정하는 방법 (eg. 집값 추정) 이었다면, classification은 주어진 feature에 따라 데이터를 discrete 한 class에 분류하는 방법이다. 예를 들면 받은 e-mail이 스팸인지 아닌지, 어떤 종양이 양성인지 악성인지 등을 판별하는 것이다. 나중에 여러 개 class를 분류하는 multi-class classification에 대해서도 다루겠지만, 우선은 두 개 class로만 분류하는 binary classification에 대해 알아보자. Binary Classification Linear regression은 output vector 가 연속적 값을 갖지만 binary classification에서는 가 0 또는 1의 값을 갖는다. 즉, ∈, . 일반적으로, 0은 "negative class"로, 1은 "positive class"라고 불리지만 어떻게 표현하든 관계없다. 이와 같이 2개의 class로 분류하는 문제는 "binary classification problem"이라고 한다. 각 class의 이름은 편의상 '0' 과 '1'이라고 하자. 어떤 이름을 쓰든 상관없지만 계산상의 이점도 있고 일반적으로 이와 같이 표기하므로 특별한 이유가 없다면 이 방식을 따르는 것이 가장 편리하다. ∈ { , } Class 0 ( = ): "Negative class" Class 1 ( = ): "Positive class" Linear Regression for Classification? 어쩌면 linear regression을 classification 문제에도 적용할 수 있지 않을까? 의사인 개똥이는 집값을 추정하는 데에 linear regression을 사용했던 방법을 진단을 내리는 데에도 적용할 수 있을지 궁금해졌다. 그래서 다음과 같이 종양 크기에 따라 악성인지 양성인지 구분되는 데이터를 가지고 실험을 해보았다. Linear regression을 이용했더니 녹색 선으로 이 데이터가 표현되었다. 그렇게 구한 hypothesis function 이 '0.5' 가 되는 종양 크기를 threshold로 잡아서 그보다 크면 '악성(malignant), 그보다 작으면 '양성(benign)'이라고 판별해 보았다. 그랬더니 classification이 제법 잘 되었다! 이때에는 linear regression을 통한 classification도 제법 쓸만한 것이다. 하지만 항상 그럴까? If θ ( ) 0.5 , predict " = " If θ ( ) 0.5 , predict " = " 호기심 많은 개똥이는 이번에는 다음과 같은 데이터로 시험해 보았다. 이번에는 아주 큰 종양이 하나 더 추가되었다. 이때 linear regression 결과는 파란 선이 될 것이다. 그런데 파란 선을 기준으로 threshold를 잡을 경우 classification이 제대로 되지 않는다. 이것은 linear regression이 실패하는 특수한 예가 아니다. 실제로 linear regression을 classification에 사용하면 잘되지 않는 경우가 많다. 이 예시와 같이 어떤 feature (종양 크기)가 class (악성/양성)을 정확하게 예측할 수 있는데도 linear regression을 이용하는 classification은 실패할 수 있다는 것에 주의하자. 또 한 가지 문제가 있다. 우리가 관심 있는 classification 문제의 target는 0 또는 1의 값만 갖는다. 그런데 linear regression의 θ ( ) 는 1보다 크거나 0보다 작은 값을 내보낼 수 있다. 따라서 logistic regression은 hypothesis function이 0과 1 사이의 값만 내보내도록 한다. Logistic regression은 이름에 regression이 들어있긴 하지만 classifier라는 것을 기억하도록 하자. 1) Hypothesis Representation Logistic Regression Model Interpretation of Hypothesis Output Logistic Regression Model Logistic regression의 hypothesis function은 0과 1 사이의 값만 내보내는 형태가 되도록 하려고 한다. 즉, ≤ θ ( ) 1 다음은 이 조건을 만족하며 미분 가능한 함수의 예이다. ( ) 1 + − 이 함수는 'sigmoid function' 또는 'logistic function'이라고 불린다. 이 때 에 에 관한 함수를 넣어 hypothesis로 만들 수 있다. Linear regression hypothesis인 T를 대입하는 것으로 시작해 보자. θ ( ) 1 + − T 이와 같이 Logistic function을 hypothesis로 쓰기 때문에 logistic regression이라고 한다. 다음 링크에서 logistic hypothesis의 parameter를 직접 바꾸어가며 함수의 모양이 어떻게 달라지는지 관찰해 보자. https://www.desmos.com/calculator/bgontvxotm Interpretation of Hypothesis Output Hypothesis function의 출력값은 '주어진 feature 가라는 값을 가질 때 class 1에 들어갈 확률'이라는 의미를 갖는다. θ ( ) P ( = | ; ) : feature : model parameter = (class 1) 일 확률과 = (class 0) 일 확률은 합이 1이 되어야 한다는 사실을 기억해두자. ( = | ; ) P ( = | ; ) 1 예를 들어, θ ( ) 0.7 이란, output이 1일 확률이 70%이며 output이 0일 확률은 30%라는 뜻이다. 2) Decision Boundary Decision Boundary Non-Linear Decision Boundaries Logistic regression의 hypothesis function은 다음과 같이 정의한다고 하였다. 이때 우리는 feature 가 어떤 값을 가지면 Class 1에 들어가는지 ( = ), 혹은 Class 0에 들어가는지 ( = ) 알고자 한다. 규칙은 간단하다. Hypothesis function이 0.5가 넘으면 Class 1에, 0.5 가 되지 않으면 Class 0에 넣기로 하자. 즉, 다음 규칙에 따라 y 값을 predict 한다. = { if θ ( ) 0.5 0 if θ ( ) 0.5 그런데 hypothesis function θ ( ) g ( ) 이 0.5 이상이 되는 경우는 = T ≥ 일 때이다. 그리고 0.5 이하가 되는 경우는 T < 일 때이다. 따라서, T = 일 때를 기준으로 class 가 나뉘게 된다. = { if T ≥ 0 if T < Decision Boundary Decision boundary는 = 과 = 을 가르는 경계선을 말하며, hypothesis function에 의해 결정된다. Decision boundary: θ ( ) 0.5 , i.e. T = 가령 다음과 같은 data를 가지고 있을 때, 모종의 방법으로 최적의 parameter를 찾았다고 하자. (Parameter를 찾는 방법은 나중에 다룰 것이다.) 이 최적의 parameter를 가지고 다음과 같은 결론을 내릴 수 있다: T = 3 x + 2 0 이면 Class 1 ( = )에 넣고 그렇지 않으면 Class 0 ( = )에 넣는다. Predict = if 3 x + 2 θ x 0 i.e. 1 x ≥ 이때의 decision boundary는 3 x + 2 0 이다. 위 그림에서 녹색으로 표시된 선이다. 이제 training set에 들어있지 않았던, 새로운 데이터가 나타나면 1 값과 2 값을 이용하여 좌표를 찍어보고, decision boundary보다 위쪽에 찍히면 class 1에, 아래쪽에 찍히면 class 0에 넣으면 되는 것이다. 이때, decision boundary는에 의해 결정되는 것임을 기억하자. Training data는 parameter를 결정하는 데에 이용될 뿐, decision boundary에 직접적으로 영향을 미치지는 않는다. Non-Linear Decision Boundaries 앞의 예는 linearly separable 한 데이터였다. 그러나 직선으로 class를 구분할 수 없는 경우도 있다. 예를 들어, 아래 그림과 같이 원형의 decision boundary가 필요한 경우도 있다. 한 가지 방법은 polynomial 하게 feature dimension을 높이는 방법이다. 이 방법을 사용하면 non-linear decision boundary도 표현할 수 있다. 이 예시와 같은 경우에는 sigmoid function의 input을 원의 방정식으로 대체하여 데이터에 적절한 hypothesis를 만들 수 있다. 3) Cost Function & Gradient Descent Logistic Regression Cost Function Gradient Descent Appendix: Partial derivative of ( ) Linear regression에서는 LSE criterion을 사용하였다. Linear regression: ( ) 1 ∑ = m 2 ( θ ( ( ) y ( ) ) ) ⏟ cost ( θ ( ) y ) 이 criterion을 logistic regression에 그대로 사용할 수 있을까? θ ( ) 1 + − T를 대입하면 될 것 같기도 하다. 그러나 그 경우, cost function이 non-convex function이 된다. Non-convex cost function은 local optima에 빠질 수 있다는 문제가 있다. 그래서 logistic regression의 cost function은 조금 다르게 정의한다. Logistic Regression Cost Function Logistic regression의 cost function은 다음과 같이 정의한다. cost ( θ ( ) y ) { log ( θ ( ) ) if = − log ( − θ ( ) ) if = 즉, 아래 그래프와 같이 = 일 때와 = 일 때 서로 다른 함수를 따르게 된다. = 일 때 cost function의 특징은, cost 0 when θ ( ) 1 cost ∞ as θ ( ) 0 이는 = and θ ( ) 0 즉, ( = | ; ) 0 인 경우 learning algorithm에 큰 penalty를 주어야 한다는 직관에 부합한다. 정리하자면 다음과 같다. Logistic regression: ( ) 1 ∑ = m cost ( θ ( ( ) ) y ( ) ) where cost ( θ ( ) y ) { log ( θ ( ) ) if = − log ( − θ ( ) ) if = 그런데는 오직 1 또는 0이라는 값만 가지므로, 다음과 같이 간단하게 표현할 수 있다. cost ( θ ( ) y ) − log ( θ ( ) ) ( − ) log ( − θ ( ) ) if = , cost ( , ) − log ( θ ( ) ) if = , cost ( , ) − log ( − θ ( ) ) 최종적으로, logistic regression의 cost function은 다음과 같이 표현한다. Logistic regression: ( ) − m i 1 [ ( ) log h ( ) ( − ( ) ) log ( − θ ( ) ) ] 이 cost function의 특징은, Maximum likelihood estimation criterion Convex 이제 최적의 parameter를 찾으려면 min J ( ) 를 구하고, 그 후에 주어진 새로운 를 어떤 class에 넣을지 판단하려면 θ ( ) 1 + exp ( θ x ) 가 0.5보다 큰지 작은지를 확인하면 된다. Gradient Descent ( ) − m i 1 [ ( ) log h ( ) ( − ( ) ) log ( − θ ( ) ) ] 이 cost function을 최소화하는 parameter를 찾는 것이 목적이다. ( ) 가 convex이므로, gradient descent에 의해 optimal를 찾을 수 있다. 즉, Repeat{ θ := j α ∂ j ( ) } simultaneously update all j 이때 ∂ j ( ) 1 ∑ = m ( θ ( ( ) ) y ( ) ) j ( ) 이 수식만 보면 linear regression의 gradient descent와 동일하다. 유일한 차이점은 hypothesis function이 θ ( ) 1 + exp ( θ x ) 로 바뀐 것이다. Appendix: Partial derivative of ( ) 우선 logistic funtion의 미분을 구해두자. ( ) = ( 1 e x ) = ( + − ) ( + − ) = 1 − ( − ) ( + − ) = − ( x ) ( − ( + − ) = ( 1 e x ) ( − 1 e x ) σ ( ) ( 1 1 e x + − ) σ ( ) ( + − + − 이제 편미분을 구해보자. ∂ j ( ) ∂ θ − m i 1 [ ( ) log ( θ ( ( ) ) ) ( − ( ) − m i 1 [ ( ) ∂ j log ( θ ( ( ) ) ) ( − ( ) ) − m i 1 [ ( ) ∂ j θ ( ( ) ) θ ( ( ) ) ( − ( ) ) − − m i 1 [ ( ) ∂ j ( T ( ) ) θ ( ( ) ) ( − ( ) ) − − m i 1 [ ( ) ( T ( ) ) ( − ( T ( ) ) ) ∂ j T ( ) θ ( ( ) ) − ( − = 1 ∑ = m [ ( ) θ ( ( ) ) ( − θ ( ( ) ) ) ∂ j T ( ) θ ( ( ) ) ( − ( − m i 1 [ ( ) ( − θ ( ( ) ) ) j ( ) ( − − m i 1 [ ( ) ( − θ ( ( ) ) ) ( − = 1 ∑ = m [ ( ) y ( ) θ ( ( ) ) h ( ( ) ) − m i 1 [ ( ) h ( ( ) ) 1 ∑ = m [ θ ( ( ) ) y ( ) ] 4) Advanced Optimization Gradient descent 외에도 optimization algorithm이 여럿 있다. 예를 들면, conjugate gradient, BFGS, L-BFGS 등이다. 이 알고리즘의 장점은 learning rate를 자동으로 골라주며, gradient descent보다 빠른 경우가 많다는 점인데, 복잡하고 이해하기 어렵다. 이 강의에서는 이러한 optimization 알고리즘들에 관해 자세히 다루지는 않고, 간략히 소개만 해주었다. 5) Multi-Class Classification One-vs-All (One-vs-Rest) 예를 들어, 받은 e-mail을 자동으로 분류한다고 하자. E.g. Email foldering/tagging: work y 1 friends y 2 family y 3 hobby y 4 이 경우 binary classifier로는 불충분하다. 이처럼 class 개수가 2개 이상일 때에는 어떻게 하면 될까? One-vs-All (One-vs-Rest) 한 가지 방법은 각 class 별로 해당 class vs 나머지 class로 binary decision을 내리도록 만들고 hypothesis function 값이 가장 큰 것을 고르는 것이다. 이렇게 하면 각 class마다 hypothesis function을 train 할 수 있다. 그런데 hypothesis function이 내보내는 값은 '주어진 가 class 1에 들어갈 확률'로서 해석된다. 따라서, hypothesis function 출력이 가장 크다는 것은 그 class에 들어갈 확률이 가장 크다는 뜻이다. θ ( ) ( ) P ( = | ; ) i { , , } 정리하자면, 각 class에 들어갈 확률 ( = ) 을 구하기 위해 regression classifier θ ( ) ( ) 를 train 한다. 새로운 데이터를 받으면, θ ( ) ( ) 가 최대인 class를 선택한다. 즉, arg max h ( ) ( ) 04. Regularization The Problem of Overfitting Adressing Overfitting Reduce the number of features Regularization The Problem of Overfitting Feature가 너무 많아도 문제가 생긴다. Hypothesis function 너무 복잡해지기 때문이다. 이 복잡한 함수는 training set의 데이터 분포를 거의 똑같이 모델링 할 수는 있을 것이다. ( ( ) 0 ) 그러나 우리의 목적은 training set과 완벽하게 똑같은 모델을 만드는 게 아니라 training set에 없는 새로운 데이터에 대해서 target을 정확하게 예측하는 것이다. 그러나 training data에 지나치게 맞춰진 모델은 오히려 새로운 데이터를 예측하는 데에는 실패할 수 있다. 이와 같이 training data에 지나치게(over) fit 되어 일반적인 추세를 표현하지 못하는 문제를 overfitting이라고 한다. Adressing Overfitting 그렇다면 overfitting을 피하기 위해 어떻게 할 수 있을까. Reduce the number of features 일단은 feature를 너무 많이 사용하지 않는 것이 좋다. 사용할 feature를 수동으로 고른다. Model selection algorithm (later in course) 그러나 feature를 버리기 아까울 수도 있다. 가령, 모든 feature가 조금씩은 traget 예측에 도움이 되는 경우가 있다. 이때에는 feature 개수를 유지하면서 overfitting을 피하는 방법을 쓴다. Regularization이라고 부르는 이 방법은 모델이 너무 복잡해지지 않도록 약간의 제약을 가하는 방법이다. Regularization 모든 feature를 유지하되, parameter j 의 크기를 작게<NAME>다. 많은 feature 가를 예측하는 데에 조금씩 기여하는 경우 유용하다. 1) Cost Function Intuition Regularization Intuition 이때, 3 θ의 값이 커질수록 penalty를 주어보자. 예를 들어 이 값들에 1000을 곱한 값을 cost function에 더해본다. 이로써 이 parameter들의 크기가 작게 유지된다. min 1 m i 1 ( θ ( ( ) ) y ( ) ) + 1000 3 + 1000 4 ⇒ 3 0 θ ≈ 이와 같이 4차 함수 모델을 사용하더라도 2차 함수 모델에 거의 근접하도록 할 수 있다. Regularization Parameters 0 θ, 2. . θ 이 작은 값을 갖도록 한다. "단순한" hypothesis Overfitting 가능성이 적어짐 eg. Housing features: 1 x, . , 100 (We don't know which feature is important) parameters: 0 θ, . , 100 ( ) 1 m i 1 ( θ ( ( ) ) y ( ) ) + ∑ = 100 j min J ( ) 일종의 penalty를 곱해주는 것으로 parameter의 크기를 작게 유지할 수 있다. 그러나 만약 가 너무 크면 (eg. = 10 10 ), j 0 가 되어 이번에는 underfit 문제가 발생한다. 그러므로 적절한 값을 정하는 것이 중요하다. 2) Regularized Linear Regression Regularized Linear Regression Gradient Descent Normal Equation Non-Invertibility 이번에는 regularization을 linear regression에 적용하여 보자. Regularized Linear Regression ( ) 1 m [ i 1 ( θ ( ( ) ) y ( ) ) + ∑ = n j ] min J ( ) Linear regression의 최적의 parameter를 찾는 데에는 gradient descent와 normal equation을 이용하는 두 가지 방법이 있다. Gradient Descent Normal Equation 한편, regularization은 feature 개수에 비해 data 수가 부족할 때 발생할 수 있는 non-invertibility 문제도 해결하는 데에 도움이 된다. Non-Invertibility 3) Regularized Logistic Regression Cost Function Gradient Descent 이번에는 logistic regression에 regularization을 적용한다. Cost Function ( ) − [ m i 1 y ( ) log h ( ( ) ) ( − ( ) ) log ( − θ ( ( ) ) ) ] λ m Gradient Descent 05. Neural Networks Non-linear Hypotheses Neural Networks Neurons and the Brain: The "One Learning Algorithm" Hypothesis Non-linear Hypotheses 지금까지 알아본 linear regression이나 logistic regression으로는 복잡한 데이터를 다루는 데에 한계가 있다. 가령, 다음과 같이 분포하는 데이터에는 non-linear decision boundary가 필요하다. 물론, logistic regression을 이용해서 non-linear boundary를 만들 수도 있긴 하다. 가령, 다음과 같이 3개 feature로부터 만들어낼 수 있는 2차 항들을 포함하는 hypothesis를 만든다고 하자. ( 0 θ x 2 θ x x θ x x + 4 2 + 5 2 3 θ x 2 ) 이 경우, 새로운 6개 feature를 이용한 것으로 볼 수 있다. 즉, 원래 3개 feature를 두 개씩 묶는 가능한 모든 경우의 수 ( + − ) 2 ( − ) = 이 새 feature 개수가 된다 (계산법은 여기 참고). 그런데 만약 원래 feature 개수가 많다면 이런 식으로 하는 데에는 한계가 있을 것이다. 예를 들어, 집값 예측 문제의 경우에 100개 feature가 필요하다고 하자. 이 경우 5,050개라는 어마어마한 양의 새 feature가 생겨난다. 이렇게 되면 사실상의 feature 개수가 기하급수적으로 증가해서 연산량이 늘어날 뿐만 아니라 overfitting의 가능성이 높아진다. 그렇다면 non-linear boundary classification을 할 때 좀 더 효율적인 방법이 없을까. Neural Networks Neural net은 우리의 두뇌가 동작하는 방식을 제한적으로 모방하는 방식으로, 뇌의 신경세포를 모방하는 알고리즘을 개발하는 과정에서 등장했다. 80년대~90년대 초반에 널리 이용되다가 90년대 후반 인기가 시들었으나, 최근 하드웨어 발전에 힘입어 재조명 받고 있다. 현재 다양한 분야에서 state-of-the-art 기술이 되고 있다. Neurons and the Brain: The "One Learning Algorithm" Hypothesis (동물의) 귀와 auditory cortex 사이를 절단해서 거기에 시신경을 연결하면 보는 법을 배운다고 한다. 즉, 뇌가 학습하는 기작은 단 한 가지뿐이고, 어떤 감각기관에서 받은 신호이든 그 '알고리즘'에 따라 지각한다는 가설을 뒷받침하는 증거 중 하나이다. 이러한 성질을 "neuroplasticity"라고 한다. 1) Model Representation Neurons in the Brain Neuron Model: Logistic Unit Neural Network Forward propagation: Vectored Implementation Examples and Intuitions I Examples and Intuitions II Neural Network Learning its Own Features Neurons in the Brain 신경세포를 단순화해 하나의 computational unit으로 생각해 보자. 뉴런은 기본적으로 입력단(dendrites)에 전기 신호 (spikes)를 입력으로 받아 처리해 출력단(axon)으로 전달하는 역할을 한다고 볼 수 있다. Neuron Model: Logistic Unit 생물학적 '뉴런'을 수학적 모델로 나타내어 보자. Dendrite은 input feature 1. . x으로, axon은 hypothesis function의 output으로 표현한다. 이 모델에서 0 은 "bias unit"이라고도 불리며 항상 1의 값을 가지므로 굳이 나타내지 않기도 한다. NN은 classification에서와 마찬가지로 logistic function ( 1 exp ( θ x ) )을 사용하는데, sigmoid (logistic) activation function이라고 부르기도 한다. 이 때의 는 "weights"라고 하기도 한다. 여기까지는 "single neuron"에 관한 모델이다. 이제 뉴런 개수를 늘려보자. Neural Network Neural net을 다음과 같이 나타내어 보자. [ 0 1 2 ] [ ] h ( ) 우리의 첫 번째 node (layer 1) 은 다른 node (layer 2)로 연결되고, 마지막엔 hypothesis function을 통해 output이 계산된다. 첫 번째 layer는 "input layer"라고 하며 마지막 layer는 "output layer"라고 한다. 이 output layer가 최종 계산된 값을 출력한다. input과 output 중간의 layer들은 "hidden layer"라고 한다. 이러한 중간, 혹은 "hidden" layer의 node들을 0 ( ) . . a ( ) 로 나타내고 "activation unit"이라 부른다. Hidden layer가 하나라면, 다음과 같이 나타낼 수 있을 것이다. [ 0 1 2 3 ] [ 1 ( ) 2 ( ) 3 ( ) ] h ( ) i ( ) : "activation" of unit in layer Θ ( ) : matrix of weights controlling function mapping from layer to layer + 각각의 activation node의 값은 다음과 같이 계산한다. 즉, 각 activation node는 3x4 matrix의 paramter에 의해 계산된다. 각 행의 paramter를 input에 곱하여 한 activation node의 값을 구한다. hypothesis output은 activation node 값의 합에 logistic funciton을 적용하여 구하며, 이는 다시 다른 parameter matrix ( ) , 두 번째 레이어의 weights'에 해당하는,에 곱해진다. 각 레이어는 고유한 weight matrix ( ) 를 갖는다. Network가 layer에 j 개 unit을 갖고, layer +에 j 1 unit을 갖는다면, ( ) 의 dimension은 j 1 ( j 1 ) 이다. "+1" 은 "bias node" 0 Θ ( ) 때문에 생긴다. 즉, output node는 bias node를 포함하지 않는 반면 input에는 포함된다. Forward propagation: Vectored Implementation 이번에는 앞의 함수들을 vector로 표현해 보도록 한다. 이를 위해 해 변수 k ( ) 를 정의한다. 이 변수는 ( ) 함수의 변수들을 반영한다. 앞의 예시를 변수를 통해 다시 나타내어 보자. 이제 입력값들을 벡터로 표현하여 간단하게 나타내어 보자. = [ 0 1 x ] z ( ) [ 1 ( ) 2 ( ) z ( ) ] 이때 = ( ) 이라 나타내면, 관계식을 더욱 간단히 나타낼 수 있다. 즉, layer 2에서, ( ) [ 1 ( ) 2 ( ) 3 ( ) ] Θ ( ) = ( ) ( ) 이때, ( ) g ( ( ) ) R이지만, bias unit 0 ( ) 1 을 추가해서 정의하는 편이 일반화하기에 더 좋다. 이제, ( ) R 가 되며, ( ) Θ ( ) ( ) 일반 layer에 대하여 나타내면, ( ) Θ ( − ) ( − ) 최종 vector는 ( − ) 다음 행렬과 모든 activation node에서의 값의 곱으로 구한다. 최종 theta matrix ( ) 는 단 하나의 행을 가지므로, 그 결과는 single number가 된다. 그렇게 최종 결과는 다음과 같이 구해진다. Θ ( ) a ( + ) g ( ( + ) ) 이 예시에서는 Θ ( ) a ( ) g ( ( ) ) 이 마지막 단계에서, layer 와 layer + 사이에서, logistic regression에서 했던 것과 정확히 같은 방식이 쓰이는 점을 주목하자. 이렇게 중간 layer 들을 쌓아 올림으로써 더욱 목잡하고 흥미로운 non-linear hypothesis를 유려하게 생성해낼 수 있다. Examples and Intuitions I 1 AND 2 를 예측하는 neural net 예시를 알아보자. 여기서 AND는 1 x 가 모두 참일 때에만 '참'을 출력하는 논리연산자이다. [ 0 1 2 ] [ ( ( ) ) ] h ( ) 이때의 0 은 bias이며 항상 1값을 갖는다는 점을 염두에 두 자. theta matrix를 다음과 같이 두 자: ( ) [ 30 20 20 ] 이는 우리의 hypothesis가 1 x 가 모두 1일 때에만 양수 값을 출력하도록 할 것이다. 즉, Θ ( ) g ( 30 20 1 20 2 ) 1 0 and 2 0 then ( 30 ) x = and 2 1 then ( 10 ) x = and 2 0 then ( 10 ) x = and 2 1 then ( 10 ) 1 이와 같이, 실제 AND gate를 사용하는 대신 작은 neural net으로 기본 컴퓨터 연산을 수행할 수 있다. Neural net은 다른 논리 게이트를 simulate 하는 데에도 이용할 수 있다. Examples and Intuitions II AND, NOR, OR 연산을 위한 ( ) 행렬은, N : ( ) [ 30 20 20 ] O : ( ) [ 10 20 20 ] R Θ ( ) [ 10 20 20 ] 이들을 조합하여 1 x 가 모두 0 이거나 모두 1일 때에만 '참'을 출력하는 XNOR 연산자를 만들 수 있다. [ 0 1 2 ] [ 1 ( ) 2 ( ) ] [ ( ) ] h ( ) 첫 번째와 두 번째 레이어를 연결하는 ( ) 은 AND와 NOR의 조합을 이용한다. ( ) [ 30 20 20 10 20 20 ] ( ) 는 OR를 이용한다. ( ) [ 10 20 20 ] 각 node에서의 값은 ( ) g ( ( ) x ) ( ) g ( ( ) a ( ) ) Θ ( ) a ( ) 이렇게 hidden layer 2개를 사용해 XNOR 연산자를 만들 수 있다. Neural Network Learning its Own Features ( ) 이라는 hypothesis에 의해 ( ) 라는 새 feature를 생성한 것으로 이해할 수 있다. 2) Cost Function Neural Network (Multiclass Classification) Cost Function Neural Network (Multiclass Classification) Multi-class classification을 하려면 output unit을 class 개수만큼 두면 된다. 가령, 데이터를 4개 클래스로 나누고자 한다면, [ 0 1 2 x ] [ 0 ( ) 1 ( ) 2 ( ) ] [ 0 ( ) 1 ( ) 2 ( ) ] ⋯ [ Θ ( ) h ( ) h ( ) h ( ) ] 마지막 layer는, theta matrix에 곱해져서 새로운 vector가 될 것인데 이 vector는 ( ) logistic function을 적용하여 hypothesis 값을 갖는 vector이다. 한 input에 대한 결과 hypothesis의 예시는 다음과 같다. Θ ( ) [ 0 0 ] 이때 classification 결과는 3번째 클래스, 혹은 Θ ( )에 해당한다. 각 input에 대한 hypothesis의 최종 값은 y의 원소 중 하나가 될 것이다. Cost Function 앞서 공부했던 Logistic regression을 다시 떠올려 보자. Logistic regression은 binary classification을 위해 logistic function을 hypothesis로 취했다. NN 역시 "activation" 과정에서 binary output을 내기 위해 logistic function (or sigmoid function)을 취한다고 생각할 수 있다. 그렇다면 Logistic regression의 cost function과 NN의 cost function은 어떻게 다를까? Logistic regression ( ) − m i 1 [ ( ) log h ( ( ) ) ( − ( ) ) log ( − θ ( ( ) ) ) ] 2 NN의 cost function을 정의하기에 앞서, 필요한 변수들을 정의해 보자. : total number of layers in the network l : number of units (not including the bias unit) in layer K : number of output units/classes NN은 여러 개 output node를 가질 수 있음을 염두에 두 자. Θ ( )를 번째 output의 hypothesis라고 하자. Θ ( ) R , ( Θ ( ) ) = th output 이제 NN은 logistic function이 여러 개인, 좀 더 일반화된 version이라고 생각할 수 있다. ( ) − m [ i 1 ∑ = K k ( ) log ( θ ( ( ) ) ) + ( − k ( ) ) log ( − Θ ( ( ) ) 이 식에는 multiple output nodes를 고려하기 위해 몇 개의 nested summation이 추가되었다. 방정식의 첫 번째 부분인 대괄호([]) 사이에는, ouput node 개수만큼 반복되는 nested summation이 추가되었다. Regularization 항 (대괄호 다음 부분)에는 복수의 행렬을 고려해야 한다. 현재 행렬의 열 개수는 현재 layer의 node 개수 (bias unit 포함)와 같다. 행렬의 행 개수는 다음 layer의 node 개수 (bias unit 제외)와 같다. Logistic regression과 마찬가지로 모든 항에 제곱을 취한다. Note the double sum simply adds up the logistic regression costs calculated for each cell in the output layer; and the triple sum simply adds up the squares of all the individual Θ s in the entire network. the i in the triple sum does not refer to training example i 3) Back-Propagation Algorithm I Gradient Computation Back-Propagation Backpropagation Algorithm Back-propagation은 cost funciton의 최솟값을 찾기 위한 NN 특유의 방법이다. Linear regression과 logistic regression에서 gradient descent가 했던 것과 같은 역할을 한다고 보면 된다. Gradient Computation 늘 그렇듯이 우리의 목적은 cost function을 최소화하는 최적의 parameter를 찾는 것이다. arg min J ( ) 이를 위해 cost function ( ) 를 정의해야 하고, 그 편미분 ∂ i j ( ) ( ) 를 계산해야 한다. ( ) 는 지난번에 정의했다. 그렇다면 편미분 함수는 어떻게 구할까? Back-Propagation Input layer에서 출발해서 output을 구하는 forward propagation 과는 반대로, BP는 output layer에서 시작한다. 즉, 마지막 결과의 'error'를 먼저 구하고, 해당 error 값을 이용해 각각의 node에서의 error를 계산한다. j ( ) "error" of node in layer 이때 j ( ) 은 layer의 activation node 임을 기억하자. 위 예와 같이 layer 개수가 4개인 경우, 마지막 layer ( 번째 layer)의 ( ) 은 단순히 계산된 L 값과 label 값의 차가 된다. ( ) a ( ) y where is the total number of layers and ( ) is the vector of ouptuts of the activation units for the last layer. 이전 layer의 ( ) 값은 (오른쪽에서 왼쪽 방향으로 되돌아가는) 다음 공식에 의해 구한다. ( ) ( ( ( ) ) δ ( + ) ) ∗ ′ ( ( ) ) 이때 ∗ 연산은 벡터의 element-by-element 곱셈을 뜻하고, ′ ( ) z 에 대해 ( ) 를 미분한 함수이다. 한편, ′ ( ( ) ) g ( ( ) ) a ( ) ∗ ( − ( ) ) 로 나타낼 수 있다 1. 즉, ( ) ( ( ( ) ) δ ( + ) ) ∗ ′ ( ( ) ) ( ( ( ) ) δ ( + ) ) ∗ ( ) ∗ ( − ( ) ) Backpropagation Algorithm 위 수식에서 ≠의 경우 i j ( ) := m ( i j ( ) λ i j ( ) ) 이다. 괄호가 빠진 것은 오타이다. 여기서 matrix는 "accumulator"로서 동작한다. 즉, 우리가 구한 값들을 더하고, 궁극적으로 편미분을 구하는 데 이용된다. i j ( ) ∂ ( ) Θ, ( ) (...라고 하는데 솔직히 잘 이해가 안 되는 강의였다. 따로 보충자료를 찾아봐야겠다.) g ( ) z − ( 1 e z ) ∂ z ( + − ) − ( 1 e z ) e z ( 1 ) ( 1 e z ) ( 1 e z ) ( − ) ( 1 e z ) ( − 1 e z ) g ( ) ( − ( ) ) ↩ 4) Back-Propagation Algorithm II Intuition Forward Propagation What is BP doing? External Resources Intuition Forward Propagation What is BP doing? External Resources BP with numerical example 5) Implementation Notes Unrolling Parameters Gradient Checking Numerical Estimation of Gradients Parameter Vector Random Initialization Zero Initialization Random Initialization: Symmetric Breaking Unrolling Parameters Gradient Checking Train이 제대로 되고 있는지 확인하는 방법의 하나이다. Numerical Estimation of Gradients 미분의 정의 자체가 → 일 때 함숫값의 변화량을 의미하는 것이니,에 아주 작은 값을 넣는다면 gradient, 즉, ( ) θ 에서의 접선은 녹색 선의 기울기와 비슷해야 한다. Parameter Vector ∂ θ ( ) 가 numerial estimation 과 비슷한지 확인한다. 일단 train algorithm이 동작하는지 확인하고 나면, 실제 training 전에 gradient checking 부분은 disable 한다. 그러지 않으면 굉장히 느려진다. Random Initialization Gradient descent 또는 advanced optimization 을 사용하기 전에는 어떤 값으로든 초기화해 주어야 한다. Zero Initialization 만약 모든 weight에 0 값을 초깃값으로 넣어주면 어떻게 될까. 한 번 weight를 업데이트할 때마다 같은 입력단에서 나온 weight 들에는 같은 값이 들어간다. (즉, 같은 색으로 표시된 node에는 계속 같은 값의 weight가 들어간다.) Random Initialization: Symmetric Breaking Initialize each i ( ) to a random value in [ ϵ ϵ ] 6) Put it Together Training a Neural Network Training a Neural Network Randomly initialize weights Implement forward propagation to get θ ( ( ) ) for any ( ) Implement code to compute the cost function ( ) Implement backprop to compute partial derivatives ∂ j ( ) ( ) Use gradient checking to compare ∂ J ( ) computed using backprop. vs. using numerical estimate of gradient of ( ) . Then disable gradient checking code. Use gd or advanced optimization method with bp to try to minimize ( ) as a function of parameters . 06. Advice for Applying Machine Learning Evaluating a Learning Algorithm Debugging a Learning Algorithm Evaluating a Learning Algorithm Debugging a Learning Algorithm 예를 들어, housing price를 예측하기 위해 regularized linear regression 을 사용한다고 하자. 그때의 cost function은 다음과 같다. 그런데 이 hypothesis를 새 데이터에 적용하자 예측 에러가 굉장히 컸다. 이때 어떤 방법을 써서 성능을 개선할 수 있을까. 시도해 볼 수 있는 방법들은 다음과 같다. Training example 을 늘린다. Feature 개수를 줄인다. Polynomial feature를 추가한다.를 늘린다 / 줄인다. 그러나 이 방법들을 마구잡이로 시도하기보다는 현재 알고리즘의 어느 부분에서 문제가 있는지 진단해서 체계적으로 알고리즘을 개선하는 편이 훨씬 효율적일 것이다. 1) Machine Learning Diagnostic Evaluating a Hypothesis Model Selection and Training/ Validation/ Test Sets Model Selection Machine Learning Diagnostic A test that you can run to gain insights what is/isn't working with a learning algorithm and gain guidance as to how best to improve its performance. Diagnostic 을 구현하는 데에는 시간이 걸릴 수 있지만 충분히 가치가 있는 일이다. Evaluating a Hypothesis 아래와 같이 4th-order polynomial 을 이용해서 housing price를 예측한다고 해보자. 이때 주어진 training example에 대해서는 거의 완벽한 modeling이 가능하지만 새로운 데이터에 대해서까지 일반화는 하지 못할 수도 있다. 따라서 주어진 데이터를 모두 training example로 사용하지 않고 일부는 training에, 일부는 test에 사용해서 성능을 평가한다. Training/ testing procedure for linear regression Learn parameter from training data (min. training error ( ) ) Compute test set error Model Selection and Training/ Validation/ Test Sets Over-fitting example Training set에 대해서 정한 parameters 0 θ, . θ를 이용해서 계산한 에러 (training error ( ) )는 실제 에러율보다 작을 가능성이 많다. Model Selection 이렇게 계산된 일련의 test ( ) d 5 일 때의 test error가 가장 작아서 0. . θ x를 선택했다고 하자. 이때 test ( ( ) ) 가 model의 일반화 성능을 잘 반영한 것일까? 사실 test ( ( ) ) 는 generalization error의 optimistic estimate 일 가능성이 높다. 왜냐하면 extra parameter는 test set에 대해서 fit 되었기 때문이다. 그러므로 주어진 데이터를 단순히 training/test로 나눌 것이 아니라를 fit 하기 위한 set 역시 만들어야 한다. Training 과 test set의 비율을 약간 줄여서 cross validation set을 만든다. 각 set에서의 error는 다음과 같이 정의한다. Training error train ( ) 1 m i 1 [ θ ( ( ) ) y ( ) ] Cross-validation error cv ( ) 1 m cv i 1 cv [ θ ( cv ( ) ) y cv ( ) ] Test error test ( ) 1 m test i 1 test [ θ ( test ( ) ) y test ( ) ] 조금 전의를 결정하는 문제는 이제 cross validation set을 이용해서 푼다. 이번에는 가령 0. . θ x를 선택했다면, generalization error는 test ( ( ) ) 를 이용하여 계산한다. 2) Bias vs. Variance Diagnosing Bias vs. Variance Regularization and Bias/Variance Choosing the Regularization Parameter Diagnosing Bias vs. Variance Training error와 cross validation error를 다음과 같이 정의하였다. Training error: train ( ) 1 m i 1 [ θ ( ( ) ) y ( ) ] Cross-validation error: cv ( ) 1 m cv i 1 cv [ θ ( cv ( ) ) y cv ( ) ] Polynomial order에 대하여 cv ( ) J train ( ) 를 그려보면 training error는 가 커질수록 줄어들지만 cross validation error는 =에서 최솟값을 갖는다. 어떤 learning algorithm의 성능이 기대한 만큼 나오지 않을 때, 즉 cv ( ) 또는 test ( ) 가 클 때, 문제가 bias 인지 variance 인지 어떻게 판단할 수 있을까? High bias (underfit)는 train ( ) 이 크다. 즉 cv ( ) J train ( ) 인 형태를 띤다. 반면 high variance (overfit)는 train ( ) 은 작은데 cv ( ) 은 큰 것, 즉 cv ( ) J train ( ) 인 것으로 확인할 수 있다. Regularization and Bias/Variance Linear regression with regularization에 대해 생각해 보자. Model: θ ( ) θ + 1 + 2 2 θ x + 4 4 ( ) 1 ∑ = m [ θ ( ( ) ) y ( ) ] + 2 ∑ = n j λ 를 포함한 두 번째 항이 model의 bias와 variance 사이의 균형을 조절한다. 첫 번째 경우처럼 가 너무 크면 두 번째 항이 dominate 하게 되어 underfit 되고, 마지막 경우처럼 가 너무 작으면 regularization 항이 거의 영향을 미치지 못해 overfit 된다. 따라서 가운데 경우와 같이 적절한 를 선택하는 것이 중요하다. 그렇다면 는 어떻게 결정할 수 있을까? Choosing the Regularization Parameter Cross-validation set을 이용해서를 선택한다. Model: θ ( ) θ + 1 + 2 2 θ x + 4 4 ( ) 1 ∑ = m [ θ ( ( ) ) y ( ) ] + 2 ∑ = n j 가령 ( ) 를 선택했다고 하면 test error는 test ( ( ) ) 가 된다. 3) Learning Curves High Bias High Variance Training example 개수에 따라 error 그래프를 그려보는 것으로 overfit/underfit을 진단할 수도 있다. 이러한 그래프를 learning curve라고 한다. High Bias High bias의 특징은, training error와 cv error가 모두 크다는 것이다. Learning algorithm에 high bias 문제가 있으면, 단순히 training data를 더 집어넣는 것은 큰 도움이 되지 않을 것이다. High Variance High variance 가 발생할 경우에는 training error와 cv error의 차이가 크다. Learning algorithm에 high variance 문제가 있으면, training data를 늘리는 것이 도움이 될 가능성이 크다. 4) Deciding What to do Next (Revisited) Neural Networks and Overfitting Housing price를 예측하는 regularized linear regression이 새로운 데이터에 대해 generalize 하지 못한다면, 어떤 방법을 시도할 것인가? Training example 을 늘린다. -> fix high variance Feature 개수를 줄인다. -> fix high variance Feature를 추가한다. -> fix high bias Polynomial feature를 추가한다. -> fix high bias를 늘린다. -> fix high variance를 줄인다. -> fix high bias Neural Networks and Overfitting 07. Machine Learning System Design 이 장에서는 스팸 메일 분류의 예시를 통해 실제 시스템을 구현하는 데에 있어 고려해야 할 사항을 살펴본다. 또한 데이터의 Class 크기가 균등하지 않은 경우에 발생하는 문제와 이때 시스템 성능을 평가하는 방법도 알아본다. 1) Building a Spam Classifier Prioritizing What to Work on Error Analysis The Importance of Numerical Evaluation Prioritizing What to Work on Supervised learning : Features of email : Spam (1) or non-spam (0) label 예를 들면, spam/non-spam 을 구별할 수 있는 단어 100개를 추려서 feature는 그러한 단어가 email에 포함되었는지를 나타내는 vector로 표현할 수 있다. 즉, 그러한 단어가 deal, buy, Andrew (수신자 이름), now,... 등이라면, x = [ 1 1 0 1 ...] 실제로는 수동으로 100개 단어를 뽑기보다는 training set에서 가장 자주 나타나는 단어 n 개 (10,000~50,000)를 선택한다. 어떻게 하면 성능 향상을 효율적으로 할 수 있을까. 데이터를 많이 모은다 (예: "Honey pot" project) Email routing information (from email header)에 기반한 알고리즘을 개선한다. Email 본문에 기반한 알고리즘을 개선한다. 의도적으로 철자를 틀리게 쓴 단어를 검출하는 알고리즘을 개선한다. (예: m0rgage, med1cine, w4tches...) Error Analysis 추천하는 방법 빠르게 구현할 수 있는 간단한 알고리즘으로 시작하자. 구현한 후 cross-validation data로 테스트한다. Learning curve를 그려서 데이터를 늘리거나, feature를 늘리거나, 혹은 다른 어떤 방법이 도움이 될지 결정한다. Error analysis: 에러를 일으키는 데이터(in cross-validation set)를 수동으로 분석한다. 어떤 종류의 데이터가 일정한 경향의 에러를 발생시키는지 관찰한다. 예를 들어, 500개 cross-validation data 중 100개 email이 잘못 분류되었다고 하자. 이 100가지 에러를 확인하여 다음과 같은 기준에 의해 분류한다. (i) What type of email it is (ii) What cues (features) you think would helped the algorithm classify them correctly (i)의 경우, 약팔 이: 12개 짝퉁: 4개 피싱: 53개 기타: 31개 였다면, '피싱'으로 분류된 메일에 대한 성능을 높이는 방법을 찾도록 하는 것이 가장 효과적일 것이다. (ii)의 경우, 의도적인 철자법 오류: 5건 unusual email routing: 16건 unusual punctuation: 32건 이었다면 unusual punctuation 을 검출하는 방법을 찾는 것이 효과적일 것이다. The Importance of Numerical Evaluation discount/discounts/discounted/discounting 등은 같은 단어로 취급해야 할까? "stemming" software (e.g. "Porter stemmer")를 이용하면 그렇게 할 수 있다. 문제는 이러한 소프트웨어는 완벽하지 않고 universe와 university를 같은 단어로 취급하는 등의 에러를 발생시킬 수 있다. Error analysis만으로는 stemming을 하는 것이 성능 향상에 도움이 될지 알기 어렵다. 한 가지 방법은 일단 시도해 보고 되는지 판단하는 것이다. 이때, numerical evaluation (예: cross-validation error)이 필요하다. 즉, stemming을 이용할 때와 이용하지 않을 때의 에러율을 비교하여 결정을 내리면 된다. 2) Handling Skewed Data Precision/ Recall Trading Off Precision and Recall 1 Score (F Score) Arithmetic and harmonic means (optional) Derivation of the F-measure (optional) References Logistic Regression 강의에서 언급했던 cancer classification의 예를 생각해 보자. Logistic regression model θ ( ) 를 이용하여 암이면 = , 암이 아니면 =으로 결정을 내리도록 시스템을 만들었다. 성능을 테스트해봤더니 test set에서의 error가 1%였다. 정확도가 99% 이니, 굉장히 잘 작동하는 알고리즘인 것 같다. 그러나 함정이 있다. 사실 환자의 0.5%만이 실제로 암이라면? 항상 =으로 결정하는 알고리즘만으로도 0.5% 에러율을 달성할 수가 있다. 결국 1% 에러율이 딱히 좋은 성능이 아닐 수도 있다는 말이다. 이렇게 class 별 데이터 수 차이가 많이 나는 데이터를 skewed data라고 한다. 이러한 skewed data의 경우, 에러율만으로는 성능을 정확하게 평가하기 어렵다. Precision/ Recall 에러율 대신 시스템 성능을 평가할 수 있는 metric에는 precision과 recall이 있다. 드문 class를 일반적으로 =로 둔다. Precision =로 결정된 환자들 중 (positive), 얼마만큼이 정말로 암인가? Recall 실제로 암인 환자들 중, 얼마만큼을 찾아내었는가? Trading Off Precision and Recall Suppose we want to predict = (cancer) only if very confident Higher precision, lower recall Suppose we want to avoid missing too many cases of cancer Higher recall, lower precision 최적의 threshold를 어떻게 결정할까? 1 Score (F Score) 이제 성능을 평가하는 데에 2개 숫자가 등장했다. 그러나 최적의 알고리즘을 고르려면 하나의 숫자로 평가하는 것이 편하다. 간단하게 이 두 숫자의 평균을 낼 수도 있을 것이다. Average: + 2 그러나 이 방법은 쓰이지 않는다. 이전에 본 예와 같이, =로 항상 결정하는 알고리즘도 이 점수는 높을 수 있기 때문이다. (Algorithm 3) 대신 F-score가 일반적으로 이용된다. 1 score: P P R 만약 = 또는 = 이면 F-score는 0이 되고, 완벽한 시스템의 경우 = , = 이 되어 F-score가 1이 된다. F-score를 이용하면 Algorithm 1이 최적의 알고리즘으로 선택된다. 이하 내용은 Ng 교수님 강의에서 다루어지지 않은 내용입니다. Arithmetic and harmonic means (optional) F-measure는 precision (P) 과 recall (R)의 harmonic mean이다. = P P R Arithmetic mean A: 일반적으로 말하는 평균 = n i 1 x Harmonic mean H: = ∑ = n x 비율에 관해서는 harmonic mean이 arithmetic mean 보다 직관적이다. 가령, 한 시스템의 precision recall이 각각 1.0 과 0.2라고 하자. 직관적으로, 이 시스템의 성능은 낮게 평가되어야 할 것이다. 이 두 measure의 arithmetic mean은 0.6이고, harmonic mean은 0.3이다. = × 1.0 0.2 1.0 0.2 0.333 Derivation of the F-measure (optional) 앞서 F-measure는 F1-measure라고도 한다고 했다. 여기서 "1"은 무슨 의미일까? F-measure의 full definition은 다음과 같다 (Chinchor, 1992) β ( 2 1 ) R 2 + , ≤ < 여기서 eta는 P와 R 사이의 밸런스를 조절한다. = : 1 은 P와 R의 harmonic mean과 같다. > : more recall-oriented < : more precision-oriented (e.g., 0 P ) References Sasaki, Y. (2007). "The trueth of the F-measure" [Chinchor, 1992] Nancy Chinchor, MUC-4 Evaluation Metrics, in Proc. of the Fourth Message Understanding Conference, pp. 22–29, 1992. http://www.aclweb.org/anthology-new/M/M 92/M92-1002.pdf 3) Using Large Data Sets Data for Machine Learning Large Data Rationale 1 Large Data Rationale 2 Data for Machine Learning Designing a high accuracy learning system 예: Classify between confusable words (? and ?, 2001) {to, two, too}, {then, than}, ... For breakfast I ate ______ eggs. 여러 algorithm을 시도해 보았다. 거의 모든 알고리즘이 training data가 늘어날수록 성능이 향상되어 "약한 알고리즘"도 데이터만 많으면 "강한 알고리즘"만큼의 성능을 내는 것이 가능했다. "It's not who has the best algorithm that wins. It's who has the most data" Large Data Rationale 1 Assume feature ∈ n 1 has sufficient information to predict accurately 예: For breakfast I ate ______ eggs. 반례: Housing price를 평수만으로 예측하기 (아무리 데이터 개수가 많아도 입지, 방 개수 등의 조건 없이 평수만으로 집값을 정확하게 예측하는 것은 어렵다.) 이 조건을 만족하는지 확인하는 유용한 방법 중 하나는 사람(전문가)이 주어 진로를 믿을 만하게 예측할 수 있는가를 따져보는 것이다. Large Data Rationale 2 Use a learning algorithm with many parameters. (예: Logistic/Linear regression with many features; Neural networks with many hidden units) 08. Support Vector Machines Alternative View of Logistic Regression Cost Function SVM Hypothesis Support vector machine (SVM) 은 다른 종류의 supervised learning algorithm으로, logistic regression보다 강력할 때가 있다. Alternative View of Logistic Regression Logistic regression의 hypothesis function을 다시 떠올려보자. If = , then θ ( ) 1 . i.e., T ≫ If = , then θ ( ) 0 . i.e., T ≪ 즉, = 일 때 T ≫로 만들어주고, = 일 때 T ≪으로 만들어주는 를 찾고자 했다. 한 개 training example에 해당하는 cost를 생각해 보자. Logistic regression은 log를 이용해서 cost function을 정의했다. 그러나 SVM은 이와 비슷하지만 piecewise-linear 한 함수를 대신 이용한다. 이 함수를 hinge loss function이라고 부른다. Cost Function 따라서 logistic regression cost function에 새롭게 정의한 cost ( ) cost ( ) 를 대입하면 SVM cost function이 된다. 그 외에도 일반적인 notation을 따르자면, exmple 당 cost의 평균 대신 합을 사용한다. ( m 탈락) 또한 regularization trade-off를 조정하는 계수 대신 = λ 를 사용해 trade-off를 조정한다. SVM Hypothesis SVM의 hypothesis는 가 1이거나 0일 확률로 해석하지 않는다. Hypothesis function의 output 자체는 그냥 1 또는 0이다. 1) Decision Boundary: Large Margin SVM Decision Boundary Mathematics behind Large Margin Classification Vector Inner Product Optimal Decision Boundary Large Margin Classifier in Presence of Outliers SVM 은 다음과 같은 optimization problem이다. T 가 0일 때를 기준으로 classification을 해도 될 텐데 굳이 +1 이상일 때와 -1 이하일 때 decision을 내리도록 했다. 바로 이 부분이 SVM이 margin을 최대화하도록 하는 역할을 한다. Decision boundary의 기울기가 달라도 주어진 데이터를 2개 class로 나눌 수 있지다. 그러나 표시된 선이 선택된 이유는 바로 그 선이 두 class 사이의 margin을 최대화하기 때문이다. 이 장에서는 어떤 원리로 최대 margin을 갖는 boundary를 찾는지 알아본다. SVM Decision Boundary 괄호 안의 수식이 0이 되는 부분이 바로 decision boundary가 된다. 그 부분에 0을 넣고 나면 우리의 최적화 문제는 다음과 같이 단순화된다. 다시 말해, 문제가 요구하는 바는 다음과 같다. 1. 어떤 조건을 만족시키는의 Euclidean norm 을 최소화할 것. 2. 그 조건이란, ( ) 1 일 때에는 T ( ) + 이 되게 하고 ( ) 0 일 때에는 T ( ) − 이 되게 하는 것. Mathematics behind Large Margin Classification 우선 vector의 내적을 잠시 복습하자. Vector Inner Product 즉, 두 벡터의 내적 T는, 벡터 를 에 project 한 벡터의 길이에 벡터의 길이를 곱한 것이다. 이때는 scalar이지만 음수가 될 수도 있다. Optimal Decision Boundary 앞에서 알아본 바와 같이 SVM의 decision boundary를 찾는 것은 다음의 optimization problem을 푸는 것이다. 문제를 단순화하기 위해 bias 0 은 0으로 놓고, 2-dimension feature (feature가 2개)인 경우를 가정하도록 하자. Decision boundary는 를 normal vector로 갖는 hyperplane이므로 decision boundary와는 서로 orthogonal 하다. 만약 내가 찾은 에 해당하는 값이 작다면 ( ) | | ≥ 1 을 만족시키는의 길이는 커져야 한다. 그런데 앞서 기술한 optimization problem은 조건을 만족하는 한 가장 작은 | |를 찾는 것이 목적이라고 했다. 그러므로 최종 결과는 최대 margin의 decision boundary가 된다. Large Margin Classifier in Presence of Outliers 가 아주 크면 outlier에 민감해진다. 녹색 선보다는 회색 선이 prediction에 있어 더 유리할 것이다. 그러므로 너무 크지 않은 값을 적절히 선택하는 것이 중요하다. 2) Kernels Non-Linear Decision Boundary Kernel Choosing the Landmarks SVM with Kernels Non-Linear Decision Boundary 다음과 같은 data에는 non-linear decision boundary가 필요하다. 여기서 SVM classifier가 목표하는 것은 0 θ x + 2 2. . θ x 2 θ x 2. . 0 일 때 = 이 되도록 하는 것이다. 이때 1 x, 1 , 2 , . 와 같은 feature들을 좀 더 일반적인 형태로 표현하기 위해 1 f, .로 고쳐 써보자. 0 θ f + 2 2 θ f + . 이와 같은 x 들은 기존의 feature들 ( 1 x, . )을 모종의 과정을 통해 변환한 새로운 feature라고 볼 수 있다. 이제 이 x 를 어떻게 구하면 non-linear decision boundary를 나타내게 되는지 알아본다. Kernel 우리의 feature space에 임의의 landmark ( ) l ( ) l ( ) 가 있다고 하자. 새로운 feature x 들은 원래 feature가 각 landmark에 얼마나 가까운가를 나타내는 것으로 정의한다. 여기에서는 Gaussian 함수를 예로 들었다. 이 함수는 정규분포 함수와 같이 bell-curve 형태로 landmark에 가까울수록 큰 값을, 멀수록 작은 값을 출력한다. 만약 example 가 첫 번째 landmark에 가깝다면 1 1 이 될 것이고, 그 landmark에서 멀다면 1 0 이 될 것이다. SVM: Predict "1" when 0 θ f + 2 2 θ f ≥ 가령, 0 − 0.5 θ = , 2 1 θ =이라고 하자.는 ( ) 에 가깝고 ( ) l ( ) 에 멀기 때문에 1 1 f ≈, 3 0 이다. 0 θ ⋅ + 2 0 θ ⋅ = 0.5 0 이므로 해당하는 점은 = 영역에 포함된다. 이와 같은 방법으로 여러 위치의 를 입력하여 어떤 값이 출력되는지 계산하면 decision boundary를 구할 수 있다. 이 예시에서의 decision boundary는 노란색 선, 즉 non-linear decision boundary가 된다. Choosing the Landmarks 한 가지 방법은 landmark를 각 training example과 같은 위치에 놓는 것이다. SVM with Kernels kernel을 도입한 새 cost function은 단순히 ( ) 자리에 ( ) 를 넣으면 된다. 꼭 SVM이 아니라도 kernel 개념을 도입할 수 있지만 SVM 외의 classifier에서는 연산속도가 매우 느려진다. 그래서 kernel은 거의 SVM에만 사용된다. 3) Using an SVM SVM Paramters Using SVM Packages Multi-Class Classification Logistic Regression vs. SVMs SVM Paramters Using SVM Packages SVM은 이미 잘 알려진 알고리즘이고 잘 구현된 library가 많기 때문에 굳이 직접 구현해서 사용하기보다는 기존에 구축된 package를 이용하는 편이 낫다. e.g. liblinear, libsvm, ... 명시해야 할 것은 값과 kernel의 종류이다. NOTE| 모든 similarity function sim ( , ) 을 kernel로 사용할 수 있는 것은 아니다. "Mercer Theorem"이라는 조건을 만족해야 SVM package의 optimization 과정이 발산하지 않고 제대로 동작한다. Multi-Class Classification Many SVM packages already have built-in multi-class classification functionality. Otherwise, use one-vs-all method. (Train SVMs, one to distinguish = from the rest, for = , , . , , get ( ) = , ( ) = , . , ( ) = . Pick class with largest ( ( ) ) x Logistic Regression vs. SVMs 09. Unsupervised Learning Unsupervised Learning Unsupervised Learning 지금까지는 supervised learning, 즉, training set의 label이 주어지는 경우에 대하여 알아보았다. 반면, unsupervised learning 은 주어진 label이 없이 training 한다. 예를 들면, 비슷한 특성을 가진 데이터끼리 묶는 clustering이 있다. 1) K-Means Algorithm Intuition Algorithm K-means for non-separated clusters Intuition 주어진 training 데이터 (검은색 점)를 K-means algorithm 을 이용해서 clustering 하는 과정을 알아보도록 한다. 우선 임의의 위치에 cluster centroids (빨간 점, 파란 점)를 초기화한다. 각 데이터를 가장 가까운 centroid에 해당하는 cluster에 배정한다. 배정된 점들은 색깔로 구분하였다. 그다음 각 cluster의 데이터 평균을 구해 centroids를 이동한다. 같은 과정을 새 centroids로 반복한다. 더 이상 변화가 없을 때까지 반복하여 clustering을 마무리한다. Algorithm 위 과정을 pseudo-code로 작성해 보면 다음과 같다. Input: K (number of clusters) training set { ( ) x ( ) . . x ( ) } where ( ) R (drop 0 1 by convention) Procedure: Randomly initialize cluster centroids 1 μ, . , m R Repeat{ for = to (cluster assignment step) c ( ) := index (from to) of cluster centroid closest to ( ) arg min | x ( ) μ | 2 for = to (move centroid step) μ := average (mean) of points assigned to cluster } 이 과정을 반복하다 보면 아무 데이터도 없는 cluster가 생기기도 한다. 일반적으로는 그 cluster를 없애는 것으로 간단히 해결한다. 그런데 이렇게 하면 개가 아니라, − 개 cluster가 된다. 만약 반드시 개 cluster가 필요한 경우에는 새로 random centroid를 만들 수도 있다. K-means for non-separated clusters 어떤 데이터는 cluster를 나누기 애매하기도 하다. 그런 경우에도 어쨌든 clustering을 수행할 수 있다. 의류회사에서 출시할 t-shirt 사이즈를 정할 때를 예로 들 수 있다. 2) Optimization Objective K-means Optimization Objective K-means Procedure K-means algorithm 도 지금까지 공부한 다른 알고리즘과 마찬가지로 objective를 정의할 수 있다. ( ) : index of cluster to which example ( ) is currently assigned k : cluster centroid ( k R) c ( ) : cluster centroid of cluster to which example ( ) has been assigned K-means Optimization Objective 이때 함수를 cost function, 또는 distortion이라고 한다. K-means Procedure Cluster assignment step에서 최적의 ( ) . . c ( ) 을 찾는 것은 각 example ( ) 가 최적의 cluster에 재배정되는 과정으로 이해할 수 있다. 한편, move centroid step에서 ( ) . . μ ( ) 를 구하는 것은 각 cluster를 대표하는 최적값 (여기서는 평균값)을 계산하는 것으로 생각할 수 있다. 3) Random Initialization Local Optima 이번에는 효과적인 초기화 방법을 알아보자. 당연한 이야기이지만, cluster 개수는 데이터 개수 보다 작아야 한다( < ). 한 가지 방법은, 주어진 training example 중 K 개를 centroid로 임의로 선택하고 1. . μ를 그 개 example과 같게 두는 것이다. 운이 좋다면 적당한 centroid를 고르게 되겠지만, 어떤 경우에는 제대로 clustering이 되지 못하는 초기화를 하게 된다. K-means 알고리즘은 초기화에 따라 다른 결과가 나타날 수 있다. 나쁜 경우, local optima에 빠진다. Local Optima 이 문제는 random initialization을 여러 번 하는 것으로 해결한다. 이 중 cost가 가장 작은 clustering을 선택한다. Cluster 개수가 적을수록 local optima에 빠질 확률이 크다. 그러므로, cluster 개수가 적다면 여러 번 초기화해서 고르는 과정을 거칠 것을 추천한다. 4) Choosing the Number of Clusters Elbow Method K-means for a Later Purpose Cluster 개수는 주로 사람이 직접 데이터 분포를 보고 manually 결정한다. 사실 어떤 K가 적절한지에 대한 명확한 답이 없기도 하다. 다음 예에서 cluster를 2개로 나누는 게 적당한가, 아니면 4개로 나누는 게 적당한가? Elbow Method 가장 적절한 K를 고르는 방법이 있긴 하다. K 개수에 따라 cost function를 그려보았을 때, 특정 K 이후 cost가 거의 변하지 않는 elbow point 가 있다면 그 K를 선택하는 것이 합리적일 것이다. 그러나 이 방법이 항상 통하는 것은 아니다. 만약 다음과 같이 변화가 대체로 부드럽다면, elbow라고 부를만한 지점이 없다. 이 경우, elbow method로 K를 정하는 데에는 무리가 있다. K-means for a Later Purpose K-means를 이후 다른 application에 적용하기 위해 사용하는 경우라면, 해당하는 목적을 잘 만족하는지 평가하는 metric을 통해 K를 결정할 수 있다. 예를 들어 t-shirt 사이즈를 결정하는 경우, 예상되는 이익이 극대화되는 사이즈 종류 수를 선택하면 된다. 10. Dimensionality Reduction Motivation Data Compression Visualization Motivation Data Compression Feature dimension 이 쓸데없이 너무 높아 redundancy가 큰 경우, dimension을 줄일 수 있다. Correlation이 높은 feature를 찾고, 그래프를 그려서 두 feature를 동시에 대표할 수 있는 새로운 line을 찾아내는 방법을 쓸 수 있다. Dimensionality reduction으로 컴퓨터 메모리에 저장되는 데이터양을 줄이고 learning algorithm 속도를 높일 수 있다. NOTE: Dimensionality reduction 이란 feature의 개수를 줄이는 것이지 example 수를 줄이는 것이 아니다. 즉, 은 같은 크기이며, 각 example의 feature 개수 이 줄어든다. 예를 들어, 2-dim data를 1-dim data로 줄일 수 있다. Visualization 데이터 차원이 3차원을 넘으면 visualization이 어렵다. 고차원 데이터를 2-dim 또는 3-dim으로 줄여 눈으로 확인할 수 있도록 하는 데에도 사용된다. 즉, 기존 feature를 효과적으로 요약해 주는 새로운 feature 1 z (and perhaps 3 )를 찾는다. 1) Principal Component Analysis Problem Formulation Relationship to Linear Regression PCA Algorithm Data Pre-processing Algorithm 가장 널리 이용되는 dimensionality reduction algorithm 은 Principal Component Analysis (PCA)이다. Problem Formulation 두 feature 1 x 가 있다고 생각해 보자. 우리는 이 두 feature를 모두 효과적으로 나타내는 하나의 선을 찾고 싶다. 이 기존의 feature들을 그 새로운 선에 map 해서 새로운 단 하나의 feature를 찾으려 한다. Reduce from 2-dim to 1-dim: Data를 project 했을 때 그 projection error를 최소로 만드는 벡터 ( ( ) R)를 찾는다. 같은 과정을 3개 feature로도 수행할 수 있다. 이 경우 선 대신 평면에 map 하게 될 것이다. 이와 같이 임의의 n 개 feature를 k-dimensional feature로 줄이는 것으로 일반화할 수 있다. Reduce from n-dim to k-dim: Data를 project 했을 때 그 projection error를 최소로 만드는 개 벡터 ( ( ) u ( ) . . u ( ) )를 찾는다. i.e. project the data onto the linear subspace spanned by the vectors Relationship to Linear Regression PCA와 lin. reg.는 비슷해 보이지만 전혀 다르다. linear regression에서는 각 데이터점과 prediction line 간의 squared error (vertical distance)를 최소화한다. PCA에서는 각 데이터점과 projection line 간의 shortest distance (or orthogonal distance)를 최소화한다. 조금 더 일반화해서 말하자면, linear regression에서는 를 predict 하기 위해의 모든 example을 택해서의 parameters를 적용한다. 그러나, PCA에서는 feature 1 x, . , n 를 택해서 그들 사이에 가장 가까운 공통적인 데이터 셋을 찾는다. 여기서는 어떤 결과를 predict 하지도, feature에 h t weight을 적용하지도 않는다. 또한, lin regression의는 예측해야 하는 특별한 변수이지만 PCA의 1 x 등 사이에는 그러한 구별이 없다. PCA Algorithm Data Pre-processing PCA 하기 전에 data pre-processing이 반드시 필요하다. Given training set: ( ) x ( ) . . x ( ) Preprocess (Feature scaling/ Mean normalization): j 1 ∑ = m j ( ) Replace each j ( ) with j ( ) μ If different features on different scales (e.g. 1 = size of house, 2 = number of bedrooms), scale features to have comparable range of values. i.e. j ( ) x ( ) μ s where j is scaling factor We can define specifically what it means to reduce from 2d to 1d data as follows: = m i 1 ( ( ) ) ( ( ) ) The values are all real numbers and are the projections of our features onto ( ) So, PCA has two tasks: Figure out ( ) u ( ) . . ( ) Find 1 z, . , m The mathematical proof for the following procedure is complicated and beyond the scope of this course. Algorithm Reduce data from n-dim to k-dim Compute "covariance matrix" Sigma = (1/m) * X' * X; % compute the covariacne matrix Covraince matrix를로 표현하였는데, summation과 혼동하지 않도록 주의하자. 여기서 ( ) n 1 vector이고, ( ( ) )는 × vector이며는 × matrix이다. 이 행렬의 곱 연산은 × 행렬이 된다. Compute "eigenvectors" of covariance matrix Covariance matirx는 positive definite이기 때문에 eig = svd [U, S, V] = svd(Sigma); % compute our projected directions SVD는 singular value decomposition을 의미한다. SVD 과정을 통해 covariance matrix의 ∈ n n 행렬을 구하는 것이 목적이다.는 ( ) u ( ) . . ( ) 으로 이루어져 있으며 바로 이 벡터들이 우리가 원하는 것이다. Take the first columns of the matrix and compute 이제 행렬의 첫 번째 개 열을 변수 'Ureduce'에 assign 하자. 이것은 × matrix가 될 것이다. 이 행렬로 를 계산한다. ( ) U reduce ⋅ ( ) r d c T : kxn ( ) : nx1 r d c T x ( ) : kx1 Ureduce = U(:,1:k) % take the first k directions; Z=X*Ureduce; % compute the projected data points 2) Reconstruction from Compressed Representation PCA로 압축한 데이터를 다시 원래대로 돌릴 수 있을까? 1-dim에서 2-dim으로 확장하려면 ∈ → ∈ 2 이 과정은 다음과 같은 방정식으로 나타낼 수 있다: approx ( ) U reduce z ( ) 이렇게 해서 얻어지는 데이터는 원래 데이터의 근삿값임에 주의하자. NOTE: 행렬 는 unitary matrix라는 특별한 성질을 갖는다. Unitary matrix는 다음과 같은 성질을 갖는다. − = ∗ where indicates "conjugate transpose". 우리는 실수로 이루어진 행렬을 다루고 있으므로, − = T 그러므로 이 성질을 이용하여 역행렬을 구해 사용할 수 있긴 하지만, 시간과 자원의 낭비이다... 3) Choosing the Number of Principal Components Criterion Algorithm (Not recommended) Algorithm (Using SVD) Number of principal component 즉,는 어떻게 정할 것인가?는 목표로 하는 차원 수 임을 기억하자. Criterion 다음 공식을 따라서를 선택한다. Averaged squared projection error: m i 1 | x ( ) x approx ( ) | Total variation in the data: m i 1 | x ( ) | 다음을 만족하는 값 중 가장 작은 것을 택한다. m i 1 | x ( ) x approx ( ) | 1 ∑ = m | ( ) | ≤ 0.01 ( % ) 이와 같은 조건을 만족할 때 variance의 99% 가 보존된다고 본다. 필요에 따라 위 수식에서 0.01 대신 0.05, 0.10 등 다른 값을 사용할 수도 있다. 그 경우 보존되는 variance는 95%, 90% 등이다. Algorithm (Not recommended) k를 점차 늘려가며 PCA를 수행하고 위 ratio가 0.01보다 작은지 확인하는 방식은 대단히 비효율적이다. 행렬 연산을 이용하면 이를 훨씬 효율적으로 수행할 수 있다. Algorithm (Using SVD) SVD (Singular Value Decomposition)을 이용하면 k를 구하는 것이 용이하다. 먼저 covariance matrix Sigma를 구한 다음, Sigma에 대하여 SVD를 한다. [U, S, V] = svd(Sigma) 이때, matrix를 이용하면 어느에서 retained variance가 99% 이상이 되는지 확인하는 과정을 더 효과적으로 수행할 수 있다. 즉, 다음 부등식을 만족하는 가장 작은 를 찾는다. i 1 S i i 1 S i 0.99 4) Advice for Applying PCA Supervised Learning Speedup Application of PCA Bad Use of PCA To Prevent Overfitting Unnecessary Dim Reduction Supervised Learning Speedup Feature 수가 아주 많은 supervised learning의 경우를 생각해 보자. 예를 들어, feature dimension이 10,000 인 경우, 연산 속도가 아주 느릴 수밖에 없을 것이다. Dataset: 이때 PCA를 이용해서 feature dimension을 1,000으로 줄이면 훨씬 빠르게 연산할 수 있다. Extract inputs New training set Prediction Note | Mapping ( ) U reduced ( ) should be defined by running PCA only on the training set. This mapping can be applied as well to the examples cv ( ) and test ( ) in the cross validation and test sets. Application of PCA Compression Reduce memory/disk needed to store data Speed up learning algorithm -> Choose by % of variance retain Visualization -> = or = Bad Use of PCA To Prevent Overfitting ( ) 대신 ( ) 을 사용하면 feature dimension 을 줄일 수 있다( < ). 그러면 fit할 paramter 수가 줄어드는 효과가 있으므로 overfitting을 피하는 데에도 좋지 않을까? 그럭저럭 동작할 수도 있다. 그러나 overfitting 문제가 발생했을 때 해결하기에 좋은 방법은 아니다. Overfitting을 피하려면 대신 regularization을 사용하는 것이 좋다. PCA는 정보의 양을 많이 줄이는데, 특히에 상관없이 동작하기 때문에 꼭 필요한 정보를 잃을 수도 있다. 반면 regularization은 label 을 반영하기 때문에 일반적으로 더 나은 결과를 낸다. Unnecessary Dim Reduction Machine learning system 을 설계할 때에 PCA를 포함하는 경우가 종종 있다. 그러나 굳이 처음부터 PCA를 써야 할까? PCA를 구현하기 전에, 우선 원래 데이터 ( ) 를 이용하여 시도해 보자. 원하는 대로 동작하지 않으면 그때 가서 PCA와 ( ) 를 이용하는 것을 고려하도록 하자. 5) Factor Analysis Introduction Types of Factor Anlaysis Exploratory Confirmatory Rotation Orthogonal Rotation Oblique Rotation Formulation Fundamental Equations for Factor Analysis Commonly Encountered Matrices in Factor Analysis Some Important Issues Interpretation of Factors Limitations Theoretical Issues Practial Issues Sample size and missing data Normality Linearity Absense of outliers among cases Absense of Multicollinearity and Singularity Factorability of R Absense of outliers among variables References tip 이 문서는 Ng 교수님 강의에 포함되지 않은 내용을 다루고 있습니다. Introduction PCA 와 비슷한 방법으로 factor analysis (FA)가 있다. 이 기법은 feature의 subset이 서로 independent 한 coherent subset을 구성하도록 하는 데에 이용된다. 이때 각 subset에 속하는 feature들은 서로 correlated 되어 있지만 다른 subset의 feature들과는 independent 하도록 구성하고, 각 subset의 feature는 어떤 "factor"로 합쳐진다. 각 factor는 feature들의 linear combination으로 표현되며 그 외에도 PCA의 compoenent와 여러 가지 공통점이 있지만, factor는 각 feature를 일으킨 일종의 원인으로 간주된다는 점이 다르며 그에 따라 구하는 방식에도 차이점이 있다. 가장 근본적인 차이점은 분석되는 covariance에 있다. PCA FA All the variances in the observed variables are analyzed Only shared variance is analyzed Types of Factor Anlaysis Exploratory Correlate된 변수들을 모아서 요약 -> theory development Confirmatory Latent process에 관한 가설을 검증 -> theory testing Rotation Orthogonal Rotation i.e. factors are uncorrelated A loading matrix is produced + factor-socre coefficient matrix Oblique Rotation Loding matrix -> structure matrix, patterm matrix + factor-score coefficient matrix + factor correlation matrix Formulation Dataset = 1 x, . , n . 이 데이터 셋의 한 데이터 포인트를 latent variable을 이용해서 수학적으로 표현해 보자. i μ W i ϵ 이때, 벡터 i 는 직접 관찰되지 않으므로 "latent"라고 하며, 은 zero-mean, covariance의 Gaussian distribution을 따르는 noise이다.는 어떤 임의의 offset vector이다. 이러한 모델은 "generative"라고 불리는데, i h로부터 어떻게 generate 되는지 기술하고 있기 때문이다. i 가 주어졌다면, 위의 식은 다음과 같은 확률 관계로 해석할 수 있다. ( i h) N ( h + , ) 확률 모델을 완성하려면 latent variable h의 prior distribution 도 알아야 한다. N ( , ) 라고 가정해 보자. 이는 x의 marginal distribution 을 Gaussian 이 되게 한다. ( ) N ( , W + ) Latent variable h 가 superflous (무슨 뜻이지)라는 가정을 할 필요 없이, x는 mean 과 covariance로 완전히 model 될 수 있다. 이 두 파라미터 중 하나에 좀 더 특정한 구조를 가정하자. Error covarinace에 대해 다음과 갗은 가정을 해보자. = 2 : PCA의 확률 모델이 된다. = i g ( 1 ψ, . , n ) : Factor Analysis가 된다. Matrix W는 "factor loading matrix"라고 불린다. 두 모델 모두 low-rank cov. matix로 estimate 한다. 이제 x 와 h의 관계식을 전체 데이터 포인트에 적용하기 위해 matrix 꼴로 확장해 보자. = + H E 이때, 우리는 matrix를 decompose 하는 것이 된다. Fundamental Equations for Factor Analysis Commonly Encountered Matrices in Factor Analysis : Number of variables : Number of subjects : Number of factors (or components) Label Name Rotation Size Description Correlation matrix Orthogonal, oblique × Matrix of correlations between variables Factor loading matrix / Pattern matrix Orthogonal / oblique × Matrix of regression-like weights used to estimate the unique contribution of each factor to the variance in a variable. If orthogonal, also correlations between variables and factors Factor-score coefficient matrix Orthogonal, oblique × Matrix of regression-like weights used to generate factor scores from variables = − A Some Important Issues Interpretation of Factors Loading ( )의 의미는 rotation의 종류에 따라 달라진다. Orthogonal rotation의 경우, loading matrix의 값은 variable과 factor 사이의 correlation이다. 의미 있는 correlation을 결정해서 (일반적으로 0.32 이상) 한 factor에 모인 variable을 고르고 그들을 연결하는 개념을 생각해 볼 수 있다. Oblique rotation의 경우에도 같은 과정을 거치지만의 값에 대한 해석은 그만큼 분명하지 않다. 이때의 값은 correlation 이 아니라 factor와 variable 사이의 유일한 관계에 대한 척도이다. Factor들이 correlate되어 있기 때문에 variable과 factor 사이의 correlation (arailable in the structure matrix) 이 factor들 간의 overlap으로 인해 과장되어 있다. Limitations Theoretical Issues Factor의 개수, rotational scheme 은 theoretical criteria보다는 practical criteria를 따르는 경우가 많음 Complexity: # factors with which a variable correlates ... Practial Issues Sample size and missing data Corr coeff는 small sample로부터 추정되면 less reliable 충분히 많은 데이터 필요하며, 그 양은 population correlation의 크기와 factor 개수에 따라 정해진다. 만약 correlation이 크고 적은 수의 distinct factor가 있다면 sample size가 비교적 적어도 된다. 100-200 acceptable with well-determined factors (i.e. most factors defined by many indicators, i.e. marker variables with loadings >.8) and communalities (squared multiple correlations among variables) in the range of .5 At least 300 cases with low communalities, a small number of factors, and just three or four indicators for each factor. over 500 are required under the worst conditions of low communalities and a larger number of weakly determined factors. Missing data가 있는 경우, missing value가 추정되거나 case가 삭제된다. [Ch 4는 missing value 추정 법에 대해 다룬다]. Missing value estimation procedure 가 data를 overfit할 가능성이 있어 correlation이 너무 높아질 수 있음에 유의하자. 이 과정 자체가 factor를 "create"할 수도 있는 셈. Normality Normality가 어느 정도 지켜지지 않더라도 solution이 어느 정도 degrade 되지만 여전히 worthwhile. Linearity Absense of outliers among cases Absense of Multicollinearity and Singularity Factorability of R Absense of outliers among variables References Tabachnick and Fidell, "Using Multivariate Statistics" Ch. 13 Scikit: Factor Analysis 6) Linear Discriminant Analysis Introduction PCA vs. LDA References tip 이 문서는 Ng 교수님 강의에 포함되지 않은 내용을 다루고 있습니다. Introduction Linear discriminant analysis (LDA)는 많은 machine learning에서 pre-processing으로 이용되는 dimensionality reduction 기법이다. 이는 class-separability를 높게 유지하면서 낮은 차원으로 데이터를 project 하는 것을 목적으로 한다. 이 기법은 Ronald A. Fisher에 의해 정립되었다 (Fisher, 1936). 처음에는 2개 class를 나누는 문제에 대해 적용되었으나 나중에 여러 class에 적용하는 방식으로 확장되었다 (Rao, 1948) LDA는 PCA와 비슷하지만, PCA는 데이터의 분산을 최대로 하는 축을 찾는 데 반해 LDA는 class 사이의 separation을 최대로 하는 축을 찾는다는 점이 다르다. 다시 말해, LDA도 PCA와 마찬가지로 한 feature space를 더 작은 k-dimensional subspace에 project 하는 linear transform 데 이번에는 class-discriminatory information을 보존하면서 줄인다. PCA vs. LDA 간단히 말하자면 PCA는 class label을 무시하고 데이터 셋 전체에 대해 적용하는 "unsupervised" 알고리즘이고 LDA는 class label 정보를 이용하여 각 class를 최대한 분리해 내는 "supervised" 알고리즘이라고 할 수 있다. 이렇게 말하면 LDA가 PCA보다 더 나은 알고리즘인 것처럼 들리겠지만, 항상 그런 것은 아니다. 예를 들어, image 인식에서 LDA와 PCA를 각각 사용한 방식의 classification accuracy를 측정하였을 때, 각 class의 sample 개수가 적으면 PCA를 사용하였을 때의 성능이 더 좋았다. (Martinez et al., 2001) (Sebastian Raschka) References Fisher, 1936 Rao, 1948 Martinez et al., 2001 Sebastian Raschka 11. Anomaly Detection 비행기 엔진을 제작하는 공장에서 불량품을 걸러내는 방법을 개발하려고 한다. 문제가 있는 엔진은 발열이나 진동 정도가 비정상적으로 크거나 작다면, 이들을 측정함으로써 불량품을 검출해낼 수 있을 것이다. 즉, 발열과 진동 세기를 feature로 사용한다. 정상 작동하는 다수의 엔진들(training data)로부터 측정한 feature 값들(빨간 점)과 test 하고 싶은 엔진에서 측정한 feature 값(파란 점)을 비교하여 불량 여부를 판단할 수 있다. 이 장에서는 이와 같은 방법으로 anomaly를 검출하는 방법에 대해서 알아본다. 1) Density Estimation Examples Gaussian Distribution Parameter Estimation Density Estimation Anomaly Detection Algorithm 다음과 같은 데이터를 사전에 수집하였다. 앞서 살펴본 예와 같이 비행기 엔진 정상여부를 판단하기 위해 발열과 진동 정도를 측정하였다면 각 데이터 포인트의 features는 2-dim vector의 형태로 나타낸다. Dataset: ( ) x ( ) . . x ( ) 이때 새로운 데이터 test 가 anomalous 한 지 어떻게 판단할 수 있을까? 수집한 데이터로부터 feature의 확률분포 ( ) 를 모델링 하여 새로운 데이터 test 가 해당 확률분포를 따를 likelihood를 계산하여 이 likelihood가 특정한 threshold 보다 크면 정상, 그렇지 않으면 비정상으로 판단한다. Examples Fraud detection ( ) : 사용자의 행동양식을 기록하는 features 다수의 데이터로부터 ( ) 를 모델링 한다. 각 사용자들이 ( ) ϵ 인지 판별하여 이상행동을 보이는 사용자를 구별한다. Manufacturing Monitoring computers in a data center ( ) : 기기에 관한 features e.g. 1 : memory use, 2 : # disk accesses/sec, 3 : CPU load, 4 : CPU load/network traffic,... Gaussian Distribution Gaussian (normal) distribution 가령 가 실수이고, 평균, 분산 2 인 정규분포를 따른다고 하자. 이러한 랜덤 변수를 ∼ ( , 2 ) 로 나타낸다. Parameter Estimation 주어진 dataset { ( ) x ( ) . . x ( ) }의 ( ) R 가 정규분포를 따른다고 가정하자. 이때의 parameter 와는 다음과 같이 추정한다. Density Estimation Anomaly Detection Algorithm Anomalous example을 판별할 수 있을 것으로 여겨지는 features i 1 i n 를 고른다. 이때 은 feature dimension, 혹은 사용할 feature의 가짓수이다. Parameters 1. . μ, 1 , . , n를 구한다. j 1 ∑ = m j ( ) j = m i 1 ( j ( ) μ) 새 example에 대하여 ( ) 를 구한다. ( ) ∏ = n ( j μ, j) ∏ = n 2 σ exp ( ( j μ) 2 j) ( ) ϵ 이면 anomaly 2) Building an Anomaly Detection System The Importance of Real Number Evaluation Aircraft Engines Example Algorithm Evaluation Anomaly Detection vs. Supervised Learning The Importance of Real Number Evaluation Learning algorithm을 개발할 때 알고리즘을 양적으로 평가할 수 있는 방법이 있으면 feature를 선택하는 등의 결정을 내리기가<NAME> 수월하다. Anomalous/non-anomalous label 데이터가 있다고 하자. 즉, 정상이면 = , 비정상이면 =이라고 표시되어 있다. Aircraft Engines Example 가령, 정상 엔진 데이터를 10,000개, 불량 엔진 데이터를 20개 갖고 있다고 하자. Algorithm Evaluation Fit model ( ) on training set ( ) . . x ( ) On a cross-validation/test example , predict Possible evaluation metrics: Note this is skewed data! True positive, false positive, false negative, true negative Precision/recall F-score Cross-validation set 을 이용하여 parameter 을 정할 수 있다. Anomaly Detection vs. Supervised Learning Label이 있다면 supervised learning 도 가능하지 않을까? 3) Choosing what Features to Use Non-Gaussian Features Error Analysis for Anomaly Detection Example: Monitoring Computers in a Data Center Non-Gaussian Features Feature 가 Gaussian distribution을 따르는 것이 이상적이겠지만, 사실 그렇지 못한 경우가 종종 있다. Non-Gaussian feature를 이용할 때에는 feature를 약간 마사지(?) 해서 Gaussian distribution을 따르도록 할 수 있다. 예를 들어, 아래와 같은 분포를 보이는 feature를 이용할 경우 log 를 취하면 Gaussian에 가까운 분포로 transform 할 수 있다. Logarithm 외에도 polynomial 등을 이용하여 feature transformation을 할 수 있다. Error Analysis for Anomaly Detection Anomaly detection을 할 때 가장 이상적인 경우는 정상 사례 normal p ( normal ) 는 크고 비정상 사례 anomalous p ( anomalous ) 는 작은 것이다. 그러나 실제 상황에서는 정상과 비정상 사례의 ( ) 가 모두 비슷한 범위에 존재, 즉 둘 다 큰 경우가 흔히 발생한다. 이때에는 anomalous 하지만 ( ) 가 큰 경우를 따로 뽑아 자세히 분석하여 새 feature를 고안해 내는 방법을 시도해 본다. Example: Monitoring Computers in a Data Center Choose features that might take on unusually large or small values in the event of an anomaly . 1 = memory use of computer 2 = # disk accesses/sec 3 = CPU load 4 = network traffic 5 = CPU load/network traffic 12. Recommender Systems Problem Formulation Problem Formulation 말똥이는 Netflix나 Watcha에서 제공하는 서비스와 같이 영화 별점을 예상하여 추천하는 알고리즘을 만들려고 한다. 각 사용자가 몇 편의 영화에 대해 0점에서 5점 사이의 별점을 매기면 그에 기반해 새로운 영화를 추천해 주는 시스템이다. 다시 말해, 다음 표와 같은 데이터를 이용해서 각 사용자가 평가하지 않은 영화, 즉 '?' 자리에 들어갈 점수를 예측하는 것이 목표이다. u = 사용자 수 = 4 m = 영화 수 = 5 ( , ) 1 if user has rated movie y ( , ) = rating given by user to movie ( ( , ) 1 인 경우에만 정의됨) 지금까지 다룬 linear regression 등의 기법을 응용해서 말똥이가 시도하는 방법들을 이용해 보자. 1) Content Based Recommendation Problem Formulation Obtimization Objective Gradient Descent Update 말똥이는 먼저 각 영화 별로 어떤 내용이 담겨있는지를 feature로 사용하는 방법을 떠올렸다. 예를 들어 영화가 로맨틱할수록 좋아하는 사용자들이 있고 액션 장면이 많을수록 좋아하는 사용자들이 있을 것이다. 그렇다면 영화가 얼마나 로맨틱한지를 나타내는 feature 1 과 얼마나 액션 장면이 잘 만들어졌는지 나타내는 feature 2 를 이용해서 별점을 예측할 수도 있지 않을까. 좀 더 구체적으로, 각 사용자에 대하여 parameter ( ) R를 결정하기로 한다. Predict user as rating movie with ( ( ) ) x ( ) starts Problem Formulation ( , ) 1 if user has rated movie (0 otherwise) ( , ) = rating by user on movie (if defined) ( ) = parameter vector for user x ( ) = feature vector for movie 사용자 가 영화에 줄 것으로 예상되는 별점: ( ( ) ) x ( ) ( ) = # movies rated by user 기본적으로 lin. regression 문제로 볼 수 있다. ( ) R + Obtimization Objective Gradient Descent Update 2) Collaborative Filtering Problem Motivation Optimization Criteria Collaborative Filtering Optimization Objective Collaborative Filtering Algorithm Problem Motivation 이전에 언급한 방법과 같이 영화 내용을 나타내는 feature를 통해 별점을 예상할 수도 있을 것이다. 그러나 문제는, 그러한 feature를 찾기도 어려울뿐더러 영화가 얼마큼 로맨틱한지 등을 수치화하는 것도 어렵다. 말똥이는 다른 아이디어를 낸다. 다름 아닌 feature를 자동으로 찾아내는 방법이다. 어떻게 하면 feature를 자동으로 찾을 수 있을까? 이번에는 ( ) 값을 미리 알고 있다고 가정해 보자. 그러면 ( ) 값들로부터 각 영화의 1 x를 유추할 수 있다. 그렇다면 ( ) 값은 어떻게 구할까. 답은 의외로 간단하다. 임의의 값을 지정하면 된다. ( ) 를 통해 1 x, . 을 구하고, 그 1 x, .로부터 최적의 ( ) 를 다시 구하는 과정을 반복하다 보면 제법 쓸만한 feature들을 얻게 된다. Optimization Criteria Collaborative Filtering Random initialization 한 후 번갈아가며 최적화하는 것도 가능하다. Optimization Objective 두 optimization을 동시에 하면 훨씬 효율적이다. 여기서는 bias unit 0 1 이 제외되었다. 어차피 feature 자체도 알고리즘이 스스로 결정할 것이기 때문이다. Collaborative Filtering Algorithm 3) Low Rank Matrix Factorization Vectorization Low Rank Matrix Factorization Finding related movies Vectorization Collaborative filtering을 matrix 꼴로 나타내어 보자. Low Rank Matrix Factorization Finding related movies 4) Implementational detail Implementational Detail: Mean Normalization Implementational Detail: Mean Normalization = , ( ) R 별점을 하나도 매기지 않은 사람은 모든 영화에 '0점'을 줄 것이라고 예측하는 것은 별로 유용하지 않다. 13. Large Scale Machine Learning 이전에 들었던 예시 Classify between confusable words eg. {to, two, too}, {then, than}, ... For breakfast I ate ______ eggs. --> Low-bias algorithm & large data set 즉, 정교한 classifier를 설계하는 것 이상으로 많은 데이터를 이용하는 것이 효과적이다. It's not who has the best algorithm that wins. It's who has the most data 그렇다면 그러한 대량의 데이터를 이용한 학습은 어떻게 하는 것이 효율적일까. 1) Gradient Descent with Large Datasets Learning with Large Datasets Stochastic Gradient Descent Linear Regression with Gradient Descent Batch Gradient Descent vs. Stochastic Gradient Descent Minibatch Gradient Descent Stochastic Gradient Descent Convergence Checking for Convergence Learning with Large Datasets 알고리즘이 high variance인 경우에는 큰 dataset이 도움이 된다. 그러나 high bias인 경우에는 데이터를 추가하는 것이 아무 도움을 주지 않는다. Dataset은 100,000,000 개 example에 이를 수도 있다. 이때, gradient descent를 수행하려면 1번 iteration 돌 때마다 100,000,000 번의 덧셈을 해야 한다. = 100 000 000 Gradient descent: j := j α m i 1 ( θ ( ( ) ) y ( ) ) j ( ) 이는 어마어마한 연산량을 의미하므로 이렇게 많은 데이터가 과연 꼭 필요한지를 확인하는 것이 좋다. 가령, 임의로 뽑은 = , 000 subset 만으로 충분히 학습이 가능하다면 굳이 그 모든 데이터를 사용하지 않아도 된다. 이는 learning curve를 그려봄으로써 확인할 수 있다. 데이터를 더 넣어주어도 더 이상 성능 개선이 없는 high bias 형태라면 적당량 이상의 데이터를 넣어줄 필요가 없다. Stochastic Gradient Descent Stochastic gradient descent는 classic (or batch) gradient descent를 대신할 수 있는 방법이며 큰 dataset로 scalable 한 효율적인 방법이다. Linear Regression with Gradient Descent Hypothesis h ( ) ∑ = n j j Cost function J train ( ) 1 m i 1 ( θ ( ( ) ) y ( ) ) Gradient Descent Repeat{ j := j α m i 1 ( θ ( ( ) ) y ( ) ) j ( ) (for every = , , ) } 이 크면 매 iteration마다 계산량이 크고 메모리를 많이 잡아먹는 문제가 생긴다. Batch Gradient Descent vs. Stochastic Gradient Descent Batch gradient descent Stochastic descent cost ( , ( ( ) y ( ) ) ) 1 ( θ ( ( ) ) y ( ) ) How well my hypothesis doing on a single example ( ( ) y ( ) ) train ( ) 1 m i 1 ( θ ( ( ) ) y ( ) ) J train ( ) 1 ∑ = m cost ( , ( ( ) y ( ) ) ) Repeat{ Missing open brace for subscript Missing open brace for subscript (for every = , , ) } 1. Randomly shuffle dataset 2. Repeat{ e.g., 10 times for = , , { Missing open brace for subscript Missing open brace for subscript (for = , , ) } } Minibatch Gradient Descent Batch gd: Use all examples in each iteration Stochastic gd: Use 1 example in each iteration Mini-batch gd: Use examples in each iteration where < is the mini-batch size (eg. = 10 ) Stochastic Gradient Descent Convergence To make sure its convergence To choose the learning rate Checking for Convergence Batch Gradient Descent: Plot train ( ) as a function of the number of iterations of gradient descent train ( ) 1 m i 1 ( θ ( ( ) ) y ( ) ) Stochastic Gradient Descent: cost ( , ( ( ) y ( ) ) ) 1 ( θ ( ( ) ) y ( ) ) During learning, compute cost ( , ( ( ) y ( ) ) ) before updating using ( ( ) y ( ) ) Every 1,000 iterations (say), plot cost ( , ( ( ) y ( ) ) ) averaged over the last 1,000 examples processed by algorithm. 2) Advanced Topics Online Learning Other Online Learning Example Map Reduce and Data Parallelism Map Reduce Map-Reduce and Summation over the Training Set Multi-Core Machines Online Learning 예를 들어, 한 택배 회사 웹사이트에서 출발지와 배송지를 입력하면 배송비 견적을 제시해 준다고 하자. 사용자들은 해당 택배 서비스를 이용하기로 결정할 수도 있고 ( = ) 아닐 수도 있다 ( = ). Feature 는 사용자 정보, 출발지, 배송지, 그리고 견적가 등이 될 수 있다. 이때, 최적의 가격을 알아내기 위해 ( = | ; ) 를 구하고자 한다. Logistic regression을 이용하면 다음과 같다. 일반적인 logistic regression과 다른 점이라면 하나의 example 마다를 업데이트하고 한 번 사용한 example은 버린다는 점이다. 이 방법을 사용하면 변화하는 사용자 성향에 맞춰 최적화할 수 있다. Other Online Learning Example Product search (learning to search) : User searches for "Android phone 1080p camera" Have 100 phones in store. Will return 10 results. : feature of phone, how many words in user query match name of phone, how many words in query match description of phone, etc, ... : 1 if user clicks on link, 0 otherwise Learn ( = | ; ) Predicted click-through rate (CTR) Use to show user the 10 phones they're most likely to click on Other examples: Choosing special offer to show user Customized selection of news articles Product recommendation ... Online learning은 stochastic gd와 비슷하지만, fixed set이 아닌 continuous stream으로 data 받으며 각 example 한 번 쓰고 버린다는 점이 다르다. Map Reduce and Data Parallelism Map Reduce Batch gradient descent j := j α 400 i 1 400 ( θ ( ( ) ) y ( ) ) j ( ) Map-Reduce and Summation over the Training Set Many learning algorithms can be expressed as comuting sums of functions over the training set eg. For advanced optimization, with logistic regression, need train ( ) − m i 1 ( ( ) log h ( ( ) ) ( − ( ) ) log ( − θ ( ( ) ) ) ∂ j train ( ) 1 ∑ = m ( θ ( ( ) ) y ( ) ) j ( ) Multi-Core Machines 14. Application Example: Photo OCR A-1. Probability and Likelihood Distinguishing Likelihood from Probability Using the Same Function "Forwards" and "Backwards" Bayesian Inference 참고 자료 머신러닝을 공부하다 보면 probability와 likelihood라는 말이 많이 나온다. 일상 언어에서는 비슷한 뜻을 지니지만 전문용어로 쓰일 때에는 서로 다른 것을 의미한다. Distinguishing Likelihood from Probability Probability는 possible result에 결부된 것이고 likelihood는 hypothesis에 결부된 것이다. Possible result는 mutually exclusinve 하고 exhaustive 하다. 동전 던지기를 10번 해서 어느 면이 나올지 추측한다고 해보자. 단 11가지의 possible results가 있다 (0~10 번의 맞는 예측). Actual result는 possible result 중 단 하나의 경우이다. 즉, possible results에 결부된 probability는 언제나 합이 1이 되어야 한다. Hypothesis는 result와는 다르게, mutually exclusive 하지도 않고 exhaustive 하지도 않다. 가령, 첫 번째 실험자가 10번 중 7번 맞았다고 하자. 이를 실험자가 그저 찍었다고 hypothesis를 만들 수도 있고 실험자에게 일종의 초자연적인 능력이 있어 단순히 찍는 것보다는 조금 더 정확도가 높다고 hypothesis를 만들 수도 있다. 혹은 실험자의 초자연적 능력이 실험 결과에 나타난 것보다 더 크다는 가설을 세울 수도 있다. 서로 다른 가설들이지만 mutually exclusive 하지 않다. 어떤 가설이 다른 가설을 포함할 수도 있다. Likelihood와 결부시킬 수 있는 hypothesis의 가짓수는 우리의 상상력에 달려있을 뿐이다. 모든 가능한 가설을 세워보았다고 확신하기는 어렵다. 그보다는 실험 결과가 각 가설의 상대적인 likelihood에 얼마만큼의 영향을 미치는가가 관심사이다. Hypothesis에 결부되는 likelihood는 그 자체로 아무 의미가 없고 상대적인 값, 즉 한 likelihood의 다른 하나에 대한 비율에 의미가 있다. Using the Same Function "Forwards" and "Backwards" Probability와 likelihood의 차이는 probability distribution function을 이용하면 더 명확해진다. 동전을 던지는 것과 같이 성공/실패로 이분법적 결과가 나오는 binomial 시행을 예로 들어보겠다. 이때, 가능한 '성공' 횟수를 변수로 하여 probability를 구하게 된다. 시행할 횟수 (동전을 몇 번 던질 것인가)와 성공 확률 (예측한 동전의 면이 나올 확률이 얼마인가)는 확률분포의 parameter로, 이 parameter 값들에 무관하게 각 경우에 대한 probability의 합은 1이 되어야 한다. 이 parameter가 고정되었을 때, possible number of success 별로 그 probability을 계산한다. (그림 1 상단) 반면, likelihood를 구할 때 주어지는 것은 '성공'한 횟수 (예측한 면이 나온 횟수)와 시행한 횟수 (동전을 몇 번 던졌는가)이다. 다시 말해 이번에는 result가 parameter로 여겨지는 것이다. 이번에는 예상되는 성공 횟수가 변수가 되는 대신 성공할 확률이 변수가 된다. 어떻게 생각하면 probability를 구하는 것의 역방향 연산이라고 볼 수도 있다. (그림 1 하단) (그림 1. Figure from R. Gallistel. ) 이러한 binomial likelihood function은 대단히 직관적이다. 만약 10번 시행에서 7번 성공하였다면, binomial distribution에서의 probability parameter (the distribuion of succesful predictions from this subject)가 0.1이 되기는 아주 어렵다. 0.7일 가능성이 더 높지만 0.5도 완전히 가능성이 없지는 않다. = 0.7 일 likelihood는 0.27이고, = 0.5 일 likelihood는 0.12인데, 이 비율은 겨우 2.28이다. 즉, 주어진 실험 결과에 비추어 해당 실험자의 long-term 성공률이 0.5이라는 가설보다 0.7이라는 가설이 더 맞을 가능성은 2배 정도이다. Data science에서 hypothesis는, 위 예에서 본 바와 같이, 특정 분포의 평균값의 가능한 값, 혹은 그 범위를 말한다. Bayesian Inference posterior likelihood prior model evidence ( | ) P ( | ) ( ) ( ) : Hypothesis. Data (or evidence) 영향을 받는 가설 무엇이든. 일반적으로, 여러 개의 경합하는 가설이 존재하고 그중 가장 가능성이 높은 것을 고른다. : Evidence or data. Prior probability를 계산하는 데 이용되지 않은 새 observation. ( ) : Prior probability. Current evidence를 관찰하기 전이 미리 계산된 hypothesis H의 추정 값. ( | ) : Posterior probability. Observed data E가 주어졌을 때의 hypothesis H 일 확률. 이 확률을 계산하는 것이 목적이다. ( | ) : Likelihood. H가 주어졌을 때 E를 관찰할 확률. H가 고정되었을 때의 E에 대한 함수로, 주어진 가설에 대한 evidence의 compatibility를 나타낸다. Posterior probability가 H에 대한 함수인 반면 likelihood는 E에 대한 함수이다. ( ) : Marginal likelihood or model evidence. 모든 가설을 고려해서 계산한 확률로, 어떤 가설에든 동일하게 적용되므로 가설 간의 비교에는 영향을 미치지 않는다. ( ) ∑ P ( | k ) ( k ) ( | , ) P ( | , ) ( | ) P ( | , ) ( | ) θ Likelihood는 probability가 만족해야 하는 몇 가지 조건을 만족하지 못한다. Assume fixed, chosen model m, P ( | , ) X 1 In this case, probability density Bayesian inference에서는 변하고, 이 고정. 즉, ( | , ) P ( | , ) − ∞ ( | , ) θ ( ∞ + ) 참고 자료 "Bayes for Beginners: Probability and Likelihood" by C. RANDY GALLISTEL https://en.wikipedia.org/wiki/Bayesian_inference https://www.youtube.com/watch?v=sm60vapz2jQ https://towardsdatascience.com/probability-concepts-explained-bayesian-inference-for-parameter-estimation-90e8930e5348 A-2. AdaBoost 참고 자료 Wikipedia: AdaBoost "Boosting and AdaBoost for Machine Learning" A-3. Gaussian Mixture Model Gaussian mixture model (GMM)은 임의의 분포를 여러 개 Gaussian 분포의 weighted sum으로 표현하는 방법이다. A-4. Feature Selection<|endoftext|>

전문분야 텍스트 ### 제목: 위키독스 ### 본문: Since 2008 위키독스는 온라인 책을 제작<NAME>는 플랫폼 서비스입니다. 누구나 위키독스에서 책을 만들 수 있습니다. 주요 이력 아무거나 질문 위키독스 디스코드 https://discord.gg/zPERvk7pza 01 위키독스의 특징 위키독스는 일반 책들과는 다른 많은 특징들을 가지고 있습니다. 간결함 살아있는 책 목차 저자와의 교류 고유 URL 알림 기능 공동작업 기능 백업 변경 이력 수익 앱 (App) 간결함 서비스 전반에 걸쳐 간결함을 염두에 두고 제작했습니다. 독자가 문서 읽기에 집중할 수 있도록 만들었습니다. 살아있는 책 종이책은 한번 인쇄되면 그 내용을 변경할 수 없습니다. 하지만 위키독스 책은 독자와 상호작용하며 발전합니다. 책의 내용은 실시간 업데이트되며, 이를 통해 독자는 항상 최신 정보를 얻을 수 있습니다. 목차 위키독스 책은 목차를 갖게 됩니다. 어떤 페이지에서도 목차를 볼 수 있으며 해당 페이지로의 이동이 쉽습니다. 저자와의 교류 위키독스 책은 페이지마다 하단에 피드백 또는 댓글을 달 수 있는 기능이 있습니다. 피드백과 댓글을 통해 작가와 독자는 상호 의사소통하여 문서를 더욱 좋게 발전시켜 나갑니다. 고유 URL 위키독스 책은 페이지별로 고유한 URL이 있어 다른 사람 또는 익명의 독자에게 링크로 전달하기 용이합니다. 알림 기능 독자가 댓글 또는 피드백을 작성할 경우 저자에게 이메일로 해당 내용이 전달됩니다. 공동작업 기능 책 단위로 공동 저자를 설정하여 여러 명이 함께 책을 만들어 갈 수 있습니다. 백업 "책 다운로드" 기능을 이용하여 책 전체를 백업 받을 수 있습니다. 변경 이력 "변경 이력" 화면에서 페이지의 특정 버전으로 되돌리기를 할 수 있습니다. 수익 저자는 전자책을 출간하거나 책에 광고를 게시하여 수익을 낼 수 있습니다. 앱 (App) 안드로이드, 아이폰의 위키독스 앱을 이용하면 모바일 환경에서 더욱 편리하게 위키독스 책을 읽을 수 있습니다. 02 위키독스 FAQ 저자가 되려면 어떻게 해야 하나요? 목차 페이지 순서를 어떻게 바꾸나요? 제목을 역순으로 정렬할 수 있나요? 위키독스에서 작성한 책을 다른 출판사에서 "종이책"으로 출판하고 싶습니다. 위키독스의 수익모델은 무엇인가요? 등록한 광고가 아닌 다른 광고가 표시됩니다. 티스토리에서 애드센스 계정을 승인받았습니다. 하지만 승인된 애드센스 스크립트를 저장해도 광고가 표시되지 않습니다. 위키독스에서 작성한 책을 출판하게 될 경우, 출판사에서 위키독스의 글을 모두 내리기를 요구하는 상황이 오면 어떻게 되나요? 위키독스에서 전자책을 판매하고 싶습니다. 위키독스 앱이 있나요? 위키독스에는 OpenAPI가 있나요? 책 표지 이미지 크기는 어떻게 해야 하나요? 위키독스에서 전자책을 구입했습니다. 그런데 내려받은 전자책을 분실했습니다. 무료로 전자책 재발송이 가능한가요? 위키독스 계정 탈퇴를 원합니다. 책을 공개해도 표시되지 않습니다. 저자가 되려면 어떻게 해야 하나요? 위키독스에서 저자가 되기 위한 특별한 절차는 없습니다. 회원가입 후 다음과 같은 순서로 책을 작성하면 됩니다. 위키독스 -> 로그인 -> 계정 설정 -> 나의 책 -> 새 책 만들기 목차 페이지 순서를 어떻게 바꾸나요? 위키독스의 목차는 이름순으로 정렬됩니다. 따라서 목차를 원하는 순서대로 정렬하려면 제목 앞에 숫자 등을 삽입하여 정렬해야 합니다. 윈도(Windows) 탐색기의 정렬 방식과 동일합니다. 제목을 역순으로 정렬할 수 있나요? 제목을 역순으로 정렬할 수 있습니다. 역순 정렬 기능은 보통 블로그 문서를 작성할 경우 유용하게 사용할 수 있습니다. 예를 들어 제목의 앞부분에 날짜를 삽입하여 날짜의 역순으로 정렬이 가능합니다. [책 수정 -> 기타 -> 역순 정렬을 사용합니까?] 항목을 "예"로 활성화하면 됩니다. 위키독스에서 작성한 책을 다른 출판사에서 "종이책"으로 출판하고 싶습니다. 위키독스에서 작성된 책의 저작권은 위키독스가 아닌 저자에게 있습니다. 따라서 저자는 원할 경우 다른 출판사에 위키독스에 올린 글을 책으로 출판할 수 있습니다. 전자책 출간을 원하실 경우에는 위키독스에서 전자책을 출간할 수 있습니다. 위키독스 전자책 출간 : https://wikidocs.net/150 위키독스의 수익모델은 무엇인가요? 위키독스는 책에 구글 광고를 게시하여 수익을 냅니다. (광고의 표시 비율은 저자의 광고 90%, 위키독스 광고 10%로 배분됩니다. 활성화된 애드센스 계정이 없는 저자의 경우 위키독스 포인트 광고를 사용하여 수익을 창출할 수 있습니다.) 전자책을 판매하여 수익을 냅니다. (전자책의 수익은 저자 80%, 위키독스 20%로 배분됩니다.) 등록한 광고가 아닌 다른 광고가 표시됩니다. 저자가 등록한 광고와 위키독스의 광고가 9 대 1의 비율로 번갈아 가면서 표시됩니다. (2017년 5월부터) 티스토리에서 애드센스 계정을 승인받았습니다. 하지만 승인된 애드센스 스크립트를 저장해도 광고가 표시되지 않습니다. 다음을 참고하여 애드센스 스크립트를 작성하세요. https://wikidocs.net/151142 위키독스에서 작성한 책을 출판하게 될 경우, 출판사에서 위키독스의 글을 모두 내리기를 요구하는 상황이 오면 어떻게 되나요? 위키독스에 게시된 글은 위키독스에 어떠한 소유권이나 저작권도 없습니다. 따라서 저자는 위키독스의 글을 삭제 또는 비공개 처리하면 됩니다. 위키독스에서 전자책을 판매하고 싶습니다. 위키독스는 현재 몇 가지 기술적인 문제로 신규 전자책 발간을 중지한 상태입니다. 문제가 해결되면 공지를 통해 다시 알려드리도록 하겠습니다. 다음 페이지를 참고해 주세요. https://wikidocs.net/150 위키독스 앱이 있나요? 안드로이드, 아이폰 앱이 있습니다. (갤럭시 탭이나 아이패드 등에서도 잘 동작합니다.) 위키독스 앱 자세히 보기 위키독스에는 OpenAPI가 있나요? 네, 있습니다. 위키독스 API 자세히 보기 책 표지 이미지 크기는 어떻게 해야 하나요? 책 표지의 이미지는 100 x 130 비율로 작성해 주세요. 위키독스에서 전자책을 구입했습니다. 그런데 내려받은 전자책을 분실했습니다. 무료로 전자책 재발송이 가능한가요? 위키독스에서 판매한 전자책은 최대 3회까지 무료로 재발송 해드립니다. 다음의 URL에서 직접 재발송 신청을 할 수 있습니다. https://wikidocs.net/buy/gbook/ 위키독스 계정 탈퇴를 원합니다. 위키독스 계정 탈퇴는 현재 사용자 기능(탈퇴 메뉴 등)으로 제공하고 있지 않습니다. 아래의 이메일로 탈퇴를 희망한다는 메일을 주시면 24시간 내로 탈퇴 처리해 드립니다. <EMAIL> 책을 공개해도 표시되지 않습니다. 위키독스 홈의 "공개" 탭에는 공개 책들이 노출됩니다. 하지만 최소 5페이지 이상의 분량을 지닌 책만 표시됩니다. 그리고 스팸 저자(광고 및 신고 접수 등)로 등록된 저자의 책인 경우에도 표시되지 않을 수 있습니다. 이외의 경우에 본인의 책이 공개 책에 노출되지 않을 경우 <EMAIL>으로 연락 주시면 조치해 드리겠습니다. 03 위키독스 가이드 위키독스의 저자가 되어 책을 만드는 방법과 편집기를 다루는 방법에 대해서 설명합니다. 03-1 책 만들기 위키독스에서 책을 만드는 방법에 대해서 설명합니다. 01) 로그인 (회원가입) 로그인 회원가입 로그인 위키독스 홈페이지에 접속하여 우측 상단의 로그인 링크를 클릭합니다. 로그인 화면에서 구글 또는 페이스북 계정으로 로그인합니다. 회원가입 또는 "계정을 만드세요"를 클릭하여 "이메일 + 비밀번호" 형태의 계정을 생성할 수 있습니다. 계정을 신규로 생성할 경우, 구글이나 페이스북에서 사용하는 이메일 주소로 가입했다면 구글 또는 페이스북으로 로그인 시 서로 다른 계정이 아닌 단일 계정으로 취급된다는 점에 유의해 주세요. (다른 방식으로 로그인하더라도 동일한 사용자로 접속됨) 02) 새 책 만들기 이번에는 위키독스에서 새 책을 만드는 방법에 대해서 알아보겠습니다. 계정 설정 새 책 만들기 편집 화면 계정 설정 위키독스에 로그인하면 다음과 같은 상단 메뉴가 보입니다. 여기서 "계정 설정" 링크를 클릭합니다. 새 책 만들기 "나의 책" -> "새 책 만들기"를 선택하여 새로운 책을 생성합니다. 편집 화면 그러면 다음과 같이 새로운 책이 생성되고 책을 편집하는 화면으로 이동합니다. 03) 책 수정, 페이지 수정 위키독스에서 책을 수정할 때는 "책 수정", "페이지 수정" 두 가지 편집모드가 있습니다. 두 가지 편집 모드에 대해서 자세히 알아보겠습니다. 책 수정 기본 저작권 공동 저자 광고 기타 책 백업 책 삭제 페이지 수정 책 수정 책 수정은 책에 대해 설정하는 곳입니다. 편집기 화면에서 좌측의 목차 중 가장 상단의 책 제목에 해당하는 항목을 선택하면 위와 같은 책 수정 화면이 나타납니다. 목차 중 가장 상단이 아닌 다른 항목을 선택할 경우에는 페이지 수정 화면이 나타납니다. 기본 기본 탭은 책의 기본적인 사항을 설정하는 곳입니다. 책 수정의 기본 탭에서는 다음과 같은 항목을 설정할 수 있습니다. 책 제목 : 책 제목을 설정합니다. 책 이미지 : 책의 이미지를 업로드합니다. 업로드하여 저장한 후에는 네모 박스를 통해 이미지의 특정 영역을 선택하여 저장할 수 있습니다. 공개/비공개 : 책을 공개 또는 비공개로 설정합니다. 책 요약 : 책에 대한 설명과 개요를 작성할 수 있습니다. 책 요약의 내용은 마크다운 문법으로 작성합니다. 마크다운에 대한 자세한 내용은 마크다운 페이지를 참고하세요. 저작권 저작권 탭은 이 책의 저작권을 설정하는 곳입니다. 저작권은 CCL(Creative Commons License) 방식과 직접 입력 방식을 선택할 수 있습니다. CCL 방식은 위 화면과 같이 선택하여 저장할 수 있습니다. 직접 입력 방식은 라이선스 명과 라이선스에 대해서 확인할 수 있는 URL을 입력하여 저장할 수 있습니다. 공동 저자 공동 저자 탭은 공동 저자를 설정하는 곳입니다. 이름 또는 이메일로 검색하여 공동 저자를 추가할 수 있습니다. 빨간색은 이 책의 메인 저자를 의미하고 파란색은 이 책의 공동 저자를 의미합니다. 공동 저자는 여러 명을 추가할 수 있습니다. 추가한 공동 저자를 취소하고 싶을 때는 파란색으로 추가된 공동 저자의 우측의 "x" 버튼을 클릭하여 공동 저자를 취소할 수 있습니다. 광고 광고 탭은 광고를 설정하는 곳입니다. 다음과 같은 항목을 설정할 수 있습니다. 광고를 표시합니까? : 광고를 표시할지 여부를 설정합니다. 위키독스 포인트 광고를 사용합니까? : 위키독스 포인트 광고를 사용할지 여부를 설정합니다. 광고 내용(PC, 하단) : 위키독스를 PC로 접속했을 경우 하단에 표시할 광고 스크립트를 적는 공간입니다. 광고 내용(PC, 우상단 고정) : 위키독스를 PC로 접속했을 경우 우측 상단에 표시할 광고 스크립트를 적는 공간입니다(이 광고는 항상 고정되어 표시되는 광고입니다). 광고 내용(모바일) : 위키독스를 스마트폰으로 접속했을 경우에 표시할 광고 스크립트를 적는 공간입니다(페이지 하단에 광고가 표시됩니다). 광고에 대한 보다 자세한 내용은 다음을 참고하시기를 바랍니다. 위키독스 광고 - https://wikidocs.net/9346 기타 기타 탭은 엔터키 줄 바꿈, 역순 정렬 등을 설정하는 곳입니다. 다음과 같은 항목을 설정할 수 있습니다. 엔터키 줄 바꿈을 사용합니까? : 위키독스는 글 작성 시 엔터키를 입력하더라도 줄 바꿈이 이루어지지 않습니다. 마크다운은 줄 바꿈을 위해 줄의 마지막에 스페이스 키를 2번 강제로 입력해야만 줄 바꿈이 표시됩니다. 하지만 이 항목을 사용하도록 설정하면 엔터키를 입력했을 때 자동으로 줄 바꿈이 됩니다. 역순 정렬을 사용합니까? : 위키독스의 목차는 제목을 기준으로 순서대로 정렬이 됩니다. 하지만 이 항목을 사용하도록 설정하면 제목의 역순으로 정렬합니다. 블로그와 같이 시간의 역순으로 표시해야 하는 문서의 경우 사용할 수 있습니다. 책 백업 책 백업 탭은 책을 백업하는 곳입니다. 책의 내용과 이미지를 전부 내려받을 수 있습니다. 내려받은 파일은 zip으로 압축되어 있으며 책의 내용은 마크다운 형태로, 이미지는 해당 페이지별로 저장되어 있습니다. 책 삭제 책 삭제 탭은 책을 삭제하는 곳입니다. 책을 삭제할 때는 책의 이름을 입력해야 합니다. 책 이름이 일치할 경우에만 책이 삭제됩니다. 책은 한번 삭제하면 되돌릴 수 없기 때문에 주의해야 합니다. 책을 삭제하기 전에 책을 백업한 후 진행하는 것이 좋습니다. 페이지 수정 편집 화면의 목차에서 가장 상단을 제외한 목차는 모두 페이지입니다. 목차 중 페이지를 선택할 경우 다음과 같은 화면이 나타납니다. 페이지 수정 화면에서는 다음과 같은 항목을 설정할 수 있습니다. 페이지 제목 : 페이지의 제목을 설정합니다. 목차는 페이지의 제목을 기준으로 정렬됩니다. 따라서 일정한 순서를 유지하기 위해서는 페이지의 제목을 숫자나 기호부터 시작하게 하여 정렬하는 것이 좋습니다. 부모 페이지 : 현재 페이지의 부모 페이지를 설정합니다. 부모 페이지가 있는 경우 부모 페이지의 하위 목차로 포함됩니다. 부모 페이지가 없는 경우에는 최상단의 목차로 설정됩니다. 공개/비공개 : 이 페이지의 공개 여부를 설정합니다. 만약 하위 페이지가 있을 때, 비공개로 설정하면 하위 페이지들도 모두 비공개로 적용됩니다. 이미지 : 이 페이지에 삽입할 이미지를 첨부할 수 있습니다. 드래그 앤드 드롭과 여러 개의 파일을 동시에 업로드할 수 있는 기능을 제공합니다. 이미지 업로드 후에 등록된 이미지의 우측에 표시된 Action 아이콘을 사용하여 삭제, 복사, 적용을 할 수 있습니다. 페이지 내용 : 페이지의 내용을 수정하는 공간입니다. 페이지의 내용은 마크다운 문법을 사용하여 작성합니다. 마크다운에 대한 자세한 내용은 마크다운 페이지에서 자세하게 설명합니다. 페이지 수정 화면의 가장 하단에는 다음과 같은 버튼이 있습니다. 저장 : 페이지를 저장합니다. 복제 : 현재 페이지를 복사하여 페이지를 신규로 추가합니다. 단, 제목에는 "Copy"라는 문장이 포함됩니다. 삭제 : 페이지를 삭제합니다. 삭제한 페이지는 복구할 수 없으니 주의해야 합니다. 04) 책 가져오기 마크다운 파일을 포함하는 zip 파일을 올려 책을 가져올 수 있습니다. zip 파일 내에는 반드시. md 파일이 포함되어 있어야 합니다. 올릴 수 있는 대표적인 파일의 종류는 다음과 같습니다. 위키독스에서 백업한 책 파일 깃허브에서 내려받은 파일 노션에서 마크다운으로 내보내기 한 파일 위키독스에 로그인한 후 [계정 설정 -> 책 가져오기] 메뉴에서 해당 기능을 사용할 수 있습니다. 올릴 파일을 선택하고 책 제목을 입력한 후 "책 가져오기" 버튼을 누르면 됩니다. 03-2 마크다운 위키독스는 마크다운을 기본 편집기로 사용합니다. 마크다운에 대한 자세한 내용은 다음 URL을 참조하세요. http://daringfireball.net/projects/markdown/ http://en.wikipedia.org/wiki/Markdown 여기서는 위키독스 편집을 위한 마크다운의 기본적인 문법에 대해서 간단하게 알아보겠습니다. 01) 헤딩 태그 문서에 소제목을 표시하기 위해서 다음과 같은 헤딩 태그를 사용합니다. 작성 예: # H1 ## H2 ### H3 #### H4 ##### H5 ###### H6 변환 결과: H1 H2 H3 H4 H5 H6 위키독스에서 헤딩 태그 사용 시 H2 헤딩 태그부터 사용할 것을 권장합니다. 전자책 생성 시 H1 헤딩 태그는 챕터로 인식되기 때문입니다. 전자책 판매를 염두에 두고 계신다면 H2 태그부터 사용하시기를 바랍니다. ※ H2 태그에는 밑줄을 긋도록 디자인했습니다. 02) 인용구 인용문은 다음처럼 표현합니다(※ 인용문은 HTML blockquote 엘리먼트로 변환됩니다.) 작성 예: > 철수는 영희가 이쁘다고 말했다. 변환 결과: 철수는 영희가 이쁘다고 말했다. 03) 리스트 리스트에는 두 가지 종류가 있습니다. 순차를 표시하는 것과 그렇지 않은 것 두 가지입니다. 순차 표시 작성 예: 1. 하나 1. 둘 1. 셋 변환 결과: 하나 셋 순차 표시 없는 것 작성 예: * 홍길동 * 김철수 * 김영희 변환 결과: 홍길동 김철수 김영희 중첩 표시 중첩해서 리스트를 표현하기 위해서는 들여 쓰기(스페이스 4개)가 필요합니다. 작성 예: * 커피의 장점 * 맛있다. * 잠을 깨운다. * 커피의 단점 * 잠이 안 온다. * 건강에 해롭다. 변환 결과: 커피의 장점 맛있다. 잠을 깨운다. 커피의 단점 잠이 안 온다. 건강에 해롭다. 04) 강조 구문 강조 구문에도 두 가지가 있습니다. 진하게 표시하는 것과 기울여서 표시하는 것 두 가지입니다. 진하게 표시 (Bold) 작성 예: 전 매우 **착하게** 살고 싶었습니다. 변환 결과: 전 매우 착하게 살고 싶었습니다. 기울여 표시 (Italic) 작성 예: 전 매우 *착하게* 살고 싶었습니다. (또는 _착하게_) 변환 결과: 전 매우 착하게 살고 싶었습니다. (또는 착하게) 05) 링크와 이미지 링크 이미지 표시 이미지 정렬과 삽입 왼쪽 정렬 왼쪽 삽입 오른쪽 정렬 오른쪽 삽입 가운데 정렬 링크 [링크 문구](링크 주소) 와 같이 작성하면 링크가 생성됩니다. 작성 예: [위키독스](http://wikidocs.net) 변환 결과: 위키독스 이미지 표시 이미지를 표시하려면 링크 주소 대신 이미지 주소를 기재하고 맨 앞에! 만 추가하면 됩니다. 작성 예:  변환 결과: 이미지 정렬과 삽입 이미지를 정렬 또는 삽입하려면 img 태그를 사용하면 됩니다. 왼쪽 정렬 <p align="left"> <img src="https://picsum.photos/100/100"> </p> 이미지를 왼쪽으로 정렬하기 위해서는 위와 같이 p 태그와 img 태그를 같이 사용하면 됩니다. 왼쪽 삽입 <img align="left" src="https://picsum.photos/100/100" style="margin-right:10px"> 이미지를 텍스트 본문 왼쪽에 삽입하기 위해서는 위와 같이 img 태그를 사용하면 됩니다. align="left" 속성을 주고 이미지 우측에는 마진을 주어야 깔끔하게 보입니다. 이미지 우측으로 작성되는 텍스트는 이미지의 세로 길이만큼 계속 들여쓰기 되어 표시됩니다. 오른쪽 정렬 <p align="right"> <img src="https://picsum.photos/100/100"> </p> 이미지를 오른쪽으로 정렬하기 위해서는 위와 같이 p 태그와 img 태그를 같이 사용하면 됩니다. 오른쪽 삽입 <img align="right" src="https://picsum.photos/100/100" style="margin-left:10px"> 이미지를 텍스트 본문 오른쪽에 삽입하기 위해서는 위와 같이 img 태그를 사용하면 됩니다. align="right" 속성을 주고 이미지 좌측에는 마진을 주어야 깔끔하게 보입니다. 이미지 좌측으로 작성되는 텍스트는 이미지의 세로 길이만큼 계속 들여쓰기 되어 표시됩니다. 가운데 정렬 <p align="center"> <img src="https://picsum.photos/460/300"> </p> 이미지를 가운데로 정렬하기 위해서는 위와 같이 p 태그와 img 태그를 같이 사용하면 됩니다. 06) 강제 줄 바꿈 마크다운 에디터에서 엔터키를 이용하여 줄 바꿈을 하더라도 실제 보이는 화면에서는 줄 바꿈이 되지 않습니다. 만약 강제로 줄 바꿈을 하고 싶으면 줄 끝에 공백(space)을 두 개를 추가해야 합니다. 책 수정 화면에서 "엔터키 줄 바꿈" 기능을 "사용함"으로 설정한 경우에는 엔터키로도 줄 바꿈이 됩니다. 작성 예: ("첫 번째 줄" 뒤에 스페이스 2개가 추가되어 있음) 첫 번째 줄 두 번째 줄 변환 결과: 첫 번째 줄 두 번째 줄 07) 코드 블록 코드 블록은 프로그래밍 코드를 삽입할 경우 사용합니다. 삽입된 코드는 보기 좋게(Syntax Highlighting) 표시됩니다. 코드 블록 Back Quote(`) 문자 세 개(```)를 코드의 위아래에 삽입합니다. 작성 예: ``` def sum(a, b): return a+b ``` 변환 결과: def sum(a, b): return a+b 자동으로 언어를 판별하여 신택스 강조가 적용됩니다. 언어 지정 코드 블록 (추천) 또는 다음과 같이 코드에 특정 언어(예:python)를 지정하여 코드 블록을 설정할 수도 있습니다. Back Quote(`) 문자 세 개와 코드의 언어를 입력하면 됩니다. (예:```python) 블록을 닫을 때는 마찬가지로 Back Quote(`) 문자 세 개를 입력합니다. python의 예 ```python def sum(a, b): return a+b ``` 변환 결과: def sum(a, b): return a+b java의 예 ```java class Test { public static void main(String[] args) { System.out.pritnln("hello world"); } } ``` 변환 결과: class Test { public static void main(String[] args) { System.out.pritnln("hello world"); } } python, java와 같은 값을 지정하지 않을 경우 자동으로 언어가 선택됩니다. 다음은 Syntax Highlighting이 지원되는 언어(Language)들입니다. 마크다운 에디터에서는 괄호 안의 값으로 사용하면 됩니다. Bash (bash) C# (cs) C++ (cpp) CSS (css) Diff (diff) HTML, XML (html) HTTP (http) Ini (ini) JSON (json) Java (java) JavaScript (javascript) PHP (php) Perl (perl) Python (python) Ruby (ruby) SQL (sql) Dart (dart) 더 많은 언어 코드 만약 위에 언급한 언어 외에 코드 블록을 사용해야 한다면 다음과 같이 페이지 상단에 해당 언어에 대한 스크립트를 추가하여 사용할 수 있습니다. [예: verilog 언어를 사용할 경우] <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.7.0/languages/verilog.min.js"></script> 그리고 다음과 같이 사용하면 됩니다. ```verilog for ( int count = 0; count < 3; count++ ) value = value +((a[count]) * (count+1)); for ( int count = 0, done = 0, j = 0; j * count < 125; j++, count++) $display("Value j = %d\n", j); ``` 변환 결과: for ( int count = 0; count < 3; count++ ) value = value +((a[count]) * (count+1)); for ( int count = 0, done = 0, j = 0; j * count < 125; j++, count++) $display("Value j = %d\n", j); 더 많은 언어 코드는 다음을 참고하세요. https://github.com/highlightjs/highlight.js/blob/main/SUPPORTED_LANGUAGES.md 위 사이트의 언어 코드 표에서 aliases에 해당하는 단어를 사용하여 다음과 같이 스크립트를 추가하면 됩니다. <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.7.0/languages/{alias}.min.js"></script> plaintext 코드 블록 만약 코드 블록을 사용하고 싶지만 신택스 강조 기능을 사용하고 싶지 않은 경우에는 다음과 같이 plaintext를 사용할 수 있습니다. ```plaintext class Test { public static void main(String[] args) { System.out.pritnln("hello world"); } } ``` 변환 결과: class Test { public static void main(String[] args) { System.out.pritnln("hello world"); } } 인라인 코드 블록 코드는 대부분 1줄 이상으로 이루어져 있지만 짤막한 코드 문장을 한 문장 내에 삽입하고 싶을 경우도 있겠지요? 이런 경우에 사용할 수 있는 인라인 코드 문법이 있습니다. 다음 예처럼 코드 부분을 ` (back quote) 문자로 감싸면 됩니다. 작성 예: 프로그램 수행 중 `return a+b`라는 문장을 만나면 결괏값이 리턴됩니다. 변환 결과: 프로그램 수행 중 return a+b라는 문장을 만나면 결괏값이 리턴됩니다. 08) 마크다운 extension 위키독스는 일반 마크다운 기능에 추가로 몇 가지 기능들을 추가로 제공합니다. ※ 다른 마크다운 에디터에서는 아래의 기능이 동작하지 않을 수도 있습니다. 테이블 작성 예: head1 | head2 ------|------- hello | foo hi | bar 변환 결과: head1 head2 hello foo hi bar (※ 테이블 내에 파이프 문자 표시하려면 |를 입력하면 됩니다.) 테이블 정렬 테이블의 내용을 좌측, 우측 또는 가운데로 정렬할 수 있습니다. 좌측 정렬인 경우 테이블의 헤더와 데이터의 구분선을 :------ 와 같이 : 을 구분 선의 좌측에 추가합니다. 우측 정렬인 경우에는 ------:, 가운데 정렬인 경우에는 :------:를 사용합니다. 작성 예: 좌측 정렬 | 우측 정렬 | 가운데 정렬 :------ |------:|:------: 연필 | 500 | Yes 커피 | 9000 | No 크레파스 | 15000 | Yes 변환 결과: 좌측 정렬 우측 정렬 가운데 정렬 연필 500 Yes 커피 9000 No 크레파스 15000 Yes 각주 각주란 본문의 어떤 부분을 설명하거나 보충하기 위해 본문 아래쪽에 별도로 작성하는 간단한 설명문으로서 주로 내용의 출처를 밝힐 때 사용합니다. 작성 예: 에릭 레이먼드는 파이썬을 배운지 하루 만에 원하는 프로그램을 작성할 수 있었다고 한다. [^myfootnote] [^myfootnote]: 에릭 레이먼드는 프로그래밍 경험이 많은 구루 프로그래머이다. 보통 사람은 파이썬을 배우고 사용하는 데 1주일 정도의 적응 시간이 필요할 것이다. 변환 결과: 에릭 레이먼드는 파이썬을 배운지 하루 만에 원하는 프로그램을 작성할 수 있었다고 한다. 1 ※ 각 주명(예:myfootnote)은 마음대로 명명할 수 있습니다. 문서 내 목차 (Table Of Contents) 문서 내에 사용된 헤딩 태그들을 이용하여 [TOC] 입력 시 그 부분에 목차가 자동으로 생성됩니다. 작성 예: [TOC] 변환 결과: 테이블 각주 문서 내 목차 (Table Of Contents) 에릭 레이먼드는 프로그래밍 경험이 많은 구루 프로그래머이다. 보통 사람은 파이썬을 배우고 사용하는 데 1주일 정도의 적응 시간이 필요할 것이다. ↩ 09) 위키독스 extension 아래는 마크다운 문법이 아닌 위키독스에서만 지원되는 문법입니다. 팁 블록 코드 마커 용어 링크 팁 블록 도움말 등을 팁 블록으로 표시하려면 다음과 같이 문장을 [[TIP]]과 [[/TIP]]으로 감싸면 됩니다. 작성 예: [[TIP]] ** 팁 블록에 대하여 ** 도움말이나 팁을 설명하는 블록을 작성할 수 있습니다. [[/TIP]] 변환 결과: tip 팁 블록에 대하여 도움말이나 팁을 설명하는 블록을 작성할 수 있습니다. 팁 블록에 "tip" 대신 다른 문자열을 넣고 싶은 경우에는 다음과 같이 사용합니다. [[TIP("알아두기")]] ** 팁 블록에 대하여 ** 도움말이나 팁을 설명하는 블록을 작성할 수 있습니다. [[/TIP]] 변환 결과: 알아두기 팁 블록에 대하여 도움말이나 팁을 설명하는 블록을 작성할 수 있습니다. 코드 마커 코드의 일부분을 강조 표시하려면 다음과 같이 강조하고 싶은 부분을 [[MARK]]와 [[/MARK]]로 감싸면 됩니다. 작성 예: 변환 결과: def sum(a, b): return a+b 코드의 삭제된 부분을 표시하려면 다음과 같이 삭제 부분을 [[SMARK]]와 [[/SMARK]]로 감싸면 됩니다. 작성 예: 변환 결과: def sum(a, b): return a+b 코드 마커는 편집기에서 마커를 적용할 부분을 마우스로 선택한 상태에서 아래 아이콘을 사용하여 손쉽게 적용할 수 있습니다. 용어 링크 용어 링크는 위키독스의 자매 서비스인 위키독스 용어 사전의 페이지의 내용을 팝업으로 미리 보기 할 수 있는 기능입니다. (각주나 팁 대신 사용할 수 있습니다.) 위키독스 용어 사전: https://wikidocs.net/wiki/ 용어 링크를 추가하려면 다음과 같이 용어 사전의 용어명 좌우를 [["와 "]]로 감싸서 입력하면 됩니다. [["위키위키"]] 실행 결과 보기: 위키위키 (링크를 클릭해 보세요) 용어 링크는 위와 같이 갈색으로 표시되며 해당 링크를 클릭하면 용어의 내용을 팝업으로 보여줍니다. 팝업을 닫으려면 용어 링크를 다시 클릭하거나 팝업창의 x 버튼을 클릭하면 됩니다. 에디터의 아이콘을 통해서도 쉽게 용어 링크를 사용할 수 있습니다. 원하는 단어를 선택한 후 에디터의 다음 아이콘을 누르면 됩니다. 03-3 수식 입력 위키독스의 수식은 mathjax를 이용합니다. 수식 입력 inline 모드 수식 입력 수식 입력 포맷 수식 입력 문자 회피 행렬식 주의사항 앱 주의사항 수식 입력 예를 들어 다음과 같은 문장을 입력하면, (수식의 좌우를 $$ 문자로 감싸주어야 합니다.) $$x = {-b \pm \sqrt{b^2-4ac} \over 2a}$$ 아래와 같은 수식이 표시됩니다. = b b − a 2 수식 입력의 방법은 LaTeX 문서 작성 시 사용하는 방법과 동일합니다. inline 모드 수식 입력 만약, inline 모드(같은 줄에 표시)로 작성하고 싶으면 $$ 대신 $를 사용하면 됩니다. 같은 줄에 표시하려면 이렇게 $x = {-b \pm \sqrt{b^2-4ac} \over 2a}$ `$`를 한 개만 사용해야 합니다. 같은 줄에 표시하려면 이렇게 = b b − a 2 $를 한 개만 사용해야 합니다. 수식 입력 포맷 다음의 문서(LaTeX 포맷)를 참고하여 원하는 수식을 입력할 수 있습니다. http://en.wikipedia.org/wiki/Help:Displaying_a_formula#Formatting_using_TeX 수식 입력 문자 회피 예를 들어 $foo, $bar라는 문장은 $ 사이의 문장이 수식으로 인식되므로 $ 수식을 피하려면 다음과 같이 작성해야 합니다. <span class="tex2jax_ignore">$foo, $bar</span> 행렬식 주의사항 수식 내에 \\ 기호가 있는 경우는 (예: 행렬식) \\ 대신 \\\\ 을 사용해야 합니다. 예) $ \begin{bmatrix} a & b \\\\ c & d \end{bmatrix}$ 결괏값: [ b d ] 앱 주의사항 수식은 줄 바꿈(word-break)이 되지 않기 때문에 앱에서 너무 긴 수식을 볼 경우 가로 스크롤이 생겨서 불편할 수 있습니다. 03-4 검색 위키독스 편집화면에서 브라우저의 검색 기능으로는 편집기 내의 글들이 정상적으로 검색되지 않습니다. 편집기 내부의 글들을 검색하기 위해서는 위키독스 편집기에 마우스 포커스가 있는 상태로 Ctrl+F 키를 입력하면 편집기 내에 검색창이 표시됩니다. 이곳에 찾고자 하는 문장을 입력하여서 검색하면 됩니다. 검색된 문자열이 여러 개일 경우 Ctrl+G를 입력하여 다음 검색 위치로 이동할 수 있습니다. 03-5 책 백업과 페이지 복구 위키독스 책을 백업하는 방법과 페이지를 이전 버전으로 복구하는 기능에 대해서 알아보겠습니다. 책 전체 백업하기 페이지 복구하기 변경 이력 화면 개별 버전 다운로드 책 전체 백업하기 책의 수정 화면에서 <책 다운로드> 버튼을 누르면 됩니다. 그러면 zip 파일이 다운로드 됩니다. zip 파일에는 책의 모든 페이지가 들어 있습니다. (업로드한 이미지 포함) 페이지 복구하기 특정 시점의 페이지를 내려받을 수 있습니다. 예를 들어 어떤 페이지는 5번을 수정했을 경우 5개의 버전을 각각 내려받을 수 있습니다. 변경 이력 화면 백업을 원하는 페이지 하단의 "마지막 편집 일시" 링크를 눌러 변경 이력 화면으로 이동합니다. 개별 버전 다운로드 변경 이력 화면에서 백업을 원하는 버전의 <download> 링크를 누르면 내려받을 수 있습니다. 내려받은 파일을 사용하여 이전 버전으로 쉽게 복구할 수 있습니다. 04 위키독스 광고 저자는 본인이 작성한 책에 구글 광고를 삽입하여 수익을 올릴 수 있습니다. 수익을 올릴 수 있는 광고의 형태는 총 3가지입니다. 본인에게 적합한 광고를 잘 선택하여 사용하시기를 바랍니다. 저자의 애드센스 사용 (자세히 보기) 호스트 파트너(예: 티스토리)의 애드센스 사용 (자세히 보기) 위키독스의 포인트 광고 사용 (자세히 보기) 공지사항 수익 배분 위의 1, 2번 방식을 사용할 경우 10% 비율로 위키독스 애드센스가 표시됩니다. (저자의 광고와 위키독스의 광고가 9 대 1의 비율로 게시. ) 광고를 표시하지 않는 책의 경우에는 위키독스의 애드센스만 10% 비율로 게시됩니다. 애드센스 1번 방식을 사용하기 위해서는 활성화된 애드센스 계정을 보유하고 있어야 합니다. 이때 계정 생성 및 활성화를 위해 위키독스 사이트를 이용할 수는 없습니다. (애드센스 계정 활성화를 위해서는 사이트 소유권한이 있어야 하기 때문입니다.) 만약 애드센스 호스트 파트너(예: 티스토리, Blogger 등)를 경유하여 애드센스 승인을 받은 경우에는 다음을 참고하세요. 호스트 파트너의 애드센스 게시하기 04-1 저자의 애드센스 게시하기 활성화된 애드센스 계정을 소유하고 있다면 다음과 같이 구글의 광고 스크립트를 "책 수정" 화면에 입력하여 구글 광고를 게시할 수 있습니다. 데스크톱 광고 [추천] 박스 형태의 광고 예시(336x280, 2개 게시) 박스 형태의 광고 예시(336x280, 1개 게시) 모바일 광고 ads.txt 데스크톱 광고 저자의 "책 수정" 화면에서 광고 내용(탁상용 컴퓨터)에 다음과 같은 형태의 HTML 코드를 삽입하세요. [추천] 박스 형태의 광고 예시(336x280, 2개 게시) 구글 광고 2개를 게시할 때는 다음과 같은 형태의 HTML 코드를 이용하세요. 두 개의 구글 광고 계정은 서로 달라도 됩니다. (공동 저자의 경우 저자별로 서로 다른 구글 광고 스크립트를 사용할 수 있습니다.) <div class="clearfix"> <div class="pull-left"> <script async src="//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js"></script> <ins class="adsbygoogle" style="display:inline-block;width:336px;height:280px" data-ad-client="ca-pub-9470517771012578" data-ad-slot="3437110462"></ins> <script> (adsbygoogle = window.adsbygoogle || []).push({}); </script> </div> <div class="pull-left" style="margin-left:30px"> <script async src="//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js"></script> <ins class="adsbygoogle" style="display:inline-block;width:336px;height:280px" data-ad-client="ca-pub-9470517771012578" data-ad-slot="3437110462"></ins> <script> (adsbygoogle = window.adsbygoogle || []).push({}); </script> </div> </div> 노란색으로 마킹되어 있는 부분은 본인의 것으로 수정해야 함 박스 형태의 광고 예시(336x280, 1개 게시) <div class="row"> <div class="col-sm-6"> <script async src="//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js"></script> <ins class="adsbygoogle" style="display:inline-block;width:336px;height:280px" data-ad-client="ca-pub-9470517771012578" data-ad-slot="3437110462"></ins> <script> (adsbygoogle = window.adsbygoogle || []).push({}); </script> </div> </div> 노란색으로 마킹되어 있는 부분은 본인의 것으로 수정해야 함 모바일 광고 모바일 광고는 가급적 반응형(responsive) 형태의 광고를 게시하시기를 바랍니다. PC용의 광고를 그대로 사용하면 위키독스 앱에 가로 스크롤이 생겨 가독성이 떨어집니다. [모바일 광고의 예] <script async src="https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js"></script> <!-- 위키독스모바일2020 --> <ins class="adsbygoogle" style="display:block" data-ad-client="ca-pub-9470517771012578" data-ad-slot="4465552259" data-ad-format="auto" data-full-width-responsive="true"></ins> <script> (adsbygoogle = window.adsbygoogle || []).push({}); </script> ads.txt 저자의 구글 광고 아이디가 아래 URL에 반드시 포함되어 있어야만 구글 광고가 정상적으로 표시됩니다. 만약 아래 URL에 저자의 구글 광고 아이디가 포함되어 있지 않다면 댓글이나 <EMAIL>으로 연락해 주시면 추가해 드리도록 하겠습니다. https://wikidocs.net/ads.txt 04-2 호스트 파트너의 애드센스 게시하기 본인의 티스토리 구글 광고를 위키독스에 게시하려면 아래에 설명한 코드를 생성하여 책 수정 > 광고 내용에 저장하세요. 티스토리에서 애드센스 계정을 승인받은 경우 두 개의 애드센스를 표시하려면 티스토리에서 애드센스 계정을 승인받은 경우 주의사항 iframe 정책 위반에 관하여 티스토리, 블로그 스폿(블로거) 등은 애드센스 호스트 파트너입니다. 이러한 애드센스 호스트 파트너를 통해 애드센스 승인을 받은 경우에는 위키독스에서 iframe을 이용한 방식으로만 광고 게시가 가능합니다. 하지만 iframe을 사용할 경우 정책 위반이 될 수도 있습니다. 다음의 공지를 확인하시기를 바랍니다. iframe 관련 애드센스 FAQ 만약 애드센스 호스트 파트너(예: 티스토리, 블로거 등)를 경유하여 애드센스 승인을 받은 경우에는 다음과 같은 방법으로만 구글 광고 게시가 가능합니다. ※ 더 좋은 방법을 아시는 분은 여기 댓글로 알려주시면 감사하겠습니다. [티스토리에서 사용하는 구글 광고를 삽입하는 방법 예시] <iframe name="adsense_iframe" width="336" height="280" frameborder="0"></iframe> <form name="adsense_form" method="post" target="adsense_iframe" action="https://googleads.g.doubleclick.net/pagead/ads"> <input type="hidden" name="client" value="ca-pub-1176584478877240"> <input type="hidden" name="host" value="ca-host-pub-9691043933427338"> <input type="hidden" name="format" value="336x280"> <input type="hidden" name="url" value="https://dextto.tistory.com/225"> </form> <script>document.adsense_form.submit();</script> 노란색으로 마킹 한 부분은 본인에게 맞는 코드로 변경해야 합니다. 다음은 hidden input 항목에 대한 설명입니다. client - 승인받은 애드센스 계정 코드 host - 호스트 파트너의 애드센스 계정 코드 (티스토리의 경우: ca-host-pub-9691043933427338) format - 광고의 크기(가로 x 세로), iframe의 width, height와 서로 일치해야 합니다. url - 애드센스 계정을 승인받은 티스토리의 URL 두 개의 애드센스를 표시하려면 한 페이지에 336x280 크기의 광고 두 개를 표시하려면 다음과 같이 할 수 있습니다. <div class="clearfix"> <div class="pull-left" style="margin-right:30px"> <iframe name="adsense_iframe1" width="336" height="280" frameborder="0"></iframe> <form name="adsense_form1" method="post" target="adsense_iframe1" action="https://googleads.g.doubleclick.net/pagead/ads"> <input type="hidden" name="client" value="ca-pub-1176584478877240"> <input type="hidden" name="host" value="ca-host-pub-9691043933427338"> <input type="hidden" name="format" value="336x280"> <input type="hidden" name="url" value="https://dextto.tistory.com/225"> </form> <script>document.adsense_form1.submit();</script> </div> <div class="pull-left"> <iframe name="adsense_iframe2" width="336" height="280" frameborder="0"></iframe> <form name="adsense_form2" method="post" target="adsense_iframe2" action="https://googleads.g.doubleclick.net/pagead/ads"> <input type="hidden" name="client" value="ca-pub-1176584478877240"> <input type="hidden" name="host" value="ca-host-pub-9691043933427338"> <input type="hidden" name="format" value="336x280"> <input type="hidden" name="url" value="https://dextto.tistory.com/225"> </form> <script>document.adsense_form2.submit();</script> </div> </div> 노란색으로 마킹 한 부분은 본인에게 맞는 코드로 변경해야 합니다. 04-3 위키독스 포인트 광고 사용하기 활성화된 애드센스 계정이 없으면 위키독스의 포인트 광고를 사용하여 수익을 창출할 수 있습니다. 위키독스 포인트 광고란? 수익분배 방침 사용 방법 포인트 및 수익 조회 수익 지급 위키독스 포인트 광고란? 위키독스 포인트 광고는 애드센스 계정이 없는 저자를 위해 저자가 작성한 책에 위키독스의 애드센스를 게시하여 발생하는 수익을 저자에게 분배하는 서비스입니다. 수익분배 방침 광고 수익의 70%를 저자에게 분배합니다. 포인트는 책별로 원화로 환산하여 10만 원 이상 적립되면 저자에게 지급됩니다. 사용 방법 위키독스의 책 수정 화면에서 "광고를 표시합니까?"와 "위키독스 포인트 광고를 사용합니까?"를 "예"로 설정하고 저장하면 해당 책에 위키독스의 애드센스가 게시되고 포인트가 적립되기 시작합니다. 포인트 및 수익 조회 위키독스 포인트 광고를 사용하면 위키독스 메인 페이지에 다음과 같은 "광고 수익" 메뉴가 표시됩니다. 광고 수익 메뉴를 통해 포인트와 수익을 조회할 수 있습니다. (수익은 매월 초에 전월치를 집계합니다.) 수익 지급 원화로 환산된 금액이 10만 원 이상일 경우 저자가 등록한 계좌에 입금됩니다. 수익을 지급받을 계좌는 다음과 같이 등록할 수 있습니다. 지급 시기는 매월 중순 ~ 말 사이입니다. (계정 설정 -> 기본 정보 -> 수익 계좌) 04-4 고정형 우상단 광고 고정형 우상단 광고 게시 방법 주의할 점과 광고의 예시 고정형 우상단 광고 다음처럼 화면 우상단에 구글 광고를 게시할 수 있습니다. 단, 우측 고정형 광고는 브라우저의 가로 사이즈가 1650px 보다 작아지면 사라집니다. 게시 방법 "책 수정" 화면에 진입한 후 다음과 같이 "광고 내용(PC, 우상단)" 항목에 게시할 구글 광고를 등록하면 됩니다. 주의할 점과 광고의 예시 단, 주의해야 할 점이 한 가지 있습니다. 구글 광고는 반드시 다음처럼 반응형이 아닌 크기 고정형을 사용해야 합니다. <script async src="https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=ca-pub-9470517771012578" crossorigin="anonymous"></script> <!-- wikidocs_sidebar --> <ins class="adsbygoogle" style="display:inline-block;width:200px;height:500px" data-ad-client="ca-pub-9470517771012578" data-ad-slot="7263258217"></ins> <script> (adsbygoogle = window.adsbygoogle || []).push({}); </script> 크기는 위의 예시대로 200 x 500처럼 가로 크기를 200 이하로 지정해야 광고가 정상적으로 표시됩니다. 04-9 광고 정책 변경 이력 2023년 2월 20일 2022년 3월 25일 2019년 10월 05일 2017년 5월 15일 2023년 2월 20일 위키독스 포인트 광고 기능 추가 2022년 3월 25일 위키독스 페이지 우상단 영역에 고정 광고 추가 고정형 우측 사이드 광고 2019년 10월 05일 구글 광고 정책 변경 사항을 알려드립니다. 저자의 구글 광고 아이디가 아래 URL에 반드시 포함되어 있어야만 구글 광고가 정상적으로 표시됩니다. 현재는 위키독스에 등록된 저자의 구글 광고를 검색하여 자동 등록하였습니다. 만약 아래 URL에 저자의 구글 광고 아이디가 포함되어 있지 않다면 댓글이나 <EMAIL>으로 연락해 주시면 추가해 드리도록 하겠습니다. https://wikidocs.net/ads.txt 2017년 5월 15일 위키독스의 지속적이고 안정적인 서비스 운영을 위하여 다음과 같이 광고 정책이 변경되었음을 알려드립니다. 변경 전 : 광고 없음. (단, 저자가 광고를 등록한 경우 저자의 광고가 표시.) 변경 후 : 10% 비율로 위키독스 광고 표시 (저자의 광고와 위키독스의 광고가 9 대 1의 비율로 게시. 단, 저자의 광고가 등록되지 않은 경우에는 위키독스의 광고만 10% 비율로 게시.) 저자분들의 많은 양해를 부탁드립니다. 05 전자책(e-book) 위키독스에 작성한 책을 전자책으로 판매할 수 있습니다. 2022년 11월부터 전자책 서비스를 재개합니다. 05-1 전자책 작성과 판매 진행 순서 다음의 순서로 전자책을 작성하고 판매할 수 있습니다. 1. 책 작성 (저자) 2. 책 판매 요청 (저자) 3. 책 판매를 위한 준비 (위키독스) 4. 판매 개시 (위키독스) 5. 익월에 인세 정산 1. 책 작성 (저자) 전자책 판매를 위한 책을 위키독스에서 저자가 직접 작성합니다. 2. 책 판매 요청 (저자) 책이 완성되면 저자가 아래의 이메일로 전자책 판매 요청을 합니다. 이메일 요청 (<EMAIL>) 3. 책 판매를 위한 준비 (위키독스) 위키독스는 전자책 판매를 위한 준비를 합니다. PDF 생성 테스트 오류 검증 4. 판매 개시 (위키독스) 위키독스는 전자책 판매를 개시합니다. (판매가 시작되면 위키독스 메인 페이지의 "전자책" 탭에 해당 책이 노출됩니다.) 저자와 전자책 가격 협의 ISBN 발행 5. 익월에 인세 정산 전자책 정산은 익월 중순 ~ 말에 진행합니다. (예를 들어 2023년 4월에 판매된 전자책은 5월 중순에 정산해 드립니다.) 05-2 전자책 샘플 위키독스에서 만들어지는 전자책은 모두 아래의 샘플과 동일한 포맷으로 제작됩니다. (책 표지는 바꿀 수 있습니다.) [점프 투 파이썬] 05-3 전자책 보안 위키독스에서 판매하는 전자책(PDF)에는 DRM과 같은 보안 기술이 적용되지 않습니다. 다만, 페이지 하단에 구매자 정보(이름, 이메일)를 표시하는 워터마크 표기를 사용합니다. 저자가 이러한 워터마크 표기 방식에 동의할 경우에만 전자책 판매가 가능합니다. DRM과 워터마크의 차이 DRM 방식 DRM 방식으로 암호화된 문서를 읽기 위해서는 DRM 전용 클라이언트 프로그램이 필요합니다. 사용자는 DRM 클라이언트 프로그램을 사용하여 DRM 서버에 인증을 획득한 후에야 구매한 문서를 읽을 수 있습니다. 이 과정은 매우 복잡하고 사용자 PC 상황에 따라 오류도 빈번하게 발생합니다. 또한 DRM 문서는 편집이 불가능하여 문서 작업에 상당한 불편함이 있습니다. 워터마크 방식 워터마크는 콘텐츠의 불법 복제와 저작권 문제 해결을 위해 사용되는 기술입니다. 위키독스는 사용자가 구매한 PDF 문서의 모든 페이지 하단에 구매자의 정보를 기재하는 기술을 사용합니다. 전자책을 실시간으로 제작할 수 없다면 사용할 수 없는 기술입니다. 전자책을 구매한 사용자는 저작권법의 허용 범위 내에서 자유롭게 문서를 출력하거나 편집하여 개인적으로 사용할 수 있습니다. 05-4 전자책 단가와 수익 배분 전자책의 단가는 저자와 위키독스가 협의하여 설정합니다. 현재 위키독스는 4,000원부터 33,000원까지의 전자책을 판매하고 있습니다. [수익 배분 형태] (기본) 전자책 수입의 80%는 저자, 20%는 위키독스에게 배분됩니다. (원천세 제외) 전자책 수입의 100%가 저자에게 배분됩니다. (PG사 수수료 및 원천세 제외) 단, 해당 책(전자책 아닌 위키독스 책)에 위키독스의 구글 광고를 게시해야 합니다. 전자책과 온라인 콘텐츠가 100% 동일한 경우에만 가능합니다. (전자책에만 수록되는 비공개 콘텐츠가 있는 경우 불가능합니다.) 활성화된 구글 애드센스 계정이 없으면 사용하세요. 한 달에 한 번 인세가 지급됩니다. (카드사 정산이 마무리된 시점인 익월 중순 ~ 말경에 지급) 05-5 전자책 작성 시 주의할 점 전자책 작성 시 오류가 발생할 수 있는 부분에 대해서 알려드립니다. 헤딩 태그 엔터키 줄 바꿈 모드 해제 팁 블록 경로명 각 주명 헤딩 태그 헤딩 태그는 2레벨(##)부터 사용해야 합니다. 1레벨(#) 헤딩 태그는 책의 챕터로 분류되기 때문에 목차가 위키독스의 목차와 동일하게 생성되지 않습니다. 엔터키 줄 바꿈 모드 해제 위키독스 책의 설정 중에 "엔터키 줄 바꿈 모드"가 있습니다. 하지만 전자책 생성 시에는 이 옵션이 적용되지 않습니다. 따라서 전자책을 목적으로 하는 책은 이 옵션을 해제하고 본문의 내용을 재조정해야 합니다. (줄 바꿈이 정상적으로 표시되는지 확인 필요) 엔터키 줄 바꿈 모드 설정을 하지 않은 경우에는 상관이 없습니다. (위키독스 책의 엔터키 줄 바꿈 모드의 기본 설정은 Off입니다.) 팁 블록 본문에 팁(TIP) 블록을 사용했다면 팁 블록의 내용이 너무 길지 않아야 합니다. 예를 들어 팁 블록의 내용이 한 페이지 이상이면 팁 블록이 전부 표시되지 않고 잘립니다. 팁 블록 - https://wikidocs.net/141889 경로명 아래와 같이 역슬래시 \ 문자를 포함한 경로명은 코드 블록으로 지정하든가 아니면 /처럼 슬래시 문자로 바꾸어서 사용해야 합니다. 올바른 파일명 예시 - C:\mydir\abc.txt, C:/mydir/abc.txt, C:/mydir/abc.txt 잘못된 파일명 예시 - C:\mydir\abc.txt 각 주명 만약 책에서 각주를 사용한다면 각주 명은 모두 다른 이름으로 만들어 주세요. 전자책 생성 시에는 책에 있는 모든 페이지를 하나의 문서로 통합하여 작업합니다. 따라서 동일한 이름의 각주가 하나의 문서에 여러 개 존재할 경우 엉뚱한 각주가 참조될 수 있습니다. 05-6 전자책 FAQ 위키독스 전자책만의 특별함이 있나요? 위키독스는 출판사인가요? 위키독스에서 전자책을 만들려면 비용이 드나요? 제작되는 전자책(e-book)의 종류는 무엇인가요? 판매하는 전자책에 ISBN이 발급되나요? PDF에 암호화가 적용되나요? 책(e-book) 판매를 목적으로 작성한 책의 내용 전체를 위키독스에 공개해야 하나요? 위키독스 전자책만의 특별함이 있나요? 위키독스의 전자책은 구매 시점에 위키독스의 책 내용 그대로 실시간 제작되어 발송되기 때문에 살아있는 전자책이 됩니다. 책의 내용이 고정되어 있지 않기 때문에 오류의 수정, 내용의 추가 등에 완전히 자유롭습니다. 위키독스는 출판사인가요? 네, 정식 출판사입니다. (출판사 신고번호 : 251002022000013, 상호: 위키독스) 현재는 전자책만 취급하고 있습니다. 위키독스에서 전자책을 만들려면 비용이 드나요? 아니요, 비용이 들지 않습니다. 무료로 전자책을 만들어 드립니다. 다만, 전자책으로 만들기 위해서는 적당한 분량과 양질의 콘텐츠를 갖추고 있어야 합니다. 제작되는 전자책(e-book)의 종류는 무엇인가요? PDF 문서입니다. (PC에서 사용하거나 프린터로 인쇄, 또는 아이패드, 갤럭시탭 등의 모바일 기기에서 활용할 수 있습니다.) 판매하는 전자책에 ISBN이 발급되나요? 네, 위키독스에서 판매하는 전자책은 모두 ISBN이 무료로 발급됩니다. ISBN 이란? PDF에 암호화가 적용되나요? 위키독스는 DRM과 같은 암호화를 적용하지 않습니다. 단, 판매되는 전자 문서의 모든 페이지 하단에 구매자 이름과 이메일을 워터마크식으로 표시합니다. 책(e-book) 판매를 목적으로 작성한 책의 내용 전체를 위키독스에 공개해야 하나요? 위키독스에 비공개 콘텐츠를 작성하고 PDF에만 비공개 콘텐츠를 공개하여 판매할 수 있습니다. 06 위키독스 앱(App) 위키독스 안드로이드, 아이폰 앱이 출시되었습니다. (2021년 10월) 이제 모바일 환경에서 위키독스 책을 보다 편리하게 읽을 수 있습니다. (갤럭시 탭이나 아이패드 등에서도 잘 동작합니다.) 스크린숏 [책 검색하기] [책 읽기] [목차 보기] [댓글 보기] [책갈피] 06-1 앱 다운로드 안드로이드 앱 아이폰 앱 안드로이드 앱 다음의 QR 코드로 앱을 내려받으세요. 안드로이드 앱 다운로드 주소: 안드로이드 앱 다운로드 아이폰 앱 App Store에서 "위키독스"로 검색 또는 다음의 QR 코드로 앱을 내려받으세요. 아이폰 앱 다운로드 주소: 아이폰 앱 다운로드 06-2 앱 가이드 책 조회 책 보기 목차 책갈피 글자 크기 조절 추천 댓글 댓글 조회 댓글 추가 댓글 수정과 삭제 로그인과 로그아웃 위키독스 앱을 사용하는 방법에 대해서 알아보겠습니다. 책 조회 위키독스 앱을 스마트폰에 설치한 후 앱을 실행하면 다음과 같은 화면이 나타납니다. 상단의 콤보 박스를 사용하여 "추천순, 인기순, 최신순"으로 조회할 수 있습니다. 상단의 "책 검색" 텍스트 창을 사용하여 책을 검색할 수 있습니다. 책 제목과 저자명으로 검색할 수 있습니다. 한 페이지에 50개씩 출력되면 50개가 넘는 경우 스크롤이 가장 하단에 위치하게 되면 자동으로 다음 50건을 조회합니다. 책 보기 위키독스에서 책을 조회한 후에 책을 선택하면 다음과 같은 화면이 나타납니다. (아래는 "점프 투 파이썬" 책을 선택한 화면입니다.) 책의 내용을 확인할 수 있는 상세 화면입니다. 하단의 "다음" 버튼을 클릭하면 책의 첫 번째 페이지가 조회됩니다. 하단의 "이전", "다음" 버튼을 클릭하여 이전 페이지와 다음 페이지로 이동할 수 있습니다. 목차 책 보기 화면에서 다음처럼 우측 하단의 아이콘을 눌러 보세요. 그러면 다음과 같은 목차가 나타납니다. 목차를 위아래로 움직여 원하는 페이지로 이동할 수 있습니다. 책갈피 책갈피 기능을 사용하면 위키독스의 특정 책이나 페이지를 저장하고 불러올 수 있습니다. 책갈피 기능은 "책 조회", "책 보기" 화면에서 사용할 수 있습니다. 책 보기 화면에서 다음처럼 우측 상단의 아이콘을 눌러 보세요. 그러면 다음과 같은 화면이 나타납니다. 이 화면에서 "추가" 버튼을 누르면 현재 페이지 또는 현재 책이 책갈피에 추가됩니다. 다음은 책갈피가 추가된 화면입니다. 추가된 책갈피를 선택하면 해당 책 또는 페이지로 이동합니다. 책갈피를 삭제하고 싶은 경우에는 책갈피의 좌측 체크 버튼을 클릭하여 체크한 후 "삭제" 버튼을 눌러 한꺼번에 삭제할 수 있습니다. 글자 크기 조절 "책 보기" 화면의 글자 크기를 조절할 수 있습니다. 위키독스 홈 화면("책 조회")으로 이동한 후 다음과 같이 "설정" 아이콘을 눌러보세요. 그러면 다음과 같은 화면이 나타납니다. 스마트폰 또는 스마트 패드에 어울리는 글자 크기를 선택하여 사용할 수 있습니다. 추천 현재 보고 있는 책을 추천할 수 있는 기능입니다. 다음과 같이 "책 화면"에서 우측 상단의 다음 아이콘을 눌러 추천할 수 있습니다. (추천 아이콘은 "책 화면"에만 노출되고 "페이지 화면"에는 노출되지 않습니다.) 댓글 페이지의 댓글을 읽거나 댓글을 작성, 수정, 삭제할 수 있습니다. "페이지 화면"에서 아래와 같은 아이콘을 누르면 작성된 댓글을 조회할 수 있습니다. 댓글 조회 다음은 댓글 조회 화면입니다. 로그인한 경우에는 본인이 작성한 댓글은 "노란색" 배경으로 표시됩니다. 댓글 추가 댓글 조회 화면에서 우측 하단의 "댓글 추가" 아이콘을 누르면 댓글을 추가할 수 있습니다. 댓글 작성을 위해서는 위키독스 로그인이 필요합니다. 만약 로그인되어 있지 않은 상태라면 다음과 같이 로그인 화면이 먼저 나타납니다. 만약 위키독스 계정이 없는 경우에는 회원 가입 후에 로그인해야 합니다. 로그인이 완료되면 다음과 같이 본인이 작성한 댓글은 노란색 배경으로 표시됩니다. 댓글 작성을 위해 다시 "댓글 작성" 아이콘을 누르면 이제 다음과 같은 화면이 나타납니다. 댓글을 입력 후 저장하면 댓글이 저장됩니다. 댓글 수정과 삭제 작성한 댓글을 수정하려면 본인이 작성한 댓글을 클릭합니다. 그러면 다음과 같이 댓글을 수정하거나 삭제할 수 있는 화면이 나타납니다. 댓글을 수정하려면 내용을 변경한 후 "저장" 버튼을 눌러 저장하고, 댓글을 삭제하려면 "삭제" 버튼을 눌러 삭제합니다. 로그인과 로그아웃 댓글 조회 화면에서 우측 상단의 아이콘을 통해 위키독스 로그인/로그아웃을 수행할 수 있습니다. 로그인이 되어 있는 경우에는 다음과 같이 로그아웃할 수 있는 버튼이 표시됩니다. 로그아웃 되어 있는 경우 다음과 같이 로그인할 수 있는 버튼이 표시됩니다. 06-3 앱 주의 사항 앱 가로 스크롤 문제 앱 가로 스크롤 문제 위키독스 앱으로 책을 볼 때 가로 스크롤이 생기면 가독성이 매우 떨어집니다. 가로 스크롤이 생기는 경우는 대표적으로 다음 두 가지가 있습니다. mathjax를 이용한 긴 수식 사용 가로 사이즈가 크게 정해져 있는 광고를 게시 수식의 경우는 가급적 이미지 캡처 형태로 변환하고 모바일 광고는 반응형으로 바꾸면 위 문제를 해결할 수 있습니다. 06-9 앱 변경 이력 1.1.0 (2023년 5월) 1.0.3 (2021년 10월) 1.1.0 (2023년 5월) 위키독스 API 변경에 따른 수정 플러터 및 라이브러리 최신 버전으로 적용 동영상 형태의 애드센스 보이지 않던 문제 해결 1.0.3 (2021년 10월) 위키독스 앱 (위키독스 리더) 출시 07 위키독스 API 위키독스는 Open API를 제공합니다. 현재는 시험 기간으로 챗 GPT 용 API와 조회 서비스만 운영하고 있습니다. 다음 URL에서 API를 확인하고 테스트해 볼 수 있습니다. 위키독스 API 스펙 - https://wikidocs.net/api/v1/docs 위키독스 API 스펙 (Readonly) - https://wikidocs.net/api/v1/redoc 08 위키독스와 챗 GPT 위키독스와 챗 GPT의 연계 방법에 관해서 설명합니다. 챗 GPT에서 위키독스 플러그인 사용하기 챗 GPT로 위키독스 페이지 만들기 인공지능으로 책 이미지 만들기 08-1 챗 GPT에서 위키독스 플러그인 사용하기 챗 GPT에 위키독스 플러그인을 등록하여 사용할 수 있습니다. 챗 GPT에서 플러그인 사용하기 위키독스 플러그인 등록하기 위키독스 플러그인 사용해 보기 위키독스 책 검색하기 위키독스 책 만들기 내 책으로 만들기 챗 GPT에서 플러그인 사용하기 챗 GPT는 다음과 같이 플러그인을 사용할 수 있습니다. 플러그인 등록은 현재 챗 GPT PLUS(유료) 사용자만 가능합니다. 위키독스 플러그인 등록하기 여기서 "No plugin enabled"를 눌러 플러그인 등록 화면으로 이동합니다. 플러그인 스토어에서 다음과 같이 "wikidocs"를 검색합니다. "Install" 버튼을 눌러 위키독스 플러그인을 등록합니다. 위키독스 플러그인 사용해 보기 위키독스 책 검색하기 그러면 이제 다음과 같이 질문해 볼 수 있습니다. 챗 GPT는 위키독스의 어떤 API를 써야 하는지 자체적으로 판단하여 잘 호출해 줍니다. 위키독스 책 만들기 다음과 같이 책을 만들 수 있습니다. 책을 생성한 후에는 다음과 같이 페이지를 추가할 수 있습니다. 그리고 작성한 페이지는 다음과 같이 수정도 가능합니다. 내 책으로 만들기 작성한 책의 저자는 ChatGPT입니다. 챗 GPT가 만든 책을 내 책으로 변환하려면 챗 GPT가 만든 위키독스 책으로 이동한 후 "내 책으로 전환하기" 버튼을 클릭하면 됩니다. (단, 위키독스에 로그인한 후에 사용할 수 있습니다.) 챗 GPT가 만든 책은 1시간 동안 변경이 없으면 자동으로 삭제됩니다. 따라서 삭제되기 전에 "내 책으로 전환하기"를 사용하여 내 책으로 바꾸어야 합니다. 단, 내 책으로 전환된 후에는 챗 GPT로 책의 페이지를 추가하거나 내용을 변경할 수 없습니다. 08-2 챗 GPT로 페이지 만들기 (시험 중) 위키독스에서 챗 GPT를 이용하여 페이지를 생성할 수 있습니다. 이 기능은 현재 시험 중입니다. 챗 GPT를 이용하여 페이지를 생성하는 방법은 다음과 같습니다. 책 수정 화면의 좌측 목차에서 "AI" 버튼을 누릅니다. 그러면 다음과 같은 화면이 나타납니다. 페이지 제목, 페이지에 대한 정보를 입력한 후 "생성하기" 버튼을 누릅니다. 페이지 생성에는 보통 30초 이상의 시간이 소요됩니다. 08-3 인공지능으로 책 이미지 만들기 (시험 중) 위키독스에서 인공지능(DALL · E)을 이용하여 책 이미지를 생성할 수 있습니다. 이 기능은 현재 시험 중입니다. 인공지능을 이용하여 책 이미지를 생성하는 방법은 다음과 같습니다. 책 수정 화면에서 "이미지 생성(AI)" 버튼을 누릅니다. 그러면 다음과 같은 화면이 나타납니다. 이미지 생성을 위한 정보를 입력한 후 "만들기" 버튼을 누릅니다. 이미지 생성에는 보통 5초 이상의 시간이 소요됩니다. 09 위키독스 용어 사전 위키독스 용어 사전이란? 용어 링크 만들기 에디터에서 사용하기 위키독스 용어 사전이란? 위키독스 용어 사전은 위키독스에서 자주 사용하는 용어를 등록하여 사용하는 서비스입니다. 위키독스 용어 사전: https://wikidocs.net/wiki/ 용어 링크 만들기 위키독스에서 용어 사전의 용어를 사용하려면 다음과 같이 페이지 편집 시 용어의 좌우를 [[" 와 "]]로 감싸서 입력하면 됩니다. 예: [["워드 커닝햄"]] 실행 결과: 워드 커닝햄 (링크를 클릭해 보세요) 용어 링크는 위와 같이 갈색 링크로 표시되며 해당 링크를 클릭하면 용어 사전에 등록된 내용을 팝업으로 보여줍니다. 팝업 상단의 용어 링크를 누르면 용어 사전의 해당 페이지로 이동합니다. 이동한 후 필요한 내용을 수정할 수 있습니다. 팝업을 닫으려면 다시 용어 링크를 클릭하거나 팝업창의 x 버튼을 클릭하면 됩니다. 용어 사전에 없는 용어인 경우에는 해당 용어 사전으로 이동하여 신규 용어를 작성할 수 있습니다. 에디터에서 사용하기 에디터의 아이콘을 통해서도 쉽게 용어 링크를 만들 수 있습니다. 원하는 단어를 선택한 후 에디터의 다음 아이콘을 누르면 단어의 좌우에 [[" 와 "]] 을 자동으로 넣어 줍니다. 98 아무거나 질문 위키독스의 궁금한 사항에 대해서 질문받습니다. 이곳에 댓글로 질문을 해 주세요. 또는 다음 위키독스 디스코드를 사용해 보세요. https://discord.gg/zPERvk7pza 99 기타 위키독스의 기타 사항 99-1 저자님을 모십니다 저자님, 위키독스가 저자님을 애타게 기다리고 있습니다. 지속적인 집필 관심 있는 주제에 대하여 오랜 시간을 두고 지속적으로 집필하실 저자분을 모십니다. 위키독스에서 만드는 책은 계속해서 다듬고 발전시켜 나가는 책입니다. 소셜 위키독스에서 책을 쓰면 재미가 있습니다. 댓글과 피드백을 통해 저자와 독자 간 커뮤니케이션이 가능하기 때문입니다. 책의 내용이 저자와 독자 간 상호 커뮤니케이션을 통해 점점 더 좋은 방향으로 수렴해 나갑니다. 광고 수익 작성한 책에 저자의 광고(예:구글 광고) 또는 위키독스의 포인트 광고를 삽입하여 수익을 낼 수 있습니다. 문의: <NAME> (<EMAIL>) 99-2 위키독스 장애일지 2023년 6월 16일 2023년 6월 4일 2022년 11월 12일 2021년 03월 26일 2021년 03월 24일 2021년 03월 17일 2021년 02월 25일 2021년 02월 03일 2023년 6월 16일 16시 40분 ~ 16시 50분, 서버 다운 원인 파악 안 됨 (AWS 지표상 아무 문제 없음) 인스턴스 재시작으로 해결 서버 업그레이드 예정 2023년 6월 4일 15시~19시 15분, 서버 다운 원인 파악 안 됨 (AWS 지표상 아무 문제 없음) 인스턴스 재시작으로 해결 캐시로 redis를 사용했기 때문으로 의심 중.. 2022년 11월 12일 19~20시, 1시간 정도 서버 다운 도 커 컨테이너 조작 실수 (관리자 실수로 인한 문제) 2021년 03월 26일 AWS Lightsail RDS - Postgresql 무응답 현상 AWS 기술 지원 의뢰 현상 지속 시 데이터베이스 업그레이드 필요 (2021년 3월 31일 데이터베이스 업그레이드 완료) 2021년 03월 24일 AWS Lightsail RDS - Postgresql 무응답 현상 18시 30분부터 발생 RDS 중지, 시작으로 해결 AWS 기술 지원 요청 2021년 03월 17일 AWS Lightsail RDS - Postgresql 무응답 현상 22시 30분부터 발생 RDS 중지, 시작으로 해결 (중지, 시작 시 25분가량 소요됨, 23시 05분 ~ 23시 27분) 재부팅은 해결되지 않음 2021년 02월 25일 AWS 인스턴스 예고 없이 중지 현상 (원인 파악 중) 인스턴스 시작으로 해결 2021년 02월 03일 AWS Lightsail RDS - Postgresql 무응답 현상 30분가량 RDS 리부팅으로 해결 (리 부팅 시 20분가량 소요됨) 99-3 위키독스 기술 스택 자세한 버전 정보는 생략합니다. (가급적 최신 버전을 유지하려고 노력하는 편입니다.) 서버 프로그래밍 언어 Python 3 프레임워크 Django FastAPI 데이터베이스 PostgreSQL 작업 큐 Celery Redis 프런트엔드 JQuery Bootstrap 3 OS Docker Ubuntu 웹서버 Nginx 미들웨어 Gunicorn Uvicorn 호스팅 AWS 99-4 위키독스 주요 이력 위키독스 History. 2023 RSS 피드 제공 (2023.10.31) 책 수정 시 reCAPTCHA 적용 (2023.10.25) 디스코드 운영 (2023.10.18) 검색 기능 개선 (2023.09.04) 용어 링크 기능 추가 (2023.08.25) 위키독스 용어 사전 서비스 출시 (2023.08.24) 매월 주말마다 도서 증정 이벤트 실시 (2023.08.04) 외부 링크인 경우 새 창으로 열도록 수정 (2023.08.04) 공개 책 필터링(최소 5페이지 이상, 스팸 저자 방지) 기능 추가 (2023.07.12) 책 가져오기, 소스코드 Copy 기능 추가 (2023.06.23) AWS 서버 업그레이드 (2023.06.17) Cloudflare 적용 (2023.06.17) 챗 GPT 플러그인 승인 (2023.06.11) 댓글 신고 기능 추가 (2023.06.01) 위키독스 영문 페이지 제공 (2023.05.17) 챗 GPT와의 연계 (2023.05.14) 책 백업 시 이미지도 함께 백업 (2023.04.27) 제목 역순 정렬 기능 추가 (2023.04.26) 책 표지 이미지 저장 시 영역을 선택할 수 있게 수정 (2023.04.24) 애플 페이 결제 추가 (2023.03.25) 위키독스 포인트 광고 서비스 출시 (2023.02.20) 2022 ISBN 발급을 위한 출판사 신고 (2022.11.29) 딥 러닝을 이용한 자연어 처리 입문 - 전자책 판매 시작 (2022.11.15) 이미지 업로드 도구 변경 (2022.11.11) 위키독스 전자책 판매 재개 (20022.11.01) 위키독스 API Open (2022.11.01) 도 커 기반으로 운영 (2022.10.29) 이미지 저장소, 스토리지 분리 (2022.10.29) 파이썬 3.10.6, 장고 4.1.2 업그레이드 (2022.10.29) 위키독스 extension MARK, SMARK 수정 (2022.04.20) highlight.js : 11.5.1 버전으로 업그레이드 (2022.04.20) 책 글자 크기 설정 기능 추가 (2022.04.19) 책 수정 기능 업데이트, 엔터키 줄 바꿈 추가 (2022.04.14) 우상단 고정 광고 추가 (2022.03.25) 이미지 업로드 후 에디터에 붙여 넣을 수 있는 "복사" 링크 추가 (2022.02.06) 2021 위키독스 앱 출시 (2021.10.04) 커스텀 라이선스 등록하기 (라이센스명과 URL을 수동으로 입력) (2021.09.03) 부모 목차가 비공개이면 자식 목차 안 보이도록 (2021.08) 페이스북 등에서 위키독스 링크 시 이미지 링크가 "책 표지"로 나오도록 수정하기 (2021.08) Mathjax 버전 2에서 3으로 업그레이드 (2021.05.23) AWS RDS 데이터베이스 업그레이드 (2021.03.31) 저자 프로필 페이지 추가 (2021.01.05) 최근 댓글 10개, 전체 댓글 보기 링크 추가 (2021.06.01) 마크다운 위키독스 Extension 코드 마커 추가 (2021.07.17) 2020 AWS EC2 서버 업그레이드 (2020.04.26) 2019 StackEditor 도입 및 화면 디자인 수정 (2019.11.08) 구글 광고 표시 오류수정 (2019.10.05) 2018 한글 목차 정렬 버그(PostgreSQL 한글 정렬 문제) 수정 (2018.03.10) 2017 목차 정렬 버그 수정 (2017.05.23) 광고 정책 변경 (2017.05.12) 헤더 및 목차 고정 (2017.04.20) 마크다운 에디터 변경 (2017.03.04) 책 다운로드 기능 추가 (2017.02.26) 검색 기능 추가 (2017.02.25) 파이썬 3.6 + Django 1.10.5 Upgrade (2017.01.22) 2014 수식 입력 지원 (2014.09.30) 2013 모바일 웹 지원 (2013.08.24) 이미지 업로드 지원 (2013.07.24) 위키독스 Version 2 Open (2013.07.01) 2008 위키독스 Open A. 개인정보처리 방침 최종 수정일: 2013년 6월 30일 '위키독스' 는 (이하 '회사'는) 고객님의 개인정보를 중요시하며, "정보통신망 이용 촉진 및 정보보호"에 관한 법률을 준수하고 있습니다. 회사는 개인정보 취급 방침을 통하여 고객님께서 제공하시는 개인정보가 어떠한 용도와 방식으로 이용되고 있으며, 개인정보보호를 위해 어떠한 조치가 취해지고 있는지 알려드립니다. 회사는 개인정보 취급 방침을 개정하는 경우 웹사이트 공지사항(또는 개별 공지)을 통하여 공지할 것입니다. 수집하는 개인정보의 항목 개인정보의 수집 및 이용목적 개인정보의 보유 및 이용 기간 개인정보의 파기 절차 및 방법 개인정보 제공 업무 위탁 이용자 및 법정대리인의 권리와 그 행사 방법 개인정보 자동 수집 장치의 설치, 운영 및 그 거부에 관한 사항 개인 정보에 관한 민원 서비스 기타 개인정보 침해에 대한 신고나 상담 수집하는 개인정보의 항목 본 방침은 : 2013년 06 월 30일부터 시행됩니다. 회사는 회원가입, 상담, 서비스 신청 등등을 위해 아래와 같은 개인정보를 수집하고 있습니다. 수집 항목 : 이름, 이메일 개인정보 수집 방법 : 홈페이지 (회원가입) 개인정보의 수집 및 이용목적 회사는 수집한 개인정보를 다음의 목적을 위해 활용합니다. 서비스 제공에 관한 계약 이행 및 서비스 제공에 따른 요금 정산 콘텐츠 제공 회원 관리: 회원제 서비스 이용에 따른 본인확인, 개인 식별, 불량 회원의 부정 이용 방지와 비인가 사용 방지, 가입 의사 확인, 고지사항 전달 개인정보의 보유 및 이용 기간 회사는 개인정보 수집 및 이용목적이 달성된 후에는 예외 없이 해당 정보를 지체 없이 파기합니다. 개인정보의 파기 절차 및 방법 회사는 원칙적으로 개인정보 수집 및 이용목적이 달성된 후에는 해당 정보를 바로 파기합니다. 파기 절차 및 방법은 다음과 같습니다. 파기 절차 회원님이 회원가입 등을 위해 입력하신 정보는 목적이 달성된 후 별도의 DB로 옮겨져(종이의 경우 별도의 서류함) 내부 방침 및 기타 관련 법령에 의한 정보보호 사유에 따라(보유 및 이용 기간 참조) 일정 기간 저장된 후 파기됩니다. 별도 DB로 옮겨진 개인정보는 법률에 의한 경우가 아니고서는 보유되는 이외의 다른 목적으로 이용되지 않습니다. 파기 방법 전자적 파일 형태로 저장된 개인정보는 기록을 재생할 수 없는 기술적 방법을 사용하여 삭제합니다. 개인정보 제공 회사는 이용자의 개인정보를 원칙적으로 외부에 제공하지 않습니다. 다만, 아래의 경우에는 예외로 합니다. 이용자들이 사전에 동의한 경우 법령의 규정에 따르거나, 수사 목적으로 법령에 정해진 절차와 방법에 따라 수사기관의 요구가 있는 경우 업무 위탁 회사는 고객님의 동의 없이 고객님의 정보를 외부 업체에 위탁하지 않습니다. 향후 그러한 필요가 생길 경우, 위탁 대상자와 위탁 업무 내용에 대해 고객님에게 통지하고 필요한 경우 사전 동의를 받도록 하겠습니다. 이용자 및 법정대리인의 권리와 그 행사 방법 이용자 및 법정 대리인은 언제든지 등록된 자신 혹은 당해 만 14세 미만 아동의 개인정보를 조회하거나 수정할 수 있으며 가입 해지를 요청할 수도 있습니다. 이용자 혹은 만 14세 미만 아동의 개인정보 조회? 수정을 위해서는 ‘개인정보변 경’(또는 ‘회원 정보 수정’ 등)을 가입해 지(동의 철회)를 위해서는 “회원 탈퇴”를 클릭하여 본인 확인 절차를 거치신 후 직접 열람, 정정 또는 탈퇴가 가능합니다. 혹은 개인 정보관리 책임자에게 서면, 전화 또는 이메일로 연락하시면 바로 조치하겠습니다. 귀하가 개인정보의 오류에 대한 정정을 요청하신 경우에는 정정을 완료하기 전까지 당해 개인정보를 이용 또는 제공하지 않습니다. 또한 잘못된 개인정보를 제3자에게 이미 제공한 경우에는 정정 처리결과를 제삼자에게 바로 통지하여 정정이 이루어지도록 하겠습니다. 회사는 이용자 혹은 법정 대리인의 요청으로 해지 또는 삭제된 개인정보는 “회사가 수집하는 개인정보의 보유 및 이용 기간”에 명시된 바에 따라 처리하고 그 외의 용도로 열람 또는 이용할 수 없도록 처리하고 있습니다. 개인정보 자동 수집 장치의 설치, 운영 및 그 거부에 관한 사항 쿠키 등 인터넷 서비스 이용 시 자동 생성되는 개인정보를 수집하는 장치를 운영하지 않습니다. 개인 정보에 관한 민원 서비스 회사는 고객의 개인정보를 보호하고 개인 정보와 관련한 불만을 처리하기 위하여 아래와 같이 관련 부서 및 개인정보 관리 책임자를 지정하고 있습니다. 개인정보 관리 책임자 성명 : <NAME> <EMAIL> 기타 개인정보 침해에 대한 신고나 상담 귀하께서는 회사의 서비스를 이용하시며 발생하는 모든 개인정보보호 관련 민원을 개인정보 관리 책임자 혹은 담당 부서로 신고하실 수 있습니다. 회사는 이용자들과 관련한 신고사항에 대해 신속하게 충분한 답변을 드릴 것입니다. 기타 개인정보 침해에 대한 신고나 상담이 필요하신 경우에는 아래 기관에 문의하시기를 바랍니다. 개인 정보 침해신고센터 (www.1336.or.kr/국번 없이 118) 정보보호 마크 인증위원회 (www.eprivacy.or.kr/02-580-0533~4) 대검찰청 인터넷 범죄 수사센터 (http://icic.sppo.go.kr/02-3480-3600) 경찰청 사이버테러대응센터 (www.ctrc.go.kr/02-392-0330) B. 서비스 약관 최종 수정일: 2022년 11월 7일 위키독스 서비스 및 제품(이하 ‘서비스’)을 이용해 주셔서 감사합니다. 본 약관은 다양한 위키독스 서비스의 이용과 관련하여 위키독스 서비스를 제공하는 위키독스와 이를 이용하는 위키독스 서비스 회원(이하 ‘회원’) 또는 비회원과의 관계를 설명하며, 아울러 여러분의 위키독스 서비스 이용에 도움이 될 수 있는 유익한 정보를 포함하고 있습니다. 위키독스 서비스를 이용하시거나 위키독스 서비스 회원으로 가입하실 경우 여러분은 본 약관 및 관련 운영 정책을 확인하거나 동의하게 되므로, 잠시 시간을 내시어 주의 깊게 살펴봐 주시기를 바랍니다 다양한 위키독스 서비스를 즐겨보세요. 여러분이 제공한 콘텐츠를 소중히 다룰 것입니다. 여러분의 개인정보를 소중히 보호합니다. 타인의 권리를 존중해 주세요. 위키독스 서비스 이용과 관련하여 몇 가지 주의사항이 있습니다. 부득이 서비스 이용을 제한할 경우 합리적인 절차를 준수합니다. 위키독스의 잘못은 위키독스가 책임집니다. 언제든지 위키독스 서비스 이용계약을 해지하실 수 있습니다. 일부 위키독스 서비스에는 광고가 포함되어 있습니다. 서비스 중단 또는 변경 시 꼭 알려드리겠습니다. 주요 사항을 잘 안내하고 여러분의 소중한 의견에 귀 기울이겠습니다. 위키독스 전자책 판매와 관련하여 몇 가지 주의사항이 있습니다. 여러분이 쉽게 알 수 있도록 약관 및 운영정책을 게시하며 사전 공지 후 개정합니다. 다양한 위키독스 서비스를 즐겨보세요. 위키독스는 wikidocs.net을 비롯한 위키독스 도메인의 웹사이트 및 응용프로그램(애플리케이션, 앱)을 통해 정보 검색, 다른 이용자와의 커뮤니케이션, 콘텐츠 제공, PDF 구입 등 여러분의 생활에 편리함을 더할 수 있는 다양한 서비스를 제공하고 있습니다. 여러분은 PC, 휴대전화 등 인터넷 이용이 가능한 각종 단말기를 통해 각양각색의 위키독스 서비스를 자유롭게 이용하실 수 있으며, 개별 서비스들의 구체적인 내용은 각 서비스 상의 안내, 공지사항, 위키독스 웹 고객센터(이하‘고객센터’) 도움말 등에서 쉽게 확인하실 수 있습니다. 회원으로 가입하시면 위키독스 서비스를 더욱 편리하게 이용할 수 있습니다. 여러분은 본 약관을 읽고 동의하신 후 회원 가입을 신청하실 수 있으며, 위키독스는 이에 대한 승낙을 통해 회원 가입 절차를 완료하고 여러분께 위키독스 서비스 이용 계정(이하 ‘계정’)을 부여합니다. 계정이란 회원이 위키독스 서비스에 로그인한 이후 이용하는 각종 서비스 이용 이력을 회원별로 관리하기 위해 설정한 회원 식별 단위를 말합니다. 회원은 자신의 계정을 통해 좀 더 다양한 위키독스 서비스를 더욱 편리하게 이용할 수 있습니다. 여러분이 제공한 콘텐츠를 소중히 다룰 것입니다. 위키독스는 여러분이 게재한 게시물이 위키독스 서비스를 통해 다른 이용자들에게 전달되어 우리 모두의 삶을 더욱 풍요롭게 해줄 것을 기대합니다. 게시물은 여러분이 타인 또는 자신이 보게 할 목적으로 위키독스 서비스상에 게재한 부호, 문자, 음성, 음향, 그림, 사진,<NAME>상, 링크 등으로 구성된 각종 콘텐츠 자체 또는 파일을 말합니다. 위키독스는 여러분의 생각과 감정이 표현된 콘텐츠를 소중히 보호할 것을 약속드립니다. 여러분이 제작하여 게재한 게시물에 대한 지식 재산권 등의 권리는 당연히 여러분에게 있습니다. 한편, 위키독스 서비스를 통해 여러분이 게재한 게시물을 적법하게 제공하려면 해당 콘텐츠에 대한 저장, 복제, 수정, 공중 송신, 전시, 배포, 이차적 저작물 작성(단, 번역에 한함) 등의 이용 권한(기한과 지역 제한에 정함이 없으며, 별도 대가 지급이 없는 라이선스)이 필요합니다. 게시물 게재로 여러분은 위키독스에게 그러한 권한을 부여하게 되므로, 여러분은 이에 필요한 권리를 보유하고 있어야 합니다. 위키독스는 여러분이 부여해 주신 콘텐츠 이용 권한을 저작권법 등 관련 법령에서 정하는 바에 따라 위키독스 서비스 내 노출, 서비스 홍보를 위한 활용, 서비스 운영, 개선 및 새로운 서비스 개발을 위한 연구, 웹 접근성 등 법률상 의무 준수, 외부 사이트에서의 검색, 수집 및 링크 허용을 위해서만 제한적으로 행사할 것입니다. 만약, 그 밖의 목적을 위해 부득이 여러분의 콘텐츠를 이용하고자 할 경우엔 사전에 여러분께 설명을 해드리고 동의 받도록 하겠습니다. 위키독스는 여러분이 자신이 제공한 콘텐츠에 대한 위키독스 또는 다른 이용자들의 이용 또는 접근을 더욱 쉽게 관리할 수 있도록 다양한 수단을 제공하기 위해 노력하고 있습니다. 여러분은 위키독스 서비스 내에 콘텐츠 삭제, 비공개 등의 관리기능이 제공되는 경우 이를 통해 직접 타인의 이용 또는 접근을 통제할 수 있고, 고객센터를 통해서도 콘텐츠의 삭제, 비공개, 검색 결과 제외 등의 조치를 요청할 수 있습니다. 다만, 일부 위키독스 서비스의 경우 삭제, 비공개 등의 처리가 어려울 수 있으며, 이러한 내용은 각 서비스 상의 안내, 공지사항, 도움말 등에서 확인해 주시길 부탁드립니다. 여러분의 개인정보를 소중히 보호합니다. 위키독스는 서비스의 원활한 제공을 위하여 회원이 동의한 목적과 범위 내에서만 개인정보를 수집·이용하며, 개인정보 보호 관련 법령에 따라 안전하게 관리합니다. 위키독스가 이용자 및 회원에 대해 관련 개인정보를 안전하게 처리하기 위하여 기울이는 노력이나 기타 상세한 사항은 개인정보 처리 방침에서 확인하실 수 있습니다. 위키독스는 여러분이 서비스를 이용하기 위해 일정 기간 로그인 혹은 접속한 기록이 없는 경우, 전자메일, 서비스 내 알림 또는 기타 적절한 전자적 수단을 통해 사전에 안내해 드린 후 여러분의 정보를 파기하거나 분리 보관할 수 있으며, 만약 이에 따라 서비스 제공을 위해 필수적인 정보가 부족해질 경우 부득이 관련 서비스 이용계약을 해지할 수 있습니다. 타인의 권리를 존중해 주세요. 여러분이 무심코 게재한 게시물로 인해 타인의 저작권이 침해되거나 명예훼손 등 권리 침해가 발생할 수 있습니다. 위키독스는 이에 대한 문제 해결을 위해 ‘정보통신망 이용 촉진 및 정보보호 등에 관한 법률’ 및 ‘저작권법’ 등을 근거로 권리침해 주장자의 요청에 따른 게시물 게시 중단, 원 게시자의 이의신청에 따른 해당 게시물 게시 재개 등으로 처리할 수 있습니다. 위키독스에서 제공하는 모든 서비스에서 아래와 같은 문제가 있다고 생각되는 경우, 해당 게시물에 대해 임시로 게시 중단을 할 수 있습니다. 본인의 저작물을 무단으로 도용당한 경우 본인의 명예를 훼손당한 경우 본인의 초상권 및 사생활을 침해당한 경우 위키독스는 저작물의 권리 침해 여부를 판단할 수 없습니다. 위키독스는 게시물이 실제로 권리를 침해했는지 임의로 판단할 수 없습니다. 권리 침해에 대한 판단 및 게시물 조치에 대한 결정은 적법한 자격을 갖춘 관련 기관을 통해 받아야 합니다. 관련 기관의 판단까지 시간이 소요될 수 있기 때문에 게시중단을 통해 우선 임시로 조치해 드리는 것입니다. 다만, 임시 조치이기 때문에 근본적인 문제 해결은 반드시 관련 기관을 통한 법률 상담 및 구제 절차를 통해 진행해야 합니다. 검찰청: 국번 없이 1301 (휴대전화: 지역번호 1301)- 해킹, 컴퓨터바이러스 유포, 전자상거래 사기, 개인 정보 침해 관련 수사 경찰청 사이버안전국: 국번 없이 182 - 해킹, 바이러스, 개인 정보 도용, 게임 사기, 인터넷 사기 등 각종 사이버 범죄 신고 한국저작권위원회: 02-2660-0000 - 저작권 등록, 심의와 분쟁 조정 및 상담 방송통신심의위원회: 02-3219-5114,5333 - 정보 통신상에서의 건전한 문화 창달 및 정보 통신에 올바른 이용 환경 조성 명예훼손 분쟁조정부: 국번 없이 1377 - 정보통신망에서 발생하는 명예훼손과 성폭력 등 사이버 권리침해에 대한 다양한 상담과 분쟁 조정 한국 인터넷진흥원: 02-405-4118,5118 - 개인 정보 보호와 관련한 상담 및 개인 정보 침해 신고 한편, 위키독스 서비스를 통해 타인의 콘텐츠를 이용한다고 하여 여러분이 해당 콘텐츠에 대한 지식 재산권을 보유하게 되는 것은 아닙니다. 여러분이 해당 콘텐츠를 자유롭게 이용하기 위해서는 그 이용이 저작권법 등 관련 법률에 따라 허용되는 범위 내에 있거나, 해당 콘텐츠의 지식 재산권자로부터 별도의 이용 허락을 받아야 하므로 각별한 주의가 필요합니다. 위키독스는 여러분이 위키독스 서비스를 마음껏 이용할 수 있도록 여러분께 위키독스 서비스에 수반되는 관련 소프트웨어 사용에 관한 이용 권한을 부여합니다. 이 경우 여러분의 자유로운 이용은 위키독스가 제시하는 이용 조건에 부합하는 범위 내에서만 허용되고, 이러한 권한은 양도가 불가능하며, 비독점적 조건 및 법적 고지가 적용된다는 점을 유의해 주세요. 위키독스 서비스 이용과 관련하여 몇 가지 주의사항이 있습니다. 위키독스는 여러분이 위키독스 서비스를 자유롭고 편리하게 이용할 수 있도록 최선을 다하고 있습니다. 다만, 여러분이 위키독스 서비스를 더욱 안전하게 이용하고 위키독스 서비스에서 여러분과 타인의 권리가 서로 존중되고 보호받으려면 여러분의 도움과 협조가 필요합니다. 여러분의 안전한 서비스 이용과 권리 보호를 위해 부득이 아래의 경우 여러분의 게시물 게재나 위키독스 서비스 이용이 제한될 수 있으므로, 이에 대한 확인 및 준수를 요청합니다. 회원 가입 시 이메일 등의 정보를 허위로 기재해서는 안 됩니다. 회원 계정에 등록된 정보는 항상 정확한 최신 정보가 유지될 수 있도록 관리해 주세요. 자신의 계정을 다른 사람에게 판매, 양도, 대여 또는 담보로 제공하거나 다른 사람에게 그 사용을 허락해서는 안 됩니다. 아울러 자신의 계정이 아닌 타인의 계정을 무단으로 사용해서는 안 됩니다. 타인에 대해 직접적이고 명백한 신체적 위협을 가하는 내용의 게시물, 타인의 자해 행위 또는 자살을 부추기거나 권장하는 내용의 게시물, 타인의 신상정보, 사생활 등 비공개 개인정보를 드러내는 내용의 게시물, 타인을 지속적으로 따돌리거나 괴롭히는 내용의 게시물, 성매매를 제안, 알선, 유인 또는 강요하는 내용의 게시물, 공공 안전에 대해 직접적이고 심각한 위협을 가하는 내용의 게시물은 제한될 수 있습니다. 관련 법령상 금지되거나 형사처벌의 대상이 되는 행위를 수행하거나 이를 교사 또는 방조하는 등의 범죄 관련 직접적인 위험이 확인된 게시물, 관련 법령에서 홍보, 광고, 판매 등을 금지하고 있는 물건 또는 서비스를 홍보, 광고, 판매하는 내용의 게시물, 타인의 지식 재산권 등을 침해하거나 모욕, 사생활 침해 또는 명예훼손 등 타인의 권리를 침해하는 내용이 확인된 게시물은 제한될 수 있습니다. 자극적이고 노골적인 성행위를 묘사하는 등 타인에게 성적 수치심을 유발하거나 왜곡된 성 의식 등을 야기할 수 있는 내용의 게시물, 타인에게 잔혹감 또는 혐오감을 일으킬 수 있는 폭력적이고 자극적인 내용의 게시물, 본인 이외의 자를 사칭하거나 허위 사실을 주장하는 등 타인을 기만하는 내용의 게시물, 과도한 욕설, 비속어 등을 계속하여 반복적으로 사용하여 심한 혐오감 또는 불쾌감을 일으키는 내용의 게시물은 제한될 수 있습니다. 자동화된 수단을 활용하는 등 위키독스 서비스의 기능을 비정상적으로 이용하여 게재된 게시물, 위키독스 개별 서비스의 제공 취지와 부합하지 않는 내용의 게시물은 다른 이용자들의 정상적인 위키독스 서비스 이용에 불편을 초래하고 더 나아가 위키독스의 원활한 서비스 제공을 방해하므로 역시 제한될 수 있습니다. 위키독스의 사전 허락 없이 자동화된 수단(예: 매크로 프로그램, 로봇(봇), 스파이더, 스크레이퍼 등)을 이용하여 위키독스 서비스 회원으로 가입을 시도 또는 가입하거나, 위키독스 서비스에 로그인을 시도 또는 로그인하거나, 위키독스 서비스상에 게시물을 게재하거나, 위키독스 서비스를 통해 커뮤니케이션하거나(예: 전자메일, 쪽지 등), 위키독스 서비스에 게재된 회원의 아이디(ID), 게시물 등을 수집하거나, 위키독스 검색 서비스에서 특정 질의어로 검색하거나 혹은 그 검색 결과에서 특정 검색 결과를 선택(이른바 ‘클릭’) 하는 등 이용자(사람)의 실제 이용을 전제로 하는 위키독스 서비스의 제공 취지에 부합하지 않는 방식으로 위키독스 서비스를 이용하거나 이와 같은 위키독스 서비스에 대한 어뷰징(남용) 행위를 막기 위한 위키독스의 기술적 조치를 무력화하려는 모든 행위(예: IP를 지속적으로 바꿔가며 접속하는 행위, Captcha를 외부 설루션 등을 통해 우회하거나 무력화하는 행위 등)를 시도해서는 안 됩니다. 위키독스의 동의 없이 자동화된 수단에 의해 위키독스 서비스상에 광고가 게재되는 영역 또는 그 밖의 영역에 부호, 문자, 음성, 음향, 그림, 사진,<NAME>상, 링크 등으로 구성된 각종 콘텐츠 자체 또는 파일을 삽입해서는 안 됩니다. 또한, 위키독스 서비스 또는 이에 포함된 소프트웨어를 복사, 수정할 수 없으며, 이를 판매, 양도, 대여 또는 담보로 제공하거나 타인에게 그 이용을 허락해서는 안 됩니다. 위키독스 서비스에 포함된 소프트웨어를 역 설계, 소스 코드 추출 시도, 복제, 분해, 모방, 기타 변형하는 등의 행위도 금지됩니다(다만, 오픈소스에 해당되는 경우 그 자체 조건에 따릅니다). 그 밖에 바이러스나 기타 악성코드를 업로드하거나 위키독스 서비스의 원활한 운영을 방해할 목적으로 서비스 기능을 비정상적으로 이용하는 행위 역시 금지됩니다. 위키독스는 본 약관의 범위 내에서 게시물 운영정책, 개별 서비스에서의 약관 또는 운영정책, 각 서비스 상의 안내, 공지사항, 고객센터 도움말 등을 두어, 여러분에게 안정적이고 원활한 서비스 이용이 가능하도록 지원하고 있습니다. 각 세부 정책에는 여러분이 참고할 수 있도록 보다 구체적인 유의 사항을 포함하고 있으니, 본 약관 본문 및 구성 페이지 상의 링크 등을 통해 이를 확인해 주시기를 바랍니다. 부득이 서비스 이용을 제한할 경우 합리적인 절차를 준수합니다. 위키독스는 다양한 정보와 의견이 담긴 여러분의 콘텐츠를 소중히 다룰 것을 약속드립니다만, 여러분이 게재한 게시물이 관련 법령, 본 약관, 게시물 운영정책, 개별 서비스에서의 약관, 운영정책 등에 위배되는 경우, 부득이 이를 비공개 또는 삭제 처리하거나 게재를 거부할 수 있습니다. 다만, 이것이 위키독스가 모든 콘텐츠를 검토할 의무가 있다는 것을 의미하지는 않습니다. 또한 여러분이 관련 법령, 본 약관, 계정 및 게시물 운영정책, 개별 서비스에서의 약관, 운영정책 등을 준수하지 않을 경우, 위키독스는 여러분의 관련 행위 내용을 확인할 수 있으며, 그 확인 결과에 따라 위키독스 서비스 이용에 대한 주의를 당부하거나, 위키독스 서비스 이용을 일부 또는 전부, 일시 또는 영구히 정지시키는 등 그 이용을 제한할 수 있습니다. 한편, 이러한 이용 제한에도 불구하고 더 이상 위키독스 서비스 이용계약의 온전한 유지를 기대하기 어려운 경우엔 부득이 여러분과의 이용계약을 해지할 수 있습니다. 부득이 여러분의 서비스 이용을 제한해야 할 경우 명백한 법령 위반이나 타인의 권리침해로서 긴급한 위험 또는 피해 차단이 요구되는 사안 외에는 위와 같은 단계적 서비스 이용 제한 원칙을 준수하겠습니다. 명백한 법령 위반 등을 이유로 부득이 서비스 이용을 즉시 영구 정지시키는 경우 서비스 이용을 통해 획득한 포인트 및 기타 혜택 등은 모두 소멸하고 이에 대해 별도로 보상하지 않으므로 유의해 주시기를 바랍니다. 서비스 이용 제한의 조건, 세부 내용 등은 계정 운영정책 및 개별 서비스에서의 운영정책을 참고하시기를 바랍니다. 위키독스의 잘못은 위키독스가 책임집니다. 위키독스는 여러분이 위키독스 서비스를 이용하는 데 위키독스의 고의 또는 과실로 인하여 손해를 입게 될 경우 관련 법령에 따라 여러분의 손해를 배상합니다. 다만, 천재지변 또는 이에<NAME>는 불가항력으로 인하여 위키독스가 서비스를 제공할 수 없거나 이용자의 고의 또는 과실로 인하여 서비스를 이용할 수 없어 발생한 손해에 대해서 위키독스는 책임을 부담하지 않습니다. 그리고 위키독스가 손해배상책임을 부담하는 경우에도 통상적으로 예견이 불가능하거나 특별한 사정으로 인한 특별 손해 또는 간접 손해, 기타 징벌적 손해에 대해서는 관련 법령에 특별한 규정이 없는 한 책임을 부담하지 않습니다. 한편, 위키독스 서비스를 매개로 한 여러분과 다른 회원 간 또는 여러분과 비회원 간의 의견 교환, 거래 등에서 발생한 손해나 여러분이 서비스 상에 게재된 타인의 게시물 등의 콘텐츠를 신뢰함으로써 발생한 손해에 대해서도 위키독스는 특별한 사정이 없으면 이에 대해 책임을 부담하지 않습니다. 언제든지 위키독스 서비스 이용계약을 해지하실 수 있습니다. 위키독스에게는 참 안타까운 일입니다만, 회원은 언제든지 위키독스 서비스 이용계약 해지를 신청하여 회원에서 탈퇴할 수 있으며, 이 경우 위키독스는 관련 법령 등이 정하는 바에 따라 이를 지체 없이 처리하겠습니다. 위키독스 서비스 이용계약이 해지되면, 관련 법령 및 개인정보 처리 방침에 따라 위키독스가 해당 회원의 정보를 보유할 수 있는 경우를 제외하고, 해당 회원 계정에 부속된 게시물 일체를 포함한 회원의 모든 데이터는 소멸함과 동시에 복구할 수 없게 됩니다. 다만, 이 경우에도 다른 회원이 별도로 담아 갔거나 스크랩한 게시물과 공용 게시판에 등록한 댓글 등의 게시물은 삭제되지 않으므로 반드시 해지 신청 이전에 삭제하신 후 탈퇴하시기를 바랍니다. 일부 위키독스 서비스에는 광고가 포함되어 있습니다. 여러분이 다양한 위키독스 서비스를 이용하다 보면 간혹 일부 개별 서비스에 광고가 포함된 경우가 있습니다. 위키독스 서비스를 이용하면서 발생할 수 있는 데이터 통신 요금은 가입하신 통신 사업자와의 이용계약에 따라 여러분이 부담하며, 포함된 광고 열람으로 인해 추가로 발생하는 비용 역시 여러분이 부담합니다. 원하는 위키독스 서비스를 이용하기 위해 원하지 않는 광고를 봐야 하는 경우가 있습니다. 이는 여러분에게 제공하는 다양한 위키독스 서비스를 원칙적으로 무료로 제공할 수 있게 해주는 데 기여하며, 더 나아가 위키독스가 연구 개발에 투자하여 더 나은 서비스를 제공할 수 있는 기반이 됩니다. 최근 타사의 일부 서비스들이 광고 없는 서비스 이용을 강조하며 주된 서비스를 유료로 제공하고 있는 관행이 이를 뒷받침합니다. 위키독스는 여러분의 본의 아닌 불편이나 부담이 최소화될 방법에 대해 항상 고민하고 개선해 나가겠습니다. 서비스 중단 또는 변경 시 꼭 알려드리겠습니다. 위키독스는 연중무휴, 1일 24시간 안정적으로 서비스를 제공하기 위해 최선을 다하고 있습니다만, 컴퓨터, 서버 등 정보통신 설비의 보수 점검, 교체 또는 고장, 통신 두절 등 운영상 타당한 이유가 있는 경우 부득이 서비스의 전부 또는 일부를 중단할 수 있습니다. 한편, 위키독스는 서비스 운영 또는 개선을 위해 상당한 필요성이 있는 경우 서비스의 전부 또는 일부를 수정, 변경 또는 종료할 수 있습니다. 무료로 제공되는 서비스의 전부 또는 일부를 수정, 변경 또는 종료하게 된 경우 관련 법령에 특별한 규정이 없는 한 별도의 보상을 하지 않습니다. 이 경우 위키독스는 예측할 수 있는 경우 상당 기간 전에 이를 안내하며, 만약 예측 불가능한 경우라면 사후 지체 없이 상세히 설명하고 안내해 드리겠습니다. 또한 서비스 중단의 경우에는 여러분 자신의 콘텐츠를 백업할 수 있도록 합리적이고 충분한 기회를 제공하도록 하겠습니다. 주요 사항을 잘 안내하고 여러분의 소중한 의견에 귀 기울이겠습니다. 위키독스는 서비스 이용에 필요한 주요 사항을 적시에 잘 안내해 드릴 수 있도록 힘쓰겠습니다. 회원에게 통지하는 경우 전자메일, 서비스 내 알림 또는 기타 적절한 전자적 수단을 통해 개별적으로 알려 드릴 것이며, 다만 회원 전체에 대한 통지가 필요할 경우엔 7일 이상 wikidocs.net을 비롯한 위키독스 도메인의 웹사이트 및 응용프로그램(애플리케이션, 앱) 초기 화면 또는 공지사항 등에 관련 내용을 게시하도록 하겠습니다. 위키독스는 여러분의 소중한 의견에 귀 기울이겠습니다. 여러분은 언제든지 고객센터를 통해 서비스 이용과 관련된 의견이나 개선사항을 전달할 수 있으며, 위키독스는 합리적 범위 내에서 가능한 그 처리 과정 및 결과를 여러분께 전달할 수 있게 하겠습니다. 위키독스 전자책 판매와 관련하여 몇 가지 주의사항이 있습니다. 위키독스에서 전자책을 판매하는 회원은 다음의 내용에 대한 확인 및 준수를 요청합니다. 전자책 판매의 흐름 (역할 분담) 위키독스는 다음과 같은 절차와 역할에 따라 전자책을 판매합니다. 회원이 온라인에서 책을 작성합니다. 회원이 위키독스 관리자에게 책 판매를 요청합니다. 위키독스는 자체 심사 과정을 통해 책 판매 가능 여부를 판단합니다. 회원의 전자책(PDF)을 위키독스가 판매합니다. 위키독스는 익월에 해당 회원에게 인세를 정산합니다. 전자책 판매에 대한 심사 절차 전자책 판매의 가능 여부는 위키독스가 다음과 같은 점들을 고려하여 판단합니다. 책의 품질 책을 작성한 기간 독자들의 피드백 책의 분량 책의 단가 저작권 침해 여부 (내용 및 첨부 이미지 등) 저작권 침해 저작권 침해에 대한 판단은 다음과 같이 이루어집니다. 위키독스 관리자가 책을 수동으로 검토 해당 책의 댓글, 피드백을 통한 신고 접수 이메일을 통한 독자들의 신고 접수 만약, 저작권 침해가 인정된다고 판단될 경우 위키독스에서 해당 책의 판매 중지와 더불어 저작권 침해가 있는 페이지를 비공개 페이지로 전환한 후에 저자에게 통지하여 후속 조치를 취할 수 있습니다. 저작권 침해에 대한 보다 자세한 내용은 "타인의 권리를 존중해 주세요" 항목을 참조하시기를 바랍니다. 여러분이 쉽게 알 수 있도록 약관 및 운영정책을 게시하며 사전 공지 후 개정합니다. 위키독스는 본 약관의 내용을 여러분이 쉽게 확인할 수 있도록 서비스 초기 화면에 게시하고 있습니다. 위키독스는 수시로 본 약관, 계정 및 게시물 운영정책을 개정할 수 있습니다만, 관련 법령을 위배하지 않는 범위 내에서 개정할 것이며, 사전에 그 개정 이유와 적용 일자를 서비스 내에 알리도록 하겠습니다. 또한 여러분에게 불리할 수 있는 중대한 내용의 약관 변경의 경우에는 최소 30일 이전에 해당 서비스 내 공지하고 별도의 전자적 수단(전자메일, 서비스 내 알림 등)을 통해 개별적으로 알릴 것입니다. 위키독스는 변경된 약관을 게시한 날로부터 효력이 발생하는 날까지 약관 변경에 대한 여러분의 의견을 기다립니다. 위 기간이 지나도록 여러분의 의견이 위키독스에 접수되지 않으면, 여러분이 변경된 약관에 따라 서비스를 이용하는 데에 동의하는 것으로 간주합니다. 위키독스로서는 매우 안타까운 일이지만, 여러분이 변경된 약관에 동의하지 않는 경우 변경된 약관의 적용을 받는 해당 서비스의 제공이 더 이상 불가능하게 될 수 있습니다. 위키독스 서비스에는 기본적으로 본 약관이 적용됩니다만, 부득이 각 개별 서비스의 고유한 특성을 반영하기 위해 본 약관 외 별도의 약관, 운영정책이 추가로 적용될 때가 있습니다. 따라서 별도의 약관, 운영정책에서 그 개별 서비스 제공에 관하여 본 약관, 계정 및 게시물 운영정책과 다르게 정한 경우에는 별도의 약관, 운영정책이 우선하여 적용됩니다. 이러한 내용은 각각의 개별 서비스 초기 화면에서 확인해 주시기를 바랍니다. 본 약관은 한국어를 정본으로 합니다. 본 약관 또는 위키독스 서비스와 관련된 여러분과 위키독스와의 관계에는 대한민국의 법령이 적용됩니다. 그리고 본 약관 또는 위키독스 서비스와 관련하여 여러분과 위키독스 사이에 분쟁이 발생할 경우, 그 분쟁의 처리는 대한민국 '민사소송법'에서 정한 절차를 따릅니다. 적용 일자: 2022년 11월 07일 위키독스 서비스와 관련하여 궁금하신 사항이 있으시면 <EMAIL>으로 문의하시기를 바랍니다.<|endoftext|>

전문분야 텍스트 ### 제목: Must Learning with R (개정판) ### 본문: MustLearning with R 개정판입니다. 기존 제작한 책에서 다시 만들려고 했으나, 책의 구성이 어느 정도 바뀐 부분도 있기 때문에 다시 새롭게 구성을 하였습니다. 기본적으로 겹치는 부분은 내용이 비슷하지만, 추가된 내용도 많습니다. 블로그 주소 : https://mustlearning.tistory.com/ ================================================ MustLearning With R(MLR)에 많은 관심을 주셔서 감사합니다. MLR에서 더 좋은 내용으로 새로운 책이 출간이 되었습니다. 많은 관심 부탁드립니다. 감사합니다. 첵 제목: 실무 프로젝트로 배우는 데이터 분석 with R (업무에 곧바로 써먹는 R 실전 활용법) yes24: http://www.yes24.com/Product/Goods/101441297 ================================================ 온라인 강의 론칭: https://class101.page.link/pDWB 클래스 101에서 온라인 강의를 론칭하게 되었습니다. 많은 관심 부탁드립니다 데이터 분석에 생소한 사람들을 위한 R 데이터 분석 기본서 이 자료를 통해, 많은 분들이 데이터 분석의 진입 장벽을 극복하셨으면 하는 바람에 작성합니다. 작성자 : KK.Park, HJ.Oh, NY.Kim 이제는 R을 R 아야 할 때가 되었습니다. 간단하게 엑셀로 데이터를 처리하고 보고서를 작성하거나, SPSS를 통해 논문을 분석한다거나 그런 시대는 끝나가고 있습니다. 많은 기업, 연구분야에서 R, python 등을 활용한 데이터 분석 결과를 원하고 있습니다. 하지만, R 프로그램에 대한 어려움과 동시에 통계학에 대한 진입장벽이 상당히 높아, 많은 분들이 어려움을 겪고 있습니다. 이 책은 여러분들이 R과 통계학을 공부하는데, 진입장벽을 허물 수 있게 하는 목표로 제작된 책입니다. 책의 구성은 다음과 같습니다. R에 친숙해지기 필수 통계학 지식 익히기 필수 통계 모형 지식 익히기 기계학습 개론 통계학은 매우 어렵습니다. R도 처음 하는 사람에게 쉽지만은 않을 것입니다. 그렇기에 먼저 R에 대해 친숙해지는 과정을 거친 후, 통계학에 대해 다룹니다. 더 나아가, 기계학습 입문에 해당하는 내용도 다루면서 이 책을 보시는 분들이 데이터 분석에 조금 더 친숙함을 느끼셨으면 합니다. 오타, 오류 수정 : <EMAIL> Ch1. Intro Ch1에서는 기본적으로 왜 통계학을 공부해야 하는지, 왜 R과 Python 등 어려운 언어를 공부를 해야 하는지에 대해 다룹니다. 또한 데이터 분석의 기본적인 접근 방법을 다룹니다. A1. 서론 1. 서론 데이터 분석에 대해 생각을 해보는 시간을 가지고 시작하는 것이 좋을 것 같습니다. 지금 쓰는 글은 무조건적인 사실이기보다는, 평소에 제가 가지고 있는 생각을 쓰는 글이기에 가볍게 읽어주셨으면 합니다. 요즘 Big data, Data Scientist, Analyst 등의 단어를 자주 접할 수 있을 것입니다. 기술의 발전으로 인해 방대한 데이터를 분석할 수 있게 되었고, 오랜 시간 기록되면서 누적되기만을 반복했던 데이터를 통해 새로운 기술을 개발하고, 인사이트를 얻을 수 있게 되었기 때문입니다. 여기서 기술의 발전은 컴퓨터 장비들의 발전이라고 생각하면 됩니다. 원래 머신러닝, 딥러닝 등 빅데이터 분석 기술의 이론과 알고리즘은 옛날부터 완성되어 있었습니다. 다만, 장비들이 뒷받침을 하지 못해 구현을 못하고 있었을 뿐입니다. 하지만 기술이 발전된 지금, 빅데이터 분석방법론들은 여러 분야에서 빠른 속도로 적용되며, 도입되고 있습니다. 여기서 제가 하고 싶은 말은 이렇게 요약할 수 있습니다. 빅데이터 분석이라고 새롭고 어려운 신기술이 아닌, 기존에 정립되어 있었던 통계학의 연장선일 뿐이다. 또한, 요즘 빅데이터 분석방법론 하면서, 여러 분석 알고리즘을 익히면서 공부하시는 분들을 많이 볼 수 있습니다. 하지만, 전 그런 공부법이 그리 좋다고 생각이 들지 않습니다. 그 이유는 알고리즘을 많이 안다고 해서 해결되는 문제들은 현실에서 많이 없다는 것입니다. 그럼 데이터 분석 학습을 어떻게 해결해야 될까요? 알고리즘을 습득하기 전에 선행되어야 하는 사항들은 다음 3가지로 정리할 수 있습니다. 데이터 분석의 목적과 경쟁 상대 먼저, 분석의 목적은 당연히 돈입니다. 먹고살려고 공부하고, 일하는 것처럼, 데이터 분석을 활용하여 돈을 더 벌어올 수 있도록 예측 분석을 적용한다든지, 데이터를 정리하고, 분석하여 실무 프로세스에서의 구멍을 발견하고, 비용을 줄인다 등의 효과를 기대할 수 있습니다. 말이야 쉽고 멋있습니다. 하지만, 이걸 실제로 성공시키기에는 알고리즘만 적용시킨다고 할 수 있는 게 아닙니다. 돈이 되는 분석을 하기 위해서는 현장에서 수년, 수십 년간 쌓인 노하우와 프로세스를 이기는 것이 가장 중요합니다. 하지만 인간들이 이제까지 쌓아 올려 최적화시켜둔 실무 프로세스들은 언뜻 보기에는 비효율처럼 보여도, 생각보다 결과는 괜찮습니다. 즉 데이터 분석으로 이겨내기에는 만만한 상대는 아닙니다. 즉, 한마디로 정리하자면, 데이터 분석의 경쟁 상대는 이제까지 실무에 적용되어 있는 노하우와 프로세스입니다. 이것을 극복하지 못하면, 데이터 분석은 안 하니만을 못한 상황이 되기 마련입니다. 도메인에 대한 충분한 이해 그렇기에 실무(현장, 도메인)에 대한 이해가 완벽한 상태에서 데이터 분석을 적용시켜야 의미가 있는 분석이 됩니다. 예를 들어 이런 상황이라 할 수 있습니다. 요즘 데이터 분석에 대한 관심이 높은 상황에, 많은 대학교에서 빅데이터 분석학 커리큘럼을 구성하여, 대학원 코스를 구성하고 있습니다. 당연히 이런 대학원 학과에 관심이 가는 사람들도 많을 것입니다. 하지만 신생학과이기도 하고, 정보도 별로 없어 의혹은 생기고, 진학 전에 고민을 가지는 사람을 많이 봤습니다. 전 이런 분들께 이렇게 말해드리고 싶습니다. 만약, 금융권에서 빅데이터 분석을 하고 싶다. 그럼 빅데이터 융합 대학원이 아닌, 경영, 경제, 산업공학과에서 금융을 연구하시는 교수님한테 가서, 빅데이터 분석을 하시길 바랍니다. 도메인에 대한 이해가 부족한 상황에서의 분석은 말 그대로 삽질하는 거랑 다를 게 없습니다. 그냥 간단하게 막대그래프, 파이 차트 등 그려주면서 평균값이 몇입니다.라고 보고하는 것이 더 효과가 좋을 수가 있습니다. 그러니 꼭 일하고 싶은 분야에서의 도메인을 충분히 익히시길 바랍니다. 통계학에 대한 충분한 이해 머신러닝이니 딥러닝이니 뭐니 해도, 어차피 다 확률을 기반으로 한 통계분석의 연장선입니다. 통계학에 대한 충분한 이해 없이는 머신러닝 및 딥러닝을 공부한다 해도 그건 '흉내' 내는 거지, 안다고 할 수가 없습니다. 예를 들어 이런 상황입니다. 딥러닝을 공부하시는 분들이라면, 시그모이드(sigmoid)라는 활성화 함수를 듣거나 알고 계실 것입니다. 하지만 이 활성화 함수가 통계학에서의 로지스틱 회귀분석, 즉 Odds Ratio에서 기반한 것은 모르는 분들이 있습니다. 이건 시그모이드 활성화 함수가 어떻게 만들어졌는지는 관심도 없고, 그냥 남들이 그렇다 하니깐 그렇구나 한 것이라고 할 수 있습니다. 그러니 빅데이터 분석학을 공부하기 전에 통계학을 깊이 있게 공부하시길 바랍니다. 어차피 통계학에 대한 충분한 이해 없이는 머신러닝, 딥러닝을 아무리 공부해도 잘 이해가 되지는 않을 것입니다. 그래서 데이터 분석이 가뜩이나 어려운데, 효과를 보기도 힘들어? 그럼 공부를 해? 말아? 해야 합니다. 몰라서 못하는 것이랑, 알면서 안 하는 것이랑은 완전히 다른 문제입니다. 무엇보다 데이터 분석 방법론들을 공부하면서, 데이터를 보는 시각을 익히는 것이 더 중요합니다. 가끔 "세상 사는데 돈 계산만 잘하면 되지, 그 어려운 수학은 왜 공부시키는 거야. "라고 조금은 논란이 발생할 수 있는 말을 하시는 분들을 볼 수 있습니다. 여러분들도 아시다시피, 수학을 공부하는 이유는 돈 계산이 아니라, 논리에 따라 생각하는 힘을 키우는 것에 있습니다. 데이터 분석도 마찬가지입니다. 데이터는 어느 분야를 막론하고 항상 마주하게 됩니다. 하지만 데이터를 눈에 보이는 대로 결론내고 그 수준에서 멈출 것인지, 아님 더 나아가 데이터에서 새로운 인사이트를 도출해낼 것인지. 그것은 데이터 분석방법론을 공부하면서 터득한 사고력과 센스가 뒷받침되어야 가능한 일입니다. 그러니 꼭 공부하시길 바랍니다. 마지막으로, 이 책에서는 위 3가지 사항에 대한 답을 다 알려주지 못합니다. 세상은 너무 복잡하고 다양하기 때문에, 귀납법으로 정리하기에는 어려운 부분이 많습니다. 또한 저도 아직 공부해야 될 것이 많기 때문입니다. 하지만 마지막에 언급한 데이터를 보고 사고를 해내는 방법에 대해서는 제대로 다룰 수 있습니다. 그 부분을 집중 삼아 책을 작성하도록 하겠습니다. A2. R에 대한 소개 2. R에 대한 소개 R을 왜 공부해야 하는가? R은 철저히 데이터 분석을 위한 무료 분석 Tool입니다. 많은 회사에서는 엑셀을 이용하여 데이터 정리를 하고 보고서를 작성합니다. 엑셀은 매우 뛰어난 프로그램입니다. 그리고 다양한 기능을 내포하고 있습니다. 하지만, 다양한 기능을 보유하고 있다는 것은 '깊이'는 떨어진다는 소리와 맥락이 같습니다. 사실 일반적인 업무에서는 R이 크게 필요한 상황은 없을 것입니다. 하지만, '통계적'으로 무언가를 해보고 싶다면, 확실한 것은 엑셀로는 한계점에 부딪히길 마련입니다. 그럴 때 R이던 Python이던 어떤 언어를 통해 통계적인 기법을 적용시켜야 합니다. 엑셀의 단점 대용량 데이터에 대해 처리가 힘듭니다. 엑셀의 가장 큰 문제입니다. 대용량 데이터에 대해서는 엑셀을 키는 것만 해도 매우 큰 시간이 소비되며, 잘못 건드리면 프로그램이 먹통이 되어버리는 현상까지 심심치 않게 발생합니다. 엑셀로 할 수 있는 데이터 분석은 제한적이다. 간단한 빈도 분석을 하는 경우는 상관이 없지만, 조금 더 고급적인 분석과 시각화를 하기에 엑셀은 매우 한정적인 기능을 보유하고 있습니다. R의 장점 엑셀에 비교하여 대용량 데이터 처리가 능합니다. 대용량 데이터 처리는 사실 SQL을 이용해서 진행하는 것이 가장 좋습니다. 하지만, 데이터 분석을 하려면 R, Python, Spss, SAS 등의 분석프로그램을 사용해야 합니다. SQL은 DB 작업 용이지, 데이터 분석용은 아닙니다. 명령어 체계가 매우 자유롭다 R의 장점이자 단점입니다. 문법이 매우 자유로우며, 자바스크립트가 표준 국어사전을 따른다면, R은 부산 사투리도 알아듣는 수준이라고 생각하시면 편합니다. 오픈 소스(무료) 및 가벼운 프로그램 대부분의 함수는 필요한 패키지를 통해 돌릴 수 있습니다. 프로그램이 타 프로그램에 비해 매우 가벼우며, 프로그램 운영 상에서의 오류(환경 설정, 설치 상의 오류 등) 발생 확률이 극히 낮습니다. Python 버전이 바뀔 때마다, 윈도 버전이 바뀌는 경우, 필요한 Module들의 정상적 기능이 가능한가 불가능한가는 항상 극심한 스트레스를 발생시킵니다. R은 그런 게 없습니다. R의 단점 메모리를 많이 잡아먹습니다. R을 돌릴 때 컴퓨터의 Ram 용량은 꽤나 중요한 요소입니다. 연산속도가 빠른 편은 아닙니다. 자동문을 적용할 때, R이 타 프로그램에 비해 빠르게 계산하지는 않습니다. 새로운 패키지를 사용할 때, 열심히 패키지 설명서를 읽어야 됩니다. 어떤 프로그래밍 언어를 공부해야 될까? 데이터 분석 관련 직무를 원하시는 경우, SQL은 필수입니다. 분석을 하려면 일단 데이터를 원하는 조건으로 가져와야 합니다. 많은 데이터는 SQL 서버에 저장되어 있습니다. 데이터 분석을 하려면 유료 툴을 제외하고서는 R, Python 중 1개를 택해야 됩니다. 둘 다 하면 좋지만, 이 글을 보시는 분들은 아직 2개를 모두 다룰 수 있는 단계가 아닐 겁니다. 그러면 자신이 하고 싶어 하는 것에 더 부합하는 언어부터 하는 것이 맞습니다. R : 데이터 핸들링 및 통계 모델링, 기계학습 & 시각화 Python : 기계학습, 딥러닝, 강화 학습 등 개발 가볍게 데이터 분석을 실무에 적용시키기에는 R이 더 적합합니다. 같은 분석을 한다고 쳤을 때, 통계분석에 한해서는 R이 Python보다 코드를 간결하게 짤 수가 있습니다. 대신, 개발 쪽으로 넘어가면 R보다는 Python이 더 적합합니다. (사실 Python을 통한 개발은 윈도 운영체제를 사용하는 것부터가 에러 사항이기 때문에 리눅스 운영체제의 가상 머신을 설치해야 되는 등 머리가 많이 아픕니다. 즉, 입문자 입장에서는 제대로 무엇을 해보기 전에 머리가 엄청 아픕니다.) 정리하자면, 통계분석을 입문하는 입장에서는 Python보다는 R을 추천하는 입장입니다. 통계학도 어려운데, 코드 및 외부 요건도 어려우면 공부하는 데에 있어, 난관이 매우 많습니다. 흥미를 붙일 때까지는 R을 활용하면서 데이터 분석에 익숙해지는 것이 좋습니다. A3. 일상생활 속에서 축척되는 데이터 그리고 통계학 3. 일상생활 속에서 축척되는 데이터 그리고 통계학 본격적으로 시작하기에 앞서, 간단한 예시를 들어 통계학의 가장 기본이 되는 확률에 대해 다루어보도록 하겠습니다. 갑자기 등장한 수식에 어렵고 당황스러울 수도 있지만, 이 정도는 숙지를 하지고 계셔야, 다음에 통계학 이론이 등장하였을 때 어렵지 않게 적용할 수 있을 것입니다. 최근 회사에 지각하는 일이 잦아진 "A"는 사수한테서 일찍 다니라는 잔소리를 받았다. 그날 퇴근 후 "A"는 달력을 키고 기억을 더듬어가며, 출근 내역을 기록해 보았다. 기록이 끝난 "A"는 본인도 놀랄 만큼의 빈도로 지각을 자주 하고 있다는 점을 깨달았다. 이래서는 안되겠다고 다짐을 한 "A"는 매일매일 자신의 출근 정보를 기록하기 시작하였다. 가장 먼저 시작한 작업은 기록할 사항(요인)들을 정하는 작업이었다. "A"는 자신의 경험에 기반하여 다음의 사항(요인)을 한 달 동안 꾸준히 기록하기로 했다. (여기서, 어제의 출근 상황은 오늘의 출근에 영향을 주지 않으며, 오늘의 출근은 내일의 출근에 영향을 주지 않는 독립성을 가정합니다. 또한, 각 교통 편의 선택, 날씨, 알람 기상시간 등은 모두 독립적으로 적용됨을 가정합니다.) 데이터(자료)의 수집 과정 날짜 : 년/월/일 기상시간 : 알람 시간 준수 여부 교통편 : 지하철/버스/택시 날씨 : 맑음/비 눈 지각 여부 : O/X 확률의 계산 "A"는 매일매일 빠짐없이 자신의 출근 기록을 입력했으며, 1달이 지난 다음 30일간의 출근 기록을 분석해 보기로 마음을 먹었다. 하지만 이제까지 데이터 분석을 제대로 해본 적이 없는 "A"는 데이터는 있으나, 무엇부터 시작해야 할지도 막막해졌다. 엑셀로 지각을 몇 번 했는지 구해보는 것이 전부였다. 결국 주변에 의학통계분석 연구에 매진하고 있는 "H"에게 도움을 요청하였다. "H"는 "A"에게 먼저 확률부터 구해보자고 하였다. 확률은 수집된 데이터의 수대비 관심사항(지각 여부)가 얼마큼 기록되었는 지로 계산을 합니다. (지각 여부(Event)를 편하게로 표기합니다.) 지각 횟수 데이터수집일 는를의미은갯수를의미 [ = ] 지 횟 데 터 수 일 n ( = ) ( = o E 1 ) P [ = ] P [ = ] 1 P 이러한 확률들을 우리는 사전 확률이라고 부릅니다. 수집된 데이티에서 계산을 진행해 본 결과, 23 으로, 평상시에 지각을 할 확률은 34.7 정도입니다. 하지만, 이 정도의 정보는 "A"도 엑세로 충분히 쉽게 구할 수 있는 정보입니다. 그래서 "A"는 이런 간단한 값 말고 좀 뭔가 더 알아낼 수 없을까라는 의문을 가지게 될 것입니다. "H"는 상황에 따라, 지각할 확률을 계산해 보자고 제안한다. 예를 들어, 선택한 교통편에 따른 지각 확률을 계산하는 것이다. 이런 확률 계산을 '조건이 주어진 상황에서 상황이 발생할 확률'이라고 해서 조건부 확률이라고 합니다. [ = | = u ] P [ = ∩ = u ] [ = u ] [ = , = u ] 는 버스를 탔을 때 지각을 한 경우에 대한 확률을 의미합니다. 이러한 확률을 결합 확률이라 합니다. [ = ∩ = u ] n ( = ∩ = u) ( = ∪ = ) 3 23 여기서 구한 경우의 수에 버스를 선택할 확률 ( [ = u ] ) 를 나누어 주면, 특정 조건 하에서 사건이 발생하는 확률을 구할 수가 있습니다. 만약 두 사건(지각 여부, 교통편)이 독립이라면 결합 확률을 구하는 공식은 다음과 같습니다. [ ∩ ] P [ ] [ ] 하지만 두 사건이 독립이 아닐 때는, 결합 확률은 다음과 같이 정의가 됩니다. [ ∩ ] P [ | ] [ ] P [ | ] [ ] [ = | = u ] P [ = ∩ = u ] [ = u ] 3 23 / 23 3 이경우, 교통편에서 버스를 선택(관측) 한 후, 지각 확률을 계산하였다는 의미로 사후 확률이라 정의합니다. 반대로 H는 지각을 했는데 버스를 탔을 가능성에 대해 계산을 해보자고 제안을 한다. [ = u | = ] P [ = u ∩ = ] [ = ] = [ = | = u P [ = $$ \frac{3}{7}\frac{3}{23}/ \frac{8}{23} = \frac{0.06}{0.34}=0.17 $$ 이렇게 사건이 발생하였을 때, 경우에 따른 가능성을 계산하는 것이면 이를 가능도(우도)*라고 합니다. 여기까지 다룬 확률들의 종류를 정리하면 다음 표와 같습니다. 경우 명칭 계산식 지각할 확률 사전 확률 [ = ] 버스를 타고 지각할 확률 결합 확률 [ = ∩ = u ] 버스를 탔을 때 지각할 확률 사후 확률 [ = ∩ = u ] [ = u ] 지각을 했을 때 버스를 탔을 가능성 가능도 [ = U ∩ = ] [ = ] 확률을 기반으로 한 통계학은 이렇게 일상생활 속에 녹아있습니다. 우리는 이러한 점을 항상 유념하여 데이터 분석의 기반이 되는 통계학을 공부해야 되며, 워밍업을 위하여 위 케이스를 살짝 다루어 보았습니다. 여기서 강조하고 싶은 것은 같은 데이터라 할지라도, 통계학 지식의 수준에 따라 다르게 보일 수 있다는 점입니다. A4. 데이터 분석의 프로세스 4. 데이터 분석의 프로세스 데이터 분석의 과정은 요리의 과정과 비슷합니다. 이번에는 데이터 분석의 진행 방식에 대해 다뤄볼까 합니다. 데이터 분석은 흔히 '요리'와 비교할 수가 있습니다. 여러분들이 알고 계시는 요리의 프로세스를 간단하게 요약하자면, '재료 공수', '재료 파악', '재료 손질', '요리', '시식'의 과정으로 정의를 내릴 수가 있습니다. 여기서 가장 중요한 것은 요리에 쓰일 재료의 특성을 정확하게 파악하고 있는 것입니다. 모든 재료에는 그에 알맞은 손질법과 가공법이 있습니다. 우리는 그 매뉴얼만 잘 따르면 되는 것입니다. 데이터도 마찬가지입니다. 우리는 데이터를 받게 되면, 바로 분석부터 시작하는 것이 아니라, 이 데이터가 어떤 과정을 통해 수집이 되었는지, 어떤 도메인 특성을 지니고 있는지부터 정확하게 파악을 해야 합니다. 조금 더 과장하자면, 성공적인 데이터 분석은 바로 이 첫 단계에서 갈린다고 생각해 봐도 무리가 없습니다. 데이터의 타입은 매우 다양합니다. 빅데이터 분석의 핵심인 IoT 센서 데이터부터 시작하여, 마케팅을 위한 고객 정보 데이터, 도로 혼잡도 예측을 위한 교통 데이터 등 매우 다양합니다. 데이터 분석의 80 ~ 90%는 전처리 과정이 해당이 된다. 데이터의 특성을 파악하셨다면 다음으로 확인해야 되는 부분은 데이터가 어떤 변수들로 구성되어 있는지 확인을 하는 작업입니다. 데이터에 포함되어 있는 변수들의 특성에 따라 데이터 핸들링 방법이 결정이 되며, 더 나아가 결론 도출을 위해서는 어떤 분석 모델을 적용해야 하는지도 바로 연결이 될 정도로 중요합니다. 변수의 특성을 파악하고 어떤 분석 모형까지 적용할지 결정이 되었다면, 그 뒤 작업들은 일사천리로 끝나게 됩니다. 정해져있는 매뉴얼에 따라 분석을 진행하면 되기에, 오히려 앞단에서 진행했던 핸들링(데이터 전처리) 작업보다 더 수월하게 끝낼 수도 있습니다. 명심하시길 바랍니다. 모든 데이터 분석의 업무량을 100으로 잡았을 때, 그중 80 ~ 90은 바로 데이터 전처리 작업이 해당됩니다. 어떤 분석이 데이터 분석을 망치는 요인일까? 데이터 분석이 망하는 이유에는 여러 가지가 있겠지만, 제가 생각했을 때는 '묻지 마 분석'입니다. 흔히들 사람들이 가장 많이 저지르는 잘못은 일단 데이터에 상관분석과 회귀분석을 때려 넣고 결괏값을 냅니다. 회귀분석에서 요구되는 기본 가정들은 깡그리 무시한 채, 일단 분석 결과를 내고 발표를 내는 경우도 많습니다. 다시 한번 말씀드리면, 분석 모형은 우리가 정하는 것이 아니라, 데이터의 특성이 알아서 정해주는 것입니다. 그러니 분석을 하기 전에 열심히 데이터부터 공부를 해야 합니다. 데이터의 도메인, 변수들의 분포, 전처리를 어떻게 할 것인지.. 그 모든 것이 포함이 됩니다. 가끔, 공부를 열심히 하신 분들이 어렵게 공부한 통계 모형, 기계학습 알고리즘 등을 활용하고 싶어, 분석 모형부터 정하고 데이터를 만지는 경우도 심심치 않게 있습니다. 이 경우도 마찬가지로 데이터 분석이 망하는 지름길입니다. 좀 많이 귀찮더라도 여러분들은 데이터에 대한 충분한 학습을 진행한 후, 분석 모형을 적용해야 합니다. 그래야 간결하면서도 의미가 있는 분석 결과를 뽑아낼 수가 있습니다. Ch2. R 기본 문법 1단계 기본적으로 Rstudio 편집기를 기준으로 진행합니다. Rstudio를 시작하기에 앞서, 몇 가지 중요한 Tip을 드리자면 다음과 같습니다. 처음 시작하는 분들이 가장 많이 틀리는 부분은 오타입니다. 소, 대문자를 구분하기 때문에 오타가 특히 많이 발생합니다. 특히 'No such file or directory'라는 Error가 발생한다면 오타가 발생하거나, 저장을 안한 것이니 코드를 다시 한번 확인하시길 바랍니다. 작성하다가 Tab 키를 누르면, 자동완성창이 뜹니다. 적극 활용하시길 바랍니다. 우측 상단의 Environment 창에서 데이터가 잘 불러와지고 저장되고 있는지 꾸준히 확인하면서 진행하면, 오류 발생을 줄일 수가 있습니다. Rstudio는 한글에 친화적이지 않으니 최대한 영어를 사용하시길 바랍니다. A1. 할당 및 논리문 1. 할당 및 논리문 할당 지정해 주는 명칭(저장소)에 값을 저장해 주는 매우 기본적인 컴퓨터 언어입니다. = : ~를 ~에 저장하여라 A = 2 print(A) [1] 2 실행 결과, A에 2가 저장되었으며, 출력하면 2가 나오는 것을 확인할 수 있습니다. 논리문 값이 지정해 준 조건을 만족하는지 값을 출력해 주는 기본적인 컴퓨터 언어입니다. 'TRUE' 혹은 'FALSE'값을 출력해 줍니다. 'TRUE'는 조건을 충족한다는 의미이며, 'FALSE'는 그 반대입니다. == : 인지 판단하여라 A == 2 [1] TRUE == : 인지 판단하여라 A != 2 [1] FALSE A2. c()의 활용 2. c()의 활용 벡터의 생성 c()는 Combind의 약자를 나타내는 명령어로, R에서 매우 자주 쓰이는 명령어입니다. c()는 벡터를 만드는 데 사용됩니다. 여기서 벡터라고 하면, 데이터에서 하나의 ’열(Column)’을 의미합니다. 즉, 데이터가 세로로 저장된다고 생각하시면 됩니다. c() : 벡터의 생성 B = c(2,3,4,5) print(B) [1] 2 3 4 5 A3. rep(), seq()을 통한 벡터 생성 3. rep(), sep()을 통한 벡터 생성 순차적인 수열 생성 sequence의 줄임말로 순차적인 데이터를 생성할 때 쓰입니다. seq() : seq(from = 시작 숫자, to = 마지막 숫자, by = 증가범위) # 1 ~ 10까지 1씩 증가하는 수열 생성 x1 = c(1:10) x1_2 = seq(from = 1, to = 10, by = 1) # 1 ~ 10까지 2씩 증가하는 수열 생성 x2 = seq(from = 1, to = 10, by = 2) print(x1) [1] 1 2 3 4 5 6 7 8 9 10 print(x1_2) [1] 1 2 3 4 5 6 7 8 9 10 print(x2) [1] 1 3 5 7 9 반복적인 수열 생성 rep()는 repeat의 줄임말로 반복된 데이터를 생성할 때 쓰입니다. rep() : rep(반복할 값, 반복할 횟수) # 1을 10번 반복 y = rep(1,10) print(y) [1] 1 1 1 1 1 1 1 1 1 1 y2 = rep(c(1,10), 2) print(y2) [1] 1 10 1 10 y3 = rep(c(1,10), c(2,2)) print(y3) [1] 1 1 10 10 A4. matrix(), data.frame()을 통해 데이터 셋 만들기 4. matrix(), data.frame()을 통해 데이터 셋 만들기 matrix의 생성 R에서는 일반적으로 데이터 셋을 matrix 형태 혹은 data.frame 형태로 정리한 후, 분석을 진행하는 경우가 많습니다. matrix(data = 데이터, nrow = 행의 수, ncol = 열의 수, byrow = 행/열 기준) MATRIX_R = matrix( data = x1, nrow = 5 ) print(MATRIX_R) [,1] [,2] [1, ] 1 6 [2, ] 2 7 [3, ] 3 8 [4, ] 4 9 [5, ] 5 10 MATRIX_C = matrix( data = x1, ncol = 5 ) print(MATRIX_C) [,1] [,2] [,3] [,4] [,5] [1, ] 1 3 5 7 9 [2, ] 2 4 6 8 10 dataframe의 생성 DATA_SET = data.frame( X1 = x1, # 변수명 = 벡터 값, X1_2 = x1_2, X2 = x2, y = y ) 데이터 상위단 보기 head()는 데이터의 상단부분을 지정해 주는 행만큼 출력해 주는 함수입니다. 현재 5로 설정하였으니 1 ~ 5행을 보여줍니다. head(데이터 프레임) print(head(DATA_SET, 5)) A5. length(), dim()을 활용한 데이터 형태 파악하기 5. length(), dim()을 활용한 데이터 형태 파악하기 저장된 데이터의 형태를 파악하는 것은, 데이터 분석 진행 상황 중에 틈틈이 확인을 해야 하는 사항입니다. 1차원 벡터인 경우, length()를 활용합니다. length(1차원 벡터) # 벡터에 속한 원소의 개수 length(x1) [1] 10 2차원 행렬, 데이터 프레임인 경우에는 dim()을 활용합니다. dim(행렬 혹은 데이터 프레임) # 행, 열 dim(MATRIX_R) [1] 5 2 dim(DATA_SET) [1] 10 4 A6. 괄호의 활용 6. 괄호의 활용 괄호에는 (), {}, []가 있습니다. 모든 컴퓨터 언어에서는 각 괄호의 종류에 따라 쓰이는 방식이 다릅니다. R에서는 이렇게 나뉩니다. ( ) ()는 실행 함수(function)과 함께 쓰입니다. 예를 들어, c()에서 c()는 들어오는 값들을 묶어 하나의 벡터로 만드는 기능을 실행합니다. () 안에는 분석하고자 하는 원소(element) 값들이 입력되어야 합니다. # ( ) A=c(1,2,3,4,5) print(A) [1] 1 2 3 4 5 { } { }는 for, if 문 등에서 조건식을 삽입할 때 쓰입니다. 예를 들어, A 벡터에 속해 있는 값들을 순서대로 출력을 해보도록 하겠습니다. # { } for(i in A){ print(i) # {} 안에 실행 함수를 삽입 } [1] 1 [1] 2 [1] 3 [1] 4 [1] 5 이번에는 빈 공간을 가지는 벡터를 하나 만든 다음, 빈 벡터에 값을 차례대로 삽입해 보도록 하겠습니다. B = c() # 빈 공간의 벡터 생성 for(k in seq(from = 1, to = 10, by = 1)){ B = c(B, k) } print(B) [1] 1 2 3 4 5 6 7 8 9 10 [] []는 Index를 입력해야 될 때 쓰입니다. 처음 시작하는 분들이 가장 틀리는 곳이 대괄호의 활용입니다. 언뜻 보기에는 쉽지만, 나중에 상당수의 Error는 여기서 발생하고 있습니다. 1차원 벡터의 경우, 간단하게 보고 싶은 위치만 입력하면 되지만, 2차원 이상의 데이터 셋에서는 보고 싶은 [행, 열]을 구분하여 입력을 해야 합니다. 1차원 데이터의 경우 # 2번째 값 A[2] [1] 2 # 1,2번째 값 A[1:2] [1] 1 2 # 3번째 값 빼고 A[-3] [1] 1 2 4 5 # 1,2,4,5번째 값 A[c(1,2,4,5)] [1] 1 2 4 5 2차원 data.frame() 형태의 경우 # 1행 전부 DATA_SET[1, ] # 1행 전부 X1 X1_2 X2 y 1 1 1 1 1 # 1열 전부 DATA_SET[,1] [1] 1 2 3 4 5 6 7 8 9 10 # 1,2,3 행 & 2열 빼고 나머지 print(DATA_SET[c(1,2,3),-2]) X1 X2 y 1 1 1 1 2 2 3 1 3 3 5 1 A7. 변수 형태 이해하기 7. 변수 형태 이해하기 R에서는 데이터의 타입을 다음으로 정리를 하며, 보통 ’Strings’라고 부릅니다. Strings 파악이 중요한 이유 Strings에 따라 완전히 다른 분석 결과가 나올 수 있습니다. 예를 들어, 순서형 변수를 명목형 변수로 취급하는 경우, 순서형에 속한 서열 정보를 포기하여 분석하게 되는 경우가 발생합니다. 또한 명령어에 따라 Error가 발생할 수 있습니다. 데이터를 변환하는 과정에서 값이 괴상하게 변경되는 상황도 발생합니다. 무엇보다 가장 중요한 이유는 분석하고자 하는 변수들의 Strings에 따라 분석방법론이 정해지게 됩니다. 변수의 특성에 대한 내용은 매우 간단하지만, 분석 과정에서는 많은 실수가 발생할 수 있으며, 개인적으로는 분석가의 센스가 가장 중요하게 적용되는 부분입니다. Discrete(이산형): 하나, 둘, 셋, 넷 등 셀 수 있는 변수 명목형 변수: 특성에 따라 명칭을 주어 구분을 지어주는 변수, 변숫값에 따라 서열 정보가 존재하지 않고 모두 동등한 것으로 판단합니다. 서열형 변수: 명목형 변수에서 서열 정보가 주입된 변수, 그에 따라 명목형 변수에 비해 정보량을 더 많이 포함하고 있습니다. Continuous(연속형): 셀 수 없고 구간으로 정의된 변수 정보량을 가장 많이 품고 있는 변수입니다. 변수의 척도에 따른 정보량 대학생 성적을 예시로 삼았을 때, 명목형으로 변수를 취급할 경우, 학생의 학점이 수여 부만을 확인할 수 있지만, 서열형으로 취급할 때는 학점 이수를 한 학생 중에서 D0 ~ A+의 성적을 확인할 수 있습니다. 더 나아가, 연속형으로 취급할 경우에는 같은 A+내에서도 백분위를 통해 서열을 알아낼 수가 있습니다. 즉, 정보량은 명목형에서 연속형으로 갈수록 더 많아지게 됩니다. 데이터의 변환 정보량이 풍부한 연속형의 데이터가 순서, 명목형으로 변환이 되는 것은 가능하지만, 명목형이 순서 혹은 연속형 데이터로, 순서형 데이터를 연속형으로 취급하기에는 정보량이 부족하기에 변환이 불가능합니다. 데이터 타입 확인 기본적으로 저장된 데이터들의 타입은 str() 명령어를 통해 확인합니다. str(벡터, 행렬, 데이터 등 모든 저장 값) Numeric_Vector = c(1:20) Chr_Vector = c("A","B","C") str(Numeric_Vector) int [1:20] 1 2 3 4 5 6 7 8 9 10 ... str(Chr_Vector) chr [1:3] "A" "B" "C" A8. 시간(날짜) 형태의 변수 다루기 8. 시간(날짜) 형태의 변수 다루기 R에서 시간(날짜) 데이터 다루는 방법은 크게 3가지 방법이 있습니다. 1. as.Date()를 활용하여 ‘년-월-일’ 형태로 다루기 2. as.POSIXct()를 활용하여 ‘년-월-일 시:분:초’ 형태로 다루기 3. lubridate 패키지를 활용하여 날짜 데이터 다루기 lubridate 패키지를 다루는 방법은 여기서 다루지 않도록 하겠습니다. as.Date()를 활용하는 경우 날짜가 입력된 포맷에 맞춰 옵션 값에 설정을 해줘야 합니다. as.Date(변수, format = “날짜<NAME>”) 처음 입력되었을 때는, strings가 character였지만, as.Date를 통해 strings가 Date로 변한 것을 확인할 수가 있습니다. DATE_O = "2018-01-02" DATE_C = as.Date(DATE_O, format = "%Y-%m-%d") str(DATE_O) chr "2018-01-02" str(DATE_C) Date[1:1], format: "2018-01-02" as.POSIXct()를 활용하는 경우 POSIXct는 시간:분:초까지 활용할 수가 있습니다. as.POSIXct(날짜, format = “날짜<NAME>”) DATE_O2 = "2015-02-04 23:13:23" DATE_P = as.POSIXct(DATE_O2, format = "%Y-%m-%d %H:%M:%S") str(DATE_P) POSIXct[1:1], format: "2015-02-04 23:13:23" format()의 활용 날짜 정보를 뽑아 새로운 변수를 만들 수 있습니다. format(날짜 변수, “형식”) format(DATE_P,"%A") [1] "수요일" format(DATE_P,"%S") [1] "23" format(DATE_P,"%M") [1] "13" format(DATE_P,"%Y") [1] "2015" A9. as & is를 통해 strings 확인 및 변경하기 9. as & is를 통해 strings 확인 및 변경하기 as() as는 “변수 x를 ~로 취급하겠다.”라는 의미를 가집니다. 또한 summary()는 매우 자주 쓰이는 명령어이며, 데이터의 타입에 따라 결괏값이 다르게 나옵니다. x=c(1,2,3,4,5,6,7,8,9,10) x1 = as.integer(x) x2 = as.numeric(x) x3 = as.factor(x) x4 = as.character(x) str(x1) int [1:10] 1 2 3 4 5 6 7 8 9 10 summary(x1) Min. 1st Qu. Median Mean 3rd Qu. Max. 1.00 3.25 5.50 5.50 7.75 10.00 str(x2) num [1:10] 1 2 3 4 5 6 7 8 9 10 summary(x2) Min. 1st Qu. Median Mean 3rd Qu. Max. 1.00 3.25 5.50 5.50 7.75 10.00 str(x3) Factor w/ 10 levels "1","2","3","4",..: 1 2 3 4 5 6 7 8 9 10 summary(x4) Length Class Mode 10 character character str(x4) chr [1:10] "1" "2" "3" "4" "5" "6" "7" "8" "9" "10" is() is는 논리문으로써 변수 x가 ~인지 판단하여라.라는 의미를 가집니다. str()은 단순히 Stirngs를 확인하는 것이지, 논리문으로 결과를 반환해 주지 못합니다. 그렇기에 논리 조건이 필요할 때는 is.()를 써야 합니다. x=c(1,2,3,4,5,6,7,8,9,10) y=c("str",'str2',"str3","str4") is.integer(x) [1] FALSE is.numeric(x) [1] TRUE is.factor(y) [1] FALSE is.character(y) [1] TRUE B1. sample()을 통한 데이터 무작위 추출하기 10. sample()을 통한 데이터 무작위 추출하기 데이터가 너무 방대한 경우, 필요 없이 긴 연산을 해야 될 때가 있습니다. 이런 경우 무작위 추출을 통해 데이터의 특성은 살리면서, 연산속도를 낮추는 경우가 종종 필요합니다. replace = FALSE는 비복원 추출을 하겠다는 의미입니다. sample(데이터 추출 범위, 데이터 추출 개수, replace = “FALSE OR”TRUE") # 로또 번호 추첨 S1 = sample(1:45, 6, replace = FALSE) # 1 ~ 45 중에 6개의 숫자를 비복원 추출하겠다. print(S1) [1] 36 28 5 16 26 13 sample() 같은 무작위 값을 결과를 내는 코드는 무작위 결괏값(실행할 때마다 다르게 나오는)을 고정시켜야 할 때가 있습니다. 이런 경우, set.seed()를 이용하여 결괏값을 고정합니다. set.seed(1234) S2 = sample(1:45, 6, replace = FALSE) print(S2) [1] 6 28 27 43 36 26 set.seed()의 괄호 안에는 아무 숫자를 저장해 주면 됩니다. 그 숫자에 함께 실행된 무작위 결괏값이 저장되어 있습니다. 정확한 기능 확인을 위해서는 set.seed()를 포함하여 sample()을 돌려본 다음, sample()만 돌려보시면 바로 확인할 수 있습니다. B2. 조건문(if) 활용하기 11. 조건문(if) 활용하기 데이터를 분석하다 보면, 반복작업을 진행해야 되거나, case by case 별로 데이터를 정리해야 될 때가 있습니다. 이런 경우, 하나씩 입력하는 것보다는 for 문과 if 문을 사용하는 것이 훨씬 일이 효율적입니다. for 문은 앞서 중괄호 활용 때 다뤄봤으니, if 문을 활용하도록 하겠습니다. A = c(1,2,3,4,5) if( 7 %in% A){ # %in% A에 속해 있는지 확인하는 논리문 print("TRUE") } else{ print("FALSE") } [1] "FALSE" B3. function()을 통해 사용자 함수 만들기 12. function()을 통해 사용자 함수 만들기 대부분의 통계 분석은 R에 내장되어 있는 함수와 패키지들을 추가로 다운로드해 해결할 수가 있습니다. 하지만 가끔 직접 함수를 만들어야 될 때가 있습니다. function()을 통해 사용자 함수를 만듭니다. 입력 값에 +1을 해주는 함수를 만들기 Plus_One = function(x){ y = x+1 return(y) } Plus_One(3) [1] 4 B4. R 패키지 설치하기 13. R 패키지 설치하기 R은 프로그램이 가벼운 대신, 필요한 함수는 패키지를 설치하여 사용해야 됩니다. 패키지를 설치한 후에는 항상 패키지를 R에 부착시켜야 합니다. install.packages("ggplot2") # ggplot2라는 패키지 설치 library(ggplot2) # ggplot2 패키지 부착 B4. 연습문제 14. 연습문제 sample()을 활용해서 로또번호(1 ~ 45, 6개)를 추첨하여라. 다음의 수열로 구성된 벡터를 생성하시오. V ( , , , , , , 99 ) V ( , , , , , , , , , ) 다음과 같은 행렬을 생성하시오. = [ 1 3 4 6 7 9 ] (위키독스 문법상 매트릭스가 1행으로 표현이 됩니다. 만들어야 되는 매트릭스는 3행 3열입니다.) funtion()을 사용하여 다음의 함수를 만드시오. u d a i ( , ) x + + 10 for() 문을 활용하여 구구단을 만드시오. Ch3. R 기본 문법 2단계 이번 Chapter에서는 쉬어가는 느낌으로, 간단하게 통계 값(Statistics)을 뽑아내는 방법들을 다뤄보도록 하겠습니다. A1. 연습 데이터 설명 1. 연습 데이터 설명 이번에 다룰 데이터는 어떤 회사의 ‘HR(Human Resource, 인사관리)’ 데이터입니다. 링크 : https://www.drop box.com/sh/xx1w2syi768kfU0/AACZgxgo1fcxyDMgv9U-iTz8a?dl=0 변수 설명 satisfaction_level : 직무 만족도 last_evaluation : 마지막 평가점수 number_project : 진행 프로젝트 수 average_monthly_hours : 월평균 근무시간 time_spend_company : 근속연수 work_accident : 사건사고 여부(0: 없음, 1: 있음, 명목형) left : 이직 여부(0: 잔류, 1: 이직, 명목형) promotion_last_5years: 최근 5년간 승진 여부(0: 승진 x, 1: 승진, 명목형) sales : 부서 salary : 임금 수준 A2. 데이터 불러오기 및 Strings 확인 2. 데이터 불러오기 및 Strings 확인 데이터 불러오기 데이터를 불러올 때는 파일이 저장되어 있는 경로를 복사한 다음, 파일 경로/파일명. csv를 입력해 주시면 됩니다. HR = read.csv('D:/Drop box/DATA SET/HR_comma_sep.csv') # /로 경로 구분 HR = read.csv('D:\Drop box\DATA SET\\HR_comma_sep.csv') # \\로 경로 구분 데이터 파악하기 데이터를 불러온 다음에는 당연히 데이터가 제대로 불러와졌는지 확인을 해야 합니다. 데이터를 확인하는 대표적인 명령어는 head(), str(), summary()가 있습니다. 여담으로 이 중에서 제가 개인적으로 가장 많이 사용하는 명령어는 str()입니다. head(), 데이터 윗부분을 출력하는 명령어 # 데이터 윗부분 띄우기 head(HR, n = 3) satisfaction_level last_evaluation number_project average_montly_hours 1 0.38 0.53 2 157 2 0.80 0.86 5 262 3 0.11 0.88 7 272 time_spend_company Work_accident left promotion_last_5years sales salary 1 3 0 1 0 sales low 2 6 0 1 0 sales medium 3 4 0 1 0 sales medium str(), 데이터의 shape, strings 파악 # 데이터 strings 파악 str(HR) 'data.frame': 14999 obs. of 10 variables: $ satisfaction_level : num 0.38 0.8 0.11 0.72 0.37 0.41 0.1 0.92 0.89 0.42 ... $ last_evaluation : num 0.53 0.86 0.88 0.87 0.52 0.5 0.77 0.85 1 0.53 ... $ number_project : int 2 5 7 5 2 2 6 5 5 2 ... $ average_montly_hours : int 157 262 272 223 159 153 247 259 224 142 ... $ time_spend_company : int 3 6 4 5 3 3 4 5 5 3 ... $ Work_accident : int 0 0 0 0 0 0 0 0 0 0 ... $ left : int 1 1 1 1 1 1 1 1 1 1 ... $ promotion_last_5years: int 0 0 0 0 0 0 0 0 0 0 ... $ sales : Factor w/ 10 levels "accounting","hr",..: 8 8 8 8 8 8 8 8 8 8 ... $ salary : Factor w/ 3 levels "high","low","medium": 2 3 3 2 2 2 2 2 2 2 ... 여기서 중요한 것은 각 변수들이 어떤 strings를 가지는지 확인을 하는 것입니다. num, int, Factor 등 어떤 변수들이 어떤 strings로 저장이 되었는지는 R이 해당 변수를 어떻게 인식하고 있는가와 같은 의미입니다. 데이터 요약해서 보기 # 요약된 데이터 살펴보기 summary(HR) # 요약된 데이터 살펴보기 satisfaction_level last_evaluation number_project average_montly_hours Min. :0.0900 Min. :0.3600 Min. :2.000 Min. : 96.0 1st Qu.:0.4400 1st Qu.:0.5600 1st Qu.:3.000 1st Qu.:156.0 Median :0.6400 Median :0.7200 Median :4.000 Median :200.0 Mean :0.6128 Mean :0.7161 Mean :3.803 Mean :201.1 3rd Qu.:0.8200 3rd Qu.:0.8700 3rd Qu.:5.000 3rd Qu.:245.0 Max. :1.0000 Max. :1.0000 Max. :7.000 Max. :310.0 time_spend_company Work_accident left Min. : 2.000 Min. :0.0000 Min. :0.0000 1st Qu.: 3.000 1st Qu.:0.0000 1st Qu.:0.0000 Median : 3.000 Median :0.0000 Median :0.0000 Mean : 3.498 Mean :0.1446 Mean :0.2381 3rd Qu.: 4.000 3rd Qu.:0.0000 3rd Qu.:0.0000 Max. :10.000 Max. :1.0000 Max. :1.0000 promotion_last_5years sales salary Min. :0.00000 sales :4140 high :1237 1st Qu.:0.00000 technical :2720 low :7316 Median :0.00000 support :2229 medium:6446 Mean :0.02127 IT :1227 3rd Qu.:0.00000 product_mng: 902 Max. :1.00000 marketing : 858 (Other) :2923 summary(DataSet)은 데이터에 포함된 모든 변수들에 대한 요 약 값을 보여줍니다. num 및 int는 변수의 최솟값, 최댓값, 평균, 중위수 등을 나타내고, Factor 형태는 개수를 집계 내주는 것을 확인할 수가 있습니다. 데이터 strings 변경 summary(HR$left) Min. 1st Qu. Median Mean 3rd Qu. Max. 0.0000 0.0000 0.0000 0.2381 0.0000 1.0000 Work_accident, left, promotion_last_5years는 명목형 변수라 R에서 Factor 형태로 들어와야 하지만, R에서는 아직 해당 변수들을 integer로 인식하고 있습니다. 이건 원래 데이터의 특성이 아직 R에 반영이 되지 않은 것이기 때문에 strings 변환을 통해 알맞게 변환을 해주어야 합니다. HR$Work_accident=as.factor(HR$Work_accident) HR$left=as.factor(HR$left) HR$promotion_last_5years=as.factor(HR$promotion_last_5years) summary(HR$left) 0 1 11428 3571 left 변수가 numeric으로 되어 있을 때와 Factor로 되어 있을 때, 요 약 값이 다르게 표시되는 것을 알 수 있습니다. 이렇게 분석하고자 하는 변수가 명목형, 순서형, 연속형인지 제대로 파악을 해야 하는 작업은 아무리 강조해도 모자랍니다. 변수의 특성은 후에 분석 방법론을 정해주며, 잘못된 변수 척도의 이해는 잘못된 분석의 시작이 됩니다. 변수의 척도에 대한 확인이 끝난 다음에는 변수의 분포를 직접 확인을 해보는 작업이 중요합니다. 변수의 분포 확인이 중요한 이유는 다음과 같습니다. 먼저, 분석하고자 하는 변수의 분포를 보고 데이터 핸들링 방향을 설정하게 됩니다. 또한 앞으로 다루게 될 분석에서 쓰이는 선형모형들은 확률변수의 분포를 가정하고 진행하는 경우가 대부분입니다. 만약 분석하고자 하는 확률변수의 분포가 가정되어 있는 분포와 같지 않다면 변환을 통해 분포를 맞추어 줘야 합니다. 마지막으로 분포를 꼼꼼히 파악해야 데이터에서 인사이트를 발굴해 낼 수 있습니다. 의미 없는 분포를 가진 변수는 과감하게 버리고, 의미 있는 데이터를 찾는 데에 집중할 수 있는 열쇠가 됩니다. A3. 조건에 맞는 데이터 가공하기 3. 조건에 맞는 데이터 가공하기 데이터 핸들링은 분석에서 가장 중요한 부분을 차지하며, 실제 분석에 들이는 시간의 80 ~ 90%는 데이터 핸들링이 차지하는 경우가 많습니다. 먼저, 데이터 핸들링을 할 때 필수로 알아야 하는 내용에 대해 설명드리도록 하겠습니다. 기본적으로 주어진 데이터를 Raw 데이터라고 합니다. 하지만 대부분의 경우 Raw 데이터에서 바로 모델링을 진행하는 경우는 없습니다. Raw 데이터로 분석을 진행하다, 중간에 분석이 틀어졌을 경우 다시 처음부터 시작해야 하는 문제점이 존재하며, 이는 생각보다 매우 큰 시간을 소모하게 됩니다. 상황에 따라서는 데이터를 조건에 따라 뽑아야 될 때도 있고, 연속형 변수를 이산형 변수로 묶어줘야 할 때도 존재합니다. 즉, 분석하고자 하는 목적, 정보에 따라 과감하게 수정을 할 수 있는 능력이 필요합니다. 기존의 주어진 데이터에 갇혀있지 않으며, 주어진 정보를 최대한 활용할 수 있도록 데이터를 변형시키는 것, 그것이 데이터 분석가에게 가장 중요한 능력이라고 할 수 있습니다. 조건에 맞는 값 할당하기 ifelse ifelse()는 R에서 매우 쓰임이 많은 조건 함수입니다. R에서 사용하는 방법은 엑셀에서의 쓰임과 매우 비슷합니다. satisfaction_level이 0.5보다 크다면 ‘High’, 크지 않다면 ‘Low’ 부여. ifelse(조건, TRUE, FALSE) HR$satisfaction_level_group_1 = ifelse(HR$satisfaction_level > 0.5, 'High', 'Low') HR$satisfaction_level_group_1 = as.factor(HR$satisfaction_level_group_1) summary(HR$satisfaction_level_group_1) High Low 10187 4812 satisfaction_level이 0.8보다 크다면 ‘High’, 0.5 ~ 0.8이면 ‘Mid’, 나머지는 ‘Low’ 조건이 추가가 되었을 경우에는 ifelse(ifelse()) 형태로 ifelse 안에 ifelse 문을 쓰면 됩니다. HR$satisfaction_level_group_2 = ifelse(HR$satisfaction_level > 0.8, 'High', ifelse(HR$satisfaction_level > 0.5, 'Mid','Low')) HR$satisfaction_level_group_2 = as.factor(HR$satisfaction_level_group_2) summary(HR$satisfaction_level_group_2) High Low Mid 4002 4812 6185 조건에 맞는 데이터 추출하기 subset subset() 함수는 조건에 맞는 데이터를 추출하는 명령어입니다. subset(데이터, 추출 조건) salary가 high인 직원들만 추출하여 HR_High라는 새로운 데이터 셋을 생성 HR_High = subset(HR, salary == 'high') summary(HR_High$salary) high low medium 1237 0 0 salary가 high이면서, sales가 IT인 직원들만 추출하여 HR_High_IT 생성 (교집합) HR_High_IT = subset(HR, salary == 'high' & sales == 'IT') print(xtabs(~ HR_High_IT$sales + HR_High_IT$salary)) HR_High_IT$salary HR_High_IT$sales high low medium accounting 0 0 0 hr 0 0 0 IT 83 0 0 management 0 0 0 marketing 0 0 0 product_mng 0 0 0 RandD 0 0 0 sales 0 0 0 support 0 0 0 technical 0 0 0 salary가 high이거나, sales가 IT인 직원들을 추출하여 HR_High_IT2 생성 (합집합) HR_High_IT2 = subset(HR, salary == 'high' | sales == 'IT') print(xtabs(~ HR_High_IT2$sales + HR_High_IT2$salary)) HR_High_IT2$salary HR_High_IT2$sales high low medium accounting 74 0 0 hr 45 0 0 IT 83 609 535 management 225 0 0 marketing 80 0 0 product_mng 68 0 0 RandD 51 0 0 sales 269 0 0 support 141 0 0 technical 201 0 0 A4. 조건에 맞는 집계 데이터 만들기 4. 조건에 맞는 집계 데이터 만들기 조건에 따라 새로운 집계된 데이터를 만드는 것은 분석할 때 매우 중요한 기법입니다. 엑셀을 사용하시는 분들이라면, 피벗테이블을 자주 만드실 겁니다. R에서는 비슷한 기능을 ‘plyr’ 패키지를 통해 만들 수가 있습니다. 패키지 설치 데이터를 편하게 집계 내기 위해서는 다음의 패키지가 필요합니다. install.packages("plyr") library(plyr) ddply를 활용한 집계 데이터 만들기 집계 데이터를 만드는 방법은 여러 방법이 있지만, 지금은 가장 기본적인 ddply()라는 함수를 사용해 보도록 하겠습니다. 명령어의 사용방법은 다음과 같습니다. 분석할 데이터 설정 집계 기준 변수 설정 집계 값을 저장할 칼럼명 및 계산 함수 설정 ddply(데이터, 집계 기준, summarise, 요약 변수) SS=ddply(HR, # 분석할 Data Set 설정 c("sales","salary"),summarise, # 집계 기준 변수 설정 M_SF = mean(satisfaction_level), # 칼럼명 및 계산 함수 설정 COUNT =length(sales), M_WH = round(mean(average_montly_hours),2)) 명령어가 제대로 실행됐다면, SS라는 새로운 데이터가 만들어진 것을 볼 수 있습니다. A5. ggplot2 기본 시각화 5. ggplot2 기본 시각화 ggplot2 패키지는 R, python에서 그래프를 쉽게 그릴 수 있는 패키지입니다. 처음에는 어려울 수 있지만, 그래프를 그리는 방식은 대부분 동일하기 때문에 좀 그리다 보면, 원하시는 그래프를 자유자재로 그릴 수가 있습니다. ggplot2 기본 문법구조 ggplot2를 이용해 그래프를 그리는 일은 우리가 직접 그래프를 그리는 과정과 유사합니다. 만약 손으로 그래프 그리게 되면 다음과 같은 과정을 따를 것입니다. 축을 그린다. 그래프를 그린다. 범례, 제목, 글씨 등 기타 옵션을 수정한다. ggplot2 역시 마찬가지라고 생각하면 됩니다. 축을 그린다 → ggplot(데이터명,aes(x=변수1,y=변수2)) (x축, y 축을 정해준다.) ggplot은 ggplot2의 시작 명령어이며, 여기서 그래프를 그릴 데이터와, 변수를 설정해 줍니다. aes는 aesthetic의 약자로, 그래프에 변수를 설정해 줄 때는 무조건 aes 안에 들어가 있어야 합니다. 그래프를 그린다 geom_bar( ) , 막대도표를 그리겠다. geom_histogram( ) , 히스토그램을 그리겠다. geom_boxplot( ), 박스 플롯을 그리겠다. geom_line( ), 선 그래프를 그리겠다. 기타 옵션을 수정하여, 그래프를 정교하게 그린다. labs( ) , 범례 제목 수정 ggtitle( ), 제목 수정 xlabs( ), ylabs( ), x축 y 축 이름 수정 다음 예시에서 어떻게 그리는지 한번 보도록 하겠습니다. library(ggplot2) # 패키지 부착 library(ggthemes) HR$salary = factor(HR$salary, levels = c("low","medium","high")) ggplot(HR) ggplot(HR, aes(x = salary)) 먼저, ggplot만 입력을 해보면, plot 창에서 회색 바탕 면이 생기는 것을 확인할 수 있습니다. 여기서 aes()와 함께 축설정을 해주면, x축에 변수명이 생기는 것을 확인할 수가 있습니다. 여기서 가장 중요한 것은 aes()입니다. aesthetic(미적)의 줄임말로, ggplot2에서 가장 핵심적인 역할을 수행합니다. aes의 용도는 매우 간단합니다. ggplot2에 들어갈 ’변수’들은 모두 aes() 안에 들어가면 됩니다. 그 외의 값은 aes()에 설정값으로 입력될 필요가 없습니다. 다음의 예시를 보고 판단해 보도록 하겠습니다. ggplot(HR, aes(x=salary)) + geom_bar() ggplot(HR, aes(x=salary)) + geom_bar(fill = 'royalblue') ggplot(HR, aes(x=salary)) + geom_bar(aes(fill=salary)) ggplot()으로 만든 바탕색에 + geom_bar()을 해주면 바탕색 위에 막대도표가 만들어지는 것을 확인할 수가 있습니다. 이제 여기서 막대도표에 색을 주고자 합니다. 막대도표에 ’royalblue’라는 색을 채워주고자 합니다. 이 경우, 간단하게 fill = ’royalblue’를 입력해 주면, 막대도표가 파란색으로 채워지는 것을 확인할 수가 있습니다. 하지만 막대 도표의 변수에 따라 색을 다르게 주고 싶을 경우, ’aes(fill = salary)’를 입력해 주어야 합니다. 차이점을 아시겠나요? royalblue는 그냥 일반적인 설정값이지만, salary는 시각화 대상 데이터에 포함되어 있는 변수이기 때문에 aes() 안에 들어가야 합니다. 이러한 차이만 잘 이해하시면 ggplot2를 활용하는데 큰 문제는 없을 것입니다. ggplot2는 이렇게 하나씩 그리고 싶은 조건들을 추가해 주면서 그리면 편하게 그릴 수가 있습니다. 막대 도표(Bar plot) 막대 도표 : 이산형 변수 하나를 집계 내는 그래프, 1차원 자주 봤을 막대 도표입니다. 막대 도표는 이산형 변수를 x축으로 두고, y 축은 자동으로 집계(Counting) 된 값들을 표현하는 도표입니다. library(ggplot2) # 패키지 부착 x축에 salary 설정, y 축은 자동으로 집계된 값이 표현되기 때문에 설정을 하지 않습니다. # 색 설정_1 ggplot(HR, aes(x=salary)) + geom_bar(fill = 'royalblue') # royalblue 색으로 색 채우기 # 색 설정_2 ggplot(HR, aes(x=salary)) + geom_bar(aes(fill=left)) # left 값에 따라 색 채우기 ggplot2에서는 col = , fill = 옵션을 줌으로써 그래프에 색을 더할 수가 있습니다. 점, 선과처럼 면적이 없는 그래프는 col 옵션을 통해 색을 바꿔주며, 면적이 있는 그래프들은 fill 옵션을 통해 색을 변경해 줍니다. 히스토그램(Histogram) 히스토그램 : 연속형 변수 하나를 집계 내는 그래프, 1차원 히스토그램은 연속형 변수를 일정 범위로 구간을 만들어, x축으로 설정하고 y 축은 집계된 값(Counting)을 나타내는 그래프입니다. # 기본 ggplot(HR, aes(x=satisfaction_level))+ geom_histogram() # 구간 수정 및 색 입히기 ggplot(HR, aes(x=satisfaction_level))+ geom_histogram(binwidth = 0.01, col='red',fill='royalblue') col은 테두리 색을, fill은 채워지는 색을 바꿔줍니다. 밀도 그래프(Density Plot) 밀도 그래프 : 연속형 변수 하나를 집계 내는 그래프, 1차원 밀도 그래프는 연속형 변수를 일정 범위로 구간을 만들어, x축으로 설정하고 y 축은 집계된 값(percentage)을 나타내는 그래프입니다. # 기본 ggplot(HR, aes(x=satisfaction_level))+ geom_density() # 색 입히기 ggplot(HR, aes(x=satisfaction_level))+ geom_density(col='red',fill='royalblue') # col은 테두리, fill은 채우기 박스 플롯 박스 플롯(Boxplot) 박스 플롯 : 이산형 변수에 따라 연속형 변수의 분포 차이를 표현해 주는 2차원 그래프 박스 플롯은 이산형 변수와 연속형 변수를 한 번에 표현하기 위한 그래프입니다. 데이터 탐색과정(EDA)에서 매우 중요하게 쓰이는 플롯 중 하나이니, 꼭 기억해두시길 바랍니다. # 기본 ggplot(HR, aes(x=left, y=satisfaction_level)) + geom_boxplot(aes(fill = left)) + xlab("이직 여부") + ylab("만족도") + ggtitle("Boxplot") + labs(fill = "이직 여부") alpha는 색 명도 조절 기능으로, 0 ~ 1 사이 값을 입력합니다. # 기본에서 조금 더 추가 ggplot(HR, aes(x=left, y=satisfaction_level)) + geom_boxplot(aes(fill = left),alpha = I(0.4)) + geom_jitter(aes(col = left),alpha = I(0.4)) + xlab("이직 여부") + ylab("만족도") + ggtitle("Boxplot") + labs(fill = "이직 여부", col = "이직 여부") # 기본에서 조금 더 추가에서 조금 변경 ggplot(HR, aes(x=left, y=satisfaction_level)) + geom_boxplot(aes(fill = salary),alpha = I(0.4),outlier.colour = 'red') + xlab("이직 여부") + ylab("만족도") + ggtitle("Boxplot") + labs(fill = "임금 수준") 산점도(Scatter Plot) 산점도 : 두 연속형 변수의 상관관계를 표현해 주는 2차원 그래프 산점도는 분석에서 가장 활발히 쓰이는 그래프 중 하나입니다. 특히 산점도의 경우, 모델링 전에 변수들 간의 관계를 파악하는 데 있어, 가장 효과적입니다. # 기본 ggplot(HR, aes(x=average_montly_hours, y=satisfaction_level))+ geom_point() # 간단한 색칠로 인사이트 발굴하기 ggplot(HR, aes(x=average_montly_hours, y=satisfaction_level))+ geom_point(aes(col = left)) + labs(col = '이직 여부') + xlab("평균 근무시간") + ylab("만족도") A6. 연습문제 6. 연습문제 HR 데이터의 행의 수, 열의 수를 구하시오. salary 변수의 strings에 대해 답하시오. salary 변수에 대하여 low는 1, medium은 2, high는 3의 값을 가져 서열 정보를 가지게 하는 salary_New 변수를 만드시오. Salary_New 값이 2이면서 left는 1인 직원들만 뽑아 Medium_Left라는 새로운 데이터 프레임을 만드시오. Medium_Left 데이터에 대해 sales 변수 별로 time_spend_company의 평균을 구하여, Time_spend_Mean이 Ch4. R 기본 문법 3단계 이번 Chapter에서는 쉬어가는 느낌으로, 간단하게 통계 값(Statistics)을 뽑아내는 방법들을 다뤄보도록 하겠습니다. A1. 변수에 대한 요약 값 살펴보기 1. 변수에 대한 요약 값 살펴보기 변수가 Factor 형태일 때는 각 level(Low, Mid, High)에 해당하는 집계 Count를 나타내주며, Numeric 형태일 때는 최솟값, 최댓값, 평균 및 각 분위수를 나타내줍니다. HR = read.csv('F:\Drop box\DATA SET\\HR_comma_sep.csv') summary(HR$salary) high low medium 1237 7316 6446 summary(HR$satisfaction_level) Min. 1st Qu. Median Mean 3rd Qu. Max. 0.0900 0.4400 0.6400 0.6128 0.8200 1.0000 A2. 분위수 계산 2. 분위수 계산 분위수(quantile)이란 변수를 오름차순으로 정리하였을 때, 특정 % 위치에 해당되는 값을 의미합니다. 예를 들어, Q1은 1분위 수로 하위 25%에 해당되는 직원의 satisfaction_level 값을 나타내줍니다. Median(중위수)는 중간(50%)에 해당되는 직원의 satisfaction_level을 나타내주며, Q3( 하위 75%, 상위 25%)의 기준에 해당되는 직원의 satisfaction_level을 의미합니다. # 10%, 30%, 60%, 90%에 해당하는 분위수 뽑아내기 quantile(HR$satisfaction_level, probs = c(0.1,0.3,0.6,0.9)) 10% 30% 60% 90% 0.21 0.49 0.72 0.92 A3. 합, 평균, 표준편차 구하기 3. 합, 평균, 표준편차 구하기 단일 변수의 합 구하기 sum(HR$satisfaction_level) [1] 9191.89 단일 변수의 평균 구하기 mean(HR$last_evaluation) [1] 0.7161017 단일 변수의 표준편차 구하기 sd(HR$satisfaction_level) [1] 0.2486307 다중 변수의 합, 평균 구하기 obs(행) 별로 합, 평균 구할 시에는 rowSums, rowMeans 활용 colMeans(HR[1:5]) satisfaction_level last_evaluation number_project 0.6128335 0.7161017 3.8030535 average_montly_hours time_spend_company 201.0503367 3.4982332 colSums(HR[1:5]) satisfaction_level last_evaluation number_project 9191.89 10740.81 57042.00 average_montly_hours time_spend_company 3015554.00 52470.00 A4. 빈도 테이블 작성하기 4. 빈도 테이블 작성하기 1차원 빈도 테이블 TABLE = as.data.frame(table(HR$sales)) 2차원 테이블 TABLE2 = as.data.frame(xtabs(~ HR$salary + HR$sales)) A5. 연습문제 5. 연습문제 HR 데이터에서 last_evaluation의 평균을 구하시오. HR 데이터에서 last_evaluation의 표준편차를 구하시오. HR 데이터에서 sales에 대한 빈도표를 작성하시오. HR 데이터에서 left, salary에 대한 교차 표를 작성하시오. Ch5. R 기본 문법 4단계 이번 챕터에서는 이전에 했던 데이터에 비해서는 좀 더 어려운 데이터를 통해 R을 익혀보도록 하겠습니다. A1. 데이터 불러오기 및 데이터 설명 1. 데이터 불러오기 및 데이터 설명 데이터 출처는 Kaggle이며, 해당 드롭박스 링크에서 받으실 수 있습니다. 링크 : https://www.drop box.com/sh/xx1w2syi768kfU0/AACZgxgo1fcxyDMgv9U-iTz8a?dl=0 # 데이터 불러오기 IMDB = read.csv("D:\Drop box\DATA SET(Drop box)\IMDB-Movie-Data.csv") 변수 설명 Rank Title : 영화 제목 Genre : 영화 장르 Description : 영화 설명 Director : 감독명 Actors : 배우 Year : 영화 상영 연도 Runtime.. Minutes : 상영시간 Rating : Rating 점수 Votes : 관객 수 Revenue.. Millions : 수익 Metascore : 메타 스코어 A2. 결측치(Missing Value) 2. 결측치(Missing Value) 결측치에 대한 정의 결측치(Missing Value)는 말 그대로 데이터에 값이 없는 것을 뜻합니다. 줄여서 ’NA’라고 표현하기도 하고, 다른 언어에서는 Null 이란 표현을 많이 씁니다. 결측치는 데이터를 분석하는 데에 있어서 매우 방해가 되는 존재입니다. 결측치는 다음과 같은 문제를 야기합니다. 먼저 결측치를 다 제거해버리는 경우, 결측치의 비율에 따라서 막대한 데이터 손실을 불러일으킬 수 있습니다. 다음으로는 결측치를 잘못 대체할 경우, 데이터에서 편향(bias)이 생길 수가 있습니다. 또한 결측치를 처리하는 데에 있어 분석가의 견해가 가장 많이 반영되기 때문에 대체가 잘못될 경우 분석 결과가 매우 틀어질 수도 있습니다. 결론은 결측치를 자세히 처리하기 위해서는 시간이 많이 투자되어야 합니다. 무엇보다, 데이터에 기반한 결측치 처리가 진행되어야 분석을 정확하게 진행할 수 있습니다. A3. R을 통한 결측치 처리 3. R을 통한 결측치 처리 결측치 확인 # Metascore 변수 내에서 결측치 논리문 판단 (TRUE, FALSE) is.na(IMDB$Metascore)[1:20] [1] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE [12] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE # Metascore 변수 내에 결측치 개수 sum(is.na(IMDB$Metascore)) [1] 64 # IMDB 내 모든 변수별 결측치 개수 colSums(is.na(IMDB)) Rank Title Genre 0 0 0 Description Director Actors 0 0 0 Year Runtime.. Minutes. Rating 0 0 0 Votes Revenue.. Millions. Metascore 0 128 64 결측치 제거 전부 삭제하는 경우, 가장 극단적인 방법입니다.(결측치가 하나라도 포함된 obs(행)은 삭제) IMDB2 = na.omit(IMDB) colSums(is.na(IMDB2)) Rank Title Genre 0 0 0 Description Director Actors 0 0 0 Year Runtime.. Minutes. Rating 0 0 0 Votes Revenue.. Millions. Metascore 0 0 0 특정 변수에 결측치가 존재하는 행만 삭제하는 경우 # 12번째 열에 결측치가 있는 경우에만 삭제 IMDB3 = IMDB[complete.cases(IMDB[ ,12]),] colSums(is.na(IMDB3)) Rank Title Genre 0 0 0 Description Director Actors 0 0 0 Year Runtime.. Minutes. Rating 0 0 0 Votes Revenue.. Millions. Metascore 0 98 0 결측치를 특정 값으로 대체할 경우 is.na가 True인 값(결측치)들에 대해 58.99 지정 # Rawdata를 새로운 변수에 복사 IMDB$Metascore2 = IMDB$Metascore # 결측치 대체 IMDB$Metascore2[is.na(IMDB$Metascore2)]=58.99 결측치 생략하고 계산할 경우 mean(IMDB$Revenue.. Millions.) # NA 생성 [1] NA mean(IMDB$Revenue.. Millions.,na.rm = TRUE) # NA 생략하고 계산 [1] 82.95638 A4. 결측치 처리 시 주의할 점 4. 결측치 처리 시 주의할 점 데이터를 다룰 때, 기본적으로 raw 데이터는 절대 건드리는 것이 아닙니다. 보통의 경우, 데이터를 새로 복사를 해두고 진행을 하는 것이 나중을 위해 매우 좋은 습관이 됩니다. 때로는 나머지 정보를 잃지 않기 위하여 최대한 합리적으로 결측치를 대체해야 할 필요가 있습니다. 가장 기본적인 방법은 다음과 같습니다. 연속형 변수 : 평균으로 대체 이산형 변수 : 최빈값으로 대체 하지만 이렇게 무턱대고 결측치를 대체하는 경우에는 데이터가 심하게 쏠릴 수가 있습니다. 결측치를 대체할 때는 항상 다음의 사항들을 확인해야 됩니다. 결측치의 비율 만약, 결측치의 비율이 상당한 경우, 일단<NAME>고 보는 방식은 크나큰 정보 손실을 불러올 수가 있습니다. 데이터의 분포 데이터를 분석할 때, 항상 데이터의 분포를 확인하고 진행을 해야 됩니다. 데이터가 평균을 중심으로 균형 있게 퍼져있는 ’정규분포’형태를 띠고 있는 경우라면 모르겠지만, 현실의 대부분 데이터는 그렇게 이상적이지는 않기 때문입니다. 다음의 그래프를 보면서 확인해 보겠습니다. 다른 변수와의 관계가 있는지 다른 변수와의 관계를 파악하여, 결측치를 대체하는 방법입니다. 전문적인 용어로는 ’Mssing value Imputation’이라고 하는데, 해당 방법론은 이 책의 수준을 벗어나기 때문에 다루지 않도록 하겠습니다. A5. 결측치 처리를 위한 데이터의 분포 탐색 5. 결측치 처리를 위한 데이터의 분포 탐색 결측치를 처리하기 위하여, Revenue.. Millions.의 분포에 대해 확인해 보도록 하겠습니다. library(ggplot2) ggplot(IMDB, aes(x=Revenue.. Millions.)) + geom_histogram(fill='royalblue', alpha = 0.4) + ylab('') + xlab("Revenue_Millions") + theme_classic() ggplot(IMDB, aes(x = "",y=Revenue.. Millions.)) + geom_boxplot(fill='red', alpha = 0.4, outlier.color = 'red') + xlab('') + ylab("Revenue_Millions") + theme_classic() summary(IMDB$Revenue.. Millions.) Min. 1st Qu. Median Mean 3rd Qu. Max. NA's 0.00 13.27 47.98 82.96 113.72 936.63 128 Revenu_Millions를 볼 때 데이터가 한쪽으로 매우 치우쳐져 있습니다. 이런 분포는 항상 평균과 중위 수의 차이를 확인해 봐야 합니다. (평균: 82.96, 중위수: 47.98) 따리서, 이런 분포의 데이터의 결측치는 평균으로 대체하면 매우 위험합니다. 평균은 극단값(Outlier, 이상치)에 영향을 받기 때문입니다. 극단값은 패턴을 벗어난 특수한 상황이지, 결코 일반적인 상황을 대변해 주지 않습니다. 그럼 어떻게 해야 하는가? 평균보다는 중위수가 안전합니다. 중위수는 극단값(Outlier)에 영향을 받지 않기 때문입니다. 물론 중위 수로 대체하는 것은 차선책이지 완벽한 방법은 아닙니다. 다른 변수들과의 관계를 보면서 대체하는 것은 많은 시간을 요구하지만, 더 정교한 분석 결과를 확인할 수 있습니다. A6. 이상치(Outlier) 뽑아내기 6. 이상치(Outlier) 뽑아내기 이상치(Outlier)는 ‘패턴에서 벗어난 값’으로 정의를 내릴 수 있습니다. 또는 ’중심에서 좀 많이 떨어져 있는 값’이라고 할 수 있습니다. 이상치는 평균에 막대한 영향을 미칩니다. 예를 들어 [1,2,3,4,5]의 평균은 3이지만, [1,2,3,4,100]의 평균은 22입니다. 하지만 중위수는 3으로 같습니다. 따라서 종종 평균으로 값을 나타내기보다는 중위 수로 요 약 값을 나타내는 것이 더 현실을 반영하는 경우가 많습니다. 이상치 여부는 다음과 같은 식으로 계산을 합니다. ggplot(IMDB, aes(x=as.factor(Year),y=Revenue.. Millions.))+ geom_boxplot(aes(fill=as.factor(Year)),outlier.colour = 'red',alpha=I(0.4))+ xlab("연도") + ylab("수익") + guides(fill = FALSE) + theme_bw() + theme(axis.text.x = element_text(angle = 90)) 박스 플롯을 그린 이유는 이상치 탐색을 가장 하기 좋은 플롯이 박스 플롯이 기 때문입니다. 박스 플롯의 구성을 살펴보시면 다음과 같습니다. 상자 안에 그려져 있는 직선은 중위수(Median)을 나타냅니다. 상자의 밑변은 1분 위수를 나타애며, 윗변은 3분 위수를 나타냅니다. 상자 테두리 외부에 직선이 있는 것을 볼 수 있습니다. 이 직선은 울타리라고 부릅니다. 상자로부터 아래 울타리의 계산식 : Q1 - 1.5 * (Q3 - Q1) 상자로부터 위 울타리의 계산식 : Q3 + 1.5 *(Q3 - Q1) 이 울타리를 벗어난 값들을 Outlier라고 부릅니다. Outlier는 기본적으로 통계 추정에 있어서 방해가 되고는 합니다. 통계분석은 전부 귀납법인데, 이상치 같은 특수 케이스가 규칙을 만드는데 방해가 되기 때문입니다. Outlier의 처리 방법 제거를 하는 방법이 쓰이기는 하지만, 개인적으로 좋아하는 방식은 아닙니다. 어찌 됐든 데이터를 버리는 거니깐요. 데이터 변형을 통해 Outlier 문제를 줄여줍니다. 통계 추정에 세는 정규분포를 맞추어 주는 것이 매우 중요합니다. 보통 Outlier로 인해 한 쪽으로 치우친 분포는 log 변환을 통해<NAME>을 맞추어주고는 합니다. (이 부분은 후에 다루도록 하겠습니다.) # Outlier인 데이터 제거하기 # 1분 위수 계산 Q1 = quantile(IMDB$Revenue.. Millions.,probs = c(0.25),na.rm = TRUE) # 3분 위수 계산 Q3 = quantile(IMDB$Revenue.. Millions.,probs = c(0.75),na.rm = TRUE) LC = Q1 - 1.5 * (Q3 - Q1) # 아래 울타리 UC = Q3 + 1.5 * (Q3 - Q1) # 위 울타리 IMDB2 = subset(IMDB, Revenue.. Millions. > LC & Revenue.. Millions. < UC) A7. 문자열 데이터 다루기 1편 7. 문자열 데이터 다루기 1편 이번에는 문자열 데이터를 처리하는 방법에 대해 다루겠습니다. 문자열을 다룰 때 기본적으로 숙지하고 있어야 하는 명령어는 다음과 같습니다. 문자열 대체 : gsub() 문자열 분리 : strsplit() 문자열 합치기 : paste() 문자열 추출 : substr() 텍스트 마이닝 함수: Corpus() & tm_map(), & tdm() 문자열 추출 substr(IMDB$Actors[1],1,5) [1] "Chris" 첫 번째 obs의 Actors 변수에서 1 ~ 5번째에 해당하는 문자열 추출 문자열 붙이기 paste(IMDB$Actors[1],"_",'A') # 첫 번째 obs의 Actors 변수에서 _ A 붙이기 [1] "Chris Pratt, Vin Diesel, Bradley Cooper, Zoe Saldana _ A" paste(IMDB$Actors[1],"_",'A',sep="") # 띄어쓰기 없이 붙이기 [1] "Chris Pratt, Vin Diesel, Bradley Cooper, Zoe Saldana_A" paste(IMDB$Actors[1],"_","Example",sep="|") # |로 붙이기 [1] "Chris Pratt, Vin Diesel, Bradley Cooper, Zoe Saldana|_|Example" paste()는 기본적으로 붙이는 문자열 사이에 " “(한 칸 빈칸)이 기본 설정입니다. 이를 수정하기 위해서는 sep =”"옵션을 주어야 합니다. 문자열 분리 strsplit(as.character(IMDB$Actors[1]), split= ",") [[1]] [1] "Chris Pratt" " Vin Diesel" " Bradley Cooper" " Zoe Saldana" 문자열 대체 IMDB$Genre2=gsub(","," ",IMDB$Genre) # ,를 띄어쓰기로 대체 gsub은 데이터 핸들링에서 매우 많이 사용되는 명령어이기에 꼭 기억하고 있어야 합니다. A8. 문자열 데이터 다루기 2편(R 텍스트 마이닝) 8. 문자열 데이터 다루기 2편 텍스트 마이닝 1 텍스트 마이닝의 절차는 다음과 같습니다. 코퍼스(말뭉치) 생성 TDM(문서 행렬) 생성 문자 처리(특수문자 제거, 조사 제거, 숫자 제거 등..) 문자열 변수 생성 Genre 변수는 영화에 대한 장르를 나타냅니다. 하지만 모든 영화가 하나의 장르에만 해당되는 것이 아니라, 여러 장르에 해당되는 것을 알 수 있습니다. 이를 분석하기 위해서는 각 영화가 어느 장르에 해당되는지 나타내줄 수 있는 변수를 만들어야 합니다. 해당 변수를 만들기 위해서 텍스트 마이닝 기법을 적용시켜보도록 하겠습니다. 1단계 : 코퍼스 생성 영어의 경우, 대문자와 소문자가 다른 글자로 인식되기 때문에 바꿔주는 작업이 필요합니다. library(tm) # tm 패키지 설치 필요 CORPUS = Corpus(VectorSource(IMDB$Genre2)) # 코퍼스 생성 CORPUS_TM = tm_map(CORPUS, removePunctuation) # 특수문자 제거 CORPUS_TM = tm_map(CORPUS_TM, removeNumbers) # 숫자 제거 CORPUS_TM = tm_map(CORPUS_TM, tolower) # 알파벳 모두 소문자로 바꾸기 Corpus는 말뭉치라는 의미로, 텍스트 마이닝을 하기 전에 문자열 데이터를 정리하는 과정이라고 생각하시면 될 것 같습니다. 2단계 : 문서 행렬 생성 문서 행렬을 만드는 이유는 다음과 같은 이유입니다. 특정 단어를 변수로 만들어, 분석에 사용하려는 목적 특정 단어가 포함되어 있는 데이터만 따로 추출하거나 특정 단어가 많이 등장하였을 때, 이것이 다른 무언가와 상관성이 있는지 분석하기 위한 목적 즉, 문자열 데이터를 가지고 통계적인 분석을 하기 위한 준비과정이라고 생각하시면 될 것 같습니다. TDM=DocumentTermMatrix(CORPUS_TM) # 문서 행렬 생성 inspect(TDM) <<DocumentTermMatrix (documents: 1000, terms: 20)>> Non-/sparse entries: 2555/17445 Sparsity : 87% Maximal term length: 9 Weighting : term frequency (tf) Sample : Terms Docs action adventure comedy crime drama horror mystery romance scifi 1 1 1 0 0 0 0 0 0 1 10 0 1 0 0 1 0 0 1 0 11 0 1 0 0 0 0 0 0 0 12 0 0 0 0 1 0 0 0 0 2 0 1 0 0 0 0 1 0 1 4 0 0 1 0 0 0 0 0 0 5 1 1 0 0 0 0 0 0 0 6 1 1 0 0 0 0 0 0 0 7 0 0 1 0 1 0 0 0 0 9 1 1 0 0 0 0 0 0 0 Terms Docs thriller 1 0 10 0 11 0 12 0 2 0 4 0 5 0 6 0 7 0 9 0 TDM = as.data.frame(as.matrix(TDM)) # 문서 행렬을 데이터 프레임 형태로 만들어주기. head(TDM) action adventure scifi mystery horror thriller animation comedy family 1 1 1 1 0 0 0 0 0 0 2 0 1 1 1 0 0 0 0 0 3 0 0 0 0 1 1 0 0 0 4 0 0 0 0 0 0 1 1 1 5 1 1 0 0 0 0 0 0 0 fantasy drama music biography romance history crime western war musical 1 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 0 3 0 0 0 0 0 0 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 5 1 0 0 0 0 0 0 0 0 0 sport 1 0 2 0 3 0 4 0 5 0 [ reached 'max' / getOption("max.print") -- omitted 1 rows ] 3단계 : 기존 데이터와 결합하기 IMDB_GENRE = cbind(IMDB, TDM) 기존에 있는 데이터와, 장르 변수들로 구성된 데이터를 합쳐야 합니다. 합쳐야 할 두 데이터가 같은 행을 가지고 순서도 같다면, cbind(Column bind) 명령어를 쓰면 됩니다. 만약, 반대로 합쳐야 할 두 데이터가 같은 열을 가지고, 순서도 같은데, 행을 합쳐야 한다면 rbind(row bind) 명령어를 쓰면 됩니다. 데이터 결합하기 명령어 cbind : 행이 동일하고, 순서도 같을 때 옆으로(변수) 합치기 rbind : 열이 동일하고, 순서도 같을 때 아래로(obs) 합치기 merge : 열과 행이 다른 두 데이터 셋을 하나의 기준을 잡고 합치고자 할 때 사용 Genre 변수를 통해 간단하게 다룰어봤다면, 이번에는 Description 변수를 통해 복습도 할 겸 다루어보도록 하겠습니다. Description 변수는 Genre 변수와 비교했을 때, 다음의 차이점이 존재합니다. 단어의 중복 등장 조사, 동사, 명사 등 등장 1단계 : stopwords를 이용한 단어 제거 library(tm) CORPUS=Corpus(VectorSource(IMDB$Description)) CORPUS_TM = tm_map(CORPUS, stripWhitespace) CORPUS_TM = tm_map(CORPUS_TM, removePunctuation) CORPUS_TM = tm_map(CORPUS_TM, removeNumbers) CORPUS_TM = tm_map(CORPUS_TM, tolower) DTM = DocumentTermMatrix(CORPUS_TM) inspect(DTM) <<DocumentTermMatrix (documents: 1000, terms: 5960)>> Non-/sparse entries: 20465/5939535 Sparsity : 100% Maximal term length: 23 Weighting : term frequency (tf) Sample : Terms Docs and for from her his that the their who with 155 2 1 1 0 0 0 4 0 0 2 232 1 0 0 0 1 0 2 0 1 2 323 1 2 0 0 0 0 3 0 0 0 324 1 0 0 0 0 1 5 0 0 1 704 0 0 1 1 0 0 2 0 1 1 764 4 0 1 0 0 0 1 2 0 0 774 0 0 3 2 2 2 3 0 1 1 836 2 0 0 0 0 0 5 1 0 0 863 2 0 1 0 3 0 0 1 1 1 960 2 0 0 0 1 0 5 0 0 0 and, for, from, with 이런 단어들은 자주 쓰이는 단어이지만, 실제로 의미를 전달하는 단어는 아닙니다. 그러므로 텍스트 마이닝 시에는 이런 단어들을 제거해 주는 것이 더 원활한 분석을 진행할 수 있습니다. CORPUS_TM = tm_map(CORPUS_TM, removeWords, c(stopwords("english"),"my","custom","words")) stopwords 기능을 사용하면 and, his 같은 단어들을 모두 삭제할 수 있습니다. 더 나아가 추가로 삭제하고 싶은 단어는 c( ) 명령어 안에 넣어주면 삭제를 시킬 수 있습니다. 현재는 ‘my’, ‘custom’,‘words’ 이 3가지 단어를 추가적으로 삭제시킨 상황입니다. 2단계 : 중복 등장 단어 처리 결정 문장을 분해한 경우, 중복 단어 처리를 어떻게 하느냐도 결정해야 될 사항입니다. 1안 : 특정 단어가 문장에 포함되어 있냐 없냐로 표시 -> 0 , 1로 코딩 (0: 포함 x, 1: 포함 o) convert_count = function(x) { y <- ifelse(x > 0,1,0) y = as.numeric(y) } 2안 : 특정 단어가 문장에서 몇 번 등장했나를 표시 -> 등장 빈도로 코딩 convert_count = function(x) { y <- ifelse(x > 0, x, 0) y = as.numeric(y) } 사용자 함수 적용 매트릭스 형태인 TDM에 convert_count를 하나씩 적용하여 값을 배출 DESCRIPT_IMDB=apply(DTM, MARGIN=2, convert_count) DESCRIPT_IMDB=as.data.frame(DESCRIPT_IMDB) 3단계 : 문자열 데이터 시각화 # Temr Document Matrix 생성 TDM = TermDocumentMatrix(CORPUS_TM) # 워드 클라우드 생성 m = as.matrix(TDM) v = sort(rowSums(m),decreasing=TRUE) # 빈도수를 기준으로 내림차순 정렬 d = data.frame(word = names(v),freq=v) library("SnowballC") library("wordcloud") library("RColorBrewer") # min.freq -> 최소 5번 이상 쓰인 단어만 띄우기 # max.words -> 최대 200개만 띄우기 # random.order -> 단어 위치 랜덤 여부 wordcloud(words = d$word, freq = d$freq, min.freq = 5, max.words=200, random.order=FALSE, colors=brewer.pal(8, "Dark2")) # 단어 빈도 그래프 그리기 ggplot(d[1:10, ]) + geom_bar(aes(x = reorder(word, freq), y = freq), stat = 'identity') + coord_flip()+ xlab("word") + ylab("freq") + theme_bw() 텍스트 마이닝은 사실 통계적인 이용보다는 알고리즘에 기반한 Computer Science 영역에 가깝습니다. 또한 텍스트를 제대로 분석하기 위해서는 형태소 분석을 기반으로 여러 가지 알고리즘을 적용시켜야 그나마 깔끔하게 정리되는 경우가 많습니다. 현재는 R을 이용하여 비정형 데이터를 어떻게 가공하며, 이를 분석에서 사용하려면 어떻게 하는지에 집중을 하도록 하겠습니다. 기회가 된다면 후에 더 심화된 내용을 다루도록 하겠습니다. A9. 연습문제 9. 연습문제 IMDB 데이터 셋의 Revenue Millions 변수에 존재하는 결측치를 모두 0으로 전환시켜 Revenue_NonNA라는 변수를 만드시오. Revenue Millions의 이상치 범위를 계산해 보세요 Ch6. R 중급문법 1단계 R 데이터 핸들링에서 매우 중요하게 쓰이는 apply와 dplyr에 대해 다룹니다. A1. 효과적인 데이터 핸들링을 위한 apply & dplyr 소개 1. 효과적인 데이터 핸들링을 위한 apply & dplyr 소개 R에는 매우 많은 명령어가 존재하며, 그중 다수의 코드는 같은 기능을 하지만 명령어만 다를 뿐입니다. 그렇기에, 인터넷에 올라와 있는 R 코드들을 살펴보면 작성자의 개성에 따라 다양하게 구성되어 있다는 것을 확인할 수 있습니다. 이는 곧 R의 가장 큰 장점이자 가장 큰 단점으로 작용합니다. 코드를 다양하고 편하게 작성할 수 있기 때문에, 편리와 다양성이 보장된 반면, 처음 접하는 사람들에게는 혼란을 야기하기 매우 좋으며, 정돈되어 있지가 않습니다. python은 numpy, pandas 등의 단일 패키지로 구성되어 있는 점과 비교하면 R은 지나치게 혼란스러울 수 있습니다. 하지만 그렇다고 파이썬이 R보다 쉽다는 의미로 직결되지는 않으니, 편한 마음으로 학습을 하면 됩니다. 이번 챕터의 목적은 통계 값을 뽑아낼 때 자주 쓰이는 명령어들을 정리하면서, 같은 기능을 하는 코드들도 다뤄보도록 하겠습니다. 아마, 여기까지 따라오셨다면 이제 R 코드의 구조는 다 이해하실 거라고 생각합니다. 이번 챕터에서 주로 다룰 패키지는 다음과 같습니다. library(dplyr) library(reshape) library(plyr) dplyr 및 reshape 패키지는 매우 자주 쓰이는 패키지입니다. 주로 이 패키지들을 위주로 다뤄보도록 하겠습니다. A2. 데이터 불러오기 2. 데이터 불러오기 HR = read.csv('D:/Drop box/DATA SET/HR_comma_sep.csv') A3. apply 함수와 dplyr 패키지 소개 3. apply 함수와 dplyr 패키지 소개 apply 함수 소개 apply라는 함수는 많은 코드에서 볼 수 있는 함수입니다. 저희는 이전에 for 문을 통해 반복문을 만들어 본 적이 있습니다. for 문은 매우 편리한 기능이지만, 만능은 아닙니다. 그 이유는 하나의 열(Column)에 대해 작동을 할 뿐, 동시에 여러 column 혹은 row에 대해서 계산을 실행할 수는 없기 때문입니다. apply는 이를 동시에 계산할 수 있도록 도와주는 훌륭한 기능의 함수입니다. 동일한 기능에 대해서 apply 문과 for 문을 사용할 경우, 명령어가 어떻게 구성이 되는지 보도록 하겠습니다. 문제 : HR 데이터 셋의 1,2열 평균을 구하고자 한다. for 문을 사용할 경우 for(i in 1:2){ print(paste(colnames(HR)[i],":",mean(HR[,i]))) } [1] "satisfaction_level : 0.612833522234816" [1] "last_evaluation : 0.716101740116008" apply를 활용할 경우 apply(HR[,1:2],2, mean) satisfaction_level last_evaluation 0.6128335 0.7161017 먼저, apply 문의 경우 (데이터, 계산 기준(1 혹은 2), 함수)를 입력해 줍니다. 여기서 ’계산 기준(1 혹은 2)’는 행/열 중 어떤 것을 기준으로 연산을 할지 정해주는 설정값입니다. 만약 1을 입력하면, mean을 각 행(row) 별로 계산을 할 것이고, 2를 입력하면 mean을 각 열(column) 별로 계산을 진행할 것입니다. 위 명령어는 2를 입력했기 때문에, 각 열(column)의 평균을 계산하였습니다. colMeans를 활용할 경우 colMeans(HR[,1:2]) satisfaction_level last_evaluation 0.6128335 0.7161017 colMeans는 간단하게 바로 각 변수의 평균을 구해주는 명령어입니다. 정말 간편하지요? 근데 이렇게 간단한 함수가 있는데 왜 굳이 apply 문을 활용해야 되는지 의문사항이 생길 수가 있습니다. 평균처럼 명령어가 만들어져 있는 상황이면 굳이 apply 문을 활용할 필요가 없습니다. 하지만, 그렇지 않은 경우는 어떻게 해야 할까요? 지금 당장만 해도 주로 평균과 같이 구하는 표준편차를 각 변수마다 계산해 주는 간단한 명령어는 존재하지 않습니다. 함수를 직접 만들어 apply에 적용을 시켜줘야 편하게 값을 구할 수가 있습니다. apply(HR[,1:2],2, sd) satisfaction_level last_evaluation 0.2486307 0.1711691 바로 이런 식으로 말이지요. 그리고 만약 데이터에 결측치가 존재한다면? 여러분도 아시다시피, 결측치가 존재할 경우 R에서 연산 함수는 na.rm = TRUE 옵션이 존재하지 않으면, 모든 결괏값이 NA로 나오게 됩니다. 각 변수의 표준편차 구하는 방법 D = c(1,2,3,4, NA) E = c(1,2,3,4,5) DF = data.frame( D = D, E = E ) 먼저, 2개의 열(column)으로 구성된 데이터 셋을 만들었습니다. 이제 apply 문으로 각 변수의 표준편차를 구해보도록 하겠습니다. apply(DF, 2, sd) D E NA 1.581139 보시다시피 결측치(NA)가 포함되어 있는 ’D’변수의 표준편차는 NA로 값이 계산이 되었습니다. 이런 경우, NA를 무시할 수 있는 표준편차 계산 함수를 직접 만들어주어야 합니다. colSd = function(x){ y = sd(x, na.rm = TRUE) return(y) } 간단하게 y는 x의 표준편차를 구하며 NA를 무시할 수 있도록 na.rm = TRUE 옵션을 추가하였습니다. 그럼 이제 다시, apply 문을 활용해 보도록 하겠습니다. apply(DF, 2, colSd) D E 1.290994 1.581139 방금 만든 ColSd를 활용해 주니 문제가 없이 계산이 잘 되는 것을 확인할 수 있습니다. 이렇게, 편하게 만들어진 명령어도 존재하지만, 상황에 따라서는 명령어가 존재하지 않을 경우도 있기 때문에, 항상 유념하고 있으셔야 합니다. 다음으로는 다른 종류의 apply 함수를 알아보도록 하겠습니다. apply 계열 함수 소개 그룹 간 평균을 구하고 싶은 경우 기초 통계분석을 진행할 경우, 그룹 간 통계 값(평균, 표준편차) 등을 구하는 상황은 매우 빈번하게 발생합니다. 이런 경우 tapply를 활용하여 간단하게 구할 수가 있습니다. tapply(HR$satisfaction_level, HR$left, mean) 0 1 0.6668096 0.4400980 tapply 함수를 활용하여 (데이터, 그룹, 연산 함수)를 입력해 주면 간단하게 그룹 간 통계 값을 구할 수가 있습니다. 한 번에 여러 변수들에 대해 동일 조건을 주고 싶은 경우 이런 경우 lappy 함수를 활용하면 비교적 편하게 여러 변수에 대하여 동일 함수를 한 번에 적용시킬 수가 있습니다. 예를 들어, 위에서 만들었던 DF 데이터 셋에 대하여 1에 해당되면 “A”를 주고자 합니다. 이 경우 각 변수에 대해 변환 함수를 입력해 주어야 하지만, lapply를 활용하면 그럴 필요가 없어지게 됩니다. 먼저, 일반적인 방법으로 진행하면 이렇게 명령어를 구성해야 됩니다. DF$D2 = gsub(1, "A",DF$D) DF$E2 = gsub(1, "A",DF$E) 이렇게 하는 것도 나쁘지는 않지만, 만약 적용해야 하는 변수의 개수가 10개, 20개인 경우는 많이 난감해지는 상황이 오게 됩니다. 그럼 이제 lappy를 활용하여 한 번에 변경을 시켜보도록 하겠습니다. DF2 = DF[,1:2] DF3 = lapply(DF2, function(x) gsub(1, "A",x)) DF3 = as.data.frame(DF3) lapply 한 줄로 간단하게 코드를 완료했습니다. 이렇게 apply 계열은 데이터 핸들링에서 매우 중요한 부분을 차지합니다. 처음에 apply 계열 함수를 접하면 매우 어렵지만, 사용하시다 보면 익숙해질 것이고, 데이터의 구조를 머릿속에 항상 그리고 계시면 어렵지 않게 apply 계열 명령어를 활용할 수 있으실 것입니다. dplyr 패키지 소개 dplyr 패키지는 R 사용자 사이에서 가장 많이 쓰이는 패키지 중 하나입니다. 그 이유는 복잡하고 연쇄적인 연산을 직관적으로 입력하고 수행할 수 있기 때문입니다. 다음의 예시를 한번 살펴보도록 하겠습니다. head(rowMeans(HR[,1:2])) [1] 0.455 0.830 0.495 0.795 0.445 0.455 HR[,1:2] %>% rowMeans() %>% head() [1] 0.455 0.830 0.495 0.795 0.445 0.455 위 두 명령어는 형태는 다르지만, 동일한 기능을 수행하고 있습니다. 2번째에 해당하는 명령어가 dplyr 패키지의 %>%를 활용한 명령어 구성입니다. 이 매우 이질적이게 생긴 코드는 dplyr 패키지에서 핵심적인 역할을 지니고 있습니다. 먼저, 첫 번째 명령어의 실행 순서를 살펴보도록 하겠습니다. head(rowMeans(HR[,1:2]))의 명령어 실행 순서는 다음과 같습니다. HR[,1:2] 계산 rowMeans(HR[,1:2]) 계산 head(rowMeans(HR[,1:2])) 계산 순서로 연산이 진행이 됩니다. 이 정도야 한 줄로 정리를 할 수 있지만, 만약 명령어를 더 활용해야 하는 경우, 구성이 매우 복잡해질 것입니다. dplyr 패키지의 %>%는 명령어가 복잡해지지 않고 직관적으로 구성이 될 수 있도록 중간다리 역할을 해줍니다. 두 번째 명령어의 구성을 살펴보시면, 데이터에 대해 의도한 연산 순서대로 명령어를 입력한 것을 확인할 수가 있습니다. 다음의 예를 통해 더 확인해 보도록 하겠습니다. apply(HR[,1:5],2, mean) satisfaction_level last_evaluation number_project 0.6128335 0.7161017 3.8030535 average_montly_hours time_spend_company 201.0503367 3.4982332 colMeans(HR[,1:5]) satisfaction_level last_evaluation number_project 0.6128335 0.7161017 3.8030535 average_montly_hours time_spend_company 201.0503367 3.4982332 HR[,1:5] %>% colMeans() satisfaction_level last_evaluation number_project 0.6128335 0.7161017 3.8030535 average_montly_hours time_spend_company 201.0503367 3.4982332 이제 %>%의 목적이 어떤 것인지 아시겠나요?? dplyr의 %>%는 언뜻 보면 매우 어려워 보이지만, 생각보다 간단한 것을 알 수 있습니다. 그럼 계속 기존 R 코드와 %>%를 사용했을 때의 차이점을 비교해 보도록 하겠습니다. 데이터 집계 내기 # Summarise summarise(HR, MEAN = mean(satisfaction_level), N = length(satisfaction_level)) MEAN N 1 0.6128335 14999 HR %>% summarise(MEAN = mean(satisfaction_level), N = length(satisfaction_level)) MEAN N 1 0.6128335 14999 subset 후 ddply를 적용했을 때 %>% 활용법 # library(plyr) HR2_O = ddply(subset(HR, left == 1),c("sales"), summarise, MEAN = mean(satisfaction_level), N = length(satisfaction_level)) HR2_D = HR %>% subset(left == 1) %>% group_by(sales) %>% dplyr::summarise(MEAN = mean(satisfaction_level), N = length(satisfaction_level)) 새로운 변수를 추가하고 싶은 경우 HR3_D = HR2_D %>% mutate(percent = MEAN / N) dplyr와 ggplot2의 조합 library(ggplot2) HR2_D %>% ggplot() + geom_bar(aes(x=sales, y=MEAN, fill=sales), stat="identity") + geom_text(aes(x=sales, y= MEAN+0.05, label=round(MEAN, 2))) + theme_bw() + xlab("부서") + ylab("평균 만족도") + guides(fill = FALSE) + theme(axis.text.x = element_text(angle = 45, size = 8.5, color = "black", face = "plain", vjust = 1, hjust = 1)) A4. 중복 데이터 제거하기 및 데이터 프레임 정렬 4. 중복 데이터 제거하기 및 데이터 프레임 정렬 흔하지는 않지만, 중복으로 입력되는 데이터 셋을 마주치는 일이 생기기 마련입니다. 보통 중복 데이터는 데이터 수집 단계에서 많이 발생합니다. 하지만 이를 하나하나 엑셀로 처리하는 것은 한계가 있기 때문에, R에서 처리하는 방법에 대해 다루어 보고자 합니다. 1차원 벡터, 리스트에서의 중복 제거 A = rep(1:10, each = 2) # 1 ~ 10까지 2번씩 반복 print(A) [1] 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 # 중복 제거 unique(A) [1] 1 2 3 4 5 6 7 8 9 10 1차원 벡터의 경우, unique 명령어를 활용하면, 손쉽게 중복 값을 제거할 수가 있습니다. 데이터 프레임에서의 중복 제거 다음과 같은 데이터 프레임을 예시로 삼겠습니다. # 데이터 불러오기 DUPLICATE = read.csv("D:\Drop box\DATA SET(Drop box)\DUPLICATED.csv") 변수의 구성은 다음과 같습니다. OBS : 번호 NAME : 환자 이름 ID : 환자 고유번호 DATE : 검사 날짜 BTW : Body total water 먼저 환자 이름이 있고, 그 환자의 고유 ID가 있습니다. 동명이인은 많기 때문에 항상 고유 ID를 기록해두기 마련입니다. 전체 중복 제거 DUPLICATED3_1 = DUPLICATE[-which(duplicated(DUPLICATE)),] 하나라도 중복이 되면 전부 지워버립니다. 별로 추천드리지는 않습니다. 변수 한 개를 기준으로 중복 제거 # NAME 이 같은 변수들 중복 제거 DUPLICATED3_2 = DUPLICATE[-which(duplicated(DUPLICATE$NAME)),] 여기서 주목해야 될 부분은 중복 값은 제거를 하고 하나만 남기게 되는데, 그 기준은 Row 번호가 빠른, 즉 위에 있는 행을 남기고 뒤에 있는 데이터 값들을 삭제 시킵다는 것입니다. 다변수를 기준으로 중복 제거 #NAME, ID 두 개의 값이 같은 중복 데이터 제거 # 변수명으로 제거 DUPLICATED3_3 = DUPLICATE[!duplicated(DUPLICATE[,c('NAME','ID')]),] # 변수 인덱스로 제거 DUPLICATED3_4 = DUPLICATE[!duplicated(DUPLICATE[,c(2,3)]),] 여러 변수들을 기준으로 중복 데이터를 삭제하는 경우도 간단합니다. 대신, 행(row) 인덱스에 중복 제거 조건을 주어야 하는 부분이 조금 복잡해 보일 수는 있지만, 천천히 살펴보시면 크게 어렵지 않다는 것을 확인할 수 있으실 것입니다. 추가적으로 가끔 병원에서는 동일 환자가 같은 검사를 날짜를 달리하여 여러 번 받는 경우가 있습니다. 물론 어떤 값을 남겨야 할지는 상황마다 다르겠지만, 지금은 ’마지막 검사 기준 데이터’를 남기는 것으로 진행하도록 하겠습니다. 중복 제거는 맨 처음 값만 남기기 때문에, 최근 검사 데이터가 맨 위로 올라오도록 정렬(sort)을 해주어야 합니다. 데이터 정렬하기 # 날짜 변수 설정하기 DUPLICATE$DATE = as.Date(DUPLICATE$DATE,"%Y-%m-%d") summary(DUPLICATE$DATE) Min. 1st Qu. Median Mean 3rd Qu. "2018-11-25" "2018-11-27" "2018-11-28" "2018-11-28" "2018-11-29" Max. "2018-11-30" 0먼저, 날짜를 기준으로 데이터를 정렬하기 위해서는 DATE 변수가 날짜로 인식이 되어 대소 비교를 할 수 있도록 변수의 strings가 변경이 되어야 합니다. 날짜 변수를 날짜<NAME>으로 바꾸는 명령어는 as.Date, as.Posixct가 있습니다. 보통 ’년-월-일’로 구성되어 있으면 as.Date를 사용하고 ’년-월-일 시:분:초’로 구성되어 있으면 as.Posixct를 쓰게 됩니다. 지금은 ’년-월-일’이기 때문에 as.Date를 사용하도록 하겠습니다. # DATE 변수 기준으로 정렬 DUPLICATE_SORT = DUPLICATE[order(DUPLICATE[,'DATE'],decreasing = TRUE), ] decreasing 옵션은 오름차순 혹은 내림차순으로 할 것인지 정의해 주는 것입니다. decreasing = TRUE은 내림차순으로 진행한다는 의미입니다. 중복제거는 위에서 진행했던 것처럼 진행하면 되겠습니다. 병원에서 같은 환자가 여러 검사를 받는 경우는 매우 흔합니다. 그리고 각 검사 수치를 가지고 분석을 해야 되지요. 하지만 데이터 수집이 조금은 애매하게 되어 있는 경우가 종종 발생합니다. 바로 이런 경우와 같습니다. TEST 변수는 검사 종류라고 보면 됩니다. 수집 체계가 잘못된 것은 아니지만, 각 검사 수치를 모델링에서 써먹으려면, TEST의 각 수준(levels, T1, T2, T3, T4)는 하나의 TEST 변수가 아닌 각각의 T1, T2, T3, T4 변수로 잡혀야 합니다. 이렇게 각 검사 수치가 변수가 되어야 후에 모델링에 사용할 수 있습니다. 다음의 코드는 이렇게 되어 있습니다. library(reshape) RESHAPE = read.csv("D:\Drop box\DATA SET(Drop box)\RESHAPE.csv") CAST_DATA = cast(RESHAPE, OBS + NAME + ID + DATE ~ TEST) reshape 라이브러리는 데이터 프레임의 형태를 바꾸고 싶을 때 주로 사용하는 패키지입니다. 이렇게 TEST의 각 수준(levels)이 변수가 되었을 때, 이런 형태를 Wide Form이라고 합니다. 반대로, 기존에 하나의 TEST 변수로 구성이 되었을 경우 Long Form 형태라고 합니다. 다시 원래대로 돌아가는 방법은 다음과 같습니다. MELT_DATA = melt(CAST_DATA, ID=c("OBS","NAME","ID","DATE")) MELT_DATA = na.omit(MELT_DATA) melt 함수를 이용하면, 다시 원래대로 돌아올 수가 있습니다. Wide & Long Form을 이해하는 것은 데이터 핸들링 단계에서 매우 중요하므로 충분한 연습이 필요한 부분입니다. 추가로 두 형태의 데이터 모두 쓰임이 다릅니다. CAST_DATA의 경우, 그래프 시각화할 때의 데이터 구조로 적합합니다. MELT_DATA의 경우, 모델링 할 때의 데이터 구조로 적합합니다. A5. 데이터 합병하기(merge) 5. 데이터 합병하기(merge) 데이터를 분석하다 보면, 특정 KEY 값으로 데이터를 합병해야 될 때가 있습니다. 방법은 다음과 같습니다. ### 이전 데이터 작업 코드 DUPLICATE = read.csv("D:\Drop box\DATA SET(Drop box)\DUPLICATED.csv") DUPLICATED3_3 = DUPLICATE[!duplicated(DUPLICATE[,c('NAME','ID')]),] RESHAPE = read.csv("D:\Drop box\DATA SET(Drop box)\RESHAPE.csv") CAST_DATA = cast(RESHAPE, OBS + NAME + ID + DATE ~ TEST) ### 데이터 합병 MERGE = merge(DUPLICATED3_3, CAST_DATA[,c(-1, -2, -4)] , by = "ID", all.x = TRUE) A6. 연습문제 6. 연습문제 Event_Time.csv를 불러오시오. 링크 : https://www.drop box.com/sh/xx1w2syi768kfU0/AACZgxgo1fcxyDMgv9U-iTz8a? dl=0 colSums를 활용하여 Alarm, Event 변수의 합을 각각 구하시오. reshape 패키지의 함수를 활용하여 다음의 데이터 셋을 만들어보시오. Ch7. R 중급문법 2단계 이번 장에서는 이전에 다루었던 dplyr를 조금 더 심도 있게 다룹니다. A0. 데이터 불러오기 0. 데이터 불러오기 다운로드 링크 : https://www.drop box.com/sh/vtqlvrgdts2yfez/AAD_cd49dBcvgBNdz-C-A6TFA?dl=0 library(dplyr) STOCK = read.csv("D:\Drop box\DATA SET(Drop box)\Uniqlo_stocks2012-2016.csv") STOCK$Date = as.Date(STOCK$Date) STOCK$Year = as.factor(format(STOCK$Date,"%Y")) STOCK$Day = as.factor(format(STOCK$Date,"%a")) str(STOCK) 'data.frame': 1226 obs. of 9 variables: $ Date : Date, format: "2016-12-30" "2016-12-29" ... $ Open : int 42120 43000 43940 43140 43310 43660 43900 42910 42790 43350 ... $ High : int 42330 43220 43970 43700 43660 43840 44370 43630 43150 43550 ... $ Low : int 41700 42540 43270 43140 43090 43190 43610 42860 42740 42810 ... $ Close : int 41830 42660 43270 43620 43340 43480 44000 43620 43130 43130 ... $ Volume : int 610000 448400 339900 400100 358200 381600 658900 499400 358700 542000 ... $ Stock.Trading: num 2.56e+10 1.92e+10 1.48e+10 1.74e+10 1.55e+10 ... $ Year : Factor w/ 5 levels "2012","2013",..: 5 5 5 5 5 5 5 5 5 5 ... $ Day : Factor w/ 5 levels "금","목","수",..: 1 2 3 5 4 2 3 5 4 1 ... A1. 집계 데이터 만들기 1. 집계 데이터 만들기 원하는 그래프를 그리려고 하다 보면, 가끔 데이터의 집계된 결과를 통해 그래프를 작성해야 될 때가 있습니다. dplyr을 활용하면 데이터 집계 과정과 시각화 과정을 함께 할 수 있습니다. 시각화를 다루기 전에, 자주 쓰이는 dplyr 명령어들을 다루도록 하겠습니다. group_by 집계 기준 변수를 정해주는 명령어입니다. summarise 집계 기준 변수 및 명령어에 따라 요 약 값을 계산합니다. Group_Data = STOCK %>% group_by(Year, Day) %>% summarise(Mean = round(mean(Open)), Median = round(median(Open)), Max = round(max(Open)), Counts = length(Open)) ungroup group으로 묶인 데이터를 그룹 해제 시켜주는 명령어입니다. ungroup을 해주는 이유 group_by를 통해 발생할 수 있는 error 방지를 합니다. Error in mutate_impl(.data, dots) : Column Class can’t be modified because it’s a grouping variable group_by 여부에 따라 결과가 다르게 나옵니다. [] 안에 조건을 줄 때, 함수가 안 먹히는 경우가 발생합니다. Ungroup_Data = Group_Data %>% ungroup() str(Group_Data) Classes 'grouped_df', 'tbl_df', 'tbl' and 'data.frame': 25 obs. of 6 variables: $ Year : Factor w/ 5 levels "2012","2013",..: 1 1 1 1 1 2 2 2 2 2 ... $ Day : Factor w/ 5 levels "금","목","수",..: 1 2 3 4 5 1 2 3 4 5 ... $ Mean : num 17179 17161 17125 17099 17099 ... $ Median: num 17280 17220 17215 17200 17225 ... $ Max : num 21480 21300 21040 20320 20610 ... $ Counts: int 50 51 52 45 50 51 51 50 42 51 ... - attr(*, "groups")=Classes 'tbl_df', 'tbl' and 'data.frame': 5 obs. of 2 variables: ..$ Year : Factor w/ 5 levels "2012","2013",..: 1 2 3 4 5 ..$ .rows:List of 5 .. ..$ : int 1 2 3 4 5 .. ..$ : int 6 7 8 9 10 .. ..$ : int 11 12 13 14 15 .. ..$ : int 16 17 18 19 20 .. ..$ : int 21 22 23 24 25 ..- attr(*, ".drop")= logi TRUE str(Ungroup_Data) Classes 'tbl_df', 'tbl' and 'data.frame': 25 obs. of 6 variables: $ Year : Factor w/ 5 levels "2012","2013",..: 1 1 1 1 1 2 2 2 2 2 ... $ Day : Factor w/ 5 levels "금","목","수",..: 1 2 3 4 5 1 2 3 4 5 ... $ Mean : num 17179 17161 17125 17099 17099 ... $ Median: num 17280 17220 17215 17200 17225 ... $ Max : num 21480 21300 21040 20320 20610 ... $ Counts: int 50 51 52 45 50 51 51 50 42 51 ... str을 통해 Group_Data와 Ungroup_Data를 비교해 보면, 생긴 것은 똑같지만 내부 타입이 다르다는 것을 확인할 수 있습니다. 또한 기본적으로 data.frame 형태가 아닌 것을 확인할 수가 있습니다. R을 처음 시작하는 입장에서는 이러한 사소한 차이에서 발생하는 오류 때문에 크게 고생하는 경우가 자주 있습니다. 그러니 분석을 시작할 때는 as.data.frame을 통해 꼭 data.frame 형태의 strings로 변경해 주시길 바랍니다. count 집계 기준에 따라 데이터의 row 개수를 계산해 줍니다. summarise 내에서 쓰인 length와 비슷한 같은 기능을 수행합니다. Count_Data = STOCK %>% group_by(Year, Day) %>% count() A2. 조건에 따라 데이터 추출하기 2. 조건에 따라 데이터 추출하기 원하는 조건에 따라 데이터를 추출하는 명령어입니다. filter(), subset()을 활용하면 됩니다. 두 명령어 모두 같은 기능을 수행하니 편하신 명령어를 사용하면 됩니다. Subseted_Data = Group_Data %>% filter(Year == "2012") head(Subseted_Data) # A tibble: 5 x 6 # Groups: Year [1] Year Day Mean Median Max Counts <fct> <fct> <dbl> <dbl> <dbl> <int> 1 2012 금 17179 17280 21480 50 2 2012 목 17161 17220 21300 51 3 2012 수 17125 17215 21040 52 4 2012 월 17099 17200 20320 45 5 2012 화 17099 17225 20610 50 A3. 데이터 중복 제거하기 3. 데이터 중복 제거하기 데이터에 내에 존재하는 중복 데이터를 제거합니다. 명령어는 distinct()를 사용합니다. # 중복 데이터 생성 SL = sample(1:nrow(Group_Data),500, replace = TRUE) Duplicated_Data = Group_Data[SL,] Group_Data는 25개의 행(row)로 구성되어 있으나, 중복을 허용하여 500개로 증가시켜버리면 중복 데이터가 무조건 발생하게 됩니다. Duplicated_Data2 = Duplicated_Data %>% distinct(Year, Day, Mean, Median, Max, Counts) A4. 샘플 데이터 무작위 추출 4. 샘플 데이터 무작위 추출 데이터의 행이 너무 많은 경우, 그래프를 그릴 때 연산속도가 오래 걸리며, R이 다운될 수 있는 문제가 있습니다. 그런 경우, 무작위로 샘플 데이터를 뽑아, 가볍게 시각화를 하는 것도 좋은 방법입니다. 명령어는 sample_frac(), sample_n()을 사용합니다. frac은 size에서 비율(0 ~ 1)을, n은 행의 개수를 입력합니다. 참고할 부분은 group 지정 여부에 따라 sample 결과가 다르게 나타납니다. sample_frac() - 그룹이 지정되어 있는 데이터 Sample_Frac_Gr = Group_Data %>% sample_frac(size = 0.4, replace = FALSE) 각 연도에서 2개씩 균형 있게 sampling 된 것을 확인할 수 있습니다. 그룹이 해제되어 있는 데이터 Sample_Frac_Un = Ungroup_Data %>% sample_frac(size = 0.4, replace = FALSE) sample_n() Sample_N_Gr = Group_Data %>% sample_n(size = 5, replace = FALSE) 각 연도별 2개씩 뽑힌 것을 확인할 수 있습니다. group이 적용되어 있는 경우에는 현재 데이터에서는 size 값을 5보다 큰 숫자를 설정할 수가 없습니다. (각 연도별 5개씩 데이터가 있기 때문) Sample_N_Un = Ungroup_Data %>% sample_n(size = 10, replace = FALSE) 제가 입력한 size 값에 따라서 무작위로 10개가 뽑힌 것을 확인할 수 있습니다. 중복 제거를 한 후, 데이터의 행(row)이 25로 돌아온 것을 확인할 수 있습니다. A5. 정해진 Index에 따라 데이터 추출하기 5. 정해진 Index에 따라 데이터 추출하기 무작위 추출이 아닌, 순서대로 뽑거나 원하는 구간만 설정해서 데이터를 뽑아내는 방법입니다. 명령어는 slice(), top_n()이 있습니다. slice() slice()는 Index를 직접 설정함으로, 원하는 구간만 추출할 수 있습니다. 이때 Dataset은 ungroup()이 되어 있는 데이터로 진행해야 됩니다. Slice_Data = Ungroup_Data %>% slice(1:10) top_n() top_n()은 설정해 준 변수를 기준으로 가장 값이 높은 n 개의 데이터를 가져옵니다. Top_n_Data = Ungroup_Data %>% top_n(5, Mean) # Mean이 가장 높은 5개 데이터 추출 A6. 데이터 정렬하기 6. 데이터 정렬하기 데이터를 특정 변수를 기준으로 정렬하는 방법입니다. arrange()를 이용합니다. 마찬가지로 ungroup()이 설정된 데이터로 정렬합니다. 만약 group_by()가 설정되어 있는 데이터를 기준으로 정렬할 경우, Year 별로 정렬합니다. 오름차순 # ungroup으로 그룹 지정을 해제한 데이터 Asce_Data = Ungroup_Data %>% arrange(Mean) # Mean을 기준으로 오름차순 정렬 연도에 상관없이 정렬되는 것을 확인할 수 있습니다. 내림차순 내림차순은 변수에 ’-’를 붙여주면 됩니다. Desc_Data = Ungroup_Data %>% arrange(-Mean) A7. 원하는 변수(Colomn)만 뽑아내기 7. 원하는 변수(Colomn)만 뽑아내기 데이터를 핸들링 할 때, 모든 변수들을 가져갈 필요는 없습니다. 이런 경우 select(), select_if()를 활용하여 원하는 변수들을 뽑아낼 수 있습니다. select() select()를 통해 원하는 변수를 뽑아낼 수 있습니다. 인덱스를 통해 뽑아도 되고, 변수명을 입력해서 뽑아내도 됩니다. 편하신 방법대로 하시면 됩니다. # Index 활용 Select_Data = Group_Data %>% select(1:2) # Column 명 활용 Select_Data = Group_Data %>% select(Year, Day) select_if() select_if()를 통해 뽑는 조건을 줄 수 있습니다. 예를 들어, 데이터 타입에 따라 뽑아낼 수 있습니다. # Factor 변수만 뽑기 Select_if_Data1 = Group_Data %>% select_if(is.factor) 데이터 타입이 Factor인 변수만 뽑아서 데이터 셋을 만든 것을 확인할 수 있습니다. # integer 변수만 뽑기 Select_if_Data2 = Group_Data %>% select_if(is.integer) A8. 새로운 변수 만들기 혹은 한 번에 처리하기 8. 새로운 변수 만들기 혹은 한 번에 처리하기 데이터 핸들링 과정에서 새로운 변수(Column)를 만들고자 할 때 필요한 기능입니다. 대표적으로는 mutate(), mutate_if(), mutate_at()이 있습니다. mutate() mutate()는 하나의 변수를 명령어에 따라 추가하는 방법입니다. Mutate_Data = STOCK %>% mutate(Divided = round(High/Low, 2)) %>% select(Date, High, Low, Divided) mutate_if() mutate_if()은 지정해 준 모든 변수에 대해 계산식을 적용시켜 줍니다. 예를 들어, 데이터의 타입을 변경하고 싶을 때, as.factor() 같은 명령어를 하나씩 적용시키는 방법은 시간을 많이 잡아먹는 막노동 작업입니다. 이런 경우, mutate_if()를 통해 한 번에 데이터 타입을 변경시켜줄 수 있습니다. # integer 타입 변수를 모두 numeric으로 변경 Mutate_If_Data = STOCK %>% mutate_if(is.integer, as.numeric) mutate_at() mutate_at()은 지정한 변수들에 대해 계산식을 적용시키는 명령어입니다. Mutate_At_Data = STOCK %>% mutate_at(vars(-Date,-Year,-Day),log) %>% select_if(is.numeric) Date, Year, Day 변수를 제외하고 나머지 변수들은 모두 log 변환이 적용된 것을 확인할 수 있습니다. 여기까지 dplyr의 활용법을 다루었습니다. 모든 기능을 다룬 것은 아니고, 제 경험상 많이 썼던 기능들을 위주로 선별하였습니다. dplyr로 핸들링 한 후, %>%를 이용하여 바로 ggplot() 명령어와 연계할 수 있기 때문에 매우 효율적으로 작업을 할 수 있습니다. A9. 연습문제 9. 연습문제 HR 데이터에 Factor 변수들만 뽑아, HR_Factor라는 데이터 프레임을, Numeric 변수들만 뽑아 HR_Numeric 데이터를 생성하시오. HR 데이터의 sales, left 변수를 기준으로 satisfaction_level, last_evaluation의 평균, 중위수, 표준편차 값을 계산해서 HR_summarise라는 데이터 프레임을 만드시오. Ch8. R 데이터 시각화 R에는 ggplot2라는 강력한 시각화 패키지가 있으며, 요즘 여러 해외 저널에서는 ggplot2를 이용한 그래프를 시각화 도구로 많이 사용하고 있습니다. 이번 챕터에서는 이 ggplot2를 이용하여 데이터를 효과적으로 시각화하는 방법에 다루고자 합니다. A1. ggplot2 테마 수정 1. ggplot2 테마 수정 ggplot2()는 기본적으로 회색 바탕에 흰색 격자선이 기본 배경입니다. 하지만, 이를 싫어하는 분들도 분명 계실 것입니다. 이런 경우에는 테마를 변경하여 그래프를 그리면 원하시는 스타일로 그릴 수가 있습니다. 테마의 종류는 다음과 같습니다. library(ggplot2) library(ggthemes) HR = read.csv('F:/Drop box/DATA SET/HR_comma_sep.csv') HR$left = as.factor(HR$left) HR$salary = factor(HR$salary, levels = c("low","medium","high")) # Classic Theme ggplot(HR, aes(x=salary)) + geom_bar(aes(fill=salary)) + theme_classic() # BW Theme ggplot(HR, aes(x=salary)) + geom_bar(aes(fill=salary)) + theme_bw() 제가 가장 많이 사용하는 테마 2개입니다. 하지만, 다른 다양한 테마도 여러 가지가 있으니, 한번 보도록 하겠습니다. ggthemes 패키지를 설치하면 더 많은 테마를 적용시킬 수가 있습니다. Graph = ggplot(HR, aes(x=salary)) + geom_bar(aes(fill=salary)) Graph + theme_bw() + ggtitle("Theme_bw") Graph + theme_classic() + ggtitle("Theme_classic") Graph + theme_dark() + ggtitle("Theme_dark") Graph + theme_light() + ggtitle("Theme_light") Graph + theme_linedraw() + ggtitle("Theme_linedraw") Graph + theme_minimal() + ggtitle("Theme_minimal") Graph + theme_test() + ggtitle("Theme_test") Graph + theme_void() + ggtitle("Theme_vold") A2. 범례 제목 수정 2. 범례 제목 수정 범례는 수정하기는 귀찮지만, 그래프를 처음 보는 사람이 가장 먼저 확인하는 부분입니다. 그렇기에 신경을 좀 써줘야 할 필요가 있습니다. 범례를 수정하는 방법은 다음과 같습니다. 범례 제목 수정 ggplot(HR, aes(x=salary)) + geom_bar(aes(fill=salary)) + theme_bw() + labs(fill = "범례 제목 수정(fill)") ggplot(HR, aes(x = salary)) + geom_bar(aes(col = salary)) + theme_bw() + labs(col = "범례 제목 수정(col)") 먼저 범례 제목을 수정하기에 앞서 색을 지정하는 2가지 방법에 대해 이해를 하셔야 합니다. 하나는 fill, 나머지 하나는 col입니다. fill은 말 그대로 ‘색 채우기’ 개념으로 면적이 있는 도형의 색을 바꿀 때 사용하는 명령어입니다. 반대로 col은 색을 바꿔만 주는 것으로 점, 글씨, 선 등에 해당됩니다. 위 2그래프를 살펴보시면 하나는 fill이고, 나머지 하나는 col로 되어 있습니다. 한눈에 봐도 차이점을 확인할 수 있습니다. 범례 제목을 바꿔주는 것은 labs()를 이용하면 매우 간단하게 바꿀 수가 있습니다. 범례 위치 수정 범례 위치를 수정하는 방법은 theme() 옵션에서 legend.positon을 통해 위치를 조정시켜줄 수가 있습니다. Graph + theme(legend.position = "top") Graph + theme(legend.position = "bottom") Graph + theme(legend.position = c(0.9,0.7)) Graph + theme(legend.position = 'none') 범례 테두리 설정 Graph + theme(legend.position = "bottom") Graph + theme(legend.position = "bottom", legend.box.background = element_rect(), legend.box.margin = margin(1, 1, 1, 1)) 범례 테두리를 설정하면 깔끔하게 범례를 정리할 수가 있습니다. A3. 축 변경 3. 축 변경 축 변경의 경우, 가장 먼저 신경 써야 할 부분은 축에 설정된 변수가 Discrete 인지 Continuous 인지 확인부터 해야 합니다. 제가 앞서 말했듯이 변수의 척도에 대한 이해는 분석뿐 아니라 시각화에서도 큰 부분을 차지하고 있습니다. 즉 사실상 분석 전체에 해당되는 경우인 것입니다. 먼저 정리하자면 다음과 같습니다. ggplot(HR, aes(x = salary)) + geom_bar(aes(fill = salary)) + theme_bw() + scale_x_discrete(expand = c(0,0), labels = c("하","중","상")) + scale_y_continuous(expand = c(0,0),breaks = seq(0,8000, by = 1000)) ggplot(HR, aes(x = salary)) + geom_bar(aes(fill = salary)) + theme_bw() + scale_x_discrete(expand = c(0,0), labels = c("하","중","상")) + scale_y_continuous(expand = c(0,0),breaks = seq(0,8000, by = 1000)) + scale_fill_discrete(labels = c("하","중","상")) 위 그래프에서 x축은 이산형이기 때문에, scale_x_discrete를 활용하여 축 수정을 해주며, y 축은 집계 값을 나타내는 연속형 수치이기 때문에 scale_y_continuous를 활용하여 수정을 해주면 됩니다. 여기서 expand 옵션은 그래프를 테두리에 맞추어 그리게 해주는 옵션입니다. 위에서 그렸던 그래프들을 살펴보면 조금씩 축(테두리)로부터 붕 떠있다는 점을 발견하실 수가 있습니다. 이 부분을 옵션으로 수정을 해주는 부분입니다. 또한 이산형(Discrete)에서는 labels 옵션을 통해 축을 변경시켜줄 수 있으며, 연속형(Continuous)은 breaks를 통해 축을 변경시켜 줄 수가 있습니다. 범례에서의 표시는 labels를 바꾸어주는 방법은 scale_fill_discrete()를 활용하면 간단하게 바꿀 수가 있습니다. 만약 색이 col 옵션으로 구분이 되었다면, scale_color_discrete()를 통해 바꿔줄 수가 있습니다. 축범위 설정 축 범위 설정은 그래프를 표현할 범위를 나타낼 수가 있습니다. ggplot(HR, aes(x = salary)) + geom_bar(aes(fill = salary)) + theme_bw() + ylim(0,5000) ggplot(HR, aes(x = salary)) + geom_bar(aes(fill = salary)) + theme_bw() + ylim(0,13000) y 축에 ylim(0,5000)을 주면 y 축 기준 0 ~ 5000까지만 나타내게 됩니다. low, medium은 5000보다 크기 때문에 그래프가 잘려서 나오지 않는 것을 확인할 수가 있습니다. 색 변경 R에서는 기본적으로 색 분류가 지정되어 있습니다. 하지만 가끔 색을 직접 변경을 해주고 싶은 경우가 존재합니다. Discrete 변수를 기준으로 색을 지정할 때는 scale_fill_manual() 혹은 scale_color_manual()을 활용하면 원하는 색 배치를 배정할 수 있습니다. ggplot(HR, aes(x = salary)) + geom_bar(aes(fill = salary)) + theme_bw() + scale_fill_manual(values = c('red','royalblue','tan')) ggplot(HR, aes(x = salary)) + geom_bar(aes(fill = salary), alpha = 0.4) + theme_bw() + scale_fill_manual(values = c('red','royalblue','tan')) scale_fill_manual에서 원하는 색상을 바꿔줄 수가 있습니다. alpha를 이용하면 색을 연하게 칠할 수가 있습니다. 그래프 분할 및 대칭 이동 그래프 분할 및 대칭이동은 다음의 옵션 추가를 통해 가능합니다. ggplot(HR, aes(x = salary)) + geom_bar(aes(fill = salary), alpha = 0.4) + theme_bw() + scale_fill_manual(values = c('red','royalblue','tan')) + coord_flip() ggplot(HR, aes(x = salary)) + geom_bar(aes(fill = salary)) + theme_bw() + scale_fill_manual(values = c('red','royalblue','tan')) + guides(fill = FALSE) + facet_wrap(~left, ncol = 1) 참고로 guides()를 활용하면 범례를 없애는 것도 가능합니다. coord_flip()을 추가해 주면 그래프가 x축, y 축이 대각선 대칭이 되어 그래프가 작성이 됩니다. facet_wrap()은 그래프를 분할하고 싶은 변수의 기준을 입력해 준 다음, ncol 옵션을 통해서 몇 개의 열로 표현할지 정해야 합니다. 현재는 ncol = 1을 주었는데 이렇게 되면 그래프를 열 1개로 나열한다는 의미가 됩니다. 글자 크기, 각도 수정 ggplot(HR, aes(x = salary)) + geom_bar(aes(fill = salary)) + theme_bw() + scale_fill_manual(values = c('red','royalblue','tan')) + coord_flip() + theme(legend.position = 'none', axis.text.x = element_text(size = 15, angle = 90), axis.text.y = element_text(size = 15), legend.text = element_text(size = 15)) Ch9. ggplot2를 활용한 다양한 그래프 그리기 이번 장에서는 ggplot2로 그릴 수 있는 그래프들의 종류에 대해 알아보도록 하겠습니다. library(ggplot2) library(dplyr) STOCK = read.csv("D:\Drop box\DATA SET(Drop box)\uniqlo.csv") STOCK$Date = as.Date(STOCK$Date) STOCK$Year = as.factor(format(STOCK$Date,"%Y")) STOCK$Day = as.factor(format(STOCK$Date,"%a")) Group_Data = STOCK %>% group_by(Year, Day) %>% dplyr::summarise(Mean = round(mean(Open)), Median = round(median(Open)), Max = round(max(Open)), Counts = length(Open)) A1. Bar Chart 막대도표는 가장 기본적인 그래프입니다. 하나의 이산형 변수에 대해 시각화를 하는 그래프입니다. 기본적으로 y 축은 따로 설정할 필요는 없습니다. 하나의 이산형 변수를 기준으로 x축 변수 1개로만 그리는 경우 ggplot(Group_Data) + geom_bar(aes(x = as.factor(Counts),fill = .. count..)) + xlab("") + ylab("") + scale_fill_gradient(low = "#CCE5FF", high = "#FF00FF") + theme_classic() + ggtitle("Continuous Color") ggplot(Group_Data) + geom_bar(aes(x = as.factor(Counts),fill = Day),alpha = 0.4) + xlab("") + ylab("") + theme_classic() + ggtitle("Discrete Color") 색 구분 포지션을 변경하고 싶은 경우 ggplot(Group_Data) + geom_bar(aes(x = as.factor(Counts),fill = Day), alpha = 0.4, position = "dodge") + xlab("") + ylab("") + theme_classic() + ggtitle("Discrete Color\n position Dodge") x축, y 축 1개씩 총 변수 2개로 그리는 경우, stat = ‘identity’ 사용합니다. ggplot(Group_Data) + geom_bar(aes(x = Year, y = Mean, fill = Day), stat = 'identity') + scale_fill_manual(values = c("#C2DAEF","#C2EFDD","#BBAAE9", "#E9F298","#FABDB3")) + theme_classic() A2. Histogram 히스토그램은 막대도표와 매우 비슷하게 생겼지만, 연속형 변수를 시각화하는 점에서 막대도표와 큰 차이점을 지니고 있습니다. 연속형 변수에 대해 구간을 나누어, 막대도표처럼 집계된 값을 출력하여 그래프를 그립니다. 여기서 히스토그램의 변수 구간을 조정하는 명령어는 binwidth를 활용합니다. ggplot(STOCK) + geom_histogram(aes(x = High , fill = .. x.. ), binwidth = 1000) + scale_fill_gradient(low = "#CCE5FF", high = "#FF00FF") + theme_classic() + labs(fill = "Labels Name") ggplot(STOCK) + geom_histogram(aes(x = High , fill = Day), binwidth = 1000, alpha = 0.4) + theme_classic() + labs(fill = "Labels Name") ggplot(STOCK) + geom_histogram(aes(x = High , fill = Day), binwidth = 1000, alpha = 0.4, position = "dodge") + theme_classic() + labs(fill = "Labels Name") A3. Density plot 히스토그램과 비슷하게 작성합니다. 그래프 면적이 각각의 비율이 되도록 맞추어줍니다. ggplot(STOCK) + geom_density(aes(x = High)) + theme_classic() + labs(fill = "Labels Name") ggplot(STOCK) + geom_density(aes(x = High , fill = Day),alpha = 0.4) + theme_classic() + labs(fill = "Labels Name") + theme(axis.text.x = element_text(size = 9, angle = 45, hjust = 1)) A4. Boxplot & Jitter plot 박스 플롯은 데이터를 요약하는 데에 있어 매우 유용한 그래프입니다. 먼저, 박스 플롯에 대해 이해를 하실 필요가 있습니다. 박스 플롯은 분위수(quantile)로 작성이 됩니다. 상자 내부에 위치한 줄은 중위수(Median)를 의미합니다. 상자의 밑변, 윗변은 각각 1, 3분 위수를 의미합니다. 상자를 감싸는 테두리는 울타리라고 합니다. 이 선을 벗어나면, 주로 이상치(Outlier)라고 합니다. 박스 플롯을 그리기 위해서 x축은 Descrete 변수를, y 축에는 Continuous 변수를 배치해야 합니다. ggplot(STOCK) + geom_boxplot(aes(x = Day, y = Volume, fill = Day), alpha = 0.4, outlier.color = 'red') + theme_bw() ggplot(STOCK) + geom_boxplot(aes(x = Day, y = Volume, fill = Day), alpha = 0.2, outlier.color = 'red') + geom_jitter(aes(x= Day, y= Volume, col = Day),alpha = 0.1) + theme_bw() A5. Violin plot 박스 플롯과 비슷한 역할을 수행합니다. ggplot(STOCK) + geom_violin(aes(x = Day, y = Volume, fill = Day), alpha = 0.4) + theme_bw() A6. Scatter plot 산점도는 데이터의 상관관계를 파악하기에 매우 유용한 그래프입니다. 그래프에서 shape, size 등을 통해 다양한 그래프를 그릴 수가 있습니다. ggplot(STOCK) + geom_point(aes(x = Open, y = Stock.Trading, col = High, size = log(Volume), shape = Year)) + scale_color_gradient(low = "#CCE5FF", high = "#FF00FF") + scale_shape_manual(values = c(19,20,21,22,23)) + labs( col = "Color", shape = "Shape", size = "Size" ) + theme_bw() + theme(axis.text.x = element_blank()) A7. Smooth plot geom_smooth는 회귀선을 그려줍니다. ggplot(STOCK) + geom_smooth(aes(x = Open, y = Stock.Trading), method = 'lm', col = '#8A8585') + theme_bw() ggplot(STOCK) + geom_point(aes(x = Open, y = Stock.Trading, ),col = 'royalblue', alpha = 0.2) + geom_smooth(aes(x = Open, y = Stock.Trading), method = 'lm', col = '#8A8585') + theme_bw() A8. abline, vline, h line 그래프에 평행선, 수직선, 대각선을 그릴 수 있는 명령어입니다. ggplot(NULL) + geom_vline(xintercept = 10, linetype = 'dashed', col = 'royalblue', size = 3) + geom_h line(yintercept = 10, linetype = 'dashed', col = 'royalblue', size = 3) + geom_abline(intercept = 0, slope = 1, col = 'red', size = 3) + theme_bw() A9. Step plot 계단<NAME>의 그래프로, 값의 증가량을 나타낼 때 효과적입니다. Hazard_Ratio = c(0.1,0.3,0.4,0.45,0.49,0.52,0.6,0.65,0.75,0.8,0.95) Survival_Time = c(1,2,3,4,5,6,7,8,9,10,11) ggplot(NULL) + geom_step(aes(x = Survival_Time, y = Hazard_Ratio),col = 'red') + scale_x_continuous(breaks = Survival_Time) + theme_classic() B1. Density 2d plot 밀도 그래프를 2개의 차원으로 그리는 그래프입니다. ggplot(STOCK) + geom_point(aes(x= log(Stock.Trading), y = Open, col = Open)) + geom_density2d(aes(x= log(Stock.Trading), y = Open)) + scale_color_gradient(low = "#E93061", high = "#574449") + theme_bw() B2. Text plot 산점도와 거의 동일합니다. 다만, 그냥 점이 아닌 지정한 글자로 그래프를 그리는 방식입니다. SL = sample(1:nrow(STOCK), 200, replace = FALSE) ggplot(STOCK[SL,]) + geom_text(aes(x = Date , y= Open, label = Open, col = Open), size = 2) + scale_color_gradient(low = "#CCE5FF", high = "#0080FF") + theme_bw() B3. Line plot & Timeseries plot 선 그래프에서는 group이라는 옵션이 필요합니다. ggplot(STOCK) + geom_line(aes(x= Year, y = Open),group = 1) + theme_bw() 이런 경우 선 그래프는 잘못 그려진 경우입니다. 그 이유는 선은 동일한 x에서 하나의 y 값만을 가져야 하는 특징을 지니고 있습니다. 그러니 선 그래프를 그리기 전에는 항상 이 점을 유의해서 요 약 값을 만들어 준 후, 그래프를 작성해야 합니다. ggplot(STOCK) + geom_line(aes(x = Date, y = Open), group = 1) + theme_bw() ggplot(STOCK) + geom_line(aes(x = Date, y = Open, col = Year, group = Year)) + theme_bw() B4. Error bar plot 우리가 직접 범위를 조정할 수 있는 오차 범위 그래프입니다. 학술 저널에서는 꽤나 잘 쓰이는 그래프입니다. 일반적으로 point, boxplot과 혼합할 때 주로 쓰입니다. DF = STOCK %>% group_by(Year) %>% summarise(Min = min(High), Max = max(High)) ggplot(NULL) + geom_boxplot(data = STOCK, aes(x = Year, y = High, fill = Year)) + geom_errorbar(data = DF, aes(x = Year, ymin = Min, ymax = Max)) + theme_classic() B5. Corrplot 상관계수를 히트맵<NAME>으로 한 그래프입니다. Cor_matrix = cor(iris[,1:4]) # iris는 R 기본 내장 데이터 library(corrplot) corrplot(Cor_matrix , method = "color", outline = T, addgrid.col = "darkgray", order="hclust", addrect = 4, rect.col = "black", rect.lwd = 5, cl.pos = "b", tl.col = "indianred4", tl.cex = 1, cl.cex = 1, addCoef.col = "white", number.digits = 2, number.cex = 1, col = colorRampPalette(c("darkred","white","midnightblue"))(100)) B6. Heatmap 위 Corrplot과 비슷한 형태의 그래프입니다. 원하는 값을 기준으로 색의 온도를 나타낼 수가 있습니다. ggplot(Group_Data) + geom_tile(aes(x = Year, y = Day, fill = Counts),alpha = 0.6) + scale_fill_gradient(low = "#C2DAEF", high = "#8A8585") + theme_classic() B7. Ribbon plot 범위를 정할 수 있는 선 그래프입니다. ggplot(STOCK) + geom_ribbon(aes(x= Date, ymin = log(Low) - 0.5, ymax = log(High) + 0.5),fill = 'royalblue' , alpha = 0.2) + theme_classic() ggplot(STOCK) + geom_ribbon(aes(x= Date, ymin = log(Low) - 0.5, ymax = log(High) + 0.5),fill = 'royalblue' , alpha = 0.2) + geom_point(aes(x= Date, y = log(Low) - 0.5), col = '#8A8585', alpha = 0.8) + geom_point(aes(x= Date, y = log(High) + 0.5), col = '#8A8585', alpha = 0.8) + geom_line(aes(x = Date, y = log(Open)),group =1 , col = '#C2DAEF' , linetype = 'dashed', size = 0.1) + geom_point(aes(x = Date, y = log(Open)),col = 'red', alpha = 0.4) + theme_classic() + ylab("") + xlab("") B8. Ridge plot density plot을 여러 개 그릴 수 있는 그래프입니다. library(ggridges) ggplot(STOCK) + geom_density_ridges_gradient(aes(x = log(High) + 0.2 , y= Year, fill = .. x..),gradient_lwd = 1.) + theme_ridges(grid = FALSE) + scale_fill_gradient(low= "#8A8585", high= "#C2DAEF") + theme(legend.position='none') + xlab("") + ylab("") B9. Area plot 누적값을 나타내는 영역 그래프입니다. ggplot(Group_Data) + geom_area(aes(x= as.numeric(as.character(Year)), y = Mean , fill = Day),alpha = 0.4) + theme_classic() + xlab("") C1. Polygon plot 그래프 분포의 범위를 나타내는 그래프입니다. geom_polygon()이라는 명령어가 있지만, 해당 명령어는 쓰기가 조금 까다롭습니다. 요구하는 데이터 입력 방식이 간단하지가 않습니다. 그렇기 때문에 stat_ellipse() 명령어를 사용하여 polygon 플랏을 그리도록 하겠습니다. stat_ellipse()처럼 stat으로 시작하는 명령어는 옵션에 geom = ‘polygon’처럼 어떻게 그래프를 그릴 것인지 옵션을 주어야 합니다. ggplot(STOCK) + stat_ellipse(geom = 'polygon', aes(x = Volume, y = Stock.Trading, fill = Year), alpha = 0.2) + geom_point(aes(x = Volume, y = Stock.Trading, col = Year), alpha = 0.2) + theme_classic() + # 그래프 가시성을 위해 축 범위 조절 xlim(0,1000000) + ylim(0,50000000000) + theme(axis.text.x = element_blank()) C2. Rect plot 사각형 형태의 그래프입니다. 주로 waterfall 그래프를 그리는데 활용이 됩니다. ggplot(Group_Data) + geom_rect(aes(xmin = as.numeric(as.character(Year)) - 0.5 , xmax = as.numeric(as.character(Year)) + 0.5, ymin = Median, ymax = Max, fill = Year), alpha = 0.4) + geom_h line(yintercept = mean(Group_Data$Median), linetype = 'dashed', col = 'red') + theme_classic() + facet_wrap(~Day, nrow = 1) + theme(axis.text.x = element_blank()) ChB1. 기초통계 이론 1단계 엑셀 통계와 R 통계가 다른 부분 흔히, 통계를 전공하지 않은 사람들은 엑셀을 활용하여 데이터 분석을 진행합니다. 피벗테이블을 통해 데이터를 집계 내고, 함수를 이용하여 평균과 분산을 구하기도 합니다. 이러한 기초통계 분석은 R로도 할 수가 있으며, 언뜻 보기에는 크게 다른 점이 없어 보입니다. 오히려 프로그램이 더 직관적으로 구성이 되어 있는 엑셀이 편합니다. 그렇다면 R을 왜 해야 되는 것일까요? 바로 ’통계학’에 기반한 데이터 분석을 진행하기 위해서입니다. 그렇다면 통계학이 일반적인 기초분석과 다른 점은 무엇일까요? 그 부분은 바로 같은 평균을 계산할 때, 기초 통계는 정말 평균만을 뽑아내지만 통계학에서는 평균과 함께 ’분산’을 계산합니다. 즉 더 많은 정보를 활용하여 데이터를 분석하는 것이 목표입니다. 여기서 분산이란, 변동의 개념으로 데이터가 중심으로부터 얼마나 산포했는지 값을 나타냅니다. 통계학에서는 같은 평균을 보더라도, 분산을 함께 고려하여 해당 평균의 값이 맞는지 틀린 지 검정과 추정을 진행하게 됩니다. 이는 나중에 점추정과 구간추정에서 자세히 다루게 됩니다. A1. 표본공간과 확률변수 확률 실험과 표본공간 확률 실험 : 같은 조건 하에서 실험을 반복할 때, 그 결과가 예측 불가능한 실험 표본 공간 : 확률 실험의 모든 가능한 결과들의 집합 통계 이론을 공부할 때 가장 먼저 알아야 될 용어는 확률 실험입니다. 확률 실험은 쉽게는 주사위 던지기부터 시작하여, 오늘 지각을 할지 안 할지 실험하는 것까지 모든 일상생활을 확률 실험이라고 할 수 있습니다. 여기서 확률 실험의 모든 가능한 결과들의 집합을 표본공간(Sample Sapce)이라고 합니다. 예를 들어, 동전을 던져 앞, 뒷면이 나오는지 확인하는 확률 실험을 진행하였을 경우, 표본공간은 {앞, 뒤}가 됩니다. 확률변수(Random Variable) 확률변수 : 발생 가능한 모든 경우에 대해서 각각의 실숫값을 대입해 주는 하나의 함수 다음으로는 통계학에서 가장 중요하다고 할 수 있는 확률변수(Random Variable)가 등장합니다. 표본공간의 각 원소 하나하나에 원하는 목적에 따라 그에 걸맞은 실수를 대입해 주는 함수입니다. 여기서 확률변수는 변수의 척도(이산형, 연속형)에 따라 2가지로 나뉩니다. 이산형 확률변수(Discrete Random Variable) : 어떤 값을 가질 확률을 계산하는 확률변수 연속형 확률변수(Conituous Random Variable) : 어떤 구간 내에 포함될 확률을 계산하는 확률변수 예시 1) 성별 어떤 팀에서 한 명을 리더로 선출하려고 하는데 성별에 관심이 있습니다. 이 경우 표본공간은 (남자, 여자) 두 가지로 이루어진 집합이 될 것입니다. 이때 확률변수를 '여자는 0 남자는 1'이라고 정의해 봅시다. 반대로 해도 상관없습니다. 그렇다면 리더가 선출되었을 때 0 또는 1이라는 확률변수 값을 얻을 수 있을 것입니다. 이는 (남자, 여자)라는 표본공간에서 각 원소들을 0과 1이라는 실수로 전화해 주는 변환 함수입니다. 예시 2) 주사위 눈이 3까지 있는 주사위 두 개를 굴리는 상황입니다. 확률변수를 '두 주사위 눈의 합'이라고 정의해 봅시다. 변수라고 하면 나올 수 있는 경우는 다음과 같습니다. 가능한 경우는 총 9가지입니다. 이는 표본공간이 9개의 원소를 가지고 있는 집합이라는 뜻이고 '두 눈의 합'이라는 함수인 확률변수는 총 5개의 값을 갖게 됩니다. 위 표에서 보면 표본공간은 왼쪽 부분이 되겠고 확률변수가 가질 수 있는 실수는 오른쪽이겠지요. 이렇게 표본공간에서 실수로 변환해 주는 변환 함수가 확률변수입니다. 또한 확률변수의 특징은 각 경우가 나올 확률이 알려져 있다는 것입니다. 주의해야 할 점은 확률변수는 그 자체로도 함수라는 사실입니다. 흔히 많은 분들이 확률변수와 확률함수를 헷갈리시는데, 확률변수는 표본공간에서 실수로 가는 함수이고 확률함수는 확률변수가 어떤 값을 가질 때(혹은 어떤 범위 내에 포함될 때)의 확률을 계산하는 함수입니다. 위 표에서는 세 번째 열이 확률함수 값이라고 할 수 있습니다. A2. 이산형 확률분포 2. 이산형 확률분포 첫 번째 챕터에서 확률변수의 개념을 말씀드리면서 확률변수는 가능한 값들에 대한 확률이 알려져 있고 그것을 계산하는 계산하는 함수가 확률함수(Probability Function)라는 것을 말씀드렸습니다. 그렇다면 이러한 확률들은 어떻게 알 수 있을까요? 그 확률변수들이 가지고 있는 확률의 구조를 알아야 하며 이 확률 구조를 흔히 확률분포(Probability Distribution)라고 합니다. 이산형 확률변수 => 이산형 확률분포 => 확률 질량 함수(Probability Mass Function, m) 연속형 확률변수 => 연속형 확률분포 => 확률밀도함수(Probability Density Function, d) 일반적으로 확률을 계산하는 대부분의 분석들은 이 확률분포와 그에 따른 확률함수를 이용한 분석들입니다. 앞으로 배우게 될 추정과 검정과 같은 통계분석 역시 이 확률분포를 통해서 하게 됩니다. 그렇지만 실제 데이터에서 정확히 일치하는 확률분포를 고안해 내기는 쉬운 일이 아닙니다. 이산형 확률분포는 데이터의 수집 상황에 따라 결정될 수 있으나 연속형의 경우는 사실 뚜렷한 방법이 없기에 얻은 데이터를 기반으로 추측하는 것이 대부분입니다. 하지만, 사람들이 실험과 연구를 하다 보니, 수많은 확률분포에서 특정한 패턴을 나타내는 분포들을 발견하였고, 이를 정리하여 이론을 성립했습니다. 이제부터 해당 확률분포들에 대해 알아보도록 하겠습니다. 이산형 확률분포는 데이터가 수집되는 상황에 따라 결정될 수 있다고 했습니다. 이 말은 곧 어떤 식으로 데이터를 수집하냐 혹은 어떤 방식으로 데이터를 분류하냐에 따라 우리가 가장할 수 있는 분포의 종류가 바뀔 수 있다는 의미입니다. 확률 질량 함수( m)는 다음의 수식으로 표현합니다. x ( ) P [ = ] 수식의 해석은 간단합니다.에 해당할 확률을 구한 값입니다. A3. 이항분포(Binomial distribution) 3. 이항분포(Binomial distribution) 베르누이 시행 : 가능한 결과가 배타적인 두 가지 중 하나로 나타나는 확률 실험 이항분포 : 성공 확률이 인 베르누이 시행을 독립적으로 번 실행하였을 때, 성공의 수를 확률변수로 정의하는 분포 이항분포는 확률변수가 배타적인 두 가지 범주를 갖고 각 시행은 독립적인 경우에서의 분포입니다. 이 시행을 베르누이 시행이라고도 합니다. 여기서 독립적이라는 것은 각 시행이 다른 시행에 전혀 영향을 미치지 않는다는 것입니다. 간단한 예로 팀원 중 10주 동안 무작위로 돌아가면서 당직을 서는데 남자가 당식을 서는 횟수에 관심이 있다고 합시다. 성별은 남자, 여자 두 가지 경우만 상호 배타적으로 존재하므로 조건에 부합합니다. 그런데 만약 한 번 뽑힌 사람을 다음 당직 때 후보에서 제외하게 된다면 이는 각 시행이 독립적이지 않습니다. 그렇지 않고 계속 동일한 후보군에서 무작위로 뽑게 된다면 각 시행은 독립적이라고 할 수 있을 것입니다. 조금 더 상황을 일반화시켜 봅시다. 시행은 총 번의 독립적인 베르누이 시행에서 관심 있는 범주가 나올 확률이라고 해봅시다. 이런 조건들이 이항분포를 결정짓는 '상황'이며, 여기서 이항분포는 관심 있는 범주가 나오는 횟수를 확률변수로 하는 분포입니다. 이제 이항분포의 확률함수를 만들어 볼 수 있습니다. 성공 확률이 0.6인 이항분포 생성 library(ggplot2) # 난수 생성 RB = rbinom(n = 400 , size = 1, prob = 0.6) ggplot(NULL) + geom_bar(aes(x = as.factor(RB), fill = as.factor(RB))) + theme_bw() + xlab("") + ylab("") + scale_x_discrete(labels = c("실패","성공")) + theme(legend.position = 'none') 이면 ∼ i ( , ) 이, ( = ) ( y ) y ( − ) − , = , , ⋯ 이 pmfpmf를 통해서 관심 있는 범주가(편의상 성공이라고 하겠습니다.) nn 개중 하나도 나오지 않을 확률부터 nn 개 중 nn 개를 성공할 확률을 구할 수 있습니다. 또한 이러한 형태의 이항분포의 평균과 분산은 각각 npnp, np(1−p) np(1−p)입니다. 이를 다음과 같이 표현합니다. [ ] n V [ ] n ( − ) 예시 위의 수식을 R로 구현해 보면 다음과 같습니다. library(ggplot2) # 난수 생성 X = c() P = c() for(k in 1:10){ RDB = dbinom(x = k, size = 10, prob = 0.4) X = c(X, k) P = c(P, RDB) } ggplot(NULL) + geom_bar(aes(x = X, y = P),stat = 'identity') + theme_bw() + scale_x_continuous(breaks = seq(1,10)) + xlab("성공 횟수") + ylab("확률") X = c() P = c() for(k in 1:10){ RDB = dbinom(x = k, size = 10, prob = 0.8) X = c(X, k) P = c(P, RDB) } ggplot(NULL) + geom_bar(aes(x = X, y = P),stat = 'identity') + theme_bw() + scale_x_continuous(breaks = seq(1,10)) + xlab("성공 횟수") + ylab("확률") 총 10번 실험을 한다고 가정하였을 때, 왼쪽은 성공 확률이 0.4일 때, 성공 횟수에 따른 성공 확률을 나타내며, 우측은 성공 확률이 0.8일 때, 성공 횟수에 따른 성공 확률을 의미합니다. A4. 다항분포(multinomial distribution) 4. 다항분포(multinomial distribution) 다항분포 : 실험 결과가 개인 확률 실험을 번 반복하였을 때, 각 범주에 속하는 횟수를 확률변수로 하는 분포 다항분포는 이항분포의 확장입니다. 이항분포가 번 시행에서 확률변수가 가질 수 있는 범주가 성공/실패 두 가지였다면, 다항분포에서는 번 시행에서 확률변수가 가질 수 있는 범주가 가지로 확장됩니다. 반대로 = 인 경우, 이항분포가 됩니다. = 인 경우인 다음 표를 보겠습니다. RM = as.data.frame(t(rmultinom(n = 1, size = 10, prob = c(0.2,0.5,0.3)))) RM = colSums(RM) ggplot(NULL) + geom_bar(aes(x = names(RM), y= RM, fill = names(RM)),stat = 'identity') + theme_bw() + theme(legend.position = 'none') + scale_x_discrete(labels = c("1","2","3")) + xlab("") + ylab("") 위의 경우는 총 개의 독립적인 시행 중 범주 1이 개 범주 2가 개 나올 확률을 나타내는 다항분포입니다. 번의 시행이니 당연히 마지막 범주는 − − 개가 될 것이고 확률은 − 1 p 가 될 것입니다. 즉, 확률변수가 2개입니다. 한 분포에 꼭 확률변수가 한 개만 있으리란 법은 없습니다. 이를 확장해서 범주가 개 있는 경우를 상상하면 − 개의 확률변수를 갖는 확률분포가 됨을 짐작할 수 있습니다. 마지막 범주는 위 표처럼 나머지 범주에 종속되기 때문입니다. 범주가 개인 다항분포의 확률함수를 보겠습니다. ( 1 X, , k 1 ) M l i ( , 1 p, , k 1 ) ( 1 x, 2 x, X − = k 1 ) n x! 2 ⋯ k 1 x x = ( − 1 x − − k 1 ) , p = ( − 1 p − − k 식은 조금 복잡하지만 어렵게 생각하실 필요 없이 다음과 같은 논리를 생각하시면 됩니다. 첫 범주 확률 첫 범주 개수 다음 범주 확률 다음 범주 개수 마지막 범주 확률 마지막 범주 개수 ( 범 확 ) 범 갯 × ( 음 주 률 ) 음 주 수 ⋯ × ( 지 범 확 ) 지 범 갯 그리고 그 범주의 조합을 곱해주어서 해당 확률을 구하는 것이죠. 이 역시 데이터의 상황이 분포를 결정합니다. 다음의 예시를 통해 다항분포 문제를 다루어보도록 하겠습니다. 예시 눈이 3까지 있는 주사위를 10회 던졌을 때, 위 경우의 결과가 나오게 되는 확률을 계산하도록 하겠습니다. # p.m.f 계산 n_F = factorial(10) x_F = factorial(5) * factorial(3) * factorial(2) Prob = (n_F / x_F) * (1/3)^5 * (1/3)^3 * (1/3)^2 Prob [1] 0.04267642 # 명령어 활용 dmultinom(c(5,3,2),prob = c(1/3,1/3,1/3)) [1] 0.04267642 [ 1 5 x = , 3 2 ] 0.04 A5. 포아송분포(Poisson Distribution) 5. 포아송분포(Poisson Distribution) 포아송분포 : 일정 단위에서 평균 성공 수가 일 때 성공 횟수를 확률변수로 하는 분포 포아송 분포는 이 충분히 크고 성공 확률 가 매우 작을 때, 이항분포에 대한 근사로 활용이 됩니다. 예를 들어 어떤 공장에서 10시간(일정 단위)마다 평균적으로 2개의 불량품(평균 성공 수 )이 발생된다면 불량품이 하나도 발생하지 않을 확률부터 수십, 수백 개가 발생할 확률까지 성공 횟수에 따른 확률을 다루는 분포입니다. RP = rpois(n = 100 ,lambda = 2) ggplot(NULL) + geom_bar(aes(x = as.factor(RP),fill = as.factor(RP))) + theme_bw() + xlab("성공 횟수") + ylab("빈도") + theme(legend.position = 'none') 포아송분포는우리 실생활에 정말 많이 적용될 수 있는 분포입니다. 빈도로 조사된 데이터는 전부 포아송분포를 적용하여 분석할 수 있기 때문이죠. 또한 포아송분포는 ’nn 번 중 성공 횟수’의 분포인 이항분포와 매우 밀접한 관련이 있습니다. 이항분포의 평균은 npnp이고 이는 곧 ’평균 성공 수’의 관점으로 바라볼 수 있기 때문입니다. 포아송분포의 확률을 계산하는 확률함수는 다음과 같습니다. 또한 위 그래프에서 성공 횟수가 증가할수록 빈도 수가 급격히 줄어드는 것을 확인할 수가 있습니다. 이면 ∼ o s o ( ) 이, ( = ) e λ y! y 0 1 2 ⋯ ( ) λ ( ) λ 포아송분포는 특이하게도 평균과 분산이 같습니다. 그래서 빈도 데이터에 적용하기가 적절하죠. 평균 빈도가 높다는 것은 그만큼 바운더리가 커진다는 것이고 바운더리가 커진다는 것은 분산이 크다고 해석할 수 있습니다. 예시 A 도로의 1시간당 통과 차량 수가 = 20 인 포아송 분포를 따를 경우, 15대 이하의 차량이 통과할 확률을 계산하도록 하겠습니다. ppois(q = 15, lambda = 20, lower.tail = TRUE) [ ≤ 15 ] 0.15 A6. 연속형 확률분포 6. 연속형 확률분포 연속형 확률분포는 이산형과는 다르게 상황이 분포를 결정짓지 못합니다. 데이터들의 형태를 보고 추측하는 정도가 전부입니다. 통계에서는 그것을 분포 가정이라고 표현하며 실질적으로 저희가 분석하는 대부분의 것들은 이 분포 가정을 통해 이루어집니다. 연속형 확률변수는 이산형 확률변수와는 다르게, 구간으로 정의역이 정의됩니다. [ < < ] ∫ b ( ) x 또한 누적된 확률 분포를 누적 확률 밀도 함수(cumulative probability density function, d)라고 합니다. d는 d를 적분한 것이라고 생각하면 됩니다. R 코드를 통해 알아보도록 하겠습니다. [ ] ∫ ∞ f ( ) x R = rnorm(n = 100000, mean = 0, sd = 1) ggplot(NULL) + geom_histogram(aes(x = R, y= .. density..),binwidth = 0.2, fill = "white",col = 'black') + geom_density(aes(x = R), col = 'red', size = 1) + scale_y_continuous(expand = c(0,0),limits = c(0,0.5)) + scale_x_continuous(limits = c(-3,3)) + xlab("") + theme_bw() 다음과 같은 분포가 있다고 가정하였을 때, 위 분포에 대한 누적 확률분포는 다음과 같이 구할 수 있습니다. CR = ecdf(R) # CDF 계산 x = seq(from = -3, to = 3, by = 0.2) CP = CR(x) ggplot(NULL) + geom_line(aes(x = x, y = CP)) + geom_area(aes(x = x, y = CP), fill = 'royalblue', alpha = 0.4) + theme_bw() 위 그래프를 확인하시면, x 값이 증가함에 따라 그에 따른 누적 확률도 증가하는 것을 알 수 있습니다. 즉, [ < ] 1 인 것을 확인할 수가 있습니다. A7. 정규분포(Normal Distribution) 7. 정규분포(Normal Distribution) 정규분포는 주어진 데이터의 형태가 산봉우리일 때 가정되는 분포입니다. 흔히 ' 종 모양'에 비유하기도 합니다. 종 모양이라 함은 중심에 많은 데이터들이 모여있고 중심에서 멀어질수록 적은 데이터를 포함합니다. 또한 중심을 기준으로 좌우가 대칭적인 형태를 가지고 있습니다. 이는 곧 데이터의 중심과 산술적인 평균이 동일함을 의미합니다. 과거의 학자들은 많은 분야의 연속형 데이터들이 이런 형태를 띤다는 것을 발견하였고 그에 착안하여 정규분포를 고안하였습니다. 위에서 언급했던 것처럼 연속형 자료는 수집 상황이 분포를 결정하는 것이 아니고 데이터의 형태를 보고 그에 알맞은 분포를 선택한다는 것을 생각하면 지극히 상식적인 관점에서 만들어진 분포라고 생각할 수 있습니다. 그렇다면 이 산봉우리 분포는 어떤 식으로 표현될 수 있을까요? 두 가지를 이용합니다. 산봉우리 정상을 나타내는 '데이터의 중심' : 평균 산의 경사를 나타내는 '데이터의 퍼짐 정도' : 분산 평균에 따라 산은 좌우로 이동이 가능하며 분산에 따라 산의 경사가 완만한지 가파른지를 가늠할 수 있습니다. 만약 완만하다고 하면 데이터는 비교적 중심에 덜 모여 있을 것입니다. 이 경우 분산은 높다고 할 수 있습니다. 반대로 경사가 가파르다면 데이터들은 중심에서 밀도가 높고 이 경우 분산은 낮습니다. 이해를 돕기 위해 간단한 그림 하나를 보겠습니다. library(reshape) library(dplyr) k1 = c() p1 = c() for(k in seq(-15,15, by = 0.01)){ p = dnorm(x = k, mean = 0, sd = 3) k1 = c(k1,k) p1 = c(p1,p) } k2 = c() p2 = c() for(k in seq(-15,15, by = 0.01)){ p = dnorm(x = k, mean = 0, sd = 5) k2 = c(k2,k) p2 = c(p2,p) } DF = data.frame( k = k1, p1 = p1, p2 = p2 ) DF %>% melt(id.vars = c("k")) %>% ggplot() + geom_line(aes(x = k, y = value, col = as.factor(variable))) + geom_vline(xintercept = 0, linetype = 'dashed') + theme_bw() + theme(legend.position = 'none') + xlab("") + ylab("") + scale_y_continuous(expand = c(0,0)) 위 그림을 보면 두 가지의 정규분포가 있습니다. 데이터의 중심이자 평균은 동일하고 분산은 파란색이 붉은색보다 높습니다. 그래서 산봉우리 형태의 경사가 파란색이 더 완만한 것을 볼 수 있습니다. 정규분포의 형태를 결정해 주는 평균과 분산은 각각 와 2 로 표현합니다. 이면 ∼ ( , 2 ) 이, ( ) 1 π σ − 2 ( − σ ) , ∞ y ∞ [ ] μ [ ] σ 정규분포에서는 분산 2 의 양의 제곱근인 를 표준편차라고 부릅니다. 이 역시 데이터가 얼마나 퍼져있는지에 대한 척도로 볼 수 있습니다. 분산이 있는데도 불구하고 굳이 표준편차가 쓰이는 이유는 단위(스케일)의 문제입니다. 분산이라는 것은 실제 자료의 제곱을 이용해서 만들어집니다. 그렇기에 분산은 실제 자료에서 제곱된 단위(스케일)을 가지고 있고 양의 제곱근을 통해 구해진 는 실제 데이터들과 같은 단위를 가지고 있습니다. 정규분포의 중요한 특징 중 하나는 정규분포를 따라는 확률변수의 선형 조합 역시 정규분포를 따른다는 사실입니다. 예를 들어 평균이 10인 정규 확률변수가 가정된 데이터에 모두 -10씩 해주면 그들 역시 정규분포를 따르고 평균은 0이 될 것입니다. 같은 식으로 분산이 100인 정규 확률변수가 가정된 데이터에 모두 10씩 나누어 주면 그들 역시 정규분포를 따르고 분산은 1이 됩니다. 이는 곧 중심과 단위(scale)를 자유자재로 바꾸어 줄 수 있는 유연성을 가졌다는 의미입니다. 이 성질을 이용해 정규분포 데이터의 단위를 맞추어 줄 수 있습니다. 각 데이터에서 평균을 빼고 표준편차를 나누어 주면 어떤 정규 확률 변수든 평균이 0, 분산이 1인 동일한 단위를 갖게 됩니다. 이를 정규화한다고 표현하며 정규화된 분포를 표준정규분포(standard normal distribution)라고 합니다. 일 때 ∼ ( , 2 ) 때 ( − σ ) N ( , ) 정규화의 실질적 의미는 각 데이터들의 단위를 제거하여 서로 다른 집단끼리도 비교할 수 있는 것입니다. 대부분의 비교 검정은 다 이런 콘셉트를 근간에 두고 진행됩니다. 정규분포가 중요한 이유는 비단 많은 연속형 데이터가 정규분포를 따르기 때문만은 아닙니다. 표본들을 뽑아서 표본들의 평균을 구해보면 그것들이 따르는 분포가 정규분포이기 때문에 더욱 중요합니다. 이를 표본분포(통계량의 확률분포)라고 합니다. 예시 ∼ ( 20 5 ) 인 확률변수에 대해 표준화를 진행해 보도록 하겠습니다. x1 = rnorm(n = 1000, mean = 20, sd = 5) x2 = scale(x1) DF = data.frame( x1 = x1, x2 = x2 ) DF %>% melt() %>% mutate(variable = ifelse(variable == "x1", "비표준화","표준화")) %>% ggplot() + geom_density(aes(x = value, fill = variable), alpha = 0.4) + theme_bw() + theme(legend.position = c(0.8,0.6)) + xlab("") + ylab("") + labs(fill = "") 다음으로는 수리영역 모의고사 문제를 R로 한번 풀어보도록 하겠습니다. 문제) 어느 실험실의 연구원이 어떤 식물로부터 하루 동안 추출하는 호르몬의 양은 평균이 30.2 g , 표준편차가 0.6 g 인 정규분포를 따른다고 한다. 어느 날 이 연구원이 하루 동안 추출한 호르몬의 양이 29.6 g 이상이고 31.4 g 이하일 확률을 오른쪽 표준정규분포 표를 이용하여 구한 것은?(2016년 9월 모의고사 가형 10번) 일 때 ∼ ( 30.2 0.6 ) 일, P [ 29.6 Y 31.4 ] ? 1 29.6 30.2 0.6 Z = 31.4 30.2 0.6 Z1 = (29.6-30.2) / 0.6 Z2 = (31.4-30.2) / 0.6 print(paste("Z1 :",round(Z1),",","Z2 :", Z2)) [ 1 Z 2 ] P [ ≤ ] P [ ≤ 1 ] k1 = c() p1 = c() for(k in seq(-5,5, by = 0.01)){ p = dnorm(x = k, mean = 0, sd = 1) k1 = c(k1,k) p1 = c(p1,p) } ggplot(NULL) + geom_line(aes(x = k1, y = p1)) + geom_area(aes(x = ifelse(k1 > -1 & k1 < 2, k1, 0), y = p1),fill = 'royalblue', alpha = 0.4) + theme_bw() + scale_x_continuous(breaks = seq(-5,5, by = 1)) + scale_y_continuous(expand = c(0,0),limits = c(0,0.45)) + xlab("") + ylab("") # pnorm => 누적 확률 구하기 Answer = pnorm(q = 2, mean = 0, sd = 1, lower.tail = TRUE) - pnorm(q = -1, mean = 0, sd = 1, lower.tail = TRUE) print(paste("Answer : ", round(Answer, 5))) [1] "Answer : 0.81859" 다음 분포를 배우기 전에 이 모수와 통계량, 그리고 평균의 표본분포에 대해 다루도록 하겠습니다. A8. 모수(parameter)와 통계량(statistic) 8. 모수(parameter)와 통계량(statistic) 모수 : 통계적 추론에서 분석자의 최종 목표이자 모집단(population)의 특성 모집단 : 분석 대상이 되는 집단의 전체 통계량 : 해당 모집단에서 추출한 표본(sample)을 이용해 만든 것으로 표본들의 함수 표본 : 모집단으로부터 무작위 추출이 되었으며, 모집단을 대표하는 분석 대상 검정 : 주장하고자 하는 가설이 맞는지 틀린 지에 대한 의사결정 과정 추정 : 표본(통계량)을 이용하여 모집단(모수)를 추정하는 과정 점추정량 : 하나의 값(점)으로 모수를 추정한 값 구간추정량 : 신뢰구간을 통해 모수를 포함하고 있을 범위를 추정한 값들의 범위 때로는 통계적 검정을 위해 특수한 통계량을 사용하기도 하고 모수를 추정하기 위해 통계량을 구해보기도 합니다. 전자의 경우는 검정통계량(test statistic)이라 부르고 후자의 경우는 특별히 추정량(estimator)라고 부릅니다. 간단한 예를 하나 들어 보겠습니다. 우리가 원하는 정보는 대한민국 남성의 평균 키입니다. 우리는 이것을 알아보기 위해서 무작위로 100명의 남성을 뽑아서 그들의 키를 평균 내 보았습니다. 이 경우 모집단은 대한민국 남성이며 표본은 뽑은 100명의 남자입니다. 또한 우리의 최종 목표이자 모집단의 특성인 모수는 대한민국 남성의 평균 키라고 할 수 있겠고 표본들을 통해 구한 표본들의 평균 키는 통계량이자 모수를 추정하는 추정량입니다. 또한 많은 분들이 착각하는 부분이 있는데, 통계량은 꼭 표본평균, 표본분산과 같이 모수를 추정하는 것들만이 아닙니다. 표본들의 함수는 전부 통계량입니다. 다만 다음과 같은 표본평균과 표본분산이 매우 자주 사용되는 통계량일뿐입니다. ― 1 ∑ = n i 2 1 − ∑ = n ( i x) 굳이 이런 함수가 아니더라도 표본들을 이용해서 만든 모든 값들은 통계량이라고 할 수 있습니다. 예를 들어 표본들 중 가장 큰 수, 표본 중 홀수 번째 표본만 더한 값 등도 사용할 일은 별로 없을 수 있지만 하나의 통계량입니다. 자유도 대표적인 점 추정량인 표본평균( ― )과 표본분산( 2 )은 다음과 같이 구해집니다. ― 1 ∑ = n i 2 1 − ∑ = n ( i X) 분명 두 점 추정량 모두 개의 전체 자료를 반영하여 구하는데, 표본평균은 으로 나누어 주는 것에 반에 표본분산은 −로 나누어줍니다. 이것은 표본분산을 구하는 과정에서 표본평균으로 사용하였기 때문입니다. 이는 자유도와 관련된 것으로, 간단한 예시와 함께 알아보도록 합시다. 자유도(degree of freedom)는 자유롭게 값을 선택할 수 있는 데이터의 개수로, 통계량의 관점에서 봤을 때, 온전히 해당 통계량의 정보를 생성하는 데에 사용되는 자료 수라고 생각할 수 있습니다. 이 아이디어를 떠올릴 만한 간단한 예를 하나 들어보겠습니다. 4명의 아이들에게 아이스크림을 사주려고 하는 상황을 떠올려 봅시다. 마켓에서 아이스크림은 종류가 다른 4개의 아이스크림밖에 없습니다. 첫 번째로 골라가는 아이는 4개 중에 먹고 싶은 것을 고를 수가 있습니다. 두 번째로 골라가는 아이는 3개 중에 골라가고, 세 번째 아이는 2개 중에 골라갑니다. 마지막 아이는 남는 것을 먹어야 됩니다. 여기서 아이스크림을 자유롭게 선택한 아이는 총 3명, 자유도는 3이 됩니다. 이 상황을 표본분산에 적용해 보겠습니다. 우선 ― 에 대해 생각해 봅시다. 점 추정량인 ― 은 확률변수이지만, 실제 표본분산은 구하는 데 사용된 값은 조사된 표본에서 얻어진 값입니다. 즉, 값이 고정되어 있습니다. 순차적으로 생각하면, 1 은 값을 자유롭게 선택할 수 있습니다. 2 X 도 마찬가지입니다. 그렇게 쭉 진행되어서 n 1 까지, 확률변수 i 는 자유롭게 값을 선택할 수 있습니다. 하지만 마지막에 해당되는 n 은 자유롭게 값을 선택할 수가 없습니다. 그 이유는 고정되어 있는 값, 표본을 통해 구해진 평균( ― )을 맞추어 주는 값을 가져야 하기 때문입니다. 이와 같은 이유로 표본평균을 사용하게 될 시, 자유도는 n이 아닌 n-1로 계산이 됩니다. 또한 이 − 은 온전히 표본분산에 대한 정보를 생성하는 데 사용된 자료의 개수입니다. 1개의 자료는 위와 같은 논리로 ― 라는 표본평균을 맞춰주어, 2 을 성립하게 하는 데 사용했으나 2 이 가지고 있는 퍼짐의 정도를 나타내는 정보를 평가하는 데는 아무 기여를 하지 못했기 때문입니다. B1. t 분포(student's t-distribution) 분포를 쉽게 이해하려면, 이 분포는 순전히 평균 검정을 하기 위해 고안되었다는 점을 알고 있어야 합니다. 만약 모집단이 정규분포를 따른다고 하면, 표본평균은 ( , 2 ) 을 따른다는 것을 기억하실 겁니다. 그래서 과거에는 이를 이용하여 평균 검정을 해왔는데, 일반적으로 우리는 모분산인 2 을 알 길이 없습니다. 만약 이 매우 크다면 표본평균은 더욱 정확히 정규분포를 따를 것이고, 표본평균의 분산 역시 0으로 점차 수렴하게 될 것입니다. 이 경우, 사실상 2 의 영향이 미미하게 되어 무시할 수 있지만, 표본 수가 작을 때는 문제가 될 수 있습니다. 모분산 2 을 정확히 알 수 없을 뿐 아니라, 그 값에 따라 정규분포의 모양이 크게 좌지우지되어, 정규분포를 이용한 검정이 그 신뢰성을 잃게 되기 때문입니다. 이 경우의 검정을 위해, 정규분포와 형태는 비슷하지만 모분산 항을 포함하고 있지 않고, 대신 표분분산을 이용한 분포를 고안해 내는데, 그것이 분포입니다. 분포는 정규분포와 같이 중심을 기준으로 좌우 대칭이고 종 모양의 형태를 갖고 중심은 0으로 고정되어 있습니다. 즉, 위에서 다룬 표준정규분포와 중심이 같고 자유도(degree of freedom, df)에 따라 종의 형태가 조금씩 변화합니다. df는 표본 수와 관련이 있는 개념으로, 표본이 많아지면 표준정규분포와 거의 동일한 형태를 보입니다. 이면 ∼ ( ) 면 f ( ) Γ ( + 2 ) ( 2 ) π ⋅ ( y + ) + 2 − < < E [ ] 0 [ ] n − t 분포의 또 다른 특징은 표본 수가 적으면 적을수록 표준정규분포에 비해 양쪽 꼬리가 더 두껍다는 것입니다. 이는 데이터들이 그만큼 중심에 덜 모여있다는 것입니다. 정규분포와 분포는 검정의 관점에서 바라볼 필요도 있습니다. 정규분포를 이용한 검정의 경우, 중심에서 비교적 조금만 벗어나도 다르다는 결과를 보이지만 분포는 정규분포에 비해 상대적으로 더 벗어나도 같다는 결과를 줍니다. 이는 표본 수가 적은 데서 나오는 우연에 의한 극단적인 값에 대해서도 어느 정도 유연한 검정 결과를 준다고 할 수 있습니다. 물론 이 역시 표본이 적을 때의 경우이고 표본이 많아진다면 표준정규분포와 거의 동일한 결과를 보입니다. 극단적으로 표본이 무한에 가까워진다면 분포는 표준정규분포와 동일한 확률 구조를 갖게 될 것입니다. 아래 그림은 표준정규분포와 분포의 차이를 보여주는 그림으로 분포의 경우 자유도가 3인 경우입니다. 각 그래프의 색칠한 부분은 좌우 각각 데이터의 2.5%씩, 합쳐서 5%의 영역입니다. 위 그림에서 확인할 수 있듯, 표준정규분포보다는 분포가 훨씬 더 중심에서 많이 퍼져있음을 볼 수 있습니다. 만약 이대로 검정을 하게 된다면 표준정규분포는 중심과 2 정도만 차이나도 다르다는 결과를 주겠지만, t 분포는 중심과 3이 차이 난다고 하여도 같다는 결과를 줄 것입니다. 이와 같은 결과를 '보수적이다' 혹은 '보수적인 검정이다'라고 표현하는데 웬만큼 확신이 없으면 다르다는 결과를 주지 않기 때문에 그렇게 불립니다. 즉, 평균에 대한 검정에서 표준정규분포를 이용한 검정보다 분포를 이용한 검정이 더 보수적인 접근 방법이라고 할 수 있습니다. 자세한 것은 검정 파트에서 데이터와 함께 다시 다루겠지만 세 가지 정도는 기억해두고 가도록 합시다. 정규분포와 다르게 분포는 모분산 2 를 포함하고 있지 않다. 이는 표본 수가 적을 때 신뢰성을 더해준다. 표본 수가 적을 때, 분포는 표준정규분포보다 양쪽 꼬리가 더 두텁다. 이는 보다 보수적인 검정을 하게 해준다. 표본 수가 많아지면 분포와 표준정규분포에 근사한다. B2. 카이제곱분포와 F 분포 (Chi-square distribution and F-distribution) 11. 2 분포와 분포 (Chi-square distribution and F-distribution) 통계에서는 변동(분산)은 비교, 관계 등 모든 분석에서 사용되는 개념입니다. 변동은 단순히 해당 변수의 퍼짐 정도를 나타내는 것뿐 아니라 비교의 신뢰성을 표현하기도 합니다. 예를 들어, 두 집단의 평균이 큰 차이가 없어도 그 평균의 변동이 크다면 신뢰하기 힘듭니다. 또한 변동은 볼륨을 뜻하기도 합니다. A라는 변동과 B라는 변동이 있을 때, 비교를 통하여 더 큰 볼륨(파워, 확장성)을 가진 변동을 알 수 있습니다. 우리는 이러한 변동을 측정하는 도구로 제곱합 구조 ( a) 사용하게 됩니다. 그 이유는 변동을 측정하는 방법에 있습니다. 변동은 어떤 값을 기준으로 각 관찰 값들이 그 기준값과 얼마큼 떨어져 있는지 평가하는 방식으로 측정하게 되는데, 대부분의 경우 평균을 사용하게 됩니다. 그렇지만 단순히 평균과 관찰 값들의 거리를 이용하면 그 합이 0이 되어 의미가 없어지기 때문이죠. 이 구조적인 문제를 해결하고자 기준값과의 거리의 제곱을 이용하게 됩니다. 그렇기에 변동은 오로지 양적인 값으로만 표현됩니다. 또한 두 집단의 변동을 비교하는 방법으로 두 변동의 차이를 사용하면 곤란합니다. 비교하려는 집단의 단위가 다를 수 있을뿐더러 각 집단의 수를 반영해 주어야 하기 때문입니다. 예컨대, 한 집단은 cm 단위로 조사되었고 다른 집단은 m 단위로 표현되어 있는 길이를 생각해 봅시다. 같은 수준의 변동을 가졌다고 해도 막상 제곱합을 구해보면 cm로 조사된 집단의 더 크게 나올 것입니다. 단위가 다르기 때문이죠. 또한 10개 데이터에서와 100개 데이터에서의 분산을 똑같이 보면 곤란합니다. 이는 '제곱의 합' 꼴로 표현되므로 자료 수가 많으면 많을수록 더욱 커질 수밖에 없는 구조이기 때문이죠. 이러한 특성들 때문에, 변동을 이용하여 검정, 추정을 하고 싶으면 위와 같은 상황들을 전부 고려한 확률 구조가 필요합니다. 변동의 '단위' 와 '자료 수'를 반영할 수 있도록 고안된 분포가 바로 2 분포이고 2 들의 비(ratio)가 따라는 분포가 분포입니다. 2 들의 비는 두 변동을 비교하기 위해 사용되는 것으로, 이 역시 자료 수와 관련된 자유도가 반영됩니다. Chi_2 = rchisq(n = 100, df = 2) Chi_3 = rchisq(n = 100, df = 3) Chi_10 = rchisq(n = 100, df = 10) Chi_30 = rchisq(n = 100, df = 30) DF_Chi = data.frame( `df=2` = Chi_2, `df=3` = Chi_3, `df=10` = Chi_10, `df=30` = Chi_30 ) DF_Chi %>% melt() %>% ggplot() + geom_density(aes(x = value, fill = variable),alpha = 0.4) + theme_bw() + xlab("") + ylab("") + labs(fill = "") + theme(legend.position = "bottom") + ggtitle("카이제곱 분포") F_11 = rf(n = 100, df1 = 1, df2 = 1) F_21 = rf(n = 100, df1 = 2, df2 = 1) F_52 = rf(n = 100, df1 = 5, df2 = 2) F_101= rf(n = 100, df1 = 10, df2 = 1) DF_F = data.frame( `df=1,1` = F_11, `df=2,1` = F_21, `df=5,5` = F_52, `df=10,1` = F_101 ) DF_F %>% melt() %>% ggplot() + geom_density(aes(x = value, fill = variable),alpha = 0.05) + theme_bw() + xlab("") + ylab("") + labs(fill = "") + theme(legend.position = "bottom") + xlim(0,5) + ggtitle("F 분포") 2 변수를 만드는 아이디어는 정규분포를 따르는 변수에서 시작합니다. 우선 단위를 일반화하기 위해 표준화를 한 후 제곱을 하면 자유도 1인 2 변수가 됩니다. 또한 2 변수는 가법성이라고 불리는 성질이 있어, 독립적인 2 변수끼리 더해도 2 분포를 따르게 됩니다. 끼리는 서로 독립 ∼ ( , ) ⇒ 2 χ ( f 1 ) ⇒ i 1 Z 2 χ ( f n ) 이것을 조금 풀어서 생각해 봅시다. iid는 독립적으로 같은 분포를 따른다는 뜻입니다. i i d ( , 2 ) ⇒ ( i μ) Z ∼ i d ( , ) ⇒ ( 위와 같이 정규분포의 제곱합은 2 분포를 따릅니다. 또한 분포는 독립적인 2 변수의 비가 따르는 분포라고 하였습니다. 과는 독립 1 χ ( 1 ) Q ∼ 2 ( 2 ) ⇒ 1 n Q / 2 F ( 1 n) F 분포를 이용하면 자유도를 반영한 비교가 가능합니다. 이는 후에 분산분석 등에서 실습하도록 하겠습니다. B3. 통계적 추정과 검정 12. 통계적 추정과 검정 선거철이 다가올 경우, 여러분들은 수없이 많은 표본조사 결과를 여러 매체를 통해 접할 수가 있습니다. '어느 후보의 지지율이 OO%이며 신뢰수준 95%에서 조사가 되었다.' 이런 문구는 매우 익숙하실 것입니다. 통계 분석의 목적은 모집단을 대표할 수 있는 표본을 수집한 뒤, 모집단에 대해 추정을 진행하는 것입니다. 추정은 점 추정량과 구간추정량으로 나뉘게 됩니다. 일반적으로 추정량이라고 하면 점 추정량을 의미하며 이는 모수를 단 하나의 점으로 추측하는 통계량입니다. 예를 들어, 우리가 A 카페에 방문한 고객들의 연령대를 조사해야 하는데, 모든 고객의 나이 정보를 수집할 수가 없는 경우를 가정하겠습니다. 이 경우, 주어진 고객들의 나이 정보를 통해 전체 고객의 평균 나이를 소수점까지 예측하는 것을 '점 추정'이라고 합니다. 하지만, 한정된 정보만으로 전체 집단(모집단)의 정보를 완벽하게 맞추는 것은 불가능합니다. 그렇기에 우리는 모수(고객 연령의 평균)를 포함하는 신뢰구간을 구하게 됩니다. 이를 구간추정이라고 합니다. "통계학이 무엇을 하는 학문인가?"라는 질문이 주어지면 통계학은 '추정'을 하는 학문이라고 간단하게 설명을 할 수가 있습니다. 검정이란 여러분들이 많이 들어보셨을법한 '가설검정'을 의미합니다. 주어진 가설이 통계적으로 참인지 거짓인지 밝혀내기 위한 과정입니다. 앞으로 등장하는 모든 분석 모형은 추정과 가설검정을 진행하게 되어 있습니다. 다만, 예외의 경우도 있으나 그 예외의 경우들에 대해서 이 책에서는 다루지 않습니다. B4. 점 추정 13. 점 추정 추정량은 우리가 알고 싶어 하는 모수를 표본들을 이용하여 단 하나의 점으로 추측하는 통계량입니다. 그 과정을 점 추정(Point estimation)이라고 하며, 그렇게 얻어진 통계량을 점주 청량(Point estimator)라고 합니다. 점 추정량은 다양한 방식으로 구할 수 있습니다. 모평균을 추정하기 위한 표본평균, 모분산을 추정하기 위한 표본평균 등이 대표적인 점 추정량입니다. 물론 하나의 모수를 다른 방법을 통해 추정할 수도 있습니다. 각 끝의 일정 부분씩은 무시하고 나머지 표본들의 평균 계산(절삭 평균, Trimmed Mean) 역시 모평균을 추정하는 하나의 점 추정량이라고 할 수 있습니다. 하지만 역시 가장 많이 쓰는 척도는 표본평균입니다. 그 이유는 수리적인 확장성과 표본평균의 분포를 비교적 쉽게 알 수 있다는 점을 들 수 있습니다. 다만, 이런 점 추정에도 몇 가지의 장점과 단점이 있습니다. 점추정의 장점 점 추정량은 지극히 직관적이다. 통계를 모르는 누군가가 한국의 30대 여성의 평균 수입을 묻는다면 점 추정량으로 즉각적인 답을 줄 수 있을 것입니다. 점 추정량은 매우 직관적이며 합리적입니다. 점 추정량은 우리가 원하는 수치를 대체할 구체적인 값을 제시해 준다. 우리가 통계적인 모델링 혹은 함수를 작성하기 위해 30대 여성 수입의 평균치가 필요하나 모평균을 알 수 없을 때, 점 추정량으로 간단히 대체할 수 있습니다. 사실상 이는 대부분에 통계 이론을 전개하는데 가장 중요한 역할을 합니다. 간단한 예를 말씀드리자면 모분산을 추정하기 위해서는 평균이 필요하기 때문에 표본평균을 이용합니다. 여기서 분산은 각 개별 값들이 평균에서 얼마큼 멀리 떨어져 있는지에 대한 척도입니다. 그런데 우리는 '진짜 평균'을 알 수 없으니 표본들의 평균으로 대체하는 것입니다. 점 추정량은 수리적 연산이나 비교에 유연하다. 경우에 따라서는 다른 집단과의 결합이나 다른 집단으로부터의 분리가 필요할 수 있습니다. 이뿐 아니라 데이터가 수정되거나 추가되었을 때도 흔히 만나게 됩니다. 이런 경우에도 점 추정량은 유연히 대처할 수 있습니다. 점 추정량의 단점 점 추정량은 그저 하나의 점입니다. 점 추정량은 그 이름에서 알 수 있듯이 하나의 점으로 추정합니다. 이것은 장점이면서 단점이 될 수 있습니다. 직관적이지만 하나의 점만 믿고 다음 분석을 진행하기에는 너무 리스크가 많습니다. 점 추정량이 정확하게 모수를 추정하지 않고 동떨어진 값을 보여줄 수 있을뿐더러, 설령 정확하게 모수에 근접했다고 하여도 점추정량 하나만 보고서는 그 사실을 알 수 없습니다. 또한 같은 맥락으로, 점 추정량을 이용해 만든 다른 추정량 및 통계 모형들은 무용지물이 될 수 있습니다. 점 추정량은 변동을 가집니다. 통계량 역시 확률변수이며, 확률분포를 가지는 특성이 있습니다. 이는 점 추정량은 정해진 값이 아닌 변동(분산)을 갖는다는 것을 의미합니다. 예컨대, '남성 키'라는 모평균을 추정하기 위해 샘플링을 통해 표본평균을 구해보니 170이 나온 경우를 생각해 봅시다. 이 170은 단지 이번 조사에서 나온 값에 불과합니다. 다음 조사에서는 168이 나올 수도 있고 172가 나올 수도 있습니다. 이것이 첨추정량의 변동(분산)이고 이는 점 추정량의 분포와 표본 수 n에 의하여 결정됩니다. 중요한 것은 점추정량 하나만 보고는 이 점 추정량이 얼마나 높은 변동을 갖고 있는지 알 수 없다는 것입니다. 만약, 추정량의 변동이 너무 크다면 해당 추정량은 신뢰할 수 없고, 다시 조사하면 지금 값과 완전히 다른 값이 나올 것이기 때문이죠. 그렇기에 추정량은 꼭 추정량의 변동과 함께 보아야 합니다. 이것이 구간추정이자 가설검정의 원리입니다. 자세한 것은 다음 챕터에서 다루도록 하겠습니다. 너무 적은 표본에서의 점 추정량은 의미가 없다. 이는 2번과 근본적으로 같은 이유지만 표본 수라는 관점에서 바라보기 위해 일부러 분류하였습니다. 표본 수가 크지 않다면, 어떤 방법을 이용하든, 점추정은 이상치에 매우 취약합니다. 실제와는 전혀 상관없는 값이 나올 수도 있습니다. 물론 추정 방법에 따라 상대적으로 이상치의 영향을 덜 받는 추정량도 있기는 합니다만, 그 어떤 것도 완전히 자유로울 수는 없습니다. 또한 자주 사용되는 추정량의 대부분은 평균에 기인한 것들인데, 평균은 모든 자료가 동등하게 반영되므로 이상치에 취약합니다. 우리는 때때로 매우 적은 양의 표본만을 이용해야 할 때가 있습니다. 이 경우 점 추정량을 해석하기 어려운 경우가 많습니다. B5. 구간추정 14. 구간추정 구간추정(interval estimation)은 점 추정량의 변동을 이용해서 어느 정도의 구간을 추정하는 방법으로 그 결과물이 많이 들어보셨을 신뢰구간(confidence interval, C.I)입니다. 신뢰구간의 길이는 당연히 짧으면 짧을수록 좋고 길면 사실상 실무적으로 아무 의미가 없을 가능성이 큽니다. 구간추정의 방법은 추정량의 분포를 근사 혹은 가정하여 그 확률 구조를 이용하는 방법부터 여러 번의 재추출을 통해 경험적인 방법을 이용하는 것까지 다양하지만 여기서는 전자만 다루도록 하겠습니다. 구간추정의 기본적인 원리는 점 추정 값에 그 점 추정량의 확률 구조와 점 추정량의 변동 정도를 가미하는 것입니다. 구간추정의 기본 요소는 다음 3가지라고 할 수 있습니다. 점추정값 점추정을 한 값입니다. 예를 들어, 모평균의 신뢰구간을 구하고 싶다면 일반적으로 표본평균 이을 사용합니다. 점 추정량의 확률 구조 구간추정은 점추정의 확률분포를 반영합니다. 정확한 확률분포를 알고 있을 때 이를 통해 구한 신뢰구간을 정확한 신뢰구간(exact confidence interval)이라고 합니다. 그러나 사실 실제로 우리가 이렇게 정확하게 분석을 할 수 있는 상황은 많지 않습니다. 여러 가지 통계적인 방법을 통하여 추정량의 근사적인 분포를 이용하는 방법 이 경우, 신뢰구간은 점근적 신뢰구간(asymptotic confidence interval) 혹은 근사적 신뢰구간(approximate confidence interval)이라고 합니다. 사실 우리가 구하는 대부분의 신뢰구간은 이 점근적 신뢰구간입니다. 그렇다면 이 확률 구조를 어떤 식으로 이용할 수 있을까요? 어떤 확률 하에서, 나올 수 있는 값을 반영하는 방법입니다. 그래서 95% 신뢰구간, 90% 신뢰구간 등, 앞에 신뢰 정도를 확률로 나타내주는 것입니다. 다시 말해, 추정량의 분포를 통해 허용할 수준을 결정하게 되는 것이지요. 만약 신뢰성을 높인다면 신뢰구간은 길어질 것이고 약간 느슨한 신뢰성을 요구하면 신뢰구간은 짧아질 것입니다. 추정량의 표준편차(변동의 척도) 마지막으로 추정량의 표준편차를 반영합니다. 이 추정량의 표준편차를 흔히 표준오차(standard error)라고 표현하고 이는 단순히 모 표준편차처럼 각 점들이 평균과 얼마나 떨어져 있냐에 대한 것 말고도 해당 추정량의 변동 정도로, 신뢰성을 의미합니다. 변동이 적으면 신뢰할 만한 추정량이고 그렇지 않다면 신뢰하기 힘든 추정량이 되겠지요. 만약 표준오차가 크다면 신뢰구간은 길어질 것이고 크지 않다면 짧아질 것입니다. 분포라는 것에 변동이 포함되어 있기 때문에 2번과 3번은 사실 같은 내용입니만 표준오차에 대한 개념 설명을 위해 분리해 두었습니다. 위 내용은 처음 읽고는 직관적으로 이해하기 어려울 수 있으니 꼭 밑의 예와 그래프를 보고 다시 읽어보시기 바랍니다. 신뢰구간의 길이는 곧 우리가 이 구간을 의미 있게 사용할 수 없는가에 대한 척도인 동시에 가설검정을 했을 때의 기각할 범위를 알려줍니다. 구간추정의 원리는 가설검정의 원리와 정확히 일치합니다. 가설검정 역시 점 추정량과 그 확률분포, 변동 정도를 반영하여 실시하게 됩니다. 다만 가설검정은 한 점에 대한 검정 결과고 구간추정은 전체적인 신뢰할 만한 범위를 알려줍니다. 당연히 신뢰구간이 정보력이 훨씬 많습니다. 그럼 구체적인 예를 들어 알아보도록 하겠습니다. 한국 남성의 키는 정규모집단을 따른다고 했을 때 100명의 표본을 뽑아 평균 키를 구간추정해 보려고 합니다. 샘플링 결과 표본 평균은 170, 표본 표준편차는 10이 나왔고 이를 이용해 95% 신뢰구간을 구하려고 합니다. 이제 우리는 이 표본평균과 관련된 확률 구조가 필요합니다. 유명한 정리를 하나 사용해 보도록 합시다. 모집단이 정규분포를 따른다고 가정하면 도 정규분포를 따를 것입니다. 그렇다면 스튜던트 정리에 의해 다음이 성립합니다. = ( ― μ / ) t ( − ) 검정통계량의 분포를 도출하였기 때문에, t 분포를 이용해 다음과 같이 검정통계량과 관련된 확률을 계산할 수 있습니다. [ X − s n ≤ 0.975 ( − ) ] 0.95 만약 가 정확하게 분포를 따른다면 위 식은 자명한 사실일 것입니다. 풀어서 생각해 보면 어렵지 않습니다.는 자유도가 − 인 분포를 따르므로 좌우 끝에 2.5%씩 제외한 영역에 포함될 확률이 95%입니다. 분포는 0을 기준으로 좌우가 동일한 대칭분포이기 때문에, 좌우 2.5%의 영역을 나누는 기준 값은 부호만 다를 뿐, 절댓값은 동일합니다. 0.975 ( − ) 는 자유도가 − 인 분포에서 97.5%가 누적되었을 때의 값입니다. 그리고 0.025 ( − ) 과 부호만 다를 뿐, 절댓값은 똑같습니다. 이를 역 확률 값이라고 부릅니다. 우리는 100명의 표본을 뽑았으니 값은 자유도가 99인 분포를 따르게 되고, 양쪽 극단에 2.5%씩 남겨둔 역 확률 값을 그림으료 표현하면 다음과 같습니다. k1 = c() p1 = c() for(k in seq(-5,5, by = 0.01)){ p = dt(x = k, df = 99) k1 = c(k1,k) p1 = c(p1,p) } DF = data.frame( k1 = k1, p1 = p1 ) ggplot(DF) + geom_line(aes(x = k1, y = p1)) + geom_area(aes(x = ifelse(k1 > qt(p = 0.025, df = 99) & k1 < qt(p = 0.975, df = 99), k1, 0), y = p1), fill = 'red', alpha = 0.2) + geom_text(aes(x = 0, y = 0.2), label = "95%") + theme_bw() + scale_x_continuous(breaks = seq(-4,4, by = 1)) + scale_y_continuous(expand = c(0,0),limits = c(0,0.45)) + xlab("") + ylab("") B6. 가설검정 15. 가설검정 통계적 가설검정은 어떤 가설을 세우고 그 가설이 사실일 가능성과 사실이 아닐 가능성을 비교해서 의사결정을 하는 하나의 추론 과정입니다. 그리고 언제나 강조하지만, 가능성은 곧 확률로 표현되고 확률을 계산하기 위해서는 확률분포가 필요합니다. 결국 추정량의 확률분포를 가정하거나 근사 시키는 방법으로 구간추정과 동일한 아이디어, 동일한 결과를 보여줍니다. 가설검정을 이해하기 위해서는 몇 가지 용어에 대한 학습이 필요합니다. 정리해 보도록 하겠습니다. 귀무가설(Null Hypothesis, 0 ) 귀무가설은 분석자가 검정하기를 원하는 가설입니다. 또한 통계적 가설검정의 시작이자 끝입니다. 왜 그런지는 가설검정의 과정을 간단하게 요약하면 다음과 같습니다. 얻어진 표본을 이용해 귀무가설 하에서 가정되는 확률분포를 계산할 수 있는 형태를 만듭니다. 귀무가설 하에서 가정되는 확률분포를 검토해서 의사결정을 합니다. 귀무가설이 사실일 것 같으면 '귀무가설을 기각하지 못한다'라고 표현하며 그렇지 않으면 '귀무가설을 기각한다'라고 표현합니다. 위의 표현을 보면 알 수 있듯이 모든 가설검정은 귀무가설 중심으로 이루어집니다. 이는 통계적으로 매우 중요한 관점입니다. 검정의 모든 과정은 귀무가설이 사실이라는 가정하에 이루어지고 일반적으로 우리의 목표는 귀무가설이 사실이 아니라는 것을 증명하는 것입니다. 그렇기에 귀무가설을 기각하지 못한다고 하더라도 귀무가설이 사실이라고 해석하기보다는 '귀무가설이 틀렸다는 확실한 증거를 찾지 못했다' 정도로 생각하시는 게 정확한 시각입니다. 대립가설(Alternative hypothesis, 1 ) 대립가설은 귀무가설이 기각되었을 때 받아들여지는 가설입니다. 그렇기에 당연하게도 귀무가설과 수학적으로 배타적입니다(exclusive). 두 가설의 교집합은 없고 두 가설의 합집합은 전체집합입니다. 대립가설은 검정의 대상이 아닙니다. 다만 우리가 선택한 귀무가설에 반하는 결과가 나올 시 선택되는 것뿐이죠. 그래서 대부분 대립가설은 귀무가설은 사실이 아니다( 1 n t 0 )라고 표현하곤 합니다. 제1종 오류(type 1 error)와 제2종 오류(type 2 error) 그리고 유의수준(significance level) 1종 오류는 귀무가설이 사실일 때 귀무가설을 기각할 확률이고, 일반적으로 라고 표현합니다. 2종 오류는 귀무가설이 사실이 아닐 때, 귀무가설을 기각하지 않을 확률이고라고 표현합니다. 즉, 두 경우 모두 분석자가 잘못된 선택을 하게 될 확률(오류율)입니다. 오류(Error)는 어떤 오류를 막론하고 일단은 낮은 것이 중요합니다. 하지만 같은 표본 하에서 우리는 이 두 가지의 오류를 동시에 줄이지 못합니다. 흔히 Trade - off 관계라고 할 수 있습니다.를 줄이려고 하면 가 늘어나며, 반대로 를 줄이려고 하면 가 늘어나게 됩니다. 이 두 경우를 동시에 줄이는 방법은 오로지 표본 수 n을 늘려가는 방법밖에 없습니다. 그렇기에 고정된 표본 수 하에서 우리는 하나의 오류율을 고정시키고 분석을 진행합니다. 우리가 관심 있는 것은 언제나 귀무가설이므로 일반적으로 귀무가설이 사실일 때 귀무가설을 기각할 확률, 즉 1종 오류를 고정시킵니다. 여기서 고정시킨다는 것은 그 한계치를 정해둔다는 의미입니다. 가설검정을 할 때 = 0.05 혹은 = 0.1 과 같은 문구들을 보았을 것입니다. 여기서 알파가 바로 제1종 오류의 허용치입니다. 귀무가설이 사실일 때 귀무가설을 기각할 확률의 한계치를 5% 혹은 10%로 고정시키고 분석을 하는 것이죠. 이 최대 허용치를 유의수준이라고 부릅니다. 일반적으로 유의수준과 1종 오류는 같지만 이산형과 같이 확률을 연속적으로 컨트롤할 수 없는 경우에는 유의수준보다 1종 오류가 작을 수 있습니다. 하지만 우리는 대부분 연속형 검정을 다루기 때문에 대부분 같다고 생각하시면 될 것 같습니다. 검정통계량(test statistic) 검정통계량은 검정에 사용되는 통계량입니다. 이 역시 하나의 통계량이므로 표본들의 함수입니다. 표본들의 함수라는 말을 조금 가볍게 표현하면 표본들을 이리저리 조합해서 만든다는 말이죠. 그렇다면 여기서 하나의 궁금증이 생기게 됩니다. '이리저리 조합'하는 기준은 뭘까요? 즉, 검정통계량의 형태에 대한 궁금증입니다. 어렵게 생각하시지 마시고 위에서 학습한 구간추정과 같은 아이디어라고 생각하시면 편합니다. 귀무가설 하에서 우리가 원하는 확률분포를 따르도록 조합하는 것입니다. 그리고 그 조합의 결과물이 검정통계량인 것이죠. 이는 확률을 계산하기 위한 핵심 아이디어입니다. 검정통계량은 검정하고자 하는 가설의 분포에 따라 다양하게 조합이 됩니다. 평균 검정을 하는 경우 우리는 분포를 활용하여야 합니다. 이때 검정통계량은 t 분포의 스튜던트 정리르 활용하여 계산이 됩니다. 만약 분산을 검정하는 경우에는 검정통계량은 2 분포 혹은 분포를 활용하여 계산이 됩니다. 유의 확률(significance probability, p-value) 유의 확률은 귀무가설 하에서 계산된 검정통계량 값보다 더 극단적인 값이 나올 확률입니다. 흔히 − a u 혹은 값이라고 부르며 가설검정에서 의사 선택을 하게 해주는 중요한 지표라고 할 수 있습니다. 귀무가설 하에서 검정통계량은 분석자가 의도했던 확률분포를 따르기 때문에 우리가 계산한 검정통계량이 그 확률 구조에서 어느 영역에 포함되어 있는지 알 수 있습니다. 그리고 그 검정통계량보다 더 극단적인 영역에 있을 확률이 바로 유의 확률입니다. (만약 오른쪽 검정을 한다면 더 오른 쪽에 있을 확률이고 양측 검정을 한다면 양쪽 극단에 있을 확률일 겁니다.) 위에서 사용하였던 남성 키를 예로 들어보겠습니다. 정규모집단에서 100명의 표본을 뽑아서 모평균이 167.5가 맞는지 검정을 하려 합니다. (참고로 이는 일표본 검정이라 불리는 가설검정입니다.) 표본평균은 170, 표본표준편차는 10이 나왔습니다. 정리하면 다음과 같습니다. = 100 X = 170 s 10 0 μ 167.5 1 μ 167.5 = 0.05 귀무가설은 모평균이 167.5인 경우이고 대립가설은 167.5가 아닌 경우입니다. 즉, 대립가설은 167.5보다 큰 경우도 167.5보다 작은 경우도 포함합니다. (이를 양측 검정이라고 부릅니다.) 위에서 말씀드렸던 것처럼 가설검정을 하기 위해서는 확률 구조가 필요하기 때문에 우리가 아는 확률분포를 따르도록 표본들을 조합해서 검정통계량을 만들어야 합니다. 확률 구조를 알아보기 위해 구간추정의 경우와 마찬가지로 스튜던트 정리를 이용해서 검정통계량을 구하도록 하겠습니다. ( ― μ / ) t ( − ) 만약 귀무가설이 사실이라면, = 167.5 일 겁니다. 그렇다면 다음의 식이 성립하게 됩니다. ( ― 167.5 / ) t ( − ) 여기서 n = 100이므로, 위의 검정통계량은 자유도가 99인 분포를 따를 것입니다. ( 170 167.5 10 100 ) 2.5 계산된 검정통계량 값을 ( 99 ) 의 그래프 상에 이를 표현해 보겠습니다. xbar = 170 sd = 10 n = 100 mu = 167.5 T_Statistics = (xbar - mu) / (sd / sqrt(n)) 1 - pt(q = T_Statistics, df = n-1) [1] 0.007031298 ggplot(DF) + geom_line(aes(x = k1, y = p1)) + geom_area(aes(x = ifelse(k1 > qt(p = 0.025, df = 99) & k1 < qt(p = 0.975, df = 99), k1, 0), y = p1), fill = 'red', alpha = 0.2) + geom_text(aes(x = 0, y = 0.2), label = "95%") + geom_vline(xintercept = qt(p = 1-0.007, df = 99),linetype = 'dashed') + geom_area(aes(x = ifelse(k1 < qt(p = 1-0.007, df = 99),0, k1), y = p1),fill = 'royalblue') + theme_bw() + scale_x_continuous(breaks = seq(-4,4, by = 1)) + scale_y_continuous(expand = c(0,0),limits = c(0,0.45)) + xlab("") + ylab("") 보시는 바와 같이 ( 99 ) 의 분포에서 2.5보다 더 극단적인 값을 나올 확률은 오른쪽에서 0.007입니다. 우리는 양측검정을 하였으니 반대쪽도 계산해 주어야 합니다. 1 μ 167.5 이란 말은 곧 1 μ 167.5 r < 167 5 을 의미하기 때문입니다. 분포는 대칭분포이니 같은 확률을 보이며, 우리가 구한 값보다 더 극단적인 값이 나올 확률(유의 확률, − a u)는 0.014 즉, 1.4%가 됩니다. 조금 넓은 의미에서 해석해 보자면, 값은 (귀무가설이 사실일 때) 우리가 얻은 표본들이 일반적으로 나올 법한 표본들이냐 아니냐를 말해주는 값입니다. 즉, 모평균이 정말 167.5일 때, 우리가 구한 170은 그것보다 극단적인 값이 나올 확률이 1.4% 정도 밖에 안될 정도로 꽤나 이상한 값이라는 뜻입니다. 다시 말해 귀무가설이 사실이어도 우연히 나올 수 있는 값이긴 하지만 그 확률이 1.4% 정도 밖에 안된다는 의미로 해석할 수가 있습니다. 우리는 귀무가설이 사실일 때, 귀무가설을 기각할 확률의 허용한계를 0.05로 고정하였기 때문에 이 예에서의 값 0.014는 우리가 허용할 만한 수준이 아닙니다. 그렇다면 귀무가설이 사실이 아니라는 결론을 내리고 기각하게 되는 것입니다. 만약 값이 큰 값이 나왔다면 귀무가설 하에서 충분히 나올 만한 값이라고 판단할 수 있으므로 귀무가설을 기각하지 않게 될 것입니다. 가설검정은 결국 단순 비교를 통해 맞냐 아니냐를 결정하는 것이 아닌, 추정량의 분포를 반영하여 변동을 포함해도 맞을 수 있냐 아니냐를 결정하는 것입니다. 즉, 추정량과 그 추정량의 분포를 반영하는 구간추정과 아이디어의 방향이 똑같습니다. 실제로 이 둘은 같은 분포를 이용했다면 정확히 같은 결과를 알려줍니다. 구간추정에서 신뢰구간이 포함하고 있는 값은 (주어진 신뢰도 하에서) 분포를 반영하여도 충분히 나올 수 있는 값이라는 뜻입니다. 위에서 설명한 가설검정과 같은 의미죠. 그래서 신뢰구간에 포함된 값들은 가설검정을 하여도 전부 귀무가설을 기각할 수 없습니다. 반대로 신뢰구간이 포함하지 않는 값들은 가설검정에도 기각될 값들입니다. 이번 예제를 통해 간단히 확인할 수 있습니다. 같은 표본분포(자유도 99의 t 분포)를 활용한 구간추정의 경우 신뢰구간이 [168.016, 171,984]이었습니다. 우리가 이번에 검정한 값은 167.5였죠. 구간에 포함되어 있지 않고 그렇기에 당연히 = 167.5 라는 귀무가설은 기각되었습니다. 이는 다른 수를 넣어봐도 같은 결과를 보일 겁니다. 계산이 그리 복잡하니 않으니 몇 가지를 넣어서 확인해 보시기 바랍니다. 97.5%의 누적 역 확률 값은 1.984이고 2.5%의 누적 역 확률 값은 -1.984입니다.는 자유도가 99인 분포를 따르므로 가 -1.984와 1.984사이에 포함될 확률은 95%라는 것이 성립합니다. 이제 저 사실을 기초하여 식을 조금 바꿔 보겠습니다. 0.975 ( − ) 은 자유도 −의 분포에서 누적 확률 0.975의 역 확률 값입니다. 교재에 따라 역 확률 값의 표현을 뒤부터 누적하는 경우가 있으니 주의 바랍니다. [ X − s n ≤ 0.975 ( − ) ] 0.95 P [ t 0.975 ( − ) X − s n t 0.975 ( − ) ] 0.95 P [ ― t 0.975 ( − ) s ≤ ≤ ― t 0.975 ( − ) s ] 0.95 이런 식으로 정리하면 주어진 조건에서 모평균 가 저 구간에 포함될 확률이 95%라는 식이 나옵니다. 이것이 구간추정의 원리이자 95% 신뢰구간입니다. 위의 한국 남성 키를 그대로 대입해 보면 ― 는 170,는 10, 은 100이므로, 한국 남성 키의 95% 신뢰구간은 [ 168.016 171.984 ] 가 됩니다. 다시 한번 강조하지만 가장 중요한 것은 추정량은 확률 구조를 가지고 있는 확률변수라는 것이고 이는 구간추정에도 그대로 적용됩니다. 신뢰구간은 매 조사마다 달라집니다. 위에서 우리가 구한 [ 168.016 171 984 ] 는 절대적인 신뢰구간이 아닌 그냥 이번 조사에서 우리가 구한 하나의 신뢰구간에 불과합니다. 한 번 더 조사하면 분명히 변할 것입니다. 그렇기에 엄밀히 따지면 [모수가 해당 신뢰구간 안에 있을 확률이 95%다]라는 말은 정확한 말이 아닙니다. [해당 신뢰구간이 모수를 포함할 확률이 95%다]라는 말이 정확합니다. 모수는 변수가 아닌 이미 정해진 수이고 바뀌는 건 신뢰구간이기 때문이죠. 더 정확히 이야기하면 [100번 조사를 해서 100개의 신뢰구간을 얻었을 때 그중 평균적으로 95개의 신뢰구간은 모수를 포함하고 있다] 정도가 될 것입니다. 이러한 분석을 일표본 검정(One Sample Test)라고 합니다. Height = rnorm(n = 98, mean = 170, sd = 10) print(paste("평균 : ", round(mean(Height),2))) [1] "평균 : 169.51" print(paste("표준편차 : ", round(sd(Height),2))) [1] "표준편차 : 9.87" t.test(x = Height, mu = 167.5, alternative = "two.sided") One Sample t-test data: Height t = 2.0176, df = 97, p-value = 0.0464 alternative hypothesis: true mean is not equal to 167.5 95 percent confidence interval: 167.5328 171.4891 sample estimates: mean of x 169.5109 위 결과는 난수 발생을 통한 분석 결과이기 때문에 결과가 100% 일치하지는 않는다는 점을 유의해 주시길 바랍니다. ChB2. 기초통계 이론 2단계 이번 챕터에서는 본격적으로 통계적 선형모형에 대해 다룹니다. A1. 통계 모형 Preview 1. 통계 모형 Preview 본격적으로 모델링을 시작하기에 앞서 간단한 주의사항 및 분석 모형에 대한 소개를 하고 넘어가도록 하겠습니다. 흔히 사람들이 분석 과정에서 실수하는 경우는 다음과 같은 상황입니다. 힘들게 어려워 보였던 예측 모형 및 알고리즘을 공부하고 이를 사용하기 위하여 바로 모델에 적합시키려고 하는 경우입니다. 물론 복잡한 모형을 적용시키면 결과가 잘 나올 거 같고 멋도 있어 보일 수 있지만, 전혀 그렇지 않습니다. 데이터 분석은 요리와 비슷합니다. 어떤 요리를 할지 결정하고, 가져온 재료를 보지는 않죠. 데이터도 마찬가지입니다. 결국 분석 모형은 데이터에 맞는 분석 모형을 적용시켜야지, 무작정 어려운 분석 모형 적용시킨다고 해서 결과가 다 나오는 것이 아닙니다. 그러므로 항상 데이터에 대한 특성을 충분히 이해하고 있어야 하며, 이런 상황에는 어떤 분석 모형을 적용시켜야 하는지 바로 생각이 떠올라야 할 것입니다. 해당 부분의 이해를 위하여 간단하게 통계 모형들에 대하여 다루고 넘어가도록 하겠습니다. A2. 분석 모형을 선택하는 기준 2. 분석 모형을 선택하는 기준 분석하고자 하는 바를 명확히 규명해야 합니다. 이는 가설을 세우는 과정과 같습니다. 가설에 맞는 데이터들에 대한 변수 척도 구분해야 합니다. 변수의 척도에 따라 적용해야 되는 모형이 정해집니다. 모형은 우리가 정하는 것이 아닌, 데이터가 정해줍니다. 분석하고자 하는 주제가 ’차이’를 검정하고 싶은 것인지, ’관계’를 검정하고 싶은 것인지에 따라 갈립니다. 차이를 보는 검정은 흔히 집단 간에 평균 차이를 검정하고 싶은 경우입니다. 예를 들어 인사관리 데이터에서 이직 여부(0: 안 함, 1: 이직)에 따라 직무 만족도가 다른지 검정하는 경우가 있을 수 있습니다. 반대로 관계를 보고자 하는 검정은 변수 간의 함수적 관계를 보고자 하는 것과 같습니다. 예를 들어 마케팅 투자비용이 마케팅 효과에 미치는 영향을 검정하고 싶은 경우가 있을 수 있습니다. 다음으로는 Response Variable(종속 변수)가 연속형이냐, 이산형이냐에 따라 결정됩니다. 종속 변수가 연속형일 때 차이를 보고자 할 때 : T 검정(T-test), 분산분석(Anova) 관계를 보고자 할 때 : 회귀분석(Regression) 종속 변수가 이산형일 때 연관을 보고자 할 때 : 카이 제곱 독립성 검정(Chi square Independent Test) 관계를 보고자 할 때 : 로지스틱 회귀분석(Logisitc Regression) A3. 분석 모형별 가설 검정 3. 분석 모형별 가설 검정 통계 분석에서 차이가 없는(즉 의미가 없는) 사실은 알아내고 싶은 사실이 아닙니다. 차이가 있는(즉 의미가 있는, 유의하다) 사실에 관심이 있으며, 의미가 있는 사실을 대립가설에 배치합니다. A4. t 검정 4. 검정 일반적으로 검정이라 하면 독립 표본 검정을 의미합니다. 독립적인 두 집단에서 추출된 표본들의 평균이 차이가 있는지 확인하기 위해 실시되며 혹시 두 집단이 상황적으로 독립이 아닌 집단이라면 대응 표본 검정(paired t-test) 등을 포함한 다른 분석을 진행하게 됩니다. 원리는 위에서 가설검정 파트에서 했던 일표본 검정과 동일합니다. 두 개의 독립적인 정규모집단에서 추출된 표본을 통해 계산된 두 집단의 표본평균 차를 이용합니다. 두 표본평균 차의 분포를 확인 후 우리가 가지고 있는 표본에서 계산된 차이가 두 평균이 같다고 가정했을 때(귀무가설이 사실일 때) 충분히 나올 법한 차이인가를 검정하는 과정입니다. 독립 표본 t 검정의 특성 분석의 목적은 두 집단의 평균이 차이가 있는지 확인하는 것이다. 분석의 대상은 독립적인 두 정규모집단에서 추출된 표본들이다. 분석의 수단은 분포다. 분석의 원리는 추출된 표본으로 계산된 차이가 우연히 나올만한 차이인지 아닌지를 분포(두 표본평균 차의 분포)를 이용하여 확인하는 것이다. 하지만 여기서 하나의 문제가 생깁니다. 바로 분산에 대한 처리입니다. 가설검정 파트에서 했던 일표본 검정의 경우 집단이 하나밖에 없으니 상관없지만 집단이 두 개인 이 경우에서는 분산을 어떻게 처리해야 할까요? 독립 표본 검정에서는 두 집단의 분산이 같은 경우와 다른 경우를 나누어 생각합니다. 이를 흔히 등 분산 가정이라 합니다. 일반적으로 검정에서는 두 집단의 등 분산이 같은 경우, 즉, 등 분산 가성이 성립되었을 때는 정확하게(exact) 분포를 이용하고 그렇지 않을 경우에는 근사적인(approximate) 검정을 실시합니다. 그런 관계로, 검정 전에는 반드시 두 집단의 분산이 같은지에 대한 검정을 진행해야 합니다. 참고로 등 분산을 확인하는 방법은 F 분포를 이용한 Levene 등 분산 검정(두 집단의 분산은 동일하다 0 두 단 분 은 일 다 )을 비롯한 몇 가지의 검정이 있으나 여기서 자세히 설명하진 않겠습니다. 만약 두 집단의 등 분산 가정이 성립한다고 판단이 되면 집단에 상관없이 전체의 분산을 계산해서 사용합니다. 이를 합동 표본분산(pooled sample variance)이라고 합니다. 그 형태는 다음과 같습니다. 여기서 1 은 X 표본(집단 1)에서의 표본 수고 2 는 Y 표본(집단 2)에서의 표본 수입니다. 합동 표본분산의 형태를 살펴보면 두 집단의에서의 변동을 각각 계산하고 더한 후 전체 자유도로 나누어준 것을 확인할 수 있습니다. 자유도는 역시 기존 다른 추정량들과 마찬가지로 합동 표본분산을 추정하는데 온전히 사용된 데이터 수로 결정됩니다. 이와 같은 것을 pooling 한다고 표현하며 단일 집단에서의 표본평균과 비교해 보면 pooling이 어떤 구조로 이루어지는 것인지 어렵지 않게 이해하실 수 있을 것입니다. 단일 집단에서의 표본평균 ( 일 단 서 표 평 ) 2 1 − ∑ = n ( i X) 이제 이를 이용해 두 집단의 표본평균 차에 대한 분포를 도출해 봅시다. 두 독립적인 정규모집단에서 추출된 표본으로 계산된 표본평균들은 정규분포를 따르기 때문에 정규분포 파트에서 학습한 대로 그들의 선형결합 ( ― Y) 역시 정규분포를 따를 것입니다. 이것에 착안하여 일표본 검정에서와 같이 스튜던트 정리를 이용합니다. ( ― Y) ( 1 μ) p n + p n ∼ ( 1 n − ) 여기서 1 μ는 각 두 집단으 모평균이고 그 차이인 ( 1 μ) 이 우리의 최종 목적입니다. 만약 두 집단의 사이의 유의한 차이가 없다면 0이 될 것이고 그렇지 않다면 충분히 유의한 차이를 보일 것입니다. 이 역시 일표본 검정에서의 검정통계량과 비교해 보시면 같은 형태를 띠는 것을 알 수 있습니다. 단일 집단에서의 검정통계량 ( 일 단 서 검 통 량 ) ― μ / = ― μ 2 ∼ ( − ) 이제 이 검정통계량을 이용하여 우리가 원하는 검정을 실시할 수 있습니다. 위에서 말씀드린 대로 우리의 최종 목적은 두 집단의 평균이 같은지 다른지를 확인하는 것입니다. 이를 귀무가설과 대립가설로 표현하면 다음과 같습니다. 0 μ = 2 H : 1 μ 만약 귀무가설이 사실이라고 가정하면 위 검정통계량에서 ( 1 μ) 은 0이 되므로 검정통계량은 좀 더 간소화가 가능합니다. 이는 귀무가설 하에서의 검정통계량이니 0 라고 하겠습니다. 0 ( ― Y) p n + p n ∼ ( 1 n − ) 판단은 원리는 이 0 를 이용하여, 우리가 가지고 있는 표본들로 계산된 검정통계량이 과연 (주어진 분포하에서) 자연스럽게 나올만한 값인지, 아니면 우연이라고 보기에는 너무 극단에 가까운 값인지 확률로써 확인하는 것입니다. 그 방식은 일표본 검정과 정확히 일치합니다. 만약 계산된 검정통계량보다 극단적인 값이 나올 확률(유의 확률)이 사전에 우리가 정한 유의수준 보다 작다면 귀무가설을 기각하고 그렇지 않다면 기각하지 못하게 될 것입니다. 다음은 두 집단의 분산이 다를 경우입니다. 이때는 일반적인 등 분산 검정에서의 검정통계량과 형태는 같게 하되 두 집단의 분산을 따로 추정합니다. 여기서 1 과 2는 각각 집단 1과 집단 2의 표본분산입니다. ( ― Y) ( 1 μ) 1 n + 2 n ∼ ( e r e f r e o) 그런데 이 경우 분포의 자유도를 계산하기가 애매합니다. 그래서 대부분의 경우는 세터스웨이트 공식과 같은 자유도의 근사치를 얻는 방법을 이용하게 됩니다. R을 비롯한 통계 프로그램에서는 자동으로 자유도 근사치를 얻어 검정을 진행합니다. A5. t 검정(R Code) 5. 검정(R Code) 데이터는 앞단에서 다루었던 HR 데이터를 이용하겠습니다. 이직 여부에 따라 직원들의 직무만족도에 차이가 있는지 검정을 하고자 합니다. 이 경우, 이직 여부(left)는 0 : 이직 안 함, 1 : 이직이기 때문에 이직 여부는 2개의 수준을 가지고 있는 명목형 변수이고 직무만족도(satisfaction_level)는 0 ~ 1 사이에 있는 연속형 변수입니다. 즉, 연속형 변수를 두 수준을 지니고 있는 명목형 변수에 따라 차이가 있는지 검정하고 싶기에 T 검정을 진행하는 것이 적합한 상황입니다. T 검정을 R에서 진행하는 방법은 다음과 같습니다. 등 분산 검정 비교하고자 하는 두 잡단의 분산이 같은지 검정하기 위함입니다. 두 집단의 분산이 동일하다 두 집단의 분산이 다르다 0 두 단 분 이 일 다 H : 집의 산 다 다 여기서 두 집단은 left 변수의 수준인 0(이직 안 함)과 1(이직)을 의미합니다. # 라이브러리 불러오기 library(car) # 등 분산 검정 실행 HR = read.csv('F:/Drop box/DATA SET/HR_comma_sep.csv') HR$left = as.factor(HR$left) leveneTest(satisfaction_level ~ left , data = HR) Levene's Test for Homogeneity of Variance (center = median) Df F value Pr(>F) group 1 122.4 < 2.2e-16 *** 14997 --- Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 Levene's 등 분산 검정은 두 집단의 분산비를 비교하기 때문에 F 분포를 따르게 됩니다. R 실행 결괏값에 나오는 v l e 122.4 는 위 분포에서의 검정통계량입니다. 앞에 가설검정 단계에서 검정통계량을 기준으로 계산된 유의 확률을 통해 귀무가설 기각 여부를 판단할 수 있다고 했습니다. 유의 확률을 나타내는 r ( F ) < 2.2 − 16 으로 표시가 되어 있습니다. R에서 − 16 1 10 16 을 의미합니다. 그러니 유의 확률은 0에 매우 근접한 값을 가지는 것을 뜻하며 유의수준 = 0.05 보다 훨씬 작기에 두 집단의 분산이 동일하다.라는 귀무가설을 기각할 수 있습니다. 즉, 이직을 한 직원들과 이직을 하지 않은 직원들 간의 직무만족도의 분산은 동일하지 않다는 것을 알 수 있습니다. 검정 앞서 등 분산 검정의 결과가 어떻게 나왔는가에 따라서 t 검정의 옵션이 변합니다. 검정의 귀무가설과 대립가설은 다음과 같습니다. 두 집단의 평균이 같다 두 집단의 평균 이 다르다 0 두 단 평 이 다 H : 집의 균 다 다 # 등 분산이 동일할 경우 t.test(satisfaction_level ~ left , data = HR, var.equal = TRUE) Two Sample t-test data: satisfaction_level by left t = 51.613, df = 14997, p-value < 2.2e-16 alternative hypothesis: true difference in means is not equal to 0 95 percent confidence interval: 0.2181017 0.2353215 sample estimates: mean in group 0 mean in group 1 0.6668096 0.4400980 # 등 분산이 동일하지 않을 경우 t.test(satisfaction_level ~ left , data = HR, var.equal = FALSE) Welch Two Sample t-test data: satisfaction_level by left t = 46.636, df = 5167, p-value < 2.2e-16 alternative hypothesis: true difference in means is not equal to 0 95 percent confidence interval: 0.2171815 0.2362417 sample estimates: mean in group 0 mean in group 1 0.6668096 0.4400980 현재 데이터는 두 집단의 분산이 동일하지 않으므로 t.test에서 옵션을 var.equal = FALSE로 설정해 줍니다. 분석 결과 검정통계량 v l e 46.636 이며 유의 확률( − a u)은 2.2 − 16 으로 0과 매우 가깝습니다. 이로써 두 집단(이직 여부)의 평균이 같다는 귀무가설을 기각할 수 있으며, 이직 여부에 따라 직무만족도의 평균 차이가 존재한다는 것을 알 수 있습니다. R 결과표에 따르면 이직을 하지 않은 집단의 평균(mean in group 0)은 0.66이고 이직을 한 집단의 평균(mean in group 1)은 0.44로 이직을 하지 않은 집단의 직무만족도가 더 높다고 할 수 있습니다. A6. 분산분석 6. 분산분석 분산분석은 검정과 마찬가지로 차이를 보는 분석입니다. 검정과 다른 점은 분산분석은 두 집단은 물론이고 세 집단 이상에서도 집단 간 평균 차이를 볼 수 있는 점입니다. 두 집단에서 진행하면 검정과 같은 결과를 줍니다. ANOVA(Analysis of Variance)의 의미를 조금 풀어서 해석해 보자면 다음과 같습니다. 분산(변동)을 분석하여 평균을 비교한다. 정도로 해석할 수 있습니다. 보통 차이를 비교할 때, 3개 이상의 개체에 대한 동시 비교는 불가능합니다. 예를 들어, 사고 싶은 제품이 3개가 있는데, 그중 1개만 살 수 있는 상황이라면 본능적으로 3개 중에 2개를 먼저 비교하고, 그중 선택된 1개가 나머지 1개를 비교하여 구매할 제품을 선택하는 과정과 같습니다. 분산분석은 이러한 한계점을 극복하고자 직접적으로 평균을 비교하는 것이 아닌, 분산을 이용하여 평균을 비교하는 방법입니다. 그래서 명칭도 '분산을 분석한다'의 의미로 Analysis of Variance라고 부릅니다. 예를 들어 HR 데이터 셋에서 satisfaction_level(직무 만족도) 변수를 salary(연봉 수준, Low, Mid, High 3개의 수준을 가지고 있는 순서형 변수) 변수에 따라 평균 차이가 있는지 없는지 통계적으로 검정하고자 합니다. 그렇다면 연속형 변수를 3 집단 간의 평균 차이를 하고자 하는 것이니, 검정이 아닌 분산분석을 적용해야 합니다. 분산분석의 아이디어는 다음과 같습니다. 먼저 전체 집단의 평균( ― ⋅ ) , 그리고 각 집단의 평균( ― ⋅ )을 구합니다. 여기서는 각 집단을 의미합니다.(salary 변수의 low, mid, high) 임의의 데이터( i)를 기준으로 총 변동을 계산합니다. 총 변동 : ― ⋅ X j 계산된 총 변동을 집단 간(between) 변동과 집단 내(within) 변동으로 분리를 합니다. 집단 간(between) 변동 : ― ⋅ X i 집단 내(within) 변동 : ― ⋅ X j 총 변동을 집단 간 및 집단 내로 분리한다는 것은 총 변동 중에 집단 간(between) 변동이 집단 내(within) 변동에 비해 얼마나 많은 부분을 차지하고 있는가를 보고자 하는 것입니다. 모든 임의의 데이터( i)에 대해서 변동의 제곱합을 구해 줍니다. 제곱합을 구해주는 이유는 임의의 데이터( i) 위치에 따라서 총 변동의 값이 양수(+)가 계산될 수가 있고 혹은 음수(-)가 계산될 수가 있기 때문입니다. 부호 간 덧셈을 하면 변동의 합이 상쇄가 되기 때문에 제곱합을 함으로써 문제를 해결해 주고자 하는 겁니다. 계산된 제곱합을 평균 제곱합으로 보정을 해준 다음, F 통계량을 구해 유의 확률(p-value)을 계산합니다. 집단 간 변동이 집단 내 변동에 비해 유의한 크기를 가지고 있다면, 귀무가설을 기각할 수 있습니다. 이제부터, 분산분석의 원리와 관련된 몇 가지 키 아이디어를 말씀드리겠습니다. 전체 평균을 구하는 이유는 3집단 이상의 변동을 비교하기 위한 기준선을 구하는 것입니다. 분산분석의 핵심은 총 변동 중에서 집단 간(between) 변동이 집단 내(within) 변동에 비해 얼마나 큰지 비교하고자 하는 것입니다. 집단 간 변동에 집중하는 이유는 분산분석에서 분석하고자 하는 것이 전체 집단의 평균과 특정 집단의 평균의 차이 즉, 다른 집단 간의 평균 차이이기 때문입니다. 반대로 집단 내(within) 변동은 동일 집단 내 차이를 나타내기 때문에 집단 간 평균 차이를 비교하고자 하는 분산분석에서는 Error 취급을 합니다. 만약 집단 내 차이가 크면 총 변동 내에서 집단 간 차이가 차지하는 부분이 줄어들기 때문에, 총 변동이 고정된 상태에서 Error가 작다는 것은 곧 집단 간의 차이가 크다는 것으로 의미가 연결됩니다. 그럼 이제 위에서 언급한 세 가지 변동을 관찰된 데이터를 통해 추정해 보도록 하겠습니다. 여기서 변동을 표현할 때 사용되는 SS는 제곱합이란 의미로 Sum of Squares를 의미합니다. 총 변동 집단의 첨자 표본의 첨자 변 : S = i 1 ∑ = n ( i − ― ⋅ ) i 집의 자 = 본 첨 S T 는 보시는 바와 같이 어떤 그룹이든 신경 쓰지 않고 전부 편차의 제곱합을 시켜 더합니다. ― ⋅ 역시 그룹과 상관없이 모든 표본들의 전체 평균입니다. 만약 위의 예처럼 집단 변수(salary 변수)가 low, mid, high 세 그룹이라면 는 3이 되겠고 i 들은 low, mid, high 각 집단에서의 표본 수입니다. 각 집단에서의 표본 수는 달라도 상관은 없으나 되도록 비슷한 것이 분석의 신뢰를 높여줍니다. 집단 간 변동 단 ( e w e) 동 S G ∑ = k j 1 i ( ― ⋅ X ⋅ ) = i 1 n ( ― ⋅ 집단 간 제곱합은 처리제곱합이라고도 많이 불립니다. 여기서 i 은 그룹의 평균입니다. 예를 들어 ― ⋅ 은 salary 변수에서 mid에 속하는 표본만의 평균이라고 보시면 됩니다. 즉, 전체 평균과 그룹 평균의 차이에 대한 제곱합이죠. 이것이 그룹의 효과입니다. S 가 그룹과 상관없는 전체 변동이라면 이는 그룹들이 가지고 있는 변동인 것이죠. 집단 내 변동 단 ( i h n ) 동 S E ∑ = k j 1 i ( i − ― ⋅ ) 마지막으로 S는 그룹 내 변동을 표현하는 제곱합입니다. 형태를 보시면 개별 관찰 값과 그 관측 값이 속한 그룹의 그룹 평균의 차이를 이용해 제곱합을 계산하는 구조입니다. 앞에서 집단 내 변동은 보고자 하는 집단 간의 차이와는 반대되는 성향을 가지고 있는 Error라고 하였습니다. 만약 이 S 가 S에 비해 상대적으로 작다면 우리는 그룹이 가지고 있는 효과가 유의하다고 판단하 것입니다. i 1 ∑ = n ( i − ― ⋅ ) = i 1 n ( ― ⋅ X ⋅ ) + i 1 ∑ = n ( i − ― S = S + S 만약 기본적인 가정들이 성립한다면 수리적으로 이 두 제곱합( S, S)은 직교 분해(orthogonal decomposition) 되었다고 할 수 있습니다. 직교 분해는 교차항이 없이 각 변동을 표현하는 제곱합 항만으로 분해되는 것이며 그 의미는 두 제곱합이 통계적으로 독립이라는 것입니다. 그리고 이 변동의 추정치인 제곱합 역시 표본으로부터 만들어진 통계량이므로 확률분포를 갖습니다. 그럼 우리는 서로 독립적인 집단 간 제곱합과 집단 내 제곱합을 갖게 됩니다. 이 둘을 조합하여 상대적 비교가 가능한 F 분포를 따르는 새로운 통계량을 얻어낼 수 있습니다. (주어진 표본들을 이용해 이 통계량을 계산한 값을 흔히 F 값이라고 부릅니다) 분산분석에서의 가설검정 절차 의자 유도 의자 유도 의 자유도의 자유도 S / ( S의 유 ) S / ( S의 유 ) F ( S의 유, S의 유 ) S 와 S의 자유도 역시 예전에 했던 자유도의 논리와 크게 다르지 않습니다. S는 K 개의 그룹의 평균( ― ⋅ )이 제곱합을 만드는데 선택될 수 있고, 만드는 과정에서 전체 평균( ― ⋅ ) 하나를 추정해서 사용하였으니 1개의 자유도를 잃습니다. 그래서 S의 자유도는 − 이 됩니다. S의 경우, 전체 표본 수가 (여기서는 N이라고 하겠습니다) 제곱합을 만드는데 선택될 수 있고 만드는 과정에서 개의 그룹 평균( ― ⋅ ) 을 추정해서 사용하였으니 k 개의 자유도를 잃습니다. 즉, S의 자유도는 −입니다. 분산분석의 검정통계량은 다음과 같습니다. 이 검정통계량을 가지고 유의 확률(p-value)을 계산합니다. = S / f S E d E F ( f, f) = u b r f r u, i n m e o s m l s o e f = − d E N k 이렇게 진행된 분산분석의 결과를 정리한 것을 분산분석 표(Anova Table)라고 합니다. 분산분석의 결과 해석은 항상 분산분석 표를 이용하여 해석하니 꼭 기억해두시길 바랍니다 i = i ϵ j ϵ i d ( , 2 ) Y j μ α + i, i ∼ i N ( , 2 ) 각 집단 = , , , ( 집 ) 각 집단에서의 개별관찰치 = , , , i ( 집 에의 별 찰 ) 각 집단의 효과 i μ − ( 집의 과 ) 여기서 각 집단의 효과 i 는 각 집단의 평균과 전체 평균의 차이입니다. 우리가 위에서 변동을 이야기하면서 사용했던 ― ⋅ X ⋅ 이 추정하려는 것이 바로 이 각 집단의 효과 i 라고 할 수 있습니다. 또한 i 란 independent and identically distributed의 줄임말로, 어떤 확률변수가 독립적이며 동일한 분포를 보인다는 의미입니다. 위 모형에서는 오차항 이 독립적으로 평균이 0이고 분산이 2 인 정규분포를 따른다는 것으로 해석할 수 있습니다. 귀무가설이 기각이 되었을 때, 즉 평균이 같지 않을 경우 분산분석에서 대립가설의 뜻은 '모든 집단별 평균은 같지 않다' 가 아닌 '적어도 하나의 집단 평균은 다르다'이라는 점입니다. − 개의 집단별 평균이 같다고 해도 하나만 유의하게 다르다면 귀무가설은 기각될 것입니다. 이는 분산분석이 가지고 있는 구조적 한계입니다. 지금까지 언급했던 검정 원리를 보아도 아노바는 집단 간 변동의 총합을 이용한 검정을 하고, 그 말은 특정 집단의 개별 효과를 전혀 확인할 수 없다는 뜻입니다. 다시 말해서 귀무가설이 기각되었을 때, 검정의 결과를 보면 각 집단별 평균이 다르다는 것은 알 수 있지만 어떤 집단이 얼마큼 큰지는 알 수 없다는 것이죠. 그래서 이 경우 대게 사후 검정(post hoc test)라 부르는 집단별 비교 검정을 진행하게 됩니다. 원리는 아주 간단합니다. 위의 예에서 low, mid, high 세 집단의 효과가 같은지에 대한 분산분석 결과 귀무가설이 기각되어 세 집단의 효과가 모두 같지는 않다는 결과를 얻었다면 사후 검정으로 (low-medium), (low-high), (medium-high) 이렇게 두 개씩 비교하면서 개별 비교를 하는 것입니다. 그 분석 방법으로는 위에서 배운 독립 검정을 이용할 수도 있겠고 같은 원리를<NAME>는 Duncan이나 Scheffe라고 불리는 개별 비교법을 이용할 수도 있습니다. A7. 분산분석(R Code) 7. 분산분석(R Code) 분산분석을 R에서 실행하는 방법은 다음과 같습니다. 분석하고자 하는 것은 satisfaction_level(직무 만족도)의 평균이 salary(연봉 수준, low, medium, high) 집단에 따라 차이가 있는지 통계적으로 검정하고자 합니다. 귀무가설은 다음과 같습니다. 연봉 수준별로 직무만족도의 평균이 같을 것이다 0 s l r ( 봉 ) 준로 a i f c i n e e ( 무 족 ) 평 이 을 이. 1 n t 0 ANOVA = aov(satisfaction_level ~ salary, data = HR) summary(ANOVA) Df Sum Sq Mean Sq F value Pr(>F) salary 2 2.3 1.1693 18.96 5.97e-09 *** Residuals 14996 924.8 0.0617 --- Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 분석 결과를 보시면 분산분석 표가 나옵니다. Df는 자유도, Sum sq는 제곱합을 Mean Sq는 평균 제곱합을 의미합니다. 위에서 언급했던 분산분석 표를 그대로 가져와서 값을 채워 넣으면 다음과 같습니다. 정해진 순서대로 제곱합과 자유도를 구한 후 평균제곱을 계산한 뒤 검정통계량인 F value를 구했습니다. 마지막으로 유의 확률 p-value를 확인할 수 있습니다. p-value는 0과 매우 가까운 값이기 때문에 당연히 유의 수준 0.05보다 작습니다. 그러므로 귀무가설 0 를 기각할 수 있습니다. 즉 연봉 수준별로 직무만족도의 평균은 동일하지 않습니다. 하지만 이 상태로는 위에서 말했듯이 '평균이 같지 않다.'만을 알 수 있지, 정확히 어떻게 다른지 알 수가 없기 때문에 사후 검정을 진행해야 됩니다. TUKEY = TukeyHSD(ANOVA) TUKEY Tukey multiple comparisons of means 95% family-wise confidence level Fit: aov(formula = satisfaction_level ~ salary, data = HR) $salary diff lwr upr p adj low-high -0.03671654 -0.05461098 -0.018822102 0.0000046 medium-high -0.01565305 -0.03372130 0.002415191 0.1049520 medium-low 0.02106349 0.01111999 0.031006988 0.0000021 plot(TUKEY) 사후 검정은 여러 방법이 있습니다. 지금 사용한 방법은 Tukey 사후 검정입니다. 해석을 하는 방법은 다음과 같습니다. 3개의 집단을 2개씩 따로 분석을 한 것이며, 비교하는 두 집단 간의 차이가 같은지 다른지 다시 한번 검정하는 것입니다. plot은 사후 검정 결과를 나타낸 것이며 보는 법은 간단합니다. 각 신뢰구간 안에 0이 포함되는지 아닌지만 보시면 됩니다. low - high : low 집단의 satisfaction_level의 평균과 high 집단의 satisfaction_level의 평균 차이를 비교하니 신뢰구간이 [ 0.054 ( w) − 0.018 ( p) ] 사이에 있는 것을 알 수 있습니다. 해당 구간 안에 0이 포함되어 있지 않으며, 0보다 작기 때문에 low 집단의 satisfaction_level 평균은 high 집단의 satisfaction_level에 비해 작다는 것을 의미합니다. medium - high : medium 집단과 high 집단의 satisfaction_level의 비교를 진행한 결과 신뢰구간이 [ 0.033 0.0024 ] 입니다. 0을 포함하기 때문에 medium 집단과 high 집단의 satisfaction_level의 평균은 같다고 볼 수 있습니다. medium - low : 신뢰구간이 0을 포함하지 않고 0보다 크기 때문에 medium이 low 집단보다 satisfaction_level의 평균이 높다고 볼 수 있습니다. 정리를 하면 satisfaction_level의 평균은 o < e i m h g 순서인 것을 알 수 있습니다. 즉 low 집단의 평균이 낮기 때문에 귀무가설을 기각하게 된 것입니다. 지금까지 진행한 이론과 분석을 정확히는 일원 배치 분산분석(One way Anova)이라고 합니다. 만약 평균을 비교할 때 하나의 요인만 사용하지 않고 여러 개의 요인을 사용하여 분석을 하고 싶을 때가 있습니다. 만약 2개의 요인을 통해 평균을 비교하고자 하면 이원 배치 분산분석(Two way Anova)이라고 합니다. T_ANOVA = aov(satisfaction_level ~ salary + left + salary:left, data = HR) summary(T_ANOVA) Df Sum Sq Mean Sq F value Pr(>F) salary 2 2.3 1.17 22.276 2.19e-10 *** left 1 137.8 137.79 2624.960 < 2e-16 *** salary:left 2 0.0 0.01 0.155 0.856 Residuals 14993 787.0 0.05 --- Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 요인을 하나 더 넣어주면 바로 이원 배치 분산분석을 진행할 수 있습니다. 다만 신경 써야 할 부분은 요인을 두 개를 사용할 경우, 각 요인 간의 교호작용이 있는지 확인을 해야 됩니다. 위 분석 결과에서는 단일 효과(salary, left)는 유의한 것을 알 수 있지만 교호작용효과(salary:left)는 유의하지 않다는 것을 알 수 있습니다. 이런 경우 교호작용항을 제거하고 모형을 다시 분석하면 됩니다. A8. 상관분석 \ 만약 두 개의 변수 간 관계를 분석하고 싶은 경우, 우리는 종종 상관계수(correlation)이란 것을 구하고는 합니다. 너무 유명한 용어라서, 상관계수의 정확한 의미는 알지 못하더라도, 상관계수가 대충 어떤 것인지는 많은 사람들이 알고 있습니다. 한번 개념을 정립하고 넘어가도록 하겠습니다. 먼저, 상관분석이란 두 변수의 관계에서 하나의 변수가 증가하면, 다른 하나의 변수도 증가하는지 혹은 감소하는 경향이 있는지 확인을 하기 위해 분석을 진행합니다. 우리는 그러한 경향을 확인하기 위해 공분산(Covariance)이라는 값을 계산합니다. 공분산과 상관계수 O [ , ] E [ ( − ― ) ( − ― ) ] 이렇게 계산을 하면, X와 Y의 상관관계를 계산할 수가 있습니다. 하지만, 한 가지 문제가 존재합니다. 공분산은 변수의 단위에 따라 범위가 무한대까지 확장됩니다. 즉, 변수가 바뀌면 공분산의 단위도 바뀌기 때문에 비교하는 값으로 확인하기에는 문제가 존재합니다. 이러한 문제점을 해결하기 위하여 공분산에 두 변수의 분산을 나누어줍니다. 그러면 공분산은 -1 ~ 1의 변수의 단위에 상관없이 일정한 범위를 가지는 상관계수(Correlation)로 변환이 됩니다. o r [ , ] C V [ , ] A [ ] V R [ ] − ≤ o r [ , ] 1 해석 방법은 매우 간단합니다. 상관계수가 1에 가까울수록 강한 긍정 관계를 가지고 있는 것이고 -1에 가까울수록 강한 부정 관계를 가지고 있습니다. 만약 0에 가까울 경우, 두 변수는 관계가 없다고 해석할 수가 있습니다. 상관분석 상관분석이란, 두 변수 간의 상관관계가 0인지 아닌지 확인을 하는 통계적 검정방법입니다. 따라서 귀무가설과 대립가설은 다음처럼 세울 수가 있습니다. 0 ρ 0 H : ≠ A9. 상관분석 (R code) 상관분석에서 주의할 점은 상관분석은 단순히 두 변수 간의 선형 관계를 파악하는 것뿐입니다. 즉 이 말은 비선형 관계는 상관계수로 잡아내기 힘들 수가 있습니다. 다음의 예시를 통해 알아보도록 하겠습니다. library(ggplot2) x1 = runif(n = 100, min = -10, max = 10) y = x1 * 10 + rnorm(n = 100, mean = 3, sd = 5) ggplot() + geom_point(aes(x = x1, y= y),size = 3) + geom_text(aes(x = 5, y = -30),label = round(cor(x1,y),4)) + theme_bw() 위 두 변수는 산점도로 보나, 상관계수로 보나 거의 1에 가까운 상관계수를 가지고 있습니다. 이는 두 변수의 관계를 하나의 선으로 표현할 수 있다는 의미와 같습니다. 그렇다면 상관분석 검정을 해보도록 하겠습니다. cor.test(x1,y) Pearson's product-moment correlation data: x1 and y t = 113.5, df = 98, p-value < 2.2e-16 alternative hypothesis: true correlation is not equal to 0 95 percent confidence interval: 0.9943742 0.9974582 sample estimates: cor 0.9962179 p−valuep−value가 매우 낮은 것을 확인할 수 있습니다. 귀무가설을 기각할 수 있으며, 두 변수의 상관계수는 0이 아니라는 결론을 내릴 수가 있습니다. y = x1^2 + x1 * 10 + rnorm(n = 100, mean = 3, sd = 5) ggplot() + geom_point(aes(x = x1, y= y),size = 3) + geom_text(aes(x = 0, y = 100),label = round(cor(x1,y),4)) + theme_bw() 두 번째 산점도에서는 선형보다는 2차 함수 꼴의 관계를 가지고 있습니다. 또한 상관계수가 0.8 ~ 0.9로 낮아진 것을 확인할 수 있습니다. 여전히 높은 값인 것은 맞지만 선형 관계가 아니기에 상관계수가 감소를 하였습니다. 하지만, 그렇다고 저 두 변수의 상관도가 낮아졌다고 판단하기는 힘듭니다. 선형 관계가 아닐 뿐이지, 비선형 관계는 그대로 유지하고 있습니다. y = sin(x1) + rnorm(n = 100, mean = 3, sd = 0.3) ggplot() + geom_point(aes(x = x1, y= y),size = 3) + geom_text(aes(x = 0, y = 5),label = round(cor(x1,y),4)) + theme_bw() 이번 산점도는 상관계수가 매우 낮게 나오는 것을 확인할 수 있습니다. 근데, 그렇다고 상관이 없다고 할 수 없습니다. 산점도에는 뚜렷이 삼각함수 sin(x) 꼴의 관계를 가지고 있는 것을 확인할 수 있기 때문입니다. 이렇게 상관분석은 정말 편한 분석이지만, 그렇다고 만능인 분석이 아닙니다. 저는 개인적으로 상관계수를 구하기보다는 산점도를 직접 봄으로써 변수의 상관 정도를 파악하고, 이러한 방법이 더 정확합니다. B1. 단순 선형 회귀분석의 추정 10. 단순 선형 회귀분석의 추정 회귀분석 : 인과관계를 가지고 있는 두 변수 간의 함수관계를 통계적으로 규명하고자 하는 분석 분산분석과 회귀분석은 선형모형이라는 큰 줄기에서 같은 방법론이라는 말씀을 드린 바 있습니다. 두 모형 모두 예측자(predictor)에 따른 평균 반응 값을 추정 혹은 예측하는 모형으로, 주어진 데이터를 통해서 선형 모형을 설정하고 새로운 값에 대한 반응 값을 예측하는 것에 그 목적이 있습니다. 예측 자란 반응 값을 예측하기 위해 사용되는 것으로 설명 변수(explanatory variable)와 혼용되는 개념으로 이해하시면 될 것 같습니다. 또한 아노바와 회귀 모형의 차이점이 있다면 아노바와 달리 회귀분석은 일반적으로 연속형 예측자를 가지고 있는 경우에 사용된다는 점입니다. 회귀분석은 설명 예측자와 반응 값의 수에 따라 단순 회귀분석, 다중 회귀분석 등으로 분류되며 설명 예측자와 반응 값의 관계에 따라 선형 회귀분석, 다항 회귀분석(비선형 회귀분석) 등으로 나누어집니다. 먼저 선형 회귀분석에 대해 알아보도록 하겠습니다. 일반적인 회귀분석의 가장 핵심 관점은 두 변수 간의 관계를 선형적으로 바라보는 것입니다. 그렇기에 관계를 확인하려는 두 변수가 선형적이지 않다면 애초에 성립될 수 없는 것이 회귀분석입니다. 이러한 선형성은 분석 전에 산점도와 같은 그래프를 통해 확인하는 것이 일반적이며 선형 회귀분석 전체를 아우르는 중요한 가정이라고 할 수 있습니다. 회귀분석의 최종 목표는 두 변수 사이의 선형성이 존재한다는 가정하에 그 선형 관계를 대표할 수 있는 하나의 직선을 구하는 것입니다. 예를 들어 Y와 X라는 두 변수 사이의 관계가 = + X 라는 직선으로 대표될 수 있다면, 두 변수 사이의 관계를 한눈에 알 수 있는 것은 물론이고 새로운 값이 주어졌을 때 값을 손쉽게 예측할 수 있을 것입니다. 여기서 고민해 보아야 하는 것은, 관찰치가 주어졌을 때, 그 관계를 표현하는 와를 어떤 방법으로 추정해야 가장 효율적이고 두 변수 간의 관계를 정확히 나타낼 수 있을까에 대한 방법론적 문제입니다. 회귀분석에서는 잔차의 제곱합을 최소로 만들어주는 와를 추정하는 방법을 택하였고 이를 최소 제곱 추정 법(method of least squares estimation)이라 부릅니다. 여기서 잔차(residual)는 실제 관측 값과 예측된 값의 차이를 말하며 그 제곱합을 최소로 한다는 것은 해당 선과 실제 관측 값의 차이의 총량을 최소로 하겠다는 것을 뜻합니다. 다음 그림을 참고하면 어렵지 않게 이해하실 수 있을 것입니다. 파란색 직선이 적합된 회귀선이고 검은 점들이 각 관찰치입니다. 이 경우 실제 관찰치와 적합된 회귀선의 차이가 바로 잔차이고 그 제곱은 위와 같이 사격형의 면적으로 표현될 것입니다. 잔차를 그냥 합하면 + / - 가 상쇄되어 의미가 없어지지만, 이런 식으로 제곱 후에 총합 이용하면 실제 관찰치와 적합된 회귀선 사이의 차이를 표현해 줄 수 있고 이것은 회귀선이 얼마나 관찰치들을 잘 대표하고 있는지에 대한 척도로 생각할 수 있습니다. 이런 관점에서 봤을 때 최소제곱법, 즉, 이 잔차 제곱합을 최소화하는 회귀선은 충분히 합리적인 회귀선이라고 볼 수 있을 것입니다. 회귀선의 평가 최소제곱법을 이용하면 어떤 자료에서든 회귀선을 추정할 수 있고, 최소제곱법이 아무리 합리적인 방법이라고 하여도 관찰치들을 절대적으로 잘 대표하는 직선을 항상 제시하지는 못합니다. 그래서 회귀선을 적합시킨 후에는 꼭 그 회귀선이 얼마나 정확한지에 대한 검정을 해주어야 합니다. 이를 회귀선의 적합도 혹은 정도를 평가한다고 하며 분산분석의 아이디어를 그대로 가져와서 진행하게 됩니다. 관찰치 i ( 찰 ) Y (관찰치의 평균), i (회귀선에 의한 추정 값)을 계산한다. 총 편차( i Y)를 회귀선을 기준으로 두 영역으로 나누어준다. 회귀선에 의해 설명이 가능한 영역 : i − ― 회귀선에 의해 설명이 되지 않은 영역 : i Y ^ 모든 관찰치에 대해 제곱합을 계산한 후, 직교 분해를 한다. i 1 ( i Y) = i 1 ( ^ − ― ) + i 1 ( i Y i ) S T S R S E 분산분석과 마찬가지로 분산분석 표를 작성하여 회귀선의 유의성 검정을 한다. 분산분석과 마찬가지로 회귀선으로 설명하는 상대적인 비중을 나타내는 S 이 모형의 잔차(Error)를 설명하는 S 보다 상대적으로 커야지 회귀선이 유의할 수 있습니다. 이 제곱합을 비교해 주기 위해 마찬가지로 분포를 이용합니다. 여기서 많은 분들이 SSE의 자유도를 이해하기 어려워하십니다. 이는 결정 계수( 2 )와도 관련이 있는 부분인데, 이 부분에 대하여 간단하게 설명하고 넘어가도록 하겠습니다. 자유도는 자유롭게 선택될 수 있는 자료 수로, 온전히 해당 통계량에 대한 정보를 생성하는 데 사용되는 자료 수라고 했습니다. 만약 관찰치가 2개밖에 없다면 회귀선은 무조건 그 두 점을 지나야 합니다. 그래야 직선이 만들어지기 때문입니다. 이 경우 두 선을 지나는 회귀선을 추정하기만 할 뿐, 그 회귀선을 평가할 자유도는 없습니다. 같은 관점으로 관찰치가 3개라면 2개는 위와 같은 논리로 사용되고 회귀선의 정도를 평가하는 데에는 하나의 관찰치만을 사용하게 될 겁니다. 즉, 기본적으로 회귀선은 2개의 자유도를 차지합니다. 그렇기 때문에 회귀선 정도 평가를 위해 사용되는 S는 −의 자유도를 갖게 됩니다. 설명 예측자가 2개 이상인 다중회귀분석에도 그대로 적용됩니다. 예를 들어 2개인 경우 회귀식은 3차원의 좌표 공간에서 어떤 평평한 면으로 표현할 수 있습니다. 이 면은 최소한 3개의 점이 있어야 형성될 수 있습니다. 그렇기 때문에 관찰치가 3개인 경우, 적합된 회귀식을 무조건 그 세 점을 지나갈 것이며, 회귀식의 정도를 파악하고 싶다면 최소한 4개 이상의 관찰치가 필요합니다.(3개의 점만 있다면 회귀 면은 모든 점을 지나갈 테고 이는 회귀선 평가에 관해서 아무 의미가 없습니다.) 즉, 이 경우 회귀식은 3의 자유도를 차지합니다. 회귀식 평가를 위한 S는 n-3의 자유도를 갖게 됩니다. 이를 일반화하면 SSE는 n-예측자 수-1 가 됩니다. 일반적으로 예측자 수를 k로 표현하니, n-k-1이라고 할 수 있습니다. 이와 같은 이유로 회귀선을 평가하는 데 사용되는 가설과 검정통계량은 다음과 같습니다. 추정된 회귀식은 유의하지 않다 0 추 된 귀 은의 지 다 추정된 회귀식은 유의하다 1 추 된 귀 은의 다 0 S R d R S / f ∼ ( f, f) d R k f = − − n n m e o o s r a i n 만약 MSE에 비해 MSR이 상대적으로 큰 값을 가지고 있다면 0 는 높은 값을 갖겠고, 이는 회귀식으로 설명할 수 있는 변동이 그렇지 않은 변동에 비해 크다는 것을 의미합니다. 이 경우 귀무가설을 기각합니다. 2 계산 회귀선이 전체 변동 중 설명하는 비중을 회귀선의 설명력, 2 라고 합니다. 2 S R S = − S S T 이는 결정 계수(coefficient of determination, 2 )라는 척도로 전체 변동중 회귀선에 의해 설명되는 변동이 차지하는 비중을 표현하는 값입니다. 0과 1 사이의 값을 가지며 '회귀식의 기여율'이라는 관점으로 해석될 수 있습니다. 이 역시 위의 F 검정과 같은 원리이며, 같은 방법으로 회귀선을 평가하는 척도입니다. 회귀 모형 설정 회귀 모형을 설정해 보도록 하겠습니다. 여기서 값은 주어진 값으로 취급하므로 오차 항의 분포는 곧 반응 값의 분포입니다. i β + 1 i ϵ, i i d ( , 2 ) 분산분석에서와 같이 오차항에 대한 가정은 곧 회귀분석을 하기 위한 가정이고 i N 에 따라 독립성,<NAME>, 등 분산성 세 가지 성질을 요합니다. 이 세 가정은 오차 항의 추정량인 잔차를 통해 진단되며 잔차가 관찰치에 따라 특정한 패턴을 보이거나 커졌다 작아졌다 하는 양상을 보인다면 독립성, 등 분산성을 의심해 보아야 하며 잔차의 히스토그램을 그려보거나 관련 검정을 통해<NAME>을 만족하는지에 대해 확인해 보아야 합니다. 또한 실제 데이터를 기지고 추정한 회귀식은 다음과 같이 표현합니다. ^ = 0 b X 절편 0 는 예측자가 0의 값을 가질 때의 반응 값을 의미하며 초깃값을 나타냅니다. 기울기 1 은 예측자가 가지고 있는 반응 값에 대한 단위 당 영향도를 의미합니다. 기울기가 양의 값을 갖고 있다면 예측자가 증가할수록 반응 값 역시 증가할 것이며 음의 값을 갖는다면 예측자의 증가에 따라 반응 값은 감소할 것입니다. 또한 절댓값이 클수록 그 영향이 크다는 것을 의미합니다. 이 영향도 역시 유의한지 검정을 진행할 수 있습니다. 이를 회귀계수의 검정 혹은 회귀식의 기울기 검정이라고 합니다. 기울기 검정은 분포를 이용하게 됩니다. 만약<NAME>의 가정이 만족하면, 회귀계수는 분포를 따르기 때문이죠. 회귀계수가가 0인가를 확인하는 검정은 해당 설명변수가 반응 값에 영향을 미치는지 아닌지를 확인하는 것과 같습니다. 여러 설명변수가 포함된 모형에서도 진행할 수 있으며, 마찬가지로 각 변수의 독립적인 영향력을 평가하게 됩니다. 회귀계수는이다 0 β = 회 계는 이. 회귀계수는 이 아니다 1 β ≠ 회 계는 이 네. B2. 회귀분석(R Code) 11. 회귀분석(R Code) 회귀분석은 제가 만들어 둔 데이터로 진행을 하도록 하겠습니다. 데이터 다운로드 링크 : https://www.drop box.com/sh/vtqlvrgdts2yfez/AAD_cd49dBcvgBNdz-C-A6TFA? dl=0 # 데이터 불러오기 Regression = read.csv("F:\Drop box\DATA SET(Drop box)/Regression.csv") 산점도 회귀분석은 우선적으로 산점도를 그려보고 선형성을 판단해야 됩니다. library(ggplot2) ggplot(Regression, aes(x = X, y = y)) + geom_point() + geom_smooth(method = 'lm') + theme_classic() 산점도를 그려본 결과 X와 y는 선형 관계를 가지고 있는 것을 알 수 있습니다. 이런 경우 단순 선형 회귀분석을 진행하면 됩니다. 회귀분석 Reg = lm(y ~ X, data = Regression) anova(Reg) Analysis of Variance Table Response: y Df Sum Sq Mean Sq F value Pr(>F) X 1 143757 143757 3882.2 < 2.2e-16 *** Residuals 148 5480 37 --- Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 summary(Reg) Call: lm(formula = y ~ X, data = Regression) Residuals: Min 1Q Median 3Q Max -9.5537 -5.7116 0.2738 5.0961 10.2835 Coefficients: Estimate Std. Error t value Pr(>|t|) (Intercept) 1.9839 0.9975 1.989 0.0486 * X 10.0924 0.1620 62.308 <2e-16 *** --- Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 Residual standard error: 6.085 on 148 degrees of freedom Multiple R-squared: 0.9633, Adjusted R-squared: 0.963 F-statistic: 3882 on 1 and 148 DF, p-value: < 2.2e-16 − a u는 0과 매우 가까운 값입니다. 그러므로 회귀분석의 귀무가설(회귀식은 유의하지 않다 0 회 식 유 하 안 )을 기각하게 됩니다. 즉, 회귀선은 유의합니다. R 분석 결과를 자세히 보도록 하겠습니다. Residuals는 i y ^ 의 요약 값을 나타냅니다. Coefficients는 추정된 회귀식을 나타냅니다. Estimate는 회귀식의 절편과 기울기를 나타냅니다. (Intercept) : 0 의 값은 1.9839입니다. : 1 의 값은 10.0924입니다. Pr(>|t|)는 각각 0 b에 대한 가설검정 결과를 나타냅니다. 만약 설명 변수를 여러 개 사용하는 다중 회귀분석을 진행할 경우, 각 설명 변수에 대한 가설 검정을 진행하게 될 것입니다. Multiple R-squared는 회귀 모형의 2 를 나타냅니다. Adjusted R-squared는 조금은 다른 2 를 나타냅니다. 일반적으로 회귀 모형은 설명 변수가 많을수록 설명력은 높아지는 구조를 가지고 있습니다. 만약 다른 변수로 구성된 두 회귀 모형의 설명력을 비교하고자 할 때 Adjusted R-squared를 사용합니다. o e 1 y ^ b + 1 1 + 2 2 M d l : i = 0 + 1 1 + 예를 들어 회귀식이 2개가 있고 두 모형 중 2 가 더 높은 모형을 택하고자 합니다. o e 2 는 3개의 설명 변수가 투입되었기에 설명 변수를 2개를 투입한 o e 1 에 비해 우위에 있습니다. 2 의 구조상 설명변수가 많아지면 항상 오를 수밖에 없는 구조이기 때문입니다. 그렇지만 설명 변수가 많은 것은 항상 바람직한 것이 아닙니다. 그만큼 많은 계수를 추정해야 하기 때문이죠. 그렇기에 설명 변수가 더 많이 투입된 부분을 보정해 주어 더 바람직한 모형의 기준을 제시해 주는 2 값이 Adjusted R-square입니다. p-value : 회귀 모형에 대한 유의성을 나타냅니다. 회귀분석의 결과를 정리하면 다음과 같습니다. 적합된 회귀선은 i = 1.9839 10.0924 i 입니다. i 가 한 단위 증가하면 i는 10.0924만큼 증가합니다. 2 는 0.963으로 96%의 설명력을 가진다고 볼 수 있습니다. 잔차 진단 회귀분석을 진행한 후에는 항상 가정 검토를 위해 잔차 진단을 해야 합니다. 회귀분석에서의 가정은<NAME>, 등 분산성, 독립성입니다. 그런데 독립성은 데이터가 수집되는 과정에서 확인하여야 할 가정이므로 수집된 데이터로 분석이 진행된 상황에서는 확인할 수 없습니다. 그렇기에 여기서는<NAME>, 등 분산성을 다루고, 추가적으로 영향점이라는 것을 다루도록 하겠습니다. plot(Reg) 정규성 qqnorm(Reg$residuals) 회귀분석에서 잔차의<NAME>을 진단하는 이유는 신뢰구간 추정과 가설 검을 정확하게 하기 위해서 진행합니다. 우측 상단에 배치되어 있는 Normal Q-Q를 보면 됩니다. x축은 Theoretical Quantiles이며, y 축은 Standardized Residuals입니다. QQ plot은 역 확률을 이용하여 두 분포를 비교하는 plot입니다. 여기서는 정규분포와 잔차의 분포를 비교하고 있습니다. 만약 선이 대각선을 따라가는 일직선이라면 그만큼 잔차의 분포는 정규분포와 비슷하다고 볼 수 있습니다. 반대로 선이 대각선과는 멀어지는 곡선 형태라면 그만큼 잔차의 분포는 정규분포와 다르다는 것을 의미합니다. 등 분산성 등 분산성은 회귀분석에서 매우 중요한 가정 중 하나입니다. 여기서 등 분산의 주체는 오차입니다. 그렇지만 실제 오차를 정량화할 수 없으니 오차의 추정치로써 잔차를 사용하게 됩니다. 잔차는 추정된 회귀선과 실제 값의 차이입니다. 즉, 등분성을 보는 것은 선과 점 사이의 거리가 패턴이 없이 일정한가를 보는 것과 같습니다. 이를 확인하기 위해 조금 극단적인 예를 보겠습니다. 좌측 산점도와 우측 산점도가 있을 때, 두 산점도에 회귀선을 적합시켜보도록 하겠습니다. 우측의 회귀선은 직관적으로 판단해도 회귀선에 문제가 없습니다. 하지만 좌측 회귀선은 그러지 못합니다. 그 이유는 회귀선과 데이터의 차이(잔차)가 x가 커지면서 같이 늘어나고 있기 때문입니다. 즉, 등 분산성을 만족한다고 할 수 없습니다. 이때는, 회귀선이 데이터를 잘 설명한다고 보기 어렵습니다. 이처럼 회귀분석에서 등 분산성이 위배되면 회귀분석은 데이터를 설명하지 못한다고 판단하기 때문에 좋은 회귀선이라고 할 수 없습니다. 좌측의 회귀선에 대한 잔차의 등 분산 진단 그래프로 보면 다음과 같은 플롯을 확인할 수 있습니다. x축은 Fitted value입니다. 즉, i를 의미합니다. y 축은 Resiuals( i y ^ )을 의미합니다. 잔차가 추정 값이 증가함에 따라 증가하는 패턴을 보이고 있습니다. 위에서 말씀드린 것처럼 등 분산성을 만족하지 못한다는 것을 알 수 있습니다. 다시 데이터로 돌아와서 위에서 그린 잔차 진단 그래프를 확인해 보겠습니다. 등 분산성은 좌측 상, 하 그래프를 보면 됩니다. 좌측은 y 축이 Residuals, 우측은 y 축이 표준화 잔차 값입니다. 이는 또한 설명변수와 반응 값과의 관계를 확인할 수도 있습니다. 만약 패턴이 존재하지 않는다면 상관없지만 Fitted value에 따라 잔차가 특정한 패턴을 보인다면 다른 분석을 고려하거나 설명변수의 변환을 생각해 보아야 합니다. 독립성 ggplot(NULL) + geom_point(aes(x = 1:nrow(Regression), y = Reg$residuals)) + geom_h line(yintercept = 0, linetype = "dashed",col = 'red') + xlab("Index") + ylab("Residuals") + theme_bw() 잔차의 독립성이란, 잔차가 ’자기상관(Auto correlation)’이 있는지 없는지 판단하는 것입니다. 우리는 확률변수 및 확률분포를 다룰 때, 모든 확률 실험은 독립시행을 했다고 가정을 하였습니다. 이 말은 전 시점에서의 확률 실험이 현재의 확률 실험에 영향을 주지 못하며, 지금의 확률 실험은 미래의 결과에 영향을 주지 못한다는 것입니다. 이를 ’자기상관’이라고 합니다. 대표적으로 주식, 날씨 등이 해당이 됩니다. 만약, 독립성이 위배가 된다면 이 때는 시계열 분석(Time Series) 방법론을 이용하여 회귀분석을 해야 합니다. 검정방법은 매우 간단합니다. Durbin-Watson 검정을 하는 방법도 있지만, 잔차들을 시점 순서대로 그래프를 그린다 다음, 패턴이 없다면 독립성을 충족한다고 판단할 수가 있습니다. 영향점 회귀분석과 같은 통계 모형에는 영향점이라는 것이 존재합니다. 영향점은 쉽게 설명하면 회귀선을 자기 자신한테 당겨오는 데이터입니다. 즉 회귀선의 무게중심과 멀리 있어, 이에 영향을 준다고 볼 수 있습니다. Cook’s distance라는 값을 계산하여 영향점을 판단합니다. plot에 찍힌 92, 134, 144번째 데이터가 회귀선에 영향을 주고 있음을 나타내고 있습니다. 이 점들은 회귀선을 기울기에 크게 영향을 주어 예측에 왜곡을 줄 수 있습니다. 영향점을 발견하였을 경우, 먼저 영향점에 대한 확인이 필요합니다. 영향점은 일반적인 x와 먼 값을 갖고 있으면서 높은 잔차를 보이므로 우선적으로 x 값이 정당한 값인가를 확인해야 합니다. 측정 자체가 잘못되었을 가능성이 있기 때문입니다. 또한 예측에 목적이 있다면 해당 데이터를 제거하고 회귀분석을 진행하는 방법도 고려해야 합니다. B3. 다중 회귀분석(Multiple Regression) 12. 다중 회귀분석(Multiple Regression) 다중 회귀분석 : 단순 선형회귀분석의 확장판으로 예측자가 2개 이상 쓰이는 경우 다중 회귀분석은 예측자를 2개 이상 쓰는 경우로, 회귀분석과 거의 동일하다고 볼 수 있습니다. 식 표현은 행렬식을 이용해 표현을 하는데, 이 책의 취지와는 맞지 않으므로 간단하게 다중 회귀분석을 진행할 때 주의해야 할 점들에 대해 다루면서 진행하겠습니다. i = 0 b x i b x i 회귀식이 위 식처럼 구해져 있을 때, 회귀식의 해석은 다음과 같이 진행합니다. 1 가 1 단위 증가하면 i는 1 만큼 변한다.(단, 2는 고정) 2 가 1 단위 증가하면 i는 2 만큼 변한다.(단, 1 은 고정) 여기서 중요한 점은 서로 다른 예측 자는 상관성이 적어야 한다는 것입니다. 만약 1 x의 상관성이 높다면, 1 이 증가하였을 때, 2 는 고정되지 못하고 함께 증가해버리는 문제가 발생해버립니다. 이런 상황을 다중공 선성(Multicolinearity)라고 합니다. 회귀식에 다중공 선성이 존재할 경우, 회귀식의 분산이 팽창을 하게 되며, 1 b에 대한 추정이 불확실하게 됩니다. 그러므로 다중공 선성이 존재할 경우, 회귀식에 투입되는 예측자를 다시 조정하여 회귀식을 구해야 합니다. 이 부분은 후에 주성분 분석에서 다루도록 하겠습니다. x1 = runif(n = 100, min = -10, max = 10) x2 = 0.7*x1 + rnorm(n = 100, mean = 0, sd = 1) y = 1.3*x1 + rnorm(n = 100, mean = 6, sd = 3) DF = data.frame( x1 = x1, x2 = x2, y = y ) library(GGally) ggpairs(DF) 위 그림을 보시면 x1x1, x2x2와의 상관관계가 매우 높은 것을 확인할 수가 있습니다. 이러한 경우, 회귀분석을 구했을 때, 다중공 선성이 매우 의심되는 상황이 발생합니다. 다중 회귀분석 M_Reg = lm(y ~ x1 + x2) summary(M_Reg) Call: lm(formula = y ~ x1 + x2) Residuals: Min 1Q Median 3Q Max -7.6871 -1.8648 0.2094 1.6262 6.5584 Coefficients: Estimate Std. Error t value Pr(>|t|) (Intercept) 6.2825 0.2965 21.192 < 2e-16 *** x1 1.1548 0.2202 5.244 9.18e-07 *** x2 0.2368 0.3083 0.768 0.444 --- Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 Residual standard error: 2.937 on 97 degrees of freedom Multiple R-squared: 0.8793, Adjusted R-squared: 0.8768 F-statistic: 353.4 on 2 and 97 DF, p-value: < 2.2e-16 언뜻 보기에는 회귀분석에 큰 문제는 없어 보입니다. 다중회귀분석에서는 x1x1, x2x2의 기울기 b1b1, b2b2에 대한 가설 검정이 진행이 됩니다. x1x1의 회귀계수 b1b1은 유의한 것으로 나왔지만, x2x2의 회귀계수 b2b2는 유의하지 않은 것으로 나왔습니다. 다중공 선성 진단 library(car) vif(M_Reg) x1 x2 19.66709 19.66709 다중공 선성은 분산 팽창지수(VIF)를 측정함으로써 판단이 가능합니다. 기본적으로 5보다 작으면 다중공 선성이 없다고 판단할 수 있습니다. 지금은 다중공 선성이 매우 높은 상황이므로 다중공 선성이 존재하고 있다고 확인할 수 있습니다. B4. 다항 회귀분석(Polynomial Regression) 13. 다항 회귀분석(Polynomial Regression) 다항 회귀분석 : 예측자들이 1차 항으로 구성된 것이 아닌, 2차 항, 3차 항 등으로 구성되어 있는 회귀식 ^ b + 1 i b x 2 ⋯ b x p \ 다항 회귀분석은 위 식처럼 구성이 될 수 있습니다. 다항회귀분석에서는 매우 중요한 개념이 하나 따라오는데, 이를 확인하고 다항 회귀분석을 진행하도록 하겠습니다. 분산-편차의 Trade off 관계 Trade off : 두 개의 목표 중에서 하나를 달성하려고 하면 다른 목표가 희생되어야 하는 관계를 의미합니다. 기계학습에서 예측 모형을 만드는 것은 항상 Trade off 관계를 생각해야 됩니다. 기본적으로 통계학에서는 모형의 Target Variable(종속 변수)이 연속형(Continuous)일 때는 MSE 와 Bias에 주목합니다. 만약 Target Variable이 범주형(Categorical)일 경우에는 모형의 Error Rate에 주목합니다. 그 이유는 모형의 정확성은 MSE 혹은 Bias가 얼마나 작은지에 따라 결정되기 때문입니다. MSE(Mean Squared Error) 앞서 단순 선형회귀에서 MSE를 다루었지만, 다시 한번 복습하면서 재차 다루어보도록 하겠습니다. S를 이해하기 위해서는 위 그림의 의미를 제대로 숙지하고 있어야 합니다. 실제 관측 값 i 실 관 값 예측값 i = 측 평균 ― 평 여기서 예측값 i 은 추정된 회귀식 i = 0 β X으로부터 추정된 예측 값입니다. 평균값 ― Y = n ( i ) 평균 산술식으로부터 계산된 표본평균입니다. 보라색 간격에 해당되는 i − ― 는 간격의 차이를 설명할 수 있기 때문에( 0 β X − n ( i ) ) 추정된 회귀식이 설명이 가능한 영역이 입니다. 하지만 초록색 간격에 해당되는 i Y ^ 는 실제로 관측된 i 값이 왜 저기에 찍혔는지에 대해서는 설명을 할 수 없습니다. 그런 관계로 해당 영역을 설명이 불가능한 영역입니다. 모든 모형은 설명력이 높으며 (혹은 설명 못하는 영역이 적은) 예측이 잘 되는 모형이 좋은 모형입니다. 결국 모형의 결함은 설명을 하지 못하는 i Y ^ 은 오차로 계산하게 됩니다. 이를 잔차(Residuals, 혹은 Error)라고 합니다. 추정된 회귀식 i = 0 β X 이 변수들 간의 인과관계를 제대로 설명하는지 측정하기 위하여 잔차의 합을 계산하게 됩니다. 여기서 잔차는 상황에 따라 양수가 될 수도, 음수가 될 수도 있습니다. 그렇기에 부호 간 계산으로 잔차의 합이 상쇄되는 것을 방지하기 위하여 잔차를 제곱하여 합을 구하게 됩니다. 이를 오차의 제곱합(Sum Squred Error, S)라고 부릅니다. 그런 다음 계산된 S를 보정하기 위하여 S를 오차의 자유도( f)로 나눕니다. 그렇게 계산된 값을 오차 평균 제곱합(Mean Squared Error, S)라고 부릅니다. S = ( i Y ^ ) M E 1 f Σ ( i Y ^ ) SSE를 오차의 자유도로 나누어주는 이유 제곱 된 값은 항상 양수입니다 양수를 모두 더하게 되면, 데이터가 많을수록 값은 커지게 됩니다. 그 의미는 SSE 자체가 데이터가 많을수록 단순히 커지는 의미이기 때문에, 정말 오차가 높은가?에 대한 평가 기준이 잘못 해석될 수가 있습니다. 이를 자유도로 나눔으로써 평균이 계산되고, 보정된 평균오차를 모형의 Error 수준으로 판단하게 됩니다. 위와 같은 계산으로 회귀식이 설명 가능한 영역인, i − ― 은 각각 다음과 같이 계산이 됩니다. S = ( i − ― ) M R 1 f Σ ( i − ― ) 그렇다면 추정되는 회귀식이 데이터의 인과관계를 얼마나 잘 설명하는지 계산하기 위해 설명을 하지 못하는 영역 대비, 설명을 할 수 있는 영역을 비교하게 됩니다. v l e M R S = d R ( i − ― ) 1 f Σ ( i Y ^ ) M R S는 두 집단의 분산을 비교하는 F 분포를 따르게 됩니다. 추정된 회귀식의 설명하는 영역이 설명하지 못하는 영역에 비해 얼마나 큰지 나타내는 검정통계량(Test Statistics) v l e 는 값이 클수록 회귀식의 귀무가설(회귀식의 기울기가이다 0 회 식 기 기 0 다 )를 기각할 가능성이 커지게 됩니다. 그렇다면 v l e 값이 커지려면 다음과 같습니다. S 이 증가 S 가 감소 분석 모형의 성능 평가를 S로 하는 이유입니다. S 가 작은 모형일수록 회귀식의 오차가 줄기 때문에 그만큼 현상을 잘 설명한다고 할 수 있습니다. Variation & Bias 회귀식으로 추정된 i는 얼핏 보면 단일 값인 점 추정(Point Estimation)으로 생각할 수 있지만, 모든 통계분석 모형은 구간 추정(Interval Estimation)입니다. 구간 추정이란 소리는 추정 값에 대한 신뢰구간을 계산한다는 의미입니다. 신뢰구간의 의미는 똑같은 값이 주어졌을 때, 추정 값 ^ β + 1의 값이 [ ^ α y + ] 의 범위에 속한다는 의미입니다. 만약 분산이 크다면, 이 신뢰구간의 길이는 길어지게 되고, 추정의 신뢰성이 떨어지는 문제가 발생합니다. 반대로 편의(Bias)는 추정된 값이 모집단의 특성, 즉 모수를 반영하지 못한다는 의미입니다. 위 그림을 보시면 분산과 편향이 크고 작을 때에 따라 모형의 정확성이 어떻게 변하는지 알 수 있습니다. 모수의 True Value가 원 정중앙에 있다고 하였을 때, Variance 가 크다는 것은 추정 값의 범위가 넓은 것을 의미하고, Bias가 크다는 것은 영점조준 사격 훈련 때 탄집군은 생겼지만 영점이 잘못 잡혔다 와 비슷하다고 생각하시면 됩니다. 선형 & 비선형 Modeling Linear Regression(선형 회귀분석)과 Non - Linear Regression(비선형 회귀분석)을 잠깐 다루고 가겠습니다. library(ggplot2) ggplot(Regression) + geom_point(aes(x = X, y = y),col = 'royalblue',alpha = 0.4) + geom_smooth(aes(x = X, y = y),col = 'red') + theme_bw() + xlab("") + ylab("") ggplot(Regression) + geom_point(aes(x = X, y = y2),col = 'royalblue',alpha = 0.4) + geom_smooth(aes(x = X, y = y2),col = 'red') + theme_bw() + xlab("") + ylab("") 사람들이 회귀분석을 돌릴 때, 가장 실수하는 부분은 단순하게 변수들 간의 상관관계만을 파악해서 분석하는 경우입니다. 상관관계는 두 변수의 관계가 선형성을 띄는지를 판단하는 것일 뿐입니다. 만약 두 변수가 비선형 관계에 있을 경우, 상관관계는 낮게 잡힐 수도 있습니다. 하지만 상관계수가 낮게 잡힌다고 해서 이 두 변수 간에 관계가 존재하지 않는 것은 아닙니다. 비선형으로 회귀식을 잡으면 충분히 관계를 설명할 수가 있게 됩니다. ggplot(Regression) + geom_point(aes(x = X, y = y3),col = 'royalblue',alpha = 0.4) + geom_smooth(aes(x = X, y = y3),col = 'red') + theme_bw() + xlab("") + ylab("") 특히 이런 경우, 데이터의 상관관계 수가 매우 낮게 계산이 됩니다. 상관계수만 보면 매우 낮기 때문에 일반적으로 모델링 할 생각부터 안 하게 됩니다. 하지만 분석 모형에서는 이러한 비선형 관계들로 관계식을 추정할 수 있습니다. 선형 회귀분석 두 변수의 관계가 선형인 경우에 대해서 회귀분석을 추정해 보겠습니다. LINEAR = lm(y ~ X, data = Regression) summary(LINEAR) Call: lm(formula = y ~ X, data = Regression) Residuals: Min 1Q Median 3Q Max -9.5537 -5.7116 0.2738 5.0961 10.2835 Coefficients: Estimate Std. Error t value Pr(>|t|) (Intercept) 1.9839 0.9975 1.989 0.0486 * X 10.0924 0.1620 62.308 <2e-16 *** --- Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 Residual standard error: 6.085 on 148 degrees of freedom Multiple R-squared: 0.9633, Adjusted R-squared: 0.963 F-statistic: 3882 on 1 and 148 DF, p-value: < 2.2e-16 ggplot(Regression) + geom_smooth(aes(x = X, y = predict(LINEAR, newdata = Regression)),col = "red", method = 'lm') + geom_point(aes(x = X, y = y),col = 'royalblue') + ylab("") + xlab("") + ggtitle("Linear Regression") + theme_bw() 일반적인 선형회귀분석, 즉 선형을 완벽하게 띄고 있는 변수 간의 관계는 간단하게 선형으로 적합시키면 문제가 없습니다. Polynomial Regression 변수 간의 관계가 y=x2y=x2 형태를 가지는 데이터에 대해 2차 항 회귀분석(다항 회귀분석)을 적용시켜 보겠습니다. # 제곱 꼴 관계를 선형으로 적합 NonLinear = lm(y2 ~ X, data = Regression) summary(NonLinear) Call: lm(formula = y2 ~ X, data = Regression) Residuals: Min 1Q Median 3Q Max -154.19 -84.79 -46.28 46.35 446.95 Coefficients: Estimate Std. Error t value Pr(>|t|) (Intercept) -208.872 21.225 -9.841 <2e-16 *** X 103.788 3.447 30.113 <2e-16 *** --- Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 Residual standard error: 129.5 on 148 degrees of freedom Multiple R-squared: 0.8597, Adjusted R-squared: 0.8587 F-statistic: 906.8 on 1 and 148 DF, p-value: < 2.2e-16 2차 항의 관계를 선형으로 적합하였을 때의 설명력은 85 ~ 86%가 나온 것을 알 수가 있습니다. 다음으로 다항 회귀분석(2차 항)을 적용시켜보도록 하겠습니다. NonLinear2 = lm(y2 ~ poly(X, 2), data = Regression) summary(NonLinear2) Call: lm(formula = y2 ~ poly(X, 2), data = Regression) Residuals: Min 1Q Median 3Q Max -65.180 -25.879 5.213 29.693 39.436 Coefficients: Estimate Std. Error t value Pr(>|t|) (Intercept) 345.341 2.582 133.74 <2e-16 *** poly(X, 2) 1 3899.149 31.625 123.29 <2e-16 *** poly(X, 2) 2 1527.866 31.625 48.31 <2e-16 *** --- Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 Residual standard error: 31.63 on 147 degrees of freedom Multiple R-squared: 0.9917, Adjusted R-squared: 0.9916 F-statistic: 8767 on 2 and 147 DF, p-value: < 2.2e-16 회귀식을 i = 0 β x + 2 i 형태로 적합한 결과 설명력은 99%로 상승한 것을 볼 수 있습니다. ggplot(Regression) + geom_smooth(aes(x = X, y = predict(NonLinear2, newdata = Regression)),col = "red") + geom_point(aes(x = X, y = y2),col = 'royalblue') + ylab("") + xlab("") + ggtitle("Polynomial Regression") + theme_bw() 유연성이 있는 회귀분석 다음 회귀분석은 = i ( ) 꼴을 가지는 두 변수 간의 관계를 회귀식으로 추정해 보도록 하겠습니다. 워낙 형태가 괴이하기 때문에 몇 차 항을 적합시켜야 할지 모르겠습니다. 그러하니 변수 항의 차수(Degree of Polynomial)을 2 ~ 10까지 주고 Testing을 해보도록 하겠습니다. # Train Set & Test Set 형성 TRAIN = Regression[1:100, ] TEST = Regression[101:150, ] # 저장 공간 생성 DEGREE = c() TEST_MSE = c() TRAIN_MSE = c() Adj_R = c() TEST_VAR = c() TRAIN_VAR = c() # 적합 모델 찾기 for( degree in 2:10){ FLEXIBLE_MODEL = lm(y3 ~ poly(X, degree),data = TRAIN) ## Summary Save SUMMARY = summary(FLEXIBLE_MODEL) ANOVA = anova(FLEXIBLE_MODEL) DEGREE = c(DEGREE, DEGREE) ## R_SQUARE Adj_R = c(Adj_R, SUMMARY$Adj.R.squared) ## Train Set TRAIN_MSE = c(TRAIN_MSE, ANOVA$`Mean Sq`[2]) TRAIN_VAR = c(TRAIN_VAR, var(FLEXIBLE_MODEL$fitted.values)) ## Test Set Pred = predict(FLEXIBLE_MODEL, newdata = TEST) TEST_RESIDUALS = (Pred - TEST$y3) TEST_MSE_VALUE = sum(TEST_RESIDUALS^2)/(nrow(TEST)) TEST_MSE = c(TEST_MSE, TEST_MSE_VALUE) TEST_VAR = c(TEST_VAR, var(Pred)) } ## Test 결과 데이터 프레임 생성 F_DATA = data.frame( DEGREE = DEGREE, Adj_R = Adj_R, TRAIN_MSE = TRAIN_MSE, TRAIN_VAR = TRAIN_VAR, TEST_MSE = TEST_MSE, TEST_VAR = TEST_VAR ) 항차를 2차 항부터 10차 항까지 차례대로 추정해 본 결과는 다음과 같습니다. library(dplyr) library(reshape) ggplot(TRAIN) + geom_point(aes(x= X, y = y3) , col = 'royalblue', alpha = 0.8) + geom_smooth(aes(x = X, y = predict(FLEXIBLE_MODEL, newdata = TRAIN)),col = 'red') + xlab("") + ylab("") + ggtitle("Flexible Regression") + theme_bw() ggplot(F_DATA) + geom_point(aes(x = DEGREE, y = Adj_R * 100)) + geom_line(aes(x = DEGREE, y = Adj_R * 100)) + geom_text(aes(x = DEGREE, y = Adj_R * 100 + 5, label = paste(round(Adj_R*100,2),"%",sep="")),size = 3)+ scale_x_continuous(breaks = seq(2,10, by = 1)) + ylab("Adj_R2") + theme_bw() F_DATA %>% select(DEGREE, TRAIN_MSE, TEST_MSE) %>% melt(id.vars = c("DEGREE")) %>% ggplot() + geom_point(aes(x = DEGREE, y = value, col = variable)) + geom_line(aes(x = DEGREE, y = value, col = variable)) + labs(col = "") + theme_bw() + theme(legend.position = "bottom") + xlab("Degree") + ylab("MSE") F_DATA %>% select(DEGREE, TRAIN_VAR, TEST_VAR) %>% melt(id.vars = c("DEGREE")) %>% ggplot() + geom_point(aes(x = DEGREE, y = value, col = variable)) + geom_line(aes(x = DEGREE, y = value, col = variable)) + labs(col = "") + theme_bw() + theme(legend.position = "bottom") + xlab("Degree") + ylab("Variation") 2 는 6차 항부터 급격하게 올라가는 것을 볼 수가 있습니다. 따라서 6차 항은 되어야 = i ( ) 형태의 관계를 잘 설명할 수 있는 편이라고 생각할 수 있습니다. S는 Train Set과 Test Set에 따라 추세가 다릅니다. 차수가 높아질수록 Train Set의 S는 감소하는 것을 알 수 있습니다. 하지만 Test Set의 MSE는 감소하다가 증가하는 것을 확인할 수 있습니다. 이는 Train Set은 기가 막히게 잘 맞추지만 새로운 데이터인 Test Set은 맞추지 못하는 OverFitting이 발생하였다고 볼 수 있습니다. a i n e 는 항차가 올라갈수록 대체로 증가하는 추세에 있는 것을 볼 수 있습니다. 여기서 고차 항의 회귀 모형의 단점이 제대로 드러납니다. 분석 모형이 유연할수록(항차가 높을수록) 회귀추정값의 분산은 높게 뛰기 마련입니다. 이는 회귀식에 의한 추정 값에 대한 신뢰구간이 길어진다는 의미이며, 결과에 대한 신뢰도가 떨어진다는 것을 의미합니다. 여기까지 비선형 회귀분석에 대해 알아보았습니다. ChB3. 범주형 자료분석 범주형 자료분석은 변수들이 이산형 변수일 때 주로 사용하는 분석입니다. 예를 들어, 두 제품 간의 선호도가 성별에 따라 연관이 있는지를 판단하고자 하는 경우, 각 집단 간의 비율 차이가 있는지 확인하기 위한 경우 등에 주로 사용합니다. 범주형 변수를 다룰 때에는 일반적으로 그 빈도를 세서 표를 작성하게 됩니다. 만약 두 변수의 범주가 교차되어 있다면 이 표를 분할표(contingency table)라고 부릅니다. 사실 범주형 변수를 요약하는 방법은 이러한 분할표 말고는 적당한 것이 없습니다. 분할표를 통해서 범주 별 비교를 하고 분할표를 기반으로 범주형 변수의 독립성, 동질성 검정 등의 카이제곱 검정을 하게 됩니다. 그만큼 분할표는 쉽지만 중요한 개념이며 로지스틱 회귀 모형 등으로 대표되는 일반화 선형모형을 해석하는 과정에서도 사용됩니다. A1. 비율의 비교 1. 비율의 비교 2x2 분할표를 통한 비율의 비교에 대해 다뤄보겠습니다. 두 범주형 변수 모두 두 가지 범주만을 갖는 이 항변 수일 때, 각 범주의 빈도를 이용해 2x2 분할표를 작성할 수 있으며, 이 분할표를 이용하면 여러 가지 방법의 범주별 비교를 할 수 있습니다. 예를 들어 단순하게 빈도의 크기를 비교할 수가 있고 한 변수의 각 범주 별다른 변수의 비율을 비교할 수도 있습니다. 우리는 이 중 대표적으로 상대위험도와 오즈비라는 두 개의 비율 비교 척도를 다룰 것이며 이 두 척도는 범주형 변수를 분석할 때 언제나 언급되는 스테디셀러입니다. 상대위험도(relative risk) 흔히 r.r이라 불리는 상대위험도는 한 변수의 범주 별다른 변수의 비율을 상대적으로 비교할 때 쓰이며 첫 범주에 속할 확률 추정량과 두 번째 범주애 속할 확률 추정량의 비로 정의됩니다. 또한 확률은 각 범주의 비율로 추정됩니다. 예를 들어 첫 번째 변수 가 어떤 시험의 결과(PASS, FAIL)이고 하고 두 번째 변수 가 학력(고졸, 대졸)이라고 했을 때 다음과 같은 표를 작성할 수 있습니다. 대졸 중 시험에 합격한 비율은 30 50 입니다. 고졸 중 시험에 합격한 비율은 15 40 입니다. 두 그룹의 상대위헙도 추정량( . ^ )은 30 50 15 40 로 1.6입니다. 해석을 하면 대졸의 경우가 고졸의 경우보다 시험에 합격한 비율이 60% 높다는 것을 알 수 있으며, 추정의 관점에서 해석하면 대졸자의 합격 확률이 고졸의 1.6배라고 볼 수 있습니다. 또한 상대위험도가 1에 가까울수록 두 변수 사이에 연관성이 없다는 뜻이며 0에 가까워지거나 커질수록 음 혹은 양의 관계를 갖는다는 의미입니다. 상대위험도는 매우 직관적인 비교 지표로 누구나 쉽게 구할 수 있고 쉽게 해석할 수 있다는 큰 장점이 있습니다. 오즈비(odds ratio) 상대위험도와 더불어 두 범주형 변수의 범주 별 비교에 자주 사용되는 척도로 오즈비라는 것이 있습니다. 오즈비는 오즈(성공 확률/실패 확률)의 각 범주 별 비로 정의되며 상대위험도보다 조금 더 유연한 특징을 보입니다. 성공 확률(관심 범주에 속할 확률)을라고 했을 때 오즈와 오즈비는 다음과 같이 표현할 수 있습니다. d s π − o r ( 1 − 1 ) ( 2 − 2 ) 상대위험도는 매우 직관적은 척도지만 한 변수의 수를 고정시킨 조사에서는 사용이 불가능하다는 단점이 있습니다. 오즈비는 이러한 경우에도 문제없이 사용될 수 있으며 대칭적으로 구해지기 때문에 반응 변수와 설명변수의 구별 없이 같은 값을 제시해 줍니다. 예를 통해 확인하겠습니다. 알코올중독과 심장질환의 연관성을 보기 위하여 심장질환을 갖고 있는 사람과 그렇지 않은 사람을 각각 50명, 100명씩 선정하여 알코올중독 여부와 비교한다고 했을 때, 분석 자는 상대위험도를 사용할 수 없습니다. 각 관측치가 독립적으로 랜덤하게 선택된 것이 아니고 심장질환 여부에 의해 정해진 비율 혹은 숫자에 따라 선정된 집단이기 때문입니다. 단적으로 전체 표본 중 심장질환자의 비율이 3 인 것은 미리 그렇게 정해 놓았기 때문이지, 실제로 3명 중 1명이 심장질환을 가지고 있다는 의미가 아닙니다. 이러한 경우 추정된 확률은 의미가 없게 되고 추정된 확률의 비를 이용하는 상대위험도 역시 의미를 잃게 됩니다. 그렇지만 오즈비는 이러한 제약에 유연합니다. 알코올중독자 중 심장질환의 추정된 오즈 ( d s x 1 ) 4 6 / = 2 입니다. 비알콜 중독자 중 심장질환의 추정된 오즈( d s x 0 )는 46 144 98 144 46 98 입니다. 오즈비 ( . ^ )는 d s x 1 d s x 0 4 2 46 98 98 23 입니다. 심장질환이 있을 오즈는 알코올중독자 집단이 비중 독자 집단의 약 4.26배인 것을 알 수 있습니다. 우리에게 익숙한 확률에 대한 지표가 아닌 오즈라는 생소한 척도를 이용해서 조금 낯설 수는 있으나 오즈비는 분할표에서 자주 사용되는 것은 물론이고 확률을 선형화하는 여러 통계 모형에서 사용되므로 익숙해질 필요가 있습니다. 상대위험도와 마찬가지로 두 변수가 연관이 없다면 오즈비는 1에 가까울 것이며 0에 가까워지거나 커질수록 밀접한 연관성을 보입니다. 또한 실패에 대한 오즈비는 성공에 대한 오즈비의 역수로 표현되며 같은 연관도를 나타냅니다. 즉, 심장질환이 있을 오즈가 아닌 심장질환이 없을 오즈를 이용하여 오즈비를 구하면 4.26의 역수인 0.2346이 나올 것이고 이는 같은 수준의 연관성을 의미합니다. A2. 카이 제곱 독립성 검정 2. 카이 제곱 독립성 검정 카이 제곱 독립성 검정은 두 범주형 변수가 독립적으로 분포하는지를 테스트하는 검정입니다. 이 역시 분할표에서 진행되며 일반적으로 2x2가 아닌 여러 범주를 갖고 있는 경우에 사용합니다. 카이 제곱 독립성 검정의 기본적 아이디어는 관측 빈도와 기대 빈도(두 변수가 독립일 때의 빈도)의 차이를 비교하는 것입니다. 이 방법론을 자세히 살펴보면 다음과 같습니다. 각 범주(셀)의 기대 빈도가 높다면(일반적으로 5를 기준으로 합니다), 정규분포 근사를 할 수 있습니다. 정규 근사가 가능하면 이를 이용해 카이 제곱 통계량을 얻을 수 있습니다. (10장 참고) 이 카이 제곱 통계량은 관측 빈도와 기대 빈도 차이의 변동을 정량화한 통계량입니다. 카이 제곱 통계량이 충분히 높다면 관측 빈도와 기대 빈도의 차이는 크다고 할 수 있습니다. 만약 관측 빈도와 기대 빈도의 차이가 충분히 크면, 두 변수가 독립적이지 않다는 결론을 내리게 됩니다. 예를 하나 보겠습니다. 기대 빈도는 두 변수가 통계적으로 독립이라는 귀무가설( 0 ) 하에 기대되는 빈도이고 이 귀무가설을 다른 방식으로 표현하면 0 π j π ⋅ π j 입니다. 위의 표를 이용하여 이 아이디어를 생각해 봅시다. i는 각 셀에 속할 확률입니다. 예를 들어 지역 3이면서 B 당을 지지할 확률은 23 이 됩니다. i 은 i 번 째 행에 속할 확률로 B 당을 지지할 확률은 2입니다. ⋅는 j 째 열에 속할 확률입니다. 지역 3에 속할 확률은 ⋅입니다. 만약 두 변수가 전혀 연관이 없다면 확률의 곱법칙에 의해 지역 3에 속하면서 B 당을 지지할 확률은 지역 3에 속할 확률과 B 당을 지지할 확률의 곱으로 표현될 것입니다. 그렇기 때문에 두 변수가 통계적으로 독립이라는 것은 i = i ⋅ ⋅ 과 동치입니다. 또한 i 은 i n 으로 추정되고 ⋅는 ⋅ n 은으로 추정됩니다. 즉, 각 행과 열의 빈도와 전체 빈도의 비율로 추정되는 것으로 볼 수 있습니다. 기대 빈도를 구하는 방법은 다음과 같습니다. 추정 i = ⋅ i = ⋅ i ⋅ ⋅ ( 정 ) n ( i n ) ( ⋅ n ) n ⋅ n j 이를 이용해 지역 3에 속하면서 B 당을 지지할 기대 빈도를 구해보면 약 161.44가 나옵니다. 이런 식으로 각 셀에 대한 기대 빈도를 구해 괄호로 표현하면 다음과 같고 각 셀의 기대 빈도는 충분히 커서 근사 가정을 만족하므로 카이제곱 검정을 진행할 수 있습니다. 위에서 말씀드렸듯이, 기대 빈도는 두 변수가 독립이라는 가정하에 구해진 빈도이므로 실제 관측 빈도와 기대 빈도의 차이가 크다는 것은 두 변수의 연관성 역시 크다는 것을 의미합니다. 이 아이디어를 기반으로 각 셀에서의 관측 빈도와 기대 빈도의 총량을 이용하면 두 변수의 독립성을 판단할 수 있을 것입니다. 단순히 차이를 합치게 되면 + / - 가 상쇄되므로 제곱을 해서 합치고 이는 카이제곱분포를 따르게 됩니다. 해당 식을 일반화하면 다음과 같습니다. = i 1 ∑ = b ( i − i) E j χ ( ( − ) ( − ) ) O o s r e f e u n i s : x e t d r q e c e a n m e o c t g r e f r o u n a i b e b n m 구해진 검정통계량 Q는 자유도가 (열 변수의 범주 - 1) (행 범주의 범주 - 1) 인 카이제곱 분포를 따릅니다. 만약 Q가 크지 않다면 실제 관측 빈도와 독립일 때의 기대 빈도의 차가 전체적으로 크지 않다는 것을 의미하고 두 변수가 독립이라는 귀무가설을 기각하지 못할 것입니다. 반대로 Q 가 매우 크다면 두 변수는 연관성이 있다는 것을 의미하고 귀무가설을 기각하게 될 것입니다. 자유도가 저런 형태를 띠는 이유는 전체 표본 수 이 고정되어 있기 때문입니다. n이 고정된 상태로 기대 빈도를 추정하면서 행의 합= , 열의 합=이라는 제약식을 갖게 되고 그 조합으로 구해지는 Q는 (열 변수의 범주 - 1) (행 범주의 범주 - 1)라는 자유도를 갖게 되는 것입니다. 이 방법을 이용하여 지역과 지지 정당이 독립인지에 대한 카이제곱 검정통계량을 구해보면 Q는 약 411.35가 되고 자유도는 (3-1)(4-1) = 6 이 됩니다. 이 경우 − a u는 매우 작아 두 변수가 독립이라는 귀무가설은 기각됩니다. A4. 로지스틱 회귀분석 4. 로지스틱 회귀분석 로지스틱 회귀분석(logistic regression analysis)은 일반화 선형모형(generalized linear model, GLM)이라 불리는 큰 범주의 통계 모형 모델링 방법에 속하는 방법입니다. 우선 GLM의 특징만 간단히 훑어보고 로지스틱 회귀 모형에 대해 다루겠습니다. GLM(Generalized Linear Model) GLM은 문자 그대로 선형적이지 않은 대상(비선형)을 선형적으로 '일반화'시킨 모형입니다. 선형화 시키는 이유는 여러 가지가 있을 수 있지만, 가장 대표적으로 선형모형에서만 사용할 수 있는 모형의 해석, 확장, 수정 등의 방법을 사용하기 위해서입니다. 비선형모형의 경우는 모형을 다루는 방법이 많이 제한될 뿐만 아니라 새로운 데이터에 민감하기 때문에 선형모형에 비해 덜 선호되는 경향이 있습니다. 그렇다면 로지스틱 회귀분석에서 선형화 시키는 대상은 무엇일까요? 바로 관심 범주에 속할 확률입니다. 확률은 일반적으로 예측자들에 따라 비선형 하게 분포되어 있고, 형태는 S자 형태가 되는 경우가 많습니다. 물론 처음부터 확률에 선형 라인을 적합시켜 선형회귀분석을 진행할 수도 있지만 이는 몇 가지 제약이 따릅니다. library(ggplot2) k = runif(n = 500, min = 2 , max = 4) K = c() P = c() P1 = c() for(i in k){ p1 = exp(-21.3 + 6.74*i) /(1 + exp(-21.3 + 6.74*i)) # error = runif(n = 1, min = -0.1, max = 0.1) error = 0 p = p1 + error p = ifelse(p < 0 ,0, p) p = ifelse(p > 1, 1, p) K = c(K, i) P = c(P, P) P1 = c(P1, P1) } ggplot(NULL) + geom_point(aes(x = K, y = P),col = 'royalblue', alpha = 0.2) + theme_bw() + scale_x_continuous(breaks = seq(2,4, by = 0.5)) + xlab("Predictor") + ylab("Prob") 위 그래프는 어떤 연속형 예측자에 따른 관심 범주에 속할 확률입니다. 예를 들어 알코올 섭취량과 비만일 확률은 이런 식으로 분포할 수 있습니다. 알코올 섭취가 많을수록 비만일 확률은 높아지지만 완전 선형적이라기보다는 약간의 커브가 존재하는 것입니다. 우선 여기에 일반적인 선형회귀 라인을 적합시켜 보겠습니다. ggplot(NULL) + geom_point(aes(x = K, y = P),col = 'royalblue', alpha = 0.2) + geom_smooth(aes(x = K, y = P),method = 'lm', col = 'grey20') + geom_h line(yintercept = c(0,1), linetype = 'dashed') + scale_x_continuous(breaks = seq(2,4, by = 0.5)) + theme_bw() + xlab("Predictor") + ylab("Prob") 선형 회귀선이 아주 비합리적이진 않습니다. 연속형 예측자가 증가함에 따라 확률 역시 증가하기 때문이죠. 또한 이런 선형식의 경우 위에서 배운 분산분석을 통한 모형의 적합도 검정부터 시작해서 기존에 회귀분석에서 사용하던 모든 분석을 진행할 수 있습니다. 그렇지만 이런 경우에는 구조적인 문제가 발생합니다. 바로 확률은 0과 1 사이의 값을 갖는 데 반해 회귀선은 경우에 따라 음의 값이나 1을 초과하는 예측값를 제시할 수도 있다는 것입니다. 영역을 표시하자면 아래 동그라미와 같은 구간입니다. ggplot(NULL) + geom_point(aes(x = K, y = P),col = 'royalblue', alpha = 0.2) + geom_smooth(aes(x = K, y = P),method = 'lm', col = 'grey20') + geom_h line(yintercept = c(0,1), linetype = 'dashed') + geom_point(aes(x = c(2.25,3.9), y = c(-0.05,1.05)),size = 10, shape = 1, col = 'red') + scale_x_continuous(breaks = seq(2,4, by = 0.5)) + theme_bw() + xlab("Predictor") + ylab("Prob") 세로축은 확률 값을 표현한 것인데, 빨간 동그라미는 확률이 가질 수 없는 값을 추정하고 있습니다. 위 데이터에서는 -4 이하의 점에서 -확률 값으로 추정되고 있지만, 이 회귀선을 이용하여 새 데이터를 예측해 보면 이보다 훨씬 많은 포인트가 잘못된 값으로 추정될 가능성이 있습니다. 또한 이러한 구조적인 문제로 확률의 특성을 이용한 기타 추가 분석 역시 불가능하게 됩니다. 그렇다면 이제 비선형적인 모형을 적합시켜보겠습니다. 아래 그래프는 S자 형태를 띠는 비선형적인 회귀곡선입니다. ggplot(NULL) + geom_point(aes(x = K, y = P),col = 'royalblue', alpha = 0.2) + geom_line(aes(x = K, y = P1),col = 'red', size = 2.5, alpha = 0.5) + geom_h line(yintercept = c(0,1), linetype = 'dashed') + scale_x_continuous(breaks = seq(2,4, by = 0.5)) + theme_bw() + xlab("Predictor") + ylab("Prob") 한눈에 보기에도 선형 회귀선보다는 훨씬 데이터에 잘 적용됨을 알 수 있고 구조적인 문제도 발생하지 않습니다. 그렇지만 위에서 말씀드린 대로 비선형 모델은 여러 가지 추가 분석에 제약이 있습니다. 이러한 제약을 극복하기 위해서 약간의 변환을 통해 이를 선형화하는 것이 로지스틱 회귀분석의 기본 아이디어입니다. 예측자가 주어졌을 때, 관심 범주에 속할 확률을 선형으로 예측하기 이해서는 ≤ x 1 의 제약을 ∞ l g ( x − x ) ∞ 의 형태로 변환을 해주어야 합니다. x π 1 π로 변환, 즉 d s 로 변환을 해주면, x − x 0 π 1 π <의 범위를 가지게 됩니다. 그 후 o 변환을 취해주면, 로그 함수의 특성에 따라 ∞ l g ( x − x ) ∞ 의 범위를 가지게 되는 것입니다. 우리는 관심 범주의 확률을 선형모형으로 예측하기 위해 순수 x 를 활용하는 것이 아니라, o ( x − x ) 를 활용할 것입니다. 이 변환을 o i 변환이라 부르며, o i 변환 값을 반응 변수 롤 하고 선형모델을 적합시킨 것을 로지스틱 회귀분석이라고 합니다. 선형화를 위해 아래의 식을 고려해 보겠습니다. 여기서 x 는 설명 예측자가 주어졌을 때의 관심 범주에 속할 확률입니다. x e p ( 0 β x ) + x ( 0 β x ) 이는 일반 선형회귀에서의 x β + 1 와 같이 직선의 관계를 나타내는 함수에 대응하는 것으로, 선형적인 관계가 아닌 성공 확률 x 와 설명 예측자와의 관계를 S자 모양으로 표현해 주는 함수입니다. 또한 선형화를 위해 위의 함수를 이용하여 선형식 모양으로 정리를 하면 다음과 같습니다. o i ( x ) l g ( x − x ) β + 1 l g ( x − x ) 와 같은 형태를 x 에 대한 로짓함수라고 부르며 o i ( x ) 와 같이 표현합니다. 이 로짓함수를 이용하면 우변을 선형식으로 표현할 수 있습니다. 이것이 처음에 말씀드렸던 확률과 예측자의 비선형적 관계를 선형식으로 일반화하는 과정입니다. 또한 로지스틱 회귀 모형과 같은 GLM에서는 절편과 기울기를 일반적인 회귀분석과 다르게 최소 제곱 추정 법이 아닌 최대 가능 도도 추정 법(method of maximum likelihood estimation)이라 불리는 방법에 의해 추정합니다. 이는 다음 장에서 다루겠습니다 이제 구체적으로 로지스틱 모형을 살펴봅시다. 기본적인 로지스틱 모형은 반응 값이 이 항변 수임을 가정합니다. 잘 생각해 보면, 위에서 계속 다루었던 확률은 주어진 값이 될 수 없다는 것을 떠올리실 수 있을 겁니다. 확률은 측정될 수 있는 것이 아니기 때문이죠. 설명을 위해 보여드린 그래프의 확률 값 역시 마찬가지입니다. 로지스틱 모형에서의 확률은 이항 반응 값으로 측정된 질적 자료를 이용해 추정됩니다. 예를 들어 알코올 섭취량과 비만일 확률의 관계를 알기 위한 조사를 할 때, '비만일 확률' 자체는 측정할 수 없고 '비만 여부'라는 이항 반응 값을 측정해 그 확률을 추정한다는 것이죠. 이런 이항 반응 값(관심 범주 = 1)와 예측자간의 산점도를 그리면 다음과 같습니다. PG = ifelse(P1 < 0.5,0, 1) K1 = K + runif(n = length(K),min = -0.5, max = 0.5) ggplot(NULL) + geom_point(aes(x = K1, y = PG),col = 'royalblue') + geom_line(aes(x = K, y = P1),col = 'red', size = 2.5, alpha = 0.5) + theme_bw() + xlab("Predictor") + ylab("Prob") + scale_x_continuous(breaks = seq(2,4, by = 0.5)) 관심 범주 아니면 비 관심 범주로 조사된 세로 축 반응 변수는 0 아니면 1의 값만 갖습니다. 관심 있는 범주면 1을 부여하고 그렇지 않으면 0을 부여해 구별해 놓은 것이지요. 그에 비해 예측 자는 연속적으로 분포함을 알 수 있습니다. 산점도를 보면 직관적으로 예측자 값이 큰 값을 가지면 관심 범주에 속할 확률이 크고 작으면 비 관심 범주에 속할 확률이 크다는 것을 확인할 수 있습니다. 문제는 예측자가 겹치는 부분입니다. 하늘색 선을 기준으로 가장 왼쪽, 오른쪽 영역은 겹치는 부분이 없어 어렵지 않게 범주를 예측할 수 있지만 두 범주가 공존하는 가운데 부분은 예측자가 겹치게 됩니다. 이 부분이 확률을 추정하여 로지스틱 회귀곡선을 그렸을 경우 변곡점이 생기는 영역이고 추정된 확률이 0.5에 가까운 애매한 값으로 표현되는 곳입니다. 즉, 예측하기 어려운 영역이라고 할 수 있습니다. 로지스틱 회귀곡선을 적합시켜 보겠습니다. ggplot(NULL) + geom_point(aes(x = K1, y = PG),col = 'royalblue') + geom_vline(xintercept = c(2.7,3.6),linetype = 'dashed', col = 'red') + geom_text(aes(x = c(2,4), y = c(0.5,0.5)),label = c("비관심범주","관심 범주"),col = 'red', size = 5) + geom_text(aes(x = 3.1, y = 0.5), label = "공존", col = 'royalblue', size = 5) + theme_bw() + xlab("") + ylab("") + scale_x_continuous(breaks = seq(1,5, by = 0.5)) 적합된 회귀곡선은 다음과 같습니다. ^ = x ( 21.3 6.74 ) + x ( 21.3 6.74 ) l g ( ^ 1 π x ) − 21.3 6.74 선형적으로 추정된 o i ( ^ ) 는 꼭 연속형 예측자뿐 아니라 범주형 예측 자도 가능하고 혼합된 형태도 가능합니다. 또한 모형에 대한 해석은 선형적으로 바라보아도 상관은 없으나 로짓 값이 직관적이지 않아 일반적으로 오즈비를 통해 하게 됩니다. 예를 들어 위 식에서 예측자의 기울기 6.74는 '예측자가 한 단위(1) 증가했을 때의 성공할 오즈 '가 됩니다. 이것은 두 모형의 차를 통해 확인할 수 있습니다. 예측자가 인 모형과 한 단위(1) 증가하여 + 인 모형의 차를 봅시다. 아래 식에서는 추정된 확률의 구별을 위해 예측자가 인 경우에는 x, + 인 경우는 x 1로 표현하겠습니다. [ 21.3 6.74 ( + ) ] [ 21.3 6.74 ( ) ] 6.74 ⇔ [ o ( ^ + 1 π x 1 ) ] [ o ( ^ 1 π x ) ] l g [ ( ^ + 1 π x 1 ) ( ^ 1 π x 즉, 로지스틱 회귀 모형에서의 기울기는 예측자가 1 증가했을 때의 로그 오즈비 추정량이고 기울기 x [ 울 ] 는 예측자가 한 단위 증가했을 때의 오즈비 추정량입니다. 위의 예에서 적용해 보면 예측자가 한 단위 증가할 때 관심 범주에 속할 오즈가 x ( 6.74 ) 846 배가 된다는 것을 알 수 있습니다. 이를 응용하면 단위를 조정해서 확인할 수도 있습니다. 예를 들어 위에서 다룬 예제는 예측자의 범위가 매우 작으므로 1이 아닌 0.1이 증가했을 때의 오즈비를 확인하고 싶을 수 있습니다. 로그 오즈비는 [ 21.3 6.74 ( + 0.1 ) ] [ 21.3 6.74 ( ) ] 0.674 이 되겠고 오즈는 x ( 0.674 ) 1.96 이 됩니다. 즉, 예측자가 0.1 증가하면 관심 범주에 속할 오즈가 1.96배 됨을 알 수 있습니다. A5. 로지스틱 회귀분석(R Code) 5. 로지스틱 회귀분석(R Code) 로지스틱 회귀분석도 결국은 회귀분석이기에 돌리는 방법은 비슷하지만 일반적인 회귀분석보다는 좀 까다롭습니다. 데이터는 역시 인사관리 데이터(HR)를 이용하여 진행하겠습니다. 직원들의 이직 여부를 판단하는 분류 모형을 만들어 통계적으로 검정하고자 합니다. 이직에 영향을 미치는 변수들의 기울기는이다 0 이에 향 미는 수의 울 는 이. 1 n t 0 로지스틱 회귀분석 Logistic = glm(left ~ satisfaction_level + salary + time_spend_company, data = HR, family = binomial()) 로지스틱 회귀분석은 일반화 선형 모형이기 때문에 glm() 명령어로 진행합니다. family = binomial()은 일반화 선형 모형에서는 다양한 분포의 종속 변수에 적용하기 때문에, 종속 변수가 어떤 분포를 따르고 있는지 옵션을 주는 것입니다. left는 이직 여부를 나타내는 이항 변수이므로 이항 분포를 따르고 있습니다. 그러므로 binomial()을 설정해 줍니다. summary(Logistic) Call: glm(formula = left ~ satisfaction_level + salary + time_spend_company, family = binomial(), data = HR) Deviance Residuals: Min 1Q Median 3Q Max -1.8628 -0.6774 -0.4666 -0.1781 2.7644 Coefficients: Estimate Std. Error z value Pr(>|z|) (Intercept) 0.48069 0.07532 6.382 1.75e-10 *** satisfaction_level -3.72386 0.08852 -42.069 < 2e-16 *** salarymedium -0.53427 0.04436 -12.044 < 2e-16 *** salaryhigh -1.98592 0.12461 -15.938 < 2e-16 *** time_spend_company 0.21159 0.01418 14.922 < 2e-16 *** --- Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 (Dispersion parameter for binomial family taken to be 1) Null deviance: 16465 on 14998 degrees of freedom Residual deviance: 13597 on 14994 degrees of freedom AIC: 13607 Number of Fisher Scoring iterations: 5 결과표 해석은 회귀분석에서 했던 것과 같습니다. 또한 Deviance, AIC 값은 다음 장에서 설명하도록 하겠습니다. 여기서 주목해야 되는 점은 Dummy variable(가변 수)로 변환되어 모형에 투입된 salary 변수의 기울기 해석입니다. Dummy variable은 범주형 변수가 회귀 모형에 투입될 때 분석에 맞게 변환 된 변수입니다. 성별(Male, Female) 변수를 회귀 모형에 투입하기 위해 Dummy variable로 변환시켜 보겠습니다. 더미 변수 변환은 먼저 하나의 수준을 기준점(reference)으로 정하는 것부터 시작합니다. 여기 예시에서는 Male을 기준점으로 해서 Male 일 때는 D_1이 0을 가지고 Female에 해당될 때는 1을 가지도록 변환했습니다. 이 변수를 모형에 투입하면 다음처럼 해석합니다. i = 0 b D - Male일 경우 : i = 0 - Female일 경우 : i = 0 b Female일 경우 Male 일 때보다 i 가 1 만큼 증가한다는 의미를 가지고 있습니다. 이렇게 기준점을 기반으로 해석을 진행합니다. 다음으로는 salary 변수처럼 3가지 수준을 가지고 있을 때는 어떻게 진행하는지 보도록 하겠습니다. R에서는 기본적으로 Factor 변수가 모형에 들어오면 자동으로 Dummy variable로 변환해서 결괏값을 출력합니다. 기준점은 첫 번째로 인식된 수준입니다. 기준을 바꿔주고 싶다면 factor 지정을 해주시면 됩니다. HR a a y f c o ( R salary , levels = c('low','medium','high')) 분석 전에 위와 같은 명령어를 통해 salary 변수의 level 순서를 ‘low’, ‘medium’, ’high’순으로 지정해 줌으로써 low가 자동으로 기준점이 된 것입니다. 분석 결과 R에서 제시된 로지스틱 회귀식을 정리하면 다음과 같습니다. o : o ( ^ 1 π x ) 0.48 3.72 S t s a t o l v l 0 + 0.22 t m d u : o ( ^ 1 π x ) 0.48 3.72 S t s a t o l v l 0.53 h g : o ( ^ 1 π x ) 0.48 3.72 S t s a t o − 1.98 + 0.22 t m 기준점인 low 일 때는 medium & high에 해당되는 회귀 계수는 모두 0이 됩니다. medium 일 때는 salarymedium의 회귀 계수인 0.53 이 남아 있어, logit 값이 -0.53만큼 낮아집니다. high 집단에 속할 때는 low 집단에 비해 이직을 할 logit 값이 1.98 만큼 감소합니다. 나머지 satisfaction_level은 증가할수록 이직할 logit은 내려가게 되고, i e s e d c m a y 는 증가할수록 이직할 logit은 증가하는 것을 의미합니다. 각 변수의 계수에<NAME> 변환을 해주면 해당 변수의 변화에 따른 오즈비 역시 구할 수 있습니다. 모형의 성능 평가 회귀분석에서는 2 를 통해 모형의 성능을 평가하지만, 일반적으로 로지스틱 회귀분석에서는 다른 방법을 사용하게 됩니다. 그 방법은 분류 모형이 실제로 얼마나 맞췄는가를 평가하는 것입니다. 그러기 위해서는 만들어진 로지스틱 회귀 모형에 데이터를 집어넣어, 확률을 추정하고 그에 따른 분류를 해야 합니다. Log_odds = predict(Logistic, newdata = HR) Probability = predict(Logistic, newdata = HR, type = 'response') predict()는 만들어진 모형에 데이터를 넣어 추정 값을 계산하는 방식입니다. type 옵션이 없으면 predict을 통해 o ( ^ 1 π x ) 이 계산이 됩니다. type = 'response' 옵션을 주면 predict을 통해 ^ 가 계산이 됩니다. 즉, 우리가 관심이 있는 값은 직원들이 이직을 할 확률 ^ 이기에 옵션을 준 값으로 계산을 해야 합니다. 그다음으로는 계산된 ^를 가지고 이직 여부를 판단해야 됩니다. 예를 들어 이직할 확률이 0.5보다 큰 경우에는 이직으로 판단, 나머지는 이직을 하지 않는 집단으로 분류합니다. 여기서 확률을 구분 짓는 값을 cut-off value라고 합니다. PREDICTED_C = ifelse(Probability > 0.5 , 1 , 0) PREDICTED_C = factor(PREDICTED_C, levels = c(1,0)) 다음처럼 ifelse() 문을 이용하여 cut-off value에 따라 분류를 진행해 줍니다. 그다음으로는 실제 값과 모델에 의한 분류 결과를 비교해야 합니다. # install.packages(c("caret","e1071")) library(caret) HR$left = factor(HR$left, levels = c(1,0)) confusionMatrix(PREDICTED_C, HR$left) Confusion Matrix and Statistics Reference Prediction 1 0 1 947 872 0 2624 10556 Accuracy : 0.7669 95% CI : (0.7601, 0.7737) No Information Rate : 0.7619 P-Value [Acc > NIR] : 0.07635 Kappa : 0.2272 Mcnemar's Test P-Value : < 2e-16 Sensitivity : 0.26519 Specificity : 0.92370 Pos Pred Value : 0.52062 Neg Pred Value : 0.80091 Prevalence : 0.23808 Detection Rate : 0.06314 Detection Prevalence : 0.12127 Balanced Accuracy : 0.59444 'Positive' Class : 1 실제 값과 모델에 의한 분류 값을 비교하는 테이블을 Confusion Matrix라고 합니다. True Positive & True Negative는 모형 예측값이 실제 값을 맞춘 경우에 해당됩니다. False Negative & False Positive는 모형 예측값이 실제 값을 맞추지 못한 경우에 해당됩니다. Accuracy : P T T + P F + N : 전체 정확도를 의미합니다. Sensitivity(민감도) : P P F :실제 Positive 중에서 모형이 Positive를 맞추었는가에 대한 지표입니다. Specificity(특이도) : P P T : 실제 Negative 중에서 모형이 Negative를 맞추었는가에 대한 지표입니다. 전체 정확도만 보는 것이 아니고 민감도 및 특이도를 보는 이유는 다음과 같습니다. 극단적인 결과지만, 분석을 잘못 돌린 경우 이러한 분석 결과가 나올 때가 종종 있습니다. 이 분석 결과에 따르면 Accuracy는 98%로 매우 높습니다. 하지만 Specificiy는 0.1도 되지 않습니다. 이러한 분석 모형은 크게 의미가 없습니다. 모형이 데이터를 Neagtive로 분류하지 못하기 때문입니다. 각 산업 군마다 중요한 부분이 다릅니다. 예를 들어 병원에서 환자의 질병을 판단하는 분류 모형을 만들어 해당 모형의 정확도를 계산하는 경우에, False Positive : 실제로 Negative인데 Positive로 오 분류한 경우 (병이 없는데 병이 있다고 분류) False Negative : 실제로 Positive인데 Negative로 오 분류한 경우 (병이 있는데 병이 없다고 분류) 질병을 발견 못하는 실수는 돌이킬 수가 없기에, 병원에서는 False Negative가 False Positive가 더 중요한 값일 수 있습니다. Confusion Matrix의 결과를 통해 Accuracy, Sensitivity, Specificity의 값을 확인할 수가 있습니다. 여기서 하나 주의할 점은, 위에서 cut-off value를 0.5로 하여 분류했다는 것입니다. 이 cut-off value가 중요한 이유는 그 값에 따라 분류가 천차만별이기 때문입니다. 그렇기에 모든 cut-off value를 고려하여 결괏값의 변화를 살펴봐야 하는데, 그 방법을 ROC curve라고 합니다. Roc Curve library(pROC) HR$left = factor(HR$left, levels = c(0,1)) ROC = roc(HR$left, Probability) plot.roc(ROC, col="royalblue", print.auc=TRUE, max.auc.polygon=TRUE, print.thres=TRUE, print.thres.pch=19, print.thres.col = "red", auc.polygon=TRUE, auc.polygon.col="#A0A0A0") Roc Curve의 y 축은 Sensitivity이며, x축은 Specificity입니다. X축이 1 ~ 0 순서로 그려져 있는 것을 주의하시기 바랍니다. Roc Curve는 cut off value의 값에 따라 Sensitivity와 Specificity의 변화량을 나타낸 그래프입니다. AUC는 Area under curve의 미로, 곡선에 해당되는 면적을 나타냅니다. AUC 값이 높을수록 바람직한 모형이라고 할 수 있습니다. 가장 좋은 결괏값을 나타내는 cut off value 값 및 sensitivity, specificity 역시 추가할 수 있습니다. 이렇게 로지스틱 회귀분석의 이론 및 실습방법을 다루었습니다. 분류 모형은 이런 로지스틱 기법이 기본 아이디어이긴 하지만, 정확한 분석을 위해서는 Train / Test SET을 통한 타당성 검증, 좋은 변수 선택법 및 기계학습 알고리즘과의 비교 분석 등이 함께 되어야 합니다. 다음 장에서부터는 해당 내용을 다루도록 하겠습니다. ChB4. 기초통계 이론 3단계 최소제곱법을 사용하는 일반적 회귀분석과 달리 GLM에서는 가정된 분포하에서 모형을 추정합니다. 이를 최대 가능도 법이라고 하는데 가능도(likelihood)라는 가능성의 개념을 이용한 추정 방법입니다. 이 가능 도라는 개념은 분포 가정만 합리적이라면 매우 파워풀하고 유용한 개념으로 통계 전체를 아우르고 있습니다. 이번 장에서는 가능도에 대한 개념과 가능도를 이용한 변수 선택(모형 선택) 방법을 다루겠습니다. A1. 가능 도와 가능도 함수 1. 가능 도와 가능도 함수 가능도(likelihood)는 가능성 혹은 공산이라는 의미를 갖고 있습니다. 조금 더 풀어서 말씀드리면 가정된 분포에서 주어진 데이터가 나올 가능성이라고 할 수 있습니다. 예를 들어 ( , 2 ) 라는 정규분포를 따를 것으로 가정되는 모집단에서 추출된 표본들을 얻었을 때, 그 표본 값들과 정규분포의 확률함수를 이용하면 평균이이고 분산이 2 가 맞을 가능성을 확인할 수 있습니다. 이 가능성이라는 것은 결국 주어진 표본들에서 확률함수를 통해 산출되므로 조건부 확률 값이라는 관점으로 볼 수 있고 데이터가 주어진 모든 환경에 적용할 수 있습니다. 가능 도라는 개념을 이해하기 위해서는 확률과의 차이점을 이해하면 쉽습니다. 간단한 동전 던지기 실험을 10번 진행했을 때 앞면이 4번 나왔습니다. 이런 경우를 가정했을 때 확률 : 앞면이 나올 확률은 0.4입니다. 즉, 확률은 확률 실험의 결과를 집계한 것이라고 볼 수 있습니다. 가능도 : 동전을 10번 던졌을 때 앞면이 나올 확률에 따라서 앞면이 4번 나올 가능성입니다. 여기서 가능도 값을 계산하는 함수를 가능도 함수(Likelihood function)라고 합니다. 동전 던지기 실험을 기반으로 가능도 함수를 계산하면 다음과 같습니다. 동전 던지기 실험은 이항분포를 따르니 확률 질량 함수( m)는 C p ( − ) −입니다. 위의 표처럼 앞면이 나올 확률에 따라 10번 중 4번이 앞면이 나올 가능성을 구한 것이 가능도 함수(Likelihood function)라고 합니다. 가능 함수를 계산하기 위해서는 가정된 분포, 조사된 표본이 필요하고 조건부적 성격을 제외하면 확률함수와 정확히 동일합니다. 다만 관점을 달리는 것뿐입니다. 확률함수에서 확률변수는 이미 조사되어 주어진 값이 되고 정해져있던 모수가 함수의 인수가 됩니다. 모집단의 확률함수가라고 알려져 있고 그 확률함수의 모수를 라고 합시다. 그렇다면 이 확률함수를 ( ; ) 라고 표현할 수 있을 것입니다. 이 모집단에서라는 표본이 나왔다고 하면 가능도 함수 은 다음과 같이 정의됩니다. ( ; ) f ( | ) 이는 표본이 한 개가 아니었을 때도 마찬가지입니다. 독립적으로 추출된 표본이 1 y, y이라고 하면 각 표본들의 모집단의 확률함수는 전부 ( ; ) 가 될 것이고 독립적으로 추출되었으므로 확률의 곱법칙에 의해 결합 확률함수를 구할 수 있습니다. 즉, i f ( i θ ) 와 같이 표현됩니다. 이를 이용하면 개의 표본에서의 우도 함수도 어렵지 않게 정의할 수 있습니다. ( ; 1 y, , n ) ∏ = n ( | 1 y, , n ) 또한 실제로 활용할 때는 계산과 편의를 위해 일반적으로 가능도 함수에 로그함수를 씌워 사용하게 됩니다. 이를 로그 가능도 함수(log-likelihood function)라고 부르며 소문자로 표현합니다. 로그함수는 단조증가함수이기 때문에 가능도 함수 값이 커지면 로그 가능도 함수 값도 항상 커집니다. A2. 최대 가능도 추정량(Maximum Likelihood Estimation, MLE) 2. 최대 가능도 추정량(Maximum Likelihood Estimation, MLE) 로지스틱 회귀 모형을 다룰 때, 로지스틱 모형과 같은 GLM은 최소제곱법이 아닌 최대 가능도 추정 법을 이용한다고 했습니다. 이 최대 가능도 추정량에 의해 추정된 추정량을 최대 가능도 추정량(maximum likelihood estimator)이라고 부르며 흔히 줄여서 MLE라고 표현합니다. MLE는 역시 가능도 함수의 개념만 잘 알고 있다면 어렵지 않은 개념입니다. 가정된 확률분포의 모수 가 될 수 있는 수많은 후보들 중 로그 가능도 함수(혹은 우도 함수)를 최대로 하는 후보를 모수의 추정량으로 선택하는 방법입니다. 로그 가능도 함수 값이 크다는 것은 그만큼 주어진 데이터에 적합하는 것을 의미하기 때문에 MLE는 충분히 합리적인 추정량입니다. GLM에서도 기울기와 절편 역시 이런 식으로 가정된 분포와 주어진 데이터에서 로그 가능도 함수를 가장 크게 하는 값으로 적합시킵니다. 이렇게 구해진 L는 이 많아짐에 따라 통계검정에 사용되는 정규 근사가 가능하며 그 외에도 효율성, 불편성이라는 좋은 성질들이 생기게 되어 매우 자주 사용되는 방법입니다. 앞서 다룬 동전 던지기 실험 예시를 들면 10번 중 4번이 나올 가능성이 가장 높은 확률은 0.4일 때입니다. 이렇게 L는 0.4가 됩니다. A3. 가능도에 따른 변수 선택법 3. 가능도에 따른 변수 선택법 위에서 다뤘다시피 로그 가능도 함수 값은 주어진 데이터에 대한 가능성의 척도이고 '적합도(goodness of fit)'의 관점으로 바라보면 MLE는 주어진 데이터에 대한 적합도를 높게 하는 추정량이라고 말씀드렸습니다. 이는 모형에도 그대로 적용됩니다. GLM은 모형의 모수를 최대 가능도 법으로 구하기 때문에 주어진 데이터에 대한 적합도가 더 높을수록 더 높은 로그 가능도 함수 값을 갖게 됩니다. 이는 단순히 말해서 로그 우도 함수 값이 높을수록 추정된 직선 혹은 곡선이 데이터들을 가깝게 지나간다는 의미입니다. 그렇기에 선택된 모형마다 로그 가능도 값은 다 다를 것이고 모형 적합에 사용된 예측 자마다 도 전부 다를 것입니다. 이를 이용하면 어떤 모형을 적용할지 예측자의 조합별로 가장 최적의 모형을 선택할 수도 있습니다. 그렇지만 로그 가능도 함수 값이 올라가는 것만 보고 무조건 좋은 모형이라고 판단할 수는 없습니다. 그 이유는 바로 변수가 추가되면 항상 높아지는 로그 가능도 함수의 구조 때문입니다. 로그 가능도 함수는 예측자가 늘어날수록 낮아지지는 않고 항상 증가합니다. 다만 영향도에 따라 더해지는 값이 다를 뿐입니다. 그렇기 때문에 각 예측자가 추가되었을 때 증가되는 로그 가능도 함수 값이 유의미한지를 보아야 합니다. 그 이유는 유의한 증가를 보여주지 못함에도 불구하고 예측자를 추가하는 것은 굳이 필요 없는 추정을 한 번 더 하는 것이기 때문입니다. 불필요한 추정과 다른 예측자와의 관계를 고려하여 모형은 최대한 간단한 것이 좋습니다. 이를 모형의 모수 절약의 원칙이라 부릅니다. 로그 가능도 함수 값을 이용하여 모형을 비교할 수 있는 척도는 여러 가지가 있습니다. 대표적으로 이탈도(deviance)라고 불리는 두 모형의 로그 가능도 함수 값의 차이가 유의한지 보는 것과 로그 가능도 함수 값과 모형에 사용된 모수의 수를 동시에 고려한 AIC가 있습니다. 이 중에 많이 사용되는 AIC에 대해 다루겠습니다. AIC는 로그 가능도 함수 값이 높으면 가산점을 주고 모형에 사용된 모수가 많으면 페널티를 주는<NAME>으로 만들어진 척도로 작으면 작을수록 바람직한 모형이라고 판단합니다. 정리하면 다음과 같습니다. I = 2 ( o l k l h o − u b r f a a e e s n o 예를 들어, 2개의 모형 모수를 이용한 모형의 로그 가능도 함수 값이-16이고 4개의 모수만을 이용한 모형의 로그 가능도 함수 값은 -15이라고 했을 때 각 모형의 AIC는 각각 36과 38입니다. 비록 로그 가능도 함수 값은 두 번째 모형이 더 컸지만 모형에 사용된 모수가 더 많아 첫 번째 모형애 비해 바람직하지 않다는 판단을 할 수 있습니다. AIC를 평가하는 절대적인 기준은 없습니다. 오직 모형 비교 통시에만 활용이 가능한 척도입니다. 이러헌 deviance 혹은 AIC를 이용하면 각각의 예측자를 추가했을 때 그 예측자가 과연 필요한 것인가를 판단할 수 있습니다. 이를 변수 선택이라 하며 그 방법으로 크게 3가지가 있습니다. 전진 선택법(Forward) 전진 선택법이라고도 불리는 포워드 방법은 기본 모형(basic model)에서부터 가장 큰 영향을 보여주는 예측자를 차례대로 모형에 넣어서 그 유의미함을 판단한는 방법입니다. 여러 과정을 거친 후 추가된 예측자가 더 이상 유의하지 않다면 제거 후 포워드 방법을 멈추게 됩니다. 후진 제거법(Backward) 후진 제거법인 백 워드 방법은 포워드와는 반대로 가장 복잡한 모형(full model)에서 시작으로 가장 유의미하지 않는 예측 자부터 차례대로 제거해 나갑니다. 여러 과정을 거친 후 제거된 예측자가 유의미한 것으로 판단되면 추가 후 백 워드 방법을 멈추게 됩니다. 단계별 선택법(Stepwise) 스텝 와이즈는 두 방법의 단점을 보완한 방법으로, 전진 선택을 하면서 각 단계마다 후진 제거를 할 것인지 체크하게 됩니다. 포워드와 백 워드는 한 번 추가되거나 제거된 예측자에 대해서는 더 이상 신경 쓰지 않는 반면 스텝 와이즈 방법은 새로운 예측자가 들어갔을 때 전 단계에서 모형에 포함된 예측자가 무의미해진다면 제거할 수 있습니다. 이는 예측자 사이의 관계 때문으로 원래는 유의했던 예측자가 다른 예측자가 포함됨에 따라 그 영향도가 바뀔 수 있다는 데에 착안해 고안된 방법입니다. 변수 선택법을 R에서 구현하는 방법은 다음과 같습니다. x1 = runif(n = 1000, min = -10, max = 10) x2 = runif(n = 1000, min = -10, max = 10) x3 = runif(n = 1000, min = -10, max = 10) x4 = runif(n = 1000, min = -10, max = 10) x5 = runif(n = 1000, min = -10, max = 10) y = 0.1 * x1 - 0.7 *x3 + runif(n = 1000, min = -1, max = 1) Reg = step(lm(y ~ x1 + x2 + x3 + x4 + x5),direction = "backward") Start: AIC=-1046.68 y ~ x1 + x2 + x3 + x4 + x5 Df Sum of Sq RSS AIC - x4 1 0.2 347.1 -1048.14 - x2 1 0.4 347.3 -1047.52 - x5 1 0.6 347.6 -1046.83 <none> 346.9 -1046.68 - x1 1 314.5 661.4 -403.35 - x3 1 16126.2 16473.1 2811.73 Step: AIC=-1048.14 y ~ x1 + x2 + x3 + x5 Df Sum of Sq RSS AIC - x2 1 0.4 347.5 -1048.98 - x5 1 0.6 347.7 -1048.33 <none> 347.1 -1048.14 - x1 1 314.4 661.5 -405.31 - x3 1 16131.5 16478.6 2810.06 Step: AIC=-1048.98 y ~ x1 + x3 + x5 Df Sum of Sq RSS AIC - x5 1 0.6 348.1 -1049.16 <none> 347.5 -1048.98 - x1 1 316.3 663.8 -403.72 - x3 1 16147.5 16495.0 2809.06 Step: AIC=-1049.16 y ~ x1 + x3 Df Sum of Sq RSS AIC <none> 348.1 -1049.16 - x1 1 315.9 664.0 -405.49 - x3 1 16152.1 16500.2 2807.37 summary(Reg) Call: lm(formula = y ~ x1 + x3) Residuals: Min 1Q Median 3Q Max -1.02878 -0.51611 -0.01759 0.51527 1.02430 Coefficients: Estimate Std. Error t value Pr(>|t|) (Intercept) -0.001265 0.018693 -0.068 0.946 x1 0.097125 0.003229 30.076 <2e-16 *** x3 -0.701708 0.003263 -215.074 <2e-16 *** --- Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 Residual standard error: 0.5909 on 997 degrees of freedom Multiple R-squared: 0.979, Adjusted R-squared: 0.9789 F-statistic: 2.322e+04 on 2 and 997 DF, p-value: < 2.2e-16 lm() 명령어에 step()을 덮어주면 자동으로 변수 선택법에 따라 변수 선별을 진행합니다. 변수 선택법은 필요한 변수만 뽑아주는 매우 효과적인 방법이지만, 변수들 간의 선형 관계가 존재하는 다중공 선성을 통제할 수는 없습니다. 다음 장에서는 고차원에서 다중공 선성을 제어하며 차원 축소를 하는 방법에 대해 다루도록 하겠습니다. A4. 주성분 분석 4. 주성분 분석 대부분의 통계분석은 예측자들이 서로 독립이라는 기본적인 가정을 가지고 있습니다. 그렇기 때문에 예측자를 '독립변수'라고 표현하기도 하며 각 예측자들의 통계적인 분포는 고려하지 않습니다. 그런데 실제로는 그렇지 않은 경우가 대부분입니다. 경우에 따라 예측자들은 크고 작은 관계를 가지고 있고 그 정도가 심하면 분석 결과를 신뢰할 수 없는 상황에 놓이게 됩니다. 이것을 다중공 선성(multicollinearity)이라 부르며 다중공 선성이 존재함에도 불구하고 모형을 적합하게 되면 각 예측자의 기울기의 분산이 비정상적으로 높아지는 등의 문제가 발생할 수 있습니다. 이는 예측자가 많아질수록 더 큰 문제로 다가오는데, 예측자가 두 개인 경우, 서로에 대한 상관관계만을 갖지만 예측자가 늘어날수록 그 조합에 따라 매우 많은 상관관계를 고려해야 하기 때문입니다. 이 문제를 해결하기 위한 방법으로는 여러 가지가 있지만 그중 가장 대표적으로 사용되는 것이 주성분 분석(principal component)입니다. 주성분 분석은 예측자의 선형 조합을 통하여 서로 독립적인 인공 변수들을 만들어내는 방법으로, 통계 분석에 사용되는 가장 이상적인 변수를 생산해낸다는 점에서 매우 유용한 방법이라고 할 수 있습니다. 또한 이 과정에서 변수들이 가지고 있는 파워를 소수의 인공 변수로 몰아주어, 분석에 사용되는 변수를 줄여주는 효과를 볼 수 있습니다. 이를 '차원 축소'라고 표현하며 다중공 선성과 더불어 통계 분석에서 아주 중요하게 취급되는 주제입니다. 이번 챕터에서는 이 두 가지 관점에서 주성분 분석의 방법론을 다루도록 하겠습니다. 왼쪽의 그래프를 보면 1 X라는 변수가 높은 상관관계가 있음을 알 수 있고 이러한 상관성이 다중공 선성의 일이 킬 수 있다는 것을 상술하였습니다. 같은 포인트를 유지하면서 상관성을 무시하기 위해서는 새로운 축이 필요합니다. 우측의 그래프를 보면 새로운 축 1 P에서는 데이터가 상관성을 잃습니다. 이런 식의 직교 회전은 원 변수들의 선형결합을 통해 이루어지며, 선형결합의 계수는 변수들의 공분산(상관성)의 구조를 분해하여 얻어지는 고유벡터(eigen vectors) 들에 의해 결정됩니다. 직교 회전을 하게 되면 두 변수는 통계적으로 독립이 되며 다중공 선성의 문제를 완벽히 해결할 수 있습니다. 주성분 분석은 이러한 방식으로 직교하는 새 축을 만들어내는 것이 목표입니다. 위 그래프는 두 개의 변수에 대한 축 회전을 표현하지만 두 개가 아닌 3차원 혹은 4차원에서도 이러한 직교 회전이 가능하고 그 경우 모든 변수가 서로 독립이 됩니다. 또한 새 주성분 축들은 변수들의 변동을 설명하는 양에 따라 만들어지는 순서가 결정됩니다. 위 그래프를 보면 2 축의 평행적인 방향보다는 P1축 방향에서 변수들의 변동이 많습니다. 이는 1 X 가 가지고 있던 변동을 1 축보다 2 축이 더 많이 설명할 수 있다는 뜻입니다. 이를 직관적으로 이해하기 위하여 다음의 그림을 봅시다. 위 그래프는 변수들이 보이는 변동을 시각화한 것으로, 주성분 축들은 타원의 끝과 끝을 이어주는 방향으로 회전될 것입니다. 각 주성분이 설명할 수 있는 변동의 크기는 주황색과 빨간색의 각 길이로 판단될 수 있으며, 이는 변수들의 공분산(상관성)의 구조를 분해하여 얻어지는 고윳값(eigen value)에 비례합니다. 즉, 빨간색 방향으로 먼저 1번 주성분 축이 생성되며 1번 주성분 축과 직교하면서 그다음으로 변동을 많이 설명할 수 있는 주황색 방향으로 2번 주성분 축을 생성하게 됩니다. 이와 같은 특성으로 인해 주성분 분석을 사용하면 합리적인 차원 축소를 가능해집니다. 이해를 위해 조금은 극단적인 예를 보겠습니다. 위와 같은 데이터가 있을 경우 데이터의 포인트들을 사용하지 않고 빨간색 선 위의 점을 대신 사용해도 무방할 것으로 보입니다. 그 이유는 빨간색 선 방향으로만 큰 변동을 보이고 다른 방향으로는 거의 변동이 없기 때문이죠. 즉, 굳이 1 X 두 변수를 사용하지 않고 저 선위의 점들만 사용하면 2개의 변수를 하나의 변수로 줄이는 효과를 볼 수 있습니다. 이는 곧 2차원에서 1차원으로의 차원 축소를 의미합니다. 차원의 경우에도 마찬가지입니다. 주성분 분석을 진행하면 개의 서로 직교하는 새로운 축을 생성하지만 처음으로 생성되는 1번 주성분 축이 가장 큰 변동을 설명하고 마지막에 생성되는 번 주성분 축이 가장 적은 변동을 설명하게 됩니다. 또한 모든 축이 설명하는 변동은 개의 원래 변수가 가지고 있던 변동의 전부를 설명합니다. 이런 점을 미루어 볼 때, 분석 자는 개의 새로운 축 중 만족하는 수준의 변동을 설명할 수 있는 소수의 축만 선택하고 소량의 변동만을 설명하는 축들은 버림으로써 차원을 축소할 수 있는 것이죠. 10개의 변수가 있을 때, 주성분 분석을 시행하면 10개의 축을 얻을 수 있고 이 중 3의 축이 설명하는 변동이 전체의 80% 라면, 3번 주성분 축까지만 택하고 나머지 7개 방향의 변동은 무시함으로써 10차원에서 3차원으로의 차원 축소가 가능한 것입니다. 또한 이 설명 비율은 위에서 언급한 고윳값과 관련이 있습니다. 이 방법들은 전부 원 변수들의 선형결합으로 제시되는 새 주성분 인공 변수를 통해 이루어집니다. 예를 들어 1 X의 5개의 변수가 있을 때 주성분 분석을 하게 되면 다음과 같은 주성분 변수와 전체 변동의 설명 비율을 구할 수 있습니다. 1 0.2 1 0.1 2 0.6 3 0.15 4 0.4 5 전체 변동 중 78% 설명 2 − 0.1 1 0.4 2 0.12 3 0.25 4 0.3 5 전체 변동 중 15% 설명 3 0.31 1 0.13 2 0.19 3 0.22 4 0.39 5 전체 변동 중 4% 설명 4 − 0.14 1 0.57 2 0.66 3 0.05 4 0.1 5 전체 변동 중 2% 설명 5 0.42 1 0.02 2 0.4 3 0.57 4 0.13 5 전체 변동 중 1% 설명 이 경우 두 인공 변수 1 P만 택하여도 전체 변동의 약 93%를 설명하면서 서로 독립적인 2개의 인공 변수를 얻게 됩니다. 이 선형결합을 통해서 구해진 값을 주성분 점수(principal score)라고 부르며 원 변수를 새 축의 관점에서의 바라보는 값이 될 것입니다. 주성분 점수와 원 변수의 상관계수 혹은 선형 결합의 계수를 이용하면 각 주성분 변수에 작용하는 원 변수의 영향을 알 수 있습니다. 만약 3 P의 상관성이 높은 양의 값으로 나타났다면 첫 번째 주성분 1 X 이 증가하면서 증가하는 것을 알 수 있고 이는 1 을 만드는데 1 의 영향이 컸음을 뜻합니다. 또한 이 주성분 점수 값은 완전 독립적인 예측자로써, 회귀분석을 포함한 다른 기타 통계분석에 활용할 수 있습니다. A5. 주성분 분석(R Code) 5. 주성분 분석(R Code) 주성분 분석은 FIFA 18 게임 데이터 셋을 이용하여 분석을 진행하겠습니다. 데이터 다운로드 링크 : https://www.drop box.com/sh/vtqlvrgdts2yfez/AAD_cd49dBcvgBNdz-C-A6TFA?dl=0 데이터 전처리 ### Principal Component Analysis library(tidyr) library(data.table) FIFA = read.csv("F:\Drop box\DATA SET(Drop box)\CompleteDataSET.csv", header = TRUE, stringsAsFactors = FALSE) FIFA_FIELD = subset(FIFA, FIFA$Preferred.Positions != "GK ") library(purrr) FIFA_FIELD2 = FIFA_FIELD[1:100, c(2, 10:40, 42:48, 61:71)] FIFA_FIELD2 = FIFA_FIELD2 %>% map_if(is.character, as.numeric) FIFA_FIELD2 = FIFA_FIELD2 %>% map_if(is.integer, as.numeric) FIFA_FIELD2 = as.data.frame(FIFA_FIELD2) rownames(FIFA_FIELD2) = FIFA_FIELD$Name[1:100] 선수들의 능력치를 추출하였습니다. 선수들이 많기 때문에 상위 100명에 대해 분석을 진행합니다. 데이터 표준화 데이터의 기하적인 특성을 이용하는 분석은 항상 표준화(Scaling)를 진행해야 합니다. 위에서 설명했듯이 주성분 분석은 데이터의 변동을 기준으로 주성분이 만들어집니다. 만약 단위가 큰(분산이 큰) 변수와 단위가 작은(분산이 작은) 변수가 같이 주성분 분석에 투입될 경우, 단위가 큰 변수가 단위가 작은 변수의 변동을 덮어버려 효과를 볼 수 없게 결괏값을 왜곡하게 됩니다. 그렇기에 기하 성질을 띄는 분석은 단위를 통일시켜주는 표준화 작업을 먼저 진행해야 됩니다. SCALED=as.data.frame(scale(FIFA_FIELD2[,1:34])) scale()을 쓰면 수치형으로 되어 있는 모든 변수들이 평균은 0, 분산은 1을 가지도록 표준화 변환이 진행됩니다. 참고로 분석은 포지션별 능력치를 제외한, 피지컬 및 테크닉 능력치들을 분석 대상으로 하겠습니다. 주성분 분석 주성분 분석을 진행하기 전에, 먼저 변수들이 선형 관계를 어느 정도 가지고 있는지에 대해서 탐색을 할 필요는 있습니다. 만약, 변수 간의 상관관계가 적은 경우, 굳이 주성분 분석을 할 이유는 크게 없기 때문입니다. 차라리 전에 언급한 변수 선택법을 통해 차원(변수)을 줄여가는 것이 더 효과적입니다. library(corrplot) library(RColorBrewer) Corr_mat = cor(SCALED) corrplot(Corr_mat, method = "color", outline = T, addgrid.col = "darkgray", order = "hclust", addrect = 4, rect.col = "black", rect.lwd = 5, cl.pos = "b", tl.col = "indianred4", tl.cex = 0.5, cl.cex = 0.5, addCoef.col = "white", number.digits = 2, number.cex = 0.3, col = colorRampPalette(c("darkred", "white", "midnightblue"))(100)) cor()은 상관 행렬을 만드는 명령어입니다. 변수들 간의 선형 관계가 꽤나 높은 것을 알 수 있습니다. 주성분 분석을 통해 차원 축소를 진행하겠습니다. 명령어 출처 : http://www.sthda.com/english/articles/31-principal-component-methods-in-r-practical-guide/112-pca-principal-component-analysis-essentials/ library(factoextra) library(FactoMineR) Principal_Component = PCA(SCALED, graph = FALSE) PCA()는 주성분 분석을 실행하는 코드입니다. graph = FALSE 옵션은 PCA() 명령어를 통해 자동으로 출력되는 그래프가 출력되지 않도록 하는 옵션입니다. 가장 먼저 확인해야 되는 부분은 새로 만들어진 주성분들이 변수들의 변동을 얼마큼 설명하고 있는지를 확인해야 됩니다. Principal_Component$eig[1:5, ] eigenvalue percentage of variance cumulative percentage of variance comp 1 14.894127 43.806256 43.80626 comp 2 3.600039 10.588349 54.39461 comp 3 2.975834 8.752452 63.14706 comp 4 2.480377 7.295227 70.44228 comp 5 2.002131 5.888621 76.33090 comp1(제1주성분, PC1)은 전체 변동의 43.80%를 설명합니다. comp2(제2주성분, PC 2)은 전체 변동의 10.58%를 설명하며, 제1주성분을 포함한 누적 설명력은 54.39%입니다. Scree plot은 각 주성분이 전체 변동에 대해 설명하는 비율을 나타냅니다. fviz_screeplot(Principal_Component, addlabels = TRUE, ylim = c(0, 50)) PC1이 가장 많은 변동을 설명하며, PC7부터는 설명하는 비율의 변화가 매우 작은 것을 볼 수 있습니다. Scree Plot을 통해 몇 개의 주성분까지 가져다 사용할 것인지 판단하는 것이 주성분 분석의 첫 번째 단계입니다. 주성분 가중치 확인 주성분 분석의 해석은 각 주성분에서 어떤 변수가 가장 큰 영향력을 가지고 있는지 파악하는 것입니다. (+)라고 좋은 것이 아니며, (-)라고 나쁜 것이 아닙니다. 부호는 방향을 의미합니다. 영향력 자체는 계수의 절댓값 크기에 집중을 해야 합니다. Dim.1은 제1주성분(PC1)을 의미합니다. Principal_Component$var$coord[1:34, ] Dim.1 Dim.2 Dim.3 Dim.4 Age -0.1391304 0.15188183 0.0002134079 0.43702597 Acceleration 0.6111358 -0.41547597 -0.0837865360 -0.44590706 Aggression -0.6583780 0.15278535 0.3071821747 0.17498731 Agility 0.8041455 -0.01336877 -0.0545868730 -0.36064461 Balance 0.6044207 0.15321777 -0.2446476197 -0.48091951 Ball.control 0.9140783 0.21037964 0.0194490653 -0.06052152 Composure 0.4190301 0.25451272 -0.0022204597 0.50070532 Crossing 0.8198600 0.25508545 -0.0058704866 -0.10857638 Curve 0.9155934 0.20091316 -0.0366767330 -0.02629993 Dribbling 0.9389829 0.04414586 -0.0944411585 -0.11187542 Finishing 0.9035608 -0.17998183 0.1005064965 0.18373436 Free.kick.accuracy 0.8181311 0.29463438 0.0920612901 0.06445744 GK.diving 0.1498721 -0.05724641 0.6802467984 -0.22159550 GK.handling 0.1079801 -0.05885318 0.6748930563 -0.16986119 GK.kicking 0.2176676 -0.08598534 0.7173101651 -0.16002126 GK.positioning 0.0916075 -0.13699776 0.6715493703 -0.11918837 GK.reflexes 0.2013511 -0.14807891 0.7759962774 -0.10869070 Heading.accuracy -0.5371602 -0.32424989 0.1744474398 0.59771117 Interceptions -0.7197588 0.58103933 0.1157715176 -0.07256358 Jumping -0.4587959 -0.35864751 0.0540112040 0.29396321 Dim.5 Age -0.080699184 Acceleration 0.380635869 Aggression 0.379845386 Agility 0.261068995 Balance 0.218730455 Ball.control 0.008509720 Composure 0.008980891 Crossing 0.169537864 Curve 0.024764215 Dribbling 0.039338751 Finishing -0.019721032 Free.kick.accuracy -0.012611936 GK.diving -0.123443113 GK.handling -0.257640855 GK.kicking 0.023624321 GK.positioning -0.086825626 GK.reflexes -0.153215026 Heading.accuracy 0.237293106 Interceptions 0.220703722 Jumping 0.558884296 [ getOption("max.print")에 도달했습니다 -- 14 행들을 생략합니다 ] $$ PC1 =-0.14Age+0.61Acceleration-0.65Aggression+\ 0.8Agility+0.6Balance+0.91Ball.control + \cdots+0.89*Volleys $$ 다음과 같은 변수들의 선형결합 꼴로 나타낼 수 있습니다. 제2주성분(PC 2)는 다음과 같습니다. $$ PC 2 =0.15Age-0.42Acceleration+0.15Aggression-\ 0.013Agility+0.15Balance+0.21Ball.control + \cdots-0.07*Volleys $$ 제1주성분에서의 변수들의 가중치를 살펴보면 다음과 같습니다. Ball.control, Curve, Dribbling, Finishing, Volleys 변수의 가중치가 0.9 전후로 양의 방향으로 가중치가 큰 것을 알 수 있습니다. Aggression, Interceptions, Marking, Sliding tackle, Standing.tackle 등의 변수는 -0.7 전후로 음의 방향으로 가중치가 큰 것을 확인할 수 있습니다. 분석한 가중치를 토대로 주성분에 대해 새로운 이름을 만들어줘야 합니다. PC1이 양의 방향으로 큰 경우는 일반적으로 공을 다루는 능력치들이 좋은 경우에 해당됩니다. 반대로 PC1이 음의 방향으로 큰 경우는 일반적으로 수비 능력치가 높을 경우에 해당됩니다. 즉, PC1은 수비 포지션 여부라는 새로운 이름을 지어줄 수 있습니다. 수많은 변수를 분석한 주성분 계수는 눈으로 확인하기 힘든 경우가 많습니다. 그렇기에 Biplot이라는 그래프를 그려 효율적으로 확인하고자 합니다. fviz_pca_var(Principal_Component, col.var = "contrib", gradient.cols = c("#00AFBB", "#E7B800", "#FC4E07"), repel = TRUE # Avoid text overlapping ) Biplot의 x축은 Dim1(제1주성분), y 축은 Dim2(제2주성분)입니다. 예를 들어 Long.passing 변수의 가중치는 제1주성분에서 0.30입니다. 제2주성분에서의 가중치는 0.82입니다. Biplot에서 Long.passing 변수는 (0.30,0.82)(0.30,0.82)에 찍히게 됩니다. Biplot에서 같은 방향으로 뻗어나가는 변수일수록 비슷한 변수들이라고 볼 수 있습니다. Biplot을 통해 확인할 수 있는 분석 결과는 PC1이 크거나 작을 경우에는 어떤 변수들이 영향을 많이 미치는지, 혹은 PC 2가 클 때, 작을 때 어떤 변수들이 영향을 많이 주는지 가중치를 한눈에 확인하는 것입니다. 추가적으로 주성분 분석은 고차원의 변수들을 단 2차원의 그래프로 시각화해주는 뛰어난 효율성을 지니고 있습니다. 그렇기에 주성분 분석은 시각화 목적으로도 자주 쓰이고는 합니다. fviz_pca_biplot(Principal_Component, repel = FALSE) 위에서 그렸던 Biplot 위에다가 선수들의 산점도를 같이 그렸습니다. 각 선수들 별로 새로운 변수(주성분)에 대한 값이 계산이 되어 있습니다. 이런 식으로 크리스티아노 호날두 선수는 Biplot 상에서 (4.95, -1.72)에 위치하게 됩니다. 각 선수들의 능력치 분포와 상대적 위치를 확인할 수 있습니다. 주성분 분석은 이렇게 기존 변수들의 선형 결합을 이용하여 새로운 축(변수)를 만듭니다. 그리고 새로운 변숫값을 이용하여 분석을 새로 진행하게 됩니다. 각 주성분 간의 상관계수는 0이기 때문에 주성분 값으로 회귀분석을 진행하게 될 경우, 다중공 선성을 걱정하지 않아도 됩니다. 또한 효과적인 차원 축소로 모델을 간단하게 만들 수 있습니다. 주성분 분석은 기계학습에서도 주로 쓰이는 차원 축소 방법입니다. 주성분 분석을 한 번에 이해하기는 매우 힘듭니다. 그러기에 많은 해석 연습이 필요한 부분입니다. A6. 군집분석 6. 군집분석 군집분석이란 데이터들을 서로 비슷한 데이터들끼리 묶어주어, 여러 개의 군집으로 묶어 주는 분석입니다. 이제까지 진행했던 분석들은 '지도 학습(Supervised Learning)'이라고 합니다. 구해야 되는 값이 명확하기 때문입니다. 군집분석은 반대로 '비지도 학습(Unsupervised Learning)'입니다. 구해야 되는 값이 명확하지 않기 때문입니다. 예를 들어, 카드사에서 고객들의 특성을 파악하여 비슷한 고객들을 대상으로 군집을 형성하려고 합니다. 이때, 카드사는 고객들을 어떻게 분류해야 되는지 기준이 없기 때문에 구해야 되는 값이 명확하지 않습니다. 이럴 때 군집분석은 매우 유용하게 사용됩니다. 먼저, 군집분석에서는 유사도(Similarity) 개념이 공통적으로 쓰입니다. 유사도(Similarity) 단어의 의미 그대로 '비슷한 정도'를 의미합니다. 단, 이 유사도를 측정하는 방법은 매우 많습니다. 여기서는 간단한 방법들에 대해만 언급하고 넘어가겠습니다. 유클리디안 거리(Euclidean Distance) 좌표상에서 데이터들 간의 직선거리를 의미합니다. 코사인 유사도(Cosine Similarity) 좌표상에서 데이터들 간의 Cosine 값을 의미합니다. 유클리디안 거리에서는 거리가 가까울수록, 코사인 유사도에서는 각 데이터 간의 각도가 작을수록 데이터가 비슷하다는 것을 의미합니다. 군집분석에서 주의해야 할 부분은 몇 개의 군집으로 나눌지는 분석가의 판단에 달려 있습니다. 선형 모형에서처럼 p-value가 해결해 주는 부분이 없습니다. 그렇기에 분석가의 정확한 해석이 요구되는 분석입니다. 이는 즉 군집분석의 단점으로 귀결이 됩니다. 군집분석은 크게 계층적 군집분석과 비계층적 군집분석으로 나눌 수 있습니다. A7. 계층적 군집분석 7. 계층적 군집분석 계층적 군집분석의 특징은 다음과 같습니다. 데이터들 간의 거리행렬을 구합니다. 거리행렬에서 규칙에 따라 가장 유사한 데이터들부터 군집을 형성합니다. 상대적으로 작은 데이터에 쓰기 알맞습니다. 계층적 군집분석을 진행하기 위해서는 먼저 유사도가 계산이 되어있어야 합니다. # 유클리디안 거리 계산 Distance_Matrix = dist(x = Iris, method = "euclidean") Distance_Matrix 10 20 30 40 20 0.7280110 30 0.2236068 0.7211103 40 0.3605551 0.4000000 0.4472136 50 0.2236068 0.5099020 0.3162278 0.1414214 min(Distance_Matrix) [1] 0.1414214 거리 행렬에서 가장 가까이 존재하는 관측치는 40, 50입니다. 그러면 40, 50은 같은 군집으로 묶이게 됩니다. 최단 거리법은 군집 내 관측치와 다른 관측치 간 가장 가까운 관측치를 선택하게 됩니다. ( 40 50 10 ) m n [ ( 40 10 ) d ( 50 10 ) ] m n ( 0.36 0.22 ) 0.22 ( 40 50 20 ) m n [ ( 40 20 ) d ( 50 20 ) ] m n ( 0.40 0.51 ) 0.40 ( 40 50 30 ) m n [ ( 40 30 ) d ( 50 30 ) ] m n ( 0.44 0.31 ) 0.31 그럼 여기서 거리가 가장 가까운 10 ( 40 50 ) 군집에 속하게 됩니다. 계층적 군집분석은 이런 식으로 서로 유사도가 높은 순서대로 군집을 형성하게 됩니다. 모든 관측치에 대해서 유사도를 계산해야 되기 때문에 표본이 클 경우에는 적합하지는 않습니다. A8. 계층적 군집분석(R Code) 8. 계층적 군집분석(R Code) 주성분 분석에서 예제로 썼던 피파 데이터를 통해 진행하도록 하겠습니다. library(cluster) library(factoextra) C = sample(1:nrow(SCALED), 40, replace = FALSE) # 랜덤하게 40개만 추출 FIFA_SAMPLE = SCALED[C, ] 100명의 선수들 중 40명을 랜덤으로 뽑아 계층적 군집분석을 진행하겠습니다. 코드 출처 : http://www.sthda.com/english/wiki/print.php?id=234 res.hk = hkmeans(SCALED[C, ], 3) fviz_dend(res.hk, cex = 0.6, palette = "jco", rect = TRUE, rect_border = "jco", rect_fill = TRUE) hkmeans()는 계층적 군집분석 명령어입니다. 3은 3개의 군집으로 표시하라는 옵션입니다. 만약 4를 주면 4개의 군집으로 색을 구분합니다. 계층적 군집분석은 기본적으로 연산량이 많기에 큰 표본에서는 추천되지 않습니다. 물론 결괏값이 덴드로그램을 통해 시각화할 수 있기에, 대표본을 대상으로는 효율적인 방법이 아닙니다. 대신 대표본을 소표본으로 샘플링 한 후, 비계층적 군집분석을 하면 대표본을 대상으로 하는 군집분석은 몇 개의 군집이 적합할지 탐색할 수 있습니다. A9. 비계층적 군집분석 9. 비계층적 군집분석 비계층적 군집분석은 계층적 군집분석과는 반대로 거리행렬을 이용하지 않고, 대표본에 대해 적합한 분석방법입니다. 대표적으로 K 평균 군집분석이 있습니다. 평균 군집분석은 다음의 순서대로 진행이 됩니다. 개의 군집 수를 사전에 결정합니다. 초기의 평균값은 데이터에서 무작위로 선택합니다. 선택된 데이터는 각의 중심이 됩니다. 개의 중심으로부터 각 데이터 간의 유사도를 구하고, 유사도가 가장 높은 데이터들을 에 할당합니다. 각 군집의 중심점을 다시 계산하고 3 ~ 4의 과정을 반복합니다. fviz_nbclust(SCALED, kmeans, method = "wss") + geom_vline(xintercept = 3, linetype = 5) 해당 그래프는 군집의 개수(x축, Number of cluster k)에 따라 각 군집 안에서 데이터 간의 거리 제곱합을 의미합니다. 값이 작을수록 군집은 작게 형성되었다는 것을 의미합니다. 하지만, 군집을 너무 많이 나눌 경우에는 해석이 힘들어지기 때문에 적당한 개를 정하는 것이 중요합니다. B1. 비계층적 군집분석(R Code) 10. 비계층적 군집분석(R Code) km.res = kmeans(SCALED, 3, nstart = 25) fviz_cluster(km.res, data = SCALED) + theme_bw() kmeans()는 K 평균 군집분석을 실행하는 명령어입니다. 3은 군집의 개수를 3개로 설정하겠다는 의미입니다. nstart 옵션은 kmeans 분석을 25번을 하여, 그중 분산이 가장 작게 나오는 결과를 분석의 최종 결과로 정하겠다는 의미입니다. 앞서 언급했듯이, K 평균 군집분석은 임의적인 위치에서 시작하기 때문에 각 결과마다 다르게 나오는 문제가 존재합니다. 그래서 반복적으로 계산합니다. 시각화를 주성분으로 차원 축소를 하는 이유는 다음과 같습니다. plot(SCALED[, 1:5], col = km.res$cluster) 이렇게 각 변수들 간의 개별 산점도로 군집이 잘 묶였는지 시각화하는 것은 너무나 비효율적이기 때문입니다. 위의 군집 결과를 확인하시면 공격수, 미드필더, 수비수들이 따로따로 군집이 형성되어 있는 것을 확인할 수 있습니다. 각 데이터가 어떤 군집에 속했는지는 다음과 같이 확인할 수 있습니다. km.res$cluster[1:10] Cristiano Ronaldo L. Messi Neymar L. Su찼rez 2 2 2 2 R. Lewandowski E. Hazard T. Kroos G. Higua 챠 n 2 2 3 2 Sergio Ramos K. De Bruyne 3 2 B2. KNN 11. KNN kNN(k nearest neighbor algorithm)은 새로운 데이터가 주어졌을 때 기존 데이터 가운데 가장 가까운 k 개 이웃의 정보를 기반으로 새로운 데이터의 집단을 예측하는 방법론입니다. kNN의 특징을 정리하면 다음과 같습니다. 분류 대상이 정해져있는 지도학습입니다. 계산 비용이 높습니다. 함수 형태가 정해져 있지 않기에, 별도의 모델을 구축하지 않습니다. 두 점 간의 거리를 측정하는 방법에 따라 다양한 결괏값 도출할 수 있습니다. k 값이 작으면 noise(이상치 등)의 영향을 크게 받고, 반대로 k가 크게 되면 정상적인 분류에 어려움 발생합니다. kNN에서 가장 핵심은 k를 어떻게 설정하냐에 따라 결괏값이 매우 크게 차이가 날 수가 있습니다. 그렇기 때문에 적절한 k를 찾는 것이 kNN의 핵심이라고 할 수 있습니다. B3. kNN(R code) 12. kNN(R code) library(caret) library(class) library(gmodels) library(ggplot2) data(iris) plot(iris$Sepal.Length, iris$Sepal.Width, col = iris$Species, pch = 19) legend("topright", legend = levels(iris$Species), bty = "n", pch = 19, col = palette()) normMinMax = function(x) { return((x - min(x))/max(x) - min(x)) } iris_norm = as.data.frame(lapply(iris[1:4], normMinMax)) normMinMax는 kNN을 진행하기 전에, 각 특성 값들의 범위를 0~1로 정규화를 시켜주는 작업입니다. 정규화를 진행하면 단위가 동일하게 되며 비율 값으로 표시가 되는 효과가 있습니다. # Train / Test 데이터 구분 ratio = 0.7 indexes = sample(2, nrow(iris), replace = TRUE, prob = c(ratio, 1 - ratio)) iris_train = iris[indexes == 1, 1:4] iris_test = iris[indexes == 2, 1:4] iris_train_labels = iris[indexes == 1, 5] iris_test_labels = iris[indexes == 2, 5] K = c() ACC = c() for(x in seq(1,80, by = 2)){ iris_mdl = knn(train=iris_train, test=iris_test, cl=iris_train_labels, k = x) CM = confusionMatrix(iris_test_labels, iris_mdl) accuracy = CM$overall[1] K = c(K, x) ACC = c(ACC, accuracy) } KNN_Result = data.frame( K = K, ACC = ACC ) ggplot(KNN_Result) + geom_point(aes(x = K, y = ACC)) + geom_line(aes(x = K, y = ACC),group = 1) + scale_x_continuous(breaks = seq(0,80, by = 10)) + theme_bw() + guides(col = FALSE) k가 작을 때는 비교적 잘 맞추지만, k가 매우 커지니 정확도가 떨어지는 것을 확인할 수가 있습니다. 참고로 iris 데이터는 연습용 데이터이기에 분류가 매우 잘 되는 편입니다. 그렇기에 kNN이 매우 좋구나라고 생각하기에는 무리가 있는 데이터 셋입니다. 군집분석은 실제 분석에서 대단히 많이 쓰이는 분석입니다. 복잡한 데이터에 대해 모델링을 하기 위해서는 비슷한 유형별로 분리시킨 후 간단하게 하는 작업이 필수적입니다. 이때, 데이터의 유사성에 따른 군집분석은 매우 유용하게 사용됩니다. ChB5. 기계학습 이번 챕터에서는 기계학습을 다룹니다. 간단하고 대표적인 알고리즘만 다룹니다. 자세한 내용은 2편에서 다룰 예정입니다. A1. 기계학습에 대한 정의 1. 기계학습에 대한 정의 데이터로부터 패턴을 뽑아내는 자동화 프로세스를 기계학습이라고 정의합니다. 기계학습의 적용 분야는 매우 다양한데, 예시를 들자면 다음과 같습니다. 스팸메일 분류 알고리즘 고객들의 구매 패턴 분석 알고리즘 환자 진단 알고리즘 비전, 음성, 문자 등 많은 분야에 적용이 가능 기계학습 모형의 가장 큰 목적은 예측 모형을 만드는 것에 있습니다. 좋은 예측 모형이란, 현재에 존재하지 않는 데이터에 대해서도 예측값을 잘 맞추는 모형을 좋은 모형이라고 하며, 이런 모형을 일반화(generalize)가 잘 되었다고 합니다. A2. 기계학습에서 주의할 점 2. 기계학습에서 주의할 점 기계학습에서 예측 모형의 정확성을 떨어트리는 문제점은 2가지가 있습니다. Underfitting Underfitting은 Feature 변수가 Response 변수를 너무 간단하게 설명하려고 할 때 발생합니다. Overfitting Overfitting은 Underfitting과 대조적으로 알고리즘이 너무 복잡하고 데이터에 너무 밀접하게 짜였을 때, 잡음(noise)에 예민해지는 문제가 발생합니다. Over(Under) fitting은 예시를 들자면, 이런 경우가 있습니다. 대부분의 대학교 학과에서 최소 강의 1개 이상은 시험 족보가 돌아다니길 마련입니다. 하지만 현명하신 교수님들께서는 족보 그대로 시험문제를 출제하는 게 아니라, 족보에서 60%, 안 나왔던 문제 40%를 배치시켜 균형 있게 문제를 내십니다. 이런 경우, Underfitting은 그냥 공부를 안 해서 시험을 못 보는 거라고 할 수 있습니다. Overfitting은 공부는 열심히 했는데 족보만 공부해가지고 새로운 문제를 못 풀어 시험을 못 보는 거라고 할 수 있습니다. Machine Learning은 '학습'입니다. 기계한테 데이터를 학습시킴으로써 새로운 데이터가 들어왔을 때, 문제없이 예측값을 뽑아낼 수 있느냐가 중요합니다. 그런 이유로 항상 예측 모형을 학습시킬 때, Training Set과 Test Set을 분리시켜 모형의 신뢰도를 높이고자 하는 앙상블 기법을 주로 사용합니다. A3. 앙상블(Ensomble) 기법 3. 앙상블(Ensomble) 기법 기계학습의 목적은 주어진 과제(데이터)에 대해서 가장 정확한 하나의 모형을 만드는 것입니다. 하지만 앙상블 기법은 목적과는 조금 다른 접근 방식입니다. 하나의 모형만 만들지 않고, 여러 개의 모형을 만들고 이를 한 세트로 구성합니다. 여러 개의 모형들의 예측값을 집계 내서 결괏값을 산출합니다. 이러한 방법을 Model ensemble이라고 합니다. 앙상블 기법은 전문가들이 모여 아이디어를 함께 내는 것이 한 명의 전문가가 해결하는 것보다 결과가 더 좋다는 경험과 비슷하게 시작되었습니다. 하지만 전문가들이 함께 일할 때여도, 전문가는 그룹에서의 생각과 다르게 독자적으로 결정을 내릴 수 있어야 합니다. 앙상블 기법도 마찬가지로 여러 가지의 모형이 있어도 각 모형이 독립적으로 결과를 뽑아냅니다. 그 후, 각 모형들의 결괏값을 집계 내어 예측값을 정하도록 합니다. Response 변수가 Categorical 변수 일 때 : 투표<NAME>으로 각 모형에서 가장 많이 뽑힌 값이 예측 값이 됩니다. Response 변수가 Numerical 변수 일 때 : 평균 혹은 중위수를 계산함으로써 중심 경향을 나타내는 값이 예측 값이 됩니다. 다음으로는 앙상블 기법에서 대표적으로 쓰이는 2개의 접근법(Bagging, Boosting)에 대해 다루도록 하겠습니다. Boosting Boosting 기법은 가중치를 이용하여 약한 학습기(Weak learners)를 강한 학습기(Strong learners)로 만드는 과정을 말합니다. Boosting 기법은 독립적인 모델이 만들어질 때마다 이전 모델의 오류를 반영한 후, 다음 모형에는 오 분류 된 데이터에 대해 가중치를 주고 모형을 만듭니다. 예를 들자면, 틀린 연습 문제에 대하여 다음 시험 때까지 틀린 유형의 연습문제를 더 많이 풀게 함으로써(가중치를 올려줌으로써) 오 분류되었던 데이터에 대해 정분류를 할 수 있도록 수정을 하는 것입니다. 먼저 Bootstrap 이란 용어에 대해 알아보도록 하겠습니다. Bootstrap 이란 예를 들어, '주어진 데이터 중에서 중복을 허용하여 m 개를 뽑고 그 m 개의 통계 값을 구하는 작업' 이 작업을 여러 번 반복한다는 것을 의미합니다. 그럼 각 시행 별로 계산된 통계 값이 쌓여 분포가 형성이 될 것입니다. Bootsraping은 보통 샘플 수가 적을 때 사용하기도 합니다. 그럼 이를 기계학습에서 어떤 논리 순서로 진행되는지 알아보도록 하겠습니다. N 개의 데이터가 있다고 할 때, 각 개별 데이터가 뽑힐 확률은 1/N입니다. 1/N의 확률로 뽑힌 데이터 셋(Training Set)을 가지고 예측 모형을 만듭니다. 만들어진 예측 모형을 평가하고 Error 발생 정도를 판단합니다. Error, 즉 오 분류 판정을 받은 데이터 셋들에 대하여 뽑힐 확률을 올려 준 다음, Random Sampling을 다시 진행합니다. 오 분류 판정을 받은 데이터들이 뽑힐 확률의 가중치 올릴 경우 계산식은 다음과 같습니다. [ ] w [ ] 1 ∗ 반대로 뽑힐 확률의 가중치를 내릴 경우 계산식은 다음과 같습니다. [ ] w [ ] 1 ∗ ( − ) 오 분류 판정을 받은 데이터들은 가중치를 더 받음으로써 다음 Random Sampling 때 뽑힐 확률이 더 높아지게 됩니다. 새로 뽑힌 Training Set을 가지고 예측 모형을 만듭니다. 오 분류를 계산하고 오 분류 데이터들의 가중치를 조정하여 다시 모형을 진행합니다. 의도한 모형 개수에 도달하게 되면 Bootstrap이 끝나게 되고 최종 결괏값이 나오게 됩니다. Boosting은 진행할 때마다 데이터의 가중치를 달리함으로써 예측 모형에 만들어지는 Training Set의 분포를 변화시키는 것이 그 목적입니다. 주로 오 분류가 발생하는 경우에서 흔한 문제는 데이터가 균형이 안 맞춰져 있을 때 발생합니다. 예를 들어 병원에서 환자들의 질병 유무를 판단하고자 예측 모형을 만들려고 합니다. 하지만 해당 질병에 걸린 사람들은 질병에 걸리지 않은 사람들보다 절대적으로 적습니다. 이런 경우 데이터의 분포가 균형 있지 못하게 됩니다. 결국 기계학습 과정에서 상대적으로 Minor 한 질병 환자 데이터가 관심을 가지지 못하게 되고, 그 결과는 예측 모형의 오 분류로 이어지게 됩니다. 이러한 문제점을 해결하고자 하는 것이 앙상블 기법에서의 Boosting 접근 방식입니다. Bagging Bagging 기법은 Boosting에 비해서는 조금은 간단하게 진행됩니다. 각 모형별 복원 추출을 통해 Training Set을 만들고, 예측 모형을 만듭니다. 원하는 개수만큼의 모형을 만들었으면, 각 모형의 결과값들을 집계하여 최종 결과물을 냅니다. 각 모형 별로 Training Set이 다르기 때문에 예측 모형도 당연히 모형별로 차이가 존재할 것입니다. 정말 이게 끝입니다. 간단하죠? 정말입니다. A4. Gradient Descent(경사하강법) Error Surface 회귀분석에서의 Error는 이제까지 언급함 MSE라고 생각하시면 됩니다. Error surface는 모든 가능한 가중치(일반적으로 통계학에서는 회귀계수 0 β으로 표현하고, 학습 쪽에서는 가중지 [ ] w [ ] 로 표현하고는 합니다.) 들에 대한 조합에 대해 Error 값을 계산하여 시각화를 하고자 한 것입니다. 통계학에서는 최소제곱법을 이용하여 회귀계수를 추정하지만, 기계학습에서의 회귀계수 추정은 살짝 다릅니다. 이 Error Surface에서 MSE가 최소점이 되는 가중치의 조합을 찾는 방식으로 회귀계수를 추정합니다. Error Surface는 일반적으로 볼록한 그릇 모양입니다. 그 의미는 MSE가 최소가 되는 바닥이 존재할 것이며, 그 바닥을 Global minimum이라고 합니다. 이러한 접근법을 저희는 least squares optimization이라고 합니다. Gradient Descent 앞서 말했듯이, 선형 회귀분석에서 global minimum을 찾기 위하여 가능한 모든 가중치의 조합(회귀계수의 조합)을 계산하는 방식은 데이터의 크기가 방대할 경우, 연산 속도가 너무 길어지기 때문에 현실적으로 구현하기에는 어려운 점이 있습니다. 하지만, Error surface에서 global minimum이 존재한다는 사실을 기반으로, 효율성을 높이기 위해 gradient descent(경사 하강법) 방법을 사용합니다. Gradient Descent(경사 하강법)의 원리는 다음과 같습니다. 앞을 보기 힘들 정도로, 안개가 낀 협곡에 있다고 가정합시다. 앞이 보이지 않아, 협곡을 내려가는 길을 찾을 수가 없지만, 바로 앞에서의 협곡의 경사는 확인할 수는 있습니다. 경사가 내려가면 해당 방향으로 가고, 경사가 올라가면 내려가는 경사를 찾아 방향을 정합니다. 이렇게 꾸준히 조심히 내려가다 보면, 언젠가는 바닥에 도착할 것입니다. 이를 그대로 알고리즘 원리에 비유를 하면, Gradient Descent는 임의의 위치에서 시작합니다.(위치 : 가중치, 회귀계수) 임의로 주어지는 가중치는 범위로 주어집니다. 전체 조합이 아닌, 해당 위치를 기준으로 한 가중치를 범위로 잡습니다. S (Sum of Squared Error)을 계산합니다. S를 통해 해당 지역(가중치, 회귀계수의 범위 내)에서의 Error Surface를 찾을 수 있습니다. Error surface에서 경사를 계산합니다. 경사가 내려가는 곳을 방향으로 설정한 후, 새로운 Error Surface로 이동을 합니다. 계산이 무수히 반복되다 보면, global minumum을 찾을 수 있습니다. 가중치들은 계산이 진행됨에 따라서 한곳으로 수렴하게 되는 데, 해당 부분이 Globar minimum이 될 것입니다. 일반적으로 Gradient Descent는 다음의 그래프를 통해 이해한다면 더 수월해질 것입니다. 여기서, learning rate라는 것이 등장하는데, 이는 쉽게 말하면 계곡에서 한 걸음씩 내려갈 때 보폭을 어느 정도의 크리고 설정하는 정도라고 생각하시면 됩니다. 보폭이 크면 씩씩하게 걸을 수는 있지만, 방향을 제대로 잡지 못해 알고리즘이 잘못 작동할 가능성이 있습니다. 반대로 보폭을 너무 짧게 하면 방향은 정확하게 정해서 내려갈 수 있겠지만, 속도가 너무 느리게 됩니다. 이는 저희의 퇴근시간에 매우 방해되는 문제입니다. 이 역시도 learning rate를 잘 설정하는 센스가 중요한 영역입니다. 아래의 그래프는 가중치가 변할 때마다 Error 값이 어떻게 낮아지는지 나타냈습니다. 흔히, Cost function이라고 합니다. 왼쪽은 learning rate가 너무 크게 잡혔을 경우, 방향을 잘못 잡아 오히려 올라가는 현상이 발생할 수도 있습니다. 오른쪽은 반대로 learning rate가 너무 낮게 잡혀, 내려가는 과정이 매우 뎌지게 진행됩니다. learning rate가 내려가는 보폭을 정한다면, 방향을 정하는 것은 Delta Function이 담당합니다. 계산 방식은 편미분을 통해 진행이 되는데, 수식이 조금 많이 복잡할 수도 있지만, 간단하게 원리를 설명해 드리겠습니다. 여러분들도 아시다시피 미분을 활용한 최소 혹은 최대점을 찾기 위한 방법입니다. Delta Function은 error surface가 낮아지는 방향을 제시해 주는 역할을 합니다. Error Loss function 정의 2 E r r o s u c i n 2 ( w X ) 1 Σ i 1 ( i ( ⋅ i ) ) 먼저 Error function을 정의하는데, 여기서 2 는 SSE라고 생각하시면 됩니다. ( ⋅ i ) 가 벡터 형태로 표시되어 이질감이 드는 것일 뿐, 풀어쓰면 [ ] w [ ] x [ ] 이기 때문입니다. Error Surface에서 편미분을 통해 global minimum 찾기 ∂ [ ] 1 Σ ( i ( [ ] w [ ] i [ ] ) ) = ∂ w [ ] 1 Σ ( i ( [ ] w [ ] i [ ] ) ) = Loss Function을 각 가중치(기울기, 회귀계수)로 편미분을 하여 0 이 되는 지점을 찾습니다. 이는 회귀분석에서 최소 제곱 법과 비슷한 방식이라고 생각하면 됩니다. 만약 회귀식이 Multiple인 경우에는 식의 형태는 조금 변하겠지만 원리는 바뀌지 않습니다. ∂ [ ] 2 ( w X ) Σ = n ( ( i M ( i ) ) x [ ] ) r o D l a ( , [ ] ) − ∂ [ ] 2 ( w X ) = i 1 ( ( i M ( 복잡한 편미분을 계산하면 Delta Function이 계산이 됩니다. 방향 설정 방법 [ ] w [ ] α i 1 ( ( i M ( i ) ) i [ ] ) 이렇게 learning rate 와 r o D l a 를 곱해준 값을 더해줌으로써 방향과 보폭을 결정할 수 있습니다. Learning rate 및 초기 가중치 설정 방법 마지막으로 최적의 learning rate 및 초기 가중치 설정 방법을 찾아주는 그렇다 할 이론은 없다는 것이 학계의 정설입니다. 초기 가중치 설정은 변수를 Normalizaton을 한 후 추정하는 것이 유리합니다. 여기서 Normalization 이란, o m l z t o ( ) x m n ( ) a ( ) m n ( ) 변환을 의미합니다. 변환 후에 x 값은 [0,1] 사이의 상대적인 비율 값을 가지게 됩니다. Learning rate 및 초기 가중치 설정은 경험적인 판단에서 결정을 내리는 것이 좋습니다. 요약하면 열심히 반복문 코드를 구성해서 실험하라는 뜻입니다. A5. 경사하강법(R Code) 5. 경사하강법(R Code) Gradient Descent를 R code로 구현해 보도록 하겠습니다. 샘플 데이터 생성(난수) x = runif(300, -10,10) # 균일 분포 난수 생성 Noise = rnorm(n = 300, mean = 0 , sd = 3) y = x + Noise DF = data.frame(x = x, y = y) library(ggplot2) ggplot(DF, aes(x= x, y= y)) + geom_point(col = 'royalblue') + theme_bw() Learning Rate 설정 alpha = 0.01 초기 가중치 행렬 생성 Weights = matrix(c(0,0),nrow = 2) Weights [,1] [1, ] 0 [2, ] 0 회귀식 계산을 위한 행렬 생성 이러한 식을 R에서 만들어주어야 하는데, 코드는 다음과 같습니다. # 행렬 형태로 만들어 주기 X = matrix(x) X = cbind(1, X) colnames(X) = c("V1", "V2") # Error 계산 # %*%는 행렬의 곱셈을 할 때 사용합니다. Error = function(x, y, Weight){ sum(( y - x %*% Weight)^2) / (2*length(y)) } 알고리즘 학습 [ ] w [ ] α i 1 ( ( i M ( i ) ) i [ ] ) 학습을 돌리기 전에, Error(Cost) 값과 가중치(회귀계수)가 저장될 빈 공간을 만들어야 합니다. Error_Surface = c() Weight_Value = list() for ( i in 1 : 300){ # X는 (300,2) 행렬 # Weights는 (2,1) 행렬 # X * Weights => (300,1) 행렬[각 데이터에서의 Error 연산] error = (X %*% Weights - y) # Delta Funtion 계산 Delta_function = t(X) %*% error / length(y) # 가중치 수정 Weights = Weights - alpha * Delta_function Error_Surface[i] = Error(X, y, Weights) Weight_Value[[i]] = Weights } 시각화 p = ggplot(DF, aes(x = x, y = y)) + geom_point(col = "royalblue", alpha = 0.4) + theme_bw() for (i in 1:300) { p = p + geom_abline(slope = Weight_Value[[i]][2], intercept = Weight_Value[[i]][1], col = "red", alpha = 0.4) } 다음과 같이 가중치(회귀계수)가 조금씩 움직이면서 최적의 회귀선을 찾아가는 것을 알 수 있습니다. DF$num = 1:300 DF$Error_value = Error_Surface ggplot(DF) + geom_line(aes(x = num, y = Error_value), group = 1) + geom_point(aes(x = num, y = Error_value)) + theme_bw() + ggtitle("Error Function") + xlab("Num of iterations") Error 값 또한 감소하면서 최적의 가중치(기울기)에 수렴하는 것을 확인할 수 있습니다. 최소제곱법을 이용한 선형회귀식과의 비교 일반 선형회귀(최소제곱법) REG = lm(y ~ x) A = summary(REG) print(paste("R Square :", round(A$r.squared, 4))) [1] "R Square : 0.7691" Gradient 경사하강법으로 회귀식을 추정했을 경우, 2 를 구해보면 다음과 같습니다. 우리가 계산한 가중치들은 앞서 저장 공간으로 만들어둔 weight_value에 저장이 되어 있습니다. GR_MODEL = Weight_Value[[300]][1] + Weight_Value[[300]][2] * x actual = y rss = sum((GR_MODEL - actual)^2) tss = sum((actual - mean(actual))^2) rsq = 1 - rss/tss print(paste("R square :", round(rsq, 4))) [1] "R square : 0.7691" 최소 제곱 법과 비교하였을 때, 비슷한 값이 계산되는 것을 확인할 수가 있습니다. A6. 의사결정 나무 6. 의사결정 나무 \ 심리 테스트 책을 보면 복잡한 순서도를 따라 '당신은 어떤 유형의 사람입니다.'라고 알려주는 페이지를 본 적이 있을 것입니다. 의사결정 나무는 비슷한 형태의 분류 알고리즘입니다. 예를 들어, 남자 100명, 여자 100명씩 총 200명으로 구성되어 있는 집단에서 남녀를 분리시키는 분류 규칙 알고리즘을 만들고자 합니다. 단, 생물학적 특성은 분류 규칙에 사용할 수가 없습니다. 분류 규칙 알고리즘을 만들기에 앞서, 의사결정 나무에서 필수적으로 알아야 되는 개념은 불순도(Impurity)입니다. 불순도는 데이터 내에서 여러 카테고리가 섞여 있어, 원하는 표본을 뽑을 확률이 적을 수록 커지는 개념입니다. 만약 통계학과 학부생을 뽑고 싶을 때, 다른 학과의 비율이 높아질수록, 자연스럽게 통계학과를 뽑을 확률은 감소하게 됩니다. 이는 반대로 불순도가 증가한다는 것을 의미합니다. 이 불순도를 지표로 만든 것을 엔트로피(Entropy)라고 합니다. ( ) − i 1 ( [ = ] l g ( [ = ] ) ) [ = ] P o a i i y f l m n t s h t p i 불순도가 높을수록 데이터에서 특정 레벨의 데이터가 뽑힐 확률은 낮아지게 됩니다. 엔트로피는 매우 작은 확률 값을 계산해야 하기에, log 변환을 해줌으로써 값이 큰 음수를 가지도록 합니다. 여기서 음수를 취해주면 불순도가 높은 값은 높은 엔트로피를 가지게 됩니다. 의사결정 나무는 엔트로피를 최대한 낮추는 방향으로 분류 규칙을 만듭니다. 여기서 감소한 엔트로피를 정보 획득(Information Gain)이라고 합니다. 다시 처음의 예시로 돌아가서, 남녀 200명을 분류하는 규칙을 만들어보겠습니다. 남/여를 구별하기 위한 규칙을 만들기 위하여, 저희는 다음과 같은 특성을 구했습니다. 머리 길이 x(cm) 이상 여부 반지 착용 여부 귀걸이 착용 여부 손톱 케어 여부 안경 착용 여부 의사결정 나무에서는 각각의 특성에 따라 얻을 수 있는 정보 획득을 측정합니다. 그리고 정보 획득이 가장 큰 특성이 첫 번째 가지에 자리를 잡게 됩니다. 손톱 케어 여부가 정보 획득이 가장 높은 것을 알 수 있습니다. 그 결과 분류 규칙은 다음과 같습니다. A7. 랜덤 포레스트 7. 랜덤 포레스트 랜덤 포레스트는 의사결정 나무를 많이 심어, 숲을 만든다는 의미로 Forest라 불립니다. 여기서 Random이 붙은 이유는 숲에 심는 의사결정 나무들에 쓰이는 특성들을 랜덤하게 뽑아 만들기 때문에 랜덤 포레스트라고 부릅니다. 랜덤 포레스트에서 특성들을 임의로 선택하여 의사결정 나무를 만드는 이유는 모든 특성들의 조합을 고려하기 위해서입니다. 같은 조합의 특성으로 의사결정 나무를 만들 경우, 대부분의 의사결정 나무는 늘 사용하는 특성만 사용할 확률이 높습니다. 특성을 임의적으로 뽑아 사용하게 함으로써, 모든 요소를 고려한 숲을 만드는 것이 목표입니다. 데이터에 대한 분류 결과 및 예측은 숲에 있는 각 의사결정 나무들이 출력한 결과들을 투표하여 종합합니다. 숲에 나무가 많아질수록, 랜덤 포레스트의 결과는 더 정교하게 되나, 어느 시점에서부터는 정확도가 수렴하게 됩니다. A8. 의사결정 나무, 랜덤 포레스트(R Code) 8. 의사결정 나무, 랜덤 포레스트(R Code) 패키지 불러오기 library(C50) library(caret) library(xtable) Train / Test Set 나누기 HR = read.csv("D:\Drop box\DATA SET\\HR_comma_sep.csv") SL = sample(1:nrow(HR), nrow(HR) * 0.7, replace = FALSE) HR$left = as.factor(HR$left) TRAIN = HR[SL, ] TEST = HR[-SL, ] FEATURE = TRAIN[, c(1:6, 8:10)] RESPONSE = TRAIN[, 7] 의사결정 나무 분류 규칙 생성 tree = C5.0(FEATURE, RESPONSE, control = C5.0Control(noGlobalPruning = FALSE, minCases = 100), trials = 10) plot(tree) C5.0은 Tree 알고리즘 명령어 중 하나입니다. trials는 boosting을 실행하는 옵션입니다. minCasese 옵션은 최종 결과 노드에 최소 몇 개의 관측치를 포함해야 되는지 설정해 줍니다. 회색은 0(이직을 하지 않은 직원), 검은색은 1(이직을 한 직원)을 의미합니다. 각 분류 규칙에 따라 분류 오차율을 확인할 수 있습니다. 만약 mincases 옵션 값을 높게 조정해 주면, 의사결정 나무가 단순해집니다. tree = C5.0(FEATURE, RESPONSE, control = C5.0Control(noGlobalPruning = FALSE, minCases = 300),trials=10) plot(tree) TEST SET 검증 y_pred = predict(tree, newdata = TEST) confusionMatrix(y_pred, TEST$left) Confusion Matrix and Statistics Reference Prediction 0 1 0 3435 87 1 18 960 Accuracy : 0.9767 95% CI : (0.9718, 0.9809) No Information Rate : 0.7673 P-Value [Acc > NIR] : < 2.2e-16 Kappa : 0.9331 Mcnemar's Test P-Value : 3.22e-11 Sensitivity : 0.9948 Specificity : 0.9169 Pos Pred Value : 0.9753 Neg Pred Value : 0.9816 Prevalence : 0.7673 Detection Rate : 0.7633 Detection Prevalence : 0.7827 Balanced Accuracy : 0.9558 'Positive' Class : 0 앞선, 로지스틱 회귀분석보다 분류 결과가 더 좋은 것을 확인할 수가 있습니다. 랜덤 포레스트 ### Random Forest library(randomForest) rf.fit = randomForest(left ~ ., data = TRAIN, mtry = 3, ntree = 200, importance = T) y_pred = predict(rf.fit, TEST) confusionMatrix(y_pred, TEST$left) Confusion Matrix and Statistics Reference Prediction 0 1 0 3448 33 1 5 1014 Accuracy : 0.9916 95% CI : (0.9884, 0.994) No Information Rate : 0.7673 P-Value [Acc > NIR] : < 2.2e-16 Kappa : 0.9761 Mcnemar's Test P-Value : 1.187e-05 Sensitivity : 0.9986 Specificity : 0.9685 Pos Pred Value : 0.9905 Neg Pred Value : 0.9951 Prevalence : 0.7673 Detection Rate : 0.7662 Detection Prevalence : 0.7736 Balanced Accuracy : 0.9835 'Positive' Class : 0 mtry는 랜덤으로 투입할 변수의 개수를 의미합니다. ntree는 몇 개의 의사결정 나무를 만들지 정해주는 옵션입니다. 의사결정 나무보다 더 높은 결과를 얻은 것을 확인할 수 있습니다. varImpPlot(rf.fit, type = 2, pch = 19, col = 1, cex = 1, main = "") importance = T 옵션을 줌으로써, 특성의 중요도 plot을 그릴 수 있습니다. plot(rf.fit$err.rate[, 1], col = "red") Random Forest는 알고리즘 내부에서 Train / Test Set을 나눠서 검증을 합니다. 여기서 Train Set에 포함되지 않은 데이터들을 Out of Bag이라 하여, 오류율을 계산합니다. 해당 plot은 랜덤 포레스트 내부에서 의사결정 나무가 많아질수록 오류율이 어떻게 변하는지 보여주고 있습니다. 오류율이 수렴하는 거를 확인할 수 있습니다. ROC 커브 기계학습 방법론을 활용한 결괏값에 대해서도 모형의 성능 평가를 위한 ROC 커브를 만들 수가 있습니다. 대신에 predict 단계에서 확률 값을 추정하도록 옵션을 추가해야 합니다. 비교를 위하여 전에 진행했던 로지스틱 모형도 다시 만들어보도록 하겠습니다. GLM = step(glm(left ~ ., data = TRAIN, family = binomial(link = "logit"))) Start: AIC=9038.94 left ~ satisfaction_level + last_evaluation + number_project + average_montly_hours + time_spend_company + Work_accident + promotion_last_5years + sales + salary Df Deviance AIC <none> 9000.9 9038.9 - sales 9 9027.9 9047.9 - last_evaluation 1 9012.4 9048.4 - promotion_last_5years 1 9036.2 9072.2 - average_montly_hours 1 9068.3 9104.3 - number_project 1 9174.9 9210.9 - time_spend_company 1 9208.0 9244.0 - Work_accident 1 9250.9 9286.9 - salary 2 9303.6 9337.6 - satisfaction_level 1 10576.9 10612.9 GLM_pred = predict(GLM, newdata = TEST, type = "response") Tree_pred = predict(tree, newdata = TEST, type = "prob") RF_pred = predict(rf.fit, newdata = TEST, type = "prob") library(pROC) GLM_ROC = roc(TEST$left, GLM_pred) Tree_ROC = roc(TEST$left, Tree_pred[, 2]) RF_ROC = roc(TEST$left, RF_pred[, 2]) ROC_DF = data.frame( SEN = c(GLM_ROC$sensitivities, Tree_ROC$sensitivities, RF_ROC$sensitivities), SPE = c(GLM_ROC$specificities, Tree_ROC$specificities, RF_ROC$specificities), Model = c(rep("GLM",length(GLM_ROC$sensitivities)), rep("Tree",length(Tree_ROC$sensitivities)), rep("RF",length(RF_ROC$sensitivities))) ) ggplot(ROC_DF) + geom_line(aes(x = 1-SPE, y = SEN, col = Model),size = 1.2) + xlab("1-specificity") + ylab("sensitivity") + theme_bw() + theme(legend.position = "bottom", legend.box.background = element_rect(), legend.box.margin = ggplot2::margin(2,2,2,2), text = element_text(size = 15)) 위 ROC 커브를 보시면 Random Forest가 가장 성능이 좋은 것을 확인할 수가 있습니다. 다만, 기계학습의 알고리즘은 종류가 매우 많으며, 딥러닝과 함께 성능이 훌륭하다고 알려져 있습니다. 하지만, 그렇다고 만능 알고리즘인 것은 아닙니다. 데이터에 따라 적합한 기계학습 방법론이 있는 것이고, 단순한 통계분석이 더 효과가 좋을 때가 있기도 합니다. 즉, 데이터 분석은 좋은 알고리즘을 쓰면 해결이 되는 것이 아니라, 데이터를 잘 정릴한 후, 적절한 분석방법을 적용하는 것이 가장 좋은 방법인 것을 유의하시길 바랍니다. A9. 교차 타당성(Cross Validation) Cross Validation 이번에는 Cross Validation에 대해 다루도록 하겠습니다. Cross Validation 이란 Train, Test set을 나누는 과정을 피자 조각처럼 나누어 할당하는 것으로 이해하시면 편합니다. 위 그림을 보시면 Data를 4조각으로 나눈 다음에 서로 돌아가면서 Test Set의 역할을 돌아가면서 하는 것을 확인할 수가 있습니다. 즉 쉽게 생각하면 Train set으로 모형을 만들고 Test set으로 검증하는 단계를 쪼갠 만큼 반복하는 것으로 생각하시면 됩니다. 이렇게 하는 이유는 모형의 타당성(Validation) 확보에 있습니다. ’이렇게 나누고, 저렇게 나누어도 비슷한 결과가 나온다. 그러니 이 모형은 타당하다.’의 주장을 입증하기 위함입니다. 여기서 마지막으로 계산되는 값은 Cross-Validateion Error(CVE)라고 합니다. V = n k 1 n M E M E = n ∑ ∈ k ( i y i [ k ] ) library(ggplot2) library(dplyr) library(reshape) library(factoextra) library(FactoMineR) AMES = read.csv("D:\Drop box\DATA SET(Drop box)\Ames_City.csv",stringsAsFactors = FALSE) 다음의 데이터로 Cross Validation Error을 계산해 보도록 하겠습니다. 조각은 6조각으로 나누도록 하겠습니다. 이때 4-CV가 됩니다. K = 4 Sample = sample(rep(1:K, length = nrow(AMES))) MSE_V = c() for(i in 1:K){ TRAIN = AMES[which(Sample != i),] TEST = AMES[which(Sample == i),] NonLinear = lm(SalePrice ~ poly(Overall.Qual, 2), data = TRAIN) NonLinear_Predicted = predict(NonLinear, newdata = TEST) NonLinear_E = TEST$SalePrice - NonLinear_Predicted MSE_V[i] = sum(NonLinear_E^2)/nrow(TEST) } 계산은 매우 간단합니다. 데이터를 4조각으로 나눈 다음에 for 문을 활용하여 차례대로 Modeling 및 검증을 반복하면 됩니다. names(MSE_V) = 1:K MSE_V 1 2 3 4 1872540857 1798261932 2149470897 2055542227 위 결괏값을 확인하면 4번 모두 비슷하면서도 다른 값이 나온 것을 확인할 수가 있습니다. 이제 이 값들에 대해 평균을 취해주면 CVE를 계산할 수가 있습니다. 사실 SalePrice의 값이 매우 크기 때문에 좀 비교하기가 애매하기는 합니다.(사실 이런 문제점들을 개선하기 위하여 데이터에 대해 log 변환, Normalization, Scaling 등을 진행해 줍니다. 저도 비교하기가 어렵기 때문에 log 변환을 하고 진행하도록 하겠습니다. K = 4 Sample = sample(rep(1:K, length = nrow(AMES))) MSE_V = c() for(i in 1:K){ TRAIN = AMES[which(Sample != i),] TEST = AMES[which(Sample == i),] NonLinear = lm(log(SalePrice) ~ poly(Overall.Qual, 2), data = TRAIN) NonLinear_Predicted = predict(NonLinear, newdata = TEST) NonLinear_E = log(TEST$SalePrice) - NonLinear_Predicted MSE_V[i] = sum(NonLinear_E^2)/nrow(TEST) } names(MSE_V) = 1:K MSE_V 1 2 3 4 0.04370626 0.05303571 0.06134567 0.05373700 log 변환을 하고 회귀분석을 하니 결과가 비슷하게 나오는 것을 확인할 수가 있습니다. mean(MSE_V) [1] 0.05295616 CVE는 0.053 정도가 나오는 것을 확인할 수가 있습니다. 심화문제 사실 위 문제는 어찌 보면 매우 간단합니다. 그러니 이번에는 좀 더 난해한 산점도를 난수 생성한 다음에 Cross Validation을 해보도록 하겠습니다. set.seed(10000) X = runif(n = 1000, min = -10, max = 10) Y = sin(X) + rnorm(n = 1000, mean = 0, sd = 0.3) ggplot(NULL) + geom_point(aes(x = X, y = Y), col = 'royalblue', alpha = 0.5) + geom_smooth(aes(x = X, y = Y), se = FALSE, col = 'red') + theme_bw() + theme(text = element_text(size = 15, face = "bold")) 보기만 해도 아찔합니다. 이걸 회귀선으로 한번 적합해 보는 연습을 해 보도록 하겠습니다. 먼저, 이 회귀선에 대해 우리는 몇 차 항을 적용시켜야 될지도 잘 모르겠습니다. 그러니 항차를 몇 차 항으로 주어야 할지도 실험을 통해 확인해야 됩니다. 이 문제를 해결하기 위한 for 문의 parameter는 다음과 같습니다. Replication : R(실험 반복 횟수) Degree : D(비선형 회귀의 항차) Kfold : K(K-CV) 어려울 수 있지만 어차피 해야 되는 것은 동일합니다. 핵심 알맹이는 어차피 회귀분석을 진행하고 MSE를 계산하는 것입니다. 위에서 만들었던 코드를 기준으로 윗단에는 Replication, 아랫단에는 Degree에 해당되는 for 문을 추가시켜주면 됩니다. 다만, for 문에서 산출되는 값들을 저장해야 될 데이터 공간들은 헷갈릴 수가 있습니다. 최대한 주석을 달도록 하겠습니다. set.seed(12123) R = 10 D = 20 K = 5 d = 5 MSE_R = list() VAR_R = list() for(r in 1:R){ Sample = sample(rep(1:K, length = length(X))) # Cross Validatiton 값 저장 공간 MSE_CV = list() VAR_CV = list() for(k in 1:K){ # Degree에 따른 값 저장 공간 MSE_Degree = c() VAR_Degree = c() MSE_Degree[1] = NA VAR_Degree[1] = NA TRAIN_X = X[which(Sample != k)] TRAIN_Y = Y[which(Sample != k)] TRAIN_DF = data.frame( Y = TRAIN_Y, X = TRAIN_X ) TEST_X = X[which(Sample == k)] TEST_Y = Y[which(Sample == k)] TEST_DF = data.frame( Y = TEST_Y, X = TEST_X ) for(d in 2:D){ NonLinear = lm(Y ~ poly(X, d), data = TRAIN_DF) NonLinear_Predicted = predict(NonLinear, newdata = TEST_DF) NonLinear_E = TEST_Y - NonLinear_Predicted # Degree에 따른 MSE, VAR 값 저장 MSE_Degree[d] = sum(NonLinear_E^2)/nrow(TEST) VAR_Degree[d] = var(NonLinear_Predicted) } # CV에 따른 MSE, VAR 값 저장 MSE_CV[[k]] = MSE_Degree VAR_CV[[k]] = VAR_Degree } ### CV DATAFRAME CVE_DF = data.frame( DEGREE = 1:D ) for(i in 1:k){ CVE_DF = cbind(CVE_DF, MSE_CV[[i]]) } ### VAR DATAFRAME VAR_DF = data.frame( DEGREE = 1:D ) for(i in 1:k){ VAR_DF = cbind(VAR_DF, VAR_CV[[i]]) } ### CVE 계산 CVE = rowMeans(CVE_DF[,2:(k+1)],na.rm = TRUE) VAR_E = rowMeans(VAR_DF[,2:(k+1)],na.rm = TRUE) MSE_R[[r]] = CVE VAR_R[[r]] = VAR_E } ### 최종 저장 CVE_R = data.frame( DEGREE = 1:D ) for(i in 1:R){ CVE_R = cbind(CVE_R, MSE_R[[i]]) colnames(CVE_R)[i+1] = paste0("R",i) } ### VAR DATAFRAME VAR_RDF = data.frame( DEGREE = 1:D ) for(i in 1:R){ VAR_RDF = cbind(VAR_RDF, VAR_R[[i]]) colnames(VAR_RDF)[i+1] = paste0("R",i) } Replication 및 Degree에 따른 MSE 값 Replication 및 Degree에 따른 VAR 값 반복 횟수, Degree, K-CV를 모두 고려한 실험 코드를 완성했습니다. 이제 결과를 확인해 보도록 하겠습니다. CVE_R %>% melt(id.vars = c("DEGREE")) %>% na.omit() %>% ggplot() + geom_point(aes(x = DEGREE, y = value, col = variable)) + geom_line(aes(x = DEGREE, y = value, col = variable)) + labs(col = "Replications") + ylab("MSE(CV)") + theme_bw() + theme(text = element_text(size = 15, face = "bold"), legend.position = "top") MSE의 경우 10차 항 이후부터는 크게 변동이 없는 것을 확인할 수가 있습니다. VAR_RDF %>% melt(id.vars = c("DEGREE")) %>% na.omit() %>% ggplot() + geom_point(aes(x = DEGREE, y = value, col = variable)) + geom_line(aes(x = DEGREE, y = value, col = variable)) + labs(col = "Replications") + ylab("VAR(CV)") + theme_bw() + theme(text = element_text(size = 15, face = "bold"), legend.position = "top") Bias-Variance trade-off의 관계에 따라서 Var도 매우 폭등한 것을 확인할 수가 있습니다. 이제 두 그래프를 동시에 비교해 보도록 하겠습니다. rbind( CVE_R %>% melt(id.vars = c("DEGREE")) %>% mutate(G = "MSE") %>% na.omit(), VAR_RDF %>% melt(id.vars = c("DEGREE")) %>% mutate(G = "VAR") %>% na.omit() ) %>% group_by(DEGREE, G) %>% summarise(value = mean(value)) %>% ggplot() + geom_point(aes(x = DEGREE, y = value, col = G),size = 5) + geom_line(aes(x = DEGREE, y = value, col = G),size = 1.2) + labs(col = "Value") + ylab("MSE & VAR") + theme_bw() + theme(text = element_text(size = 15, face = "bold"), legend.position = "top") ChB6. Case Study 이번 장에서는 Case Study를 통해 실제 데이터를 어떤 관점으로 분석하는지 알아보도록 하겠습니다. A1. Case Study(EDA 편 1) Case Study 1 1. 탐색적 자료분석 이번 포스팅에서는 중고 자동차 가격 데이터에 대해 EDA(탐색적 자료분석)를 진행해 보도록 하겠습니다. 탐색적 자료분석(EDA, Exploratory Data Analysis)은 데이터 분석에 있어서 매우 중요한 step입니다. 절차는 본 분석에 진행되기에 앞서 어떻게 데이터를 분석할 건지 탐색하는 것입니다. 사회에서 가장 통계분석을 못하는 유형은 탐색적 분석 절차를 거치지 않고 바로 모델링부터 도전하려는 사람들입니다. 이 글을 읽으시는 분들은 그런 실수를 안 하시기를 바랍니다. 탐색적 자료분석은 정답이 있는 것이 아닙니다. 그저 짧은 시간을 투자해 최대한의 정보를 뽑아, 데이터에 대해 이해를 하는 단계라고 보시면 됩니다. 다양한 방법들이 존재하지만, 제가 주로 하는 방법은 ’시각화’입니다. 시각화만큼 데이터를 바로 이해하기 좋은 방법은 없습니다. 시각화를 주로 사용하지만, 필요에 따라 간단하게 Linear Model들 또한 활용을 합니다. Linear Model이라 하면 t-test, 분산분석, 회귀분석 등이 해당이 됩니다. 2. 데이터 및 패키지 로딩 데이터 다운로드 링크: https://www.kaggle.com/aryamonani/car-price-predictions library(ggplot2) library(dplyr) library(reshape) CAR = read.csv("D:\Drop box\DATA SET(Drop box)\car-price-predictions\1.04. Real-life example.csv") colnames(CAR)[1] = "Brand" str(CAR) 'data.frame': 4345 obs. of 9 variables: $ Brand : Factor w/ 7 levels "Audi","BMW","Mercedes-Benz",..: 2 3 3 1 6 3 2 1 5 7 ... $ Price : num 4200 7900 13300 23000 18300 ... $ Body : Factor w/ 6 levels "crossover","hatch",..: 4 6 4 1 1 1 4 5 5 3 ... $ Mileage : int 277 427 358 240 120 0 438 200 193 212 ... $ EngineV : num 2 2.9 5 4.2 2 5.5 2 2.7 1.5 1.8 ... $ Engine.Type : Factor w/ 4 levels "Diesel","Gas",..: 4 1 2 4 4 4 2 1 1 2 ... $ Registration: Factor w/ 2 levels "no","yes": 2 2 2 2 2 2 2 2 2 1 ... $ Year : int 1991 1999 2003 2007 2011 2016 1997 2006 2012 1999 ... $ Model : Factor w/ 312 levels "1 Series","100",..: 19 267 239 225 228 146 19 67 190 150 ... colSums(is.na(CAR)) Brand Price Body Mileage EngineV Engine.Type 0 172 0 0 150 0 Registration Year Model 0 0 0 CAR = na.omit(CAR) 데이터는 꽤 간단합니다. 우리의 목적은 차량 가격을 예측하는 것입니다. 차량 가격을 나타내는 변수인 Price를 중심으로 EDA를 진행해 보도록 하겠습니다. 또한 결측치가 존재하기 때문에 결측치가 포함된 데이터는 삭제를 해주겠습니다. 3. 브랜드에 따른 차량 가격 시각화 먼저 가장 관심 있는 브랜드에 따라 차량 가격의 분포가 다른지 확인해 보겠습니다. 브랜드는 범주형 자료, 차량 가격은 연속형 자료이기 때문에, 이에 적합한 시각화 방법을 선택해야 됩니다. 이럴 때, 박스 플롯은 탐색적 분석에서 매우 유용한 그래프입니다. ggplot(CAR) + geom_boxplot(aes(x = Brand, y = Price), outlier.colour = "red") + theme_bw() + theme(text = element_text(size = 15, face = "bold"), axis.text.x = element_text(angle = 90)) 빨간 점은 outlier(이상점)을 의미합니다. 일반적인 범위에서 벗어나는 차량 가격들입니다 메르세데스 벤츠의 경우가 상당히 이상점이 많은 것을 확인할 수가 있습니다. ggplot(CAR) + geom_boxplot(aes(x = Brand, y = Price), outlier.colour = "red") + theme_bw() + theme(text = element_text(size = 15, face = "bold"), axis.text.x = element_text(angle = 90)) + facet_wrap(~Body) 이번에는 차량의 Body에 따라 어떤지 살펴보겠습니다. 어떤 Body의 차량들이 많이 고가인지 살펴보니 주로 crossover, sedan, van, other 등에 위치한 것을 볼 수 있습니다. 근데, 전체적으로 가격이 높은 Body는 crossover입니다. 다른 Body들은 이상점이 높은 건데, crossover은 그냥 상자 자체가 매우 큰 것을 확인할 수가 있습니다. 여기서 하나 확인할 수는 있는 것이 기본적으로 차량 가격에 이상점이 매우 많다는 것입니다. 이상점이 많을 경우, 통계적인 분석에 많은 error가 발생할 수가 있습니다. 그러므로 다음 단계에서는 Price에 대한 분포를 살펴보도록 하겠습니다. 4. 차량 가격 분포 탐색 ggplot(CAR) + geom_histogram(aes(x = Price, y = .. density..), fill = 'royalblue',col ='black',alpha = 0.4) + geom_density(aes(x = Price),col = 'red', size = 1.2) + xlab("Price") + ylab("Density") + scale_x_continuous(expand = c(0,0)) + scale_y_continuous(expand = c(0,0)) + theme_bw() + theme(text = element_text(size = 15, face = "bold")) 차량 가격에 대한 분포를 살펴보시면, 매우 오른쪽으로 꼬리가 치우친 분포인 것을 확인할 수가 있습니다. 이런 데이터는 정규분포와 매우 거리가 먼 상황입니다. 모든 데이터가 정규분포일 필요는 없지만, 적어도 분석하고자 하는 Target 변수는 정규분포를 따라주는 게 분석의 피로도를 줄일 수 있습니다. qqnorm(CAR$Price) qqplot을 그려보면 역시나, 정규분포와 거리가 멀다는 것을 확인할 수가 있습니다. 근데 분포가 오른쪽으로 꼬리가 치우친 경우는 사실 매우 간단하게 처리를 할 수가 있습니다. log 변환을 주면 오른쪽으로 매우 치우친 분포를 중앙으로 집결시킬 수가 있습니다. ## Log Transform ggplot(CAR) + geom_histogram(aes(x = log(Price), y = .. density..), fill = 'royalblue',col ='black',alpha = 0.4, binwidth = 0.1) + geom_density(aes(x = log(Price)),col = 'red', size = 1.2) + xlab("Price") + ylab("Density") + scale_x_continuous(expand = c(0,0)) + scale_y_continuous(expand = c(0,0)) + theme_bw() + theme(text = element_text(size = 15, face = "bold")) qqnorm(log(CAR$Price)) 로그 변환 한번 했을 뿐인데, 매우 정규분포와 유사해졌습니다. log 변환된 값이기는 하지만, 분석을 할 때 이 log 변환 된 값을 중심으로 분석을 하는 것이 더 통계적으로 유의한 결과들을 만들어낼 수 있는 가능성이 높아집니다. 가능성이 높아진다고 하는 얘기는, 통계분석에는 정해진 정답이 없기 때문입니다. “이 방법이 제일 좋다”라는 것은 통계분석에서 존재하지 않습니다. 즉 상황마다 적합한 분석방법이 모두 존재하는 것입니다. 5. Brand와 Body의 Price에 대한 Interaction effect 분석 교호 효과는 두 범주형 변수들의 수준(levels) 조합에 따라 Target 변수의 기댓값이 달라지는가 나타내는 효과입니다. 주로 하나의 범주형 변수 수준(levels)에 따라 Target 변수들의 기댓값 차이를 보는데, 이럴 때는 주효과(Main Effect)라고 합니다. 교호 효과를 보는 방법은 간단합니다. 변수의 조합에 따라 기댓값(평균)의 변화를 나타내는 그래프를 그려주면 됩니다. # Log CAR %>% group_by(Brand, Body) %>% summarise(Mean = mean(log(Price))) %>% ggplot() + geom_point(aes(x = Brand, y = Mean, col = Body)) + geom_line(aes(x = Brand, y = Mean, col = Body, group = Body)) + theme_bw() + theme(text = element_text(size = 15, face = "bold"), axis.text.x = element_text(angle = 90)) 교호 효과를 확인하는 좋은 방법은 선들이 만나는가 안 만나는 가입니다. 즉, 선들이 변수에 따라 평행 관계를 유지하고 있으면 딱히 교호 효과가 없다고 볼 수 있습니다. 예를 들어 crossover, other에 대한 수준은 Brand 별로 비슷한 패턴을 보이고 있습니다. 하지만, hatch를 살펴보시면 벤츠와 미츠 비씨에서 아주 꼬라박고 있다는 것을 확인할 수가 있습니다. 꼬라박으면서 다른 선들과 겹치게 되죠. 이런 상황이 교호 효과가 존재할 수 있다는 합리적 의심을 가질 수 있게 도와줍니다. 교호 효과가 정말 있는지 통계적으로 검정하는 방법은 분산분석을 활용하면 됩니다. ## Anova ANOVA = aov(log(Price) ~ Brand + Body + Brand:Body, data = CAR) summary(ANOVA) Df Sum Sq Mean Sq F value Pr(>F) Brand 6 331.4 55.23 93.232 <2e-16 *** Body 5 715.5 143.11 241.560 <2e-16 *** Brand:Body 29 96.7 3.33 5.628 <2e-16 *** Residuals 3984 2360.2 0.59 --- Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 Two Way ANOVA를 진행해 본 결과, 역시나 주효과와 교호 효과가 모두 존재하는 것을 확인할 수가 있습니다. 분산분석 표에 대해서는 따로 설명을 적지는 않겠습니다. 분산분석의 결과가 유의할 경우 사후 검정을 같이 해주는 것이 국룰이지만, 지금은 범주형 자료들의 수준이 너무 많기 때문에, 해봤자 머리만 아파집니다. 효율이 없으니 넘어가도록 합니다. A2. Case Study(EDA 편 2) 6. 자동차 모델 및 주행거리에 따른 Price 분석 300여 개의 자동차 모델에 대해 4025개의 중고 자동차 가격이 있는 데이터입니다. 그런 관계로 우리는 자동차 모델에 따라 값을 보기 위해서는 데이터를 요약해 주어야 합니다. CAR %>% group_by(Model, Brand) %>% summarise(Mean_Price = mean(log(Price)), Mean_Mile = mean(Mileage)) %>% ggplot() + geom_text(aes(x = Mean_Mile, y = Mean_Price, label = Model, col = Brand)) + theme_bw() + theme(text = element_text(size = 15, face = "bold"), legend.position = c(0.8,0.8)) ggplot(CAR) + geom_point(aes(x = Mileage, y = log(Price))) + geom_smooth(aes(x = Mileage, y = log(Price))) + theme_bw() + theme(text = element_text(size = 15, face = "bold")) 보시면 Mileage(주행거리)에 따라 가격이 하락하고 있는 것을 확인할 수가 있습니다. 이런 경우 우리는 회귀분석을 적용해 볼 수가 있습니다. 참고로 만약 log 변환을 하지 않은 데이터로 산점도를 그려볼 경우, 다음과 같은 그래프가 나옵니다. ggplot(CAR) + geom_point(aes(x = Mileage, y = Price)) + geom_smooth(aes(x = Mileage, y = Price)) + theme_bw() + theme(text = element_text(size = 15, face = "bold")) 만약 로그 변환을 안 했다면, 유의한 관계를 찾기 힘들 가능성이 높았을 겁니다. o ( r c) β + 1 i e g l g ( r c) β + 1 i e g + 그래프 상에서 비선형 관계도 보이므로 일반 선형회귀와 다항회귀분석을 진행해 보겠습니다. # Simple Linear Reg = lm(log(Price) ~ Mileage, data = CAR) summary(Reg) Call: lm(formula = log(Price) ~ Mileage, data = CAR) Residuals: Min 1Q Median 3Q Max -3.8327 -0.4511 0.0226 0.4749 6.0869 Coefficients: Estimate Std. Error t value Pr(>|t|) (Intercept) 10.2830105 0.0221983 463.23 <2e-16 *** Mileage -0.0053392 0.0001147 -46.54 <2e-16 *** --- Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 Residual standard error: 0.7524 on 4023 degrees of freedom Multiple R-squared: 0.35, Adjusted R-squared: 0.3498 F-statistic: 2166 on 1 and 4023 DF, p-value: < 2.2e-16 2 34.98 가 나왔습니다. 변수 하나만을 투입했는데 이 정도면 나쁜 것은 아니라고 봅니다. # Polynomial Poly_Reg = lm(log(Price) ~ poly(Mileage, 2), data = CAR) summary(Poly_Reg) Call: lm(formula = log(Price) ~ poly(Mileage, 2), data = CAR) Residuals: Min 1Q Median 3Q Max -4.0717 -0.4301 0.0498 0.4844 2.6382 Coefficients: Estimate Std. Error t value Pr(>|t|) (Intercept) 9.40967 0.01146 821.01 <2e-16 *** poly(Mileage, 2) 1 -35.01901 0.72713 -48.16 <2e-16 *** poly(Mileage, 2) 2 12.29046 0.72713 16.90 <2e-16 *** --- Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 Residual standard error: 0.7271 on 4022 degrees of freedom Multiple R-squared: 0.3931, Adjusted R-squared: 0.3928 F-statistic: 1303 on 2 and 4022 DF, p-value: < 2.2e-16 2 39.28 가 나왔습니다. 역시 선형회귀보다는 더 적합을 잘하는 것을 확인할 수가 있습니다. 다항회귀 항차를 더 높여볼 수도 있지만, 그래프 상에서 2차함수 꼴을 보였으니 굳이 더 올려서 분석해 볼 필요는 없을 것 같습니다. 원하시는 분은 한번 항차를 추가해서 값이 어떻게 변하는지 확인을 해보셔도 될 것 같습니다. A3. Case Study(EDA 편 3) 7. 엔진과 차량 가격 분석 이번에는 엔진 변수를 활용해서 차량 가격을 분석해 보도록 하겠습니다. ggplot(CAR) + geom_point(aes(x = EngineV, y = log(Price))) + theme_bw() + theme(text = element_text(size = 15, face = "bold")) EngineV와 Price 간의 산점도인데, 매우 괴상하게 생겼습니다. 이런 그래프를 만나면 한 가지 팁이 있습니다. x 축의 범위를 조절해서 그래프를 다시 그려보는 것입니다ㅣ. 그 이유는 x 범위는 매우 넓은 것에 비해 대부분의 데이터는 한쪽에 몰려있기 때문입니다. ggplot(CAR) + geom_point(aes(x = EngineV, y = log(Price))) + theme_bw() + theme(text = element_text(size = 15, face = "bold")) + scale_x_continuous(limits = c(0,10)) 그래프를 잘라서 보니 다른 관계가 보입니다. 탐색적 자료분석의 핵심은 이런 부분에 있습니다. 데이터를 쪼개서도 보고 하나하나 살펴보며, 어떤 함정이 숨어있는지 발견하는 것, 이게 바로 데이터 분석을 정확하게 할 수 있는 실력의 지름길이 됩니다. ggplot(CAR) + geom_boxplot(aes(x = Engine.Type, y = log(Price), fill = Engine.Type), alpha = 0.4, outlier.colour = 'red') + geom_jitter(aes(x = Engine.Type, y = log(Price), col = Engine.Type), alpha = 0.4) + theme_bw() + theme(text = element_text(size = 15, face = "bold")) 다음으로는 엔진 타입에 대해 그래프를 그렸습니다. 역시 엔진 타입에 따라서도 가격이 다른 것을 확인할 수가 있습니다. 범주형 변수의 수준에 따른 기댓값(평균)의 차이가 있는지 확인하기 위하여 다시 한번 분산분석을 진행해 보도록 하겠습니다. ANOVA = aov(log(Price) ~ Engine.Type, data = CAR) summary(ANOVA) Df Sum Sq Mean Sq F value Pr(>F) Engine.Type 3 44 14.78 17.18 4.41e-11 *** Residuals 4021 3460 0.86 --- Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 분산분석 결과 차이가 매우 유의하다는 것을 확인할 수가 있습니다. 이번에는 수준 수가 4개이기 때문에 사후 검정을 진행해 보도록 하겠습니다. TUKEY = TukeyHSD(ANOVA) TUKEY Tukey multiple comparisons of means 95% family-wise confidence level Fit: aov(formula = log(Price) ~ Engine.Type, data = CAR) $Engine.Type diff lwr upr p adj Gas-Diesel -0.24113612 -0.35376896 -0.12850328 0.0000003 Other-Diesel -0.25238630 -0.49043654 -0.01433606 0.0327292 Petrol-Diesel 0.05838048 -0.02483674 0.14159771 0.2719751 Other-Gas -0.01125018 -0.26273875 0.24023839 0.9994567 Petrol-Gas 0.29951661 0.18331123 0.41572198 0.0000000 Petrol-Other 0.31076679 0.07100555 0.55052802 0.0048353 plot(TUKEY) 사후 검정 결과가 나왔습니다. 좀 자세히 정리해 볼 필요가 있겠습니다. 각 차이에 대한 95% 신뢰구간이 0을 포함하는지 안 하는지만 확인하시면 됩니다. 그러면 다음과 같이 정리가 가능합니다. 혹은 p-value를 통해 확인하셔도 문제는 없습니다. a − i s l 0 t e − i s l 0 e r l D e e = O 이번에는 엔진과 엔진 타입을 포함하여 가변 수 회귀분석을 진행해 보도록 하겠습니다. 이번에는 엔진과 엔진 타입을 포함하여 가변 수 회귀분석을 진행해 보도록 하겠습니다. Reg2 = lm(log(Price) ~ Engine.Type + EngineV, data = CAR) summary(Reg2) Call: lm(formula = log(Price) ~ Engine.Type + EngineV, data = CAR) Residuals: Min 1Q Median 3Q Max -3.08079 -0.55506 -0.05422 0.57677 3.10458 Coefficients: Estimate Std. Error t value Pr(>|t|) (Intercept) 9.408607 0.022757 413.431 < 2e-16 *** Engine.TypeGas -0.243758 0.043793 -5.566 2.77e-08 *** Engine.TypeOther -0.272324 0.092793 -2.935 0.00336 ** Engine.TypePetrol 0.055358 0.032366 1.710 0.08727. EngineV 0.008598 0.002969 2.896 0.00379 ** --- Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 Residual standard error: 0.9267 on 4020 degrees of freedom Multiple R-squared: 0.01471, Adjusted R-squared: 0.01373 F-statistic: 15 on 4 and 4020 DF, p-value: 3.54e-12 만약 EngineV에 데이터 범위를 조정하지 않을 경우 회귀분석의 결과는 정말 처참하게 나옵니다. 그렇기 때문에 EngineV를 활용해 데이터를 추출해 보고 다시 돌려보도록 하겠습니다. CAR2 = subset(CAR, EngineV < 10) Reg2s = lm(log(Price) ~ Engine.Type + EngineV, data = CAR2) summary(Reg2s) Call: lm(formula = log(Price) ~ Engine.Type + EngineV, data = CAR2) Residuals: Min 1Q Median 3Q Max -3.11037 -0.47377 0.01656 0.53087 2.39005 Coefficients: Estimate Std. Error t value Pr(>|t|) (Intercept) 8.40716 0.03649 230.402 <2e-16 *** Engine.TypeGas -0.39544 0.03916 -10.098 <2e-16 *** Engine.TypeOther -0.19139 0.08363 -2.289 0.0222 * Engine.TypePetrol -0.05580 0.02898 -1.925 0.0542. EngineV 0.44104 0.01336 33.008 <2e-16 *** --- Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 Residual standard error: 0.8222 on 4000 degrees of freedom Multiple R-squared: 0.224, Adjusted R-squared: 0.2232 F-statistic: 288.6 on 4 and 4000 DF, p-value: < 2.2e-16 2 가 나름 22% 까지 상승한 것을 볼 수가 있습니다. 이 정도면 엔진 타입도 효과를 준다고 볼 수가 있습니다. Petrol Type에 대한 회귀계수 검정의 p-value가 0.0542로 0.05보다 높지만, 아주 높은 것도 아니며, 탐색적 자료분석은 Rough 하게 분석하는 것이 주요 point입니다. 처음부터 너무 잔혹하게 볼 필요는 또 없는 것입니다. 여기서 우리에게 주어진 과제는 다음과 같습니다. EngineV를 어떻게 처리를 해야 되는 것인가? Mileage를 어떻게 처리를 해야 하는 것인가? EngineV는 바로 위에서 사례를 봤으며, Mileage는 Mileage가 큰 경우에 한 해 선형 데이터가 비선형으로 꺾여버리는 문제점이 존재하기 때문입니다. 이런 상황은 사실 데이터를 예측 모델링 혹은 관계를 설명하기 위한 모델링을 진행하는데 매우 방해가 됩니다. 그렇기 때문에, 값을 자르고 갈 것인지, 안고 갈 것인지 선택을 해야 합니다. 이건 데이터 분석가들의 생각에 따라 갈리게 됩니다. 즉 자신이 맞는다고 생각하는 방향으로 진행하면 됩니다. 대신에 그 이유는 충분히 설명할 수는 있어야 합니다("분석은 설득입니다"). 이렇게 차량의 특징들이 차량 가격에 어떤 관계를 가지고 있는지 확인을 하는 탐색적 자료분석을 진행했습니다. A4. Case Study(Modeling 편 1) Case Study 2 이번 케이스스터디는 새로운 데이터를 기준으로 데이터 분석을 처음부터 끝까지 진행하는 과정에 대해 알아보도록 하겠습니다. 이번 장에서의 목표는 하나하나 깊게 해석하는 것이 아니라, 효율적으로 빠르게 결과를 뽑아내는 방법에 대해 다루어보도록 하겠습니다. 1. 데이터 설명 데이터 다운로드 링크 : https://www.kaggle.com/pavansubhasht/ibm-hr-analytics-attrition-dataset Kaggle에 있는 IBM_HR 데이터를 활용하였습니다. 이 책에서 꾸준히 예시로 사용한 HR_comma_sep 데이터와 유사한 성격의 인사관리 데이터입니다. 이 친숙할 수 있는 데이터를 통해 통계분석을 진행하는 방법에 대해 다뤄보도록 하겠습니다. 2. 데이터 불러오기 IBM = read.csv("D:\Drop box\DATA SET(Drop box)\IBM_HR.csv") colnames(IBM)[1] = "Age" str(IBM) 'data.frame': 1470 obs. of 35 variables: $ Age : int 41 49 37 33 27 32 59 30 38 36 ... $ Attrition : Factor w/ 2 levels "No","Yes": 2 1 2 1 1 1 1 1 1 1 ... $ BusinessTravel : Factor w/ 3 levels "Non-Travel","Travel_Frequently",..: 3 2 3 2 3 2 3 3 2 3 ... $ DailyRate : int 1102 279 1373 1392 591 1005 1324 1358 216 1299 ... $ Department : Factor w/ 3 levels "Human Resources",..: 3 2 2 2 2 2 2 2 2 2 ... $ DistanceFromHome : int 1 8 2 3 2 2 3 24 23 27 ... $ Education : int 2 1 2 4 1 2 3 1 3 3 ... $ EducationField : Factor w/ 6 levels "Human Resources",..: 2 2 5 2 4 2 4 2 2 4 ... $ EmployeeCount : int 1 1 1 1 1 1 1 1 1 1 ... $ EmployeeNumber : int 1 2 4 5 7 8 10 11 12 13 ... $ EnvironmentSatisfaction : int 2 3 4 4 1 4 3 4 4 3 ... $ Gender : Factor w/ 2 levels "Female","Male": 1 2 2 1 2 2 1 2 2 2 ... $ HourlyRate : int 94 61 92 56 40 79 81 67 44 94 ... $ JobInvolvement : int 3 2 2 3 3 3 4 3 2 3 ... $ JobLevel : int 2 2 1 1 1 1 1 1 3 2 ... $ JobRole : Factor w/ 9 levels "Healthcare Representative",..: 8 7 3 7 3 3 3 3 5 1 ... $ JobSatisfaction : int 4 2 3 3 2 4 1 3 3 3 ... $ MaritalStatus : Factor w/ 3 levels "Divorced","Married",..: 3 2 3 2 2 3 2 1 3 2 ... $ MonthlyIncome : int 5993 5130 2090 2909 3468 3068 2670 2693 9526 5237 ... $ MonthlyRate : int 19479 24907 2396 23159 16632 11864 9964 13335 8787 16577 ... $ NumCompaniesWorked : int 8 1 6 1 9 0 4 1 0 6 ... $ Over18 : Factor w/ 1 level "Y": 1 1 1 1 1 1 1 1 1 1 ... $ OverTime : Factor w/ 2 levels "No","Yes": 2 1 2 2 1 1 2 1 1 1 ... $ PercentSalaryHike : int 11 23 15 11 12 13 20 22 21 13 ... $ PerformanceRating : int 3 4 3 3 3 3 4 4 4 3 ... $ RelationshipSatisfaction: int 1 4 2 3 4 3 1 2 2 2 ... $ StandardHours : int 80 80 80 80 80 80 80 80 80 80 ... $ StockOptionLevel : int 0 1 0 0 1 0 3 1 0 2 ... $ TotalWorkingYears : int 8 10 7 8 6 8 12 1 10 17 ... $ TrainingTimesLastYear : int 0 3 3 3 3 2 3 2 2 3 ... $ WorkLifeBalance : int 1 3 3 3 3 2 2 3 3 2 ... $ YearsAtCompany : int 6 10 0 8 2 7 1 1 9 7 ... $ YearsInCurrentRole : int 4 7 0 7 2 7 0 0 7 7 ... $ YearsSinceLastPromotion : int 0 1 0 3 2 3 0 0 1 7 ... $ YearsWithCurrManager : int 5 7 0 0 2 6 0 0 8 7 ... Education : 1 ‘Below College’ 2 ‘College’ 3 ‘Bachelor’ 4 ‘Master’ 5 ‘Doctor’ EnvironmentSatisfaction : 1 ‘Low’ 2 ‘Medium’ 3 ‘High’ 4 ‘Very High’ JobInvolvement : 1 ‘Low’ 2 ‘Medium’ 3 ‘High’ 4 ‘Very High’ JobSatisfaction : 1 ‘Low’ 2 ‘Medium’ 3 ‘High’ 4 ‘Very High’ PerformanceRating : 1 ‘Low’ 2 ‘Good’ 3 ‘Excellent’ 4 ‘Outstanding’ RelationshipSatisfactionn1 : ‘Low’ 2 ‘Medium’ 3 ‘High’ 4 ‘Very High’ WorkLifeBalance 1 : ‘Bad’ 2 ‘Good’ 3 ‘Better’ 4 ‘Best’ 데이터의 행은 1470, 열은 35개인 것을 확인할 수가 있습니다. 또한 수치형 데이터와 명목형 데이터 등 다양한 데이터가 있기 때문에 전처리를 하는 데 조금은 까다로울 것 같습니다. 여기서 가장 좋은 방법은 모든 변수들에 대해 자세히 살펴보는 것이 좋지만, 우리에겐 그렇게 많은 시간이 주어지지 못한 경우가 많습니다. 그렇다면 이 변수들을 최대한 빠르고 효율적으로 판단할 수 있는 방법들에 대해 진행해 보도록 하겠습니다. 우리는 여기서 ’Attrition’변수를 Target 변수로 정하고 분석을 진행하도록 하겠습니다. 3. 패키지 불러오기 R 코드를 구성하실 때, 우리는 훗날 코드가 뒤죽박죽으로 섞이게 되는 대참사가 벌어지지 않도록 신경을 써야 합니다. 그 첫 과정은 일단 패키지를 불러오는 코드는 모두 위에 배치시키는 것입니다. 그래야 나중에 패키지 안 불러와서 코드가 안 돌아가는 참사가 벌어지지가 않습니다. library(ggplot2) library(dplyr) library(reshape) library(cowplot) library(gmodels) library(corrplot) library(RColorBrewer) library(DMwR) library(caret) library(C50) library(randomForest) library(class) library(nnet) library(ROCR) library(car) library(pROC) 불러오는 패키지가 많지만, 대부분 앞에서 다뤘던 패키지들이니 따로 설명하지는 않겠습니다. 4. 탐색적 데이터 분석 Attrition 변수는 ’Yes’와 ’No’로 구성되어 있습니다. 우리의 목표는 ’Attrition’에 따라 어떤 변수들이 유의하게 차이가 나는지 탐색적으로 분석을 해보는 것입니다. 먼저, 빠른 분석을 위해서는 Numeric 변수와 Factor 변수를 분리시켜서 분석하는 것이 한 번에 퉁쳐서 분석을 진행할 수가 있습니다. 결측치 분석 분석을 시작하기에 앞서, 결측치가 데이터에 얼마나 존재하는지 파악하는 것은 필수입니다. colSums(is.na(IBM)) Age Attrition BusinessTravel 0 0 0 DailyRate Department DistanceFromHome 0 0 0 Education EducationField EmployeeCount 0 0 0 EmployeeNumber EnvironmentSatisfaction Gender 0 0 0 HourlyRate JobInvolvement JobLevel 0 0 0 JobRole JobSatisfaction MaritalStatus 0 0 0 MonthlyIncome MonthlyRate NumCompaniesWorked 0 0 0 Over18 OverTime PercentSalaryHike 0 0 0 PerformanceRating RelationshipSatisfaction StandardHours 0 0 0 StockOptionLevel TotalWorkingYears TrainingTimesLastYear 0 0 0 WorkLifeBalance YearsAtCompany YearsInCurrentRole 0 0 0 YearsSinceLastPromotion YearsWithCurrManager 0 0 결측치는 존재하지 않은 것을 알 수 있습니다. 타깃 변수 분석 타깃 변수 ’Attrition’이 대충 어떻게 구성되어 있는지 확인을 합니다. summary(IBM$Attrition) No Yes 1233 237 print(paste(round(summary(IBM$Attrition) / nrow(IBM),2) *100, "%",sep = "")) [1] "84%" "16%" ’Yes’에 해당되는 데이터가 ’No’에 비해 매우 적은 것을 확인할 수가 있습니다. 나중에 ’Attrition’을 타깃으로 분류 모형을 만든다고 할 때, 이 불균형을 해결해 주어야 한다는 점을 기억하고 있으시길 바랍니다. 수치형 변수 분석 수치형 변수를 분석하는 방법 중 가장 기본적인 것은 평균, 표준편차, 중위수 등을 ’Attrition’의 그룹 간에 계산을 해보는 것입니다. 그리고 또 수치형 변수들은 모두 단위가 다른 것을 확인할 수가 있습니다. 단위가 다르면 여러 변수들 간의 비교는 해석을 제대로 진행할 수가 없습니다. 그렇기에 우리는 기존에 변수의 단위를 포기하고 모두 같은 단위를 가지도록 표준화 혹은 정규화 변환을 진행해 줍니다. 표준화는 재미가 없으니 정규화(0 ~ 1)를 진행하도록 하겠습니다. o m l z t o ( ) x m n ( ) a ( ) m n ( ) # 정규화 함수 만들기 Normalization = function(x){ y = (x - min(x)) / (max(x)-min(x)) return(y) } # 수치형 변수들만 골라내기 IBM_Attrition_Numeric = IBM[,c(-grep("BusinessTravel",colnames(IBM)), -grep("Attrition",colnames(IBM)), -grep("Department",colnames(IBM)), -grep("EducationField",colnames(IBM)), -grep("Gender",colnames(IBM)), -grep("JobRole",colnames(IBM)), -grep("MaritalStatus",colnames(IBM)), -grep("Over18",colnames(IBM)), -grep("OverTime",colnames(IBM)))] # 정규화 함수 적용 IBM_Attrition_Numeric = lapply(IBM_Attrition_Numeric, FUN = Normalization) IBM_Attrition_Numeric = as.data.frame(IBM_Attrition_Numeric) 여기까지 진행하면, 수치형 변수들만 따로 뽑아냈으며, 정규화 변환이 진행된 데이터 셋이 만들어진 것을 확인할 수가 있습니다. 그렇다면, 이제 ’Attrition’에 따라 평균, 중위수, 표준편차를 한 번에 구해보도록 하겠습니다. IBM_Attrition_Numeric$Attrition = IBM$Attrition IBM_Attrition_Numeric_Mean = IBM_Attrition_Numeric %>% group_by(Attrition) %>% summarise_all(.funs = mean) %>% as.data.frame() %>% melt(id.vars = "Attrition") IBM_Attrition_Numeric_Median = IBM_Attrition_Numeric %>% group_by(Attrition) %>% summarise_all(.funs = median) %>% as.data.frame() %>% melt(id.vars = "Attrition") IBM_Attrition_Numeric_Sd = IBM_Attrition_Numeric %>% group_by(Attrition) %>% summarise_all(.funs = sd) %>% as.data.frame() %>% melt(id.vars = "Attrition") IBM_Numeric_Sumamry = data.frame( Attrition = IBM_Attrition_Numeric_Mean$Attrition, Variable = IBM_Attrition_Numeric_Mean$variable, Mean = IBM_Attrition_Numeric_Mean$value, Median = IBM_Attrition_Numeric_Median$value, Sd = IBM_Attrition_Numeric_Sd$value ) dplyr 패키지와 reshape 패키지를 혼합하여 사용하면 이렇게, Attrition에 따른 수치형 변수들의 통계량들을 구할 수가 있습니다. 하지만, 모든 값을 표로 비교하기에는 아직 좀 어려운 부분이 있습니다. 그러니 우리는 이 통계량들을 가지고 효과적인 시각화를 시도해 보도록 하겠습니다. 시각화도 하나씩 그리면 너무 많기 때문에, 한 번에 퉁쳐서 그리도록 하겠습니다. 표도 좀 더 직관적으로 표현을 해보도록 하겠습니다. 평소와 같았으면 엑셀에 보기 좋게 표를 정리하는 분들이 많겠지만, 우리는 R을 공부하기 때문에 모든 작업을 R로 처리해야만 합니다. IBM_Numeric_Sumamry %>% na.omit() %>% mutate(Mean = ifelse(Attrition == "No",Mean * -1, Mean), Attrition = factor(Attrition, levels = c("No","Yes"))) %>% ggplot() + geom_bar(aes(x = Variable, y = Mean, fill = Attrition), stat = 'identity') + geom_text(aes(x = Variable, y = rep(c(-0.7,0.7),24), fill = Attrition, label = round(abs(Mean),2))) + scale_y_continuous(labels = abs) + coord_flip() + theme_bw() + theme(text = element_text(size = 15), legend.position = "bottom") 만약 그래프를 이런 식으로 그린다면, ‘Attrition’ 값에 따른 수치형 변수들의 차이를 확인할 수가 있습니다. 그래프가 내주는 메시지는 한번 직접 해석을 해보시길 바랍니다. 마찬가지로 dplyr와 약간의 for 문을 활용해 주면 이제 저희가 자주 보던 양식의 표를 만들어낼 수가 있습니다. 표의 해석은 여러분들에게 맡기겠습니다. IBM_Numeric_Sumamry2 %>% mutate(Group = ifelse(Diff > 0 , "Yes","No")) %>% ggplot() + geom_bar(aes(x = Variable, y = Diff, fill = Group), stat = 'identity') + geom_text(aes(x = Variable, y = Diff, fill = Group, label = round(Diff, 2))) + scale_y_continuous(labels = abs) + coord_flip() + theme_bw() + theme(text = element_text(size = 15)) 그래프도 두 평균의 차이 값을 표현하게 그릴 수가 있습니다. 보시면 ’Attrition’이 ’Yes’에 해당되는 직원들은 DistanceFromHome, NumCompaniesWorked, MonthlyRate 등의 값이 ’No’인 사람들보다 더 높은 것을 확인할 수가 있습니다. A5. Case Study(Modeling 편 2) 5. 탐색적 데이터 분석 2 탐색적 데이터 분석은 시각화가 주를 이루지만, 시각화에 대한 결과를 조금 더 통계학적으로 검증하기 위하여 t-test 혹은 ANOVA 분석을 자주 사용합니다. 물론 통계적인 이론을 하나하나 다 따져가면 많이 까다로울 수 있으나, 보통 탐색적 분석을 위해서는 적당한 선에서 돌려서 결과를 Rough 하게 확인하는 정도로 많이 사용합니다. 즉, 결과에 대해 맹신을<NAME> 말고 참고하는 정도로 해석하는 것이 바람직합니다. ’Attrition’은 수준이 2개이기 때문에 t-test를 활용해야 합니다. 차이가 크게 나는 변수들을 2개를 골라서 t-test를 진행해 보겠습니다. 가장 차이가 큰 변수는 JobLevel인 것을 알 수 있습니다. ggplot(IBM) + geom_boxplot(aes(x = Attrition, y = JobLevel, fill = Attrition), alpha = 0.2, outlier.colour = "red") + geom_jitter(aes(x = Attrition, y = JobLevel, col = Attrition), alpha = 0.8) + theme_bw() + theme(text = element_text(size = 15), legend.position = "bottom", axis.title.x = element_blank()) # Job Level leveneTest(JobLevel ~ Attrition, data = IBM) Levene's Test for Homogeneity of Variance (center = median) Df F value Pr(>F) group 1 7.2855 0.007031 ** 1468 --- Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 t.test(JobLevel ~ Attrition, data = IBM, var.equal = FALSE) Welch Two Sample t-test data: JobLevel by Attrition t = 7.3859, df = 376.25, p-value = 9.845e-13 alternative hypothesis: true difference in means is not equal to 0 95 percent confidence interval: 0.3733861 0.6443231 sample estimates: mean in group No mean in group Yes 2.145985 1.637131 이렇게 t-test를 진행한 다음, 해석은 동일하게 하면 되지만, 하나씩 돌려보기에는 너무 반복작업이 많고 귀찮습니다. 그렇기에 모든 변수에 대해 한 번에 진행할 수 없을까라는 생각이 들 수 있습니다. 그럴 때는 for 문을 활용하면 됩니다. Numeric_Variable = IBM_Numeric_Sumamry2$ Variable Numeric_Variable = as.character(Numeric_Variable) P_value = c() for(k in 1:length(Numeric_Variable)){ LEVENE = leveneTest(IBM[,Numeric_Variable[k]] ~ Attrition, data = IBM) LEVENE_Pvalue = LEVENE$`Pr(>F)`[1] VAR_EQAUL = ifelse(LEVENE_Pvalue > 0.05, TRUE, FALSE) T_TEST = t.test(IBM[,Numeric_Variable[k]] ~ Attrition, data = IBM, var.equal = VAR_EQAUL) TTEST_Pvalue = T_TEST$p.value P_value[k] = TTEST_Pvalue } IBM_Numeric_Sumamry2$ P_value = P_value 이렇게 for 문을 적절하게 활용해 주면, 모든 변수에 대한 t-test와 그 결과를 정리할 수 있습니다. 이 결과는 맹신하는 결과가 아니라, 대략적으로 어떤 변수가 유의한 관계를 가지는지 탐색하기 위한 분석 단계라는 것을 명심하시길 바랍니다. 5. 탐색적 데이터 분석 3 이번에는 범주형 변수들을 대상으로 분석을 실행해 보겠습니다. 범주형 변수들은 카이 제곱 독립성검정을 진행하면서 분석을 해야 합니다. Over18변수는 모두 ’Y’이기 때문에, 분석할 필요가 없습니다. IBM_Attrition_Factor = IBM[,c(grep("Attrition",colnames(IBM)), grep("BusinessTravel",colnames(IBM)), grep("Department",colnames(IBM)), grep("EducationField",colnames(IBM)), grep("Gender",colnames(IBM)), grep("JobRole",colnames(IBM)), grep("MaritalStatus",colnames(IBM)), grep("OverTime",colnames(IBM)))] Cols = c() P_value_V = c() for(k in 2:ncol(IBM_Attrition_Factor)){ Table = table(IBM_Attrition_Factor$Attrition, IBM_Attrition_Factor[,k]) Chisq = chisq.test(Table) P_Value = Chisq$p.value Cols[k] = colnames(IBM_Attrition_Factor)[k] P_value_V[k] = P_Value } Cols = na.omit(Cols) P_value_V = na.omit(P_value_V) DF = data.frame( Cols = Cols, P_value = P_value_V ) 결과를 보시면 Gender의 경우 p-value가 매우 높은 것을 확인할 수가 있습니다. 이로써 우리는 Gender은 Attrition에 크게 유의한 변수는 아니라는 것을 사전에 확인할 수가 있습니다. 여기까지 여러 변수에 대해 탐색적으로 분석하는 과정을 진행했으며, 다음 분석에서는 실제 예측 모형을 적용시켜보도록 하겠습니다. A6. Case Study(Modeling 편 3) 6. 예측 모형 우리가 관심 있어 하는 Attrition 변수는 범주형 변수입니다. 즉, 분류 모형을 고려해야 된다는 의미입니다. 여기서 한 가지 짚고 넘어갈 것은 분류 모형을 구성하는 데에 있어서 Target 변수의 균형은 매우 중요합니다. summary(IBM$Attrition) No Yes 1233 237 보시면 Attrition에 No가 Yes에 비해 매우 많은 것을 확인할 수가 있습니다. 이런 경우 추정된 분류 모형은 편향된 결과를 낼 수도 있습니다. 여기서 등장하는 것이 Sampling 방법들입니다. 크게 보면 뿔리냐, 축소하냐 그 차이입니다. 상대적으로 작은 Group에 대해서 양을 부풀리는 것을 Oversampling이라고 하고, 상대적으로 큰 Group에 대해서는 축소시키는 방법을 Undersampling이라고 합니다. 의학통계에서는 성향 점수 매칭(PSM) 방법을 주로 사용하기도 합니다. 기계학습 분야에서도 SMOTE라든지 대책들이 있습니다. 다만, 샘플링 방법은 더 정답이 없는 경우가 많습니다. 이렇게 저렇게 해보다가 가장 결과가 잘 나오는 것이 해당 데이터와 모형에 가장 적합하다고 할 수가 있습니다. 일단 이 책에서는 성향 점수 매칭, SMOTE 등의 방법들을 다루지 않았습니다. 그러니 간단하게 Original 하게 분석하였을 경우에 대해서 진행하도록 하겠습니다. 대신 K-fold CV는 다루었으니, 그 부분을 활용해 보도록 하겠습니다. 모델에서는 앞서 진행한 EDA에서 유의하게 나온 변수들을 활용하겠습니다. Original IBM_A = IBM %>% select(Age, DailyRate, EnvironmentSatisfaction, JobInvolvement, JobSatisfaction, MonthlyIncome, MonthlyRate, StockOptionLevel, TotalWorkingYears, TrainingTimesLastYear, WorkLifeBalance, YearsAtCompany, YearsInCurrentRole, YearsWithCurrManager, BusinessTravel, Department, EducationField, JobRole, MaritalStatus, OverTime, Attrition) %>% mutate(Attrition = as.factor(ifelse(Attrition == "Yes",1,0))) K = 4 set.seed(1234) Sample = sample(rep(1:K, length = nrow(IBM_A))) CV_LIST = data.frame() for(k in 1:K){ TRAIN = IBM_A[Sample!= k,] TEST = IBM_A[Sample == k,] # Logistic Regression GLM = step(glm(Attrition == 1 ~ . , data = TRAIN), direction = "backward",) GLM_Probs = predict(GLM, newdata = TEST, type = 'response') # Decision Tree FEATURE = TRAIN[,-grep("Attrition",colnames(TRAIN))] RESPONSE = TRAIN[,grep("Attrition",colnames(TRAIN))] tree = C5.0(FEATURE, RESPONSE, control = C5.0Control(noGlobalPruning = FALSE, minCases = 20), trials = 10) Tree_Probs = predict(tree, newdata = TEST, type = 'prob') # RandomForest RF = randomForest(Attrition ~ ., data = TRAIN, mtry = 5, ntree = 300, importance = T) RF_Probs = predict(RF, newdata = TEST, type = 'prob') GLM_ROC = roc(TEST$Attrition, GLM_Probs) Tree_ROC = roc(TEST$Attrition, Tree_Probs[, 2]) RF_ROC = roc(TEST$Attrition, RF_Probs[, 2]) ROC_DF = data.frame( SEN = c(GLM_ROC$sensitivities, Tree_ROC$sensitivities, RF_ROC$sensitivities), SPE = c(GLM_ROC$specificities, Tree_ROC$specificities, RF_ROC$specificities), Model = c(rep("GLM",length(GLM_ROC$sensitivities)), rep("Tree",length(Tree_ROC$sensitivities)), rep("RF",length(RF_ROC$sensitivities))), K = k ) CV_LIST = rbind(CV_LIST, ROC_DF) } Step: AIC=735.83 Attrition == 1 ~ Age + DailyRate + EnvironmentSatisfaction + JobInvolvement + JobSatisfaction + StockOptionLevel + TrainingTimesLastYear + WorkLifeBalance + YearsInCurrentRole + YearsWithCurrManager + BusinessTravel + EducationField + JobRole + MaritalStatus + OverTime Df Deviance AIC - YearsInCurrentRole 1 119.27 734.64 <none> 119.18 735.83 - StockOptionLevel 1 119.46 736.42 - TrainingTimesLastYear 1 119.52 736.94 - YearsWithCurrManager 1 119.59 737.64 - DailyRate 1 119.67 738.41 - EducationField 5 120.57 738.64 - MaritalStatus 2 120.05 739.84 - WorkLifeBalance 1 119.88 740.24 - EnvironmentSatisfaction 1 120.38 744.86 - JobRole 8 122.12 746.75 - Age 1 120.81 748.78 - JobInvolvement 1 120.99 750.42 - JobSatisfaction 1 121.10 751.49 - BusinessTravel 2 121.65 754.44 - OverTime 1 127.19 805.54 Step: AIC=734.64 Attrition == 1 ~ Age + DailyRate + EnvironmentSatisfaction + JobInvolvement + JobSatisfaction + StockOptionLevel + TrainingTimesLastYear + WorkLifeBalance + YearsWithCurrManager + BusinessTravel + EducationField + JobRole + MaritalStatus + OverTime Df Deviance AIC <none> 119.27 734.64 - StockOptionLevel 1 119.55 735.25 - TrainingTimesLastYear 1 119.60 735.75 - EducationField 5 120.63 737.17 - DailyRate 1 119.79 737.44 - MaritalStatus 2 120.17 739.01 - WorkLifeBalance 1 120.02 739.59 - EnvironmentSatisfaction 1 120.48 743.81 - YearsWithCurrManager 1 120.61 745.00 - JobRole 8 122.34 746.73 - Age 1 120.95 748.06 - JobInvolvement 1 121.06 749.07 - JobSatisfaction 1 121.21 750.47 - BusinessTravel 2 121.75 753.36 - OverTime 1 127.32 804.70 CV_LIST %>% ggplot() + geom_line(aes(x = 1-SPE, y = SEN, col = Model),size = 1.2) + xlab("1-specificity") + ylab("sensitivity") + theme_bw() + theme(legend.position = "bottom", legend.box.background = element_rect(), legend.box.margin = ggplot2::margin(2,2,2,2), text = element_text(size = 15)) + facet_wrap(~K) 결과를 살펴보면 4번째 CV의 경우 GLM이 가장 ROC 커브가 넓게 그려진 것을 확인할 수가 있습니다. 여기서 꼭 기억해야 되는 사실은 기계학습이라고 일반 통계 모형보다 좋은 것이 아니라는 부분입니다. 항상 상황과 데이터에 따라 다르기 마련입니다. 그러니 이 글을 읽으시는 여러분들은 직접 분석 프로젝트에 투입되셨을 때 특정 알고리즘에 대해 높은 신뢰를 가지지 않기를 바랍니다. ChC. 추가 예정 목록 추가될 내용은 다음과 같습니다. - 캐글 데이터를 활용한 탐색적 자료분석(추가 완료) - 선형모형 적합(추가 완료) - 중심극한 정리의 수리통계학적 이론 데이터마이닝과 기계학습의 더 자세한 내용은 MLR 2편에서 다룰 예정입니다. 현재 작업 중에 있습니다. 제 개인 블로그 주소는 다음과 같습니다. https://mustlearning.tistory.com 감사합니다.<|endoftext|>