_zeroiszero.log

3. 비정제데이터 체험하기2

Fri, 19 Sep 2025 03:52:37 GMT

프로젝트

Fri, 15 Dec 2023 14:56:34 GMT

<목차>

1 주제 및 선정 이유

2 코드 및 결과 설명

3 느낀점

1 주제 및 선정 이유

2023-2학기에 '데이터 전처리' 수업을 들으면서 머릿속에 흩어져서 존재하던 데이터 분석 과정과 그 과정에서 활용되는 분석 절차, 코드, 여러가지 툴이 어느정도 정리가 되는것 같았다.

그래서 데이터 전처리 수업 시간에 배운 내용 일부분을 적용하여 내용 정리 겸 실제 데이터 분석에 적용을 해보고자 한다.

주제는 '남산도서관의 도서 대출건수 예측' 이다. 도서관 대출 데이터를 사용해 분석에 불필요한 문자, 행, 열 등을 제거하고 머신러닝 기법을 이용하여 남산도서관의 도서 대출건수를 예측하는 간단한 프로젝트를 해보는 것이다.

(데이터 전처리 과정에서 중간중간 코드 실행은 했지만, 너무 분량이 많아져서 벨로그에 첨부하지 않은 것도 있음!!)

2 코드 및 설명

1. 데이터 전처리 하기

1) 불필요한 데이터 삭제하기

📝 불필요한 행과 열을 제거하기 위해 짧게 여러개씩 작성했던 코드들을 새로운 데이터에 적용하기 쉽도록 일괄처리하는 data_cleansing( ) 이라는 일괄처리용 함수를 만들어서 처리를 해보았다. 남산도서관에서 새로운 도서 데이터를 다운로드 했을때 dropna() 하고 groupby()등을 일일이 하기에는 너무 코드가 길었다. 따라서 필요한 코드만 파이썬 def함수로 만들어서 저장하면 간단하게 함수를 호출하거나 파이썬 스크립트를 실행하여 데이터 전처리를 하는 과정을 단순하게 만들 수 있다.

ns_book4.to_csv('ns_book4.csv', index=False) # 분석에 활용할 csv파일 (한줄한줄씩 전처리해서 만든 데이터프레임 (불필요한 데이터들 제거한거))

# 남산 도서관 장서 csv 데이터 전처리 함수 
def data_cleaning(filename):
     # 파일을 데이터프레임으로 읽음
    ns_df = pd.read_csv(filename, low_memory=False) # 여기서 filename은 csv파일 이름을 말함 
    # NaN인 열을 삭제함
    ns_book = ns_df.dropna(axis=1, how='all')

    # 대출건수를 합치기 위해 필요한 행만 추출하여 count_df 데이터프레임을 만듦
    count_df = ns_book[['도서명','저자','ISBN','권','대출건수']]
    # 도서명, 저자, ISBN, 권을 기준으로 대출건수를 groupby함
    loan_count = count_df.groupby(by=['도서명','저자','ISBN','권'], dropna=False).sum()
    # 원본 데이터프레임에서 중복된 행을 제외하고 고유한 행만 추출하여 복사함
    dup_rows = ns_book.duplicated(subset=['도서명','저자','ISBN','권'])
    unique_rows = ~dup_rows
    ns_book3 = ns_book[unique_rows].copy()
    # 도서명, 저자, ISBN, 권을 인덱스로 설정
    ns_book3.set_index(['도서명','저자','ISBN','권'], inplace=True)
    # load_count에 저장된 누적 대출건수를 업데이트함
    ns_book3.update(loan_count)

    # 인덱스 재설정함
    ns_book4 = ns_book3.reset_index()
    # 원본 데이터프레임의 열 순서로 변경함
    ns_book4 = ns_book4[ns_book.columns]

    return ns_book4

📝 위에서 원본 데이터인 ns_202104.csv 파일을 전달하여 새로운 데이터프레임인 new_ns_book4를 만들고, 내가 개인적으로 한줄한줄씩 전처리해서 만든 ns_book4 데이터프레임과 같은지 비교를 해보았다. 다른 데이터프레임과 비교할때는 equals() 사용!! (개인적으로 한줄씩 전처리를 해본 ns_book4는 너무 내용이 많아서 못넣었음)

new_ns_book4 = data_cleaning('ns_202104.csv')

ns_book4.equals(new_ns_book4)

결과

👉 내가 개인적으로 한줄씩 전처리를한 ns_book4 와 위의 일괄처리 함수가 수행한 데이터프레임이 같다고 나왔다. 이를 통해서 남산 도서관을 제외한 새로운 장서 데이터를 분석하고 싶으면, 위의 일괄처리용 함수를 수행해서 전처리 작업을 간단하게 한번에 끝낼 수 있다.

2) 잘못된 데이터 수정하기

📝 1)의 '불필요한 데이터 삭제하기' 과정에서도 말했듯이 2)의 과정도 한줄한줄씩 코랩에서 잘못된 데이터에 한해서 개인적으로 전처리를 해보았다. 그러나 코드가 너무 길어져서 1)과 마찬가지로 일괄처리 함수를 작성하여 그나마 간단하게 잘못된 데이터를 전처리를 해보았다.

ns_book6.to_csv('ns_book6.csv', index=False) # 한줄씩 전처리해서 만든 데이터프레임 (NaN이랑 잘못된거 처리한거)


def data_fixing(ns_book4):
    # 도서권수와 대출건수를 int32로 바꿈 
    ns_book4 = ns_book4.astype({'도서권수':'int32', '대출건수': 'int32'})
    # NaN인 세트 ISBN을 빈문자열로 바꿈
    set_isbn_na_rows = ns_book4['세트 ISBN'].isna()
    ns_book4.loc[set_isbn_na_rows, '세트 ISBN'] = ''

    # 발행년도 열에서 연도 네 자리를 추출하여 대체, 나머지 발행년도는 -1로 바꿈
    ns_book5 = ns_book4.replace({'발행년도':'.*(\d{4}).*'}, r'\1', regex=True)
    unkown_year = ns_book5['발행년도'].str.contains('\D', na=True)
    ns_book5.loc[unkown_year, '발행년도'] = '-1'


    # 발행년도를 int32로 바꿈
    ns_book5 = ns_book5.astype({'발행년도': 'int32'})
    # 4000년 이상인 경우 2333년을 뺀다
    dangun_yy_rows = ns_book5['발행년도'].gt(4000)
    ns_book5.loc[dangun_yy_rows, '발행년도'] = ns_book5.loc[dangun_yy_rows, '발행년도'] - 2333
    # 여전히 4000년 이상인 경우 -> -1로 바꿈
    dangun_year = ns_book5['발행년도'].gt(4000)
    ns_book5.loc[dangun_year, '발행년도'] = -1
    # 0~1900년 사이의 발행년도는 -1로 바꿈
    old_books = ns_book5['발행년도'].gt(0) & ns_book5['발행년도'].lt(1900)
    ns_book5.loc[old_books, '발행년도'] = -1

     # 도서명, 저자, 출판사가 NaN이거나 발행년도가 -1인 행을 찾음
    na_rows = ns_book5['도서명'].isna() | ns_book5['저자'].isna() \
              | ns_book5['출판사'].isna() | ns_book5['발행년도'].eq(-1)
    # 교보문고 도서 상세 페이지에서 누락된 정보를 채움
    updated_sample = ns_book5[na_rows].apply(get_book_info,
        axis=1, result_type ='expand')
    updated_sample.columns = ['도서명','저자','출판사','발행년도']
    ns_book5.update(updated_sample)

     # 도서명, 저자, 출판사가 NaN이거나 발행년도가 -1인 행을 삭제함
    ns_book6 = ns_book5.dropna(subset=['도서명','저자','출판사'])
    ns_book6 = ns_book6[ns_book6['발행년도'] != -1]

    return ns_book6

👉 위의 일괄처리 함수도 엄~청 분량이 많은 편이지만, 한줄한줄 전처리를 했을 때보다는 그래도 적은편이었다. 이렇게 불필요한 데이터들과 결측치, 오류가 있는 데이터들을 처리하면 드디어 분석에 활용할 데이터가 만들어진 것이다.

2. 머신러닝으로 예측하기

📝 위에서 전처리해서 만든 ns_book6 에서 sum(ns_book['도서권수']==0) 으로 도서권수의 열의 값이 0인 행의 개수를 확인했더니, 3206개가 나왔다. 정확하지 않은 판단일수도 있지만 0권은 의미없다고 생각해서 삭제했다.

ns_book7 = ns_book6[ns_book6['도서권수']>0]
# 도서권수가 0인 데이터 제외한것을 ns_book7에 저장함

📝 이제 머신러닝에 활용할 데이터는 ns_book7이다.

1) 대출건수 예측하기

✔ 훈련 데이터와 검증 데이터로 나누기

# ns_book7 데이터를 다운받고 데이터프레임으로 불러옴 
import gdown

gdown.download('https://bit.ly/3pK7iuu', 'ns_book7.csv', quiet=False)

import pandas as pd

ns_book7 = pd.read_csv('ns_book7.csv', low_memory=False)
ns_book7.head()

결과

from sklearn.model_selection import train_test_split

train_set, test_set = train_test_split(ns_book7, random_state=42)

print(len(train_set), len(test_set))

결과

📝 코드 실행결과 전체에서 75%가 훈련 데이터, 25%가 검증 데이터로 나누어졌다. 이제 사이킷런에 있는 선형회귀모델을 위의 데이터로 훈련해본다.

X_train = train_set[['도서권수']]
y_train = train_set['대출건수']

print(X_train.shape, y_train.shape)

결과

📝 X_train은 282577개의 행과 1개의 열로 이루어진 데이터프레임이고, y_train은 '시리즈 객체' 즉 282577개 원소를 가진 1차원 배열이다. (사이킷런이 입력으로는 2차원 배열, target으로는 1차원 배열을 기대하기 때문에 이런식으로 해줬다.)

✔ 선형회귀모델 훈련

📝 이제 사이킷런의 linear_model 모듈의 LinearRegression 클래스를 불러와서 선형회귀모델을 훈련시켜본다.

from sklearn.linear_model import LinearRegression

lr = LinearRegression() # LinearRegression 클래스의 객체 lr 만들었음
lr.fit(X_train, y_train) # fit() 메서드를 호출해서 모델을 훈련함

결과

✔ 훈련시킨 모델 평가하기

X_test = test_set[['도서권수']]
y_test = test_set['대출건수']

lr.score(X_test, y_test)

결과

📝 위의 결과를 보면 점수가 0.1이므로 점수가 안좋다. 도서권수로 대출건수를 예측하는건 어렵다고 본다.

✔ 선형회귀로 연속적인 값을 예측하기

선형회귀 : 선형함수를 사용하여 모델을 만드는 알고리즘
- 식 : y = ax + b
  - 선형회귀알고리즘이 fit() 메서드를 호출했을때 데이터에서 학습한것이 기울기 a와 절편 b이다.

print(lr.coef_, lr.intercept_)
# lr.coef_ : 학습된 기울기, lr.intercept_ : 절편

결과

📝 위의 결과를 보면 기울기는 1, 절편은 0에 매우 가까운 음수이다. 따라서 선형회귀모델 : y = x 이다.

✔ 로지스틱회귀로 카테고리 예측하기

로지스틱회귀 : 분류 알고리즘의 대표적인 예시
로지스틱 함수를 사용하여 연속적인 실수 출력값을 1 또는 0으로 변환한다.
- 로지스틱 함수를 '시그모이드 함수' 라고 한다.

📝 로지스틱회귀 모델을 만들기 전에, 먼저 타겟 y_train과 y_test를 이진 분류에 맞게 바꿔야한다. 즉, 음성 클래스에 해당하는 0과 양성 클래스에 해당하는 1로 바꿔야한다. 아래 코드는 도서권수로 대출건수가 평균보다 높은지 아닌지를 예측하는 이진분류를 하는 코드이다.

borrow_mean = ns_book7['대출건수'].mean()
y_train_c = y_train > borrow_mean
y_test_c = y_test > borrow_mean

from sklearn.linear_model import LogisticRegression

logr = LogisticRegression()
logr.fit(X_train, y_train_c) # 훈련 세트로 fit() 메서드를 호출함
logr.score(X_test, y_test_c) # 검증 세트로 score() 메서드를 호출함

결과

📝 실행 결과를 보면 71%정도를 맞췄다. 나름 괜찮은 결과가 나왔다. 그러나, y_test_c에 있는 음성 클래스와 양성 클래스의 비율이 비슷하지 않다는 문제점이 있다.

✔ 양성 클래스와 음성 클래스 분포 확인해보기

y_test_c.value_counts()

결과

📝 음성 클래스가 69% 정도이고 양성 클래스는 31% 정도이다. 이제 더미모델로 score() 메서드의 결과를 확인해본다.

from sklearn.dummy import DummyClassifier

dc = DummyClassifier()
dc.fit(X_train, y_train_c)
dc.score(X_test, y_test_c)

결과

📝 69% 정도로 정확도가 나왔다. 이 값이 모델을 만들때 기준점이 되는 점수이다. 만약 이 점수보다 낮으면 좋은 모델이라고 하기 어렵다.

3 느낀점

이번 프로젝트를 하면서 데이터 전처리 과정은 형식적인 과정은 딱 정해져 있다는걸 알면서도, 막상 해보면 그 안에서 논리적으로 꼼꼼하게 생각해야 할 것들이 많다고 느꼈다.

그렇지만 이러한 점은 내가 전처리를 많이 해보지 않아서 능숙하지 않기 때문에 어렵다고 느끼는 것이다. 많이 해봐야지 실력이 늘 것이기 때문에 방학기간을 활용해서 파이썬으로 데이터 전처리를 능숙하게 할 수 있도록 연습을 해야겠다. 또, 코딩만 잘하면 되는것이 아니라 모델을 사용할 때 통계적 개념이 거의 필수이기 때문에 통계 공부도 같이 해야겠다고 생각했다. 나는 R데이터분석 수업을 들을때도 로지스틱회귀가 정말 헷갈리고 어려웠는데, 여기서도 하는 데에 애를 먹었었다. 로지스틱회귀는 이번에 실습하면서 80%는 이해한것 같다.

더 나아가서 나는 파이썬보다는 R이 그나마 익숙한데, R로 코드를 작성한 것을 파이썬으로 그대로 작성해 보는 공부를 할 예정이다.

PP-파이프라인

Sun, 03 Dec 2023 13:38:04 GMT

1 파이프라인

1.1 파이프라인 (Pipeline)

여러 개의 데이터의 처리(preprocessor, classifier, regressor, estimator 등)를 하나의 처리과정(pipeline, sequence)으로 만들어 데이터를 일괄처리해 주는 기능
파이프라인을 사용하면 데이터 전처리나 모델 구축 과정 등을 더 짧은 코드로, 더 가시성 있게, 더 효율적으로 처리할 수 있음
다양한 패키지에서 파이프라인을 지원하고 있음
- 데이터 프레임: Pandas, Polars
- 머신러닝: SciKit-Learn
- 딥러닝: TensorFlow, PyTorch

파이프라인 처리 차이

1.2 SciKit-Learn의 파이프라인

SciKit-Learn에서는 Pipeline 클래스를 통해 파이프라인을 구현할 수 있음
- Pipeline 클래스는 여러 개의 추정기(estimator)를 하나의 추정기처럼 사용할 수 있도록 해 줌
파이프라인 사용 목적
- 편의성과 캡슐화
  - 전체 데이터 처리 시퀀스에서 fit과 predict를 한 번만 적용하면 됨
- 통합된 하이퍼 파라미터 최적화
  - grid search를 이용하여 한 번에 하이퍼 파라미터 최적화 가능
- 안전성 강화
  - 교차검증(cross-validation)시 랜덤성에 의한 데이터의 통계적 특성이 변경되는 것을 방지하여 일관성을 유지할 수 있음

1.3 파이프라인을 이용하여 연결형 추정기 만들기

파이프라인을 사용하지 않은 경우

from sklearn.feature_selection import SelectKBest, f_classif # 피처선택 메서드
from sklearn.preprocessing import StandardScaler # 데이터 표준화
from sklearn.tree import DecisionTreeClassifier # 의사결정나무 분류기
from sklearn.datasets import load_iris # iris 데이터세트

# iris 데이터세트 로드
X, y = load_iris(return_X_y=True)

## 피쳐 선택
feat_sel = SelectKBest(f_classif, k=2)
X_selected = feat_sel.fit_transform(X, y)
print('Selected features:', feat_sel.get_feature_names_out())

## 표준화
scaler = StandardScaler()
scaler.fit(X_selected)
X_transformed = scaler.transform(X_selected)
print('Standard Scaled: \n', X_transformed[:5, :])

## 모델 학습
clf = DecisionTreeClassifier(max_depth=3)
clf.fit(X_transformed, y)
print('Estimate : ', clf.predict(X_transformed)[:3])
print('Accuracy : ', clf.score(X_transformed, y))

** ↳ 결과**

파이프라인을 사용한 경우

파이프라인은 (key, value)의 리스트를 구성하여 만듦
파이프라인을 사용하면, 변환된 데이터를 별도로 저장하지 않고 연속적으로 사용하므로 속도가 개선되고 메모리가 절약됨

from sklearn.pipeline import Pipeline # 파이프라인 구성을 위한 함수
from sklearn.feature_selection import SelectKBest, f_classif # 피처선택 메서드
from sklearn.preprocessing import StandardScaler # 데이터 표준화
from sklearn.tree import DecisionTreeClassifier # 의사결정나무 분류기
from sklearn.datasets import load_iris # iris 데이터세트

# iris 데이터세트 로드
X, y = load_iris(return_X_y=True)

## pipeline 구축
pipeline = Pipeline([
    ('Feature_Selection', SelectKBest(f_classif, k=2)), ## 피쳐 선택
    ('Standardization', StandardScaler()),  ## 표준화
    ('Decision_Tree', DecisionTreeClassifier(max_depth=3)) ## 학습 모델
])
display(pipeline) # 파이프라인 그래프로 구성 확인

pipeline.fit(X, y) ## 모형 학습
print('Estimate : ', pipeline.predict(X)[:3]) ## 예측
print('Accuracy : ', pipeline.score(X, y)) ## 성능 평가

** ↳ 결과**

make_pipeline() 함수를 사용하여 파이프라인을 만들 수 있음
- make_pipeline() 함수는 파이프라인의 이름을 자동으로 만들어 줌
- 파이프라인의 이름은 각 추정기의 클래스 이름을 소문자로 바꾼 것과 같음
- 파이프라인의 이름을 지정하려면 Pipeline() 클래스를 사용해야 함

from sklearn.pipeline import make_pipeline # 파이프라인 구성을 위한 함수

pipeline_auto = make_pipeline(SelectKBest(f_classif, k=2), 
              StandardScaler(), 
              DecisionTreeClassifier(max_depth=3))
display(pipeline_auto) # 파이프라인 그래프로 구성 확인

** ↳ 결과**

파이프라인 내부의 중간결과 확인하기
- pipeline의 인덱스나 named_steps로 확인이 가능

# pipiline의 Feature_Selection step의 결과 확인
# pipeline.named_steps['Feature_Selection'] == pipeline[0]
# pipeline.named_steps['Standardization'] == pipeline[1]
# pipeline.named_steps['Decision_Tree'] == pipeline[2]
print('Selected features:', pipeline.named_steps['Feature_Selection'].get_feature_names_out())
X_transformed = pipeline[1].transform(X_selected)
print('Standard Scaled: \n', X_transformed[:5, :])

** ↳ 결과**

2 파이프라인의 결합

2.1 수치형 데이터 파이프라인 처리

import seaborn as sns
import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer

# 데이터 로드
df = sns.load_dataset('diamonds')
print(df.info())
X = df.drop('price', axis=1)
y = df['price']

# 데이터를 유형에 따라 분리
numeric_col = list(X.select_dtypes(exclude='category').columns)
category_col = list(X.select_dtypes(include='category').columns)
print(f'numeric_col: {numeric_col}')
print(f'category_col: {category_col}')

** ↳ 결과**

# 파이프라인 구축
numeric_pipeline = Pipeline(
    steps=[
        ('imputer', SimpleImputer(strategy='mean')), # 평균값으로 Nan값 채워주기
        ('scaler', StandardScaler()) # 표준화
    ])

display(numeric_pipeline) # 파이프라인 그래프로 구성 확인

# 파이프라인 학습
numerical_data_piped = numeric_pipeline.fit_transform(X[numeric_col])
pd.DataFrame(numerical_data_piped, columns=numeric_col).head()

** ↳ 결과**

2.2 범주형 데이터 파이프라인 처리

from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder

# 파이프라인 구축
category_pipeline = Pipeline(
    steps=[
        ('imputer', SimpleImputer(strategy='constant', fill_value='missing')), # 비어있는 값을 'missing'으로 채우기
        ('onehot', OneHotEncoder(sparse_output=False)), # Onehotencoder
    ])

display(category_pipeline) # 파이프라인 그래프로 구성 확인

# 파이프라인 학습
category_data_piped = category_pipeline.fit_transform(X[category_col])
# Onehotencoder의 컬럼명을 확인
category_colnames = category_pipeline[1].get_feature_names_out(category_col)
# 파이프라인 이후 데이터(array형 -> 데이터프레임)
pd.DataFrame(category_data_piped, columns=category_colnames).head()

** ↳ 결과**

2.3 수치형 + 범주형 파이프라인 결합한 파이프라인

ColumnTransformer 클래스를 사용하여 수치형 데이터와 범주형 데이터의 파이프라인을 결합할 수 있음

from sklearn.compose import ColumnTransformer
from sklearn.linear_model import LinearRegression

# numeric & category 파이프라인 합치기
preprocessor = ColumnTransformer(
    transformers=[
        ('numeric', numeric_pipeline, numeric_col),
        ('category', category_pipeline, category_col)
    ])

pipe = make_pipeline(preprocessor, LinearRegression())
display(pipe) # 파이프라인 그래프로 구성 확인
pipe.fit(X,y)

print('Estimate : ', pipe.predict(X))
print('Accuracy : ', pipe.score(X, y))

** ↳ 결과**

2.4 ColumnTransformer

컬럼 기준으로 데이터를 복합하여 처리해주는 함수

from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
import pandas as pd
import numpy as np

data_df = pd.DataFrame({
    "height":[165,  np.nan, 182],
    "weight":[70,   62,     np.nan],
    "age"   :[np.nan,18,    15]
})

# SimpleImputer를 사용해서 height의 null 값들은 평균으로 출력하고 나머지 column은 통과
col_transformer = ColumnTransformer([
    ("Impute_mean", SimpleImputer(strategy="mean"), ["height"])
    ], 
    remainder="passthrough"
)

display(col_transformer) # 파이프라인 그래프로 구성 확인
print(data_df)
print(col_transformer.fit_transform(data_df))

** ↳ 결과**

# SimpleImputer를 사용해서 mean과 median 값을 null에 넣고 
# 나머지 열(column)에 대한 값은 상수로 -1 값을 넣어 줌
col_transformer2 = ColumnTransformer([
    ("Impute_mean"  , SimpleImputer(strategy="mean")  , ["height"]),
    ("Impute_median", SimpleImputer(strategy="median"), ["weight"])
    ],
    remainder=SimpleImputer(strategy="constant", fill_value=-1)
)

display(col_transformer2) # 파이프라인 그래프로 구성 확인
print(data_df)
print(col_transformer2.fit_transform(data_df))

** ↳ 결과**

응용 사례

1.3 make_pipeline( ) 응용

위스콘신 유방암 데이터셋을 활용하여 종양이 악성인지 양성인지 예측하는 모델 만들기

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

👉 pandas를 사용하여 UCI서버에서 직접 데이터셋을 불러옴

from sklearn.preprocessing import LabelEncoder

X = df.loc[:, 2:].values
y = df.loc[:, 1].values
le = LabelEncoder()
y = le.fit_transform(y)
le.classes_

👉 30개의 특성을 넘파이 배열X에 할당 -> LabelEncoder 객체를 사용하여 클래스 레이블을 원본 문자열 표현에서 정수로 변환함

** ↳ 결과**

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

👉 두개의 더미 클래스 레이블 샘플로 LabelEncoder 객체의 transform 메서드를 호출하여 매핑 확인함

** ↳ 결과**

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = \
     train_test_split(X, y,
                      test_size=0.20,
                      stratify=y,
                      random_state=1)

👉 전체 데이터셋을 훈련 데이터셋(전체 데이터의 80%)과 별도의 테스트 데이터셋(전체 데이터의 20%)으로 나눔

from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
pipe_lr = make_pipeline(StandardScaler(),
                         PCA(n_components=2),
                         LogisticRegression(random_state=1))
pipe_lr.fit(X_train, y_train)
y_pred = pipe_lr.predict(X_test)
print('테스트 정확도: %.3f' % pipe_lr.score(X_test, y_test))

👉 훈련 데이터셋과 테스트 데이터셋을 각각 학습하고 변환하는 단계를 구성하는 대신 StandardScaler, PCA, LogisticRegression 객체를 'make_pipeline()' 를 활용하여 하나의 파이프라인으로 연결함

** ↳ 결과**

PP-피쳐엔지니어링

Sun, 03 Dec 2023 13:17:22 GMT

1 피쳐엔지니어링

1.1 피쳐(feature)

데이터 모델(특히, 인공지능)에서 예측을 수행하는 데 사용되는 입력변수를 의미
통계학에서는 독립 변수라고 함

피쳐의 유형

속성에 따라
- 범주형(categorical): 범주나 순위가 있는 변수
- 수치형(numerical): 수치로 표현되는 변수
인과관계에 따라
- 독립변수(independent variable): 다른 변수에 영향을 받지 않고 종속변수에 영향을 주는 변수
- 종속변수(dependent variable): 독립 변수로부터 영향을 받는 변수
머신러닝에서
- 입력(input): 변수(Feature), 속성(Attribute), 예측변수(Predictor), 차원(Dimension), 관측치(Observation), 독립변수(Independent Variable)
- 출력(output): 라벨(Label), 클래스(Class), 목푯값(Target), 반응(Response), 종속변수(Dependent Variable)

1.2 피쳐 엔지니어링(Feature Engineering)

머신러닝 알고리즘의 성능을 향상시키기 위하여 데이터에 대한 도메인 지식을 활용하여 변수를 조합하거나 새로운 변수를 만드는 과정

피쳐 추출(feature extraction)

피쳐들 사이에 내재한 특성이나 관계를 분석하여 이들을 잘 표현할 수 있는 새로운 선형 혹은 비선형 결합 변수를 만들어 데이터를 줄이는 방법
고차원의 원본 피쳐 공간을 저차원의 새로운 피쳐 공간으로 투영
PCA(주성분 분석), LDA(선형 판별 분석) 등

피쳐 선택(feature selection)

피쳐 중 타겟에 가장 관련성이 높은 피쳐만을 선정하여 피쳐의 수를 줄이는 방법
관련없거나 중복되는 피쳐들을 필터링하고 간결한 subset을 생성
모델 단순화, 훈련 시간 축소, 차원의 저주 방지, 과적합(Over-fitting)을 줄여 일반화해주는 장점이 있음
Filter, Wrapper, Embedded 메서드

머신러닝 성능 향상을 위한 방법

피쳐 엔지니어링 적용
머신러닝 알고리즘의 하이퍼 파라미터를 최적화

2 피쳐 추출

2.1 피쳐 추출 (Feature Extraction)

변수들 사이에 내재한 특성이나 관계를 분석하여 이들을 잘 표현할 수 있는 새로운 선형 혹은 비선형 결합 변수를 만들어 데이터를 줄이는 방법
주성분 분석(Principal Component Analysis, PCA)
- 변수들의 공분산 행렬이나 상관행렬을 이용
- 원래 데이터 특징을 잘 설명해주는 성분을 추출하기 이하여 고차원 공간의 표본들을 선형 연관성이 없는 저차원 공간으로 변환하는 기법
- 행의 수와 열의 수가 같은 정방행렬에서만 사용
선형판별분석(Linear Discriminant Analysis, LDA)
- 데이터의 Target값 클래스끼리 최대한 분리할 수 있는 축을 찾음
- 특정 공간상에서 클래스 분리를 최대화하는 축을 찾기 위해 클래스 간 분산(between-class scatter)과 클래스 내부 분산(within-class scatter)의 비율을 최대화하는 방식으로 차원을 축소
특이값 분해(Singular Value Decomposition)
- M X N 차원의 행렬데이터에서 특이값을 추출하고 이를 통해 주어진 데이터 세트를 효과적으로 축약할 수 있는 기법
요인분석(Factor Analysis)
- 데이터 안에 관찰할 수 있는 잠재적인 변수(Latent Variable)가 존재한다고 가정
- 모형을 세운 뒤 관찰 가능한 데이터를 이용하여 해당 잠재 요인을 도출하고 데이터 안의 구조를 해석하는 기법
- 주로 사회과학이나 설문 조사 등에서 많이 활용
독립성분분석(Independent Component Analysis)
- 주성분 분석과는 달리 다변량의 신호를 통계적으로 독립적인 하부성분으로 분리하여 차원을 축소하는 기법
- 독립 성분의 분포는 비정규 분포를 따르게 되는 차원축소 기법
다차원 척도법(Multi-Dimensional Scaling)
- 개체들 사이의 유사성, 비유사성을 측정하여 2차원 또는 3차원 공간상에 점으로 표현하여 개체들 사이의 집단화를 시각적으로 표현하는 분석 방법

2.2 주성분 분석

주성분 분석 (Principal Component Analysis)

가장 널리 사용되는 차원(변수) 축소 기법 중 하나
원 데이터의 분산(variance)을 최대한 보존하면서 서로 직교하는 새 기저(축)를 찾아, 고차원 공간의 표본들을 선형 연관성이 없는 저차원 공간으로 변환하는 기법
PCA는 기존의 변수를 조합하여 서로 연관성이 없는 새로운 변수, 즉 주성분(principal component, PC)들을 만들어 냄
주성분의 개수를 증가시킴에 따라 원 데이터의 분산의 보존수준이 높아짐

PCA 절차

학습 데이터셋에서 분산이 최대인 축(axis)을 찾음
첫번째 축과 직교(orthogonal)하면서 분산이 최대인 두 번째 축을 찾음
첫 번째 축과 두 번째 축에 직교하고 분산을 최대한 보존하는 세 번째 축을 찾음
1~3과 같은 방법으로 데이터셋의 차원(특성 수)만큼의 축을 찾음

2.3 선형판별분석

선형판별분석(Linear Discriminant Analysis, LDA)

입력 데이터 세트를 저차원 공간으로 투영(projection)해 차원을 축소하는 기법
데이터의 Target값 클래스끼리 최대한 분리할 수 있는 축을 찾음 → 지도 학습
PCA는 Target값을 사용하지 않으므로 비지도 학습

LDA 절차

특정 공간상에서 클래스 분리를 최대화하는 축을 찾기 위해 클래스 간 분산(between-class scatter)과 클래스 내부 분산(within-class scatter)의 비율을 최대화하는 방식으로 차원을 축소
SVM 같은 다른 분류 알고리즘을 적용하기 전에 차원을 축소시키는 데 사용

2.4 Scikit-Learn으로 PCA와 LDA 수행하기

from sklearn import datasets
from sklearn.decomposition import PCA
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis

# iris 데이터셋을 로드
iris = datasets.load_iris()

X = iris.data # iris 데이터셋의 피쳐들
y = iris.target # iris 데이터셋의 타겟
target_names = list(iris.target_names) # iris 데이터셋의 타겟 이름

print(f'{X.shape = }, {y.shape = }') # 150개 데이터, 4 features
print(f'{target_names = }')

↳ 결과

# PCA의 객체를 생성, 차원은 2차원으로 설정(현재는 4차원)
pca = PCA(n_components=2)

# PCA를 수행. PCA는 비지도 학습이므로 y값을 넣지 않음
pca_fitted = pca.fit(X)

print(f'{pca_fitted.components_ = }')  # 주성분 벡터
print(f'{pca_fitted.explained_variance_ratio_ = }') # 주성분 벡터의 설명할 수 있는 분산 비율

X_pca = pca_fitted.transform(X) # 주성분 벡터로 데이터를 변환
print(f'{X_pca.shape = }')  # 4차원 데이터가 2차원 데이터로 변환됨

↳ 결과

# LDA의 객체를 생성. 차원은 2차원으로 설정(현재는 4차원)
lda = LinearDiscriminantAnalysis(n_components=2)

# LDA를 수행. LDA는 지도학습이므로 타겟값이 필요
lda_fitted = lda.fit(X, y)

print(f'{lda_fitted.coef_=}') # LDA의 계수
print(f'{lda_fitted.explained_variance_ratio_=}') # LDA의 분산에 대한 설명력

X_lda = lda_fitted.transform(X)
print(f'{X_lda.shape = }')  # 4차원 데이터가 2차원 데이터로 변환됨

↳ 결과

# 시각화 하기
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd

# Seaborn을 이용하기 위해 데이터프레임으로 변환
df_pca = pd.DataFrame(X_pca, columns=['PC1', 'PC2'])
df_lda = pd.DataFrame(X_lda, columns=['LD1', 'LD2'])
y = pd.Series(y).replace({0:'setosa', 1:'versicolor', 2:'virginica'})

# subplot으로 시각화
fig, ax = plt.subplots(1, 2, figsize=(10, 4))

sns.scatterplot(df_pca, x='PC1', y='PC2', hue=y, style=y, ax=ax[0], palette='Set1')
ax[0].set_title('PCA of IRIS dataset')

sns.scatterplot(df_lda, x='LD1', y='LD2', hue=y, style=y, ax=ax[1], palette='Set1')
ax[1].set_title('LDA of IRIS dataset')

plt.show()

↳ 결과

3 피쳐 선택 기법

종속변수 활용여부에 따라
- Supervised: 종속변수를 활용하여 선택
- Unsupervised: 독립변수들 만으로 선택
선택 메커니즘에 따라
- Filter: 통계적인 방법으로 선택
- Wrapper: 모델을 활용하여 선택
- Embedded: 모델 훈련 과정에서 자동으로 선택
- Hybrid: Filter + Wrapper

3.1 필터 기법(Filter Method)

필터기법의 종류

분산 기반 선택(Variance-based Selection)
- 분산이 낮은 변수를 제거하는 방법
정보 소득(Information Gain)
- 가장 정보 소득이 높은 속성을 선택하여 데이터를 더 잘 구분하게 되는 것
카이제곱 검정(Chi-Square Test)
- 카이제곱 분포에 기초한 통계적 방법으로 관찰된 빈도가 기대되는 빈도와 의미있게 다른지 여부를 검증하기 위해 사용되는 검증 방법
피셔 스코어(Fisher Score)
- 최대 가능성 방정식을 풀기 위해 통계에 사용되는 뉴턴(Newton)의 방법
상관계수(Correlation Coefficient)
- 두 변수 사이의 통계적 관계를 표현하기 위해 특정한 상관관계의 정도를 수치적으로 나타낸 계수

분산 기반 선택(Variance-based Selection)

from sklearn import datasets
from sklearn.feature_selection import VarianceThreshold

# iris 데이터셋을 로드
iris = datasets.load_iris()

X = iris.data # iris 데이터셋의 피쳐들
y = iris.target # iris 데이터셋의 타겟
X_names = iris.feature_names # iris 데이터셋의 피쳐 이름
y_names = iris.target_names # iris 데이터셋의 타겟 이름

# 분산이 0.2 이상인 피쳐들만 선택하도록 학습
sel = VarianceThreshold(threshold=0.2).fit(X)
print(f'{sel.variances_ = }') # 각 피쳐의 분산 확인

# 분산이 0.2 이상인 피쳐들만 선택 적용
X_selected = sel.transform(X) # 분산이 0.2 이상인 피쳐들만 선택
X_selected_names = [X_names[i] for i in sel.get_support(indices=True)] # 선택된 피쳐들의 이름

print(f'{X_selected_names = }')
print(f'{X_selected[:5] = }')

↳ 결과

Scikit-Learn 제공 피쳐 선택 메서드

SelectKBest(): 고정된 k개의 피쳐 선택기
SelectPercentile(): 분위수 기반 선택기
SelectFpr(): False positive rate 기반 선택기
SelectFdr(): 추정된 False discovery rate 기반 선택기
SelectFwe(): familiy-wise error rate 기반 선택기
GenericUnivariateSelect(): 단변량 피쳐 선택기

Scikit-Learn 제공 피쳐 선택 기준

f_classif: ANOVA F-value 분류
mutual_info_classif: 상호정보량(mutual information) 분류
chi2: 카이제곱 분류
f_regression: F-value 회귀
mutual_info_regression: 상호정보량(mutual information) 회귀

F-value

두 모집단(확률변수)의 분산의 비율을 나타내는 값
ANOVA, Regression에서는 모형이 설명하는 분산/잔차의 분산
- F-value가 크면 모형이 잘 설명하고 있다는 의미

상호정보량(mutual information)

하나의 확률변수가 다른 하나의 확률변수에 대해 제공하는 정보의 양
두 확률변수가 공유하는 엔트로피
- 두 확률변수가 독립이라면, 상호정보량은 0
- 두 확률변수의 상관관계가 강할수록 상호정보량이 커짐

χ2-test

범주형 데이터에서 두 요인간 독립성 검정에서 사용
- χ2-value가 크면 두 요인간 독립이 아니라는 의미(즉, 상관관계가 있음)

from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import f_classif, f_regression, chi2

# k개의 베스트 피쳐를 선택
sel_fc = SelectKBest(f_classif, k=2).fit(X, y)
print('f_classif: ')
print(f'{sel_fc.scores_ = }')
print(f'{sel_fc.pvalues_ = }')
print(f'{sel_fc.get_support() = }')
print('Selected features: ', [X_names[i] for i in sel_fc.get_support(indices=True)]) # 선택된 피쳐들의 이름

sel_fr = SelectKBest(f_regression, k=2).fit(X, y)
print('\nf_regression: ')
print(f'{sel_fr.scores_ = }')
print(f'{sel_fr.pvalues_ = }')
print(f'{sel_fr.get_support() = }')
print('Selected features: ', [X_names[i] for i in sel_fr.get_support(indices=True)]) # 선택된 피쳐들의 이름

sel_chi2 = SelectKBest(chi2, k=2).fit(X, y)
print('\nchi2: ')
print(f'{sel_chi2.scores_ = }')
print(f'{sel_chi2.pvalues_ = }')
print(f'{sel_chi2.get_support() = }')
print('Selected features: ', [X_names[i] for i in sel_chi2.get_support(indices=True)]) # 선택된 피쳐들의 이름

↳ 결과

3.2 래퍼 기법(Wrapper Method)

변수 선택을 위한 알고리즘

전진 선택법(Forward Selection)
- 모형을 가장 많이 향상시키는 변수를 하나씩 점진적으로 추가하는 방법
후진 제거법(Backward Elimination)
- 모두 포함된 상태에서 시작하여 가장 적은 영향을 주는 변수부터 하나씩 제거
단계적 방법(Stepwise Method)
- 전진선택과 후향제거의 결합
- 각 단계에서 최상의 속성을 선택하고 나머지 속성 중 최악의 속성을 제거하는 과정을 실행
의사결정트리

래퍼기법의 종류

RFE(Recursive Feature Elimination)
- SVM(Support Vector Machine)을 사용하여 재귀적으로 제거하는 방법
- 전진 선택, 후진 제거, 단계적 방법 사용
SFS(Sequential Feature Selection)
- 그리디 알고리즘(Greedy Algorithm)으로 빈 부분 집합에서 특성 변수를 하나씩 추가하는 방법
- 전진 선택, 후진 제거 사용

# RFE(Recursive Feature Elimination) 적용
from sklearn.datasets import load_iris
from sklearn.feature_selection import RFE, RFECV, SelectFromModel, SequentialFeatureSelector
from sklearn.svm import SVC, SVR

# iris 데이터셋 로드
X, y = load_iris(return_X_y=True)

# 분류기 SVC 객체 생성, 선형분류, 3개의 클래스 
svc = SVR(kernel="linear", C=3)

# RFE 객체 생성, 2개의 피쳐 선택, 1개씩 제거 
rfe = RFE(estimator=svc, n_features_to_select=2, step=1)
# RFE+CV(Cross Validation), 5개의 폴드, 1개씩 제거
rfe_cv = RFECV(estimator=svc, step=1, cv=5) 

# 데이터셋에 RFE 적용
rfe.fit(X, y)
print('RFE Rank: ', rfe.ranking_)

# rank가 1인 피쳐들만 선택
X_selected = rfe.transform(X) 
X_selected_names = [X_names[i] for i in rfe.get_support(indices=True)] # 선택된 피쳐들의 이름

print(f'{X_selected_names = }')
print(f'{X_selected[:5] = }')

# 데이터셋에 RFECV 적용
rfe_cv.fit(X, y)
print('RFECV Rank: ', rfe_cv.ranking_)

# rank가 1인 피쳐들만 선택
X_selected = rfe_cv.transform(X) 
X_selected_names = [X_names[i] for i in rfe_cv.get_support(indices=True)] # 선택된 피쳐들의 이름

print(f'{X_selected_names = }')
print(f'{X_selected[:5] = }')

↳ 결과

# SFS(Sequential Feature Selector) : 순차적으로 특성을 선택하는 방법

from sklearn.feature_selection import SequentialFeatureSelector
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris

# 데이터를 로드하고, 분류기를 초기화한 후 SFS를 적용
X, y = load_iris(return_X_y=True)
knn = KNeighborsClassifier(n_neighbors=3)
sfs = SequentialFeatureSelector(knn, n_features_to_select=2, direction='backward')

# SFS를 학습하고, 선택된 특성을 출력
sfs.fit(X, y)
print('SFS selected: ', sfs.get_support())

# 선택된 피쳐들만 선택
X_selected = sfs.transform(X) 
X_selected_names = [X_names[i] for i in sfs.get_support(indices=True)] # 선택된 피쳐들의 이름

print(f'{X_selected_names = }')
print(f'{X_selected[:5] = }')

↳ 결과

3.3 임베디드 기법(Embedded Method)

임베디드 기법의 종류

SelectFromModel
- 의사결정나무 기반 알고리즘에서 변수를 선택하는 기법

from sklearn.feature_selection import SelectFromModel
from sklearn import tree
from sklearn.datasets import load_iris

# 데이터를 로드하고, 분류기를 초기화한 후 SFS를 적용
X, y = load_iris(return_X_y=True)
clf = tree.DecisionTreeClassifier()
sfm = SelectFromModel(estimator=clf)

# 모형 구조 확인 및 출력을 pandas로 설정
sfm.set_output(transform='pandas')

↳ 결과

# 모형 학습
sfm.fit(X, y)
print('SFM threshold: ', sfm.threshold_)

# 선택된 피쳐들만 선택
X_selected = sfm.transform(X) 
X_selected.columns = [X_names[i] for i in sfm.get_support(indices=True)] # 선택된 피쳐들의 이름

X_selected.head()

↳ 결과

응용 사례

2.2 주성분 분석(PCA) 응용

PCA는 다양한 분야에서 사용된다. 주식이나 금융 분야에서도 PCA는 다양하게 쓰인다. 미국과 일본, 유럽, 한국의 과거 20년간의 주가를 살펴보는 예시에서 PCA가 사용된다.

pd.core.common.is_list_like = pd.api.types.is_list_like
import pandas_datareader.data as web
import datetime

symbols = [
    "SPASTT01USM661N", # US: 미국
    "SPASTT01JPM661N", # JP: 일본
    "SPASTT01EZM661N", # EZ: 유럽
    "SPASTT01KRM661N", # KR: 한국
]

data = pd.DataFrame()
for sym in symbols:
    data[sym] = web.DataReader(sym, data_source='fred', 
                               start=datetime.datetime(1998, 1, 1),
                               end=datetime.datetime(2017, 12, 31))[sym]
data.columns = ["US", "JP", "EZ", "KR"]
data = data / data.iloc[0] * 100

styles = ["b-.", "g--", "c:", "r-"]
data.plot(style=styles)
plt.title("세계 주요국의 20년간의 주가")
plt.show()

↳ 결과

# 세계 주가의 공통요인은 평균값으로 구할수 있음
m = pca2.mean_
m

↳ 결과

# 나라별로 주가를 다르게 하는 요인은 '주성분' 으로 구할 수 있음
p1 = pca2.components_[0]
p1

↳ 결과

PP-인코딩과 범주화

Sun, 03 Dec 2023 12:22:40 GMT

1 인코딩

1.1 인코딩(Encoding)

많은 실제 데이터셋에는 수치형(numerical)과 범주형(categorical) 변수가 혼재하고 있음
인코딩은 컴퓨터가 처리하기 용이하도록 기존의 데이터를 변경하는 것
- 범주형 데이터는 일반적으로 텍스트(string)로 되어 있으므로 이를 숫자(일반적으로 양의 정수)로 변환 → 레이블 인코딩(Label encoding)
- 분류(classification) 문제에서는 종속변수가 범주형이어야 하므로 수치형(numerical) 데이터는 범주형으로 변환해주어야 함 -> 이진화(Binarizsaztion), 이산화(Discretization)
- 회귀(regression) 모형이나 신경망에서는 독립변수는 수치형 변수이어야 하므로 범주형 변수를 수치형으로 변환해주어야 함 → 원핫인코딩(One-hot encoding), 더미변수화(Dummy encoding)
- 텍스트 데이터는 자연어 처리를 위해 토큰화(tokenization) 과정을 거쳐야 함 → 정수인코딩(Integer encoding)
인코딩된 코드를 원래의 데이터로 변환하는 것은 디코딩(Decoding)이라고 함

인코딩의 장단점

1.2 인코딩 분류

1. 범주형 데이터 -> 이산 수치형 데이터

OrdinalEncoder() (1:1)
- 범주형 데이터를 정수로 인코딩
- 여러 컬럼(독립변수)에 사용 가능
LabelEncoder() (1:1)
- 범주형 데이터를 정수로 인코딩
- 하나의 컬럼(종속변수, 타겟)에만 사용 가능
TargetEncoder() (1:1)
- 범주형 데이터를 특정한 컬럼(타겟)의 값의 크기와 비례한 숫자로 인코딩

2. 범주형 데이터 -> 이진 데이터

One-hot encoding (1:M)
- 하나의 컬럼에 있는 범주형 데이터를 여러개의 이진수 컬럼(수치형 데이터)로 인코딩
- one-of-K 인코딩이라고도 함
Dummy encoding (1:M)
- One-hot encoding과 동일한 기능
- 회귀분석에서 범주형 변수를 고려할 때 사용
  3. 연속 수치형 데이터 -> 이진 데이터
Binarizer() (1:1)
- 연속 수치형 데이터를 기준값(threshold)을 기준으로 이진수로 인코딩
LabelBinarizer() (1:M)
- 연속형 데이터를 이진수 컬럼으로 인코딩
- 하나의 컬럼(종속변수, 타겟)에만 사용 가능
MultiLabelBinarizer() (1:M)
- multi-class(여러개의 범주가 있는) 데이터를 이진수 컬럼으로 인코딩
- 하나의 컬럼(종속변수, 타겟)에만 사용 가능

2 인코딩 방법

2.1 범주형 데이터 -> 이산 수치형 데이터

테스트를 위한 데이터 세트 생성하기

import pandas as pd

df = pd.DataFrame({'weight':[40, 80, 60, 50, 90], # feature: weight, continuous
                   'height':[162, 155, 182, 173, 177], # feature: height, continuous
                   'sex':['f', 'm', 'm', 'f', 'm'], # feature: sex, categorical
                   'blood_type':['O', 'A', 'B', 'O', 'A'], # feature: blood_type, categorical
                   'health':['good', 'excellent', 'bad', 'bad', 'good'], # target: health, categorical
                   })
df

↳ 결과

OrdinalEncoder

범주형 데이터를 정수로 인코딩

여러 컬럼(독립변수)에 사용 가능

from sklearn.preprocessing import OrdinalEncoder

데이터프레임 복사

df_oe = df.copy()

OrdinalEncoder에 대한 객체 생성

oe = OrdinalEncoder()

데이터로 oe 학습

oe.fit(df)

학습된 결과

print(f'{oe.categories_=}')

OrdinalEncoder는 수치형 weight와 height도 범주형으로 인식하여 변경하므로 주의

학습된 결과를 적용하여 변환

df_oe = pd.DataFrame(oe.transform(df), columns=df.columns) df_oe

**↳ 결과**
![](https://velog.velcdn.com/images/__zeroiszero/post/00797c3a-6ac2-4517-91e5-d9e59a004112/image.png)

```{python}
# OrdinalEncoder 수정된 사용

# 데이터프레임 복사
df_oe = df.copy()

# OrdinalEncoder에 대한 객체 생성
oe = OrdinalEncoder()

# 데이터로 oe 학습
oe.fit(df[['sex', 'blood_type']])

# 학습된 결과 
print(f'{oe.categories_=}')

# 학습된 결과를 적용하여 삽입
df_oe.iloc[:,2:4] = oe.transform(df[['sex', 'blood_type']])
df_oe

↳ 결과

# 디코딩(decoding)
oe.inverse_transform(df_oe.iloc[:,2:4])

↳ 결과

LabelEncoder

범주형 데이터를 정수로 인코딩
하나의 컬럼(종속변수, 타겟)에만 사용 가능

from sklearn.preprocessing import LabelEncoder

# 데이터프레임 복사
df_le = df.copy()

# LabelEncoder는 하나의 변수에 대해서만 변환 가능
# LabelEncoder 객체 생성과 fit을 동시에 적용
health_le = LabelEncoder().fit(df.health)
df_le['health'] = health_le.transform(df.health)
df_le

↳ 결과

# fit_transform() 메서드를 사용하여 한번에 인코딩 수행가능

# 데이터프레임 복사
df_le = df.copy()

# LabelEncoder 객체 생성과 fit을 동시에 적용
df_le['health'] = LabelEncoder().fit_transform(df.health)
df_le

↳ 결과

TargetEncoder 적용

범주형 데이터를 특정한 컬럼(타겟)의 값의 크기와 비례한 숫자로 인코딩

from sklearn.preprocessing import TargetEncoder

# 데이터프레임 복사
df_te = df.copy()

# TargetEncoder에 대한 객체 생성
# smooth는 정밀도를 조정하고 target_type은 인코딩 타입을 지정
te = TargetEncoder(smooth=0, target_type='continuous')

# 데이터로 te 학습
# 타겟을 weight라고 가정하고 blood_type을 인코딩
# blood_type_target은 weight와 비례하여 인코딩된 값
# 인코딩이 되는 값은 2차원으로 변환해야 함
te.fit(df['blood_type'].values.reshape(-1, 1), df.weight)

# 학습된 결과 
print(f'{te.categories_=}')

# 학습된 결과를 적용하여 새로운 컬럼 삽입
df_te['blood_type_target'] = te.transform(df['blood_type'].values.reshape(-1, 1))
df_te

↳ 결과

2.2 범주형 데이터 → 이진 데이터

원핫인코딩(One-Hot-Encoding)

하나의 컬럼에 있는 범주형 데이터를 여러개의 이진수 컬럼(수치형 데이터)로 인코딩
one-of-K 인코딩이라고도 함

from sklearn.preprocessing import OneHotEncoder

# 데이터프레임 복사
df_ohe = df.copy()

# OneHotEncoder에 대한 객체 생성 후 fit
ohe = OneHotEncoder().fit(df_ohe[['blood_type']])

# 학습된 결과 
print(f'{ohe.categories_=}')

# 학습된 결과를 적용하여 새로운 컬럼 삽입
# OneHotEncoder는 결과를 sparse matrix로 반환하므로 toarray()를 통해 ndarray로 변환
df_ohe[ohe.categories_[0]] = ohe.transform(df_ohe[['blood_type']]).toarray()
df_ohe

↳ 결과

Dummy encoding

Pandas에서 제공하는 get_dummies는 One-hot encoding과 동일한 기능
- 여러 컬럼을 한 번에 변환 가능
회귀분석에서 범주형 변수를 고려할 때 사용

pd.get_dummies(df, columns=['sex', 'blood_type'], drop_first=False)

↳ 결과

2.3 연속 수치형 데이터 → 이진 데이터

Binerizer

from sklearn.preprocessing import Binarizer

# 데이터 불러오기
df_bin = df.copy()

# Binarizer 객체 생성과 fit, transform을 동시에 적용
# Binarizer는 수치형 변수에 대해서만 변환 가능
df_bin['weight_bin'] = Binarizer(threshold=50).fit_transform(df.weight.values.reshape(-1,1))
df_bin['height_bin'] = Binarizer(threshold=170).fit_transform(df.height.values.reshape(-1,1))
df_bin

↳ 결과

LabelBinerizer

연속형 데이터를 이진수 컬럼으로 인코딩
하나의 컬럼(종속변수, 타겟)에만 사용 가능

from sklearn.preprocessing import LabelBinarizer

# 데이터프레임 복사
df_lb = df.copy()

# LabelBinarizer 객체 생성과 fit을 적용
lb = LabelBinarizer().fit(df.health)

# lb.classes_ : LabelBinarizer가 인코딩한 클래스 확인
print(f'{lb.classes_ = }')

# lb.transform() : 인코딩 변환
health_lb = lb.transform(df.health)
print('health_lb = \n', health_lb)

# 인코딩된 데이터를 데이터프레임으로 변환
df_lb[lb.classes_] = health_lb
df_lb

↳ 결과

MultiLabelBinerizer

multi-class(여러개의 범주가 있는) 데이터를 이진수 컬럼으로 인코딩
하나의 컬럼(종속변수, 타겟)에만 사용 가능

from sklearn.preprocessing import MultiLabelBinarizer

# 데이터프레임 복사
df_mlb = df.copy()

# multi-class를 위한 컬럼 추가
df_mlb['test'] = [['math', 'english'], ['math', 'science'], ['science'], ['math', 'english'], 
                           ['science']] # target: test, categorical, multi-class
df_mlb

↳ 결과

# MultiLabelBinarizer 객체를 생성하고 fit() 메소드를 호출하여 클래스를 인코딩
mlb = MultiLabelBinarizer().fit(df_mlb.test)

# classes_ 속성을 사용하면 어떤 클래스가 인코딩되었는지 확인 가능
print(f'{mlb.classes_ = }')

# 인코딩된 데이터를 데이터프레임으로 변환
df_mlb[mlb.classes_] = mlb.transform(df_mlb.test)
df_mlb

↳ 결과

3 범주화

3.1 범주화 (Discritization)

연속형 변수를 구간별로 나누어 범주형 변수로 변환하는 것
quantization 또는 binning이라고도 함

K-bins discretization

from sklearn.preprocessing import KBinsDiscretizer

# 데이터프레임 복사
df_kbd = df.copy()

# KBinsDiscretizer 객체 생성과 fit을 적용
kbd = KBinsDiscretizer(n_bins=3, encode='ordinal').fit(df[['weight', 'height']])

# kbd.transform() : 인코딩 변환
# 인코딩된 데이터를 데이터프레임으로 변환
df_kbd[['weight_bin', 'height_bin']] = kbd.transform(df[['weight', 'height']])
df_kbd

↳ 결과

응용 사례

2.2의 원핫인코딩(One-Hot-Encoding) 응용

# 필요한 패키지 임포트
import numpy as np 
import pandas as pd

from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer, make_column_transformer

# pandas로 데이터프레임 생성
df = pd.DataFrame([
    [2,1,'male','A',3],
    [3,2,'female','C',5],
    [3,4,'male','B',7],
    [5,5,'female','A',10],
    [7,5,'female','B',12],
    [2,5,'male','A',7],
    [9,2,'male','C',13]
], columns=['hours', 'attendance', 'sex', 'cate', 'score'])

from sklearn.preprocessing import OneHotEncoder
ohe = OneHotEncoder(sparse=False) # OneHotEncoder에 대한 객체를 생성

ohe.fit(df[['sex']]) # 위에서 객체 생성후 fit
print(ohe.transform(df[['sex']])) # 학습된 결과를 적용하여 새로운 컬럼 삽입
'''
[[0. 1.]
 [1. 0.]
 [0. 1.]
 [1. 0.]
 [1. 0.]
 [0. 1.]
 [0. 1.]]
'''

ohe.fit(df[['cate']])
print(ohe.transform(df[['cate']]))
'''
[[1. 0. 0.]
 [0. 0. 1.]
 [0. 1. 0.]
 [1. 0. 0.]
 [0. 1. 0.]
 [1. 0. 0.]
 [0. 0. 1.]]
'''

↳ 결과

PP-스케일링

Sat, 18 Nov 2023 12:00:38 GMT

1 Scikit-Learn

1.1 Scikit-Learn

python을 대표하는 머신러닝 라이브러리
매우 다양한 전처리 도구와 알고리즘을 제공하고 있어 머신러닝 기법을 배우는 데 적합
- 분류, 회귀, 클러스터링, 차원 축소 등을 포함한 광범위한 머신러닝 알고리즘을 제공
- 예제와 사용 설명서가 잘 되어있어 참고하여 코드를 작성하기 용이
데이터 분석을 위한 간단하고 효율적인 도구를 제공
- 간단하고 직관적인 API를 제공하므로 다양한 수준의 전문 지식을 가진 사용자가 접근 가능
  - fit(), transform(), predict() 등 체계적이고 일관된 분석 및 학습모형 운용 체계를 갖추고 있음
- 다른 많은 패키지도 scikit-learn과 동일한 체계를 제공하여 유사한 프레임에서 사용이 가능
NumPy, Pandas, SciPy 및 matplotlib를 기반으로 구축되어 있어 다른 파이썬 패키지와 함께 사용하기 용이
- NumPy: 다차원 배열을 위한 기본 패키지
- Pandas: 데이터프레임을 위한 기본 패키지
- SciPy: 과학 계산용 함수를 모아놓은 패키지
- matplotlib: 데이터 시각화를 위한 패키지
단점
- 딥러닝, 강화학습, 시계열 모형은 매우 약함
- 최근 개발된 대용량을 위한 데이터프레임인 Polars와 같은 라이브러리와는 연동이 잘 안됨

1.2 Scikit-Learn의 주요 기능

분류: 로지스틱 회귀, 결정 트리, 서포트 벡터 머신(SVM)
회귀: 선형 회귀, 릿지 회귀 등
군집화: k-평균 군집화, 계층적 군집화 등
차원 축소: 주성분 분석(PCA), t-분산 확률적 이웃 내재화(t-SNE) 등
전처리: 데이터 정규화, 스케일링, 인코딩 등

2 Scikit-Learn Preprocessing

Scikit-learn의 전처리 기능은 크게 4가지로 나눌 수 있음
- 스케일링(scaling): 서로 다른 변수의 값 범위를 일정한 수준으로 맞추는 것
- 이진화(binarization): 연속적인 값을 0 또는 1로 나누는 것, 연속형 변수 → 이진형 변수
- 인코딩(encodig): 범주형 값을 적절한 숫자형으로 변환하는 작업, 범주형 변수 → 수치형 변수
- 변환(transformation): 데이터의 분포를 변환하여 정규성을 확보하는 것

2.1 스케일링(Scaling)

서로 다른 변수(feature)의 값 범위를 선형변환을 통하여 일정한 수준으로 맞추는 작업
- 독립변수(feature)별로 값의 변위가 상이하면
  - 종속변수(target)에 대한 영향이 독립변수의 변위에 따라 크게 달라짐 → 머신러닝 시 학습효과가 떨어짐
- 다차원의 값들을 동일한 수준에서 비교 분석하기 용이하게 만들어 줌
- 컴퓨터의 비트수로 인하여 다른 값으로 인식되는 오버플로우(overflow)나 언더플로우(underflow)를 방지
- 최적화 과정에서의 안정성 및 수렴 속도를 향상
- 특히 k-means 등 거리 기반의 모델에서는 스케일링이 매우 중요
표준화, 정규화, 변환이 있음
- 표준화(Standardization) → 표준분포화(평균을 0, 분산을 1 로 스케일링)
  - StandardScaler(): 기본 스케일러, 평균과 표준편차 사용
  - RobustScaler(): 중앙값과 IQR(Q3-Q1)을 사용. 이상치의 영향을 최소화
- 정규화(Normalization) → 규격화(특정 범위(주로 [0,1]) 로 스케일링)
  - MinMaxScaler(): 범위가 [0,1]이 되도록 스케일링
  - MaxAbsScaler(): 양수는 [0,1], 음수는 [-1,0], 양음수는 [-1,1]이 되도록 스케일링
- 변환(Transformation)(특정한 분포나 모양을 따르도록 스케일링)
  - PowerTransformer(): 정규분포화(Box-Cox 변환, Yeo-Johnson 변환)
  - QuantileTransformer(): 균일(Uniform)분포 또는 정규(Gaussian)분포로 변환
  - Normalizer(): 한 행의 모든 피처들 사이의 유클리드 거리가 1이 되도록 변환

2.2 스케일링 절차

✍ Scaler 객체를 이용

fit(): 주어진 데이터에 맞추어 학습
- 데이터 변환을 위한 기준 정보 설정을 적용 (ex) 최소값, 최대값 등)
transform(): Scaler 적용, fit()된 정보를 이용해 데이터를 변환
fit_transform() : fit()과 transform()을 한 번에 실행

✍ 훈련 데이터와 평가 데이터의 스케일링 변환 시 유의점

훈련 데이터는 fit()과 transform() 모두 적용
- 평가 데이터는 fit()은 필요없으므로 transform()만 적용해야 함
- 훈련 데이터로 fit()된 스케일링 기준 정보를 그대로 테스트에 적용해야하기 때문

2.3 표준화(Standardization)

표준화를 하면, 서로 다른 통계 데이터들을 비교하기 용이함
- 평균은 0, 분산과 표준편차는 1이 되므로 데이터의 분포가 단순화되어 독립변수간 데이터 수준의 비교가 용이
- RBF(Radial Basis Function) 커널을 이용하는 서포트 벡터 머신(Support Vector Machine), 선형회귀(Linear Regression), 로지스틱 회귀(Logistic Regression)는 데이터가 정규분포를 가지고 있다고 가정하고 구현됨
  - RBF Kernel: Gaussian kernel, 가우시안 방사 기저 함수
이상치에 민감하며, 분류보다는 회귀에 유용

✍ 데이터 로드

import pandas as pd
import seaborn as sns

# Pandas 소수점 4째자리 이하에서 반올림
pd.set_option('display.float_format', lambda x: f'{x:.4f}')

# iris 데이터 로드
iris = sns.load_dataset('iris')

# iris의 수치형 변수만 선택
iris = iris.select_dtypes(exclude='object')

# iris의 기술통계량을 확인
iris.describe()

# sepal_lengh와 petal_length의 jointplot을 그림
sns.jointplot(data=iris, x='petal_length', y='petal_width', kind='reg')

↳ 결과

✍ 표준화

from sklearn.preprocessing import StandardScaler, RobustScaler

# Scaler 객체 생성
standard_scaler = StandardScaler()
robust_scaler = RobustScaler()

# 데이터 변환
iris_standard = pd.DataFrame(standard_scaler.fit_transform(iris), columns=iris.columns)
iris_robust = pd.DataFrame(robust_scaler.fit_transform(iris), columns=iris.columns)

# 결과 출력
print('Standard Scaled: \n', iris_standard.describe()) # mean = 0, std = 1
print()
print('Robust Scaled: \n', iris_robust.describe()) # median = 0, IQR = 1

↳ 결과

위에서 seaborn의 jointplot은 figure의 axes를 지정할 수 없어 subplot을 그리기가 어려움
patchworklib 패키지8을 사용하여 subplot을 그림
- 설치 : conda install patchworklib

pip install patchworklib

# 그래프로 확인
import seaborn as sns
import patchworklib as pw
pw.overwrite_axisgrid()

# 첫번째 그래프 
g1 = sns.jointplot(data=iris_standard, x='petal_length', y='petal_width', kind='reg')
g1 = pw.load_seaborngrid(g1)
g1.set_suptitle("Standard Scaled")

# 두번째 그래프 
g2 = sns.jointplot(data=iris_robust, x='petal_length', y='petal_width', kind='reg')
g2 = pw.load_seaborngrid(g2)
g2.set_suptitle("Robust Scaled")

# 그래프 합치기
g12 = (g1|g2)
g12

↳ 결과

2.4 정규화(Normalization)

MinMaxScaler(): 범위가 [0,1]이 되도록 스케일링
MaxAbsScaler()
- 모든 값이 양수이면, 범위가 [0,1]이 되도록 스케일링, MinMaxScaler()와 유사
- 모든 값이 음수이면, 범위가 [-1,0]이 되도록 스케일링
- 양수와 음수가 혼재하면, 범위가 [-1,1]이 되도록 스케일링

from sklearn.preprocessing import MinMaxScaler, MaxAbsScaler

# Scaler 객체 생성
minmax_scaler = MinMaxScaler()
maxabs_scaler = MaxAbsScaler()

# 데이터 변환
iris_minmax = pd.DataFrame(minmax_scaler.fit_transform(iris), columns=iris.columns)
iris_maxabs = pd.DataFrame(maxabs_scaler.fit_transform(iris), columns=iris.columns)

# 결과 출력
print('MinMax Scaled: \n', iris_minmax.describe()) # min = 0, max = 1
print()
print('MaxAbs Scaled: \n', iris_maxabs.describe()) # min ~ 0, max = 1

↳ 결과

# 세번째 그래프 
g3 = sns.jointplot(data=iris_minmax, x='petal_length', y='petal_width', kind='reg')
g3 = pw.load_seaborngrid(g3)
g3.set_suptitle("MinMax Scaled")

# 네번째 그래프 
g4 = sns.jointplot(data=iris_maxabs, x='petal_length', y='petal_width', kind='reg')
g4 = pw.load_seaborngrid(g4)
g4.set_suptitle("MaxAbs Scaled")

# 그래프 합치기
g34 = (g3|g4)
g34

↳ 결과

2.5 변환(Transformation)

PowerTransformer(): 정규성 변환(Box-Cox 변환, Yeo-Johnson 변환)
QuantileTransformer(): 균일(Uniform)분포 또는 정규(Gaussian)분포로 변환
Normalizer(): 한 행의 모든 피처들 사이의 유클리드 거리가 1이 되도록 변환

import numpy as np
from sklearn.preprocessing import PowerTransformer, Normalizer

# Scaler 객체 생성
power_scaler = PowerTransformer()
normal_scaler = Normalizer()

# 데이터 변환
iris_power = pd.DataFrame(power_scaler.fit_transform(iris), columns=iris.columns)
iris_normal = pd.DataFrame(normal_scaler.fit_transform(iris), columns=iris.columns)

# 결과 출력
print('PowerTranformer Scaled: \n', iris_power.describe()) # mean = 0, std = 1
print()
print('Normalizer Scaled: \n', iris_normal.describe())
print('Euclidian Distance from 0: \n', np.linalg.norm(iris_normal, axis=1)) # 각 행의 벡터 크기가 1이 되는지 확인

↳ 결과

# 다섯번째 그래프
g5 = sns.jointplot(data=iris_power, x='petal_length', y='petal_width', kind='reg')
g5 = pw.load_seaborngrid(g5)
g5.set_suptitle("PowerTransformer Scaled")

# 여섯번째 그래프
g6 = sns.jointplot(data=iris_normal, x='petal_length', y='petal_width', kind='reg')
g6 = pw.load_seaborngrid(g6)
g6.set_suptitle("Normalizer Scaled")

# 그래프 합치기
g56 = (g5|g6)
g56

↳ 결과

from sklearn.preprocessing import QuantileTransformer

# Scaler 객체 생성
gaussian_scaler = QuantileTransformer(output_distribution='normal')
uniform_scaler = QuantileTransformer(output_distribution='uniform')

# 데이터 변환
iris_gaussian = pd.DataFrame(gaussian_scaler.fit_transform(iris), columns=iris.columns)
iris_uniform = pd.DataFrame(uniform_scaler.fit_transform(iris), columns=iris.columns)

# 결과 출력
print('QuantileTranformer_Gaussian Scaled: \n', iris_gaussian.describe())
print()
print('QuantileTranformer_Uniform Scaled: \n', iris_uniform.describe())

↳ 결과

# 일곱번째 그래프
g7 = sns.jointplot(data=iris_gaussian, x='petal_length', y='petal_width', kind='reg')
g7 = pw.load_seaborngrid(g7)
g7.set_suptitle("QuantileTranformer_Gaussian Scaled")

# 여덟번째 그래프
g8 = sns.jointplot(data=iris_uniform, x='petal_length', y='petal_width', kind='reg')
g8 = pw.load_seaborngrid(g8)
g8.set_suptitle("QuantileTranformer_Uniform Scaled")

# 그래프 합치기
g78 = (g7|g8)
g78

↳ 결과

# 모든 그래프 합치기

(g1|g2|g3|g4)/(g5|g6|g7|g8)

↳ 결과

응용 사례

정규화 응용

# 판다스 불러오기
import pandas as pd
from sklearn.preprocessing import MinMaxScaler

# 데이터 불러오기
df = pd.DataFrame([
    [2, 1, 3],
    [3, 2, 5],
    [3, 4, 7],
    [5, 5, 10],
    [7, 5, 12],
    [2, 5, 7],
    [8, 9, 13],
    [9, 10, 13],
    [6, 12, 12],
    [9, 2, 13],
    [6, 10, 12],
    [2, 4, 6]
], columns=['hour', 'attendance', 'score']) # hour, attendance, score 열로 할당

↳ 결과

# 데이터 전처리
x_data = df.drop(['score'], axis=1) 
y_data = df['score']

x_data = df.drop(['score'], axis=1) 
y_data = df['score']

transformer = MinMaxScaler() #transformer = MinMaxScaler 적용 (feature_range는 (0, 1))

transformer.fit(x_data) #MinMaxScaler 모델에 x_train_df 데이터 적용 (최소값, 최대값 계산)
print(transformer.data_min_)
print(transformer.data_max_) 
x_data = transformer.transform(x_data)
print(x_data) # print해서 결과를 보면, 특성들의 범위가 0에서 1사이가 되도록 비례적으로 맞춰진것을 볼 수 있음

↳ 결과

PP-노이즈처리

Sat, 18 Nov 2023 10:08:50 GMT

1 노이즈

1.1 노이즈(Noise)

측정된 변수에 무작위의 오류(random error) 또는 분산(variance)이 존재하는 것
1.1-1 정형 데이터의 노이즈
정형 데이터에서 노이즈는 분산(varianve)으로 나타냄
- 분산 : 데이터의 무작위 변동을 의미함
- 이상치 : 데이터의 무작위 변동을 초과하는 특정한 값으로 별도로 처리함
- 통계 모형에서는 오차항으로 나타남
  - 오차항 : 모형에서 설명하지 못하는 무작위 변동을 의미함
  - ex) 단순선형회귀모형 -> 오차항 ϵi가 노이즈
    1.1-2 이미지/영상 데이터의 노이즈
이미지/영상에서 노이즈는 blur, white noise, pink noise, Guasian noise등 다양한 형태로 나타남
- blur : 이미지가 흐릿하게 보이는 현상
- white noise : 백색 잡음, 모든 주파수를 가진 잡음
- pink noise : 특정 주파수 대역 (일반적으로 낮은 주파수) 에서 강하게 나타나는 노이즈
- Gaussian noise : 가우시안 분포를 따르는 잡음
이미지/노이즈의 주요 원인
- 이미지 획득 과정에서 너무 낮은 수집된 광자의 양, 센서/렌즈의 열화 (degradation 등
- 이미지 전송 중 무선 통신의 에코 및 대기 왜곡 등
  1.1-3 시계열/음성/신호 데이터의 노이즈
시계열/음성/신호에서 노이즈는 일반적으로 white noise (백색잡음) or Gaussian noise (가우시안 잡음) 으로 나타남
- 백색잡음 : 모든 주파수 영역에서 동일한 에너지를 갖는 잡음
- 가우시안 잡음 : 평균이 0, 분산이 1인 정규분포를 따르는 잡음
  1.1-4 텍스트 데이터의 노이즈
일반적으로 철자, 오류, 약어, 비표준 단어, 반복, 구두점 누락, 대소문자 정보누락, "음" 및 "어"와 같은 의성어 등
텍스트 데이터의 노이즈는 자연어 처리의 성능을 저하시키는 중요한 요인
자동 음성 인식, 광학 문자 인식, 기계 번역, Web Scraping 등으로 수집한 데이터에 노이즈가 많음

👉 ex) 음성 인식

1.2 Defact(결함) vs Fault(불량) vs Artifact(아티팩트) vs Noise(잡음, 노이즈)

Defact, Falut, Artifact, Noise는 의미는 명확하게 구분되지만, 혼재되어 사용됨

1. Defact

Defact는 전체 데이터에 존재하는 일부 오류(error) 데이터
- 범위에서 벗어난 이상치(outlier)가 아니라, 잘못된(error) 데이터
- 주로 생산, 제조 분야에서 사용하는 용어
  - Defact가 제품/설비의 기능에 손상을 야기하면 제품/설비가 Fault(불량/기능이상)이 됨
  - 모든 defect가 fault를 야기하진 않음

👉 ex) 반도체 결함

-** Artifact(아티팩트)**는 Defact와 동일한 의미를 갖는 용어

주로 과학기술 분야에서 사용하는 용어, 특히 이미지의 defect를 지칭

👉 ex) 두개골

2. Noise(잡음, 노이즈)

Noise는 일반적으로 그 원인을 알 수 없는 무작위 변동을 의미함
- 무작위(random)가 발생하는 기전(mechanism)을 알 수 없다는 의미임
주로 신호처리(signal processing) 분야에서 사용하는 용어임
데이터 과학에서는 데이터의 무작위 변동을 의미
동작 기전을 모르므로 제거는 불가하고, 이를 저감(Denoising) 해야함
- 디노이징 기법은 기본적으로 평활화(smoothing, 구간평균), 구간화(binning, 구간집계), 필터링(filtering, 주파성분 저감) 기법을 사용함

2 디노이징(Denoising)

디노이징은 데이터에서 노이즈를 저감하여 모형이 더 좋은 성능을 할 수 있도록 하는 전처리 과정

2.1 정형 데이터의 디노이징

구간화(Binning)
- 정렬된 데이터 값들을 몇 개의 bin(혹은 bucket)으로 분할하여 대표값으로 대체
군집화(clustering)
- 유사한 값들을 하나의 군집으로 처리하여 중심점(centroid)을 대표값으로 대체

2.1-1 구간화(Binning)

✍ 구간설정 방법

1. 동일 간격(equal-distance) 구간화 -> pandas의 cut() 사용

동일한 간격으로 구간을 설정
- 정상 데이터가 한쪽으로 편중(biassed)되고 outlier에 의해 영향을 많이 받음
- 한쪽으로 몰려있는 데이터들은 다 동일한 bin으로 들어오기 때문에 skewed data를 다룰 수 없음

2. 동일 빈도(eual-frequency) 구간화 → pandas의 qcut() 사용

동일한 개수의 데이터를 가지는 구간으로 설정

✍ 구간별 대표값 설정 방법

평균값 평활화 : bin에 있는 값들을 평균값으로 대체
중앙값 평활화 : 중앙값으로 대체
경계값 평활화 : 경계값 중 가까운 값으로 대체
```
import pandas as pd
import numpy as np
```

데이터 생성하기, 결과를 보기 용이하도록 sort

df = pd.DataFrame({'uniform': np.sort(np.random.uniform(0,10,10)), 'normal': np.sort(np.random.normal(5,1,10)), 'gamma': np.sort(np.random.gamma(2, size=10))})

데이터 확인하기

df.plot(kind='hist', bins=15, alpha=0.5) df.describe()

 **↳ 결과**
 ![](https://velog.velcdn.com/images/__zeroiszero/post/9d081281-a456-48e4-9aa0-986119b571ac/image.png)

#### 2.1-1-(1) Pandas로 구간화
```{python}
# cut(), qcut() 기본 동작 확인
col = 'uniform'
num_bins = 5
df_binned = pd.DataFrame()
df_binned[col] = df[col].sort_values()  # 원 데이터
df_binned['eq_dist_auto'] = pd.cut(df_binned[col], num_bins)  # 동일 간격으로 나누기
df_binned['eq_dist_fixed'] = pd.cut(df_binned[col], bins=[0,2,4,6,8,10]) # 지정된 구간으로 나누기
df_binned['eq_freq_auto'] = pd.qcut(df_binned[col], num_bins) # 동일 빈도로 나누기
df_binned

↳ 결과

# 구간화하여 평균값 대체하기
cols = ['uniform', 'normal', 'gamma']

# 동일 간격 구간화
df_ew = df.copy()
for col in cols:
    df_ew[col+'_eq_dist'] = pd.cut(df_ew[col], 3)   # 구간으로 나누기
    means = df_ew.groupby(col+'_eq_dist')[col].mean() # 구간별 평균값 계산
    df_ew.replace({col+'_eq_dist': means}, inplace=True) # 평균값으로 대체

display(df_ew)

# 동일 빈도 구간화
df_ef = df.copy()
for col in cols:
    df_ef[col+'_eq_freq'] = pd.qcut(df_ef[col], 3)   # 구간으로 나누기
    means = df_ef.groupby(col+'_eq_freq')[col].mean() # 구간별 평균값 계산
    df_ef.replace({col+'_eq_freq': means}, inplace=True) # 평균값으로 대체

display(df_ef)

# 시각화
import matplotlib.pyplot as plt

fig, axes = plt.subplots(1, 2, figsize=(10,5))
df_ew.astype(float).plot(ax=axes[0])
df_ef.astype(float).plot(ax=axes[1])
plt.show()

↳ 결과

2.1-2 군집화(clustering)

2.1-2-(1) Scikit-Learn으로 구간화

KBinsDiscretizer() 사용
- encode{‘onehot’, ‘onehot-dense’, ‘ordinal’}, default=’onehot’
- strategy{‘uniform’(동일간격), ‘quantile’(동일빈도), ‘kmeans’(K-Means 군집화)}, default=’quantile’

import warnings

# hide warnings
warnings.filterwarnings("ignore")

from sklearn.preprocessing import KBinsDiscretizer

# 동일 간격 구간화
ed_binner = KBinsDiscretizer(n_bins=3, encode='ordinal', strategy='uniform', subsample=None)
df_ed = ed_binner.fit_transform(df)

# 동일 빈도 구간화
ef_binner = KBinsDiscretizer(n_bins=3, encode='ordinal', strategy='quantile', subsample=None)
df_ef = ef_binner.fit_transform(df)

# K-means 구간화
km_binner = KBinsDiscretizer(n_bins=3, encode='ordinal', strategy='kmeans', subsample=None)
df_km = km_binner.fit_transform(df)

# 결과 확인
df_ed = pd.DataFrame(df_ed, columns=df.columns+'_eq_dist')
df_ef = pd.DataFrame(df_ef, columns=df.columns+'_eq_freq')
df_km = pd.DataFrame(df_km, columns=df.columns+'_km')
df_bin = pd.concat([df, df_ed, df_ef, df_km], axis=1)
df_bin

↳ 결과

# 구간화하여 평균값 대체하기
for bin_col in df_bin.columns:
    col = bin_col.split('_')[0]
    means = df_bin.groupby(by=bin_col)[col].mean() # 구간별 평균값 계산
    df_bin.replace({bin_col: means}, inplace=True) # 평균값으로 대체

df_bin

↳ 결과

# 시각화
import matplotlib.pyplot as plt

fig, axes = plt.subplots(1, 3, figsize=(15,5))
pd.concat([df_bin.iloc[:,:3], df_bin.iloc[:,3:6]], axis=1).astype(float).plot(ax=axes[0])
pd.concat([df_bin.iloc[:,:3], df_bin.iloc[:,6:9]], axis=1).astype(float).plot(ax=axes[1])
pd.concat([df_bin.iloc[:,:3], df_bin.iloc[:,9:]], axis=1).astype(float).plot(ax=axes[2])
plt.show()

↳ 결과

응용 사례

2 디노이징 응용

# 특성 이산화

# 라이브러리 불러오기
import numpy as np
from sklearn.preprocessing import Binarizer

# 특성 만들기
age = np.array([[6],
                [12],
                [20],
                [36],
                [65]])

# Binarizer 객체를 만들기
binarizer = Binarizer(threshold=18)

# 특성 변환하기
binarizer.fit_transform(age)

↳ 결과

# 특성을 나눈다
np.digitize(age, bins=[20,30,64])

↳ 결과

# 특성을 나눈다
np.digitize(age, bins=[20,30,64], right=True)

↳ 결과

# 특성을 나눈다
np.digitize(age, bins=[18])

↳ 결과

from sklearn.preprocessing import KBinsDiscretizer

# 네 개의 구간으로 나누기
kb = KBinsDiscretizer(4, encode='ordinal', strategy='quantile')
kb.fit_transform(age)

↳ 결과

# 원-핫 인코딩을 반환함
kb = KBinsDiscretizer(4, encode='onehot-dense', strategy='quantile')
kb.fit_transform(age)

↳ 결과

# 동일한 길이의 구간을 만듦
kb = KBinsDiscretizer(4, encode='onehot-dense', strategy='uniform')
kb.fit_transform(age)

↳ 결과

kb.bin_edges_

↳ 결과

PP-결측치처리

Sun, 15 Oct 2023 07:50:58 GMT

1 결측치 탐색

1.1 결측치

데이터의 값이 누락된것 = 결측값, Missing Values
- NA 또는 N/A(Not Applicable or Not Available), NaN(Not a Number), NULL로 표기됨
전산오류, 입력누락, 인위적 누락 등으로 발생함
설문조사(survey)와 종단연구(longitudinal research)에서 보편적으로 발생
- 설문조사는 참가자 중 일부가 답변하기 곤란한 질문에 의도적으로 응답을 하지 않을 수 있음
- 종단연구는 특정 대상을 장기간에 걸쳐 조사하는 것으로, 사망, 임의탈퇴, 연락두절 등의 상태가 발생

1.2 결측치의 유형

MCAR(Missing Completely At Random, 완전 무작위 결측)
- 결측치가 발생한 변수의 값에 상관없이 전체에 걸쳐 무작위로 발생한 경우
- 통계적으로 결측치의 영향이 없으므로 제거 가능
MAR(Missing At Random, 무작위 결측)
- 결측치가 발생한 변수의 값이 다른 변수와 상관관계가 있어 추정이 가능한 경우
- 통계적으로 결측치의 영향이 다소 있으나 편향은 없으므로 대체 가능함
MNAR(Missing Not At Random, 비무작위 결측)
- 결측치가 발생한 변수의 값과 관계가 있고 그 이유가 있는 경우
- 통계적으로 결측치의 영향이 크므로 결측치의 원인에 대한 조사 후 대응이 필요함

👉 결측치의 유형 예

(위에서)

MCAR은 특별한 패턴이 없이 데이터가 누락
MAR은 낮은 IQ영역에서만 데이터 누락, IQ로 Job Performance Ratings를 어느정도 추정 가능
MNAR은 패턴은 존재하나 IQ로 추정이 불가능

1.3 결측치 탐색

1.3-1 Pandas를 이용한 결측치 탐색

(colab 기준) preprocessing_students.csv 를 다운로드 하여 content 파일에 업로드 해준다
```
import pandas as pd
```

데이터 세트 불러오기

df = pd.read_csv('preprocessing_students.csv', sep=',') df.head()

 #### 👉 결과
 ![](https://velog.velcdn.com/images/__zeroiszero/post/f413bfce-f1b6-49c6-9534-07dc11583cc8/image.png)

#### ✍ 결측치 갯수 확인하기
- df.info(), df.isnull(), df.notnull(), sum(0), sum(1)
``` python
# 데이터 정보에서 Non-Null Count 갯수로 결측치 확인
df.info()

👉 결과

# isnull()의 True 개수를 합하여 확인 
print(df.isnull().sum(axis=0)) #  axis = 0 열기준, 1 행기준

👉 결과

결측치는 weight, IQ, mid_score, employed로 각각 4,6,6,2개가 있음 (결측치의 유형은 파악 어려움)

1.3-2 klib을 이용한 결측치 탐색

pip install klib

import klib
import warnings

# 경고 메시지 무시
warnings.filterwarnings(action='ignore') 

# 결측치에 대한 프로파일링 플롯
klib.missingval_plot(df)

👉 결과

# 결측치에 대한 프로파일링 플롯
klib.missingval_plot(df, sort=True)

👉 결과

결측치 프로파일링 결과 weight, IQ, mid_score에 다수의 결측치가 존재

# 상관관계 플롯
klib.corr_plot(df)

👉 결과

변수간 상관분석 결과 weight와 height의 상관관계가 강한 양의 상관관계(0.78), IQ와 mid_score가 양의 상관관계(0.59), mid_score와 final_score가 양의 상관관계(0.53)을 보이고 있음

import matplotlib.pyplot as plt
# 한글이 안나올 경우 폰트 지정
plt.rc('font', family='Malgun Gothic')

# 범주형 변수에 대한 분석
klib.cat_plot(df)

👉 결과

# 결측치가 있는 변수의 분포 확인
klib.dist_plot(df.weight)
klib.dist_plot(df.IQ)
klib.dist_plot(df.mid_score)

👉 결과

weight는 특정한 패턴이 보이지 않음
IQ는 중간 영역대의 밀도가 낮아 중간영역대의 데이터가 누락되었음을 확인 가능
mid_score는 낮은 점수대의 데이터가 누락되었음을 확인 가능

2 결측치 처리

2.1 결측치 처리방법 개요

제거(deletion)
- MCAR(완전 무작위 결측) 일때 사용 가능함
- 데이터의 손실이 발생 -> 자유도 감소 -> 통계적 검정력 저하
- 표본의 수가 충분하고 결측값이 10%-15% 이내일 때에는 결측값을 제거한 후 분석해도 결과에 크게 영향을 주지 않음
대체(imputation)
- 표본 평균과 같은 대표값으로 대체할 경우 -> 대표값 데이터가 많아짐 -> 잔차 변동이 줄어듬 -> 잘못된 통계적 결론 유도
- 모수추정 시 편향(bias) 발생함

2.2 결측치 제거(Deletion)

1. Listwise deletion
- 결측치가 존재하는 행(instance) 자체를 삭제하는 방식
- 데이터 표본의 숫자가 적은 경우 표본의 축소로 인한 검정력 감소
2.** Pairwise deletion**
- 분석에 사용하는 속성의 결측치가 포함된 행만 제거하는 방식
- MCAR일때만 가능함

import pandas as pd

# Listwise deletion
df_listwise = df.dropna()

# Pairwise deletion
df_pairwise = df.dropna(subset=['weight', 'mid_score'])

print(f'Original Data:\n {df}\n')
print(f'Listwise deletion:\n {df_listwise}\n')
print(f'Pairwise deletion:\n {df_pairwise}\n')

👉 결과

2.3 결측치 대체(Imputation)

2.3-1 Single Imputation(단순대체법)

결측치의 대체값으로 하나의 값을 선정하는 것
mean, correlation, 회귀계수와 같은 파라미터 추정시 편향(bias) 발생가능성 높음
이러한 추정 편향으로 인해 아예 결측값을 제거하는 것보다 통계적 특성이 나빠질 수 있음

📝 단순대체법 종류

Explicit Modeling
1. Mean imputation
- 데이터의 평균값(mean, median, mode)으로 결측값을 대체
- 평균 대체 -> 표본오차 왜곡, 축소 -> 부정확한 p-value -> 검정력 약화
2. Regression imputation
- 회귀식을 만들어 예측된 값으로 결측값 대체
- 회귀 예측값 대체 -> 잔차 축소, 왜곡 -> R-squared 증가, 왜곡
3. Stochastic regression imputation
- 회귀 예측값으로 대체하는 것과 유사하나, random error term을 추가하여 예측값에 변동을 주는 방법
- 표본오차의 과소 추정 문제가 있음
Implicit Modeling
1. Hot deck imputation
- 연구중인 자료에서 표본을 바탕으로 비슷한 규칙을 찾아 결측값을 대체
- 다른 변수에서 비슷한 값을 갖는 데이터 중에서 하나를 랜덤 샘플링하여 그 값을 복사
- 결측값이 존재하는 변수가 가질 수 있는 값의 범위가 한정되어 있을때 사용
2. Cold deck imputation
- 외부 출처에서 비슷한 연구를 찾아 결측값을 대체
- Hot deck imputation과 유사하나, 어떠한 규칙 하(ex) k번째 샘플의 값을 취해오는 등..)에서 하나를 선정

2.3-2 단순대체법 Python 적용

1. Mean imputation
- scikit-learn의 SimpleImputer 클래스를 사용
  - strategy : mean/mode/most_frequent
  - 데이터가 실수 연속값인 경우에는 평균 또는 중앙값을 사용, 값의 분포가 대칭적이면 평균이 좋고, 값의 분포가 심하게 비대칭인 경우에는 중앙값이 적당함
  - 데이터가 범주값이거나 정수값인 경우에는 최빈값을 사용함
2. Regression/Stochastic regression imputation
- scikit-learn의 LinearRegression 사용
3. Hot deck/Cold deck imputation
- Pandas의 fillna()적용

from sklearn.impute import SimpleImputer

df_imputed = pd.DataFrame.copy(df)

# 110대가 결측인 IQ는 평균으로 대체
df_imputed[['IQ']] = SimpleImputer(strategy="mean").fit_transform(df[['IQ']])

# 비대칭 분포를 갖는 mid_score는 중앙값으로 대체
df_imputed[['mid_score']] = SimpleImputer(strategy="median").fit_transform(df[['mid_score']])

# 범주형 employed는 Hot deck으로 대체
df_imputed['employed'].fillna(method='bfill', inplace=True) 

# height와 양의 상관관계가 있는 weight는 Stochastic regression으로 대체
from sklearn.linear_model import LinearRegression
import numpy as np
# 결측치가 있는 인덱스 검색
idx = df.weight.isnull() == True
# 학습을 위한 데이터 세트 분리
X_train, X_test, y_train = df[['height']][~idx], df[['height']][idx], df[['weight']][~idx]
# 선형회귀모형 인스탄스 생성 후 학습
lm = LinearRegression().fit(X_train, y_train)
# 예측값 + 변동값하여 결측치를 대체
df_imputed.loc[idx, 'weight'] = lm.predict(X_test) + 5*np.random.rand(4,1)

df_imputed

👉 결과

2.3-3 다중대체법(Multiple Imputation)

결측치의 대체값을 여러 추정값을 종합하여 선정하는 것
Multiple Imputation 3단계
- 1. Imputation Phase: 가능한 대체 값의 분포에서 추출된 서로 다른 값으로 복수의 데이터 셋을 생성
- 1. Analysis Phase: 각 데이터 셋에 대하여 모수의 추정치와 표본오차 계산
- 1. Pooling Phase: 모든 데이터 셋의 추정치와 표본오차를 통합하여 하나의 대치값 생성

✍ MICE(Multiple Imputation by Chained Equations)

다중대체법의 한 종류

import numpy as np
# scikit-learn에서 R의 MICE 패키지를 따라서 실험적으로 개발 중
from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer

# 데이터 세트
X_train = [[33, np.nan, .153], [18, 12000, np.nan], [np.nan, 13542, .125]]
X_test = [[45, 10300, np.nan], [np.nan, 13430, .273], [15, np.nan, .165]]

# mice 인스탄스 생성
mice = IterativeImputer(max_iter=10, random_state=0)
mice.fit(X_train)

np.set_printoptions(precision=5, suppress=True)
print('X_train MICE: \n', mice.transform(X_train))
print('X_test MICE: \n', mice.transform(X_test))

👉 결과

✍ KNN Imputation

KNN(K-Nearest Neighbor)은 분석대상을 중심으로 가장 가까운 k개 요소(이웃)들 중에서 가장 많은 수의 집단으로 분류하는 지도학습 알고리즘
KNN Imputation은 결측치가 범주형이면 이웃 데이터 중 최빈값으로 대체하고 연속형이면 이웃 데이터들의 중앙값으로 대체하는 방법

import numpy as np
from sklearn.impute import KNNImputer

knn = KNNImputer(n_neighbors=2, weights="uniform")
knn.fit(X_train)

print('X_train KNN: \n', knn.transform(X_train))
print('X_test KNN: \n', knn.transform(X_test))

👉 결과

PP-프로파일링(코드 실습)

Mon, 09 Oct 2023 00:03:56 GMT

3 데이터 프로파일링을 위한 파이썬 패키지

3.1 klib

Pandas 데이터프레임을 기반으로 데이터전처리 및 프로파일링을 제공해주는 패키지
데이터 품질평가, 전처리, 관계 시각화를 목적으로 사용
속도가 매우 빠르며 다양한 시각화 기능을 제공

설치

pip install klib
pip install pandas
pip install seaborn

import warnings

# hide warnings
warnings.filterwarnings("ignore")

import klib
import pandas as pd
import seaborn as sns

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

# 결측치에 대한 프로파일링 플롯
klib.missingval_plot(df)

# 양의 상관관계 플롯
klib.corr_plot(df, split='pos')
# 음의 상관관계 플롯
klib.corr_plot(df, split='neg')

위의 그림은 양의 상관관계 그래프
색상이 어두울수록 상관관계가 크다는 의미
위의 그림은 음의 상관관계 그래프

마찬가지로 색상이 어두울수록 상관관계가 크다는 의미

# default representation of correlations with the feature column
klib.corr_plot(df, target='age') # age를 기준으로한 다른 피쳐들과의 상관계수를 나타낸 그래프

위의 그림을 보면 age와 adult_male은 양의 상관관계가 높고, pclass와는 음의 상관관계가 높다

klib.corr_plot(df, target='fare') # fare를 기준으로한 다른 피쳐들과의 상관계수를 나타낸 그래프

위의 그림을 보면 fare는 pclass와는 음의 상관관계가 높은 반면, survived과는 약한 양의 상관관계를 가짐

# default representation of a distribution plot, other settings include fill_range, histogram, ...
klib.dist_plot(df) # 히스토그램 그리기

df_cleaned = klib.data_cleaning(df) # 데이터 클렌징

↳ df_cleaned 결과**

Shape of cleaned data: (784, 15) - Remaining NAs: 692

Dropped rows: 107 of which 107 duplicates. (Rows (first 150 shown): [47, 76, 77, 87, 95, 101, 121, 133, 173, 196, 198, 201, 213, 223, 241, 260, 274, 295, 300, 304, 313, 320, 324, 335, 343, 354, 355, 358, 359, 364, 368, 384, 409, 410, 413, 418, 420, 425, 428, 431, 454, 459, 464, 466, 470, 476, 481, 485, 488, 490, 494, 500, 511, 521, 522, 526, 531, 560, 563, 564, 568, 573, 588, 589, 598, 601, 612, 613, 614, 635, 636, 640, 641, 644, 646, 650, 656, 666, 674, 692, 696, 709, 732, 733, 734, 738, 739, 757, 758, 760, 773, 790, 792, 800, 808, 832, 837, 838, 844, 846, 859, 863, 870, 877, 878, 884, 886])

Dropped columns: 0 of which 0 single valued. Columns: [] Dropped missing values: 177 Reduced memory by at least: 0.06 MB (-75.0%)

---------------------------------------------
## 3.2 ydata-profiling
- interactive한 프로파일링 기능을 통합한 패키지
- pandas profiling에서 최근 ydata-profiling으로 이름 변경
- 주요 특징
  - 컬럼 데이터타입 자동 감지, 경고 요약, 단변량&다변량 분석, 시계열에 대한 다양한 통계정보 포함, 텍스트 분석, 파일 및 이미지 분석, 데이터 세트 비교, 유연한 출력 형식 등..
### 3.2-1 ydata-profiling 활용
**ydata-profiling 패키지 및 ipywidgets 설치하기**
```{python}
pip install ydata-profiling ipywidgets

필요한 패키지 import하기

import numpy as np
import pandas as pd
from ydata_profiling import ProfileReport

테스트 데이터 생성하기

df = pd.DataFrame(np.random.rand(100, 5), columns=["a", "b", "c", "d", "e"])
print(df.head())

** ↳ 테스트 데이터 생성 결과**

          a         b         c         d         e
0  0.995817  0.268284  0.563712  0.569891  0.489493
1  0.054562  0.586358  0.311612  0.794190  0.076927
2  0.801426  0.570937  0.747227  0.812121  0.881083
3  0.032467  0.155426  0.434115  0.641922  0.912143
4  0.498620  0.106867  0.099020  0.988647  0.054433

프로파일링 리포트 생성

profile = ProfileReport(df, title="Ydata Profiling Report")

#profile.to_widgets() # jupyter notebook에서 위젯으로 보기
profile.to_notebook_iframe() # HTML 보고서와 유사한 방식으로 셀에 직접 포함
profile.to_file("my_profiling_report.html") # HTML로 별도 저장

** ↳ 리포트 생성 결과** 하..진짜 주피터노트북에서 자꾸 에러나서 아래부터는 colab으로 함 ㅠㅠ

위와 같은 데이터들을 전반적으로 요약한 결과물들이 문서 형태로 한눈에 볼 수 있게 출력됨
3.2-2 결측치가 있는 데이터(titanic)
```
import seaborn as sns
import pandas as pd
```

Seborn 데이터 세트 로드

df_titanic = sns.load_dataset('titanic') df_titanic.head()

**↳ 결과**
 ![](https://velog.velcdn.com/images/__zeroiszero/post/5f39e637-f2cb-4e52-ac5f-7aa69202c7f4/image.png)
**위의 titanic 데이터에 대한 프로파일링 리포트 생성하기**
```{python}
# titanic 데이터세트는 시간이 오래 걸려 최소수준의 분석만 실행
profile = ProfileReport(df_titanic, title = "Titanic 데이터에 대한 프로파일링 보고서", minimal=True)

profile.to_notebook_iframe()
profile.to_file("titanic_profiling_report.html") # HTML로 별도 저장

↳ 결과

3.2.3 NLP를 위한 네이버 영화 리뷰 데이터

Github 페이지에서 ko_test.csv 다운로드 함
** Google Drive와 연결하여 데이터나 파일에 대한 접근허용해준다!!**
```
import pandas as pd
```

movie_df = pd.read_csv('ko_test_label.csv', sep = ',') #print(movie_df.info()) #print(movie_df.shape) print(movie_df.head(5))

**↳ 결과**
![](https://velog.velcdn.com/images/__zeroiszero/post/c9eb6724-29db-40e0-b66a-9e311444b21d/image.png)
**위의 영화리뷰에 대한 프로파일링 리포트 생성하기**
```{python}
pf_movie = ProfileReport(movie_df, title="네이버 영화 리뷰 데이터에 대한 프로파일링 보고서")
# pf_movie.to_widgets() # jupyter notebook에서 위젯으로 보기
pf_movie.to_notebook_iframe()
pf_movie.to_file("review_profiling_report.html") # HTML로 별도 저장

↳ 결과

3.3 PyGWalker

PyGWalker(“Pig Walker”로 발음)는 시각화를 통한 탐색적 데이터 분석을 위한 Python 라이브러리
판다스 데이터프레임을 시각적으로 보기 위한 Tableau 스타일 사용자 인터페이스로 제공
간단한 끌어서 놓기 작업으로 데이터를 분석하고 패턴을 시각화 가능함

PyGWalker 설치하기

pip install "pygwalker[notebook]" --pre

필요한 패키지 import하기

import pandas as pd
import pygwalker as pyg

Pandas 데이터프레임으로 PyGWalker 실행함

import seaborn as sns
# Seborn 데이터 세트 로드
df_titanic = sns.load_dataset('titanic')

gwalker = pyg.walk(df_titanic).display_on_jupyter()

↳ 결과

위 사진과 같이 x축, y축별로 왼쪽에서 변수를 끌어다가 놓을 수 있음
파이썬으로는 일일히 코딩하기 힘들지만 PyGWalker를 사용하면 마우스로 X,Y축에 놓일 변수들만 클릭하면 됨
polars가 판다스보다 대용량 데이터를 처리할 수 있음

DataFrame을 polars로 변경하여 pygwalker 실행

import polars as pl

titanic_pl = pl.from_pandas(df_titanic)
gwalker = pyg.walk(titanic_pl).display_on_jupyter()

PP-프로파일링(이론)

Sun, 08 Oct 2023 09:16:08 GMT

1 탐색적 데이터 분석 개요

1.1 탐색적 데이터 분석(EDA)

EDA(Exploratory Data Analysis)라고 함
수집한 데이터를 분석하기 전에 그래프나 통계적인 방법을 이용하여 다양한 각도에서 데이터의 특징을 파악하고 자료를 직관적으로 바라보는 분석 방법
EDA를 통하여 데이터전처리, 피쳐 엔지니어링 방향을 확보할 수 있음
1.2 EDA 프로세스

Step1 : 데이터의 속성(변수, feature) 확인하기
Step2 : 각 피쳐별 단변량 데이터 분석
Step3 : 피쳐간 상관관계 분석
Step4 : 결측치 처리하기
Step5 : 이상치 처리하기
Step6 : 피쳐 엔지니어링을 통한 피쳐 선택, 추가, 삭제하기
1.3 변수 분석

단변량 분석
변수 하나에 대하여 기술통계량(descriptive statistics) 확인
- 대표값 : 데이터의 평균, 중위수, 최빈수
- 산포 : 표준편차, 분산, 범위, 사분위수
- 분포 : 왜도, 첨도
- 기타 : 신뢰구간, 데이터의 정규성
히스토그램이나 Boxplot을 사용 -> 평균, 최빈값, 중간값 등과 함께 각 변수들의 분포를 확인
범주형 변수의 경우 Boxplot을 사용하여 빈도 수 분포를 체크
이변량 분석
변수 2개간의 관계를 분석
- 상관관계 분석(correlation analysis) : 두 개 이상의 변수 사이에 존재하는 상호 연관성의 존재 여부와 연관성의 강도를 측정하여 분석
변수의 유형에 따라 적절한 시각화 및 분석 방법을 적용(ex) 산점도)
다변량 분석
범주형 변수가 하나 이상 포함되어 있는 경우에는 변수를 범주에 따라 분리한 후 분석 방법에 따라 분석함
모두 연속형 변수일때 -> 연속형 변수를 Feature engineering을 통해 범주형 변수로 변환한 후 분석, 혹은 3차원 그래프를 그려서 시각적으로 확인
1.4 그래프 분석
데이터의 종류에 따라 적절한 그래프를 선택해야함
다양한 그래프를 통하여 피쳐들의 특성을 파악하는것이 중요함 (출처:https://lantsandlaminins.com/writing-guides/choosing-a-graph-type/)

2 데이터 프로파일링

2.1 데이터 프로파일링

프로파일링(profiling)

어떤 개인의 심리적, 행동적 특성을 분석함으로써 특정 상황이나 영역에서의 행동을 예상하는 것
사회인구학적 특성을 포함한 여러 변수에 의해 특정한 하위 그룹으로 분류하는 것
데이터 프로파일링이란?
EDA(탐색적 데이터 분석)를 수행하는 것
데이터 내 값의 분포, 변수 간의 관계, NULL과 같은 결측값(missing value) 존재 유무 등을 분석
2.2 데이터 프로파일링의 단계

2.2-1 메타데이터 수집 및 분석
실제 운영중인 데이터베이스의 테이블명, 컬럼명, 제약조건 등의 정보를 분석
- 테이블 정의서, 컬럼 정의서와 같은 데이터 관리 문서의 정보 분석
- 추출된 테이블 및 컬럼에 대한 메타데이터와 데이터 관리 문서를 매핑하여 불일치 사항을 분석
  2.2-2 컬럼 속성 분석
대상 컬럼의 비유효한 값을 확인
컬럼의 총 건수, 유일값 수, NULL값 수, 공백값 수, 최댓값, 최솟값, 최대빈도, 최소빈도 등 기초 집계값을 산출하여 값이 유효한 범위 내에 있는지 판단
2.2-3 결측치 분석
반드시 입력되어야 하는데 누락이 발생한 컬럼을 발견하는 절차
결측치에는 NULL값, 공백값 또는 숫자 0 등이 해당
NULL 허용 컬럼일지라도 NULL과 공백이 섞여있는 경우와 총 건수와 NULL건수가 같아 미사용으로 추정되는 컬럼을 발견하는 일도 포함
2.2-4 허용범위 분석
값이 가져야 할 범위 내에 그 값이 있는지를 파악하는 절차
허용범위는 해당 속성의 도메인 유형에 따라 정해짐
아래 예시에서 MAGAZINE 테이블의 권, 호, 페이지 등의 컬럼은 0 이상의 값을 가져야 하지만 최솟값이 -999 등으로 이루어진 것을 봐서 NULL 대신 무의미한 값을 부여한 데이터일 가능성이 큼
해당값이 오류 데이터라면 NULL값을 부여해야 함
2.2-5 허용값 분석
해당 컬럼의 허용값 목록이나 집합에 포함되지 않는 값을 발견하는 절차
코드 매핑 정의서에 기술한 코드 성격의 컬럼이 분석 대상에 해당
- 아래 예시에서 등록되지 않은 코드가 포함되어 있거나 의미는 유사하나 다른 값으로 혼재된 경우를 확인가능
  2.2-6 패턴 분석
해당 컬럼의 문자열 유형을 따르지 않는 오류 유형을 발견하는 절차
데이터를 집계할 때 문자일 경우C, 숫자일 경우9, 공백일 경우S를 반환하는 함수를 만들어 사용
- 해당 컬럼의 데이터를 패턴화하여 SQL로 조회하면 비정상적인 형태를 보인 값을 오류로 추정할 수 있음
  2.2-7 날짜 유형 분석
대상 컬럼이 DBMS의 DATE관련 자료형을 가지면 날짜 패턴 및 유효성 검증은 문제가 없음
- 하지만 문자형 데이터 타입에 날짜 데이터를 입력하면 아래 예시와 같은 사례가 발생할 수 있음
- 이는 패턴 검증을 통하여 쉽게 검증할 수 있음
  2.2-8 유일값 분석
업무적 의미에서 유일해야 하는 컬럼에 중복이 발생하였는지를 파악하는 절차
DBMS의 제약조건으로 PK(Primary Key)가 설정된 컬럼이나 UNIQUE가 설정된 컬럼은 문제없음
- 아래 예시처럼 CUSTOMER테이블의 EMAIL컬럼은 PK컬럼이 아니지만, 업무적으로 고객의 이메일은 유일해야 하는 경우 최대 빈도를 통하여 중복된 데이터를 확인할 수 있음
  2.2-9 구조 분석
구조 결함으로 인해 일관되지 못한 데이터를 발견하는 분석 기법
아래 예시에 ORDER테이블에 CUSTOMER테이블에는 존재하지 않는 데이터가 존재하여 데이터의 일관성이 없는 오류 데이터가 발생
ERD(Entity Relationship Diagram)등 설계 시에는 관계를 설정해두고 실제 데이터베이스에는 제약조건을 적용하지 않고 개발하는 경우 이러한 사례가 빈번하게 발생

Py-Pandas

Sun, 24 Sep 2023 19:05:20 GMT

1 Pandas

1.1 판다스(Pandas)

Python Data Analysis Library의 약어
R의 data.frame을 벤치마킹하여 Python에서 사용할 수 있는 형태의 Dataframe을 제공해주는 라이브러리
Python을 활용해 데이터 분석을 하기 위해서 사용하는 필수적인 패키지

1.2 데이터프레임 구조 및 명칭

필요한 패키지 import 하기
```
  import numpy as np
  import pandas as pd
```
2 데이터프레임 다루기(기초)

2.1 데이터프레임 생성하기
pandas.DataFrame()
- data : dict, list, set, ndarray, lterable 또는 DataFrame
- [index] : index명, 디폴트는 0, 1, 2..
- [columns] : 컬럼명, 디폴트는 0, 1, 2..
- [dtype] : 데이터 타입 지정
- [copy] : 입력으로부터 복사, True or False
  
  직접 데이터프레임 작성하기
```
my_df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6]])
                   , index=range(1,3), columns=['A','B','C'])
print(my_df)
```
  결과
```
 A  B  C
```
  1 1 2 3 2 4 5 6
  
  2D array를 데이터프레임으로 변환
```
my_2darray = np.array([[1, 2, 3], [4, 5, 6]])
print(pd.DataFrame(my_2darray))
```
  결과
```
 0  1  2
```
  0 1 2 3 1 4 5 6
  
  dictionary를 데이터프레임으로 변환
```
my_dict = {'a': ['1', '3'], 'b': ['1', '2'], 'c': ['2', '4']}
print(pd.DataFrame(my_dict))
```
  결과
```
 a  b  c
```
  0 1 1 2 1 3 2 4
  
  Series를 데이터프레임으로 변환
```
my_series = pd.Series({'United Kingdom':'London', 'India':'New Delhi'
                 , 'United States':'Washington', 'Belgium':'Brussels'})
print(pd.DataFrame(my_series))
```
  결과
```
                           0
```
  United Kingdom London India New Delhi United States Washington Belgium Brussels
  
  외부 파일로 부터 불러오기
```
df = pd.read_csv('bank.csv', sep = ',')
print(df.head(3)) # default=5
```
  결과
```
age;"job";"marital";"education";"default";"balance";"housing";"loan";"contact";"day";"month";"duration";"campaign";"pdays";"previous";"poutcome";"y"
```
  0 30;"unemployed";"married";"primary";"no";1787;...
  1 33;"services";"married";"secondary";"no";4789;...
  2 35;"management";"single";"tertiary";"no";1350;...
  
  2.2 데이터프레임 살펴보기
  
  메타데이터 확인하기
```
my_df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6]])
               , index=range(1,3), columns=['A','B','C'])
my_df.info()
```
  결과 RangeIndex: 2 entries, 1 to 2 Data columns (total 3 columns): #Column Non-Null Count Dtype
  
  0 A 2 non-null int32 1 B 2 non-null int32 2 C 2 non-null int32 dtypes: int32(3) memory usage: 156.0 bytes
  
  출력 제한 걸기
```
pd.options.display.max_rows = 20  # 최대 표시 행수
pd.set_option('display.min_rows', 5) # 최소 표시 행수

df = pd.read_csv('bank.csv', sep = ',').iloc[:,0:7]
print(df)
```
  결과
```
     age           job  marital  education default  balance housing
```
  0 58 management married tertiary no 2143 yes 1 44 technician single secondary no 29 yes ... ... ... ... ... ... ... ... 45209 57 blue-collar married secondary no 668 no 45210 37 entrepreneur married secondary no 2971 no

[45211 rows x 7 columns]

데이터프레임의 형태

     df = pd.DataFrame({'A':[11,21,31], 'B':[12,22,32], 'C':[13,23,33]}
                  , index=['1st','2nd','3rd'])
     print(df.shape) # 행과 열의 수
     print(len(df.index)) # 인덱스(행)의 갯수

    결과
    (3, 3)
    3

데이터프레임 데이터 확인하기

    df = pd.DataFrame({'A':[11,21,31], 'B':[12,22,32], 'C':[13,23,33]}
                  , index=['1st','2nd','3rd'])
    print(df)
    display(df) # HTML로 출력

👉 결과

2.3 데이터 추가 하기와 삭제하기

행 추가하기

    df = pd.DataFrame({'A':[11,21,31], 'B':[12,22,32], 'C':[13,23,33]}
                  , index=['1st','2nd','3rd'])
    df.loc['4th'] = [41, 42, 43]
    df.loc['8th'] = [81, 82, 83]
    print(df)

    결과
          A   B   C
    1st  11  12  13
    2nd  21  22  23
    3rd  31  32  33
    4th  41  42  43
    8th  81  82  83

열 추가하기

    df['D'] = [14, 24, 34, 44, 84]
    print(df)

    결과
          A   B   C   D
    1st  11  12  13  14
    2nd  21  22  23  24
    3rd  31  32  33  34
    4th  41  42  43  44
    8th  81  82  83  84

열 삭제하기

    df.drop('D', axis = 1, inplace = True) #inplace는 삭제 후 다시 저장
    print(df)

    결과
          A   B   C
    1st  11  12  13
    2nd  21  22  23
    3rd  31  32  33
    4th  41  42  43
    8th  81  82  83

행 삭제하기

    df.drop(['4th','8th'], axis = 0, inplace = True) # inplace는 삭제 후 다시 저장
    print(df)

    결과
          A   B   C
    1st  11  12  13
    2nd  21  22  23
    3rd  31  32  33

2.4 인덱싱과 슬라이싱

열선택: df[‘colname’], df.colname, df[[‘colname1’,‘colname2’,‘colname3’]]

    df = pd.DataFrame({'A':[11,21,31], 'B':[12,22,32], 'C':[13,23,33]}
                  , index=['1st','2nd','3rd'])
    print(df['C'])
    print(df[['A','C']])

    결과
    1st    13
    2nd    23
    3rd    33
    Name: C, dtype: int64
          A   C
    1st  11  13
    2nd  21  23
    3rd  31  33

인덱스 선택: df.loc[], df.loc[[]], df.loc[:], df.loc[:,:]

    print(df.loc['1st']) # 행 선택
    print(df.loc[['1st','3rd']]) # 여러행 선택

    결과
    A    11
    B    12
    C    13
    Name: 1st, dtype: int64
          A   B   C
    1st  11  12  13
    3rd  31  32  33

    print(df.loc['1st':'2nd']) # 행 슬라이싱
    print(df.loc[:,'B':'C']) # 행열 슬라이싱

    결과
          A   B   C
    1st  11  12  13
    2nd  21  22  23
          B   C
    1st  12  13
    2nd  22  23
    3rd  32  33

절대위치선택: df.iloc[], df.iloc[[]], df.iloc[:], df.iloc[:,:]

    print(df.iloc[0]) # 행 선택
    print(df.iloc[[0,2]]) # 여러행 선택

    결과
    A    11
    B    12
    C    13
    Name: 1st, dtype: int64
          A   B   C
    1st  11  12  13
    3rd  31  32  33

    print(df.iloc[0:3]) # 행 슬라이싱
    print(df.iloc[:,1:3]) # 행열 슬라이싱

    결과
          A   B   C
    1st  11  12  13
    2nd  21  22  23
    3rd  31  32  33
          B   C
    1st  12  13
    2nd  22  23
    3rd  32  33

2.5 탐색하여 슬라이싱

Dataframe의 변수를 이용하여 슬라이싱

    df = pd.DataFrame({'A':[11,21,31], 'B':[12,22,32], 'C':[13,23,33]}
                  , index=['1st','2nd','3rd'])
    print(df[df.C<30]) # 행선택

    결과
          A   B   C
    1st  11  12  13
    2nd  21  22  23

    print(df.loc[lambda x: x.C<30]) #행 선택

    결과
          A   B   C
    1st  11  12  13
    2nd  21  22  23

    print(df.loc[df['C']<30, ['A','B']]) #행열 선택

    결과
          A   B
    1st  11  12
    2nd  21  22

3 데이터프레임 다루기(중급)

3.1 데이터프레임 클래스

Python의 모든 자료구조는 클래스(class)임
- 클래스는 객체로서 변수와 메소드(함수)의 집합체

따라서 데이터프레임 객체의 변수와 메소드는 직접 사용이 가능함

데이터프레임의 변수와 메서드 보기

  df = pd.DataFrame({'A':[11,21,31], 'B':[12,22,32], 'C':[13,23,33]}, 
                index=['1st','2nd','3rd'])
  print(dir(df)[:20])

  결과
  ['A', 'B', 'C', 'T', '_AXIS_LEN', '_AXIS_ORDERS', '_AXIS_TO_AXIS_NUMBER', '_HANDLED_TYPES', '__abs__', '__add__', '__and__', '__annotations__', '__array__', '__array_priority__', '__array_ufunc__', '__bool__', '__class__', '__contains__', '__copy__', '__dataframe__']

3.2 데이터프레임 변수

데이터프레임의 열

  df = pd.DataFrame({'A':[11,21,31], 'B':[12,22,32], 'C':[13,23,33]}, 
                index=['1st','2nd','3rd'])
  print(df.A) # .컬럼명

  결과
  1st    11
  2nd    21
  3rd    31
  Name: A, dtype: int64

데이터프레임의 T(transpose, 전치행렬)

전치행렬이 이미 클래스 내의 T변수에 저장이 되어 있으므로 별도로 계산할 필요없이 바로 사용하면 됨

  print(df.T) # .T transpose

  결과
     1st  2nd  3rd
  A   11   21   31
  B   12   22   32
  C   13   23   33

3.3 사칙연산

  df1 = pd.DataFrame({'A':[11,21,31], 'B':[12,22,32], 'C':[13,23,33]}
                , index=['1st','2nd','3rd'])
  df2 = pd.DataFrame({'A':[11,21,41], 'B':[12,22,42], 'E':[14,24,44]}
                    , index=['1st','2nd','4th'])

  print(df1+df2)  # 각 원소별 매칭되는 것만 더하기

  결과
          A     B   C   E
  1st  22.0  24.0 NaN NaN
  2nd  42.0  44.0 NaN NaN
  3rd   NaN   NaN NaN NaN
  4th   NaN   NaN NaN NaN

  print(df1.add(df2, fill_value=0)) # 값이 없는 것은 0으로 대체하여 각 원소별 더하기

  결과
          A     B     C     E
  1st  22.0  24.0  13.0  14.0
  2nd  42.0  44.0  23.0  24.0
  3rd  31.0  32.0  33.0   NaN
  4th  41.0  42.0   NaN  44.0

  print(df1.mul(df2, fill_value=1)) # 값이 없는 것은 1로 대체하여 각 원소별 더하기

  결과
           A      B     C     E
  1st  121.0  144.0  13.0  14.0
  2nd  441.0  484.0  23.0  24.0
  3rd   31.0   32.0  33.0   NaN
  4th   41.0   42.0   NaN  44.0

3.4 Assign

기존의 열을 이용하여 새로운 열을 생성

  df = pd.DataFrame({'A':[11,21,31], 'B':[12,22,32], 'C':[13,23,33]}
                , index=['1st','2nd','3rd'])
  print(df)

  결과
        A   B   C
  1st  11  12  13
  2nd  21  22  23
  3rd  31  32  33

새로운 열 생성

  print(df.assign(A_plus_B = df.A+df.B))

  결과
        A   B   C  A_plus_B
  1st  11  12  13        23
  2nd  21  22  23        43
  3rd  31  32  33        63

새로운 열 생성(callable)

  import numpy as np
  print(df.assign(log_A = lambda x:np.log(x.A)))

  결과
        A   B   C     log_A
  1st  11  12  13  2.397895
  2nd  21  22  23  3.044522
  3rd  31  32  33  3.433987

3.5 열 수정

  df = pd.DataFrame({'A':[11,21,31], 'B':[12,22,32], 'C':[13,23,33]}
                , index=['1st','2nd','3rd'])
  df.insert(loc=0, column='D', value=[14,24,34])  # 열 삽입, df자체가 변경됨
  df.insert(loc=2, column='E', value=5)  # 열 삽입
  print(df)

  결과
        D   A  E   B   C
  1st  14  11  5  12  13
  2nd  24  21  5  22  23
  3rd  34  31  5  32  33

  df = df.drop(columns = ['D','E']) # 열 제거, df에 저장해 주어야 함
  print(df)

  결과
        A   B   C
  1st  11  12  13
  2nd  21  22  23
  3rd  31  32  33

  df = df.rename(columns = {'A':'aaa'}) # 열이름 변경
  print(df)

  결과
       aaa   B   C
  1st   11  12  13
  2nd   21  22  23
  3rd   31  32  33

3.6 값 수정

  df = pd.DataFrame({'A':[11,21,31], 'B':[12,22,32], 'C':[13,23,33]}
                , index=['1st','2nd','3rd'])
  print(df)

  결과
        A   B   C
  1st  11  12  13
  2nd  21  22  23
  3rd  31  32  33

위치지정 수정

  df['2nd','A'] = 201  # 잘못된 명령어
  print(df)

  결과
        A   B   C  (2nd, A)
  1st  11  12  13       201
  2nd  21  22  23       201
  3rd  31  32  33       201

  df.loc['2nd','A'] = 222
  print(df)

  결과
         A   B   C  (2nd, A)
  1st   11  12  13       201
  2nd  222  22  23       201
  3rd   31  32  33       201

  df.iloc[:,3] = 'NA'
  print(df)

  결과
         A   B   C (2nd, A)
  1st   11  12  13       NA
  2nd  222  22  23       NA
  3rd   31  32  33       NA

값을 찾아서 대체

  df = df.replace('NA', 1111)
  print(df)

  결과
         A   B   C  (2nd, A)
  1st   11  12  13      1111
  2nd  222  22  23      1111
  3rd   31  32  33      1111

  df = df.replace({'B':32}, 9999)
  print(df)

  결과
         A     B   C  (2nd, A)
  1st   11    12  13      1111
  2nd  222    22  23      1111
  3rd   31  9999  33      1111

3.7 데이터 정렬

  df = pd.DataFrame({'A':[11,21,31], 'B':[12,22,32], 'C':[33,32,31]}
                , index=['1st','2nd','3rd'])
  print(df)

  결과
        A   B   C
  1st  11  12  33
  2nd  21  22  32
  3rd  31  32  31

정렬

  df = df.sort_values(by='A', ascending=False) # 값기준 정렬
  print(df)

  결과
        A   B   C
  3rd  31  32  31
  2nd  21  22  32
  1st  11  12  33

  df = df.sort_index(axis=0)    # 행 index 정렬
  print(df)

  결과
        A   B   C
  1st  11  12  33
  2nd  21  22  32
  3rd  31  32  31

랭크

  df_rank = df.rank(axis=0, method='average', ascending=False)   # 열기준, 평균순위, 역순
  print(df_rank)

  결과
         A    B    C
  1st  3.0  3.0  1.0
  2nd  2.0  2.0  2.0
  3rd  1.0  1.0  3.0

3.8 Melt

pandas.melt()를 이용하여 wide format 데이터를 column format으로 변경
- id_var: 식별자 변수
- value_vars: 해체할 열
- var_name: 변수에 사용할 열이름
- value_name: 해체된 열에 사용할 열이름
- col_level: multiindex인 경우 이 수준을 사용
```
df = pd.DataFrame({'order': ['1st','2nd','3rd'],'A':[11,21,31], 'B':[12,22,32], 'C':[33,32,31]})
print(df)
```
  결과
```
order   A   B   C
```
  0 1st 11 12 33 1 2nd 21 22 32 2 3rd 31 32 31
```
df_melted = pd.melt(df, id_vars=['order'], value_vars=['A','B','C'], var_name='name', value_name='score')
print(df_melted)
```
  결과
```
order name  score
```
  0 1st A 11 1 2nd A 21 2 3rd A 31 3 1st B 12 4 2nd B 22 5 3rd B 32 6 1st C 33 7 2nd C 32 8 3rd C 31
  3.9 통계 처리
  
  산술통계량 계산

axis=0: 열별, axis=1: 행별, ddof=1: 표본 자유도 반영

  print(df.count(axis=0)) # 데이터 갯수

  결과
  order    3
  A        3
  B        3
  C        3
  dtype: int64

최근 파이썬 버전부터는 수치형이 아닌경우 오류가 발생

  df_numeric = df[['A','B','C']]

  df_numeric.mean(axis=1) # 평균

  결과
  0    18.666667
  1    25.000000
  2    31.333333
  dtype: float64

  df_numeric.max(axis=0) # 최대값

  결과
  A    31
  B    32
  C    33
  dtype: int64

  df_numeric.var(axis=1, ddof=1) # 표본분산

  결과
  0    154.333333
  1     37.000000
  2      0.333333
  dtype: float64

  df_numeric.corr() # 상관계수

👉 결과*

기술통계량 요약

    df = pd.DataFrame({'A':[11,21,31,41], 'B':[12,22,32,42], 'C':[13,23,33,43]}
                  , index=['1st','2nd','3rd','4th'])
    print(df.describe()) #기술통계량

    결과
                   A          B          C
    count   4.000000   4.000000   4.000000
    mean   26.000000  27.000000  28.000000
    std    12.909944  12.909944  12.909944
    min    11.000000  12.000000  13.000000
    25%    18.500000  19.500000  20.500000
    50%    26.000000  27.000000  28.000000
    75%    33.500000  34.500000  35.500000
    max    41.000000  42.000000  43.000000

샘플링

    print(df.sample(n=2))

    결과
          A   B   C
    1st  11  12  13
    2nd  21  22  23

    print(df.sample(frac=0.5))

    결과
          A   B   C
    2nd  21  22  23
    1st  11  12  13

3.10 데이터 정제

    df = pd.DataFrame({'A':[11,21,31,None,31], 'B':[12,22,32,42,32], 'C':[13,None,33,43,33]}
                  , index=['1st','2nd','3rd','4th','7th'])
    print(df)

    결과
            A   B     C
    1st  11.0  12  13.0
    2nd  21.0  22   NaN
    3rd  31.0  32  33.0
    4th   NaN  42  43.0
    7th  31.0  32  33.0

중복데이터 제거

    print(df.drop_duplicates())

    결과
            A   B     C
    1st  11.0  12  13.0
    2nd  21.0  22   NaN
    3rd  31.0  32  33.0
    4th   NaN  42  43.0

결측치 행 제거

결측값 있는 행 제거 : df.dropna() or df.dropna(axis=0)

결측값 있는 열 제거 : df.dropna(axis=1)

  print(df.dropna())

  결과
          A   B     C
  1st  11.0  12  13.0
  3rd  31.0  32  33.0
  7th  31.0  32  33.0

결측치 대체

결측값을 특정 값으로 채우기 : df.fillna(특정값)
결측값을 결측값의 앞 행의 값으로 채우기 : df.fillna(method=‘ffill’) or df.fillna(method=‘pad’)
결측값을 결측값의 뒷 행의 값으로 채우기 : df.fillna(method=‘bfill’) or df.fillna(method=‘backfill’)

결측값을 각 열의 평균 값으로 채우기 : df.fillna(df.mean())

print(df)

결과
        A   B     C
1st  11.0  12  13.0
2nd  21.0  22   NaN
3rd  31.0  32  33.0
4th   NaN  42  43.0
7th  31.0  32  33.0

print(df.fillna(axis=1, method='ffill'))

결과
        A     B     C
1st  11.0  12.0  13.0
2nd  21.0  22.0  22.0
3rd  31.0  32.0  33.0
4th   NaN  42.0  43.0
7th  31.0  32.0  33.0

print(df.fillna(df.mean()))

결과
        A   B     C
1st  11.0  12  13.0
2nd  21.0  22  30.5
3rd  31.0  32  33.0
4th  23.5  42  43.0
7th  31.0  32  33.0

3.11 filter

데이터를 필터링하는 유용한 함수

람다함수와 정규표현식(regex) 사용이 가능하여 데이터 전처리시 유용

  df = pd.DataFrame({'abc':[1,4,7], 'bcd':[2,5,8], 'abd':[3,6,9]}, index=['1st','2nd','3rd'])
  print(df)

  결과
       abc  bcd  abd
1st    1    2    3
2nd    4    5    6
3rd    7    8    9

컬럼명으로 선택

  print(df.filter(items=['abc', 'abd']))

  결과
       abc  abd
  1st    1    3
  2nd    4    6
  3rd    7    9

정규표현식으로 선택

  print(df.filter(regex='^ab', axis=1)) # 열이름이 ab로 시작하는 열 선택

  결과
       abc  abd
  1st    1    3
  2nd    4    6
  3rd    7    9

문자열 포함으로 선택

  print(df.filter(like='d', axis=0)) # 인덱스명에 d가 포함된 행 선택

  결과
       abc  bcd  abd
  2nd    4    5    6
  3rd    7    8    9

3.12 Query

조건에 부합하는 데이터를 추출할 때 가장 많이 사용

.loc[ ] 로 구현한 것보다 속도가 느림

  df = pd.DataFrame({'abc':[1,4,7], 'bcd':[2,5,8], 'abd':[3,6,9]}, index=['1st','2nd','3rd'])
  print(df)

  결과
       abc  bcd  abd
  1st    1    2    3
  2nd    4    5    6
  3rd    7    8    9

질의어로 선택

  print(df.query('abc > 3'))

  결과
       abc  bcd  abd
  2nd    4    5    6
  3rd    7    8    9

  print(df.query('(abc > 3) & (abd < 9)'))

  결과
       abc  bcd  abd
  2nd    4    5    6

외부 값(함수) 참조 @

  abd_max = 9
  print(df.query('(abc > 3) & (abd < @abd_max)'))

  결과
       abc  bcd  abd
  2nd    4    5    6

3.13 Groupby

범주별로 그룹을 만들어서 데이터를 처리하고 Series로 반환

  df = pd.DataFrame({'scale':['small','large','small','large']
                 , 'location':['east','east','south','south'], 'sales':[10,20,30,40]})
  print(df)

  결과
     scale location  sales
  0  small     east     10
  1  large     east     20
  2  small    south     30
  3  large    south     40

scale별로 그룹을 나누어 sales의 합계를 구함

  data_s = df.groupby(by='scale')['sales'].sum()
  print(data_s)
  print(type(data_s))  # Series 데이터
  print(data_s.index)
  print(data_s.values)

  결과
  scale
  large    60
  small    40
  Name: sales, dtype: int64
  
  Index(['large', 'small'], dtype='object', name='scale')
  [60 40]

location-scale별로 그룹을 나누어 sales의 평균을 구함

  data_sl = df.groupby(by=['location', 'scale'])['sales'].mean()
  print(data_sl)
  print(type(data_sl))  # Series 데이터
  print(data_sl.index)
  print(data_sl.values)

  결과
  location  scale
  east      large    20.0
            small    10.0
  south     large    40.0
            small    30.0
  Name: sales, dtype: float64
  
  MultiIndex([( 'east', 'large'),
              ( 'east', 'small'),
              ('south', 'large'),
              ('south', 'small')],
             names=['location', 'scale'])
  [20. 10. 40. 30.]

location-scale별로 그룹을 나누어 sales의 평균을 구하여 데이터프레임으로 반환

  data_sl = df.groupby(by=['location', 'scale'])[['sales']].mean()
  print(data_sl)
  print(type(data_sl))  # Series 데이터
  print(data_sl.index)
  print(data_sl.values)

  결과
                  sales
location scale       
east     large   20.0
         small   10.0
south    large   40.0
         small   30.0

MultiIndex([( 'east', 'large'),
            ( 'east', 'small'),
            ('south', 'large'),
            ('south', 'small')],
           names=['location', 'scale'])
[[20.]
 [10.]
 [40.]
 [30.]]

3.14 Apply

객체(함수)를 반복하여 적용

파이썬 내장함수 map과 유사

  df = pd.DataFrame({'scale':['small','large','small','large']
                 , 'location':['east','east','south','south'], 'sales':[10,20,30,40]})
  print(df)

  결과
     scale location  sales
  0  small     east     10
  1  large     east     20
  2  small    south     30
  3  large    south     40

map 적용

  print(list(map(lambda x: x**2, df.sales)))

  결과
  [100, 400, 900, 1600]

apply 적용

  print(df.sales.apply(lambda x: x**2))

  결과
  0     100
  1     400
  2     900
  3    1600
  Name: sales, dtype: int64

3.15 Join

  df1 = pd.DataFrame({'id':['1st','2nd','3rd'], 'name': ['홍길동', '임꺽정', '김홍익']})
  df2 = pd.DataFrame({'id':['2nd','3rd','4th'], 'address': ['서울', '강원도', '경기도']})
  print(df1)
  print(df2)

  결과
      id name
  0  1st  홍길동
  1  2nd  임꺽정
  2  3rd  김홍익
      id address
  0  2nd      서울
  1  3rd     강원도
  2  4th     경기도

합치기(Concat) -> axis = 0: 행으로 합침, axis = 1: 열로 합침

  concat_row = pd.concat([df1,df2], axis = 0)
  concat_col = pd.concat([df1,df2], axis = 1)

  print('행으로 합침: \n', concat_row)
  print('열로 합침: \n', concat_col)

  결과
  행으로 합침:

id name address 0 1st 홍길동 NaN 1 2nd 임꺽정 NaN 2 3rd 김홍익 NaN 0 2nd NaN 서울 1 3rd NaN 강원도 2 4th NaN 경기도 열로 합침:

   id name   id address

0 1st 홍길동 2nd 서울 1 2nd 임꺽정 3rd 강원도 2 3rd 김홍익 4th 경기도

조인(Join)

내부 결합(Inner Join): 두 개의 테이블 키가 일치하는 데이터만 추출
외부 결합(Outer Join): 두 개의 테이블 키와 관련된 모든 데이터 추출
```
  inner_join = pd.merge(df1, df2, on='id', how='inner')
  outer_join = pd.merge(df1, df2, on='id', how='outer')
  print('inner: \n', inner_join)
  print('outer: \n', outer_join)
```
```
  결과
  inner: 
```
id name address 0 2nd 임꺽정 서울 1 3rd 김홍익 강원도 outer:
```
   id name address
```
0 1st 홍길동 NaN 1 2nd 임꺽정 서울 2 3rd 김홍익 강원도 3 4th NaN 경기도
좌 결합(Left Join): 왼쪽 테이블 키와 일치하는 데이터 추출

우 결합(Right Join): 오른쪽 테이블 키와 일치하는 데이터 추출

  left_join = pd.merge(df1, df2, on='id', how='left')
  right_join = pd.merge(df1, df2, on='id', how='right')
  print('left: \n', left_join)
  print('right: \n', right_join)

  결과
  left:

id name address 0 1st 홍길동 NaN 1 2nd 임꺽정 서울 2 3rd 김홍익 강원도 right:

   id name address

0 2nd 임꺽정 서울 1 3rd 김홍익 강원도 2 4th NaN 경기도

4 데이터프레임 다루기(고급)

4.1 메서드 결합

  df = pd.DataFrame({'name':['Kim','Lee','Park','Kim','Lee','Kim']
                 , 'sex':['M','F','F','M','F','M']
                 , 'age':[20,25,30,20,25,20]
                 , 'class':['DS','DS','DS','PP','PP','DV']})
  print(df)

  결과
     name sex  age class
  0   Kim   M   20    DS
  1   Lee   F   25    DS
  2  Park   F   30    DS
  3   Kim   M   20    PP
  4   Lee   F   25    PP
  5   Kim   M   20    DV

class 별 수강학생수

  df.groupby(by='class')['name'].count()

  결과
  class

DS 3 DV 1 PP 2 Name: name, dtype: int64

학생별 수강교과목의 갯수

  df.groupby(by=['name','sex','age'])['class'].count()

  결과
  name  sex  age

Kim M 20 3 Lee F 25 2 Park F 30 1 Name: class, dtype: int64

학생별 수강교과목이 2개 이상인 데이터만 필터링

  df.groupby(by=['name','sex','age']).filter(lambda x: len(x)>=2)

👉 결과*

2 class 이상 수강하는 학생의 이름

    df.groupby(by=['name','sex','age']).filter(lambda x: len(x)>=2)['name'].unique()

    결과
    array(['Kim', 'Lee'], dtype=object)

2 class 이상 수강하는 학생의 평균 나이

     (df
       .groupby(by=['name','sex','age'])
       .filter(lambda x: len(x)>=2)[['name','age']]
       .drop_duplicates()['age']
       .mean())

    결과
    22.5

4.2 Pandas 그래프

판다스는 Matplotlib 라이브러리의 기능을 일부 내장하고 있어 간단한 그래프를 그릴 수 있음
판다스에서 제공하는 plot(kind=＇옵션’) 메소드를 이용하여 그림
- ‘line’ : line plot (default)
- ‘bar’ : vertical bar plot
  - ‘barh’ : horizontal bar plot
- ‘hist’ : histogram
- ‘box’ : boxplot
- ‘kde’ : Kernel Density Estimation plot
- ‘density’ : same as ‘kde’
- ‘area’ : area plot
- ‘pie’ : pie plot
- scatter’ : scatter plot (DataFrame only)
- ‘hexbin’ : hexbin plot (DataFrame only)
```
import pandas as pd
import matplotlib.pyplot as plt

df1 = pd.DataFrame(np.random.rand(5))
print(df1.head())

df2 = pd.DataFrame(np.random.rand(5))
print(df2.head())
```
  결과
```
        0
```
  0 0.603505 1 0.638853 2 0.686185 3 0.773065 4 0.742881
```
        0
```
  0 0.401318 1 0.021973 2 0.496399 3 0.966737 4 0.949217
```
df1.plot()
df2.plot()
plt.title("랜덤 넘버 df1")
plt.rc('font', family='gulim')  
plt.show()
```
👉 결과1*

👉 결과2

    df = pd.concat([df1,df2], axis=1)
    df.columns = ['df1', 'df2']
    print(df.head())
    df.plot()

👉 결과

    df.plot(kind='barh')

👉 결과

    df.plot(kind='area')

👉 결과

    df.plot(kind='scatter', x='df1', y='df2')

👉 결과

5 다양한 그래프 그려보기

아래 그래프가 출력될 수 있도록 코드를 작성해보자

  import matplotlib.pyplot as plt

  fig, ax = plt.subplots()

  fruits = ['apple', 'blueberry', 'cherry', 'orange']
  counts = [40, 100, 30, 55]
  bar_labels = ['red', 'blue', '_red', 'orange']
  bar_colors = ['tab:red', 'tab:blue', 'tab:red', 'tab:orange']

  ax.bar(fruits, counts, label=bar_labels, color=bar_colors)

  ax.set_ylabel('fruit supply')
  ax.set_title('Fruit supply by kind and color')
  ax.legend(title='Fruit color')

  plt.show()

👉 결과*

    import matplotlib.pyplot as plt

    data = {'apple': 10, 'orange': 15, 'lemon': 5, 'lime': 20}
    names = list(data.keys())
    values = list(data.values())

    fig, axs = plt.subplots(1, 3, figsize=(9, 3), sharey=True)
    axs[0].bar(names, values)
    axs[1].scatter(names, values)
    axs[2].plot(names, values)
    fig.suptitle('Categorical Plotting')

👉 결과

    import numpy as np
    import matplotlib.pyplot as plt

    # Fixing random state for reproducibility
    np.random.seed(19680801)

    dt = 0.01
    t = np.arange(0, 30, dt)
    nse1 = np.random.randn(len(t))                 # white noise 1
    nse2 = np.random.randn(len(t))                 # white noise 2

    # Two signals with a coherent part at 10 Hz and a random part
    s1 = np.sin(2 * np.pi * 10 * t) + nse1
    s2 = np.sin(2 * np.pi * 10 * t) + nse2

    fig, axs = plt.subplots(2, 1)
    axs[0].plot(t, s1, t, s2)
    axs[0].set_xlim(0, 2)
    axs[0].set_xlabel('Time')
    axs[0].set_ylabel('s1 and s2')
    axs[0].grid(True)

    cxy, f = axs[1].cohere(s1, s2, 256, 1. / dt)
    axs[1].set_ylabel('Coherence')

    fig.tight_layout()
    plt.show()

👉 결과

    import matplotlib.pyplot as plt
    import pandas as pd

    ts = pd.Series(np.random.randn(1000), index=pd.date_range("1/1/2000", periods=1000))
    ts = ts.cumsum()
    ts.plot()

👉 결과

    df = pd.DataFrame(np.random.randn(1000, 4), index=ts.index, columns=list("ABCD"))
    df = df.cumsum()
    plt.figure()
    df.plot()

👉 결과

    df2 = pd.DataFrame(np.random.rand(10, 4), columns=["a", "b", "c", "d"])
    df2.plot.bar()

👉 결과

    df2.plot.bar(stacked=True)

👉 결과

    df2.plot.barh(stacked=True)

👉 결과

    df4 = pd.DataFrame(
    {
        "a": np.random.randn(1000) + 1,
        "b": np.random.randn(1000),
        "c": np.random.randn(1000) - 1,
    },
    columns=["a", "b", "c"],
)
    plt.figure()
    df4.plot.hist(alpha=0.5)

👉 결과

    df = pd.DataFrame(np.random.rand(10, 5), columns=["A", "B", "C", "D", "E"])
    df.plot.box()

👉 결과

Py-Numpy

Sun, 24 Sep 2023 16:44:38 GMT

1 Numpy 다루기

배열(array)는 벡터(1D) 또는 행렬(2D이상)
- List와 유사하나 List는 이종의 자료형이 가능하고, 수치 연산의 형태가 상이함
- 원소의 개수를 바꿀 수 없음
Numpy는 배열 연산과 관련된 편리한 기능을 제공
- 적은 메모리 사용으로 연산속도가 빠름
- 벡터화 연산, 배열 인덱싱들을 통한 질의가 가능함
파이썬에서는 기본적으로 배열 자료형을 제공하지 않기 때문에 배열을 다루기 위해서는 numpy를 이용함
1.1 배열(Array) 만들기

값을 이용하여 배열 만들기
배열을 생성하고 유형 확인하기
```
import numpy as np
```

a = np.array([[1, 2, 3], [4, 5, 6]]) # 입력한 데이터 유형에 따라 자동으로 dtype이 설정됨 print(a) print(a.shape) print(a.dtype)

    결과
    [[1 2 3]
     [4 5 6]]
    (2, 3)
    int32
``` python
    a = np.array([[1.0, 2, 3], [4, 5, 6]]) # 입력한 데이터 유형에 따라 자동으로 dtype이 설정됨
    print(a)
    print(a.shape)
    print(a.dtype)

    결과
    [[1. 2. 3.]
     [4. 5. 6.]]
    (2, 3)
    float64

배열의 유형을 변경하기

  a = a.astype(np.int32) # dtype을 변경할 수 있음
  print(a)
  print(a.dtype)

  결과
  [[1 2 3]
   [4 5 6]]
  int32

유형을 지정하여 생성하기

  a = np.array([[1.2, 2.5, 3.7], [4, 5, 6]], dtype=np.int32) # 데이터는 반올림하지 않고 절삭함
  print(a)
  print(a.shape)
  print(a.dtype)

  결과
  [[1 2 3]
   [4 5 6]]
  (2, 3)
  int32

배열의 크기를 확인하기

  print(a.shape) # (행의 크기, 열의 크기)를 튜플로 반환
  print(a.size) # 데이터의 갯수를 값으로 반환
  print(len(a)) # inatance(행)의 갯수를 값으로 반환

  결과
  (2, 3)
  6
  2

등간격의 배열 만들기

arrange(처음값, 마지막 값, 간격) : 처음값부터 (마지막 값-1)까지 간격(default=1)으로 정수 생성

   np.arange(0,10,2) # 0부터 10까지 2씩 증가하는 1차원 배열 생성

  결과
  array([0, 2, 4, 6, 8])

  np.arange(0,10)

  결과
  array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

  np.arange(0,10.8,0.7)

  결과
  array([ 0. ,  0.7,  1.4,  2.1,  2.8,  3.5,  4.2,  4.9,  5.6,  6.3,  7. ,
  7.7,  8.4,  9.1,  9.8, 10.5])

  np.arange(10,0,-1)

  결과
  array([10,  9,  8,  7,  6,  5,  4,  3,  2,  1])

  np.arange(10) # 시작값 디폴트 0, 증가값 디폴트 1

  결과
  array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

linspace(시작값, 마지막값, 갯수) : 시작값(포함)부터 마지막값(포함)까지 등간격으로 갯수(default=50)만큼 값 생성

  np.linspace(0,10,10)

  결과
  array([ 0.        ,  1.11111111,  2.22222222,  3.33333333,  4.44444444,
  5.55555556,  6.66666667,  7.77777778,  8.88888889, 10.        ])

  np.linspace(5,-5,9)

  결과
  array([ 5.  ,  3.75,  2.5 ,  1.25,  0.  , -1.25, -2.5 , -3.75, -5.  ])

empty, zeros, ones 배열 만들기

empty(빈배열) : 현재 메모리에 있는 값 그대로 빈 공간만 생성

  e = np.empty([3,3])
  print(e)

  결과
  [[ 5.    3.75  2.5 ]
   [ 1.25  0.   -1.25]
   [-2.5  -3.75 -5.  ]]

zeros(영배열) : 모든 원소가 0인 배열 생성

  z = np.zeros([3,3], dtype=np.int32)  # dtype의 디폴트는 float64
  print(z)

  결과
  [[0 0 0]
   [0 0 0]
   [0 0 0]]

ones(1배열) : 모든 원소가 1인 배열 생성

  o = np.ones([3,3])
  print(o)

  결과
  [[1. 1. 1.]
   [1. 1. 1.]
   [1. 1. 1.]]

랜덤 배열 만들기

seed는 랜덤값을 생성할 때, 시작점을 의미
seed를 지정해 주지 않으면, 매번 실행할 때마다 값이 변경됨
- 테스트할 때마다 값이 변경되므로 비교 평가가 불가함
- 따라서 seed를 지정해서 실험을 하고, 실제로 실행할 경우에는 이를 해제함
```
np.random.seed(0)  
```

random.randint(): 지정한 값 사이의 정수를 랜덤으로 생성

  np.random.randint(10) # 0에서 (10-1)사이의 랜덤 정수 생성

  결과
  7

  np.random.randint(0,10,15) #0에서 (10-1)사이의 랜덤 정수 15개 생성

  결과
  array([8, 0, 8, 5, 9, 3, 7, 1, 8, 2, 6, 1, 6, 2, 7])

random.rand(): 0 이상 1 미만의 임의의 값을 생성

  np.random.rand(10) # 10개의 랜덤값을 가진 어레이 생성

  결과
  array([0.35433176, 0.75517944, 0.15649   , 0.05942972, 0.22688245,
 0.72483354, 0.64809509, 0.77758691, 0.34826044, 0.54150907])

  np.random.rand(2,5) # 랜덤 행렬 생성

  결과
  array([[0.08217991, 0.29054503, 0.45048709, 0.27329039, 0.37529013],
 [0.53922297, 0.40800884, 0.26610577, 0.51821411, 0.95936814]])

1.2 실습

    a = np.array([[1,2,3],[4,5,6]]) # 2차원 배열 생성
    print(a)

    결과
    [[1 2 3]
     [4 5 6]]

     np.arange(10).reshape(2,5) # 1부터 10까지 1차원 배열 생성 후 2 by 5로 변환

    결과
    array([[0, 1, 2, 3, 4],
              [5, 6, 7, 8, 9]])

    np.arange(2,3,0.1)  # 2이상 3미만 0.1간격 배열생성

    결과
    array([2. , 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9])

    np.linspace(1.0,4.0,6) # 1.0이상 4.0이하 등간격 6원소 배열생성

    결과
    array([1. , 1.6, 2.2, 2.8, 3.4, 4. ])

    np.zeros((2,2),int) # 2 by 2 정수 영행렬 생성

    결과
    array([[0, 0],
              [0, 0]])

    np.zeros((2,2),float) # 2by2 float 0행렬

    결과
    array([[0., 0.],
           [0., 0.]])

    np.ones((2,2)) # 2by2 float 1행렬

    결과
    array([[1., 1.],
           [1., 1.]])

    np.full((2,2), 7) # 2by2 행렬을 7로 채움

    결과
    array([[7, 7],
           [7, 7]])

    np.eye(2) # 2by2 eigen 행렬

    결과
    array([[1., 0.],
           [0., 1.]])

    np.random.random((2,2)) # 2by2 random 생성

    결과
    array([[0.42961291, 0.6709883 ],
           [0.71483539, 0.01489149]])

1.3 배열 다루기

배열 모양 바꾸기

배열 풀기 -> 열벡터로 변환

  a = np.array([[1,2,3],[4,5,6]]) # 2차원 배열 생성
  print(f'{a = }')
  print(f'{a.reshape(-1) = }') # 1차원 배열로 변환
  print(f'{a = }') # 원본은 변하지 않음

  결과
  a = array([[1, 2, 3],
             [4, 5, 6]])
  a.reshape(-1) = array([1, 2, 3, 4, 5, 6])
  a = array([[1, 2, 3],
             [4, 5, 6]])

배열은 변경 후 별도의 저장을 하지 않으면, 변경되지 않음

  a_61 = a.reshape(-1) 
  print(f'{a_61 = }')
  print(f'{a_61.shape = }')
  print(f'{a = }') # 원본은 변하지 않음

  결과
  a_61 = array([1, 2, 3, 4, 5, 6])
  a_61.shape = (6,)
  a = array([[1, 2, 3],
                [4, 5, 6]])

배열의 모양을 바꾸기 -> 열벡터로 변환 후 재배정함

  a_32 = a.reshape(3,2)
  print(a_32)

  결과
  [[1 2]
   [3 4]
   [5 6]]

2 인덱싱과 슬라이싱

2.1 인덱싱(Indexing)

배열에서 원소를 찾는 것

인덱스는 0부터 시작

맨 뒤는 -1

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

print('a = \n', a)
print(f'{a[2,2] = }') # 인덱스 2행, 인덱스 2열 원소
print(f'{a[(2,2)] = }') # 인덱스 2행, 인덱스 2열 원소
print(f'{a[1,2] = }') # 인덱스 1행, 인덱스 2열 원소
print(f'{a[-1,-1] = }') # 마지막행, 마지막열 원소

결과 a = [[ 1 2 3 4] [ 5 6 7 8] [ 9 10 11 12]] a[2,2] = 11 a[(2,2)] = 11 a[1,2] = 7 a[-1,-1] = 12

2.2 슬라이싱(Slicing)

배열에서 부분집합을 가져오는 것

i:j -> i에서 (j-1)까지

print('a = \n', a)
print(f'{a[1,0:1] = }') # 슬라이싱은 부분을 취하는 것이므로 원본과 같은 어레이가 반환됨
print(f'{a[1,:] = }') # 인덱스 1행, 모든열
print(f'{a[:,1] = }') # 모든행, 인덱스 1열

결과 a = [[ 1 2 3 4] [ 5 6 7 8] [ 9 10 11 12]] a[1,0:1] = array([5]) a[1,:] = array([5, 6, 7, 8]) a[:,1] = array([ 2, 6, 10])

print(f'{a[:2,:] = }') # 인덱스 0부터 인덱스 2미만행, 모든열

결과 a[:2,:] = array([[1, 2, 3, 4],

                  [5, 6, 7, 8]])

print(f'{a[:2,1:3] = }') # 인덱스 0부터 인덱스 2미만행,  인덱스 1부터 3미만 열
print(f'{a[:,0:3:2] = }') # 모든행, 0부터 3미만 2간격 모든열
print(f'{a[:,-1:-4:-2]= }') # 모든행, 마지막열부터 -4미만 -2간격 모든열

결과 a[:2,1:3] = array([[2, 3],

                    [6, 7]])

a[:,0:3:2] = array([[ 1, 3],

                  [ 5,  7],
                  [ 9, 11]])

a[:,-1:-4:-2]= array([[ 4, 2],

                       [ 8,  6],
                       [12, 10]])

print(f'{a[:,[3,0,2,1]] = }') # 모든행, 3,0,2,1열 순서로
print(f'{a[[0,1,2],[0,1,2]] = }') # [0,0],[1,1],[1,2] 원소

결과 a[:,[3,0,2,1]] = array([[ 4, 1, 3, 2],

     [ 8,  5,  7,  6],
     [12,  9, 11, 10]])

a[[0,1,2],[0,1,2]] = array([ 1, 6, 11])

print(f'{a = }')
a[0,0] = 100  # 인덱스 0행, 인덱스 0열 원소를 100으로 변경
print(f'{a = }')

결과 a = array([[ 1, 2, 3, 4],

         [ 5,  6,  7,  8],
         [ 9, 10, 11, 12]])

a = array([[100, 2, 3, 4],

         [  5,   6,   7,   8],
         [  9,  10,  11,  12]])

3 얕은 복사(shallow copy)와 깊은 복사(deep copy)

3.1 mutable과 immutable

mutable : 배열에서 원소의 수정 가능한 자료형
- 리스트(List), 집합(Set), 딕셔너리(Dictionary)

immutable : 배열에서 원소의 수정이 불가능한 자료형

문자열(String), 튜플(Tuple), Boolean, Number

mutable 동작원리

ls = [1,2,3] # 리스트 생성
arr = np.array(ls)  # 리스트로 배열 생성
print(f'{ls = }')
print(f'{arr = }')
print(f'{id(ls) = }') # 리스트의 주소 확인
print(f'{id(arr) = }') # 배열의 주소 확인, ls와 arr은 완전히 다른 객체

결과 ls = [1, 2, 3] arr = array([1, 2, 3]) id(ls) = 2448791471360 id(arr) = 2448738516496

변수의 값을 변경하더라도 변수의 주소는 동일하고 배열의 값만 바뀜

  ls[0] = 10
  arr[0] = 100
  print(f'{ls = }')
  print(f'{arr = }')
  print(f'{id(ls) = }') # 리스트의 주소 확인
  print(f'{id(arr) = }') # 배열의 주소 확인

  결과
  ls = [10, 2, 3]
  arr = array([100,   2,   3])
  id(ls) = 2448791471360
  id(arr) = 2448738516496

다른 배열을 할당하면, 주소가 바뀜

  ls = [4,5,6] # 리스트에 다른 값 배정
  print(f'{ls = }')
  print(f'{arr = }')
  print(f'{id(ls) = }') # 리스트의 주소 확인
  print(f'{id(arr) = }') # 배열의 주소 확인

  결과
  ls = [4, 5, 6]
  arr = array([100,   2,   3])
  id(ls) = 2448791484224
  id(arr) = 2448738516496

  arr = np.array([4,5,6])  # 다른 배열 배정
  print(f'{ls = }')
  print(f'{arr = }')
  print(f'{id(ls) = }') # 리스트의 주소 확인
  print(f'{id(arr) = }') # 배열의 주소 확인

  결과
  ls = [4, 5, 6]
  arr = array([4, 5, 6])
  id(ls) = 2448791484224
  id(arr) = 2448791602448

3.2 얕은 복사(shallow copy)

다른 변수로 복사하면 주소는 동일함

  arr = np.array([1,2,3])  # 배열 배정
  print(f'{arr = }')
  print(f'{id(arr) = }') # 배열의 주소 확인

  arr_shallow_copied = arr

  print(f'{arr_shallow_copied = }')
  print(f'{id(arr_shallow_copied) = }') # 배열의 주소 확인, arr과 동일 주소

  결과
  arr = array([1, 2, 3])
  id(arr) = 2448791602256
  arr_shallow_copied = array([1, 2, 3])
  id(arr_shallow_copied) = 2448791602256

두 변수는 동일한 주소를 가지고 있으므로, 하나의 값을 변경하면 다른 하나도 변경됨

  arr[0] = 500
  arr_shallow_copied[2] = 1000

  print(f'{arr = }') # 원본 복사본 모두 변경됨
  print(f'{arr_shallow_copied = }') # 원본 복사본 모두 변경됨

  결과
  arr = array([ 500,    2, 1000])
  arr_shallow_copied = array([ 500,    2, 1000])

3.3 깊은 복사(deep copy)

이러한 현상을 해소하기 위해서는 deep copy를 해야함

  arr = np.array([1,2,3])  # 배열 배정
  print(f'{arr = }')
  print(f'{id(arr) = }') # 배열의 주소 확인

  import copy
  arr_deep_copied = copy.deepcopy(arr)
  arr_copied = arr.copy()  # copy() 메소드를 사용하여 복사, 파이썬 내장함수, 1차원 배열만 가능

  print(f'{arr_deep_copied = }')
  print(f'{id(arr_deep_copied) = }') # 배열의 주소 확인, arr과 다른 주소

  print(f'{arr_copied = }')
  print(f'{id(arr_copied) = }') # 배열의 주소 확인, arr과 다른 주소

  결과
  arr = array([1, 2, 3])
  id(arr) = 2448791602832
  arr_deep_copied = array([1, 2, 3])
  id(arr_deep_copied) = 2448791602448
  arr_copied = array([1, 2, 3])
  id(arr_copied) = 2448791603024

  arr[0] = 500
  arr_deep_copied[2] = 1000

  print(f'{arr = }') # 각각의 값만 변경됨
  print(f'{arr_deep_copied = }') # 각각의 값만 변경됨

  결과
  arr = array([500,   2,   3])
  arr_deep_copied = array([   1,    2, 1000])

4 배열 연산하기

4.1 사칙연산

    a = np.arange(9).reshape(3, 3)
    a

    결과
    array([[0, 1, 2],
           [3, 4, 5],
           [6, 7, 8]])

배열과 수치의 연산

a+3

  결과
  array([[ 3,  4,  5],
         [ 6,  7,  8],
         [ 9, 10, 11]])

  a+3.0

  결과
  array([[ 3.,  4.,  5.],
         [ 6.,  7.,  8.],
         [ 9., 10., 11.]])

a*3

  결과
  array([[ 0,  3,  6],
         [ 9, 12, 15],
         [18, 21, 24]])

a/3

  결과
  array([[0.        , 0.33333333, 0.66666667],
         [1.        , 1.33333333, 1.66666667],
         [2.        , 2.33333333, 2.66666667]])

  a**2

  결과
  array([[ 0,  1,  4],
         [ 9, 16, 25],
         [36, 49, 64]])

배열과 벡터의 연산(브로드캐스팅 : shape가 다른 배열 간에도 자동반복하여 연산이 가능하게 하는 것)

  a = np.arange(9).reshape(3, 3)
  b = np.array([100, 200, 300])
  print(f'{a = }')
  print(f'{b = }')

  결과
  a = array([[0, 1, 2],
             [3, 4, 5],
             [6, 7, 8]])
  b = array([100, 200, 300])

  a+b  # 각 행마다 벡터를 원소끼리 더함

  결과
  array([[100, 201, 302],
         [103, 204, 305],
         [106, 207, 308]])

  a*b  # 각 행마다 벡터를 원소끼리 곱함

  결과
  array([[   0,  200,  600],
         [ 300,  800, 1500],
         [ 600, 1400, 2400]])

배열과 배열의 연산

  a = np.arange(9).reshape(3, 3)
  print(f'{a = }')
  c = np.arange(0,90,10).reshape(3, 3)
  print(f'{c = }')

  결과
  a = array([[0, 1, 2],
             [3, 4, 5],
             [6, 7, 8]])
  c = array([[ 0, 10, 20],
             [30, 40, 50],
             [60, 70, 80]])

  a+c  # 동일 위치의 원소끼리 더함

  결과
  array([[ 0, 11, 22],
         [33, 44, 55],
         [66, 77, 88]])

  a*c  # 동일 위치의 원소끼리 곱함

  결과
  array([[  0,  10,  40],
         [ 90, 160, 250],
         [360, 490, 640]])

4.2 메서드를 이용한 연산

배열은 일종의 클래스 오브젝트로서 자체 변수와 메서드를 가지고 있음

  a = np.arange(9).reshape(3, 3)
  a

  결과
  array([[0, 1, 2],
         [3, 4, 5],
         [6, 7, 8]])

  a.sum() # 모든 원소의 합

  결과
  36

  a.sum(axis=0)  # 열별 합

  결과
  array([ 9, 12, 15])

  a.sum(axis=1)  # 행별 합

  결과
  array([ 3, 12, 21])

   print(f'{a.min()= }, {a.max()= }, {a.mean()= }, {a.std()= }, {a.var()= }')

  결과
  a.min()= 0, a.max()= 8, a.mean()= 4.0, a.std()= 2.581988897471611, a.var()= 6.666666666666667

4.3 numpy 함수를 이용한 연산

    print('a = \n', a)
    print('c = \n', c)

    결과
    a = 
     [[0 1 2]
     [3 4 5]
     [6 7 8]]
    c = 
     [[ 0 10 20]
     [30 40 50]
     [60 70 80]]

    np.sqrt(a) # 원소별 연산

    결과
    array([[0.        , 1.        , 1.41421356],
           [1.73205081, 2.        , 2.23606798],
           [2.44948974, 2.64575131, 2.82842712]])

    np.dot(a, c.transpose()) # 행렬 연산

    결과
    array([[  50,  140,  230],
           [ 140,  500,  860],
           [ 230,  860, 1490]])

    np.dot(a, c.T) # 행렬 연산

    결과
    array([[  50,  140,  230],
           [ 140,  500,  860],
           [ 230,  860, 1490]])

4.3-1 기타 유용한 배열 연산

찾기 및 추출

    a = np.arange(9).reshape(3, 3)
    print('a = \n', a)

    a>5 # a의 원소 중 5보다 큰 것

    결과
    array([[False, False, False],
           [False, False, False],
           [ True,  True,  True]])

    a[a>5] # a의 원소 중 5보다 큰 것만 뽑아냄

    결과
    array([6, 7, 8])

    (a>3)&(a<=7) # a의 원소 중 3보다 크고 7보다 작거나 같은 것

    결과
    array([[False, False, False],
           [False,  True,  True],
           [ True,  True, False]])

    a[(a>3)&(a<=7)] # a의 원소 중 3보다 크고 7보다 작거나 같은 것만 뽑아냄

    결과
    array([4, 5, 6, 7])

4.4 기타 함수

    np.empty_like(a)   # a와 동일한 shape를 가지며 비어있는 행렬 생성

    결과
    array([[        0,         1,         0],
           [  5570652,      1544,         0],
           [      768,       181, 572533794]])

    np.tile(a, (3, 2)) # a 를 3행 2열로 쌓음

    결과
    array([[0, 1, 2, 0, 1, 2],
           [3, 4, 5, 3, 4, 5],
           [6, 7, 8, 6, 7, 8],
           [0, 1, 2, 0, 1, 2],
           [3, 4, 5, 3, 4, 5],
           [6, 7, 8, 6, 7, 8],
           [0, 1, 2, 0, 1, 2],
           [3, 4, 5, 3, 4, 5],
           [6, 7, 8, 6, 7, 8]])

    a = np.arange(6).reshape(2, 3)
    b = np.arange(0,60,10).reshape(2, 3)
    print('a = \n', a)
    print('b = \n', b)

    결과
    a = 
     [[0 1 2]
     [3 4 5]]
    b = 
     [[ 0 10 20]
     [30 40 50]]

    np.vstack((a,b)) # 수직으로 쌓음

    결과
    array([[ 0,  1,  2],
           [ 3,  4,  5],
           [ 0, 10, 20],
           [30, 40, 50]])

    np.hstack((a,b)) # 수평으로 쌓음

    결과
    array([[ 0,  1,  2,  0, 10, 20],
           [ 3,  4,  5, 30, 40, 50]])

    np.concatenate((a,b), axis=0) # 수직으로 쌓음

    결과
    array([[ 0,  1,  2],
           [ 3,  4,  5],
           [ 0, 10, 20],
           [30, 40, 50]])

    np.concatenate((a,b), axis=1) # 수평으로 쌓음

    결과
    array([[ 0,  1,  2,  0, 10, 20],
              [ 3,  4,  5, 30, 40, 50]])

    np.concatenate((a,b), axis=None) # 1차원 배열로 쌓음

    결과
    array([ 0,  1,  2,  3,  4,  5,  0, 10, 20, 30, 40, 50])

    np.r_[a,b] # 수직으로 쌓음

    결과
    array([[ 0,  1,  2],
           [ 3,  4,  5],
           [ 0, 10, 20],
           [30, 40, 50]])

    np.c_[a,b] # 수평으로 쌓음

    결과
    array([[ 0,  1,  2,  0, 10, 20],
              [ 3,  4,  5, 30, 40, 50]])

    np.ravel(a, order='C') # 1차원 배열로 변환 (C: row 우선 디폴트, F: column 우선)

    결과
    array([0, 1, 2, 3, 4, 5])

    np.ravel(a, order='F') # 1차원 배열로 변환 (C: row 우선 디폴트, F: column 우선)

    결과
    array([0, 3, 1, 4, 2, 5])

Py-파이썬 기초

Sun, 24 Sep 2023 14:59:19 GMT

1 파이썬의 기본 자료구조

1.1 데이터의 유형(type)

수치형(Number) : 수치형 데이터, int, float, complex

123, 123.45, (123+45j)
문자열(String) : 문자 또는 문자의 집합

'abc', "abc"
리스트(List) : 다양한 타입의 데이터 목록

['abc', 123]
튜플(Tuple) : 다양한 타입의 데이터 목록, 리스트와 유사하나 원소의 변경이 불가

('abc', 123)
딕셔너리(Dictionary) : key:value 조합의 데이터

{'name':'Youngeun', 'id':0831}

변수에 데이터를 배정(assignment)하고 유형 확인
```
x_value=12345
print(f'{x_value=}\n{type(x_value)=}')
```
👉 결과 x_value = 12345 type(x_value) =

x_str = 'abcde' 
print(f'{x_str = }\n{type(x_str) = }')

👉 결과 x_str = 'abcde' type(x_str) =

x_list = [x_str, x_value] 
print(f'{x_list = }\n{type(x_list) = }')

👉 결과 x_list = ['abcde', 12345] type(x_list) =

x_tuple = (x_str, x_value)
print(f'{x_tuple=}\n{type(x_tuple)=}')

👉 결과 x_tuple=('abcde', 12345) type(x_tuple)=

x_dict = {'name': 'Youngeun', 'id':83100}
print(f'{x_dict=}\n{type(x_dict)=}')

👉 결과 x_dict={'name': 'Youngeun', 'id': 83100} type(x_dict) =

1.2 mutable과 immutable

mutable : 배열에서 원소의 수정 가능한 자료형
- 리스트(List), 딕셔너리(Ditionary)
immutable : 배열에서 원소의 수정이 불가능한 자료형
- 문자열(String), 튜플(Tuple)
  mutable: 리스트(List)
```
print(f'Before: {x_list = }')
x_list[1] = 'fghij'  # 인덱스 1 원소를 'fghij'로 변경
print(f'After : {x_list = }')
```
👉 결과* Before: x_list = ['abcde', 12345] After : x_list = ['abcde', 'fghij']

mutable: 딕셔너리(Dictionary)

print(f'Before: {x_dict = }')
x_dict['name'] = 'Gildong Hong'  # 인덱스 1 원소를 'fghij'로 변경
print(f'After : {x_dict = }')

👉 결과
Before: x_dict = {'name': 'Youngeun', 'id': 83100} After : x_dict = {'name': 'Gildong Hong', 'id': 83100}

immutable: 문자열 -> 원소 바꾸기 불가능

print(f'Before: {x_str = }')
x_str[1] = '2'  # 인덱스 1 원소를 '2'로 변경
print(f'After : {x_str = }')

👉 결과 Before: x_str = 'abcde'

TypeError: 'str' object does not support item assignment

immutable: 튜플 -> 원소 바꾸기 불가능

print(f'Before: {x_tuple = }')
x_tuple[1] = 'fghij'  # 인덱스 1 원소를 'fghij'로 변경
print(f'After : {x_tuple = }')

👉 결과 Before: x_tuple = ('abcde', 12345)

TypeError: 'tuple' object does not support item assignment

2 인덱싱과 슬라이싱

2.1 인덱싱(Indexing)

배열에서 원소를 찾는 것

- 인덱스는 0부터 시작하여 1씩 증가
- 맨뒤 원소의 인덱스는 -1

인덱싱한 결과는 원소의 유형을 따른다

인덱싱(Indexing)

x_dict['name']

👉 결과 'Gildong Hong'

print(f'{x_str = } \t\t==> {x_str[0] = }') # 0은 첫원소의 인덱스
print(f'{x_str = } \t\t==> {x_str[3] = }')
print(f'{x_list = } \t==> {x_list[0] = }')
print(f'{x_tuple = } \t==> {x_tuple[-1] = }') # -1은 마지막 원소의 인덱스
print(f'{x_dict = } \t==> {x_dict["name"] = }') # dictionary는 key로 인덱싱

👉 결과 x_str = 'abcde' ==> x_str[0] = 'a' x_str = 'abcde' ==> x_str[3] = 'd' x_list = ['abcde', 'fghij'] ==> x_list[0] = 'abcde' x_tuple = ('abcde', 12345) ==> x_tuple[-1] = 12345 x_dict = {'name': 'Gildong Hong', 'id': 83100} ==> x_dict["name"] = 'Gildong Hong'

2.2 슬라이싱(Slicing)

배열에서 부분집합을 가져오는 것

- i:j -> 인덱스 i에서 (j-1)까지
- i: -> 인덱스 i에서 마지막까지
-  :j -> 인덱스 처음부터 (j-1)까지
-  : -> 인덱스 처음부터 끝까지

슬라이싱한 결과는 원래의 type과 동일함

슬라이싱(Slicing)

print(f'{x_str = } \t\t==> {x_str[2:] = }')
print(f'{x_list = } \t==> {x_list[0:1] = }')
print(f'{x_tuple = } \t==> {x_tuple[0:1] = }')

👉 결과 x_str = 'abcde' ==> x_str[2:] = 'cde' x_list = ['abcde', 'fghij'] ==> x_list[0:1] = ['abcde'] x_tuple = ('abcde', 12345) ==> x_tuple[0:1] = ('abcde',)

3 제어문

3.1 분기문(if-else)

조건의 만족 여부에 따라 코드의 실행 경로를 변경하는 문장

  - 조건은 True 또는 False로 구분되는 문장
  - 파이썬은 indent로 문단을 구분함

if (조건 1):
  (실행문 1)
elif (조건 2): # 생략 및 추가 기능
  (실행문 2)
else:          # 생략 가능
  (실행문 3)

if-else

money = 1000
if money <= 500:
  print('걸어간다.')
else:
  print('택시탄다.')

👉 결과
택시탄다.

if-elif-else

money = 1000
if money <= 500:
  print('걸어간다.')
elif money <= 2500:
  print('버스탄다.')
else:
  print('택시탄다.')

👉 결과 버스탄다.

3.2 반복문(while, for)

조건을 만족하는 동안 코드블럭을 반복수행하는 문장
파이썬은 indent로 문단을 구분함 (cf) C에서는 {}로 구분)

while문

조건변수 = 초기값
while (조건):
    조건변수 업데이트    (실행문)

n=0
while n < 5:
  n = n+1
  print("n=", n)

👉 결과
n= 1 n= 2 n= 3 n= 4 n= 5

for문

for 변수 in (유한한 변수의 값들):
    (실행문)

for n in range(0,6):
    print("n=", n)

👉 결과
n= 0 n= 1 n= 2 n= 3 n= 4 n= 5

for item in x_list:
  print(f'{item = }')

👉 결과
item = 'abcde' item = 'fghij'

x = [10,20,30,40,50]
for method in [len, max, sum]:
    print(f'{method(x) = }')

👉 결과
method(x) = 5 method(x) = 50 method(x) = 150

enumerate() 함수를 이용한 for문

for문에서 인덱스를 사용하고자 할 때 사용

for item in enumerate(['a','b','c','d','e']):
 print(f'{item = }')

👉 결과*
item = (0, 'a') item = (1, 'b') item = (2, 'c') item = (3, 'd') item = (4, 'e')

for i, item in enumerate(['a','b','c','d','e']):
    print(f'{i = }, {item = }')

👉 결과
i = 0, item = 'a' i = 1, item = 'b' i = 2, item = 'c' i = 3, item = 'd' i = 4, item = 'e'

3.3 함수

인수(arguments)를 입력으로 받아 실행문(코드블럭)을 실행하고 출력(return)하는 하나의 실행 모듈
return은 튜플로 반환됨
매개변수(parameter)는 함수에 입력으로 전달된 값을 받는 변수를 의미하고 인수(arguments)는 함수를 호출할 때 전달하는 입력 값을 의미함

def 함수명(매개변수):
    (실행문)
    return 변수

함수 정의

def minus(a,b): # a,b는 parameters
  result = a-b
  return result

함수의 활용

a = minus(3,7) # 3,7은 arguments
print(a)

👉 결과
-4

3.4 람다함수(익명함수)

일반함수를 가볍게 만들어 사용하기 위한 함수
람다함수 정의
람다 표현식(lambda expression) = 익명함수(anonymous function)

lambda 인자 : 표현식

lambda x : x+1

👉 결과
main.(x)>

함수명을 지정하여 재사용 가능함

add_ten = lambda x: x + 10

람다함수의 사용

print((lambda x: x+1)(10))
print(add_ten(10))

👉 결과*
11 20
람다 표현식 안에서는 새 변수를 만들 수 없으나 밖의 변수는 사용가능함
```
y = 100
(lambda x: x+y+1)(10)
```
👉 결과*
111

람다함수를 인자로 활용

map 함수에 적용

list(map(lambda x: x + 10, [1, 2, 3]))

👉 결과
[11, 12, 13]

람다 표현식에 조건부 표현식 사용

a = range(10)
list(map(lambda x: 'str'+str(x) if x % 3 == 0 else x, a))

👉 결과
['str0', 1, 2, 'str3', 4, 5, 'str6', 7, 8, 'str9']

람다 표현식에 복잡한 조건부 표현식 사용

a = range(10)
list(map(lambda x: 'str'+str(x) if x % 3 == 0 else float(x) if x % 3 == 1 else x, a))

👉 결과
['str0', 1.0, 2, 'str3', 4.0, 5, 'str6', 7.0, 8, 'str9']

람다 표현식에 인자 여러개 넣기

a = range(10)
b = [100]*10     # 브로드캐스팅은 안됨
list(map(lambda x, y: x if x % 3 == 0 else x + y, a, b))

👉 결과
[0, 101, 102, 3, 104, 105, 6, 107, 108, 9]

4 모듈과 패키지

4.1 모듈

함수나 변수 또는 클래스 들을 모아 놓은 파이썬 파일(.py)
다른 파이썬 프로그램에서 불러와(import) 사용할 수 있음

모듈 만들기(my_module.py)

my_var = 'my_var'
def my_func():
    return 'my_func'
def _my_private_func():
    return 'my_private_func'

모듈 불러오기

import my_module as mm

print(mm.my_var)
print(mm.my_func())
print(mm._my_private_func())

👉 결과
my_var my_func my_private_func

4.2 패키지

모듈과 패키지들의 구조화된 collection으로 선행 연구자가 만들어서 배포한 것

Numpy, Pandas, Matplotlib, Seaborn 등

import numpy
import matplotlib.pyplot as plt

print(numpy.sum([1,2,3,4,5])) plt.plot([10,20,30,40], [1,4,9,16], 'rs--', [10,20,30,40], [11,24,9,6], 'g^-') plt.show()

**👉 결과**  
![](https://velog.velcdn.com/images/__zeroiszero/post/78a75ec9-4651-4638-882d-f8c7ee2dbedd/image.png)


-----------------------------------------------
# 5 데이터 불러오기와 저장하기
-----------------------------------------------
## 5.1 Pandas를 이용한 csv 데이터 불러오기
### csv 데이터 불러와서 확인하기

``` python
import pandas as pd

df = pd.read_csv('bank.csv', sep = ',')
print(df.head(3)) # default=5
print(df.tail(2)) # default=5

👉 결과(모양 깨짐) age;"job";"marital";"education";"default";"balance";"housing";"loan";"contact";"day";"month";"duration";"campaign";"pdays";"previous";"poutcome";"y" 0 30;"unemployed";"married";"primary";"no";1787;...
1 33;"services";"married";"secondary";"no";4789;...
2 35;"management";"single";"tertiary";"no";1350;...
age;"job";"marital";"education";"default";"balance";"housing";"loan";"contact";"day";"month";"duration";"campaign";"pdays";"previous";"poutcome";"y" 4519 28;"blue-collar";"married";"secondary";"no";11...
4520 44;"entrepreneur";"single";"tertiary";"no";113...

csv 파일로 저장하기

df.to_csv('data/bank_new.csv', index=False)

5.2 raw string을 이용하여 출력하기

string 앞에 r을 표기
모든 escape 문자를 그대로 출력하기

string = "Hello!!!\tPython world.\n My name is Youngeun"
rstring = r"Hello!!!\tPython world.\n My name is Youngeun"

print(string)
print(rstring)

👉 결과
Hello!!! Python world. My name is Youngeun Hello!!!\tPython world.\n My name is Youngeun

5.3 f-string을 이용하여 출력하기

formatted string literals
파이썬 3.6부터 format, %(서식지정자)와 같은 문자열 포매팅 방법 대신에 f-string이 가능함

문자열 " 앞에 f를 붙이고, 문자열 내에 {}를 이용하여 값을 지정

names = ['홍익', '파이썬', '스트링']
num_ints = [10, 20, 30]
num_float = 4321.12345678

# 변수 지정
print(f'{names}의 나이는 {num_ints}이다.')
# 변수를 인덱싱, 슬라이싱하여 지정
print(f'{names[0]}의 나이는 {num_ints[:2]}이다.')
# {}내 연산 가능
print(f'{names[0]}의 나이는 {num_ints[0] + num_ints[1]}이다.')
# 변수로 사용
for name, age in zip(names, num_ints):
    print(f'{name}의 나이는 {age}이다.')

👉 결과
['홍익', '파이썬', '스트링']의 나이는 [10, 20, 30]이다. 홍익의 나이는 [10, 20]이다. 홍익의 나이는 30이다. 홍익의 나이는 10이다. 파이썬의 나이는 20이다. 스트링의 나이는 30이다.

5.3-1 글자수, 정렬, 소숫점 자리수

글자수를 지정하여 문자열을 정렬

f-string의 중괄호{} 안에서 : 구분자를 이용함
구분자 왼쪽은 문자나 숫자를, 오른쪽에는 정렬 기호와 숫자, 서식 지정자를 사용함
- 정렬기호 : 없음 -> 왼쪽, ^ -> 가운데, > -> 오른쪽
- 서식지정자 : 문자열 -> s, 정수 -> d, 실수 -> f
  소수점 자릿수 지정

: 구분자 오른편에. 자릿수 f를 사용함

# 자리수와 정렬 지정
print(f'{names[0]:10s}의 나이는 {num_ints[0]:>10d}이다.')
print(f'{names[1]:>10s}의 나이는 {num_ints[0]:^10d}이다.')

소숫점 자리수 지정

print(f'{names[2]:>10s}의 숫자는 {num_float:^10.2f}이다.')

``` 👉 결과
홍익 의 나이는 10이다. 파이썬의 나이는 10 이다. 스트링의 숫자는 4321.12 이다.