SPACE-S
팔로워0명
주최대회0개
경진대회
전체보기
경진대회
종료
안내 | 제5회 2023 연구개발특구 AI SPARK 챌린지
SPACE-S
800만원
안내 | 제5회 2023 연구개발특구 AI SPARK 챌린지
SPACE-S
800만원
경진대회
종료
제5회 2023 연구개발특구 AI SPARK 챌린지
SPACE-S
제5회 2023 연구개발특구 AI SPARK 챌린지
SPACE-S
경진대회
종료
[2023 연구개발특구 AI SPARK 챌린지] 인공지능 경진대회 수요기업 모집
SPACE-S
[2023 연구개발특구 AI SPARK 챌린지] 인공지능 경진대회 수요기업 모집
SPACE-S
경진대회
종료
[2023 연구개발특구 AI SPARK 챌린지] 인공지능 경진대회 온라인 설명회
SPACE-S
[2023 연구개발특구 AI SPARK 챌린지] 인공지능 경진대회 온라인 설명회
SPACE-S
경진대회
종료
[Space-S x KaKR] 그래프 러닝 및 해커톤
SPACE-S
525만원
[Space-S x KaKR] 그래프 러닝 및 해커톤
SPACE-S
525만원
경진대회
종료
제3회 연구개발특구 AI SPARK 챌린지
SPACE-S
900만원
제3회 연구개발특구 AI SPARK 챌린지
SPACE-S
900만원
경진대회
종료
제2회 연구개발특구 인공지능 경진대회 AI SPARK 챌린지
SPACE-S
900만원
제2회 연구개발특구 인공지능 경진대회 AI SPARK 챌린지
SPACE-S
900만원
경진대회
종료
[AI SPARK 챌린지] 대회1. 섬진강 유역 내 강우량 예측 문제
SPACE-S
800만원
[AI SPARK 챌린지] 대회1. 섬진강 유역 내 강우량 예측 문제
SPACE-S
800만원
경진대회
종료
[AI SPARK 챌린지] 대회2. 수도관 누수 탐지 분류 문제
SPACE-S
800만원
[AI SPARK 챌린지] 대회2. 수도관 누수 탐지 분류 문제
SPACE-S
800만원
경진대회
종료
제1회 연구개발특구 인공지능 경진대회 AI SPARK 챌린지 : ESG 혁신
SPACE-S
1,600만원
제1회 연구개발특구 인공지능 경진대회 AI SPARK 챌린지 : ESG 혁신
SPACE-S
1,600만원
세미나
전체보기
세미나
참가 접수중
진행중
INNOPOLIS AI SPACE-S 인공지능 세미나 - 추천시스템 입문하기
SPACE-S
기프티콘
INNOPOLIS AI SPACE-S 인공지능 세미나 - 추천시스템 입문하기
SPACE-S
기프티콘
세미나
종료
테스트
SPACE-S
테스트
SPACE-S
세미나
종료
[DLD 2022] 하이퍼파라미터 튜닝과 ML 파이프라인 - 박찬성
SPACE-S
[DLD 2022] 하이퍼파라미터 튜닝과 ML 파이프라인 - 박찬성
SPACE-S
세미나
종료
[DLD 2022] EDSR Super-resolution 소개 및 Keras 코드 실습
SPACE-S
[DLD 2022] EDSR Super-resolution 소개 및 Keras 코드 실습
SPACE-S
세미나
종료
[DLD 2022] 이미지를 어떻게 표현할 수 있는가 - 임훈
SPACE-S
[DLD 2022] 이미지를 어떻게 표현할 수 있는가 - 임훈
SPACE-S
세미나
종료
[DLD 2022] Tensorflow Decision Forests 를 이용한 분류모델 만들기 - 이동훈
SPACE-S
[DLD 2022] Tensorflow Decision Forests 를 이용한 분류모델 만들기 - 이동훈
SPACE-S
세미나
종료
[DLD 2022] Tensorflow Decision Forests 를 이용한 Text Classification - 이동훈
SPACE-S
[DLD 2022] Tensorflow Decision Forests 를 이용한 Text Classification - 이동훈
SPACE-S
세미나
종료
[DLD 2022] Augmenting Convolutional networks with attention-based aggregation - 고승희
SPACE-S
[DLD 2022] Augmenting Convolutional networks with attention-based aggregation - 고승희
SPACE-S
세미나
종료
[DLD 2022] Keras Trainer pattern 세미나 - 허지완
SPACE-S
[DLD 2022] Keras Trainer pattern 세미나 - 허지완
SPACE-S
세미나
종료
[DLD 2022] Structured data learning with TabTransformer - 박성수
SPACE-S
[DLD 2022] Structured data learning with TabTransformer - 박성수
SPACE-S
세미나
종료
[DLD 2022] 정신차려 이 모델이 커져만 가는 각박한 세상 속에서 : ViT knowledge distillation 해보기 - 박정현
SPACE-S
[DLD 2022] 정신차려 이 모델이 커져만 가는 각박한 세상 속에서 : ViT knowledge distillation 해보기 - 박정현
SPACE-S
세미나
종료
[DLD 2022] 케라스 NLP를 활용한 GPT 텍스트 생성 도전하기 - 최태균
SPACE-S
[DLD 2022] 케라스 NLP를 활용한 GPT 텍스트 생성 도전하기 - 최태균
SPACE-S
세미나
종료
[DLD 2022] Keras 기반 Stable Diffusion을 이미지를 생성해보자 - 박찬성
SPACE-S
[DLD 2022] Keras 기반 Stable Diffusion을 이미지를 생성해보자 - 박찬성
SPACE-S
세미나
종료
[DLD 2022] Train a Vision Transformer on small datasets - 박은수
SPACE-S
[DLD 2022] Train a Vision Transformer on small datasets - 박은수
SPACE-S
세미나
종료
[DLD 2022] English speaker accent recognition using Transfer Learning - 소준섭
SPACE-S
[DLD 2022] English speaker accent recognition using Transfer Learning - 소준섭
SPACE-S
세미나
종료
[DLD 2022] Denoising Diffusion Implicit Models - 박수철
SPACE-S
[DLD 2022] Denoising Diffusion Implicit Models - 박수철
SPACE-S
세미나
종료
[DLD 2022] Bert 보다 빠르다? FNet으로 Text Classification 해보기 - 김노은
SPACE-S
[DLD 2022] Bert 보다 빠르다? FNet으로 Text Classification 해보기 - 김노은
SPACE-S
세미나
종료
[DLD 2022] 요즘 핫한 생성모델 stable diffusion 찍먹해보기 - 김형섭
SPACE-S
[DLD 2022] 요즘 핫한 생성모델 stable diffusion 찍먹해보기 - 김형섭
SPACE-S
세미나
종료
[DLD 2022] 눈으로 보자 Attention - 최현영
SPACE-S
[DLD 2022] 눈으로 보자 Attention - 최현영
SPACE-S
세미나
종료
[DLD 2022] Advanced Augmentation Strategy in Keras - 김종석
SPACE-S
[DLD 2022] Advanced Augmentation Strategy in Keras - 김종석
SPACE-S
세미나
종료
[DLD 2022] 허깅페이스로 나만의 BERT Pretraining 해보기 - 윤주성
SPACE-S
[DLD 2022] 허깅페이스로 나만의 BERT Pretraining 해보기 - 윤주성
SPACE-S
세미나
종료
[DLD 2022] Attention mechanism이 없는 Vision Transformer를 상상해보셨나요? - 배성수
SPACE-S
[DLD 2022] Attention mechanism이 없는 Vision Transformer를 상상해보셨나요? - 배성수
SPACE-S
세미나
종료
[DLD 2022] Question Answering with Hugging Face Transformers - 배성수
SPACE-S
[DLD 2022] Question Answering with Hugging Face Transformers - 배성수
SPACE-S
세미나
종료
[DLD 2022] 허깅페이스로 나만의 요약 모델 만들기 - 윤주성
SPACE-S
[DLD 2022] 허깅페이스로 나만의 요약 모델 만들기 - 윤주성
SPACE-S
세미나
종료
[DLD 2022] 사람이 하는 번역, 인공지능이 하는 번역 - 김영하
SPACE-S
[DLD 2022] 사람이 하는 번역, 인공지능이 하는 번역 - 김영하
SPACE-S
세미나
종료
[DLD 2022] Pascal VOC 2007로 알아보는 객체 감지 모델 기초 - 김영하
SPACE-S
[DLD 2022] Pascal VOC 2007로 알아보는 객체 감지 모델 기초 - 김영하
SPACE-S
세미나
종료
INNOPOLIS AI SPACE-S 인공지능 세미나 - 이미지 분류를 위한 딥러닝 문제해결 패턴
SPACE-S
1
INNOPOLIS AI SPACE-S 인공지능 세미나 - 이미지 분류를 위한 딥러닝 문제해결 패턴
SPACE-S
1
세미나
종료
[그래프 러닝 및 해커톤] 파이썬 베이스라인 따라하기 - 연습
SPACE-S
[그래프 러닝 및 해커톤] 파이썬 베이스라인 따라하기 - 연습
SPACE-S
세미나
종료
[그래프 러닝 및 해커톤] 파이썬 베이스라인 따라하기 - 준비
SPACE-S
[그래프 러닝 및 해커톤] 파이썬 베이스라인 따라하기 - 준비
SPACE-S
세미나
종료
INNOPOLIS AI SPACE-S 인공지능 세미나 - 정형 데이터를 다루는 머신러닝 문제해결 패턴
SPACE-S
INNOPOLIS AI SPACE-S 인공지능 세미나 - 정형 데이터를 다루는 머신러닝 문제해결 패턴
SPACE-S
세미나
종료
INNOPOLIS AI SPACE-S 인공지능 세미나-TESLA 자율주행 기술에 발가락 담그기
SPACE-S
INNOPOLIS AI SPACE-S 인공지능 세미나-TESLA 자율주행 기술에 발가락 담그기
SPACE-S
세미나
종료
INNOPOLIS AI SPACE-S 인공지능 세미나 - 라벨링 없이 해보는 의미론적 분할
SPACE-S
INNOPOLIS AI SPACE-S 인공지능 세미나 - 라벨링 없이 해보는 의미론적 분할
SPACE-S
세미나
종료
INNOPOLIS AI SPACE-S 인공지능 세미나 - GCP와 TFX로 쉽게 MLOps를 시작하는법
SPACE-S
INNOPOLIS AI SPACE-S 인공지능 세미나 - GCP와 TFX로 쉽게 MLOps를 시작하는법
SPACE-S
세미나
종료
INNOPOLIS AI SPACE-S 인공지능 세미나 - MLOps와 높은 진입 장벽
SPACE-S
INNOPOLIS AI SPACE-S 인공지능 세미나 - MLOps와 높은 진입 장벽
SPACE-S
세미나
종료
INNOPOLIS AI SPACE-S 인공지능 세미나 - 신뢰가능한 딥러닝을 향하여
SPACE-S
INNOPOLIS AI SPACE-S 인공지능 세미나 - 신뢰가능한 딥러닝을 향하여
SPACE-S
세미나
종료
INNOPOLIS AI SPACE-S 인공지능 세미나 - 추천시스템 더 알아보기
SPACE-S
INNOPOLIS AI SPACE-S 인공지능 세미나 - 추천시스템 더 알아보기
SPACE-S
세미나
종료
[Learning] 엣지 디바이스에서의 영상 분류 및 물체 탐지 (NVIDIA Jetson)
SPACE-S
[Learning] 엣지 디바이스에서의 영상 분류 및 물체 탐지 (NVIDIA Jetson)
SPACE-S
세미나
종료
[Learning] 아이에게 인공지능 게임 만들어주기
SPACE-S
[Learning] 아이에게 인공지능 게임 만들어주기
SPACE-S
트레이닝
전체보기
참가 접수중
진행중
패션 아이템 이미지 분류하기
SPACE-S
학습용
패션 아이템 이미지 분류하기
SPACE-S
학습용
참가 접수중
진행중
리뷰 데이터 감성 분석
SPACE-S
리뷰 데이터 감성 분석
SPACE-S
참가 접수중
진행중
머신러닝을 통한 당뇨병 예측
SPACE-S
머신러닝을 통한 당뇨병 예측
SPACE-S
참가 접수중
진행중
딥러닝으로 은하 분류하기
SPACE-S
딥러닝으로 은하 분류하기
SPACE-S
참가 접수중
진행중
타이타닉 생존자 예측하기
SPACE-S
타이타닉 생존자 예측하기
SPACE-S
게시글
전체보기Discussion 01
This is a discussion test for account withdrawal.People can see this feed after I delete my account.
[2023 연구개발특구 AI SPARK 챌린지] 인공지능 경진대회 온라인설명회 Q&A
대회관련 자세한 사항은 수요기업 모집하고 문제 파악한 후에 나오는건가요?<code class="language-c">-경진대회 프로세스를 참고하시면 되시며, 수요기업 신청서 및 선정된 기업에 한하여 컨설팅을 진행 하면서 문제정의, 데이터셋 등을 정하게 됩니다.</code>경진대회 사례 중 작년 대회에 참여한 특구기업(세종강우, 위플랫, 아이준 등)이 어떤 수요(문제상황)가 있어 대회를 통해 어떻게 문제해결에 도움을 받았는지 구체적인 내용이 궁금합니다.<code class="language-c">-데이터는 가지고 있으나, 모델개발이 부족하여 실제 외부 상용화, 내부 연구 등에 지원하였습니다.</code>현재 특구재단에서 진행하고 있는 ai역량강화사업 참여수행기업은 경진대회에서 인센티브등이 있는지요?<code class="language-c">-따로 논의된 바는 없으나, 제한은 없기에 참여 가능합니다. 또한 ai역량강화사업에 미선정된 기업도 금번 수요기업모집에 참여하시어, 선정되시면 해결하고자 하시는 문제정의 대해 컨설팅 및 경진대회 가능성이 있습니다.</code>개발자는 어떤분인가요?<code class="language-c">-따로 개발자를 두는것이 아닌, 외부 참가 개발자=경진대회 참가자이십니다.</code>사회문제해결형 정확한 진행일정(접수신청 등)은 미정인가요<code class="language-c">-아직 특구 재단과 논의중입니다. 정확한 일정 협의 후 공지 예정</code>현재 수요기업 모집중에 있는데 신청하는 기업에 제한이 있나요? (지역, 데이터 보유 등)<code class="language-c">-따로 제한이 없고, 특구재단가산점있으나 일반기업 신청가능 합니다.</code>대회 수상기준은 모델의 validation 정확도 인가요?<code class="language-c">-우선은 평가 방법에 대해서 컨설팅을 통해 협의 결정 (F1, iou 등 평가방법을 구축) </code>참가자는 어떻게 모집하나요? 인재풀이 있나요?<code class="language-c">-저희 플랫폼에 회원분들 및 각종 커뮤니티에 홍보중(공모전,카페,협/학회,오픈채팅방) </code>혹시 참여기업이 역으로 어떤 데이터셋을 요청할 수 있나요??<code class="language-c">-이 부분은 수요기업이 문제정의와 데이터셋을 가지고 신청하시는것이기에, 데이터셋을 제공 할 수 없고 경진대회 개최 지원 등 후속 프로세스 진행이 되겠습니다.</code>대회 1등 결과 모델이 수요기업이 사용하게 될 모델일까요?<code class="language-c">-1등~3등까지 입상자, 이용권 가지게 됨 저작권은 입상자와 양도양수 계약을 별도 진행합니다.</code>데이터셋이 중요한 경우 비공개로도 가능한가요?<code class="language-c">-아니오, 데이터 공개로 진행됩니다.</code>만약 AI를 통해 문제해결을 희망하는 기업이 자체 데이터를 보유하고 있지 않아도 신청 가능한가요?<code class="language-c">-우선 자체 데이터를 보유하신 기업께서 유리하십니다. 본 경진대회가 데이터 수집 부터 라벨링까지 지원할 수 없는 일정이기에 자체 데이터를 보유하신게 좋으나, 없으신 경우에는 오픈 데이터를 활용할수 있는지 논의가 필요 합니다.</code>그렇다면 가지고 있는 데이터셋 중 최소의 공개만으로 진행이 된다면 어느정도가 될까요?<code class="language-c">-어느정도 기준을 말씀드리기가 어려우나, 문제 정의에와 데이터 공개정도에 따라 정확도 확인 등이 필요합니다.</code>공개데이터로도 진행이 가능한건가요?<code class="language-c">-진행 가능합니다. 정확도 확인 필요 (라벨링 등)</code>사회적 기여 사업성은 어느정도 참조하나요?<code class="language-c">-사회문제형 경진대회는 주제 및 이슈 특구재단과 협의 후 공지 될 예정입니다. </code>입상자는 단순 모델 개발까지만 도움을 주나요?<code class="language-c">-추후 수요기업 필요한 입상자와 컨텍해서 도움을 받으셔야함</code>입상후 저작권 구매비용이 지정되어 있는지요<code class="language-c">-따로 책정되어 있지 않습니다. -상금 금액과 비교해서 정하시면 될 것 같습니다.</code>입상자의 수상시에, 수상 주체는 누가 되는것인지요?<code class="language-c">-모델 개발 참가자, 본 경진대회 특구재단에서 열기에 주체는 연구개발특구재단 입니다.</code>
[2023 연구개발특구 AI SPARK 챌린지] 인공지능 경진대회 온라인설명회 Q&A
대회관련 자세한 사항은 수요기업 모집하고 문제 파악한 후에 나오는건가요?<code class="language-c">-경진대회 프로세스를 참고하시면 되시며, 수요기업 신청서 및 선정된 기업에 한하여 컨설팅을 진행 하면서 문제정의, 데이터셋 등을 정하게 됩니다.</code>경진대회 사례 중 작년 대회에 참여한 특구기업(세종강우, 위플랫, 아이준 등)이 어떤 수요(문제상황)가 있어 대회를 통해 어떻게 문제해결에 도움을 받았는지 구체적인 내용이 궁금합니다.<code class="language-c">-데이터는 가지고 있으나, 모델개발이 부족하여 실제 외부 상용화, 내부 연구 등에 지원하였습니다.</code>현재 특구재단에서 진행하고 있는 ai역량강화사업 참여수행기업은 경진대회에서 인센티브등이 있는지요?<code class="language-c">-따로 논의된 바는 없으나, 제한은 없기에 참여 가능합니다. 또한 ai역량강화사업에 미선정된 기업도 금번 수요기업모집에 참여하시어, 선정되시면 해결하고자 하시는 문제정의 대해 컨설팅 및 경진대회 가능성이 있습니다.</code>개발자는 어떤분인가요?<code class="language-c">-따로 개발자를 두는것이 아닌, 외부 참가 개발자=경진대회 참가자이십니다.</code>사회문제해결형 정확한 진행일정(접수신청 등)은 미정인가요<code class="language-c">-아직 특구 재단과 논의중입니다. 정확한 일정 협의 후 공지 예정</code>현재 수요기업 모집중에 있는데 신청하는 기업에 제한이 있나요? (지역, 데이터 보유 등)<code class="language-c">-따로 제한이 없고, 특구재단가산점있으나 일반기업 신청가능 합니다.</code>대회 수상기준은 모델의 validation 정확도 인가요?<code class="language-c">-우선은 평가 방법에 대해서 컨설팅을 통해 협의 결정 (F1, iou 등 평가방법을 구축) </code>참가자는 어떻게 모집하나요? 인재풀이 있나요?<code class="language-c">-저희 플랫폼에 회원분들 및 각종 커뮤니티에 홍보중(공모전,카페,협/학회,오픈채팅방) </code>혹시 참여기업이 역으로 어떤 데이터셋을 요청할 수 있나요??<code class="language-c">-이 부분은 수요기업이 문제정의와 데이터셋을 가지고 신청하시는것이기에, 데이터셋을 제공 할 수 없고 경진대회 개최 지원 등 후속 프로세스 진행이 되겠습니다.</code>대회 1등 결과 모델이 수요기업이 사용하게 될 모델일까요?<code class="language-c">-1등~3등까지 입상자, 이용권 가지게 됨 저작권은 입상자와 양도양수 계약을 별도 진행합니다.</code>데이터셋이 중요한 경우 비공개로도 가능한가요?<code class="language-c">-아니오, 데이터 공개로 진행됩니다.</code>만약 AI를 통해 문제해결을 희망하는 기업이 자체 데이터를 보유하고 있지 않아도 신청 가능한가요?<code class="language-c">-우선 자체 데이터를 보유하신 기업께서 유리하십니다. 본 경진대회가 데이터 수집 부터 라벨링까지 지원할 수 없는 일정이기에 자체 데이터를 보유하신게 좋으나, 없으신 경우에는 오픈 데이터를 활용할수 있는지 논의가 필요 합니다.</code>그렇다면 가지고 있는 데이터셋 중 최소의 공개만으로 진행이 된다면 어느정도가 될까요?<code class="language-c">-어느정도 기준을 말씀드리기가 어려우나, 문제 정의에와 데이터 공개정도에 따라 정확도 확인 등이 필요합니다.</code>공개데이터로도 진행이 가능한건가요?<code class="language-c">-진행 가능합니다. 정확도 확인 필요 (라벨링 등)</code>사회적 기여 사업성은 어느정도 참조하나요?<code class="language-c">-사회문제형 경진대회는 주제 및 이슈 특구재단과 협의 후 공지 될 예정입니다. </code>입상자는 단순 모델 개발까지만 도움을 주나요?<code class="language-c">-추후 수요기업 필요한 입상자와 컨텍해서 도움을 받으셔야함</code>입상후 저작권 구매비용이 지정되어 있는지요<code class="language-c">-따로 책정되어 있지 않습니다. -상금 금액과 비교해서 정하시면 될 것 같습니다.</code>입상자의 수상시에, 수상 주체는 누가 되는것인지요?<code class="language-c">-모델 개발 참가자, 본 경진대회 특구재단에서 열기에 주체는 연구개발특구재단 입니다.</code>
정형 데이터를 다루는 머신러닝 문제해결 패턴 리뷰
정형 데이터를 다루는 머신러닝 문제해결 패턴 리뷰AIFactory 에서 제공하는 세미나 중에서 흥미로웠던 부분을 중심으로 리뷰했습니다.실제로 많은 도움이 되었고 전체적인 진행방향을 잡기 좋은 강의였습니다. 목차머신러닝 문제해결 프로세스 & 탐색적 데이터 분석(EDA)의 중요성과 개요베이스라인 모델 설계모델 성능 개선 방안 1. 머신러닝 문제해결 프로세스 & 탐색적 데이터 분석(EDA)의 중요성과 개요과정문제 이해탐색적 데이터 분석주어진 데이터를 면밀히 분석데이터 전처리더러운 데이터를 깨끗하게 만드는 작업대회에서는 상당 수준 전처리가 이미 이루어진 상태 머신러닝 문제해결 체크리스트 1-1. 문제 이해문제 배경과 목적어떤 데이터를 활용해서 어떤 값을 예측해야 하는지?문제 유형 확인회귀인지, 분류인지?데이터 확인주어진 데이터가 무엇인지?문제 접근 방법어떻게 접근해서 문제를 풀어야 하는지?배경 지식을 활용한 만한 점이 있을지가장 큰 공감이 되는 부분이었습니다. 막상 대회를 수행할 때 주제가 흥미로운지에 관점을 두고 주먹구구식으로 대회를 한 적이 많아서 다시 모델링을 하게 되는 경우가 있었습니다. 가장 중요한 주제와 제약조건을 꼭 확인하는 것이 중요! 1-2. 탐색적 데이터 분석이란?주어진 데이터의 구조를 간단히 훑어보거나 몇 가지 통계값을 구해봄다양한 그래프를 활용해 데이터 전반을 깊이 있게 살펴봄해당 과정에서 어떤 피처가 중요한지, 피처끼리 어떻게 조합해서 새로운 피처를 만들지, 어떤 점을 주의해서 모델링 할지 등의 인사이트를 얻게 됨 제공된 데이터 둘러보기제공된 파일별 용도 파악데이터 양(레코드 수, 피처 수, 전체 용량 등)info(), shape피처 이해이름, 의미, 데이터 타입, 결측값/고윳값 개수피처 요약표 활용훈련 vs 테스트 데이터 차이분포가 서로 비슷한지?훈련 데이터엔 있지만 테스트 데이터에 없는 피처가 있는지?타깃값(목표값) 파악때에 따라 훈련 데이터 타겟값이 명확히 없는 경우도 있음 데이터 피처 탐색표타깃값 파악때에 따라 훈련 데이터에 타깃값이 명확히 없는 경우 존재개별 피처들을 확인할 때는 몰랐던 정보가 존재할 수 있는 전체 피처 요약표를 만들고 해당 내용을 파악 후 대회를 진행하는 것이 좋다는 말씀! 1-3. 데이터 시각화Permalink효과적인 시각화를 위한 피처 엔지니어링각종 시각화수치형 데이터 시각화, 범주형 데이터 시각화, 데이터 관계 시각화피처 파악추가할 피처제거할 피처피처별 인코딩 전략이상치, 결측값 파악이상치, 결측값 파악 기법해당 피처별 처리 방법 치우친 분포를 가진 데이터정규분포에서 멀리 떨어진 분포는 회귀에서의 성능 저하 발생할 수 있어서 변환 연도, 월, 일 시각화1번 그래프 : 2011 < 2012 더 많은 자전거 대여수량 기록2번 그래프 : 월별 대여수량을 통해 날씨가 더울수록 자전거 대여 수량이 높다는 것을 파악3번 그래프 : 일별 데이터가 거이 비슷하기 때문에 제거 가능성 파악4번 그래프 : 시간이라는 피처를 통해 출퇴근 시간때 많은 대여량 확인평일과 휴일간의 차이를 확인가능해당 그림을 통해 타겟값 예측에 도움을 줄 피처인지 유추가능특정 피처 A 가 있다고 한다면 해당 A라는 피처가 타겟값과의 비율을 확인해 해당 피처가 예측에 도움이 되는 피처인지 파악해당 방법은 정말 해보지 않은 방법이었습니다. Classification 문제에 적용해보는 것이 좋을 거 같습니다.상관관계를 절대적인 지표로 하기는 어렵지만 참고용으로는 가능레이블 인코딩은 데이터 간의 대소 관계나 크기의 차이가 존재할 때 사용이 적절, 순서가 유의미 하지만 원-핫이 좋을수도 있음시각화의 중요성을 조금 더 크게 알 수 있었고 블랙박스인 모델에서 설명을 위해서도 10% 정도는 투자하는 것이 좋다는 말씀 2. 베이스라인 모델 설계아주 간단한 기본 모델을 생성, 훈련해 성능 확인기본적인 뼈대를 만들어두는 것추후 모델링을 진행하면서 여기에 살을 덧붙이면서 성능을 끌어올림 2-1. 평가지표모델 훈련이 제대로 이루어졌는지 확인하는 방법대부분 평가지표는 사이킷런에서 제공 필요한 경우 커스텀 평가지표 작성 2-2. 모델훈련훈련 : 피처와 타깃값이 주어졌을 때 최적 가중치(회귀계수)를 찾는 과정 - 세타값 찾기예측 : 최적 가중치를 아는 상태(훈련된 모델)에서 새로운 독립변수(데이터)가 주어졌을 때 타깃값을 추정하는 과정 - 찾은 세타값을 통해 예측탐색적 데이터 분석 : 예측에 도움이 될 피처를 추리고, 적절한 모델링 방법을 탐색하는 과정피처 엔지니어링 : 추려진 피처들을 훈련에 적합하도록, 성능 향상에 도움되도록 가공하는 과정 3. 모델 성능 개선 방안피처 엔지니어링모델 성능 개선의 첫 단계이상치 제거, 결측값 처리하기, 데이터 인코딩, 피처 스케일링, 파생 피처 생성, 피처 제거 및 선택 등을 수행하이퍼파라미터 최적화모델의 최적 하이퍼 파라미터를 찾는 작업하이퍼파라미터 최적화 기법으로는 그리드서치, 랜덤서치, 베이지안 최적화 등이 있음, 그 중 베이지안 최적화가 효율적그 외 성능 개선 기법 적용교차 검증, OOF(out-of-fold), 테스트 단계 데이터 증강(TTA), 레이블 스무딩성능 평가성능이 좋지 않다면 탐색적 데이터 분석이나 피처 엔지니어링부터 다시 수행 3-1. 피처 엔지니어링 파생 피처 생성기존 피처를 가공해 타깃값 예측에 도움될 피처 새로 생성쉽게 생각할 수 있는 점부터 도메인 지식을 요하는 부분까지 다양함가장 창의력이 많이 필요한 파트시차(lag, 지연) 피처 생성 (시계열 데이터에 한정 - 과거 시점의 타겟값을 현재 시점의 피처로 넣을수 있음)이전 타겟 피처로 사용하는 코드시차 피처란 과거 시점에 관한 피처시계열 문제에서 성능 향상에 큰 도움이 됨트렌드와 유사성 반영다양한 기준을 바탕으로 시차 피처를 만들 수 있음 데이터 조합을 생성해 데이터 수 늘려주기 (모든 가능한 조합)가능한 모든 조합 생성 코드데이터가 아예 없는 것보다 유의미한 데이터가 많은것이 좋음 데이터 다운캐스팅더 작은 데이터 타입으로 변환하는 작업훈련 속도가 빨라지고, 메모리 소모도 줄일수 있음해당 코드 피처 스케일링 (트리 기반은 굳이 수행할 필요없음 - 대소관계로 판단하기 때문)서로 다른 피처 값의 범위(최댓값 - 최솟값)이 일치하도록 조정하는 작업대표적으로는 min-max 정규화와 Standardization트리 모델을 사용할 땐 굳이 적용할 필요 없음 이상치 제거통계치 vs 특별히 튀는 값 vs 도메인 지식 활용 vs 이상 탐지 결측값 처리결측값이 많으면 해당 데이터 자체를 없앨 수도 있지만, 해당 데이터가 정말 중요한 데이터라면?일반적으로 최빈, 평균, 중앙, 대체보다는 더 현명한 방법을 생각함결측값 자체를 타깃값으로 생각하고, 별도로 모델링을 활용해 결측값 예측데이터 특성에 맞는 적절한 결측값 처리 방안 구상 어떤 파생 피처를 만들어야 성능 향상에 도움이 될까요?처음부터 어떤 파생 피처가 예측에 도움이 될지 알기는 쉽지 않음대회 상위권 캐글러들도 갖은 방법으로 피처 엔지니어링을 시도그중 성능 향상에 도움되는 피처를 선별다만, EDA와 도메인 배경지식, 창의적인 아이디어가 도움을 줄 수 있음 하이퍼 파라미터 최적화대표적인 하이퍼 파라미터 최적화 기법그리드 서치 (grid search) : 내가 어느정도 하이퍼 파라미터에 대한 이해가 있을 때랜덤 서치 (random search) : 너무 random 이라 잘 사용하지 않음베이지안 최적화 (bayesian optimization) 머신러닝 체크리스트 github 주소 강의 후기확실히 대회를 수행하면서 주요한 내용을 모두 간략하게 다뤄 주신 강의였던 거 같습니다. EDA ~ 모델 추론까지 모든 내용을 전반적으로 확인할 수 있어서 좋았습니다.
Advanced Augmentation Strategy in Keras 리뷰
Advanced Augmentation Strategy in Keras 리뷰강의 링크강의 자료AIF SeminarAIFactory 에서 제공하는 '[Space-S x DLD 2022] 케라스 실용 예제 및 개발 가이드 컨퍼런스' 세미나 후기입니다. Data Augmentation이란?학습/추론에 사용하는 데이터의 양을 늘리기 위해 적용Data space에서 비어 있는 공간을 채워 generalization 효과 증가 (overfitting 해결)Image와 Text 등 다양한 도메인의 특징에 맞게 적용Augmentation의 종류(Image)Pixel-levelSpatial-levelGenerative modelAdvanced augmentation strategy Basic Image ManipulationPixel-level Transformspixel 단위로 변환을 적용하는 기법으로 color, blur, noise등을 변화시키거나 추가변환 정도를 수치적으로 지정하여 사용Spatial-level TransformsFlip, Rotation, Crop 등 Image의 위상을 변경Cutout: Image의 일부를 잘라내는 변환 기법Generative model Based Approach생성 모델을 활용하여 학습에 사용할 데이터를 생성하는 기법주로 데이터의 수가 매우 적거나 data noise가 많을 때 사용Data Augmentation 사용 시 주의사항Data Augmentation은 의미가 변형되지 않는 선에서 적용Domain에 따라 적용 가능한 data augmentation의 범위가 달라짐학습하는 데이터가 수집된 domain konwledge를 통해 더 좋은 data augmentation pool 구성 가능어떤 특징을 가지고 있는지 파악하는 것이 중요!, 데이터가 수집된 도메인 지식을 가지고 있어야 함 Test Time Augmentation(TTA)추론 과정에서 성능 향상을 위해 사용하는 기법class를 예측해서 voting추론할 이미지 여러개 만들어둬야함 Advanced Augmentation Strategy여러 이미지를 섞어 완전히 새로운 데이터를 생성하는 기법Cutmix, Mixup을 시작으로 puzzle mix등 다양한 알고리즘 연구중RandAugment : 강화학습 기반으로 가장 효율적인 Data augmentation 알고리즘 search여러 data augmentation pool에서 선택적으로 dataset에 맞게 적용 Code Review<code class="language-plaintext">import keras_cv import matplotlib.pyplot as plt import tensorflow as tf import tensorflow_datasets as tfds from tensorflow import keras from tensorflow.keras import applications from tensorflow.keras import losses from tensorflow.keras import optimizers</code>Flower Dataset을 사용한 분류 문제 데이터<code class="language-plaintext">BATCH_SIZE = 32 # 배치 사이즈 AUTOTUNE = tf.data.AUTOTUNE tfds.disable_progress_bar() data, dataset_info = tfds.load("oxford_flowers102", with_info=True, as_supervised=True) # tarin, val split train_steps_per_epoch = dataset_info.splits["train"].num_examples // BATCH_SIZE val_steps_per_epoch = dataset_info.splits["test"].num_examples // BATCH_SIZE</code>이미지 해상도는 224, 224<code class="language-plaintext">IMAGE_SIZE = (224, 224) num_classes = dataset_info.features["label"].num_classes def to_dict(image, label): image = tf.image.resize(image, IMAGE_SIZE) image = tf.cast(image, tf.float32) label = tf.one_hot(label, num_classes) return {"images": image, "labels": label} # train, test에 사용할 데이터셋 구분 def prepare_dataset(dataset, split): if split == "train": return ( dataset.shuffle(10 * BATCH_SIZE) .map(to_dict, num_parallel_calls=AUTOTUNE) .batch(BATCH_SIZE) ) if split == "test": return dataset.map(to_dict, num_parallel_calls=AUTOTUNE).batch(BATCH_SIZE) def load_dataset(split="train"): dataset = data[split] return prepare_dataset(dataset, split) train_dataset = load_dataset()</code>Dataset 시각화Augmentation 적용 이전실제 학습에 사용되는 데이터 이미지 확인<code class="language-plaintext">def visualize_dataset(dataset, title): plt.figure(figsize=(6, 6)).suptitle(title, fontsize=18) for i, samples in enumerate(iter(dataset.take(9))): images = samples["images"] plt.subplot(3, 3, i + 1) plt.imshow(images[0].numpy().astype("uint8")) plt.axis("off") plt.show() visualize_dataset(train_dataset, title="Before Augmentation")</code>RandAugment강화학습 기반으로 최적의 Augmentation 찾아줌값을 정하는 기준은 없음, 해보면서 스스로 판단'value_range'는 이미지에 포함된 값의 범위'magnitude'는 augmentation 강도를 나타내는 0과 1 사이의 값'augmentations_per_image'는 레이어에 각각에 적용할 증강의 수를 알려주는 정수(선택 사항) 'magnitude_stddev'는 'magnitude'가 무작위로 샘플링되도록 하는 수(선택사항) 'rate'는 증강을 적용할 확률<code class="language-plaintext">rand_augment = keras_cv.layers.RandAugment( value_range=(0, 255), augmentations_per_image=3, magnitude=0.3, magnitude_stddev=0.2, rate=0.5, ) def apply_rand_augment(inputs): inputs["images"] = rand_augment(inputs["images"]) return inputs train_dataset = load_dataset().map(apply_rand_augment, num_parallel_calls=AUTOTUNE) visualize_dataset(train_dataset, title="After RandAugment")</code>Cutmix, Mixupclass 여러개가 섞임실제로 존재하지 않는 데이터를 학습하면서 모델이 robust 해짐<code class="language-plaintext">cut_mix = keras_cv.layers.CutMix() mix_up = keras_cv.layers.MixUp() def cut_mix_and_mix_up(samples): samples = cut_mix(samples, training=True) samples = mix_up(samples, training=True) return samples train_dataset = load_dataset().map(cut_mix_and_mix_up, num_parallel_calls=AUTOTUNE) visualize_dataset(train_dataset, title="After CutMix and MixUp")</code>Customize augmentationGridMask() : 이미지 일부분을 사각형이나, 마름모로 마스킹 추가흑백이미지도 학습에 사용<code class="language-plaintext">pipeline = keras_cv.layers.RandomAugmentationPipeline( layers=[keras_cv.layers.GridMask(), keras_cv.layers.Grayscale(output_channels=3)], augmentations_per_image=1, ) train_dataset = load_dataset().map(apply_pipeline, num_parallel_calls=AUTOTUNE) visualize_dataset(train_dataset, title="After custom pipeline")</code> Training a CNNlabel도 변화됨 -> cutmix, mixup keras함수는 자동 지정<code class="language-plaintext">def preprocess_for_model(inputs): images, labels = inputs["images"], inputs["labels"] images = tf.cast(images, tf.float32) return images, labels train_dataset = ( load_dataset() .map(apply_rand_augment, num_parallel_calls=AUTOTUNE) .map(cut_mix_and_mix_up, num_parallel_calls=AUTOTUNE) ) visualize_dataset(train_dataset, "CutMix, MixUp and RandAugment") train_dataset = train_dataset.map(preprocess_for_model, num_parallel_calls=AUTOTUNE) test_dataset = load_dataset(split="test") test_dataset = test_dataset.map(preprocess_for_model, num_parallel_calls=AUTOTUNE) train_dataset = train_dataset.prefetch(AUTOTUNE) test_dataset = test_dataset.prefetch(AUTOTUNE) train_dataset = train_dataset test_dataset = test_dataset</code>모델은 DenseNet121 사용label_smoothing : class 들 사이에서 바운더리를 10%확률로 나눠가지게 하는 기법<code class="language-plaintext">input_shape = IMAGE_SIZE + (3,) def get_model(): model = keras_cv.models.DenseNet121( include_rescaling=True, include_top=True, classes=num_classes ) model.compile( loss=losses.CategoricalCrossentropy(label_smoothing=0.1), optimizer=optimizers.SGD(momentum=0.9), metrics=["accuracy"], ) return model strategy = tf.distribute.MirroredStrategy() with strategy.scope(): model = get_model() model.fit( train_dataset, epochs=1, validation_data=test_dataset, )</code> 최신 연구 동향class 마다 data augmentation의 효과가 다르게 적용일부 class 정확도 희생에 전체의 정확도 상승각 class 마다 적절한 augmentation을 적용하기 위한 연구일부를 희생해서 전체의 성능을 올림, 즉 class 마다 서로 다른 augmentation을 적용해야 된다. 강의 후기Data Augmentation에 대해서 크게 생각하지 않았는데 이번 강의를 통해 Augmentation 기법이 강력하다는 것을 알 수 있었습니다.이후 프로젝트나 개인적인 분류 모델 작성 시 사용해봐야 하겠습니다.일부 class에 따라 augmentation을 다르게 지정하는 것이 좋다는 것은 신기했습니다.
이미지 분류를 위한 딥러닝 문제해결 패턴 리뷰
이미지 분류를 위한 딥러닝 문제해결 패턴 리뷰강의 링크AIFactory 에서 제공하는 세미나 중에서 흥미로웠던 부분을 중심으로 리뷰했습니다.실제로 많은 도움이 되었고 전체적인 진행방향을 잡기 좋은 강의였습니다. 1. 탐색적 데이터 분석1단계 : 문제(경진대회) 이해문제를 정확히 이해해야 목표점을 명확히 설정할 수 있음 2단계 : 탐색적 데이터 분석(EDA)주어진 데이터를 면밀히 분석딥러닝 성능은 데이터 수와 품질에 크게 좌우됨이미지 분류 딥러닝에서는 선택적 데이터 분석의 양이 적음, EDA 양이 적음 3단계 : 베이스라인 모델 설계딥러닝 프레임워크를 활용해 기본 모델 만들기처음부터 좋을수는 없음tensorflow는 배포가 pytorch 보다는 편함 4단계 : 성능 개선베이스라인 모델을 점진적으로 개선무언가 놓친 것 같다면 1단계나 2단계로 돌아가는 것도 바람직 딥러닝 문제해결 체크리스트이미지 부분에서는 EDA 할게 별로 없음이진 분류 문제의 타깃값 분포 확인 & 다중 분류 문제의 타깃값 분포 확인실제 이미지 출력 및 확인시각화를 통해 클래스별 차이를 눈으로 확인 딥러닝 이미지 분류 체크리스트 2. 베이스라인 모델 설계베이스라인 모델은 딥러닝 모델링의 시작점시작부터 최고 성능의 모델을 시도해도 성공 하기 어려움기본 모델이 있어야 최적화 기법 적용후 얼마나 성능이 더 좋아졌는지 비교해볼 수 있음 2-1) 환경 설정시드값 고정 - 결과 재현을 위한 작업GPU 장비 설정훈련 속도를 높이기 위해 데이터를 GPU 처리하도록 설정 2-2) 데이터 준비훈련/검증 데이터 분리데이터 증강이미지를 변환해 데이터 개수를 늘리는 기법이미지 개수가 부족한 상황에서 유용한 방법여러 데이터 증강 패키지 존재torchvision.transforms 변환기transforms.Pad(32, padding_mode=’symmetric’) <- 패딩추가albumentations 변환기예제 사이트 매 epoch 마다 적용하면 동일한 원본 이미지라도 새로운 학습의 효과를 얻음이미지 사이즈의 크기를 키웠을때 성능이 높아지는 경향이 있다고 함! 데이터셋 클래스 정의변환기 전달__ len __ 과 __ getitem __ 필수!__ len __ : 데이터셋 크기 반환하는 메서드__ getitem __ : 인덱스를 인수로 받아, 그 인덱스에 해당하는 데이터를 반환하는 메서드데이터 증강도 함께 적용할 수 있음사용자 정의 데이터셋 클래스를 만들 때 Dataset 추상 클래스를 꼭 상속받아야 하는지?필수는 아님, __ len __ () 과 __ getitem __ () 메서드만 동일하게 정의한다면 상속 받지 않아도 동작하지만, 코드의 의도를 명확하게 하기 위해서는 Dataset을 상속받는 것이 바람직함데이터셋 생성데이터 로더 생성결과물 : 훈련/검증용 데이터 로더 및 데이터셋 2-3) 모델 생성딥러닝 모델 직접 구현/설계torchvision.models 모듈pretrainedmodels 모듈기타 가용한 모듈 검색해 사용미리 정의된 모델을 가져와서 사용하는 것이 좋음 EDA 와 베이스라인 모델 설계 체크리스트데이터 증강을 어느정도 까지 해야하는지?데이터 증강은 너무 많이하면 오버피팅, 적정 지점을 찾는것이 정형화 되어 있지 않아서 검증데이터를 확인해서 파악하는 방법사용 3. 딥러닝 모델 성능 개선 프로세스크게 두개로 나눔, 훈련단계-예측단계 3-1) 훈련 단계 최적화손실 함수옵티마이저딥러닝 학습이 올바른 방향으로 학습하게 해주는 것adam이 최고? -> adam 계열인 Adamax, AdamW 도 좋음스케줄러get_cosin_schedule 이 좋았다고 하심 !훈련 초기와 훈련 말미에 변화를 완만하게 하면 좋은 결과를 얻었음학습률을 조절하는 것epoch 조절 2) 예측 단계 최적화테스트 단계 데이터 증강(TTA)테스트 데이터에 여러 변환 적용변환한 테스트 데이터별로 타깃 확률값 예측타깃 예측 확률의 평균 구하기이렇게 하면 앙상블 효과가 있어서 원본 데이터로 한 차례만 예측할 때보다 성능이 좋아짐변환된 target 값 여러게 사용한것이 성능을 잘 예측할수 있음안좋아지는 경우도 존재num_TTA : 5~7 정도 추천 레이블 스무딩과잉 확신한 타깃 확률값을 보정하는 기법확신이 과하면 일반화 성능이 떨어질 우려가 있음수식왼쪽과 같은 예측이 오른쪽 처럼 변화100% 성능 향상은 아님 딥러닝 문제해결 전체 체크리스트 강의 후기이전의 머신러닝 패턴 세미나와 같이 입문할 때 매우 좋은 강의였습니다.필요한 점이나 확인해야 하는 점을 꼼꼼하게 집어주신 것 같습니다.
2위 코드 공유
시간이 조금 지났지만 2위한 코드 공유합니다.코드는 아래 github에 올려놨습니다. Pytorch_Geometric 사용한 코드입니다.대회에 사용해 본 모델은 DimeNet, SchNet, TorchMDNet 3개입니다. 각각의 모델로 달성했던 성능은 표에 있습니다.DimeNet과 SchNet은 pytorch_geometric에서 쉽게 불러서 사용하실 수 있고 TorchMDNet은 논문 저자의 공식 코드 repo에서 가져온 코드를 사용하기 편하게 그냥 한 파일에 다 넣어놨습니다.TorchMDNet 논문에서는 dipole moment 예측 성능이 0.011MAE라고 리포트해놨는데 제가 완벽히 재현하지는 못한 것 같네요.혹시 궁금한 것 있으시면 댓글로 남겨주세요. 최대한 답변해 드리겠습니다.감사합니다. github link
[공지] 대회 결과 및 수상 안내
안녕하세요. 캐글 코리아 운영진 김태영입니다. 한 달 넘게 진행된 “[Space-S x KaKR] 그래프 러닝 및 해커톤”에 참여해주셔서 감사드립니다. 수상 후보 솔루션에 대한 학습 및 추론 재현성 검토 및 상금 지급을 위한 행정처리 준비 때문에 수상 안내가 늦어진 점 양해 부탁드립니다. 아래와 같이 수상 공지 드립니다.qm9 해커톤 1등 : e***lqm9 해커톤 2등 : m***mqm9 해커톤 3등 : 근***근시각화 상 : j***g코드공유 상 : 뛰***이 다***라 안***요 몌***메 p***s 노력상 : 확***까 감***란 a***d S***z 권***형 도***넛수상 되신 분들은 개별 안내 드렸습니다. "함께 공부해서, 함께 나눕시다"라는 캐글 코리아 슬로건에 맞게 많은 분들이 모델 성능을 높일 수 있는 팁들을 공유해주시고, 감사의 댓글로 피드백을 주고 받으시는 것을 보면서 다시 한 번 집단지성의 힘은 대단하다는 것을 깨닫게 된 것 같습니다. 앞으로도 좋은 기회로 커뮤니티에서 다시 뵙겠습니다. 감사합니다.
DGL SAGEConv로 점수 올리기! score 0.144 (3D feature 사용)
안녕하세요!이번 해커톤을 계기로 처음 그래프를 공부하고 있습니다.!GNN 기초적인 공부만 하다보니 어느새 기간이 며칠 안남았네요.. 아쉽습니다!그래서 지금까지 공부한 것을 바탕으로 복잡하게 하진 못하구…간단한 SAGE + 약간의 변경? 을 통해 리더보드 점수 0.14를 얻은 코드를 공유하고자 합니다!베이스 라인과 거의 동일하니 모든 분들이 쉽게 이해하실 수 있으실겁니다! 일단 yaml파일은 이렇게 변경해보았습니다.(best 파라미터를 찾지는 않았습니다!)<code class="language-plaintext">model: "SAGE_model" dataset: "qm9" out_dir: "./results/" data_path: './data/' task: 'mu' gpu: use: true id: 0 train_params: seed: 41 epochs: 100 batch_size: 256 init_lr: 1e-3 lr_reduce_factor: 0.5 lr_schedule_patience: 10 min_lr: 1e-9 weight_decay: 0.0 print_epoch_interval: 5 data: num_workers: 0 graph_encoder_params: n_layer: 4 n_heads: 4 hidden_dim: 256 out_dim: 256 edge_feat: true num_atom_type: 5</code>별다르게 바꾼 점은 없습니다.제가 변경하고자 한 부분은 노드의 피쳐를 만드는 부분이였습니다.일단, 베이스 라인에서 모델forward를 보면,<code class="language-plaintext">def forward(self, graph): h = graph.ndata["f"] h = self.embedding_h(h) # [2344] -> [2344, 64] for layer in self.gnn_layers: h = layer(graph, h) # [2344, 64] -> [2344, 64] graph_embedding = self.pooling_layer(graph, h) # [2344, 64] -> [128, 64] outputs = self.MLP_layer(graph_embedding) return outputs</code>노드 피쳐의 ‘f’만 사용한다는 점이였습니다. (그래프 노드 피쳐는 x,f 2가지가 존재)또, 피쳐 f는 단순 분자 나열?일 뿐입니다. 이 분자를 임베딩을 한 후 백터로 변환하여 사용하게 되죠.토론 글에 해당 피쳐만 사용하여 0.5점수가 나오는 코드를 올려주셨습니다.(몌메님 감사합니다.) 그럼, 여기다 피쳐 x(3차원 공간좌표)도 넣어주어 학습을 해보자 라는 생각과 토론에서 3차원 공간좌표가 중요하다고 언급하신걸 토대로 시도하게 되었습니다.그래서, 모델 코드를 이와같이 변경하였습니다.<code class="language-plaintext">class GNN_model(torch.nn.Module): def __init__(self, graph_encoder_params): super(GNN_model, self).__init__() # graph self.graph_encoder_n_layer = graph_encoder_params["n_layer"] # 5 self.graph_encoder_dim = graph_encoder_params["hidden_dim"] # 256 self.num_atom_type = graph_encoder_params["num_atom_type"] # 5 self.layer_in = self.graph_encoder_n_layer * 2 self.layer_out = self.graph_encoder_dim* 2 # 3차원 좌표 특정 vector size로 변경 self.W2 = nn.Linear(3,self.graph_encoder_dim) # (5, 64) / 즉 feature 5 개를 64개의 feature로 embedding self.embedding_h = nn.Embedding(self.num_atom_type, self.graph_encoder_dim) self.gnn_layers = ModuleList([]) for i in range(self.graph_encoder_n_layer): self.gnn_layers.append( SAGEConv( in_feats=self.layer_out, out_feats=self.layer_out, aggregator_type = 'pool', ) ) self.pooling_layer = AvgPooling() self.MLP_layer = MLPReadout(self.layer_out, 1) # 1개의 벡터 값이 나온다 def forward(self, graph): h1 = graph.ndata["f"] h2 = graph.ndata["x"] h1 = self.embedding_h(h1) h2 = self.W2(h2) h = torch.cat((h1, h2), 1) for layer in self.gnn_layers: h = layer(graph, h) # [256, 64] -> [256, 64] graph_embedding = self.pooling_layer(graph, h) # [2344, 64] -> [128, 64] outputs = self.MLP_layer(graph_embedding) return outputs</code>피쳐 x도 layer를 걸쳐 vector화를 시켜, f와 x vector를 단순 concat(옆으로 붙임) 하여 노드피쳐를 생성해 주었습니다. 이런 노드 피쳐를 가지고 학습을 진행하면… MXMNet과 같은 모델과는 비교할 수 없지만, 생각보다 성능이 훨씬 좋아지는 것을 볼 수 있었습니다.(+ 여기다 파라미터 튜닝을 하시면.. 훨씬 더….?) 전체 코드 링크도 올려놓겠습니다! 다들 공유해주셔서 감사합니다! 많이 배웠습니다!https://drive.google.com/file/d/1KnD6Wc7PHnbzxKkbPbVpFL5DXNV-N_rj/view?usp=sharing
높은 score를 위한 논문 공유(DimeNet, MXMNet)
안녕하세요. 안녕해요입니다. 대회에 참여하면서 여러 모델들을 만들어 보았는데, 분자의 3D 정보를 잘 활용하는 것이 높은 score를 달성하는데 중요하다는 사실을 알게 되었습니다.SMILES만 사용하는 경우에 비해 성능이 월등히 좋습니다.관련 코드 정리가 어려워 코드 공유는 추후에 하도록 하겠습니다. 모델 자체가 크기 때문에 코랩으로 실행이 불가능합니다.DimeNet: https://arxiv.org/abs/2003.03123MXMNet: https://arxiv.org/abs/2011.07457현재까지 제가 공부한 모델들의 논문 주소 입니다. 코드도 제공되어 있으니 대회의 데이터에 맞춰 수정하면 적용 가능합니다.저는 MXMNet을 사용해 0.0361997567의 성능을 달성했습니다. 더 성능을 올리기 위해서는 더 최근에 나온 논문을 찾아보고 구현한다면 좋을 결과가 있을 수 있을 것 같습니다. 감사합니다.
[코드 공유] hyperparameter tuning 해보기 (mae 계산 코드를 곁들인)
안녕하세요 몌메 입니다 🍓👩🏻💻!모델을 최적화하기 위해 하이퍼파라미터를 튜닝하는 과정을 필수죠.특히 딥러닝 같은 경우에서 하이퍼파라미터가 많고 그에 따라 성능이 아주 달라 지기 때문에 중요합니다. 그래서 오늘은 hyperparameter tuning을 하기 위한 코드를 가져와봤습니다.그와 더불어 어떤 파라미터가 좋은 성능을 보이는지 확인도 필요하겠죠!그래서 mae 계산 코드도 가져와봤습니다. (매우 간단 주의)또한 모든 파일을 돌리기 위한 bash코드도 적어보았습니다. 사실 하이퍼파라미터 튜닝 방법은 여러가지가 있습니다.그 중 해커톤에서 제공해주신 파이썬 프로젝트 베이스라인을 잘 활용해 튜닝할 수 있는 방법이 없을까? 생각을 해보다가…🤩 configs 폴더에 여러 파라미터를 내장한 yaml 파일을 만들어보자 !!!라는 아이디어를 떠올리게 되었습니다. 파이썬 프로젝트 베이스라인 폴더를 살펴보면 이런식으로 configs, data, model.py, qm9_dataset.py, README.md, train.py가 있는데요. 여기서 configs 파일을 들어가시면 처음에 gnn.yaml 파일이 있는 걸 확인할 수 있습니다.gnn.yaml 파일은 이런식으로 생겼습니다. yaml은 데이터 직렬화 언어인데, python으로 가져와서 필요한 변수에 값을 지정해주는 역할을 해줍니다.저는 여기서 graph_encoder_params를 주목했는데요, 이 변수들은 모두 model안의 parameter들을 의미합니다.model 코드안을 살펴보면 graph_encoder_params['~~'] 이런식으로 변수를 가져오는 것을 확인할 수 있습니다.그러므로 yaml의 graph_encoder_params를 바꿔주면, 다른 파라미터를 적용할 수 있는것이죠!! 하이퍼파라미터 튜닝의 종류도 아주아주 다양하지만, 저는 random search를 사용하였습니다.random search는 경계 내에서 임의의 조합을 추출하여 최적의 조합을 찾는 방법입니다.그래서 임의로 파라미터 범위를 지정해주면 거기서 랜덤으로 뽑아서 변수가 지정되게 되는 것이죠.그래서 random search를 하면서 yaml 파일을 저장해주는 코드는 다음과 같습니다. <code class="language-python">import random import yaml def make_conf(nums): ############ 1.기본으로 주어진 config 파일을 열어줍니다. path = '/configs/gnn.yaml' with open(path, 'r') as f: conf = yaml.safe_load(f) ############ 2.num 만큼 반복해줍니다. for num in range(nums): ############ 3. 바꿔줄 hyperparameter들의 값들을 list 형태로 넣어줍니다. hyperparameter = { 'n_layer':random.choice([3,5,7]), 'n_heads' :random.choice([5,8,10]), 'hidden_dim':random.choice([32,64,128]), 'out_dim':random.choice([32,64,128]) } ############ 4.graph_encoder_params 를 바꿔줍니다. for i, j in hyperparameter.items(): conf['graph_encoder_params'][i] = j ############ 5. config 파일을 저장해줍니다. with open(f'/configs/gnn_{num}.yaml', 'w') as o: yaml.dump(conf, o) if __name__ == "__main__": make_conf(nums = 10)</code> nums에 random search 하고 싶은 수를 적어주면 그만큼의 파일이 생깁니다. bash 언어로 모든 파일을 돌리는 코드도 공유해드립니다 ㅎㅎ*로 표시하면 * 앞뒤로 적혀있는 문자들을 포함하는 모든 파일들을 가져온다는 뜻입니다. <code class="language-python">%%bash for gnn in $(ls -v configs/gnn_*.yaml); do python train.py --config configs/$gnn; done</code> 어떤 파라미터가 가장 좋은 성능을 내는지를 확인하는 지표가 필요하겠죠.이번 해커톤에서 사용하는 평가 메트릭인 Mean Absolute Error이기 때문에 이를 계산하는 코드를 val_epoch에 추가해줍니다. <code class="language-python">from sklearn.metrics import mean_absolute_error def val_epoch(epoch, model, loss_fnc, dataloader, FLAGS, device): model.eval() total_loss = 0 total_mae = 0 rescale_loss = 0 for i, (g, y) in enumerate(tqdm(dataloader)): g = g.to(device) y = y.to(device) # run model forward and compute loss pred = model(g) loss = loss_fnc(pred, y) total_loss += loss.item() # calculate mae mae = mean_absolute_error(to_np(pred),to_np(y)) total_mae += mae print(f"...[{epoch}|val] loss: {total_loss:.5f} mae: {mae/i+1:.5f}")</code> 이상으로 코드 공유를 마치겠습니다.궁금한 점이 있으시다면 댓글로 남겨주세요!! 👩🏻💻💬
DGL SAGEConv 코드 공부
안녕하세요~ 이번 해커톤을 통해 처음 그래프 모델을 공부하게 됐습니다!다른 분야와는 사뭇 다르고, 뭔가 어렵다고 느껴져서 기초부터 공부하고 있는데, 도무지 이론적으로는 와닿지가 않아영상중에 빠지지 않는 GraphSAGE의 코드를 한번 보고자 하였습니다.dgl에서 제공하는 SAGEConv 레이어에 간단한 예제를 넣어 디버깅을 하면서 나름대로 주석을 달아 보았습니다. 막상 보고나니, 머릿속이 혼동스럽기도 하네요 ㅎㅎ… 도움이 되시는 분이 있길 바랍니다.!https://colab.research.google.com/drive/10Tt6yWozVm0Mld5DL-LWjC1Ry4TyL6XC?usp=sharing *아무래도 이론적인 내용을 더 학습해야 진도를 나갈 수 있을것 같네요 …ㅎ +추가) https://sims-solve.tistory.com/68 해당 블로그에 간단한 예제를 SAGEConve를 통하면 어떻게 결과값이 나오는지 직접 계산해보았습니다.이렇게 하고 나니 SAGEConv에 대한 개념이 많이 잡히게 됐네요!!! Massage passing , reduce funtion의 개념도 어느정도는 잡힌것같습니다!혹시나 도움이 되시는 분이 있길 바랍니다! 화이팅!
[코드 공유] Convolution Layers 바꿔보기 (리더보드 0.599점)
안녕하세요 몌메 입니다 🍓👩🏻💻!평소 그래프 러닝에 관심이 아주 많았는데, 이렇게 해커톤을 열어주셔서 감사합니다. 오늘은 Convolution Layer을 바꿔 점수를 높일 수 있는 코드를 알려드리려고 합니다.리더보드 기준 0.599점까지 달성할 수 있는 코드입니다! 기본 모델 베이스라인 코드의 ‘model.py’파일을 열어보시면 gnn모델의 코드를 확인하실 수 있습니다.<code class="language-python">class GNN_model(torch.nn.Module): def __init__(self, graph_encoder_params): super(GNN_model, self).__init__() # graph self.graph_encoder_n_layer = graph_encoder_params["n_layer"] self.graph_encoder_dim = graph_encoder_params["hidden_dim"] self.num_atom_type = graph_encoder_params["num_atom_type"] self.embedding_h = nn.Embedding(self.num_atom_type, self.graph_encoder_dim) self.gnn_layers = ModuleList([]) for _ in range(self.graph_encoder_n_layer): self.gnn_layers.append( GraphConv( in_feats=self.graph_encoder_dim, out_feats=self.graph_encoder_dim, norm="both", ) ) self.pooling_layer = AvgPooling() self.MLP_layer = MLPReadout(self.graph_encoder_dim, 1)</code> 위 모델에는 from dgl.nn import GraphConv을 통해 GraphConv라는 것을 사용했습니다.하지만 이 layer는 아주 기본적인 것 이므로 이것 말고 더 다양한 layer들을 존재하는데요,pytorch에서 제공하는 layer들은 다음과 같습니다.더 많은 layer들의 정보들은 이 링크를 통해 들어가셔서 확인해주시면 됩니다. 제가 실험해본 layer은 GINConv와 SAGEConv입니다.GINConv는 Graph Isomorphism Network layer이고, SAGEConv는 SAmple and aggreGatE convolution layer입니다. 우선 각 layer을 사용한 모델을 만듭니다.<code class="language-python">class GINConv_model(torch.nn.Module): def __init__(self, graph_encoder_params): super(GINConv_model, self).__init__() # graph self.graph_encoder_n_layer = graph_encoder_params["n_layer"] self.graph_encoder_dim = graph_encoder_params["hidden_dim"] self.num_atom_type = graph_encoder_params["num_atom_type"] self.embedding_h = nn.Embedding(self.num_atom_type, self.graph_encoder_dim) self.gnn_layers = ModuleList([]) for _ in range(self.graph_encoder_n_layer): lin = torch.nn.Linear(self.graph_encoder_dim,self.graph_encoder_dim) self.gnn_layers.append( GINConv(lin, 'sum', ) ) self.pooling_layer = AvgPooling() self.MLP_layer = MLPReadout(self.graph_encoder_dim, 1) def forward(self, graph): h = graph.ndata["f"] h = self.embedding_h(h) # [2344] -> [2344, 64] for layer in self.gnn_layers: h = layer(graph, h) # [2344, 64] -> [2344, 64] graph_embedding = self.pooling_layer(graph, h) # [2344, 64] -> [128, 64] outputs = self.MLP_layer(graph_embedding) return outputs</code><code class="language-python">class SAGEConv_model(torch.nn.Module): def __init__(self, graph_encoder_params): super(SAGEConv_model, self).__init__() # graph self.graph_encoder_n_layer = graph_encoder_params["n_layer"] self.graph_encoder_dim = graph_encoder_params["hidden_dim"] self.num_atom_type = graph_encoder_params["num_atom_type"] self.embedding_h = nn.Embedding(self.num_atom_type, self.graph_encoder_dim) self.gnn_layers = ModuleList([]) for _ in range(self.graph_encoder_n_layer): self.gnn_layers.append( SAGEConv( in_feats=self.graph_encoder_dim, out_feats=self.graph_encoder_dim, aggregator_type = 'pool', ) ) self.pooling_layer = AvgPooling() self.MLP_layer = MLPReadout(self.graph_encoder_dim, 1) def forward(self, graph): h = graph.ndata["f"] h = self.embedding_h(h) # [2344] -> [2344, 64] for layer in self.gnn_layers: h = layer(graph, h) # [2344, 64] -> [2344, 64] graph_embedding = self.pooling_layer(graph, h) # [2344, 64] -> [128, 64] outputs = self.MLP_layer(graph_embedding) return outputs</code>조심해야할 점은 각 layer마다 필요로하는 parameter들이 다릅니다.그래서 parameter들을 확인해주신 다음 그에 알맞는 변수들을 넣어주시면 됩니다. 그 후 각 모델들의 parameter들을 넣어줄 yaml 파일을 만들어 줍니다.<code class="language-python">model: "GINConv_model" dataset: "qm9" out_dir: "./results/" data_path: './data/' task: 'mu' gpu: use: true id: 0 train_params: seed: 41 epochs: 100 batch_size: 64 init_lr: 0.0007 lr_reduce_factor: 0.5 lr_schedule_patience: 15 min_lr: 1e-6 weight_decay: 0.0 print_epoch_interval: 5 max_time: 24 data: num_workers: 0 graph_encoder_params: n_layer: 3 n_heads: 8 hidden_dim: 64 out_dim: 64 edge_feat: true num_atom_type: 5</code><code class="language-python">model: "SAGEConv_model" dataset: "qm9" out_dir: "./results/" data_path: './data/' task: 'mu' gpu: use: true id: 0 train_params: seed: 41 epochs: 100 batch_size: 128 init_lr: 0.0007 lr_reduce_factor: 0.5 lr_schedule_patience: 15 min_lr: 1e-6 weight_decay: 0.0 print_epoch_interval: 5 max_time: 24 data: num_workers: 0 graph_encoder_params: n_layer: 3 n_heads: 8 hidden_dim: 64 out_dim: 64 edge_feat: true num_atom_type: 5</code>위의 파일들을 원하는 directory에 넣은 후, 모델학습을 시작하시면 됩니다!모델을 불러올 때는 from model import GNN_model, SAGEConv_model, GINConv_model 로 불러오시면 됩니다.또 방금 만든 yaml는 parser의 config에서 경로를 지정해 주시면 됩니다.<code class="language-python">################ 1. parsing arguments parser = argparse.ArgumentParser() parser.add_argument('--config', type=str, default='./gin.yaml', help='configration for model') parser.add_argument('--pretrained_path', type=str, default=None, help='configration for model') args, extra_args = parser.parse_known_args() FLAGS = OmegaConf.load(args.config) # Create model directory if not os.path.isdir(FLAGS.out_dir): os.makedirs(FLAGS.out_dir) # Fix SEED torch.manual_seed(FLAGS.train_params.seed) np.random.seed(FLAGS.train_params.seed) # Automatically choose GPU if available device = gpu_setup(FLAGS['gpu']['use'], FLAGS['gpu']['id']) ################ 2. Prepare data dataset = QM9DGLDataset(FLAGS.data_path, FLAGS.task, file_name='qm9_train_data.pt', mode='train') train_dataset, val_dataset = dataset.train_val_random_split(0.8) train_loader = DataLoader(train_dataset, batch_size=FLAGS.train_params.batch_size, shuffle=True, collate_fn=dataset.collate_fn, num_workers=FLAGS.data.num_workers) val_loader = DataLoader(val_dataset, batch_size=FLAGS.train_params.batch_size, shuffle=False, collate_fn=dataset.collate_fn, num_workers=FLAGS.data.num_workers) # Test Dataset test_dataset = QM9DGLDataset(FLAGS.data_path, FLAGS.task, file_name='qm9_test_data.pt', mode='test') test_loader = DataLoader(test_dataset, batch_size=FLAGS.train_params.batch_size, shuffle=False, collate_fn=test_dataset.collate_fn, num_workers=FLAGS.data.num_workers) FLAGS.train_size = len(train_dataset) FLAGS.val_size = len(val_dataset) FLAGS.test_size = len(test_dataset) print(f"Train set size: {len(train_dataset)}") print(f"Validation set size: {len(val_dataset)}") print(f"Test set size: {len(test_dataset)}") ################ 2. Prepare model model = GINConv_model(FLAGS.graph_encoder_params) if args.pretrained_path is not None: model.load_state_dict(torch.load(args.pretrained_path)) model.to(device) criterion = l1_loss optimizer = optim.Adam(model.parameters(), lr=FLAGS.train_params.init_lr) scheduler = optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer, FLAGS.train_params.epochs, eta_min=FLAGS.train_params.min_lr) ################ 2. Start training # Run training print('Begin training') for epoch in range(FLAGS.train_params.epochs): train_epoch(epoch, model, criterion, train_loader, optimizer, scheduler, FLAGS, device) val_epoch(epoch, model, criterion, val_loader, FLAGS, device) # save checkpoint save_path = os.path.join(FLAGS.out_dir, f"{FLAGS.model}_{FLAGS.task}_{epoch}.pt") torch.save(model.state_dict(), save_path) print(f"Saved checkpoint: {save_path}") ################ 3. Test print('Begin test') predictions = run_test(model, test_loader, device) np.savetxt('gin_pred.csv', predictions)</code><code class="language-python">################ 1. parsing arguments parser = argparse.ArgumentParser() parser.add_argument('--config', type=str, default='./sage.yaml', help='configration for model') parser.add_argument('--pretrained_path', type=str, default=None, help='configration for model') args, extra_args = parser.parse_known_args() FLAGS = OmegaConf.load(args.config) # Create model directory if not os.path.isdir(FLAGS.out_dir): os.makedirs(FLAGS.out_dir) # Fix SEED torch.manual_seed(FLAGS.train_params.seed) np.random.seed(FLAGS.train_params.seed) # Automatically choose GPU if available device = gpu_setup(FLAGS['gpu']['use'], FLAGS['gpu']['id']) ################ 2. Prepare data dataset = QM9DGLDataset(FLAGS.data_path, FLAGS.task, file_name='qm9_train_data.pt', mode='train') train_dataset, val_dataset = dataset.train_val_random_split(0.8) train_loader = DataLoader(train_dataset, batch_size=FLAGS.train_params.batch_size, shuffle=True, collate_fn=dataset.collate_fn, num_workers=FLAGS.data.num_workers) val_loader = DataLoader(val_dataset, batch_size=FLAGS.train_params.batch_size, shuffle=False, collate_fn=dataset.collate_fn, num_workers=FLAGS.data.num_workers) # Test Dataset test_dataset = QM9DGLDataset(FLAGS.data_path, FLAGS.task, file_name='qm9_test_data.pt', mode='test') test_loader = DataLoader(test_dataset, batch_size=FLAGS.train_params.batch_size, shuffle=False, collate_fn=test_dataset.collate_fn, num_workers=FLAGS.data.num_workers) FLAGS.train_size = len(train_dataset) FLAGS.val_size = len(val_dataset) FLAGS.test_size = len(test_dataset) print(f"Train set size: {len(train_dataset)}") print(f"Validation set size: {len(val_dataset)}") print(f"Test set size: {len(test_dataset)}") ################ 2. Prepare model model = SAGEConv_model(FLAGS.graph_encoder_params) if args.pretrained_path is not None: model.load_state_dict(torch.load(args.pretrained_path)) model.to(device) criterion = l1_loss optimizer = optim.Adam(model.parameters(), lr=FLAGS.train_params.init_lr) scheduler = optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer, FLAGS.train_params.epochs, eta_min=FLAGS.train_params.min_lr) ################ 2. Start training # Run training print('Begin training') for epoch in range(FLAGS.train_params.epochs): train_epoch(epoch, model, criterion, train_loader, optimizer, scheduler, FLAGS, device) val_epoch(epoch, model, criterion, val_loader, FLAGS, device) # save checkpoint save_path = os.path.join(FLAGS.out_dir, f"{FLAGS.model}_{FLAGS.task}_{epoch}.pt") torch.save(model.state_dict(), save_path) print(f"Saved checkpoint: {save_path}") ################ 3. Test print('Begin test') predictions = run_test(model, test_loader, device) np.savetxt('sage_pred.csv', predictions)</code> 리더보드 기준 gnn은 0.8644, SAGEConv는 0.5990, GINConv는 0.8423점이 나오네요!다른 layer들은 또 얼마만큼의 성능을 가지고 있을지 궁금하네요! 이상으로 코드공유를 마치겠습니다.궁금한 점이 있으시다면 댓글로 남겨주세요!! 🤗
dgllife를 활용하여 MPNN 모델 사용해 보기
안녕하세요. 안녕해요입니다.지난 글에서 SMILES와 Mol_id를 합쳐 놓은 train, test파일을 만드는 방법에 대해서 알아보았습니다. 이번에는 해당 파일을 가지고 손쉽게 graph파일을 만들고, MPNN모델에 넣어보는 예제를 가져왔습니다.<code class="language-plaintext">!pip install dgl-cu113 dglgo -f https://data.dgl.ai/wheels/repo.html # 화학, 생명과학에 적용하기 위한 GNN 코드들을 구현해 둔 Package !pip install dgllife</code>가장 먼저 dgl과 dgllife package를 다운로드 합니다.<code class="language-plaintext">import pandas as pd import numpy as np Train = pd.read_csv('data/train.csv') </code>우선 train파일을 불러온 후 <code class="language-plaintext">from dgllife.utils import CanonicalAtomFeaturizer # atom_type_one_hot(44), atom_degree_one_hot, atom_implicit_valence_ont_hot, atom_formal_charge, atom_num_radical_electrons, atom_hybridization_one_hot, atom_is_aromatic, atom_total_num_H_one_hot from dgllife.utils import CanonicalBondFeaturizer # bond_type_one_hot(Single, Double, Triple, Aromatic), bond_is_conjugated, bond_is_in_ring, bond_stereo_one_hot(Stereonone, stereoany, stereoz, stereoe, stereocis, stereotrans) from dgllife.utils import SMILESToBigraph from rdkit import Chem smiles_to_g = SMILESToBigraph(add_self_loop=False, node_featurizer=CanonicalAtomFeaturizer(), edge_featurizer=CanonicalBondFeaturizer()) example_graph = smiles_to_g(Train.smiles[0])</code>Train데이터의 SMILES 하나를 graph로 만들어 봅니다. 이 때 atomfeaturizer과 bondfeaturizer를 사용합니다.<code class="language-plaintext">from dgllife.model.model_zoo.mpnn_predictor import MPNNPredictor model = MPNNPredictor(node_in_feats = len(example_graph.ndata['h'][0]), edge_in_feats = len(example_graph.edata['e'][0])) output = model(example_graph, node_feats = example_graph.ndata['h'], edge_feats = example_graph.edata['e']) output</code>그리고 MPNN Predictor를 불러와 해당 예시 Graph를 input으로 넣어보면 하나의 값이 output으로 나오는 것을 확인할 수 있습니다. 해당 내용을 활용해 GAT, GCN, MPNN, AttentiveFP 등 다양한 모델들에 손쉽게 적용할 수 있을 것으로 생각합니다.https://lifesci.dgl.ai/api/model.zoo.html 이 문서를 통해 source코드들을 확인해보고, 적용해보면 좋을 것 같습니다. https://colab.research.google.com/drive/1JmS2qbEZYn2dyFl3BzB8uTf3r0F7L0Va?usp=sharing 해당 링크를 통해 위 code들을 실행해 보실 수 있습니다. 추후에는 높은 score를 달성 할 수 있는 code와 관련한 게시글로 찾아 오겠습니다. 감사합니다.
[러닝 콘텐츠] 분자데이터와 그래프 데이터 다루어보기
안녕하세요 KaKR 김준태입니다.이번 해커톤 대회 그래프 데이터 시각화 부분 코랩 노트북이 제공되었습니다.그래프 데이터를 다룰때에는 networkX 분자데이터를 다룰 때에는 rdkit을 많이 사용합니다.하지만 이런 파이썬 패키지 사용을 잘 경험해보지 못하셨으리라 생각합니다. 그래서 이번 시각화 콘텐츠로 기획하게 된 것은“분자 데이터를 그래프로 시각화해보자” 입니다. 주 내용은rdkit을 이용하여 smiles 다루기rdkit을 이용하여 분자 시각화하기networkX을 이용하여 분자 데이터 그래프로 표현하기분자 데이터 속성 분석하기를 간단히 소개하고 연습으로 따라 해볼 수 있는 코드를 제공했습니다. 감사합니다. https://colab.research.google.com/github/aifactory-team/AFCompetition/blob/main/2106/molecule_visaulization.ipynb
언어 모델 BERT를 이용한 molecule property 예측
안녕하세요, 본 대회는 graph 형태의 input을 이용한 molecular property 예측을 목표로 하고 있지만, 다른 방법론으로 SMILES라는 분자 구조 표현 방식을 언어로 취급하여 자연어 처리 모델을 사용하는 방법이 있습니다. 예전에 진행했던 프로젝트에서 학습시켜두었던 pretrained BERT 모델을 이용하여 예측을 하는 모델을 만들어 보았습니다. 해당 코드를 공유드리오니 SMILES라는 문자열 기반 표현 체계가 이런 식으로 사용되는구나 하고 참고하는 기회가 되셨으면 좋겠습니다. 코랩 링크는 아래와 같습니다.https://colab.research.google.com/drive/1dnPvQYAszXqedZyO7bYZMF6HKLa0sDyP?usp=sharing 필요 라이브러리torch / sklearn / pytorch_lightning / transformers여기에서 pytorch_lightning은 학습을 간단하게 하기 위해 사용한 wrapper로서 사용하지 않으셔도 무방합니다. huggingface 의 hub에 bert weight 과 tokenizer를 업로드 해두어서 자동으로 다운로드 받아 사용하실 수 있게 작업해두었습니다. 2. 모델 설명분자 구조는 SMILES (Simplified molecular-input line-entry system)라 불리는 문자 체계를 이용하여 표현할 수 있습니다. SMILES는 atom, bond type 등을 약속된 문자를 이용하여 표현합니다. 예를 들어 caffeine은 CN1C=NC2=C1C(=O)N(C(=O)N2C)C으로 표현됩니다. 각각의 atom과 bond type 등이 자연어의 의미를 담고 있는 단어, 문법적 기능을 수행하는 단어처럼 가정하여 이를 언어 모델에다가 넣어줍니다. 학습은 BERT 모델과 유사하게 masked language modeling을 적용합니다. 해당 모델에 대한 자세한 설명은 https://huggingface.co/jonghyunlee/DrugLikeMoleculeBERT 을 참고하시기 바랍니다. 3. 결과본 대회의 취지가 graph 를 사용하는 것이니 만큼 튜닝에 큰 정성을 쏟지는 않았습니다. 하여 성능이 그닥 높지는 않았습니다만, 0.4906 가 나와 baseline 보다는 높았습니다 : ) 4. 참고 문헌본 모델은 Deargen 사의 MT-DTI 모델에 영향을 받았습니다. https://arxiv.org/abs/1908.06760
[러닝 콘텐츠] 파이썬 베이스라인 코드 따라해보기
안녕하세요! KaKR 김태진입니다.이번 해커톤 대회에 베이스라인 코드는 “파이썬 프로젝트”와 “코랩 노트북” 이 2가지 형태로 제공되었습니다.노트북 형태의 베이스라인은 많은 분들이 익숙하실거라 생각하지만 “파이썬 프로젝트”로 이루어진 베이스라인은 잘 경험해보지 못하셨으리라 생각합니다. 그래서 이번 러닝 콘텐츠로 기획하게 된 것은, “파이썬 프로젝트의 베이스라인을 한번 사용해보자” 입니다.주 내용은파이썬 프로젝트로 실험을 하였을 때 어떤 장점이 있는지, 파이썬 프로젝트 환경은 어떻게 설정하고.IDE를 사용했을 때 편리한 점이 무엇인지,IDE에서 코드 디버깅은 어떻게 이루어지는지 등을 간단히 소개 하고 연습으로 따라해볼 수 있는 영상을 제작하였습니다.이번 기회에 파이썬 프로젝트에 익숙해지고 싶은 분들께 추천드립니다! 영상을 빨리 찍어 올려드렸어야 하는데 늦게 준비되어 죄송한 말씀을 드립니다. (_ _)영상 내용에 대해 질문이 있으시거나 수정이 필요한 내용이 있다면 언제든 문의 부탁드립니다. 감사합니다. 파이썬 베이스라인 코드 따라하기 - 준비https://aifactory.space/learning/detail/2150파이썬 베이스라인 코드 따라하기 - 연습https://aifactory.space/learning/detail/2151
개요 영상 요약
그래프 데이터라는 형식이 존재하는지도 몰랐던 반도체를 전공하는 대학생입니다!반도체는 21세기 첨단 산업으로서 다양한 화학반응으로 많은 공정들을 통해 생산이 되는데 나중에 반도체 분야에 가서 관련 데이터를 통해 인사이트를 도출할 수 있다면 좋을 것같아 도전하고자 합니다.대회에 참가하면서 될 수 있는 한 관련 서적을 통해 얻은 지식들을 학습하고 공유할 생각입니다! 잘 부탁드립니다!~ 그래프 데이터셋의 진입장벽 (허들)데이터 타입 자체가 이해하기 힘들다.노드 사이에 연결이 존재한다.이미지 데이터의 경우, batch size를 10으로 지정하면 같은 크기의 이미지들이 학습과정에서 동시에 학습되지만 그래프 데이터의 경우, batch size가 10이어도 그래프들 10개가 학습되는 것이 아니라 그래프 내 노드들이 10개씩 학습되는 구조이기에 다른 그래프들의 노드들이 학습과정에서 같이 학습되는 경우가 있다. 그래프들마다 다이나믹한 노드 수를 가지고 있다. 대회 취지그래프 데이터를 전문적으로 다루는 사람들 사이의 경쟁 X그래프 데이터를 같이 공부했으면 좋겠다 싶어 개최한 해커톤!이번 대회를 통해 그래프 데이터라는 것이 있다는 것을 알고 학습하게 됨에 따라 나중에 프로젝트를 하면서 그래프 데이터로 해결할 수 있다는 하나의 선택지를 가지게 되는 것!많은 사람들과 같이 공부하며 성장하는 것 준비한 데이터셋 = QM9C(탄소), H(수소), O(산소), N(질소), F(플루오린)으로 구성된 약 13만 4천여개의 데이터원래 데이터셋에는 예측에 사용할 수 있는 속성들이 많지만 대회에서는 그 중에서 하나의 속성만 제공예측하고자 하는 속성은 바로 ‘smiles’라는 문자열로 되어 있는 분자들의 구조회귀문제에 해당 TIP!그래프 형태로 입력하거나 그래프를 벡터 형태로 인코딩하는 molecule fingerprint 방법이 존재출력이 어떤 값인 지 이해하는 것도 중요하지만 대회 취지가 그래프 데이터 학습이기에 도메인 지식을 습득하기 위한 노력은 추천하지 않음DFS, BFS와 같은 알고리즘 지식 필요 X데이터를 어떻게 전처리하고 파이프라인에 넣는 것이 중요
베이스 라인 코드 보기
뒤늦게 그래프 러닝 해커톤에 참여하게 됐습니다.! Pytorch를 공부할 겸 제공해준 베이스 라인코드에 나름대로 주석을 넣어서 한번 작성해 보았습니다.!토론 게시글에 보다 자세하고 훌륭하게 베이스 라인 코드를 분석해주신 분이 있으니, 꼭 보시는걸 추천드립니다! 단순, 코드를 한줄씩 보면서 나름대로 주석을 넣어봤습니다!저처럼 완전 초보이신 분에게 도움이 됐으면 좋겠네요! :)https://colab.research.google.com/drive/1vTQk98_YzTNQsLimRQnSprIPJLckRjh2?usp=sharing 참고로 베이스라인 코드 점수는 0.8644150494점 이 나왔습니다!
학습데이터 테스트데이터 만들기
학습데이터와 테스트데이터를 불러오고데이터 구조를 파악해보고마지막으로 Smiles 데이터와 병합시켜주어최종적으로 학습될 학습데이터와 테스트데이터를 만들어주었습니다. <code class="language-plaintext">import pandas as pd import numpy as np test = torch.load('../input/kagglekorea/qm9_test_data.pt') train = torch.load('../input/kagglekorea/qm9_train_data.pt') submission = pd.read_csv('../input/kagglekorea/sample_submission.csv') mol = pd.read_csv('../input/kagglekorea/mol_id_to_smiles.csv') smiles = pd.read_csv('../input/kagglekorea/mol_id_to_smiles.csv') submission.shape, mol.shape submission pd.DataFrame(zip(list(test.keys()), list(test.values()))).T test.keys(), train.keys() train['mu'] empty_train_set = pd.DataFrame() empty_train_3d_set = [] for key in train.keys(): if train[key].ndim == 1: empty_train_set = pd.concat([empty_train_set, pd.DataFrame(train[key])], axis = 1) elif train[key].ndim == 3: empty_train_3d_set.append(train[key]) empty_train_set.columns = list(train.keys())[:-4] empty_test_set = pd.DataFrame() empty_test_3d_set = [] for key in test.keys(): if test[key].ndim == 1: empty_test_set = pd.concat([empty_test_set, pd.DataFrame(test[key])], axis = 1) elif test[key].ndim == 3: empty_test_3d_set.append(test[key]) empty_train_3d_set[0].shape empty_test_3d_set[0].shape m,n,r = empty_train_3d_set[0].shape train_stack = np.column_stack((np.repeat(np.arange(m),n),empty_train_3d_set[0].reshape(m*n,-1))) train_3d = pd.DataFrame(train_stack) m,n,r = empty_test_3d_set[0].shape test_stack = np.column_stack((np.repeat(np.arange(m),n),empty_test_3d_set[0].reshape(m*n,-1))) test_3d = pd.DataFrame(test_stack) train_3d test_3d pd.DataFrame(dict(rows = list(empty_train_3d_set[0]))) pd.DataFrame(dict(rows = list(empty_test_3d_set[0]))) empty_test_set.columns = list(test.keys())[:-4] empty_test_set X_train = empty_train_set.drop(['mu'], axis=1) y_train = empty_train_set['mu'] X_test = empty_test_set X_train.rename(columns = {X_train.columns[0] : 'id'}, inplace = True) X_test.rename(columns = {X_test.columns[0] : 'id'}, inplace = True) smiles.rename(columns = {smiles.columns[0] : 'id'}, inplace = True) smiles.rename(columns = {smiles.columns[0] : 'id'}, inplace = True) X_train.columns, smiles.columns X_train = X_train.merge(smiles, left_on='id', right_on = 'id') X_train X_test = X_test.merge(smiles, left_on='id', right_on = 'id') X_test import torch import tensorflow as tf import keras from keras.models import Sequential from keras.layers import Conv2D, MaxPooling2D, AveragePooling2D from keras.layers import Dense, Activation, Dropout, Flatten </code>
Mol_id와 SMILES를 merge한 DataFrame 만들기
안녕하세요. 안녕해요입니다.현재 Data파일에 SMILES 데이터가 추가되었기 때문에 SMILES와 mol_id를 columns으로 가지는 DataFrame 만드는 방법을 가져왔습니다.SMILES는 Simplified molecular-input line-entry system으로 분자를 쉽게 문자열로 표기하는 대표적인 방법들 중 하나이고, 가장 많이 사용됩니다. SMILES를 손쉽게 graph로 변환할 수 있는 tools들이 많이 개발되어 있어 분자 관련 연구를 할 때 SMILES를 많이 사용합니다. 우선 3가지 데이터를 각각 불러옵니다.<code class="language-plaintext">import torch import pandas as pd Train = torch.load('data/qm9_train_data.pt') # Dictionary 형태의 데이터 Test = torch.load('data/qm9_test_data.pt') smiles_df = pd.read_csv('data/mol_id_to_smiles.csv')</code>그리고 Train, Test에서 각각 사용할 key들을 불러와 DataFrame을 만들어줍니다.<code class="language-plaintext">train_df = pd.DataFrame(np.stack((Train['mol_id'], Train['mu']), axis=1), columns=['id', 'mu']) test_df = pd.DataFrame(Test['mol_id'], columns=['id'])</code>마지막으로 train파일과 smiles_df의 id에 맞춰 merge해주면 쉽게 mol_id와 SMILES를 merge한 DataFrame을 만들 수 있습니다.<code class="language-plaintext">train_df = pd.merge(train_df, smiles_df, on='id') test_df = pd.merge(test_df, smiles_df, on='id')</code>Merge된 파일들은 첨부했으니 참고 바랍니다. 추후에 SMILES를 활용해 graph를 만들고, 다양한 GNN을 손쉽게 적용할 수 있는 코드를 가지고 돌아오겠습니다.
파이토치에서 과적합 전의 최적 모델을 저장하고 불러오는 방법
현재 제공된 베이스라인을 살펴보시면 전체 에포크만큼 학습한 최종 모델로 제출 파일을 생성합니다. 이러면 과적합이 된 모델로 추론했을 가능성이 높습니다. (과적합에 대해서 더 알고싶으시다면, 이 태스크로 >> 다층 퍼셉트론 신경망 검증하기) 과적합 전의 최적 모델의 결과를 얻기 위해 파이토치에서 학습한 모델을 저장하고 불러오는 방법에 대해서 설명드리고자 합니다. 이 방법은 여러가지 목적으로 사용되므로 알아두시면 요긴하게 사용할 수 있습니다.예를들어, 학습이 오래 걸릴 경우, 매 에포크마다 저장해놓았다가, 원할 때 다시 로딩해서 사용할 수 있습니다. 마치 긴 문서 작업이나 어드벤처 게임할 때 중간중간 저장하는 것 처럼요. 실제로 모델을 사용할때도 매번 학습해서 사용하는 것이 아니라 한 번 학습한 모델을 추론환경에서 사용하기 때문에 이때도 저장 및 불러오는 기능이 필요하겠죠?하지만 이번에는 과적합이 되기 전의 최적의 모델을 획득하기 위한 목적으로 사용해보겠습니다. 즉 매 에포크마다 검증 손실이 가장 낮은 것이 최적의 모델이라고 가정하고, 학습과정에서는 현재까지 에포크에서 가장 낮은 검증 손실이 확인될 때마다 모델 파일을 갱신합니다. 추론과정에서는 저장된 모델이 가장 낮은 검증손실을 가졌으므로, 이를 불러와서 사용합니다.모델 저장 및 불러오는 코드 예시를 설명하기 위해 파이토치 공식 튜토리얼 중 퀵스타트 코드에 적용해보겠습니다.필요한 패키지 선언파이토치 모델 및 데이터셋을 사용하기 위해 필요한 패키지를 불러옵니다.<code class="language-python">import torch from torch import nn from torch.utils.data import DataLoader from torchvision import datasets from torchvision.transforms import ToTensor</code>데이터셋 정의Fashion MNIST 데이터셋을 사용합니다. 이 데이터셋에 대해서 더 알고 싶으시면, 아래 태스크를 살펴보시기 바랍니다.* [다층 퍼셉트론 신경망 기반 패션아이템 이미지 분류](https://aifactory.space/class/detail/1674)<code class="language-python"># 훈련셋 설정 training_data = datasets.FashionMNIST( root="data", train=True, download=True, transform=ToTensor(), ) # 검증셋 설정 val_data = datasets.FashionMNIST( root="data", train=False, download=True, transform=ToTensor(), ) # 데이터로더 설정 train_dataloader = DataLoader(training_data, batch_size=64) val_dataloader = DataLoader(val_data, batch_size=64)</code>모델 정의nn.Module을 상속받아 간단한 모델을 정의합니다. 이어서 손실함수 및 최적화기도 함께 정의합니다.<code class="language-python"># 아키텍처 정의 class NeuralNetwork(nn.Module): def __init__(self): super(NeuralNetwork, self).__init__() self.flatten = nn.Flatten() self.linear_relu_stack = nn.Sequential( nn.Linear(28*28, 512), nn.ReLU(), nn.Linear(512, 512), nn.ReLU(), nn.Linear(512, 10) ) def forward(self, x): x = self.flatten(x) logits = self.linear_relu_stack(x) return logits # 모델 생성 device = "cuda" if torch.cuda.is_available() else "cpu" print(f"Using {device} device") model = NeuralNetwork().to(device) loss_fn = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr = 0.01)</code>학습 및 검증 함수 정의머신러닝에서는 크게 학습과정과 추론과정으로 나누어집니다. 학습과정은 데이터셋으로 모델의 가중치를 업데이트하는 것이고, 추론과정은 학습 모델을 사용하는 것입니다. 모델 아키텍처 특성에 따라 학습과 추론 시 다르게 동작하는 경우도 있기 때문에 학습 과정에서는 'model.train()'을 추론과정에서는 'model.eval()'을 명시적으로 호출합니다.학습과정에서는 모델의 가중치를 업데이트하기 때문에 손실을 계산하는 부분과 계산된 손실로 역전파하는 코드가 포함되어 있습니다. 반대로 추론 과정에서는 역전파를 하지 않아 그래이디언트를 계산할 필요가 없으므로 torch.no_grad() 함수를 호출합니다.모델 검증 및 과적합을 확인하기 위해서는 매 에포크마다 검증셋으로 모델 평가를 수행합니다. 모델 평가시에는 이미 정답을 알고 있는 데이터로 모델을 추론하여 모델 결과와 정답으로 손실을 계산합니다. 이때 모델 가중치는 업데이트 하지 않습니다.<code class="language-python"># 학습 함수 def train(dataloader, model, loss_fn, optimizer): size = len(dataloader.dataset) model.train() for batch, (X, y) in enumerate(dataloader): X, y = X.to(device), y.to(device) # Compute prediction error pred = model(X) loss = loss_fn(pred, y) # Backpropagation optimizer.zero_grad() loss.backward() optimizer.step() if batch % 100 == 0: loss, current = loss.item(), batch * len(X) print(f"loss: {loss:>7f} [{current:>5d}/{size:>5d}]") # 검증 함수 def val(dataloader, model, loss_fn): size = len(dataloader.dataset) num_batches = len(dataloader) model.eval() val_loss, correct = 0, 0 with torch.no_grad(): for X, y in dataloader: X, y = X.to(device), y.to(device) pred = model(X) val_loss += loss_fn(pred, y).item() correct += (pred.argmax(1) == y).type(torch.float).sum().item() val_loss /= num_batches correct /= size print(f"Val Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {val_loss:>8f} \n") return val_loss </code>학습 및 검증 수행학습 시에 매 에포크마다 검증셋으로 검증손실을 구합니다. 검증손실이 가장 낮을 때마다 "best_model.pth" 이란 이름으로 파이토치 모델을 저장합니다. 같은 파일명으로 덮어쓰기 때문에 이 파일명으로 저장된 모델은 지정된 에포크에서 가장 낮은 검증 손실을 가지고 있습니다.<code class="language-python">epochs = 30 best_val_loss = 999.0 for t in range(epochs): print(f"Epoch {t+1}\n-------------------------------") train(train_dataloader, model, loss_fn, optimizer) curr_val_loss = val(val_dataloader, model, loss_fn) if curr_val_loss < best_val_loss: print(f"The best model is saved. epoch: {t+1} val_loss: {curr_val_loss}\n") torch.save(model.state_dict(), "best_model.pth") best_val_loss = curr_val_loss print("Done!")</code>모델 불러오기model을 선언한 뒤, "best_model.pth" 파일에서 가중치를 가지고 온 뒤 model에 설정합니다.<code class="language-python"># 모델 선언 및 모델 불러오기 model = NeuralNetwork() model.load_state_dict(torch.load("best_model.pth"))</code>추론하기최적의 모델로 임의의 데이터에 대한 추론을 수행합니다.# 불러온 모델으로 추론한다.<code class="language-python">classes = [ "T-shirt/top", "Trouser", "Pullover", "Dress", "Coat", "Sandal", "Shirt", "Sneaker", "Bag", "Ankle boot", ] model.eval() x, y = val_data[0][0], val_data[0][1] with torch.no_grad(): pred = model(x) predicted, actual = classes[pred[0].argmax(0)], classes[y] print(f'Predicted: "{predicted}", Actual: "{actual}"')</code>참고https://pytorch.org/tutorials/beginner/basics/quickstart_tutorial.html
torch_geometric 사용자를 위한 Data 생성 코드 snippet입니다!
<code class="language-python">import os import torch from torch_geometric.data import Data import pathlib # ============= Training Data ============== # data = torch.load("qm9_train_data.pt") # training data 불러오기 y = data['mu'] # target 값: dipole moment value num_nodes = data['num_atoms'] # 분자 내 원자 수(==그래프의 노드 갯수) num_edges = data['num_bonds'] # 분자 내 결합 수(==그래프의 엣지 갯수) coords = data['x'] # 각 원자의 3d 좌표 값 atomic_numbers = data['atomic_numbers'] # 각 원자의 원자번호 edge = data['edge'] # 엣지 인덱스와 결합 종류 pathlib.Path('processed_train').mkdir(parents=True, exist_ok=True) for i in range(len(y)): y_s = torch.tensor(y[i], dtype=torch.float) num_node_s = num_nodes[i] num_edge_s = num_edges[i] coord = torch.tensor(coords[i][:num_node_s]) atomic_num = torch.tensor(atomic_numbers[i][:num_node_s, :], dtype=torch.long) edge_index = torch.tensor(edge[i][:num_edge_s, :2], dtype=torch.long).t() edge_attr = torch.tensor(edge[i][:num_edge_s, 2], dtype=torch.long).unsqueeze(1) sample = Data(pos=coord, z=atomic_num, y=y_s, edge_index=edge_index, edge_attr=edge_attr) torch.save(sample, f'processed_train/data_{i}_train.pt') # ============= Test Data ============== # data_test = torch.load("qm9_test_data.pt") # test data 불러오기 num_nodes = data_test['num_atoms'] num_edges = data_test['num_bonds'] coords = data_test['x'] atomic_numbers = data_test['atomic_numbers'] edge_test = data_test['edge'] pathlib.Path('processed_test').mkdir(parents=True, exist_ok=True) for i in range(len(num_nodes)): num_node_s = num_nodes[i] num_edge_s = num_edges[i] coord = torch.tensor(coords[i][:num_node_s]) edge_index = torch.tensor(edge_test[i][:num_edge_s, :2], dtype=torch.long).t() edge_attr = torch.tensor(edge_test[i][:num_edge_s, 2], dtype=torch.long).unsqueeze(1) atomic_num = torch.tensor(atomic_numbers[i][:num_node_s, :], dtype=torch.long) sample = Data(pos=coord, z=atomic_num, edge_index=edge_index, edge_attr=edge_attr) torch.save(sample, f'processed_test/data_{i}_test.pt') </code>torch_geometric 라이브러리를 활용하여 학습 및 예측을 진행하고자 하시는 분들을 위해서, 각각의 분자구조를 서로 다른 파일로 저장할 수 있도록 코드를 작성해보았습니다. 궁금하신 사항은 댓글로 달아주시면 제가 아는 선에서 최대한 답변드리도록 노력하겠습니다. 감사합니다.