Hello!

면접후기

2021-12-28T00:00:00+00:00

1. 면접 후기

21년 12월 24일, 크리스마스 이브에 면접을 봤습니다. AI-Robotics 관련 회사에 인공지능 연구개발 직무로 지원해서 면접을 보게 됐습니다.

전반적으로 포트폴리오를 바탕으로 간단하게 발표 및 질의응답으로 시작했습니다. 후에는 기술적인 질문들 위주로 진행됐습니다. 인공지능 전반에 걸쳐 다양한 개념들에 대해 질문을 받고 대답 여부에 따라 깊이있게 질문이 이어졌습니다.

예를 들어, Batch Normalization의 개념부터 시작해서 왜 잘 되는 지, 어떤 분석을 할 수 있는지에 대한 질문으로 이어졌습니다.

저는 인공지능 연구개발 직무로 지원을 했기 때문에 모든 분야에 대해 넓게 아는 것보다는 한 개념에 대해서 얼마나 고민을 해봤고 나름의 생각을 하고 결론을 내봤는 지에 대해 많이 여쭤보셨습니다.

평소에도 수학과로서 제가 가져야되는 태도와 강점은 “왜?” 에 대한 질문을 끝없이 하고 나름의 정리를 해야된다고 생각했습니다. 이번 면접을 통해 이 생각은 더욱 확고해진 것 같습니다.

면접은 딱딱하지 않고 편한 분위기에서 진행됐지만, 교육과정이 끝나고 지나치게 해이해진 상태라 준비가 지나치게 부족해 좋은 모습을 보이지는 못했습니다.

2. 어떻게 고쳐나갈 것인가

‘어 이게 뭐였더라?’ 라는 생각이 들면 바로 구글링을 해보고 ‘아 맞다. 이거였지.’ 하고 알게 됐다고 착각하는 경우가 많습니다. 머리 속 어딘가에 숨어있는 지식을 스스로 꺼내기 보다는 구글의 힘을 빌려 간단하게 해결할 수 있습니다.

비약이 있긴 하지만 일종의 ‘디지털 치매’와 비슷한 점이 있다는 생각이 들었습니다. 면접장에서는 알고 있던 개념에 대해서도 전혀 다른 방향으로 설명을 하게 되는 일이 종종 있었던 것 같습니다.

‘어떻게 공부할 것인가’ 라는 책을 읽어본 적이 있습니다. 책의 내용은 내가 배운 것을 다양한 방식으로 꺼내봐야 잘 알게된다는 내용이였습니다.

‘아 이 정도면 아는거지, 생각 안나면 구글링 하면 돼.’ 라고 생각하며 자주 꺼내보지 않았던 습관이 문제가 됐었습니다. 네비게이션이 없어도, 핸드폰이 없어도 자주 가본 길을 까먹지 않듯이, 꾸준히 계속 공부를 해야한다는 것을 또 깨닫게 됐습니다.

저는 면접을 그다지 어려운 과정이라고 생각하지 않았었습니다. 평소에 꾸준히 잘 해왔다면 딱히 준비 할 필요가 없다고 생각했기 때문입니다. 따라서 이번 면접 경험을 통해 얻은 깨달음을 바탕으로 그런 태도를 평소에도 항상 가질 수 있도록 노력해야겠습니다.

3. 마치며

CV, 포트폴리오, 자기소개서는 설득하는 글입니다. 고용주 입장에서 나를 한번 만나보고 싶게끔 잘 어필해야합니다.

설득에 성공해서 면접의 기회를 얻게 되면 제가 한 말이 진짜인지에 대해서 설명을 하는 단계로 넘어갑니다. 이제는 내가 알고 있다는 것을 효과적으로 잘 설명해야 합니다.

지원한 직무가 어떤 직무이고, 이 직무를 맡을 사람에게는 어떤 모습을 기대하는 지 이해하는 것도 정말 중요합니다. 연구 분야, 개발 분야 등 지원한 직무에 따라 어떤 모습을 보이는 게 좋은지를 염두에 두고 평소에도 그런 태도로 임하는 게 중요하다는 생각이 들었습니다.

저는 크게 긴장을 하지 않는 성격이지만 긴장이 많이 된다면 면접 또한 하나의 좋은 기회고 많은 것을 배워갈 수 있는 과정, 특히 앞으로 이 직무를 맡으려면 어떤 태도를 갖춰야 하는 지에 대해서 알 수 있다고 생각하면 조금 마음이 놓이지 않을까 하는 생각이 듭니다.

면접에 대한 좋은 글과 팁은 정말 많으니, 이 글에서는 기본적이지만 가장 중요한 점, 성실하게 공부를 해야한다는 점만 강조하면서 마치겠습니다.

포트폴리오 속 프로젝트 정리/후기

2021-12-28T00:00:00+00:00

20대는 왜 백신을 맞아야할까?

아이펠에서 진행한 미니 해커톤으로 코로나 데이터셋에 관해 분석을 하고 나름의 가설을 내리고 결론을 찾아보는 과정이였습니다.

주제 자체도 재밌었고 한창 시각화에 흥미를 느끼고 있던 시기라 정말 재밌게 진행했던 미니 해커톤이였습니다.

코로나 초창기 데이터라특수한 경우인 ‘신천지 감염 사례’가 대부분을 차지하고 있었습니다. 따라서 현재에 바로 적용시킬 수 있는 데에는 무락 해석하기는 어렵지만 비슷한 패턴을 보일 것이라고 판단했습니다.

데이터를 우선적으로 살펴보며 궁금했던 것들을 생각해보고 이에 대한 해답을 각각 데이터를 통해 찾아내려고 많은 노력을 기울였습니다.

최종적으로 선택한 목표는 20-30대가 백신을 맞아야하는 이유에 대해서 데이터를 통해 파악해보는 것으로 정했습니다. 따라서 여러 방면에서 파악한 결과 접촉자 수는 월등히 많고 치명율은 현저히 낮기 때문에 오히려 전파를 많이 시키고 다닐 수 있겠다는 생각을 하게 됐습니다.

Pandas, Seaborn, Matplotlib등을 사용해 시각화를 진행했습니다.

상세한 내용은 노트북에 나름 잘 정리가 되어있는 것 같아 노트북 링크를 함께 올려두겠습니다.

링크

수원시 치안 빅데이터 시각화 및 아이디어 공모전

COMPAS에서 진행한 공모전이였습니다. 팀은 캐글코리아 카톡방에 공고가 올라와서 참여하게 됐습니다.

결과적으로는 예선탈락을 한 만큼 아쉬움이 많이 남습니다. 한가지 명확한 문제점을 파악하고 해결하지 못하고 너무 두루뭉술하게 진행한 게 원인이라고 생각을 합니다.

저희 팀이 주제로 선택한 건 시각화를 통해 문제를 파악하고, 일종의 안전지수를 도출한 뒤에 맞춤형 치안 대상지를 선정하는 것이였습니다.

수원시가 인구수 대비 신고수, 파출소 대비 신고수, 경찰관 1인당 담당 인구수가 가장 많은 지역임을 데이터와 기사등을 통해 파악했고 이를 토대로 적재적소에 맞춤형 치안을 제공하자는 의도였습니다.

EDA를 하는 과정과 시각화를 하는 과정은 재밌었지만 시작부터 명확한 플랜없이 진행한 점, 결국엔 Tableau를 통해 결과를 내야한다는 점을 파악했음에도 잊고 있었던 점이 겹쳐져서 아쉬운 결과를 냈습니다.

상당히 조악하지만 나름 인터랙티브하게 시각화를 진행해보기도 했습니다.

DACON 주식 종료가격 예측대회

위 공모전이 인연이 되어 진행하게 된 프로젝트였습니다. KOSPI-200, KOSDAQ-150의 종목의 5일 간의 종가를 예측하는 것이 목표였습니다. 실제 주식 예측에 사용되는 다양한 기술적 지표를 feature로 사용해봤고 모델 또한 선형회귀부터 시작해서 XGBOOST, LightGBM등 다양한 시도를 했습니다.

프로젝트에서는 feature에 대한 아이디어를 내거나 XGBOOST를 Optuna를 통해 tuning하는 역할을 주로 맡아서 진행했습니다. 여러 테스트를 진행해보니 feature는 종가만 모델은 선형회귀를 사용하는 것이 가장 좋았습니다.

그래도 Public 스코어 기준으로 만족할만한 성능이 나오지 않아 일종의 시나리오 개념으로 USD/JPY값이 일정 수준이 넘으면 2%를 전반적으로 떨어뜨리는 아이디어를 도입하게 됐습니다.

운이 좋게도 오미크론 쇼크와 더불어 아이디어가 잘 맞아들어가서 좋은 성능이 나왔고, private 스코어1위 그리고 대상을 받게 됐습니다.

기억에 남는 것은 전반적으로 다른 상위권에 위치한 팀들도 public에서는 좋은 성적이 나오지 않았지만 private에서는 상위권에 든 팀들이 있었습니다. 실제 주가 예측에 있을 수 있는 다양한 변수들 때문에 그런 결과가 나온 것이 아닐까하고 생각을 하고 있습니다.

프로젝트를 진행하면서 스태킹등의 기법을 많이 사용하지 않은 것이 public 기준으로는 성능이 크게 개선되지 않았는데 이 점이 조금 아쉽습니다. 주가 예측은 알고리즘적인 접근만을 하는 것보다는 시나리오, 전략등을 생각하고 rule-based도 더해지는 것이 좋겠다라는 생각도 들었습니다.

SOCAR X AIFFEL 날씨데이터를 이용한 지역별 수요특성 분석 및 예측

쏘카와 함께 진행한 최종 해커톤입니다. 처음 데이터를 살펴보며 전개해봤던 주제는 전기차 문제, 탈퇴 이용자 문제, 유휴율 문제등이 있었습니다. 하지만

전기차의 경우에는 차종을 명확하게 알 수 없다는 문제가 있어서 진행하지 못했습니다. 추후에 문제정의를 전기차의 실제적인 수요를 보기보다는 이용에 관련된 다른 feature들을 살펴보며 잠재수요를 파악해보려 시도했지만 이 또한 쉽지 않아 다른 주제를 선택하게 됐습니다.
탈퇴 이용자는 일반 이용자보다 이용시간이 짧을까, 길까 어느 지역에 많을까에 대한 분석을 진행하고 이 문제를 어떻게 해결할 수 있을까에 대해서 생각해봤습니다. 하지만 탈퇴 이용자가 전체 데이터에서 차지하는 부분이 현저하게 적어 패턴을 파악하기 힘들어 제외하게 됐습니다.
쏘카와의 피드백 이후, 차량이 쏘카존에서 놀지 않도록 가동률을 높이고, 유휴율을 낮추는 방법을 찾아보려고 노력했습니다. 실제로 데이터에는 해당 쏘카존에 차량이 몇대 있는 지 명확히 알 수 없어서, 로그 데이터를 통해 해당 지역에 이용횟수의 최대값을 차량대수라고 생각해도 되지 않을까? 라는 생각이 들었습니다. 하지만 당연하게도 한 차량이 100번 나가는 것과 100대의 차량이 1번씩 나가는 경우가 같게 체크가 되기 때문에 사용할 수 없었습니다. 단순히 이용량 만으로는 유휴율, 가동율에 대한 이야기를 진행하기 어려움이 있다고 판단해 다른 주제를 선택하게 됐습니다.

따라서 쏘카와의 피드백 과정에서 날씨 정보를 현재는 현황을 파악하는 위주로 많이 사용하고 있지만 이를 통해 예측에는 아직 사용하는 방법에 대해 모호하다는 의견을 받게 됐고, 날씨 오픈데이터를 통해 수요 예측을 하는 방향으로 목표를 정하게 됐습니다.

Metric은 SMAPE를 사용했고, 매출에 직결되는 지역별, 일별 이용시간을 target으로 삼았습니다.

모델링은 주가 예측을 했던 경험을 살려 비슷하게 선형회귀, XGBOOST등을 비롯한 다양한 시도를 했습니다.

눈에 띄게 좋은 성능을 내지는 못해 아쉬웠지만 날씨 데이터를 어떻게 사용할 수 있을 지에 대한 아이디어를 여러 방면으로 생각할 수 있었습니다.

마지막 해커톤 프로젝트 관련해서는 별도로 따로 글을 한번 작성해 볼 예정입니다.

AIFFEL 오리엔테이션 후기

2021-06-25T00:00:00+00:00

AIFFEL 1~2일차 오리엔테이션 후기

이틀에 걸쳐 AIFFEL 오리엔테이션이 있었다. 바로 수업을 진행하지는 않고, 아이펠이 어떤 과정인지 무엇을 지향하는 지 어떤 태도로 임하는 것이 좋은 지에 대한 이야기를 들을 수 있었다.

아이펠하면 플립러닝이 가장 먼저 떠오르는데, 그에 맞게 다양한 학생들의 얘기를 들어볼 수 있는 것도 좋았다. 오늘은 AI에 대한 생각을 얘기하는 시간도 가지게 됐는데 우리 조에서는 ‘her’에 대한 얘기가 나왔다. 영화를 봤을 때 느낌을 되살리며 얘기를 했는데 너무 좋은 시간이였다. 다시 한번 her를 보면 또 생각이 많이 달라져있겠지.

새로운 사람들을 만났을 때는 아무래도 이야기를 시작하는 것이 가장 어렵다. 그 어려움을 아이펠에서 준비한 아이스 브레이킹으로 비교적 수월하게 이겨냈지않나 싶다. 일정의 타이트함이 있어서 어쩔 수 없었지만 조금 더 이야기를 할 수 있는 시간이 길어도 좋지 않았을까 하는 생각이 조금 들긴 했다.

아이펠을 시작하며 같이 공부를 할 많은 사람들을 만나고 싶었는데, 아이펠을 그럴 수 있는 좋은 시스템을 갖추고 있었다. 무엇보다 게더타운이라는 플랫폼이 아주 매력적이고 신기하게 느껴졌다. 다른 사람들은 뭘하고 있는 지를 보면 공부가 힘들 때 좋은 동기부여가 될 수 있을 거라고 생각했다. 그래서 스터디윗미를 켜놓고 공부를 해보려고 한 적도 있었는데 그닥 성과는 없었고 앞으로는 게더타운을 이용해봐야겠다.

문득 생각해보니 고등학교 때 이후로 하루에 8시간 정도 수업을 들으며 공부를 해본 적이 없다. 대학교 때도 수업을 듣는 건 많아도 5시간 내외였는데, 어쨌든 하루에 8시간 가까이는 공부를 할 수 있으니 오히려 좋아…

아무튼 매번 느끼지만 열심히 해야겠다는 생각이 다시금 들기는 했다.

Kaggle-Zillow EDA

2021-05-01T00:00:00+00:00

Kaggle - EDA(Zillow-practice)

Can you improve the algorithm that changed the world of real estate?

두번째 EDA 실습, 공부로 부족했던 제 첫 EDA에 대한 리뷰를 겸해 Zillow Prize에 대한 필사를 해보겠습니다. 저번 실습에서 많은 부분에 부족함을 느꼈기 때문에 이번 리뷰를 철저히 하기 위해서 Zillow Prize에 대회 설명부터 하나씩 차근차근 진행하겠습니다.

“Zestimates” are estimated home values based on 7.5 million statistical and machine learning models that analyze hundreds of data points on each property. And, by continually improving the median margin of error (from 14% at the onset to 5% today), Zillow has since become established as one of the largest, most trusted marketplaces for real estate information in the U.S. and a leading example of impactful machine learning.

“Zestimates” (Zillow에서 제공하는 부동산정보) 약 750만개의 통계와 각 재산에 대한 수백개의 데이터 포인트들을 분석한 머신러닝 모델을 토대로 부동산의 가치를 매깁니다. 오차의 중위수(median)를 14%에서 5%까지 계속 증가시키면서 Zillow는 부동산 정보를 제공하는 가장 크고 믿음직한 시장 중 하나로 자리매김 했고, 또한 머신러닝의 영향력을 보여주는 좋은 예시가 되고 있습니다.

머신러닝에 대한 세미나나 이런 저런 강의를 듣다보면 부동산 가격 예측을 포함해서 부동산에 관한 얘기를 정말 많이 들을 수 있었는데 Zillow 문제는 그 대표적인 예시입니다. 부동산 시장은 큰 만큼 큰 돈이 움직이는 시장이다 보니 데이터에 대해서 사람들이 더 확신을 얻고 싶어하고 그 방법으로 머신러닝, 데이터과학을 이용한 점이 당연하게 느껴지면서도 머신러닝의 영향력이 어느수준인가에 대해 알 수 있습니다.

이번 리뷰에서는 직접 EDA는 진행하지 않고, 많은 vote를 받은 “SRK” 라는 유저의 노트북을 보고 EDA 필사에 초점을 두겠습니다.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
color = sns.color_palette()

%matplotlib inline

pd.options.mode.chained_assignment = None
pd.options.display.max_columns = 999

우선 모듈들을 import하는 코드입니다.

기본적으로 numpy, pandas, matplotlib, seaborn을 사용한다는 점을 알 수 있었고,
color = sns.color_palette()를 통해 사용할 색상을 미리 정해놓는다는 점을 알 수 있었습니다.
IPython에서 제공하는 Rich output를 표현하기 위해 %matplotlib을 사용했습니다.
pd.options.mode.chained_assignment = None을 통해 추후에 생길수도 있는 chained indexing 이슈에 대해 경고문구를 아얘 띄우지않게 처리했습니다. 지난 EDA 과제를 할 때 문제를 겪었던 부분이기도 해 https://stackoverflow.com/questions/20625582/how-to-deal-with-settingwithcopywarning-in-pandas 를 참고해 따로 정리해봐야겠습니다.

from subprocess import check_output
print(check_output["ls", "../input"]).decode("utf-8")

항상 간과하고 넘어가거나 직접 폴더안에 어떤 파일이 있는 지를 살펴보기만 하고 명시해주지 않았는데, 이런식으로 명시를 해줘야겠습니다.

파이썬의 모듈 subprocess의 check_output을 사용했습니다. "ls" 방법을 이용해 ".../input" 을 출력했습니다. 사실 subprocess는 현재 소스코드안에서 다른 프로세스 실행을 가능하게 해주고, 그 과정에서 입출력을 제어하기 위함으로 결과값을 다른 변수에 저장할 수 있다는 장점이 있습니다. 여기서는 단순히 출력을 편리하게 하기 위해 사용한 것 같지만, 나중에 관련해서 더 찾아봐야겠습니다.

train_df = pd.read_csv("../input/train_2016.csv", parse_dates=["transactiondate"])
train_df.shape

train data가 어떻게 생겼는지 살펴보기 위해 csv 파일을 읽었습니다.
거래일, transactiondate가 있는 컬럼을 parse_dates를 통해 datetime type으로 형변환 했습니다.

train_df.head()

를 통해 데이터가 어떻게 생겼는지도 살펴봅니다.

이 대회에서는 logerror를 줄이는 것이 목표입니다. 따라서 logerror와 관련된 분석을 시작하겠습니다.

plt.figure(figsize=(8,6))
plt.scatter(range(train_df.shape[0]), np.sort(train_df.logerror.values))
plt.xlabel('index', fontsize=12)
plt.ylabel('logerror', fontsize=12)

plt.show()

간단하게 logerror가 어떻게 되는 지 scatter plot을 이용해 보여주고 있습니다.

np.sort를 이용해 작은값부터 큰 값으로 정렬했습니다.
각 행마다 logerror 값을 가져오기 위해 pandas에서 제공하는 .values를 사용했습니다. pandas 공식 문서에서는 .values보다는 .to_numpy를 사용하기를 추천합니다. .values를 사용하는 경우에는 실제로 반환되는 값이 배열(array)인지, 배열의 어떤 변환인지, pandas의 custom 배열인 지 알 수 없다고 합니다. 더 좋은 일관성(consistency) 유지를 위해 .to_numpy()의 사용을 하는 것이 좋습니다.

전반적으로 0에 가깝지만 가장 가장 작은값, 가장 큰 값들에 이상치(outlier)들이 많은 걸 알 수 있습니다.

이 이상치들을 지우고 히스토그램을 그려보겠습니다.

ulimit = np.percentile(train_df.logerror.values, 99)
llimit = np.percentile(train_df.logerror.values, 1)

train_df['logerror'].loc[train_df['logerror']>ulimit] = ulimit
train_df['logerror'].loc[train_df['logerror']<llimit] = llimit

plt.figure(figsize=(12,8))
sns.distplot(train_df.logerror.values, bins=50, kde=False)
plt.xlabel('logerror', fontsize=12)
plt.show()

np.percentile을 이용해 가장 큰 99%, 가장 작은 1% 로 ulimit, llimit을 설정하고 ulimit보다 크면 ulimit으로 llimit보다 작으면 llimit으로 값을 대체했습니다. 이 과정에서 .ix 명령어가 사라져 .loc로 코드를 작성했습니다. 이 과정에서도 copyWarning이 발생하지만 무시하기로 했으므로 그냥 넘어갑니다.
결과가 정규분포에 가까운 모습으로 나오는 것을 볼 수 있습니다.

이제 거래일, transactiondate에 대해 분석해보겠습니다. 우선 매달마다 거래량이 어떻게 변하는 지 알아보겠습니다.

train_df['transaction_month'] = train_df['transactiondate'].dt.month

cnt_srs = train_df['transaction_month'].value_counts()
plt.figure(figsize=(12, 6))
sns.barplot(cnt_srs.index, cnt_srs.values, alpha=0.8, color=color[3])
plt.xticks(rotation='vertical')
plt.xlabel('Month of transaction', fontsize=12)
plt.ylabel('Number of Occurences', fontsize=12)
plt.show()

우선 'transactiondate' 컬럼에서 dt.month 함수를 통해 무슨 달인지에 대한 정보를 가져옵니다. dt.month는 달의 정보를 1, 2, 3, … 12 와 같은 형식으로 가져옵니다.
각 달이 나온 횟수를 뽑아내 cnt_srs에 저장합니다.

캐글의 데이터 페이지를 살펴보면 train data가 2016년 10월 15일 이전의 모든 거래내역과, 그 이후의 약간의 거래내역으로 구성되어있다고 하는 것을 보면 왜 10월에서 12월까지가 비교적 적은 거래량을 보이는 지 알 수 있습니다.

캐글의 데이터에 대한 설명을 상세히 읽어 ‘아 연말에는 부동산 거래를 잘 하지 않는구나.’ 와 같은 이상한 인사이트를 얻는 일이 없도록 해야합니다.

이제 Parcel Id, 땅에 매기는 구획번호에 대해 알아보겠습니다. 땅에 매기는 구획번호는 특정 관할권안에서 고유하다고 합니다. 그런지 한번 살펴보겠습니다.

(train_df['parcelid'].value_counts().reset_index())['parcelid'].value_counts()

복잡해보이기만 하는 위 코드는 몇개의 단계로 나눠서 쓸 수 있습니다.

train_df['parcelid'].value_counts(): 앞에서 본 것 처럼 고유한 값들을 세줍니다.
.reset_index(): index번호를 다시 붙여줍니다.
['parcelid'].value_counts(): 2를 대상으로 다시 value_counts()를 통해 parcelid 값을 고유한대로 세줍니다.

위 코드의 결과로, 1: 9006, 2: 123, 3: 1을 얻을 수 있습니다. 기록상의 오류인지는 조금 더 상세히 찾아봐야 알 수 있을 것 같습니다.

이제 properties_2016 파일을 뜯어보겠습니다.

prop_df = pd.read_csv('/content/properties_2016.csv.zip')
prop_df.shape
prop_df.head()

shape를 확인하고 head()로 데이터를 살짝 봤더니 NaN값이 너무 많습니다. 각 부동산 당 가지고 있는 자산이 다 달라 NaN이 많은가 싶네요.

일단 NaN값이 얼마나, 어디에, 어떻게 많은 지 살펴보겠습니다.

missing_df = prop_df.isnull().sum(axis=0).reset_index()
missing_df.columns = ['column_name', 'missing_count']
missing_df = missing_df.loc[missing_df['missing_count']>0]
missing_df = missing_df.sort_values(by='missing_count')

idx = np.arange(missing_df.shape[0])
width = 0.9
fig, ax = plt.subplots(figsize=(12, 18))
rects = ax.barh(idx, missing_df.missing_count.values, color='blue')
ax.set_yticks(idx)
ax.set_yticklabels(missing_df.column_name.values, rotation='horizontal')
ax.set_xlabel("Count of missing values")
ax.set_title("Number of missing values in each column")
plt.show()

코드부터 하나하나 살펴보겠습니다.

missing_df = prob_df.isnull().sum(axis=0).reset_index(): prob_df에서 결측값, missing values를 찾기위해 .isnull() 을 했습니다. 그 뒤에 (axis=0)으로, 즉 내려가면서 합을 구합니다. 이 때 True는 1 False는 0 이 됩니다. 그 뒤 reset_index()를 통해 index를 다시 붙여줍니다. (axis=0)은 가로축을 의미합니다. 가로축 방향으로 길게 뻗은 막대기가 아래로 내려간다고 생각하면 어떤 방향 연산인지 떠올리기가 쉽습니다.
missing_df.columns = ['column_name', 'missing_count']을 통해 column의 이름을 붙여줍니다.
missing_df = missing_df.loc[missing_df['missing_count']>0]: missing_count가 0보다 큰 데이터프레임을 뽑아서 새로 데이터프레임을 지정해줍니다.
missing_df = missing_df.sort_values(by='missing_count'): missing_count를 기준으로 정렬해줍니다.
그래프는 missing_df의 길이만큼 인덱스를 만들어주고, missing_df의 missing_count.values 들을 하나씩 세우는 막대그래프를 그렸습니다.

이제 부동산 데이터가 어떤 위치에 많이 놓여있는 지에 대해 알아보기 위해 (위도, 경도)를 시각화해보겠습니다.

plt.figure(figsize=(12, 12))
sns.jointplot(x=prop_df.latitude.values, y=prop_df.longitude.values, height=10)
plt.ylabel('Longitude', fontsize=12)
plt.xlabel('Latitude', fontsize=12)
plt.show()

다른 특별한 건 없고 Seaborn의 jointplot은 두 변수에 대해 이변량, 일변량 그래프를 그리는 함수입니다.

따라서 위도, 경도에 따라 어디에 분포되어있는지 이변량 함수가 가운데에 그려져 있고, 각각의 분포는 어떠한가에 대해 x축, y축의 끝에 그려져있습니다.

Kaggle 대회 내의 data 페이지를 살펴보면 이 데이터는 Los Angeles, Orange and Ventura, California 세 구역에 대한 2016년 전체 부동산 데이터를 가지고 있습니다.

train 데이터에는 90275개의 행이 있고 properties 파일에는 2,985,217 개의 행이 있습니다. 이제 이 두 파일을 합쳐서 분석을 해보겠습니다.

train_df = pd.merge(train_df, prop_df, on='parcelid', how='left')
train_df.head()

코드를 보게 되면, train_df의 왼쪽에 prop_df를 parcelid를 기준으로 합치고 있는 것을 볼 수 있습니다.

분석의 편의를 위해 각 변수의 자료형에 대해 살펴보겠습니다.

대부분의 변수는 실수형(float)이며, object 변수는 거의 없습니다. 자세히 갯수를 세보겠습니다.

dtype_df.groupby("Column Type").aggregate('count').reset_index()

groupby 함수는 mapper나 Series of columns를 이용해 데이터프레임을 묶어주는 역할을 합니다. 즉 groupby() 안의 parameter를 기준으로 묶는 것으로, 그 parameter가 일종의 새로운 index, 행으로 옮겨간다고 생각할 수 있습니다.
aggregate는 한개 이상의 operation을 특정 축에 시행하는 함수입니다.

이제 합쳐진 새로운 데이터에서 결측치, Null의 갯수를 세보겠습니다.

missing_df = train_df.isnull().sum(axis=0).reset_index()
missing_df.columns = ['column_name', 'missing_count']
missing_df['missing_ratio'] = missing_df['missing_count'] / train_df.shape[0]
missing_df.loc[missing_df['missing_ratio']>0.999]

위에서 결측치를 체크했을 때와 똑같은 방식의 코드입니다. 다만 마지막에 missing_ratio가 99.9%가 넘는 데이터를 뽑아내는 코드를 추가했습니다.

변수가 너무 많기 때문에, 실수형, float 변수만 살펴보면서 목표로 하는 target variable과 어떤 관련이 있나 살펴보겠습니다.

mean_values = train_df.mean(axis=0)
train_df_new = train_df.fillna(mean_values)

x_cols = [col for col in train_df_new.columns if col not in ['logerror'] if train_df_new[col].dtype=='float64']
labels = []
values = []
for col in x_cols:
    labels.append(col)
    values.append(np.corrcoef(train_df_new[col].values, train_df_new.logerror.values)[0,1])
corr_df = pd.DataFrame({'col_labels':labels, 'corr_values':values})
corr_df = corr_df.sort_values(by='corr_values')

idx = np.arange(len(labels))
width = 0.9
fig, ax = plt.subplots(figsize=(12,40))
rects = ax.barh(idx, np.array(corr_df.corr_values.values), color='y')
ax.set_yticks(idx)
ax.set_yticklabels(corr_df.col_labels.values, rotation='horizontal')
ax.set_xlabel('Correlation coefficient')
ax.set_title('Correlation coefficient of the variables')

plt.show()

상관관계를 알아보기 위해 우선 결측치를 모두 평균값으로 채운 새로운 데이터프레임을 생성했습니다.
그리고 list comprehension을 통해 train_df_new의 column들 중에 ['logerror']를 제외하고 모든 실수형의 column을 가져왔습니다. if문 2개로 작성한 구문을 and로 바꿔주는 편이 좋아보입니다.
x_cols를 반복하면서, col은 labels에 np.corrcoef(~)는 values에 추가했습니다. np.corrcoef는 Pearson 상관계수를 반환하는 함수로, covariance matrix의 normalized 된 모습으로 볼 수 있습니다. 식은 아래와 같습니다.

\[R_{ij} = \frac{C_{ij}}{\sqrt{C_{ii}C_{jj}}}\]

Person 상관계수는 $[-1, 1]$에 놓입니다. 절댓값이 클수록 상관관계가 크며, 부호는 그 방향성을 나타냅니다. 따라서 -1에 가까울수록 음의 상관관계가 크고, 1에 가까울수록 양의 상관관계가 큽니다.

위 그래프를 통해보면 대부분 상관관계가 전반적으로 매우 맞다는 것을 볼 수 있습니다. 가장 위에는 상관계수가 0인 변수들도 있는데, 아마 유일한 값을 가져 그럴 것이라 추정하고 그 추정이 맞는 지 확인해보겠습니다.

corr_zero_cols = ['assessmentyear', 'storytypeid', 'pooltypeid2', 'pooltypeid7', 'pooltypeid10', 'poolcnt', 'decktypeid', 'buildingclasstypeid']
for col in corr_zero_cols:
    print(col, len(train_df_new[col].unique()))

assessmentyear 1

storytypeid 1

pooltypeid2 1

pooltypeid7 1

pooltypeid10 1

poolcnt 1

decktypeid 1

buildingclasstypeid 1

확인결과 전부 하나의 값을 가지는 것을 확인할 수 있었습니다.

이번엔 상관관계가 높은 변수를 대상으로 분석을 해보겠습니다.

corr_df_sel = corr_df.loc[(corr_df['corr_values']>0.02) | (corr_df['corr_values'] < -0.01)]
corr_df_sel

cols_to_use = corr_df_sel.col_labels.tolist()

temp_df = train_df[cols_to_use]
corrmat = temp_df.corr(method='spearman')
f, ax = plt.subplots(figsize=(8,8))

sns.heatmap(corrmat, vmax=1., square=True)
plt.title("Importatn variables correlation map", fontsize=15)
plt.show()

corr_df_sel ~ temp_df: 상관관계가 높은 변수들을 데이터프레임으로 만들고, 그 컬럼들을 가져와 원래 데이터에서 사용하겠습니다.
temp_df.corr(method='spearman'): 상관관계를 스피어먼 상관 계수, Spearman rank correlation coefficient를 이용해 구하곘습니다. 스피어먼 계수란 두 변수간의 랭크가 얼마나 상관있는지 보는 계수입니다. 두 변수가 얼마나 단조함수, monotonic function으로 나타낼 수 있는 지 체크할 수 있습니다. 그에 따라 부호는 방향을 의미하고, 일반적으로 커질수록 두 변수가 단조함수로 잘 표현된다고 생각할 수 있습니다.
이를 heatmap을 이용하여 그래프를 그렸습니다.

스피어먼 상관계수 정의에 따르면 대각선 방향의 값들이 모두 1인 걸 알 수 있습니다. 이제 각각의 변수들을 한번 살펴보겠습니다.(그런 의미 아닐까?)

일반적으로 다른 변수들과 큰 상관관계를 가지는 finished square feet 12가 log error에 따라 어떻게 변하는 지 알아보겠습니다. finished square footage에 포함이 되는 공간은 벽, 바닥, 천장, 열원(가스레인지) 등으로 일반적으로 도면에서의 넓이라고 볼 수 있을 것 같습니다.

col = "finishedsquarefeet12"
ulimit = np.percentile(train_df[col].values, 99.5)
llimit = np.percentile(train_df[col].values, 0.5)
train_df[col].loc[train_df[col]>ulimit] = ulimit
train_df[col].loc[train_df[col]<llimit] = llimit

plt.figure(figsize=(12,12))
sns.jointplot(x=train_df.finishedsquarefeet12.values, y=train_df.logerror.values, height=10,
              color=color[4])
plt.ylabel('Log error', fontsize=12)
plt.xlabel('Finished Square Feet 12', fontsize=12)
plt.title('Finsished square feet 12 vs Log error', fontsize=12)
plt.show()

np.percentile을 이용해 데이터를 수정해주고 finshedsquarefeet12.values를 x축으로 logerror.values를 y축으로 하는 jointplot을 그렸습니다.

이상치가 존재하는 것을 제외하면 logerror의 분포가 finished square feet 12 변수가 커질수록 좁아지고 있습니다. 어쩌면 큰 집들이 조금 더 추정하기 쉽다는 것을 말하는 것인지 알아보겠습니다.

calculated finished square feet에 대해서도 위와 같이 분석을 해보겠습니다.

col = "calculatedfinishedsquarefeet"
ulimit = np.percentile(train_df[col].values, 99.5)
llimit = np.percentile(train_df[col].values, 0.5)
train_df[col].loc[train_df[col]>ulimit] = ulimit
train_df[col].loc[train_df[col]<llimit] = llimit

plt.figure(figsize=(12,12))
sns.jointplot(x=train_df.calculatedfinishedsquarefeet.values, y=train_df.logerror.values, height=10,
              color=color[5])
plt.ylabel('Log error', fontsize=12)
plt.xlabel('Calculated finished square feet', fontsize=12)
plt.title('Calculated finished square feet vs Log error', fontsize=12)
plt.show()

둘은 거의 비슷한 그래프를 보이며, 이는 둘의 상관계수가 매우 높다는 점과도 일맥상통 하는 이야기 입니다.

이번엔 욕실의 수를 간단하게 알아보겠습니다.

plt.figure(figsize=(12, 8))
sns.countplot(x='bathroomcnt', data=train_df)
plt.ylabel('Count', fontsize=12)
plt.xlabel('Bathroom', fontsize=12)
plt.xticks(rotation='vertical')
plt.title("Frequency of Bathroom count", fontsize=15)
plt.show()

필사를 하는 원본에는 2.279… 로 나타나는 숫자가 있는데 평균값이라고 합니다. 어쨌든 이 그래프에서도 0.5 단위로 표가 나오는데 2.5개의 욕실을 의미하는 것인지, 평균인지는 따로 살펴봐야겠습니다.

log error의 욕실의 수에 따른 변화에 대해서 알아보겠습니다.

plt.figure(figsize=(12,8))
sns.boxplot(x='bathroomcnt', y='logerror', data=train_df)
plt.ylabel('Log error', fontsize=12)
plt.xlabel('Bathroom Count', fontsize=12)
plt.xticks(rotation='vertical')
plt.title('How log error changes with bathroom count?', fontsize=15)
plt.show()

그래프에서 볼 수 있듯이, 대부분의 분포가 log error가 0 근방에 있다가 Bathroom count가 7.5, 11.0, 12.0 인 경우에는 log error가 넓게 분포하고 median값이 0에서 조금씩 벗어나고 있는 것을 볼 수 있습니다.

(Null value를 replace하고 나서 3.03이라는 평균을 얻었다는 부분은 데이터를 업데이트 하면서 NaN value가 모두 사라진 것 같습니다.)

분포가 흔들리기 시작하는 7을 넘는 값들을 7로 치환해주고 분포를 살펴보겠습니다.

train_df['bedroomcnt'].loc[train_df['bedroomcnt']>7]=7
plt.figure(figsize=(12,8))
sns.violinplot(x='bedroomcnt', y='logerror', data=train_df)
plt.xlabel('Bedroom count', fontsize=12)
plt.ylabel('Log error', fontsize=12)
plt.show()

7 초과의 값들을 없애주고 나니 훨씬 균일한 분포를 보이긴 하지만 아직도 끝으로 갈수록 조금씩 퍼지는 모양을 확인할 수 있습니다.

이번에는 세금과 logerror 사이의 관계를 살펴보겠습니다.

col = 'taxamount'
ulimit = np.percentile(train_df[col].values, 99.5)
llimit = np.percentile(train_df[col].values, 0.5)
train_df[col].loc[train_df[col]>ulimit] = ulimit
train_df[col].loc[train_df[col]<llimit] = llimit

plt.figure(figsize=(12,12))
sns.jointplot(x=train_df[col].values, y=train_df['logerror'].values, height=10, color='g')
plt.ylabel('Log error', fontsize=12)
plt.xlabel('Tax amount', fontsize=12)
plt.title('Tax amount vs Log error', fontsize=15)
plt.show()

이 그림 또한 대부분의 데이터가 logerror가 0인 지점 근처에 몰려있는 정규분포와 비슷한 모습을 하고 있습니다.

이번엔 지어진 년도, yearbuilt와 logerror 사이의 관계를 알아보겠습니다.

from plotnine import *
ggplot(aes(x='yearbuilt', y='logerror'), data=train_df) + \
    geom_point(color='steelblue', size=1) + \
    stat_smooth()

ggplot을 그려야하는데 기존의 코드처럼 ggplot 모듈을 설치하면 오류가 많이 납니다. 예전 모듈이다 보니 Pandas 내부에서 사라진 방법들이 많아 잘 돌아가지 않았습니다. 별도로 코드를 수정해가며 사용해보려고 했지만, 잘 되지 않아 ggplot 깃헙에서 PR을 읽던 중에 plotnine을 알게되어 사용하게 됐습니다.

그래프를 살펴보면 아주 작은 기울기의 선형성을 조금 보이고 있습니다.

계속 ggplot을 이용해, 경도/위도, longitude, latitude 와 logerror 사이의 관계를 살펴보겠습니다.

ggplot(aes(x='latitude', y='longitude', color='logerror'), data=train_df) + \
    geom_point() + \
    scale_color_gradient(low='red', high='blue')

위 그래프르 봤을 때는 딱히 시각적으로 눈여겨볼 만한 점이 보이지 않습니다. 따라서 가장 큰 양의 상관관계와 가장 큰 음의 상관관계를 보이는 변수들을 살펴보겠습니다.

이 또한 딱히 유의미한 점은 보이지 않습니다.

단변량분석(univariate analysis)를 통해 중요한 변수가 있다는 것을 알아냈습니다. 하지만 이러한 분석은 하나만 바라보는 데에 기반을(stand alone basis) 두고 있고 또한 선형성을 가정하고 있습니다.

다음으로는 Extra Trees model을 통해 비선형성 모델을 만들어 중요한 변수들을 얻어보겠습니다.

train_y = train_df['logerror'].values
cat_cols = ["hashottuborspa", "propertycountylandusecode", "propertyzoningdesc", "fireplaceflag", "taxdelinquencyflag"]
drop_train_df = train_df.drop(['parcelid', 'logerror', 'transactiondate', 'transaction_month'] + cat_cols, axis=1)
feat_names = train_df.columns.values

train_y에 logerror 값들을 넣어줍니다.
category 변수는 트리모델분석시 사용이 불가능하므로 cat_cols로 모으고, 기타 날짜형 변수등도 drop 해줍니다.
이제 남은 수치형 변수 컬럼들을 feat_names에 모아줍니다.

drop_train_df = drop_train_df.fillna(0)
from sklearn import ensemble
model = ensemble.ExtraTreesRegressor(n_estimators=25, max_depth=30, max_features=0.3, n_jobs=-1, random_state=0)
model.fit(drop_train_df, train_y)

트리 모델 생성시 NaN value가 있어서 불가능하다는 오류가 떠서 fillna(0)을 했습니다.

ExtraTreesRegressor 클래스는 meta 추정기를 만드는데, 그 추정기는 많은 랜덤 결정 트리를 데이터셋의 다양한 샘플에 fit하고 정확도를 올리고 overfitting을 컨트롤하기 위해 평균화(averaging)를 사용합니다. 엑스트라 트리는 기존의 랜덤포레스트 모델에서 무작위로 특성을 분할해 더욱 무작위하게 만드는 모델입니다.

아직 머신러닝에 대한 지식이 부족해 추후에 더 정리해보도록 하겠습니다.
Output으로는 다음과 같은 Regressor가 나옵니다.

ExtraTreesRegressor(bootstrap=False, ccp_alpha=0.0, criterion=’mse’, max_depth=30, max_features=0.3, max_leaf_nodes=None, max_samples=None, min_impurity_decrease=0.0, min_impurity_split=None, min_samples_leaf=1, min_samples_split=2, min_weight_fraction_leaf=0.0, n_estimators=25, n_jobs=-1, oob_score=False, random_state=0, verbose=0, warm_start=False)

importances = model.feature_importances_
std = np.std([tree.feature_importances_ for tree in model.estimators_], axis=0)
indices = np.argsort(importances)[::-1][:20]

plt.figure(figsize=(12,12))
plt.title('Feaute importances')
plt.bar(range(len(indices)), importances[indices], color='tomato', yerr=std[indices], align='center')
plt.xticks(range(len(indices)), feat_names[indices], rotation='vertical')
plt.xlim([-1, len(indices)])
plt.show()

.feature_importances_를 통해 특성의 중요성을 가져오고 이 특성들의 표준편차도 위와 같이 구합니다. 그리고중요도가 높은 상위 20개의 특성을 indices에 넣습니다.

그래프의 결과로 봤을때는 ‘yardbuildingsqft26’ 변수가 가장 중요한 변수로 보입니다.

XGBoost를 사용해서 중요도를 분석해보겠습니다. XGBoost는 Extreme Gradient Boosting의 약자로, Gradient Boost 기법을 병렬 학습이 지원되도록 발전시킨 형태라고 합니다.

(이 부분도 머신러닝을 공부하며 내용을 추가하겠습니다.)

import xgboost as xgb
xgb_parmas = {
    'eta': 0.05,
    'max_depth': 8,
    'sub_sample': 0.7,
    'colsample_bytree': 0.7,
    'objective': 'reg:linear',
    'silent': 1,
    'seed': 0
}
dtrain = xgb.DMatrix(drop_train_df, train_y, feature_names=drop_train_df.columns.values)
model = xgb.train(dict(xgb_parmas, silent=0), dtrain, num_boost_round=50)

fig, ax = plt.subplots(figsize=(12,18))
xgb.plot_importance(model, max_num_features=50, height=0.8, ax=ax)
plt.show()

XGBoost로 그린 그래프에서는 ‘latitude’ 가 가장 중요성이 높은 변수로 볼 수 있습니다.

Conclusion

다양한 모듈로 다양한 그림을 통해 분석을 할 수 있다는 사실을 알 수 있었습니다. 필사를 하면서 ‘이렇게 할 수 있구나.’ 하며 최대한 알아가려고 노력했습니다. 특히 jointplot을 그려서 다양한 그래프를 한번에 보여주면서 효과적으로 보여줬던 점, heatmap을 효과적으로 썼던 점이 놀라웟습니다.

TODO

고치고 싶은 부분 수정하기: pandas setting copy warning 관련 부분.
values를 to.numpy()로 수정하기.
matplotlib, seaborn 등등 객체지향으로 바꾸기.

이미지 태그

2021-04-17T00:00:00+00:00

블로그 관련해서 이미지 첨부시

경로는 그대로인데

![Kaggle - EDA f498b5128ea24cc299bc1010cc0b64f8/_2021-04-17__12.14.01.png](/assets/Kaggle%20-%20EDA%20f498b5128ea24cc299bc1010cc0b64f8/1.png)

![Kaggle - EDA f498b5128ea24cc299bc1010cc0b64f8/_2021-04-17__12.14.01.png](/assets/Kaggle%20-%20EDA%20f498b5128ea24cc299bc1010cc0b64f8/_2021-04-17__12.14.01.png)

둘 다 마크다운에서는 잘 보이지만 아래는 호스팅 된 블로그에서는 보이지 않는다. 아마도 under_score 관련된 문제인듯 하다.

추가적으로 확인해야하지만 일단은 그렇지 않을까 싶다…

![Kaggle - EDA f498b5128ea24cc299bc1010cc0b64f8/_2021-04-17__12.14.01.png](/assets/Kaggle%20-%20EDA%20f498b5128ea24cc299bc1010cc0b64f8/results___9_0.png)

![Kaggle - EDA f498b5128ea24cc299bc1010cc0b64f8/_2021-04-1712.14.01.png](/assets/Kaggle%20-%20EDA%20f498b5128ea24cc299bc1010cc0b64f8/results_9_0.png)

![Kaggle - EDA f498b5128ea24cc299bc1010cc0b64f8/_2021-04-17__12.14.01.png](/assets/Kaggle%20-%20EDA%20f498b5128ea24cc299bc1010cc0b64f8/results--9--0.png)

Jekyll이 빌드를 안해준다고 한다! link

By default, Jekyll doesn’t build files or folders that:

are located in a folder called /node_modules or /vendor
start with _, ., or #
end with ~
are excluded by the exclude setting in your configuration file
If you want Jekyll to process any of these files, you can use the includes setting in your configuration file.

Kaggle-Survey EDA

2021-04-17T00:00:00+00:00

Kaggle - EDA

2020 Kaggle Machine Learning & Data Science Survey

The most comprehensive dataset available on the state of ML and data science

https://www.kaggle.com/c/kaggle-survey-2020

Introduction.

처음 해본 Kaggle 프로젝트였습니다. 이미 끝난 대회이지만 퓨쳐스킬을 통해서 배운 EDA 기술을 끌어모아 유의미한 분석을 하는데에 목표를 두고 임했습니다. 퓨쳐스킬에서 푼 다양한 데이터 시각화 기본기 문제들을 다시 뒤적이면서 복습 겸 분석에 도전했습니다.

그럼 대회의 설명부터 읽고 요약을 하겠습니다.

This survey data EDA provides an overview of the industry on an aggregate scale, but it also leaves us wanting to know more about the many specific communities comprised within the survey. For that reason, we’re inviting the Kaggle community to dive deep into the survey datasets and help us tell the diverse stories of data scientists from around the world.

데이터 사이언티스트들을 주제로 다양한 얘기를 할 수 있도록 EDA를 하는 것이 이번 대회의 목표입니다.

The challenge objective: tell a data story about a subset of the data science community represented in this survey, through a combination of both narrative text and data exploration. A “story” could be defined any number of ways, and that’s deliberate. The challenge is to deeply explore (through data) the impact, priorities, or concerns of a specific group of data science and machine learning practitioners. That group can be defined in the macro (for example: anyone who does most of their coding in Python) or the micro (for example: female data science students studying machine learning in masters programs). This is an opportunity to be creative and tell the story of a community you identify with or are passionate about!

조사에 참여한 데이터 사이언티스트 커뮤니티의 일부에 대해 이야기를 데이터와 적절한 말과 데이터 탐색을 통해 풀어나가야합니다. 이 대회를 내가 포함되있거나 관심이 있는 분야 커뮤니티에 대한 이야기를 창의적으로 할 수 있는 기회를 가질 수가 있게 됩니다.

마지막 구절을 듣고, ‘나와 비슷한 사람들을 분석하면, 내가 뭘 해야 먹고 살 수 있을 지, 또 잘 먹고 살 수 있을 지 알 수 있지 않을까?’ 하는 생각이 들어서 그것에 초점을 두고 분석을 시작하게 됐습니다.

Import module, read data.

먼저 EDA에 사용할 모듈들을 import 하고, data를 읽어들이는 과정입니다.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
import seaborn as sns

data = pd.read_csv('/kaggle/input/kaggle-survey-2020/kaggle_survey_2020_responses.csv')

처음 해보는 kaggle 과제라 처음에는 colab에서 문제를 풀고 노트를 그대로 옮기는 식으로 시작했습니다. kaggle API 토큰을 받아서 데이터를 다운로드하는 과정을 거쳤지만 실제로 kaggle 노트북 작성에 들어가니 기존에 built-in 되어있는 코드를 이용해 데이터를 받을 수 있었고 바로 읽어올 수 있었습니다.

우선 읽어온 데이터가 어떤 모습을 하고 있나 개략적으로 훑어보기로 했습니다.

data.head()

DataFrame의 열에는 질문 번호로 인덱싱이 되어있고, 복수 선택지가 있는 경우는 _Part_#꼴로 되어있는 모습을 알 수 있었습니다.

Analysis

저는 저의 상황과 비슷하게 석사과정을 거친 남자들의 정보만 가지고 분석을 하기로 했습니다. 그리고 그런 사람들의 나이는 어떤식으로 분포하고 있을까에 대해서 가장 먼저 알고 싶었습니다.

df_similar_to_me = data[(data["Q2"] == "Man")  & (data["Q4"] == "Master’s degree")]

age_group = df_similar_to_me['Q1'].value_counts().sort_index().astype(np.int64)

idx = age_group.index

fig, ax = plt.subplots(figsize=(15, 8))
ax.bar(idx, age_group, facecolor='lightgray')
ax.set_xlabel('Age group', fontsize=14, fontweight='bold', color='gray', labelpad=12)
ax.set_ylabel('Population', fontsize=14, fontweight='bold', color='gray', labelpad=12)

for p in ax.patches:
    left, bottom, width, height = p.get_bbox().bounds
    if height == 1529:
        ax.annotate(height.astype(np.int64), (left+width/2, height+30), ha='center', color='k', fontweight='bold')
    else:
        ax.annotate(height.astype(np.int64), (left+width/2, height+30), ha='center', color='k')
    
ax.patches[2].set_facecolor('yellow')
ax.patches[2].set_linewidth('3')
ax.patches[2].set_edgecolor('darkorange')

value_counts()를 통해 age열에 고유한 값들을 반환하고 그 값들을 sort_index()를 통해 index에 따라 오름차순으로 sort 했습니다. 그리고 matplotlib의 bar 그래프를 통해 어떤 분포를 하고 있는 지 알아보고 annotate를 해 구체적인 값을 명시했습니다.

그래프가 그려지고 나서 가장 큰 값을 차지하는 25~29 나이그룹에 강조를 하기위해 색을 입혔습니다.

나이대를 확인하니 약간의 안도감을 느끼고, 이 사람들은 그럼 어떤 일을 하고 있을까 알아보기로 했습니다.

current_role = df_similar_to_me['Q5'].value_counts().sort_index().astype(np.int64)

fig, ax = plt.subplots(figsize=(15, 8))
ax.bar(current_role.index, current_role, facecolor='lightgray')
ax.set_xlabel('Current role', fontsize=14, fontweight='bold', color='gray', labelpad=12)
ax.set_ylabel('Population', fontsize=14, fontweight='bold', color='gray', labelpad=12)

ax.tick_params(axis='x', rotation=90, labelsize=10, length=5)

for p in ax.patches:
    left, bottom, width, height = p.get_bbox().bounds
    ax.annotate(height.astype(np.int64), (left+width/2, height+10), ha='center', color='k', fontweight='bold')
    

ax.patches[5].set_facecolor('yellow')
ax.patches[5].set_linewidth('3')
ax.patches[5].set_edgecolor('darkorange')

ax.patches[6].set_facecolor('lime')
ax.patches[6].set_linewidth('3')
ax.patches[6].set_edgecolor('seagreen')

ax.patches[9].set_facecolor('skyblue')
ax.patches[9].set_linewidth('3')
ax.patches[9].set_edgecolor('dodgerblue')

ax.get_xticklabels()[5].set_color('darkorange')
ax.get_xticklabels()[5].set_fontweight('bold')
ax.get_xticklabels()[6].set_color('seagreen')
ax.get_xticklabels()[6].set_fontweight('bold')
ax.get_xticklabels()[9].set_color('dodgerblue')
ax.get_xticklabels()[9].set_fontweight('bold')

코드 자체는 위와 동일한 구조로, 직업에 따라 분류하기 위해 'Q5' 열을 사용한 점만 다릅니다. 이번에는 제가 관심있는 3가지 직업, Data Scientist, Machine Learning Engineer, Reserach Scientist의 결과값을 강조했습니다.

이제 더 범위를 좁혀 석사 남자중에서 이 3가지 직업을 가지는 데이터만 살펴보기로 했습니다. 이 3가지 직업을 가진 사람들은 얼마만큼의 코딩, 프로그래밍 경력이 있는지 볼 수 있으면 내가 얼마나 더 열심히 많이 경험을 해야할 지 알 수 있을거라고 생각했습니다.

top_3_jobs = df_similar_to_me[(df_similar_to_me["Q5"] == "Data Scientist") |
                              (df_similar_to_me["Q5"] == "Machine Learning Engineer") |
                              (df_similar_to_me["Q5"] == "Research Scientist")]

top_3_jobs.head()

top_3_jobs['count'] = 1

jobs_exp = pd.pivot_table(top_3_jobs, index=['Q6'], columns=['Q5'], values='count', aggfunc='sum').reindex(['1-2 years', '3-5 years', '5-10 years', '10-20 years', '20+ years'])

jobs_exp.head()

fig, ax = plt.subplots(figsize=(5,12))
sns.heatmap(jobs_exp, linewidths=2.5, annot=True, annot_kws={"size": 10, "fontweight": 'bold'}, cmap="Greens", fmt="d")
ax.set_ylabel('Experience in programming',fontsize=14, fontweight='bold', color='gray', labelpad=12)
ax.set_xlabel('Current Jobs',fontsize=14, fontweight='bold', color='gray', labelpad=12)

top_3_jobs['count'] = 1 라는 코드를 추가했습니다. 이렇게 하면 바로 뒤에 따라나오는 jobs_exp = pd.pivot_table(~)에서 count로 sum을 하여 직업당 경험년수에 따른 인원 수를 셀 수 있습니다. 그리고 표를 보여주듯이 시각화를 하기위해 heatmap을 사용했습니다.

대충 얼마만큼의 경험이 있어야 하는지 대략적으로 알게 되고 더 열심히 해야 쓸모가 있겠구나 라고 생각했습니다. 그러면 몇개의 언어를 다룰 수 있어야 하는지, 무슨 언어를 알아야 하는지도 알아보겠습니다.

lang_sum = top_3_jobs.loc[:,'Q7_Part_1':'Q7_OTHER'].count(axis=1).values

top_3_jobs['lang_sum'] = lang_sum.astype(np.int64)

g = sns.catplot(data=top_3_jobs, x='Q6', y='lang_sum', order=['1-2 years', '3-5 years', '5-10 years', '10-20 years', '20+ years'], 
            kind='violin', inner='stick', palette='pastel')

g.set_xlabels('Experience in coding', fontsize=14, fontweight='bold', color='gray', labelpad=12)
g.set_ylabels('Number of languages', fontsize=14, fontweight='bold', color='gray', labelpad=12)

g.axes[0][0].axhline(2, ls='-', color='dodgerblue', linewidth=3)
g.axes[0][0].axhline(3, ls='-', color='dodgerblue', linewidth=3)

우선 다룰 줄 아는 언어의 갯수를 새로운 column으로 추가해주고 바이올린 플롯을 그려봤습니다.

경력에 상관없이 보통 2~3개의 언어를 다룰 줄 아는 사람이 가장 많고 경력이 긴 집단에서는 10개 이상의 언어를 다룰 수 있는 사람들도 있긴 했습니다.

df = pd.DataFrame(top_3_jobs.loc[:,'Q7_Part_1':'Q7_OTHER'])

df_2 = df.notnull().astype('int')
df_2 = df_2.append(df_2.agg("sum"), ignore_index=True)

lang_group = df_2.iloc[-1,:]
idx = ['Python', 'R', 'SQL', 'C', 'C++', 'Java', 'Javascript', 'Julia', 'Swift', 'Bash', 'MATLAB', 'None', 'Other']

fig, ax = plt.subplots(figsize=(15, 6))
ax.bar(idx, lang_group, facecolor='lightgray')
ax.set_xlabel('Language', fontsize=14, fontweight='bold', color='gray', labelpad=12)
ax.set_ylabel('Recommendations', fontsize=14, fontweight='bold', color='gray', labelpad=12)
ax.set_title('First Language to learn for aspiring data scientist', fontsize=14, fontweight='bold')

for p in ax.patches:
    left, bottom, width, height = p.get_bbox().bounds
    if height == 1626 or height == 861:
        ax.annotate(height.astype(np.int64), (left+width/2, height+30), ha='center', color='k', fontweight='bold')
    else:
        ax.annotate(height.astype(np.int64), (left+width/2, height+30), ha='center', color='k')
    
ax.patches[0].set_facecolor('yellow')
ax.patches[0].set_linewidth('3')
ax.patches[0].set_edgecolor('darkorange')

ax.patches[2].set_facecolor('yellow')
ax.patches[2].set_linewidth('3')
ax.patches[2].set_edgecolor('darkorange')

가장 많이 배우기로 추천하는 언어들을 살펴보니, Python과 SQL이 꽤나 앞서고 있었습니다. 운 좋게도 Python으로 코딩을 하고 있어서 다행이네요.

직업을 얘기하면서 돈 얘기를 빼놓을 수 없습니다.

salary = top_3_jobs.iloc[:,118].value_counts().astype(np.int64)

해당 월급을 받는 사람의 인원을 bar 그래프로 그려도 좋지만, 경험에 따라 얼마나 연봉이 변하는 지 알고 시었습니다. 위와 같이 series를 출력해보니 index에 ‘-‘ 도 있고 ‘> $’ 가 있는 경우도 있어서 정규표현식을 사용하려고 했지만 아직 실력이 부족해 일일이 하나씩 빼주기로 했습니다.

salary.index = [i.replace(',','') for i in salary.index]

salary.index = [i.replace('$','') for i in salary.index]

salary.index = [i.replace('> ','') for i in salary.index]

new_index = {}
for i in salary.index:
    mid_point = i.find('-')
    left_num = int(i[:(mid_point)])
    right_num = int(i[(mid_point+1):])
    new_index[i] = (left_num+right_num)/2

new_index

차례대로 쉼표, 달러기호, ‘> ‘ 표시를 제외하고 new_index라는 딕셔너리를 만들어 각 금액대의 (표시된) 중간값, 평균값을 선택하기로 했습니다. 딕셔너리로 만든 이유는 과거의 index와 해당하는 중간값을 같이 가지고 사용할 수 있겠다는 생각이 들어서였습니다.

exp_comp = pd.pivot_table(top_3_jobs, values='count', index=['Q6'], columns=['Q24'], aggfunc=np.sum)

new_col = list(new_index.values())

exp_comp.columns = new_col

exp_comp.fillna(0, inplace=True)

exp_comp

exp_comp['avg_income'] = 0
v2 = np.array(exp_comp.columns[:-1])

for i in range(0,7):
    v1 = np.array(exp_comp.iloc[i, :-1])
    sum = np.sum(v1)
    avg_income = np.dot(v1, v2) / sum
    exp_comp.iloc[i,-1] = round(avg_income,2)

q6_order = ['I have never written code', '< 1 years', '1-2 years', '3-5 years','5-10 years', '10-20 years', '20+ years']

exp_comp = exp_comp.reindex(q6_order)

fig, ax = plt.subplots(figsize=(15, 6))
ax.plot(exp_comp.index, exp_comp['avg_income'], color = 'dodgerblue', linewidth=2.5, linestyle='--')
ax.bar(exp_comp.index, exp_comp['avg_income'], facecolor = 'lightgray', edgecolor='black')
ax.set_xlabel('Experience in coding', fontsize=14, fontweight='bold', color='gray', labelpad=12)
ax.set_ylabel('Average yearly compensation', fontsize=14, fontweight='bold', color='gray', labelpad=12)

결국엔 new_index의 value값만 사용하게 됐습니다. exp_comp를 만들어 열을 교체하고 avg_income 이라는 열을 만든뒤에 평균을 (가격대의 중간값(new_col) * 인원 수) / 인원수총합으로 계산했습니다.

그리고 아래와 같이 막대그래프와 직선그래프를 함께 그렸습니다. 사실 연속데이터가 아니기 때문에 정확한 직선이라고 할 수는 없지만 추세를 알고 싶었기에 아래와 같이 그렸습니다.

결과적으로는 경험이 많을수록 연봉이 는다는 것을 알 수 있었습니다.

위의 직선을 또 다른 방법으로 그리면서 각 직업별로는 어떻게 차이가 있을까 궁금해졌습니다.

year_job_salary = top_3_jobs[["Q6", "Q5", "Q24"]]

new_salary_list = list(new_index.values())

old_salary_index = top_3_jobs.iloc[:,118].value_counts().astype(np.int64)

old_salary_list = list(old_salary_index.index)

idx_map = dict(zip(old_salary_list, new_salary_list))

year_job_salary = year_job_salary.replace({"Q24": idx_map})

q6_order = ['I have never written code', '< 1 years', '1-2 years', '3-5 years','5-10 years', '10-20 years', '20+ years']

integer_q6 = [0, 1, 1.5, 4, 7.5, 15, 20]

q6_dict = dict(zip(q6_order, integer_q6))

year_job_salary = year_job_salary.replace({"Q6": q6_dict})

year_job_salary.fillna(0, inplace=True)

fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(10, 6))
axs = axes.ravel()
palette = sns.color_palette("mako_r", 3)

sns.lineplot(data=year_job_salary, x="Q6", y="Q24", hue="Q5", ci=None, palette=palette, ax=axs[0])
axs[0].legend().set_title('Jobs')
axs[0].set_xlabel('Experience in coding', fontsize=14, fontweight='bold', color='gray', labelpad=12)
axs[0].set_ylabel('Average yearly compensation', fontsize=14, fontweight='bold', color='gray', labelpad=12)

sns.lineplot(data=year_job_salary, x="Q6", y="Q24", ci=None, ax=axs[1])
axs[1].set_ylabel('')
axs[1].set_xlabel('Experience in coding', fontsize=14, fontweight='bold', color='gray', labelpad=12)

프로그래밍 경험, 직업, 연봉범위로 이루어진 데이터 프레임을 가지고 기존에 했던 것 처럼 우선 연봉범위를 실수값으로 바꿨습니다. 그리고 경험 또한 평균값을 선택해서 새롭게 인덱싱을 했습니다. 그리고 NaN값을 0으로 바꿔준 뒤 seaborn의 hue를 이용해 그래프를 그렸습니다.

Conclusion

Python 기반으로 진득하게 경력 쌓다보면 금세 고연봉자가 될 수 있다는 결론을 내릴 수 있었습니다.

Thoughts

데이터에서는 연봉 부분은 0~999$를 버는 사람이 가장 많다는 것이 잘 이해가 되지 않았는데 아마 무소득자, 학생등도 포함이 되있어서 그런건가 싶네요.

EDA를 처음 해봐서 많이 어려웠습니다. 내가 뭘 표현하고 싶은지, 뭘 표현할 수 있는지 생각을 우선적으로 하고 임해야겠다는 생각이 많이 들었습니다. 범주형 데이터가 많아서 너무 막대그래프에서 벗어나질 못하는 것 같아서 억지로 선 그래프도 그려봤습니다.

EDA를 시작하기 전에 데이터를 훑어보며 질문 만들기(A와 B가 관련이 있을까?)

질문에 답을 할 수 있는 방향으로 분석하기(A가 많아지면 B도 커지는구나.)

추가적인 질문 만들기(항상 많아지는 건 아닌 것 같은데 왜 그럴까? 다른 요인이 있을까?)

질문에 답을 할 수 있는 방향으로 분석하기(C가 많아지면 B는 적어지는구나.)

와 같은 과정으로 계속 연습을 해봐야겠습니다.

어렵고 반복적인 과정이였지만 무언가 눈에 보이는 걸 만들 수 있다는 점이 재밌었습니다. 다음에는 더 재밌는 자료로 아니면 이 데이터를 가지고 새로운 분석을 꼭 해봐야겠습니다.

Futureskill - Numpy

2021-03-02T00:00:00+00:00

FutureSkill(https://www.futureskill.io) 에서 공부한 내용.

Numpy 는 NUMerical PYthon 의 약자로서, 행렬 등을 다루기 위한 배열(Array)같은 형태의 자료형을 자유자재로 잘 다룰 수 있도록 도와주는 라이브러리 입니다.

데이터 분석을 하기 위해서는 데이터 연산을 해야 합니다. 이 때 연산을 효율적으로 하기 위해서 데이터는 모두 벡터로 표현됩니다. 이런 벡터 연산에 최적화된 Numpy를 통해서 데이터를 빠르게 처리할 수 있습니다.

Numpy Creation

import numpy as np
L = [1, 2, 3, 4, 5]
arr = np.array(L) # Python list L -> Numpy array
arr2 = np.zeros(10) # 원소가 모두 0인 array

L = [1.1, 2.2, 3.3, -4.4, 5.5]
np.array(L, dtype = np.float32) # 원소가 모두 32bytes 사이즈의 float(float32) 타입

arr = np.array(range(1,1001))
arr = np.arange(1,1001) # 1부터 1000까지의 정수 array

arr = np.arange(0, 1.1, 0.1) # 0부터 1까지 0.1의 간격으로 놓인 실수들을 가지는 array

numpy array가 가질 수 있는 자료형은 다음과 같습니다.

i - integer

b - boolean

u - unsigned integer

f - float

c - complex float

m - timedelta

M - datetime

O - object

S - string

U - unicode string

V - fixed chunk of memory for other type ( void )

Python list는 다른 종류의 데이터 타입을 저장할 수 있는 반면 numpy array 내에서는 모든 원소가 동일한 data type을 가져야 합니다. 이는 연산을 빠르게 처리하기 위한 Numpy의 특성 때문입니다.

Numpy가 빠른 연산을 할 수 있는 이유는 Numpy는 연산을 여러개의 부분적 연산(subtasks)들로 나눠서 병렬적으로 처리가 가능하고, C로 구현되어 있기 때문에 Python list보다 빠르게 연산을 처리할 수 있기 때문입니다.

Numpy indexing

arr[1] # arr의 2번째 원소.
arr2 = np.array([1, 2, 3], [4, 5, 6], [7, 8, 9]])
arr2[1][2] # arr의 2번째 행, 3번째 열의 원소
arr2[0] # 첫번째 행 fancy indexing
arr2[:,1] # 두번째 열 facny indexing

Numpy masking

arr = np.array([30,4,550,9,112,10000,15,21])

mask = (30 < arr[:])
#mask = 30 < arr 

arr[mask] # 주어진 데이터에 30보다 큰 원소들만 뽑아내는 masking
# arr[arr>30] 과 같이 간단히 쓸 수 있다.

Numpy functions

arr = np.array([30,4,550,9,112,10000,15,21])

arr.min() # 최소값
arr.max() # 최대값
arr.argmin() # 최소값의 위치
arr.argmax() # 최대값의 위치

arr1 = np.array([1, 2, 3, 4, 5])
arr2 = np.array([6, 7, 8, 9])
np.concatenate((arr1,arr2), axis = 0) # [arr1, arr2] 꼴로 합치는 코드.

arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
arr3 = np.array([7, 8, 9])
np.vstack((arr1, arr2, arr3)) # 세로로 쌓는 코드
np.concatenate([arr1, arr2, arr3]).reshape(3,3) # 세로로 쌓는 코드

# vstack 이나 concatenate 둘다 
# (arr1, arr2, arr3) or [arr1, arr2, arr3] 모두 사용가능하다.

Numpy arithmetic operation

v1 = np.array([1, 2, 3])
v2 = np.array([4, -1, 2])

v1 + v2
np.add(v1,v2) # v1 + v2 벡터합

np.dot(v1, v2) # (v1, v2) 내적
innerPd = np.vdot(v1, v2)
innerPd2 = np.inner(v1, v2) # 1d에서만 가능함.
MatMul = np.matmul(v1, v2) # 1d에서는 내적처럼 바꿔준다.
MatMul2 = np.matmul(v1, v2.T) # 위의 Matmul과 같은 값

내적(inner product)와 관련된 코드는 다음과 같은 경우들로 조금 더 깊이 살펴보겠습니다.

사실 inner product 와 dot product는 차이가 있긴 합니다. 이 부분은 이곳에 설명이 아주 잘 나와있습니다.

https://math.stackexchange.com/questions/476738/difference-between-dot-product-and-inner-product

요약해서 dot product는 $\R^{n}$ 에서의 inner product 정도로만 알고 있어도 될 것 같습니다.

np.dot(): numpy.dot(vector_a, vector_b, out = None) → 벡터 a, b의 내적(dot product)를 을 계산합니다. 2D array를 다룰 수 있지만 행렬(matrix)로 생각하고 행렬곱(matrix multiplication)을 계산합니다. np.vdot(): numpy.vdot(vector_a, vector_b) → 벡터 a, b의 내적(dot product)를 계산합니다.

vector_a = np.array([2 + 3j])
vector_b = np.array([4 + 5j])

dot_product = np.dot(vector_a, vector_b)
vdot_product = np.vdot(vector_a, vector_b)
matmul = np.matmul(vector_a, vector_b)
matmul2 = np.matmul(vector_a, vector_b.T)
print(dot_product)
print(vdot_product)
print(matmul)
print(matmul2)

→ np.dot와 np.inner의 계산값은 -7+22j 가 나오게 됩니다. 이는 별도로 conjugate 처리를 하지 않고 계산을 했기 때문입니다.

$(2+3j)\cdot(4+5j) = -7+22j$

→ np.vdot의 경우에는 (2-3j) 에 대해 conjugate 처리를 해주기 때문에 23-2j 가 나오게 됩니다.

(1,2j) , (2,3j) 와 같은 2차원 꼴로 예를 들어서 보면 더 쉽게 차이를 볼 수 있습니다. 실제 dot product와 더 가까운 것은 np.vdot이라고 할 수 있습니다. 하지만 np.vdot과는 (a,b) 순서가 다르다고 보시면 됩니다.

실제 $\vec{a} \cdot \vec{b} =$ np.vdot(b,a) 라고 생각하시면 됩니다.

np.matmul

np.matmul의 경우 1차원 벡터를 받으면 알아서 뒤의 벡터를 전치해준 뒤 일반적인 내적을 계산해줍니다. 따라서 np.matmul(v1, v2) 와 np.matmul(v1, v2.T) 의 값이 같게 나옵니다. 복소수의 경우에서는 np.dot, np.inner 와 같은 값을 출력합니다.

np.matmul의 경우 vector_a = 2+3j로 선언 후 사용하려고 하면 사용이 되지 않습니다. 다른 함수들과 달리 scalar를 입력으로 받을 수 없기 때문입니다. 따라서 vector_a = np.array([2 + 3j])로 선언 후 사용해야 합니다.

1차원에서는 위와 같이 조금 복잡하게 계산이 이루어집니다. 2차원에서의 np.dot과 np.vdot의 차이는 다음과 같습니다.

vector_a = np.array([[1, 4], [5, 6]]) 
vector_b = np.array([[2, 4], [5, 2]])

dot_product = np.dot(vector_a, vector_b)
matmul = np.matmul(vector_a, vector_b)
vdot_product = np.vdot(vector_a, vector_b)

값을 확인해보면 처음 둘은 그냥 행렬곱(matrix multiplication) 을 계산해주고, vdot의 경우 두 벡터를 flatten 한 뒤에 내적을 구합니다 따라서 [1, 4, 5, 6] 과 [2, 4, 5, 2] 의 내적과 같은 계산이 됩니다.

(계속 numpy doc을 보며 공부하고 내용을 보완, 수정할 것!)

Numpy functions

arr1 = np.array([1, 2, 3])
arr1+=3 # broadcasting

img = np.random.random((5, 5))

ravel = img.ravel()
reshape = img.reshape(-1)
flatten = img.flatten()

# 행의 갯수를 모를 때 flatten
N = int(input("N? : "))
data = np.random.random((N, 6))

flatten_data = data.flatten()
ravel_data = data.ravel()
reshape_data = data.reshape(-1)

ravel, reshape는 복사가 아니므로 img의 원소를 바꾸면 같이 바뀝니다. 반면에 flatten은 복사이므로 바뀌지 않습니다.

# math functions
x = 10
np.sin(x)
np.cos(x)
np.tan(x)

np.abs(x)
np.sqrt(x)
np.square(x)

# python 출력 소수점 4자리까지
print("abs(10) : ", '%.4f'%np.abs(x))
print("sqrt(10) : ", '%.4f'%np.sqrt(x))
print("square(10) : ", '%.4f'%np.square(x))

x = 3.14

print("exp({}) : {}".format(x, np.exp(x)))
print("log({}) : {}".format(x, np.log10(x)))
# log(x) = ln(x) 이므로 헷갈리지 말자.

Sorting

arr = np.array([1, -5, 3.4, 55.41, -1009, 2245, -575, -1935.124])
arr2 = np.sort(arr)

arr3 = np.argsort(arr) # arr을 정렬하는 인덱스의 어레이 반환
arr4 = arr[arr3]
arr5 = np.lexsort((arr, arr3))
arr6 = np.argsort(arr3)
print('sorted arr', arr2)
print('sorted arr', arr4)
print('argsort', arr3)
print('answer', arr5)
print('answer', arr6)

####### np.lexsort example #######

a = np.array([5, 5, 4])
b = np.array([3, 1, 1])
print(np.lexsort(a,b))

###### Matrix sorting ######
mat = np.array([[1, -1, 3],
               [4, 3, -6],
               [0, 11, 9]])
mat2 = np.sort(mat) # 행별로 오름차순 정렬
mat3 = np.sort(mat, axis = 0)[::-1] # 열별로 내림차순 정렬
print(mat2)
print(mat3)

→ np.lexsort가 어떻게 구현되는 지 보기위해 아래 예제를 들어보겠습니다.

먼저 b를 기준으로 sort 합니다. → [1, 1, 3] → idx = [2, 1, 0] or [1, 2, 0] 1이 2개 이므로 b[1] = b[2] 가 같습니다.
이제 a를 기준으로 sort 합니다. → 이 때 a[1] > a[2] 이므로 idx = [2, 1, 0] 으로 정렬합니다.

Futureskill - Pandas Basic 2

2021-03-01T00:00:00+00:00

Pandas

FutureSkill(https://www.futureskill.io) 에서 제출한 문제를 풀고 공부한 내용

DataFrame method

array = [[0 for col in range(4)] for row in range(12)]

for x in range(len(array)):
    for y in range(len(array[x])):
        array[x][y] = chr(y+65) + str(x)

columns = ['A', 'B', 'C', 'D']

df_B = pd.DataFrame(array, columns = columns)

print(df_B)

간단한 DataFrame을 만들어보았습니다. 피어리뷰를 구경하던 중 다음과 같은 코드를 봤습니다. (논문읽는재간둥이님 코드)

cols = ['A', 'B', 'C', 'D']

data = [[c+str(i) for i in range(12)] for c in cols]

df_b = pd.DataFrame(np.array(data).T, index=range(0, 12), columns=cols)

cols를 재활용해서 조금 더 직관적으로 data의 모양이 눈에 보이고, 결국 이를 전치(.T) 한 뒤에 DataFrame을 만들어주는 게 더 깔끔하고 멋져보였습니다.

DataFrame df_b(df_B)에서 데이터를 출력하는 방법을 연습했습니다. 우선 기본적으로 위에서부터 5개 행을 출력하는 코드는 다음과 같습니다.

df_b.head()
df_b[:5] # indexing operator 사용
df_b.loc[0:4,:]
df_b.iloc[0:5,:]

.loc가 있을 때는 0:4, 그냥 참조할 때, iloc를 사용할 때는 :5 로 잡아주고 있습니다.

간단하게 요약하면 다음과 같습니다.

.loc 는 label based 이기 때문에 0:4 까지 출력해서 0, 1, 2, 3 ,4 로 5개를 출력할 수 있음.
.iloc 는 integer position based 이기 때문에 0:5 까지 출력해서 0, 1, 2, 3, 4 로 출력할 수 있음.

→ 아마 행보다는 열을 뽑아낼 때 column의 이름(label), 위치(position)에 따라 다르게 쓸 수 있어 차이를 보기 더 쉬울 것 같습니다.

# A 열을 출력할 때
df_A.loc[:,"A"] # "A" label의 열
df_A.iloc[:,0] # 0번째 위치의 열
df_A['A'] # indexing operator 사용

df_A.iloc[1:4,0:2] # 1행 ~ 3행, 1열 ~ 3열 까지의 데이터를 출력
df_A.loc["2020-01-02":"2020-01-04","A":"B"]

DataFrame의 정보를 추출하는 몇개의 코드를 작성해보겠습니다.

df_B.index # index 출력
df_B.values # values 출력
df_B.columns # columns 출력

# 각각 df_B를 요약해주는 방법들
df_B.describe() # 통계량 출력
df_B.describe # df_B.info와 같은 역할
df_B.info() # 요약
df_B.info

describe 와 describe() 의 차이 :

describe() : method로 class 내의 함수.

descirbe : attributes(속성) 으로 다른 오브젝트를 참조하는 변수

→ 다른 기능을 보이고 있습니다. (나중에 알아보기.)

DataFrame의 정렬 또한 다음과 같이 간단하게 구현할 수 있습니다.

# df_A를 이용해서, column C 기준으로 내림차순 정렬한 결과를 출력하는 코드를 작성해보세요
df_A = df_A.sort_values(by=['C'], ascending=False)

오름차순은 ascending=True 로 바꿔주면 됩니다.

df_A에서 0보다 큰 데이터를 모두 출력하고, 그렇지 않은 경우 NaN(Not a Number)로 출력하는 코드는 다음과 같습니다.

df_A[df_A > 0]

DataFrame 두 개를 위-아래로 합치는 코드를 작성해보겠습니다.

col = list('ABC')
A = pd.DataFrame([[1,3,5],[2,4,6]],columns=col) # A Dataframe
B = pd.DataFrame([[-1,-3,-5],[-2,-4,-6]],columns=col) # B Dataframe

# axis = 0 : 가로축을 기준으로 합친다. -> 위, 아래
# axis = 1 : 세로축을 기준으로 합친다. -> 오른쪽, 왼쪽
# ignore_index = True : 합치고 나서 인덱스를 무시한다.

frames = [A, B]
C1 = pd.concat(frames,axis = 0,ignore_index=True)

.concat과 비슷한 기능을 하는 append도 있습니다. 하지만 여러개를 합치는 게 불가능하고, axis 값을 줄 수 없는 등 기능이 더 적습니다.

C2 = A.append(B, ignore_index = True)

merge는 데이터베이스에서 join을 반영한 병합방식입니다. (SQL)

C3 = pd.merge(A,B,how="outer")

Read/Write panel data

panel data는 xlsx, csv와 같은 테이블 형식의 정형 데이터로, tabular data, structured data 라고도 부릅니다. csv 파일은 comma spread value의 약자로 확장성이 좋아 많은 경우 표준이 됩니다.

└── workspace
    └── train.csv
		└── report.xlsx
    └── solution.py # (or solution.ipynb)

현재 폴더의 위치는 workspace라고 표기하였습니다.
작성중인 코드파일의 이름을 solution 이라고 표기하였습니다.
작성중인 코드파일과 동일한 폴더에 위치하게끔 파일을 옮기세요.
'코드파일과 데이터의 폴더'에 대한 개념도 문제에 포함되어 있습니다.

다음과 같이 코드파일과 데이터의 폴더가 같은 폴더에 있을 때, .csv, .xlsx 파일을 불러오는 코드는 다음과 같습니다.

df_E = pd.read_csv('train.csv')
df_F = pd.read_excel('report.xlsx')

이번에는 코드 작성 후, 같은 디렉토리 내에 폴더(result)를 만들고 내부에 수정된 데이터를 train(edited).csv로 저장하는 코드를 작성해보겠습니다.

├── result
│   └── train(edited).csv
├── train.csv
└── solution.py # (or solution.ipynb)

df_E = df_E.drop(columns=['PassengerId', 'Name', 'Ticket']) # 해당 열 삭제.
df_E.to_csv('result/train(edited).csv')

데이터를 불러와 NaN 값을 처리하는 코드를 작성해보겠습니다.

df_C = pd.read_excel('toy.xlsx')

df_C = df_C.dropna() # NaN값 삭제.
df_C = df_C.fillna(method='ffill') # NaN 값을 앞의 값으로 채운다.
df_C.fillna(df_C.mean()) # NaN 값을 해당 열의 평균값으로 채운다.
df_C = df_C.fillna(np.nanmean(df_C)) # NaN 값을 데이터 전체의 평균으로 채운다.

마지막 전체의 평균으로 채우는 경우, 처음에는 df_C.fillna(df_C.mean().mean())과 같이 작성을 했는데, 이 경우 평균값을 제대로 구하지 못한다.

df_c.mean() 에서 평균값을 계산할 때는 NaN을 제외하고 계산.(np.nanmean과 같은 방식) 이 값을 다시 평균을 내면(df_C.mean().mean()) 열 갯수의 값으로 나눠주게 되는데 여기서는 NaN을 제외하지 않으므로 오류가 생긴다.

Aggregating

각 행의 평균을 저장하고 있는 열을 만들고, 열의 이름을 “평균”으로 지정하는 코드와 각 열마다의 합계를 구하고 마지막 행에 추가하는 코드를 작성해보겠습니다.

data = [[1, -1, 2], [2, -2, 3], [3, -3, 4], [4, -4, 7], [5, -5, 8]]

df = pd.DataFrame(data, columns=['A', 'B', 'C'])

df['평균'] = df.agg("mean", axis="columns") # "sum", "min" 등 다양한 방법이 존재.

print(df)

df = df.append(df.agg("sum"), ignore_index=True)
print(df)

df_D['평균'] = df_D.mean(axis=1)와 같이 .agg를 사용하지 않을 수도 있습니다.

Groupby, pivot table

data = [[1, -1, 2], [2, -2, 3], [3, -3, 4], [4, -4, 7], [5, -5, 8]]

df = pd.DataFrame(data, columns=['val1', 'val2', 'val3'])

df['label'] = ['A', 'A', 'B', 'B', 'B']

print(df.groupby(by=['label']).sum())

label 을 기준으로 합을 구하는 코드입니다.

pivot table은 다음과 같이 pivot_table, groupby를 이용해 만들 수 있습니다.

table = pd.pivot_table(df, index=['label'], aggfunc=np.mean)
df1 = df.groupby('label').mean()

aggfunc의 경우 다음과 같이 여러개의 방법을 사용할 수 있습니다.

aggfunc = [‘sum’, ‘count’…] 와 같이 리스트로 처리하면 된다.
aggfunc = [sum, count…] 와 같이 리스트로 처리하면 된다.
aggfunc = [np.sum,…]와 같이 numpy를 불러와서 처리할 수 있다

Futureskill - OOP

2021-02-25T00:00:00+00:00

OOP

FutureSkill에서 푼 OOP문제를 정리한 내용입니다.

파이썬은 OOP 패러다임을 가지는 프로그래밍 언어입니다. OOP는 Object Oriented Programming으로 ‘객체지향 프로그래밍’ 이라는 뜻이고, OOP 패러다임을 가진다는 말은 class 기반으로 짜여진 코드라는 뜻 입니다.

OOP의 정의

OOP는 우리가 원하는대로 메모리 상의 객체의 형태를 지정할 수 있는 프로그래밍 방법론입니다.

Object 를 감싸고 있는 Class를 선언해 Object의 속성(함수도 포함)들을 감싸주면 그 Class를 통해 사용하게 될 변수가 식별하고 있는 메모리공간에 메모리주소를 통해 전달해주는 꼴입니다.

Procedural programming is about writing procedures or functions that perform operations on the data, while object-oriented programming is about creating objects that contain both data and functions.

→ 절차지향 프로그래밍은 데이터에 수행할 절차(procedures)또는 함수에 대해서 작성하는 프로그래밍인 반면, 객체지향 프로그래밍은 데이터와 함수를 모두 포함하는 object(객체)들을 만들어내는 것에 관한 프로그래밍입니다.

Object-oriented programming has several advantages over procedural programming:

객체지향 프로그래밍은 절차적 프로그래밍에 비해 다음과 같은 이점들이 있습니다.

OOP is faster and easier to execute

→ 실행하기에 빠르고 쉽다

OOP provides a clear structure for the programs

→ 프로그램에 명확한 구조를 제공한다.

OOP helps to keep the C++ code DRY “Don’t Repeat Yourself”, and makes the code easier to maintain, modify and debug

→ 같은 일을 반복하는 걸 막아주고 코드를 유지, 수정, 디버깅 하기 쉽게 해준다.

OOP makes it possible to create full reusable applications with less code and shorter development time

→ 적은 코드와 짧은 개발 시간으로도 완전히 재사용가능하게 해준다. (완전히 재사용 가능한 applications를 만들게 해준다.)

(동빈나님 블로그, w3Schools - C++ OOP 참고.)

퓨처스킬 피어리뷰로 확인한 ‘비선형적인핑크젤리’님의 답변도 참고해서 정리해보겠습니다.

앞서 말한대로 객체지향 프로그래밍은 절차지향 프로그래밍과 자주 비교됩니다. 이는 객체지향이 절차지향의 한계점으로부터 고안됐다고 볼 수도 있기 때문입니다. (이런식으로 비교를 하는 것이 이해에도 큰 도움이 됩니다.)

절차지향은 말 그대로 Procedure, 순차적인 처리위주로 진행하는 프로그래밍 방식으로 C언어 등이 있습니다. 하지만 시간이 지날수록 실제 세상의 대상(Object)을 본 딴 프로그래밍이 필요하게 됐고, 객체지향 프로그래밍이 탄생하게 됐습니다.

Python과 OOP

우선 ‘특수한데이터엔지니어’ 님의 답변을 참조하겠습니다.

추상화 : 객체에서 공통된 속성과 행위를 추출함
캡슐화 : 세부 구현 내용을 몰라도 원하는 결과를 얻을 수 있음
상속성 : 하나의 객체에서 구현된 속성이나 행동 내용을 다른 객체가 물려받아 사용할 수 있음
다형성 : 하나의 이름으로 여러 명령을 수행할 수 있는 것.

이러한 Python에서 OOP의 특징을 토대로 다음과 같은 장점을 생각해볼 수 있습니다.

OOP is faster and easier to execute

→ 실행하기에 빠르고 쉽다

OOP provides a clear structure for the programs

프로그램에 명확한 구조를 제공한다.

OOP helps to keep the Python code DRY “Don’t Repeat Yourself”, and makes the code easier to maintain, modify and debug

→ 같은 일을 반복하는 걸 막아주고 코드를 유지, 수정, 디버깅 하기 쉽게 해준다.

OOP makes it possible to create full reusable applications with less code and shorter development time

→ 적은 코드와 짧은 개발 시간으로도 완전히 재사용가능하게 해준다. (완전히 재사용 가능한 applications를 만들게 해준다.)

Python class

본격적으로 객체를 만들고, 이를 위해 클래스를 정의하는 구현과정을 보겠습니다. Python에서는 class라는 키워드를 통해 클래스를 정의합니다. 이 예제에서는 Notebook개념을 클래스로 정의하고, 객체를 생성하려고 합니다. 다음 조건에 맞춰 Notebook class를 만들고 객체를 생성해보겠습니다.

Notebook(Macbook, Surface Pro, ..)들은 여러 제조사에서 생산됩니다.
같은 제조사에서 생산된 Notebook들은 여러 모델명을 가집니다.
같은 모델의 Notebook도 서로 다른 하드웨어 스펙을 가집니다.
manufacturer 변수에 제조사 이름을 저장합니다.
model 변수에서 해당 제조사가 생산한 노트북의 모델명을 저장합니다.
memory1, memory2 변수에 각각 RAM의 용량과 SSD의 용량을 GB 단위로 저장합니다. (e.g. RAM - 8GB, SSD - 256GB → memory1 = 8, memory2 = 256)

class Notebook: # Notebook class를 정의합니다.
    def __init__(self, manufacturer, model, memory1, memory2):
        # manufacturer, model, memory1, memory2 변수 정의
        self.manufacturer = manufacturer
        self.model = model
        self.memory1 = memory1
        self.memory2 = memory2

위와 같이 간단하게 정의할 수 있습니다. 여기서 정의된 __init__()함수는 클래스가 생성(initiated)될 때 마다 실행되는 생성자 함수입니다. 객체의 properties에 값을 주거나, 객체가 만들어질 때 필요한 operation을 객체에 부여합니다.

(All classes have a function called init(), which is always executed when the class is being initiated.

Use the __init__() function to assign values to object properties, or other operations that are necessary to do when the object is being created)

다음으로 위 코드에 노트북에 설치된 OS를 확인하는 is_UNIX함수를 만들어보겠습니다.
그리고 모델명을 출력해주는 print_model method 또한 만들어보겠습니다.

UNIX = set(["macOS X", "CentOS", "Ubuntu", "iOS", "Android", "webOS"])

class Notebook:
    def __init__(self, manufacturer, model, memory1, memory2, os):
        self.manufacturer = manufacturer
        self.model = model
        self.memory1 = memory1
        self.memory2 = memory2
        self.os = os

    def is_UNIX(self):
        return self.os in UNIX
		
		def print_model(self):
    print(f"Model : {self.model}")

nb = Notebook("Apple", "MacBook Pro", 16, 512, "macOS X")
nb2 = Notebook("Dell", "Dell XPS", 16, 1024, "Windows 10")

# nb가 UNIX인지 아닌지 확인하는 코드
print(nb.is_UNIX())
# nb2가 UNIX인지 아닌지 확인하는 코드
print(nb2.is_UNIX())

처음에 풀 때, method를 만들어야한다는 내용을 못 보고 os정보를 저장하는 변수를 만들고, 따로 set에 있는 함수를 사용해 풀었습니다. 따로 method 구현없이 self.os = os를 사용하고 nb.os in UNIX를 출력했습니다.
- Objects can also contain methods. Methods in objects are functions that belong to the object.
→ Objects 는 method들을 포함할 수 있는데, method들은 object에 속해있는 함수들이다.
- The self parameter is a reference to the current instance of the class, and is used to access variables that belongs to the class.
→ self 파라미터는 class에 있는 인스턴스 변수들을 참조하는 파라미터로 클래스에 속해있는 변수에 접근할 때 사용된다.
- It does not have to be named self , you can call it whatever you like, but it has to be the first parameter of any function in the class.
→ self 라고 이름 붙여질 필요는 없지만, class내 생성되는 함수의 첫번째 파라미터에 이름을 따라야한다.
- 클래스 변수와 인스턴스 변수의 차이 :
→ 여러 인스턴스 간에 서로 공유해야 하는 값은 클래스 변수를 통해 바인딩한다. 왜냐하면 파이썬은 인스턴스의 네임스페이스에 없는 이름은 클래스의 네임스페이스에서 찾아보기 때문에 이러한 특성을 이용하면 클래스 변수가 모든 인스턴스에 공유될 수 있다.

(w3schools(https://www.w3schools.com/python/python_classes.asp), https://wikidocs.net/1744 참고)
출력(print)과 반환(return)을 착각하고 return 후 print 를 했다가 수정했습니다. print("Model :",self.model) 처럼 간단하게 출력을 할 수도 있습니다.

클래스 상속(class inheritance)

클래스의 상속은 상위 개념에서 정의한 내용자체를 그대로 상속받아, 하위 개념에도 적용하기 위해서 사용합니다.

Notebook class를 상속받는 두 개의 새로운 하위 class인 MacBook class와 DellLaptop class를 선언하는 코드를 작성해보겠습니다.

UNIX = set(["macOS X", "CentOS", "Ubuntu", "iOS", "Android", "webOS"])

class Notebook: # Notebook class를 정의합니다.
    def __init__(self, manufacturer, model, memory1, memory2, os):
        # manufacturer, model, memory1, memory2 변수 정의
        self.manufacturer = manufacturer
        self.model = model
        self.memory1 = memory1
        self.memory2 = memory2
    # os 정보를 저장하는 변수
        self.os = os

class MacBook(Notebook):
    def __init__(self, manufacturer, model, memory1, memory2, os, period, size):
        Notebook.__init__(self, manufacturer, model, memory1, memory2, os)
        self.period = period
        self.size = size

class Dell_Laptop(Notebook):
    def __init__(self, manufacturer, model, memory1, memory2, os, naming, size):
        super().__init__(manufacturer, model, memory1, memory2, os)
        self.naming = naming
        self.size = size

MacBook class선언처럼 Notebook.__init__ 을 사용해 상속받을 수 있습니다. 이 경우 필요한 period, size 변수는 추가적으로 설정해줬습니다. 자세히 보면 대부분의 성질(properties) 들을 그대로 상속받기 때문에 좀 더 간편하게 super().__init__을 사용해보겠습니다.

Dell_Laptop class 에서 처럼 super().__init__ 후 self 없이 변수들만 적어주고 추가적으로 필요한 성질만 선언해줬습니다.

하위클래스에 __init__을 추가하면 더 이상 상위클래스의 __init__을 상속받는 것이 아니라 override 하게 됩니다. 이를 상속받기 위해서는 위와 같은 방법을 사용해야 합니다.

Method Overriding

하위클래스에서 필요에 따라 상위 클래스에서 정의한 method를 다시 정의해서 사용합니다. 예를 들어서 하위 클래스에서 모델을 출력할 때는 세부모델명 까지 포함해서 출력한다고 가정하고, print_model 함수를 재정의해보겠습니다.

UNIX = set(["macOS X", "CentOS", "Ubuntu", "iOS", "Android", "webOS"])

class Notebook: # Notebook class를 정의합니다.
    def __init__(self, manufacturer, model, memory1, memory2, os):
        # manufacturer, model, memory1, memory2 변수 정의
        self.manufacturer = manufacturer
        self.model = model
        self.memory1 = memory1
        self.memory2 = memory2
    # os 정보를 저장하는 변수
        self.os = os
    def is_UNIX(self):
        return self.os in UNIX

    def print_model(self):
        print("Model: ", self.model)

class MacBook(Notebook):
    def __init__(self, manufacturer, model, memory1, memory2, os, period, size):
        Notebook.__init__(self, manufacturer, model, memory1, memory2, os)
        self.period = period
        self.size = size
    def print_model(self):
        print("MacBook Model : {}({} inch, {})".format(self.model, self.size, self.period))

class DellLaptop(Notebook):
    def __init__(self, manufacturer, model, memory1, memory2, os, naming, size):
        super().__init__(manufacturer, model, memory1, memory2, os)
        self.naming = naming
        self.size = size
    def print_model(self):
        print("DellLaptop Model : {} {} {}".format(self.model, self.size, self.naming))

macbook = MacBook("Apple", "MacBook Pro", 16, 512, "macOS X", "Late 2015", 15)
delllaptop = DellLaptop("Dell", "Dell XPS", 16, 1024, "Windows 10", 9500, 15)

macbook.print_model()
delllaptop.print_model()

출력을 예쁘지 않게 해서 복잡해보여도 간단하게 method를 override할 수 있습니다.

나중에 기회가 되면 C++ 로 class를 생성하는 과정도 정리해야겠습니다.

Futureskill - Pandas Basic

2021-02-23T00:00:00+00:00

한 3일전에 공부한 내용을 부랴부랴 정리한 내용입니다. 기본적인 내용들이라 그렇게 알차지는 않네요.

Pandas data structure (1 ~ 3)

import pandas as pd
L = [1, 2, 3, 4, 5]
L = pd.Series(L)

Pandas 라이브러리를 불러옵니다.
pd.Series 를 통해 Pandas Series로 변환합니다.

import numpy as np
import pandas as pd

array = np.random.random((5,4))
pd.DataFrame(array,columns=['A','B','C','D'])

np.random.random((5,4)) 를 통해 (5,4) array를 만듭니다.
pd.DataFrame(array,columns=['A','B','C','D']) 로 Pandas DataFrame을 만듭니다.

df_A = pd.DataFrame(np.random.randn(5, 4), columns=['A', 'B', 'C', 'D'])
idx = pd.date_range('2021-1-1', freq='D', periods=5)
# idx = pd.date_range(start='2021-1-1', end='2021-1-5')
# idx = pd.date_range(start='20210101', end='20210105')
df_A = df_A.set_index(idx)

인덱스를 별도로 2021. 1. 1 부터 일(‘D’)이 5개 나오게 지정해주고 인덱스를 설정했습니다.