파이썬 Matplotlib을 이용한 데이터 시각화 프로그래밍15 - 서브플롯 활용하기

이번에는 서브플롯을 활용하여 한 화면에 여러가지 그래프를 보는 방법에 대해 살펴봅니다.

여태까지 다룬 소스코드는 주가트렌드, 주가캔들 그리고 미국 출생아수에 대한 그래프를 출력하는 것이었죠.

이들 세 가지 그래프를 서브플롯을 이용해 그려봅니다.

서브플롯은 아래의 코드로 3개로 구분합니다.

>>> ax1 = plt.subplot2grid((2, 2), (0, 0))

>>> ax2 = plt.subplot2grid((2, 2), (0, 1))

>>> ax3 = plt.subplot2gird((2, 2), (1, 0), colspan=2)

ax1에는 주가트렌드 그래프를, ax2에는 주가캔들 그래프를, ax3에는 미국 출생아수 그래프를 출력하도록 이전 코드를 활용해서 그려봅니다.

14편까지 충실하게 따라왔다면 아래 코드는 별로 설명할 것이 없습니다.

결과는 아래와 같습니다.

이 예에서는 미국 출생아수 그래프는 나머지 2개와 관련이 없는 것이지만, 이런 유형의 데이터 시각화는 서로 상관이 있는 것들을 다른 각도에서 살펴보기 위해 많이 활용됩니다.

자, 그러면 연관성이 있는 주가트렌드와 주가캔들을 서브플롯을 활용하여 한눈에 보이도록 해봅니다.​

x축의 값은 날짜로 동일하며, y축의 값은 주가이므로 동일한 스케일로 그려주면 될 것 같습니다.

​

이를 위해서 x축을 공유하여 서브플롯을 정의합니다. ax1에는 주가트렌드를, ax2에는 주가캔들을 그릴 겁니다.

​

>>> ax1 = plt.subplot2grid((2,1), (0,0))

>>> ax2 = plt.subplot2grid((2,1), (1,0), sharex=ax1)

그리고 y축의 스케일을 같게 두기 위해 주가트렌드 그래프 및 주가캔들을 그린 후 아래의 코드를 추가합니다.

주가트렌드 그래프를 그린 후 추가할 코드

>>> ax1.yaxis.set_major_locator(mticker.MaxNLocator(nbins=5, prune='lower'))

주가캔들을 그린 후 추가할 코드

>>> ax2.yaxis.set_major_locator(mticker.MaxNLocator(nbins=5, prune='upper'))

​

마지막으로 plt.show()를 호출하기 전에 아래 코드를 삽입하여 ax1의 x축에 표시되는 눈금 라벨을 보이지 않게 합니다.

>>> plt.setp(ax1.get_xticklabels(), visible=False)

수정된 drawStockTrend() 함수 부분은 아래와 같습니다.

코드 실행 결과는 아래와 같습니다.

파이썬 Matplotlib을 이용한 데이터 시각화 프로그래밍14 - 그래프 또는 차트에 주석 달기

데이터를 분석하여 그래프나 차트로 보여줄 때 중요한 이벤트나 이슈 등이 있다면 이를 텍스트나 화살표로 표시하면 사용자에게 보다 친절함을 제공해줄 수 있습니다.

13편에서 활용한 데이터는 1880년 이후로 미국에서 태어난 남자아이, 여자아이 출생수를 그래프로 나타낸 것입니다. 그래프를 보면 1958년 정도에 피크를 보인 후 점차 출생자수가 줄어드는 것을 알 수 있습니다.

1958년에 즈음에 태어난 세대들을 우리나라에서는 베이비붐 세대라고 하는데 미국에서도 마찬가지네요. 차트에 이 부분을 '베이비붐'이라고 표시를 해보도록 하겠습니다.

13편의 코드와 달라진 부분은 하나입니다.

>>> ax.annotate('베이비붐', (1958, y2[1958-1881]), xytext=(0.7, 0.95),

        textcoords='axes fraction', arrowprops=dict(color='g', alpha=0.5))

annotate()는 플롯에 텍스트를 표시하며 옵션으로 화살표도 표시할 수 있습니다. annotate()에 사용된 인자를 살펴보면,

• '베이비붐': 플롯에 표시할 텍스트
• (1958, y2[1958-1881]): 화살표를 그리는 경우 화살표 끝이 지시할 위치. 좌표값으로 표시함
• xytext=(0.7, 0.95): 텍스트가 위치할 지점. textcoords 인자가 'axes fraction'인 경우 0.7과 0.95는 플롯의 가로, 세로방향으로 70%와 95%위치임을 의미함
• textcoords='axes fraction': xytext의 인자는 가로방향, 세로방향의 비율로 지정
• arrowprops=dict(color='g', alpha=0.5): 화살표의 속성을 사전 자료로 지정. 색상은 green, 투명도는 0.5로 설정함. 여기에 사용될 수 있는 인자는 여기를 참고

여기서 텍스트 위치를 지정하는 xytext는 textcoords 인자에 따라 인자의 값이 의미하는 바가 다릅니다. textcoords를 지정하지 않으면 xytext로 지정되는 값은 디폴트로 좌표값이 됩니다.

이 코드를 실행하면 아래와 같습니다.

이제, 베이비붐 시기에 태어난 남자아이 여자아이 출생수를 차트에 삽입해보겠습니다.

이 역시 annotate()를 사용할 것인데, 위 코드의 plt.legend(loc=4) 앞부분에 아래의 코드를 삽입합니다.

>>> bbox_props_f = dict(boxstyle='round', fc='w', ec='r', lw=2)

>>> bbox_props_m = dict(boxstyle='round', fc='w', ec='b', lw=2)

주석을 둥근 모서리 사각형으로 둘러싸기 위해 박스 속성을 위해 사전자료를 정의합니다. 주요 인자는 다음과 같습니다.

• boxstyle='round': 박스스타일을 둥근 모서리 사각형으로 지정 
• fc = 'w': 사각형을 흰색으로 채움
• ec='r': 외곽선을 빨간색 선으로 함
• lw=2: 선두께를 2로 설정

annotate()에 사용되는 화살표 및 박스 속성 인자에 대해 보다 많은 정보는 여기를 참고하세요~

annotate()의 인자로 bbox= 가 있음을 알 수 있습니다. 코드를 실행하면 아래와 같은 결과가 나옵니다.

파이썬 Matplotlib을 이용한 데이터 시각화 프로그래밍13 - Matplotlib 스타일 적용하기

Matplotlib은 그래프를 다양한 스타일로 출력할 수 있게 해줍니다. 윈도우 커맨드 창을 열고 파이썬을 실행한 후 아래의 코드를 입력하고 돌려봅니다.

>>> from matplotlib import style

>>> print(style.available)

화면에 출력되는 것은 Matplotlib에서 사용 가능한 스타일입니다.

• seaborn-dark-palette
• seaborn-darkgrid
• seaborn-whitegrid
• seaborn-colorbline
• seaborn-poster
• seaborn-paper
• seaborn-ticks
• seaborn-notebook
• seaborn-pastel
• seaborn-deep
• seaborn-white
• seaborn-dark
• seaborn-muted
• seaborn-talk
• seaborn-bright
• bmh
• dark_background
• classic
• fivethirtyeight
• ggplot
• grayscale

스타일을 적용하려면 여태까지 여러분이 작성한 코드에 matplotlib.style을 import하고 아래 한줄을 추가하면 됩니다.,

>>> style.use(스타일)

예를 들어 dark_background를 적용하려면

>>> style.use('dark_backgroud')

로 하면 됩니다.

단, 몇몇 스타일에서는 한글이 제대로 동작하지 않는 경우도 있네요. 이 부분은 아직 제가 해결하지 못했습니다. 뭐 언젠가는 해결되겠죠~

아래는 7편에서 다루었던 코드에 몇몇 스타일을 적용한 결과입니다.

seaborn-talk

ggplot

dark_background

이것 말고 다른 스타일은 각자가 한번씩 사용해보기 바랍니다.

파이썬 Matplotlib을 이용한 데이터 시각화 프로그래밍12 - 주가 캔들 그리기

이왕 Matplotlib을 응용하는 예로 주식 가격을 예로 들었으므로, 주가 캔들을 그리는 방법에 대해 알아겠습니다. 주식에 전혀 관심 없는 분들도 있겠지만 주식을 조금이라도 해본 분들은 주가 캔들에 대해 많이 알고 있을거라 생각합니다.

흔히 주가 캔들을 양봉, 음봉으로 부르기도 하는데, 우리나라 주식 시장에서 빨간색은 좋은 것이고, 파란색은 별로 안좋은 것이죠. 무슨 말인고 하면 빨간색은 주가가 전날에 비해 올라갔다는 말이고, 파란색은 전날에 비해 내려갔다는 의미입니다.

먼저, 11편에서 다루었던 코드를 약간 수정하여 삼성전자 주가의 1달치를 가져와서 주가 캔들을 그려보는 코드를 작성합니다.

코드의 주요 부분만 살펴봅니다.

>>> import matplotlib.finance import candlestick_ohlc

주가 캔들을 그려주기 위해 matplotlib의 필요한 모듈을 import 합니다.

>>>  ohlc = []

     for i in range(len(date)):

         stock_data = date[i], openp[i], high[i], low[i], closep[i], volume[i]

         ohlc.append(stock_data)

주가를 뽑아낸 기간 동안 날짜, 시작가, 고가, 저가, 종가, 거래량 순으로 묶어 ohlc의 요소로 추가합니다.

>>> candlestick_ohlc(ax, ohlc, width=0.5, colorup='r', colordown='b')

주가 캔들을 그립니다. 그릴 공간은 서브플롯 ax, 데이터는 ohlc, 주가 캔들의 폭은 0.5, 양봉은 빨간색으로, 음봉은 파란색으로 그려라는 의미입니다.

>>> ax.xaxis.set_major_formatter(mdates,DateFormatter(%Y-%m-$d))

>>> ax.xaxis.set_major_locator(mticker.MaxNLocator(10))

그래프 좌표의 x축을 설정합니다. 눈금에 표시할 라벨을 날짜 형식으로 지정하고, 눈금의 개수를 10개 정도로 합니다.

이 값을 변경해보면 그래프의 모양이 바뀌는 것을 알 수 있습니다.

코드 실행 결과는 아래와 같습니다.

파이썬 Matplotlib을 이용한 데이터 시각화 프로그래밍11 - Spine과 임의의 수평선을 기준으로 상하 부분 색칠하기

Spine은 영어로 척추를 의미합니다. 척추란 동물이나 사람의 몸을 지탱하는 중요한 역할을 하죠. 플로팅에서 Spine이란 좌표의 테두리를 굵게 표시하는 것으로 생각하면 됩니다. 이번 포스팅에서는 Matplotlib으로 Spine을 표시하는 방법을 살펴보겠습니다.

그리고 또 살펴볼 것은 다음과 같습니다.

주가 그래프를 볼 때 어떤 가격을 기준으로 윗부분과 아랫부분의 영역을 다른 색상으로 칠하면 보기에 매우 직관적일 것입니다. 예를 들어 삼성전자 주가 그래프에서 125만원 아랫쪽은 파란색, 윗쪽은 빨간색으로 칠하게 되면 120만원보다 주가가 낮았을 때와 높았을 때를 구분하여 보기 쉬울 것입니다.

10편의 코드와 다른 부분만 살펴보겠습니다.

>>> ref_price = 1250000

삼성전자 주가 그래프에서 ref_price를 기준으로 위쪽과 아래쪽의 색상을 다르게 할 것입니다.

>>> ax.fill_between(date, closep, ref_price, where=(closep > ref_price), \

                     facecolor='r', alpha=0.5)

>>> ax.fill_between(date, closep, ref_price, where=(closep < ref_price), \

                     facecolor='b', alpha=0.5)

10편에서 다루었던 fill_between()에서 인자 where= 가 추가되었습니다. where= 다음에는 조건을 입력합니다. where=(closep > ref_price)는 closep의 값이 ref_price보다 클 경우에만 색으로 채우는데, 그 색은 'r'로써 빨간색이며, 투명도는 0.5로 합니다. 마찬가지로 아래의 fill_between()은 closep의 값이 ref_price 보다 작을 경우에만 파란색으로 칠하고 투명도는 0.5로 합니다.

>>> ax.spines['left'].set_color('c')

>>> ax.spines['left'].set_linewidth(5)

>>> ax.spines['right'].set_visible(False)

>>> ax.spines['top'].set_visible(False)

Spine을 설정합니다. 좌측 Spine은 색상은 cyan, 두께는 5로 지정하였고 오른쪽과 위쪽은 Spine을 보이지 않게 했습니다.

>>> ax.tick_params(axis='x', color='r')

>>> ax.tick_params(axis='y', color='#225588')

x축의 값을 빨간색으로 표시하고, y축의 값을 225588 값에 해당하는 색으로 나타냅니다.

이 코드의 실행 결과는 다음과 같습니다.

파이썬 Matplotlib을 이용한 데이터 시각화 프로그래밍10 - 격자 표시 및 x축과 그래프로 둘러싸인 부분 색으로 채우기

8편의 코드에서 야후의 Open API를 이용해 주식정보를 받아오는 코드를 별도의 파일 stockreader.py로 만들어서 다른 코드에서 재사용할 수 있도록 했습니다. 첨부로 파일을 올려 두었으니 필요하신 분은 사용하세요~

stockreader.py의 getStockData() 함수를 재사용하게 될 것이며, 이 함수의 인자는 2개로 하나는 종목코드, 나머지 하나는 주식 데이터를 뽑을 기간입니다. 뽑을 기간은 현재 기준으로 삼성전자 주가 데이터을 1년, 3년, 1달, 3달치를 각각 얻고 싶으면 아래와 같이 호출하면 됩니다.

# 현재기준 1년치, 3년치 삼성전자 주가 데이터를 가져와 data1, data2에 할당함  

>>> import stockreader

>>> data1 = stockreader.getStockData('005930', '1y')

>>> data2 = stockreader.getStockData('005930', '3y')

# 현재기준 1달치, 3달치 삼성전자 주가 데이터를 가져와 data3, data4에 할당함  

>>> import stockreader

>>> data3 = stockreader.getStockData('005930', '1m')

>>> data4 = stockreader.getStockData('005930', '3m')

getStockData의 두 번째 인자를 지정하지 않으면 디폴트로 10년치 주가 데이터를 가져옵니다.

Matplotlib 강좌를 하면서 각종 그래프를 그릴 때 아무것도 없는 백지에다 그렸습니다. 하지만 1년치 주가정보와 같이 값을 확인해야 할 필요가 있는 경우, 모눈종이처럼 격자가 있으면 확인하기가 편리할 겁니다.

자, 다음의 코드를 보시죠~

전편 코드와 비교해서 달라진 부분만 살펴봅니다.

>>> krfont = {'family': 'NanumGothic', 'weight':'bold', 'size':10}

>>> matplotlib.rc('font', **krfont)

Matplotlib에 한글을 표시할 수 있도록 matplotlib에 한글 폰트를 지정해줍니다. 'family'의 값으로 폰트 파일의 이름을 써주시면 됩니다. 우분투의 경우 폰트 디렉토리 위치는 아래와 같으니 폰트파일(.ttf)을 이곳에 복사하면 됩니다.

/usr/share/fonts/trutype/

>>> date, closep, high, low, openp, volume = stockreader.getStockData(compcode, 1)

compcode에 해당하는 주가 데이터의 1년치를 가져옵니다.

>>> ax = plt.subplot2grid((1,1), (0,0))

루트 플롯을 1 x 1로 구분한 서브 플롯을 생성하고 루트 플롯의 (0, 0)에 위치킵니다. 즉, 서브 플롯은 루트 플롯과 그 크기가 동일합니다. 우리는 여태 matplotlib의 루트 플롯에 그래프나 차트를 그리고 화면에 출력했습니다. subplot2grid()는 루트 플롯에 서브 플롯을 지정해줍니다. 루트 플롯은 하나밖에 안되지만 서브 플롯은 여러개가 될 수 있습니다. 이는 UI 프로그래밍을 할 때 루트 프레임을 여러 개의 서브 프레임으로 나누고 서브 프레임에 다양한 위젯을 위치시키는 원리와 비슷합니다. 이해를 돕기 위해 아래의 코드를 봅니다.

>>> ax1 = plt.subplot2grid((3,3), (0,0), colspan=3)

>>> ax2 = plt.subplot2grid((3,3), (1,0), colspan=2)

>>> ax3 = plt.subplot2grid((3,3), (1,2), rowspan=2)

>>> ax4 = plt.subplot2gird((3,3), (2,0))

>>> ax5 = plt.subplot2grid((3,3), (2,1))

위 코드는 루트 플롯을 3 x 3, 9개의 영역으로 구분하고 ax1~ax5에 해당하는 서브 플롯을 정의해주는 코드입니다. 이 코드를 실행하면 matplotlib의 루트 플롯은 아래의 그림과 같이 5개의 서브 플롯으로 구분됩니다.

ax1~ax5는 플로팅을 위한 독립적인 공간이 됩니다. 따라서 무엇을 어떻게 어떤 배치로 나타낼 것이다라는 것을 미리 스케치한 후 matplotlib의 서브 플롯을 적절하게 구성하여 그에 맞는 차트나 그래프를 그려주면 됩니다.

우리의 코드에서는 루트 플롯과 같은 크기의 서브 플롯을 생성했습니다.

>>> ax.plot_date(date, closep, '-')

서브 플롯 ax에 시간별 주식 종가를 선으로 그려줍니다.

>>> for label in ax.xaxis.get_ticklabels():

            label.set_rotation(45)

서브 플롯 ax의 x축의 라벨을 45도 각도로 틀어줍니다.

>>> ax.grid(True)

서브 플롯 ax에 격자를 보이게 합니다.

>>> plt.subplots_adjust(left=0.1, bottom=0.2, right=0.95, top=0.9, wspace=0.2, hspace=0)

서브 플롯간의 간격을 조정해줍니다. 이번 코드는 서브 플롯이 하나이므로 루트 플롯과의 간격이 됩니다. 이 값을 조정해보면 어떤 내용인지 이해할 수 있습니다.

이제 주가 그래프의 아랫 부분을 색으로 채워 보겠습니다.

처음 코드에서 한 줄이 추가되었습니다.

>>> ax.fill_between(date, 1000000, closep)

fill_between(date, 1000000, closep)는 x값은 date이고, 1000000 이상 closep 이하 부분을 디폴트 색상인 파란색으로 채웁니다. 만약 1000000을 500000으로 줄여서 다시 그려보면 아래의 그림과 같이 나옵니다.

이는 y값의 범위가 달라져서 원래의 스케일과는 좀 다르게 나타납니다. 경계부분의 트렌드는 비슷한데 상대적인 차이가 줄어든 것입니다.

채우는 색상을 변경하고자 하면 아래와 같이 하면 됩니다. 아래는 cyan으로 채우고 그리는 색을 변경합니다.

>>> ax.fill_between(date, 1000000, closep, color='c')

>>> ax.plot_date(date, closep, '-', color='c')

결과는 아래와 같이 출력됩니다.

아래 코드는 부분을 칠하는 방법입니다. 물론 이는 정상적인 방법이 아닐 수 있습니다. 코드에 대한 설명은 생략합니다.

파이썬 Matplotlib을 이용한 데이터 시각화 프로그래밍9 - pandas를 이용해 주식 차트 그리기

pandas는 파이썬을 위한 데이터 구조 및 분석을 위한 매우 편리하고 고성능의 오픈소스 라이브러리 입니다. BSD 라이선스라서 pandas를 누구나 수정하여 사용할 수 있고, 재배포의 의무가 없으며 심지어 상용 소프트웨어에서도 제한없이 사용할 수 있습니다.

8편에서 주식 차트를 그리기위해 야후의 Open API URL주소를 이용해서 데이터를 가져오고 그것을 numpy.loadtxt()라는 함수로 주가 데이터를 파싱하여 matplotlib으로 차트를 그리는 알고리즘이었습니다.

자, 이제는 pandas를 이용해 8편과 동일한 프로그램을 만들어 보겠습니다. pandas의 위력을 조금이나마 알 수 있습니다. 먼저 pandas를 사용하기 위해서는 pandas를 우리의 컴퓨터에 설치를 해야겠지요..

PIP를 이용해 pandas를 설치합니다.

D:\> pip install pandas

그리고 pandas로부터 독립을 선언(?)한 pandas_datareader 모듈을 PIP로 설치합니다.

D:\> pip install pandas_datareader

무사히 잘 설치되었다면 파이썬을 구동해서 pandas를 import 해봅니다. 오류없다면 설치끝~

이제 아래의 코드를 보시죠~

8편의 코드에 비해 많이 단순하게 되었습니다. 살포시 코드로 가보죠..

>>> import pandas_datareader.data as web

pandas의 독립적인 모듈인 pandas_datareader.data를 web이라는 별명으로 import 합니다.

>>> def viewStockTrend(compcode)

인자로 입력된 compcode에 해당되는 주가 정보를 가져와서 matploitlib으로 화면에 그래프를 그려주는 함수입니다.

>>> start = datetime.datetime(2015, 2, 2)

>>> end = datetime.datetime(2016, 7, 13)

datetime.datetime(2015, 2, 2)는 2015-02-02 00:00:00 형식으로 변환해줍니다.

start와 end는 살펴볼 기간입니다.

>>> stock = web.DataReader(compcode, 'yahoo', start, end)

이 부분은 야후로부터 종목코드 compcode에 해당하는 주가 정보를 start, end로 지정된 기간만큼 가져와서 stock 변수에 담습니다.

만약 start와 end가 생략되면 2010-01-01 부터 프로그램을 구동한 현재까지의 주가정보를 가져오고, start만 인자로 입력하면 start부터 현재까지의 주가정보를 가져옵니다.

삼성전자의 2015년 2월 2일부터 2016년 7월 13일까지의 주가 그래프를 결과로 그려줍니다.

이와 같이 pandas를 이용하면 복잡한 작업을 매우 편리하게 해주는 기능들을 활용할 수 있어 프로그래밍이 매우 단순해집니다.

pandas에 대해서는 시간이 나는대로 별도로 포스팅할 예정입니다.

파이썬 Matplotlib을 이용한 데이터 시각화 프로그래밍8 - Open API를 이용해 주식 차트 그리기

이번에는 인터넷에 공개된 API를 이용해 주식 정보를 받아오고 이에 대한 차트를 Matplotlib으로 그려보도록 하겠습니다. 불행히도 주식 정보를 API로 제공하는 국내 사이트는 없습니다.

증권사에서 자체적인 API를 제공해주고 있긴 한데, 그냥 가져다 쓰기에는 무척이나 번거로운 작업이고 절차도 까다롭습니다. 하지만 걱정은 여기까지~

우리나라 주가 정보를 편리하게 제공해주는 사이트가 하나 있는데, 바로 미국의 야후입니다.

주가 정보를 제공하는 주소는 다음과 같습니다.

http://chartapi.finance.yahoo.com/instrument/1.0/{종목코드}/chartdata:type=quote;range=10y/csv

예를 들어 삼성전자의 종목코드는 005930입니다. 야후는 전세계 주식 정보를 제공해주고 있어서 이 종목코드가 어느 나라의 것인지 구분하기 위해 종목코드 뒤에 식별자를 부여해줘야 하는데, 우리나라는 KS가 식별자입니다. 따라서 005930.KS가 유효한 삼성전자 종목코드가 됩니다.

인터넷 브라우저를 열고 아래의 주소를 입력한 후 엔터를 쳐보세요~

http://chartapi.finance.yahoo.com/instrument/1.0/005930.KS/chartdata;type=quote;range=10y/csv

20060717,594000.0000,598000.0000,576000.0000,584000.0000,224900

....

....

이 부분은 모두 콤마로 6개 부분으로 구분되어 있습니다. 

순서대로 날짜, 종가, 고가, 저가, 시작가, 거래량입니다.

우리는 이 데이터를 받아와서 Matplotlib으로 주식 차트를 그려볼 겁니다. 일반적인 주식 차트는 그날의 종가를 기준으로 그려줍니다. 자 그러면 아래의 코드를 보시죠~

stockreader.py

stockreader.py의 주요 부분만 살펴보겠습니다.

>>> bytesdate2num(fmt, encoding='utf-8')

​

이 함수는 8자리로 된 날짜 데이터를 Matplotlib이 인식하는 숫자로 변경합니다. 

 

[출처] 데이터 시각화 프로그래밍8 - Open API를 이용해 주식 차트 그리기|작성자 옥수별

파이썬 Matplotlib을 이용한 데이터 시각화 프로그래밍7 - 파일로부터 데이터를 읽어서 그래프 그리기

첨부한 파일(births.txt)은 1880년부터 2011년까지 미국에서 태어난 남녀 출생아 수를 정리한 데이터입니다.

이 파일은 아래와 같은 형식으로 되어 있습니다.

1880, 90993, 110491
1881, 91954, 100745
1882, 107850, 113688

....

....

각 숫자는 콤마로 구분되어 있고 첫번째 데이터는 년도, 두번째 데이터는 여자 아기 출생수, 세번째 데이터는 남자 아기 출생수입니다.

우리가 해볼 것은 이 데이터를 읽어서 여자 아기와 남자 아기의 출생수 추이를 그래프로 나타내 보고자 합니다.

자, 코드를 바로 보실까요..

>>> import csv

파일로부터 데이터를 편리하게 읽어 들이기 위해 csv 모듈이 제공하는 reader()를 사용할 예정입니다.

>>> years = range(1880, 2012)

년도의 범위는 1880년에서 2011년 까지로 합니다.

>>> with open(datafile, 'rb') as f:

          data = csv.reader(f, delimiter = ',')

          for d in data:

               pieces.append(d)

births.txt 파일을 바이너리 읽기 모드로 열고 그 핸들을 f로 합니다. csv.reader(f, delimiter = ',')은 구분자를 콤마로 해서 파일 f의 데이터를 읽고 구분하여 변수 data에 할당합니다.

data는 [['1880', '90993', '110491'], ['1881', '91954', '100745'], ['1882', '107850', '113688'],....] 와 같은 형식이 됩니다.

x, y1, y2에 각각 data의 첫번째 데이터인 년도, 두번째 데이터인 여자 아기 출생수, 세번째 데이터인 남자 아기 출생수만 따로 모아서 구성합니다.

>>> p1 = plt.plot(x, y1, 'r^--', label='female')

>>> p2 = plt.plot(x, y2, 'bs-', label='male')

데이터를 그래프로 그립니다. plot의 세번째 인자인 'r^--'은 점선으로 연결된 빨간색 삼각형,  'bs-'은 선으로 연결된 파란색 사각형을 의미합니다. 그래프를 그릴 때 마커에 대한 내용은 4편에서 이미 살펴보았습니다.  

파이썬 Matplotlib을 이용한 데이터 시각화 프로그래밍6 - Matplotlib으로 파이 차트 그리기

파이 차트는 전체를 이루는 각 구성 요소가 전체 중 얼마만큼의 비중으로 되어 있는지 파악하기 매우 좋은 그래프 유형입니다. 바로 코드를 보실까요..

파이 차트를 그리기 위한 데이터는 누적 영역 그래프에서 사용된 어느 사람의 한달 동안 하루 일과 데이터입니다.

>>> activities = ['sleeping', 'working', 'eating', playing']

파이 차트의 라벨을 정의합니다. 이는 데이터 순서와 동일해야 합니다.

>>> n = 11

>>> title = 'Pie Chart for %d day' %(n+1)

>>> plt.title(title)

한 사람의 한달 동안 하루 일과에서 12일 부분을 선택하여 파이 차트를 그릴 예정입니다. 타이틀을 그에 맞게 구성합니다.

>>> slice = [sleeping[n], working[n], earing[n], playing[n]]

파이 차트를 구성하는 슬라이스 데이터를 정의합니다. 한달 데이터에서 12번째 데이터를 각각 취해서 하나의 리스트로 구성합니다.

>>> plt.pie(slice, labels=activities, startangle=90, shadow=True,

                explode=(0, 0, 0.1, 0), autopct='%1.1f%%')

파이 차트를 그려주는 Matplotlib 함수는 plt.pie()입니다. 인자는 다음과 같습니다.

• slice: 파이 차트를 구성할 데이터
• labels: 파이 조각의 라벨
• startangle: 그려지는 파이 조각 시작 위치. 90이면 12시 방향임. 파이 조각은 이 각도를 기준을 반시계 방향으로 그려짐
• shadow: 파이 차트의 그림자 효과 유무
• explode: 파이 조각이 돌출되는 크기. 0이면 돌출되지 않음
• autopct: 파이 조각의 전체 대비 백분율.

코드에서 explode는 3번째 파이 조각을 돌출하게 했습니다. 그리고 autopct에서 파이 조각 백분율은 소수점 1자리까지 %로 표기하도록 했습니다.

파이썬 Matplotlib을 이용한 데이터 시각화 프로그래밍5 - Matplotlib으로 누적 영역 그래프 그리기

누적 영역 그래프(Stacked Area Graph)는 전체에서 부분이 차지하는 것을 쉽게 보이게 하는 그래프의 한 종류입니다. 이런 목적을 가진 다른 유형의 그래프는 파이 차트입니다. 누적 그래프는 시간의 경과에 따라 각 부분들이 어떻게 변해가는지 살펴보기에 좋은 유형의 그래프인 반면, 파이 차트는 특정 기간 동안 각 부분이 얼만큼 비중을 차지하는가를 살펴보기에 좋은 그래프입니다.

일단 누적 영역 그래프를 그려보겠습니다.

이 코드는 1에서 180도까지 사인 그래프 4개를 누적시킨 그래프를 그립니다.

Matplotlib의 누적 영역 그래프를 그리는 함수는 plt.stackplot() 입니다.

>>> plt.stackplot(days, y1, y2, y3, y4, colors=colors)

x축 방향으로는 days를 위치시키고 y1, y2, y3, y4를 누적하여 그래프를 그립니다. 각 그래프 영역의 색상은 colors로 정의합니다.

보다 실제적인 누적 영역 그래프를 그려보도록 하겠습니다.

어느 한 사람의 하루 일과중 소비하는 시간 추이를 보여주는 그래프를 그리는 코드입니다.

어느 사람의 한달동안 생활 패턴을 분석한 결과를 누적 영역 그래프로 표시하는 코드입니다.

사용한 Matplotlib 함수는 동일하지만, 그래프를 그리기 위한 데이터가 달라졌습니다. sleeping, working, eating, playing의 동일한 위치의 요소들의 합은 모두 24가 됩니다. 하루는 24시간이므로 이 값은 변함이 없어야 겠지요.

playing의 색상은 'k'로 지정했는데, 이는 검정색을 나타냅니다. 

파이썬 Matplotlib을 이용한 데이터 시각화 프로그래밍4 - Matplotlib으로 산점도 그리기

산점도(Scatter plot)는 2차원 또는 3차원 좌표에 도형으로 표시를 하여 데이터의 상관관계 등을 파악하기 위해 주로 사용됩니다.

아래의 코드는 1에서 100까지 수를 마구 섞어 x좌표, y좌표를 만들고 산점도 결과를 출력하는 코드입니다.

산점도를 그려주는 Matplotlib 함수는 plt.scatter() 입니다. scatter() 함수의 인자는 다양한데, 이 코드에서는 x, y좌표와 라벨, 표시할 도형 종류, 그리고 색상만 인자로 정의했습니다.

산점도에서 표시할 수 있는 도형은 marker= 로 지정하면 되는데, Matplotlib에서 제공하는 마커의 종류는 여기를 참고하세요. 

산점도 그리기를 좀 더 응용해 보겠습니다.

위 코드는 Numpy 배열을 활용하여 50개의 좌표를 무작위로 만들고, 산점도를 원 모양으로 그리되 원의 크기를 무작위로, 원의 색상도 무작위로 해서 그려줍니다.

>>> x = np.random.rand(N)

>>> y = np.random.rand(N)

0에서 1사이의 N개의 수를 무작위로 생성하여 numpy 배열로 구성합니다. 마찬가지로 colors와 area를 50개의 요소를 무작위로 만들어 numpy 배열로 구성합니다. area는 0~15 포인트 사이의 값을 가집니다.

>>> plt.scatter(x, y, label='samples', s=area, c=colors, alpha=0.5)

scatter()의 인자 s는 도형의 크기, c는 도형의 색상, alpha는 색상의 투명도를 지정합니다. alpha의 값이 0이면 완전 투명이고, 1이면 완전 불투명입니다. 

파이썬 Matplotlib을 이용한 데이터 시각화 프로그래밍3 - Matplotlib으로 막대그래프, 히스토그램 그리기

막대 그래프(Bar Chart)나 히스토그램은 특정 그룹의 데이터의 추세와 정량적인 분포를 파악하는데 매우 유용합니다. 

Matplotlib으로 막대 그래프 그리기

다음과 같은 두 개의 데이터 세트가 있다고 가정합니다.

세트1: (1, 5), (3, 3), (5, 9), (7, 2), (9, 8) 

세트2: (2, 8), (4, 7), (6, 2), (8, 11), (10, 4)

이를 막대 그래프로 그리기 위한 코드는 아래와 같습니다.

>>> plt.bar(data_x1, data_y1, label='Set 1', color='b')

Matplotlib에서 막대 그래프를 그리는 함수는 plt.bar() 입니다. 막대의 폭을 지정하지 않으면 막대의 폭이 0.8로 정해집니다. data_x1으로 지정된 좌표에서 폭이 0.8이고 높이가 data_y1, color로 지정된 색상의 막대를 그립니다. Matplotlib에서 색상은 'r'이 Red, 'g'는 Green, 'b'는 Blue를 뜻합니다.

color값으로 #AA2848 처럼 RGB의 색상값으로 표현해도 됩니다.

위 코드에서 Set 2의 막대 그래프 색상을 #AA2848로 저정하여 실행하면 아래와 같은 결과가 나옵니다.

막대의 폭 0.5로 조정하고 싶다면 plt.bar()의 인자로 width = 0.5를 지정하면 됩니다. 아래는 Set 2의 막대그래프 폭을 0.5로 지정하여 출력한 결과입니다.

Matplotlib으로 히스토그램 그리기

히스토그램은 막대그래프와 모양은 비슷하나, 데이터가 있을 때 특정 범위의 값들을 그룹화하여 막대그래프 모양으로 표시하는 것입니다. 예를 들어 아래와 같은 30개의 데이터가 있다고 가정합니다.

22,55,62,45,21,22,34,42,42,4,99,102,110,120,121,122,130,111,115,112,80,75,65,54,44,43,42,48,16,11

이 데이터를 10단위의 간격으로 히스토그램을 그리는 코드는 아래와 같습니다. 

Matplotlib에서 히스토그램을 그리는 함수는 plt.hist() 입니다. 위 코드에서 변수 bins는 데이터 분류 기준이 되는 간격을 정의합니다. 여기서는 0~10, 11~20, 21~30,, 과 같이 간격을 10으로 정의했습니다. 히스토그램에서 BIN은 분류하고자 하는 범위라고 생각하면 됩니다. data에 있는 값들을 헤아려서 0~10, 11~20,,, 범위에 있는 개수를 히스토그램으로 나타냅니다. 

결과를 보면 data에 있는 값들 중 0~10 사이에 있는 값은 1개, 60~70사이에 있는 값은 2개임을 알 수 있습니다.

만약, 데이터를 분류하는 범위를 수동으로 지정하지 않고 BIN의 크기로 정해줄 수도 있습니다. data에 있는 값들을 분류하여 BIN의 크기대로 범위를 자동으로 정하고 결과를 화면에 출력하는 것이죠.

위 코드에서 bins = 8로 수정하고 실행하면 아래와 같은 결과가 출력됩니다.

BIN의 크기에 따라 data를 분류하는 값의 범위가 자동적으로 조정되었음을 알 수 있습니다.

이미치 처리를 위해 히스토그램을 응용하기도 하는데, 여기를 눌러 살펴보세요~ 

파이썬 Matplotlib을 이용한 데이터 시각화 프로그래밍2 - Matplotlib에 제목, 라벨, 레전드 삽입하기

데이터를 분석하고 그 결과만 화면에 출력한다면 이게 무슨 데이터를 분석하여 나온 결과인지 전혀 모를 수 있습니다.

따라서 결과 화면에 제목과 라벨, 레전드 등을 삽입하여 결과를 보는 사용자에게 친절함을 베풀어주는 것이 중요하겠죠.

이번 포스팅에서는 Matplotlib을 이용해 결과를 화면에 출력하되 제목과 라벨, 레전드를 삽입하는 방법에 대해 알아봅니다. 아래는 Jupyter Notebook으로 코딩을 하고 실행한 후 결과를 보인 것입니다.

이 코드는 0도에서 360도 범위에서 삼각함수의 사인함수와 코사인함수의 그래프를 화면에 출력합니다.

plt.plot()에 대해서는 이전 포스팅에서 배웠으므로, 우리의 주제인 제목과 라벨, 레전드 삽입 코드만 살펴보겠습니다.

>>> plt.plot(xs, ys1, label='SIN Curve')

>>> plt.plot(xs, ys2, label='COS Curve')

사인곡선과 코사인곡선을 계산하여 그리되 라벨링을 포함합니다.

>>> plt.xlim([0, 360])

출력할 때 x 값의 범위를 0에서 360도로 제한합니다.

>>> plt.xlabel('X value')

>>> plt.ylabel('Y value')

plt.xlabel()과 plt.ylabel()은 각각 Matplotlib이 출력한 그래프의 x축과 y축에 라벨링하는 함수입니다. 

>>> plt.title('Trigonometric Function')

plt.title()은 Matplotlib이 출력한 결과 화면에 제목을 표시합니다.

>>> plt.legend()

각 곡선에 라벨링한 것을 레전드로 표시합니다.

>>> plt.show()

결과를 화면에 출력합니다.

이제 Matplotlib을 이용한 결과가 좀 풍성해진 것 같네요.. 

파이썬 Matplotlib을 이용한 데이터 시각화 프로그래밍1 - Matplotlib 시작하기

요즘 IT업계에서 유행하는 용어가 '빅데이터' 입니다.

빅데이터는 말그대로 용량이 매우 큰 데이터라는 말인데, 좀 더 세밀하게 정의하면 이 의미 의외에 몇가지가 더 있습니다.

아무튼 데이터든 빅데이터든 이들을 분석해서 의미있는 자료로 가공하는 것이 중요한 일이고, 가공된 데이터는 사람이 알아보기 쉽게 시각화(비주얼라이제이션; Visualization) 해주는 것이 중요합니다.

빅데이터 분석을 위한 강좌를 하기 전에 먼저 데이터를 시각화 하는 방법에 대해 살펴보도록 하겠습니다.

먼저 환경은 윈도우 10, 파이썬 3.5.2 입니다. 파이썬 2.7.x 버전을 사용하시는 분들은 일부 코드가 호환되지 않을 수 있으니 참고하세요.

파이썬 라이브러리 Matplotlib은 데이터 분석 결과를 시각화 하는데 필요한 막대 그래프, 선 그래프, 파이 차트, 바 차트 등 다양한 그래프와 차트를 생성하는 함수들을 제공합니다. 일단 Matplotlib을 설치해야 겠네요. 윈도 커맨드창에서 PIP를 이용해 다음과 같이 Matplotlib을 설치하면 필요한 모듈을 모두 알아서 설치해줍니다.

pip install matplotlib

만약 PIP로 matplotlib이 제대로 설치되지 않으면 여기로 가서 차근차근 읽어보고 matplotlib을 설치해보기 바랍니다.

Matplotlib이 제대로 설치되었는지 윈도 명령 프롬프트창에서 파이썬을 실행하고 matplotlib을 import 해봅니다.

>>> import matplotlib

아무 오류없이 import가 되면 성공적으로 설치가 된 것입니다.

자, 그러면 파이썬을 실행하거나 에디터를 이용해 다음과 같이 간단한 코드를 한번 작성해봅니다.

>>> import matplotlib.pyplot as plt

>>> xs = [x for x in range(10)]

>>> ys = [y*y for y in range(10)]

>>> plt.plot(xs, ys)

>>> plt.show()

이 코드는 matplotlib.pyplot을 import 하는데 이 녀석의 별명을 plt로 정의합니다.

plt.plot(xs, ys)는 리스트인 xs와 ys를 이용해 그려야 할 좌표를 정의하고 이 좌표들을 선으로 연결합니다.

xs와 ys는 수가 멤버인 크기가 동일한 리스트여야 합니다.

plt.show()는 결과를 화면에 그려줍니다.

이 코드를 실행하면 아래와 같이 matplotlib 윈도우가 생성되고 결과를 화면에 그려줍니다.

matplotlib 윈도우 아랫부분에는 결과를 다양하게 탐색할 수 있는 버튼들이 있습니다. 마치 인터넷 브라우저의 버튼과 비슷해 보입니다. 맨 왼쪽 집모양은 홈버튼입니다. 결과를 확대하고 축소하고 옮겨다니다가 맨 처음 모양으로 되돌리는 버튼입니다.

화살표 모양의 버튼은 뒤로 가기와 앞으로 가기 버튼입니다. 결과들을 이리저리 보다가 인터넷 브라우저 처럼 이전의 결과를 보고 싶으면 왼쪽 화살표 버튼을, 이후의 결과를 보고 싶으면 오른쪽 화살표 버튼을 이용합니다.

십자가 모양의 화살표는 결과를 이리저리 옮길 수 있다는 것을 표시해주는 아이콘입니다. 결과 화면에 마우스 왼쪽  버튼을 누른 채로 이동하면 결과를 아래 위나 왼쪽 오른쪽으로 이동할 수 있습니다.

결과 화면에 마우스 오른쪽 버튼을 누른채로 움직이면 결과를 확대하거나 축소할 수 있습니다. 아래 그림은 결과를 임의로 축소해본 것입니다.

다섯번째 아이콘을 클릭하면 결과 화면의 특정 부분을 사각형 영역으로 지정하여 확대해 볼 수 있습니다. 아래 그림은 사각형 영역으로 지정한 후 확대한 것입니다.

여섯번째 아이콘을 클릭하면 아래 그림과 같이 그림판의 여백을 조절할 수 있는 게이지가 나타납니다.

아래 그림은 right 여백을 조정한 결과입니다. 게이지 조정에 따른 결과 화면입니다.

이번 포스팅에서는 matplotlib의 기본적인 사항에 대해 가볍게 살펴보았습니다.

참고로 데이터 시각화 프로그래밍2에서는 데이터 분석을 위한 프로그래밍 도구로 많이 활용되는 Jupyter Notebook을 이용할 예정입니다. Jupyter Notebook에 대한 자세한 내용은 아래의 링크를 참조하세요.

☞Jupyter Notebook 개요 및 설치 

# 파이프라인을 가진 스트리밍 워크플로우

'''
위스콘신 유방암 데이터
이 데이터는 악성(malignant)과 양성(benign)의 암세포로 구성된 569개 샘플을 포함.
~2 열까지는 각 샘플의 ID숫자와 이들의 진단 결과값을 저장
3 ~ 32 열은 30개의 실제 값으로 이루어진 피처
'''

import pandas as pd
df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/wdbc.data', header=None)

from sklearn.preprocessing import LabelEncoder
X = df.loc[:, 2:].values
y = df.loc[:, 1].values
print('df: ', df)
print('X: ', X)
print('y: ', y)
le = LabelEncoder()
y = le.fit_transform(y)
print('y-transform: ', y)

print(le.transform(['M', 'B']))

from sklearn.cross_validation import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=1)
print('X_train: ', X_train)
print('y_train: ', y_train)
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
pipe_lr = Pipeline([('scl', StandardScaler()),
                    ('pca', PCA(n_components=2)),
                    ('clf', LogisticRegression(random_state=1))])
pipe_lr.fit(X_train, y_train)
print('Test Accuracy: %.3f' % pipe_lr.score(X_test, y_test))


# k-fold 교차검증을 사용하여 모델 성능 평가
# - 일반화 성능을 만족시키는 최적의 하이퍼파라미터 값을 찾기 위한 모델 튜닝에 사용
import numpy as np
from sklearn.cross_validation import StratifiedKFold
kfold = StratifiedKFold(y=y_train, n_folds=10, random_state=1)
#print('kfold: ', kfold)
scores = []
for k, (train, test) in enumerate(kfold):
#    print('train: ', train, 'test: ', test)
    pipe_lr.fit(X_train[train], y_train[train])
    score = pipe_lr.score(X_train[test], y_train[test])
    scores.append(score)
    print('Fold: %s, Class dist.: %s, Acc: %.3f' % (k+1, np.bincount(y_train[train]), score))
print('CV accuracy: %.3f +/- %.3f' % (np.mean(scores), np.std(scores)))


from sklearn.cross_validation import cross_val_score
scores = cross_val_score(estimator=pipe_lr, X=X_train, y=y_train, cv=10, n_jobs=1)
print('CV accuracy scores: %s' % scores)
print('CV accuracy: %.3f +/- %.3f' % (np.mean(scores), np.std(scores)))

# 검증 곡선을 사용해서 높은 바이어스나 높은 분산에 대한 이슈를 어떻게 해소할 수 있는지 확인.
import matplotlib.pyplot as plt
from sklearn.learning_curve import learning_curve
pipe_lr = Pipeline([
    ('scl', StandardScaler()),
    ('clf', LogisticRegression(penalty='l2', random_state=0))
])
train_sizes, train_scores, test_scores = learning_curve(estimator=pipe_lr,
                                                        X=X_train,
                                                        y=y_train,
                                                        train_sizes=np.linspace(0.1, 1.0, 10),
                                                        cv=10,
                                                        n_jobs=1)
train_mean = np.mean(train_scores, axis=1)
train_std = np.std(train_scores, axis=1)
test_mean = np.mean(test_scores, axis=1)
test_std = np.std(test_scores, axis=1)

plt.plot(train_sizes, train_mean, color='blue', marker='o', markersize=5, label='training accuracy')
plt.fill_between(train_sizes, train_mean + train_std, train_mean - train_std, alpha=0.15, color='blue')
plt.plot(train_sizes, test_mean, color='green', linestyle='--', marker='s', markersize=5, label='validation accuracy')
plt.fill_between(train_sizes, test_mean + test_std, test_mean - test_std, alpha=0.15, color='green')
plt.grid()
plt.xlabel('Number of training samples')
plt.ylabel('Accuracy')
plt.legend(loc='lower right')
plt.ylim([0.8, 1.0])
plt.show()

# 검증곡선으로 오버피팅과 언더피팅 다루기
'''
검증곡선은 학습곡선과 관련되어 있지만 훈련 정확도와 테스트 정확도를 샘플 크기의 함수로 플롯하는 대신,
로지스틱 회귀의 역정규화 파라피터 C와 같은 모델 파라미터 값들을 다양하게 한다.
'''
from sklearn.learning_curve import validation_curve
param_range = [0.001, 0.01, 0.1, 1.0, 10.0, 100.0]
train_scores, test_scores = validation_curve(
    estimator=pipe_lr,
    X=X_train,
    y=y_train,
    param_name='clf__C',
    param_range=param_range,
    cv=10
)
train_mean = np.mean(train_scores, axis=1)
train_std = np.std(train_scores, axis=1)
test_mean = np.mean(test_scores, axis=1)
test_std = np.std(test_scores, axis=1)
plt.plot(param_range, train_mean, color='blue', marker='o', markersize=5, label='training accuracy')
plt.fill_between(param_range, train_mean + train_std, train_mean - train_std, alpha=0.15, color='blue')
plt.plot(param_range, test_mean, color='green', linestyle='--', marker='s', markersize=5, label='validation accuracy')
plt.fill_between(param_range, test_mean + test_std, test_mean - test_std, alpha=0.15, color='green')
plt.grid()
plt.xscale('log')
plt.legend(loc='lower right')
plt.xlabel('Parameter C')
plt.ylabel('Accuracy')
plt.ylim([0.8, 1.0])
plt.show()

'''
차원축소를 위한 피처 선택의 방법 중 피처 추출이 있다.
원래보다 낮은 차원의 새로운 피처 부분공간으로 변환시킴으로써 데이터의 정보를 요약할 수 있도록 도와주는
세 가지 기초 기법에 대해 학습한다.
* 비지도적 데이터 압축을 위한 주성분 분석(PCA)
* 최대화 분류 분리를 위한 지도적 차원축소 기법으로써의 선형 분리 분석(LDA)
* 커널(kernel) 주성분 분석을 활용한 비선형 차원축소
'''
# 주성분 분석을 활요한 비지도적 차원축소

# 전체 분산과 설명 분산
import pandas as pd
df_wine = pd.read_csv('wine.data', header=None)

from sklearn.cross_validation import train_test_split
from sklearn.preprocessing import StandardScaler
X, y = df_wine.iloc[:, 1:].values, df_wine.iloc[:, 0].values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)
# 표준화
sc = StandardScaler()
X_train_std = sc.fit_transform(X_train)
X_test_std = sc.fit_transform(X_test)

# 공분산 행렬 만들기
# 아이겐페어(eigenpairs)는 Numpy의 linalg.eig 함수 사용
import numpy as np
cov_mat = np.cov(X_train_std.T) # 공분산행렬 계산 (같은 피처를 행으로 만들어서)
eigen_vals, eigen_vecs = np.linalg.eig(cov_mat)
print('\nEigenvalues \n%s' % eigen_vals)
print('\nEigenvectors \n%s' % eigen_vecs)

# 아이겐밸류의 분산 비율을 구한다.
tot = sum(eigen_vals)
var_exp = [(i / tot) for i in sorted(eigen_vals, reverse=True)] # 내림차순 정렬
cum_var_exp = np.cumsum(var_exp) # 설명 분산의 누적 합 계산
import matplotlib.pyplot as plt
plt.bar(range(1,14), var_exp, alpha=0.5, align='center', label='individual explained variance')
plt.step(range(1,14), cum_var_exp, where='mid', label='cumulative explained variance')
plt.ylabel('Explained variance ratio')
plt.xlabel('Principal components')
plt.legend(loc='best')
plt.show()

# 피처 변환
eigen_pairs = [(np.abs(eigen_vals[i]), eigen_vecs[:, i]) for i in range(len(eigen_vals))]
eigen_pairs.sort(reverse=True) # 내림차순 정렬
print('eigen_pairs:\n', eigen_pairs)
w = np.hstack((eigen_pairs[0][1][:, np.newaxis], eigen_pairs[1][1][:, np.newaxis]))
print('Matrix W:\n', w)

# 투영행렬을 사용해서 샘플 x(1x13차원의 행 벡터)를 PCA 부분공간 x`로 변환할 수 있다.
print('X_train_std[0]:\n', X_train_std[0].dot(w))
# 124 x 13차원의 훈련데이터를 행렬의 내적곱 계산을 사용해서 두 개의 주성분으로 변환
X_train_pca = X_train_std.dot(w)

colors = ['r', 'b', 'g']
markers = ['s', 'x', 'o']
for l, c, m in zip(np.unique(y_train), colors, markers):
    plt.scatter(X_train_pca[y_train==l, 0], X_train_pca[y_train==l, 1], c=c, label=l, marker=m)
plt.xlabel('PC 1')
plt.ylabel('PC 2')
plt.legend(loc='upper left')
plt.show()


## 사이킷런에서 주성분 분석
from matplotlib.colors import ListedColormap

def plot_decision_regions(X, y, classifier, resolution=0.02):
    markers = ('s', 'x', 'o', '^', 'v')
    colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan')
    cmap = ListedColormap(colors[:len(np.unique(y))])

    x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution), np.arange(x2_min, x2_max, resolution))

    Z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T)
    Z = Z.reshape(xx1.shape)
    plt.contourf(xx1, xx2, Z, alpha=0.4, cmap=cmap)
    plt.xlim(xx1.min(), xx1.max())
    plt.ylim(xx2.min(), xx2.max())

    for idx, cl in enumerate(np.unique(y)):
        plt.scatter(x=X[y==cl, 0], y=X[y==cl, 1], alpha=0.8, c=cmap(idx), marker=markers[idx], label=cl)

from sklearn.linear_model import LogisticRegression
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
lr = LogisticRegression()
X_train_pca = pca.fit_transform(X_train_std)
X_test_pca = pca.transform(X_test_std)
lr.fit(X_train_pca, y_train)
plot_decision_regions(X_train_pca, y_train, classifier=lr)
plt.xlabel('PC1')
plt.ylabel('PC2')
plt.legend(loc='lower left')
plt.show()

plot_decision_regions(X_test_pca, y_test, classifier=lr)
plt.xlabel('PC 1')
plt.ylabel('PC 2')
plt.legend(loc='lower left')
plt.show()

pca = PCA(n_components=None)
X_train_pca = pca.fit_transform(X_train_std)
print('pca.explained_variance_ratio_:\n', pca.explained_variance_ratio_)

# 세 개의 평균 벡터 결과 도출
np.set_printoptions(precision=4)
mean_vecs = []

for label in range(1,4):
    mean_vecs.append(np.mean(X_train_std[y_train==label], axis=0))
    print('MV %s: %s\n' %(label, mean_vecs[label-1]))

d = 13 # number of features
S_W = np.zeros((d, d))
for label, mv in zip(range(1,4), mean_vecs):
    class_scatter = np.zeros((d, d))
    for row in X[y==label]:
        row, mv = row.reshape(d, 1), mv.reshape(d, 1)
        class_scatter += (row-mv).dot((row-mv).T)
    S_W += class_scatter
print('Within-class scatter matrix: %sx%s' % (S_W.shape[0], S_W.shape[1]))

print('Class label distribution: %s' % np.bincount(y_train)[1:])

d = 13
S_W = np.zeros((d, d))
for label, mv in zip(range(1,4), mean_vecs):
    class_scatter = np.cov(X_train_std[y_train==label].T)
    S_W += class_scatter
print('Scaled within-class scatter matrix: %sx%s' % (S_W.shape[0], S_W.shape[1]))

mean_overall = np.mean(X_train_std, axis=0)
d = 13
S_B = np.zeros((d,d))
for i, mean_vec in enumerate(mean_vecs):
    n = X[y==i+1, :].shape[0]
    mean_vec = mean_vec.reshape(d, 1)
    mean_overall = mean_overall.reshape(d, 1)
    S_B += n * (mean_vec - mean_overall).dot((mean_vec - mean_overall).T)
print('Between-class scatter matrix: %sx%s' % (S_B.shape[0], S_B.shape[1]))

import pandas as pd
from io import StringIO

csv_data = '''A,B,C,D
1.0,2.0,3.0,4.0
5.0,6.0,,8.0
0.0,11.0,12.0,
'''
df = pd.read_csv(StringIO(csv_data))
print('df:\n ', df)
print('df.isnull().sum():\n ', df.isnull().sum())

# 결측값을 가진 샘플이나 피처 제거
print('df.dropna():\n ', df.dropna()) # 결측값을 가진 행을 제거하는 방법
print('df.dropna(axis=1):\n ', df.dropna(axis=1)) # 결측값을 가진 열을 제거하는 방법
print("df.dropna(how='all'):\n", df.dropna(how='all')) # 모든 열이 결측값을 가진 행만 제거
print('df.dropna(thresh=4):\n', df.dropna(thresh=4)) # 최소 4개의 결측치가 아닌 값을 가지지 못하는 행 제거
print("df.dropna(subset=['C']:\n", df.dropna(subset=['C'])) # C열에서 결측치가 있는 행을 제거

# 결측값의 보정
# 전체 피처열의 평균값으로 결측값을 간단히 대체하는 평균보정법
from sklearn.preprocessing import Imputer
imr = Imputer(missing_values='NaN', strategy='mean', axis=0)
imr = imr.fit(df)
imputed_data = imr.transform(df.values)
print('imputed_data:\n', imputed_data)


import pandas as pd
df = pd.DataFrame([
    ['green', 'M', 10.1, 'class1'],
    ['red', 'L', 13.5, 'class2'],
    ['blue', 'XL', 15.3, 'class1']
])
df.columns = ['color', 'size', 'price', 'classlabel']
print('df:\n', df)

# 순위형 피처 매핑
# ex) XL = L + 1 = M + 2
size_mapping = {'XL': 3, 'L': 2, 'M': 1}
df['size'] = df['size'].map(size_mapping)
print('df:\n', df)

# 역매핑
inv_size_mapping = {v: k for k, v in size_mapping.items()}
print('inv_size_mapping:\n', inv_size_mapping)


# 분류 레이블 인코딩
import numpy as np
class_mapping = {label:idx for idx, label in enumerate(np.unique(df['classlabel']))}
print('class_mapping:\n', class_mapping)

df['classlabel'] = df['classlabel'].map(class_mapping)
print('df:\n', df)
# 역매핑
inv_class_mapping = {v: k for k, v in class_mapping.items()}
df['classlabel'] = df['classlabel'].map(inv_class_mapping)
print('df:\n', df)

from sklearn.preprocessing import LabelEncoder
class_le = LabelEncoder()
y = class_le.fit_transform(df['classlabel'].values)
print('y:\n', y)

print('class_le.inverse_transform(y):\n', class_le.inverse_transform(y))


# 명목형 피처에 원핫 인코딩 수행
X = df[['color', 'size', 'price']].values
color_le = LabelEncoder()
X[:, 0] = color_le.fit_transform(X[:, 0])
print('X:\n', X)


# one hot encoding
from sklearn.preprocessing import OneHotEncoder
ohe = OneHotEncoder(categorical_features=[0])
print('ohe.fit_transform(X).toarray():\n', ohe.fit_transform(X).toarray())

print('df:\n', df)
print("pd.get_dummies(df[['price', 'color', 'size']]):\n", pd.get_dummies(df[['price', 'color', 'size']]))


# 데이터를 훈련용과 테스트용으로 분할하기
df_wine = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data', header=None)
df_wine.columns = ['Class label', 'Alcohol',
                   'Malic acid', 'Ash',
                   'Alcalinity of ash', 'Magnesium',
                   'Total phenols', 'Flavanoids',
                   'Nonflavanoid phenols', 'Proanthocyanins',
                   'Color intensity', 'Hue',
                   'OD280/OD315 of diluted wines', 'Proline']
print('Class labels', np.unique(df_wine['Class label']))
print('df_wine.head():\n', df_wine.head())

# 테스트용과 훈련용으로 임의 분할하기 위한 편리한 방법 한 가지는 사이킷런 cross_validation 서브 모듈의 train_test_split 함수
from sklearn.cross_validation import train_test_split
X, y = df_wine.iloc[:, 1].values, df_wine.iloc[:, 0].values
print('X:\n', df_wine.iloc[:, 1].values)    # Alcohol
print('y:\n', df_wine.iloc[:, 0].values)    # Class label
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)
print('X_train:\n', X_train)
print('X_test:\n', X_test)

# 최소-최대 스케일링 프로시저
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
X_train = np.array(X_train).reshape((len(X_train), 1))
X_test = np.array(X_test).reshape((len(X_test), 1))
X_train_norm = mms.fit_transform(X_train)
X_test_norm = mms.transform(X_test)
print('X_train_norm:\n', X_train_norm)
print('X_test_norm:\n', X_test_norm)

# 표준화 프로시저
from sklearn.preprocessing import StandardScaler
stdsc = StandardScaler()
X_train_std = stdsc.fit_transform(X_train)
X_test_std = stdsc.transform(X_test)
print('X_train:\n', X_train)
print('X_train_std:\n', X_train_std)


############ 오버피팅을 줄일 수 있는 일반적인 방법

from sklearn.linear_model import LogisticRegression
LogisticRegression(penalty='l1')
print("LogistincRegression(penality='l1'):\n", LogisticRegression(penalty='l1'))
lr = LogisticRegression(penalty='l1', C=0.1)
lr.fit(X_train_std, y_train)
print('Training accuracy:', lr.score(X_train_std, y_train))
print('Test accuracy:', lr.score(X_test_std, y_test))
lr.intercept_
print('lr.intercept_: ', lr.intercept_)
lr.coef_
print('lr.coef_: ', lr.coef_)


# 여러가지 정규화 강도를 위한 다양한 피처들의 가중계수인 정규화의 경로를 플롯
import matplotlib.pyplot as plt
fig = plt.figure()
ax = plt.subplot(111)
colors = ['blue', 'green', 'red', 'cyan',
          'magenta', 'yellow', 'black',
          'pink', 'lightgreen', 'lightblue',
          'gray', 'indigo', 'orange']
weights, params = [], []
for c in np.arange(-4, 6):
    lr = LogisticRegression(penalty='l1', C=10**np.float32(c), random_state=0)
    lr.fit(X_train_std, y_train)
    weights.append(lr.coef_[1])
    params.append(10**np.float32(c))

weights = np.array(weights)
for column, color in zip(range(weights.shape[1]), colors):
    plt.plot(params, weights[:, column], label=df_wine.columns[column+1], color=color)

plt.axhline(0, color='black', linestyle='--', linewidth=3)
plt.xlim([10**(-5), 10**5])
plt.ylabel('weight coefficient')
plt.xlabel('C')
plt.xscale('log')
plt.legend(loc='upper left')
ax.legend(loc='upper center', bbox_to_anchor=(1.38, 1.03), ncol=1, fancybox=True)
plt.show()

# 연속형 피처 선택 알고리즘
'''
SBS(Sequential Backward Selection) : 계산상 효율을 위해 초기 피처 부분 공간의 차원을 축소시킬 때
분류기 성능이 무너지는 것을 최소화하는 것을 목표로 한다.
'''
df_wine = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data', header=None)
df_wine.columns = ['Class label', 'Alcohol', 'Malic acid', 'Ash',
                   'Alcalinity of ash', 'Magnesium', 'Total phenols', 'Flavanoids',
                   'Nonflavanoid phenols', 'Proanthocyanins', 'Color intensity', 'Hue',
                   'OD280/OD315 of diluted wines', 'Proline']

from sklearn.cross_validation import train_test_split
X, y = df_wine.iloc[:, 1:].values, df_wine.iloc[:, 0].values

from sklearn.base import clone
from itertools import combinations
import numpy as np
from sklearn.cross_validation import train_test_split
from sklearn.metrics import accuracy_score
class SBS():
    def __init__(self, estimator, k_features, scoring=accuracy_score,
                 test_size=0.25, random_state=1):
        self.scoring = scoring
        self.estimator = clone(estimator)
        self.k_features = k_features
        self.test_size = test_size
        self.random_state = random_state

    def fit(self, X, y):
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=self.test_size,
                                                            random_state=self.random_state)
        dim = X_train.shape[1]
        #print('dim:\n', dim)
        self.indices_ = tuple(range(dim))
        #print('self.indices:\n', self.indices_)
        self.subsets_ = [self.indices_]
        #print('self.subsets:\n', self.subsets_)
        score = self._calc_score(X_train, y_train, X_test, y_test, self.indices_)
        #print('score:\n', score)
        self.scores_ = [score]

        while dim > self.k_features:
            scores = []
            subsets = []

            for p in combinations(self.indices_, r=dim-1):
                score = self._calc_score(X_train, y_train, X_test, y_test, p)
                scores.append(score)
                subsets.append(p)
                best = np.argmax(scores)
                self.indices_ = subsets[best]
                self.subsets_.append(self.indices_)
                dim -= 1

                self.scores_.append(scores[best])
                #print('self.scores_:\n', self.scores_)
            self.k_score_ = self.scores_[-1]

            return self

    def transform(self, X):
        return X[:, self.indices_]

    def _calc_score(self, X_train, y_train, X_test, y_test, indices):
        self.estimator.fit(X_train[:, indices], y_train)
        y_pred = self.estimator.predict(X_test[:, indices])
        score = self.scoring(y_test, y_pred)
        return score

from sklearn.neighbors import KNeighborsClassifier
import matplotlib.pyplot as plt
knn = KNeighborsClassifier(n_neighbors=2)
sbs = SBS(knn, k_features=1)
sbs.fit(X_train_std, y_train)
#print('sbs.subsets_:\n', sbs.subsets_)
k_feat = [len(k) for k in sbs.subsets_]
plt.plot(k_feat, sbs.scores_, marker='o')
plt.ylim([0.7, 1.1])
plt.ylabel('Accuracy')
plt.xlabel('Number of features')
plt.grid()
plt.show()

k5 = list(sbs.subsets_[8])
#print('k5:\n', k5)
print('df_wine.columns[1:][k5]:\n', df_wine.columns[1:][k5])

knn.fit(X_train_std, y_train)
print('Training accuracy:', knn.score(X_train_std, y_train))
print('Test accuracy:', knn.score(X_test_std, y_test))

knn.fit(X_train_std[:, k5], y_train)
print('Training accuracy:', knn.score(X_train_std[:, k5], y_train))
print('Test accuracy:', knn.score(X_test_std[:, k5], y_test))

#### 랜덤 포레스트를 활용한 피처 중요도의 평가
'''
랜덤 포레스트를 사용하면 데이터가 선형적으로 분리 가능한지 여부와 상관없이
포레스트 내의 모든 의사결정나무로부터 계산된 평균 불순도 감소분으로 피처의 중요도를 측정할 수 있다.
나무 기반의 모델은 표준화나 정규화가 필요하지 않다는 것을 기억하자.
'''
from sklearn.ensemble import RandomForestClassifier
feat_labels = df_wine.columns[1:]
forest = RandomForestClassifier(n_estimators=10000, random_state=0, n_jobs=-1)
forest.fit(X_train, y_train)
importances = forest.feature_importances_
indices = np.argsort(importances)[::-1]
for f in range(X_train.shape[1]):
    print("%2d) %-*s %f" % (f+1, 30, feat_labels[f], importances[indices[f]]))

plt.title('Feature Importances')
plt.bar(range(X_train.shape[1]), importances[indices], color='lightblue', align='center')
plt.xticks(range(X_train.shape[1]), feat_labels, rotation=90)
plt.xlim([-1, X_train.shape[1]])
plt.tight_layout()
plt.show()

X_selected = forest.transform(X_train, threshold=0.15)
print('X_selected.shape:\n', X_selected.shape)

이제 드디어 APM을 설치합니다.

SSH로 아마존 인스턴스에 접속합니다. putty를 통해 접속하는 방법은 이미 알고계시죠? : )

# sudo su

를 입력하여 root권한을 획득 하고 이후의 내용을 진행하세요.

이제 본격적으로 Apache, Mysql, PHP를 설치할 것입니다.

먼저 yum 업데이트를 시작합니다. 여러 패키지들을 업데이트 합니다.

# yum update

를 입력하세요.

설치할 패키지 목록이 쭈욱 나타나고 설치를 진행할것인지 묻습니다. 

y를 입력하고 엔터를 누르면 다운로드 및 설치가 진행됩니다.

완료가 되었습니다.

APM을 설치해봅시다. 설치과정은 위와 유사합니다.



PHP와 아파치, 기타 모듈 설치

# sudo yum install php-mysql php php-xml php-mcrypt php-mbstring php-cli mysql httpd

마찬가지로 설치를 할것이냐고 물으면 y를 눌러주세요.



MYSQL 설치

#sudo yum install mysql mysql-server mysql-libs mysql-server

PHP, Apache, MYSQL를 한꺼번에 설치하고, 그리고 SSL까지 쓴다면 이렇게 한꺼번에 타이핑하여 한방에 설치하셔도 됩니다.

# sudo yum install mod_ssl mysql mysql-sever mysql-libs mysql-server php php-mysql php-xml php-mcrypt php-mbstring php-cli httpd

설치가 완료되면

mysql을 실행해봅시다.


# sudo /etc/init.d/mysqld start

OK 가 나타났다면 정상적으로 실행이 된것입니다.



MYSQL root 비밀번호 설정


# mysqladmin -u root password '비밀번호'

보안을 위해서 mysql root 비번도 바꿔주는 센스!

향후 사용할 DB를 생성하고 사용자를 추가하고 그에 대한 권한을 주는것은 기존에 하시던 방식과 동일하니 넘어가겠습니다.


아파치 conf 파일을 수정할 차례입니다. 

이 과정은 /etc/httpd/conf/httpd.conf 에 웹서버 정보를 수정하는 과정입니다.

아파치 conf 파일은 /etc/httpd/conf/httpd.conf 경로에 위치해있습니다.

# vi /etc/httpd/conf/httpd.conf

로 파일을 열고 웹서버정보를 수정해봅시다.

아무것도 수정하지 않은 httpd.conf의 설정은 /var/www/html 을 루트경로로 하고있습니다.

도메인은 설정되지 않았습니다.

먼저 도메인을 설정합니다.

(먼저 가지고 계신 도메인의 DNS 설정을 마치셔야 합니다.)

#ServerName www.example.com:80

주석으로 처리된 이 부분을 주석을 삭제하고 여러분이 가지고 계신 도메인으로 설정하세요.

ServerName www.test.com


도메인이 없다면 아마존이 제공해준 굉장히 긴 이름의 public DNS를 그대로 입력하셔도 됩니다.


이제 웹서버의 루트 경로를 변경할 차례입니다.

루트경로를 굳이 변경하지 않는 경우에는 기본 경로인 /var/www/html가 웹서버의 루트경로가 되고

웹문서는 여기에 업로드하시면 됩니다.


웹서버의 루트경로를 변경하는 경우에는

httpd.conf 파일에서

아래 두 부분을 찾아 원하는 경로로 수정하시면 됩니다.




DocumentRoot "/var/www/html"

<Directory "/var/www/html">


저는 웹문서경로는 /var/www/html 폴더를 그대로 사용하고

ServerName은 아마존에서 제공해준 public DNS를 그대로 사용했습니다.

/home/ec2-user/ 폴더를 웹루트폴더로 사용하려고 ec2-user 폴더의 퍼미션을 변경하면 그 다음부터 해당 인스턴스에 더이상 접속이 되지 않습니다. ec2-user 폴더의 퍼미션을 절대 변경하지마세요.

한가지 더 수정할 것이 있는데

인덱스파일로 index.php를 추가해주는 것입니다.

httpd.conf 파일에서

DirectoryIndex index.html index.php

DirectoryIndex를 찾아 끝에 index.php를 추가해주세요.

폴더에 접근했을때 index.html을 가장 먼저 보여주고, index.html 파일이 없을때 index.php 파일을 보여준다는 설정입니다.

수정한 것을 저장하고, 아파치를 실행합니다.

# sudo /etc/init.d/httpd start


재부팅시에도 apache와 mysql이 자동으로 실행될수 있도록 설정합니다.


# sudo chkconfig --levels 235 mysqld on
# sudo chkconfig --levels 235 httpd on

이제 웹페이지에 보여줄 php 파일을 만들어보겠습니다.

저는 웹문서경로가 /var/www/html 이고,

이 안에 아래의 내용이 담긴 index.php 파일을 생성하여 업로드하였습니다.

<html>
<head>
<title>Hello World!</title>
</head>
<body>
<?php echo 'Hello World!' ?>
</body>
</html>


자 이제 웹브라우저를 통해서 접속해볼까요.

잘나오는군요!


웹서버의 루트경로에 아무런 웹문서가 없다면

웹브라우저로 접속했을때 이런 화면이 나올거예요.

혹시 접근할수 없다는 메시지가 나온다면

웹문서경로의 퍼미션을 확인해주세요.

yum install git-coregit을 사용하신다면 git도 요렇게 설치해주시고

이제 드디어 아마존 EC2를 이용하여 LAMP 환경을 구축하는 것을 모두 마쳤습니다.

아직 DB연결에 관한 부분은 테스트 하지 않았지만,

아마 여기까지 성공하셨으니 이 이후과정은 충분히 진행하실 수 있으리라 생각합니다.



아마존 클라우드 서비스는 앞으로도 활용할 곳이 정말 무궁무진합니다.

아마존 서비스 장애가 발생할 우려가 있다는 것은 충분히 감안하시고,

잘 활용하신다면 상대적으로 저렴한 비용에 아주 손쉽게 서버를 구성하실수 있습니다.

사용해보니 아시아에 위치해 있는 서버도 국내에서 호스팅을 이용하는 것보다는 속도가 떨어지는것 같습니다.

이점도 참고하시면 좋을 것 같아요.



저희가 지금까지 해온 과정은 하나의 인스턴스에 APM을 설치하는것이었는데

이렇게 하지 않고 두개의 인스턴스를 사용해서 웹서버와 DB서버로 나누어서 사용하는 방법도 있습니다.

이렇게 사용할 경우에는 php코드 상에서 mysql host를 적을때 mysql이 실행되고 있는 인스턴스의 ip를 적어주시면 되겠죠.


즐거운 개발하세요~

코드 작성을 위해 EC2에 editplus로 접속하는 방법이 포스팅 되었습니다.

출처: http://trend21c.tistory.com/1297 [나를 찾는 아이]

1. EC2 인스턴스 생성할 때 만든 key pair를 다운받는다.(기존 key pair를 선택하거나 새로 만들어 다운받는다) pem 파일

2. $ ssh -i [pem파일 경로] [유저명@퍼블릭DNS or IP]

예) ssh -i ~/Download/ec2.pem ec2-user@ec2-51-71-102-14.ap-northeast-2.compute.amazonaws.com

여기까지가 접속방법

pem 파일 없이 ssh keygen을 가지고 접속하기 위해서는 아래와 같이 적용한다.

1. $ ssh-keygen -t rsa

2. yes 를 연달아 치면 $HOME/.ssh 경로에 id_rsa파일이 만들어진다. id_rsa.pub파일을 텍스트 에디터로 열고 내용 그대로를 remote 서버에 $HOME/.ssh/authorized_keys 파일에 내용을 추가해준다.

3. $ ssh ec2-user@[DNS(IP)] 접속

출처: http://tbang.tistory.com/116 [heene]

FROM

ON

JOIN

WHERE

GROUP BY

WITH CUBE | WITH ROLLUP

HAVING

SELECT

DISTINCT

ORDER BY

TOP

wget https://raw.githubusercontent.com/sarfata/voodooprivacy/master/voodoo-vpn.sh

vi voodoo-vpn.sh

정보 변경

sudo bash voodoo-vpn.sh

그리고 방화벽 오픈

UDP로 열 것..

4500

500

1701 <--- 요거만 열어주면 되긴 함..

http://blog.naver.com/wjdtjdgus956/120211932298

wget http://s3.amazonaws.com/ec2metadata/ec2-metadata

chmod +x ec2-metadata

./ec2-metadata

http://169.254.169.254/latest/meta-data/

help

http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html

https://cjh5414.github.io/ubuntu-jenkins/

SpringBoot 프로젝트에 Jenkins를 이용하여 배포, 테스트 자동화 등을 적용하기 위해 Ubuntu 16.04에서 Jenkins를 설치하는 과정을 기록했다.

Jenkins 설치

apt-get을 이용하여 Jenkins를 설치 하기 위해 저장소 key를 다운받고 (정상적으로 저장소 key를 다운받으면 OK를 반환한다.) 패키지 주소를 sources.list에 더해준다.

$ wget -q -O - https://pkg.jenkins.io/debian/jenkins-ci.org.key | sudo apt-key add -
OK

$ echo deb http://pkg.jenkins.io/debian-stable binary/ | sudo tee /etc/apt/sources.list.d/jenkins.list

새로 받은 저장소를 적용하기 위해 apt-get을 업데이트한 후에 Jenkins를 설치한다.

$ sudo apt-get update
$ sudo apt-get install jenkins

Jenkins 시작하기

systemctl을 이용하여 Jenkins를 시작할 수 있다. 하지만 결과를 출력해주지 않기 때문에 status를 이용하여 시작이 잘 되었는지 확인해보는 것이 좋다. 잘 동작했다면 아래와 같은 메세지를 출력할 것이다.

$ sudo systemctl start jenkins
$ sudo systemctl status jenkins
● jenkins.service - LSB: Start Jenkins at boot time
  Loaded: loaded (/etc/init.d/jenkins; bad; vendor preset: enabled)
  Active:active (exited) since Thu 2017-04-20 16:51:13 UTC; 2min 7s ago
    Docs: man:systemd-sysv-generator(8)
    ...

Firewall 허용하기

Jenkins가 잘 동작하면 웹 브라우저를 통해 접근할 수 있도록 방화벽 설정이 필요하다. Jenkins는 기본적으로 8080포트에서 실행되도록 설정 돼 있다. ufw으로 8080 포트를 허가해줘서 접근할 수 있도록 하고 결과를 확인해본다.

$ sudo ufw allow 8080
$ sudo ufw status
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
8080                       ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
8080 (v6)                  ALLOW       Anywhere (v6)

Jenkins Port 변경

만약 다른 곳에서 8080포트를 사용하고 있으면 중복되어서 Jenkins가 동작하지 않을 것이다. 아래와 같이 jenkins 설정 파일에서 포트를 8081으로 바꿔줄 수 있다.

/etc/default/jenkins

HTTP_PORT=8081

방화벽 또한 8081포트를 허용해주고 Jenkins를 재시작하면 된다.

$ sudo ufw allow 8081
$ sudo systemctl restart jenkins

Jenkins 설정

이제 웹 브라우저를 통해 Jenkins에 접속할 수 있다.

http://ip_address_or_domain_name:8080 
포트를 변경했다면,
http://ip_address_or_domain_name:8081
으로 입력한다.

처음 접속했다면 아래와 같은 화면이 보일텐데 Jenkins를 설치할 때 생성된/var/lib/jenkins/secrets/initialAdminPassword 파일의 내용을 빈칸에 입력해야한다.

cat 명령으로 파일의 내용을 출력한 후 복사해서 붙여넣자.

$ sudo cat /var/lib/jenkins/secrets/initialAdminPassword

완료되면 두 가지 선택사항이 나오는데 Select plugins to install을 클릭하면 설치하고 싶은 plugins를 선택할 수 있다. 권장하는 설치 항목들을 설치하고 싶다면 Install suggested plugins를 선택하자.

설치가 완료되면 admin 계정을 생성하고,

Start using Jenkins 을 클릭하면 완료된다.

참고자료

• https://www.digitalocean.com/community/tutorials/how-to-install-jenkins-on-ubuntu-16-04

EC2 Linux(ubuntu) 계정 추가 & 설정

AWS의 EC2 를 생성하고 계정을 관리하면서 새로 알게된 내용을 정리한다.

정석은 EC2에서 생성한 각각의 사용자 계정마다 key pair를 생성해 주고, 각 계정에 맞게 설정된 key pair를 통해 접속해야 하지만...
최초 EC2를 생성하며 만들었던 key pair를 모든 사용자가 공유한다던가, password 기반의 로그인을 활성화하여 ssh key를 사용하지 않고 password 기반으로 로그인 하는 방법이 있다. 여기서는 사용자를 추가한 후 password 기반으로 로그인 하는 방법과 모든 사용자가 같은 pem파일을 사용할 수 있도록 하는 방법을 정리하였다.

먼저 AWS EC2 instance(Amazon Linux)를 생성하면 자동으로 ec2-user가 생성된다.
instance 생성시 설정했던 key pair (.pem)를 통해 서버에 접속한다.

1. root password 설정
[ec2-user@ip-172-31-7-114 ~]$ sudo passwd root

2. password 기반의 로그인을 활성화하기
[ec2-user@ip-172-31-7-114 ~]$ sudo vi /etc/ssh/sshd_config

# Change to no to disable tunnelled clear text passwords
PasswordAuthentication no

위의 no를 yes로 변경한 후 저장한다.

3. root 계정으로 로그인
[ec2-user@ip-172-31-7-114 ~]$ su - root 

4. 다른 사용자 계정 추가
[root@ip-172-31-7-114 ~]$ adduser jmkim

5. 새로 생성한 사용자 계정의 비밀번호 변경
[root@ip-172-31-7-114 ~]$ sudo passwd jmkim

6. 새로 생성한 사용자 계정에 root 권한을 사용할 수 있도록 설정
[root@ip-172-31-7-114 ~]$ sudo visudo

root ALL=(ALL) ALL 아래에 
jmkim ALL=(ALL) ALL 을 추가해 준다.

7. 같은 key pair로 로그인 할 수 있도록 새로 생성한 사용자 계정으로 ec2-user 의 것을 복사

# 이부분에 대한 자세한 내용은 SSH KEY 를 참고한다. (https://opentutorials.org/module/432/3742)

# ubuntu 에서.ssh 폴더를 생성해 주어야한다.
[root@ip-172-31-7-114 ~]$ sudo cp /home/ec2-user/.ssh/ /home/jmkim/.ssh/

8. 복사한 key pair의 소유자를 jmkim으로 변경 (-R : 하위 폴더까지 모두 소유권을 바꿔줌)

[root@ip-172-31-7-114 ~]$ sudo chown -R jmkim:jmkim /home/jmkim/.ssh

9. sshd 서비스 재시작
[root@ip-172-31-7-114 ~]$ sudo service sshd restart
# ubuntu
[root@ip-172-31-7-114 ~]$ sudo service ssh restart
 

이제 EC2 instance를 생성할때 만들었던 .pem 파일과 설정한 비밀번호를 통해 새로 생성한 계정으로 서버에 접속할 수 있다.

출처: http://uroa.tistory.com/100 [UroA 개발 블로그]

추가. 테스트 해보니 제대로 권한이 처리가 안된다.

그래서 확인해보니 

   46  chmod u+w /etc/sudoers

   47  vi /etc/sudoers

   48  chmod u-w /etc/sudoers

   49  ls -al /etc/sudoers

요렇게 권한을 주고 수정한 후 다시 권한을 빼라.

그리고 reboot 하면 권한이 주어진다.

우분투를 설치후 매번 admin으로 접속하기는 찜찜(?)하니 계정을 추가하여 접속을 해보도록 하자.

우분투에서는 계정을 생성하는 명령어가 두가지가 있다. 바로 adduser와 useradd이다. 

두 명령어 모두 계정을 추가하는 명령어지만 약간의 차이점이 있다. 

adduser의 경우 명령어 실행시 기본 계정정보를 같이 생성해주지만

useradd의 경우 계정만 생성하며 기타 다른 정보를 수동으로 생성 및 설정해주어야 한다. 

하나하나 실행하면서 살펴보도록 하자.

1. adduser [계정이름] - 계정 추가

- 계정생성시 비밀번호 까지 입력받으며 기본정보를 바로 입력 시켜줄수 있다. 홈 디렉토리 또한 자동으로 생성된다.

이렇게 adduser로 계정을 생성시 우선 암호입력창이 뜨고 후에 부가적인 Commant 입력창이 생성된다.

2. useradd [계정이름] - 계정 추가

- 순수 계정만 생성해주고 기본 셀인 sh가 할당되며 홈 디렉토리와 패스워드는 따로 설정해줘야 한다.

useradd로 계정을 추가시 따로 결과 메세지나 입력메세지가 없다.

이제 이 두가지 계정을 한번 비교해보도록 하자

3. /etc/passwd - 계정 정보 파일

- 사용자 인증에 필요한 계정 정보를 가지고 있다. cat 명령어로 내용을 살펴보자.

맨 아래줄에 보면 mirUseradd와 miradduser 계정이 추가된것이 보인다.

하나하나 자세히 분석해보자.

분명 위에서 useradd 명령은 홈 디렉토리를 따로 설정해줘야 된다고 말했지만 계정정보를 보면 홈디렉토리가 보인다.

하지만 실제로 홈 디렉토리를 가볼려고 하면 디렉토리가 없다고 표시된다.

즉 설정된 홈디렉토리를 생성시켜주거나 다른 홈디렉토리를 생성하여 설정값을 바꿔줘야 한다.

4. /etc/shadow - 암호 정보 파일

- 사용자 인증에 필요한 암호 정보를 가지고 있다. cat 명령어로 내용을 살펴 보자.

암호정보도 하나하나 분석해보자.

5. usermod [옵션] [계정명]- 계정 수정