# ---
# jupyter:
#   jupytext:
#     text_representation:
#       extension: .py
#       format_name: light
#       format_version: '1.5'
#       jupytext_version: 1.14.4
#   kernelspec:
#     display_name: Python 3
#     language: python
#     name: python3
# ---

# +
#예제 7-3 다중 회귀분석
# -*- coding: utf-8 -*-

#기본 라이브러리 불러오기
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

'''
Step.1~3 데이터 준비
'''

#csv 파일을 데이터 프레임으로 변환
df = pd.read_csv('./auto-mpg.csv', header=None)

#열 이름 지정
df.columns =['mpg','cylinders','displacement','horsepower', 'weight', 'acceleration', 'model year', 'origin', 'name']

#horsepower 열의 자료형 변경(문자열 -> 숫자)
df['horsepower'].replace('?', np.nan, inplace=True)
df.dropna(subset=['horsepower'], axis=0, inplace=True) #누락 데이터 행 삭제
df['horsepower'] = df['horsepower'].astype('float') #문자열을 실수형으로 변환

#분석에 활용할 열(속성) 선택(연비, 실린더, 출력, 중량)
ndf = df[['mpg', 'cylinders', 'horsepower', 'weight']]

'''
Step.4 데이터셋 구분- 훈련용(train data)/검증용(test data)
'''

#속성(변수) 선택
X=ndf[['cylinders', 'horsepower', 'weight']] #독립변수 X1, X2, X3
y=ndf['mpg'] #종속변수 y

#train data와 test data로 구분(7:3 비율)
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=10)

print('훈련 데이터: ', X_train.shape)
print('검증 데이터: ', X_test.shape)

# +
'''
Step.5 단순회귀분석 모형
'''

#sklearn 라이브러리에서 선형회귀분석 모듈 가져오기
from sklearn.linear_model import LinearRegression

#단순회귀분석 모형 객체 생성
lr = LinearRegression()

#train data를 가지고 모형 학습
lr.fit(X_train, y_train)

#학습을 마친 모형에 test data를 적용하여 결정계수(R-제곱) 계산
r_square = lr.score(X_test, y_test)
print(r_square)
print('\n')

#회귀식의 기울기
print('X 변수의 계수 a:', lr.coef_)
print('\n')

#회귀식의 y절편
print('상수항 b', lr.intercept_)

# +
#train data의 산점도와 test data로 예측한 회귀선을 그래프로 출력
y_hat = lr.predict(X_test)

plt.figure(figsize =(10,5))
ax1 = sns.distplot(y_test, hist=False, label="y_test")
ax2 = sns.distplot(y_hat, hist=False, label="y_hat",ax=ax1)
plt.show()
plt.close()

# +
#KNN 분류 알고리즘
#k-nearest-neighbors

# -*-coding: utf-8 -*-
#기본 라이브러리 불러오기

import pandas as pd
import seaborn as sns

'''
Step.1 데이터 준비 - seaborn에서 제공하는 titanic 데이터셋 가지오기
'''

#load_dataset 함수를 사용하여 데이터프레임으로 변환
df = sns.load_dataset('titanic')

#데이터 살펴보기
print(df.head())
print('\n')

#IPython 디스플레이 설정 - 출력할 열의 개수 한도 늘리기
pd.set_option('display.max_columns', 15)
print(df.head())
# -

df.info()

df.describe()

# +
'''
Step.2 데이터 탐색/ 전처리
'''

#데이터 자료형 확인
print(df.info())
# -

#NaN 값이 많은 deck 열 삭제, embarked와 내용이 겹치는 embark_town 열 삭제
rdf = df.drop(['deck', 'embark_town'], axis=1)
print(rdf.columns.values)

#age열에 나이 데이터가 없는 모든 행 삭제- age 열 (891개 중 177개의 NaN값)
rdf = rdf.dropna(subset=['age'], how='any', axis=0)
print(len(rdf))

# +
#embarked 열의 NaN 값을 승선도시 중에서 가장 많이 출현한 값으로 치환하기
most_freq = rdf['embarked'].value_counts(dropna=True).idxmax()
print(most_freq)
print('\n')

print(rdf.describe(include='all'))
print('\n')

rdf['embarked'].fillna(most_freq, inplace=True)

# +
'''
Step.3 분석에 사용할 속성 선택
'''

#분석에 사용할 열(속성) 선택
ndf = rdf[['survived', 'pclass', 'sex', 'age', 'sibsp', 'parch', 'embarked']]
print(ndf.head())

# +
#원핫인코딩 - 범주형 데이터를 모형이 인식할 수 있도록 숫자형으로 변환
onehot_sex = pd.get_dummies(ndf['sex'])
ndf = pd.concat([ndf, onehot_sex], axis=1)

onehot_embarked = pd.get_dummies(ndf['embarked'], prefix='town')
ndf = pd.concat([ndf, onehot_embarked], axis=1)
print(ndf.head())
print()
ndf.drop(['sex', 'embarked'], axis=1, inplace=True)
print(ndf.head())
# -

ndf

# +
'''
Step.4 데이터셋 구분- 훈련용 train dat/ 검증용 test data
'''

#속성(변수) 선택
X = ndf[['pclass', 'age', 'sibsp', 'parch', 'female', 'male',
        'town_C', 'town_Q', 'town_S']] #설병변수 X
y = ndf['survived']                    #예측변수 y

#설명 변수 데이터를 정규화(normalization)
from sklearn import preprocessing
X = preprocessing.StandardScaler().fit(X).transform(X)

#train data와 test data 로 구분(7:3 비율)
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=10)

print('train data 개수: ', X_train.shape)
print('test data 개수: ', X_test.shape)

# +
'''
Step.5 KNN분류 모형 - sklearn 사용
'''

#sklearn 라이브러리에서 KNN 분류 모형 가져오기
from sklearn.neighbors import KNeighborsClassifier

#모형 객체 생성(k=5로 설정)
knn = KNeighborsClassifier(n_neighbors=5)

#train data를 가지고 모형 학습
knn.fit(X_train, y_train)

#test data를 가지고 y_hat을 예측(분류)
y_hat = knn.predict(X_test)

print(y_hat[0:10])
print(y_test.values[0:10])
# -

#모형 성능 평가 - Confusion Matrix 계산
from sklearn import metrics
knn_matrix = metrics.confusion_matrix(y_test,y_hat)
print(knn_matrix)

#모형 성능 평가 - 평가 지표 계산
knn_report = metrics.classification_report(y_test, y_hat)
print(knn_report)

# +
#예제 7-5 SVM 모형

# -*- coding: utf-8 -*-

#기본 라이브러리 불러오기
import pandas as pd
import seaborn as sns

'''
Step.1 데이터 준비/ 기본 설정
'''

#load_dataset 함수를 사용하여 데이터 프레임으로 변환

df = sns.load_dataset('titanic')

#IPython 디스플레이 설정 - 출력할 열의 개수 한도 늘리기
pd.set_option('display.max_columns', 15)

'''
Step.2 데이터 탐색/ 전처리
'''

#NaN 값이 많은 deck 열 삭제, embarked와 내용이 겹치는 embark_town 열 삭제
rdf = df.drop(['deck', 'embark_town'], axis=1)

#age 열에 나이 데이터가 없는 모든 행 삭제 -age 열 (891개 중 177개의 NaN값)
rdf = rdf.dropna(subset=['age'],how='any', axis=0)

#embarked 열의 NaN 값을 승선도시 중에서 가장 많이 출현한 값으로 치환하기
most_freq = rdf['embarked'].value_counts(dropna=True).idxmax()
rdf['embarked'].fillna(most_freq, inplace=True)

'''
Step.3 분석에 사용할 속성 선택
'''

#분석에 활용할 열(속성) 선택
ndf = rdf[['survived', 'pclass', 'sex', 'age', 'sibsp', 'parch', 'embarked']]

#원핫인코딩 - 범주형 데이터를 모형이 인식할 수 있도록 숫자형으로 변환
onehot_sex = pd.get_dummies(ndf['sex'])
ndf = pd.concat([ndf, onehot_sex], axis =1)

onehot_embarked = pd.get_dummies(ndf['embarked'], prefix='town')
ndf = pd.concat([ndf, onehot_embarked], axis=1)

ndf.drop(['sex', 'embarked'], axis=1, inplace=True)

'''
Step.4 데이터셋 구분 - 훈련용 train data/ 검증용 test data
'''

#속성(변수) 선택
X = ndf[['pclass', 'age', 'sibsp', 'parch', 'female', 'male',
         'town_C', 'town_Q', 'town_S']]    #독립변수 X
y = ndf['survived']                        #종속변수 y
# -

X

#설명 변수 데이터를 정규화(normalization)
from sklearn import preprocessing
X = preprocessing.StandardScaler().fit(X).transform(X)

X

# +
#train data와 test data로 구분(7:3 비율)
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=10)

print('train data 개수: ', X_train.shape)
print('test data 개수: ', X_test.shape)

# +
'''
Step.5 SVM 분류 모형 -sklearn 사용
'''

#sklearn 라이브러리에서 SVM 분류 모형 가져오기
from sklearn import svm

#모형 객체 생성(kernel='rbf' 적용)
svm_model = svm.SVC(kernel='rbf')


#train data를 가지고 모형 학습
svm_model.fit(X_train, y_train)

#test data 를 가지고 y_hat 예측(분류)
y_hat = svm_model.predict(X_test)

print(y_hat[0:10])
print(y_test.values[0:10])

# +
#모형 성능 평가 - Confusion Matrix 계산
from sklearn import metrics
svm_matrix = metrics.confusion_matrix(y_test,y_hat)

print(svm_matrix)
print('\n')

#모형 성능 평가 - 평가 지표 계산
svm_report = metrics.classification_report(y_test, y_hat)
print(svm_report)

# +
#예제 7-6 Decision Tree 모형

# -*- coding: utf-8 -*-
#기본 라이브러리 불러오기
import pandas as pd
import numpy as np

'''
Step.1 데이터준비/기본설정
'''

#Breast Cancer 데이터셋 가져오기(출처: UCI ML Repository)
uci_path = 'https://archive.ics.uci.edu/ml/machine-learning-databases/\
breast-cancer-wisconsin/breast-cancer-wisconsin.data'

df = pd.read_csv(uci_path, header=None)

# 열 이름 지정
df.columns = ['id','clump','cell_size','cell_shape', 'adhesion','epithlial',
              'bare_nuclei','chromatin','normal_nucleoli', 'mitoses', 'class'] 

#IPython 디스플레이 설정- 출력할 열의 개수 한도 늘리기
pd.set_option('display.max_columns', 15)

'''
Step.2 데이터 탐색
'''

#데이터 살펴보기
print(df.head())
print('\n')

#데이터 자료형 확인
print(df.info())
print('\n')

#데이터 통계 요약 정보 확인
print(df.describe())

# +
#bare_nuclei 열의 자료형 변경(문자열 -> 숫자)
print(df['bare_nuclei'].unique())                 #bare_nuclei 열의 고유값 확인
print('\n')

df['bare_nuclei'].replace('?', np.nan, inplace=True) #'?'를 np.nan으로 변경
df.dropna(subset=['bare_nuclei'], axis=0, inplace=True) #누락 데이터행 삭제
df['bare_nuclei'] = df['bare_nuclei'].astype('int')

print(df.describe())

# +
'''
Step.3 데이터셋 구분- 훈련용 train data/ 검증용 test data
'''

#속성(변수) 선택
X = df[['clump', 'cell_size', 'cell_shape', 'adhesion', 'epithlial',
       'bare_nuclei', 'chromatin', 'normal_nucleoli', 'mitoses']]              #설명 변수 X
y = df['class']                                                                #예측 변수 y

#설명 변수 데이터 정규화
from sklearn import preprocessing
X = preprocessing.StandardScaler().fit(X).transform(X)

#train data와 test data로 구분(7:3 비율) 
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=10)

print('train data 개수: ', X_train.shape)
print('test data 개수: ', X_test.shape)

# +
'''
Step.4 Decision Tree 분류 모형 sklearn 사용
'''

#sklearn 라이브러리에서 Decision Tree 분류 모형 가져오기
from sklearn import tree

#모형 객체 생성(criterion ='entropy' 적용)
tree_model = tree.DecisionTreeClassifier(criterion='entropy', max_depth=5)

#train data를 가지고 모형 학습
tree_model.fit(X_train, y_train)

#test data를 가지고 y_hat 예측(분류)
y_hat = tree_model.predict(X_test)    # 2:benign(양성), 4:malignant(악성)

print(y_hat[0:10])
print(y_test.values[0:10])

# +
#모형 성능 평가 - Confusion Matrix 계산
from sklearn import metrics
tree_matrix = metrics.confusion_matrix(y_test, y_hat)
print(tree_matrix)
print('\n')

#모형 성능 평가 - 평가 지표 계산
tree_report = metrics.classification_report(y_test, y_hat)
print(tree_report)

# +
#예제 7-7 k-means 군집 분석
#군집은 분류랑 비슷하지만 정답을 주지 않기 때문에 비지도 학습이다.
# -*- coding: utf-8 -*-

#기본 라이브러리 불러오기
import pandas as pd
import matplotlib.pyplot as plt

'''
Step.1 데이터 준비
'''

#Wholesale customers 데이터셋 가져오기(출처: UCI ML Repository)
uci_path = 'https://archive.ics.uci.edu/ml/machine-learning-databases/\
00292/Wholesale%20customers%20data.csv'
df= pd.read_csv(uci_path, header=0)

'''
Step.2 데이터 탐색
'''

#데이터 살펴보기
print(df.head())
print('\n')

#데이터 자료형 확인
print(df.info())
print('\n')

#데이터 통계 요약 정보 확인
print(df.describe())

# +
'''
Step.3 데이터 전처리
'''

#분석에 사용할 속성 선택
X=df.iloc[:,:]
print(X[:5])
print('\n')

#설명 변수 데이터 정규화
from sklearn import preprocessing
X = preprocessing.StandardScaler().fit(X).transform(X)

print(X[:5])

# +
'''
Step.4 k-means 군집 모형 -sklearn 사용
'''

#sklearn 라이브러리에서 cluster 군집 모형 가져오기
from sklearn import cluster

#모형 객체 생성
kmeans = cluster.KMeans(init='k-means++', n_clusters=5, n_init=10)

#모형 학습
kmeans.fit(X)

#예측(군집)
cluster_label = kmeans.labels_
print(cluster_label)
print('\n')

#예측 결과를 데이터프레임에 추가
df['Cluster'] = cluster_label
print(df.head())
# -

#그래프로 표현 - 시각화
df.plot(kind='scatter', x='Grocery', y='Frozen', c='Cluster', cmap='Set1',
       colorbar=False, figsize=(10,10))
df.plot(kind='scatter', x='Milk', y='Delicassen', c='Cluster', cmap='Set1',
       colorbar=True, figsize=(10,10))
plt.show()
plt.close()

# +
#큰 값으로 구성된 클러스터(0,4) 제외 - 값이 몰려 있는 구간을 자세히 분석
mask = (df['Cluster'] == 0) | (df['Cluster'] == 4)
ndf = df[~mask]

ndf.plot(kind='scatter', x='Grocery', y='Frozen', c='Cluster', cmap='Set1',
        colorbar=False, figsize=(10,10))
ndf.plot(kind='scatter', x='Milk', y='Delicassen', c='Cluster', cmap = 'Set1',
        colorbar=True, figsize=(10,10))

# +
#예제 7-8 DBSCAN 군집 분석
# -*- coding: utf-8 -*-

#기본 라이브러리 불러오기
import pandas as pd
import folium

'''
Step.1 데이터 준비/ 기본 설정
'''

#서울 시내 중학교 진학률 데이터셋
file_path = './2016_middle_school_graduates_report.xlsx'

df = pd.read_excel(file_path, header=0 ,index_col= 0)

#Ipython console 디스플레이 옵션 설정하기
pd.set_option('display.width', None) #출력 화면의 너비
pd.set_option('display.max_rows',100) #출력할 행의 개수 한도
pd.set_option('display.max_columns', 10) #출력할 열의 개수 한도
pd.set_option('display.max_colwidth', 20) #출력할 열의 너비
pd.set_option('display.unicode.east_asian_width', True) #유니코드 사용 너비 조정

#열 이름 배열 출력
print(df.columns.values)
df

# +
'''
Step.2 데이터 탐색
'''

#데이터 살펴보기
print(df.head())
print('\n')

#데이터 자료형 확인
print(df.info())
print('\n')

#데이터 통계 요약 정보 확인
print(df.describe())

# +
#예제 7-8 DBSCAN 군집 분석

#지도에 위치 표시
mschool_map = folium.Map(location=[37.55, 126.98], tiles='Stamen Terrain',
                        zoom_start=12)

#중학교 위치 정보를 CircleMarker로 표시
for name, lat, lng in zip (df.학교명, df.위도, df.경도):
    folium.CircleMarker([lat, lng],
                        radius = 5, #원의 반지름
                        color='brown', #원의 둘레 색상
                        fill = True,
                        fill_color='coral', #원을 채우는색
                        fill_opacity=0.7, #투명도
                        popup=name
                       ).add_to(mschool_map)
    
#지도를 html 파일로 저장하기
mschool_map.save('./seoul_mschool_location.html')

# +
'''
Step.3 데이터 전처리
'''

#원핫인코딩(더미변수)
from sklearn import preprocessing

label_encoder = preprocessing.LabelEncoder() #label encoder 생성
onehot_encoder = preprocessing.OneHotEncoder() #one hot encoder 생성

onehot_location = label_encoder.fit_transform(df['지역'])
onehot_code = label_encoder.fit_transform(df['코드'])
onehot_type = label_encoder.fit_transform(df['유형'])
onehot_day = label_encoder.fit_transform(df['주야'])

df['location'] = onehot_location
df['code'] = onehot_code
df['type'] = onehot_type
df['day'] = onehot_day

print(df.head())

# +
'''
Step.4 DBSCAN 군집 모형 -sklearn 사용
'''

#sklearn 라이브러리에서 cluster 군집 모형 가져오기
from sklearn import cluster

#분석에 사용할 속성 선택(과학고, 외고국제고, 자사고 진학율)
columns_list = [9, 10, 13]
X = df.iloc[:,columns_list]
print(X[:5])
print('\n')

#설명 변수 데이터 정규화
X = preprocessing.StandardScaler().fit(X).transform(X)

#DBSCAN 모형 객체 생성
dbm = cluster.DBSCAN(eps=0.2, min_samples=5)

#모형 학습
dbm.fit(X)

#예측(군집)
cluster_label = dbm.labels_
print(cluster_label)
print('\n')

#예측 결과를 데이터프레임에 추가
df['Cluster'] = cluster_label
print(df.head())

# +
#클러스터 값으로 그룹화하고 그룹별로 내용 출력(첫 5행만 출력)
grouped_cols = [0,1,3] + columns_list
grouped = df.groupby('Cluster')
for key, group in grouped:
    print('* key: ', key)
    print('* number: ',len(group))
    print(group.iloc[:,grouped_cols].head())
    print('\n')
    
#그래프로 표현 - 시각화
colors ={-1:'gray', 0:'coral', 1:'blue', 2:'green', 3:'red', 4:'purple', 
          5:'orange', 6:'brown', 7:'brick', 8:'yellow', 9:'magenta', 10:'cyan'}
cluster_map = folium.Map(location=[37.55,126.98], tiles='Stamen Terrain',
                        zoom_start=12)

for name, lat, lng, clus in zip(df.학교명, df.위도, df.경도, df.Cluster):
    folium.CircleMarker([lat,lng],
                       radius=5,
                       color=colors[clus],
                       fill=True,
                       fill_color=colors[clus],
                       fill_opacity=0.7,
                       popup=name).add_to(cluster_map)
#지도를 html 파일로 저장하기
cluster_map.save('./seoul_mschool_cluster.html')

# +
#X2 데이터셋에 대하여 위의 과정을 반복(과학고, 외고국제고, 자사고 진학률 + 유형)
columns_list2 = [9,10,13,22]
X2 = df.iloc[:,columns_list2]
print(X2[:5])
print('\n')

X2 = preprocessing.StandardScaler().fit(X2).transform(X2)
dbm2 = cluster.DBSCAN(eps=0.2, min_samples=5)
dbm2.fit(X2)
df['Cluster2'] = dbm2.labels_

grouped2_cols = [0,1,3] + columns_list2
grouped2 = df.groupby('Cluster2')
for key, group in grouped2:
    print('*key :',key)
    print('*number :',len(group))
    print(group.iloc[:,grouped2_cols].head())
    print('\n')
    
cluster2_map = folium.Map(location=[37.55, 126.98], titles='Stamen Terrain', zoom_start=12)

for name, lat, lng, clus in zip(df.학교명, df.위도, df.경도, df.Cluster2):
    folium.CircleMarker([lat, lng],
                       radius=5,
                       color=colors[clus],
                       fill=True,
                       fill_color=colors[clus],
                       fill_opacity=0.7,
                        popup=name).add_to(cluster2_map)
#지도를 html 파일로 저장하기
cluster2_map.save('./seoul_mschool_cluster2.html')

# +
# X3 데이터셋에 대하여 위의 과정을 반복(과학고, 외고_국제고)
columns_list3=[9,10]
X3 = df.iloc[:,columns_list3]
print(X3[:5])
print('\n')

X3 = preprocessing.StandardScaler().fit(X3).transform(X3)
dbm3 = cluster.DBSCAN(eps=0.2, min_samples=5)
dbm3.fit(X3)
df['Cluster3'] = dbm3.labels_
grouped3_cols = [0,1,3]+columns_list3
grouped3 = df.groupby('Cluster3')
for key, group in grouped3:
    print('*key :',key)
    print('*number :', len(group))
    print(group.iloc[:,grouped3_cols].head())
    print('\n')

cluster3_map = folium.Map(location=[37.55, 126.98],tiles='Stamen Terrain', zoom_start=12)

for name, lat, lng, clus in zip(df.학교명, df.위도, df.경도, df.Cluster3):
    folium.CircleMarker([lat, lng],
                       radius=5,
                       color=colors[clus],
                       fill=True,
                       fill_color=colors[clus],
                       fill_opacity=0.7,
                       popup=name).add_to(cluster3_map)
#지도를 html 파일로 저장하기
cluster3_map.save('./seoul_mschool_cluster3.html')
# -



StarcoderdataJupyterScriptsDedupFiltered