1. 법정동별 인근 충전소 평균 거리 순위
2. 인근 급속 충전소 거리가 500m가 넘는 충전소 개수

충전소간 거리 구하기

우선 급속충전소 데이터만 뺀다

charger_fast_df = charger_dong_df[charger_dong_df['기종(대)'] == '급속'].reset_index(drop = True)
charger_fast_df.head(3)

좌표 데이터에서 자기 자신과 같은 좌표는 제외하고 가장 가까운 좌표를 찾는다.

# 충전소 좌표에 대한 중복값을 제거하여 charger_point 생성
charger_point2 = charger_fast_df[['위도', '경도']].drop_duplicates().reset_index(drop=True)

# 인근충전소위도, 인근충전소경도 컬럼을 charger_point에 추가하고 초기화
charger_point2['인근충전소위도'] = None
charger_point2['인근충전소경도'] = None

# NearestNeighbors 모델을 사용하여 가장 가까운 인근 충전소 찾기
X = charger_point2[['위도', '경도']]
nbrs = NearestNeighbors(n_neighbors=2, algorithm='ball_tree').fit(X)

# 가장 가까운 인근 충전소 찾아서 인근충전소위도, 인근충전소경도 컬럼에 할당
def find_nearest_neighbor(row):
    # 현재 충전소의 좌표를 제외한 가장 가까운 이웃의 인덱스 찾기
    distances, indices = nbrs.kneighbors([row[['위도', '경도']]])
    nearest_index = indices[0][1]  # 자기 자신을 제외한 가장 가까운 이웃의 인덱스
    nearest_row = charger_point2.iloc[nearest_index]
    # 자기 자신과 동일한 좌표를 가진 행이 있으면 두 번째로 가까운 이웃 선택
    while (nearest_row['위도'] == row['위도']) and (nearest_row['경도'] == row['경도']):
        nearest_index = (nearest_index + 1) % len(charger_point2)  # 인덱스를 순환하도록 수정
        nearest_row = charger_point2.iloc[nearest_index]
    row['인근충전소위도'] = nearest_row['위도']
    row['인근충전소경도'] = nearest_row['경도']
    return row

# 충전소 좌표별로 가장 가까운 인근 충전소를 찾아서 인근충전소위도, 인근충전소경도 컬럼에 할당
charger_fast_df[['인근충전소위도(급속)', '인근충전소경도(급속)']] = charger_fast_df[['위도', '경도']].apply(find_nearest_neighbor, axis=1)[['인근충전소위도', '인근충전소경도']]

찾은 좌표로 최단거리를 계산한다

#인근 충전소와의 거리 계산

# 위도와 경도 간의 직선 거리를 계산하는 함수
def haversine(lat1, lon1, lat2, lon2):
    R = 6371  # 지구의 반지름 (단위: km)
    dlat = np.radians(lat2 - lat1)
    dlon = np.radians(lon2 - lon1)
    a = np.sin(dlat / 2) * np.sin(dlat / 2) + np.cos(np.radians(lat1)) * np.cos(np.radians(lat2)) * np.sin(dlon / 2) * np.sin(dlon / 2)
    c = 2 * np.arctan2(np.sqrt(a), np.sqrt(1 - a))
    distance = R * c * 1000  # 미터 단위로 변환
    return distance

# 위도와 경도 간의 직선 거리를 계산하여 인근충전소거리 컬럼에 추가
charger_fast_df['인근충전소거리(급속)'] = charger_fast_df.apply(lambda row: haversine(row['위도'], row['경도'], row['인근충전소위도(급속)'], row['인근충전소경도(급속)']), axis=1)

언제쯤 코드를 스스로 쓸 수 있을가...

시각화 해보면 대충 이런 모습 그래도 대부분의 충전소가 반경 500m이내에는 위치해있다.

법정동별 인근 충전소 평균 거리 순위

bdong_nearly_charger_df = pd.DataFrame(charger_fast_df.groupby(['군구','법정동코드', '법정동명','법정동중심위도','법정동중심경도'])['인근충전소거리(급속)'].mean()).sort_values(by = '인근충전소거리(급속)', ascending=False)
bdong_nearly_charger_df.reset_index(inplace = True)
bdong_nearly_charger_df

지도시각화

시각화를 하려면 우선 법정동 구역을 지도에 표시해야한다. folium은 json파일을 쓰는데 법정동 경계 좌표 데이터가 json형식이 아무리 찾아도 없다.(행정동만 보임) 결국 수기로 변환해주었다.

• http://www.gisdeveloper.co.kr/?p=2332 이곳에서 읍면동 데이터를 받은 후 아래 사이트를 참고해서 json파일로 변환했다.
• https://park9eon.com/how-to-convert-to-korea-shp-geojson/

아래 코드부터 다시 시작, 깨지는 글자로 encoding 추가. 지도 경계데이터라 좌표가 무지 많다. 그래서 서울시 코드(11)만 불러와서 변수에 저장한다.

#법정동 경계 좌표 json파일 불러오기
# JSON 파일 경로
json_file_path = '/Users/sookyeong/Documents/내배캠/팀프로젝트/project5_final/emd (2).json'

# JSON 파일 열기
with open(json_file_path, 'r', encoding='utf-8') as f:
    geo_data = json.load(f)

# EMD_CD가 앞 두글자가 '11'인 데이터만 필터링
filtered_features = [feature for feature in geo_data['features'] if feature['properties']['EMD_CD'][:2] == '11']

# 필터링된 데이터로 새로운 GeoJSON 생성
filtered_geo_data = {
    'type': 'FeatureCollection',
    'features': filtered_features
}

웬걸 아무 생각없이 시각화하려고 해도 지도가 제대로 안뜬다. 좌표계가 wgs84가 아니었던 것. 27.xxx, 135.xxx이런식으로 변환해주기 위해 다시 작업

#wgs84 좌표계로 변환
import geopandas as gpd
import json

# GeoJSON 데이터를 GeoDataFrame으로 변환
gdf = gpd.GeoDataFrame.from_features(filtered_geo_data)

# 좌표계를 WGS84로 변환
gdf.crs = "EPSG:5179"

# 좌표계가 설정된 상태에서 다시 변환
gdf_wgs84 = gdf.to_crs(epsg=4326)

# GeoDataFrame을 GeoJSON 형식으로 변환
wgs84_geojson = gdf_wgs84.to_json()

# 필요한 경우 딕셔너리로 다시 변환
wgs84_geojson_dict = json.loads(wgs84_geojson)

wgs84_geojson_dict

변환해준 좌표를 사용해서 folium 시각화

import folium

# Folium 지도 객체 생성
m = folium.Map(location=[37.55, 126.98], zoom_start=11, tiles='cartodbpositron')

folium.Choropleth(
    geo_data=wgs84_geojson_dict,
    data=bdong_nearly_charger_df,
    columns=['법정동코드', '인근충전소거리(급속)'],
    fill_color='PuBu',
    key_on='feature.properties.EMD_CD',  # GeoJSON 데이터에서 특정 속성 값의 키를 지정합니다.
    highlight=True,
    fill_opacity=0.5,
    line_opacity=0.5,
    legend_name='급속충전소',
    nan_fill_color='none'
).add_to(m)

# Folium 지도 객체 출력
m

차충비, 인구밀도, 교통량등에도 지도를 사용할 수 있을 것 같다. 뭐하나 쉬운게 없는 ㅠ^ㅠ..

1. 법정동 중심점 좌표 구하기

이는 geopandas를 사용하는데, 우선 우리나라 최신 행정구역 shp파일을 받아둔다. 읍면동 데이터의 최신 버전을 다운로드 받았다. http://www.gisdeveloper.co.kr/?p=2332

2. 중심좌표 구하기

# 라이브러리 호출
import geopandas as gpd

# 서울시 법정동 경계 데이터 불러오기
dong_boundary = gpd.read_file('/Users/sookyeong/Documents/내배캠/팀프로젝트/project5_final/emd.shp', encoding='cp949')

파일을 불러오면 평소 사용하는 WGS84 좌표가 아니다. 우선 CSR로 EPSG:5179으로 변환해주어야 한다.

# CRS 설정
dong_boundary.crs = 'EPSG:5179'  

'EPSG:5179'는 GeoDataFrame의 좌표 참조 시스템(CRS)을 'EPSG:5179'로 설정하는 것을 의미한다.EPSG(European Petroleum Survey Group)는 좌표 참조 시스템에 대한 표준 데이터 세트를 관리하는 국제적인 조직입니다. 'EPSG:5179'는 대한민국 내에서 주로 사용되는 좌표 참조 시스템 중 하나라고 한다.

# 중심점 좌표 계산
dong_boundary['center_point'] = dong_boundary['geometry'].centroid

# 좌표를 WGS 84 좌표계로 변환
dong_boundary['geometry'] = dong_boundary['geometry'].to_crs(epsg=4326)
dong_boundary['center_point'] = dong_boundary['center_point'].to_crs(epsg=4326)

그 다음은 간단하다. 중심점을 찾고 그 지점을 WGS 84좌표로 변환해준다. center_point의 좌표를 위도, 경도 컬럼으로 분리하여주면 끝

전체코드

import geopandas as gpd
# 서울시 법정동 경계 데이터 불러오기
dong_boundary = gpd.read_file('/Users/sookyeong/Documents/내배캠/팀프로젝트/project5_final/emd.shp', encoding='cp949')

# CRS 설정
dong_boundary.crs = 'EPSG:5179'  

# 중심점 좌표 계산
dong_boundary['center_point'] = dong_boundary['geometry'].centroid

# 좌표를 WGS 84 좌표계로 변환
dong_boundary['geometry'] = dong_boundary['geometry'].to_crs(epsg=4326)
dong_boundary['center_point'] = dong_boundary['center_point'].to_crs(epsg=4326)

#위도, 경도 컬럼 생성
dong_boundary['위도'] = dong_boundary['center_point'].y
dong_boundary['경도'] = dong_boundary['center_point'].x

#필요한 컬럼 남기기
dong_boundary = dong_boundary.drop(columns = ['geometry', 'center_point'])

문제

정수를 저장한 배열, arr 에서 가장 작은 수를 제거한 배열을 리턴하는 함수, solution을 완성해주세요. 단, 리턴하려는 배열이 빈 배열인 경우엔 배열에 -1을 채워 리턴하세요. 예를들어 arr이 [4,3,2,1]인 경우는 [4,3,2]를 리턴 하고, [10]면 [-1]을 리턴 합니다.

👩🏻‍💻 my coding

• 리스트의 sort(), remove()
• 리스트의 메소드를 적용해 변수에 저장이 안된다.

  def solution(x) : 
    if len(x) > 1 : 
        x.sort(reverse = True)
        x.remove(x[-1])
        return x 
    elif len(x) <= 1 : 
        result = [-1]
        return result 

  테스트는 통과했는데 제출하니 오답이다. min을 쓰면 된다.

  def solution(arr):
    if len(arr) <= 1:
        return [-1]
    else:
        min_val = min(arr)
        arr.remove(min_val)
        return arr

  크기순으로 나열해서 remove하는것과 왜 다른지 잘 모르겠다. 해답을 찾아보니 정렬로 배열 순서를 바꾸면 안된다고 한다. 문제 조건에 들어가있으면 좋았을텐데 !

30. 가운데 글자 가져오기

문제

단어 s의 가운데 글자를 반환하는 함수, solution을 만들어 보세요. 단어의 길이가 짝수라면 가운데 두글자를 반환하면 됩니다.

👩🏻‍💻 my coding

• 나머지로 글자수 짝/홀 구하기
• 2로 나누어 가운데 글자 위치 뽑아내기

  def solution(x) : 
    a = int(len(x) / 2 - 0.5)
    if len(x) %2 == 0 : 
        return x[a:a+2]
    else : 
        return x[a]
  

````

1. 결측치 처리

결측치 삭제

✅ dropna

df.info() #결측치 확인
df.isna().sum() #결측치 확인

#결측치 그래프로 보기
import missingno as msno
msno.bar(df)

# 결측치 있는 행 삭제
df.dropna(axis=0)

#결측치 있는 열 학제
df.dropna(axis=0)

df.dropna(axis=0, how='any')  # 해당 행이나 열에 결측치가 하나라도 있다면 제거. (default)

df.dropna(axis=0, how='all')  # 해당 행이나 열의 '모든 값'이 결측치라면 제거.

df.dropna(axis=1, thresh=800)  # 결측치가 아닌 값이 thresh보다 적게 있을 때 제거. how와 함께 사용 불가.

df.dropna(axis=0, subset=['age'])  # 고려해야할 다른 축의 레이블 (ex. 행을 삭제하는 경우엔 열 지정.)

df.dropna(axis=0, ignore_index=True)  # True로 지정할 경우 결측치가 제거된 DataFrame의  index가 reset됨.

df.dropna(axis=0, ignore_index=True, inplace=True)  # True로 지정할 경우 해당 DataFrame 의 값이 변경됨.

결측치 대치

✅ fillna()

#결측치 0으로 채우기
new_df['age'] = new_df['age'].fillna(0)

#평균값으로 대체
new_df['age'] = new_df['age'].fillna(new_df['age'].mean())

#최빈값으로 대체
new_df['age'] = new_df['age'].fillna(new_df['age'].mode()[0])

✅ fowardfill, backwardfill

import yfinance as yf
import pandas as pd
df1 = yf.download( '005930.KS', '2023-03-01','2024-03-01')  # 종목코드(삼성전자), 시작일자, 종료일자
df2 = yf.download( '035420.KS', '2023-03-01','2024-03-01')   # 종목코드(네이버), 시작일자, 종료일자
df3 = yf.download( '035720.KS', '2023-03-01','2024-03-01')   # 종목코드(카카오), 시작일자, 종료일자

# 각 데이터프레임에서 'High'와 'Volume' 컬럼만 선택하고, 컬럼명 변경
df1_selected = df1[['High', 'Volume']].rename(columns={'High': 'High_samsung', 'Volume': 'Volume_samsung'})
df2_selected = df2[['High', 'Volume']].rename(columns={'High': 'High_naver', 'Volume': 'Volume_naver'})
df3_selected = df3[['High', 'Volume']].rename(columns={'High': 'High_kakao', 'Volume': 'Volume_kakao'})

# 인덱스를 기준으로 세 데이터 프레임 합치기
df_merged = pd.concat([df1_selected, df2_selected, df3_selected], axis=1)

#인덱스 설정
df_merged.index = pd.to_datetime(df_merged.index)

#연습을 위해 임의로 결측치 넣어줌
import numpy as np
np.random.seed(0)  # 재현 가능성을 위해 랜덤 시드 고정

# 모든 컬럼에 대해 10%의 값들을 랜덤으로 선택하여 NaN으로 설정
for column in df_merged.columns:
    # 결측치로 만들 인덱스를 랜덤 선택
    idxs = np.random.choice(df_merged.index, size=int(len(df_merged) * 0.3), replace=False)
    df_merged.loc[idxs, column] = np.nan

# np.random.choice(모집단, random으로 추출할 표본의 size, 복원추출여부(똑같은 값을 또 뽑을 수 있는지 여부))
np.random.choice(df_merged.index, size=int(len(df_merged) * 0.1), replace=False)

#결측치 확인
df_merged.isnull().sum()

✅ ffill(), bfill()

#결측치를 앞 방향으로 채우기(가장 최근의 비결측치로)
df_merged.ffill()
#결측치를 뒷 방향으로 채우기(해당 열에서 이후의 값으로 채우기)
df_merged.fillna(method='ffill')

✅ 보간법(interpolation)

#결측치를 선형으로 채움
plt.figure(figsize=(20,10))

plt.plot(df_merged['High_samsung'].interpolate(method='linear'))
plt.plot(df_merged['High_samsung'], marker='o')

# 결측치를 spline(곡선)으로 채움
# 더 과장될 수 있음
plt.figure(figsize=(20,10))
plt.plot(df_merged['High_samsung'].interpolate(method='spline', order=2))
plt.plot(df_merged['High_samsung'], marker='o')

2. 이상치 처리

#주식데이터 불러오기
import yfinance as yf

samsung_df = pd.DataFrame(yf.download('005930.KS', '2023-03-01','2024-03-01'))
naver_df = pd.DataFrame(yf.download('035420.KS', '2023-03-01','2024-03-01'))
kakao_df = pd.DataFrame(yf.download('035720.KS', '2023-03-01','2024-03-01'))


samsung_df = samsung_df[['High', 'Volume']].rename(columns = {'High' : 'High_samsung', 'Volume' : 'Volume_samsung'})
naver_df = naver_df[['High', 'Volume']].rename(columns = {'High' : 'High_naver', 'Volume' : 'Volume_naver'})
kakao_df = kakao_df[['High', 'Volume']].rename(columns = {'High' : 'High_kakao', 'Volume' : 'Volume_kakao'})

✅ z-score 기반 이상치 확인 naver_df['Valume_naver']열 이상치 확인

# 컬럼 선택
data = df_merged['Volume_naver']

# 평균과 표준편차 계산
mean = np.mean(data)
std_dev = np.std(data)

# 각 데이터 포인트에 대한 Z-score 계산
z_scores = [(x - mean) / std_dev for x in data]

# Z-score의 절댓값이 3 이상인 데이터 포인트를 이상치로 판별
outliers = [data[i] for i in range(len(z_scores)) if abs(z_scores[i]) > 3]

print("이상치:", outliers) # 이상치: [2725703, 3102468, 2561625, 3055268, 3013711]

#z-score 값 붙이기
merge_df['Volume_naver_z_score'] = z_scores

✅ boxplot 그래프

df = sns.load_dataset("titanic")
plt.boxplot(df['age'].dropna())
plt.xlabel('age')
plt.show()

✅ IQR

# 1사분위수(Q1)와 3사분위수(Q3) 계산
Q1 = df['age'].quantile(0.25)
Q3 = df['age'].quantile(0.75)

# IQR 계산
IQR = Q3 - Q1

# 하한과 상한 계산
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR

# 이상치 필터링
outliers = df[(df['age'] < lower_bound) | (df['age'] > upper_bound)]

print("이상치를 포함하는 행:\n")
outliers

타이타닉 데이터

• 불러오기

  import pandas as pd 
  import seaborn as sns
  

df = sns.load_dataset("titanic") df.head()

- T : 행과 열을 자리를 바꿈
```python
df.T

✅ sort_counts()

# column 별 값의 분포를 확인할 때 사용합니다.
df['who'].value_counts()

df['who'].value_counts(ascending=True)  # 오름차순정렬

df['who'].value_counts(normalize=True)  # 비율구하기 

df['age'].value_counts(bins=3, sort=False)  # 연속형 자료를 이산형 자료로 변환 후 개수 확인. 3개 구간으로 범주화. 
# '()'는 미포함, '[]'는 포함.

df['age'].value_counts(bins=[0, 20, 40, 60, 100], sort=False)  # 연속형 자료를 사용자 지정 구간으로 Binning 

✅ sort_values()

df.sort_values(by='age').head()

#오름차순 정렬
df.sort_values(by='age', ascending=False).head() 

#여러개 컬럼 정렬
df.sort_values(by=['fare', 'age'], ascending=[False, True]).head()

✅** indexing / slicing / 조건 필터링**

df.loc[0, 'class']  # indexing 예시

df.loc[2:5, 'class':'deck'].head()  # slicing 예시 (slicing은 [시작(포함): 끝(포함)])

df.loc[:6, 'class':'deck'] #6행까지 열 지정

✅ 조건필터링

# 조건1 정의
cond1 = (df['fare'] > 30)
# 조건2 정의
cond2 = (df['who'] == 'woman')
df.loc[cond1 & cond2] # 또는 -> |

✅ iloc : loc과 유사하지만 index만 허용

df.iloc[[0, 3, 4], [0, 1, 5, 6]]  # Fancy Indexing

df.iloc[:3, :5]  # Slicing

✅ isin : 포함여부

sample = pd.DataFrame({'name': ['kim', 'lee', 'park', 'choi'], 
                        'age': [24, 27, 34, 19]
                      })
condition = sample['name'].isin(['kim', 'lee'])  # loc를 활용한 조건 필터링으로도 찰떡궁합입니다.

sample.loc[condition]

연습문제

• tips 데이터셋 중 day가 금요일(Fri), 토요일(Sat) 만 필터링 합니다.
• tip이 $10보다 적게 낸 데이터만 필터링합니다.
• 컬럼은 total_bill, tip, smoker, time만 출력합니다.
• 상위 10개 행만 출력합니다.

  #풀이1
  con1 = tips['day'] == 'Fri'
  con2 = tips['day'] == 'Sat'
  con3 = tips['tip'] < 10 
  

tips[(con1 | con2)& con3][['total_bill', 'tip', 'smoker', 'time']].head(10)

#풀이2 con1 = tips['day'].isin(['Fri', 'Sat']) con2 = tips['tip'] < 10

tips.loc[con1&con2][['total_bill', 'tip', 'smoker', 'time']].head(10) ```

문제

프로그래머스 모바일은 개인정보 보호를 위해 고지서를 보낼 때 고객들의 전화번호의 일부를 가립니다. 전화번호가 문자열 phone_number로 주어졌을 때, 전화번호의 뒷 4자리를 제외한 나머지 숫자를 전부 *으로 가린 문자열을 리턴하는 함수, solution을 완성해주세요.

👩🏻‍💻 my coding

• 인덱스 슬라이싱 사용
• 문자 대체 'replace'

  def solution(phone_number) : 
    back = phone_number[-4:]
    front = phone_number[:-4]
    return phone_number.replace(front, '*'*len(front))

28. 없는 숫자 더하기

문제

0부터 9까지의 숫자 중 일부가 들어있는 정수 배열 numbers가 매개변수로 주어집니다. numbers에서 찾을 수 없는 0부터 9까지의 숫자를 모두 찾아 더한 수를 return 하도록 solution 함수를 완성해주세요.

👩🏻‍💻 my coding

• total을 먼저 정의하고
• total을 for문으로 반복하며 그 숫자가 numbers에 없는 수들의 합

  def solution(numbers) : 
    sum = 0
    total = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
    for i in total : 
        if i not in numbers : 
            sum  = sum + i 
    return sum
  

````

👩🏻‍💻 학습한 것

1. 불러오기 관련 ✅ nrows ✅ tsv 파일 불러오기 2. 불러올때 column 설정 ✅ header ✅ names ✅ index_col ✅ index.name ✅ parse_dates ✅ dtype 3. API활용하여 XML 데이터 파싱 4. 저장하기 ✅ to_csv(encoding, index=False, header = False) ✅ mode

1. pandas로 데이터 불러오기

• shape 행과 열의 갯수 표시

  df = pd.read_csv("week1_1.csv")
  display (df.head())
  print (df.shape) # (50, 6)

• nrows 데이터의 크기가 너무 커서 일부만 가져온 뒤 빠르게 데이터를 확인하고 싶을 때

  df = pd.read_csv("week1_1.csv", nrows=7)
  display (df.head())
  print (df.shape)

  

• sep 불러오는 파일의 구분자

• tsv파일? TSV 파일은 Tab Separated Values의 약자로, 데이터를 탭(tab) 문자로 구분하여 저장하는 텍스트 파일 형식. 쉼표로 구분되는 csv보다 가독성이 좋을 수 있다.

  df = pd.read_csv('/Users/sookyeong/Documents/내배캠/스탠다드B/week1_1.tsv', sep = '\t')
  df.head()

  

2. 데이터 불러오기 - COLUMN

• header = None 첫 행이 컬럼명이 아니고, 컬럼명 없이 데이터로만 이뤄져 있을 때. (데이터에 헤더가 없을 때 사용)

  df = pd.read_csv("week1_1.csv", header=None) 
  df.head()

  

• names 헤더가 없는 상황에서 컬럼명을 넣어주고 싶을 때

  df = pd.read_csv("week1_1.csv", names=['c1', 'c2', 'c3', 'c4', 'c5', 'c6']) 
  df.head()

  

• header & names 첫 행이 컬럼명이 맞는데, 컬럼명을 새로 지정해주고 싶을 때.

  df = pd.read_csv("week1_1.csv", header=None, names=['c1', 'c2', 'c3', 'c4', 'c5', 'c6']) 
  df.head()

  

• header = 1 두번째 행을 컬럼명으로 지정하고 싶을 때. 주로 엑셀 형태로 관리되었던 파일에서 사용한다.(위에 공백을 처리하기 위해)

  df = pd.read_csv("week1_1.csv", header=1) # 두번 째 행을 컬럼명으로 하고 싶을 때 (주로 엑셀 형태로 관리되었던 파일에서 사용.)
  df.head()

  

3. 데이터 불러오기 - INDEX

• index_col n번째 열을 index로 사용하고 싶을 때

  df = pd.read_csv("week1_1.csv", index_col=0) 
  df.head()

  

• index.name = None index 이름을 없애고 싶을 때

  df = pd.read_csv("week1_1.csv", index_col=0)
  df.index.name = None
  df.head()

• parse_date 컬럼을 날짜형식으로 불러올때.

  • 인덱스 : parse_dates = True
  • 일반컬럼 : parse_dates = 'column'

    df = pd.read_csv("week1_1.csv", index_col=0, parse_dates = True)
    df.index.name = None
    df.head()
    print(df.index.dtype) # datetime64[ns]

• 날짜형식 활용* 원하는 날짜를 기준으로 데이터를 불러올 수 있음

  df[df.index.month == 10] #10월달의 데이터만
  

from datetime import datetime cutoff_date = datetime(2023, 10, 1) # 해당날짜보다 큰 날짜 출력 df[df.index > cutoff_date]

![](https://velog.velcdn.com/images/waterglasses_k/post/8da451d9-28ac-41ac-b66e-a85780cb52f2/image.png)

- **dtype**
데이터 타입을 지정하여 불러옴
```python
df = pd.read_csv("week1_1.csv", dtype={'number':'object'})
df.dtypes

4. 데이터 불러오기 - API 활용한 XML Data 파싱

• xml 공공데이터 불러오기

import requests

serviceKey = "~~~~~"  # 일반 인증키 (Decoding)

url = 'http://apis.data.go.kr/B551182/yadmOpCloInfoService1/getHospPharmacyOpCloList'
params ={'serviceKey' : serviceKey, 'numOfRows' : '10', 'pageNo' : '1', 'crtrYm' : '202401', 'yadmTp' : '0', 'opCloTp' : '0' }

response = requests.get(url, params=params)
# print(response.content)  # bytes 형태여서 보기 힘듦.
content = response.content.decode('utf-8')  # utf-8로 디코딩함. 

df = pd.read_xml(response.content, xpath=".//item")

저장하기

• to_csv

  df.to_csv('file_name.csv')
  

#저장한 파일이 글자가 깨졌다면 df.to_scv('file_name.csv', encoding = 'cp949')

#index 저장하지 않을 때 df.to_scv('file_name.csv', index = False)

#header 저장하지 않을 때 df.to_scv('file_name.csv', header = False)

````

• mode

  #파일이 이미 있을 경우 덮어쓰기
  df.to_csv("file_name.csv", mode='w')
  

#파일이 이미 있을 경우 append하기 (모델 성능을 csv 파일로 저장할 때) df.to_csv("file_name.csv", mode='a')

#파일이 이미 있을 경우 생성하지 않음 df.to_csv("file_name.csv", mode='x')

#tsv로 저장(자주사용하지 않음) df.to_csv("file_name.tsv", sep = '\t') ```

컴알못인 나에게 가상환경는 말조차 이해가 안갔다. 처음에는 아~ 이런게 있나보구나 나중에 필요할때가 있겠지 싶었는데, 처음에 안된다고 이것저것 설치한 파이썬 버전에 패키지들까지, 도저히 정리가 안돼서 떠오른 것이 가상환경이었다.

가상환경 필요한 이유

• 파이썬 프로젝트의 프로젝트별로 격리시켜 관리
• 하나의 시스템에서 여러 프로젝트를 다룰 때, 각각의 프로젝트가 서로 다른 라이브러리 또는 동일 라이브러리의 다른 버전을 요구할 수 있다.
• 즉, 가상환경을 사용하면 프로젝트별로 안정적으로 패키지 버전을 관리할 수 있다. 위 그림처럼 상위버전을 설치해도 프로젝트A의 에러를 방지할 수 있다. ▶️ 출처 블로그

가상환경 설치하기

• VSCode사용

  #현재 경로 보여줌
  !pwd
  

#현재 위치의 폴더들 보여줌 !ls

#'myenv' 폴더 생성 !python -m venv myenv

#폴더생성한 것 확인 !ls

#생성한 폴더 실행 !source myenv/bin/activate # 맥

myenv\Scripts\activate # 윈도우

#커널설치 !pip install ipkernel

내가 지금 쓰고있는 가상환경 확인

!which python3

ipykernel 커널 설치

!pip install ipykernel

IPython 커널 생성 및 연결

!python -m ipykernel install --user --name myenv_kernel --display-name "커널이름(peach)"

```

그러면 주피터에서

또는 VSCode에서도

peach이름이 커널 확인 이 커널을 선택해서 프로젝트를 관리하면 된다.

👩🏻‍💻 Pycaret 메소드

• setup() : 데이터 전처리
• compare_models(): 여러 회귀모델을 훈련하여 비교
• tune_model() : 오토튜닝, 자동으로 모델 최적화
• plot_model(): pycaret 시각화(잔차, 오차)
• predict_model(): 모델의 예측성능 평가

pycaret?

Python에서 사용할 수 있는 저코드 머신러닝 라이브러리 데이터 전저리, 모델선택, 최적화 및 배포까지 한번에 해주는 치트키

pycaret 용도

• 베이스라인 모델을 정할때 활용
• 머신러닝의 통상 과정들을 한번에 스킵할 수 있다.
  • 1. 데이터 클리닝: 결측치 처리, 이상치 감지 및 제거
  • 2. 특성 공학: 새로운 특성 생성 및 변환, 비선형 관계를 갖는 변수 변환
  • 3. 데이터 분할: 훈련 데이터와 테스트 데이터로 분할
  • 4. 정규화/표준화: 데이터의 스케일 조정
  • 5. 인코딩: 범주형 변수를 수치형 변수로 변환
  • 6. 다중 공선성 확인: 변수 간의 고도의 상관관계 분석 및 처리
  • 7. 특성 선택: 중요한 특성 선택 및 불필요한 특성 제거

# pycaret 설치
! pip install pycaret full

# 데이터 불러오기
from pycaret.dataset import get_data
boston_df = get_data('boston')

# pycaret 회귀분석 라이브러리 불러오기
from pycaret.regression import * 

# pycaret 한번에 전처리하기
s = setup(data = boston_df,
    target = 'medv', #예측 대상변수
    session_id = 123,    #실험의 재현성과 관리를 위위함
    normalize = True,    #정규화
    transformation = True,    #데이터변환(정규분포를 더 정규분포와 유사하게)
    remove_outliers = True,        #이상치제거
    remove_multicollinearity = True,    #다중공선성제거 
    multicollinearity_threshold = 0.9,    #다중공선성제거 임계치
    feature_selection = True)    #특성선택(불필요한 특성 제거)

전처리된 결과를 한번에 확인할 수 있다. 데이터분리, 결측치 제거, 이상치제거, 정규화 등 어떻게 처리되었는지 확인

#전처리된 trian data 확인
s.train_transformed

선택된 변수는 age, lstat

# 머신러닝 모델 비교
best_model = compare_models()

정말 신세계라 할 수 있다. 위 모델을 전부 비교해주고 가장 베스트 알아서 골라준다. 베스트 모델은 knn 여기서 끝이 아니다. 설명력을 더 높일 수 있게 모델을 tune할 수 있다.

#자동 하이퍼파라미터 튜닝(오토튜닝)
tuned_model = tune_model(best_model, optimize = 'R2')

R2 : 0.6709 -> 0.6857 모델 성능 최적화도 쉽게 할 수 있다.

#모델 분석 시각화 
import matplotlib.pyplot as plt

#원본 histogram
plt.hist(boston_df['medv'], bins = 100)

plot_model(tuned_model, plot = 'residuals')
plt.show()

잔차그래프는 예측값과 실제값의 차이를 보여준다. 잔차가 무작위로 분포하고 특정 패턴이 없어야 모델이 잘 학습했다고 할 수 있다.

# 오차그래프
plot_model(tuned_model, plot = 'error')

오차그래프는 모델의 예측 오차를 시각화 한다. 일반적으로 예측값 대비 실제값의 오차를 보여주고, 잔차 분포의 특성을 파악하는데 도움된다.

#모델 최종평가
new_boston_df = boston_df
final_prediction = predict_model(tuned_model, data = new_boston_df)

knn접근법으로 설명력이 0.7039까지 상승했다. 다만, pycaret 모델을 바로 사용하는게 아니라 참고하여 모델을 선정하고 설명력의 기준을 잡으면 되겠다.

시험 접수 팁!

웬걸, 시험 접수시작한 날 저녁쯤 접수할려니까 근처 시험장 모두 이미 자리가 없었다. 지역마다 차이가 있겠지만 내가 가려고 했던 수원, 용인은 자리가 빨리 빠지는것 같으니 재시험(?)을 치게 되거나 다른 자격증 시험 접수하려면 접수오픈에 맞춰서 접수해야겠다. 어쩔 수 없이 4-50분 걸리는 평택으로 신청했다.

• 데이터자격검정(시험접수) https://www.dataq.or.kr/www/main.do

강의

강의는 스파르타코딩클럽 SQLD 강의를 수강했다. 이건 내일배움캠프 데이터분석 부트캠프 과정에 있는 커리큘럼으로, 이 수업을 듣기 전에 SQL 실습 교육을 먼저 수강한 덕분에 SQLD 자격증 수업을 듣는데 더욱 도움 되었다.

SQLD는 필기시험만 보기 때문에 이론만 잘 공부하면 되는데, 수업은 그렇다 치고 강의 노트가 생각보다 자세해서 이것만 읽어봐도 개념을 공부하는데 많은 도움이 되었다.

혹시라도 누가 관심있을지 모르니까 수강하고 있는 데이터분석캠프 홈페이지 링크를 달아둔다. 기간이 끝나면 부트캠프 후기도 기록해두어야겠다. https://nbcamp.spartacodingclub.kr/data

교재

사실 부트캠프 과정에서 SQLD자격증 시험은 메인 커리큘럼이 아니라서 개인적으로 추가 공부를 해야했다. 강의 교재로 이론공부하기는 좋지만 시험대비 문제지도 필요했다. https://www.yes24.com/Product/Goods/124645703

교재는 유명한 노랭이 시험 주관하는 곳에서 출판하는 책이니 이건 무조건 풀어보아야 한다. 실제 시험에서 해당 교재에 있는 문제가 2문제 정도 출제됐다. 교재 공부는 3회독했다. 처음 풀때는 이론 공부했던게 생각이 안나서 어려웠는데 2, 3회 나름 감이 잡혔다.

그런데 이 책은 SQLD+SQLP 교재이기 때문에 뒤의 분량은 SQLP 범위다. 책의 반만 풀기 때문에 문제가 적게 느껴질 수 있다. 문제가 부족하다면 기출문제지를 따로 사서 풀어보는게 좋겠다.

학습일정

누구는 2주, 누구는 두 달도 걸릴 수 있다. 기초지식이 있다면 2주도 가능할 것 같다. 그치만 짬짬이 공부해야 하는 탓에 날짜만 나는 두 달쪽에 속하는 것 같다. 두 달 동안 공부를 안한 날이 더 많았지만~ 한 열흘 전부터는 하루 2-3시간씩은 공부했다.

• 빡세게 공부하겠다! : 2주 가능할듯
• 짬나는 시간에 조금씩 하겠다 : 1~2달 가능

시험후기

뭐 별거라고 후기까지 남기는가 싶겠지만, 예~전에 토익, NCS 시험 본 이후로 처음 이런 시험을 보게 됐는데 나름 떨렸다. 어떤 시험을 보아도 빨리 푸는 편은 아닌데 이번에도 마찬가지로 시간을 거의 꽉 채웠다. 시험을 처음 보는 사람이라면 한번 쯤 시간 체킹하며 풀어보는 연습을 해보면 좋을 것 같다. 빨리 푸는 사람은 1시간, 나같은 사람은 꽉채워서 1시간 30분 다쓰고 퇴실했다.

다른 책들은 안풀어봐서 모르겠지만 시험 난이도는 위의 노랭이 책과 비슷했다. 아리까리한 문제들이 제법 있었어서 확실히 하려면 문제지 하나 더 풀걸 그랬다 ㅠㅠ

암튼 60점은 넘길 바라며,,,!

문제

String형 배열 seoul의 element중 "Kim"의 위치 x를 찾아, "김서방은 x에 있다"는 String을 반환하는 함수, solution을 완성하세요. seoul에 "Kim"은 오직 한 번만 나타나며 잘못된 값이 입력되는 경우는 없습니다.

👩🏻‍💻 my coding

• 반복문으로 리스트 내의 'Kim'찾기라고 생각했는데, 이 경우에는 index를 사용해준다.

  def solution(seoul) :
    if 'Kim' in seoul : 
        x = seoul.index('Kim')
        answer = f'김서방은 {x}에 있다'
    return answer 

25. 나누어 떨어지는 숫자 배열

문제

문제 설명 array의 각 element 중 divisor로 나누어 떨어지는 값을 오름차순으로 정렬한 배열을 반환하는 함수, solution을 작성해주세요. divisor로 나누어 떨어지는 element가 하나도 없다면 배열에 -1을 담아 반환하세요.

👩🏻‍💻 my coding

• arr 리스트 생성
• 조건문과 반복문 사용
• 오름차순 정렬

  def solution(arr, divisor) : 
    answer = []
    for i in arr : 
        if i % divisor == 0 : 
            answer.append(i)
        elif len(answer) == 0 :
            answer.append(-1)
    return sorted(answer)

  테스트케이스는 통과했는데 오답이다. [3, 2, 6, 10], 10을 넣으니 [-1, 10]이 출력되버린다.

  def solution(arr, divisor) : 
    answer = []
    for i in arr : 
        if i % divisor == 0 : 
            answer.append(i)
    if len(answer) == 0 :
            answer.append(-1)
    return sorted(answer)

  들여쓰기에 문제가 있었다. 위에 구문처럼 하면 나누어 떨어지는 요소가 없어도 -1을 추가하게 된다. 반복문을 다 돌고, 리스트에 값이 없으면 -1을 넣어주기 위해 하나 더 내어써야 함.

26. 음양 더하기

문제

어떤 정수들이 있습니다. 이 정수들의 절댓값을 차례대로 담은 정수 배열 absolutes와 이 정수들의 부호를 차례대로 담은 불리언 배열 signs가 매개변수로 주어집니다. 실제 정수들의 합을 구하여 return 하도록 solution 함수를 완성해주세요.

입출력 예

absolutes signs result [4,7,12] [true,false,true] 9 [1,2,3] [false,false,true] 0

👩🏻‍💻 my coding

이건 각 리스트에서 어떻게 하나씩 추출하느냐 골머리 앓다가, 찾아보니 zip을 이용하면 된다는걸 알았다.

• zip : 리스트 내 병렬 추출
• true이면 더하기, false면 빼주기

  def solution(absolutes, signs) : 
    answer = 0
    for i, j in zip(absolutes, signs) : 
        if j == True : 
            answer = answer + i
        else : 
            answer = answer - i 
    return answer 

• 비지도학습 개념 : 정답을 알려주지 않고 데이터간 유사성으로 정답을 지정하는 것.
• Kmeans Clustering 군집화
• RFM으로 고객 세그멘테이션
  • 고객 군집화의 방법
  • Recency 구하기
  • 불균형 군집화에 대한 로그스케일 적용
• 군집화모델 평가 : 실루엣 스코어

1. 비지도학습

지도학습과 비지도학습

• 지도학습 : 문제(X)와 정답(Y)가 주어지고 정답(Y)를 맞추는 학습
• 비지도학습 : 정답(Y)를 알려주지 않고 데이터간 유사성을 이용해서 정답(Y)을 지정하는 방법

2. K-Means Clustering

K-Means 수행순서

1. 1. K개 군집 수 설정
2. 임의의 중심을 선정
3. 해당 중심점과 거리가 가까운 데이터를 그룹화
4. 데이터의 그룹의 무게 중심으로 중심점을 이동
5. 중심점을 이동했기 때문에 다시 거리가 가까운 데이터를 그룹화 (3~5번 반복)

-> 좀 무식한 방법이라 할 수 있음

K-Means 정리

• 장점
  • 일반적이고 적용하기 쉬움
• 단점
  • 거리 기반으로 가까움을 측정하기 때문에 차원이 많을 수록 정확도가 떨어짐
  • 반복 횟수가 많을 수록 시간이 느려짐
  • 몇 개의 군집(K)을 선정할지 주관적임
  • 평균을 이용하기 때문에(중심점) 이상치에 취약함
• Python 라이브러리
  • sklearn.cluster.KMeans
    • 함수 입력 값
      • n_cluster: 군집화 갯수
      • max_iter: 최대 반복 횟수
    • 메소드
      • labels_: 각 데이터 포인트가 속한 군집 중심점 레이블
      • cluster_centers: 각 군집 중심점의 좌표

3. 군집평가 지표 - 실루엣계수

실루엣 계수란 ?

비지도 학습 특성상 답이 없기 때문에 평가를 하기 쉽지 않다. 다만, 군집화가 잘 되어있다는 것은 다른 군집간의 거리가 떨어져 있고 동일한 구집끼리는 가까이 있다는 것을 의미한다. 실루엣 분석(Silhouette Analaysis) : 군집간의 거리가 얼마나 효율적으로 분리되어잇는지 측정

실루엣 계수 특징

• 수식:

  $$ S(i) = \frac{b(i)-a(i)}{max(a(i),b(i))} \ 단\ i는 데이터 $$

• 해석: 1로 갈수록 근처의 군집과 더 멀리 떨어짐. 0에 가까울 수록 근처 군집과 가까워 진다는 것

• Python 라이브러리
  • sklearn.metrics.sihouette_score: 전제 데이터의 실루엣 계수 평균 값 반환
    • 함수 입력 값
      • X: 데이터 세트
      • labels: 레이블
      • metrics: 측정 기준 기본은 euclidean

        좋은 군집화의 조건

        • 실루엣 값이 높을수록(1에 가까울 수록)
        • 0에 가까울수록 클러스터링 불확실
        • 음수값은 클러스터링 결과가 잘못됨
        • 개별 군집의 평균 값의 편차가 크지 않을 수록

4. 붓꽃 데이터 군집화

• 원본 데이터 분포 확인

  import pandas as pd
  import seaborn as sns 
  import sklearn 
  import matplotlib.pyplot as plt 
  

iris_df = sns.load_dataset('iris') iris_df.head(3)

sns.scatterplot(data = iris_df, x = 'sepal_length', y = 'sepal_width')

![](https://velog.velcdn.com/images/waterglasses_k/post/6e0926d9-b4fc-48d7-93fd-eaeb3fae503c/image.png)

- KMeans 모델 학습 및 예측
```python
iris_df_2 = iris_df.copy().drop(columns = 'species')

iris_df_2.head(3)

from sklearn.cluster import KMeans
X = iris_df_2[['sepal_length', 'sepal_width', 'petal_length', 'petal_width']]

kmeans = KMeans(n_clusters = 3, random_state=42, init = 'k-means++', max_iter= 300)
kmeans.fit(X) #비지도학습이기 때문에 y값을 넣어주지 않음
iris_df_2['cluster'] = kmeans.predict(X)  

iris_df_2.head(3) 

• 그래프 비교

  plt.figure(figsize = (12, 6))
  plt.subplot(1, 2, 1)
  sns.scatterplot(data = iris_df, x = 'sepal_length', y = 'sepal_width', hue = 'species')
  plt.title('Original')
  

plt.subplot(1, 2, 2) sns.scatterplot(data = iris_df_2, x = 'sepal_length', y = 'sepal_width', hue = 'cluster', palette = 'winter') plt.title('Clustering') plt.show()

![](https://velog.velcdn.com/images/waterglasses_k/post/abaeedbc-295d-465a-83ec-fd9b0eb1b04d/image.png)

왼쪽 그래프는 군집화 그래프와 비교해보기 위해 species를 그려본 것.
1번 군집은 잘 군집화 된 것으로 보임
- 평가지표 - 실루엣 계수
```python
from sklearn.metrics import silhouette_score
silhouette_score(X, iris_df_2['cluster'])
```
0.5528190123564097
이 수준이면 클러스터링이 잘 되었다고 판단할 수 있다고 gpt가 말해주었다.

---

# 5. RFM 고객 군집화 실습
## 고객 세그멘테이션 정의
비지도 학습이 가장 많이 사용되는 곳이 고객관리(CRM)
타겟마케팅을 위해 고객 특성에 맞게 세분화할 수 있다. 
## RFM
- Recency(R) 가장 최근 구입 일에서 오늘까지의 시간
- Frequency(F): 상품 구매 횟수
- Monetary value(M): 총 구매 금액

---
- 데이터 불러오기 및 전처리를 위한 확인과정
```python
import pandas as pd 
import matplotlib.pyplot
import seaborn as sns 
import sklearn 

retail_df = pd.read_excel('/Users/sookyeong/Desktop/Online Retail.xlsx')

retail_df.isnull().sum()

retail_df.describe(include = 'all')
```
- 전처리 대상
   - customerid , description null값 삭제
   - quantity, unitprice (-)값 삭제
   - county 영국 대상
```python
con_customer = retail_df['CustomerID'].notnull()
con_quan = retail_df['Quantity'] > 0 
con_price = retail_df['UnitPrice'] > 0
con_county = retail_df['Country'] == 'United Kingdom'
retail_df2 = retail_df[con_customer & con_quan & con_price & con_county]

• RFM
  • R : 최근방문일 : InvoiceDate 컬럼 사용해 가장최근(2011-12-09 + 1)일에서 고객별 최신방문일 빼줌
  • F : 방문빈도 : 고객별 방문건수
  • M : 구매합계 --> 고객별 amount_monetary

    #매출총합
    retail_df2['amount_monetary'] = retail_df2['Quantity'] * retail_df2['UnitPrice']
    retail_df2['amount_monetary'] = retail_df2['amount_monetary'].astype('int')
    

#최근방문경과일 import datetime as dt #2011.12.10일 기준으로 각 날짜를 빼고 + 1

추후 customerid 기준으로 period의 최소의 period를 구하면 그것이 recency

retail_df2['Period'] = (dt.datetime(2011, 12, 10) - retail_df2['InvoiceDate']).apply(lambda x : x.days + 1) retail_df2

#고객별 RFM rfm_df = retail_df2.groupby('CustomerID').agg({'Period' : 'min', 'InvoiceNo' : 'count', 'amount_monetary' : 'sum'}) rfm_df.columns = ['Recency', 'Frequency', 'Monetary']

rfm_df

![](https://velog.velcdn.com/images/waterglasses_k/post/a35293f4-be06-44fb-ae3c-32afa2063237/image.png)

- 분포도 확인 및 스케일링
```python
sns.pairplot(rfm_df)


from sklearn.preprocessing import StandardScaler
sc = StandardScaler() 

X = rfm_df[['Recency', 'Frequency', 'Monetary']]

X_features = sc.fit_transform(X)
X_features

• KMeans 군집화

  from sklearn.cluster import KMeans
  from sklearn.metrics import silhouette_score
  

kmeans = KMeans(n_clusters = 3, random_state = 42) labels = kmeans.fit_predict(X_features) rfm_df['label'] = labels

silhouette_score(X_features, labels) -- 0.592575402996014

- 군집화 그래프를 위한 함수
```python
### 여러개의 클러스터링 갯수를 List로 입력 받아 각각의 실루엣 계수를 면적으로 시각화한 함수 작성
def visualize_silhouette(cluster_lists, X_features): 

    from sklearn.cluster import KMeans
    from sklearn.metrics import silhouette_samples, silhouette_score

    import matplotlib.pyplot as plt
    import matplotlib.cm as cm
    import numpy as np

    # 입력값으로 클러스터링 갯수들을 리스트로 받아서, 각 갯수별로 클러스터링을 적용하고 실루엣 개수를 구함
    n_cols = len(cluster_lists)

    # plt.subplots()으로 리스트에 기재된 클러스터링 수만큼의 sub figures를 가지는 axs 생성 
    fig, axs = plt.subplots(figsize=(4*n_cols, 4), nrows=1, ncols=n_cols)

    # 리스트에 기재된 클러스터링 갯수들을 차례로 iteration 수행하면서 실루엣 개수 시각화
    for ind, n_cluster in enumerate(cluster_lists):

        # KMeans 클러스터링 수행하고, 실루엣 스코어와 개별 데이터의 실루엣 값 계산. 
        clusterer = KMeans(n_clusters = n_cluster, max_iter=500, random_state=0)
        cluster_labels = clusterer.fit_predict(X_features)

        sil_avg = silhouette_score(X_features, cluster_labels)
        sil_values = silhouette_samples(X_features, cluster_labels)

        y_lower = 10
        axs[ind].set_title('Number of Cluster : '+ str(n_cluster)+'\n' \
                          'Silhouette Score :' + str(round(sil_avg,3)) )
        axs[ind].set_xlabel("The silhouette coefficient values")
        axs[ind].set_ylabel("Cluster label")
        axs[ind].set_xlim([-0.1, 1])
        axs[ind].set_ylim([0, len(X_features) + (n_cluster + 1) * 10])
        axs[ind].set_yticks([])  # Clear the yaxis labels / ticks
        axs[ind].set_xticks([0, 0.2, 0.4, 0.6, 0.8, 1])

        # 클러스터링 갯수별로 fill_betweenx( )형태의 막대 그래프 표현. 
        for i in range(n_cluster):
            ith_cluster_sil_values = sil_values[cluster_labels==i]
            ith_cluster_sil_values.sort()

            size_cluster_i = ith_cluster_sil_values.shape[0]
            y_upper = y_lower + size_cluster_i

            color = cm.nipy_spectral(float(i) / n_cluster)
            axs[ind].fill_betweenx(np.arange(y_lower, y_upper), 0, ith_cluster_sil_values, \
                                facecolor=color, edgecolor=color, alpha=0.7)
            axs[ind].text(-0.05, y_lower + 0.5 * size_cluster_i, str(i))
            y_lower = y_upper + 10

        axs[ind].axvline(x=sil_avg, color="red", linestyle="--")

• 그래프 함수적용1.

  visualize_silhouette([2,3,4,5,6], X_features)

  실루엣 스코어는 높은데 군집의 불균형이 너무 심함

• 로그 스케일 적용

• 그래프 함수적용2. 로그 스케일

  #log 스케일을 통한 추가전처리
  import numpy as np
  

rfm_df['Recency_log'] = np.log1p(rfm_df['Recency']) rfm_df['Frequency_log'] = np.log1p(rfm_df['Frequency']) rfm_df['Monetary_log'] = np.log1p(rfm_df['Monetary'])

X_features2 = rfm_df[['Recency_log','Frequency_log','Monetary_log']] sc2 = StandardScaler() X_features2_sc = sc2.fit_transform(X_features2)

visualize_silhouette([2,3,4,5,6], X_features2_sc)

![](https://velog.velcdn.com/images/waterglasses_k/post/298ff0a4-e765-4e73-ac10-896aa7336a84/image.png)

실루엣 스코어는 줄었지만 군집화가 균일하게 잘 적용됨을 확인 할 수 있음.

분류모델 학습과 실습

• 로지스틱스회귀
• 의사결정나무
• 랜덤포레스트
• KNN
• 부스팅알고리즘(Grediant, Xboost, Lightgbm)

1. 의사결정나무(Decision Tree)

의사결정나무란?

의사결정 규칙을 나무 구조로 나타내어 전체 자료를 몇 개의 소집단으로 분류하거나 예측을 수행하는 분석방법

의사결정나무 구조

• 루트 노드(Root Node): 의사결정나무의 시작점. 최초의 분할조건
• 리프 노드(Leaf Node): 루트 노드로부터 파생된 중간 혹은 최종 노드
• 분류기준(criteria): sex는 여성인 경우 0, 남성인 경우 1로 인코딩. 여성인 경우 좌측 노드로, 남성인 경우 우측 노드로 분류
• 불순도(impurity)
  • 불순도 측정 방법 중 하나 인 지니 계수는 0과 1사이 값으로 0이 완벽한 순도(모든 샘플이 하나의 클래스), 1은 완전한 불순도(노드의 샘플의 균등하게 분포) 됨을 나타냄
  • 리프 노드로 갈수록 불순도가 작아지는(한쪽으로 클래스가 분류가 잘되는)방향으로 나무가 자람
    • 샘플(samples): 해당 노드의 샘플 개수(891개의 관측치)
    • 값(value): Y변수에 대한 배열. 549명이 죽었고(Y = 0), 342명이 살았음(Y = 1)
    • 클래스(class)
  • 가장 많은 샘플을 차지하는 클래스를 표현
  • 위에서는 주황색(Y = 0 다수), 파란색(Y=1 다수)를 표현

    의사결정나무 정리

• 장점
  • 쉽고 해석하기 용이
  • 다중분류와 회귀에 모두 적용이 가능
  • 이상치에 견고하며 데이터 스케일링이 불필요(데이터의 상대적인 순서를 고려해서)
• 단점
  • 나무가 성장을 너무 많이하면 과대 적합의 오류에 빠질 수 있다.
  • 훈련 데이터에 민감하게 반응하여 작은 변화가 노이즈에도 나무의 구조가 크게 달라짐(불안정성)
• Python 라이브러리
  • sklearn.tree.DecisionTreeClassifier
  • sklearn.tree.DecisionTreeRegressor

    X = titanic_df[['Pclass', 'Sex', 'Age']]
    y_true = titanic_df['Survived']
    

#labelencoder : Pclass, Sex

결측치제거 : Age

from sklearn.preprocessing import LabelEncoder le1 = LabelEncoder() le2 = LabelEncoder()

titanic_df['Sex'] = le1.fit_transform(titanic_df['Sex']) titanic_df['Pclass'] = le2.fit_transform(titanic_df['Pclass']) titanic_df['Age'] = titanic_df['Age'].fillna(titanic_df['Age'].mean())

decisiontree

from sklearn.tree import DecisionTreeClassifier from sklearn import tree

model_dt = DecisionTreeClassifier(max_depth = 1, random_state=42) model_dt.fit(X, y_true)

plt.figure(figsize = (10, 5)) tree.plot_tree(model_dt, feature_names = X.columns.tolist(), class_names = ['Not Survived', 'Survived'], filled = True) plt.show()

![](https://velog.velcdn.com/images/waterglasses_k/post/5dffd8b1-58a6-40b5-94a9-842ff2264fbe/image.png)

---

# 2. 랜덤포레스트(Random Forest) 
## 랜덤포레스트란?

의사결정나무의 과적합과 불안정성을 해결하기 위함
## 배깅(Bagging)의 원리
- 언제나 머신러닝은 데이터의 부족이 문제
- 이를 해결 하기 위한 Bootstrapping + Aggregating 방법론
    - Bootstrapping: 데이터를 복원 추출해서 유사하지만 다른 데이터 집단을 생성하는 것
    - Aggregating: 데이터의 예측,분류 결과를 합치는 것
    - Ensemble(앙상블): 여러 개의 모델을 만들어 결과를 합치는 것
![](https://velog.velcdn.com/images/waterglasses_k/post/d30ce71a-469e-4723-9a3e-0ab61d6c916f/image.png)
## Tree를 Forest로 만들기
- 여러개의 데이터 샘플에서 각자 의사결정트리를 만들어서 다수결 법칙에 따라 결론을 냄
ex) 1번 승객에 대해서 모델 2개는 생존, 모델 1개는 사망을 분류하였다면, 1번 승객은 최종적으로 생존으로 분류
- 이로써 의사결정모델이 훈련 데이터에 민감한 점을 극복함.
![](https://velog.velcdn.com/images/waterglasses_k/post/90452615-582b-4bec-8584-24179cc98ef7/image.png)
## 랜덤포레스트 정리
- 장점
    - Bagging  과정을 통해 과적합을 피할 수 있다.
    - 이상치에 견고하며 데이터 스케일링이 불필요
    - 변수 중요도를 추출하여 모델 해석에 중요한 특징을 파악 할 수 있다.
- 단점
    - 컴퓨터 리소스 비용이 크다.
    - 앙상블 적용으로 해석이 어렵다.
- Python 패키지
    - `sklearn.ensemble.RandomForestClassifer`
    - `sklearn.ensemble.RandomForestRegressor`

```python
#로지스틱스회귀, 디시전트리, 랜덤포레스트(--학습한 분류모델 비교)
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier

X = titanic_df[['Pclass', 'Sex', 'Age']]
y_true = titanic_df['Survived']

model_lr = LogisticRegression()
model_dt = DecisionTreeClassifier()
model_rf = RandomForestClassifier()

#학습
model_lr.fit(X, y_true)
model_dt.fit(X, y_true)
model_rf.fit(X, y_true)

#예측 
lr_y_pred = model_lr.predict(X)
dt_y_pred = model_dt.predict(X)
rf_y_pred = model_rf.predict(X)

#평가, acc, f1
from sklearn.metrics import accuracy_score, f1_score
print('로지스틱스회귀 : acc', accuracy_score(y_true, lr_y_pred).round(2), 'f1', f1_score(y_true, dt_y_pred).round(2))
print('의사결정나무 : acc', accuracy_score(y_true, dt_y_pred).round(3), 'f1', f1_score(y_true, dt_y_pred).round(3))
print('랜덤포레스트 : acc', accuracy_score(y_true, rf_y_pred).round(3), 'f1', f1_score(y_true, rf_y_pred).round(3))

로지스틱스회귀 : acc 0.8 f1 0.83 의사결정나무 : acc 0.88 f1 0.833 랜덤포레스트 : acc 0.88 f1 0.835

3. KNN(K-Nearest Neighbor, 최근접 이웃)

KNN이란?

• 주변의 데이터를 보고 내가 알고 싶은 데이터를 예측하는 방식
  • K=3이라면 별 1개와 세모 2개이므로 ? 는 세모로 예측될 것
    • K=7이라면 별 4개와 세모 3개이므로 ?는 별로 예측될 것

      하이퍼마라미터

• 파라미터(Parameter): 머신러닝 모델이 학습 과정에서 추정하는 내부 변수이며 자동으로 결정 되는 값
  • Ex) 선형회귀에서 가중치와 편향
  • (혼동주의) Python에서는 함수 정의에서 함수가 받을 수 있는 인자(입력 값)를 지정하는 개념
• 하이퍼 파라미터(Hyper parameter): 데이터 과학자가 기계 학습 모델 훈련을 관리하는데 사용하는 외부 구성변수이며 모델 학습과정이나 구조에 영향을 미침 즉, 분석가가 지정하는 값.

  거리의 개념

• 유클리드 거리 : 2차원에서는 두 점 좌표 사이의 거리
• 맨해튼거리 : 가로와 세로의 거리
• 거리는 단위의 영향을 많이 받기 때문에 스케일링 필수!

KNN 모델 정리

• 장점
  • 이해하기 쉽고 직관적
  • 모집단의 가정이나 형태를 고려하지 않음
  • 회귀, 분류 모두 가능함
• 단점
  • 차원 수가 많을 수록 계산량이 많아짐
  • 거리 기반의 알고리즘이기 때문에 피처의 표준화가 필요함
• Python 라이브러리
  • sklearn.neighbors.KNeighborsClassifier
  • sklearn.neighbors.KNeighborsRegressor

4. 부스팅 알고리즘

부스팅 알고리즘이란?

여러개의 약한 학습을 순차적으로 학습하면서 잘못 예측한 데이터에 가중치를 부여하여 오류를 개선해나가는 학습 방법

부스팅 알고리즘 종류

• Gradient Boosting Model
  • 특징
    • 가중치 업데이트를 경사하강법 방법을 통해 진행
  • Python 라이브러리
    • sklearn.ensemble.GradientBoostingClassifier
    • sklearn.ensemble.GradientBoostingRegressor
      • XGBoost
  • 특징
    • 트리기반 앙상블 기법으로, 가장 각광받으며 Kaggle의 상위 알고리즘
    • 병렬학습이 가능해 속도가 빠름
  • Python 라이브러리
    • xgboost.XGBRegressor
    • xgboost.XGBRegressor
      • LightGBM
  • 특징
    • XGBoost와 함께 가장 각광받는 알고리즘
    • XGBoost보다 학습시간이 짧고 메모리 사용량이 작음
    • 작은 데이터(10,000건 이하)의 경우 과적합 발생
  • Python 라이브러리
    • lightgbm.LGBMClassifier
    • lightgbm.LGBMRegressor

# KNN
# 부스팅알고리즘(gradient, XGboost, LightGBM) & 회귀, 의사결정, 랜포 함께 비교

from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import GradientBoostingClassifier
from xgboost import XGBRFClassifier
from lightgbm import LGBMClassifier

model_knn = KNeighborsClassifier()
model_gbm = GradientBoostingClassifier(random_state=42)
model_xgbm = XGBRFClassifier(random_state=42)
model_lgbm = LGBMClassifier(random_state=42)

#학습
model_knn.fit(X, y_true)
model_gbm.fit(X, y_true)
model_xgbm.fit(X, y_true)
model_lgbm.fit(X, y_true)

#예측
knn_y_pred = model_knn.predict(X)
gbm_y_pred = model_gbm.predict(X)
xgbm_y_pred = model_xgbm.predict(X)
lgbm_y_pred = model_lgbm.predict(X)

#평가
print('로지스틱스회귀 : acc', accuracy_score(y_true, lr_y_pred).round(2), 'f1', f1_score(y_true, dt_y_pred).round(3))
print('의사결정나무 : acc', accuracy_score(y_true, dt_y_pred).round(3), 'f1', f1_score(y_true, dt_y_pred).round(3))
print('랜덤포레스트 : acc', accuracy_score(y_true, rf_y_pred).round(3), 'f1', f1_score(y_true, rf_y_pred).round(3))
print('KNN : acc', accuracy_score(y_true, knn_y_pred).round(3), 'f1', f1_score(y_true, knn_y_pred).round(3))
print('GBM : acc', accuracy_score(y_true, gbm_y_pred).round(3), 'f1', f1_score(y_true, gbm_y_pred).round(3))
print('XBOOST : acc', accuracy_score(y_true, xgbm_y_pred).round(3), 'f1', f1_score(y_true, xgbm_y_pred).round(3))
print('LightGBM : acc', accuracy_score(y_true, lgbm_y_pred).round(3), 'f1', f1_score(y_true, lgbm_y_pred).round(3))

로지스틱스회귀 : acc 0.8 f1 0.833 의사결정나무 : acc 0.88 f1 0.833 랜덤포레스트 : acc 0.88 f1 0.835 KNN : acc 0.833 f1 0.77 GBM : acc 0.855 f1 0.805 XBOOST : acc 0.82 f1 0.752 LightGBM : acc 0.862 f1 0.812

모델 평가지수 높여보기

• x변수 추가

  #fare와 embarked(결측치처리) 추가하여 평가점수 높여보기
  

X = titanic_df[['Pclass', 'Sex', 'Age', 'Fare', 'Embarked']] y_true = titanic_df['Survived'] titanic_df['Embarked'] = titanic_df['Embarked'].fillna('S')

le3 = LabelEncoder() titanic_df['Embarked'] = le3.fit_transform(titanic_df['Embarked'])

model_lr = LogisticRegression() model_dt = DecisionTreeClassifier() model_rf = RandomForestClassifier() model_knn = KNeighborsClassifier() model_gbm = GradientBoostingClassifier(random_state=42) model_xgbm = XGBRFClassifier(random_state=42) model_lgbm = LGBMClassifier(random_state=42)

#학습

model_lr.fit(X, y_true) model_dt.fit(X, y_true) model_rf.fit(X, y_true) model_knn.fit(X, y_true) model_gbm.fit(X, y_true) model_xgbm.fit(X, y_true) model_lgbm.fit(X, y_true)

#예측 lr_y_pred = model_lr.predict(X) dt_y_pred = model_dt.predict(X) rf_y_pred = model_rf.predict(X) knn_y_pred = model_knn.predict(X) gbm_y_pred = model_gbm.predict(X) xgbm_y_pred = model_xgbm.predict(X) lgbm_y_pred = model_lgbm.predict(X)

#평가 print('로지스틱스회귀 : acc', accuracy_score(y_true, lr_y_pred).round(2), 'f1', f1_score(y_true, dt_y_pred).round(3)) print('의사결정나무 : acc', accuracy_score(y_true, dt_y_pred).round(3), 'f1', f1_score(y_true, dt_y_pred).round(3)) print('랜덤포레스트 : acc', accuracy_score(y_true, rf_y_pred).round(3), 'f1', f1_score(y_true, rf_y_pred).round(3)) print('KNN : acc', accuracy_score(y_true, knn_y_pred).round(3), 'f1', f1_score(y_true, knn_y_pred).round(3)) print('GBM : acc', accuracy_score(y_true, gbm_y_pred).round(3), 'f1', f1_score(y_true, gbm_y_pred).round(3)) print('XBOOST : acc', accuracy_score(y_true, xgbm_y_pred).round(3), 'f1', f1_score(y_true, xgbm_y_pred).round(3)) print('LightGBM : acc', accuracy_score(y_true, lgbm_y_pred).round(3), 'f1', f1_score(y_true, lgbm_y_pred).round(3))

```` 로지스틱스회귀 : acc 0.79 f1 0.973 의사결정나무 : acc 0.98 f1 0.973 랜덤포레스트 : acc 0.98 f1 0.973 KNN : acc 0.809 f1 0.732 GBM : acc 0.889 f1 0.845 XBOOST : acc 0.869 f1 0.813 LightGBM : acc 0.945 f1 0.927

문제

두 정수 a, b가 주어졌을 때 a와 b 사이에 속한 모든 정수의 합을 리턴하는 함수, solution을 완성하세요. 예를 들어 a = 3, b = 5인 경우, 3 + 4 + 5 = 12이므로 12를 리턴합니다.

👩🏻‍💻 my coding

처음엔 a, b 중간의 값들을 어떻게 빼야하는지 계속 골머리를 앓았다. a, b 사이에 정수가 여러개면 어째야 하지 고민하다보니 리스트에 넣어서 모두 더하기로.

def solution(a, b):
    if a != b:
        n = abs(a - b)
        num = min(a, b)
        x = []
        for i in range(n + 1):
            num = num + i 
            x.append(num)
        return sum(x)
    else:
        return a

그런데 함수를 작동해보니 테스트케이스가 틀린다. 노트에 하나씩 써봐도 왜 틀린지를 모르겠다. gpt 해보니

def solution(a, b):
    if a != b:
        n = abs(a - b)
        num = min(a, b)
        x = []
        for i in range(n + 1):
            num = num 
            x.append(num + i)
        return sum(x)
    else:
        return a

리스트에 직접 +i 를 해준다. 어떻게 다른지 물어봐도 지피티도 계속 같은 함수라는 말만 한다. 튜터님에게 물어봐야겠다.

아대박 😇 멍청한게 여기서 드러나네 함수하면 if, for을 써야하겠다는 댕초보의 강박관념... 쉽게! 생각하면 된다고 하시며 알려줌

def solution(a, b) : 
    start_value = min(a, b)
    final_value = max(a, b)
    return sum(range(start_value, final_value+1))

한번만 보고도 코드를 쳤다. 등차수열을 이용하는게 가장 빠르다고 하셨지만 어차피 내가 응용을 못할 것 같아서 패스했다. 상단에 내가 틀린 반복문은 num이 계속 자라나는 형태라는데, 크게 중요하진 않은듯

정말 아차싶었던 이번 문제였다. 혼자풀지말고 쉽게 풀어가는 길을 찾아야겠다.

22. 콜라츠 추측

문제

1937년 Collatz란 사람에 의해 제기된 이 추측은, 주어진 수가 1이 될 때까지 다음 작업을 반복하면, 모든 수를 1로 만들 수 있다는 추측입니다. 작업은 다음과 같습니다.

1-1. 입력된 수가 짝수라면 2로 나눕니다. 1-2. 입력된 수가 홀수라면 3을 곱하고 1을 더합니다. 2. 결과로 나온 수에 같은 작업을 1이 될 때까지 반복합니다.

예를 들어, 주어진 수가 6이라면 6 → 3 → 10 → 5 → 16 → 8 → 4 → 2 → 1 이 되어 총 8번 만에 1이 됩니다. 위 작업을 몇 번이나 반복해야 하는지 반환하는 함수, solution을 완성해 주세요. 단, 주어진 수가 1인 경우에는 0을, 작업을 500번 반복할 때까지 1이 되지 않는다면 –1을 반환해 주세요.

👩🏻‍💻 my coding

def solution(num) : 
    count = 0
    for _ in range(500) : 
        if num == 1 : 
            return count 
        if num % 2 == 0 : 
            num  = num // 2
        elif num % 2 != 0 : 
            num  = num * 3 + 1
        count = count + 1 
    return -1 

여기서는 순서가 중요하다. 1인지 아닌지 먼저 판별하고 그 뒤에 홀짝여부 판별 뒤 카운트를 해준다.

• SQLite 데이터베이스에서 SQL을 사용하여 데이터를 전처리하고
• Python을 활용해 필요한 데이터를 시각화하기!

👩🏻‍💻 오늘 배운 것

*✅ SQLite 활용법 ✅ 파이썬에서 SQL연결, 테이블 생성하기 ✅ 시각화 스킬업(plt.grid(True), plt.tight_layout()) ✅ pd.to_datetime으로 날짜타입으로 바꿔 그래프 정리해주기 ✅ 변동성 분석(절대값으로!) ✅ `LAG(윈도우함수, 이전행을 가져옴) ✅ 자기상관성 분석(np 이용해 자기상관계수 구하기, 그래프 그리기) *

SQLite란?

장점

• 별도의 서버 프로세스 없이 SQL 데이터베이스 엔진을 제공
• 모바일 애플리케이션, 소규모 프로젝트에 적합
• 접근이 용이하고 관리가 간편함

단점

• 대용량 데이터베이스나 고성능을 요구하는 애플리케이션에서는 부적합
• 동시성 처리가 제한적

MySQL과 비교

• MySQL은 서버 기반의 DBMS로, 대규모 데이터베이스와 고성능을 요구하는 애플리케이션에 적합
• 고급 기능과 보안, 복잡한 트랜잭션 처리 제공
• 단, 설치와 관리가 복잡하며 리소스 사용량이 더 높음

✅ 규모로 따지면, Oracle > MySQL > SQLite

1. 라이브러리 임포트

import pandas as pd
import sqlite3. #SQLite를 사용하기 위한 파이썬 내장 라이브러리
import matplotlib.pyplot as plt

2. 데이터 로드 및 SQLite 데이터베이스로 변환

url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/daily-min-temperatures.csv'
data = pd.read_csv(url)

conn = sqlite3.connect('daily_temperatures.db')

data.to_sql('temperatures', conn, if_exists = 'replace', index = False)

✅ sql 연결, 테이블 생성 conn = sqlite3.connect('daily_temperatures.db')

• sqlite에 있는 daily_temperatures.db에 연결
• 해당 파일이 없다면 새로 생성하고, 존재하는 경우 파일에 연결

.to_sql

• 'temperatures'라는 이름의 테이블로 데이터를 SQLite에 저장

if_exists = replace

• 해당 테이블이 이미 존재하는 경우, 기존 테이블을 대체

index = False

• dataframe의 인덱스를 테이블에 저장하지 않겠다

3. SQL 쿼리실행: 연도별 최대 기온

yearly_max_temp_query = """
SELECT strftime('%Y', Date) as Year,
       max(Temp) as MaxTemp
FROM temperatures 
GROUP BY Year
ORDER BY Year ; 
"""

yearly_max_temp = pd.read_sql_query(yearly_max_temp_quaery)

✅ 파이썬에서 """사이에 SQL 쿼리문을 작성하여 전처리 가능

4. 데이터 시각화 : 연도별 최대 기온

plt.figure(figsize = (12, 6))
plt.plot(yearly_max_temp['Year'], yearly_max_temp['MaxTemp'], marker = 'o', color = 'darkblue', linestyle = '--')
plt.title('Yearly Maximum Temperature')
plt.xlabel('Year')
plt.ylabel('Max Temperature (°C)')
plt.xticks(rotation=45)
plt.grid(True)
plt.tight_layout()
plt.show()

✅ 시각화 스킬 업 plt.grid(True) : 그리드를 표시해 포인트 위치를 잘 식별 plt.tight_layout(): 그래프 레이아웃 자동 조정, 이쁘게

5. SQL 쿼리 실행 : 월별 평균 기온

monthly_avg_temp_query = """
select strftime('%Y-%m', Date) as YearMonth,
       avg(Temp) as AvgTemp
from temperatures
group by YearMonth
order by YearMonth ; 
"""

monthly_avg_temp = pd.read_sql_query(monthly_avg_temp_query, conn)

6. 데이터 시각화 : 월별 평균 기온

plt.figure(figsize=(15, 7))
plt.plot(monthly_avg_temp['YearMonth'], monthly_avg_temp['AvgTemp'], marker='o', linestyle='-', color='coral')
plt.title('Monthly Average Temperature')
plt.xlabel('Year-Month')
plt.ylabel('Average Temperature (°C)')
plt.xticks(rotation=45)
plt.grid(True)
plt.tight_layout()
plt.show()

이러면 x축 눈금이 너무 많아 보기 안좋다. pd.to_datetime으로 시각화 수정하기

plt.figure(figsize=(15, 7))
plt.plot(pd.to_datetime(monthly_avg_temp['YearMonth']), monthly_avg_temp['AvgTemp'], marker='o', linestyle='-', color='coral')
plt.title('Monthly Average Temperature')
plt.xlabel('Year-Month')
plt.ylabel('Average Temperature (°C)')
plt.xticks(rotation=45)
plt.grid(True)
plt.tight_layout()
plt.show()

7. 변동성 분석

• 변동성 분석은 기온데이터의 일일변동폭을 측정하여 기온이 얼마나 변동성이 큰지 파악하는 분석
• 특정기간 동안 기온 변화의 안정성을 평가할 수 있다.

  query = """
  select Date,
          ABS(Temp - LAG(Temp,1) over (order by Date)) as DailyChange
  from temperatures
  """
  daily_change = pd.read_sql_query(query, conn)

  # 일별 기온 변동성 시각화
  plt.figure(figsize=(14, 7))
  plt.plot(pd.DataFrame(daily_change['Date']), daily_change['DailyChange'], color='blue', alpha=0.5)
  plt.title('Daily Temperature Change')
  plt.xlabel('Date')
  plt.ylabel('Temperature Change (°C)')
  plt.show()

  

✅ 변동성 분석 : 얼마나 변동성이 큰지 파악(절대값 사용) ✅ LAG: 이전의 행을 가져옴

오늘의 킥! - 자기상관성 분석

• 자기상관성 분석? 시계열 데이터에서 한 시점의 데이터가 이전 시점의 데이터와 어떤 관계를 가지는지 분석하는 방법. 시간의 흐름에 따른 데이터의 패턴 파악하는데 유용함.

  import numpy as np
  

query = """ select Date, Temp, LAG(Temp, 1) over (order by Date)as PrevDayTemp from temperatures order by Date """

temp_data = pd.to_sql_query(query, conn) temp_data.dropna(inplace = True) temp_data['TempChange'] = temp_data['Temperature'] - temp_data['PrevDayTemp'] temp_data

````

자기상관성 분석 그래프

correlation = np.corrcoef(temp_data['TempChange'][1:], temp_data['TempChange'][:-1])[0, 1]
print(f'1일차 기온 변화의 자기상관계수 {correlation : 2.f}')

pd.plotting.autocorrelation_plot(temp_data['Temperature'])
plt.title['Autocorrelation of Daily Temperature']
plt.show()

1일 시차 기온 변화의 자기상관 계수: -0.18

✅ 자기상관성 계수는 -1에서 1 사이 ✅ 자기상관성 계수 그래프 : pd.plotting.autocorrelation_plot ✅ 첫번째와 마지막 요소 제외(인덱싱) 이유 : 이전값과 현재값의 쌍을 맞춰 데이터 포인트의 불균형을 줄이고 신뢰성을 높일 수 있음 ✅[0, 1]은 상관 계수행렬의 인덱싱. 상관계수 행렬의 [i, j]위치의 값은 i번째 배열과 j번째 배열의 상관관계를 나타냄. [0,1]은 상관계수 행렬에 인덱싱하여 두 배열간의 상관계수를 추출함.

Table 1 : User

+-------------+---------+ | Column Name | Type | +-------------+---------+ | user_id | int | | user_name | varchar | +-------------+---------+ user_id is the primary key (column with unique values) for this table. Each row of this table contains the name and the id of a user.

Table 2 : Register

+-------------+---------+ | Column Name | Type | +-------------+---------+ | contest_id | int | | user_id | int | +-------------+---------+

문제

각 콘테스트에 등록된 사용자의 비율을 소수점 이하 두 자리 까지 반올림하여 구하는 솔루션을 작성하세요. percentage로 내림차순으로 반환합니다 . 동점인 경우 contest_id 오름차순으로 정렬 합니다.

👩🏻‍💻my coding

# 콘테스트별 참여 유저
SELECT contest_id, COUNT(DISTINCT user_id) AS users_participated
FROM Register
GROUP BY contest_id;

# 유저의 총 합
SELECT COUNT(DISTINCT user_id) AS total_users
FROM Register;

# 합치기
select contest_id,
round(count(distinct user_id) *100 / (select count(distinct user_id) as total_users from register),2) as percentage
from register
group by contest_id 
order by percentage desc, contest_id 

👩🏻‍💻 학습한 것

✅ parse_dates : 컬럼을 날짜형식으로 파싱 ✅ data.isnull().values.any() : 데이터 결측지 있는지 확인 ✅ data.dropna(inplace = true) : 결측치 행 삭제 ✅ unstack() : 다중인덱스 중 하나를 열로 변환 ✅ 이동평균 : 데이터의 장기적인 추세를 파악 ✅ rolling(window=) : 이동평균 계산시 얼마나 말아주느냐 ✅ resample : 동일 간격별로 데이터를 뽑음(WAU, MAU에도 많이 사용) ✅ 추세선 : 선형회귀 모델을 활용한 추세선 그리기 ✅ 히트맵 - cmap : colormap / annot : annotion / fmt : format ✅ IQR 이상치 전처리

Q1 = data['column'].quantile(0.25) Q3 = data['column'].quantile(0.75) IQR = Q3 - Q1 upper_limit = Q3 + 1.5 IQR lower_limit = Q1 - 1.5 IQR

1. 데이터 로드 및 전처리

# 필요한 라이브러리 임포트
import pandas as pd  # 데이터를 다루는데 사용되는 라이브러리
import matplotlib.pyplot as plt  # 시각화를 위한 라이브러리
import seaborn as sns  # Matplotlib을 기반으로 한 시각화 라이브러리

# 데이터 로드
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/daily-min-temperatures.csv'  # 데이터가 저장된 URL
data = pd.read_csv(url, parse_dates=['Date'], index_col='Date')  # CSV 파일을 Pandas DataFrame으로 읽어들임
# parse_dates 옵션은 'Date' 열을 날짜로 파싱하도록 지정함
# index_col 옵션은 'Date' 열을 인덱스로 사용하도록 지정함

# 데이터 확인
print(data.head())  # 데이터의 처음 몇 개 행을 출력하여 내용을 확인함

# 결측치 확인 및 처리
if data.isnull().values.any():  # 데이터에 결측치(NaN)가 있는지 확인
    data.dropna(inplace=True)  # 결측치가 있으면 해당 행을 삭제함

# 데이터 타입 확인
print(data.dtypes)  # 데이터프레임의 각 열의 데이터 타입을 출력함

✅ parse_dates : 컬럼을 날짜형식으로 파싱 ✅ data.isnull().values.any() : 데이터 결측지 있는지 확인 ✅ data.dropna(inplace = true) : 결측치 행 삭제

2. 기초 통계 분석

# 연도와 월 컬럼 추가
data['Year'] = data.index.year  # 인덱스에서 연도를 추출하여 'Year' 열로 추가
data['Month'] = data.index.month  # 인덱스에서 월을 추출하여 'Month' 열로 추가

# 연도별 평균 기온 계산
yearly_avg_temp = data.groupby('Year')['Temp'].mean()  # 'Year'로 그룹화하여 각 연도별 평균 기온을 계산

# 월별 평균 기온 계산
monthly_avg_temp = data.groupby(['Year', 'Month'])['Temp'].mean().unstack()
# 'Year'와 'Month'로 그룹화하여 각 연도별, 월별 평균 기온을 계산하고,
# unstack() 함수를 사용하여 다중 인덱스에서 월을 열로 변환하여 표 형태로 만듦

# 연도별 평균 기온 통계 정보 출력
print(yearly_avg_temp.describe())
# 연도별 평균 기온에 대한 통계 정보(평균, 표준편차, 최솟값, 1사분위수, 중위값, 3사분위수, 최댓값)를 출력

✅ unstack() : 다중인덱스 중 하나를 열로 변환

3. 이동평균 분석

# 12개월 이동 평균 계산
data['Moving_Avg'] = data['Temp'].rolling(window=365).mean()
# 'Temp' 열을 기준으로 12개월 이동 평균을 계산하여 'Moving_Avg' 열에 저장
# rolling(window=365) 메서드는 이동 평균을 계산하는데 사용되며, 창(window) 크기를 365로 지정하여 12개월 이동 평균을 계산

# 이동 평균 시각화
plt.figure(figsize=(12, 6))  # 시각화 영역의 크기를 설정
plt.plot(data['Moving_Avg'], color='orange', label='12-Month Moving Average')  # 이동 평균 데이터를 주황색으로 선 그래프로 플롯
plt.title('12-Month Moving Average of Temperature')  # 그래프 제목 설정
plt.xlabel('Date')  # x축 레이블 설정
plt.ylabel('Temperature')  # y축 레이블 설정
plt.legend()  # 범례 표시
plt.show()  # 그래프 출력

✅ 이동평균 : 데이터의 장기적인 추세를 파악 ✅ window : 이동평균 계산시 얼마나 말아주느냐

• window=12 : 이전 12개(월데이터에 적절)

4. 이동평균 추세선

import numpy as np  # 수치 연산을 위한 라이브러리
from sklearn.linear_model import LinearRegression  # 선형 회귀 모델 라이브러리 임포트

# 연도별 이동 평균 기온 준비
yearly_moving_avg = data['Moving_Avg'].resample('Y').mean()
# 'Moving_Avg' 열의 연도별 이동 평균을 계산하기 위해 연도(Year)별로 리샘플링하고, 각 연도별 평균값을 계산함
# .resample : 계열 index를 연도 단위의 동일 간격별로 데이터를 뽑으라는 뜻

# 선형 회귀 모델을 사용하여 추세선 계산
model = LinearRegression().fit(np.arange(len(yearly_moving_avg)).reshape(-1, 1), yearly_moving_avg.values)
# 선형 회귀 모델을 초기화하고, 연도별 이동 평균 기온 데이터에 대해 학습함
# np.arange(len(yearly_moving_avg)).reshape(-1, 1)은 데이터를 피팅하기 위한 형태로 변환함

# 추세선을 위한 예측 값 계산
trend = model.predict(np.arange(len(yearly_moving_avg)).reshape(-1, 1))
# 학습된 모델을 사용하여 각 연도별 추세 값을 예측함

# 이동 평균과 함께 추세선 그리기
plt.figure(figsize=(12, 6))  # 그래프 영역의 크기를 설정함
plt.plot(yearly_moving_avg.index, yearly_moving_avg.values, label='12-Month Moving Average')  # 12개월 이동 평균을 플롯함
plt.plot(yearly_moving_avg.index, trend, label='Trend', color='red')  # 추세선을 빨간색으로 플롯함
plt.title('12-Month Moving Average with Trend Line')  # 그래프 제목 설정
plt.xlabel('Year')  # x축 레이블 설정
plt.ylabel('Temperature')  # y축 레이블 설정
plt.legend()  # 범례 표시
plt.show()  # 그래프 출력

✅ ** resample : 동일 간격별로 데이터를 뽑음(WAU, MAU에도 많이 사용) ✅ 추세선 : 선형회귀 모델을 활용한 추세선 그리기**

5. Box Plot과 이상치 탐색

# 월별 기온 분포 상자 그림
sns.boxplot(x='Month', y='Temp', data=data)
# 월별로 기온 데이터를 상자 그림으로 표시
# x='Month'는 x축에 월을, y='Temp'는 y축에 기온을 나타냄
# data=data는 사용할 데이터프레임을 지정함

plt.title('Box Plot of Temperatures by Month')
# 그래프 제목 설정
plt.show()
# 그래프 출력

6. IQR 이상치 처리

#IQR로 이상치 제거하기(혼자 실습))
Q1 = data['Temp'].quantile(0.25)
Q3 = data['Temp'].quantile(0.75)
IQR = Q3 - Q1 

upper_limit = Q3 + 1.5 * IQR
lower_limit = Q1 - 1.5 * IQR 

data_no_outliers = data[(data['Temp'] <= upper_limit) & (data['Temp'] >= lower_limit)]

sns.boxplot(data = data_no_outliers, x = 'Month', y = 'Temp')

✅ IQR 수식 외우기

Q1 = data['column'].quantile(0.25) Q3 *= data['column'].quantile(0.75) *IQR = Q3 - Q1 upper_limit = Q3 + 1.5 * IQR lower_limit = Q1 - 1.5 * IQR

7. 히트맵 시각화

plt.figure(figsize=(12, 9))
# 그래프의 크기를 설정함

sns.heatmap(monthly_avg_temp, cmap='coolwarm', annot=True, fmt=".1f")
# seaborn의 heatmap 함수를 사용하여 월별 평균 기온 데이터를 열 지도(heat map)로 시각화함
# monthly_avg_temp는 월별 평균 기온 데이터를 포함하는 DataFrame이며, 각 셀에는 기온 값이 표시됨
# cmap='coolwarm'은 컬러맵을 설정하는데, coolwarm은 차가운 색과 따뜻한 색의 대비를 나타냄
# annot=True는 각 셀에 값의 주석을 추가하라는 의미이며, fmt=".1f"는 주석의 형식을 소수점 첫째 자리까지 표시하라는 의미임

plt.title('Heatmap of Monthly Average Temperatures')
# 그래프의 제목을 설정함

plt.xlabel('Month')
# x축 레이블을 설정함

plt.ylabel('Year')
# y축 레이블을 설정함

plt.show()
# 그래프를 출력함

✅ cmap : colormap ✅ annot : annotion ✅ fmt : format

✅ DAU, WAU, MAU - groupby 이용해 구하기

dau = df3.groupby(df3['new_date'])['fullVisitorId'].nunique()
wau = df3.groupby(df3['new_date'].dt.to_period('W'))['fullVisitorId'].nunique()
mau = df3.groupby(df3['new_date'].dt.to_period('M'))['fullVisitorId'].nunique()

plt.figure(figsize=(10,5))
plt.plot(dau, label = 'DAU')
plt.plot(wau, label = 'WAU')
plt.plot(mau, label = 'MAU')
plt.xlabel('DATE')
plt.ylabel('Number of User')
plt.title('DAU / WAU / MAU')
plt.legend()

데이터 타입이 날짜형식이라면 dt.to_period메소드를 사용해 주별, 연도별 활동유저를 구할 수 있다!

유저별 평균접속시간의 분포를 ECDF로 시각화

: 데이터의 누적분포를 시각화 한 것이다. 이건 답이 아닌것 같지만 작업한 과정을 기록해보기로

• 방법 : daily로 첫 접속과 마지막 접속 사이의 길이를 평균 접속 시간으로 간주

  #유저별 첫 번째 접속과 마지막 접속을 파악하여 DataFrame을 재구성
  first_last_visit = df3.groupby([df3['fullVisitorId'], df3['new_visitStartTime'].dt.date])['new_visitStartTime'].agg(['first', 'last'])
  

각 사용자의 접속 기간을 계산하여 새로운 열로 추가

first_last_visit['session_duration'] = first_last_visit['last'] - first_last_visit['first'] #session_duration이 음수값도 있음 -> 제외 필요

마지막 접속 시간이 처음 접속 시간보다 큰 행만 선택하여 새로운 DataFrame을 생성

filtered_data = first_last_visit[first_last_visit['last'] > first_last_visit['first']]

#유저별 평균 접속시간 계산하기 #이미 사용자별 접속시간을 구했으므로(session_duration) 해당 컬럼으로 groupby #level = 0 : 사용자별로 다 시그룹화하는데 사용되는 인덱스 레벨 -> fullVisitorId mean_session_duration = filtered_data['session_duration'].groupby(level=0).mean()

#ecdf계산 def ecdf(data): n = len(data) x = np.sort(data) y = np.arange(1, n + 1) / n return x, y

x, y = ecdf(mean_session_duration)

시각화

plt.figure(figsize=(6, 5)) plt.plot(x, y, marker='.', linestyle='none') plt.xlabel('Average Session Duration') plt.ylabel('ECDF') plt.title('ECDF of Average Session Duration by User') plt.grid(True) plt.show()

![](https://velog.velcdn.com/images/waterglasses_k/post/452c41b2-47ca-4b3f-915b-b073ea1f4fdc/image.png)
내가 해석한 내용은
- y축 0.5기준으로 평균접속시간이 늘어난다.
- 데이터 분포가 right-skew됨을 알 수 있다. 

---
## 요일/시간대별 사용자 수를 구하고 이를 heatmap으로 시각화
```python
#요일별, 시간대별 사용자수 구하기
week_hour_user = df3.groupby([df3['new_visitStartTime'].dt.hour, df3['new_visitStartTime'].dt.weekday])['fullVisitorId'].nunique()

# 히트맵을 그리기위한 피벗테이블
# unstack은 다중 인덱스를 가진 데이터프레임을 사용할 때 하나의 인덱스를 컬럼으로 변환할 수 있음
week_hour_user = week_hour_user.unstack()

여기서 unstack()이 킥이다. .unstack()을 해주면 인덱스컬럼이 열로 변환되어 피봇으로 이쁘게 변환된다.

# heatmap그리기
plt.figure(figsize=(15, 8))
sns.heatmap(data = week_hour_user, cmap='YlGnBu', annot = True, fmt = 'd', linewidths=0.5)
plt.title('Weekday/Hour User Count')
plt.xlabel('Week of Day')
plt.ylabel('Hour')
plt.xticks(ticks=np.arange(7), labels=['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'])
plt.show()

비교적 히트맵은 이쁘게 그려진듯 평일 오후 6시정도가 가장 유저 활동이 많다!

👩🏻‍💻 오늘 써먹어본 것

• goupby : 사용법에 대해 이제 좀 감이 잡힌듯
• unstack() : 히트맵그릴때, 피봇테이블 만들때 유용
• ECDF : 분포를 확인하는 그래프같은데 아직 잘 모르겠음..!

# new_date는 new_visitstarttime과 같은 값이라 제외
df3 = df3.drop(['keyword', 'newVisits', 'new_date'], axis =1)

✅ drop을 쓸때도 axis=1을 해준다. null값이 있는게 눈에 띄는데 pageview는 조회수, bounce는 이탈, transactionrevenue는 거래금액으로 분석의 중요한 지표라 판단해서 결측치를 처리해 사용하기로 했다. 결측치는 평균값을 대체하거나 0을 넣거나 하는 등 적절하게 채워주면 된다. 세 컬럼 모두 기록이 없는 것이 결측치라 판단, 0을 넣어주었다.

#transactionrevenue, bounces 결측치 0으로 채우기
df3['transactionRevenue'] = df3['transactionRevenue'].fillna(0)
df3['bounces'] = df3['bounces'].fillna(0)
df3['pageviews'] = df3['pageviews'].fillna(0)

✅ fillna(0) 으로 결측치 처리하기

DAU/WAU/MAU

전처리가 모두 완료된건 아닌 것 같지만, 필요한 것은 그때그때 분석때 하기로하고 먼저 DAU/WAU/MAU 구하는 것을 시도해보기로!

• 유저는 'fullVisitorID'
• 일자는 new_visitStartTime

✅ 1. 시각까지 포함된 컬럼값 수정(dt.date)

timestamp_day = df3['new_visitStartTime'].dt.date

✅ DAU 구하기(groupby 사용)

dau = df3.groupby(timestamp_day)['fullVisitorId'].nunique()

groupby 메소드로 날짜별 고유한 유저수를 구한다.

✅ WAU/MAU 구하기(resample 사용) WAU와 MAU는 단순히 일자를 보는게 아니라 일주일별, 달별로 기간을 쪼개고 유저수를 따져주어야 한다. resample 메소드를 사용해봄

#wau 구하기
start_date = pd.Timestamp('2016-08-01')
end_date = pd.Timestamp('2017-07-31')
filtered_data = df[(df['new_visitStartTime'] >= start_date) & (df['new_visitStartTime'] <= end_date)]

wau = filtered_data.resample('W-Mon', on='new_visitStartTime')['fullVisitorId'].nunique()
wau

wau에서 filtered_data 대신 df3데이터를 넣으면 로딩이 한참걸린다. 데이터 기준을 잡고 필터링을 하고 'W-Mon'을 기준으로 구한다. 'M'을 기준으로 구하면 MAU 'D'로 잡으면 DAU겠지?

#mau 구하기
start_date = pd.Timestamp('2016-08-01')
end_date = pd.Timestamp('2017-07-31')
filtered_data = df[(df['new_visitStartTime'] >= start_date) & (df['new_visitStartTime'] <= end_date)]

# 월별로 사용자를 그룹화하고 MAU 계산
mau = filtered_data.resample('M', on='new_visitStartTime')['fullVisitorId'].nunique()
mau

✅ DAU/WAU/MAU 그래프 합치기

#dau, mau 그래프 합치기
plt.figure(figsize=(8,5))
plt.plot(dau, label = 'DAU', color = 'blue')
plt.plot(wau, label = 'WAU', color = 'green')
plt.plot(mau, label = 'MAU', color = 'red')
plt.xlabel('Date')
plt.ylabel('users')
plt.legend()
plt.show()

내가 혼자 해본거라 틀릴수도 있음!

👩🏻‍💻오늘 써먹어본 것!

• .fillna()
• drop.df['column'], axis = 1
• filterdata.resample('M', on='date')['use_id'].nunique()
• df.groupby('date')['user_id'].nunique()

문제설명

문자열 s를 숫자로 변환한 결과를 반환하는 함수, solution을 완성하세요.

제한조건

s의 길이는 1 이상 5이하입니다. s의 맨앞에는 부호(+, -)가 올 수 있습니다. s는 부호와 숫자로만 이루어져있습니다. s는 "0"으로 시작하지 않습니다.

입출력 예

예를들어 str이 "1234"이면 1234를 반환하고, "-1234"이면 -1234를 반환하면 됩니다. str은 부호(+,-)와 숫자로만 구성되어 있고, 잘못된 값이 입력되는 경우는 없습니다.

👩🏻‍💻 my coding

def solution(n) : 
    return int(n)

19. 정수 제곱근 판별

문제설명

임의의 양의 정수 n에 대해, n이 어떤 양의 정수 x의 제곱인지 아닌지 판단하려 합니다. n이 양의 정수 x의 제곱이라면 x+1의 제곱을 리턴하고, n이 양의 정수 x의 제곱이 아니라면 -1을 리턴하는 함수를 완성하세요.

👩🏻‍💻 my coding

def solution(n): 
    for i in range(n) : 
        if n == i**2 : 
            return (i+1)**2
        else : 
            return -1

처음 이렇게 코딩했는데, 이렇게 하면 첫번째 반복문에서 조건 검사 후 무조건 -1이 출력된다. return -1을 반복문이 끝난 후에 실행해 반복문을 모두 실행한 후에도 정답을 못찾을 때만 -1이 출려되게 한다.

def solution(n):
    for i in range(n):
        if n == i ** 2:
            return (i + 1) ** 2
    return -1

그런데 이렇게 해도 예외 테스트 케이스에서 걸린다. 실제로는 i가 n-1까지 돌기 때문에

def solution(n):
    for i in range(n+1):
        if n == i ** 2:
            return (i + 1) ** 2
    return -1

😇 n 자기 자신인 경우에도 고려되어야 하기 때문에 range(n+1)이 되어야 한다.