Q1~Q20
인기동영상 제작횟수가 많은 채널 상위 10개명을 출력하라 (날짜기준, 중복포함)
df.channelTitle.value_counts()
head(10)
#value_counts는 null값은 포함하지 않기때문에 null값이 있는 먼저 확인 해줘야한다.
#df.insull().sum()
논란으로 인기동영상이 된 케이스를 확인하고 싶다.dislikes수가 like 수보다 높은 동영상을 제작한 채널을 모두 출력하라
df[df['likes'] < df['dislikes']]['channelTitle'].unique()
채널명을 바꾼 케이스가 있는지 확인하고 싶다.
channelId의 경우 고유값이므로 이를 통해 채널명을 한번이라도 바꾼 채널의 갯수를 구하여라
change = df[['channelTitle','channelId']].drop_duplicates().channelId.value_counts()
target = change[change>1]
print(len(target))
#drop.duplicates = 중복제거 , 아예 똑같은 열만 지우는 것이다.
일요일에 인기있었던 영상들중 가장많은 영상 종류(categoryId)는 무엇인가?
df['trending_date2'] = pd.to_datetime(df['trending_date2'])
answer =df.loc[df['trending_date2'].dt.day_name() =='Sunday'].categoryId.value_counts().index[0]
print(answer)
각 요일별 인기 영상들의 categoryId는 각각 몇개 씩인지 하나의 데이터 프레임으로 표현하라
group = df.groupby([df['trending_date2'].dt.day_name(),'categoryId'],as_index=False).size()
answer= group.pivot(index='categoryId',columns='trending_date2')
display(answer)
댓글의 수로 (comment_count) 영상 반응에 대한 판단을 할 수 있다. viewcount대비 댓글수가 가장 높은 영상을 확인하라 (view_count값이 0인 경우는 제외한다)
target2= df.loc[df.view_count!=0]
t = target2.copy()
t['ratio'] = (target2['comment_count']/target2['view_count']).dropna()
result = t.sort_values(by='ratio', ascending=False).iloc[0].title
print(result)
댓글의 수로 (comment_count) 영상 반응에 대한 판단을 할 수 있다.viewcount대비 댓글수가 가장 낮은 영상을 확인하라 (view_counts, ratio값이 0인경우는 제외한다.
ratio = (df['comment_count'] / df['view_count']).dropna().sort_values()
#ratio[ratio!=0].index[0]
result= df.iloc[ratio[ratio!=0].index[0]].title
print(result)
like 대비 dislike의 수가 가장 적은 영상은 무엇인가? (like, dislike 값이 0인경우는 제외한다)
target = df.loc[(df.likes !=0) & (df.dislikes !=0)]
num = (target['dislikes']/target['likes']).sort_values().index[0]
answer = df.iloc[num].title
print(answer)
가장많은 트렌드 영상을 제작한 채널의 이름은 무엇인가? (날짜기준, 중복포함)
answer = df.loc[df.channelId ==df.channelId.value_counts().index[0]].channelTitle.unique()
print(answer)
#channelId 기준으로 많았던 영상이 트렌드 영상이라고 가정
20회(20일)이상 인기동영상 리스트에 포함된 동영상의 숫자는?
answer= (df[['title','channelId']].value_counts()>=20).sum()
print(answer)
각 데이터의 ‘ct’컬럼을 시간으로 인식할수 있게 datatype을 변경하고
video 데이터의 videoname의 각 value 마다 몇개의 데이터씩 가지고 있는지 확인하라
channel =pd.read_csv('https://drive.google.com/uc?id=1ehmjHMrI6ITfWgmfrIGQlp64AP0FC4P1')
video =pd.read_csv('https://drive.google.com/uc?id=12JRL63ArNYP0OyLGyqqUs2DvMQ7W1YuO')
display(channel.head())
display(video.head())
수집된 각 video의 가장 최신화 된 날짜의 viewcount값을 출력하라
answer = video.sort_values(['videoname','ct']).drop_duplicates('videoname',keep='last')[['viewcnt','videoname','ct']].reset_index(drop=True)
display(answer)
#drop_duplicates keep=last를 써서 중복중에 가장 마지막에 있는 즉, 최신화 내용을 남기는 것
Channel 데이터중 2021-10-03일 이후 각 채널의 처음 기록 됐던 구독자 수(subcnt)를 출력하라
channel.ct = pd.to_datetime(channel.ct)
target = channel[channel.ct >= pd.to_datetime('2021-10-03')].sort_values(['ct','channelname']).drop_duplicates('channelname')
answer = target[['channelname','subcnt']].reset_index(drop=True)
print(answer)
각채널의 2021-10-03 03:00:00 ~ 2021-11-01 15:00:00 까지 구독자수 (subcnt) 의 증가량을 구하여라
end = channel.loc[channel.ct.dt.strftime('%Y-%m-%d %H') =='2021-11-01 15']
start = channel.loc[channel.ct.dt.strftime('%Y-%m-%d %H') =='2021-10-03 03']
end_df = end[['channelname','subcnt']].reset_index(drop=True)
start_df = start[['channelname','subcnt']].reset_index(drop=True)
end_df.columns = ['channelname','end_sub']
start_df.columns = ['channelname','start_sub']
tt = pd.merge(start_df,end_df)
tt['del'] = tt['end_sub'] - tt['start_sub']
result = tt[['channelname','del']]
display(result)
#strftime(형태) : 형태로 맞게 바꾼다는 내용
각 비디오는 10분 간격으로 구독자수, 좋아요, 싫어요수, 댓글수가 수집된것으로 알려졌다.
공범 EP1의 비디오정보 데이터중 수집간격이 5분 이하, 20분이상인 데이터 구간( 해당 시점 전,후) 의 시각을 모두 출력하라
import datetime
ep_one = video.loc[video.videoname.str.contains('1')].sort_values('ct').reset_index(drop=True)
ep_one[
(ep_one.ct.diff(1) >=datetime.timedelta(minutes=20)) | (엔터)
(ep_one.ct.diff(1) <=datetime.timedelta(minutes=5))
]
answer = ep_one[ep_one.index.isin([720,721,722,723,1635,1636,1637])]
display(answer)
#diff는 바로앞에 데이터와의 차이
각 에피소드의 시작날짜(년-월-일)를 에피소드 이름과 묶어 데이터 프레임으로 만들고 출력하라
start_date = video.sort_values(['ct','videoname']).drop_duplicates('videoname')[['ct','videoname']]
start_date
start_date['date'] = start_date.ct.dt.date
answer = start_date[['date','videoname']]
display(answer)
“공범” 컨텐츠의 경우 19:00시에 공개 되는것으로 알려져있다.
공개된 날의 21시의 viewcnt, ct, videoname 으로 구성된 데이터 프레임을 viewcnt를 내림차순으로 정렬하여 출력하라
video['time']= video.ct.dt.hour
answer = video.loc[video['time'] ==21] \
.sort_values(['videoname','ct'])\
.drop_duplicates('videoname') \
.sort_values('viewcnt',ascending=False)[['videoname','viewcnt','ct']]\
.reset_index(drop=True)
display(answer)
video 정보의 가장 최근 데이터들에서 각 에피소드의 싫어요/좋아요 비율을 ratio 컬럼으로 만들고
videoname, ratio로 구성된 데이터 프레임을 ratio를 오름차순으로 정렬하라
target = video.sort_values('ct').drop_duplicates('videoname',keep='last')
target['ratio'] =target['dislikecnt'] / target['likecnt']
answer = target.sort_values('ratio')[['videoname','ratio']].reset_index(drop=True)
answer
2021-11-01 00:00:00 ~ 15:00:00까지 각 에피소드별 viewcnt의 증가량을 데이터 프레임으로 만드시오
start = pd.to_datetime("2021-11-01 00:00:00")
end = pd.to_datetime("2021-11-01 15:00:00")
target = video.loc[(video["ct"] >= start) & (video['ct'] <= end)].reset_index(drop=True)
def check(x):
result = max(x) - min(x)
return result
answer = target[['videoname','viewcnt']].groupby("videoname").agg(check)
answer
video 데이터 중에서 중복되는 데이터가 존재한다. 중복되는 각 데이터의 시간대와 videoname 을 구하여라
answer = video[video.index.isin(set(video.index) - set(video.drop_duplicates().index))]
result = answer[['videoname','ct']]
display(result)
#set(video.index)는 video의 모든 index를 보여주는 것
Q21~40
주어진 전체 기간의 각 나라별 골득점수 상위 5개 국가와 그 득점수를 데이터프레임형태로 출력하라
result = df.groupby('Country', as_index=False)['Goals'].sum().sort_values(by=['Goals'],ascending=False).head()
display(result)
주어진 전체기간동안 골득점을 한 선수가 가장 많은 나라 상위 5개 국가와 그 선수 숫자를 데이터 프레임 형식으로 출력하라
result = df.groupby('Country').size().sort_values(ascending=False).head(5)
print(result)
Years 컬럼은 년도 -년도 형식으로 구성되어있고,
각 년도는 4자리 숫자이다. 년도 표기가 4자리 숫자로 안된 케이스가 존재한다. 해당 건은 몇건인지 출력하라
df['yearLst'] = df.Years.str.split('-')
def checkFour(x):
for value in x:
if len(str(value)) != 4:
return False
return Truedf['check'] = df['yearLst'].apply(checkFour)
result = len(df[df.check ==False])
result
위 문제에서 발생한 예외 케이스를 제외한 데이터프레임을 df2라고 정의하고 데이터의 행의 숫자를 출력하라
(아래 문제부터는 df2로 풀이하겠습니다)
df2 = df[df.check ==True].reset_index(drop=True)
print(df2.shape[0])
월드컵 출전횟수를 나타내는 ‘LenCup’ 컬럼을 추가하고 4회 출전한 선수의 숫자를 구하여라
df2['LenCup'] =df2['yearLst'].str.len()
result = df2['LenCup'].value_counts()[4]
print(result)
Yugoslavia 국가의 월드컵 출전횟수가 2회인 선수들의 숫자를 구하여라
result = len(df2[(df2.LenCup==2) & (df2.Country =='Yugoslavia')])
print(result)
2002년도에 출전한 전체 선수는 몇명인가?
result =len(df2[df2.Years.str.contains('2002')])
print(result)
이름에 ‘carlos’ 단어가 들어가는 선수의 숫자는 몇 명인가? (대, 소문자 구분 x)
result = len(df2[df2.Player.str.lower().str.contains('carlos')])
print(result)
#lower()는 문자를 모두 소문자로 바꾼다는 뜻
월드컵 출전 횟수가 1회뿐인 선수들 중에서 가장 많은 득점을 올렸던 선수는 누구인가?
result = df2[df2.LenCup==1].sort_values('Goals',ascending=False).Player.values[0]
print(result)
월드컵 출전횟수가 1회 뿐인 선수들이 가장 많은 국가는 어디인가?
result= df2[df2.LenCup==1].Country.value_counts().index[0]
print(result)
대여일자별 데이터의 수를 데이터프레임으로 출력하고, 가장 많은 데이터가 있는 날짜를 출력하라
result = df['대여일자'].value_counts().sort_index().to_frame()
answer = result[result.대여일자 == result.대여일자.max()].index[0]
print(answer)
각 일자의 요일을 표기하고 (‘Monday’ ~’Sunday’) ‘day_name’컬럼을 추가하고
이를 이용하여 각 요일별 이용 횟수의 총합을 데이터 프레임으로 출력하라
df['대여일자'] = pd.to_datetime(df['대여일자'])
df['day_name'] = df['대여일자'].dt.day_name()
result = df.day_name.value_counts().to_frame()
result
#데이터 프레임화 하라고 했기 때문에 to_frame()을 적어준다.
각 요일별 가장 많이 이용한 대여소의 이용횟수와 대여소 번호를 데이터 프레임으로 출력하라
result = df.groupby(['day_name','대여소번호']).size().to_frame('size').sort_values(['day_name','size'],ascending=False).reset_index()
answer = result.drop_duplicates('day_name',keep='first').reset_index(drop=True)
display(answer)
나이대별 대여구분 코드의 (일일권/전체횟수) 비율을 구한 후 가장 높은 비율을 가지는 나이대를 확인하라.
일일권의 경우 일일권 과 일일권(비회원)을 모두 포함하라
daily = df[df.대여구분코드.isin(['일일권','일일권(비회원)'])].연령대코드.value_counts().sort_index()
total = df.연령대코드.value_counts().sort_index()
ratio = (daily /total).sort_values(ascending=False)
print(ratio)
print('max ratio age ',ratio.index[0])
나이대별 이동거리의 평균을 구하여라
result = df[['연령대코드','이동거리']].groupby(['연령대코드']).mean()
print(result)
연령대 코드가 20대인 데이터를 추출하고,이동거리값이 추출한 데이터의 이동거리값의 평균 이상인 데이터를 추출한다.
최종 추출된 데이터를 대여일자, 대여소 번호 순서로 내림차순 정렬 후 1행부터 200행까지의 탄소량의 평균을 소숫점 3째 자리까지 구하여라
tw = df[df.연령대코드 =='20대'].reset_index(drop=True)
tw_mean = tw[tw.이동거리 >= tw.이동거리.mean()].reset_index(drop=True)
tw_mean['탄소량'] =tw_mean['탄소량'].astype('float')
target =tw_mean.sort_values(['대여일자','대여소번호'], ascending=False).reset_index(drop=True).iloc[:200].탄소량
result = round(target.sum()/len(target),3)
print(result)
6월 7일 ~10대의 “이용건수”의 중앙값은?
df['대여일자'] =pd.to_datetime(df['대여일자'])
result = df[(df.연령대코드 =='~10대') & (df.대여일자 ==pd.to_datetime('2021-06-07'))].이용건수.median()
print(result)
평일 (월~금) 출근 시간대(오전 6,7,8시)의 대여소별 이용 횟수를 구해서 데이터 프레임 형태로 표현한 후
각 대여시간별 이용 횟수의 상위 3개 대여소와 이용횟수를 출력하라
target = df[(df.day_name.isin(['Tuesday', 'Wednesday', 'Thursday', 'Friday','Monday'])) & (df.대여시간.isin([6,7,8]))]
result = target.groupby(['대여시간','대여소번호']).size().to_frame('이용 횟수')
answer = result.sort_values(['대여시간','이용 횟수'],ascending=False).groupby('대여시간').head(3)
display(answer)
이동거리의 평균 이상의 이동거리 값을 가지는 데이터를 추출하여 추출데이터의 이동거리의 표본표준편차 값을 구하여라
result = df[df.이동거리 >= df.이동거리.mean()].reset_index(drop=True).이동거리.std()
print(result)
남성(‘M’ or ‘m’)과 여성(‘F’ or ‘f’)의 이동거리값의 평균값을 구하여라
df['sex'] = df['성별'].map(lambda x: '남' if x in ['M','m'] else '여')
answer = df[['sex','이동거리']].groupby('sex').mean()
display(answer)
Q41~60
데이터는 2018년도와 2019년도의 전세계 행복 지수를 표현한다.
각년도의 행복랭킹 10위를 차지한 나라의 행복점수의 평균을 구하여라
result = df[df.행복랭킹 ==10]['점수'].mean()
print(result)
데이터는 2018년도와 2019년도의 전세계 행복 지수를 표현한다.
각년도의 행복랭킹 50위이내의 나라들의 각각의 행복점수 평균을 데이터프레임으로 표시하라
result = df[df.행복랭킹<=50]['년도','점수']].groupby('년도').mean()
print(result)
2018년도 데이터들만 추출하여 행복점수와 부패에 대한 인식에 대한 상관계수를 구하여라
result = df[df.년도 ==2018]['점수','부패에 대한인식']].corr().iloc[0,1]
print(result)
2018년도와 2019년도의 행복랭킹이 변화하지 않은 나라명의 수를 구하여라
result = len(df[['행복랭킹','나라명']]) - len(df[['행복랭킹','나라명']].drop_duplicates())
print(result)
2019년도 데이터들만 추출하여 각변수간 상관계수를 구하고 내림차순으로 정렬한 후 상위 5개를 데이터 프레임으로 출력하라.
컬럼명은 v1,v2,corr으로 표시하라
zz = df[df.년도 ==2019].corr().unstack().to_frame().reset_index().dropna()
result = zz[zz[0] !=1].sort_values(0,ascending=False).drop_duplicates(0)
answer = result.head(5).reset_index(drop=True)
answer.columns = ['v1','v2','corr']
display(answer)
각 년도별 하위 행복점수의 하위 5개 국가의 평균 행복점수를 구하여라
result = df.groupby('년도').tail(5).groupby('년도').mean()[['점수']]
print(result)
2019년 데이터를 추출하고 해당데이터의 상대 GDP 평균 이상의 나라들과 평균 이하의 나라들의 행복점수 평균을 각각 구하고 그 차이값을 출력하라
df2 = df[df['년도'] == 2019]
over = df2[df2.상대GDP >= df2.상대GDP.mean()]['점수'].mean()
under = df2[df2.상대GDP <= df2.상대GDP.mean()]['점수'].mean()
result= over - under
print(result)
각년도의 부패에 대한인식을 내림차순 정렬했을때 상위 20개 국가의 부패에 대한인식의 평균을 구하여라
result = df.sort_values(['년도','부패에 대한인식'],ascending=False).groupby('년도').head(20).groupby(['년도']).mean()[['부패에 대한인식']]
print(result)
2018년도 행복랭킹 50위 이내에 포함됐다가 2019년 50위 밖으로 밀려난 국가의 숫자를 구하여라
result = set(df[(df.년도==2018) & (df.행복랭킹 <=50)].나라명) -set(df[(df.년도==2019) & (df.행복랭킹 <=50)].나라명)
answer = len(result)
print(answer)
2018년,2019년 모두 기록이 있는 나라들 중 년도별 행복점수가 가장 증가한 나라와 그 증가 수치는?
count = df.나라명.value_counts()
target = count[count>=2].index
df2 =df.copy()
multiple = df2[df2.나라명.isin(target)].reset_index(drop=True)
multiple.loc[multiple['년도']==2018,'점수'] = multiple[multiple.년도 ==2018]['점수'].values * (-1)
result = multiple.groupby('나라명').sum()['점수'].sort_values().to_frame().iloc[-1]
result
DateTime컬럼을 통해 각 월별로 몇개의 데이터가 있는지 데이터 프레임으로 구하여라
df['DateTime'] = pd.to_datetime(df['DateTime'])
result = df['DateTime'].dt.month.value_counts().sort_index().to_frame()
print(result)
3월달의 각 시간대별 온도의 평균들 중 가장 낮은 시간대의 온도를 출력하라
target = df[df.DateTime.dt.month ==3]
result = target.groupby(target.DateTime.dt.hour)['Temperature'].mean().sort_values().values[0]
print(result)
3월달의 각 시간대별 온도의 평균들 중 가장 높은 시간대의 온도를 출력하라
target = df[df.DateTime.dt.month ==3]
result = target.groupby(target.DateTime.dt.hour)['Temperature'].mean().sort_values().values[-1]
print(result)
Zone 1 Power Consumption 컬럼의 value값의 크기가 Zone 2 Power Consumption 컬럼의 value값의 크기보다 큰 데이터들의 Humidity의 평균을 구하여라
result = df[df['Zone 1 Power Consumption'] > df['Zone 2 Power Consumption']].Humidity.mean()
print(result)
각 zone의 에너지 소비량의 상관관계를 구해서 데이터 프레임으로 표기하라
result = df.iloc[:,-3:].corr()
display(result)
Temperature의 값이 10미만의 경우 A, 10이상 20미만의 경우 B,20이상 30미만의 경우 C, 그 외의 경우 D라고 할때 각 단계의 데이터 숫자를 구하여라
def split_data(x):
if x<10:
return "A"
elif x<20:
return 'B'
elif x<30:
return 'C'
else:
return 'D'
df['sp'] = df.Temperature.map(split_data)
result = df['sp'].value_counts()
display(result)
6월 데이터중 12시의 Temperature의 표준편차를 구하여라
result =df[(df.DateTime.dt.month ==6) & (df.DateTime.dt.hour ==12)].Temperature.std()
print(result)
6월 데이터중 12시의 Temperature의 분산을 구하여라
result =df[(df.DateTime.dt.month ==6) & (df.DateTime.dt.hour ==12)].Temperature.var()
print(result)
Temperature의 평균이상의 Temperature의 값을 가지는 데이터를 Temperature를 기준으로 정렬 했을때
4번째 행의 Humidity 값은?
result = df[df.Temperature >= df.Temperature.mean()].sort_values('Temperature').Humidity.values[3]
print(result)
Temperature의 중간값 이상의 Temperature의 값을 가지는 데이터를Temperature를 기준으로 정렬 했을때 4번째 행의 Humidity 값은?
result = df[df.Temperature >= df.Temperature.median()].sort_values('Temperature').Humidity.values[3]
print(result)
Q61~80
Legendary 컬럼은 전설포켓몬 유무를 나타낸다.전설포켓몬과 그렇지 않은 포켓몬들의 HP평균의 차이를 구하여라
target = df.groupby('Legendary')['HP'].mean()
result = target.values[1] -target.values[0]
print(result)
Type 1은 주속성 Type 2 는 부속성을 나타낸다. 가장 많은 부속성 종류는 무엇인가?
result = df['Type 2'].value_counts().index[0]
print(result)
가장 많은 Type 1 의 종의 평균 Attack 을 평균 Defense로 나눈값은?
Max = df['Type 1'].value_counts().index[0]
result = df[df['Type 1']== Max].Attack.mean() /df[df['Type 1']== Max].Defense.mean()
print(result)
포켓몬 세대(Generation) 중 가장많은 Legendary를 보유한 세대는 몇세대인가?
result =df[df.Legendary==True].Generation.value_counts().index[0]
result
‘HP’, ‘Attack’, ‘Defense’, ‘Sp. Atk’, ‘Sp. Def’, ‘Speed’ 간의 상관 계수중 가장 절댓값이 큰 두 변수와 그 값을 구하여라
target = df[[ 'HP', 'Attack', 'Defense', 'Sp. Atk', 'Sp. Def', 'Speed']]
.corr().unstack().reset_index().rename(columns={0: "corr"})
result = target[target['corr']!=1].sort_values('corr',ascending=False).iloc[0]
print(result)
#corr은 자기자신값인 1은 빼야한다.
각 Generation의 Attack으로 오름차순 정렬시 상위 3개 데이터들(18개)의 Attack의 전체 평균을 구하여라
result = df.sort_values(['Generation','Attack']).groupby('Generation').head(3).Attack.mean()
print(result)
각 Generation의 Attack으로 내림차순 정렬시 상위 5개 데이터들(30개)의 Attack의 전체 평균을 구하여라
result = df.sort_values(['Generation','Attack'],ascending=False).groupby('Generation').head(5).Attack.mean()
print(result)
주속성(Type 1)별 포켓몬의 평균 HP는 얼마인가?
answer = df.groupby('Type 1')['HP'].mean().sort_values(ascending=False)
answer
주속성(Type 1) 중 평균 특수공격력(Sp. Atk)이 가장 높은 속성은 무엇인가?
highest_sp_atk_type = df.groupby('Type 1')['Sp. Atk'].mean().idxmax()
highest_sp_atk_type
#idxmax()는 값들중에 가장큰 index를 가져오는 것
부속성(Type 2)이 없는 포켓몬은 몇 마리인가?
count_no_secondary_type = df['Type 2'].isna().sum()
count_no_secondary_type
전체데이터의 수축기혈압(최고) - 이완기혈압(최저)의 평균을 구하여라
result = (df['수축기혈압(최고) : mmHg'] - df['이완기혈압(최저) : mmHg']).mean()
print(result)
50~59세의 신장평균을 구하여라
result = df[(df.측정나이 <60) & (df.측정나이>=50)].iloc[:,2].mean()
print(result)
연령대 (20~29 : 20대 …) 별 인원수를 구하여라
df['연령대'] =df.측정나이 //10 *10
result = df['연령대'].value_counts()
print(result)
연령대 (20~29 : 20대 …) 별 등급의 숫자를 데이터 프레임으로 표현하라
result = df.groupby(['연령대','등급'],as_index=False).size()
print(result)
남성 중 A등급과 D등급의 체지방률 평균의 차이(큰 값에서 작은 값의 차)를 구하여라
result = abs(df[(df.측정회원성별 =='M') &(df.등급 =='A')].iloc[:,4].mean() -df[(df.측정회원성별 =='M') &(df.등급 =='D')].iloc[:,4].mean())
print(result)
#iloc[:,4] = 4번째 칼럼 = 체지방률 칼럼
여성 중 A등급과 D등급의 체중의 평균의 차이(큰 값에서 작은 값의 차)를 구하여라
result = abs(df[(df.측정회원성별 =='F') &(df.등급 =='A')].iloc[:,3].mean() -df[(df.측정회원성별 =='F') &(df.등급 =='D')].iloc[:,3].mean())
print(result)
bmi는 자신의 몸무게(kg)를 키의 제곱(m)으로 나눈값이다. 데이터의 bmi 를 구한 새로운 컬럼을 만들고 남성의 bmi 평균을 구하기
df['bmi'] = df['체중 : kg'] / (df['신장 : cm']/100) **2
result = df[df.측정회원성별 =='M'].bmi.mean()
bmi보다 체지방율이 높은 사람들의 체중평균을 구하여라
result =df[df.bmi <df['체지방율 : %']]['체중 : kg'].mean()
print(result)
남성과 여성의 악력 평균의 차이를 구하여라
target= df.groupby('측정회원성별')['악력D : kg'].mean()
result = target.M - target.F -> target['M'] - target['F']도 됌
print(result)
남성과 여성의 교차윗몸일으키기 횟수의 평균의 차이를 구하여라
target= df.groupby('측정회원성별')['교차윗몸일으키기 : 회'].mean()
result = target.M - target.F
print(result)
Q81~100
여름철(6월,7월,8월) 이화동이 수영동보다 높은 기온을 가진 시간대는 몇개인가?
df.time = pd.to_datetime(df.time)
summer = df.loc[df.time.dt.month.isin([6,7,8])].reset_index(drop=True)
answer = len(summer.loc[summer['이화동기온'] > summer['수영동기온']])
print(answer)
이화동과 수영동의 최대강수량의 시간대를 각각 구하여라
answer1 = df.loc[df['이화동강수']==df['이화동강수'].max()].time.values
answer2 = df.loc[df['수영동강수']==df['수영동강수'].max()].time.values
print(answer1,answer2)
남성 이탈(Exited)이 가장 많은 국가(Geography)는 어디이고 이탈 인원은 몇명인가?
answer = df.loc[df.Gender=='Male'].groupby(['Geography'])['Exited'].sum().sort_values(ascending=False).head(1)
print(answer)
카드를 소유(HasCrCard ==1)하고 있으면서 활성멤버(IsActiveMember ==1) 인 고객들의 평균 나이를 소숫점이하 4자리까지 구하여라?
answer = df.loc[(df.HasCrCard==1) &(df.IsActiveMember==1)].Age.mean()
print(round(answer,4))
Balance 값이 중간값 이상을 가지는 고객들의 CreditScore의 표준편차를 소숫점이하 3자리까지 구하여라
answer =df.loc[df.Balance >= df.Balance.median()].CreditScore.std()
print(round(answer,3))
수축기혈압과 이완기 혈압기 수치의 차이를 새로운 컬럼(‘혈압차’) 으로 생성하고,
연령대 코드별 각 그룹 중 ‘혈압차’ 의 분산이 5번째로 큰 연령대 코드를 구하여라
df['혈압차'] =df['수축기혈압'] -df['이완기혈압']
answer = df.groupby('연령대코드(5세단위)')['혈압차'].var().sort_values()
print(answer.index[-5])
비만도를 나타내는 지표인 WHtR는 허리둘레 / 키로 표현한다. 일반적으로 0.58이상이면 비만으로 분류한다.
데이터중 WHtR 지표상 비만인 인원의 남/여 비율을 구하여라
df['비만']=df['허리둘레']/df['신장(5Cm단위)']
data = df.loc[df['비만']>=0.58].성별코드.value_counts()
answer = data['M']/data['F']
print(answer)
Vehicle_Age 값이 2년 이상인 사람들만 필터링 하고 그중에서 Annual_Premium 값이 전체 데이터의 중간값 이상인 사람들을 찾고, 그들의 Vintage값의 평균을 구하여라
answer = df[(df['Vehicle_Age']=='> 2 Years') & (df['Annual_Premium'] >= df['Annual_Premium'].median())]['Vintage'].mean()
print(answer)
vehicle_age에 따른 각 성별(gender)그룹의 Annual_Premium값의 평균을 구하여 아래 테이블과 동일하게 구현하라
meandf = df.groupby(['Gender','Vehicle_Age'],as_index = False)['Annual_Premium'].mean()
meandf.pivot(index='Vehicle_Age',columns='Gender',values='Annual_Premium')
price_range 의 각 value를 그룹핑하여 각 그룹의 n_cores 의 빈도가 가장높은 value와 그 빈도수를 구하여라
answer =df[['price_range','n_cores']].groupby(['price_range','n_cores']).size().sort_values(0).groupby(level=0).tail(1)
answer
price_range 값이 3인 그룹에서 상관관계가 2번째로 높은 두 컬럼과 그 상관계수를 구하여라
cordf = df.loc[df['price_range']==3].corr().unstack().sort_values(ascending=False)
answer = cordf.loc[cordf!=1].reset_index().iloc[1]
print(answer)
Arrival Delay in Minutes 컬럼이 결측치인 데이터들 중 satisfaction col에서‘neutral or dissatisfied’ 보다 ‘satisfied’의 수가 더 높은 Class는 어디 인가?
answer =df.loc[df['Arrival Delay in Minutes'].isnull()].groupby(['Class','satisfaction'],as_index=False).size().pivot(index='Class',columns='satisfaction')
result =answer[answer['size']['neutral or dissatisfied'] < answer['size']['satisfied']]
result
#answer는 멀티인덱스여서 2번 접근해야한다.
ph값은 상당히 많은 결측치를 포함한다. 결측치를 제외한 나머지 데이터들 중 사분위값 기준 하위 25%의 값들의 평균값은?
target = df['ph'].dropna()
answer =target.loc[target <= target.quantile(0.25)].mean()
print(answer)
#quantile(0.25) = 하위 25퍼센트 값들 표현
흡연자와 비흡연자 각각 charges의 상위 10% 그룹의 평균의 차이는?
high = train.loc[train.smoker =='yes'].charges.quantile(0.9)
high2 = train.loc[train.smoker =='no'].charges.quantile(0.9)
mean_yes = train.loc[(train.smoker =='yes') &(train.charges >=high)].charges.mean()
mean_no = train.loc[(train.smoker =='no') &(train.charges >=high2)].charges.mean()
answer = mean_yes - mean_no
print(answer)
bedrooms 의 빈도가 가장 높은 값을 가지는 데이터들의 price의 상위 10%와 하위 10%값의 차이를 구하여라
answer1 = df.loc[df.bedrooms ==df.bedrooms.value_counts().index[0]].price.quantile(0.9)
answer2 = df.loc[df.bedrooms ==df.bedrooms.value_counts().index[0]].price.quantile(0.1)
print(answer1 - answer2)
Serial No. 컬럼을 제외하고 ‘Chance of Admit’을 종속변수, 나머지 변수를 독립변수라 할때,
랜덤포레스트를 통해 회귀 예측을 할 떄 변수중요도 값을 출력하라 (시드값에 따라 순서는 달라질수 있음)
from sklearn.ensemble import RandomForestRegressor
df_t = df.drop([df.columns[0]],axis=1)
x = df_t.drop([df.columns[-1]],axis=1)
y = df_t[df.columns[-1]]
ml = RandomForestRegressor()
ml.fit(x,y)
result=pd.DataFrame({'importance':ml.featureimportances},x.columns).sort_values('importance',ascending=False)
display(result)
quality 값이 3인 그룹과 8인 데이터그룹의 각 컬럼별 독립변수의 표준편차 값의 차이를 구할때 그값이 가장 큰 컬럼명을 구하여라
answer = (df.loc[df.quality ==8].std() -df.loc[df.quality ==3].std()).sort_values().index[-1]
print(answer)
남성들의 연령대별 (10살씩 구분 0-9세, 10-19세 …) Na_to_K값의 평균값을 구해서 데이터 프레임으로 표현하여라
pre = df.loc[df.Sex=='M']
pre2= pre.copy()
pre2['Age2'] = pre.Age//10 *10
answer =pre2.groupby('Age2')['Na_to_K'].mean().to_frame()
display(answer)
데이터의 Risk 값에 따른 score_a와 score_b의 평균값을 구하여라
answer =df.groupby('Risk')[['Score_A','Score_B']].mean()
display(answer)
pose값에 따른 각 motion컬럼의 중간값의 가장 큰 차이를 보이는 motion컬럼은 어디이며 그값은?
t= df.groupby('pose').median().T
dfs = abs(t[0] - t[1]).sort_values().reset_index()
dfs[dfs[0] ==dfs[0].max()]['index'].values
#median().T 에서 .T는 행과 열을 바꾸는 것이다 -> 보기 쉽게 바꾼것
#abs는 절대값을 씌운다는 뜻
Q101 ~ 114
정보(row수)가 가장 많은 상위 3차종(model)의 price값의 각 평균값은?
answer =df.loc[df.model.isin(df.model.value_counts().index[:3])].groupby('model')['price'].mean().to_frame()
display(answer)
Outcome 값에 따른 각 그룹의 각 컬럼의 평균 차이를 구하여라
answer = df.groupby('Outcome').mean().diff().iloc[1,:]
print(answer)
매년 5월달의 open가격의 평균값을 데이터 프레임으로 표현하라
df['Date'] =pd.to_datetime(df['Date'])
target = df.groupby(df['Date'].dt.strftime('%Y-%m')).mean()
answer = target.loc[target.index.str.contains('-05')].Open
print(answer)
Tm 컬럼은 각 팀의 이름을 의미한다. TOR팀의 평균나이를 소수 4째 자리까지 구하여라
result = round(df[df.Tm =='TOR'].Age.mean(),4)
print(result)
Pos 컬럼은 포지션을 의미한다. 전체 선수 중 최소나이대의 선수들을 필터하고 그들 중 가장 많은 포지션은 무엇인지 확인하라
result = df[df.Age==df.Age.min()].Pos.value_counts().index[0]
print(result)
선수들의 이름은 first_name+ 공백 + last_name으로 이루어져 있다. 가장 많은 first_name은 무엇이며 몇 회 발생하는지 확인
result= df['Player'].str.split().str[0].str.lower().value_counts().index[0]
print(result)
PTS컬럼은 경기당 평균득점수 이다. 각포지션별로 경기당 평균득점수의 평균을 구하여라
result = df.groupby('Pos')['PTS'].mean().sort_values()
print(result)
#df.groupby('Pos')['PTS'].mean() 로도 구할 수 있음
G컬럼은 참여한 경기의 숫자이다. 각 팀별로 가장 높은 경기참여 수를 가진 선수들의 경기 참여 숫자의 평균을 구하여라
result = df.sort_values(['Tm','G']).groupby('Tm').tail(1).G.mean()
print(result)
Tm의 값이 MIA이며 Pos는 C또는 PF인 선수의 MP값의 평균은?
result = df[(df.Tm =='MIA') & (df.Pos.isin(['C','PF']))].MP.mean()
print(result)
전체 데이터중 G의 평균값의 1.5배 이상인 데이터들만 추출했을때 3P값의 평균은?
result = df[df.G >= df.G.mean()*1.5]['3P'].mean()
print(result)
Age의 평균 이상인 그룹과 평균 미만인 그룹간의 G값의 평균의 차이는?
result = df[df.Age >= df.Age.mean()].G.mean() - df[df.Age < df.Age.mean()].G.mean()
print(result)
평균나이가 가장 젊은 팀은 어디인가
result = df.groupby('Tm')['Age'].mean().sort_values().index[0]
print(result)
Pos그룹별 평균 MP값을 구하여라
result = df.groupby('Pos')['MP'].mean()
print(result)
- 데이터 헨들링 ( 주로 쓰는 것들 )
#Data 형태 확인
df.shape
#Data type 확인
df.info()
#Null 값 확인
df.isnull().sum()
len(df['col'].unique())
df['col'].unique()
#Unique한 value별 카운팅
import numpy as np
import pandas as pd
df.replace(-200, np.NaN)
#dataframe 특정값 치환
import numpy as np
df.fillna(method='ffill')
#Null값 이전 값으로 채워넣기
import pandas as pd
df = df[['col1', 'col2']]
#DataFrame 특정 col만 가져오기
import pandas as pd
df[ (df['T'] >= 25) & (df['T'] <= 27) ]
#조건에 맞는 dataframe 출력
import pandas as pd
df['col'].sort_values(ascending=False)
#ascending = False(내림차순), default(오름차순)
df[df['col'].astype(str).str.contains('text')]
#특정값이 포함된 Data 찾기
import numpy as np
np.where(df['col'] <= 5,1,0)
#특정 조건 만족하는 값 변경하기
import numpy as np
import pandas as pd
df['y'].groupby(df['job']).value_counts()
#group by 활용 카운팅
import pandas as pd
df_job = pd.pivot_table(df_job, # 피벗할 데이터프레임
index = 'index', # 행 위치에 들어갈 열
columns = 'col', # 열 위치에 들어갈 열
values = 'value') # 데이터로 사용할 열
#pivot table 활용 데이터 처리
import numpy as np
import pandas as pd
df['col'].replace([np.inf, -np.inf], np.nan)
#inf(무한대) 데이터 null 처리
import numpy as np
import pandas as pd
df['col'].shift(1)
#+ n : 순방향, - n : 역방향 lag 데이터 생성
import numpy as np
import pandas as pd
df.drop_duplicates(['col'], keep = 'first', inplace=True)
#중복 데이터 처리
import numpy as np
import pandas as pd
df['col'].str.lstrip()
#문자열 데이터 앞 공백 제거
import datetime
df["Date"].dt.strftime("%Y-%m")
#날짜 데이터 형식 변경
import pandas as pd
all_list = list(df['start']) + list(df['end'])
unique_list = set(all_list)
#list 중복 없애기
- 데이터 시각화 ( 주로 쓰는 것들 )
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
plt.style.use(['dark_background'])
sns.displot(df['col']);
#displot 활용 분포 그리기
print("col :", df['col'].mean())
#분포의 평균도 같이 출력
#연속형 변수 분포 확인
import matplotlib.pyplot as plt
#(20, 5) → 가로 inch, 세로 inch
plt.gcf().set_size_inches(20, 5)
#plot size 조절
import seaborn as sns
#x(가로), y(세로), hue(구분자)
sns.scatterplot(x=df['x'], y=df['y'], hue = df['hue'], data=df)
#산점도 그리기( 많이 씀 )★
import matplotlib.pyplot as plt
plt.plot(df['x'], df['y'], label='label')
#기본 line plot 그리기 ( 자주 씀 )★
import matplotlib.pyplot as plt
#데이터에 i번째 데이터부터 출력
for i in range(1,13):
plt.subplot(3,4,i)
plt.grid(False)
sns.distplot(df.iloc[:,i])
plt.gcf().set_size_inches(20, 10)
plt.tight_layout()
plt.show()
#for문 활용하여 distplot 다중 출력
import matplotlib.pyplot as plt
fig, ax1 = plt.subplots()
ax1.plot(df['x'], df['y'], color='green', label='label1')
ax2 = ax1.twinx()
ax2.plot(df['x'], df['y'], color='deeppink', label='label2')
fig.legend()
plt.gcf().set_size_inches(25, 5)
plt.show()
#이중 축 그래프 그리기
import seaborn as sns
#모든 변수 조합에 관한 Scatter plot
df_pair = df[['col1', 'col2', 'col3', 'col4']]
sns.pairplot(df_pair)
plt.show()
#pairplot 상관관계 분석
import seaborn as sns
#모든 조합, 상관계수 표현
df_pair = df[['col1', 'col2', 'col3', 'col4']]
sns.heatmap(df_pair.corr(), vmin = -1, vmax = +1, annot = True, cmap = 'coolwarm');
#heat map 상관관계 분석 ( 많이 씀 ) ★
import seaborn as sns
import matplotlib.pyplot as plt
sns.scatterplot(data=df,x='x',y='y', s=50, linewidth=0);
#수직선 추가
plt.vlines(-2, ymin=-2, ymax=2, color='r', linewidth=2);
plt.vlines(2, ymin=-2, ymax=2, color='r', linewidth=2);
#수평선 추가
plt.hlines(-2, xmin=-2, xmax=2, color='r', linewidth=2);
plt.hlines(2, xmin=-2, xmax=2, color='r', linewidth=2);
#그래프에 수직,수평선 추가 및 길이 조절
import seaborn as sns
import matplotlib.pyplot as plt
%matplotlib inline
plt.style.use(['dark_background'])
sns.catplot(x="x", hue="y", kind="count",palette="pastel", edgecolor=".6",data=df);
plt.gcf().set_size_inches(25, 3)
#catplot 그리기 ( 범주형 변수에서 주로 사용 )
import numpy as np
import matplotlib.pyplot as plt
df['vol_color'] = np.where(df['Volume_issue']==1, 'red', 'gray')
colors=list(df['vol_color'])
print(colors)
plt.figure(figsize=(10, 8))
plt.subplot(2,1,1)
plt.plot(df['Date'], df['Close'], 'o-', ms=1, lw=0.5, label='Close')
plt.legend()
plt.subplot(2,1,2)
plt.bar(df['Date'], df['Volume'], label='volume', color=colors)
plt.legend()
#그래프에 특정 값에 색상 입히기
#barplot, order 옵션을 활용하여 가독성 Up
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
plt.style.use(['dark_background'])
sns.barplot(x='arrival_date_month', y='hotel', hue='arrival_date_year', data = df_reservation,
order = ['01.January', '02.February', '03.March', '04.April', '05.May', '06.June', '07.July', '08.August', '09.September', '10.October', '11.November', '12.December']);
plt.gcf().set_size_inches(20, 5);
#bar plot 그리기
- 데이터 분석 및 모델링 ( 자주 쓰는 것 ) - 머신러닝
#모델링을 학습하기 위한 Feature(X)와 Y데이터를 구분하는 단계
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn import metrics
X=df_merge.drop(['y'], axis=1)
Y=df_merge['y']
x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=0.3, stratify=Y)
print(x_train.shape)
print(y_train.shape)
print(x_test.shape)
print(y_test.shape)
#Train/Test set 분할
from sklearn.ensemble import RandomForestClassifier
#모델 학습
rfc = RandomForestClassifier(random_state=123456)
rfc.fit(x_train, y_train)
#예측
#예측은 학습에 사용된 Data와 Test Data 모두 예측하고 평가함(※ 과적합 여부 판별)
y_pred_train = rfc.predict(x_train)
y_pred_test = rfc.predict(x_test)
#모델 학습 및 예측
from sklearn.metrics import classification_report
print(classification_report(y_train, y_pred_train))
print(classification_report(y_test, y_pred_test))
#이진분류 모델 성능 확인
from sklearn.ensemble import RandomForestClassifier
from sklearn.modelselection import GridSearchCV
params = { 'n_estimators' : [400, 500],
'max_depth' : [6, 8, 10, 12]
}
#RandomForestClassifier 객체 생성 후 GridSearchCV 수행
rf_clf = RandomForestClassifier(random_state = 123456, n_jobs = -1)
grid_cv = GridSearchCV(rf_clf, param_grid = params, cv = 3, n_jobs = -1, scoring='recall')
grid_cv.fit(x_train, y_train)
print('최적 하이퍼 파라미터: ', grid_cv.best_params)
print('최고 예측 정확도: {:.4f}'.format(gridcv.best_score))
#하이퍼 파라미터 튜닝
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
plt.style.use(['dark_background'])
#rfc → 생성한 Model에 name 기재
ftrimportances_values = rfc.feature_importances
ftr_importances = pd.Series(ftr_importances_values, index = x_train.columns)
ftr_top20 = ftr_importances.sort_values(ascending=False)[:20]
plt.figure(figsize=(8,6))
plt.title('Feature Importances')
sns.barplot(x=ftr_top20, y=ftr_top20.index)
plt.show()
#중요 변수 파악(Feature Importance)
import pickle
#모델 저장
saved_model = pickle.dumps(model)
#모델 Read
model_from_pickle = pickle.loads(saved_model)
import scipy.stats as stats
stats.pearsonr(x=df['x'], y=df['y'])
#상관 계수 값 출력
#모델링을 학습하기 위한 Fearue(X)와 Y데이터를 구분하는 단계
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn import metrics
X=df.drop(['y'], axis=1)
Y=df['y']
x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=0.3)
print(x_train.shape)
print(y_train.shape)
print(x_test.shape)
print(y_test.shape)
#RandomForestRegressor 모델 학습
rfr = RandomForestRegressor()
rfr.fit(x_train, y_train)
#예측
#예측은 학습에 사용된 Data와 Test Data 모두 예측하고 평가함(※ 과적합 여부 판별)
import numpy as np
from sklearn.metrics import mean_absolute_error, r2_score
y_pred_train = rfr.predict(x_train)
y_pred_test = rfr.predict(x_test)
mse_train = mean_absolute_error(y_train, y_pred_train)
print('mse_train(mse): ', mse_train)
rmse_train = (np.sqrt(mse_train))
print('rmse_train(rmse): ', rmse_train)
r2_train = r2_score(y_train, y_pred_train)
print('rmse_train(r2): ', r2_train)
print('')
mse_test = mean_absolute_error(y_test, y_pred_test)
print('mse_test(mse): ', mse_test)
rmse_test = (np.sqrt(mse_test))
print('rmse_test(rmse): ', rmse_test)
r2_test = r2_score(y_test, y_pred_test)
print('rmse_test(r2): ', r2_test)
#회귀(Regressor) 모델 학습 및 평가
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
x = StandardScaler().fit_transform(x)
pca = PCA(n_components = 2)
principalComponents = pca.fit_transform(x)
principalDf = pd.DataFrame(data = principalComponents
, columns = ['principal component 1', 'principal component 2'])
#표준화 및 PCA 차원축소
#모델링을 학습하기 위한 Fearue(X)와 Y데이터를 구분하는 단계
from sklearn.model_selection import train_test_split
from sklearn import metrics
X=df.drop(['y'], axis=1)
Y=df['y']
x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=0.3)
print(x_train.shape)
print(y_train.shape)
print(x_test.shape)
print(y_test.shape)
#LR(선형회귀) 모델 활용
from sklearn.linear_model import LinearRegression
mlr = LinearRegression()
mlr.fit(x_train, y_train)
#예측
#예측은 학습에 사용된 Data와 Test Data 모두 예측하고 평가함(※ 과적합 여부 판별)
import numpy as np
from sklearn.metrics import mean_absolute_error, r2_score
y_pred_train = mlr.predict(x_train)
y_pred_test = mlr.predict(x_test)
#평가
mse_train = mean_absolute_error(y_train, y_pred_train)
print('mse_train(mse): ', mse_train)
rmse_train = (np.sqrt(mse_train))
print('rmse_train(rmse): ', rmse_train)
r2_train = r2_score(y_train, y_pred_train)
print('rmse_train(r2): ', r2_train)
print('')
mse_test = mean_absolute_error(y_test, y_pred_test)
print('mse_test(mse): ', mse_test)
rmse_test = (np.sqrt(mse_test))
print('rmse_test(rmse): ', rmse_test)
r2_test = r2_score(y_test, y_pred_test)
print('rmse_test(r2): ', r2_test)
#선형 회귀 활용 모델링
dfcoef = pd.DataFrame({'col':X.columns, 'coef':mlr.coef}).reset_index(drop=True)
df_coef
#선형 회귀 상관 계수 확인
#▶ 모델링을 학습하기 위한 Fearue(X)와 Y데이터를 구분하는 단계
import lightgbm as lgb
import numpy as np
from sklearn.model_selection import train_test_split
#데이터 세트로드
X = df.drop(['y'], axis=1)
Y = df['y']
#train/test split
x_train, x_test, y_train, y_test = train_test_split (X, Y, test_size = 0.3)
#데이터 세트를 적절한 LGB 형식으로 변환
d_train = lgb.Dataset (x_train, label = y_train)
#setting the parameters
params = {}
params [ 'learning_rate'] = 0.02
params [ 'boosting_type'] = 'gbdt' # GradientBoostingDecisionTree
params['objective'] = 'binary'
params [ 'metric' ] = 'binary_logloss' # metric for binary-class
params [ 'max_depth'] = 5
params [ 'num_leaves' ] = 32
params ['seed'] = 23456
#모델 학습
clf = lgb.train (params, d_train, 1000) # epocs에서 모델 훈련
from sklearn.metrics import classification_report
y_pred_train = clf.predict(x_train)
for i in range(0,len(y_pred_train)):
if y_pred_train[i]>=.5: # setting threshold to .5
y_pred_train[i]=1
else:
y_pred_train[i]=0
y_pred_test = clf.predict(x_test)
for i in range(0,len(y_pred_test)):
if y_pred_test[i]>=.5: # setting threshold to .5
y_pred_test[i]=1
else:
y_pred_test[i]=0
print(classification_report(y_train, y_pred_train))
print(classification_report(y_test, y_pred_test))
#Light gbm 활용 모델링
import numpy as np
import pandas as pd
#numeric, categorical value 나누기
numeric_list=[]
categoical_list=[]
for i in df.columns :
if df[i].dtypes == 'O' :
categoical_list.append(i)
else :
numeric_list.append(i)
#연속형,범주형 변수 list 나누기
from sklearn.metrics import roc_auc_score
y_pred_train_proba = rfc.predict_proba(x_train)[:, 1]
y_pred_test_proba = rfc.predict_proba(x_test)[:, 1]
roc_score_train = roc_auc_score(y_train, y_pred_train_proba)
roc_score_test = roc_auc_score(y_test, y_pred_test_proba)
print("roc_score_train :", roc_score_train)
print("roc_score_test :", roc_score_test)
#AUROC score 출력하기
from sklearn.preprocessing import LabelEncoder
for col in categoical_list:
print(col)
le = LabelEncoder()
le.fit(list(x_train[col].values) + list(x_test[col].values))
x_train[col] = le.transform(x_train[col])
x_test[col] = le.transform(x_test[col])
#Lable encoder 활용해서 범주형 데이터 처리
from sklearn.metrics import roc_curve
def roc_curve_plot(y_test , pred_proba_c1):
#임곗값에 따른 FPR, TPR 값을 반환 받음.
#FPR : 암환자가 아닌 환자를 암환자라고 잘 못 예측한 비율
#TPR : Recall
fprs , tprs , thresholds = roc_curve(y_test ,pred_proba_c1)
#ROC Curve를 plot 곡선으로 그림.
plt.plot(fprs , tprs, label='ROC')
# 가운데 대각선 직선을 그림.
plt.plot([0, 1], [0, 1], 'k--', label='Random', color='red')
#FPR X 축의 Scale을 0.1 단위로 변경, X,Y 축명 설정등
start, end = plt.xlim()
plt.xticks(np.round(np.arange(start, end, 0.1),2))
plt.xlim(0,1)
plt.ylim(0,1)
plt.xlabel('FPR( 1 - Sensitivity )')
plt.ylabel('TPR( Recall )')
plt.legend()
plt.show()roc_curve_plot(y_test, y_pred_test_proba)
#ROC 커브 그리기
from sklearn.preprocessing import minmax_scale
rfm['Recency'] = minmax_scale(rfm['Recency'], axis=0, copy=True)
#min-max scale 활용 정규화
