NAIAHD

**cartogram

=>데이터의 크기 등을 나타내기 위해서 지도의 면적을 왜곡해서 표현하는 그림

=>만드는 방식은 엑셀 등을 이용해서 지도를 그려내는 방식이 있고 일러스트레이터나 web의 svg(xml)를 이용해서 그린 후 svg를 추출하는 방법

 

**인구 소멸 지역을 나타내는 cartogram과 colorpleth( 단계구분도)

1.국가 통계 포털에서 인구정보를 다운로드

population_raw_data.xlsx

 

2.필요한 라이브러리를 import하고 그래프에서 한글을 사용하기 위한 설정을 하고 음수 표현을 위한 설정

 

#배열 자료구조(행렬 포함), 선형대구 ,과학 기술 계산을 위한 패키지

import numpy as np

#Series, DataFrame(자교구조), 기술 통계, 간단한 시각화를 위한 패키지

import pandas as pd

 

 

#시각화 기본 패키지

import matplotlib.pyplot as plt

 

#그래프에서 한글 처리를 위한 패키지

import platform

from matplotlib import font_manager, rc

 

#데이터 셋과 화려한 시각화를 위한 패키지

import seaborn as sns

#데이터 전처리를 위한 패키지

#sklearn 은 데이터셋과 전처리 그리고 머신러닝을 위한 패키지

from sklearn import preprocessing

 

#지도 시각화(단계 구분도 )를 위한 패키지

import folium

 

#그래프에서 한글 처리를 위한 설정

if platform.system() =='Windows':

    font_name = font_manager.FontProperties(fname = 'c:/windows/fonts/malgun.ttf').get_name()

    rc('font',family = font_name)

elif platform.system() == 'Darwin':

    rc('font', family = 'AppleGothic')

   

 

#음수 하용을 위한 설정

#마이나스를 unicode로 하지 말라는 것이다.

plt.rcParams['axes.unicode_minus'] = False

 

3. 엑셀 파일의 내용을 읽기

엑셀 파일 읽을 경우 셀 병합이 있는지

 

#3. 엑셀 파일의 내용을 읽기

population = pd.read_excel('./Desktop/data/population_raw_data.xlsx', header = 1)

print(population.head())

population.info()

 

 

 

4.결측치(NA, None, NULL, np.NaN)처리

=>컬럼 자체를 제거 , NA인 행만 제거 ,다른 값으로 치환(이전값, 이후값, 중간값, 평균 ,최빈값, 머신러닝의 결과 ~ 가장 정확할 가능성이 높지만 시간이 오래 걸림)

#이 엑셀 파일에서는 위와 항목이름이 같은 경우가 Na

#d이전 값으로 NA를 채우기

population.fillna(method='ffill',inplace = True)

print(population.head())

population.info()

 

 

 

5.컬럼이름 변경

=>데이터를 직접 다운로드를 받으면 컬럼이름이 사용하기 어려운 경우가 많습니다.

성별은 보통 -> sex, gender

통계청에는 rc-1 , rc-2(직업) 

자료랑 같이 보면서 해야 한다.컬럼이름을 확인해서 바꾸는 작업을 해야 한다.

통계 spss 등을 많이 사용한다. 한글 인식 잘 안되고 컬럼이름을 잘 확인하고 알기 쉬운 것으로 바꾸기

 

 

6.시도가 소계인 데이터를 제외하고 가져오기

#시도가 소계인 데이터를 제외

#제외를 할 때는 drop을 이용해서 삭제를 할 수 도 있고

#필터링을 할 수 도 있습니다.

# population['시도'] == '소계' 소계인것  찾아보기

# population['시도'] != '소계' 소계가 아닌 것 행을 삭제

population = population[(population['시도'] != '소계')]

print(population.head()) #소계가 없어진다.

 

 

7.항목컬럼을 구분으로 변경

#항목 컬럼을 구분으로 변경

population.rename(columns = {'항목':'구분'},inplace = True)

 

#셀의 값 변경

#구분이 총인구수(명) -> 합계

#구분이 남자인구수(명) -> 남자

#구분이 여자인구수(명) ->여자

population.loc[population['구분'] == '총인구수 (명)','구분' ] ='합계'

population.loc[population['구분'] =='남자인구수 (명)','구분'] ='남자'

population.loc[population['구분'] =='여자인구수 (명)','구분'] ='여자'

print(population['구분'].head())

 

7.청년과 노년을 분리하기 위해서 20- 39 까지의 합계와 65-100+까지의 합계를 새로운 컬럼으로 추가

#청년과 노년 층으로 새로운 컬럼을 추가

population['청년'] = population['20 - 24세'] +population['25 - 29세']+population['30 - 34세'] +population['35 - 39세']

 

population['노년'] = population['65 - 69세']+population['70 - 74세']+population['75 - 79세'] + population['80 - 84세'] +population['80 - 84세'] +population['80 - 84세'] +population['85 - 89세']+population['90 - 94세'] +population['95 - 99세']

 

print(population['청년'].head())

print(population['노년'].head())

 

 

8.피봇 테이블(행과 열을 설정해서 데이터의 기술 통계값을 확인) 생성

#8.피봇 테이블(행과 열을 설정해서 데이터의 기술 통계값을 확인) 생성

#광역시도와 시도별 그리고 구분 별로 청년과 노년의 값 확인

pop = pd.pivot_table(population, index = ['광역시도','시도'], columns ='구분', values=['인구수','청년','노년'])

print(pop.head())

 

9. 소별비율 컬럼을 생성해서 추가 - 청년층 여자 / 노년층 합계/ 2

#9. 소별비율 컬럼을 생성해서 추가 - 청년층 여자 / 노년층 합계/ 2

pop['소멸비율'] = pop['청년','여자'] /pop['노년','합계'] / 2

print(pop['소멸비율'].head())

 

10.소멸위기지역이라는 컬럼을 추가 - 소멸비율이 1.0 미만이면 True아니면 False

 

#소멸위기 지역이라는 컬럼을 추가 - 소멸비율 < 1.0 여부

pop['소멸위기지역'] = pop['소멸비율'] < 1.0

print(pop['소멸위기지역'])

print(pop[pop['소멸위기지역']==False].index.get_level_values(1))

 

 

계산식을 바뀌서 할 수 도 있다.  ==============>

pop['소멸비율'] = pop['청년','여자'] / (pop['노년','합계'] / 2)

print(pop['소멸비율'].head())

 

#소멸위기 지역이라는 컬럼을 추가 - 소멸비율 < 1.0 여부

pop['소멸위기지역'] = pop['소멸비율'] < 1.0

print(pop['소멸위기지역'])

print(pop[pop['소멸위기지역']==False].index.get_level_values(1))
==================================

 

10 . 인덱스로 설정되어 있는 광역시도와 시도를 일반 컬럼으로 전환

=>인덱스를 컬럼으로 만들고자 할 때는 인덱스를 제거하면 됩니다.

#인덱스 제거

pop.reset_index(inplace = True)

print(pop.head())

 

 

11.2단으로 구성된 컬럼이름을 하나의 컬럼이름 만들기

광역시도와 시도를 합쳐서 하나의 컬럼 만들기

#컬럼이름 만들기 - 컬럼이름이 2래벨로 되여 있어서 위 아래 레벨을 합치느느 작업

#0번 레벨하고 1번 레벨의 데이터를 합치기

tmp_columns = [pop.columns.get_level_values(0)[n] +

               pop.columns.get_level_values(1)[n]

               for n in range(0, len(pop.columns.get_level_values(0)))]

print(tmp_columns)

pop.columns = tmp_columns

print(pop.head())

12. 시도이름 만들기

=>광역시는 구별로 분류가 도어 있는데 광역시가 아닌데 구를 가진 곳은 분류가 안되어 있음

=> 이 작업은 행정구역을 알아야 함

#광역시가 아닌 곳 중에서 구를 가지고 있는 곳의 딕셔너리 만들기

si_name = [None] * len(pop)

 

tmp_gu_dict = {'수원':['장안구', '권선구', '팔달구', '영통구'],

'성남':['수정구', '중원구', '분당구'],

'안양':['만안구', '동안구'],

'안산':['상록구', '단원구'],

'고양':['덕양구', '일산동구', '일산서구'],

'용인':['처인구', '기흥구', '수지구'],

'청주':['상당구', '서원구', '흥덕구', '청원구'],

'천안':['동남구', '서북구'],

'전주':['완산구', '덕진구'],

'포항':['남구', '북구'],

'창원':['의창구', '성산구', '진해구', '마산합포구', '마산회원구'],

'부천':['오정구', '원미구', '소사구']}

 

#고성에 대한 처리

for n in pop.index:

    #광역시나 특별시 또는 자치시로 끝나지 않는

    if pop['광역시도'][n][-3:] not in ['광역시','특별시','자치시']:

        if pop['시도'][n][:-1] == '고성' and pop['광역시도'][n] =='강원도':

            si_name[n] ='고성(강원)'

        elif pop['시도'][n][:-1] == '고성' and pop['광역시도'][n] =='강원도':

            si_name[n] ='고성(경남)'

        else:

            si_name[n] = pop['시도'][n][:-1]

            #왕역시나 특셜시 차지시가 아닌데 구를 가지고 있는 것 처리

            for keys, values in tmp_gu_dict.items():

                if pop['시도'][n] in values:

                    if len(pop['시도'][n]) == 2:

                        si_name[n] = keys + ' '+ pop['시도'][n]

                    elif pop['시도'][n] in ['마산함포구','마산회원구'] :

                        si_name[n] = keys + ' ' + pop['시도'][n][2:-1] #앞에 두글자 빼기

                    else:

                        si_name[n] = keys + ' ' + pop['시도'][n][:-1]

    elif pop['광역시도'][n] == '세종특별자치시':

        si_name[n] = '세종'

    else:

        if len(pop['시도'][n]) == 2 :

            si_name[n] = pop['광역시도'][n][:2] + '' + pop['시도'][n]

        else:

            si_name[n] = pop['광역시도'][n][:2] + '' +pop['시도'][n][:-1]

print(si_name)

 

 

13.도시 이름을 pop에 새로운 컬럼으로 추가

pop['ID'] = si_name

 

#시도 이름을 pop에 새로운 컬럼으로 추가

pop['ID'] = si_name

print(pop['ID'])

 

 

#현재 상태 확인

print(pop.head())

print(pop.info())

 

 

14. 지도 정보를 저장한 엑셀 파일 읽기

#지도 정보를 가진 Excel 파일 읽기

draw_korea_draw = pd.read_excel('./Desktop/data/draw_korea_raw.xlsx')

print(draw_korea_draw)

 

 

15. 각 셀의 위치를 좌표로 만들기

#컬럼이름이 일련번호로 되어 있습니다.

#STACK함수를 일용해서 컬럼이름을 인덱스로 만들기

draw_korea_raw_stacked = pd.DataFrame(draw_korea_draw.stack())       

print(draw_korea_raw_stacked)

 

 

#좌표로 사용하기 위해서 커럶 이름 변경

draw_korea_raw_stacked.rename(columns = {'level_0' :'y','level_1':'x',0:'ID'},inplace = True)

print(draw_korea_raw_stacked)

 

16.  지도 그리기

1)경계선 만들기 위한 좌표 생성

#경계선 생성을 위한 조료 그리기

BORDER_LINES = [

[(5, 1), (5,2), (7,2), (7,3), (11,3), (11,0)], # 인천

[(5,4), (5,5), (2,5), (2,7), (4,7), (4,9), (7,9),

(7,7), (9,7), (9,5), (10,5), (10,4), (5,4)], # 서울

[(1,7), (1,8), (3,8), (3,10), (10,10), (10,7),

(12,7), (12,6), (11,6), (11,5), (12, 5), (12,4),

(11,4), (11,3)], # 경기도

[(8,10), (8,11), (6,11), (6,12)], # 강원도

[(12,5), (13,5), (13,4), (14,4), (14,5), (15,5),

(15,4), (16,4), (16,2)], # 충청북도

[(16,4), (17,4), (17,5), (16,5), (16,6), (19,6),

(19,5), (20,5), (20,4), (21,4), (21,3), (19,3), (19,1)], # 전라북도

[(13,5), (13,6), (16,6)], # 대전시

[(13,5), (14,5)], #세종시

[(21,2), (21,3), (22,3), (22,4), (24,4), (24,2), (21,2)], #광주

[(20,5), (21,5), (21,6), (23,6)], #전라남도

[(10,8), (12,8), (12,9), (14,9), (14,8), (16,8), (16,6)], #충청북도

[(14,9), (14,11), (14,12), (13,12), (13,13)], #경상북도

[(15,8), (17,8), (17,10), (16,10), (16,11), (14,11)], #대구

[(17,9), (18,9), (18,8), (19,8), (19,9), (20,9), (20,10), (21,10)], #부산

[(16,11), (16,13)], #울산

# [(9,14), (9,15)],

[(27,5), (27,6), (25,6)],

]

 

2)지도 그리기

plt.figure(figsize = (8,12))

#지역이름 표시

#행단위로 읽어오기

for idx, row in draw_korea_raw_stacked.iterrows():

    #공백을 기준으로 2개로 나누어 진다면 줄바꿈을 해서 출력

    if len(row['ID'].split()) == 2:

        dispname = '{}\n{}'.format(row['ID'].split()[0],row['ID'].split()[1])

    #마지막 2글자가 고성이라면 고성이라고 출력

    elif row['ID'][:2] =='고성':

        dispname ='고성'

    else:

        dispname = row['ID']

   

    #3글자가 넘으면 폰트를 줄여서 출력

    if len(dispname.splitlines()[-1]) >= 3 :

        fontsize, linespacing = 9.5, 1.5

    else:

        fontsize, linespacing = 11, 1.2

   

    #글자 작성

    plt.annotate(dispname,(row['x']+0.5, row['y']+0.5),

                 weight ='bold',

                 fontsize = fontsize, ha ='center',va ='center',

                 linespacing= linespacing)

   

#경계선 그리기

for path in BORDER_LINES:

    ys, xs = zip(*path)

    plt.plot(xs,ys, c = 'black',lw=1.5)

 

#상하 뒤집기 - 엑셀은 하단으로 갈때 좌표가 증가하지만

#모티너는 상단으로 갈 때 좌표가 증가합니다.

plt.gca().invert_yaxis()

 

#축 제거

plt.axis('off')

 

plt.show()

plt.gca().invert_yaxis()

위아래 뒤집어 졌다,

17.pop의 시도 이름과 draw_korea_raw_stacked의 id 일치시기키

=>set은 합집합 , 교집합 , 차집합 ,여집합을 계산할 수 있음

 

 

merge해서 id inner join

굳이 merge할 필요 없을 때는 set()을 기억하는 것이 좋다.

set -> 합집합 , 교집합 , 차집합 ,여집합

 

#pop의 ID와 draw_korea_raw_stacke의 ID 불일치 찾기

print(set(draw_korea_raw_stacked['ID'].unique())-set(pop['ID'].unique()))

 

print(set(pop['ID'].unique())-set(draw_korea_raw_stacked['ID'].unique()))

 

#서로 다른 것은 list로 만드다.

#pop에는 있는데 draw에는 없는 데이터 제거할 리스트 만들기

del_list = list(set(pop['ID'].unique())- set(draw_korea_raw_stacked['ID'].unique()))

print(del_list)

for rownum in del_list:

    pop = pop.drop(pop[pop['ID']==rownum].index)

 

#리스트를 순회하면서 데이터를 제거

print(set(pop['ID'].unique())-set(draw_korea_raw_stacked['ID'].unique()))

 

 

18.pop와 draw_korea_raw_stacked을 join

#pop와 draw_korea_raw_stacked을 join

pop = pd.merge(pop, draw_korea_raw_stacked , how='inner', on =['ID'])

pop.info()

 

19.좌표와 인구수를 이용해서 pivot 테이블을 생성

#좌표와 인구수를 이용해서 pivot 테이블을 생성

mapdata = pop.pivot_table(index ='y', columns = 'x' , values ='인구수합계')

print(mapdata)

 

#NaN 제거를 위한 작업

#NaN데이터는 --로 변환

masked_mapdata = np.ma.masked_where(np.isnan(mapdata),mapdata)

print(masked_mapdata)

#NaN을 -- 로 바꿔졌다.

 

20.컬럼이름과 datarame그리고 색상 이름을 대입하면 catogram을 그려주는 함수 만들기

 

#컬럼이름을 문자열로 설정하고 데이터프레임을 대입하고 색상을

def drawKorea(targetData, blockedMap, cmapname):

    gamma = 0.75

    #인구수 데이터의 크고 낮음을 분류하기 위한 값 만들기

    whitelabelmin = (max(blockedMap[targetData]) -

    min(blockedMap[targetData]))*0.25 + \

    min(blockedMap[targetData])

    #컬럼이름을 대입하기

    datalabel = targetData

    #최대값과 최소값 구하기

    vmin = min(blockedMap[targetData])

    vmax = max(blockedMap[targetData])

    #x 와 y를 가지고 피봇 테이블 만들기

    mapdata = blockedMap.pivot_table(index='y', columns='x', values=targetData)

    #데이터가 존재하는 것 골라내기

    masked_mapdata = np.ma.masked_where(np.isnan(mapdata), mapdata)

    #그래프 영역 크기 만들기

    plt.figure(figsize=(9, 11))

   

    #색상 설정

    #지도에 색상을 설정

    plt.pcolor(masked_mapdata, vmin=vmin, vmax=vmax, cmap=cmapname,

               edgecolor='#aaaaaa', linewidth=0.5)

              

    # 지역 이름 표시

    for idx, row in blockedMap.iterrows():

        # 광역시는 구 이름이 겹치는 경우가 많아서 시단위 이름도 같이 표시

        #(중구, 서구)

        if len(row['ID'].split())==2:

            dispname = '{}\n{}'.format(row['ID'].split()[0], row['ID'].split()[1])

        elif row['ID'][:2]=='고성':

            dispname = '고성'

        else:

            dispname = row['ID']

       

       

        # 서대문구, 서귀포시 같이 이름이 3자 이상인 경우에 작은 글자로 표시

        if len(dispname.splitlines()[-1]) >= 3:

            fontsize, linespacing = 10.0, 1.1

        else:

            fontsize, linespacing = 11, 1.

            

        #글자색상 만들기

        #글자 색상ㅇ을 다르게 한다.

        #while 아니면 블랙

        annocolor = 'white' if row[targetData] > whitelabelmin else 'black'

        #텍스트 출력하기

        plt.annotate(dispname, (row['x']+0.5, row['y']+0.5), weight='bold',

        fontsize=fontsize, ha='center', va='center', color=annocolor,

        linespacing=linespacing)

       

       

    # 시도 경계 그리기

    for path in BORDER_LINES:

        ys, xs = zip(*path)   

        plt.plot(xs, ys, c='black', lw=2)

       

    plt.gca().invert_yaxis()

    plt.axis('off')

    cb = plt.colorbar(shrink=.1, aspect=10)

    cb.set_label(datalabel)

   

    plt.tight_layout()

plt.show()

 

21.인구 수 합계 이용해서 그리기  

#그리기

drawKorea('인구수합계', pop, 'Blues')

 

22.소멸위기 지역  그리기

print(pop.head())

#소멸위기지역을 수치 데이터로 변환 -True:1, False :0

pop['소멸위기지역'] = [1 if imsi else 0 for imsi in pop['소멸위기지역']]

 

drawKorea('소멸위기지역', pop, 'Blues')

 

**위의 데이터를 이용해서 단계구분도(colorpleth)그리기

=>단계구분도를 그릴때는 그리고자 하는 지도의 경계를 나타내는 json파일이 있어야 합니다.

=>우리나라 데이터는 southkorea-maps를 검색하면 github에서 제공

#단계구분도를 위한 라이브러리

import folium

import json

 

#데이터에서 지역이름을 인덱스로 설정

pop_folium = pop.set_index('ID')

print(pop_folium)

 

#표기하고자하는 지도의 경계선 데이터를 가져옵니다.

geo_str = json.load(open('./Desktop/data/korea_geo_simple.json',encoding='utf-8'))

print(geo_str)

 

#지도 출력

map = folium.Map(location=[36.2003,127.0541],zoom_start = 7)

 

map.choropleth(geo_data=geo_str,data = pop_folium['인구수합계'],fill_color='YlGnBu',key_on ='feature.id',

               columns =[pop_folium.index,pop_folium['인구수합계']])

 

map.save('pop.html')

 

print(pop_folium.index)

 

print(pop[pop['광역시도'] == '서울특별시'])

 

 

#지도 출력

map = folium.Map(location=[36.2003,127.0541],zoom_start = 7)

 

map.choropleth(geo_data=geo_str,data = pop_folium['소멸위기지역'],fill_color='YlGnBu',key_on ='feature.id',

               columns =[pop_folium.index,pop_folium['소멸위기지역']])

 

map.save('pop.html')

**기술통계

=>논리적 사고와 객관적인 사실에 따르며 일반적이고 확률적 결정론에 따라 인과관계를 규명

=>수집된 자료의 특성을 쉽게 파악하기 위해서 대표값이나 표 또는 그래프로 요약하는 기술통계학과 모집단에서 추출한 정보를 이용해서 다양한 특성을 과학적으로 추론하는 추론 통계학(검정, 분산분석 , 회귀분석)으로 나

눔

 

**기술통계

=>자료를 요약하는 기초적인 통계량

=>모집단의 특성을 유추

=>빈도분석 : 개수 파악

=>기술통계분석 : 평균이나 합계 등을 구하는 것

1.기술통계함수

=>numpy에서 numpy가 기술 통계함수를 소유 : numpy.mean(데이터)

=>pandas에서는 Series나 DataFrame이 기술 통계함수를 소유:  DataFrame객체.mean()

DataFrame.mean(데이터프레임)

=>count, min,max, sum, std, var, median , mean(평균)

=>argmin,argmax, idxmin, idxmax(최대값을 가진 데이터의 위치)

6과 차이가 가장 작은 수

1 5 3 9

5 1 3 3

결국에 찾아야 하는 것이 차이값의 위치 의 값 을 찾아야 한다. 5

차이가 최소 찾을 때 index를 찾아야 한다.

유클리티 거리 , 맨하튼 거리 거리의 가까운 것의 거리를 찾는 것이다.

 

=>quantile(사분위수) : IQR(75%에서 25% 뺀것 이상치 찾는 것 )

           표준화 할 때도 필요 SCALLER할 때  

STANDARD scaller

minmax scaller -> min max 극단치 가능성이 있다. 극단치가 너무 좌우가 된다.

그래서 robus scaller를 사용한다.

=>describe: 최대 , 최소 , 평균 ,중간값 , 4분위수를 리턴

=>diff(이전 항과의 차), pct_change(이전 항과의 비율)

=>하나의 컬럼에만 사용 가능한 함수 : unique()-유일한 값들 리턴 , value _count() - 각 데이터의 개수

 

2.평균(mean)

1) 산술 평균 :데이터의 총합을 데이터의 개수로 나눈 값

 

2)기하 평균 : 평균 비율을 구할 때 사용

매출액이 100인 회사에서 다음 해에 매출액이 110이 되었고 그 다음해에 107.8을 기록했다면 평균 성장률은?

첫해에 105증가했고 그다음해에 2% 로 감소했으므로 평균 성장률은 (10-2) / 2 = 4 % ? 이렇게 하면 안된다.

1.1  * 0.98의 제곱근

 

3) 조화평균: 2개의 값의 곱에 2를 곱한 후 2개의 수를 더한 값으로 나누는 것

동일한 거리를 시곡 100km 로 가고 한번은 60km로 갔을 때 평균 속도는 ?

300km을 갔다고 했을 때 평균속도는 ?

 

(2 * 100 * 60 ) / (100+60)

 

4).단순 이동 평균

=>모든 데이터의 평균을 구하는 것이 아니고 최근의 데이터 몇 개의 평균만 구하는 것

=>pandas의 Series를 가지고 rolling 메소드에 window에 데이터 개수를 설정해서 호출

 

5)지수 이동 평균

=>최근의 데이터에 가중치를 부여해서 평균을 구하는 것

=>pandas의 Series 를 가지고 ewm 메소드에 span 매개변수를 이용해서 데이터 개수를 설정해서 호출

 

6) 주가를 가지고 회귀를 할 때는 단순 이동평균이나 지수 이동평균을 사용해야 합니다.

(최근데이터 + (1-알파)이전데이터 + (1-알파)제곱 * 이전의 이전데이터)/(1+(1-일파) +(1-알파)제곱)

 

 

###평균 그하기

s = pd.Series([10,11,10,78])

#비율 평균을 산출 평균으로 구하기

print(s.pct_change().mean())

 

 

import math

#평균 비율울 구할 때는 기하 평균을 사용

print(math.sqrt((11/10)*(10.78/11)) - 1)

 

#속도의 경우는 조화 평균을 사용

#동일한 거리르 100km 의 60km 로 달린 경우

print(2* 100* 60/(100+60))

 

#단순 이동 평균

print(s.rolling(window = 2))

 

#지수이동 평균  가중치를 0.5가지고 한다.

print(s.ewm(span= 2))

 

절사 평균 :양 극단치의 데이터를 제거하고 평균을 구하는 것

 

 

3. 중간 값(median)

=>데어터를 정렬했을 때 가장 중앙에 있는 값

=>데이터가 짝수인 경우는 중앙의 좌우값 평균을 이용

 

1 2 3 4 5: 중간값 - 3

1 2 3 4 5 6 : 중간ㄱ밧 - 3.5

=>중간값 데이터는 데이터 그룹에 없을 수도 있음

평균은 극단치에 매우 민감합니다.

극단치가 있을 때는 중간값이나 최빈값을 모집단을 대표하는 값으로 사용하는 것이 좋습니다.

시애틀에서 메디나와 원더미어 주변의 소득을 비교하는 경우 메디나에 빌게이츠가 삽니다.

평균을 가지고 비교하면 메디나 높게 나을 가능성이 높습니다.

이런 경우에는 중간값이나 최빈값을 모집단을 대표하는 값으로 사용하는 것이 좋습니다.

 

 

**척도

=>변수 , 변량, 컬럼 ,열 이라고도 부르는 테이블에서의 열

 

1.descriptive.csv

=>부모의 학력 수준에 따른 자녀의 대학진학 합격 여부를 조사한 데이터 셋

=>300개의 행과 8개의 열로 구성

=>열의 으미

resident: 거주지역(1,2,3 - 서울 , 광역시 ,시군구)

gender: 성별(1,2, - 남자,여자)

age:나이

level: 부모의 학력 수준(1,2,3 ~ 고졸 ,대졸 ,대학원졸 이상)

cost: 생활비

type: 학교 유형 (1,2 ~-4년제 , 4년제 미만)

survey: 만족도(1-2)

pass: 합격여부(1,2 ~ 합격 , 불합격)

 

 

#descriptive.csv파일 읽기

df = pd.read_csv('./Desktop/data/descriptive.csv')

print(df.head()) #데이터가 읽어지는 지 확인

 

 

df.info() # 데이터의 특성 확인 , 개수,

print(df.describe())#기술 통곟 확인

 

 

2. 명목 적도

=>구분 만을 위해서 의미없는 숫자로 만든 데이터 : 범주형이라고 하기도 합니다

=>거주지역이나 성별처럼 특별한 의미없이 구분만을 위해서 만든 척도

=>기술통계량을 구하는 것이 아무런 의미가 없음

=>이런 데이터는 비율만 확인하는 것이 일반적

=>막대 그래프나 원 그래프를 그려서 크기를 확인

=>이 척도가 분규의 타겟으로 사용이 된다면 비율이 거의 같은 것이 올바른 결과를 유추할 가능성이 높아집니다.

차이가 많이 나면 데이터를 더 수집하거나 다운샘플링이나 업샘풀링 등을 해주어야 한다.

 

#gender 값의 개수만 확인

df['gender'].value_counts().plot.bar(color='k')

#0하고 5 도 있다.

 

#이상한 데이터 확인 - 0, 5

df = df[(df['gender'] == 1 )| (df['gender'] == 2)]

df['gender'].value_counts().plot.bar(color='k')

 

 

3. 서열 척도

=>구분 뿐 아니라 순위를 표현하는 숫자로 만든 데이터 : 범주형

=>학력 수준이나 학교에서의 성적 순위 같은 데이터

=>명목 척도 처럼 기술 통계는 별 의미가 없고 비율만 확인하는 것이 일반적

=>순서는 명확하지만 순서마다 차이는 일정하지 않고 알기가 어려움

 

 

4.등간 척도

=>범주형으로 구분, 순위 그리고 각 값의 간격이 일정한 데이터

=>학교에서의 점수 , (90점하고 80점은 10점 더 잘 했다. ) ,및 설문 조사에서의 만족도

=>이 경우 부터는 기술 통계량이 의미를 갖음

 

5. 비율적도

=>연속형 데이터로 만들어진 데이터

=>사용자의 입력으로 만들어지는 데이터

=>기술 통계값이 의미를 갖음

=>빈도 분석할 때 주의 해야 합니다.

빈도 분석을 하게되면 너무 많은 항목이 만들어질 수 있습니다.

bining(구간 분할)을 해서 빈도 분석을 하는 것이 일반적입니다.

 

**표본 추출

=>전수 조사와 표본 조사

=>전수 조사는 모집단 내의 모든 대상을 상대로 조사하는 것

모집단의 특성을 정확하게 반영

비용과 기간이 많이 소모

 

=>표본조사는 모집단에서 일정한 대상을 샘플링해서 조사하는 것

전수조사의 단점을 보완할 수 있지만 잘못된 샘플링을 하게 됨녀 모집단의 특성을 정확하게 반영할 수 없습니다.

 

=>모수는 모집단의 특성을 나타내는 수치를 의미하고 통계량은 표본의 특성을 나타내는 것

통계량이 모수의 특성을 얼마나 잘 나타낼 수 있는가 ?

값이 얼마나 비슷한가

 

=>sample(표본) : 큰 데이터 집합으로부터의 부분 집합

=>population (모집단) : 데이터 전체 대상

=>N(n) : 모집단의 개수

 

=>랜덤 표본 추출 : 무작위 표본

(안에 아래 두개 있ㄷ.)

 

=>층화 표본 추출 : 모집단을 층으로 나눈 뒤 각 층에서 무작위로 데이터를 추출하는 것

=>단순 랜덤 추출 : 층화없이 표본을 추출하는 것

 

=>복원추출 : 이전에 추출된 데이터를 다시 모집단에 넣고 추출 (주사위 )

=>비복원 추출: 이전에 추출된 데이터를 모집단에서 제거하고 추출 (로또 )

 

=>표본 편향 : 잘못된 표본 (여론 조사하는데 단순 랜덤 추출하면 표본 편향이다.)

 

시청률이 높다고 해서 이슈화 되지 않는다. 20~30대 얼마 시청 했는냐 ? 화재성  여론조사는 단순 랜덤 추출하면 안되고 층화 표분 추출해야 한다.

 

=>추정

-점 추정 : 하나의 값과 일치하는 지 추정

-구간 추정: 범위를 가지고 추정

 

-신뢰수전 :계산된 구간이 모수를 포함할 확률 을 의미하면 보통 90% , 95% , 99% 를 사용

-유의수준(머신러닝할 경우 대부분 이것을 본다.) : 계산된 구간이 우연히 모수의 특성을 포함할 확률 0.1 . 0.05, 0.01을 사용

이름은 p-value

유의수준과 신뢰수준은 반대이다.

<= 0.05 우연히 나올 확률은 그것 밖에 안된다.

특정 유의 수준을 설정하고 그 유의 수준보다 낮게 나오면 기각 한다던가 채택을 합니다.

-신뢰구간: 모수를 포함할 상한값과 하한값

-표본오차(잔차): 모집단에서 추출한 표본이 모집단의 특성과 정확히 일치하지 않아서 발생하는 확률의 차이

-대통령 후보의 지지율 여론조사에서 후보의 지지율이 95%신뢰수준에서 표본오차 +- 3%범위 내에서 32.4%로 조사 되었다는 의미는

지지율이 29.4 ~ 35.4 %가 나올 확률이 95%라는 의미입니다.

5%는 틀릴 수도 있다.

 

1.단순 임의 추출

=>파이썬에서의 random모듈이 제공

random.random()을 이용하면 복원 추출

random.sample()을 이용하면 비복원 추출

random.shuffle(시퀀스 자료형): 을 이용하면 시퀀스 자료형을 랜덤하게 섞음

random()함수는 0과 1사이의 실수를 리턴

randrange(시작숫자, 종료숫자)를 이용하면 범위를 변경

randint(시작숫자, 종료숫자)

 

 

import random

 

li = list(range(1,40,1))

print(li)

 

print(random.shuffle(li))#섞어 버렸다.

print(li)

 

#비복원 추출

print(random.sample(li, k = 4))

#할 때마다 다른 것 나온다.

 

 

2.가중치를 설정한 추출

=>numpy의 choice메소드를 이용하면 가중치를 설정해서 추출이 가능

=>choice(배열 , size = 추출할 개수 , replace =복원추출여부 ,p =[확률])

=>데이터의 비율이 동일하지 않을 떄는 확률을 설정해서 추출해야 합니다.

 

0-10

1-90

결과가 외곡 할 수 있다. 단순 랜덤 추출하면 1이 70개 나올 수 있다.

그래서 비율로 나와야 한다.

 

0-50

1-30

2-20

테스트 데이터  7:4 는 같기 때문이다.

iris -> 5:5:5같기 같기 떄문에

 

li = ['라투','오미크론','다크스펙터','나이즈']

print(np.random.choice(li, 4)) #동일한 비율로 추출

print(np.random.choice(li, 4, p = [0.05, 0.3, 0.15, 0.5])) #나이즈 나올 확률이 높아진다.

 

 

3.pandas의 랜덤한 행 추출

=>Series나 DataFrame의 sample메소드

n: 추출한 데이터 개수

frac: 전체 개수에서 추출할 비율 -n과 Frac은 같이 설정 불가

replace: 복원 추출 여부로 기본값은 False

weight: 가중치

random_state: 시드 번호 - 계속 나오는 매개변수 중의 하나

                                  머신러닝할 때 이 옵션의 값을 변경하면서 수행

axis: 추출할 방향으로 기본은 행 단위로 추출

 

 

4.scikit-learn 라이브러리의 model_selection 클래스의 train_test_split()이용

=>샘플링할 때 가장 많이 사용하는 함수

=>무작위 샘플링을 할 떄는 shuffle

=>

=>test_size옵션

 

 

overfit(과적합)

=>훈련 데이터에는 잘 맞는데 시험데이터에 잘 안맞는 경우

=>훈련데이터가 너무 많거나 변수가 너무 많을 때

두개를 하나로 만들어는 것 고유백터 교차 항

 

 

 

**python에서 인스턴스 메소드 호출

클래스.메소드이름(인스턴스) -unbound호출

인스턴스.메소드이름() -bound호출

 

class X:

           def funct(self):

                       print('인스턴스 메소드')

 

x = X()

x.func() -bound호출

 

X.func(x) ->unbound호출

**지수이동 평균

=>DatqaFream.ewm(span= 가중치를 부여할 데이터 개수).mean()

 

알파 = 1/span

 

최근의 데이터 + (1-알파)이전데이터 + (1-알파)제곱 * 그이전 데이터

 

=>최근의 데이터 반영 비율을 높이고 이전 데이터의 반영 비율을 줄여서 계산하는 방식

=>주가 데이터에 많이 사용

주가는 최근의 데이터의 추세를 반영하는 것이 예측의 정확성을 높여주기 떄문입니다.

 

 

import numpy as np

import pandas as pd

 

#2020년 1월 1일 부터 월 단위로 5개이 데이터를 생성

timeindex = pd.date_range('01/01/2020', periods = 5, freq ='M')

 

df = pd.DataFrame(index = timeindex)

 

df["price"] = [10,20,30,40,50]

 

print(df)

 

#span을 2로 설정해서 지수 이동 평균 구하기

print(df.ewm(span = 2).mean())

 

price

2020-01-31  10.000000

2020-02-29  17.500000

2021-03-31  26.153846

2020-04-30  35.500000

2020-05-31  45.206612

10 20 -> 15 20 => 17.5

10 20 30 -> 30

 

 

예를 들어 설명하겠습니다.

최근 5일간 종가가 1000, 1010, 1005, 1010, 1015 이렇게 형성되었다고 가정하겠습니다.

3일간 지수이동평균을 구해보겠습니다.

먼저 오늘 종가를 보면 1015원에 끝났습니다.

그러면 C=1015가 됩니다.

Xp는 전일의 3일 이동평균값이므로 (1010+1005+1010)/3 = 약 1008

K = 2/(n+1)이고 n = 3이므로

K = 1/2가 됩니다.

따라서 EMA는

   1015*(1/2)+1008*(1-1/2)

= 1015*(1/2)+1008*(1/2)

= (1015+1008)/2 = 1011.5

즉, 오늘을 기준으로 계산한 3일 지수이동평균 값은 1011.5가 됩니다.

제가 제대로 이해한건지 모르겠네요...^^;

 

아무튼...

Xp는 전일의 n일 이동평균을 뜻하고

K는 오늘 종가를 이동평균을 계산하는데 얼마나 비중을 둘것인가를 결정하는 것 같습니다.

n값이 커지면 K값은 작아지죠

 

--------

기술적으로 해석해보자면

n값이 커질 때(20일 60일 120일 등..), 현재 주가와 n일 이동평균과의 차이가 얼마나지 않는 다는 건,

시장이 그 기간동안 급등락, 급반등 하지 않았다는 것을 의미하는 건가?

 

** 시계열 데이터에서의 누락된 값

=>시간의 간격이 일정한 간격에서 데이터가 누락된 경우라면 제거를 하는 것보다는 패턴을 확인해서 데이터를 대입하는 것이 좋습니다.

 

2019-01-01 : 100

2019-02-01 : 200

2019-03-01 : None

2019-04-01 : 400

 

=>DataFrame의 interpolate함수를 호출하면 누락된 값을 채워집니다.

매개변수가 없으면 선형으로 관계를 파악해서 채워주고 method에 quadratic을 설정하면 비선형으로 채워줍니다.

 

aX + b: 일차 방정식 0 선형 : 데이터의 분포가 직선에 가까워집니다.

aX ^ 2 + bX + c: 이차 방정식 이상 - 비선형 : 데잍의 분포가 곡선에 가까워집니다.

 

머신러닝을 할 때도 회구나 분류하기 전에 데이터의 분포를 확인해야 합니다.

데이터의 분포를 확인 할 때는 산포도(scatter) 를 열어 이용합니다.

 

10 20 30 40 -> 선형

1 4 8 ...-> 제곱의 관계 비선형

데이터의 분포를 보고 판단해야 한다.

비선형은 정확도가 떨어진다.

 

 

#2020년 1월 1일 부터 월 단위로 5개이 데이터를 생성

timeindex = pd.date_range('01/01/2020', periods = 12, freq ='M')

 

df = pd.DataFrame(index = timeindex)

 

#누락된 데이터(결측치 - None ,null, np.NaN) 만들기

df["price"] = [10,20,np.NaN,40,50,60,70,80,90,np.NaN,110,120]

 

print(df)

 

#선형으로 누락된 값 채우기

print(df.interpolate())

 

 

df["price"] = [100,400,np.NaN,1600,2500,3600,4900,6400,81000,np.NaN,12100,14400]

 

print(df)

 

#비선형으로 누락된 데이터 값 채우기

print(df.interpolate(method = 'quadratic'))

 

df["price"] = [100,400,np.NaN,1600,2500,3600,4900,6400,81000,np.NaN,12100,14400]

 

print(df)

 

#비선형으로 누락된 데이터 값 채우기

print(df.interpolate(method = 'linear'))

 

**pandas의 함수 매핑

=>pandas에서는 Series나 DataFrame의 개별 요소에 동일한 함수를 적용하고자 하는 경우에 apply메소드를 이용

1.Series가 apply메소드를 호출하면 각 요소에게 함수를 적용한 후 그 결과를 가지고 다시 Series를 만들어서 리턴

 

 

2.DataFrame에 적용을 하게 되면 적용방법에 따라 Series가 되기도 하고 DataFrame이 리턴되기도 합니다.

axis 옵션을 이용해서 열과 행 단위로 데이터를 대입할 수 있습니다.

axis = 0 이 기본값으로 열 단위로 대입하는 데 1을 설정하면 행단위로 함수에 대입

 

=>Series는 하나의 열의 개념이고 DataFrame은 행열(Matrix(numpy) - Trable(pandas))

=>머신러닝에서는 데이터의 단위가 대부분 Matrix입니다.

DataFrame['컬럼이름' ] :Series

DataFrame[['컬럼이름']] : DataFrame

pandas 자료구조에서 .values 하게되면 컬럼이름을 제거하고 데이터 만으로 구성된 numpy.ndarray를 리턴합니다.

=>머신러닝에서는 컬럼이름이 필요없습니다.

 

#seaborn 패키지에 존재하는 titanic데이터 가져오기

#인터넷에서 가져오기 때문에 인터넷이 안되면 안됨

#seaborn 패키지 : 샘플 데이터 셋과 matplotlib보다 시각적인 효과가 뛰어난 그래프를 만들어주는 패키지

#numpy, pandas, matplotlib, seaborn ,sklearn (전처리(preprocessing) , 머신러닝 )

import seaborn as sns

titanic = sns.load_dataset('titanic') #인터넷이 있어야 가능하다.

titanic.info()

#titanic 분류 누가 살았나 ? 누가 죽었고 ?

 

#2개의 컬럼을 추출해서 새로운 DataFrame만들기

#age, fare

df = titanic[['age','fare']] #열만

df.info()

 

#행 전체의 age와 fare,을 가져오기

df = titanic.log[:, ['age','fare']]  #행 까지 뽑아 낼때

#df = titanic.log[1:10, ['age','fare']]  #행 까지 뽑아 낼때

df.info()

 

 

def add_10(x):

    return x + 10

 

# 데이터프레임에 함수 적용  - 열단위로 적용

result = df.apply(add_10)

print(result.head())

print(result.info())

 

# 데이터프레임에 함수 적용  - 행단위로 적용

result = df.apply(add_10, axis =1)

print(result.head())

print(result.info())

 

 

 

**DataFrame 결합

1.merge()

=>2개의 DataFrame이나 Series를 합치기 위한 함수

=>첫번째 와 두번째 매개변수는 합치기 위한 Series나 DataFrame을 설정해야 하는데 left와 RIGHT 매개변수로 대입해도 됩니다.

=>하나 이상의 KEY를 가지고 결합

=>관계형 데이터베이스의 JOIN과 유사

=>별다를 설정이 없으면 동일한 컬럼이름을 찾아서 JOIN

=>직접 JOIN KEY를 지정하고자 하면 ON 매개변수에 컬럼이름을 설정

=>양쪽의 KEY이름이 다른 경우에는 LEFT_ON그리고 RIGHT_ON 매개변수를 이용해서 직접 KEY를 설정

=>기본 merge는 inner join의 개념

=>어느 한쪽에만 존재하는 데이터를 merge에 참여시키고자 할 때는 how라는 매개변수에 left, right, outer 중에 하나를 설정하빈다.

이러한 join방식을 Outer join이라고 합니다.

 

=>key가 아닌 컬럼 중에 양쪽에 동일한 이름으로 존재하는 컬럼이 있으면 이 때는 _x와 _y라는 이름이 자동 삽입되는데 이것을 변경하고자 하면 suffixes 옵션에 튜플로 추가될 이름 2개를 설정하면 됩니다.

 

 

=>양쪽에 동일한 의미를 갖는 컬럼이 없는 경우 index를 이용해서 join을 할 수 있는데 이 경우에는 left_index = True 그리고 right_index = True를 추가해주면 됩니다.

 

 

=>merge를 수행하면 key 의 값으로 정렬을 수행하는데 sort옵션에 false를 설정하면 정렬하지 않습니다.

 

 

#stack price.xlsx파일과 stock valueation.xlsx파일 읽기

price = pd.read_excel('./Desktop/data/stock price.xlsx')

valuation = pd.read_excel('./Desktop/data/stock valuation.xlsx')

price.info()

valuation.info()

 

#2개의 dataframe을 id를 기준으로 합치기

#양쪽 모두에 존재하는 데이터만 조인에 참여 -inner jon

merge_inner = pd.merge(price, valuation)

print(merge_inner)

print(merge_inner.info())

#5개만 남는다. inner join이다.

 

 

 

#어느 한쪽 에만 존재하는 데이터도 join 에 참여 -outer join

merge_outer = pd.merge(price,valuation, how = 'outer',on = 'id')

print(merge_outer)

 

merge_outer = pd.merge(valuation ,price, how = 'outer',on = 'id')

print(merge_outer)

 

 

 

2.join

=>인덱스를 기준으로 합쳐주는 함수

DataFrame.join(다른 데이터 프레임)

 

#파일의 내용을 읽을 때 하나의 커럶을 인덱스로 설정

#id가 없어진다.

price = pd.read_excel('./Desktop/data/stock price.xlsx',index_col = 'id')

valuation = pd.read_excel('./Desktop/data/stock valuation.xlsx',index_col = 'id')

price.info()

valuation.info()

 

#index를 이용해서 join

#price 의 모든 데이터는 join 에 참여한다.

#valuation에서는 참여하지 않는 데이터도 있을 수 있음

#left outer join

stock_join = price.join(valuation)

print(stock_join)

 

 

 

3.concat

=>구성 형태와 속성이 균일한 경우 행 또는 열방향으로 이어 붙이는 함수

=>merge나 join은 행방향으로 결합

=>join옵션에 inner를 적용하면 양쪽에 모두 존재하는 데이터끼리 결합하고 outer를 설정하면 한쪽에만 존재하는 데이터도 결합을 하는데 기본값이 outer

=>axis옵션에 0을 설정하면 열방향으로 합치고 1을 설정하면 행 방향으로 합침

 

 

#concat 1- 열 행 방향으로 DataFrame을 합쳐주는 함수

df1 = pd.DataFrame({'a' : ['a0','a1','a2']},index = [1,2,3])

df2 = pd.DataFrame({'a' : ['a2','a3','a4'], 'b':['b2','b3','b4']},index = [2,3,4])

print(df1)

print(df2)

 

print(pd.concat([df1, df2])) #위 아래로 합쳐져 버린다.

print(pd.concat([df1, df2], axis = 0)) # 행으로 합친다. 기본이 axis = 0 이다.

 

#좌우로 합치기 - 기본이 outer라서 한쪽에만 존재하는 것도 나옴

print(pd.concat([df1, df2], axis = 1)) # 행으로 합친다.

 

#한 똑에만 존재하는 데이터 제거

print(pd.concat([df1, df2], axis = 1, join = 'inner'))

 

 

 

4.append

=>인덱스가 별의미가 없는 경우 무조건 행방으로 합치는 함수

 

5.combine_first

=>양쪽에 겹쳐지는 인덱스가 존재하는 경우에 무조건 호출하는 쪽의 값으로 설정

 

 

#행방향으로 무조건 합치기

print(df1.append(df2)) #행방향으로 무조건 합친다.

 

#인덱스를 가지고 합치는데 호출하는 쪽의 데이터를 우선 적용

print(df1.combine_first(df2))

print(df2.combine_first(df1))

 

 

**그룹화

=>DataFrame의 내용을 그룹 단위로 분할해서 탐색하는 것

=>그룹화를 한 후 집계 , 변환 ,필터링을 적용

=>분할을 이해서는 groupby 함수를 이용하고 변환에는 apply함수를 적용

 

1.groupby 함수

=>그룹화할 컬럼이름을 대입하면 그룹화를 수행 ,컬럼이름은 1개도 되고 컬럼이름의 list도 가능

=>그룹별 데이터를 별도가 가져오고자 하는 경우에는 get_group(그룹이름)

=>빠른 열거를 이용하면 그룹화할 때 사용한 키와 데이터를 튜플로 접근을 할 수 있습니다.

파이썬은 튜플을 나누어서 저장 가능

=>집계함수(개수 , 합계, 평균, 최대값 , 최소값, 표준편차 , 분산, 중간값, 사분위수 ) 사용 가능

=>mean(), max(), min(), sum(),count(), size(), var(), std(), first(), last(), describe(), info()등

describe()기술 통계에 대한 요약 정보

info()  자료형에 대한 요약 정보

=>apply()를 호출해서 변환 가능 - 매개변수 1개를 받아서 return하는 함수를 대입

=>filter()를 호출해서 원하는 데이터만 추출 가능 - 매개변수 1개를 받아서 bool을 리턴하는 함수를 대입

=>직접 만든 함수를 대입해서 결과를 얻고자 하는 경우에는 agg함수를 이용

agg함수에는 함수의 list를 대입해도 됩니다.

 

 

 

import seaborn as sns

 

#titanic 데이터 가져오기

titanic = sns.load_dataset('titanic')

print(titanic.info())

 

#class 별로 그룹화

grouped  = titanic.groupby('class')

print(grouped)

# <pandas.core.groupby.generic.DataFrameGroupBy object at 0x0000020F8F61A548> 클라스 이름의 객체로 나온다.

 

#그룹화된 데이터에 접근

#first,second, third 별로 보여준다.

for key ,data in grouped :

    print(key)

    print(data.head())

   

#Third 에 해당하는 그룹의 데이터만 가져오기

third = grouped.get_group('Third')

print(third['class']) # 다 third이다.  491 개가 있다.

 

#집계함수 적용 - 그룹별 평균 구하기

print(grouped.mean())

 

 

#2개의 특성으로 그룹화해서 집계

grouped = titanic.groupby(['class','sex'])

print(grouped.mean())

 

#그룹화 해서 원하는 함수를 적용

def func(x):

    return x.max() - x.min()

 

grouped = titanic.groupby(['class'])

 

print(grouped.agg(func))

 

#여러 개의 함수를 적용

print(grouped.agg(['max', 'min']))

#보고서 만들 때 유용하다. 그룹별로 결과를 만들어서 보여주면 훨씬 좋다.

 

#각 그룹별 데이터 개수 확인

for key,data in grouped: #공백 있으면 오류

    print(key, len(data))

   

#데이터가 200개 안되는 그룹은 제거

 

#데이터의 개수가 200이상인 여부를 알려주느 함수

def over200(x):

    return len(x) >= 200

 

grouped_filter = grouped.filter(over200)

print(grouped_filter['class'])

#second가 제거 됬다.

 

#위의 내뇽을 람다함후소 변환

#python에서의 람다는 이름없는 한줄 짜리 함수

#필터링이나 mapping(apply) 메소드에서 람다를 많이 사용

grouped_filter = grouped.filter(lambda x : len(x) >= 200)

print(grouped_filter['class'])

 

#age열의 평균이 30이 안되는 부분을 출력

for key,data in grouped: #공백 있으면 오류

    print(key, data['age'].mean())

   

grouped_filter = grouped.filter(lambda x : x['age'].mean() < 30)

print(grouped_filter['class'])

 

 

 

2.멀티 인덱스

=>인덱스를 여러 그룹으로 설정한 것

=>멀티 인덱스로 설정된 데이터 모임에서 특정한 인덱스의 데이터를 가져오고자 하면 loc[(첫번째 인덱스 값, 두번째 인덱스 값...)]

=>xs라는 함수를 이용할 수 있는데 이 경우에는 첫버째 매개변수로 인덱스 이름을 대입하고 level에 인덱스의 값을 대입합니다.

 

#멀티 인덱스

#그룹화를 할 때 2개 이상의 컬럼 이름을 대입하면 멀티 인덱스

grouped = titanic.groupby(['class','sex'])

gdf = grouped.mean()

print(gdf)

#내가 원하는 하나만 찾고 싶을 때

# 행단위로 데이터 접근

print(gdf.loc['Third']) #남자 여자 따로 따로 나온다.

 

#Third 의 male 만 가져오기

print(gdf.loc[('Third' , 'male')]) #third에 남자만 알고 싶다.

#index를 안쓰니깐 전체 male가져올 수 없다.

 

#xs인덱스 사용

print(gdf.xs('male',level = 'sex')) # 전체 male만 가져온다.

 

 

 

 

 

3.pivot_table()

=>데이터를 그룹화하기 위한 함수

=>데이터를 행과 열 단위로 그룹화해서 기술 통계 값을 출력해주는 함수

pandas.pivot_table(데이터프레임, values = [연산을 수행할 컬럼이름 나열],index = [index로 사용할 컬럼이름 나열] , colunmns =[컬럼으로 사용할 이름 나열] ,margins = 전체 데이터 출력여부 (bool로 설정), argfunc =수행할 함수 , fill_vale = NA인 경우의 대체값 )

=>pivot_table 함수를 호출하면 인덱스는 대부분의 경우 멀티 인덱스로 생성되는데 해제하고자 하는 경우에는 reset_index를 호출하면 됩니다.

 

#####pivot_table()

import numpy as np

import pandas as pd

import seaborn as sns

 

#seaborn에 존재하는 titanic데이터 가져오기

titanic = sns.load_dataset('titanic')

titanic.info()

 

 

#age , sex, class, fare, survice

#새로운 데이터 프레임 만들기

df = titanic[['age','sex','class','fare','survived']]

print(df)

 

df = titanic.loc[:,['age','sex','class','fare','survived']]

print(df)

 

#class별로 성별로 구분해서 age의 평균 구하기

pivot1 = pd.pivot_table(df,index= ['class'], columns =['sex'], values =['age'],aggfunc='mean')

#일반함수는 그냥 사용해야 하는데 제공한 것은 ''을 사용해야 한다.

print(pivot1)

 

pivot1 = pd.pivot_table(df,index= ['class','sex'], columns =['sex'], values =['age','fare'],aggfunc=['mean','sum','count'])

print(pivot1)

 

 

#첫번째 인덱스(class)가 First인 데이터 가져오기

print(pivot1.xs('First'))

#level을 안되서 index를 설정했다. pivot_table 에서

#First, 이고 male인 데이터 가져오기

print(pivot1.xs(('First','male'), level =['class','sex']))

 

#mean 열의 데이터만 가져오기

print(pivot1.xs('mean',axis = 1))

 

 

 

 

** 서울시 구별 CCTV(자치구별 cctv)개수 와 인구수를 시각화

1.데이터 가져오기

1) data.seoul.go.kr 사이트에서 서울시와 관련된 데이터를 가져오기

=>cctv개수 ->cctv.xlsx ->pop_cctv.xlsx

http://data.seoul.go.kr/dataList/OA-2734/C/1/datasetView.do

 

=>인구 데이터 ->pop.txt

http://data.seoul.go.kr/dataList/419/S/2/datasetView.do

hwp는 읽기 불편하다. python 도큐먼트는 영어로 쓰야 한다.

 

2. python에서 2개의 파일을 내용을 읽어서 DataFrame으로 만들기

 

'''

    서울시 구별 cctv와 인구수 시각화

'''

import pandas as pd

#1.pop_cctv.xlsx파일과 pop.txt파일의 내용 읽기

cctv = pd.read_excel('./Desktop/data/pop_cctv.xlsx')

print(cctv.head())

cctv.info()

 

#skiprows= 2 2줄 뛰기

#,sep=' '

#delimiter ='\t') 구분자는 탭

#thousands =','천단위 구분기호는

pop = pd.read_csv('Desktop/data/pop.txt',skiprows= 2,delimiter ='\t',thousands =',')

print(pop.head())

pop.info()

 

3. 컬럼이름을 수정  구 이름을 동일한 형태로 만들기

 

#3.컬럼이름을 수정  구 이름을 동일한 형태로 만들기

#inplace = True 가 설정되면 현재 데이터프레임에 적용하고

# 이 옵션이 없으멶 현재 데이터프레임을 복사해서 작업하고  return을 해줍니다.

cctv.rename(columns = {cctv.columns[0]:'구별'},inplace = True)

pop.rename(columns = {cctv.columns[1]:'구별'},inplace = True)

 

#cctv의 구별 데이터에서 공백을 전부 제거하기

gu = []

for x in cctv['구별']:

    gu.append(x.replace(' ',''))

cctv['구별'] = gu

 

 

 

4.불필요한 컬럼이나 열을 제거

=>컬럼이나 열을 제거하는 방법은 현재 데이터프레임에서 직접 제거(drop함수 이용)

=>필요한 컬럼이나 열만 추출

 

#4.불필요한 컬럼이나 열을 제거

#pop에서 필요한 행과 열만 가져오기

#pop에서 기간 ,구불 계, 남자 ,여자 열만 추출

pop = pop[['기간','구별','계','남자','여자']]

 

#0번 행을 제거

pop.drop([0],inplace = True)

 

#여성비율이라는 새로운 컬럼을 추가 - 여자 /계 * 100

pop["여성비율"] = pop['여자'] / pop['계'] * 100

print(pop)

 

5.2개의 데이터프레임을 합치기

 

#cctv와 pop를 합치기 -기준은 구별

df = pd.merge(cctv,pop, on ='구별')

print(df)

 

6.합치면 데이터프레임에서 불필요한 컬럼 제거

2011년 이전 ,2012년 , 2013년 , 2014년 , 2015년, 20166년 , 2017년 , 기간

 

df.drop(['2011년 이전','2012년','2013년','2014년','2015년','2016년','2017년','기간'],axis = 1, inplace = True)

print(df)

 

7.구별 컬럼을 인덱스로 설정

#구별 컬럼을 인덱스로 설정

df.set_index('구별',inplace = True)

print(df)

 

 

 

8. 그래프 그리기

#그래프 그리기 위한 패키지

import matplotlib.pyplot as plt

 

#그래프에서 한글 처리를 위한 패키지

from matplotlib import font_manager, rc

import platform

 

#운영체제를 확인해서 글ㄸ꼴 설정

if platform.system() == 'Windows':

    font_name= font_manager.FontProperties(fname="c:/Windows/Fonts/malgun.ttf").get_name()

    rc('font', family=font_name)

elif platform.system() =='Darwin':

    rc('font',family = 'AppleGothic')

   

#cctv 개수를 가지고 막대 그래프 그리기

df['소계'].plot(kind='barh', figsize=(10,10))

plt.show()

 

 

산포도 그리기

#인구수 (계) 와 cctv 개수(소계)를 가지고 산포도 그리기

plt.figure(figsize = (8,8))

plt.scatter(df['계'],df['소계'],s = 50)

plt.xlabel('인구수')

plt.ylabel('cctv 개수')

plt.grid()

plt.show()

 

10. numpy의 polyfit 이라는 함수를 이용해서 다항식을 구해서 선 그래프 그리기

=> 다항식 -> 회귀식

 

#막대 그래프와 산포도 같이 그려진다.

#개와 소계의 데이터를 가지고 다항식 구하기

import numpy as np

#1이면 1차 다항식 2이면 2차 다항식 3이면 3차 다항식  점점 더 정확해진다.

fp1 = np.polyfit(df['계'],df['소계'],1)

f1 = np.poly1d(fp1)

print(f1)

 

 

#선 그래프 그리기

# 10000 부터 700000 까지를 100개로 분할 배열 생성

fx = np.linspace(100000,700000,100)

plt.figure(figsize = (8,8))

plt.scatter(df['계'], df['소계'] , s = 50)

#lw 두께이다.

plt.plot(fx, f1(fx), ls = 'dashed', lw = 3, color ='g')

plt.xlabel('인구수')

plt.xlabel('cctv 개수')

plt.grid()

plt.show()

 

 

11. 산포도의 각 점에 자신의 이름을 표시하고 잔차 (실제 데이터와 예측된 데이터와의 차이)를 점의 색상으로 설정

 

#막대 그래프와 산포도 같이 그려진다.

#개와 소계의 데이터를 가지고 다항식 구하기

import numpy as np

#1이면 1차 다항식 2이면 2차 다항식 3이면 3차 다항식  점점 더 정확해진다.

fp1 = np.polyfit(df['계'],df['소계'],1)

f1 = np.poly1d(fp1)

print(f1)

 

 

#선 그래프 그리기

# 10000 부터 700000 까지를 100개로 분할 배열 생성

fx = np.linspace(100000,700000,100)

plt.figure(figsize = (8,8))

plt.scatter(df['계'], df['소계'] , s = 50)

#lw 두께이다.

plt.plot(fx, f1(fx), ls = 'dashed', lw = 3, color ='g')

plt.xlabel('인구수')

plt.xlabel('cctv 개수')

plt.grid()

plt.show()

 

잔차 - 실제 데이터와 예측된 데이터와의 차이

 

 

#잔차를 색상으로 표시하고 지역 이름을 점위에 출력

#잔차 계산

df['잔차'] = np.abs(df['소계'] - f1(df['계']))

plt.figure(figsize = (14,12))

#c = df['잔차'] 색갈로 구분한다.

plt.scatter(df['계'], df['소계'] , c = df['잔차'],s = 50)

#lw 두께이다.

plt.plot(fx, f1(fx), ls = 'dashed', lw = 3, color ='g')

 

#그래프에 텍스트 출력하기

# 1.02 오른쪽으로

# 0.98 주위

# 1 이상이면 위에

for n in range(25):

    plt.text(df['계'][n]*1.02 , df['소계'][n]*0.98, df.index[n],fontsize= 12)

 

plt.xlabel('인구수')

plt.xlabel('cctv 개수')

plt.colorbar()

plt.grid()

plt.show()

 

**데이터 구조화

stack & unstacke

1.stack과 unstack

=>stack은 컬럼을 인덱스로 이동시켜 데이터를 길게 쌓는 것이고 unstack은 쌓은 것을 옆으로 늘어뜨리는 것=>읽어온 데이터의 구조가 원하는 구조가 아닐때 이러한 구조화 메소드를 이용해서 원하는 구조로 만들어서 데이터 분석을 수행합니다.

multi index 연습할때 데이터 만들기 쉽지 않다.

 

 

#데이터 구조화

#stack과 unstack

#튜플의 list를 이용해서 멀티 인덱스 만들기

mul_index = pd.MultiIndex.from_tuples([('cust_1','2015'),('cust_1','2016'),('cust_2','2015'),('cust_2','2016')])

#데이터 프레임 만들기

data = pd.DataFrame(data = np.arange(16).reshape(4,4),index = mul_index,columns=['prd_1','prd_2','prd_3','prd_4'])

print(data)  #4줄로

#stack하면 밑으로

 

#z컬럼들을 인덱스로 설정 -stack

#모든 열을 세로 방향으로 세워서 하나의 열로 만듭니다.

#index는 1개의 level.이 더 많아 집니다.

data_stacked = data.stack()

print(data_stacked) #세로 방향으로 생긴다. 3* 4

 

 

#unstack은 데이터를 가로 방향으로 늘어 뜨리는 것

#level옵션을 이용해서 원하는 만큼만 열로 만들 수 있습니다.

#지금 같은 경우는 index가 3가지 이므로 0,1,2 가능

print(data_stacked.unstack(level = 0)) #8개로 변경  잴 앞에 있는것 빠져나간다. cust_1  cust_2

print(data_stacked.unstack(level = 1)) #8개로 변경  2015으로 나누는 거

print(data_stacked.unstack(level = 2)) #4개로 변경  prd_1  prd_2  prd_3  prd_4

print(data_stacked.unstack(level = 2).unstack(level= 1)) #2개로 변경  prd_1  prd_2  prd_3  prd_4 ,2015 2016

 

 

 

 

2. melt 

=>여러 개의 컬럼의 데이터를 합쳐서 하나의 컬럼으로 만드는 것

=>데이터프레임과 id_vars매개변수에 합치고자 하는 컬럼 이름의 list를 대입하면 됩니다.

melt

#2개의 컬럼을 합쳐서 1개로 만들기

#남겨두고자 하는 컬럼의 list를 id_vars에 대입하면

#나머지 컬럼을 합쳐서 컬럼의 이름은 variable

#값은 value에 설정합니다.

print(data)

print(pd.melt(data, id_vars=['prd_3','prd_4']))

 

print(pd.melt(data, id_vars=['prd_3']))

 

3.crosstab

=>행과 열을 기준으로 빈도를 세어서 테이블을 만들어주는 함수

=>교차분석 할 때 이용 ~ 도수분포표(frequency table)를 만들어준느 기능

=>함수에  행 이름과 열 이름을 설정

=>머신러닝 결과 등을 타날 때 자주 이용

오른 것을 오른것 얼마나 했느냐? 정확도 출력해주느

 

 

#도수분포표 -CRASSTAB

data = pd.DataFrame({'id':['id1','id1','id1','id2','id2','id2'],

                     'fac_1':['a','a','a','b','b','b'],

                     'fac_2':['c','c','c','c','d','d']})

   

print(pd.crosstab(data['fac_1'],data['fac_2']))

 

 

a이고 c인것 3개 d이고 a인것 0개

b이고 c인것 1하 d이고 b인것 2개

그룹별로 계산 하면 된다.

 

 

 

#도수분포표 -CRASSTAB

data = pd.DataFrame({'id':['id1','id1','id1','id2','id2','id2'],

                     'fac_1':['a','a','a','b','b','b'],

                     'fac_2':['c','c','c','c','d','d']})

   

print(pd.crosstab(data['fac_1'],data['fac_2']))

 

#비율로 출력하기

print(pd.crosstab(data['fac_1'],data['fac_2'],normalize = True))

# 3/6 1/6 0/6 2/6

 

#잔차의 합으로 평가하는 것도 있고 그룹별로 하는 것도 있다.

#머신러닝에서는 잔차로 한다. 회귀분석에서 한다.

 

정확도

잔차(error) -> 회귀에서 사용  예측값에서 실제 값을 뺀것

분류에서는 아래 같은 식으로 계산한다.

분류는 표보고 판단하는 것이 중요하다.

 

 

비가 오는 날 얼마 안되고 비가 오지 않는 날이 많다. 그래서 비율이 달라서 assembling등 해야 한다.

 

인구는 적지만 젊은 분이 많으면 소멸이 안될 수 있다.

 

 

rpa ->자동화 software만드는 것  공장 같은데 가면 자동화 하는 것

자동화 프로그램 사용하는 원인은 스마트 팩토리

 

 

보통은 메크로이다.

 

 

**일반적인 python이나 anaconda를 이용해서 설치한 파이썬 -C로 만들어진 PYTHON

=>C언어로만든 라이브러리를 파이썬에서 사용할 수 있음

=>C언어는 소스코드를 가지고 실행 파일을 만들어서 배포

실행 파일을 만들 때 운영체제의 start up코드가 포함되어야 합니다.

실행되는 프로그램이 운영체제마다 다릅니다.

=>windows에서 실행되는 c언어는 ms-c이고 이 언어로 프로그램을 만드느 대표적인 ide가 visual c++ 이고 이 visual c++로 만들어진 프고르램을 실행시키기 위해서 재배포 패키지나 build tool이 설치되어 있어야 합니다.

 

**windows애서 python t실행시 라이브러리가 설치되지 않는데

visual c++ 14.0이 설치되어 있어야 하는데 설치되어 잇지 않다는 에러 메시지가 출력되는 경우

-visual studio 2015 재배포 패키지 설치 : 설치해도 잘 안됨

-visual studio 2015 build tools 설치 : 설치해도 잘 안됨

-visual studio 최신 버전 설치 : visual studio community버전 다운로드

 

 

ar . vr 게임 등 관심있으면 unity

mmo rpg ->언니얼

microsoft vr tool -> 테이블 그래는 것 자동으로 하는 것

 

 

 

데이터 적을 때 는 오차 , 정밀도 , 재현울 , F1점수 roc 곡선 등

 

 

 

** 불균형한(개수가 다른 경우) 클래스의 데이터를 가지고 분석을 해야 하는 경우

=>샘플 자체의 개수가 작을 떄는 자료를 더 수집하는 것이 가장 좋은 방법

=>데이터 를 수집하는 것이 가능하지 않을 때는 데이터에 가중치를 적용해서 사용- 분류 알고리즘의 매개변수 중에서 weight가 있으면 이 매개변수가 데이터에 가중치를 적용할 수 있는 매개변수 입니다.

=>개수가 작은 데이터의 개수를 강제로 늘리거나 개수가 많은 데이터의 개수를 줄이는 업샘플링이나 다운 샘플링을 해서 알고리즘에 적용

=>평가지표를 다양하게 선택 - 정확도 대신에 재현율이나 F1 통계량 등을 이용

정확도 , 재현율 등 .. 어느 하나 선택할 때는 결과가 외곡 될 수 있다.

정확도 , 재현율 ,F1통계량 결정 계수 등  정확하게 뭘 의미하는 지 알아야 한다.

분석은 어렵지 않다.그 결과를 판정하는 데 어렵고 뭐하는지 알아야 한다.

 

 

import numpy as np

import pandas as pd

 

#0이 10개이고 1이 90개 인 ndarray생성

list1 =[]

for i in range(0,10,1):

    list1.append(0)

 

list2 =[]

for i in range(0,90,1):

    list2.append(1)

   

#2개의 list를 가지고 하나이 array생성

target = np.array(list1+ list2)

#list더하기 하면 결합이고

#분석은 더하기 하면 더하기 이다.

print(target)

 

#분류 알고리즘에 위의 데이터를 이용하는 경우

#0: 10% 1 : 90%

from sklearn.ensemble import RandomForestClassifier

#데이터의 비율이 헌저하게 다르기 때문에 가중치 설정

weights = {0:0.9, 1:0.1}

#비율은 반대로 쓴다. 10%, 90%

#0.9 = .9

rfc = RandomForestClassifier(class_weight = weights)

print(rfc)

 

#assemble하고 down는 같이 하면 안된다.

 

#가중치를 직접 설정하지 않고 분류기에게 판단하도록 해주는 옵션

rfc = RandomForestClassifier(class_weight='balanced')

print(rfc)

 

#샘플링 비율 조건

#np.where(target == 0)

#target행렬에서 값이 0인 데이터의 행번호를 리턴

#(행번호행렬, 자료형)으로 결과를 리턴

#행번호행렬만 가져오기 위해서 [0]을 추가

class0 = np.where(target == 0)[0]

class1 = np.where(target == 1)[0]

print(len(class0))

print(len(class1))

 

#target이 1인 데이터에서 target이 0인 데이터만큼 다운 샘플링을 해서

#새로운 데이터 셋을 생성

#class1에서 class0의 데이터 개수 만큼 비복원 추출 (나온것은 제거)

#assembling랄 때는 복원 추축

downsample = np.random.choice(class1, size = len(class0) , replace= False)

result = np.hstack((target[class0], target[downsample]))

#0개에서는 90개 만들 수 없다.

#downsample = np.random.choice(class0, size = len(class1) , replace= True)

#result = np.hstack((target[class1], target[downsample]))

print(result)

 

** 다변량 분석에서 데이터의 상대적 크기 문제

=>다변량 분석 - 2개이상의 컬럼의 데이터를 가지고 분석

=>하나의 컬럼의 데이터는 값의 범위가 0-100이고 다른 컬럼의 데이터는 값이 범이가 0-1이라면 이 경우 2개의 데이터를 가지고 다변량 분석을 하게 되면 첫번째 컬럼의 영향을 받게 될 수 있습니다.

이런 경우에는 값의 범위를 일치시켜 주는 것이 좋습니다.

=>값의 범위는 같은데 분포가 다른 경우에도 분포를 기준으로 값을 조정할 필요가 있습니다.

최대값으로 나누거나 최대값 - 최소값을 분모로하고 해당값 - 최소값을 분자로 해서 값을 조정

=>이러한 값의 조정을 scalling이라고 합니다.

0-1 사이나 -1~1사이로 조정합니다.

더 큰 값으로 가능하지만 머신러닝 모델에서는 값으 크기가 커지면 정확도가 떨어집니다.

 

 

1.표준화

=>모든 값들의 표준 값을 정해서 그 값을 기준으로 차이를 구해서 비교하는 방법

1)표준값: (데이터- 평균) /표준편차 -표준 값의 평균은 50 (사람한테 줄 때 )

2)편차값: 표준값 * 10 + 50 -위의 숫자보다 큰  숫자로 변환

 

#표준화

#student.csv파일의 내용을 가져오기

#index로 이름을 설정

import os

print(os.getcwd())

#utf8이 아니다.

data = pd.read_csv('./Desktop/data/student.csv', index_col ='이름',encoding = 'cp949')

print(data)

 

#그래프에 한글을 출력하기 위한 설정

import matplotlib.pyplot as plt

import platform

from matplotlib import font_manager, rc

#매킨토시의 경우

if platform.system() == 'Darwin':

    rc('font', family='AppleGothic')

#윈도우의 경우

elif platform.system() == 'Windows':

    font_name = font_manager.FontProperties(fname="c:/Windows/Fonts/malgun.ttf").get_name()

    rc('font', family=font_name)

 

#인덱스를 기준으로 해서 막대 그래프 그리기

data.plot(kind='bar')

 

#표준값 - 작업

#평균을 표준 편차로 나누어서 계산

#각과목의 평균과 표준편차 구하기

kormean, korstd = data['국어'].mean(), data['국어'].std()

engmean, engstd = data['영어'].mean(), data['영어'].std()

matmean, matstd = data['수학'].mean(), data['수학'].std()

 

 

#표쥰값 구하기 -(자신의 값 - 평균 )/ 표준편차

#내가 0.0이면 중간

#편차값이 1.0이면 항상 상하위 15%

#2.0 상하위 1.1%

#음수가 있을 수 있다.

data['국어표준값'] = (data['국어']- kormean )/korstd

data['영어표준값'] = (data['영어']- engmean )/engstd

data['수학표준값'] = (data['수학']- matmean )/matstd

print(data[['국어표준값','영어표준값','수학표준값']])

#박지영은 국어는 영어보다 잘 한다.  수학은 못한다.

 

#음수를 잘 안보이기 때문에 우리가 자주사용하는 숫자로 변한다.

 

#표준값은 비교가 가능하기는 하지만 사람이 알아보기 불편

#표준값 * 10 + 50 을 해서 편차값을 만들어서 보고서를 만듬

 

 

data['국어표준값'] = data['국어표준값']* 10 + 50

data['영어표준값'] = data['영어표준값']* 10 + 50

data['수학표준값'] = data['수학표준값']* 10 + 50

print(data[['국어표준값','영어표준값','수학표준값']])

 

 

data[['국어표준값','영어표준값','수학표준값']].plot(kind='bar')

 

 

#최대값으로 나누어서 표준화  - 정규화로 많이 불리운다.

#자신의 값 - 최소값/ 최대값 - 최소값으로 하기도 함

#0.0 ~ 1.0 사이로 있다.

data['국어정규화1']  = data['국어'] / data['국어'].max()

data['국어정규화2']  =( data['국어']- data['국어'].min()) / (data['국어'].max()-data['국어'].min())

 

 

 

2.sklearn의 정규화

1)StandartScaler: 평균이 0이고 표준편차가 1이 되도록 변환

(백터- 평균) / 표준편차

주로 주성분분석에서 많이 이용

음수가 잇을 가능성 있다.

 

2)MinMaxScaler:  최대값이 1 최소값이 0 이 되도록 변환

(백터 - 최소값) /(최대값 - 최소값)

신경망에서 주로 이용 (cnn, rnn)

 

 

 

3)RobustScaler: 중앙값이 0 IQR(4분위수 )를 이용하는 방식

(백터 - 중간값) /( 75%- 255)

=>앞의 방식들은 outlier(이상치)에 영향을 많이 받습니다.

=>데이터의 분포가 불균형이거나 극단치가 존재하는 경우에 주로 이용

 

 

 

0 1 2 3 4 5 6 100->이상치가 있을 수 있다. 1),2) OUTLIER

그래서 75%의 값 25%의 값

그래서 최대값 최소값 영향을 받지않는다.

 

 

4)QuantileTransformer:데어터를 1000개의 분위로 나눈 후 0-1 사이에 고르게 분포시키는 방식

=>outlier 의 영향을 적게 받기 위해서 사용

 

 

0 ~ 100 사이의 데이터인데

17 27 25 16 41 33 27 -> 이렇게 된것은 표준화 하면 안좋다. 데이터의 분포가 작아서

표준화 하면 꼭 고려해야 할 두가지 데이터 분포 , outlier

아주 큰 값 있으면 하나 버리기

데이터 분포가 완전히 쏠려져 있을 경우에는 정규화를 하지 않는다.

 

변화 하면 fit_transform

모델에 적용하면 fit 이다.

표준화는 값만 가지고 해야 한다.

 

 

 

#표준화 작업

#sklearn을 이용한 scailing

from sklearn import preprocessing

 

#StandardScaler

#StandardScaler - 평균은 0 표준편차는 1이 되도록 표준화

scaler = preprocessing.StandardScaler()

#국어 점수만 이용하는 경우 data['국어'] 가 아닌고 data[['국어']]

#머신러닝의 데이터들은 행렬을 이용하는데 data['국어']하게 되면 컬럼이름이

#1개라서 하나의 열로 리턴되서 1차원 데이터가 됨

#data[['국어']] 하게 되면 list를 대입하기 때문에 datafrmae으로 리턴

result = scaler.fit_transform(data[['국어']].values)

print(result) #표준값 구한 것

print(np.mean(result)) #평균이 0에 가까워진다. 1.2335811384723961e-17 ->거의 0이다 e의 17승

print(np.std(result)) # 값이 1에 가까워진다.

 

 

 

#MinMaxScaler

#MinMaxScaler - 음수가 안나온다. 최대값 최소값 이용해서 하기 때문에

scaler = preprocessing.MinMaxScaler()

result = scaler.fit_transform(data[['국어']].values)

print(result)

print(np.mean(result))

print(np.std(result))

 

 

#RobustScaler

#RobustScaler - 음수가 나온다.  이상치 값이 있을 때 해결하기 위한 것

scaler = preprocessing.RobustScaler()

result = scaler.fit_transform(data[['국어']].values)

print(result)

print(np.mean(result))

print(np.std(result))

 

 

#QuantileTransformer

#QuantileTransformer - 음수가 나오지 않는다. 데어터 분포를 고려해야 한다. 데이터가 적으면 안된다.

scaler = preprocessing.QuantileTransformer()

result = scaler.fit_transform(data[['국어']].values)

print(result)

print(np.mean(result))

print(np.std(result))

 

 

**정규화

=>값의 범위를 0 -1 사이의 데이터로 변환

=>표쥰화는 일정한 범위 내로 데이터를 변환하는 것이고 정규화는 0-1 사이로 해야 합니다.

=>Normalizer클래스를 이용해서 transform메소드에 데이터를 대입하면 됩니다.

이 때 norm매개변수에 옵션을 설정할 수 있는데 l1, l2, max등의 값을 설정할 수 있습니다.

max는 최대값으로 나누는 방식

l1과 l2는 거리 계산 방식

l1-  맨하턴 거리를 이용하고 l2는 유클리드 거리를 이용

맨하탄 거리  -> 장애물이 있을 경우에는 직접 못간다.'

이 두개 크기 자체는 별로 차이 안나는데 계산 방식이 다르다.

게임 shoting게임 할 때 사용한다.

A 과 B 거리 계산 할때 거리 계산한다. 거리가 멀면 시간이 오래 걸린다.

ping할 때  ttl ->라우터의 계수

 

 

 

 

#이차원 행렬을 생성

matrix = data[['국어','영어']].values

print(matrix)

 

 

matrix = np.array([[30,20],[10,30],[30,40]])

print(matrix)

 

from sklearn import preprocessing

 

#l1-  맨하턴 거리를 이용하고 l2는 유클리드 거리를 이용

#정규화 객체 생성 - 유클리디안 거리를 사용

norm = preprocessing.Normalizer(norm = 'l2')

print(norm.transform(matrix))

# 30 /  30의 2승 + 40의 2승 에 root => 30 / 50

 

#합을 가지고 나누느 방식

norm = preprocessing.Normalizer(norm = 'l1')

print(norm.transform(matrix))

# 30 / 50  20/50

 

#큰값을 가지고 나누는 방식

norm = preprocessing.Normalizer(norm = 'max')

print(norm.transform(matrix))

#30/40  40/40

 

 

** 다항과 교차항 특성

=>기존 데이터에 데이터들을 곱하고 제곱을 해서 데이터를 추가하는 것

=>특성과 타겟 사이에 비선형 관계과 존재할 때 사용하는 방식

=>비선형 관계는 2개의 관계가 직선의 형태가 아니고 곡선의 형태인것

=>각 특성이 다른 특성에 영향을 줄 때 각 특성을 곱할 교차형을 가지고 인코딩

=>다변량 분석(2개 이상의 컬럼을 가지고 분석) 을 할 때 2개의 컬럼 사이에 상관관계가 있는 경우가 있는데 이런 경우 2개의 컬럼 모두를 가지고 분석을 하게 되면 다중공선성 문제가 발생할 수 있습니다.

어떤 컬럼의 값을 알면 다른 컬럼의 값을 예측할 수 있는 경우 발생할 수 있는 문제입니다.

이런 경우에는 2개의 컬럼을 1개의 컬럼으로 변환하는 작업을 해야 하는데 (차원축소) 이런 경우 더하거나 거나 제곱해서 새로운 값을 만들어냅니다ㅣ.

 

 

 

=>PolynomialFeatures 클래스를 이용하는데 몇 차 항 까지 생성할 것인지 degree에 설정

첫번 떄 데이터로 1을 추가할 지 여부를 include_bias에 설정

=>연산식의 순서는 get_features_names메소드를 이용해서 확인 가능

 

[ 1 , 2 ]            degree  = 2 제곱 까지 만 한다.

[1 , 2 , 1의 제곱 1, 1 * 2 = 2, 2의 제곱 = 4 ]

2를 적용하면 5개 데이터를 만든다.

[4,7]

[4, 7, 16, 28, 49 ]

 

degree = 3

[4, 7, 16, 28, 49 , 64, .......]

[[  4.   7.  16.  28.  49.  64. 112. 196. 343.]]

차원 축소 할 때 데이터를 만들어 낸다.

4의 2승 * 7 ,

28 * 6  * 7 = 196

 

 

 

 

 

matrix = np.array([[30,20],[10,30],[30,40]])

print(matrix)

 

#다항과 교차항을 만들어주는 객체를 생성

#include_bias = False 첫번 때 0을 안 집어 여겠다.

# degree = 2: 제곱한 것 까지 생성

polynomial  = preprocessing.PolynomialFeatures(degree = 2, include_bias = False)

result = polynomial.fit_transform(matrix)

print(result )

 

matrix = np.array([[4,7]])

print(matrix)

 

polynomial  = preprocessing.PolynomialFeatures(degree = 3, include_bias = False)

result = polynomial.fit_transform(matrix)

print(result )

 

**표준화나 정규화는 직접 하는 경우가 많지만 다항식을 만드는 것은 머신러닝 알고리즘에서 자체적으로 처리하는 경우가 많음

 

**특성 변환

=>데이터에 동일한 함수를 적용해서 다른 데이터로 직접 변환하는 것

=>pandas에서는 apply메소드를 이용하고 sklean에서는 preprocessing.FunctionTransformer나 ColumnTransformer클래스를 이용ㅇ

=>FunctionTransformer는 모든 열에 동일한 함수를 적용하고  ColumnTransformer는 서로 다른 함수를 적용할 수 있습니다.

객체를 생성할 때 적용할 함수를 설정해서 만들고 transform 메소드에 데이터를 대입하면 됩니다.

 

import numpy as np

from sklearn import preprocessing

#함수 적용하기

matrix = np.array([[100,200],[300,150]])

print(matrix)

#위 데이터를 정수로 변환하기

#100을 결합하기

def intconvert(x):

    return x + 100

#행렬을 변환해서 리턴해준다.

transformer = preprocessing.FunctionTransformer(intconvert)

result = transformer.fit_transform(matrix)

print(result)

print(data['국어'])

print(data['국어'].apply(intconvert))

 

 

**Outlier 감지

=>Outlier 이상치나 극단치 , 일반적인 데이터의 범위를 넘어선 값

1.z점수를 이용하는 방법 : 중앙값을 기준으로 표준편차가 3 또는 -3 범위의 바깥똑에 있는 데이터를 Outlier 로 간주

2.z점수의 보정 :z 점수는 데이터가 12개 이하이면 감지를 못함

넘 작으면 표준편차가 잡지 못하기 때문에

편차의 범위를 3.5로 늘리고 0.6745를 곱한 값을 이용

3.IOR(3사분위수 - 1사 분위수)이용: 1사분위수 (25%)보다 1.5 IQR 작은 값이나 3사분위수(75%) 보다 1.5IQR 큰 데이터를 outlier 로 간주

 

 

1,2,3 10004

10010/4

 

1,2,3 10004 , 10004 => 이 경우에는 outlier가 알될수 도 있다. 많이 적으면 outlier가 나올 수 있다.

 

 

import numpy as np

import pandas as pd

 

 

#array를 입력받아서 z 점수(표준편차의 3배) 밖에 있는 데이터를 리턴해주는 함수

def z_score_outlier(ar):

    threshold  = 3

    #평균 가져오기

    meandata = np.mean(ar)

    stdevdata = np.std(ar)

    #stdevdata for y in ar의 요소를 y에 하나씩 대입하고 앞에 수식을 적용해서 결과를 가지고

    #다시 list를 만드는 것

    z_scores  = [(y-meandata) / stdevdata for y in ar]

    return np.where(np.abs(z_scores) > threshold)

 

#샘플 데이터 생성

#features = np.array([[10,30,13,-20,4,12],[20000,3,5,4,2,1]])

#features = np.array([[10,30,1003,-20,4,12],[2,30,5,4,2,1]])

    #(array([0], dtype=int64), array([2], dtype=int64)) 0에 2번

#features = np.array([[10,30,13,-20,4,12],[2,9,5,4,2,10]])#없다.

features = np.array([[10,30,13,-2000000,4, 12, 10,30, 13, 11, 4, 12,10,30,13,20,4,2,4,2],

                     [2,9,5,4,2,2000000,10,30,13,20,4,12,10,30,13,20,4,2,4,2]])

#(array([0, 1], dtype=int64), array([3, 5], dtype=int64))

    #0번에 3 1번에 5

 

result = z_score_outlier(features)

print(result)

 

 

#z score 보정  -범위를 3.5배로 널리고 표준편차 0.6875를 곱해줍니다.

def modify_z_score_outlier(ar):

    threshold  = 3.5

    #평균 가져오기

    meandata = np.mean(ar)

    stdevdata = np.std(ar)

    #stdevdata for y in ar의 요소를 y에 하나씩 대입하고 앞에 수식을 적용해서 결과를 가지고

    #다시 list를 만드는 것

    z_scores  = [0.6875 * (y-meandata) / stdevdata for y in ar]

    return np.where(np.abs(z_scores) > threshold)

 

#샘플 데이터 생성

features = np.array([[10,30,13,-20,4, 12, 10,30, 13, 11, 4, 12,10,30,13,20,4,2,4,2],

                     [2,9,5,4,2,2000000,10,30,13,20,4,12,10,30,13,20,4,2,4,2]])

#(array([0, 1], dtype=int64), array([3, 5], dtype=int64))

 

result = modify_z_score_outlier(features)

print(result)

 

 

#iqr이용 : 3 사분위수 - 1사분위의 +- 1.5 배이상 차이나면 이상치로 간주

def iqr_outlier(ar):

    #25%와 75%의 값 찾기

    q1 ,q3 = np.percentile(ar,[25,75])

    #iqr값 찾기

    iqr = q3- q1

    #25% 값과 .5 iqr보다 작은 값 찾기

    lower = q1- iqr*1.5

    upper = q3 + iqr* 1.5

    return np.where( (ar > upper )| (ar < lower))

 

#샘플 데이터 생성

features = np.array([[10,30,13,-20,4, 12, 10,30, 13, 11, 4, 12,10,30,13,20,4,2,4,2],

                     [2,9,5,4,2,2000000,10,30,13,20,4,12,10,30,13,20,4,2,4,2]])

 

 

result = iqr_outlier(features)

print(result)

 

 

**Outlier처리

1.제거

=>설문조사를 했는데 이상한 데이터가 입력된 것 같은 경우

=>분석 목적에 맞지 않는 데이터인 경우

 

 

2.이상한 데이터로 표현해두고 특성의 하나로 간주

이상한 상황을 없에면 안되고 특수한 상황으로 해야 한다.

 

3. outlier의 영향이 줄어돌도록 특성을 변환 - 값의 범위를 줄임(표준화, 정규화 등)

=> 표준화 할 때는 RobustScalar를 이용하는 것이 좋음

 

 

house = pd.DataFrame()

house['price'] = [100000,200000,150000,10000000]

house['rooms'] = [1,3,2,100]

house['square'] = [11,23, 16, 1200]

print(house)

 

 

#이상한 데이터 제거 : 방이 5개 이상 제거

print(house[house['rooms'] < 6])

#이상한 데이터를 별도로 표시

house['outlier'] = np.where(house['rooms'] < 6 , 0,1)

print(house)

 

 

#값의 범위 줄이기 -np.log는 자연 로그를 계산

house['log'] = [np.log(x) for x in house['rooms']]

print(house)

 

** 시계열 데이터

=>날짜 및 시간에 관련된 데이터

1.pandas의 시계열 자료형

=>datatime64 : 부등호를 이용해서 크기비교를 할 수 있고 - 를 이용해서 뺄셈을 할 수 있음

=>Period:두개의 날 짜 사이의 간격을 나타내기 위한 자료형

=>시계열 자료형을 별도로 구성하는 이유는 일정한 패턴을 만들기 쉽도록 하기 위해서

 

 

 

2. 생성

=>문자열 데이터를 시계열로 변경 : pandas.to_datetime()이용

날짜 형식의 문자열과 format매개변수에 날짜 형식을 대입

 

 

#문자 데이터를 pandas의 시계열 데이터로 만들기

df = pd.read_csv('./Desktop/data/stock-data.csv')

print(df)

#자료형 확인

print(df.info())

#Date 컬럼의 값을 시계열로 변경해서 추가

df['newDate'] = pd.to_datetime(df['Date'])

print(df.info())

 

 

#위와 같은 데이터프레임에서는

#날짜를 index로 설정하는 경우가 많습니다.

df.set_index('newDate',inplace = True)

df.drop('Date',axis = 1 , inplace = True)

print(df.head())

 

 

 

 

 

3.Period 간격을 나타낸다.

=>pandas.to_period 함수를 이용해서 datatime을 period로 생성

freq 옵션에 기준이 되는 기간을 설정

=>freq옵션

 

D: 1일

W: 1주

M 1개월 (월말 기준)

MS: 1개월 (월초 기준)

Q: 분기말

QS :  분기초

A:연말

AS:초

B: 휴일제외

H,T,S,L,U,N: 시간 , 분 , 초 , 밀리초 , 마이코로초 , 나노초

 

 

#일정한 간격을 갖는 날짜 만들기

dates = ['2017-03-01','2017-06-01','2019-12-01']

print(dates)

#날짜로 변경

pddates = pd.to_datetime(dates)

print(pddates)# DatetimeIndex로 바꿔졌다.

 

 

#Period로 변환

pdperiod  = pddates.to_period(freq = 'D')

print(pdperiod)

#PeriodIndex(['2017-03-01', '2017-06-01', '2019-12-01'], dtype='period[D]', freq='D')

 

pdperiod  = pddates.to_period(freq = 'M')

print(pdperiod)

#PeriodIndex(['2017-03', '2017-06', '2019-12'], dtype='period[M]', freq='M')

 

pdperiod  = pddates.to_period(freq = 'Q')

print(pdperiod)

 

pdperiod  = pddates.to_period(freq = 'A')

print(pdperiod)

 

 

 

5.date_range()

=>일정한 간격을 소유한 날짜 데이터의 집합을 생성

=>매개변수

start: 시작 날짜

end: 종료 날짜

periods: 생성할 날짜 개수

freq: 간격

tx: 시간대

 

 

 

#일정한 간격을 가진 날짜 데이터 생성

ts_ms = pd.date_range(start = '2018-01-01',end = None, periods = 12, freq = 'M')

print(ts_ms)

 

ts_ms = pd.date_range(start = '2018-01-01',end = None, periods = 12, freq = 'D')

print(ts_ms)

 

#2H ->2시간씩

ts_ms = pd.date_range(start = '2018-01-01',end = None, periods = 12, freq = '2H')

print(ts_ms)

 

 

6.날짜 데이터에서 필요한 부분 추출하기

=>dt.year, dt.month, dt.day...

=>요일은  dt.weekday_name은 문자열로 dt.weekday하면 숫자로 리턴 (월요일이 0)

화면에 출력할 때는 문자열로 하고 머신러닝을 사용할 때는 숫자로 리턴 받습니다.

ts_year = df['newDate'].dt.year

print(ts_year)

 

df['year'] = df['newDate'].dt.year

print(df['year'])

 

 

7.python에서는 날짜는 datetime패키지의 datetime으로 제공

=>날짜 형식의 문자열을 가지고 날짜 형식의 데이터를 생성

 

 

8.shift함수를 이용하면 기존 날짜를 이동시키는 것이 가능

=>freq 매개변수에 간격을 설정할 수 있습니다.

 

 

#python의날짜 패키지

from datetime import datetime

dates = [datetime(2017,1,1),datetime(2017,1,4),datetime(2017,1,7)]

ts = pd.Series(np.random.randn(3) , index = dates)

print(ts)

print(ts.shift()) #데이터를 하나씩 민다. 아래쪽으로

print(ts.shift(1)) #데이터를 하나씩 민다. 아래쪽으로

print(ts.shift(-1)) #데이터를 하나씩 반대로 민다. 위로

 

 

9.resampling

=>시계열의 빈도를 변환하는 것

=>상위 빈도의 데이터를 하위 빈도의 데이터로 변환하는 것을 다운 샘플링이라고 하고 반대의 과정을 asampling이라고 한다.

=>resampling(freq, how, fill, method, closed, label , king)

freq: 리샘플링 빈도(M,Q, A등)

how: 집계함수를 지정하는 것으로 기본은 mean(평균을 구한다.) first, last, max, median ,min등

데이터가 있으면  합계등 골라내다.

fill_method: 업 샘플링할 때 데이터를 채우늠 옵션이므로 기본은 None인데 fill이나 bfill을 설정해서 이전값이나 이후값으로 채울 수 있음

closed: 다운 샘플링을 할 때 왼쪽과 오른쪽 어느쪽을 호팜시킬지 설정

label: 다운 샘플링을 할 때 레이블을 왼쪽 또는 오른쪽을 사용할 것인지 여부

 

 

 

#일정한 조건으로 집계

ran = pd.date_range('11/3/2010',periods = 20, freq ='T')

print(ran)

 

ts = pd.Series(np.arange(20),index = ran)

print(ts)

#5개씩 하면 5분단위로 할 수 있다.

#실데이터는 다르다. 10분마다

#label을 0분이나 4분이나 할 것이다

 

#5분 단위로 합게

print(ts.resample('5T').sum())

 

print(ts.resample('5T').mean())

 

 

10.날짜 데이터가 데이터프레임에 존재하는 경우 날짜 데이터를 인덱스로 설정하면 특정 시간단위로 집계를 하는 것이 쉬워집니다.

 

**이동시간 윈도우

=>통계적 수치를 계산을 할 때 최근의 데이터에 가중치를 부여해야 한다라는 개념

평균을 구할 때 데이터 전체의 평균을 구하는 것 보다는 최근의 데이터 몇 개의 평균을 구하는 것이 미래를 예축할 때는 더 잘 맞을 가능성이 높다.

이전 데이터와 최근의 데이터를 같이 사용할 거라면 최근의 데이터에 가중치를 부여하는 것이 미래를 예측할 때는 더 잘 맞을 가능성이 높다.

 

 

1.rolling 함수

=>단순 이동 평균을 계산해주는 함수

=>winodw 매개변수에 데이터 개수를 설정하면 데이터 개수 단위로 연산을 수행

 

 

2.ewm함수

=>지수 이동 평균을 계산해주는 함수

=>지수 이동 평균은 최근의 데이터에 가중치를 부여하는 방식의 평균

주식 데이터는 이 평균을 사용합니다.

=>기간(span)을 설정하면 아래 수식으로 평균

데이터가 3개인 경우

x1, x2, x3(가장 최근 데이터)

1-span을 알파라고 합니다.

 

x3+(1-(1-span)) x2 +(1-(1-span) )제곱 x3  / 1 + (1-알파) +(1-알파)제곱

숫자를 줄인다.

 

 

500 2000 2300 2700

3일

2000 +2500+2700 / 3

반영율을 조정한다.

 2500 + (1-1/3) * 2000 + (1-1/3)2 의 제곱 * 2000

 

지수 이용 평균

어느 속도를 기준해서 낮아진다. 불량율 , 숙련도 주식등에서 많이 사용한다.

 

시간에 따라 변경되는

데이터를 가지고 계속 할 때는 최근의 데이터

가중치를 부여해야 한다.

에이징 커브 -전년도 데이터를 해서 하는 것

최근에 얼마 사용했는지에 따라 가중치를 준다.

휴대폰이 2년 100시간 최근에는 2시간

 

 

python문법 ->데이터 가공 numpy pandas ->

sklearn

회귀 군집 알고리즘 등