웹의 이해

• 웹의 이해
• 월드 와이드 웹(world wide web) 은 인터넷에 연결된 컴퓨터를 이용하여 사람들과 정보를 공유할 수 있도록 거미줄처럼 엮인 공간
• 웹 컴포넌트 : HTML과 HTTP : HTML
• HTML(Hyper Text Markup Language)은 웹상의 정보를 구조적으로 표햔하기 위한 언어
• HTTP 프로토콜 : 데이터 송수신을 위해
• HTML 형식 : 데이터를 표시하기 위해
• 웹 컴포넌트 : HTML과 HTTP : HTML
• 태그는 꺾쇠 괄호 < >로 둘러싸여 있고, 그 안에 정보르에 대한 의미를 적음. 그리고 그 의미가 끝나는 부분에 슬래시(/) 를 사용하여 해당 태그를 종료

<title> Hello, World</title> # 제목 요소, 값은 Hello, World

• 웹 컴포넌트 : HTML과 HTTP : HTTP
• HTTP(Hypertext Transaction Protocol)는 인터넷에서 컴퓨터 간에 정보를 주고 받을 때 사용하는 일종의 약속을 말하며, 일반적으로 컴퓨터 과학에서는 이러한 약속을 프로토콜(protocol)이라고 함
• 웹의 동작 순서
• 웹에 있는 정보를 보기 위해 먼저 하는 일은 웹 브라우저를 시작하고, 거기에 주소 정보를 입력하는 것. 주소 정보의 공식 이름은 URL(Uniform Resource Locator)이라고 함

– URL에는 해당 서버가 위치한 인터넷 주소 정보인 도메인 네임이 있다. 흔히 도메인 정보 또는 서버 주소라고도 하는 이 주소를 통해 웹의 정보를 제공하는 서버에 접속

– 일반적으로 컴퓨터는 인터넷 프로토콜 주소(Internet Protocol address), 즉 IP주소라고 부르는 주소값을 가짐

– IP주소를 컴퓨터의 주소로 생각하면 이 주소에 접속하기 위해 사용하는 도메인 네임과 연결하기 위한 도메인 네임 서버(Domain Name Server, DNS)가 운영됨

• 웹의 이해
• 웹의 동작 순서

• 웹 스크래핑
• 모든 웹은HTML로 구성되어 있으므로, HTML의 규칙을 파악한다면 얼마든지 HTML에서 필요한 정보를 가져올 수 있다
• 이러한 과정을 일반적으로 웹 스크래핑 이라고 함

엑셀에서 웹의 정보 가져오기

꼭 파이썬을 사용하지 않더라도 엑셀에서 간단하게 웹의 정보를 가져올 수 있다. 먼저 엑셀을 실행하여 [데이터] — [웹] 메뉴 선택. 대화상자가 열리면 추출하고 싶은 데이터가 있는 웹 주소를 입력. 추출하고자 하는 테이블을 선택하면 데이터가 출력되어 엑셀에 기록되는 것을 확인

HTML 데이터 다루기

• 웹에서 데이터 다운로드

import urllib.request #urllib 모듈 호출.
url = "http://storage.googleapis.com/patents/grants_full_text/2014/ipg140107.zip"
# 다운로드 URL 주소.
print("Start Download")
fname.header = urllib.request.urlretrieve(url, 'ipg140107.zip')
print('End Download')

웹에서 데이터 다운로드

• 1행에서는 파이썬의 웹 페이지 연결 모듈인 urllib 모듈을 호출. 2행에서 파일이 있는 다운로드 URL 주소를 지정하고, 5행에서 urlretrieve() 함수와 URL 주소, 파일명을 입력하여 특정 파일을 저장
• 특정 그림이나 강의 자료 같은 데이터를 자동화하여 다운로드할 때 매우 유용하다. 예를 들어, 구글 검색을 통해 특정 인물의 사진만 다운로드 할 수 있는 프로그램을 작성하여 이를 실행하면 효율적으로 특정 인물의 사진을 다운로드 할 수 있음

• HTML파싱
• 웹 페이지의 HTML을 분석하여 데이터를 추출하는 작업
• 특정 텍스트를 분석하여 그 데이터로부터 필요한 정보 추출
• http://finance.naver.com/item/main--nhn?code=005930

HTML파싱

• 다음으로 웹 페이지에서 필요한 정보만 추출하는 방법은 무엇일까? 아래의 테이블에서 필요한 주식 정보를 이떻게 가져올 수 있을까?

→ 가장 좋은 방법은 데이블을 구성하는 HTML 페이지를 찾아 그 정보를 가져오는 것. 먼저 해당 웹 페이지를 열고 마우스 오른쪽 버튼을 누른 후, ‘페이지 소스 보기’를 클릭. 웹페이지의 정보가 있는 HTML 코드를 확인할 수 있다. 이 코드를 분석하여 원하는 정보만 따로 추출할 수 있는데, 이를 위해 해당 정보를 표현하는 코드의 패턴을 찾아 HTML 생성 규칙을 파악, 이를 추출하는 프로그램을 만들어야 함.

정규 표현식

• 정규 표현식의 개념
• 정규 표현식은 일종의 문자를 표현하는 공식으로, 특정 규칙이 있는 문자열 집합을 추출할 때 자주 사용하는 기법
• 정규 표현식, regexp 또는 regex 등으로 불림
• 복잡한 문자열 패턴을 정의하는 문자 표현 공식
• 특정한 규칙을 가진 문자열의 집합을 추출

일반 문자정규 표현식.010–0000–0000^\d{3}-\d{4}-\d{4}$203.252.101.40^\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}$

• 주민등록 번호, 전화번호, 도서 ISBN 등 형식이 있는 문자열을 원본 문자열로 부터 추출함
• HTML역시 tag를 사용한 일정한 형식이 존재하여 정규식으로 추출

정규 표현식 문법

• 정규 표현식을 배우기 위해 기본으로 알아야 하는 개념은 메타문자
• 메타문자는 문자를 설명하기 위한 문자로 문자의 구성을 설명하기 위해 원래의 의미가 아니라 다른 의미로 쓰이는 문자를 뜻함

. ^ $ * + ? { } [ ] / | ( )

기본 메타문자 

• 먼저 대괄호 []는 [ 와 ] 사이의 문자와 매칭하라는 뜻

ex) [abc]는 어떤 텍스트에 a 또는 b 또는 c라는 텍스트가 있는지 찾으라는 뜻

• 에는 or의 의미가 있다
• 만약 [abc]라는 정규 표현식을 쓴다면 다음과 같은 텍스트에서 검색되는 텍스트는 어떤 것이 있을까? 여기서는 ‘a’의 a, ‘before’의 b와 같은 방식으로 검색될 것이다

a, before, deep, dud, sunset

• “-”를 사용 범위를 지정할 수 있음

Ex) [A-Za-z]나 [가-힣]과 같은 기호로 문자열에서 알파벳과 한글을 추출할 수 있음

[0–9]은 숫자 전체를 추출

반복 관련 메타문자 -, +, *, ?, { }

앞에서 배운 [ ]는 매우 유용하지만, 한 번에 여러 개의 글자를 표현할 수 없다. 예를 들어, 휴대전화번호를 찾고 싶다면 다음과 같이 정규 표현식을 작성해야 한다.

[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]

• 하지만 이렇게 하면 몇 가지 문제점이 있다. 먼저 텍스트를 너무 많이 적는다. 이럴 때 쓸 수 있는 메타문자가 + 이다. + 는 해당 글자가 1개 이상 출현하는 것을 뜻한다.

[0-9]+-[0-9]+-[0-9]+

반복 관련 메타문자 -, +, *, ?, { }

• 출현 획수를 조정해야 할 때 사용하는 메타문자는 중괄호 { } 이다.

ex) [a-zA-Z]{3, 4} 이면 알파벳이 3자부터 4자까지 출현할 수 있다는 뜻.

• 반복 횟수는 {1,}, {0,}, {1,3}처럼 시작값이나 끝값은 지정하지 않고 오픈할 수 있음. 만약 {1,}라고 쓴다면 한번 이상 출현해야 한다는 제약이 있다.

[0-9]{3}-[0-9]{3,4}-[0-9]{4}

• {m-n} — 반복 횟수를 지정

그 외 메타문자 ( ), ., |, ^, $, \

• 메타문자 ()는 묶음을 표시하는 것으로, 좀 더 쉽게 메타문자의 묶음을 표시하는 역할.
• [.] — 줄바꿈 문자인 \n를 제외한 모든 문자와 매치.
• |는 or의 의미.
• ^은 not의 의미.
• 정규 표현식의 처음과 끝에느메타문자 ^과 $를 주로 붙임.

import re
text = "문의사항이 있으면 032-232-3245 으로 연락주시기 바랍니다."

regex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d')
matchobj = regex.search(text)
phonenumber = matchobj.group()
print(phonenumber)

• 파이썬에서 정규표현식을 사용하기 위해서는 Regex를 위한 모듈인 re 모듈 사용.
• re 모듈의 compile 함수는 정규식 패턴을 입력으로 받아들여 정규식 객체를 리턴하는데, 즉, re.compile(검색할문자열) 와 같이 함수를 호출하면 정규식 객체(re.RegexObjcet 클래스 객체)리턴.

Lab : 웹스크래핑 실습

아이디 추출

• 먼저 특정 아이디를 추출하는 Lab이다. 다음 웹 사이트에는 이벤트 당첨자의 아이디를 발표한 웹 페이지가 있는데, 이 웹 페이지에서 필욯ㄴ 아이디만 추출

import re
import urllib.request

url = "http://goo.gl/U7mSQI"
html = urllib.request.urlopen(url)
html_contents = str(html.read())
id_results = re.findall("([A-Za-z0-9]+\*\*\*)", html_contents)
# findall 전체 찾기, 정규 표현식 패턴 대로 데이터 찾기.
for result in id_results: # 찾은 정보를 화면에 출력.
	print(result)

→ 4행 접속할 웹 페이지의 링크 작성.

→ 5행 웹 페이지에 접속

→ 6행 해당 웹 페이지의 HTML 코드를 문자열로 가져옴.

→ HTML코드를 findall() 함수를 사용하여 정규 표현식 패턴에 넣어주면 패턴대로 데이터 추출 → id_results 변수에 넣어줌. 해당 변수는 튜플 형태로 반환되기 때문에 각각을 출력하기 위해서는 10행과 같이 for문 사용

파일 자동 다운로드

import urllib.request
import re

url = "http://www.google.com/googlebooks/uspto-patents-grants-text.html"
html = urllib.request..urlopen(url)
html_contents = str(html.read().decode("utf8"))
url_list = re.findall(r"(http)(.+)(zip)", html_contents)
for url in url_list:
	full_url = "".join(url)
	print(full_url)
	fname,header = urllib.request.urlretrieve(full_url, file_name)
	print("End Download")

HTML 파싱

• 코드는 크게 두 가지 부분으로 구성
• ~에 정보가 있음
• ~정보를 추출

(\)[\s\S]+?)(\<\/dl>)
(\)([\s\S]+?(\<\/dd>)

CODE

import urllib.request
import re

url = "http://finance.naver.com/item/main.nhn?code=005930"
html = urllib.request.urlopen(url)
html_contents = str(html.read().decode("ms949"))
# 첫 번째 HTML 패턴.
stock_results = re.findall("(\<dl class = \"blind\"\>)([\s\S]+?)(\<\/d'\>)",
html_contents)
samsung_stock = stock_results[0]
samsung_index = samsung_stock[1]
print(type(stock_results))
print(type(samsung_stock))
print(type(samsung_index))
idex_list = re.findall("(\<dd\>)([\s\S]+?)(\<\/dd\>)", samsung_index)
for index in index_list:
	print(index[1])

matplotlib 시각화

• Matplotlib는 데이터 시각화와 2D 그래프 플롯에 사용되는 파이썬 라이브러리.

Matplotlib 기본 사용

• matplotlib.pyplot
• 기본 그래프

import matplotlib.pyplot as plt 
plt.plot([1,2,3,4]) # x 값 자동 완성. 
plt.ylabel('y-label') 
plt.show()

• 기본 그래프

import matplotlib.pyplot as plt 
plt.plot([1,2,3,4], [1,4,9,16]) # x, y 지정 
plt.show()

• 레이블 설정

import matplotlib.pyplot as plt plt.plot([1,2,3,4], [1,4,9,16]) plt.xlabel('X-label') plt.ylabel('Y-label') plt.show()

• matplotlib 축 범위 지정하기
• matplotlib.pyplot 모듈의 axis() 함수를 사용

import matplotlib.pyplot as plt

plt.plot([1,2,3,4], [1,4,9,16], 'bo') # x, y 지정.
plt.xlabel('x-label')
plt.ylabel('y-label')
plt.axis([0, 5, 0, 20])
plt.show()

• matplotlib 색상 지정하기
• 그래프 선 색 지정

import matplotlib.pyplot as plt

plt.plot([1,2,3,4], [1,4,9,16], 'r')
plt.plot([1,2,3,4], [1,3,5,7], 'violet')
plt.xlabel('X-label')
plt.ylabel('Y-label')
plt.axis([0, 5, 0, 20])
plt.show()

• 스타일 지정
• x, y 값 인자에 대해 선의 색상과 형태를 지정하는 포맷 문자열을 세번째 인자에 입력

import matplotlib.pyplot as plt 
plt.plot([1,2,3,4], [1,4,9,16], 'ro') 
plt.axis([0,6,0,20])
plt.show()

• 여러 개의 그래프 그리기.
• matplotlib에서는 일반적으로 Numpy 어레이를 이용.
• Numpy 어레이를 사용하지 않더라도 모든 시퀀스는 내부적으로 Numpy 어레이로 변환.

import matplotlib,pyplot as plt 
import numpy as np 
t = np.arange(0., 5., 0.2) 
plt.plot(t, t, 'r--', t, t**2, 'bs', t, t**3, 'g^') plt.show()

• Matplotlib 그래프 영역 채우기.
• 그래프의 특정 영역을 색상으로 채워서 강조.
  – fill_between()
  – fill_betweenx()
  – fill()

import matplotlib.pyplot as plt 
x = [1,2,3,4] 
y = [1,4,9,16] 
plt.plot(x, y) 
plt.xlabel('X-label') 
plt.ylabel('Y-label') 
plt.fill_between(x[1:3], y[1:3], alpha = 0.5) plt.show()

Matplotlib 그래프 영역 채우기 — 두 그래프 사이 영역 채우기

import matplotlib .pyplot as plt 
x = [1,2,3,4] 
y1 = [1,4,9,16] 
y2 = [1,2,4,8] 
plt.plot(x, y1) 
plt.plot(x, y2) 
plt.xlabel('X-label') 
plt.ylabel('Y-label') 
plt.fill_between(x[1:3], y1[1:3], y2[1:3], color = "lightgray", alpha = 0.5) 
plt.show()

matplotlib 그래프 영역 채우기 — 임의의 영역 채우기

import matplotlib.pyplot as plt 
x = [1,2,3,4] 
y1 = [1,4,9,16] 
y2 = [1,2,4,8] 
plt.plot(x, y1) 
plt.plot(x, y2) 
plt.xlabel('X-label') 
plt.ylabel('Y-label') 
plt.fill([1.9, 1.9, 3.1, 3.1], [2, 5, 11, 8], color = 'lightgray', alpha = 0.5) 
plt.show()

• matplotlib 눈금 표시하기
• 틱은 그래프의 축에 간격을 구분하기 위해 표시하는 눈금
• matplotlib.pyplot 모듈의 xticks(), yticks(), tick_params() 함수 이용

import matplotlib.pyplot as plt
import numpy as np

a = np.arange(0, 2, 0.2)
plt.plot(a, a, 'bo')
plt.plot(a, a**2, color = 'red' marker = '*', linewidth = 2)
plt.plot(a, a**3, color = 'springgreen' marker = '^', markersize = 9)
plt.xticks([0, 1, 2])
plt.yticks(np.arange(1, 6))

plt.show()

matplotlib 타이틀 설정

import matplotlib.pyplot as plt
import numpy as np

a = np.arnage(0, 2, 0.2)
plt.plot(a, a, 'bo')
plt.plot(a, a**2, color = 'red', marker = '*', linewidth = 2)
plt.plot(a, a**3, color = 'springgreen' marker = '^', markersize = 9)
plt.xticks([0, 1, 2])
plt.yticks(np,arange(1, 6))
plt.title('Title test')

plt.show()

matplotlib 막대 그래프 그리기

• matplotlib.pyplot 의 bar() 함수 이용

import matplotlib.pyplot as plt
import numpy as np

x = np.arange(3)

years = ['2017', '2018', '2019']
values = [100, 400, 900]
plt.bar(x.values)
plt.xticks(x, years)
plt.show()

• 스타일 지정

plt.bar(x, values, width = 0.6,
align = 'edge', color = 'springgreen',
edgecolor = 'gray', linewidth = 3, tick_label = years, log=True)

• width는 막대 너비. 디폴트 값 0.8

• align는 틱과 막대의위치 조절. 디폴트 값은 ‘center’, ‘edge’로 설정하면 막대의 왼쪽 끝에 x_tick 표시

• color는 막대의 색 지정

• edgecolor는 막대의 테두리 색 지정

• linewidth는 테두리의 두께 지정

• tick_label을 어레이 형태로 지정하면, 틱에 어레이의 문자열을 순서대로 나타낼 수 있음

• log = True로 설정하면, y축이 로그 스케일로 표시

matplotlib 수평 막대 그래프 그리기

import matplotlib as plt
import numpy as np

y = np.arnage(3)
years = ['2017', '2018', '2019']
values = [100, 400, 900]
plt.barh(y, values, height = 0.6, align = 'edge', color = 'springgreen',
edgecolor = 'gray', linewidth = 3, ticl_label = years, log = False)
plt.show()

matplotlib 산점도 그리기

• 산점도는 두 변수의 상관 관계를 직교 좌표계의 평면에 데이터를 점으로 표현하는 그래프
• matplotlib.pyplot 모듈의 scatter() 함수 이용

import matplotlib.pyplot as plt
import numpy as np

np.random.seed(19680801)
N = 50
x = np.random.rand(N)
y = np.rnadom.rand(N)
colors = np.random.rand(N))**2
area = (30 * np.random.rand(N)) ** 2
plt.scatter(x, y, s = area, c = colors, alpha = 0.5)
plt.show()

matplotlib 히스토그램 그리기

• 히스토그램은 도수분포표를 그래프로 나타낸 것으로서, 가로축은 계급, 세로축은 도수 (횟수나 개수 등)를 나타냄
• matplotlib.pyplot 모듈의 hist() 함수를 이용

import matplotlib.pyplot as plt

weight = [68, 81, 64, 56, 78, 74, 61, 77, 66, 68, 59, 71, 80, 59, 67, 81, 69, 73, 69, 74, 70, 65]
plt.hist(weight)
plt.show()

• 여러 개 히스토그램

import matplotlib.pyplot as plt
import numpy as np

a = 2.0 * np.random.rnadn(10000) + 1.0
b = np. rnadom.standard_normal(10000)
c = 20.0 * np.random.rand(5000) = 10.0
plt.hist(a, bins = 100, density = True, alpha = 0.7, histtype = 'step')
plt.hist(b, bins = 50, density = True, alpha = 0.5, histtype = 'stepfilled')
plt.hist(c, bins = 100, density = True, alpha = 0.9, histtype = 'step')
plt.show()

matplotlib 에러바 그리기

• 에러바(Errorbar, 오차 막대)는 데이터의 편차를 표시하기 위한 그래프 형태
• matplotlib.pyplot 모듈의 errorbar() 함수 이용

import matplotlib.pyplot as plt

x = [1,2,3,4]
y = [1,4,9,16]
yerr = [2.3, 3.1, 1.7, 2.5]
plt.errorbar(x, y, yerr = yerr)
plt.show()

• 비대칭 편차 나타내기

import matplotlib.pyplot as plt

x = [1,2,3,4]
y = [1,4,9,16]
yerr = [(2.3, 3.1, 1.7, 2.5), (1.1, 2.5, 0.9, 3.9)]
plt.errorbar(x, y, yerr= yerr)
plt.show()

matplotlib 파이차트 그리기

• 범주별 구성 비율을 원형으로 표현한 그래프
• matplotlib.pyplot 모듈의 pie()함수 이용

import matplotlib.pyplot as plt

ratio = [34, 32, 16, 18]
labels = ['Apple', 'Banana', 'Melon', 'Grapes']
plt.pie(ratio, labels = labels, autopct = '%1.f%%')
plt.show()

• 시작 각도와 방향 설정

plt.pie(ratio, labels = labels, autopct = '%.1f%%', startangle = 260,
counterclock = False)

matplotlib 파이차트 그리기

• 그림자 나타내기
• 색상지정

import matpotlib.pyplot as plt

ratio = [34, 32, 16, 18]
labels = ['Apple', 'Banana', 'Melon', 'Grapes']
explode = [0.05, 0.05, 0.05, 0.05]
colors = ['silver', 'gold', 'whitesmoke', 'lightgray']
plt.pie(ratio, labels = labels, autopct = '%.1f%%',
startangle = 260, counterclock = False, explode = explode,
shadow = True, colors = colors)
plt.show()

xml의 이해

XML의 개념

• XML은 확장적인 마크업 언어라는 뜻으로, 데이터의 구조와 의미를 설명하는 태그를 사용하여 어떤 데이터의 속성과 값을 표현하는 언어
• 시작 태그와 종료태그 사이에 값이 있고, 그 값은 태그의 이름으로 만들어진 속성에 대한 값

• 정보의 구조에 대한 정보인 스키마와 DTD 등으로 정보에 대한 정보가 표현
• 용도에 따라 다양한 형태로 변형 가능
• 컴퓨터 간에 정보를 주고 받기 위한 유용한 저장방식으로 사용됨

XML 문서

• 간단한 딕셔너리로 생각하면 다음과 같은 방식으로 표현할 수 있다.

XML Parsing in Python

• 정규식으로도 파싱 가능
• 사용하기 쉬운 도구들이 갭발되어 있음
• 가장 많이 쓰이는 파서는 BeautifulSoup

BeautifulSoup 모듈 개요

• beautifulsoup 모듈은 HTML과 XML 문서들의 구문을 분석하기 위한 파이썬 패키지
• 전통적인 파이썬 XML 파서(XML Parser)에는 lxml과 htmlslib 드이 있으며, Beautifulsoup모듈은 이를 차용하여 데이터를 쉽고 빠르게 처리함

BeautifulSoup 모듈 사용법

from bs4 import BeautifulSoup

with open("../Users/chohyunjun/Desktop/data/books (1).xml", "r", encoding = "utf8")as books_file:
    books_xml = books_file.read()
soup = BeautifulSoup(books_xml, "lxml")
#aouthor가 들어간 모든 요소의 값 추출.
for book_info in soup.find_all("author"):
    print(book_info)
    print(book_info.get_text())

PSPTO XML 데이터

• 미국 특허청의 특허 데이터는 XML 제공됨
• 특정 특허 XML 문서로부터 필요한 정보 가져오는 실습 : 분석할 특허는 등록번호

import urllib.request
from bs4 import BeautifulSoup

with open(".US08621662-20140107 (1).xml", "r", encoding = "UTF8") as patent_xml:
    xml = patent_xml.read()
soup = BeautifulSoup(xml, "lxml")
invention_title_tag = soup.find("invention-title")
print(invention_title_tag.get_text())

Lab: XML 파싱

import urllib.request
from bs4 import BeautifulSoup

with open("../Users/chohyunjun/Desktop/data/US08621662-20140107 (1).xml", "r", encoding = 'utf8')as patent_xml:
    xml = patent_xml.read()
soup = BeautifulSoup(xml, "lxml")
invention_title_tag = soup.find("invention-title")
print(invention_title_tag.get_text())
publication_reference_tag = soup.find("publication-reference")
p_document_id_tag = publication_reference_tag.find("document-id")
p_country = p_document_id_tag.find("country").get_text()
p_doc_number = p_document_id_tag.find("doc-number").get_text()
p_kind = p_document_id_tag.find("kind").get_text()
p_date = p_document_id_tag.find("date").get_text()

JSON의 이해

• JSON의 개념
• (JAVASCRIPT OBJECT Notation)
• JSON은 XML보다 데이터 용량이 적고 코드로의 전환이 쉽다는 측면에서 XML의 대체로 가장 많이 활용되고 있음
• JSON은 파이썬의 딕셔너리형과 매우 비슷
• key:value의 쌍으로 구성되어 있음

JSON과 XML

• XML과 비교할 때 JSON의 장점.
• 간결한 코드.
• 쉬운 코드의 전환.
• 코드의 간결함 때문에 용량의 절약(가장 큰 장점)

JSON IN PYTHON

• JSON 모듈을 사용하여 손 쉽게 파싱 및 저장 가능
• PYTHON은 기본적으로 JSON 표준 라이브러리(json) 제공
• ‘import json’을 사용하여 JSON 라이브러리 사용
• JSON 라이브러리를 사용하여 PYTHON 타입의 Object를 JSON 문자열로 변경할 수 있고(JSON인코딩), 또한 JSON 문자열을 다시 Python 타입으로 변환할 수 있음.(JSON 디코딩)
• 데이터 저장 및 읽기는 dict type과 상호 호환 가능
• 웹에서 제공하는 API는 대부분 정보 교환 시 JSON 활용
• 페이스북, 트위터, GITHUB 등 거의 모든 사이트
• 각 사이트 마다 Developer API의 활용법을 찾아 사용

Lab : JSON 데이터 분석 — 읽기

• JSON 읽기
• 파이썬에서 JSON dmf tkdydgkrl dnlgotjsms .Json 모듈 이용. Json 데이터 포맷은 데이터 저장 및 읽기가 딕셔너리형과 완벽히 상호 호환되어, 딕셔너리형에 익숙한 사용자가 매우 쉽게 사용할 수 있다는 장점이 있음
• JSON을 읽기 위해서는 JSON 파일의 구조를 확인한 후, JSON 모듈로 읽고 딕셔너리형처럼 처리한다

Sample data(json_example.json)

• 앞 sample data 에는 ‘employees’ 아래에 3개의 데이터가 있다
• 파이썬으로 읽어 오기 위해 다음과 같이 입력

import json
with open("json_example.json","r",encoding = "utf8") as f:
	contents = f.read()
	json_data = json.loads(contents)
	print(json_data["employees"])

• JSON 읽기.
• 1행에서 JSON 모듈을 호출.
• 3행에서 open() 함수를 사용하여 파일 내용을 가져옴.
• 4행에서 문자열형으로 변환하여 처리.
• 5행에서는 loads() 함수를 사용하여 해당 문자열을 딕셔너리형처럼 변환.
• 6행에서 테스트로 json_data[”employees”]를 출력.
• 읽기 — request 모듈 사용.
• import requests url = '웹사이트 json 파일' data =requests.get(url).json() <예제> import requests url = '.....' data = requests.get(url).json() print(data)
• JSON 쓰기.
• 딕셔너리형으로 구성된 데이터를 json형태의 파일로 변환하는 과정에 대해 알아보자.
• import json dict_data = {'Name' : 'Zara', 'Age':7, 'Class':'First'} with open("data.json","w") as f: json.dump(dict_data, f)
• → Json을 파일 작성.
• 3행처럼 데이터를 저장한 딕셔너리형 생성.
• 6행에서 Json.dump() 함수를 사용하여 데이터 저장. 이때 인수는 딕셔너리형 자료와 파일 객체.
• 실행 결과, 작업 폴더에 ‘data.json’ 파일.

1. DFS 알고리즘

BFS에 있던 큐(Queue) 대신에 스택(stack)으로 자료구조를 대체하기만 하면 쉽게 구현하실 수 있다.

graph = dict()
 
graph['A'] = ['B', 'C']
graph['B'] = ['A', 'D']
graph['C'] = ['A', 'G', 'H', 'I']
graph['D'] = ['B', 'E', 'F']
graph['E'] = ['D']
graph['F'] = ['D']
graph['G'] = ['C']
graph['H'] = ['C']
graph['I'] = ['C', 'J']
graph['J'] = ['I']

def dfs(graph, start_node):
# 항상 두개의 리스트를 별도로 관리해주는 것.
    need_visited, visited = list(), list()
# 시작 노드를 시정.
    need_visited.append(start_node)
# 만약 방문이 필요한 노드가 있다면,
    while need_visited:
			# 그중에서 가장 마지막 데이터를 추출.
        node = need_visited.pop()
			# 만약 그 노드가 방문한 목록에 없다면
        if node not in visited:
			# 방문한 목록에 추가.
            visited.append(node)
			# 그 노드에 연결된 노드
            need_visited.extend(graph[node])

return visited

dfs(graph, 'A')

BFS 알고리즘

graph = dict()
 
graph['A'] = ['B', 'C']
graph['B'] = ['A', 'D']
graph['C'] = ['A', 'G', 'H', 'I']
graph['D'] = ['B', 'E', 'F']
graph['E'] = ['D']
graph['F'] = ['D']
graph['G'] = ['C']
graph['H'] = ['C']
graph['I'] = ['C', 'J']
graph['J'] = ['I']

def bfs(graph, start_node):
    need_visited, visited = [],[]
    need_visited.append(start_node)

while need_visited:
        node = need_visited[0]
        del need_visited[0]
        if node not in visited:
            visited.append(node)
            need_visited.extend(graph[node])
    return visited

bfs(graph, 'A')

A* 알고리즘

class Node:
    def __init__(self, data, hval, level):
        self.data = data
        self.hval = hval
        self.level = level

class Puzzle:
    def __init__(self, start):
        self.start = start
    def h(self, puzzle, goal):
        cnt = 0
        for i in range(3):
            for j in range(3):
                if puzzle[i][j] != goal[i][j]:
                    cnt += 1
        return cnt
    def f(self, puzzle, goal):
        return puzzle.level + self.h(puzzle.data, goal)
    def astar(self, puzzle):
        visit = []
        queue = []
        goal = [['1', '2', '3'], ['8', '0', '4'], ['7', '6', '5']]
        oper = ['up', 'down', 'right', 'left']
        start = Node(data=puzzle, hval=self.h(puzzle=puzzle, goal=goal), level=0)
        queue.append(start)
        while queue is not None:
            current = queue.pop(0)
            if(self.h(current.data, goal)==0):
                return visit
            else:
                visit.append(current.data)
                x, y = checkZero(current.data)
                for op in oper:
                    next = movePuzzle(copy.deepcopy(current.data), x, y, op)
                    if next not in visit and next is not None:
                        queue.append(Node(next, self.h(next, goal), current.level + 1))
                queue.sort(key=lambda x:self.f(x,goal), reverse=False)
        return -1

탐색 방법 개요

탐색

• 맹목적 탐색
• 정보이용 탐색
• 게임에서의 탐색 → 적대적탐색(두개의 에이전트가 적대적 관계를 가질 때)

게임에서의 탐색 알고리즘

• minimax 알고리즘
• 알파 — 베타 가지치기
• 몬테카를로 시뮬레이션
• 몬테카를로 트리 탐색

minimax 알고리즘

• 두 사람이 번갈아 수를 두고 승패를 겨루는 게임으로 확장
• 체스와 바둑 등
• 새로운 탐색 알고리즘 필요
• 인공지능은 어떤 전략을 구사해 상대를 이길 수 있을까?
• 미니맥스 전략
• 내가 둘차례에서는 MAX
• 상대 차례에서는 min을 적용(상대의 최적의 수는 나에게 최악의 수이므로 min 적용.)

alpha−Beta 가지치기

Minimax을 개선한 적대적 탐색방법으로써, MAX가 찾아 놓은 최선값인 알파값을 유지하여 후보 노드의 좋은 정도가 알파값 보다작을 경우 가지치기를 함으로써 보다 효율적인 탐색 수행

인공지능과 관련된 흥미로운 문제들

제약조건 만족 문제

인공지능 문제 해결을 위한 중요 단계

• 문제를 명확하게 정의
• 문제에 대한 철저한 분석
• 정해진 제약 조건이나 규칙이 있는 경우 규칙의 적용에 대한 검증
• 최적의 기법 선택
• 결과가 나오면 과정에 문제점이 없는지 분석 검토

초기의 인공지능 적용 문제 ‘상자 쌓기’

• 일정한 규칙과 목표 상태가 주어진 경우
• 인공지능을 이용하여 해결하는 방법의 예

tic-tae-toe 문제

from math import sqrt,log
import random

n=3
start='-'*(n*n)
class Node():
    def __init__(self,state,player=None,pos=None,parent=None):
        self.state=state
        self.player=player
        self.pos=pos
        self.parent=parent
        self.nwin=0
        self.nvisit=0
        self.untried=get_empty(state)
        self.children=[]
    def UCTselect(self):
        s=sorted(self.children, key=lambda c: c.nwin/c.nvisit+sqrt(log(self.nvisit)/c.nvisit))
        return s[-1]
    def makeChild(self,state,pos,player):
        node=Node(state,player,pos,parent=self)
        self.untried.remove(pos)
        self.children.append(node)
        return node
    def update(self,winner):
        self.nvisit+=1
        if winner=='T': # 비긴 경우
            self.nwin+=0.5
        elif winner==self.player:
            self.nwin+=1
    def __repr__(self):
        return str(self.state)+" "+str(self.nwin)+"/"+str(self.nvisit)
def Move(state,pos,player):
    return state[:pos]+player+state[pos+1:]
def switch_player(player):
    return 'X' if player=='O' else 'O'
def print_board(state):
    print('  0123456789012345'[:n+2])
    for i in range(n):
        print(str(i%10)+':'+state[n*i:n*(i+1)])
def get_empty(state):
    if decide_winner(state) in ['O','X','T']: # 승자가 정해지면
        return []
    empty=[]
    for i in range(len(start)):
        if state[i]=='-':
            empty.append(i)
    return empty
def decide_winner(state):
    for (a,b,c) in [(0,1,2),(3,4,5),(6,7,8),(0,3,6),(1,4,7),(2,5,8),(0,4,8),(2,4,6)]:
        if state[a]==state[b]==state[c]:
            if state[a]=='O': return 'O'
            elif state[a]=='X': return 'X'
    if [i for i in range(n*n) if state[i]=='-']==[]: return 'T' # Tie (비김)
    return 'N' # 아직 승자 정해지지 않음
def mcts(state,player):
    root=Node(state)
    for i in range(10000):
        node=root
        state=node.state
        roll_player=player
        while node.untried==[] and node.children!=[]: # 선택
            node = node.UCTselect()
            state=Move(state,node.pos,roll_player)
            roll_player=switch_player(roll_player)
        if node.untried!=[]: # 확장
            pos=random.choice(node.untried)
            state=Move(state,pos,roll_player)
            node=node.makeChild(state,pos,roll_player)
            roll_player=switch_player(roll_player)
        while True: # 시뮬레이션
            e=get_empty(state)
            if e==[]: break
            state=Move(state,random.choice(e),roll_player)
            roll_player=switch_player(roll_player)
        winner=decide_winner(state) # 백트랙킹
        while node!=None:
            node.update(winner);
            node = node.parent
    return sorted(root.children,key=lambda c:c.nwin/c.nvisit)[-1].pos
def tictactoe_play(first_mover):
    state=start
    player=first_mover
    print_board(state)
    while True:
        if player=='X':
            print("컴퓨터 차례입니다.")
            pos=mcts(state,player)
        elif player=='O':
            x,y=input("사람 차례입니다. (x와 y를 공백 구분하여 입력하세요.)").split()
            pos=int(y)*n+int(x)
            if state[pos]!='-':
                print("둘 수 없는 곳입니다.")
                continue
        state=Move(state,pos,player)
        print_board(state)
        winner=decide_winner(state)
        if winner in ['O','X','T']:
            if winner=='T': print('비겼습니다.')
            else: print(winner,'가 이겼습니다.')
            break
        player=switch_player(player)
# 틱택토를 시작하는 main
tictactoe_play('O')

수학적인 함수, 수학적인 계산 담당

• 넘파이 배열과 리스트의 차이점
• 넘파이가 제공하는 다차원 배열 넘파이의 강력한 기능을 직접 사용하면서 익히기
• 확률 분포와 난수 생성.
• 고차원 배열의 인덱싱 기법
• 넘파이가 제공하는 데이터 분석 함수 사용
• 다수 변수들 간의 상관관계 계산

리스트, 넘파이배열(nd.array)

리스트는 여러 개의 값들을 저장할 수 있는 자료구조.

리스트는 다양한 자료형의 데이터를 여러 개 저장할 수 있으며 데이터를 변경하거나 추가, 제거할 수 있음.

하지만 데이터 과학에서는 파이썬의 기본 리스트로 충분하지 않음.

데이터를 처리할 떄는 리스트와 리스트 간의 다양한 연산이 필요함.

따라서, 데이터 과학자들은 기본 리스트 대신에 넘파이 선호

Numpy란.

• numpy는 C언어로 구현된 파이썬 라이브러리로써,고성능의 수치계산을 위해 제작. 먼저, numpy를 이용하기 위해서는 numpy를 import 해야 함.

import numpy as np

numpy 기초

# numpy 사용.
import numpy as np

# Array 정의.
data1 = [1,2,3,4,5]
data1
data2 = [1,2,3,3.5,4]
data2
# numpy를 이용하여 array 정의.
# 1. 위에서 만든 python list를 이용.
arr1 = np.array(data1)
arr1
# array의 형태(크기)를 확인할 수 있음.
arr1.shape
# 2. 바로 python list를 넣어 줌으로써 만듦.
arr2 = np.array([1,2,3,4,5])
arr2
arr2.shape
# array의 자료형을 확인할 수 있음.
arr2.dtype
arr3 = np.array(data2)
arr3
arr3.shape
arr3.dtype
arr4 = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
arr4
arr4.shape

numpy shape

numpy에서는 해당 array의 크기를 알 수 있음. shape를 확인함으로써 몇개의 데이터가 있는지, 몇 차원으로 존재하는지 등을 확인할 수 있음. 위에서 arr1.shape의 결과는 (5,) 으로써, 1차원의 데이터이며 총 5라는 크기를 갖고 있음을 알 수 있음.

numpy 자료형

arr1이나 arr2는 int64라는 자료형을 갖는 것에 반해 arr3는 float64라는 자료형을 갖음. 이는 arr3 내부 데이터를 살펴보면 3.5라는 실수형 데이터를 갖기 때문임을 알 수 있음. numpy에서 사용되는 자료형은 아래와 같음. (자료형 뒤에 붙는 숫자는 몇 비트 크기인지를 의미)

• 부호가 있는 정수 int(8, 16, 32, 64)
• 부호가 없는 정수 unit(8, 16, 32, 64)
• 실수 float(16, 32, 64, 128)
• 복소수 complex(64, 128, 256)
• 불리언 bool
• 문자열 string_
• 파이썬 오브젝트 object
• 유니코드 unicode

넘파이의 핵심적인 객체는 다차원 배열

ex) 정수들의 2차원 배열(테이블)을 넘파이를 이용해서 생성.
배열의 각 요소는 인덱스(index)라고 불리는 정수들로 참조됨.
넘파이에서 차원은 축(axis)이라고도 함

• Why 넘파이?
• 넘파이는 성능이 우수한 ndarray 객체 제공.
• ndarray의 장점.
• ndarray는 C언어에 기반한 배열 구조 : 메모리를 적게 차지하고 속도가 빠름.
• ndarray를 사용하면 배열과 배열 간에 수학적인 연산을 적용할 수 있음.
• ndarray는 고급 연산자와 풍부한 함수들을 제공

Numpy의 장점

• 파이썬 리스트 더하기 연산자는 두 리스트를 연결
• Numpy배열 더하기 연산자는 벡터의 연산으로 계산

np.zeros(), np.ones(), np.arange() 함수

np.zeros(10)
np.zeros((3,5))
# np.ones() 함수는 인자로 받는 크기만큼, 모든요소가 1인 array를 만듦.
np.ones(9)
np.ones((2, 10))

# np.arange() 함수는 인자로 받는 값 만큼 1씩 증가하는 1차원 array를 만듦.
# 이때, 하나의 인자만 입력하면 0~ 입력한 인자 값 만큼의 크기를 가짐.

np.arange(10)
np.arange(3, 10)

array 연산

기본적으로 numpy에서 연산을 할 때는 크기가 서로 동일한 array 끼리 연산이 진행됨.

arr1 = np.array([[1,2,3], [4,5,6]])
arr1

arr1.shape
arr2 = np.array([[10, 11, 12], [13, 14, 15]])
arr2
arr2.shape
# array 덧셈
arr1 + arr2
# array 뺄셈.
arr1 - arr2
# array 곱셈.
arr1 * arr2
# array 나눗셈.
arr1 / arr2
# array의 브로드 캐스트.
# 위에서 array가 같은 크기를 가져야 사로 연산이 가능하다고 했지만,
# numpy에서는 브로드캐스트라는 기능을 제공.
# 브로드캐스트란?, 서로 크기가 다른 array가 연산이 가능하게 끔 하는 것.
arr1
arr1.shape
arr3 = np.array([10, 11, 12])
arr3
arr3.shape
arr1 + arr3
arr1 * arr3
arr1 * 10
# 각각의 데이터의 제곱처리
arr1 ** 2

array 인덱싱

numpy에서 사용되는 인덱싱은 기본적으로 python 인덱싱과 동일. 이때, python에서와 같이 1번째 시작하는 것이 아니라 0번째로 시작하는 것에 주의해야 함.

import numpy as np

arr1 = np.arange(10) # 0~9까지 숫자를 numpy배열에 표현이 됨.
arr1
# 1번째 데이터
arr1[0]
# 3번째 데이터
arr1[2]
# 4번째 요소부터 9번째 요소
arr1[3:9]
# 전체데이터를 뽑음
arr1[:]

arr2 = np.array([[1,2,3,4],
                 [5,6,7,8],
                 [9,10,11,12]])

arr2

# 2차원의 array에서 인덱싱을 하기 위해서는 2개의 인자를 입력해야 함.
arr2[0, 0]


# 3행의 모든 요소 꺼내기.
arr2[2, :]

# 3행의 4번째 요소 꺼내기.
arr2[2, 3]

# 모든 행, 열의 4번째 요소 꺼내기
arr2[:, 3]

array boolean 인덱싱(마스크)

위에서 이용한 다차원의 인덱싱을 응용하여 boolean 인덱싱을 할 수 있음. 해당 기능은 주로 마스크라고 이야기하는데, boolean인덱싱을 통해 만들어낸 array를 통해 우리가 원하는 행 또는 열의 값만 뽑아낼 수 있음. 즉, 마스크처럼 우리가 가리고 싶은 부분은 가리고, 원하는 요소만 꺼낼 수 있음.

names = np.array(['Beomwoo','Beomwoo','Kim','Joan','Lee','Beomwoo','Park','Beomwoo'])

names

names.shape

# 아래에서 사용되는 np.random.randn() 함수는 기대값이 0이고, 표준편차가 1인 가우시안 정규 분포를 따르는 난수를 발생시키는 함수.
# 이 외에도 0~1의 난수를 발생시키는 np.random.rand() 함수도 존재함.

data = np.random.randn(8,4) # 가로(row) 8, 세로(col) 4 인 데이터 구조를 가지는 난수(랜덤한 숫자)를 생성해라.
data


data.shape

위와 같은 names와 data라는 array가 있음. 이때, names의 각 요소가 data의 각 행과 연결된다고 가정해보자. 그리고 이 때, names가 Beomwoo인 행의 data만 보고 싶을 때 다음과 같이 마스크를 사용.

# 요소가 Beomwoo인 항목에 대한 mask 생성.

names_Beomwoo_mask = (names == 'Beomwoo')
names_Beomwoo_mask

data[names_Beomwoo_mask,:] # data[names == 'Beomwoo', :]

# 요소가 Kim인 행의 데이터만 꺼내기
data[names == 'Kim',:]

# 논리 연산을 응용하여, 요소가 Kim 또는 Park인 행의 데이터만 꺼내기

data[(names == 'Kim') | (names == 'Park'),:]

# 먼저 마스크를 만든다.
# data array에서 0번째 열이 0보다 작은 요소의 boolean 값은 다음과 같음.
data[:,0] < 0

# 위에서 만든 마스크를 이용하여 0번째 열의 값이 0보다 작은 행을 구함.
data[data[:,0]<0,:]

이를 통해 특정 위치에만 우리가 원하는 값을 대입가능

# 0번째 열의 값이 0보다 작은 행의 2,3번째 열 값.
data[data[:,0]<0,2:4]

data[data[:,0]<0,2:4] = 0
data

Numpy 함수

arr1 = np.random.randn(5,3)
arr1

# 각 성분의 절대값 계산하기
np.abs(arr1)

# 각 성분의 제곱근 계산하기 ( == array ** 0.5)
np.sqrt(arr1)

# 각 성분의 제곱 계산하기
np.square(arr1)

# 각 성분을 무리수 e의 지수로 삼은 값을 계산하기
np.exp(arr1)

# 각 성분을 자연로그, 상용로그, 밑이 2인 로그를 씌운 값을 계산하기

np.log(arr1)
np.log10(arr1)
np.log2(arr1)

# 각 성분의 부호 계산하기(+인 경우 1, -인 경우 -1, 0인 경우 0)
np.sign(arr1)

# 각 성분의 부호 계산하기(+인 경우 1, -인 경우 -1, 0인 경우 0)
np.sign(arr1)

# 각 성분의 소수 첫 번째 자리에서 내림한 값을 계산하기
np.floor(arr1)

np.isnan(np.log(arr1))

# 각 성분이 무한대인 경우 True를, 아닌 경우 False를 반환하기
np.isinf(arr1)

# 각 성분에 대해 삼각함수 값을 계산하기(cos, cosh, sin, sinh, tan, tanh)
np.sin(arr1)

두 개의 array에 적용되는 함수

arr1

arr2 = np.random.randn(5,3)
arr2
# 두 개의 array에 대해 동일한 위치의 성분끼리 연산 값을 계산하기
# (add, subtract, multiply, divide)
np.multiply(arr1,arr2)
# 두 개의 array에 대해 동일한 위치의 성분끼리 비교하여 최대값 또는 최소값 계산하기(maximum, minimum)
np.maximum(arr1,arr2)

기본적인 통계함수

arr1

# 전체 성분의 합을 계산
np.sum(arr1)
# 행 간의 합을 계산
np.sum(arr1, axis=1)
# 열 간의 합을 계산
np.sum(arr1, axis=0)
# 전체 성분의 평균을 계산
np.mean(arr1)
# 행 간의 평균을 계산
np.mean(arr1, axis=0, 1)
# 전체 성분의 표준편차, 분산, 최소값, 최대값 계산(std, var, min, max)
np.std(arr1)
np.min(arr1, axis=0, 1)
# 전체 성분의 최소값, 최대값이 위치한 몇번째를 반환(argmin, argmax)
np.argmin(arr1)
np.argmax(arr1,axis=0, 1)
# 맨 처음 성분부터 각 성분까지의 누적합 또는 누적곱을 계산(cumsum, cumprod)
np.cumsum(arr1)
np.cumsum(arr1,axis=0, 1)
np.cumprod(arr1)

Numpy에서의 인덱싱과 슬라이싱

scores = np.array([88,72,93,94,89,78,99])

scores[2]
scores[-1]

score[3:] # 마지막 인덱스를 생략하면 디폴트 값은 -1임
scores[4:-1] # 마지막 인덱스로 -1을 사용할 경우 -1의 앞에 있는 78까지 슬라이싱함.

논리적인 인덱싱을 통한 값 추출

• 논리적인 인덱싱이란 어떤 조건을 주어서 배열에서 원하는 값을 추려내는 것

ages = np.array([18, 19, 25, 30, 28])

• ages에서 20살 이상인 사람만 고르려고 하면 다음과 같은 조건식을 써줌

y = ages > 20
y # 결과는 부울형의 넘파이 배열.

age[ages > 20]

bmi = np_weights/(np_heights ** 2)
print(bmi[bmi > 25])

2차원 배열의 인덱싱

• 2차원 리스트는 “리스트의 리스트”라고 말할 수 있음.
• 수학의 행렬과는 비슷하지만 리스트는 행렬 연산을 지원하지 않음.

import numpy as np
y = [[1,2,3],[4,5,6],[7,8,9]]
y

• 넘파이의 2차원 배열은 수학에서의 행렬과 같이 다룰 수 있음.
  -> 역행렬이나 행렬식을 구하는 등의 행렬 연산들이 쉽게 적용될 수 있음.

np_array = np.array(y)
np_array

• 첫 번째 인덱스는 행, 두 번째 인덱스는 열

np_array[0][2]

• np_array[0][1] == np_array[0,1](넘파이 표기법)
• 콤마 앞에 값은 행, 콤마 뒤에 값은 열

np_array[0, 0] = 12
np_array

• 파이썬 리스트와 달리, 넘파이 배열은 모든 항목이 동일한 자료형을 가짐.
• 정수 배열에 부동 소수점 값을 삽입하려고 하면 소수점 이하값은 버림.

np_array[2,2] = 1.234
np_array

• 슬라이싱은 큰 행렬에서 작은 행렬을 추출하는 의미

np_array = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]])
np_array[0;2, 2:4]

• 2차원 행렬에서 하나의 행을 지정하는 방식

np_array[0]

• 넘파이 스타일의 표기법도 가능

np_array[1, 1:3]

• ndarray의 인덱싱 및 슬라이싱 예제

import numpy as np

np_array = np.array([[1,2,3], [4,5,6], [7,8,9]])
np_array > 5

np_array[np_array > 5]

np_array[:, 2]

np_array[:, 2] > 5

np_array[:] % 2 == 0

np_array[np_array % 2 == 0]

난수생성함수

함수내용np.random.seed()np.random.seed(42)np.random.randn()표준 정규분포에 따른 n개의 무작위 숫자 생성np.random.randint()np.random.randint(0, 10, 5) # 0 이상 10 미만의 숫자 5개 랜덤 생성

linspace() 함수, logspace() 함수

linspace()는 시작값부터 끝값까지 균일한 간격으로 지정된 개수만큼의 배열 생성.

비슷한 함수로 logspace()함수로 로그스케일로 수들을 생성

linspace() 함수와 logspace() 함수

np.linspace(0, 10, 100)

0부터 10까지 균일한 간격으로 100개로 쪼갬

np.logspace(0, 5, 10)

배열의 형태를 바꾸는 reshape() 함수, flatten() 함수

• reshape() 함수는 상당히 많이 사용되는 함수.
• 데이터의 개수는 유지한 채로 배열의 차원과 형태 변경. 이 함수의 인자인 shape를 튜플의 형태로 넘겨주는 것이 원칙이지만, reshape(x, y)라고 하면 reshape((x, y))와 동일하게 처리.

y = np.arange(12)
y

y.reshape(3, 4)

배열의 형태를 3행 4열 형태로 바꿔줌

y.reshape(6, -1)

y.reshape(7, 2)

reshape()에 의해 생성될 배열의 형태가 호환되지 않을 경우 발생하는 오류

y.flatten() # 배열의 2차원이상의 고차원 배열을 1차원으로 작성하는 함수

Streamlit share.

streamlit share 사이트.

URL: https://share.streamlit.

---

프로젝트 명

우리나라의 관광지 분석을 통한 신규 관광객 유입

---

프로젝트 개요.

1. 주제
2. 주제 선정이유.
3. 우리나라의 코로나19 방역 완화, 엔데믹과 원화 가치 급락 등의 이유로 외국인 관광객의 방한이 많아지고 있다. 우리나라의 관광지 분석을 통해 기존의 사람들이 잘 몰랐었던 숨어있는 관광지를 알려주고, 관광객이 줄어들고 있는 관광지는 새로운 마케팅을 통해 관광객을 끌어들일 수 있는 기회를 만듦.
4. b. 장점 & 보완점
5. 프로그램.
6. 프로그램의 구성도
7. 인기 TOP 10을 만들어서 해당 지역 주변의 편의시설 등을 알려주는 것을 만듦

---

프로젝트 주요 내용 및 기능.

• 관광지역의 관광객들의 유입 분석기능
• 인기 많은 관광지역 주변의 편의시설 및 맛집 추천 기능
• 현재 위치 기반으로 가까운 관광지 추천?

---

개발 내용.

💡 기준연월 2019.11~2022.10 데이터 날짜 기준

1. 서울시 주요 관광지점 입장객 방문 수 분석

[주요관광지점 입장객(2004.07 이후)_221203075929.xls](%25EC%25A3%25BC%25EC%259A%2594%25EA%25B4%2580%25EA%25B4%2591%25EC%25A7%2580%25EC%25A0%2590_%25EC%259E%2585%25EC%259E%25A5%25EA%25B0%259D(2004.07_%25EC%259D%25B4%25ED%259B%2584)_221203075929.xls)


import numpy as np
import pandas as pd

visitors = pd.read_excel('../Users/chohyunjun/Downloads/visitor.xls', thousands=',')
visitors
visitors_total = visitors.loc[visitors['내/외국인'] == '합계']
visitors_total = visitors_total.iloc[:,0:31]

import googlemaps

gmaps_key = "AIzaSyCpqSO-mFH36wjjiqUlQPJHhwYkLE9WWns"
gmaps = googlemaps.Client(key = gmaps_key)

visit_name = []

for name in visitors_total['관광지']:
    visit_name.append('서울'+ str(name))

visit_name

visit_address = []
visit_lat = []
visit_lng = []

    print(name + '-->' + tmp[0].get("formatted_address"))

visit_lat

visit_lng

visitors_total['lat'] = visit_lat
visitors_total['lng'] = visit_lng

visitors_total1 = pd.pivot_table(visitors_total, index = ['관광지'])

import folium

map = folium.Map(location=[37.5502, 126.982], zoom_start= 11)

for n in visitors_total1.index:
    folium.Marker([visitors_total1['lat'][n],
                visitors_total1['lng'][n]]).add_to(map)

map

---

streamlit

import urllib.request
import numpy as np
import pandas as pd
import plotly.express as px
import requests
import streamlit as st
import xmltodict
from pandas import json_normalize
from streamlit_extras.add_vertical_space import add_vertical_space
from streamlit_lottie import st_lottie
import folium
import googlemaps
from streamlit_folium import st_folium
from folium import plugins
from folium.plugins import MarkerCluster
from folium import Map, Popup, Marker, Icon, IFrame

st.set_page_config(page_title="파이썬응용 데이터분석 기말 프로젝트", layout="wide")
row0_spacer1, row0_1, row0_spacer2, row0_2, row0_spacer3 = st.columns(
    (0.1, 6, 0.2, 2, 0.1)
)
row0_1.title("파이썬응용 데이터분석 기말 프로젝트.")
with row0_2:
    add_vertical_space()
    st.markdown("###### 2017E8129 통계데이터과학과 조현준")
def visitor_area():
        st.subheader("방문자 거주지 분포.")
        st.markdown("###### 방문자 거주지 분포 시각화를 통해 경기도, 인천광역시, 강원도등 순으로 방문객 비율을 보이고 있다.")
        visitorArea = pd.read_csv('https://raw.githubusercontent.com/CHJun47/Data/main/visitor_area.csv', encoding = 'CP949')
        fig3 = px.treemap(visitorArea, path = [px.Constant('대한민국'),'광역지자체명','기초지자체명'], values = '방문자 수(합)',
                            color = '방문자 수(합)',
                            color_continuous_scale = 'GnBu')
        fig3.update_layout(margin = dict(t=50, l=25, r=25, b=25))
        st.plotly_chart(fig3, theme = "streamlit", use_container_width = True)
def visitor_seoul():
    line1_spacer1, line1_1, line1_spacer2 = st.columns((0.1, 3.2, 0.1))
    with line1_1:
        st.header("Analysis of Seoul Data.")
        st.markdown("###### 서울은 대한민국의 수도이자 많은 관광객들이 몰려 있는 곳이다. 한국을 찾는 많은 관광객들이 주로 서울을 방문하는 경우들이 많다. 서울관광지 Top10 데이터를 분석하여 관광지를 추천해주고자 한다.") 
    row3_space1, row3_1, row3_space2, row3_2, row3_space3 = st.columns(
        (0.1, 1, 0.1, 1, 0.1)
    )
    with row3_1:
        st.subheader("서울 방문자 수")
        st.markdown("###### 코로나19 유행 기간 서울 방문자 수가 급격히 줄어 들었지만, 거리두기가 풀린 뒤 서울 방문객들이 점차 증가하는 추세를 보이고 있다.")
        visitorData = pd.read_csv('https://raw.githubusercontent.com/CHJun47/Data/main/visitorData_seoul.csv', encoding='CP949')
        visitorData.columns = ["기준연월","지역명","방문자 수"]
        fig = px.line(
            visitorData,
            x = '기준연월',
            y = '방문자 수',
            color_discrete_sequence = ["lightgoldenrodyellow"]
        )
        st.plotly_chart(fig, theme = "streamlit", use_container_width = True)
    with row3_2:
        visitor_area()      
visitor_seoul()
def inflow_ouflow_chart():
    row4_spacer1, row4_1, row4_spacer2 = st.columns((0.1, 5, 0.1))
    with row4_1:
        st.subheader("유입 유출 분석")
        st.markdown("###### 서울의 유입 유출 방문객의 분석을 통해 첫 번째로 많이 나타는 경기도 유입은 86.9% ,유출은 85.5%, 두 번째는 인천광역시 유입9.9% ,유출8.2%, 세 번째는 강원도 유입1.1% ,유출3.7%를 나타내고 있음.")
        flowData = pd.read_csv("https://raw.githubusercontent.com/CHJun47/Data/main/inflow_outflow.csv", encoding = 'CP949')
        fig1 = px.parallel_categories(
            flowData,
            color = "유입 비율",
            color_continuous_scale = "GnBu"
            )
        st.plotly_chart(fig1, theme = "streamlit", use_container_width = True)
inflow_ouflow_chart()
def touristDest():
    row5_space1, row5_1, row5_space2, row5_2, row5_space3 = st.columns(
        (0.1, 1, 0.1, 1, 0.1)
    )
    with row5_1:
        st.subheader("관광소비 유형.")
        st.markdown("###### 관광소비 유형으로 1위가 식음료이다. 음식은 그 나라의 문화와 전통을 가장 잘 나타낼 수 있는 관광 자원이다.") 
        st.markdown("###### 한 지역을 대표하는 음식은 때로는 그 자체만으로도 여행의 목적이 되기도 한다.")
        st.markdown("###### 2위로 쇼핑업을 볼 수 있다. 유행하는 옷이나 우리나라를 대표하는 한복을 입고 문화를 즐기고 향유하려는 것을 볼 수 있다.")
        st.markdown("###### 나머지는 운송업, 숙박업, 여가서비스등을 볼 수 있다.")
        tourrist_dest = pd.read_csv("https://raw.githubusercontent.com/CHJun47/Data/main/tourrist_dest.csv", encoding='CP949')
        fig4 = px.treemap(tourrist_dest, path = [px.Constant('점포'),'업종대분류명','업종중분류명'], values = '중분류 소비액(합)',
                            color = '중분류 소비액(합)',
                            color_continuous_scale = "GnBu")
        fig4.update_layout(margin = dict(t=50, l=25, r=25, b=25))
        st.plotly_chart(fig4, theme = "streamlit", use_container_width = True)
    with row5_2:
        st.subheader("SNS언급량.")
        st.markdown("###### 코로나19 거리두기로 여행이나 놀러갈 수 없는 상황이였지만,")
        st.markdown("###### 거리두기가 풀리고 나서부터 SNS에서도 여행, 놀러가는 사진을 SNS에서의 언급량이 점점 증가하고있다.")
        st.markdown("###### ")
        seoul_SNS = pd.read_csv('https://raw.githubusercontent.com/CHJun47/Data/main/seoul_SNS.csv', encoding = 'CP949')
        fig5 = px.bar(
            seoul_SNS,
            x = '기준연월',
            y = '검색량(건)',
            color_discrete_sequence = ["lightgoldenrodyellow"]
        )
        st.plotly_chart(fig5, theme = "streamlit", use_container_width = True)
touristDest()
def Folium_visit():
    row6_spacer1, row6_1, row6_spacer2, row6_2, row_spacer3 = st.columns((0.1, 30, 0.1,5,0.1))
    with row6_1:
        gmaps_key = "AIzaSyCpqSO-mFH36wjjiqUlQPJHhwYkLE9WWns"
        gmaps = googlemaps.Client(key = gmaps_key)
        visitors = pd.read_csv('https://raw.githubusercontent.com/CHJun47/Data/main/visitor(2).csv', encoding='CP949')
        visitors_total = visitors.loc[visitors['내/외국인'] == '합계']
        visitors_total = visitors_total.iloc[:,0:31]
        visit_name = []
        visit_url = []
        for name in visitors.iloc[:,-1]:
            visit_url.append(name)
        
        for name in visitors_total['관광지']:
            visit_name.append('서울'+ str(name))
        visit_address = []
        visit_lat = []
        visit_lng = []
        for name in visit_name:
            tmp = gmaps.geocode(name, language='ko')
            tmp_loc = tmp[0].get("geometry")
            visit_lat.append(tmp_loc['location']['lat'])
            visit_lng.append(tmp_loc['location']['lng'])
        # food.
        food = pd.read_csv('https://raw.githubusercontent.com/CHJun47/Data/main/food(1).csv')
        food_address = []
        food_lat = []
        food_lng = []
        food_name = []
        food_info = []
        food1_info = []
        food2_info = []
        food3_info = []
        food4_info = []
        food5_info = []
        food6_info = []
        food1_name = []
        food2_name = []
        food3_name = []
        food4_name = []
        food5_name = []
        food6_name = []
        for name in food.iloc[:,1]:
            food_name.append(name)
        for add in food.iloc[:,2]:
            food_address.append(str('서울')+add)
        for name in food_address:
            tmp = gmaps.geocode(name, language='ko')
            tmp_loc = tmp[0].get("geometry")
            food_lat.append((tmp_loc['location']['lat']))
            food_lng.append(tmp_loc['location']['lng'])
        food['lat'] = food_lat
        food['lng'] = food_lng
        food1 = food[food['분류'] == '음식점기타']
        for name in food1.iloc[:,5]:
            food1_info.append(name)
        food2 = food[food['분류'] == '한식']
        for name in food2.iloc[:,5]:
            food2_info.append(name)
        food3 = food[food['분류'] == '카페/찻집']
        for name in food3.iloc[:,5]:
            food3_info.append(name)
        food4 = food[food['분류'] == '간이음식']
        for name in food4.iloc[:,5]:
            food4_info.append(name)
        food5 = food[food['분류'] == '전문음식']
        for name in food5.iloc[:,5]:
            food5_info.append(name)
        food6 = food[food['분류'] == '외국식']
        for name in food6.iloc[:,5]:
            food6_info.append(name)
        for name in food1.iloc[:,1]:
            food1_name.append(name)
        for name in food2.iloc[:,1]:
            food2_name.append(name)
        for name in food3.iloc[:,1]:
            food3_name.append(name)
        for name in food4.iloc[:,1]:
            food4_name.append(name)
        for name in food5.iloc[:,1]:
            food5_name.append(name)
        for name in food6.iloc[:,1]:
            food6_name.append(name)
        food1 = pd.pivot_table(food1, index = ['주소'])
        food2 = pd.pivot_table(food2, index = ['주소'])
        food3 = pd.pivot_table(food3, index = ['주소'])
        food4 = pd.pivot_table(food4, index = ['주소'])
        food5 = pd.pivot_table(food5, index = ['주소'])
        food6 = pd.pivot_table(food6, index = ['주소'])
        visitors_total['lat'] = visit_lat
        visitors_total['lng'] = visit_lng
        visitors_total1 = pd.pivot_table(visitors_total, index = ['관광지'])
        map = folium.Map(location=[37.566535, 126.9779692],
        tiles = "stamen Terrain",
        zoom_start= 11)
        marker_cluster = MarkerCluster().add_to(map)
        ######################### 수정.
        if st.checkbox('관광지'):
            for n in range(int(len(visitors_total1))):
                folium.Marker([visitors_total1['lat'][n],
                visitors_total1['lng'][n]],tooltip = '"'+visit_name[n]+'"').add_to(marker_cluster)
        elif st.checkbox('음식점기타'):
            for n1 in range(int(len(food1))):
                folium.Marker([food1['lat'][n1],
                food1['lng'][n1]],popup = "<a href="+'"'+food1_info[n1]+'"'+"target ="+"_blank"+">Site</a>",tooltip = '"'+food1_name[n1]+'"',icon = folium.Icon(icon = 'star', color = 'red')).add_to(marker_cluster)
        elif st.checkbox('한식'):
            for n2 in range(int(len(food2))):
                folium.Marker([food2['lat'][n2],
                food2['lng'][n2]],popup = "<a href="+'"'+food2_info[n2]+'"'+"target ="+"_blank"+">Site</a>",tooltip = '"'+food2_name[n2]+'"',icon = folium.Icon(icon = 'star', color = 'yellow')).add_to(marker_cluster)
        elif st.checkbox('카페/찻집'):
            for n3 in range(int(len(food3))):
                folium.Marker([food3['lat'][n3],
                food3['lng'][n3]],popup = "<a href="+'"'+food3_info[n3]+'"'+"target ="+"_blank"+">Site</a>",tooltip = '"'+food3_name[n3]+'"',icon = folium.Icon(icon = 'star', color = 'green')).add_to(marker_cluster)
        elif st.checkbox('간이음식'):
            for n4 in range(int(len(food4))):
                folium.Marker([food4['lat'][n4],
                food4['lng'][n4]],popup = "<a href="+'"'+food4_info[n4]+'"'+"target ="+"_blank"+">Site</a>",tooltip = '"'+food4_name[n4]+'"',icon = folium.Icon(icon = 'star', color = 'orange')).add_to(marker_cluster)
        elif st.checkbox('전문음식'):
            for n5 in range(int(len(food5))):
                folium.Marker([food5['lat'][n5],
                food5['lng'][n5]],popup = "<a href="+'"'+food5_info[n5]+'"'+"target ="+"_blank"+">Site</a>",tooltip = '"'+food5_name[n5]+'"',icon = folium.Icon(icon = 'star', color = 'lightgray')).add_to(marker_cluster)
        elif st.checkbox('외국식'):
            for n6 in range(int(len(food6))):
                folium.Marker([food6['lat'][n6],
                food6['lng'][n6]],popup = "<a href="+'"'+food6_info[n6]+'"'+"target ="+"_blank"+">Site</a>",tooltip = '"'+food6_name[n6]+'"',icon = folium.Icon(icon = 'star', color = 'lightcyan')).add_to(marker_cluster)
        
        return map
st.subheader("주변 Search 지도.")
m = Folium_visit()
output = st_folium(m, key = "map", width = 1800, height = 600)

---

folium

import folium

m=folium.Map(location=[37.55092, 127.0377],zoom_start=11)
m.add_child(folium.LatLngPopup()) 
#Tpo10 우리나라 관광지추천
#경복궁iframe으로 사진 띄우기-사진 경로지정해야함 
pic1 = base64.b64encode(open('C:/Users/김나영/Desktop/Gbg.jpg','rb').read()).decode()
image_tag1 = '<img src="data:image/jpeg;base64,{}">'.format(pic1)
iframe1 = folium.IFrame(image_tag1, width=500, height=500)
popup1 = folium.Popup(iframe1, max_width=650)
# 1.경복궁
folium.Marker([37.579617, 126.977041], # 마커 찍고싶은 좌표를 구해와서 원본 m에다 표시/추가
            popup=popup1, # popup: 마커 클릭시 팝업으로 상세내용 표시되는 옵션 추가
            tooltip='<i>경복궁</i>').add_to(m)# tooltip: 마우스오버시 상세내용 표시
#창경궁iframe으로 사진 띄우기
pic2 = base64.b64encode(open('C:/Users/김나영/Desktop/Cgg.jpg','rb').read()).decode()
image_tag2 = '<img src="data:image/jpeg;base64,{}">'.format(pic2)
iframe2 = folium.IFrame(image_tag2, width=500, height=500)
popup2 = folium.Popup(iframe2, max_width=650)          
# 2.창경궁
folium.Marker([37.5787708, 126.9948698],
            popup=popup2,
            tooltip='<i>창경궁</i>').add_to(m)              
#창덕궁iframe으로 사진 띄우기
pic3 = base64.b64encode(open('C:/Users/김나영/Desktop/Cdg.jpg','rb').read()).decode()
image_tag3 = '<img src="data:image/jpeg;base64,{}">'.format(pic3)
iframe3 = folium.IFrame(image_tag3, width=500, height=500)
popup3 = folium.Popup(iframe3, max_width=650)
# 3.창덕궁
folium.Marker([37.5794309, 126.9910426],
            popup=popup3,
            tooltip='<i>창덕궁</i>').add_to(m)
#덕수궁iframe으로 사진 띄우기
pic4 = base64.b64encode(open('C:/Users/김나영/Desktop/Dsg.jpg','rb').read()).decode()
image_tag4 = '<img src="data:image/jpeg;base64,{}">'.format(pic4)
iframe4 = folium.IFrame(image_tag4, width=500, height=500)
popup4 = folium.Popup(iframe4, max_width=650)
#4.덕수궁
folium.Marker([37.5658049, 126.9751461],
            popup=popup4,
            tooltip='<i>덕수궁</i>').add_to(m)
#경희궁iframe으로 사진 띄우기
pic5 = base64.b64encode(open('C:/Users/김나영/Desktop/Ghg.jpg','rb').read()).decode()
image_tag5 = '<img src="data:image/jpeg;base64,{}">'.format(pic5)
iframe5 = folium.IFrame(image_tag5, width=500, height=500)
popup5 = folium.Popup(iframe5, max_width=650)
#5.경희궁
folium.Marker([37.5712378, 126.9681688],
            popup=popup5,
            tooltip='<i>경희궁</i>').add_to(m)
#세종대왕기념관iframe으로 사진 띄우기
pic6 = base64.b64encode(open('C:/Users/김나영/Desktop/King.jpg','rb').read()).decode()
image_tag6 = '<img src="data:image/jpeg;base64,{}">'.format(pic6)
iframe6 = folium.IFrame(image_tag6, width=500, height=500)
popup6 = folium.Popup(iframe6, max_width=650)
#6.세종대왕기념관
folium.Marker([37.590783, 127.0435458],
            popup=popup6,
            tooltip='<i>세종대왕기념관</i>').add_to(m)
#서울스카이iframe으로 사진 띄우기
pic7 = base64.b64encode(open('C:/Users/김나영/Desktop/Sky.png','rb').read()).decode()
image_tag7 = '<img src="data:image/jpeg;base64,{}">'.format(pic7)
iframe7 = folium.IFrame(image_tag7, width=500, height=500)
popup7 = folium.Popup(iframe7, max_width=650)
#7.서울스카이
folium.Marker([37.5136918, 127.1037211],
            popup=popup7,
            tooltip='<i>남산타워</i>').add_to(m)
#롯데월드iframe으로 사진 띄우기
pic8 = base64.b64encode(open('C:/Users/김나영/Desktop/Lotte.jpg','rb').read()).decode()
image_tag8 = '<img src="data:image/jpeg;base64,{}">'.format(pic8)
iframe8 = folium.IFrame(image_tag8, width=500, height=500)
popup8 = folium.Popup(iframe8, max_width=650)
#8.롯데월드
folium.Marker([37.5111158, 127.098167],
            popup=popup8,
            tooltip='<i>롯데월드</i>').add_to(m)
              
#서울시립미술관iframe으로 사진 띄우기
pic9 = base64.b64encode(open('C:/Users/김나영/Desktop/SMA.jpg','rb').read()).decode()
image_tag9 = '<img src="data:image/jpeg;base64,{}">'.format(pic9)
iframe9 = folium.IFrame(image_tag9, width=500, height=500)
popup9 = folium.Popup(iframe9, max_width=650)
#9.서울시립미술관
folium.Marker([37.5640625, 126.9738125],
            popup=popup9,
            tooltip='<i>서울시립미술관</i>').add_to(m)
              
#국립중앙박물관iframe으로 사진 띄우기
pic10 = base64.b64encode(open('C:/Users/김나영/Desktop/NMK.jpg','rb').read()).decode()
image_tag10 = '<img src="data:image/jpeg;base64,{}">'.format(pic10)
iframe10 = folium.IFrame(image_tag10, width=500, height=500)
popup10 = folium.Popup(iframe10, max_width=650)
#10.국립중앙박물관
folium.Marker([37.5238506, 126.9804702],
            popup=popup10,
            tooltip='<i>국립중앙박물관</i>').add_to(m

streamlit →folium지도

import urllib.request
import numpy as np
import pandas as pd
import plotly.express as px
import requests
import streamlit as st
from streamlit_folium import st_folium
from folium.plugins import MarkerCluster
import folium
import xmltodict
import base64
from pandas import json_normalize
from streamlit_extras.add_vertical_space import add_vertical_space
from streamlit_lottie import st_lottie

st.set_page_config(page_title="파이썬응용 데이터분석 기말 프로젝트", layout="wide")
row0_spacer1, row0_1, row0_spacer2, row0_2, row0_spacer3 = st.columns(
    (0.1, 6, 0.2, 2, 0.1)
)
row0_1.title("파이썬응용 데이터분석 기말 프로젝트.")
with row0_2:
    add_vertical_space()
    st.markdown("###### 2017E8129 통계데이터과학과 조현준")
def visitor_area():
        st.subheader("방문자 거주지 분포.")
        visitorArea = pd.read_csv('https://raw.githubusercontent.com/CHJun47/Data/main/visitor_area.csv', encoding = 'CP949')
        fig3 = px.treemap(visitorArea, path = [px.Constant('대한민국'),'광역지자체명','기초지자체명'], values = '방문자 수(합)',
                            color = '방문자 수(합)',
                            color_continuous_scale = 'GnBu')
        fig3.update_layout(margin = dict(t=50, l=25, r=25, b=25))
        st.plotly_chart(fig3, theme = "streamlit", use_container_width = True)
def visitor_seoul():
    line1_spacer1, line1_1, line1_spacer2 = st.columns((0.1, 3.2, 0.1))
    with line1_1:
        st.header("Analysis of Seoul Data.")
    row3_space1, row3_1, row3_space2, row3_2, row3_space3 = st.columns(
        (0.1, 1, 0.1, 1, 0.1)
    )
    with row3_1:
        st.subheader("서울 방문자 수")
        visitorData = pd.read_csv('https://raw.githubusercontent.com/CHJun47/Data/main/visitorData_seoul.csv', encoding='CP949')
        visitorData.columns = ["기준연월","지역명","방문자 수"]
        fig = px.line(
            visitorData,
            x = '기준연월',
            y = '방문자 수',
            color_discrete_sequence = ["lightgoldenrodyellow"]
        )
        st.plotly_chart(fig, theme = "streamlit", use_container_width = True)
    with row3_2:
        visitor_area()
visitor_seoul()
def inflow_ouflow_chart():
    row4_spacer1, row4_1, row4_spacer2 = st.columns((0.1, 5, 0.1))
    with row4_1:
        st.subheader("유입 유출 분석")
        flowData = pd.read_csv("https://raw.githubusercontent.com/CHJun47/Data/main/inflow_outflow.csv", encoding = 'CP949')
        fig1 = px.parallel_categories(
            flowData,
            color = "유입 비율",
            color_continuous_scale = "GnBu"
            )
        st.plotly_chart(fig1, theme = "streamlit", use_container_width = True)
inflow_ouflow_chart()
def touristDest():
    row5_space1, row5_1, row5_space2, row5_2, row5_space3 = st.columns(
        (0.1, 1, 0.1, 1, 0.1)
    )
    with row5_1:
        st.subheader("관광소비 유형.")
        tourrist_dest = pd.read_csv("https://raw.githubusercontent.com/CHJun47/Data/main/tourrist_dest.csv", encoding='CP949')
        fig4 = px.treemap(tourrist_dest, path = [px.Constant('점포'),'업종대분류명','업종중분류명'], values = '중분류 소비액(합)',
                            color = '중분류 소비액(합)',
                            color_continuous_scale = "GnBu")
        fig4.update_layout(margin = dict(t=50, l=25, r=25, b=25))
        st.plotly_chart(fig4, theme = "streamlit", use_container_width = True)
    with row5_2:
        st.subheader("SNS언급량.")
        seoul_SNS = pd.read_csv('https://raw.githubusercontent.com/CHJun47/Data/main/seoul_SNS.csv', encoding = 'CP949')
        fig5 = px.bar(
            seoul_SNS,
            x = '기준연월',
            y = '검색량(건)',
            color_discrete_sequence = ["lightgoldenrodyellow"]
        )
        st.plotly_chart(fig5, theme = "streamlit", use_container_width = True)
touristDest()
def draw_folium_map():
    center = [39.5, -98.5]
    tiles = ["cartodbpositron", "Stamen Toner", "OpenStreetMap"]
    map = folium.Map(
        location=[center[0], center[1]],
        zoom_start=10,
        zoom_control=True,
        scrollWheelZoom=False,
        tiles=tiles[0],
    )
    folium.Marker(
        location=[39.5, -98.5],
        popup=f"A location!",
        icon=folium.Icon(color="blue", icon="star"),
    ).add_to(map)
    return map
m = draw_folium_map()
output = st_folium(m, key="map", width=650, height=600)
st.write(output)

---

CircleMarker — popup

import pandas as pd
import folium
from folium.plugins import FastMarkerCluster

file_url = 'http://www2.census.gov/geo/docs/maps-data/data/gazetteer/2016_Gazetteer/2016_Gaz_zcta_national.zip'
#Pandas usually infers zips are numerics, but we lose our leading zeroes so let's go with the object dtype
df = pd.read_csv(file_url, sep='\t', dtype={'GEOID' : object}) 
df.columns = df.columns.str.strip() #some column names have some padding
df = df.sample(1000)
folium_map = folium.Map(location=[38, -97],
                        zoom_start=4.4,
                        tiles='CartoDB dark_matter')
# These two lines should create FastMarkerClusters
FastMarkerCluster(data=list(zip(df['INTPTLAT'].values, df['INTPTLONG'].values))).add_to(folium_map)
folium.LayerControl().add_to(folium_map)
for index, row in df.iterrows():
    # generate the popup message that is shown on click.
    popup_text = "{}<br> ALAND: {:,}<br> AWATER: {:,}"
    popup_text = popup_text.format(
                      index,
                      row["ALAND_SQMI"],
                      row["AWATER_SQMI"]
                      )
    folium.CircleMarker(location=(row["INTPTLAT"],
                                  row["INTPTLONG"]),
                        radius= row['ALAND_SQMI']/100,
                        color="#007849",
                        popup=popup_text,
                        fill=False).add_to(folium_map)
folium_map

회귀분석

flowchart TD

A['1단계 패키지 설정'] --> B['2단계 데이터 준비'] --> C['3단계 탐색적 데이터분석'] --> D['4단계 피처 스케일링'] --> E['5단계 모형화 및 학습'] --> F['6단계 예측']

from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
import numpy as np
import matplotlib.pyplot as plt

# 학습용 데이터
# 입력.
X_train = np.array([[25, 25],
        [33, 30],
        [38, 30],
        [45, 35],
        [28, 40]])
# 라벨.
y_train = np.array([0,0,1,1,0])
# 테스트용 데이터(새로운 개체)
X_test = np.array([[30, 35]]) # 새로운 개체의 X1, X2
# 산포도.
# 학습용 데이터.
plt.scatter(X_train[:,0], X_train[:,1], c = y_train)
# 테스트용 데이터.
plt.scatter(X_test[:,0], X_test[:,1], c = 'red', marker = 'D', s = 100)
plt.xlabel('x1')
plt.ylabel('x2')
plt.show()

# 피처 스케일링: 학습용 데이터.
scalerX = StandardScaler()
scalerX.fit(X_train)
X_train_std = scalerX.transform(X_train)
print(X_train_std)

# 피처 스케일링 : 테스트용 데이터.

X_test_std = scalerX.transform(X_test)
print(X_test_std)

# 모형화.
knn = KNeighborsClassifier(n_neighbors=3, metric='euclidean')
# 학습.
knn.fit(X_train_std, y_train)
# 에측.
pred = knn.predict(X_test_std)
print(pred)
#클래스별 확률 값을 반환.
knn.predict_proba(X_test_std)

# 인접한 k개의 개체들에 대한 거리와 색인을 반환.
dist,index = knn.kneighbors(X_test_std)
print(dist)
print(index)

KNN(k-Nearest Neighbor Classifier)

K-NN의 꽃잎 분류에의 적용 예.

• 꽃잎의 크기와 밝기에 따른 K-NN 분류.
• 오른쪽 위에 새로운 꽃잎이 입력으로 들어왔을 때 빨간 화살표의 3가지를 비교한 후 분류하는 것을 보여줌.

K-NN의 장단점과 활용 분야.

• 장점은 매우 간단하며 빠르고 효과적인 알고리즘 또 어떤 데이터라도 유사성 측정 가능.
• 단점으로는 적절한 k를 선택해야 한다는 점 새로운 데이터에 대해 일일이 거리를 계산한 후 분류.

K-NN의 활용 분야.

• 영화나 음악 추천에 대한 개인별 선호 예측.
• 수표에 적힌 광학 숫자와 글자인식.
• 얼굴인식과 같은 컴퓨터 비전.
• 유방암 등 질병의 진단과 유전자 데이터 인식.
• 재정적인 위험성의 파악과 관리, 주식 시장 예측.

# 새로운 값을 분류할 때 .predict() 사용.
unknown_points = [
    [0.2,0.1,0.7],
    [0.4,0.7,0.6],
    [0.5,0.8,0.1]
]

guesses = classifier.predict(unknown_points)
print(guesses)

sklearn을 이용한 kNN 알고리즘 실습

from sklearn.datasets import load_iris
iris = load_iris()
print(iris.data)

# 4개의 특징 이름을 출력.
print(iris.feature_names)

# 정수는 꽃의 종류를 나타낸다.: 0 = setosa, 1 = versicolor, 2 = virginica
print(iris.target)

from sklearn.model_selection import train_test_split

X = iris.data
y = iris.target
# (80:20)으로 분할.
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state=4)
print(X_train.shape)
print(X_test.shape)

from sklearn.neighbors import KNeighborsClassifier
from sklearn import metrics

knn = KNeighborsClassifier(n_neighbors=6)
knn.fit(X_train, y_train)
y_pred = knn.predict(X_test)
scores = metrics.accuracy_score(y_test, y_pred)

#0 = setosa, 1 = versicolor, 2 = virginca
classes = {0:'setosa', 1:'versicolor', 2:'virginca'}

# 아직 보지 못한 새로운 데이터를 제시해보자.

x_new = [[3,4,5,2],
        [5,4,2,2]]
y_predict = knn.predict(x_new)
print(classes[y_predict[0]])
print(classes[y_predict[1]])

나이브 베이지 분류 예제 살펴보기

나이브 베이즈의 정리

💡 P(A)가 A가 일어날 확률, P(B)가 B가 일어날 확률, P(B|A)가 A가 일어나고나서 B가 일어날 확률, P(A|B)가 B가 일어나고나서 A가 일어날 확률이라고 해봅시다. 이때 P(B|A) 를 쉽게 구할 수 있는 상황이라면, 아래와 같은 식을 통해 P(A|B)를 구할 수 있습니다.

P(A∣B)=P(B∣A)P(A)/P(B)

K-NN

• sklearn에서 제공하는 예시 데이터 중 유방암 데이터를 사용해 KNN 모델을 적용.

1. KNeighborsClassifier(n_neighbos = K)에서 K를 1부터 100까지 변화시켜서 테스트 해보기.
2. 가장 정확도가 큰 K는 얼마인지 알아보기.

기업별 개인 비서 리스트

⇒ 애플 → 시리

⇒ 구글 → 구글 어시스턴트, 구글 나우

⇒ 마이크로소프트 → 코타나

⇒ 아마존 → 알렉사(에코)

⇒ 페이스북 → M.(2018년 1월 중단.)

⇒ 삼성 → 빅스비

⇒ LG →. Q보이스

⇒ KT → KT 비서

intelligent agent(혹은 개인 비서)란?

에이전트는 특정한 목적을 위해 사용자를 대신해서 작업을 수행하는 자율적 프로세스. 에이전트는 독자적으로 존재하지 않고 어떤 환경의 일부이거나 그 안에서 동작하는 시스템. 여기서의 환경은 운영 체제, 네트워크 등을 지칭함. 에이전트는 지식베이스와 추론 기능을 가지며 사용자, 자원(resource), 또는 다른 에이전트와의 정보교환과 통신을 통해 문제해결을 도모함. 에이전트는 스스로 환경의 변화를 인지하고 그에 대응하는 행동을 취하며, 경험을 바탕으로 학습하는 기능을 가짐. 에이전트는 수동적으로 주어진 작업만을 수행하는 것이 아니고, 자신의 목적을 가지고 그 목적 달성을 추구하는 능동적 자세를 지님. 에이전트의 행동의 결과로 환경의 변화를 가져올 수 있다. 에이전트의 행동은 한번에 끝나는 것이 아니라 지속적으로 이루어짐.

성질

• 자율성.

에이전트는 사람이나 다른 사물의 직접적인 간섭 없이 스스로 판단하여 동작하고, 그들의 행동이나 내부 상태에 대한 어떤 종류의 제어를 갖음.

• 사회성.

에이전트는 에이전트 통신 언어를 사용하여 사람과 다른 에이전트들과 상호작용할 수 있음.

• 반응성.

에이전트는 실세계, 그래픽사용자 인터페이스를 경유한 사용자, 다른 에이전트들의 집합, 인터넷 같은 환경을 인지하고 그 안에서 일어나는 변화에 시간상 적절히 반응함.

• 능동성.

에이전트는 단순히 환경에 반응하여 행동하는 것이 아니라 주도권을 가지고 목표 지향적으로 행동함.

• 시간연속성.

에이전트는 단순히 한번 주어진 입력을 처리하여 결과를 보여주고 종료하는 것이 아니라, 전면에서 실행하고 이면에서 잠시 휴식하는 연속적으로 수행하는 데몬(demon)같은 프로세스.

• 목표지향성.

에이전트는 복잡한 고수준 작업들을 수행한다. 작업이 더 작은 세부 작업으로 나뉘고 처리순서가 결정되어 처리되는 등의 책임을 에이전트가 진다.

속성

• 이동성.

사용자가 요구한 작업을 현재의 컴퓨터에서 처리하지 않고 그 작업을 처리할 수 있는 다른 컴퓨터로 이동시켜 수행함으로써 효율을 높이고 네트워크 부하를 감소.

• 합리성.

에이전트가 목표를 달성하기 위해 행동하지 목표 달성을 방해하는 방향으로는 행동하지 않는다.

• 적응성.

에이전트는 사용자의 습관과 작업 방식 그리고 취향에 따라 스스로를 적응시킬 수 있다.

• 협동성.

에이전트는 다른 에이전트, 자원, 사람과도 복잡한 작업을 수행하기 위해 협력할 수 있다.

분류

• 학습에이전트.

학습 에이전트(learning agent)는 사용자가 웹상에서의 수행하는 행동을 관찰하고 어떤 내용에 관심을 가지고 있는지 판단하여 사용자에게 알맞은 내용을 전달하도록 하는 것을 말함.

• 인터페이스 에이전트.

현존하는 많은 컴퓨터 프로그램과 인터페이스는 명백하게 인간의 재능과 흥미를 표현하지만 인간과 컴퓨터 사이에는 아직도 대화능력이 부족하다. 사용자 인터페이스 에이전트(user interface agent)는 사용자의 원하는 작업을 찾아내서 이들을 네트워크나 응용 프로그램안 어디에서든지 실행할 수 있도록 이동시켜 준다. 사용자 인터페이스는 응용 프로그램의 성공에 있어 매우 중요하다. 이것은 사용자 요구의 자연적 모호성을 명확하게 해석하여 모호하지 않은 문장을 즉시 프로세스로 보낼 수 있어야 한다. 인터페이스는 또한 결과를 사용자에 의해 요구되고 이해되는 형태로 변환할 수 있어야 함.

• 데스크톱 에이전트.

데스크톱 에이전트(desktop agent)는 PC나 워크스테이션의 운영 체제에 상주하면서 국부적으로 실행되는 소프트웨어 에이전트이다. 데스크톱 에이전트는 운영 체제 에이전트, 응용 프로그램 에이전트, 응용 프로그램 환경 에이전트로 분류.

• 인터넷 에이전트.

인터넷 에이전트(internet agent)는 서버에 상주하면서 사용자와 직접적인 상호 작용없이 사용자를 대신해서 작업을 수행하도록 인터넷상에서 분산된 온라인 정보를 접근하는 컴퓨터 프로그램이다. 인터넷 에이전트는 정보제공자와 정보소비자 사이의 정보중개인으로 동작한다. 그런 정보 매개체로서 인터넷 에이전트는 사용자들의 정보 요구를 정보 공급자, 정보 형태, 정보 내용에 따라 중재해 준다.

• 전자상거래 에이전트.

현재의 상거래는 사람이 물건을 사고 파는 업무를 수행하는 거의 전적으로 사람에 의해 이루어지고 있다. 그러나 일부 상거래 과정을 살펴보면 상거래의 일부가 자동화되지 않을 이유가 없다. 상거래 과정의 일부는 에이전트가 대신하는 전자상거래 에이전트(electronic commerce agent)가 출현.

2. 전문가 시스템과 전통적인 프로그래밍과의 차이점은 무엇인가?

전문가 시스템이란?

전문지식의 특정영역에 대한 전문가의 지식을 요약하고 그 영역 안에서 지적인 판단을 내릴 수 있는 Software Package이다. 전문가시스템을 정의하는 다른 방법은, 이를 보통의 프로그램과 비교하는 것. 가장 기본적인 차이는, 보통의 프로그램이 data를 처리하는데 반하여 전문가시스템은 Knowledge를 처리하는 것.

일반 프로그램전문가 시스템데이터 표현하고 사용.지식을 표현하고 사용.알고리즘을 사용.휴리스틱을 사용.반복적인 처리.추론적인 처리.데이터베이스를 처리.지식 베이스.

전문가시스템의 특징

1. 전문지식을 취급함.

따라서 관련 분야의 전문가와 같은 정도의 성과를 발휘해야 하며 또한 빠르게 좋은 해를 찾아내기 위해 효율적으로 구성되어야 한다. 또한 인간과 같이 넓고 깊은 지식을 제공할 수 있어야 한다.실제에 있어서는 관련분야에 2년 정도 종사한 전문가의 지식구현에 만족하는 경향이며 또한 정확한 해를 구하기 위하여 문제를 축소 시켜 좁은 부분에서 정확한 해를 추구하는 경향

1. 심볼에 의한 추론을 행함.

전문가뿐 아니라 전문가시스템의 User들은 인간이기 때문에 인간과의Interactive한 지식교환을 하려면 인간의 애매한 표현들을 정량화하여 전문가 시스템에 구현하여 불확실성을 줄여 나가야 한다. 이러한 심볼 표현에 의한 불확실성은 Certainty Factor나 Fuzzy 이론으로써 구현하게 된다.

1. 휴리스틱을 이용.

“휴리스틱”의 의미는 “자기 힘으로 알아내는 자기 발견적인”의 의미이다. 따라서 항상 옳은 것은 아니지만 대부분의 경우에 옳은 정보를 제공한다. Graph Search 과정에서의 넓이우선,깊이우선 탐색은 목표의 위치에 무관한 Blind Search 이다. 그러나 휴리스틱 Search는 가장 가능성이 있는 목표의 위치에 대하여 탐색을 행하여 불필요한 자원낭비를 줄이게 된다. 이때 가장 가능성이 있는 위치를 찾아내기 위하여 전문가의 경험에 의한 규칙(Rules of Thumb)을 이용하거나 또는 각 단계에서의 바람직한 정도를 평가하기 위한 척도로써 Evaluation Function을 사용하기도 한다.

1. 자기지식을 사용.

이는 시스템이 갖는 자신의 사고에 관한 지식을 말한다. 이는 지식에 대한 지식을 의미한다. “이순신 장군의 신발은 몇 문인가”하는 질문에 대하여 인간은 쉽게 “모른다”는 답을 하지만 컴퓨터는 자기의 지식을 모두 검색한 후에야 답을 얻는다.그러나 전문가시스템은 Rule로써 문제의 성격을 파악하여 결론의 정확성,일관성,가능성들을 검토하여 추론한다. 이를 위해서 explanation facility를 가지게 되며 Why (왜 전문가시스템이 그런 질문을 하는가를 보여준다), How (어떻게 해서 전문가시스템이 그런 결론을 내렸는가를 보여준다) 등의 자문에 응하게 된다.

기존의 program과 expert System의 다른 점

특징conventional programexpert system제어 (control by…)statement orderinference enginecontrol and dataimplicit integrationexplicit separationcontrol strengthstrongweaksolution by..algorithmrules and inferencesolution searchsmall or nonelargeproblem solvingalgorithm is correctrulesinputassumed correctincomplete, incorrectunexpected inputdifficult to deal withvery responsiveoutputalways correctvaries with problemexplanationnoneusuallyapplicationsnumeric, file, and textsymbolic reasoningexecutiongenerally sequentialopportunistic rulesprogram designstructured designlittle or no structuremodifiabilitydifficultreasonableexpansiondone in major jumpsincremental

3. 순방향 추론과 역방향 추론 과정을 예를 들어 설명해 보세요.

전제 추론의 정의.

문제의 해결책은 일반적으로 솔루션에 도달하기 위해 초기 데이터와 사실을 포함합니다. 이러한 알려지지 않은 사실과 정보는 결과를 추론하는 데 사용됩니다. 예를 들어, 환자를 진단하는 동안 의사는 먼저 온도, 혈압, 맥박, 눈 색깔, 혈액 등과 같은 신체의 증상과 의학적 상태를 확인합니다. 그 후, 환자의 증상을 분석하고 미리 결정된 증상과 비교합니다. 그러면 의사는 환자의 증상에 따라 약을 제공 할 수 있습니다. 따라서 솔루션에서 이러한 추론 방식을 사용하는 경우 정방향 추론이라고
합니다.

• 정방향 추론에서 수행되는 단계.

추론 엔진은 우선 순위가 주어진 현재 상태와 일치하는 제약 조건에 대해 제공된 정보를 사용하여 지식 기반을 탐색합니다.

• 첫 번째 단계에서는 시스템에 하나 이상의 제약 조건이 부여됩니다.
• 그런 다음 각 제약 조건에 대한 지식 기반에서 규칙을 검색합니다. 조건을 충족시키는 규칙이 선택됩니다 (즉, IF 부분).
• 이제 각 규칙은 호출 된 규칙의 결론에서 새로운 조건을 생성 할 수 있습니다. 결과적으로 THEN 부분은 기존 부분에 다시 포함됩니다.
• 추가 된 조건은 2 단계를 반복하여 다시 처리됩니다. 새 조건이없는 경우 프로세스가 종료됩니다.

역 추론의 정의

역방향 추론
은 규칙, 초기 사실 및 데이터를 추론하기 위해 목표가 분석되는 순방향 추론의 역입니다. 의사는 증상과 같은 잘못된 데이터의 도움을 받아 환자를 진단하려고하는 위의 정의에서 주어진 비슷한 예를 통해 개념을 이해할 수 있습니다. 그러나이 경우 환자는 자신의 신체에 문제가있어 의사가 증상을 증명할 수 있습니다. 이러한 종류의 추론은 역 추론 하에서 이루어진다.

역방향 추론에서 따르는 단계

이러한 유형의 추론에서 시스템은 목표 상태와 이유를 역방향으로 선택합니다. 자, 어떻게 그것이 일어나고 어떤 단계가 뒤따른 지 이해합시다.

• 첫째, 목표 상태와 규칙은 목표 상태가 THEN 부분에있는 경우 결론으로 선택됩니다.
• 선택된 규칙의 IF 부분에서 목표 상태가 참이되도록 부 대상이 만족되도록 만들어집니다.
• 모든 부 목적을 만족시키는 데 중요한 초기 조건을 설정하십시오.
• 제공된 초기 상태가 설정된 상태와 일치하는지 확인하십시오. 조건을 충족하면 목표는 다른 목표 상태가 선택되는 솔루션입니다.

인공지능의 전후 추론의 주요 차이점

1. 순방향 추론은 데이터 중심 접근 방식이며 역방향 추론은 목표 기반입니다.
2. 프로세스는 순방향 추론에서 새로운 데이터와 사실로 시작합니다. 반대로, 역 추론은 결과로 시작됩니다.
3. 순방향 추론은 결과를 결정하고 일부 시퀀스가 뒤 따르는 것을 목표로합니다. 반면에, 결론을 뒷받침하는 행위에 대한 역 추론 강조.
4. 앞으로의 추론은 다른 결과를 가져올 수 있으므로 기회 주의적 접근 방식입니다. 반대로 후진 적 추론에서 특정 목표는 제한된 특정 초기 데이터 만 가질 수 있습니다.
5. 앞으로 추론의 흐름은 선행에서 추론으로 이어지는 반면, 후진 추론은 결론에서 시작으로 시작하는 역순으로 작용합니다.

예시.

⇒ 대전제 : 모든사람은 죽는다.

⇒ 소전제 : 소크라테스는 사람이다.

⇒ 결 론 : 소크라테스는 죽는다.

4. 자율주행 자동차에 필요할 것 같은 규칙을 만들어 보자

⇒ 필요한 규칙

• 부분 자율주행시스템은 다음 조건을 모두 만족하는 경우에만 작동 할 것
• 운전자가 부분 자율주행시스템을 의도적으로 작동시키는 행위가 있을 것
• 운전자가 운전석에 있고, 안전띠를 착용하고 있을 것
• 운전자가 운전전환 준비상태가 된 것을 감지할 것
• 운행에 필요한 모든 기능이 정상적으로 작동되고 있을 것
• 자동차가 주행하는 도로는 다음의 조건을 갖추고 있을 것
• 보행자와 자전거탑승자의 통행이 금지되는 도로일 것
• 중앙분리대 등 반대방향으로 이동하는 교통수단을 물리적으로 분리하는 시설을 갖춘 도로일 ML것
• 운행가능영역 내에 있을 것
• 시동 후 제작자가 정한 감지거리 이상의 거리에서 최소 한 번 이상 물체를 감지할 것
• 자율주행정보 기록장치가 정상적으로 작동하고 있을 것

등이 필요할 것이다.

머신러닝의 종류.

• Training : 학습에 사용됨
• Verification data : 학습되는 모델을 검증 하는데 사용됨
• Test data : 학습된 모델의 성능을 실제로 평가하기 위해서 사용됨

머신러닝은 4가지 종류로 분류됨.

• Supervised learning
• Unsupervised learning
• semi-supervised learning
• Reinforcement learning

Supervised learning.

• labeled data로 학습 수행
• 라벨이 붙어있는 학습 데이터의 예

• 입력과 출력 사이의 관계를 학습하고, 이 관계가 규칙 또는 함수로 표현되는 모델을 찾음
• 가장 일반적인 문제 유형
• image labeling : tagged images로부터 학습
• Email spam filter: labeled (spam or ham) 이메일로부터 학습
• 시험 점수 예측 : 이전의 시험 성적과 공부한 시간을 학습

Unsupervised learning

• Unlabeled data로 학습.
• 어떤 데이터는 라벨을 일일이 할당할 수 없음
• Google news grouping
• 자동적으로 유사한 뉴스를 그룹핑함
• 유사한 단어를 수집하는 Word clustering
• 일일이 데이터에 라벨을 부여하기가 어려움
• 데이터를 보고 스스로 학습을 수행

반지도학습.(semi-supervised learning.)

• 지도 학습과 비지도 학습의 중간에 위치함
• 입력과 출력 정보가 있는 학습데이터와 입력만 있고 출력 정보가 없는 학습데이터를 함꼐 사용함
• 입력과 출력정보가 함께 있는 학습데이터가 적은 상황에서 분류나 회귀 모델 개발시
• 출력 정보가 없는 입력데이터의 분포 특성 정보를 활용하여 성능 개선

강화학습(reinforcement learning.)

• 특정 환경에서 행동과 이에 대한 보상의 경험을 통해서 보상이 최대가 되도록 상황별로 취할 행동을 결정하는 방법
• 게임, 제어문제, 금융공학 등에서 행동 전략이나 정책을 결정할 때 사용함

supervised Learning의 수행단계

• step 1 : Training data set과 ML 모델이 주어짐
• step 2 : Label이 주어진 training data set을 학습시킴
• step 3 : 학습을 통해 ML 모델이 생성됨
• 모델의 파라미터가 학습을 통해 결정됨
• step 4 : 생성된 ML 모델에 x_test라는 값을 입력하여 y의 값을 물어봄
• step 5 : 생성된 ML 모델은 x_test에 대한 y의 값은 3이라고 알려줌

감독학습의 종류.

• Regression
  • 출력이 연속적인 영역 안의 값을 결정하는 분야
  • Linear regression과 nonlinear regression으로 분류됨
  • 공부한 시간을 기반으로 0점에서 100점 사이의 시험 성적을 예측하는 시스템
• Classification
  • 데이터들을 정해진 몇 개의 class로 대응시키는 문제
• Binary classification
  • 데이터를 2가지 class로 분류함
  • 공부한 시간을 기준으로 성적이 pass했는지 non-pass 했는지를 예측하는 시스템
• Multi-label classification
  • 데이터를 여러 가지 class로 분류함
  • 공부한 시간을 기반으로 성적이 A,B,C,D,F 이지를 예측하는 시스템

신경망

• 인간 두뇌의 생리적 활동에 대한 계산적 모델을 통해 인공지능을 구현하려는 분야
• 인간의 궁극적인 꿈 : 생각하는 기계 만들기
• 생물학적인 뉴런의 구성도
• 여러 개의 Signals 들이 입력되어서 cell nucleus에서 합해짐
• 합쳐진 시그널들이 일정한 값 이상이 될 때에는 활성화가 되어서 다음 뉴런에 전달됨

Biological neuron 동작 원리를 흉내냄

• 인공적인 뉴런을 만듦
• 인공적인 뉴럴 네트워크
• 인공적인 뉴런을 여러 개 결합한 것

perceptron

• 입력 노드와 출력 노드로 구성된 ANN
• Frank Rosenblatte 박사에 의해 고안됨

Multi-layer perceptron (MLP)

• input layer 및 output layer와 함께 hidden layer가 존재함
• Marvin Minsky 교수에 의해 고안됨

Deep neural network (DNN)

• 은닉층이 2개 이상인 MLP를 의미

딥러닝(deep learning.)

• Deep NN을 사용해 만든 모든 알고리즘

딥러닝의 종류.

• Convolutional neural network (CNN)
• Recurrent Neural network(RNN)
• Restricted Boltzmann Machine (RBM)
• Deep Belief Network (DBN)
• Generative Adversarial Network (GAN)
• Relation Networks (RN)

Convolutional neural network (CNN)

• 특징맵을 생성하는 필터까지도 학습이 가능해 비전(vision)분야에서 성능이 우수함

Recurrent Neural network (RNN)

• 음성과 같은 Time-series data의 처리에 적합함

필요한 개발 툴.

• IDE : jupyter Notebook
• Python
• Numpy : 강력한 계산 기능 수행
• Matplotlib : 분석된 데이터의 시각화
• Scikit-Learn : Python의 ML package
• TensorFlow
• 머신러닝을 위해 구글에서 만들어짐
• data flows를 사용해서 수치 계산을 위한 open-source software library for
• 최근에 머신러닝 라이브러리로 가장 많이 사용 되고 있음

머신러닝으로 암 데이터 예측.

• 특징 데이터
• Age와 tumor_size
• Label 데이터
• 0(암), 1(정상)
• 학습 모델
• Multi-variable linear
• regression model
• ML library
• Scikit-learn 사용함

import matplotlib.pyplot as plt
import numpy as np
import numpy.random as npr
from sklearn import datasets, linear_model
from sklearn.metrics import mean_squared_error, r2_score

datum = np.genfromtxt('../Desktop/data/cancer_data.csv',delimiter = ',', dtype = np.float32, skip_header = True)
# except header.
datum = datum[1:,:]
#shuffle.
npr.shuffle(datum)
X = datum[:, :2]
Y = datum[:, 2]
train_x = X[:60]
test_x = X[60:80]
val_x = X[80:]
train_y = Y[:60]
test_y = Y[60:80]
val_y = Y[80:]
regr = linear_model.LinearRegression()
regr.fit(train_x, train_y)
test_preds = regr.predict(test_x)
fig = plt.figure()
ax = fig.add_subplot(2,2,1)
ax.set_xlim(0, 10)
ax.set_ylim(0, 10)
ax.set_title('Pred')
test_preds = [0 if pred <= 0.5 else 1 for pred in test_preds]
pred_colors = ['b' if pred == 0 else 'r' for pred in test_preds]
ax.scatter(test_x[:,0], test_x[:,1], color = pred_colors, linewidth = 3)
ax = fig.add_subplot(2,2,2)
ax.set_xlim(0, 10)
ax.set_ylim(0, 10)
ax.set_title('True')
y_colors = ['b' if y == 0 else 'r' for y in test_y]
ax.scatter(test_x[:,0], test_x[:,1], color = y_colors, linewidth = 3)
plt.show()